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


//------------------------------------------------------------------------------
// strcmp( ESI, EDI)
// strlen( EDI)
// strcpy( EDI, ESI) --- 0 if ==
// strcat( EDI, ESI)
// strchr( ESI,BL) --- find first BL
// strrchr( ESI,BL) --- find last BL
// strstr( EBX, EDX)
// itoa( ESI)
// atoi( EAX)
// strupr( ESI)
// strlwr( ESI) --- kyrillic symbols may not work
// strttl( EDX)
// strtok( ESI)
// strtrim( ESI) --- removes "blank" characters (\r, \n and space)
// chrnum(dword searchin, char symbol)
// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
// strnumb(dword searchin, startstr, endstr) --- get number between strings
//------------------------------------------------------------------------------
 
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 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 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 strtrim( ESI)
{
	EDI = ESI;
	do{
		AL=DSBYTE[EDI];
		if (AL != '\32') && (AL != '\13') && (AL != '\10')
		{
			DSBYTE[ESI]=AL;
			ESI++;
		}
 		EDI++;
	}while(AL!=0);
	DSBYTE[ESI] = '\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
	}
}
 
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:
  }
}
 
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;
	}
}
 
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;
}
 
 
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;
}
 
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;
}  
 
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 4639	Rev 4645
1	//------------------------------------------------------------------------------	1	//------------------------------------------------------------------------------
2	// strcmp( ESI, EDI)	2	// strcmp( ESI, EDI)
3	// strlen( EDI)	3	// strlen( EDI)
4	// strcpy( EDI, ESI) --- 0 if ==	4	// strcpy( EDI, ESI) --- 0 if ==
5	// strcat( EDI, ESI)	5	// strcat( EDI, ESI)
6	// strchr( ESI,BL) --- find first BL	6	// strchr( ESI,BL) --- find first BL
7	// strrchr( ESI,BL) --- find last BL	7	// strrchr( ESI,BL) --- find last BL
8	// strstr( EBX, EDX)	8	// strstr( EBX, EDX)
9	// itoa( ESI)	9	// itoa( ESI)
10	// atoi( EAX)	10	// atoi( EAX)
11	// strupr( ESI)	11	// strupr( ESI)
12	// strlwr( ESI) --- kyrillic symbols may not work	12	// strlwr( ESI) --- kyrillic symbols may not work
13	// strttl( EDX)	13	// strttl( EDX)
14	// strtok( ESI)	14	// strtok( ESI)
15	// strtrim( ESI) --- removes "blank" characters (\r, \n and space)	15	// strtrim( ESI) --- removes "blank" characters (\r, \n and space)
16	// chrnum(dword searchin, char symbol)	16	// chrnum(dword searchin, char symbol)
17	// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings	17	// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
18	// strnumb(dword searchin, startstr, endstr) --- get number between strings	18	// strnumb(dword searchin, startstr, endstr) --- get number between strings
19	//------------------------------------------------------------------------------	19	//------------------------------------------------------------------------------
20		20
21	inline fastcall signed int strcmp( ESI, EDI)	21	inline fastcall signed int strcmp( ESI, EDI)
22	{	22	{
23	loop()	23	loop()
24	{	24	{
25	IF (DSBYTE[ESI]	25	IF (DSBYTE[ESI]
26	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;	26	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
27	IF (DSBYTE[ESI]=='\0') RETURN 0;	27	IF (DSBYTE[ESI]=='\0') RETURN 0;
28	ESI++;	28	ESI++;
29	EDI++;	29	EDI++;
30	}	30	}
31	}	31	}
32		32
33		33
34	inline fastcall signed int strncmp( ESI, EDI, ECX)	34	inline fastcall signed int strncmp( ESI, EDI, ECX)
35	{	35	{
36	asm {	36	asm {
37	MOV EBX, EDI	37	MOV EBX, EDI
38	XOR EAX, EAX	38	XOR EAX, EAX
39	MOV EDX, ECX	39	MOV EDX, ECX
40	OR ECX, ECX	40	OR ECX, ECX
41	JE L1	41	JE L1
42	REPNE SCASB	42	REPNE SCASB
43	SUB EDX, ECX	43	SUB EDX, ECX
44	MOV ECX, EDX	44	MOV ECX, EDX
45	MOV EDI, EBX	45	MOV EDI, EBX
46	XOR EBX, EBX	46	XOR EBX, EBX
47	REPE CMPSB	47	REPE CMPSB
48	MOV AL, DSBYTE[ ESI-1]	48	MOV AL, DSBYTE[ ESI-1]
49	MOV BL, DSBYTE[ EDI-1]	49	MOV BL, DSBYTE[ EDI-1]
50	SUB EAX, EBX	50	SUB EAX, EBX
51	L1:	51	L1:
52	}	52	}
53	}	53	}
54		54
55		55
56	inline fastcall unsigned int strlen( EDI)	56	inline fastcall unsigned int strlen( EDI)
57	{	57	{
58	$xor eax, eax	58	$xor eax, eax
59	$mov ecx, -1	59	$mov ecx, -1
60	$REPNE $SCASB	60	$REPNE $SCASB
61	EAX-=2+ECX;	61	EAX-=2+ECX;
62	}	62	}
63		63
64		64
65	inline fastcall void strcpy( EDI, ESI)	65	inline fastcall void strcpy( EDI, ESI)
66	{	66	{
67	$cld	67	$cld
68	L2:	68	L2:
69	$lodsb	69	$lodsb
70	$stosb	70	$stosb
71	$test al,al	71	$test al,al
72	$jnz L2	72	$jnz L2
73	}	73	}
74		74
75		75
76	inline fastcall int strlcpy(dword ESI, EDI, EBX)	76	inline fastcall int strlcpy(dword ESI, EDI, EBX)
77	{	77	{
78	if (EBX<0) return -1;	78	if (EBX<0) return -1;
79	EDX=0;	79	EDX=0;
80	do {	80	do {
81	DSBYTE[ESI]=DSBYTE[EDI];	81	DSBYTE[ESI]=DSBYTE[EDI];
82	ESI++;	82	ESI++;
83	EDI++;	83	EDI++;
84	EDX++;	84	EDX++;
85	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}	85	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
86	} while(DSBYTE[EDI-1]!='\0');	86	} while(DSBYTE[EDI-1]!='\0');
87	return 0;	87	return 0;
88	}	88	}
89		89
90	inline fastcall strtrim( ESI)	90	inline fastcall strtrim( ESI)
91	{	91	{
92	EDI = ESI;	92	EDI = ESI;
93	do{	93	do{
94	AL=DSBYTE[EDI];	94	AL=DSBYTE[EDI];
95	if (AL != '\32') && (AL != '\13') && (AL != '\10')	95	if (AL != '\32') && (AL != '\13') && (AL != '\10')
96	{	96	{
97	DSBYTE[ESI]=AL;	97	DSBYTE[ESI]=AL;
98	ESI++;	98	ESI++;
99	}	99	}
100	EDI++;	100	EDI++;
101	}while(AL!=0);	101	}while(AL!=0);
102	DSBYTE[ESI] = '\0';	102	DSBYTE[ESI] = '\0';
103	}	103	}
104		104
105		105
106	inline fastcall void strcat( EDI, ESI)	106	inline fastcall void strcat( EDI, ESI)
107	{	107	{
108	asm {	108	asm {
109	mov ebx, edi	109	mov ebx, edi
110	xor ecx, ecx	110	xor ecx, ecx
111	xor eax, eax	111	xor eax, eax
112	dec ecx	112	dec ecx
113	repne scasb	113	repne scasb
114	dec edi	114	dec edi
115	mov edx, edi	115	mov edx, edi
116	mov edi, esi	116	mov edi, esi
117	xor ecx, ecx	117	xor ecx, ecx
118	xor eax, eax	118	xor eax, eax
119	dec ecx	119	dec ecx
120	repne scasb	120	repne scasb
121	xor ecx, 0ffffffffh	121	xor ecx, 0ffffffffh
122	mov edi, edx	122	mov edi, edx
123	mov edx, ecx	123	mov edx, ecx
124	mov eax, edi	124	mov eax, edi
125	shr ecx, 2	125	shr ecx, 2
126	rep movsd	126	rep movsd
127	mov ecx, edx	127	mov ecx, edx
128	and ecx, 3	128	and ecx, 3
129	rep movsb	129	rep movsb
130	mov eax, ebx	130	mov eax, ebx
131	}	131	}
132	}	132	}
133		133
134	inline fastcall void chrcat(ESI, BL)	134	inline fastcall void chrcat(ESI, BL)
135	{	135	{
136	EDI = strlen(ESI);	136	EDI = strlen(ESI);
137	ESBYTE[ESI+EDI] = BL;	137	ESBYTE[ESI+EDI] = BL;
138	ESBYTE[ESI+EDI+1] = 0;	138	ESBYTE[ESI+EDI+1] = 0;
139	}	139	}
140		140
141		141
142	inline fastcall signed int strchr( ESI,BL)	142	inline fastcall signed int strchr( ESI,BL)
143	{	143	{
144	int jj=0;	144	int jj=0;
145	do{	145	do{
146	jj++;	146	jj++;
147	$lodsb	147	$lodsb
148	IF(AL==BL) return jj;	148	IF(AL==BL) return jj;
149	} while(AL!=0);	149	} while(AL!=0);
150	return 0;	150	return 0;
151	}	151	}
152		152
153		153
154	inline fastcall signed int strrchr( ESI,BL)	154	inline fastcall signed int strrchr( ESI,BL)
155	{	155	{
156	int jj=0, last=0;	156	int jj=0, last=0;
157	do{	157	do{
158	jj++;	158	jj++;
159	$lodsb	159	$lodsb
160	IF(AL==BL) last=jj;	160	IF(AL==BL) last=jj;
161	} while(AL!=0);	161	} while(AL!=0);
162	return last;	162	return last;
163	}	163	}
164		164
165		165
166	int chrnum(dword searchin, char symbol)	166	int chrnum(dword searchin, char symbol)
167	{	167	{
168	int num = 0;	168	int num = 0;
169	while(DSBYTE[searchin])	169	while(DSBYTE[searchin])
170	{	170	{
171	if (DSBYTE[searchin] == symbol) num++;	171	if (DSBYTE[searchin] == symbol) num++;
172	searchin++;	172	searchin++;
173	}	173	}
174	return num;	174	return num;
175	}	175	}
176		176
177		177
178	inline fastcall signed int strstr( EBX, EDX)	178	inline fastcall signed int strstr( EBX, EDX)
179	{	179	{
180	asm {	180	asm {
181	MOV EDI, EDX	181	MOV EDI, EDX
182	XOR ECX, ECX	182	XOR ECX, ECX
183	XOR EAX, EAX	183	XOR EAX, EAX
184	DEC ECX	184	DEC ECX
185	REPNE SCASB	185	REPNE SCASB
186	NOT ECX	186	NOT ECX
187	DEC ECX	187	DEC ECX
188	JE LS2	188	JE LS2
189	MOV ESI, ECX	189	MOV ESI, ECX
190	XOR ECX, ECX	190	XOR ECX, ECX
191	MOV EDI, EBX	191	MOV EDI, EBX
192	DEC ECX	192	DEC ECX
193	REPNE SCASB	193	REPNE SCASB
194	NOT ECX	194	NOT ECX
195	SUB ECX, ESI	195	SUB ECX, ESI
196	JBE LS2	196	JBE LS2
197	MOV EDI, EBX	197	MOV EDI, EBX
198	LEA EBX, DSDWORD[ ESI-1]	198	LEA EBX, DSDWORD[ ESI-1]
199	LS1: MOV ESI, EDX	199	LS1: MOV ESI, EDX
200	LODSB	200	LODSB
201	REPNE SCASB	201	REPNE SCASB
202	JNE LS2	202	JNE LS2
203	MOV EAX, ECX	203	MOV EAX, ECX
204	PUSH EDI	204	PUSH EDI
205	MOV ECX, EBX	205	MOV ECX, EBX
206	REPE CMPSB	206	REPE CMPSB
207	POP EDI	207	POP EDI
208	MOV ECX, EAX	208	MOV ECX, EAX
209	JNE LS1	209	JNE LS1
210	LEA EAX, DSDWORD[ EDI-1]	210	LEA EAX, DSDWORD[ EDI-1]
211	JMP SHORT LS3	211	JMP SHORT LS3
212	LS2: XOR EAX, EAX	212	LS2: XOR EAX, EAX
213	LS3:	213	LS3:
214	}	214	}
215	}	215	}
216		216
217	dword strcmpi(dword cmp1, cmp2)	217	dword strcmpi(dword cmp1, cmp2)
218	{	218	{
219	char si, ue;	219	char si, ue;
220		220
221	loop()	221	loop()
222	{	222	{
223	si = DSBYTE[cmp1];	223	si = DSBYTE[cmp1];
224	ue = DSBYTE[cmp2];	224	ue = DSBYTE[cmp2];
225	if (si>='A') && (si<='Z') si +=32;	225	if (si>='A') && (si<='Z') si +=32;
226	if (ue>='A') && (ue<='Z') ue +=32;	226	if (ue>='A') && (ue<='Z') ue +=32;
227	if (si != ue) return -1;	227	if (si != ue) return -1;
228	cmp1++;	228	cmp1++;
229	cmp2++;	229	cmp2++;
230	if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;	230	if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
231	if (DSBYTE[cmp1]=='\0') return -1;	231	if (DSBYTE[cmp1]=='\0') return -1;
232	if (DSBYTE[cmp2]=='\0') return 1;	232	if (DSBYTE[cmp2]=='\0') return 1;
233	}	233	}
234	}	234	}
235		235
236	dword strstri(dword searchin, usestr_s)	236	dword strstri(dword searchin, usestr_s)
237	{	237	{
238	dword usestr_e = usestr_s;	238	dword usestr_e = usestr_s;
239	char si, ue;	239	char si, ue;
240		240
241	while(DSBYTE[searchin])	241	while(DSBYTE[searchin])
242	{	242	{
243	si = DSBYTE[searchin];	243	si = DSBYTE[searchin];
244	ue = DSBYTE[usestr_e];	244	ue = DSBYTE[usestr_e];
245	if (si>='A') && (si<='Z') si +=32;	245	if (si>='A') && (si<='Z') si +=32;
246	if (ue>='A') && (ue<='Z') ue +=32;	246	if (ue>='A') && (ue<='Z') ue +=32;
247	if (si == ue) usestr_e++; else usestr_e = usestr_s;	247	if (si == ue) usestr_e++; else usestr_e = usestr_s;
248	searchin++;	248	searchin++;
249	if (DSBYTE[usestr_e]=='\0') return searchin;	249	if (DSBYTE[usestr_e]=='\0') return searchin;
250	}	250	}
251	return 0;	251	return 0;
252	}	252	}
253		253
254		254
255	unsigned int strcpyb(dword search_in, copyin, startstr, endstr)	255	unsigned int strcpyb(dword search_in, copyin, startstr, endstr)
256	{	256	{
257	dword startp, endp;	257	dword startp, endp;
258	dword copyin_start_off = copyin;	258	dword copyin_start_off = copyin;
259	if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);	259	if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);
260	endp = strstri(startp, endstr);	260	endp = strstri(startp, endstr);
261	if (endp==0) endp = startp+strlen(search_in);	261	if (endp==0) endp = startp+strlen(search_in);
262	//if (startp==endp) return 0;	262	//if (startp==endp) return 0;
263	do	263	do
264	{	264	{
265	DSBYTE[copyin] = DSBYTE[startp];	265	DSBYTE[copyin] = DSBYTE[startp];
266	copyin++;	266	copyin++;
267	startp++;	267	startp++;
268	}	268	}
269	while (startp	269	while (startp
270	DSBYTE[copyin] = '\0';	270	DSBYTE[copyin] = '\0';
271	return copyin_start_off;	271	return copyin_start_off;
272	}	272	}
273		273
274		274
275	/void strcat(char to, char *from) //òîæå ðàáîòàåò	275	/void strcat(char to, char *from) //òîæå ðàáîòàåò
276	{	276	{
277	while(*to) to++;	277	while(*to) to++;
278	while(*from)	278	while(*from)
279	{	279	{
280	to = from;	280	to = from;
281	to++;	281	to++;
282	from++;	282	from++;
283	}	283	}
284	*to = '\0';	284	*to = '\0';
285	}*/	285	}*/
286		286
287		287
288	inline fastcall dword atoi( EDI)	288	inline fastcall dword atoi( EDI)
289	{	289	{
290	$push ebx	290	$push ebx
291	$push esi	291	$push esi
292	ESI=EDI;	292	ESI=EDI;
293	while (DSBYTE[ESI]==' ') ESI++;	293	while (DSBYTE[ESI]==' ') ESI++;
294	if (DSBYTE[ESI]=='-') ESI++;	294	if (DSBYTE[ESI]=='-') ESI++;
295	EAX=0;	295	EAX=0;
296	while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')	296	while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
297	{	297	{
298	$xor ebx, ebx	298	$xor ebx, ebx
299	EBX = DSBYTE[ESI]-'0';	299	EBX = DSBYTE[ESI]-'0';
300	EAX *= 10;	300	EAX *= 10;
301	EAX += EBX;	301	EAX += EBX;
302	ESI++;	302	ESI++;
303	}	303	}
304	IF (DSBYTE[EDI]=='-') -EAX;	304	IF (DSBYTE[EDI]=='-') -EAX;
305	$pop esi	305	$pop esi
306	$pop ebx	306	$pop ebx
307	}	307	}
308		308
309		309
310		310
311	inline fastcall strupr( ESI)	311	inline fastcall strupr( ESI)
312	{	312	{
313	do{	313	do{
314	AL=DSBYTE[ESI];	314	AL=DSBYTE[ESI];
315	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;	315	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
316	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï	316	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï
317	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï	317	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï
318	ESI++;	318	ESI++;
319	}while(AL!=0);	319	}while(AL!=0);
320	}	320	}
321		321
322	inline fastcall strlwr( ESI)	322	inline fastcall strlwr( ESI)
323	{	323	{
324	do{	324	do{
325	$LODSB	325	$LODSB
326	IF(AL>='A')&&(AL<='Z'){	326	IF(AL>='A')&&(AL<='Z'){
327	AL+=0x20;	327	AL+=0x20;
328	DSBYTE[ESI-1]=AL;	328	DSBYTE[ESI-1]=AL;
329	CONTINUE;	329	CONTINUE;
330	}	330	}
331	}while(AL!=0);	331	}while(AL!=0);
332	}	332	}
333		333
334	inline fastcall strttl( EDX)	334	inline fastcall strttl( EDX)
335	{	335	{
336	AL=DSBYTE[EDX];	336	AL=DSBYTE[EDX];
337	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;	337	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
338	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï	338	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï
339	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï	339	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï
340	do{	340	do{
341	EDX++;	341	EDX++;
342	AL=DSBYTE[EDX];	342	AL=DSBYTE[EDX];
343	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}	343	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}
344	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯	344	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯
345	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï	345	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï
346	}while(AL!=0);	346	}while(AL!=0);
347	}	347	}
348		348
349		349
350	dword itoa( ESI)	350	dword itoa( ESI)
351	{	351	{
352	unsigned char buffer[11];	352	unsigned char buffer[11];
353	$pusha	353	$pusha
354	EDI = #buffer;	354	EDI = #buffer;
355	ECX = 10;	355	ECX = 10;
356	if (ESI < 0)	356	if (ESI < 0)
357	{	357	{
358	$mov al, '-'	358	$mov al, '-'
359	$stosb	359	$stosb
360	$neg esi	360	$neg esi
361	}	361	}
362		362
363	$mov eax, esi	363	$mov eax, esi
364	$push -'0'	364	$push -'0'
365	F2:	365	F2:
366	$xor edx, edx	366	$xor edx, edx
367	$div ecx	367	$div ecx
368	$push edx	368	$push edx
369	$test eax, eax	369	$test eax, eax
370	$jnz F2	370	$jnz F2
371	F3:	371	F3:
372	$pop eax	372	$pop eax
373	$add al, '0'	373	$add al, '0'
374	$stosb	374	$stosb
375	$jnz F3	375	$jnz F3
376		376
377	$mov al, '\0'	377	$mov al, '\0'
378	$stosb	378	$stosb
379		379
380	$popa	380	$popa
381	return #buffer;	381	return #buffer;
382	}	382	}
383		383
384	inline fastcall itoa_(signed int EDI, ESI)	384	inline fastcall itoa_(signed int EDI, ESI)
385	{	385	{
386	$pusha	386	$pusha
387	EBX = EDI;	387	EBX = EDI;
388	ECX = 10;	388	ECX = 10;
389	if (ESI > 90073741824)	389	if (ESI > 90073741824)
390	{	390	{
391	$mov al, '-'	391	$mov al, '-'
392	$stosb	392	$stosb
393	$neg esi	393	$neg esi
394	}	394	}
395		395
396	$mov eax, esi	396	$mov eax, esi
397	$push -'0'	397	$push -'0'
398	F2:	398	F2:
399	$xor edx, edx	399	$xor edx, edx
400	$div ecx	400	$div ecx
401	$push edx	401	$push edx
402	$test eax, eax	402	$test eax, eax
403	$jnz F2	403	$jnz F2
404	F3:	404	F3:
405	$pop eax	405	$pop eax
406	$add al, '0'	406	$add al, '0'
407	$stosb	407	$stosb
408	$jnz F3	408	$jnz F3
409		409
410	$mov al, '\0'	410	$mov al, '\0'
411	$stosb	411	$stosb
412		412
413	$popa	413	$popa
414	return EBX;	414	return EBX;
415	}	415	}
416		416
417	void debugi(dword d_int)	417	void debugi(dword d_int)
418	{	418	{
419	char tmpch[12];	419	char tmpch[12];
420	itoa_(#tmpch, d_int);	420	itoa_(#tmpch, d_int);
421	debug(#tmpch);	421	debugln(#tmpch);
422	}	422	}
423		423
424		424
425	#define strncpy strcpyn	425	#define strncpy strcpyn
426	#define strnmov strmovn	426	#define strnmov strmovn
427	#define stricmp strcmpi	427	#define stricmp strcmpi
428	#define strcmpn strncmp	428	#define strcmpn strncmp
429	>	429	>
430	>	430	>
431	>	431	>
432	>	432	>
433	>	433	>

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 4639 → 4645