;; str.len
; desc: gets length of string
; args: string - string pointer
;       buflen - length of string buffer
; ret: CF set on error, otherwise
;      OF set and EAX=buflen if ending 0 wasn't found in buffer, otherwise
;      OF clear and EAX=length of string
; error: ERR_ZERO_SIZE - buflen=0
;================================
proc str.len string, buflen
        push    ecx edi
        pushf
        cld

        ;ERR_ZERO_SIZE if buflen=0
        cmp     [buflen], 0
        je      .error_buflen_zero

        ;clear OF in stack
        and     word [esp], not (1 shl 11)

        ;find ending zero in buffer
        mov     ecx, [buflen]
        mov     edi, [string]
        xor     al,al
        repne   scasb

        ;set OF if ending 0 wasn't found
        je      @f
        or      word [esp], 1 shl 11
        dec     ecx             ;to disable effect of "dec eax", if there was no ending zero (ugly, i know...)
@@:

        ;EAX = number of readen chars
        mov     eax, [buflen]
        sub     eax, ecx
        dec     eax             ;ending zero

        ;clear CF
        and     byte [esp], not 1

.r:     popf
        pop     edi ecx
        ret

.error_buflen_zero:
        mov     eax, ERR_ZERO_SIZE
.rc:    or      byte [esp], 1   ;set CF in stack
        jmp     .r

endp
    

strlen  proc
        mov     ecx,[esp+4]
        test    ecx,3
        je      short main_loop

str_misaligned:
        mov     al,byte ptr [ecx]
        inc     ecx
        test    al,al
        je      short byte_3
        test    ecx,3
        jne     short str_misaligned

        add     eax,dword ptr 0

        align   16

main_loop:
        mov     eax,dword ptr [ecx]
        mov     edx,7efefeffh
        add     edx,eax
        xor     eax,-1
        xor     eax,edx
        add     ecx,4
        test    eax,81010100h
        je      short main_loop
        ; found zero byte in the loop
        mov     eax,[ecx - 4]
        test    al,al                   ; is it byte 0
        je      short byte_0
        test    ah,ah                   ; is it byte 1
        je      short byte_1
        test    eax,00ff0000h           ; is it byte 2
        je      short byte_2
        test    eax,0ff000000h          ; is it byte 3
        je      short byte_3
        jmp     short main_loop         ; taken if bits 24-30 are clear and bit
                                        ; 31 is set

byte_3:
        lea     eax,[ecx - 1]
        mov     ecx,string
        sub     eax,ecx
        ret
byte_2:
        lea     eax,[ecx - 2]
        mov     ecx,string
        sub     eax,ecx
        ret
byte_1:
        lea     eax,[ecx - 3]
        mov     ecx,string
        sub     eax,ecx
        ret
byte_0:
        lea     eax,[ecx - 4]
        mov     ecx,string
        sub     eax,ecx
        ret
strlen  endp    

; from donkey's string lib, see www.assembler.ca
lszLen FRAME pString
        uses ebx,edx,ecx,esi

                mov     eax,[pString]
                mov esi,eax
                test eax,3
                jz >N1
                        add eax,3
                        and eax,-4
ALIGN 4
                :
                        mov dl,[esi]
                        or dl,dl
                        jz >E1
                        inc esi
                        cmp esi,eax
                jl <

                N1:
                lea             edx,[eax+3]

ALIGN 4
        :  
                mov             ebx,[eax]
                add             eax,4
                lea             ecx,[ebx-01010101h]
                not             ebx
                and             ecx,ebx
                and             ecx,80808080h    
                jz              <
                test    ecx,00008080h
                jnz             >
                shr             ecx,16
                add             eax,2
        :
                shl             cl,1
                sbb             eax,edx

        add eax,esi
        sub eax,[pString]
        ret

        E1:
        mov eax,esi
        sub eax,[pString]
        ret
ENDF
    

;; str.len 
; desc: gets length of string 
; args: string - string pointer 
;       buflen - length of string buffer 
; ret: CF set on error, otherwise 
;      OF set and EAX=buflen if ending 0 wasn't found in buffer, otherwise 
;      OF clear and EAX=length of string 
; error: ERR_ZERO_SIZE - buflen=0 
;=================================    

thanks. but note that i still must also check buffer size (buflen), and never access memory behind it:

Code:

;; str.len 
; error: ERR_ZERO_SIZE - buflen=0 
;=================================    

Code:

.error_buflen_zero:     mov     eax, ERR_ZERO_SIZE
    

You can use instruction up to pentium. Even versions with usage of MMX, SSE etc. are welcomed.

; ret: CF set on error, otherwise
; OF set and EAX=buflen if ending 0 wasn't found in buffer, otherwise
; OF clear and EAX=length of string
; error: ERR_ZERO_SIZE - buflen=0

Shouldn't buflen=0 just cause the OF set with EAX=0? It appears to me as a logical conclusion from the above: in buffer of length 0 the ending 0 cannot be found, and thus we should get OF=1 and EAX=0.