Subversion Repositories Kolibri OS

Rev

Rev 6887 | Rev 7286 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5598 pavelyakov 1
#ifndef INCLUDE_STRING_H
2
#define INCLUDE_STRING_H
3
 
4
#ifndef INCLUDE_MEM_H
5
#include "../lib/mem.h"
6
#endif
7
 
3067 leency 8
//------------------------------------------------------------------------------
5574 pavelyakov 9
// strspn(dword text1,text2) --- example: strspn("12 year","1234567890") -> return 2
10
// strpbrk(dword text1,text2) --- example: strpbrk("this test", " ckfi") -> return "is test"
3067 leency 11
// strcmp( ESI, EDI)
12
// strlen( EDI)
5713 leency 13
// utf8_strlen( ESI)
3107 leency 14
// strcpy( EDI, ESI) --- 0 if ==
5803 leency 15
// strlcpy(dword text1,text2,signed length)
3067 leency 16
// strcat( EDI, ESI)
5573 pavelyakov 17
// strncat(dword text1,text2,signed length) --- pasting the text of a certain length
3363 leency 18
// strchr( ESI,BL) --- find first BL
19
// strrchr( ESI,BL) --- find last BL
3067 leency 20
// strstr( EBX, EDX)
5573 pavelyakov 21
// itoa(signed long number) --- convert the number as a string
22
// atoi(dword text) --- convert a string as a number
3067 leency 23
// strupr( ESI)
5690 leency 24
// strlwr( ESI) --- Cyrillic symbols may not work
3067 leency 25
// strttl( EDX)
26
// strtok( ESI)
5573 pavelyakov 27
// strltrim(dword text) --- removes "blank" characters on the left (\r, \n and space)
28
// strrtrim(dword text) --- removes "blank" characters on the right (\r, \n and space)
29
// strtrim(dword text) --- delete "empty" characters (\ r \ n and space) on both sides
3444 leency 30
// chrnum(dword searchin, char symbol)
3107 leency 31
// strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
3128 leency 32
// strnumb(dword searchin, startstr, endstr) --- get number between strings
5573 pavelyakov 33
// strdup(dword text) --- allocation under the text
3067 leency 34
//------------------------------------------------------------------------------
35
 
5573 pavelyakov 36
/*
3067 leency 37
inline fastcall signed int strcmp( ESI, EDI)
38
{
5573 pavelyakov 39
    loop()
40
    {
41
        IF (DSBYTE[ESI]
42
        IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
43
        IF (DSBYTE[ESI]=='\0') RETURN 0;
44
        ESI++;
45
        EDI++;
46
    }
3067 leency 47
}
5573 pavelyakov 48
*/
3067 leency 49
 
5598 pavelyakov 50
 
51
 
5575 pavelyakov 52
inline int strspn(dword text1,text2)
5574 pavelyakov 53
{
54
	dword beg;
55
	char s1,s2;
56
	int ret;
57
	ret = 0;
58
	beg = text2;
59
	do {
60
		s1 = ESBYTE[text1];
61
		text2 = beg;
62
		do {
63
			s2 = ESBYTE[text2];
64
			if(s1==s2)
65
			{
66
				if(!s2)break;
67
				$inc ret
68
				break;
69
			}
70
			else $inc text2
71
		} while(s2);
72
		$inc text1
73
	} while(s1);
74
	return ret;
75
}
3067 leency 76
 
5575 pavelyakov 77
inline dword strpbrk(dword text1,text2)
5574 pavelyakov 78
{
79
	char s,ss;
80
	dword beg;
81
	beg = text2;
82
	do {
83
		s = ESBYTE[text1];
84
		text2 = beg;
85
		do {
86
			ss = ESBYTE[text2];
87
			if(ss==s) return text1;
88
			$inc text2
89
		} while(ss);
90
		$inc text1
91
	} while(s);
92
	return text1;
93
}
94
 
3067 leency 95
inline fastcall signed int strncmp( ESI, EDI, ECX)
96
{
97
  asm {
98
    MOV EBX, EDI
99
    XOR EAX, EAX
100
    MOV EDX, ECX
101
    OR ECX, ECX
102
    JE L1
103
    REPNE SCASB
104
    SUB EDX, ECX
105
    MOV ECX, EDX
106
    MOV EDI, EBX
107
    XOR EBX, EBX
108
    REPE CMPSB
109
    MOV AL, DSBYTE[ ESI-1]
110
    MOV BL, DSBYTE[ EDI-1]
111
    SUB EAX, EBX
112
L1:
113
  }
114
}
115
 
