NEW
PREFIX /A2OSX.BUILD
AUTO 4,1
*---------------------------------------
SRC.ParseLine		jsr OUT.Reset
					
					jsr SRC.GetChar
					bcs .8
					
					cmp #'*'			Comment?
					beq .8
					cmp #';'			Comment?
					beq .8
					
					>LDA.G ASM.DO.StackPtr
					beq .1
					
					clc
					adc #ASM.DO.Stack-1
					tay
					lda (pData),y
					beq .8
					
.1					>LDA.G MAC.bAdd
					bmi SRC.ParseLine.MACRO

					jmp SRC.ParseLine.LABEL
					
.8					clc
					rts
					
SRC.ParseLine.Macro lda (ZPLinePtr)
					cmp #' '			No label, scan to DIR/OP if any
					bne .1
					
					jsr SRC.GetNextCharNB
					bcs .8
					
					lda #' '			Store ONE blank
					jsr MAC.AddChar
					bcs .90
					
					lda (ZPLinePtr)		get back non blank char
					bra .2
					
.1					jsr MAC.AddChar
					bcs .99
								
					jsr SRC.GetNextChar
					bcs .80
					cmp #' '
					bne .1
					
					jsr MAC.AddChar
.90					bcs .99
					
					jsr SRC.GetNextCharNB
					bcs .80
					
.2					cmp #'.'			Directive ?
					bne .4

					ldy #1
					lda (ZPLinePtr),y
					beq .3
					cmp #'E'
					beq .21
					cmp #'e'
					bne .3
					
.21					iny
					lda (ZPLinePtr),y
					beq .3
					cmp #'M'
					beq .22
					cmp #'m'
					bne .3
					
.22					jsr MAC.Store
					bcs SRC.ParseLine.RTS
					
					>STZ.G MAC.bAdd
					
.8					clc
					rts

.80					lda #0
					jmp MAC.AddChar
					
.3					lda (ZPLinePtr)
					
.4					jsr MAC.AddChar
					bcs .99
								
					jsr SRC.GetNextChar
					bcs .80
					cmp #' '
					bne .4
					
					jsr SRC.GetNextChar
					bcs .8
					cmp #' '
					beq .80				Comments...
					
					pha
					
					lda #' '
					jsr MAC.AddChar
					
					pla
					bcs .99
					
.5					jsr MAC.AddChar		Store ARG....
					bcs .99
								
					jsr SRC.GetNextChar
					bcs .80
					cmp #' '
					bne .5

					lda #0
					jmp MAC.AddChar		End of Line
					clc
					rts
					
.99					lda #ERR.MACRO.TOO.BIG					
					sec
					
SRC.ParseLine.RTS	rts
*---------------------------------------
SRC.ParseLine.LABEL	jsr SRC.GetChar
					cmp #' '			no label...go scan dir/opcode
					beq SRC.ParseLine.DirOp
					
					cmp #'.'			local symbol?
					bne	.1

					lda (ZPGlobalBuf)
					beq SRC.ParseLine.InvLbl
					
					jsr SRC.GetNextChar
					bcs SRC.ParseLine.InvLbl
					jsr SRC.GetDecimal
					bcs SRC.ParseLine.InvLbl
					
					lda SRC.ACC+1
					ora SRC.ACC+2
					ora SRC.ACC+3
					bne SRC.ParseLine.InvLbl	Max .255
					lda SRC.ACC
					beq SRC.ParseLine.InvLbl	.0 is not allowed

					jsr SYM.AddLocal
					bcs SRC.ParseLine.RTS
					bra SRC.ParseLine.DirOp

.1					jsr SYMG.FlushGlobal
					bcs SRC.ParseLine.Err
					
					>LDA.G ASM.PASS
					bne .2

					jsr SYM.LookupGlobal	already defined...get it
					bcc SRC.ParseLine.Redef
					
					jsr SYM.NewGlobal		Pass #1; try to add global...				
					bra SRC.ParseLine.DirOp
					
.2					jsr SYM.GetGlobal		Pass #2: should be already defined...
					bcs SRC.ParseLine.Undef	
*---------------------------------------				
SRC.ParseLine.DirOp	jsr SRC.GetNextCharNB	Scan for an Opcode...
					bcs SRC.ParseLine.Ok
					
					cmp #'.'
					bne .5
					
					jsr SRC.GetNextChar
					bcs SRC.ParseLine.InvDir
					
					jsr SRC.ParseLine.Dir
					bcs SRC.ParseLine.Err
					bra SRC.ParseLine.Ok

