Subversion Repositories Kolibri OS

Rev

Rev 5575 | Rev 5582 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 5575 Rev 5576
Line 176... Line 176...
176 
    $stosb
 176 
    $stosb
177 
    $test al,al
 177 
    $test al,al
178 
    $jnz L2
 178 
    $jnz L2
179 
}
 179 
}
Line 180... Line 180...
180 
 
 180 
 
181 
inline dword strncpy(dword text1, text2, signed len)
 181 
:inline dword strncpy(dword text1, text2, signed len)
182 
	signed o1,o2;
 182 
	signed o1,o2;
- 
 
 183 
{
- 
 
 184 
	if(!text1)||(!len) return text1;
- 
 
 185 
	if(len<4)
- 
 
 186 
	{
- 
 
 187 
		o2 = len;
- 
 
 188 
		goto RUN_BYTE;
183 
{
 189 
	}
184 
	o1 = len/4;
 190 
	o1 = len/4;
185 
	o2 = len-4*o1;
 191 
	o2 = len-4*o1;
186 
	while(o1){
 192 
	while(o1){
187 
		ESDWORD[text1] = ESDWORD[text2];
 193 
		DSDWORD[text1] = DSDWORD[text2];
188 
		text1 += 4;
 194 
		text1 += 4;
189 
		text2 += 4;
 195 
		text2 += 4;
190 
		$dec o1
 196 
		$dec o1
- 
 
 197 
	}
191 
	}
 198 
	RUN_BYTE:
192 
	while(o2){
 199 
	while(o2){
193 
		ESBYTE[text1] = ESBYTE[text2];
 200 
		DSBYTE[text1] = DSBYTE[text2];
194 
		$inc text1
201 
		$inc text1
195 
		$inc text2
202 
		$inc text2
196 
		$dec o2
 203 
		$dec o2
197 
	}
 204 
	}
198 
	ESBYTE[text1] = 0;
 205 
	DSBYTE[text1] = 0;
199 
	return text1;
 206 
	return text1;
Line 200... Line 207...
200 
}
 207 
}
201 
 
 208 
 
Line 337... Line 344...
337 
 
 344 
 
338 
void strncat(dword text1, text2, signed len)
 345 
void strncat(dword text1, text2, signed len)
339 
	signed o1,o2;
 346 
	signed o1,o2;
340 
	char s;
 347 
	char s;
341 
{
 348 
{
342 
	s = ESBYTE[text1];
 349 
	s = DSBYTE[text1];
343 
	while(s){
 350 
	while(s){
344 
		$inc text1
 351 
		$inc text1
345 
		s = ESBYTE[text1];
 352 
		s = DSBYTE[text1];
346 
	}
 353 
	}
347 
	o1 = len/4;
 354 
	o1 = len/4;
348 
	o2 = len-4*o1;
 355 
	o2 = len-4*o1;
349 
	while(o1){
 356 
	while(o1){
350 
		ESDWORD[text1] = ESDWORD[text2];
 357 
		DSDWORD[text1] = DSDWORD[text2];
351 
		text1 += 4;
 358 
		text1 += 4;
352 
		text2 += 4;
 359 
		text2 += 4;
353 
		$dec o1
 360 
		$dec o1
354 
	}
 361 
	}
355 
	while(o2){
 362 
	while(o2){
356 
		ESBYTE[text1] = ESBYTE[text2];
 363 
		DSBYTE[text1] = DSBYTE[text2];
357 
		$inc text1
364 
		$inc text1
358 
		$inc text2
365 
		$inc text2
359 
		$dec o2
 366 
		$dec o2
- 
 
 367 
	}
360 
	}
 368 
	DSBYTE[text1] = 0;
Line 361... Line 369...
361 
}
 369 
}
362 
 
 370 
 
363 
inline fastcall void chrcat(ESI, BL)
 371 
inline fastcall void chrcat(ESI, BL)
Line 612... Line 620...
612 
*/
 620 
*/
Line 613... Line 621...
613
621
614 
inline dword itoa(signed long number)
 622 
