Initial community commit

1 files changed, 946 insertions, 0 deletions

diff --git a/Src/ns-eel/nseel-compiler.c b/Src/ns-eel/nseel-compiler.c
new file mode 100644
index 00000000..eb25ec5c
--- /dev/null
+++ b/Src/ns-eel/nseel-compiler.c
@@ -0,0 +1,946 @@
+/*
+  Nullsoft Expression Evaluator Library (NS-EEL)
+  Copyright (C) 1999-2003 Nullsoft, Inc.
+  
+  nseel-compiler.c
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#include <windows.h>
+#include "ns-eel-int.h"
+
+#ifdef NSEEL_REENTRANT_EXECUTION
+#include <malloc.h>
+#endif
+
+#define ltoupper(x) ((char)CharUpper((LPSTR)x))
+static int nseel_evallib_stats[5]; // source bytes, static code bytes, call code bytes, data bytes, segments
+int *NSEEL_getstats()
+{
+  return nseel_evallib_stats;
+}
+double *NSEEL_getglobalregs()
+{
+  return nseel_globalregs;
+}
+
+static size_t LLB_DSIZE=0;
+//#define LLB_DSIZE (65536-64)
+typedef struct _llBlockHeader
+{
+  struct _llBlock *next;
+  size_t sizeused;
+} llBlockHeader;
+
+typedef struct _llBlock {
+	llBlockHeader header;
+	char block[1];
+} llBlock;
+
+typedef struct _startPtr {
+  struct _startPtr *next;
+  void *startptr;
+} startPtr;
+
+
+
+typedef struct {
+  int workTablePtr_size;
+
+  llBlock *blocks;
+  void *code;
+  int code_stats[4];
+} codeHandleType;
+
+#ifndef NSEEL_MAX_TEMPSPACE_ENTRIES
+#define NSEEL_MAX_TEMPSPACE_ENTRIES 2048
+#endif
+
+static void *__newBlock(llBlock **start,size_t size);
+
+#define newTmpBlock(x) __newBlock((llBlock **)&ctx->tmpblocks_head,x)
+#define newBlock(x) __newBlock((llBlock **)&ctx->blocks_head,x)
+
+static void freeBlocks(llBlock *start);
+
+void nseel_asm_sin(void);
+void nseel_asm_sin_end(void);
+void nseel_asm_cos(void);
+void nseel_asm_cos_end(void);
+void nseel_asm_tan(void);
+void nseel_asm_tan_end(void);
+void nseel_asm_asin(void);
+void nseel_asm_asin_end(void);
+void nseel_asm_acos(void);
+void nseel_asm_acos_end(void);
+void nseel_asm_atan(void);
+void nseel_asm_atan_end(void);
+void nseel_asm_atan2(void);
+void nseel_asm_atan2_end(void);
+void nseel_asm_sqr(void);
+void nseel_asm_sqr_end(void);
+
+void nseel_asm_sqrt(void);
+void nseel_asm_sqrt_end(void);
+void nseel_asm_pow(void);
+void nseel_asm_pow_end(void);
+void nseel_asm_exp(void);
+void nseel_asm_exp_end(void);
+void nseel_asm_log(void);
+void nseel_asm_log_end(void);
+void nseel_asm_log10(void);
+void nseel_asm_log10_end(void);
+void nseel_asm_abs(void);
+void nseel_asm_abs_end(void);
+void nseel_asm_min(void);
+void nseel_asm_min_end(void);
+void nseel_asm_max(void);
+void nseel_asm_max_end(void);
+void nseel_asm_sig(void);
+void nseel_asm_sig_end(void);
+void nseel_asm_sign(void);
+void nseel_asm_sign_end(void);
+void nseel_asm_rand(void);
+void nseel_asm_rand_end(void);
+void nseel_asm_band(void);
+void nseel_asm_band_end(void);
+void nseel_asm_bor(void);
+void nseel_asm_bor_end(void);
+void nseel_asm_bnot(void);
+void nseel_asm_bnot_end(void);
+void nseel_asm_if(void);
+void nseel_asm_if_end(void);
+void nseel_asm_repeat(void);
+void nseel_asm_repeat_end(void);
+void nseel_asm_equal(void);
+void nseel_asm_equal_end(void);
+void nseel_asm_below(void);
+void nseel_asm_below_end(void);
+void nseel_asm_above(void);
+void nseel_asm_above_end(void);
+void nseel_asm_assign(void);
+void nseel_asm_assign_end(void);
+void nseel_asm_add(void);
+void nseel_asm_add_end(void);
+void nseel_asm_sub(void);
+void nseel_asm_sub_end(void);
+void nseel_asm_mul(void);
+void nseel_asm_mul_end(void);
+void nseel_asm_div(void);
+void nseel_asm_div_end(void);
+void nseel_asm_mod(void);
+void nseel_asm_mod_end(void);
+void nseel_asm_or(void);
+void nseel_asm_or_end(void);
+void nseel_asm_and(void);
+void nseel_asm_and_end(void);
+void nseel_asm_uplus(void);
+void nseel_asm_uplus_end(void);
+void nseel_asm_uminus(void);
+void nseel_asm_uminus_end(void);
+void nseel_asm_floor(void);
+void nseel_asm_floor_end(void);
+void nseel_asm_ceil(void);
+void nseel_asm_ceil_end(void);
+void nseel_asm_invsqrt(void);
+void nseel_asm_invsqrt_end(void);
+void nseel_asm_exec2(void);
+void nseel_asm_exec2_end(void);
+
+/*
+#define DECL_ASMFUNC(x)         \
+  void nseel_asm_##x##(void);        \
+  void nseel_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(repeat)
+  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)
+*/
+
+static functionType fnTable1[] = {
+													 { "if",     nseel_asm_if,nseel_asm_if_end,    3 },
+#ifdef NSEEL_LOOPFUNC_SUPPORT
+													 { "loop", nseel_asm_repeat,nseel_asm_repeat_end, 2 },
+#endif
+                           { "sin",   nseel_asm_sin,nseel_asm_sin_end,   1 },
+                           { "cos",    nseel_asm_cos,nseel_asm_cos_end,   1 },
+                           { "tan",    nseel_asm_tan,nseel_asm_tan_end,   1 },
+                           { "asin",   nseel_asm_asin,nseel_asm_asin_end,  1 },
+                           { "acos",   nseel_asm_acos,nseel_asm_acos_end,  1 },
+                           { "atan",   nseel_asm_atan,nseel_asm_atan_end,  1 },
+                           { "atan2",  nseel_asm_atan2,nseel_asm_atan2_end, 2 },
+                           { "sqr",    nseel_asm_sqr,nseel_asm_sqr_end,   1 },
+                           { "sqrt",   nseel_asm_sqrt,nseel_asm_sqrt_end,  1 },
+                           { "pow",    nseel_asm_pow,nseel_asm_pow_end,   2 },
+                           { "exp",    nseel_asm_exp,nseel_asm_exp_end,   1 },
+                           { "log",    nseel_asm_log,nseel_asm_log_end,   1 },
+                           { "log10",  nseel_asm_log10,nseel_asm_log10_end, 1 },
+                           { "abs",    nseel_asm_abs,nseel_asm_abs_end,   1 },
+                           { "min",    nseel_asm_min,nseel_asm_min_end,   2 },
+                           { "max",    nseel_asm_max,nseel_asm_max_end,   2 },
+													 { "sigmoid",nseel_asm_sig,nseel_asm_sig_end,   2 } ,
+													 { "sign",   nseel_asm_sign,nseel_asm_sign_end,  1 } ,
+													 { "rand",   nseel_asm_rand,nseel_asm_rand_end,  1 } ,
+													 { "band",   nseel_asm_band,nseel_asm_band_end,  2 } ,
+													 { "bor",    nseel_asm_bor,nseel_asm_bor_end,   2 } ,
+													 { "bnot",   nseel_asm_bnot,nseel_asm_bnot_end,  1 } ,
+													 { "equal",  nseel_asm_equal,nseel_asm_equal_end, 2 },
+													 { "below",  nseel_asm_below,nseel_asm_below_end, 2 },
+													 { "above",  nseel_asm_above,nseel_asm_above_end, 2 },
+                           { "floor",  nseel_asm_floor,nseel_asm_floor_end, 1 },
+                           { "ceil",   nseel_asm_ceil,nseel_asm_ceil_end,  1 },
+                           { "invsqrt",   nseel_asm_invsqrt,nseel_asm_invsqrt_end,  1 },
+                           { "assign",nseel_asm_assign,nseel_asm_assign_end,2},
+                           { "exec2",nseel_asm_exec2,nseel_asm_exec2_end,2},
+                           { "exec3",nseel_asm_exec2,nseel_asm_exec2_end,3},
+                           };
+
+static functionType *fnTableUser;
+static int fnTableUser_size;
+
+functionType *nseel_getFunctionFromTable(int idx)
+{
+  if (idx<0) return 0;
+  if (idx>=sizeof(fnTable1)/sizeof(fnTable1[0]))
+  {
+    idx -= sizeof(fnTable1)/sizeof(fnTable1[0]);
+    if (!fnTableUser || idx >= fnTableUser_size) return 0;
+    return fnTableUser+idx;
+  }
+  return fnTable1+idx;
+}
+
+int NSEEL_init() // returns 0 on success
+{
+  NSEEL_quit();
+  return 0;
+}
+
+void NSEEL_addfunctionex(char *name, int nparms, int code_startaddr, int code_len, void *pproc)
+{
+  if (!fnTableUser || !(fnTableUser_size&7))
+  {
+    fnTableUser=(functionType *)realloc(fnTableUser,(fnTableUser_size+8)*sizeof(functionType));
+  }
+  if (fnTableUser)
+  {
+    fnTableUser[fnTableUser_size].nParams = nparms;
+    fnTableUser[fnTableUser_size].name = name;
+    fnTableUser[fnTableUser_size].afunc = (void *)code_startaddr;
+    fnTableUser[fnTableUser_size].func_e = (void *)(code_startaddr + code_len);
+    fnTableUser[fnTableUser_size].pProc = (NSEEL_PPPROC) pproc;
+    fnTableUser_size++;
+  }
+}
+
+void NSEEL_quit()
+{
+  free(fnTableUser);
+  fnTableUser_size=0;
+  fnTableUser=0;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static void *realAddress(void *fn, void *fn_e, int *size)
+{
+#ifdef DISABLED_DEBUG
+  char *ptr = (char *)fn;
+  int beg=(*(int *)(ptr+1))+5;
+
+  int extrasize=(int)nseel_asm_exec2_end - (int)nseel_asm_exec2;
+  int extrabeg=(*(int *)(((char *)nseel_asm_exec2)+1))+5;
+
+  *size=((int)fn_e - (int)fn) - (extrasize-extrabeg) - beg;
+  return ptr + beg;
+#else
+  // Release Mode
+  *size  = (int)fn_e - (int) fn;
+	return fn;
+#endif
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static void freeBlocks(llBlock *start)
+{
+  while (start)
+	{
+    llBlock *llB = start->header.next;
+    VirtualFree(start, 0 /*LLB_DSIZE*/, MEM_RELEASE);
+	 start=llB;
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static void *__newBlock(llBlock **start, size_t size)
+{
+  llBlock *llb = NULL;
+  size_t alloc_size = 0;
+	if (!LLB_DSIZE)
+	{
+		SYSTEM_INFO systemInfo;
+		GetSystemInfo(&systemInfo);
+		LLB_DSIZE = systemInfo.dwAllocationGranularity;
+	}
+
+  if (*start && (LLB_DSIZE - (*start)->header.sizeused) >= size)
+  {
+    void *t=(*start)->block+(*start)->header.sizeused;
+    (*start)->header.sizeused+=size;
+    return t;
+  }
+
+  alloc_size=LLB_DSIZE;
+	size+=sizeof(llBlockHeader); // make sure we have enough room for the block header;
+  while (size > alloc_size) alloc_size += LLB_DSIZE;
+  llb = (llBlock *)VirtualAlloc(NULL, alloc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+  llb->header.sizeused=size;
+  llb->header.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 nseel_createCompiledValue(compileContext *ctx, double value, double *addrValue)
+{
+  unsigned char *block = NULL;
+  double *dupValue = NULL;
+
+  block=(unsigned char *)newTmpBlock(4+5);
+
+  if (addrValue == NULL)
+  {
+    ctx->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));
+
+}
+
+//---------------------------------------------------------------------------------------------------------------
+static int nseel_getFunctionAddress(int fntype, int fn, int *size, NSEEL_PPPROC *pProc)
+{
+  *pProc = NULL;
+  switch (fntype)
+	{
+  	case MATH_SIMPLE:
+	  	switch (fn)
+			{
+			  case FN_ASSIGN:
+				  return (int)realAddress(nseel_asm_assign,nseel_asm_assign_end,size);
+			  case FN_ADD:
+				  return (int)realAddress(nseel_asm_add,nseel_asm_add_end,size);
+			  case FN_SUB:
+				  return (int)realAddress(nseel_asm_sub,nseel_asm_sub_end,size);
+			  case FN_MULTIPLY:
+				  return (int)realAddress(nseel_asm_mul,nseel_asm_mul_end,size);
+			  case FN_DIVIDE:
+				  return (int)realAddress(nseel_asm_div,nseel_asm_div_end,size);
+			  case FN_MODULO:
+				  return (int)realAddress(nseel_asm_mod,nseel_asm_mod_end,size);
+			  case FN_AND:
+				  return (int)realAddress(nseel_asm_and,nseel_asm_and_end,size);
+			  case FN_OR:
+				  return (int)realAddress(nseel_asm_or,nseel_asm_or_end,size);
+			  case FN_UPLUS:
+				  return (int)realAddress(nseel_asm_uplus,nseel_asm_uplus_end,size);
+			  case FN_UMINUS:
+				  return (int)realAddress(nseel_asm_uminus,nseel_asm_uminus_end,size);
+			}
+	  case MATH_FN:
+      {
+        functionType *p=nseel_getFunctionFromTable(fn);
+		    if (!p) 
+        {
+          if (size) *size=0;
+          return 0;
+        }
+        if (p->pProc) *pProc=p->pProc;
+        return (int)realAddress(p->afunc,p->func_e,size);
+      }
+	}		
+  return 0;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+int nseel_createCompiledFunction3(compileContext *ctx, 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 = NULL;
+    int size = 0;
+    int *ptr = NULL;
+    char *block = NULL;
+
+    unsigned char *newblock2,*newblock3 = NULL;
+
+    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;
+
+    ctx->l_stats[2]+=sizes2+sizes3+2;
+    
+    func3 = realAddress(nseel_asm_if,nseel_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;
+    ctx->computTableTop++;
+
+    return (int)block;
+
+  }
+  else
+  {
+    int size2 = 0;
+    unsigned char *block = NULL;
+    unsigned char *outp = NULL;
+
+    int myfunc = 0;
+    NSEEL_PPPROC preProc;
+  
+    myfunc = nseel_getFunctionAddress(fntype, fn, &size2, &preProc);
+
+    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(outp,(void*)myfunc,size2);
+    if (preProc) preProc(outp,size2,ctx->userfunc_data);
+
+    ctx->computTableTop++;
+
+    return ((int)(block));  
+  }
+}
+
+//---------------------------------------------------------------------------------------------------------------
+int nseel_createCompiledFunction2(compileContext *ctx, int fntype, int fn, int code1, int code2)
+{
+  int size2 = 0;
+  unsigned char *block = NULL;
+  unsigned char *outp = NULL;
+  int myfunc = 0;
+  int sizes1=((int *)code1)[0];
+  int sizes2=((int *)code2)[0];
+
+#ifdef NSEEL_LOOPFUNC_SUPPORT
+  if (fntype == MATH_FN && fn == 1) // special case: REPEAT
+  {
+    void *func3 = NULL;
+    int size = 0;
+    int *ptr = NULL;
+    char *block = NULL;
+
+    unsigned char *newblock2 = NULL;
+
+    newblock2=newBlock(sizes2+1);
+    memcpy(newblock2,(char*)code2+4,sizes2);
+    newblock2[sizes2]=X86_RET;
+
+    ctx->l_stats[2]+=sizes2+2;
+    
+    func3 = realAddress(nseel_asm_repeat,nseel_asm_repeat_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;
+
+    ctx->computTableTop++;
+    return (int)block;
+  }
+  else
+#endif
+  {
+    NSEEL_PPPROC preProc;
+    myfunc = nseel_getFunctionAddress(fntype, fn, &size2,&preProc);
+
+    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(outp,(void*)myfunc,size2);
+    if (preProc) preProc(outp,size2,ctx->userfunc_data);
+
+    ctx->computTableTop++;
+
+    return ((int)(block));
+  }
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+int nseel_createCompiledFunction1(compileContext *ctx, int fntype, int fn, int code)
+{
+  NSEEL_PPPROC preProc;
+  int size,size2 = 0;
+  char *block = NULL;
+  int myfunc = 0;
+  void *func1 = NULL;
+  
+  size =((int *)code)[0];
+  func1 = (void *)(code+4);
+  
+  myfunc = nseel_getFunctionAddress(fntype, fn, &size2,&preProc);
+
+  block=(char *)newTmpBlock(4+size+size2);
+  ((int*)block)[0]=size+size2;
+
+  memcpy(block+4, func1, size);
+  memcpy(block+size+4,(void*)myfunc,size2);
+  if (preProc) preProc(block+size+4,size2,ctx->userfunc_data);
+
+  ctx->computTableTop++;
+
+  return ((int)(block));
+}
+
+static char *preprocessCode(compileContext *ctx, 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') ctx->l_stats[0]++;
+      }
+    }
+    else if (expression[0] == '$')
+    {
+      if (ltoupper(expression[1]) == 'P' && ltoupper(expression[2]) == 'I')
+      {
+        static char *str="3.141592653589793";
+        expression+=3;
+        memcpy(buf+len,str,17);
+        len+=17; //strlen(str);
+        ctx->l_stats[0]+=17;
+      }
+      else if (ltoupper(expression[1]) == 'E')
+      {
+        static char *str="2.71828183";
+        expression+=2;
+        memcpy(buf+len,str,10);
+        len+=10; //strlen(str);
+        ctx->l_stats[0]+=10;
+      }
+      if (ltoupper(expression[1]) == 'P' && ltoupper(expression[2]) == 'H' && ltoupper(expression[3]) == 'I')
+      {
+        static char *str="1.61803399";
+        expression+=4;
+        memcpy(buf+len,str,10);
+        len+=10; //strlen(str);
+        ctx->l_stats[0]+=10;
+      }
+      else 
+      {
+        char c = buf[len++]=*expression++;
+        if (c != ' ' && c != '\t' && c != '\r' && c != '\n') ctx->l_stats[0]++;
+      }
+    }
+    else
+    {
+      char c=*expression++;
+      if (c == '\r' || c == '\n' || c == '\t') c=' ';
+      buf[len++]=c;
+      if (c != ' ') ctx->l_stats[0]++;
+    }
+  }
+  buf[len]=0;
+
+  return buf;
+}
+
+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);
+}
+
+//------------------------------------------------------------------------------
+NSEEL_CODEHANDLE NSEEL_code_compile(NSEEL_VMCTX _ctx, char *_expression)
+{
+  compileContext *ctx = (compileContext *)_ctx;
+  char *expression,*expression_start;
+  int computable_size=0;
+  codeHandleType *handle;
+  startPtr *scode=NULL;
+  startPtr *startpts=NULL;
+
+  if (!ctx || !_expression || !*_expression) return 0;
+
+  ctx->last_error_string[0]=0;
+  ctx->blocks_head=0;
+  ctx->tmpblocks_head=0;
+  memset(ctx->l_stats,0, sizeof(ctx->l_stats) / sizeof(ctx->l_stats[0]));
+
+  handle = (codeHandleType*)newBlock(sizeof(codeHandleType));
+
+  if (!handle) 
+  {
+    return 0;
+  }
+  
+  memset(handle,0,sizeof(codeHandleType));
+
+  expression_start=expression=preprocessCode(ctx,_expression);
+
+  while (*expression)
+	{
+    startPtr *tmp;
+    char *expr;
+    ctx->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;
+    ctx->computTableTop=0;
+    tmp->startptr=nseel_compileExpression(ctx,expr);
+
+    if (ctx->computTableTop > NSEEL_MAX_TEMPSPACE_ENTRIES- /* safety */ 16 - /* alignment */4 ||
+        !tmp->startptr) 
+    { 
+      lstrcpyn(ctx->last_error_string,expr,sizeof(ctx->last_error_string)/sizeof(ctx->last_error_string[0]));
+      scode=NULL; 
+      break; 
+    }
+    if (computable_size < ctx->computTableTop)
+    {
+      computable_size=ctx->computTableTop;
+    }
+
+    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((llBlock *)ctx->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
+      ctx->l_stats[1]=size;
+    }
+    handle->blocks = ctx->blocks_head;
+    handle->workTablePtr_size=(computable_size) * sizeof(double);
+  }
+  freeBlocks((llBlock *)ctx->tmpblocks_head);  // free blocks
+  ctx->tmpblocks_head=0;
+
+  ctx->blocks_head=0;
+
+  if (handle)
+  {
+    memcpy(handle->code_stats,ctx->l_stats,sizeof(ctx->l_stats));
+    nseel_evallib_stats[0]+=ctx->l_stats[0];
+    nseel_evallib_stats[1]+=ctx->l_stats[1];
+    nseel_evallib_stats[2]+=ctx->l_stats[2];
+    nseel_evallib_stats[3]+=ctx->l_stats[3];
+    nseel_evallib_stats[4]++;
+  }
+  memset(ctx->l_stats,0,sizeof(ctx->l_stats));
+
+  free(expression_start);
+
+  return (NSEEL_CODEHANDLE)handle;
+}
+
+//------------------------------------------------------------------------------
+void NSEEL_code_execute(NSEEL_CODEHANDLE code)
+{
+#ifdef NSEEL_REENTRANT_EXECUTION
+  int baseptr;
+#else
+  static double _tab[NSEEL_MAX_TEMPSPACE_ENTRIES];
+  int baseptr = (int) _tab;
+#endif
+  codeHandleType *h = (codeHandleType *)code;
+
+  if (!h || !h->code)
+      return;
+
+#ifdef NSEEL_REENTRANT_EXECUTION
+  baseptr = (int) alloca(h->workTablePtr_size + 16*sizeof(double) /*safety*/ + 32 /*alignment*/);
+
+  if (!baseptr)
+      return;
+#endif
+
+  {
+    int startPoint=(int)h->code;
+    __asm 
+    {
+      mov ebx, baseptr
+      mov eax, startPoint
+      pushad // Lets cover our ass
+      add ebx, 31
+      and ebx, ~31
+      mov edi, ebx
+      call eax
+      popad
+    }
+  }
+}
+
+char *NSEEL_code_getcodeerror(NSEEL_VMCTX ctx)
+{
+  compileContext *c=(compileContext *)ctx;
+  if (ctx && c->last_error_string[0]) return c->last_error_string;
+  return 0;
+}
+
+//------------------------------------------------------------------------------
+void NSEEL_code_free(NSEEL_CODEHANDLE code)
+{
+  codeHandleType *h = (codeHandleType *)code;
+  if (h != NULL)
+  {
+    nseel_evallib_stats[0]-=h->code_stats[0];
+    nseel_evallib_stats[1]-=h->code_stats[1];
+    nseel_evallib_stats[2]-=h->code_stats[2];
+    nseel_evallib_stats[3]-=h->code_stats[3];
+    nseel_evallib_stats[4]--;
+    freeBlocks(h->blocks);
+  }
+}
+
+
+//------------------------------------------------------------------------------
+void NSEEL_VM_resetvars(NSEEL_VMCTX _ctx)
+{
+  if (_ctx)
+  {
+    compileContext *ctx=(compileContext *)_ctx;
+    int x;
+    if (ctx->varTable_Names || ctx->varTable_Values) for (x = 0; x < ctx->varTable_numBlocks; x ++)
+    {
+      if (ctx->varTable_Names)
+          free(ctx->varTable_Names[x]);
+
+      if (ctx->varTable_Values)
+          free(ctx->varTable_Values[x]);
+    }
+
+    free(ctx->varTable_Values);
+    free(ctx->varTable_Names);
+    ctx->varTable_Values=0;
+    ctx->varTable_Names=0;
+
+    ctx->varTable_numBlocks=0;
+  }
+}
+
+
+NSEEL_VMCTX NSEEL_VM_alloc() // return a handle
+{
+  compileContext *ctx=calloc(1,sizeof(compileContext));
+  return ctx;
+}
+
+void NSEEL_VM_free(NSEEL_VMCTX ctx) // free when done with a VM and ALL of its code have been freed, as well
+{
+  free(ctx);
+}
+
+int *NSEEL_code_getstats(NSEEL_CODEHANDLE code)
+{
+  codeHandleType *h = (codeHandleType *)code;
+  if (h)
+  {
+    return h->code_stats;
+  }
+  return 0;
+}
\ No newline at end of file