WebSVN – Kolibri OS – Diff – /programs/fs/Eolite/trunk/lib/strings.h


//CODED by Veliant, Leency 2008-2012. GNU GPL licence.
 
 
inline fastcall dword strlen( EDI)
{
	asm {
	  xor ecx, ecx
	  xor eax, eax
	  dec ecx
	  repne scasb
	  sub eax, 2
	  sub eax, ecx
	}
}
 
 
inline fastcall copystr( ESI,EDI)
{
	$cld
L1:
	$lodsb
	$stosb
	$test al,al
	$jnz L1
}
 
char buffer[11];
inline fastcall dword IntToStr( ESI)
{
     $mov     edi, #buffer
     $mov     ecx, 10
     $test     esi, esi
     $jns     F1
     $mov     al, '-'
     $stosb
     $neg     esi
F1:
     $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     eax, #buffer
 
}
 
inline fastcall dword StrToInt()
{
	ESI=EDI=EAX;
	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;
}
 
dword StrToCol(char* htmlcolor)
{
  dword j, color=0;
  char ch=0x00;
  
  FOR (j=0; j<6; j++)
  {
    ch=ESBYTE[htmlcolor+j];
    IF ((ch>='0') && (ch<='9')) ch -= '0';
    IF ((ch>='A') && (ch<='F')) ch -= 'A'-10;
    IF ((ch>='a') && (ch<='f')) ch -= 'a'-10;
    color = color*0x10 + ch;
  }
   return color;
}
 
inline fastcall signed char 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 strchr(ESI,BL)
{
	int jj=0, last=-1;
	do{
		jj++;
		$lodsb
		IF(AL==BL) last=jj;
	} while(AL!=0);
	return last;
}
 
 
inline fastcall TitleCase( 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 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
	}
}
>

