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)
// strncat(dword text1,text2,signed length) --- pasting the text of a certain length
// strchr( ESI,BL) --- find first BL
// strrchr( ESI,BL) --- find last BL
// strstr( EBX, EDX)
// itoa(signed long number) --- convert the number as a string
// atoi(dword text) --- convert a string as a number
// strupr( ESI)
// strlwr( ESI) --- Cyrillic symbols may not work
// strttl( EDX)
// strtok( ESI)
// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)
// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)
// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides
// chrnum(dword searchin, char symbol)
// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
// strnumb(dword searchin, startstr, endstr) --- get number between strings
// strdup(dword text) --- allocation under the text
//------------------------------------------------------------------------------
 
/*
inline fastcall signed int strcmp( ESI, EDI)
{
    loop()
    {
        IF (DSBYTE[ESI]
        IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
        IF (DSBYTE[ESI]=='\0') RETURN 0;
        ESI++;
        EDI++;
    }
}
*/
 
 
 
inline int strspn(dword text1,text2)
{
	dword beg;
	char s1,s2;
	int ret;
	ret = 0;
	beg = text2;
	do {
		s1 = ESBYTE[text1];
		text2 = beg;
		do {
			s2 = ESBYTE[text2];
			if(s1==s2)
			{
				if(!s2)break;
				$inc ret
				break;
			}
			else $inc text2
		} while(s2);
		$inc text1
	} while(s1);
	return ret;
}
 
inline dword strpbrk(dword text1,text2)
{
	char s,ss;
	dword beg;
	beg = text2;
	do {
		s = ESBYTE[text1];
		text2 = beg;
		do {
			ss = ESBYTE[text2];
			if(ss==s) return text1;
			$inc text2
		} while(ss);
		$inc text1
	} while(s);
	return text1;
}
 
inline fastcall signed int strncmp( ESI, EDI, ECX)
{
  asm {
    MOV EBX, EDI
    XOR EAX, EAX
    MOV EDX, ECX
    OR ECX, ECX
    JE L1
    REPNE SCASB
    SUB EDX, ECX
    MOV ECX, EDX
    MOV EDI, EBX
    XOR EBX, EBX
    REPE CMPSB
    MOV AL, DSBYTE[ ESI-1]
    MOV BL, DSBYTE[ EDI-1]
    SUB EAX, EBX
L1:
  }
}
 
/*
inline signed int strncmp(dword text1,text2,len)
{
	
	loop()
	{
		if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
		$dec len 
		if(!len)return 0;
	}
}
*/
inline fastcall unsigned int strlen( EDI)
{
    $xor eax, eax
    $mov ecx, -1
    $REPNE $SCASB
    EAX-=2+ECX;
}
 
inline strnlen(dword str, dword maxlen)
{
	dword cp;
	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
	return cp - str;
}
 
inline fastcall unsigned int utf8_strlen( ESI)
{
 $xor  ecx, ecx
  _loop: 
 $lodsb
 $test  al, al
 $jz  _done
 $and al, 0xc0
 $cmp al, 0x80
 $jz  _loop 
 $inc ecx
 $jmp _loop
 
  _done:
 return ECX;
}
 
inline signed int strcmp(dword text1, text2)
{
	char s1,s2;
	dword p1,p2;
	p1 = text1;
	p2 = text2;
	loop()
	{
		s1 = DSBYTE[text1];
		s2 = DSBYTE[text2];
		if(s1==s2)
		{
			if(s1==0) return 0;
		}
		else {
			return s1-s2;
		}
		$inc text1 
		$inc text2
	}
	return 0;
}
 
:bool strequ(dword text1, text2) {
	if (!strcmp(text1,text2)) return true; else return false;
}
 
/*
signed int strncmp(dword s1, s2, signed n)
unsigned char _s1,_s2;
{
	if (n == 0)
		return 0;
	do {
		_s1 = DSBYTE[s1];
		_s2 = DSBYTE[s2];
		if (_s1 != _s2)
		{
			$dec s2
			return _s1 - _s2;
		}
		$inc s2
		if (_s1 == 0)
			break;
		$inc s1
		$dec n
	} while (n);
	return 0;
}
*/
 
 
inline fastcall void strcpy( EDI, ESI)
{
    $cld
L2:
    $lodsb
    $stosb
    $test al,al
    $jnz L2
}
 
