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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 5676 → 5690