WebSVN – Kolibri OS – Diff – /programs/other/table/kosSyst.cpp


#include "kosSyst.h"
#include "func.h"
#include 
 
#define atexitBufferSize	32
 
 
char pureCallMessage[] = "PURE function call!";
 
char *kosExePath = NULL;
 
//
void (__cdecl *atExitList[atexitBufferSize])();
int atExitFnNum = 0;
//
int __cdecl atexit( void (__cdecl *func )( void ))
{
	//
	if ( atExitFnNum < atexitBufferSize )
	{
		//
		atExitList[atExitFnNum++] = func;
		return 0;
	}
	else
	{
		return 1;
	}
}
 
 
//
Dword RandomSeed = 1;
//
void rtlSrand( Dword seed )
{
	RandomSeed = seed;
}
//
Dword rtlRand( void )
{
  //ìàñêà 0x80000776
 
  Dword dwi, i;
 
  for ( i = 0; i < 32; i++ )
  {
 
    dwi = RandomSeed & 0x80000776;
  
      __asm{
            mov   eax, dwi
            mov   edx, eax
            bswap eax
            xor   eax, edx
            xor   al, ah
            setpo al
            movzx eax, al
            mov   dwi, eax
    }
 
    RandomSeed = ( RandomSeed << 1 ) | ( dwi & 1 );
  }
  
 return RandomSeed;
}
 
 
/*void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount )
{
	__asm{
		mov edi, dst
		mov eax, dst
		mov esi, src
		mov ecx, bytesCount
		rep movsb
	}
}
 
//
void memset( Byte *dst, Byte filler, Dword count )
{
	//
	__asm{
		mov edi, dst
		mov al, filler
		mov ecx, count
		rep stosb
	}
}*/
 
 
//
Dword rtlInterlockedExchange( Dword *target, Dword value )
{
//	Dword result;
 
	//
	__asm{
		mov eax, value
		mov ebx, target
		xchg eax, [ebx]
//		mov result, eax
	}
	//
//	return result;
}
 
 
//////////////////////////////////////////////////////////////////////
//
// êîïèðîâàíèå ñòðîêè
//
 
char * __cdecl strcpy( char *target, const char *source )
{
	char *result = target;
 
	while( target[0] = source[0] )
	{
		target++;
		source++;
	}
 
	return result;
}
 
 
//////////////////////////////////////////////////////////////////////
//
// ðåâåðñèâíûé ïîèñê ñèìâîëà
//
 
char * __cdecl strrchr( const char * string, int c )
{
	char *cPtr;
 
	//
	for ( cPtr = (char *)string + strlen( string ); cPtr >= string; cPtr-- )
	{
		//
		if ( *cPtr == c ) return cPtr;
	}
	//
	return NULL;
}
 
 
//////////////////////////////////////////////////////////////////////
//
// îïðåäåëåíèå äëèíû ñòðîêè
//
 
int __cdecl strlen( const char *line )
{
  int i;
 
  for( i=0; line[i] != 0; i++ );
  return i;
}
 
 
 
//////////////////////////////////////////////////////////////////////
//
// ïåðåâîä øåñòíàäöàòèðè÷íîãî ÷èñëà â ñèìâîë
//
 
unsigned int num2hex( unsigned int num )
{
  if( num < 10 )
    return num + '0';
  return num - 10 + 'A';
}
 
 
//////////////////////////////////////////////////////////////////////
//
// âûâîä ñòðîêè íà ïå÷àòü. barsuk äîáàâèë %f 
 
//#define PREC 2
//#define HALF 0.499
#define PREC 6
#define HALF 0.4999999
 
double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30};
 
 
//
 
Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,
                   10000, 1000, 100, 10, 0 };
 