5606 pavelyakov 116
/*
117
inline signed int strncmp(dword text1,text2,len)
118
{
119
 
120
	loop()
121
	{
122
		if(DSBYTE[text1]!=DSBYTE[text2])return text1-text2;
123
		$dec len
124
		if(!len)return 0;
125
	}
126
}
127
*/
3067 leency 128
inline fastcall unsigned int strlen( EDI)
129
{
5573 pavelyakov 130
    $xor eax, eax
131
    $mov ecx, -1
132
    $REPNE $SCASB
133
    EAX-=2+ECX;
3067 leency 134
}
135
 
5575 pavelyakov 136
inline strnlen(dword str, dword maxlen)
137
{
138
	dword cp;
139
	for (cp = str; (maxlen != 0) && (DSBYTE[cp] != '\0'); cp++, maxlen--);
140
	return cp - str;
141
}
3067 leency 142
 
5713 leency 143
inline fastcall unsigned int utf8_strlen( ESI)
144
{
145
 $xor  ecx, ecx
146
  _loop:
147
 $lodsb
148
 $test  al, al
149
 $jz  _done
150
 $and al, 0xc0
151
 $cmp al, 0x80
152
 $jz  _loop
153
 $inc ecx
154
 $jmp _loop
155
 
156
  _done:
157
 return ECX;
158
}
5575 pavelyakov 159
 
160
inline signed int strcmp(dword text1, text2)
5573 pavelyakov 161
{
162
	char s1,s2;
163
	dword p1,p2;
164
	p1 = text1;
165
	p2 = text2;
166
	loop()
167
	{
168
		s1 = DSBYTE[text1];
169
		s2 = DSBYTE[text2];
170
		if(s1==s2)
171
		{
172
			if(s1==0) return 0;
173
		}
174
		else {
5574 pavelyakov 175
			return s1-s2;
5573 pavelyakov 176
		}
177
		$inc text1
178
		$inc text2
179
	}
180
	return 0;
181
}
182
 
6730 leency 183
:bool strequ(dword text1, text2) {
6058 leency 184
	if (!strcmp(text1,text2)) return true; else return false;
185
}
186
 
5575 pavelyakov 187
/*
188
signed int strncmp(dword s1, s2, signed n)
189
unsigned char _s1,_s2;
190
{
191
	if (n == 0)
192
		return 0;
193
	do {
194
		_s1 = DSBYTE[s1];
195
		_s2 = DSBYTE[s2];
196
		if (_s1 != _s2)
197
		{
198
			$dec s2
199
			return _s1 - _s2;
200
		}
201
		$inc s2
202
		if (_s1 == 0)
203
			break;
204
		$inc s1
205
		$dec n
206
	} while (n);
207
	return 0;
208
}
209
*/
5573 pavelyakov 210
 
5575 pavelyakov 211
 
3363 leency 212
inline fastcall void strcpy( EDI, ESI)
3067 leency 213
{
5573 pavelyakov 214
    $cld
3107 leency 215
L2:
5573 pavelyakov 216
    $lodsb
217
    $stosb
218
    $test al,al
219
    $jnz L2
3067 leency 220
}
221
 
3128 leency 222
inline fastcall int strlcpy(dword ESI, EDI, EBX)
223
{
5573 pavelyakov 224
    if (EBX<0) return -1;
225
    EDX=0;
226
    do {
227
        DSBYTE[ESI]=DSBYTE[EDI];
228
        ESI++;
229
        EDI++;
230
        EDX++;
231
        if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
232
    } while(DSBYTE[EDI-1]!='\0');
233
    return 0;
3128 leency 234
}
235
 
7049 leency 236
:void strncpy(dword dst, src, len)
237
{
238
	while (len)
239
	{
240
		ESBYTE[dst] = ESBYTE[src];
241
		dst++;
242
		src++;
243
		len--;
244
	}
245
	ESBYTE[dst]=0;
246
}
247
 
5573 pavelyakov 248
/*
249
inline fastcall void strtrim( ESI)
3448 esevece 250
{
5573 pavelyakov 251
    EDI = ESI;
252
    do{
253
        AL=DSBYTE[EDI];
254
        if (AL != '\32') && (AL != '\13') && (AL != '\10')
255
        {
256
            DSBYTE[ESI]=AL;
257
            $inc ESI
258
        }
259
         $inc EDI
260
    }while(AL!=0);
261
    DSBYTE[ESI] = '\0';
262
}
263
*/
264
 
