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)
// 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:
  }
}
 
/*
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 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;
}
 
/*
TODO: rewrite streq() using pure assembliy
 
inline fastcall void strcpy( EDI, ESI)
{
    $cld
L2:
    $lodsb
    $stosb
    $test al,al
    $jnz L2
}
*/
 
inline fastcall streq(ESI, EDI)
{
	loop()
	{
		if(DSBYTE[ESI]==DSBYTE[EDI])
		{
			if(DSBYTE[ESI]==0) return true;
		}
		else {
			return false;
		}
		ESI++;
		EDI++;
	}
	return true;
}
 
/*
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 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[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 text1, text2, signed len)
signed o1,o2;
char s;
{
	s = DSBYTE[text1];
	while(s){
		$inc text1
		s = DSBYTE[text1];
	}
	o1 = len/4;
	o2 = len-4*o1;
	while(o1){
		DSDWORD[text1] = DSDWORD[text2];
		text1 += 4;
		text2 += 4;
		$dec o1
	}
	while(o2){
		DSBYTE[text1] = DSBYTE[text2];
		$inc text1 
		$inc text2 
		$dec o2
	}
	DSBYTE[text1] = 0;
}
 
inline fastcall void chrcat(ESI, BL)
{
    EDI = strlen(ESI);
    ESBYTE[ESI+EDI] = BL;
    ESBYTE[ESI+EDI+1] = 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;
					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;
}
 
: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;
}
 
 
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
 
#endif
>
>
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 7163 → 7286