//
void sprintf( char *Str, char* Format, ... )
{
	int i, fmtlinesize, j, k, flag;
	Dword head, tail;
	char c;
	va_list arglist;
	//
	va_start(arglist, Format);
 
	//
	fmtlinesize = strlen( Format );
	//
	if( fmtlinesize == 0 ) return;
  
	//
	for( i = 0, j = 0; i < fmtlinesize; i++ )
	{
		//
		c = Format[i];
		//
		if( c != '%' )
		{
			Str[j++] = c;
			continue;
		}
		//
		i++;
		//
		if( i >= fmtlinesize ) break;
 
		//
		flag = 0;
		//
		c = Format[i];
		//
		switch( c )
		{
		//
		case '%':
			Str[j++] = c;
			break;
		// âûâîä ñòðîêè
		case 'S':
			Byte* str;
			str = va_arg(arglist, Byte*);
			for( k = 0; ( c = str[k] ) != 0; k++ )
			{
				Str[j++] = c;
			}
			break;
		// âûâîä áàéòà
		case 'B':
			k = va_arg(arglist, int) & 0xFF;
			Str[j++] = num2hex( ( k >> 4 ) & 0xF );
			Str[j++] = num2hex( k & 0xF );
			break;
		// âûâîä ñèìâîëà
		case 'C':
			Str[j++] = va_arg(arglist, int) & 0xFF;
			break;
		// âûâîä äâîéíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
		case 'X':
			Dword val;
			val = va_arg(arglist, Dword);
			for( k = 7; k >= 0; k-- )
			{
				//
				c = num2hex ( ( val >> (k * 4) ) & 0xF );
				//
				if( c == '0' )
				{
					if( flag ) Str[j++] = c;
				}
				else
				{
					flag++;
					Str[j++] = c;
				}
			}
			//
			if( flag == 0 ) Str[j++] = '0';
			break;
		// âûâîä äâîéíîãî ñëîâà â äåñÿòè÷íîì âèäå
		case 'U':
			head = va_arg(arglist, Dword);
			tail = 0;
			for( k = 0; dectab[k] != 0; k++ )
			{
				tail = head % dectab[k];
				head /= dectab[k];
				c = head + '0';
				if( c == '0' )
				{
					if( flag ) Str[j++] = c;
				}
				else
				{
					flag++;
					Str[j++] = c;
				}
				//
				head = tail;
			}
			//
			c = head + '0';
			Str[j++] = c;
			break;
		// âåùåñòâåííîå ÷èñëî â ôîðìàòå 7.2
		case 'f':
		case 'F':
		case 'g':
		case 'G':
			{
			double val, w;
			int p;
			val = va_arg(arglist, double);
			if (val < 0.0)
			{
				Str[j++] = '-';
				val = -val;
			}
			for (k = 0; k < 30; k++)
				if (val < double_tab[k])
					break;
 
			if (val < 1.0)
			{
				Str[j++] = '0';
			}
			
			for (p = 1; p < k + 1; p++)
			{
				int d = (int)di(val / double_tab[k - p] - HALF) % 10;
				Str[j++] = '0' + d;
				val -= d * double_tab[k - p];
			}
			Str[j++] = '.';
			w = 0.1;
			for (p = 0; p < PREC - 1; p++)
			{
				val-=floor(val);
				Str[j++] = '0' + di(val / w - HALF) % 10;
				w /= 10.0;
			}
			}
			break;
 
		// âûâîä 64-áèòíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
		case 'Q':
			unsigned int low_dword, high_dword;
			low_dword = va_arg(arglist, unsigned int);
			high_dword = va_arg(arglist, unsigned int);
			for( k = 7; k >= 0; k-- )
			{
				//
				c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF );
				//
				if( c == '0' )
				{
					if( flag ) Str[j++] = c;
				}
				else
				{
					flag++;
					Str[j++] = c;
				}
			}
			//
			for( k=7; k >= 0; k-- )
			{
				//
				c = num2hex ( ( low_dword >> (k * 4) ) & 0xF );
				//
				if( c == '0' )
				{
					if( flag ) Str[j++] = c;
				}
				else
				{
					flag++;
					Str[j++] = c;
				}
			}
			//
			if( flag == 0 ) Str[j++] = '0';
			//
			break;
		//
		default:
			break;
		}
	}
	//
	Str[j] = 0;
}
 
 
// ôóíêöèÿ -1 çàâåðøåíèÿ ïðîöåññà
void kos_ExitApp()
{
	int i;
 
	//
	for ( i = atExitFnNum - 1; i >= 0; i-- )
	{
		//
		atExitList[i]();
	}
	//
	__asm{
		mov eax, -1
		int 0x40
	}
}
 
 
// ôóíêöèÿ 0
void kos_DefineAndDrawWindow(
	Word x, Word y,
	Word sizeX, Word sizeY,
	Byte mainAreaType,
	Dword mainAreaColour,
	Byte headerType,
	Dword headerColour,
	Dword borderColour
	)
{
	Dword arg1, arg2, arg3, arg4;
 
	//
	arg1 = ( x << 16 ) + sizeX;
	arg2 = ( y << 16 ) + sizeY;
	arg3 = ( mainAreaType << 24 ) | mainAreaColour;
	arg4 = ( headerType << 24 ) | headerColour;
	//
	__asm{
		mov eax, 0
		mov ebx, arg1
		mov ecx, arg2
		mov edx, arg3
		mov esi, arg4
		mov edi, borderColour
		int 0x40
	}
}
 
 
// ôóíêöèÿ 1 ïîñòàâèòü òî÷êó
void kos_PutPixel( Dword x, Dword y, Dword colour )
{
	//
	__asm{
		mov eax, 1
		mov ebx, x
		mov ecx, y
		mov edx, colour
		int 0x40
	}
}
 
 
// ôóíêöèÿ 2 ïîëó÷èòü êîä íàæàòîé êëàâèøè
bool kos_GetKey( Byte &keyCode )
{
	Dword result;
 
	//
	__asm{
		mov eax, 2
		int 0x40
		mov result, eax
	}
	//
	keyCode = result >> 8;
	//
	return ( result & 0xFF ) == 0;
}
 
 
// ôóíêöèÿ 3 ïîëó÷èòü âðåìÿ
Dword kos_GetSystemClock()
{
//	Dword result;
 
	//
	__asm{
		mov eax, 3
		int 0x40
//		mov result, eax
	}
	//
//	return result;
}
 
 
// ôóíêöèÿ 4
void kos_WriteTextToWindow(
	Word x,
	Word y,
	Byte fontType,
	Dword textColour,
	char *textPtr,
	Dword textLen
	)
{
	Dword arg1, arg2;
 
	//
	arg1 = ( x << 16 ) | y;
	arg2 = ( fontType << 24 ) | textColour;
	//
	__asm{
		mov eax, 4
		mov ebx, arg1
		mov ecx, arg2
		mov edx, textPtr
		mov esi, textLen
		int 0x40
	}
}
 
 
// ôóíêöèÿ 5 ïàóçà, â ñîòûõ äîëÿõ ñåêóíäû
void kos_Pause( Dword value )
{
	//
	__asm{
		mov eax, 5
		mov ebx, value
		int 0x40
	}
}
 
 
// ôóíêöèÿ 7 íàðèñîâàòü èçîáðàæåíèå
void kos_PutImage( RGB * imagePtr, Word sizeX, Word sizeY, Word x, Word y )
{
	Dword arg1, arg2;
 
	//
	arg1 = ( sizeX << 16 ) | sizeY;
	arg2 = ( x << 16 ) | y;
	//
	__asm{
		mov eax, 7
		mov ebx, imagePtr
		mov ecx, arg1
		mov edx, arg2
		int 0x40
	}
}
 
 
 