.5					cmp #'>'
					bne .6
					
					jsr SRC.ParseLine.ExecMacro
					bcs SRC.ParseLine.Err
					bra SRC.ParseLine.Ok
					
.6					jsr SRC.ParseLine.OpCode
					bcs SRC.ParseLine.Err

SRC.ParseLine.Ok	clc
SRC.ParseLine.Err	rts

SRC.ParseLine.InvLbl
					lda #ERR.INV.LABEL
					sec
					rts
					
SRC.ParseLine.Redef lda #ERR.SYMBOL.REDEF
					sec
					rts
					
SRC.ParseLine.Undef	lda #ERR.UNDEF.SYMBOL
					sec
					rts
SRC.ParseLine.InvDir
					lda #ERR.INV.DIR
					sec
					rts
*---------------------------------------
SRC.ParseLine.Dir	>LDYA L.T.DIRECTIVES
					jsr SRC.GetKeyword

					bcs SRC.ParseLine.InvDir
					
					jmp (J.DIRECTIVES,x)
*---------------------------------------
SRC.ParseLine.ExecMacro
					
					
					clc
					rts
*---------------------------------------
SRC.ParseLine.OpCode
					stz SRC.AM.StrBuf
					
					>LDYA ZPOpsPtr
					>STYA ZPOpDefPtr
					
.1					lda (ZPOpDefPtr)	End Of OpCode List
					ldy #1
					ora (ZPOpDefPtr),y
					beq .9
					
					lda ZPOpDefPtr
					clc
					adc #2
					sta ZPPtr2
					lda ZPOpDefPtr+1
					adc #0
					sta ZPPtr2+1
					
					lda (ZPPtr2)
					tax
					
					ldy #0
					
.2					lda (ZPLinePtr),y
					beq .7
					
					cmp #'a'
					bcc .3
					cmp #'z'+1
					bcs .3
					
					eor #$20
					
.3					iny
					cmp (ZPPtr2),y
					bne .7
					
					dex
					bne .2
					
					lda (ZPLinePtr),y
					beq .8				End of Line, no AM
					
					cmp #' '			A space after opcode ?
					bne .7
					
					tya
					sec					skip OP + ' '
					adc ZPLinePtr
					sta ZPLinePtr
					bcc .5
					
					inc ZPLinePtr+1
					
.5					bra SRC.ParseLine.AM
					
.7					lda ZPOpDefPtr
					clc
					adc (ZPOpDefPtr)
					tax
					
					lda ZPOpDefPtr+1
					ldy #1
					adc (ZPOpDefPtr),y
					stx ZPOpDefPtr
					sta ZPOpDefPtr+1
					bra .1
					
.8					jmp SRC.ParseLine.OPAMCheckFF					
					
.9					lda #ERR.INV.OPCODE
					sec
.99					rts
*---------------------------------------
SRC.ParseLine.AM	
.1					jsr SRC.GetChar
					bcs SRC.ParseLine.AMCheck
					
.10					cmp #' '			another space ?
					beq SRC.ParseLine.AMCheck	ignore end of line (comment)
					
					jsr SRC.IsAMReserved
					bcs .2
					
					inc SRC.AM.StrBuf
					ldx SRC.AM.StrBuf
					sta SRC.AM.StrBuf,x
					bra .7
					
.2					jsr SRC.IsLetter	Any register?
					bcs .6				no, try something else
					
					>LDYA ZPRPtr		Check in register table
					jsr SRC.GetKeyword
					bcs .6
					
					lda (ZPPtr1)		get register len
					tax
					
					ldy SRC.AM.StrBuf
					
.4					inc ZPPtr1
					bne .5
					inc ZPPtr1+1
					
.5					lda (ZPPtr1)
					iny
					sta SRC.AM.StrBuf,y
					dex
					bne .4
					
					sty SRC.AM.StrBuf
					
					bra .1
					
.6					jsr EXP.Eval
					bcs .99
					
					>LDA.G EXP.Prefix		
					beq .74
					inc SRC.AM.StrBuf
					ldx SRC.AM.StrBuf
					sta SRC.AM.StrBuf,x

.74					ldx SRC.ACC.SIZE
					beq .75				Pending...assume 2 bytes...
					
.73					lda SRC.ACC-1,x					
					bne .72
					dex
					bne .73
					
					inx
					bra .72
					
.75					ldx #2
					
.72					lda #'a'
					
					ldy SRC.AM.StrBuf
					
.71					iny
					sta SRC.AM.StrBuf,y
					dex
					bne .71

					sty SRC.AM.StrBuf
					bra .1
					
.7					jsr SRC.GetNextChar
					bcc .10

					jmp SRC.ParseLine.AMCheck
					
