;;
;; Copyright (c) 2016 Marco Granati <mg@unet.bz>
;;
;; Permission to use, copy, modify, and distribute this software for any
;; purpose with or without fee is hereby granted, provided that the above
;; copyright notice and this permission notice appear in all copies.
;;
;; THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
;; WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
;; MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
;; ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
;; WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
;; ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
;; OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
;;

;; name: string.asm	
;; rev.: 2016/22/10
;; o.s. 65C816 version v1.0

;; shared library: string functions

.LIST on

; flags
PNFLAG		.EQU	10000000B	; Negative flag
PVFLAG		.EQU	01000000B	; Overflow flag
PMFLAG		.EQU	00100000B	; Acc/Mem 8 bit flag
PXFLAG		.EQU	00010000B	; Index 8 bit flag
PDFLAG		.EQU	00001000B	; Decimal flag
PIFLAG		.EQU	00000100B	; IRQ disable flag
PZFLAG		.EQU	00000010B	; Zero flag
PCFLAG		.EQU	00000001B	; Carry flag

; macro's
; MEM/ACC 16 bit
ACC16:		.MACRO
	.MLIST
	rep	#PMFLAG
	.LONGA	on
	.MNLIST
.ENDM

; MEM/ACC 16 bit AND CLEAR CARRY
ACC16CLC:	.MACRO
	.MLIST
	rep	#(PMFLAG.OR.PCFLAG)
	.LONGA	on
	.MNLIST
.ENDM

; MEM/ACC 8 bit
ACC08:		.MACRO
	.MLIST
	sep	#PMFLAG
	.LONGA	off
	.MNLIST
.ENDM

; MEM/ACC 8 bit AND SET CARRY
ACC08SEC:	.MACRO
	.MLIST
	sep	#(PMFLAG.OR.PCFLAG)
	.LONGA	off
	.MNLIST
.ENDM

; X/Y 16 bit
INDEX16:	.MACRO
	.MLIST
	rep	#PXFLAG
	.LONGI	on
	.MNLIST
.ENDM

; X/Y 16 bit AND CLEAR CARRY
INDEX16CLC:	.MACRO
	.MLIST
	rep	#(PXFLAG.OR.PCFLAG)
	.LONGI	on
	.MNLIST
.ENDM

; X/Y 8 bit
INDEX08:	.MACRO
	.MLIST
	sep	#PXFLAG
	.LONGI	off
	.MNLIST
.ENDM

; A/M/X/Y 16 bit
CPU16:		.MACRO
	.MLIST
	rep	#(PMFLAG.OR.PXFLAG)
	.LONGA	on
	.LONGI	on
	.MNLIST
.ENDM

; A/M/X/Y 16 bit AND CLEAR CARRY
CPU16CLC:	.MACRO
	.MLIST
	rep	#(PMFLAG.OR.PXFLAG.OR.PCFLAG)
	.LONGA	on
	.LONGI	on
	.MNLIST
.ENDM

; A/M/X/Y 8 bit
CPU08:		.MACRO
	.MLIST
	sep	#(PMFLAG.OR.PXFLAG)
	.LONGA	off
	.LONGI	off
	.MNLIST
.ENDM

; A/M/X/Y 8 bit AND SET CARRY
CPU08SEC:	.MACRO
	.MLIST
	sep	#(PMFLAG.OR.PXFLAG.OR.PCFLAG)
	.LONGA	off
	.LONGI	off
	.MNLIST
.ENDM

;---------------------------------------------------------------------------
; code segment 
;---------------------------------------------------------------------------

	.CODE

	.LONGA	off
	.LONGI	off

; _strlen(src)
;
; return in C the length of the string src
; if the lenght is greater than 64k return $FFFF
;
;-------------------------------
_strlen:
	.PUBLIC _strlen
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	3		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
src	.SET	entsr + 4	; <src> parameter
;
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	INDEX16			; X/Y 16 bit
	ACC08			; be sure A 8 bit
	ldy	#0		; pointer
