tinybasic.asm

;----------------------------------------------------------------------------------
; Tiny Basic port to MKHBC-8-R1 6502 computer
; by Marek Karcz 2012.
;
; Based on the work by:
;
; ================= ORIGINAL HEADER ======================================
;
; OMS-02 Firmware
;
; Bill O'Neill - Last update: 2008/12/06
;
; Tiny Basic and minimal Monitor (BIOS)
;
; This version is for the assembler that comes with
; Michal Kowalski's 6502 emulator.  To run it, load it
; into the emulator, assemle it, begin debug mode then,
; set the PC to $1CF0 then run.
;
; The emulator was used to help figure out Tiny Basic
; and this code is only documented to that extent.
;
; It should be easy enough to configure this to run any-
; where in memory or convert it to assemble with any 6502
; assembler.  The current location is being used as this is
; to be placed into a controller I designed (OMS-02) around
; a 6507 CPU (a 6502 variant) that has only 8k off memory.
; The memory map for the OMS-02 is;
;
; $0000-$0FFF     RAM
; $1000-$13FF     I/O space (ACIA is at $1200)
; $1400-$1FFF     Tiny Basic and simple monitor
;
;
; Next steps:
;        Write a BREAK routine that will enable a break if any charater is typed at the console
;        More comments to document this code
;        Investigate using assembler variables and directives to make it easy to re-locate this code
;
; ============ END OF ORIGINAL HEADER =========================================
;
; Revision history (MKHBC-8-R1 port):
; 
; 1/4/2012:
;    TB port created.
;
; 1/5/2012:
;    Version 1.0.1.
;    Added 2-byte peek routine.
;
; 1/11/2012:
;	 Figured out jump addresses for routines and used symbolic labels
;	 instead of hardcoded addresses. Relocated TB to $0400 (from $1400).
;
; 2/15/2016
;    Ported to my own 6502 emulator.
; 
; 3/30/2016
;
;    Changed char input address from blocking to non-blocking.
;
;
;--------------------------------------------------------------------------------------

.segment "BEGN"

   .ORG  $0000

.segment "BASIC"

;
; Tiny Basic starts here
;
    .ORG      $4400                 ; Start of Basic.  First 1K of ROM is shaded by I/O on the OMS-02

SOBAS:

C_00BC   =     $00BC             	; These are needed because my assembler
C_20     =     $20               	; does not hanle standard 6502 notation
C_22     =     $22               	; properly
C_24     =     $24               	;
C_2A     =     $2A               	; I may just fix this someday - HA!
C_2C     =     $2C               	;
C_2E     =     $2E               	;
C_B8     =     $B8               	;
C_BC     =     $BC               	;
C_C1     =     $C1               	;
C_C2     =     $C2               	;
C_C6     =     $C6               	;

SR_V_L   =     SOBAS + $1E         	; Base address for subroutine vector lo byte
SR_V_H   =     SOBAS + $1F         	; Base address for subroutine vector hi byte

CV:       jmp      COLD_S            ; Cold start vector
WV:       jmp      WARM_S            ; Warm start vector
IN_V:     jmp      GetCh             ; Input routine address. 
OUT_V:    jmp      PutCh             ; Output routine address.
BREAK:    nop                        ; Begin dummy break routine
          clc                        ; Clear the carry flag
          rts                        ; End break routine
;
; Some codes
;
BSC:      .byte $5f                   	; Backspace code
LSC:      .byte $18                   	; Line cancel code
PCC:      .byte $80                   	; Pad character control
TMC:      .byte $00                   	; Tape mode control
;SSS:      .byte $04                   	; Spare Stack size. (was $04 but documentation suggests $20 ?)
SSS:      .byte $20                   	; Spare Stack size. (was $04 but documentation suggests $20 ?)

;
; Code fragment
; Seems to store or retreive a byte to/from memory and the accumulator
; ---
; M.K.: I think this code it is used from Tiny Basic programs by calling USR to store/retrieve
;       data (since TB does not support arrays, this is one way to emulate them).
; This location is at exactly 20 bytes distance from the start of TB code.
; TB programs typically make USR calls to locations: 
; SOBAS+20
; SOBAS+24
; E.g:
; LET S=_SOBAS_ REM (_SOBAS_ is TB start)
; LET B=_ARRAY_SIZE_+2 (_ARRAY_SIZE_ is the size of 2-dim array)
; Get byte from location V(I,J), store in Z.
; LET Z=USR(S+20,V+B*I+J,0)
; Store Z in location V(I,J)
; LET Z=USR(S+24,V+B*I+J,Z)
; From TB documentation:
;   For your convenience two subroutines have been included in the TINY BASIC interpreter to access memory.  
;   If S contains the address of the beginning of the TINY BASIC interpreter (256 for standard 6800, 512 
;   for standard 6502, etc.), then location S+20 (hex 0114) is the entry point of a subroutine to read one 
;   byte from the memory address in the index register, and location S+24 (hex 0118) is the entry point of 
;   a subroutine to store one byte into memory. 
;-------------------------------------------------
;      USR (address)
;      USR (address,Xreg)
;      USR (address,Xreg,Areg)
;
;   This function is actually a machine-language subroutine call to the address in the first argument.  
;   If the second argument is included the index registers contain that value on entry to the subroutine, 
;   with the most significant part in X.  If the third argument is included, the accumulators contain that 
;   value on entry to the subroutine, with the least significant part in A.  On exit, the value in the 
;   Accumulators (for the 6800; A and Y for the 6502) becomes the value of the function, with the least 
;   significant part in A.  All three arguments are evaluated as normal expressions.
;   It should be noted that machine language subroutine addresses are 16-bit Binary numbers.  TINY BASIC 
;   evaluates all expressions to 16-bit binary numbers, so any valid expression may be used to define a 
;   subroutine address.  However, most addresses are expressed in hexadecimal whereas TINY BASIC only accepts 
;   numerical constants in decimal.  Thus to jump to a subroutine at hex address 40AF, you must code USR(16559). 
;   Hex address FFB5 is similarly 65461 in decimal, though the equivalent (-75) may be easier to use. 
; 

