dest dd ?      

        invoke HeapAlloc, <invoke GetProcessHeap>, HEAP_ZERO_MEMORY, 256
        mov [dest], eax

        stdcall szRep, source, [dest], search, replace
        invoke MessageBox, 0, [dest], "", 0

        invoke HeapFree, <invoke GetProcessHeap>, 0, [dest]
        ret
    

I never used libC or use libC (not that I know, if I do, please, let me know).

No, I don't care. Why? --> Because it is impossible to create something that is "un-hackable".

In other words, a waste of time.

vid got a complete string function implementation,
http://fasmlib.x86asm.net/

struc string {
  .capacity dd ?
  .len      dd ?
  label .data byte
}

virtual at -(sizeof.string)
  string string
  sizeof.string = $-string
end virtual    

stdcall StrDup, 'Test string'
stdcall StrPtr, eax
mov ecx, [esi+string.len]    

struc string {
  .capacity dd ?
  .len      dd ?
  .data     rb 0
}    

struct string
  org $-sizeof.string

  .capacity dd  ?
  .len      dd  ?
  .data     rb  0
ends    

StringRep:
mov ebp,esp
mov edi,[ebp+4];pSourceString
mov esi,[ebp+8];pSearchString
xor ecx,ecx ;Equal bytes counter
.loop: ;Main loop
cmp byte[edi],0
je .loop_end    ;If pSourceString end then breaks the loop
mov al,[esi+ecx] ;Loads byte pSearchString + counter
cmp al,[edi] ;Compares above byte with pSearchString character
jne .not_equal
.equal: ; Both bytes are equal
add ecx,1
add edi,1
mov al,[esi+ecx]
cmp al,0
je .loop_end
jmp .loop
.not_equal: ;Both bytes aren't equal
add edi,1
xor ecx,ecx
jmp .loop
.loop_end:
invoke lstrlen, esi ;Return pSearchString length
cmp eax,ecx ;If length isn't equal with counter then returns error
jne .fail
ret
.fail:
xor eax,eax
ret    

stdcall StringRep,SourceString,SearchString    

SourceString: db "This is string manipulation function!",0
SearchString: db "func",0    

Yea, it looks better. Although, recently I invented another way to make structures on negative offsets, using "struct" (here is with your trick):

Code:

struct string
  org $-sizeof.string

  .capacity dd  ?
  .len      dd  ?
  .data     rb  0
ends    

Oh, but org will break the addressing space into sections. And then you can get 'out of scope' errors.

Hi, I have a little question about StringCopy(pSrc, pDest, dwBytes),
Why do we need dwBytes parameter?

You've text "Welcome to the site of flat assembler!", and you want to copy only first word to some other place. Will you copy all bytes? Of course, not. So you must use 7 in this case as the third parameter.

Well, then it's better to rename it MemoryCopy or something like that, if you want to copy a defined number of bytes. Very Happy

Asm++ wrote:

Well, then it's better to rename it MemoryCopy or something like that, if you want to copy a defined number of bytes.

No, memory copy would be different because you would have to specify the number of bytes that want to be copied.

Asm++ wrote:

Well, then it's better to rename it MemoryCopy or something like that, if you want to copy a defined number of bytes.

No, memory copy would be different because you would have to specify the number of bytes that want to be copied.

With string this is optional as you can know where a string ends and you can copy till its end is reached. To copy part of a string is another story...you would to specify the bytes count too.

Asm++ wrote:

Well, then it's better to rename it MemoryCopy or something like that, if you want to copy a defined number of bytes. Very Happy

Indeed, that routine is a memcpy.

It would be useful, however, specifying the max size of destination - heck, even the size of source - for a string-copy routine, to avoid buffer overflows. Even just reading a buffer can be a security problem

Asm++: even if you're going to use unsafe interfaces, please don't implement a string copy as string length + memory copy... scan over the source string twice? UGH!

strcpy:; 24 bytes
        push    esi
        push    edi

        mov     edi, [esp + 12] ; dst
        mov     esi, [esp + 16] ; src
        
        push    esi
        call    strlen
        mov     ecx, eax
        rep     movsb
        
        pop     eax ; to get rid of arg for strlen
        pop     edi
        pop     esi
        ret    

strcpy_1:       ; 19 bytes
        push    esi
        push    edi
        mov     edi, [esp + 12] ; dst
        mov     esi, [esp + 18] ; src
.copy:
        lodsb
        stosb
        test    al, al
        jnz     .copy

        pop     edi
        pop     esi
        ret

strcpy_2:       ; 19 bytes
        mov     edx, [esp + 4]  ; dst
        mov     ecx, [esp + 8]  ; src
.copy:
        mov     al, [ecx]
        mov     [edx], al
        inc     ecx
        inc     edx
        test    al, al
        jnz     .copy
        ret