5582 pavelyakov 265
inline byte __isWhite(int s){ if (s==13)||(s==32)||(s==10)||(s==9) return true; return false; }
5575 pavelyakov 266
inline void strltrim(dword text){
5573 pavelyakov 267
	int s;
268
	dword back_text;
269
	back_text = text;
270
	s = ESBYTE[text];
271
	while(__isWhite(s))
272
	{
273
		$inc text
274
		s = ESBYTE[text];
275
	}
276
	loop()
277
	{
278
		ESBYTE[back_text] = s;
279
		$inc back_text
280
		if(!s) break;
281
		$inc text
282
		s = ESBYTE[text];
283
	};
284
}
285
 
5575 pavelyakov 286
inline void strrtrim(dword text)
5573 pavelyakov 287
{
288
	int s;
289
	dword p;
290
	do {
291
		s = ESBYTE[text];
292
		if(__isWhite(s))
3448 esevece 293
		{
5573 pavelyakov 294
			p = text;
295
			while(__isWhite(s))
296
			{
297
				$inc text;
298
				s = ESBYTE[text];
299
			}
3448 esevece 300
		}
5573 pavelyakov 301
		else $inc text
302
	} while(s);
303
	$dec text
304
	s = ESBYTE[text];
305
	if(__isWhite(s)) ESBYTE[p] = 0;
3448 esevece 306
}
3128 leency 307
 
5575 pavelyakov 308
inline void strtrim(dword text){
5573 pavelyakov 309
	int s;
310
	dword p,back_text;
311
	back_text = text;
312
	s = ESBYTE[text];
313
	while(__isWhite(s))
314
	{
315
		$inc text
316
		s = ESBYTE[text];
317
	}
318
	do {
319
		s = ESBYTE[text];
320
		if(__isWhite(s))
321
		{
322
			p = back_text;
323
			while(__isWhite(s))
324
			{
325
				ESBYTE[back_text] = s;
326
				$inc back_text
327
				$inc text;
328
				s = ESBYTE[text];
329
			}
330
		}
331
		else {
332
			ESBYTE[back_text] = s;
333
			$inc back_text
334
			$inc text
335
		}
336
	} while(s);
337
	$dec text
338
	s = ESBYTE[text];
339
	if(__isWhite(s)) ESBYTE[p] = 0;
340
}
3128 leency 341
 
3363 leency 342
inline fastcall void strcat( EDI, ESI)
3067 leency 343
{
344
  asm {
345
    mov ebx, edi
346
    xor ecx, ecx
347
    xor eax, eax
348
    dec ecx
349
    repne scasb
350
    dec edi
351
    mov edx, edi
352
    mov edi, esi
353
    xor ecx, ecx
354
    xor eax, eax
355
    dec ecx
356
    repne scasb
357
    xor ecx, 0ffffffffh
358
    mov edi, edx
359
    mov edx, ecx
360
    mov eax, edi
361
    shr ecx, 2
362
    rep movsd
363
    mov ecx, edx
364
    and ecx, 3
365
    rep movsb
366
    mov eax, ebx
5573 pavelyakov 367
    }
368
}
369
 
6742 leency 370
:void strncat(dword text1, text2, signed len)
371
signed o1,o2;
372
char s;
5573 pavelyakov 373
{
5576 pavelyakov 374
	s = DSBYTE[text1];
5573 pavelyakov 375
	while(s){
376
		$inc text1
5576 pavelyakov 377
		s = DSBYTE[text1];
3067 leency 378
	}
5573 pavelyakov 379
	o1 = len/4;
380
	o2 = len-4*o1;
381
	while(o1){
5576 pavelyakov 382
		DSDWORD[text1] = DSDWORD[text2];
5573 pavelyakov 383
		text1 += 4;
384
		text2 += 4;
385
		$dec o1
386
	}
387
	while(o2){
5576 pavelyakov 388
		DSBYTE[text1] = DSBYTE[text2];
5573 pavelyakov 389
		$inc text1
390
		$inc text2
391
		$dec o2
392
	}
5576 pavelyakov 393
	DSBYTE[text1] = 0;
3067 leency 394
}
395
 