.9					lda #ERR.INV.AM.SYN
					sec
.99					rts
*---------------------------------------
SRC.ParseLine.AMCheck
*					jsr OUT.PrintLine.1
*					>PUSHW L.SRC.AM.StrBuf
*					>LDYA L.MSG.PSTRCRLF
*					>SYSCALL PrintF.YA
					
					lda SRC.AM.StrBuf
					beq SRC.ParseLine.OPAMCheckFF
					
					>LDYA ZPAMPtr
					>STYA ZPPtr1
					
					ldx #0
					
.1					inx

					lda (ZPPtr1)
					beq .9
					
					cmp SRC.AM.StrBuf 
					bne .7
					
					tay
					
.2					lda (ZPPtr1),y				
					cmp SRC.AM.StrBuf,y
					bne .6
					dey
					bne .2
					
					txa
					>STA.G SRC.AMID
					bra SRC.ParseLine.OPAMCheck
					
.6					lda (ZPPtr1)
.7					sec
					adc ZPPtr1
					sta ZPPtr1
					bcc .1
					inc ZPPtr1+1
					bra .1
					
.9					lda #ERR.INV.AM
					sec
					rts
*---------------------------------------
SRC.ParseLine.OPAMCheckFF
					lda #$ff			Default to no AM
					>STA.G SRC.AMID

SRC.ParseLine.OPAMCheck
					ldy #2				Skip nPtr+Len+OP
					lda (ZPOpDefPtr),y	LEN
					sec					LEN Byte
					adc #2				nPtr
					adc ZPOpDefPtr
					sta ZPOpDefPtr
					bcc .10
					inc ZPOpDefPtr+1
					
.10					lda (ZPOpDefPtr)

.1					>CMP.G SRC.AMID
					beq .3
					
					ldy #1
					lda (ZPOpDefPtr),y
					inc
					sec
					adc ZPOpDefPtr
					sta ZPOpDefPtr
					bcc .2
					inc ZPOpDefPtr+1
.2					lda (ZPOpDefPtr)
					bne .1
					
.99					lda #ERR.INV.AM.4.OC
					sec
					rts
					
.3					stz SRC.ACCTMP			index in ACC

					ldy #1
					lda (ZPOpDefPtr),y
					sta SRC.ACCTMP+1		Char Count in AM
					iny
					
.4					lda (ZPOpDefPtr),y
					cmp #'a
					bcs .5
					jsr SRC.IsDigit16
					asl
					asl
					asl
					asl
					sta SRC.ACCTMP+2
					iny
					dec SRC.ACCTMP+1
					lda (ZPOpDefPtr),y
					jsr SRC.IsDigit16
					ora SRC.ACCTMP+2

.50					jsr OUT.EmitByte

					bcs .9
					iny
					dec SRC.ACCTMP+1
					bne .4
					clc
					rts
					
.5					bne .6
					
					ldx SRC.ACCTMP
					inc SRC.ACCTMP
					lda SRC.ACC,x
					bra .50

.6					cmp #'r
					bne .99

					ldx SRC.ACCTMP
					inc SRC.ACCTMP
					lda ASM.PC,x
					sec
					sbc SRC.ACC,x
					pha
					
					
					
					pla
					bra .50

.8					clc
.9					rts
*---------------------------------------
SRC.GetDecimal		jsr SRC.GetChar
					beq .99
					
					stz SRC.ACC+1
					stz SRC.ACC+2
					stz SRC.ACC+3
					
					jsr SRC.IsDigit10
					bcs .99
					
					and #$0F
					sta SRC.ACC
					
.1					jsr SRC.GetNextChar
					bcs .8
					
					cmp #' '
					beq .8
					
					jsr SRC.IsEXPReserved
					bcc .8
					
					jsr SRC.IsAMReserved
					bcc .8
					
					jsr SRC.IsDigit10
					bcs .9
					
					and #$0F
					
					pha
					jsr SRC.ACC10
					pla
					bcs .9

					adc SRC.ACC
					sta SRC.ACC
					bcc .1
					
					inc SRC.ACC+1
					bne .1
					inc SRC.ACC+2
					bne .1
					inc SRC.ACC+3
					bne .1
					
.9					lda #ERR.VAL.TOO.BIG
					sec
					rts

.8					clc
					rts
					
.99					lda #ERR.SYNTAX.ERROR
					sec
					rts
*---------------------------------------
SRC.GetHex			jsr SRC.GetNextChar	skip '$'
					bcs .99
					
					stz SRC.ACC+1
					stz SRC.ACC+2
					stz SRC.ACC+3
					
					jsr SRC.IsDigit16
					bcs .99

					sta SRC.ACC
					