;
?loop:	lda	[src],y		; get next char
	beq	?done		; done when get a nul
	iny			; bump pointer
	bne	?loop
	dey			; max length = $FFFF
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = string length
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strcpy(dst, src)
;
; copy string src to dst
; return in C the lenght of string
; dst must have sufficient room to hold the result
; if length of src > $FFFF, dst will be truncated
;
;-------------------------------
_strcpy:
	.PUBLIC _strcpy
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	6		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
src	.SET	entsr + 4	; <src> parameter
dst	.SET	src + 3		; <dst> parameter
;
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	INDEX16			; X/Y 16 bit
	ACC08			; be sure A 8 bit
	ldy	#0		; pointer
;
?loop:	lda	[src],y		; get next char
	sta	[dst],y		; store
	beq	?done		; done when get a null
	iny			; bump pointer
	bne	?loop
	tya			; A=0
	dey			; max length = $FFFF	
	sta	[dst],y		; always NUL terminates dst
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = string length
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strcat(str, append)
;
; append string append to string str
; return in C the lenght of string
; str must have sufficient room to hold the result
;
;-------------------------------
_strcat:
	.PUBLIC _strcat
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	6		; parameter stack frame size
locsiz	.SET	2		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
append	.SET	entsr + 4	; <append> parameter
str	.SET	append + 3	; <str> parameter
;
indx	.SET	1		; <indx>: local var
;
	php			; save SR
	INDEX16			; X/Y 16 bit
	ldy	#0		; pointer
	phy			; make room for local var <indx=0>
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	ACC08			; be sure A is 8 bit
;
?loop:	lda	[str],y		; search end of string str
	beq	?cat		; done when get a nul
	iny			; bump pointer
	bne	?loop
	dey			; max length = $FFFF
	bra	?done		; can't append more char's
;
?cat:	tyx			; X = current str index
	ldy	<indx		; index to append string
	lda	[append],y	; get next char from append
	iny			; bump pointer to append string
	sty	<indx
	txy
	sta	[str],y		; append char to str
	cmp	#0		; nul?
	beq	?done		; yes
	iny			; bump pointer
	bne	?cat		; append next char
	dey			; max length = $FFFF
;	
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = string length
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strncpy(dst, src, siz)
;
; copy string src to string dst of size <siz+1>
; at most siz characters will be copied
; return in C the lenght of string
; if <siz=0> src is an empty string
;
;-------------------------------
_strncpy:
	.PUBLIC _strncpy
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	8		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
siz	.SET	entsr + 4	; <siz> parameter
src	.SET	siz + 2		; <src> parameter
dst	.SET	src + 3		; <dst> parameter
;
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	INDEX16			; X/Y 16 bit
	ACC08			; be sure A 8 bit
	ldy	<siz
	beq	?nul		; return an empty string
	ldy	#0		; pointer
;
?loop:	lda	[src],y		; get next char
	sta	[dst],y		; store
	beq	?done		; done when get a null
	iny			; bump pointer
	cpy	<siz
	bcc	?loop
;
?nul:	lda	#0		; always NUL terminates dst
	sta	[dst],y	
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = string length
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strdel(str, start, count)
;
; remove at most <count> characters from string <str>, starting
; at index <start>
;
;	stack param's:
;
;	<str>:		long pointer to string
;	<start>:	index of first character to remove (word)
;	<count>:	count of characters to remove (word)
;
;	return:		C = length of string 
;
;	note:		X & Y not preserved
;
;-------------------------------
_strdel:
	.PUBLIC _strdel
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	7		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
count	.SET	entsr + 4	; <count> parameter
start	.SET	count + 2	; <start> parameter
str	.SET	start + 2	; <str> parameter
;
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08			; be sure A,X,Y 8 bit
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
;
?len:	lda	[str],y		; compute string length
	beq	?chk		; done when get a nul
	iny			; bump pointer
	bne	?len
	tya
	dey			; max length = $FFFF
	sta	[str],y		; force string terminator	
;
?chk:	tyx			; check string lenght
	beq	?done		; empty string
	ldx	<count
	beq	?done		; nothing to delete
	cpy	<start		; if length <= start...
	bcc	?done		; ...nothing to delete
	beq	?done
	CPU16CLC		; A 16 bit and clear carry
	txa			; <count>
	adc	<start		; index of first character to move back
	sta	<count
	ACC08			; A 8 bit
	bcs	?mov		; beyond the string...put nul at <start> index 
	cpy	<count		; length < start + count?
	bcc	?mov		; yes -- terminate string at <start> index
	ldy	<count		; index of next character to move back