Rev 3050	Rev 3113
1	//CODED by Veliant, Leency 2008-2012. GNU GPL licence.	1	//CODED by Veliant, Leency 2008-2012. GNU GPL licence.
2		2
3		3
4	inline fastcall dword strlen( EDI)	4	inline fastcall dword strlen( EDI)
5	{	5	{
6	asm {	6	asm {
7	xor ecx, ecx	7	xor ecx, ecx
8	xor eax, eax	8	xor eax, eax
9	dec ecx	9	dec ecx
10	repne scasb	10	repne scasb
11	sub eax, 2	11	sub eax, 2
12	sub eax, ecx	12	sub eax, ecx
13	}	13	}
14	}	14	}
15		15
16		16
17	inline fastcall copystr( ESI,EDI)	17	inline fastcall copystr( ESI,EDI)
18	{	18	{
19	$cld	19	$cld
20	l1:	20	L1:
21	$lodsb	21	$lodsb
22	$stosb	22	$stosb
23	$test al,al	23	$test al,al
24	$jnz l1	24	$jnz L1
25	}	25	}
26		26
27	char buffer[11];	27	char buffer[11];
28	inline fastcall dword IntToStr( ESI)	28	inline fastcall dword IntToStr( ESI)
29	{	29	{
30	$mov edi, #buffer	30	$mov edi, #buffer
31	$mov ecx, 10	31	$mov ecx, 10
32	$test esi, esi	32	$test esi, esi
33	$jns f1	33	$jns F1
34	$mov al, '-'	34	$mov al, '-'
35	$stosb	35	$stosb
36	$neg esi	36	$neg esi
37	f1:	37	F1:
38	$mov eax, esi	38	$mov eax, esi
39	$push -'0'	39	$push -'0'
40	f2:	40	F2:
41	$xor edx, edx	41	$xor edx, edx
42	$div ecx	42	$div ecx
43	$push edx	43	$push edx
44	$test eax, eax	44	$test eax, eax
45	$jnz f2	45	$jnz F2
46	f3:	46	F3:
47	$pop eax	47	$pop eax
48	$add al, '0'	48	$add al, '0'
49	$stosb	49	$stosb
50	$jnz f3	50	$jnz F3
51	$mov eax, #buffer	51	$mov eax, #buffer
52	//$ret	-
53	}	52	}
54		53
55	inline fastcall dword StrToInt()	54	inline fastcall dword StrToInt()
56	{	55	{
57	ESI=EDI=EAX;	56	ESI=EDI=EAX;
58	IF(DSBYTE[ESI]=='-')ESI++;	57	IF(DSBYTE[ESI]=='-')ESI++;
59	EAX=0;	58	EAX=0;
60	BH=AL;	59	BH=AL;
61	do{	60	do{
62	BL=DSBYTE[ESI]-'0';	61	BL=DSBYTE[ESI]-'0';
63	EAX=EAX*10+EBX;	62	EAX=EAX*10+EBX;
64	ESI++;	63	ESI++;
65	}while(DSBYTE[ESI]>0);	64	}while(DSBYTE[ESI]>0);
66	IF(DSBYTE[EDI]=='-') -EAX;	65	IF(DSBYTE[EDI]=='-') -EAX;
67	}	66	}
68		67
69	dword StrToCol(char* htmlcolor)	68	dword StrToCol(char* htmlcolor)
70	{	69	{
71	dword j, color=0;	70	dword j, color=0;
72	char ch=0x00;	71	char ch=0x00;
73		72
74	FOR (j=0; j<6; j++)	73	FOR (j=0; j<6; j++)
75	{	74	{
76	ch=ESBYTE[htmlcolor+j];	75	ch=ESBYTE[htmlcolor+j];
77	IF ((ch>='0') && (ch<='9')) ch -= '0';	76	IF ((ch>='0') && (ch<='9')) ch -= '0';
78	IF ((ch>='A') && (ch<='F')) ch -= 'A'-10;	77	IF ((ch>='A') && (ch<='F')) ch -= 'A'-10;
79	IF ((ch>='a') && (ch<='f')) ch -= 'a'-10;	78	IF ((ch>='a') && (ch<='f')) ch -= 'a'-10;
80	color = color*0x10 + ch;	79	color = color*0x10 + ch;
81	}	80	}
82	return color;	81	return color;
83	}	82	}
84		83
85	inline fastcall signed char strcmp(ESI, EDI)	84	inline fastcall signed char strcmp(ESI, EDI)
86	{	85	{
87	loop()	86	loop()
88	{	87	{
89	IF (DSBYTE[ESI]	88	IF (DSBYTE[ESI]
90	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;	89	IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
91	IF (DSBYTE[ESI]=='\0') RETURN 0;	90	IF (DSBYTE[ESI]=='\0') RETURN 0;
92	ESI++;	91	ESI++;
93	EDI++;	92	EDI++;
94	}	93	}
95	}	94	}
96		95
97		96
98		97
99	inline fastcall signed int strchr(ESI,BL)	98	inline fastcall signed int strchr(ESI,BL)
100	{	99	{
101	int jj=0, last=-1;	100	int jj=0, last=-1;
102	do{	101	do{
103	jj++;	102	jj++;
104	$lodsb	103	$lodsb
105	IF(AL==BL) last=jj;	104	IF(AL==BL) last=jj;
106	} while(AL!=0);	105	} while(AL!=0);
107	return last;	106	return last;
108	}	107	}
109		108
110		109
111	inline fastcall TitleCase( EDX)	110	inline fastcall TitleCase( EDX)
112	{	111	{
113	AL=DSBYTE[EDX];	112	AL=DSBYTE[EDX];
114	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;	113	IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
115	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï	114	IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //à-ï
116	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï	115	IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //à-ï
117	do{	116	do{
118	EDX++;	117	EDX++;
119	AL=DSBYTE[EDX];	118	AL=DSBYTE[EDX];
120	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}	119	IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL\|0x20; CONTINUE;}
121	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯	120	IF(AL>='')&&(AL<='')DSBYTE[EDX]=AL\|0x20; // -¯
122	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï	121	IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //à-ï
123	}while(AL!=0);	122	}while(AL!=0);
124	}	123	}
125		124
126		125
127		126
128	inline fastcall strcpy( EDI, ESI)	127	inline fastcall strcpy( EDI, ESI)
129	{	128	{
130	$cld	129	$cld
131	l2:	130	L2:
132	$lodsb	131	$lodsb
133	$stosb	132	$stosb
134	$test al,al	133	$test al,al
135	$jnz l2	134	$jnz L2
136	}	135	}
137		136
138		137
139	inline fastcall strcat( EDI, ESI)	138	inline fastcall strcat( EDI, ESI)
140	{	139	{
141	asm {	140	asm {
142	mov ebx, edi	141	mov ebx, edi
143	xor ecx, ecx	142	xor ecx, ecx
144	xor eax, eax	143	xor eax, eax
145	dec ecx	144	dec ecx
146	repne scasb	145	repne scasb
147	dec edi	146	dec edi
148	mov edx, edi	147	mov edx, edi
149	mov edi, esi	148	mov edi, esi
150	xor ecx, ecx	149	xor ecx, ecx
151	xor eax, eax	150	xor eax, eax
152	dec ecx	151	dec ecx
153	repne scasb	152	repne scasb
154	xor ecx, 0ffffffffh	153	xor ecx, 0ffffffffh
155	mov edi, edx	154	mov edi, edx
156	mov edx, ecx	155	mov edx, ecx
157	mov eax, edi	156	mov eax, edi
158	shr ecx, 2	157	shr ecx, 2
159	rep movsd	158	rep movsd
160	mov ecx, edx	159	mov ecx, edx
161	and ecx, 3	160	and ecx, 3
162	rep movsb	161	rep movsb
163	mov eax, ebx	162	mov eax, ebx
164	}	163	}
165	}	164	}
166	>	165	>

Subversion Repositories Kolibri OS

(root)/programs/fs/Eolite/trunk/lib/strings.h – Rev 3050 → 3113