3363 leency 396
inline fastcall void chrcat(ESI, BL)
397
{
5573 pavelyakov 398
    EDI = strlen(ESI);
399
    ESBYTE[ESI+EDI] = BL;
400
    ESBYTE[ESI+EDI+1] = 0;
3363 leency 401
}
3128 leency 402
 
5598 pavelyakov 403
inline dword strchr(dword shb;char s)
404
{
405
	char ss;
406
	loop()
407
	{
408
		ss = DSBYTE[shb];
409
		if(!ss)return 0;
410
		if(ss==s)return shb;
411
		shb++;
412
	}
3128 leency 413
}
414
 
415
inline fastcall signed int strrchr( ESI,BL)
416
{
5573 pavelyakov 417
    int jj=0, last=0;
418
    do{
419
        jj++;
420
        $lodsb
421
        IF(AL==BL) last=jj;
422
    } while(AL!=0);
423
    return last;
3128 leency 424
}
425
 
426
 
6742 leency 427
inline fastcall unsigned int chrnum( ESI, BL)
3128 leency 428
{
5573 pavelyakov 429
    int num = 0;
6742 leency 430
    while(DSBYTE[ESI])
5573 pavelyakov 431
    {
6742 leency 432
        if (DSBYTE[ESI] == BL) num++;
433
        ESI++;
5573 pavelyakov 434
    }
435
    return num;
3128 leency 436
}
437
 
438
 
3363 leency 439
inline fastcall signed int strstr( EBX, EDX)
3128 leency 440
{
441
  asm {
442
    MOV EDI, EDX
443
    XOR ECX, ECX
444
    XOR EAX, EAX
445
    DEC ECX
446
    REPNE SCASB
447
    NOT ECX
448
    DEC ECX
449
    JE LS2
450
    MOV ESI, ECX
451
    XOR ECX, ECX
452
    MOV EDI, EBX
453
    DEC ECX
454
    REPNE SCASB
455
    NOT ECX
456
    SUB ECX, ESI
457
    JBE LS2
458
    MOV EDI, EBX
459
    LEA EBX, DSDWORD[ ESI-1]
460
LS1: MOV ESI, EDX
461
    LODSB
462
    REPNE SCASB
463
    JNE LS2
464
    MOV EAX, ECX
465
    PUSH EDI
466
    MOV ECX, EBX
467
    REPE CMPSB
468
    POP EDI
469
    MOV ECX, EAX
470
    JNE LS1
471
    LEA EAX, DSDWORD[ EDI-1]
472
    JMP SHORT LS3
473
LS2: XOR EAX, EAX
474
LS3:
475
  }
476
}
477
 
5582 pavelyakov 478
inline dword strcmpi(dword cmp1, cmp2)
4226 punk_joker 479
{
5573 pavelyakov 480
    char si, ue;
3128 leency 481
 
5573 pavelyakov 482
    loop()
483
    {
484
        si = DSBYTE[cmp1];
485
        ue = DSBYTE[cmp2];
486
        if (si>='A') && (si<='Z') si +=32;
487
        if (ue>='A') && (ue<='Z') ue +=32;
488
        if (si != ue) return -1;
489
        cmp1++;
490
        cmp2++;
491
        if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
492
        if (DSBYTE[cmp1]=='\0') return -1;
493
        if (DSBYTE[cmp2]=='\0') return 1;
494
    }
4226 punk_joker 495
}
496
 
5582 pavelyakov 497
inline dword strstri(dword searchin, usestr_s)
3128 leency 498
{
5573 pavelyakov 499
    dword usestr_e = usestr_s;
500
    char si, ue;
3128 leency 501
 
5573 pavelyakov 502
    while(DSBYTE[searchin])
503
    {
504
        si = DSBYTE[searchin];
505
        ue = DSBYTE[usestr_e];
506
        if (si>='A') && (si<='Z') si +=32;
507
        if (ue>='A') && (ue<='Z') ue +=32;
508
        if (si == ue) usestr_e++; else usestr_e = usestr_s;
509
        searchin++;
510
        if (DSBYTE[usestr_e]=='\0') return searchin;
511
    }
6021 leency 512
    return -1;
3128 leency 513
}
514
 
515
 
5582 pavelyakov 516
inline unsigned int strcpyb(dword search_in, copyin, startstr, endstr)
3128 leency 517
{
5573 pavelyakov 518
    dword startp, endp;
519
    dword copyin_start_off = copyin;
520
    if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);
