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;
}
 
/*
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 fastcall signed int old_strchr( ESI,BL)
{
    int jj=0;
    do{
        jj++;
        $lodsb
        IF(AL==BL) return jj;
    } while(AL!=0);
    return 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 0;
}
 
 
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;
}
 
inline void debugi(dword d_int)
{
    char tmpch[12];
    itoa_(#tmpch, d_int);
    debugln(#tmpch);
}
 
 
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
 
#endif
>
>
>
>
>
>
 

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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h @ 7049 – Rev 5713 → 5803