inline fastcall int strlcpy(dword ESI, EDI, EBX)
{
    if (EBX<0) return -1;
    EDX=0;
    do {
        DSBYTE[ESI]=DSBYTE[EDI];
        ESI++;
        EDI++;
        EDX++;
        if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
    } while(DSBYTE[EDI-1]!='\0');
    return 0;
}
 
/*
inline fastcall void strtrim( ESI)
{
    EDI = ESI;
    do{
        AL=DSBYTE[EDI];
        if (AL != '\32') && (AL != '\13') && (AL != '\10')
        {
            DSBYTE[ESI]=AL;
            $inc ESI
        }
         $inc EDI
    }while(AL!=0);
    DSBYTE[ESI] = '\0';
}
*/
 
inline byte __isWhite(int s){ if (s==13)||(s==32)||(s==10)||(s==9) return true; return false; }
inline void strltrim(dword text){
	int s;
	dword back_text;
	back_text = text;
	s = ESBYTE[text];
	while(__isWhite(s))
	{
		$inc text
		s = ESBYTE[text];
	}
	loop()
	{
		ESBYTE[back_text] = s;
		$inc back_text
		if(!s) break;
		$inc text
		s = ESBYTE[text];
	};
}
 
inline void strrtrim(dword text)
{
	int s;
	dword p;
	do {
		s = ESBYTE[text];
		if(__isWhite(s))
		{
			p = text;
			while(__isWhite(s))
			{
				$inc text;
				s = ESBYTE[text];
			}
		}
		else $inc text
	} while(s);
	$dec text
	s = ESBYTE[text];
	if(__isWhite(s)) ESBYTE[p] = 0;
}
 
inline void strtrim(dword text){
	int s;
	dword p,back_text;
	back_text = text;
	s = ESBYTE[text];
	while(__isWhite(s))
	{
		$inc text
		s = ESBYTE[text];
	} 
	do {
		s = ESBYTE[text];
		if(__isWhite(s))
		{
			p = back_text;
			while(__isWhite(s))
			{
				ESBYTE[back_text] = s;
				$inc back_text
				$inc text;
				s = ESBYTE[text];
			}
		}
		else {
			ESBYTE[back_text] = s;
			$inc back_text
			$inc text
		}
	} while(s);
	$dec text
	s = ESBYTE[text];
	if(__isWhite(s)) ESBYTE[p] = 0;
}
 
inline fastcall void strcat( EDI, ESI)
{
  asm {
    mov ebx, edi
    xor ecx, ecx
    xor eax, eax
    dec ecx
    repne scasb
    dec edi
    mov edx, edi
    mov edi, esi
    xor ecx, ecx
    xor eax, eax
    dec ecx
    repne scasb
    xor ecx, 0ffffffffh
    mov edi, edx
    mov edx, ecx
    mov eax, edi
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    mov eax, ebx
    }
}
 
:void strncat(dword text1, text2, signed len)
signed o1,o2;
char s;
{
	s = DSBYTE[text1];
	while(s){
		$inc text1
		s = DSBYTE[text1];
	}
	o1 = len/4;
	o2 = len-4*o1;
	while(o1){
		DSDWORD[text1] = DSDWORD[text2];
		text1 += 4;
		text2 += 4;
		$dec o1
	}
	while(o2){
		DSBYTE[text1] = DSBYTE[text2];
		$inc text1 
		$inc text2 
		$dec o2
	}
	DSBYTE[text1] = 0;
}
 
inline fastcall void chrcat(ESI, BL)
{
    EDI = strlen(ESI);
    ESBYTE[ESI+EDI] = BL;
    ESBYTE[ESI+EDI+1] = 0;
}
 
inline dword strchr(dword shb;char s)
{
	char ss;
	loop()
	{
		ss = DSBYTE[shb];
		if(!ss)return 0;
		if(ss==s)return shb;
		shb++;
	}
}
 