OneBytePeek:

         stx $C3		; read one byte from memory address in the index register
         bcc LBL008

OneBytePoke:

         stx $C3		; store one byte into memory
         sta (C_C2),Y
         rts
LBL008:  lda (C_C2),Y
         ldy #$00
         rts

	
	 ; These seem to be addresses associated with the IL branch instructions
     ;.byte $62,$15, $64,$15, $D8,$15, $05,$16, $33,$16, $FD,$15    	
	 .byte <JUMP01,>JUMP01
	 .byte <LBL027,>LBL027
	 .byte <JUMP02,>JUMP02
	 .byte <JUMP03,>JUMP03
	 .byte <JUMP04,>JUMP04
	 .byte <JUMP05,>JUMP05

	; NOTE: The original comment below is obsolete now, since I found the jump
	;       addresses locations and put them in this table. Now assembler will
	;		take care of the reallocation.
	 ; START OF ORIGINAL COMMENT
	 ; This appears to be a table of
	 ; execution addresses to jump to ML routines
	 ; that handle the the IL instructions.
	 ; You cannot add code to or relocate this program
	 ; without updating these
	 ; END OF ORIGINAL COMMENT

     ;.byte $9F,$17, $42,$1B, $3F,$1B, $7A,$17, $FC,$18, $95,$17, $9F,$17, $9F,$17 
	 .byte <LBL067,>LBL067
	 .byte <LBL132,>LBL132
	 .byte <JUMP06,>JUMP06
	 .byte <JUMP07,>JUMP07
	 .byte <LBL035,>LBL035
	 .byte <LBL097,>LBL097
	 .byte <LBL067,>LBL067
	 .byte <LBL067,>LBL067
	 
     ;.byte $BD,$1A, $C1,$1A, $8A,$1A, $9B,$1A, $E9,$1A, $61,$17, $51,$17, $41,$1A 
	 .byte <JUMP08,>JUMP08
	 .byte <JUMP09,>JUMP09
	 .byte <JUMP10,>JUMP10
	 .byte <JUMP11,>JUMP11
	 .byte <JUMP12,>JUMP12
	 .byte <JUMP13,>JUMP13
	 .byte <JUMP14,>JUMP14
	 .byte <LBL071,>LBL071
	 
     ;.byte $52,$1A, $4F,$1A, $62,$1A, $E7,$19, $CD,$16, $06,$17, $9F,$17, $15,$18 
	 .byte <JUMP15,>JUMP15
	 .byte <JUMP16,>JUMP16
	 .byte <JUMP17,>JUMP17
	 .byte <JUMP18,>JUMP18
	 .byte <JUMP19,>JUMP19
	 .byte <JUMP20,>JUMP20
	 .byte <LBL067,>LBL067
	 .byte <JUMP21,>JUMP21
	 
     ;.byte $A7,$17, $B7,$16, $BF,$16, $83,$18, $A1,$16, $9F,$17, $9F,$17, $A8,$18 
	 .byte <JUMP22,>JUMP22
	 .byte <JUMP23,>JUMP23
	 .byte <LBL047,>LBL047
	 .byte <LBL081,>LBL081
	 .byte <LBL013,>LBL013
	 .byte <LBL067,>LBL067
	 .byte <LBL067,>LBL067
	 .byte <JUMP24,>JUMP24
	 
     ;.byte $4F,$1B, $4D,$1B, $07,$19, $AA,$14, $37,$17, $BD,$14, $1B,$1B, $B1,$1A 
     .byte <JUMP25,>JUMP25
	 .byte <JUMP26,>JUMP26
	 .byte <JUMP27,>JUMP27
	 .byte <MEM_T2,>MEM_T2
	 .byte <JUMP28,>JUMP28
	 .byte <WARM_S,>WARM_S
	 .byte <JUMP29,>JUMP29
	 .byte <JUMP30,>JUMP30

     .byte $20,$41, $54,$20     ; No idea ????

     .byte $80                  ; No idea
         
LBL002:  .byte <ILTBL	;$70                  ; $70 - lo byte of IL address
LBL003:  .byte >ILTBL	;$1B                  ; $1B - hi byte of IL address

;
;Begin Cold Start
;
;
;
; Load start of free ram ($1C00) into locations $0020 and $0022
; The memory between $1000 and $1Bff (3 kB) is free for assembler programs
; that can be loaded and used simultaneously with TB.
; $1C00 to the end of writable memory is the BASIC memory space.
;
COLD_S:  lda #$00                   ; Load accumulator with lo byte of lower and upper prg memory limits
         sta $20                    ; Store in $20
         sta $22                    ; Store in $22
         lda #$50                   ; Load accumulator with hi byte of lower and upper prg memory limits
         sta $21                    ; Store in $21
         sta $23                    ; Store in $23
		 ; NOTE: $22,$23 vector will be updated by routine below to be the upper RAM limit for TB.