inline dword itoa(signed long number)
615 
{
 623 
{
616 
	unsigned char buf[11];
 624 
	unsigned char buf[11];
617 
	dword ret;
 625 
	dword ret,p;
618 
	byte cmd;
 626 
	byte cmd;
619 
	long mask,tmp;
 627 
	long mask,tmp;
620 
	mask = 1000000000;
 628 
	mask = 1000000000;
- 
 
 629 
	cmd = true;
621 
	cmd = true;
 630 
	p = #buf;
622 
	if(!number){
 631 
	if(!number){
623 
		ESBYTE[buf] = '0';
 632 
		ESBYTE[p] = '0';
624 
		ESBYTE[buf+1] = 0;
 633 
		ESBYTE[p+1] = 0;
625 
		return buf;
 634 
		return p;
626 
	}
 635 
	}
627 
	ret = buf;
 636 
	ret = p;
628 
	if(number<0)
 637 
	if(number<0)
629 
	{
 638 
	{
630 
		$neg number
 639 
		$neg number
631 
		ESBYTE[buf] = '-';
 640 
		ESBYTE[p] = '-';
632 
		$inc buf
 641 
		$inc p
633 
	}
 642 
	}
634 
	while(mask)
 643 
	while(mask)
635 
	{
 644 
	{
636 
		tmp = number / mask;
 645 
		tmp = number / mask;
Line 637... Line 646...
637 
		tmp = tmp%10;
 646 
		tmp = tmp%10;
638
647
639 
		if(cmd){
 648 
		if(cmd){
640 
			if(tmp){
 649 
			if(tmp){
641 
				ESBYTE[buf] = tmp + '0';
 650 
				ESBYTE[p] = tmp + '0';
642 
				$inc buf
 651 
				$inc p
643 
				cmd = false;
 652 
				cmd = false;
644 
			}
 653 
			}
645 
		}
 654 
		}
646 
		else {
 655 
		else {
647 
			ESBYTE[buf] = tmp + '0';
 656 
			ESBYTE[p] = tmp + '0';
648 
			$inc buf
 657 
			$inc p
649 
		}
 658 
		}
650 
		mask /= 10;
 659 
		mask /= 10;
651 
	}
 660 
	}
652 
	ESBYTE[buf] = 0;
 661 
	ESBYTE[p] = 0;
Line 653... Line 662...
653 
	return ret;
 662 
	return ret;
654 
}
 663 
}
655
664 
 
656 
inline fastcall itoa_(signed int EDI, ESI)
 665 
:inline fastcall itoa_(signed int EDI, ESI)
657 
{
 666 
{
658 
    $pusha
 667 
    $pusha
Line 684... Line 693...
684 
 
 693 
 
685 
    $popa
 694 
    $popa
686 
    return EBX;
 695 
    return EBX;
Line -... Line 696...
- 
 
 696 
}
- 
 
 697 
 
- 
 
 698 
:inline dword memchr(dword s,int c,signed len)
- 
 
 699 
{
- 
 
 700 
	if(!len) return NULL;
- 
 
 701 
	do {
- 
 
 702 
		if(DSBYTE[s] == c) return s;
- 
 
 703 
		$inc s
- 
 
 704 
		$dec len
- 
 
 705 
	} while(len);
- 
 
 706 
	return NULL;
687 
}
707 
}
688 
 
 708 
 
689 
inline dword strdup(dword text)
 709 
:inline dword strdup(dword text)
690 
{
 710 
{
- 
 
 711 
    dword l = strlen(text);
691 
    dword l = strlen(text);
 712 
    dword ret = malloc(l+1);
692 
    dword ret = malloc(l+1);
 713 
	if(!ret) return NULL;
693 
    strncpy(ret,text,l);
 714 
    strncpy(ret,text,l);
Line 694... Line 715...
694 
    return ret;
 715 
    return ret;
695 
}
 716 
}
696 
 
 717 
 
Line 697... Line 718...
697 
inline dword strndup(dword str, signed maxlen)
 718 