inline fastcall signed int strrchr( ESI,BL)
{
    int jj=0, last=0;
    do{
        jj++;
        $lodsb
        IF(AL==BL) last=jj;
    } while(AL!=0);
    return last;
}
 
 
inline fastcall unsigned int chrnum( ESI, BL)
{
    int num = 0;
    while(DSBYTE[ESI])
    { 
        if (DSBYTE[ESI] == BL) num++;
        ESI++;
    }
    return num;
}
 
 
inline fastcall signed int strstr( EBX, EDX)
{
  asm {
    MOV EDI, EDX
    XOR ECX, ECX
    XOR EAX, EAX
    DEC ECX
    REPNE SCASB
    NOT ECX
    DEC ECX
    JE LS2
    MOV ESI, ECX
    XOR ECX, ECX
    MOV EDI, EBX
    DEC ECX
    REPNE SCASB
    NOT ECX
    SUB ECX, ESI
    JBE LS2
    MOV EDI, EBX
    LEA EBX, DSDWORD[ ESI-1]
LS1: MOV ESI, EDX
    LODSB
    REPNE SCASB
    JNE LS2
    MOV EAX, ECX
    PUSH EDI
    MOV ECX, EBX
    REPE CMPSB
    POP EDI
    MOV ECX, EAX
    JNE LS1
    LEA EAX, DSDWORD[ EDI-1]
    JMP SHORT LS3
LS2: XOR EAX, EAX
LS3:
  }
}
 
inline dword strcmpi(dword cmp1, cmp2)
{
    char si, ue;
 
    loop()
    { 
        si = DSBYTE[cmp1];
        ue = DSBYTE[cmp2];
        if (si>='A') && (si<='Z') si +=32;
        if (ue>='A') && (ue<='Z') ue +=32;
        if (si != ue) return -1;
        cmp1++;
        cmp2++;
        if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
        if (DSBYTE[cmp1]=='\0') return -1;
        if (DSBYTE[cmp2]=='\0') return 1;
    }
}
 
inline dword strstri(dword searchin, usestr_s)
{
    dword usestr_e = usestr_s;
    char si, ue;
 
    while(DSBYTE[searchin])
    { 
        si = DSBYTE[searchin];
        ue = DSBYTE[usestr_e];
        if (si>='A') && (si<='Z') si +=32;
        if (ue>='A') && (ue<='Z') ue +=32;
        if (si == ue) usestr_e++; else usestr_e = usestr_s;
        searchin++;
        if (DSBYTE[usestr_e]=='\0') return searchin;
    }
    return -1;
}
 
 
inline unsigned int strcpyb(dword search_in, copyin, startstr, endstr)
{
    dword startp, endp;
    dword copyin_start_off = copyin;
    if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);
    endp = strstri(startp, endstr);
    if (endp==0) endp = startp+strlen(search_in);
    //if (startp==endp) return 0;
    do
    { 
        DSBYTE[copyin] = DSBYTE[startp];
        copyin++;
        startp++;
    }
    while (startp
    DSBYTE[copyin] = '\0';
    return copyin_start_off;
}
 
 
/*void strcat(char *to, char *from) 
{
    while(*to) to++;
    while(*from)
    {
        *to = *from;
        to++;
        from++;
    }
    *to = '\0';
}*/
 
 
inline fastcall dword atoi( EDI)
{
    $push ebx
    $push esi
    ESI=EDI;
    while (DSBYTE[ESI]==' ') ESI++;
    if (DSBYTE[ESI]=='-') ESI++;
    EAX=0;
    while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
    {
        $xor ebx, ebx
        EBX = DSBYTE[ESI]-'0';
        EAX *= 10;
        EAX += EBX;
        ESI++;
    } 
    IF (DSBYTE[EDI]=='-') -EAX;
    $pop esi
    $pop ebx
}
 
 
 
inline fastcall strupr( ESI)
{
    do{
        AL=DSBYTE[ESI];
        IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
        IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;    //à-ï
        IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;    //à-ï
         ESI++;
    }while(AL!=0);
}
 
inline fastcall strlwr( ESI)
{
    do{
        $LODSB
        IF(AL>='A')&&(AL<='Z'){
            AL+=0x20;
            DSBYTE[ESI-1]=AL;
            CONTINUE;
        }
    }while(AL!=0);
}
 
inline fastcall strttl( EDX)
{
    AL=DSBYTE[EDX];
    IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
    IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;    //à-ï
    IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;    //à-ï
    do{
        EDX++;
        AL=DSBYTE[EDX];
        IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
        IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL|0x20; // -¯
        IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;    //à-ï
    }while(AL!=0);
}
 