// ôóíêöèÿ 8 îïðåäåëèòü êíîïêó
void kos_DefineButton( Word x, Word y, Word sizeX, Word sizeY, Dword buttonID, Dword colour )
{
	Dword arg1, arg2;
 
	//
	arg1 = ( x << 16 ) | sizeX;
	arg2 = ( y << 16 ) | sizeY;
	//
	__asm{
		mov eax, 8
		mov ebx, arg1
		mov ecx, arg2
		mov edx, buttonID
		mov esi, colour
		int 0x40
	}
}
 
 
// ôóíêöèÿ 9 - èíôîðìàöèÿ î ïðîöåññå
Dword kos_ProcessInfo( sProcessInfo *targetPtr, Dword processID )
{
//	Dword result;
 
	//
	__asm{
		mov eax, 9
		mov ebx, targetPtr
		mov ecx, processID
		int 0x40
//		mov result, eax
	}
	//
//	return result;
}
 
 
// ôóíêöèÿ 10
Dword kos_WaitForEvent()
{
//	Dword result;
 
	__asm{
		mov eax, 10
		int 0x40
//		mov result, eax
	}
	
//	return result;
}
 
 
// ôóíêöèÿ 11
Dword kos_CheckForEvent()
{
//	Dword result;
 
	__asm{
		mov eax, 11
		int 0x40
//		mov result, eax
	}
	
//	return result;
}
 
 
// ôóíêöèÿ 12
void kos_WindowRedrawStatus( Dword status )
{
	__asm{
		mov eax, 12
		mov ebx, status
		int 0x40
	}
}
 
 
// ôóíêöèÿ 13 íàðèñîâàòü ïîëîñó
void kos_DrawBar( Word x, Word y, Word sizeX, Word sizeY, Dword colour )
{
	Dword arg1, arg2;
 
	//
	arg1 = ( x << 16 ) | sizeX;
	arg2 = ( y << 16 ) | sizeY;
	//
	__asm{
		mov eax, 13
		mov ebx, arg1
		mov ecx, arg2
		mov edx, colour
		int 0x40
	}
}
 
 
// ôóíêöèÿ 17
bool kos_GetButtonID( Dword &buttonID )
{
	Dword result;
 
	//
	__asm{
		mov eax, 17
		int 0x40
		mov result, eax
	}
	//
	buttonID = result >> 8;
	//
	return (result & 0xFF) == 0;
}
 
 
// ôóíêöèÿ 23
Dword kos_WaitForEvent( Dword timeOut )
{
//	Dword result;
 
	__asm{
		mov eax, 23
		mov ebx, timeOut
		int 0x40
//		mov result, eax
	}
	
//	return result;
}
 
 
// ïîëó÷åíèå èíôîðìàöèè î ñîñòîÿíèè "ìûøè" ôóíêöèÿ 37
void kos_GetMouseState( Dword & buttons, int & cursorX, int & cursorY )
{
	Dword mB;
	Word curX;
	Word curY;
	sProcessInfo sPI;
 
	//
	__asm{
		mov		eax, 37
		mov		ebx, 0
		int		0x40
		mov		curY, ax
		shr		eax, 16
		mov		curX, ax
		mov		eax, 37
		mov		ebx, 2
		int		0x40
		mov		mB, eax
	}
	//
	kos_ProcessInfo( &sPI );
	//
	buttons = mB;
	cursorX = curX - sPI.processInfo.x_start;
	cursorY = curY - sPI.processInfo.y_start;
}
 
 
// ôóíêöèÿ 40 óñòàíîâèòü ìàñêó ñîáûòèé
void kos_SetMaskForEvents( Dword mask )
{
	//
	__asm{
		mov eax, 40
		mov ebx, mask
		int 0x40
	}
}
 
 
// ôóíêöèÿ 47 âûâåñòè â îêíî ïðèëîæåíèÿ ÷èñëî
void kos_DisplayNumberToWindow(
   Dword value,
   Dword digitsNum,
   Word x,
   Word y,
   Dword colour,
   eNumberBase nBase,
   bool valueIsPointer
   )
{
	Dword arg1, arg2;
 
	//
	arg1 = ( valueIsPointer ? 1 : 0 ) |
		( ((Byte)nBase) << 8 ) |
		( ( digitsNum & 0x1F ) << 16 );
	arg2 = ( x << 16 ) | y;
	//
	__asm{
		mov eax, 47
		mov ebx, arg1
		mov ecx, value
		mov edx, arg2
		mov esi, colour
		int 0x40
	}
}
 
 
// ôóíêöèÿ 70 äîñòóï ê ôàéëîâîé ñèñòåìå
Dword kos_FileSystemAccess( kosFileInfo *fileInfo )
{
//	Dword result;
 
	//
	__asm{
		mov eax, 70
		mov ebx, fileInfo
		int 0x40
//		mov result, eax
	}
	//
//	return result;
}
 
 
// ôóíêöèÿ 63 âûâîä ñèìâîëÿ â îêíî îòëàäêè
void kos_DebugOutChar( char ccc )
{
	//
	__asm{
		mov eax, 63
		mov ebx, 1
		mov cl, ccc
		int 0x40
	}
}
 
 
// ôóíêöèÿ 66 ðåæèì ïîëó÷åíèÿ äàííûõ îò êëàâèàòóðû
void kos_SetKeyboardDataMode( Dword mode )
{
	//
	__asm{
		mov eax, 66
		mov ebx, 1
		mov ecx, mode
		int 0x40
	}
}
 
 
// âûâîä ñòðîêè â îêíî îòëàäêè
void rtlDebugOutString( char *str )
{
	//
	for ( ; str[0] != 0; str++ )
	{
		kos_DebugOutChar( str[0] );
	}
	//
	kos_DebugOutChar( 13 );
	kos_DebugOutChar( 10 );
}
 
 
// ôóíêöèÿ 64 èçìåíåíèå êîëè÷åñòâà ïàìÿòè, âûäåëåííîé äëÿ ïðîãðàììû
bool kos_ApplicationMemoryResize( Dword targetSize )
{
	Dword result;
 
	//
	__asm{
		mov eax, 64
		mov ebx, 1
		mov ecx, targetSize
		int 0x40
		mov result, eax
	}
	//
	return result == 0;
}
 
 
// ôóíêöèÿ 67 èçìåíèòü ïàðàìåòðû îêíà, ïàðàìåòð == -1 íå ìåíÿåòñÿ
void kos_ChangeWindow( Dword x, Dword y, Dword sizeX, Dword sizeY )
{
	//
	__asm{
		mov eax, 67
		mov ebx, x
		mov ecx, y
		mov edx, sizeX
		mov esi, sizeY
		int 0x40
	}
}
 
