MSVCRT strcpy以及strcat
page ,132
title strcat - concatenate (append) one string to another
;***
;strcat.asm - contains strcat() and strcpy() routines
;
; Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
;
;Purpose:
; STRCAT concatenates (appends) a copy of the source string to the
; end of the destination string, returning the destination string.
;
;*******************************************************************************
.xlist
include cruntime.inc
.list
page
;***
;char *strcat(dst, src) - concatenate (append) one string to another
;
;Purpose:
; Concatenates src onto the end of dest. Assumes enough
; space in dest.
;
; Algorithm:
; char * strcat (char * dst, char * src)
; {
; char * cp = dst;
;
; while( *cp )
; ++cp; /* Find end of dst */
; while( *cp++ = *src++ )
; ; /* Copy src to end of dst */
; return( dst );
; }
;
;Entry:
; char *dst - string to which "src" is to be appended
; const char *src - string to be appended to the end of "dst"
;
;Exit:
; The address of "dst" in EAX
;
;Uses:
; EAX, ECX
;
;Exceptions:
;
;*******************************************************************************
page
;***
;char *strcpy(dst, src) - copy one string over another
;
;Purpose:
; Copies the string src into the spot specified by
; dest; assumes enough room.
;
; Algorithm:
; char * strcpy (char * dst, char * src)
; {
; char * cp = dst;
;
; while( *cp++ = *src++ )
; ; /* Copy src over dst */
; return( dst );
; }
;
;Entry:
; char * dst - string over which "src" is to be copied
; const char * src - string to be copied over "dst"
;
;Exit:
; The address of "dst" in EAX
;
;Uses:
; EAX, ECX
;
;Exceptions:
;*******************************************************************************
CODESEG
% public strcat, strcpy ; make both functions available
strcpy proc
push edi ; preserve edi
mov edi,[esp+8] ; edi points to dest string 堆栈
jmp short copy_start
strcpy endp
align 16
strcat proc
.FPO ( 0, 2, 0, 0, 0, 0 )
mov ecx,[esp+4] ; ecx -> dest string
push edi ; preserve edi
test ecx,3 ; test if string is aligned on 32 bits
je short find_end_of_dest_string_loop
dest_misaligned: ; simple byte loop until string is aligned
mov al,byte ptr [ecx]
inc ecx
test al,al
je short start_byte_3
test ecx,3
jne short dest_misaligned
align 4
find_end_of_dest_string_loop:
mov eax,dword ptr [ecx] ; read 4 bytes
mov edx,7efefeffh
add edx,eax
xor eax,-1
xor eax,edx
add ecx,4
test eax,81010100h
je short find_end_of_dest_string_loop
; found zero byte in the loop
mov eax,[ecx - 4]
test al,al ; is it byte 0
je short start_byte_0
test ah,ah ; is it byte 1
je short start_byte_1
test eax,00ff0000h ; is it byte 2
je short start_byte_2
test eax,0ff000000h ; is it byte 3
je short start_byte_3
jmp short find_end_of_dest_string_loop
; taken if bits 24-30 are clear and bit
; 31 is set
start_byte_3:
lea edi,[ecx - 1]
jmp short copy_start
start_byte_2:
lea edi,[ecx - 2]
jmp short copy_start
start_byte_1:
lea edi,[ecx - 3]
jmp short copy_start
start_byte_0:
lea edi,[ecx - 4]
; jmp short copy_start
; edi points to the end of dest string.
copy_start::
mov ecx,[esp+0ch] ; ecx -> sorc string
test ecx,3 ; test if string is aligned on 32 bits
je short main_loop_entrance
src_misaligned: ; simple byte loop until string is aligned
mov dl,byte ptr [ecx]
inc ecx
test dl,dl
je short byte_0
mov [edi],dl
inc edi
test ecx,3
jne short src_misaligned ;continue aligned loop
jmp short main_loop_entrance
main_loop: ; edx contains first dword of sorc string
mov [edi],edx ; store one more dword
add edi,4 ; kick dest pointer
main_loop_entrance:
mov edx,7efefeffh
mov eax,dword ptr [ecx] ; read 4 bytes
add edx,eax ; plus edx magic_bits
xor eax,-1 ; eax = ~eax
xor eax,edx ;
mov edx,[ecx] ; it's in cache now
add ecx,4 ; kick dest pointer
test eax,81010100h
je short main_loop
; found zero byte in the loop
; main_loop_end:
test dl,dl ; is it byte 0
je short byte_0
test dh,dh ; is it byte 1
je short byte_1
test edx,00ff0000h ; is it byte 2
je short byte_2
test edx,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:
mov [edi],edx
mov eax,[esp+8] ; return in eax pointer to dest string
pop edi
ret
byte_2:
mov [edi],dx
mov eax,[esp+8] ; return in eax pointer to dest string
mov byte ptr [edi+2],0
pop edi
ret
byte_1:
mov [edi],dx
mov eax,[esp+8] ; return in eax pointer to dest string
pop edi
ret
byte_0:
mov [edi],dl
mov eax,[esp+8] ; return in eax pointer to dest string
pop edi
ret
strcat endp
end
char* strcpy(char*pdest,const char*psrc)
{
const char *char_psrc;
const ulong *longword_psrc,*longword_pdest;
register ulong longword, magic_bits;
char *char_pest=pdest;
for ( char_psrc = psrc; //初始位置
((ulong)char_src& (sizeof(ulong) - 1)) != 0; //边界对齐判断 //地址的size以下全部是0
*char_pdest++ = *char_psrc++) //copy...
{
if (*char_psrc == '\0') //结束...
{
*char_pdest='\0';
return pdest;
}
}
longword_psrc = (ulong*)char_psrc; //从自然边界开始
longword_pdest = (ulong*)char_pdest;
magic_bits = 0x7efefeffL;
while (1)
{
longword = *longword_psrc++;
if ((((longword + magic_bits) ^ ~longword) & ~magic_bits) != 0)
{
const char *cp = (const char*)(longword_psrc - 1);
if (cp[0] == 0)
{
*(char*)longword_pdest = '\0';
return pdest;
}
if (cp[1] == 0)
{
*(WORD*)longword_pdest = *(WORD*)longword_word;
return pdest;
}
if (cp[2] == 0)
{
*(WORD*)longword_pdest = *(WORD*)longword_word;
*((char*)longword_pdest+2) = '\0';
return pdest;
}
if (cp[3] == 0)
{
*longword_pdest = *longword_word;
return pdest;
}
}
*longword_pdest++ = *longword;
}
}
char* strcat(char*pdest,const char*psrc)
{
const char *char_psrc;
const ulong *longword_psrc,*longword_pdest;
register ulong longword, magic_bits;
char *char_pest=pdest;
while(1) //查找源字符串终止位置
{
longword = *longword_psrc++;
if ((((longword + magic_bits) ^ ~longword) & ~magic_bits) != 0)
{
const char *cp = (const char*)(longword_psrc - 1);
if (cp[0] == 0)
{
char_pdest = (char*)longword;
break;
}
if (cp[1] == 0)
{
char_pdest = (char*)longword + 1;
break;
}
if (cp[2] == 0)
{
char_pdest = (char*)longword + 2;
break;
}
if (cp[3] == 0)
{
char_pdest = (char*)longword + 3;
break;
}
}
}
//strcpy
for ( char_psrc = psrc;
((ulong)char_src& (sizeof(ulong) - 1)) != 0;
*char_pdest++ = *char_psrc++)
{
if (*char_psrc == '\0')
{
*char_pdest='\0';
return pdest;
}
}
//对齐后的strcpy
longword_psrc = (ulong*)char_psrc;
longword_pdest = (ulong*)char_pdest;
magic_bits = 0x7efefeffL;
while (1)
{
longword = *longword_psrc++;
if ((((longword + magic_bits) ^ ~longword) & ~magic_bits) != 0)
{//判断是否有0
const char *cp = (const char*)(longword_psrc - 1);
if (cp[0] == 0)
{
*(char*)longword_pdest = '\0';
return pdest;
}
if (cp[1] == 0)
{
*(WORD*)longword_pdest = *(WORD*)longword_word;
return pdest;
}
if (cp[2] == 0)
{
*(WORD*)longword_pdest = *(WORD*)longword_word;
*((char*)longword_pdest+2) = '\0';
return pdest;
}
if (cp[3] == 0)
{
*longword_pdest = *longword_word;
return pdest;
}
}
*longword_pdest++ = *longword;
}
}