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


//------------------------------------------------------------------------------
// strcmp( ESI, EDI)
// strlen( EDI)
// strcpy( EDI, ESI)
// strcat( EDI, ESI)
// strchr( ESI,BL)
// strrchr( ESI,BL)
// strstr( EBX, EDX)
// itoa( ESI)
// atoi( EAX)
// strupr( ESI)
// strlwr( ESI) ----- âîçìîæíî íå ïîääåðæèâàåò êèðèëëèöó
// strttl( EDX)
// strtok( ESI)
//------------------------------------------------------------------------------
 
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 signed int strcmpi( ESI,EDI)
uses EBX
{
	do{
		$lodsb
		IF(AL>='a')&&(AL<='z')AL-=0x20;
		BL=DSBYTE[(E)DI];
		IF(BL>='a')&&(BL<='z')BL-=0x20;
		AL-=BL;
		IF(!ZEROFLAG)BREAK;
		(E)DI++;
	}while(BL!=0);
}
 
inline char STRNCMPI((E)SI,(E)DI,(E)CX)
{
	(E)AX=0;
	LOOPNZ((E)CX){
		$lodsb
		IF(AL>='a')&&(AL<='z')AL-=0x20;
		AH=DSBYTE[EDI];
		IF(AH>='a')&&(AH<='z')AH-=0x20;
		EDI++;
		IF(AL==0)||(AH==0)||(AL!=AH)BREAK;
	}
	AL=AL-AH;
}*/
 
 
 
inline fastcall unsigned int strlen( EDI)
{
	$xor eax, eax
	$mov ecx, -1
	$REPNE $SCASB
	EAX-=2+ECX;
}
 
 
inline fastcall strcpy( EDI, ESI)
{
	$cld
l2:
	$lodsb
	$stosb
	$test al,al
	$jnz l2
}
 
 
inline fastcall 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 strcat(char *to, char *from) //òîæå ðàáîòàåò
{
	while(*to) to++;
	while(*from)
	{
		*to = *from;
		to++;
		from++;
	}
	*to = '\0';
}*/
 
dword itoa( ESI)
{
	unsigned char buffer[11];
	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
	 
     return #buffer;
} 
 
 
 
inline fastcall dword atoi( EDI)
{
	ESI=EDI;
	IF(DSBYTE[ESI]=='-')ESI++;
	EAX=0;
	BH=AL;
	do{
		BL=DSBYTE[ESI]-'0';
		EAX=EAX*10+EBX;
		ESI++;
	}while(DSBYTE[ESI]>0);
	IF(DSBYTE[EDI]=='-') -EAX;
}
 
 
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;
}
 
 
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);
}
 
 
 