521
    endp = strstri(startp, endstr);
522
    if (endp==0) endp = startp+strlen(search_in);
523
    //if (startp==endp) return 0;
524
    do
525
    {
526
        DSBYTE[copyin] = DSBYTE[startp];
527
        copyin++;
528
        startp++;
529
    }
530
    while (startp
531
    DSBYTE[copyin] = '\0';
532
    return copyin_start_off;
3128 leency 533
}
534
 
535
 
5423 leency 536
/*void strcat(char *to, char *from)
3081 leency 537
{
5573 pavelyakov 538
    while(*to) to++;
539
    while(*from)
540
    {
541
        *to = *from;
542
        to++;
543
        from++;
544
    }
545
    *to = '\0';
3081 leency 546
}*/
547
 
3114 leency 548
 
3067 leency 549
inline fastcall dword atoi( EDI)
550
{
5573 pavelyakov 551
    $push ebx
552
    $push esi
553
    ESI=EDI;
554
    while (DSBYTE[ESI]==' ') ESI++;
555
    if (DSBYTE[ESI]=='-') ESI++;
556
    EAX=0;
557
    while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
558
    {
559
        $xor ebx, ebx
560
        EBX = DSBYTE[ESI]-'0';
561
        EAX *= 10;
562
        EAX += EBX;
563
        ESI++;
564
    }
565
    IF (DSBYTE[EDI]=='-') -EAX;
566
    $pop esi
567
    $pop ebx
3067 leency 568
}
569
 
570
 
571
 
572
inline fastcall strupr( ESI)
573
{
5573 pavelyakov 574
    do{
575
        AL=DSBYTE[ESI];
576
        IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
577
        IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;    //à-ï
578
        IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;    //à-ï
579
         ESI++;
580
    }while(AL!=0);
3067 leency 581
}
582
 
583
inline fastcall strlwr( ESI)
584
{
5573 pavelyakov 585
    do{
586
        $LODSB
587
        IF(AL>='A')&&(AL<='Z'){
588
            AL+=0x20;
589
            DSBYTE[ESI-1]=AL;
590
            CONTINUE;
591
        }
592
    }while(AL!=0);
3067 leency 593
}
594
 
595
inline fastcall strttl( EDX)
596
{
5573 pavelyakov 597
    AL=DSBYTE[EDX];
598
    IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
599
    IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;    //à-ï
600
    IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;    //à-ï
601
    do{
602
        EDX++;
603
        AL=DSBYTE[EDX];
604
        IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
605
        IF(AL>='€')&&(AL<='')DSBYTE[EDX]=AL|0x20; // -¯
606
        IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;    //à-ï
607
    }while(AL!=0);
3067 leency 608
}
609
 
5573 pavelyakov 610
/*
4166 leency 611
dword itoa( ESI)
612
{
4639 yogev_ezra 613
    unsigned char buffer[11];
5573 pavelyakov 614
    $pusha
615
    EDI = #buffer;
616
    ECX = 10;
617
    if (ESI < 0)
618
    {
619
         $mov     al, '-'
620
         $stosb
621
         $neg     esi
622
    }
4166 leency 623
 
5573 pavelyakov 624
    $mov     eax, esi
625
    $push    -'0'
4166 leency 626
F2:
5573 pavelyakov 627
    $xor     edx, edx
628
    $div     ecx
629
    $push    edx
630
    $test    eax, eax
631
    $jnz     F2
4166 leency 632
F3:
5573 pavelyakov 633
    $pop     eax
634
    $add     al, '0'
635
    $stosb
636
    $jnz     F3
637
 
638
    $mov     al, '\0'
639
    $stosb
4166 leency 640
 
5573 pavelyakov 641
    $popa
4166 leency 642
    return #buffer;
643
}
5573 pavelyakov 644
*/
5591 pavelyakov 645
:unsigned char BUF_ITOA[11];
5575 pavelyakov 646
inline dword itoa(signed long number)
4166 leency 647
{
5576 pavelyakov 648
	dword ret,p;
5573 pavelyakov 649
	byte cmd;
650
	long mask,tmp;
651
	mask = 1000000000;
652
	cmd = true;
5591 pavelyakov 653
	p = #BUF_ITOA;
5573 pavelyakov 654
	if(!number){
5576 pavelyakov 655
		ESBYTE[p] = '0';
656
		ESBYTE[p+1] = 0;
657
		return p;
5573 pavelyakov 658
	}
5576 pavelyakov 659
	ret = p;
5573 pavelyakov 660
	if(number<0)
4166 leency 661
	{
5573 pavelyakov 662
		$neg number
5576 pavelyakov 663
		ESBYTE[p] = '-';
664
		$inc p
4166 leency 665
	}
5573 pavelyakov 666
	while(mask)
667
	{
668
		tmp = number / mask;
669
		tmp = tmp%10;
670
 
671
		if(cmd){
672
			if(tmp){
5576 pavelyakov 673
				ESBYTE[p] = tmp + '0';
674
				$inc p
5573 pavelyakov 675
				cmd = false;
676
			}
677
		}
678
		else {
5576 pavelyakov 679
			ESBYTE[p] = tmp + '0';
680
			$inc p
5573 pavelyakov 681
		}
682
		mask /= 10;
683
	}
5576 pavelyakov 684
	ESBYTE[p] = 0;
5573 pavelyakov 685
	return ret;
686
}
5576 pavelyakov 687
 
