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


#ifndef INCLUDE_STRING_H
#define INCLUDE_STRING_H
 
#ifndef INCLUDE_MEM_H
#include "../lib/mem.h"
#endif
 
//------------------------------------------------------------------------------
// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2
// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"
// strcmp( ESI, EDI)
// strlen( EDI)
// utf8_strlen( ESI)
// strcpy( EDI, ESI) --- 0 if ==
// strlcpy(dword text1,text2,signed length)
// strcat( EDI, ESI)
// chrcat(ESI, BL)
// strncat(dword text1,text2,signed length) --- pasting the text of a certain length
// strchr( ESI,BL) --- find first BL
// strrchr( ESI,BL) --- find last BL
// strstr( EBX, EDX)
// itoa(signed long number) --- convert the number as a string
// atoi(dword text) --- convert a string as a number
// strupr( ESI)
// strlwr( ESI) --- Cyrillic symbols may not work
// strttl( EDX)
// strtok( ESI)
// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)
// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)
// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides
// chrnum(dword searchin, char symbol)
// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
// strnumb(dword searchin, startstr, endstr) --- get number between strings
// strdup(dword text) --- allocation under the text
//------------------------------------------------------------------------------
 
/*
inline fastcall signed int strcmp( ESI, EDI)
{
    loop()
    {
        IF (DSBYTE[ESI]
        IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
        IF (DSBYTE[ESI]=='\0') RETURN 0;
        ESI++;
        EDI++;
    }
}
*/
 
 
 
inline int strspn(dword text1,text2)
{
	dword beg;
	char s1,s2;
	int ret;
	ret = 0;
	beg = text2;
	do {
		s1 = ESBYTE[text1];
		text2 = beg;
		do {
			s2 = ESBYTE[text2];
			if(s1==s2)
			{
				if(!s2)break;
				$inc ret
				break;
			}
			else $inc text2
		} while(s2);
		$inc text1
	} while(s1);
	return ret;
}
 
inline dword strpbrk(dword text1,text2)
{
	char s,ss;
	dword beg;
	beg = text2;
	do {
		s = ESBYTE[text1];
		text2 = beg;
		do {
			ss = ESBYTE[text2];
			if(ss==s) return text1;
			$inc text2
		} while(ss);
		$inc text1
	} while(s);
	return text1;
}
 
inline fastcall signed int strncmp( ESI, EDI, ECX)
{
  asm {
    MOV EBX, EDI
    XOR EAX, EAX
    MOV EDX, ECX
    OR ECX, ECX
    JE L1
    REPNE SCASB
    SUB EDX, ECX
    MOV ECX, EDX
    MOV EDI, EBX
    XOR EBX, EBX
    REPE CMPSB
    MOV AL, DSBYTE[ ESI-1]
    MOV BL, DSBYTE[ EDI-1]
    SUB EAX, EBX
L1:
  }
}
 
/*
signed int strncmp(dword s1, s2, signed n)
unsigned char _s1,_s2;
{
	if (n == 0)
		return 0;
	do {
		_s1 = DSBYTE[s1];
		_s2 = DSBYTE[s2];
		if (_s1 != _s2)
		{
			$dec s2
			return _s1 - _s2;
		}
		$inc s2
		if (_s1 == 0)
			break;
		$inc s1
		$dec n
	} while (n);
	return 0;
}
*/
 
/*
inline signed int strncmp(dword text1,text2,len)
{
	
	loop()
	{
		if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
		$dec len 
		if(!len)return 0;
	}
}
*/
inline fastcall unsigned int strlen( EDI)
{
	$xor eax, eax
	$mov ecx, -1
	$REPNE $SCASB
	EAX-=2+ECX;
}
 
inline dword strnlen(dword str, dword maxlen)
{
	dword cp;
	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
	return cp - str;
}
 
inline fastcall unsigned int utf8_strlen( ESI)
{
 $xor  ecx, ecx
  _loop: 
 $lodsb
 $test  al, al
 $jz  _done
 $and al, 0xc0
 $cmp al, 0x80
 $jz  _loop 
 $inc ecx
 $jmp _loop
 
  _done:
 return ECX;
}
 
