Freeware assember ASxx.EXE Ver 1.03. 0001 * BUFFALO 0002 * "Bit User's Fast Friendly Aid to Logical Operation" 0003 * 0004 * Rev 2.0 - 4/23/85 - added disassembler. 0005 * - variables now PTRn and TMPn. 0006 * Rev 2.1 - 4/29/85 - added byte erase to chgbyt routine. 0007 * Rev 2.2 - 5/16/85 - added hooks for evb board - acia 0008 * drivers, init and host routines. 0009 * 7/8/85 - fixed dump wraparound problem. 0010 * 7/10/85 - added evm board commands. 0011 * - added fill instruction. 0012 * 7/18/85 - added jump to EEPROM. 0013 * Rev 2.3 - 8/22/85 - call targco to disconnect sci from host 0014 * in reset routine for evb board. 0015 * 10/3/85 - modified load for download through terminal. 0016 * Rev 2.4 - 7/1/86 - Changed DFLOP address to fix conflicts with 0017 * EEPROM. (was at A000) 0018 * Rev 2.5 - 9/8/86 - Modified to provide additional protection from 0019 * program run-away on power down. Also fixed bugs 0020 * in MM and MOVE. Changed to 1 stop bit from 2. 0021 * Rev 2.6 - 9/25/86 - Modified boot routine for variable length download 0022 * for use with 'HC11E8. 0023 * Rev 3.0 1/15/87 - EEPROM programming routines consolidated into WRITE. 0024 * Fill, Assem, and breakpoints will now do EEPROM. 0025 * - Added compare a to $0D to WSKIP routine. 0026 * 2/11/87 - Set up load to detect receiver error. 0027 * Rev 3.2 7/7/87 - Add disassembly to trace. 0028 * - Add entries to jump table. 0029 * 9/20/87 - Rewrote trace to use XIRQ, added STOPAT Command 0030 * 11/24/87- Write block protect reg for 'E9 version 0031 * - Modified variable length download for use 0032 * with 'E9 bootloader (XBOOT command) 0033 * Rev 3.3 3/17/88 - Set I bit to block interrupts on Warm Start and 0034 * return from CALL command. 0035 * - Added EEMOD Command. 0036 * - Rearranged source so that HELP command overlaps 0037 * EEPROM in test mode. 0038 * 3/24/88 - Added '+', '-', '=', '.' to MEM and ASM commands. 0039 * - Added check for 16 byte boundary to MEM 0040 * space sub-command. 0041 * - LOAD command now puts dummy (~) command into 0042 * inbuff so that any stray cr's won`t hang. 0043 * Rev 3.4 8/15/88 - Changed WRITE subroutine so that config register 0044 * gets byte erased before programmed. The original 0045 * value of config is used for EEBYTE so that config 0046 * RAM value doesn't get changed in test mode. 0047 * 8/17/88 - Fixed MOVE command so that it doesn't hang when move 0048 * is done to a ROM location. 0049 * - Added OFFSET command for download offset capability. 0050 * 0051 **************************************************** 0052 * Although the information contained herein, * 0053 * as well as any information provided relative * 0054 * thereto, has been carefully reviewed and is * 0055 * believed accurate, Motorola assumes no * 0056 * liability arising out of its application or * 0057 * use, neither does it convey any license under * 0058 * its patent rights nor the rights of others. * 0059 **************************************************** 0060 0061 *************** 0062 * EQUATES * 0063 *************** 0064 *Author EQU Tony Fourcroy 0065 0000 RAMBS EQU $0000 start of ram 0066 1000 REGBS EQU $1000 start of registers 0067 e000 ROMBS EQU $E000 start of rom 0068 b600 DSTREE EQU $B600 start of eeprom 0069 b7ff DENDEE EQU $B7FF end of eeprom 0070 100a PORTE EQU REGBS+$0A port e 0071 100b CFORC EQU REGBS+$0B force output compare 0072 100e TCNT EQU REGBS+$0E timer count 0073 101e TOC5 EQU REGBS+$1E oc5 reg 0074 1020 TCTL1 EQU REGBS+$20 timer control 1 0075 1022 TMSK1 EQU REGBS+$22 timer mask 1 0076 1023 TFLG1 EQU REGBS+$23 timer flag 1 0077 1024 TMSK2 EQU REGBS+$24 timer mask 2 0078 102b BAUD EQU REGBS+$2B sci baud reg 0079 102c SCCR1 EQU REGBS+$2C sci control1 reg 0080 102d SCCR2 EQU REGBS+$2D sci control2 reg 0081 102e SCSR EQU REGBS+$2E sci status reg 0082 102f SCDAT EQU REGBS+$2F sci data reg 0083 1035 BPROT EQU REGBS+$35 block protect reg 0084 1039 OPTION EQU REGBS+$39 option reg 0085 103a COPRST EQU REGBS+$3A cop reset reg 0086 103b PPROG EQU REGBS+$3B ee prog reg 0087 103c HPRIO EQU REGBS+$3C hprio reg 0088 103f CONFIG EQU REGBS+$3F config register 0089 4000 DFLOP EQU $4000 evb d flip flop 0090 d000 DUART EQU $D000 duart address 0091 d000 PORTA EQU DUART 0092 d008 PORTB EQU DUART+8 0093 9800 ACIA EQU $9800 acia address 0094 003e PROMPT EQU '>' 0095 0023 BUFFLNG EQU 35 0096 0001 CTLA EQU $01 exit host or assembler 0097 0002 CTLB EQU $02 send break to host 0098 0017 CTLW EQU $17 wait 0099 0018 CTLX EQU $18 abort 0100 007f DEL EQU $7F abort 0101 0004 EOT EQU $04 end of text/table 0102 003f SWI EQU $3F 0103 0104 *************** 0105 * RAM * 0106 *************** 0107 002d ORG $2D 0108 *** Buffalo ram space *** 0109 002d RMB 20 user stack area 0110 0041 USTACK RMB 30 monitor stack area 0111 005f STACK RMB 1 0112 0060 REGS RMB 9 user's pc,y,x,a,b,c 0113 0069 SP RMB 2 user's sp 0114 006b INBUFF RMB BUFFLNG input buffer 0115 008e ENDBUFF EQU * 0116 008e COMBUFF RMB 8 command buffer 0117 0096 SHFTREG RMB 2 input shift register 0118 0098 STREE RMB 2 eeprom start address 0119 009a ENDEE RMB 2 eeprom end address 0120 009c BRKTABL RMB 8 breakpoint table 0121 00a4 AUTOLF RMB 1 auto lf flag for i/o 0122 00a5 IODEV RMB 1 0=sci, 1=acia, 2=duartA, 3=duartB 0123 00a6 EXTDEV RMB 1 0=none, 1=acia, 2=duart, 0124 00a7 HOSTDEV RMB 1 0=sci, 1=acia, 3=duartB 0125 00a8 COUNT RMB 1 # characters read 0126 00a9 CHRCNT RMB 1 # characters output on current line 0127 00aa PTRMEM RMB 2 current memory location 0128 00ac LDOFFST RMB 2 offset for download 0129 0130 *** Buffalo variables - used by: *** 0131 00ae PTR0 RMB 2 main,readbuff,incbuff,AS 0132 00b0 PTR1 RMB 2 main,BR,DU,MO,AS,EX 0133 00b2 PTR2 RMB 2 EX,DU,MO,AS 0134 00b4 PTR3 RMB 2 EX,HO,MO,AS 0135 00b6 PTR4 RMB 2 EX,AS 0136 00b8 PTR5 RMB 2 EX,AS,BOOT 0137 00ba PTR6 RMB 2 EX,AS,BOOT 0138 00bc PTR7 RMB 2 EX,AS 0139 00be PTR8 RMB 2 AS 0140 00c0 TMP1 RMB 1 main,hexbin,buffarg,termarg 0141 00c1 TMP2 RMB 1 GO,HO,AS,LOAD 0142 00c2 TMP3 RMB 1 AS,LOAD 0143 00c3 TMP4 RMB 1 TR,HO,ME,AS,LOAD 0144 *** Vector jump table *** 0145 00c4 JSCI RMB 3 0146 00c7 JSPI RMB 3 0147 00ca JPAIE RMB 3 0148 00cd JPAO RMB 3 0149 00d0 JTOF RMB 3 0150 00d3 JTOC5 RMB 3 0151 00d6 JTOC4 RMB 3 0152 00d9 JTOC3 RMB 3 0153 00dc JTOC2 RMB 3 0154 00df JTOC1 RMB 3 0155 00e2 JTIC3 RMB 3 0156 00e5 JTIC2 RMB 3 0157 00e8 JTIC1 RMB 3 0158 00eb JRTI RMB 3 0159 00ee JIRQ RMB 3 0160 00f1 JXIRQ RMB 3 0161 00f4 JSWI RMB 3 0162 00f7 JILLOP RMB 3 0163 00fa JCOP RMB 3 0164 00fd JCLM RMB 3 0165 ***************************************************** 0166 * USER PRGRAM AREA for 27256 0167 ***************************************************** 0168 * ORG $8000 0169 * FCC 'VERSION 96 V1.0' 0170 0171 0172 0173 ***************** 0174 * 0175 * ROM starts here * 0176 * 0177 ***************** 0178 0179 e000 ORG ROMBS 0180 0181 ***************** 0182 ** BUFFALO - This is where Buffalo starts 0183 ** out of reset. All initialization is done 0184 ** here. 0185 ***************** 0186 * ROUTINE TO PUT HELLO WORLD ON LCD 0187 * 0188 e000 8e 00 5f BUFFALO LDS #STACK ;SET STACK 0189 e003 b6 11 00 LDAA $1100 ;READ THE 74HC244 0190 e006 b7 11 00 STAA $1100 ;WRITE BACK TO 74HC273 0191 e009 ce ff ff LDX #$FFFF ;GIVE LCD TIME TO RESET 0192 e00c 09 JKD DEX 0193 e00d 26 fd BNE JKD 0194 e00f bd e0 37 JSR CLRLCD ;SET UP LCD 0195 e012 ce e0 87 LDX #RESMES ;PRINT POWER ON RESET 0196 e015 bd e0 53 JSR LCDTEXT ; 0197 e018 ce ff ff LDX #$FFFF ;DELAY 0198 e01b 09 JKD1 DEX ; 0199 e01c 26 fd BNE JKD1 ; 0200 e01e 86 01 LDA #$01 ;CLEAR SCRN 0201 e020 bd e0 96 JSR WCTRL ; 0202 e023 ce e0 66 LDX #HELLO ;PRINT HELLO WORD 0203 e026 bd e0 53 JSR LCDTEXT ;DISPLAY A LINE OF TEXT 0204 e029 86 c0 LDA #$C0 ;ADDRESS OF SECOND LINE 0205 e02b bd e0 96 JSR WCTRL ;WRITE CONTROL BYTE TO LCD 0206 e02e ce e0 76 LDX #HELLO1 ;SEND SECOND LINE 0207 e031 bd e0 53 JSR LCDTEXT ;DISPLAY A LINE OF TEXT 0208 e034 7e e0 b0 JMP BUFISIT 0209 *************************************************** 0210 * SET UP LCD 0211 *************************************************** 0212 0213 e037 36 CLRLCD PSHA 0214 e038 86 01 LDAA #$01 0215 e03a bd e0 96 JSR WCTRL ;CLEAR LCD 0216 e03d 86 02 LDAA #$02 0217 e03f bd e0 96 JSR WCTRL ;HOME CURSOR 0218 e042 86 38 LDAA #$38 0219 e044 bd e0 96 JSR WCTRL ;SET 8 BIT, 2 LINE, 5X7 0220 e047 86 0c LDAA #$0C 0221 e049 bd e0 96 JSR WCTRL ;DISPLAY ON, CURSOR OFF 0222 e04c 86 06 LDAA #$06 0223 e04e bd e0 96 JSR WCTRL ;ENTRY MODE - INC ADDR, NO SHIFT 0224 e051 32 PULA 0225 e052 39 RTS 0226 *************************************************** 0227 * SEND A LINE OF TEXT TO LCD 0228 * PASS START ADDRESS OF TEXT IN X 0229 * TEXT STRING TERMINATED BY $00 OR $04 0230 *************************************************** 0231 e053 36 LCDTEXT PSHA 0232 e054 a6 00 LCD LDAA 0,X ;GET BYTE FROM MESSAGE TABLE 0233 e056 81 00 CMPA #$00 ;Check for end of string 0234 e058 27 0a BEQ DLCD ;$00 OR $04 0235 e05a 81 04 CMPA #$04 0236 e05c 27 06 BEQ DLCD 0237 e05e bd e0 a3 JSR WDAT ;SEND CHARACTER TO LCD 0238 e061 08 INX 0239 e062 20 f0 BRA LCD 0240 e064 32 DLCD PULA 0241 e065 39 RTS 0242 **************************************************** 0243 * MESSAGES 0244 **************************************************** 0245 0246 e066 48 45 4c 4c 4f 20 HELLO FCC 'HELLO WORLD V96' 57 4f 52 4c 44 20 56 39 36 0247 e075 00 FCB $00 0248 e076 48 43 31 31 20 4d HELLO1 FCC 'HC11 MPP (C)1996' 50 50 20 28 43 29 31 39 39 36 0249 e086 00 FCB $00 0250 e087 50 4f 57 45 52 20 RESMES FCC 'POWER ON RESET' 4f 4e 20 52 45 53 45 54 0251 e095 00 FCB $00 0252 ************************************************** 0253 * OUPUT CONTROL BYTE TO LCD 0254 ************************************************** 0255 e096 37 WCTRL PSHB 0256 e097 b7 14 00 STA $1400 0257 e09a f6 14 00 WCTRLL LDAB $1400 0258 e09d c4 80 ANDB #$80 0259 e09f 26 f9 BNE WCTRLL 0260 e0a1 33 PULB 0261 e0a2 39 RTS 0262 *************************************************** 0263 * OUTPUT DATA BYTE TO LCD 0264 *************************************************** 0265 e0a3 37 WDAT PSHB 0266 e0a4 b7 14 01 STA $1401 0267 e0a7 f6 14 00 WDATL LDAB $1400 0268 e0aa c4 80 ANDB #$80 0269 e0ac 26 f9 BNE WDATL 0270 e0ae 33 PULB 0271 e0af 39 RTS 0272 * 0273 * MODIFIED TO USE ONLY SERIAL PORT ON MPP BOARD 0274 * CODE THAT JUMPS TO EEPROM AT START REMOVED 0275 * 0276 e0b0 86 93 BUFISIT LDAA #$93 0277 e0b2 b7 10 39 STAA OPTION adpu, dly, irqe, cop 0278 e0b5 86 00 LDAA #$00 0279 e0b7 b7 10 24 STAA TMSK2 timer pre = %1 for trace 0280 e0ba 86 00 LDAA #$00 0281 e0bc b7 10 35 STAA BPROT clear 'E9 eeprom block protect 0282 e0bf ce b6 00 LDX #DSTREE set up default eeprom address range 0283 e0c2 df 98 STX STREE 0284 e0c4 ce b7 ff LDX #DENDEE 0285 e0c7 df 9a STX ENDEE 0286 e0c9 ce 00 00 LDX #$0000 set up default download offset 0287 e0cc df ac STX LDOFFST 0288 e0ce 8e 00 5f LDS #STACK monitor stack pointer 0289 e0d1 bd e3 8c JSR VECINIT 0290 e0d4 ce 00 41 LDX #USTACK 0291 e0d7 df 69 STX SP default user stack 0292 e0d9 b6 10 20 LDAA TCTL1 0293 e0dc 8a 03 ORAA #$03 0294 e0de b7 10 20 STAA TCTL1 force oc5 pin high for trace 0295 e0e1 86 d0 LDAA #$D0 0296 e0e3 97 68 STAA REGS+8 default user ccr 0297 e0e5 cc 3f 0d LDD #$3F0D initial command is ? 0298 e0e8 dd 6b STD INBUFF 0299 e0ea bd e1 fd JSR BPCLR clear breakpoints 0300 e0ed 7f 00 a4 CLR AUTOLF 0301 e0f0 7c 00 a4 INC AUTOLF auto cr/lf = on 0302 0303 * Determine type of external comm device - none, or acia * 0304 0305 e0f3 7f 00 a6 CLR EXTDEV default is none 0306 * LDAA HPRIO 0307 * ANDA #$20 0308 * BEQ BUFF2 jump if single chip mode 0309 * LDAA #$03 see if external acia exists 0310 * STAA ACIA master reset 0311 * LDAA ACIA 0312 * ANDA #$7F mask irq bit from status register 0313 * BNE BUFF1 jump if status reg not 0 0314 * LDAA #$12 0315 * STAA ACIA turn on acia 0316 * LDAA ACIA 0317 * ANDA #$02 0318 * BEQ BUFF1 jump if tdre not set 0319 * LDAA #$01 0320 * STAA EXTDEV external device is acia 0321 * BRA BUFF2 0322 * 0323 *BUFF1 EQU * see if duart exists 0324 * LDAA DUART+$0C read IRQ vector register 0325 * CMPA #$0F should be out of reset 0326 * BNE BUFF2 0327 * LDAA #$AA 0328 * STAA DUART+$0C write irq vector register 0329 * LDAA DUART+$0C read irq vector register 0330 * CMPA #$AA 0331 * BNE BUFF2 0332 * LDAA #$02 0333 * STAA EXTDEV external device is duart A 0334 0335 * Find terminal port - SCI or external. * 0336 0337 e0f6 7f 00 a5 BUFF2 CLR IODEV 0338 * JSR TARGCO disconnect sci for evb board 0339 e0f9 bd e1 06 JSR SIGNON initialize sci 0340 * LDAA EXTDEV 0341 * BEQ BUFF3 jump if no external device 0342 * STAA IODEV 0343 * JSR SIGNON initialize external device 0344 e0fc 7f 00 a5 BUFF3 CLR IODEV 0345 e0ff bd e3 b5 JSR INPUT get input from sci port 0346 e102 81 0d CMPA #$0D 0347 e104 20 0a BRA BUFF4 jump if cr - sci is terminal port 0348 * LDAA EXTDEV 0349 * BEQ BUFF3 jump if no external device 0350 * STAA IODEV 0351 * JSR INPUT get input from external device 0352 * CMPA #$0D 0353 * BEQ BUFF4 jump if cr - terminal found ext 0354 * BRA BUFF3 0355 0356 e106 bd e3 ad SIGNON JSR INIT initialize device 0357 e109 ce e6 57 LDX #MSG1 buffalo message 0358 e10c bd e5 2f JSR OUTSTRG 0359 e10f 39 RTS 0360 0361 * Determine where host port should be. * 0362 0363 e110 7f 00 a7 BUFF4 CLR HOSTDEV default - host = sci port 0364 * LDAA IODEV 0365 * CMPA #$01 0366 * BEQ BUFF5 default host if term = acia 0367 * LDAA #$03 0368 * STAA HOSTDEV else host is duart port b 0369 e113 BUFF5 EQU * 0370 * add switch to user routine in rom 0371 0372 * LDAA $1100 0373 * ANDA #$01 0374 * BEQ MAIN 0375 * JMP $8500 0376 ***************** 0377 ** MAIN - This module reads the user's input into 0378 ** a buffer called INBUFF. The first field (assumed 0379 ** to be the command field) is then parsed into a 0380 ** second buffer called COMBUFF. The command table 0381 ** is then searched for the contents of COMBUFF and 0382 ** if found, the address of the corresponding task 0383 ** routine is fetched from the command table. The 0384 ** task is then called as a subroutine so that 0385 ** control returns back to here upon completion of 0386 ** the task. Buffalo expects the following format 0387 ** for commands: 0388 ** [...] 0389 ** [] implies contents optional. 0390 ** means whitespace character (space,comma,tab). 0391 ** = command string of 1-8 characters. 0392 ** = Argument particular to the command. 0393 ** = Carriage return signifying end of input string. 0394 ***************** 0395 * Prompt user 0396 *do 0397 * a=input(); 0398 * if(a==(cntlx or del)) continue; 0399 * elseif(a==backspace) 0400 * b--; 0401 * if(b<0) b=0; 0402 * else 0403 * if(a==cr && buffer empty) 0404 * repeat last command; 0405 * else put a into buffer; 0406 * check if buffer full; 0407 *while(a != (cr or /) 0408 e113 0f MAIN SEI block interrupts 0409 e114 8e 00 5f LDS #STACK initialize sp every time 0410 e117 7f 00 a4 CLR AUTOLF 0411 e11a 7c 00 a4 INC AUTOLF auto cr/lf = on 0412 e11d bd e5 1f JSR OUTCRLF 0413 e120 86 3e LDAA #PROMPT prompt user 0414 e122 bd e3 e1 JSR OUTPUT 0415 e125 5f CLRB 0416 e126 bd e5 5b MAIN1 JSR INCHAR read terminal 0417 e129 ce 00 6b LDX #INBUFF 0418 e12c 3a ABX pointer into buffer 0419 e12d 81 18 CMPA #CTLX 0420 e12f 27 e2 BEQ MAIN jump if cntl X 0421 e131 81 7f CMPA #DEL 0422 e133 27 de BEQ MAIN jump if del 0423 e135 81 08 CMPA #$08 0424 e137 26 05 BNE MAIN2 jump if not bckspc 0425 e139 5a DECB 0426 e13a 2d d7 BLT MAIN jump if buffer empty 0427 e13c 20 e8 BRA MAIN1 0428 e13e 81 0d MAIN2 CMPA #$D 0429 e140 26 07 BNE MAIN3 jump if not cr 0430 e142 5d TSTB 0431 e143 27 17 BEQ COMM0 jump if buffer empty 0432 e145 a7 00 STAA ,X put a in buffer 0433 e147 20 13 BRA COMM0 0434 e149 a7 00 MAIN3 STAA ,X put a in buffer 0435 e14b 5c INCB 0436 e14c c1 23 CMPB #BUFFLNG 0437 e14e 2f 08 BLE MAIN4 jump if not long 0438 e150 ce e6 a1 LDX #MSG3 "long" 0439 e153 bd e5 2f JSR OUTSTRG 0440 e156 20 bb BRA MAIN 0441 e158 81 2f MAIN4 CMPA #'/' 0442 e15a 26 ca BNE MAIN1 jump if not "/" 0443 * ******************* 0444 0445 ***************** 0446 * Parse out and evaluate the command field. 0447 ***************** 0448 *Initialize 0449 0450 e15c COMM0 EQU * 0451 e15c 7f 00 c0 CLR TMP1 Enable "/" command 0452 e15f 7f 00 96 CLR SHFTREG 0453 e162 7f 00 97 CLR SHFTREG+1 0454 e165 5f CLRB 0455 e166 ce 00 6b LDX #INBUFF ptrbuff[] = inbuff[] 0456 e169 df ae STX PTR0 0457 e16b bd e3 4b JSR WSKIP find first char 0458 0459 *while((a=readbuff) != (cr or wspace)) 0460 * upcase(a); 0461 * buffptr[b] = a 0462 * b++ 0463 * if (b > 8) error(too long); 0464 * if(a == "/") 0465 * if(enabled) mslash(); 0466 * else error(command?); 0467 * else hexbin(a); 0468 0469 e16e COMM1 EQU * 0470 e16e bd e3 36 JSR READBUFF read from buffer 0471 e171 ce 00 8e LDX #COMBUFF 0472 e174 3a ABX 0473 e175 bd e1 f2 JSR UPCASE convert to upper case 0474 e178 a7 00 STAA ,X put in command buffer 0475 e17a 81 0d CMPA #$0D 0476 e17c 27 36 BEQ SRCH jump if cr 0477 e17e bd e3 5b JSR WCHEK 0478 e181 27 31 BEQ SRCH jump if wspac 0479 e183 bd e3 3d JSR INCBUFF move buffer pointer 0480 e186 5c INCB 0481 e187 c1 08 CMPB #$8 0482 e189 2f 09 BLE COMM2 0483 e18b ce e6 a1 LDX #MSG3 "long" 0484 e18e bd e5 2f JSR OUTSTRG 0485 e191 7e e1 13 JMP MAIN 0486 0487 e194 COMM2 EQU * 0488 e194 81 2f CMPA #'/' 0489 e196 26 17 BNE COMM4 jump if not "/" 0490 e198 7d 00 c0 TST TMP1 0491 e19b 26 09 BNE COMM3 jump if not enabled 0492 e19d 5a DECB 0493 e19e d7 a8 STAB COUNT 0494 e1a0 ce e9 2e LDX #MSLASH 0495 e1a3 7e e1 ed JMP EXEC execute "/" 0496 e1a6 ce e6 b9 COMM3 LDX #MSG8 "command?" 0497 e1a9 bd e5 2f JSR OUTSTRG 0498 e1ac 7e e1 13 JMP MAIN 0499 e1af COMM4 EQU * 0500 e1af bd e2 4c JSR HEXBIN 0501 e1b2 20 ba BRA COMM1 0502 0503 ***************** 0504 * Search tables for command. At this point, 0505 * COMBUFF holds the command field to be executed, 0506 * and B = # of characters in the command field. 0507 * The command table holds the whole command name 0508 * but only the first n characters of the command 0509 * must match what is in COMBUFF where n is the 0510 * number of characters entered by the user. 0511 ***************** 0512 *count = b; 0513 *ptr1 = comtabl; 0514 *while(ptr1[0] != end of table) 0515 * ptr1 = next entry 0516 * for(b=1; b=count; b++) 0517 * if(ptr1[b] == combuff[b]) continue; 0518 * else error(not found); 0519 * execute task; 0520 * return(); 0521 *return(command not found); 0522 0523 e1b4 d7 a8 SRCH STAB COUNT size of command entered 0524 e1b6 ce e5 65 LDX #COMTABL pointer to table 0525 e1b9 df b0 STX PTR1 pointer to next entry 0526 e1bb de b0 SRCH1 LDX PTR1 0527 e1bd 18 ce 00 8e LDY #COMBUFF pointer to command buffer 0528 e1c1 e6 00 LDAB 0,X 0529 e1c3 c1 ff CMPB #$FF 0530 e1c5 26 09 BNE SRCH2 0531 e1c7 ce e6 9b LDX #MSG2 "command not found" 0532 e1ca bd e5 2f JSR OUTSTRG 0533 e1cd 7e e1 13 JMP MAIN 0534 e1d0 3c SRCH2 PSHX compute next table entry 0535 e1d1 cb 03 ADDB #$3 0536 e1d3 3a ABX 0537 e1d4 df b0 STX PTR1 0538 e1d6 38 PULX 0539 e1d7 5f CLRB 0540 e1d8 5c SRCHLP INCB match characters loop 0541 e1d9 a6 01 LDAA 1,X read table 0542 e1db 18 a1 00 CMPA 0,Y compare to combuff 0543 e1de 26 db BNE SRCH1 try next entry 0544 e1e0 08 INX move pointers 0545 e1e1 18 08 INY 0546 e1e3 d1 a8 CMPB COUNT 0547 e1e5 2d f1 BLT SRCHLP loop countu1 times 0548 e1e7 de b0 LDX PTR1 0549 e1e9 09 DEX 0550 e1ea 09 DEX 0551 e1eb ee 00 LDX 0,X jump address from table 0552 e1ed ad 00 EXEC JSR 0,X call task as subroutine 0553 e1ef 7e e1 13 JMP MAIN 0554 * 0555 ***************** 0556 * UTILITY SUBROUTINES - These routines 0557 * are called by any of the task routines. 0558 ***************** 0559 ***************** 0560 * UPCASE(a) - If the contents of A is alpha, 0561 * returns a converted to uppercase. 0562 ***************** 0563 e1f2 81 61 UPCASE CMPA #'a' 0564 e1f4 2d 06 BLT UPCASE1 jump if < a 0565 e1f6 81 7a CMPA #'z' 0566 e1f8 2e 02 BGT UPCASE1 jump if > z 0567 e1fa 80 20 SUBA #$20 convert 0568 e1fc 39 UPCASE1 RTS 0569 0570 ***************** 0571 * BPCLR() - Clear all entries in the 0572 * table of breakpoints. 0573 ***************** 0574 e1fd ce 00 9c BPCLR LDX #BRKTABL 0575 e200 c6 08 LDAB #8 0576 e202 6f 00 BPCLR1 CLR 0,X 0577 e204 08 INX 0578 e205 5a DECB 0579 e206 2e fa BGT BPCLR1 loop 8 times 0580 e208 39 RTS 0581 0582 ***************** 0583 * RPRNT1(x) - Prints name and contents of a single 0584 * user register. On entry X points to name of register 0585 * in reglist. On exit, a=register name. 0586 ***************** 0587 e209 50 59 58 41 42 43 REGLIST FCC 'PYXABCS' names 53 0588 e210 00 02 04 06 07 08 FCB 0,2,4,6,7,8,9 offset 09 0589 e217 01 01 01 00 00 00 FCB 1,1,1,0,0,0,1 size 01 0590 e21e a6 00 RPRNT1 LDAA 0,X 0591 e220 36 PSHA 0592 e221 3c PSHX 0593 e222 bd e3 e1 JSR OUTPUT name 0594 e225 86 2d LDAA #'-' 0595 e227 bd e3 e1 JSR OUTPUT dash 0596 e22a e6 07 LDAB 7,X contents offset 0597 e22c a6 0e LDAA 14,X bytesize 0598 e22e ce 00 60 LDX #REGS address 0599 e231 3a ABX 0600 e232 4d TSTA 0601 e233 27 03 BEQ RPRN2 jump if 1 byte 0602 e235 bd e5 07 JSR OUT1BYT 2 bytes 0603 e238 bd e5 16 RPRN2 JSR OUT1BSP 0604 e23b 38 PULX 0605 e23c 32 PULA 0606 e23d 39 RTS 0607 0608 ***************** 0609 * RPRINT() - Print the name and contents 0610 * of all the user registers. 0611 ***************** 0612 e23e 3c RPRINT PSHX 0613 e23f ce e2 09 LDX #REGLIST 0614 e242 bd e2 1e RPRI1 JSR RPRNT1 print name 0615 e245 08 INX 0616 e246 81 53 CMPA #'S' s is last register 0617 e248 26 f8 BNE RPRI1 jump if not done 0618 e24a 38 PULX 0619 e24b 39 RTS 0620 0621 ***************** 0622 * HEXBIN(a) - Convert the ASCII character in a 0623 * to binary and shift into shftreg. Returns value 0624 * in tmp1 incremented if a is not hex. 0625 ***************** 0626 e24c 36 HEXBIN PSHA 0627 e24d 37 PSHB 0628 e24e 3c PSHX 0629 e24f bd e1 f2 JSR UPCASE convert to upper case 0630 e252 81 30 CMPA #'0' 0631 e254 2d 22 BLT HEXNOT jump if a < $30 0632 e256 81 39 CMPA #'9' 0633 e258 2f 0a BLE HEXNMB jump if 0-9 0634 e25a 81 41 CMPA #'A' 0635 e25c 2d 1a BLT HEXNOT jump if $39> a <$41 0636 e25e 81 46 CMPA #'F' 0637 e260 2e 16 BGT HEXNOT jump if a > $46 0638 e262 8b 09 ADDA #$9 convert $A-$F 0639 e264 84 0f HEXNMB ANDA #$0F convert to binary 0640 e266 ce 00 96 LDX #SHFTREG 0641 e269 c6 04 LDAB #4 0642 e26b 68 01 HEXSHFT ASL 1,X 2 byte shift through 0643 e26d 69 00 ROL 0,X carry bit 0644 e26f 5a DECB 0645 e270 2e f9 BGT HEXSHFT shift 4 times 0646 e272 aa 01 ORAA 1,X 0647 e274 a7 01 STAA 1,X 0648 e276 20 03 BRA HEXRTS 0649 e278 7c 00 c0 HEXNOT INC TMP1 indicate not hex 0650 e27b 38 HEXRTS PULX 0651 e27c 33 PULB 0652 e27d 32 PULA 0653 e27e 39 RTS 0654 0655 ***************** 0656 * BUFFARG() - Build a hex argument from the 0657 * contents of the input buffer. Characters are 0658 * converted to binary and shifted into shftreg 0659 * until a non-hex character is found. On exit 0660 * shftreg holds the last four digits read, count 0661 * holds the number of digits read, ptrbuff points 0662 * to the first non-hex character read, and A holds 0663 * that first non-hex character. 0664 ***************** 0665 *Initialize 0666 *while((a=readbuff()) not hex) 0667 * hexbin(a); 0668 *return(); 0669 0670 e27f 7f 00 c0 BUFFARG CLR TMP1 not hex indicator 0671 e282 7f 00 a8 CLR COUNT # or digits 0672 e285 7f 00 96 CLR SHFTREG 0673 e288 7f 00 97 CLR SHFTREG+1 0674 e28b bd e3 4b JSR WSKIP 0675 e28e bd e3 36 BUFFLP JSR READBUFF read char 0676 e291 bd e2 4c JSR HEXBIN 0677 e294 7d 00 c0 TST TMP1 0678 e297 26 08 BNE BUFFRTS jump if not hex 0679 e299 7c 00 a8 INC COUNT 0680 e29c bd e3 3d JSR INCBUFF move buffer pointer 0681 e29f 20 ed BRA BUFFLP 0682 e2a1 39 BUFFRTS RTS 0683 0684 ***************** 0685 * TERMARG() - Build a hex argument from the 0686 * terminal. Characters are converted to binary 0687 * and shifted into shftreg until a non-hex character 0688 * is found. On exit shftreg holds the last four 0689 * digits read, count holds the number of digits 0690 * read, and A holds the first non-hex character. 0691 ***************** 0692 *initialize 0693 *while((a=inchar()) == hex) 0694 * if(a = cntlx or del) 0695 * abort; 0696 * else 0697 * hexbin(a); countu1++; 0698 *return(); 0699 0700 e2a2 7f 00 a8 TERMARG CLR COUNT 0701 e2a5 7f 00 96 CLR SHFTREG 0702 e2a8 7f 00 97 CLR SHFTREG+1 0703 e2ab bd e5 5b TERM0 JSR INCHAR 0704 e2ae 81 18 CMPA #CTLX 0705 e2b0 27 04 BEQ TERM1 jump if controlx 0706 e2b2 81 7f CMPA #DEL 0707 e2b4 26 03 BNE TERM2 jump if not delete 0708 e2b6 7e e1 13 TERM1 JMP MAIN abort 0709 e2b9 7f 00 c0 TERM2 CLR TMP1 hex indicator 0710 e2bc bd e2 4c JSR HEXBIN 0711 e2bf 7d 00 c0 TST TMP1 0712 e2c2 26 05 BNE TERM3 jump if not hex 0713 e2c4 7c 00 a8 INC COUNT 0714 e2c7 20 e2 BRA TERM0 0715 e2c9 39 TERM3 RTS 0716 0717 ***************** 0718 * CHGBYT() - If shftreg is not empty, put 0719 * contents of shftreg at address in X. If X 0720 * is an address in EEPROM then program it. 0721 ***************** 0722 *if(count != 0) 0723 * (x) = a; 0724 e2ca 7d 00 a8 CHGBYT TST COUNT 0725 e2cd 27 05 BEQ CHGBYT4 quit if shftreg empty 0726 e2cf 96 97 LDAA SHFTREG+1 get data into a 0727 e2d1 bd e2 d5 JSR WRITE 0728 e2d4 39 CHGBYT4 RTS 0729 0730 0731 ***************** 0732 * WRITE() - This routine is used to write the 0733 *contents of A to the address of X. If the 0734 *address is in EEPROM, it will be programmed 0735 *and if it is already programmed, it will be 0736 *byte erased first. 0737 ****************** 0738 *if(X == config) then 0739 * byte erase config; 0740 *if(X is eeprom)then 0741 * if(not erased) then erase; 0742 * program (x) = A; 0743 *write (x) = A; 0744 *if((x) != A) error(rom); 0745 e2d5 WRITE EQU * 0746 e2d5 8c 10 3f CPX #CONFIG 0747 e2d8 27 10 BEQ WRITE0 jump if config 0748 e2da 9c 98 CPX STREE start of EE 0749 e2dc 25 12 BLO WRITE2 jump if not EE 0750 e2de 9c 9a CPX ENDEE end of EE 0751 e2e0 22 0e BHI WRITE2 jump if not EE 0752 e2e2 37 WRITEE PSHB check if byte erased 0753 e2e3 e6 00 LDAB 0,X 0754 e2e5 c1 ff CMPB #$FF 0755 e2e7 33 PULB 0756 e2e8 27 03 BEQ WRITE1 jump if erased 0757 e2ea bd e3 0b WRITE0 JSR EEBYTE byte erase 0758 e2ed bd e2 ff WRITE1 JSR EEWRIT byte program 0759 e2f0 a7 00 WRITE2 STAA 0,X write for non EE 0760 e2f2 a1 00 CMPA 0,X 0761 e2f4 27 08 BEQ WRITE3 jump if write ok 0762 e2f6 3c PSHX 0763 e2f7 ce e6 b4 LDX #MSG6 "rom" 0764 e2fa bd e5 2f JSR OUTSTRG 0765 e2fd 38 PULX 0766 e2fe 39 WRITE3 RTS 0767 0768 0769 ***************** 0770 * EEWRIT(), EEBYTE(), EEBULK() - 0771 * These routines are used to program and eeprom 0772 *locations. eewrite programs the address in X with 0773 *the value in A, eebyte does a byte address at X, 0774 *and eebulk does a bulk of eeprom. Whether eebulk 0775 *erases the config or not depends on the address it 0776 *receives in X. 0777 **************** 0778 e2ff EEWRIT EQU * program one byte at x 0779 e2ff 37 PSHB 0780 e300 c6 02 LDAB #$02 0781 e302 f7 10 3b STAB PPROG 0782 e305 a7 00 STAA 0,X 0783 e307 c6 03 LDAB #$03 0784 e309 20 18 BRA EEPROG 0785 *** 0786 e30b EEBYTE EQU * byte erase address x 0787 e30b 37 PSHB 0788 e30c c6 16 LDAB #$16 0789 e30e f7 10 3b STAB PPROG 0790 e311 c6 ff LDAB #$FF 0791 e313 e7 00 STAB 0,X 0792 e315 c6 17 LDAB #$17 0793 e317 20 0a BRA EEPROG 0794 *** 0795 e319 EEBULK EQU * bulk erase eeprom 0796 e319 37 PSHB 0797 e31a c6 06 LDAB #$06 0798 e31c f7 10 3b STAB PPROG 0799 e31f a7 00 STAA 0,X erase config or not ... 0800 e321 c6 07 LDAB #$07 ... depends on X addr 0801 e323 26 01 EEPROG BNE ACL1 0802 e325 5f CLRB fail safe 0803 e326 f7 10 3b ACL1 STAB PPROG 0804 e329 33 PULB 0805 *** 0806 e32a DLY10MS EQU * delay 10ms at E = 2MHz 0807 e32a 3c PSHX 0808 e32b ce 0d 06 LDX #$0D06 0809 e32e 09 DLYLP DEX 0810 e32f 26 fd BNE DLYLP 0811 e331 38 PULX 0812 e332 7f 10 3b CLR PPROG 0813 e335 39 RTS 0814 0815 0816 ***************** 0817 * READBUFF() - Read the character in INBUFF 0818 * pointed at by ptrbuff into A. Returns ptrbuff 0819 * unchanged. 0820 ***************** 0821 e336 3c READBUFF PSHX 0822 e337 de ae LDX PTR0 0823 e339 a6 00 LDAA 0,X 0824 e33b 38 PULX 0825 e33c 39 RTS 0826 0827 ***************** 0828 * INCBUFF(), DECBUFF() - Increment or decrement 0829 * ptrbuff. 0830 ***************** 0831 e33d 3c INCBUFF PSHX 0832 e33e de ae LDX PTR0 0833 e340 08 INX 0834 e341 20 04 BRA INCDEC 0835 e343 3c DECBUFF PSHX 0836 e344 de ae LDX PTR0 0837 e346 09 DEX 0838 e347 df ae INCDEC STX PTR0 0839 e349 38 PULX 0840 e34a 39 RTS 0841 0842 ***************** 0843 * WSKIP() - Read from the INBUFF until a 0844 * non whitespace (space, comma, tab) character 0845 * is found. Returns ptrbuff pointing to the 0846 * first non-whitespace character and a holds 0847 * that character. WSKIP also compares a to 0848 * $0D (CR) and cond codes indicating the 0849 * results of that compare. 0850 ***************** 0851 e34b bd e3 36 WSKIP JSR READBUFF read character 0852 e34e bd e3 5b JSR WCHEK 0853 e351 26 05 BNE WSKIP1 jump if not wspc 0854 e353 bd e3 3d JSR INCBUFF move pointer 0855 e356 20 f3 BRA WSKIP loop 0856 e358 81 0d WSKIP1 CMPA #$0D 0857 e35a 39 RTS 0858 0859 ***************** 0860 * WCHEK(a) - Returns z=1 if a holds a 0861 * whitespace character, else z=0. 0862 ***************** 0863 e35b 81 2c WCHEK CMPA #$2C comma 0864 e35d 27 06 BEQ WCHEK1 0865 e35f 81 20 CMPA #$20 space 0866 e361 27 02 BEQ WCHEK1 0867 e363 81 09 CMPA #$09 tab 0868 e365 39 WCHEK1 RTS 0869 0870 ***************** 0871 * DCHEK(a) - Returns Z=1 if a = whitespace 0872 * or carriage return. Else returns z=0. 0873 ***************** 0874 e366 bd e3 5b DCHEK JSR WCHEK 0875 e369 27 02 BEQ DCHEK1 jump if whitespace 0876 e36b 81 0d CMPA #$0D 0877 e36d 39 DCHEK1 RTS 0878 0879 ***************** 0880 * CHKABRT() - Checks for a control x or delete 0881 * from the terminal. If found, the stack is 0882 * reset and the control is transferred to main. 0883 * Note that this is an abnormal termination. 0884 * If the input from the terminal is a control W 0885 * then this routine keeps waiting until any other 0886 * character is read. 0887 ***************** 0888 *a=input(); 0889 *if(a=cntl w) wait until any other key; 0890 *if(a = cntl x or del) abort; 0891 0892 e36e bd e3 b5 CHKABRT JSR INPUT 0893 e371 27 18 BEQ CHK4 jump if no input 0894 e373 81 17 CMPA #CTLW 0895 e375 26 05 BNE CHK2 jump in not cntlw 0896 e377 bd e3 b5 CHKABRT1 JSR INPUT 0897 e37a 27 fb BEQ CHKABRT1 jump if no input 0898 e37c 81 7f CHK2 CMPA #DEL 0899 e37e 27 08 BEQ CHK3 jump if delete 0900 e380 81 18 CMPA #CTLX 0901 e382 27 04 BEQ CHK3 jump if control x 0902 e384 81 01 CMPA #CTLA 0903 e386 26 03 BNE CHK4 jump not control a 0904 e388 7e e1 13 CHK3 JMP MAIN abort 0905 e38b 39 CHK4 RTS return 0906 0907 *********************** 0908 * HOSTCO - connect sci to host for evb board. 0909 * TARGCO - connect sci to target for evb board. 0910 *********************** 0911 *HOSTCO PSHA 0912 * LDAA #$01 0913 * STAA DFLOP send 1 to d-flop 0914 * PULA 0915 * RTS 0916 0917 *TARGCO PSHA 0918 * LDAA #$00 0919 * STAA DFLOP send 0 to d-flop 0920 * PULA 0921 * RTS 0922 0923 * 0924 ********** 0925 * 0926 * VECINIT - This routine checks for 0927 * vectors in the RAM table. All 0928 * uninitialized vectors are programmed 0929 * to JMP STOPIT 0930 * 0931 ********** 0932 * 0933 e38c ce 00 c4 VECINIT LDX #JSCI Point to First RAM Vector 0934 e38f 18 ce e3 a6 LDY #STOPIT Pointer to STOPIT routine 0935 e393 cc 7e 03 LDD #$7E03 A=JMP opcode; B=offset 0936 e396 a1 00 VECLOOP CMPA 0,X 0937 e398 27 05 BEQ VECNEXT If vector already in 0938 e39a a7 00 STAA 0,X install JMP 0939 e39c 1a ef 01 STY 1,X to STOPIT routine 0940 e39f 3a VECNEXT ABX Add 3 to point at next vector 0941 e3a0 8c 01 00 CPX #JCLM+3 Done? 0942 e3a3 26 f1 BNE VECLOOP If not, continue loop 0943 e3a5 39 RTS 0944 * 0945 e3a6 86 50 STOPIT LDAA #$50 Stop-enable; IRQ, XIRQ-Off 0946 e3a8 06 TAP 0947 e3a9 cf STOP You are lost! Shut down 0948 e3aa 7e e3 a6 JMP STOPIT In case continue by XIRQ 0949 0950 ********** 0951 * 0952 * I/O MODULE 0953 * Communications with the outside world. 0954 * 3 I/O routines (INIT, INPUT, and OUTPUT) call 0955 * drivers specified by IODEV (0=SCI, 1=ACIA, 0956 * 2=DUARTA, 3=DUARTB). 0957 * 0958 ********** 0959 * INIT() - Initialize device specified by iodev. 0960 ********* 0961 * 0962 e3ad INIT EQU * 0963 e3ad 36 PSHA save registers 0964 e3ae 3c PSHX 0965 * LDAA IODEV 0966 * CMPA #$00 0967 * BNE INIT1 jump not sci 0968 e3af bd e4 60 JSR ONSCI initialize sci 0969 * BRA INIT4 0970 *INIT1 CMPA #$01 0971 * BNE INIT2 jump not acia 0972 * JSR ONACIA initialize acia 0973 * BRA INIT4 0974 *INIT2 LDX #PORTA 0975 * CMPA #$02 0976 * BEQ INIT3 jump duart a 0977 * LDX #PORTB 0978 *INIT3 JSR ONUART initialize duart 0979 e3b2 38 INIT4 PULX restore registers 0980 e3b3 32 PULA 0981 e3b4 39 RTS 0982 0983 ********** 0984 * INPUT() - Read device. Returns a=char or 0. 0985 * This routine also disarms the cop. 0986 ********** 0987 e3b5 INPUT EQU * 0988 e3b5 3c PSHX 0989 e3b6 86 55 LDAA #$55 reset cop 0990 e3b8 b7 10 3a STAA COPRST 0991 e3bb 86 aa LDAA #$AA 0992 e3bd b7 10 3a STAA COPRST 0993 e3c0 96 a5 LDAA IODEV 0994 e3c2 26 05 BNE INPUT1 jump not sci 0995 e3c4 bd e4 70 JSR INSCI read sci 0996 e3c7 20 16 BRA INPUT4 0997 e3c9 81 01 INPUT1 CMPA #$01 0998 e3cb 26 05 BNE INPUT2 jump not acia 0999 e3cd bd e4 ab JSR INACIA read acia 1000 e3d0 20 0d BRA INPUT4 1001 e3d2 ce d0 00 INPUT2 LDX #PORTA 1002 e3d5 81 02 CMPA #$02 1003 e3d7 27 03 BEQ INPUT3 jump if duart a 1004 e3d9 ce d0 08 LDX #PORTB 1005 e3dc bd e4 35 INPUT3 JSR INUART read uart 1006 e3df 38 INPUT4 PULX 1007 e3e0 39 RTS 1008 1009 ********** 1010 * OUTPUT() - Output character in A. 1011 * chrcnt indicates the current column on the 1012 *output display. It is incremented every time 1013 *a character is outputted, and cleared whenever 1014 *the subroutine outcrlf is called. 1015 ********** 1016 1017 e3e1 OUTPUT EQU * 1018 e3e1 36 PSHA save registers 1019 e3e2 37 PSHB 1020 e3e3 3c PSHX 1021 e3e4 d6 a5 LDAB IODEV 1022 e3e6 26 05 BNE OUTPUT1 jump not sci 1023 e3e8 bd e4 7d JSR OUTSCI write sci 1024 e3eb 20 16 BRA OUTPUT4 1025 e3ed c1 01 OUTPUT1 CMPB #$01 1026 e3ef 26 05 BNE OUTPUT2 jump not acia 1027 e3f1 bd e4 c5 JSR OUTACIA write acia 1028 e3f4 20 0d BRA OUTPUT4 1029 e3f6 ce d0 00 OUTPUT2 LDX #PORTA 1030 e3f9 c1 02 CMPB #$02 1031 e3fb 27 03 BEQ OUTPUT3 jump if duart a 1032 e3fd ce d0 08 LDX #PORTB 1033 e400 bd e4 40 OUTPUT3 JSR OUTUART write uart 1034 e403 38 OUTPUT4 PULX 1035 e404 33 PULB 1036 e405 32 PULA 1037 e406 7c 00 a9 INC CHRCNT increment column count 1038 e409 39 RTS 1039 1040 ********** 1041 * ONUART(port) - Initialize a duart port. 1042 * Sets duart to internal clock, divide by 16, 1043 * 8 data + 1 stop bits. 1044 ********** 1045 1046 e40a 86 22 ONUART LDAA #$22 1047 e40c a7 02 STAA 2,X reset receiver 1048 e40e 86 38 LDAA #$38 1049 e410 a7 02 STAA 2,X reset transmitter 1050 e412 86 40 LDAA #$40 1051 e414 a7 02 STAA 2,X reset error status 1052 e416 86 10 LDAA #$10 1053 e418 a7 02 STAA 2,X reset pointer 1054 e41a 86 00 LDAA #$00 1055 e41c b7 d0 04 STAA DUART+4 clock source 1056 e41f 86 00 LDAA #$00 1057 e421 b7 d0 05 STAA DUART+5 interrupt mask 1058 e424 86 13 LDAA #$13 1059 e426 a7 00 STAA 0,X 8 data, no parity 1060 e428 86 07 LDAA #$07 1061 e42a a7 00 STAA 0,X 1 stop bits 1062 e42c 86 bb LDAA #$BB baud rate (9600) 1063 e42e a7 01 STAA 1,X tx and rcv baud rate 1064 e430 86 05 LDAA #$05 1065 e432 a7 02 STAA 2,X enable tx and rcv 1066 e434 39 RTS 1067 1068 ********** 1069 * INUART(port) - Check duart for any input. 1070 ********** 1071 e435 a6 01 INUART LDAA 1,X read status 1072 e437 84 01 ANDA #$01 check rxrdy 1073 e439 27 04 BEQ INUART1 jump if no data 1074 e43b a6 03 LDAA 3,X read data 1075 e43d 84 7f ANDA #$7F mask parity 1076 e43f 39 INUART1 RTS 1077 1078 ********** 1079 * OUTUART(port) - Output the character in a. 1080 * if autolf=1, transmits cr or lf as crlf. 1081 ********** 1082 e440 7d 00 a4 OUTUART TST AUTOLF 1083 e443 27 10 BEQ OUTUART2 jump if no autolf 1084 e445 8d 0e BSR OUTUART2 1085 e447 81 0d CMPA #$0D 1086 e449 26 04 BNE OUTUART1 1087 e44b 86 0a LDAA #$0A if cr, output lf 1088 e44d 20 06 BRA OUTUART2 1089 e44f 81 0a OUTUART1 CMPA #$0A 1090 e451 26 0c BNE OUTUART3 1091 e453 86 0d LDAA #$0D if lf, output cr 1092 e455 e6 01 OUTUART2 LDAB 1,X check status 1093 e457 c4 04 ANDB #$4 1094 e459 27 fa BEQ OUTUART2 loop until tdre=1 1095 e45b 84 7f ANDA #$7F mask parity 1096 e45d a7 03 STAA 3,X send character 1097 e45f 39 OUTUART3 RTS 1098 1099 ********** 1100 * ONSCI() - Initialize the SCI for 9600 1101 * baud at 8 MHz Extal. 1102 ********** 1103 e460 86 30 ONSCI LDAA #$30 1104 e462 b7 10 2b STAA BAUD baud register 1105 e465 86 00 LDAA #$00 1106 e467 b7 10 2c STAA SCCR1 1107 e46a 86 0c LDAA #$0C 1108 e46c b7 10 2d STAA SCCR2 enable 1109 e46f 39 RTS 1110 1111 ********** 1112 * INSCI() - Read from SCI. Return a=char or 0. 1113 ********** 1114 e470 b6 10 2e INSCI LDAA SCSR read status reg 1115 e473 84 20 ANDA #$20 check rdrf 1116 e475 27 05 BEQ INSCI1 jump if no data 1117 e477 b6 10 2f LDAA SCDAT read data 1118 e47a 84 7f ANDA #$7F mask parity 1119 e47c 39 INSCI1 RTS 1120 1121 ********** 1122 * OUTSCI() - Output A to sci. IF autolf = 1, 1123 * cr and lf sent as crlf. 1124 ********** 1125 e47d 7d 00 a4 OUTSCI TST AUTOLF 1126 e480 27 10 BEQ OUTSCI2 jump if autolf=0 1127 e482 8d 0e BSR OUTSCI2 1128 e484 81 0d CMPA #$0D 1129 e486 26 04 BNE OUTSCI1 1130 e488 86 0a LDAA #$0A if cr, send lf 1131 e48a 20 06 BRA OUTSCI2 1132 e48c 81 0a OUTSCI1 CMPA #$0A 1133 e48e 26 0e BNE OUTSCI3 1134 e490 86 0d LDAA #$0D if lf, send cr 1135 e492 f6 10 2e OUTSCI2 LDAB SCSR read status 1136 e495 c5 80 BITB #$80 1137 e497 27 f9 BEQ OUTSCI2 loop until tdre=1 1138 e499 84 7f ANDA #$7F mask parity 1139 e49b b7 10 2f STAA SCDAT send character 1140 e49e 39 OUTSCI3 RTS 1141 1142 ********** 1143 * ONACIA - Initialize the ACIA for 1144 * 8 data bits, 1 stop bit, divide by 64 clock. 1145 ********** 1146 e49f ce 98 00 ONACIA LDX #ACIA 1147 e4a2 86 03 LDAA #$03 1148 e4a4 a7 00 STAA 0,X master reset 1149 e4a6 86 16 LDAA #$16 1150 e4a8 a7 00 STAA 0,X setup 1151 e4aa 39 RTS 1152 1153 ********** 1154 * INACIA - Read from the ACIA, Return a=char or 0. 1155 * Tmp3 is used to flag overrun or framing error. 1156 ********** 1157 e4ab ce 98 00 INACIA LDX #ACIA 1158 e4ae a6 00 LDAA 0,X read status register 1159 e4b0 36 PSHA 1160 e4b1 84 30 ANDA #$30 check ov, fe 1161 e4b3 32 PULA 1162 e4b4 27 06 BEQ INACIA1 jump - no error 1163 e4b6 86 01 LDAA #$01 1164 e4b8 97 c2 STAA TMP3 flag reciever error 1165 e4ba 20 04 BRA INACIA2 read data to clear status 1166 e4bc 84 01 INACIA1 ANDA #$01 check rdrf 1167 e4be 27 04 BEQ INACIA3 jump if no data 1168 e4c0 a6 01 INACIA2 LDAA 1,X read data 1169 e4c2 84 7f ANDA #$7F mask parity 1170 e4c4 39 INACIA3 RTS 1171 1172 ********** 1173 * OUTACIA - Output A to acia. IF autolf = 1, 1174 * cr or lf sent as crlf. 1175 ********** 1176 e4c5 8d 18 OUTACIA BSR OUTACIA3 output char 1177 e4c7 7d 00 a4 TST AUTOLF 1178 e4ca 27 12 BEQ OUTACIA2 jump no autolf 1179 e4cc 81 0d CMPA #$0D 1180 e4ce 26 06 BNE OUTACIA1 1181 e4d0 86 0a LDAA #$0A 1182 e4d2 8d 0b BSR OUTACIA3 if cr, output lf 1183 e4d4 20 08 BRA OUTACIA2 1184 e4d6 81 0a OUTACIA1 CMPA #$0A 1185 e4d8 26 04 BNE OUTACIA2 1186 e4da 86 0d LDAA #$0D 1187 e4dc 8d 01 BSR OUTACIA3 if lf, output cr 1188 e4de 39 OUTACIA2 RTS 1189 1190 e4df ce 98 00 OUTACIA3 LDX #ACIA 1191 e4e2 e6 00 LDAB 0,X 1192 e4e4 c5 02 BITB #$2 1193 e4e6 27 f7 BEQ OUTACIA3 loop until tdre 1194 e4e8 84 7f ANDA #$7F mask parity 1195 e4ea a7 01 STAA 1,X output 1196 e4ec 39 RTS 1197 * 1198 * Space for modifying OUTACIA routine 1199 * 1200 e4ed ff ff ff ff ff ff FDB $FFFF,$FFFF,$FFFF,$FFFF ff ff 1201 ******************************* 1202 *** I/O UTILITY SUBROUTINES *** 1203 ***These subroutines perform the neccesary 1204 * data I/O operations. 1205 * OUTLHLF-Convert left 4 bits of A from binary 1206 * to ASCII and output. 1207 * OUTRHLF-Convert right 4 bits of A from binary 1208 * to ASCII and output. 1209 * OUT1BYT-Convert byte addresed by X from binary 1210 * to ASCII and output. 1211 * OUT1BSP-Convert byte addressed by X from binary 1212 * to ASCII and output followed by a space. 1213 * OUT2BSP-Convert 2 bytes addressed by X from binary 1214 * to ASCII and output followed by a space. 1215 * OUTSPAC-Output a space. 1216 * 1217 * OUTCRLF-Output a line feed and carriage return. 1218 * 1219 * OUTSTRG-Output the string of ASCII bytes addressed 1220 * by X until $04. 1221 * OUTA-Output the ASCII character in A. 1222 * 1223 * TABTO-Output spaces until column 20 is reached. 1224 * 1225 * INCHAR-Input to A and echo one character. Loops 1226 * until character read. 1227 * ******************* 1228 1229 ********** 1230 * OUTRHLF(), OUTLHLF(), OUTA() 1231 *Convert A from binary to ASCII and output. 1232 *Contents of A are destroyed.. 1233 ********** 1234 e4f5 44 OUTLHLF LSRA shift data to right 1235 e4f6 44 LSRA 1236 e4f7 44 LSRA 1237 e4f8 44 LSRA 1238 e4f9 84 0f OUTRHLF ANDA #$0F mask top half 1239 e4fb 8b 30 ADDA #$30 convert to ascii 1240 e4fd 81 39 CMPA #$39 1241 e4ff 2f 02 BLE OUTA jump if 0-9 1242 e501 8b 07 ADDA #$07 convert to hex A-F 1243 e503 bd e3 e1 OUTA JSR OUTPUT output character 1244 e506 39 RTS 1245 1246 ********** 1247 * OUT1BYT(x) - Convert the byte at X to two 1248 * ASCII characters and output. Return X pointing 1249 * to next byte. 1250 ********** 1251 e507 36 OUT1BYT PSHA 1252 e508 a6 00 LDAA 0,X get data in a 1253 e50a 36 PSHA save copy 1254 e50b 8d e8 BSR OUTLHLF output left half 1255 e50d 32 PULA retrieve copy 1256 e50e 8d e9 BSR OUTRHLF output right half 1257 e510 32 PULA 1258 e511 08 INX 1259 e512 39 RTS 1260 1261 ********** 1262 * OUT1BSP(x), OUT2BSP(x) - Output 1 or 2 bytes 1263 * at x followed by a space. Returns x pointing to 1264 * next byte. 1265 ********** 1266 e513 bd e5 07 OUT2BSP JSR OUT1BYT do first byte 1267 e516 bd e5 07 OUT1BSP JSR OUT1BYT do next byte 1268 e519 86 20 OUTSPAC LDAA #$20 output a space 1269 e51b bd e3 e1 JSR OUTPUT 1270 e51e 39 RTS 1271 1272 ********** 1273 * OUTCRLF() - Output a Carriage return and 1274 * a line feed. Returns a = cr. 1275 ********** 1276 e51f 86 0d OUTCRLF LDAA #$0D cr 1277 e521 bd e3 e1 JSR OUTPUT output a 1278 e524 86 00 LDAA #$00 1279 e526 bd e3 e1 JSR OUTPUT output padding 1280 e529 86 0d LDAA #$0D 1281 e52b 7f 00 a9 CLR CHRCNT zero the column counter 1282 e52e 39 RTS 1283 1284 ********** 1285 * OUTSTRG(x) - Output string of ASCII bytes 1286 * starting at x until end of text ($04). Can 1287 * be paused by control w (any char restarts). 1288 ********** 1289 e52f bd e5 1f OUTSTRG JSR OUTCRLF 1290 e532 36 OUTSTRG0 PSHA 1291 e533 a6 00 OUTSTRG1 LDAA 0,X read char into a 1292 e535 81 04 CMPA #EOT 1293 e537 27 14 BEQ OUTSTRG3 jump if eot 1294 e539 bd e3 e1 JSR OUTPUT output character 1295 e53c 08 INX 1296 e53d bd e3 b5 JSR INPUT 1297 e540 27 f1 BEQ OUTSTRG1 jump if no input 1298 e542 81 17 CMPA #CTLW 1299 e544 26 ed BNE OUTSTRG1 jump if not cntlw 1300 e546 bd e3 b5 OUTSTRG2 JSR INPUT 1301 e549 27 fb BEQ OUTSTRG2 jump if any input 1302 e54b 20 e6 BRA OUTSTRG1 1303 e54d 32 OUTSTRG3 PULA 1304 e54e 39 RTS 1305 1306 1307 ********* 1308 * TABTO() - move cursor over to column 20. 1309 *while(chrcnt < 16) outspac. 1310 e54f TABTO EQU * 1311 e54f 36 PSHA 1312 e550 bd e5 19 TABTOLP JSR OUTSPAC 1313 e553 96 a9 LDAA CHRCNT 1314 e555 81 14 CMPA #20 1315 e557 2f f7 BLE TABTOLP 1316 e559 32 PULA 1317 e55a 39 RTS 1318 1319 ********** 1320 * INCHAR() - Reads input until character sent. 1321 * Echoes char and returns with a = char. 1322 e55b bd e3 b5 INCHAR JSR INPUT 1323 e55e 4d TSTA 1324 e55f 27 fa BEQ INCHAR jump if no input 1325 e561 bd e3 e1 JSR OUTPUT echo 1326 e564 39 RTS 1327 1328 ********************* 1329 *** COMMAND TABLE *** 1330 e565 COMTABL EQU * 1331 e565 05 FCB 5 1332 e566 41 53 53 45 4d FCC 'ASSEM' 1333 e56b eb 3b FDB ASSEM 1334 e56d 05 FCB 5 1335 e56e 42 52 45 41 4b FCC 'BREAK' 1336 e573 e7 05 FDB BREAK 1337 e575 04 FCB 4 1338 e576 42 55 4c 4b FCC 'BULK' 1339 e57a e7 c0 FDB BULK 1340 e57c 07 FCB 7 1341 e57d 42 55 4c 4b 41 4c FCC 'BULKALL' 4c 1342 e584 e7 c4 FDB BULKALL 1343 e586 04 FCB 4 1344 e587 43 41 4c 4c FCC 'CALL' 1345 e58b fa 14 FDB CALL 1346 e58d 04 FCB 4 1347 e58e 44 55 4d 50 FCC 'DUMP' 1348 e592 e7 cd FDB DUMP 1349 e594 05 FCB 5 1350 e595 45 45 4d 4f 44 FCC 'EEMOD' 1351 e59a e8 62 FDB EEMOD 1352 e59c 04 FCB 4 1353 e59d 46 49 4c 4c FCC 'FILL' 1354 e5a1 e8 b2 FDB FILL 1355 e5a3 02 FCB 2 1356 e5a4 47 4f FCC 'GO' 1357 e5a6 fa 6d FDB GO 1358 e5a8 04 FCB 4 1359 e5a9 48 45 4c 50 FCC 'HELP' 1360 e5ad f6 1b FDB HELP 1361 e5af 04 FCB 4 1362 e5b0 48 4f 53 54 FCC 'HOST' 1363 e5b4 fb e8 FDB HOST 1364 e5b6 04 FCB 4 1365 e5b7 4c 4f 41 44 FCC 'LOAD' 1366 e5bb fc 80 FDB LOAD 1367 e5bd 06 FCB 6 LENGTH OF COMMAND 1368 e5be 4d 45 4d 4f 52 59 FCC 'MEMORY' ASCII COMMAND 1369 e5c4 e9 1a FDB MEMORY COMMAND ADDRESS 1370 e5c6 04 FCB 4 1371 e5c7 4d 4f 56 45 FCC 'MOVE' 1372 e5cb e9 ee FDB MOVE 1373 e5cd 06 FCB 6 1374 e5ce 4f 46 46 53 45 54 FCC 'OFFSET' 1375 e5d4 fd 8e FDB OFFSET 1376 e5d6 07 FCB 7 1377 e5d7 50 52 4f 43 45 45 FCC 'PROCEED' 44 1378 e5de fa 5b FDB PROCEED 1379 e5e0 08 FCB 8 1380 e5e1 52 45 47 49 53 54 FCC 'REGISTER' 45 52 1381 e5e9 fd cf FDB REGISTER 1382 e5eb 06 FCB 6 1383 e5ec 53 54 4f 50 41 54 FCC 'STOPAT' 1384 e5f2 fb 43 FDB STOPAT 1385 e5f4 05 FCB 5 1386 e5f5 54 52 41 43 45 FCC 'TRACE' 1387 e5fa fa fe FDB TRACE 1388 e5fc 06 FCB 6 1389 e5fd 56 45 52 49 46 59 FCC 'VERIFY' 1390 e603 fc 78 FDB VERIFY 1391 e605 01 FCB 1 1392 e606 3f FCC '?' initial command 1393 e607 f6 1b FDB HELP 1394 e609 05 FCB 5 1395 e60a 58 42 4f 4f 54 FCC 'XBOOT' 1396 e60f fe 3f FDB BOOT 1397 e611 01 FCB 1 dummy command for load 1398 e612 7e FCC '~' 1399 e613 fe b7 FDB TILDE 1400 * 1401 *** Command names for evm compatability *** 1402 * 1403 e615 03 FCB 3 1404 e616 41 53 4d FCC 'ASM' 1405 e619 eb 3b FDB ASSEM 1406 e61b 02 FCB 2 1407 e61c 42 46 FCC 'BF' 1408 e61e e8 b2 FDB FILL 1409 e620 04 FCB 4 1410 e621 43 4f 50 59 FCC 'COPY' 1411 e625 e9 ee FDB MOVE 1412 e627 05 FCB 5 1413 e628 45 52 41 53 45 FCC 'ERASE' 1414 e62d e7 c0 FDB BULK 1415 e62f 02 FCB 2 1416 e630 4d 44 FCC 'MD' 1417 e632 e7 cd FDB DUMP 1418 e634 02 FCB 2 1419 e635 4d 4d FCC 'MM' 1420 e637 e9 1a FDB MEMORY 1421 e639 02 FCB 2 1422 e63a 52 44 FCC 'RD' 1423 e63c fd cf FDB REGISTER 1424 e63e 02 FCB 2 1425 e63f 52 4d FCC 'RM' 1426 e641 fd cf FDB REGISTER 1427 e643 04 FCB 4 1428 e644 52 45 41 44 FCC 'READ' 1429 e648 e9 ee FDB MOVE 1430 e64a 02 FCB 2 1431 e64b 54 4d FCC 'TM' 1432 e64d fb e8 FDB HOST 1433 e64f 04 FCB 4 1434 e650 54 45 53 54 FCC 'TEST' 1435 e654 fe b8 FDB EVBTEST 1436 e656 ff FCB $FF 1437 1438 ******************* 1439 *** TEXT TABLES *** 1440 1441 e657 42 55 46 46 41 4c MSG1 FCC 'BUFFALO 3.4 (ext) - Bit User Fast Friendly Aid to Logical Operation' 4f 20 33 2e 34 20 28 65 78 74 29 20 2d 20 42 69 74 20 55 73 65 72 20 46 61 73 74 20 46 72 69 65 6e 64 6c 79 20 41 69 64 20 74 6f 20 4c 6f 67 69 63 61 6c 20 4f 70 65 72 61 74 1442 e69a 04 FCB EOT 1443 e69b 57 68 61 74 3f MSG2 FCC 'What?' 1444 e6a0 04 FCB EOT 1445 e6a1 54 6f 6f 20 4c 6f MSG3 FCC 'Too Long' 6e 67 1446 e6a9 04 FCB EOT 1447 e6aa 46 75 6c 6c MSG4 FCC 'Full' 1448 e6ae 04 FCB EOT 1449 e6af 4f 70 2d 20 MSG5 FCC 'Op- ' 1450 e6b3 04 FCB EOT 1451 e6b4 72 6f 6d 2d MSG6 FCC 'rom-' 1452 e6b8 04 FCB EOT 1453 e6b9 43 6f 6d 6d 61 6e MSG8 FCC 'Command?' 64 3f 1454 e6c1 04 FCB EOT 1455 e6c2 42 61 64 20 61 72 MSG9 FCC 'Bad argument' 67 75 6d 65 6e 74 1456 e6ce 04 FCB EOT 1457 e6cf 4e 6f 20 68 6f 73 MSG10 FCC 'No host port' 74 20 70 6f 72 74 1458 e6db 04 FCB EOT 1459 e6dc 64 6f 6e 65 MSG11 FCC 'done' 1460 e6e0 04 FCB EOT 1461 e6e1 63 68 6b 73 75 6d MSG12 FCC 'chksum error' 20 65 72 72 6f 72 1462 e6ed 04 FCB EOT 1463 e6ee 65 72 72 6f 72 20 MSG13 FCC 'error addr ' 61 64 64 72 20 1464 e6f9 04 FCB EOT 1465 e6fa 72 63 76 72 20 65 MSG14 FCC 'rcvr error' 72 72 6f 72 1466 e704 04 FCB EOT 1467 1468 ********** 1469 * break [-][] . . . 1470 * Modifies the breakpoint table. More than 1471 * one argument can be entered on the command 1472 * line but the table will hold only 4 entries. 1473 * 4 types of arguments are implied above: 1474 * break Prints table contents. 1475 * break Inserts . 1476 * break - Deletes . 1477 * break - Clears all entries. 1478 ********** 1479 * while 1 1480 * a = wskip(); 1481 * switch(a) 1482 * case(cr): 1483 * bprint(); return; 1484 1485 e705 bd e3 4b BREAK JSR WSKIP 1486 e708 26 04 BNE BRKDEL jump if not cr 1487 e70a bd e7 9c JSR BPRINT print table 1488 e70d 39 RTS 1489 1490 * case("-"): 1491 * incbuff(); readbuff(); 1492 * if(dchek(a)) /* look for wspac or cr */ 1493 * bpclr(); 1494 * breaksw; 1495 * a = buffarg(); 1496 * if( !dchek(a) ) return(bad argument); 1497 * b = bpsrch(); 1498 * if(b >= 0) 1499 * brktabl[b] = 0; 1500 * breaksw; 1501 1502 e70e 81 2d BRKDEL CMPA #'-' 1503 e710 26 31 BNE BRKDEF jump if not - 1504 e712 bd e3 3d JSR INCBUFF 1505 e715 bd e3 36 JSR READBUFF 1506 e718 bd e3 66 JSR DCHEK 1507 e71b 26 06 BNE BRKDEL1 jump if not delimeter 1508 e71d bd e1 fd JSR BPCLR clear table 1509 e720 7e e7 05 JMP BREAK do next argument 1510 e723 bd e2 7f BRKDEL1 JSR BUFFARG get address to delete 1511 e726 bd e3 66 JSR DCHEK 1512 e729 27 07 BEQ BRKDEL2 jump if delimeter 1513 e72b ce e6 c2 LDX #MSG9 "bad argument" 1514 e72e bd e5 2f JSR OUTSTRG 1515 e731 39 RTS 1516 e732 bd e7 ab BRKDEL2 JSR BPSRCH look for addr in table 1517 e735 5d TSTB 1518 e736 2b 08 BMI BRKDEL3 jump if not found 1519 e738 ce 00 9c LDX #BRKTABL 1520 e73b 3a ABX 1521 e73c 6f 00 CLR 0,X clear entry 1522 e73e 6f 01 CLR 1,X 1523 e740 7e e7 05 BRKDEL3 JMP BREAK do next argument 1524 1525 * default: 1526 * a = buffarg(); 1527 * if( !dchek(a) ) return(bad argument); 1528 * b = bpsrch(); 1529 * if(b < 0) /* not already in table */ 1530 * x = shftreg; 1531 * shftreg = 0; 1532 * a = x[0]; x[0] = $3F 1533 * b = x[0]; x[0] = a; 1534 * if(b != $3F) return(rom); 1535 * b = bpsrch(); /* look for hole */ 1536 * if(b >= 0) return(table full); 1537 * brktabl[b] = x; 1538 * breaksw; 1539 1540 e743 bd e2 7f BRKDEF JSR BUFFARG get argument 1541 e746 bd e3 66 JSR DCHEK 1542 e749 27 07 BEQ BRKDEF1 jump if delimiter 1543 e74b ce e6 c2 LDX #MSG9 "bad argument" 1544 e74e bd e5 2f JSR OUTSTRG 1545 e751 39 RTS 1546 e752 bd e7 ab BRKDEF1 JSR BPSRCH look for entry in table 1547 e755 5d TSTB 1548 e756 2c ad BGE BREAK jump if already in table 1549 1550 e758 de 96 LDX SHFTREG x = new entry addr 1551 e75a a6 00 LDAA 0,X save original contents 1552 e75c 36 PSHA 1553 e75d 86 3f LDAA #SWI 1554 e75f bd e2 d5 JSR WRITE write to entry addr 1555 e762 e6 00 LDAB 0,X read back 1556 e764 32 PULA 1557 e765 bd e2 d5 JSR WRITE restore original 1558 e768 c1 3f CMPB #SWI 1559 e76a 27 0c BEQ BRKDEF2 jump if writes ok 1560 e76c df b0 STX PTR1 save address 1561 e76e ce 00 b0 LDX #PTR1 1562 e771 bd e5 13 JSR OUT2BSP print address 1563 e774 bd e7 9c JSR BPRINT 1564 e777 39 RTS 1565 e778 7f 00 96 BRKDEF2 CLR SHFTREG 1566 e77b 7f 00 97 CLR SHFTREG+1 1567 e77e 3c PSHX 1568 e77f bd e7 ab JSR BPSRCH look for 0 entry 1569 e782 38 PULX 1570 e783 5d TSTB 1571 e784 2a 0a BPL BRKDEF3 jump if table not full 1572 e786 ce e6 aa LDX #MSG4 "full" 1573 e789 bd e5 2f JSR OUTSTRG 1574 e78c bd e7 9c JSR BPRINT 1575 e78f 39 RTS 1576 e790 18 ce 00 9c BRKDEF3 LDY #BRKTABL 1577 e794 18 3a ABY 1578 e796 cd ef 00 STX 0,Y put new entry in 1579 e799 7e e7 05 JMP BREAK do next argument 1580 1581 ********** 1582 * bprint() - print the contents of the table. 1583 ********** 1584 e79c bd e5 1f BPRINT JSR OUTCRLF 1585 e79f ce 00 9c LDX #BRKTABL 1586 e7a2 c6 04 LDAB #4 1587 e7a4 bd e5 13 BPRINT1 JSR OUT2BSP 1588 e7a7 5a DECB 1589 e7a8 2e fa BGT BPRINT1 loop 4 times 1590 e7aa 39 RTS 1591 1592 ********** 1593 * bpsrch() - search table for address in 1594 * shftreg. Returns b = index to entry or 1595 * b = -1 if not found. 1596 ********** 1597 *for(b=0; b=6; b=+2) 1598 * x[] = brktabl + b; 1599 * if(x[0] = shftreg) 1600 * return(b); 1601 *return(-1); 1602 1603 e7ab 5f BPSRCH CLRB 1604 e7ac ce 00 9c BPSRCH1 LDX #BRKTABL 1605 e7af 3a ABX 1606 e7b0 ee 00 LDX 0,X get table entry 1607 e7b2 9c 96 CPX SHFTREG 1608 e7b4 26 01 BNE BPSRCH2 jump if no match 1609 e7b6 39 RTS 1610 e7b7 5c BPSRCH2 INCB 1611 e7b8 5c INCB 1612 e7b9 c1 06 CMPB #$6 1613 e7bb 2f ef BLE BPSRCH1 loop 4 times 1614 e7bd c6 ff LDAB #$FF 1615 e7bf 39 RTS 1616 1617 1618 ********** 1619 * bulk - Bulk erase the eeprom not config. 1620 * bulkall - Bulk erase eeprom and config. 1621 ********* 1622 e7c0 BULK EQU * 1623 e7c0 de 98 LDX STREE 1624 e7c2 20 03 BRA BULK1 1625 e7c4 ce 10 3f BULKALL LDX #CONFIG 1626 e7c7 86 ff BULK1 LDAA #$FF 1627 e7c9 bd e3 19 JSR EEBULK 1628 e7cc 39 RTS 1629 1630 1631 1632 ********** 1633 * dump [ []] - Dump memory 1634 * in 16 byte lines from to . 1635 * Default starting address is "current 1636 * location" and default number of lines is 8. 1637 ********** 1638 *ptr1 = ptrmem; /* default start address */ 1639 *ptr2 = ptr1 + $80; /* default end address */ 1640 *a = wskip(); 1641 *if(a != cr) 1642 * a = buffarg(); 1643 * if(countu1 = 0) return(bad argument); 1644 * if( !dchek(a) ) return(bad argument); 1645 * ptr1 = shftreg; 1646 * ptr2 = ptr1 + $80; /* default end address */ 1647 * a = wskip(); 1648 * if(a != cr) 1649 * a = buffarg(); 1650 * if(countu1 = 0) return(bad argument); 1651 * a = wskip(); 1652 * if(a != cr) return(bad argument); 1653 * ptr2 = shftreg; 1654 1655 e7cd de aa DUMP LDX PTRMEM current location 1656 e7cf df b0 STX PTR1 default start 1657 e7d1 c6 80 LDAB #$80 1658 e7d3 3a ABX 1659 e7d4 df b2 STX PTR2 default end 1660 e7d6 bd e3 4b JSR WSKIP 1661 e7d9 27 35 BEQ DUMP1 jump - no arguments 1662 e7db bd e2 7f JSR BUFFARG read argument 1663 e7de 7d 00 a8 TST COUNT 1664 e7e1 27 26 BEQ DUMPERR jump if no argument 1665 e7e3 bd e3 66 JSR DCHEK 1666 e7e6 26 21 BNE DUMPERR jump if delimiter 1667 e7e8 de 96 LDX SHFTREG 1668 e7ea df b0 STX PTR1 1669 e7ec c6 80 LDAB #$80 1670 e7ee 3a ABX 1671 e7ef df b2 STX PTR2 default end address 1672 e7f1 bd e3 4b JSR WSKIP 1673 e7f4 27 1a BEQ DUMP1 jump - 1 argument 1674 e7f6 bd e2 7f JSR BUFFARG read argument 1675 e7f9 7d 00 a8 TST COUNT 1676 e7fc 27 0b BEQ DUMPERR jump if no argument 1677 e7fe bd e3 4b JSR WSKIP 1678 e801 26 06 BNE DUMPERR jump if not cr 1679 e803 de 96 LDX SHFTREG 1680 e805 df b2 STX PTR2 1681 e807 20 07 BRA DUMP1 jump - 2 arguments 1682 e809 ce e6 c2 DUMPERR LDX #MSG9 "bad argument" 1683 e80c bd e5 2f JSR OUTSTRG 1684 e80f 39 RTS 1685 1686 *ptrmem = ptr1; 1687 *ptr1 = ptr1 & $fff0; 1688 1689 e810 dc b0 DUMP1 LDD PTR1 1690 e812 dd aa STD PTRMEM new current location 1691 e814 c4 f0 ANDB #$F0 1692 e816 dd b0 STD PTR1 start dump at 16 byte boundary 1693 1694 *** dump loop starts here *** 1695 *do: 1696 * output address of first byte; 1697 1698 e818 bd e5 1f DUMPLP JSR OUTCRLF 1699 e81b ce 00 b0 LDX #PTR1 1700 e81e bd e5 13 JSR OUT2BSP first address 1701 1702 * x = ptr1; 1703 * for(b=0; b=16; b++) 1704 * output contents; 1705 1706 e821 de b0 LDX PTR1 base address 1707 e823 5f CLRB loop counter 1708 e824 bd e5 16 DUMPDAT JSR OUT1BSP hex value loop 1709 e827 5c INCB 1710 e828 c1 10 CMPB #$10 1711 e82a 2d f8 BLT DUMPDAT loop 16 times 1712 1713 * x = ptr1; 1714 * for(b=0; b=16; b++) 1715 * a = x[b]; 1716 * if($7A < a < $20) a = $20; 1717 * output ascii contents; 1718 1719 e82c 5f CLRB loop counter 1720 e82d de b0 DUMPASC LDX PTR1 base address 1721 e82f 3a ABX 1722 e830 a6 00 LDAA ,X ascii value loop 1723 e832 81 20 CMPA #$20 1724 e834 25 04 BLO DUMP3 jump if non printable 1725 e836 81 7a CMPA #$7A 1726 e838 23 02 BLS DUMP4 jump if printable 1727 e83a 86 20 DUMP3 LDAA #$20 space for non printables 1728 e83c bd e3 e1 DUMP4 JSR OUTPUT output ascii value 1729 e83f 5c INCB 1730 e840 c1 10 CMPB #$10 1731 e842 2d e9 BLT DUMPASC loop 16 times 1732 1733 * chkabrt(); 1734 * ptr1 = ptr1 + $10; 1735 *while(ptr1 <= ptr2); 1736 *return; 1737 1738 e844 bd e3 6e JSR CHKABRT check abort or wait 1739 e847 dc b0 LDD PTR1 1740 e849 c3 00 10 ADDD #$10 point to next 16 byte bound 1741 e84c dd b0 STD PTR1 update ptr1 1742 e84e 1a 93 b2 CPD PTR2 1743 e851 22 0e BHI DUMP5 quit if ptr1 > ptr2 1744 e853 1a 83 00 00 CPD #$00 check wraparound at $ffff 1745 e857 26 bf BNE DUMPLP jump - no wraparound 1746 e859 dc b2 LDD PTR2 1747 e85b 1a 83 ff f0 CPD #$FFF0 1748 e85f 25 b7 BLO DUMPLP upper bound not at top 1749 e861 39 DUMP5 RTS quit 1750 1751 1752 1753 ********** 1754 * eemod [ []] 1755 * Modifies the eeprom address range. 1756 * EEMOD -show ee address range 1757 * EEMOD -set range to addr1 -> addr1+2k 1758 * EEMOD -set range to addr1 -> addr2 1759 ********** 1760 *if() 1761 * stree = addr1; 1762 * endee = addr1 + 2k bytes; 1763 *if() 1764 * endee = addr2; 1765 *print(stree,endee); 1766 e862 EEMOD EQU * 1767 e862 bd e3 4b JSR WSKIP 1768 e865 27 34 BEQ EEMOD2 jump - no arguments 1769 e867 bd e2 7f JSR BUFFARG read argument 1770 e86a 7d 00 a8 TST COUNT 1771 e86d 27 3c BEQ EEMODER jump if no argument 1772 e86f bd e3 66 JSR DCHEK 1773 e872 26 37 BNE EEMODER jump if no delimeter 1774 e874 dc 96 LDD SHFTREG 1775 e876 dd b0 STD PTR1 1776 e878 c3 07 ff ADDD #$07FF add 2k bytes to stree 1777 e87b dd b2 STD PTR2 default endee address 1778 e87d bd e3 4b JSR WSKIP 1779 e880 27 11 BEQ EEMOD1 jump - 1 argument 1780 e882 bd e2 7f JSR BUFFARG read argument 1781 e885 7d 00 a8 TST COUNT 1782 e888 27 21 BEQ EEMODER jump if no argument 1783 e88a bd e3 4b JSR WSKIP 1784 e88d 26 1c BNE EEMODER jump if not cr 1785 e88f de 96 LDX SHFTREG 1786 e891 df b2 STX PTR2 1787 e893 de b0 EEMOD1 LDX PTR1 1788 e895 df 98 STX STREE new stree address 1789 e897 de b2 LDX PTR2 1790 e899 df 9a STX ENDEE new endee address 1791 e89b bd e5 1f EEMOD2 JSR OUTCRLF display ee range 1792 e89e ce 00 98 LDX #STREE 1793 e8a1 bd e5 13 JSR OUT2BSP 1794 e8a4 ce 00 9a LDX #ENDEE 1795 e8a7 bd e5 13 JSR OUT2BSP 1796 e8aa 39 RTS 1797 1798 e8ab ce e6 c2 EEMODER LDX #MSG9 "bad argument" 1799 e8ae bd e5 2f JSR OUTSTRG 1800 e8b1 39 RTS 1801 1802 1803 1804 1805 ********** 1806 * fill [] - Block fill 1807 *memory from addr1 to addr2 with data. Data 1808 *defaults to $FF. 1809 ********** 1810 *get addr1 and addr2 1811 e8b2 FILL EQU * 1812 e8b2 bd e3 4b JSR WSKIP 1813 e8b5 bd e2 7f JSR BUFFARG 1814 e8b8 7d 00 a8 TST COUNT 1815 e8bb 27 4f BEQ FILLERR jump if no argument 1816 e8bd bd e3 5b JSR WCHEK 1817 e8c0 26 4a BNE FILLERR jump if bad argument 1818 e8c2 de 96 LDX SHFTREG 1819 e8c4 df b0 STX PTR1 address1 1820 e8c6 bd e3 4b JSR WSKIP 1821 e8c9 bd e2 7f JSR BUFFARG 1822 e8cc 7d 00 a8 TST COUNT 1823 e8cf 27 3b BEQ FILLERR jump if no argument 1824 e8d1 bd e3 66 JSR DCHEK 1825 e8d4 26 36 BNE FILLERR jump if bad argument 1826 e8d6 de 96 LDX SHFTREG 1827 e8d8 df b2 STX PTR2 address2 1828 1829 *Get data if it exists 1830 e8da 86 ff LDAA #$FF 1831 e8dc 97 c1 STAA TMP2 default data 1832 e8de bd e3 4b JSR WSKIP 1833 e8e1 27 11 BEQ FILL1 jump if default data 1834 e8e3 bd e2 7f JSR BUFFARG 1835 e8e6 7d 00 a8 TST COUNT 1836 e8e9 27 21 BEQ FILLERR jump if no argument 1837 e8eb bd e3 4b JSR WSKIP 1838 e8ee 26 1c BNE FILLERR jump if bad argument 1839 e8f0 96 97 LDAA SHFTREG+1 1840 e8f2 97 c1 STAA TMP2 1841 1842 *while(ptr1 <= ptr2) 1843 * *ptr1 = data 1844 * if(*ptr1 != data) abort 1845 1846 e8f4 FILL1 EQU * 1847 e8f4 bd e3 6e JSR CHKABRT check for abort 1848 e8f7 de b0 LDX PTR1 starting address 1849 e8f9 96 c1 LDAA TMP2 data 1850 e8fb bd e2 d5 JSR WRITE write the data to x 1851 e8fe a1 00 CMPA 0,X 1852 e900 26 11 BNE FILLBAD jump if no write 1853 e902 9c b2 CPX PTR2 1854 e904 27 05 BEQ FILL2 quit yet? 1855 e906 08 INX 1856 e907 df b0 STX PTR1 1857 e909 20 e9 BRA FILL1 loop 1858 e90b 39 FILL2 RTS 1859 1860 e90c ce e6 c2 FILLERR LDX #MSG9 "bad argument" 1861 e90f bd e5 2f JSR OUTSTRG 1862 e912 39 RTS 1863 1864 e913 FILLBAD EQU * 1865 e913 ce 00 b0 LDX #PTR1 output bad address 1866 e916 bd e5 13 JSR OUT2BSP 1867 e919 39 RTS 1868 1869 1870 1871 ******************************************* 1872 * MEMORY [] 1873 * []/ 1874 * Opens memory and allows user to modify the 1875 *contents at or the last opened location. 1876 * Subcommands: 1877 * [] - Close current location and exit. 1878 * []<+> - Close current and open next. 1879 * []<^><-> - Close current and open previous. 1880 * [] - Close current and open next. 1881 * []<=> - Reopen current location. 1882 * The contents of the current location is only 1883 * changed if valid data is entered before each 1884 * subcommand. 1885 * []O - Compute relative offset from current 1886 * location to . The current location must 1887 * be the address of the offset byte. 1888 ********** 1889 *a = wskip(); 1890 *if(a != cr) 1891 * a = buffarg(); 1892 * if(a != cr) return(bad argument); 1893 * if(countu1 != 0) ptrmem[] = shftreg; 1894 1895 e91a bd e3 4b MEMORY JSR WSKIP 1896 e91d 27 18 BEQ MEM1 jump if cr 1897 e91f bd e2 7f JSR BUFFARG 1898 e922 bd e3 4b JSR WSKIP 1899 e925 27 07 BEQ MSLASH jump if cr 1900 e927 ce e6 c2 LDX #MSG9 "bad argument" 1901 e92a bd e5 2f JSR OUTSTRG 1902 e92d 39 RTS 1903 e92e 7d 00 a8 MSLASH TST COUNT 1904 e931 27 04 BEQ MEM1 jump if no argument 1905 e933 de 96 LDX SHFTREG 1906 e935 df aa STX PTRMEM update "current location" 1907 1908 ********** 1909 * Subcommands 1910 ********** 1911 *outcrlf(); 1912 *out2bsp(ptrmem[]); 1913 *out1bsp(ptrmem[0]); 1914 1915 e937 bd e5 1f MEM1 JSR OUTCRLF 1916 e93a ce 00 aa MEM2 LDX #PTRMEM 1917 e93d bd e5 13 JSR OUT2BSP output address 1918 e940 de aa MEM3 LDX PTRMEM 1919 e942 bd e5 16 JSR OUT1BSP output contents 1920 e945 7f 00 96 CLR SHFTREG 1921 e948 7f 00 97 CLR SHFTREG+1 1922 *while 1 1923 *a = termarg(); 1924 * switch(a) 1925 * case(space): 1926 * chgbyt(); 1927 * ptrmem[]++; 1928 * if(ptrmem%16 == 0) start new line; 1929 * case(linefeed | +): 1930 * chgbyt(); 1931 * ptrmem[]++; 1932 * case(up arrow | backspace | -): 1933 * chgbyt(); 1934 * ptrmem[]--; 1935 * case('/' | '='): 1936 * chgbyt(); 1937 * outcrlf(); 1938 * case(O): 1939 * d = ptrmem[0] - (shftreg); 1940 * if($80 < d < $ff81) 1941 * print(out of range); 1942 * countt1 = d-1; 1943 * out1bsp(countt1); 1944 * case(carriage return): 1945 * chgbyt(); 1946 * return; 1947 * default: return(command?) 1948 1949 e94b bd e2 a2 MEM4 JSR TERMARG 1950 e94e bd e1 f2 JSR UPCASE 1951 e951 de aa LDX PTRMEM 1952 e953 81 20 CMPA #$20 1953 e955 27 31 BEQ MEMSP jump if space 1954 e957 81 0a CMPA #$0A 1955 e959 27 3e BEQ MEMLF jump if linefeed 1956 e95b 81 2b CMPA #$2B 1957 e95d 27 43 BEQ MEMPLUS jump if + 1958 e95f 81 5e CMPA #$5E 1959 e961 27 48 BEQ MEMUA jump if up arrow 1960 e963 81 2d CMPA #$2D 1961 e965 27 44 BEQ MEMUA jump if - 1962 e967 81 08 CMPA #$08 1963 e969 27 40 BEQ MEMUA jump if backspace 1964 e96b 81 2f CMPA #'/' 1965 e96d 27 45 BEQ MEMSL jump if / 1966 e96f 81 3d CMPA #'=' 1967 e971 27 41 BEQ MEMSL jump if = 1968 e973 81 4f CMPA #'O' 1969 e975 27 43 BEQ MEMOFF jump if O 1970 e977 81 0d CMPA #$0D 1971 e979 27 6f BEQ MEMCR jump if carriage ret 1972 e97b 81 2e CMPA #'.' 1973 e97d 27 6e BEQ MEMEND jump if . 1974 e97f ce e6 b9 LDX #MSG8 "command?" 1975 e982 bd e5 2f JSR OUTSTRG 1976 e985 7e e9 37 JMP MEM1 1977 e988 bd e2 ca MEMSP JSR CHGBYT 1978 e98b 08 INX 1979 e98c df aa STX PTRMEM 1980 e98e 8f XGDX 1981 e98f c4 0f ANDB #$0F 1982 e991 27 03 BEQ MEMSP1 jump if mod16=0 1983 e993 7e e9 40 JMP MEM3 continue same line 1984 e996 7e e9 37 MEMSP1 JMP MEM1 .. else start new line 1985 e999 bd e2 ca MEMLF JSR CHGBYT 1986 e99c 08 INX 1987 e99d df aa STX PTRMEM 1988 e99f 7e e9 3a JMP MEM2 output next address 1989 e9a2 bd e2 ca MEMPLUS JSR CHGBYT 1990 e9a5 08 INX 1991 e9a6 df aa STX PTRMEM 1992 e9a8 7e e9 37 JMP MEM1 output cr, next address 1993 e9ab bd e2 ca MEMUA JSR CHGBYT 1994 e9ae 09 DEX 1995 e9af df aa STX PTRMEM 1996 e9b1 7e e9 37 JMP MEM1 output cr, previous address 1997 e9b4 bd e2 ca MEMSL JSR CHGBYT 1998 e9b7 7e e9 37 JMP MEM1 output cr, same address 1999 e9ba dc 96 MEMOFF LDD SHFTREG destination addr 2000 e9bc 93 aa SUBD PTRMEM 2001 e9be 81 00 CMPA #$0 2002 e9c0 26 06 BNE MEMOFF1 jump if not 0 2003 e9c2 c1 80 CMPB #$80 2004 e9c4 23 13 BLS MEMOFF3 jump if in range 2005 e9c6 20 08 BRA MEMOFF2 out of range 2006 e9c8 81 ff MEMOFF1 CMPA #$FF 2007 e9ca 26 04 BNE MEMOFF2 out of range 2008 e9cc c1 81 CMPB #$81 2009 e9ce 24 09 BHS MEMOFF3 in range 2010 e9d0 ce e6 a1 MEMOFF2 LDX #MSG3 "Too long" 2011 e9d3 bd e5 2f JSR OUTSTRG 2012 e9d6 7e e9 37 JMP MEM1 output cr, addr, contents 2013 e9d9 83 00 01 MEMOFF3 SUBD #$1 b now has offset 2014 e9dc d7 c3 STAB TMP4 2015 e9de bd e5 19 JSR OUTSPAC 2016 e9e1 ce 00 c3 LDX #TMP4 2017 e9e4 bd e5 16 JSR OUT1BSP output offset 2018 e9e7 7e e9 37 JMP MEM1 output cr, addr, contents 2019 e9ea bd e2 ca MEMCR JSR CHGBYT 2020 e9ed 39 MEMEND RTS exit task 2021 2022 2023 ********** 2024 * move [] - move 2025 *block at to to . 2026 * Moves block 1 byte up if no . 2027 ********** 2028 *a = buffarg(); 2029 *if(countu1 = 0) return(bad argument); 2030 *if( !wchek(a) ) return(bad argument); 2031 *ptr1 = shftreg; /* src1 */ 2032 2033 e9ee MOVE EQU * 2034 e9ee bd e2 7f JSR BUFFARG 2035 e9f1 7d 00 a8 TST COUNT 2036 e9f4 27 2b BEQ MOVERR jump if no arg 2037 e9f6 bd e3 5b JSR WCHEK 2038 e9f9 26 26 BNE MOVERR jump if no delim 2039 e9fb de 96 LDX SHFTREG src1 2040 e9fd df b0 STX PTR1 2041 2042 *a = buffarg(); 2043 *if(countu1 = 0) return(bad argument); 2044 *if( !dchek(a) ) return(bad argument); 2045 *ptr2 = shftreg; /* src2 */ 2046 2047 e9ff bd e2 7f JSR BUFFARG 2048 ea02 7d 00 a8 TST COUNT 2049 ea05 27 1a BEQ MOVERR jump if no arg 2050 ea07 bd e3 66 JSR DCHEK 2051 ea0a 26 15 BNE MOVERR jump if no delim 2052 ea0c de 96 LDX SHFTREG src2 2053 ea0e df b2 STX PTR2 2054 2055 *a = buffarg(); 2056 *a = wskip(); 2057 *if(a != cr) return(bad argument); 2058 *if(countu1 != 0) tmp2 = shftreg; /* dest */ 2059 *else tmp2 = ptr1 + 1; 2060 2061 ea10 bd e2 7f JSR BUFFARG 2062 ea13 bd e3 4b JSR WSKIP 2063 ea16 26 09 BNE MOVERR jump if not cr 2064 ea18 7d 00 a8 TST COUNT 2065 ea1b 27 0b BEQ MOVE1 jump if no arg 2066 ea1d de 96 LDX SHFTREG dest 2067 ea1f 20 0a BRA MOVE2 2068 ea21 ce e6 c2 MOVERR LDX #MSG9 "bad argument" 2069 ea24 bd e5 2f JSR OUTSTRG 2070 ea27 39 RTS 2071 2072 ea28 de b0 MOVE1 LDX PTR1 2073 ea2a 08 INX default dest 2074 ea2b df b4 MOVE2 STX PTR3 2075 2076 *if(src1 < dest <= src2) 2077 * dest = dest+(src2-src1); 2078 * for(x = src2; x = src1; x--) 2079 * dest[0]-- = x[0]--; 2080 ea2d de b4 LDX PTR3 dest 2081 ea2f 9c b0 CPX PTR1 src1 2082 ea31 23 28 BLS MOVE3 jump if dest =< src1 2083 ea33 9c b2 CPX PTR2 src2 2084 ea35 22 24 BHI MOVE3 jump if dest > src2 2085 ea37 dc b2 LDD PTR2 2086 ea39 93 b0 SUBD PTR1 2087 ea3b d3 b4 ADDD PTR3 2088 ea3d dd b4 STD PTR3 dest = dest+(src2-src1) 2089 ea3f de b2 LDX PTR2 2090 ea41 bd e3 6e MOVELP1 JSR CHKABRT check for abort 2091 ea44 a6 00 LDAA ,X char at src2 2092 ea46 3c PSHX 2093 ea47 de b4 LDX PTR3 2094 ea49 bd e2 d5 JSR WRITE write a to x 2095 ea4c a1 00 CMPA 0,X 2096 ea4e 26 28 BNE MOVEBAD jump if no write 2097 ea50 09 DEX 2098 ea51 df b4 STX PTR3 2099 ea53 38 PULX 2100 ea54 9c b0 CPX PTR1 2101 ea56 27 1f BEQ MOVRTS 2102 ea58 09 DEX 2103 ea59 20 e6 BRA MOVELP1 Loop SRC2 - SRC1 times 2104 * 2105 * else 2106 * for(x=src1; x=src2; x++) 2107 * dest[0]++ = x[0]++; 2108 2109 2110 ea5b de b0 MOVE3 LDX PTR1 srce1 2111 ea5d bd e3 6e MOVELP2 JSR CHKABRT check for abort 2112 ea60 a6 00 LDAA ,X 2113 ea62 3c PSHX 2114 ea63 de b4 LDX PTR3 dest 2115 ea65 bd e2 d5 JSR WRITE write a to x 2116 ea68 a1 00 CMPA 0,X 2117 ea6a 26 0c BNE MOVEBAD jump if no write 2118 ea6c 08 INX 2119 ea6d df b4 STX PTR3 2120 ea6f 38 PULX 2121 ea70 9c b2 CPX PTR2 2122 ea72 27 03 BEQ MOVRTS 2123 ea74 08 INX 2124 ea75 20 e6 BRA MOVELP2 Loop SRC2-SRC1 times 2125 ea77 39 MOVRTS RTS 2126 2127 ea78 38 MOVEBAD PULX restore stack 2128 ea79 ce 00 b4 LDX #PTR3 2129 ea7c bd e5 13 JSR OUT2BSP output bad address 2130 ea7f 39 RTS 2131 2132 2133 **************** 2134 * assem(addr) -68HC11 line assembler/disassembler. 2135 * This routine will disassemble the opcode at 2136 * and then allow the user to enter a line for 2137 *assembly. Rules for assembly are as follows: 2138 * -A '#' sign indicates immediate addressing. 2139 * -A ',' (comma) indicates indexed addressing 2140 * and the next character must be X or Y. 2141 * -All arguments are assumed to be hex and the 2142 * '$' sign shouldn't be used. 2143 * -Arguments should be separated by 1 or more 2144 * spaces or tabs. 2145 * -Any input after the required number of 2146 * arguments is ignored. 2147 * -Upper or lower case makes no difference. 2148 * 2149 * To signify end of input line, the following 2150 *commands are available and have the indicated action: 2151 * - Finds the next opcode for 2152 * assembly. If there was no assembly input, 2153 * the next opcode disassembled is retrieved 2154 * from the disassembler. 2155 * <+> - Works the same as carriage return 2156 * except if there was no assembly input, the 2157 * is incremented and the next is 2158 * disassembled. 2159 * <^><-> - Decrements and the previous 2160 * address is then disassembled. 2161 * <=> - Redisassembles the current address. 2162 * 2163 * To exit the assembler use CONTROL A or . (period). 2164 *Of course control X and DEL will also allow you to abort. 2165 *** Equates for assembler *** 2166 0000 PAGE1 EQU $00 values for page opcodes 2167 0018 PAGE2 EQU $18 2168 001a PAGE3 EQU $1A 2169 00cd PAGE4 EQU $CD 2170 0000 IMMED EQU $0 addressing modes 2171 0001 INDX EQU $1 2172 0002 INDY EQU $2 2173 0003 LIMMED EQU $3 (long immediate) 2174 0004 OTHER EQU $4 2175 2176 *** Rename variables for assem/disassem *** 2177 00c1 AMODE EQU TMP2 addressing mode 2178 00c2 YFLAG EQU TMP3 2179 00c3 PNORM EQU TMP4 page for normal opcode 2180 00be OLDPC EQU PTR8 2181 00b0 PC EQU PTR1 program counter 2182 00b2 PX EQU PTR2 page for x indexed 2183 00b3 PY EQU PTR2+1 page for y indexed 2184 00b4 BASEOP EQU PTR3 base opcode 2185 00b5 CLASS EQU PTR3+1 class 2186 00b6 DISPC EQU PTR4 pc for disassembler 2187 00b8 BRADDR EQU PTR5 relative branch offset 2188 00ba MNEPTR EQU PTR6 pointer to table for dis 2189 00bc ASSCOMM EQU PTR7 subcommand for assembler 2190 2191 *** Error messages for assembler *** 2192 ea80 ea 92 MSGDIR FDB MSGA1 message table index 2193 ea82 ea a5 FDB MSGA2 2194 ea84 ea b8 FDB MSGA3 2195 ea86 ea c7 FDB MSGA4 2196 ea88 ea d4 FDB MSGA5 2197 ea8a ea e7 FDB MSGA6 2198 ea8c ea ff FDB MSGA7 2199 ea8e eb 1a FDB MSGA8 2200 ea90 eb 27 FDB MSGA9 2201 ea92 49 6d 6d 65 64 20 MSGA1 FCC 'Immed mode illegal' 6d 6f 64 65 20 69 6c 6c 65 67 61 6c 2202 eaa4 04 FCB EOT 2203 eaa5 45 72 72 6f 72 20 MSGA2 FCC 'Error in Mne table' 69 6e 20 4d 6e 65 20 74 61 62 6c 65 2204 eab7 04 FCB EOT 2205 eab8 49 6c 6c 65 67 61 MSGA3 FCC 'Illegal bit op' 6c 20 62 69 74 20 6f 70 2206 eac6 04 FCB EOT 2207 eac7 42 61 64 20 61 72 MSGA4 FCC 'Bad argument' 67 75 6d 65 6e 74 2208 ead3 04 FCB EOT 2209 ead4 4d 6e 65 6d 6f 6e MSGA5 FCC 'Mnemonic not found' 69 63 20 6e 6f 74 20 66 6f 75 6e 64 2210 eae6 04 FCB EOT 2211 eae7 55 6e 6b 6e 6f 77 MSGA6 FCC 'Unknown addressing mode' 6e 20 61 64 64 72 65 73 73 69 6e 67 20 6d 6f 64 65 2212 eafe 04 FCB EOT 2213 eaff 49 6e 64 65 78 65 MSGA7 FCC 'Indexed addressing assumed' 64 20 61 64 64 72 65 73 73 69 6e 67 20 61 73 73 75 6d 65 64 2214 eb19 04 FCB EOT 2215 eb1a 53 79 6e 74 61 78 MSGA8 FCC 'Syntax error' 20 65 72 72 6f 72 2216 eb26 04 FCB EOT 2217 eb27 42 72 61 6e 63 68 MSGA9 FCC 'Branch out of range' 20 6f 75 74 20 6f 66 20 72 61 6e 67 65 2218 eb3a 04 FCB EOT 2219 2220 ********** 2221 *oldpc = rambase; 2222 *a = wskip(); 2223 *if (a != cr) 2224 * buffarg() 2225 * a = wskip(); 2226 * if ( a != cr ) return(error); 2227 * oldpc = a; 2228 eb3b ASSEM EQU * 2229 eb3b ce 00 00 LDX #RAMBS 2230 eb3e df be STX OLDPC 2231 eb40 bd e3 4b JSR WSKIP 2232 eb43 27 13 BEQ ASSLOOP jump if no argument 2233 eb45 bd e2 7f JSR BUFFARG 2234 eb48 bd e3 4b JSR WSKIP 2235 eb4b 27 07 BEQ ASSEM1 jump if argument ok 2236 eb4d ce ea c7 LDX #MSGA4 "bad argument" 2237 eb50 bd e5 2f JSR OUTSTRG 2238 eb53 39 RTS 2239 eb54 de 96 ASSEM1 LDX SHFTREG 2240 eb56 df be STX OLDPC 2241 2242 *repeat 2243 * pc = oldpc; 2244 * out2bsp(pc); 2245 * disassem(); 2246 * a=readln(); 2247 * asscomm = a; /* save command */ 2248 * if(a == [^,+,-,/,=]) outcrlf; 2249 * if(a == 0) return(error); 2250 2251 eb58 de be ASSLOOP LDX OLDPC 2252 eb5a df b0 STX PC 2253 eb5c bd e5 1f JSR OUTCRLF 2254 eb5f ce 00 b0 LDX #PC 2255 eb62 bd e5 13 JSR OUT2BSP output the address 2256 eb65 bd f3 8d JSR DISASSM disassemble opcode 2257 eb68 bd e5 4f JSR TABTO 2258 eb6b 86 3e LDAA #PROMPT prompt user 2259 eb6d bd e5 03 JSR OUTA output prompt character 2260 eb70 bd ec 1c JSR READLN read input for assembly 2261 eb73 97 bc STAA ASSCOMM 2262 eb75 81 5e CMPA #'^' 2263 eb77 27 15 BEQ ASSLP0 jump if '^' 2264 eb79 81 2b CMPA #'+' 2265 eb7b 27 11 BEQ ASSLP0 jump if '+' 2266 eb7d 81 2d CMPA #'-' 2267 eb7f 27 0d BEQ ASSLP0 jump if '-' 2268 eb81 81 2f CMPA #'/' 2269 eb83 27 09 BEQ ASSLP0 jump if '/' 2270 eb85 81 3d CMPA #'=' 2271 eb87 27 05 BEQ ASSLP0 jump if '=' 2272 eb89 81 00 CMPA #$00 2273 eb8b 26 04 BNE ASSLP1 jump if none of above 2274 eb8d 39 RTS return if bad input 2275 eb8e bd e5 1f ASSLP0 JSR OUTCRLF 2276 eb91 ASSLP1 EQU * come here for cr or lf 2277 eb91 bd e5 19 JSR OUTSPAC 2278 eb94 bd e5 19 JSR OUTSPAC 2279 eb97 bd e5 19 JSR OUTSPAC 2280 eb9a bd e5 19 JSR OUTSPAC 2281 eb9d bd e5 19 JSR OUTSPAC 2282 2283 * b = parse(input); /* get mnemonic */ 2284 * if(b > 5) print("not found"); asscomm='/'; 2285 * elseif(b >= 1) 2286 * msrch(); 2287 * if(class==$FF) 2288 * print("not found"); asscomm='/'; 2289 * else 2290 * a = doop(opcode,class); 2291 * if(a == 0) dispc=0; 2292 * else process error; asscomm='/'; 2293 2294 eba0 bd ec 65 JSR PARSE 2295 eba3 c1 05 CMPB #$5 2296 eba5 2f 08 BLE ASSLP2 jump if mnemonic <= 5 chars 2297 eba7 ce ea d4 LDX #MSGA5 "mnemonic not found" 2298 ebaa bd e5 2f JSR OUTSTRG 2299 ebad 20 2f BRA ASSLP5 2300 ebaf ASSLP2 EQU * 2301 ebaf c1 00 CMPB #$0 2302 ebb1 27 2e BEQ ASSLP10 jump if no input 2303 ebb3 bd ec ac JSR MSRCH 2304 ebb6 96 b5 LDAA CLASS 2305 ebb8 81 ff CMPA #$FF 2306 ebba 26 08 BNE ASSLP3 2307 ebbc ce ea d4 LDX #MSGA5 "mnemonic not found" 2308 ebbf bd e5 2f JSR OUTSTRG 2309 ebc2 20 1a BRA ASSLP5 2310 ebc4 bd ec e4 ASSLP3 JSR DOOP 2311 ebc7 81 00 CMPA #$00 2312 ebc9 26 07 BNE ASSLP4 jump if doop error 2313 ebcb ce 00 00 LDX #$00 2314 ebce df b6 STX DISPC indicate good assembly 2315 ebd0 20 0f BRA ASSLP10 2316 ebd2 4a ASSLP4 DECA a = error message index 2317 ebd3 16 TAB 2318 ebd4 ce ea 80 LDX #MSGDIR 2319 ebd7 3a ABX 2320 ebd8 3a ABX 2321 ebd9 ee 00 LDX 0,X 2322 ebdb bd e5 2f JSR OUTSTRG output error message 2323 ebde 7f 00 bc ASSLP5 CLR ASSCOMM error command 2324 2325 * /* compute next address - asscomm holds subcommand 2326 * and dispc indicates if valid assembly occured. */ 2327 * if(asscomm== ^ or -) oldpc--; 2328 * if(asscomm==(lf or + or cr) 2329 * if(dispc==0) oldpc=pc; /* good assembly */ 2330 * else 2331 * if(asscomm==lf or +) dispc= ++oldpc; 2332 * oldpc=dispc; 2333 *until(eot) 2334 ebe1 ASSLP10 EQU * 2335 ebe1 96 bc LDAA ASSCOMM 2336 ebe3 81 5e CMPA #'^' 2337 ebe5 27 04 BEQ ASSLPA jump if '^' 2338 ebe7 81 2d CMPA #'-' 2339 ebe9 26 07 BNE ASSLP11 jump not '-' 2340 ebeb de be ASSLPA LDX OLDPC back up for '^' or '-' 2341 ebed 09 DEX 2342 ebee df be STX OLDPC 2343 ebf0 20 27 BRA ASSLP15 2344 ebf2 81 0a ASSLP11 CMPA #$0A 2345 ebf4 27 08 BEQ ASSLP12 jump if linefeed 2346 ebf6 81 2b CMPA #'+' 2347 ebf8 27 04 BEQ ASSLP12 jump if '+' 2348 ebfa 81 0d CMPA #$0D 2349 ebfc 26 1b BNE ASSLP15 jump if not cr 2350 ebfe de b6 ASSLP12 LDX DISPC 2351 ec00 26 06 BNE ASSLP13 jump if dispc != 0 2352 ec02 de b0 LDX PC 2353 ec04 df be STX OLDPC 2354 ec06 20 11 BRA ASSLP15 2355 ec08 81 0a ASSLP13 CMPA #$0A 2356 ec0a 27 04 BEQ ASSLPB jump not lf 2357 ec0c 81 2b CMPA #'+' 2358 ec0e 26 05 BNE ASSLP14 jump not lf or '+' 2359 ec10 de be ASSLPB LDX OLDPC 2360 ec12 08 INX 2361 ec13 df b6 STX DISPC 2362 ec15 de b6 ASSLP14 LDX DISPC 2363 ec17 df be STX OLDPC 2364 ec19 7e eb 58 ASSLP15 JMP ASSLOOP 2365 2366 **************** 2367 * readln() --- Read input from terminal into buffer 2368 * until a command character is read (cr,lf,/,^). 2369 * If more chars are typed than the buffer will hold, 2370 * the extra characters are overwritten on the end. 2371 * On exit: b=number of chars read, a=0 if quit, 2372 * else a=next command. 2373 **************** 2374 *for(b==0;b<=bufflng;b++) inbuff[b] = cr; 2375 2376 ec1c 5f READLN CLRB 2377 ec1d 86 0d LDAA #$0D carriage ret 2378 ec1f ce 00 6b RLN0 LDX #INBUFF 2379 ec22 3a ABX 2380 ec23 a7 00 STAA 0,X initialize input buffer 2381 ec25 5c INCB 2382 ec26 c1 23 CMPB #BUFFLNG 2383 ec28 2d f5 BLT RLN0 2384 *b=0; 2385 *repeat 2386 * if(a == (ctla, cntlc, cntld, cntlx, del)) 2387 * return(a=0); 2388 * if(a == backspace) 2389 * if(b > 0) b--; 2390 * else b=0; 2391 * else inbuff[b] = upcase(a); 2392 * if(b < bufflng) b++; 2393 *until (a == [cr,lf,+,^,-,/,=]) 2394 *return(a); 2395 2396 ec2a 5f CLRB 2397 ec2b bd e5 5b RLN1 JSR INCHAR 2398 ec2e 81 7f CMPA #DEL Delete 2399 ec30 27 31 BEQ RLNQUIT 2400 ec32 81 18 CMPA #CTLX Control X 2401 ec34 27 2d BEQ RLNQUIT 2402 ec36 81 01 CMPA #CTLA Control A 2403 ec38 27 29 BEQ RLNQUIT 2404 ec3a 81 2e CMPA #$2E Period 2405 ec3c 27 25 BEQ RLNQUIT 2406 ec3e 81 03 CMPA #$03 Control C 2407 ec40 27 21 BEQ RLNQUIT 2408 ec42 81 04 CMPA #$04 Control D 2409 ec44 27 1d BEQ RLNQUIT 2410 ec46 81 08 CMPA #$08 backspace 2411 ec48 26 05 BNE RLN2 2412 ec4a 5a DECB 2413 ec4b 2e de BGT RLN1 2414 ec4d 20 cd BRA READLN start over 2415 ec4f ce 00 6b RLN2 LDX #INBUFF 2416 ec52 3a ABX 2417 ec53 bd e1 f2 JSR UPCASE 2418 ec56 a7 00 STAA 0,X put char in buffer 2419 ec58 c1 23 CMPB #BUFFLNG max buffer length 2420 ec5a 2c 01 BGE RLN3 jump if buffer full 2421 ec5c 5c INCB move buffer pointer 2422 ec5d bd ec 91 RLN3 JSR ASSCHEK check for subcommand 2423 ec60 26 c9 BNE RLN1 2424 ec62 39 RTS 2425 ec63 4f RLNQUIT CLRA quit 2426 ec64 39 RTS return 2427 2428 2429 ********** 2430 * parse() -parse out the mnemonic from INBUFF 2431 * to COMBUFF. on exit: b=number of chars parsed. 2432 ********** 2433 *combuff[3] = ; initialize 4th character to space. 2434 *ptrbuff[] = inbuff[]; 2435 *a=wskip(); 2436 *for (b = 0; b = 5; b++) 2437 * a=readbuff(); incbuff(); 2438 * if (a = (cr,lf,^,/,wspace)) return(b); 2439 * combuff[b] = upcase(a); 2440 *return(b); 2441 2442 ec65 86 20 PARSE LDAA #$20 2443 ec67 97 91 STAA COMBUFF+3 2444 ec69 ce 00 6b LDX #INBUFF initialize buffer ptr 2445 ec6c df ae STX PTR0 2446 ec6e bd e3 4b JSR WSKIP find first character 2447 ec71 5f CLRB 2448 ec72 bd e3 36 PARSLP JSR READBUFF read character 2449 ec75 bd e3 3d JSR INCBUFF 2450 ec78 bd e3 5b JSR WCHEK 2451 ec7b 27 13 BEQ PARSRT jump if whitespace 2452 ec7d bd ec 91 JSR ASSCHEK 2453 ec80 27 0e BEQ PARSRT jump if end of line 2454 ec82 bd e1 f2 JSR UPCASE convert to upper case 2455 ec85 ce 00 8e LDX #COMBUFF 2456 ec88 3a ABX 2457 ec89 a7 00 STAA 0,X store in combuff 2458 ec8b 5c INCB 2459 ec8c c1 05 CMPB #$5 2460 ec8e 2f e2 BLE PARSLP loop 6 times 2461 ec90 39 PARSRT RTS 2462 2463 2464 **************** 2465 * asschek() -perform compares for 2466 * lf, cr, ^, /, +, -, = 2467 **************** 2468 ec91 81 0a ASSCHEK CMPA #$0A linefeed 2469 ec93 27 16 BEQ ASSCHK1 2470 ec95 81 0d CMPA #$0D carriage ret 2471 ec97 27 12 BEQ ASSCHK1 2472 ec99 81 5e CMPA #'^' up arrow 2473 ec9b 27 0e BEQ ASSCHK1 2474 ec9d 81 2f CMPA #'/' slash 2475 ec9f 27 0a BEQ ASSCHK1 2476 eca1 81 2b CMPA #'+' plus 2477 eca3 27 06 BEQ ASSCHK1 2478 eca5 81 2d CMPA #'-' minus 2479 eca7 27 02 BEQ ASSCHK1 2480 eca9 81 3d CMPA #'=' equals 2481 ecab 39 ASSCHK1 RTS 2482 2483 2484 ********* 2485 * msrch() --- Search MNETABL for mnemonic in COMBUFF. 2486 *stores base opcode at baseop and class at class. 2487 * Class = FF if not found. 2488 ********** 2489 *while ( != EOF ) 2490 * if (COMBUFF[0-3] = MNETABL[0-3]) 2491 * return(MNETABL[4],MNETABL[5]); 2492 * else *MNETABL =+ 6 2493 2494 ecac ce f0 0e MSRCH LDX #MNETABL pointer to mnemonic table 2495 ecaf 18 ce 00 8e LDY #COMBUFF pointer to string 2496 ecb3 20 03 BRA MSRCH1 2497 ecb5 MSNEXT EQU * 2498 ecb5 c6 06 LDAB #6 2499 ecb7 3a ABX point to next table entry 2500 ecb8 a6 00 MSRCH1 LDAA 0,X read table 2501 ecba 81 04 CMPA #EOT 2502 ecbc 26 05 BNE MSRCH2 jump if not end of table 2503 ecbe 86 ff LDAA #$FF 2504 ecc0 97 b5 STAA CLASS FF = not in table 2505 ecc2 39 RTS 2506 ecc3 18 a1 00 MSRCH2 CMPA 0,Y op[0] = tabl[0] ? 2507 ecc6 26 ed BNE MSNEXT 2508 ecc8 a6 01 LDAA 1,X 2509 ecca 18 a1 01 CMPA 1,Y op[1] = tabl[1] ? 2510 eccd 26 e6 BNE MSNEXT 2511 eccf a6 02 LDAA 2,X 2512 ecd1 18 a1 02 CMPA 2,Y op[2] = tabl[2] ? 2513 ecd4 26 df BNE MSNEXT 2514 ecd6 a6 03 LDAA 3,X 2515 ecd8 18 a1 03 CMPA 3,Y op[2] = tabl[2] ? 2516 ecdb 26 d8 BNE MSNEXT 2517 ecdd ec 04 LDD 4,X opcode, class 2518 ecdf 97 b4 STAA BASEOP 2519 ece1 d7 b5 STAB CLASS 2520 ece3 39 RTS 2521 2522 ********** 2523 ** doop(baseop,class) --- process mnemonic. 2524 ** on exit: a=error code corresponding to error 2525 ** messages. 2526 ********** 2527 *amode = OTHER; /* addressing mode */ 2528 *yflag = 0; /* ynoimm, nlimm, and cpd flag */ 2529 *x[] = ptrbuff[] 2530 2531 ece4 DOOP EQU * 2532 ece4 86 04 LDAA #OTHER 2533 ece6 97 c1 STAA AMODE mode 2534 ece8 7f 00 c2 CLR YFLAG 2535 eceb de ae LDX PTR0 2536 2537 *while (*x != end of buffer) 2538 * if (x[0]++ == ',') 2539 * if (x[0] == 'y') amode = INDY; 2540 * else amod = INDX; 2541 * break; 2542 *a = wskip() 2543 *if( a == '#' ) amode = IMMED; 2544 2545 eced 8c 00 8e DOPLP1 CPX #ENDBUFF (end of buffer) 2546 ecf0 27 1b BEQ DOOP1 jump if end of buffer 2547 ecf2 ec 00 LDD 0,X read 2 chars from buffer 2548 ecf4 08 INX move pointer 2549 ecf5 81 2c CMPA #',' 2550 ecf7 26 f4 BNE DOPLP1 2551 ecf9 c1 59 CMPB #'Y' look for ",y" 2552 ecfb 26 06 BNE DOPLP2 2553 ecfd 86 02 LDAA #INDY 2554 ecff 97 c1 STAA AMODE 2555 ed01 20 0a BRA DOOP1 2556 ed03 c1 58 DOPLP2 CMPB #'X' look for ",x" 2557 ed05 26 06 BNE DOOP1 jump if not x 2558 ed07 86 01 LDAA #INDX 2559 ed09 97 c1 STAA AMODE 2560 ed0b 20 00 BRA DOOP1 2561 ed0d bd e3 4b DOOP1 JSR WSKIP 2562 ed10 81 23 CMPA #'#' look for immediate mode 2563 ed12 26 07 BNE DOOP2 2564 ed14 bd e3 3d JSR INCBUFF point at argument 2565 ed17 86 00 LDAA #IMMED 2566 ed19 97 c1 STAA AMODE 2567 ed1b DOOP2 EQU * 2568 2569 *switch(class) 2570 ed1b d6 b5 LDAB CLASS 2571 ed1d c1 02 CMPB #P2INH 2572 ed1f 26 03 BNE DOSW1 2573 ed21 7e ed 82 JMP DOP2I 2574 ed24 c1 01 DOSW1 CMPB #INH 2575 ed26 26 03 BNE DOSW2 2576 ed28 7e ed 87 JMP DOINH 2577 ed2b c1 05 DOSW2 CMPB #REL 2578 ed2d 26 03 BNE DOSW3 2579 ed2f 7e ed 8e JMP DOREL 2580 ed32 c1 08 DOSW3 CMPB #LIMM 2581 ed34 26 03 BNE DOSW4 2582 ed36 7e ed bd JMP DOLIM 2583 ed39 c1 07 DOSW4 CMPB #NIMM 2584 ed3b 26 03 BNE DOSW5 2585 ed3d 7e ed c7 JMP DONOI 2586 ed40 c1 03 DOSW5 CMPB #GEN 2587 ed42 26 03 BNE DOSW6 2588 ed44 7e ed d0 JMP DOGENE 2589 ed47 c1 04 DOSW6 CMPB #GRP2 2590 ed49 26 03 BNE DOSW7 2591 ed4b 7e ed de JMP DOGRP 2592 ed4e c1 15 DOSW7 CMPB #CPD 2593 ed50 26 03 BNE DOSW8 2594 ed52 7e ee 10 JMP DOCPD 2595 ed55 c1 10 DOSW8 CMPB #XNIMM 2596 ed57 26 03 BNE DOSW9 2597 ed59 7e ee 31 JMP DOXNOI 2598 ed5c c1 09 DOSW9 CMPB #XLIMM 2599 ed5e 26 03 BNE DOSW10 2600 ed60 7e ee 3a JMP DOXLI 2601 ed63 c1 12 DOSW10 CMPB #YNIMM 2602 ed65 26 03 BNE DOSW11 2603 ed67 7e ee 52 JMP DOYNOI 2604 ed6a c1 11 DOSW11 CMPB #YLIMM 2605 ed6c 26 03 BNE DOSW12 2606 ed6e 7e ee 5b JMP DOYLI 2607 ed71 c1 13 DOSW12 CMPB #BTB 2608 ed73 26 03 BNE DOSW13 2609 ed75 7e ee 7a JMP DOBTB 2610 ed78 c1 14 DOSW13 CMPB #SETCLR 2611 ed7a 26 03 BNE DODEF 2612 ed7c 7e ee 7a JMP DOSET 2613 2614 * default: return("error in mnemonic table"); 2615 2616 ed7f 86 02 DODEF LDAA #$2 2617 ed81 39 RTS 2618 2619 * case P2INH: emit(PAGE2) 2620 2621 ed82 86 18 DOP2I LDAA #PAGE2 2622 ed84 bd f0 03 JSR EMIT 2623 2624 * case INH: emit(baseop); 2625 * return(0); 2626 2627 ed87 96 b4 DOINH LDAA BASEOP 2628 ed89 bd f0 03 JSR EMIT 2629 ed8c 4f CLRA 2630 ed8d 39 RTS 2631 2632 * case REL: a = assarg(); 2633 * if(a=4) return(a); 2634 * d = address - pc + 2; 2635 * if ($7f >= d >= $ff82) 2636 * return (out of range); 2637 * emit(opcode); 2638 * emit(offset); 2639 * return(0); 2640 2641 ed8e bd ef e5 DOREL JSR ASSARG 2642 ed91 81 04 CMPA #$04 2643 ed93 26 01 BNE DOREL1 jump if arg ok 2644 ed95 39 RTS 2645 ed96 dc 96 DOREL1 LDD SHFTREG get branch address 2646 ed98 de b0 LDX PC get program counter 2647 ed9a 08 INX 2648 ed9b 08 INX point to end of opcode 2649 ed9c df b8 STX BRADDR 2650 ed9e 93 b8 SUBD BRADDR calculate offset 2651 eda0 dd b8 STD BRADDR save result 2652 eda2 1a 83 00 7f CMPD #$7F in range ? 2653 eda6 23 09 BLS DOREL2 jump if in range 2654 eda8 1a 83 ff 80 CMPD #$FF80 2655 edac 24 03 BHS DOREL2 jump if in range 2656 edae 86 09 LDAA #$09 'Out of range' 2657 edb0 39 RTS 2658 edb1 96 b4 DOREL2 LDAA BASEOP 2659 edb3 bd f0 03 JSR EMIT emit opcode 2660 edb6 96 b9 LDAA BRADDR+1 2661 edb8 bd f0 03 JSR EMIT emit offset 2662 edbb 4f CLRA normal return 2663 edbc 39 RTS 2664 2665 * case LIMM: if (amode == IMMED) amode = LIMMED; 2666 2667 edbd 96 c1 DOLIM LDAA AMODE 2668 edbf 81 00 CMPA #IMMED 2669 edc1 26 04 BNE DONOI 2670 edc3 86 03 LDAA #LIMMED 2671 edc5 97 c1 STAA AMODE 2672 2673 * case NIMM: if (amode == IMMED) 2674 * return("Immediate mode illegal"); 2675 2676 edc7 96 c1 DONOI LDAA AMODE 2677 edc9 81 00 CMPA #IMMED 2678 edcb 26 03 BNE DOGENE jump if not immediate 2679 edcd 86 01 LDAA #$1 "immediate mode illegal" 2680 edcf 39 RTS 2681 2682 * case GEN: dogen(baseop,amode,PAGE1,PAGE1,PAGE2); 2683 * return; 2684 2685 edd0 86 00 DOGENE LDAA #PAGE1 2686 edd2 97 c3 STAA PNORM 2687 edd4 97 b2 STAA PX 2688 edd6 86 18 LDAA #PAGE2 2689 edd8 97 b3 STAA PY 2690 edda bd ef 16 JSR DOGEN 2691 eddd 39 RTS 2692 2693 * case GRP2: if (amode == INDY) 2694 * emit(PAGE2); 2695 * amode = INDX; 2696 * if( amode == INDX ) 2697 * doindx(baseop); 2698 * else a = assarg(); 2699 * if(a=4) return(a); 2700 * emit(opcode+0x10); 2701 * emit(extended address); 2702 * return; 2703 2704 edde 96 c1 DOGRP LDAA AMODE 2705 ede0 81 02 CMPA #INDY 2706 ede2 26 09 BNE DOGRP1 2707 ede4 86 18 LDAA #PAGE2 2708 ede6 bd f0 03 JSR EMIT 2709 ede9 86 01 LDAA #INDX 2710 edeb 97 c1 STAA AMODE 2711 eded DOGRP1 EQU * 2712 eded 96 c1 LDAA AMODE 2713 edef 81 01 CMPA #INDX 2714 edf1 26 04 BNE DOGRP2 2715 edf3 bd ef b6 JSR DOINDEX 2716 edf6 39 RTS 2717 edf7 DOGRP2 EQU * 2718 edf7 96 b4 LDAA BASEOP 2719 edf9 8b 10 ADDA #$10 2720 edfb bd f0 03 JSR EMIT 2721 edfe bd ef e5 JSR ASSARG 2722 ee01 81 04 CMPA #$04 2723 ee03 27 0a BEQ DOGRPRT jump if bad arg 2724 ee05 dc 96 LDD SHFTREG extended address 2725 ee07 bd f0 03 JSR EMIT 2726 ee0a 17 TBA 2727 ee0b bd f0 03 JSR EMIT 2728 ee0e 4f CLRA 2729 ee0f 39 DOGRPRT RTS 2730 2731 * case CPD: if (amode == IMMED) 2732 * amode = LIMMED; /* cpd */ 2733 * if( amode == INDY ) yflag = 1; 2734 * dogen(baseop,amode,PAGE3,PAGE3,PAGE4); 2735 * return; 2736 2737 ee10 96 c1 DOCPD LDAA AMODE 2738 ee12 81 00 CMPA #IMMED 2739 ee14 26 04 BNE DOCPD1 2740 ee16 86 03 LDAA #LIMMED 2741 ee18 97 c1 STAA AMODE 2742 ee1a 96 c1 DOCPD1 LDAA AMODE 2743 ee1c 81 02 CMPA #INDY 2744 ee1e 26 03 BNE DOCPD2 2745 ee20 7c 00 c2 INC YFLAG 2746 ee23 86 1a DOCPD2 LDAA #PAGE3 2747 ee25 97 c3 STAA PNORM 2748 ee27 97 b2 STAA PX 2749 ee29 86 cd LDAA #PAGE4 2750 ee2b 97 b3 STAA PY 2751 ee2d bd ef 16 JSR DOGEN 2752 ee30 39 RTS 2753 2754 * case XNIMM: if (amode == IMMED) /* stx */ 2755 * return("Immediate mode illegal"); 2756 2757 ee31 96 c1 DOXNOI LDAA AMODE 2758 ee33 81 00 CMPA #IMMED 2759 ee35 26 03 BNE DOXLI 2760 ee37 86 01 LDAA #$1 "immediate mode illegal" 2761 ee39 39 RTS 2762 2763 * case XLIMM: if (amode == IMMED) /* cpx, ldx */ 2764 * amode = LIMMED; 2765 * dogen(baseop,amode,PAGE1,PAGE1,PAGE4); 2766 * return; 2767 2768 ee3a 96 c1 DOXLI LDAA AMODE 2769 ee3c 81 00 CMPA #IMMED 2770 ee3e 26 04 BNE DOXLI1 2771 ee40 86 03 LDAA #LIMMED 2772 ee42 97 c1 STAA AMODE 2773 ee44 86 00 DOXLI1 LDAA #PAGE1 2774 ee46 97 c3 STAA PNORM 2775 ee48 97 b2 STAA PX 2776 ee4a 86 cd LDAA #PAGE4 2777 ee4c 97 b3 STAA PY 2778 ee4e bd ef 16 JSR DOGEN 2779 ee51 39 RTS 2780 2781 * case YNIMM: if (amode == IMMED) /* sty */ 2782 * return("Immediate mode illegal"); 2783 2784 ee52 96 c1 DOYNOI LDAA AMODE 2785 ee54 81 00 CMPA #IMMED 2786 ee56 26 03 BNE DOYLI 2787 ee58 86 01 LDAA #$1 "immediate mode illegal" 2788 ee5a 39 RTS 2789 2790 * case YLIMM: if (amode == INDY) yflag = 1;/* cpy, ldy */ 2791 * if(amode == IMMED) amode = LIMMED; 2792 * dogen(opcode,amode,PAGE2,PAGE3,PAGE2); 2793 * return; 2794 2795 ee5b 96 c1 DOYLI LDAA AMODE 2796 ee5d 81 02 CMPA #INDY 2797 ee5f 26 03 BNE DOYLI1 2798 ee61 7c 00 c2 INC YFLAG 2799 ee64 81 00 DOYLI1 CMPA #IMMED 2800 ee66 26 04 BNE DOYLI2 2801 ee68 86 03 LDAA #LIMMED 2802 ee6a 97 c1 STAA AMODE 2803 ee6c 86 18 DOYLI2 LDAA #PAGE2 2804 ee6e 97 c3 STAA PNORM 2805 ee70 97 b3 STAA PY 2806 ee72 86 1a LDAA #PAGE3 2807 ee74 97 b2 STAA PX 2808 ee76 bd ef 16 JSR DOGEN 2809 ee79 39 RTS 2810 2811 * case BTB: /* bset, bclr */ 2812 * case SETCLR: a = bitop(baseop,amode,class); 2813 * if(a=0) return(a = 3); 2814 * if( amode == INDY ) 2815 * emit(PAGE2); 2816 * amode = INDX; 2817 2818 ee7a DOBTB EQU * 2819 ee7a bd ee f0 DOSET JSR BITOP 2820 ee7d 81 00 CMPA #$00 2821 ee7f 26 03 BNE DOSET1 2822 ee81 86 03 LDAA #$3 "illegal bit op" 2823 ee83 39 RTS 2824 ee84 96 c1 DOSET1 LDAA AMODE 2825 ee86 81 02 CMPA #INDY 2826 ee88 26 09 BNE DOSET2 2827 ee8a 86 18 LDAA #PAGE2 2828 ee8c bd f0 03 JSR EMIT 2829 ee8f 86 01 LDAA #INDX 2830 ee91 97 c1 STAA AMODE 2831 ee93 DOSET2 EQU * 2832 2833 * emit(baseop); 2834 * a = assarg(); 2835 * if(a = 4) return(a); 2836 * emit(index offset); 2837 * if( amode == INDX ) 2838 * Buffptr += 2; /* skip ,x or ,y */ 2839 2840 ee93 96 b4 LDAA BASEOP 2841 ee95 bd f0 03 JSR EMIT 2842 ee98 bd ef e5 JSR ASSARG 2843 ee9b 81 04 CMPA #$04 2844 ee9d 26 01 BNE DOSET22 jump if arg ok 2845 ee9f 39 RTS 2846 eea0 96 97 DOSET22 LDAA SHFTREG+1 index offset 2847 eea2 bd f0 03 JSR EMIT 2848 eea5 96 c1 LDAA AMODE 2849 eea7 81 01 CMPA #INDX 2850 eea9 26 06 BNE DOSET3 2851 eeab bd e3 3d JSR INCBUFF 2852 eeae bd e3 3d JSR INCBUFF 2853 eeb1 DOSET3 EQU * 2854 2855 * a = assarg(); 2856 * if(a = 4) return(a); 2857 * emit(mask); /* mask */ 2858 * if( class == SETCLR ) 2859 * return; 2860 2861 eeb1 bd ef e5 JSR ASSARG 2862 eeb4 81 04 CMPA #$04 2863 eeb6 26 01 BNE DOSET33 jump if arg ok 2864 eeb8 39 RTS 2865 eeb9 96 97 DOSET33 LDAA SHFTREG+1 mask 2866 eebb bd f0 03 JSR EMIT 2867 eebe 96 b5 LDAA CLASS 2868 eec0 81 14 CMPA #SETCLR 2869 eec2 26 02 BNE DOSET4 2870 eec4 4f CLRA 2871 eec5 39 RTS 2872 eec6 DOSET4 EQU * 2873 2874 * a = assarg(); 2875 * if(a = 4) return(a); 2876 * d = (pc+1) - shftreg; 2877 * if ($7f >= d >= $ff82) 2878 * return (out of range); 2879 * emit(branch offset); 2880 * return(0); 2881 2882 eec6 bd ef e5 JSR ASSARG 2883 eec9 81 04 CMPA #$04 2884 eecb 26 01 BNE DOSET5 jump if arg ok 2885 eecd 39 RTS 2886 eece de b0 DOSET5 LDX PC program counter 2887 eed0 08 INX point to next inst 2888 eed1 df b8 STX BRADDR save pc value 2889 eed3 dc 96 LDD SHFTREG get branch address 2890 eed5 93 b8 SUBD BRADDR calculate offset 2891 eed7 1a 83 00 7f CMPD #$7F 2892 eedb 23 0d BLS DOSET6 jump if in range 2893 eedd 1a 83 ff 80 CMPD #$FF80 2894 eee1 24 07 BHS DOSET6 jump if in range 2895 eee3 4f CLRA 2896 eee4 bd f0 03 JSR EMIT 2897 eee7 86 09 LDAA #$09 'out of range' 2898 eee9 39 RTS 2899 eeea 17 DOSET6 TBA offset 2900 eeeb bd f0 03 JSR EMIT 2901 eeee 4f CLRA 2902 eeef 39 RTS 2903 2904 2905 ********** 2906 ** bitop(baseop,amode,class) --- adjust opcode on bit 2907 ** manipulation instructions. Returns opcode in a 2908 ** or a = 0 if error 2909 ********** 2910 *if( amode == INDX || amode == INDY ) return(op); 2911 *if( class == SETCLR ) return(op-8); 2912 *else if(class==BTB) return(op-12); 2913 *else fatal("bitop"); 2914 2915 eef0 BITOP EQU * 2916 eef0 96 c1 LDAA AMODE 2917 eef2 d6 b5 LDAB CLASS 2918 eef4 81 01 CMPA #INDX 2919 eef6 26 01 BNE BITOP1 2920 eef8 39 RTS 2921 eef9 81 02 BITOP1 CMPA #INDY 2922 eefb 26 01 BNE BITOP2 jump not indexed 2923 eefd 39 RTS 2924 eefe c1 14 BITOP2 CMPB #SETCLR 2925 ef00 26 07 BNE BITOP3 jump not bset,bclr 2926 ef02 96 b4 LDAA BASEOP get opcode 2927 ef04 80 08 SUBA #8 2928 ef06 97 b4 STAA BASEOP 2929 ef08 39 RTS 2930 ef09 c1 13 BITOP3 CMPB #BTB 2931 ef0b 26 07 BNE BITOP4 jump not bit branch 2932 ef0d 96 b4 LDAA BASEOP get opcode 2933 ef0f 80 0c SUBA #12 2934 ef11 97 b4 STAA BASEOP 2935 ef13 39 RTS 2936 ef14 4f BITOP4 CLRA 0 = fatal bitop 2937 ef15 39 RTS 2938 2939 ********** 2940 ** dogen(baseop,mode,pnorm,px,py) - process 2941 ** general addressing modes. Returns a = error #. 2942 ********** 2943 *pnorm = page for normal addressing modes: IMM,DIR,EXT 2944 *px = page for INDX addressing 2945 *py = page for INDY addressing 2946 *switch(amode) 2947 ef16 96 c1 DOGEN LDAA AMODE 2948 ef18 81 03 CMPA #LIMMED 2949 ef1a 27 13 BEQ DOGLIM 2950 ef1c 81 00 CMPA #IMMED 2951 ef1e 27 2c BEQ DOGIMM 2952 ef20 81 02 CMPA #INDY 2953 ef22 27 41 BEQ DOGINDY 2954 ef24 81 01 CMPA #INDX 2955 ef26 27 4c BEQ DOGINDX 2956 ef28 81 04 CMPA #OTHER 2957 ef2a 27 57 BEQ DOGOTH 2958 2959 *default: error("Unknown Addressing Mode"); 2960 2961 ef2c 86 06 DOGDEF LDAA #$06 unknown addre... 2962 ef2e 39 RTS 2963 2964 *case LIMMED: epage(pnorm); 2965 * emit(baseop); 2966 * a = assarg(); 2967 * if(a = 4) return(a); 2968 * emit(2 bytes); 2969 * return(0); 2970 2971 ef2f 96 c3 DOGLIM LDAA PNORM 2972 ef31 bd ef fb JSR EPAGE 2973 ef34 96 b4 DOGLIM1 LDAA BASEOP 2974 ef36 bd f0 03 JSR EMIT 2975 ef39 bd ef e5 JSR ASSARG get next argument 2976 ef3c 81 04 CMPA #$04 2977 ef3e 26 01 BNE DOGLIM2 jump if arg ok 2978 ef40 39 RTS 2979 ef41 dc 96 DOGLIM2 LDD SHFTREG 2980 ef43 bd f0 03 JSR EMIT 2981 ef46 17 TBA 2982 ef47 bd f0 03 JSR EMIT 2983 ef4a 4f CLRA 2984 ef4b 39 RTS 2985 2986 *case IMMED: epage(pnorm); 2987 * emit(baseop); 2988 * a = assarg(); 2989 * if(a = 4) return(a); 2990 * emit(lobyte); 2991 * return(0); 2992 2993 ef4c 96 c3 DOGIMM LDAA PNORM 2994 ef4e bd ef fb JSR EPAGE 2995 ef51 96 b4 LDAA BASEOP 2996 ef53 bd f0 03 JSR EMIT 2997 ef56 bd ef e5 JSR ASSARG 2998 ef59 81 04 CMPA #$04 2999 ef5b 26 01 BNE DOGIMM1 jump if arg ok 3000 ef5d 39 RTS 3001 ef5e 96 97 DOGIMM1 LDAA SHFTREG+1 3002 ef60 bd f0 03 JSR EMIT 3003 ef63 4f CLRA 3004 ef64 39 RTS 3005 3006 *case INDY: epage(py); 3007 * a=doindex(op+0x20); 3008 * return(a); 3009 3010 ef65 96 b3 DOGINDY LDAA PY 3011 ef67 bd ef fb JSR EPAGE 3012 ef6a 96 b4 LDAA BASEOP 3013 ef6c 8b 20 ADDA #$20 3014 ef6e 97 b4 STAA BASEOP 3015 ef70 bd ef b6 JSR DOINDEX 3016 ef73 39 RTS 3017 3018 *case INDX: epage(px); 3019 * a=doindex(op+0x20); 3020 * return(a); 3021 3022 ef74 96 b2 DOGINDX LDAA PX 3023 ef76 bd ef fb JSR EPAGE 3024 ef79 96 b4 LDAA BASEOP 3025 ef7b 8b 20 ADDA #$20 3026 ef7d 97 b4 STAA BASEOP 3027 ef7f bd ef b6 JSR DOINDEX 3028 ef82 39 RTS 3029 3030 *case OTHER: a = assarg(); 3031 * if(a = 4) return(a); 3032 * epage(pnorm); 3033 * if(countu1 <= 2 digits) /* direct */ 3034 * emit(op+0x10); 3035 * emit(lobyte(Result)); 3036 * return(0); 3037 * else emit(op+0x30); /* extended */ 3038 * eword(Result); 3039 * return(0) 3040 3041 ef83 bd ef e5 DOGOTH JSR ASSARG 3042 ef86 81 04 CMPA #$04 3043 ef88 26 01 BNE DOGOTH0 jump if arg ok 3044 ef8a 39 RTS 3045 ef8b 96 c3 DOGOTH0 LDAA PNORM 3046 ef8d bd ef fb JSR EPAGE 3047 ef90 96 a8 LDAA COUNT 3048 ef92 81 02 CMPA #$2 3049 ef94 2e 0e BGT DOGOTH1 3050 ef96 96 b4 LDAA BASEOP 3051 ef98 8b 10 ADDA #$10 direct mode opcode 3052 ef9a bd f0 03 JSR EMIT 3053 ef9d 96 97 LDAA SHFTREG+1 3054 ef9f bd f0 03 JSR EMIT 3055 efa2 4f CLRA 3056 efa3 39 RTS 3057 efa4 96 b4 DOGOTH1 LDAA BASEOP 3058 efa6 8b 30 ADDA #$30 extended mode opcode 3059 efa8 bd f0 03 JSR EMIT 3060 efab dc 96 LDD SHFTREG 3061 efad bd f0 03 JSR EMIT 3062 efb0 17 TBA 3063 efb1 bd f0 03 JSR EMIT 3064 efb4 4f CLRA 3065 efb5 39 RTS 3066 3067 ********** 3068 ** doindex(op) --- handle all wierd stuff for 3069 ** indexed addressing. Returns a = error number. 3070 ********** 3071 *emit(baseop); 3072 *a=assarg(); 3073 *if(a = 4) return(a); 3074 *if( a != ',' ) return("Syntax"); 3075 *buffptr++ 3076 *a=readbuff() 3077 *if( a != 'x' && != 'y') warn("Ind Addr Assumed"); 3078 *emit(lobyte); 3079 *return(0); 3080 3081 efb6 96 b4 DOINDEX LDAA BASEOP 3082 efb8 bd f0 03 JSR EMIT 3083 efbb bd ef e5 JSR ASSARG 3084 efbe 81 04 CMPA #$04 3085 efc0 26 01 BNE DOINDX0 jump if arg ok 3086 efc2 39 RTS 3087 efc3 81 2c DOINDX0 CMPA #',' 3088 efc5 27 03 BEQ DOINDX1 3089 efc7 86 08 LDAA #$08 "syntax error" 3090 efc9 39 RTS 3091 efca bd e3 3d DOINDX1 JSR INCBUFF 3092 efcd bd e3 36 JSR READBUFF 3093 efd0 81 59 CMPA #'Y' 3094 efd2 27 0a BEQ DOINDX2 3095 efd4 81 58 CMPA #'X' 3096 efd6 27 06 BEQ DOINDX2 3097 efd8 fe ea ff LDX MSGA7 "index addr assumed" 3098 efdb bd e5 2f JSR OUTSTRG 3099 efde 96 97 DOINDX2 LDAA SHFTREG+1 3100 efe0 bd f0 03 JSR EMIT 3101 efe3 4f CLRA 3102 efe4 39 RTS 3103 3104 ********** 3105 ** assarg(); - get argument. Returns a = 4 if bad 3106 ** argument, else a = first non hex char. 3107 ********** 3108 *a = buffarg() 3109 *if(asschk(aa) && countu1 != 0) return(a); 3110 *return(bad argument); 3111 3112 efe5 bd e2 7f ASSARG JSR BUFFARG 3113 efe8 bd ec 91 JSR ASSCHEK check for command 3114 efeb 27 05 BEQ ASSARG1 jump if ok 3115 efed bd e3 5b JSR WCHEK check for whitespace 3116 eff0 26 06 BNE ASSARG2 jump if not ok 3117 eff2 7d 00 a8 ASSARG1 TST COUNT 3118 eff5 27 01 BEQ ASSARG2 jump if no argument 3119 eff7 39 RTS 3120 eff8 86 04 ASSARG2 LDAA #$04 bad argument 3121 effa 39 RTS 3122 3123 ********** 3124 ** epage(a) --- emit page prebyte 3125 ********** 3126 *if( a != PAGE1 ) emit(a); 3127 3128 effb 81 00 EPAGE CMPA #PAGE1 3129 effd 27 03 BEQ EPAGRT jump if page 1 3130 efff bd f0 03 JSR EMIT 3131 f002 39 EPAGRT RTS 3132 3133 ********** 3134 * emit(a) --- emit contents of a 3135 ********** 3136 f003 de b0 EMIT LDX PC 3137 f005 bd e2 d5 JSR WRITE write a to x 3138 f008 bd e5 16 JSR OUT1BSP 3139 f00b df b0 STX PC 3140 f00d 39 RTS 3141 3142 *Mnemonic table for hc11 line assembler 3143 0000 NULL EQU $0 nothing 3144 0001 INH EQU $1 inherent 3145 0002 P2INH EQU $2 page 2 inherent 3146 0003 GEN EQU $3 general addressing 3147 0004 GRP2 EQU $4 group 2 3148 0005 REL EQU $5 relative 3149 0006 IMM EQU $6 immediate 3150 0007 NIMM EQU $7 general except for immediate 3151 0008 LIMM EQU $8 2 byte immediate 3152 0009 XLIMM EQU $9 longimm for x 3153 0010 XNIMM EQU $10 no immediate for x 3154 0011 YLIMM EQU $11 longimm for y 3155 0012 YNIMM EQU $12 no immediate for y 3156 0013 BTB EQU $13 bit test and branch 3157 0014 SETCLR EQU $14 bit set or clear 3158 0015 CPD EQU $15 compare d 3159 0016 BTBD EQU $16 bit test and branch direct 3160 0017 SETCLRD EQU $17 bit set or clear direct 3161 3162 ********** 3163 * mnetabl - includes all '11 mnemonics, base opcodes, 3164 * and type of instruction. The assembler search routine 3165 *depends on 4 characters for each mnemonic so that 3 char 3166 *mnemonics are extended with a space and 5 char mnemonics 3167 *are truncated. 3168 ********** 3169 3170 f00e MNETABL EQU * 3171 f00e 41 42 41 20 FCC 'ABA ' Mnemonic 3172 f012 1b FCB $1B Base opcode 3173 f013 01 FCB INH Class 3174 f014 41 42 58 20 FCC 'ABX ' 3175 f018 3a FCB $3A 3176 f019 01 FCB INH 3177 f01a 41 42 59 20 FCC 'ABY ' 3178 f01e 3a FCB $3A 3179 f01f 02 FCB P2INH 3180 f020 41 44 43 41 FCC 'ADCA' 3181 f024 89 FCB $89 3182 f025 03 FCB GEN 3183 f026 41 44 43 42 FCC 'ADCB' 3184 f02a c9 FCB $C9 3185 f02b 03 FCB GEN 3186 f02c 41 44 44 41 FCC 'ADDA' 3187 f030 8b FCB $8B 3188 f031 03 FCB GEN 3189 f032 41 44 44 42 FCC 'ADDB' 3190 f036 cb FCB $CB 3191 f037 03 FCB GEN 3192 f038 41 44 44 44 FCC 'ADDD' 3193 f03c c3 FCB $C3 3194 f03d 08 FCB LIMM 3195 f03e 41 4e 44 41 FCC 'ANDA' 3196 f042 84 FCB $84 3197 f043 03 FCB GEN 3198 f044 41 4e 44 42 FCC 'ANDB' 3199 f048 c4 FCB $C4 3200 f049 03 FCB GEN 3201 f04a 41 53 4c 20 FCC 'ASL ' 3202 f04e 68 FCB $68 3203 f04f 04 FCB GRP2 3204 f050 41 53 4c 41 FCC 'ASLA' 3205 f054 48 FCB $48 3206 f055 01 FCB INH 3207 f056 41 53 4c 42 FCC 'ASLB' 3208 f05a 58 FCB $58 3209 f05b 01 FCB INH 3210 f05c 41 53 4c 44 FCC 'ASLD' 3211 f060 05 FCB $05 3212 f061 01 FCB INH 3213 f062 41 53 52 20 FCC 'ASR ' 3214 f066 67 FCB $67 3215 f067 04 FCB GRP2 3216 f068 41 53 52 41 FCC 'ASRA' 3217 f06c 47 FCB $47 3218 f06d 01 FCB INH 3219 f06e 41 53 52 42 FCC 'ASRB' 3220 f072 57 FCB $57 3221 f073 01 FCB INH 3222 f074 42 43 43 20 FCC 'BCC ' 3223 f078 24 FCB $24 3224 f079 05 FCB REL 3225 f07a 42 43 4c 52 FCC 'BCLR' 3226 f07e 1d FCB $1D 3227 f07f 14 FCB SETCLR 3228 f080 42 43 53 20 FCC 'BCS ' 3229 f084 25 FCB $25 3230 f085 05 FCB REL 3231 f086 42 45 51 20 FCC 'BEQ ' 3232 f08a 27 FCB $27 3233 f08b 05 FCB REL 3234 f08c 42 47 45 20 FCC 'BGE ' 3235 f090 2c FCB $2C 3236 f091 05 FCB REL 3237 f092 42 47 54 20 FCC 'BGT ' 3238 f096 2e FCB $2E 3239 f097 05 FCB REL 3240 f098 42 48 49 20 FCC 'BHI ' 3241 f09c 22 FCB $22 3242 f09d 05 FCB REL 3243 f09e 42 48 53 20 FCC 'BHS ' 3244 f0a2 24 FCB $24 3245 f0a3 05 FCB REL 3246 f0a4 42 49 54 41 FCC 'BITA' 3247 f0a8 85 FCB $85 3248 f0a9 03 FCB GEN 3249 f0aa 42 49 54 42 FCC 'BITB' 3250 f0ae c5 FCB $C5 3251 f0af 03 FCB GEN 3252 f0b0 42 4c 45 20 FCC 'BLE ' 3253 f0b4 2f FCB $2F 3254 f0b5 05 FCB REL 3255 f0b6 42 4c 4f 20 FCC 'BLO ' 3256 f0ba 25 FCB $25 3257 f0bb 05 FCB REL 3258 f0bc 42 4c 53 20 FCC 'BLS ' 3259 f0c0 23 FCB $23 3260 f0c1 05 FCB REL 3261 f0c2 42 4c 54 20 FCC 'BLT ' 3262 f0c6 2d FCB $2D 3263 f0c7 05 FCB REL 3264 f0c8 42 4d 49 20 FCC 'BMI ' 3265 f0cc 2b FCB $2B 3266 f0cd 05 FCB REL 3267 f0ce 42 4e 45 20 FCC 'BNE ' 3268 f0d2 26 FCB $26 3269 f0d3 05 FCB REL 3270 f0d4 42 50 4c 20 FCC 'BPL ' 3271 f0d8 2a FCB $2A 3272 f0d9 05 FCB REL 3273 f0da 42 52 41 20 FCC 'BRA ' 3274 f0de 20 FCB $20 3275 f0df 05 FCB REL 3276 f0e0 42 52 43 4c FCC 'BRCL' (BRCLR) 3277 f0e4 1f FCB $1F 3278 f0e5 13 FCB BTB 3279 f0e6 42 52 4e 20 FCC 'BRN ' 3280 f0ea 21 FCB $21 3281 f0eb 05 FCB REL 3282 f0ec 42 52 53 45 FCC 'BRSE' (BRSET) 3283 f0f0 1e FCB $1E 3284 f0f1 13 FCB BTB 3285 f0f2 42 53 45 54 FCC 'BSET' 3286 f0f6 1c FCB $1C 3287 f0f7 14 FCB SETCLR 3288 f0f8 42 53 52 20 FCC 'BSR ' 3289 f0fc 8d FCB $8D 3290 f0fd 05 FCB REL 3291 f0fe 42 56 43 20 FCC 'BVC ' 3292 f102 28 FCB $28 3293 f103 05 FCB REL 3294 f104 42 56 53 20 FCC 'BVS ' 3295 f108 29 FCB $29 3296 f109 05 FCB REL 3297 f10a 43 42 41 20 FCC 'CBA ' 3298 f10e 11 FCB $11 3299 f10f 01 FCB INH 3300 f110 43 4c 43 20 FCC 'CLC ' 3301 f114 0c FCB $0C 3302 f115 01 FCB INH 3303 f116 43 4c 49 20 FCC 'CLI ' 3304 f11a 0e FCB $0E 3305 f11b 01 FCB INH 3306 f11c 43 4c 52 20 FCC 'CLR ' 3307 f120 6f FCB $6F 3308 f121 04 FCB GRP2 3309 f122 43 4c 52 41 FCC 'CLRA' 3310 f126 4f FCB $4F 3311 f127 01 FCB INH 3312 f128 43 4c 52 42 FCC 'CLRB' 3313 f12c 5f FCB $5F 3314 f12d 01 FCB INH 3315 f12e 43 4c 56 20 FCC 'CLV ' 3316 f132 0a FCB $0A 3317 f133 01 FCB INH 3318 f134 43 4d 50 41 FCC 'CMPA' 3319 f138 81 FCB $81 3320 f139 03 FCB GEN 3321 f13a 43 4d 50 42 FCC 'CMPB' 3322 f13e c1 FCB $C1 3323 f13f 03 FCB GEN 3324 f140 43 4f 4d 20 FCC 'COM ' 3325 f144 63 FCB $63 3326 f145 04 FCB GRP2 3327 f146 43 4f 4d 41 FCC 'COMA' 3328 f14a 43 FCB $43 3329 f14b 01 FCB INH 3330 f14c 43 4f 4d 42 FCC 'COMB' 3331 f150 53 FCB $53 3332 f151 01 FCB INH 3333 f152 43 50 44 20 FCC 'CPD ' 3334 f156 83 FCB $83 3335 f157 15 FCB CPD 3336 f158 43 50 58 20 FCC 'CPX ' 3337 f15c 8c FCB $8C 3338 f15d 09 FCB XLIMM 3339 f15e 43 50 59 20 FCC 'CPY ' 3340 f162 8c FCB $8C 3341 f163 11 FCB YLIMM 3342 f164 44 41 41 20 FCC 'DAA ' 3343 f168 19 FCB $19 3344 f169 01 FCB INH 3345 f16a 44 45 43 20 FCC 'DEC ' 3346 f16e 6a FCB $6A 3347 f16f 04 FCB GRP2 3348 f170 44 45 43 41 FCC 'DECA' 3349 f174 4a FCB $4A 3350 f175 01 FCB INH 3351 f176 44 45 43 42 FCC 'DECB' 3352 f17a 5a FCB $5A 3353 f17b 01 FCB INH 3354 f17c 44 45 53 20 FCC 'DES ' 3355 f180 34 FCB $34 3356 f181 01 FCB INH 3357 f182 44 45 58 20 FCC 'DEX ' 3358 f186 09 FCB $09 3359 f187 01 FCB INH 3360 f188 44 45 59 20 FCC 'DEY ' 3361 f18c 09 FCB $09 3362 f18d 02 FCB P2INH 3363 f18e 45 4f 52 41 FCC 'EORA' 3364 f192 88 FCB $88 3365 f193 03 FCB GEN 3366 f194 45 4f 52 42 FCC 'EORB' 3367 f198 c8 FCB $C8 3368 f199 03 FCB GEN 3369 f19a 46 44 49 56 FCC 'FDIV' 3370 f19e 03 FCB $03 3371 f19f 01 FCB INH 3372 f1a0 49 44 49 56 FCC 'IDIV' 3373 f1a4 02 FCB $02 3374 f1a5 01 FCB INH 3375 f1a6 49 4e 43 20 FCC 'INC ' 3376 f1aa 6c FCB $6C 3377 f1ab 04 FCB GRP2 3378 f1ac 49 4e 43 41 FCC 'INCA' 3379 f1b0 4c FCB $4C 3380 f1b1 01 FCB INH 3381 f1b2 49 4e 43 42 FCC 'INCB' 3382 f1b6 5c FCB $5C 3383 f1b7 01 FCB INH 3384 f1b8 49 4e 53 20 FCC 'INS ' 3385 f1bc 31 FCB $31 3386 f1bd 01 FCB INH 3387 f1be 49 4e 58 20 FCC 'INX ' 3388 f1c2 08 FCB $08 3389 f1c3 01 FCB INH 3390 f1c4 49 4e 59 20 FCC 'INY ' 3391 f1c8 08 FCB $08 3392 f1c9 02 FCB P2INH 3393 f1ca 4a 4d 50 20 FCC 'JMP ' 3394 f1ce 6e FCB $6E 3395 f1cf 04 FCB GRP2 3396 f1d0 4a 53 52 20 FCC 'JSR ' 3397 f1d4 8d FCB $8D 3398 f1d5 07 FCB NIMM 3399 f1d6 4c 44 41 41 FCC 'LDAA' 3400 f1da 86 FCB $86 3401 f1db 03 FCB GEN 3402 f1dc 4c 44 41 42 FCC 'LDAB' 3403 f1e0 c6 FCB $C6 3404 f1e1 03 FCB GEN 3405 f1e2 4c 44 44 20 FCC 'LDD ' 3406 f1e6 cc FCB $CC 3407 f1e7 08 FCB LIMM 3408 f1e8 4c 44 53 20 FCC 'LDS ' 3409 f1ec 8e FCB $8E 3410 f1ed 08 FCB LIMM 3411 f1ee 4c 44 58 20 FCC 'LDX ' 3412 f1f2 ce FCB $CE 3413 f1f3 09 FCB XLIMM 3414 f1f4 4c 44 59 20 FCC 'LDY ' 3415 f1f8 ce FCB $CE 3416 f1f9 11 FCB YLIMM 3417 f1fa 4c 53 4c 20 FCC 'LSL ' 3418 f1fe 68 FCB $68 3419 f1ff 04 FCB GRP2 3420 f200 4c 53 4c 41 FCC 'LSLA' 3421 f204 48 FCB $48 3422 f205 01 FCB INH 3423 f206 4c 53 4c 42 FCC 'LSLB' 3424 f20a 58 FCB $58 3425 f20b 01 FCB INH 3426 f20c 4c 53 4c 44 FCC 'LSLD' 3427 f210 05 FCB $05 3428 f211 01 FCB INH 3429 f212 4c 53 52 20 FCC 'LSR ' 3430 f216 64 FCB $64 3431 f217 04 FCB GRP2 3432 f218 4c 53 52 41 FCC 'LSRA' 3433 f21c 44 FCB $44 3434 f21d 01 FCB INH 3435 f21e 4c 53 52 42 FCC 'LSRB' 3436 f222 54 FCB $54 3437 f223 01 FCB INH 3438 f224 4c 53 52 44 FCC 'LSRD' 3439 f228 04 FCB $04 3440 f229 01 FCB INH 3441 f22a 4d 55 4c 20 FCC 'MUL ' 3442 f22e 3d FCB $3D 3443 f22f 01 FCB INH 3444 f230 4e 45 47 20 FCC 'NEG ' 3445 f234 60 FCB $60 3446 f235 04 FCB GRP2 3447 f236 4e 45 47 41 FCC 'NEGA' 3448 f23a 40 FCB $40 3449 f23b 01 FCB INH 3450 f23c 4e 45 47 42 FCC 'NEGB' 3451 f240 50 FCB $50 3452 f241 01 FCB INH 3453 f242 4e 4f 50 20 FCC 'NOP ' 3454 f246 01 FCB $01 3455 f247 01 FCB INH 3456 f248 4f 52 41 41 FCC 'ORAA' 3457 f24c 8a FCB $8A 3458 f24d 03 FCB GEN 3459 f24e 4f 52 41 42 FCC 'ORAB' 3460 f252 ca FCB $CA 3461 f253 03 FCB GEN 3462 f254 50 53 48 41 FCC 'PSHA' 3463 f258 36 FCB $36 3464 f259 01 FCB INH 3465 f25a 50 53 48 42 FCC 'PSHB' 3466 f25e 37 FCB $37 3467 f25f 01 FCB INH 3468 f260 50 53 48 58 FCC 'PSHX' 3469 f264 3c FCB $3C 3470 f265 01 FCB INH 3471 f266 50 53 48 59 FCC 'PSHY' 3472 f26a 3c FCB $3C 3473 f26b 02 FCB P2INH 3474 f26c 50 55 4c 41 FCC 'PULA' 3475 f270 32 FCB $32 3476 f271 01 FCB INH 3477 f272 50 55 4c 42 FCC 'PULB' 3478 f276 33 FCB $33 3479 f277 01 FCB INH 3480 f278 50 55 4c 58 FCC 'PULX' 3481 f27c 38 FCB $38 3482 f27d 01 FCB INH 3483 f27e 50 55 4c 59 FCC 'PULY' 3484 f282 38 FCB $38 3485 f283 02 FCB P2INH 3486 f284 52 4f 4c 20 FCC 'ROL ' 3487 f288 69 FCB $69 3488 f289 04 FCB GRP2 3489 f28a 52 4f 4c 41 FCC 'ROLA' 3490 f28e 49 FCB $49 3491 f28f 01 FCB INH 3492 f290 52 4f 4c 42 FCC 'ROLB' 3493 f294 59 FCB $59 3494 f295 01 FCB INH 3495 f296 52 4f 52 20 FCC 'ROR ' 3496 f29a 66 FCB $66 3497 f29b 04 FCB GRP2 3498 f29c 52 4f 52 41 FCC 'RORA' 3499 f2a0 46 FCB $46 3500 f2a1 01 FCB INH 3501 f2a2 52 4f 52 42 FCC 'RORB' 3502 f2a6 56 FCB $56 3503 f2a7 01 FCB INH 3504 f2a8 52 54 49 20 FCC 'RTI ' 3505 f2ac 3b FCB $3B 3506 f2ad 01 FCB INH 3507 f2ae 52 54 53 20 FCC 'RTS ' 3508 f2b2 39 FCB $39 3509 f2b3 01 FCB INH 3510 f2b4 53 42 41 20 FCC 'SBA ' 3511 f2b8 10 FCB $10 3512 f2b9 01 FCB INH 3513 f2ba 53 42 43 41 FCC 'SBCA' 3514 f2be 82 FCB $82 3515 f2bf 03 FCB GEN 3516 f2c0 53 42 43 42 FCC 'SBCB' 3517 f2c4 c2 FCB $C2 3518 f2c5 03 FCB GEN 3519 f2c6 53 45 43 20 FCC 'SEC ' 3520 f2ca 0d FCB $0D 3521 f2cb 01 FCB INH 3522 f2cc 53 45 49 20 FCC 'SEI ' 3523 f2d0 0f FCB $0F 3524 f2d1 01 FCB INH 3525 f2d2 53 45 56 20 FCC 'SEV ' 3526 f2d6 0b FCB $0B 3527 f2d7 01 FCB INH 3528 f2d8 53 54 41 41 FCC 'STAA' 3529 f2dc 87 FCB $87 3530 f2dd 07 FCB NIMM 3531 f2de 53 54 41 42 FCC 'STAB' 3532 f2e2 c7 FCB $C7 3533 f2e3 07 FCB NIMM 3534 f2e4 53 54 44 20 FCC 'STD ' 3535 f2e8 cd FCB $CD 3536 f2e9 07 FCB NIMM 3537 f2ea 53 54 4f 50 FCC 'STOP' 3538 f2ee cf FCB $CF 3539 f2ef 01 FCB INH 3540 f2f0 53 54 53 20 FCC 'STS ' 3541 f2f4 8f FCB $8F 3542 f2f5 07 FCB NIMM 3543 f2f6 53 54 58 20 FCC 'STX ' 3544 f2fa cf FCB $CF 3545 f2fb 10 FCB XNIMM 3546 f2fc 53 54 59 20 FCC 'STY ' 3547 f300 cf FCB $CF 3548 f301 12 FCB YNIMM 3549 f302 53 55 42 41 FCC 'SUBA' 3550 f306 80 FCB $80 3551 f307 03 FCB GEN 3552 f308 53 55 42 42 FCC 'SUBB' 3553 f30c c0 FCB $C0 3554 f30d 03 FCB GEN 3555 f30e 53 55 42 44 FCC 'SUBD' 3556 f312 83 FCB $83 3557 f313 08 FCB LIMM 3558 f314 53 57 49 20 FCC 'SWI ' 3559 f318 3f FCB $3F 3560 f319 01 FCB INH 3561 f31a 54 41 42 20 FCC 'TAB ' 3562 f31e 16 FCB $16 3563 f31f 01 FCB INH 3564 f320 54 41 50 20 FCC 'TAP ' 3565 f324 06 FCB $06 3566 f325 01 FCB INH 3567 f326 54 42 41 20 FCC 'TBA ' 3568 f32a 17 FCB $17 3569 f32b 01 FCB INH 3570 f32c 54 50 41 20 FCC 'TPA ' 3571 f330 07 FCB $07 3572 f331 01 FCB INH 3573 f332 54 45 53 54 FCC 'TEST' 3574 f336 00 FCB $00 3575 f337 01 FCB INH 3576 f338 54 53 54 20 FCC 'TST ' 3577 f33c 6d FCB $6D 3578 f33d 04 FCB GRP2 3579 f33e 54 53 54 41 FCC 'TSTA' 3580 f342 4d FCB $4D 3581 f343 01 FCB INH 3582 f344 54 53 54 42 FCC 'TSTB' 3583 f348 5d FCB $5D 3584 f349 01 FCB INH 3585 f34a 54 53 58 20 FCC 'TSX ' 3586 f34e 30 FCB $30 3587 f34f 01 FCB INH 3588 f350 54 53 59 20 FCC 'TSY ' 3589 f354 30 FCB $30 3590 f355 02 FCB P2INH 3591 f356 54 58 53 20 FCC 'TXS ' 3592 f35a 35 FCB $35 3593 f35b 01 FCB INH 3594 f35c 54 59 53 20 FCC 'TYS ' 3595 f360 35 FCB $35 3596 f361 02 FCB P2INH 3597 f362 57 41 49 20 FCC 'WAI ' 3598 f366 3e FCB $3E 3599 f367 01 FCB INH 3600 f368 58 47 44 58 FCC 'XGDX' 3601 f36c 8f FCB $8F 3602 f36d 01 FCB INH 3603 f36e 58 47 44 59 FCC 'XGDY' 3604 f372 8f FCB $8F 3605 f373 02 FCB P2INH 3606 f374 42 52 53 45 FCC 'BRSE' bit direct modes for 3607 f378 12 FCB $12 disassembler. 3608 f379 16 FCB BTBD 3609 f37a 42 52 43 4c FCC 'BRCL' 3610 f37e 13 FCB $13 3611 f37f 16 FCB BTBD 3612 f380 42 53 45 54 FCC 'BSET' 3613 f384 14 FCB $14 3614 f385 17 FCB SETCLRD 3615 f386 42 43 4c 52 FCC 'BCLR' 3616 f38a 15 FCB $15 3617 f38b 17 FCB SETCLRD 3618 f38c 04 FCB EOT End of table 3619 3620 ********************************************** 3621 0000 PG1 EQU $0 3622 0001 PG2 EQU $1 3623 0002 PG3 EQU $2 3624 0003 PG4 EQU $3 3625 3626 ****************** 3627 *disassem() - disassemble the opcode. 3628 ****************** 3629 *(check for page prebyte) 3630 *baseop=pc[0]; 3631 *pnorm=PG1; 3632 *if(baseop==$18) pnorm=PG2; 3633 *if(baseop==$1A) pnorm=PG3; 3634 *if(baseop==$CD) pnorm=PG4; 3635 *if(pnorm != PG1) dispc=pc+1; 3636 *else dispc=pc; (dispc points to next byte) 3637 3638 f38d DISASSM EQU * 3639 f38d de b0 LDX PC address 3640 f38f a6 00 LDAA 0,X opcode 3641 f391 c6 00 LDAB #PG1 3642 f393 81 18 CMPA #$18 3643 f395 27 0a BEQ DISP2 jump if page2 3644 f397 81 1a CMPA #$1A 3645 f399 27 05 BEQ DISP3 jump if page3 3646 f39b 81 cd CMPA #$CD 3647 f39d 26 04 BNE DISP1 jump if not page4 3648 f39f 5c DISP4 INCB set up page value 3649 f3a0 5c DISP3 INCB 3650 f3a1 5c DISP2 INCB 3651 f3a2 08 INX 3652 f3a3 df b6 DISP1 STX DISPC point to opcode 3653 f3a5 d7 c3 STAB PNORM save page 3654 3655 *If(opcode == ($00-$5F or $8D or $8F or $CF)) 3656 * if(pnorm == (PG3 or PG4)) 3657 * disillop(); return(); 3658 * b=disrch(opcode,NULL); 3659 * if(b==0) disillop(); return(); 3660 3661 f3a7 a6 00 LDAA 0,X get current opcode 3662 f3a9 97 b4 STAA BASEOP 3663 f3ab 08 INX 3664 f3ac df b6 STX DISPC point to next byte 3665 f3ae 81 5f CMPA #$5F 3666 f3b0 23 0f BLS DIS1 jump if in range 3667 f3b2 81 8d CMPA #$8D 3668 f3b4 27 0b BEQ DIS1 jump if bsr 3669 f3b6 81 8f CMPA #$8F 3670 f3b8 27 07 BEQ DIS1 jump if xgdx 3671 f3ba 81 cf CMPA #$CF 3672 f3bc 27 03 BEQ DIS1 jump if stop 3673 f3be 7e f4 58 JMP DISGRP try next part of map 3674 f3c1 d6 c3 DIS1 LDAB PNORM 3675 f3c3 c1 02 CMPB #PG3 3676 f3c5 25 04 BLO DIS2 jump if page 1 or 2 3677 f3c7 bd f6 12 JSR DISILLOP "illegal opcode" 3678 f3ca 39 RTS 3679 f3cb d6 b4 DIS2 LDAB BASEOP opcode 3680 f3cd 5f CLRB class=null 3681 f3ce bd f5 41 JSR DISRCH 3682 f3d1 5d TSTB 3683 f3d2 26 04 BNE DISPEC jump if opcode found 3684 f3d4 bd f6 12 JSR DISILLOP "illegal opcode" 3685 f3d7 39 RTS 3686 3687 * if(opcode==$8D) dissrch(opcode,REL); 3688 * if(opcode==($8F or $CF)) disrch(opcode,INH); 3689 3690 f3d8 96 b4 DISPEC LDAA BASEOP 3691 f3da 81 8d CMPA #$8D 3692 f3dc 26 04 BNE DISPEC1 3693 f3de c6 05 LDAB #REL 3694 f3e0 20 0a BRA DISPEC3 look for BSR opcode 3695 f3e2 81 8f DISPEC1 CMPA #$8F 3696 f3e4 27 04 BEQ DISPEC2 jump if XGDX opcode 3697 f3e6 81 cf CMPA #$CF 3698 f3e8 26 05 BNE DISINH jump not STOP opcode 3699 f3ea c6 01 DISPEC2 LDAB #INH 3700 f3ec bd f5 41 DISPEC3 JSR DISRCH find other entry in table 3701 3702 * if(class==INH) /* INH */ 3703 * if(pnorm==PG2) 3704 * b=disrch(baseop,P2INH); 3705 * if(b==0) disillop(); return(); 3706 * prntmne(); 3707 * return(); 3708 3709 f3ef DISINH EQU * 3710 f3ef d6 b5 LDAB CLASS 3711 f3f1 c1 01 CMPB #INH 3712 f3f3 26 18 BNE DISREL jump if not inherent 3713 f3f5 d6 c3 LDAB PNORM 3714 f3f7 c1 00 CMPB #PG1 3715 f3f9 27 0e BEQ DISINH1 jump if page1 3716 f3fb 96 b4 LDAA BASEOP get opcode 3717 f3fd c6 02 LDAB #P2INH class=p2inh 3718 f3ff bd f5 41 JSR DISRCH 3719 f402 5d TSTB 3720 f403 26 04 BNE DISINH1 jump if found 3721 f405 bd f6 12 JSR DISILLOP "illegal opcode" 3722 f408 39 RTS 3723 f409 bd f5 64 DISINH1 JSR PRNTMNE 3724 f40c 39 RTS 3725 3726 * elseif(class=REL) /* REL */ 3727 * if(pnorm != PG1) 3728 * disillop(); return(); 3729 * prntmne(); 3730 * disrelad(); 3731 * return(); 3732 3733 f40d DISREL EQU * 3734 f40d d6 b5 LDAB CLASS 3735 f40f c1 05 CMPB #REL 3736 f411 26 10 BNE DISBTD 3737 f413 7d 00 c3 TST PNORM 3738 f416 27 04 BEQ DISREL1 jump if page1 3739 f418 bd f6 12 JSR DISILLOP "illegal opcode" 3740 f41b 39 RTS 3741 f41c bd f5 64 DISREL1 JSR PRNTMNE output mnemonic 3742 f41f bd f5 9a JSR DISRELAD compute relative address 3743 f422 39 RTS 3744 3745 * else /* SETCLR,SETCLRD,BTB,BTBD */ 3746 * if(class == (SETCLRD or BTBD)) 3747 * if(pnorm != PG1) 3748 * disillop(); return(); /* illop */ 3749 * prntmne(); /* direct */ 3750 * disdir(); /* output $byte */ 3751 * else (class == (SETCLR or BTB)) 3752 * prntmne(); /* indexed */ 3753 * disindx(); 3754 * outspac(); 3755 * disdir(); 3756 * outspac(); 3757 * if(class == (BTB or BTBD)) 3758 * disrelad(); 3759 * return(); 3760 3761 f423 DISBTD EQU * 3762 f423 d6 b5 LDAB CLASS 3763 f425 c1 17 CMPB #SETCLRD 3764 f427 27 04 BEQ DISBTD1 3765 f429 c1 16 CMPB #BTBD 3766 f42b 26 11 BNE DISBIT jump not direct bitop 3767 f42d 7d 00 c3 DISBTD1 TST PNORM 3768 f430 27 04 BEQ DISBTD2 jump if page 1 3769 f432 bd f6 12 JSR DISILLOP 3770 f435 39 RTS 3771 f436 bd f5 64 DISBTD2 JSR PRNTMNE 3772 f439 bd f5 f2 JSR DISDIR operand(direct) 3773 f43c 20 06 BRA DISBIT1 3774 f43e DISBIT EQU * 3775 f43e bd f5 64 JSR PRNTMNE 3776 f441 bd f5 7e JSR DISINDX operand(indexed) 3777 f444 bd e5 19 DISBIT1 JSR OUTSPAC 3778 f447 bd f5 f2 JSR DISDIR mask 3779 f44a d6 b5 LDAB CLASS 3780 f44c c1 13 CMPB #BTB 3781 f44e 27 04 BEQ DISBIT2 jump if btb 3782 f450 c1 16 CMPB #BTBD 3783 f452 26 03 BNE DISBIT3 jump if not bit branch 3784 f454 bd f5 9a DISBIT2 JSR DISRELAD relative address 3785 f457 39 DISBIT3 RTS 3786 3787 3788 *Elseif($60 <= opcode <= $7F) /* GRP2 */ 3789 * if(pnorm == (PG3 or PG4)) 3790 * disillop(); return(); 3791 * if((pnorm==PG2) and (opcode != $6x)) 3792 * disillop(); return(); 3793 * b=disrch(baseop & $6F,NULL); 3794 * if(b==0) disillop(); return(); 3795 * prntmne(); 3796 * if(opcode == $6x) 3797 * disindx(); 3798 * else 3799 * disext(); 3800 * return(); 3801 3802 f458 DISGRP EQU * 3803 f458 81 7f CMPA #$7F a=opcode 3804 f45a 22 2a BHI DISNEXT try next part of map 3805 f45c d6 c3 LDAB PNORM 3806 f45e c1 02 CMPB #PG3 3807 f460 25 04 BLO DISGRP2 jump if page 1 or 2 3808 f462 bd f6 12 JSR DISILLOP "illegal opcode" 3809 f465 39 RTS 3810 f466 84 6f DISGRP2 ANDA #$6F mask bit 4 3811 f468 5f CLRB class=null 3812 f469 bd f5 41 JSR DISRCH 3813 f46c 5d TSTB 3814 f46d 26 04 BNE DISGRP3 jump if found 3815 f46f bd f6 12 JSR DISILLOP "illegal opcode" 3816 f472 39 RTS 3817 f473 bd f5 64 DISGRP3 JSR PRNTMNE 3818 f476 96 b4 LDAA BASEOP get opcode 3819 f478 84 f0 ANDA #$F0 3820 f47a 81 60 CMPA #$60 3821 f47c 26 04 BNE DISGRP4 jump if not 6x 3822 f47e bd f5 7e JSR DISINDX operand(indexed) 3823 f481 39 RTS 3824 f482 bd f5 ff DISGRP4 JSR DISEXT operand(extended) 3825 f485 39 RTS 3826 3827 *Else ($80 <= opcode <= $FF) 3828 * if(opcode == ($87 or $C7)) 3829 * disillop(); return(); 3830 * b=disrch(opcode&$CF,NULL); 3831 * if(b==0) disillop(); return(); 3832 3833 f486 DISNEXT EQU * 3834 f486 81 87 CMPA #$87 a=opcode 3835 f488 27 04 BEQ DISNEX1 3836 f48a 81 c7 CMPA #$C7 3837 f48c 26 04 BNE DISNEX2 3838 f48e bd f6 12 DISNEX1 JSR DISILLOP "illegal opcode" 3839 f491 39 RTS 3840 f492 84 cf DISNEX2 ANDA #$CF 3841 f494 5f CLRB class=null 3842 f495 bd f5 41 JSR DISRCH 3843 f498 5d TSTB 3844 f499 26 04 BNE DISNEW jump if mne found 3845 f49b bd f6 12 JSR DISILLOP "illegal opcode" 3846 f49e 39 RTS 3847 3848 * if(opcode&$CF==$8D) disrch(baseop,NIMM; (jsr) 3849 * if(opcode&$CF==$8F) disrch(baseop,NIMM; (sts) 3850 * if(opcode&$CF==$CF) disrch(baseop,XNIMM; (stx) 3851 * if(opcode&$CF==$83) disrch(baseop,LIMM); (subd) 3852 3853 f49f 96 b4 DISNEW LDAA BASEOP 3854 f4a1 84 cf ANDA #$CF 3855 f4a3 81 8d CMPA #$8D 3856 f4a5 26 04 BNE DISNEW1 jump not jsr 3857 f4a7 c6 07 LDAB #NIMM 3858 f4a9 20 16 BRA DISNEW4 3859 f4ab 81 8f DISNEW1 CMPA #$8F 3860 f4ad 26 04 BNE DISNEW2 jump not sts 3861 f4af c6 07 LDAB #NIMM 3862 f4b1 20 0e BRA DISNEW4 3863 f4b3 81 cf DISNEW2 CMPA #$CF 3864 f4b5 26 04 BNE DISNEW3 jump not stx 3865 f4b7 c6 10 LDAB #XNIMM 3866 f4b9 20 06 BRA DISNEW4 3867 f4bb 81 83 DISNEW3 CMPA #$83 3868 f4bd 26 0c BNE DISGEN jump not subd 3869 f4bf c6 08 LDAB #LIMM 3870 f4c1 bd f5 41 DISNEW4 JSR DISRCH 3871 f4c4 5d TSTB 3872 f4c5 26 04 BNE DISGEN jump if found 3873 f4c7 bd f6 12 JSR DISILLOP "illegal opcode" 3874 f4ca 39 RTS 3875 3876 * if(class == (GEN or NIMM or LIMM )) /* GEN,NIMM,LIMM,CPD */ 3877 * if(opcode&$CF==$83) 3878 * if(pnorm==(PG3 or PG4)) disrch(opcode#$CF,CPD) 3879 * class=LIMM; 3880 * if((pnorm == (PG2 or PG4) and (opcode != ($Ax or $Ex))) 3881 * disillop(); return(); 3882 * disgenrl(); 3883 * return(); 3884 3885 f4cb d6 b5 DISGEN LDAB CLASS get class 3886 f4cd c1 03 CMPB #GEN 3887 f4cf 27 08 BEQ DISGEN1 3888 f4d1 c1 07 CMPB #NIMM 3889 f4d3 27 04 BEQ DISGEN1 3890 f4d5 c1 08 CMPB #LIMM 3891 f4d7 26 31 BNE DISXLN jump if other class 3892 f4d9 96 b4 DISGEN1 LDAA BASEOP 3893 f4db 84 cf ANDA #$CF 3894 f4dd 81 83 CMPA #$83 3895 f4df 26 0f BNE DISGEN3 jump if not #$83 3896 f4e1 d6 c3 LDAB PNORM 3897 f4e3 c1 02 CMPB #PG3 3898 f4e5 25 09 BLO DISGEN3 jump not pg3 or 4 3899 f4e7 c6 15 LDAB #CPD 3900 f4e9 bd f5 41 JSR DISRCH look for cpd mne 3901 f4ec c6 08 LDAB #LIMM 3902 f4ee d7 b5 STAB CLASS set class to limm 3903 f4f0 d6 c3 DISGEN3 LDAB PNORM 3904 f4f2 c1 01 CMPB #PG2 3905 f4f4 27 04 BEQ DISGEN4 jump if page 2 3906 f4f6 c1 03 CMPB #PG4 3907 f4f8 26 0c BNE DISGEN5 jump not page 2 or 4 3908 f4fa 96 b4 DISGEN4 LDAA BASEOP 3909 f4fc 84 b0 ANDA #$B0 mask bits 6,3-0 3910 f4fe 81 a0 CMPA #$A0 3911 f500 27 04 BEQ DISGEN5 jump if $Ax or $Ex 3912 f502 bd f6 12 JSR DISILLOP "illegal opcode" 3913 f505 39 RTS 3914 f506 bd f5 bc DISGEN5 JSR DISGENRL process general class 3915 f509 39 RTS 3916 3917 * else /* XLIMM,XNIMM,YLIMM,YNIMM */ 3918 * if(pnorm==(PG2 or PG3)) 3919 * if(class==XLIMM) disrch(opcode&$CF,YLIMM); 3920 * else disrch(opcode&$CF,YNIMM); 3921 * if((pnorm == (PG3 or PG4)) 3922 * if(opcode != ($Ax or $Ex)) 3923 * disillop(); return(); 3924 * class=LIMM; 3925 * disgen(); 3926 * return(); 3927 3928 f50a d6 c3 DISXLN LDAB PNORM 3929 f50c c1 01 CMPB #PG2 3930 f50e 27 04 BEQ DISXLN1 jump if page2 3931 f510 c1 02 CMPB #PG3 3932 f512 26 13 BNE DISXLN4 jump not page3 3933 f514 96 b4 DISXLN1 LDAA BASEOP 3934 f516 84 cf ANDA #$CF 3935 f518 d6 b5 LDAB CLASS 3936 f51a c1 09 CMPB #XLIMM 3937 f51c 26 04 BNE DISXLN2 3938 f51e c6 11 LDAB #YLIMM 3939 f520 20 02 BRA DISXLN3 look for ylimm 3940 f522 c6 12 DISXLN2 LDAB #YNIMM look for ynimm 3941 f524 bd f5 41 DISXLN3 JSR DISRCH 3942 f527 d6 c3 DISXLN4 LDAB PNORM 3943 f529 c1 02 CMPB #PG3 3944 f52b 25 0c BLO DISXLN5 jump if page 1 or 2 3945 f52d 96 b4 LDAA BASEOP get opcode 3946 f52f 84 b0 ANDA #$B0 mask bits 6,3-0 3947 f531 81 a0 CMPA #$A0 3948 f533 27 04 BEQ DISXLN5 jump opcode = $Ax or $Ex 3949 f535 bd f6 12 JSR DISILLOP "illegal opcode" 3950 f538 39 RTS 3951 f539 c6 08 DISXLN5 LDAB #LIMM 3952 f53b d7 b5 STAB CLASS 3953 f53d bd f5 bc JSR DISGENRL process general class 3954 f540 39 RTS 3955 3956 3957 ****************** 3958 *disrch(a=opcode,b=class) 3959 *return b=0 if not found 3960 * else mneptr=points to mnemonic 3961 * class=class of opcode 3962 ****************** 3963 *x=#MNETABL 3964 *while(x[0] != eot) 3965 * if((opcode==x[4]) && ((class=NULL) || (class=x[5]))) 3966 * mneptr=x; 3967 * class=x[5]; 3968 * return(1); 3969 * x += 6; 3970 *return(0); /* not found */ 3971 3972 f541 DISRCH EQU * 3973 f541 ce f0 0e LDX #MNETABL point to top of table 3974 f544 a1 04 DISRCH1 CMPA 4,X test opcode 3975 f546 26 0f BNE DISRCH3 jump not this entry 3976 f548 5d TSTB 3977 f549 27 04 BEQ DISRCH2 jump if class=null 3978 f54b e1 05 CMPB 5,X test class 3979 f54d 26 08 BNE DISRCH3 jump not this entry 3980 f54f e6 05 DISRCH2 LDAB 5,X 3981 f551 d7 b5 STAB CLASS 3982 f553 df ba STX MNEPTR return ptr to mnemonic 3983 f555 5c INCB 3984 f556 39 RTS return found 3985 f557 37 DISRCH3 PSHB save class 3986 f558 c6 06 LDAB #6 3987 f55a 3a ABX 3988 f55b e6 00 LDAB 0,X 3989 f55d c1 04 CMPB #EOT test end of table 3990 f55f 33 PULB 3991 f560 26 e2 BNE DISRCH1 3992 f562 5f CLRB 3993 f563 39 RTS return not found 3994 3995 ****************** 3996 *prntmne() - output the mnemonic pointed 3997 *at by mneptr. 3998 ****************** 3999 *outa(mneptr[0-3]); 4000 *outspac; 4001 *return(); 4002 4003 f564 PRNTMNE EQU * 4004 f564 de ba LDX MNEPTR 4005 f566 a6 00 LDAA 0,X 4006 f568 bd e5 03 JSR OUTA output char1 4007 f56b a6 01 LDAA 1,X 4008 f56d bd e5 03 JSR OUTA output char2 4009 f570 a6 02 LDAA 2,X 4010 f572 bd e5 03 JSR OUTA output char3 4011 f575 a6 03 LDAA 3,X 4012 f577 bd e5 03 JSR OUTA output char4 4013 f57a bd e5 19 JSR OUTSPAC 4014 f57d 39 RTS 4015 4016 ****************** 4017 *disindx() - process indexed mode 4018 ****************** 4019 *disdir(); 4020 *outa(','); 4021 *if(pnorm == (PG2 or PG4)) outa('Y'); 4022 *else outa('X'); 4023 *return(); 4024 4025 f57e DISINDX EQU * 4026 f57e bd f5 f2 JSR DISDIR output $byte 4027 f581 86 2c LDAA #',' 4028 f583 bd e5 03 JSR OUTA output , 4029 f586 d6 c3 LDAB PNORM 4030 f588 c1 01 CMPB #PG2 4031 f58a 27 04 BEQ DISIND1 jump if page2 4032 f58c c1 03 CMPB #PG4 4033 f58e 26 04 BNE DISIND2 jump if not page4 4034 f590 86 59 DISIND1 LDAA #'Y' 4035 f592 20 02 BRA DISIND3 4036 f594 86 58 DISIND2 LDAA #'X' 4037 f596 bd e5 03 DISIND3 JSR OUTA output x or y 4038 f599 39 RTS 4039 4040 ****************** 4041 *disrelad() - compute and output relative address. 4042 ****************** 4043 * braddr = dispc[0] + (dispc++);( 2's comp arith) 4044 *outa('$'); 4045 *out2bsp(braddr); 4046 *return(); 4047 4048 f59a DISRELAD EQU * 4049 f59a de b6 LDX DISPC 4050 f59c e6 00 LDAB 0,X get relative offset 4051 f59e 08 INX 4052 f59f df b6 STX DISPC 4053 f5a1 5d TSTB 4054 f5a2 2b 03 BMI DISRLD1 jump if negative 4055 f5a4 3a ABX 4056 f5a5 20 04 BRA DISRLD2 4057 f5a7 09 DISRLD1 DEX 4058 f5a8 5c INCB 4059 f5a9 26 fc BNE DISRLD1 subtract 4060 f5ab df b8 DISRLD2 STX BRADDR save address 4061 f5ad bd e5 19 JSR OUTSPAC 4062 f5b0 86 24 LDAA #'$' 4063 f5b2 bd e5 03 JSR OUTA 4064 f5b5 ce 00 b8 LDX #BRADDR 4065 f5b8 bd e5 13 JSR OUT2BSP output address 4066 f5bb 39 RTS 4067 4068 4069 ****************** 4070 *disgenrl() - output data for the general cases which 4071 *includes immediate, direct, indexed, and extended modes. 4072 ****************** 4073 *prntmne(); 4074 *if(baseop == ($8x or $Cx)) /* immediate */ 4075 * outa('#'); 4076 * disdir(); 4077 * if(class == LIMM) 4078 * out1byt(dispc++); 4079 *elseif(baseop == ($9x or $Dx)) /* direct */ 4080 * disdir(); 4081 *elseif(baseop == ($Ax or $Ex)) /* indexed */ 4082 * disindx(); 4083 *else (baseop == ($Bx or $Fx)) /* extended */ 4084 * disext(); 4085 *return(); 4086 4087 f5bc DISGENRL EQU * 4088 f5bc bd f5 64 JSR PRNTMNE print mnemonic 4089 f5bf 96 b4 LDAA BASEOP get opcode 4090 f5c1 84 b0 ANDA #$B0 mask bits 6,3-0 4091 f5c3 81 80 CMPA #$80 4092 f5c5 26 17 BNE DISGRL2 jump if not immed 4093 f5c7 86 23 LDAA #'#' do immediate 4094 f5c9 bd e5 03 JSR OUTA 4095 f5cc bd f5 f2 JSR DISDIR 4096 f5cf d6 b5 LDAB CLASS 4097 f5d1 c1 08 CMPB #LIMM 4098 f5d3 27 01 BEQ DISGRL1 jump class = limm 4099 f5d5 39 RTS 4100 f5d6 de b6 DISGRL1 LDX DISPC 4101 f5d8 bd e5 07 JSR OUT1BYT 4102 f5db df b6 STX DISPC 4103 f5dd 39 RTS 4104 f5de 81 90 DISGRL2 CMPA #$90 4105 f5e0 26 04 BNE DISGRL3 jump not direct 4106 f5e2 bd f5 f2 JSR DISDIR do direct 4107 f5e5 39 RTS 4108 f5e6 81 a0 DISGRL3 CMPA #$A0 4109 f5e8 26 04 BNE DISGRL4 jump not indexed 4110 f5ea bd f5 7e JSR DISINDX do extended 4111 f5ed 39 RTS 4112 f5ee bd f5 ff DISGRL4 JSR DISEXT do extended 4113 f5f1 39 RTS 4114 4115 ***************** 4116 *disdir() - output "$ next byte" 4117 ***************** 4118 f5f2 DISDIR EQU * 4119 f5f2 86 24 LDAA #'$' 4120 f5f4 bd e5 03 JSR OUTA 4121 f5f7 de b6 LDX DISPC 4122 f5f9 bd e5 07 JSR OUT1BYT 4123 f5fc df b6 STX DISPC 4124 f5fe 39 RTS 4125 4126 ***************** 4127 *disext() - output "$ next 2 bytes" 4128 ***************** 4129 f5ff DISEXT EQU * 4130 f5ff 86 24 LDAA #'$' 4131 f601 bd e5 03 JSR OUTA 4132 f604 de b6 LDX DISPC 4133 f606 bd e5 13 JSR OUT2BSP 4134 f609 df b6 STX DISPC 4135 f60b 39 RTS 4136 4137 4138 ***************** 4139 *disillop() - output "illegal opcode" 4140 ***************** 4141 f60c 49 4c 4c 4f 50 DISMSG1 FCC 'ILLOP' 4142 f611 04 FCB EOT 4143 f612 DISILLOP EQU * 4144 f612 3c PSHX 4145 f613 ce f6 0c LDX #DISMSG1 4146 f616 bd e5 32 JSR OUTSTRG0 no cr 4147 f619 38 PULX 4148 f61a 39 RTS 4149 4150 4151 4152 ********** 4153 * help - List buffalo commands to terminal. 4154 ********** 4155 f61b HELP EQU * 4156 f61b ce f6 22 LDX #HELPMSG1 4157 f61e bd e5 2f JSR OUTSTRG print help screen 4158 f621 39 RTS 4159 4160 f622 HELPMSG1 EQU * 4161 f622 41 53 4d 20 5b 3c FCC 'ASM [] Line asm/disasm' 61 64 64 72 3e 5d 20 20 4c 69 6e 65 20 61 73 6d 2f 64 69 73 61 73 6d 4162 f63f 0d FCB $0D 4163 f640 20 20 5b 2f 2c 3d FCC ' [/,=] Same addr, [^,-] Prev addr, [+,CTLJ] Next addr' 5d 20 20 53 61 6d 65 20 61 64 64 72 2c 20 20 20 20 20 20 20 5b 5e 2c 2d 5d 20 20 50 72 65 76 20 61 64 64 72 2c 20 20 20 20 20 20 20 5b 2b 2c 43 54 4c 4a 5d 20 4e 65 78 74 20 4164 f684 0d FCB $0D 4165 f685 20 20 5b 43 52 5d FCC ' [CR] Next opcode, [CTLA,.] Quit' 20 20 4e 65 78 74 20 6f 70 63 6f 64 65 2c 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 5b 43 54 4c 41 2c 2e 5d 20 20 51 75 69 74 4166 f6c5 0d FCB $0D 4167 f6c6 42 46 20 3c 61 64 FCC 'BF [] Block fill memory' 64 72 31 3e 20 3c 61 64 64 72 32 3e 20 5b 3c 64 61 74 61 3e 5d 20 20 42 6c 6f 63 6b 20 66 69 6c 6c 20 6d 65 6d 6f 72 79 4168 f6f4 0d FCB $0D 4169 f6f5 42 52 20 5b 2d 5d FCC 'BR [-][] Set up bkpt table' 5b 3c 61 64 64 72 3e 5d 20 53 65 74 20 75 70 20 62 6b 70 74 20 74 61 62 6c 65 4170 f715 0d FCB $0D 4171 f716 42 55 4c 4b 20 20 FCC 'BULK Erase EEPROM, BULKALL Erase EEPROM and CONFIG' 45 72 61 73 65 20 45 45 50 52 4f 4d 2c 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 42 55 4c 4b 41 4c 4c 20 20 45 72 61 73 65 20 45 45 50 52 4f 4d 20 61 6e 64 20 43 4f 4172 f75a 0d FCB $0D 4173 f75b 43 41 4c 4c 20 5b FCC 'CALL [] Call subroutine' 3c 61 64 64 72 3e 5d 20 43 61 6c 6c 20 73 75 62 72 6f 75 74 69 6e 65 4174 f778 0d FCB $0D 4175 f779 47 4f 20 5b 3c 61 FCC 'GO [] Execute code at addr, PROCEED Continue execution' 64 64 72 3e 5d 20 45 78 65 63 75 74 65 20 63 6f 64 65 20 61 74 20 61 64 64 72 2c 20 20 20 20 20 20 20 20 50 52 4f 43 45 45 44 20 20 43 6f 6e 74 69 6e 75 65 20 65 78 65 63 75 4176 f7bd 0d FCB $0D 4177 f7be 45 45 4d 4f 44 20 FCC 'EEMOD [ []] Modify EEPROM range' 5b 3c 61 64 64 72 3e 20 5b 3c 61 64 64 72 3e 5d 5d 20 4d 6f 64 69 66 79 20 45 45 50 52 4f 4d 20 72 61 6e 67 65 4178 f7e9 0d FCB $0D 4179 f7ea 4c 4f 41 44 2c 20 FCC 'LOAD, VERIFY [T] Load or verify S-records' 56 45 52 49 46 59 20 5b 54 5d 20 3c 68 6f 73 74 20 64 77 6e 6c 64 20 63 6f 6d 6d 61 6e 64 3e 20 20 4c 6f 61 64 20 6f 72 20 76 65 72 69 66 79 20 53 2d 72 65 63 6f 72 64 73 4180 f829 0d FCB $0D 4181 f82a 4d 44 20 5b 3c 61 FCC 'MD [ []] Memory dump' 64 64 72 31 3e 20 5b 3c 61 64 64 72 32 3e 5d 5d 20 20 4d 65 6d 6f 72 79 20 64 75 6d 70 4182 f84d 0d FCB $0D 4183 f84e 4d 4d 20 5b 3c 61 FCC 'MM [] or []/ Memory Modify' 64 64 72 3e 5d 20 6f 72 20 5b 3c 61 64 64 72 3e 5d 2f 20 20 4d 65 6d 6f 72 79 20 4d 6f 64 69 66 79 4184 f875 0d FCB $0D 4185 f876 20 20 5b 2f 2c 3d FCC ' [/,=] Same addr, [^,-,CTLH] Prev addr, [+,CTLJ,SPACE] Next addr' 5d 20 20 53 61 6d 65 20 61 64 64 72 2c 20 20 5b 5e 2c 2d 2c 43 54 4c 48 5d 20 50 72 65 76 20 61 64 64 72 2c 20 20 5b 2b 2c 43 54 4c 4a 2c 53 50 41 43 45 5d 20 4e 65 78 74 20 4186 f8ba 0d FCB $0D 4187 f8bb 20 20 3c 61 64 64 FCC ' O Compute offset, [CR] Quit' 72 3e 4f 20 43 6f 6d 70 75 74 65 20 6f 66 66 73 65 74 2c 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 5b 43 52 5d 20 20 51 75 69 74 4188 f8f1 0d FCB $0D 4189 f8f2 4d 4f 56 45 20 3c FCC 'MOVE [] Block move' 73 31 3e 20 3c 73 32 3e 20 5b 3c 64 3e 5d 20 20 42 6c 6f 63 6b 20 6d 6f 76 65 4190 f912 0d FCB $0D 4191 f913 4f 46 46 53 45 54 FCC 'OFFSET [-] Offset for download' 20 5b 2d 5d 3c 61 72 67 3e 20 20 4f 66 66 73 65 74 20 66 6f 72 20 64 6f 77 6e 6c 6f 61 64 4192 f937 0d FCB $0D 4193 f938 52 4d 20 5b 50 2c FCC 'RM [P,Y,X,A,B,C,S] Register modify' 59 2c 58 2c 41 2c 42 2c 43 2c 53 5d 20 20 52 65 67 69 73 74 65 72 20 6d 6f 64 69 66 79 4194 f95b 0d FCB $0D 4195 f95c 53 54 4f 50 41 54 FCC 'STOPAT Trace until addr' 20 3c 61 64 64 72 3e 20 20 54 72 61 63 65 20 75 6e 74 69 6c 20 61 64 64 72 4196 f97b 0d FCB $0D 4197 f97c 54 20 5b 3c 6e 3e FCC 'T [] Trace n instructions' 5d 20 20 54 72 61 63 65 20 6e 20 69 6e 73 74 72 75 63 74 69 6f 6e 73 4198 f999 0d FCB $0D 4199 f99a 54 4d 20 20 54 72 FCC 'TM Transparent mode (CTLA = exit, CTLB = send brk)' 61 6e 73 70 61 72 65 6e 74 20 6d 6f 64 65 20 28 43 54 4c 41 20 3d 20 65 78 69 74 2c 20 43 54 4c 42 20 3d 20 73 65 6e 64 20 62 72 6b 29 4200 f9cd 0d FCB $0D 4201 f9ce 5b 43 54 4c 57 5d FCC '[CTLW] Wait, [CTLX,DEL] Abort [CR] Repeat last cmd' 20 20 57 61 69 74 2c 20 20 20 20 20 20 20 20 20 20 5b 43 54 4c 58 2c 44 45 4c 5d 20 41 62 6f 72 74 20 20 20 20 20 20 20 20 20 5b 43 52 5d 20 52 65 70 65 61 74 20 6c 61 73 74 4202 fa12 0d FCB $0D 4203 fa13 04 FCB 4 4204 4205 4206 4207 ********** 4208 * call [] - Execute a jsr to or user 4209 *pc value. Return to monitor via rts or breakpoint. 4210 ********** 4211 *a = wskip(); 4212 *if(a != cr) 4213 * a = buffarg(); 4214 * a = wskip(); 4215 * if(a != cr) return(bad argument) 4216 * pc = shftreg; 4217 fa14 bd e3 4b CALL JSR WSKIP 4218 fa17 27 13 BEQ CALL3 jump if no arg 4219 fa19 bd e2 7f JSR BUFFARG 4220 fa1c bd e3 4b JSR WSKIP 4221 fa1f 27 07 BEQ CALL2 jump if cr 4222 fa21 ce e6 c2 LDX #MSG9 "bad argument" 4223 fa24 bd e5 2f JSR OUTSTRG 4224 fa27 39 RTS 4225 fa28 de 96 CALL2 LDX SHFTREG 4226 fa2a df 60 STX REGS pc = 4227 4228 *put return address on user stack 4229 *setbps(); 4230 *restack(); /* restack and go*/ 4231 fa2c de 69 CALL3 LDX SP 4232 fa2e 09 DEX user stack pointer 4233 fa2f cc fa 40 LDD #RETURN return address 4234 fa32 ed 00 STD 0,X 4235 fa34 09 DEX 4236 fa35 df 69 STX SP new user stack pointer 4237 fa37 bd fa b1 JSR SETBPS 4238 fa3a 7f 00 c1 CLR TMP2 1=go, 0=call 4239 fa3d 7e fb a0 JMP RESTACK go to user code 4240 4241 ********** 4242 * return() - Return here from rts after 4243 *call command. 4244 ********** 4245 fa40 36 RETURN PSHA save a register 4246 fa41 07 TPA 4247 fa42 97 68 STAA REGS+8 cc register 4248 fa44 0f SEI mask interrupts 4249 fa45 32 PULA 4250 fa46 dd 66 STD REGS+6 a and b registers 4251 fa48 df 64 STX REGS+4 x register 4252 fa4a 18 df 62 STY REGS+2 y register 4253 fa4d 9f 69 STS SP user stack pointer 4254 fa4f 9e b2 LDS PTR2 monitor stack pointer 4255 fa51 bd fa de JSR REMBPS remove breakpoints 4256 fa54 bd e5 1f JSR OUTCRLF 4257 fa57 bd e2 3e JSR RPRINT print user registers 4258 fa5a 39 RTS 4259 4260 4261 ********** 4262 * proceed - Same as go except it ignores 4263 *a breakpoint at the first opcode. Calls 4264 *runone for the first instruction only. 4265 ********** 4266 fa5b PROCEED EQU * 4267 fa5b bd fb 80 JSR RUNONE run one instruction 4268 fa5e bd e3 6e JSR CHKABRT check for abort 4269 fa61 7f 00 c1 CLR TMP2 flag for breakpoints 4270 fa64 7c 00 c1 INC TMP2 1=go 0=call 4271 fa67 bd fa b1 JSR SETBPS 4272 fa6a 7e fb a0 JMP RESTACK go execute 4273 4274 ********** 4275 * go [] - Execute starting at or 4276 *user's pc value. Executes an rti to user code. 4277 *Returns to monitor via an swi through swiin. 4278 ********** 4279 *a = wskip(); 4280 *if(a != cr) 4281 * a = buffarg(); 4282 * a = wskip(); 4283 * if(a != cr) return(bad argument) 4284 * pc = shftreg; 4285 *setbps(); 4286 *restack(); /* restack and go*/ 4287 fa6d bd e3 4b GO JSR WSKIP 4288 fa70 27 13 BEQ GO2 jump if no arg 4289 fa72 bd e2 7f JSR BUFFARG 4290 fa75 bd e3 4b JSR WSKIP 4291 fa78 27 07 BEQ GO1 jump if cr 4292 fa7a ce e6 c2 LDX #MSG9 "bad argument" 4293 fa7d bd e5 2f JSR OUTSTRG 4294 fa80 39 RTS 4295 fa81 de 96 GO1 LDX SHFTREG 4296 fa83 df 60 STX REGS pc = 4297 fa85 7f 00 c1 GO2 CLR TMP2 4298 fa88 7c 00 c1 INC TMP2 1=go, 0=call 4299 fa8b bd fa b1 JSR SETBPS 4300 fa8e 7e fb a0 JMP RESTACK go to user code 4301 4302 ***** 4303 ** SWIIN - Breakpoints from go or call commands enter here. 4304 *Remove breakpoints, save user registers, return 4305 fa91 SWIIN EQU * swi entry point 4306 fa91 30 TSX user sp -> x 4307 fa92 9e b2 LDS PTR2 restore monitor sp 4308 fa94 bd fb bf JSR SAVSTACK save user regs 4309 fa97 bd fa de JSR REMBPS remove breakpoints from code 4310 fa9a de 60 LDX REGS 4311 fa9c 09 DEX 4312 fa9d df 60 STX REGS save user pc value 4313 4314 *if(call command) remove call return addr from user stack; 4315 fa9f 7d 00 c1 TST TMP2 1=go, 0=call 4316 faa2 26 06 BNE GO3 jump if go command 4317 faa4 de 69 LDX SP remove return address 4318 faa6 08 INX user stack pointer 4319 faa7 08 INX 4320 faa8 df 69 STX SP 4321 faaa bd e5 1f GO3 JSR OUTCRLF print register values 4322 faad bd e2 3e JSR RPRINT 4323 fab0 39 RTS done 4324 4325 ********** 4326 * setbps - Replace user code with swi's at 4327 *breakpoint addresses. 4328 ********** 4329 *for(b=0; b=6; b =+ 2) 4330 * x = brktabl[b]; 4331 * if(x != 0) 4332 * optabl[b] = x[0]; 4333 * x[0] = $3F; 4334 *Put monitor SWI vector into jump table 4335 4336 fab1 5f SETBPS CLRB 4337 fab2 ce 00 9c SETBPS1 LDX #BRKTABL 4338 fab5 18 ce 00 b6 LDY #PTR4 4339 fab9 3a ABX 4340 faba 18 3a ABY 4341 fabc ee 00 LDX 0,X breakpoint table entry 4342 fabe 27 0a BEQ SETBPS2 jump if 0 4343 fac0 a6 00 LDAA 0,X save user opcode 4344 fac2 18 a7 00 STAA 0,Y 4345 fac5 86 3f LDAA #SWI 4346 fac7 bd e2 d5 JSR WRITE insert swi into code 4347 faca cb 02 SETBPS2 ADDB #$2 4348 facc c1 06 CMPB #$6 4349 face 2f e2 BLE SETBPS1 loop 4 times 4350 fad0 de f5 LDX JSWI+1 4351 fad2 df b4 STX PTR3 save user swi vector 4352 fad4 86 7e LDAA #$7E jmp opcode 4353 fad6 97 f4 STAA JSWI 4354 fad8 ce fa 91 LDX #SWIIN 4355 fadb df f5 STX JSWI+1 monitor swi vector 4356 fadd 39 RTS 4357 4358 ********** 4359 * rembps - Remove breakpoints from user code. 4360 ********** 4361 *for(b=0; b=6; b =+ 2) 4362 * x = brktabl[b]; 4363 * if(x != 0) 4364 * x[0] = optabl[b]; 4365 *Replace user's SWI vector 4366 fade 5f REMBPS CLRB 4367 fadf ce 00 9c REMBPS1 LDX #BRKTABL 4368 fae2 18 ce 00 b6 LDY #PTR4 4369 fae6 3a ABX 4370 fae7 18 3a ABY 4371 fae9 ee 00 LDX 0,X breakpoint table entry 4372 faeb 27 06 BEQ REMBPS2 jump if 0 4373 faed 18 a6 00 LDAA 0,Y 4374 faf0 bd e2 d5 JSR WRITE restore user opcode 4375 faf3 cb 02 REMBPS2 ADDB #$2 4376 faf5 c1 06 CMPB #$6 4377 faf7 2f e6 BLE REMBPS1 loop 4 times 4378 faf9 de b4 LDX PTR3 restore user swi vector 4379 fafb df f5 STX JSWI+1 4380 fafd 39 RTS 4381 4382 4383 ********** 4384 * trace - Trace n instructions starting 4385 *at user's pc value. n is a hex number less than 4386 *$FF (defaults to 1). 4387 ********** 4388 *a = wskip(); 4389 *if(a != cr) 4390 * a = buffarg(); a = wskip(); 4391 * if(a != cr) return(bad argument); 4392 * countt1 = n 4393 fafe 7f 00 c3 TRACE CLR TMP4 4394 fb01 7c 00 c3 INC TMP4 default count=1 4395 fb04 7f 00 a9 CLR CHRCNT set up for display 4396 fb07 bd e3 4b JSR WSKIP 4397 fb0a 27 13 BEQ TRACE2 jump if cr 4398 fb0c bd e2 7f JSR BUFFARG 4399 fb0f bd e3 4b JSR WSKIP 4400 fb12 27 07 BEQ TRACE1 jump if cr 4401 fb14 ce e6 c2 LDX #MSG9 "bad argument" 4402 fb17 bd e5 2f JSR OUTSTRG 4403 fb1a 39 RTS 4404 fb1b 96 97 TRACE1 LDAA SHFTREG+1 n 4405 fb1d 97 c3 STAA TMP4 4406 4407 *Disassemble the line about to be traced 4408 fb1f TRACE2 EQU * 4409 fb1f d6 c3 LDAB TMP4 4410 fb21 37 PSHB 4411 fb22 de 60 LDX REGS 4412 fb24 df b0 STX PTR1 pc value for disass 4413 fb26 bd f3 8d JSR DISASSM 4414 fb29 33 PULB 4415 fb2a d7 c3 STAB TMP4 4416 4417 *run one instruction 4418 *rprint(); 4419 *while(count > 0) continue trace; 4420 fb2c bd fb 80 JSR RUNONE 4421 fb2f bd e3 6e JSR CHKABRT check for abort 4422 fb32 bd e5 4f JSR TABTO print registers for 4423 fb35 bd e2 3e JSR RPRINT result of trace 4424 fb38 7a 00 c3 DEC TMP4 4425 fb3b 27 05 BEQ TRACDON quit if count=0 4426 fb3d bd e5 1f TRACE3 JSR OUTCRLF 4427 fb40 20 dd BRA TRACE2 4428 fb42 39 TRACDON RTS 4429 4430 4431 ********** 4432 * stopat - Trace instructions until 4433 *is reached. 4434 ********** 4435 *if((a=wskip) != cr) 4436 * a = buffarg(); a = wskip(); 4437 * if(a != cr) return(bad argument); 4438 *else return(bad argument); 4439 fb43 STOPAT EQU * 4440 fb43 bd e3 4b JSR WSKIP 4441 fb46 27 18 BEQ STOPGO jump if cr - no argument 4442 fb48 bd e2 7f JSR BUFFARG 4443 fb4b bd e3 4b JSR WSKIP 4444 fb4e 27 07 BEQ STOPAT1 jump if cr 4445 fb50 ce e6 c2 LDX #MSG9 "bad argument" 4446 fb53 bd e5 2f JSR OUTSTRG 4447 fb56 39 RTS 4448 fb57 7d 00 a8 STOPAT1 TST COUNT 4449 fb5a 27 04 BEQ STOPGO jump if no argument 4450 fb5c de 96 LDX SHFTREG 4451 fb5e df aa STX PTRMEM update "current location" 4452 4453 *while(!(ptrmem <= userpc < ptrmem+10)) runone(); 4454 *rprint(); 4455 fb60 dc 60 STOPGO LDD REGS userpc 4456 fb62 1a 93 aa CPD PTRMEM 4457 fb65 25 0a BLO STOPNEXT if(userpc < ptrmem) runone 4458 fb67 dc aa LDD PTRMEM 4459 fb69 c3 00 0a ADDD #10 4460 fb6c 1a 93 60 CPD REGS 4461 fb6f 22 08 BHI STOPDON quit if ptrmem+10 > userpc 4462 fb71 bd fb 80 STOPNEXT JSR RUNONE 4463 fb74 bd e3 6e JSR CHKABRT check for abort 4464 fb77 20 e7 BRA STOPGO 4465 fb79 bd e5 1f STOPDON JSR OUTCRLF 4466 fb7c bd e2 3e JSR RPRINT result of trace 4467 fb7f 39 RTS done 4468 4469 4470 ************************* 4471 * runone - This routine is used by the trace and 4472 * execute commands to run one only one user instruction. 4473 * Control is passed to the user code via an RTI. OC5 4474 * is then used to trigger an XIRQ as soon as the first user 4475 * opcode is fetched. Control then returns to the monitor 4476 * through XIRQIN. 4477 * Externally, the OC5 pin must be wired to the XIRQ pin. 4478 ************************ 4479 * Disable oc5 interrupts 4480 * Put monitor XIRQ vector into jump table 4481 * Unmask x bit in user ccr 4482 * Setup OC5 to go low when first user instruction executed 4483 fb80 RUNONE EQU * 4484 fb80 86 7e LDAA #$7E put "jmp xirqin" in jump table 4485 fb82 97 d3 STAA JTOC5 4486 fb84 ce fb bc LDX #XIRQIN 4487 fb87 df f2 STX JXIRQ+1 4488 fb89 96 68 LDAA REGS+8 x bit will be cleared when 4489 fb8b 84 bf ANDA #$BF rti is executed below 4490 fb8d 97 68 STAA REGS+8 4491 fb8f c6 57 LDAB #87 cycles to end of rti 4492 fb91 fe 10 0e LDX TCNT 4493 fb94 3a ABX 3~ \ 4494 fb95 ff 10 1e STX TOC5 oc5 match register 5~ \ 4495 fb98 b6 10 20 LDAA TCTL1 4~ \ 4496 fb9b 84 fe ANDA #$FE set up oc5 low on match 2~ \ 4497 fb9d b7 10 20 STAA TCTL1 enable oc5 interrupt 4~ / 86~ 4498 4499 ** RESTACK - Restore user stack and RTI to user code. 4500 * This code is the pathway to execution of user code. 4501 *(Force extended addressing to maintain cycle count) 4502 *Restore user stack and rti to user code 4503 fba0 RESTACK EQU * 68~ 4504 fba0 bf 00 b2 STS >PTR2 save monitor sp 4505 fba3 be 00 69 LDS >SP user stack pointer 4506 fba6 fe 00 60 LDX >REGS 4507 fba9 3c PSHX pc 4508 fbaa fe 00 62 LDX >REGS+2 4509 fbad 3c PSHX y 4510 fbae fe 00 64 LDX >REGS+4 4511 fbb1 3c PSHX x 4512 fbb2 fc 00 66 LDD >REGS+6 4513 fbb5 36 PSHA a 4514 fbb6 37 PSHB b 4515 fbb7 b6 00 68 LDAA >REGS+8 4516 fbba 36 PSHA ccr 4517 fbbb 3b RTI 4518 4519 ** Return here from run one line of user code. 4520 fbbc XIRQIN EQU * 4521 fbbc 30 TSX user sp -> x 4522 fbbd 9e b2 LDS PTR2 restore monitor sp 4523 4524 ** SAVSTACK - Save user's registers. 4525 * On entry - x points to top of user stack. 4526 fbbf SAVSTACK EQU * 4527 fbbf a6 00 LDAA 0,X 4528 fbc1 97 68 STAA REGS+8 user ccr 4529 fbc3 ec 01 LDD 1,X 4530 fbc5 97 67 STAA REGS+7 b 4531 fbc7 d7 66 STAB REGS+6 a 4532 fbc9 ec 03 LDD 3,X 4533 fbcb dd 64 STD REGS+4 x 4534 fbcd ec 05 LDD 5,X 4535 fbcf dd 62 STD REGS+2 y 4536 fbd1 ec 07 LDD 7,X 4537 fbd3 dd 60 STD REGS pc 4538 fbd5 c6 08 LDAB #8 4539 fbd7 3a ABX 4540 fbd8 df 69 STX SP user stack pointer 4541 fbda b6 10 20 LDAA TCTL1 force oc5 pin high which 4542 fbdd 8a 03 ORAA #$03 is tied to xirq line 4543 fbdf b7 10 20 STAA TCTL1 4544 fbe2 86 08 LDAA #$08 4545 fbe4 b7 10 0b STAA CFORC 4546 fbe7 39 RTS 4547 4548 4549 ********** 4550 * HOST() - Establishes transparent link between 4551 * terminal and host. Port used for host is 4552 * determined in the reset initialization routine 4553 * and stored in HOSTDEV. 4554 * To exit type control A. 4555 * To send break to host type control B. 4556 *if(no external device) return; 4557 *initialize host port; 4558 *While( !(control A)) 4559 * input(terminal); output(host); 4560 * input(host); output(terminal); 4561 4562 fbe8 96 a6 HOST LDAA EXTDEV 4563 fbea 26 07 BNE HOST0 jump if host port avail. 4564 fbec ce e6 cf LDX #MSG10 "no host port avail" 4565 fbef bd e5 2f JSR OUTSTRG 4566 fbf2 39 RTS 4567 fbf3 7f 00 a4 HOST0 CLR AUTOLF turn off autolf 4568 * JSR HOSTCO connect sci (evb board) 4569 fbf6 bd fc 52 JSR HOSTINIT initialize host port 4570 fbf9 bd e3 b5 HOST1 JSR INPUT read terminal 4571 fbfc 4d TSTA 4572 fbfd 27 10 BEQ HOST3 jump if no char 4573 fbff 81 01 CMPA #CTLA 4574 fc01 27 17 BEQ HOSTEND jump if control a 4575 fc03 81 02 CMPA #CTLB 4576 fc05 26 05 BNE HOST2 jump if not control b 4577 fc07 bd fc 1e JSR TXBREAK send break to host 4578 fc0a 20 03 BRA HOST3 4579 fc0c bd fc 6a HOST2 JSR HOSTOUT echo to host 4580 fc0f bd fc 5e HOST3 JSR HOSTIN read host 4581 fc12 4d TSTA 4582 fc13 27 e4 BEQ HOST1 jump if no char 4583 fc15 bd e3 e1 JSR OUTPUT echo to terminal 4584 fc18 20 df BRA HOST1 4585 fc1a 7c 00 a4 HOSTEND INC AUTOLF turn on autolf 4586 * JSR TARGCO disconnect sci (evb board) 4587 fc1d 39 RTS return 4588 4589 ********** 4590 * txbreak() - transmit break to host port. 4591 * The duration of the transmitted break is 4592 * approximately 200,000 E-clock cycles, or 4593 * 100ms at 2.0 MHz. 4594 *********** 4595 fc1e TXBREAK EQU * 4596 fc1e 96 a7 LDAA HOSTDEV 4597 fc20 81 03 CMPA #$03 4598 fc22 27 0d BEQ TXBDU jump if duartb is host 4599 4600 fc24 ce 10 2d TXBSCI LDX #SCCR2 sci is host 4601 fc27 1c 00 01 BSET 0,X $01 set send break bit 4602 fc2a 8d 1d BSR TXBWAIT 4603 fc2c 1d 00 01 BCLR 0,X $01 clear send break bit 4604 fc2f 20 0d BRA TXB1 4605 4606 fc31 ce d0 08 TXBDU LDX #PORTB duart host port 4607 fc34 86 60 LDAA #$60 start break cmd 4608 fc36 a7 02 STAA 2,X port b command register 4609 fc38 8d 0f BSR TXBWAIT 4610 fc3a 86 70 LDAA #$70 stop break cmd 4611 fc3c a7 02 STAA 2,X port b command register 4612 4613 fc3e 86 0d TXB1 LDAA #$0D 4614 fc40 bd fc 6a JSR HOSTOUT send carriage return 4615 fc43 86 0a LDAA #$0A 4616 fc45 bd fc 6a JSR HOSTOUT send linefeed 4617 fc48 39 RTS 4618 4619 fc49 18 ce 6f 9b TXBWAIT LDY #$6F9B loop count = 28571 4620 fc4d 18 09 TXBWAIT1 DEY 7 cycle loop 4621 fc4f 26 fc BNE TXBWAIT1 4622 fc51 39 RTS 4623 4624 4625 ********** 4626 * hostinit(), hostin(), hostout() - host i/o 4627 *routines. Restores original terminal device. 4628 ********** 4629 fc52 d6 a5 HOSTINIT LDAB IODEV save terminal 4630 fc54 37 PSHB 4631 fc55 d6 a7 LDAB HOSTDEV 4632 fc57 d7 a5 STAB IODEV point to host 4633 fc59 bd e3 ad JSR INIT initialize host 4634 fc5c 20 16 BRA TERMRES restore terminal 4635 fc5e d6 a5 HOSTIN LDAB IODEV save terminal 4636 fc60 37 PSHB 4637 fc61 d6 a7 LDAB HOSTDEV 4638 fc63 d7 a5 STAB IODEV point to host 4639 fc65 bd e3 b5 JSR INPUT read host 4640 fc68 20 0a BRA TERMRES restore terminal 4641 fc6a d6 a5 HOSTOUT LDAB IODEV save terminal 4642 fc6c 37 PSHB 4643 fc6d d6 a7 LDAB HOSTDEV 4644 fc6f d7 a5 STAB IODEV point to host 4645 fc71 bd e3 e1 JSR OUTPUT write to host 4646 fc74 33 TERMRES PULB restore terminal device 4647 fc75 d7 a5 STAB IODEV 4648 fc77 39 RTS 4649 4650 4651 ********** 4652 * load(ptrbuff[]) - Load s1/s9 records from 4653 *host to memory. Ptrbuff[] points to string in 4654 *input buffer which is a command to output s1/s9 4655 *records from the host ("cat filename" for unix). 4656 * Returns error and address if it can't write 4657 *to a particular location. 4658 ********** 4659 * verify(ptrbuff[]) - Verify memory from load 4660 *command. Ptrbuff[] is same as for load. 4661 * tmp3 is used as an error indication, 0=no errors, 4662 * 1=receiver, 2=rom error, 3=checksum error. 4663 ********** 4664 fc78 7f 00 c1 VERIFY CLR TMP2 4665 fc7b 7c 00 c1 INC TMP2 TMP2=1=verify 4666 fc7e 20 03 BRA LOAD1 4667 fc80 7f 00 c1 LOAD CLR TMP2 0=load 4668 4669 *a=wskip(); 4670 *if(a = cr) goto transparent mode; 4671 *if(t option) hostdev = iodev; 4672 fc83 LOAD1 EQU * 4673 fc83 7f 00 c2 CLR TMP3 clear error flag 4674 fc86 bd e3 4b JSR WSKIP 4675 fc89 26 03 BNE LOAD2 4676 fc8b 7e fb e8 JMP HOST go to host if no args 4677 fc8e bd e1 f2 LOAD2 JSR UPCASE 4678 fc91 81 54 CMPA #'T' look for t option 4679 fc93 26 16 BNE LOAD3 jump not t option 4680 fc95 bd e3 3d JSR INCBUFF 4681 fc98 bd e3 36 JSR READBUFF get next character 4682 fc9b bd e3 43 JSR DECBUFF 4683 fc9e 81 0d CMPA #$0D 4684 fca0 26 09 BNE LOAD3 jump if not t option 4685 fca2 7f 00 a4 CLR AUTOLF 4686 fca5 96 a5 LDAA IODEV 4687 fca7 97 a7 STAA HOSTDEV set host port = terminal 4688 fca9 20 18 BRA LOAD10 go wait for s1 records 4689 4690 *else while(not cr) 4691 * read character from input buffer; 4692 * send character to host; 4693 fcab 7f 00 a4 LOAD3 CLR AUTOLF 4694 * JSR HOSTCO connect sci (evb board) 4695 fcae bd fc 52 JSR HOSTINIT initialize host port 4696 fcb1 bd e3 36 LOAD4 JSR READBUFF get next char 4697 fcb4 bd e3 3d JSR INCBUFF 4698 fcb7 36 PSHA save char 4699 fcb8 bd fc 6a JSR HOSTOUT output to host 4700 fcbb bd e3 e1 JSR OUTPUT echo to terminal 4701 fcbe 32 PULA 4702 fcbf 81 0d CMPA #$0D 4703 fcc1 26 ee BNE LOAD4 jump if not cr 4704 4705 *repeat: /* look for s records */ 4706 * if(hostdev != iodev) check abort; 4707 * a = hostin(); 4708 * if(a = 'S') 4709 * a = hostin; 4710 * if(a = '1') 4711 * checksum = 0; 4712 * get byte count in b; 4713 * get base address in x; 4714 * while(byte count > 0) 4715 * byte(); 4716 * x++; b--; 4717 * if(tmp3=0) /* no error */ 4718 * if(load) x[0] = shftreg+1; 4719 * if(x[0] != shftreg+1) 4720 * tmp3 = 2; /* rom error */ 4721 * ptr3 = x; /* save address */ 4722 * if(tmp3 = 0) do checksum; 4723 * if(checksum err) tmp3 = 3; /* checksum error */ 4724 ** Look for s-record header 4725 fcc3 LOAD10 EQU * 4726 fcc3 96 a7 LDAA HOSTDEV 4727 fcc5 91 a5 CMPA IODEV 4728 fcc7 27 03 BEQ LOAD11 jump if hostdev=iodev 4729 fcc9 bd e3 6e JSR CHKABRT check for abort 4730 fccc bd fc 5e LOAD11 JSR HOSTIN read host 4731 fccf 4d TSTA 4732 fcd0 27 f1 BEQ LOAD10 jump if no input 4733 fcd2 81 53 CMPA #'S' 4734 fcd4 26 ed BNE LOAD10 jump if not S 4735 fcd6 bd fc 5e LOAD12 JSR HOSTIN read host 4736 fcd9 4d TSTA 4737 fcda 27 fa BEQ LOAD12 jump if no input 4738 fcdc 81 39 CMPA #'9' 4739 fcde 27 4e BEQ LOAD90 jump if S9 record 4740 fce0 81 31 CMPA #'1' 4741 fce2 26 df BNE LOAD10 jump if not S1 4742 fce4 7f 00 c3 CLR TMP4 clear checksum 4743 ** Get Byte Count and Starting Address 4744 fce7 bd fd 71 JSR BYTE 4745 fcea d6 97 LDAB SHFTREG+1 4746 fcec c0 02 SUBB #$2 b = byte count 4747 fcee bd fd 71 JSR BYTE 4748 fcf1 bd fd 71 JSR BYTE 4749 fcf4 37 PSHB save byte count 4750 fcf5 dc 96 LDD SHFTREG 4751 fcf7 d3 ac ADDD LDOFFST add offset 4752 fcf9 8f XGDX x = address+offset 4753 fcfa 33 PULB restore byte count 4754 fcfb 09 DEX condition for loop 4755 ** Get and Store Incoming Data Byte 4756 fcfc bd fd 71 LOAD20 JSR BYTE get next byte 4757 fcff 08 INX 4758 fd00 5a DECB check byte count 4759 fd01 27 1b BEQ LOAD30 if b=0, go do checksum 4760 fd03 7d 00 c2 TST TMP3 4761 fd06 26 bb BNE LOAD10 jump if error flagged 4762 fd08 7d 00 c1 TST TMP2 4763 fd0b 26 05 BNE LOAD21 jump if verify 4764 fd0d 96 97 LDAA SHFTREG+1 4765 fd0f bd e2 d5 JSR WRITE load only 4766 fd12 a1 00 LOAD21 CMPA 0,X verify ram location 4767 fd14 27 e6 BEQ LOAD20 jump if ram ok 4768 fd16 86 02 LDAA #$02 4769 fd18 97 c2 STAA TMP3 indicate rom error 4770 fd1a df b4 STX PTR3 save error address 4771 fd1c 20 de BRA LOAD20 finish download 4772 ** Get and Test Checksum 4773 fd1e 7d 00 c2 LOAD30 TST TMP3 4774 fd21 26 a0 BNE LOAD10 jump if error already 4775 fd23 96 c3 LDAA TMP4 4776 fd25 4c INCA do checksum 4777 fd26 27 9b BEQ LOAD10 jump if s1 record okay 4778 fd28 86 03 LDAA #$03 4779 fd2a 97 c2 STAA TMP3 indicate checksum error 4780 fd2c 20 95 BRA LOAD10 4781 4782 * if(a = '9') 4783 * read rest of record; 4784 * if(tmp3=2) return("[ptr3]"); 4785 * if(tmp3=1) return("rcv error"); 4786 * if(tmp3=3) return("checksum err"); 4787 * else return("done"); 4788 fd2e bd fd 71 LOAD90 JSR BYTE 4789 fd31 d6 97 LDAB SHFTREG+1 b = byte count 4790 fd33 bd fd 71 LOAD91 JSR BYTE 4791 fd36 5a DECB 4792 fd37 26 fa BNE LOAD91 loop until end of record 4793 fd39 c6 64 LDAB #$64 4794 fd3b bd e3 2a LOAD91A JSR DLY10MS delay 1 sec -let host finish 4795 fd3e 5a DECB 4796 fd3f 26 fa BNE LOAD91A 4797 fd41 bd e3 b5 JSR INPUT clear comm device 4798 fd44 cc 7e 0d LDD #$7E0D put dummy command in inbuff 4799 fd47 dd 6b STD INBUFF 4800 fd49 7c 00 a4 INC AUTOLF turn on autolf 4801 * JSR TARGCO disconnect sci (evb) 4802 fd4c ce e6 dc LDX #MSG11 "done" default msg 4803 fd4f 96 c2 LDAA TMP3 4804 fd51 81 02 CMPA #$02 4805 fd53 26 08 BNE LOAD92 jump not rom error 4806 fd55 ce 00 b4 LDX #PTR3 4807 fd58 bd e5 13 JSR OUT2BSP address of rom error 4808 fd5b 20 13 BRA LOAD95 4809 fd5d 81 01 LOAD92 CMPA #$01 4810 fd5f 26 05 BNE LOAD93 jump not rcv error 4811 fd61 ce e6 fa LDX #MSG14 "rcv error" 4812 fd64 20 07 BRA LOAD94 4813 fd66 81 03 LOAD93 CMPA #$03 4814 fd68 26 03 BNE LOAD94 jump not checksum error 4815 fd6a ce e6 e1 LDX #MSG12 "checksum error" 4816 fd6d bd e5 2f LOAD94 JSR OUTSTRG 4817 fd70 39 LOAD95 RTS 4818 4819 4820 ********** 4821 * byte() - Read 2 ascii bytes from host and 4822 *convert to one hex byte. Returns byte 4823 *shifted into shftreg and added to tmp4. 4824 ********** 4825 fd71 37 BYTE PSHB 4826 fd72 3c PSHX 4827 fd73 bd fc 5e BYTE0 JSR HOSTIN read host (1st byte) 4828 fd76 4d TSTA 4829 fd77 27 fa BEQ BYTE0 loop until input 4830 fd79 bd e2 4c JSR HEXBIN 4831 fd7c bd fc 5e BYTE1 JSR HOSTIN read host (2nd byte) 4832 fd7f 4d TSTA 4833 fd80 27 fa BEQ BYTE1 loop until input 4834 fd82 bd e2 4c JSR HEXBIN 4835 fd85 96 97 LDAA SHFTREG+1 4836 fd87 9b c3 ADDA TMP4 4837 fd89 97 c3 STAA TMP4 add to checksum 4838 fd8b 38 PULX 4839 fd8c 33 PULB 4840 fd8d 39 RTS 4841 4842 4843 ********** 4844 * offset [] 4845 * Specify offset to be added to s-record address when 4846 * downloading from the host. 4847 * OFFSET -show the current offset 4848 * OFFSET -current offset = data 4849 * OFFSET - -current offset = 0 - data 4850 ********** 4851 *if() then offset = data; 4852 *print(offset); 4853 fd8e OFFSET EQU * 4854 fd8e 7f 00 c3 CLR TMP4 minus indicator 4855 fd91 bd e3 4b JSR WSKIP 4856 fd94 27 28 BEQ OFFST3 jump if cr (no argument) 4857 fd96 81 2d CMPA #'-' 4858 fd98 26 09 BNE OFFST1 jump not - 4859 fd9a 7c 00 c3 INC TMP4 set minus sign flag 4860 fd9d bd e3 3d JSR INCBUFF move buffer pointer 4861 fda0 bd e3 4b JSR WSKIP 4862 fda3 bd e2 7f OFFST1 JSR BUFFARG read argument 4863 fda6 7d 00 a8 TST COUNT 4864 fda9 27 1d BEQ OFFSTER jump if bad argument 4865 fdab bd e3 4b JSR WSKIP 4866 fdae 26 18 BNE OFFSTER jump if not cr 4867 fdb0 dc 96 LDD SHFTREG get offset value 4868 fdb2 7d 00 c3 TST TMP4 4869 fdb5 27 05 BEQ OFFST2 jump if positive 4870 fdb7 cc 00 00 LDD #$0000 negative - sub from 0 4871 fdba 93 96 SUBD SHFTREG 4872 fdbc dd ac OFFST2 STD LDOFFST 4873 fdbe bd e5 1f OFFST3 JSR OUTCRLF display current offset 4874 fdc1 ce 00 ac LDX #LDOFFST 4875 fdc4 bd e5 13 JSR OUT2BSP 4876 fdc7 39 RTS 4877 4878 fdc8 ce e6 c2 OFFSTER LDX #MSG9 "bad argument" 4879 fdcb bd e5 2f JSR OUTSTRG 4880 fdce 39 RTS 4881 4882 4883 4884 4885 4886 ********** 4887 * register [] - prints the user regs 4888 *and opens them for modification. is 4889 *the first register opened (default = P). 4890 * Subcommands: 4891 * [] Opens the next register. 4892 * [] Return. 4893 * The register value is only changed if 4894 * is entered before the subcommand. 4895 ********** 4896 *x[] = reglist 4897 *a = wskip(); a = upcase(a); 4898 *if(a != cr) 4899 * while( a != x[0] ) 4900 * if( x[0] = "s") return(bad argument); 4901 * x[]++; 4902 * incbuff(); a = wskip(); 4903 * if(a != cr) return(bad argument); 4904 4905 fdcf ce e2 09 REGISTER LDX #REGLIST 4906 fdd2 bd e3 4b JSR WSKIP a = first char of arg 4907 fdd5 bd e1 f2 JSR UPCASE convert to upper case 4908 fdd8 81 0d CMPA #$D 4909 fdda 27 1c BEQ REG4 jump if no argument 4910 fddc a1 00 REG1 CMPA 0,X 4911 fdde 27 0e BEQ REG3 4912 fde0 e6 00 LDAB 0,X 4913 fde2 08 INX 4914 fde3 c1 53 CMPB #'S' 4915 fde5 26 f5 BNE REG1 jump if not "s" 4916 fde7 ce e6 c2 REG2 LDX #MSG9 "bad argument" 4917 fdea bd e5 2f JSR OUTSTRG 4918 fded 39 RTS 4919 fdee 3c REG3 PSHX 4920 fdef bd e3 3d JSR INCBUFF 4921 fdf2 bd e3 4b JSR WSKIP next char after arg 4922 fdf5 38 PULX 4923 fdf6 26 ef BNE REG2 jump if not cr 4924 4925 *rprint(); 4926 * while(x[0] != "s") 4927 * rprnt1(x); 4928 * a = termarg(); /* read from terminal */ 4929 * if( ! dchek(a) ) return(bad argument); 4930 * if(countu1 != 0) 4931 * if(x[14] = 1) 4932 * regs[x[7]++ = shftreg; 4933 * regs[x[7]] = shftreg+1; 4934 * if(a = cr) break; 4935 *return; 4936 4937 fdf8 bd e2 3e REG4 JSR RPRINT print all registers 4938 fdfb bd e5 1f REG5 JSR OUTCRLF 4939 fdfe bd e2 1e JSR RPRNT1 print reg name 4940 fe01 7f 00 96 CLR SHFTREG 4941 fe04 7f 00 97 CLR SHFTREG+1 4942 fe07 bd e2 a2 JSR TERMARG read subcommand 4943 fe0a bd e3 66 JSR DCHEK 4944 fe0d 27 07 BEQ REG6 jump if delimeter 4945 fe0f ce e6 c2 LDX #MSG9 "bad argument" 4946 fe12 bd e5 2f JSR OUTSTRG 4947 fe15 39 RTS 4948 fe16 36 REG6 PSHA 4949 fe17 3c PSHX 4950 fe18 7d 00 a8 TST COUNT 4951 fe1b 27 14 BEQ REG8 jump if no input 4952 fe1d e6 07 LDAB 7,X get reg offset 4953 fe1f a6 0e LDAA 14,X byte size 4954 fe21 ce 00 60 LDX #REGS user registers 4955 fe24 3a ABX 4956 fe25 4d TSTA 4957 fe26 27 05 BEQ REG7 jump if 1 byte reg 4958 fe28 96 96 LDAA SHFTREG 4959 fe2a a7 00 STAA 0,X put in top byte 4960 fe2c 08 INX 4961 fe2d 96 97 REG7 LDAA SHFTREG+1 4962 fe2f a7 00 STAA 0,X put in bottom byte 4963 fe31 38 REG8 PULX 4964 fe32 32 PULA 4965 fe33 e6 00 LDAB 0,X CHECK FOR REGISTER S 4966 fe35 c1 53 CMPB #'S' 4967 fe37 27 05 BEQ REG9 jump if "s" 4968 fe39 08 INX point to next register 4969 fe3a 81 0d CMPA #$D 4970 fe3c 26 bd BNE REG5 jump if not cr 4971 fe3e 39 REG9 RTS 4972 4973 4974 * Equates 4975 0008 JPORTD EQU $08 4976 0009 JDDRD EQU $09 4977 002b JBAUD EQU $2B 4978 002c JSCCR1 EQU $2C 4979 002d JSCCR2 EQU $2D 4980 002e JSCSR EQU $2E 4981 002f JSCDAT EQU $2F 4982 * 4983 4984 ************ 4985 * xboot [ []] - Use SCI to talk to an 'hc11 in 4986 * boot mode. Downloads bytes from addr1 thru addr2. 4987 * Default addr1 = $C000 and addr2 = $C0ff. 4988 * 4989 * IMPORTANT: 4990 * if talking to an 'A8 or 'A2: use either default addresses or ONLY 4991 * addr1 - this sends 256 bytes 4992 * if talking to an 'E9: include BOTH addr1 and addr2 for variable 4993 * length 4994 ************ 4995 4996 *Get arguments 4997 *If no args, default $C000 4998 fe3f bd e3 4b BOOT JSR WSKIP 4999 fe42 26 0b BNE BOT1 jump if arguments 5000 fe44 ce c0 ff LDX #$C0FF addr2 default 5001 fe47 df b8 STX PTR5 5002 fe49 18 ce c0 00 LDY #$C000 addr1 default 5003 fe4d 20 36 BRA BOT2 go - use default address 5004 5005 *Else get arguments 5006 fe4f bd e2 7f BOT1 JSR BUFFARG 5007 fe52 7d 00 a8 TST COUNT 5008 fe55 27 27 BEQ BOTERR jump if no address 5009 fe57 18 de 96 LDY SHFTREG start address (addr1) 5010 fe5a bd e3 4b JSR WSKIP 5011 fe5d 26 0c BNE BOT1A go get addr2 5012 fe5f 18 df b8 STY PTR5 default addr2... 5013 fe62 dc b8 LDD PTR5 ...by taking addr1... 5014 fe64 c3 00 ff ADDD #$FF ...and adding 255 to it... 5015 fe67 dd b8 STD PTR5 ...for a total download of 256 5016 fe69 20 1a BRA BOT2 continue 5017 * 5018 fe6b bd e2 7f BOT1A JSR BUFFARG 5019 fe6e 7d 00 a8 TST COUNT 5020 fe71 27 0b BEQ BOTERR jump if no address 5021 fe73 de 96 LDX SHFTREG end address (addr2) 5022 fe75 df b8 STX PTR5 5023 fe77 bd e3 4b JSR WSKIP 5024 fe7a 26 02 BNE BOTERR go use addr1 and addr2 5025 fe7c 20 07 BRA BOT2 5026 5027 * 5028 fe7e ce e6 c2 BOTERR LDX #MSG9 "bad argument" 5029 fe81 bd e5 2f JSR OUTSTRG 5030 fe84 39 RTS 5031 5032 *Boot routine 5033 fe85 c6 ff BOT2 LDAB #$FF control character ($ff -> download) 5034 fe87 bd fe 9d JSR BTSUB set up SCI and send control char 5035 * initializes X as register pointer 5036 *Download block 5037 fe8a 18 a6 00 BLOP LDAA 0,Y 5038 fe8d a7 2f STAA JSCDAT,X write to transmitter 5039 fe8f 1f 2e 80 fc BRCLR JSCSR,X $80 * wait for TDRE 5040 fe93 18 9c b8 CPY PTR5 if last... 5041 fe96 27 04 BEQ BTDONE ...quit 5042 fe98 18 08 INY else... 5043 fe9a 20 ee BRA BLOP ...send next 5044 fe9c 39 BTDONE RTS 5045 5046 ************************************************ 5047 *Subroutine 5048 * btsub - sets up SCI and outputs control character 5049 * On entry, B = control character 5050 * On exit, X = $1000 5051 * A = $0C 5052 *************************** 5053 5054 fe9d BTSUB EQU * 5055 fe9d ce 10 00 LDX #$1000 to use indexed addressing 5056 fea0 86 02 LDAA #$02 5057 fea2 a7 08 STAA JPORTD,X drive transmitter line 5058 fea4 a7 09 STAA JDDRD,X high 5059 fea6 6f 2d CLR JSCCR2,X turn off XMTR and RCVR 5060 fea8 86 22 LDAA #$22 BAUD = /16 5061 feaa a7 2b STAA JBAUD,X 5062 feac 86 0c LDAA #$0C TURN ON XMTR & RCVR 5063 feae a7 2d STAA JSCCR2,X 5064 feb0 e7 2f STAB JSCDAT,X 5065 feb2 1f 2e 80 fc BRCLR JSCSR,X $80 * wait for TDRE 5066 feb6 39 RTS 5067 5068 5069 *********** 5070 * TILDE - This command is put into the combuff by the 5071 * load command so that extraneous carriage returns after 5072 * the load will not hang up. 5073 feb7 39 TILDE RTS 5074 5075 ****************** 5076 * 5077 * EVBTEST - This routine makes it a little easier 5078 * on us to test this board. 5079 * 5080 ****************** 5081 5082 feb8 86 ff EVBTEST LDAA #$FF 5083 feba b7 10 00 STAA $1000 Write ones to port A 5084 febd 7f 00 a4 CLR AUTOLF Turn off auto lf 5085 * JSR HOSTCO Connect host 5086 fec0 bd fc 52 JSR HOSTINIT Initialize host 5087 fec3 86 7f LDAA #$7f 5088 fec5 bd fc 6a JSR HOSTOUT Send Delete to Altos 5089 fec8 86 0d LDAA #$0d 5090 feca bd fc 6a JSR HOSTOUT Send 5091 fecd 7c 00 a4 INC AUTOLF Turn on Auto LF 5092 fed0 ce 00 70 LDX #INBUFF+5 Point at Load message 5093 fed3 df ae STX PTR0 Set pointer for load command 5094 fed5 18 ce fe f3 LDY #MSGEVB Point at cat line 5095 fed9 18 a6 00 LOOP LDAA 0,Y Loop to xfer command line 5096 fedc 81 04 CMPA #04 Into buffalo line buffer 5097 fede 27 07 BEQ DONE Quit on $04 5098 fee0 a7 00 STAA 0,X 5099 fee2 08 INX next character 5100 fee3 18 08 INY 5101 fee5 20 f2 BRA LOOP 5102 fee7 7f 00 c1 DONE CLR TMP2 Set load vs. verify 5103 feea bd fc ab JSR LOAD3 Jmp into middle of load 5104 feed 8e 00 5f LDS #STACK Reset Stack 5105 fef0 7e c0 b3 JMP $C0B3 Jump to Downloaded code 5106 5107 fef3 63 61 74 20 65 76 MSGEVB FCC /cat evbtest.out/ 62 74 65 73 74 2e 6f 75 74 5108 ff02 0d FCB $0D 5109 ff03 04 FCB $04 5110 5111 5112 5113 *** Jump table *** 5114 ff7c ORG ROMBS+$1F7C 5115 ff7c 7e e1 13 .WARMST JMP MAIN warm start 5116 ff7f 7e e1 fd .BPCLR JMP BPCLR clear breakpoint table 5117 ff82 7e e2 3e .RPRINT JMP RPRINT display user registers 5118 ff85 7e e2 4c .HEXBIN JMP HEXBIN convert ascii hex char to binary 5119 ff88 7e e2 7f .BUFFAR JMP BUFFARG build hex argument from buffer 5120 ff8b 7e e2 a2 .TERMAR JMP TERMARG read hex argument from terminal 5121 ff8e 7e e2 ca .CHGBYT JMP CHGBYT modify memory at address in x 5122 ff91 7e e3 36 .READBU JMP READBUFF read character from buffer 5123 ff94 7e e3 3d .INCBUF JMP INCBUFF increment buffer pointer 5124 ff97 7e e3 43 .DECBUF JMP DECBUFF decrement buffer pointer 5125 ff9a 7e e3 4b .WSKIP JMP WSKIP find non-whitespace char in buffer 5126 ff9d 7e e3 6e .CHKABR JMP CHKABRT check for abort from terminal 5127 5128 ffa0 ORG ROMBS+$1FA0 5129 ffa0 7e e1 f2 .UPCASE JMP UPCASE convert to upper case 5130 ffa3 7e e3 5b .WCHEK JMP WCHEK check for white space 5131 ffa6 7e e3 66 .DCHEK JMP DCHEK check for delimeter 5132 ffa9 7e e3 ad .INIT JMP INIT initialize i/o device 5133 ffac 7e e3 b5 .INPUT JMP INPUT low level input routine 5134 ffaf 7e e3 e1 .OUTPUT JMP OUTPUT low level output routine 5135 ffb2 7e e4 f5 .OUTLHL JMP OUTLHLF display top 4 bits as hex digit 5136 ffb5 7e e4 f9 .OUTRHL JMP OUTRHLF display bottom 4 bits as hex digit 5137 ffb8 7e e5 03 .OUTA JMP OUTA output ascii character in A 5138 ffbb 7e e5 07 .OUT1BY JMP OUT1BYT display the hex value of byte at X 5139 ffbe 7e e5 16 .OUT1BS JMP OUT1BSP out1byt followed by space 5140 ffc1 7e e5 13 .OUT2BS JMP OUT2BSP display 2 hex bytes at x and a space 5141 ffc4 7e e5 1f .OUTCRL JMP OUTCRLF carriage return, line feed to terminal 5142 ffc7 7e e5 2f .OUTSTR JMP OUTSTRG display string at X (term with $04) 5143 ffca 7e e5 32 .OUTST0 JMP OUTSTRG0 outstrg with no initial carr ret 5144 ffcd 7e e5 5b .INCHAR JMP INCHAR wait for and input a char from term 5145 ffd0 7e e3 8c .VECINT JMP VECINIT initialize RAM vector table 5146 5147 ffd6 ORG ROMBS+$1FD6 5148 *** Vectors *** 5149 ffd6 00 c4 VSCI FDB JSCI 5150 ffd8 00 c7 VSPI FDB JSPI 5151 ffda 00 ca VPAIE FDB JPAIE 5152 ffdc 00 cd VPAO FDB JPAO 5153 ffde 00 d0 VTOF FDB JTOF 5154 ffe0 00 d3 VTOC5 FDB JTOC5 5155 ffe2 00 d6 VTOC4 FDB JTOC4 5156 ffe4 00 d9 VTOC3 FDB JTOC3 5157 ffe6 00 dc VTOC2 FDB JTOC2 5158 ffe8 00 df VTOC1 FDB JTOC1 5159 ffea 00 e2 VTIC3 FDB JTIC3 5160 ffec 00 e5 VTIC2 FDB JTIC2 5161 ffee 00 e8 VTIC1 FDB JTIC1 5162 fff0 00 eb VRTI FDB JRTI 5163 fff2 00 ee VIRQ FDB JIRQ 5164 fff4 00 f1 VXIRQ FDB JXIRQ 5165 fff6 00 f4 VSWI FDB JSWI 5166 fff8 00 f7 VILLOP FDB JILLOP 5167 fffa 00 fa VCOP FDB JCOP 5168 fffc 00 fd VCLM FDB JCLM 5169 fffe e0 00 VRST FDB BUFFALO 5170 5171 5172 Number of errors 0