;
; BDSNEW - New BDS C Library Functions
;
; File creation date: April 12, 1982 @ 15:33 by BDR
; Last revision date: new file
;
; Operating System: CP/M 2.x
; Software Revision: 1.0
;
;
; This file replaces several of the BDS C library functions that were
; written in C. The functions, being written in assembly rather than
; C, are much faster than the old functions. The most impressive speed
; increase was found in the 'strcmp' function, which is used fairly often
; in many applications.
;
; These functions are believed to accurately replace the corresponding
; BDS C functions. If any bugs are found, please notify me either
; through Uucp (ucbvax(shriek)ucivax(shriek)csuf(shriek)bruce), or
; through the Garden Grove Data Exchange RCPM system: (714) 534-1547.
; (Gee, I wish MAC allowed exclamation marks in comments...)
;
; Bruce Robertson
;
page
;
; Modification History
; ====================
;
; July 21, 1982 Modified to include two block move functions MOVE and
; MOVDN which assemble with the Z80 move instructions if
; the 'z80' equate is true.(Incidently using conditionals
; with CASM isn't easy..it doesn't recognize 'if..endifs')
; J.R.
; July 19, 1982 Modified to be compatible with the CASM preprocessor.
; Jack Riley (303) 499-9169 RCPM
;
; v1.0 April 12, 1982 @ 13:33 by BDR
; Original file was created.
;
page
maclib bds
page
z80 equ 1 ; set to 1 only if code used on z80 computer
;
; This macro is used with the character argument functions to fetch
; the argument from the stack. The argument is placed into register A.
;
getbyte macro
lxi h,2 ;; load the offset to the argument
dad sp ;; HL now points to the argument
mov a,m ;; fetch the argument from the stack
endm
page
;
; Character functions: isupper(), islower(), isalpha(), isdigit(),
; toupper(), tolower(), isspace()
;
; Each of these functions expects a single 'char' as an argument. The
; functions starting with 'is' return either TRUE or FALSE for a given
; character argument, depending on the condition the function is testing.
; the functions starting with 'to' return a (possibly altered) character.
;
;
; Return TRUE if upper case.
;
FUNCTION isupper
getbyte ; fetch the argument from the stack
lxi h,0 ; assume that it isn't upper case
cpi 'A' ; can't be lower than an A...
rc ; return with FALSE if it is
cpi 'Z'+1 ; can't be greater than a Z...
rnc ; return with FALSE if it is
inr l ; change the result to TRUE
ret ; return to caller
ENDFUNC isupper
;
; Return TRUE if lower case.
;
FUNCTION islower
getbyte ; fetch the argument from the stack
lxi h,0 ; assume that it isn't lower case
cpi 'a' ; can't be lower than an 'a'...
rc ; return with FALSE if it is
cpi 'z'+1 ; can't be greater than a 'z'...
rnc ; return with FALSE if it is
inr l ; change the result to TRUE
ret ; return to caller
ENDFUNC islower
;
; Return TRUE if upper or lower case.
;
FUNCTION isalpha
getbyte ; fetch the argument from the stack
lxi h,0 ; assume that it isn't alphabetic
ani 0DFh ; if lower case, convert to upper case
cpi 'A' ; can't be lower than an A...
rc ; return with FALSE if it is
cpi 'Z'+1 ; can't be larger than a Z...
rnc ; return with FALSE if it is
inr l ; change the result to TRUE
ret ; return to caller
ENDFUNC isalpha
;
; Return TRUE if digit.
;
FUNCTION isdigit
getbyte ; fetch the argument from the stack
lxi h,0 ; assume that it isn't a digit
cpi '0' ; can't be lower than a zero...
rc ; return FALSE if it is
cpi '9'+1 ; can't be larger than a nine...
rnc ; return FALSE if it is
inr l ; change the result to TRUE
ret ; return to caller
ENDFUNC isdigit
;
; Convert to upper case if lower case.
;
FUNCTION toupper
getbyte ; fetch the argument from the stack
mov l,a ; assume that the character isn't lower case
mvi h,0 ; (this is placing the character into HL)
cpi 'a' ; can't be lower than an 'a'...
rc ; return with the original character if it is
cpi 'z'+1 ; can't be larger than a 'z'...
rnc ; return with the original if it is
ani 05Fh ; it's lower case - convert to upper case
mov l,a ; put the new character into HL
ret ; return to caller
ENDFUNC toupper
;
; Convert upper case to lower case.
;
FUNCTION tolower
getbyte ; fetch the argument from the stack
mov l,a ; assume that the character isn't upper case
mvi h,0 ; (this is placing the character into HL)
cpi 'A' ; can't be lower than an A...
rc ; return with the original character if it is
cpi 'Z'+1 ; can't be larger than a Z...
rnc ; return with the original if it is
ori 020h ; it's upper case - convert to lower case
mov l,a ; put the new character into HL
ret ; return to caller
ENDFUNC tolower
;
; Return TRUE if character is a space, tab or newline.
;
FUNCTION isspace
getbyte ; fetch the argument from the stack
lxi h,1 ; assume that it is a white space character
cpi ' ' ; check for a space
rz ; return if we have one
cpi 'I'-040h ; check for a tab
rz ; return if we have one
cpi 'J'-040h ; check for a newline
rz ; return if we have one
dcr l ; make the result FALSE
ret ; return to caller
ENDFUNC isspace
page
;
; Function: atoi()
;
;
; This function converts an ascii integer to its binary equivalent. White
; space at the front of the string is ignored, and a minus sign is
; recognized.
;
; int atoi(str)
; char *str;
;
FUNCTION atoi
pop h ; fetch the return address
pop d ; fetch the pointer to the string
push d ; put everything back the way it was
push h
push b ; save the BC register
lxi h,0 ; zero the number accumulator
xra a ; set the sign flag to POSITIVE
push psw ; save the sign flag on the stack
atoi10: ldax d ; fetch the next byte of the string
inx d ; increment the string pointer
cpi ' ' ; check for a leading space
jz atoi10 ; go skip the space
cpi 'I'-040h ; check for a leading tab
jz atoi10 ; go skip the tab
cpi '-' ; check for the minus sign
jnz atoi20 ; jump if no minus sign
pop psw ; fetch the sign flag
inr a ; change the flag to NEGATIVE
push psw ; put the sign flag back
ldax d ; fetch the next string character
inx d ; increment the pointer
atoi20: sui '0' ; convert the alleged digit to binary
cpi 10 ; it can't be larger than 9
jnc atoi30 ; jump if this isn't an ascii digit
mov b,h ; copy the accumulator into BC
mov c,l
dad h ; multiply the accumulator by 8
dad h
dad h
dad b ; adding the original accumulator in twice...
dad b ; multiplies the accumulator by 10.
mov c,a ; put the current digit into BC
mvi b,0
dad b ; add in the current digit
ldax d ; fetch the next string character
inx d ; increment the string pointer
jmp atoi20 ; go check for another digit
atoi30: pop a ; end of number - fetch the sign flag
pop b ; restore the BC register
rz ; return if the sign flag is POSITIVE
mov a,h ; two's complement the accumulator
cma
mov h,a
mov a,l
cma
mov l,a
inx h
ret ; return to caller
ENDFUNC atoi
page
;
; Function: strlen()
;
;
; This function returns the length in bytes of its string argument. The
; terminating zero byte is not counted in the length.
;
; unsigned strlen(str)
; char *str;
;
FUNCTION strlen
pop h ; fetch the return address...
pop d ; fetch the string pointer
push d ; put everything back the way it was
push h
mov h,d ; copy the string pointer into HL
mov l,e
slen10: ldax d ; fetch the next byte of the string
inx d ; increment the string pointer
ora a ; check for a zero byte
jnz slen10 ; loop until we reach the end of the string
;
; To compute the length, we subtract the original string pointer from
; the new string pointer (which is pointing to the zero byte at the
; end of the string).
;
dcx d ; we don't want to count the zero byte
mov a,e ; subtract the low order bytes first
sub l
mov l,a
mov a,d ; subtract the high order bytes next
sbb h
mov h,a
ret ; return to caller with the string length
ENDFUNC strlen
page
;
; Function: strcmp()
;
;
; This function compares two strings. If the first argument is either
; longer than the second argument, or one if its bytes is arithmetically
; greater than the corresponding byte of the second argument (using the
; ASCII collating sequence), then a positive number is returned. If the
; second argument is greater than the first, a negative number is
; returned. If the strings are equal, zero is returned.
;
; If a positive or negative number is returned, the actual value returned
; is meaningless. Only the sign is of use.
;
; int strcmp(s1, s2)
; char *s1, *s2;
;
FUNCTION strcmp
call arghak ; hack apart the arguments
lhld arg1 ; fetch the string 1 pointer
xchg ; put it into DE
lhld arg2 ; fetch the string 2 pointer
scmp10: ldax d ; fetch the next byte of string 1
cmp m ; compare with the next byte of string 2
jnz scmp20 ; jump if the bytes are not equal
inx h ; increment the string pointers
inx d
ora a ; if the byte is zero, we're all done
jnz scmp10 ; loop if we're not done yet
lxi h,0 ; return zero - the strings are equal
ret ; return to caller
scmp20: sub m ; figure out which byte (and string) is larger
mov h,a ; return the result in HL
ret ; return to caller
ENDFUNC strcmp
page
;
; Function: strcpy()
;
;
; This function copies the source string onto the destination string. If
; the destination string should happen to be valid, it will be destroyed.
; There MUST be enough room allocated for the destination string to hold
; the entire source string, or the code or data following the destination
; string will be overwritten.
;
; The function returns a pointer to the destination string.
;
; char *strcpy(dest, source)
; char *dest, *source;
;
FUNCTION strcpy
call arghak ; go hack apart the arguments
lhld arg1 ; fetch the destination string pointer
xchg ; put the pointer into DE
lhld arg2 ; fetch the source string pointer
scpy10: mov a,m ; fetch the next byte of the source string
stax d ; store the byte into the destination string
inx d ; increment the string pointers
inx h
ora a ; if A is zero, we've reached the string end
jnz scpy10 ; loop if we're not at the end
lhld arg1 ; return a pointer to the destination string
ret ; return to caller
ENDFUNC strcpy
page
;
; Function: strcat()
;
;
; This function concatenates the source string onto the destination
; string. There MUST be enough room allocated at the end of the
; destination string to hold the entire source string.
;
; char *strcat(dest, source)
; char *dest, *source;
;
FUNCTION strcat
call arghak ; go hack apart the arguments
lhld arg2 ; fetch the source string pointer
xchg ; put the pointer into DE
lhld arg1 ; fetch the destination string pointer
;
; The loop below finds the end of the destination string.
;
scat10: mov a,m ; fetch the next byte of the destination string
inx h ; increment the string pointer
ora a ; if A is non-zero, we need to keep searching
jnz scat10 ; loop until we reach the end of the string
dcx h ; point back to the zero terminating byte
;
; Now we copy the source onto the end of the destination.
;
scat20: ldax d ; fetch the next source string byte
mov m,a ; store the byte into the destination string
inx h ; increment the string pointers
inx d
ora a ; if A is zero, we've reached the end
jnz scat20 ; loop if we have more to do
lhld arg1 ; return a pointer to the destination string
ret ; return to caller
ENDFUNC strcat
page
;
; Function: move()
;
;
; This function moves <length> bytes from location <source> to
; location <destination>. The move is performed from first to
; last bytes so if there is overlap of range, be sure that
; <source> greater than <destination>. If this condition is not
; true use the 'movdn' function instead. The block move
; instruction is used if the Z80 equate is true.
;
; move(dest, source,length)
; char *dest, *source;
; int length
FUNCTION move
call arghak ; go hack apart the arguments
lhld arg1 ; fetch the destination pointer
xchg ; put the pointer into DE
lhld arg3 ; fetch the length
mov a,h
ora l ; return on zero
rz
push h
pop b ; put into BC
lhld arg2 ; fetch the source pointer
mve10:
if z80
db 0edh,0b0h ; perform LDIR instruction
ret ; return to caller
else ; 8080
mov a,m ; fetch the next byte of the source string
stax d ; store the byte into the destination string
inx d ; increment the string pointers
inx h
dcx b ; decrement count
mov a,b ; test zero in b
ora c ; and c
endif
jnz mve10 ; loop if we're not at the end
ret ; return to caller
ENDFUNC move
FUNCTION movdn
page
;
; Function: movdn()
;
;
; This function moves <length> bytes from location <source> to
; location <destination>. The move is performed from last to
; first bytes so if there is overlap of range, be sure that
; <source> less than <destination>. If this condition is not
; true use the 'move' function instead. Also use 'move' if
; there is no overlap since it is more efficient. The block move
; instruction is used if the Z80 equate is true.
;
; movdn(dest, source , length)
; char *dest, *source;
; int length
call arghak ; go hack apart the arguments
lhld arg3 ; fetch the length
mov a,h
ora l ; return on zero
rz
push h ; save
xchg ; into DE
lhld arg1 ; fetch the destination pointer
dad d ; add length
dcx h ; one too many
push h
lhld arg3 ; fetch the length
xchg ; into DE
lhld arg2 ; fetch the source pointer
dad d ; add length
dcx h ; one too many
pop d ; get back destination
pop b ; and length
mvdn10:
if z80
db 0edh,0b8h ; perform LDDR instruction
ret ; return to caller
else ; 8080
mov a,m ; fetch the next byte of the source string
stax d ; store the byte into the destination string
dcx d ; increment the string pointers
dcx h
dcx b ; decrement count
mov a,b ; test zero in b
ora c ; and c
endif
jnz mvdn10 ; loop if we're not at the end
ret ; return to caller
