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;
}
 
 
 
 
 
 
#endif
>
>
>
>
>
>

Rev 7506	Rev 7742
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		182
183	/*	183	/*
184	TODO: rewrite streq() using pure assembliy	184	TODO: rewrite streq() using pure assembliy
185		185
186	inline fastcall void strcpy( EDI, ESI)	186	inline fastcall void strcpy( EDI, ESI)
187	{	187	{
188	$cld	188	$cld
189	L2:	189	L2:
190	$lodsb	190	$lodsb
191	$stosb	191	$stosb
192	$test al,al	192	$test al,al
193	$jnz L2	193	$jnz L2
194	}	194	}
195	*/	195	*/
196		196
197	inline fastcall streq(ESI, EDI)	197	inline fastcall streq(ESI, EDI)
198	{	198	{
199	loop()	199	loop()
200	{	200	{
201	if(DSBYTE[ESI]==DSBYTE[EDI])	201	if(DSBYTE[ESI]==DSBYTE[EDI])
202	{	202	{
203	if(DSBYTE[ESI]==0) return true;	203	if(DSBYTE[ESI]==0) return true;
204	}	204	}
205	else {	205	else {
206	return false;	206	return false;
207	}	207	}
208	ESI++;	208	ESI++;
209	EDI++;	209	EDI++;
210	}	210	}
211	return true;	211	return true;
212	}	212	}
213		213
214	/*	214	/*
215	signed int strncmp(dword s1, s2, signed n)	215	signed int strncmp(dword s1, s2, signed n)
216	unsigned char _s1,_s2;	216	unsigned char _s1,_s2;
217	{	217	{
218	if (n == 0)	218	if (n == 0)
219	return 0;	219	return 0;
220	do {	220	do {
221	_s1 = DSBYTE[s1];	221	_s1 = DSBYTE[s1];
222	_s2 = DSBYTE[s2];	222	_s2 = DSBYTE[s2];
223	if (_s1 != _s2)	223	if (_s1 != _s2)
224	{	224	{
225	$dec s2	225	$dec s2
226	return _s1 - _s2;	226	return _s1 - _s2;
227	}	227	}
228	$inc s2	228	$inc s2
229	if (_s1 == 0)	229	if (_s1 == 0)
230	break;	230	break;
231	$inc s1	231	$inc s1
232	$dec n	232	$dec n
233	} while (n);	233	} while (n);
234	return 0;	234	return 0;
235	}	235	}
236	*/	236	*/
237		237
238		238
239	inline fastcall void strcpy( EDI, ESI)	239	inline fastcall void strcpy( EDI, ESI)
240	{	240	{
241	$cld	241	$cld
242	L2:	242	L2:
243	$lodsb	243	$lodsb
244	$stosb	244	$stosb
245	$test al,al	245	$test al,al
246	$jnz L2	246	$jnz L2
247	}	247	}
248		248
249	inline fastcall int strlcpy(dword ESI, EDI, EBX)	249	inline fastcall int strlcpy(dword ESI, EDI, EBX)
250	{	250	{
251	if (EBX<0) return -1;	251	if (EBX<0) return -1;
252	EDX=0;	252	EDX=0;
253	do {	253	do {
254	DSBYTE[ESI]=DSBYTE[EDI];	254	DSBYTE[ESI]=DSBYTE[EDI];
255	ESI++;	255	ESI++;
256	EDI++;	256	EDI++;
257	EDX++;	257	EDX++;
258	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}	258	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
259	} while(DSBYTE[EDI-1]!='\0');	259	} while(DSBYTE[EDI-1]!='\0');
260	return 0;	260	return 0;
261	}	261	}
262		262
263	:void strncpy(dword dst, src, len)	263	:void strncpy(dword dst, src, len)
264	{	264	{
265	while (len)	265	while (len)
266	{	266	{
267	ESBYTE[dst] = ESBYTE[src];	267	ESBYTE[dst] = ESBYTE[src];
268	dst++;	268	dst++;
269	src++;	269	src++;
270	len--;	270	len--;
271	}	271	}
272	ESBYTE[dst]=0;	272	ESBYTE[dst]=0;
273	}	273	}
274		274
275	/*	275	/*
276	inline fastcall void strtrim( ESI)	276	inline fastcall void strtrim( ESI)
277	{	277	{
278	EDI = ESI;	278	EDI = ESI;
279	do{	279	do{
280	AL=DSBYTE[EDI];	280	AL=DSBYTE[EDI];
281	if (AL != '\32') && (AL != '\13') && (AL != '\10')	281	if (AL != '\32') && (AL != '\13') && (AL != '\10')
282	{	282	{
283	DSBYTE[ESI]=AL;	283	DSBYTE[ESI]=AL;
284	$inc ESI	284	$inc ESI
285	}	285	}
286	$inc EDI	286	$inc EDI
287	}while(AL!=0);	287	}while(AL!=0);
288	DSBYTE[ESI] = '\0';	288	DSBYTE[ESI] = '\0';
289	}	289	}
290	*/	290	*/
291		291
292	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; }
293	inline void strltrim(dword text){	293	inline void strltrim(dword text){
294	int s;	294	int s;
295	dword back_text;	295	dword back_text;
296	back_text = text;	296	back_text = text;
297	s = ESBYTE[text];	297	s = ESBYTE[text];
298	while(__isWhite(s))	298	while(__isWhite(s))
299	{	299	{
300	$inc text	300	$inc text
301	s = ESBYTE[text];	301	s = ESBYTE[text];
302	}	302	}
303	loop()	303	loop()
304	{	304	{
305	ESBYTE[back_text] = s;	305	ESBYTE[back_text] = s;
306	$inc back_text	306	$inc back_text
307	if(!s) break;	307	if(!s) break;
308	$inc text	308	$inc text
309	s = ESBYTE[text];	309	s = ESBYTE[text];
310	};	310	};
311	}	311	}
312		312
313	inline void strrtrim(dword text)	313	inline void strrtrim(dword text)
314	{	314	{
315	int s;	315	int s;
316	dword p;	316	dword p;
317	do {	317	do {
318	s = ESBYTE[text];	318	s = ESBYTE[text];
319	if(__isWhite(s))	319	if(__isWhite(s))
320	{	320	{
321	p = text;	321	p = text;
322	while(__isWhite(s))	322	while(__isWhite(s))
323	{	323	{
324	$inc text;	324	$inc text;
325	s = ESBYTE[text];	325	s = ESBYTE[text];
326	}	326	}
327	}	327	}
328	else $inc text	328	else $inc text
329	} while(s);	329	} while(s);
330	$dec text	330	$dec text
331	s = ESBYTE[text];	331	s = ESBYTE[text];
332	if(__isWhite(s)) ESBYTE[p] = 0;	332	if(__isWhite(s)) ESBYTE[p] = 0;
333	}	333	}
334		334
335	inline void strtrim(dword text){	335	inline void strtrim(dword text){
336	int s;	336	int s;
337	dword p,back_text;	337	dword p,back_text;
338	back_text = text;	338	back_text = text;
339	s = ESBYTE[text];	339	s = ESBYTE[text];
340	while(__isWhite(s))	340	while(__isWhite(s))
341	{	341	{
342	$inc text	342	$inc text
343	s = ESBYTE[text];	343	s = ESBYTE[text];
344	}	344	}
345	do {	345	do {
346	s = ESBYTE[text];	346	s = ESBYTE[text];
347	if(__isWhite(s))	347	if(__isWhite(s))
348	{	348	{
349	p = back_text;	349	p = back_text;
350	while(__isWhite(s))	350	while(__isWhite(s))
351	{	351	{
352	ESBYTE[back_text] = s;	352	ESBYTE[back_text] = s;
353	$inc back_text	353	$inc back_text
354	$inc text;	354	$inc text;
355	s = ESBYTE[text];	355	s = ESBYTE[text];
356	}	356	}
357	}	357	}
358	else {	358	else {
359	ESBYTE[back_text] = s;	359	ESBYTE[back_text] = s;
360	$inc back_text	360	$inc back_text
361	$inc text	361	$inc text
362	}	362	}
363	} while(s);	363	} while(s);
364	$dec text	364	$dec text
365	s = ESBYTE[text];	365	s = ESBYTE[text];
366	if(__isWhite(s)) ESBYTE[p] = 0;	366	if(__isWhite(s)) ESBYTE[p] = 0;
367	}	367	}
368		368
369	inline fastcall void strcat( EDI, ESI)	369	inline fastcall void strcat( EDI, ESI)
370	{	370	{
371	asm {	371	asm {
372	mov ebx, edi	372	mov ebx, edi
373	xor ecx, ecx	373	xor ecx, ecx
374	xor eax, eax	374	xor eax, eax
375	dec ecx	375	dec ecx
376	repne scasb	376	repne scasb
377	dec edi	377	dec edi
378	mov edx, edi	378	mov edx, edi
379	mov edi, esi	379	mov edi, esi
380	xor ecx, ecx	380	xor ecx, ecx
381	xor eax, eax	381	xor eax, eax
382	dec ecx	382	dec ecx
383	repne scasb	383	repne scasb
384	xor ecx, 0ffffffffh	384	xor ecx, 0ffffffffh
385	mov edi, edx	385	mov edi, edx
386	mov edx, ecx	386	mov edx, ecx
387	mov eax, edi	387	mov eax, edi
388	shr ecx, 2	388	shr ecx, 2
389	rep movsd	389	rep movsd
390	mov ecx, edx	390	mov ecx, edx
391	and ecx, 3	391	and ecx, 3
392	rep movsb	392	rep movsb
393	mov eax, ebx	393	mov eax, ebx
394	}	394	}
395	}	395	}
396		396
397	:void strncat(dword text1, text2, signed len)	397	:void strncat(dword text1, text2, signed len)
398	signed o1,o2;	398	signed o1,o2;
399	char s;	399	char s;
400	{	400	{
401	s = DSBYTE[text1];	401	s = DSBYTE[text1];
402	while(s){	402	while(s){
403	$inc text1	403	$inc text1
404	s = DSBYTE[text1];	404	s = DSBYTE[text1];
405	}	405	}
406	o1 = len/4;	406	o1 = len/4;
407	o2 = len-4*o1;	407	o2 = len-4*o1;
408	while(o1){	408	while(o1){
409	DSDWORD[text1] = DSDWORD[text2];	409	DSDWORD[text1] = DSDWORD[text2];
410	text1 += 4;	410	text1 += 4;
411	text2 += 4;	411	text2 += 4;
412	$dec o1	412	$dec o1
413	}	413	}
414	while(o2){	414	while(o2){
415	DSBYTE[text1] = DSBYTE[text2];	415	DSBYTE[text1] = DSBYTE[text2];
416	$inc text1	416	$inc text1
417	$inc text2	417	$inc text2
418	$dec o2	418	$dec o2
419	}	419	}
420	DSBYTE[text1] = 0;	420	DSBYTE[text1] = 0;
421	}	421	}
422		422
423	inline fastcall void chrcat(ESI, BL)	423	inline fastcall void chrcat(ESI, BL)
424	{	424	{
425	EDI = strlen(ESI);	425	EDI = strlen(ESI);
426	ESBYTE[ESI+EDI] = BL;	426	ESBYTE[ESI+EDI] = BL;
427	ESBYTE[ESI+EDI+1] = 0;	427	ESBYTE[ESI+EDI+1] = 0;
428	}	428	}
429		429
430	inline dword strchr(dword shb;char s)	430	inline dword strchr(dword shb;char s)
431	{	431	{
432	char ss;	432	char ss;
433	loop()	433	loop()
434	{	434	{
435	ss = DSBYTE[shb];	435	ss = DSBYTE[shb];
436	if(!ss)return 0;	436	if(!ss)return 0;
437	if(ss==s)return shb;	437	if(ss==s)return shb;
438	shb++;	438	shb++;
439	}	439	}
440	}	440	}
441		441
442	inline fastcall signed int strrchr( ESI,BL)	442	inline fastcall signed int strrchr( ESI,BL)
443	{	443	{
444	int jj=0, last=0;	444	int jj=0, last=0;
445	do{	445	do{
446	jj++;	446	jj++;
447	$lodsb	447	$lodsb
448	IF(AL==BL) last=jj;	448	IF(AL==BL) last=jj;
449	} while(AL!=0);	449	} while(AL!=0);
450	return last;	450	return last;
451	}	451	}
452		452
453		453
454	inline fastcall unsigned int chrnum( ESI, BL)	454	inline fastcall unsigned int chrnum( ESI, BL)
455	{	455	{
456	int num = 0;	456	int num = 0;
457	while(DSBYTE[ESI])	457	while(DSBYTE[ESI])
458	{	458	{
459	if (DSBYTE[ESI] == BL) num++;	459	if (DSBYTE[ESI] == BL) num++;
460	ESI++;	460	ESI++;
461	}	461	}
462	return num;	462	return num;
463	}	463	}
464		464
465		465
466	inline fastcall signed int strstr( EBX, EDX)	466	inline fastcall signed int strstr( EBX, EDX)
467	{	467	{
468	asm {	468	asm {
469	MOV EDI, EDX	469	MOV EDI, EDX
470	XOR ECX, ECX	470	XOR ECX, ECX
471	XOR EAX, EAX	471	XOR EAX, EAX
472	DEC ECX	472	DEC ECX
473	REPNE SCASB	473	REPNE SCASB
474	NOT ECX	474	NOT ECX
475	DEC ECX	475	DEC ECX
476	JE LS2	476	JE LS2
477	MOV ESI, ECX	477	MOV ESI, ECX
478	XOR ECX, ECX	478	XOR ECX, ECX
479	MOV EDI, EBX	479	MOV EDI, EBX
480	DEC ECX	480	DEC ECX
481	REPNE SCASB	481	REPNE SCASB
482	NOT ECX	482	NOT ECX
483	SUB ECX, ESI	483	SUB ECX, ESI
484	JBE LS2	484	JBE LS2
485	MOV EDI, EBX	485	MOV EDI, EBX
486	LEA EBX, DSDWORD[ ESI-1]	486	LEA EBX, DSDWORD[ ESI-1]
487	LS1: MOV ESI, EDX	487	LS1: MOV ESI, EDX
488	LODSB	488	LODSB
489	REPNE SCASB	489	REPNE SCASB
490	JNE LS2	490	JNE LS2
491	MOV EAX, ECX	491	MOV EAX, ECX
492	PUSH EDI	492	PUSH EDI
493	MOV ECX, EBX	493	MOV ECX, EBX
494	REPE CMPSB	494	REPE CMPSB
495	POP EDI	495	POP EDI
496	MOV ECX, EAX	496	MOV ECX, EAX
497	JNE LS1	497	JNE LS1
498	LEA EAX, DSDWORD[ EDI-1]	498	LEA EAX, DSDWORD[ EDI-1]
499	JMP SHORT LS3	499	JMP SHORT LS3
500	LS2: XOR EAX, EAX	500	LS2: XOR EAX, EAX

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 7506 → 7742