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

Subversion Repositories Kolibri OS

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