/*
dword itoa( ESI)
{
    unsigned char buffer[11];
    $pusha
    EDI = #buffer;
    ECX = 10;
    if (ESI < 0)
    {
         $mov     al, '-'
         $stosb
         $neg     esi
    }
 
    $mov     eax, esi
    $push    -'0'
F2:
    $xor     edx, edx
    $div     ecx
    $push    edx
    $test    eax, eax
    $jnz     F2
F3:
    $pop     eax
    $add     al, '0'
    $stosb
    $jnz     F3
    
    $mov     al, '\0'
    $stosb
 
    $popa
    return #buffer;
}
*/
:unsigned char BUF_ITOA[11];
inline dword itoa(signed long number)
{
	dword ret,p;
	byte cmd;
	long mask,tmp;
	mask = 1000000000;
	cmd = true;
	p = #BUF_ITOA;
	if(!number){
		ESBYTE[p] = '0';
		ESBYTE[p+1] = 0;
		return p;
	}
	ret = p;
	if(number<0)
	{
		$neg number
		ESBYTE[p] = '-';
		$inc p
	}
	while(mask)
	{
		tmp = number / mask;
		tmp = tmp%10;
		
		if(cmd){
			if(tmp){
				ESBYTE[p] = tmp + '0';
				$inc p
				cmd = false;
			}
		}
		else {
			ESBYTE[p] = tmp + '0';
			$inc p
		}
		mask /= 10;
	}
	ESBYTE[p] = 0;
	return ret;
}
 
inline fastcall itoa_(signed int EDI, ESI)
{
    $pusha
    EBX = EDI;
    ECX = 10;
    if (ESI > 90073741824)
    {
         $mov     al, '-'
         $stosb
         $neg     esi
    }
 
    $mov     eax, esi
    $push    -'0'
F2:
    $xor     edx, edx
    $div     ecx
    $push    edx
    $test    eax, eax
    $jnz     F2
F3:
    $pop     eax
    $add     al, '0'
    $stosb
    $jnz     F3
    
    $mov     al, '\0'
    $stosb
 
    $popa
    return EBX;
} 
 
inline dword memchr(dword s,int c,signed len)
{
	if(!len) return NULL;
	do {
		if(DSBYTE[s] == c) return s;
		$inc s
		$dec len
	} while(len);
	return NULL;
}
 
inline dword strdup(dword text)
{
    dword l = strlen(text);
    dword ret = malloc(l+1);
	if(!ret) return NULL;
    strlcpy(ret,text,l);
    return ret;
}
 
inline dword strndup(dword str, signed maxlen)
{
	dword copy,len;
 
	len = strnlen(str, maxlen);
	copy = malloc(len + 1);
	if (copy != NULL)
	{
		strlcpy(copy, str, len);
		DSBYTE[len+copy] = '\0';
	}
	return copy;
}
 
inline dword hexdec(dword text)
{
	char s;
	dword ret,l;
	ret = 0;
	s = DSBYTE[text];
	while(s)
	{	
		ret <<= 4;
		if(s>='A')&&(s<='F')ret |= s-'A'+10;
		else if(s>='a')&&(s<='f')ret |= s-'a'+10;
		else if(s>='0')&&(s<='9')ret |= s-'0';
		text++;
		s = DSBYTE[text];
	}
	return ret;
}
 
inline signed csshexdec(dword text)
{
	char s;
	dword ret,l;
	byte tmp;
	l = strlen(text);
	ret = 0;
	s = DSBYTE[text];
	tmp = 0;
	if(l==6) while(s)
	{	
		ret <<= 4;
		if(s>='A')&&(s<='F')ret |= s-'A'+10;
		else if(s>='a')&&(s<='f')ret |= s-'a'+10;
		else if(s>='0')&&(s<='9')ret |= s-'0';
		text++;
		s = DSBYTE[text];
	}
	else if(l==3) while(s)
	{	
		ret |= tmp;
		ret <<= 4;
		ret |= tmp;
		ret <<= 4;
		if(s>='A')&&(s<='F')tmp = s-'A'+10;
		else if(s>='a')&&(s<='f')tmp = s-'a'+10;
		else if(s>='0')&&(s<='9')tmp = s-'0';
		text++;
		s = DSBYTE[text];
	}
	return ret;
}
 
inline cdecl int sprintf(dword buf, format,...)
{
	#define END_ARGS 0xFF00FF //ARGS FUNCTION
	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 ret;
}
 
inline signed strcoll(dword text1,text2)
{
	char s,ss;
	loop()
	{
		s = DSBYTE[text2];
		ss=strchr(text1,s);
		if(ss)return ss;
		text2++;
	}
	return 0;
}
 
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
 
#endif
>
>
>
>
>
>

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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h @ 7051 – Rev 6791 → 6887