;
;
; Begin test for free ram
; As a result, memory locations $20,$21 will contain lo,hi byte order address of lower RAM boundary
; and $22,$23 upper RAM boundary respectively.
;
         
         ldy #$01                   ; Load register Y with $01
MEM_T:   lda (C_22),Y               ; Load accumulator With the contents of a byte of memory
         tax                        ; Save it to X
         eor #$FF                   ; Next 4 instuctions test to see if this memeory location
         sta (C_22),Y               ; is ram by trying to write something new to it - new value
         cmp (C_22),Y               ; gets created by XORing the old value with $FF - store the
         php                        ; result of the test on the stack to look at later
         txa                        ; Retrieve the old memory value
         sta (C_22),Y               ; Put it back where it came from
         inc $22                    ; Increment $22 (for next memory location)
         bne SKP_PI                 ; Goto $14A6 if we don't need to increment page
         inc $23                    ; Increment $23 (for next memory page)
SKP_PI:  plp                        ; Now look at the result of the memory test
         beq MEM_T                  ; Go test the next mempry location if the last one was ram
         dey                        ; If last memory location did not test as ram, decrement Y (should be $00 now)
MEM_T2:  cld                        ; Make sure we're not in decimal mode
         lda $20                    ; Load up the low-order by of the start of free ram
         adc SSS                    ; Add to the spare stack size
         sta $24                    ; Store the result in $0024
         tya                        ; Retrieve Y
         adc $21                    ; And add it to the high order byte of the start of free ram (this does not look right)
         sta $25                    ; Store the result in $0025
         tya                        ; Retrieve Y again
         sta (C_20),Y               ; Store A in the first byte of program memory
         iny                        ; Increment Y
         sta (C_20),Y               ; Store A in the second byte of program memory
;
;Begin Warm Start;
;
WARM_S:  lda $22
         sta $C6
         sta $26
         lda $23
         sta $C7
         sta $27
         jsr LBL001                 ; Go print CR, LF and pad charachters
LBL014:  lda LBL002
         sta $2A
         lda LBL003
         sta $2B
         lda #$80
         sta $C1
         lda #$30
         sta $C0
         ldx #$00
         stx $BE
         stx $C2
         dex
         txs
LBL006:  cld
         jsr LBL004                 ; Go read a byte from the TBIL table
         jsr LBL005
         jmp LBL006
;
;
;
         .byte $83                  ; No idea about this
         .byte $65                  ; No idea about this
;
;
; Routine to service the TBIL Instructions
;
LBL005:  cmp #$30                   ;
         bcs LBL011                 ; If it's $30 or higher, it's a Branch or Jump - go handle it
         cmp #$08                   ; 
         bcc LBL007                 ; If it's less than $08 it's a stack exchange - go handle it
         asl                        ; Multiply the OP code by 2 
         tax                        ; Transfer it to X
LBL022:  lda SR_V_H,X               ; Get the hi byte of the OP Code handling routine
         pha                        ; and save it on the stack
         lda SR_V_L,X               ; Get the lo byte
         pha                        ; and save it on the stack
         php                        ; save the processor status too
         rti                        ; now go execute the OP Code handling routine
;
;
; Routine to handle the stack exchange 
;
LBL007:  adc $C1
         tax
         lda (C_C1),Y
         pha
         lda $00,X
         sta (C_C1),Y
         pla
         sta $00,X
         rts
;
;
;
LBL015:  jsr LBL001                 ; Go print CR, LF and pad charachters
         lda #$21                   ; Load an ASCII DC2
         jsr OUT_V                  ; Go print it
         lda $2A                    ; Load the current TBIL pointer (lo) 
         sec                        ; Set the carry flag
         sbc LBL002                 ; Subtract the TBIL table origin (lo)
         tax                        ; Move the difference to X
         lda $2B                    ; Load the current TBIL pointer (hi)
         sbc LBL003                 ; Subtract the TBIL table origin (hi)
         jsr LBL010
         lda $BE
         beq LBL012
         lda #$7E
         sta $2A
         lda #$20
         sta $2B
         jsr LBL013
         ldx $28
         lda $29
         jsr LBL010
LBL012:  lda #$07                   ; ASCII Bell
         jsr OUT_V                  ; Go ring Bell
         jsr LBL001                 ; Go print CR, LF and pad charachters
LBL060:  lda $26
         sta $C6
         lda $27
         sta $C7
         jmp LBL014
;
;
;
LBL115:  ldx #$7C
LBL048:  cpx $C1
LBL019:  bcc LBL015
         ldx $C1
         inc $C1
         inc $C1
         clc
         rts
;
;
;
JUMP01:  dec $BD
LBL027:  lda $BD
         beq LBL015
LBL017:  lda $BC
         sta $2A
         lda $BD
         sta $2B
         rts
;
; Branch handling routine
;
LBL011:  cmp #$40	                  ;
         bcs LBL016                 ; If it's not a Jump, go to branch handler
         pha
         jsr LBL004                 ; Go read a byte from the TBIL table
         adc LBL002
         sta $BC
         pla
         pha
         and #$07
         adc LBL003
         sta $BD
         pla
         and #$08
         bne LBL017
         lda $BC
         ldx $2A
         sta $2A
         stx $BC
         lda $BD
         ldx $2B
         sta $2B
         stx $BD
