Commit: b8e195c4ec493b879649ac61a6026c666d1fb784 - nsvtl (git)

Deriving a new dialect of Very Tiny Language from VTL-2 6800 version

Commit MetaInfo

• Revision: b8e195c4ec493b879649ac61a6026c666d1fb784 (tree)
• Time: 2022-09-25 22:00:21
• Author: Joel Matthew Rees <joel.rees@gmai...>
• Commiter: Joel Matthew Rees

Log Message

starting on better 6809/coco version

Change Summary

• modified: VTL_6809_coco.asm

Incremental Difference

--- a/VTL_6809_coco.asm
+++ b/VTL_6809_coco.asm
@@ -1,130 +1,111 @@
-*	VTL-2 for 6809	
-*	derived from VTL-2 for 6801
+	OPT 6809
+*	VTL-2 for 6809
+*	A transliteration of VTL-2 for 6801
 *	V-3.6
 *	9-23-76
 *	BY GARY SHANNON
 *	& FRANK MCCOY
 *	COPYWRIGHT 1976, THE COMPUTER STORE
 *
-*	Transliterations and modifications 
+*	Transliteration and modifications for Color Computer
+*	including original modifications for MC-10
 *	by Joel Matthew Rees
 *	Copyright 2022, Joel Matthew Rees
 *
 *	Modifications explained at 
-* (URL)
+* https://joels-programming-fun.blogspot.com/2022/09/vtl-2-part-5-transliterating-to-6809.html
+*
+*	Note that this is a travesty of a program, 
+*	since it is 6809 code, but does not make any use of the 6809's added resources.
+* 
 *
 *	DEFINE LOCATIONS IN MONITOR
-* 	These are defined for the Color Computer target at the end of the source.
 * INCH	EQU	$FF00	; per VTL.ASM
+* EINCH	EQU	$F012	; exorsim mdos Input byte with echo unless AECHO is set
+* INCH	EQU	$F015	; exorsim mdos Input char with echo (F012 -> strip bit 7)
 * POLCAT	EQU	$FF24	; from VTL.ASM
 * OUTCH	EQU	$FF81	; from VTL.ASM
+* EOUTCH	EQU	$F018	; exorsim mdos Output character with NULs
 * OUTS	EQU	$FF82	; from VTL.ASM
+* EPCRLF	EQU	$F021	; Primarily for forced initialization in exorsim.
 *
 *	FOR SBC6800:
 *BREAK	EQU	$1B	; BREAK KEY
-* 	For MC-10:
+* 	For MC-10 and Color Computer:
 BREAK	EQU	$03