5582 pavelyakov 688
inline fastcall itoa_(signed int EDI, ESI)
5573 pavelyakov 689
{
690
    $pusha
691
    EBX = EDI;
692
    ECX = 10;
693
    if (ESI > 90073741824)
694
    {
695
         $mov     al, '-'
696
         $stosb
697
         $neg     esi
698
    }
4166 leency 699
 
5573 pavelyakov 700
    $mov     eax, esi
701
    $push    -'0'
4166 leency 702
F2:
5573 pavelyakov 703
    $xor     edx, edx
704
    $div     ecx
705
    $push    edx
706
    $test    eax, eax
707
    $jnz     F2
4166 leency 708
F3:
5573 pavelyakov 709
    $pop     eax
710
    $add     al, '0'
711
    $stosb
712
    $jnz     F3
713
 
714
    $mov     al, '\0'
715
    $stosb
4166 leency 716
 
5573 pavelyakov 717
    $popa
4166 leency 718
    return EBX;
5573 pavelyakov 719
}
4166 leency 720
 
5582 pavelyakov 721
inline dword memchr(dword s,int c,signed len)
5573 pavelyakov 722
{
5576 pavelyakov 723
	if(!len) return NULL;
724
	do {
725
		if(DSBYTE[s] == c) return s;
726
		$inc s
727
		$dec len
728
	} while(len);
729
	return NULL;
730
}
731
 
5582 pavelyakov 732
inline dword strdup(dword text)
5576 pavelyakov 733
{
5573 pavelyakov 734
    dword l = strlen(text);
735
    dword ret = malloc(l+1);
5576 pavelyakov 736
	if(!ret) return NULL;
5803 leency 737
    strlcpy(ret,text,l);
5573 pavelyakov 738
    return ret;
739
}
740
 
5582 pavelyakov 741
inline dword strndup(dword str, signed maxlen)
5575 pavelyakov 742
{
743
	dword copy,len;
744
 
745
	len = strnlen(str, maxlen);
746
	copy = malloc(len + 1);
747
	if (copy != NULL)
748
	{
5803 leency 749
		strlcpy(copy, str, len);
5575 pavelyakov 750
		DSBYTE[len+copy] = '\0';
751
	}
752
	return copy;
753
}
754
 
5582 pavelyakov 755
inline dword hexdec(dword text)
5576 pavelyakov 756
{
5582 pavelyakov 757
	char s;
758
	dword ret,l;
759
	ret = 0;
760
	s = DSBYTE[text];
761
	while(s)
762
	{
763
		ret <<= 4;
764
		if(s>='A')&&(s<='F')ret |= s-'A'+10;
765
		else if(s>='a')&&(s<='f')ret |= s-'a'+10;
5598 pavelyakov 766
		else if(s>='0')&&(s<='9')ret |= s-'0';
5582 pavelyakov 767
		text++;
768
		s = DSBYTE[text];
769
	}
5598 pavelyakov 770
	return ret;
771
}
772
 