?mov:	lda	[str],y
	tyx			; save to X
	ldy	<start		; index where put character
	sta	[str],y
	cmp	#0		; nul byte?
	beq	?done		; yes, done
	iny
	sty	<start
	txy
	iny
	bra	?mov		; move loop
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = string length
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strins(str1, str2, start, maxlen)
;
; insert <str2> string into <str1> string, starting at index <start> of <str1>
; character of <str1>, starting from <start> index, are moved ahead to make
; room for characters of <str2>
; if <maxlen>=0 then string <str1> will be truncated (return an empty string)
; buffer <str1> should have a size=<maxlen>+1 to hold the nul terminator
;
;	stack param's:
;
;	<str1>:		long pointer to target string
;	<str2>:		long pointer to string to insert
;	<start>:	index of first character where start insertion (word)
;	<maxlen>:	max. length of <str1> (word)
;
;	return:		C = length of string <str1>
;
;	note:		X & Y not preserved
;
;-------------------------------
_strins:
	.PUBLIC _strins
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	10		; parameter stack frame size
locsiz	.SET	14		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
maxlen	.SET	entsr + 4	; <maxlen> parameter
start	.SET	maxlen + 2	; <start> parameter
str2	.SET	start + 2	; <str2> long pointer
str1	.SET	str2 + 3	; <str1> long pointer
;
len1	.SET	1		; local: <str1> length
len2	.SET	3		; local: <str2> length
iy	.SET	5		; local: temp. index
end	.SET	7		; local: index of last byte of <str1> to move
newend	.SET	9		; local: index of final <str1> ending
cnt1	.SET	11		; local: count of bytes to move in <str1>
cnt2	.SET	13		; local: count of bytes to copy from <str2>
;
	php			; save SR
	CPU16CLC
	tsc
	sbc	#locsiz-1	; make room for locals var's
	tcs			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	stz	<iy		; clear <iy>, <cnt1>, <cnt2>
	stz	<cnt1
	stz	<cnt2	
	ACC08			; X/Y 16 bit, A/M 8 bit
	ldy	<iy		; pointer Y = 0
	tyx			; X = 0
;
?len2:	lda	[str2],y	; compute string <str2> length
	beq	?stl		; done when get a nul
	iny			; bump pointer
	bne	?len2
	tya
	dey			; max length = $FFFF
	sta	[str2],y	; force string terminator	
;
?stl:	sty	<len2		; store <str2> lenght
	txy			; Y = 0
;
?len1:	lda	[str1],y	; compute string <str1> length
	beq	?chk		; done when get a nul
	iny			; bump pointer
	bne	?len1
	tya
	dey			; max length = $FFFF
	sta	[str1],y	; force string terminator	
;
?chk:	cpy	<maxlen		; fix <maxlen> if below the actual...
	bcc	?chk1		; ...<str1> length
	sty	<maxlen
;
?chk1:	CPU16CLC
	tya
	adc	<len2		; final string length 
	bcs	?chk2		; truncate to <maxlen>
	cmp	<maxlen		; can fit?
	bcs	?chk2		; no, truncate to <maxlen>
	sta	<maxlen		; store final length
;
?chk2:	sty	<len1		; store <str1> length
	ldx	<len2		; if <str2> is empty...
	beq	?done		; ...return <str1>
	tyx			; if <str1> is empty...
	beq	?cat		; ...return <str1> = <str2>
	ldx	<maxlen
	dex
	stx	<newend		; pointer to the end of final <str1>
	lda	<start
	cmp	<len1
	bcc	?chk3		; <start> is in range [1..length(str1)-1]
;
?cat:	sty	<start		; append <str2> to the end of <str1> 
	sec
	lda	<maxlen		; count of bytes to copy from <str2> to...
	sbc	<len1		; ...<str1> starting at index <start>
	sta	<cnt2
	bra	?mov
;
?chk3:	adc	<len2		; <start> + length(str2)
	bcc	?chk4
	lda	#$FFFF		; limit max. length
