WebSVN – Kolibri OS – Diff – /programs/cmm/lib/strings.h


#ifndef INCLUDE_STRING_H
#define INCLUDE_STRING_H
 
#ifndef INCLUDE_MEM_H
#include "../lib/mem.h"
#endif
 
//------------------------------------------------------------------------------
// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2
// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"
// strcmp( ESI, EDI)
// strlen( EDI)
// utf8_strlen( ESI)
// strcpy( EDI, ESI) --- 0 if ==
// strlcpy(dword text1,text2,signed length)
// strcat( EDI, ESI)
// chrcat(ESI, BL)
// strncat(dword text1,text2,signed length) --- pasting the text of a certain length
// strchr( ESI,BL) --- find first BL
// strrchr( ESI,BL) --- find last BL
// strstr( EBX, EDX)
// itoa(signed long number) --- convert the number as a string
// atoi(dword text) --- convert a string as a number
// strupr( ESI)
// strlwr( ESI) --- Cyrillic symbols may not work
// strttl( EDX)
// strtok( ESI)
// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)
// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)
// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides
// chrnum(dword searchin, char symbol)
// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
// strnumb(dword searchin, startstr, endstr) --- get number between strings
// strdup(dword text) --- allocation under the text
//------------------------------------------------------------------------------
 
/*
inline fastcall signed int strcmp( ESI, EDI)
{
    loop()
    {
        IF (DSBYTE[ESI]
        IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
        IF (DSBYTE[ESI]=='\0') RETURN 0;
        ESI++;
        EDI++;
    }
}
*/
 
 
 
inline int strspn(dword text1,text2)
{
	dword beg;
	char s1,s2;
	int ret;
	ret = 0;
	beg = text2;
	do {
		s1 = ESBYTE[text1];
		text2 = beg;
		do {
			s2 = ESBYTE[text2];
			if(s1==s2)
			{
				if(!s2)break;
				$inc ret
				break;
			}
			else $inc text2
		} while(s2);
		$inc text1
	} while(s1);
	return ret;
}
 
inline dword strpbrk(dword text1,text2)
{
	char s,ss;
	dword beg;
	beg = text2;
	do {
		s = ESBYTE[text1];
		text2 = beg;
		do {
			ss = ESBYTE[text2];
			if(ss==s) return text1;
			$inc text2
		} while(ss);
		$inc text1
	} while(s);
	return text1;
}
 
inline fastcall signed int strncmp( ESI, EDI, ECX)
{
  asm {
    MOV EBX, EDI
    XOR EAX, EAX
    MOV EDX, ECX
    OR ECX, ECX
    JE L1
    REPNE SCASB
    SUB EDX, ECX
    MOV ECX, EDX
    MOV EDI, EBX
    XOR EBX, EBX
    REPE CMPSB
    MOV AL, DSBYTE[ ESI-1]
    MOV BL, DSBYTE[ EDI-1]
    SUB EAX, EBX
L1:
  }
}
 
/*
signed int strncmp(dword s1, s2, signed n)
unsigned char _s1,_s2;
{
	if (n == 0)
		return 0;
	do {
		_s1 = DSBYTE[s1];
		_s2 = DSBYTE[s2];
		if (_s1 != _s2)
		{
			$dec s2
			return _s1 - _s2;
		}
		$inc s2
		if (_s1 == 0)
			break;
		$inc s1
		$dec n
	} while (n);
	return 0;
}
*/
 
/*
inline signed int strncmp(dword text1,text2,len)
{
	
	loop()
	{
		if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
		$dec len 
		if(!len)return 0;
	}
}
*/
inline fastcall unsigned int strlen( EDI)
{
	$xor eax, eax
	$mov ecx, -1
	$REPNE $SCASB
	EAX-=2+ECX;
}
 
inline dword strnlen(dword str, dword maxlen)
{
	dword cp;
	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
	return cp - str;
}
 
inline fastcall unsigned int utf8_strlen( ESI)
{
 $xor  ecx, ecx
  _loop: 
 $lodsb
 $test  al, al
 $jz  _done
 $and al, 0xc0
 $cmp al, 0x80
 $jz  _loop 
 $inc ecx
 $jmp _loop
 
  _done:
 return ECX;
}
 
inline signed int strcmp(dword text1, text2)
{
	char s1,s2;
	dword p1,p2;
	p1 = text1;
	p2 = text2;
	loop()
	{
		s1 = DSBYTE[text1];
		s2 = DSBYTE[text2];
		if(s1==s2)
		{
			if(s1==0) return 0;
		}
		else {
			return s1-s2;
		}
		$inc text1 
		$inc text2
	}
	return 0;
}
 
 
inline fastcall streq(ESI, EDI)
{
	loop()
	{
		if(DSBYTE[ESI]==DSBYTE[EDI])
		{
			if(DSBYTE[ESI]==0) return true;
		}
		else {
			return false;
		}
		ESI++;
		EDI++;
	}
	return true;
}
 
inline fastcall void strcpy( EDI, ESI)
{
    $cld
L2:
    $lodsb
    $stosb
    $test al,al
    $jnz L2
}
 
inline fastcall int strlcpy(dword ESI, EDI, EBX)
{
    if (EBX<0) return -1;
    EDX=0;
    do {
        DSBYTE[ESI]=DSBYTE[EDI];
        ESI++;
        EDI++;
        EDX++;
        if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
    } while(DSBYTE[EDI-1]!='\0');
    return 0;
}
 
:void strncpy(dword dst, src, len)
{
	while (len) && (ESBYTE[src])
	{
		ESBYTE[dst] = ESBYTE[src];
		dst++;
		src++;
		len--;
	}
	ESBYTE[dst]=0;
}
 