-*
-*	In the 6809, there are several ways to approach the VTL trick of  
-*	aliasing the variable names to their ASCII codes as addresses
-*
-*	A way that would completely ignore the features (and benefits) of the 6809
-*	might be to just follow the original VTL-2 source in putting the variables all
-*	down at the bottom of the address space (and setting the DP register register to zero).
-*	This approach would conflict with some hardware and a lot of system software.
-*
-*	A similar method would be to use the DP as the base of the variable area.
-*	In some ways, this would allow a greater flexibility, although I understand 
-*	you would still find conflicts. It would also require a bit of glue code, 
-*	since Motorola did not mirror the direct page mode in the index modes.
-*	And there would be system conflicts in system/BIOS/monitors that 
-*	don't save and switch DP on interrupts.
-*
-*	A third way would be similar to what I did to move the variables 
-*	out of the direct page on the 6800 source -- 
-*	the variables would still be at absolute addresses, but by keeping those addresses
-*	free from entanglement with the code there would give greater host flexibility.
-*
-*	A fourth approach would be to use the Y or U register as the base of the variable space.
-*	The base itself could be kept in a direct page variable, allowing the index to be used
-*	for other things, as well. 
-*	(A similar approach could be taken with the 6801, with a lot of shuffling X. 
-*	Because the 6809 has several index regisers, shuffling is not so much of a problem here.)
-*
-*	If Motorola had only mirrored the DP mode in the index modes (like they mirrored the 
-*	extended mode to get absolute memory indirect), the DP would be the slam-dunk.
-*	(But Microsoft would have ignored the DP register anyway, making for conflicts with BASIC.)
-*
-*	I'm inclined to use the DP as the base, just to show how to do it.
-*	But I know there will be a lot of designs where that will cause problems,
-*	particularly the Tandy/RS Color Computer, the most available target I have at present.
-*
-*	So I'm going to go with using Y as the base, which means saving and restoring it
-*	when I use it for something else.
-*
-*	Some of the interpreter variables belong conceptually in the direct page, 
-*	but I'm going to essentially ignore the direct page in this transliteration,
-*	so I'll move the interpreter variables back to mixed in with the programmer variables.
-*
-* 	ORG	$C0	; Move this according to your environment's needs.
-* DPBASE	EQU	$C0	; Change this to move the registers.
+*	For exorsim
+*ACIACS	EQU	$FCF4	; exorcisor
+*ACIADA	EQU	$FCF5	; exorcisor
+*
+*	A few interpreter variables in the direct page won't hurt, said the spider to the fly.
+*	(See SNDDUR and PLYTMR in particular.)
+*	(Really need to move these. Use DP after all? IRQ, at least, uses extended mode addressing.)
+*	(Yes, I can hear voices of complaint that it's not as "tight" as it could be.)
+*	(This allows us to save more ROM space and uses DP that would otherwise go wasted.)
+*	(Trade-offs.)
+*	(It also helps us understand the code, so we can do a better 6809 transliteration.)
+*	(I hope the names are meaningful.)
+*
+*	In .c10 format, the following as ORG and RMBs caused object code output, 
+*	which will prevent the code from loading on the MC-10.
+*	Changed to EQU for the MC10 and left this way for the initial CoCo code.
+*
+*	Does not really make specific use of the DP register.
+* 	ORG	$C0	; Move this according to your environment's needs, but not on CoCo.
+* Change this to move the registers:
+DPBASE	EQU	$C4	; PIA mask at $C2? Avoid it, anyway.
 * PARSET	RMB	2	; Instead of SAVE0 in TERM/NXTRM
-* PARSET	EQU	DPBASE+2
+PARSET	EQU	DPBASE+2
 * CVTSUM	RMB	2	; Instead of SAVE1 in CBLOOP
-* CVTSUM	EQU	PARSET+2
+CVTSUM	EQU	PARSET+2
 * MLDVCT	EQU	CVTSUM	; Instead of SAVE1 in mul/div (1 byte only)
-* MLDVCT	EQU	CVTSUM
+MLDVCT	EQU	CVTSUM
 * DIVQUO	RMB	2	; Instead of SAVE2 in DIV
-* DIVQUO	EQU	MLDVCT+2
+DIVQUO	EQU	MLDVCT+2
 * MPLIER	EQU	DIVQUO	; Instead of SAVE2 in MULTIP
-* MPLIER	EQU	DIVQUO
+MPLIER	EQU	DIVQUO
 * EVALPT	RMB	2	; Instead of SAVE3
-* EVALPT	EQU	MPLIER+2
+EVALPT	EQU	MPLIER+2
 * CNVPTR	RMB	2	; Instead of SAVE4
-* CNVPTR	EQU	EVALPT+2
+CNVPTR	EQU	EVALPT+2
 * VARADR	RMB	2	; Instead of SAVE6
-* VARADR	EQU	CNVPTR+2
+VARADR	EQU	CNVPTR+2
 * OPRLIN	RMB	2	; Instead of SAVE7
-* OPRLIN	EQU	VARADR+2
+OPRLIN	EQU	VARADR+2
 * EDTLIN	RMB	2	; Instead of SAVE8
-* EDTLIN	EQU	OPRLIN+2
+EDTLIN	EQU	OPRLIN+2
 * INSPTR	RMB	2	; Instead of SAVE10 (maybe? Will some VTL programs want it back?)
-* INSPTR	EQU	EDTLIN+2
+INSPTR	EQU	EDTLIN+2
 * SAVLIN	RMB	2	; Instead of SAVE11
-* SAVLIN	EQU	INSPTR+2
-* SRC	RMB	2	; For copy routine, register in 6809
-* SRC	EQU	SAVLIN+2
+SAVLIN	EQU	INSPTR+2
+* SRC	RMB	2	; For copy routine
+SRC	EQU	SAVLIN+2
 * DST	RMB	2	; ditto
-* DST	EQU	SRC+2
-	SETDP	0
-* Just these DP variables:
-* STKMRK	EQU	DST+2
-USTKMK	EQU	$F8	; to restore the stack on each pass.
-SSTKMK	EQU	USTKMK+2
-ZEROMK	EQU	SSTKMK+2
-
-* DPALLOC	EQU	STKMRK+2	; total storage declared in the direct page
+DST	EQU	SRC+2
+STKMRK	EQU	DST+2	; to restore the stack on each pass.
+DPALLOC	EQU	STKMRK+2	; total storage declared in the direct page
 *
+*******!!!!!! CoCo: Check that we have avoided $00E2, as well, since it is used as PLYTMR by an interrupt routine.
+*             CoCo: Also, $008D is used as SNDDUR by BASIC.
 *
 *	SET ASIDE FOUR BYTES FOR USER
-*	DEFINED INTERUPT ROUTINE IF NEEDED (not needed, but ...)
-	ORG	$1600	; Dodge BASIC and video use RAM.
-* ZERO probably should be set at even $100 boundary for address math to work.
-ZERO	RMB	4	; INTERUPT VECTOR in original
+*	DEFINED INTERUPT ROUTINE IF NEEDED
+ZERO	EQU	$1600	; Dodge BASIC and video use RAM.
+	ORG	ZERO
+* ZERO probably no longer needs to be at even $100, but we'll put it there for good luck.
+	RMB	4	; INTERUPT VECTOR (probably not unnecessary? Implicit non-use in interpreter.)
 AT	RMB	2	; CANCEL & C-R
 *
 *	GENERAL PURPOSE STORRGE
 VARS	RMB	52	; VARIABLES(A-Z)
 BRAK	RMB	2	; [
-* SAVE10 has me worried about implicit linkage in VTL programs. Might need to just be here.
+* SAVE10 has me worried about implicit linkage in VTL programs. Might need to leave it here.
 SAVE10	RMB	2	; BACK SLASH
-INSPTR	EQU	SAVE10	; (Will some VTL programs want it here regardless?)
 BRIK	RMB	2	; ]
 UP	RMB	2	; ^
 SAVE11	RMB	2	; Need something in each SAVE to reserve space
-SAVLIN	EQU	SAVE11
-*			; To keep the address math straight. 
-*			; always leave the SAVEs declared as they are.
+*			; to keep the math straight. 
+*			; Leave the SAVEs declared as they are.
 *
 SAVE14	RMB	2	; SPACE (originally unused)
 EXCL	RMB	2	; !
@@ -143,26 +124,16 @@ MINS	RMB	2	; -
 PERD	RMB	2	; .
 SLASH	RMB	2	; /
 *
-SAVE0	RMB	2
-PARSET	EQU	SAVE0	; in TERM/NXTRM
-SAVE1	RMB	2
-CVTSUM	EQU	SAVE1	; in CBLOOP
-MLDVCT	EQU	CVTSUM	; in mul/div (1 byte only)
-SAVE2	RMB	2
-DIVQUO	EQU	SAVE2	; in DIV
-MPLIER	EQU	DIVQUO	; in MULTIP
-SAVE3	RMB	2
-EVALPT	EQU	SAVE3
-SAVE4	RMB	2
-CNVPTR	EQU	SAVE4
-SAVE5	RMB	2	; unused (stacked)
-SAVE6	RMB	2
-VARADR	EQU	SAVE6
-SAVE7	RMB	2
-OPRLIN	EQU	SAVE7
-SAVE8	RMB	2
-EDTLIN	EQU	SAVE8
-SAVE9	RMB	2	; unused (stacked)
+SAVE0	RMB	2	; unused
+SAVE1	RMB	2	; unused
+SAVE2	RMB	2	; unused
+SAVE3	RMB	2	; unused
+SAVE4	RMB	2	; unused
+SAVE5	RMB	2	; unused (PSH/PULX)
+SAVE6	RMB	2	; unused
+SAVE7	RMB	2	; unused
+SAVE8	RMB	2	; unused
+SAVE9	RMB	2	; unused (PSH/PULX)
 COLN	RMB	2	; :
 SEMI	RMB	2	; ;
 LESS	RMB	2	; <
@@ -177,67 +148,63 @@ LINLEN	EQU	72
 LINBUF	RMB	LINLEN+1
 BUFOFF	EQU	LINBUF-ZERO	; Unmagic 87. Some assemblers will cough at this.
 *
-	ORG	$16F0	; parameter/temp stack below here
-USTACK	RMB	1
+STACK	EQU	ZERO+$F0
+	ORG	STACK
+	RMB	1	; 6809 stack pointer points to last item pushed.
 *
-	ORG	$1700	; leave some buffer space
-MI	RMB	4	; INTERUPT VECTORS (not for 6809)
+VPRGM	EQU	STACK+$10	; buffer zone, really
+	ORG	VPRGM
+MI	RMB	4	; INTERUPT VECTORS ; again, probably not relevant here.
 NMI	RMB	4
-PRGM	EQU	*	; VTL PROGRAM STARTS HERE
+PRGM	EQU	*	; PROGRAM STARTS HERE
 * Must have some RAM here.
 *
-	ORG	$4000	; for 16K system
+CODESG	EQU	$3800	; 16K-2K for breathing room in 16K system (2K for now, adjust later.)
+	ORG	CODESG
 *
 * The COLD boot can be removed or ignored to restore the original behavior, 
 * but if you do that don't forget to set & (AMPR) and * (STAR) values
-* by hand immediately after STARTing,
-* and ' (QUITE) before trying to get a pseudo-random number.
+* by hand immediately after STARTing.
 *
 * Also, instead of PROBEing, if you know the limits for a particular ROM
-* application, you can set STAR directly, too:
+* application, you can set STAR directly:
 *	LDX	#PRGM
 *	STX	AMPR
 * 	LDX	#RAMLIM
 *	STX	STAR
 * START	...
 * 
-COLD	STS	SSTKMK	; Mark the stacks, 
-	STU	USTKMK	; but use BASIC's return stack.
-*	LDS	#SSTACK	; (S/U on 6809 point to most recently pushed.)
-	LDU	#USTACK
+COLD	STS	STKMRK	; Mark the stack, 
+*	LDS	#STACK	; Maybe use BASIC's stack. (S on 6809 points to last pushed.)
 *	JSR	TRMINI
-	LEAX	COLD,PCR
-	PSHU	X	; probe termination address
-	LDY	#ZERO
-	STY	ZEROMK
-	LDD	#PRGM-ZERO	; initialize program area base
-	STD	AMPR,Y
-	LEAX	D,Y
+	LDX	#PRGM	; initialize program area base
+	STX	AMPR
 	LDA	#$5A	; Probe RAM limit
 	LDB	#$A5
 	BRA	PROBET
-PROBE	STA	,X
-	CMPA	,X
+PROBE	STA	0,X
+	CMPA	0,X
 	BNE	NOTRAM
-	STB	,X
-	CMPB	,X+
-	BNE	NOTRAM
-PROBET	CMPX	,U	; all bits seem to be R/W.
+	STB	0,X
+	CMPB	0,X
+	BNE	NOTRAM		; all bits seem to be R/W.
+	LEAX	1,X
+PROBET	CMPX	#COLD
 	BLO	PROBE	; CMPX on 6809 works right.
 NOTRAM	LEAX	-1,X
 	STX	STAR
 START
-	LDS	SSTKMK	; re-initialize at beginning of each evaluate
-	LDU	USTKMK	; from mark instead of constant
+*	LDS	#STACK	; re-initialize at beginning of each evaluate
+	LDS	STKMRK	; from mark instead of constant
 	STS	SEMI	; DBG Comment this out when we no longer need to see the stack pointer BASIC gives us.
 	CLRA		; NUL delimiter
-	LEAX	OKM,PCR
-	BSR	STRGT
+	LDX	#OKM
+	LBSR	STRING
 *
 LOOP	CLRA
-	STAA	DOLR
-	STAA	DOLR+1
-	JSR	CVTLN
+	STA	DOLR
+	STA	DOLR+1
+	LBSR	CVTLN
 	BCC	STMNT	; NO LINE# THEN EXEC
 	BSR	EXEC
 	BEQ	START
@@ -247,17 +214,15 @@ EQSTRT	BEQ	START	; IF END THEN STOP
 	LDX	0,X	; LOAD REAL LINE #
 	STX	DOLR	; SAVE IT
 	LDX	SAVLIN	; GET LINE
-	INX		; BUMP PAST LINE #
-	INX		; BUMP PAST LINE #
-	INX		; BUMP PAST SPACE
+	LEAX	3,X	; BUMP PAST LINE # and SPACE
 	BSR	EXEC	; EXECUTE IT
 	BEQ	LOOP3	; IF ZERO, CONTINUE
-	LDX	SAVLIN	; FIND LINE
-	LDX	0,X	; GET IT
-	CPX	DOLR	; HAS IT CHANGED?
+	LDX	[SAVLIN]	; FIND LINE
+*	LDX	0,X	; GET IT
+	CMPX	DOLR	; HAS IT CHANGED?
 	BEQ	LOOP3	; IF NOT GET NEXT
 *
-	INX		; INCREMENT OLD LINE#
+	LEAX	1,X	; INCREMENT OLD LINE#
 	STX	EXCL	; SAVE FOR RETURN
 	BRA	LOOP2	; CONTINUE
 *
@@ -265,18 +230,18 @@ LOOP3	BSR	FND3	; FIND NEXT LINE
 	BRA	EQSTRT	; CONTINUE
 *
 EXEC	STX	OPRLIN	; EXECUTE LINE
-	JSR	VAR2
-	INX
+	LBSR	VAR2
+	LEAX	1,X
 *
-SKIP	LDAA	0,X	; GET FIRST TERM
+SKIP	LDA	0,X	; GET FIRST TERM
 	BSR	EVIL	; EVALUATE EXPRESSION
 OUTX	LDX	DOLR	; GET LINE #
 	RTS
 *
 EVIL	CMPA	#$22	; IF " THEN BRANCH
 	BNE	EVALU
-	INX
-STRGT	JMP	STRING	; TO PRINT IT
+	LEAX	1,X
+STRGT	LBRA	STRING	; TO PRINT IT
 *
 STMNT	STX	EDTLIN	; SAVE LINE #
 	STD	DOLR
@@ -284,63 +249,60 @@ STMNT	STX	EDTLIN	; SAVE LINE #
 	BNE	SKP2	; IF LINE# <> 0
 *
 	LDX	#PRGM	; LIST PROGRAM
-LST2	CPX	AMPR	; END OF PROGRAM
+LST2	CMPX	AMPR	; END OF PROGRAM
 	BEQ	EQSTRT
 	STX	SAVLIN	; LINE # FOR CVDEC
 	LDD	0,X
-	JSR	PRNT2
+	LBSR	PRNT2
 	LDX	SAVLIN
-	INX
-	INX
-	JSR	PNTMSG
-	JSR	CRLF
+	LEAX	2,X
+	LBSR	PNTMSG
+	LBSR	CRLF
 	BRA	LST2
 *
 NXTXT	LDX	SAVLIN	; GET POINTER
-	INX		; BUMP PAST LINE#
-LOOKAG	INX		; FIND END OF LINE
+	LEAX	1,X	; BUMP PAST LINE#
+LOOKAG	LEAX	1,X	; FIND END OF LINE
 	TST	0,X
 	BNE	LOOKAG
-	INX
+	LEAX	1,X
 	RTS
 *
 FIND	LDX	#PRGM	; FIND LINE
 FND2	STX	SAVLIN
-	CPX	AMPR
+	CMPX	AMPR
 	BEQ	RTS1
-*	LDAA	1,X	; almost missed this.
+*	LDA	1,X	; almost missed this.
 *	SUBA	DOLR+1	; This was necessary because no SUBD
-*	LDAA	0,X	; and CPX does not affect C flag on 6800
+*	LDA	0,X	; and CPX does not affect C flag on 6800
 *	SBCA	DOLR
-*	PSHB		; B does not seem to be in use.
+*	PSHS	B		; B does not seem to be in use.
 	LDD	0,X	; Use D because we think we want to keep X.
 	SUBD	DOLR
-*	PULB
+*	PULS	B
 	BCC	SET
 FND3	BSR	NXTXT
 	BRA	FND2
 *
-SET	LDAA	#$FF	; SET NOT EQUAL
-RTS1	RTS
+SET	LDA	#$FF	; SET NOT EQUAL
+RTS1
+	RTS
 *
-EVALU	JSR	EVAL	; EVALUATE LINE
-	PSHB
-	PSHA
+EVALU	LBSR	EVAL	; EVALUATE LINE
+	PSHS	A,B	; A is pushed after B
 	LDX	OPRLIN
-	JSR	CONVP
-	PULA
+	LBSR	CONVP
+	PULS	A
 	CMPB	#'$	; STRING?
 	BNE	AR1
-	PULB
-	JMP	OUTCH	; THEN PRINT IT
+	PULS	B
+	LBRA	OUTCH	; THEN PRINT IT
 AR1	SUBB	#'?	; PRINT?
-	BNE	AR11	; was out of range.
-	JMP	PRNT	; THEN DO IT
-*	BEQ	PRNT	; When we bring it back within range.
+	LBEQ	PRNT
 AR11	INCB		; MACHINE LANGUAGE?
-	PULB
+	PULS	B
 	BNE	AR2
-	SWI		; THEN INTERUPT
+	SWI		; THEN INTERUPT (Need to fix this for CoCo -- and for MC-10.)
 *
 AR2	STD	0,X	; STORE NEW VALUE
 	BNE	AR2RND	; Initialize/don't get stuck on zero.
@@ -351,31 +313,30 @@ AR2RND	ADDB	QUITE	; RANDOMIZER	; Adding the low byte to the high byte
 	STD	QUITE
 	RTS
 *
-SKP2	BSR	FIND	; FIND LINE
+SKP2
+	BSR	FIND	; FIND LINE
 	BEQ	INSRT	; IF NOT THERE
 	LDX	0,X	; THEN INSERT
-	CPX	DOLR	; NEW LINE
+	CMPX	DOLR	; NEW LINE
 	BNE	INSRT
 *
 	BSR	NXTXT	; SETUP REGISTERS
 *	LDS	SAVLIN	; FOR DELETE
-	STX	SRC
+	STX	SRC	; Patience! we can use Y here after we make sure this runs.
 	LDX	SAVLIN
 	STX	DST
 *
 DELT	LDX	SRC
-	CPX	AMPR	; DELETE OLD LINE
+	CMPX	AMPR	; DELETE OLD LINE
 	BEQ	FITIT
-	LDAA	0,X
-	INX
+	LDA	,X+
 	STX	SRC
 *	PSHA
 *	INX
 *	INS
 *	INS
 	LDX	DST
-	STA	0,X
-	INX
+	STA	,X+
 	STX	DST
 	BRA	DELT
 *
@@ -383,12 +344,13 @@ DELT	LDX	SRC
 FITIT	LDX	DST
 	STX	AMPR	; STORE NEW END
 *
-INSRT	LDX	EDTLIN	; COUNT NEW LINE LENGTH
-	LDAB	#$03
+INSRT
+	LDX	EDTLIN	; COUNT NEW LINE LENGTH
+	LDB	#$03
 	TST	0,X
 	BEQ	GOTIT	; IF NO LINE THEN STOP
 CNTLN	INCB		; count bytes
-	INX
+	LEAX	1,X
 	TST	0,X	; Find trailing NUL
 	BNE	CNTLN
 *
@@ -396,33 +358,32 @@ OPEN	CLRA		; CALCULATE NEW END
 	ADDD	AMPR
 	STD	INSPTR
 	SUBD	STAR
-	BCC	RSTRT	; IF TOO BIG THEN STOP
+	LBCC	START	; IF TOO BIG THEN STOP
 	LDX	AMPR
-*	LDS	INSPTR	; remember that the 6800/6801 stack is postdecrement push.
+*	LDS	INSPTR	; Remember that the 6800/6801 stack is postdecrement push.
 *	STS	AMPR
-	LDD	INSPTR	; remember that the 6800/6801 stack is postdecrement push.
+	LDD	INSPTR	; The 6809 stack is predecrement push, but that doesn't matter here.
 	STD	AMPR
-*
-*	LDS	AMPR
 	STD	DST
-	INX		; SLIDE OPEN GAP
-SLIDE	DEX		; going down
+	LEAX	1,X	; SLIDE OPEN GAP
+SLIDE	LEAX	-1,X	; going down
 	STX	SRC
-	LDAB	0,X
+	LDB	0,X
 *	PSHB		; stack blast it
 	LDX	DST
-	STAB	0,X	; mimic 6800 push
-	DEX
+	STB	0,X	; mimic 6800 push
+	LEAX	-1,X
 	STX	DST
 	LDX	SRC
-	CPX	SAVLIN
+	CMPX	SAVLIN
 	BHI	SLIDE
 *
 * DON	LDS	DOLR	; STORE LINE #
 *	STS	0,X
-DON	LDD	DOLR	; STORE LINE #
-	STD	0,X
-	STX	DST	; will skip by offset store
+DON
+	LDD	DOLR	; STORE LINE #
+	STD	0,X	; Note MSB1st byte order implicit dependency here.
+	STX	DST	; will skip by offset on store
 *	LDS	EDTLIN	; GET NEW LINE
 *	DES		; pre-increment
 	LDD	EDTLIN	; GET NEW LINE
@@ -432,107 +393,105 @@ DON	LDD	DOLR	; STORE LINE #
 *	PULB
 *	STAB	1,X	; (skips over low byte, BTW)
 MOVL	LDX	SRC
-	LDAB	0,X
-	INX
+	LDB	,X+
 	STX	SRC
 	LDX	DST
-	INX		; skip over what was already stored (too tricky for words).
+	LEAX	1,X		; skip over what was already stored (too tricky for words).
 	STX	DST
-	STAB	1,X	; note offset store
+	STB	1,X	; note offset store
 	BNE	MOVL	; until NUL stored
 *
 GOTIT
 *	LDS	#STACK	; Ready for a new line of input.
-	LDS	USTKMK	; restore from mark
-	JMP	LOOP
+	LDS	STKMRK	; restore from mark
+	LBRA	LOOP
 *
-RSTRT	JMP	START	; warm start over
+* RSTRT	LBRA	START	; warm start over
 *
-PRNT	PULB		; PRINT DECIMAL
+PRNT	PULS	B	; PRINT DECIMAL
 PRNT2	LDX	#DECBUF	; CONVERT TO DECIMAL
 	STX	CNVPTR
 	LDX	#PWRS10
-CVD1	PSHX
+CVD1	PSHS	X
 	LDX	0,X
 	STX	VARADR
 	LDX	#VARADR
-	JSR	DIVIDE
-	PSHA
+	LBSR	DIVIDE
+	PSHS	A
 	LDX	CNVPTR
-	LDAA	DIVQUO+1
+	LDA	DIVQUO+1
 	ADDA	#'0
-	STAA	0,X
-	PULA
-	INX
+	STA	0,X
+	PULS	A
+	LEAX	1,X
 	STX	CNVPTR
-	PULX
-	INX
-	INX
+	PULS	X
+	LEAX	2,X
 	TST	1,X
 	BNE	CVD1
 *
 	LDX	#DECB_1
 	COM	5,X	; ZERO SUPPRESS
-ZRSUP	INX
-	LDAB	0,X
+ZRSUP	LEAX	1,X
+	LDB	0,X
 	CMPB	#'0
 	BEQ	ZRSUP
 	COM	LASTD
 *
 PNTMSG	CLRA		; ZERO FOR DELIM
-STRTMS	STAA	DELIM	; STORE DELIMTER
+STRTMS	STA	DELIM	; STORE DELIMTER
 *
-OUTMSG	LDAB	0,X	; GENERAL PURPOSE PRINT
-	INX
+OUTMSG	LDB	,X+	; GENERAL PURPOSE PRINT
 	CMPB	DELIM
 	BEQ	CTLC
-	JSR	OUTCH
+	LBSR	OUTCH
 	BRA	OUTMSG
 *
-CTLC	JSR	POLCAT	; POL FOR CHARACTER
-	BCC	RTS2
-	BSR	INCH2
+CTLC
+	LBSR	POLCAT	; POL FOR CHARACTER
+	BCC	RTS2	; return wherever we came from
+	LBSR	INCH
 	CMPB	#BREAK	; BREAK KEY?
-	BEQ	RSTRT
+	LBEQ	START
 *
-INCH2	JMP	INCH
+INCH2	LBRA	INCH
 *
 STRING	BSR	STRTMS	; PRINT STRING LITERAL
-	LDAA	0,X
+	LDA	0,X
 	CMPA	#';
 	BEQ	OUTD
-	JMP	CRLF
+	LBRA	CRLF
 *
 EVAL	BSR	GETVAL	; EVALUATE EXPRESSION
 *
-NXTRM	PSHA
-	LDAA	0,X	; END OF LINE?
+NXTRM	PSHS	A
+	LDA	0,X	; END OF LINE?
 	BEQ	OUTN
 	CMPA	#')
-OUTN	PULA
+OUTN	PULS	A
 	BEQ	OUTD
 	BSR	TERM
 	LDX	PARSET
 	BRA	NXTRM
 *
-TERM	PSHA		; GET VALUE
-	PSHB
-	LDAA	0,X
-	PSHA
-	INX
+TERM	PSHS	A		; GET VALUE
+	PSHS	B
+	LDA	0,X
+	PSHS	A
+	LEAX	1,X
 	BSR	GETVAL
 	STD	EVALPT
 	STX	PARSET
 	LDX	#EVALPT
-	PULA
-	PULB
+	PULS	A
+	PULS	B
 *
 	CMPA	#'*	; SEE IF *
 	BNE	EVAL2
-	PULA		; MULTIPLY
+	PULS	A	; MULTIPLY
 MULTIP	STD	MPLIER	; 2'S COMPLEMENT
-	LDAB	#$10
-	STAB	MLDVCT
+	LDB	#$10
+	STB	MLDVCT
 	CLRA
 	CLRB
 *
@@ -546,27 +505,27 @@ NOAD	ASL	1,X
 	BNE	MULT	; LOOP TIL DONE
 RTS2	RTS
 *
-GETVAL	JSR	CVBIN	; GET VALUE
+GETVAL	LBSR	CVBIN	; GET VALUE
 	BCC	OUTV
 	CMPB	#'?	; OF LITERAL
 	BNE	VAR
-	PSHX		; OR INPUT
-	JSR	INLN
+	PSHS	X	; OR INPUT
+	LBSR	INLN
 	BSR	EVAL
-	PULX
-OUTD	INX
+	PULS	X
+OUTD	LEAX	1,X
 OUTV	RTS
 *
 VAR	CMPB	#'$	; OR STRING
 	BNE	VAR1
-	BSR	INCH2
+	LBSR	INCH
 	CLRA
-	INX
+	LEAX	1,X
 	RTS
 *
 VAR1	CMPB	#'(
 	BNE	VAR2
-	INX
+	LEAX	1,X
 	BRA	EVAL
 *
 VAR2	BSR	CONVP	; OR VARIABLE
@@ -574,14 +533,14 @@ VAR2	BSR	CONVP	; OR VARIABLE
 	LDX	VARADR	; LOAD OLD INDEX
 	RTS
 *
-ARRAY	JSR	EVAL	; LOCATE ARRAY ELEMENT
-	ASLD
+ARRAY	LBSR	EVAL	; LOCATE ARRAY ELEMENT
+	ASLB
+	ROLA
 	ADDD	AMPR
 	BRA	PACK
 *
-CONVP	LDAB	0,X	; GET LOCATION
-	INX
-	PSHB
+CONVP	LDB	,X+	; GET LOCATION
+	PSHS	B
 	CMPB	#':
 	BEQ	ARRAY	; OF VARIABLE OR
 	CLRA		; ARRAY ELEMENT
@@ -593,24 +552,24 @@ CONVP	LDAB	0,X	; GET LOCATION
 PACK	STX	VARADR	; STORE OLD INDEX
 	STD	CNVPTR
 	LDX	CNVPTR	; LOAD NEW INDEX
-	PULB
+	PULS	B
 	RTS
 *
 EVAL2	CMPA	#'+	; ADDITION
 	BNE	EVAL3
-	PULA
+	PULS	A
 ADD	ADDD	0,X
 	RTS
 *
 EVAL3	CMPA	#'-	; SUBTRACTION
 	BNE	EVAL4
-	PULA
+	PULS	A
 SUBTR	SUBD	0,X
 	RTS
 *
 EVAL4	CMPA	#'/	; SEE IF IT'S DIVIDE
 	BNE	EVAL5
-	PULA
+	PULS	A
 	BSR	DIVIDE
 	STD	REMN
 	LDD	DIVQUO
@@ -618,19 +577,19 @@ EVAL4	CMPA	#'/	; SEE IF IT'S DIVIDE
 *
 EVAL5	SUBA	#'=	; SEE IF EQUAL TEST
 	BNE	EVAL6
-	PULA
-	BSR	SUBTR
+	PULS	A
+	SUBD	0,X	; missed this in the 6801 code!
 	BNE	NOTEQ
 	TSTB
 	BEQ	EQL
-NOTEQ	LDAB	#$FF
+NOTEQ	LDB	#$FF
 EQL	BRA	COMBOUT
 *
 EVAL6	DECA		; SEE IF LESS THAN TEST
-	PULA
+	PULS	A
 	BEQ	EVAL7
 *
-SUB2	BSR	SUBTR
+SUB2	SUBD	0,X
 	ROLB
 COMOUT	CLRA
 	ANDB	#$01
@@ -660,14 +619,15 @@ GOT	INC	MLDVCT
 	ROR	1,X
 	CLR	DIVQUO
 	CLR	DIVQUO+1
-DIV2	BSR	SUBTR
+DIV2	SUBD	0,X
 	BCC	OK
 	ADDD	0,X
-	CLC
+	ANDCC	#$FE
 	BRA	DIVNOC	; instead of the trick
-* The 6801 CPX affects all relevant flags, can't use this trick.
-*	FCB	$9C	; CPX
-OK	SEC		; $0D
+* The 6809 CMPX affects all relevant flags, can't use this trick.
+* And the op-codes are different in the 6809, too.
+*	FCB	$9C	; CMPX
+OK	ORCC	#$01
 DIVNOC	ROL	DIVQUO+1
 	ROL	DIVQUO
 	DEC	MLDVCT
@@ -676,14 +636,14 @@ DIVNOC	ROL	DIVQUO+1
 	ROR	1,X
 	BRA	DIV2
 *
-TSTN	LDAB	0,X	; TEST FOR NUMERIC
+TSTN	LDB	0,X	; TEST FOR NUMERIC
 	CMPB	#$3A
 	BPL	NOTDEC
 	CMPB	#'0
 	BGE	DONE
-NOTDEC	SEC
+NOTDEC	ORCC	#$01
 	RTS
-DONE	CLC
+DONE	ANDCC	#$FE
 DUN	RTS
 *
 CVTLN	BSR	INLN
@@ -697,30 +657,33 @@ CBLOOP	ADDB	0,X
 	SUBB	#'0
 	SBCA	#$00
 	STD	CVTSUM
-	INX
-	PSHB
+	LEAX	1,X
+	PSHS	B
 	BSR	TSTN
-	PULB
+	PULS	B
 	BCS	DONE
-	ASLD
-	ASLD
+	ASLB
+	ROLA
+	ASLB
+	ROLA
 	ADDD	CVTSUM
-	ASLD
+	ASLB
+	ROLA
 	BRA	CBLOOP
 *
 INLN6	CMPB	#'@	; CANCEL
 	BEQ	NEWLIN
-	INX		; '.'
-	CPX	#ZERO+LINLEN+2	; (Here's part of what we had to fix for moving the variables.)
+	LEAX	1,X		; '.'
+	CMPX	#ZERO+LINLEN+2	; (Here's part of what we had to fix for moving the variables.)
 	BNE	INLN2
 NEWLIN	BSR	CRLF
 *
 INLN	LDX	#ZERO+2	; INPUT LINE FROM TERMINAL
-INLN5	DEX
-	CPX	#ZERO	; Make this explicit to enable variables moved out of DP.
+INLN5	LEAX	-1,X
+	CMPX	#ZERO	; Make this explicit to enable variables moved out of DP.
 	BEQ	NEWLIN	; (Was implicit zero compare X from DEX, now explicit.)
-INLN2	JSR	INCH	; INPUT CHARACTER
-	STAB	BUFOFF-1,X	; STORE IT
+INLN2	LBSR	INCH	; INPUT CHARACTER
+	STB	BUFOFF-1,X	; STORE IT
 	CMPB	#$5F	; BACKSPACE?
 	BEQ	INLN5
 *
@@ -733,9 +696,9 @@ INLIN4	CLR	BUFOFF-1,X	; CLEAR LAST CHAR
 	BRA	LF
 *
 * CRLF	JSR	EPCRLF
-CRLF	LDAB	#$0D	; CARR-RET
+CRLF	LDB	#$0D	; CARR-RET
 	BSR	OUTCH2
-LF	LDAB	#$0A	; LINE FEED
+LF	LDB	#$0A	; LINE FEED
 OUTCH2	BRA	OUTCH
 *
 OKM	FCB	$0D
@@ -749,21 +712,18 @@ OKM	FCB	$0D
 *	BNE TRMILP
 *	RTS
 *
-* MC-10 BASIC ROM vectors
-INCHV	EQU	$FFDC	; Scan keyboard	
-OUTCHV	EQU	$FFDE	; Write char to screen
+* Color Computer BASIC ROM vectors
+INCHV	EQU	$A000	; Scan keyboard	
+OUTCHV	EQU	$A002	; Write char to screen
 *
 *	RECEIVER POLLING
-POLCAT	PSHA
-	PSHX
-	LDX	INCHV	; at any rate, don't wait.
-	JSR	0,X	; 
-	TAB		; MC-10 ROM says NUL is not input.
-	SEC
+POLCAT	PSHS	A
+	JSR	[INCHV]	; at any rate, don't wait. 
+	TFR	A,B	; because the source I'm working with expects it in B 
+	ORCC	#$01
 	BNE	POLCATR	; Don't wait.
-	CLC
-POLCATR	PULX
-	PULA
+	ANDCC	#$FE
+POLCATR	PULS	A
 	RTS
 *POLCAT	LDAB	ACIACS
 *	ASRB
@@ -772,17 +732,14 @@ POLCATR	PULX
 *	INPUT ONE CHAR INTO B ACCUMULATOR
 INCH	BSR	POLCAT
 	BCC	INCH	; Wait here.
-	BSR	OUTCH
+	BSR	OUTCH	; echo
 	RTS
 *
 *	OUTPUT ONE CHAR 
-OUTCH	PSHA
-	PSHX
-	LDX	OUTCHV
-	TBA
-	JSR	0,X
-	PULX
-	PULA
+OUTCH	PSHS	B,A
+	TFR	B,A
+	JSR	[OUTCHV]
+	PULS	A,B
 	RTS
 *
 	ORG COLD