773
inline signed csshexdec(dword text)
774
{
775
	char s;
776
	dword ret,l;
777
	byte tmp;
778
	l = strlen(text);
779
	ret = 0;
780
	s = DSBYTE[text];
781
	tmp = 0;
782
	if(l==6) while(s)
5582 pavelyakov 783
	{
784
		ret <<= 4;
785
		if(s>='A')&&(s<='F')ret |= s-'A'+10;
786
		else if(s>='a')&&(s<='f')ret |= s-'a'+10;
5598 pavelyakov 787
		else if(s>='0')&&(s<='9')ret |= s-'0';
5582 pavelyakov 788
		text++;
789
		s = DSBYTE[text];
5598 pavelyakov 790
	}
791
	else if(l==3) while(s)
792
	{
793
		ret |= tmp;
794
		ret <<= 4;
795
		ret |= tmp;
796
		ret <<= 4;
797
		if(s>='A')&&(s<='F')tmp = s-'A'+10;
798
		else if(s>='a')&&(s<='f')tmp = s-'a'+10;
799
		else if(s>='0')&&(s<='9')tmp = s-'0';
800
		text++;
801
		s = DSBYTE[text];
802
	}
5582 pavelyakov 803
	return ret;
804
}
805
 
806
inline cdecl int sprintf(dword buf, format,...)
807
{
6791 leency 808
	#define END_ARGS 0xFF00FF //ARGS FUNCTION
5576 pavelyakov 809
	byte s;
810
	char X[10];
811
	dword ret, tmp, l;
812
	dword arg = #format;
813
	ret = buf;
814
	s = DSBYTE[format];
815
	while(s){
816
		if(s=='%'){
817
			arg+=4;
818
			tmp = DSDWORD[arg];
819
			if(tmp==END_ARGS)goto END_FUNC_SPRINTF;
820
			$inc format
821
			s = DSBYTE[format];
822
			if(!s)goto END_FUNC_SPRINTF;
823
			switch(s)
824
			{
825
				case 's':
826
					l = tmp;
827
					s = DSBYTE[tmp];
828
					while(s)
829
					{
830
						DSBYTE[buf] = s;
831
						$inc tmp
832
						$inc buf
833
						s = DSBYTE[tmp];
834
					}
835
				break;
836
				case 'c':
837
					DSBYTE[buf] = tmp;
838
					$inc buf
839
				break;
840
				case 'u': //if(tmp<0)return ret;
841
				case 'd':
842
				case 'i':
843
					tmp = itoa(tmp);
844
					if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
845
					l = strlen(tmp);
5646 pavelyakov 846
					strlcpy(buf,tmp,l);
5576 pavelyakov 847
					buf += l;
848
				break;
849
				case 'a':
850
				case 'A':
5646 pavelyakov 851
					strlcpy(buf,"0x00000000",10);
5576 pavelyakov 852
					buf+=10;
853
					l=buf;
854
					while(tmp)
855
					{
856
						$dec buf
857
						s=tmp&0xF;
858
						if(s>9)DSBYTE[buf]='A'+s-10;
859
						else DSBYTE[buf]='0'+s;
860
						tmp>>=4;
861
					}
862
					buf=l;
863
				break;
864
				case 'p':
865
					tmp = itoa(#tmp);
866
					if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
867
					l = strlen(tmp);
5646 pavelyakov 868
					strlcpy(buf,tmp,l);
5576 pavelyakov 869
					buf += l;
870
				break;
871
				case '%':
872
					DSBYTE[buf] = '%';
873
					$inc buf
874
				break;
875
				default:
876
				goto END_FUNC_SPRINTF;
877
			}
878
		}
879
		else {
880
			DSBYTE[buf] = s;
881
			$inc buf
882
		}
883
		$inc format
884
		s = DSBYTE[format];
885
	}
886
	END_FUNC_SPRINTF:
887
	DSBYTE[buf] = 0;
6771 leency 888
	return ret;
5576 pavelyakov 889
}
890
 
5598 pavelyakov 891
inline signed strcoll(dword text1,text2)
892
{
893
	char s,ss;
894
	loop()
895
	{
896
		s = DSBYTE[text2];
897
		ss=strchr(text1,s);
898
		if(ss)return ss;
899
		text2++;
900
	}
901
	return 0;
902
}
903
 
7049 leency 904
replace_char(dword in_str, char from_char, to_char, int length) {
905
	int i;
906
	for (i=0; i
907
		if (ESBYTE[in_str+i] == from_char) ESBYTE[in_str+i] = to_char;
908
	}
909
	ESBYTE[in_str+length]=0;
910
}
911
 
912
 
3067 leency 913
#define strnmov strmovn
914
#define stricmp strcmpi
915
#define strcmpn strncmp
3467 leency 916
 
5598 pavelyakov 917
#endif