LBL126:  lda $C6
         sbc #$01
         sta $C6
         bcs LBL018
         dec $C7
LBL018:  cmp $24
         lda $C7
         sbc $25
         bcc LBL019
         lda $BC
         sta (C_C6),Y
         iny
         lda $BD
         sta (C_C6),Y
         rts
;
;Branch handler
;
LBL016:  pha
         lsr
         lsr
         lsr
         lsr
         and #$0E
         tax
         pla
         cmp #$60
         and #$1F
         bcs LBL020
         ora #$E0
LBL020:  clc
         beq LBL021
         adc $2A
         sta $BC
         tya
         adc $2B
LBL021:  sta $BD
         JMP LBL022
;
;
;
JUMP02:  lda $2C
         sta $B8
         lda $2D
         sta $B9
LBL025:  jsr LBL023
         jsr LBL024
         eor (C_2A),Y
         tax
         jsr LBL004                 ; Go read a byte from the TBIL table
         txa
         beq LBL025
         asl
         beq LBL026
         lda $B8
         sta $2C
         lda $B9
         sta $2D
LBL028:  jmp LBL027
JUMP05:  jsr LBL023
         cmp #$0D
         bne LBL028
LBL026:  rts
;
;
;
JUMP03:  jsr LBL023
         cmp #$5B
         bcs LBL028
         cmp #$41
         bcc LBL028
         asl
         jsr LBL029
LBL024:  ldy #$00
         lda (C_2C),Y
         inc $2C
         bne LBL030
         inc $2D
LBL030:  cmp #$0D
         clc
         rts
;
;

LBL031:  jsr LBL024
LBL023:  lda (C_2C),Y
         cmp #$20
         beq LBL031
         cmp #$3A
         clc
         bpl LBL032
         cmp #$30
LBL032:  rts
;
;
;
JUMP04:  jsr LBL023
         bcc LBL028
         sty $BC
         sty $BD
LBL033:  lda $BC
         ldx $BD
         asl $BC
         rol $BD
         asl $BC
         rol $BD
         clc
         adc $BC
         sta $BC
         txa
         adc $BD
         asl $BC
         rol
         sta $BD
         jsr LBL024
         and #$0F
         adc $BC
         sta $BC
         tya
         adc $BD
         sta $BD
         jsr LBL023
         bcs LBL033
         jmp LBL034
LBL061:  jsr LBL035
         lda $BC
         ora $BD
         beq LBL036
LBL065:  lda $20
         sta $2C
         lda $21
         sta $2D
LBL040:  jsr LBL037
         beq LBL038
         lda $28
         cmp $BC
         lda $29
         sbc $BD
         bcs LBL038
LBL039:  jsr LBL024
         bne LBL039
         jmp LBL040
LBL038:  lda $28
         eor $BC
         bne LBL041
         lda $29
         eor $BD
LBL041:  rts
;
;
;
LBL043:  jsr LBL042
LBL013:  jsr LBL004                 ; Entry point for TBIL PC (print literal) - Go read a byte from the TBIL table
         bpl LBL043                 ; 
LBL042:  inc $BF
         bmi LBL044
         jmp OUT_V                  ; Go print it
LBL044:  dec $BF
LBL045:  rts
;
;
;
LBL046:  cmp #$22
         beq LBL045
         jsr LBL042
JUMP23:  jsr LBL024
         bne LBL046
LBL036:  jmp LBL015
LBL047:  lda #$20
         jsr LBL042
         lda $BF
         and #$87
         bmi LBL045
         bne LBL047
         rts
;
;
;
JUMP19:  ldx #$7B
         jsr LBL048
         inc $C1
         inc $C1
         inc $C1
         sec
         lda $03,X
         sbc $00,X
         sta $00,X
         lda $04,X
         sbc $01,X
         bvc LBL052
         eor #$80
         ora #$01
LBL052:  bmi LBL053
         bne LBL054
         ora $00,X
         beq LBL049
LBL054:  lsr $02,X
LBL049:  lsr $02,X
LBL053:  lsr $02,X
         bcc LBL050
LBL004:  ldy #$00                   ; Read a byte from the TBIL Table
         lda (C_2A),Y               ;
         inc $2A                    ; Increment TBIL Table pointer as required
         bne LBL051                 ;
         inc $2B                    ;
LBL051:  ora #$00                   ; Check for $00 and set the 'Z' flag acordingly
LBL050:  rts                        ; Return
;
;
;
JUMP20:  lda $BE
         beq LBL055
LBL056:  jsr LBL024
         bne LBL056
         jsr LBL037
         beq LBL057
LBL062:  jsr LBL058
         jsr BREAK
         bcs LBL059
         lda $C4
         sta $2A
         lda $C5
         sta $2B
         rts
;
;
;
LBL059:  lda LBL002
         sta $2A
         lda LBL003
         sta $2B
LBL057:  jmp LBL015
LBL055:  sta $BF
         jmp LBL060
JUMP28:  lda $20
         sta $2C
         lda $21
         sta $2D
         jsr LBL037
         beq LBL057
         lda $2A
         sta $C4
         lda $2B
         sta $C5
LBL058:  lda #$01
         sta $BE
         rts
