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


//------------------------------------------------------------------------------
// 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) --- kyrillic 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 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 strchr( ESI,BL)
{
    int jj=0;
    do{
        jj++;
        $lodsb
        IF(AL==BL) return jj;
    } while(AL!=0);
    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;
}
 
 
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;
	//l = strlen(text);
	ret = 0;
	s = DSBYTE[text];
	//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-'a'+10;
		text++;
		s = DSBYTE[text];
	}
	/*else if(l==3) 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-'a'+10;
		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);
					strncpy(buf,tmp,l);
					buf += l;
				break;
				case 'a':
				case 'A':
					strncpy(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);
					strncpy(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 void debugi(dword d_int)
{
    char tmpch[12];
    itoa_(#tmpch, d_int);
    debugln(#tmpch);
}
 
 
//#define strncpy strcpyn
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
>
>
>
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 5582 → 5591