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


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

Subversion Repositories Kolibri OS

(root)/programs/games/rforces/trunk/kosSyst.cpp – Rev 5114 → 7481