Subversion Repositories Kolibri OS

Rev

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