;
;
;
JUMP14:  jsr LBL061
         beq LBL062
LBL066:  lda $BC
         sta $28
         lda $BD
         sta $29
         jmp LBL015
JUMP13:  jsr LBL063
         jsr LBL064
         jsr LBL065
         bne LBL066
         rts
;
;
;
LBL037:  jsr LBL024
         sta $28
         jsr LBL024
         sta $29
         ora $28
         rts
;
;
;
JUMP07:  jsr LBL035
         jsr LBL034
LBL034:  lda $BD
LBL131:  jsr LBL029
         lda $BC
LBL029:  ldx $C1
         dex
         sta $00,X
         stx $C1
         cpx $C0
         bne LBL067
LBL068:  jmp LBL015
LBL097:  ldx $C1
         cpx #$80
         bpl LBL068
         lda $00,X
         inc $C1
LBL067:  rts
;
;
;
LBL010:  sta $BD
         stx $BC
         jmp LBL069
JUMP22:  ldx $C1	; entry point to TBIL PN (print number)
         lda $01,X
         bpl LBL070
         jsr LBL071
         lda #$2D
         jsr LBL042
LBL070:  jsr LBL035
LBL069:  lda #$1F
         sta $B8
         sta $BA
         lda #$2A
         sta $B9
         sta $BB
         ldx $BC
         ldy $BD
         sec
LBL072:  inc $B8
         txa
         sbc #$10
         tax
         tya
         sbc #$27
         tay
         bcs LBL072
LBL073:  dec $B9
         txa
         adc #$E8
         tax
         tya
         adc #$03
         tay
         bcc LBL073
         txa
LBL074:  sec
         inc $BA
         sbc #$64
         bcs LBL074
         dey
         bpl LBL074
LBL075:  dec $BB
         adc #$0A
         bcc LBL075
         ora #$30
         sta $BC
         lda #$20
         sta $BD
         ldx #$FB
LBL199:  stx $C3
         lda $BD,X
         ora $BD
         cmp #$20
         beq LBL076
         ldy #$30
         sty $BD
         ora $BD
         jsr LBL042
LBL076:  ldx $C3
         inx
         bne LBL199
         rts
;
;
;
JUMP21:  lda $2D
         pha
         lda $2C
         pha
         lda $20
         sta $2C
         lda $21
         sta $2D
         lda $24
         ldx $25
         jsr LBL077
         beq LBL078
         jsr LBL077
LBL078:  lda $2C
         sec
         sbc $B6
         lda $2D
         sbc $B7
         bcs LBL079
         jsr LBL037
         beq LBL079
         ldx $28
         lda $29
         jsr LBL010
         lda #$20
LBL080:  jsr LBL042
         jsr BREAK
         bcs LBL079
         jsr LBL024
         bne LBL080
         jsr LBL081
         jmp LBL078
LBL077:  sta $B6
         inc $B6
         bne LBL082
         inx
LBL082:  stx $B7
         ldy $C1
         cpy #$80
         beq LBL083
         jsr LBL061
LBL099:  lda $2C
         ldx $2D
         sec
         sbc #$02
         bcs LBL084
         dex
LBL084:  sta $2C
         jmp LBL085
LBL079:  pla
         sta $2C
         pla
         sta $2D
LBL083:  rts
LBL081:  lda $BF
         bmi LBL083
;
;
; Routine to handle CR, LF and pad characters in the ouput
;
LBL001:  lda #$0D                   ; Load up a CR
         jsr OUT_V                  ; Go print it
         lda PCC                    ; Load the pad character code
         and #$7F                   ; Test to see - 
         sta $BF                    ; how many pad charachters to print
         beq LBL086                 ; Skip if 0
LBL088:  jsr LBL087                 ; Go print pad charcter
         dec $BF                    ; One less
         bne LBL088                 ; Loop until 0
LBL086:  lda #$0A                   ; Load up a LF
         jmp LBL089                 ; Go print it
;
;
;
LBL092:  ldy TMC
LBL091:  sty $BF
         bcs LBL090
JUMP24:  lda #$30                   ; Entry pont for TBIL GL (get input line)
         sta $2C
         sta $C0
         sty $2D
         jsr LBL034
LBL090:  eor $80
         sta $80
         jsr IN_V
         ldy #$00
         ldx $C0
         and #$7F
         beq LBL090
         cmp #$7F
         beq LBL090
         cmp #$13
         beq LBL091
         cmp #$0A
         beq LBL092
         cmp LSC
         beq LBL093
         cmp BSC
         bne LBL094
         cpx #$30
         bne LBL095
LBL093:  ldx $2C
         sty $BF
         lda #$0D
LBL094:  cpx $C1
         bmi LBL096
         lda #$07
         jsr LBL042
         jmp LBL090
LBL096:  sta $00,X
         inx
         inx
LBL095:  dex
         stx $C0
         cmp #$0D
         bne LBL090
         jsr LBL081
LBL035:  jsr LBL097
         sta $BC
         jsr LBL097
         sta $BD
         rts
;
;
;
JUMP27:  jsr LBL098
         jsr LBL061
         php
         jsr LBL099
         sta $B8
         stx $B9
         lda $BC
         sta $B6
         lda $BD
         sta $B7
         ldx #$00
         plp
         bne LBL100
         jsr LBL037
         dex
         dex
LBL101:  dex
         jsr LBL024
         bne LBL101
