748 lines
19 KiB
C
748 lines
19 KiB
C
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include "Compiler.h"
|
|
#include "eval.h"
|
|
|
|
// defining this allows code to run in different threads at the same time
|
|
// it tends however, to be slower. We leave this OFF for AVS, since most of our shit runs in one thread
|
|
// anyhow.
|
|
//#define NSEEL_REENTRANT_EXECUTION
|
|
|
|
#ifdef NSEEL_REENTRANT_EXECUTION
|
|
#include <malloc.h>
|
|
#endif
|
|
#define NSEEL_USE_CRITICAL_SECTION g_eval_cs
|
|
|
|
// note that compiling can only happen in one thread at a time, always.
|
|
|
|
|
|
|
|
|
|
int g_evallib_stats[5]; // source bytes, static code bytes, call code bytes, data bytes, segments
|
|
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
CRITICAL_SECTION NSEEL_USE_CRITICAL_SECTION;
|
|
#endif
|
|
|
|
|
|
#define LLB_DSIZE (65536-64)
|
|
typedef struct _llBlock {
|
|
struct _llBlock *next;
|
|
int sizeused;
|
|
char block[LLB_DSIZE];
|
|
} llBlock;
|
|
|
|
typedef struct _startPtr {
|
|
struct _startPtr *next;
|
|
void *startptr;
|
|
} startPtr;
|
|
|
|
typedef struct {
|
|
int workTablePtr_size;
|
|
|
|
llBlock *blocks;
|
|
void *code;
|
|
int code_stats[4];
|
|
} codeHandleType;
|
|
|
|
static llBlock *blocks_head = NULL;
|
|
static llBlock *tmpblocks_head = NULL; // used only during compile
|
|
|
|
#define NSEEL_MAX_TEMPSPACE_ENTRIES 8192
|
|
|
|
static int g_evallib_computTableTop; // make it abort on potential overflow =)
|
|
|
|
static int l_stats[4]; // source bytes, static code bytes, call code bytes, data bytes
|
|
|
|
static void *__newBlock(llBlock **start,int size);
|
|
|
|
#define newTmpBlock(x) __newBlock(&tmpblocks_head,x)
|
|
#define newBlock(x) __newBlock(&blocks_head,x)
|
|
|
|
static void freeBlocks(llBlock *start);
|
|
|
|
char *g_evallib_visdata;
|
|
|
|
#define DECL_ASMFUNC(x) \
|
|
void _asm_##x##(void); \
|
|
void _asm_##x##_end(void); \
|
|
|
|
DECL_ASMFUNC(sin)
|
|
DECL_ASMFUNC(cos)
|
|
DECL_ASMFUNC(tan)
|
|
DECL_ASMFUNC(asin)
|
|
DECL_ASMFUNC(acos)
|
|
DECL_ASMFUNC(atan)
|
|
DECL_ASMFUNC(atan2)
|
|
DECL_ASMFUNC(sqr)
|
|
DECL_ASMFUNC(sqrt)
|
|
DECL_ASMFUNC(pow)
|
|
DECL_ASMFUNC(exp)
|
|
DECL_ASMFUNC(log)
|
|
DECL_ASMFUNC(log10)
|
|
DECL_ASMFUNC(abs)
|
|
DECL_ASMFUNC(min)
|
|
DECL_ASMFUNC(min)
|
|
DECL_ASMFUNC(max)
|
|
DECL_ASMFUNC(sig)
|
|
DECL_ASMFUNC(sign)
|
|
DECL_ASMFUNC(rand)
|
|
DECL_ASMFUNC(band)
|
|
DECL_ASMFUNC(bor)
|
|
DECL_ASMFUNC(bnot)
|
|
DECL_ASMFUNC(if)
|
|
DECL_ASMFUNC(equal)
|
|
DECL_ASMFUNC(below)
|
|
DECL_ASMFUNC(above)
|
|
DECL_ASMFUNC(assign)
|
|
DECL_ASMFUNC(add)
|
|
DECL_ASMFUNC(sub)
|
|
DECL_ASMFUNC(mul)
|
|
DECL_ASMFUNC(div)
|
|
DECL_ASMFUNC(mod)
|
|
DECL_ASMFUNC(or)
|
|
DECL_ASMFUNC(and)
|
|
DECL_ASMFUNC(uplus)
|
|
DECL_ASMFUNC(uminus)
|
|
DECL_ASMFUNC(floor)
|
|
DECL_ASMFUNC(ceil)
|
|
DECL_ASMFUNC(invsqrt)
|
|
DECL_ASMFUNC(exec2)
|
|
|
|
DECL_ASMFUNC(getosc)
|
|
DECL_ASMFUNC(getspec)
|
|
DECL_ASMFUNC(gettime)
|
|
DECL_ASMFUNC(getmouse)
|
|
DECL_ASMFUNC(setmousepos)
|
|
|
|
|
|
static functionType fnTable1[36] = {
|
|
{ "if", _asm_if,_asm_if_end, 3 },
|
|
{ "sin", _asm_sin,_asm_sin_end, 1 },
|
|
{ "cos", _asm_cos,_asm_cos_end, 1 },
|
|
{ "tan", _asm_tan,_asm_tan_end, 1 },
|
|
{ "asin", _asm_asin,_asm_asin_end, 1 },
|
|
{ "acos", _asm_acos,_asm_acos_end, 1 },
|
|
{ "atan", _asm_atan,_asm_atan_end, 1 },
|
|
{ "atan2", _asm_atan2,_asm_atan2_end, 2 },
|
|
{ "sqr", _asm_sqr,_asm_sqr_end, 1 },
|
|
{ "sqrt", _asm_sqrt,_asm_sqrt_end, 1 },
|
|
{ "pow", _asm_pow,_asm_pow_end, 2 },
|
|
{ "exp", _asm_exp,_asm_exp_end, 1 },
|
|
{ "log", _asm_log,_asm_log_end, 1 },
|
|
{ "log10", _asm_log10,_asm_log10_end, 1 },
|
|
{ "abs", _asm_abs,_asm_abs_end, 1 },
|
|
{ "min", _asm_min,_asm_min_end, 2 },
|
|
{ "max", _asm_max,_asm_max_end, 2 },
|
|
{ "sigmoid",_asm_sig,_asm_sig_end, 2 } ,
|
|
{ "sign", _asm_sign,_asm_sign_end, 1 } ,
|
|
{ "rand", _asm_rand,_asm_rand_end, 1 } ,
|
|
{ "band", _asm_band,_asm_band_end, 2 } ,
|
|
{ "bor", _asm_bor,_asm_bor_end, 2 } ,
|
|
{ "bnot", _asm_bnot,_asm_bnot_end, 1 } ,
|
|
{ "equal", _asm_equal,_asm_equal_end, 2 },
|
|
{ "below", _asm_below,_asm_below_end, 2 },
|
|
{ "above", _asm_above,_asm_above_end, 2 },
|
|
{ "floor", _asm_floor,_asm_floor_end, 1 },
|
|
{ "ceil", _asm_ceil,_asm_ceil_end, 1 },
|
|
{ "invsqrt", _asm_invsqrt,_asm_invsqrt_end, 1 },
|
|
{ "assign",_asm_assign,_asm_assign_end,2},
|
|
{ "exec2",_asm_exec2,_asm_exec2_end,2},
|
|
// these will be seperated since they are AVS specific
|
|
{ "getosc", _asm_getosc,_asm_getosc_end,3 },
|
|
{ "getspec",_asm_getspec,_asm_getspec_end,3 },
|
|
{ "gettime", _asm_gettime,_asm_gettime_end,1},
|
|
{ "getkbmouse",_asm_getmouse,_asm_getmouse_end,1},
|
|
{ "setmousepos",_asm_setmousepos,_asm_setmousepos_end,2},
|
|
};
|
|
|
|
|
|
functionType *getFunctionFromTable(int idx)
|
|
{
|
|
// todo: add API for adding functions to a seperate table :)
|
|
if (idx<0 || idx>=sizeof(fnTable1)/sizeof(fnTable1[0])) return 0;
|
|
return fnTable1+idx;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
static void *realAddress(void *fn, void *fn_e, int *size)
|
|
{
|
|
#ifdef _DEBUG
|
|
// Debug Mode
|
|
*siiiize=0; // fucko, need to figure this out
|
|
char *ptr = (char *)fn;
|
|
return ptr + (*(int *)(ptr+1))+5;
|
|
#else
|
|
// Release Mode
|
|
*size = (int)fn_e - (int) fn;
|
|
return fn;
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
static void freeBlocks(llBlock *start)
|
|
{
|
|
while (start)
|
|
{
|
|
llBlock *llB = start->next;
|
|
GlobalFree(start);
|
|
start=llB;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
static void *__newBlock(llBlock **start, int size)
|
|
{
|
|
llBlock *llb;
|
|
int alloc_size;
|
|
if (*start && (LLB_DSIZE - (*start)->sizeused) >= size)
|
|
{
|
|
void *t=(*start)->block+(*start)->sizeused;
|
|
(*start)->sizeused+=size;
|
|
return t;
|
|
}
|
|
|
|
alloc_size=sizeof(llBlock);
|
|
if ((int)size > LLB_DSIZE) alloc_size += size - LLB_DSIZE;
|
|
llb = (llBlock *)VirtualAlloc(NULL, alloc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
|
|
// benski> CUT: llb = (llBlock *)GlobalAlloc(GMEM_FIXED,alloc_size); // grab bigger block if absolutely necessary (heh)
|
|
llb->sizeused=size;
|
|
llb->next = *start;
|
|
*start = llb;
|
|
return llb->block;
|
|
}
|
|
|
|
|
|
#define X86_MOV_EAX_DIRECTVALUE 0xB8
|
|
#define X86_MOV_ESI_DIRECTVALUE 0xBE
|
|
#define X86_MOV_ESI_DIRECTMEMVALUE 0x358B
|
|
#define X86_PUSH_EAX 0x50
|
|
#define X86_POP_EBX 0x5B
|
|
#define X86_POP_ECX 0x59
|
|
#define X86_MOV_ESI_EDI 0xF78B
|
|
|
|
#define X86_PUSH_ESI 0x56
|
|
#define X86_POP_ESI 0x5E
|
|
|
|
#define X86_RET 0xC3
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
static int *findFBlock(char *p)
|
|
{
|
|
while (*(int *)p != 0xFFFFFFFF) p++;
|
|
return (int*)p;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
int createCompiledValue(double value, double *addrValue)
|
|
{
|
|
unsigned char *block;
|
|
double *dupValue;
|
|
|
|
block=(unsigned char *)newTmpBlock(4+5);
|
|
|
|
if (addrValue == NULL)
|
|
{
|
|
l_stats[3]+=sizeof(double);
|
|
*(dupValue = (double *)newBlock(sizeof(double))) = value;
|
|
}
|
|
else
|
|
dupValue = addrValue;
|
|
|
|
((int*)block)[0]=5;
|
|
block[4]=X86_MOV_EAX_DIRECTVALUE; // mov eax, <value>
|
|
*(int *)(block+5) = (int)dupValue;
|
|
|
|
return ((int)(block));
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
int getFunctionAddress(int fntype, int fn, int *size)
|
|
{
|
|
switch (fntype)
|
|
{
|
|
case MATH_SIMPLE:
|
|
switch (fn)
|
|
{
|
|
case FN_ASSIGN:
|
|
return (int)realAddress(_asm_assign,_asm_assign_end,size);
|
|
case FN_ADD:
|
|
return (int)realAddress(_asm_add,_asm_add_end,size);
|
|
case FN_SUB:
|
|
return (int)realAddress(_asm_sub,_asm_sub_end,size);
|
|
case FN_MULTIPLY:
|
|
return (int)realAddress(_asm_mul,_asm_mul_end,size);
|
|
case FN_DIVIDE:
|
|
return (int)realAddress(_asm_div,_asm_div_end,size);
|
|
case FN_MODULO:
|
|
return (int)realAddress(_asm_mod,_asm_mod_end,size);
|
|
case FN_AND:
|
|
return (int)realAddress(_asm_and,_asm_and_end,size);
|
|
case FN_OR:
|
|
return (int)realAddress(_asm_or,_asm_or_end,size);
|
|
case FN_UPLUS:
|
|
return (int)realAddress(_asm_uplus,_asm_uplus_end,size);
|
|
case FN_UMINUS:
|
|
return (int)realAddress(_asm_uminus,_asm_uminus_end,size);
|
|
}
|
|
case MATH_FN:
|
|
{
|
|
functionType *p=getFunctionFromTable(fn);
|
|
if (!p)
|
|
{
|
|
if (size) *size=0;
|
|
return 0;
|
|
}
|
|
return (int)realAddress(p->afunc,p->func_e,size);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
int createCompiledFunction3(int fntype, int fn, int code1, int code2, int code3)
|
|
{
|
|
int sizes1=((int *)code1)[0];
|
|
int sizes2=((int *)code2)[0];
|
|
int sizes3=((int *)code3)[0];
|
|
|
|
if (fntype == MATH_FN && fn == 0) // special case: IF
|
|
{
|
|
void *func3;
|
|
int size;
|
|
int *ptr;
|
|
char *block;
|
|
|
|
unsigned char *newblock2,*newblock3;
|
|
|
|
newblock2=newBlock(sizes2+1);
|
|
memcpy(newblock2,(char*)code2+4,sizes2);
|
|
newblock2[sizes2]=X86_RET;
|
|
|
|
newblock3=newBlock(sizes3+1);
|
|
memcpy(newblock3,(char*)code3+4,sizes3);
|
|
newblock3[sizes3]=X86_RET;
|
|
|
|
l_stats[2]+=sizes2+sizes3+2;
|
|
|
|
func3 = realAddress(_asm_if,_asm_if_end,&size);
|
|
|
|
block=(char *)newTmpBlock(4+sizes1+size);
|
|
((int*)block)[0]=sizes1+size;
|
|
memcpy(block+4,(char*)code1+4,sizes1);
|
|
ptr=(int *)(block+4+sizes1);
|
|
memcpy(ptr,func3,size);
|
|
|
|
ptr=findFBlock((char*)ptr); *ptr++=(int)newblock2;
|
|
ptr=findFBlock((char*)ptr); *ptr=(int)newblock3;
|
|
|
|
return (int)block;
|
|
|
|
}
|
|
else
|
|
{
|
|
int size2;
|
|
unsigned char *block;
|
|
unsigned char *outp;
|
|
|
|
int myfunc;
|
|
|
|
myfunc = getFunctionAddress(fntype, fn, &size2);
|
|
|
|
block=(unsigned char *)newTmpBlock(4+size2+sizes1+sizes2+sizes3+4);
|
|
|
|
((int*)block)[0]=4+size2+sizes1+sizes2+sizes3;
|
|
outp=block+4;
|
|
memcpy(outp,(char*)code1+4,sizes1);
|
|
outp+=sizes1;
|
|
*outp++ = X86_PUSH_EAX;
|
|
memcpy(outp,(char*)code2+4,sizes2);
|
|
outp+=sizes2;
|
|
*outp++ = X86_PUSH_EAX;
|
|
memcpy(outp,(char*)code3+4,sizes3);
|
|
outp+=sizes3;
|
|
*outp++ = X86_POP_EBX;
|
|
*outp++ = X86_POP_ECX;
|
|
|
|
memcpy(block+4+4+sizes1+sizes2+sizes3,(void*)myfunc,size2);
|
|
g_evallib_computTableTop++;
|
|
|
|
return ((int)(block));
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
int createCompiledFunction2(int fntype, int fn, int code1, int code2)
|
|
{
|
|
int size2;
|
|
unsigned char *block;
|
|
unsigned char *outp;
|
|
|
|
int myfunc;
|
|
int sizes1=((int *)code1)[0];
|
|
int sizes2=((int *)code2)[0];
|
|
|
|
myfunc = getFunctionAddress(fntype, fn, &size2);
|
|
|
|
block=(unsigned char *)newTmpBlock(2+size2+sizes1+sizes2+4);
|
|
|
|
((int*)block)[0]=2+size2+sizes1+sizes2;
|
|
outp=block+4;
|
|
memcpy(outp,(char*)code1+4,sizes1);
|
|
outp+=sizes1;
|
|
*outp++ = X86_PUSH_EAX;
|
|
memcpy(outp,(char*)code2+4,sizes2);
|
|
outp+=sizes2;
|
|
*outp++ = X86_POP_EBX;
|
|
|
|
memcpy(block+4+2+sizes1+sizes2,(void*)myfunc,size2);
|
|
|
|
g_evallib_computTableTop++;
|
|
|
|
return ((int)(block));
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
int createCompiledFunction1(int fntype, int fn, int code)
|
|
{
|
|
int size,size2;
|
|
char *block;
|
|
int myfunc;
|
|
void *func1;
|
|
|
|
size =((int *)code)[0];
|
|
func1 = (void *)(code+4);
|
|
|
|
myfunc = getFunctionAddress(fntype, fn, &size2);
|
|
|
|
block=(char *)newTmpBlock(4+size+size2);
|
|
((int*)block)[0]=size+size2;
|
|
|
|
memcpy(block+4, func1, size);
|
|
memcpy(block+size+4,(void*)myfunc,size2);
|
|
|
|
g_evallib_computTableTop++;
|
|
|
|
return ((int)(block));
|
|
}
|
|
|
|
static char *preprocessCode(char *expression)
|
|
{
|
|
int len=0;
|
|
int alloc_len=strlen(expression)+1+64;
|
|
char *buf=(char *)malloc(alloc_len);
|
|
|
|
while (*expression)
|
|
{
|
|
if (len > alloc_len-32)
|
|
{
|
|
alloc_len = len+128;
|
|
buf=(char*)realloc(buf,alloc_len);
|
|
}
|
|
|
|
if (expression[0] == '/')
|
|
{
|
|
if (expression[1] == '/')
|
|
{
|
|
expression+=2;
|
|
while (expression[0] && expression[0] != '\r' && expression[0] != '\n') expression++;
|
|
}
|
|
else if (expression[1] == '*')
|
|
{
|
|
expression+=2;
|
|
while (expression[0] && (expression[0] != '*' || expression[1] != '/')) expression++;
|
|
if (expression[0]) expression+=2; // at this point we KNOW expression[0]=* and expression[1]=/
|
|
}
|
|
else
|
|
{
|
|
char c=buf[len++]=*expression++;
|
|
if (c != ' ' && c != '\t' && c != '\r' && c != '\n') l_stats[0]++;
|
|
}
|
|
}
|
|
else if (expression[0] == '$')
|
|
{
|
|
if (toupper(expression[1]) == 'P' && toupper(expression[2]) == 'I')
|
|
{
|
|
static char *str="3.141592653589793";
|
|
expression+=3;
|
|
memcpy(buf+len,str,17);
|
|
len+=17; //strlen(str);
|
|
l_stats[0]+=17;
|
|
}
|
|
else if (toupper(expression[1]) == 'E')
|
|
{
|
|
static char *str="2.71828183";
|
|
expression+=2;
|
|
memcpy(buf+len,str,10);
|
|
len+=10; //strlen(str);
|
|
l_stats[0]+=10;
|
|
}
|
|
if (toupper(expression[1]) == 'P' && toupper(expression[2]) == 'H' && toupper(expression[3]) == 'I')
|
|
{
|
|
static char *str="1.61803399";
|
|
expression+=4;
|
|
memcpy(buf+len,str,10);
|
|
len+=10; //strlen(str);
|
|
l_stats[0]+=10;
|
|
}
|
|
else
|
|
{
|
|
char c = buf[len++]=*expression++;
|
|
if (c != ' ' && c != '\t' && c != '\r' && c != '\n') l_stats[0]++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char c=*expression++;
|
|
if (c == '\r' || c == '\n' || c == '\t') c=' ';
|
|
buf[len++]=c;
|
|
if (c != ' ') l_stats[0]++;
|
|
}
|
|
}
|
|
buf[len]=0;
|
|
|
|
return buf;
|
|
}
|
|
|
|
int g_log_errors;
|
|
|
|
static void movestringover(char *str, int amount)
|
|
{
|
|
char tmp[1024+8];
|
|
|
|
int l=(int)strlen(str);
|
|
l=min(1024-amount-1,l);
|
|
|
|
memcpy(tmp,str,l+1);
|
|
|
|
while (l >= 0 && tmp[l]!='\n') l--;
|
|
l++;
|
|
|
|
tmp[l]=0;//ensure we null terminate
|
|
|
|
memcpy(str+amount,tmp,l+1);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
int compileCode(char *_expression)
|
|
{
|
|
char *expression,*expression_start;
|
|
int computable_size=0;
|
|
codeHandleType *handle;
|
|
startPtr *scode=NULL;
|
|
startPtr *startpts=NULL;
|
|
|
|
if (!_expression || !*_expression) return 0;
|
|
if (!varTable) return 0;
|
|
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
EnterCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
|
|
blocks_head=0;
|
|
tmpblocks_head=0;
|
|
memset(l_stats,0,sizeof(l_stats));
|
|
|
|
handle = (codeHandleType*)newBlock(sizeof(codeHandleType));
|
|
|
|
if (!handle)
|
|
{
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
LeaveCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
memset(handle,0,sizeof(codeHandleType));
|
|
|
|
expression_start=expression=preprocessCode(_expression);
|
|
|
|
while (*expression)
|
|
{
|
|
startPtr *tmp;
|
|
char *expr;
|
|
colCount=0;
|
|
|
|
// single out segment
|
|
while (*expression == ';' || *expression == ' ') expression++;
|
|
if (!*expression) break;
|
|
expr=expression;
|
|
while (*expression && *expression != ';') expression++;
|
|
if (*expression) *expression++ = 0;
|
|
|
|
// parse
|
|
tmp=(startPtr*) newTmpBlock(sizeof(startPtr));
|
|
if (!tmp) break;
|
|
g_evallib_computTableTop=0;
|
|
tmp->startptr=compileExpression(expr);
|
|
if (computable_size < g_evallib_computTableTop)
|
|
{
|
|
computable_size=g_evallib_computTableTop;
|
|
}
|
|
|
|
if (g_evallib_computTableTop > NSEEL_MAX_TEMPSPACE_ENTRIES-32)
|
|
{
|
|
tmp->startptr=0; // overflow in this mode
|
|
}
|
|
|
|
if (!tmp->startptr)
|
|
{
|
|
if (g_log_errors)
|
|
{
|
|
int l=strlen(expr);
|
|
if (l > 512) l=512;
|
|
movestringover(last_error_string,l+2);
|
|
memcpy(last_error_string,expr,l);
|
|
last_error_string[l]='\r';
|
|
last_error_string[l+1]='\n';
|
|
}
|
|
|
|
scode=NULL;
|
|
break;
|
|
}
|
|
tmp->next=NULL;
|
|
if (!scode) scode=startpts=tmp;
|
|
else
|
|
{
|
|
scode->next=tmp;
|
|
scode=tmp;
|
|
}
|
|
}
|
|
|
|
// check to see if failed on the first startingCode
|
|
if (!scode)
|
|
{
|
|
freeBlocks(blocks_head); // free blocks
|
|
handle=NULL; // return NULL (after resetting blocks_head)
|
|
}
|
|
else
|
|
{
|
|
// now we build one big code segment out of our list of them, inserting a mov esi, computable before each item
|
|
unsigned char *writeptr;
|
|
int size=1; // for ret at end :)
|
|
startPtr *p;
|
|
p=startpts;
|
|
while (p)
|
|
{
|
|
size+=2; // mov esi, edi
|
|
size+=*(int *)p->startptr;
|
|
p=p->next;
|
|
}
|
|
handle->code = newBlock(size);
|
|
if (handle->code)
|
|
{
|
|
writeptr=(unsigned char *)handle->code;
|
|
p=startpts;
|
|
while (p)
|
|
{
|
|
int thissize=*(int *)p->startptr;
|
|
*(unsigned short *)writeptr= X86_MOV_ESI_EDI;
|
|
writeptr+=2;
|
|
memcpy(writeptr,(char*)p->startptr + 4,thissize);
|
|
writeptr += thissize;
|
|
|
|
p=p->next;
|
|
}
|
|
*writeptr=X86_RET; // ret
|
|
l_stats[1]=size;
|
|
}
|
|
handle->blocks = blocks_head;
|
|
handle->workTablePtr_size=(computable_size+4) * sizeof(double);
|
|
}
|
|
freeBlocks(tmpblocks_head); // free blocks
|
|
tmpblocks_head=0;
|
|
|
|
blocks_head=0;
|
|
|
|
if (handle)
|
|
{
|
|
memcpy(handle->code_stats,l_stats,sizeof(l_stats));
|
|
g_evallib_stats[0]+=l_stats[0];
|
|
g_evallib_stats[1]+=l_stats[1];
|
|
g_evallib_stats[2]+=l_stats[2];
|
|
g_evallib_stats[3]+=l_stats[3];
|
|
g_evallib_stats[4]++;
|
|
}
|
|
memset(l_stats,0,sizeof(l_stats));
|
|
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
LeaveCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
|
|
free(expression_start);
|
|
|
|
return (int)handle;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
void executeCode(int handle, char visdata[2][2][576])
|
|
{
|
|
#ifdef NSEEL_REENTRANT_EXECUTION
|
|
int baseptr;
|
|
#else
|
|
static double _tab[NSEEL_MAX_TEMPSPACE_ENTRIES];
|
|
int baseptr = (int) _tab;
|
|
#endif
|
|
codeHandleType *h = (codeHandleType *)handle;
|
|
if (!h || !h->code) return;
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
EnterCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
g_evallib_visdata=(char*)visdata;
|
|
#ifdef NSEEL_REENTRANT_EXECUTION
|
|
baseptr = (int) alloca(h->workTablePtr_size);
|
|
if (!baseptr) return;
|
|
#endif
|
|
{
|
|
int startPoint=(int)h->code;
|
|
__asm
|
|
{
|
|
mov ebx, baseptr
|
|
mov eax, startPoint
|
|
pushad // Lets cover our ass
|
|
mov edi, ebx
|
|
call eax
|
|
popad
|
|
}
|
|
}
|
|
g_evallib_visdata=NULL;
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
LeaveCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
void freeCode(int handle)
|
|
{
|
|
codeHandleType *h = (codeHandleType *)handle;
|
|
if (h != NULL)
|
|
{
|
|
g_evallib_stats[0]-=h->code_stats[0];
|
|
g_evallib_stats[1]-=h->code_stats[1];
|
|
g_evallib_stats[2]-=h->code_stats[2];
|
|
g_evallib_stats[3]-=h->code_stats[3];
|
|
g_evallib_stats[4]--;
|
|
freeBlocks(h->blocks);
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
void resetVars(varType *vars)
|
|
{
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
if (vars) EnterCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
varTable=vars;
|
|
#ifdef NSEEL_USE_CRITICAL_SECTION
|
|
if (!vars) LeaveCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
|
|
#endif
|
|
}
|