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)
{
	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 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;
}
 
 
void strcpyb(dword search_in, copyin, startstr, endstr)
{
	dword startp, endp;
	startp = strstr(search_in, startstr) + strlen(startstr);
	endp = strstri(startp, endstr);
	if (startp==endp) return;
	do
	{ 
		DSBYTE[copyin] = DSBYTE[startp];
		copyin++;
		startp++;
	}
	while (startp
	DSBYTE[copyin] = '\0';
}
 
 
/*void strcat(char *to, char *from) //òîæå ðàáîòàåò
{
	while(*to) to++;
	while(*from)
	{
		*to = *from;
		to++;
		from++;
	}
	*to = '\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 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);
}
 
void debugi(dword d_int)
{
	char tmpch[11];
	strcpy(#tmpch, itoa(d_int));
	debug(#tmpch);
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#define strncpy strcpyn
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
 
 
 
 
 
>
>
>
>
>
 

Rev 3448	Rev 3467
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	EDX=0;	78	EDX=0;
79	do {	79	do {
80	DSBYTE[ESI]=DSBYTE[EDI];	80	DSBYTE[ESI]=DSBYTE[EDI];
81	ESI++;	81	ESI++;
82	EDI++;	82	EDI++;
83	EDX++;	83	EDX++;
84	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}	84	if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
85	} while(DSBYTE[EDI-1]!='\0');	85	} while(DSBYTE[EDI-1]!='\0');
86	return 0;	86	return 0;
87	}	87	}
88		88
89	inline fastcall strtrim( ESI)	89	inline fastcall strtrim( ESI)
90	{	90	{
91	EDI = ESI;	91	EDI = ESI;
92	do{	92	do{
93	AL=DSBYTE[EDI];	93	AL=DSBYTE[EDI];
94	if (AL != '\32') && (AL != '\13') && (AL != '\10')	94	if (AL != '\32') && (AL != '\13') && (AL != '\10')
95	{	95	{
96	DSBYTE[ESI]=AL;	96	DSBYTE[ESI]=AL;
97	ESI++;	97	ESI++;
98	}	98	}
99	EDI++;	99	EDI++;
100	}while(AL!=0);	100	}while(AL!=0);
101	DSBYTE[ESI] = '\0';	101	DSBYTE[ESI] = '\0';
102	}	102	}
103		103
104		104
105	inline fastcall void strcat( EDI, ESI)	105	inline fastcall void strcat( EDI, ESI)
106	{	106	{
107	asm {	107	asm {
108	mov ebx, edi	108	mov ebx, edi
109	xor ecx, ecx	109	xor ecx, ecx
110	xor eax, eax	110	xor eax, eax
111	dec ecx	111	dec ecx
112	repne scasb	112	repne scasb
113	dec edi	113	dec edi
114	mov edx, edi	114	mov edx, edi
115	mov edi, esi	115	mov edi, esi
116	xor ecx, ecx	116	xor ecx, ecx
117	xor eax, eax	117	xor eax, eax
118	dec ecx	118	dec ecx
119	repne scasb	119	repne scasb
120	xor ecx, 0ffffffffh	120	xor ecx, 0ffffffffh
121	mov edi, edx	121	mov edi, edx
122	mov edx, ecx	122	mov edx, ecx
123	mov eax, edi	123	mov eax, edi
124	shr ecx, 2	124	shr ecx, 2
125	rep movsd	125	rep movsd
126	mov ecx, edx	126	mov ecx, edx
127	and ecx, 3	127	and ecx, 3
128	rep movsb	128	rep movsb
129	mov eax, ebx	129	mov eax, ebx
130	}	130	}
131	}	131	}
132		132
133	inline fastcall void chrcat(ESI, BL)	133	inline fastcall void chrcat(ESI, BL)
134	{	134	{
135	EDI = strlen(ESI);	135	EDI = strlen(ESI);
136	ESBYTE[ESI+EDI] = BL;	136	ESBYTE[ESI+EDI] = BL;
137	ESBYTE[ESI+EDI+1] = 0;	137	ESBYTE[ESI+EDI+1] = 0;
138	}	138	}
139		139
140		140
141	inline fastcall signed int strchr( ESI,BL)	141	inline fastcall signed int strchr( ESI,BL)
142	{	142	{
143	int jj=0;	143	int jj=0;
144	do{	144	do{
145	jj++;	145	jj++;
146	$lodsb	146	$lodsb
147	IF(AL==BL) return jj;	147	IF(AL==BL) return jj;
148	} while(AL!=0);	148	} while(AL!=0);
149	return 0;	149	return 0;
150	}	150	}
151		151
152		152
153	inline fastcall signed int strrchr( ESI,BL)	153	inline fastcall signed int strrchr( ESI,BL)
154	{	154	{
155	int jj=0, last=0;	155	int jj=0, last=0;
156	do{	156	do{
157	jj++;	157	jj++;
158	$lodsb	158	$lodsb
159	IF(AL==BL) last=jj;	159	IF(AL==BL) last=jj;
160	} while(AL!=0);	160	} while(AL!=0);
161	return last;	161	return last;
162	}	162	}
163		163
164		164
165	int chrnum(dword searchin, char symbol)	165	int chrnum(dword searchin, char symbol)
166	{	166	{
167	int num = 0;	167	int num = 0;
168	while(DSBYTE[searchin])	168	while(DSBYTE[searchin])
169	{	169	{
170	if (DSBYTE[searchin] == symbol) num++;	170	if (DSBYTE[searchin] == symbol) num++;
171	searchin++;	171	searchin++;
172	}	172	}
173	return num;	173	return num;
174	}	174	}
175		175
176		176
177	inline fastcall signed int strstr( EBX, EDX)	177	inline fastcall signed int strstr( EBX, EDX)
178	{	178	{
179	asm {	179	asm {
180	MOV EDI, EDX	180	MOV EDI, EDX
181	XOR ECX, ECX	181	XOR ECX, ECX
182	XOR EAX, EAX	182	XOR EAX, EAX
183	DEC ECX	183	DEC ECX
184	REPNE SCASB	184	REPNE SCASB
185	NOT ECX	185	NOT ECX
186	DEC ECX	186	DEC ECX
187	JE LS2	187	JE LS2
188	MOV ESI, ECX	188	MOV ESI, ECX
189	XOR ECX, ECX	189	XOR ECX, ECX
190	MOV EDI, EBX	190	MOV EDI, EBX
191	DEC ECX	191	DEC ECX
192	REPNE SCASB	192	REPNE SCASB
193	NOT ECX	193	NOT ECX
194	SUB ECX, ESI	194	SUB ECX, ESI
195	JBE LS2	195	JBE LS2
196	MOV EDI, EBX	196	MOV EDI, EBX
197	LEA EBX, DSDWORD[ ESI-1]	197	LEA EBX, DSDWORD[ ESI-1]
198	LS1: MOV ESI, EDX	198	LS1: MOV ESI, EDX
199	LODSB	199	LODSB
200	REPNE SCASB	200	REPNE SCASB
201	JNE LS2	201	JNE LS2
202	MOV EAX, ECX	202	MOV EAX, ECX
203	PUSH EDI	203	PUSH EDI
204	MOV ECX, EBX	204	MOV ECX, EBX
205	REPE CMPSB	205	REPE CMPSB
206	POP EDI	206	POP EDI
207	MOV ECX, EAX	207	MOV ECX, EAX
208	JNE LS1	208	JNE LS1
209	LEA EAX, DSDWORD[ EDI-1]	209	LEA EAX, DSDWORD[ EDI-1]
210	JMP SHORT LS3	210	JMP SHORT LS3
211	LS2: XOR EAX, EAX	211	LS2: XOR EAX, EAX
212	LS3:	212	LS3:
213	}	213	}
214	}	214	}
215		215
216		216
217	dword strstri(dword searchin, usestr_s)	217	dword strstri(dword searchin, usestr_s)
218	{	218	{
219	dword usestr_e = usestr_s;	219	dword usestr_e = usestr_s;
220	char si, ue;	220	char si, ue;
221		221
222	while(DSBYTE[searchin])	222	while(DSBYTE[searchin])
223	{	223	{
224	si = DSBYTE[searchin];	224	si = DSBYTE[searchin];
225	ue = DSBYTE[usestr_e];	225	ue = DSBYTE[usestr_e];
226	if (si>='A') && (si<='Z') si +=32;	226	if (si>='A') && (si<='Z') si +=32;
227	if (ue>='A') && (ue<='Z') ue +=32;	227	if (ue>='A') && (ue<='Z') ue +=32;
228	if (si == ue) usestr_e++; else usestr_e = usestr_s;	228	if (si == ue) usestr_e++; else usestr_e = usestr_s;
229	searchin++;	229	searchin++;
230	if (DSBYTE[usestr_e]=='\0') return searchin;	230	if (DSBYTE[usestr_e]=='\0') return searchin;
231	}	231	}
232	return 0;	232	return 0;
233	}	233	}
234		234
235		235
236	void strcpyb(dword search_in, copyin, startstr, endstr)	236	void strcpyb(dword search_in, copyin, startstr, endstr)
237	{	237	{
238	dword startp, endp;	238	dword startp, endp;
239	startp = strstr(search_in, startstr) + strlen(startstr);	239	startp = strstr(search_in, startstr) + strlen(startstr);
240	endp = strstri(startp, endstr);	240	endp = strstri(startp, endstr);
241	if (startp==endp) return;	241	if (startp==endp) return;
242	do	242	do
243	{	243	{
244	DSBYTE[copyin] = DSBYTE[startp];	244	DSBYTE[copyin] = DSBYTE[startp];
245	copyin++;	245	copyin++;
246	startp++;	246	startp++;
247	}	247	}
248	while (startp	248	while (startp
249	DSBYTE[copyin] = '\0';	249	DSBYTE[copyin] = '\0';
250	}	250	}
251		251
252		252
253	/void strcat(char to, char *from) //òîæå ðàáîòàåò	253	/void strcat(char to, char *from) //òîæå ðàáîòàåò
254	{	254	{
255	while(*to) to++;	255	while(*to) to++;
256	while(*from)	256	while(*from)
257	{	257	{
258	to = from;	258	to = from;
259	to++;	259	to++;
260	from++;	260	from++;
261	}	261	}
262	*to = '\0';	262	*to = '\0';
263	}*/	263	}*/
264		264
265	dword itoa( ESI)	265	dword itoa( ESI)
266	{	266	{
267	unsigned char buffer[11];	267	unsigned char buffer[11];
268	$pusha	268	$pusha
269		269
270	EDI = #buffer;	270	EDI = #buffer;
271	ECX = 10;	271	ECX = 10;
272	if (ESI < 0)	272	if (ESI < 0)
273	{	273	{
274	$mov al, '-'	274	$mov al, '-'
275	$stosb	275	$stosb
276	$neg esi	276	$neg esi
277	}	277	}
278		278
279	$mov eax, esi	279	$mov eax, esi
280	$push -'0'	280	$push -'0'
281	F2:	281	F2:
282	$xor edx, edx	282	$xor edx, edx
283	$div ecx	283	$div ecx
284	$push edx	284	$push edx
285	$test eax, eax	285	$test eax, eax
286	$jnz F2	286	$jnz F2
287	F3:	287	F3:
288	$pop eax	288	$pop eax
289	$add al, '0'	289	$add al, '0'
290	$stosb	290	$stosb
291	$jnz F3	291	$jnz F3
292		292
293	$mov al, '\0'	293	$mov al, '\0'
294	$stosb	294	$stosb
295		295
296	$popa	296	$popa
297	return #buffer;	297	return #buffer;
298	}	298	}
299		299
300		300
301	inline fastcall dword atoi( EDI)	301	inline fastcall dword atoi( EDI)
302	{	302	{
303	$push ebx	303	$push ebx
304	$push esi	304	$push esi
305	ESI=EDI;	305	ESI=EDI;
306	while (DSBYTE[ESI]==' ') ESI++;	306	while (DSBYTE[ESI]==' ') ESI++;
307	if (DSBYTE[ESI]=='-') ESI++;	307	if (DSBYTE[ESI]=='-') ESI++;
308	EAX=0;	308	EAX=0;
309	while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')	309	while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
310	{	310	{
311	$xor ebx, ebx	311	$xor ebx, ebx
312	EBX = DSBYTE[ESI]-'0';	312	EBX = DSBYTE[ESI]-'0';
313	EAX *= 10;	313	EAX *= 10;
314	EAX += EBX;	314	EAX += EBX;
315	ESI++;	315	ESI++;
316	}	316	}
317	IF (DSBYTE[EDI]=='-') -EAX;	317	IF (DSBYTE[EDI]=='-') -EAX;
318	$pop esi	318	$pop esi
319	$pop ebx	319	$pop ebx
320	}	320	}
321		321
322		322
323		323
324	inline fastcall strupr( ESI)	324	inline fastcall strupr( ESI)
325	{	325	{
326	do{	326	do{
327	AL=DSBYTE[ESI];	327	AL=DSBYTE[ESI];
328	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;	328	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
329	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï	329	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï
330	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï	330	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï
331	ESI++;	331	ESI++;
332	}while(AL!=0);	332	}while(AL!=0);
333	}	333	}
334		334
335	inline fastcall strlwr( ESI)	335	inline fastcall strlwr( ESI)
336	{	336	{
337	do{	337	do{
338	$LODSB	338	$LODSB
339	IF(AL>='A')&&(AL<='Z'){	339	IF(AL>='A')&&(AL<='Z'){
340	AL+=0x20;	340	AL+=0x20;
341	DSBYTE[ESI-1]=AL;	341	DSBYTE[ESI-1]=AL;
342	CONTINUE;	342	CONTINUE;
343	}	343	}
344	}while(AL!=0);	344	}while(AL!=0);
345	}	345	}
346		346
347	inline fastcall strttl( EDX)	347	inline fastcall strttl( EDX)
348	{	348	{
349	AL=DSBYTE[EDX];	349	AL=DSBYTE[EDX];
350	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;	350	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
351	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï	351	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï
352	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï	352	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï
353	do{	353	do{
354	EDX++;	354	EDX++;
355	AL=DSBYTE[EDX];	355	AL=DSBYTE[EDX];
356	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}	356	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}
357	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯	357	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯
358	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï	358	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï
359	}while(AL!=0);	359	}while(AL!=0);
360	}	360	}
361		361
362	void debugi(dword d_int)	362	void debugi(dword d_int)
363	{	363	{
364	char tmpch[11];	364	char tmpch[11];
365	strcpy(#tmpch, itoa(d_int));	365	strcpy(#tmpch, itoa(d_int));
366	debug(#tmpch);	366	debug(#tmpch);
367	}	367	}
368		368
369		-
370	/* strtok( LPSTR dest, src, divs);	-
371	src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà	-
372	dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî	-
373	divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè	-
374	Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò	-
375	íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå	-
376	â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */	-
377		-
378	inline fastcall dword strtok( EDX, ESI, EBX)	-
379	{	-
380	asm {	-
381	XOR ECX, ECX	-
382	MOV EDI, EBX	-
383	XOR EAX, EAX	-
384	DEC ECX	-
385	REPNE SCASB	-
386	XOR ECX, 0FFFFFFFFH	-
387	DEC ECX	-
388	PUSH ECX	-
389	L1: LODSB	-
390	OR AL, AL	-
391	JZ L4	-
392	MOV EDI, EBX	-
393	MOV ECX, SSDWORD[ ESP]	-
394	REPNE SCASB	-
395	JZ L1	-
396	DEC ESI	-
397	L2: LODSB	-
398	MOV EDI, EBX	-
399	MOV ECX, SSDWORD[ ESP]	-
400	REPNE SCASB	-
401	JZ L3	-
402	MOV DSBYTE[ EDX], AL	-
403	INC EDX	-
404	JMP SHORT L2	-
405	L3: MOV EAX, ESI	-
406	L4: POP ECX	-
407	} DSBYTE[ EDX] = 0;	-
408	}	369
409		370
410	#define strncpy strcpyn	371	#define strncpy strcpyn
411	#define strnmov strmovn	372	#define strnmov strmovn
412	#define stricmp strcmpi	373	#define stricmp strcmpi
413	#define strcmpn strncmp	374	#define strcmpn strncmp
414	#define strncmpi strcmpni	-
415	#define stricmpn strcmpni	-
416	#define strnicmp strcmpni	-
417	#define strincmp strcmpni	-
418	#define strcmpin strcmpni	-
-		375	>
419	>	376	>
420	>	377	>
421	>	378	>
422	>	379	>
423	>	-

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 3448 → 3467