/*
inline fastcall void strtrim( ESI)
{
    EDI = ESI;
    do{
        AL=DSBYTE[EDI];
        if (AL != '\32') && (AL != '\13') && (AL != '\10')
        {
            DSBYTE[ESI]=AL;
            $inc ESI
        }
         $inc EDI
    }while(AL!=0);
    DSBYTE[ESI] = '\0';
}
*/
 
inline byte __isWhite(int s){ if (s==13)||(s==32)||(s==10)||(s==9) return true; return false; }
inline void strltrim(dword text){
	int s;
	dword back_text;
	back_text = text;
	s = ESBYTE[text];
	while(__isWhite(s))
	{
		$inc text
		s = ESBYTE[text];
	}
	loop()
	{
		ESBYTE[back_text] = s;
		$inc back_text
		if(!s) break;
		$inc text
		s = ESBYTE[text];
	};
}
 
inline void strrtrim(dword text)
{
	int s;
	dword p;
	do {
		s = ESBYTE[text];
		if(__isWhite(s))
		{
			p = text;
			while(__isWhite(s))
			{
				$inc text;
				s = ESBYTE[text];
			}
		}
		else $inc text
	} while(s);
	$dec text
	s = ESBYTE[text];
	if(__isWhite(s)) ESBYTE[p] = 0;
}
 
inline void strtrim(dword text){
	int s;
	dword p,back_text;
	back_text = text;
	s = ESBYTE[text];
	while(__isWhite(s))
	{
		$inc text
		s = ESBYTE[text];
	} 
	do {
		s = ESBYTE[text];
		if(__isWhite(s))
		{
			p = back_text;
			while(__isWhite(s))
			{
				ESBYTE[back_text] = s;
				$inc back_text
				$inc text;
				s = ESBYTE[text];
			}
		}
		else {
			ESBYTE[back_text] = s;
			$inc back_text
			$inc text
		}
	} while(s);
	$dec text
	s = ESBYTE[text];
	if(__isWhite(s)) ESBYTE[p] = 0;
}
 
inline fastcall void strcat( EDI, ESI)
{
  asm {
    mov ebx, edi
    xor ecx, ecx
    xor eax, eax
    dec ecx
    repne scasb
    dec edi
    mov edx, edi
    mov edi, esi
    xor ecx, ecx
    xor eax, eax
    dec ecx
    repne scasb
    xor ecx, 0ffffffffh
    mov edi, edx
    mov edx, ecx
    mov eax, edi
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    mov eax, ebx
    }
}
 
:void strncat(dword dst, src, len)
{
	while (ESBYTE[dst]) && (len) {
		dst++;
		len--;
	}
	while (ESBYTE[src]) && (len>1) {
		ESBYTE[dst] = ESBYTE[src];
		dst++;
		src++;
		len--;
	}
	ESBYTE[dst] = 0;
}
 
:void chrncat(dword dst, unsigned char s, dword len)
{
	while (ESBYTE[dst]) && (len) {
		dst++;
		len--;
	}
	if (len>1) {
		ESBYTE[dst] = s;
		ESBYTE[dst+1] = 0;
	}
}
 
inline fastcall void chrcat(ESI, DI)
{
    while (ESBYTE[ESI]) ESI++;
    ESBYTE[ESI] = DI;
    ESI++;
    ESBYTE[ESI] = 0;
}
 
inline dword strchr(dword shb;char s)
{
	char ss;
	loop()
	{
		ss = DSBYTE[shb];
		if(!ss)return 0;
		if(ss==s)return shb;
		shb++;
	}
}
 
inline fastcall signed int strrchr( ESI,BL)
{
    int jj=0, last=0;
    do{
        jj++;
        $lodsb
        IF(AL==BL) last=jj;
    } while(AL!=0);
    return last;
}
 
 
inline fastcall unsigned int chrnum( ESI, BL)
{
    int num = 0;
    while(DSBYTE[ESI])
    { 
        if (DSBYTE[ESI] == BL) num++;
        ESI++;
    }
    return num;
}
 
 
inline fastcall signed int strstr( EBX, EDX)
{
  asm {
    MOV EDI, EDX
    XOR ECX, ECX
    XOR EAX, EAX
    DEC ECX
    REPNE SCASB
    NOT ECX
    DEC ECX
    JE LS2
    MOV ESI, ECX
    XOR ECX, ECX
    MOV EDI, EBX
    DEC ECX
    REPNE SCASB
    NOT ECX
    SUB ECX, ESI
    JBE LS2
    MOV EDI, EBX
    LEA EBX, DSDWORD[ ESI-1]
LS1: MOV ESI, EDX
    LODSB
    REPNE SCASB
    JNE LS2
    MOV EAX, ECX
    PUSH EDI
    MOV ECX, EBX
    REPE CMPSB
    POP EDI
    MOV ECX, EAX
    JNE LS1
    LEA EAX, DSDWORD[ EDI-1]
    JMP SHORT LS3
LS2: XOR EAX, EAX
LS3:
  }
}
 
inline dword strcmpi(dword cmp1, cmp2)
{
    char si, ue;
 
    loop()
    { 
        si = DSBYTE[cmp1];
        ue = DSBYTE[cmp2];
        if (si>='A') && (si<='Z') si +=32;
        if (ue>='A') && (ue<='Z') ue +=32;
        if (si != ue) return -1;
        cmp1++;
        cmp2++;
        if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
        if (DSBYTE[cmp1]=='\0') return -1;
        if (DSBYTE[cmp2]=='\0') return 1;
    }
}
 