;
?chk4:	cmp	<maxlen		; can move som bytes of <str1> to make room?
	bcc	?less		; yes
	sbc	<start		; no... compute how much bytes of <str2>...
	sta	<cnt2		; ...can be inserted
	bra	?mov
;
?less:	sta	<cnt1		; index where move bytes of <str1>
	sec
	lda	<maxlen
	sbc	<cnt1
	sta	<cnt1		; count of bytes to move in <str1>
	clc
	adc	<start
	dec	a		; pointer to the last byte of <str1>...
	sta	<end		; ...that will be moved ahead
	ldx	<len2		; the whole <str2> can be inserted
	stx	<cnt2
;
; move <cnt1> bytes from the <str1> to the new end of <str1>
?mov:	ACC08			; A/M 8 bit
	ldx	<cnt1		; count of bytes to move
	beq	?cpy		; nothing to move in <str1>
;
?lmov:	ldy	<end		; move from the end of <str1>...
	lda	[str1],y
	dey
	sty	<end
	ldy	<newend		; ...to the new end
	sta	[str1],y
	dey			; decrement (move previous)
	sty	<newend
	dex
	bne	?lmov		; move loop
;
; copy <cnt2> bytes from beginning of <str2> to <str1>, starting at index <start>
?cpy:	ldx	<cnt2		; count of bytes to copy
	beq	?nul		; nothing to copy: terminate <str1>
;
?lcpy:	ldy	<iy	
	lda	[str2],y
	iny
	sty	<iy
	ldy	<start		; target index
	sta	[str1],y
	iny
	sty	<start
	dex
	bne	?lcpy		; loop copy
;
?nul:	txa			; terminate string <str1>
	ldy	<maxlen
	sta	[str1],y
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = string <str1> length
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

;---------------------------------------------------------------------------
; strings comparison
;---------------------------------------------------------------------------

; _strcmp(s1, s2)
;
; lexicographically compare the null-terminated strings s1 and s2
;
;	stack param's:
;
;	<s1>:		long pointer to first string
;	<s2>:		long pointer to second string
;
;	return:		status flags affected like in 'cmp' instruction
;			CF=0 & ZF=0 if s1 less than s2
;			CF=1 & ZF=1 if s1 equal to s2
;			CF=1 & ZF=0 if s1 greater than s2
;
;	note:		X & Y not preserved
;
;-------------------------------
_strcmp:
	.PUBLIC _strcmp
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	6		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
s2	.SET	entsr + 4	; <s1> parameter
s1	.SET	s2 + 3		; <s2> parameter
;
	rep	#PZFLAG+PCFLAG	; clear CF & ZF
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08			; A/M & X/Y 8 bit
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
;
?cmp:	lda	[s1],y		; get next char from <s1>
	cmp	[s2],y		; compare with byte in <s2>
	bne	?end		; unmatch, set flags
	cmp	#0		; end of string?
	beq	?end		; yes, set flags
	iny			; bump pointer
	bne	?cmp		; compare next char
	sec			; all match: set carry
;
?end:	php			; CF & ZF affected according comparison
	pla
	and	#PZFLAG+PCFLAG	; mask on CF & ZF
	tsb	<entsr		; set flags on saved status reg.
	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strncmp(s1, s2, n)
;
; lexicographically compare the null-terminated strings s1 and s2
; this function compares not more than n characters
;
;	stack param's:
;
;	<s1>:		long pointer to first string
;	<s2>:		long pointer to second string
;	<n>:		word: count of characters to compare
;
;	return:		status flags affected like in 'cmp' instruction
;			CF=0 & ZF=0 if s1 less than s2
;			CF=1 & ZF=1 if s1 equal to s2
;			CF=1 & ZF=0 if s1 greater than s2
;
;	note:		X & Y not preserved
;
;-------------------------------
_strncmp:
	.PUBLIC _strncmp
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	8		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
n	.SET	entsr + 4	; <n> parameter
s2	.SET	n + 2		; <s1> parameter
s1	.SET	s2 + 3		; <s2> parameter
;
	rep	#PZFLAG+PCFLAG	; clear CF & ZF
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08SEC		; A/M & X/Y 8 bit & set carry
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
	ldx	<n		; if <n> = 0 set CF=1 & ZF=1
	beq	?end		