LBL100:  sty $28
         sty $29
         jsr LBL098
         lda #$0D
         cmp (C_2C),Y
         beq LBL102
         inx
         inx
         inx
LBL103:  inx
         iny
         cmp (C_2C),Y
         bne LBL103
         lda $B6
         sta $28
         lda $B7
         sta $29
LBL102:  lda $B8
         sta $BC
         lda $B9
         sta $BD
         clc
         ldy #$00
         txa
         beq LBL104
         bpl LBL105
         adc $2E
         sta $B8
         lda $2F
         sbc #$00
         sta $B9
LBL109:  lda (C_2E),Y
         sta (C_B8),Y
         ldx $2E
         cpx $24
         bne LBL106
         lda $2F
         cmp $25
         beq LBL107
LBL106:  inx
         stx $2E
         bne LBL108
         inc $2F
LBL108:  inc $B8
         bne LBL109
         inc $B9
         bne LBL109
LBL105:  adc $24
         sta $B8
         sta $2E
         tya
         adc $25
         sta $B9
         sta $2F
         lda $2E
         sbc $C6
         lda $2F
         sbc $C7
         bcc LBL110
         dec $2A
         jmp LBL015
LBL110:  lda (C_24),Y
         sta (C_2E),Y
         ldx $24
         bne LBL111
         dec $25
LBL111:  dec $24
         ldx $2E
         bne LBL112
         dec $2F
LBL112:  dex
         stx $2E
         cpx $BC
         bne LBL110
         ldx $2F
         cpx $BD
         bne LBL110
LBL107:  lda $B8
         sta $24
         lda $B9
         sta $25
LBL104:  lda $28
         ora $29
         beq LBL113
         lda $28
         sta (C_BC),Y
         iny
         lda $29
         sta (C_BC),Y
LBL114:  iny
         sty $B6
         jsr LBL024
         php
         ldy $B6
         sta (C_BC),Y
         plp
         bne LBL114
LBL113:  jmp LBL014
JUMP18:  jsr LBL115
         lda $03,X
         and #$80
         beq LBL116
         lda #$FF
LBL116:  sta $BC
         sta $BD
         pha
         adc $02,X
         sta $02,X
         pla
         pha
         adc $03,X
         sta $03,X
         pla
         eor $01,X
         sta $BB
         bpl LBL117
         jsr LBL118
LBL117:  ldy #$11
         lda $00,X
         ora $01,X
         bne LBL119
         jmp LBL015
LBL119:  sec
         lda $BC
         sbc $00,X
         pha
         lda $BD
         sbc $01,X
         pha
         eor $BD
         bmi LBL120
         pla
         sta $BD
         pla
         sta $BC
         sec
         jmp LBL121
LBL120:  pla
         pla
         clc
LBL121:  rol $02,X
         rol $03,X
         rol $BC
         rol $BD
         dey
         bne LBL119
         lda $BB
         bpl LBL122
LBL071:  ldx $C1
LBL118:  sec
         tya
         sbc $00,X
         sta $00,X
         tya
         sbc $01,X
         sta $01,X
LBL122:  rts
;
;
;
JUMP16:  jsr LBL071
JUMP15:  jsr LBL115
         lda $00,X
         adc $02,X
         sta $02,X
         lda $01,X
         adc $03,X
         sta $03,X
         rts
;
;
;
JUMP17:  jsr LBL115
         ldy #$10
         lda $02,X
         sta $BC
         lda $03,X
         sta $BD
LBL124:  asl $02,X
         rol $03,X
         rol $BC
         rol $BD
         bcc LBL123
         clc
         lda $02,X
         adc $00,X
         sta $02,X
         lda $03,X
         adc $01,X
         sta $03,X
LBL123:  dey
         bne LBL124
         rts
;
;
;
JUMP10:  jsr LBL097
         tax
         lda $00,X
         ldy $01,X
         dec $C1
         ldx $C1
         sty $00,X
         jmp LBL029
JUMP11:  ldx #$7D
         jsr LBL048
         lda $01,X
         pha
         lda $00,X
         pha
         jsr LBL097
         tax
         pla
         sta $00,X
         pla
         sta $01,X
         rts
JUMP30:  jsr LBL063
         lda $BC
         sta $2A
         lda $BD
         sta $2B
         rts
;
;
;
JUMP08:  ldx #$2C                   ; Entry point to Save Basic Pointer SB
         bne LBL125
JUMP09:  ldx #$2E
LBL125:  lda $00,X
         cmp #$80
         bcs LBL098
         lda $01,X
         bne LBL098
         lda $2C
         sta $2E
         lda $2D
         sta $2F
         rts
;
;
;
LBL098:  lda $2C
         ldy $2E
         sty $2C
         sta $2E
         lda $2D
         ldy $2F
         sty $2D
         sta $2F
         ldy #$00
         rts
;
;
;
JUMP12:  lda $28
         sta $BC
         lda $29
         sta $BD
         jsr LBL126
         lda $C6
         sta $26
         lda $C7
LBL064:  sta $27
LBL129:  rts
;
;
;
LBL063:  lda (C_C6),Y
         sta $BC
         jsr LBL127
         lda (C_C6),Y
         sta $BD
LBL127:  inc $C6
         bne LBL128
         inc $C7
LBL128:  lda $22
         cmp $C6
         lda $23
         sbc $C7
         bcs LBL129
         jmp LBL015