:inline dword strndup(dword str, signed maxlen)
698 
{
 719 
{
699 
	dword copy,len;
 720 
	dword copy,len;
700 
 
 721 
 
701 
	len = strnlen(str, maxlen);
 722 
	len = strnlen(str, maxlen);
702 
	copy = malloc(len + 1);
 723 
	copy = malloc(len + 1);
703 
	if (copy != NULL)
 724 
	if (copy != NULL)
704 
	{
 725 
	{
705 
		memcpy(copy, str, len);
 726 
		strncpy(copy, str, len);
Line -... Line 727...
- 
 
 727 
		DSBYTE[len+copy] = '\0';
- 
 
 728 
	}
- 
 
 729 
	return copy;
- 
 
 730 
}
- 
 
 731 
 
- 
 
 732 
:inline cdecl int sprintf(dword buf, format,...)
- 
 
 733 
{
- 
 
 734 
	byte s;
- 
 
 735 
	char X[10];
- 
 
 736 
	dword ret, tmp, l;
- 
 
 737 
	dword arg = #format;
- 
 
 738 
	ret = buf;
- 
 
 739 
	s = DSBYTE[format];
- 
 
 740 
	while(s){
- 
 
 741 
		if(s=='%'){
- 
 
 742 
			arg+=4;
- 
 
 743 
			tmp = DSDWORD[arg];
- 
 
 744 
			if(tmp==END_ARGS)goto END_FUNC_SPRINTF;
- 
 
 745 
			$inc format
- 
 
 746 
			s = DSBYTE[format];
- 
 
 747 
			if(!s)goto END_FUNC_SPRINTF;
- 
 
 748 
			switch(s)
- 
 
 749 
			{
- 
 
 750 
				case 's':
- 
 
 751 
					l = tmp;
- 
 
 752 
					s = DSBYTE[tmp];
- 
 
 753 
					while(s)
- 
 
 754 
					{
- 
 
 755 
						DSBYTE[buf] = s;
- 
 
 756 
						$inc tmp
- 
 
 757 
						$inc buf
- 
 
 758 
						s = DSBYTE[tmp];
- 
 
 759 
					}
- 
 
 760 
				break;
- 
 
 761 
				case 'c':
- 
 
 762 
					DSBYTE[buf] = tmp;
- 
 
 763 
					$inc buf
- 
 
 764 
				break;
- 
 
 765 
				case 'u': //if(tmp<0)return ret;
- 
 
 766 
				case 'd':
- 
 
 767 
				case 'i':
- 
 
 768 
					tmp = itoa(tmp);
- 
 
 769 
					if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
- 
 
 770 
					l = strlen(tmp);
- 
 
 771 
					strncpy(buf,tmp,l);
- 
 
 772 
					buf += l;
- 
 
 773 
				break;
- 
 
 774 
				case 'a':
- 
 
 775 
				case 'A':
- 
 
 776 
					strncpy(buf,"0x00000000",10);
- 
 
 777 
					buf+=10;
- 
 
 778 
					l=buf;
- 
 
 779 
					while(tmp)
- 
 
 780 
					{
- 
 
 781 
						$dec buf
- 
 
 782 
						s=tmp&0xF;
- 
 
 783 
						if(s>9)DSBYTE[buf]='A'+s-10;
- 
 
 784 
						else DSBYTE[buf]='0'+s;
- 
 
 785 
						tmp>>=4;
- 
 
 786 
					}
- 
 
 787 
					buf=l;
- 
 
 788 
				break;
- 
 
 789 
				case 'p':
- 
 
 790 
					tmp = itoa(#tmp);
- 
 
 791 
					if(!DSBYTE[tmp])goto END_FUNC_SPRINTF;
- 
 
 792 
					l = strlen(tmp);
- 
 
 793 
					strncpy(buf,tmp,l);
- 
 
 794 
					buf += l;
- 
 
 795 
				break;
- 
 
 796 
				case '%':
- 
 
 797 
					DSBYTE[buf] = '%';
- 
 
 798 
					$inc buf
- 
 
 799 
				break;
- 
 
 800 
				default:
- 
 
 801 
				goto END_FUNC_SPRINTF;
- 
 
 802 
			}
- 
 
 803 
		}
- 
 
 804 
		else {
- 
 
 805 
			DSBYTE[buf] = s;
- 
 
 806 
			$inc buf
- 
 
 807 
		}
- 
 
 808 
		$inc format
- 
 
 809 
		s = DSBYTE[format];
- 
 
 810 
	}
706 
		DSBYTE[len+copy] = '\0';
 811 
	END_FUNC_SPRINTF:
707 
	}
 812 
	DSBYTE[buf] = 0;
708 
	return copy;
 813 
	return buf-ret;
709 
}
 814 
}
710 
 
 815