.1					jsr SRC.GetNextChar
					bcs .8
					
					cmp #' '
					beq .8
					jsr SRC.IsEXPReserved
					bcc .8
					jsr SRC.IsAMReserved
					bcc .8
					jsr SRC.IsDigit16
					bcs .99
					
					ldx #4
.2					asl SRC.ACC
					rol SRC.ACC+1
					rol SRC.ACC+2
					rol SRC.ACC+3
					bcs .9
					dex
					bne .2
					ora SRC.ACC
					sta SRC.ACC
					bra .1
					
.8					clc
					rts
					
.9					lda #ERR.VAL.TOO.BIG
					sec
					rts
					
.99					lda #ERR.SYNTAX.ERROR
					sec
					rts
*---------------------------------------
SRC.GetOctal		jsr SRC.GetNextChar	skip '&'
					bcs .99
					
					stz SRC.ACC+1
					stz SRC.ACC+2
					stz SRC.ACC+3
					
					jsr SRC.IsDigit8
					bcs .99
					
					and #$0F
					sta SRC.ACC
					
.1					jsr SRC.GetNextChar
					bcs .8
					
					cmp #' '
					beq .8
					
					jsr SRC.IsEXPReserved
					bcc .8
					
					jsr SRC.IsAMReserved
					bcc .8
					
					jsr SRC.IsDigit8
					bcs .9
					
					asl
					asl
					asl
					asl
					asl
					
					ldx #3
.2					asl
					rol SRC.ACC
					rol SRC.ACC+1
					rol SRC.ACC+2
					rol SRC.ACC+3
					bcs .9
					dex
					bne .2
					bra .1
					
.8					clc
					rts
					
.9					lda #ERR.VAL.TOO.BIG
					sec
					rts
					
.99					lda #ERR.SYNTAX.ERROR
					sec
					rts
*---------------------------------------
SRC.GetBinary		jsr SRC.GetNextChar	skip '%'
					bcs .99
					
					stz SRC.ACC+1
					stz SRC.ACC+2
					stz SRC.ACC+3
					
					cmp #'1'
					beq .10
					
					cmp #'0'
					bne .99
					
.10					and #$01
					sta SRC.ACC
					
.1					jsr SRC.GetNextChar
					bcs .8
					
					cmp #' '
					beq .8
					
					jsr SRC.IsEXPReserved
					bcc .8
					
					jsr SRC.IsAMReserved
					bcc .8
					
					cmp #'1'
					beq .11
					
					cmp #'0'
					bne .8
					
.11					lsr
					
					rol SRC.ACC
					rol SRC.ACC+1
					rol SRC.ACC+2
					rol SRC.ACC+3
					bcs .9
					bra .1
					
.8					clc
					rts
					
.9					lda #ERR.VAL.TOO.BIG
					sec
					rts
					
.99					lda #ERR.SYNTAX.ERROR
					sec
					rts
*---------------------------------------
SRC.GetKeyword		>STYA ZPPtr1		KeyWord table

					ldx #0				Keyword.ID

.1					phx
					
					lda (ZPPtr1)
					beq .9				End Of table
					
					tax					KW len
					
					ldy #0

.3					lda (ZPLinePtr),y
					beq .6
					
					jsr SRC.IsKeywordLetterUC
					bcs .6
					
					iny
					cmp (ZPPtr1),y
					bne .6
					
					dex
					bne .3
					
					lda (ZPLinePtr),y	All chars match...
					beq .4				End of Line ?
					
					jsr SRC.IsKeywordLetterUC
					bcc .6				Additional letters...
					
.4					lda ZPLinePtr
					clc
					adc (ZPPtr1)
					sta ZPLinePtr
					bcc .5
					inc ZPLinePtr+1
					
.5					plx					Keyword.ID
					clc
					rts

.6					lda (ZPPtr1)
					sec					Add keyword Len+1
					adc ZPPtr1
					sta ZPPtr1
					bcc .7
					
					inc ZPPtr1+1
					
.7					plx					Keyword.ID
					inx
					inx
					bra .1
					
.9					plx
					sec
					rts
*---------------------------------------
SRC.IsAMReserved	ldx SRC.AM.RESERVED
.1					cmp SRC.AM.RESERVED,x
					beq .8
					dex
					bne .1
					sec
					rts
.8					clc
					rts					
*---------------------------------------
SRC.IsMODReserved	ldx SRC.MOD.RESERVED
.1					cmp SRC.MOD.RESERVED,x
					beq .8
					dex
					bne .1
					sec
					rts
					