;
?cmp:	lda	[s1],y		; get next char from <s1>
	cmp	[s2],y		; compare with byte in <s2>
	bne	?end		; unmatch, set flags
	cmp	#0		; end of string?
	beq	?end		; yes, set flags
	iny			; bump pointer
	cpy	<n		; at most <n> characters...
	bcc	?cmp		; compare next char
				; all match: set carry & zero flag
;
?end:	php			; CF & ZF affected according comparison
	pla
	and	#PZFLAG+PCFLAG	; mask on CF & ZF
	tsb	<entsr		; set flags on saved status reg.
	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off
	
; _strcasecmp(s1, s2)
;
; lexicographically compare the null-terminated strings s1 and s2,
; ignoring stings case
;
;	stack param's:
;
;	<s1>:		long pointer to first string
;	<s2>:		long pointer to second string
;
;	return:		status flags affected like in 'cmp' instruction
;			CF=0 & ZF=0 if s1 less than s2
;			CF=1 & ZF=1 if s1 equal to s2
;			CF=1 & ZF=0 if s1 greater than s2
;
;	note:		X & Y not preserved
;
;-------------------------------
_strcasecmp:
	.PUBLIC _strcasecmp
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	6		; parameter stack frame size
locsiz	.SET	2		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
s2	.SET	entsr + 4	; <s1> parameter
s1	.SET	s2 + 3		; <s2> parameter
;
tmp	.SET	1		; local: temp. byte
;
	rep	#PZFLAG+PCFLAG	; clear CF & ZF
	php			; save SR
	pea	#0		; local variable
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08			; A/M & X/Y 8 bit
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
;
?cmp:	lda	[s2],y		; get next char from <s2>
	cmp	#'a'		; translate lower case to upper case
	bcc	?st
	cmp	#'z'+1
	bcs	?st
	and	#$DF		; upper case
?st:	sta	<tmp		; store character
	lda	[s1],y		; get next char from <s1>
	cmp	#'a'		; translate lower case to upper case
	bcc	?cmp2
	cmp	#'z'+1
	bcs	?cmp2
	and	#$DF		; upper case
?cmp2:	cmp	<tmp		; compares characters
	bne	?end		; unmatch, set flags
	cmp	#0		; end of string?
	beq	?end		; yes, set flags
	iny			; bump pointer
	bne	?cmp		; compare next char
	sec			; all match: set carry
;
?end:	php			; CF & ZF affected according comparison
	pla
	and	#PZFLAG+PCFLAG	; mask on CF & ZF
	tsb	<entsr		; set flags on saved status reg.
	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strncasecmp(s1, s2, n)
;
; lexicographically compare the null-terminated strings s1 and s2,
; ignoring strings case; this function compares not more than n characters
;
;	stack param's:
;
;	<s1>:		long pointer to first string
;	<s2>:		long pointer to second string
;	<n>:		word: count of characters to compare
;
;	return:		status flags affected like in 'cmp' instruction
;			CF=0 & ZF=0 if s1 less than s2
;			CF=1 & ZF=1 if s1 equal to s2
;			CF=1 & ZF=0 if s1 greater than s2
;
;	note:		X & Y not preserved
;
;-------------------------------
_strncasecmp:
	.PUBLIC _strncasecmp
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	8		; parameter stack frame size
locsiz	.SET	2		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
n	.SET	entsr + 4	; <n> parameter
s2	.SET	n + 2		; <s1> parameter
s1	.SET	s2 + 3		; <s2> parameter
;
tmp	.SET	1		; local: temp. byte
;
	rep	#PZFLAG+PCFLAG	; clear CF & ZF
	php			; save SR
	pea	#0		; local variable
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08SEC		; A/M & X/Y 8 bit & set carry
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
	ldx	<n		; if <n> = 0 set CF=1 & ZF=1
	beq	?end		
;
?cmp:	lda	[s2],y		; get next char from <s2>
	cmp	#'a'		; translate lower case to upper case
	bcc	?st
	cmp	#'z'+1
	bcs	?st
	and	#$DF		; upper case