void kos_InitHeap()
{
	__asm{
		mov eax, 68
		mov ebx, 11
		int 0x40
	}
}
 
 
 
// âûçîâ àáñòðàêòíîãî ìåòîäà
int __cdecl _purecall()
{
	rtlDebugOutString( pureCallMessage );
	kos_ExitApp();
	return 0;
}
 
 
// âûçîâ ñòàòè÷åñêèõ èíèöèàëèçàòîðîâ
// çàîäíî èíèöèàëèçàöèÿ ãåíåðàòîðà ñëó÷àéíûõ ÷èñåë
//#pragma section(".CRT$XCA",long,read,write)
//#pragma section(".CRT$XCZ",long,read,write)
#pragma data_seg(".CRT$XCA")
#pragma data_seg(".CRT$XCZ")
typedef void (__cdecl *_PVFV)(void);
__declspec(allocate(".CRT$XCA"))  _PVFV __xc_a[1] = { NULL };
__declspec(allocate(".CRT$XCZ"))  _PVFV __xc_z[1] = { NULL };
//
#pragma comment(linker, "/merge:.CRT=.rdata")
//
void crtStartUp()
{
	// âûçûâàåì èíèöèàëèçàòîðû ïî ñïèñêó, NULL'û èãíîðèðóåì
	for ( _PVFV *pbegin = __xc_a; pbegin < __xc_z; pbegin++ )
	{
		//
		if ( *pbegin != NULL )
			(**pbegin)();
	}
	// èíèöèàëèçèðóåì ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
	rtlSrand( kos_GetSystemClock() );
	// ïóòü ê ôàéëó ïðîöåññà
	kosExePath = *((char **)0x20);
	// âûçîâ ãëàâíîé ôóíêöèè ïðèëîæåíèÿ
	kos_Main();
	// âûõîä
	kos_ExitApp();
}

