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


#include "kosSyst.h"
#include "func.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;
}
 
#ifdef AUTOBUILD
// Well, not really related to auto-build, but some compilation issue
void 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';
}
 
 
//////////////////////////////////////////////////////////////////////
//
// âûâîä ñòðîêè íà ïå÷àòü. 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_WaitForEventTimeout( 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 };
//
extern void ALMOST_HALF_init();
#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)();
	}*/
	ALMOST_HALF_init();
	// èíèöèàëèçèðóåì ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
	rtlSrand( kos_GetSystemClock() );
#ifndef AUTOBUILD
	// ïóòü ê ôàéëó ïðîöåññà
	kosExePath = *((char **)0x20);
#endif
	// âûçîâ ãëàâíîé ôóíêöèè ïðèëîæåíèÿ
	kos_Main();
	// âûõîä
	kos_ExitApp();
}

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

Subversion Repositories Kolibri OS

(root)/programs/other/table/kosSyst.cpp – Rev 1764 → 2750