added table sources
git-svn-id: svn://kolibrios.org@990 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
parent
5b11f988f5
commit
c24abef1b6
|
@ -0,0 +1,132 @@
|
|||
#include "kosSyst.h"
|
||||
#include "kosfile.h"
|
||||
//#include "string.h"
|
||||
|
||||
|
||||
CKosFile::CKosFile(char *fileName)
|
||||
{
|
||||
//
|
||||
this->fileInfo.bufferPtr = new Byte[FILE_BUFFER_SIZE];
|
||||
//
|
||||
this->filePointer = 0;
|
||||
this->bufferPointer = 0;
|
||||
this->validBuffer = false;
|
||||
//
|
||||
strcpy( this->fileInfo.fileURL, fileName );
|
||||
}
|
||||
|
||||
|
||||
CKosFile::~CKosFile(void)
|
||||
{
|
||||
//
|
||||
delete this->fileInfo.bufferPtr;
|
||||
}
|
||||
|
||||
|
||||
void CKosFile::ValidateBuffer()
|
||||
{
|
||||
//
|
||||
if ( this->validBuffer )
|
||||
{
|
||||
//
|
||||
if ( this->filePointer < this->bufferPointer
|
||||
|| this->filePointer >= (this->bufferPointer + FILE_BUFFER_SIZE) )
|
||||
{
|
||||
//
|
||||
this->validBuffer = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CKosFile::UpdateBuffer(void)
|
||||
{
|
||||
//
|
||||
if ( ! this->validBuffer )
|
||||
{
|
||||
//
|
||||
this->fileInfo.OffsetLow = this->filePointer / OS_BLOCK_SIZE;
|
||||
this->fileInfo.OffsetHigh = 0;
|
||||
//
|
||||
this->bufferPointer = this->fileInfo.OffsetLow * OS_BLOCK_SIZE;
|
||||
//
|
||||
this->fileInfo.dataCount = FILE_BUFFER_BLOCKS;
|
||||
//
|
||||
this->fileInfo.rwMode = 0;
|
||||
//
|
||||
Dword rr = kos_FileSystemAccess( &(this->fileInfo) );
|
||||
this->validBuffer = ( rr == 0 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int CKosFile::Seek(int seekFrom, int seekStep)
|
||||
{
|
||||
//
|
||||
switch ( seekFrom )
|
||||
{
|
||||
//
|
||||
case SEEK_SET:
|
||||
//
|
||||
this->filePointer = seekStep;
|
||||
break;
|
||||
//
|
||||
case SEEK_CUR:
|
||||
//
|
||||
this->filePointer += seekStep;
|
||||
break;
|
||||
}
|
||||
//
|
||||
this->ValidateBuffer();
|
||||
//
|
||||
return this->filePointer;
|
||||
}
|
||||
|
||||
|
||||
int CKosFile::Read(Byte *targetPtr, int readCount)
|
||||
{
|
||||
int bufferLeast, result;
|
||||
|
||||
//
|
||||
result = 0;
|
||||
//
|
||||
do
|
||||
{
|
||||
//
|
||||
this->UpdateBuffer();
|
||||
//
|
||||
if ( ! this->validBuffer ) return result;
|
||||
//
|
||||
bufferLeast = FILE_BUFFER_SIZE - (this->filePointer - this->bufferPointer);
|
||||
//
|
||||
if ( bufferLeast > readCount ) bufferLeast = readCount;
|
||||
//
|
||||
if ( bufferLeast )
|
||||
{
|
||||
//
|
||||
memcpy(
|
||||
targetPtr,
|
||||
this->fileInfo.bufferPtr + (this->filePointer - this->bufferPointer),
|
||||
bufferLeast
|
||||
);
|
||||
//
|
||||
targetPtr += bufferLeast;
|
||||
readCount -= bufferLeast;
|
||||
this->filePointer += bufferLeast;
|
||||
//
|
||||
result += bufferLeast;
|
||||
}
|
||||
//
|
||||
this->ValidateBuffer();
|
||||
}
|
||||
while ( readCount > 0 );
|
||||
//
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
int CKosFile::Write(Byte *sourcePtr, int writeCount)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
#pragma once
|
||||
|
||||
#define SEEK_SET 0
|
||||
#define SEEK_CUR 1
|
||||
|
||||
#define FILE_BUFFER_SIZE 512
|
||||
#define OS_BLOCK_SIZE 1
|
||||
#define FILE_BUFFER_BLOCKS (FILE_BUFFER_SIZE / OS_BLOCK_SIZE)
|
||||
|
||||
|
||||
class CKosFile
|
||||
{
|
||||
public:
|
||||
CKosFile(char *fileName);
|
||||
virtual ~CKosFile(void);
|
||||
virtual int Read(Byte *targetPtr, int readCount);
|
||||
virtual int Write(Byte *sourcePtr, int writeCount);
|
||||
virtual int Seek(int seekFrom, int seekStep);
|
||||
protected:
|
||||
int filePointer;
|
||||
int bufferPointer;
|
||||
bool validBuffer;
|
||||
kosFileInfo fileInfo;
|
||||
virtual void ValidateBuffer(void);
|
||||
virtual void UpdateBuffer(void);
|
||||
};
|
|
@ -0,0 +1,28 @@
|
|||
//
|
||||
|
||||
struct MemBlock
|
||||
{
|
||||
Dword Size;
|
||||
Dword Addr;
|
||||
MemBlock *Next;
|
||||
MemBlock *Previous;
|
||||
};
|
||||
|
||||
|
||||
#define INITIALQUEUESIZE (32 * 4)
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE -1
|
||||
|
||||
#define MB_FREE 0
|
||||
#define MB_USER 1
|
||||
|
||||
#define SIZE_ALIGN 4
|
||||
|
||||
|
||||
|
||||
Byte *allocmem( Dword reqsize );
|
||||
Dword freemem( void *vaddress );
|
||||
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,24 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "KosSyst.h"
|
||||
|
||||
extern int cf_x0, cf_x1, cf_y0, cf_y1;
|
||||
|
||||
void calculate_values();
|
||||
int get_x(int x);
|
||||
int get_y(int y);
|
||||
char *make_col_cap(int i);
|
||||
char *make_row_cap(int i);
|
||||
void init();
|
||||
void reinit();
|
||||
int SaveFile(char *fname);
|
||||
int LoadFile(char *fname);
|
||||
int SaveCSV(char *fname);
|
||||
int LoadCSV(char *fname);
|
||||
void fill_cells(int sel_x, int sel_y, int sel_end_x, int sel_end_y, int old_end_x, int old_end_y);
|
||||
int parse_cell_name(char *str, int *px, int *py, int *xd = NULL, int *yd = NULL);
|
||||
char *make_cell_name(int x, int y, int xd, int yd);
|
||||
char *change_formula(char *name, int sx, int sy);
|
||||
|
||||
void freeBuffer();
|
|
@ -0,0 +1,510 @@
|
|||
|
||||
|
||||
#include "func.h"
|
||||
|
||||
int convert_error = 0;
|
||||
int SysColor = 0;
|
||||
char debuf[50] = "";
|
||||
|
||||
|
||||
// ïî÷åìó-òî íå áûëî â ñòàíäàðòíîé áèáëèîòåêå
|
||||
void kos_DrawLine( Word x1, Word y1, Word x2, Word y2, Dword colour, Dword invert )
|
||||
{
|
||||
Dword arg1, arg2, arg3;
|
||||
|
||||
//
|
||||
arg1 = ( x1 << 16 ) | x2;
|
||||
arg2 = ( y1 << 16 ) | y2;
|
||||
arg3 = (invert)?0x01000000:colour;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 38
|
||||
mov ebx, arg1
|
||||
mov ecx, arg2
|
||||
mov edx, arg3
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
// ïîõèùåíî èç áèáëèîòåêè ê C--
|
||||
void DrawRegion(Dword x,Dword y,Dword width,Dword height,Dword color1)
|
||||
{
|
||||
kos_DrawBar(x,y,width,1,color1); //ïîëîñà ãîð ñâåðõó
|
||||
kos_DrawBar(x,y+height,width,1,color1); //ïîëîñà ãîð ñíèçó
|
||||
kos_DrawBar(x,y,1,height,color1); //ïîëîñà âåðò ñëåâà
|
||||
kos_DrawBar(x+width,y,1,height+1,color1); //ïîëîñà âåðò ñïðàâà
|
||||
}
|
||||
|
||||
|
||||
// äà, ýòî áàÿí
|
||||
int atoi(const char* string)
|
||||
{
|
||||
int res=0;
|
||||
int sign=0;
|
||||
const char* ptr;
|
||||
for (ptr=string; *ptr && *ptr<=' ';ptr++);
|
||||
if (*ptr=='-') {sign=1;++ptr;}
|
||||
while (*ptr >= '0' && *ptr <= '9')
|
||||
{
|
||||
res = res*10 + *ptr++ - '0';
|
||||
}
|
||||
if (sign) res = -res;
|
||||
return res;
|
||||
}
|
||||
|
||||
/*int abs(int n)
|
||||
{
|
||||
return (n<0)?-n:n;
|
||||
}*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
double fabs(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fabs
|
||||
}
|
||||
#define M_PI 3.14159265358979323846
|
||||
double cos(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fcos
|
||||
}
|
||||
double sin(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fsin
|
||||
}
|
||||
|
||||
bool isalpha(char c)
|
||||
{
|
||||
return (c==' ' || c=='\n' || c=='\t' || c=='\r');
|
||||
}
|
||||
|
||||
// ýòà ôóíêöèÿ - âåëîñèïåä. íî ïðîùå áûëî íàïèñàòü ÷åì íàéòè.
|
||||
double convert(char *s, int *len)
|
||||
{
|
||||
|
||||
int i;
|
||||
|
||||
|
||||
double sign,res, tail, div;
|
||||
|
||||
convert_error = 0;
|
||||
|
||||
res = 0.0;
|
||||
|
||||
i=0;
|
||||
while (s[i] && isalpha(s[i])) i++;
|
||||
if (len) *len=i;
|
||||
if (s[i] == '\0')
|
||||
{
|
||||
convert_error = ERROR_END;
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
sign=1.0;
|
||||
if (s[i] == '-')
|
||||
{
|
||||
sign=-1.0;
|
||||
i++;
|
||||
}
|
||||
while (s[i] && s[i] >= '0' && s[i] <= '9')
|
||||
{
|
||||
res *= 10.0;
|
||||
res += id(s[i] - '0');
|
||||
i++;
|
||||
}
|
||||
if (len) *len=i;
|
||||
if (!s[i] || isalpha(s[i]))
|
||||
return sign*res;
|
||||
if (s[i] != '.' && s[i] != ',')
|
||||
{
|
||||
convert_error = ERROR;
|
||||
return 0;
|
||||
}
|
||||
i++;
|
||||
if (len) *len=i;
|
||||
if (!s[i])
|
||||
return sign*res;
|
||||
|
||||
div = 1.0;
|
||||
tail = 0.0;
|
||||
while (s[i] && s[i] >= '0' && s[i] <= '9')
|
||||
{
|
||||
tail *= 10.0;
|
||||
tail += id(s[i] - '0');
|
||||
div *= 10.0;
|
||||
i++;
|
||||
}
|
||||
res += tail/div;
|
||||
if (len) *len=i;
|
||||
return sign*res;
|
||||
}
|
||||
|
||||
/*
|
||||
#define PREC 2
|
||||
|
||||
double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15};
|
||||
|
||||
// ýòî sprintf, óìåþùèé ôîðìàòèðîâàòü _òîëüêî_ âåùåñòâåííûå ÷èñëà (double) %f
|
||||
void format( char *Str, int len, char* Format, ... )
|
||||
{
|
||||
int i, fmtlinesize, j, k, flag;
|
||||
char c;
|
||||
va_list arglist;
|
||||
//
|
||||
va_start(arglist, Format);
|
||||
|
||||
//
|
||||
fmtlinesize = strlen( Format );
|
||||
//
|
||||
if( fmtlinesize == 0 ) return;
|
||||
|
||||
for (i = 0; i < len; i++)
|
||||
Str[i] = 0;
|
||||
|
||||
//
|
||||
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;
|
||||
// auaia aauanoaaiiiai ?enea
|
||||
case 'f':
|
||||
// ii?aaaeeou ?enei oeo? ai oi?ee
|
||||
double val, w;
|
||||
int p;
|
||||
val = va_arg(arglist, double);
|
||||
if (val < 0.0)
|
||||
{
|
||||
Str[j++] = '-';
|
||||
val = -val;
|
||||
}
|
||||
for (k = 0; k < 15; k++)
|
||||
if (val < double_tab[k])
|
||||
break;
|
||||
|
||||
if (val < 1.0)
|
||||
{
|
||||
Str[j++] = '0';
|
||||
}
|
||||
|
||||
for (p = 1; p < k + 1; p++)
|
||||
{
|
||||
Str[j++] = '0' + di(val / double_tab[k - p] - 0.499) % 10;
|
||||
}
|
||||
Str[j++] = '.';
|
||||
w = 0.1;
|
||||
for (p = 0; p < 2; p++)
|
||||
{
|
||||
val-=floor(val);
|
||||
Str[j++] = '0' + di(val / w - 0.499) % 10;
|
||||
w /= 10.0;
|
||||
}
|
||||
|
||||
//
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
//
|
||||
Str[j] = 0;
|
||||
}
|
||||
|
||||
void *memcpy(void *dst, const void *src, unsigned size)
|
||||
{
|
||||
while (size--)
|
||||
*((char*)dst+size) = *((char*)src+size);
|
||||
return dst;
|
||||
}
|
||||
*/
|
||||
int strcmp(const char *s1, const char *s2)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (s1 == NULL)
|
||||
if (s2 == NULL)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
else
|
||||
if (s2 == NULL)
|
||||
return 1;
|
||||
|
||||
for (i = 0;;i++)
|
||||
{
|
||||
if (s1[i] == '\0')
|
||||
if (s2[i] == '\0')
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
else
|
||||
if (s2[i] == '\0')
|
||||
return 1;
|
||||
else
|
||||
{
|
||||
if (s1[i] != s2[i])
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
kol_struct_import* kol_cofflib_load(char *name)
|
||||
{
|
||||
//asm ("int $0x40"::"a"(68), "b"(19), "c"(name));
|
||||
__asm
|
||||
{
|
||||
mov eax, 68
|
||||
mov ebx, 19
|
||||
mov ecx, name
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void* kol_cofflib_procload (kol_struct_import *imp, char *name)
|
||||
{
|
||||
|
||||
int i;
|
||||
for (i=0;;i++)
|
||||
if ( NULL == ((imp+i) -> name))
|
||||
break;
|
||||
else
|
||||
if ( 0 == strcmp(name, (imp+i)->name) )
|
||||
return (imp+i)->data;
|
||||
return NULL;
|
||||
|
||||
}
|
||||
|
||||
|
||||
unsigned kol_cofflib_procnum (kol_struct_import *imp)
|
||||
{
|
||||
|
||||
unsigned i, n;
|
||||
|
||||
for (i=n=0;;i++)
|
||||
if ( NULL == ((imp+i) -> name))
|
||||
break;
|
||||
else
|
||||
n++;
|
||||
|
||||
return n;
|
||||
|
||||
}
|
||||
|
||||
|
||||
void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n)
|
||||
{
|
||||
|
||||
unsigned i;
|
||||
*name = 0;
|
||||
|
||||
for (i=0;;i++)
|
||||
if ( NULL == ((imp+i) -> name))
|
||||
break;
|
||||
else
|
||||
if ( i == n )
|
||||
{
|
||||
strcpy(name, ((imp+i)->name));
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
end of system part
|
||||
*/
|
||||
|
||||
|
||||
// ïîñêîëüêó ÿ ïîðòèðîâàë ñ äðåâíåãî äîñà...
|
||||
void line( int x1, int y1, int x2, int y2)
|
||||
{
|
||||
kos_DrawLine(x1,y1,x2,y2,SysColor,0);
|
||||
}
|
||||
|
||||
void outtextxy( int x, int y, char *s, int len)
|
||||
{
|
||||
kos_WriteTextToWindow(x,y,0,SysColor,s,len);
|
||||
}
|
||||
|
||||
double textwidth( char *s, int len)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < len; i++)
|
||||
if (s[i] == 0)
|
||||
break;
|
||||
return id(i * 6);
|
||||
}
|
||||
|
||||
double textheight( char *s, int len)
|
||||
{
|
||||
return 8.0;
|
||||
}
|
||||
|
||||
void setcolor( DWORD color)
|
||||
{
|
||||
SysColor = color;
|
||||
}
|
||||
|
||||
void rectangle( int x1, int y1, int x2, int y2)
|
||||
{
|
||||
kos_DrawBar(x1,y1,x2-x1,y2-y1,SysColor);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Dword kos_GetSkinHeight()
|
||||
{
|
||||
__asm{
|
||||
mov eax, 48
|
||||
mov ebx, 4
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
Dword kos_GetSpecialKeyState()
|
||||
{
|
||||
__asm{
|
||||
mov eax, 66
|
||||
mov ebx, 3
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
Dword kos_GetSlotByPID(Dword PID)
|
||||
{
|
||||
__asm
|
||||
{
|
||||
push ebx
|
||||
push ecx
|
||||
mov eax, 18
|
||||
mov ebx, 21
|
||||
mov ecx, PID
|
||||
int 0x40
|
||||
pop ecx
|
||||
pop ebx
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Dword kos_GetActiveSlot()
|
||||
{
|
||||
__asm
|
||||
{
|
||||
push ebx
|
||||
mov eax, 18
|
||||
mov ebx, 7
|
||||
int 0x40
|
||||
pop ebx
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void kos_GetScrollInfo(int &vert, int &hor)
|
||||
{
|
||||
short v, h;
|
||||
__asm
|
||||
{
|
||||
mov eax, 37
|
||||
mov ebx, 7
|
||||
int 0x40
|
||||
mov ebx, eax
|
||||
and eax, 0xffff
|
||||
mov v, ax
|
||||
shr ebx, 16
|
||||
mov h, bx
|
||||
}
|
||||
vert = v;
|
||||
hor = h;
|
||||
}
|
||||
|
||||
|
||||
// ïîëó÷åíèå èíôîðìàöèè î ñîñòîÿíèè "ìûøè" ôóíêöèÿ 37/1
|
||||
void kos_GetMouseStateWnd( Dword & buttons, int & cursorX, int & cursorY )
|
||||
{
|
||||
Dword mB;
|
||||
Word curX;
|
||||
Word curY;
|
||||
sProcessInfo sPI;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 37
|
||||
mov ebx, 1
|
||||
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;
|
||||
}
|
||||
|
||||
char *ftoa(double d)
|
||||
{
|
||||
char buffer[256], *p;
|
||||
sprintf(buffer, "%f", d);
|
||||
p = (char*)allocmem(strlen(buffer)+1);
|
||||
strcpy(p, buffer);
|
||||
return p;
|
||||
}
|
||||
|
||||
double atof(char *s)
|
||||
{
|
||||
return convert(s, NULL);
|
||||
}
|
||||
|
||||
|
||||
int di(double x)
|
||||
{
|
||||
int a;
|
||||
__asm fld x
|
||||
__asm fistp a
|
||||
return a;
|
||||
}
|
||||
|
||||
double id(int x)
|
||||
{
|
||||
double a;
|
||||
__asm fild x
|
||||
__asm fstp a
|
||||
return a;
|
||||
}
|
|
@ -0,0 +1,131 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "kosSyst.h"
|
||||
#include "kosFile.h"
|
||||
#include "MCSMEMM.H"
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
|
||||
#define min(a,b) (((a)<(b))?(a):(b))
|
||||
#define max(a,b) (((a)>(b))?(a):(b))
|
||||
|
||||
|
||||
#define ERROR -1
|
||||
#define ERROR_END -2
|
||||
|
||||
extern int convert_error;
|
||||
|
||||
#define PREC 2
|
||||
|
||||
typedef int HDC;
|
||||
typedef int DWORD;
|
||||
|
||||
extern int SysColor;
|
||||
extern char debuf[50];
|
||||
|
||||
typedef double (*function_t)(double);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
double x, y;
|
||||
} TCoord;
|
||||
|
||||
struct kosBDVK
|
||||
{
|
||||
Dword attrib;
|
||||
Dword name_type;
|
||||
Dword create_time;
|
||||
Dword create_date;
|
||||
Dword access_time;
|
||||
Dword access_date;
|
||||
Dword modify_time;
|
||||
Dword modify_date;
|
||||
Dword size_low;
|
||||
Dword size_high;
|
||||
};
|
||||
|
||||
Dword kos_GetSlotByPID(Dword PID);
|
||||
Dword kos_GetActiveSlot();
|
||||
Dword kos_GetSkinHeight();
|
||||
Dword kos_GetSpecialKeyState();
|
||||
void kos_GetMouseStateWnd( Dword & buttons, int & cursorX, int & cursorY );
|
||||
void kos_DrawLine( Word x1, Word y1, Word x2, Word y2, Dword colour, Dword invert);
|
||||
void DrawRegion(Dword x,Dword y,Dword width,Dword height,Dword color1);
|
||||
int atoi(const char* string);
|
||||
void kos_GetScrollInfo(int &vert, int &hor);
|
||||
|
||||
|
||||
Dword kos_GetSlotByPID(Dword PID);
|
||||
Dword kos_GetActiveSlot();
|
||||
Dword kos_GetSkinHeight();
|
||||
Dword kos_GetSpecialKeyState();
|
||||
|
||||
|
||||
double fabs(double x);
|
||||
double cos(double x);
|
||||
double sin(double x);
|
||||
bool isalpha(char c);
|
||||
double convert(char *s, int *len=NULL);
|
||||
void format( char *Str, int len, char* Format, ... );
|
||||
|
||||
void line( int x1, int y1, int x2, int y2);
|
||||
|
||||
void outtextxy( int x, int y, char *s, int len);
|
||||
void settextstyle( int a1, int a2, int a3);
|
||||
|
||||
|
||||
double textwidth( char *s, int len);
|
||||
double textheight( char *s, int len);
|
||||
void setcolor( DWORD color);
|
||||
void unsetcolor(HDC hdc);
|
||||
void rectangle( int x1, int y1, int x2, int y2);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned p00 ;
|
||||
unsigned p04 ;
|
||||
unsigned p08 ;
|
||||
unsigned p12 ;
|
||||
unsigned p16 ;
|
||||
char p20 ;
|
||||
char *p21 ;
|
||||
} kol_struct70 ;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned p00 ;
|
||||
char p04 ;
|
||||
char p05[3] ;
|
||||
unsigned p08 ;
|
||||
unsigned p12 ;
|
||||
unsigned p16 ;
|
||||
unsigned p20 ;
|
||||
unsigned p24 ;
|
||||
unsigned p28 ;
|
||||
unsigned p32[2] ;
|
||||
unsigned p40 ;
|
||||
} kol_struct_BDVK ;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *name ;
|
||||
void *data ;
|
||||
} kol_struct_import ;
|
||||
|
||||
|
||||
|
||||
kol_struct_import* kol_cofflib_load(char *name);
|
||||
void* kol_cofflib_procload (kol_struct_import *imp, char *name);
|
||||
unsigned kol_cofflib_procnum (kol_struct_import *imp);
|
||||
void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n);
|
||||
int strcmp(const char* string1, const char* string2);
|
||||
|
||||
char *ftoa(double d);
|
||||
double atof(char *s);
|
||||
|
||||
|
||||
int di(double x);
|
||||
double id(int x);
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,139 @@
|
|||
# Microsoft Developer Studio Project File - Name="hello" - Package Owner=<4>
|
||||
# Microsoft Developer Studio Generated Build File, Format Version 6.00
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Application" 0x0101
|
||||
|
||||
CFG=hello - Win32 Release
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "hello.mak".
|
||||
!MESSAGE
|
||||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "hello.mak" CFG="hello - Win32 Release"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "hello - Win32 Release" (based on "Win32 (x86) Application")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
# PROP AllowPerConfigDependencies 0
|
||||
# PROP Scc_ProjName ""
|
||||
# PROP Scc_LocalPath ""
|
||||
CPP=cl.exe
|
||||
MTL=midl.exe
|
||||
RSC=rc.exe
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
|
||||
# ADD CPP /nologo /Zp1 /W3 /vd0 /O2 /YX /FD /c
|
||||
# SUBTRACT CPP /X
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x419 /d "NDEBUG"
|
||||
# ADD RSC /l 0x419 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
|
||||
# ADD LINK32 /nologo /base:"0" /entry:"crtStartUp" /subsystem:windows /machine:I386 /nodefaultlib /align:16
|
||||
# SUBTRACT LINK32 /pdb:none
|
||||
# Begin Custom Build
|
||||
InputPath=.\Release\hello.exe
|
||||
SOURCE="$(InputPath)"
|
||||
|
||||
"hello.kex" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
|
||||
pe2kos Release\hello.exe hello.kex
|
||||
|
||||
# End Custom Build
|
||||
# Begin Target
|
||||
|
||||
# Name "hello - Win32 Release"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\calc.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\func.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\hello.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\KosFile.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\kosSyst.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\math2.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\mcsmemm.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\parser.cpp
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Header Files"
|
||||
|
||||
# PROP Default_Filter "h;hpp;hxx;hm;inl"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\calc.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\func.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\KosFile.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\kosSyst.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\MCSMEMM.H
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\parser.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\use_library.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Resource Files"
|
||||
|
||||
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
|
||||
# End Group
|
||||
# End Target
|
||||
# End Project
|
|
@ -0,0 +1,29 @@
|
|||
Microsoft Developer Studio Workspace File, Format Version 6.00
|
||||
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "hello"=".\hello.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Global:
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<3>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
|
@ -0,0 +1,894 @@
|
|||
#include "kosSyst.h"
|
||||
#include "func.h"
|
||||
#include <stdarg.h>
|
||||
|
||||
#define atexitBufferSize 32
|
||||
|
||||
|
||||
char pureCallMessage[] = "PURE function call!";
|
||||
|
||||
char *kosExePath = NULL;
|
||||
|
||||
//
|
||||
void (__cdecl *atExitList[atexitBufferSize])();
|
||||
int atExitFnNum = 0;
|
||||
//
|
||||
int __cdecl atexit( void (__cdecl *func )( void ))
|
||||
{
|
||||
//
|
||||
if ( atExitFnNum < atexitBufferSize )
|
||||
{
|
||||
//
|
||||
atExitList[atExitFnNum++] = func;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
Dword RandomSeed = 1;
|
||||
//
|
||||
void rtlSrand( Dword seed )
|
||||
{
|
||||
RandomSeed = seed;
|
||||
}
|
||||
//
|
||||
Dword rtlRand( void )
|
||||
{
|
||||
//ìàñêà 0x80000776
|
||||
|
||||
Dword dwi, i;
|
||||
|
||||
for ( i = 0; i < 32; i++ )
|
||||
{
|
||||
|
||||
dwi = RandomSeed & 0x80000776;
|
||||
|
||||
__asm{
|
||||
mov eax, dwi
|
||||
mov edx, eax
|
||||
bswap eax
|
||||
xor eax, edx
|
||||
xor al, ah
|
||||
setpo al
|
||||
movzx eax, al
|
||||
mov dwi, eax
|
||||
}
|
||||
|
||||
RandomSeed = ( RandomSeed << 1 ) | ( dwi & 1 );
|
||||
}
|
||||
|
||||
return RandomSeed;
|
||||
}
|
||||
|
||||
|
||||
void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount )
|
||||
{
|
||||
__asm{
|
||||
mov edi, dst
|
||||
mov eax, dst
|
||||
mov esi, src
|
||||
mov ecx, bytesCount
|
||||
rep movsb
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
void memset( Byte *dst, Byte filler, Dword count )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov edi, dst
|
||||
mov al, filler
|
||||
mov ecx, count
|
||||
rep stosb
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
Dword rtlInterlockedExchange( Dword *target, Dword value )
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, value
|
||||
mov ebx, target
|
||||
xchg eax, [ebx]
|
||||
// mov result, eax
|
||||
}
|
||||
//
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// êîïèðîâàíèå ñòðîêè
|
||||
//
|
||||
|
||||
char * __cdecl strcpy( char *target, const char *source )
|
||||
{
|
||||
char *result = target;
|
||||
|
||||
while( target[0] = source[0] )
|
||||
{
|
||||
target++;
|
||||
source++;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// ðåâåðñèâíûé ïîèñê ñèìâîëà
|
||||
//
|
||||
|
||||
char * __cdecl strrchr( const char * string, int c )
|
||||
{
|
||||
char *cPtr;
|
||||
|
||||
//
|
||||
for ( cPtr = (char *)string + strlen( string ); cPtr >= string; cPtr-- )
|
||||
{
|
||||
//
|
||||
if ( *cPtr == c ) return cPtr;
|
||||
}
|
||||
//
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// îïðåäåëåíèå äëèíû ñòðîêè
|
||||
//
|
||||
|
||||
int __cdecl strlen( const char *line )
|
||||
{
|
||||
int i;
|
||||
|
||||
for( i=0; line[i] != 0; i++ );
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// ïåðåâîä øåñòíàäöàòèðè÷íîãî ÷èñëà â ñèìâîë
|
||||
//
|
||||
|
||||
unsigned int num2hex( unsigned int num )
|
||||
{
|
||||
if( num < 10 )
|
||||
return num + '0';
|
||||
return num - 10 + 'A';
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// âûâîä ñòðîêè íà ïå÷àòü. barsuk äîáàâèë %f
|
||||
|
||||
//#define PREC 2
|
||||
//#define HALF 0.499
|
||||
#define PREC 6
|
||||
#define HALF 0.4999999
|
||||
|
||||
double double_tab[]={1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
|
||||
1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30};
|
||||
|
||||
|
||||
//
|
||||
|
||||
Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000,
|
||||
10000, 1000, 100, 10, 0 };
|
||||
|
||||
//
|
||||
void sprintf( char *Str, char* Format, ... )
|
||||
{
|
||||
int i, fmtlinesize, j, k, flag;
|
||||
Dword head, tail;
|
||||
char c;
|
||||
va_list arglist;
|
||||
//
|
||||
va_start(arglist, Format);
|
||||
|
||||
//
|
||||
fmtlinesize = strlen( Format );
|
||||
//
|
||||
if( fmtlinesize == 0 ) return;
|
||||
|
||||
//
|
||||
for( i = 0, j = 0; i < fmtlinesize; i++ )
|
||||
{
|
||||
//
|
||||
c = Format[i];
|
||||
//
|
||||
if( c != '%' )
|
||||
{
|
||||
Str[j++] = c;
|
||||
continue;
|
||||
}
|
||||
//
|
||||
i++;
|
||||
//
|
||||
if( i >= fmtlinesize ) break;
|
||||
|
||||
//
|
||||
flag = 0;
|
||||
//
|
||||
c = Format[i];
|
||||
//
|
||||
switch( c )
|
||||
{
|
||||
//
|
||||
case '%':
|
||||
Str[j++] = c;
|
||||
break;
|
||||
// âûâîä ñòðîêè
|
||||
case 'S':
|
||||
Byte* str;
|
||||
str = va_arg(arglist, Byte*);
|
||||
for( k = 0; ( c = str[k] ) != 0; k++ )
|
||||
{
|
||||
Str[j++] = c;
|
||||
}
|
||||
break;
|
||||
// âûâîä áàéòà
|
||||
case 'B':
|
||||
k = va_arg(arglist, int) & 0xFF;
|
||||
Str[j++] = num2hex( ( k >> 4 ) & 0xF );
|
||||
Str[j++] = num2hex( k & 0xF );
|
||||
break;
|
||||
// âûâîä ñèìâîëà
|
||||
case 'C':
|
||||
Str[j++] = va_arg(arglist, int) & 0xFF;
|
||||
break;
|
||||
// âûâîä äâîéíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
|
||||
case 'X':
|
||||
Dword val;
|
||||
val = va_arg(arglist, Dword);
|
||||
for( k = 7; k >= 0; k-- )
|
||||
{
|
||||
//
|
||||
c = num2hex ( ( val >> (k * 4) ) & 0xF );
|
||||
//
|
||||
if( c == '0' )
|
||||
{
|
||||
if( flag ) Str[j++] = c;
|
||||
}
|
||||
else
|
||||
{
|
||||
flag++;
|
||||
Str[j++] = c;
|
||||
}
|
||||
}
|
||||
//
|
||||
if( flag == 0 ) Str[j++] = '0';
|
||||
break;
|
||||
// âûâîä äâîéíîãî ñëîâà â äåñÿòè÷íîì âèäå
|
||||
case 'U':
|
||||
head = va_arg(arglist, Dword);
|
||||
tail = 0;
|
||||
for( k = 0; dectab[k] != 0; k++ )
|
||||
{
|
||||
tail = head % dectab[k];
|
||||
head /= dectab[k];
|
||||
c = head + '0';
|
||||
if( c == '0' )
|
||||
{
|
||||
if( flag ) Str[j++] = c;
|
||||
}
|
||||
else
|
||||
{
|
||||
flag++;
|
||||
Str[j++] = c;
|
||||
}
|
||||
//
|
||||
head = tail;
|
||||
}
|
||||
//
|
||||
c = head + '0';
|
||||
Str[j++] = c;
|
||||
break;
|
||||
// âåùåñòâåííîå ÷èñëî â ôîðìàòå 7.2
|
||||
case 'f':
|
||||
case 'F':
|
||||
case 'g':
|
||||
case 'G':
|
||||
{
|
||||
double val, w;
|
||||
int p;
|
||||
val = va_arg(arglist, double);
|
||||
if (val < 0.0)
|
||||
{
|
||||
Str[j++] = '-';
|
||||
val = -val;
|
||||
}
|
||||
for (k = 0; k < 30; k++)
|
||||
if (val < double_tab[k])
|
||||
break;
|
||||
|
||||
if (val < 1.0)
|
||||
{
|
||||
Str[j++] = '0';
|
||||
}
|
||||
|
||||
for (p = 1; p < k + 1; p++)
|
||||
{
|
||||
int d = (int)di(val / double_tab[k - p] - HALF) % 10;
|
||||
Str[j++] = '0' + d;
|
||||
val -= d * double_tab[k - p];
|
||||
}
|
||||
Str[j++] = '.';
|
||||
w = 0.1;
|
||||
for (p = 0; p < PREC - 1; p++)
|
||||
{
|
||||
val-=floor(val);
|
||||
Str[j++] = '0' + di(val / w - HALF) % 10;
|
||||
w /= 10.0;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
// âûâîä 64-áèòíîãî ñëîâà â øåñòíàäöàòèðè÷íîì âèäå
|
||||
case 'Q':
|
||||
unsigned int low_dword, high_dword;
|
||||
low_dword = va_arg(arglist, unsigned int);
|
||||
high_dword = va_arg(arglist, unsigned int);
|
||||
for( k = 7; k >= 0; k-- )
|
||||
{
|
||||
//
|
||||
c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF );
|
||||
//
|
||||
if( c == '0' )
|
||||
{
|
||||
if( flag ) Str[j++] = c;
|
||||
}
|
||||
else
|
||||
{
|
||||
flag++;
|
||||
Str[j++] = c;
|
||||
}
|
||||
}
|
||||
//
|
||||
for( k=7; k >= 0; k-- )
|
||||
{
|
||||
//
|
||||
c = num2hex ( ( low_dword >> (k * 4) ) & 0xF );
|
||||
//
|
||||
if( c == '0' )
|
||||
{
|
||||
if( flag ) Str[j++] = c;
|
||||
}
|
||||
else
|
||||
{
|
||||
flag++;
|
||||
Str[j++] = c;
|
||||
}
|
||||
}
|
||||
//
|
||||
if( flag == 0 ) Str[j++] = '0';
|
||||
//
|
||||
break;
|
||||
//
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
//
|
||||
Str[j] = 0;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ -1 çàâåðøåíèÿ ïðîöåññà
|
||||
void kos_ExitApp()
|
||||
{
|
||||
int i;
|
||||
|
||||
//
|
||||
for ( i = atExitFnNum - 1; i >= 0; i-- )
|
||||
{
|
||||
//
|
||||
atExitList[i]();
|
||||
}
|
||||
//
|
||||
__asm{
|
||||
mov eax, -1
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 0
|
||||
void kos_DefineAndDrawWindow(
|
||||
Word x, Word y,
|
||||
Word sizeX, Word sizeY,
|
||||
Byte mainAreaType,
|
||||
Dword mainAreaColour,
|
||||
Byte headerType,
|
||||
Dword headerColour,
|
||||
Dword borderColour
|
||||
)
|
||||
{
|
||||
Dword arg1, arg2, arg3, arg4;
|
||||
|
||||
//
|
||||
arg1 = ( x << 16 ) + sizeX;
|
||||
arg2 = ( y << 16 ) + sizeY;
|
||||
arg3 = ( mainAreaType << 24 ) | mainAreaColour;
|
||||
arg4 = ( headerType << 24 ) | headerColour;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 0
|
||||
mov ebx, arg1
|
||||
mov ecx, arg2
|
||||
mov edx, arg3
|
||||
mov esi, arg4
|
||||
mov edi, borderColour
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 1 ïîñòàâèòü òî÷êó
|
||||
void kos_PutPixel( Dword x, Dword y, Dword colour )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov eax, 1
|
||||
mov ebx, x
|
||||
mov ecx, y
|
||||
mov edx, colour
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 2 ïîëó÷èòü êîä íàæàòîé êëàâèøè
|
||||
bool kos_GetKey( Byte &keyCode )
|
||||
{
|
||||
Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 2
|
||||
int 0x40
|
||||
mov result, eax
|
||||
}
|
||||
//
|
||||
keyCode = result >> 8;
|
||||
//
|
||||
return ( result & 0xFF ) == 0;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 3 ïîëó÷èòü âðåìÿ
|
||||
Dword kos_GetSystemClock()
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 3
|
||||
int 0x40
|
||||
// mov result, eax
|
||||
}
|
||||
//
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 4
|
||||
void kos_WriteTextToWindow(
|
||||
Word x,
|
||||
Word y,
|
||||
Byte fontType,
|
||||
Dword textColour,
|
||||
char *textPtr,
|
||||
Dword textLen
|
||||
)
|
||||
{
|
||||
Dword arg1, arg2;
|
||||
|
||||
//
|
||||
arg1 = ( x << 16 ) | y;
|
||||
arg2 = ( fontType << 24 ) | textColour;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 4
|
||||
mov ebx, arg1
|
||||
mov ecx, arg2
|
||||
mov edx, textPtr
|
||||
mov esi, textLen
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 5 ïàóçà, â ñîòûõ äîëÿõ ñåêóíäû
|
||||
void kos_Pause( Dword value )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov eax, 5
|
||||
mov ebx, value
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 7 íàðèñîâàòü èçîáðàæåíèå
|
||||
void kos_PutImage( RGB * imagePtr, Word sizeX, Word sizeY, Word x, Word y )
|
||||
{
|
||||
Dword arg1, arg2;
|
||||
|
||||
//
|
||||
arg1 = ( sizeX << 16 ) | sizeY;
|
||||
arg2 = ( x << 16 ) | y;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 7
|
||||
mov ebx, imagePtr
|
||||
mov ecx, arg1
|
||||
mov edx, arg2
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ôóíêöèÿ 8 îïðåäåëèòü êíîïêó
|
||||
void kos_DefineButton( Word x, Word y, Word sizeX, Word sizeY, Dword buttonID, Dword colour )
|
||||
{
|
||||
Dword arg1, arg2;
|
||||
|
||||
//
|
||||
arg1 = ( x << 16 ) | sizeX;
|
||||
arg2 = ( y << 16 ) | sizeY;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 8
|
||||
mov ebx, arg1
|
||||
mov ecx, arg2
|
||||
mov edx, buttonID
|
||||
mov esi, colour
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 9 - èíôîðìàöèÿ î ïðîöåññå
|
||||
Dword kos_ProcessInfo( sProcessInfo *targetPtr, Dword processID )
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 9
|
||||
mov ebx, targetPtr
|
||||
mov ecx, processID
|
||||
int 0x40
|
||||
// mov result, eax
|
||||
}
|
||||
//
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 10
|
||||
Dword kos_WaitForEvent()
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
__asm{
|
||||
mov eax, 10
|
||||
int 0x40
|
||||
// mov result, eax
|
||||
}
|
||||
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 11
|
||||
Dword kos_CheckForEvent()
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
__asm{
|
||||
mov eax, 11
|
||||
int 0x40
|
||||
// mov result, eax
|
||||
}
|
||||
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 12
|
||||
void kos_WindowRedrawStatus( Dword status )
|
||||
{
|
||||
__asm{
|
||||
mov eax, 12
|
||||
mov ebx, status
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 13 íàðèñîâàòü ïîëîñó
|
||||
void kos_DrawBar( Word x, Word y, Word sizeX, Word sizeY, Dword colour )
|
||||
{
|
||||
Dword arg1, arg2;
|
||||
|
||||
//
|
||||
arg1 = ( x << 16 ) | sizeX;
|
||||
arg2 = ( y << 16 ) | sizeY;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 13
|
||||
mov ebx, arg1
|
||||
mov ecx, arg2
|
||||
mov edx, colour
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 17
|
||||
bool kos_GetButtonID( Dword &buttonID )
|
||||
{
|
||||
Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 17
|
||||
int 0x40
|
||||
mov result, eax
|
||||
}
|
||||
//
|
||||
buttonID = result >> 8;
|
||||
//
|
||||
return (result & 0xFF) == 0;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 23
|
||||
Dword kos_WaitForEvent( Dword timeOut )
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
__asm{
|
||||
mov eax, 23
|
||||
mov ebx, timeOut
|
||||
int 0x40
|
||||
// mov result, eax
|
||||
}
|
||||
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
// ïîëó÷åíèå èíôîðìàöèè î ñîñòîÿíèè "ìûøè" ôóíêöèÿ 37
|
||||
void kos_GetMouseState( Dword & buttons, int & cursorX, int & cursorY )
|
||||
{
|
||||
Dword mB;
|
||||
Word curX;
|
||||
Word curY;
|
||||
sProcessInfo sPI;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 37
|
||||
mov ebx, 0
|
||||
int 0x40
|
||||
mov curY, ax
|
||||
shr eax, 16
|
||||
mov curX, ax
|
||||
mov eax, 37
|
||||
mov ebx, 2
|
||||
int 0x40
|
||||
mov mB, eax
|
||||
}
|
||||
//
|
||||
kos_ProcessInfo( &sPI );
|
||||
//
|
||||
buttons = mB;
|
||||
cursorX = curX - sPI.processInfo.x_start;
|
||||
cursorY = curY - sPI.processInfo.y_start;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 40 óñòàíîâèòü ìàñêó ñîáûòèé
|
||||
void kos_SetMaskForEvents( Dword mask )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov eax, 40
|
||||
mov ebx, mask
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 47 âûâåñòè â îêíî ïðèëîæåíèÿ ÷èñëî
|
||||
void kos_DisplayNumberToWindow(
|
||||
Dword value,
|
||||
Dword digitsNum,
|
||||
Word x,
|
||||
Word y,
|
||||
Dword colour,
|
||||
eNumberBase nBase,
|
||||
bool valueIsPointer
|
||||
)
|
||||
{
|
||||
Dword arg1, arg2;
|
||||
|
||||
//
|
||||
arg1 = ( valueIsPointer ? 1 : 0 ) |
|
||||
( ((Byte)nBase) << 8 ) |
|
||||
( ( digitsNum & 0x1F ) << 16 );
|
||||
arg2 = ( x << 16 ) | y;
|
||||
//
|
||||
__asm{
|
||||
mov eax, 47
|
||||
mov ebx, arg1
|
||||
mov ecx, value
|
||||
mov edx, arg2
|
||||
mov esi, colour
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 70 äîñòóï ê ôàéëîâîé ñèñòåìå
|
||||
Dword kos_FileSystemAccess( kosFileInfo *fileInfo )
|
||||
{
|
||||
// Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 70
|
||||
mov ebx, fileInfo
|
||||
int 0x40
|
||||
// mov result, eax
|
||||
}
|
||||
//
|
||||
// return result;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 63 âûâîä ñèìâîëÿ â îêíî îòëàäêè
|
||||
void kos_DebugOutChar( char ccc )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov eax, 63
|
||||
mov ebx, 1
|
||||
mov cl, ccc
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 66 ðåæèì ïîëó÷åíèÿ äàííûõ îò êëàâèàòóðû
|
||||
void kos_SetKeyboardDataMode( Dword mode )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov eax, 66
|
||||
mov ebx, 1
|
||||
mov ecx, mode
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// âûâîä ñòðîêè â îêíî îòëàäêè
|
||||
void rtlDebugOutString( char *str )
|
||||
{
|
||||
//
|
||||
for ( ; str[0] != 0; str++ )
|
||||
{
|
||||
kos_DebugOutChar( str[0] );
|
||||
}
|
||||
//
|
||||
kos_DebugOutChar( 13 );
|
||||
kos_DebugOutChar( 10 );
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 64 èçìåíåíèå êîëè÷åñòâà ïàìÿòè, âûäåëåííîé äëÿ ïðîãðàììû
|
||||
bool kos_ApplicationMemoryResize( Dword targetSize )
|
||||
{
|
||||
Dword result;
|
||||
|
||||
//
|
||||
__asm{
|
||||
mov eax, 64
|
||||
mov ebx, 1
|
||||
mov ecx, targetSize
|
||||
int 0x40
|
||||
mov result, eax
|
||||
}
|
||||
//
|
||||
return result == 0;
|
||||
}
|
||||
|
||||
|
||||
// ôóíêöèÿ 67 èçìåíèòü ïàðàìåòðû îêíà, ïàðàìåòð == -1 íå ìåíÿåòñÿ
|
||||
void kos_ChangeWindow( Dword x, Dword y, Dword sizeX, Dword sizeY )
|
||||
{
|
||||
//
|
||||
__asm{
|
||||
mov eax, 67
|
||||
mov ebx, x
|
||||
mov ecx, y
|
||||
mov edx, sizeX
|
||||
mov esi, sizeY
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
void kos_InitHeap()
|
||||
{
|
||||
__asm{
|
||||
mov eax, 68
|
||||
mov ebx, 11
|
||||
int 0x40
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// âûçîâ àáñòðàêòíîãî ìåòîäà
|
||||
int __cdecl _purecall()
|
||||
{
|
||||
rtlDebugOutString( pureCallMessage );
|
||||
kos_ExitApp();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
// âûçîâ ñòàòè÷åñêèõ èíèöèàëèçàòîðîâ
|
||||
// çàîäíî èíèöèàëèçàöèÿ ãåíåðàòîðà ñëó÷àéíûõ ÷èñåë
|
||||
//#pragma section(".CRT$XCA",long,read,write)
|
||||
//#pragma section(".CRT$XCZ",long,read,write)
|
||||
#pragma data_seg(".CRT$XCA")
|
||||
#pragma data_seg(".CRT$XCZ")
|
||||
typedef void (__cdecl *_PVFV)(void);
|
||||
__declspec(allocate(".CRT$XCA")) _PVFV __xc_a[1] = { NULL };
|
||||
__declspec(allocate(".CRT$XCZ")) _PVFV __xc_z[1] = { NULL };
|
||||
//
|
||||
#pragma comment(linker, "/merge:.CRT=.rdata")
|
||||
//
|
||||
void crtStartUp()
|
||||
{
|
||||
// âûçûâàåì èíèöèàëèçàòîðû ïî ñïèñêó, NULL'û èãíîðèðóåì
|
||||
for ( _PVFV *pbegin = __xc_a; pbegin < __xc_z; pbegin++ )
|
||||
{
|
||||
//
|
||||
if ( *pbegin != NULL )
|
||||
(**pbegin)();
|
||||
}
|
||||
// èíèöèàëèçèðóåì ãåíåðàòîð ñëó÷àéíûõ ÷èñåë
|
||||
rtlSrand( kos_GetSystemClock() );
|
||||
// ïóòü ê ôàéëó ïðîöåññà
|
||||
kosExePath = *((char **)0x20);
|
||||
// âûçîâ ãëàâíîé ôóíêöèè ïðèëîæåíèÿ
|
||||
kos_Main();
|
||||
// âûõîä
|
||||
kos_ExitApp();
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,214 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
typedef unsigned __int32 Dword;
|
||||
typedef unsigned __int16 Word;
|
||||
typedef unsigned __int8 Byte;
|
||||
//typedef unsigned __int32 size_t;
|
||||
|
||||
#define NULL 0
|
||||
|
||||
#define MAX_PATH 256
|
||||
|
||||
#define FO_READ 0
|
||||
#define FO_WRITE 2
|
||||
|
||||
#define EM_WINDOW_REDRAW 1
|
||||
#define EM_KEY_PRESS 2
|
||||
#define EM_BUTTON_CLICK 4
|
||||
#define EM_APP_CLOSE 8
|
||||
#define EM_DRAW_BACKGROUND 16
|
||||
#define EM_MOUSE_EVENT 32
|
||||
#define EM_IPC 64
|
||||
#define EM_NETWORK 256
|
||||
|
||||
#define KM_CHARS 0
|
||||
#define KM_SCANS 1
|
||||
|
||||
#define WRS_BEGIN 1
|
||||
#define WRS_END 2
|
||||
|
||||
#define PROCESS_ID_SELF -1
|
||||
|
||||
#define abs(a) (a<0?0-a:a)
|
||||
|
||||
extern "C" double acos(double x);
|
||||
extern "C" double asin(double x);
|
||||
extern "C" double floor(double x);
|
||||
extern "C" double round(double x);
|
||||
#pragma function(acos,asin)
|
||||
#if _MSC_VER > 1200
|
||||
#pragma function(floor)
|
||||
#endif
|
||||
|
||||
|
||||
struct kosFileInfo
|
||||
{
|
||||
Dword rwMode;
|
||||
Dword OffsetLow;
|
||||
Dword OffsetHigh;
|
||||
Dword dataCount;
|
||||
Byte *bufferPtr;
|
||||
char fileURL[MAX_PATH];
|
||||
};
|
||||
|
||||
|
||||
struct RGB
|
||||
{
|
||||
Byte b;
|
||||
Byte g;
|
||||
Byte r;
|
||||
//
|
||||
RGB() {};
|
||||
//
|
||||
RGB( Dword value )
|
||||
{
|
||||
r = (Byte)(value >> 16);
|
||||
g = (Byte)(value >> 8);
|
||||
b = (Byte)value;
|
||||
};
|
||||
//
|
||||
bool operator != ( RGB &another )
|
||||
{
|
||||
return this->b != another.b || this->g != another.g || this->r != another.r;
|
||||
};
|
||||
//
|
||||
bool operator == ( RGB &another )
|
||||
{
|
||||
return this->b == another.b && this->g == another.g && this->r == another.r;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
union sProcessInfo
|
||||
{
|
||||
Byte rawData[1024];
|
||||
struct
|
||||
{
|
||||
Dword cpu_usage;
|
||||
Word window_stack_position;
|
||||
Word window_stack_value;
|
||||
Word reserved1;
|
||||
char process_name[12];
|
||||
Dword memory_start;
|
||||
Dword used_memory;
|
||||
Dword PID;
|
||||
Dword x_start;
|
||||
Dword y_start;
|
||||
Dword x_size;
|
||||
Dword y_size;
|
||||
Word slot_state;
|
||||
} processInfo;
|
||||
};
|
||||
|
||||
//
|
||||
extern char *kosExePath;
|
||||
|
||||
//
|
||||
void crtStartUp();
|
||||
//
|
||||
int __cdecl _purecall();
|
||||
//
|
||||
int __cdecl atexit( void (__cdecl *func )( void ));
|
||||
//
|
||||
void rtlSrand( Dword seed );
|
||||
Dword rtlRand( void );
|
||||
//
|
||||
char * __cdecl strcpy( char *target, const char *source );
|
||||
int __cdecl strlen( const char *line );
|
||||
char * __cdecl strrchr( const char * string, int c );
|
||||
|
||||
#if _MSC_VER < 1400
|
||||
extern "C" void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount );
|
||||
extern "C" void memset( Byte *dst, Byte filler, Dword count );
|
||||
//#pragma intrinsic(memcpy,memset)
|
||||
#else
|
||||
void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount );
|
||||
void memset( Byte *dst, Byte filler, Dword count );
|
||||
#endif
|
||||
|
||||
void sprintf( char *Str, char* Format, ... );
|
||||
//
|
||||
Dword rtlInterlockedExchange( Dword *target, Dword value );
|
||||
// ôóíêöèÿ -1 çàâåðøåíèÿ ïðîöåññà
|
||||
void kos_ExitApp();
|
||||
// ôóíêöèÿ 0
|
||||
void kos_DefineAndDrawWindow(
|
||||
Word x, Word y,
|
||||
Word sizeX, Word sizeY,
|
||||
Byte mainAreaType, Dword mainAreaColour,
|
||||
Byte headerType, Dword headerColour,
|
||||
Dword borderColour
|
||||
);
|
||||
// ôóíêöèÿ 1 ïîñòàâèòü òî÷êó
|
||||
void kos_PutPixel( Dword x, Dword y, Dword colour );
|
||||
// ôóíêöèÿ 2 ïîëó÷èòü êîä íàæàòîé êëàâèøè
|
||||
bool kos_GetKey( Byte &keyCode );
|
||||
// ôóíêöèÿ 3 ïîëó÷èòü âðåìÿ
|
||||
Dword kos_GetSystemClock();
|
||||
// ôóíêöèÿ 4
|
||||
void kos_WriteTextToWindow(
|
||||
Word x, Word y,
|
||||
Byte fontType,
|
||||
Dword textColour,
|
||||
char *textPtr,
|
||||
Dword textLen
|
||||
);
|
||||
// ôóíêöèÿ 7 íàðèñîâàòü èçîáðàæåíèå
|
||||
void kos_PutImage( RGB * imagePtr, Word sizeX, Word sizeY, Word x, Word y );
|
||||
// ôóíêöèÿ 8 îïðåäåëèòü êíîïêó
|
||||
void kos_DefineButton( Word x, Word y, Word sizeX, Word sizeY, Dword buttonID, Dword colour );
|
||||
// ôóíêöèÿ 5 ïàóçà, â ñîòûõ äîëÿõ ñåêóíäû
|
||||
void kos_Pause( Dword value );
|
||||
// ôóíêöèÿ 9 - èíôîðìàöèÿ î ïðîöåññå
|
||||
Dword kos_ProcessInfo( sProcessInfo *targetPtr, Dword processID = PROCESS_ID_SELF );
|
||||
// ôóíêöèÿ 10
|
||||
Dword kos_WaitForEvent();
|
||||
// ôóíêöèÿ 11
|
||||
Dword kos_CheckForEvent();
|
||||
// ôóíêöèÿ 12
|
||||
void kos_WindowRedrawStatus( Dword status );
|
||||
// ôóíêöèÿ 13 íàðèñîâàòü ïîëîñó
|
||||
void kos_DrawBar( Word x, Word y, Word sizeX, Word sizeY, Dword colour );
|
||||
// ôóíêöèÿ 17
|
||||
bool kos_GetButtonID( Dword &buttonID );
|
||||
// ôóíêöèÿ 23
|
||||
Dword kos_WaitForEvent( Dword timeOut );
|
||||
//
|
||||
enum eNumberBase
|
||||
{
|
||||
nbDecimal = 0,
|
||||
nbHex,
|
||||
nbBin
|
||||
};
|
||||
// ïîëó÷åíèå èíôîðìàöèè î ñîñòîÿíèè "ìûøè" ôóíêöèÿ 37
|
||||
void kos_GetMouseState( Dword & buttons, int & cursorX, int & cursorY );
|
||||
// ôóíêöèÿ 40 óñòàíîâèòü ìàñêó ñîáûòèé
|
||||
void kos_SetMaskForEvents( Dword mask );
|
||||
// ôóíêöèÿ 47 âûâåñòè â îêíî ïðèëîæåíèÿ ÷èñëî
|
||||
void kos_DisplayNumberToWindow(
|
||||
Dword value,
|
||||
Dword digitsNum,
|
||||
Word x,
|
||||
Word y,
|
||||
Dword colour,
|
||||
eNumberBase nBase = nbDecimal,
|
||||
bool valueIsPointer = false
|
||||
);
|
||||
// ôóíêöèÿ 58 äîñòóï ê ôàéëîâîé ñèñòåìå
|
||||
Dword kos_FileSystemAccess( kosFileInfo *fileInfo );
|
||||
// ôóíêöèÿ 63
|
||||
void kos_DebugOutChar( char ccc );
|
||||
//
|
||||
void rtlDebugOutString( char *str );
|
||||
// ôóíêöèÿ 64 èçìåíèòü ïàðàìåòðû îêíà, ïàðàìåòð == -1 íå ìåíÿåòñÿ
|
||||
void kos_ChangeWindow( Dword x, Dword y, Dword sizeX, Dword sizeY );
|
||||
// ôóíêöèÿ 67 èçìåíåíèå êîëè÷åñòâà ïàìÿòè, âûäåëåííîé äëÿ ïðîãðàììû
|
||||
bool kos_ApplicationMemoryResize( Dword targetSize );
|
||||
// ôóíêöèÿ 66 ðåæèì ïîëó÷åíèÿ äàííûõ îò êëàâèàòóðû
|
||||
void kos_SetKeyboardDataMode( Dword mode );
|
||||
|
||||
void kos_InitHeap();
|
||||
|
||||
//
|
||||
void kos_Main();
|
|
@ -0,0 +1,83 @@
|
|||
#include <math.h>
|
||||
#include "kosSyst.h"
|
||||
extern "C" int _fltused = 0;
|
||||
double acos(double x)
|
||||
{
|
||||
__asm {
|
||||
fld qword ptr [esp+4]
|
||||
fld1
|
||||
fadd st, st(1)
|
||||
fld1
|
||||
fsub st, st(2)
|
||||
fmulp st(1), st
|
||||
fsqrt
|
||||
fxch st(1)
|
||||
fpatan
|
||||
}
|
||||
}
|
||||
double asin(double x)
|
||||
{
|
||||
__asm {
|
||||
fld qword ptr [esp+4]
|
||||
fld1
|
||||
fadd st, st(1)
|
||||
fld1
|
||||
fsub st, st(2)
|
||||
fmulp st(1), st
|
||||
fsqrt
|
||||
fpatan
|
||||
ret
|
||||
}
|
||||
}
|
||||
#if _MSC_VER <= 1200
|
||||
extern "C" double _ftol(double x)
|
||||
{
|
||||
__asm {
|
||||
fld qword ptr [esp+4]
|
||||
push 1F3Fh
|
||||
fstcw word ptr [esp+2]
|
||||
fldcw word ptr [esp]
|
||||
frndint
|
||||
fldcw word ptr [esp+2]
|
||||
add esp, 4
|
||||
}
|
||||
}
|
||||
#endif
|
||||
double ceil(double x)
|
||||
{
|
||||
__asm {
|
||||
fld qword ptr [esp+4]
|
||||
push 1B3Fh
|
||||
fstcw word ptr [esp+2]
|
||||
fldcw word ptr [esp]
|
||||
frndint
|
||||
fldcw word ptr [esp+2]
|
||||
add esp, 4
|
||||
}
|
||||
}
|
||||
|
||||
double floor(double x)
|
||||
{
|
||||
__asm {
|
||||
fld qword ptr [esp+4]
|
||||
push 173Fh
|
||||
fstcw word ptr [esp+2]
|
||||
fldcw word ptr [esp]
|
||||
frndint
|
||||
fldcw word ptr [esp+2]
|
||||
add esp, 4
|
||||
}
|
||||
}
|
||||
|
||||
double round(double x)
|
||||
{
|
||||
__asm {
|
||||
fld qword ptr [esp+4]
|
||||
push 133Fh
|
||||
fstcw word ptr [esp+2]
|
||||
fldcw word ptr [esp]
|
||||
frndint
|
||||
fldcw word ptr [esp+2]
|
||||
add esp, 4
|
||||
}
|
||||
}
|
|
@ -0,0 +1,354 @@
|
|||
// memman.cpp : Defines the entry point for the console application.
|
||||
//
|
||||
|
||||
#include "kosSyst.h"
|
||||
#include "mcsmemm.h"
|
||||
|
||||
|
||||
void * __cdecl operator new ( size_t count, size_t element_size )
|
||||
{
|
||||
return allocmem( (Dword)(count * element_size) );
|
||||
}
|
||||
|
||||
void * __cdecl operator new [] ( size_t amount )
|
||||
{
|
||||
return allocmem( (Dword)amount );
|
||||
}
|
||||
|
||||
void * __cdecl operator new ( size_t amount )
|
||||
{
|
||||
return allocmem( (Dword)amount );
|
||||
}
|
||||
|
||||
void __cdecl operator delete ( void *pointer )
|
||||
{
|
||||
if ( pointer != NULL ) freemem( pointer );
|
||||
}
|
||||
|
||||
void __cdecl operator delete [] ( void *pointer )
|
||||
{
|
||||
if ( pointer != NULL ) freemem( pointer );
|
||||
}
|
||||
|
||||
Byte *allocmem( Dword reqsize )
|
||||
{
|
||||
__asm
|
||||
{
|
||||
mov eax, 68
|
||||
mov ebx, 12
|
||||
mov ecx, reqsize
|
||||
int 0x40
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Dword freemem( void *vaddress )
|
||||
{
|
||||
__asm
|
||||
{
|
||||
mov eax, 68
|
||||
mov ebx, 13
|
||||
mov ecx, vaddress
|
||||
int 0x40
|
||||
}
|
||||
|
||||
}
|
||||
/*
|
||||
|
||||
//
|
||||
Dword mmMutex = FALSE;
|
||||
MemBlock *rootfree = NULL;
|
||||
MemBlock *rootuser = NULL;
|
||||
bool mmInitialized = false;
|
||||
Byte *mmHeapTop = NULL;
|
||||
|
||||
|
||||
//
|
||||
Byte * AllocMemFromSystem( Dword reqSize )
|
||||
{
|
||||
Byte *result;
|
||||
sProcessInfo pInfo;
|
||||
|
||||
//
|
||||
if ( mmInitialized )
|
||||
{
|
||||
result = mmHeapTop;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
kos_ProcessInfo( &pInfo );
|
||||
//
|
||||
result = (Byte *)(pInfo.processInfo.used_memory + 1);
|
||||
//
|
||||
mmInitialized = true;
|
||||
}
|
||||
//
|
||||
if ( ! kos_ApplicationMemoryResize( ((Dword)result) + reqSize ) )
|
||||
{
|
||||
result = NULL;
|
||||
}
|
||||
//
|
||||
mmHeapTop = result + reqSize;
|
||||
//
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
Byte *allocmem( Dword reqsize )
|
||||
{
|
||||
MemBlock *BlockForCheck;
|
||||
MemBlock *LastKnownGood;
|
||||
Dword tail;
|
||||
Byte *address;
|
||||
|
||||
//ïîäðîâíÿåì ðàçìåð
|
||||
if( ( tail = reqsize % SIZE_ALIGN ) != 0 )
|
||||
{
|
||||
reqsize += SIZE_ALIGN - tail;
|
||||
}
|
||||
|
||||
LastKnownGood = NULL;
|
||||
|
||||
// æä¸ì îñâîáîæäåíèÿ ìüþòåêñà
|
||||
while ( rtlInterlockedExchange( &mmMutex, TRUE ) )
|
||||
{
|
||||
//
|
||||
kos_Pause( 1 );
|
||||
}
|
||||
|
||||
//èùåì ïîäõîäÿùèé ñâîáîäíûé áëîê
|
||||
if( rootfree != NULL )
|
||||
{
|
||||
for ( BlockForCheck = rootfree; ; BlockForCheck = BlockForCheck->Next )
|
||||
{
|
||||
if ( BlockForCheck->Size >= reqsize )
|
||||
{
|
||||
//íàøëè
|
||||
if ( LastKnownGood != NULL )
|
||||
{
|
||||
if ( LastKnownGood->Size >= BlockForCheck->Size )
|
||||
LastKnownGood = BlockForCheck;
|
||||
}
|
||||
else
|
||||
LastKnownGood = BlockForCheck;
|
||||
if ( LastKnownGood->Size == reqsize )
|
||||
break;
|
||||
}
|
||||
if ( BlockForCheck->Next == NULL )
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ( LastKnownGood != NULL )
|
||||
{
|
||||
//ïðîâåðèì íàéäåííûé áëîê íà âîçìîæíîñòü äåëåíèÿ
|
||||
tail = LastKnownGood->Size - reqsize;
|
||||
if ( tail >= ( sizeof(MemBlock) + SIZE_ALIGN ) )
|
||||
{
|
||||
//áóäåì ðàçáèâàòü
|
||||
BlockForCheck = (MemBlock *)( ( (Byte *)LastKnownGood ) + tail );
|
||||
BlockForCheck->Size = reqsize;
|
||||
//âñòàâèì çàíÿòûé áëîê â íà÷àëî ñïèñêà çàíàòûõ áëîêîâ
|
||||
if( rootuser != NULL )
|
||||
{
|
||||
BlockForCheck->Next = rootuser;
|
||||
rootuser->Previous = BlockForCheck;
|
||||
BlockForCheck->Previous = NULL;
|
||||
rootuser = BlockForCheck;
|
||||
}
|
||||
else
|
||||
{
|
||||
rootuser = BlockForCheck;
|
||||
BlockForCheck->Next = NULL;
|
||||
BlockForCheck->Previous = NULL;
|
||||
}
|
||||
|
||||
//èçìåíèì ðàçìåð îñòàâøåéñÿ ÷àñòè
|
||||
LastKnownGood->Size = tail - sizeof(MemBlock);
|
||||
address = ( (Byte *)BlockForCheck ) + sizeof(MemBlock);
|
||||
|
||||
// îòïóñòèì ìüþòåêñ
|
||||
rtlInterlockedExchange( &mmMutex, FALSE );
|
||||
|
||||
return address;
|
||||
}
|
||||
else
|
||||
{
|
||||
//ïåðåìåñòè áëîê èç î÷åðåäè ñâîáîäíûõ â íà÷àëî î÷åðåäè çàíÿòûõ
|
||||
//ñíà÷àëà âûêèíåì åãî èç î÷åðåäè ñâîáîäíûõ
|
||||
if ( LastKnownGood->Previous != NULL )
|
||||
{
|
||||
LastKnownGood->Previous->Next = LastKnownGood->Next;
|
||||
}
|
||||
else
|
||||
{
|
||||
//áëîê ñòîèò â íà÷àëå î÷åðåäè
|
||||
rootfree = LastKnownGood->Next;
|
||||
}
|
||||
if( LastKnownGood->Next != NULL )
|
||||
{
|
||||
LastKnownGood->Next->Previous = LastKnownGood->Previous;
|
||||
}
|
||||
//òåïåðü âñòàâèì åãî â î÷åðåäü çàíÿòûõ
|
||||
if( rootuser != NULL )
|
||||
{
|
||||
LastKnownGood->Next = rootuser;
|
||||
rootuser->Previous = LastKnownGood;
|
||||
LastKnownGood->Previous = NULL;
|
||||
rootuser = LastKnownGood;
|
||||
}
|
||||
else
|
||||
{
|
||||
rootuser = LastKnownGood;
|
||||
LastKnownGood->Next = NULL;
|
||||
LastKnownGood->Previous = NULL;
|
||||
}
|
||||
//
|
||||
address = ( (Byte *)LastKnownGood ) + sizeof(MemBlock);
|
||||
|
||||
// îòïóñòèì ìüþòåêñ
|
||||
rtlInterlockedExchange( &mmMutex, FALSE );
|
||||
|
||||
return address;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//íàäî ïîëó÷èòü åù¸ êóñî÷åê ïàìÿòè
|
||||
LastKnownGood = (MemBlock *)AllocMemFromSystem( reqsize + sizeof(MemBlock) );
|
||||
//
|
||||
if( LastKnownGood != NULL )
|
||||
{
|
||||
LastKnownGood->Size = reqsize;
|
||||
//òåïåðü âñòàâèì åãî â î÷åðåäü çàíÿòûõ
|
||||
if( rootuser != NULL )
|
||||
{
|
||||
LastKnownGood->Next = rootuser;
|
||||
rootuser->Previous = LastKnownGood;
|
||||
LastKnownGood->Previous = NULL;
|
||||
rootuser = LastKnownGood;
|
||||
}
|
||||
else
|
||||
{
|
||||
rootuser = LastKnownGood;
|
||||
LastKnownGood->Next = NULL;
|
||||
LastKnownGood->Previous = NULL;
|
||||
}
|
||||
address = ( (Byte *)LastKnownGood ) + sizeof(MemBlock);
|
||||
|
||||
// îòïóñòèì ìüþòåêñ
|
||||
rtlInterlockedExchange( &mmMutex, FALSE );
|
||||
|
||||
return address;
|
||||
}
|
||||
}
|
||||
|
||||
// îòïóñòèì ìüþòåêñ
|
||||
rtlInterlockedExchange( &mmMutex, FALSE );
|
||||
|
||||
//
|
||||
rtlDebugOutString( "allocmem failed." );
|
||||
kos_ExitApp();
|
||||
//
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//
|
||||
Dword freemem( void *vaddress )
|
||||
{
|
||||
Dword result;
|
||||
|
||||
Byte *checknext, *address = (Byte *)vaddress;
|
||||
|
||||
// æä¸ì îñâîáîæäåíèÿ ìüþòåêñà
|
||||
while ( rtlInterlockedExchange( &mmMutex, TRUE ) )
|
||||
{
|
||||
//
|
||||
kos_Pause( 1 );
|
||||
}
|
||||
|
||||
MemBlock *released = (MemBlock *)( address - sizeof(MemBlock) );
|
||||
|
||||
result = released->Size;
|
||||
|
||||
//óáèðàåì áëîê èç ñïèñêà çàíÿòûõ
|
||||
if ( released->Previous != NULL )
|
||||
{
|
||||
released->Previous->Next = released->Next;
|
||||
}
|
||||
else
|
||||
{
|
||||
rootuser = released->Next;
|
||||
}
|
||||
if ( released->Next != NULL )
|
||||
{
|
||||
released->Next->Previous = released->Previous;
|
||||
}
|
||||
//çàêèíåì òåïåðü ýòîò áëîê â ñïèñîê ñâîáîäíûõ
|
||||
released->Next = rootfree;
|
||||
released->Previous = NULL;
|
||||
rootfree = released;
|
||||
if ( released->Next != NULL )
|
||||
{
|
||||
released->Next->Previous = released;
|
||||
}
|
||||
|
||||
//òåïåðü ïîèùåì ñìåæíûå ñâîáîäíûå áëîêè
|
||||
checknext = (Byte *)(rootfree) + ( rootfree->Size + sizeof(MemBlock) );
|
||||
//
|
||||
for ( released = rootfree->Next; released != NULL; released = released->Next )
|
||||
{
|
||||
if ( checknext == (Byte *)released )
|
||||
{
|
||||
//ñîáèðàåì áëîêè âìåñòå
|
||||
//ñíà÷àëà âûêèíåì èç î÷åðåäè ñâîáîäíûõ
|
||||
released->Previous->Next = released->Next;
|
||||
if( released->Next != NULL )
|
||||
{
|
||||
released->Next->Previous = released->Previous;
|
||||
}
|
||||
//òåïåðü óâåëè÷èì ðàçìåð êîðíåâîãî áëîêà
|
||||
rootfree->Size += released->Size + sizeof(MemBlock);
|
||||
break;
|
||||
}
|
||||
}
|
||||
//åñëè íàäî, ïîèùåì áëîêè ïåðåä òåêùèì.
|
||||
checknext = (Byte *)(rootfree);
|
||||
//
|
||||
if ( released == NULL )
|
||||
{
|
||||
for ( released = rootfree->Next; released != NULL; released = released->Next )
|
||||
{
|
||||
if ( checknext == (Byte *)released + ( released->Size + sizeof(MemBlock) ) )
|
||||
{
|
||||
//ñîáèðàåì áëîêè âìåñòå
|
||||
//óâåëè÷èì ðàçìåð áëîêà
|
||||
released->Size += rootfree->Size + sizeof(MemBlock);
|
||||
//òåïåðü âûêèíåì èç î÷åðåäè ñâîáîäíûõ
|
||||
released->Previous->Next = released->Next;
|
||||
if ( released->Next != NULL )
|
||||
{
|
||||
released->Next->Previous = released->Previous;
|
||||
}
|
||||
//è çàêèíåì åãî â íà÷àëî î÷åðåäè âìåñòî ïðèñîåäèí¸ííîãî áëîêà èç êîðíÿ ñïèñêà
|
||||
if ( rootfree->Next != NULL )
|
||||
{
|
||||
rootfree->Next->Previous = released;
|
||||
}
|
||||
released->Next = rootfree->Next;
|
||||
released->Previous = NULL;
|
||||
rootfree = released;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// îòïóñòèì ìüþòåêñ
|
||||
rtlInterlockedExchange( &mmMutex, FALSE );
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
*/
|
|
@ -0,0 +1,95 @@
|
|||
/* Rocket Forces
|
||||
* Filename: mymath.h
|
||||
* Version 0.1
|
||||
* Copyright (c) Serial 2007
|
||||
*/
|
||||
|
||||
|
||||
extern "C" int _fltused = 0;
|
||||
|
||||
#define M_PI 3.14159265358979323846
|
||||
|
||||
inline double sin(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fsin
|
||||
}
|
||||
|
||||
inline double cos(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fcos
|
||||
}
|
||||
|
||||
inline double sqrt(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fsqrt
|
||||
}
|
||||
|
||||
inline double acos(double x)
|
||||
{
|
||||
__asm fld x
|
||||
__asm fld st(0)
|
||||
__asm fmul st,st(1)
|
||||
__asm fld1
|
||||
__asm fsubrp st(1),st(0)
|
||||
__asm fsqrt
|
||||
__asm fxch st(1)
|
||||
__asm fpatan
|
||||
}
|
||||
|
||||
inline double atan(double x)
|
||||
{
|
||||
double res = acos(1 / sqrt(1 + x * x));
|
||||
if (x < 0)
|
||||
{
|
||||
res *= -1;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
inline int round_int(double x)
|
||||
{
|
||||
int i;
|
||||
static const float round_to_nearest = 0.5f;
|
||||
__asm
|
||||
{
|
||||
fld x
|
||||
fadd st, st(0)
|
||||
fadd round_to_nearest
|
||||
fistp i
|
||||
sar i, 1
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
inline int floor_int(double x)
|
||||
{
|
||||
int i;
|
||||
static const float round_toward_m_i = -0.5f;
|
||||
__asm
|
||||
{
|
||||
fld x
|
||||
fadd st, st (0)
|
||||
fadd round_toward_m_i
|
||||
fistp i
|
||||
sar i, 1
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
inline int ceil_int(double x)
|
||||
{
|
||||
int i;
|
||||
static const float round_toward_p_i = -0.5f;
|
||||
__asm
|
||||
{
|
||||
fld x
|
||||
fadd st, st (0)
|
||||
fsubr round_toward_p_i
|
||||
fistp i
|
||||
sar i, 1
|
||||
}
|
||||
return (-i);
|
||||
}
|
|
@ -0,0 +1,925 @@
|
|||
|
||||
|
||||
#include "func.h"
|
||||
#include "parser.h"
|
||||
//#include <math.h>
|
||||
//#include <stdlib.h>
|
||||
//#include <stdio.h>
|
||||
|
||||
// token types
|
||||
#define DELIMITER 1
|
||||
#define VARIABLE 2
|
||||
#define NUMBER 3
|
||||
#define FUNCTION 4
|
||||
#define FINISHED 10
|
||||
|
||||
//#define allocmem(x) malloc(x)
|
||||
//#define freemem(x) free(x)
|
||||
|
||||
double epsilon = 1e-6;
|
||||
|
||||
// structure for most parser functions
|
||||
|
||||
char token[80];
|
||||
int token_type;
|
||||
char *prog;
|
||||
|
||||
int code; // error code
|
||||
|
||||
|
||||
variable_callback *find_var;
|
||||
|
||||
struct double_list
|
||||
{
|
||||
double val;
|
||||
int code; // êîä îøèáêè
|
||||
double_list *next;
|
||||
};
|
||||
|
||||
double tg(double d)
|
||||
{
|
||||
double cosd = cos(d);
|
||||
if (fabs(cosd) < epsilon)
|
||||
{
|
||||
serror(ERR_OVERFLOW);
|
||||
return 0.0;
|
||||
}
|
||||
return sin(d) / cosd;
|
||||
}
|
||||
|
||||
double ctg(double d)
|
||||
{
|
||||
double sind = sin(d);
|
||||
if (fabs(sind) < epsilon)
|
||||
{
|
||||
serror(ERR_OVERFLOW);
|
||||
return 0.0;
|
||||
}
|
||||
return cos(d) / sind;
|
||||
}
|
||||
|
||||
double exp(double x)
|
||||
{
|
||||
__asm {
|
||||
fld x
|
||||
FLDL2E
|
||||
FMUL
|
||||
|
||||
FLD st(0)
|
||||
|
||||
FLD1
|
||||
|
||||
FXCH
|
||||
FPREM
|
||||
F2XM1
|
||||
fadd
|
||||
FSCALE
|
||||
FSTP st(1)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
double log(double x)
|
||||
{
|
||||
//return 0.0;
|
||||
if (x <= 0)
|
||||
{
|
||||
serror(ERR_OVERFLOW);
|
||||
//return 0.0;
|
||||
__asm {
|
||||
fldz
|
||||
}
|
||||
}
|
||||
__asm {
|
||||
FLD1
|
||||
FLD x
|
||||
FYL2X
|
||||
FLDLN2
|
||||
FMUL
|
||||
}
|
||||
}
|
||||
|
||||
double sqrt(double x)
|
||||
{
|
||||
if (x < 0)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
__asm {
|
||||
fldz
|
||||
}
|
||||
}
|
||||
__asm {
|
||||
fld x
|
||||
fsqrt
|
||||
}
|
||||
}
|
||||
|
||||
double atan(double x)
|
||||
{
|
||||
serror(ERR_GENERAL);
|
||||
return 0.0; // â ëîì
|
||||
}
|
||||
|
||||
double pow(double x, double y)
|
||||
{
|
||||
return exp(y * log(x)); //
|
||||
}
|
||||
|
||||
double func_pi()
|
||||
{
|
||||
return 3.14159265358979;
|
||||
}
|
||||
|
||||
double func_eps()
|
||||
{
|
||||
return epsilon;
|
||||
}
|
||||
|
||||
double func_if(double_list *p)
|
||||
{
|
||||
double_list *a, *b, *c;
|
||||
a = p;
|
||||
b = a->next;
|
||||
if (!b)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
return 0.0;
|
||||
}
|
||||
c = b->next;
|
||||
if (!c || c->next)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
return 0.0;
|
||||
}
|
||||
if (a->val != 0.0)
|
||||
{
|
||||
if (b->code)
|
||||
code = b->code;
|
||||
return b->val;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (c->code)
|
||||
code = c->code;
|
||||
return c->val;
|
||||
}
|
||||
}
|
||||
|
||||
double sum(double_list *p)
|
||||
{
|
||||
double res = 0.0;
|
||||
while (p)
|
||||
{
|
||||
res += p->val;
|
||||
if (p->code)
|
||||
code = p->code;
|
||||
p = p->next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
double func_min(double_list *p)
|
||||
{
|
||||
if (!p)
|
||||
serror(ERR_BADPARAM);
|
||||
double res = p->val;
|
||||
p = p->next;
|
||||
while (p)
|
||||
{
|
||||
if (p->code)
|
||||
code = p->code;
|
||||
if (p->val < res)
|
||||
res = p->val;
|
||||
p = p->next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
double func_max(double_list *p)
|
||||
{
|
||||
if (!p)
|
||||
serror(ERR_BADPARAM);
|
||||
double res = p->val;
|
||||
p = p->next;
|
||||
while (p)
|
||||
{
|
||||
if (p->code)
|
||||
code = p->code;
|
||||
if (p->val > res)
|
||||
res = p->val;
|
||||
p = p->next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
double avg(double_list *p)
|
||||
{
|
||||
double res = 0.0;
|
||||
int count = 0;
|
||||
while (p)
|
||||
{
|
||||
if (p->code)
|
||||
code = p->code;
|
||||
res += p->val;
|
||||
count++;
|
||||
p = p->next;
|
||||
}
|
||||
return res / count;
|
||||
}
|
||||
|
||||
double func_isnull(char *str)
|
||||
{
|
||||
if (code != 0)
|
||||
return 0.0;
|
||||
double tmp = find_var(str);
|
||||
int c = code;
|
||||
code = 0;
|
||||
if (c != 0)
|
||||
return 1.0;
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
const double HALF = 0.5;
|
||||
double func_ceil(double val) // õîòåë round, à ïîëó÷èëñÿ ceil...
|
||||
{
|
||||
int x;
|
||||
__asm fld val
|
||||
__asm fld HALF // äà, êðèâîðóêî ^_^
|
||||
__asm fadd
|
||||
__asm fistp x
|
||||
__asm fild x
|
||||
}
|
||||
|
||||
double func_round(double val)
|
||||
{
|
||||
int x;
|
||||
__asm fld val
|
||||
__asm fld epsilon
|
||||
__asm fadd
|
||||
__asm fistp x
|
||||
__asm fild x
|
||||
}
|
||||
|
||||
const double ALMOST_HALF = 0.5 - epsilon;
|
||||
double func_floor(double val)
|
||||
{
|
||||
int x;
|
||||
__asm fld val
|
||||
__asm fld ALMOST_HALF
|
||||
__asm fsub
|
||||
__asm fistp x
|
||||
__asm fild x
|
||||
}
|
||||
|
||||
double logic_xor(double a, double b)
|
||||
{
|
||||
if (a == 0.0)
|
||||
if (b == 0.0)
|
||||
return 0.0;
|
||||
else
|
||||
return 1.0;
|
||||
else
|
||||
if (b == 0.0)
|
||||
return 1.0;
|
||||
else
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
double logic_and(double a, double b)
|
||||
{
|
||||
if (a == 0.0)
|
||||
return 0.0;
|
||||
else
|
||||
if (b == 0.0)
|
||||
return 0.0;
|
||||
else
|
||||
return 1.0;
|
||||
}
|
||||
|
||||
double logic_or(double a, double b)
|
||||
{
|
||||
if (a == 0.0)
|
||||
if (b == 0.0)
|
||||
return 0.0;
|
||||
else
|
||||
return 1.1;
|
||||
else
|
||||
return 1.0;
|
||||
}
|
||||
|
||||
double rand_seed;
|
||||
double func_rand(double max)
|
||||
{
|
||||
double q = (257.0 * rand_seed + 739.0); // ÷èñëà îò áàëäû. íàäî âñòàâèòü ïðàâèëüíûå.
|
||||
rand_seed = q - 65536.0 * func_floor(q / 65536.0); // äëÿ õîðîøåãî ðàñïðåäåëåíèÿ
|
||||
return q - max * func_floor(q / max); // äëÿ ìîäóëÿ
|
||||
}
|
||||
|
||||
double func_case(double_list *p)
|
||||
{
|
||||
if (!p || !p->next)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
return 0.0;
|
||||
}
|
||||
double x = p->val;
|
||||
int count = (int)p->next->val;
|
||||
int i, k;
|
||||
|
||||
double_list *cur = p->next->next;
|
||||
k = count;
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
if (!cur)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
return 0.0;
|
||||
}
|
||||
if (fabs(x - cur->val) < epsilon)
|
||||
{
|
||||
if (k != count + 1)
|
||||
{
|
||||
serror(ERR_GENERAL);
|
||||
return 0.0;
|
||||
}
|
||||
k = i;
|
||||
}
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
for (i = 0; i < k; i++)
|
||||
{
|
||||
if (!cur)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
return 0.0;
|
||||
}
|
||||
cur = cur->next;
|
||||
}
|
||||
if (!cur) // ïðîâåðêè áèï. äîñòàëè áèï.
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
return 0.0;
|
||||
}
|
||||
if (cur->code)
|
||||
code = cur->code;
|
||||
return cur->val;
|
||||
}
|
||||
|
||||
#define INF_ARGS -1
|
||||
#define STR_ARG -2
|
||||
|
||||
// represents general mathematical function
|
||||
typedef double(*matfunc0)();
|
||||
typedef double(*matfunc)(double);
|
||||
typedef double(*matfunc2)(double,double);
|
||||
typedef double(*matfunc3)(double,double,double);
|
||||
typedef double(*matfunc_inf)(double_list*);
|
||||
typedef double(*matfunc_str)(char*);
|
||||
|
||||
// used to link function name to the function
|
||||
typedef struct
|
||||
{
|
||||
char name[10];
|
||||
int args;
|
||||
void * f;
|
||||
} func;
|
||||
|
||||
// the list of functions
|
||||
const int max_func = 29;
|
||||
func functions[max_func] =
|
||||
{
|
||||
"", 1, NULL, // íå ïîìíþ, ñ êàêîé öåëüþ
|
||||
"sin", 1, &sin,
|
||||
"cos", 1, &cos,
|
||||
"exp", 1, &exp,
|
||||
"sqrt", 1, &sqrt,
|
||||
"log", 1, &log,
|
||||
"tg", 1, &tg,
|
||||
"ctg", 1, &ctg,
|
||||
"arcsin", 1, &asin,
|
||||
"arccos", 1, &acos,
|
||||
"arctg", 1, &atan, // íå ðåàëèçîâàíî. âîçâðàùàåò îøèáêó ERR_GENERAL
|
||||
"abs", 1, &fabs,
|
||||
"pow", 2, &pow,
|
||||
"if", INF_ARGS, &func_if,
|
||||
"sum",INF_ARGS,&sum,
|
||||
"isnull",STR_ARG,&func_isnull, // ñëåãêà ÷/æ
|
||||
"min",INF_ARGS,&func_min,
|
||||
"max",INF_ARGS,&func_max,
|
||||
"avg",INF_ARGS,&avg,
|
||||
"ceil",1,&func_ceil,
|
||||
"round",1,&func_round,
|
||||
"floor",1,&func_floor,
|
||||
"and",2,&logic_and,
|
||||
"or",2,&logic_or,
|
||||
"xor",2,&logic_xor,
|
||||
"rand",1,&func_rand,
|
||||
"case",INF_ARGS,&func_case,
|
||||
"pi",0,&func_pi,
|
||||
"eps",0,&func_eps
|
||||
};
|
||||
|
||||
// all delimiters
|
||||
#define MAXDELIM 17
|
||||
const char delim[MAXDELIM]="+-*^/%=;(),><#! "; // not bad words
|
||||
|
||||
|
||||
int isdelim(char c)
|
||||
{
|
||||
//return strchr(delim, c) != 0;
|
||||
for (int i = 0; i < MAXDELIM; i++)
|
||||
if (c == delim[i])
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int isdigit(char c)
|
||||
{
|
||||
return (c >= '0' && c <= '9');
|
||||
}
|
||||
|
||||
int isalpha2(char c)
|
||||
{
|
||||
return ((c >= 'a' && c <= 'z')
|
||||
|| (c >= 'A' && c <= 'Z') || (c=='$'));
|
||||
}
|
||||
|
||||
int iswhite(char c)
|
||||
{
|
||||
return (c==' ' || c=='\t');
|
||||
}
|
||||
|
||||
|
||||
void serror(int acode)
|
||||
{
|
||||
if (acode != 0)
|
||||
code = acode;
|
||||
}
|
||||
|
||||
void set_exp(char *exp)
|
||||
{
|
||||
prog = exp;
|
||||
}
|
||||
|
||||
int get_token()
|
||||
{
|
||||
int tok;
|
||||
char *temp;
|
||||
(token_type) = 0;
|
||||
tok = 0;
|
||||
temp = (token);
|
||||
|
||||
if (*(prog) == '\0')
|
||||
{
|
||||
*(token) = 0;
|
||||
tok = FINISHED;
|
||||
return ((token_type) = DELIMITER);
|
||||
}
|
||||
while (iswhite(*(prog))) ++(prog);
|
||||
if (isdelim(*(prog)))
|
||||
{
|
||||
char t=*temp = *(prog);
|
||||
(prog)++;
|
||||
temp++;
|
||||
if ((t == '>' || t == '<' || t == '!') && (*prog) && (*prog == '='))
|
||||
{
|
||||
*temp = *(prog);
|
||||
(prog)++;
|
||||
temp++;
|
||||
}
|
||||
*temp = 0;
|
||||
return ((token_type) = DELIMITER);
|
||||
}
|
||||
if (isdigit(*(prog)))
|
||||
{
|
||||
while (!isdelim(*(prog)))
|
||||
*temp++=*(prog)++;
|
||||
*temp = '\0';
|
||||
return ((token_type) = NUMBER);
|
||||
}
|
||||
if (isalpha2(*(prog)))
|
||||
{
|
||||
while (!isdelim(*(prog)))
|
||||
*temp++=*(prog)++;
|
||||
(token_type) = VARIABLE;
|
||||
}
|
||||
*temp = '\0';
|
||||
if ((token_type) == VARIABLE)
|
||||
{
|
||||
tok = look_up((token));
|
||||
if (tok)
|
||||
(token_type) = FUNCTION;
|
||||
}
|
||||
return (token_type);
|
||||
}
|
||||
|
||||
double sign(double d)
|
||||
{
|
||||
if (d > 0.0)
|
||||
return 1.0;
|
||||
if (d < 0.0)
|
||||
return -1.0;
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
void putback()
|
||||
{
|
||||
char *t;
|
||||
t = (token);
|
||||
for (;*t;t++)
|
||||
(prog)--;
|
||||
}
|
||||
|
||||
int get_exp(double *hold)
|
||||
{
|
||||
code = 0;
|
||||
|
||||
get_token();
|
||||
if (!*(token))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
level1( hold);
|
||||
putback();
|
||||
return code==0;
|
||||
}
|
||||
|
||||
void level1(double *hold)
|
||||
{
|
||||
char op[2];
|
||||
double h;
|
||||
|
||||
level1_5( hold);
|
||||
while (op[0] = *token, op[1] = (*(token+1)) ? *(token + 1) : 0,
|
||||
*op == '<' || *op == '>' || *op == '=' || *op == '#' || *op == '!')
|
||||
{
|
||||
get_token();
|
||||
level1_5( &h);
|
||||
logic(op, hold, &h);
|
||||
}
|
||||
}
|
||||
|
||||
void level1_5(double *hold)
|
||||
{
|
||||
char op;
|
||||
|
||||
op = 0;
|
||||
if (((token_type) == DELIMITER) && *(token) == '!')
|
||||
{
|
||||
op = *(token);
|
||||
get_token();
|
||||
}
|
||||
level2( hold);
|
||||
|
||||
if (op)
|
||||
{
|
||||
if (*hold == 0.0)
|
||||
*hold = 1.0;
|
||||
else
|
||||
*hold = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
void level2(double *hold)
|
||||
{
|
||||
char op;
|
||||
double h;
|
||||
|
||||
level3( hold);
|
||||
while ((op=*(token)) == '+' || op == '-')
|
||||
{
|
||||
get_token();
|
||||
level3( &h);
|
||||
arith(op, hold, &h);
|
||||
}
|
||||
}
|
||||
|
||||
void level3(double *hold)
|
||||
{
|
||||
char op;
|
||||
double h;
|
||||
|
||||
level4( hold);
|
||||
while ((op=*(token)) == '*' || op == '/' || op == '%')
|
||||
{
|
||||
get_token();
|
||||
level4( &h);
|
||||
arith( op, hold, &h);
|
||||
}
|
||||
}
|
||||
|
||||
void level4(double *hold)
|
||||
{
|
||||
double h;
|
||||
level5( hold);
|
||||
|
||||
if (*(token) == '^')
|
||||
{
|
||||
get_token();
|
||||
level5( &h);
|
||||
arith( '^', hold, &h);
|
||||
}
|
||||
}
|
||||
|
||||
void level5(double *hold)
|
||||
{
|
||||
char op;
|
||||
|
||||
op = 0;
|
||||
if (((token_type) == DELIMITER) && *(token) == '+' || *(token) == '-')
|
||||
{
|
||||
op = *(token);
|
||||
get_token();
|
||||
}
|
||||
level6( hold);
|
||||
|
||||
if (op)
|
||||
unary(op, hold);
|
||||
}
|
||||
|
||||
void level6(double *hold)
|
||||
{
|
||||
if ((*(token) == '(') && ((token_type) == DELIMITER))
|
||||
{
|
||||
get_token();
|
||||
level1( hold);
|
||||
if (*(token) != ')')
|
||||
serror( ERR_NOBRACKET);
|
||||
get_token();
|
||||
}
|
||||
else
|
||||
primitive( hold);
|
||||
}
|
||||
|
||||
void calc_function(double *hold)
|
||||
{
|
||||
double_list *args = NULL, *last = NULL, *t;
|
||||
double d;
|
||||
int i,argc=0,save_code;
|
||||
|
||||
save_code = code;
|
||||
code = 0;
|
||||
i = look_up(token);
|
||||
|
||||
if (i == 0)
|
||||
serror(ERR_BADFUNCTION); // error
|
||||
|
||||
get_token();
|
||||
if (*(token) != '(')
|
||||
serror(ERR_NOBRACKET); // error
|
||||
//get_token();
|
||||
if (functions[i].args == STR_ARG)
|
||||
{
|
||||
get_token();
|
||||
d = ((matfunc_str)(functions[i].f))(token);
|
||||
*hold = d;
|
||||
get_token();
|
||||
if (save_code)
|
||||
code = save_code;
|
||||
return;
|
||||
}
|
||||
|
||||
//last = args = (double_list*)malloc(sizeof(double_list));
|
||||
//args->next = NULL;
|
||||
//level1(&args->val);
|
||||
//get_token();
|
||||
argc=0;
|
||||
do
|
||||
{
|
||||
get_token();
|
||||
if (*token == ')')
|
||||
break;
|
||||
t = (double_list*)allocmem(sizeof(double_list));
|
||||
code = 0;
|
||||
level1(&t->val);
|
||||
t->code = code;
|
||||
t->next = NULL;
|
||||
if (last)
|
||||
last->next = t;
|
||||
else
|
||||
args = t;
|
||||
last = t;
|
||||
argc++;
|
||||
} while (*token == ',');
|
||||
|
||||
code = save_code;
|
||||
|
||||
if (argc != functions[i].args && functions[i].args >= 0)
|
||||
{
|
||||
serror(ERR_BADPARAM);
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (functions[i].args)
|
||||
{
|
||||
case 0:
|
||||
d = ((matfunc0)(functions[i].f))();
|
||||
break;
|
||||
case 1:
|
||||
d = ((matfunc)(functions[i].f))(args->val);
|
||||
break;
|
||||
case 2:
|
||||
d = ((matfunc2)(functions[i].f))(args->val,args->next->val);
|
||||
break;
|
||||
case 3:
|
||||
d = ((matfunc3)(functions[i].f))(args->val,args->next->val,args->next->next->val);
|
||||
break;
|
||||
case INF_ARGS:
|
||||
d = ((matfunc_inf)(functions[i].f))(args);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
t = args;
|
||||
while (t)
|
||||
{
|
||||
args = t->next;
|
||||
freemem(t);
|
||||
t = args;
|
||||
}
|
||||
|
||||
*hold = d;
|
||||
// else
|
||||
// serror( ERR_OVERFLOW);
|
||||
|
||||
}
|
||||
|
||||
void primitive(double *hold)
|
||||
{
|
||||
switch (token_type)
|
||||
{
|
||||
case VARIABLE:
|
||||
*hold = find_var(token);
|
||||
get_token();
|
||||
return;
|
||||
case NUMBER:
|
||||
//
|
||||
*hold = atof((token));
|
||||
//if (sscanf(token, "%lf", hold) != 1)
|
||||
*hold = convert(token);
|
||||
if (convert_error == ERROR)
|
||||
serror( ERR_BADNUMER);
|
||||
get_token();
|
||||
return;
|
||||
case FUNCTION:
|
||||
calc_function( hold);
|
||||
if (*token != ')')
|
||||
serror(ERR_NOBRACKET);
|
||||
get_token();
|
||||
return;
|
||||
default: // error
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void arith(char op, double *r, double *h)
|
||||
{
|
||||
double t;
|
||||
switch(op)
|
||||
{
|
||||
case '-':
|
||||
*r = *r - *h;
|
||||
break;
|
||||
case '+':
|
||||
*r = *r + *h;
|
||||
break;
|
||||
case '*':
|
||||
*r = *r * *h;
|
||||
break;
|
||||
case '/':
|
||||
if (fabs(*h) < epsilon)
|
||||
serror( ERR_OVERFLOW);
|
||||
else
|
||||
*r = (*r) / (*h);
|
||||
break;
|
||||
case '%':
|
||||
if (fabs(*h) < epsilon)
|
||||
serror( ERR_OVERFLOW);
|
||||
else
|
||||
{
|
||||
t = func_floor ((*r) / (*h));
|
||||
*r = *r - (t * (*h));
|
||||
}
|
||||
break;
|
||||
case '^':
|
||||
*r = pow(*r, *h);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void logic(char *op, double *r, double *h)
|
||||
{
|
||||
double t;
|
||||
switch (*op)
|
||||
{
|
||||
case '<':
|
||||
if (*(op+1) && *(op+1) == '=')
|
||||
t = *r <= *h + epsilon ? 1.0 : 0.0;
|
||||
else
|
||||
t = *r < *h - epsilon? 1.0 : 0.0;
|
||||
break;
|
||||
case '>':
|
||||
if (*(op+1) && *(op+1) == '=')
|
||||
t = *r >= *h - epsilon ? 1.0 : 0.0;
|
||||
else
|
||||
t = *r > *h + epsilon ? 1.0 : 0.0;
|
||||
break;
|
||||
case '=':
|
||||
t = fabs(*r - *h) <= epsilon ? 1.0 : 0.0;
|
||||
break;
|
||||
case '#':
|
||||
t = fabs(*r - *h) > epsilon ? 1.0 : 0.0;
|
||||
break;
|
||||
case '!':
|
||||
if (*(op+1) && *(op+1) == '=')
|
||||
t = fabs(*r - *h) > epsilon ? 1.0 : 0.0;
|
||||
else
|
||||
serror(ERR_GENERAL);
|
||||
break;
|
||||
}
|
||||
*r = t;
|
||||
}
|
||||
|
||||
|
||||
void unary(char op, double *r)
|
||||
{
|
||||
if (op == '-')
|
||||
*r = -(*r);
|
||||
}
|
||||
|
||||
bool strcmp(char *s1, char *s2)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (s1 == NULL)
|
||||
if (s2 == NULL)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
else
|
||||
if (s2 == NULL)
|
||||
return 1;
|
||||
|
||||
for (i = 0;;i++)
|
||||
{
|
||||
if (s1[i] == '\0')
|
||||
if (s2[i] == '\0')
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
else
|
||||
if (s2[i] == '\0')
|
||||
return 1;
|
||||
else
|
||||
{
|
||||
if (s1[i] != s2[i])
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool strncmp(char *s1, char *s2, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (s1 == NULL)
|
||||
if (s2 == NULL)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
else
|
||||
if (s2 == NULL)
|
||||
return 1;
|
||||
|
||||
for (i = 0;i<n;i++)
|
||||
{
|
||||
if (s1[i] == '\0')
|
||||
if (s2[i] == '\0')
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
else
|
||||
if (s2[i] == '\0')
|
||||
return 1;
|
||||
else
|
||||
{
|
||||
if (s1[i] != s2[i])
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int look_up(char *s)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < max_func; i++)
|
||||
if (strcmp(s, functions[i].name) == 0)
|
||||
return i;
|
||||
return 0; // search command/function name
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
// error codes
|
||||
#define ERR_BADFUNCTION -1
|
||||
#define ERR_BADNUMER -2
|
||||
#define ERR_GENERAL -3
|
||||
#define ERR_NOBRACKET -4
|
||||
#define ERR_BADVARIABLE -5
|
||||
#define ERR_OVERFLOW -6
|
||||
#define ERR_BADPARAM -7
|
||||
|
||||
typedef double variable_callback(char *s);
|
||||
|
||||
void set_exp(char *exp);
|
||||
// puts the token back to line
|
||||
void putback(double *hold);
|
||||
// gets the expression. This function is used externally
|
||||
int get_exp(double *hold);
|
||||
|
||||
// logic binary
|
||||
void level1(double *hold);
|
||||
|
||||
// unary !
|
||||
void level1_5(double *hold);
|
||||
|
||||
// works with +-
|
||||
void level2(double *hold);
|
||||
// works with */%
|
||||
void level3(double *hold);
|
||||
// works with ^
|
||||
void level4(double *hold);
|
||||
// works with ()
|
||||
void level5(double *hold);
|
||||
// works with elementary tokens
|
||||
void level6(double *hold);
|
||||
// gets value of number, function or variable
|
||||
void primitive(double *hold);
|
||||
// performs arithmetical operation
|
||||
void arith(char op, double *r, double *h);
|
||||
|
||||
void logic(char *op, double *r, double *h);
|
||||
|
||||
|
||||
// performs unary (one-operand) operation
|
||||
void unary(char op, double *r);
|
||||
// gets variable value by name
|
||||
extern variable_callback *find_var;
|
||||
|
||||
extern double rand_seed;
|
||||
|
||||
// stops execution of parser and return error code
|
||||
void serror(int code);
|
||||
// checks the function table to see if such a function exists
|
||||
int look_up(char *s);
|
||||
|
||||
bool strcmp(char *s1, char *s2);
|
||||
bool strncmp(char *s1, char *s2, int n);
|
||||
|
||||
extern double epsilon;
|
||||
|
||||
|
||||
int isdelim(char c);
|
||||
int isdigit(char c);
|
||||
int isalpha2(char c);
|
||||
int iswhite(char c);
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
// stdafx.cpp : source file that includes just the standard includes
|
||||
// FixedPoint.pch will be the pre-compiled header
|
||||
// stdafx.obj will contain the pre-compiled type information
|
||||
|
||||
#include "stdafx.h"
|
||||
|
||||
// TODO: reference any additional headers you need in STDAFX.H
|
||||
// and not in this file
|
|
@ -0,0 +1,11 @@
|
|||
// stdafx.h : include file for standard system include files,
|
||||
// or project specific include files that are used frequently, but
|
||||
// are changed infrequently
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
|
||||
|
||||
// TODO: reference additional headers your program requires here
|
|
@ -0,0 +1,58 @@
|
|||
|
||||
typedef Dword dword;
|
||||
|
||||
dword am__ = 0x0;
|
||||
dword bm__ = 0x0;
|
||||
|
||||
char aEdit_box_draw[9] = "edit_box";
|
||||
char aEdit_box_key[13] = "edit_box_key";
|
||||
char aEdit_box_mouse[15] = "edit_box_mouse";
|
||||
char aVersion_ed[11] = "version_ed";
|
||||
|
||||
char aCheck_box_draw [15] = "check_box_draw";
|
||||
char aCheck_box_mouse [16] = "check_box_mouse";
|
||||
char aVersion_ch [11] = "version_ch";
|
||||
|
||||
char aOption_box_draw [16] = "option_box_draw";
|
||||
char aOption_box_mouse[17] = "option_box_mouse";
|
||||
char aVersion_op [11] = "version_op" ;
|
||||
|
||||
//BOX_LIB
|
||||
|
||||
typedef dword __stdcall dword_func(dword);
|
||||
//typedef dword __stdcall dword3_func(dword,dword,dword);
|
||||
|
||||
dword_func *edit_box_draw =(dword_func*) &aEdit_box_draw;
|
||||
dword_func *edit_box_key =(dword_func*) &aEdit_box_key;
|
||||
dword_func *edit_box_mouse =(dword_func*) &aEdit_box_mouse;
|
||||
|
||||
//char lib_path[] = "/sys/lib/box_lib.obj";
|
||||
char lib_path[] = "/sys/lib/box_lib.obj";
|
||||
dword lib_path_addr = (dword)lib_path;
|
||||
dword dummy = 0;
|
||||
|
||||
|
||||
struct edit_box{
|
||||
dword width, left, top, color, shift_color, focus_border_color, blur_border_color,
|
||||
text_color, max, text, flags, size, pos, offset, cl_curs_x, cl_curs_y, shift, shift_old;
|
||||
};
|
||||
|
||||
void load_edit_box()
|
||||
{
|
||||
kol_struct_import *k = kol_cofflib_load(lib_path);
|
||||
|
||||
if (k == NULL)
|
||||
{
|
||||
sprintf(debuf, "cannot load library %S", lib_path);
|
||||
rtlDebugOutString(debuf);
|
||||
return;
|
||||
}
|
||||
|
||||
edit_box_draw = (dword_func*)kol_cofflib_procload(k, "edit_box");
|
||||
edit_box_key = (dword_func*)kol_cofflib_procload(k,"edit_box_key");
|
||||
edit_box_mouse = (dword_func*)kol_cofflib_procload(k,"edit_box_mouse");
|
||||
kos_SetMaskForEvents(0x27);
|
||||
|
||||
if (edit_box_draw == NULL || edit_box_key == NULL || edit_box_mouse == NULL)
|
||||
rtlDebugOutString("some of functions cannot be loaded!");
|
||||
}
|
Loading…
Reference in New Issue