WebSVN – Kolibri OS – Diff – /programs/network/htmlv/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
	}
}
 
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 3054	Rev 3058
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		132
133	dword itoa( ESI)	133	dword itoa( ESI)
134	{	134	{
135	unsigned char buffer[11];	135	unsigned char buffer[11];
136	EDI = #buffer;	136	EDI = #buffer;
137	ECX = 10;	137	ECX = 10;
138	if (ESI < 0)	138	if (ESI < 0)
139	{	139	{
140	$mov al, '-'	140	$mov al, '-'
141	$stosb	141	$stosb
142	$neg esi	142	$neg esi
143	}	143	}
144		144
145	$mov eax, esi	145	$mov eax, esi
146	$push -'0'	146	$push -'0'
147	f2:	147	f2:
148	$xor edx, edx	148	$xor edx, edx
149	$div ecx	149	$div ecx
150	$push edx	150	$push edx
151	$test eax, eax	151	$test eax, eax
152	$jnz f2	152	$jnz f2
153	f3:	153	f3:
154	$pop eax	154	$pop eax
155	$add al, '0'	155	$add al, '0'
156	$stosb	156	$stosb
157	$jnz f3	157	$jnz f3
158		158
159	$mov al, '\0'	159	$mov al, '\0'
160	$stosb	160	$stosb
161		161
162	return #buffer;	162	return #buffer;
163	}	163	}
164		164
165		165
166		166
167	inline fastcall dword atoi( EDI)	167	inline fastcall dword atoi( EDI)
168	{	168	{
169	ESI=EDI;	169	ESI=EDI;
170	IF(DSBYTE[ESI]=='-')ESI++;	170	IF(DSBYTE[ESI]=='-')ESI++;
171	EAX=0;	171	EAX=0;
172	BH=AL;	172	BH=AL;
173	do{	173	do{
174	BL=DSBYTE[ESI]-'0';	174	BL=DSBYTE[ESI]-'0';
175	EAX=EAX*10+EBX;	175	EAX=EAX*10+EBX;
176	ESI++;	176	ESI++;
177	}while(DSBYTE[ESI]>0);	177	}while(DSBYTE[ESI]>0);
178	IF(DSBYTE[EDI]=='-') -EAX;	178	IF(DSBYTE[EDI]=='-') -EAX;
179	}	179	}
180		180
181		181
182	inline fastcall signed int strchr( ESI,BL)	182	inline fastcall signed int strchr( ESI,BL)
183	{	183	{
184	int jj=0;	184	int jj=0;
185	do{	185	do{
186	jj++;	186	jj++;
187	$lodsb	187	$lodsb
188	IF(AL==BL) return jj;	188	IF(AL==BL) return jj;
189	} while(AL!=0);	189	} while(AL!=0);
190	return 0;	190	return 0;
191	}	191	}
192		192
193		193
194	inline fastcall signed int strrchr( ESI,BL)	194	inline fastcall signed int strrchr( ESI,BL)
195	{	195	{
196	int jj=0, last=-1;	196	int jj=0, last=0;
197	do{	197	do{
198	jj++;	198	jj++;
199	$lodsb	199	$lodsb
200	IF(AL==BL) last=jj;	200	IF(AL==BL) last=jj;
201	} while(AL!=0);	201	} while(AL!=0);
202	return last;	202	return last;
203	}	203	}
204		204
205		205
206	inline fastcall strupr( ESI)	206	inline fastcall strupr( ESI)
207	{	207	{
208	do{	208	do{
209	AL=DSBYTE[ESI];	209	AL=DSBYTE[ESI];
210	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;	210	IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
211	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï	211	IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //à-ï
212	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï	212	IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //à-ï
213	ESI++;	213	ESI++;
214	}while(AL!=0);	214	}while(AL!=0);
215	}	215	}
216		216
217	inline fastcall strlwr( ESI)	217	inline fastcall strlwr( ESI)
218	{	218	{
219	do{	219	do{
220	$LODSB	220	$LODSB
221	IF(AL>='A')&&(AL<='Z'){	221	IF(AL>='A')&&(AL<='Z'){
222	AL+=0x20;	222	AL+=0x20;
223	DSBYTE[ESI-1]=AL;	223	DSBYTE[ESI-1]=AL;
224	CONTINUE;	224	CONTINUE;
225	}	225	}
226	}while(AL!=0);	226	}while(AL!=0);
227	}	227	}
228		228
229	inline fastcall strttl( EDX)	229	inline fastcall strttl( EDX)
230	{	230	{
231	AL=DSBYTE[EDX];	231	AL=DSBYTE[EDX];
232	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;	232	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
233	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï	233	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï
234	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï	234	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï
235	do{	235	do{
236	EDX++;	236	EDX++;
237	AL=DSBYTE[EDX];	237	AL=DSBYTE[EDX];
238	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}	238	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}
239	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯	239	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯
240	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï	240	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï
241	}while(AL!=0);	241	}while(AL!=0);
242	}	242	}
243		243
244		244
245		245
246	inline fastcall dword strstr( EBX, EDX)	246	inline fastcall dword strstr( EBX, EDX)
247	{	247	{
248	asm {	248	asm {
249	MOV EDI, EDX	249	MOV EDI, EDX
250	XOR ECX, ECX	250	XOR ECX, ECX
251	XOR EAX, EAX	251	XOR EAX, EAX
252	DEC ECX	252	DEC ECX
253	REPNE SCASB	253	REPNE SCASB
254	NOT ECX	254	NOT ECX
255	DEC ECX	255	DEC ECX
256	JE LS2	256	JE LS2
257	MOV ESI, ECX	257	MOV ESI, ECX
258	XOR ECX, ECX	258	XOR ECX, ECX
259	MOV EDI, EBX	259	MOV EDI, EBX
260	DEC ECX	260	DEC ECX
261	REPNE SCASB	261	REPNE SCASB
262	NOT ECX	262	NOT ECX
263	SUB ECX, ESI	263	SUB ECX, ESI
264	JBE LS2	264	JBE LS2
265	MOV EDI, EBX	265	MOV EDI, EBX
266	LEA EBX, DSDWORD[ ESI-1]	266	LEA EBX, DSDWORD[ ESI-1]
267	LS1: MOV ESI, EDX	267	LS1: MOV ESI, EDX
268	LODSB	268	LODSB
269	REPNE SCASB	269	REPNE SCASB
270	JNE LS2	270	JNE LS2
271	MOV EAX, ECX	271	MOV EAX, ECX
272	PUSH EDI	272	PUSH EDI
273	MOV ECX, EBX	273	MOV ECX, EBX
274	REPE CMPSB	274	REPE CMPSB
275	POP EDI	275	POP EDI
276	MOV ECX, EAX	276	MOV ECX, EAX
277	JNE LS1	277	JNE LS1
278	LEA EAX, DSDWORD[ EDI-1]	278	LEA EAX, DSDWORD[ EDI-1]
279	JMP SHORT LS3	279	JMP SHORT LS3
280	LS2: XOR EAX, EAX	280	LS2: XOR EAX, EAX
281	LS3:	281	LS3:
282	}	282	}
283	}	283	}
284		284
285		285
286		286
287		287
288	/* strtok( LPSTR dest, src, divs);	288	/* strtok( LPSTR dest, src, divs);
289	src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà	289	src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
290	dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî	290	dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
291	divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè	291	divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
292	Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò	292	Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
293	íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå	293	íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
294	â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */	294	â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
295		295
296	inline fastcall dword strtok( EDX, ESI, EBX)	296	inline fastcall dword strtok( EDX, ESI, EBX)
297	{	297	{
298	asm {	298	asm {
299	XOR ECX, ECX	299	XOR ECX, ECX
300	MOV EDI, EBX	300	MOV EDI, EBX
301	XOR EAX, EAX	301	XOR EAX, EAX
302	DEC ECX	302	DEC ECX
303	REPNE SCASB	303	REPNE SCASB
304	XOR ECX, 0FFFFFFFFH	304	XOR ECX, 0FFFFFFFFH
305	DEC ECX	305	DEC ECX
306	PUSH ECX	306	PUSH ECX
307	L1: LODSB	307	L1: LODSB
308	OR AL, AL	308	OR AL, AL
309	JZ L4	309	JZ L4
310	MOV EDI, EBX	310	MOV EDI, EBX
311	MOV ECX, SSDWORD[ ESP]	311	MOV ECX, SSDWORD[ ESP]
312	REPNE SCASB	312	REPNE SCASB
313	JZ L1	313	JZ L1
314	DEC ESI	314	DEC ESI
315	L2: LODSB	315	L2: LODSB
316	MOV EDI, EBX	316	MOV EDI, EBX
317	MOV ECX, SSDWORD[ ESP]	317	MOV ECX, SSDWORD[ ESP]
318	REPNE SCASB	318	REPNE SCASB
319	JZ L3	319	JZ L3
320	MOV DSBYTE[ EDX], AL	320	MOV DSBYTE[ EDX], AL
321	INC EDX	321	INC EDX
322	JMP SHORT L2	322	JMP SHORT L2
323	L3: MOV EAX, ESI	323	L3: MOV EAX, ESI
324	L4: POP ECX	324	L4: POP ECX
325	} DSBYTE[ EDX] = 0;	325	} DSBYTE[ EDX] = 0;
326	}	326	}
327		327
328	#define strncpy strcpyn	328	#define strncpy strcpyn
329	#define strnmov strmovn	329	#define strnmov strmovn
330	#define stricmp strcmpi	330	#define stricmp strcmpi
331	#define strcmpn strncmp	331	#define strcmpn strncmp
332	#define strncmpi strcmpni	332	#define strncmpi strcmpni
333	#define stricmpn strcmpni	333	#define stricmpn strcmpni
334	#define strnicmp strcmpni	334	#define strnicmp strcmpni
335	#define strincmp strcmpni	335	#define strincmp strcmpni
336	#define strcmpin strcmpni	336	#define strcmpin strcmpni
337	>	337	>
338	>	338	>
339	>	339	>
340	>	340	>
341	>	341	>
342	>	342	>
343	>	343	>

Subversion Repositories Kolibri OS

(root)/programs/network/htmlv/lib/strings.h – Rev 3054 → 3058