WebSVN – Kolibri OS – Diff – /programs/games/xonix/trunk/kosSyst.cpp


#include "kosSyst.h"
 
#define atexitBufferSize	32
 
// Autobuild uses FASM method for exe->kos,
// MENUET01 header should be present in EXE.
#ifdef AUTOBUILD
char kosExePath[1024];
char exeStack[16384];
// must be alphabetically first in the image
#pragma data_seg(".1seg")
extern "C" struct
{
	char header[8];
	int headerver;
	void* entry;
	void* i_end;
	void* memsize;
	void* stack;
	void* params;
	void* icon;
} header = {
	{'M', 'E', 'N', 'U', 'E', 'T', '0', '1'},
	1,
	&crtStartUp,
	0,	// filled by doexe2.asm
	0,	// filled by doexe2.asm
	exeStack + sizeof(exeStack),
	NULL,
	kosExePath
};
#pragma data_seg()
#else
char *kosExePath = NULL;
#endif
 
char pureCallMessage[] = "PURE function call!";
 
//
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';
}
 
 
//////////////////////////////////////////////////////////////////////
//
// âûâîä ñòðîêè íà ïå÷àòü
//
 
Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,
                   10000, 1000, 100, 10, 0 };
 
//
void sprintk( char *Str, PRINTK *arg )
{
	int i, fmtlinesize, j, ac, k, flag;
	Dword head, tail;
	char c;
	
	//
	ac = 0;
 
	//
	fmtlinesize = strlen( arg->fmtline );
	//
	if( fmtlinesize == 0 ) return;
  
	//
	for( i = 0, j = 0; i < fmtlinesize; i++ )
	{
		//
		c = arg->fmtline[i];
		//
		if( c != '%' )
		{
			Str[j++] = c;
			continue;
		}
		//
		i++;
		//
		if( i >= fmtlinesize ) break;
 
		//
		flag = 0;
		//
		c = arg->fmtline[i];
		//
		switch( c )
		{
		//
		case '%':
			Str[j++] = c;
			break;
		// âûâîä ñòðîêè
		case 'S':
			for( k = 0; ( c = ((Byte *)arg->args[ac])[k] ) != 0; k++ )
			{
				Str[j++] = c;
			}
			ac++;
			break;
		// âûâîä áàéòà
		case 'B':
			k = (int)(arg->args[ac]) & 0xFF;
			Str[j++] = num2hex( ( k >> 4 ) & 0xF );
			Str[j++] = num2hex( k & 0xF );
			ac++;
			break;
		// âûâîä ñèìâîëà
		case 'C':
			Str[j++] = (int)(arg->args[ac]) & 0xFF;
			ac++;
			break;
		// âûâîä äâîéíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
		case 'X':
			for( k = 7; k >= 0; k-- )
			{
				//
				c = num2hex ( ( (Dword)(arg->args[ac]) >> (k * 4) ) & 0xF );
				//
				if( c == '0' )
				{
					if( flag ) Str[j++] = c;
				}
				else
				{
					flag++;
					Str[j++] = c;
				}
			}
			//
			if( flag == 0 ) Str[j++] = '0';
			ac++;
			break;
		// âûâîä äâîéíîãî ñëîâà â äåñÿòè÷íîì âèäå
		case 'U':
			head = (Dword)(arg->args[ac]);
			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;
			ac++;
			break;
		// âûâîä 64-áèòíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
		case 'Q':
			for( k = 7; k >= 0; k-- )
			{
				//
				c = num2hex ( ( *((unsigned int *)(arg->args[ac]) + 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 ( ( *((unsigned int *)(arg->args[ac])) >> (k * 4) ) & 0xF );
				//
				if( c == '0' )
				{
					if( flag ) Str[j++] = c;
				}
				else
				{
					flag++;
					Str[j++] = c;
				}
			}
			//
			if( flag == 0 ) Str[j++] = '0';
			//
			ac++;
			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,
	char *title
	)
{
	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, title
		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
	}
}
 
 
// 48, 4 -- get skin height
Dword kos_GetSkinHeight()
{
	__asm{
		mov eax, 48
		mov ebx, 4
		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
	}
}
 
 
// 71,1 set window caption
void kos_SetWindowCaption(char *caption)
{
	__asm{
		mov eax, 71
		mov ebx, 1
		mov ecx, caption
		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)
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()
{
#ifdef AUTOBUILD
// linker will try to remove unused variables; force header to be included
	header.header;
#endif
	// âûçûâàåì èíèöèàëèçàòîðû ïî ñïèñêó, NULL'û èãíîðèðóåì
	for ( _PVFV *pbegin = __xc_a; pbegin < __xc_z; pbegin++ )
	{
		//
		if ( *pbegin != NULL )
			(**pbegin)();
	}
	// èíèöèàëèçèðóåì ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
	rtlSrand( kos_GetSystemClock() );
#ifndef AUTOBUILD
	// ïóòü ê ôàéëó ïðîöåññà
	kosExePath = *((char **)0x20);
#endif
	// âûçîâ ãëàâíîé ôóíêöèè ïðèëîæåíèÿ
	kos_Main();
	// âûõîä
	kos_ExitApp();
}

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

Subversion Repositories Kolibri OS

(root)/programs/games/xonix/trunk/kosSyst.cpp – Rev 5115 → 5822