JUMP29:  jsr LBL130
         sta $BC
         tya
         jmp LBL131
LBL130:  jsr LBL035
         lda $BC
         sta $B6
         jsr LBL035
         lda $BD
         sta $B7
         ldy $BC
         jsr LBL035
         ldx $B7
         lda $B6
         clc
         jmp (C_00BC)
JUMP06:  jsr LBL132
LBL132:  jsr LBL004                 ; Go read a byte from the TBIL Table
         jmp LBL029
LBL085:  stx $2D
         cpx #$00
         rts
;
;
;
JUMP26:  ldy #$02
JUMP25:  sty $BC
         ldy #$29
         sty $BD
         ldy #$00
         lda (C_BC),Y
         cmp #$08
         bne LBL133
         jmp LBL117
LBL133:  rts
;
;
; Subroutine to decide which pad character to print
;
LBL089:  jsr OUT_V                  ; Entry point with a charater to print first
LBL087:  lda #$FF                   ; Normal entry point - Set pad to $FF
         bit PCC                    ; Check if the pad flag is on
         bmi LBL134                 ; Skip it if not
         lda #$00                   ; set pad to $00
LBL134:  jmp OUT_V                  ; Go print it


;
; TBIL Tables
;
ILTBL:   .byte $24, $3A, $91, $27, $10, $E1, $59, $C5, $2A, $56, $10, $11, $2C, $8B, $4C
         .byte $45, $D4, $A0, $80, $BD, $30, $BC, $E0, $13, $1D, $94, $47, $CF, $88, $54
         .byte $CF, $30, $BC, $E0, $10, $11, $16, $80, $53, $55, $C2, $30, $BC, $E0, $14
         .byte $16, $90, $50, $D2, $83, $49, $4E, $D4, $E5, $71, $88, $BB, $E1, $1D, $8F
         .byte $A2, $21, $58, $6F, $83, $AC, $22, $55, $83, $BA, $24, $93, $E0, $23, $1D
         .byte $30, $BC, $20, $48, $91, $49, $C6, $30, $BC, $31, $34, $30, $BC, $84, $54
         .byte $48, $45, $CE, $1C, $1D, $38, $0D, $9A, $49, $4E, $50, $55, $D4, $A0, $10
         .byte $E7, $24, $3F, $20, $91, $27, $E1, $59, $81, $AC, $30, $BC, $13, $11, $82
         .byte $AC, $4D, $E0, $1D, $89, $52, $45, $54, $55, $52, $CE, $E0, $15, $1D, $85
         .byte $45, $4E, $C4, $E0, $2D, $98, $4C, $49, $53, $D4, $EC, $24, $00, $00, $00
         .byte $00, $0A, $80, $1F, $24, $93, $23, $1D, $30, $BC, $E1, $50, $80, $AC, $59
         .byte $85, $52, $55, $CE, $38, $0A, $86, $43, $4C, $45, $41, $D2, $2B, $84, $52
         .byte $45, $CD, $1D, $A0, $80, $BD, $38, $14, $85, $AD, $30, $D3, $17, $64, $81
         .byte $AB, $30, $D3, $85, $AB, $30, $D3, $18, $5A, $85, $AD, $30, $D3, $19, $54
         .byte $2F, $30, $E2, $85, $AA, $30, $E2, $1A, $5A, $85, $AF, $30, $E2, $1B, $54
         .byte $2F, $98, $52, $4E, $C4, $0A, $80, $80, $12, $0A, $09, $29, $1A, $0A, $1A
         .byte $85, $18, $13, $09, $80, $12, $01, $0B, $31, $30, $61, $72, $0B, $04, $02
         .byte $03, $05, $03, $1B, $1A, $19, $0B, $09, $06, $0A, $00, $00, $1C, $17, $2F
         .byte $8F, $55, $53, $D2, $80, $A8, $30, $BC, $31, $2A, $31, $2A, $80, $A9, $2E
         .byte $2F, $A2, $12, $2F, $C1, $2F, $80, $A8, $30, $BC, $80, $A9, $2F, $83, $AC
         .byte $38, $BC, $0B, $2F, $80, $A8, $52, $2F, $84, $BD, $09, $02, $2F, $8E, $BC
         .byte $84, $BD, $09, $93, $2F, $84, $BE, $09, $05, $2F, $09, $91, $2F, $80, $BE
         .byte $84, $BD, $09, $06, $2F, $84, $BC, $09, $95, $2F, $09, $04, $2F, $00, $00
         .byte $00
;
; End of Tiny Basic


.segment "MAIN"

         .org $4CF0    ; Address of main program

; Code needs work below here, BIOS must be changed for MKHBC-8-R1

;FBLK:
;
; Set some symbols
;
;ACIARW   = $1200                    ; Base address of ACIA
;ACIAST   = ACIARW+$01               ; ACIA status register 
;ACIACM   = ACIARW+$02               ; ACIA commnad register
;ACIACN   = ACIARW+$03               ; ACIA control register


;
; Begin base system initialization
;
;		 jmp main		; no 6522 on MKHBC-8-R1
;--------------------		 
;         sta ACIAST                 ; Do a soft reset on the ACIA
;         lda #$0B                   ; Set it up for :
;         sta ACIACM                 ;        no echo, no parity, RTS low, No IRQ, DTR low
;         lda #$1A                   ; and :
;         sta ACIACN                 ;        2400, 8 bits, 1 stop bit, external Rx clock
;--------------------

