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


#ifndef INCLUDE_STRING_H
#define INCLUDE_STRING_H
#print "[include ]\n"
 
#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;
}
 
inline signed int streq(dword text1, text2) {
	if (!strcmp(text1,text2)) return true; else return false;
}
 
/*
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;
}
 
/*
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;
}
 
 
int chrnum(dword searchin, char symbol)
{
    int num = 0;
    while(DSBYTE[searchin])
    { 
        if (DSBYTE[searchin] == symbol)    num++;
        searchin++;
    }
    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,...)
{
	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 buf-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;
}
 
 
 
 
 
 
 
 
 
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
 
#endif
>
>
>
>
>
>

Rev 6021	Rev 6058
1	#ifndef INCLUDE_STRING_H	1	#ifndef INCLUDE_STRING_H
2	#define INCLUDE_STRING_H	2	#define INCLUDE_STRING_H
3	#print "[include ]\n"	3	#print "[include ]\n"
4		4
5	#ifndef INCLUDE_MEM_H	5	#ifndef INCLUDE_MEM_H
6	#include "../lib/mem.h"	6	#include "../lib/mem.h"
7	#endif	7	#endif
8		8
9	//------------------------------------------------------------------------------	9	//------------------------------------------------------------------------------
10	// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2	10	// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2
11	// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"	11	// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"
12	// strcmp( ESI, EDI)	12	// strcmp( ESI, EDI)
13	// strlen( EDI)	13	// strlen( EDI)
14	// utf8_strlen( ESI)	14	// utf8_strlen( ESI)
15	// strcpy( EDI, ESI) --- 0 if ==	15	// strcpy( EDI, ESI) --- 0 if ==
16	// strlcpy(dword text1,text2,signed length)	16	// strlcpy(dword text1,text2,signed length)
17	// strcat( EDI, ESI)	17	// strcat( EDI, ESI)
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	inline signed int strncmp(dword text1,text2,len)	118	inline signed int strncmp(dword text1,text2,len)
119	{	119	{
120		120
121	loop()	121	loop()
122	{	122	{
123	if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;	123	if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
124	$dec len	124	$dec len
125	if(!len)return 0;	125	if(!len)return 0;
126	}	126	}
127	}	127	}
128	*/	128	*/
129	inline fastcall unsigned int strlen( EDI)	129	inline fastcall unsigned int strlen( EDI)
130	{	130	{
131	$xor eax, eax	131	$xor eax, eax
132	$mov ecx, -1	132	$mov ecx, -1
133	$REPNE $SCASB	133	$REPNE $SCASB
134	EAX-=2+ECX;	134	EAX-=2+ECX;
135	}	135	}
136		136
137	inline strnlen(dword str, dword maxlen)	137	inline strnlen(dword str, dword maxlen)
138	{	138	{
139	dword cp;	139	dword cp;
140	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);	140	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
141	return cp - str;	141	return cp - str;
142	}	142	}
143		143
144	inline fastcall unsigned int utf8_strlen( ESI)	144	inline fastcall unsigned int utf8_strlen( ESI)
145	{	145	{
146	$xor ecx, ecx	146	$xor ecx, ecx
147	_loop:	147	_loop:
148	$lodsb	148	$lodsb
149	$test al, al	149	$test al, al
150	$jz _done	150	$jz _done
151	$and al, 0xc0	151	$and al, 0xc0
152	$cmp al, 0x80	152	$cmp al, 0x80
153	$jz _loop	153	$jz _loop
154	$inc ecx	154	$inc ecx
155	$jmp _loop	155	$jmp _loop
156		156
157	_done:	157	_done:
158	return ECX;	158	return ECX;
159	}	159	}
160		160
161	inline signed int strcmp(dword text1, text2)	161	inline signed int strcmp(dword text1, text2)
162	{	162	{
163	char s1,s2;	163	char s1,s2;
164	dword p1,p2;	164	dword p1,p2;
165	p1 = text1;	165	p1 = text1;
166	p2 = text2;	166	p2 = text2;
167	loop()	167	loop()
168	{	168	{
169	s1 = DSBYTE[text1];	169	s1 = DSBYTE[text1];
170	s2 = DSBYTE[text2];	170	s2 = DSBYTE[text2];
171	if(s1==s2)	171	if(s1==s2)
172	{	172	{
173	if(s1==0) return 0;	173	if(s1==0) return 0;
174	}	174	}
175	else {	175	else {
176	return s1-s2;	176	return s1-s2;
177	}	177	}
178	$inc text1	178	$inc text1
179	$inc text2	179	$inc text2
180	}	180	}
181	return 0;	181	return 0;
182	}	182	}
-		183
-		184	inline signed int streq(dword text1, text2) {
-		185	if (!strcmp(text1,text2)) return true; else return false;
-		186	}
183		187
184	/*	188	/*
185	signed int strncmp(dword s1, s2, signed n)	189	signed int strncmp(dword s1, s2, signed n)
186	unsigned char _s1,_s2;	190	unsigned char _s1,_s2;
187	{	191	{
188	if (n == 0)	192	if (n == 0)
189	return 0;	193	return 0;
190	do {	194	do {
191	_s1 = DSBYTE[s1];	195	_s1 = DSBYTE[s1];
192	_s2 = DSBYTE[s2];	196	_s2 = DSBYTE[s2];
193	if (_s1 != _s2)	197	if (_s1 != _s2)
194	{	198	{
195	$dec s2	199	$dec s2
196	return _s1 - _s2;	200	return _s1 - _s2;
197	}	201	}
198	$inc s2	202	$inc s2
199	if (_s1 == 0)	203	if (_s1 == 0)
200	break;	204	break;
201	$inc s1	205	$inc s1
202	$dec n	206	$dec n
203	} while (n);	207	} while (n);
204	return 0;	208	return 0;
205	}	209	}
206	*/	210	*/
207		211
208		212
209	inline fastcall void strcpy( EDI, ESI)	213	inline fastcall void strcpy( EDI, ESI)
210	{	214	{
211	$cld	215	$cld
212	L2:	216	L2:
213	$lodsb	217	$lodsb
214	$stosb	218	$stosb
215	$test al,al	219	$test al,al
216	$jnz L2	220	$jnz L2
217	}	221	}
218		222
219	inline fastcall int strlcpy(dword ESI, EDI, EBX)	223	inline fastcall int strlcpy(dword ESI, EDI, EBX)
220	{	224	{
221	if (EBX<0) return -1;	225	if (EBX<0) return -1;
222	EDX=0;	226	EDX=0;
223	do {	227	do {
224	DSBYTE[ESI]=DSBYTE[EDI];	228	DSBYTE[ESI]=DSBYTE[EDI];
225	ESI++;	229	ESI++;
226	EDI++;	230	EDI++;
227	EDX++;	231	EDX++;
228	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}	232	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
229	} while(DSBYTE[EDI-1]!='\0');	233	} while(DSBYTE[EDI-1]!='\0');
230	return 0;	234	return 0;
231	}	235	}
232		236
233	/*	237	/*
234	inline fastcall void strtrim( ESI)	238	inline fastcall void strtrim( ESI)
235	{	239	{
236	EDI = ESI;	240	EDI = ESI;
237	do{	241	do{
238	AL=DSBYTE[EDI];	242	AL=DSBYTE[EDI];
239	if (AL != '\32') && (AL != '\13') && (AL != '\10')	243	if (AL != '\32') && (AL != '\13') && (AL != '\10')
240	{	244	{
241	DSBYTE[ESI]=AL;	245	DSBYTE[ESI]=AL;
242	$inc ESI	246	$inc ESI
243	}	247	}
244	$inc EDI	248	$inc EDI
245	}while(AL!=0);	249	}while(AL!=0);
246	DSBYTE[ESI] = '\0';	250	DSBYTE[ESI] = '\0';
247	}	251	}
248	*/	252	*/
249		253
250	inline byte __isWhite(int s){ if (s==13)\|\|(s==32)\|\|(s==10)\|\|(s==9) return true; return false; }	254	inline byte __isWhite(int s){ if (s==13)\|\|(s==32)\|\|(s==10)\|\|(s==9) return true; return false; }
251	inline void strltrim(dword text){	255	inline void strltrim(dword text){
252	int s;	256	int s;
253	dword back_text;	257	dword back_text;
254	back_text = text;	258	back_text = text;
255	s = ESBYTE[text];	259	s = ESBYTE[text];
256	while(__isWhite(s))	260	while(__isWhite(s))
257	{	261	{
258	$inc text	262	$inc text
259	s = ESBYTE[text];	263	s = ESBYTE[text];
260	}	264	}
261	loop()	265	loop()
262	{	266	{
263	ESBYTE[back_text] = s;	267	ESBYTE[back_text] = s;
264	$inc back_text	268	$inc back_text
265	if(!s) break;	269	if(!s) break;
266	$inc text	270	$inc text
267	s = ESBYTE[text];	271	s = ESBYTE[text];
268	};	272	};
269	}	273	}
270		274
271	inline void strrtrim(dword text)	275	inline void strrtrim(dword text)
272	{	276	{
273	int s;	277	int s;
274	dword p;	278	dword p;
275	do {	279	do {
276	s = ESBYTE[text];	280	s = ESBYTE[text];
277	if(__isWhite(s))	281	if(__isWhite(s))
278	{	282	{
279	p = text;	283	p = text;
280	while(__isWhite(s))	284	while(__isWhite(s))
281	{	285	{
282	$inc text;	286	$inc text;
283	s = ESBYTE[text];	287	s = ESBYTE[text];
284	}	288	}
285	}	289	}
286	else $inc text	290	else $inc text
287	} while(s);	291	} while(s);
288	$dec text	292	$dec text
289	s = ESBYTE[text];	293	s = ESBYTE[text];
290	if(__isWhite(s)) ESBYTE[p] = 0;	294	if(__isWhite(s)) ESBYTE[p] = 0;
291	}	295	}
292		296
293	inline void strtrim(dword text){	297	inline void strtrim(dword text){
294	int s;	298	int s;
295	dword p,back_text;	299	dword p,back_text;
296	back_text = text;	300	back_text = text;
297	s = ESBYTE[text];	301	s = ESBYTE[text];
298	while(__isWhite(s))	302	while(__isWhite(s))
299	{	303	{
300	$inc text	304	$inc text
301	s = ESBYTE[text];	305	s = ESBYTE[text];
302	}	306	}
303	do {	307	do {
304	s = ESBYTE[text];	308	s = ESBYTE[text];
305	if(__isWhite(s))	309	if(__isWhite(s))
306	{	310	{
307	p = back_text;	311	p = back_text;
308	while(__isWhite(s))	312	while(__isWhite(s))
309	{	313	{
310	ESBYTE[back_text] = s;	314	ESBYTE[back_text] = s;
311	$inc back_text	315	$inc back_text
312	$inc text;	316	$inc text;
313	s = ESBYTE[text];	317	s = ESBYTE[text];
314	}	318	}
315	}	319	}
316	else {	320	else {
317	ESBYTE[back_text] = s;	321	ESBYTE[back_text] = s;
318	$inc back_text	322	$inc back_text
319	$inc text	323	$inc text
320	}	324	}
321	} while(s);	325	} while(s);
322	$dec text	326	$dec text
323	s = ESBYTE[text];	327	s = ESBYTE[text];
324	if(__isWhite(s)) ESBYTE[p] = 0;	328	if(__isWhite(s)) ESBYTE[p] = 0;
325	}	329	}
326		330
327	inline fastcall void strcat( EDI, ESI)	331	inline fastcall void strcat( EDI, ESI)
328	{	332	{
329	asm {	333	asm {
330	mov ebx, edi	334	mov ebx, edi
331	xor ecx, ecx	335	xor ecx, ecx
332	xor eax, eax	336	xor eax, eax
333	dec ecx	337	dec ecx
334	repne scasb	338	repne scasb
335	dec edi	339	dec edi
336	mov edx, edi	340	mov edx, edi
337	mov edi, esi	341	mov edi, esi
338	xor ecx, ecx	342	xor ecx, ecx
339	xor eax, eax	343	xor eax, eax
340	dec ecx	344	dec ecx
341	repne scasb	345	repne scasb
342	xor ecx, 0ffffffffh	346	xor ecx, 0ffffffffh
343	mov edi, edx	347	mov edi, edx
344	mov edx, ecx	348	mov edx, ecx
345	mov eax, edi	349	mov eax, edi
346	shr ecx, 2	350	shr ecx, 2
347	rep movsd	351	rep movsd
348	mov ecx, edx	352	mov ecx, edx
349	and ecx, 3	353	and ecx, 3
350	rep movsb	354	rep movsb
351	mov eax, ebx	355	mov eax, ebx
352	}	356	}
353	}	357	}
354		358
355	void strncat(dword text1, text2, signed len)	359	void strncat(dword text1, text2, signed len)
356	signed o1,o2;	360	signed o1,o2;
357	char s;	361	char s;
358	{	362	{
359	s = DSBYTE[text1];	363	s = DSBYTE[text1];
360	while(s){	364	while(s){
361	$inc text1	365	$inc text1
362	s = DSBYTE[text1];	366	s = DSBYTE[text1];
363	}	367	}
364	o1 = len/4;	368	o1 = len/4;
365	o2 = len-4*o1;	369	o2 = len-4*o1;
366	while(o1){	370	while(o1){
367	DSDWORD[text1] = DSDWORD[text2];	371	DSDWORD[text1] = DSDWORD[text2];
368	text1 += 4;	372	text1 += 4;
369	text2 += 4;	373	text2 += 4;
370	$dec o1	374	$dec o1
371	}	375	}
372	while(o2){	376	while(o2){
373	DSBYTE[text1] = DSBYTE[text2];	377	DSBYTE[text1] = DSBYTE[text2];
374	$inc text1	378	$inc text1
375	$inc text2	379	$inc text2
376	$dec o2	380	$dec o2
377	}	381	}
378	DSBYTE[text1] = 0;	382	DSBYTE[text1] = 0;
379	}	383	}
380		384
381	inline fastcall void chrcat(ESI, BL)	385	inline fastcall void chrcat(ESI, BL)
382	{	386	{
383	EDI = strlen(ESI);	387	EDI = strlen(ESI);
384	ESBYTE[ESI+EDI] = BL;	388	ESBYTE[ESI+EDI] = BL;
385	ESBYTE[ESI+EDI+1] = 0;	389	ESBYTE[ESI+EDI+1] = 0;
386	}	390	}
387		-
388		-
389	inline fastcall signed int old_strchr( ESI,BL)	-
390	{	-
391	int jj=0;	-
392	do{	-
393	jj++;	-
394	$lodsb	-
395	IF(AL==BL) return jj;	-
396	} while(AL!=0);	-
397	return 0;	-
398	}	-
399		391
400	inline dword strchr(dword shb;char s)	392	inline dword strchr(dword shb;char s)
401	{	393	{
402	char ss;	394	char ss;
403	loop()	395	loop()
404	{	396	{
405	ss = DSBYTE[shb];	397	ss = DSBYTE[shb];
406	if(!ss)return 0;	398	if(!ss)return 0;
407	if(ss==s)return shb;	399	if(ss==s)return shb;
408	shb++;	400	shb++;
409	}	401	}
410	}	402	}
411		403
412	inline fastcall signed int strrchr( ESI,BL)	404	inline fastcall signed int strrchr( ESI,BL)
413	{	405	{
414	int jj=0, last=0;	406	int jj=0, last=0;
415	do{	407	do{
416	jj++;	408	jj++;
417	$lodsb	409	$lodsb
418	IF(AL==BL) last=jj;	410	IF(AL==BL) last=jj;
419	} while(AL!=0);	411	} while(AL!=0);
420	return last;	412	return last;
421	}	413	}
422		414
423		415
424	int chrnum(dword searchin, char symbol)	416	int chrnum(dword searchin, char symbol)
425	{	417	{
426	int num = 0;	418	int num = 0;
427	while(DSBYTE[searchin])	419	while(DSBYTE[searchin])
428	{	420	{
429	if (DSBYTE[searchin] == symbol) num++;	421	if (DSBYTE[searchin] == symbol) num++;
430	searchin++;	422	searchin++;
431	}	423	}
432	return num;	424	return num;
433	}	425	}
434		426
435		427
436	inline fastcall signed int strstr( EBX, EDX)	428	inline fastcall signed int strstr( EBX, EDX)
437	{	429	{
438	asm {	430	asm {
439	MOV EDI, EDX	431	MOV EDI, EDX
440	XOR ECX, ECX	432	XOR ECX, ECX
441	XOR EAX, EAX	433	XOR EAX, EAX
442	DEC ECX	434	DEC ECX
443	REPNE SCASB	435	REPNE SCASB
444	NOT ECX	436	NOT ECX
445	DEC ECX	437	DEC ECX
446	JE LS2	438	JE LS2
447	MOV ESI, ECX	439	MOV ESI, ECX
448	XOR ECX, ECX	440	XOR ECX, ECX
449	MOV EDI, EBX	441	MOV EDI, EBX
450	DEC ECX	442	DEC ECX
451	REPNE SCASB	443	REPNE SCASB
452	NOT ECX	444	NOT ECX
453	SUB ECX, ESI	445	SUB ECX, ESI
454	JBE LS2	446	JBE LS2
455	MOV EDI, EBX	447	MOV EDI, EBX
456	LEA EBX, DSDWORD[ ESI-1]	448	LEA EBX, DSDWORD[ ESI-1]
457	LS1: MOV ESI, EDX	449	LS1: MOV ESI, EDX
458	LODSB	450	LODSB
459	REPNE SCASB	451	REPNE SCASB
460	JNE LS2	452	JNE LS2
461	MOV EAX, ECX	453	MOV EAX, ECX
462	PUSH EDI	454	PUSH EDI
463	MOV ECX, EBX	455	MOV ECX, EBX
464	REPE CMPSB	456	REPE CMPSB
465	POP EDI	457	POP EDI
466	MOV ECX, EAX	458	MOV ECX, EAX
467	JNE LS1	459	JNE LS1
468	LEA EAX, DSDWORD[ EDI-1]	460	LEA EAX, DSDWORD[ EDI-1]
469	JMP SHORT LS3	461	JMP SHORT LS3
470	LS2: XOR EAX, EAX	462	LS2: XOR EAX, EAX
471	LS3:	463	LS3:
472	}	464	}
473	}	465	}
474		466
475	inline dword strcmpi(dword cmp1, cmp2)	467	inline dword strcmpi(dword cmp1, cmp2)
476	{	468	{
477	char si, ue;	469	char si, ue;
478		470
479	loop()	471	loop()
480	{	472	{
481	si = DSBYTE[cmp1];	473	si = DSBYTE[cmp1];
482	ue = DSBYTE[cmp2];	474	ue = DSBYTE[cmp2];
483	if (si>='A') && (si<='Z') si +=32;	475	if (si>='A') && (si<='Z') si +=32;
484	if (ue>='A') && (ue<='Z') ue +=32;	476	if (ue>='A') && (ue<='Z') ue +=32;
485	if (si != ue) return -1;	477	if (si != ue) return -1;
486	cmp1++;	478	cmp1++;
487	cmp2++;	479	cmp2++;
488	if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;	480	if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
489	if (DSBYTE[cmp1]=='\0') return -1;	481	if (DSBYTE[cmp1]=='\0') return -1;
490	if (DSBYTE[cmp2]=='\0') return 1;	482	if (DSBYTE[cmp2]=='\0') return 1;
491	}	483	}
492	}	484	}
493		485
494	inline dword strstri(dword searchin, usestr_s)	486	inline dword strstri(dword searchin, usestr_s)
495	{	487	{
496	dword usestr_e = usestr_s;	488	dword usestr_e = usestr_s;

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 6021 → 6058