.8					clc
					rts					
*---------------------------------------
SRC.IsEXPReserved	ldx SRC.EXP.RESERVED
.1					cmp SRC.EXP.RESERVED,x
					beq SRC.IsEXPReserved.8
					dex
					bne .1
					sec
					rts
					
SRC.IsEXPReserved.8	clc
					rts					
*---------------------------------------
SRC.IsKeywordLetterUC
					cmp #'.'
					beq SRC.IsEXPReserved.8

					cmp #'_'
					beq SRC.IsEXPReserved.8

					cmp #'A'
					bcc .9
					cmp #'Z'+1
					bcc .99

					cmp #'a'
					bcc .9
					cmp #'z'+1
					
					eor #$20
					
					rts					CC if lowercase
					
.9					sec					
.99					rts	
*---------------------------------------
SRC.IsLetterOrDigit jsr SRC.IsDigit10
					bcc SRC.IsLetterRTS
*---------------------------------------
SRC.IsLetter		cmp #'A'
					bcc .9
					cmp #'Z'+1
					bcc SRC.IsLetterRTS

					cmp #'a'
					bcc .9
					cmp #'z'+1
					rts					CC if lowercase
					
.9					sec					
SRC.IsLetterRTS		rts					
*---------------------------------------
SRC.IsDigit16		jsr SRC.IsDigit10
					bcc .8
					cmp #'A'
					bcc .9
					cmp #'F'+1
					bcc .1
					
					cmp #'a'
					bcc .9
					cmp #'f'+1
					bcs .9

					eor #$20
					
.1					
*					clc
					sbc #'A'-11			cc so A->10 (11-CC)
					clc
					
.8					and #$0F					
					rts
					
.9					sec
					rts
*---------------------------------------
SRC.IsDigit10		cmp #'0'
					bcc .9
					cmp #'9'+1
					rts					cc if ok, cs if not
					
.9					sec
					rts
*---------------------------------------
SRC.IsDigit8		cmp #'0'
					bcc .9
					cmp #'7'+1
					rts					cc if ok, cs if not
					
.9					sec
					rts
*---------------------------------------
SRC.GetNextCharNB	jsr SRC.GetNextChar
					bcs .9
					cmp #' '
					beq SRC.GetNextCharNB
					
					clc
					
.9					rts
*---------------------------------------
SRC.GetNextCharUC	jsr SRC.GetNextChar
					bcs .9
					cmp #'a'
					bcc .8
					cmp #'z'+1
					bcs .8
					eor #$20			to Uppercase
					
.8					clc
.9					rts
*---------------------------------------
SRC.GetNextChar		lda (ZPLinePtr)
					beq SRC.GetChar.ERR
					cmp #$0D
					beq SRC.GetChar.ERR
					
					inc ZPLinePtr
					bne SRC.GetChar
					
					inc ZPLinePtr+1
					
SRC.GetChar			lda (ZPLinePtr)
					beq SRC.GetChar.ERR
					cmp #$0D
					beq SRC.GetChar.ERR
					
					clc
					rts
					
SRC.GetChar.ERR		sec
					rts
*---------------------------------------
SRC.ACC10			lda SRC.ACC			ACC*2-> ACC & ACCTMP
					asl
					sta SRC.ACC
					sta SRC.ACCTMP
					lda SRC.ACC+1
					rol
					sta SRC.ACC+1
					sta SRC.ACCTMP+1
					lda SRC.ACC+2
					rol
					sta SRC.ACC+2
					sta SRC.ACCTMP+2
					lda SRC.ACC+3
					rol
					sta SRC.ACC+3
					sta SRC.ACCTMP+3
					bcs .9
					
					ldx #2
.1					asl SRC.ACC			ACC=ACC*4
					rol SRC.ACC+1
					rol SRC.ACC+2
					rol SRC.ACC+3
					bcs .9
					dex
					bne .1
					
					lda SRC.ACC			CC from ROL SRC.ACC+3
					adc SRC.ACCTMP
					sta SRC.ACC
					lda SRC.ACC+1
					adc SRC.ACCTMP+1
					sta SRC.ACC+1
					lda SRC.ACC+2
					adc SRC.ACCTMP+2
					sta SRC.ACC+2
					lda SRC.ACC+3
					adc SRC.ACCTMP+3
					sta SRC.ACC+3		CS if overflow
					
.9					rts					
*---------------------------------------
MAN
SAVE /A2OSX.BUILD/BIN/DEV/ASM.S.SRC
LOAD /A2OSX.BUILD/BIN/DEV/ASM.S
ASM