WebSVN – Kolibri OS – Diff – /programs/games/kosilka/kosSyst.cpp


#include "kosSyst.h"
#include 
 
char stack[16384];
char kosExePath[257];
 
// must be alphabetically first in the image
#pragma data_seg(".1seg")
struct __MENUET_header_t
{
	char signature[8];
	unsigned version;
	void* entry;
	unsigned init_size;
	unsigned memsize;
	void* stackptr;
	void* command_line_ptr;
	void* app_path_ptr;
};
__MENUET_header_t __MENUET_header =
{
	{'M','E','N','U','E','T','0','1'},
	1,
	&crtStartUp,
	-1,
	-1,
	stack + sizeof(stack),
	NULL,
	&kosExePath
};
#pragma data_seg()
 
#if 0
#define atexitBufferSize	32
#endif
 
char pureCallMessage[] = "PURE function call!";
 
//char *kosExePath = NULL;
 
#if 0
//
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;
	}
}
#endif
 
//
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;
}
 
#if _MSC_VER >= 1400
//
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
	}
}
#endif
 
//
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 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;
		// âûâîä 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 __declspec(noreturn) kos_ExitApp()
{
#if 0
	int i;
 
	//
	for ( i = atExitFnNum - 1; i >= 0; i-- )
	{
		//
		atExitList[i]();
	}
	//
#endif
	__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
	{
		push edx
getkey:
		mov  eax,2 ; Gluk
		int  0x40
		cmp eax,1
		jne getkeyi
		mov ah,dh
		jmp getkeyii
getkeyi:
		mov dh,ah ; Gluk
		jmp getkey
getkeyii:
		pop edx
		mov result, eax
	}
	//
	keyCode = result >> 8;
	//
	return ( result & 0xFF ) == 0;
}
 
// ôóíêöèÿ 3 ïîëó÷èòü âðåìÿ
Dword __cdecl kos_GetSystemClock()
{
//	Dword result;
 
	//
	__asm{
		mov eax, 3
		int 0x40
//		mov result, eax
	}
	//
//	return result;
}
 
#if 0
// ôóíêöèÿ 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
	}
}
#else
// ôóíêöèÿ 4
void kos_WriteTextToWindow_internal(
	Dword pos,
	Dword font,
	const char *textPtr,
	Dword textLen
	)
{
	__asm{
		mov eax, 4
		mov ebx, pos
		mov ecx, font
		mov edx, textPtr
		mov esi, textLen
		int 0x40
	}
}
#endif
 
 
// ôóíêöèÿ 5 ïàóçà, â ñîòûõ äîëÿõ ñåêóíäû
void __cdecl 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 __cdecl 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 __cdecl 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 __cdecl 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
	}
}
 
 
Dword kos_GetSkinHeight()
{
	__asm{
		mov eax, 48
		mov ebx, 4
		int 0x40
	}
}
 
 
// ôóíêöèÿ 70 äîñòóï ê ôàéëîâîé ñèñòåìå
Dword __fastcall kos_FileSystemAccess( kosFileInfo *fileInfo )
{
//	Dword result;
 
	//
	__asm{
		mov eax, 70
		mov ebx, ecx //fileInfo
		int 0x40
//		mov result, eax
	}
	//
//	return result;
}
 
 
// ôóíêöèÿ 63 âûâîä ñèìâîëÿ â îêíî îòëàäêè
void __fastcall 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
	}
}
 
 
 
// âûçîâ àáñòðàêòíîãî ìåòîäà
int __cdecl _purecall()
{
	rtlDebugOutString( pureCallMessage );
	kos_ExitApp();
	return 0;
}
 
 
// âûçîâ ñòàòè÷åñêèõ èíèöèàëèçàòîðîâ
// çàîäíî èíèöèàëèçàöèÿ ãåíåðàòîðà ñëó÷àéíûõ ÷èñåë
//#pragma section(".CRT$XCA",long,read,write)
//#pragma section(".CRT$XCZ",long,read,write)
void crtStartUp()
{
	__MENUET_header.app_path_ptr;
	// èíèöèàëèçèðóåì ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
	rtlSrand( kos_GetSystemClock() );
	// ïóòü ê ôàéëó ïðîöåññà
	//kosExePath = *((char **)0x20);
	// âûçîâ ãëàâíîé ôóíêöèè ïðèëîæåíèÿ
	kos_Main();
	// âûõîä
	kos_ExitApp();
}

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

Subversion Repositories Kolibri OS

(root)/programs/games/kosilka/kosSyst.cpp @ 968 – Rev 3132 → 5117