Rev 990	Rev 1114
1	#include "kosSyst.h"	1	#include "kosSyst.h"
2	#include "func.h"	2	#include "func.h"
3	#include	3	#include
4		4
5	#define atexitBufferSize 32	5	#define atexitBufferSize 32
6		6
7		7
8	char pureCallMessage[] = "PURE function call!";	8	char pureCallMessage[] = "PURE function call!";
9		9
10	char *kosExePath = NULL;	10	char *kosExePath = NULL;
11		11
12	//	12	//
13	void (__cdecl *atExitList[atexitBufferSize])();	13	void (__cdecl *atExitList[atexitBufferSize])();
14	int atExitFnNum = 0;	14	int atExitFnNum = 0;
15	//	15	//
16	int __cdecl atexit( void (__cdecl *func )( void ))	16	int __cdecl atexit( void (__cdecl *func )( void ))
17	{	17	{
18	//	18	//
19	if ( atExitFnNum < atexitBufferSize )	19	if ( atExitFnNum < atexitBufferSize )
20	{	20	{
21	//	21	//
22	atExitList[atExitFnNum++] = func;	22	atExitList[atExitFnNum++] = func;
23	return 0;	23	return 0;
24	}	24	}
25	else	25	else
26	{	26	{
27	return 1;	27	return 1;
28	}	28	}
29	}	29	}
30		30
31		31
32	//	32	//
33	Dword RandomSeed = 1;	33	Dword RandomSeed = 1;
34	//	34	//
35	void rtlSrand( Dword seed )	35	void rtlSrand( Dword seed )
36	{	36	{
37	RandomSeed = seed;	37	RandomSeed = seed;
38	}	38	}
39	//	39	//
40	Dword rtlRand( void )	40	Dword rtlRand( void )
41	{	41	{
42	//ìàñêà 0x80000776	42	//ìàñêà 0x80000776
43		43
44	Dword dwi, i;	44	Dword dwi, i;
45		45
46	for ( i = 0; i < 32; i++ )	46	for ( i = 0; i < 32; i++ )
47	{	47	{
48		48
49	dwi = RandomSeed & 0x80000776;	49	dwi = RandomSeed & 0x80000776;
50		50
51	__asm{	51	__asm{
52	mov eax, dwi	52	mov eax, dwi
53	mov edx, eax	53	mov edx, eax
54	bswap eax	54	bswap eax
55	xor eax, edx	55	xor eax, edx
56	xor al, ah	56	xor al, ah
57	setpo al	57	setpo al
58	movzx eax, al	58	movzx eax, al
59	mov dwi, eax	59	mov dwi, eax
60	}	60	}
61		61
62	RandomSeed = ( RandomSeed << 1 ) \| ( dwi & 1 );	62	RandomSeed = ( RandomSeed << 1 ) \| ( dwi & 1 );
63	}	63	}
64		64
65	return RandomSeed;	65	return RandomSeed;
66	}	66	}
67		67
68		68
69	void * __cdecl memcpy( void dst, const void src, size_t bytesCount )	69	/void __cdecl memcpy( void dst, const void src, size_t bytesCount )
70	{	70	{
71	__asm{	71	__asm{
72	mov edi, dst	72	mov edi, dst
73	mov eax, dst	73	mov eax, dst
74	mov esi, src	74	mov esi, src
75	mov ecx, bytesCount	75	mov ecx, bytesCount
76	rep movsb	76	rep movsb
77	}	77	}
78	}	78	}
79		79
80	//	80	//
81	void memset( Byte *dst, Byte filler, Dword count )	81	void memset( Byte *dst, Byte filler, Dword count )
82	{	82	{
83	//	83	//
84	__asm{	84	__asm{
85	mov edi, dst	85	mov edi, dst
86	mov al, filler	86	mov al, filler
87	mov ecx, count	87	mov ecx, count
88	rep stosb	88	rep stosb
89	}	89	}
90	}	90	}*/
91		91
92		92
93	//	93	//
94	Dword rtlInterlockedExchange( Dword *target, Dword value )	94	Dword rtlInterlockedExchange( Dword *target, Dword value )
95	{	95	{
96	// Dword result;	96	// Dword result;
97		97
98	//	98	//
99	__asm{	99	__asm{
100	mov eax, value	100	mov eax, value
101	mov ebx, target	101	mov ebx, target
102	xchg eax, [ebx]	102	xchg eax, [ebx]
103	// mov result, eax	103	// mov result, eax
104	}	104	}
105	//	105	//
106	// return result;	106	// return result;
107	}	107	}
108		108
109		109
110	//////////////////////////////////////////////////////////////////////	110	//////////////////////////////////////////////////////////////////////
111	//	111	//
112	// êîïèðîâàíèå ñòðîêè	112	// êîïèðîâàíèå ñòðîêè
113	//	113	//
114		114
115	char * __cdecl strcpy( char target, const char source )	115	char * __cdecl strcpy( char target, const char source )
116	{	116	{
117	char *result = target;	117	char *result = target;
118		118
119	while( target[0] = source[0] )	119	while( target[0] = source[0] )
120	{	120	{
121	target++;	121	target++;
122	source++;	122	source++;
123	}	123	}
124		124
125	return result;	125	return result;
126	}	126	}
127		127
128		128
129	//////////////////////////////////////////////////////////////////////	129	//////////////////////////////////////////////////////////////////////
130	//	130	//
131	// ðåâåðñèâíûé ïîèñê ñèìâîëà	131	// ðåâåðñèâíûé ïîèñê ñèìâîëà
132	//	132	//
133		133
134	char * __cdecl strrchr( const char * string, int c )	134	char * __cdecl strrchr( const char * string, int c )
135	{	135	{
136	char *cPtr;	136	char *cPtr;
137		137
138	//	138	//
139	for ( cPtr = (char *)string + strlen( string ); cPtr >= string; cPtr-- )	139	for ( cPtr = (char *)string + strlen( string ); cPtr >= string; cPtr-- )
140	{	140	{
141	//	141	//
142	if ( *cPtr == c ) return cPtr;	142	if ( *cPtr == c ) return cPtr;
143	}	143	}
144	//	144	//
145	return NULL;	145	return NULL;
146	}	146	}
147		147
148		148
149	//////////////////////////////////////////////////////////////////////	149	//////////////////////////////////////////////////////////////////////
150	//	150	//
151	// îïðåäåëåíèå äëèíû ñòðîêè	151	// îïðåäåëåíèå äëèíû ñòðîêè
152	//	152	//
153		153
154	int __cdecl strlen( const char *line )	154	int __cdecl strlen( const char *line )
155	{	155	{
156	int i;	156	int i;
157		157
158	for( i=0; line[i] != 0; i++ );	158	for( i=0; line[i] != 0; i++ );
159	return i;	159	return i;
160	}	160	}
161		161
162		162
163		163
164	//////////////////////////////////////////////////////////////////////	164	//////////////////////////////////////////////////////////////////////
165	//	165	//
166	// ïåðåâîä øåñòíàäöàòèðè÷íîãî ÷èñëà â ñèìâîë	166	// ïåðåâîä øåñòíàäöàòèðè÷íîãî ÷èñëà â ñèìâîë
167	//	167	//
168		168
169	unsigned int num2hex( unsigned int num )	169	unsigned int num2hex( unsigned int num )
170	{	170	{
171	if( num < 10 )	171	if( num < 10 )
172	return num + '0';	172	return num + '0';
173	return num - 10 + 'A';	173	return num - 10 + 'A';
174	}	174	}
175		175
176		176
177	//////////////////////////////////////////////////////////////////////	177	//////////////////////////////////////////////////////////////////////
178	//	178	//
179	// âûâîä ñòðîêè íà ïå÷àòü. barsuk äîáàâèë %f	179	// âûâîä ñòðîêè íà ïå÷àòü. barsuk äîáàâèë %f
180		180
181	//#define PREC 2	181	//#define PREC 2
182	//#define HALF 0.499	182	//#define HALF 0.499
183	#define PREC 6	183	#define PREC 6
184	#define HALF 0.4999999	184	#define HALF 0.4999999
185		185
186	double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,	186	double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
187	1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30};	187	1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30};
188		188
189		189
190	//	190	//
191		191
192	Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,	192	Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,
193	10000, 1000, 100, 10, 0 };	193	10000, 1000, 100, 10, 0 };
194		194
195	//	195	//
196	void sprintf( char Str, char Format, ... )	196	void sprintf( char Str, char Format, ... )
197	{	197	{
198	int i, fmtlinesize, j, k, flag;	198	int i, fmtlinesize, j, k, flag;
199	Dword head, tail;	199	Dword head, tail;
200	char c;	200	char c;
201	va_list arglist;	201	va_list arglist;
202	//	202	//
203	va_start(arglist, Format);	203	va_start(arglist, Format);
204		204
205	//	205	//
206	fmtlinesize = strlen( Format );	206	fmtlinesize = strlen( Format );
207	//	207	//
208	if( fmtlinesize == 0 ) return;	208	if( fmtlinesize == 0 ) return;
209		209
210	//	210	//
211	for( i = 0, j = 0; i < fmtlinesize; i++ )	211	for( i = 0, j = 0; i < fmtlinesize; i++ )
212	{	212	{
213	//	213	//
214	c = Format[i];	214	c = Format[i];
215	//	215	//
216	if( c != '%' )	216	if( c != '%' )
217	{	217	{
218	Str[j++] = c;	218	Str[j++] = c;
219	continue;	219	continue;
220	}	220	}
221	//	221	//
222	i++;	222	i++;
223	//	223	//
224	if( i >= fmtlinesize ) break;	224	if( i >= fmtlinesize ) break;
225		225
226	//	226	//
227	flag = 0;	227	flag = 0;
228	//	228	//
229	c = Format[i];	229	c = Format[i];
230	//	230	//
231	switch( c )	231	switch( c )
232	{	232	{
233	//	233	//
234	case '%':	234	case '%':
235	Str[j++] = c;	235	Str[j++] = c;
236	break;	236	break;
237	// âûâîä ñòðîêè	237	// âûâîä ñòðîêè
238	case 'S':	238	case 'S':
239	Byte* str;	239	Byte* str;
240	str = va_arg(arglist, Byte*);	240	str = va_arg(arglist, Byte*);
241	for( k = 0; ( c = str[k] ) != 0; k++ )	241	for( k = 0; ( c = str[k] ) != 0; k++ )
242	{	242	{
243	Str[j++] = c;	243	Str[j++] = c;
244	}	244	}
245	break;	245	break;
246	// âûâîä áàéòà	246	// âûâîä áàéòà
247	case 'B':	247	case 'B':
248	k = va_arg(arglist, int) & 0xFF;	248	k = va_arg(arglist, int) & 0xFF;
249	Str[j++] = num2hex( ( k >> 4 ) & 0xF );	249	Str[j++] = num2hex( ( k >> 4 ) & 0xF );
250	Str[j++] = num2hex( k & 0xF );	250	Str[j++] = num2hex( k & 0xF );
251	break;	251	break;
252	// âûâîä ñèìâîëà	252	// âûâîä ñèìâîëà
253	case 'C':	253	case 'C':
254	Str[j++] = va_arg(arglist, int) & 0xFF;	254	Str[j++] = va_arg(arglist, int) & 0xFF;
255	break;	255	break;
256	// âûâîä äâîéíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå	256	// âûâîä äâîéíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
257	case 'X':	257	case 'X':
258	Dword val;	258	Dword val;
259	val = va_arg(arglist, Dword);	259	val = va_arg(arglist, Dword);
260	for( k = 7; k >= 0; k-- )	260	for( k = 7; k >= 0; k-- )
261	{	261	{
262	//	262	//
263	c = num2hex ( ( val >> (k * 4) ) & 0xF );	263	c = num2hex ( ( val >> (k * 4) ) & 0xF );
264	//	264	//
265	if( c == '0' )	265	if( c == '0' )
266	{	266	{
267	if( flag ) Str[j++] = c;	267	if( flag ) Str[j++] = c;
268	}	268	}
269	else	269	else
270	{	270	{
271	flag++;	271	flag++;
272	Str[j++] = c;	272	Str[j++] = c;
273	}	273	}
274	}	274	}
275	//	275	//
276	if( flag == 0 ) Str[j++] = '0';	276	if( flag == 0 ) Str[j++] = '0';
277	break;	277	break;
278	// âûâîä äâîéíîãî ñëîâà â äåñÿòè÷íîì âèäå	278	// âûâîä äâîéíîãî ñëîâà â äåñÿòè÷íîì âèäå
279	case 'U':	279	case 'U':
280	head = va_arg(arglist, Dword);	280	head = va_arg(arglist, Dword);
281	tail = 0;	281	tail = 0;
282	for( k = 0; dectab[k] != 0; k++ )	282	for( k = 0; dectab[k] != 0; k++ )
283	{	283	{
284	tail = head % dectab[k];	284	tail = head % dectab[k];
285	head /= dectab[k];	285	head /= dectab[k];
286	c = head + '0';	286	c = head + '0';
287	if( c == '0' )	287	if( c == '0' )
288	{	288	{
289	if( flag ) Str[j++] = c;	289	if( flag ) Str[j++] = c;
290	}	290	}
291	else	291	else
292	{	292	{
293	flag++;	293	flag++;
294	Str[j++] = c;	294	Str[j++] = c;
295	}	295	}
296	//	296	//
297	head = tail;	297	head = tail;
298	}	298	}
299	//	299	//
300	c = head + '0';	300	c = head + '0';
301	Str[j++] = c;	301	Str[j++] = c;
302	break;	302	break;
303	// âåùåñòâåííîå ÷èñëî â ôîðìàòå 7.2	303	// âåùåñòâåííîå ÷èñëî â ôîðìàòå 7.2
304	case 'f':	304	case 'f':
305	case 'F':	305	case 'F':
306	case 'g':	306	case 'g':
307	case 'G':	307	case 'G':
308	{	308	{
309	double val, w;	309	double val, w;
310	int p;	310	int p;
311	val = va_arg(arglist, double);	311	val = va_arg(arglist, double);
312	if (val < 0.0)	312	if (val < 0.0)
313	{	313	{
314	Str[j++] = '-';	314	Str[j++] = '-';
315	val = -val;	315	val = -val;
316	}	316	}
317	for (k = 0; k < 30; k++)	317	for (k = 0; k < 30; k++)
318	if (val < double_tab[k])	318	if (val < double_tab[k])
319	break;	319	break;
320		320
321	if (val < 1.0)	321	if (val < 1.0)
322	{	322	{
323	Str[j++] = '0';	323	Str[j++] = '0';
324	}	324	}
325		325
326	for (p = 1; p < k + 1; p++)	326	for (p = 1; p < k + 1; p++)
327	{	327	{
328	int d = (int)di(val / double_tab[k - p] - HALF) % 10;	328	int d = (int)di(val / double_tab[k - p] - HALF) % 10;
329	Str[j++] = '0' + d;	329	Str[j++] = '0' + d;
330	val -= d * double_tab[k - p];	330	val -= d * double_tab[k - p];
331	}	331	}
332	Str[j++] = '.';	332	Str[j++] = '.';
333	w = 0.1;	333	w = 0.1;
334	for (p = 0; p < PREC - 1; p++)	334	for (p = 0; p < PREC - 1; p++)
335	{	335	{
336	val-=floor(val);	336	val-=floor(val);
337	Str[j++] = '0' + di(val / w - HALF) % 10;	337	Str[j++] = '0' + di(val / w - HALF) % 10;
338	w /= 10.0;	338	w /= 10.0;
339	}	339	}
340	}	340	}
341	break;	341	break;
342		342
343	// âûâîä 64-áèòíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå	343	// âûâîä 64-áèòíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
344	case 'Q':	344	case 'Q':
345	unsigned int low_dword, high_dword;	345	unsigned int low_dword, high_dword;
346	low_dword = va_arg(arglist, unsigned int);	346	low_dword = va_arg(arglist, unsigned int);
347	high_dword = va_arg(arglist, unsigned int);	347	high_dword = va_arg(arglist, unsigned int);
348	for( k = 7; k >= 0; k-- )	348	for( k = 7; k >= 0; k-- )
349	{	349	{
350	//	350	//
351	c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF );	351	c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF );
352	//	352	//
353	if( c == '0' )	353	if( c == '0' )
354	{	354	{
355	if( flag ) Str[j++] = c;	355	if( flag ) Str[j++] = c;
356	}	356	}
357	else	357	else
358	{	358	{
359	flag++;	359	flag++;
360	Str[j++] = c;	360	Str[j++] = c;
361	}	361	}
362	}	362	}
363	//	363	//
364	for( k=7; k >= 0; k-- )	364	for( k=7; k >= 0; k-- )
365	{	365	{
366	//	366	//
367	c = num2hex ( ( low_dword >> (k * 4) ) & 0xF );	367	c = num2hex ( ( low_dword >> (k * 4) ) & 0xF );
368	//	368	//
369	if( c == '0' )	369	if( c == '0' )
370	{	370	{
371	if( flag ) Str[j++] = c;	371	if( flag ) Str[j++] = c;
372	}	372	}
373	else	373	else
374	{	374	{
375	flag++;	375	flag++;
376	Str[j++] = c;	376	Str[j++] = c;
377	}	377	}
378	}	378	}
379	//	379	//
380	if( flag == 0 ) Str[j++] = '0';	380	if( flag == 0 ) Str[j++] = '0';
381	//	381	//
382	break;	382	break;
383	//	383	//
384	default:	384	default:
385	break;	385	break;
386	}	386	}
387	}	387	}
388	//	388	//
389	Str[j] = 0;	389	Str[j] = 0;
390	}	390	}
391		391
392		392
393	// ôóíêöèÿ -1 çàâåðøåíèÿ ïðîöåññà	393	// ôóíêöèÿ -1 çàâåðøåíèÿ ïðîöåññà
394	void kos_ExitApp()	394	void kos_ExitApp()
395	{	395	{
396	int i;	396	int i;
397		397
398	//	398	//
399	for ( i = atExitFnNum - 1; i >= 0; i-- )	399	for ( i = atExitFnNum - 1; i >= 0; i-- )
400	{	400	{
401	//	401	//
402	atExitList[i]();	402	atExitList[i]();
403	}	403	}
404	//	404	//
405	__asm{	405	__asm{
406	mov eax, -1	406	mov eax, -1
407	int 0x40	407	int 0x40
408	}	408	}
409	}	409	}
410		410
411		411
412	// ôóíêöèÿ 0	412	// ôóíêöèÿ 0
413	void kos_DefineAndDrawWindow(	413	void kos_DefineAndDrawWindow(
414	Word x, Word y,	414	Word x, Word y,
415	Word sizeX, Word sizeY,	415	Word sizeX, Word sizeY,
416	Byte mainAreaType,	416	Byte mainAreaType,
417	Dword mainAreaColour,	417	Dword mainAreaColour,
418	Byte headerType,	418	Byte headerType,
419	Dword headerColour,	419	Dword headerColour,
420	Dword borderColour	420	Dword borderColour
421	)	421	)
422	{	422	{
423	Dword arg1, arg2, arg3, arg4;	423	Dword arg1, arg2, arg3, arg4;
424		424
425	//	425	//
426	arg1 = ( x << 16 ) + sizeX;	426	arg1 = ( x << 16 ) + sizeX;
427	arg2 = ( y << 16 ) + sizeY;	427	arg2 = ( y << 16 ) + sizeY;
428	arg3 = ( mainAreaType << 24 ) \| mainAreaColour;	428	arg3 = ( mainAreaType << 24 ) \| mainAreaColour;
429	arg4 = ( headerType << 24 ) \| headerColour;	429	arg4 = ( headerType << 24 ) \| headerColour;
430	//	430	//
431	__asm{	431	__asm{
432	mov eax, 0	432	mov eax, 0
433	mov ebx, arg1	433	mov ebx, arg1
434	mov ecx, arg2	434	mov ecx, arg2
435	mov edx, arg3	435	mov edx, arg3
436	mov esi, arg4	436	mov esi, arg4
437	mov edi, borderColour	437	mov edi, borderColour
438	int 0x40	438	int 0x40
439	}	439	}
440	}	440	}
441		441
442		442
443	// ôóíêöèÿ 1 ïîñòàâèòü òî÷êó	443	// ôóíêöèÿ 1 ïîñòàâèòü òî÷êó
444	void kos_PutPixel( Dword x, Dword y, Dword colour )	444	void kos_PutPixel( Dword x, Dword y, Dword colour )
445	{	445	{
446	//	446	//
447	__asm{	447	__asm{
448	mov eax, 1	448	mov eax, 1
449	mov ebx, x	449	mov ebx, x
450	mov ecx, y	450	mov ecx, y
451	mov edx, colour	451	mov edx, colour
452	int 0x40	452	int 0x40
453	}	453	}
454	}	454	}
455		455
456		456
457	// ôóíêöèÿ 2 ïîëó÷èòü êîä íàæàòîé êëàâèøè	457	// ôóíêöèÿ 2 ïîëó÷èòü êîä íàæàòîé êëàâèøè
458	bool kos_GetKey( Byte &keyCode )	458	bool kos_GetKey( Byte &keyCode )
459	{	459	{
460	Dword result;	460	Dword result;
461		461
462	//	462	//
463	__asm{	463	__asm{
464	mov eax, 2	464	mov eax, 2
465	int 0x40	465	int 0x40
466	mov result, eax	466	mov result, eax
467	}	467	}
468	//	468	//
469	keyCode = result >> 8;	469	keyCode = result >> 8;
470	//	470	//
471	return ( result & 0xFF ) == 0;	471	return ( result & 0xFF ) == 0;
472	}	472	}
473		473
474		474
475	// ôóíêöèÿ 3 ïîëó÷èòü âðåìÿ	475	// ôóíêöèÿ 3 ïîëó÷èòü âðåìÿ
476	Dword kos_GetSystemClock()	476	Dword kos_GetSystemClock()
477	{	477	{
478	// Dword result;	478	// Dword result;
479		479
480	//	480	//
481	__asm{	481	__asm{
482	mov eax, 3	482	mov eax, 3
483	int 0x40	483	int 0x40
484	// mov result, eax	484	// mov result, eax
485	}	485	}
486	//	486	//
487	// return result;	487	// return result;
488	}	488	}
489		489
490		490
491	// ôóíêöèÿ 4	491	// ôóíêöèÿ 4
492	void kos_WriteTextToWindow(	492	void kos_WriteTextToWindow(
493	Word x,	493	Word x,
494	Word y,	494	Word y,
495	Byte fontType,	495	Byte fontType,
496	Dword textColour,	496	Dword textColour,
497	char *textPtr,	497	char *textPtr,
498	Dword textLen	498	Dword textLen
499	)	499	)
500	{	500	{

Subversion Repositories Kolibri OS

(root)/programs/other/table/kosSyst.cpp – Rev 990 → 1114