2015-07-22 21:32:54 +03:00
|
|
|
|
#ifndef INCLUDE_STRING_H
|
|
|
|
|
#define INCLUDE_STRING_H
|
2015-08-04 18:48:36 +03:00
|
|
|
|
#print "[include <strings.h>]\n"
|
2015-07-22 21:32:54 +03:00
|
|
|
|
|
|
|
|
|
#ifndef INCLUDE_MEM_H
|
|
|
|
|
#include "../lib/mem.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-11-26 19:26:15 +04:00
|
|
|
|
//------------------------------------------------------------------------------
|
2015-07-11 19:44:18 +03:00
|
|
|
|
// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2
|
|
|
|
|
// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"
|
2012-11-26 19:26:15 +04:00
|
|
|
|
// strcmp( ESI, EDI)
|
|
|
|
|
// strlen( EDI)
|
2015-08-10 18:59:20 +03:00
|
|
|
|
// utf8_strlen( ESI)
|
2012-12-15 04:16:06 +04:00
|
|
|
|
// strcpy( EDI, ESI) --- 0 if ==
|
2015-09-05 17:04:04 +03:00
|
|
|
|
// strlcpy(dword text1,text2,signed length)
|
2012-11-26 19:26:15 +04:00
|
|
|
|
// strcat( EDI, ESI)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
// strncat(dword text1,text2,signed length) --- pasting the text of a certain length
|
2013-03-11 22:16:24 +04:00
|
|
|
|
// strchr( ESI,BL) --- find first BL
|
|
|
|
|
// strrchr( ESI,BL) --- find last BL
|
2012-11-26 19:26:15 +04:00
|
|
|
|
// strstr( EBX, EDX)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
// itoa(signed long number) --- convert the number as a string
|
|
|
|
|
// atoi(dword text) --- convert a string as a number
|
2012-11-26 19:26:15 +04:00
|
|
|
|
// strupr( ESI)
|
2015-08-07 01:37:34 +03:00
|
|
|
|
// strlwr( ESI) --- Cyrillic symbols may not work
|
2012-11-26 19:26:15 +04:00
|
|
|
|
// strttl( EDX)
|
|
|
|
|
// strtok( ESI)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)
|
|
|
|
|
// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)
|
|
|
|
|
// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides
|
2013-04-04 21:07:38 +04:00
|
|
|
|
// chrnum(dword searchin, char symbol)
|
2012-12-15 04:16:06 +04:00
|
|
|
|
// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
|
2012-12-19 21:37:24 +04:00
|
|
|
|
// strnumb(dword searchin, startstr, endstr) --- get number between strings
|
2015-07-11 19:01:28 +03:00
|
|
|
|
// strdup(dword text) --- allocation under the text
|
2012-11-26 19:26:15 +04:00
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
2015-07-11 19:01:28 +03:00
|
|
|
|
/*
|
2012-11-26 19:26:15 +04:00
|
|
|
|
inline fastcall signed int strcmp( ESI, EDI)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
IF (DSBYTE[ESI]<DSBYTE[EDI]) RETURN -1;
|
|
|
|
|
IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
|
|
|
|
|
IF (DSBYTE[ESI]=='\0') RETURN 0;
|
|
|
|
|
ESI++;
|
|
|
|
|
EDI++;
|
|
|
|
|
}
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
2015-07-11 19:01:28 +03:00
|
|
|
|
*/
|
2012-11-26 19:26:15 +04:00
|
|
|
|
|
2015-07-22 21:32:54 +03:00
|
|
|
|
|
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline int strspn(dword text1,text2)
|
2015-07-11 19:44:18 +03:00
|
|
|
|
{
|
|
|
|
|
dword beg;
|
|
|
|
|
char s1,s2;
|
|
|
|
|
int ret;
|
|
|
|
|
ret = 0;
|
|
|
|
|
beg = text2;
|
|
|
|
|
do {
|
|
|
|
|
s1 = ESBYTE[text1];
|
|
|
|
|
text2 = beg;
|
|
|
|
|
do {
|
|
|
|
|
s2 = ESBYTE[text2];
|
|
|
|
|
if(s1==s2)
|
|
|
|
|
{
|
|
|
|
|
if(!s2)break;
|
|
|
|
|
$inc ret
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else $inc text2
|
|
|
|
|
} while(s2);
|
|
|
|
|
$inc text1
|
|
|
|
|
} while(s1);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline dword strpbrk(dword text1,text2)
|
2015-07-11 19:44:18 +03:00
|
|
|
|
{
|
|
|
|
|
char s,ss;
|
|
|
|
|
dword beg;
|
|
|
|
|
beg = text2;
|
|
|
|
|
do {
|
|
|
|
|
s = ESBYTE[text1];
|
|
|
|
|
text2 = beg;
|
|
|
|
|
do {
|
|
|
|
|
ss = ESBYTE[text2];
|
|
|
|
|
if(ss==s) return text1;
|
|
|
|
|
$inc text2
|
|
|
|
|
} while(ss);
|
|
|
|
|
$inc text1
|
|
|
|
|
} while(s);
|
|
|
|
|
return text1;
|
|
|
|
|
}
|
2012-11-26 19:26:15 +04:00
|
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 14:54:26 +03:00
|
|
|
|
/*
|
|
|
|
|
inline signed int strncmp(dword text1,text2,len)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
|
|
|
|
|
$dec len
|
|
|
|
|
if(!len)return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
*/
|
2012-11-26 19:26:15 +04:00
|
|
|
|
inline fastcall unsigned int strlen( EDI)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$xor eax, eax
|
|
|
|
|
$mov ecx, -1
|
|
|
|
|
$REPNE $SCASB
|
|
|
|
|
EAX-=2+ECX;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline strnlen(dword str, dword maxlen)
|
|
|
|
|
{
|
|
|
|
|
dword cp;
|
|
|
|
|
for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
|
|
|
|
|
return cp - str;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-10 18:59:20 +03:00
|
|
|
|
inline fastcall unsigned int utf8_strlen( ESI)
|
|
|
|
|
{
|
|
|
|
|
$xor ecx, ecx
|
|
|
|
|
_loop:
|
|
|
|
|
$lodsb
|
|
|
|
|
$test al, al
|
|
|
|
|
$jz _done
|
|
|
|
|
$and al, 0xc0
|
|
|
|
|
$cmp al, 0x80
|
|
|
|
|
$jz _loop
|
|
|
|
|
$inc ecx
|
|
|
|
|
$jmp _loop
|
|
|
|
|
|
|
|
|
|
_done:
|
|
|
|
|
return ECX;
|
|
|
|
|
}
|
2015-07-11 19:01:28 +03:00
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline signed int strcmp(dword text1, text2)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
{
|
|
|
|
|
char s1,s2;
|
|
|
|
|
dword p1,p2;
|
|
|
|
|
p1 = text1;
|
|
|
|
|
p2 = text2;
|
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
s1 = DSBYTE[text1];
|
|
|
|
|
s2 = DSBYTE[text2];
|
|
|
|
|
if(s1==s2)
|
|
|
|
|
{
|
|
|
|
|
if(s1==0) return 0;
|
|
|
|
|
}
|
|
|
|
|
else {
|
2015-07-11 19:44:18 +03:00
|
|
|
|
return s1-s2;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
}
|
|
|
|
|
$inc text1
|
|
|
|
|
$inc text2
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
2016-11-20 14:10:10 +03:00
|
|
|
|
:bool strequ(dword text1, text2) {
|
2016-01-15 02:05:51 +03:00
|
|
|
|
if (!strcmp(text1,text2)) return true; else return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
/*
|
|
|
|
|
signed int strncmp(dword s1, s2, signed n)
|
|
|
|
|
unsigned char _s1,_s2;
|
|
|
|
|
{
|
|
|
|
|
if (n == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
do {
|
|
|
|
|
_s1 = DSBYTE[s1];
|
|
|
|
|
_s2 = DSBYTE[s2];
|
|
|
|
|
if (_s1 != _s2)
|
|
|
|
|
{
|
|
|
|
|
$dec s2
|
|
|
|
|
return _s1 - _s2;
|
|
|
|
|
}
|
|
|
|
|
$inc s2
|
|
|
|
|
if (_s1 == 0)
|
|
|
|
|
break;
|
|
|
|
|
$inc s1
|
|
|
|
|
$dec n
|
|
|
|
|
} while (n);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
*/
|
|
|
|
|
|
2012-11-26 19:26:15 +04:00
|
|
|
|
|
2013-03-11 22:16:24 +04:00
|
|
|
|
inline fastcall void strcpy( EDI, ESI)
|
2012-11-26 19:26:15 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$cld
|
2012-12-15 04:16:06 +04:00
|
|
|
|
L2:
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$lodsb
|
|
|
|
|
$stosb
|
|
|
|
|
$test al,al
|
|
|
|
|
$jnz L2
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-19 21:37:24 +04:00
|
|
|
|
inline fastcall int strlcpy(dword ESI, EDI, EBX)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
if (EBX<0) return -1;
|
|
|
|
|
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;
|
2012-12-19 21:37:24 +04:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-11 19:01:28 +03:00
|
|
|
|
/*
|
|
|
|
|
inline fastcall void strtrim( ESI)
|
2013-04-05 09:35:28 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
EDI = ESI;
|
|
|
|
|
do{
|
|
|
|
|
AL=DSBYTE[EDI];
|
|
|
|
|
if (AL != '\32') && (AL != '\13') && (AL != '\10')
|
|
|
|
|
{
|
|
|
|
|
DSBYTE[ESI]=AL;
|
|
|
|
|
$inc ESI
|
|
|
|
|
}
|
|
|
|
|
$inc EDI
|
|
|
|
|
}while(AL!=0);
|
|
|
|
|
DSBYTE[ESI] = '\0';
|
|
|
|
|
}
|
|
|
|
|
*/
|
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline byte __isWhite(int s){ if (s==13)||(s==32)||(s==10)||(s==9) return true; return false; }
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline void strltrim(dword text){
|
2015-07-11 19:01:28 +03:00
|
|
|
|
int s;
|
|
|
|
|
dword back_text;
|
|
|
|
|
back_text = text;
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
while(__isWhite(s))
|
|
|
|
|
{
|
|
|
|
|
$inc text
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
}
|
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
ESBYTE[back_text] = s;
|
|
|
|
|
$inc back_text
|
|
|
|
|
if(!s) break;
|
|
|
|
|
$inc text
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline void strrtrim(dword text)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
{
|
|
|
|
|
int s;
|
|
|
|
|
dword p;
|
|
|
|
|
do {
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
if(__isWhite(s))
|
2013-04-05 09:35:28 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
p = text;
|
|
|
|
|
while(__isWhite(s))
|
|
|
|
|
{
|
|
|
|
|
$inc text;
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
}
|
2013-04-05 09:35:28 +04:00
|
|
|
|
}
|
2015-07-11 19:01:28 +03:00
|
|
|
|
else $inc text
|
|
|
|
|
} while(s);
|
|
|
|
|
$dec text
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
if(__isWhite(s)) ESBYTE[p] = 0;
|
2013-04-05 09:35:28 +04:00
|
|
|
|
}
|
2012-12-19 21:37:24 +04:00
|
|
|
|
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline void strtrim(dword text){
|
2015-07-11 19:01:28 +03:00
|
|
|
|
int s;
|
|
|
|
|
dword p,back_text;
|
|
|
|
|
back_text = text;
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
while(__isWhite(s))
|
|
|
|
|
{
|
|
|
|
|
$inc text
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
}
|
|
|
|
|
do {
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
if(__isWhite(s))
|
|
|
|
|
{
|
|
|
|
|
p = back_text;
|
|
|
|
|
while(__isWhite(s))
|
|
|
|
|
{
|
|
|
|
|
ESBYTE[back_text] = s;
|
|
|
|
|
$inc back_text
|
|
|
|
|
$inc text;
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
ESBYTE[back_text] = s;
|
|
|
|
|
$inc back_text
|
|
|
|
|
$inc text
|
|
|
|
|
}
|
|
|
|
|
} while(s);
|
|
|
|
|
$dec text
|
|
|
|
|
s = ESBYTE[text];
|
|
|
|
|
if(__isWhite(s)) ESBYTE[p] = 0;
|
|
|
|
|
}
|
2012-12-19 21:37:24 +04:00
|
|
|
|
|
2013-03-11 22:16:24 +04:00
|
|
|
|
inline fastcall void strcat( EDI, ESI)
|
2012-11-26 19:26:15 +04:00
|
|
|
|
{
|
|
|
|
|
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
|
2015-07-11 19:01:28 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void strncat(dword text1, text2, signed len)
|
|
|
|
|
signed o1,o2;
|
|
|
|
|
char s;
|
|
|
|
|
{
|
2015-07-16 04:44:30 +03:00
|
|
|
|
s = DSBYTE[text1];
|
2015-07-11 19:01:28 +03:00
|
|
|
|
while(s){
|
|
|
|
|
$inc text1
|
2015-07-16 04:44:30 +03:00
|
|
|
|
s = DSBYTE[text1];
|
2015-07-11 19:01:28 +03:00
|
|
|
|
}
|
|
|
|
|
o1 = len/4;
|
|
|
|
|
o2 = len-4*o1;
|
|
|
|
|
while(o1){
|
2015-07-16 04:44:30 +03:00
|
|
|
|
DSDWORD[text1] = DSDWORD[text2];
|
2015-07-11 19:01:28 +03:00
|
|
|
|
text1 += 4;
|
|
|
|
|
text2 += 4;
|
|
|
|
|
$dec o1
|
|
|
|
|
}
|
|
|
|
|
while(o2){
|
2015-07-16 04:44:30 +03:00
|
|
|
|
DSBYTE[text1] = DSBYTE[text2];
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$inc text1
|
|
|
|
|
$inc text2
|
|
|
|
|
$dec o2
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
2015-07-16 04:44:30 +03:00
|
|
|
|
DSBYTE[text1] = 0;
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
2013-03-11 22:16:24 +04:00
|
|
|
|
inline fastcall void chrcat(ESI, BL)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
EDI = strlen(ESI);
|
|
|
|
|
ESBYTE[ESI+EDI] = BL;
|
|
|
|
|
ESBYTE[ESI+EDI+1] = 0;
|
2013-03-11 22:16:24 +04:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-22 21:32:54 +03:00
|
|
|
|
inline dword strchr(dword shb;char s)
|
|
|
|
|
{
|
|
|
|
|
char ss;
|
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
ss = DSBYTE[shb];
|
|
|
|
|
if(!ss)return 0;
|
|
|
|
|
if(ss==s)return shb;
|
|
|
|
|
shb++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-12-19 21:37:24 +04:00
|
|
|
|
|
|
|
|
|
inline fastcall signed int strrchr( ESI,BL)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
int jj=0, last=0;
|
|
|
|
|
do{
|
|
|
|
|
jj++;
|
|
|
|
|
$lodsb
|
|
|
|
|
IF(AL==BL) last=jj;
|
|
|
|
|
} while(AL!=0);
|
|
|
|
|
return last;
|
2012-12-19 21:37:24 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int chrnum(dword searchin, char symbol)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
int num = 0;
|
|
|
|
|
while(DSBYTE[searchin])
|
|
|
|
|
{
|
|
|
|
|
if (DSBYTE[searchin] == symbol) num++;
|
|
|
|
|
searchin++;
|
|
|
|
|
}
|
|
|
|
|
return num;
|
2012-12-19 21:37:24 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-03-11 22:16:24 +04:00
|
|
|
|
inline fastcall signed int strstr( EBX, EDX)
|
2012-12-19 21:37:24 +04:00
|
|
|
|
{
|
|
|
|
|
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:
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline dword strcmpi(dword cmp1, cmp2)
|
2013-11-14 04:39:19 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
char si, ue;
|
|
|
|
|
|
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
si = DSBYTE[cmp1];
|
|
|
|
|
ue = DSBYTE[cmp2];
|
|
|
|
|
if (si>='A') && (si<='Z') si +=32;
|
|
|
|
|
if (ue>='A') && (ue<='Z') ue +=32;
|
|
|
|
|
if (si != ue) return -1;
|
|
|
|
|
cmp1++;
|
|
|
|
|
cmp2++;
|
|
|
|
|
if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
|
|
|
|
|
if (DSBYTE[cmp1]=='\0') return -1;
|
|
|
|
|
if (DSBYTE[cmp2]=='\0') return 1;
|
|
|
|
|
}
|
2013-11-14 04:39:19 +04:00
|
|
|
|
}
|
2012-12-19 21:37:24 +04:00
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline dword strstri(dword searchin, usestr_s)
|
2012-12-19 21:37:24 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
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;
|
|
|
|
|
}
|
2016-01-01 19:51:53 +03:00
|
|
|
|
return -1;
|
2012-12-19 21:37:24 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline unsigned int strcpyb(dword search_in, copyin, startstr, endstr)
|
2012-12-19 21:37:24 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
dword startp, endp;
|
|
|
|
|
dword copyin_start_off = copyin;
|
|
|
|
|
if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);
|
|
|
|
|
endp = strstri(startp, endstr);
|
|
|
|
|
if (endp==0) endp = startp+strlen(search_in);
|
|
|
|
|
//if (startp==endp) return 0;
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
DSBYTE[copyin] = DSBYTE[startp];
|
|
|
|
|
copyin++;
|
|
|
|
|
startp++;
|
|
|
|
|
}
|
|
|
|
|
while (startp<endp);
|
|
|
|
|
DSBYTE[copyin] = '\0';
|
|
|
|
|
return copyin_start_off;
|
2012-12-19 21:37:24 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-02-18 23:49:48 +03:00
|
|
|
|
/*void strcat(char *to, char *from)
|
2012-12-06 11:49:06 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
while(*to) to++;
|
|
|
|
|
while(*from)
|
|
|
|
|
{
|
|
|
|
|
*to = *from;
|
|
|
|
|
to++;
|
|
|
|
|
from++;
|
|
|
|
|
}
|
|
|
|
|
*to = '\0';
|
2012-12-06 11:49:06 +04:00
|
|
|
|
}*/
|
|
|
|
|
|
2012-11-26 19:26:15 +04:00
|
|
|
|
|
|
|
|
|
inline fastcall dword atoi( EDI)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$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
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
inline fastcall strupr( ESI)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
do{
|
|
|
|
|
AL=DSBYTE[ESI];
|
|
|
|
|
IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
|
|
|
|
|
IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32; //<2F>-<2D>
|
|
|
|
|
IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80; //<2F>-<2D>
|
|
|
|
|
ESI++;
|
|
|
|
|
}while(AL!=0);
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline fastcall strlwr( ESI)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
do{
|
|
|
|
|
$LODSB
|
|
|
|
|
IF(AL>='A')&&(AL<='Z'){
|
|
|
|
|
AL+=0x20;
|
|
|
|
|
DSBYTE[ESI-1]=AL;
|
|
|
|
|
CONTINUE;
|
|
|
|
|
}
|
|
|
|
|
}while(AL!=0);
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline fastcall strttl( EDX)
|
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
AL=DSBYTE[EDX];
|
|
|
|
|
IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
|
|
|
|
|
IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32; //<2F>-<2D>
|
|
|
|
|
IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80; //<2F>-<2D>
|
|
|
|
|
do{
|
|
|
|
|
EDX++;
|
|
|
|
|
AL=DSBYTE[EDX];
|
|
|
|
|
IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
|
|
|
|
|
IF(AL>='<EFBFBD>')&&(AL<='<EFBFBD>')DSBYTE[EDX]=AL|0x20; //<2F>-<2D>
|
|
|
|
|
IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80; //<2F>-<2D>
|
|
|
|
|
}while(AL!=0);
|
2012-11-26 19:26:15 +04:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-11 19:01:28 +03:00
|
|
|
|
/*
|
2013-11-05 03:27:39 +04:00
|
|
|
|
dword itoa( ESI)
|
|
|
|
|
{
|
2014-03-13 04:31:31 +04:00
|
|
|
|
unsigned char buffer[11];
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$pusha
|
|
|
|
|
EDI = #buffer;
|
|
|
|
|
ECX = 10;
|
|
|
|
|
if (ESI < 0)
|
|
|
|
|
{
|
|
|
|
|
$mov al, '-'
|
|
|
|
|
$stosb
|
|
|
|
|
$neg esi
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$mov eax, esi
|
|
|
|
|
$push -'0'
|
2013-11-05 03:27:39 +04:00
|
|
|
|
F2:
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$xor edx, edx
|
|
|
|
|
$div ecx
|
|
|
|
|
$push edx
|
|
|
|
|
$test eax, eax
|
|
|
|
|
$jnz F2
|
2013-11-05 03:27:39 +04:00
|
|
|
|
F3:
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$pop eax
|
|
|
|
|
$add al, '0'
|
|
|
|
|
$stosb
|
|
|
|
|
$jnz F3
|
|
|
|
|
|
|
|
|
|
$mov al, '\0'
|
|
|
|
|
$stosb
|
|
|
|
|
|
|
|
|
|
$popa
|
2013-11-05 03:27:39 +04:00
|
|
|
|
return #buffer;
|
|
|
|
|
}
|
2015-07-11 19:01:28 +03:00
|
|
|
|
*/
|
2015-07-21 04:10:37 +03:00
|
|
|
|
:unsigned char BUF_ITOA[11];
|
2015-07-12 02:45:19 +03:00
|
|
|
|
inline dword itoa(signed long number)
|
2013-11-05 03:27:39 +04:00
|
|
|
|
{
|
2015-07-16 04:44:30 +03:00
|
|
|
|
dword ret,p;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
byte cmd;
|
|
|
|
|
long mask,tmp;
|
|
|
|
|
mask = 1000000000;
|
|
|
|
|
cmd = true;
|
2015-07-21 04:10:37 +03:00
|
|
|
|
p = #BUF_ITOA;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
if(!number){
|
2015-07-16 04:44:30 +03:00
|
|
|
|
ESBYTE[p] = '0';
|
|
|
|
|
ESBYTE[p+1] = 0;
|
|
|
|
|
return p;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
}
|
2015-07-16 04:44:30 +03:00
|
|
|
|
ret = p;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
if(number<0)
|
2013-11-05 03:27:39 +04:00
|
|
|
|
{
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$neg number
|
2015-07-16 04:44:30 +03:00
|
|
|
|
ESBYTE[p] = '-';
|
|
|
|
|
$inc p
|
2013-11-05 03:27:39 +04:00
|
|
|
|
}
|
2015-07-11 19:01:28 +03:00
|
|
|
|
while(mask)
|
|
|
|
|
{
|
|
|
|
|
tmp = number / mask;
|
|
|
|
|
tmp = tmp%10;
|
|
|
|
|
|
|
|
|
|
if(cmd){
|
|
|
|
|
if(tmp){
|
2015-07-16 04:44:30 +03:00
|
|
|
|
ESBYTE[p] = tmp + '0';
|
|
|
|
|
$inc p
|
2015-07-11 19:01:28 +03:00
|
|
|
|
cmd = false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
2015-07-16 04:44:30 +03:00
|
|
|
|
ESBYTE[p] = tmp + '0';
|
|
|
|
|
$inc p
|
2015-07-11 19:01:28 +03:00
|
|
|
|
}
|
|
|
|
|
mask /= 10;
|
|
|
|
|
}
|
2015-07-16 04:44:30 +03:00
|
|
|
|
ESBYTE[p] = 0;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
2015-07-16 04:44:30 +03:00
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline fastcall itoa_(signed int EDI, ESI)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
{
|
|
|
|
|
$pusha
|
|
|
|
|
EBX = EDI;
|
|
|
|
|
ECX = 10;
|
|
|
|
|
if (ESI > 90073741824)
|
|
|
|
|
{
|
|
|
|
|
$mov al, '-'
|
|
|
|
|
$stosb
|
|
|
|
|
$neg esi
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$mov eax, esi
|
|
|
|
|
$push -'0'
|
2013-11-05 03:27:39 +04:00
|
|
|
|
F2:
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$xor edx, edx
|
|
|
|
|
$div ecx
|
|
|
|
|
$push edx
|
|
|
|
|
$test eax, eax
|
|
|
|
|
$jnz F2
|
2013-11-05 03:27:39 +04:00
|
|
|
|
F3:
|
2015-07-11 19:01:28 +03:00
|
|
|
|
$pop eax
|
|
|
|
|
$add al, '0'
|
|
|
|
|
$stosb
|
|
|
|
|
$jnz F3
|
|
|
|
|
|
|
|
|
|
$mov al, '\0'
|
|
|
|
|
$stosb
|
|
|
|
|
|
|
|
|
|
$popa
|
2013-11-05 03:27:39 +04:00
|
|
|
|
return EBX;
|
2015-07-11 19:01:28 +03:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline dword memchr(dword s,int c,signed len)
|
2015-07-16 04:44:30 +03:00
|
|
|
|
{
|
|
|
|
|
if(!len) return NULL;
|
|
|
|
|
do {
|
|
|
|
|
if(DSBYTE[s] == c) return s;
|
|
|
|
|
$inc s
|
|
|
|
|
$dec len
|
|
|
|
|
} while(len);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline dword strdup(dword text)
|
2015-07-11 19:01:28 +03:00
|
|
|
|
{
|
|
|
|
|
dword l = strlen(text);
|
|
|
|
|
dword ret = malloc(l+1);
|
2015-07-16 04:44:30 +03:00
|
|
|
|
if(!ret) return NULL;
|
2015-09-05 17:04:04 +03:00
|
|
|
|
strlcpy(ret,text,l);
|
2015-07-11 19:01:28 +03:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
2013-11-05 03:27:39 +04:00
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline dword strndup(dword str, signed maxlen)
|
2015-07-12 02:45:19 +03:00
|
|
|
|
{
|
|
|
|
|
dword copy,len;
|
|
|
|
|
|
|
|
|
|
len = strnlen(str, maxlen);
|
|
|
|
|
copy = malloc(len + 1);
|
|
|
|
|
if (copy != NULL)
|
|
|
|
|
{
|
2015-09-05 17:04:04 +03:00
|
|
|
|
strlcpy(copy, str, len);
|
2015-07-12 02:45:19 +03:00
|
|
|
|
DSBYTE[len+copy] = '\0';
|
|
|
|
|
}
|
|
|
|
|
return copy;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-20 02:09:56 +03:00
|
|
|
|
inline dword hexdec(dword text)
|
|
|
|
|
{
|
|
|
|
|
char s;
|
|
|
|
|
dword ret,l;
|
|
|
|
|
ret = 0;
|
|
|
|
|
s = DSBYTE[text];
|
|
|
|
|
while(s)
|
|
|
|
|
{
|
|
|
|
|
ret <<= 4;
|
|
|
|
|
if(s>='A')&&(s<='F')ret |= s-'A'+10;
|
|
|
|
|
else if(s>='a')&&(s<='f')ret |= s-'a'+10;
|
2015-07-22 21:32:54 +03:00
|
|
|
|
else if(s>='0')&&(s<='9')ret |= s-'0';
|
2015-07-20 02:09:56 +03:00
|
|
|
|
text++;
|
|
|
|
|
s = DSBYTE[text];
|
|
|
|
|
}
|
2015-07-22 21:32:54 +03:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline signed csshexdec(dword text)
|
|
|
|
|
{
|
|
|
|
|
char s;
|
|
|
|
|
dword ret,l;
|
|
|
|
|
byte tmp;
|
|
|
|
|
l = strlen(text);
|
|
|
|
|
ret = 0;
|
|
|
|
|
s = DSBYTE[text];
|
|
|
|
|
tmp = 0;
|
|
|
|
|
if(l==6) while(s)
|
2015-07-20 02:09:56 +03:00
|
|
|
|
{
|
|
|
|
|
ret <<= 4;
|
|
|
|
|
if(s>='A')&&(s<='F')ret |= s-'A'+10;
|
|
|
|
|
else if(s>='a')&&(s<='f')ret |= s-'a'+10;
|
2015-07-22 21:32:54 +03:00
|
|
|
|
else if(s>='0')&&(s<='9')ret |= s-'0';
|
2015-07-20 02:09:56 +03:00
|
|
|
|
text++;
|
|
|
|
|
s = DSBYTE[text];
|
2015-07-22 21:32:54 +03:00
|
|
|
|
}
|
|
|
|
|
else if(l==3) while(s)
|
|
|
|
|
{
|
|
|
|
|
ret |= tmp;
|
|
|
|
|
ret <<= 4;
|
|
|
|
|
ret |= tmp;
|
|
|
|
|
ret <<= 4;
|
|
|
|
|
if(s>='A')&&(s<='F')tmp = s-'A'+10;
|
|
|
|
|
else if(s>='a')&&(s<='f')tmp = s-'a'+10;
|
|
|
|
|
else if(s>='0')&&(s<='9')tmp = s-'0';
|
|
|
|
|
text++;
|
|
|
|
|
s = DSBYTE[text];
|
|
|
|
|
}
|
2015-07-20 02:09:56 +03:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline cdecl int sprintf(dword buf, format,...)
|
2015-07-16 04:44:30 +03:00
|
|
|
|
{
|
|
|
|
|
byte s;
|
|
|
|
|
char X[10];
|
|
|
|
|
dword ret, tmp, l;
|
|
|
|
|
dword arg = #format;
|
|
|
|
|
ret = buf;
|
|
|
|
|
s = DSBYTE[format];
|
|
|
|
|
while(s){
|
|
|
|
|
if(s=='%'){
|
|
|
|
|
arg+=4;
|
|
|
|
|
tmp = DSDWORD[arg];
|
|
|
|
|
if(tmp==END_ARGS)goto END_FUNC_SPRINTF;
|
|
|
|
|
$inc format
|
|
|
|
|
s = DSBYTE[format];
|
|
|
|
|
if(!s)goto END_FUNC_SPRINTF;
|
|
|
|
|
switch(s)
|
|
|
|
|
{
|
|
|
|
|
case 's':
|
|
|
|
|
l = tmp;
|
|
|
|
|
s = DSBYTE[tmp];
|
|
|
|
|
while(s)
|
|
|
|
|
{
|
|
|
|
|
DSBYTE[buf] = s;
|
|
|
|
|
$inc tmp
|
|
|
|
|
$inc buf
|
|
|
|
|
s = DSBYTE[tmp];
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case 'c':
|
|
|
|
|
DSBYTE[buf] = tmp;
|
|
|
|
|
$inc buf
|
|
|
|
|
break;
|
|
|
|
|
case 'u': //if(tmp<0)return ret;
|
|
|
|
|
case 'd':
|
|
|
|
|
case 'i':
|
|
|
|
|
tmp = itoa(tmp);
|
|
|
|
|
if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
|
|
|
|
|
l = strlen(tmp);
|
2015-08-02 14:41:41 +03:00
|
|
|
|
strlcpy(buf,tmp,l);
|
2015-07-16 04:44:30 +03:00
|
|
|
|
buf += l;
|
|
|
|
|
break;
|
|
|
|
|
case 'a':
|
|
|
|
|
case 'A':
|
2015-08-02 14:41:41 +03:00
|
|
|
|
strlcpy(buf,"0x00000000",10);
|
2015-07-16 04:44:30 +03:00
|
|
|
|
buf+=10;
|
|
|
|
|
l=buf;
|
|
|
|
|
while(tmp)
|
|
|
|
|
{
|
|
|
|
|
$dec buf
|
|
|
|
|
s=tmp&0xF;
|
|
|
|
|
if(s>9)DSBYTE[buf]='A'+s-10;
|
|
|
|
|
else DSBYTE[buf]='0'+s;
|
|
|
|
|
tmp>>=4;
|
|
|
|
|
}
|
|
|
|
|
buf=l;
|
|
|
|
|
break;
|
|
|
|
|
case 'p':
|
|
|
|
|
tmp = itoa(#tmp);
|
|
|
|
|
if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
|
|
|
|
|
l = strlen(tmp);
|
2015-08-02 14:41:41 +03:00
|
|
|
|
strlcpy(buf,tmp,l);
|
2015-07-16 04:44:30 +03:00
|
|
|
|
buf += l;
|
|
|
|
|
break;
|
|
|
|
|
case '%':
|
|
|
|
|
DSBYTE[buf] = '%';
|
|
|
|
|
$inc buf
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
goto END_FUNC_SPRINTF;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
DSBYTE[buf] = s;
|
|
|
|
|
$inc buf
|
|
|
|
|
}
|
|
|
|
|
$inc format
|
|
|
|
|
s = DSBYTE[format];
|
|
|
|
|
}
|
|
|
|
|
END_FUNC_SPRINTF:
|
|
|
|
|
DSBYTE[buf] = 0;
|
|
|
|
|
return buf-ret;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-22 21:32:54 +03:00
|
|
|
|
inline signed strcoll(dword text1,text2)
|
|
|
|
|
{
|
|
|
|
|
char s,ss;
|
|
|
|
|
loop()
|
|
|
|
|
{
|
|
|
|
|
s = DSBYTE[text2];
|
|
|
|
|
ss=strchr(text1,s);
|
|
|
|
|
if(ss)return ss;
|
|
|
|
|
text2++;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-26 19:26:15 +04:00
|
|
|
|
#define strnmov strmovn
|
|
|
|
|
#define stricmp strcmpi
|
|
|
|
|
#define strcmpn strncmp
|
2013-04-12 04:15:39 +04:00
|
|
|
|
|
2015-07-22 21:32:54 +03:00
|
|
|
|
#endif
|