inline signed int strcmp(dword text1, text2)
{
	char s1,s2;
	dword p1,p2;
	p1 = text1;
	p2 = text2;
	loop()
	{
		s1 = DSBYTE[text1];
		s2 = DSBYTE[text2];
		if(s1==s2)
		{
			if(s1==0) return 0;
		}
		else {
			return s1-s2;
		}
		$inc text1 
		$inc text2
	}
	return 0;
}
 
 
inline fastcall bool streq(ESI, EDI)
{
	loop()
	{
		if(DSBYTE[ESI]==DSBYTE[EDI])
		{
			if(DSBYTE[ESI]==0) return true;
		}
		else {
			return false;
		}
		ESI++;
		EDI++;
	}
}
 
inline fastcall bool streqrp(ESI, EDI) //streq right part
{
	if(DSBYTE[ESI]==0) || (DSBYTE[EDI]==0) return false;
	loop()
	{
		if(DSBYTE[EDI]==0) return true;
		if(DSBYTE[ESI]!=DSBYTE[EDI]) return false;
		ESI++;
		EDI++;
	}
}
 
inline fastcall void strcpy( EDI, ESI)
{
    $cld
L2:
    $lodsb
    $stosb
    $test al,al
    $jnz L2
}
 
inline fastcall int strlcpy(dword ESI, EDI, EBX)
{
    if (EBX<0) return -1;
    EDX=0;
    do {
        DSBYTE[ESI]=DSBYTE[EDI];
        ESI++;
        EDI++;
        EDX++;
        if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
    } while(DSBYTE[EDI-1]!='\0');
    return 0;
}
 
:void strncpy(dword dst, src, len)
{
	while (len) && (ESBYTE[src])
	{
		ESBYTE[dst] = ESBYTE[src];
		dst++;
		src++;
		len--;
	}
	ESBYTE[dst]=0;
}
 
/*
inline fastcall void strtrim( ESI)
{
    EDI = ESI;
    do{
        AL=DSBYTE[EDI];
        if (AL != '\32') && (AL != '\13') && (AL != '\10')
        {
            DSBYTE[ESI]=AL;
            $inc ESI
        }
         $inc EDI
    }while(AL!=0);
    DSBYTE[ESI] = '\0';
}
*/
 
inline byte __isWhite(int s){ if (s==13)||(s==32)||(s==10)||(s==9) return true; return false; }
inline void strltrim(dword text){
	int s;
	dword back_text;
	back_text = text;
	s = ESBYTE[text];
	while(__isWhite(s))
	{
		$inc text
		s = ESBYTE[text];
	}
	loop()
	{
		ESBYTE[back_text] = s;
		$inc back_text
		if(!s) break;
		$inc text
		s = ESBYTE[text];
	};
}
 
inline void strrtrim(dword text)
{
	int s;
	dword p;
	do {
		s = ESBYTE[text];
		if(__isWhite(s))
		{
			p = text;
			while(__isWhite(s))
			{
				$inc text;
				s = ESBYTE[text];
			}
		}
		else $inc text
	} while(s);
	$dec text
	s = ESBYTE[text];
	if(__isWhite(s)) ESBYTE[p] = 0;
}
 
inline void strtrim(dword text){
	int s;
	dword p,back_text;
	back_text = text;
	s = ESBYTE[text];
	while(__isWhite(s))
	{
		$inc text
		s = ESBYTE[text];
	} 
	do {
		s = ESBYTE[text];
		if(__isWhite(s))
		{
			p = back_text;
			while(__isWhite(s))
			{
				ESBYTE[back_text] = s;
				$inc back_text
				$inc text;
				s = ESBYTE[text];
			}
		}
		else {
			ESBYTE[back_text] = s;
			$inc back_text
			$inc text
		}
	} while(s);
	$dec text
	s = ESBYTE[text];
	if(__isWhite(s)) ESBYTE[p] = 0;
}
 
