From 9166e950b4727618ea9a41eab85f4f08c6069af7 Mon Sep 17 00:00:00 2001 From: barsuk Date: Wed, 28 Jan 2009 15:13:38 +0000 Subject: [PATCH] uploaded graph git-svn-id: svn://kolibrios.org@1005 a494cfbc-eb01-0410-851d-a64ba20cac60 --- programs/other/graph/KosFile.cpp | 132 +++++ programs/other/graph/KosFile.h | 26 + programs/other/graph/MCSMEMM.H | 28 + programs/other/graph/func.cpp | 389 +++++++++++++ programs/other/graph/func.h | 95 ++++ programs/other/graph/hello.cpp | 682 +++++++++++++++++++++++ programs/other/graph/hello.dsp | 147 +++++ programs/other/graph/hello.dsw | 29 + programs/other/graph/kolibri.cpp | 1 + programs/other/graph/kolibri.h | 0 programs/other/graph/kosSyst.cpp | 844 +++++++++++++++++++++++++++++ programs/other/graph/kosSyst.h | 214 ++++++++ programs/other/graph/man.txt | 46 ++ programs/other/graph/math2.cpp | 83 +++ programs/other/graph/mcsmemm.cpp | 354 ++++++++++++ programs/other/graph/parser.cpp | 493 +++++++++++++++++ programs/other/graph/parser.h | 29 + programs/other/graph/stdafx.cpp | 8 + programs/other/graph/string.c | 111 ++++ programs/other/graph/string.h | 12 + programs/other/graph/use_library.h | 58 ++ 21 files changed, 3781 insertions(+) create mode 100644 programs/other/graph/KosFile.cpp create mode 100644 programs/other/graph/KosFile.h create mode 100644 programs/other/graph/MCSMEMM.H create mode 100644 programs/other/graph/func.cpp create mode 100644 programs/other/graph/func.h create mode 100644 programs/other/graph/hello.cpp create mode 100644 programs/other/graph/hello.dsp create mode 100644 programs/other/graph/hello.dsw create mode 100644 programs/other/graph/kolibri.cpp create mode 100644 programs/other/graph/kolibri.h create mode 100644 programs/other/graph/kosSyst.cpp create mode 100644 programs/other/graph/kosSyst.h create mode 100644 programs/other/graph/man.txt create mode 100644 programs/other/graph/math2.cpp create mode 100644 programs/other/graph/mcsmemm.cpp create mode 100644 programs/other/graph/parser.cpp create mode 100644 programs/other/graph/parser.h create mode 100644 programs/other/graph/stdafx.cpp create mode 100644 programs/other/graph/string.c create mode 100644 programs/other/graph/string.h create mode 100644 programs/other/graph/use_library.h diff --git a/programs/other/graph/KosFile.cpp b/programs/other/graph/KosFile.cpp new file mode 100644 index 0000000000..22d6aeca81 --- /dev/null +++ b/programs/other/graph/KosFile.cpp @@ -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; +} + diff --git a/programs/other/graph/KosFile.h b/programs/other/graph/KosFile.h new file mode 100644 index 0000000000..5f7c18e9bc --- /dev/null +++ b/programs/other/graph/KosFile.h @@ -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); +}; diff --git a/programs/other/graph/MCSMEMM.H b/programs/other/graph/MCSMEMM.H new file mode 100644 index 0000000000..42d61eaadb --- /dev/null +++ b/programs/other/graph/MCSMEMM.H @@ -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 ); + + + diff --git a/programs/other/graph/func.cpp b/programs/other/graph/func.cpp new file mode 100644 index 0000000000..624813f6d3 --- /dev/null +++ b/programs/other/graph/func.cpp @@ -0,0 +1,389 @@ + + +#include "func.h" + +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 +} + +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; +} + +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; + + res = 0.0; + + i=0; + while (s[i] && isalpha(s[i])) i++; + if (len) *len=i; + if (s[i] == '\0') + return ERROR_END; + + 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] != ',') + return ERROR; + 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); +} + + + diff --git a/programs/other/graph/func.h b/programs/other/graph/func.h new file mode 100644 index 0000000000..cb84349000 --- /dev/null +++ b/programs/other/graph/func.h @@ -0,0 +1,95 @@ + +#pragma once + +#include "kosSyst.h" +#include "kosFile.h" +#include "MCSMEMM.H" + +#include + + +#define ERROR 8888888888.9 +#define ERROR_END 8888888888.7 + +#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; + + +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); + +double fabs(double x); +double cos(double x); +double sin(double x); +int di(double x); + +double id(int 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); \ No newline at end of file diff --git a/programs/other/graph/hello.cpp b/programs/other/graph/hello.cpp new file mode 100644 index 0000000000..dc5a4fbf02 --- /dev/null +++ b/programs/other/graph/hello.cpp @@ -0,0 +1,682 @@ + +#include "func.h" +#include "parser.h" +#include "kolibri.h" +#include "use_library.h" + +const char header[] = "Graph"; +const char empty_text[] = "No function loaded. Type file name and press Enter. "; +const char er_file_not_found[] = "Cannot open file. "; +const char str_filename[]="Filename:"; +const char str_editfile[]="Edit"; + +// начальные размеры +#define WND_W 400 +#define WND_H 300 + +#define LIGHTGREEN 0xff0000 +#define WHITE 0xffffff +#define BLACK 0x0 +#define LIGHTBLUE 0x0000ff +#define LIGHTRED 0xff0000 + +// font colors +#define BIGFONTCOLOR BLACK +#define SMALLFONTCOLOR BLACK + +#define THREE 3.0 +// minimum space: 3 pixels + +#define BIG_HEIGHT 4.0 +#define SMALL_HEIGHT 2.0 +#define TEXT_X 15.0 +// numeric format for output +#define FORMAT "%f" +// format for two coords +#define FORMAT_COORD "(%f,%f)" +// special value to text if enough space +#define FORMAT_TEST "0.00" + +#define DELTA_BIG 1.0 +#define DELTA_SMALL 0.1 + +double *points; +Dword point_count = 0; +double x1,y1,x2,y2; +char *funct = NULL; + +char edit_path[256]; +//Dword editbox_y = WND_H - 16, editbox_w = WND_W - 70; +edit_box mybox = {0,9*8-5,WND_H - 16-32,0xffffff,0x6a9480,0,0x808080,0,99,(dword)&edit_path,0}; + +char *full_head; + +char *HugeBuf = NULL; + +//char fuck[64] = "$this is a fucking marker$"; +// параметры командной строки +char params[1024] = "_FIND_ME_"; + +/* + + fucking piece of shit + + */ + +// constructor of TCoord +TCoord coord(double x, double y) +{ + TCoord r; + r.x = x; + r.y = y; + return r; +} + +// move and scale mathematical coords to fit screen coords +TCoord mat2Graf(TCoord c, TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax) +{ + TCoord r; + if (c.x > mMax.x) + c.x = mMax.x; + if (c.x < mMin.x) + c.x = mMin.x; + if (c.y > mMax.y) + c.y = mMax.y; + if (c.y < mMin.y) + c.y = mMin.y; + r.x = (scrMax.x - scrMin.x) / (mMax.x - mMin.x) * (c.x - mMin.x) + scrMin.x; + r.y = (scrMax.y - scrMin.y) / (mMax.y - mMin.y) * (mMax.y - c.y) + scrMin.y; + + return r; +} + +// double-обертки +void line_d( double x1, double y1, double x2, double y2) +{ + line(di(x1), di(y1), di(x2), di(y2)); +} + +void outtextxy_d( double x, double y, char * text, int len) +{ + outtextxy(di(x), di(y), text, len); +} + +// huge function to draw all the stuff except the function itself +void drawAxis( TCoord scrMin, TCoord scrMax, TCoord mMin, TCoord mMax) +{ + TCoord cZero={0.0,0.0}, + gMin, gMax, gZero, step; + TCoord from, to; + double i=0.0; + int j; + double xmin, xmin2, ymin, ymin2; + char buf[30]=""; + + +// scr means Screen(bounding rect) +// m means Mathematical +// g means Graphic(real screen position) + + //rtlDebugOutString("draw axis called\n"); + + //format(debuf, 30, "test: %f,%f,%f,%f\n", 123.45, 1.0, -0.9, 12.57); + //rtlDebugOutString(debuf); + + gMin = mat2Graf(mMin, scrMin, scrMax, mMin, mMax); + gMax = mat2Graf(mMax, scrMin, scrMax, mMin, mMax); + gZero = mat2Graf(cZero, scrMin, scrMax, mMin, mMax); + + // clear + // setcolor(WHITE); + //rectangle(di(gMin.x), di(gMin.y), di(gMax.x), di(gMax.y)); + // ftopku + + setcolor(BLACK); + // osy X + line_d(gMin.x, gZero.y ,gMax.x, gZero.y); + // osy Y + line_d(gZero.x, gMin.y, gZero.x, gMax.y); + // bounding rect + line_d(gMin.x, gMin.y, gMax.x, gMin.y); + line_d(gMin.x, gMax.y, gMax.x, gMax.y); + + line_d(gMin.x, gMin.y, gMin.x, gMax.y); + line_d(gMax.x, gMin.y, gMax.x, gMax.y); + + // coords of the rect : lower left + format(buf, 30, FORMAT_COORD, x1, y1); + //rtlDebugOutString(buf); + outtextxy_d(gMin.x, gMin.y + textheight(buf, 20), buf, 20); + // upper left + format(buf, 30, FORMAT_COORD, x1, y2); + outtextxy_d(gMin.x, gMax.y - textheight(buf, 20), buf, 20); + // lower right + format(buf, 30, FORMAT_COORD, x2, y1); + outtextxy_d(gMax.x - textwidth(buf, 20), gMin.y + textheight(buf, 20), buf, 20); + // upper right + format(buf, 30, FORMAT_COORD, x2, y2); + outtextxy_d(gMax.x - textwidth(buf, 20), gMax.y - textheight(buf, 20), buf, 20); + + //rtlDebugOutString("some lines painted\n"); + + + step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x); + step.y = (mMax.y - mMin.y) / (scrMax.y - scrMin.y); + +// round values + xmin = id(di((mMin.x / DELTA_BIG) * DELTA_BIG)); + ymin = id(di((mMin.y / DELTA_BIG) * DELTA_BIG)); + + // (0,0) + + if ((x1 * x2 <= 0.0) && (y1 * y2 <= 0.0)) + { + from.x=0.0; + from.y=0.0; + from = mat2Graf(from, scrMin, scrMax, mMin, mMax); + setcolor(BLACK); + format(buf, 30, FORMAT, 0.0); + outtextxy_d(from.x - textwidth(buf, 20), from.y + textheight(buf, 20), buf, 20); + } + + + // big marks on X + //settextstyle(0, 0, 1); + if (DELTA_BIG / step.x > THREE) + { + for (i = xmin; i <= mMax.x; i += DELTA_BIG) + { + if (i != 0.0) + { + from.x = i; + to.x = from.x; + from.y = -BIG_HEIGHT * step.y; + to.y = BIG_HEIGHT * step.y; + from = mat2Graf(from, scrMin, scrMax, mMin, mMax); + to = mat2Graf(to, scrMin, scrMax, mMin, mMax); + setcolor(BLACK); + line_d(from.x, from.y, to.x, to.y); + // write number + format(buf, 30, FORMAT, i); + // if it fits in the GAP, then write it + if (from.y > scrMin.y && (DELTA_BIG > (textwidth(buf, 20) + 1.0) * step.x)) + { + setcolor(BIGFONTCOLOR); + outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20); + } + } + } + } + //rtlDebugOutString("big marks x painted\n"); + + // big marks on Y + if (DELTA_BIG / step.y > THREE) + { + for (i = ymin; i <= mMax.y; i += DELTA_BIG) + { + if (i != 0.0) + { + from.y = i; + to.y = from.y; + from.x = -BIG_HEIGHT * step.x; + to.x = BIG_HEIGHT * step.x; + from = mat2Graf(from, scrMin, scrMax, mMin, mMax); + to = mat2Graf(to, scrMin, scrMax, mMin, mMax); + setcolor(BLACK); + line_d(from.x, from.y, to.x, to.y); + format(buf, 30, FORMAT, i); + if (from.x > scrMin.x && (DELTA_BIG > textheight(buf, 20) * step.y)) + { + setcolor(BIGFONTCOLOR); + outtextxy_d(from.x + TEXT_X, to.y - textheight(buf, 20) / 2.0, buf, 20); + } + } + } + } + + xmin2 = id(di(mMin.x / DELTA_SMALL)) * DELTA_SMALL; + ymin2 = id(di(mMin.y / DELTA_SMALL)) * DELTA_SMALL; + + if (DELTA_SMALL / step.x > THREE) + { + j = di((( - xmin + xmin2 ) / DELTA_SMALL)); + for (i = xmin2; i <= mMax.x; i += DELTA_SMALL, j++) + { + if (j % 10 == 0) + { + // we need to skip every tenth mark, to avoid overwriting big marks + j = 0; + continue; + } + from.x = i; + to.x = from.x; + from.y = -SMALL_HEIGHT * step.y; + to.y = SMALL_HEIGHT * step.y; + from = mat2Graf(from, scrMin, scrMax, mMin, mMax); + to = mat2Graf(to, scrMin, scrMax, mMin, mMax); + setcolor(BLACK); + line_d(from.x, from.y, to.x, to.y); + format(buf, 30, FORMAT, i); + + if (from.y > scrMin.y && (DELTA_SMALL > textwidth(buf, 20) * step.x)) + { + setcolor(SMALLFONTCOLOR); + outtextxy_d(from.x - textwidth(buf, 20) / 2.0, to.y - textheight(buf, 20), buf, 20); + } + + + } + + } + + // finally small marks on Y + if (DELTA_SMALL / step.y > THREE) + { + //rtlDebugOutString("really small marks y painted\n"); + j = di((( - ymin + ymin2) / DELTA_SMALL)); + for (i = ymin2; i <= mMax.y; i += DELTA_SMALL, j++) + { + if (j % 10 == 0) + { + // we need to skip every tenth, to avoid overwriting + j = 0; + continue; + } + from.y = i; + to.y = from.y; + from.x = -SMALL_HEIGHT * step.x; + to.x = SMALL_HEIGHT * step.x; + from = mat2Graf(from, scrMin, scrMax, mMin, mMax); + to = mat2Graf(to, scrMin, scrMax, mMin, mMax); + setcolor(BLACK); + line_d(from.x, from.y, to.x, to.y); + format(buf, 30, FORMAT, i); + if (from.x > scrMin.x && (DELTA_SMALL > textheight(buf, 20) * step.y)) + { + setcolor(SMALLFONTCOLOR); + outtextxy_d(from.x + TEXT_X, from.y - textheight(buf, 20) / 2.0, buf, 20); + } + } + } + +} + +/* + ends fucking piece of shit +*/ + +void drawFunction( function_t fi, TCoord scrMin, TCoord scrMax, + TCoord mMin, TCoord mMax, DWORD color) +{ + double x; + double y; + int firstPoint = 1; + TCoord p, p0 = {0.0, 0.0}, step; + + drawAxis(scrMin, scrMax, mMin, mMax); + + setcolor(color); + step.x = (mMax.x - mMin.x) / (scrMax.x - scrMin.x); + + for (x = mMin.x; x < mMax.x; x += step.x) + { + y = fi(x); +// function is defined here and gets in the range + if (1) // тут было условие, что функция правильно вычислена + { + if ((y > mMin.y) && (y < mMax.y)) + { + p = mat2Graf(coord(x, y), scrMin, scrMax, mMin, mMax); + // if it's our first point, only remember its coords + // otherwise, draw a line_d from prev to current + if (firstPoint == 0) + { + line_d(p0.x, p0.y, p.x, p.y); + } + else + firstPoint = 0; + + p0 = p; + } + else // too big/small + { + firstPoint = 1; + } + } + else // no value + { + firstPoint = 1; + } + } + +} + +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; +}; + +// итоговая версия читалки текстовых файлов +int load_points3() +{ + kosFileInfo fileInfo; + kosBDVK bdvk; + int filePointer = 0; + + Dword count; + int i,j,k; + double d; + Dword filesize, num_number; + + double *p2; + + if (edit_path[0] == '\0') + return 0; + + // get file size + strcpy(fileInfo.fileURL,edit_path); + fileInfo.OffsetLow = 0; + fileInfo.OffsetHigh = 0; + fileInfo.dataCount = 0; + fileInfo.rwMode = 5; + fileInfo.bufferPtr = (Byte *)&bdvk; + Dword rr = kos_FileSystemAccess( &(fileInfo) ); // в CKosFile нет определения размера + sprintf(debuf, "getsize: %U\n", rr); + rtlDebugOutString(debuf); + if (rr != 0) + { + kos_WriteTextToWindow(10,10,0,0x00,(char*)er_file_not_found,strlen(er_file_not_found)); + return 0; + } + + filesize = bdvk.size_low; + num_number = filesize / 2; + + HugeBuf = (char *)allocmem(filesize + 1); // разбираем как строку, отсюда терминатор \0 + + for (i=0;i= points[(point_count-1) * 2]) + return points[(point_count-1) * 2 + 1]; + + for (i = 0; i < point_count; i++) + { + if ((x >= points[2 * i]) && (x < points[2 * (i + 1)])) + break; + } + + return (x - points[2 * i]) / (points[2 * (i + 1)] - points[2 * i]) + * (points[2 * (i + 1) + 1] - points[2 * i + 1]) + points[2 * i + 1]; + +} + +void draw_window(void) +{ + char str[80]; + int i; + double xx0=0.0, yy0=0.0, xx,yy; + sProcessInfo info; + Dword wi, he; + void *p; + + for (i = 0; i < 1024; i++) + info.rawData[i] = 0; + kos_ProcessInfo(&info, 0xFFFFFFFF); + + p = info.rawData + 42; // magic + wi = *(Dword *)(p); + he = *(Dword *)((Byte *)p + 4); + + if (wi == 0) + wi = WND_W; + if (he == 0) + he = WND_H; + + mybox.top = he - 45; + mybox.width = wi - mybox.left - 80; + + // start redraw + kos_WindowRedrawStatus(1); + kos_DefineAndDrawWindow(10,40,WND_W,WND_H, + 0x33,0xFFFFFF,0,0,(Dword)full_head); + + rtlDebugOutString("entering draw_window\n"); + + if (point_count == 0 && funct == NULL) + { + kos_WriteTextToWindow((wi - 6 * strlen(empty_text))/2,he/2,0,0x000000,(char *)empty_text,strlen(empty_text)); + } + else + { + drawFunction(&fu, coord(10, 20), coord(id(wi - 20), id(he - 70)), + coord(x1,y1), coord(x2,y2), 0x00ff0000); + + } + + kos_WriteTextToWindow(4, mybox.top + 4, 0, 0, (char*)str_filename, strlen(str_filename)); + + if ((void*)edit_box_draw != NULL) + edit_box_draw((DWORD)&mybox); + + kos_DefineButton(wi - 70, mybox.top, 50, 12, 5, 0xc0c0c0); + kos_WriteTextToWindow(wi - 58, mybox.top + 4, 0, 0, (char*)str_editfile, strlen(str_editfile)); + + // end redraw + kos_WindowRedrawStatus(2); +} + +void kos_Main() +{ + kos_InitHeap(); + full_head = (char*)allocmem(300); + strcpy(full_head, "Graph"); + load_edit_box(); + if (params[0]) // fuck[0] for debug + { + rtlDebugOutString("launched with params"); + rtlDebugOutString((char*)params); + strcpy(edit_path, params); + //rtlDebugOutString((char*)edit_path); + load_points3(); + } + rtlDebugOutString("data loaded.\n"); + draw_window(); + for (;;) + { + edit_box_mouse((dword)&mybox); + switch (kos_WaitForEvent()) + { + case 1: + draw_window(); + break; + case 2: + // key pressed, read it + Byte keyCode; + kos_GetKey(keyCode); + + switch (keyCode) + { + case 0x0D: + if (HugeBuf!=NULL) + { + //sprintf(debuf, "freemem: HugeBuf = %X", HugeBuf); + //rtlDebugOutString(debuf); + freemem((void*)HugeBuf); // что за баг - понять не могу. + HugeBuf = NULL; + funct = NULL; + } + if (points!=NULL) + { + //sprintf(debuf, "freemem: points = %X", points); + //rtlDebugOutString(debuf); + freemem((void*)points); // и тут. ну не обращаюсь я к этому указателю, только память в него + // потом снова выделяю + points = NULL; + } + point_count = 0; + kos_DrawBar(10,10,200,20,0xFFFFFF); // фон для сообщений об ошибках + if (load_points3()) + draw_window(); + break; + default: + { + __asm + { + mov ah, keyCode + } + edit_box_key((dword)&mybox); + } + } + break; + + + case 3: + // button pressed; we have only one button, close + Dword button; + kos_GetButtonID(button); + if (button == 1) + kos_ExitApp(); + else if (button == 5) + { + LaunchTinypad(); + } + } + } +} + diff --git a/programs/other/graph/hello.dsp b/programs/other/graph/hello.dsp new file mode 100644 index 0000000000..b415fa839f --- /dev/null +++ b/programs/other/graph/hello.dsp @@ -0,0 +1,147 @@ +# 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 _FIND_ME_ + +# 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=.\func.cpp +# End Source File +# Begin Source File + +SOURCE=.\hello.cpp +# End Source File +# Begin Source File + +SOURCE=.\kolibri.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 +# Begin Source File + +SOURCE=.\string.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\func.h +# End Source File +# Begin Source File + +SOURCE=.\kolibri.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=.\string.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 diff --git a/programs/other/graph/hello.dsw b/programs/other/graph/hello.dsw new file mode 100644 index 0000000000..07550fec4b --- /dev/null +++ b/programs/other/graph/hello.dsw @@ -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> +{{{ +}}} + +############################################################################### + diff --git a/programs/other/graph/kolibri.cpp b/programs/other/graph/kolibri.cpp new file mode 100644 index 0000000000..d3f5a12faa --- /dev/null +++ b/programs/other/graph/kolibri.cpp @@ -0,0 +1 @@ + diff --git a/programs/other/graph/kolibri.h b/programs/other/graph/kolibri.h new file mode 100644 index 0000000000..e69de29bb2 diff --git a/programs/other/graph/kosSyst.cpp b/programs/other/graph/kosSyst.cpp new file mode 100644 index 0000000000..00daf8512d --- /dev/null +++ b/programs/other/graph/kosSyst.cpp @@ -0,0 +1,844 @@ +#include "kosSyst.h" +#include + +#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; +} + +#if _MSC_VER >= 1400 +// +void * __cdecl memcpy( void *dst, const void *src, size_t bytesCount ) +{ + __asm{ + mov edi, dst + mov eax, dst + mov esi, src + mov ecx, bytesCount + rep movsb + } +} + +// +void memset( Byte *dst, Byte filler, Dword count ) +{ + // + __asm{ + mov edi, dst + mov al, filler + mov ecx, count + rep stosb + } +} +#endif + +// +Dword rtlInterlockedExchange( Dword *target, Dword value ) +{ +// Dword result; + + // + __asm{ + mov eax, value + mov ebx, target + xchg eax, [ebx] +// mov result, eax + } + // +// return result; +} + + +////////////////////////////////////////////////////////////////////// +// +// копирование строки +// + +char * __cdecl strcpy( char *target, const char *source ) +{ + char *result = target; + + while( target[0] = source[0] ) + { + target++; + source++; + } + + return result; +} + + +////////////////////////////////////////////////////////////////////// +// +// реверсивный поиск символа +// + +char * __cdecl strrchr( const char * string, int c ) +{ + char *cPtr; + + // + for ( cPtr = (char *)string + strlen( string ); cPtr >= string; cPtr-- ) + { + // + if ( *cPtr == c ) return cPtr; + } + // + return NULL; +} + + +////////////////////////////////////////////////////////////////////// +// +// определение длины строки +// + +int __cdecl strlen( const char *line ) +{ + int i; + + for( i=0; line[i] != 0; i++ ); + return i; +} + + + +////////////////////////////////////////////////////////////////////// +// +// перевод шестнадцатиричного числа в символ +// + +unsigned int num2hex( unsigned int num ) +{ + if( num < 10 ) + return num + '0'; + return num - 10 + 'A'; +} + + +////////////////////////////////////////////////////////////////////// +// +// вывод строки на печать +// + +Dword dectab[] = { 1000000000, 100000000, 10000000, 1000000, 100000, + 10000, 1000, 100, 10, 0 }; + +// +void sprintf( char *Str, char* Format, ... ) +{ + int i, fmtlinesize, j, k, flag; + Dword head, tail; + char c; + va_list arglist; + // + va_start(arglist, Format); + + // + fmtlinesize = strlen( Format ); + // + if( fmtlinesize == 0 ) return; + + // + for( i = 0, j = 0; i < fmtlinesize; i++ ) + { + // + c = Format[i]; + // + if( c != '%' ) + { + Str[j++] = c; + continue; + } + // + i++; + // + if( i >= fmtlinesize ) break; + + // + flag = 0; + // + c = Format[i]; + // + switch( c ) + { + // + case '%': + Str[j++] = c; + break; + // вывод строки + case 'S': + Byte* str; + str = va_arg(arglist, Byte*); + for( k = 0; ( c = str[k] ) != 0; k++ ) + { + Str[j++] = c; + } + break; + // вывод байта + case 'B': + k = va_arg(arglist, int) & 0xFF; + Str[j++] = num2hex( ( k >> 4 ) & 0xF ); + Str[j++] = num2hex( k & 0xF ); + break; + // вывод символа + case 'C': + Str[j++] = va_arg(arglist, int) & 0xFF; + break; + // вывод двойного слова в шестнадцатиричном виде + case 'X': + Dword val; + val = va_arg(arglist, Dword); + for( k = 7; k >= 0; k-- ) + { + // + c = num2hex ( ( val >> (k * 4) ) & 0xF ); + // + if( c == '0' ) + { + if( flag ) Str[j++] = c; + } + else + { + flag++; + Str[j++] = c; + } + } + // + if( flag == 0 ) Str[j++] = '0'; + break; + // вывод двойного слова в десятичном виде + case 'U': + head = va_arg(arglist, Dword); + tail = 0; + for( k = 0; dectab[k] != 0; k++ ) + { + tail = head % dectab[k]; + head /= dectab[k]; + c = head + '0'; + if( c == '0' ) + { + if( flag ) Str[j++] = c; + } + else + { + flag++; + Str[j++] = c; + } + // + head = tail; + } + // + c = head + '0'; + Str[j++] = c; + break; + // вывод 64-битного слова в шестнадцатиричном виде + case 'Q': + unsigned int low_dword, high_dword; + low_dword = va_arg(arglist, unsigned int); + high_dword = va_arg(arglist, unsigned int); + for( k = 7; k >= 0; k-- ) + { + // + c = num2hex ( ( ( high_dword + 1) >> (k * 4) ) & 0xF ); + // + if( c == '0' ) + { + if( flag ) Str[j++] = c; + } + else + { + flag++; + Str[j++] = c; + } + } + // + for( k=7; k >= 0; k-- ) + { + // + c = num2hex ( ( low_dword >> (k * 4) ) & 0xF ); + // + if( c == '0' ) + { + if( flag ) Str[j++] = c; + } + else + { + flag++; + Str[j++] = c; + } + } + // + if( flag == 0 ) Str[j++] = '0'; + // + break; + // + default: + break; + } + } + // + Str[j] = 0; +} + + +// функция -1 завершения процесса +void 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(); +} + + diff --git a/programs/other/graph/kosSyst.h b/programs/other/graph/kosSyst.h new file mode 100644 index 0000000000..b8552de08e --- /dev/null +++ b/programs/other/graph/kosSyst.h @@ -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(); diff --git a/programs/other/graph/man.txt b/programs/other/graph/man.txt new file mode 100644 index 0000000000..c4fe646873 --- /dev/null +++ b/programs/other/graph/man.txt @@ -0,0 +1,46 @@ +=== v 0.2 === 6.06.08 + +формат входных данных(файл graph.cvs) + +а) если заданы точки и требуется провести кусочно-линейную функцию +x1 y1 x2 y2 ; границы области построения +x y +x y ; значения +... + +б) если задана функция +x1 y1 x2 y2 ; границы области построения +=формула + + +где числа записываются в формате ###,### или ###.###, например, допустимы следующие записи: +1 +1.2 +1. +.6 +-543.1463 +и недопустимы: +1e2 ++5 + +формула - выражение, составленное из чисел, переменной x, операций + - * / и функций: sin, cos, tg ,ctg (остальные в проекте). +примеры: +=sin(x)*x +=x/2 +=cos(sin(cos(x)+1)+1)+1 +=1/x + +в случае ошибки вычисления(не найдена функция, деление на 0) программа не выводит никаких сообщений, а либо вылетает, либо считает результат недопустимой операции нулевым. + + +== v 0.3 ==== 7.06.08 + +добавлено много чего из интерфейса. +функции: log, exp, sqrt. + + + +== v 0.4 ===== 9.06.08 + +улучшен ввод имени файла, обработка ошибок, фиксы утечек памяти. + diff --git a/programs/other/graph/math2.cpp b/programs/other/graph/math2.cpp new file mode 100644 index 0000000000..6b348ed777 --- /dev/null +++ b/programs/other/graph/math2.cpp @@ -0,0 +1,83 @@ +#include +#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 + } +} diff --git a/programs/other/graph/mcsmemm.cpp b/programs/other/graph/mcsmemm.cpp new file mode 100644 index 0000000000..8073a0e703 --- /dev/null +++ b/programs/other/graph/mcsmemm.cpp @@ -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; +} + +*/ \ No newline at end of file diff --git a/programs/other/graph/parser.cpp b/programs/other/graph/parser.cpp new file mode 100644 index 0000000000..9dc8206d94 --- /dev/null +++ b/programs/other/graph/parser.cpp @@ -0,0 +1,493 @@ + + +#include "func.h" +#include "parser.h" + +// token types +#define DELIMITER 1 +#define VARIABLE 2 +#define NUMBER 3 +#define FUNCTION 4 +#define FINISHED 10 + +// 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 + +double tg(double d) +{ + return sin(d) / cos(d); +} + +double ctg(double d) +{ + return cos(d) / sin(d); +} + +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; + __asm { + FLD1 + FLD x + FYL2X + FLDLN2 + FMUL + } +} + +double sqrt(double x) +{ + __asm { + fld x + fsqrt + } +} + +double atan(double x) +{ + return 0.0; // в лом +} + +double pow(double x, double y) +{ + return 0.0; // в лом, пускай считают черех exp и log +} + + +// represents general mathematical function +typedef double(*matfunc)(double); + +// used to link function name to the function +typedef struct +{ + char name[10]; + matfunc f; +} func; + +// the list of functions +const int max_func = 12; +func functions[max_func] = +{ + "", NULL, + "sin", &sin, + "cos", &cos, + "exp", &exp, + "sqrt", &sqrt, + "log", &log, + "tg", &tg, + "ctg", &ctg, + "arcsin", &asin, + "arccos", &acos, + "arctg", &atan, + "abs", &fabs +}; + +// all delimiters +const char *delim="+-*^/%=;(),><"; // not bad words + +// structure for most parser functions + + char token[80]; + int token_type; + char *prog; + double x_value; + int code; // error code + +int isdelim(char c) +{ + //return strchr(delim, c) != 0; + for (int i = 0; i < 14; 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')); +} + +int iswhite(char c) +{ + return (c==' ' || c=='\t'); +} + + +void serror(int code) +{ + ::code = code; +// longjmp(j, code); +} + +void set_exp(char *exp, double x) +{ + prog = exp; + x_value = x; +} + +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))) + { + *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); +} + +int 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) +{ + int res; + code = 0; +// if (res = setjmp(j) != 0) +// return code; + get_token(); + if (!*(token)) + { + return 0; + } + level2( hold); + putback(); + return 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(); + level2( hold); + if (*(token) != ')') + serror( ERR_NOBRACKET); + get_token(); + } + else + primitive( hold); +} + +void calc_function(double *hold) +{ + double d; + int i; + + i = look_up(token); + + if (i == 0) + serror(ERR_BADFUNCTION); // error + + get_token(); + if (*(token) != '(') + serror(ERR_NOBRACKET); // error + get_token(); + level2(hold); + get_token(); + + d = functions[i].f(*hold); + *hold = (functions[i].f)(*hold); +// 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 (*hold == ERROR) + serror( ERR_BADNUMER); + get_token(); + return; + case FUNCTION: + calc_function( hold); + 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 (*h == 0) + serror( ERR_OVERFLOW); + else + *r = (*r) / (*h); + break; + case '%': + t = (*r) / (*h); + *r = *r - (t * (*h)); + break; + case '^': + *r = pow(*r, *h); + break; + } +} + +void unary(char op, double *r) +{ + if (op == '-') + *r = -(*r); +} + +double find_var(char *s) +{ + //return 0; // not imp + //int i; + + //for (i = 0; i < kvar; i++) + // if (strcmp(vars[i].name, s) == 0) + // return vars[i].value; + + if (s[1] == '\0' && (s[0] == 'x' || s[0] == 'X')) + //if (strcmp(s,"x") == 0 || strcmp(s,"X") == 0) + return x_value; + + serror( ERR_BADVARIABLE); + return 0; // to make compiler very happy + + //printf("\nPlease enter value for variable \"%s\": ", s); + //scanf("%lf", &vars[kvar].value); + //strcpy(vars[kvar].name, s); + //kvar++; + //return vars[kvar - 1].value; +} + +bool strcmp(char *s1, char *s2) +{ + int i; + + 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; + } + } +} + +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 +} + +/* +void delete_white(char *buf) +{ + int len = strlen(buf); + char *d = (char *)malloc(len + 1); + char *t = buf; + strcpy(d, buf); + d[len] = '\0'; + + int i; + + for (i = 0; i < len; i++) + if (!iswhite(d[i])) + *t++=d[i]; + *t++='\0'; + free(d); +} +*/ + +/* +void main(void) +{ + + = (parser_struct)malloc(sizeof(parser_struct)); + double a; + char buffer[256]; + + + printf("Enter expression: "); + memset(buffer, 0, 256); + gets(buffer); + + prog = buffer; + delete_white(buffer); + + a = 0; + x_value = 3; + get_exp( &a); + + printf("result: %lg\n", a); + getch(); + +} +*/ \ No newline at end of file diff --git a/programs/other/graph/parser.h b/programs/other/graph/parser.h new file mode 100644 index 0000000000..db675b1d46 --- /dev/null +++ b/programs/other/graph/parser.h @@ -0,0 +1,29 @@ + + +void set_exp(char *exp, double x); +// puts the token back to line +void putback(double *hold); +// gets the expression. This function is used externally +int get_exp(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); +// performs unary (one-operand) operation +void unary(char op, double *r); +// gets variable value by name +double find_var(char *s); +// 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); diff --git a/programs/other/graph/stdafx.cpp b/programs/other/graph/stdafx.cpp new file mode 100644 index 0000000000..eec82ebe13 --- /dev/null +++ b/programs/other/graph/stdafx.cpp @@ -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 diff --git a/programs/other/graph/string.c b/programs/other/graph/string.c new file mode 100644 index 0000000000..9f9eac90a3 --- /dev/null +++ b/programs/other/graph/string.c @@ -0,0 +1,111 @@ + +#include "string.h" + +void* memset(void *mem, int c, unsigned size) +{ +unsigned i; + +for ( i = 0; i < size; i++ ) + *((char *)mem+i) = (char) c; + +return NULL; +} + + +void* memcpy(void *dst, const void *src, unsigned size) +{ + +unsigned i; + +for ( i = 0; i < size; i++) + *((char *)dst+i) = *((char *)src+i); + +return NULL; +} + + +void strcat(char strDest[], char strSource[]) +{ + +int i, j; + +i = j = 0; +while (strDest[i] != '\0') + i++; + +while ((strDest[i++] = strSource[j++]) != '\0') + ; +} + + +int strcmp(const char* string1, const char* string2) +{ + +while (1) +{ +if (*string1<*string2) + return -1; +if (*string1>*string2) + return 1; + +if (*string1=='\0') + return 0; + +string1++; +string2++; +} + +} + + +void strcpy(char strDest[], const char strSource[]) +{ +unsigned i; + +i = 0; +while ((strDest[i] = strSource[i]) != '\0') + i++; + +} + + +char* strncpy(char *strDest, const char *strSource, unsigned n) +{ +unsigned i; + +if (! n ) + return strDest; + +i = 0; +while ((strDest[i] = strSource[i]) != '\0') + if ( (n-1) == i ) + break; + else + i++; + +return strDest; +} + + +int strlen(const char* string) +{ +int i; + +i=0; +while (*string++) i++; +return i; +} + + + +char* strchr(const char* string, int c) +{ + while (*string) + { + if (*string==c) + return (char*)string; + string++; + } + return (char*)0; +} + diff --git a/programs/other/graph/string.h b/programs/other/graph/string.h new file mode 100644 index 0000000000..7cf010c54e --- /dev/null +++ b/programs/other/graph/string.h @@ -0,0 +1,12 @@ + +#define NULL ((void*)0) + +void* memset(void *mem, int c, unsigned size); +void* memcpy(void *dst, const void *src, unsigned size); + +void strcat(char strDest[], char strSource[]); +int strcmp(const char* string1, const char* string2); +//void strcpy(char strDest[], const char strSource[]); +char* strncpy(char *strDest, const char *strSource, unsigned n); +int strlen(const char* string); +char *strchr(const char* string, int c); diff --git a/programs/other/graph/use_library.h b/programs/other/graph/use_library.h new file mode 100644 index 0000000000..ab8364619a --- /dev/null +++ b/programs/other/graph/use_library.h @@ -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!"); +} \ No newline at end of file