Subversion Repositories Kolibri OS

$Revision: 431 $

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;; Author: Kees J. Bot 1 Jan 1994                               ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; size_t strncat(char *s1, const char *s2, size_t n)

; Append string s2 to s1.

; char *strchr(const char *s, int c)

; int strncmp(const char *s1, const char *s2, size_t n)

; Compare two strings.

; char *strncpy(char *s1, const char *s2, size_t n)

; Copy string s2 to s1.

; size_t strnlen(const char *s, size_t n)

; Return the length of a string.

; proc strrchr stdcall, s:dword, c:dword

; Look for the last occurrence a character in a string.

proc strncat stdcall, s1:dword, s2:dword, n:dword

           push esi

           push edi

           mov edi, [s1]         ; String s1

           mov edx, [n]          ; Maximum length

           mov ecx, -1

           xor al, al            ; Null byte

           cld

           repne scasb           ; Look for the zero byte in s1

           dec edi               ; Back one up (and clear 'Z' flag)

           push edi              ; Save end of s1

           mov edi, [s2]         ; edi = string s2

           mov ecx, edx          ; Maximum count

           repne scasb           ; Look for the end of s2

           jne @F

           inc ecx               ; Exclude null byte

@@:

           sub edx, ecx          ; Number of bytes in s2

           mov ecx, edx

           mov esi, [s2]         ; esi = string s2

           pop edi               ; edi = end of string s1

           rep movsb             ; Copy bytes

           stosb                 ; Add a terminating null

           mov eax, [s1]         ; Return s1

           pop edi

           pop esi

           ret

endp

align 4

proc strncmp stdcall, s1:dword, s2:dword, n:dword

           push esi

           push edi

           mov ecx, [n]

           test ecx, ecx         ; Max length is zero?

           je .done

           mov esi, [s1]         ; esi = string s1

           mov edi, [s2]         ; edi = string s2

           cld

.compare:

           cmpsb                 ; Compare two bytes

           jne .done

           cmp byte [esi-1], 0   ; End of string?

           je .done

           dec ecx               ; Length limit reached?

           jne .compare

.done:

           seta al               ; al = (s1 > s2)

           setb ah               ; ah = (s1 < s2)

           sub al, ah

           movsx eax, al         ; eax = (s1 > s2) - (s1 < s2), i.e. -1, 0, 1

           pop edi

           pop esi

           ret

endp

align 4

proc strncpy stdcall, s1:dword, s2:dword, n:dword

           push esi

           push edi

           mov ecx, [n]          ; Maximum length

           mov edi, [s2]         ; edi = string s2

           xor al, al            ; Look for a zero byte

           mov edx, ecx          ; Save maximum count

           cld

           repne scasb           ; Look for end of s2

           sub edx, ecx          ; Number of bytes in s2 including null

           xchg ecx, edx

           mov esi, [s2]         ; esi = string s2

           mov edi, [s1]         ; edi = string s1

           rep movsb             ; Copy bytes

           mov ecx, edx          ; Number of bytes not copied

           rep stosb             ; strncpy always copies n bytes by null padding

           mov eax, [s1]         ; Return s1

           pop edi

           pop esi

           ret

endp

align 4

proc strnlen stdcall, s:dword, n:dword

           push edi

           mov edi, [s]          ; edi = string

           xor al, al            ; Look for a zero byte

           mov edx, ecx          ; Save maximum count

           cmp cl, 1             ; 'Z' bit must be clear if ecx = 0

           cld

           repne scasb           ; Look for zero

           jne @F

           inc ecx               ; Don't count zero byte

@@:

           mov eax, edx

           sub eax, ecx          ; Compute bytes scanned

           pop edi

           ret

endp

align 4

proc strchr stdcall, s:dword, c:dword

           push edi

           cld

           mov edi, [s]          ; edi = string

           mov edx, 16           ; Look at small chunks of the string

.next:

           shl edx, 1            ; Chunks become bigger each time

           mov ecx, edx

           xor al, al            ; Look for the zero at the end

           repne scasb

           pushf                 ; Remember the flags

           sub ecx, edx

           neg ecx               ; Some or all of the chunk

           sub edi, ecx          ; Step back

           mov eax, [c]          ; The character to look for

           repne scasb

           je .found

           popf                  ; Did we find the end of string earlier?

           jne .next             ; No, try again

           xor eax, eax          ; Return NULL

           pop edi

           ret

.found:

           pop eax               ; Get rid of those flags

           lea eax, [edi-1]      ; Address of byte found

           pop edi

           ret

endp

proc strrchr stdcall, s:dword, c:dword

           push edi

           mov edi, [s]      ; edi = string

           mov ecx, -1

           xor al, al

           cld

           repne scasb           ; Look for the end of the string

           not ecx               ; -1 - ecx = Length of the string + null

           dec edi               ; Put edi back on the zero byte

           mov eax, [c]          ; The character to look for

           std                   ; Downwards search

           repne scasb

           cld                   ; Direction bit back to default

           jne .fail

           lea eax, [edi+1]      ; Found it

           pop edi

           ret

.fail:

           xor eax, eax          ; Not there

           pop edi

           ret

endp