inline dword strstri(dword searchin, usestr_s)
{
    dword usestr_e = usestr_s;
    char si, ue;
 
    while(DSBYTE[searchin])
    { 
        si = DSBYTE[searchin];
        ue = DSBYTE[usestr_e];
        if (si>='A') && (si<='Z') si +=32;
        if (ue>='A') && (ue<='Z') ue +=32;
        if (si == ue) usestr_e++; else usestr_e = usestr_s;
        searchin++;
        if (DSBYTE[usestr_e]=='\0') return searchin;
    }
    return -1;
}
 
 
inline unsigned int strcpyb(dword search_in, copyin, startstr, endstr)
{
    dword startp, endp;
    dword copyin_start_off = copyin;
    if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);
    endp = strstri(startp, endstr);
    if (endp==0) endp = startp+strlen(search_in);
    //if (startp==endp) return 0;
    do
    { 
        DSBYTE[copyin] = DSBYTE[startp];
        copyin++;
        startp++;
    }
    while (startp
    DSBYTE[copyin] = '\0';
    return copyin_start_off;
}
 
 
/*void strcat(char *to, char *from) 
{
    while(*to) to++;
    while(*from)
    {
        *to = *from;
        to++;
        from++;
    }
    *to = '\0';
}*/
 
 
inline fastcall dword atoi( EDI)
{
    $push ebx
    $push esi
    ESI=EDI;
    while (DSBYTE[ESI]==' ') ESI++;
    if (DSBYTE[ESI]=='-') ESI++;
    EAX=0;
    while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
    {
        $xor ebx, ebx
        EBX = DSBYTE[ESI]-'0';
        EAX *= 10;
        EAX += EBX;
        ESI++;
    } 
    IF (DSBYTE[EDI]=='-') -EAX;
    $pop esi
    $pop ebx
}
 
 
 
inline fastcall strupr( ESI)
{
    do{
        AL=DSBYTE[ESI];
        IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
        IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;    //à-ï
        IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;    //à-ï
         ESI++;
    }while(AL!=0);
}
 
inline fastcall strlwr( ESI)
{
    do{
        $LODSB
        IF(AL>='A')&&(AL<='Z'){
            AL+=0x20;
            DSBYTE[ESI-1]=AL;
            CONTINUE;
        }
    }while(AL!=0);
}
 
inline fastcall strttl( EDX)
{
    AL=DSBYTE[EDX];
    IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
    IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;    //à-ï
    IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;    //à-ï
    do{
        EDX++;
        AL=DSBYTE[EDX];
        IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
        IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL|0x20; // -¯
        IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;    //à-ï
    }while(AL!=0);
}
 
/*
dword itoa( ESI)
{
    unsigned char buffer[11];
    $pusha
    EDI = #buffer;
    ECX = 10;
    if (ESI < 0)
    {
         $mov     al, '-'
         $stosb
         $neg     esi
    }
 
    $mov     eax, esi
    $push    -'0'
F2:
    $xor     edx, edx
    $div     ecx
    $push    edx
    $test    eax, eax
    $jnz     F2
F3:
    $pop     eax
    $add     al, '0'
    $stosb
    $jnz     F3
    
    $mov     al, '\0'
    $stosb
 
    $popa
    return #buffer;
}
*/
:unsigned char BUF_ITOA[11];
inline dword itoa(signed long number)
{
	dword ret,p;
	byte cmd;
	long mask,tmp;
	mask = 1000000000;
	cmd = true;
	p = #BUF_ITOA;
	if(!number){
		ESBYTE[p] = '0';
		ESBYTE[p+1] = 0;
		return p;
	}
	ret = p;
	if(number<0)
	{
		$neg number
		ESBYTE[p] = '-';
		$inc p
	}
	while(mask)
	{
		tmp = number / mask;
		tmp = tmp%10;
		
		if(cmd){
			if(tmp){
				ESBYTE[p] = tmp + '0';
				$inc p
				cmd = false;
			}
		}
		else {
			ESBYTE[p] = tmp + '0';
			$inc p
		}
		mask /= 10;
	}
	ESBYTE[p] = 0;
	return ret;
}
 
inline fastcall itoa_(signed int EDI, ESI)
{
    $pusha
    EBX = EDI;
    ECX = 10;
    if (ESI > 90073741824)
    {
         $mov     al, '-'
         $stosb
         $neg     esi
    }
 
    $mov     eax, esi
    $push    -'0'
F2:
    $xor     edx, edx
    $div     ecx
    $push    edx
    $test    eax, eax
    $jnz     F2
F3:
    $pop     eax
    $add     al, '0'
    $stosb
    $jnz     F3
    
    $mov     al, '\0'
    $stosb
 
    $popa
    return EBX;
} 
 
inline dword memchr(dword s,int c,signed len)
{
	if(!len) return NULL;
	do {
		if(DSBYTE[s] == c) return s;
		$inc s
		$dec len
	} while(len);
	return NULL;
}
 
inline dword strdup(dword text)
{
    dword l = strlen(text);
    dword ret = malloc(l+1);
	if(!ret) return NULL;
    strlcpy(ret,text,l);
    return ret;
}
 
inline dword strndup(dword str, signed maxlen)
{
	dword copy,len;
 
	len = strnlen(str, maxlen);
	copy = malloc(len + 1);
	if (copy != NULL)
	{
		strlcpy(copy, str, len);
		DSBYTE[len+copy] = '\0';
	}
	return copy;
}
 
inline dword hexdec(dword text)
{
	char s;
	dword ret,l;
	ret = 0;
	s = DSBYTE[text];
	while(s)
	{	
		ret <<= 4;
		if(s>='A')&&(s<='F')ret |= s-'A'+10;
		else if(s>='a')&&(s<='f')ret |= s-'a'+10;
		else if(s>='0')&&(s<='9')ret |= s-'0';
		text++;
		s = DSBYTE[text];
	}
	return ret;
}
 
