home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / beehive / os / super8.arc / MON.S8 < prev    next >
Text File  |  1990-09-21  |  177KB  |  7,766 lines
  1. ;-------------------------------------------------------
  2. ; SUPER8 Monitor Firmware, for the S8 contest board
  3. ; This version altered for META assembler
  4. ;
  5. ;
  6. ;
  7. ;  init.s8:
  8. ;    (1) Entry point for monitor.
  9. ;    (2) Initialization routines for monitor.
  10. ;    (3) Interrupt routines for Serial Input.
  11. ;       (4) Console I/O routines
  12. ;
  13. ;
  14. ; 3/1/87  Start fixing things up
  15. ;
  16. ;    1) Clean up binary to ascii routines
  17. ;    2) Disable HOST_DELAY
  18. ;    3) CLean up breakpoint stuff
  19. ;    4) TRACE
  20. ;    5) Clean up op table
  21. ;
  22. ; Things that would be nice to do:
  23. ;
  24. ;    a) Shift some of the montor registers & stack to RAM
  25. ;    b) Preserve ALL user registers in monitor
  26. ;
  27. ;*****************************************************
  28. ;*
  29. ;*      Constants and register usage used by
  30. ;*      all or some of the software modules.
  31. ;*
  32. ;******************************************************;
  33. ; register allocation 
  34.  
  35. WORKREGS        equ    $80     ; working registers 
  36.  
  37. ALT_PC        equ    $90     ; used by TRACE
  38. TX_MODE         equ    $92     ; X_ON/X_OFF mode 
  39. USER_RP0        equ    $93     ; user RP0 
  40. USER_RP1        equ    $94     ; user RP1 
  41. USER_FLAGS      equ    $95     ; user flag reg 
  42. USER_PC         equ    $96     ; user PC
  43. USERPC_HI       equ    $96     ; user PC high 
  44. USERPC_LO       equ    $97     ; user PC low 
  45. REG_MODE        equ    $98     ; current reg disp. mode 
  46. ERR_CODE        equ    $99     ; error code 
  47. ECHO_MODE       equ    $9A     ; echo on/off mode 
  48. SIO_MODE        equ    $9B     ; mode register 
  49. CFLAG           equ    $9C     ; CFLAG register 
  50. OUTPTR          equ    $9D     ; offset in output buff. 
  51. OUTLEN          equ    $9E     ; length of output str.  
  52. INPTR           equ    $9F     ; offset in input buff. 
  53. PUTCHRPTR       equ    $A0     ; output offset 
  54. GETCHRPTR       equ    $A1     ; output offset 
  55. RETRY           equ    $A2     ; load record retries 
  56. USER_EI         equ    $A3     ; user EI status 
  57. REGBUF          equ    $A4     ; temp reg buffer 
  58.                    ; 4 registers long 
  59. OUT_CHR1        equ    $A8     ; char output reg 
  60. OUT_CHR2        equ    $A9     ; char output reg 
  61. D_MEMFLAG       equ    $AA     ; data/prog. memory 
  62. STX_ETX         equ    $AB     ; STX_ETX mode 
  63. HOSTGET         equ    $AC     ; host input offset 
  64. HOSTPUT         equ    $AD     ; host output offset 
  65. USER_IMR        equ    $AE     ;
  66.  
  67.     ; registers used by ZAP command 
  68. DIS_CT          equ    $AE     ; instructon count 
  69. BYTE_1          equ    $AF     ; 1st byte 
  70. BYTE_2          equ    $B0     ; 2nd byte 
  71. BYTE_3          equ    $B1     ; 3rd byte 
  72. BYTE_4          equ    $B2     ; 4th byte 
  73. AD_IN_HI        equ    $B3     ; instruction addr 
  74. AD_IN_LO        equ    $B4
  75. AD_OUT_HI       equ    $B5     ; output pointer 
  76. AD_OUT_LO       equ    $B6
  77. AD_TBL_HI       equ    $B7     ; table pointer 
  78. AD_TBL_LO       equ    $B8
  79. TYPE_           equ    $B9     ; instruction type 
  80. USER_SP        equ    $BA     ; two bytes
  81.  
  82. ; Monitor Ram locations 
  83. ;
  84. ;relocated interrupt vectors
  85. INTV0:        equ    $E000    ; interrupt vector 0
  86. INTV1:        equ    $E003    ; interrupt vector 1
  87. INTV2:        equ    $E006    ; interrupt vector 2
  88. INTV3:        equ    $E009    ; interrupt vector 3
  89. INTV4:        equ    $E00C   ; interrupt vector 4
  90. INTV5:        equ    $E00F   ; interrupt vector 5
  91. INTV6:        equ    $E012    ; interrupt vector 6
  92. INTV7:        equ    $E015    ; interrupt vector 7
  93. INTV8:        equ    $E018    ; interrupt vector 8
  94. INTV9:        equ    $E01B    ; interrupt vector 9
  95. INTV10:        equ    $E01E    ; interrupt vector 10
  96. INTV11:        equ    $E021    ; interrupt vector 11
  97. INTV12:        equ    $E024    ; interrupt vector 12
  98. INTV13:        equ    $E027    ; interrupt vector 13
  99. INTV14:        equ    $E02A    ; interrupt vector 14
  100. INTV15:        equ    $E02D    ; interrupt vector 15
  101. ;
  102. ;
  103. USER_STACK    equ    $FB00   ; one is required for GO to work
  104. INBUF           equ    $FB00   ; 256 byte Serial input buffer 
  105. HOSTBUF         equ    $FC00   ; 256 byte Host buffer 
  106. CONIBF          equ    $FD00   ; 256 byte console input buffer
  107. CONOBF          equ    $FE00   ; 256 byte console output buffer
  108. T_CODE        equ    $FF00   ; 7 bytes used by TRACE
  109.  
  110. BP1_SAVE        equ    $FFF0   ; 3 byte save for breakpointed inst.
  111. BP1_ADDR    equ    $FFF3   ; Addres of breakpted intruction.
  112. I_CODE          equ    $FFF5   ; I_CODE execute location (4 bytes max)
  113. ECHO_STAT       equ    $FFF6   ; 1 byte saved echo status 
  114. REG_READ        equ    $FFF7   ; 1 byte pass location for register reads
  115. WARMSTART       equ    $FFF8   ; 4 byte warm start pattern location 
  116.  
  117.  
  118. ; RAM CONSTANTS 
  119. BUF_LGTH        equ    $46     ; ZAP output buff. size
  120.  
  121. ; transmit mode 
  122. X_ON            equ    $01     ; X_ON mode 
  123. X_OFF           equ    $00     ; X_OFF mode 
  124.  
  125. ; register display mode flags 
  126. S_FLAG          equ    $01     ; systems registers 
  127. C_FLAG          equ    $02     ; control registers 
  128. GEN_FLAG        equ    $04     ; gen. purpose registers 
  129. ZERO_FLAG       equ    $08     ; bank zero flag 
  130. ONE_FLAG        equ    $10     ; bank one flag 
  131.  
  132. ; serial line mode 
  133. NORMAL_MODE     equ    $01     ; command mode 
  134. LOAD_MODE       equ    $02     ; load mode 
  135. EXT_MODE        equ    $80     ; load extension 
  136.                           ;   area 
  137.  
  138. ; echo mode 
  139. ECHO_ON         equ    $01     ; echo on 
  140. ECHO_OFF        equ    $00     ; echo off 
  141.  
  142.  
  143. ; CFLAG 
  144. LOAD_SEND       equ    $20     ; BIT 5 LOAD/SEND 
  145. GETMEMFLG       equ    $40     ; BIT 6 GETMEMFLG 
  146. LASTCMD         equ    $80     ; BIT 7 LASTCMD 
  147. CLSTCMD        equ    $7F    ; COMPLEMENT OF LASTCMD.  FIX OF ASSEMBLER BUG
  148. ; error codes 
  149. BAD_CMD         equ    $01     ; invalid command 
  150. MIS_PARAM       equ    $02     ; missing parameter 
  151. BAD_HEX         equ    $03     ; bad hex value 
  152. BAD_OPT         equ    $04     ; bad option 
  153. LOADABORT       equ    $05     ; load aborted by host 
  154. ABSEND          equ    $06     ; load aborted by EM 
  155. FILE_ERR        equ    $07     ; file error 
  156. BAD_PARAM_VAL   equ    $08     ; value out of range 
  157. BAD_EXT_ADDR    equ    $09     ; bad extension load addr
  158.  
  159.  
  160. ASCIICR         equ    $0D     ; ASCII char. vlaues 
  161. ASCIISP         equ    $20
  162. ASCIILF         equ    $0A
  163. ASCIIESC        equ    $1B
  164. ASCBKSP         equ    $08
  165. ASCIIQ          equ    $51
  166. ASCIIUP         equ    $5E
  167. ASCIIDOT        equ    $2E
  168. ASCIISTAR       equ    $2A
  169. ASCIIEQ         equ    $3D
  170. ASCIIDEL        equ    $7F
  171. ASCIITAB        equ    $09
  172. ASCIIDSH        equ    $2D
  173. ASCIICTLS       equ    $13
  174. ASCIICTLQ       equ    $11
  175. ASCIISTX        equ    $02
  176. ASCIIETX        equ    $03
  177.  
  178. ;-----------------------------------
  179. ; Some constants that control things
  180.  
  181. CHR_DELAY    equ    $25    ; character output delay variable 
  182.                 ;    use $0E for 12.0 MHz crystal
  183.                 ;    use $05 for 7.37 MHz crystal
  184. CRLF_DELAY    equ    $08    ; initialize CRLF output delay variable 
  185.                 ;    use $03 for 12.0 MHz crystal
  186.                 ;    use $02 for 7.37 MHz crystal
  187.  
  188.  
  189. SYS_EMT        equ    %00101011    ; INternal stack for monitor
  190. USR_EMT        equ    %00101011    ; external stack for user
  191. SYS_STACK    equ    $FFEF        ; sys. stack base
  192. ;----------------------------------------------------------------------
  193. ;
  194. ;      Interrupt vectors
  195. ;
  196.  
  197.  
  198.     ORG    $000
  199.  
  200.     dw INTV0        ;
  201.     dw INTV1        ;
  202.     dw INTV2        ;
  203.     dw INTV3        ;
  204.     dw INTV4        ;
  205.     dw INTV5        ;
  206.     dw INTV6        ;
  207.     dw INTV7        ;
  208.     dw INTV8        ;
  209.     dw INTV9        ;
  210.     dw INPUTINT        ; Serial input interrupt routine
  211.     dw INTV11        ;
  212.     dw INTV12        ;
  213.     dw INTV13        ;
  214.     dw INTV14        ;
  215.     dw INTV15        ;
  216.  
  217.  
  218.  
  219. INITS8:
  220. ;*********************************************************
  221. ;*
  222. ;*   INITS8  Initailize the monitor S8 processor and
  223. ;*        registers
  224. ;*
  225. ;**********************************************************;
  226. ;    org $0020
  227.  
  228.     EI                ; enable writes to IMR 
  229.     DI                ; disable interrupts 
  230.  
  231. ; initialize ports and control registers
  232.  
  233.     ld    IPR,#$18        ; Priority: B>A>C 
  234.     ld    IMR,#$00        ; IRQ6 (Serial input) polled mode 
  235.     ld    IRQ,#$00        ; clear IRQ6 
  236.  
  237. ; initialize ports
  238.  
  239.     ld    P2AM,#%10001010   ; Outputs: P31,P20,P21, INPUTS: P30
  240.     ld    P2BM,#%00000010   ;        : P22                : P33,P32,P23
  241.     ld    P2CM,#%00001000   ;        : P25                : P35,P34,P24
  242.     ld    P2DM,#%00000010   ;        : P26                : P37,P36,P27
  243.  
  244. ; Enable the address/data bus, 16 address lines & internal stack
  245.  
  246.     ld    PM,#%00110000   ; Port 1 AD0 - AD7
  247.     ld    P0M,#%11111111  ; Port 0  A8 - A15
  248.     ld    EMT,#SYS_EMT    ; Internal stack
  249.  
  250. ; internal stack during initialization, self test
  251.     ldw    SP,#SYS_STACK      ; Init stack to top 
  252.     SRP    #$C0        ; set reg. pointer  to temp value
  253.  
  254. ; Set baud rate to 9600 bps
  255.  
  256.     sb1
  257.     ld     UMA,#%01110000    ; X16 clock, 8 bit/char, no parity
  258.  
  259.     ldw    UBG,#7           ; set up for bit rate of 
  260.                      ;     9600, continuous mode
  261.                 ; For XTAL = 12.0 MHz use 0009
  262.                 ;     XTAL = 19.6 MHz use 0015
  263.     ld    UMB,#%00011110   ; P21 data, no clock out
  264.                 ; auto echo disabled, use BRG for
  265.                 ; TxC and RxC, Enable BRG
  266.     sb0                     ;
  267.     ld    UTC,#%10001000  ; P31 - TxD out, no break, 1 stop bit
  268.                 ; No wake-up, transmitter enabled
  269.     ld    URC,#%00000010  ; Enable the reciver
  270.     ld    UIE,#%00000000    ; disable all interrupts
  271.  
  272. ; Clear register file (registers $00 thru $BF)
  273.  
  274.     ld    R4,#$00        ; R4 points to $00 
  275.     ld    R5,#$BF        ; r5 has count 
  276. CLEAR_VAR:
  277.     CLR    @R4        ; clear it 
  278.     INC    R4        ; point to next register
  279.     DJNZ      R5,CLEAR_VAR    ; Loop till done
  280.  
  281.     ld    TX_MODE,#X_ON    ; initialize transmit mode 
  282.     ld    SIO_MODE,#NORMAL_MODE    ; set input mode 
  283.     ld    STX_ETX,#ECHO_ON    ; set STX_ETX  to echo 
  284.     ld    ECHO_MODE,#ECHO_ON    ; initialize echo mode on for terminal 
  285.     AND    CFLAG,#CLSTCMD        ; clear the go 
  286.  
  287. ;    initialize the interrupt table in ram
  288.  
  289.     call    INT_TAB_REL
  290.  
  291. ;    Wait for a <CR> from Host or terminal
  292.  
  293. WAIT:    TM    URC,#%00000001    ; Wait for recieved char
  294.     jr    z,WAIT        ; 1=char received
  295.     ld    r0,UIO        ; Get char
  296.     and    r0,#$7F        ; Mask off upper bit
  297.     cp    r0,#$0D        ; Is it a <CR> ?
  298.     jr    eq,WAIT1    ; if so, continue
  299.     cp    r0,#$0A        ; some systems transmit <LF>
  300.     jr    ne,WAIT        ; Keep waiting if not
  301.  
  302. ;    Clear the screen
  303. WAIT1:
  304.     call    SEND_STX
  305.     ld     R8,#$20        ; clear screen 
  306.  
  307. CLEAR_LOOP:            ; with 32 CRs 
  308.     call    CRLF
  309.     DJNZ   R8,CLEAR_LOOP
  310.     call    SEND_ETX
  311.  
  312. ; check for warm start 
  313.     call    IS_WARM            ; set C if warm start 
  314.     JR    C,WARM_START        ; yes 
  315.     call    COLD_START        ; no, cold start 
  316.  
  317. WARM_START:
  318.  
  319.     ldw    rr6,#^LB BP1_ADDR    ; Clear any breakpoint set
  320.     ld    r0,#$00
  321.     ldc    @rr6,r0
  322.     incw    rr6
  323.     ldc    @rr6,r0
  324.     ldw    USER_SP,#USER_STACK
  325.  
  326. READ_SIZE:
  327. ; initialize system, control registers for monitor 
  328.     SRP    #WORKREGS    ; set reg. pointer 
  329.     ld    FLAGS,#$00    ; clear flags 
  330.     ld    IPR,#$18    ; B>A>C 
  331.     ld    IMR,#$40    ; enable IRQ6 - Serial input
  332.     ld    IRQ,#$00    ; nothing pending 
  333.     ld    UIE,#%00000001    ; Enable RxChar INT
  334.  
  335. HDR_DISP:
  336.     EI            ; enable interrupts 
  337.  
  338. ;
  339. ;
  340. ;    Display sign-on header message.
  341. ;
  342. ;
  343.  
  344.  
  345. ; delay and let host catch up 
  346.     call    HOST_DELAY
  347.  
  348. ; if echoing, request "e -0" from host
  349.     CP    ECHO_MODE,#ECHO_OFF    ; echoing? 
  350.     JR    EQ,MAIN            ; no, skip request 
  351.     call     SEND_STX        ; leading STX 
  352.                     ; nothing in between 
  353.     call     SEND_ETX        ; trailing ETX 
  354.  
  355. ; delay and let host catch up 
  356.     call    HOST_DELAY
  357.     call    SEND_STX
  358.     call    CRLF
  359.     call    CRLF
  360.     call    CRLF
  361.     call    SEND_ETX
  362.  
  363. ; delay before output of header to host 
  364.     call    HOST_DELAY
  365.  
  366.     call    SEND_STX
  367.     LDW    RR6,#STRT_MSG    ; output header 
  368.     call    OUTMSG
  369.     LDW        RR6,#REV_MSG
  370.     call    OUTMSG
  371.     call    SEND_ETX
  372.     call    HOST_DELAY
  373.  
  374.     call    SEND_STX
  375.     LDW    RR6,#DATE_MSG
  376.     call    OUTMSG
  377.     call    SEND_ETX
  378.     call    HOST_DELAY
  379.  
  380.     ld    R8,#$06        ; center header 
  381.     call    SEND_STX
  382. CENTER_SCR:
  383.     call    CRLF
  384.     DJNZ   R8,CENTER_SCR
  385.     call    SEND_ETX
  386.  
  387. ; delay and let host catch up 
  388.     call    HOST_DELAY
  389.  
  390. ; if echoing, request "e -0" from host
  391.     CP       ECHO_MODE,#ECHO_OFF    ; echoing? 
  392.     JR       EQ,MAIN        ; no, skip request 
  393.     call     SEND_STX        ; leading STX 
  394.                 ; nothing in between 
  395.     call     SEND_ETX        ; trailing ETX 
  396.  
  397. ; delay and let host catch up 
  398.     call    HOST_DELAY
  399.  
  400. ;------------------------------------------------------------------------------
  401. ;    Main program loop
  402. ; Loop here for commands to execute
  403. ;
  404.  
  405. MAIN:
  406.  
  407.     AND        CFLAG,#CLSTCMD    ; clear the GO flag
  408.     call    CMD_STATUS        ; indicate cmd mode 
  409.     CLR        D_MEMFLAG        ; reset D_MEMFLAG 
  410.     call    SEND_STX        ; start msg 
  411.     ld         R4,#'S'        ; issue "S8>" 
  412.     call    OUTCHR
  413.     ld    R4,#'8'
  414.     call    OUTCHR
  415.     ld    R4,#'>'
  416.     call    OUTCHR
  417.     call    SEND_ETX        ; end msg 
  418.  
  419. GET_RESPONSE:
  420.     ld    STX_ETX,#ECHO_ON    ; enable echo 
  421.     call    GETLINE        ; get the response 
  422.  
  423. PROCESS_CMD:
  424.     CP    R4,#ASCIICR        ; a CR? 
  425.     JR    EQ,MAIN        ; yes, ignore 
  426.  
  427.     CLR    ERR_CODE
  428.     call    MATCH_CMD    ; match the command 
  429.     CP    ERR_CODE,#0        ; command error? 
  430.     JR    EQ,CHECK_ETX        ; no 
  431.     call    OUT_ERROR        ; yes, output message 
  432.  
  433. CHECK_ETX:
  434.     CP    STX_ETX,#ECHO_OFF    ; invisible last cmd? 
  435.     JR    NE,MAIN            ; no 
  436.     JR    GET_RESPONSE        ; yes, no new promt 
  437.     JR         MAIN            ; re-enter main 
  438.  
  439.  
  440. HOST_DELAY
  441. ;*********************************************************
  442. ;    Delay for Host Package to catch up
  443. ;
  444. ;    Deleted for CP/M
  445.  
  446. ;    ld       R5,#$20
  447. ;CATCH_UP:
  448. ;    ld     R4,#$ff
  449. ;    call   DELAY
  450. ;    DJNZ   R5, CATCH_UP
  451.     RET
  452.  
  453.  
  454. IS_WARM:
  455. ;***************************************************
  456. ;*
  457. ;*   IS_WARM Read warm start pattern location.
  458. ;*            If pattern is valid set carry flag.
  459. ;*            Otherwise reset carry flag.
  460. ;*
  461. ;***************************************************;
  462.  
  463.     LDW    RR6,#WARMSTART    ; point to warm start location
  464.  
  465. ; look for pattern 00 FF A5 5A 
  466.  
  467.     LDC    R4,@RR6        ; read 1st mem byte 
  468.     CP     R4,#0        ; 0 ? 
  469.     JR     NE,RESET_C        ; no, cold start 
  470.     INCW   RR6
  471.     LDC   R4,@RR6        ; read 2nd byte 
  472.     CP     R4,#$FF        ; $FF ? 
  473.     JR     NE,RESET_C        ; no, cold start 
  474.     INCW   RR6
  475.     LDC   R4,@RR6        ; read 3rd byte 
  476.     CP     R4,#$A5        ; $A5 ? 
  477.     JR     NE,RESET_C        ; no, cold start 
  478.     INCW   RR6
  479.     LDC   R4,@RR6        ; read 4th byte 
  480.     CP     R4,#$5A        ; $5A ? 
  481.     JR     NE,RESET_C        ; no, cold start 
  482.     SCF            ; pattern matches 
  483.     RET
  484.  
  485. RESET_C:
  486.     RCF                ; no match 
  487.     RET
  488.  
  489.  
  490.  
  491. COLD_START:
  492. ;***************************************************
  493. ;*
  494. ;*   COLD_START Read warm start pattern location.
  495. ;*               If pattern is valid set carry flag.
  496. ;*               Otherwise reset carry flag.
  497. ;*
  498. ;***************************************************;
  499.  
  500.     ld    R5,#$04
  501. VERIFY_DELAY:
  502.     ld    R4,#$FF
  503.     call    DELAY
  504.     DJNZ    R5,VERIFY_DELAY
  505.  
  506.     call    VERIFY        ; self test 
  507.  
  508.     ; write out warm start pattern to memory 
  509.     LDW    RR6,#WARMSTART    ; point to warm start location
  510.  
  511.     ; write pattern 00 FF A5 5A 
  512.     ld    R4,#0        ; 0 
  513.     LDC    @RR6,R4        ; write 1st mem byte 
  514.     INCW    RR6
  515.     ld    R4,#$FF        ; $FF 
  516.     LDC        @RR6,R4        ; write 2nd byte 
  517.     INCW       RR6
  518.     ld    R4,#$A5        ; $A5 
  519.     LDC        @RR6,R4        ; write 3rd byte 
  520.     INCW       RR6
  521.     ld    R4,#$5A        ; $5A 
  522.     LDC        @RR6,R4        ; write 4th byte 
  523.  
  524.     ld    ECHO_MODE,#ECHO_ON    ; initialize echo mode on for terminal 
  525.     LDW    RR6,#ECHO_STAT    ; and save in monitor RAM for warm reset read 
  526.     ld    R4,#ECHO_OFF
  527.     LDC    @RR6,R4
  528.     RET
  529.  
  530.  
  531. MATCH_CMD:
  532. ;********************************************************
  533. ;*
  534. ;*   MATCH_COMMAND  call the appropriate routine given the
  535. ;*               first letter in the command.
  536. ;*
  537. ;*    input:    R4 has the first letter of the command.
  538. ;*
  539. ;********************************************************;
  540.  
  541.     OR    R4,#$20        ; force to low case 
  542.     CP    R4,#'x'        ; an 'x' command? 
  543.     JR    NE,GO_ON    ; no 
  544.     ld    D_MEMFLAG,#$FF    ; yes, set flag for 
  545.                 ;   extern. data mem 
  546.     ld     R7,INPTR        ; RR6 points to input 
  547.     ld     R6,#^HB CONIBF    ;   buffer
  548.  
  549. GO_BACK:
  550.     INC    R7            ; look at next char. 
  551.     LDC    R4,@RR6        ;   in CONIBUF
  552.     CP     R4,#ASCIICR    ; is it a CR? 
  553.     jp     EQ,OUT_MATCH_CMD    ; yes, no command 
  554.     CP     R4,#ASCIISP    ; no, is it a space? 
  555.     JR     EQ,GO_BACK    ; yes, ignore spaces 
  556.     OR     R4,#$20        ; no, force low case 
  557.     CP     R4,#'x'        ; multiple 'x's ? 
  558.     JR     EQ,GO_BACK     ; yes, ignore them 
  559.     ld     INPTR,R7        ; no, RR6 points to 
  560.                 ;   command letter  
  561.     ; match the command 
  562. GO_ON:
  563.     CP    R4,#'b'
  564.     jp    EQ,BREAK        ; set a breakpoint 
  565.     CP    R4,#'c'
  566.     jp    EQ,COMPARE        ; compare memory 
  567.     CP    R4,#'d'
  568.     jp    EQ,MEMORY        ; display/alter mem 
  569.     CP    R4,#'e'
  570.     jp    EQ,EXTENSION        ; echo off/on 
  571.     CP    R4,#'f'
  572.     jp    EQ,FILL            ; fill memory 
  573.     CP    R4,#'g'
  574.     jp    EQ,GO            ; start user execution 
  575.     CP    R4,#'i'
  576.     jp    EQ,INTERRUPT_ENABLE    ; user interrupts 
  577.     CP    R4,#'j'
  578.     jp    EQ,PC_SET        ; change user pc 
  579.     CP    R4,#'k'
  580.     jp    EQ,KILL            ; kill a breakpoint 
  581.     CP    R4,#'l'
  582.     jp    EQ,LOAD             ; load a file 
  583.     CP    R4,#'m'
  584.     jp    EQ,MOVE            ; move a memory block 
  585.     CP    R4,#'p'
  586.     jp    EQ,PHIL_REGISTERS    ; fill registers 
  587.     CP    R4,#'q'
  588.     jp    EQ,QUIT            ; quit host 
  589.     CP    R4,#'r'
  590.     jp    EQ,REGISTERS        ; register display/write 
  591.     CP    R4,#'s'
  592.     jp    EQ,SET            ; set memory 
  593.     CP    R4,#'t'
  594.     jp    EQ,TRACE        ; set memory 
  595.     CP    R4,#'u'
  596.     jp    EQ,UPLOAD         ; upload a file 
  597.     CP    R4,#'v'
  598.     jp    EQ,VERIFY        ; self test 
  599.     CP    R4,#'w'
  600.     jp    EQ,WORKING_REGS    ; working registers 
  601.     CP    R4,#'z'
  602.     jp    EQ,ZAP            ; disassembler 
  603.  
  604.     ld    ERR_CODE,#BAD_CMD    ; invalid command 
  605.  
  606. OUT_MATCH_CMD:
  607.     RET
  608.  
  609.  
  610.  
  611. ZAP:
  612. ;************************************************************
  613. ;*
  614. ;*   ZAP Prepare for and call disassembler.
  615. ;*
  616. ;************************************************************;
  617.  
  618.     call   GETADDR        ; get address parameter 
  619.     JR     C,ERR3        ; an error? yes 
  620.     ld     AD_IN_HI,R10        ; no, load hi address 
  621.     ld     AD_IN_LO,R11        ; load low address 
  622.     call   GETADDR        ; count supplied? 
  623.     JR     C,NO_NUM1        ; no 
  624.     ld       DIS_CT,R11        ; yes, load it 
  625.     JR       DIS_LOOP        ;   and go on 
  626.  
  627. ;**************************************************
  628. ;*  NO_NUM is called by routines that need a      *
  629. ;*  single line disassembled after a halt,        *
  630. ;*  breakpoint, or single step.                   *
  631. ;**************************************************;
  632. NO_NUM:
  633.  
  634.     ld    AD_IN_HI,USERPC_HI    ; load saved breakpoint 
  635.     ld    AD_IN_LO,USERPC_LO    ;   address 
  636.  
  637. NO_NUM1:
  638.     ld     DIS_CT,#$01      ; disassemble one inst. 
  639.     CLR    ERR_CODE        ; clear error flag 
  640.  
  641. DIS_LOOP:
  642.     ld     AD_OUT_HI,#^HB HOSTBUF ; address of output 
  643.     ld     AD_OUT_LO,#^LB HOSTBUF ;   buffer for inst. 
  644.                  ;   mnemonics. 
  645.     call   DIS_ASM        ; disassemble 
  646.     ld     R6,#^HB HOSTBUF     ; print output buffer 
  647.     ld     R7,#^LB HOSTBUF
  648.     call   OUTMSG
  649.  
  650.     DEC    DIS_CT        ; repeat "DIS_CT" times 
  651.     JR     NZ,DIS_LOOP
  652.  
  653. ERR3:
  654.     RET
  655.  
  656.  
  657. INPUTINT:
  658. ;************************************************
  659. ;*
  660. ;*    INPUTINT Serial Input Interrupt handler.
  661. ;*
  662. ;***********************************************;
  663.     PUSH    R15        ; transparent 
  664.     PUSH    R6        ; don't interfere 
  665.     PUSH    R7        ; 
  666.  
  667.     ld    R15,UIO        ; get the input 
  668.     AND    R15,#$7F    ; mask off high bit 
  669.  
  670. ; convert LINE FEED into CARRIAGE RETURN 
  671.     CP    R15,#$0A
  672.     JR    NE,CHECK_ESC
  673.     ld    R15,#ASCIICR
  674.     JR    CHECK_MODE
  675.  
  676. CHECK_ESC:
  677. ; ESC character means halt emulation, or reset monitor 
  678.     CP    R15,#ASCIIESC    ; ESC char? 
  679.     JR    NE,CHECK_CTLS
  680.  
  681.     ld    R4,#$FF
  682.     call    DELAY
  683.     TM    CFLAG,#LASTCMD    ; are we executing? 
  684.     JR    Z,RESET_MONITOR    ; no, reset the monitor 
  685.     ld    TX_MODE,#X_ON   ; transmit on 
  686.     jp    WARM_START    ; Go do a warm start
  687.  
  688. ;    We are not executing (GO mode) so return to monitor
  689.  
  690. RESET_MONITOR:
  691.     AND    CFLAG,#CLSTCMD    ; clear the go 
  692.     ldw    SP,#SYS_STACK    ; point back on stack 
  693.     ld      SIO_MODE,#NORMAL_MODE ; set mode 
  694.     ld    TX_MODE,#X_ON   ; transmit on 
  695.  
  696. ; terminate previous output 
  697.     ld    R4,#ASCIICR
  698.     call    OUTCHR
  699.  
  700. ; delay for CRLF output 
  701.     ld    R4,#$20
  702.     call    DELAY
  703.     call    CRLF
  704.     ld    R4,#$20
  705.     call    DELAY
  706.  
  707.         ld     FLAGS,#$00    ; clear flags 
  708.         ld     IPR,#$18        ;  
  709.         ld    IMR,#$40    ; enable SIO IRQ
  710.         ld     IRQ,#$00        ; nothing pending 
  711.     EI            ; enable interrupts 
  712.     jp    MAIN        ; in monitor mode 
  713.  
  714. ; check for CTLQ/CTLS 
  715. CHECK_CTLS:
  716.     CP    R15,#ASCIICTLS    ; CTLS ? 
  717.     JR    NE,CHECK_CTLQ    ; no 
  718.     ld    TX_MODE,#X_OFF
  719.     JR    XECUTE_ON
  720.  
  721. CHECK_CTLQ:
  722.     CP    R15,#ASCIICTLQ    ; CTLQ ? 
  723.     JR    NE,CHECK_MODE    ; no 
  724.     ld    TX_MODE,#X_ON
  725.     JR    XECUTE_ON
  726.  
  727. CHECK_MODE:
  728.     CP    SIO_MODE,#NORMAL_MODE    ; which buffer? 
  729.     JR    NE,HOSTINPUT
  730.     TM    CFLAG,#LASTCMD        ; if 'go',can't use the 
  731.     JR    Z,INTO_RAM        ; (jump if not in GO mode) data bus
  732.                     ;   hence can't store 
  733.     CP    R15,#ASCIIESC        ; ESC char is a halt 
  734. ;    JR    NE,PASS_TO_USER        ; not ESC char, pass interrupt to user
  735.     JR    NE,XECUTE_ON        ; if not ESC just ignore it & IRET 
  736.     jp    WARM_START        ; Was ESC, so restart monitor
  737.  
  738. INTO_RAM:
  739.     ld    R6,#^HB INBUF        ; keyboard input 
  740.     ld    R7,GETCHRPTR        ;  
  741.     INC    GETCHRPTR        ; move pointer 
  742.     JR    DATA_IN            ; 
  743.  
  744. HOSTINPUT:
  745.     ld    R6,#^HB HOSTBUF        ; put into buffer for host 
  746.     ld    R7,HOSTGET        ; 
  747.     INC    HOSTGET            ; update pointer 
  748.  
  749. DATA_IN:
  750.     LDC    @RR6,R15        ; put in I/O buffer 
  751.  
  752. XECUTE_ON:
  753.     POP    R7            ; restore 
  754.     POP    R6            ; 
  755.     POP    R15            ; 
  756.     IRET                ; 
  757.  
  758. PASS_TO_USER:
  759.     POP    R7            ; restore registers before...
  760.     POP    R6
  761.     POP    R15
  762.     jp    INTV10            ; pass ram interrupt vector
  763.  
  764.  
  765.  
  766. OUT_ERROR:
  767. ;*************************************************************
  768. ;*
  769. ;*   OUT_ERROR Output error code and error message
  770. ;*
  771. ;*    input:    ERR_CODE has the error code.
  772. ;*
  773. ;*************************************************************;
  774.     PUSH    R5        ; save registers 
  775.     PUSH    R8
  776.     PUSH    R9
  777.  
  778.     CP    ERR_CODE,#8    ; bad error code? 
  779.     JR    LE,FIND_MSG    ; no 
  780.     ld      ERR_CODE,#0    ; yes 
  781.  
  782. FIND_MSG:
  783.     ld    R5,ERR_CODE    ; save error code 
  784.     ld    R8,#^HB ERR_MSG_LIST
  785.     ld    R9,#^LB ERR_MSG_LIST
  786.  
  787. LOOP_MSG:
  788.     CP    R5,#0        ; at the right address? 
  789.     JR    EQ,AT_BEGIN    ; yes 
  790.     INCW    RR8        ; no, point to next 
  791.     INCW    RR8
  792.     DEC    R5
  793.     JR    LOOP_MSG
  794.  
  795. AT_BEGIN:
  796.     ; RR8 now points to the address of the error message 
  797.     LDC    R6,@RR8        ; load low byte of address 
  798.     INCW    RR8
  799.     LDC    R7,@RR8        ; load hi byte of address 
  800.     call    OUTMSG        ; write the error message 
  801.  
  802.     POP    R9        ; restore registers 
  803.     POP    R8
  804.     POP    R5        ; save registers 
  805.  
  806.     RET
  807.  
  808.  
  809. BTOHEXADDR 
  810. ;***********************************************
  811. ;*
  812. ;*    BTOHEXADDR  Convert an address to hex
  813. ;*
  814. ;*    input:    Registers R10-R11 hold address
  815. ;*          to be converted.
  816. ;*
  817. ;*    output:    R6 points to next location in REGBUF
  818. ;*          after last digit of address.
  819. ;*        Converted address is returned in REGBUF.
  820. ;*
  821. ;***********************************************;
  822.  
  823.     ld    R4,R10        ; convert hi byte 
  824.     call    BTOHEXDAT    ; 
  825.     ld    R4,R11        ; convert lo byte 
  826.                 ; fall through 
  827.  
  828.  
  829.  
  830. BTOHEXDAT 
  831. ;***********************************************
  832. ;*
  833. ;*    BTOHEXDAT  Convert a byte to hex
  834. ;*
  835. ;*    input:    R4 contains byte to be converted.
  836. ;*        R6 points to location convert
  837. ;*          byte will go.
  838. ;*
  839. ;*    output:    R6 is incremented twice
  840. ;*
  841. ;***********************************************;
  842.  
  843.     PUSH    R4        ; save 
  844.     SWAP    R4        ; do up nibble 
  845.     call    NIBBLE        ; 
  846.     POP    R4        ; fall through 
  847.     call    NIBBLE
  848.     RET
  849.  
  850.  
  851.  
  852.  
  853. NIBBLE 
  854. ;***********************************************
  855. ;*
  856. ;*    NIBBLE  Convert a nibble to hex
  857. ;*
  858. ;*    input:    R4 has nibble to be converted
  859. ;*          in the lower nibble.
  860. ;*               R6 points to where convert goes.
  861. ;*
  862. ;*    output:    R6 is incremented once.
  863. ;*
  864. ;***********************************************;
  865.  
  866.     and    R4,#$0F        ; isolate nibble 
  867.     add    r4,#$90
  868.     da    r4
  869.     adc    r4,#$40
  870.     da    r4
  871.     ld    @R6,R4        ; put into buffer 
  872.     inc    R6        ; point to next register 
  873.     ret            ; 
  874.  
  875.  
  876. OUTSTR 
  877. ;*******************************************************
  878. ;*
  879. ;*    OUTSTR    Write a string out to the screen
  880. ;*
  881. ;*    input:    RR6 points to string to be output to
  882. ;*          to the screen.  The string is terminated
  883. ;*          with a <CR>.
  884. ;*
  885. ;*    output:    Each character is output to the screen.
  886. ;*
  887. ;*******************************************************;
  888.  
  889. NEXT_CHR:
  890.     LDC    R4,@RR6        ; get contents 
  891.     CP    R4,#ASCIICR    ; stop if <CR> data 
  892.     JR    EQ,DONE_STR    ; 
  893.     call    OUTCHR        ; write the char @RR6 
  894.     INCW    RR6        ; increment pointer 
  895.     JR    NEXT_CHR    ; but continue til then 
  896.  
  897. DONE_STR:
  898.     RET
  899.  
  900.  
  901.  
  902. OUTMSG 
  903. ;*******************************************************
  904. ;*
  905. ;*    OUTMSG    Write a string out to the screen
  906. ;*        followed by <LF> <CR>.
  907. ;*
  908. ;*    input:    RR6 points to string to be output to
  909. ;*          to the screen.  The string is terminated
  910. ;*          with a <CR>.
  911. ;*
  912. ;*    output:    Each character is output to the screen.
  913. ;*        Send a <CR> <LF> at the end of the string.
  914. ;*
  915. ;*******************************************************;
  916.  
  917.     call    OUTSTR        ; write string RR6 
  918.     call    CRLF        ; move cursor to next line 
  919.     RET
  920.  
  921.  
  922.  
  923. OTMSG 
  924. ;********************************************************
  925. ;*
  926. ;*    OTMSG  Write a string in CONOBF out to the screen.
  927. ;*
  928. ;*    input:    R6 is hi byte of buffer, string at beginning
  929. ;*          of the buffer.
  930. ;*        OUTLEN is length of string.
  931. ;*
  932. ;*    output:    Each character in the string is output to
  933. ;*          the screen.
  934. ;*
  935. ;*    R4,R5,R6,R7 destroyed
  936. ;*
  937. ;********************************************************;
  938.  
  939.     CLR    R7        ; string at begin of CONOBF 
  940.     ld    R5,OUTLEN    ; 
  941. OUTR5:
  942.     LDC    R4,@RR6        ; get into R4 for output 
  943.     call    OUTCHR        ; 
  944.     INC    R7        ; move pointer 
  945.     DJNZ    R5,OUTR5    ; until length 
  946.     RET            ; 
  947.  
  948.  
  949.  
  950. CRLF 
  951. ;*******************************************************
  952. ;*
  953. ;*    CRLF  Output a <LF> <CR>
  954. ;*
  955. ;*    input:    none
  956. ;*
  957. ;*    output:    output a <LF><CR> to the screen
  958. ;*
  959. ;*******************************************************;
  960.  
  961.     ld    R4,#ASCIILF
  962.     call    OUTCHR
  963.     ld    R4,#ASCIICR
  964.     call    OUTCHR
  965.     RET
  966.  
  967.  
  968. BACKSPACE 
  969. ;*******************************************************
  970. ;*
  971. ;*    BACKSPACE  Process a backspace character
  972. ;*
  973. ;*    input:    none
  974. ;*
  975. ;*    output: Write a <BKSP> <SP> <BKSP> to terminal
  976. ;*
  977. ;********************************************************;
  978.  
  979.     call    OUTCHR        ; output the backspace 
  980.     ld    R4,#ASCIISP    ; space 
  981.     call    OUTCHR        ; 
  982.     ld    R4,#ASCBKSP    ; backspace 
  983.     call    OUTCHR        ; 
  984.     RET            ; 
  985.  
  986.  
  987.  
  988. GETLINE 
  989. ;*******************************************************
  990. ;*
  991. ;*    GETLINE      Fill CONIBF with string in INBUF
  992. ;*
  993. ;*    input:    none
  994. ;*
  995. ;*    output    Place string terminated by <CR> in INBUF
  996. ;*          into CONIBF.
  997. ;*        R4 holds the first letter in the string.
  998. ;*        INPTR is offset to first char in CONIBF.
  999. ;*
  1000. ;*******************************************************;
  1001.     CLR    R7        ; using R7 as ptr 
  1002.     ld    R6,#^HB CONIBF    ; 
  1003.  
  1004. INLOOP:    call    GETCHR        ; get from INBUF to CONIBF 
  1005.     CP    R4,#ASCIICR    ; <CR> stops input 
  1006.     JR    NE,INLOOP    ; end of input 
  1007.  
  1008.     CLR    R7        ; get pointer 
  1009.     ld    R6,#^HB CONIBF    ; 
  1010. FIRSTCHR:
  1011.     LDC    R4,@RR6        ; get first character 
  1012.     CP    R4,#ASCIISP    ; ignore spaces 
  1013.     JR    NE,GOTFIRST    ; 
  1014.     INC    R7        ; increment pointer 
  1015.     JR    FIRSTCHR    ; wait for nonspace 
  1016.  
  1017. GOTFIRST:
  1018.     ld    INPTR,R7    ; 
  1019.     RET            ; back with command string 
  1020.  
  1021.  
  1022.  
  1023. OUTADDR 
  1024. ;*******************************************************
  1025. ;*
  1026. ;*    OUTADDR  Convert an address to hex and display it.
  1027. ;*
  1028. ;*    input:    R10-R11 hold address to be converted
  1029. ;*          and displayed.
  1030. ;*
  1031. ;*    output:    Hex address is displayed on the screen.
  1032. ;*
  1033. ;*******************************************************;
  1034.  
  1035.     ld    R6,#REGBUF    ; converted output into REGBUF 
  1036.     call    BTOHEXADDR    ; convert 
  1037.     ld    R5,#$04        ; display four bytes 
  1038. DISPLAY:
  1039.     ld    R6,#REGBUF    ; start at beginning 
  1040. DISP_NUM:
  1041.     ld    R4,@R6        ; get character for output 
  1042.     call    OUTCHR        ; 
  1043.     INC    R6        ; point to next character 
  1044.     DJNZ    R5,DISP_NUM    ; display 
  1045.  
  1046.     ld    R4,#ASCIISP    ; follow with a space 
  1047.     call    OUTCHR        ; 
  1048.     RET            ; 
  1049.  
  1050.  
  1051.  
  1052. OUTDAT 
  1053. ;******************************************************
  1054. ;*
  1055. ;*    OUTDAT  Convert a byte to hex and display it.
  1056. ;*
  1057. ;*    input:    R4 has data to convert.
  1058. ;*
  1059. ;*    output: Write a hex byte value to the screen
  1060. ;*        followed by a space.
  1061. ;*
  1062. ;******************************************************;
  1063.  
  1064.     call    OUTHEX        ; Print hex byte
  1065.     ld    R4,#ASCIISP    ; follow with a space 
  1066.     call    OUTCHR        ; 
  1067.     RET            ; 
  1068.  
  1069.  
  1070. OUTHEX 
  1071. ;******************************************************
  1072. ;*
  1073. ;*    OUTHEX  Convert a byte to hex and display it.
  1074. ;*
  1075. ;*    input:    R4 has data to convert.
  1076. ;*
  1077. ;*    output: Write a hex byte value to the screen
  1078. ;*
  1079. ;******************************************************;
  1080.  
  1081.     ld    R6,#REGBUF    ; register buffer 
  1082.     call    BTOHEXDAT    ; convert 
  1083.  
  1084.     ld    R5,#$02        ; two characters 
  1085.     ld    R6,#REGBUF    ; start at beginning 
  1086. DISP_NIB:
  1087.     ld    R4,@R6        ; get character for output 
  1088.     call    OUTCHR        ; 
  1089.     INC    R6        ; point to next character 
  1090.     DJNZ    R5,DISP_NIB    ; display 
  1091.     RET            ; 
  1092.  
  1093.  
  1094.  
  1095. OUTCHR 
  1096. ;*****************************************************
  1097. ;*
  1098. ;*    OUTCHR  Output a character to the screen
  1099. ;*
  1100. ;*    input:    R4 contains the character to be
  1101. ;*          written.
  1102. ;*
  1103. ;*    output:    The character in R4 is written to the
  1104. ;*          screen.
  1105. ;*
  1106. ;*****************************************************;
  1107.     ; delay on output if not echoing 
  1108.     CP    ECHO_MODE,#ECHO_ON
  1109.     JR    NE,OUTPUT_DEL
  1110.  
  1111.     JR    CHECK_TX
  1112.  
  1113. OUTPUT_DEL:
  1114.     ; delay 
  1115.     PUSH    R4        ; save R4 
  1116.     ld    R4,#CHR_DELAY
  1117.     call    DELAY
  1118.     POP    R4        ; restore R4 
  1119.  
  1120.     ; check for X_OFF 
  1121. CHECK_TX:
  1122.     CP    TX_MODE,#X_OFF
  1123.     JR    EQ,CHECK_TX
  1124.  
  1125.     ld    UIO,R4        ; 
  1126. TEST_OUT:
  1127.     TM    UTC,#$02    ; wait for output finished 
  1128.     JR    Z,TEST_OUT    ; 
  1129.     RET            ; 
  1130.  
  1131.  
  1132. GETCHR 
  1133. ;***************************************************
  1134. ;*
  1135. ;*    GETCHR  Get a character from INBUF and place
  1136. ;*          in CONIBF.
  1137. ;*
  1138. ;*    input:    none
  1139. ;*
  1140. ;*    output:    Process backspace and line delete. 
  1141. ;*          Other characters are put into CONIBF
  1142. ;*          for parsing.
  1143. ;*
  1144. ;***************************************************;
  1145.     call    GETDAT        ; 
  1146.  
  1147.     CP    R4,#ASCIIDEL    ; is it a line delete? 
  1148.     JR    NE,NOT_DEL    ; 
  1149.     CP    R7,#$00        ; not at beginning 
  1150.     JR    EQ,END_GETCHR    ; 
  1151.  
  1152.     ld    R4,#ASCBKSP    ; R7 backspaces 
  1153. LINE_BACK:
  1154.     call    BACKSPACE    ; back to begining 
  1155.     DJNZ    R7,LINE_BACK    ; 
  1156.     JR    END_GETCHR    ; new input 
  1157. NOT_DEL:
  1158.     CP    R4,#ASCIISP    ; is it printable? 
  1159.     JR    C,NOT_PRINTING    ; 
  1160. ECHO:
  1161.     CP    R7,#$FF        ; end of buffer 
  1162.     JR    NE,BUFOK    ; 
  1163.     ld    R4,#ASCIICR    ; insert carriage return 
  1164.  
  1165. BUFOK:
  1166.     CP    ECHO_MODE,#ECHO_ON  ; are we echoing ? 
  1167.     JR    NE,FILL_BUF    ; no, no echo 
  1168.  
  1169.     CP    STX_ETX,#ECHO_ON  ; echo enabled? 
  1170.     JR    NE,FILL_BUF    ; no, no echo 
  1171.  
  1172.     call    OUTCHR        ; yes, echo 
  1173.  
  1174. FILL_BUF:
  1175.     LDC    @RR6,R4        ; put into CONIBF 
  1176.     INC    R7        ; move pointer 
  1177.     JR    END_GETCHR    ; return 
  1178.  
  1179. NOT_PRINTING:
  1180.     CP    R4,#ASCIISTX    ; STX? 
  1181.     JR    NE,CHECK_TAB    ; no 
  1182.     ld    STX_ETX,#ECHO_OFF ; yes 
  1183.     JR    END_GETCHR
  1184.  
  1185. CHECK_TAB:
  1186.     CP    R4,#ASCIITAB    ; change tab to space 
  1187.     JR    NE,NOT_TAB    ; 
  1188.     ld    R4,#ASCIISP    ; 
  1189.     JR    ECHO        ; 
  1190.  
  1191. NOT_TAB:
  1192.     CP    R4,#ASCBKSP    ; process backspace 
  1193.     JR    NE,NOT_BKSP    ; not a backspace 
  1194.     CP    R7,#$00        ; forget backspace at begin 
  1195.     JR    EQ,END_GETCHR    ; 
  1196.  
  1197.     call    BACKSPACE    ; do the backspace 
  1198.     DEC    R7        ; backup pointer 
  1199.     JR    END_GETCHR    ; 
  1200.  
  1201. NOT_BKSP:
  1202.     CP    R4,#ASCIICR    ; preface CR with LF 
  1203.     JR    NE,END_GETCHR    ; 
  1204.  
  1205.     CP    ECHO_MODE,#ECHO_OFF ; are we echoing? 
  1206.     JR    EQ,FILL_BUF    ; no 
  1207.  
  1208.     CP    STX_ETX,#ECHO_OFF ; echo enabled? 
  1209.     JR    EQ,FILL_BUF    ; no 
  1210.  
  1211.     call    CRLF        ; 
  1212.     JR    ECHO        ; echo and put in CONIBF 
  1213. END_GETCHR:
  1214.     RET            ; 
  1215.  
  1216.  
  1217. GETDAT 
  1218. ;****************************************************
  1219. ;*
  1220. ;*    GETDAT  Get a byte from INBUF
  1221. ;*
  1222. ;*    input:    none
  1223. ;*
  1224. ;*    output:    First byte in INBUF is placed in R4
  1225. ;*
  1226. ;****************************************************;
  1227.     PUSH    R6            ; save 
  1228.     PUSH    R7            ; save 
  1229.     ld    R6,#^HB INBUF        ; get pointer 
  1230.     ld    R7,PUTCHRPTR        ; 
  1231.  
  1232. GETDAT1:
  1233.     CP    GETCHRPTR,PUTCHRPTR    ; wait for character 
  1234.     JR    EQ,GETDAT1        ; 
  1235.  
  1236.     LDC    R4,@RR6            ; get it from output 
  1237.     INC    PUTCHRPTR        ; increment ptr 
  1238.     POP    R7            ; 
  1239.     POP    R6            ; restore 
  1240.     RET                ; end of input 
  1241.  
  1242.  
  1243.  
  1244. FINDNEXT 
  1245. ;*******************************************************
  1246. ;*
  1247. ;*    FINDNEXT
  1248. ;*
  1249. ;*    input:    INPTR is offset for current character in
  1250. ;*          CONIBF.
  1251. ;*
  1252. ;*    output:    INPTR is offset again to the first  character
  1253. ;*        of next token in CONIBF. on input line
  1254. ;*        R4 contains that first character.
  1255. ;*        Returns a zero if char is <CR>
  1256. ;*
  1257. ;*******************************************************;
  1258.  
  1259.     ld    R6,#^HB CONIBF    ; get pointer 
  1260.     ld    R7,INPTR    ; into input buffer 
  1261. FINDNEXT1:
  1262.     LDC    R4,@RR6        ; wait for a space 
  1263.     INC    R7        ; point ahead 
  1264.     CP    R4,#ASCIICR    ; if a CR no param 
  1265.     JR    EQ,NO_PARAM    ; no parameter 
  1266.     CP    R4,#ASCIISP    ; 
  1267.     JR    NE,FINDNEXT1    ; 
  1268.  
  1269. SKPSPCE:
  1270.     LDC    R4,@RR6        ; wait for nonspace 
  1271.     INC    R7        ; 
  1272.     CP    R4,#ASCIISP    ; 
  1273.     JR    EQ,SKPSPCE    ; 
  1274.  
  1275.     DEC    R7        ; point to first character 
  1276.     CP    R4,#ASCIICR    ; end of line if <CR> 
  1277.  
  1278. NO_PARAM:
  1279.     ld    INPTR,R7    ; update pointer 
  1280.     RET            ; 
  1281.  
  1282.  
  1283.  
  1284. FINDOPT 
  1285. ;*******************************************************
  1286. ;*
  1287. ;*    FINDOPT
  1288. ;*
  1289. ;*    input:    INPTR is offset for current character in
  1290. ;*          CONIBF.
  1291. ;*
  1292. ;*    output:    Locate next token in input line.  Clear R10
  1293. ;*        if token does not begin with "-".  Place
  1294. ;*        first character of token in R10.  Place
  1295. ;*        second character of token in R11.  If token
  1296. ;*        begins with "-", remove it from input buffer
  1297. ;*        by replacing with spaces.
  1298. ;*
  1299. ;*******************************************************;
  1300.     CLR    R10        ; clear output reg. 
  1301.     CLR    R11
  1302.  
  1303.     ld    R6,#^HB CONIBF    ; get pointer 
  1304.     ld    R7,INPTR    ; into input buffer 
  1305.  
  1306. FINDOPT1:
  1307.     LDC    R4,@RR6        ; wait for a space 
  1308.     INC    R7        ; point ahead 
  1309.     CP    R4,#ASCIICR    ; if a CR no param 
  1310.     JR    EQ,END_FIND    ; no parameter 
  1311.     CP    R4,#ASCIISP    ; 
  1312.     JR    NE,FINDOPT1    ; 
  1313.  
  1314. SKIPSP:
  1315.     LDC    R4,@RR6        ; wait for nonspace 
  1316.     INC    R7        ; 
  1317.     CP    R4,#ASCIISP    ; 
  1318.     JR    EQ,SKIPSP    ; 
  1319.  
  1320.     CP    R4,#ASCIIDSH    ; is 1st char a "-" ? 
  1321.     JR    NE,END_FIND
  1322.  
  1323.     LDC    R10,@RR6    ; load 1st char of token 
  1324.     INC    R7
  1325.     LDC    R11,@RR6    ; load 2nd char of token 
  1326.     DEC    R7        ; point back to "-" 
  1327.     DEC    R7
  1328.  
  1329. CLR_TOKEN:
  1330.     ld    R4,#ASCIISP
  1331.     LDC    @RR6,R4        ; clear token 
  1332.     INC    R7
  1333.     LDC    R4,@RR6        ; check for token end 
  1334.     CP    R4,#ASCIICR
  1335.     JR    EQ,END_FIND
  1336.     CP    R4,#ASCIISP    ; continue until we hit 
  1337.     JR    NE,CLR_TOKEN    ;   a space. 
  1338.  
  1339. END_FIND:
  1340.     RET            ; 
  1341.  
  1342.  
  1343. GETADDR 
  1344. ;*******************************************************
  1345. ;*
  1346. ;*    GETADDR     Get an address value from input line
  1347. ;*
  1348. ;*    input:    INPTR is offset from CONIBF to last parameter
  1349. ;*
  1350. ;*    output:    address is stored in R10 R11
  1351. ;*
  1352. ;*    R6,R7,R12,R4 destroyed
  1353. ;*
  1354. ;*******************************************************;
  1355.     CLR    R10        ; clear the temp 
  1356.     CLR    R11        ; 
  1357.  
  1358.     call    FINDNEXT    ; R4 has first char 
  1359.     JR    Z,PARA_CR    ; it is a <CR> 
  1360. CON_BYTE:
  1361.  
  1362.     call    CONVERT        ; convert to 4 bit bin 
  1363.     JR    C,INV_HEX    ; invalid hex 
  1364.     SWAP    R4        ; get into upper nibble  
  1365.     ld    R12,#$04    ; must SHIFT all 
  1366.                 ;   four bits 
  1367. SHIFTIT:
  1368.     RLC    R4        ; SHIFT msb into carry 
  1369.     RLC    R11        ; from carry to lsb low byte 
  1370.     RLC    R10        ; msb low byte -> lsb hi byte 
  1371.     DJNZ    R12,SHIFTIT    ; 
  1372.  
  1373.     INC    R7        ; point to next digit 
  1374.     LDC    R4,@RR6        ; get into working register 
  1375.     CP    R4,#ASCIISP    ; space is end 
  1376.     JR    EQ,LAST_NUM    ; 
  1377.     CP    R4,#ASCIICR    ; so is <CR> 
  1378.     JR    EQ,LAST_NUM    ; 
  1379.     JR    CON_BYTE    ; convert next digit
  1380.  
  1381. PARA_CR:
  1382.     ld    ERR_CODE,#MIS_PARAM ; type 2 error -- 
  1383.                     ; missing param 
  1384.     SCF            ; set flag 
  1385.     RET
  1386.  
  1387. INV_HEX:
  1388.     ld    ERR_CODE,#BAD_HEX ; type 3 error -- 
  1389.                   ; bad hex value 
  1390.     SCF            ; set flag 
  1391.     RET
  1392.  
  1393. LAST_NUM:
  1394.     DEC    R7        ; 
  1395.     ld    INPTR,R7    ; update pointer 
  1396.     RCF            ; reset flag 
  1397.     RET
  1398.  
  1399.  
  1400.  
  1401. CONVERT 
  1402. ;*******************************************************
  1403. ;*
  1404. ;*    CONVERT  convert ASCII char to hex
  1405. ;*
  1406. ;*    input:    ASCII char is in R4, INPTR points one
  1407. ;*          byte ahead of location where the char
  1408. ;*          was taken from.
  1409. ;*
  1410. ;*    output:    The value is returned in R4.
  1411. ;*
  1412. ;******************************************************;
  1413.  
  1414.     CP    R4,#'0'        ; less than ascii 0 is bad 
  1415.     JR    LT,BAD_HEX_VAL    ; 
  1416.  
  1417.     CP    R4,#'9'        ; if a numeric, mask hi nib 
  1418.     JR    LE,UPMASK    ; 
  1419.  
  1420.     CP    R4,#'A'        ; if > '9', be at least 'a' 
  1421.     JR    LT,BAD_HEX_VAL    ; 
  1422.  
  1423.     CP    R4,#'F'        ; can't be gt 
  1424.     JR    LE,UP_CASE    ; unless it is lower case 
  1425.  
  1426.     CP    R4,#'a'        ; lower case must be at least 
  1427.     JR    LT,BAD_HEX_VAL    ; an 'a' 
  1428.  
  1429.     CP    R4,#'f'        ; but no greater than an 'f' 
  1430.     JR    GT,BAD_HEX_VAL    ; 
  1431.  
  1432. UP_CASE:
  1433.     SUB    R4,#$07        ; change alpha character 
  1434. UPMASK:
  1435.     AND    R4,#$0F        ; mask off upper nibble 
  1436.     RCF            ; reset carry for good exit 
  1437.     RET            ; 
  1438.  
  1439. BAD_HEX_VAL:
  1440.     SCF
  1441.     RET
  1442.  
  1443.  
  1444.  
  1445. SEND_STX 
  1446. ;********************************************************
  1447. ;*
  1448. ;*    SEND_STX  Send the character $02 (STX) to the
  1449. ;*          host.  It will be ignored if an ASCII
  1450. ;*          terminal is connected.
  1451. ;*
  1452. ;*********************************************************;
  1453.  
  1454.  
  1455.     ld    R4,#ASCIISTX    ; send the STX character 
  1456.     call    OUTCHR
  1457.  
  1458.     ; delay on output if not echoing 
  1459.     CP    ECHO_MODE,#ECHO_ON  ; echoing? 
  1460.     JR    EQ,DONE_STX    ; yes 
  1461.     ld    R4,#CRLF_DELAY    ; no, so delay 
  1462.     call    DELAY
  1463.  
  1464. DONE_STX:
  1465.     RET
  1466.  
  1467. SEND_ETX 
  1468. ;********************************************************
  1469. ;*
  1470. ;*    SEND_ETX  Send the character $03 (ETX) to the
  1471. ;*          host.  It will be ignored if an ASCII
  1472. ;*          terminal is connected.
  1473. ;*
  1474. ;*********************************************************;
  1475.     ld    R4,#ASCIIETX    ; send the ETX character 
  1476.     call    OUTCHR
  1477.  
  1478.     ; now delay for a moment 
  1479.     ld    R4,#CRLF_DELAY
  1480.     call    DELAY
  1481.     RET
  1482.  
  1483. CMD_STATUS 
  1484. ;********************************************************
  1485. ;*
  1486. ;*    CMD_STATUS  Send the command status (<STX> I <ETX>)
  1487. ;*        to the host if we are not echoing characters.
  1488. ;*
  1489. ;*********************************************************;
  1490.     CP    ECHO_MODE,#ECHO_ON    ; echoing ? 
  1491.     JR    EQ,DONE_CMD_STAT    ; yes, just ret 
  1492.  
  1493.     call    SEND_STX        ; STX 
  1494.     ld    R4,#'I'            ; I 
  1495.     call    OUTCHR
  1496.     call    SEND_ETX        ; ETX 
  1497.  
  1498. DONE_CMD_STAT:
  1499.     RET
  1500.  
  1501.  
  1502.  
  1503. EDIT_STATUS 
  1504. ;********************************************************
  1505. ;*
  1506. ;*    EDIT_STATUS  Send the edit status (<STX> T <ETX>)
  1507. ;*        to the host if we are not echoing characters.
  1508. ;*
  1509. ;*********************************************************;
  1510.     CP    ECHO_MODE,#ECHO_ON    ; echoing ? 
  1511.     JR    EQ,DONE_EDIT_STAT    ; yes, just ret 
  1512.  
  1513.     call    SEND_STX        ; STX 
  1514.     ld    R4,#'T'            ; T 
  1515.     call    OUTCHR
  1516.     call    SEND_ETX        ; ETX 
  1517.  
  1518. DONE_EDIT_STAT:
  1519.     RET
  1520.  
  1521.  
  1522.  
  1523. GO 
  1524. ;*********************************************************
  1525. ;*
  1526. ;*    GO
  1527. ;*
  1528. ;*    syntax    G [<ADDRESS>]
  1529. ;*
  1530. ;*    defaults    <ADDRESS> = current PC
  1531. ;*
  1532. ;*********************************************************;
  1533.  
  1534.     call    PC_SET        ; optional jump 
  1535.     OR    CFLAG,#LASTCMD    ; mark user is executing 
  1536.     DI            ; change imr 
  1537.     ld    IMR,#$40    ; Enable SIO int only
  1538.     EI            ; 
  1539. ;    CP    USER_EI,#$FF    ; go with interrupts 
  1540. ;    JR    NE,GO_AHEAD    ; 
  1541. ;    call    FORCE_EI    ; 
  1542.  
  1543.  
  1544. GO_AHEAD:
  1545.     ld    RP0,USER_RP0    ;
  1546.     ld    RP1,USER_RP1    ;
  1547.     sb0
  1548.     ld    EMT,#USR_EMT    ; set up external stack for user
  1549.     ld    FLAGS,USER_FLAGS ;
  1550.     ld    IMR,USER_IMR    ;
  1551.  
  1552.     ldw    sp,USER_SP
  1553.     push    USERPC_LO    ; low byte
  1554.     push    USERPC_HI    ; Get high address byte
  1555.     ret            ; GO !!!
  1556.                 ; We will return through the
  1557.                 ; SOFTWARE_BREAK routine or
  1558.                 ; by a RESET only
  1559.  
  1560.  
  1561.  
  1562. PC_SET 
  1563. ;******************************************************
  1564. ;*
  1565. ;*    PC_SET    (but don't go)
  1566. ;*
  1567. ;*    syntax    J [<ADDRESS>]
  1568. ;*
  1569. ;*    defaults   <ADDRESS> = current PC value
  1570. ;*
  1571. ;******************************************************;
  1572.     call    GETADDR        ; get go address 
  1573.     JR    NC,NEW_PC    ; jump if new address parameter 
  1574.  
  1575.     ld    R10,USERPC_HI    ; get user PC 
  1576.     ld    R11,USERPC_LO    ; into RR10 
  1577. NEW_PC:
  1578.     CLR    ERR_CODE    ; no error 
  1579.     ld    USERPC_HI,R10    ; change internal copy 
  1580.     ld    USERPC_LO,R11    ; 
  1581.     RET            ; done 
  1582.  
  1583. TRACE
  1584. ;******************************************************
  1585. ;*
  1586. ;*    Sets breakpoint at the next op code,
  1587. ;*    then executes GO.  This is smart 
  1588. ;*    about program branches.
  1589. ;*
  1590. ;******************************************************
  1591.  
  1592.  
  1593.     ldw    rr10,USER_PC
  1594.     ldci    r12,@rr10    ; fetch opcode
  1595.     ldc    T_CODE,r12    ; save opcode for branch handler
  1596.  
  1597.     cp    r12,#$0F    ; next?
  1598.     jr    nz,trc_1
  1599.     ldw    rr12,IP
  1600.     jr    trc_x        ; share some code
  1601.  
  1602. trc_1:    cp    r12,#$F6    ; call #addr ?
  1603.     jr    z,trc_1a
  1604.  
  1605.     cp    r12,#$1F    ; enter?
  1606.     jr    nz,trc_2    ; if not
  1607. trc_1a:    ldw    rr12,rr10
  1608. trc_x    ldci    r10,@rr12    ; fetch next pc from the word list
  1609.     ldc    r11,@rr12
  1610.     jp    trc_0        ; go set BP
  1611.  
  1612. trc_2:    cp    r12,#$2F    ; Exit?
  1613.     jr    nz,trc_3
  1614.     ldw    rr10,sp
  1615.     ldci    r12,@rr10
  1616.     ldc    r13,@rr10
  1617.     jr    trc_x
  1618.  
  1619. trc_3:    cp    r12,#$AF    ; return?
  1620.     jr    nz,trc_4
  1621.     pop    r10        ; get pc off stack
  1622.     pop    r11
  1623.     push    r11        ; restore stack
  1624.     push    r10
  1625.     jp    trc_0        ; go set BP
  1626.  
  1627. trc_4:    cp    r12,#$F4    ; CALL @R ?
  1628.     jr    z,trc_4a    ; if so
  1629.  
  1630.     cp    r12,#$30    ; JP @R ?
  1631.     jr    nz,trc_5
  1632.  
  1633. trc_4a:    ld    r14,#$C4    ; ldw opcode
  1634.     ldc    T_CODE,r14
  1635.     ldci    r14,@rr10    ; get des. field from opcode (@R)
  1636.     ldc    T_CODE+1,r14    ; = source for LDW
  1637.     ld    r14,#ALT_PC
  1638.     ldc    T_CODE+2,r14    ; ldw ALT_PC,R; R is destination
  1639.     ld    r14,#$AF
  1640.     ldc    T_CODE+3,r14    ; ret
  1641.  
  1642.     ld    FLAGS,USER_FLAGS  ; we need user flags for condx. jump
  1643.     ld    RP0,USER_RP0    ; user registers are needed for djnz, etc.
  1644.     ld    RP1,USER_RP1
  1645.     call    T_CODE        ; get the destination to ALT_PC
  1646.     srp    #WORKREGS    ; Point to monitor reg. set
  1647.     ldw    rr10,ALT_PC
  1648.     jp    trc_0
  1649. ;-----
  1650. trc_5:
  1651.     inc    r12        
  1652.     ldw    rr4,#OP_TAB-1    ; get starting
  1653. nxt_2:    incw    rr4        ; find next
  1654.     ldc    r13,@rr4    ; control byte
  1655.     TM    r13,#$80    ; bit 7 set?
  1656.     jr    z,nxt_2        ; loop 2 till
  1657.  
  1658. nxt_3:    djnz    r12,nxt_2    ; if not there, get next
  1659.  
  1660.     swap    r13
  1661.     rr    r13
  1662.     and    r13,#3
  1663.     add    r11,r13
  1664.     adc    r10,#0        ; Next addr now in rr10
  1665. ;------------------------------------------------    
  1666. ; Now look at the opcode, & take care of branches
  1667.  
  1668.     ldw    ALT_PC,rr10    ; save next intruction address
  1669.     ldw    rr8,USER_PC
  1670.     ldci    r14,@rr8    ; fetch opcode 
  1671.     ldc    T_CODE,r14    ; save opcode just in case
  1672.  
  1673.     cp    r14,#$d2    ; cpijne?
  1674.     jr    z,tbr4a
  1675.     cp    r14,#$C2    ; cpije?
  1676.     jr    z,tbr4a
  1677.  
  1678. tbr4:    cp    r14,#$37    ; btjrf/t?
  1679.     jr    nz,trb3
  1680. tbr4a:    ldci    r14,@rr8
  1681.     ldc    T_CODE+1,r14
  1682.     ld    r14,#3
  1683.     ldc    T_CODE+2,r14
  1684.     ldc    r13,@rr8    ; get displacement to r13
  1685.     ld    r12,r13
  1686.     add    r12,r12        ; sign bit to carry
  1687.     clr    r12
  1688.     sbc    r12,#0        ; extend sign bit into r12
  1689.     add    r13,r11
  1690.     adc    r12,r10        ; destination to rr12
  1691.     jr    tbr1b
  1692.  
  1693. trb3:    and    r14,#$F
  1694.     cp    r14,#$0A    ; DJNZ?
  1695.     jr    z,trb2        ; if so, use same code as JR
  1696.  
  1697.     cp    r14,#$0B    ; jump relative?
  1698.     jr    nz,tbr1        ; if not
  1699.  
  1700. trb2:    ldc    r13,@rr8    ; get displacement to r13
  1701.     ld    r12,r13
  1702.     add    r12,r12        ; sign bit to carry
  1703.     clr    r12
  1704.     sbc    r12,#0        ; extend sign bit into r12
  1705.     add    r13,r11
  1706.     adc    r12,r10        ; destination to rr12
  1707.     jr    tbr1a        ; go do it
  1708.  
  1709. tbr1    cp    r14,#$0D    ; jump?
  1710.     jr    nz,trc_0    ; if not, get out of here
  1711.     ldci    r12,@rr8    ; 
  1712.     ldc    r13,@rr8
  1713.     ldc    r14,T_CODE
  1714.     sub    r14,#2        ; turn JP into JR
  1715.     ldc    T_CODE,r14
  1716.     
  1717. tbr1a:    ld    r14,#4        ; displacement for jr cc
  1718.     ldc    T_CODE+1,r14
  1719.     ld    r14,#$ff
  1720.     ldc    T_CODE+2,r14    ; throw in a nop
  1721.  
  1722. tbr1b:    ldw    USER_PC,rr12    ; assume a jump 
  1723.     ld    r14,#$C4    ; ldw opcode
  1724.     ldc    T_CODE+3,r14
  1725.     ld    r14,#ALT_PC    ; if branch not taken, 
  1726.     ldc    T_CODE+4,r14    ; ALT_PC --> USER_PC
  1727.     ld    r14,#USER_PC
  1728.     ldc    T_CODE+5,r14    ; ldw rr12,rr10 if branch not taken
  1729.     ld    r14,#$AF
  1730.     ldc    T_CODE+6,r14    ; ret
  1731.  
  1732.     ld    FLAGS,USER_FLAGS  ; we need user flags for condx. jump
  1733.     ld    RP0,USER_RP0    ; user registers are needed for djnz, etc.
  1734.     ld    RP1,USER_RP1
  1735.     call    T_CODE
  1736.     srp    #WORKREGS    ; Point to monitor reg. set
  1737.     ld    R4,#'J'        ; output a 'J' for jump 
  1738.     jp    BRK_2        ; fake a break
  1739.     .xlist        
  1740. ;-----
  1741. trc_0:    call    SET_BREAK_ADDR
  1742.     jp    GO
  1743.  
  1744.  
  1745. BREAK 
  1746. ;*******************************************************
  1747. ;*
  1748. ;*    BREAK
  1749. ;*
  1750. ;*    syntax        B        display breakpoints
  1751. ;*    syntax        B <ADDRESS>     set one breakpoint
  1752. ;*
  1753. ;*******************************************************;
  1754.  
  1755.  
  1756.     call    GETADDR        ; check for parameters
  1757.     JR    C,DISP_BRK    ; jump if no parameters
  1758.     CP    R10,#$80    ; Break range must be > ROM space
  1759.     JR    ULT, BAD_RANGE
  1760.     jr    SET_BREAK_ADDR    ;
  1761.  
  1762. ; Display the breakpoints set
  1763.  
  1764. DISP_BRK:
  1765.     ldw    rr10,#BP1_ADDR ; Point to Break point save location
  1766.     ldc    r12,@rr10    ; Get high byte of breakpoint address
  1767.     cp    r12,#$80    ; Check if in ROM space
  1768.     jr    uge,CHK_BRK    ; Jump if not
  1769.     clr    ERR_CODE    ; No breakpoint set
  1770.     ret
  1771.  
  1772. CHK_BRK:
  1773.     ld    r6,#^HB BRK_MES    ; Print
  1774.     ld    r7,#^LB BRK_MES    ;   breakpoint
  1775.     call    OUTSTR        ;       header
  1776.     ldc    r4,@rr10    ; Get High address byte
  1777.     call    OUTHEX        ; Print high byte
  1778.     incw    rr10        ; Point to Low address byte
  1779.     ldc    r4,@rr10    ; Get Low address byte
  1780.     call    OUTHEX        ; Print low byte
  1781.     call    CRLF
  1782.     CLR    ERR_CODE    ; clear errors 
  1783.     RET
  1784.  
  1785. BAD_RANGE:
  1786.     ld    ERR_CODE,#BAD_PARAM_VAL
  1787.     ret
  1788.  
  1789.  
  1790. ;    Set a breakpoint
  1791. ; "BREAK_ADDR" can be called to set a breakpoint 
  1792. ;    if RR10 has the breakpoint address 
  1793.  
  1794. SET_BREAK_ADDR:
  1795.     CLR    ERR_CODE    ; clear errors 
  1796.  
  1797. ; Make sure the address is not in ROM space
  1798.  
  1799.     CP    R10,#$80        ; Is it in lower 16K? (ROM Space)
  1800.     JR    UGE,INT_ADDR        ; no
  1801.     ld    ERR_CODE,#BAD_PARAM_VAL    ; Opps! It is
  1802.     RET                ; Send back error code
  1803.  
  1804. ; Get the three bytes we need to replace with the call instruction
  1805.  
  1806. INT_ADDR:
  1807.     push    r0            ; save
  1808.     push    r2            ;   some
  1809.     push    r3            ;    registers
  1810.     ldw    rr2,#BP1_ADDR        ; pt to save address of breakaddress
  1811.     ldc    @rr2,r10        ; Save High byte of break address
  1812.     incw    rr2            ; Point to next location
  1813.     ldc    @rr2,r11        ; Save Low byte of break address
  1814.     ldw    rr2,#BP1_SAVE        ; Point to save address of breakaddress
  1815.     ldc    r0,@rr10        ; Get first byte
  1816.     ldc    @rr2,r0            ; Save 1st byte
  1817.     ld    r0,#$F6
  1818.     ldc    @rr10,r0        ; Insert call opcode
  1819.     incw    rr10            ; Point to next byte
  1820.     incw    rr2            ;   & next save location
  1821.     ldc    r0,@rr10        ; Get 2nd byte
  1822.     ldc    @rr2,r0            ; Save it
  1823.     ld    r0,#^HB SOFTWARE_BREAK
  1824.     ldc    @rr10,r0
  1825.     incw    rr10            ;
  1826.     incw    rr2            ;
  1827.     ldc    r0,@rr10        ; Get 3rd byte
  1828.     ldc    @rr2,r0            ; save it
  1829.     ld    r0,#^LB SOFTWARE_BREAK    ;
  1830.     ldc    @rr10,r0
  1831.     pop    r3
  1832.     pop    r2
  1833.     pop    r0
  1834.     ret
  1835.  
  1836.  
  1837. KILL 
  1838. ;*******************************************************
  1839. ;*
  1840. ;*    KILL
  1841. ;*
  1842. ;*    syntax        K
  1843. ;*
  1844. ;*******************************************************;
  1845.  
  1846.     ld    ERR_CODE, #0
  1847.     ldw    rr10,#BP1_ADDR    ; Point to saved address
  1848.     ldci    r0,@rr10    ; Load break address
  1849.     ldc    r1,@rr10    ;   into rr0
  1850.     clr    r3
  1851.     ldw    rr10,#BP1_ADDR    ; Point to saved address
  1852.     ldc    @rr10,r3    ; Clear break address
  1853.     incw    rr10
  1854.     ldc    @rr10,r3
  1855.     ldw    rr10,#BP1_SAVE        ; Load pointer to save area
  1856.     ldci    r2,@rr10        ; Get 1st byte
  1857.     ldc    @rr0,r2            ; Restore 1st byte
  1858.     incw    rr0
  1859.     ldci    r2,@rr10        ; get 2nd byte
  1860.     ldc    @rr0,r2            ; Restore 2nd byte
  1861.     incw    rr0
  1862.     ldci    r2,@rr10        ; Get 3rd byte
  1863.     ldc    @rr0,r2            ; Restore 3rd byte
  1864.     ret
  1865.  
  1866.  
  1867. SOFTWARE_BREAK
  1868. ;**********************************************************
  1869. ;*
  1870. ;*      Software breakpoint reached
  1871. ;*
  1872. ;* This routine is the call location for a software
  1873. ;* breakpoint.
  1874. :*
  1875. ;**********************************************************
  1876.  
  1877.     DI
  1878.     ld    USER_FLAGS,FLAGS    ; Save USER FLAGS
  1879.     ld    USER_IMR,IMR        ;
  1880.     ld    USER_RP0,RP0        ;      RP0
  1881.     ld    USER_RP1,RP1        ;      RP1
  1882.     srp    #WORKREGS        ; Point to correct reg set
  1883.     pop    r0            ; Get USER PC
  1884.     pop    r1            ;     off of stack
  1885.     ldw    USER_SP,SP
  1886.     decw    rr0            ; Break
  1887.     decw    rr0            ;   address is
  1888.     decw    rr0            ;     3 less
  1889.     ld    USERPC_HI,r0        ; Save high address
  1890.     ld    USERPC_LO,r1        ;    & low address
  1891.  
  1892. ; Restore removed instruction
  1893.  
  1894.     ldw    rr10,#BP1_ADDR    ; Point to saved address
  1895.     ldci    r0,@rr10        ; Load break address
  1896.     ldc    r1,@rr10        ;   into rr0
  1897.     clr    r3
  1898.     ldw    rr10,#BP1_ADDR    ; Point to saved address
  1899.     ldc    @rr10,r3        ; Clear break address
  1900.     incw    rr10
  1901.     ldc    @rr10,r3
  1902.     ldw    rr10,#BP1_SAVE        ; Load pointer to save area
  1903.     ldci    r2,@rr10        ; Get 1st byte
  1904.     ldc    @rr0,r2            ; Restore 1st byte
  1905.     incw    rr0
  1906.     ldci    r2,@rr10        ; get 2nd byte
  1907.     ldc    @rr0,r2            ; Restore 2nd byte
  1908.     incw    rr0
  1909.     ldci    r2,@rr10        ; Get 3rd byte
  1910.     ldc    @rr0,r2            ; Restore 3rd byte
  1911.  
  1912. ; We hit a breakpoint
  1913.  
  1914. BREAK_1:
  1915.     ld    IMR,#$40    ; Reset the IMR (Enable SIO IRQ)
  1916.     EI            ; enable other interrupts 
  1917.     ld    R4,#'B'        ; output a 'B' for break 
  1918. BRK_2:    call    OUTCHR        ; 
  1919.     ld    R4,#ASCIISP    ; followed by a space 
  1920.     call    OUTCHR        ; 
  1921.     call    NO_NUM        ; Disassemble instruction
  1922. HALTED:
  1923.     AND    CFLAG,#CLSTCMD    ; clear the go 
  1924.     sb0
  1925.     ld    EMT,#SYS_EMT
  1926.     ldw    SP,#SYS_STACK    ; point back on stack 
  1927.     jp    MAIN        ; in monitor mode 
  1928.  
  1929.  
  1930. INT_TAB_REL:
  1931. ;************************************************************
  1932. ;*
  1933. ;*    INTERRUPT TABLE RELOCATION ROUTINE
  1934. ;*    MOVES DUMMY INTERRUPT TABLE TO RAM LOCATION
  1935. ;*    E000H FOR USER ACCESS.  ALL VECTORS POINT TO AN
  1936. ;*    INTERRUPT RETURN.
  1937. ;*
  1938. ;************************************************************
  1939.  
  1940.     ldw    rr4,#$E000    ;beginning location of interrupt vector table
  1941.                 ;in ram
  1942.     ldw    rr6,#IVECT0    ;beginning location of table data in ROM
  1943.     ld    r8,#IVECLEN    ;get length of table
  1944. IVLOOP:    ldci    r0,@rr6        ;get the byte
  1945.     ldc    @rr4,r0        ;put the byte
  1946.     incw    rr4        ;bump pointer
  1947.     djnz    r8,IVLOOP    ;loop till done
  1948.     ret
  1949.  
  1950.  
  1951.  
  1952. ;************************************************************
  1953. ;*
  1954. ;*   TABLES and MESSAGE STRINGS
  1955. ;*
  1956. ;************************************************************;
  1957.  
  1958.  
  1959. ERR_MSG_LIST dw ERR_0_MSG, ERR_1_MSG, ERR_2_MSG, ERR_3_MSG, ERR_4_MSG
  1960.          dw ERR_5_MSG, ERR_6_MSG, ERR_7_MSG, ERR_8_MSG
  1961.  
  1962. ERR_0_MSG .ascii '? INVALID ERROR CODE\r'
  1963. ERR_1_MSG .ascii '? 01 INVALID COMMAND\r'
  1964. ERR_2_MSG .ascii '? 02 MISSING PARAMETER\r'
  1965. ERR_3_MSG .ascii '? 03 BAD HEX NUMBER\r'
  1966. ERR_4_MSG .ascii '? 04 BAD COMMAND OPTION\r'
  1967. ERR_5_MSG .ascii '? 05 LOAD ABORTED BY HOST\r'
  1968. ERR_6_MSG .ascii '? 06 LOAD ABORTED BY SUPER8 MONITOR\r'
  1969. ERR_7_MSG .ascii '? 07 FILE ERROR MESSAGE\r'
  1970. ERR_8_MSG .ascii '? 08 PARAMETER VALUE OUT OF RANGE\r'
  1971.  
  1972. STRT_MSG .ascii '                          SUPER8  Monitor\r'
  1973. REV_MSG  .ascii '                          Version  1.02.07\r'
  1974. DATE_MSG .ascii '                          March  9,  1987\r'
  1975.  
  1976. BRK_MES      .ascii 'Breakpoint set at: \r'
  1977.  
  1978. WARM_PATTERN db $00,$FF,$A5,$5A
  1979.  
  1980. ;
  1981. ; interrupt handlers
  1982. ; null return will terminate improperly initialized interrupt
  1983. ;
  1984. NULIRET:    IRET
  1985. ;
  1986. ; null vector table to be relocated into ram beginning at location E000H
  1987. ;
  1988. IVECT0:        jp    NULIRET
  1989. IVECT1:        jp    NULIRET
  1990. IVECT2:        jp    NULIRET
  1991. IVECT3:        jp    NULIRET
  1992. IVECT4:        jp    NULIRET
  1993. IVECT5:        jp    NULIRET
  1994. IVECT6:        jp    NULIRET
  1995. IVECT7:        jp    NULIRET
  1996. IVECT8:        jp    NULIRET
  1997. IVECT9:        jp    NULIRET
  1998. IVECT10:    jp    NULIRET
  1999. IVECT11:    jp    NULIRET
  2000. IVECT12:    jp    NULIRET
  2001. IVECT13:    jp    NULIRET
  2002. IVECT14:    jp    NULIRET
  2003. IVECT15:    jp    NULIRET
  2004. IVECLEN        equ    $-IVECT0    ;LENGTH OF TABLE TO BE RELOCATED
  2005.  
  2006. ;************************************************
  2007. ;*
  2008. ;*    mem.s : all the memory command
  2009. ;*        routines except low-level routines.
  2010. ;*
  2011. ;*  ** This version doctored for META assembler
  2012. ;*
  2013. ;*****************************************************
  2014. ;*
  2015. ;*               Constants and register usage used by
  2016. ;*               all or some of the software modules.
  2017. ;*
  2018. ;******************************************************;
  2019. ; register allocation 
  2020.  
  2021. FILL 
  2022. ;*****************************************************
  2023. ;*
  2024. ;*    FILL
  2025. ;*
  2026. ;*    syntax        F <START ADDR> <LENGTH> {<DATA>}
  2027. ;*
  2028. ;*    defaults    none
  2029. ;*
  2030. ;*    action        the pattern input as {<DATA>}
  2031. ;*            is written into memory beginning
  2032. ;*            at <START ADDR> and is copied
  2033. ;*            in as many times as necessary to
  2034. ;*            fill <LENGTH> bytes of memory
  2035. ;*
  2036. ;*****************************************************;
  2037.     PUSH    R15
  2038.  
  2039.     CALL    GETADDR        ; get the address 
  2040.     JR    C,BADHX5    ; no good 
  2041.     LD    R0,R10        ; use RR0 
  2042.     LD    R1,R11        ; 
  2043.     CALL    GETADDR        ; get length 
  2044.     JR    C,BADHX5    ; no good 
  2045.     LD    R2,R10        ; put length into RR2 
  2046.     LD    R3,R11        ; 
  2047.  
  2048.     CLR    OUTPTR        ; use the input buffer 
  2049.     CLR    R13        ; count # of data bytes 
  2050. ACCUM:
  2051.     CALL    GETADDR        ; get data 
  2052.     JR    C,DO_FILL    ; stop input and fill 
  2053.     LD    R7,OUTPTR    ; get pointer 
  2054.     LDC    @RR6,R11    ; one byte of data 
  2055.     INC    R13        ; keep count 
  2056.     INC    OUTPTR        ; increment pointer 
  2057.     JR    ACCUM        ; 
  2058. DO_FILL:
  2059.     CP    R13,#$00    ; if no data,don't fill 
  2060.     JR    EQ,BADHX5    ; didn't get any data 
  2061.  
  2062.  
  2063. RE_PEAT:
  2064.     LD    R9,R13        ; get length of pattern 
  2065.     CLR    R7        ; pointer not shared 
  2066. R9LOOP:
  2067.     LDC    R15,@RR6        ; get data from pattern 
  2068.  
  2069.     PUSH    R8
  2070.     PUSH    R9
  2071.     LD    R8,R0
  2072.     LD    R9,R1
  2073.     CALL    PUTMEM        ; LDE    @RR8,R15 
  2074.     POP    R9
  2075.     POP    R8
  2076.  
  2077.     INCW    RR0        ; increment memory ptr 
  2078.     INC    R7        ; increment buffer ptr 
  2079.     DECW    RR2        ; decrement length of memory 
  2080.     JR    Z,FILL_END    ; 
  2081.     DJNZ    R9,R9LOOP    ; DJNZ    R9,R9loop 
  2082.     JR    RE_PEAT        ; repeat the pattern 
  2083. FILL_END:
  2084.  
  2085.  
  2086.     CLR    ERR_CODE    ; normal ending,clear error 
  2087. BADHX5:
  2088.     POP    R15
  2089.  
  2090.     RET            ; stop this 
  2091.  
  2092.  
  2093.  
  2094.  
  2095. MOVE 
  2096. ;******************************************************
  2097. ;*
  2098. ;*    MOVE
  2099. ;*
  2100. ;*    syntax    M <DEST ADDR> <SOURCE ADDR> [<LENGTH>]
  2101. ;*
  2102. ;*    defaults    <LENGTH> = 1
  2103. ;*
  2104. ;******************************************************;
  2105.     PUSH    R8
  2106.     PUSH    R9
  2107.     PUSH    R15
  2108.  
  2109.     CALL    GETADDR        ; get first address 
  2110.     JR    C,BADHX6    ; no good 
  2111.  
  2112.     LD    R2,R10        ; first address 
  2113.     LD    R3,R11        ; into RR2 
  2114.     CALL    GETADDR        ; second address 
  2115.     JR    C,BADHX6    ; no good 
  2116.  
  2117.     LD    R0,R10        ; second address into 
  2118.     LD    R1,R11        ; RR0 
  2119.     CALL    GETADDR        ; get move length 
  2120.     JR    NC,DO_MOVE    ; default is 1 
  2121.  
  2122.     CLR    R10        ; clear high order 
  2123.     LD    R11,#$01    ; get default into R11 
  2124.  
  2125. DO_MOVE:
  2126.     PUSH    R2        ; save from pointer 
  2127.     PUSH    R3        ; 
  2128.     SUB    R3,R1        ; subtract word 
  2129.     SBC    R2,R0        ; in two steps 
  2130.     POP    R3        ; restore pointer 
  2131.     POP    R2        ; 
  2132.     JR    C,BKWARD    ; carry indicates back move 
  2133.  
  2134. FORWARD:
  2135.     LD    R8,R2
  2136.     LD    R9,R3
  2137.     CALL    GETMEM        ; LDE    R15,@RR8 
  2138.  
  2139.     ; data is now in R15 
  2140.  
  2141.     LD    R8,R0
  2142.     LD    R9,R1
  2143.     CALL    PUTMEM        ; LDE    @RR8,R15 
  2144.  
  2145.     INCW    RR0        ; increment pointers 
  2146.     INCW    RR2        ; 
  2147.     DECW    RR10        ; decrement count 
  2148.     JR    NZ,FORWARD    ; 
  2149.     JR    END_MOVE    ; stop 
  2150.  
  2151. BKWARD:
  2152.     ADD    R1,R11        ; point to back end 
  2153.     ADC    R0,R10        ; word add 
  2154.     ADD    R3,R11        ; point to back end 
  2155.     ADC    R2,R10        ; 
  2156. BACKWD:
  2157.     DECW    RR0        ; decrement pointers 
  2158.     DECW    RR2        ; 
  2159.  
  2160.  
  2161.     LD    R8,R2
  2162.     LD    R9,R3
  2163.     CALL    GETMEM        ; LDE    R15,@RR8 
  2164.  
  2165.     ; data is now in R15 
  2166.  
  2167.     LD    R8,R0
  2168.     LD    R9,R1
  2169.     CALL    PUTMEM        ; LDE    @RR8,R15 
  2170.  
  2171.     DECW    RR10        ; decrement counter 
  2172.     JR    NZ,BACKWD    ; 
  2173. END_MOVE:
  2174. BADHX6:
  2175.     POP    R15
  2176.     POP    R9
  2177.     POP    R8
  2178.     RET            ; stop 
  2179.  
  2180.  
  2181.  
  2182.  
  2183. SET 
  2184. ;*****************************************************
  2185. ;*
  2186. ;*    SET memory
  2187. ;*
  2188. ;*    syntax    S <ADDR> {<DATA>}
  2189. ;*
  2190. ;*    defaults    none
  2191. ;*
  2192. ;*    Set memory at <ADDR> with <DATA> string.
  2193. ;*    Input is limited to 80 (decimal) characters
  2194. ;*    on the command line.
  2195. ;*
  2196. ;******************************************************;
  2197.     PUSH    R15
  2198.  
  2199.     CALL    GETADDR        ; get the start address 
  2200.     JR    C,BADHX2A    ; bad hex 
  2201.  
  2202.     LD    R8,R10        ; use reg's RR8 
  2203.     LD    R9,R11        ; 
  2204.  
  2205. SETVAL:
  2206.     CALL    GETADDR        ; 
  2207.     JR    C,BADHX2    ;  
  2208.  
  2209.     LD    R15,R11        ; data 
  2210.     PUSH    R8        ; hi addr 
  2211.     PUSH    R9        ; lo addr 
  2212.     CALL    PUTMEM        ; LDE    @RR8,R15 
  2213.     POP    R9        ; 
  2214.     POP    R8        ; 
  2215.  
  2216.     INCW    RR8        ; 
  2217.     JR    SETVAL        ; get next value 
  2218. BADHX2:
  2219.     CLR    ERR_CODE    ; clear error 
  2220. BADHX2A:
  2221.     POP    R15
  2222.     RET            ; 
  2223.  
  2224.  
  2225.  
  2226.  
  2227. MEMORY 
  2228. ;*******************************************************
  2229. ;*
  2230. ;*    MEMORY
  2231. ;*
  2232. ;*    syntax        D [<START ADDR> [<LENGTH>]]
  2233. ;*
  2234. ;*    defaults    <length> = 1,and the user is given
  2235. ;*                     the opportunity to
  2236. ;*                     change the contents
  2237. ;*            <start addr> = 0 (user_zero)
  2238. ;*
  2239. ;*    action    (full syntax)
  2240. ;*            memory is displayed $10 locations to
  2241. ;*            a line (unless less is specified)
  2242. ;*            each line has two addresses, the first
  2243. ;*            location displayed and the 8th location.
  2244. ;*            following each line and on the same line
  2245. ;*            is the ascii conversion when possible
  2246. ;*            and a dot when value not an ascii character.
  2247. ;*            the ascii conversion is offset by '*'
  2248. ;*
  2249. ;*        (partial syntax)
  2250. ;*            each memory location is displayed, first
  2251. ;*            the address then the contents, and a prompt
  2252. ;*            is issued to the user for input.
  2253. ;*            possible inputs are:
  2254. ;*            [^|.|q] <cr>
  2255. ;*            or
  2256. ;*            <data> [^|.|q] <cr>
  2257. ;*            <data> replaces previous contents
  2258. ;*            <cr> causes the next location to be displayed
  2259. ;*            ^ <cr> the previous location is displayed
  2260. ;*            . <cr> the current location is displayed again
  2261. ;*            q <cr> terminates the command
  2262. ;*
  2263. ;*******************************************************;
  2264.     CALL    GETADDR        ; get first parameter 
  2265.     JP    C,ZERO_START    ; start display from zero 
  2266.  
  2267.     PUSH    R10        ; save start address 
  2268.     PUSH    R11        ; 
  2269.  
  2270.  
  2271.     CALL    GETADDR        ; get length parameter 
  2272.     JP    C,DISP_ALT    ; no parameter,display + alter 
  2273.  
  2274.     LD    R0,R10        ; put total into RR0 
  2275.     LD    R1,R11        ; 
  2276.     POP    R11        ; recover start address 
  2277.     POP    R10        ; 
  2278. NEWLINE:
  2279.     PUSH    R10        ; 
  2280.     PUSH    R11        ; 
  2281.     CP    R0,#$00        ; any left to display ? 
  2282.     JR    NZ,GO_AHEAD1    ; go ahead and display 
  2283.  
  2284.     CP    R1,#$00        ; 
  2285.     JR    Z,ALL_DONE    ; 
  2286. GO_AHEAD1:
  2287.     CALL    DISPMEMLINE    ; display a line of memory 
  2288.     POP    R13        ; get start of current line 
  2289.     POP    R12        ; using RR12 
  2290.     CALL    DISPASCII    ; display 
  2291.     JR    NEWLINE        ; display next line 
  2292. ALL_DONE:
  2293.     POP    R11        ; pop stack 
  2294.     POP    R10        ; 
  2295. ERR_EXIT:
  2296.     RET            ; errors exit here 
  2297. DONE:
  2298.     CLR    ERR_CODE    ; no error,a token 
  2299.     RET            ; and exit 
  2300.  
  2301.  
  2302. ZERO_START:
  2303.     CALL    EDIT_STATUS    ; tell host edit mode 
  2304.     CLR    R10        ; 
  2305.     CLR    R11        ; start at user zero 
  2306.  
  2307.     JR    DISP_1        ; display one at a time 
  2308. DISP_ALT:
  2309.     CALL    EDIT_STATUS    ; tell host edit mode 
  2310.     POP    R11        ; recover parameter for 
  2311.     POP    R10        ; the start address 
  2312. DISP_1:
  2313.     CALL    OUTADDR        ; output the address 
  2314.  
  2315.     PUSH    R8
  2316.     PUSH    R9
  2317.     PUSH    R15
  2318.  
  2319.     LD    R8,R10        ; hi addr 
  2320.     LD    R9,R11        ; lo addr 
  2321.     CALL    GETMEM        ; read byte from memory
  2322.     LD    R4,R15        ; get data 
  2323.  
  2324.     POP    R15
  2325.     POP    R9
  2326.     POP    R8
  2327.  
  2328.     CALL    OUTDAT        ; 
  2329.  
  2330.     ; output prompt with leading STX and trialing ETX 
  2331.     ;   for host package 
  2332.     LD    R4,#ASCIISTX
  2333.     CALL    OUTCHR
  2334.     LD    R4,#'+'        ; prompt for response 
  2335.     CALL    OUTCHR        ; 
  2336.     LD    R4,#ASCIIETX
  2337.     CALL    OUTCHR
  2338.  
  2339.     CALL    GETLINE        ; get the response 
  2340.  
  2341. DISP_TOKEN:
  2342.  
  2343.     CP    R4,#ASCIIQ    ; is it quit ? 
  2344.     JR    Z,DONE        ; 
  2345.  
  2346.     CP    R4,#'q'        ; is it quit ? 
  2347.     JR    Z,DONE        ; 
  2348.  
  2349.     CP    R4,#ASCIIUP    ; is it an up ? 
  2350.     JR    NZ,DOT        ; 
  2351.  
  2352.     DECW    RR10        ; 
  2353.     JR    DISP_1        ; 
  2354. DOT:
  2355.     CP    R4,#ASCIIDOT    ; is it a dot ? 
  2356.     JR    Z,DISP_1    ; 
  2357.  
  2358.     CP    R4,#ASCIICR    ; is it a <cr> ? 
  2359.     JR    NZ,NUMERIC    ; 
  2360.  
  2361.     INCW    RR10        ; 
  2362.     JR    DISP_1        ; 
  2363. NUMERIC:
  2364.     PUSH    R10        ; save 
  2365.     PUSH    R11        ; save 
  2366.     CLR    R10        ; clear 
  2367.     CLR    R11        ; for conversion 
  2368.     CALL    CON_BYTE    ; entry to getaddr 
  2369.     JR    C,ALL_DONE    ; error 
  2370.  
  2371.     LD    R4,R11        ; low order byte important 
  2372.     POP    R11        ; restore address 
  2373.     POP    R10        ; 
  2374.  
  2375.     PUSH    R8
  2376.     PUSH    R9
  2377.     PUSH    R15
  2378.     LD    R15,R4        ; data 
  2379.     LD    R8,R10        ; hi addr 
  2380.     LD    R9,R11        ; lo addr 
  2381.     CALL    PUTMEM        ; write byte to memory
  2382.     POP    R15
  2383.     POP    R9
  2384.     POP    R8
  2385.  
  2386.     CALL    FINDNEXT    ; are there two tokens? 
  2387.     JR    NZ,DISP_TOKEN    ; 
  2388.  
  2389.     INCW    RR10        ; move pointer 
  2390.     JR    DISP_1        ; go again 
  2391.  
  2392.  
  2393.  
  2394. COMPARE 
  2395. ;*****************************************************
  2396. ;*
  2397. ;*    COMPARE memory
  2398. ;*
  2399. ;*    syntax        C <ADDR1> <ADDR2> [<LENGTH>]
  2400. ;*
  2401. ;*    defaults    <LENGTH> = 1
  2402. ;*
  2403. ;*    action        compares contents of addr1 with addr2
  2404. ;*            if values are unequal,the addresses
  2405. ;*            and contents are displayed on the console
  2406. ;*            <ADDR1> = <VAL1> <ADDR2> = <VAL2>
  2407. ;*            if values are equal,nothing is displayed
  2408. ;*            <ADDR1>=<ADDR2>+1 and <ADDR2>=<ADDR2>+1
  2409. ;*
  2410. ;*****************************************************;
  2411.     PUSH    R8
  2412.     PUSH    R9
  2413.  
  2414.     CALL    GETADDR        ; get first parameter 
  2415.     JR    C,BADHX3    ; bad hex 
  2416.  
  2417.     LD    R0,R10        ; use RR0 for first adddress 
  2418.     LD    R1,R11        ; 
  2419.     CALL    GETADDR        ; get second address 
  2420.     JR    C,BADHX3    ; 
  2421.  
  2422.     LD    R2,R10        ; use RR2 for second addr 
  2423.     LD    R3,R11        ; 
  2424.     CALL    GETADDR        ; get length 
  2425.     JR    NC,COMP        ; got length in RR10 
  2426.  
  2427.     CLR    R10        ; no good parameter 
  2428.     LD    R11,#$01    ; just compare 1 
  2429. COMP:
  2430.     LD    R8,R10        ; put length in RR8 
  2431.     LD    R9,R11        ; 
  2432. DO_COMP:
  2433.     PUSH    R8
  2434.     PUSH    R9
  2435.     LD    R8,R0        ; hi addr 
  2436.     LD    R9,R1        ; lo addr 
  2437.     CALL    GETMEM        ; LDE    R15,@RR8 
  2438.     LD    R14,R15        ; get data 
  2439.  
  2440.     LD    R8,R2        ; hi addr 
  2441.     LD    R9,R3        ; lo addr 
  2442.     CALL    GETMEM        ; LDE    R15,@RR8 
  2443.     POP    R9
  2444.     POP    R8
  2445.  
  2446.     ; data is in R15 
  2447.  
  2448.     CP    R14,R15        ; compare the values 
  2449.     JR    EQ,NODISPLAY    ; don't display if equal 
  2450.  
  2451.     CALL    COMPDISP    ; display 
  2452.  
  2453. NODISPLAY:
  2454.     INCW    RR0        ; increment pointers 
  2455.     INCW    RR2        ; 
  2456.     DECW    RR8        ; 
  2457.     JR    NZ,DO_COMP    ; 
  2458. BADHX3:
  2459.     POP    R9
  2460.     POP    R8
  2461.     RET            ; finished 
  2462.  
  2463.  
  2464.  
  2465. ;**********************************************
  2466. ;*
  2467. ;*    sup.s : low level support routines for
  2468. ;*         the various commands.
  2469. ;*
  2470. ;*        (1) memory read/write
  2471. ;*        (2) register read/write
  2472. ;*        (3) I-CODE execution
  2473. ;*
  2474. ;***********************************************;
  2475.  
  2476.  
  2477.  
  2478. READ_DIR_REG 
  2479. ;*****************************************************
  2480. ;*
  2481. ;*    READ_DIR_REG  Read register using Register
  2482. ;*           addressing mode.  This will
  2483. ;*           read "set one" registers above
  2484. ;*           register address $BF
  2485. ;*
  2486. ;*    input    R9 has register number
  2487. ;*
  2488. ;*    output    R6,R7 point to reg_read,where
  2489. ;*        the register value is returned
  2490. ;*        R9 is unchanged,R4 = $00
  2491. ;*
  2492. ;*****************************************************;
  2493.  
  2494.     push    r0
  2495.     push    r4            ; Save some
  2496.     push    r5            ;    registers
  2497.  
  2498.     ldw    rr6,#I_CODE        ; Point to I_CODE buffer
  2499.     ld    r0,#$48            ; 1st byte of LD R4,REG#
  2500.     ldc    @rr6,r0            ;    instruction
  2501.     incw    rr6            ; Point to next location
  2502.     ldc    @rr6,r9            ; 2nd byte is REG#
  2503.     incw    rr6            ; Point to next location
  2504.     ld    r0,#$AF            ; Place a RET instruction
  2505.     ldc    @rr6,r0            ;   at the end
  2506.     call    I_CODE            ; Go execute the LD instruction
  2507.  
  2508.     LDW    rr6,#REG_READ        ; leave RR6 pointing to place
  2509.                     ;   where reg val is returned
  2510.     ldc    @rr6,r4            ; Place value read into memory
  2511.     pop    r5
  2512.     pop    r4
  2513.     pop    r0
  2514.     RET 
  2515.  
  2516.  
  2517.  
  2518.  
  2519. READ_IR_REG 
  2520. ;*****************************************************
  2521. ;*
  2522. ;*    READ_IR_REG  Read general purpose register
  2523. ;*        using Indirect Register addressing mode.
  2524. ;*        This will read "set two" registers above
  2525. ;*        register address $BF.
  2526. ;*
  2527. ;*    input    R9 has register number and should
  2528. ;*        be in the range $C0 - $FF
  2529. ;*
  2530. ;*    output    R6,R7 point to reg_read,where
  2531. ;*        the register value is returned
  2532. ;*        R9 is unchanged,R4 = $00
  2533. ;*
  2534. ;*****************************************************;
  2535.     PUSH    R4
  2536.     PUSH    R5
  2537.     ld    r5,@r9            ; get register contents
  2538.     LDW    rr6,#REG_READ        ; leave RR6 pointing to
  2539.                     ;   place reg val returned
  2540.     ldc    @RR6,r5            ; Write register value to memory
  2541.     POP R5
  2542.     POP R4
  2543.     RET            ; 
  2544.  
  2545.  
  2546.  
  2547.  
  2548. WRITE_DIR_REG 
  2549. ;***************************************************
  2550. ;*
  2551. ;*    WRITE_DIR_REG  Write a value to general registers
  2552. ;*        $00 - $BF, or set one registers
  2553. ;*
  2554. ;*    input    R9 has register number
  2555. ;*        R11 has value to be written to it
  2556. ;*
  2557. ;*    used    R6,R7 used as pointers to I-CODE
  2558. ;*        R5 used to send opcode
  2559. ;*
  2560. ;*    output    R9 is unchanged,R11 = 0
  2561. ;*        R5,R6,R7 destroyed
  2562. ;*
  2563. ;***************************************************;
  2564.  
  2565.     LDW    RR6,#I_CODE    ; Point to I_CODE execution buffer
  2566.  
  2567.     LD    R5,#$B9        ; 1st byte of LD REG#,R11 instruction
  2568.     LDC    @RR6,R5        ; first write opcode        
  2569.     INCW    RR6        ; 
  2570.     LDC    @RR6,R9        ; 2nd byte is REG# to write
  2571.     INCW    RR6        ; 
  2572.     ld    r5,#$AF        ; 3rd byte is a RET instruction
  2573.     LDC    @RR6,R5        ;
  2574.  
  2575.     CALL    I_CODE        ; now execute I-CODE 
  2576.  
  2577.     RET            ; it will happen 
  2578.  
  2579.  
  2580.  
  2581.  
  2582. WRITE_IR_REG 
  2583. ;***************************************************
  2584. ;*
  2585. ;*    WRITE_IR_REG  Write a value to a register using
  2586. ;*        Indirect Register mode.  This will access
  2587. ;*        set two registers $C0 - $FF.
  2588. ;*
  2589. ;*    input    R9 has register number to be written to and
  2590. ;*        should be in the range $C0 - $FF.
  2591. ;*        R11 has value to be written to it
  2592. ;*
  2593. ;*    output    R9 is unchanged,R11 = 0
  2594. ;*
  2595. ;***************************************************;
  2596.  
  2597.     ld    @r9,r11            ; Write register
  2598.     clr    r11
  2599.     RET
  2600.  
  2601.  
  2602.  
  2603.  
  2604. GETMEM 
  2605. ;****************************************************************
  2606. ;*
  2607. ;*    GETMEM
  2608. ;*
  2609. ;*    Sets GETMEMFLG bit in CFLAG and calls GETPUTMEM
  2610. ;*    checks address for internal or external memory
  2611. ;*    internal 0 through (ROM_size -1), adds offset
  2612. ;*    external >= ROM_size forces user z8 to read
  2613. ;*
  2614. ;*    input:  RR8 contains address to be read from
  2615. ;*
  2616. ;*    output: R15 contains data read
  2617. ;*
  2618. ;****************************************************************;
  2619.  
  2620. ;    Read from data memory?
  2621.         CP      D_MEMFLAG, #$ff ; X command ? 
  2622.     JR      EQ, EXT_MEM
  2623.  
  2624. ;    doing prpgram memory
  2625. GM_INTERN:
  2626.     PUSH    R6        ; save registers
  2627.     PUSH    R7        ; use RR6 for LDC 
  2628.     LD    R6,R8        ; high address byte 
  2629.     LD    R7,R9        ;   and low address byte
  2630.     LDC    R15,@RR6    ; Read byte from program memory
  2631.     POP    R7        ; restore 
  2632.     POP    R6        ;   registers
  2633.     RET            ; deliver the byte 
  2634.  
  2635. ;    doing data memory 
  2636. EXT_MEM:
  2637.     PUSH    R6        ; save registers
  2638.     PUSH    R7        ; use RR6 for LDC 
  2639.     LD    R6,R8        ; high address byte 
  2640.     LD    R7,R9        ;   and low address byte
  2641.     LDC    R15,@RR6    ; Read byte from data memory
  2642.     POP    R7        ; restore 
  2643.     POP    R6        ;   registers
  2644.     RET            ; deliver the byte 
  2645.  
  2646.  
  2647.  
  2648.  
  2649.  
  2650. PUTMEM 
  2651. ;***************************************************************
  2652. ;*
  2653. ;*    PUTMEM
  2654. ;*
  2655. ;*    resets GETMEMFLG bit in CFLAG and calls GETPUTMEM
  2656. ;*    checks address for internal or external memory
  2657. ;*    internal 0 through (ROM_size -1) , adds offset
  2658. ;*    external >= ROM_size forces user z8 to write
  2659. ;*
  2660. ;*    input:  RR8 contains address to be written to.
  2661. ;*            R15 contains data to be written.
  2662. ;*
  2663. ;****************************************************************;
  2664.  
  2665. ;    write to data memory ?
  2666.     CP    D_MEMFLAG, #$ff    ;X command ? 
  2667.     JR    EQ, EXT_MEM_PUT
  2668.  
  2669. ;    write to program memory
  2670. PM_INTERN:
  2671.     PUSH    R6        ; save 
  2672.     PUSH    R7        ; use RR6 for LDE 
  2673.     LD    R6,R8
  2674.     LD    R7,R9
  2675.     LDC    @RR6,R15    ; write byte to program memory
  2676.     POP    R7        ; 
  2677.     POP    R6        ; 
  2678.     RET            ; deliver the byte 
  2679.  
  2680. ;    write to data memory
  2681. EXT_MEM_PUT:
  2682.     PUSH    R6        ; save 
  2683.     PUSH    R7        ; use RR6 for LDE 
  2684.     LD    R6,R8
  2685.     LD    R7,R9
  2686.     LDC    @RR6,R15    ; write byte to data memory
  2687.     POP    R7        ; 
  2688.     POP    R6        ; 
  2689.     RET            ; deliver the byte 
  2690.  
  2691.  
  2692.  
  2693. PUTEXT 
  2694. ;*****************************************************
  2695. ;*
  2696. ;*    PUTEXT  Store downloaded data into extension area.
  2697. ;*        Makes sure that address is valid.
  2698. ;*        Address must be in $D000 - $DFFF range.
  2699. ;*
  2700. ;*    input  R4 has byte value to be stored
  2701. ;*        RR14 has address to store value in
  2702. ;*
  2703. ;*    output LDC @RR14,R4
  2704. ;*
  2705. ;*
  2706. ;********************************************************;
  2707.  
  2708.     CP    R14,#$D0    ; address below $D000? 
  2709.     JR    LT,BAD_ADDR    ; yes 
  2710.     CP    R14,#$DF    ; address above $DFFF? 
  2711.     JR    GT,BAD_ADDR    ; yes 
  2712.  
  2713.     LDC    @RR14,R4
  2714.     JR    DONE_PUTEXT
  2715.  
  2716. BAD_ADDR:
  2717.     LD    ERR_CODE,#BAD_EXT_ADDR
  2718.  
  2719. DONE_PUTEXT:
  2720.     RET
  2721.  
  2722.  
  2723.  
  2724. DISPMEMLINE 
  2725. ;*****************************************************
  2726. ;*
  2727. ;*    DISPMEMLINE  Display a line of memory
  2728. ;*
  2729. ;*    input    RR10 points to first address
  2730. ;*        RR0 has count of data to be displayed
  2731. ;*
  2732. ;*    used    R2 counts characters in half line segment
  2733. ;*        R3 to count half line segments
  2734. ;*        R4 to output data to console
  2735. ;*        R5,R10,R11 are used by OUTADDR
  2736. ;*
  2737. ;*    output    R2 = 0
  2738. ;*        R3 = 0
  2739. ;*        R5 = 0
  2740. ;*        RR10 = RR10 + # of locations displayed
  2741. ;*        RR0 = RR0 - # of locations displayed
  2742. ;*        R4 has last ASCII character output
  2743. ;*
  2744. ;*****************************************************;
  2745.  
  2746.     PUSH    R8
  2747.     PUSH    R9
  2748.     PUSH    R15
  2749.  
  2750.     LD    R3,#$02        ; disp 2 8-byte segments 
  2751. A_LINE:
  2752.     LD    R2,#$08        ; assume full half lines 
  2753.     CP    R0,#$00        ; how much left to display? 
  2754.     JR    NZ,DO_LIN_SEG    ; enough for a line seg 
  2755.  
  2756.     CP    R1,#$08        ; 
  2757.     JR    NC,DO_LIN_SEG    ; ditto 
  2758.  
  2759.     CP    R1,#$00        ; any left at all 
  2760.     JR    Z,ALL_DISPED    ; no,just exit 
  2761.  
  2762.     LD    R2,R1        ; display partial line seg 
  2763. DO_LIN_SEG:
  2764.     SUB    R1,R2        ; adjust count 
  2765.     SBC    R0,#$00        ; subtract carry from hi byte 
  2766.  
  2767. HALFLINE:
  2768.     CALL    OUTADDR        ; line starts with address 
  2769.  
  2770. LINESEG:
  2771.     PUSH    R4        ; data 
  2772.     PUSH    R10        ; hi addr 
  2773.     PUSH    R11        ; lo addr 
  2774.     LD    R8,R10
  2775.     LD    R9,R11
  2776.     CALL    GETMEM        ; LDE    R15,@RR8 
  2777.     POP    R11        ; 
  2778.     POP    R10        ; 
  2779.     POP    R4        ; 
  2780.  
  2781.     LD    R4,R15
  2782.     CALL    OUTDAT        ; display 
  2783.     INCW    RR10        ; move pointer 
  2784.     DJNZ    R2,LINESEG    ; DJNZ    R2,LINESEG 
  2785.  
  2786.     CP    R3,#2        ; are we at midpoint? 
  2787.     JR    NE,NOT_MID
  2788.     LD    R4,#ASCIISP     ; yes, output 2 spaces 
  2789.     CALL    OUTCHR
  2790.     CALL    OUTCHR
  2791.  
  2792. NOT_MID:
  2793.     DJNZ    R3,A_LINE    ; DJNZ    R3,A_LINE 
  2794.  
  2795. ALL_DISPED:
  2796.     POP    R15
  2797.     POP    R9
  2798.     POP    R8
  2799.  
  2800.     RET            ; finished 
  2801.  
  2802.  
  2803.  
  2804.  
  2805. DISPASCII 
  2806. ;*****************************************************
  2807. ;*
  2808. ;*    DISPASCII  Display ASCII portion memory dump
  2809. ;*
  2810. ;*
  2811. ;*    input    RR12 point to segment to display
  2812. ;*        RR10 point to next segment
  2813. ;*
  2814. ;*    used    R4 for character output
  2815. ;*        R5 for counter
  2816. ;*
  2817. ;*    output    RR10 saved, ASCII displayed on console
  2818. ;*        RR12 = RR10
  2819. ;*        R4 = <LF>, and R5 = 0
  2820. ;*
  2821. ;*****************************************************;
  2822.     PUSH    R8
  2823.     PUSH    R9
  2824.     PUSH    R10        ; save pointer to next 
  2825.     PUSH    R11        ; segment in memory 
  2826.     PUSH    R15
  2827.  
  2828.     LD    R4,#ASCIISP    ; tab one space 
  2829.     CALL    OUTCHR
  2830.  
  2831.     SUB    R11,R13        ; how many were displayed? 
  2832.     CP    R11,#$10    ; was it a full line ? 
  2833.     JR    EQ,ASCOUT    ; output the ASCII 
  2834.  
  2835.     CP    R11,#$08    ; at least half a line ? 
  2836.     JR    GT,MTHALF    ; yes,more than half 
  2837.  
  2838.     LD    R5,#$05        ; put out extra spaces 
  2839.     LD    R4,#ASCIISP    ; 
  2840. SKIPHD:
  2841.     CALL    OUTCHR        ; 
  2842.     DJNZ    R5,SKIPHD    ; DJNZ    R5,SKIPHD 
  2843. MTHALF:
  2844.     PUSH    R11        ; save numberr displayed 
  2845.     COM    R11        ; get complement 
  2846.     AND    R11,#$0F    ; mask off upper nibble 
  2847.     INC    R11        ; increment for correct count 
  2848.                 ; now have # not displayed 
  2849.     LD    R4,#ASCIISP    ; put out 3 spaces for each 
  2850. OUT3SP:
  2851.     LD    R5,#$03        ; location in a line not displayed 
  2852. SPACE_3:
  2853.     CALL    OUTCHR        ; 
  2854.  
  2855.     DJNZ    R5,SPACE_3    ; DJNZ    R5,SPACE_3 
  2856.  
  2857.     DJNZ    R11,OUT3SP    ; DJNZ    R11,OUT3SP 
  2858.  
  2859.     POP    R11        ; get back number displayed 
  2860. ASCOUT:
  2861.     LD    R4,#ASCIISTAR    ; start displayed with a star 
  2862.     CALL    OUTCHR        ; 
  2863. PRINT_IT:
  2864.     PUSH    R4        ; data 
  2865.     PUSH    R12        ; hi addr 
  2866.     PUSH    R13        ; lo addr 
  2867.     LD    R8,R12
  2868.     LD    R9,R13
  2869.     CALL    GETMEM        ; LDE    R15,@RR8 
  2870.     POP    R13        ; 
  2871.     POP    R12        ; 
  2872.     POP    R4        ; 
  2873.  
  2874.     ; data is in R15 
  2875.     LD    R4,R15
  2876.     CP    R4,#ASCIISP    ; is it printable? 
  2877.     JR    GE,MAY_PRINT    ; maybe 
  2878. UN_PRINT:
  2879.     LD    R4,#ASCIIDOT    ; output a dot if not 
  2880.     JR    CAN_PRINT    ; a printable character 
  2881. MAY_PRINT:
  2882.     CP    R4,#$7F        ; it could be too large 
  2883.     JR    GE,UN_PRINT    ; so can't print it 
  2884. CAN_PRINT:
  2885.     CALL    OUTCHR        ; output the character 
  2886.                 ; be it a dot or ASCII 
  2887.     INCW    RR12        ; increment pointer 
  2888.  
  2889.     DJNZ    R11,PRINT_IT    ; DJNZ    R11,PRINT_IT 
  2890.  
  2891.     LD    R4,#ASCIISTAR    ; final star 
  2892.     CALL    OUTCHR        ; 
  2893.     CALL    CRLF        ; end of line 
  2894.     POP    R15        ; 
  2895.     POP    R11        ; restore pointer to nxt 
  2896.     POP    R10        ; segment of memory 
  2897.     POP    R9
  2898.     POP    R8
  2899.     RET            ; 
  2900.  
  2901.  
  2902.  
  2903.  
  2904. COMPDISP 
  2905. ;*******************************************************
  2906. ;*
  2907. ;*    COMPDISP
  2908. ;*
  2909. ;*    input    RR0 point to addr1
  2910. ;*        RR2 point to addr2
  2911. ;*        R14 has contents of RR0
  2912. ;*        R15 has contents of RR2
  2913. ;*
  2914. ;*    used    R8 (saved first) to point to R14,R15
  2915. ;*        R4 for character output
  2916. ;*        R5,R10,R11 for address output
  2917. ;*        R12 to point to registers RR0,RR2
  2918. ;*        R13 to count to 2
  2919. ;*
  2920. ;*    output    R8 preserved
  2921. ;*        R13 = 0
  2922. ;*        R5 = 0
  2923. ;*        R4 = <LF>
  2924. ;*        R12 points to R4
  2925. ;*        R10,R11 destroyed
  2926. ;*        RR0,RR2,R14,R15 unchanged
  2927. ;*
  2928. ;*****************************************************;
  2929.     PUSH    R8        ; used in calling routine 
  2930.  
  2931.     LD    R12,RP0        ; point to R0 with R12 
  2932.     LD    R8,R12        ; make R8 point to R14 
  2933.     ADD    R8,#14        ; to get the values 
  2934.     LD    R13,#$02    ; two values to display 
  2935.  
  2936. DISP_COMP:
  2937.     LD    R10,@R12    ; display address 
  2938.     INC    R12        ; 
  2939.     LD    R11,@R12    ; 
  2940.     INC    R12        ; 
  2941.  
  2942.     CALL    OUTADDR        ; line starts with address 
  2943.  
  2944.     LD    R4,#ASCIIEQ    ; connect with an equals 
  2945.     CALL    OUTCHR        ; 
  2946.     LD    R4,#ASCIISP    ; and space 
  2947.     CALL    OUTCHR        ; 
  2948.  
  2949.     LD    R4,@R8        ; get contents into R4 
  2950.     INC    R8        ; 
  2951.     CALL    OUTDAT        ; 
  2952.  
  2953.     DJNZ    R13,DISP_COMP    ; DJNZ    R13,disp_comp 
  2954.  
  2955.     CALL    CRLF        ; new line 
  2956.     POP    R8        ; restore 
  2957.     RET
  2958.  
  2959.  
  2960.  
  2961. DELAY 
  2962. ;*******************************************************
  2963. ;*
  2964. ;*    DELAY    kill time routine.
  2965. ;*
  2966. ;*    input    R4 has delay variable
  2967. ;*
  2968. ;*******************************************************;
  2969.     PUSH    R5
  2970.  
  2971. DELAY_LOOP:
  2972.     LD    R5,#$40
  2973. DELAY_R5:
  2974.     DJNZ    R5,DELAY_R5
  2975.     DJNZ    R4,DELAY_LOOP
  2976.  
  2977.     POP    R5
  2978.     RET
  2979.  
  2980.  
  2981. ;**********************************************
  2982. ;*
  2983. ;*    reg.s : Register display and edit
  2984. ;*         routines.
  2985. ;*
  2986. ;**********************************************;
  2987.  
  2988.  
  2989.  
  2990. CONSTANT
  2991. RW    equ    $00        ; read/write register 
  2992. WO    equ    $01        ; write only register 
  2993. RO    equ    $02        ; read only register 
  2994. UI    equ    $04        ; unimplemented register 
  2995.  
  2996.  
  2997. REGISTERS 
  2998. ;******************************************************
  2999. ;*
  3000. ;*    REGISTER display and alter
  3001. ;*
  3002. ;*    syntax    R [-S|C|SC] [<REG NUMBER> [<REG VALUE>]]
  3003. ;*
  3004. ;*    defaults    *
  3005. ;******************************************************;
  3006.     CLR    REG_MODE
  3007.  
  3008. ; look for SC option in command line 
  3009. ; GET_SC_OPT sets REG_MODE accordingly 
  3010.  
  3011.     CALL    GET_SC_OPT    ; look for SC options 
  3012.     CP    ERR_CODE,#BAD_OPT
  3013.     JR    EQ,DONE_REGISTER
  3014.  
  3015.     CALL    GETADDR        ; are there parameters? 
  3016.     JR    C,DISP_REGS    ; no, display all 
  3017.     PUSH    R11        ; save register number 
  3018.     CALL    GETADDR        ; is it a single command? 
  3019.     JP    C,EDIT_REG    ; no,scroll thru registers 
  3020.     POP    R9        ; get the reg number into R9 
  3021.  
  3022.     CALL    WRITE_1_REG    ; write value in R11 into 
  3023.                 ;   reg pointed to by R9 
  3024.     RET
  3025.  
  3026. DISP_REGS
  3027.     CP    ERR_CODE,#BAD_HEX ; was there a bad reg# ? 
  3028.     JR    EQ,DONE_REGISTER
  3029.  
  3030. ;    Display system registers
  3031.     TM    REG_MODE,#S_FLAG  ; display sys regs? 
  3032.     JR    Z,CNTRL_MODE    ; no 
  3033.     CALL    SYS_REG        ; yes 
  3034.     TM    REG_MODE,#C_FLAG  ; displaying control 
  3035.     JR    Z,DONE_REGISTER      ;   also?  no  
  3036.     CALL    CRLF        ; yes, so put an extra CR 
  3037.  
  3038. ;    Display control registers
  3039. CNTRL_MODE
  3040.     TM    REG_MODE,#C_FLAG  ; display ctl regs? 
  3041.     JR    Z,GEN_MODE    ; no 
  3042.     CALL    CNTR_REG    ; yes 
  3043.  
  3044. ;    Display general purpose registers
  3045. GEN_MODE
  3046.     TM    REG_MODE,#S_FLAG+C_FLAG ; display gen. regs? 
  3047.     JR    NZ,DONE_REGISTER  ; no 
  3048.     CALL    GEN_PURPOSE      ; yes 
  3049.  
  3050.     RET
  3051.  
  3052. EDIT_REG
  3053.     CALL    EDIT_STATUS    ; indicate to host edit mode 
  3054.  
  3055.     POP    R9        ; get the reg number into R9 
  3056.     CP    ERR_CODE,#BAD_HEX ; was there a bad reg value? 
  3057.     JR    EQ,DONE_REGISTER  ; yes 
  3058.  
  3059.     TM    REG_MODE,#S_FLAG  ; edit sys regs? 
  3060.     JP    NZ,EDIT_SYS    ; yes, JP to edit 
  3061.                 ; sys regs procedure 
  3062.  
  3063.     TM    REG_MODE,#C_FLAG  ; edit ctl regs? 
  3064.     JP    NZ,EDIT_CTL    ; yes, JP to edit 
  3065.                 ; ctl reg procedure 
  3066.  
  3067.     ; edit gen. regs? 
  3068.     TM    REG_MODE,#S_FLAG+C_FLAG
  3069.     JR    NZ,DONE_REGISTER  ; no 
  3070.     CALL    EDIT_GEN      ; yes 
  3071.  
  3072. DONE_REGISTER
  3073.     RET            ; stop the command 
  3074.  
  3075.  
  3076.  
  3077.  
  3078. WRITE_1_REG 
  3079. ;*****************************************************************
  3080. ;*
  3081. ;*    WRITE_1_REG    Write the value in R11 into the user
  3082. ;*            register pointed to by R9.
  3083. ;*
  3084. ;*    input:    R9 has the user register number to be written to.
  3085. ;*        R11 has the value to be written.
  3086. ;*        REG_MODE has the appropriate flags set for the
  3087. ;*        '-S' and '-C' options.
  3088. ;*
  3089. ;*    output:    If no errors are found, the value is written to
  3090. ;*        the user register.
  3091. ;*
  3092. ;*******************************************************************;
  3093.     TM    REG_MODE,#C_FLAG+S_FLAG
  3094.                 ; is it a sys or ctl register? 
  3095.     JR    NZ,WRITE_SC    ; yes 
  3096.  
  3097.     ; it's a general purpose register 
  3098.     CP    R9,#$C0        ; is register < $C0 ? 
  3099.     JR    ULT,WRITE_R    ; yes, write direct 
  3100.     JR    WRITE_IR    ; no, write indirect 
  3101.  
  3102. WRITE_SC
  3103.     CP    R9,#$C0        ; is it < $C0 ? 
  3104.     JR    ULT,ERR_WR1    ; yes, error 
  3105.     CP    R9,#$CF        ; is it > $CF ? 
  3106.     JR    UGT,WRITE_R    ; yes, write it 
  3107.  
  3108.     ; it's a "set one" Cx register 
  3109.     LD    D_MEMFLAG,#$FF    ; indicate a write 
  3110.     CALL    RD_WR_CX    ; to a Cx register 
  3111.     CLR    D_MEMFLAG
  3112.     JR    DONE_WR_1
  3113.  
  3114. WRITE_IR
  3115.     CALL    WRITE_IR_REG    ; write indirect 
  3116.     JR    DONE_WR_1
  3117.  
  3118. WRITE_R
  3119.     ; check for control register 
  3120.     CP    R9,#$E0        ; is it >= $E0? 
  3121.     JR    ULT,NO_BANK    ; no, a sys register 
  3122.  
  3123.     ; check for bank 0 
  3124.     TM    REG_MODE,#ZERO_FLAG ; bank zero ? 
  3125.     JR    Z,CHECK_BANK1    ; no 
  3126.  
  3127.     ; its a bank 0 register write 
  3128.     PUSH    R2        ; save R2 
  3129.     CLR    R2        ; a bank 0 register 
  3130.     LD    D_MEMFLAG,#$FF    ; a write 
  3131.     CALL    RD_WR_BANK    ; write it 
  3132.     POP    R2        ; restore R2 
  3133.     CLR    D_MEMFLAG
  3134.     JR    DONE_WR_1
  3135.  
  3136. CHECK_BANK1
  3137.     ; check for bank 1 
  3138.     TM    REG_MODE,#ONE_FLAG ; bank ONE ? 
  3139.     JR    Z,NO_BANK    ; no 
  3140.  
  3141.     ; its a bank 1 register write 
  3142.     PUSH    R2        ; save R2 
  3143.     LD    R2,#1        ; a bank 1 register 
  3144.     LD    D_MEMFLAG,#$FF    ; a write 
  3145.     CALL    RD_WR_BANK    ; write it 
  3146.     POP    R2        ; restore R2 
  3147.     CLR    D_MEMFLAG
  3148.     JR    DONE_WR_1
  3149.  
  3150.  
  3151. NO_BANK
  3152.     CALL    WRITE_DIR_REG   ; write direct 
  3153.  
  3154. DONE_WR_1
  3155.     RET
  3156.  
  3157. ERR_WR1
  3158.     LD    ERR_CODE,#BAD_PARAM_VAL
  3159.     JR    DONE_WR_1
  3160.  
  3161.  
  3162.  
  3163. GET_SC_OPT 
  3164. ;***********************************************************
  3165. ;*
  3166. ;*    GET_SC_OPT  Look at the command line for the
  3167. ;*        [-S | -C | -SC | -C0 | -C1] options.  Set
  3168. ;*        REG_MODE with the appropriate flags.
  3169. ;*
  3170. ;************************************************************;
  3171.  
  3172.     AND    REG_MODE,#GEN_FLAG ; assume no option 
  3173.     CALL    FINDOPT        ; look for option in command 
  3174.     CP    R10,#0        ; is there no option 
  3175.     JR    EQ,DONE_SC
  3176.  
  3177.     CP    R10,#ASCIISP    ; just a " " following "-" ? 
  3178.     JR    EQ,SC_ERROR
  3179.  
  3180.     CP    R10,#ASCIICR    ; just a <CR> following "-" ? 
  3181.     JR    EQ,SC_ERROR
  3182.  
  3183.     ; check for option in R10 
  3184.     CP    R10,#'s'    ; check R10 for 's' opt 
  3185.     JR    NE,R10_NOT_S
  3186.     OR    REG_MODE,#S_FLAG
  3187.     JR    CHECK_R11
  3188.  
  3189. R10_NOT_S
  3190.     CP    R10,#'c'    ; if its not a 'c' and 
  3191.     JR    NE,SC_ERROR    ; not an 's', its an error 
  3192.     OR    REG_MODE,#C_FLAG
  3193.  
  3194. CHECK_R11
  3195.     ; check for option in R10 
  3196.     CP    R11,#ASCIISP    ; check for a space 
  3197.     JR    EQ,DONE_SC
  3198.     CP    R11,#ASCIICR    ; check for a CR 
  3199.     JR    EQ,DONE_SC
  3200.  
  3201.     CP    R11,#'s'    ; check R11 for 's' opt 
  3202.     JR    NE,R11_NOT_S
  3203.     OR    REG_MODE,#S_FLAG
  3204.     JR    DONE_SC
  3205.  
  3206. R11_NOT_S
  3207.     CP    R11,#'c'    ; check for 'c' option 
  3208.     JR    NE,R11_NOT_C    ; not an 's' 
  3209.     OR    REG_MODE,#C_FLAG
  3210.     JR    DONE_SC
  3211.  
  3212. R11_NOT_C
  3213.     CP    R11,#'0'    ; a 0 ? 
  3214.     JR    NE,R11_NOT_0    ; not a '0' 
  3215.     CP    R10,#'c'    ; was 1st opt a 'c'? 
  3216.     JR    NE,SC_ERROR    ; no, error 
  3217.     OR    REG_MODE,#ZERO_FLAG  ; yes, set flag 
  3218.     JR    DONE_SC
  3219.  
  3220. R11_NOT_0
  3221.     CP    R11,#'1'    ; a 1 ? 
  3222.     JR    NE,SC_ERROR    ; not a '1' 
  3223.     CP    R10,#'c'    ; was 1st opt a 'c'? 
  3224.     JR    NE,SC_ERROR    ; no, error 
  3225.     OR    REG_MODE,#ONE_FLAG  ; yes, set flag 
  3226.  
  3227. DONE_SC
  3228.     RET
  3229.  
  3230. SC_ERROR
  3231.     CLR    REG_MODE
  3232.     LD    ERR_CODE,#BAD_OPT
  3233.     JR    DONE_SC
  3234.  
  3235.  
  3236.  
  3237.  
  3238. EDIT_GEN 
  3239. ;*************************************************************
  3240. ;*
  3241. ;*    EDIT_GEN  Edit the general purpose registers
  3242. ;*
  3243. ;*    input: starting register number is in R9
  3244. ;*
  3245. ;*
  3246. ;***************************************************************;
  3247.     CLR    ERR_CODE    ; NOT AN ERROR 
  3248.  
  3249. DISP_1_REG
  3250.     LD    R4,R9        ; display the register value 
  3251.     CALL    OUTDAT        ; 
  3252.  
  3253.     PUSH    R9        ; save reg number 
  3254.     CP    R9,#$C0        ; set two register? 
  3255.     JR    UGE,IR_READ    ; yes 
  3256.  
  3257.     CALL    READ_DIR_REG    ; read reg. number R9 
  3258.     JR    READ_RESULT
  3259.  
  3260. IR_READ
  3261.     CALL    READ_IR_REG    ; read set two reg. number R9 
  3262.  
  3263. READ_RESULT
  3264.     LDC    R4,@RR6        ; display the register contents 
  3265.     CALL    OUTDAT        ; 
  3266.     POP    R9        ; restore reg number  
  3267.  
  3268.     ; prompt for a new value, package STX and ETX around 
  3269.     ;   prompt for the host package 
  3270.     LD    R4,#ASCIISTX
  3271.     CALL    OUTCHR
  3272.     LD    R4,#'+'        ; prompt for a new value 
  3273.     CALL    OUTCHR        ; 
  3274.     LD    R4,#ASCIIETX
  3275.     CALL    OUTCHR
  3276.  
  3277.     CALL    GETLINE        ; input response up to <CR> 
  3278.  
  3279. REG_TOKEN
  3280.     CP    R4,#ASCIIQ    ; is it a quit? 
  3281.     JR    Z,END_REG    ; stop the command sequence 
  3282.  
  3283.     CP    R4,#'q'        ; is it a quit? 
  3284.     JR    Z,END_REG    ; stop the command sequence 
  3285.  
  3286.     CP    R4,#ASCIIUP    ; is it an ^ 
  3287.     JR    NZ,REG_DOT    ; if not check for dot 
  3288.     DEC    R9        ; it is a ^,do previous 
  3289.     JR    DISP_1_REG    ; display previous register 
  3290. REG_DOT
  3291.     CP    R4,#ASCIIDOT    ; dot displays same 
  3292.     JR    Z,DISP_1_REG    ; 
  3293.  
  3294.     CP    R4,#ASCIICR    ; just display next? 
  3295.     JR    NZ,NEW_REG_VAL    ; no, convert the number 
  3296.     JR    MORE_REG    ; 
  3297.  
  3298. NEW_REG_VAL
  3299.     CLR    R10        ; 
  3300.     CLR    R11        ; 
  3301.     CALL    CON_BYTE    ; convert 
  3302.     JR    C,END_REG    ; error 
  3303.  
  3304.     CP    R9,#$C0        ; a set two register? 
  3305.     JR    UGE,WRITE_IND    ; yes 
  3306.  
  3307.     CALL    WRITE_DIR_REG    ; no, write R11 into R9 
  3308.     JR    WROTE_REG
  3309.  
  3310. WRITE_IND
  3311.     CALL    WRITE_IR_REG    ; write R11 into R9 
  3312.                 ;   (set two)  
  3313.  
  3314. WROTE_REG
  3315.     CALL    FINDNEXT    ; is there a token also?
  3316.     JR    NZ,REG_TOKEN    ; yes,there is more on the line 
  3317. MORE_REG
  3318.     INC    R9        ; increment register pointer
  3319.     JP    DISP_1_REG    ; display the nest register 
  3320.  
  3321. END_REG
  3322.     RET            ; stop the command 
  3323.  
  3324.  
  3325.  
  3326. EDIT_SYS 
  3327. ;*************************************************************
  3328. ;*
  3329. ;*    EDIT_SYS  Edit the system registers
  3330. ;*
  3331. ;*
  3332. ;*    input: starting register number is in R9
  3333. ;*
  3334. ;***************************************************************;
  3335.     CLR    ERR_CODE    ; NOT AN ERROR 
  3336.  
  3337.     CP    R9,#$D0        ; too low for a sys reg.? 
  3338.     JR    UGE,CHK_SYS_HI  ; no 
  3339.     LD    ERR_CODE,#BAD_PARAM_VAL ; yes 
  3340.     JR    END_SYS_ED
  3341.  
  3342. CHK_SYS_HI
  3343.     CP    R9,#$DE        ; too high for a sys reg.? 
  3344.     JR    ULE,DISP_1_SYS  ; no 
  3345.     LD    ERR_CODE,#BAD_PARAM_VAL ; yes 
  3346.     JR    END_SYS_ED
  3347.  
  3348. DISP_1_SYS
  3349.     LD    R4,R9        ; display the register value 
  3350.     CALL    OUTDAT        ; 
  3351.  
  3352.     CALL    READ_DIR_REG    ; read reg pointed to by R9 
  3353.  
  3354.     LDC    R4,@RR6        ; display the register contents 
  3355.     CALL    OUTDAT        ; 
  3356.  
  3357.     ; prompt for a new value, package STX and ETX around 
  3358.     ;   prompt for the host package 
  3359.     LD    R4,#ASCIISTX
  3360.     CALL    OUTCHR
  3361.     LD    R4,#'+'        ; prompt for a new value 
  3362.     CALL    OUTCHR        ; 
  3363.     LD    R4,#ASCIIETX
  3364.     CALL    OUTCHR
  3365.  
  3366.     CALL    GETLINE        ; input response up to <CR> 
  3367.  
  3368.  
  3369. SYS_TOKEN
  3370.     CP    R4,#ASCIIQ    ; is it a quit? 
  3371.     JR    Z,END_SYS_ED    ; stop the command sequence 
  3372.  
  3373.     CP    R4,#'q'        ; is it a quit? 
  3374.     JR    Z,END_SYS_ED    ; stop the command sequence 
  3375.  
  3376.     CP    R4,#ASCIIUP    ; is it an ^ 
  3377.     JR    NZ,SYS_DOT    ; if not check for dot 
  3378.     DEC    R9        ; it is a ^,do previous 
  3379.     CP    R9,#$CF        ; at boundry? 
  3380.     JR    UGT,DISP_1_SYS  ; no 
  3381.     LD    R9,#$DE        ; yew 
  3382.     JR    DISP_1_SYS    ; display previous register 
  3383. SYS_DOT
  3384.     CP    R4,#ASCIIDOT    ; dot displays same 
  3385.     JR    Z,DISP_1_SYS    ; 
  3386.  
  3387.     CP    R4,#ASCIICR    ; just display next? 
  3388.     JR    NZ,NEW_SYS_VAL    ; no, convert the number
  3389.     JR    MORE_SYS    ; 
  3390. NEW_SYS_VAL
  3391.     CLR    R10        ;  
  3392.     CLR    R11        ; 
  3393.     CALL    CON_BYTE    ; convert 
  3394.     JR    C,END_SYS_ED    ; error 
  3395.     CALL    WRITE_DIR_REG    ; write R11 into R9 
  3396.     CALL    FINDNEXT    ; is there a token also 
  3397.     JR    NZ,SYS_TOKEN    ; yes,there is more on the line 
  3398. MORE_SYS
  3399.     INC    R9        ; indrement pointer to reg 
  3400.     CP    R9,#$DF        ; at boundry ? 
  3401.     JP    ULT,DISP_1_SYS  ; no 
  3402.     LD    R9,#$D0        ; yes 
  3403.     JP    DISP_1_SYS    ; display the next register 
  3404.  
  3405. END_SYS_ED
  3406.     RET            ; stop the command 
  3407.  
  3408.  
  3409.  
  3410.  
  3411. EDIT_CTL 
  3412. ;*************************************************************
  3413. ;*
  3414. ;*    EDIT_CTL  Edit the control registers
  3415. ;*
  3416. ;*
  3417. ;*    input: starting register number is in R9
  3418. ;*
  3419. ;***************************************************************;
  3420.     PUSH    R2
  3421.  
  3422.     ; check for start bank 
  3423.     TM    REG_MODE,#ONE_FLAG ; bank one? 
  3424.     JR    Z,ITS_BANK2    ; no 
  3425.     LD    R2,#1        ; yes, set number 
  3426.     JR    CLEAR_ERR
  3427.  
  3428. ITS_BANK2
  3429.     CLR    R2        ; bank number starts with 0 
  3430.  
  3431. CLEAR_ERR
  3432.     CLR    ERR_CODE    ; not an error 
  3433.  
  3434.     ; check for reg number between $C0 and $CF 
  3435.     CP    R9,#$C0        ; reg number < $C0 ? 
  3436.     JP    ULT,CTL_BAD_PARAM  ; yes 
  3437.     CP    R9,#$CF        ; reg number <= $CF ? 
  3438.     JR    ULE,DISP_1_CTL  ; yes 
  3439.  
  3440.     ; check for reg number between $E0 and $CF 
  3441.     CP    R9,#$E0        ; reg number < $E0 ? 
  3442.     JP    ULT,CTL_BAD_PARAM  ; yes 
  3443.  
  3444. DISP_1_CTL
  3445.     LD    R4,R9        ; display the register number 
  3446.     CALL    OUTHEX        ; 
  3447.  
  3448.     ; display the bank number if in range $E0 - $FF 
  3449.     CP    R9,#$CF        ; a control register? 
  3450.     JR    ULE,CX_REG    ; no, a Cx register 
  3451.  
  3452.     LD    R4,#'/'        ; display bank number 
  3453.     CALL    OUTCHR
  3454.     LD    R4,R2        ; save bank # in R4 
  3455.     LD    R6,#REGBUF
  3456.     CALL    BTOHEXDAT    ; convert to ASCII 
  3457.     LD    R4,REGBUF+1     ; get least sig. digit 
  3458.     CALL    OUTCHR        ; print it 
  3459.     LD    R4,#ASCIISP
  3460.     CALL    OUTCHR
  3461.  
  3462.     CLR    D_MEMFLAG    ; indicate a read 
  3463.     CALL    RD_WR_BANK    ; read reg pointed to by R9 
  3464.     LD    R4,R10        ; R10 has the value 
  3465.  
  3466.     JR    OUT_REG
  3467.  
  3468. CX_REG
  3469.     LD    R4,#ASCIISP    ; write out a space 
  3470.     CALL    OUTCHR
  3471.  
  3472.     CALL    RD_WR_CX    ; Cx reg pointed to by 
  3473.                 ;   R9 and load its value 
  3474.                 ;   into R4 
  3475.  
  3476. OUT_REG
  3477.     CALL    OUTDAT        ; display register vlaue 
  3478.  
  3479.     ; prompt for a new value, package STX and ETX around 
  3480.     ;   prompt for the host package 
  3481.     LD    R4,#ASCIISTX
  3482.     CALL    OUTCHR
  3483.     LD    R4,#'+'        ; prompt for a new value 
  3484.     CALL    OUTCHR        ; 
  3485.     LD    R4,#ASCIIETX
  3486.     CALL    OUTCHR
  3487.  
  3488.     CALL    GETLINE        ; input response up to <CR> 
  3489.  
  3490. CTL_TOKEN
  3491.     CP    R4,#ASCIIQ    ; is it a quit? 
  3492.     JP    Z,END_CTL_ED    ; stop the command sequence 
  3493.  
  3494.     CP    R4,#'q'        ; is it a quit? 
  3495.     JP    Z,END_CTL_ED    ; stop the command sequence 
  3496.  
  3497.     CP    R4,#ASCIIUP    ; is it an ^ 
  3498.     JR    NZ,CTL_DOT    ; if not check for dot 
  3499.     DEC    R9        ; it is a ^,do previous 
  3500.     CP    R9,#$DF        ; past $E0 boundry? 
  3501.     JR    EQ,TO_CF      ; yes, skip to $CF 
  3502.     CP    R9,#$BF        ; past $C0 boundry? 
  3503.     JP    NE,DISP_1_CTL     ; no, display previous 
  3504.  
  3505.     ; wrap around and change bank numbers 
  3506.     LD    R9,#$FF        ; start at $FF again 
  3507.     CP    R2,#0        ; bank 0? 
  3508.     JR    EQ,TO_BANK1    ; yes 
  3509.     LD    R2,#0        ; no, set to 0 
  3510.     JP    DISP_1_CTL
  3511.  
  3512. TO_BANK1
  3513.     LD    R2,#1        ; set to 1 
  3514.     JP    DISP_1_CTL
  3515.  
  3516. TO_CF
  3517.     LD    R9,#$CF        ; start at $CF 
  3518.     JP    DISP_1_CTL
  3519.  
  3520. CTL_DOT
  3521.     CP    R4,#ASCIIDOT    ; dot displays same 
  3522.     JP    Z,DISP_1_CTL    ; 
  3523.  
  3524.     CP    R4,#ASCIICR    ; just display next? 
  3525.     JR    NZ,NEW_CTL_VAL    ; no, convert the number 
  3526.     JR    MORE_CTL    ; 
  3527. NEW_CTL_VAL
  3528.     CLR    R10        ; 
  3529.     CLR    R11        ; 
  3530.     CALL    CON_BYTE    ; convert 
  3531.     JR    C,END_CTL_ED    ; error 
  3532.  
  3533.     ; write value in R11 into register pointed to by R9 
  3534.     CP    R9,#$CF        ; a Cx register? 
  3535.     JR    ULE,WR_CX_REG    ; yes 
  3536.  
  3537.     LD    D_MEMFLAG,#$FF    ; indicate a write 
  3538.     CALL    RD_WR_BANK    ; no, normal write 
  3539.     CLR    D_MEMFLAG
  3540.     JR    NEXT_FIND
  3541.  
  3542. WR_CX_REG
  3543.     LD    D_MEMFLAG,#$FF    ; indicate a write 
  3544.     CALL    RD_WR_CX    ;   to a Cx reg. 
  3545.     CLR    D_MEMFLAG
  3546.  
  3547. NEXT_FIND
  3548.     CALL    FINDNEXT    ; is there a token also 
  3549.     JR    NZ,CTL_TOKEN    ; yes,there's more on the line
  3550. MORE_CTL
  3551.     CP    R9,#$CF        ; at $CF boundry ? 
  3552.     JR    EQ,TO_E0    ; yes, next is $E0 
  3553.  
  3554.     CP    R9,#$FF        ; at $FF boundry ? 
  3555.     JR    ULT,INC_CTL_ED  ; no 
  3556.  
  3557.     ; wrap around and change bank number 
  3558.     LD    R9,#$C0        ; yes, prepare for $C0 
  3559.     CP    R2,#1        ; bank 1? 
  3560.     JR    EQ,TO_BANK0    ; yes 
  3561.     LD    R2,#1        ; no, set to 1 
  3562.     JP    DISP_1_CTL
  3563.  
  3564. TO_BANK0
  3565.     LD    R2,#0        ; set to 0 
  3566.     JP    DISP_1_CTL
  3567.  
  3568. INC_CTL_ED
  3569.     INC    R9        ; indrement register pointer
  3570.     JP    DISP_1_CTL    ; display the next register 
  3571.  
  3572. TO_E0
  3573.     LD    R9,#$E0        ; new register is $E0 
  3574.     JP    DISP_1_CTL
  3575.  
  3576. END_CTL_ED
  3577.     ; restore user flag register 
  3578.     PUSH    R9
  3579.     PUSH    R11
  3580.     LD    R9,#$D5        ; flag reg number 
  3581.     LD    R11,USER_FLAGS  ; flag reg value 
  3582.     CALL    WRITE_DIR_REG    ; write it 
  3583.     POP    R11
  3584.     POP    R9
  3585.  
  3586.     POP    R2
  3587.     RET
  3588.  
  3589. CTL_BAD_PARAM
  3590.     LD    ERR_CODE,#BAD_PARAM_VAL
  3591.     JR    END_CTL_ED
  3592.  
  3593.  
  3594.  
  3595. RD_WR_CX 
  3596. ;*************************************************************
  3597. ;*
  3598. ;*    RD_WR_CX    Read/write a "set one" register in the
  3599. ;*            range $C0 - $CF.
  3600. ;*
  3601. ;*    input:    R9 has the register number to be read.
  3602. ;*        D_MEMFLAG is 0 for a read and $FF for a write.
  3603. ;*        R11 has the value to be written for a write.
  3604. ;*
  3605. ;*    output: R4 has the register value for a read.
  3606. ;*
  3607. ;*************************************************************;
  3608.  
  3609.     PUSH    R9        ; save reg number 
  3610.     PUSH    R11        ; save value 
  3611.  
  3612.     ; read RP0 and RP1 and save them 
  3613.     LD    R9,#$D6        ; RP0
  3614.     CALL    READ_DIR_REG    ; read it 
  3615.     LDC    R4,@RR6
  3616.     LD    USER_RP0,R4    ; save it 
  3617.  
  3618.     LD    R9,#$D7        ; RP1
  3619.     CALL    READ_DIR_REG    ; read it 
  3620.     LDC    R4,@RR6
  3621.     LD    USER_RP1,R4    ; save it 
  3622.  
  3623.     ; write $C0 and $C8 to RP0 and RP1 
  3624.     LD    R9,#$D6        ; RP0
  3625.     LD    R11,#$C0    ; gets $C0
  3626.     CALL    WRITE_DIR_REG    ; write it 
  3627.     LD    R9,#$D7        ; RP1
  3628.     LD    R11,#$C8    ; gets $C8
  3629.     CALL    WRITE_DIR_REG    ; write it 
  3630.  
  3631.  
  3632.     ; now read/write the register 
  3633.     POP    R11        ; restore reg value 
  3634.     POP    R9        ; restore reg number 
  3635.  
  3636.     CP    D_MEMFLAG,#0    ; is it a read? 
  3637.     JR    EQ,READ_CX    ; yes 
  3638.  
  3639.     CALL    WRITE_DIR_REG    ; write it 
  3640.     JR    RESTORE_CX
  3641.  
  3642. READ_CX
  3643.     CALL    READ_DIR_REG    ; read it 
  3644.     LDC    R4,@RR6        ; save it 
  3645.  
  3646.     ; restore RP0 and RP1 
  3647. RESTORE_CX
  3648.     PUSH    R9        ; save reg number 
  3649.     PUSH    R11        ; save value 
  3650.     LD    R9,#$D6        ; RP0
  3651.     LD    R11,USER_RP0
  3652.     CALL    WRITE_DIR_REG    ; write it 
  3653.  
  3654.     LD    R9,#$D7        ; RP1
  3655.     LD    R11,USER_RP1
  3656.     CALL    WRITE_DIR_REG    ; write it 
  3657.     POP    R11        ; restore reg value 
  3658.     POP    R9        ; restore reg number 
  3659.  
  3660.     RET
  3661.  
  3662.  
  3663.  
  3664. SYS_REG 
  3665. ;*************************************************************
  3666. ;*
  3667. ;*    SYS_REG  Display all system registers
  3668. ;*
  3669. ;***************************************************************;
  3670.  
  3671.     CLR    ERR_CODE    ; clear errors 
  3672.  
  3673. ; display 1st row of PC and system registers 
  3674.     LD    R6,#^HB SYS1_H_REG ; print 1st nmemonic 
  3675.     LD    R7,#^LB SYS1_H_REG ;   header for system 
  3676.     CALL    OUTMSG        ;     registers 
  3677.  
  3678.     LD    R6,#^HB SYS1_N_REG ; print the register 
  3679.     LD    R7,#^LB SYS1_N_REG ;   numbers 
  3680.     CALL    OUTMSG        ; 
  3681.  
  3682.     ld    r10,USERPC_HI    ; Print
  3683.     ld    r11,USERPC_LO    ;   user
  3684.     call    OUTADDR        ;     PC
  3685.     LD    R4,#ASCIISP    ; tab 1 space 
  3686.     CALL    OUTCHR
  3687.  
  3688.     LD    R9,#$D0        ; display start 
  3689.     LD    R10,#$D6    ; display end 
  3690.     CALL    SYS_OUT        ; display the regs 
  3691.     CALL    CRLF        ; 
  3692.     CALL    CRLF        ; one blank line 
  3693.  
  3694. ; display 2nd row of system registers 
  3695.     LD    R6,#^HB SYS2_H_REG ; print 2nd nmemonic 
  3696.     LD    R7,#^LB SYS2_H_REG ;   header for system 
  3697.     CALL    OUTMSG        ;     registers 
  3698.     LD    R6,#^HB SYS2_N_REG ; print the register 
  3699.     LD    R7,#^LB SYS2_N_REG ;   numbers 
  3700.     CALL    OUTMSG        ; for input 
  3701.  
  3702.     LD    R9,#$D7        ; display start 
  3703.     LD    R10,#$DE    ; display end 
  3704.     CALL    SYS_OUT        ; display the regs 
  3705.     CALL    CRLF        ; 
  3706.     RET
  3707.  
  3708.  
  3709. GEN_PURPOSE 
  3710. ;*************************************************************
  3711. ;*
  3712. ;*    GEN_PURPOSE  Display all general purpose registers
  3713. ;*
  3714. ;***************************************************************;
  3715.     PUSH    R6
  3716.     PUSH    R7
  3717.     PUSH    R9
  3718.     PUSH    R10
  3719.     PUSH    R11
  3720.     PUSH    R12
  3721.  
  3722. ; R12 has the leading character, a 'R' (working register) 
  3723. ;   or ' '.  Space is the default 
  3724.  
  3725.     LD    R12,#' '
  3726.     CLR    R9        ; register counter 
  3727.     LD    R6,#^HB GEN_REG_H ; print the register 
  3728.     LD    R7,#^LB GEN_REG_H ;   numbers header
  3729.     CALL    OUTMSG        ; for input 
  3730.  
  3731. GEN_LOOP
  3732.  
  3733.     PUSH    R9        ; save reg number 
  3734.     CP    R9,#$C0        ; set two register? 
  3735.     JR    UGE,GEN_READ_IR    ; yes 
  3736.  
  3737.     CALL    READ_DIR_REG    ; read (direct) reg. number R9 
  3738.     JR    GEN_GET_RESULT
  3739.  
  3740. GEN_READ_IR
  3741.     CALL    READ_IR_REG    ; read set two (indirect) reg. number R9 
  3742.  
  3743. GEN_GET_RESULT
  3744.     ; RR6 now points to result register 
  3745.     LDC    R10,@RR6    ; save register value 
  3746.                 ; in R10 
  3747.     POP    R9        ; restore reg number 
  3748.  
  3749.     TM    R9,#$0F        ; R9 = x0 ? 
  3750.     JR    NZ,CHECK_RP    ; no 
  3751.  
  3752.     ; write out high nibble for row 
  3753.     CALL    CRLF
  3754.     LD    R4,#'r'        ; write 'r' 
  3755.     CALL    OUTCHR
  3756.  
  3757.     LD    R6,#OUT_CHR1    ; destination of NIBBLE
  3758.     LD    R4,R9        ; load reg number 
  3759.     SWAP    R4        ; put upper nibble in lower
  3760.     CALL    NIBBLE        ; convert to ASCII 
  3761.     LD    R4,OUT_CHR1    ; write it 
  3762.     CALL    OUTCHR
  3763.  
  3764.     LD    R4,#'x'        ; write 'x' 
  3765.     CALL    OUTCHR
  3766.     LD    R4,#ASCIISP    ; write ' ' 
  3767.     CALL    OUTCHR
  3768.     CALL    OUTCHR
  3769.     CALL    OUTCHR        ; 3 times 
  3770.  
  3771. CHECK_RP
  3772.     TM    R9,#$07        ; are we at an 8th reg? 
  3773.     JR    NZ,WRITE_IT    ; no 
  3774.  
  3775.     CP    R9,USER_RP0    ; equal to RP0 ? 
  3776.     JR    NE,CHECK_RP1    ; no, check RP1 
  3777.  
  3778.     CP    R9, #$C0    ; are we still in register area? 
  3779.     JR    UGE, CHECK_RP1
  3780.  
  3781.     LD    R12,#'R'    ; yes, output leading 'R'
  3782.     JR    WRITE_IT
  3783.  
  3784. CHECK_RP1
  3785.     CP    R9,USER_RP1    ; equal to RP1 ? 
  3786.     JR    NE, NOT_RP    ; no 
  3787.  
  3788.     CP    R9, #$C0    ; are we still in register area? 
  3789.     JR    UGE, NOT_RP
  3790.  
  3791.     LD    R12,#'R'    ; yes, output leading 'R'
  3792.     JR    WRITE_IT
  3793.  
  3794. NOT_RP
  3795.     LD    R12,#' '    ; yes, output leading 'R'
  3796.  
  3797. WRITE_IT
  3798.     LD    R4,R12        ; output a leading 
  3799.     CALL    OUTCHR        ;   'R' or ' ' 
  3800.     LD    R4,R10        ; register value in R4 
  3801.     LD    R6,#OUT_CHR1    ; dest of BTOHEXDAT 
  3802.     CALL    BTOHEXDAT
  3803.  
  3804.     LD    R4,OUT_CHR1    ; print high nibble 
  3805.     CALL    OUTCHR
  3806.     LD    R4,OUT_CHR2    ; print low nibble 
  3807.     CALL    OUTCHR
  3808.  
  3809.     LD    R4,#ASCIISP    ; a trailing ' ' 
  3810.     CALL    OUTCHR
  3811.  
  3812.     INC    R9        ; next register 
  3813.     CP    R9,#0        ; are we done? 
  3814.     JR    EQ,DONE_GEN    ; yes 
  3815.     JP    GEN_LOOP    ; no, continue 
  3816.  
  3817. DONE_GEN
  3818.     CALL    CRLF
  3819.     CLR    ERR_CODE
  3820.     POP    R12
  3821.     POP    R11
  3822.     POP    R10
  3823.     POP    R9
  3824.     POP    R7
  3825.     POP    R6
  3826.     RET
  3827.  
  3828.  
  3829. CNTR_REG 
  3830. ;*************************************************************
  3831. ;*
  3832. ;*    CNTR_REG  Display all control and mode registers
  3833. ;*
  3834. ;***************************************************************;
  3835.  
  3836.     CLR    ERR_CODE    ; clear errors 
  3837.  
  3838.     AND    CFLAG,#$F8    ; clear errors 
  3839.  
  3840. ; display 1st row of control and mode registers 
  3841.  
  3842.     LD    R6,#^HB CTL1_H_REG ; print 1st nmemonic 
  3843.     LD    R7,#^LB CTL1_H_REG ;   header for control 
  3844.     CALL    OUTMSG        ;     registers 
  3845.  
  3846.     LD    R6,#^HB CTL1_N_REG ; print the register 
  3847.     LD    R7,#^LB CTL1_N_REG ;   numbers 
  3848.     CALL    OUTMSG        ; 
  3849.  
  3850.     LD    R9,#$E0        ; display start 
  3851.     LD    R10,#$F0    ; display end 
  3852.     LD    R11,#0        ; bank 0 
  3853.     CALL    CNTRL_OUT    ; display the regs 
  3854.     CALL    CRLF
  3855.     CALL    CRLF        ; one blank line 
  3856.  
  3857. ; display 2nd row of control and mode registers 
  3858.  
  3859.     LD    R6,#^HB CTL2_H_REG ; print 2nd nmemonic 
  3860.     LD    R7,#^LB CTL2_H_REG ;   header for control 
  3861.     CALL    OUTMSG        ;     registers 
  3862.  
  3863.     LD    R6,#^HB CTL2_N_REG ; print the register 
  3864.     LD    R7,#^LB CTL2_N_REG ;   numbers 
  3865.     CALL    OUTMSG        ; 
  3866.  
  3867.     LD    R9,#$F6        ; display start 
  3868.     LD    R10,#$FF    ; display end 
  3869.     LD    R11,#0        ; bank 0 
  3870.     CALL    CNTRL_OUT    ; display the regs 
  3871.  
  3872. ; last 4 regs of row 2 are bank 1 registers 
  3873.  
  3874.     LD    R9,#$E0        ; display start 
  3875.     LD    R10,#$E3    ; display end 
  3876.     LD    R11,#1        ; bank 1 
  3877.     CALL    CNTRL_OUT    ; display the regs 
  3878.  
  3879.     CALL    CRLF
  3880.     CALL    CRLF        ; one blank line 
  3881.  
  3882. ; display 3rd row of control and mode registers 
  3883.  
  3884.     LD    R6,#^HB CTL3_H_REG ; print 3rd nmemonic 
  3885.     LD    R7,#^LB CTL3_H_REG ;   header for control 
  3886.     CALL    OUTMSG        ;     registers 
  3887.  
  3888.     LD    R6,#^HB CTL3_N_REG ; print the register 
  3889.     LD    R7,#^LB CTL3_N_REG ;   numbers 
  3890.     CALL    OUTMSG        ; 
  3891.  
  3892.     LD    R9,#$E4        ; display start 
  3893.     LD    R10,#$FF    ; display end 
  3894.     LD    R11,#1        ; bank 1 
  3895.     CALL    CNTRL_OUT    ; display the regs 
  3896.  
  3897.     CALL    CRLF
  3898.     CALL    CRLF        ; one blank line 
  3899.  
  3900. ; display 4th row (Cx) registers 
  3901.  
  3902.     LD    R6,#^HB CTL4_N_REG ; print 3rd register 
  3903.     LD    R7,#^LB CTL4_N_REG ;   numbers 
  3904.     CALL    OUTMSG        ; 
  3905.  
  3906.     LD    R9,#$C0        ; display start 
  3907.     LD    R10,#$CF    ; display end 
  3908.     CALL    SYS_OUT        ; display the regs 
  3909.     CALL    CRLF
  3910.  
  3911.     RET
  3912.  
  3913.  
  3914.  
  3915. SYS_OUT 
  3916. ;*******************************************************
  3917. ;*
  3918. ;*    SYS_OUT  Print out system or Cx  registers.
  3919. ;*
  3920. ;*    input  R9  contains 1st register to be displayed.
  3921. ;*           R10 contains last register to be displayed.
  3922. ;*           R9 and R10 are in the range $C0 to $DE.
  3923. ;*           R9 <= R10.
  3924. ;*          
  3925. ;*************************************************************;
  3926.  
  3927. SYS_LOOP
  3928.     CALL    READ_DIR_REG    ; read S8 reg. @R9 
  3929.     ; RR6 now points to result register 
  3930.     LDC    R4,@RR6        ; save the value 
  3931.  
  3932.     LD    R6,#OUT_CHR1    ; dest of BTOHEXDAT 
  3933.     CALL    BTOHEXDAT
  3934.  
  3935.     LD    R4,OUT_CHR1    ; print high nibble 
  3936.     CALL    OUTCHR
  3937.     LD    R4,OUT_CHR2    ; print low nibble 
  3938.     CALL    OUTCHR
  3939.  
  3940.     LD    R4,#ASCIISP    ; 2 trailing ' 's 
  3941.     CALL    OUTCHR        ;   for rCx regs. 
  3942.     CALL    OUTCHR
  3943.     CP    R9,#$D0        ; rCx registers? 
  3944.     JR    LT,CHECK_DONE    ; yes 
  3945.  
  3946.     CALL    OUTCHR        ; 4 trailing ' 's 
  3947.     CALL    OUTCHR        ;   for sys regs. 
  3948.  
  3949. CHECK_DONE
  3950.     CP    R9,R10        ; are we through 
  3951.     JR    EQ,SYS_DONE
  3952.  
  3953.     INC    R9        ; next register 
  3954.     JR    SYS_LOOP
  3955.  
  3956. SYS_DONE
  3957.     RET
  3958.  
  3959.  
  3960.  
  3961. CNTRL_OUT 
  3962. ;*******************************************************
  3963. ;*
  3964. ;*    CNTRL_OUT  Print out control registers.
  3965. ;*            Skip over unimplemented or
  3966. ;*            write only registers.
  3967. ;*
  3968. ;*    input  R9  contains 1st register to be displayed.
  3969. ;*           R10 contains last register to be displayed.
  3970. ;*           R9 and R10 are in the range $E0 to $FF.
  3971. ;*           R9 <= R10.
  3972. ;*           R11 contains bank number to be displayed.
  3973. ;*          
  3974. ;*************************************************************;
  3975.     PUSH    R8
  3976.     PUSH    R12
  3977.     PUSH    R13
  3978.  
  3979.     LD    R8,R9        ; save start reg. 
  3980.  
  3981. ; Now, do we want Bank 0 or 1 registers ?
  3982.  
  3983.     CP    R11,#0
  3984.     JR    NE,BANK_1
  3985.  
  3986. ; Bank 0
  3987.     LD    R12,#^HB BANK_0_TAB    ; point to proper table
  3988.     LD    R13,#^LB BANK_0_TAB
  3989.     JR    FIND_ENTRY
  3990.  
  3991. ; Bank 1
  3992. BANK_1
  3993.     LD    R12,#^HB BANK_1_TAB    ; point to proper table
  3994.     LD    R13,#^LB BANK_1_TAB
  3995.  
  3996. ; Find correct location in lookup table for first register requested
  3997.  
  3998. FIND_ENTRY
  3999.     SUB    R8,#$E0        ; find offset from $E0 
  4000. LOOP_FIND
  4001.     CP    R8,#0        ; are we through ? 
  4002.     JR    EQ,CNTRL_LOOP    ; yes 
  4003.     DEC    R8        ; decrement counter 
  4004.     INCW    RR12        ; point to next byte in table
  4005.     JR    LOOP_FIND
  4006.  
  4007. ; check for unimplemented or write-only 
  4008. ;   control registers 
  4009. CNTRL_LOOP
  4010.     LDC    R4,@RR12    ; get value from table
  4011.     CP    R4,#UI
  4012.     JR    EQ,NEXT_CNTRL
  4013.     CP    R4,#WO
  4014.     JR    EQ,NEXT_CNTRL
  4015.  
  4016. START_READ
  4017.  
  4018. ; Fisrt save the current user flag register 
  4019. ;        so we know which bank (0 or 1) to return to
  4020.  
  4021.     push    FLAGS    ; save it
  4022.  
  4023. ; set correct bank number 
  4024.  
  4025.     CP    R11,#0        ; bank 0 ? 
  4026.     JR    NE,SET_BANK_1   ; no 
  4027.     sb0
  4028.     JR    WRITE_FLAG
  4029.  
  4030. SET_BANK_1
  4031.     sb1
  4032.  
  4033. WRITE_FLAG
  4034.  
  4035. ; now read the correct control register 
  4036.     CALL    READ_DIR_REG    ; read S8 reg. @R9 
  4037.  
  4038. ; Restore flag register so we back to the correct bank (0 or 1)
  4039.     pop    FLAGS
  4040.  
  4041. ; RR6 now points to result register 
  4042.     LDC    R4,@RR6        ; save the value 
  4043.  
  4044.     LD    R6,#OUT_CHR1    ; dest of BTOHEXDAT 
  4045.     CALL    BTOHEXDAT
  4046.  
  4047.     LD    R4,OUT_CHR1    ; print high nibble 
  4048.     CALL    OUTCHR
  4049.     LD    R4,OUT_CHR2    ; print low nibble 
  4050.     CALL    OUTCHR
  4051.  
  4052.     LD    R4,#ASCIISP    ; 4 trailing ' 's 
  4053.     CALL    OUTCHR
  4054.     CALL    OUTCHR
  4055.     CALL    OUTCHR
  4056.     CALL    OUTCHR
  4057.  
  4058.  
  4059. NEXT_CNTRL
  4060.     CP    R9,R10        ; are we through ? 
  4061.     JR    GE,DONE_CNTRL
  4062.     INC    R9        ; next register 
  4063.     INCW    RR12
  4064.     JR    CNTRL_LOOP
  4065.  
  4066. DONE_CNTRL
  4067.  
  4068.     POP    R13
  4069.     POP    R12
  4070.     POP    R8
  4071.     RET
  4072.  
  4073.  
  4074.  
  4075. RD_WR_BANK 
  4076. ;*******************************************************
  4077. ;*
  4078. ;*    BANK_REG  Read/write the correct control register
  4079. ;*        value for the given bank0/bank1 register.
  4080. ;*
  4081. ;*    input  R9  contains register number and must be
  4082. ;*           in the range $E0 through $FF.
  4083. ;*           R2 contains bank number.
  4084. ;*           R11 contains the value to be written.
  4085. ;*
  4086. ;*    output R10 has the register value read.
  4087. ;*
  4088. ;*
  4089. ;*******************************************************;
  4090.     PUSH    R4
  4091.     PUSH    R9        ; save reg number 
  4092.     LD    R9,#$D5        ; read flag register 
  4093.     CALL    READ_DIR_REG
  4094.     LDC    R4,@RR6
  4095.     LD    USER_FLAGS,R4
  4096.     POP    R9
  4097.  
  4098.     ; determine bank, R4 has bank value 
  4099.     CP    R2,#0        ; bank 0 ? 
  4100.     JR    EQ,SET_BANK0
  4101.     OR    R4,#$01        ; bank 1  
  4102.     JR    WRITE_BANK
  4103.  
  4104. SET_BANK0
  4105.     AND    R4,#$FE        ; bank 0 
  4106.  
  4107. WRITE_BANK
  4108.     PUSH    R9        ; save used regs 
  4109.     PUSH    R11
  4110.     LD    R11,R4
  4111.     LD    R9,#$D5        ; read flag register 
  4112.     CALL    WRITE_DIR_REG
  4113.     POP    R11
  4114.     POP    R9
  4115.  
  4116.     ; check for a read or write 
  4117.     CP    D_MEMFLAG,#0    ; a read? 
  4118.     JR    NE,WR_BANK_REG
  4119.  
  4120.     ; now read the register, R9 has reg number 
  4121.     CALL    READ_DIR_REG
  4122.     LDC    R10,@RR6    ; save in output reg 
  4123.     JR    RESTOR_FLAG
  4124.  
  4125. WR_BANK_REG
  4126.     CALL    WRITE_DIR_REG
  4127.  
  4128. RESTOR_FLAG
  4129.     ; restore user flag register 
  4130.     PUSH    R9        ; save used regs 
  4131.     PUSH    R11
  4132.     LD    R9,#$D5        ; flag reg number 
  4133.     LD    R11,USER_FLAGS  ; flag reg value 
  4134.     CALL    WRITE_DIR_REG    ; write it 
  4135.     POP    R11
  4136.     POP    R9
  4137.     POP    R4
  4138.     RET
  4139.  
  4140.  
  4141. ;*********************************************
  4142. ;*
  4143. ;*    new.s : Misc. commands
  4144. ;*
  4145. ;*        (1) Phill (fill) registers
  4146. ;*        (2) Interrupt enable/disable
  4147. ;*        (3) Working register display
  4148. ;*        (4) Echo on/off
  4149. ;*        (5) Verify (self test)
  4150. ;*
  4151. ;**********************************************;
  4152.  
  4153.  
  4154. PHIL_REGISTERS 
  4155. ;************************************************
  4156. ;*
  4157. ;*    PHILL  fill general registers just as memory
  4158. ;*           is filled.
  4159. ;*
  4160. ;*    syntax    P <REG NUM> <NUM OF REGS> {<DATA>}
  4161. ;*
  4162. ;************************************************;
  4163.  
  4164.     CALL    GETADDR        ; get first reg num 
  4165.     JR    C,BADHX_    ; no good 
  4166.     LD    R9,R11        ; first register 
  4167.     CALL    GETADDR        ; number of registers 
  4168.     JR    C,BADHX_    ; no good 
  4169.     LD    R2,R11        ; put length in R2 
  4170.  
  4171.     CLR    OUTPTR        ; use input buffer to 
  4172.     CLR    R13        ; store converted pattern 
  4173. ACCUM_
  4174.     CALL    GETADDR        ; get value 
  4175.     JR    C,DO_FILL_    ; stop input and fill regs 
  4176.     LD    R7,OUTPTR    ; 
  4177.     LDC    @RR6,R11    ; one byte of data 
  4178.     INC    R13        ; keep count 
  4179.     INC    OUTPTR        ; 
  4180.     JR    ACCUM_        ; get next data byte 
  4181.  
  4182. DO_FILL_
  4183.     CP    R13,#$00    ; if no data, don't fill 
  4184.     JR    EQ,BADHX_    ; 
  4185.     LD    R0,R6        ; use RR0 to access pattern 
  4186.  
  4187. RE_PEAT_
  4188.     LD    R8,R13        ; save pattern length 
  4189.     CLR    R1        ; and start at begin of pattern 
  4190. R8LOOP_
  4191.     LDC    R11,@RR0    ; get byte 
  4192.  
  4193.     CP    R9,#$C0        ; set two register? 
  4194.     JR    UGE,WRITE_IR1    ; yes 
  4195.  
  4196.     CALL    WRITE_DIR_REG    ; no, write R11 into @R9 
  4197.     JR    WROTE_IT
  4198.  
  4199. WRITE_IR1
  4200.     CALL    WRITE_IR_REG    ; write R11 into @R9 
  4201.                 ;  (set two) 
  4202.  
  4203. WROTE_IT
  4204.     INC    R9        ; 
  4205.     INC    R1        ; 
  4206.     DEC    R2        ; number of registers 
  4207.     JR    Z,PHIL_END    ; done 
  4208.     DJNZ    R8,R8LOOP_    ; 
  4209.     JR    RE_PEAT_    ; 
  4210. PHIL_END
  4211.     CLR    ERR_CODE    ; no errors 
  4212. BADHX_
  4213.     RET            ; 
  4214.  
  4215.  
  4216.  
  4217.  
  4218. INTERRUPT_ENABLE 
  4219. ;************************************************
  4220. ;*
  4221. ;*    ENABLE USER INTERRUPTS in next 'go'
  4222. ;*
  4223. ;*    syntax        I [E|D]
  4224. ;*
  4225. ;*    default        E
  4226. ;*
  4227. ;************************************************;
  4228.     DI            ; must DI to change IMR 
  4229.     CALL    FINDNEXT    ; parameter? 
  4230.     JR    C,DEFAULT_I    ; allow interrupts 
  4231.     OR    R4,#$20        ; upper or lower case 
  4232.     CP    R4,#'e'        ; enable is default 
  4233.     JR    EQ,DEFAULT_I    ; 
  4234.     CP    R4,#'d'        ; disable 
  4235.     JR    NE,IN_ERROR    ; invalid parameter 
  4236.     CLR    USER_EI
  4237.     JR    ENABLE_GLOBAL    ; 
  4238. DEFAULT_I
  4239.     CLR    ERR_CODE    ; 
  4240.     LD    USER_EI,#$FF    ; go with interrupts 
  4241.     JR    ENABLE_GLOBAL    ; 
  4242. IN_ERROR
  4243.     LD    ERR_CODE,#BAD_OPT ; invalid parameter 
  4244. ENABLE_GLOBAL
  4245.     EI            ; 
  4246.     RET            ; 
  4247.  
  4248.  
  4249.  
  4250.  
  4251. WORKING_REGS 
  4252. ;*************************************************
  4253. ;*
  4254. ;*    WORKING register display/modify routine
  4255. ;*
  4256. ;*    syntax    W
  4257. ;*
  4258. ;*************************************************;
  4259.  
  4260.     CALL    GETADDR        ; Check for register number
  4261.     JP    C,DISP_WREGS    ; Jump if none found
  4262.  
  4263.     PUSH    R10        ; save
  4264.     PUSH    R11        ;    it
  4265.  
  4266.     CALL    GETADDR        ; Check for a new value?
  4267.     JP    C,EDIT_WREGS    ; Jump if no value found to edit mode
  4268.  
  4269. ; Write new value to working register
  4270.  
  4271.     POP    R13        ;
  4272.  
  4273.     CP    R13,#$a        ;
  4274.     JR    LT,GET_WREG    ;
  4275.     SUB    R13,#$6        ;
  4276.  
  4277. GET_WREG
  4278.     POP    R12        ; get register 
  4279.     CP    R13,#$f        ; valid register
  4280.     JR    GT,BADREG    ;
  4281.  
  4282.     LD    R9,#$D6        ; get rp0
  4283.     LD    R12,R13        ;
  4284.  
  4285.     CP    R13,#8        ; which RP
  4286.     JR    LT,GET_RP
  4287.     INC    R9
  4288.     SUB    R12,#8
  4289.  
  4290. GET_RP
  4291.     CALL    READ_DIR_REG
  4292.     LDC    R9,@RR6
  4293.     AND    R9,#$F8
  4294.  
  4295.     ADD    R9,R12        ; R9 is register, R11 value 
  4296.     CALL    WRITE_DIR_REG
  4297.     CLR    ERR_CODE
  4298.     RET
  4299.  
  4300. BADREG
  4301.     LD    ERR_CODE,#BAD_PARAM_VAL
  4302.     RET
  4303.  
  4304. ; Edit working register set
  4305.  
  4306. EDIT_WREGS
  4307.     CLR    ERR_CODE
  4308.     CALL    EDIT_STATUS
  4309.  
  4310.     POP    R11
  4311.     POP    R10
  4312.  
  4313.     CP    R11,#$15
  4314.     JR    GT,BADREG
  4315.  
  4316.     CP    R11,#10        ; convert hex to decimal 
  4317.     JR    LT,LOOP
  4318.     SUB    R11,#6
  4319.  
  4320. LOOP                ; here we go editing
  4321.     CALL    SEND_STX
  4322.     LD    R4,#'R'
  4323.     CALL    OUTCHR
  4324.  
  4325.     LD    R4,R11        ; print register number
  4326.     CP    R4,#10
  4327.     JR    LT,LP1
  4328.     ADD    R4,#6
  4329. LP1
  4330.     CALL    OUTHEX
  4331.  
  4332.     LD    R4,#' '
  4333.     CALL    OUTCHR
  4334.  
  4335.     LD    R9,#$D6    ; get register pointers 
  4336.     LD    R10,R11
  4337.  
  4338.     CP    R11,#8
  4339.     JR    LT,LP2
  4340.     INC    R9
  4341.     SUB    R10,#8
  4342. LP2
  4343.     CALL    READ_DIR_REG
  4344.     LDC    R9,@RR6
  4345.     AND    R9,#$F8
  4346.                 ; get old value
  4347.     ADD    R9,R10
  4348.     PUSH    R9        ; save register
  4349.     CALL    READ_DIR_REG
  4350.  
  4351.     LDC    R4,@RR6
  4352.     CALL    OUTHEX
  4353.  
  4354.     LD    R4,#'+'
  4355.     CALL    OUTCHR
  4356.     CALL    SEND_ETX
  4357.  
  4358.     CALL    GETLINE
  4359.     POP    R13        ; register number 
  4360.  
  4361. REG_TOKEN1
  4362.     CP    R4,#'Q'        ; do we quit
  4363.     JP    EQ,ENDWEDIT
  4364.     CP    R4,#'q'
  4365.     JP    EQ,ENDWEDIT
  4366.  
  4367.     CP    R4,#ASCIIUP
  4368.     JR    NZ,REG_DOT1        ; ^ go back
  4369.     DEC    R11
  4370.     CP    R11,#0
  4371.     JP    GE,LOOP
  4372.     LD    R11,#$f        ; wrap around
  4373.     JP    LOOP
  4374.  
  4375. REG_DOT1
  4376.     CP    R4,#'.'
  4377.     JP    EQ,LOOP        ; same reg again 
  4378.  
  4379.     CP    R4,#ASCIICR
  4380.     JR    EQ,MORE_REG1
  4381.  
  4382. NEW_REG_VALUE
  4383.                     ; R13 should have register number 
  4384.     PUSH    R11
  4385.     CALL    CON_BYTE        ; convert byte
  4386.                     ; R11 = byte
  4387.     LD    R9,R13        ; R9 = register
  4388.     CALL    WRITE_DIR_REG
  4389.     POP    R11
  4390.  
  4391.     CALL    FINDNEXT
  4392.     JR    NZ,REG_TOKEN1
  4393.  
  4394. MORE_REG1
  4395.     INC    R11            ; next register
  4396.     CP    R11,#16
  4397.     JP    LT,LOOP
  4398.     LD    R11,#0
  4399.     JP    LOOP
  4400.  
  4401. ENDWEDIT
  4402.     RET
  4403.  
  4404.  
  4405. ; ----- Display the working register set ------------------
  4406.  
  4407. DISP_WREGS
  4408.  
  4409. ; Start by displaying the  working register header, numbers are 
  4410. ;   in decimal 
  4411.  
  4412.     LD    R0,#0        ; counter 
  4413. DISP_HDR
  4414.     LD    R4,#'R'        ; Put a 'R'
  4415.     CALL    OUTCHR        ;   in front of each #
  4416.  
  4417. ; print tens digit 
  4418.  
  4419.     LD    R1,R0        ; save reg number 
  4420.     CP    R0,#9        ; is R0 > 9 ? 
  4421.     JR    GT,GT_9        ; yes 
  4422.     LD    R4,#'0'        ; no, print '0' 
  4423.     CALL    OUTCHR
  4424.     JR    DIGIT_2
  4425.  
  4426. GT_9
  4427.     LD    R4,#'1'        ; print '1' 
  4428.     CALL    OUTCHR
  4429.     SUB    R1,#10        ; R1 has ones digit
  4430.  
  4431. DIGIT_2
  4432.     ADD    R1,#$30        ; make it ascii 
  4433.     LD    R4,R1
  4434.     CALL    OUTCHR
  4435.     CP    R0,#$0F        ; are we through? 
  4436.     JR    EQ,DISP_WORKS    ; yes 
  4437.     LD    R4,#' '        ; no, print 2 spaces 
  4438.     CALL    OUTCHR        ;
  4439.     CALL    OUTCHR        ;
  4440.     INC    R0        ; inc counter 
  4441.     JR    DISP_HDR    ; and repeat 
  4442.  
  4443. ; ------ Okay we finished with the header now move on ------------
  4444. ;         to displaying the working registers values
  4445.  
  4446. DISP_WORKS
  4447.     CALL    CRLF
  4448.     LD    R9,USER_RP0    ; get USER's RP0 
  4449.     and    r9,#$F8        ; Mask off don't care bits
  4450.     PUSH    R9        ; save RP0
  4451.     CALL    DISP_REG    ; Display the RP0 register set
  4452.  
  4453. GET_RP1
  4454.     LD    R9,USER_RP1    ; get USER_RP1 
  4455.     AND    R9,#$F8        ; mask off don't cares 
  4456.     PUSH    R9        ; save RP1 
  4457.     CALL    DISP_REG    ; Display the RP1 register set
  4458.  
  4459. ; ------- Now print the reister pointer values themselves ----------
  4460.  
  4461.     POP    R11        ; Get the RP1
  4462.     POP    R10        ;    and RP0 values off of stack
  4463.     CALL    CRLF
  4464.     LD    R4, #'R'
  4465.     CALL    OUTCHR
  4466.     LD    R4, #'P'
  4467.     CALL    OUTCHR
  4468.     LD    R4, #'0'
  4469.     CALL    OUTCHR
  4470.     LD    R4, #'='
  4471.     CALL    OUTCHR
  4472.     LD    R4,R10        ; print the RP0 value
  4473.     CALL    OUTHEX
  4474.     LD    R4, #' '
  4475.     CALL    OUTCHR
  4476.  
  4477.     LD    R4, #'R'
  4478.     CALL    OUTCHR
  4479.     LD    R4, #'P'
  4480.     CALL    OUTCHR
  4481.     LD    R4, #'1'
  4482.     CALL    OUTCHR
  4483.     LD    R4, #'='
  4484.     CALL    OUTCHR
  4485.     LD    R4,R11        ; print the RP1 value
  4486.     CALL    OUTHEX
  4487.     LD    R4, #' '
  4488.     CALL    OUTCHR
  4489.  
  4490.     LD    R4, #'S'
  4491.     CALL    OUTCHR
  4492.     LD    R4, #'P'
  4493.     CALL    OUTCHR
  4494.     LD    R4, #'='
  4495.     CALL    OUTCHR
  4496.     ldw    rr10,USER_SP    ; Print  SP
  4497.     call    OUTADDR
  4498.  
  4499. DISP_DONE
  4500.     CALL    CRLF
  4501.     CLR    ERR_CODE
  4502.     RET            ; 
  4503.  
  4504.  
  4505.  
  4506. ; ------ Display eight register set ------------------------
  4507. ;
  4508. ;  Enter: R9 points to 8 register set
  4509.  
  4510. DISP_REG 
  4511.     LD    R10, R9        ; get base register pointer
  4512.     ADD    R10, #7        ; set end pointer for displaying 8 registers 
  4513.  
  4514. SYS_LOOP1
  4515.     LD    R4,#ASCIISP    ; 1 leading ' ' 
  4516.     CALL    OUTCHR        ;   for rCx regs. 
  4517.     CALL    READ_DIR_REG    ; read S8 reg. @R9 
  4518.                 ; RR6 now points to result register 
  4519.     LDC    R4,@RR6        ; save the value 
  4520.     CALL    OUTDAT
  4521.     LD    R4,#ASCIISP    ; 1 trailing ' '  
  4522.     CALL    OUTCHR        ;   for rCx regs. 
  4523.  
  4524.     CP    R9,R10        ; are we through 
  4525.     JR    EQ,SYS_DONE1
  4526.     INC    R9        ; next register 
  4527.     JR    SYS_LOOP1
  4528. SYS_DONE1
  4529.     RET
  4530.  
  4531.  
  4532.  
  4533. EXTENSION 
  4534. ;************************************************************
  4535. ;*
  4536. ;*    Echo command:    E -O|1|0
  4537. ;*
  4538. ;*    Options have the following meanings:
  4539. ;*
  4540. ;*        O    Toggle the "ECHO ON/ECHO OFF" mode.
  4541. ;*        1    Turn echo on.
  4542. ;*        0    Turn echo off.
  4543. ;*
  4544. ;*
  4545. ;**************************************************************;
  4546.     CALL    FINDOPT        ; look for the option 
  4547.     CP    R10,#'o'    ; is it an 'o' 
  4548.     JR    NE,CHECK_0    ; no 
  4549.  
  4550.     ; toggle the echo mode 
  4551.     CP    ECHO_MODE,#ECHO_ON  ; are we echoing? 
  4552.     JR    EQ,RESET_ECHO        ; yes, so stop echo 
  4553.     JR    SET_ECHO        ; no, start echo 
  4554.  
  4555. CHECK_0
  4556.     CP    R10,#'0'    ; '0' option ? 
  4557.     JR    NE,CHECK_1    ; no 
  4558.     JR    RESET_ECHO    ; yes, turn echo off 
  4559.  
  4560. CHECK_1
  4561.     CP    R10,#'1'    ; '1' option ? 
  4562.     JR    NE,NOT_VALID    ; no, illegal option 
  4563.     JR    SET_ECHO    ; yes, turn echo o n
  4564.  
  4565.  
  4566. SET_ECHO
  4567.     LD    ECHO_MODE,#ECHO_ON  ; no, start echoing 
  4568.     JR    DONE_EXT
  4569.  
  4570. RESET_ECHO
  4571.     LD    ECHO_MODE,#ECHO_OFF  ; stop echoing 
  4572.     JR    DONE_EXT
  4573.  
  4574. NOT_VALID
  4575.     LD    ERR_CODE,#BAD_OPT
  4576.  
  4577. DONE_EXT
  4578.     ; save echo status in monitor RAM 
  4579.     LDW    RR6,#ECHO_STAT   ; point to echo save 
  4580.     LD    R4,ECHO_MODE
  4581.     LDC    @RR6, R4       ; save the status 
  4582.  
  4583.     RET
  4584.  
  4585.  
  4586.  
  4587.  
  4588. VERIFY 
  4589. ;********************************************************
  4590. ;*
  4591. ;*
  4592. ;*    VERIFY    Self test of S8 EM board
  4593. ;*
  4594. ;*    tests:
  4595. ;*      (1) Performs checksum on Monitor
  4596. ;*
  4597. ;*        (2) Performs simple test of Super8
  4598. ;*            registers & , User Internal, and Breakpoint RAM
  4599. ;*          by writing and reading 0 and 1 at each bit
  4600. ;*          location.
  4601. ;*
  4602. ;*      (2) I-Code register interface by writing and
  4603. ;*          reading a SUPER8 register.
  4604. ;*
  4605. ;*      (3) Emulation interface by the folowing steps:
  4606. ;*
  4607. ;*        A. write a value to a SUPER8 register.
  4608. ;*
  4609. ;*        B. put instructions into SUPER8 memory
  4610. ;*           to increment that register.
  4611. ;*
  4612. ;*        c. set a breakpoint at the end of those
  4613. ;*           instructions.
  4614. ;*
  4615. ;*        d. start emulation
  4616. ;*
  4617. ;*        e. read the SUPER8 register after the break
  4618. ;*           occurs to verify execution.
  4619. ;;*
  4620. ;**********************************************************;
  4621.  
  4622.     CLR    ERR_CODE
  4623.     CALL    HOST_DELAY    ; Wait for Host to catch up
  4624.     CALL    SEND_STX
  4625.     LDW    RR6,#TEST_MSG    ; test message 
  4626.     CALL    OUTMSG
  4627.     CALL    SEND_ETX
  4628.  
  4629.     CALL    HOST_DELAY    ; Wait for host to catch up
  4630.     CALL    SEND_STX    ; start message 
  4631.     CALL    MON_RAM_TEST    ; test monitor RAM 
  4632.     CP    ERR_CODE,#$FF    ; RAM test error ? 
  4633.     JR    EQ,TEST_ICODE    ; yes 
  4634.  
  4635.     LDW    RR6,#RAM_OK_STR  ; print RAM_OK message 
  4636.     CALL    OUTMSG
  4637.     CALL    SEND_ETX    ; end message 
  4638.  
  4639.     CALL    HOST_DELAY    ; Wait for host to catch up
  4640.  
  4641. TEST_ICODE
  4642.     CLR    ERR_CODE
  4643.     RET
  4644.  
  4645.  
  4646.  
  4647. MON_RAM_TEST 
  4648. ;********************************************************
  4649. ;*
  4650. ;*    MON_RAM_TEST  Test monitor RAM with 1's and 0's
  4651. ;*            to all locations.
  4652. ;*
  4653. ;*      Performs a non-destructive read/write test
  4654. ;*********************************************************;
  4655.  
  4656.     push    r3
  4657.     push    r4
  4658.     push    r5
  4659.     push    r12
  4660.     push    r13
  4661.  
  4662. ; First check if we have a 8K or 32K RAM out there
  4663.  
  4664.     ld    r4,#$AA        ; Load test pattern
  4665.     ld    r12,#$80    ; Point to
  4666.     ld    r13,#$00    ;   test location
  4667.     ldc    r3,@rr12    ; Save byte thats there
  4668.     ldc    @rr12,r4    ; Write test pattern to RAM
  4669.     ldc    r5,@rr12    ; Read back test pattern
  4670.     ldc    @rr12,r3    ; Restore byte that was there
  4671.     cp    r4,r5        ; Compare value read with test pattern
  4672.     jr    ne,RAM_8K    ; If not equal must be 8K RAM
  4673.  
  4674. ; Print test message
  4675.  
  4676.     ld    r6,#^HB RAM_MESS1
  4677.     ld    r7,#^LB RAM_MESS1
  4678.     call    OUTMSG
  4679.  
  4680. ; Write a 1 to all locations for 32K RAM
  4681.  
  4682.     LD    R12,#$80    ; high byte of start address
  4683.     LD    R14,#$F0    ; high byte of end address
  4684.     LD    R15,#$FF    ; write all 1's 
  4685.     CALL    MEM_WRITE_READ
  4686.  
  4687. ; Now write a 0 to all locations for 32K RAM
  4688.  
  4689.     LD    R12,#$80    ; high byte of start address
  4690.     LD    R14,#$F0    ; high byte of end address
  4691.     LD    R15,#$00    ; write all 0's 
  4692.     CALL    MEM_WRITE_READ
  4693.     jr    RAM_EXIT
  4694.  
  4695. ; Print test message
  4696.  
  4697. RAM_8K:    ldw    rr6,#RAM_MESS2
  4698.     call    OUTMSG
  4699.  
  4700. ; Write a 1 to all locations for 8K RAM
  4701.  
  4702.     LD    R12,#$E0    ; high byte of start address
  4703.     LD    R14,#$F0    ; high byte of end address
  4704.     LD    R15,#$FF    ; write all 1's 
  4705.     CALL    MEM_WRITE_READ
  4706.  
  4707. ; Now write a 0 to all locations for 8K RAM
  4708.  
  4709.     LD    R12,#$E0    ; high byte of start address
  4710.     LD    R14,#$F0    ; high byte of end address
  4711.     LD    R15,#$00    ; write all 0's 
  4712.     CALL    MEM_WRITE_READ
  4713.  
  4714.  
  4715. RAM_EXIT:
  4716.     pop    r13
  4717.     pop    r12
  4718.     pop    r5
  4719.     pop    r4
  4720.     pop    r3
  4721.     RET
  4722.  
  4723.  
  4724. MEM_WRITE_READ 
  4725. ;*************************************************
  4726. ;*
  4727. ;*    Write a value to memory on the SUPER8 EM
  4728. ;*    board and read it back.
  4729. ;*    If error, print out message.  Repeat for
  4730. ;*    specified range of memory.
  4731. ;*
  4732. ;*    input:    R12  -- hi byte of starting address
  4733. ;*        R14  -- hi byte of end address + 1
  4734. ;*        R15  -- data to be written and read
  4735. ;*
  4736. ;*      Performs a non-destructive read/write test
  4737. ;*************************************************;
  4738.     PUSH    R3        ; save used registers 
  4739.     PUSH    R4
  4740.     PUSH    R5
  4741.     PUSH    R6
  4742.     PUSH    R7
  4743.     PUSH    R10
  4744.     PUSH    R11
  4745.     PUSH    R15
  4746.  
  4747.     CLR    R13
  4748. ; main write - read loop 
  4749. WRITE_READ_LOOP
  4750.     LDC    R3,@RR12    ; save value at location 
  4751.                 ;   to be tested 
  4752.     LDC    @RR12,R15    ; write data in R15 
  4753.     LDC    R5,@RR12    ; read it back into R5 
  4754.  
  4755.     LDC    @RR12,R3    ; restore original value 
  4756.  
  4757.     CP    D_MEMFLAG,#0    ; is it BREAK memory? 
  4758.     JR    EQ,NOT_BREAK    ; no 
  4759.     AND    R5,#$01        ; yes, only LSB is valid 
  4760.  
  4761. NOT_BREAK
  4762.     CP    R5,R15        ; are values and equal ? 
  4763.     JR    NE,NOT_EQUAL
  4764.  
  4765. NEXT_LOC
  4766.     INCW    RR12        ; inc. mem pointer 
  4767.     CP    R12,R14        ; are we through? 
  4768.     JR    ULT,WRITE_READ_LOOP  ; no 
  4769.     JR    DONE_WRITE_READ         ; yes 
  4770.  
  4771. NOT_EQUAL
  4772.     PUSH    R5        ; save data values 
  4773.     PUSH    R15
  4774.  
  4775.     LD    R4,#$10
  4776.     CALL    DELAY
  4777.  
  4778.     LDW    RR6,#RAM_ERROR  ; 'RAM FAILURE AT '
  4779.     CALL    OUTSTR
  4780.  
  4781.     LD    R4,#$10
  4782.     CALL    DELAY
  4783.  
  4784.     LD    R10,R12        ; put bad address in 
  4785.     LD    R11,R13        ;   RR10 for OUTADDR 
  4786.     CALL    OUTADDR        ; <ADDRESS> 
  4787.  
  4788.     LD    R4,#$10
  4789.     CALL    DELAY
  4790.  
  4791.     LD    R6,#^HB WROTE_STR  ; ' WROTE ' 
  4792.     LD    R7,#^LB WROTE_STR
  4793.     CALL    OUTSTR
  4794.  
  4795.     LD    R4,#$10
  4796.     CALL    DELAY
  4797.  
  4798.     POP    R15        ; <write value> 
  4799.     LD    R4,R15
  4800.     CALL    OUTDAT
  4801.  
  4802.     LD    R4,#$10
  4803.     CALL    DELAY
  4804.  
  4805.     LD    R6,#^HB READ_STR      ; ' READ ' 
  4806.     LD    R7,#^LB READ_STR
  4807.     CALL    OUTSTR
  4808.  
  4809.     LD    R4,#$10
  4810.     CALL    DELAY
  4811.  
  4812.     POP    R5
  4813.     LD    R4,R5        ; <read value> 
  4814.     CALL    OUTDAT
  4815.  
  4816.     LD    R4,#$10
  4817.     CALL    DELAY
  4818.  
  4819.     LD    ERR_CODE,#$FF    ; set error flag 
  4820.  
  4821.     CALL    CRLF
  4822.     ;  exit after first error 
  4823.  
  4824. DONE_WRITE_READ
  4825.     POP    R15        ; restore used registers 
  4826.     POP    R11
  4827.     POP    R10
  4828.     POP    R7
  4829.     POP    R6
  4830.     POP    R5
  4831.     POP    R4
  4832.     POP    R3
  4833.     RET
  4834.  
  4835.  
  4836. QUIT 
  4837. ;****************************************************
  4838. ;*
  4839. ;*    QUIT  Send message to host to quit to MSDOS.
  4840. ;*
  4841. ;*    SYNTAX:    Q
  4842. ;*
  4843. ;****************************************************;
  4844.  
  4845.     CP    ECHO_MODE,#ECHO_ON  ; are we echoing? 
  4846.     JR    NE,SEND_QUIT        ; no, send quit msg 
  4847.  
  4848.     ; we are echoing, don't send message and flag error 
  4849.     LD    ERR_CODE,#BAD_CMD   ; bad command 
  4850.     RET
  4851.  
  4852.     ; send quit message: "<STX> Q <ETX>" 
  4853. SEND_QUIT
  4854.     CALL    SEND_STX        ; STX 
  4855.     LD    R4,#'Q'
  4856.     CALL    OUTCHR            ; 'Q' 
  4857.     CALL    SEND_ETX        ; ETX 
  4858.     RET
  4859.  
  4860.  
  4861. TEST_MSG    .ascii 'Executing SELF TEST...\r'
  4862. RAM_MESS1    .ascii 'Testing 32K RAM at location 8000 - FFFF\r'
  4863. RAM_MESS2    .ascii 'Testing 8K RAM at location E000 - FFFF\r'
  4864. RAM_ERROR    .ascii 'RAM Failure at \r'
  4865. WROTE_STR    .ascii ' wrote \r'
  4866. READ_STR    .ascii ' read \r'
  4867. RAM_OK_STR    .ascii  'RAM test OK\r'
  4868.  
  4869.  
  4870. ; mnemonic PC and register header for first row of system regs 
  4871. SYS1_H_REG .ascii 'PC    P0    P1    P2    P3    P4    FLAGS RP0\r'
  4872.  
  4873.  
  4874. ; register numbers for first row of system regs 
  4875. SYS1_N_REG .ascii '      rD0   rD1   rD2   rD3   rD4   rD5   rD6\r'
  4876.  
  4877.  
  4878. ; mnemonic register header for second row of system regs 
  4879. SYS2_H_REG .ascii 'RP1   SPH   SPL   IPH   IPL   IRQ   IMR   SYM\r'
  4880.  
  4881.  
  4882. ; register numbers for second row of system regs 
  4883. SYS2_N_REG .ascii 'rD7   rD8   rD9   rDA   rDB   rDC   rDD   rDE\r'
  4884.  
  4885.  
  4886. ; mnemonic register header for first row of control/mode regs 
  4887. CTL1_H_REG .ascii 'C0CT  C1CT  C0CH  C0CL  C1CH  C1CL  UTC   URC   UIE   UIO   P0M\r'
  4888.  
  4889. ; register numbers for first row of control/mode regs 
  4890. CTL1_N_REG .ascii 'rE0/0 rE1/0 rE2/0 rE3/0 rE4/0 rE5/0 rEB/0 rEC/0 rED/0 rEF/0 rF0/0\r'
  4891.  
  4892. ; mnemonic register header for second row of control/mode regs 
  4893. CTL2_H_REG .ascii 'P4D   P4OD  P2AIP P2BIP EMT   IPR   C0M   C1M   C0CTH C0CTL\r'
  4894.  
  4895. ; register numbers for second row of control/mode regs 
  4896. CTL2_N_REG .ascii 'rF6/0 rF7/0 rFC/0 rFD/0 rFE/0 rFF/0 rE0/1 rE1/1 rE2/1 rE3/1\r'
  4897.  
  4898. ; mnemonic register header for third row of control/mode regs 
  4899. CTL3_H_REG .ascii 'C1TCH C1TCL DCH   DCL   UBGH  UBGL  UMA   UMB   WUMCH WUMSK\r'   
  4900.  
  4901. ; register numbers for third row of control/mode regs 
  4902. CTL3_N_REG .ascii 'rE4/1 rE5/1 rF0/1 rF1/1 rF8/1 rF9/1 rFA/1 rFB/1 rFE/1 rFF/1\r'
  4903.  
  4904. ; register numbers for fourth row of control/mode regs 
  4905. CTL4_N_REG .ascii 'rC0 rC1 rC2 rC3 rC4 rC5 rC6 rC7 rC8 rC9 rCA rCB rCC rCD rCE rCF\r'
  4906.  
  4907.  
  4908. ; map of bank 0 control/mode registers: 
  4909. ; read/write(RW), write only(WO), read only(RO), unimplemented(UI) 
  4910. BANK_0_TAB:
  4911.  
  4912. ;      E0  E1  E2  E3  E4  E5  E6  E7  E8  E9  EA  EB  EC  ED  EE  EF
  4913.  db RW, RW, RW, RW, RW, RW, UI, UI, UI, UI, UI, RW, RW, RW, UI, RW
  4914.  
  4915. ;      F0  F1  F2  F3  F4  F5  F6  F7  F8  F9  FA  FB  FC  FD  FE  FF
  4916.  db RW, WO, UI, UI, WO, WO, RW, RW, WO, WO, WO, WO, RW, RW, RW, RW
  4917.  
  4918.  
  4919. ; map of bank 1 control/mode registers: 
  4920. ; read/write(RW), write only(WO), read only(RO), unimplemented(UI) 
  4921. BANK_1_TAB:
  4922.  
  4923. ;      E0  E1  E2  E3  E4  E5  E6  E7  E8  E9  EA  EB  EC  ED  EE  EF
  4924.  db RW, RW, RW, RW, RW, RW, UI, UI, UI, UI, UI, UI, UI, UI, UI, UI
  4925.  
  4926. ;      F0  F1  F2  F3  F4  F5  F6  F7  F8  F9  FA  FB  FC  FD  FE  FF
  4927.  db RW, RW, UI, UI, UI, UI, UI, UI, RW, RW, RW, RW, UI, UI, RW, RW
  4928.  
  4929.  
  4930. ; general register display header 
  4931. GEN_REG_H  .ascii '       x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xA  xB  xC  xD  xE  xF\r'
  4932.  
  4933.  
  4934. ;************************************************
  4935. ;*
  4936. ;*    load.s : Download and Upload functions
  4937. ;*
  4938. ;************************************************;
  4939. ;*
  4940. ;*               Constants and register usage used by
  4941. ;*               all or some of the software modules.
  4942. ;*
  4943. ;******************************************************;
  4944. ; register allocation 
  4945.  
  4946.  
  4947.  
  4948. LOAD 
  4949. ;**************************************************
  4950. ;*
  4951. ;*    LOAD  Download a program
  4952. ;*
  4953. ;*    syntax    L [-E] <filename>
  4954. ;*
  4955. ;****************************************************;
  4956.     LD    SIO_MODE,#LOAD_MODE  ; load input mode 
  4957.  
  4958.     CALL    FINDOPT        ; look for an option
  4959.     CP    R10,#0        ; an option? 
  4960.     JR    EQ,LOADUP    ; no 
  4961.  
  4962.     CP    R10,'e'        ; yes, is it an 'e'?
  4963.     JR    EQ,E_OPTION    ; yes 
  4964.     LD    ERR_CODE,#BAD_OPT ; no, bad option 
  4965.     LD    SIO_MODE,#NORMAL_MODE
  4966.     RET
  4967.  
  4968. E_OPTION:
  4969.     LD    SIO_MODE,#EXT_MODE
  4970.  
  4971.  
  4972. LOADUP:
  4973.     OR    SIO_MODE,#LOAD_MODE
  4974.  
  4975.     CALL    LODCMD        ; do the load 
  4976.  
  4977.     LD    SIO_MODE,#NORMAL_MODE
  4978.     RET
  4979.  
  4980.  
  4981.  
  4982. UPLOAD 
  4983. ;***************************************************
  4984. ;*
  4985. ;*    UPLOAD  Upload a program image
  4986. ;*
  4987. ;*    syntax    U <FILENAME> <ADDRESS> <N>
  4988. ;*
  4989. ;*****************************************************;
  4990.     LD    SIO_MODE,#LOAD_MODE
  4991.  
  4992.     CALL    SEND        ; send the records 
  4993.  
  4994.     LD    SIO_MODE,#NORMAL_MODE
  4995.     RET
  4996.  
  4997.  
  4998.  
  4999. LODCMD 
  5000. ;**************************************************
  5001. ;*
  5002. ;* load command expects records of data (ascii chars)
  5003. ;* in the following tek hhex format:
  5004. ;* <address(4)> <count(2)> <cksum1(2)> <data(2)> <data(2)>
  5005. ;*  <data(2)> ... <data(2)> <cksum2(2)>
  5006. ;*
  5007. ;*  the two checksum values are verified before the data
  5008. ;*  is stored in memory (specified by <address>)
  5009. ;*  <cksum1> is the checksum for <address> & <count>
  5010. ;*  <cksum2> is the checksum for the data portion
  5011. ;*
  5012. ;*  if the record is recieved with <count> = 0, this is
  5013. ;*  the end of the load data
  5014. ;*
  5015. ;*  after each data record is recieved, either and acknowledge
  5016. ;*  (ascii 0 followed by cr) or a non-acknowledge (ascii 7
  5017. ;*  followed by a cr) will be sent.
  5018. ;*
  5019. ;*  if the recieved record begins with //, the character string
  5020. ;*  will be sent instead to the terminal and the command aborted.
  5021. ;*
  5022. ;*************************************************************;
  5023.  
  5024.  
  5025.     ; send command to host to download file  
  5026. GOTFILE:
  5027.     OR    CFLAG,#LOAD_SEND    ; set bit for load 
  5028. ;*****    JR    NZ,NXXTR *****          all ok 
  5029. ;*****    RET         *****          ret z 
  5030.  
  5031. NXXTR:
  5032.     CALL    LODREC        ; fetch record in CONIBF 
  5033.     LD    R6,#^HB CONIBF    ; 
  5034.     CLR    R7        ; pointing to CONIBF with RR6 
  5035.     LDC    R0,@RR6        ; check for error (//) 
  5036.     CP    R0,#'/'        ; 
  5037.     JR    NZ,RECOK    ; the record is ok 
  5038.  
  5039.     OR    CFLAG,#LOADABORT ; send error message 
  5040.     RET            ; and forget characters 
  5041.  
  5042. RECOK:
  5043.     CALL    REKCKS        ; verify checksums 
  5044.     JR    NC,LODOK    ; good checksums 
  5045.  
  5046.     CALL    BADCKS        ; bad checksums send non-ack 
  5047.     JR    NXXTR        ; try again 
  5048.  
  5049.     ; check if this is the last record (count = 0) 
  5050.  
  5051. LODOK:
  5052.     CP    R5,#$00        ; data count in R5 
  5053.     JR    NZ,STRED    ; not 0, put data into memory 
  5054.     CALL    GODCKS        ; send acknowledge 
  5055.     RET            ; back to main 
  5056.  
  5057. STRED:
  5058.     CALL    GODCKS        ; send acknowledge 
  5059.     CALL    STREC        ; store data in memory 
  5060.     JR    NXXTR        ; get next record 
  5061.  
  5062.  
  5063.  
  5064.  
  5065. SEND 
  5066. ;***************************************************************
  5067. ;*
  5068. ;* send transfers data in memory to host system.
  5069. ;* all data is converted to ascii characters before
  5070. ;* they are sent. maximum is 30 bytes of data in one
  5071. ;* record in the following format:
  5072. ;*
  5073. ;*    /<address> <count> <cksum1> <data> <data> ... <data>
  5074. ;*     <cksum2> cr
  5075. ;* where
  5076. ;*    <address> - the address of the first byte of data
  5077. ;*    <count>   - # bytes of data in that record
  5078. ;*    <cksum1>  - cksum of <address> & <count>
  5079. ;*    <data>    - data byte of specified memory
  5080. ;*    <cksum2>  - checksum of the data bytes
  5081. ;*
  5082. ;* after all data is sent, a record in the following format will
  5083. ;* be sent at the end:
  5084. ;*
  5085. ;*    /<entry address> 00 <cksum> cr
  5086. ;*    where cksum is the checksum of <entry address>
  5087. ;*
  5088. ;* send command will retry 10 times if a non-acknowledge is received.
  5089. ;* then it will send //error cr to abort command.
  5090. ;*
  5091. ;*
  5092. ;***************************************************************;
  5093.  
  5094.     ; reset host input buffer pointer, insure filename exists 
  5095.  
  5096.     CALL    CKFNAM
  5097.     JR    Z,SENDER    ; no parameter, filename 
  5098.  
  5099.     PUSH    INPTR        ; save pointer at filename 
  5100.  
  5101.     CALL    GETADDR        ; get start address 
  5102.     JR    C,SENDER_POP    ; error, send message 
  5103.     LD    R14,R10        ; save start address 
  5104.     LD    R15,R11        ; in RR12 
  5105.  
  5106.     CALL    GETADDR        ; get length 
  5107.     JR    C,SENDER_POP    ; error, send message 
  5108.     LD    R8,R10        ; save length 
  5109.     LD    R9,R11        ; in RR8 
  5110.  
  5111.     POP    INPTR        ; pointer at filename 
  5112.  
  5113.     AND    CFLAG,#^C LOAD_SEND    ; for send process 
  5114.  
  5115.         JR    OPOK
  5116.  
  5117.     ; send command to host upload data 
  5118. ;****    JR    NZ,OPOK    ****      send was loaded 
  5119. SENDER:
  5120.     RET            ; not loaded 
  5121. SENDER_POP:
  5122.     POP    INPTR        ; syntax error,must 
  5123.     RET            ; pop ptr to filename 
  5124.  
  5125.  
  5126. OPOK:
  5127. NXTR:
  5128.     LD    RETRY,#10    ; retry 10 times max 
  5129.     CP    R8,#$00        ; see if length < 30 
  5130.     JR    NE,SET30    ; not if R8 > 0 
  5131.     CP    R9,#30        ; check lower byte 
  5132.     JR    NC,SET30    ; send 30 
  5133.  
  5134.     LD    R0,R9        ; use R9 for count 
  5135.     CLR    R9        ; clear the count to 0 
  5136.     JR    COTT        ; 
  5137. SET30:
  5138.     LD    R0,#30        ; send 30 bytes each time 
  5139.     RCF            ; clear carry for 2 reg sub 
  5140.     SUB    R9,#30        ; RR8 has length,must sub 30 
  5141.     SBC    R8,#$00        ; only subtract carry from R8 
  5142.  
  5143. COTT:
  5144.     LD    R11,R0        ; save count for possible resend 
  5145.  
  5146.     ; format address, checksum & data in record &
  5147.     ;  send to host  ;
  5148. RESEND:
  5149.  
  5150.     ; delay so that host can set up 
  5151.     PUSH    R3
  5152.     PUSH    R4
  5153.     LD    R3,#$04
  5154.  
  5155. REC_DELAY:
  5156.     LD    R4,#$FF
  5157.     CALL    DELAY
  5158.     DJNZ    R3,REC_DELAY
  5159.  
  5160.     POP    R4
  5161.     POP    R3
  5162.  
  5163.     CALL    RECSND        ; send data record to host 
  5164.     JR    Z,LREC        ; was last record 
  5165.  
  5166.     CALL    WATACK        ; 
  5167.     JR    NZ,RECE79    ; got a 7 or 9 from host 
  5168.     JR    NXTR        ; z means ok, sendnext record 
  5169.  
  5170. RECE79:
  5171.     JR    C,ABTS        ; '9' means abort 
  5172.  
  5173.     ; recieve non-acknowledge, resend same record 
  5174.  
  5175.     SUB    R15,R11        ; set back address 
  5176.     SBC    R14,#$00    ; 
  5177.     LD    R0,R11        ; get back count 
  5178.     DEC    RETRY        ; 1 of 10 chances 
  5179.     JR    Z,SNDABT    ; that was last chance 
  5180.  
  5181.     JR    RESEND        ; 
  5182.  
  5183.     ; send last record /<entry addr> 00 <cksum> cr 
  5184.  
  5185. LREC:
  5186.     CALL    LASREC        ; send last record 
  5187.  
  5188.     CALL    WATACK        ; wait for acknowledge 
  5189.     JR    NZ,C2        ; not done 
  5190.     RET            ; done 
  5191. C2:    JR    NC,RESD        ; nz,nc recieve 7,resend 
  5192. ABTS:    OR    CFLAG,#ABSEND    ; 9 is file error 
  5193.     RET            ; 
  5194.  
  5195.     ; got a '7', so send same data if not the 10th time 
  5196.  
  5197. RESD:    DEC    RETRY        ; try counter 
  5198.     JR    NZ,RESEND    ; 
  5199.  
  5200. SNDABT:
  5201.     CALL    SNDERR        ; format an error record for host 
  5202.     OR    CFLAG,#ABSEND    ; abort 
  5203.     RET            ; with an error message 
  5204.  
  5205.  
  5206.  
  5207.  
  5208. RECSND 
  5209. ;*********************************************************
  5210. ;*
  5211. ;*    recsnd formats address, count, checksums & data in
  5212. ;*    tektronix format. it sends the data to the host
  5213. ;*    system or the terminal.
  5214. ;*    if the count = 0, just store '/' in buffer & don't
  5215. ;*    format the data
  5216. ;*
  5217. ;*    input:    R0 has count, RR12 has start address
  5218. ;*    output:    RR14 increased by count (R0)
  5219. ;*        return z for last record
  5220. ;*        return nz when record is sent and
  5221. ;*            ready for acknowledge.
  5222. ;*
  5223. ;************************************************************;
  5224.     LD    R6,#^HB CONOBF        ; pt to output buffer 
  5225.     CLR    R7            ; with RR0 
  5226.     LD    R4,#'/'            ; first character 
  5227.     LDC    @RR6,R4            ; 
  5228.     INCW    RR6            ; 
  5229.     CP    R0,#$00            ; any data ? 
  5230.     JR    NE,SENDDATA        ; yes 
  5231.     RET                ; no data 
  5232. SENDDATA:
  5233.     CLR    R3            ; checksum accumualtor 
  5234.     LD    R5,R14            ; format address 
  5235.     CALL    PUT1            ; and put into buffer 
  5236.     LD    R5,R15            ; 
  5237.     CALL    PUT1            ; 
  5238.     LD    R5,R0            ; and count 
  5239.     CALL    PUT1            ; 
  5240.     LD    R5,R3            ; then checksum1 
  5241.     CALL    PUT1            ; 
  5242.     ; format <data> <data> ... <data> <checksum2> 
  5243.     CLR    R3            ; clear checksum accumulator 
  5244. MDATA:
  5245.     PUSH    R8
  5246.     PUSH    R9
  5247.     PUSH    R14            ; hi addr 
  5248.     PUSH    R15            ; lo addr 
  5249.     LD    R8,R14
  5250.     LD    R9,R15
  5251.     CALL    GETMEM            ; lde    R5,@RR14 
  5252.     LD    R5,R15            ; data 
  5253.     POP    R15            ; 
  5254.     POP    R14            ; 
  5255.     POP    R9            ; 
  5256.     POP    R8            ; 
  5257.     CALL    PUT1            ; add to checksum 
  5258.     INCW    RR14            ; next data byte 
  5259.     DJNZ    R0,MDATA        ; until all data converted 
  5260.  
  5261.     LD    R5,R3            ; and checksum 
  5262.     CALL    PUT1            ; 
  5263.  
  5264.     LD    R4,#ASCIILF        ; end with a <LF> 
  5265.     LDC    @RR6,R4            ; 
  5266.     INC    R7            ; send <LF> also 
  5267.     LD    OUTLEN,R7        ; into outlen 
  5268.     CALL    OTMSG            ; to send to host 
  5269.     INC    R6            ; reset z flag 
  5270.  
  5271.     RET                ; 
  5272.  
  5273.  
  5274.  
  5275. LASREC 
  5276. ;*******************************************************
  5277. ;*    lasrec formats entry address with 0 count and
  5278. ;*    checksum in tektronix format for the last record
  5279. ;*    and sends it to the host
  5280. ;*
  5281. ;*    input    RR10 is entry address
  5282. ;*
  5283. ;*******************************************************;
  5284.     CLR    R3        ; clear accumulator 
  5285.  
  5286.     LD    R5,#$00        ; address 
  5287.     CALL    PUT1        ; put into buffer 
  5288.     LD    R5,#$0C        ; low byte 
  5289.     CALL    PUT1        ; 
  5290.  
  5291.     CLR    R5        ; 0 byte count 
  5292.     CALL    PUT1        ; 
  5293.     LD    R5,R3        ; the checksum 
  5294.     CALL    PUT1        ; 
  5295.     LD    R4,#ASCIILF    ; read ascii on host side 
  5296.     LDC    @RR6,R4        ; 
  5297.     INC    R7        ; send <LF> also 
  5298.     LD    OUTLEN,R7    ; into outlen 
  5299.     CALL    OTMSG        ; output to host 
  5300.     RET
  5301.  
  5302.  
  5303.  
  5304.  
  5305. PUT1 
  5306. ;*******************************************************            
  5307. ;*    add each nibble of R5 to the checksum accumulator R3
  5308. ;*    convert contents of R5 to 2 ascii characters
  5309. ;*    enter characters into buffer pointed to by RR6
  5310. ;*    RR6 gets incremented in 'nibble'
  5311. ;********************************************************;
  5312.     LD    R4,R5            ; do high byte first 
  5313.     SWAP    R4            ; 
  5314.     AND    R4,#$0F            ; isolate nibble 
  5315.     ADD    R3,R4            ; checksum 
  5316.     CALL    NOOBLE            ; puts it into buffer
  5317.                     ;  increments pointer ;
  5318.  
  5319.     LD    R4,R5            ; low nibble 
  5320.     AND    R4,#$0F            ; isolate nibble 
  5321.     ADD    R3,R4            ; checksum 
  5322.     CALL    NOOBLE            ; into buffer 
  5323.     RET                ; 
  5324.  
  5325.  
  5326.  
  5327. NOOBLE 
  5328. ;***********************************************************
  5329. ;*
  5330. ;*    convert hex to ASCII and put into memory @RR6
  5331. ;*
  5332. ;*    input:    R4 has hex value in lower nibble
  5333. ;*
  5334. ;************************************************************;
  5335.     and    R4,#$0F        ; isolate lower nibble 
  5336.     add    r4,#$90
  5337.     da    r4
  5338.     adc    r4,#$40
  5339.     da    r4
  5340.     LDC    @RR6,R4        ; put into buffer 
  5341.     inc    r7        ; point to next location 
  5342.     ret 
  5343.  
  5344.  
  5345. CKFNAM 
  5346. ;**************************************************************
  5347. ;*
  5348. ;*    ckfname resets two pointers of the ram buffer before
  5349. ;*    starting the upload/download procedure. also checks
  5350. ;*    that the filename is included in the command.
  5351. ;*
  5352. ;*        z flag on => no filename
  5353. ;*        z flag off => filename present
  5354. ;*
  5355. ;**************************************************************;
  5356.  
  5357.     CLR    HOSTGET        ; these are offsets 
  5358.     CLR    HOSTPUT        ; not pointers 
  5359.     CALL    FINDNEXT    ; get the filename 
  5360.     JR    NZ,GOTIT    ; filename present 
  5361.     OR    CFLAG,#$02    ; missing filename 
  5362. GOTIT:
  5363.     RET            ; there is a filename 
  5364.  
  5365.  
  5366.  
  5367.  
  5368. LODREC 
  5369. ;************************************************************
  5370. ;*
  5371. ;*    lodrec reads in an input line into conibf from the host
  5372. ;*    and starts storing data once a '/' is recieved.
  5373. ;*    the input line is terminated by a carriage return.
  5374. ;*    it will read in a maximum of 80 characters (ascii)
  5375. ;*    and ignore the rest until a carriage return is recieved.
  5376. ;*    all control characters are skipped ( <20h)
  5377. ;*
  5378. ;*    output:    data in conibf
  5379. ;***********************************************************;
  5380.     CALL    HOSTINP        ; get the character 
  5381.     CP    R4,#'/'        ; wait for '/' 
  5382.     JR    NZ,LODREC    ; 
  5383.  
  5384.     LD    R2,#^HB CONIBF    ; start at beginning of conibf 
  5385.     CLR    R3        ; use RR6 
  5386.     LD    R8,#80        ; maximum character count 
  5387.  
  5388.     ; start storing characters , ignore control characters
  5389.     ;  also check for carriage return for end of record ;
  5390. LODRC0:
  5391.     CALL    HOSTINP        ; get next character 
  5392.     LDC    @RR2,R4        ; put into conibf 
  5393.     CP    R4,#ASCIICR    ; end of record? 
  5394.     JR    EQ,DONE_LODREC
  5395.     CP    R4,#ASCIILF    ; end of record? 
  5396.     JR    EQ,DONE_LODREC
  5397.  
  5398. CKCT:
  5399.     CP    R4,#ASCIISP    ; ignore control characters 
  5400.     JR    C,LODRC0    ; was a control char 
  5401.  
  5402.     INCW    RR2        ; increment pointer 
  5403.     DJNZ    R8,LODRC0    ; next character 
  5404.  
  5405.     ; have received 80 characters, skip over all characters
  5406.     ;  until carriage return ;
  5407. LODRC2:
  5408.     CALL    HOSTINP        ; ignore all but <CR> 
  5409.     CP    R4,#ASCIICR    ; 
  5410.     JR    EQ,TERM_REC
  5411.     CP    R4,#ASCIILF    ; and <LF> 
  5412.     JR    EQ,TERM_REC
  5413.  
  5414.     JR    LODRC2        ; 
  5415.  
  5416. TERM_REC:
  5417.     LD    R3,#80        ; put terminator here 
  5418.     LDC    @RR2,R4        ; get <CR> into buffer 
  5419.                 ; returns z flag on 
  5420.  
  5421. DONE_LODREC:
  5422.     RET
  5423.  
  5424.  
  5425.  
  5426.  
  5427. REKCKS 
  5428. ;************************************************************
  5429. ;*
  5430. ;*    rekcks verifies two checksums values in a record
  5431. ;*    stored in conibf. all ascii characters in conibf are
  5432. ;*    converted to 4-bit hex value to obtain checksum
  5433. ;*    which is the sum of all these 4 bit hex values.
  5434. ;*
  5435. ;*    the format of the record is as follows:
  5436. ;*    <address(4)> <count(2)> <cksum1(2)> <data(2)>
  5437. ;*    ... <data(2)> <cksum2(2)> <CR>
  5438. ;*
  5439. ;*    input: record in conibf
  5440. ;*        RR6 pointing to conibf
  5441. ;*
  5442. ;*    output:    R5 has count in byte value
  5443. ;*
  5444. ;*        return c if checksum bad
  5445. ;*        return c if non-ascii found in conibf
  5446. ;*        return nc if ok
  5447. ;*
  5448. ;*************************************************************;
  5449.     LD    R5,#$03        ; chksum is for 3 pairs 
  5450.     CALL    CHKCKS        ; verify first checksum 
  5451.     JR    C,REKCKS_END    ; bad checksum 
  5452.  
  5453.     CP    R5,#$00        ; this is the count 
  5454.     JR    Z,REKCKS_END    ; no data if count 0 
  5455.  
  5456.     PUSH    R5        ; save count 
  5457.     CALL    CHKCKS        ; verify second check sum 
  5458.  
  5459.     POP    R5        ; get count back 
  5460. REKCKS_END:
  5461.     RET            ; all exits here 
  5462.  
  5463.  
  5464.  
  5465.  
  5466. CHKCKS 
  5467. ;************************************************************
  5468. ;*
  5469. ;*    chkcks verifies the checksum in the record. converts
  5470. ;*    each ascii character in the record to the hex value
  5471. ;*    and accumulates their values to obtain the checksum.
  5472. ;*    the checksum is then compared with the check sum in the
  5473. ;*    record following the character string. all characters
  5474. ;*    including the checksum are ascii characters
  5475. ;*
  5476. ;*    input:    RR6 pointer to the ascii string
  5477. ;*        R5  # of char pairs in this chksum calculation
  5478. ;*
  5479. ;*    output:    R5 count value of the record
  5480. ;*        R2 calculated checksum
  5481. ;*        R4 checksum in the record
  5482. ;*
  5483. ;*        return c if cksum bad
  5484. ;*        return c if found non-ascii character
  5485. ;*        return nc if chksum is correct
  5486. ;*
  5487. ;***********************************************************;
  5488.     ; init cksum accumulator (R2), convert the
  5489.      ; next pair of characters to hex and sum their
  5490.       ;hex values. ;
  5491.     CLR    R2        ; checksum accumulator 
  5492. CHKSM2:
  5493.     CALL    LODBYL        ; convert next two characters 
  5494.                 ; to hex & add to chksm accum 
  5495.     JR    C,CHKCKS_END    ; bad ascii 
  5496.     DJNZ    R5,CHKSM2    ; R3 is number of pairs 
  5497.  
  5498.     ; save 8 bit hex value of last two characters
  5499.       ;(count of the data in the record). save calculated
  5500.       ;cksum then convert next two chars to get chksm in
  5501.       ;the record and compare the two chksum ;
  5502.  
  5503.     LD    R5,R4        ; get count into R5 
  5504.     PUSH    R5        ; save count 
  5505.     PUSH    R2        ; and checksum 
  5506.  
  5507.     CALL    LODBYL        ; convert next two characters 
  5508.  
  5509.     POP    R2        ; get record checksum in R4 
  5510.     POP    R5        ; 
  5511.     JR    C,CHKCKS_END    ; bad ascii 
  5512.  
  5513.     CP    R4,R2        ; return nc if match 
  5514.     JR    Z,CHKCKS_END    ; 
  5515.     SCF            ; return carry if no match 
  5516. CHKCKS_END:
  5517.     RET            ; common exit 
  5518.  
  5519.  
  5520.  
  5521.  
  5522. LODBYL 
  5523. ;*********************************************************
  5524. ;*
  5525. ;*    convert two ascii characters to two 4-bit hex
  5526. ;*    and add the two hex values to an accumulator
  5527. ;*
  5528. ;*    input:    RR6 points to first ascii character
  5529. ;*        R2 is the accumulator
  5530. ;*
  5531. ;*    output:    RR6 updated
  5532. ;*        R2 updated
  5533. ;*        R4 8 bit hex result of conversion
  5534. ;*
  5535. ;*        return c if any characters non-ascii
  5536. ;*        return nc if ok
  5537. ;*
  5538. ;********************************************************;
  5539.     CALL    HEXDCD        ; convert char ptd by RR6 
  5540.     JR    C,LODBYL_END    ; bad ascii 
  5541.  
  5542.     ADD    R2,R4        ; add to accumulator 
  5543.     LD    R1,R4        ; save value in R1 
  5544.     SWAP    R1        ; put in upper nibble 
  5545.  
  5546.     CALL    HEXDCD        ; convert next 4 bits 
  5547.     JR    C,LODBYL_END    ; common exit 
  5548.  
  5549.     ADD    R2,R4        ; add to accumulator 
  5550.     OR    R4,R1        ; 8 bit value in R4 
  5551.     RCF            ; reset carry 
  5552. LODBYL_END:
  5553.     RET            ; common exit 
  5554.  
  5555.  
  5556.  
  5557.  
  5558. HEXDCD 
  5559. ;********************************************************
  5560. ;*
  5561. ;*    convert ascii character pointed to by RR6 to
  5562. ;*    the 4 bit hex value. increment RR6 by one.
  5563. ;*
  5564. ;*    input: RR6 pointer to ascii character
  5565. ;*
  5566. ;*    output: RR6 advanced by one
  5567. ;*        R4 4-bit value of ascii char
  5568. ;*
  5569. ;*        return c if character is non-ascii
  5570. ;*        return nc if ok
  5571. ;*
  5572. ;******************************************************;
  5573.  
  5574.     LDC    R4,@RR6        ; get the character 
  5575.     INCW    RR6        ; 
  5576.     JP    CONVERT        ; convert to hex 
  5577.  
  5578.  
  5579.  
  5580.  
  5581. STREC 
  5582. ;**********************************************************
  5583. ;*
  5584. ;*    strec unpacks data in record & stores them into
  5585. ;*    memory location specified by address in record
  5586. ;*
  5587. ;*    input:    record in conibf
  5588. ;*        R5 # of bytes of data in record
  5589. ;*
  5590. ;************************************************************;
  5591.  
  5592.     LD    R8,R5        ; use R8 to count down data 
  5593.  
  5594.     ; convert <address> & <count> to hex value.
  5595.       ;store byte data in memory. the number of bytes
  5596.       ;is specified by <count> ;
  5597.     CALL    RECADR        ; calculate record address 
  5598.     LD    R7,#$08        ; skip count and checksum 
  5599.  
  5600. LODFR3:
  5601.     CALL    LODBYL        ; convert next two char 
  5602.     PUSH    R4        ; 
  5603.     PUSH    R8        ; 
  5604.     PUSH    R9        ; 
  5605.     PUSH    R14        ; 
  5606.     PUSH    R15        ; 
  5607.  
  5608.     LD    R8,R14        ; save address 
  5609.     LD    R9,R15
  5610.     LD    R15,R4        ; save data 
  5611.  
  5612.     TM    SIO_MODE,#EXT_MODE ; extension load? 
  5613.     JR    Z,NO_EXT    ; no 
  5614.     CALL    PUTEXT        ; yes, store it 
  5615.     JR    CLEAN_UP
  5616.  
  5617. NO_EXT:
  5618.     CALL    PUTMEM        ; lde    @RR8,R15 
  5619.  
  5620. CLEAN_UP:
  5621.     POP    R15        ; 
  5622.     POP    R14        ; 
  5623.     POP    R9        ; 
  5624.     POP    R8        ; 
  5625.     POP    R4        ; 
  5626.     INCW    RR14        ; increment memory pointer 
  5627.     DJNZ    R8,LODFR3    ; next byte 
  5628.     RET            ; done 
  5629.  
  5630.  
  5631.  
  5632. RECADR 
  5633. ;***********************************************************
  5634. ;*
  5635. ;*    convert the starting address in load record to
  5636. ;*    the hex value and put into RR0
  5637. ;*
  5638. ;***********************************************************;
  5639.     LD    R6,#^HB CONIBF    ; point to begin of rec 
  5640.     CLR    R7        ; 
  5641.     CALL    LODBYL        ; get first byte of address 
  5642.     LD    R14,R4        ; 
  5643.     CALL    LODBYL        ; get lo byte of address 
  5644.     LD    R15,R4        ; 
  5645.     RET            ; got it 
  5646.  
  5647.  
  5648.  
  5649.  
  5650. BADCKS 
  5651. ;************************************************************
  5652. ;*
  5653. ;*    badcks sends non-acknowledge (ascii 7 (37h) & <CR> )
  5654. ;*    for receiving a non-ascii character or if the checksum
  5655. ;*    is incorrect.
  5656. ;*
  5657. ;*    godcks sends an acknowledge (ascii 0 (30h) & <CR> ) for
  5658. ;*    valid record of data
  5659. ;*
  5660. ;*************************************************************;
  5661.     LD    R4,#'7'        ; output to host 
  5662.     JR    MSEND        ; 
  5663.  
  5664. GODCKS:
  5665.     LD    R4,#'0'        ; output to host 
  5666. MSEND:
  5667.  
  5668.     ; delay so that host has time to set up 
  5669.     PUSH    R4
  5670.     LD    R4,#$80
  5671.     CALL    DELAY
  5672.     POP    R4
  5673.  
  5674.     CALL    OUTCHR        ; output 
  5675.  
  5676.     ; delay so that host has time to set up 
  5677.     LD    R4,#$80
  5678.     CALL    DELAY
  5679.  
  5680.     LD    R4,#ASCIICR    ; read ascii of rio 
  5681.     CALL    OUTCHR        ; 
  5682.     RET            ; 
  5683.  
  5684.  
  5685.  
  5686. WATACK 
  5687. ;**************************************************************
  5688. ;*    expects either acknowledge (ascii 0) or non-acknowledge
  5689. ;*    (ascii 7) from serial line. ignore other characters
  5690. ;*
  5691. ;*    good-ack from host        returns z, nc
  5692. ;*    non-ack from host        returns nz,nc
  5693. ;*    abort-ack from host        returns nz,c
  5694. ;*
  5695. ;***************************************************************;
  5696.     CALL MCHAR        ; get character 
  5697.     CP    R4,#'0'        ; good ack? 
  5698.     JR    NZ,CK79        ; check for 7 or 9 
  5699.     CALL    SKIP_EOL    ; skip to end of line 
  5700.     RCF            ; reset carry flag 
  5701.     XOR    R4,R4        ; set z flag 
  5702.     JR    END_ACK        ; z,nc is good ack 
  5703. CK79:
  5704.     CP    R4,#'7'        ; check for non-ack 
  5705.     JR    NZ,CK9        ; no 
  5706.     CALL    SKIP_EOL    ; skip to end of line 
  5707.     INC    R4        ; reset the z flag 
  5708.     RCF            ; reset the carry flag 
  5709.     JR    END_ACK        ; nz,nc is non-ack 
  5710. CK9:
  5711.     CP    R4,#'9'        ; check for abort acknowledge 
  5712.     JR    Z,MATC        ; yes 
  5713.     CALL    HOSTINP        ; advance pointer to get next 
  5714.     JR    WATACK        ; ignore character 
  5715. MATC:
  5716.     CALL    SKIP_EOL    ; skip to end of line 
  5717.     INC    R4        ; reset the z flag 
  5718.     SCF            ; set carry flag 
  5719.  
  5720. END_ACK:
  5721.     RET            ; return nz,c for abort 
  5722.  
  5723.  
  5724.  
  5725. SNDERR 
  5726. ;***********************************************************
  5727. ;*
  5728. ;*    formats an error record to send to host
  5729. ;*
  5730. ;*    error record is '//<CR>'
  5731. ;*
  5732. ;*    this is an abort initiated by the 'send' command
  5733. ;*
  5734. ;*    because of too many checksum errors detected by
  5735. ;*
  5736. ;*    the host system on a single record
  5737. ;*
  5738. ;**********************************************************;
  5739.     LD    R6,#^HB CONIBF    ; point to record buffer 
  5740.     CLR    R7        ; 
  5741.     LD    R4,#'/'        ; put two '/'s in the buffer 
  5742.     LDC    @RR6,R4        ; 
  5743.     INCW    RR6        ; 
  5744.     LDC    @RR6,R4        ; 
  5745.     INCW    RR6        ; 
  5746.     LD    R4,#ASCIICR    ; and follow with a <CR> 
  5747.     LDC    @RR6,R4        ;
  5748.     INC    R7        ; get count
  5749.     LD    OUTLEN,R7    ; and send over serial
  5750.     JP    OTMSG        ; channel to host
  5751.  
  5752.  
  5753.  
  5754. SKIP_EOL
  5755. ;************************************************************
  5756. ;*
  5757. ;*    skip over input line until <CR> is recieved from host.
  5758. ;*
  5759. ;*************************************************************;
  5760.     CALL    HOSTINP        ; input from the host
  5761.     CP    R4,#ASCIICR    ; until <CR>
  5762.     JR    NE,SKIP_EOL    ;
  5763.  
  5764.     RET
  5765.  
  5766.  
  5767.  
  5768. HOSTINP
  5769. ;************************************************************
  5770. ;*
  5771. ;*    gets a character from the host input interrupt buffer.
  5772. ;*    if no character is in the buffer, it waits...
  5773. ;*
  5774. ;*    hostput updated to point to next character
  5775. ;*    character returned in R4
  5776. ;*
  5777. ;*************************************************************;
  5778.     CALL    MCHAR        ;
  5779.     INC    HOSTPUT        ;
  5780.     RET            ;
  5781.  
  5782.  
  5783.  
  5784. MCHAR
  5785. ;***********************************************************
  5786. ;*
  5787. ;*    same as hostinp except don't update pointer
  5788. ;*
  5789. ;***********************************************************;
  5790.     CP    HOSTGET,HOSTPUT    ; got a character
  5791.     JR    EQ,MCHAR    ;
  5792.  
  5793.     PUSH    R6        ;
  5794.     PUSH    R7        ;
  5795.     LD    R6,#^HB HOSTBUF    ; get full pointer
  5796.     LD    R7,HOSTPUT    ;
  5797.     LDC    R4,@RR6        ;
  5798.     POP    R7        ;
  5799.     POP    R6        ;
  5800.     RET            ;
  5801.  
  5802.   ;********************************************************
  5803. ;*
  5804. ;*    dasm.s : Super8 disassembler
  5805. ;*
  5806. ;*   This version doctored for the META assembler
  5807. ;*
  5808. ;*********************************************************;
  5809.  
  5810. ONE_BYTE:    equ    $00    ; one-byte inst.
  5811. TWO_BYTES:    equ    $20    ; two-byte inst.
  5812. THREE_BYTES:    equ    $40    ; three-byte inst.
  5813. FOUR_BYTES:    equ    $60    ; four-byte inst.
  5814. HI_BIT:        equ    $80    ; most sig. bit
  5815. ONE_M:        equ    $00+$80    ; one-byte inst.
  5816. TWO_M:        equ    $20+$80    ; two-byte inst.
  5817. THREE_M:    equ    $40+$80    ; three-byte inst.
  5818. FOUR_M:        equ    $60+$80    ; four-byte inst.
  5819. COMMA:        equ    $2C    ; ASCII comma
  5820. VARY_MNE:    equ    $00    ; var. mnemonics glag
  5821. AD_TYPE_0:    equ    $00    ; address mode types
  5822. AD_TYPE_1:    equ    $01
  5823. AD_TYPE_2:    equ    $02
  5824. AD_TYPE_3:    equ    $03
  5825. AD_TYPE_4:    equ    $04
  5826. AD_TYPE_5:    equ    $05
  5827. AD_TYPE_6:    equ    $06
  5828. AD_TYPE_7:    equ    $07
  5829. AD_TYPE_8:    equ    $08
  5830. AD_TYPE_9:    equ    $09
  5831. AD_TYPE_A:    equ    $0A
  5832. AD_TYPE_B:    equ    $0B
  5833. AD_TYPE_C:    equ    $0C
  5834. AD_TYPE_D:    equ    $0D
  5835. AD_TYPE_E:    equ    $0E
  5836. AD_TYPE_F:    equ    $0F
  5837. AD_TYPE_10:    equ    $10
  5838. AD_TYPE_11:    equ    $11
  5839. AD_TYPE_12:    equ    $12
  5840. AD_TYPE_13:    equ    $13
  5841. AD_TYPE_14:    equ    $14
  5842. AD_TYPE_15:    equ    $15
  5843. AD_TYPE_16:    equ    $16
  5844. AD_TYPE_17:    equ    $17
  5845. AD_TYPE_18:    equ    $18
  5846. AD_TYPE_19:    equ    $19
  5847. AD_TYPE_1A:    equ    $1A
  5848. AD_TYPE_1B:    equ    $1B
  5849. AD_TYPE_1C:    equ    $1C
  5850.  
  5851.  
  5852. DIS_ASM
  5853. ;**********************************************************
  5854. ;*
  5855. ;*    ZAP  disassemble SUPER8 instructions
  5856. ;*
  5857. ;*    syntax    Z <address> [<n>]
  5858. ;*
  5859. ;*    defaults    <n> = 1
  5860. ;*
  5861. ;*    Disassemble <n> instructions starting at <address>
  5862. ;*    Maximum value for <n> = $FF
  5863. ;*
  5864. ;*    input: AD_IN_HI,AD_IN_LO point to memory location to be
  5865. ;*           disassembled.
  5866. ;*           AD_OUT_HI,AD_OUT_LO point to output buffer
  5867. ;*
  5868. ;*    output:    The output buffer is filled with the disassembled
  5869. ;*        instruction.
  5870. ;*
  5871. ;**************************************************************;
  5872.  
  5873.     PUSH    R0        ; save all regs
  5874.     PUSH    R1        ; except R6,R7
  5875.     PUSH    R2
  5876.     PUSH    R3
  5877.     PUSH    R4
  5878.     PUSH    R5
  5879.     PUSH    R8
  5880.     PUSH    R9
  5881.     PUSH    R10
  5882.     PUSH    R11
  5883.     PUSH    R12
  5884.     PUSH    R13
  5885.     PUSH    R14
  5886.     PUSH    R15
  5887.  
  5888.  
  5889.     ; write output buffer with 70 spaces
  5890.  
  5891.     LD    R10,#BUF_LGTH    ; loop of 70
  5892.     LD    R11,#' '    ; ASCII space
  5893.     LD    R12,AD_OUT_HI    ; output buffer
  5894.     LD    R13,AD_OUT_LO    ;  address
  5895. LP1A:
  5896.     LDC    @RR12,R11    ; write one space
  5897.     INCW    RR12        ; points to next
  5898.     DJNZ    R10,LP1A    ; loop 80. times
  5899.     LD    R11,#$0D    ; carrage return
  5900.     LDC    @RR12,R11    ; output
  5901.  
  5902.     ; initialize output buffer pointer
  5903.     LD    R2,AD_OUT_HI    ; output buffer
  5904.     LD    R3,AD_OUT_LO    ;  address
  5905.  
  5906.     ; initialize memory pointer
  5907.     LD    R0,AD_IN_HI    ;  memory address
  5908.     LD    R1,AD_IN_LO    ;
  5909.  
  5910.     ; tab in 4 spaces before writing
  5911.     LD    R15,#$04    ; tab 4 spaces
  5912.     CALL    TAB_SP
  5913.  
  5914.     ; write address in output buffer
  5915.     LD    R10,AD_IN_HI    ; first hi addr
  5916.     CALL    HEX_ASCII    ;  inti buffer
  5917.     LD    R10,AD_IN_LO    ; then lo addr
  5918.     CALL    HEX_ASCII    ;  into buffer
  5919.     LD    R15,#$04    ; tab 4 spaces
  5920.     CALL    TAB_SP
  5921.  
  5922.     ; get opcode and write first byte in out buf
  5923.     CALL    RD_MEM        ; read first byte into R10
  5924.     INCW    RR0        ; point to next
  5925.     LD    R12,R10        ; save opcode
  5926.     LD    BYTE_1,R10    ; save first byte
  5927.     CALL    HEX_ASCII    ; write out buffer
  5928.  
  5929.     ; find table entry that = hex mnemonic
  5930.     LD    R4,#^HB OP_TAB    ; get starting
  5931.     LD    R5,#^LB OP_TAB    ;  addr of table
  5932.     LDC    R10,@RR4    ; read first control
  5933. AGN3:
  5934.     CP    R12,#$00    ; there yet ?
  5935.     JR    Z,DONE1        ; if zero yes
  5936.  
  5937. AGN2:    INCW    RR4        ; find next
  5938.     LDC    R10,@RR4    ; control byte
  5939.     TM    R10,#$80    ; bit 7 set
  5940.     JR    Z,AGN2        ; loop 2 till
  5941.     DEC    R12        ;  bit 7 set
  5942.     JR    AGN3        ;test for zero
  5943.  
  5944. DONE1:
  5945.     LD    R8,R10        ; save control in R8
  5946.  
  5947.     ; get type of instruction from control byte
  5948.     LD    R11,R8        ; save control
  5949.     AND    R11,#$1F    ;isolate least sig. 5 bits
  5950.     LD    TYPE_,R11    ; save in type_
  5951.  
  5952.     ; test for quantity of bytes in instruction
  5953.     ; encoded as (n - 1) in bits 5 and 6 of control byte
  5954.     LD    R9,R8        ; save size in R9
  5955.     AND    R9,#FOUR_BYTES    ;isolate bits 5,6
  5956.  
  5957.     CP    R9,#ONE_BYTE    ; test for one byte
  5958.     JR    NZ, BY_2    ; no - at least two
  5959.  
  5960.     ; one byte instruction -- pad with spaces
  5961.     LD    R15,#$12    ; tab 18. spaces
  5962.     CALL    TAB_SP
  5963.     JR    MNE        ; ASCII mnemonic
  5964.  
  5965. BY_2:
  5966.     INCW    RR2        ; tab two spaces
  5967.     INCW    RR2
  5968.     CALL    RD_MEM        ; read second byte
  5969.     INCW    RR0        ; point to third
  5970.     LD    BYTE_2,R10    ; save byte 2
  5971.     CALL    HEX_ASCII    ; write to buffer
  5972.  
  5973.     CP    R9,#TWO_BYTES    ; test for two bytes
  5974.     JR    NZ, BY_3    ; no - at least three
  5975.  
  5976.     ; two byte instruction -- pad with spaces
  5977.     LD    R15,#$0E    ; tab 14. spaces
  5978.     CALL    TAB_SP
  5979.     JR    MNE        ; ASCII mnemonic
  5980.  
  5981. BY_3:
  5982.     INCW    RR2        ; tab two spaces
  5983.     INCW    RR2
  5984.     CALL    RD_MEM        ; read third byte
  5985.     INCW    RR0        ; point to fourth
  5986.     LD    BYTE_3,R10    ; save byte 3
  5987.     CALL    HEX_ASCII    ; write to buffer
  5988.  
  5989.     CP    R9,#THREE_BYTES ; test for three bytes
  5990.     JR    NZ, BY_4    ; no - four bytes
  5991.  
  5992.     ; three byte instruction -- pad with spaces
  5993.     LD    R15,#$0A    ; tab 10. spaces
  5994.     CALL    TAB_SP
  5995.     JR    MNE        ; ASCII mnemonic
  5996.  
  5997. BY_4:
  5998.     INCW    RR2        ; tab two spaces
  5999.     INCW    RR2
  6000.     CALL    RD_MEM        ; read fourth byte
  6001.     INCW    RR0        ; point to next
  6002.     LD    BYTE_4,R10    ; save byte 4
  6003.     CALL    HEX_ASCII    ; write to buffer
  6004.     LD    R15,#$06    ; tab 6. spaces
  6005.     CALL    TAB_SP
  6006.  
  6007.     ; output mnemonic to buffer
  6008. MNE:
  6009.     INCW    RR4        ; first ASCII
  6010.     LD    R11,#$09    ; 6 ch +3 spaces
  6011.  
  6012.     LDC    R10,@RR4    ; read letter
  6013.     LD    R8,R10        ; check for varying
  6014.     TM    R8,#$F0        ; mnemonics
  6015.     JR    NZ,AGN4        ; not varying
  6016.     CALL    CHK_MNE        ; varies
  6017.  
  6018. AGN4:                ; letter of mnemonic
  6019.     LDC    R10,@RR4    ; read letter
  6020.  
  6021.     TM    R10,#$80    ; test next byte
  6022.     JR    NZ,SK_SP    ;  for control byte
  6023.  
  6024.     LDC    @RR2,R10    ; write letter
  6025.     INCW    RR2        ; point next wr
  6026.     INCW    RR4        ; point next rd
  6027.     DEC    R11
  6028.     JR    AGN4        ; do 2 to 6 times
  6029.  
  6030. SK_SP:
  6031.     LD    R15,R11        ; add remaining spaces
  6032.     CALL    TAB_SP
  6033.  
  6034.  
  6035.     ; call routine 0 through 15 as function type
  6036.  
  6037.     CP    TYPE_,#AD_TYPE_0
  6038.     JP    EQ, DONE_DASM
  6039.     CP    TYPE_,#AD_TYPE_1
  6040.     JP    EQ, TYPE_01
  6041.     CP    TYPE_,#AD_TYPE_2
  6042.     JP    EQ, TYPE_02
  6043.     CP    TYPE_,#AD_TYPE_3
  6044.     JP    EQ, TYPE_03
  6045.     CP    TYPE_,#AD_TYPE_4
  6046.     JP    EQ,TYPE_04
  6047.     CP    TYPE_,#AD_TYPE_5
  6048.     JP    EQ,TYPE_05
  6049.     CP    TYPE_,#AD_TYPE_6
  6050.     JP    EQ,TYPE_06
  6051.     CP    TYPE_,#AD_TYPE_7
  6052.     JP    EQ,TYPE_07
  6053.     CP    TYPE_,#AD_TYPE_8
  6054.     JP    EQ,TYPE_08
  6055.     CP    TYPE_,#AD_TYPE_9
  6056.     JP    EQ,TYPE_09
  6057.     CP    TYPE_,#AD_TYPE_A
  6058.     JP    EQ,TYPE_0A
  6059.     CP    TYPE_,#AD_TYPE_B
  6060.     JP    EQ,TYPE_0B
  6061.     CP    TYPE_,#AD_TYPE_C
  6062.     JP    EQ,TYPE_0C
  6063.     CP    TYPE_,#AD_TYPE_D
  6064.     JP    EQ,TYPE_0D
  6065.     CP    TYPE_,#AD_TYPE_E
  6066.     JP    EQ,TYPE_0E
  6067.     CP    TYPE_,#AD_TYPE_F
  6068.     JP    EQ,TYPE_0F
  6069.  
  6070.     CP    TYPE_,#AD_TYPE_10
  6071.     JP    EQ,TYPE_10
  6072.     CP    TYPE_,#AD_TYPE_11
  6073.     JP    EQ,TYPE_11
  6074.     CP    TYPE_,#AD_TYPE_12
  6075.     JP    EQ,TYPE_12
  6076.     CP    TYPE_,#AD_TYPE_13
  6077.     JP    EQ,TYPE_13
  6078.     CP    TYPE_,#AD_TYPE_14
  6079.     JP    EQ,TYPE_14
  6080.     CP    TYPE_,#AD_TYPE_15
  6081.     JP    EQ,TYPE_15
  6082.     CP    TYPE_,#AD_TYPE_16
  6083.     JP    EQ,TYPE_16
  6084.     CP    TYPE_,#AD_TYPE_17
  6085.     JP    EQ,TYPE_17
  6086.     CP    TYPE_,#AD_TYPE_18
  6087.     JP    EQ,TYPE_18
  6088.     CP    TYPE_,#AD_TYPE_19
  6089.     JP    EQ,TYPE_19
  6090.     CP    TYPE_,#AD_TYPE_1A
  6091.     JP    EQ,TYPE_1A
  6092.     CP    TYPE_,#AD_TYPE_1B
  6093.     JP    EQ,TYPE_1B
  6094.     CP    TYPE_,#AD_TYPE_1C
  6095.     JP    EQ,TYPE_1C
  6096.  
  6097.     ; common exit point from disassembler
  6098. DONE_DASM:
  6099.     ; update memory pointer
  6100.     LD    AD_IN_HI,R0    ; output buffer
  6101.     LD    AD_IN_LO,R1    ;  address
  6102.  
  6103.     POP    R15        ; restore all regs
  6104.     POP    R14        ; except R6,R7
  6105.     POP    R13
  6106.     POP    R12
  6107.     POP    R11
  6108.     POP    R10
  6109.     POP    R9
  6110.     POP    R8
  6111.     POP    R5
  6112.     POP    R4
  6113.     POP    R3
  6114.     POP    R2
  6115.     POP    R1
  6116.     POP    R0
  6117.  
  6118.     RET
  6119.  
  6120.  
  6121.  
  6122. TYPE_01
  6123. ;*******************************************************
  6124. ;*
  6125. ;*    Process and output operands for addressing mode:
  6126. ;*
  6127. ;*    opcode    r
  6128. ;*
  6129. ;*********************************************************;
  6130.  
  6131. L_TYPE_01:
  6132.     LD    R8,BYTE_1    ; get reg #
  6133.     AND    R8,#$F0        ; in hi nibble
  6134.     SWAP    R8        ; put in lo nibble
  6135.     OR    R8,#$C0        ; a working reg
  6136.     CALL    WR_REG
  6137.  
  6138.     JP    DONE_DASM    ; done
  6139.  
  6140. TYPE_02
  6141. ;*********************************************************
  6142. ;*
  6143. ;*    Process and output operands for addressing modes:
  6144. ;*
  6145. ;*    opcode    R
  6146. ;*    opcode    IR
  6147. ;*
  6148. ;***********************************************************;
  6149.  
  6150. L_TYPE_02:
  6151.     ; get mode from byte #1
  6152.     TM    BYTE_1,#$01    ; even = direct addr
  6153.     JR    Z,DIR        ; odd = indirect add
  6154.     LD    R10,#'@'    ; indirect mode
  6155.     CALL    OUT_BUF        ; put @ in out buf
  6156. DIR:
  6157.     ; test for working reg from byte #2
  6158.     LD    R10,BYTE_2    ; c0 to ef =
  6159.     AND    R10,#$F0
  6160.     CP    R10,#$C0
  6161.     JR    NE,END_EXC    ; working regs
  6162.     LD    R10,#'R'    ; yes working reg
  6163.     CALL    OUT_BUF
  6164.     AND    BYTE_2,#$0F    ; delete c from wr
  6165.     ; two exceptions are 80 and a0 mnenomics
  6166.     ; which are word format not byte
  6167.     CP    BYTE_1,#$80    ; test for inst 80
  6168.     JR    NE,NO_EXC    ; test next inst
  6169. EXCT:
  6170.     LD    R10,#'R'    ; put r in out buf
  6171.     CALL    OUT_BUF
  6172.     JR    END_EXC        ; done
  6173. NO_EXC:
  6174.     CP    BYTE_1,#$A0    ; test for inst a0
  6175.     JR    NE,END_EXC    ; done
  6176.     JR    EXCT        ; yes a0 out r
  6177. END_EXC:
  6178.     LD    R10,BYTE_2
  6179.     CALL    HEX_D_ASCII    ; put reg # in out buf
  6180.  
  6181.     JP    DONE_DASM    ; done
  6182.  
  6183.  
  6184. TYPE_03
  6185. ;*********************************************************
  6186. ;*
  6187. ;*    Process and output operands for addressing modes:
  6188. ;*
  6189. ;*    opcode    IRR
  6190. ;*    opcode    IR
  6191. ;*
  6192. ;***********************************************************;
  6193.  
  6194. L_TYPE_03:
  6195.     LD    R10,#'@'    ;put @ in out buffer
  6196.     CALL    OUT_BUF
  6197.     ; test for working regs in byte #2
  6198.     LD    R8,BYTE_2
  6199.     CALL    WR_REG_PAIR
  6200.  
  6201.     JP    DONE_DASM    ; done
  6202.  
  6203. TYPE_04
  6204. ;*********************************************************
  6205. ;*
  6206. ;*    Process and output operands for addressing modes:
  6207. ;*
  6208. ;*    opcode    IM
  6209. ;*
  6210. ;***********************************************************;
  6211.  
  6212.     LD    R10,#'#'    ; put # in out buffer
  6213.     CALL    OUT_BUF
  6214.     LD    R10,BYTE_2    ; save im value
  6215.     AND    R10,#$FC    ; mask bank mode in
  6216.                 ; bits 0-1
  6217.     CALL    HEX_D_ASCII
  6218.  
  6219.     JP    DONE_DASM    ; done
  6220.  
  6221.  
  6222. TYPE_05
  6223. ;*********************************************************
  6224. ;*
  6225. ;*    Process and output operands for addressing modes:
  6226. ;*
  6227. ;*    opcode    r,r
  6228. ;*    opcode    r,Ir
  6229. ;*
  6230. ;***********************************************************;
  6231.  
  6232.  
  6233.     ; write dst operand
  6234.     LD    R8,BYTE_2    ; save dst in R8
  6235.     SWAP    R8        ; put in lo nibble
  6236.     AND    R8,#$0F        ; isolate
  6237.     OR    R8,#$C0        ; make working reg
  6238.     CALL    WR_REG        ; write it
  6239.     CALL    SEP_OPRNDS
  6240.  
  6241.     ; write src operand
  6242.     ; test for indirect
  6243.     LD    R10,BYTE_1    ; save opcode
  6244.     TM    R10,#$01    ; test: even = direct
  6245.     JR    Z, DIRRECT
  6246.                 ; odd = indirect
  6247.     LD    R10,#'@'    ; put @ in out buffer
  6248.     CALL    OUT_BUF
  6249. DIRRECT:
  6250.     LD    R8,BYTE_2    ; save src in R8
  6251.     AND    R8,#$0F        ; isolate
  6252.     OR    R8,#$C0        ; make working reg
  6253.     CALL    WR_REG        ; write it
  6254.  
  6255.     JP    DONE_DASM    ; done
  6256.  
  6257.  
  6258. TYPE_06
  6259. ;*********************************************************
  6260. ;*
  6261. ;*    Process and output operands for addressing modes:
  6262. ;*
  6263. ;*    opcode    r,Irr
  6264. ;*    opcode    Ir,Ir
  6265. ;*
  6266. ;***********************************************************;
  6267.  
  6268.     ; get mode from byte #1
  6269.     TM    BYTE_1,#$10    ; even = direct
  6270.     JR    NZ,IDIR        ; odd = indirect
  6271.  
  6272. N_OPC:
  6273.     LD    R8,BYTE_2    ; save reg# in high
  6274.     AND    R8,#$F0        ; nibble -- put in
  6275.     SWAP    R8        ; low nibble
  6276.     OR    R8,#$C0        ; a working reg
  6277.     CALL    WR_REG        ; write it
  6278.     CALL    SEP_OPRNDS
  6279.  
  6280.     LD    R10,#'@'    ;put '@' in out buffer
  6281.     CALL    OUT_BUF
  6282.  
  6283.     LD    R8,BYTE_2    ; save reg# in low
  6284.     AND    R8,#$0F        ; nibble
  6285.     OR    R8,#$C0        ; a working reg
  6286.     CALL    WR_REG_PAIR    ; write it
  6287.  
  6288.     JP    DONE_DASM    ; done
  6289.  
  6290. IDIR:
  6291.     LD    R10,#'@'    ;put @RR in out buffer
  6292.     CALL    OUT_BUF
  6293.  
  6294.     LD    R8,BYTE_2    ; save reg# in low
  6295.     AND    R8,#$0F        ; nibble
  6296.     OR    R8,#$C0        ; a working reg
  6297.     CALL    WR_REG_PAIR    ; write it
  6298.     CALL    SEP_OPRNDS
  6299.  
  6300. DIR2:
  6301.     LD    R8,BYTE_2    ; save reg# in high
  6302.     AND    R8,#$F0        ; nibble -- put in
  6303.     SWAP    R8        ; low nibble
  6304.     OR    R8,#$C0        ; a working reg
  6305.     CALL    WR_REG        ; write it
  6306.  
  6307.     JP    DONE_DASM    ; done
  6308.  
  6309.  
  6310. TYPE_07
  6311. ;*********************************************************
  6312. ;*
  6313. ;*    Process and output operands for addressing modes:
  6314. ;*
  6315. ;*    opcode    r,R
  6316. ;*
  6317. ;***********************************************************;
  6318.  
  6319.     LD    R10,BYTE_1    ; opcode x8 or x9
  6320.     TM    R10,#$01
  6321.     JR    NZ,X9_
  6322.  
  6323.     LD    R10,#'R'    ; opcode = x8
  6324.     CALL    OUT_BUF        ; put r in out buffer
  6325.     LD    R10,BYTE_1    ; put reg# in out buf
  6326.     AND    R10,#$F0
  6327.     SWAP    R10
  6328.     CALL    HEX_D_ASCII
  6329.     CALL    SEP_OPRNDS
  6330.  
  6331.     LD    R8,BYTE_2
  6332.     CALL    WR_REG        ; write working reg
  6333.  
  6334.     JP    DONE_DASM    ; done
  6335.  
  6336. X9_:
  6337.                 ; opcode = x9
  6338.     LD    R8,BYTE_2
  6339.     CALL    WR_REG        ; write working reg
  6340.     CALL    SEP_OPRNDS
  6341.  
  6342.     LD    R10,#'R'    ; put r in out buffer
  6343.     CALL    OUT_BUF
  6344.     LD    R10,BYTE_1    ;put reg# in out buf
  6345.     AND    R10,#$F0
  6346.     SWAP    R10
  6347.     CALL    HEX_D_ASCII
  6348.  
  6349.     JP    DONE_DASM    ; done
  6350.  
  6351. TYPE_08
  6352. ;*********************************************************
  6353. ;*
  6354. ;*    Process and output operands for addressing modes:
  6355. ;*
  6356. ;*    opcode    r,IM
  6357. ;*
  6358. ;***********************************************************;
  6359.  
  6360.     LD    R10,#'R'    ; put r in out buffer
  6361.     CALL    OUT_BUF
  6362.     LD    R10,BYTE_1    ; put reg# in out buf
  6363.     AND    R10,#$F0
  6364.     SWAP    R10
  6365.     CALL    HEX_D_ASCII
  6366.     CALL    SEP_OPRNDS
  6367.  
  6368.     LD    R10,#'#'    ; put # in out buffer
  6369.     CALL    OUT_BUF
  6370.     LD    R10,BYTE_2    ; put reg# in out buf
  6371.     CALL    HEX_D_ASCII
  6372.  
  6373.     JP    DONE_DASM    ; done
  6374.  
  6375.  
  6376. TYPE_09
  6377. ;*********************************************************
  6378. ;*
  6379. ;*    Process and output operands for addressing modes:
  6380. ;*
  6381. ;*    opcode    r,RA
  6382. ;*    opcode    cc,RA
  6383. ;*
  6384. ;***********************************************************;
  6385.  
  6386.     LD    R10,BYTE_1    ; opcode xa or xb ?
  6387.     TM    R10,#$01
  6388.     JR    NZ,XB_
  6389.     LD    R10,#'R'    ; opcode = xa
  6390.     CALL    OUT_BUF        ; put r in out buffer
  6391.     LD    R10,BYTE_1    ; put reg# in out buf
  6392.     AND    R10,#$F0
  6393.     SWAP    R10
  6394.     CALL    HEX_D_ASCII
  6395.     CALL    SEP_OPRNDS
  6396.     JR    COMM        ; same as opc xb
  6397. XB_:
  6398.     LD    R10,BYTE_1    ; get condition code
  6399.     AND    R10,#$F0
  6400.     SWAP    R10
  6401.     LD    R12,#^HB CC_TAB    ; cc table addr
  6402.     LD    R13,#^LB CC_TAB
  6403. LUPE2:
  6404.     LDC    R11,@RR12    ; read cc table
  6405.     CP    R10,#$00    ; test for done
  6406.     JR    Z,COMP2
  6407. LLUP2:
  6408.     INCW    RR12        ; find next table flag
  6409.     LDC    R11,@RR12
  6410.     TM    R11,#$80
  6411.     JR    Z,LLUP2
  6412.     INCW    RR12        ; found flag
  6413.     DEC    R10        ; point to valid data
  6414.     JR    LUPE2
  6415. COMP2:
  6416.     LD    R10,R11        ; put cc in out buffer
  6417. AGNI2:
  6418.     CALL    OUT_BUF
  6419.     INCW    RR12
  6420.     LDC    R10,@RR12
  6421.     TM    R10,#$80
  6422.     JR    Z,AGNI2
  6423. COMM:
  6424.     LD    R10,#$25    ; put $ in out buf
  6425.     CALL    OUT_BUF
  6426.     CLR    R10        ; calculate address
  6427.     TM    BYTE_2,#$80    ; test for minus
  6428.     JR    Z,SKFF
  6429.     LD    R10,#$FF
  6430. SKFF:
  6431.     LD    R12,R1        ; lo input addr
  6432.     ADD    R12,BYTE_2    ; add relative addr
  6433.     JR    NC,SKK1
  6434.     INC    R10
  6435. SKK1:
  6436.     ADD    R10,R0
  6437.     CALL    HEX_ASCII    ;put addr in out buf
  6438.     LD    R10,R12
  6439.     CALL    HEX_ASCII
  6440.  
  6441.     JP    DONE_DASM    ; done
  6442.  
  6443.  
  6444. TYPE_0A
  6445. ;*********************************************************
  6446. ;*
  6447. ;*    Process and output operands for addressing modes:
  6448. ;*
  6449. ;*    opcode    R,R
  6450. ;*    opcode    IR,R
  6451. ;*
  6452. ;***********************************************************;
  6453.  
  6454.     LD    R8,BYTE_3
  6455.     CALL    WR_REG        ; write working reg
  6456.     CALL    SEP_OPRNDS
  6457.  
  6458.     ; test mode from byte #1
  6459.     LD    R10,BYTE_1    ; even = direct
  6460.     TM    R10,#$01    ; odd = indirect
  6461.     JR    Z,DIRR
  6462.     LD    R10,#'@'    ; indirect mode
  6463.     CALL    OUT_BUF        ; put @ in out buffer
  6464. DIRR:
  6465.     LD    R8,BYTE_2
  6466.     CALL    WR_REG        ; write working reg
  6467.  
  6468.     JP    DONE_DASM    ; done
  6469.  
  6470. TYPE_0B
  6471. ;*********************************************************
  6472. ;*
  6473. ;*    Process and output operands for addressing modes:
  6474. ;*
  6475. ;*    opcode    R,IM
  6476. ;*    opcode    IR,IM
  6477. ;*
  6478. ;***********************************************************;
  6479.  
  6480.     ; check for ir,im
  6481.     LD    R10,BYTE_1    ; check for opcode
  6482.     CP    R10,#$D6    ; d6 -- indirect
  6483.     JR    NE,DIRR_
  6484.     LD    R10,#'@'    ; indirect mode
  6485.     CALL    OUT_BUF        ; put @ in out buffer
  6486. DIRR_:
  6487.     LD    R8,BYTE_2
  6488.     CALL    WR_REG        ; write working reg
  6489.     CALL    SEP_OPRNDS
  6490.  
  6491.     LD    R10,#'#'    ; put # in out buffer
  6492.     CALL    OUT_BUF
  6493.     LD    R10,BYTE_3    ; put reg# in out buf
  6494.     CALL    HEX_D_ASCII
  6495.  
  6496.     JP    DONE_DASM    ; done
  6497.  
  6498. TYPE_0C
  6499. ;*********************************************************
  6500. ;*
  6501. ;*    Process and output operands for addressing modes:
  6502. ;*
  6503. ;*    opcode    R,IR
  6504. ;*
  6505. ;***********************************************************;
  6506.  
  6507.     LD    R10,#'@'    ; put @ in out buffer
  6508.     CALL    OUT_BUF
  6509.     LD    R8,BYTE_3
  6510.     CALL    WR_REG        ; write working reg
  6511.     CALL    SEP_OPRNDS
  6512.  
  6513.     LD    R8,BYTE_2
  6514.     CALL    WR_REG        ; write working reg
  6515.  
  6516.     JP    DONE_DASM    ; done
  6517.  
  6518.  
  6519. TYPE_0D
  6520. ;*********************************************************
  6521. ;*
  6522. ;*    Process and output operands for addressing modes:
  6523. ;*
  6524. ;*    opcode    r,x,R
  6525. ;*
  6526. ;***********************************************************;
  6527.  
  6528.     LD    R10,BYTE_1    ; test opcode for
  6529.     CP    R10,#$87    ; 87 or 97
  6530.     JR    EQ,OPC_87
  6531.  
  6532.     LD    R10,BYTE_3    ; opcode = 97
  6533.     CALL    HEX_D_ASCII    ; put reg# in out buf
  6534.     LD    R10,#$28    ; put (r in out buf
  6535.     CALL    OUT_BUF
  6536.     LD    R10,#'R'
  6537.     CALL    OUT_BUF
  6538.     LD    R10,BYTE_2    ; put reg# in out buf
  6539.     AND    R10,#$0F
  6540.     CALL    HEX_D_ASCII
  6541.     LD    R10,#$29    ; put ) in out buffer
  6542.     CALL    OUT_BUF
  6543.     CALL    SEP_OPRNDS
  6544.  
  6545.     LD    R10,#'R'    ; put r in out buffer
  6546.     CALL    OUT_BUF
  6547.     LD    R10,BYTE_2    ; put reg# in out buf
  6548.     AND    R10,#$F0
  6549.     SWAP    R10
  6550.     CALL    HEX_D_ASCII
  6551.  
  6552.     JP    DONE_DASM    ; done
  6553.  
  6554. OPC_87:
  6555.     LD    R10,#'R'    ; put r in out buffer
  6556.     CALL    OUT_BUF
  6557.     LD    R10,BYTE_2    ; put reg# in out buf
  6558.     AND    R10,#$F0
  6559.     SWAP    R10
  6560.     CALL    HEX_D_ASCII
  6561.     CALL    SEP_OPRNDS
  6562.  
  6563.     LD    R10,BYTE_3    ; put reg# in out buf
  6564.     CALL    HEX_D_ASCII
  6565.     LD    R10,#$28    ; put (r in out buf
  6566.     CALL    OUT_BUF
  6567.     LD    R10,#'R'
  6568.     CALL    OUT_BUF
  6569.     LD    R10,BYTE_2    ; put reg# in out buf
  6570.     AND    R10,#$0F
  6571.     CALL    HEX_D_ASCII
  6572.     LD    R10,#$29    ; put ) in out buffer
  6573.     CALL    OUT_BUF
  6574.  
  6575.     JP    DONE_DASM    ; done
  6576.  
  6577.  
  6578. TYPE_0E
  6579. ;*********************************************************
  6580. ;*
  6581. ;*    Process and output operands for addressing modes:
  6582. ;*
  6583. ;*    opcode    cc,DA
  6584. ;*
  6585. ;***********************************************************;
  6586.  
  6587.     LD    R10,BYTE_1    ; get condition code
  6588.     AND    R10,#$F0
  6589.     SWAP    R10
  6590.     LD    R12,#^HB CC_TAB    ; cc table address
  6591.     LD    R13,#^LB CC_TAB
  6592. LUPE1:
  6593.     LDC    R11,@RR12    ; read table
  6594.     CP    R10,#$00
  6595.     JR    Z,COMP1        ; find table entry
  6596. LLUP1:
  6597.     INCW    RR12        ; find next table flag
  6598.     LDC    R11,@RR12
  6599.     TM    R11,#$80
  6600.     JR    Z,LLUP1
  6601.     INCW    RR12        ; point to next entry
  6602.     DEC    R10
  6603.     JR    LUPE1
  6604. COMP1:
  6605.     LD    R10,R11        ; put cc in out buffer
  6606. AGNI1:
  6607.     CALL    OUT_BUF
  6608.     INCW    RR12
  6609.     LDC    R10,@RR12
  6610.     TM    R10,#$80
  6611.     JR    Z,AGNI1
  6612.  
  6613.     LD    R10,#$25    ; put $ in out buffer
  6614.     CALL    OUT_BUF
  6615.     LD    R10,BYTE_2    ; put addr in out buf
  6616.     CALL    HEX_ASCII
  6617.     LD    R10,BYTE_3
  6618.     CALL    HEX_ASCII
  6619.  
  6620.     JP    DONE_DASM    ; done
  6621.  
  6622. TYPE_0F
  6623. ;*********************************************************
  6624. ;*
  6625. ;*    Process and output operands for addressing modes:
  6626. ;*
  6627. ;*    opcode    DA
  6628. ;*
  6629. ;***********************************************************;
  6630.  
  6631.     LD    R10,#$25    ; put $ in out buffer
  6632.     CALL    OUT_BUF
  6633.     LD    R10,BYTE_2    ; put addr in out buf
  6634.     CALL    HEX_ASCII
  6635.     LD    R10,BYTE_3
  6636.     CALL    HEX_ASCII
  6637.  
  6638.     JP    DONE_DASM    ; done
  6639.  
  6640. TYPE_10
  6641. ;*********************************************************
  6642. ;*
  6643. ;*    Process and output operands for addressing modes:
  6644. ;*
  6645. ;*    opcode    r,b
  6646. ;*    opcode    r,b,R
  6647. ;*
  6648. ;***********************************************************;
  6649.  
  6650.     LD    R9,BYTE_2    ; save bit number in R8
  6651.     RR    R9        ; bits 0-2
  6652.     AND    R9,#$07
  6653.  
  6654.     LD    R10,BYTE_2    ; find mode
  6655.     TM    R10,#$01    ; even: dst(0) or src(b)
  6656.     JR    Z,DST0_    ; odd: dst(b) or src(0)
  6657.  
  6658. DSTb_:    ; write out dst operand
  6659.     LD    R8,BYTE_3
  6660.     CALL    WR_REG        ; write working reg
  6661.     CALL    SEP_OPRNDS
  6662.  
  6663.     ; write out bit number
  6664.     LD    R10,#'#'    ; put '#' in out buffer
  6665.     CALL    OUT_BUF
  6666.     LD    R10,R9        ; put bit# in out buf
  6667.     CALL    HEX_D_ASCII
  6668.     CALL    SEP_OPRNDS
  6669.  
  6670.     ; write out src operand
  6671.     LD    R8,BYTE_2    ; save reg#
  6672.     SWAP    R8        ; put reg# in lo nibble
  6673.     AND    R8,#$0F        ; clear upper nibble
  6674.     OR    R8,#$C0        ; working register
  6675.     CALL    WR_REG        ; write src operand
  6676.  
  6677.     JP    DONE_DASM    ; done
  6678.  
  6679. DST0_:    ; write out dst operand
  6680.     LD    R8,BYTE_2    ; save reg#
  6681.     SWAP    R8        ; put reg# in lo nibble
  6682.     AND    R8,#$0F        ; clear upper nibble
  6683.     OR    R8,#$C0        ; working register
  6684.     CALL    WR_REG        ; write src operand
  6685.     CALL    SEP_OPRNDS
  6686.  
  6687.     ; write out src operand
  6688.     LD    R8,BYTE_3
  6689.     CALL    WR_REG        ; write working reg
  6690.     CALL    SEP_OPRNDS
  6691.  
  6692.     ; write out bit number
  6693.     LD    R10,#'#'    ; put '#' in out buffer
  6694.     CALL    OUT_BUF
  6695.     LD    R10,R9        ; put bit# in out buf
  6696.     CALL    HEX_D_ASCII
  6697.  
  6698.     JP    DONE_DASM    ; done
  6699.  
  6700. TYPE_11
  6701. ;*********************************************************
  6702. ;*
  6703. ;*    Process and output operands for addressing modes:
  6704. ;*
  6705. ;*    opcode    IR,R
  6706. ;*    opcode    R,IR
  6707. ;*
  6708. ;***********************************************************;
  6709.     ; check for IR,R
  6710.     LD    R10,BYTE_1    ; save opcode
  6711.     TM    R10,#$10    ; test bit 4
  6712.     JR    Z, IR_R        ; even = IR,R
  6713. R_IR:                ; odd = R,IR
  6714.     ; write dst operand
  6715.     LD    R8,BYTE_3    ; save reg
  6716.     CALL    WR_REG        ; write it
  6717.     CALL    SEP_OPRNDS
  6718.  
  6719.     ; write src operand
  6720.     LD    R10,#'@'    ; write '@'
  6721.     CALL    OUT_BUF
  6722.     LD    R8,BYTE_2    ; save reg
  6723.     CALL    WR_REG        ; write it
  6724.  
  6725.     JP    DONE_DASM    ; done
  6726.  
  6727. IR_R:
  6728.     ; write dst operand
  6729.     LD    R10,#'@'    ; write '@'
  6730.     CALL    OUT_BUF
  6731.     LD    R8,BYTE_2    ; save reg
  6732.     CALL    WR_REG        ; write it
  6733.     CALL    SEP_OPRNDS
  6734.  
  6735.     ; write src operand
  6736.     LD    R8,BYTE_3    ; save reg
  6737.     CALL    WR_REG        ; write it
  6738.  
  6739.     JP    DONE_DASM    ; done
  6740.  
  6741.  
  6742. TYPE_12      ; r,b,ra
  6743. ;*********************************************************
  6744. ;*
  6745. ;*    Process and output operands for addressing modes:
  6746. ;*
  6747. ;*    opcode    r,b,RA
  6748. ;*
  6749. ;***********************************************************;
  6750.     LD    R9,BYTE_2    ; save bit number in R8
  6751.     RR    R9        ; bits 0-2
  6752.     AND    R9,#$07
  6753.  
  6754.     ; write out relative address operand
  6755.     LD    R10,#$25    ; put $ in out buf
  6756.     CALL    OUT_BUF
  6757.     CLR    R10        ; calculate address
  6758.     TM    BYTE_3,#$80    ; test for minus
  6759.     JR    Z,SK12FF
  6760.     LD    R10,#$FF
  6761. SK12FF:
  6762.     LD    R12,R1        ; lo input addr
  6763.     ADD    R12,BYTE_3    ; add relative addr
  6764.     JR    NC,SK12K1
  6765.     INC    R10
  6766. SK12K1:
  6767.     ADD    R10,R0
  6768.     CALL    HEX_ASCII    ;put addr in out buf
  6769.     LD    R10,R12
  6770.     CALL    HEX_ASCII
  6771.     CALL    SEP_OPRNDS
  6772.  
  6773.     ; write out src register
  6774.     LD    R8,BYTE_2    ; save reg#
  6775.     SWAP    R8        ; put reg# in lo nibble
  6776.     AND    R8,#$0F        ; clear upper nibble
  6777.     OR    R8,#$C0        ; working register
  6778.     CALL    WR_REG        ; write src operand
  6779.     CALL    SEP_OPRNDS
  6780.  
  6781.     ; write out bit#
  6782.     LD    R10,#'#'    ; put '#' in out buffer
  6783.     CALL    OUT_BUF
  6784.     LD    R10,R9        ; put bit# in out buf
  6785.     CALL    HEX_D_ASCII
  6786.  
  6787.     JP    DONE_DASM    ; done
  6788.  
  6789. TYPE_13     ; r,b
  6790. ;*********************************************************
  6791. ;*
  6792. ;*    Process and output operands for addressing modes:
  6793. ;*
  6794. ;*    opcode    r,b
  6795. ;*
  6796. ;***********************************************************;
  6797.     LD    R9,BYTE_2    ; save bit number in R8
  6798.     RR    R9        ; bits 0-2
  6799.     AND    R9,#$07
  6800.  
  6801.     ; write out dst register
  6802.     LD    R8,BYTE_2    ; save reg#
  6803.     SWAP    R8        ; put reg# in lo nibble
  6804.     AND    R8,#$0F        ; clear upper nibble
  6805.     OR    R8,#$C0        ; working register
  6806.     CALL    WR_REG        ; write src operand
  6807.     CALL    SEP_OPRNDS
  6808.  
  6809.     ; write out bit#
  6810.     LD    R10,#'#'    ; put '#' in out buffer
  6811.     CALL    OUT_BUF
  6812.     LD    R10,R9        ; put bit# in out buf
  6813.     CALL    HEX_D_ASCII
  6814.  
  6815.     JP    DONE_DASM    ; done
  6816.  
  6817. TYPE_14
  6818. ;*********************************************************
  6819. ;*
  6820. ;*    Process and output operands for addressing modes:
  6821. ;*
  6822. ;*    opcode    R,RR
  6823. ;*    opcode    IR,RR
  6824. ;*
  6825. ;***********************************************************;
  6826.     ; write out dst operand
  6827.     LD    R8,BYTE_3
  6828.     CALL    WR_REG_PAIR
  6829.     CALL    SEP_OPRNDS
  6830.  
  6831.     ; write out src operand
  6832.     LD    R10,BYTE_1    ; even = direct
  6833.     TM    R10,#$01    ; odd = indirect
  6834.     JR    Z,DIRR14
  6835.     LD    R10,#'@'    ; indirect mode
  6836.     CALL    OUT_BUF        ; put @ in out buffer
  6837. DIRR14:
  6838.     LD    R8,BYTE_2
  6839.     CALL    WR_REG        ; write out reg#
  6840.  
  6841.     JP    DONE_DASM    ; done
  6842.  
  6843. TYPE_15
  6844. ;*********************************************************
  6845. ;*
  6846. ;*    Process and output operands for addressing modes:
  6847. ;*
  6848. ;*    opcode    IM,RR
  6849. ;*
  6850. ;***********************************************************;
  6851.  
  6852.     ; write out dst operand
  6853.     LD    R8,BYTE_3
  6854.     CALL    WR_REG_PAIR
  6855.     CALL    SEP_OPRNDS
  6856.  
  6857.     ; write out src operand
  6858.     LD    R10,#'#'    ; put # in out buffer
  6859.     CALL    OUT_BUF
  6860.     LD    R10,BYTE_2    ; put reg# in out buf
  6861.     CALL    HEX_D_ASCII
  6862.  
  6863.     JP    DONE_DASM    ; done
  6864.  
  6865. TYPE_16
  6866. ;*********************************************************
  6867. ;*
  6868. ;*    Process and output operands for addressing modes:
  6869. ;*
  6870. ;*    opcode    IR,r,RA
  6871. ;*
  6872. ;***********************************************************;
  6873.     ; write out dst operand
  6874.     LD    R8,BYTE_2
  6875.     AND    R8,#$0F
  6876.     OR    R8,#$C0
  6877.     CALL    WR_REG
  6878.     CALL    SEP_OPRNDS
  6879.  
  6880.     ; write out src operand
  6881.     LD    R10,#'@'    ; write '@'
  6882.     CALL    OUT_BUF
  6883.     LD    R8,BYTE_2    ; save src
  6884.     SWAP    R8        ; put reg# in lo nibble
  6885.     AND    R8,#$0F        ; clear upper nibble
  6886.     OR    R8,#$C0        ; working register
  6887.     CALL    WR_REG        ; write it
  6888.     CALL    SEP_OPRNDS
  6889.  
  6890.     ; write out relative address operand
  6891.     LD    R10,#$25    ; put '$' in out buf
  6892.     CALL    OUT_BUF
  6893.     CLR    R10        ; calculate address
  6894.     TM    BYTE_3,#$80    ; test for minus
  6895.     JR    Z,SK16FF
  6896.     LD    R10,#$FF
  6897. SK16FF:
  6898.     LD    R12,R1        ; lo input addr
  6899.     ADD    R12,BYTE_3    ; add relative addr
  6900.     JR    NC,SK16K1
  6901.     INC    R10
  6902. SK16K1:
  6903.     ADD    R10,R0
  6904.     CALL    HEX_ASCII    ;put addr in out buf
  6905.     LD    R10,R12
  6906.     CALL    HEX_ASCII
  6907.  
  6908.     JP    DONE_DASM    ; done
  6909.  
  6910. TYPE_17
  6911. ;*********************************************************
  6912. ;*
  6913. ;*    Process and output operands for addressing modes:
  6914. ;*
  6915. ;*    opcode    RR,RR
  6916. ;*
  6917. ;***********************************************************;
  6918.     ; write out dst operand
  6919.     LD    R8,BYTE_3
  6920.     CALL    WR_REG_PAIR
  6921.     CALL    SEP_OPRNDS
  6922.  
  6923.     ; write out src operand
  6924.     LD    R8,BYTE_2
  6925.     CALL    WR_REG_PAIR
  6926.  
  6927.     JP    DONE_DASM    ; done
  6928.  
  6929. TYPE_18
  6930. ;*********************************************************
  6931. ;*
  6932. ;*    Process and output operands for addressing modes:
  6933. ;*
  6934. ;*    opcode    RR,IML
  6935. ;*
  6936. ;***********************************************************;
  6937.     ; write out dst operand
  6938.     LD    R8,BYTE_2
  6939.     CALL    WR_REG_PAIR
  6940.     CALL    SEP_OPRNDS
  6941.  
  6942.     ; write out src operand
  6943.     LD    R10,#'#'    ; put # in out buffer
  6944.     CALL    OUT_BUF
  6945.     LD    R10,#$25    ; put $ in out buffer
  6946.     CALL    OUT_BUF
  6947.     LD    R10,BYTE_3    ; put addr in out buf
  6948.     CALL    HEX_ASCII
  6949.     LD    R10,BYTE_4
  6950.     CALL    HEX_ASCII
  6951.  
  6952.     JP    DONE_DASM    ; done
  6953.  
  6954. TYPE_19
  6955. ;*********************************************************
  6956. ;*
  6957. ;*    Process and output operands for addressing modes:
  6958. ;*
  6959. ;*    opcode    IA
  6960. ;*
  6961. ;***********************************************************;
  6962.     ; write out dst operand
  6963.     LD    R10,#$23    ; put # in out buffer
  6964.     CALL    OUT_BUF
  6965.     LD    R10,#$25    ; put $ in out buffer
  6966.     CALL    OUT_BUF
  6967.     LD    R10,BYTE_2    ; put addr in out buf
  6968.     CALL    HEX_ASCII
  6969.  
  6970.     JP    DONE_DASM    ; done
  6971.  
  6972. TYPE_1A
  6973. ;*********************************************************
  6974. ;*
  6975. ;*    Process and output operands for addressing modes:
  6976. ;*
  6977. ;*    opcode    r,x(rr)
  6978. ;*    opcode    x(rr),r
  6979. ;*
  6980. ;***********************************************************;
  6981.     ; determine mode - test bit 4
  6982.     LD    R10,BYTE_1
  6983.     TM    R10,#$10        ; if cleared then
  6984.     JR    Z, R_X        ; r,x(irr) mode
  6985.  
  6986. X_R:                ; otherwise x(irr),r
  6987.     ; write indexed (short or long) dst operand
  6988.     LD    R10,#$25    ; put $ in out buffer
  6989.     CALL    OUT_BUF
  6990.  
  6991.     LD    R10,BYTE_1    ; test for long offset
  6992.     TM    R10,#$40    ; bit 6 in opcode
  6993.     JR    NZ, NLX_R    ; not long if cleared
  6994. LX_R:
  6995.     LD    R10,BYTE_4    ; output (hi) offset
  6996.     CALL    HEX_ASCII
  6997.  
  6998. NLX_R:
  6999.     LD    R10,BYTE_3    ; output (lo) offset
  7000.     CALL    HEX_ASCII
  7001.     LD    R10,#'('    ; output '('
  7002.     CALL    OUT_BUF
  7003.  
  7004.     LD    R8,BYTE_2    ; save reg #
  7005.     AND    R8,#$0F        ; in lo nibble
  7006.     OR    R8,#$C0        ; make work reg
  7007.     CALL    WR_REG_PAIR    ; write pair
  7008.  
  7009.     LD    R10,#')'    ; output ')'
  7010.     CALL    OUT_BUF
  7011.     CALL    SEP_OPRNDS
  7012.  
  7013.     ; write src operand
  7014.     LD    R8,BYTE_2    ; save src
  7015.     SWAP    R8        ; put src in lo nibble
  7016.     AND    R8,#$0F        ; isolate src reg
  7017.     OR    R8,#$C0        ; make work reg
  7018.     CALL    WR_REG        ; write it
  7019.  
  7020.     JP    DONE_DASM    ; done
  7021.  
  7022. R_X:
  7023.     ; write dst operand
  7024.     LD    R8,BYTE_2    ; save src
  7025.     SWAP    R8        ; put src in lo nibble
  7026.     AND    R8,#$0F        ; isolate src reg
  7027.     OR    R8,#$C0        ; make work reg
  7028.     CALL    WR_REG        ; write it
  7029.     CALL    SEP_OPRNDS
  7030.  
  7031.     ; write indexed (short or long) src operand
  7032.     LD    R10,#$25    ; put $ in out buffer
  7033.     CALL    OUT_BUF
  7034.  
  7035.     LD    R10,BYTE_1    ; test for long offset
  7036.     TM    R10,#$40    ; bit 6 in opcode
  7037.     JR    NZ, NLR_X    ; not long if cleared
  7038. LR_X:
  7039.     LD    R10,BYTE_4    ; output (hi) offset
  7040.     CALL    HEX_ASCII
  7041. NLR_X:
  7042.     LD    R10,BYTE_3    ; output (lo) offset
  7043.     CALL    HEX_ASCII
  7044.     LD    R10,#'('    ; output '('
  7045.     CALL    OUT_BUF
  7046.  
  7047.     LD    R8,BYTE_2    ; save reg #
  7048.     AND    R8,#$0F        ; in lo nibble
  7049.     OR    R8,#$C0        ; make work reg
  7050.     CALL    WR_REG_PAIR    ; write pair
  7051.  
  7052.     LD    R10,#')'    ; output ')'
  7053.     CALL    OUT_BUF
  7054.  
  7055.     JP    DONE_DASM    ; done
  7056.  
  7057. TYPE_1B
  7058. ;*********************************************************
  7059. ;*
  7060. ;*    Process and output operands for addressing modes:
  7061. ;*
  7062. ;*    opcode    r,DA
  7063. ;*    opcode    DA,r
  7064. ;*
  7065. ;***********************************************************;
  7066.  
  7067.     ; test for indexed mode
  7068.     LD    R10,BYTE_2    ; test bits 1-3
  7069.     TM    R10,#$0E    ; if nz then indexed
  7070.     JP    NZ,TYPE_1A    ; mode
  7071.  
  7072.     ; test for order of operands
  7073.     LD    R10,BYTE_1    ; test opcode bit 1
  7074.     TM    R10,#$10    ; if cleared then
  7075.     JR    Z, r_DA        ; r, da mode
  7076. DA_r:                ; otherwise da,r
  7077.     ; write address operand
  7078.     LD    R10,#$25    ; output '$'
  7079.     CALL    OUT_BUF
  7080.     LD    R10,BYTE_4    ; output hi
  7081.     CALL    HEX_ASCII    ; address byte
  7082.     LD    R10,BYTE_3    ; output lo
  7083.     CALL    HEX_ASCII    ; address byte
  7084.     CALL    SEP_OPRNDS
  7085.  
  7086.     ; write src operand
  7087.     LD    R8,BYTE_2    ; save src
  7088.     SWAP    R8        ; put src in lo nibble
  7089.     AND    R8,#$0F        ; isolate src reg
  7090.     OR    R8,#$C0        ; make work reg
  7091.     CALL    WR_REG        ; write it
  7092.  
  7093.     JP    DONE_DASM    ; done
  7094.  
  7095. r_DA:
  7096.     ; write dst operand
  7097.     LD    R8,BYTE_2    ; save src
  7098.     SWAP    R8        ; put src in lo nibble
  7099.     AND    R8,#$0F        ; isolate src reg
  7100.     OR    R8,#$C0        ; make work reg
  7101.     CALL    WR_REG        ; write it
  7102.     CALL    SEP_OPRNDS
  7103.  
  7104.     ; write address operand
  7105.     LD    R10,#$25    ; output '$'
  7106.     CALL    OUT_BUF
  7107.     LD    R10,BYTE_4    ; output hi
  7108.     CALL    HEX_ASCII    ; address byte
  7109.     LD    R10,BYTE_3    ; output lo
  7110.     CALL    HEX_ASCII    ; address byte
  7111.  
  7112.     JP    DONE_DASM    ; done
  7113.  
  7114. TYPE_1C
  7115. ;*********************************************************
  7116. ;*
  7117. ;*    Process and output operands for addressing modes:
  7118. ;*
  7119. ;*    opcode    Ir,r
  7120. ;*
  7121. ;***********************************************************;
  7122.  
  7123.     ; write dst operand
  7124.     LD    R10,#'@'    ; put @ in out buffer
  7125.     CALL    OUT_BUF
  7126.     LD    R8,BYTE_2    ; save dst in R8
  7127.     SWAP    R8        ; put in lo nibble
  7128.     AND    R8,#$0F        ; isolate
  7129.     OR    R8,#$C0        ; make working reg
  7130.     CALL    WR_REG        ; write it
  7131.     CALL    SEP_OPRNDS
  7132.  
  7133.  
  7134.     ; write src operand
  7135.     LD    R8,BYTE_2    ; save src in R8
  7136.     AND    R8,#$0F        ; isolate
  7137.     OR    R8,#$C0        ; make working reg
  7138.     CALL    WR_REG        ; write it
  7139.     CALL    SEP_OPRNDS
  7140.  
  7141.     JP    DONE_DASM    ; done
  7142.  
  7143. CHK_MNE
  7144. ;***************************************************************
  7145. ;*
  7146. ;*    CHK_MNE  Check for opcode mnemonics that vary.
  7147. ;*
  7148. ;*    input    RR4 points to current main table entry.
  7149. ;*        Lo nibble of R10 contains entry# for alternate
  7150. ;*        table.    Use alternate table if bit 0 of byte_2
  7151. ;*        is cleared.
  7152. ;*
  7153. ;*    output    If bit 0 of byte_2 is cleared, then RR4 points
  7154. ;*        to the correct entry in the alternate table.
  7155. ;*
  7156. ;***************************************************************;
  7157.     ; check for opcode mnemonics that vary
  7158.     ; RR4 points to current table entry
  7159.     ; lo nibble of R10 contains entry# for alt. table
  7160.     ; use alt. table if bit 0 of byte_2 is cleared
  7161.  
  7162.  
  7163.  
  7164.     LD    R8,BYTE_2    ; save mode
  7165.     TM    R8,#$01        ; test bit 1
  7166.     JR    Z, VRY_TAB    ; use other table
  7167.                 ; if cleared
  7168.  
  7169. SAME_TAB:
  7170.     ; use the same table -- just inc pointer
  7171.     INCW    RR4
  7172.     JR    DONE_CHK
  7173.  
  7174. VRY_TAB:
  7175.     ; check for special case of srp
  7176.     CP    BYTE_1,#$31    ; test for srp
  7177.     JR    NE,NOT_SRP0    ; opcode
  7178.  
  7179.     TM    BYTE_2,#$02    ; test bit 1
  7180.     JR    Z,NOT_SRP0    ; for srp0
  7181.  
  7182.     LD    R10,#$08    ; load alt table
  7183.                 ; index for srp0
  7184.  
  7185. NOT_SRP0:
  7186.     ; point RR4 to correct pos. in alt. table
  7187.     LD    R8,R10        ; save entry #
  7188.     AND    R8,#$0F        ; isolate entry #
  7189.  
  7190.     LD    R4,#^HB ALT_TAB    ; point RR4 to
  7191.     LD    R5,#^LB ALT_TAB    ; alt table
  7192.  
  7193. ENTRY_LP:
  7194.     CP    R8,#$00        ; are we at right
  7195.     JR    EQ, AT_ENTRY    ; entry ?
  7196.  
  7197. CHAR_LP: ; increment RR4 until we get to control byte
  7198.     INCW    RR4        ; get next char.
  7199.     LDC    R9,@RR4
  7200.     TM    R9,#$80        ; control byte?
  7201.     JR    Z,CHAR_LP    ; no
  7202.  
  7203.     DEC    R8        ; yes
  7204.     JR    ENTRY_LP
  7205.  
  7206. AT_ENTRY:
  7207.     INCW    RR4        ; point RR4 to letter
  7208.  
  7209. DONE_CHK:
  7210.     ; if instruction is ldc/lde type,
  7211.     ; clear lsb of byte_2
  7212.     LDC    R10,@RR4    ; put letter in R10
  7213.     CP    R10,#'L'    ; load inst. ?
  7214.     JR    NE,RET_CHK    ; no
  7215.  
  7216.     AND    BYTE_2,#$FE    ; yes -- clear bit
  7217.  
  7218. RET_CHK:
  7219.     RET
  7220.  
  7221.  
  7222.  
  7223.  
  7224.  
  7225. HEX_ASCII
  7226. ;**********************************************************
  7227. ;*
  7228. ;*    HEX_ASCII  Convert hex byte to ASCII char and output.
  7229. ;*
  7230. ;*    input    R10 has hex byte.
  7231. ;*        RR2 points to the current output buffer pos.
  7232. ;*
  7233. ;*    output    The byte value is converted to ASCII
  7234. ;*        and placed in the output buffer.
  7235. ;*
  7236. ;************************************************************;
  7237.  
  7238.     LD    R11,R10        ; save R10
  7239.     AND    R10,#$F0    ; isolate hi nibble
  7240.     SWAP    R10        ;  first
  7241.     add    r10,#$90
  7242.     da    r10
  7243.     adc    r10,#$40
  7244.     da    r10
  7245.     LDC    @RR2,R10    ; write hi nibble
  7246.     INCW    RR2        ; into out buffer
  7247.     AND    R11,#$0F    ; now lo nibble
  7248.     add    r11,#$90
  7249.     da    r11
  7250.     adc    r11,#$40
  7251.     da    r11
  7252.     LDC    @RR2,R11    ; write lo nibble
  7253.     INCW    RR2        ; into out buffer
  7254.     RET
  7255.  
  7256.  
  7257.  
  7258. RD_MEM
  7259. ;**********************************************************
  7260. ;*
  7261. ;*    RD_MEM  Read a byte of memory
  7262. ;*
  7263. ;*    input:    RR0 is the memory read address
  7264. ;*
  7265. ;*    output: R10 contains the value read from
  7266. ;*        the address
  7267. ;*
  7268. ;**********************************************************;
  7269.     PUSH    R8
  7270.     PUSH    R9
  7271.     PUSH    R15
  7272.  
  7273.     LD    R8,R0
  7274.     LD    R9,R1
  7275.     CALL    GETMEM
  7276.     LD    R10,R15
  7277.  
  7278.     POP    R15
  7279.     POP    R9
  7280.     POP    R8
  7281.  
  7282.     RET
  7283.  
  7284.  
  7285. OUT_BUF
  7286. ;*****************************************************
  7287. ;*
  7288. ;*    OUT_BUF  Put a character into the output buffer.
  7289. ;*
  7290. ;*    input:    R10 has the  character
  7291. ;*
  7292. ;*******************************************************;
  7293.     LDC    @RR2,R10
  7294.     INCW    RR2
  7295.     RET
  7296.  
  7297.  
  7298. HEX_D_ASCII
  7299. ;**********************************************************
  7300. ;*
  7301. ;*    HEX_D_ASCII  Convert hex to decimal and put in
  7302. ;*        output buffer.
  7303. ;*
  7304. ;*    input:    R10 has the value to be converted
  7305. ;*
  7306. ;**********************************************************;
  7307.     ; first convert hex to decimal ff to 255
  7308.     CLR    R15        ;unit decimal #
  7309.     CLR    R14        ;tens decimal #
  7310.     CLR    R13        ;hundreds dec #
  7311. LUP:
  7312.     CP    R10,#$00    ; test for done
  7313.     JR    EQ,ASCI        ; yes then to sacii
  7314.     DEC    R10        ; decrement hex
  7315.     INC    R15        ; increment dec
  7316.     CP    R15,#$0A    ; check for dec carry
  7317.     JR    NE,LUP        ; no do again
  7318.     CLR    R15        ; yes carry to tens
  7319.     INC    R14        ; zero units
  7320.     CP    R14,#$0A    ; check for dec carry
  7321.     JR    NE,LUP        ; no do again
  7322.     CLR    R14        ; yes carry to hundreds
  7323.     INC    R13        ; clear tens
  7324.     JR    LUP        ; do again
  7325.     ; now convert decimal to ASCII
  7326.     ; and delete leading zeros
  7327. ASCI:
  7328.     CP    R13,#$00    ; first hundreds
  7329.     JR    EQ,TENS_
  7330.     ADD    R13,#$30    ; add 30
  7331.     LDC    @RR2,R13    ; put in out buf
  7332.     INCW    RR2
  7333.     JR    SK8        ; no delete tens
  7334. TENS_:
  7335.     CP    R14,#$00    ; next tens
  7336.     JR    EQ,UNITS_
  7337. SK8:
  7338.     ADD    R14,#$30    ; add 30
  7339.     LDC    @RR2,R14    ; put in out buf
  7340.     INCW    RR2
  7341. UNITS_:
  7342.     ADD    R15,#$30    ; next units
  7343.     LDC    @RR2,R15    ; put in out buf
  7344.     INCW    RR2
  7345.     RET
  7346.  
  7347.  
  7348. TAB_SP
  7349. ;***********************************************************
  7350. ;*
  7351. ;*    TAB_SP  Tab over some spaces in the output buffer
  7352. ;*
  7353. ;*    input:    R15 has the number of spaces to tab.
  7354. ;*
  7355. ;***********************************************************;
  7356.     ADD    R3,R15
  7357.     JR    NC,SKP
  7358.     INC    R2
  7359. SKP:
  7360.     RET
  7361.  
  7362.  
  7363. WR_REG
  7364. ;*******************************************************
  7365. ;*
  7366. ;*    WR_REG  Write a register operand into the output
  7367. ;*        buffer.
  7368. ;*
  7369. ;*    input:    R8 has the register number.
  7370. ;*
  7371. ;*******************************************************;
  7372.     ; R8 must contain the register number
  7373.  
  7374.     ; test for working reg in R8
  7375.     LD    R10,R8
  7376.     AND    R10,#$F0    ; hi nibble =c wregs
  7377.     CP    R10,#$C0
  7378.     JR    NE,NWR
  7379.     LD    R10,#'R'    ;put r in out buf
  7380.     CALL    OUT_BUF
  7381.     AND    R8,#$0F        ; delete c
  7382. NWR:
  7383.     LD    R10,R8        ; put reg# in out buf
  7384.     CALL    HEX_D_ASCII
  7385.  
  7386.     RET
  7387.  
  7388.  
  7389.  
  7390. WR_REG_PAIR
  7391. ;*******************************************************
  7392. ;*
  7393. ;*    WR_REG  Write a register pair operand into the
  7394. ;*        output buffer.
  7395. ;*
  7396. ;*    input:    R8 has the register number.
  7397. ;*
  7398. ;*******************************************************;
  7399.  
  7400.     ; test for working reg in R8
  7401.     LD    R10,R8
  7402.     AND    R10,#$F0    ; hi nibble =c wregs
  7403.     CP    R10,#$C0
  7404.     JR    NE,NWR_PAIR
  7405.     LD    R10,#'R'    ;put r in out buf
  7406.     CALL    OUT_BUF
  7407.     CALL    OUT_BUF
  7408.     AND    R8,#$0F        ; delete c
  7409. NWR_PAIR:
  7410.     LD    R10,R8        ; put reg# in out buf
  7411.     CALL    HEX_D_ASCII
  7412.  
  7413.     RET
  7414.  
  7415.  
  7416.  
  7417. SEP_OPRNDS
  7418. ;******************************************************
  7419. ;*
  7420. ;*    SEP_OPRNDS  Write a ", " into the output buffer
  7421. ;*        to separate the  operands.
  7422. ;*
  7423. ;******************************************************;
  7424.     LD    R10,#','    ; write out ", " to
  7425.     CALL    OUT_BUF        ; separate operands
  7426.     LD    R10,#' '
  7427.     CALL    OUT_BUF
  7428.     RET
  7429.  
  7430.  
  7431.  
  7432.  
  7433. ; opcode table:  each entry has a control byte followed by 2-6 characters
  7434. ;         of opcode mnemonics.
  7435. ;    control byte format:
  7436. ;        bit 7    : set to indicate control byte
  7437. ;        bit 5-6 : instruction size encoded as (n - 1)
  7438. ;        bit 0-4 : instruction type for operad mnemonics
  7439.  
  7440.  
  7441. OP_TAB:
  7442.  
  7443. ; opcodes 0x
  7444.     db TWO_M+AD_TYPE_2,    'DEC'
  7445.     db TWO_M+AD_TYPE_2,    'DEC'
  7446.     db TWO_M+AD_TYPE_5,    'ADD'
  7447.     db TWO_M+AD_TYPE_5,    'ADD'
  7448.     db THREE_M+AD_TYPE_A,    'ADD'
  7449.     db THREE_M+AD_TYPE_A,    'ADD'
  7450.     db THREE_M+AD_TYPE_B,    'ADD'
  7451.     db THREE_M+AD_TYPE_10,    'BOR'
  7452.     db TWO_M+AD_TYPE_7,    'LD'
  7453.     db TWO_M+AD_TYPE_7,    'LD'
  7454.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7455.     db TWO_M+AD_TYPE_9,    'JR'
  7456.     db TWO_M+AD_TYPE_8,    'LD'
  7457.     db THREE_M+AD_TYPE_E,    'JP'
  7458.     db ONE_M+AD_TYPE_1,    'INC'
  7459.     db ONE_M+AD_TYPE_0,    'NEXT'
  7460.  
  7461. ; opcodes 1x
  7462.     db TWO_M+AD_TYPE_2,    'RLC'
  7463.     db TWO_M+AD_TYPE_2,    'RLC'
  7464.     db TWO_M+AD_TYPE_5,    'ADC'
  7465.     db TWO_M+AD_TYPE_5,    'ADC'
  7466.     db THREE_M+AD_TYPE_A,    'ADC'
  7467.     db THREE_M+AD_TYPE_A,    'ADC'
  7468.     db THREE_M+AD_TYPE_B,    'ADC'
  7469.     db THREE_M+AD_TYPE_10,    'BCP'
  7470.     db TWO_M+AD_TYPE_7,    'LD'
  7471.     db TWO_M+AD_TYPE_7,    'LD'
  7472.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7473.     db TWO_M+AD_TYPE_9,    'JR'
  7474.     db TWO_M+AD_TYPE_8,    'LD'
  7475.     db THREE_M+AD_TYPE_E,    'JP'
  7476.     db ONE_M+AD_TYPE_1,    'INC'
  7477.     db ONE_M+AD_TYPE_0,    'ENTER'
  7478.  
  7479. ; opcodes 2x
  7480.  
  7481.     db TWO_M+AD_TYPE_2,    'INC'
  7482.     db TWO_M+AD_TYPE_2,    'INC'
  7483.     db TWO_M+AD_TYPE_5,    'SUB'
  7484.     db TWO_M+AD_TYPE_5,    'SUB'
  7485.     db THREE_M+AD_TYPE_A,    'SUB'
  7486.     db THREE_M+AD_TYPE_A,    'SUB'
  7487.     db THREE_M+AD_TYPE_B,    'SUB'
  7488.     db THREE_M+AD_TYPE_10,    'BXOR'
  7489.     db TWO_M+AD_TYPE_7,    'LD'
  7490.     db TWO_M+AD_TYPE_7,    'LD'
  7491.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7492.     db TWO_M+AD_TYPE_9,    'JR'
  7493.     db TWO_M+AD_TYPE_8,    'LD'
  7494.     db THREE_M+AD_TYPE_E,    'JP'
  7495.     db ONE_M+AD_TYPE_1,    'INC'
  7496.     db ONE_M+AD_TYPE_0,    'EXIT'
  7497.  
  7498. ; opcodes 3x
  7499.     db TWO_M+AD_TYPE_3,    'JP'
  7500.     db TWO_M+AD_TYPE_4,    VARY_MNE+7, 'SRP1'
  7501.     db TWO_M+AD_TYPE_5,    'SBC'
  7502.     db TWO_M+AD_TYPE_5,    'SBC'
  7503.     db THREE_M+AD_TYPE_A,    'SBC'
  7504.     db THREE_M+AD_TYPE_A,    'SBC'
  7505.     db THREE_M+AD_TYPE_B,    'SBC'
  7506.     db THREE_M+AD_TYPE_12,    VARY_MNE+6, 'BTJRT'
  7507.     db TWO_M+AD_TYPE_7,    'LD'
  7508.     db TWO_M+AD_TYPE_7,    'LD'
  7509.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7510.     db TWO_M+AD_TYPE_9,    'JR'
  7511.     db TWO_M+AD_TYPE_8,    'LD'
  7512.     db THREE_M+AD_TYPE_E,    'JP'
  7513.     db ONE_M+AD_TYPE_1,    'INC'
  7514.     db ONE_M+AD_TYPE_0,    'WFI'
  7515.  
  7516. ; opcodes 4x
  7517.     db TWO_M+AD_TYPE_2,    'DA'
  7518.     db TWO_M+AD_TYPE_2,    'DA'
  7519.     db TWO_M+AD_TYPE_5,    'OR'
  7520.     db TWO_M+AD_TYPE_5,    'OR'
  7521.     db THREE_M+AD_TYPE_A,    'OR'
  7522.     db THREE_M+AD_TYPE_A,    'OR'
  7523.     db THREE_M+AD_TYPE_B,    'OR'
  7524.     db THREE_M+AD_TYPE_10,    'LDB'
  7525.     db TWO_M+AD_TYPE_7,    'LD'
  7526.     db TWO_M+AD_TYPE_7,    'LD'
  7527.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7528.     db TWO_M+AD_TYPE_9,    'JR'
  7529.     db TWO_M+AD_TYPE_8,    'LD'
  7530.     db THREE_M+AD_TYPE_E,    'JP'
  7531.     db ONE_M+AD_TYPE_1,    'INC'
  7532.     db ONE_M+AD_TYPE_0,    'SB0'
  7533.  
  7534. ; opcodes 5x
  7535.     db TWO_M+AD_TYPE_2,    'POP'
  7536.     db TWO_M+AD_TYPE_2,    'POP'
  7537.     db TWO_M+AD_TYPE_5,    'AND'
  7538.     db TWO_M+AD_TYPE_5,    'AND'
  7539.     db THREE_M+AD_TYPE_A,    'AND'
  7540.     db THREE_M+AD_TYPE_A,    'AND'
  7541.     db THREE_M+AD_TYPE_B,    'AND'
  7542.     db TWO_M+AD_TYPE_13,    'BITC'
  7543.     db TWO_M+AD_TYPE_7,    'LD'
  7544.     db TWO_M+AD_TYPE_7,    'LD'
  7545.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7546.     db TWO_M+AD_TYPE_9,    'JR'
  7547.     db TWO_M+AD_TYPE_8,    'LD'
  7548.     db THREE_M+AD_TYPE_E,    'JP'
  7549.     db ONE_M+AD_TYPE_1,    'INC'
  7550.     db ONE_M+AD_TYPE_0,    'SB1'
  7551.  
  7552. ; opcodes 6x
  7553.     db TWO_M+AD_TYPE_2,    'COM'
  7554.     db TWO_M+AD_TYPE_2,    'COM'
  7555.     db TWO_M+AD_TYPE_5,    'TCM'
  7556.     db TWO_M+AD_TYPE_5,    'TCM'
  7557.     db THREE_M+AD_TYPE_A,    'TCM'
  7558.     db THREE_M+AD_TYPE_A,    'TCM'
  7559.     db THREE_M+AD_TYPE_B,    'TCM'
  7560.     db THREE_M+AD_TYPE_10,    'BAND'
  7561.     db TWO_M+AD_TYPE_7,    'LD'
  7562.     db TWO_M+AD_TYPE_7,    'LD'
  7563.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7564.     db TWO_M+AD_TYPE_9,    'JR'
  7565.     db TWO_M+AD_TYPE_8,    'LD'
  7566.     db THREE_M+AD_TYPE_E,    'JP'
  7567.     db ONE_M+AD_TYPE_1,    'INC'
  7568.     db ONE_M+AD_TYPE_0,    '**'
  7569.  
  7570. ; opcodes 7x
  7571.     db TWO_M+AD_TYPE_2,    'PUSH'
  7572.     db TWO_M+AD_TYPE_2,    'PUSH'
  7573.     db TWO_M+AD_TYPE_5,    'TM'
  7574.     db TWO_M+AD_TYPE_5,    'TM'
  7575.     db THREE_M+AD_TYPE_A,    'TM'
  7576.     db THREE_M+AD_TYPE_A,    'TM'
  7577.     db THREE_M+AD_TYPE_B,    'TM'
  7578.     db TWO_M+AD_TYPE_13,    VARY_MNE+5,'BITS'
  7579.     db TWO_M+AD_TYPE_7,    'LD'
  7580.     db TWO_M+AD_TYPE_7,    'LD'
  7581.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7582.     db TWO_M+AD_TYPE_9,    'JR'
  7583.     db TWO_M+AD_TYPE_8,    'LD'
  7584.     db THREE_M+AD_TYPE_E,    'JP'
  7585.     db ONE_M+AD_TYPE_1,    'INC'
  7586.     db ONE_M+AD_TYPE_0,    '**'
  7587.  
  7588. ; opcodes 8x
  7589.     db TWO_M+AD_TYPE_2,    'DECW'
  7590.     db TWO_M+AD_TYPE_2,    'DECW'
  7591.     db THREE_M+AD_TYPE_11,    'PUSHUD'
  7592.     db THREE_M+AD_TYPE_11,    'PUSHUI'
  7593.     db THREE_M+AD_TYPE_14,    'MULT'
  7594.     db THREE_M+AD_TYPE_14,    'MULT'
  7595.     db THREE_M+AD_TYPE_15,    'MULT'
  7596.     db THREE_M+AD_TYPE_D,    'LD'
  7597.     db TWO_M+AD_TYPE_7,    'LD'
  7598.     db TWO_M+AD_TYPE_7,    'LD'
  7599.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7600.     db TWO_M+AD_TYPE_9,    'JR'
  7601.     db TWO_M+AD_TYPE_8,    'LD'
  7602.     db THREE_M+AD_TYPE_E,    'JP'
  7603.     db ONE_M+AD_TYPE_1,    'INC'
  7604.     db ONE_M+AD_TYPE_0,    'DI'
  7605.  
  7606. ; opcodes 9x
  7607.     db TWO_M+AD_TYPE_2,    'RL'
  7608.     db TWO_M+AD_TYPE_2,    'RL'
  7609.     db THREE_M+AD_TYPE_11,    'POPUD'
  7610.     db THREE_M+AD_TYPE_11,    'POPUI'
  7611.     db THREE_M+AD_TYPE_14,    'DIV'
  7612.     db THREE_M+AD_TYPE_14,    'DIV'
  7613.     db THREE_M+AD_TYPE_15,    'DIV'
  7614.     db THREE_M+AD_TYPE_D,    'LD'
  7615.     db TWO_M+AD_TYPE_7,    'LD'
  7616.     db TWO_M+AD_TYPE_7,    'LD'
  7617.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7618.     db TWO_M+AD_TYPE_9,    'JR'
  7619.     db TWO_M+AD_TYPE_8,    'LD'
  7620.     db THREE_M+AD_TYPE_E,    'JP'
  7621.     db ONE_M+AD_TYPE_1,    'INC'
  7622.     db ONE_M+AD_TYPE_0,    'EI'
  7623.  
  7624. ; opcodes ax
  7625.     db TWO_M+AD_TYPE_2,    'INCW'
  7626.     db TWO_M+AD_TYPE_2,    'INCW'
  7627.     db TWO_M+AD_TYPE_5,    'CP'
  7628.     db TWO_M+AD_TYPE_5,    'CP'
  7629.     db THREE_M+AD_TYPE_A,    'CP'
  7630.     db THREE_M+AD_TYPE_A,    'CP'
  7631.     db THREE_M+AD_TYPE_B,    'CP'
  7632.     db FOUR_M+AD_TYPE_1B,    VARY_MNE+0,'LDE'
  7633.     db TWO_M+AD_TYPE_7,    'LD'
  7634.     db TWO_M+AD_TYPE_7,    'LD'
  7635.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7636.     db TWO_M+AD_TYPE_9,    'JR'
  7637.     db TWO_M+AD_TYPE_8,    'LD'
  7638.     db THREE_M+AD_TYPE_E,    'JP'
  7639.     db ONE_M+AD_TYPE_1,    'INC'
  7640.     db ONE_M+AD_TYPE_0,    'RET'
  7641.  
  7642. ; opcodes bx
  7643.     db TWO_M+AD_TYPE_2,    'CLR'
  7644.     db TWO_M+AD_TYPE_2,    'CLR'
  7645.     db TWO_M+AD_TYPE_5,    'XOR'
  7646.     db TWO_M+AD_TYPE_5,    'XOR'
  7647.     db THREE_M+AD_TYPE_A,    'XOR'
  7648.     db THREE_M+AD_TYPE_A,    'XOR'
  7649.     db THREE_M+AD_TYPE_B,    'XOR'
  7650.     db FOUR_M+AD_TYPE_1B,    VARY_MNE+0,'LDE'
  7651.     db TWO_M+AD_TYPE_7,    'LD'
  7652.     db TWO_M+AD_TYPE_7,    'LD'
  7653.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7654.     db TWO_M+AD_TYPE_9,    'JR'
  7655.     db TWO_M+AD_TYPE_8,    'LD'
  7656.     db THREE_M+AD_TYPE_E,    'JP'
  7657.     db ONE_M+AD_TYPE_1,    'INC'
  7658.     db ONE_M+AD_TYPE_0,    'IRET'
  7659.  
  7660. ; opcodes cx
  7661.     db TWO_M+AD_TYPE_2,    'RRC'
  7662.     db TWO_M+AD_TYPE_2,    'RRC'
  7663.     db THREE_M+AD_TYPE_16,    'CPIJE'
  7664.     db TWO_M+AD_TYPE_6,    VARY_MNE+0,'LDE'
  7665.     db THREE_M+AD_TYPE_17,    'LDW'
  7666.     db THREE_M+AD_TYPE_14,    'LDW'
  7667.     db FOUR_M+AD_TYPE_18,    'LDW'
  7668.     db TWO_M+AD_TYPE_5,    'LD'
  7669.     db TWO_M+AD_TYPE_7,    'LD'
  7670.     db TWO_M+AD_TYPE_7,    'LD'
  7671.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7672.     db TWO_M+AD_TYPE_9,    'JR'
  7673.     db TWO_M+AD_TYPE_8,    'LD'
  7674.     db THREE_M+AD_TYPE_E,    'JP'
  7675.     db ONE_M+AD_TYPE_1,    'INC'
  7676.     db ONE_M+AD_TYPE_0,    'RCF'
  7677.  
  7678. ; opcodes dx
  7679.     db TWO_M+AD_TYPE_2,    'SRA'
  7680.     db TWO_M+AD_TYPE_2,    'SRA'
  7681.     db THREE_M+AD_TYPE_16,    'CPIJNE'
  7682.     db TWO_M+AD_TYPE_6,    VARY_MNE+0,'LDE'
  7683.     db TWO_M+AD_TYPE_19,    'CALL'
  7684.     db ONE_M+AD_TYPE_0,    '**'
  7685.     db THREE_M+AD_TYPE_B,    'LD'
  7686.     db TWO_M+AD_TYPE_1C,    'LD'
  7687.     db TWO_M+AD_TYPE_7,    'LD'
  7688.     db TWO_M+AD_TYPE_7,    'LD'
  7689.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7690.     db TWO_M+AD_TYPE_9,    'JR'
  7691.     db TWO_M+AD_TYPE_8,    'LD'
  7692.     db THREE_M+AD_TYPE_E,    'JP'
  7693.     db ONE_M+AD_TYPE_1,    'INC'
  7694.     db ONE_M+AD_TYPE_0,    'SCF'
  7695.  
  7696. ; opcodes ex
  7697.     db TWO_M+AD_TYPE_2,    'RR'
  7698.     db TWO_M+AD_TYPE_2,    'RR'
  7699.     db TWO_M+AD_TYPE_6,    VARY_MNE+1,'LDED'
  7700.     db TWO_M+AD_TYPE_6,    VARY_MNE+2,'LDEI'
  7701.     db THREE_M+AD_TYPE_A,    'LD'
  7702.     db THREE_M+AD_TYPE_A,    'LD'
  7703.     db THREE_M+AD_TYPE_B,    'LD'
  7704.     db THREE_M+AD_TYPE_1A,    VARY_MNE+0,'LDE'
  7705.     db TWO_M+AD_TYPE_7,    'LD'
  7706.     db TWO_M+AD_TYPE_7,    'LD'
  7707.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7708.     db TWO_M+AD_TYPE_9,    'JR'
  7709.     db TWO_M+AD_TYPE_8,    'LD'
  7710.     db THREE_M+AD_TYPE_E,    'JP'
  7711.     db ONE_M+AD_TYPE_1,    'INC'
  7712.     db ONE_M+AD_TYPE_0,    'CCF'
  7713.  
  7714. ; opcodes fx
  7715.     db TWO_M+AD_TYPE_2,    'SWAP'
  7716.     db TWO_M+AD_TYPE_2,    'SWAP'
  7717.     db TWO_M+AD_TYPE_6,    VARY_MNE+3,'LDEPD'
  7718.     db TWO_M+AD_TYPE_6,    VARY_MNE+4,'LDEPI'
  7719.     db TWO_M+AD_TYPE_3,    'CALL'
  7720.     db THREE_M+AD_TYPE_C,    'LD'
  7721.     db THREE_M+AD_TYPE_F,    'CALL'
  7722.     db THREE_M+AD_TYPE_1A,    VARY_MNE+0,'LDE'
  7723.     db TWO_M+AD_TYPE_7,    'LD'
  7724.     db TWO_M+AD_TYPE_7,    'LD'
  7725.     db TWO_M+AD_TYPE_9,    'DJNZ'
  7726.     db TWO_M+AD_TYPE_9,    'JR'
  7727.     db TWO_M+AD_TYPE_8,    'LD'
  7728.     db THREE_M+AD_TYPE_E,    'JP'
  7729.     db ONE_M+AD_TYPE_1,    'INC'
  7730.     db ONE_M+AD_TYPE_0,    'NOP'
  7731.     db HI_BIT
  7732.  
  7733. ; mnenmonics that vary
  7734. ALT_TAB:
  7735.     db HI_BIT,    'LDC'
  7736.     db HI_BIT,    'LDCD'
  7737.     db HI_BIT,    'LDCI'
  7738.     db HI_BIT,    'LDCPD'
  7739.     db HI_BIT,    'LDCPI'
  7740.     db HI_BIT,    'BITR'
  7741.     db HI_BIT,    'BTJRF'
  7742.     db HI_BIT, 'SRP'
  7743.     db HI_BIT, 'SRP0'
  7744.     db HI_BIT
  7745.  
  7746. ; condition code mnemonics
  7747. CC_TAB:
  7748.     db 'F',COMMA,' ',$80
  7749.     db 'LT',COMMA,' ',$80
  7750.     db 'LE',COMMA,' ',$80
  7751.     db 'ULE',COMMA,' ',$80
  7752.     db 'OV',COMMA,' ',$80
  7753.     db 'MI',COMMA,' ',$80
  7754.     db 'Z/EQ',COMMA,' ',$80
  7755.     db 'C/ULT',COMMA,' ',$80
  7756.     db '    ',$80
  7757.     db 'GE',COMMA,' ',$80
  7758.     db 'GT',COMMA,' ',$80
  7759.     db 'UGT',COMMA,' ',$80
  7760.     db 'NOV',COMMA,' ',$80
  7761.     db 'PL',COMMA,' ',$80
  7762.     db 'NZ/NE',COMMA,' ',$80
  7763.     db 'NC/UGE',COMMA,' ',$80
  7764.  
  7765.     END
  7766.