?st:	sta	<tmp		; store character
	lda	[s1],y		; get next char from <s1>
	cmp	#'a'		; translate lower case to upper case
	bcc	?cmp2
	cmp	#'z'+1
	bcs	?cmp2
	and	#$DF		; upper case
?cmp2:	cmp	<tmp		; compares characters
	bne	?end		; unmatch, set flags
	cmp	#0		; end of string?
	beq	?end		; yes, set flags
	iny			; bump pointer
	cpy	<n		; at most <n> characters...
	bcc	?cmp		; compare next char
				; all match: set carry & zero flag
;
?end:	php			; CF & ZF affected according comparison
	pla
	and	#PZFLAG+PCFLAG	; mask on CF & ZF
	tsb	<entsr		; set flags on saved status reg.
	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

;---------------------------------------------------------------------------
; find character & substring
;---------------------------------------------------------------------------

; _strchr(s, c)
;
; locates the first occurrence of character <c> in string pointed to by <s>
;
;	stack param's:
;
;	<s>:		long pointer to string
;	<c>:		character to find (byte)
;
;	return:		CF=0 & C = index of character in string, if found
;			CF=1 & C = index of the nul terminator if not found
;			           (string length in fact)
;
;	note:		X & Y not preserved
;
;-------------------------------
_strchr:
	.PUBLIC _strchr
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	4		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
c	.SET	entsr + 4	; <c> parameter
s	.SET	c + 1		; <s> parameter
;
	sec			; assume not found
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08			; A/M & X/Y 8 bit
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
;
?cmp:	lda	[s],y		; get next char from <s>
	cmp	<c		; compare with character <c>
	beq	?end		; match, reset carry flag
	cmp	#0		; end of string?
	beq	?done		; yes, return index of terminator
	iny			; bump pointer
	bne	?cmp		; compare next char
	dey
	bra	?done
;
?end:	lda	#PCFLAG		; clear CF
	trb	<entsr
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = index
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strrchr(s, c)
;
; locates the last occurrence of character <c> in string pointed to by <s>
;
;	stack param's:
;
;	<s>:		long pointer to string
;	<c>:		character to find (byte)
;
;	return:		CF=0 & C = index of character in string, if found
;			CF=1 & C = index of the nul terminator if not found
;			           (string length in fact)
;
;	note:		X & Y not preserved
;
;-------------------------------
_strrchr:
	.PUBLIC _strrchr
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	4		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
c	.SET	entsr + 4	; <c> parameter
s	.SET	c + 1		; <s> parameter
;
	sec			; assume not found
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08			; A/M & X/Y 8 bit
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
;
?len:	lda	[s],y		; find end of string
	beq	?ok		; done when get a nul
	iny			; bump pointer
	bne	?len
	tya
	dey			; max length = $FFFF
	sta	[s],y		; force string terminator	
;
?ok:	tyx			; save pointer to the end of string
	lda	<c
?cmp:	cmp	[s],y		; compare
	beq	?end		; match, reset carry flag
	dey			; update pointer
	bne	?cmp		; compare previous char
	cmp	[s]		; compare character at index 0
	bne	?done		; unmatch
;
?end:	lda	#PCFLAG		; clear CF
	trb	<entsr
	tyx			; index where found character
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	txa			; C = index
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strlchr(s, c, i)
;
; locates the first occurrence of character <c> in string pointed to by <s>,
; starting from the character at index <i>
;
;	stack param's:
;
;	<s>:		long pointer to string
;	<c>:		character to find (byte)
;	<i>:		index where start searching (word)
;
;	return:		CF=0 & C = index of character in string, if found
;			CF=1 & C = index of the nul terminator if not found
;			           (string length in fact)
;
;	note:		X & Y not preserved
;
;-------------------------------
_strlchr:
	.PUBLIC _strlchr
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	6		; parameter stack frame size
locsiz	.SET	0		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
i	.SET	entsr + 4	; <i> parameter
c	.SET	i + 2		; <c> parameter
s	.SET	c + 1		; <s> parameter
;
	sec			; assume not found
	php			; save SR
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	CPU08			; A/M & X/Y 8 bit
	ldy	#0		; pointer
	INDEX16			; X/Y 16 bit