inline fastcall void strcat( EDI, ESI)
{
  asm {
    mov ebx, edi
    xor ecx, ecx
    xor eax, eax
    dec ecx
    repne scasb
    dec edi
    mov edx, edi
    mov edi, esi
    xor ecx, ecx
    xor eax, eax
    dec ecx
    repne scasb
    xor ecx, 0ffffffffh
    mov edi, edx
    mov edx, ecx
    mov eax, edi
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    mov eax, ebx
    }
}
 
:void strncat(dword dst, src, len)
{
	while (ESBYTE[dst]) && (len) {
		dst++;
		len--;
	}
	while (ESBYTE[src]) && (len>1) {
		ESBYTE[dst] = ESBYTE[src];
		dst++;
		src++;
		len--;
	}
	ESBYTE[dst] = 0;
}
 
inline fastcall void chrcat(ESI, DI)
{
    while (ESBYTE[ESI]) ESI++;
    ESBYTE[ESI] = DI;
    ESI++;
    ESBYTE[ESI] = 0;
}
 
inline fastcall void chrncat(EDI, AL, EDX)
{
    while (ESBYTE[EDI]) && (EDX) {
    	EDI++;
    	EDX--;
    }
    ESBYTE[EDI] = AL;
    EDI++;
    ESBYTE[EDI] = 0;
}
 
/*
inline dword strchr(ESI, BL)
{
	loop()
	{
		AL = DSBYTE[ESI];
		if(!AL)return 0;
		if(AL==BL)return ESI;
		ESI++;
	}
}
*/
 
/*
:void chrncat(dword dst, unsigned char s, dword len)
{
	while (ESBYTE[dst]) && (len) {
		dst++;
		len--;
	}
	if (len>1) {
		ESBYTE[dst] = s;
		ESBYTE[dst+1] = 0;
	}
}
*/
 
inline dword strchr(dword shb;char s)
{
	char ss;
	loop()
	{
		ss = DSBYTE[shb];
		if(!ss)return 0;
		if(ss==s)return shb;
		shb++;
	}
}
 
inline dword strchrw(dword str, len)
{
	len += str;
	loop()
	{
		if(!DSBYTE[str])return 0;
		if (__isWhite(DSBYTE[str])) return str;
		str++;
		if (str >= len) return 0;
	}
}
 
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 unsigned int chrlnum( ESI, BL, EDI)
{
    int num = 0;
    while(DSBYTE[ESI]) && (EDI)
    { 
        if (DSBYTE[ESI] == BL) num++;
        ESI++;
        EDI--;
    }
    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 int strnum(dword haystack, needle)
{
	int count = 0;
	int needle_len = strlen(needle);
	loop() {
		if (! haystack = strstr(haystack, needle)) break;
		haystack+=needle_len;
		count++;
	}
	return count;
}
 
inline int strinum(dword haystack, needle)
{
	int count = 0;
	int needle_len = strlen(needle);
	loop() {
		if (! haystack = strstri(haystack, needle)) break;
		haystack+=needle_len;
		count++;
	}
	return count;
}
 
inline signed int 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 si-ue;
        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);
    if (! endp = strstri(startp, endstr)) 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;
}
 
:void miniprintf(dword dst, format, insert_line)
{
	dword in_pos = strchr(format, '%');
	if (ESBYTE[in_pos+1] == 's') {
		strlcpy(dst, format, in_pos - format);
		strcat(dst, insert_line);
		strcat(dst, in_pos+2);
	}
}
 
inline cdecl int sprintf(dword buf, format,...)
{
	#define END_ARGS 0xFF00FF //ARGS FUNCTION
	byte s;
 
	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;
}
 
// void * memset( ptr, value, num );
// fills the memory with a dword
// example: memset(str,'-', sizeof(str));
inline void MEMSETD(EDI,ECX,EAX)
{
	$REP 
	$STOSD
}
 
:replace_char(dword in_str, char from_char, to_char, int length) {
	dword max = in_str + length;
	while (in_str < max) {
		if (ESBYTE[in_str] == from_char) ESBYTE[in_str] = to_char;
		in_str++;
	}
}
 
#endif
>
>
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 8484 → 8868