inline signed csshexdec(dword text)
{
	char s;
	dword ret,l;
	byte tmp;
	l = strlen(text);
	ret = 0;
	s = DSBYTE[text];
	tmp = 0;
	if(l==6) while(s)
	{	
		ret <<= 4;
		if(s>='A')&&(s<='F')ret |= s-'A'+10;
		else if(s>='a')&&(s<='f')ret |= s-'a'+10;
		else if(s>='0')&&(s<='9')ret |= s-'0';
		text++;
		s = DSBYTE[text];
	}
	else if(l==3) while(s)
	{	
		ret |= tmp;
		ret <<= 4;
		ret |= tmp;
		ret <<= 4;
		if(s>='A')&&(s<='F')tmp = s-'A'+10;
		else if(s>='a')&&(s<='f')tmp = s-'a'+10;
		else if(s>='0')&&(s<='9')tmp = s-'0';
		text++;
		s = DSBYTE[text];
	}
	return ret;
}
 
inline cdecl int sprintf(dword buf, format,...)
{
	#define END_ARGS 0xFF00FF //ARGS FUNCTION
	byte s;
	char X[10];
	dword ret, tmp, l;
	dword arg = #format;
	ret = buf;
	s = DSBYTE[format];
	while(s){
		if(s=='%'){
			arg+=4;
			tmp = DSDWORD[arg];
			if(tmp==END_ARGS)goto END_FUNC_SPRINTF;
			$inc format
			s = DSBYTE[format];
			if(!s)goto END_FUNC_SPRINTF;
			switch(s)
			{
				case 's':
					l = tmp;
					s = DSBYTE[tmp];
					while(s)
					{
						DSBYTE[buf] = s;
						$inc tmp
						$inc buf
						s = DSBYTE[tmp];
					}
				break;
				case 'c':
					DSBYTE[buf] = tmp;
					$inc buf
				break;
				case 'u': //if(tmp<0)return ret;
				case 'd':
				case 'i':
					tmp = itoa(tmp);
					if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
					l = strlen(tmp);
					strlcpy(buf,tmp,l);
					buf += l;
				break;
				case 'a':
				case 'A':
					strlcpy(buf,"0x00000000",10);
					buf+=10;
					l=buf;
					debugval("tmp", tmp);
					while(tmp)
					{
						$dec buf
						s=tmp&0xF;
						if(s>9)DSBYTE[buf]='A'+s-10;
						else DSBYTE[buf]='0'+s;
						tmp>>=4;
					}
					buf=l;
				break;
				case 'p':
					tmp = itoa(#tmp);
					if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
					l = strlen(tmp);
					strlcpy(buf,tmp,l);
					buf += l;
				break;
				case '%':
					DSBYTE[buf] = '%';
					$inc buf
				break;
				default:
				goto END_FUNC_SPRINTF;
			}
		}
		else {
			DSBYTE[buf] = s;
			$inc buf
		}
		$inc format
		s = DSBYTE[format];
	}
	END_FUNC_SPRINTF:
	DSBYTE[buf] = 0;
	return ret;
}
 
inline signed strcoll(dword text1,text2)
{
	char s,ss;
	loop()
	{
		s = DSBYTE[text2];
		ss=strchr(text1,s);
		if(ss)return ss;
		text2++;
	}
	return 0;
}
 
// void * memset( ptr, value, num );
// fills the memory with a dword
// example: memset(str,'-', sizeof(str));
inline void MEMSETD(EDI,ECX,EAX)
{
	$REP 
	$STOSD
}
 
:replace_char(dword in_str, char from_char, to_char, int length) {
	int i;
	for (i=0; i
		if (ESBYTE[in_str+i] == from_char) ESBYTE[in_str+i] = to_char;
	}
	ESBYTE[in_str+length]=0;
}
 
#endif
>
>
>
>
>
>

Rev 7764	Rev 7768
1	#ifndef INCLUDE_STRING_H	1	#ifndef INCLUDE_STRING_H
2	#define INCLUDE_STRING_H	2	#define INCLUDE_STRING_H
3		3
4	#ifndef INCLUDE_MEM_H	4	#ifndef INCLUDE_MEM_H
5	#include "../lib/mem.h"	5	#include "../lib/mem.h"
6	#endif	6	#endif
7		7
8	//------------------------------------------------------------------------------	8	//------------------------------------------------------------------------------
9	// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2	9	// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2
10	// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"	10	// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"
11	// strcmp( ESI, EDI)	11	// strcmp( ESI, EDI)
12	// strlen( EDI)	12	// strlen( EDI)
13	// utf8_strlen( ESI)	13	// utf8_strlen( ESI)
14	// strcpy( EDI, ESI) --- 0 if ==	14	// strcpy( EDI, ESI) --- 0 if ==
15	// strlcpy(dword text1,text2,signed length)	15	// strlcpy(dword text1,text2,signed length)
16	// strcat( EDI, ESI)	16	// strcat( EDI, ESI)
17	// chrcat(ESI, BL)	17	// chrcat(ESI, BL)
18	// strncat(dword text1,text2,signed length) --- pasting the text of a certain length	18	// strncat(dword text1,text2,signed length) --- pasting the text of a certain length
19	// strchr( ESI,BL) --- find first BL	19	// strchr( ESI,BL) --- find first BL
20	// strrchr( ESI,BL) --- find last BL	20	// strrchr( ESI,BL) --- find last BL
21	// strstr( EBX, EDX)	21	// strstr( EBX, EDX)
22	// itoa(signed long number) --- convert the number as a string	22	// itoa(signed long number) --- convert the number as a string
23	// atoi(dword text) --- convert a string as a number	23	// atoi(dword text) --- convert a string as a number
24	// strupr( ESI)	24	// strupr( ESI)
25	// strlwr( ESI) --- Cyrillic symbols may not work	25	// strlwr( ESI) --- Cyrillic symbols may not work
26	// strttl( EDX)	26	// strttl( EDX)
27	// strtok( ESI)	27	// strtok( ESI)
28	// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)	28	// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)
29	// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)	29	// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)
30	// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides	30	// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides
31	// chrnum(dword searchin, char symbol)	31	// chrnum(dword searchin, char symbol)
32	// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings	32	// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
33	// strnumb(dword searchin, startstr, endstr) --- get number between strings	33	// strnumb(dword searchin, startstr, endstr) --- get number between strings
34	// strdup(dword text) --- allocation under the text	34	// strdup(dword text) --- allocation under the text
35	//------------------------------------------------------------------------------	35	//------------------------------------------------------------------------------
36		36
37	/*	37	/*
38	inline fastcall signed int strcmp( ESI, EDI)	38	inline fastcall signed int strcmp( ESI, EDI)
39	{	39	{
40	loop()	40	loop()
41	{	41	{
42	IF (DSBYTE[ESI]	42	IF (DSBYTE[ESI]
43	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;	43	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
44	IF (DSBYTE[ESI]=='\0') RETURN 0;	44	IF (DSBYTE[ESI]=='\0') RETURN 0;
45	ESI++;	45	ESI++;
46	EDI++;	46	EDI++;
47	}	47	}
48	}	48	}
49	*/	49	*/
50		50
51		51
52		52
53	inline int strspn(dword text1,text2)	53	inline int strspn(dword text1,text2)
54	{	54	{
55	dword beg;	55	dword beg;
56	char s1,s2;	56	char s1,s2;
57	int ret;	57	int ret;
58	ret = 0;	58	ret = 0;
59	beg = text2;	59	beg = text2;
60	do {	60	do {
61	s1 = ESBYTE[text1];	61	s1 = ESBYTE[text1];
62	text2 = beg;	62	text2 = beg;
63	do {	63	do {
64	s2 = ESBYTE[text2];	64	s2 = ESBYTE[text2];
65	if(s1==s2)	65	if(s1==s2)
66	{	66	{
67	if(!s2)break;	67	if(!s2)break;
68	$inc ret	68	$inc ret
69	break;	69	break;
70	}	70	}
71	else $inc text2	71	else $inc text2
72	} while(s2);	72	} while(s2);
73	$inc text1	73	$inc text1
74	} while(s1);	74	} while(s1);
75	return ret;	75	return ret;
76	}	76	}
77		77
78	inline dword strpbrk(dword text1,text2)	78	inline dword strpbrk(dword text1,text2)
79	{	79	{
80	char s,ss;	80	char s,ss;
81	dword beg;	81	dword beg;
82	beg = text2;	82	beg = text2;
83	do {	83	do {
84	s = ESBYTE[text1];	84	s = ESBYTE[text1];
85	text2 = beg;	85	text2 = beg;
86	do {	86	do {
87	ss = ESBYTE[text2];	87	ss = ESBYTE[text2];
88	if(ss==s) return text1;	88	if(ss==s) return text1;
89	$inc text2	89	$inc text2
90	} while(ss);	90	} while(ss);
91	$inc text1	91	$inc text1
92	} while(s);	92	} while(s);
93	return text1;	93	return text1;
94	}	94	}
95		95
96	inline fastcall signed int strncmp( ESI, EDI, ECX)	96	inline fastcall signed int strncmp( ESI, EDI, ECX)
97	{	97	{
98	asm {	98	asm {
99	MOV EBX, EDI	99	MOV EBX, EDI
100	XOR EAX, EAX	100	XOR EAX, EAX
101	MOV EDX, ECX	101	MOV EDX, ECX
102	OR ECX, ECX	102	OR ECX, ECX
103	JE L1	103	JE L1
104	REPNE SCASB	104	REPNE SCASB
105	SUB EDX, ECX	105	SUB EDX, ECX
106	MOV ECX, EDX	106	MOV ECX, EDX
107	MOV EDI, EBX	107	MOV EDI, EBX
108	XOR EBX, EBX	108	XOR EBX, EBX
109	REPE CMPSB	109	REPE CMPSB
110	MOV AL, DSBYTE[ ESI-1]	110	MOV AL, DSBYTE[ ESI-1]
111	MOV BL, DSBYTE[ EDI-1]	111	MOV BL, DSBYTE[ EDI-1]
112	SUB EAX, EBX	112	SUB EAX, EBX
113	L1:	113	L1:
114	}	114	}
115	}	115	}
116		116
117	/*	117	/*
118	signed int strncmp(dword s1, s2, signed n)	118	signed int strncmp(dword s1, s2, signed n)
119	unsigned char _s1,_s2;	119	unsigned char _s1,_s2;
120	{	120	{
121	if (n == 0)	121	if (n == 0)
122	return 0;	122	return 0;
123	do {	123	do {
124	_s1 = DSBYTE[s1];	124	_s1 = DSBYTE[s1];
125	_s2 = DSBYTE[s2];	125	_s2 = DSBYTE[s2];
126	if (_s1 != _s2)	126	if (_s1 != _s2)
127	{	127	{
128	$dec s2	128	$dec s2
129	return _s1 - _s2;	129	return _s1 - _s2;
130	}	130	}
131	$inc s2	131	$inc s2
132	if (_s1 == 0)	132	if (_s1 == 0)
133	break;	133	break;
134	$inc s1	134	$inc s1
135	$dec n	135	$dec n
136	} while (n);	136	} while (n);
137	return 0;	137	return 0;
138	}	138	}
139	*/	139	*/
140		140
141	/*	141	/*
142	inline signed int strncmp(dword text1,text2,len)	142	inline signed int strncmp(dword text1,text2,len)
143	{	143	{
144		144
145	loop()	145	loop()
146	{	146	{
147	if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;	147	if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
148	$dec len	148	$dec len
149	if(!len)return 0;	149	if(!len)return 0;
150	}	150	}
151	}	151	}
152	*/	152	*/
153	inline fastcall unsigned int strlen( EDI)	153	inline fastcall unsigned int strlen( EDI)
154	{	154	{
155	$xor eax, eax	155	$xor eax, eax
156	$mov ecx, -1	156	$mov ecx, -1
157	$REPNE $SCASB	157	$REPNE $SCASB
158	EAX-=2+ECX;	158	EAX-=2+ECX;
159	}	159	}
160		160
161	inline dword strnlen(dword str, dword maxlen)	161	inline dword strnlen(dword str, dword maxlen)
162	{	162	{
163	dword cp;	163	dword cp;
164	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);	164	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
165	return cp - str;	165	return cp - str;
166	}	166	}
167		167
168	inline fastcall unsigned int utf8_strlen( ESI)	168	inline fastcall unsigned int utf8_strlen( ESI)
169	{	169	{
170	$xor ecx, ecx	170	$xor ecx, ecx
171	_loop:	171	_loop:
172	$lodsb	172	$lodsb
173	$test al, al	173	$test al, al
174	$jz _done	174	$jz _done
175	$and al, 0xc0	175	$and al, 0xc0
176	$cmp al, 0x80	176	$cmp al, 0x80
177	$jz _loop	177	$jz _loop
178	$inc ecx	178	$inc ecx
179	$jmp _loop	179	$jmp _loop
180		180
181	_done:	181	_done:
182	return ECX;	182	return ECX;
183	}	183	}
184		184
185	inline signed int strcmp(dword text1, text2)	185	inline signed int strcmp(dword text1, text2)
186	{	186	{
187	char s1,s2;	187	char s1,s2;
188	dword p1,p2;	188	dword p1,p2;
189	p1 = text1;	189	p1 = text1;
190	p2 = text2;	190	p2 = text2;
191	loop()	191	loop()
192	{	192	{
193	s1 = DSBYTE[text1];	193	s1 = DSBYTE[text1];
194	s2 = DSBYTE[text2];	194	s2 = DSBYTE[text2];
195	if(s1==s2)	195	if(s1==s2)
196	{	196	{
197	if(s1==0) return 0;	197	if(s1==0) return 0;
198	}	198	}
199	else {	199	else {
200	return s1-s2;	200	return s1-s2;
201	}	201	}
202	$inc text1	202	$inc text1
203	$inc text2	203	$inc text2
204	}	204	}
205	return 0;	205	return 0;
206	}	206	}
207		207
208		208
209	inline fastcall streq(ESI, EDI)	209	inline fastcall streq(ESI, EDI)
210	{	210	{
211	loop()	211	loop()
212	{	212	{
213	if(DSBYTE[ESI]==DSBYTE[EDI])	213	if(DSBYTE[ESI]==DSBYTE[EDI])
214	{	214	{
215	if(DSBYTE[ESI]==0) return true;	215	if(DSBYTE[ESI]==0) return true;
216	}	216	}
217	else {	217	else {
218	return false;	218	return false;
219	}	219	}
220	ESI++;	220	ESI++;
221	EDI++;	221	EDI++;
222	}	222	}
223	return true;	223	return true;
224	}	224	}
225		225
226	inline fastcall void strcpy( EDI, ESI)	226	inline fastcall void strcpy( EDI, ESI)
227	{	227	{
228	$cld	228	$cld
229	L2:	229	L2:
230	$lodsb	230	$lodsb
231	$stosb	231	$stosb
232	$test al,al	232	$test al,al
233	$jnz L2	233	$jnz L2
234	}	234	}
235		235
236	inline fastcall int strlcpy(dword ESI, EDI, EBX)	236	inline fastcall int strlcpy(dword ESI, EDI, EBX)
237	{	237	{
238	if (EBX<0) return -1;	238	if (EBX<0) return -1;
239	EDX=0;	239	EDX=0;
240	do {	240	do {
241	DSBYTE[ESI]=DSBYTE[EDI];	241	DSBYTE[ESI]=DSBYTE[EDI];
242	ESI++;	242	ESI++;
243	EDI++;	243	EDI++;
244	EDX++;	244	EDX++;
245	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}	245	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
246	} while(DSBYTE[EDI-1]!='\0');	246	} while(DSBYTE[EDI-1]!='\0');
247	return 0;	247	return 0;
248	}	248	}
249		249
250	:void strncpy(dword dst, src, len)	250	:void strncpy(dword dst, src, len)
251	{	251	{
252	while (len) && (ESBYTE[src])	252	while (len) && (ESBYTE[src])
253	{	253	{
254	ESBYTE[dst] = ESBYTE[src];	254	ESBYTE[dst] = ESBYTE[src];
255	dst++;	255	dst++;
256	src++;	256	src++;
257	len--;	257	len--;
258	}	258	}
259	ESBYTE[dst]=0;	259	ESBYTE[dst]=0;
260	}	260	}
261		261
262	/*	262	/*
263	inline fastcall void strtrim( ESI)	263	inline fastcall void strtrim( ESI)
264	{	264	{
265	EDI = ESI;	265	EDI = ESI;
266	do{	266	do{
267	AL=DSBYTE[EDI];	267	AL=DSBYTE[EDI];
268	if (AL != '\32') && (AL != '\13') && (AL != '\10')	268	if (AL != '\32') && (AL != '\13') && (AL != '\10')
269	{	269	{
270	DSBYTE[ESI]=AL;	270	DSBYTE[ESI]=AL;
271	$inc ESI	271	$inc ESI
272	}	272	}
273	$inc EDI	273	$inc EDI
274	}while(AL!=0);	274	}while(AL!=0);
275	DSBYTE[ESI] = '\0';	275	DSBYTE[ESI] = '\0';
276	}	276	}
277	*/	277	*/
278		278
279	inline byte __isWhite(int s){ if (s==13)\|\|(s==32)\|\|(s==10)\|\|(s==9) return true; return false; }	279	inline byte __isWhite(int s){ if (s==13)\|\|(s==32)\|\|(s==10)\|\|(s==9) return true; return false; }
280	inline void strltrim(dword text){	280	inline void strltrim(dword text){
281	int s;	281	int s;
282	dword back_text;	282	dword back_text;
283	back_text = text;	283	back_text = text;
284	s = ESBYTE[text];	284	s = ESBYTE[text];
285	while(__isWhite(s))	285	while(__isWhite(s))
286	{	286	{
287	$inc text	287	$inc text
288	s = ESBYTE[text];	288	s = ESBYTE[text];
289	}	289	}
290	loop()	290	loop()
291	{	291	{
292	ESBYTE[back_text] = s;	292	ESBYTE[back_text] = s;
293	$inc back_text	293	$inc back_text
294	if(!s) break;	294	if(!s) break;
295	$inc text	295	$inc text
296	s = ESBYTE[text];	296	s = ESBYTE[text];
297	};	297	};
298	}	298	}
299		299
300	inline void strrtrim(dword text)	300	inline void strrtrim(dword text)
301	{	301	{
302	int s;	302	int s;
303	dword p;	303	dword p;
304	do {	304	do {
305	s = ESBYTE[text];	305	s = ESBYTE[text];
306	if(__isWhite(s))	306	if(__isWhite(s))
307	{	307	{
308	p = text;	308	p = text;
309	while(__isWhite(s))	309	while(__isWhite(s))
310	{	310	{
311	$inc text;	311	$inc text;
312	s = ESBYTE[text];	312	s = ESBYTE[text];
313	}	313	}
314	}	314	}
315	else $inc text	315	else $inc text
316	} while(s);	316	} while(s);
317	$dec text	317	$dec text
318	s = ESBYTE[text];	318	s = ESBYTE[text];
319	if(__isWhite(s)) ESBYTE[p] = 0;	319	if(__isWhite(s)) ESBYTE[p] = 0;
320	}	320	}
321		321
322	inline void strtrim(dword text){	322	inline void strtrim(dword text){
323	int s;	323	int s;
324	dword p,back_text;	324	dword p,back_text;
325	back_text = text;	325	back_text = text;
326	s = ESBYTE[text];	326	s = ESBYTE[text];
327	while(__isWhite(s))	327	while(__isWhite(s))
328	{	328	{
329	$inc text	329	$inc text
330	s = ESBYTE[text];	330	s = ESBYTE[text];
331	}	331	}
332	do {	332	do {
333	s = ESBYTE[text];	333	s = ESBYTE[text];
334	if(__isWhite(s))	334	if(__isWhite(s))
335	{	335	{
336	p = back_text;	336	p = back_text;
337	while(__isWhite(s))	337	while(__isWhite(s))
338	{	338	{
339	ESBYTE[back_text] = s;	339	ESBYTE[back_text] = s;
340	$inc back_text	340	$inc back_text
341	$inc text;	341	$inc text;
342	s = ESBYTE[text];	342	s = ESBYTE[text];
343	}	343	}
344	}	344	}
345	else {	345	else {
346	ESBYTE[back_text] = s;	346	ESBYTE[back_text] = s;
347	$inc back_text	347	$inc back_text
348	$inc text	348	$inc text
349	}	349	}
350	} while(s);	350	} while(s);
351	$dec text	351	$dec text
352	s = ESBYTE[text];	352	s = ESBYTE[text];
353	if(__isWhite(s)) ESBYTE[p] = 0;	353	if(__isWhite(s)) ESBYTE[p] = 0;
354	}	354	}
355		355
356	inline fastcall void strcat( EDI, ESI)	356	inline fastcall void strcat( EDI, ESI)
357	{	357	{
358	asm {	358	asm {
359	mov ebx, edi	359	mov ebx, edi
360	xor ecx, ecx	360	xor ecx, ecx
361	xor eax, eax	361	xor eax, eax
362	dec ecx	362	dec ecx
363	repne scasb	363	repne scasb
364	dec edi	364	dec edi
365	mov edx, edi	365	mov edx, edi
366	mov edi, esi	366	mov edi, esi
367	xor ecx, ecx	367	xor ecx, ecx
368	xor eax, eax	368	xor eax, eax
369	dec ecx	369	dec ecx
370	repne scasb	370	repne scasb
371	xor ecx, 0ffffffffh	371	xor ecx, 0ffffffffh
372	mov edi, edx	372	mov edi, edx
373	mov edx, ecx	373	mov edx, ecx
374	mov eax, edi	374	mov eax, edi
375	shr ecx, 2	375	shr ecx, 2
376	rep movsd	376	rep movsd
377	mov ecx, edx	377	mov ecx, edx
378	and ecx, 3	378	and ecx, 3
379	rep movsb	379	rep movsb
380	mov eax, ebx	380	mov eax, ebx
381	}	381	}
382	}	382	}
383		383
384	:void strncat(dword dst, src, len)	384	:void strncat(dword dst, src, len)
385	{	385	{
386	while (ESBYTE[dst]) && (len) {	386	while (ESBYTE[dst]) && (len) {
387	dst++;	387	dst++;
388	len--;	388	len--;
389	}	389	}
390	while (ESBYTE[src]) && (len>1) {	390	while (ESBYTE[src]) && (len>1) {
391	ESBYTE[dst] = ESBYTE[src];	391	ESBYTE[dst] = ESBYTE[src];
392	dst++;	392	dst++;
393	src++;	393	src++;
394	len--;	394	len--;
395	}	395	}
396	ESBYTE[dst] = 0;	396	ESBYTE[dst] = 0;
397	}	397	}
398		398
399	:void chrncat(dword dst, unsigned char s, dword len)	399	:void chrncat(dword dst, unsigned char s, dword len)
400	{	400	{
401	while (ESBYTE[dst]) && (len) {	401	while (ESBYTE[dst]) && (len) {
402	dst++;	402	dst++;
403	len--;	403	len--;
404	}	404	}
405	if (len>1) {	405	if (len>1) {
406	ESBYTE[dst] = s;	406	ESBYTE[dst] = s;
407	ESBYTE[dst+1] = 0;	407	ESBYTE[dst+1] = 0;
408	}	408	}
409	}	409	}
410		410
411	inline fastcall void chrcat(ESI, DI)	411	inline fastcall void chrcat(ESI, DI)
412	{	412	{
413	while (ESBYTE[ESI]) ESI++;	413	while (ESBYTE[ESI]) ESI++;
414	ESBYTE[ESI] = DI;	414	ESBYTE[ESI] = DI;
415	ESI++;	415	ESI++;
416	ESBYTE[ESI] = 0;	416	ESBYTE[ESI] = 0;
417	}	417	}
418		418
419	inline dword strchr(dword shb;char s)	419	inline dword strchr(dword shb;char s)
420	{	420	{
421	char ss;	421	char ss;
422	loop()	422	loop()
423	{	423	{
424	ss = DSBYTE[shb];	424	ss = DSBYTE[shb];
425	if(!ss)return 0;	425	if(!ss)return 0;
426	if(ss==s)return shb;	426	if(ss==s)return shb;
427	shb++;	427	shb++;
428	}	428	}
429	}	429	}
430		430
431	inline fastcall signed int strrchr( ESI,BL)	431	inline fastcall signed int strrchr( ESI,BL)
432	{	432	{
433	int jj=0, last=0;	433	int jj=0, last=0;
434	do{	434	do{
435	jj++;	435	jj++;
436	$lodsb	436	$lodsb
437	IF(AL==BL) last=jj;	437	IF(AL==BL) last=jj;
438	} while(AL!=0);	438	} while(AL!=0);
439	return last;	439	return last;
440	}	440	}
441		441
442		442
443	inline fastcall unsigned int chrnum( ESI, BL)	443	inline fastcall unsigned int chrnum( ESI, BL)
444	{	444	{
445	int num = 0;	445	int num = 0;
446	while(DSBYTE[ESI])	446	while(DSBYTE[ESI])
447	{	447	{
448	if (DSBYTE[ESI] == BL) num++;	448	if (DSBYTE[ESI] == BL) num++;
449	ESI++;	449	ESI++;
450	}	450	}
451	return num;	451	return num;
452	}	452	}
453		453
454		454
455	inline fastcall signed int strstr( EBX, EDX)	455	inline fastcall signed int strstr( EBX, EDX)
456	{	456	{
457	asm {	457	asm {
458	MOV EDI, EDX	458	MOV EDI, EDX
459	XOR ECX, ECX	459	XOR ECX, ECX
460	XOR EAX, EAX	460	XOR EAX, EAX
461	DEC ECX	461	DEC ECX
462	REPNE SCASB	462	REPNE SCASB
463	NOT ECX	463	NOT ECX
464	DEC ECX	464	DEC ECX
465	JE LS2	465	JE LS2
466	MOV ESI, ECX	466	MOV ESI, ECX
467	XOR ECX, ECX	467	XOR ECX, ECX
468	MOV EDI, EBX	468	MOV EDI, EBX
469	DEC ECX	469	DEC ECX
470	REPNE SCASB	470	REPNE SCASB
471	NOT ECX	471	NOT ECX
472	SUB ECX, ESI	472	SUB ECX, ESI
473	JBE LS2	473	JBE LS2
474	MOV EDI, EBX	474	MOV EDI, EBX
475	LEA EBX, DSDWORD[ ESI-1]	475	LEA EBX, DSDWORD[ ESI-1]
476	LS1: MOV ESI, EDX	476	LS1: MOV ESI, EDX
477	LODSB	477	LODSB
478	REPNE SCASB	478	REPNE SCASB
479	JNE LS2	479	JNE LS2
480	MOV EAX, ECX	480	MOV EAX, ECX
481	PUSH EDI	481	PUSH EDI
482	MOV ECX, EBX	482	MOV ECX, EBX
483	REPE CMPSB	483	REPE CMPSB
484	POP EDI	484	POP EDI
485	MOV ECX, EAX	485	MOV ECX, EAX
486	JNE LS1	486	JNE LS1
487	LEA EAX, DSDWORD[ EDI-1]	487	LEA EAX, DSDWORD[ EDI-1]
488	JMP SHORT LS3	488	JMP SHORT LS3
489	LS2: XOR EAX, EAX	489	LS2: XOR EAX, EAX
490	LS3:	490	LS3:
491	}	491	}
492	}	492	}
493		493
494	inline dword strcmpi(dword cmp1, cmp2)	494	inline dword strcmpi(dword cmp1, cmp2)
495	{	495	{
496	char si, ue;	496	char si, ue;
497		497
498	loop()	498	loop()
499	{	499	{
500	si = DSBYTE[cmp1];	500	si = DSBYTE[cmp1];

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 7764 → 7768