;
?cmp:	lda	[s],y		; get next char from <s>
	cmp	<c		; compare with character <c>
	beq	?fnd		; match, test index
?tst:	cmp	#0		; end of string?
	beq	?done		; yes, return index of terminator
	iny			; bump pointer
	bne	?cmp		; compare next char
	dey
	bra	?done
;
?fnd:	cpy	<i		; at right starting index?
	bcc	?tst		; no, search again
	lda	#PCFLAG		; clear CF
	trb	<entsr
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	tya			; C = index
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off

; _strstr(s, find)
; locates the first occurrence of string <find> in string <s>
;
;	stack param's:
;
;	<s>:		long pointer to string <s>
;	<find>:		long pointer to string <find>
;
;	return:		CF=0 & C=index of first character of first occurrence
;			CF=1 & C=length of <s> if <find> occur nowhere in <s>
;			if <find> is empty return CF=0 & C=0
;
;	note:		X & Y not preserved
;
;-------------------------------
_strstr:
	.PUBLIC _strstr
;-------------------------------

	.LONGA	off
	.LONGI	off
	
parsiz	.SET	6		; parameter stack frame size
locsiz	.SET	4		; locals stack frame size
skpsiz	.SET	parsiz + locsiz	; bytes to skip to realign stack
entsr	.SET	locsiz + 1	; pointer to saved status reg.
exitsr	.SET	skpsiz + 1	; pointer to moved status reg.
;
find	.SET	entsr + 4	; <find> parameter
s	.SET	find + 3	; <s> parameter
;
len	.SET	1		; local: string <find> length
c	.SET	3		; local: firs character of <find>
;
	sec			; assume not found
	php			; save SR
	CPU08			; A/M & X/Y 8 bit
	ldx	#0		; index
	INDEX16			; X/Y 16 
	phx			; local: <c>
	phx			; local: <len>
	tsc			; stack frame
	phd			; save DP reg.
	tcd			; dp access to stack var's
	lda	[find]		; if string <find> is empty...
	beq	?end2		; ...exit with index = 0 & CF = 0
	sta	<c		; <c> = first character of <find>
	ldy	<find		; bump pointer to <find>
	iny
	sty	<find		; <find1> = pointer to 2nd character of <find>
	bne	?go
	inc	<find+2
;
?go	txy			; Y = 0
;
?len:	lda	[find],y	; compute string <find1> length
	beq	?do		; done when get a nul
	iny			; bump pointer
	bne	?len
	tya
	dey			; max length = $FFFF
	sta	[find],y	; force string terminator	
;
?do:	sty	<len		; <len> = <find1> length
;
?do1:	ldy	<s		; scan string <s>
;
?do2:	lda	[s]		; next char of string <s>
	beq	?done		; end of string <s>: exit with CF=1
	inx			; update <s> scan index
	iny
	sty	<s		; bump <s> pointer
	bne	?do3
	inc	<s+2
;
?do3:	cmp	<c		; match first character of <find>?
	bne	?do2		; no, so check next character of <s>
	ldy	<len		; now compute _strncmp(s, find1, len)
	beq	?end		; if <len> = 0 match first character
	ldy	#0
;
?cmp:	lda	[s],y		; get next char from <s>
	cmp	[find],y	; compare with byte in <find1>
	bne	?do1		; unmatch, try next char of <s>
	cmp	#0		; end of string?
	beq	?end		; yes, reset carry flag
	iny			; bump pointer
	cpy	<len		; at most <len> characters...
	bcc	?cmp		; compare next char
;
?end:	dex			; all match: update index & reset carry flag
;
?end2:
	lda	#PCFLAG		; reset CF...
	trb	<entsr		; ...on saved status reg.
;
?done:	CPU16CLC		; A,X,Y 16 bit - clear carry
	lda	<entsr+2	; move saved SR and return address
	sta	<exitsr+2
	lda	<entsr
	sta	<exitsr
	pld			; restore DP reg.
	tsc			; stack frame
	adc	#skpsiz		; realign stack
	tcs
	txa			; C = index
	plp			; restore SR
	rtl

	.LONGA	off
	.LONGI	off