; Radio Shack MC-10 Disassembly ; (C) Copyright 1999 Kevin Timmerman ; Additional annotation by Greg D. ; Fixed and modified by James Tamer for use with TASM cross-assembler ; A few handy defines to make TASM more like typcial ; motorola syntax .MSFIRST ; Most Significant byte first ; .ADDINSTR inst args opcode nbytes rule class shift binor .ADDINSTR JSRE * BD 3 SWAP 1 shift binor #define EQU .EQU #define ORG .ORG #define RMB .BLOCK #define FCB .BYTE #define FCC .TEXT #define FDB .WORD #define equ .EQU #define org .ORG #define rmb .BLOCK #define fcb .BYTE #define fcc .TEXT #define fdb .WORD ; end a few handy defines ram00 equ $00 ;Port 1/2 Data Directon Register 1=Output 0=Input ram01 equ $01 ram02 equ $02 ;Port 1 Data Register ram03 equ $03 ;Port 2 Data Register ram08 equ $08 ;Timer control and status register ram09 equ $09 ;Counter (2 bytes) ram0B equ $0B ;Output Compare (2 bytes) ram80 equ $80 ;number build store MSB ram81 equ $81 ;number build store LSB ram82 equ $82 ;logic AND/OR function store ram83 equ $83 ram84 equ $84 ;vartype flag ram85 equ $85 ;data token flag ram86 equ $86 ram87 equ $87 ;READ cmd status flag ram88 equ $88 ram89 equ $89 ;address temp store ram8B equ $8B TBL008C equ $8C TBL008D equ $8D ; DIGIT 4 MSB ram8E equ $8E ; 3 ram8F equ $8F ; 2 ram90 equ $90 ; 1 LSB ram91 equ $91 ; stack pointer store ram93 equ $93 ; start of BASIC memory ram95 equ $95 ; start of variable space ram97 equ $97 ; start of dimensioned variable space ram99 equ $99 ; end of variables. ram9B equ $9B ; start of string space ram9D equ $9D ; next free string store ram9F equ $9F ; address build store ramA1 equ $A1 ; top of string storage ramA3 equ $A3 ramA5 equ $A5 ramA7 equ $A7 ; program break address MSB ramA8 equ $A8 ; program break address LSB ramA9 equ $A9 ramAB equ $AB ramAD equ $AD ; DATA pointer ramAF equ $AF ; LIST command end line no. ramB1 equ $B1 ramB2 equ $B2 ramB3 equ $B3 ramB5 equ $B5 ; FOR-NEXT var pointer ramB7 equ $B7 ramB9 equ $B9 TBL00BA equ $BA ; EXPONENT ramBB equ $BB ; DIGIT 4-3 ramBD equ $BD ; DIGIT 2-1 ramBF equ $BF ; SIGN ramC0 equ $C0 ramC1 equ $C1 ramC2 equ $C2 TBL00C4 equ $C4 ramC5 equ $C5 ramC7 equ $C7 ramC9 equ $C9 ; EXPONENT [FPA0] ramCA equ $CA ; DIGIT 4 MSB ramCB equ $CB ; DIGIT 3 ramCC equ $CC ; DIGIT 2 ramCD equ $CD ; DIGIT 1 LSB ramCE equ $CE ; SIGN ramCF equ $CF ramD0 equ $D0 ramD2 equ $D2 ramD5 equ $D5 ramD6 equ $D6 ; EXPONENT [FPA1] ramD7 equ $D7 ; DIGIT 4 MSB ramD8 equ $D8 ; DIGIT 3 ramD9 equ $D9 ; DIGIT 2 ramDA equ $DA ; DIGIT 1 LSB ramDB equ $DB ; SIGN ramDC equ $DC ; SIGN ramDD equ $DD ramDE equ $DE ; end of string address MSB ramDF equ $DF ; end of string address LSB ramE2 equ $E2 ; filename screen pointer ramE4 equ $E4 ; i/o tab field ramE5 equ $E5 ; i/o last tab field ramE6 equ $E6 ; max line length MSB ramE7 equ $E7 ; max line length LSB ramE8 equ $E8 ; I/O select 0=screen -1=printer ramE9 equ $E9 ramEA equ $EA ; warm start setup flag =$55 LBL00EB equ $EB ; bump interpreter pointer LBL00F3 equ $F3 ; A <- [address ptr] ramF4 equ $F4 ; address ptr MSB ramF5 equ $F5 ; address ptr LSB TBL4000 equ $4000 ; start of screen mem TBL41FD equ $41FD ; start clearing. FNC_USR equ $4215 ; USR command address ram4218 equ $4218 ; random number seed word 1 ram421A equ $421A ; random number seed word 2 ram421C equ $421C ; upcase flag ram421D equ $421D ; keyboard debounce delay $045E ram421F equ $421F ; default EXEC address $EC2E ram4221 equ $4221 ram4223 equ $4223 ; printer baud rate $0080 ram4225 equ $4225 ; cr. delay count $0001 ram4227 equ $4227 ; tab field width 16 ram4229 equ $4229 ; last tab zone 112 ram422A equ $422A ; printer line length max MSB 88 ram422B equ $422B ; printer line length max LSB 132 ram422C equ $422C ; cassette 1200/2400Hz partition 21 ($15) ram422D equ $422D ; upper limit of 1200 Hz ram422E equ $422E ; lower limit of 2400 Hz ram422F equ $422F ; number of 55's in leader MSB TBL4230 equ $4230 ; number of 55's in leader LSB 128; kyboard scan buff 4231-8. ram4239 equ $4239 ; keyboard strobe store ram423A equ $423A ; keyboard control key flag ram423B equ $423B ; keyboard break flag ram423C equ $423C ram423D equ $423D ; string buffer pointer ram423F equ $423F TBL4241 equ $4241 ; string buffer ram4250 equ $4250 ; end of memory pointer ram4252 equ $4252 ram4253 equ $4253 ram4254 equ $4254 ; random number store 1 ram4255 equ $4255 ; random number store 2 TBL4256 equ $4256 ; file name length TBL4257 equ $4257 ; SKIP/LOAD file name TBL425F equ $425F ; TAPE file name block ram4267 equ $4267 ; file type flag ram426A equ $426A ; EXEC address offset ram426C equ $426C ; LOAD address ram426E equ $426E ; NEW command status flag ram426F equ $426F ram4271 equ $4271 ram4273 equ $4273 ram4274 equ $4274 ram4275 equ $4275 ; cass block type flag ram4276 equ $4276 ; cass block length ram4278 equ $4278 ; cass buffer address ram427A equ $427A ; cass sumcheck ram427B equ $427B ; cass load status flag ram427C equ $427C ; cass byte load bit counter ram427D equ $427D ; tone duration counter ram427E equ $427E ; cass polarity flag ram427F equ $427F ; last keyboard input char ram4280 equ $4280 ; cursor address MSB ram4281 equ $4281 ; cursor address LSB ram4282 equ $4282 ; cursor color ram4283 equ $4283 ; break status flag ram4284 equ $4284 ; LIST command status flag LBL4285 equ $4285 ; input char command extension LBL4288 equ $4288 ; output char command extension LBL428B equ $428B ; output char command extension LBL428E equ $428E ; NEW command extension LBL4291 equ $4291 ; build command line extension LBL4294 equ $4294 ; maths command extension LBL4297 equ $4297 ; error return extension 1 LBL429A equ $429A ; error return extension 2 LBL429D equ $429D ; fp-acc number transfer extension LBL42A0 equ $42A0 ; RUN command extension LBL42A3 equ $42A3 ; command token lookup extension LBL42A6 equ $42A6 ; LIST command extension LBL42A9 equ $42A9 LBL42AC equ $42AC ram42AF equ $42AF ram42B0 equ $42B0 TBL42B1 equ $42B1 TBL42B2 equ $42B2 ; command line buffer TBL4333 equ $4333 TBL4334 equ $4334 TBL4335 equ $4335 ; binary-decimal conversion buffer TBL4346 equ $4346 ioBFFF equ $BFFF org $E000 ; --- Function vector table --- TBLE000 FDB FNC_SGN ; $F2BA SGN FDB FNC_INT ; $F335 INT FDB FNC_ABS ; $F2D5 ABS FDB FNC_USR ; $4215 USR FDB FNC_RND ; $F62A RND FDB FNC_SQR ; $F54D SQR FDB FNC_LOG ; $F0B9 LOG FDB FNC_EXP ; $F5C9 EXP FDB FNC_SIN ; $F68C SIN FDB FNC_COS ; $F686 COS FDB FNC_TAN ; $F6D2 TAN FDB FNC_PEEK ; $EF5F PEEK FDB FNC_LEN ; $EE82 LEN FDB FNC_STR ; $ECED STR$ FDB FNC_VAL ; $EF1C VAL FDB FNC_ASC ; $EEA2 ASC FDB FNC_CHR ; $EE8E CHR$ FDB FNC_LEFT ; $EEAD LEFT$ FDB FNC_RIGHT ; $EEC8 RIGHT$ FDB FNC_MID ; $EECF MID$ FDB FNC_POINT ; $FB9C POINT FDB FNC_VARPTR ; $FC11 VARPTR FDB FNC_INKEY ; $FBED INKEY$ FDB FNC_MEM ; $ECDB MEM TBLE030 FCB $79 FDB fp_ADD ; $EF80 + FCB $79 FDB fp_SUB ; $EF75 - FCB $7B FDB fp_MUL ; $F0F1 * FCB $7B FDB fp_DIV ; $F1C8 / FCB $7F FDB fp_POW ; $F556 ^ FCB $50 FDB fp_OR+1 ; $EA8E AND (fp_AND) FCB $46 FDB fp_OR ; $EA8D OR ;--- Tokens --- TBLE045 FCB $46,$4F,$D2 ;FOR 80 FCB $47,$4F,$54,$CF ;GOTO 81 FCB $47,$4F,$53,$55,$C2 ;GOSUB 82 FCB $52,$45,$CD ;REM 83 FCB $49,$C6 ;IF 84 FCB $44,$41,$54,$C1 ;DATA 85 FCB $50,$52,$49,$4E,$D4 ;PRINT 86 FCB $4F,$CE ;ON 87 FCB $49,$4E,$50,$55,$D4 ;INPUT 88 FCB $45,$4E,$C4 ;END 89 FCB $4E,$45,$58,$D4 ;NEXT 8A FCB $44,$49,$CD ;DIM 8B FCB $52,$45,$41,$C4 ;READ 8C FCB $4C,$45,$D4 ;LET 8D FCB $52,$55,$CE ;RUN 8E FCB $52,$45,$53,$54,$4F,$52,$C5 ;RESTORE 8F FCB $52,$45,$54,$55,$52,$CE ;RETURN 90 FCB $53,$54,$4F,$D0 ;STOP 91 FCB $50,$4F,$4B,$C5 ;POKE 92 FCB $43,$4F,$4E,$D4 ;CONT 93 FCB $4C,$49,$53,$D4 ;LIST 94 FCB $43,$4C,$45,$41,$D2 ;CLEAR 95 FCB $4E,$45,$D7 ;NEW 96 FCB $43,$4C,$4F,$41,$C4 ;CLOAD 97 FCB $43,$53,$41,$56,$C5 ;CSAVE 98 FCB $4C,$4C,$49,$53,$D4 ;LLIST 99 FCB $4C,$50,$52,$49,$4E,$D4 ;LPRINT 9A FCB $53,$45,$D4 ;SET 9B FCB $52,$45,$53,$45,$D4 ;RESET 9C FCB $43,$4C,$D3 ;CLS 9D FCB $53,$4F,$55,$4E,$C4 ;SOUND 9E FCB $45,$58,$45,$C3 ;EXEC 9F FCB $53,$4B,$49,$50,$C6 ;SKIPF A0 FCB $54,$41,$42,$A8 ;TAB( A1 FCB $54,$CF ;TO A2 FCB $54,$48,$45,$CE ;THEN A3 FCB $4E,$4F,$D4 ;NOT A4 FCB $53,$54,$45,$D0 ;STEP A5 FCB $4F,$46,$C6 ;OFF A6 FCB $AB ;+ A7 FCB $AD ;- A8 FCB $AA ;* A9 FCB $AF ;/ AA FCB $DE ;^ AB FCB $41,$4E,$C4 ;AND AC FCB $4F,$D2 ;OR AD FCB $BE ;> AE FCB $BD ;= AF FCB $BC ;< B0 FCB $53,$47,$CE ;SGN B1 FCB $49,$4E,$D4 ;INT B2 FCB $41,$42,$D3 ;ABS B3 FCB $55,$53,$D2 ;USR B4 FCB $52,$4E,$C4 ;RND B5 FCB $53,$51,$D2 ;SQR B6 FCB $4C,$4F,$C7 ;LOG B7 FCB $45,$58,$D0 ;EXP B8 FCB $53,$49,$CE ;SIN B9 FCB $43,$4F,$D3 ;COS BA FCB $54,$41,$CE ;TAN BB FCB $50,$45,$45,$CB ;PEEK BC FCB $4C,$45,$CE ;LEN BD FCB $53,$54,$52,$A4 ;STR$ BE FCB $56,$41,$CC ;VAL BF FCB $41,$53,$C3 ;ASC C0 FCB $43,$48,$52,$A4 ;CHR$ C1 FCB $4C,$45,$46,$54,$A4 ;LEFT$ C2 FCB $52,$49,$47,$48,$54,$A4 ;RIGHT$ C3 FCB $4D,$49,$44,$A4 ;MID$ C4 FCB $50,$4F,$49,$4E,$D4 ;POINT C5 FCB $56,$41,$52,$50,$54,$D2 ;VARPTR C6 FCB $49,$4E,$4B,$45,$59,$A4 ;INKEY$ C7 FCB $4D,$45,$CD ;MEM C8 FCB $00 ; --- Command vector table --- TBLE148 FDB CMD_FOR ; $E4C4 FOR FDB CMD_GOTO ; $E61A GOTO FDB CMD_GOSUB ; $E604 GOSUB FDB CMD_REM ; $E685 REM FDB CMD_IF ; $E672 IF FDB CMD_DATA ; $E651 DATA FDB CMD_PRINT ; $E71F PRINT FDB CMD_ON ; $E692 ON FDB CMD_INPUT ; $E7DE INPUT FDB CMD_END ; $E57F END FDB CMD_NEXT ; $E8BB NEXT FDB CMD_DIM ; $EB12 DIM FDB CMD_READ ; $E80E READ FDB CMD_LET ; $E6D3 LET FDB CMD_RUN ; $E5FA RUN FDB CMD_RESTORE ; $E560 RESTORE FDB CMD_RETURN ; $E631 RETURN FDB CMD_STOP ; $E57E STOP FDB CMD_POKE ; $EF66 POKE FDB CMD_CONT ; $E5A6 CONT FDB CMD_LIST ; $E40D LIST FDB CMD_CLEAR ; $E5B8 CLEAR FDB CMD_NEW ; $E3CD NEW FDB CMD_CLOAD ; $FD5C CLOAD FDB CMD_CSAVE ; $FC3B CSAVE FDB CMD_LLIST ; $E40B LLIST FDB CMD_LPRINT ; $E71C LPRINT FDB CMD_SET ; $FB25 SET FDB CMD_RESET ; $FB55 RESET FDB CMD_CLS ; $FBBF CLS FDB CMD_SOUND ; $FFA5 SOUND FDB CMD_EXEC ; $FC04 EXEC FDB CMD_SKIPF ; $FE2F SKIPF ; --- Errors --- TBLE18A FCB $4E,$46 ;$00 NF NEXT without FOR FCB $53,$4E ;$02 SN Syntax Error FCB $52,$47 ;$04 RG RETURN without GOSUB FCB $4F,$44 ;$06 OD Out of Data FCB $46,$43 ;$08 FC Illegal Function Call FCB $4F,$56 ;$0A OV Overflow FCB $4F,$4D ;$0C OM Out of Memory FCB $55,$4C ;$0E UL Undefined Line FCB $42,$53 ;$20 BS Bad Subscript FCB $44,$44 ;$22 DD Double Dimensioned Array FCB $2F,$30 ;$24 /0 Division by 0 FCB $49,$44 ;$26 ID Illegal Direct Statement FCB $54,$4D ;$28 TM Type Mismatch FCB $4F,$53 ;$2A OS Out of String Space FCB $4C,$53 ;$2C LS Long String (exceeds 255 characters) FCB $53,$54 ;$2E ST String Formula Too Complex ? ""+(""+(""+"")) FCB $43,$4E ;$30 CN Can't Continue FCB $49,$4F ;$32 IO Input/Output Error FCB $46,$4D ;$34 FM File Mode Error TBLE1B0 FCB $20,$45,$52,$52,$4F,$52,$00 ; ERROR TBLE1B7 FCB $20,$49,$4E,$20,$00 ; IN TBLE1BC FCB $0D,$4F,$4B,$0D,$00 ; OK TBLE1C1 FCB $0D,$42,$52,$45,$41,$4B,$00 ; BREAK LBLE1C8 CMPA #$3A ;Leave if non-numeric. Z=':' or NULL BHS LBLE1D7 ; C=Numeric CMPA #$20 ;skip whitespace BNE LBLE1D3 JMP LBL00EB LBLE1D3 SUBA #$30 SUBA #$D0 ;Set Carry if numeric. LBLE1D7 RTS LBLE1D8 TSX LDAB #$04 ABX LBLE1DC LDAB #$12 STX ram89 LDAA ,X ; SP+0==return addr. SP+2==?. SP+4->A SUBA #$80 BNE LBLE1FA LDX 1,X STX ram8B LDX ramB5 BEQ LBLE1F6 CPX ram8B BEQ LBLE1FA BSR LBLE22F BRA LBLE1DC LBLE1F6 LDX ram8B STX ramB5 LBLE1FA LDX ram89 TSTA RTS ; -- copy [C1:BD]->[bf:BB] LBLE1FE BSR LBLE21E; see if D bytes fit on stack LBLE200 TPA PSHA STS ram91 SEI LDS ramBB ; store in [BB] LDX ramBD ; start at [BD] INX LBLE20A DEX LDAA ,X PSHA CPX ramC1 ; stop at [C1] BNE LBLE20A INS STS ramBF ; store end in [BF] LDS ram91 PULA TAP RTS LBLE21A CLRA ; return with 2*B+#$3A+ram99 ASLB ; ADDD ram99 ; check if 2*B+3A+ram99>0xffff LBLE21E ADDD #$003A BLO LBLE236; ?OM error STS ram91 SUBD ram91 BHS LBLE236; ?OM if greater than stack ADDD ram91 RTS LBLE22C CLRA ; B+X->D,X LBLE22D STX ram89 ; D+X->D,X (save old X in 89. New X,D in 8B) LBLE22F ADDD ram89 ; D+ram89->D,X. STD ram8B LDX ram8B RTS LBLE236 LDAB #$0C ;?OM error LBLE238 JSR LBL4297 ;error return extension 1 JSR LBL429A ;error return extension 2 JSR LBLFC86 LDAA ram426E BEQ LBLE249 JSR LBLE3CF LBLE249 JSR LBLE3EE CLR ramE8 ;turn off printer JSR LBLE76A JSR LBLE7BB+1 LDX #TBLE18A ;Error table ABX LDAA ,X JSR LBLE7BE ;A->SCN LDAA 1,X JSR LBLE7BE ;A->SCN LDX #TBLE1B0-1 ;"ERROR" LBLE266 JSR LBLE7A8 ;Write string LDX ramE2 INX BEQ LBLE271 JSR LBLF412 ;' IN ' line LBLE271 JSR LBLE76A LDX #TBLE1BC ;"OK" JSR LBLE7A8 ;Write string LBLE27A LDX #$FFFF STX ramE2 JSR LBLFAA4 ;Get Command Line BLO LBLE27A ;Try again if carry set (BREAK) STX ramF4 JSRE LBL00EB BEQ LBLE27A ;Try again if blank line BLO LBLE293 JSR LBLE311 ;immediate mode - compile line. JMP LBLE53D LBLE293 JSR LBLE6B2 ;get line number->ramA5 LDX ramA5 STX ram42B0 ;store line number JSR LBLE311 ;compile line STAB ram82 ;length of line JSR LBLE3B9 ;find first line greater than line number BLO LBLE2C1 ; none found, insert at end. LDD ramC1 SUBD ,X ADDD ram95 STD ram95 TPA PSHA STS ram91 SEI LDS ,X DES LBLE2B5 PULA STAA ,X INX CPX ram95 BNE LBLE2B5 LDS ram91 PULA TAP LBLE2C1 LDAA TBL42B2 BEQ LBLE2EB LDD ram95 STD ramBD ADDB ram82 ADCA #$00 STD ramBB JSR LBLE1FE ;copy [C1:BD]->[bf:BB] TPA PSHA STS ram91 SEI LDS #$42AD LBLE2DB PULA STAA ,X INX CPX ramBF BNE LBLE2DB LDS ram91 PULA TAP LDX ramBB STX ram95 LBLE2EB JSR LBLE3D9 ;reset variables BSR LBLE2F3 ;adjust next statement pointers JMP LBLE27A ;get command line ; adjust next statement pointers LBLE2F3 LDX ram93 ;start of basic LBLE2F5 LDD ,X ;return if last statement. BNE LBLE2FA RTS LBLE2FA PSHX ;push address of statement LDAB #$04 ABX LBLE2FE INX LDAA ,X BNE LBLE2FE INX PSHX ;push address of next statement TSX LDD ,X ;addr of next statement -> D LDX 2,X ;addr of prev statement -> X STD ,X ;update addr of prev statment to point to next statement. PULX INS INS BRA LBLE2F5 LBLE311 CLR ram85 ;clear DATA token flag LDX ramF4 ;reset pointer back to start of line. DEX STX ramF4 LDX #TBL42B1 ;start of command line buffer-1 STX ramDE STS ram91 TPA ; save interrupt flag STAA ram87 LBLE323 NOP SEI ; disable interrupts LDS ramF4 PULB CMPB #$20 ; ' ' BEQ LBLE364 STAB ram81 CMPB #$22 ; '"' BEQ LBLE38D LDAA ram85 BNE LBLE364 CMPB #$3F ; '?' BNE LBLE33E LDAB #$86 ; 'PRINT' code BRA LBLE364 LBLE33E CMPB #$30 ; '0' BLO LBLE346 CMPB #$3C ; '<' BLO LBLE364 LBLE346 TSTB ; use ! for non-printing input chars BMI LBLE361+1 LDX #TBLE045-1 ; start matching tokens LDS ramF4 CLRB LBLE34F INX LBLE350 PULA CMPA #$20 ; skip whitespace when matching tokens BEQ LBLE350 SUBA ,X BEQ LBLE34F CMPA #$80 BNE LBLE392 ORAB #$80 ; found match, store token. LBLE35F LDX ramDE LBLE361 CPX #$C621 ;LDAB #$21 '!' LBLE364 STS ramF4 LDS ram91 LDAA ram87 ; restore interrupt TAP INX STX ramDE STAB ,X BEQ LBLE3AA SUBB #$3A ; ':' BEQ LBLE37A CMPB #$4B ; 'DATA' encountered BNE LBLE37C LBLE37A STAB ram85 ; set DATA token flag LBLE37C SUBB #$49 ; 'REM' BNE LBLE323 ; get next char. STAB ram81 ; 'REM' found, clear ram81 SEI LDS ramF4 LBLE385 PULB ; copy until 0 or ram81 encountered. TSTB BEQ LBLE364 CMPB ram81 BEQ LBLE364 LBLE38D INX STAB ,X BRA LBLE385 LBLE392 LDS ramF4 ; token failed match INCB ; inc token count LBLE395 LDAA ,X ; INX BPL LBLE395 LDAA ,X BNE LBLE350 STS ramF4 ; no tokens matched. LDS ram91 JSR LBL42A3 LDS ramF4 PULB BRA LBLE35F LBLE3AA STAB 1,X ; clear next two bytes STAB 2,X LDD ramDE SUBD #$42AD ; length of buff in D. LDX #TBL42B1 STX ramF4 RTS LBLE3B9 LDX ram93 LBLE3BB LDD ,X BEQ LBLE3C9 LDD ramA5 SUBD 2,X BLS LBLE3CA LDX ,X BRA LBLE3BB LBLE3C9 SEC LBLE3CA STX ramC1 RTS ; --- NEW command --- CMD_NEW BNE LBLE3CA ; cause syntax error LBLE3CF LDX ram93 ; start of BASIC CLR ,X ; clear line INX CLR ,X INX STX ram95 ; end of BASIC LBLE3D9 LDX ram93 ; transfer control to program DEX STX ramF4 ; read pointer LBLE3DE JSR LBL428E ; NEW command extension LDX ramA1 ; top of string storage STX ram9D ; avail string storage. JSR CMD_RESTORE LDX ram95 ; end of BASIC STX ram97 ; DATA pointer STX ram99 ; LBLE3EE LDX #TBL4241 ; string buff. STX ram423D ; string ptr. PULX LDS ram9B ; bottom of system stack CLRA PSHA STAA ramA7 ; program BREAK address STAA ramA8 ; program BREAK address STAA ram86 ; ? STAA ram426E ; NEW command status flag JMP ,X ; RTS LBLE404 LDAB #$FE ; select printer STAB ramE8 ; turn on printer LBLE408 JMP LBL00F3 ; --- LLIST command --- CMD_LLIST BSR LBLE404 ; --- LIST command --- CMD_LIST TPA PSHA BSR LBLE408 ; Get char JSR LBLE6B2 ; Get line number BSR LBLE3B9 ; Find line number in program PULA TAP PSHX BEQ LBLE431 JSRE LBL00F3 BEQ LBLE436 CMPA #$A8 ; '-' BNE LBLE42E JSRE LBL00EB BEQ LBLE431 JSR LBLE6B2 BEQ LBLE436 LBLE42E JMP LBLEA3C ;?SN ERROR LBLE431 LDX #$FFFF STX ramA5 LBLE436 PULX INS INS LBLE439 JSR LBLE76A JSR LBLE566 LDD ,X BNE LBLE449 LBLE443 CLR ramE8 ; set output to printer JMP LBLE271 LBLE449 LDD 2,X SUBD ramA5 BHI LBLE443 LDD 2,X PSHX JSR LBLF419 PULX INX INX INX INX STX ram89 CLR ram4284 LDAA #$20 LBLE461 CPX #$8621 ;LDAA #$21 LBLE464 LDX ram89 ANDA #$7F LBLE468 JSR LBLE7BE ;A->SCN LDAA ,X INX TSTA BEQ LBLE439 LDAB ram4284 CMPA #$22 ; '"' BNE LBLE47D EORB #$01 STAB ram4284 LBLE47D CMPA #$3A ; ':' BNE LBLE48A BITB #$01 BNE LBLE48A ANDB #$FD STAB ram4284 LBLE48A TSTA BPL LBLE468 TSTB BNE LBLE468 CMPA #$85 ; 'DATA' BNE LBLE496 ORAB #$02 LBLE496 CMPA #$83 ; 'REM' BNE LBLE49C ORAB #$04 LBLE49C STAB ram4284 JSR LBL42A6 CMPA #$C8 ; 'MEM' BHI LBLE461+1 ; write ! for unknown print BSR LBLE4B2 LBLE4A8 LDAA ,X ; write token BMI LBLE464 INX JSR LBLE7BE;A->SCN BRA LBLE4A8 LBLE4B2 SUBA #$7F ;Find address of matching token->X STX ram89 ;save X into ram89 LDX #TBLE045 LBLE4B9 DECA BNE LBLE4BD RTS LBLE4BD TST ,X INX BPL LBLE4BD BRA LBLE4B9 ; --- FOR Command --- CMD_FOR LDAA #$80 STAA ram86 JSR CMD_LET JSR LBLE1D8 PULX BNE LBLE4D5 LDX ram89 ABX TXS LBLE4D5 LDAB #$09 JSR LBLE21A ; Verify 9 words will fit on stack JSR LBLE656 ; ignore rest of line until ':' seen PSHX LDX ramE2 PSHX LDAB #$A2 ;'TO' index JSR LBLEA31 JSR LBLE90E ; expect numeric JSR LBLE90C ; Get numeric value LDAB ramCE ORAB #$7F ANDB ramCA STAB ramCA LDX #LBLE4FA ; push C9-CA onto stack JMP LBLE9A4 LBLE4FA LDX #TBLF08B ; 1.0 JSR LBLF251 ;X->C9-E JSRE LBL00F3 CMPA #$A5 ;'STEP' index BNE LBLE50D JSRE LBL00EB JSR LBLE90C ; Get numeric value LBLE50D JSR LBLF2AD ;Sign C9-E -> B -1 0 1 JSR LBLE9A2 LDX ramB5 PSHX LDAA #$80 PSHA LBLE519 BSR LBLE566 ; check for BREAK or PAUSE LDX ramF4 STX ramA9 LDAA ,X BEQ LBLE52A CMPA #$3A ; ':' BEQ LBLE53D LBLE527 JMP LBLEA3C ; ?SN ERROR LBLE52A INX ; check for next line LDAA ,X INX ORAA ,X STAA ram4283 ; 0 if at last line number BEQ LBLE589 ; Implicit END if no next line. INX LDD ,X STD ramE2 ; Otherwise store current line in E2. INX STX ramF4 LBLE53D JSRE LBL00EB ; get token BSR LBLE544 BRA LBLE519 ; continue executing line LBLE544 BEQ LBLE5B7 ; RTS if 0 encountered. LBLE546 JSR LBL42A0 ; Run command extension TSTA BMI LBLE54F ; Command encountered. JMP CMD_LET ; otherwise, this must be an assignment. LBLE54F CMPA #$A0 ; SKIPF is the last valid command. BHI LBLE527 ; ?SN ERROR ASLA ; lookup command. TAB LDX #TBLE148 ABX LDX ,X JSRE LBL00EB ; prefetch next character. JMP ,X ; GO! [to command] ; --- RESTORE command --- CMD_RESTORE LDX ram93 DEX LBLE563 STX ramAD ;DATA pointer RTS LBLE566 JSR LBLF879 BEQ LBLE576 LBLE56B CMPA #$03 ; 'break pressed? BEQ CMD_STOP CMPA #$13 ; 'shift+@ pressed (pause) BEQ LBLE577 ; wait for next key. STAA ram427F LBLE576 RTS LBLE577 JSR LBLF883 BEQ LBLE577 BRA LBLE56B ; --- STOP command --- CMD_STOP SEC ; --- END command --- CMD_END BNE LBLE5B7 LDX ramF4 STX ramA9 LBLE585 ROR ram4283 ; break status flag PULX LBLE589 LDX ramE2 INX BEQ LBLE595 DEX STX ramA3 LDX ramA9 STX ramA7 LBLE595 CLR ramE8 ; turn off printing LDX #TBLE1C1-1 ; 'BREAK' TST ram4283 BPL LBLE5A3 JMP LBLE266 ; in program LBLE5A3 JMP LBLE271 ; not in program ; --- CONT command --- CMD_CONT BNE LBLE5B7 LDAB #$20 ;?CN error LDX ramA7 BNE LBLE5B1 JMP LBLE238 ;write ?CN error LBLE5B1 STX ramF4 LDX ramA3 STX ramE2 LBLE5B7 RTS ; --- CLEAR command --- CMD_CLEAR BEQ LBLE5F4 JSR LBLEBBD PSHB PSHA LDX ramA1 ; top of string storage STX ramCC JSRE LBL00F3 BEQ LBLE5DA JSR LBLEA2E+1 ; get ',' JSR LBLEF4C LDX ramCC DEX STX ramCC LDD ram4250 ; end of memory pointer SUBD ramCC BLO LBLE5F7 ; ?OM error LBLE5DA LDD ramCC PSHB PSHA TSX SUBD 2,X BLO LBLE5F7 ; ?OM error STD 2,X SUBD #$003A BLO LBLE5F7 ; ?OM error SUBD ram95 BLO LBLE5F7 ; ?OM error PULX STX ramA1 ; top of string storage PULX STX ram9B ; bottom of system stack LBLE5F4 JMP LBLE3DE ; reset variables LBLE5F7 JMP LBLE236 ; ?OM ERROR ; --- RUN command --- CMD_RUN BNE LBLE5FF JMP LBLE3D9 ; transfer control to program / reset variables LBLE5FF JSR LBLE3DE ; reset data variables BRA LBLE612 ; --- GOSUB command --- CMD_GOSUB LDAB #$03 JSR LBLE21A ; verify 3 words on stack LDX ramF4 PSHX LDX ramE2 PSHX LDAA #$82 PSHA LBLE612 JSRE LBL00F3 BSR CMD_GOTO JMP LBLE519 ; Continue executing line ; --- GOTO command --- CMD_GOTO JSR LBLE6B2 BSR LBLE658+1 INX LDD ramA5 SUBD ramE2 BHI LBLE628 LDX ram93 LBLE628 JSR LBLE3BB BLO LBLE641+1 ;?UL error DEX STX ramF4 LBLE630 RTS ; --- RETURN command --- CMD_RETURN BNE LBLE630 ; will ultimately result in ?SN error LDAA #$FF STAA ramB5 JSR LBLE1D8 TXS CMPA #$02 BEQ LBLE64A LDAB #$04 ;?RG error LBLE641 CPX #$C60E ;LDAB #$0E ?UL error JMP LBLE238 ;Write error LBLE647 JMP LBLEA3C ;?SN error LBLE64A PULA PULX STX ramE2 PULX STX ramF4 ; --- DATA command --- CMD_DATA BSR LBLE656 ; ignore rest of line until ':' or 0 reached. STX ramF4 LBLE655 RTS LBLE656 LDAB #$3A ; ignore rest of line until ':' or 0 reached. LBLE658 LDAA #$5F ;CLRB; ignore rest of line STAB ram80 CLRB LDX ramF4 LBLE65F TBA LDAB ram80 STAA ram80 LBLE664 LDAA ,X BEQ LBLE655 CBA BEQ LBLE655 INX CMPA #$22 ; '"' BEQ LBLE65F BRA LBLE664 ; --- IF command --- CMD_IF JSR LBLE90C ; Get numeric value JSRE LBL00F3 CMPA #$81 ; GOTO BEQ LBLE681 LDAB #$A3 ; THEN JSR LBLEA31 LBLE681 LDAA ramC9 BNE LBLE68A ; --- REM command --- CMD_REM BSR LBLE658+1 STX ramF4 RTS LBLE68A JSRE LBL00F3 BLO CMD_GOTO JMP LBLE544 ; --- ON command ---- CMD_ON JSR LBLEF0D ; Arg->ramCD PSHA CMPA #$82 ; GOSUB BEQ LBLE69E CMPA #$81 ; GOTO LBLE69C BNE LBLE647 ; ?SN ERROR LBLE69E DEC ramCD BNE LBLE6A7 PULA JMP LBLE546 LBLE6A7 JSRE LBL00EB BSR LBLE6B2 ; get line number->A5 CMPA #$2C ; ',' BEQ LBLE69E INS LBLE6B1 RTS ; bug -- "0 ON 2 GOTO 4,#,4,4#" hangs the MC-10 on RUN. LBLE6B2 LDX #$0000 ; get line number->ramA5 STX ramA5 LBLE6B7 BHS LBLE6B1 SUBA #$30 STAA ram80 LDD ramA5 ; Get line number CMPA #$18 ; err if > 6399 BHI LBLE69C ; ?SN ERROR ASLD ; ramA5 = 10*ramA5 + ram80 ASLD ADDD ramA5 ASLD ADDB ram80 ADCA #$00 STD ramA5 JSRE LBL00EB BRA LBLE6B7 ; --- LET command --- CMD_LET JSR LBLEB1B STX ramB5 LDAB #$AF JSR LBLEA31 LDAA ram84 ; vartype flag PSHA JSR LBLE91A PULA RORA JSR LBLE910 ;check for ?TM and get next number BEQ LBLE719 LBLE6EA LDX ramCC LDD ram9B ; bottom of system stack SUBD 2,X BHS LBLE705 LDD ram95 SUBD ramCC BHI LBLE705 LDAB ,X JSR LBLECFC LDX ramC7 JSR LBLEE38 LDX #ramD0 LBLE705 STX ramC7 JSR LBLEE70 LDX ramC7 LDAA ,X PSHA LDD 2,X LDX ramB5 STD 2,X PULA STAA ,X RTS LBLE719 JMP LBLF26F+1 ; --- LPRINT command --- CMD_LPRINT JSR LBLE404 ; --- PRINT command --- CMD_PRINT BSR LBLE725 CLR ramE8 ; turn off printing RTS LBLE725 BEQ LBLE766 CMPA #$40 ; '@' BNE LBLE736 JSR LBLFC29 JSRE LBL00F3 BEQ LBLE766 JSR LBLEA2E+1 ; get ',' LBLE736 BEQ LBLE773 LBLE738 CMPA #$A1 BEQ LBLE78C CMPA #$2C BEQ LBLE774 CMPA #$3B BEQ LBLE7A2 JSR LBLE91A LDAA ram84 ; vartype flag PSHA BNE LBLE752 JSR LBLF426 JSR LBLED05 LBLE752 BSR LBLE7AB PULB TSTB BNE LBLE761 JSRE LBL00F3 CMPA #$2C BEQ LBLE774 BSR LBLE7B9 LBLE761 JSRE LBL00F3 BNE LBLE738 LBLE766 LDAA #$0D BRA LBLE7BE ;A->SCN LBLE76A JSR LBLFA7B BEQ LBLE766 LDAA ramE6 BNE LBLE766 LBLE773 RTS LBLE774 JSR LBLFA7B BEQ LBLE783 LDAB ramE6 CMPB ramE5 BLO LBLE785 BSR LBLE766 BRA LBLE7A2 LBLE783 LDAB ramE6 LBLE785 SUBB ramE4 BHS LBLE785 NEGB BRA LBLE79D LBLE78C JSR LBLEF0A CMPA #$29 BEQ LBLE796 JMP LBLEA3C ;?SN ERROR LBLE796 JSR LBLFA7B SUBB ramE6 BLS LBLE7A2 LBLE79D BSR LBLE7B9 DECB BNE LBLE79D LBLE7A2 JSRE LBL00EB JMP LBLE736 ; --- Write string to screen --- LBLE7A8 JSR LBLED06 ;Calc string length LBLE7AB JSR LBLEE56 ;Get length to B, start address to X INCB LBLE7AF DECB ;Dec char count BEQ LBLE773 ;RTS LDAA ,X ;Get char INX ;Inc char ptr BSR LBLE7BE ;A->SCN Write char BRA LBLE7AF ;Next char LBLE7B9 LDAA #$20 LBLE7BB CPX #$863F ;LDAA #$3F LBLE7BE JMP LBLF9C6 ;A->SCN TBLE7C1 FCB $3F,$52,$45,$44,$4F,$0D,$00 ;?REDO LBLE7C8 LDAA ram87 BEQ LBLE7D3 LDX ramAB STX ramE2 JMP LBLEA3C ;?SN ERROR LBLE7D3 LDX #TBLE7C1-1 JSR LBLE7A8 LDX ramA9 STX ramF4 LBLE7DD RTS ; --- INPUT command --- CMD_INPUT LDAB #$16 ;?ID error LDX ramE2 INX BNE LBLE7E8 JMP LBLE238 ;write ?ID error LBLE7E8 CMPA #$22 ;check for "Prompt"; BNE LBLE7F7 JSR LBLEA07 ; scan string until '"' reached. LDAB #$3B JSR LBLEA31 ;expect and skip ';' JSR LBLE7AB ;write string to screen. LBLE7F7 BSR LBLE7FF ;"? " and get command line LDAB #$2C STAB ,X BRA LBLE810+1 LBLE7FF JSR LBLE7BB+1 ; "?"->SCN JSR LBLE7B9 ; " "->SCN JSR LBLFAA4 ; get command line BHS LBLE7DD PULX JMP LBLE585 ;break pressed - abort prog ; --- READ command --- CMD_READ LDX ramAD ;DATA pointer LBLE810 LDAA #$4F ;CLRA [used during INPUT command] STAA ram87 STX ramAF LBLE816 JSR LBLEB1B ; Get Var STX ramB5 LDX ramF4 STX ramA5 LDX ramAF LDAA ,X BNE LBLE82E LDAA ram87 BNE LBLE877 JSR LBLE7BB+1 BSR LBLE7FF LBLE82E STX ramF4 JSRE LBL00EB LDAB ram84 ;vartype flag BEQ LBLE853 LDX ramF4 STAA ram80 CMPA #$22 BEQ LBLE846 DEX LDAA #$3A STAA ram80 LDAA #$2C LBLE846 STAA ram81 JSR LBLED0C JSR LBLEF3E JSR LBLE6EA BRA LBLE859 LBLE853 JSR LBLF359 JSR LBLF26F+1 LBLE859 JSRE LBL00F3 BEQ LBLE865 CMPA #$2C BEQ LBLE865 JMP LBLE7C8 LBLE865 LDX ramF4 STX ramAF LDX ramA5 STX ramF4 JSRE LBL00F3 BEQ LBLE897 JSR LBLEA2E+1 ; get ',' BRA LBLE816 LBLE877 STX ramF4 JSR LBLE656 ; ignore rest of line thru ':' INX TSTA BNE LBLE88F LDAB #$06 LDAA ,X ORAA 1,X BEQ LBLE8CE LDD 2,X STD ramAB LDAB #$04 ABX LBLE88F LDAA ,X CMPA #$85 BNE LBLE877 BRA LBLE82E LBLE897 LDX ramAF LDAB ram87 BEQ LBLE8A0 JMP LBLE563 LBLE8A0 LDAA ,X BEQ LBLE8AA LDX #LBLE8AB-1 JMP LBLE7A8 LBLE8AA RTS LBLE8AB FCB $3F,$45,$58,$54,$52,$41,$20,$49,$47,$4E,$4F,$52,$45,$44,$0D,$00 ;?EXTRA IGNORED ; --- NEXT command --- CMD_NEXT BNE LBLE8C2 LDX #$0000 BRA LBLE8C5 LBLE8C2 JSR LBLEB1B ;Get Var LBLE8C5 STX ramB5 JSR LBLE1D8 BEQ LBLE8D0 LDAB #$00 ;?NF error LBLE8CE BRA LBLE917 ;write error LBLE8D0 TXS INX INX INX JSR LBLF251 ;X->C9-E TSX LDAA $08,X STAA ramCE LDX ramB5 JSR LBLEF7D JSR LBLF26F+1 TSX LDAB #$09 ABX JSR LBLF2D9 TSX SUBB $08,X BEQ LBLE8FC LDX $0E,X STX ramE2 TSX LDX $10,X STX ramF4 LBLE8F9 JMP LBLE519 ; continue executing line LBLE8FC LDAB #$12 ABX TXS JSRE LBL00F3 CMPA #$2C ; ',' BNE LBLE8F9 ; continue executing line JSRE LBL00EB BSR LBLE8C2 LBLE90C BSR LBLE91A LBLE90E TST $0D,X ;SEC E-expect numeric? F-expect string? LBLE910 ROR ram84 ;vartype flag BVC LBLE8AA ;RTS LDAB #$18 ;?TM error LBLE917 JMP LBLE238 LBLE91A LDX ramF4 DEX STX ramF4 CLRA LBLE920 LDAB #$37 ;PSHB PSHA LDAB #$01 JSR LBLE21A ; see if 1 word fits on stack JSR LBLE9E5 CLR ramB9 LBLE92E JSRE LBL00F3 LBLE931 SUBA #$AE ; '>' ; + - * / ^ AND OR > = < BLO LBLE949 CMPA #$03 ; SGN BHS LBLE949 CMPA #$01 ROLA EORA ramB9 CMPA ramB9 BLO LBLE99B STAA ramB9 JSRE LBL00EB BRA LBLE931 LBLE949 LDAB ramB9 BNE LBLE978 BHS LBLE9B5 ADDA #$07 ; + - * / ^ AND OR > = < BHS LBLE9B5 ADCA ram84 ; vartype flag BNE LBLE95A JMP LBLEE06 LBLE95A ADCA #$FF TAB ; B = A*3 ASLA ABA TAB LDX #TBLE030 ABX LBLE964 PULA CMPA ,X BHS LBLE9BC BSR LBLE90E ;expect numeric LBLE96B PSHA BSR LBLE991 LDX ramB7 PULA BNE LBLE98B TSTA BEQ LBLE9E2 BRA LBLE9C5 LBLE978 ASL ram84 ROLB LDX ramF4 DEX STX ramF4 LDX #TBLE988 STAB ramB9 BRA LBLE964 TBLE988 FCB $64,$EA,$AE LBLE98B CMPA ,X BHS LBLE9C5 BRA LBLE96B LBLE991 LDD 1,X PSHB ;push binary fp operation onto stack. PSHA BSR LBLE99E ;push CE onto stack. LDAB ramB9 BRA LBLE920+1 LBLE99B JMP LBLEA3C ;?SN ERROR LBLE99E LDAB ramCE ;push C9-CE onto stack. LDAA ,X LBLE9A2 PULX PSHB LBLE9A4 LDAB ramCD ;push C9 onto stack and return. PSHB LDAB ramCC PSHB LDAB ramCB PSHB LDAB ramCA PSHB LDAB ramC9 PSHB JMP ,X LBLE9B5 LDX #$0000 PULA TSTA BEQ LBLE9E2 LBLE9BC CMPA #$64 BEQ LBLE9C3 JSR LBLE90E ; expect numeric LBLE9C3 STX ramB7 LBLE9C5 PULB CMPA #$5A BEQ LBLE9E4 ;RTS CMPA #$7D BEQ LBLE9E4 ;RTS LSRB STAB ram88 PULA PULB STD ramD6 PULX STX ramD8 PULB STAB ramDA PULB STAB ramDB EORB ramCE STAB ramDC LBLE9E2 LDAB ramC9 LBLE9E4 RTS LBLE9E5 JSR LBL4294 ; maths command extension CLR ram84 ; vartype flag BSR LBLEA39 ; get next char BHS LBLE9F2 ; go if not numeric LBLE9EF JMP LBLF359 ; get FP number LBLE9F2 JSR LBLEB76 ; is_alpha()? BHS LBLEA49 ; go if alpha() CMPA #$2E ; '.' BEQ LBLE9EF CMPA #$A8 ; '-' BEQ LBLEA41 CMPA #$A7 ; '+' BEQ LBLE9E5 CMPA #$22 ; '"' BNE LBLEA0F LBLEA07 LDX ramF4 JSR LBLED06 JMP LBLEF3E LBLEA0F CMPA #$A4 ; ? NOT BNE LBLEA20 LDAA #$5A JSR LBLE920+1 JSR LBLEBC7 ;get result into D COMA ;perform bitwise negation COMB JMP LBLECE3 ;return D LBLEA20 SUBA #$B1 ; start of function tokens [SGN()] BHS LBLEA55 ;go if a function LBLEA24 BSR LBLEA2B+1 ;otherwise, must be a parenthetical expression JSR LBLE91A LBLEA29 LDAB #$29 ; ')' expect and skip char. LBLEA2B CPX #$C628 ;LDAB #$28 '(' LBLEA2E CPX #$C62C ;LDAB #$2C ',' LBLEA31 PSHX LDX ramF4 CMPB ,X PULX BNE LBLEA3C ;?SN error LBLEA39 JMP LBL00EB LBLEA3C LDAB #$02 ;?SN error JMP LBLE238 LBLEA41 LDAA #$7D JSR LBLE920+1 JMP LBLF593 LBLEA49 JSR LBLEB1B ; :get/init var STX ramCC LDAA ram84 ;vartype flag BNE LBLE9E4 JMP LBLF251 ;X->C9-E LBLEA55 TAB ASLB BSR LBLEA39 ;get next char PSHB CMPB #$22 ;'"' BLO LBLEA7F CMPB #$2C ;',' BHS LBLEA81 BSR LBLEA2B+1 ;get '(' PULB CMPB #$28 ;'(' BHS LBLEA82 PSHB JSR LBLE91A BSR LBLEA2E+1 ;get ',' JSR LBLE90E+1 ;expect string PULA LDX ramCC PSHX PSHA JSR LBLEF0D PULA PSHB TAB BRA LBLEA82 LBLEA7F BSR LBLEA24 LBLEA81 PULB LBLEA82 LDX #TBLE000 ABX LDX ,X JSR ,X JMP LBLE90E ; expect numeric fp_OR LDAA #$4F ; perform fp OR. CLRA -- perform fp_AND. STAA ram82 JSR LBLEBC7 ; get result->D STD ram80 JSR LBLF28B ; copy D6->C9. Clear DD. JSR LBLEBC7 ; get result->D TST ram82 BNE LBLEAA7 ANDA ram80 ; perform the AND ANDB ram81 BRA LBLEAAB LBLEAA7 ORAA ram80 ; perform the OR ORAB ram81 LBLEAAB JMP LBLECE3 ; return D. ; probably < = > ?? fp_EAAE JSR LBLE910 ; check for ?TM and get next number BNE LBLEAC3 LDAA ramDB ORAA #$7F ANDA ramD7 STAA ramD7 LDX #ramD6 JSR LBLF2D9 BRA LBLEB03 LBLEAC3 CLR ram84 ; vartype flag DEC ramB9 JSR LBLEE56 STAB ramD0 STX ramD2 LDX ramD9 JSR LBLEE58 LDAA ramD0 SBA BEQ LBLEAE1 LDAA #$01 BHS LBLEAE1 LDAB ramD0 NEGA LBLEAE1 STAA ramCE TPA PSHA STS ram91 SEI TXS LDX ramD2 INCB DEX LBLEAED DECB BNE LBLEAF4 LDAB ramCE BRA LBLEAFF LBLEAF4 PULA INX CMPA ,X BEQ LBLEAED LDAB #$FF BHS LBLEAFF NEGB LBLEAFF LDS ram91 PULA TAP LBLEB03 ADDB #$01 ROLB ANDB ram88 BEQ LBLEB0C LDAB #$FF LBLEB0C JMP LBLF2BC LBLEB0F JSR LBLEA2E+1 ; get ',' ; --- DIM command --- CMD_DIM TAB BSR LBLEB1F JSRE LBL00F3 BNE LBLEB0F RTS LBLEB1B CLRB JSRE LBL00F3 ;Get current char LBLEB1F STAB ram83 ; STAA ramB1 JSRE LBL00F3 BSR LBLEB76 ;Check for A-Z BHS LBLEB2D JMP LBLEA3C ;?SN error LBLEB2D CLRB STAB ram84 ; vartype flag JSRE LBL00EB ; get next char BLO LBLEB39 ; go if numeric BSR LBLEB76 ; check for A-Z BLO LBLEB43 ; go if not LBLEB39 TAB ; B holds second char (0) if none. LBLEB3A JSRE LBL00EB ; skip until first non-alphanumeric char BLO LBLEB3A ; ' BSR LBLEB76 ; ' BHS LBLEB3A ; ' LBLEB43 CMPA #$24 ; check for $ BNE LBLEB4F COM ram84 ; vartype flag FF=string 00=numeric ADDB #$80 ; mask second char of B if string JSRE LBL00EB ; get next char LBLEB4F STAB ramB2 ; B1-B2 hold varname. LDAB ram86 ; 01 if in CSAVE* or CLOAD* 80 if in FOR 0 else? DECB BNE LBLEB59 JMP LBLEC07 LBLEB59 ADDA ram86 SUBA #$28 ;'(' BNE LBLEB62 JMP LBLEBDE LBLEB62 CLR ram86 LDX ram95 ; start of variable space LBLEB67 CPX ram97 ; start of dim variable space BEQ LBLEB7F ; go if varname not found LDD ramB1 SUBD ,X BEQ LBLEBB0 ; go if varname found LDAB #$07 ABX BRA LBLEB67 ; try again LBLEB76 CMPA #$41 ; 'A' BLO LBLEB7E SUBA #$5B ; 'Z' SUBA #$A5 ;-'Z' LBLEB7E RTS LBLEB7F PULX ;Varname not found. find caller PSHX CPX #$EA4C ;were we called from EA49? BNE LBLEB8A ;yes, insert variable LDX #TBLEBB7 ;[X]=0 RTS LBLEB8A LDD ram99 ;end of arrays STD ramBD ; ADDD #$0007 ;length of var STD ramBB ; LDX ram97 ;start of arrays STX ramC1 ; JSR LBLE1FE ;copy [C1:BD]->[bf:BB] LDX ramBB ; STX ram99 ;bump end of arrays LDX ramBF ; STX ram97 ;bump start of arrays LDX ramC1 ;get destination of variable LDD ramB1 ;get varname STD ,X ;store varname CLRA CLRB STD 2,X ;initialize variable to zero STD 4,X STAA 6,X LBLEBB0 INX INX STX ramB3 ;?start of array data RTS TBLEBB5 FCB $90 FCB $80 TBLEBB7 FCB $00 FCB $00 FCB $00 LBLEBBA JSRE LBL00EB LBLEBBD JSR LBLE90C LBLEBC0 JSR LBLE90E ;expect numeric LDAA ramCE BMI LBLEC2D+1 ;?FC error LBLEBC7 JSR LBLE90E ;expect numeric LDAA ramC9 CMPA #$90 BLO LBLEBD8 LDX #TBLEBB5 ; -32768.0 JSR LBLF2D9 ; compare [X] with C9-E. BNE LBLEC2D+1 ;?FC error LBLEBD8 JSR LBLF30B ; C9-x -> integer LDD ramCC LBLEBDD RTS LBLEBDE LDX ram83 ; Array detected... PSHX CLRB LBLEBE2 PSHB LDX ramB1 PSHX BSR LBLEBBA PULX STX ramB1 PULB INCB STAB ram82 PULA PULB LDX ramCC PSHX PSHB PSHA LDAB ram82 JSRE LBL00F3 CMPA #$2C BEQ LBLEBE2 JSR LBLEA29; get ')' PULX STX ram83 LDAB #$FF LBLEC07 PSHB LDX ram97 LBLEC0A CPX ram99 BEQ LBLEC33 ; go if not found LDD ramB1 ; get varname SUBD ,X BEQ LBLEC1B ; go if found LDD 2,X ; get length of current var JSR LBLE22D ; D+X->D,X BRA LBLEC0A LBLEC1B LDAB #$12 ;?DD error PULA TSTA BEQ LBLEBDD ; RTS - if found and 0 on stack LDAA ram83 BNE LBLEC30 ;write error if in a DIM command on a previously alloc'd var. LDAB ram82 CMPB 4,X BEQ LBLEC87 LBLEC2B LDAB #$10 ;?BS error LBLEC2D CPX #$C608 ;LDAB #$08 ?FC error LBLEC30 JMP LBLE238 LBLEC33 PULA TSTA BEQ LBLEC2D+1 ;?FC error LDD #$0005 STD ramDE LDD ramB1 STD ,X LDAB ram82 STAB 4,X JSR LBLE21A ; see if B words fit on stack STX ramBB LBLEC49 LDAB #$0B CLRA TST ram83 BEQ LBLEC56 PULA PULB ADDD #$0001 LBLEC56 STD 5,X BSR LBLECB9 STD ramDE INX INX DEC ram82 BNE LBLEC49 JSR LBLE22D ; D+X->D,X BHS LBLEC6B JMP LBLE236 ; ?OM ERROR LBLEC6B JSR LBLE21E ; see if D bytes fit on stack SUBD #$0035 STD ram99 CLRA LBLEC74 DEX STAA 5,X CPX ram89 BNE LBLEC74 LDX ramBB LDAA ram99 SUBD ramBB STD 2,X LDAA ram83 BNE LBLECB8 LBLEC87 LDAB 4,X STAB ram82 CLRA CLRB LBLEC8D STD ramDE PULA PULB STD ramCC PSHB PSHA SUBD 5,X BHS LBLECD8 LDD ramDE PULA PULB BEQ LBLECA3 BSR LBLECB9 ADDD ramCC LBLECA3 INX INX DEC ram82 BNE LBLEC8D STD ram89 ASLD ASLD ADDD ram89 ADDD #$0005 JSR LBLE22D ;D+X->D,X STX ramB3 LBLECB8 RTS LBLECB9 LDAA #$10 STAA ramBF LDD 5,X STD ram91 CLRA CLRB LBLECC3 ASLD BLO LBLECD8 ASL ramDF ROL ramDE BHS LBLECD2 ADDD ram91 BLO LBLECD8 LBLECD2 DEC ramBF BNE LBLECC3 RTS LBLECD8 JMP LBLEC2B ; --- MEM function --- FNC_MEM STS ram91 LDD ram91 SUBD ram99 FCB $21 ;"BRN CLRA" LBLECE2 CLRA ; return value of B. LBLECE3 CLR ram84 ; vartype flag = 0 (numeric) STD ramCA LDAB #$90 JMP LBLF2C3 ; --- STR$ function --- FNC_STR JSR LBLE90E ; expect numeric LDX #TBL4334 JSR LBLF429 PULX LDX #TBL4333 BRA LBLED06 LBLECFC STX ramC7 LBLECFE BSR LBLED5F LBLED00 STX ramD2 STAB ramD0 RTS LBLED05 DEX LBLED06 LDAA #$22 STAA ram80 ;String term char #1 STAA ram81 ;String term char #2 LBLED0C INX STX ramDC STX ramD2 LDAB #$FF LBLED13 INCB LDAA ,X BEQ LBLED26 ;Null char term INX CMPA ram80 BEQ LBLED21 CMPA ram81 BNE LBLED13 LBLED21 CMPA #$22 BEQ LBLED26 DEX LBLED26 STX ramDE ;Points to non-null, non-" term char. STAB ramD0 ;stringsize->D0 PSHB LDD ramDC SUBD #$4334 ;See if in command buffer PULB BHI LBLED3A ;Jump if in program BSR LBLECFC LDX ramDC JSR LBLEE3A LBLED3A LDX ram423D ;string buff pointer CPX #$4250 ;end of pointer space BNE LBLED47 LDAB #$1E ;?ST error LBLED44 JMP LBLE238 LBLED47 LDAA ramD0 ;stringsize STAA ,X LDD ramD2 STD 2,X LDAA #$FF STAA ram84 ;vartype flag STX ram423F ;temp str buff ptr STX ramCC LDAB #$05 ABX STX ram423D ;string buff pointer RTS LBLED5F CLR ram85 LBLED62 PSHB CLRA STD ram89 LDD ram9D SUBD ram89 SUBD ram9B ; bottom of system stack BLO LBLED79 ADDD ram9B ; bottom of system stack STD ram9D LDX ram9D INX STX ram9F PULB RTS LBLED79 LDAB #$1A ;?OS error COM ram85 BEQ LBLED44 ;write error BSR LBLED85 PULB BRA LBLED62 LBLED85 LDX ramA1 LBLED87 STX ram9D CLRA CLRB STD ramC5 LDX ram9B ; bottom of system stack STX ramC1 LDX #TBL4241 LBLED94 CPX ram423D ;string buff pointer BEQ LBLED9D BSR LBLEDCD BRA LBLED94 LBLED9D LDX ram95 LBLED9F CPX ram97 BEQ LBLEDA7 BSR LBLEDC7 BRA LBLED9F LBLEDA7 STX ramBB LBLEDA9 LDX ramBB LBLEDAB CPX ram99 BEQ LBLEDE7 LDD 2,X ADDD ramBB STD ramBB LDAA 1,X BPL LBLEDA9 LDAB 4,X ASLB ADDB #$05 ABX LBLEDBF CPX ramBB BEQ LBLEDAB BSR LBLEDCD BRA LBLEDBF LBLEDC7 LDAA 1,X INX INX BPL LBLEDE3 LBLEDCD LDAB ,X BEQ LBLEDE3 LDD 2,X SUBD ram9D BHI LBLEDE3 LDD 2,X SUBD ramC1 BLS LBLEDE3 STX ramC5 LDD 2,X STD ramC1 LBLEDE3 LDAB #$05 ABX LBLEDE6 RTS LBLEDE7 LDX ramC5 BEQ LBLEDE6 CLRA LDAB ,X DECB ADDD ramC1 STD ramBD LDX ram9D STX ramBB JSR LBLE200 LDX ramC5 LDD ramBF STD 2,X LDX ramBF DEX JMP LBLED87 LBLEE06 LDX ramCC PSHX JSR LBLE9E5 JSR LBLE90E+1 ; expect string PULX STX ramDC LDAB ,X LDX ramCC ADDB ,X BHS LBLEE1F LDAB #$1C ;?LS error JMP LBLE238 LBLEE1F JSR LBLECFC LDX ramDC LDAB ,X BSR LBLEE38 LDX ramC7 BSR LBLEE58 BSR LBLEE3A LDX ramDC BSR LBLEE58 JSR LBLED3A JMP LBLE92E LBLEE38 LDX 2,X LBLEE3A TPA PSHA STS ram91 SEI TXS LDX ram9F INCB BRA LBLEE49 LBLEE45 PULA STAA ,X INX LBLEE49 DECB BNE LBLEE45 STX ram9F LDS ram91 PULA TAP RTS LBLEE53 JSR LBLE90E+1 ;expect string LBLEE56 LDX ramCC LBLEE58 LDAB ,X BSR LBLEE70 BNE LBLEE6D LDX 7,X DEX CPX ram9D ; next free string store BNE LBLEE6B PSHB ADDD ram9D STD ram9D PULB LBLEE6B INX RTS LBLEE6D LDX 2,X RTS LBLEE70 CPX ram423F ;tmp str buff ptr BNE LBLEE81 STX ram423D ;string buff pointer DEX DEX DEX DEX DEX STX ram423F ;tmp str buff ptr CLRA LBLEE81 RTS ; --- LEN function --- FNC_LEN BSR LBLEE87 ; stringlen->B LBLEE84 JMP LBLECE2 LBLEE87 BSR LBLEE53 CLR ram84 ; vartype flag TSTB RTS ; --- CHR$ function --- FNC_CHR JSR LBLEF10 LBLEE91 LDAB #$01 JSR LBLED5F LDAA ramCD JSR LBLED00 STAA ,X LBLEE9D INS INS LBLEE9F JMP LBLED3A ; --- ASC function --- FNC_ASC BSR LBLEEA6 BRA LBLEE84 LBLEEA6 BSR LBLEE87 BEQ LBLEF07 ;?FC error LDAB ,X RTS ; --- LEFT$ function --- FNC_LEFT BSR LBLEEF2 CLRA LBLEEB0 CMPB ,X BLS LBLEEB7 LDAB ,X CLRA LBLEEB7 PSHB PSHA JSR LBLECFE LDX ramC7 BSR LBLEE58 PULB ABX PULB JSR LBLEE3A BRA LBLEE9F ; --- RIGHT$ function --- FNC_RIGHT BSR LBLEEF2 LDAA ,X SBA BRA LBLEEB0 ; --- MID$ function --- FNC_MID LDAB #$FF STAB ramCD BSR LBLEF19 CMPA #$29 ;')' BEQ LBLEEDC JSR LBLEF47 LBLEEDC BSR LBLEEF2 BEQ LBLEF07 ;?FC error CLRB DECA CMPA ,X BHS LBLEEB7 TAB SUBB ,X NEGB CMPB ramCD BLS LBLEEB7 LDAB ramCD BRA LBLEEB7 LBLEEF2 JSR LBLEA29; get ')' TSX LDD 5,X STD ramC7 LDD ,X STD 5,X INS INS INS INS PULA LDX ramC7 TAB RTS LBLEF07 JMP LBLEC2D+1 ;?FC error LBLEF0A JSRE LBL00EB ;get arg -> B LBLEF0D JSR LBLE90C LBLEF10 JSR LBLEBC0 LDAA ramCC ; err if result >255 BNE LBLEF07 ;?FC error LDAB ramCD LBLEF19 JMP LBL00F3 ; --- VAL function --- FNC_VAL JSR LBLEE87 BNE LBLEF24 JMP LBLEFF4 LBLEF24 JSR LBLE22C LDAA ,X PSHA CLR ,X LDX ramF4 STX ramDE LDX ram89 STX ramF4 BSR LBLEF19 JSR LBLF359 ; get FP number PULA LDX ram8B STAA ,X LBLEF3E LDX ramDE STX ramF4 RTS LBLEF43 BSR LBLEF4C STX ramA5 LBLEF47 JSR LBLEA2E+1 ;get ',' BRA LBLEF0D ;get arg into B ; get 0-65535 into X LBLEF4C JSR LBLE90C ;get numeric var. LBLEF4F LDAA ramCE BMI LBLEF07 ;?FC error LDAA ramC9 CMPA #$90 BHI LBLEF07 ;?FC error JSR LBLF30B ;C9->integer LDX ramCC RTS ; --- PEEK function --- FNC_PEEK BSR LBLEF4F LDAB ,X JMP LBLECE2; return B ; --- POKE function --- CMD_POKE BSR LBLEF43 LDX ramA5 STAB ,X RTS LBLEF6D LDX #TBLF524 BRA LBLEF7D LBLEF72 JSR LBLF160 ; perform fp - fp_SUB COM ramCE COM ramDC BRA fp_ADD LBLEF7D JSR LBLF160 ; peform fp + fp_ADD TSTB BNE LBLEF86 JMP LBLF28B ; copy D6->C9. Clear DD. LBLEF86 LDX #ramD6 LBLEF89 TAB BEQ LBLEFF9 ; RTS SUBB ramC9 BEQ LBLEFFA BMI LBLEF9C STAA ramC9 LDAA ramDB STAA ramCE LDX #ramC9 NEGB LBLEF9C CMPB #$F8 BLE LBLEFFA CLRA LSR 1,X JSR LBLF080 LBLEFA6 LDAB ramDC BPL LBLEFB5 COM 1,X COM 2,X COM 3,X COM 4,X COMA ADCA #$00 LBLEFB5 STAA ramDD LDAA ramCD ADCA ramDA STAA ramCD LDAA ramCC ADCA ramD9 STAA ramCC LDAA ramCB ADCA ramD8 STAA ramCB LDAA ramCA ADCA ramD7 STAA ramCA TBA BPL LBLF018+1 LBLEFD2 BLO LBLEFD6 BSR LBLF03C ; negate C9-E LBLEFD6 CLRB LBLEFD7 LDAA ramCA BNE LBLF00F LDAA ramCB ;shift digits left by one byte STAA ramCA LDAA ramCC STAA ramCB LDAA ramCD STAA ramCC LDAA ramDD STAA ramCD CLR ramDD ADDB #$08 CMPB #$28 BLT LBLEFD7 LBLEFF4 CLRA LBLEFF5 STAA ramC9 LBLEFF7 STAA ramCE LBLEFF9 RTS LBLEFFA BSR LBLF074 ;shift digits right by -B bits CLC BRA LBLEFA6 LBLEFFF INCB ASL ramDD ROL ramCD ROL ramCC ROL ramCB ROL ramCA LBLF00F BPL LBLEFFF LDAA ramC9 SBA STAA ramC9 BLS LBLEFF4 LBLF018 CPX #$2509 ;BLO LBLF024 ASL ramDD LDAA #$00 STAA ramDD BRA LBLF035 LBLF024 INC ramC9 ;mul by 2 BEQ LBLF058 ;?OV ERROR ROR ramCA ;div digits by 2 ROR ramCB ROR ramCC ROR ramCD LBLF035 BHS LBLF03B ; leave if we don't need to round up BSR LBLF04B ; increment CA-CD BEQ LBLF024 ; adjust exponenent if we broke the bank LBLF03B RTS LBLF03C COM ramCE ; negate C9-E LBLF03F COM ramCA ; negate C9-D COM ramCB COM ramCC COM ramCD LBLF04B LDX ramCC INX STX ramCC BNE LBLF057 LDX ramCA INX STX ramCA LBLF057 RTS LBLF058 LDAB #$0A ;?OV error JMP LBLE238 LBLF05D LDX #TBL008C LBLF060 LDAA 4,X ;shift digits right one byte. STAA ramDD LDAA 3,X STAA 4,X LDAA 2,X STAA 3,X LDAA 1,X STAA 2,X LDAA ramD5 STAA 1,X LBLF074 ADDB #$08 ;if B<-8, shift digits right one byte. BLE LBLF060 LDAA ramDD SUBB #$08 BEQ LBLF08A LBLF07E ASR 1,X ;if B<0 shift digits right one bit LBLF080 ROR 2,X ROR 3,X ROR 4,X RORA INCB BNE LBLF07E LBLF08A RTS TBLF08B FCB $81,$00,$00,$00,$00 ; 1.0 TBLF090 FCB $03 FCB $7F,$5E,$56,$CB,$79 ;0.43425594 FCB $80,$13,$9B,$0B,$64 ;0.57658454 FCB $80,$76,$38,$93,$16 ;0.96180076 FCB $82,$38,$AA,$3B,$20 ;2.88539007 TBLF0A5 FCB $80,$35,$04,$F3,$34 ;SQR(0.5) TBLF0AA FCB $81,$35,$04,$F3,$34 ;SQR(2.0) TBLF0AF FCB $80,$80,$00,$00,$00 ;-0.5 TBLF0B4 FCB $80,$31,$72,$17,$F8 ;LOG(2.0) ; --- LOG function --- LBLF0B9 FNC_LOG JSR LBLF2AD ;Test C9-E BGT LBLF0C1 JMP LBLEC2D+1 ;?FC error LBLF0C1 LDX #TBLF0A5 LDAA ramC9 SUBA #$80 PSHA LDAA #$80 STAA ramC9 JSR LBLEF7D LDX #TBLF0AA JSR LBLF1C5+1 LDX #TBLF08B ; 1.0 JSR LBLEF72 LDX #TBLF090 JSR LBLF5F8 LDX #TBLF0AF JSR LBLEF7D PULB JSR LBLF3E9 LDX #TBLF0B4 LBLF0EF BSR LBLF160 ; perform fp * fp_MUL BEQ LBLF15F JSR LBLF179 LBLF0F6 LDAA #$00 STAA TBL008D STAA ram8E STAA ram8F STAA ram90 LDAB ramCD BSR LBLF12A LDAB ramDD STAB ram4255 LDAB ramCC BSR LBLF12A LDAB ramDD STAB ram4254 LDAB ramCB BSR LBLF12A LDAB ramDD STAB ram4253 LDAB ramCA BSR LBLF12F LDAB ramDD STAB ram4252 JSR LBLF248 JMP LBLEFD6 LBLF12A BNE LBLF12F JMP LBLF05D LBLF12F SEC LBLF130 LDAA TBL008D RORB BEQ LBLF15F BHS LBLF14D LDAA ram90 ADDA ramDA STAA ram90 LDAA ram8F ADCA ramD9 STAA ram8F LDAA ram8E ADCA ramD8 STAA ram8E LDAA TBL008D ADCA ramD7 LBLF14D RORA STAA TBL008D ROR ram8E ROR ram8F ROR ram90 ROR ramDD CLC BRA LBLF130 LBLF15F RTS LBLF160 LDD 1,X STAA ramDB ORAA #$80 STD ramD7 LDAB ramDB EORB ramCE STAB ramDC LDD 3,X STD ramD9 LDAA ,X STAA ramD6 LDAB ramC9 RTS LBLF179 TSTA BEQ LBLF195 ADDA ramC9 RORA ROLA BVC LBLF195 ADDA #$80 STAA ramC9 BNE LBLF18B JMP LBLEFF7 LBLF18B LDAA ramDC STAA ramCE RTS LBLF190 LDAA ramCE COMA BRA LBLF197 LBLF195 PULA PULA LBLF197 BMI LBLF19C JMP LBLEFF4 LBLF19C JMP LBLF058 ; ?OV ERROR LBLF19F JSR LBLF29F ; copy fp C9->D6 BEQ LBLF1B3 ; RTS ADDA #$02 BLO LBLF19C ; ?OV ERROR CLR ramDC JSR LBLEF89 INC ramC9 BEQ LBLF19C ; ?OV ERROR LBLF1B3 RTS TBLF1B4 FCB $84,$20,$00,$00,$00 ; 10.0 LBLF1B9 JSR LBLF29F ;copy fp C9->D6 LDX #TBLF1B4 ;10.0 CLRB LBLF1C0 STAB ramDC JSR LBLF251 ;X->C9-E LBLF1C5 CPX #$8D98 ;BSR LBLF160 ; perform fp / fp_DIV BEQ LBLF243 ; ?/0 error NEG ramC9 BSR LBLF179 INC ramC9 BEQ LBLF19C LDX #TBL008D LDAB #$04 STAB ram82 LDAB #$01 LBLF1DD LDAA ramCA CMPA ramD7 BNE LBLF1F6 LDAA ramCB CMPA ramD8 BNE LBLF1F6 LDAA ramCC CMPA ramD9 BNE LBLF1F6 LDAA ramCD CMPA ramDA BNE LBLF1F6 SEC LBLF1F6 TPA ROLB BHS LBLF206 STAB ,X INX DEC ram82 BMI LBLF239 BEQ LBLF235 LDAB #$01 LBLF206 TAP BLO LBLF21B LBLF209 ASL ramDA ROL ramD9 ROL ramD8 ROL ramD7 BLO LBLF1F6 BMI LBLF1DD BRA LBLF1F6 LBLF21B LDAA ramDA SUBA ramCD STAA ramDA LDAA ramD9 SBCA ramCC STAA ramD9 LDAA ramD8 SBCA ramCB STAA ramD8 LDAA ramD7 SBCA ramCA STAA ramD7 BRA LBLF209 LBLF235 LDAB #$40 BRA LBLF206 LBLF239 RORB RORB RORB STAB ramDD BSR LBLF248 JMP LBLEFD6 LBLF243 LDAB #$14 ;?/0 error JMP LBLE238 LBLF248 LDX TBL008D STX ramCA LDX ram8F STX ramCC RTS LBLF251 PSHA LDD 1,X STAA ramCE ORAA #$80 STD ramCA CLR ramDD LDAB ,X LDX 3,X STX ramCC STAB ramC9 PULA RTS LBLF267 LDX #ramBF BRA LBLF272 ;FPA->X LBLF26C LDX #TBL00BA LBLF26F CPX #$DEB5 ;LDX ramB5 LBLF272 LDAA ramC9 ; Load floating-point ACOI storage-> X. STAA ,X LDAA ramCE ORAA #$7F ANDA ramCA STAA 1,X LDAA ramCB STAA 2,X LDAA ramCC STAA 3,X LDAA ramCD STAA 4,X RTS ; copy D6->C9. Clear DD. LBLF28B LDAA ramDB LBLF28D STAA ramCE LDX ramD6 STX ramC9 CLR ramDD LDX ramD8 STX ramCB LDX ramD9 STX ramCC RTS LBLF29F LDD ramC9 STD ramD6 LDX ramCB STX ramD8 LDX ramCD STX ramDA TSTA RTS LBLF2AD LDAB ramC9 BEQ LBLF2B9 LBLF2B1 LDAB ramCE LBLF2B3 ROLB LDAB #$FF ; return -1 in B. BLO LBLF2B9 NEGB ; return 1 in B. LBLF2B9 RTS ; --- SGN function --- FNC_SGN BSR LBLF2AD ; Test C9-E. B = -1 0 +1 LBLF2BC STAB ramCA CLR ramCB LDAB #$88 LBLF2C3 LDAA ramCA SUBA #$80 LBLF2C7 STAB ramC9 LDAA #$00 TAB STD ramCC STAA ramDD STAA ramCE JMP LBLEFD2 ; --- ABS function --- FNC_ABS CLR ramCE ; clear sign bit RTS ; Compare C9-E with X, returning in B ; =1 if C>X, =-1 if CB if equal LBLF306 RORB EORB ramCE BRA LBLF2B3 ; convert C9-x to integer (contained in CC-D) LBLF30B LDAB ramC9 BEQ LBLF350 SUBB #$A0 LDAA ramCE ;test sign byte BPL LBLF31B COM ramD5 JSR LBLF03F ;negate CA-CD LBLF31B LDX #ramC9 CMPB #$F8 BGT LBLF329 JSR LBLF074 ;shift digits right by -B bits CLR ramD5 RTS LBLF329 CLR ramD5 LDAA ramCE ROLA ROR ramCA JMP LBLF080 ;divide CA-CD by 2^($100-B). ; --- INT function --- LBLF335 FNC_INT LDAB ramC9 CMPB #$A0 BHS LBLF358 BSR LBLF30B ; C9-x -> integer STAB ramDD LDAA ramCE STAB ramCE SUBA #$80 LDAA #$A0 STAA ramC9 LDAA ramCD STAA ram80 JMP LBLEFD2 LBLF350 STAB ramCA STAB ramCB STAB ramCC STAB ramCD LBLF358 RTS LBLF359 JSR LBL429D ;fp-acc number transfer extension LDX #$0000 STX ramCE ;clear C9 STX ramC9 STX ramCB STX ramCC STX ramC1 ;clear C1 STX ramBF BLO LBLF3D8 ;go if numeric CMPA #$2D ; '-' BNE LBLF376 COM ramCF BRA LBLF37A LBLF376 CMPA #$2B ; '+' BNE LBLF37F LBLF37A JSRE LBL00EB BLO LBLF3D8 LBLF37F CMPA #$2E ; '.' BEQ LBLF3B0 CMPA #$45 ; 'E' BNE LBLF3B5 JSRE LBL00EB BLO LBLF3F5 CMPA #$A8 ; '-' BEQ LBLF39E CMPA #$2D ; '-' BEQ LBLF39E CMPA #$A7 ; '+' BEQ LBLF3A1 CMPA #$2B ; '+' BEQ LBLF3A1 BRA LBLF3A6 LBLF39E COM ramC2 LBLF3A1 JSRE LBL00EB BLO LBLF3F5 LBLF3A6 TST ramC2 BEQ LBLF3B5 NEG ramC1 BRA LBLF3B5 LBLF3B0 COM ramC0 BNE LBLF37A LBLF3B5 LDAA ramC1 SUBA ramBF STAA ramC1 BEQ LBLF3D1 BPL LBLF3C9 LBLF3BF JSR LBLF1B9 INC ramC1 BNE LBLF3BF BRA LBLF3D1 LBLF3C9 JSR LBLF19F DEC ramC1 BNE LBLF3C9 LBLF3D1 LDAA ramCF BPL LBLF358 JMP LBLF593 LBLF3D8 LDAB ramBF SUBB ramC0 STAB ramBF PSHA JSR LBLF19F PULB SUBB #$30 BSR LBLF3E9 BRA LBLF37A LBLF3E9 JSR LBLF26C ;C9->BA JSR LBLF2BC LDX #TBL00BA JMP LBLEF7D ;ramC1 = 10*ramC1+(A-$30). LBLF3F5 LDAB ramC1 ASLB ASLB ADDB ramC1 ASLB SUBA #$30 ABA STAA ramC1 BRA LBLF3A1 TBLF403 FCB $9B,$3E,$BC,$1F,$FD ; 99999999.90625 TBLF408 FCB $9E,$6E,$6B,$27,$FD ; 999999999.25000 TBLF40D FCB $9E,$6E,$6B,$28,$00 ;1000000000.00000 LBLF412 LDX #TBLE1B7-1; ' IN ' BSR LBLF423 LDD ramE2 ; line number LBLF419 STD ramCA LDAB #$90 SEC JSR LBLF2C7 BSR LBLF426 LBLF423 JMP LBLE7A8 LBLF426 LDX #TBL4335 LBLF429 LDAA #$20 LDAB ramCE BPL LBLF431 LDAA #$2D LBLF431 STAA ,X STAA ramCE STX ramDE INX LDAA #$30 LDAB ramC9 BNE LBLF441 JMP LBLF51C LBLF441 CLRA CMPB #$80 BHI LBLF44E LDX #TBLF40D JSR LBLF0EF LDAA #$F7 LBLF44E STAA ramBF LBLF450 LDX #TBLF408 JSR LBLF2E3 BGT LBLF468 LBLF458 LDX #TBLF403 JSR LBLF2E3 BGT LBLF470 JSR LBLF19F DEC ramBF BRA LBLF458 LBLF468 JSR LBLF1B9 INC ramBF BRA LBLF450 LBLF470 JSR LBLEF6D JSR LBLF30B ;C9-x -> integer LDAB #$01 LDAA ramBF ADDA #$0A BMI LBLF486 CMPA #$0B BHS LBLF486 DECA TAB LDAA #$02 LBLF486 DECA DECA STAA ramC1 STAB ramBF BGT LBLF49F LDX ramDE LDAA #$2E INX STAA ,X TSTB BEQ LBLF49D LDAA #$30 INX STAA ,X LBLF49D STX ramDE LBLF49F LDX #TBLF529 LDAB #$80 LBLF4A4 LDAA ramCD ADDA 3,X STAA ramCD LDAA ramCC ADCA 2,X STAA ramCC LDAA ramCB ADCA 1,X STAA ramCB LDAA ramCA ADCA ,X STAA ramCA INCB RORB ROLB BVC LBLF4A4 BHS LBLF4C6 SUBB #$0B NEGB LBLF4C6 ADDB #$2F INX INX INX INX STX ramB3 LDX ramDE INX TBA ANDA #$7F STAA ,X DEC ramBF BNE LBLF4E0 LDAA #$2E INX STAA ,X LBLF4E0 STX ramDE LDX ramB3 COMB ANDB #$80 CPX #$F54D BNE LBLF4A4 LDX ramDE LBLF4EE LDAA ,X DEX CMPA #$30 ; '0' BEQ LBLF4EE CMPA #$2E ; '.' BEQ LBLF4FA INX LBLF4FA LDAA #$2B ; '+' LDAB ramC1 BEQ LBLF51E BPL LBLF505 LDAA #$2D ; '-' NEGB LBLF505 STAA 2,X LDAA #$45 STAA 1,X LDAA #$2F LBLF50D INCA SUBB #$0A BHS LBLF50D ADDB #$3A STAA 3,X STAB 4,X CLR 5,X BRA LBLF520 LBLF51C STAA ,X LBLF51E CLR 1,X LBLF520 LDX #TBL4335 LBLF523 RTS TBLF524 FCB $80,$00,$00,$00,$00 ; 0.5 TBLF529 FCB $FA,$0A,$1F,$00 ;-100,000,000 FCB $00,$98,$96,$80 ; 10,000,000 FCB $FF,$F0,$BD,$C0 ; -1,000,000 FCB $00,$01,$86,$A0 ; 100,000 FCB $FF,$FF,$D8,$F0 ; -10,000 FCB $00,$00,$03,$E8 ; 1,000 FCB $FF,$FF,$FF,$9C ; -100 FCB $00,$00,$00,$0A ; 10 FCB $FF,$FF,$FF,$FF ; -1 ; --- SQR function --- FNC_SQR JSR LBLF29F ;copy fp C9->D6 LDX #TBLF524 ;0.5 JSR LBLF251 ;X->C9-E ; perform fp ^ fp_POW BEQ LBLF5C9 TSTA BNE LBLF565 LDAA ramCE BPL LBLF562 JMP LBLF243 ; ?/0 error LBLF562 JMP LBLEFF5 LBLF565 LDX #TBL00C4 JSR LBLF272 ;FPA->X CLRB LDAA ramDB BPL LBLF580 JSR FNC_INT ; LBLF335 LDX #TBL00C4 LDAA ramDB JSR LBLF2E3 BNE LBLF580 COMA LDAB ram80 ; TBL0080 LBLF580 JSR LBLF28D PSHB JSR FNC_LOG ; LBLF0B9 LDX #TBL00C4 JSR LBLF0EF BSR LBLF5C9 PULA RORA BHS LBLF523 LBLF593 LDAA ramC9 BEQ LBLF59A COM ramCE LBLF59A RTS TBLF59B FCB $81,$38,$AA,$3B,$29 ;1.44269504 (CF) correction factor for EXP function TBLF5A0 FCB $07 ;eight coeff's... tchebyshev modified taylor series coeffs for exp(x) FCB $71,$34,$58,$3E,$56 ;0.00002150 1/(7! * CF^7) FCB $74,$16,$7E,$B3,$1B ;0.00014352 1/(6! * CF^6) FCB $77,$2F,$EE,$E3,$85 ;0.00134226 1/(5! * CF^5) FCB $7A,$1D,$84,$1C,$2A ;0.00961402 1/(4! * CF^4) FCB $7C,$63,$59,$58,$0A ;0.05550513 1/(3! * CF^3) FCB $7E,$75,$FD,$E7,$C6 ;0.24022638 1/(2! * CF^2) FCB $80,$31,$72,$18,$10 ;0.69314719 1/(1! * CF^1) FCB $81,$00,$00,$00,$00 ; 1.0 ; --- EXP function --- LBLF5C9: FNC_EXP LDX #TBLF59B ;Get correction factor BSR LBLF604 ;Multiply FPA0 by X JSR LBLF26C ;pack fpa0 and store in fpa3 LDAA ramC9 ;get exponent of fpa0 and compare to max value CMPA #$88 ; (128) BLO LBLF5DA ;br if fpa0 < 128 LBLF5D7 JMP LBLF190 ;set fpa0 = 0 or ?OV ERROR LBLF5DA JSR FNC_INT ;convert fpa0 to integer LDAA ram80 ;get least significant byte of integer ADDA #$81 ; =127? BEQ LBLF5D7 ; ?OV ERROR DECA ; adds bias of 80 (since 81 used above) PSHA ;save exponent on stack LDX #TBL00BA ;point (x) to FPa3 JSR LBLEF72 ;subtract fpa0 from (x) LDX #TBLF5A0 ;point x to coeffs BSR LBLF607 ;eval polynomial for frac part CLR ramDC ;force mantissa to be positive PULA JSR LBLF179 ;calc exp of new fpa0 by adding exps of integer and frac'l parts. RTS LBLF5F8 STX ramDE JSR LBLF26C BSR LBLF604 BSR LBLF609 LDX #TBL00BA LBLF604 JMP LBLF0EF LBLF607 STX ramDE LBLF609 JSR LBLF267 LDX ramDE LDAB ,X STAB ramCF INX STX ramDE LBLF615 BSR LBLF604 LDX ramDE LDAB #$05 ABX STX ramDE JSR LBLEF7D LDX #ramBF DEC ramCF BNE LBLF615 RTS ; --- RND function --- FNC_RND JSR LBLF2AD ; Test C9-E BMI LBLF650 BEQ LBLF646 BSR LBLF643 JSR LBLF26C BSR LBLF646 LDX #TBL00BA BSR LBLF604 LDX #TBLF08B ; 1.0 JSR LBLEF7D LBLF643 JMP FNC_INT LBLF646 LDX ram4218 STX ramCA LDX ram421A STX ramCC LBLF650 LDX CONF682 STX ramD7 LDX CONF684 STX ramD9 JSR LBLF0F6 LDD ram4254 ADDD #$658B STD ram421A STD ramCC LDD ram4252 ADCB #$B0 ADCA #$05 STD ram4218 STD ramCA CLR ramCE LDAA #$80 STAA ramC9 LDAA ram8F STAA ramDD JMP LBLEFD6 CONF682 FDB $40E6 CONF684 FDB $4DAB ; --- COS function --- FNC_COS LDX #TBLF6F6 ; Pi/2 JSR LBLEF7D ; --- SIN function --- FNC_SIN JSR LBLF29F ; copy FPA0 to FPA1 LDX #TBLF6FB ; point X to 2*Pi LDAB ramDB ; get mantissa sign of fpa1 JSR LBLF1C0 ; divide fpa0 by X JSR LBLF29F ; copy FPA0 to FPA1 JSR FNC_INT ; convert FPA0 to integer CLR ramDC ; set result sign to positive LDAA ramD6 ; get exponent of fpa1 LDAB ramC9 ; get exponent of fpa0 JSR fp_SUB ; subtract fpa0 from fpa1 LDX #TBLF700 ; point X to 0.25 JSR LBLEF72 ; subtract fpa0 from 0.25 (pi/2) LDAA ramCE ; get mantissa sign of fpa0 PSHA ; save on stack BPL LBLF6BC ; branch if mantissa positive JSR LBLEF6D ; add 0.5 (pi) to fpa0 LDAA ramCE ; get sign of fpa0 BMI LBLF6BF ; branch if negative COM ram88 ; com if 3pi/2 > arg > pi/2 [quadrant flag] LBLF6BC JSR LBLF593 ; toggle mantissa sign of fpa0 LBLF6BF LDX #TBLF700 ; point X to 0.25 JSR LBLEF7D ; add it to fpa0 PULA ; get the old sign TSTA ; BPL LBLF6CC ; branch if old sign was positve JSR LBLF593 ; toggle mantissa sign LBLF6CC LDX #TBLF705 ; point x to table of coeff's JMP LBLF5F8 ; calculate polynomial value ; --- TAN function --- FNC_TAN JSR LBLF26C CLR ram88 BSR FNC_SIN LDX #TBL00C4 JSR LBLF272 ;FPA->X LDX #TBL00BA JSR LBLF251 ;X->C9-E CLR ramCE LDAA ram88 BSR LBLF6F3 LDX #TBL00C4 JMP LBLF1C5+1 LBLF6F3 PSHA BRA LBLF6BC TBLF6F6 FCB $81,$49,$0F,$DA,$A2 ; 1.57079632 Pi/2 TBLF6FB FCB $83,$49,$0F,$DA,$A2 ; 6.28318531 2*Pi TBLF700 FCB $7F,$00,$00,$00,$00 ; 0.25 1/4 TBLF705 FCB $05 FCB $84,$E6,$1A,$2D,$1B ;-14.38139067 -(2*Pi)^11/11! should be -15.094642578 ($84,$F1,$83,$A7,$EF) FCB $86,$28,$07,$FB,$F8 ; 42.00779712 (2*Pi)^9 / 9! should be 42.058693944 ($86,$28,$3C,$1A,$44) FCB $87,$99,$68,$89,$01 ;-76.70417026 -(2*Pi)^7 / 7! should be -76.705859753 ($87,$99,$69,$66,$73) FCB $87,$23,$35,$DF,$E1 ; 81.60522369 (2*Pi)^5 / 5! should be 81.605249276 ($87,$23,$35,$E3,$3C) FCB $86,$A5,$5D,$E7,$28 ;-41.34170210 -(2*Pi)^3 / 3! should be -41.341702240 ($86,$A5,$5D,$E7,$31) FCB $83,$49,$0F,$DA,$A2 ; 6.28318531 (2*Pi)^1 / 1! should be 6.283185307 ($86,$49,$0F,$DA,$A2) FCB $A1,$54,$46,$8F,$13 ; 7122787878.0 unused? FCB $8F,$52,$43,$89,$CD ; 26913.76914 unused? ; --- Reset Vector --- ;Reset I/O LBLF72E LDAA #$FF STAA ram00 LDAA #$01 STAA ram01 LDAA #$01 STAA ram03 LDAA ramEA ;Check for warm boot flag CMPA #$55 BNE LBLF74A ;Not warm boot LDX ram4221 LDAA ,X DECA BNE LBLF74A JMP ,X ;Warm boot ;Cold boot LBLF74A LDX #$0080 ;Clear 6803 RAM LBLF74D CLR ,X INX CPX #$0100 BNE LBLF74D LDX #TBL41FD ;Size and clear external RAM LBLF758 INX LDAA 2,X ;Get a byte COM 2,X ;Complement LDAB 2,X ;Get the complement CLR 2,X ;Clear COMA CBA ;Complement successful? BEQ LBLF758 ;Next... STX ram4250 ;Save top of RAM STX ramA1 STX ram9D LDD ram9D SUBD #100 ;Reserve 100 bytes for string space STD ram9B ;bottom of system stack LDS ram9B LDX #TBLF7CF ;Init 6803 RAM LDD #$00EB BSR LBLF7AD LDX #TBLF7DE ;Init external RAM LDD #$4200 BSR LBLF7AD LDAA #$39 ;==RTS LDX #LBL4285 ;4285 to 42AE set to RTS LBLF78A STAA ,X INX CPX #$42AF BNE LBLF78A COM ram42AF ;??? LDX #TBL4346 ;init start of prog mem. STX ram93 JSR LBLE3CF ;NEW command JSR LBLFBD3+1 ;Clear screen LDX #TBLF810-1 ;Copyright message JSR LBLE7A8 LDAA #$55 ;Flag warm boot STAA ramEA LBLF7AA JMP LBLE271 ;Copy block of memory from [X+1] to [D], length at [X] LBLF7AD STD ramBF ;Save destination LDAB ,X ;Get length LBLF7B1 INX ;Inc start ;Copy block of memory from [X] to [$00BF], length in B LBLF7B2 LDAA ,X ;Get byte STX ramC1 ;Save source LDX ramBF ;Get dest STAA ,X ;Put byte INX ;Inc dest STX ramBF ;Save dest LDX ramC1 ;Get source DECB ;Dec count BNE LBLF7B1 ;More... RTS ;DEFAULT RESET WARM-BOOT (F7C3) NOP CLR ramE8 ;turn off printing JSR LBLE3EE JSR LBLFBD3+1 ;Clear screen BRA LBLF7AA ;Copied to $00EB TBLF7CF FCB 14 ;14 bytes to copy INC ramF5 BNE LBLF7D8 INC ramF4 LBLF7D8 LDAA >ram00 JMP LBLE1C8 ;Copied to $4200 TBLF7DE FCB 49 ;49 bytes to copy RTI FCB $00 FCB $00 RTI FCB $00 FCB $00 RTI FCB $00 FCB $00 RTI FCB $00 FCB $00 RTI FCB $00 FCB $00 RTI FCB $00 FCB $00 RTI FCB $00 FCB $00 JMP LBLEC2D+1 ;?FC error FCB $4F,$C7,$52,$59,$FF,$04,$5E,$EC,$2E,$F7,$C3,$00,$76,$00,$01,$10 FCB $70,$84,$00,$01,$15,$1A,$0B,$00,$80 TBLF810 FCB $4D,$49,$43,$52,$4F,$43,$4F,$4C,$4F,$52,$20,$42,$41,$53,$49,$43 ;MICROCOLOR BASIC FCB $20,$31,$2E,$30,$0D ; 1.0 FCB $43,$4F,$50,$59,$52,$49,$47,$48,$54,$20,$31,$39,$38,$32,$20 ;COPYRIGHT 1982 TBLF834 FCB $4D,$49,$43,$52,$4F,$53,$4F,$46,$54,$0D,$00 ;MICROSOFT ; --- Flash cursor --- LBLF83F DEC ram422B ;cursor flash delay counter BNE LBLF85E LDAA ram4282 ;cursor color EORA #$0F STAA ram4282 ORAA #$80 LDX ram4280 STAA ,X LDAB #$16 ANDA #$0F BEQ LBLF85B LDAB #$58 ;flash color longer than black. LBLF85B STAB ram422B LBLF85E LDX #$03FA LBLF861 DEX BNE LBLF861 RTS ; --- Idle loop --- LBLF865 JSR LBL4285 ;input char command extension PSHX PSHB LBLF86A BSR LBLF83F ;Flash cursor BSR LBLF883 ;Scan keyboard BEQ LBLF86A ;Repeat if no key pressed LDAB #$60 LDX ram4280 ;cursor address STAB ,X BRA LBLF8CB LBLF879 CLRA BSR LBLF8D0 BNE LBLF883 BSR LBLF8E4 INCA BEQ LBLF8CD ; --- Scan keyboard --- LBLF883 JSR LBL42A9 ; Keyscan command extension PSHX PSHB LDAA #$FB ; Port code for BREAK key. BSR LBLF8D0 TAB BEQ LBLF892 EORB ram423B ; keyboard BREAK flag. LBLF892 STAA ram423B TSTB BEQ LBLF89E BSR LBLF8DC ; delay BSR LBLF8D2 ; still a break? BNE LBLF8C7+1 ; return BREAK code 03 LBLF89E LDX #TBL4230 CLRB DECB STAB ram4239 LBLF8A6 ROLB BHS LBLF8C6 INC ram4239 BSR LBLF8E2 PSHB TAB INX EORA ,X ANDA ,X STAB ,X PULB TSTA SEC BEQ LBLF8A6 PSHA BSR LBLF8DC BSR LBLF8E4 CMPA ,X PULA BNE LBLF8EA LBLF8C6 CLRA LBLF8C7 CPX #$8603 ;LDAA #$03 LBLF8CA TSTA LBLF8CB PULB ;Restore clobbered registers PULX LBLF8CD RTS ; End Scan Keyboard subroutine LBLF8CE LDAA #$7F ; Port code for SHIFT key LBLF8D0 STAA ram02 ; Keyboard port i/o sequence LBLF8D2 LDAA ram03 ; A=0x00=found COMA ; A=0xff=not found ANDA #$02 BEQ LBLF8DB LDAA #$FF LBLF8DB RTS LBLF8DC LDX ram421D ;keyboard debounce delay JMP LBLF861 LBLF8E2 STAB ram02 LBLF8E4 LDAA ioBFFF ORAA #$C0 RTS LBLF8EA LDAB #$F8 LBLF8EC ADDB #$08 LSRA BHS LBLF8EC ADDB ram4239 ; keyboard strobe store LDAA #$FE ; Port code for CONTROL key BSR LBLF8D0 STAA ram423A ; keyboard control key flag JSR LBL42AC ; keyboard control extension BEQ LBLF911 LDX #TBLF97C CMPB #$20 BNE LBLF92E LDAA ram4282 ADDA #$10 STAA ram4282 BRA LBLF8C6 LBLF911 TBA BEQ LBLF918+1 CMPB #$1A BLS LBLF933 LBLF918 CPX #$C61D ;LDAB #$1D LDX #TBLF956-$1D BSR LBLF8CE BEQ LBLF92E LDX #TBLF969-$1D CMPB #$20 BNE LBLF92E COM ram421C BRA LBLF8C6 LBLF92E ABX LDAA ,X BRA LBLF8CA LBLF933 BSR LBLF8CE EORA ram421C BNE LBLF941 LDAA ram421C BNE LBLF946 ORAB #$20 LBLF941 TBA ORAA #$40 LBLF944 BRA LBLF8CA LBLF946 LDX #TBLF9AB ABX LDAA ,X BPL LBLF944 LDAB ram4282 ANDB #$70 ABA BRA LBLF944 TBLF956 FCB $40,$0D,$20 ;@- FCB $30,$31,$32,$33,$34,$35,$36,$37 ;01234567 FCB $38,$39,$3A,$3B,$2C,$2D,$2E,$2F ;89:;,-./ TBLF969 FCB $13,$0D,$20 ;-- FCB $00,$21,$22,$23,$24,$25,$26,$27 ;-!"#$%&' FCB $28,$29,$2A,$2B,$3C,$3D,$3E,$3F ;()*+<=>? ;Tokens TBLF97C FCB $88,$08,$B3,$B2,$82,$9B,$90,$84 ;-------- FCB $A3,$8A,$81,$9E,$BC,$BA,$B9,$A5 ;-------- FCB $C7,$15,$9C,$09,$8C,$80,$B5,$5E ;-------^ FCB $B1,$8F,$0A,$00,$00,$00,$0D,$20 ;------- FCB $00,$8E,$93,$98,$97,$96,$94,$95 ;-------- FCB $9D,$86,$89,$92,$BB,$91,$B7 ;------- ;Graphic chars TBLF9AB FCB $B6,$89,$80,$82,$87,$8D,$86,$85 ;-------- FCB $48,$49,$4A,$4B,$4C,$4D,$4E,$4F ;HIJKLMNO FCB $50,$8F,$8C,$88,$8B,$55,$81,$8E ;P----U-- FCB $83,$8A,$84 ;--- LBLF9C6 JSR LBL4288 ; --- Write char to screen --- PSHX PSHB PSHA LDAB ramE8 ;Ouput device # BEQ LBLFA1B ;Video... ;Assume printer TAB TPA PSHA SEI TBA LBLF9D5 LDAB ram03 ;Wait for handshake ANDB #$04 BNE LBLF9D5 BSR LBLFA0A ;Idle bit CLRB BSR LBLFA0C ;Start bit LDAB #$08 LBLF9E2 PSHB CLRB LSRA ROLB BSR LBLFA0C ;Bit out PULB DECB BNE LBLF9E2 ;Next bit BSR LBLFA0A ;Stop bit PULA TAP PULA CMPA #$0D BEQ LBLFA00 INC ram422A LDAB ram422A CMPB ram4229 BLO LBLFA07 LBLFA00 CLR ram422A BSR LBLFA15 BSR LBLFA15 LBLFA07 PULB PULX RTS LBLFA0A LDAB #$01 LBLFA0C STAB ram03 ;Printer bit output BSR LBLFA10 LBLFA10 LDX ram4223 BRA LBLFA18 LBLFA15 LDX ram4225 LBLFA18 JMP LBLF861 ; A->SCN LBLFA1B LDX ram4280 CMPA #$08 ; backspace BNE LBLFA2E CPX #$4000 BEQ LBLFA77 LDAA #$60 DEX STAA ,X BRA LBLFA5C LBLFA2E CMPA #$0D ; carriage return BNE LBLFA46 LDX ram4280 LBLFA35 LDAA #$60 STAA ,X INX STX ram4280 LDAB ram4281 BITB #$1F BNE LBLFA35 BRA LBLFA5C LBLFA46 CMPA #$20 BLO LBLFA77 TSTA BMI LBLFA59 CMPA #$40 BLO LBLFA57 CMPA #$60 BLO LBLFA59 ANDA #$DF LBLFA57 EORA #$40 LBLFA59 STAA ,X INX LBLFA5C STX ram4280 CPX #$4200 BNE LBLFA77 LDX #$4000 ; scroll up LBLFA67 LDD $20,X STD ,X INX INX CPX #$41E0 BNE LBLFA67 LDAB #$60 JSR LBLFBD9 LBLFA77 PULA PULB PULX RTS LBLFA7B JSR LBL428B ;I/O pointer setup command extenstion PSHX PSHB PSHA LDAA ramE8 ;Get device output 0=screen, -1 printer BEQ LBLFA8D ;go if on screen LDX ram4227 ;tab field width 16/last tab zone 112 LDD ram4229 ;printer line length max BRA LBLFA97 LBLFA8D LDAB ram4281 ;cursor address lsb ANDB #$1F LDX #$1010 LDAA #$20 LBLFA97 STX ramE4 ;i/o tab and last tab field STAB ramE6 ;max line length msb STAA ramE7 ;max line length lsb PULA PULB PULX RTS LBLFAA1 JSR LBLFBD3+1 ;Clear screen LBLFAA4 JSR LBL4291 ;build command line extension LBLFAA7 CLR ram427F ;last keyboard input char LDX #TBL42B2 ;command line buffer LDAB #$01 LBLFAAF JSR LBLF865 ;Cursor loop return with KEY->A TST ramE9 ;Punt if set. (by cmd extension?) BNE LBLFB04 TST ramE8 ;check output flag BNE LBLFB00 ;go if printer TSTA BPL LBLFADD TST ram423A ;control key flag BEQ LBLFADD JSR LBLE4B2 ;address of token->X (save X->ram89) LBLFAC7 LDAA ,X INX PSHX PSHA ANDA #$7F LDX ram89 BSR LBLFB1A STX ram89 PULA PULX TSTA BPL LBLFAC7 LDX ram89 BRA LBLFAAF LBLFADD CMPA #$0C ;unimplemented clearscreen key? BEQ LBLFAA1 CMPA #$08 ;backspace BNE LBLFAED DECB BEQ LBLFAA7 ;don't go before stop DEX BSR LBLFB22 ;A->SCN BRA LBLFAAF LBLFAED CMPA #$15 ;L. DEL BNE LBLFAFB LBLFAF1 DECB ;keep backspacing until stop BEQ LBLFAA7 LDAA #$08 JSR LBLF9C6 ;A->SCN BRA LBLFAF1 LBLFAFB CMPA #$03 ;break SEC BEQ LBLFB05 LBLFB00 CMPA #$0D ;ENTER key BNE LBLFB12 LBLFB04 CLRA ;clear carry flag LBLFB05 TPA PSHA JSR LBLE766 ;#0D->SCN CLR ,X ;terminate scratch LDX #TBL42B1 ;command line buff-1 PULA ;carry set if BREAK'd. TAP LBLFB11 RTS LBLFB12 CMPA #$20 BLO LBLFAAF ;ignore any non-printing char's BSR LBLFB1A BRA LBLFAAF LBLFB1A CMPB #$80 ;don't go more than 128 chars. BHS LBLFB11 STAA ,X ;store char into command line buffer INX INCB LBLFB22 JMP LBLF9C6 ;A->SCN ; --- SET command --- CMD_SET BSR LBLFB6A ; get (x,y arg into memloc into X PSHX JSR LBLEF47 ; get ,c (B holds color code ) PULX CMPB #$08 BHI LBLFB67 ; ?FC error if color > 8 DECB BMI LBLFB38 LDAA #$10 ; LSLB LSLB LSLB LSLB MUL BRA LBLFB40 LBLFB38 LDAB ,X ; Get color from screen BPL LBLFB3F ; Set to zero if text encountered ANDB #$70 FCB $21 ;"BRN CLRB" LBLFB3F CLRB LBLFB40 STAB ram82 ; save color BSR LBLFBB4 ; get trailing ')' LDAA ,X BMI LBLFB49 ; make sure its graphics CLRA ; clear if a text char LBLFB49 ANDA #$0F ; ignore color bits ORAA ram423C ; holds desired bit ORAA ram82 ; get color LBLFB50 ORAA #$80 ; make a graphics char STAA ,X ; write value to screen RTS ; --- RESET command --- CMD_RESET BSR LBLFB6A ; get (x,y arg into memloc into X BSR LBLFBB4 ; get trailing ')' CLRA LDAB ,X BPL LBLFB50 ; clear if it's a text char COM ram423C ANDB ram423C STAB ,X RTS LBLFB67 JMP LBLEC2D+1 ; ?FC error LBLFB6A JSR LBLEA2B+1 ; get '(' LBLFB6D JSR LBLEF0D ; get x position CMPB #$3F BHI LBLFB67 ; ?FC error if > 63 PSHB ; push x on stack JSR LBLEF47 ; get y position CMPB #$1F BHI LBLFB67 ; ?FC error if > 31 PSHB ; push y on stack LSRB ; y=y/2 LDAA #$20 MUL ADDD #$4000 ; get address of left side of screen from y PSHB ; push onto stack PSHA TSX LDAB 3,X ; take x/2 and add to left side of screen LSRB PULX ABX PULA ; now construct mask for char block and store in 423C PULB ANDA #$01 RORB ROLA ; A holds 2's complement of bit pos LDAB #$10 ; start B with bit 4 LBLFB94 LSRB ; shift right until A is zero DECA BPL LBLFB94 STAB ram423C ; done, store into 423C RTS ; --- POINT command --- FNC_POINT BSR LBLFB6D ; get '(x,y' into X and mask into 423C LDAB #$FF LDAA ,X BPL LBLFBB2 ; need to return -1 if text char ANDA ram423C BEQ LBLFBB1 ; not set, return 0 LDAB ,X LSRB LSRB LSRB LSRB ANDB #$07 LBLFBB1 INCB LBLFBB2 BSR LBLFBB7 ; return B (sign extended) LBLFBB4 JMP LBLEA29 ; get ')' LBLFBB7 CLRA ; return B (sign extended) TSTB BPL LBLFBBC COMA LBLFBBC JMP LBLECE3 ; return D ; --- CLS command --- CMD_CLS BEQ LBLFBD3+1 ;No args - default clear JSR LBLEF0D ;Get integer arg into B between 0-255. CMPB #$08 BHI LBLFBE5 ;If > 8 - Clear screen and print Microsoft message TSTB BEQ LBLFBD1 ;CLS 0... DECB LDAA #$10 MUL ORAB #$0F LBLFBD1 ORAB #$80 ;0=$80, 1=$8F, 2=$9F, 3=$AF, 4=$BF, 5=$CF, 6=$DF, 7=$EF, 8=$FF LBLFBD3 CPX #$C660 ;==LDAB #$60 - Default clear char LDX #TBL4000 ;Start of video memory LBLFBD9 STX ram4280 LBLFBDC STAB ,X ;Set mem INX ;Next CPX #$4200 ;Done? BNE LBLFBDC ;More... RTS LBLFBE5 BSR LBLFBD3+1 ;Clear screen LDX #TBLF834-1 ;Microsoft message JMP LBLE7A8 ;Write string ; --- INKEY$ function --- FNC_INKEY LDAA ram427F ;last keyboard input char BNE LBLFBF5 JSR LBLF883 LBLFBF5 CLR ram427F STAA ramCD BEQ LBLFBFF JMP LBLEE91 LBLFBFF STAA ramD0 JMP LBLEE9D ; --- EXEC function --- CMD_EXEC BEQ LBLFC0C JSR LBLEF4C ; Get address to X STX ram421F LBLFC0C LDX ram421F JMP ,X ; --- VARPTR function --- FNC_VARPTR LDX ram99 PSHX JSR LBLEB1B JSR LBLEA29 ; get ')' STX ram89 PULX LDD ram89 CPX ram99 BEQ LBLFC26 JMP LBLEC2D+1 ; ?FC error LBLFC26 JMP LBLECE3 ; return D ; --- PRINT @expression --- LBLFC29 JSR LBLEBBA SUBD #$01FF BLS LBLFC34 JMP LBLEC2D+1 ; ?FC error LBLFC34 ADDD #$41FF STD ram4280 RTS ; --- CSAVE command --- CMD_CSAVE LDX ram93 STX ram426F ; start LDX ram95 STX ram4271 ; end CLRB CMPA #$A9 ; CSAVE* BNE LBLFC4F JSR LBLFDDB LDAB #$04 LBLFC4F STAB ram4267 ;file type flag LDD ram4271 ; end SUBD ram426F ; start STD ram426C ;LOAD address BSR LBLFC8B LDX ram426F ; start LBLFC60 STX ram4278 ;cass buffer address LDAA #$FF STAA ram4276 ;cass block length LDD ram4271 SUBD ram4278 ;cass buffer address BLS LBLFC7E TSTA BNE LBLFC7A CMPB #$FF BEQ LBLFC7A STAB ram4276 ;cass block length LBLFC7A BSR LBLFCC0 ;write cassette block BRA LBLFC60 LBLFC7E NEG ram4275 ;cass block type flag CLR ram4276 ;cass block length BSR LBLFCC0 ;write cassette block LBLFC86 LDAA #$01 STAA ram03 RTS LBLFC8B JSR LBLFD29 LDX #TBL425F ;tape filename block STX ram4278 ;cass buffer address STX ramBF CLR $09,X ;ram4268 CLR $0A,X ;ram4269 LDX #TBL4257 ;skip/load filename LDAB #$08 JSR LBLF7B2 ;Copy block of memory from [X] to [$00BF], length in B CLR ram4275 ;cass block type flag LDAA #$0F STAA ram4276 ;cass block length BSR LBLFCB7 ;write cassette leader BSR LBLFCC0 ;write cassette block INC ram4275 ;cass block type flag LDX #$0000 JSR LBLF861 ;Write cassette leader LBLFCB7 LDX ram422F ; numer of $55's in leader LBLFCBA BSR LBLFD01 DEX BNE LBLFCBA RTS LBLFCC0 NOP ;Write cassette block SEI LDAB ram4276 ;cass block length STAB ram427B ;cass load status flag LDAA ram4276 ;cass block length BEQ LBLFCD6 LDX ram4278 ;cass buffer address LBLFCD0 ADDA ,X INX DECB BNE LBLFCD0 LBLFCD6 ADDA ram4275 ;cass block type flag STAA ram427A ;cass sumcheck LDX ram4278 ;cass buffer address BSR LBLFD01 LDAA #$3C BSR LBLFD03 LDAA ram4275 BSR LBLFD03 LDAA ram4276 ;cass block length BSR LBLFD03 TSTA BEQ LBLFCFC LBLFCF2 LDAA ,X INX BSR LBLFD03 DEC ram427B ;cass load status flag BNE LBLFCF2 LBLFCFC LDAA ram427A ;cass sumcheck BSR LBLFD03 LBLFD01 LDAA #$55 ;Write cassette char LBLFD03 PSHX PSHA PSHA LDAB #$08 LBLFD08 TSX LSR ,X LDX #$0020 BLO LBLFD13 LDX #$0040 LBLFD13 PSHX LDAA #$01 STAA ram03 LBLFD18 DEX BNE LBLFD18 CLRA STAA ram03 PULX LBLFD1F DEX BNE LBLFD1F DECB BNE LBLFD08 PULA PULA PULX LBLFD28 RTS LBLFD29 BSR LBLFD33 JSRE LBL00F3 BEQ LBLFD28 JMP LBLEA3C;?SN ERROR LBLFD33 LDX #TBL4256 ; file name length CLR ,X LDAA #$20 ; pad filename with space chars LBLFD3A INX STAA ,X CPX #$425F ;tape filename block BNE LBLFD3A JSRE LBL00F3 ; load input char BEQ LBLFD28 ; return if no filename JSR LBLE91A ; evaulate arg JSR LBLEE53 ; get string? STAB TBL4256 ; length of string to filename len. BEQ LBLFD28 ; RTS PSHB LDD #$4257 ;skip/load filename STD ramBF PULB JMP LBLF7B2 ;Copy block of memory from [X] to [$00BF], length in B ; --- CLOAD command --- CMD_CLOAD CMPA #$A9 ; CLOAD* BNE LBLFD63 JMP LBLFDB1 LBLFD63 CMPA #$4D ; CLOADM BNE LBLFD6A JMP LBLFE06 LBLFD6A CLRA ; program data BSR LBLFD8F JSR LBLE3CF ; NEW command status flag COM ram426E ; unset new command flag LDD ram426C ; LOAD address ADDD ram93 JSR LBLE21E ; see if D bytes fit on stack LDX ram93 LBLFD7D STX ram4278 ; cass buffer address BSR LBLFDD0 BPL LBLFD7D STX ram95 LDX #TBLE1BC-1 ; "OK" JSR LBLE7A8 ; Write string JMP LBLE2EB ; adjust next line pointers, and return to command mode LBLFD8F PSHA ; A: 00=program 02=machine code 04=array data BSR LBLFDA2 PULA TST ram4274 BNE LBLFDCF CMPA ram4267 ;File type flag BEQ LBLFDCF LDAB #$24 ;?FM error JMP LBLE238 ;write error LBLFDA2 BSR LBLFD33 JSR LBLFE37 BNE LBLFDAC ;?IO error JMP LBLFF4E ;Read cassette leader LBLFDAC LDAB #$22 ;?IO error JMP LBLE238 ;CLOAD* LBLFDB1 BSR LBLFDDB LDAA #$04 ;array data BSR LBLFD8F LDD ram4271 ;end SUBD ram426F ;start SUBD ram426C ; LOAD address BHS LBLFDC5 JMP LBLE236 ;?OM error LBLFDC5 LDX ram426F LBLFDC8 STX ram4278 ;cass buffer address BSR LBLFDD0 BPL LBLFDC8 LBLFDCF RTS LBLFDD0 JSR LBLFEB5+1 ;disable blocklength limit, enable writing, read block->X LBLFDD3 BNE LBLFDAC ; ?IO error LDAA ram4275 ; Cass block type flag BEQ LBLFDAC ; ?IO error RTS ;CSAVE* LBLFDDB JSRE LBL00EB ;get next char LDAB #$01 STAB ram86 JSR LBLEB1B ;get init/var CLR ram86 JSR LBLE90E ;expect string LDD 2,X JSR LBLE22D ;D+X->D,X STX ram4271 LDX ram89 LDAB 4,X ASLB ADDB #$05 ABX STX ram426F JSRE LBL00F3 BEQ LBLFDCF JMP LBLEA2E+1 ; get ',' ;CLOADM LBLFE06 JSRE LBL00EB ; Get next input char LDAA #$02 ; machine code BSR LBLFD8F LDX #$0000 JSRE LBL00F3 BEQ LBLFE1B JSR LBLEA2E+1 ; get ',' JSR LBLEF4C ; get address offset to X LBLFE1B STX ram89 LDD ram426A ;EXEC address offset ADDD ram89 STD ram421F ;default EXEC address LDD ram426C ;LOAD address ADDD ram89 PSHB PSHA PULX BRA LBLFDC8 ; --- SKIPF command --- CMD_SKIPF JSR LBLFDA2 BSR LBLFE8A BNE LBLFDD3 RTS LBLFE37 LDAA ramE2 INCA BNE LBLFE46 JSR LBLFBD3+1 ;Clear screen LDAA #$53 ;write 'S' to screen BSR LBLFE81 JSR LBLE7B9 LBLFE46 BSR LBLFEAA ORAA ram4275 ; Cass block type flag BNE LBLFE80 CLRB PSHB LBLFE4F LDX #TBL425F ;tape filename block ABX LDAA ,X LDX ramE2 INX BNE LBLFE5C BSR LBLFE81 LBLFE5C LDX #TBL4257 ;skip/load filename ABX SUBA ,X TSX ORAA ,X STAA ,X INCB CMPB #$08 BNE LBLFE4F PULA TSTA BEQ LBLFE7B TST TBL4256 BEQ LBLFE7B BSR LBLFE87 BNE LBLFE80 BRA LBLFE37 LBLFE7B LDAA #$46 BSR LBLFEA1 CLRA LBLFE80 RTS LBLFE81 CLR ramE8 ;turn off printer JMP LBLF9C6 ;A->SCN LBLFE87 JSR LBLFF4E ;Read cassette leader LBLFE8A LDAA #$FF ;disable blocklength limit TAB ;disable writing (B=$FF) BSR LBLFEB9 BNE LBLFE98 LDAA ram4275 ;cass block type flag NEGA BMI LBLFE8A DECA LBLFE98 STAA ram427B ;cass load status flag RTS LBLFE9C LDAA TBL4000 EORA #$40 LBLFEA1 LDAB ramE2 INCB BNE LBLFEA9 STAA TBL4000 LBLFEA9 RTS LBLFEAA JSR LBLFF4E ;Read cassette leader LDX #TBL425F ;tape filename block STX ram4278 ;cass buffer address LDAA #$0F ;15 byte block length limit LBLFEB5 CPX #$86FF ;LDAA #$FF (disable blocklength limit) CLRB ;enable writing LBLFEB9 PSHA ;Read cassette block STAB ram4273 NOP SEI BSR LBLFE9C LDX ram4278 ;cass buffer address CLRA LBLFEC5 BSR LBLFF22 ;Read cassette bit RORA CMPA #$3C ;00111100 BNE LBLFEC5 BSR LBLFF14 ;Read cassette char STAA ram4275 ;cass block type flag BSR LBLFF14 ;Read cassette char STAA ram4276 ;cass block length PULB CBA BHI LBLFF0A+1 ADDA ram4275 ;cass block type flag STAA ram427A ;cass sumcheck LDAA ram4276 ;cass block length STAA ram427B ;cass load status flag BEQ LBLFF01 LBLFEE8 BSR LBLFF14 ;Read cassette char TST ram4273 BNE LBLFEF6 ;don't write if set STAA ,X CMPA ,X BNE LBLFF0D+1 INX LBLFEF6 ADDA ram427A ;cass sumcheck STAA ram427A ;cass sumcheck DEC ram427B ;cass load status flag BNE LBLFEE8 LBLFF01 BSR LBLFF14 ;Read cassette char SUBA ram427A ;cass sumcheck BEQ LBLFF10 LDAA #$01 ; #$01 - bad sumcheck LBLFF0A CPX #$8603 ;LDAA #$03 - unexpected block length LBLFF0D CPX #$8602 ;LDAA #$02 - store failed LBLFF10 STAA ram427B ;cass load status flag RTS LBLFF14 LDAA #$08 ;Read cassette char->A STAA ram427C ;cass byte load bit counter LBLFF19 BSR LBLFF22 ;read cassette bit RORA DEC ram427C ;cass byte load bit counter BNE LBLFF19 RTS LBLFF22 BSR LBLFF2C ;Read cassette bit->C LDAB ram427D ;tone duration counter DECB CMPB ram422C ;cassette 1200/2400Hz partition RTS LBLFF2C CLR ram427D ;tone duration counter TST ram427E ;cass polarity flag BNE LBLFF45 ;get 1->0 transition ;get 0->1 transition LBLFF34 BSR LBLFF3D ;Inc duration until 0 BNE LBLFF34 LBLFF38 BSR LBLFF3D ;Inc duration until 1 BEQ LBLFF38 RTS LBLFF3D INC ram427D ;tone duration counter LDAB ram03 ANDB #$10 RTS ;get 1->0 transition LBLFF45 BSR LBLFF3D ;Inc duration until 1 BEQ LBLFF45 LBLFF49 BSR LBLFF3D ;Inc duration until 0 BNE LBLFF49 RTS LBLFF4E NOP ;Read cassette leader SEI CLR ram427C ;cass byte load bit counter LBLFF53 BSR LBLFF34 ;get 0->1 xsition LBLFF55 BSR LBLFF84 ;clear counter, count until 0, compare counter against limit BHI LBLFF6B LBLFF59 BSR LBLFF7D ;clear counter, count until 1, compare counter against limit BLO LBLFF6F DEC ram427C ;cass byte load bit counter LDAA ram427C ;cass byte load bit counter CMPA #$A0 LBLFF65 BNE LBLFF53 STAA ram427E ;cass polarity flag RTS LBLFF6B BSR LBLFF7D ;clear counter, count until 1, compare counter against limit BHI LBLFF55 LBLFF6F BSR LBLFF84 ;clear counter, count until 0, compare counter against limit BLO LBLFF59 INC ram427C ;cass byte load bit counter LDAA ram427C ;cass byte load bit counter SUBA #$60 BRA LBLFF65 LBLFF7D CLR ram427D ;tone duration counter BSR LBLFF38 ;incr duration until 1 BRA LBLFF89 LBLFF84 CLR ram427D ;tone duration counter BSR LBLFF49 ;incr duration until 0 LBLFF89 LDAB ram427D ;tone duration counter CMPB ram422D ;upper limit of 1200 Hz BHI LBLFF95 CMPB ram422E ;lower limit of 2400 Hz RTS LBLFF95 CLR ram427C ;cass byte load bit counter RTS LBLFF99 JSR LBLEA2E+1 ; get ',' LBLFF9C JSR LBLEF0D ; get num->B TSTB BNE LBLFFD1 JMP LBLEC2D+1 ;?FC error if B=0 ; --- SOUND command --- CMD_SOUND BSR LBLFF9C ;get num->B PSHB BSR LBLFF99 ;get ,num->B PULA LBLFFAB PSHA ;A=PITCH, B=DURATION PSHB CLRA LBLFFAE LDX ram09 ;4; read counter LDAB ram08 ;3; read timer control and status reg [req'd to clear OCF flag] (ICF OCF TOF EICI EOCI ETOI IEDG OLVL) STX ram0B ;4; store counter to output compare register LBLFFB4 EORA #$80 ;2; toggle speaker coil output STAA ioBFFF ;4; TSX ;3; LDAB 1,X ;4; get pitch LBLFFBC INX ;3; timewaste INX ;3; timewaste INCB ;2; BNE LBLFFBC ;3; (11 cycles per loop) LDAB ram08 ;3; ANDB #$40 ;2; get output compare flag BEQ LBLFFB4 ;3; toggle again if still clear... (freq = 1MHz/(11*(256-PITCH)+21)) TSX ;4; DEC ,X ;6; dec duration (=DURATION * 65.56ms) BNE LBLFFAE ;3; CLRA STAA ioBFFF PULX LBLFFD1 RTS FCB $6E,$69,$6C,$72,$65,$62,$6D,$61,$68,$43 ; nilrebmahC (spell it backwards) ; --- User ROM routines--- FDB LBLF883 ;Scan keyboard FDB LBLF9C6 ;Write char to screen FDB LBLFF4E ;Read cassette leader FDB LBLFEB9 ;Read cassette block FDB LBLFCC0 ;Write cassette block FDB LBLFFAB ;Sound FDB LBLFCB7 ;Write cassette leader FDB LBLECE3 ; return D to BASIC FDB LBLEBC7 ; get result -> D FCB $00,$C9 ; 6803 vectors FDB $4200 ;SCI (TDRE + RDRF + ORFE) FDB $4203 ;TOF Timer overflow interrupt FDB $4206 ;OCF Output compare interrupt FDB $4209 ;ICF Input capture interrupt FDB $420C ;IRQ1 Maskable interrupt req 1. FDB $420F ;SWI Software interrupt FDB $4212 ;NMI Non-maskable interrupt FDB LBLF72E ;Reset .end ; { 0xE000, VECTOR }, ; { 0xE030, TABLE }, ; { 0xE045, TABLE_ASCII }, ; { 0xE148, VECTOR }, ; { 0xE18A, TABLE_ASCII }, ; { 0xE1C8, CODE }, ; { 0xE7C1, TABLE_ASCII }, ; { 0xE7C8, CODE }, ; { 0xE8AB, TABLE_ASCII }, ; { 0xE8BB, CODE }, ; { 0xE988, TABLE }, ; { 0xE98B, CODE }, ; { 0xF08B, TABLE }, ; { 0xF0B9, CODE }, ; { 0xF403, TABLE }, ; { 0xF412, CODE }, ; { 0xF524, TABLE }, ; { 0xF54D, CODE }, ; { 0xF59B, TABLE }, ; { 0xF5C9, CODE }, ; { 0xF682, TABLE_WORD }, ; { 0xF686, CODE }, ; { 0xF6F6, TABLE }, ; { 0xF72E, CODE }, ; { 0xF7F7, TABLE }, ; { 0xF810, TABLE_ASCII }, ; { 0xF83F, CODE }, ; { 0xF956, TABLE_ASCII }, ; { 0xF9C6, CODE }, ; { 0xFFD2, TABLE_ASCII }, ; { 0xFFDC, VECTOR }, ; { 0xFFEE, TABLE }, ; { 0xFFF0, TABLE_WORD }, ; { 0x10000, DISASM_END },