inline fastcall dword 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:
  }
}
 
 
 
 
/* strtok( LPSTR dest, src, divs);
src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
         íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
               â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
 
inline fastcall dword strtok( EDX, ESI, EBX)
{
  asm {
    XOR ECX, ECX
    MOV EDI, EBX
    XOR EAX, EAX
    DEC ECX
    REPNE SCASB
    XOR ECX, 0FFFFFFFFH
    DEC ECX
    PUSH ECX
L1: LODSB
    OR AL, AL
    JZ L4
    MOV EDI, EBX
    MOV ECX, SSDWORD[ ESP]
    REPNE SCASB
    JZ L1
    DEC ESI
L2: LODSB
    MOV EDI, EBX
    MOV ECX, SSDWORD[ ESP]
    REPNE SCASB
    JZ L3
    MOV DSBYTE[ EDX], AL
    INC EDX
    JMP SHORT L2
L3: MOV EAX, ESI
L4: POP ECX
  } DSBYTE[ EDX] = 0;
}
 
#define strncpy strcpyn
#define strnmov strmovn
#define stricmp strcmpi
#define strcmpn strncmp
#define strncmpi strcmpni
#define stricmpn strcmpni
#define strnicmp strcmpni
#define strincmp strcmpni
#define strcmpin strcmpni
>
>
>
>
>
>
>

Rev 3067	Rev 3081
1	//------------------------------------------------------------------------------	1	//------------------------------------------------------------------------------
2	// strcmp( ESI, EDI)	2	// strcmp( ESI, EDI)
3	// strlen( EDI)	3	// strlen( EDI)
4	// strcpy( EDI, ESI)	4	// strcpy( EDI, ESI)
5	// strcat( EDI, ESI)	5	// strcat( EDI, ESI)
6	// strchr( ESI,BL)	6	// strchr( ESI,BL)
7	// strrchr( ESI,BL)	7	// strrchr( ESI,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) ----- âîçìîæíî íå ïîääåðæèâàåò êèðèëëèöó	12	// strlwr( ESI) ----- âîçìîæíî íå ïîääåðæèâàåò êèðèëëèöó
13	// strttl( EDX)	13	// strttl( EDX)
14	// strtok( ESI)	14	// strtok( ESI)
15	//------------------------------------------------------------------------------	15	//------------------------------------------------------------------------------
16		16
17	inline fastcall signed int strcmp( ESI, EDI)	17	inline fastcall signed int strcmp( ESI, EDI)
18	{	18	{
19	loop()	19	loop()
20	{	20	{
21	IF (DSBYTE[ESI]	21	IF (DSBYTE[ESI]
22	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;	22	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
23	IF (DSBYTE[ESI]=='\0') RETURN 0;	23	IF (DSBYTE[ESI]=='\0') RETURN 0;
24	ESI++;	24	ESI++;
25	EDI++;	25	EDI++;
26	}	26	}
27	}	27	}
28		28
29		29
30	inline fastcall signed int strncmp( ESI, EDI, ECX)	30	inline fastcall signed int strncmp( ESI, EDI, ECX)
31	{	31	{
32	asm {	32	asm {
33	MOV EBX, EDI	33	MOV EBX, EDI
34	XOR EAX, EAX	34	XOR EAX, EAX
35	MOV EDX, ECX	35	MOV EDX, ECX
36	OR ECX, ECX	36	OR ECX, ECX
37	JE L1	37	JE L1
38	REPNE SCASB	38	REPNE SCASB
39	SUB EDX, ECX	39	SUB EDX, ECX
40	MOV ECX, EDX	40	MOV ECX, EDX
41	MOV EDI, EBX	41	MOV EDI, EBX
42	XOR EBX, EBX	42	XOR EBX, EBX
43	REPE CMPSB	43	REPE CMPSB
44	MOV AL, DSBYTE[ ESI-1]	44	MOV AL, DSBYTE[ ESI-1]
45	MOV BL, DSBYTE[ EDI-1]	45	MOV BL, DSBYTE[ EDI-1]
46	SUB EAX, EBX	46	SUB EAX, EBX
47	L1:	47	L1:
48	}	48	}
49	}	49	}
50		50
51		51
52		52
53	/*	53	/*
54		54
55	inline fastcall signed int strcmpi( ESI,EDI)	55	inline fastcall signed int strcmpi( ESI,EDI)
56	uses EBX	56	uses EBX
57	{	57	{
58	do{	58	do{
59	$lodsb	59	$lodsb
60	IF(AL>='a')&&(AL<='z')AL-=0x20;	60	IF(AL>='a')&&(AL<='z')AL-=0x20;
61	BL=DSBYTE[(E)DI];	61	BL=DSBYTE[(E)DI];
62	IF(BL>='a')&&(BL<='z')BL-=0x20;	62	IF(BL>='a')&&(BL<='z')BL-=0x20;
63	AL-=BL;	63	AL-=BL;
64	IF(!ZEROFLAG)BREAK;	64	IF(!ZEROFLAG)BREAK;
65	(E)DI++;	65	(E)DI++;
66	}while(BL!=0);	66	}while(BL!=0);
67	}	67	}
68		68
69	inline char STRNCMPI((E)SI,(E)DI,(E)CX)	69	inline char STRNCMPI((E)SI,(E)DI,(E)CX)
70	{	70	{
71	(E)AX=0;	71	(E)AX=0;
72	LOOPNZ((E)CX){	72	LOOPNZ((E)CX){
73	$lodsb	73	$lodsb
74	IF(AL>='a')&&(AL<='z')AL-=0x20;	74	IF(AL>='a')&&(AL<='z')AL-=0x20;
75	AH=DSBYTE[EDI];	75	AH=DSBYTE[EDI];
76	IF(AH>='a')&&(AH<='z')AH-=0x20;	76	IF(AH>='a')&&(AH<='z')AH-=0x20;
77	EDI++;	77	EDI++;
78	IF(AL==0)\|\|(AH==0)\|\|(AL!=AH)BREAK;	78	IF(AL==0)\|\|(AH==0)\|\|(AL!=AH)BREAK;
79	}	79	}
80	AL=AL-AH;	80	AL=AL-AH;
81	}*/	81	}*/
82		82
83		83
84		84
85	inline fastcall unsigned int strlen( EDI)	85	inline fastcall unsigned int strlen( EDI)
86	{	86	{
87	$xor eax, eax	87	$xor eax, eax
88	$mov ecx, -1	88	$mov ecx, -1
89	$REPNE $SCASB	89	$REPNE $SCASB
90	EAX-=2+ECX;	90	EAX-=2+ECX;
91	}	91	}
92		92
93		93
94	inline fastcall strcpy( EDI, ESI)	94	inline fastcall strcpy( EDI, ESI)
95	{	95	{
96	$cld	96	$cld
97	l2:	97	l2:
98	$lodsb	98	$lodsb
99	$stosb	99	$stosb
100	$test al,al	100	$test al,al
101	$jnz l2	101	$jnz l2
102	}	102	}
103		103
104		104
105	inline fastcall strcat( EDI, ESI)	105	inline fastcall 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
-		133	/void strcat(char to, char *from) //òîæå ðàáîòàåò
-		134	{
-		135	while(*to) to++;
-		136	while(*from)
-		137	{
-		138	to = from;
-		139	to++;
-		140	from++;
-		141	}
-		142	*to = '\0';
-		143	}*/
132		144
133	dword itoa( ESI)	145	dword itoa( ESI)
134	{	146	{
135	unsigned char buffer[11];	147	unsigned char buffer[11];
136	EDI = #buffer;	148	EDI = #buffer;
137	ECX = 10;	149	ECX = 10;
138	if (ESI < 0)	150	if (ESI < 0)
139	{	151	{
140	$mov al, '-'	152	$mov al, '-'
141	$stosb	153	$stosb
142	$neg esi	154	$neg esi
143	}	155	}
144		156
145	$mov eax, esi	157	$mov eax, esi
146	$push -'0'	158	$push -'0'
147	f2:	159	f2:
148	$xor edx, edx	160	$xor edx, edx
149	$div ecx	161	$div ecx
150	$push edx	162	$push edx
151	$test eax, eax	163	$test eax, eax
152	$jnz f2	164	$jnz f2
153	f3:	165	f3:
154	$pop eax	166	$pop eax
155	$add al, '0'	167	$add al, '0'
156	$stosb	168	$stosb
157	$jnz f3	169	$jnz f3
158		170
159	$mov al, '\0'	171	$mov al, '\0'
160	$stosb	172	$stosb
161		173
162	return #buffer;	174	return #buffer;
163	}	175	}
164		176
165		177
166		178
167	inline fastcall dword atoi( EDI)	179	inline fastcall dword atoi( EDI)
168	{	180	{
169	ESI=EDI;	181	ESI=EDI;
170	IF(DSBYTE[ESI]=='-')ESI++;	182	IF(DSBYTE[ESI]=='-')ESI++;
171	EAX=0;	183	EAX=0;
172	BH=AL;	184	BH=AL;
173	do{	185	do{
174	BL=DSBYTE[ESI]-'0';	186	BL=DSBYTE[ESI]-'0';
175	EAX=EAX*10+EBX;	187	EAX=EAX*10+EBX;
176	ESI++;	188	ESI++;
177	}while(DSBYTE[ESI]>0);	189	}while(DSBYTE[ESI]>0);
178	IF(DSBYTE[EDI]=='-') -EAX;	190	IF(DSBYTE[EDI]=='-') -EAX;
179	}	191	}
180		192
181		193
182	inline fastcall signed int strchr( ESI,BL)	194	inline fastcall signed int strchr( ESI,BL)
183	{	195	{
184	int jj=0;	196	int jj=0;
185	do{	197	do{
186	jj++;	198	jj++;
187	$lodsb	199	$lodsb
188	IF(AL==BL) return jj;	200	IF(AL==BL) return jj;
189	} while(AL!=0);	201	} while(AL!=0);
190	return 0;	202	return 0;
191	}	203	}
192		204
193		205
194	inline fastcall signed int strrchr( ESI,BL)	206	inline fastcall signed int strrchr( ESI,BL)
195	{	207	{
196	int jj=0, last=0;	208	int jj=0, last=0;
197	do{	209	do{
198	jj++;	210	jj++;
199	$lodsb	211	$lodsb
200	IF(AL==BL) last=jj;	212	IF(AL==BL) last=jj;
201	} while(AL!=0);	213	} while(AL!=0);
202	return last;	214	return last;
203	}	215	}
204		216
205		217
206	inline fastcall strupr( ESI)	218	inline fastcall strupr( ESI)
207	{	219	{
208	do{	220	do{
209	AL=DSBYTE[ESI];	221	AL=DSBYTE[ESI];
210	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;	222	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
211	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï	223	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï
212	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï	224	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï
213	ESI++;	225	ESI++;
214	}while(AL!=0);	226	}while(AL!=0);
215	}	227	}
216		228
217	inline fastcall strlwr( ESI)	229	inline fastcall strlwr( ESI)
218	{	230	{
219	do{	231	do{
220	$LODSB	232	$LODSB
221	IF(AL>='A')&&(AL<='Z'){	233	IF(AL>='A')&&(AL<='Z'){
222	AL+=0x20;	234	AL+=0x20;
223	DSBYTE[ESI-1]=AL;	235	DSBYTE[ESI-1]=AL;
224	CONTINUE;	236	CONTINUE;
225	}	237	}
226	}while(AL!=0);	238	}while(AL!=0);
227	}	239	}
228		240
229	inline fastcall strttl( EDX)	241	inline fastcall strttl( EDX)
230	{	242	{
231	AL=DSBYTE[EDX];	243	AL=DSBYTE[EDX];
232	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;	244	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
233	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï	245	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï
234	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï	246	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï
235	do{	247	do{
236	EDX++;	248	EDX++;
237	AL=DSBYTE[EDX];	249	AL=DSBYTE[EDX];
238	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}	250	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}
239	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯	251	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯
240	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï	252	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï
241	}while(AL!=0);	253	}while(AL!=0);
242	}	254	}
243		255
244		256
245		257
246	inline fastcall dword strstr( EBX, EDX)	258	inline fastcall dword strstr( EBX, EDX)
247	{	259	{
248	asm {	260	asm {
249	MOV EDI, EDX	261	MOV EDI, EDX
250	XOR ECX, ECX	262	XOR ECX, ECX
251	XOR EAX, EAX	263	XOR EAX, EAX
252	DEC ECX	264	DEC ECX
253	REPNE SCASB	265	REPNE SCASB
254	NOT ECX	266	NOT ECX
255	DEC ECX	267	DEC ECX
256	JE LS2	268	JE LS2
257	MOV ESI, ECX	269	MOV ESI, ECX
258	XOR ECX, ECX	270	XOR ECX, ECX
259	MOV EDI, EBX	271	MOV EDI, EBX
260	DEC ECX	272	DEC ECX
261	REPNE SCASB	273	REPNE SCASB
262	NOT ECX	274	NOT ECX
263	SUB ECX, ESI	275	SUB ECX, ESI
264	JBE LS2	276	JBE LS2
265	MOV EDI, EBX	277	MOV EDI, EBX
266	LEA EBX, DSDWORD[ ESI-1]	278	LEA EBX, DSDWORD[ ESI-1]
267	LS1: MOV ESI, EDX	279	LS1: MOV ESI, EDX
268	LODSB	280	LODSB
269	REPNE SCASB	281	REPNE SCASB
270	JNE LS2	282	JNE LS2
271	MOV EAX, ECX	283	MOV EAX, ECX
272	PUSH EDI	284	PUSH EDI
273	MOV ECX, EBX	285	MOV ECX, EBX
274	REPE CMPSB	286	REPE CMPSB
275	POP EDI	287	POP EDI
276	MOV ECX, EAX	288	MOV ECX, EAX
277	JNE LS1	289	JNE LS1
278	LEA EAX, DSDWORD[ EDI-1]	290	LEA EAX, DSDWORD[ EDI-1]
279	JMP SHORT LS3	291	JMP SHORT LS3
280	LS2: XOR EAX, EAX	292	LS2: XOR EAX, EAX
281	LS3:	293	LS3:
282	}	294	}
283	}	295	}
284		296
285		297
286		298
287		299
288	/* strtok( LPSTR dest, src, divs);	300	/* strtok( LPSTR dest, src, divs);
289	src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà	301	src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
290	dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî	302	dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
291	divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè	303	divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
292	Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò	304	Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
293	íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå	305	íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
294	â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */	306	â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
295		307
296	inline fastcall dword strtok( EDX, ESI, EBX)	308	inline fastcall dword strtok( EDX, ESI, EBX)
297	{	309	{
298	asm {	310	asm {
299	XOR ECX, ECX	311	XOR ECX, ECX
300	MOV EDI, EBX	312	MOV EDI, EBX
301	XOR EAX, EAX	313	XOR EAX, EAX
302	DEC ECX	314	DEC ECX
303	REPNE SCASB	315	REPNE SCASB
304	XOR ECX, 0FFFFFFFFH	316	XOR ECX, 0FFFFFFFFH
305	DEC ECX	317	DEC ECX
306	PUSH ECX	318	PUSH ECX
307	L1: LODSB	319	L1: LODSB
308	OR AL, AL	320	OR AL, AL
309	JZ L4	321	JZ L4
310	MOV EDI, EBX	322	MOV EDI, EBX
311	MOV ECX, SSDWORD[ ESP]	323	MOV ECX, SSDWORD[ ESP]
312	REPNE SCASB	324	REPNE SCASB
313	JZ L1	325	JZ L1
314	DEC ESI	326	DEC ESI
315	L2: LODSB	327	L2: LODSB
316	MOV EDI, EBX	328	MOV EDI, EBX
317	MOV ECX, SSDWORD[ ESP]	329	MOV ECX, SSDWORD[ ESP]
318	REPNE SCASB	330	REPNE SCASB
319	JZ L3	331	JZ L3
320	MOV DSBYTE[ EDX], AL	332	MOV DSBYTE[ EDX], AL
321	INC EDX	333	INC EDX
322	JMP SHORT L2	334	JMP SHORT L2
323	L3: MOV EAX, ESI	335	L3: MOV EAX, ESI
324	L4: POP ECX	336	L4: POP ECX
325	} DSBYTE[ EDX] = 0;	337	} DSBYTE[ EDX] = 0;
326	}	338	}
327		339
328	#define strncpy strcpyn	340	#define strncpy strcpyn
329	#define strnmov strmovn	341	#define strnmov strmovn
330	#define stricmp strcmpi	342	#define stricmp strcmpi
331	#define strcmpn strncmp	343	#define strcmpn strncmp
332	#define strncmpi strcmpni	344	#define strncmpi strcmpni
333	#define stricmpn strcmpni	345	#define stricmpn strcmpni
334	#define strnicmp strcmpni	346	#define strnicmp strcmpni
335	#define strincmp strcmpni	347	#define strincmp strcmpni
336	#define strcmpin strcmpni	348	#define strcmpin strcmpni
337	>	349	>
338	>	350	>
339	>	351	>
340	>	352	>
341	>	353	>
342	>	354	>
343	>	355	>

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/strings.h – Rev 3067 → 3081