main:    cli 
         cld
         jsr CLRSC                  ; Go clear the screen
         ldy #$00                   ; Offset for welcome message and prompt
         jsr SNDMSG                 ; Go print it
ST_LP:   JSR GetCh                  ; Go get a character from the console
         cmp #$43                   ; Check for 'C'
         BNE IS_WRM                 ; If not branch to next check
         jmp COLD_S                 ; Otherwise cold-start Tiny Basic
IS_WRM:  cmp #$57                   ; Check for 'W'
         BNE PRMPT                  ; If not, branch to re-prompt them
         jmp WARM_S                 ; Otherwise warm-start Tiny Basic
PRMPT:   ldy #$00                   ; Offset of prompt
         jsr SNDMSG                 ; Go print the prompt	 
         jmp ST_LP                  ; Go get the response

.segment "MESG"

         .org $4E00    ; Address of message area
MBLK:

;
; The message block begins at $4E00 and is at most 256 bytes long.
; Messages terminate with an FF.
;
         .byte "MKHBC-8-R2 TINY BASIC 6502 PORT"
         .byte  $0D, $0A ;, $0A
         .byte "Adapted from OMEGA MICRO SYSTEMS."
         .byte  $0D, $0A ;, $0A
         .byte "Version: 1.0.3, 3/31/2016"
         .byte  $0D, $0A ;, $0A
         .byte  "(NOTE: Use upper case letters.)"
         .byte  $0D, $0A ;, $0A
         .byte "Boot ([C]old/[W]arm)? "
         .byte  $07, $FF
	
.segment "SUBR"

     .org $4F00    ;address of subroutine area
	 
SBLK:
;
; Begin BIOS subroutines
;

; M.O.S. API defines.

StrPtr	=	$E0

;SNDCHR	=	PutCh
;RCCHR	=	GetCh


;
; Clear the screen
;
ESC	=	$1b

; 2-BYTE PEEK USR FUNCTION
; For TINY BASIC IL ASSEMBLER VERSION 0

TwoBytePeek:

   STX $C3          ;($C2=00)
   LDA ($C2),Y      ;GET MSB
   PHA              ;SAVE IT
   INY
   LDA ($C2),Y      ;GET LSB
   TAX
   PLA
   TAY              ;Y=MSB
   TXA
   RTS


;ClrScrCode:

;	.BYTE ESC,"[2J",0	;clear screen sequence (ANSI).
	
;ClearScreen:

;	lda #<ClrScrCode
;	sta StrPtr
;	lda #>ClrScrCode
;	sta StrPtr+1
;	jsr Puts
;	rts

CLRSC:   ldx #$19                   ; Load X - we're going tp print 25 lines
         lda #$0D                   ; CR
         jsr PutCh                  ; Send a carriage retuen
         lda #$0A                   ; LF
CSLP:    jsr PutCh                  ; Send the line feed
         dex                        ; One less to do
         bne CSLP                   ; Go send another untill we're done
         rts                        ; Return

;
; Print a message.
; This sub expects the messsage offset from MBLK in X.
;
SNDMSG:  lda MBLK,y                 ; Get a character from teh message block
         cmp #$FF                   ; Look for end of message marker
         beq EXSM                   ; Finish up if it is
         jsr PutCh                  ; Otherwise send the character
         iny                        ; Increment the pointer
         jmp SNDMSG                 ; Go get next character
EXSM:    rts                        ; Return

;
; Get a character from the character input device
; Runs into SNDCHR to provide echo
;
RCCHR:   lda $E001                  ; Check if a character typed (for emulator, non-blocking)
         beq RCCHR                  ; Loop until we get one (for emulator)
         cmp #'a'                   ; < 'a'?
         bcc SNDCHR                 ; yes, done
         cmp #'{'                   ; >= '{'?
         bcs SNDCHR                 ; yes, done         
         and #$5f                   ; convert to upper case
;
; Send a character to the character output device
;
SNDCHR:  sta $FE                    ; Save the character to be printed
         cmp #$FF                   ; Check for a bunch of characters
         beq EXSC                   ; that we don't want to print to
         cmp #$00	                  ; the terminal and discard them to
         beq EXSC	                  ; clean up the output
         cmp #$91	                  ;
         beq EXSC	                  ;
         cmp #$93	                  ;
         beq EXSC	                  ;
         cmp #$80	                  ;
         beq EXSC	                  ;
SCLP:    lda $FE                    ; Restore the character
         sta $E000                  ; Transmit it (for emulator)
EXSC:    rts                        ; Return

; Kernel jump table

;GetCh =  $FFED
;PutCh =  $FFF0
;Gets  =  $FFF3
;Puts  =  $FFF6

; String I/O not used at this time.

STRIN:   rts
STROUT:  rts

; Vector jumps handlers

NmiHandle: rti
RstHandle: jmp main
IrqHandle: rti

.segment "KERN"

   .ORG  $FFED

GetCh:   jmp RCCHR
PutCh:   jmp SNDCHR
Gets:    jmp STRIN
Puts:    jmp STROUT   

.segment "VECT"

   .ORG  $FFFA

.byte    <NmiHandle, >NmiHandle, <RstHandle, >RstHandle, <IrqHandle, >IrqHandle



;--------------------------- END ----------------------------------------------------------------------