mirrors/winamp
Archived
1
0
Fork 0
Code
This repository has been archived on 2024-10-17. You can view files and clone it, but cannot push or open issues or pull requests.
community
winamp/Src/ns-eel2/nseel-compiler.c

5701 lines
187 KiB
C
Raw Permalink Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
/*
Expression Evaluator Library (NS-EEL) v2
Copyright (C) 2004-2013 Cockos Incorporated
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 "ns-eel-int.h"
#include "denormal.h"
#include "wdlcstring.h"
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <ctype.h>
#if !defined(EEL_TARGET_PORTABLE) && !defined(_WIN32)
#include <sys/mman.h>
#include <stdint.h>
#include <unistd.h>
#endif
#include "glue_x86.h"
#ifdef _WIN64
#include "glue_x86_64.h"
#endif // _WIN64
#define NSEEL_VARS_MALLOC_CHUNKSIZE 8
//#define LOG_OPT
//#define EEL_PRINT_FAILS
//#define EEL_VALIDATE_WORKTABLE_USE
//#define EEL_VALIDATE_FSTUBS
#ifdef EEL_PRINT_FAILS
#ifdef _WIN32
#define RET_MINUS1_FAIL(x) { OutputDebugString(x); return -1; }
#else
#define RET_MINUS1_FAIL(x) { printf("%s\n",x); return -1; }
#endif
#else
#define RET_MINUS1_FAIL(x) return -1;
#endif
#ifdef EEL_DUMP_OPS
FILE *g_eel_dump_fp, *g_eel_dump_fp2;
#endif
#ifdef EEL_VALIDATE_WORKTABLE_USE
#define MIN_COMPUTABLE_SIZE 0
#define COMPUTABLE_EXTRA_SPACE 64 // safety buffer, if EEL_VALIDATE_WORKTABLE_USE set, used for magic-value-checking
#else
#define MIN_COMPUTABLE_SIZE 32 // always use at least this big of a temp storage table (and reset the temp ptr when it goes past this boundary)
#define COMPUTABLE_EXTRA_SPACE 16 // safety buffer, if EEL_VALIDATE_WORKTABLE_USE set, used for magic-value-checking
#endif
/*
P1 is rightmost parameter
P2 is second rightmost, if any
P3 is third rightmost, if any
registers on x86 are (RAX etc on x86-64)
P1(ret) EAX
P2 EDI
P3 ECX
WTP RSI
x86_64: r12 is a pointer to ram_state.blocks
x86_64: r13 is a pointer to closenessfactor
registers on PPC are:
P1(ret) r3
P2 r14
P3 r15
WTP r16 (r17 has the original value)
r13 is a pointer to ram_state.blocks
ppc uses f31 and f30 and others for certain constants
*/
#ifdef EEL_TARGET_PORTABLE
#define EEL_DOESNT_NEED_EXEC_PERMS
#include "glue_port.h"
#elif defined(__ppc__)
#include "glue_ppc.h"
#elif defined(__aarch64__)
#include "glue_aarch64.h"
#elif defined(__arm__) || (defined (_M_ARM) && _M_ARM == 7)
#include "glue_arm.h"
#elif defined(_WIN64) || defined(__LP64__)
#include "glue_x86_64.h"
#else
#include "glue_x86.h"
#endif
#ifndef GLUE_INVSQRT_NEEDREPL
#define GLUE_INVSQRT_NEEDREPL 0
#endif
// used by //#eel-no-optimize:xxx, in ctx->optimizeDisableFlags
#define OPTFLAG_NO_OPTIMIZE 1
#define OPTFLAG_NO_FPSTACK 2
#define OPTFLAG_NO_INLINEFUNC 4
#define OPTFLAG_FULL_DENORMAL_CHECKS 8 // if set, denormals/NaN are always filtered on assign
#define OPTFLAG_NO_DENORMAL_CHECKS 16 // if set and FULL not set, denormals/NaN are never filtered on assign
#define DENORMAL_CLEARING_THRESHOLD 1.0e-50 // when adding/subtracting a constant, assume if it's greater than this, it will clear denormal (the actual value is probably 10^-290...)
#define MAX_SUB_NAMESPACES 32
typedef struct
{
const char *namespacePathToThis;
const char *subParmInfo[MAX_SUB_NAMESPACES];
} namespaceInformation;
static int nseel_evallib_stats[5]; // source bytes, static code bytes, call code bytes, data bytes, segments
int *NSEEL_getstats()
{
return nseel_evallib_stats;
}
static int findLineNumber(const char *exp, int byteoffs)
{
int lc=0;
while (byteoffs-->0 && *exp) if (*exp++ =='\n') lc++;
return lc;
}
static int nseel_vms_referencing_globallist_cnt;
nseel_globalVarItem *nseel_globalreg_list;
static EEL_F *get_global_var(compileContext *ctx, const char *gv, int addIfNotPresent);
static void *__newBlock(llBlock **start,int size, int wantMprotect);
#define OPCODE_IS_TRIVIAL(x) ((x)->opcodeType <= OPCODETYPE_VARPTRPTR)
enum {
OPCODETYPE_DIRECTVALUE=0,
OPCODETYPE_DIRECTVALUE_TEMPSTRING, // like directvalue, but will generate a new tempstring value on generate
OPCODETYPE_VALUE_FROM_NAMESPACENAME, // this.* or namespace.* are encoded this way
OPCODETYPE_VARPTR,
OPCODETYPE_VARPTRPTR,
OPCODETYPE_FUNC1,
OPCODETYPE_FUNC2,
OPCODETYPE_FUNC3,
OPCODETYPE_FUNCX,
OPCODETYPE_MOREPARAMS,
OPCODETYPE_INVALID,
};
struct opcodeRec
{
int opcodeType;
int fntype;
void *fn;
union {
struct opcodeRec *parms[3];
struct {
double directValue;
EEL_F *valuePtr; // if direct value, valuePtr can be cached
} dv;
} parms;
int namespaceidx;
// OPCODETYPE_VALUE_FROM_NAMESPACENAME (relname is either empty or blah)
// OPCODETYPE_VARPTR if it represents a global variable, will be nonempty
// OPCODETYPE_FUNC* with fntype=FUNCTYPE_EELFUNC
const char *relname;
};
static void *newTmpBlock(compileContext *ctx, int size)
{
const int align = 8;
const int a1=align-1;
char *p=(char*)__newBlock(&ctx->tmpblocks_head,size+a1, 0);
return p+((align-(((INT_PTR)p)&a1))&a1);
}
static void *__newBlock_align(compileContext *ctx, int size, int align, int isForCode)
{
const int a1=align-1;
char *p=(char*)__newBlock(
(
isForCode < 0 ? (isForCode == -2 ? &ctx->pblocks : &ctx->tmpblocks_head) :
isForCode > 0 ? &ctx->blocks_head :
&ctx->blocks_head_data) ,size+a1, isForCode>0);
return p+((align-(((INT_PTR)p)&a1))&a1);
}
static opcodeRec *newOpCode(compileContext *ctx, const char *str, int opType)
{
const size_t strszfull = str ? strlen(str) : 0;
const size_t str_sz = wdl_min(NSEEL_MAX_VARIABLE_NAMELEN, strszfull);
opcodeRec *rec = (opcodeRec*)__newBlock_align(ctx,
(int) (sizeof(opcodeRec) + (str_sz>0 ? str_sz+1 : 0)),
8, ctx->isSharedFunctions ? 0 : -1);
if (rec)
{
memset(rec,0,sizeof(*rec));
rec->opcodeType = opType;
if (str_sz > 0)
{
char *p = (char *)(rec+1);
memcpy(p,str,str_sz);
p[str_sz]=0;
rec->relname = p;
}
else
{
rec->relname = "";
}
}
return rec;
}
#define newCodeBlock(x,a) __newBlock_align(ctx,x,a,1)
#define newDataBlock(x,a) __newBlock_align(ctx,x,a,0)
#define newCtxDataBlock(x,a) __newBlock_align(ctx,x,a,-2)
static void freeBlocks(llBlock **start);
static int __growbuf_resize(eel_growbuf *buf, int newsize)
{
if (newsize<0)
{
free(buf->ptr);
buf->ptr=NULL;
buf->alloc=buf->size=0;
return 0;
}
if (newsize > buf->alloc)
{
const int newalloc = newsize + 4096 + newsize/2;
void *newptr = realloc(buf->ptr,newalloc);
if (!newptr)
{
newptr = malloc(newalloc);
if (!newptr) return 1;
if (buf->ptr && buf->size) memcpy(newptr,buf->ptr,buf->size);
free(buf->ptr);
buf->ptr=newptr;
}
else
buf->ptr = newptr;
buf->alloc=newalloc;
}
buf->size = newsize;
return 0;
}
#ifndef DECL_ASMFUNC
#define DECL_ASMFUNC(x) \
void nseel_asm_##x(void); \
void nseel_asm_##x##_end(void);
void _asm_megabuf(void);
void _asm_megabuf_end(void);
void _asm_gmegabuf(void);
void _asm_gmegabuf_end(void);
#endif
DECL_ASMFUNC(booltofp)
DECL_ASMFUNC(fptobool)
DECL_ASMFUNC(fptobool_rev)
DECL_ASMFUNC(sin)
DECL_ASMFUNC(cos)
DECL_ASMFUNC(tan)
DECL_ASMFUNC(1pdd)
DECL_ASMFUNC(2pdd)
DECL_ASMFUNC(2pdds)
DECL_ASMFUNC(1pp)
DECL_ASMFUNC(2pp)
DECL_ASMFUNC(sqr)
DECL_ASMFUNC(sqrt)
DECL_ASMFUNC(log)
DECL_ASMFUNC(log10)
DECL_ASMFUNC(abs)
DECL_ASMFUNC(min)
DECL_ASMFUNC(max)
DECL_ASMFUNC(min_fp)
DECL_ASMFUNC(max_fp)
DECL_ASMFUNC(sig)
DECL_ASMFUNC(sign)
DECL_ASMFUNC(band)
DECL_ASMFUNC(bor)
DECL_ASMFUNC(bnot)
DECL_ASMFUNC(bnotnot)
DECL_ASMFUNC(if)
DECL_ASMFUNC(fcall)
DECL_ASMFUNC(repeat)
DECL_ASMFUNC(repeatwhile)
DECL_ASMFUNC(equal)
DECL_ASMFUNC(equal_exact)
DECL_ASMFUNC(notequal_exact)
DECL_ASMFUNC(notequal)
DECL_ASMFUNC(below)
DECL_ASMFUNC(above)
DECL_ASMFUNC(beloweq)
DECL_ASMFUNC(aboveeq)
DECL_ASMFUNC(assign)
DECL_ASMFUNC(assign_fromfp)
DECL_ASMFUNC(assign_fast)
DECL_ASMFUNC(assign_fast_fromfp)
DECL_ASMFUNC(add)
DECL_ASMFUNC(sub)
DECL_ASMFUNC(add_op)
DECL_ASMFUNC(sub_op)
DECL_ASMFUNC(add_op_fast)
DECL_ASMFUNC(sub_op_fast)
DECL_ASMFUNC(mul)
DECL_ASMFUNC(div)
DECL_ASMFUNC(mul_op)
DECL_ASMFUNC(div_op)
DECL_ASMFUNC(mul_op_fast)
DECL_ASMFUNC(div_op_fast)
DECL_ASMFUNC(mod)
DECL_ASMFUNC(shl)
DECL_ASMFUNC(shr)
DECL_ASMFUNC(mod_op)
DECL_ASMFUNC(or)
DECL_ASMFUNC(or0)
DECL_ASMFUNC(xor)
DECL_ASMFUNC(xor_op)
DECL_ASMFUNC(and)
DECL_ASMFUNC(or_op)
DECL_ASMFUNC(and_op)
DECL_ASMFUNC(uplus)
DECL_ASMFUNC(uminus)
DECL_ASMFUNC(invsqrt)
DECL_ASMFUNC(dbg_getstackptr)
#ifdef NSEEL_EEL1_COMPAT_MODE
DECL_ASMFUNC(exec2)
#endif
DECL_ASMFUNC(stack_push)
DECL_ASMFUNC(stack_pop)
DECL_ASMFUNC(stack_pop_fast) // just returns value, doesn't mod param
DECL_ASMFUNC(stack_peek)
DECL_ASMFUNC(stack_peek_int)
DECL_ASMFUNC(stack_peek_top)
DECL_ASMFUNC(stack_exch)
static void *NSEEL_PProc_GRAM(void *data, int data_size, compileContext *ctx)
{
if (data_size>0) data=EEL_GLUE_set_immediate(data, (INT_PTR)ctx->gram_blocks);
return data;
}
static void *NSEEL_PProc_Stack(void *data, int data_size, compileContext *ctx)
{
codeHandleType *ch=ctx->tmpCodeHandle;
if (data_size>0)
{
UINT_PTR m1=(UINT_PTR)(NSEEL_STACK_SIZE * sizeof(EEL_F) - 1);
UINT_PTR stackptr = ((UINT_PTR) (&ch->stack));
ch->want_stack=1;
if (!ch->stack) ch->stack = newDataBlock(NSEEL_STACK_SIZE*sizeof(EEL_F),NSEEL_STACK_SIZE*sizeof(EEL_F));
data=EEL_GLUE_set_immediate(data, stackptr);
data=EEL_GLUE_set_immediate(data, m1); // and
data=EEL_GLUE_set_immediate(data, ((UINT_PTR)ch->stack&~m1)); //or
}
return data;
}
static void *NSEEL_PProc_Stack_PeekInt(void *data, int data_size, compileContext *ctx, INT_PTR offs)
{
codeHandleType *ch=ctx->tmpCodeHandle;
if (data_size>0)
{
UINT_PTR m1=(UINT_PTR)(NSEEL_STACK_SIZE * sizeof(EEL_F) - 1);
UINT_PTR stackptr = ((UINT_PTR) (&ch->stack));
ch->want_stack=1;
if (!ch->stack) ch->stack = newDataBlock(NSEEL_STACK_SIZE*sizeof(EEL_F),NSEEL_STACK_SIZE*sizeof(EEL_F));
data=EEL_GLUE_set_immediate(data, stackptr);
data=EEL_GLUE_set_immediate(data, offs);
data=EEL_GLUE_set_immediate(data, m1); // and
data=EEL_GLUE_set_immediate(data, ((UINT_PTR)ch->stack&~m1)); //or
}
return data;
}
static void *NSEEL_PProc_Stack_PeekTop(void *data, int data_size, compileContext *ctx)
{
codeHandleType *ch=ctx->tmpCodeHandle;
if (data_size>0)
{
UINT_PTR stackptr = ((UINT_PTR) (&ch->stack));
ch->want_stack=1;
if (!ch->stack) ch->stack = newDataBlock(NSEEL_STACK_SIZE*sizeof(EEL_F),NSEEL_STACK_SIZE*sizeof(EEL_F));
data=EEL_GLUE_set_immediate(data, stackptr);
}
return data;
}
#if defined(_MSC_VER) && _MSC_VER >= 1400
//static double __floor(double a) { return floor(a); }
//static double __ceil(double a) { return ceil(a); }
#define floor __floor
#define ceil __ceil
#endif
#ifdef NSEEL_EEL1_COMPAT_MODE
static double eel1band(double a, double b)
{
return (fabs(a)>NSEEL_CLOSEFACTOR && fabs(b) > NSEEL_CLOSEFACTOR) ? 1.0 : 0.0;
}
static double eel1bor(double a, double b)
{
return (fabs(a)>NSEEL_CLOSEFACTOR || fabs(b) > NSEEL_CLOSEFACTOR) ? 1.0 : 0.0;
}
static double eel1sigmoid(double x, double constraint)
{
double t = (1+exp(-x * (constraint)));
return fabs(t)>NSEEL_CLOSEFACTOR ? 1.0/t : 0;
}
#endif
#define FUNCTIONTYPE_PARAMETERCOUNTMASK 0xff
#define BIF_NPARAMS_MASK 0x7ffff00
#define BIF_RETURNSONSTACK 0x0000100
#define BIF_LASTPARMONSTACK 0x0000200
#define BIF_RETURNSBOOL 0x0000400
#define BIF_LASTPARM_ASBOOL 0x0000800
// 0x00?0000 -- taken by FP stack flags
#define BIF_TAKES_VARPARM 0x0400000
#define BIF_TAKES_VARPARM_EX 0x0C00000 // this is like varparm but check count exactly
#define BIF_WONTMAKEDENORMAL 0x0100000
#define BIF_CLEARDENORMAL 0x0200000
#if defined(GLUE_HAS_FXCH) && GLUE_MAX_FPSTACK_SIZE > 0
#define BIF_SECONDLASTPARMST 0x0001000 // use with BIF_LASTPARMONSTACK only (last two parameters get passed on fp stack)
#define BIF_LAZYPARMORDERING 0x0002000 // allow optimizer to avoid fxch when using BIF_TWOPARMSONFPSTACK_LAZY etc
#define BIF_REVERSEFPORDER 0x0004000 // force a fxch (reverse order of last two parameters on fp stack, used by comparison functions)
#ifndef BIF_FPSTACKUSE
#define BIF_FPSTACKUSE(x) (((x)>=0&&(x)<8) ? ((7-(x))<<16):0)
#endif
#ifndef BIF_GETFPSTACKUSE
#define BIF_GETFPSTACKUSE(x) (7 - (((x)>>16)&7))
#endif
#else
// do not support fp stack use unless GLUE_HAS_FXCH and GLUE_MAX_FPSTACK_SIZE>0
#define BIF_SECONDLASTPARMST 0
#define BIF_LAZYPARMORDERING 0
#define BIF_REVERSEFPORDER 0
#define BIF_FPSTACKUSE(x) 0
#define BIF_GETFPSTACKUSE(x) 0
#endif
#define BIF_TWOPARMSONFPSTACK (BIF_SECONDLASTPARMST|BIF_LASTPARMONSTACK)
#define BIF_TWOPARMSONFPSTACK_LAZY (BIF_LAZYPARMORDERING|BIF_SECONDLASTPARMST|BIF_LASTPARMONSTACK)
#ifndef GLUE_HAS_NATIVE_TRIGSQRTLOG
static double sqrt_fabs(double a) { return sqrt(fabs(a)); }
#endif
EEL_F NSEEL_CGEN_CALL nseel_int_rand(EEL_F f);
#define FNPTR_HAS_CONDITIONAL_EXEC(op) \
(op->fntype == FN_LOGICAL_AND || \
op->fntype == FN_LOGICAL_OR || \
op->fntype == FN_IF_ELSE || \
op->fntype == FN_WHILE || \
op->fntype == FN_LOOP)
static functionType fnTable1[] = {
#ifndef GLUE_HAS_NATIVE_TRIGSQRTLOG
{ "sin", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_WONTMAKEDENORMAL, {&sin} },
{ "cos", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_CLEARDENORMAL, {&cos} },
{ "tan", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&tan} },
{ "sqrt", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_WONTMAKEDENORMAL, {&sqrt_fabs}, },
{ "log", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&log} },
{ "log10", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&log10} },
#else
{ "sin", nseel_asm_sin,nseel_asm_sin_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_WONTMAKEDENORMAL|BIF_FPSTACKUSE(1) },
{ "cos", nseel_asm_cos,nseel_asm_cos_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_CLEARDENORMAL|BIF_FPSTACKUSE(1) },
{ "tan", nseel_asm_tan,nseel_asm_tan_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1) },
{ "sqrt", nseel_asm_sqrt,nseel_asm_sqrt_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1)|BIF_WONTMAKEDENORMAL },
{ "log", nseel_asm_log,nseel_asm_log_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(3), },
{ "log10", nseel_asm_log10,nseel_asm_log10_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(3), },
#endif
{ "asin", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&asin}, },
{ "acos", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&acos}, },
{ "atan", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&atan}, },
{ "atan2", nseel_asm_2pdd,nseel_asm_2pdd_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK, {&atan2}, },
{ "exp", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&exp}, },
{ "abs", nseel_asm_abs,nseel_asm_abs_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(0)|BIF_WONTMAKEDENORMAL },
{ "sqr", nseel_asm_sqr,nseel_asm_sqr_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1) },
{ "min", nseel_asm_min,nseel_asm_min_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_FPSTACKUSE(3)|BIF_WONTMAKEDENORMAL },
{ "max", nseel_asm_max,nseel_asm_max_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_FPSTACKUSE(3)|BIF_WONTMAKEDENORMAL },
{ "sign", nseel_asm_sign,nseel_asm_sign_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL, },
{ "rand", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_CLEARDENORMAL, {&nseel_int_rand}, },
//{ "floor", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_CLEARDENORMAL, {&floor} },
//{ "ceil", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_CLEARDENORMAL, {&ceil} },
{ "invsqrt", nseel_asm_invsqrt,nseel_asm_invsqrt_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(3), {GLUE_INVSQRT_NEEDREPL} },
{ "__dbg_getstackptr", nseel_asm_dbg_getstackptr,nseel_asm_dbg_getstackptr_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1), },
#ifdef NSEEL_EEL1_COMPAT_MODE
{ "sigmoid", nseel_asm_2pdd,nseel_asm_2pdd_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK, {&eel1sigmoid}, },
// these differ from _and/_or, they always evaluate both...
{ "band", nseel_asm_2pdd,nseel_asm_2pdd_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_CLEARDENORMAL , {&eel1band}, },
{ "bor", nseel_asm_2pdd,nseel_asm_2pdd_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_CLEARDENORMAL , {&eel1bor}, },
{"exec2",nseel_asm_exec2,nseel_asm_exec2_end,2|NSEEL_NPARAMS_FLAG_CONST|BIF_WONTMAKEDENORMAL},
{"exec3",nseel_asm_exec2,nseel_asm_exec2_end,3|NSEEL_NPARAMS_FLAG_CONST|BIF_WONTMAKEDENORMAL},
#endif // end EEL1 compat
{"freembuf",_asm_generic1parm,_asm_generic1parm_end,1,{&__NSEEL_RAM_MemFree},NSEEL_PProc_RAM},
{"memcpy",_asm_generic3parm,_asm_generic3parm_end,3,{&__NSEEL_RAM_MemCpy},NSEEL_PProc_RAM},
{"memset",_asm_generic3parm,_asm_generic3parm_end,3,{&__NSEEL_RAM_MemSet},NSEEL_PProc_RAM},
{"__memtop",_asm_generic1parm,_asm_generic1parm_end,1,{&__NSEEL_RAM_MemTop},NSEEL_PProc_RAM},
{"mem_set_values",_asm_generic2parm_retd,_asm_generic2parm_retd_end,2|BIF_TAKES_VARPARM|BIF_RETURNSONSTACK,{&__NSEEL_RAM_Mem_SetValues},NSEEL_PProc_RAM},
{"mem_get_values",_asm_generic2parm_retd,_asm_generic2parm_retd_end,2|BIF_TAKES_VARPARM|BIF_RETURNSONSTACK,{&__NSEEL_RAM_Mem_GetValues},NSEEL_PProc_RAM},
{"stack_push",nseel_asm_stack_push,nseel_asm_stack_push_end,1|BIF_FPSTACKUSE(0),{0,},NSEEL_PProc_Stack},
{"stack_pop",nseel_asm_stack_pop,nseel_asm_stack_pop_end,1|BIF_FPSTACKUSE(1),{0,},NSEEL_PProc_Stack},
{"stack_peek",nseel_asm_stack_peek,nseel_asm_stack_peek_end,1|NSEEL_NPARAMS_FLAG_CONST|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(0),{0,},NSEEL_PProc_Stack},
{"stack_exch",nseel_asm_stack_exch,nseel_asm_stack_exch_end,1|BIF_FPSTACKUSE(1), {0,},NSEEL_PProc_Stack_PeekTop},
};
static eel_function_table default_user_funcs;
static int functable_lowerbound(functionType *list, int list_sz, const char *name, int *ismatch)
{
int a = 0, c = list_sz;
while (a != c)
{
const int b = (a+c)/2;
const int cmp = stricmp(name,list[b].name);
if (cmp > 0) a = b+1;
else if (cmp < 0) c = b;
else
{
*ismatch = 1;
return b;
}
}
*ismatch = 0;
return a;
}
static int funcTypeCmp(const void *a, const void *b) { return stricmp(((functionType*)a)->name,((functionType*)b)->name); }
functionType *nseel_getFunctionByName(compileContext *ctx, const char *name, int *mchk)
{
eel_function_table *tab = ctx && ctx->registered_func_tab ? ctx->registered_func_tab : &default_user_funcs;
static char sorted;
const int fn1size = (int) (sizeof(fnTable1)/sizeof(fnTable1[0]));
int idx,match;
if (!sorted)
{
NSEEL_HOSTSTUB_EnterMutex();
if (!sorted) qsort(fnTable1,fn1size,sizeof(fnTable1[0]),funcTypeCmp);
sorted=1;
NSEEL_HOSTSTUB_LeaveMutex();
}
idx=functable_lowerbound(fnTable1,fn1size,name,&match);
if (match) return fnTable1+idx;
if ((!ctx || !(ctx->current_compile_flags&NSEEL_CODE_COMPILE_FLAG_ONLY_BUILTIN_FUNCTIONS)) && tab->list)
{
idx=functable_lowerbound(tab->list,tab->list_size,name,&match);
if (match)
{
if (mchk)
{
while (idx>0 && !stricmp(tab->list[idx-1].name,name)) idx--;
*mchk = tab->list_size - 1 - idx;
}
return tab->list + idx;
}
}
return NULL;
}
int NSEEL_init() // returns 0 on success
{
#ifdef EEL_VALIDATE_FSTUBS
int a;
for (a=0;a < sizeof(fnTable1)/sizeof(fnTable1[0]);a++)
{
char *code_startaddr = (char*)fnTable1[a].afunc;
char *endp = (char *)fnTable1[a].func_e;
// validate
int sz=0;
char *f=(char *)GLUE_realAddress(code_startaddr,endp,&sz);
if (f+sz > endp)
{
#ifdef _WIN32
OutputDebugString("bad eel function stub\n");
#else
printf("bad eel function stub\n");
#endif
*(char *)NULL = 0;
}
}
#ifdef _WIN32
OutputDebugString("eel function stub (builtin) validation complete\n");
#else
printf("eel function stub (builtin) validation complete\n");
#endif
#endif
NSEEL_quit();
return 0;
}
void NSEEL_quit()
{
free(default_user_funcs.list);
default_user_funcs.list = NULL;
default_user_funcs.list_size = 0;
}
void NSEEL_addfunc_varparm_ex(const char *name, int min_np, int want_exact, NSEEL_PPPROC pproc, EEL_F (NSEEL_CGEN_CALL *fptr)(void *, INT_PTR, EEL_F **), eel_function_table *destination)
{
const int sz = (int) ((char *)_asm_generic2parm_retd_end-(char *)_asm_generic2parm_retd);
NSEEL_addfunctionex2(name,min_np|(want_exact?BIF_TAKES_VARPARM_EX:BIF_TAKES_VARPARM),(char *)_asm_generic2parm_retd,sz,pproc,fptr,NULL,destination);
}
void NSEEL_addfunc_ret_type(const char *name, int np, int ret_type, NSEEL_PPPROC pproc, void *fptr, eel_function_table *destination) // ret_type=-1 for bool, 1 for value, 0 for ptr
{
char *stub=NULL;
int stubsz=0;
#define DOSTUB(np) { \
stub = (ret_type == 1 ? (char*)_asm_generic##np##parm_retd : (char*)_asm_generic##np##parm); \
stubsz = (int) ((ret_type == 1 ? (char*)_asm_generic##np##parm_retd_end : (char *)_asm_generic##np##parm_end) - stub); \
}
if (np == 1) DOSTUB(1)
else if (np == 2) DOSTUB(2)
else if (np == 3) DOSTUB(3)
#undef DOSTUB
if (stub) NSEEL_addfunctionex2(name,np|(ret_type == -1 ? BIF_RETURNSBOOL:0), stub, stubsz, pproc,fptr,NULL,destination);
}
void NSEEL_addfunctionex2(const char *name, int nparms, char *code_startaddr, int code_len, NSEEL_PPPROC pproc, void *fptr, void *fptr2, eel_function_table *destination)
{
const int list_size_chunk = 128;
functionType *r;
if (!destination) destination = &default_user_funcs;
if (!destination->list || !(destination->list_size & (list_size_chunk-1)))
{
void *nv = realloc(destination->list, (destination->list_size + list_size_chunk)*sizeof(functionType));
if (!nv) return;
destination->list = (functionType *)nv;
}
if (destination->list)
{
int match,idx;
idx=functable_lowerbound(destination->list,destination->list_size,name,&match);
#ifdef EEL_VALIDATE_FSTUBS
{
char *endp = code_startaddr+code_len;
// validate
int sz=0;
char *f=(char *)GLUE_realAddress(code_startaddr,endp,&sz);
if (f+sz > endp)
{
#ifdef _WIN32
OutputDebugString("bad eel function stub\n");
#else
printf("bad eel function stub\n");
#endif
*(char *)NULL = 0;
}
#ifdef _WIN32
OutputDebugString(name);
OutputDebugString(" - validated eel function stub\n");
#else
printf("eel function stub validation complete for %s\n",name);
#endif
}
#endif
r = destination->list + idx;
if (idx < destination->list_size)
memmove(r + 1, r, (destination->list_size - idx) * sizeof(functionType));
destination->list_size++;
memset(r, 0, sizeof(functionType));
if (!(nparms & BIF_RETURNSBOOL))
{
if (code_startaddr == (void *)&_asm_generic1parm_retd ||
code_startaddr == (void *)&_asm_generic2parm_retd ||
code_startaddr == (void *)&_asm_generic3parm_retd)
{
nparms |= BIF_RETURNSONSTACK;
}
}
r->nParams = nparms;
r->name = name;
r->afunc = code_startaddr;
r->func_e = code_startaddr + code_len;
r->pProc = pproc;
r->replptrs[0] = fptr;
r->replptrs[1] = fptr2;
}
}
//---------------------------------------------------------------------------------------------------------------
static void freeBlocks(llBlock **start)
{
llBlock *s=*start;
*start=0;
while (s)
{
llBlock *llB = s->next;
free(s);
s=llB;
}
}
//---------------------------------------------------------------------------------------------------------------
static void *__newBlock(llBlock **start, int size, int wantMprotect)
{
#if !defined(EEL_DOESNT_NEED_EXEC_PERMS) && defined(_WIN32)
DWORD ov;
UINT_PTR offs,eoffs;
#endif
llBlock *llb;
int alloc_size;
if (*start && (LLB_DSIZE - (*start)->sizeused) >= size)
{
void *t=(*start)->block+(*start)->sizeused;
(*start)->sizeused+=(size+7)&~7;
return t;
}
alloc_size=sizeof(llBlock);
if ((int)size > LLB_DSIZE) alloc_size += size - LLB_DSIZE;
llb = (llBlock *)malloc(alloc_size); // grab bigger block if absolutely necessary (heh)
if (!llb) return NULL;
#ifndef EEL_DOESNT_NEED_EXEC_PERMS
if (wantMprotect)
{
#ifdef _WIN32
offs=((UINT_PTR)llb)&~4095;
eoffs=((UINT_PTR)llb + alloc_size + 4095)&~4095;
VirtualProtect((LPVOID)offs,eoffs-offs,PAGE_EXECUTE_READWRITE,&ov);
// MessageBox(NULL,"vprotecting, yay\n","a",0);
#else
{
static int pagesize = 0;
if (!pagesize)
{
pagesize=sysconf(_SC_PAGESIZE);
if (!pagesize) pagesize=4096;
}
uintptr_t offs,eoffs;
offs=((uintptr_t)llb)&~(pagesize-1);
eoffs=((uintptr_t)llb + alloc_size + pagesize-1)&~(pagesize-1);
mprotect((void*)offs,eoffs-offs,PROT_WRITE|PROT_READ|PROT_EXEC);
}
#endif
}
#endif
llb->sizeused=(size+7)&~7;
llb->next = *start;
*start = llb;
return llb->block;
}
//---------------------------------------------------------------------------------------------------------------
opcodeRec *nseel_createCompiledValue(compileContext *ctx, EEL_F value)
{
opcodeRec *r=newOpCode(ctx,NULL,OPCODETYPE_DIRECTVALUE);
if (r)
{
r->parms.dv.directValue = value;
}
return r;
}
opcodeRec *nseel_createCompiledValuePtr(compileContext *ctx, EEL_F *addrValue, const char *namestr)
{
opcodeRec *r=newOpCode(ctx,namestr,OPCODETYPE_VARPTR);
if (!r) return 0;
r->parms.dv.valuePtr=addrValue;
return r;
}
static int validate_varname_for_function(compileContext *ctx, const char *name)
{
if (!ctx->function_curName || !ctx->function_globalFlag) return 1;
if (ctx->function_localTable_Size[2] > 0 && ctx->function_localTable_Names[2])
{
char * const * const namelist = ctx->function_localTable_Names[2];
const int namelist_sz = ctx->function_localTable_Size[2];
int i;
const size_t name_len = strlen(name);
for (i=0;i<namelist_sz;i++)
{
const char *nmchk=namelist[i];
const size_t l = strlen(nmchk);
if (l > 1 && nmchk[l-1] == '*')
{
if (name_len >= l && !strnicmp(nmchk,name,l-1) && name[l-1]=='.') return 1;
}
else
{
if (name_len == l && !stricmp(nmchk,name)) return 1;
}
}
}
return 0;
}
opcodeRec *nseel_resolve_named_symbol(compileContext *ctx, opcodeRec *rec, int parmcnt, int *errOut)
{
const int isFunctionMode = parmcnt >= 0;
int rel_prefix_len=0;
int rel_prefix_idx=-2;
int i;
char match_parmcnt[4]={-1,-1,-1,-1}; // [3] is guess
unsigned char match_parmcnt_pos=0;
char *sname = (char *)rec->relname;
int is_string_prefix = parmcnt < 0 && sname[0] == '#';
const char *prevent_function_calls = NULL;
if (errOut) *errOut = 0;
if (sname) sname += is_string_prefix;
if (rec->opcodeType != OPCODETYPE_VARPTR || !sname || !sname[0]) return NULL;
if (!isFunctionMode && !is_string_prefix && !strnicmp(sname,"reg",3) && isdigit(sname[3]) && isdigit(sname[4]) && !sname[5])
{
EEL_F *a=get_global_var(ctx,sname,1);
if (a)
{
rec->parms.dv.valuePtr = a;
sname[0]=0; // for dump_ops compat really, but this shouldn't be needed anyway
}
return rec;
}
if (ctx->function_curName)
{
if (!strnicmp(sname,"this.",5))
{
rel_prefix_len=5;
rel_prefix_idx=-1;
}
else if (!stricmp(sname,"this"))
{
rel_prefix_len=4;
rel_prefix_idx=-1;
}
// scan for parameters/local variables before user functions
if (rel_prefix_idx < -1 &&
ctx->function_localTable_Size[0] > 0 &&
ctx->function_localTable_Names[0] &&
ctx->function_localTable_ValuePtrs)
{
char * const * const namelist = ctx->function_localTable_Names[0];
const int namelist_sz = ctx->function_localTable_Size[0];
for (i=0; i < namelist_sz; i++)
{
const char *p = namelist[i];
if (p)
{
if (!isFunctionMode && !is_string_prefix && !strnicmp(p,sname,NSEEL_MAX_VARIABLE_NAMELEN))
{
rec->opcodeType = OPCODETYPE_VARPTRPTR;
rec->parms.dv.valuePtr=(EEL_F *)(ctx->function_localTable_ValuePtrs+i);
rec->parms.dv.directValue=0.0;
return rec;
}
else
{
const size_t plen = strlen(p);
if (plen > 1 && p[plen-1] == '*' && !strnicmp(p,sname,plen-1) && ((sname[plen-1] == '.'&&sname[plen]) || !sname[plen-1]))
{
rel_prefix_len=(int) (sname[plen-1] ? plen : plen-1);
rel_prefix_idx=i;
break;
}
}
}
}
}
// if instance name set, translate sname or sname.* into "this.sname.*"
if (rel_prefix_idx < -1 &&
ctx->function_localTable_Size[1] > 0 &&
ctx->function_localTable_Names[1])
{
char * const * const namelist = ctx->function_localTable_Names[1];
const int namelist_sz = ctx->function_localTable_Size[1];
const char *full_sname = rec->relname; // include # in checks
for (i=0; i < namelist_sz; i++)
{
const char *p = namelist[i];
if (p && *p)
{
const size_t tl = strlen(p);
if (!strnicmp(p,full_sname,tl) && (full_sname[tl] == 0 || full_sname[tl] == '.'))
{
rel_prefix_len=0; // treat as though this. prefixes is present
rel_prefix_idx=-1;
break;
}
}
}
}
if (rel_prefix_idx >= -1)
{
ctx->function_usesNamespaces=1;
}
} // ctx->function_curName
if (!isFunctionMode)
{
// instance variables
if (rel_prefix_idx >= -1)
{
rec->opcodeType = OPCODETYPE_VALUE_FROM_NAMESPACENAME;
rec->namespaceidx = rel_prefix_idx;
if (rel_prefix_len > 0)
{
if (is_string_prefix) sname[-1] = '#';
memmove(sname, sname+rel_prefix_len, strlen(sname + rel_prefix_len) + 1);
}
}
else
{
// no namespace index, so it must be a global
if (!validate_varname_for_function(ctx,rec->relname))
{
if (errOut) *errOut = 1;
if (ctx->last_error_string[0]) lstrcatn(ctx->last_error_string, ", ", sizeof(ctx->last_error_string));
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"global '%s' inaccessible",rec->relname);
return NULL;
}
}
return rec;
}
if (ctx->func_check)
prevent_function_calls = ctx->func_check(sname,ctx->func_check_user);
////////// function mode
// first off, while() and loop() are special and can't be overridden
//
if (parmcnt == 1 && !stricmp("while",sname) && !prevent_function_calls)
{
rec->opcodeType = OPCODETYPE_FUNC1;
rec->fntype = FN_WHILE;
return rec;
}
if (parmcnt == 2 && !stricmp("loop",sname) && !prevent_function_calls)
{
rec->opcodeType = OPCODETYPE_FUNC2;
rec->fntype = FN_LOOP;
return rec;
}
//
// resolve user function names before builtin functions -- this allows the user to override default functions
if (!(ctx->current_compile_flags & NSEEL_CODE_COMPILE_FLAG_ONLY_BUILTIN_FUNCTIONS))
{
_codeHandleFunctionRec *best=NULL;
size_t bestlen=0;
const char * const ourcall = sname+rel_prefix_len;
const size_t ourcall_len = strlen(ourcall);
int pass;
for (pass=0;pass<2;pass++)
{
_codeHandleFunctionRec *fr = pass ? ctx->functions_common : ctx->functions_local;
// sname is [namespace.[ns.]]function, find best match of function that matches the right end
while (fr)
{
int this_np = fr->num_params;
const char *thisfunc = fr->fname;
const size_t thisfunc_len = strlen(thisfunc);
if (this_np < 1) this_np=1;
if (thisfunc_len == ourcall_len && !stricmp(thisfunc,ourcall))
{
if (this_np == parmcnt)
{
bestlen = thisfunc_len;
best = fr;
break; // found exact match, finished
}
else
{
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = fr->num_params;
}
}
if (thisfunc_len > bestlen && thisfunc_len < ourcall_len && ourcall[ourcall_len - thisfunc_len - 1] == '.' && !stricmp(thisfunc,ourcall + ourcall_len - thisfunc_len))
{
if (this_np == parmcnt)
{
bestlen = thisfunc_len;
best = fr;
}
else
if (match_parmcnt[3]<0) match_parmcnt[3]=fr->num_params;
}
fr=fr->next;
}
if (fr) break; // found exact match, finished
}
if (best)
{
switch (parmcnt)
{
case 0:
case 1: rec->opcodeType = OPCODETYPE_FUNC1; break;
case 2: rec->opcodeType = OPCODETYPE_FUNC2; break;
case 3: rec->opcodeType = OPCODETYPE_FUNC3; break;
default: rec->opcodeType = OPCODETYPE_FUNCX; break;
}
if (ourcall != rec->relname) memmove((char *)rec->relname, ourcall, strlen(ourcall)+1);
if (ctx->function_curName && rel_prefix_idx<0)
{
// if no namespace specified, and this.commonprefix.func() called, remove common prefixes and set prefixidx to be this
const char *p=ctx->function_curName;
if (*p) p++;
while (*p && *p != '.') p++;
if (*p && p[1]) // we have a dot!
{
while (p[1]) p++; // go to last char of string, which doesn't allow possible trailing dot to be checked
while (--p > ctx->function_curName) // do not check possible leading dot
{
if (*p == '.')
{
const size_t cmplen = p+1-ctx->function_curName;
if (!strnicmp(rec->relname,ctx->function_curName,cmplen) && rec->relname[cmplen])
{
const char *src=rec->relname + cmplen;
memmove((char *)rec->relname, src, strlen(src)+1);
rel_prefix_idx=-1;
ctx->function_usesNamespaces=1;
break;
}
}
}
}
}
if (ctx->function_curName && rel_prefix_idx < -1 &&
strchr(rec->relname,'.') && !validate_varname_for_function(ctx,rec->relname))
{
if (errOut) *errOut = 1;
if (ctx->last_error_string[0]) lstrcatn(ctx->last_error_string, ", ", sizeof(ctx->last_error_string));
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"namespaced function '%s' inaccessible",rec->relname);
return NULL;
}
rec->namespaceidx = rel_prefix_idx;
rec->fntype = FUNCTYPE_EELFUNC;
rec->fn = best;
return rec;
}
}
if (prevent_function_calls)
{
if (ctx->last_error_string[0]) lstrcatn(ctx->last_error_string, ", ", sizeof(ctx->last_error_string));
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"'%.30s': %s",sname, prevent_function_calls);
if (errOut) *errOut = 0;
return NULL;
}
#ifdef NSEEL_EEL1_COMPAT_MODE
if (!stricmp(sname,"assign"))
{
if (parmcnt == 2)
{
rec->opcodeType = OPCODETYPE_FUNC2;
rec->fntype = FN_ASSIGN;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 2;
}
else if (!stricmp(sname,"if"))
{
if (parmcnt == 3)
{
rec->opcodeType = OPCODETYPE_FUNC3;
rec->fntype = FN_IF_ELSE;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 3;
}
else if (!stricmp(sname,"equal"))
{
if (parmcnt == 2)
{
rec->opcodeType = OPCODETYPE_FUNC2;
rec->fntype = FN_EQ;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 2;
}
else if (!stricmp(sname,"below"))
{
if (parmcnt == 2)
{
rec->opcodeType = OPCODETYPE_FUNC2;
rec->fntype = FN_LT;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 2;
}
else if (!stricmp(sname,"above"))
{
if (parmcnt == 2)
{
rec->opcodeType = OPCODETYPE_FUNC2;
rec->fntype = FN_GT;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 2;
}
else if (!stricmp(sname,"bnot"))
{
if (parmcnt == 1)
{
rec->opcodeType = OPCODETYPE_FUNC1;
rec->fntype = FN_NOT;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 1;
}
else if (!stricmp(sname,"megabuf"))
{
if (parmcnt == 1)
{
rec->opcodeType = OPCODETYPE_FUNC1;
rec->fntype = FN_MEMORY;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 1;
}
else if (!stricmp(sname,"gmegabuf"))
{
if (parmcnt == 1)
{
rec->opcodeType = OPCODETYPE_FUNC1;
rec->fntype = FN_GMEMORY;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 1;
}
else
#endif
// convert legacy pow() to FN_POW
if (!stricmp("pow",sname))
{
if (parmcnt == 2)
{
rec->opcodeType = OPCODETYPE_FUNC2;
rec->fntype = FN_POW;
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = 2;
}
else if (!stricmp("__denormal_likely",sname) || !stricmp("__denormal_unlikely",sname))
{
if (parmcnt == 1)
{
rec->opcodeType = OPCODETYPE_FUNC1;
rec->fntype = !stricmp("__denormal_likely",sname) ? FN_DENORMAL_LIKELY : FN_DENORMAL_UNLIKELY;
return rec;
}
}
{
int chkamt=0;
functionType *f=nseel_getFunctionByName(ctx,sname,&chkamt);
if (f) while (chkamt-->=0)
{
const int pc_needed=(f->nParams&FUNCTIONTYPE_PARAMETERCOUNTMASK);
if ((f->nParams&BIF_TAKES_VARPARM_EX)==BIF_TAKES_VARPARM ? (parmcnt >= pc_needed) : (parmcnt == pc_needed))
{
rec->fntype = FUNCTYPE_FUNCTIONTYPEREC;
rec->fn = (void *)f;
switch (parmcnt)
{
case 0:
case 1: rec->opcodeType = OPCODETYPE_FUNC1; break;
case 2: rec->opcodeType = OPCODETYPE_FUNC2; break;
case 3: rec->opcodeType = OPCODETYPE_FUNC3; break;
default: rec->opcodeType = OPCODETYPE_FUNCX; break;
}
return rec;
}
if (match_parmcnt_pos < 3) match_parmcnt[match_parmcnt_pos++] = (f->nParams&FUNCTIONTYPE_PARAMETERCOUNTMASK);
f++;
if (stricmp(f->name,sname)) break;
}
}
if (ctx->last_error_string[0]) lstrcatn(ctx->last_error_string, ", ", sizeof(ctx->last_error_string));
if (match_parmcnt[3] >= 0)
{
if (match_parmcnt_pos<3) match_parmcnt[match_parmcnt_pos] = match_parmcnt[3];
match_parmcnt_pos++;
}
if (!match_parmcnt_pos)
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"'%.30s' undefined",sname);
else
{
int x;
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"'%.30s' needs ",sname);
for (x = 0; x < match_parmcnt_pos; x++)
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"%s%d",x==0?"" : x == match_parmcnt_pos-1?" or ":",",match_parmcnt[x]);
lstrcatn(ctx->last_error_string," parms",sizeof(ctx->last_error_string));
}
if (errOut) *errOut = match_parmcnt_pos > 0 ? parmcnt<match_parmcnt[0]?2:(match_parmcnt[0] < 2 ? 4:1) : 0;
return NULL;
}
opcodeRec *nseel_setCompiledFunctionCallParameters(compileContext *ctx, opcodeRec *fn, opcodeRec *code1, opcodeRec *code2, opcodeRec *code3, opcodeRec *postCode, int *errOut)
{
opcodeRec *r;
int np=0,x;
if (!fn || fn->opcodeType != OPCODETYPE_VARPTR || !fn->relname || !fn->relname[0])
{
return NULL;
}
fn->parms.parms[0] = code1;
fn->parms.parms[1] = code2;
fn->parms.parms[2] = code3;
for (x=0;x<3;x++)
{
opcodeRec *prni=fn->parms.parms[x];
while (prni && np < NSEEL_MAX_EELFUNC_PARAMETERS)
{
const int isMP = prni->opcodeType == OPCODETYPE_MOREPARAMS;
np++;
if (!isMP) break;
prni = prni->parms.parms[1];
}
}
r = nseel_resolve_named_symbol(ctx, fn, np<1 ? 1 : np ,errOut);
if (postCode && r)
{
if (code1 && r->opcodeType == OPCODETYPE_FUNC1 && r->fntype == FN_WHILE)
{
// change while(x) (postcode) to be
// while ((x) ? (postcode;1) : 0);
r->parms.parms[0] =
nseel_createIfElse(ctx,r->parms.parms[0],
nseel_createSimpleCompiledFunction(ctx,FN_JOIN_STATEMENTS,2,postCode,nseel_createCompiledValue(ctx,1.0f)),
NULL); // NULL defaults to 0.0
}
else
{
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"syntax error following function");
*errOut = -1;
return NULL;
}
}
return r;
}
struct eelStringSegmentRec *nseel_createStringSegmentRec(compileContext *ctx, const char *str, int len)
{
struct eelStringSegmentRec *r = newTmpBlock(ctx,sizeof(struct eelStringSegmentRec));
if (r)
{
r->_next=0;
r->str_start=str;
r->str_len = len;
}
return r;
}
opcodeRec *nseel_eelMakeOpcodeFromStringSegments(compileContext *ctx, struct eelStringSegmentRec *rec)
{
if (ctx && ctx->onString)
{
return nseel_createCompiledValue(ctx, ctx->onString(ctx->caller_this,rec));
}
return NULL;
}
opcodeRec *nseel_createMoreParametersOpcode(compileContext *ctx, opcodeRec *code1, opcodeRec *code2)
{
opcodeRec *r=code1 && code2 ? newOpCode(ctx,NULL,OPCODETYPE_MOREPARAMS) : NULL;
if (r)
{
r->parms.parms[0] = code1;
r->parms.parms[1] = code2;
}
return r;
}
opcodeRec *nseel_createIfElse(compileContext *ctx, opcodeRec *code1, opcodeRec *code2, opcodeRec *code3)
{
opcodeRec *r=code1 ? newOpCode(ctx,NULL,OPCODETYPE_FUNC3) : NULL;
if (r)
{
if (!code2) code2 = nseel_createCompiledValue(ctx,0.0);
if (!code3) code3 = nseel_createCompiledValue(ctx,0.0);
if (!code2||!code3) return NULL;
r->fntype = FN_IF_ELSE;
r->parms.parms[0] = code1;
r->parms.parms[1] = code2;
r->parms.parms[2] = code3;
}
return r;
}
opcodeRec *nseel_createMemoryAccess(compileContext *ctx, opcodeRec *code1, opcodeRec *code2)
{
if (code1 && code1->opcodeType == OPCODETYPE_VARPTR && !stricmp(code1->relname,"gmem"))
{
return nseel_createSimpleCompiledFunction(ctx, FN_GMEMORY,1,code2?code2:nseel_createCompiledValue(ctx,0.0),0);
}
if (code2 && (code2->opcodeType != OPCODETYPE_DIRECTVALUE || code2->parms.dv.directValue != 0.0))
{
code1 = nseel_createSimpleCompiledFunction(ctx,FN_ADD,2,code1,code2);
}
return nseel_createSimpleCompiledFunction(ctx, FN_MEMORY,1,code1,0);
}
opcodeRec *nseel_createSimpleCompiledFunction(compileContext *ctx, int fn, int np, opcodeRec *code1, opcodeRec *code2)
{
opcodeRec *r=code1 && (np<2 || code2) ? newOpCode(ctx,NULL,np>=2 ? OPCODETYPE_FUNC2:OPCODETYPE_FUNC1) : NULL;
if (r)
{
r->fntype = fn;
r->parms.parms[0] = code1;
r->parms.parms[1] = code2;
if (fn == FN_JOIN_STATEMENTS)
{
r->fn = r; // for joins, fn is temporarily used for _tail pointers
if (code1 && code1->opcodeType == OPCODETYPE_FUNC2 && code1->fntype == fn)
{
opcodeRec *t = (opcodeRec *)code1->fn;
// keep joins in the form of dosomething->morestuff.
// in this instance, code1 is previous stuff to do, code2 is new stuff to do
r->parms.parms[0] = t->parms.parms[1];
code1->fn = (t->parms.parms[1] = r);
return code1;
}
}
}
return r;
}
// these are bitmasks; on request you can tell what is supported, and compileOpcodes will return one of them
#define RETURNVALUE_IGNORE 0 // ignore return value
#define RETURNVALUE_NORMAL 1 // pointer
#define RETURNVALUE_FPSTACK 2
#define RETURNVALUE_BOOL 4 // P1 is nonzero if true
#define RETURNVALUE_BOOL_REVERSED 8 // P1 is zero if true
#define RETURNVALUE_CACHEABLE 16 // only to be used when (at least) RETURNVALUE_NORMAL is set
static int compileOpcodes(compileContext *ctx, opcodeRec *op, unsigned char *bufOut, int bufOut_len, int *computTable, const namespaceInformation *namespacePathToThis,
int supportedReturnValues, int *rvType, int *fpStackUsage, int *canHaveDenormalOutput);
static unsigned char *compileCodeBlockWithRet(compileContext *ctx, opcodeRec *rec, int *computTableSize, const namespaceInformation *namespacePathToThis,
int supportedReturnValues, int *rvType, int *fpStackUse, int *canHaveDenormalOutput);
_codeHandleFunctionRec *eel_createFunctionNamespacedInstance(compileContext *ctx, _codeHandleFunctionRec *fr, const char *nameptr)
{
size_t n;
_codeHandleFunctionRec *subfr =
fr->isCommonFunction ?
ctx->isSharedFunctions ? newDataBlock(sizeof(_codeHandleFunctionRec),8) :
newCtxDataBlock(sizeof(_codeHandleFunctionRec),8) : // if common function, but derived version is in non-common context, set ownership to VM rather than us
newTmpBlock(ctx,sizeof(_codeHandleFunctionRec));
if (!subfr) return 0;
// fr points to functionname()'s rec, nameptr to blah.functionname()
*subfr = *fr;
n = strlen(nameptr);
if (n > sizeof(subfr->fname)-1) n=sizeof(subfr->fname)-1;
memcpy(subfr->fname,nameptr,n);
subfr->fname[n]=0;
subfr->next = NULL;
subfr->startptr=0; // make sure this code gets recompiled (with correct member ptrs) for this instance!
subfr->startptr_size=-1;
// subfr->derivedCopies already points to the right place
fr->derivedCopies = subfr;
return subfr;
}
static void combineNamespaceFields(char *nm, const namespaceInformation *namespaceInfo, const char *relname, int thisctx) // nm must be NSEEL_MAX_VARIABLE_NAMELEN+1 bytes
{
const char *prefix = namespaceInfo ?
thisctx<0 ? (thisctx == -1 ? namespaceInfo->namespacePathToThis : NULL) : (thisctx < MAX_SUB_NAMESPACES ? namespaceInfo->subParmInfo[thisctx] : NULL)
: NULL;
int lfp = 0, lrn=relname ? (int)strlen(relname) : 0;
if (prefix) while (prefix[lfp] && prefix[lfp] != ':' && lfp < NSEEL_MAX_VARIABLE_NAMELEN) lfp++;
if (!relname) relname = "";
while (*relname == '.') // if relname begins with ., then remove a chunk of context from prefix
{
relname++;
while (lfp>0 && prefix[lfp-1] != '.') lfp--;
if (lfp>0) lfp--;
}
if (lfp > NSEEL_MAX_VARIABLE_NAMELEN-3) lfp=NSEEL_MAX_VARIABLE_NAMELEN-3;
if (lfp>0) memcpy(nm,prefix,lfp);
if (lrn > NSEEL_MAX_VARIABLE_NAMELEN - lfp - (lfp>0)) lrn=NSEEL_MAX_VARIABLE_NAMELEN - lfp - (lfp>0);
if (lrn > 0)
{
if (lfp>0) nm[lfp++] = '.';
memcpy(nm+lfp,relname,lrn);
lfp+=lrn;
}
nm[lfp++]=0;
}
//---------------------------------------------------------------------------------------------------------------
static void *nseel_getBuiltinFunctionAddress(compileContext *ctx,
int fntype, void *fn,
NSEEL_PPPROC *pProc, void ***replList,
void **endP, int *abiInfo, int preferredReturnValues, const EEL_F *hasConstParm1, const EEL_F *hasConstParm2)
{
const EEL_F *firstConstParm = hasConstParm1 ? hasConstParm1 : hasConstParm2;
static void *pow_replptrs[4]={&pow,};
switch (fntype)
{
#define RF(x) *endP = nseel_asm_##x##_end; return (void*)nseel_asm_##x
case FN_MUL_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(mul_op);
case FN_DIV_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(div_op);
case FN_OR_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(or_op);
case FN_XOR_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(xor_op);
case FN_AND_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(and_op);
case FN_MOD_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(mod_op);
case FN_ADD_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(add_op);
case FN_SUB_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(sub_op);
case FN_POW_OP:
*abiInfo=BIF_LASTPARMONSTACK|BIF_CLEARDENORMAL;
*replList = pow_replptrs;
RF(2pdds);
case FN_POW:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK;//BIF_FPSTACKUSE(2) might be safe, need to look at pow()'s implementation, but safer bet is to disallow fp stack caching for this expression
*replList = pow_replptrs;
RF(2pdd);
case FN_ADD:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2);
// for x +- non-denormal-constant, we can set BIF_CLEARDENORMAL
if (firstConstParm && fabs(*firstConstParm) > DENORMAL_CLEARING_THRESHOLD) *abiInfo |= BIF_CLEARDENORMAL;
RF(add);
case FN_SUB:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_FPSTACKUSE(2);
// for x +- non-denormal-constant, we can set BIF_CLEARDENORMAL
if (firstConstParm && fabs(*firstConstParm) > DENORMAL_CLEARING_THRESHOLD) *abiInfo |= BIF_CLEARDENORMAL;
RF(sub);
case FN_MULTIPLY:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2);
// for x*constant-greater-than-eq-1, we can set BIF_WONTMAKEDENORMAL
if (firstConstParm && fabs(*firstConstParm) >= 1.0) *abiInfo |= BIF_WONTMAKEDENORMAL;
RF(mul);
case FN_DIVIDE:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_FPSTACKUSE(2);
// for x/constant-less-than-eq-1, we can set BIF_WONTMAKEDENORMAL
if (firstConstParm && fabs(*firstConstParm) <= 1.0) *abiInfo |= BIF_WONTMAKEDENORMAL;
RF(div);
case FN_MOD:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_FPSTACKUSE(1)|BIF_CLEARDENORMAL;
RF(mod);
case FN_ASSIGN:
*abiInfo = BIF_FPSTACKUSE(1)|BIF_CLEARDENORMAL;
RF(assign);
case FN_AND: *abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL; RF(and);
case FN_OR: *abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL; RF(or);
case FN_XOR:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(xor);
case FN_SHR:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(shr);
case FN_SHL:
*abiInfo = BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK|BIF_FPSTACKUSE(2)|BIF_CLEARDENORMAL;
RF(shl);
#ifndef EEL_TARGET_PORTABLE
case FN_NOTNOT: *abiInfo = BIF_LASTPARM_ASBOOL|BIF_RETURNSBOOL|BIF_FPSTACKUSE(1); RF(uplus);
#else
case FN_NOTNOT: *abiInfo = BIF_LASTPARM_ASBOOL|BIF_RETURNSBOOL|BIF_FPSTACKUSE(1); RF(bnotnot);
#endif
case FN_UMINUS: *abiInfo = BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_WONTMAKEDENORMAL; RF(uminus);
case FN_NOT: *abiInfo = BIF_LASTPARM_ASBOOL|BIF_RETURNSBOOL|BIF_FPSTACKUSE(1); RF(bnot);
case FN_EQ:
*abiInfo = BIF_TWOPARMSONFPSTACK_LAZY|BIF_RETURNSBOOL|BIF_FPSTACKUSE(2);
RF(equal);
case FN_EQ_EXACT:
*abiInfo=BIF_TWOPARMSONFPSTACK_LAZY|BIF_RETURNSBOOL|BIF_FPSTACKUSE(2);
RF(equal_exact);
case FN_NE:
*abiInfo=BIF_TWOPARMSONFPSTACK_LAZY|BIF_RETURNSBOOL|BIF_FPSTACKUSE(2);
RF(notequal);
case FN_NE_EXACT:
*abiInfo=BIF_TWOPARMSONFPSTACK_LAZY|BIF_RETURNSBOOL|BIF_FPSTACKUSE(2);
RF(notequal_exact);
case FN_LOGICAL_AND:
*abiInfo = BIF_RETURNSBOOL;
RF(band);
case FN_LOGICAL_OR:
*abiInfo = BIF_RETURNSBOOL;
RF(bor);
#ifdef GLUE_HAS_FXCH
case FN_GT:
*abiInfo = BIF_TWOPARMSONFPSTACK|BIF_RETURNSBOOL|BIF_FPSTACKUSE(2);
RF(above);
case FN_GTE:
*abiInfo = BIF_TWOPARMSONFPSTACK|BIF_RETURNSBOOL|BIF_REVERSEFPORDER|BIF_FPSTACKUSE(2);
RF(beloweq);
case FN_LT:
*abiInfo = BIF_TWOPARMSONFPSTACK|BIF_RETURNSBOOL|BIF_REVERSEFPORDER|BIF_FPSTACKUSE(2);
RF(above);
case FN_LTE:
*abiInfo = BIF_TWOPARMSONFPSTACK|BIF_RETURNSBOOL|BIF_FPSTACKUSE(2);
RF(beloweq);
#else
case FN_GT:
*abiInfo = BIF_RETURNSBOOL|BIF_LASTPARMONSTACK;
RF(above);
case FN_GTE:
*abiInfo = BIF_RETURNSBOOL|BIF_LASTPARMONSTACK;
RF(aboveeq);
case FN_LT:
*abiInfo = BIF_RETURNSBOOL|BIF_LASTPARMONSTACK;
RF(below);
case FN_LTE:
*abiInfo = BIF_RETURNSBOOL|BIF_LASTPARMONSTACK;
RF(beloweq);
#endif
#undef RF
#define RF(x) *endP = _asm_##x##_end; return (void*)_asm_##x
case FN_MEMORY:
{
static void *replptrs[4]={&__NSEEL_RAMAlloc,};
*replList = replptrs;
*abiInfo = BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1)|BIF_CLEARDENORMAL;
#ifdef GLUE_MEM_NEEDS_PPROC
*pProc = NSEEL_PProc_RAM;
#endif
RF(megabuf);
}
break;
case FN_GMEMORY:
{
static void *replptrs[4]={&__NSEEL_RAMAllocGMEM,};
*replList = replptrs;
*abiInfo=BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1)|BIF_CLEARDENORMAL;
*pProc=NSEEL_PProc_GRAM;
RF(gmegabuf);
}
break;
#undef RF
case FUNCTYPE_FUNCTIONTYPEREC:
if (fn)
{
functionType *p=(functionType *)fn;
// if prefers fpstack or bool, or ignoring value, then use fp-stack versions
if ((preferredReturnValues&(RETURNVALUE_BOOL|RETURNVALUE_FPSTACK)) || !preferredReturnValues)
{
static functionType min2={ "min", nseel_asm_min_fp,nseel_asm_min_fp_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2)|BIF_WONTMAKEDENORMAL };
static functionType max2={ "max", nseel_asm_max_fp,nseel_asm_max_fp_end, 2|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_TWOPARMSONFPSTACK_LAZY|BIF_FPSTACKUSE(2)|BIF_WONTMAKEDENORMAL };
if (p->afunc == (void*)nseel_asm_min) p = &min2;
else if (p->afunc == (void*)nseel_asm_max) p = &max2;
}
*replList=p->replptrs;
*pProc=p->pProc;
*endP = p->func_e;
*abiInfo = p->nParams & BIF_NPARAMS_MASK;
if (firstConstParm)
{
const char *name=p->name;
if (!strcmp(name,"min") && *firstConstParm < -1.0e-10) *abiInfo |= BIF_CLEARDENORMAL;
else if (!strcmp(name,"max") && *firstConstParm > 1.0e-10) *abiInfo |= BIF_CLEARDENORMAL;
}
return p->afunc;
}
break;
}
return 0;
}
static void *nseel_getEELFunctionAddress(compileContext *ctx,
opcodeRec *op,
int *customFuncParmSize, int *customFuncLocalStorageSize,
EEL_F ***customFuncLocalStorage, int *computTableTop,
void **endP, int *isRaw, int wantCodeGenerated,
const namespaceInformation *namespacePathToThis, int *rvMode, int *fpStackUse, int *canHaveDenormalOutput,
opcodeRec **ordered_parmptrs, int num_ordered_parmptrs
) // if wantCodeGenerated is false, can return bogus pointers in raw mode
{
_codeHandleFunctionRec *fn = (_codeHandleFunctionRec*)op->fn;
namespaceInformation local_namespace={NULL};
char prefix_buf[NSEEL_MAX_VARIABLE_NAMELEN+1], nm[NSEEL_MAX_FUNCSIG_NAME+1];
if (!fn) return NULL;
// op->relname ptr is [whatever.]funcname
if (fn->parameterAsNamespaceMask || fn->usesNamespaces)
{
if (wantCodeGenerated)
{
char *p = prefix_buf;
combineNamespaceFields(nm,namespacePathToThis,op->relname,op->namespaceidx);
lstrcpyn_safe(prefix_buf,nm,sizeof(prefix_buf));
local_namespace.namespacePathToThis = prefix_buf;
// nm is full path of function, prefix_buf will be the path not including function name (unless function name only)
while (*p) p++;
while (p >= prefix_buf && *p != '.') p--;
if (p > prefix_buf) *p=0;
}
if (fn->parameterAsNamespaceMask)
{
int x;
for(x=0;x<MAX_SUB_NAMESPACES && x < fn->num_params;x++)
{
if (fn->parameterAsNamespaceMask & (((unsigned int)1)<<x))
{
if (wantCodeGenerated)
{
const char *rn=NULL;
char tmp[NSEEL_MAX_VARIABLE_NAMELEN+1];
if (x < num_ordered_parmptrs && ordered_parmptrs[x])
{
if (ordered_parmptrs[x]->opcodeType == OPCODETYPE_VARPTR)
{
rn=ordered_parmptrs[x]->relname;
}
else if (ordered_parmptrs[x]->opcodeType == OPCODETYPE_VALUE_FROM_NAMESPACENAME)
{
const char *p=ordered_parmptrs[x]->relname;
if (*p == '#') p++;
combineNamespaceFields(tmp,namespacePathToThis,p,ordered_parmptrs[x]->namespaceidx);
rn = tmp;
}
}
if (!rn)
{
// todo: figure out how to give correct line number/offset (ugh)
snprintf(ctx->last_error_string,sizeof(ctx->last_error_string),"parameter %d to %.120s() must be namespace",x+1,fn->fname);
return NULL;
}
lstrcatn(nm,":",sizeof(nm));
local_namespace.subParmInfo[x] = nm+strlen(nm);
lstrcatn(nm,rn,sizeof(nm));
}
ordered_parmptrs[x] = NULL; // prevent caller from bothering generating parameters
}
}
}
if (wantCodeGenerated)
{
_codeHandleFunctionRec *fr = fn;
// find namespace-adjusted function (if generating code, otherwise assume size is the same)
fn = 0; // if this gets re-set, it will be the new function
while (fr && !fn)
{
if (!stricmp(fr->fname,nm)) fn = fr;
fr=fr->derivedCopies;
}
if (!fn) // generate copy of function
{
fn = eel_createFunctionNamespacedInstance(ctx,(_codeHandleFunctionRec*)op->fn,nm);
}
}
}
if (!fn) return NULL;
if (!fn->startptr && fn->opcodes && fn->startptr_size != 0)
{
int sz = fn->startptr_size;
if (sz < 0)
{
fn->tmpspace_req=0;
fn->rvMode = RETURNVALUE_IGNORE;
fn->canHaveDenormalOutput=0;
sz = compileOpcodes(ctx,fn->opcodes,NULL,128*1024*1024,&fn->tmpspace_req,
wantCodeGenerated ? &local_namespace : NULL,RETURNVALUE_NORMAL|RETURNVALUE_FPSTACK,
&fn->rvMode,&fn->fpStackUsage,&fn->canHaveDenormalOutput);
if (sz<0) return NULL;
fn->startptr_size = sz;
}
if (!wantCodeGenerated)
{
// don't compile anything for now, just give stats
if (computTableTop) *computTableTop += fn->tmpspace_req;
*customFuncParmSize = fn->num_params;
*customFuncLocalStorage = fn->localstorage;
*customFuncLocalStorageSize = fn->localstorage_size;
*rvMode = fn->rvMode;
*fpStackUse = fn->fpStackUsage;
if (canHaveDenormalOutput) *canHaveDenormalOutput=fn->canHaveDenormalOutput;
if (sz <= NSEEL_MAX_FUNCTION_SIZE_FOR_INLINE && !(ctx->optimizeDisableFlags&OPTFLAG_NO_INLINEFUNC))
{
*isRaw = 1;
*endP = ((char *)1) + sz;
return (char *)1;
}
*endP = (void*)nseel_asm_fcall_end;
return (void*)nseel_asm_fcall;
}
if (sz <= NSEEL_MAX_FUNCTION_SIZE_FOR_INLINE && !(ctx->optimizeDisableFlags&OPTFLAG_NO_INLINEFUNC))
{
void *p=newTmpBlock(ctx,sz);
fn->tmpspace_req=0;
if (p)
{
fn->canHaveDenormalOutput=0;
if (fn->isCommonFunction) ctx->isGeneratingCommonFunction++;
sz=compileOpcodes(ctx,fn->opcodes,(unsigned char*)p,sz,&fn->tmpspace_req,&local_namespace,RETURNVALUE_NORMAL|RETURNVALUE_FPSTACK,&fn->rvMode,&fn->fpStackUsage,&fn->canHaveDenormalOutput);
if (fn->isCommonFunction) ctx->isGeneratingCommonFunction--;
// recompile function with native context pointers
if (sz>0)
{
fn->startptr_size=sz;
fn->startptr=p;
}
}
}
else
{
unsigned char *codeCall;
fn->tmpspace_req=0;
fn->fpStackUsage=0;
fn->canHaveDenormalOutput=0;
if (fn->isCommonFunction) ctx->isGeneratingCommonFunction++;
codeCall=compileCodeBlockWithRet(ctx,fn->opcodes,&fn->tmpspace_req,&local_namespace,RETURNVALUE_NORMAL|RETURNVALUE_FPSTACK,&fn->rvMode,&fn->fpStackUsage,&fn->canHaveDenormalOutput);
if (fn->isCommonFunction) ctx->isGeneratingCommonFunction--;
if (codeCall)
{
void *f=GLUE_realAddress(nseel_asm_fcall,nseel_asm_fcall_end,&sz);
fn->startptr = newTmpBlock(ctx,sz);
if (fn->startptr)
{
memcpy(fn->startptr,f,sz);
EEL_GLUE_set_immediate(fn->startptr,(INT_PTR)codeCall);
fn->startptr_size = sz;
}
}
}
}
if (fn->startptr)
{
if (computTableTop) *computTableTop += fn->tmpspace_req;
*customFuncParmSize = fn->num_params;
*customFuncLocalStorage = fn->localstorage;
*customFuncLocalStorageSize = fn->localstorage_size;
*rvMode = fn->rvMode;
*fpStackUse = fn->fpStackUsage;
if (canHaveDenormalOutput) *canHaveDenormalOutput= fn->canHaveDenormalOutput;
*endP = (char*)fn->startptr + fn->startptr_size;
*isRaw=1;
return fn->startptr;
}
return 0;
}
// returns true if does something (other than calculating and throwing away a value)
static char optimizeOpcodes(compileContext *ctx, opcodeRec *op, int needsResult)
{
opcodeRec *lastJoinOp=NULL;
char retv, retv_parm[3], joined_retv=0;
while (op && op->opcodeType == OPCODETYPE_FUNC2 && op->fntype == FN_JOIN_STATEMENTS)
{
if (!optimizeOpcodes(ctx,op->parms.parms[0], 0) || OPCODE_IS_TRIVIAL(op->parms.parms[0]))
{
// direct value, can skip ourselves
memcpy(op,op->parms.parms[1],sizeof(*op));
}
else
{
joined_retv |= 1;
lastJoinOp = op;
op = op->parms.parms[1];
}
}
goto start_over;
#define RESTART_DIRECTVALUE(X) { op->parms.dv.directValue = (X); goto start_over_directvalue; }
start_over_directvalue:
op->opcodeType = OPCODETYPE_DIRECTVALUE;
op->parms.dv.valuePtr=NULL;
start_over: // when an opcode changed substantially in optimization, goto here to reprocess it
retv = retv_parm[0]=retv_parm[1]=retv_parm[2]=0;
if (!op || // should never really happen
OPCODE_IS_TRIVIAL(op) || // should happen often (vars)
op->opcodeType < 0 || op->opcodeType >= OPCODETYPE_INVALID // should never happen (assert would be appropriate heh)
) return joined_retv;
if (!needsResult)
{
if (op->fntype == FUNCTYPE_EELFUNC)
{
needsResult=1; // assume eel functions are non-const for now
}
else if (op->fntype == FUNCTYPE_FUNCTIONTYPEREC)
{
functionType *pfn = (functionType *)op->fn;
if (!pfn || !(pfn->nParams&NSEEL_NPARAMS_FLAG_CONST)) needsResult=1;
}
else if (op->fntype >= FN_NONCONST_BEGIN && op->fntype < FUNCTYPE_SIMPLEMAX)
{
needsResult=1;
}
}
if (op->opcodeType>=OPCODETYPE_FUNC2) retv_parm[1] = optimizeOpcodes(ctx,op->parms.parms[1], needsResult);
if (op->opcodeType>=OPCODETYPE_FUNC3) retv_parm[2] = optimizeOpcodes(ctx,op->parms.parms[2], needsResult);
retv_parm[0] = optimizeOpcodes(ctx,op->parms.parms[0], needsResult ||
(FNPTR_HAS_CONDITIONAL_EXEC(op) && (retv_parm[1] || retv_parm[2] || op->opcodeType <= OPCODETYPE_FUNC1)) );
if (op->opcodeType != OPCODETYPE_MOREPARAMS)
{
if (op->fntype >= 0 && op->fntype < FUNCTYPE_SIMPLEMAX)
{
if (op->opcodeType == OPCODETYPE_FUNC1) // within FUNCTYPE_SIMPLE
{
if (op->parms.parms[0]->opcodeType == OPCODETYPE_DIRECTVALUE)
{
switch (op->fntype)
{
case FN_NOTNOT: RESTART_DIRECTVALUE(fabs(op->parms.parms[0]->parms.dv.directValue)>=NSEEL_CLOSEFACTOR ? 1.0 : 0.0);
case FN_NOT: RESTART_DIRECTVALUE(fabs(op->parms.parms[0]->parms.dv.directValue)>=NSEEL_CLOSEFACTOR ? 0.0 : 1.0);
case FN_UMINUS: RESTART_DIRECTVALUE(- op->parms.parms[0]->parms.dv.directValue);
}
}
else if (op->fntype == FN_NOT || op->fntype == FN_NOTNOT)
{
if (op->parms.parms[0]->opcodeType == OPCODETYPE_FUNC1)
{
switch (op->parms.parms[0]->fntype)
{
case FN_UMINUS:
case FN_NOTNOT: // ignore any NOTNOTs UMINUS or UPLUS, they would have no effect anyway
op->parms.parms[0] = op->parms.parms[0]->parms.parms[0];
goto start_over;
case FN_NOT:
op->fntype = op->fntype==FN_NOT ? FN_NOTNOT : FN_NOT; // switch between FN_NOT and FN_NOTNOT
op->parms.parms[0] = op->parms.parms[0]->parms.parms[0];
goto start_over;
}
}
else if (op->parms.parms[0]->opcodeType == OPCODETYPE_FUNC2)
{
int repl_type = -1;
switch (op->parms.parms[0]->fntype)
{
case FN_EQ: repl_type = FN_NE; break;
case FN_NE: repl_type = FN_EQ; break;
case FN_EQ_EXACT: repl_type = FN_NE_EXACT; break;
case FN_NE_EXACT: repl_type = FN_EQ_EXACT; break;
case FN_LT: repl_type = FN_GTE; break;
case FN_LTE: repl_type = FN_GT; break;
case FN_GT: repl_type = FN_LTE; break;
case FN_GTE: repl_type = FN_LT; break;
}
if (repl_type != -1)
{
const int oldtype = op->fntype;
memcpy(op,op->parms.parms[0],sizeof(*op));
if (oldtype == FN_NOT) op->fntype = repl_type;
goto start_over;
}
}
}
}
else if (op->opcodeType == OPCODETYPE_FUNC2) // within FUNCTYPE_SIMPLE
{
const int dv0 = op->parms.parms[0]->opcodeType == OPCODETYPE_DIRECTVALUE;
const int dv1 = op->parms.parms[1]->opcodeType == OPCODETYPE_DIRECTVALUE;
if (dv0 && dv1)
{
int reval = -1;
switch (op->fntype)
{
case FN_MOD:
{
int a = (int) op->parms.parms[1]->parms.dv.directValue;
if (a)
{
a = (int) op->parms.parms[0]->parms.dv.directValue % a;
if (a<0) a=-a;
}
RESTART_DIRECTVALUE((EEL_F)a);
}
break;
case FN_SHL: RESTART_DIRECTVALUE(((int)op->parms.parms[0]->parms.dv.directValue) << ((int)op->parms.parms[1]->parms.dv.directValue));
case FN_SHR: RESTART_DIRECTVALUE(((int)op->parms.parms[0]->parms.dv.directValue) >> ((int)op->parms.parms[1]->parms.dv.directValue));
case FN_POW: RESTART_DIRECTVALUE(pow(op->parms.parms[0]->parms.dv.directValue, op->parms.parms[1]->parms.dv.directValue));
case FN_DIVIDE: RESTART_DIRECTVALUE(op->parms.parms[0]->parms.dv.directValue / op->parms.parms[1]->parms.dv.directValue);
case FN_MULTIPLY: RESTART_DIRECTVALUE(op->parms.parms[0]->parms.dv.directValue * op->parms.parms[1]->parms.dv.directValue);
case FN_ADD: RESTART_DIRECTVALUE(op->parms.parms[0]->parms.dv.directValue + op->parms.parms[1]->parms.dv.directValue);
case FN_SUB: RESTART_DIRECTVALUE(op->parms.parms[0]->parms.dv.directValue - op->parms.parms[1]->parms.dv.directValue);
case FN_AND: RESTART_DIRECTVALUE((double) (((WDL_INT64)op->parms.parms[0]->parms.dv.directValue) & ((WDL_INT64)op->parms.parms[1]->parms.dv.directValue)));
case FN_OR: RESTART_DIRECTVALUE((double) (((WDL_INT64)op->parms.parms[0]->parms.dv.directValue) | ((WDL_INT64)op->parms.parms[1]->parms.dv.directValue)));
case FN_XOR: RESTART_DIRECTVALUE((double) (((WDL_INT64)op->parms.parms[0]->parms.dv.directValue) ^ ((WDL_INT64)op->parms.parms[1]->parms.dv.directValue)));
case FN_EQ: reval = fabs(op->parms.parms[0]->parms.dv.directValue - op->parms.parms[1]->parms.dv.directValue) < NSEEL_CLOSEFACTOR; break;
case FN_NE: reval = fabs(op->parms.parms[0]->parms.dv.directValue - op->parms.parms[1]->parms.dv.directValue) >= NSEEL_CLOSEFACTOR; break;
case FN_EQ_EXACT: reval = op->parms.parms[0]->parms.dv.directValue == op->parms.parms[1]->parms.dv.directValue; break;
case FN_NE_EXACT: reval = op->parms.parms[0]->parms.dv.directValue != op->parms.parms[1]->parms.dv.directValue; break;
case FN_LT: reval = op->parms.parms[0]->parms.dv.directValue < op->parms.parms[1]->parms.dv.directValue; break;
case FN_LTE: reval = op->parms.parms[0]->parms.dv.directValue <= op->parms.parms[1]->parms.dv.directValue; break;
case FN_GT: reval = op->parms.parms[0]->parms.dv.directValue > op->parms.parms[1]->parms.dv.directValue; break;
case FN_GTE: reval = op->parms.parms[0]->parms.dv.directValue >= op->parms.parms[1]->parms.dv.directValue; break;
case FN_LOGICAL_AND: reval = fabs(op->parms.parms[0]->parms.dv.directValue) >= NSEEL_CLOSEFACTOR && fabs(op->parms.parms[1]->parms.dv.directValue) >= NSEEL_CLOSEFACTOR; break;
case FN_LOGICAL_OR: reval = fabs(op->parms.parms[0]->parms.dv.directValue) >= NSEEL_CLOSEFACTOR || fabs(op->parms.parms[1]->parms.dv.directValue) >= NSEEL_CLOSEFACTOR; break;
}
if (reval >= 0) RESTART_DIRECTVALUE((EEL_F) reval);
}
else if (dv0 || dv1)
{
double dvalue = op->parms.parms[!dv0]->parms.dv.directValue;
switch (op->fntype)
{
case FN_OR:
case FN_XOR:
if (!(WDL_INT64)dvalue)
{
// replace with or0
static functionType fr={"or0",nseel_asm_or0, nseel_asm_or0_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_LASTPARMONSTACK|BIF_RETURNSONSTACK|BIF_CLEARDENORMAL, {0}, NULL};
op->opcodeType = OPCODETYPE_FUNC1;
op->fntype = FUNCTYPE_FUNCTIONTYPEREC;
op->fn = &fr;
if (dv0) op->parms.parms[0] = op->parms.parms[1];
goto start_over;
}
break;
case FN_SUB:
if (dv0)
{
if (dvalue == 0.0)
{
op->opcodeType = OPCODETYPE_FUNC1;
op->fntype = FN_UMINUS;
op->parms.parms[0] = op->parms.parms[1];
goto start_over;
}
break;
}
// fall through, if dv1 we can remove +0.0
case FN_ADD:
if (dvalue == 0.0)
{
memcpy(op,op->parms.parms[!!dv0],sizeof(*op));
goto start_over;
}
break;
case FN_AND:
if ((WDL_INT64)dvalue) break;
dvalue = 0.0; // treat x&0 as x*0, which optimizes to 0
// fall through
case FN_MULTIPLY:
if (dvalue == 0.0) // remove multiply by 0.0 (using 0.0 direct value as replacement), unless the nonzero side did something
{
if (!retv_parm[!!dv0])
{
memcpy(op,op->parms.parms[!dv0],sizeof(*op)); // set to 0 if other action wouldn't do anything
goto start_over;
}
else
{
// this is 0.0 * oldexpressionthatmustbeprocessed or oldexpressionthatmustbeprocessed*0.0
op->fntype = FN_JOIN_STATEMENTS;
if (dv0) // 0.0*oldexpression, reverse the order so that 0 is returned
{
// set to (oldexpression;0)
opcodeRec *tmp = op->parms.parms[1];
op->parms.parms[1] = op->parms.parms[0];
op->parms.parms[0] = tmp;
}
goto start_over;
}
}
else if (dvalue == 1.0) // remove multiply by 1.0 (using non-1.0 value as replacement)
{
memcpy(op,op->parms.parms[!!dv0],sizeof(*op));
goto start_over;
}
break;
case FN_POW:
if (dv1)
{
// x^0 = 1
if (fabs(dvalue) < 1e-30)
{
RESTART_DIRECTVALUE(1.0);
}
// x^1 = x
if (fabs(dvalue-1.0) < 1e-30)
{
memcpy(op,op->parms.parms[0],sizeof(*op));
goto start_over;
}
}
else if (dv0)
{
// pow(constant, x) = exp((x) * ln(constant)), if constant>0
// opcodeRec *parm0 = op->parms.parms[0];
if (dvalue > 0.0)
{
static functionType expcpy={ "exp", nseel_asm_1pdd,nseel_asm_1pdd_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK, {&exp}, };
// 1^x = 1
if (fabs(dvalue-1.0) < 1e-30)
{
RESTART_DIRECTVALUE(1.0);
}
dvalue=log(dvalue);
if (fabs(dvalue-1.0) < 1e-9)
{
// caller wanted e^x
op->parms.parms[0]=op->parms.parms[1];
}
else
{
// it would be nice to replace 10^x with exp(log(10)*x) or 2^x with exp(log(2),x), but
// doing so breaks rounding. we could maybe only allow 10^x, which is used for dB conversion,
// but for now we should just force the programmer do it exp(log(10)*x) themselves.
break;
/*
parm0->opcodeType = OPCODETYPE_FUNC2;
parm0->fntype = FN_MULTIPLY;
parm0->parms.parms[0] = nseel_createCompiledValue(ctx,dvalue);
parm0->parms.parms[1] = op->parms.parms[1];
*/
}
op->opcodeType = OPCODETYPE_FUNC1;
op->fntype = FUNCTYPE_FUNCTIONTYPEREC;
op->fn = &expcpy;
goto start_over;
}
}
break;
case FN_MOD:
if (dv1)
{
const int a = (int) dvalue;
if (!a)
{
RESTART_DIRECTVALUE(0.0);
}
}
break;
case FN_DIVIDE:
if (dv1)
{
if (dvalue == 1.0) // remove divide by 1.0 (using non-1.0 value as replacement)
{
memcpy(op,op->parms.parms[!!dv0],sizeof(*op));
goto start_over;
}
else
{
// change to a multiply
if (dvalue == 0.0)
{
op->fntype = FN_MULTIPLY;
goto start_over;
}
else
{
double d = 1.0/dvalue;
WDL_DenormalDoubleAccess *p = (WDL_DenormalDoubleAccess*)&d;
// allow conversion to multiply if reciprocal is exact
// we could also just look to see if the last few digits of the mantissa were 0, which would probably be good
// enough, but if the user really wants it they should do * (1/x) instead to force precalculation of reciprocal.
if (!p->w.lw && !(p->w.hw & 0xfffff))
{
op->fntype = FN_MULTIPLY;
op->parms.parms[1]->parms.dv.directValue = d;
op->parms.parms[1]->parms.dv.valuePtr=NULL;
goto start_over;
}
}
}
}
else if (dvalue == 0.0)
{
if (!retv_parm[!!dv0])
{
// if 0/x set to always 0.
// this is 0.0 / (oldexpression that can be eliminated)
memcpy(op,op->parms.parms[!dv0],sizeof(*op)); // set to 0 if other action wouldn't do anything
}
else
{
opcodeRec *tmp;
// this is 0.0 / oldexpressionthatmustbeprocessed
op->fntype = FN_JOIN_STATEMENTS;
tmp = op->parms.parms[1];
op->parms.parms[1] = op->parms.parms[0];
op->parms.parms[0] = tmp;
// set to (oldexpression;0)
}
goto start_over;
}
break;
case FN_EQ:
if (dvalue == 0.0)
{
// convert x == 0.0 to !x
op->opcodeType=OPCODETYPE_FUNC1;
op->fntype = FN_NOT;
if (dv0) op->parms.parms[0]=op->parms.parms[1];
goto start_over;
}
break;
case FN_NE:
if (dvalue == 0.0)
{
// convert x != 0.0 to !!
op->opcodeType=OPCODETYPE_FUNC1;
op->fntype = FN_NOTNOT;
if (dv0) op->parms.parms[0]=op->parms.parms[1];
goto start_over;
}
break;
case FN_LOGICAL_AND:
if (dv0)
{
// dvalue && expr
if (fabs(dvalue) < NSEEL_CLOSEFACTOR)
{
// 0 && expr, replace with 0
RESTART_DIRECTVALUE(0.0);
}
else
{
// 1 && expr, replace with 0 != expr
op->fntype = FN_NE;
op->parms.parms[0]->parms.dv.valuePtr=NULL;
op->parms.parms[0]->parms.dv.directValue = 0.0;
}
}
else
{
// expr && dvalue
if (fabs(dvalue) < NSEEL_CLOSEFACTOR)
{
// expr && 0
if (!retv_parm[0])
{
// expr has no consequence, drop it
RESTART_DIRECTVALUE(0.0);
}
else
{
// replace with (expr; 0)
op->fntype = FN_JOIN_STATEMENTS;
op->parms.parms[1]->parms.dv.valuePtr=NULL;
op->parms.parms[1]->parms.dv.directValue = 0.0;
}
}
else
{
// expr && 1, replace with expr != 0
op->fntype = FN_NE;
op->parms.parms[1]->parms.dv.valuePtr=NULL;
op->parms.parms[1]->parms.dv.directValue = 0.0;
}
}
goto start_over;
case FN_LOGICAL_OR:
if (dv0)
{
// dvalue || expr
if (fabs(dvalue) >= NSEEL_CLOSEFACTOR)
{
// 1 || expr, replace with 1
RESTART_DIRECTVALUE(1.0);
}
else
{
// 0 || expr, replace with 0 != expr
op->fntype = FN_NE;
op->parms.parms[0]->parms.dv.valuePtr=NULL;
op->parms.parms[0]->parms.dv.directValue = 0.0;
}
}
else
{
// expr || dvalue
if (fabs(dvalue) >= NSEEL_CLOSEFACTOR)
{
// expr || 1
if (!retv_parm[0])
{
// expr has no consequence, drop it and return 1
RESTART_DIRECTVALUE(1.0);
}
else
{
// replace with (expr; 1)
op->fntype = FN_JOIN_STATEMENTS;
op->parms.parms[1]->parms.dv.valuePtr=NULL;
op->parms.parms[1]->parms.dv.directValue = 1.0;
}
}
else
{
// expr || 0, replace with expr != 0
op->fntype = FN_NE;
op->parms.parms[1]->parms.dv.valuePtr=NULL;
op->parms.parms[1]->parms.dv.directValue = 0.0;
}
}
goto start_over;
}
} // dv0 || dv1
// general optimization of two parameters
switch (op->fntype)
{
case FN_MULTIPLY:
{
opcodeRec *first_parm = op->parms.parms[0],*second_parm = op->parms.parms[1];
if (second_parm->opcodeType == first_parm->opcodeType)
{
switch(first_parm->opcodeType)
{
case OPCODETYPE_VALUE_FROM_NAMESPACENAME:
if (first_parm->namespaceidx != second_parm->namespaceidx) break;
// fall through
case OPCODETYPE_VARPTR:
if (first_parm->relname && second_parm->relname && !stricmp(second_parm->relname,first_parm->relname)) second_parm=NULL;
break;
case OPCODETYPE_VARPTRPTR:
if (first_parm->parms.dv.valuePtr && first_parm->parms.dv.valuePtr==second_parm->parms.dv.valuePtr) second_parm=NULL;
break;
}
if (!second_parm) // switch from x*x to sqr(x)
{
static functionType sqrcpy={ "sqr", nseel_asm_sqr,nseel_asm_sqr_end, 1|NSEEL_NPARAMS_FLAG_CONST|BIF_RETURNSONSTACK|BIF_LASTPARMONSTACK|BIF_FPSTACKUSE(1) };
op->opcodeType = OPCODETYPE_FUNC1;
op->fntype = FUNCTYPE_FUNCTIONTYPEREC;
op->fn = &sqrcpy;
goto start_over;
}
}
}
break;
case FN_POW:
{
opcodeRec *first_parm = op->parms.parms[0];
if (first_parm->opcodeType == op->opcodeType && first_parm->fntype == FN_POW)
{
// since first_parm is a pow too, we can multiply the exponents.
// set our base to be the base of the inner pow
op->parms.parms[0] = first_parm->parms.parms[0];
// make the old extra pow be a multiply of the exponents
first_parm->fntype = FN_MULTIPLY;
first_parm->parms.parms[0] = op->parms.parms[1];
// put that as the exponent
op->parms.parms[1] = first_parm;
goto start_over;
}
}
break;
case FN_LOGICAL_AND:
case FN_LOGICAL_OR:
if (op->parms.parms[0]->fntype == FN_NOTNOT)
{
// remove notnot, unnecessary for input to &&/|| operators
op->parms.parms[0] = op->parms.parms[0]->parms.parms[0];
goto start_over;
}
if (op->parms.parms[1]->fntype == FN_NOTNOT)
{
// remove notnot, unnecessary for input to &&/|| operators
op->parms.parms[1] = op->parms.parms[1]->parms.parms[0];
goto start_over;
}
break;
}
}
else if (op->opcodeType==OPCODETYPE_FUNC3) // within FUNCTYPE_SIMPLE
{
if (op->fntype == FN_IF_ELSE)
{
if (op->parms.parms[0]->opcodeType == OPCODETYPE_DIRECTVALUE)
{
int s = fabs(op->parms.parms[0]->parms.dv.directValue) >= NSEEL_CLOSEFACTOR;
memcpy(op,op->parms.parms[s ? 1 : 2],sizeof(opcodeRec));
goto start_over;
}
if (op->parms.parms[0]->opcodeType == OPCODETYPE_FUNC1)
{
if (op->parms.parms[0]->fntype == FN_NOTNOT)
{
// remove notnot, unnecessary for input to ? operator
op->parms.parms[0] = op->parms.parms[0]->parms.parms[0];
goto start_over;
}
}
}
}
if (op->fntype >= FN_NONCONST_BEGIN && op->fntype < FUNCTYPE_SIMPLEMAX) retv|=1;
// FUNCTYPE_SIMPLE
}
else if (op->fntype == FUNCTYPE_FUNCTIONTYPEREC && op->fn)
{
/*
probably worth doing reduction on:
_divop (constant change to multiply)
_and
_or
abs
maybe:
min
max
also, optimize should (recursively or maybe iteratively?) search transitive functions (mul/div) for more constant reduction possibilities
*/
functionType *pfn = (functionType *)op->fn;
if (!(pfn->nParams&NSEEL_NPARAMS_FLAG_CONST)) retv|=1;
if (op->opcodeType==OPCODETYPE_FUNC1) // within FUNCTYPE_FUNCTIONTYPEREC
{
if (op->parms.parms[0]->opcodeType == OPCODETYPE_DIRECTVALUE)
{
int suc=1;
EEL_F v = op->parms.parms[0]->parms.dv.directValue;
#define DOF(x) if (!strcmp(pfn->name,#x)) v = x(v); else
#define DOF2(x,y) if (!strcmp(pfn->name,#x)) v = x(y); else
DOF(sin)
DOF(cos)
DOF(tan)
DOF(asin)
DOF(acos)
DOF(atan)
DOF2(sqrt, fabs(v))
DOF(exp)
DOF(log)
DOF(log10)
/* else */ suc=0;
#undef DOF
#undef DOF2
if (suc)
{
RESTART_DIRECTVALUE(v);
}
}
}
else if (op->opcodeType==OPCODETYPE_FUNC2) // within FUNCTYPE_FUNCTIONTYPEREC
{
const int dv0=op->parms.parms[0]->opcodeType == OPCODETYPE_DIRECTVALUE;
const int dv1=op->parms.parms[1]->opcodeType == OPCODETYPE_DIRECTVALUE;
if (dv0 && dv1)
{
if (!strcmp(pfn->name,"atan2"))
{
RESTART_DIRECTVALUE(atan2(op->parms.parms[0]->parms.dv.directValue, op->parms.parms[1]->parms.dv.directValue));
}
}
}
// FUNCTYPE_FUNCTIONTYPEREC
}
else
{
// unknown or eel func, assume non-const
retv |= 1;
}
}
// if we need results, or our function has effects itself, then finish
if (retv || needsResult)
{
return retv || joined_retv || retv_parm[0] || retv_parm[1] || retv_parm[2];
}
// we don't need results here, and our function is const, which means we can remove it
{
int cnt=0, idx1=0, idx2=0, x;
for (x=0;x<3;x++) if (retv_parm[x]) { if (!cnt++) idx1=x; else idx2=x; }
if (!cnt) // none of the parameters do anything, remove this opcode
{
if (lastJoinOp)
{
// replace previous join with its first linked opcode, removing this opcode completely
memcpy(lastJoinOp,lastJoinOp->parms.parms[0],sizeof(*lastJoinOp));
}
else if (op->opcodeType != OPCODETYPE_DIRECTVALUE)
{
// allow caller to easily detect this as trivial and remove it
op->opcodeType = OPCODETYPE_DIRECTVALUE;
op->parms.dv.valuePtr=NULL;
op->parms.dv.directValue=0.0;
}
// return joined_retv below
}
else
{
// if parameters are non-const, and we're a conditional, preserve our function
if (FNPTR_HAS_CONDITIONAL_EXEC(op)) return 1;
// otherwise, condense into either the non-const statement, or a join
if (cnt==1)
{
memcpy(op,op->parms.parms[idx1],sizeof(*op));
}
else if (cnt == 2)
{
op->opcodeType = OPCODETYPE_FUNC2;
op->fntype = FN_JOIN_STATEMENTS;
op->fn = op;
op->parms.parms[0] = op->parms.parms[idx1];
op->parms.parms[1] = op->parms.parms[idx2];
op->parms.parms[2] = NULL;
}
else
{
// todo need to create a new opcodeRec here, for now just leave as is
// (non-conditional const 3 parameter functions are rare anyway)
}
return 1;
}
}
return joined_retv;
}
static int generateValueToReg(compileContext *ctx, opcodeRec *op, unsigned char *bufOut, int whichReg, const namespaceInformation *functionPrefix, int allowCache)
{
EEL_F *b=NULL;
if (op->opcodeType==OPCODETYPE_VALUE_FROM_NAMESPACENAME)
{
char nm[NSEEL_MAX_VARIABLE_NAMELEN+1];
const char *p = op->relname;
combineNamespaceFields(nm,functionPrefix,p+(*p == '#'),op->namespaceidx);
if (!nm[0]) return -1;
if (*p == '#')
{
if (ctx->isGeneratingCommonFunction)
b = newCtxDataBlock(sizeof(EEL_F),sizeof(EEL_F));
else
b = newDataBlock(sizeof(EEL_F),sizeof(EEL_F));
if (!b) RET_MINUS1_FAIL("error creating storage for str")
if (!ctx->onNamedString) return -1; // should never happen, will not generate OPCODETYPE_VALUE_FROM_NAMESPACENAME with # prefix if !onNamedString
*b = ctx->onNamedString(ctx->caller_this,nm);
}
else
{
b = nseel_int_register_var(ctx,nm,0,NULL);
if (!b) RET_MINUS1_FAIL("error registering var")
}
}
else
{
if (op->opcodeType != OPCODETYPE_DIRECTVALUE) allowCache=0;
if (op->opcodeType==OPCODETYPE_DIRECTVALUE_TEMPSTRING && ctx->onNamedString)
{
op->parms.dv.directValue = ctx->onNamedString(ctx->caller_this,"");
op->parms.dv.valuePtr = NULL;
}
b=op->parms.dv.valuePtr;
if (!b && op->opcodeType == OPCODETYPE_VARPTR && op->relname && op->relname[0])
{
op->parms.dv.valuePtr = b = nseel_int_register_var(ctx,op->relname,0,NULL);
}
if (b && op->opcodeType == OPCODETYPE_VARPTRPTR) b = *(EEL_F **)b;
if (!b && allowCache)
{
int n=50; // only scan last X items
opcodeRec *r = ctx->directValueCache;
while (r && n--)
{
if (r->parms.dv.directValue == op->parms.dv.directValue && (b=r->parms.dv.valuePtr)) break;
r=(opcodeRec*)r->fn;
}
}
if (!b)
{
ctx->l_stats[3]++;
if (ctx->isGeneratingCommonFunction)
b = newCtxDataBlock(sizeof(EEL_F),sizeof(EEL_F));
else
b = newDataBlock(sizeof(EEL_F),sizeof(EEL_F));
if (!b) RET_MINUS1_FAIL("error allocating data block")
if (op->opcodeType != OPCODETYPE_VARPTRPTR) op->parms.dv.valuePtr = b;
#if EEL_F_SIZE == 8
*b = denormal_filter_double2(op->parms.dv.directValue);
#else
*b = denormal_filter_float2(op->parms.dv.directValue);
#endif
if (allowCache)
{
op->fn = ctx->directValueCache;
ctx->directValueCache = op;
}
}
}
GLUE_MOV_PX_DIRECTVALUE_GEN(bufOut,(INT_PTR)b,whichReg);
return GLUE_MOV_PX_DIRECTVALUE_SIZE;
}
unsigned char *compileCodeBlockWithRet(compileContext *ctx, opcodeRec *rec, int *computTableSize, const namespaceInformation *namespacePathToThis,
int supportedReturnValues, int *rvType, int *fpStackUsage, int *canHaveDenormalOutput)
{
unsigned char *p, *newblock2;
// generate code call
int funcsz=compileOpcodes(ctx,rec,NULL,1024*1024*128,NULL,namespacePathToThis,supportedReturnValues, rvType,fpStackUsage, NULL);
if (funcsz<0) return NULL;
p = newblock2 = newCodeBlock(funcsz+ sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE,32);
if (!newblock2) return NULL;
#if GLUE_FUNC_ENTER_SIZE > 0
memcpy(p,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE);
p += GLUE_FUNC_ENTER_SIZE;
#endif
*fpStackUsage=0;
funcsz=compileOpcodes(ctx,rec,p, funcsz, computTableSize,namespacePathToThis,supportedReturnValues, rvType,fpStackUsage, canHaveDenormalOutput);
if (funcsz<0) return NULL;
p+=funcsz;
#if GLUE_FUNC_LEAVE_SIZE > 0
memcpy(p,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE);
p+=GLUE_FUNC_LEAVE_SIZE;
#endif
memcpy(p,&GLUE_RET,sizeof(GLUE_RET)); p+=sizeof(GLUE_RET);
#if defined(__arm__) || defined(__aarch64__)
__clear_cache(newblock2,p);
#endif
ctx->l_stats[2]+=funcsz+2;
return newblock2;
}
static int compileNativeFunctionCall(compileContext *ctx, opcodeRec *op, unsigned char *bufOut, int bufOut_len, int *computTableSize, const namespaceInformation *namespacePathToThis,
int *rvMode, int *fpStackUsage, int preferredReturnValues, int *canHaveDenormalOutput)
{
// builtin function generation
int func_size=0;
int cfunc_abiinfo=0;
int local_fpstack_use=0; // how many items we have pushed onto the fp stack
int parm_size=0;
int restore_stack_amt=0;
void *func_e=NULL;
NSEEL_PPPROC preProc=0;
void **repl=NULL;
int n_params= 1 + op->opcodeType - OPCODETYPE_FUNC1;
const int parm0_dv = op->parms.parms[0]->opcodeType == OPCODETYPE_DIRECTVALUE;
const int parm1_dv = n_params > 1 && op->parms.parms[1]->opcodeType == OPCODETYPE_DIRECTVALUE;
void *func = nseel_getBuiltinFunctionAddress(ctx, op->fntype, op->fn, &preProc,&repl,&func_e,&cfunc_abiinfo,preferredReturnValues,
parm0_dv ? &op->parms.parms[0]->parms.dv.directValue : NULL,
parm1_dv ? &op->parms.parms[1]->parms.dv.directValue : NULL
);
if (!func) RET_MINUS1_FAIL("error getting funcaddr")
*fpStackUsage=BIF_GETFPSTACKUSE(cfunc_abiinfo);
*rvMode = RETURNVALUE_NORMAL;
if (cfunc_abiinfo & BIF_TAKES_VARPARM)
{
#if defined(__arm__) || (defined (_M_ARM) && _M_ARM == 7)
const int max_params=16384; // arm uses up to two instructions, should be good for at leaast 64k (16384*4)
#elif defined(__ppc__)
const int max_params=4096; // 32kb max offset addressing for stack, so 4096*4 = 16384, should be safe
#elif defined(__aarch64__)
const int max_params=32768;
#else
const int max_params=32768; // sanity check, the stack is free to grow on x86/x86-64
#endif
int x;
// this mode is less efficient in that it creates a list of pointers on the stack to pass to the function
// but it is more flexible and works for >3 parameters.
if (op->opcodeType == OPCODETYPE_FUNCX)
{
n_params=0;
for (x=0;x<3;x++)
{
opcodeRec *prni=op->parms.parms[x];
while (prni)
{
const int isMP = prni->opcodeType == OPCODETYPE_MOREPARAMS;
n_params++;
if (!isMP||n_params>=max_params) break;
prni = prni->parms.parms[1];
}
}
}
restore_stack_amt = (sizeof(void *) * n_params + 15)&~15;
if (restore_stack_amt)
{
int offs = restore_stack_amt;
while (offs > 0)
{
int amt = offs;
if (amt > 4096) amt=4096;
if (bufOut_len < parm_size+GLUE_MOVE_STACK_SIZE) RET_MINUS1_FAIL("insufficient size for varparm")
if (bufOut) GLUE_MOVE_STACK(bufOut+parm_size, - amt);
parm_size += GLUE_MOVE_STACK_SIZE;
offs -= amt;
if (offs>0) // make sure this page is in memory
{
if (bufOut_len < parm_size+GLUE_STORE_P1_TO_STACK_AT_OFFS_SIZE(0))
RET_MINUS1_FAIL("insufficient size for varparm stackchk")
if (bufOut) GLUE_STORE_P1_TO_STACK_AT_OFFS(bufOut+parm_size,0);
parm_size += GLUE_STORE_P1_TO_STACK_AT_OFFS_SIZE(0);
}
}
}
if (op->opcodeType == OPCODETYPE_FUNCX)
{
n_params=0;
for (x=0;x<3;x++)
{
opcodeRec *prni=op->parms.parms[x];
while (prni)
{
const int isMP = prni->opcodeType == OPCODETYPE_MOREPARAMS;
opcodeRec *r = isMP ? prni->parms.parms[0] : prni;
if (r)
{
int canHaveDenorm=0;
int rvt=RETURNVALUE_NORMAL;
int subfpstackuse=0, use_offs;
int lsz = compileOpcodes(ctx,r,bufOut ? bufOut + parm_size : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, rvt,&rvt, &subfpstackuse, &canHaveDenorm);
if (canHaveDenorm && canHaveDenormalOutput) *canHaveDenormalOutput = 1;
if (lsz<0) RET_MINUS1_FAIL("call coc for varparmX failed")
if (rvt != RETURNVALUE_NORMAL) RET_MINUS1_FAIL("call coc for varparmX gave bad type back");
parm_size += lsz;
use_offs = n_params*(int) sizeof(void *);
if (bufOut_len < parm_size+GLUE_STORE_P1_TO_STACK_AT_OFFS_SIZE(use_offs))
RET_MINUS1_FAIL("call coc for varparmX size");
if (bufOut) GLUE_STORE_P1_TO_STACK_AT_OFFS(bufOut + parm_size, use_offs);
parm_size+=GLUE_STORE_P1_TO_STACK_AT_OFFS_SIZE(use_offs);
if (subfpstackuse+local_fpstack_use > *fpStackUsage) *fpStackUsage = subfpstackuse+local_fpstack_use;
}
else RET_MINUS1_FAIL("zero parameter varparmX")
n_params++;
if (!isMP||n_params>=max_params) break;
prni = prni->parms.parms[1];
}
}
}
else for (x=0;x<n_params;x++)
{
opcodeRec *r = op->parms.parms[x];
if (r)
{
int canHaveDenorm=0;
int subfpstackuse=0;
int rvt=RETURNVALUE_NORMAL;
int use_offs;
int lsz = compileOpcodes(ctx,r,bufOut ? bufOut + parm_size : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, rvt,&rvt, &subfpstackuse, &canHaveDenorm);
if (canHaveDenorm && canHaveDenormalOutput) *canHaveDenormalOutput = 1;
if (lsz<0) RET_MINUS1_FAIL("call coc for varparm123 failed")
if (rvt != RETURNVALUE_NORMAL) RET_MINUS1_FAIL("call coc for varparm123 gave bad type back");
parm_size += lsz;
use_offs = x*(int)sizeof(void *);
if (bufOut_len < parm_size+GLUE_STORE_P1_TO_STACK_AT_OFFS_SIZE(use_offs))
RET_MINUS1_FAIL("call coc for varparm123 size");
if (bufOut) GLUE_STORE_P1_TO_STACK_AT_OFFS(bufOut + parm_size, use_offs);
parm_size+=GLUE_STORE_P1_TO_STACK_AT_OFFS_SIZE(use_offs);
if (subfpstackuse+local_fpstack_use > *fpStackUsage) *fpStackUsage = subfpstackuse+local_fpstack_use;
}
else RET_MINUS1_FAIL("zero parameter for varparm123");
}
if (bufOut_len < parm_size+GLUE_MOV_PX_DIRECTVALUE_SIZE+GLUE_MOVE_PX_STACKPTR_SIZE) RET_MINUS1_FAIL("insufficient size for varparm p1")
if (bufOut) GLUE_MOV_PX_DIRECTVALUE_GEN(bufOut+parm_size, (INT_PTR)n_params,1);
parm_size+=GLUE_MOV_PX_DIRECTVALUE_SIZE;
if (bufOut) GLUE_MOVE_PX_STACKPTR_GEN(bufOut+parm_size, 0);
parm_size+=GLUE_MOVE_PX_STACKPTR_SIZE;
}
else // not varparm
{
int pn;
#ifdef GLUE_HAS_FXCH
int need_fxch=0;
#endif
int last_nt_parm=-1, last_nt_parm_type=-1;
if (op->opcodeType == OPCODETYPE_FUNCX)
{
// this is not yet supported (calling conventions will need to be sorted, among other things)
RET_MINUS1_FAIL("funcx for native functions requires BIF_TAKES_VARPARM or BIF_TAKES_VARPARM_EX")
}
if (parm0_dv)
{
if (func == nseel_asm_stack_pop)
{
func = GLUE_realAddress(nseel_asm_stack_pop_fast,nseel_asm_stack_pop_fast_end,&func_size);
if (!func || bufOut_len < func_size) RET_MINUS1_FAIL(func?"failed on popfast size":"failed on popfast addr")
if (bufOut)
{
memcpy(bufOut,func,func_size);
NSEEL_PProc_Stack(bufOut,func_size,ctx);
}
return func_size;
}
else if (func == nseel_asm_stack_peek)
{
int f = (int) op->parms.parms[0]->parms.dv.directValue;
if (!f)
{
func = GLUE_realAddress(nseel_asm_stack_peek_top,nseel_asm_stack_peek_top_end,&func_size);
if (!func || bufOut_len < func_size) RET_MINUS1_FAIL(func?"failed on peek size":"failed on peek addr")
if (bufOut)
{
memcpy(bufOut,func,func_size);
NSEEL_PProc_Stack_PeekTop(bufOut,func_size,ctx);
}
return func_size;
}
else
{
func = GLUE_realAddress(nseel_asm_stack_peek_int,nseel_asm_stack_peek_int_end,&func_size);
if (!func || bufOut_len < func_size) RET_MINUS1_FAIL(func?"failed on peekint size":"failed on peekint addr")
if (bufOut)
{
memcpy(bufOut,func,func_size);
NSEEL_PProc_Stack_PeekInt(bufOut,func_size,ctx,f*sizeof(EEL_F));
}
return func_size;
}
}
}
// end of built-in function specific special casing
// first pass, calculate any non-trivial parameters
for (pn=0; pn < n_params; pn++)
{
if (!OPCODE_IS_TRIVIAL(op->parms.parms[pn]))
{
int canHaveDenorm=0;
int subfpstackuse=0;
int lsz=0;
int rvt=RETURNVALUE_NORMAL;
int may_need_fppush=-1;
if (last_nt_parm>=0)
{
if (last_nt_parm_type==RETURNVALUE_FPSTACK)
{
may_need_fppush= parm_size;
}
else
{
// push last result
if (bufOut_len < parm_size + (int)sizeof(GLUE_PUSH_P1)) RET_MINUS1_FAIL("failed on size, pushp1")
if (bufOut) memcpy(bufOut + parm_size, &GLUE_PUSH_P1, sizeof(GLUE_PUSH_P1));
parm_size += sizeof(GLUE_PUSH_P1);
}
}
if (func == nseel_asm_bnot) rvt=RETURNVALUE_BOOL_REVERSED|RETURNVALUE_BOOL;
else if (pn == n_params - 1)
{
if (cfunc_abiinfo&BIF_LASTPARMONSTACK) rvt=RETURNVALUE_FPSTACK;
else if (cfunc_abiinfo&BIF_LASTPARM_ASBOOL) rvt=RETURNVALUE_BOOL;
else if (func == nseel_asm_assign) rvt=RETURNVALUE_FPSTACK|RETURNVALUE_NORMAL;
}
else if (pn == n_params -2 && (cfunc_abiinfo&BIF_SECONDLASTPARMST))
{
rvt=RETURNVALUE_FPSTACK;
}
lsz = compileOpcodes(ctx,op->parms.parms[pn],bufOut ? bufOut + parm_size : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, rvt,&rvt, &subfpstackuse, &canHaveDenorm);
if (lsz<0) RET_MINUS1_FAIL("call coc failed")
if (func == nseel_asm_bnot && rvt==RETURNVALUE_BOOL_REVERSED)
{
// remove bnot, compileOpcodes() used fptobool_rev
#ifndef EEL_TARGET_PORTABLE
func = nseel_asm_uplus;
func_e = nseel_asm_uplus_end;
#else
func = nseel_asm_bnotnot;
func_e = nseel_asm_bnotnot_end;
#endif
rvt = RETURNVALUE_BOOL;
}
if (canHaveDenorm && canHaveDenormalOutput) *canHaveDenormalOutput = 1;
parm_size += lsz;
if (may_need_fppush>=0)
{
if (local_fpstack_use+subfpstackuse >= (GLUE_MAX_FPSTACK_SIZE-1) || (ctx->optimizeDisableFlags&OPTFLAG_NO_FPSTACK))
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_POP_FPSTACK_TOSTACK))
RET_MINUS1_FAIL("failed on size, popfpstacktostack")
if (bufOut)
{
memmove(bufOut + may_need_fppush + sizeof(GLUE_POP_FPSTACK_TOSTACK), bufOut + may_need_fppush, parm_size - may_need_fppush);
memcpy(bufOut + may_need_fppush, &GLUE_POP_FPSTACK_TOSTACK, sizeof(GLUE_POP_FPSTACK_TOSTACK));
}
parm_size += sizeof(GLUE_POP_FPSTACK_TOSTACK);
}
else
{
local_fpstack_use++;
}
}
if (subfpstackuse+local_fpstack_use > *fpStackUsage) *fpStackUsage = subfpstackuse+local_fpstack_use;
last_nt_parm = pn;
last_nt_parm_type = rvt;
if (pn == n_params - 1 && func == nseel_asm_assign)
{
if (!(ctx->optimizeDisableFlags & OPTFLAG_FULL_DENORMAL_CHECKS) &&
(!canHaveDenorm || (ctx->optimizeDisableFlags & OPTFLAG_NO_DENORMAL_CHECKS)))
{
if (rvt == RETURNVALUE_FPSTACK)
{
cfunc_abiinfo |= BIF_LASTPARMONSTACK;
func = nseel_asm_assign_fast_fromfp;
func_e = nseel_asm_assign_fast_fromfp_end;
}
else
{
func = nseel_asm_assign_fast;
func_e = nseel_asm_assign_fast_end;
}
}
else
{
if (rvt == RETURNVALUE_FPSTACK)
{
cfunc_abiinfo |= BIF_LASTPARMONSTACK;
func = nseel_asm_assign_fromfp;
func_e = nseel_asm_assign_fromfp_end;
}
}
}
}
}
pn = last_nt_parm;
if (pn >= 0) // if the last thing executed doesn't go to the last parameter, move it there
{
if ((cfunc_abiinfo&BIF_SECONDLASTPARMST) && pn == n_params-2)
{
// do nothing, things are in the right place
}
else if (pn != n_params-1)
{
// generate mov p1->pX
if (bufOut_len < parm_size + GLUE_SET_PX_FROM_P1_SIZE) RET_MINUS1_FAIL("size, pxfromp1")
if (bufOut) GLUE_SET_PX_FROM_P1(bufOut + parm_size,n_params - 1 - pn);
parm_size += GLUE_SET_PX_FROM_P1_SIZE;
}
}
// pop any pushed parameters
while (--pn >= 0)
{
if (!OPCODE_IS_TRIVIAL(op->parms.parms[pn]))
{
if ((cfunc_abiinfo&BIF_SECONDLASTPARMST) && pn == n_params-2)
{
if (!local_fpstack_use)
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_POP_STACK_TO_FPSTACK)) RET_MINUS1_FAIL("size, popstacktofpstack 2")
if (bufOut) memcpy(bufOut+parm_size,GLUE_POP_STACK_TO_FPSTACK,sizeof(GLUE_POP_STACK_TO_FPSTACK));
parm_size += sizeof(GLUE_POP_STACK_TO_FPSTACK);
#ifdef GLUE_HAS_FXCH
need_fxch = 1;
#endif
}
else
{
local_fpstack_use--;
}
}
else
{
if (bufOut_len < parm_size + GLUE_POP_PX_SIZE) RET_MINUS1_FAIL("size, poppx")
if (bufOut) GLUE_POP_PX(bufOut + parm_size,n_params - 1 - pn);
parm_size += GLUE_POP_PX_SIZE;
}
}
}
// finally, set trivial pointers
for (pn=0; pn < n_params; pn++)
{
if (OPCODE_IS_TRIVIAL(op->parms.parms[pn]))
{
if (pn == n_params-2 && (cfunc_abiinfo&(BIF_SECONDLASTPARMST))) // second to last parameter
{
int a = compileOpcodes(ctx,op->parms.parms[pn],bufOut ? bufOut+parm_size : NULL,bufOut_len - parm_size,computTableSize,namespacePathToThis,
RETURNVALUE_FPSTACK,NULL,NULL,canHaveDenormalOutput);
if (a<0) RET_MINUS1_FAIL("coc call here 2")
parm_size+=a;
#ifdef GLUE_HAS_FXCH
need_fxch = 1;
#endif
}
else if (pn == n_params-1) // last parameter, but we should call compileOpcodes to get it in the right format (compileOpcodes can optimize that process if it needs to)
{
int rvt=0, a;
int wantFpStack = func == nseel_asm_assign;
#ifdef GLUE_PREFER_NONFP_DV_ASSIGNS // x86-64, and maybe others, prefer to avoid the fp stack for a simple copy
if (wantFpStack &&
(op->parms.parms[pn]->opcodeType != OPCODETYPE_DIRECTVALUE ||
(op->parms.parms[pn]->parms.dv.directValue != 1.0 && op->parms.parms[pn]->parms.dv.directValue != 0.0)))
{
wantFpStack=-1; // cacheable but non-FP stack
}
#endif
a = compileOpcodes(ctx,op->parms.parms[pn],bufOut ? bufOut+parm_size : NULL,bufOut_len - parm_size,computTableSize,namespacePathToThis,
func == nseel_asm_bnot ? (RETURNVALUE_BOOL_REVERSED|RETURNVALUE_BOOL) :
(cfunc_abiinfo & BIF_LASTPARMONSTACK) ? RETURNVALUE_FPSTACK :
(cfunc_abiinfo & BIF_LASTPARM_ASBOOL) ? RETURNVALUE_BOOL :
wantFpStack < 0 ? (RETURNVALUE_CACHEABLE|RETURNVALUE_NORMAL) :
wantFpStack ? (RETURNVALUE_FPSTACK|RETURNVALUE_NORMAL) :
RETURNVALUE_NORMAL,
&rvt, NULL,canHaveDenormalOutput);
if (a<0) RET_MINUS1_FAIL("coc call here 3")
if (func == nseel_asm_bnot && rvt == RETURNVALUE_BOOL_REVERSED)
{
// remove bnot, compileOpcodes() used fptobool_rev
#ifndef EEL_TARGET_PORTABLE
func = nseel_asm_uplus;
func_e = nseel_asm_uplus_end;
#else
func = nseel_asm_bnotnot;
func_e = nseel_asm_bnotnot_end;
#endif
rvt = RETURNVALUE_BOOL;
}
parm_size+=a;
#ifdef GLUE_HAS_FXCH
need_fxch = 0;
#endif
if (func == nseel_asm_assign)
{
if (rvt == RETURNVALUE_FPSTACK)
{
if (!(ctx->optimizeDisableFlags & OPTFLAG_FULL_DENORMAL_CHECKS))
{
func = nseel_asm_assign_fast_fromfp;
func_e = nseel_asm_assign_fast_fromfp_end;
}
else
{
func = nseel_asm_assign_fromfp;
func_e = nseel_asm_assign_fromfp_end;
}
}
else if (!(ctx->optimizeDisableFlags & OPTFLAG_FULL_DENORMAL_CHECKS))
{
// assigning a value (from a variable or other non-computer), can use a fast assign (no denormal/result checking)
func = nseel_asm_assign_fast;
func_e = nseel_asm_assign_fast_end;
}
}
}
else
{
if (bufOut_len < parm_size + GLUE_MOV_PX_DIRECTVALUE_SIZE) RET_MINUS1_FAIL("size, pxdvsz")
if (bufOut)
{
if (generateValueToReg(ctx,op->parms.parms[pn],bufOut + parm_size,n_params - 1 - pn,namespacePathToThis, 0/*nocaching, function gets pointer*/)<0) RET_MINUS1_FAIL("gvtr")
}
parm_size += GLUE_MOV_PX_DIRECTVALUE_SIZE;
}
}
}
#ifdef GLUE_HAS_FXCH
if ((cfunc_abiinfo&(BIF_SECONDLASTPARMST)) && !(cfunc_abiinfo&(BIF_LAZYPARMORDERING))&&
((!!need_fxch)^!!(cfunc_abiinfo&BIF_REVERSEFPORDER))
)
{
// emit fxch
if (bufOut_len < sizeof(GLUE_FXCH)) RET_MINUS1_FAIL("len,fxch")
if (bufOut)
{
memcpy(bufOut+parm_size,GLUE_FXCH,sizeof(GLUE_FXCH));
}
parm_size+=sizeof(GLUE_FXCH);
}
#endif
if (!*canHaveDenormalOutput)
{
// if add_op or sub_op, and constant non-denormal input, safe to omit denormal checks
if (func == (void*)nseel_asm_add_op && parm1_dv && fabs(op->parms.parms[1]->parms.dv.directValue) >= DENORMAL_CLEARING_THRESHOLD)
{
func = nseel_asm_add_op_fast;
func_e = nseel_asm_add_op_fast_end;
}
else if (func == (void*)nseel_asm_sub_op && parm1_dv && fabs(op->parms.parms[1]->parms.dv.directValue) >= DENORMAL_CLEARING_THRESHOLD)
{
func = nseel_asm_sub_op_fast;
func_e = nseel_asm_sub_op_fast_end;
}
// or if mul/div by a fixed value of >= or <= 1.0
else if (func == (void *)nseel_asm_mul_op && parm1_dv && fabs(op->parms.parms[1]->parms.dv.directValue) >= 1.0)
{
func = nseel_asm_mul_op_fast;
func_e = nseel_asm_mul_op_fast_end;
}
else if (func == (void *)nseel_asm_div_op && parm1_dv && fabs(op->parms.parms[1]->parms.dv.directValue) <= 1.0)
{
func = nseel_asm_div_op_fast;
func_e = nseel_asm_div_op_fast_end;
}
}
} // not varparm
if (cfunc_abiinfo & (BIF_CLEARDENORMAL | BIF_RETURNSBOOL) ) *canHaveDenormalOutput=0;
else if (!(cfunc_abiinfo & BIF_WONTMAKEDENORMAL)) *canHaveDenormalOutput=1;
func = GLUE_realAddress(func,func_e,&func_size);
if (!func) RET_MINUS1_FAIL("failrealladdrfunc")
if (bufOut_len < parm_size + func_size) RET_MINUS1_FAIL("funcsz")
if (bufOut)
{
unsigned char *p=bufOut + parm_size;
memcpy(p, func, func_size);
if (preProc) p=preProc(p,func_size,ctx);
if (repl)
{
if (repl[0]) p=EEL_GLUE_set_immediate(p,(INT_PTR)repl[0]);
if (repl[1]) p=EEL_GLUE_set_immediate(p,(INT_PTR)repl[1]);
if (repl[2]) p=EEL_GLUE_set_immediate(p,(INT_PTR)repl[2]);
if (repl[3]) p=EEL_GLUE_set_immediate(p,(INT_PTR)repl[3]);
}
}
if (restore_stack_amt)
{
int rem = restore_stack_amt;
while (rem > 0)
{
int amt = rem;
if (amt > 4096) amt=4096;
rem -= amt;
if (bufOut_len < parm_size + func_size + GLUE_MOVE_STACK_SIZE) RET_MINUS1_FAIL("insufficient size for varparm")
if (bufOut) GLUE_MOVE_STACK(bufOut + parm_size + func_size, amt);
parm_size += GLUE_MOVE_STACK_SIZE;
}
}
if (cfunc_abiinfo&BIF_RETURNSONSTACK) *rvMode = RETURNVALUE_FPSTACK;
else if (cfunc_abiinfo&BIF_RETURNSBOOL) *rvMode=RETURNVALUE_BOOL;
return parm_size + func_size;
}
static int compileEelFunctionCall(compileContext *ctx, opcodeRec *op, unsigned char *bufOut, int bufOut_len, int *computTableSize, const namespaceInformation *namespacePathToThis,
int *rvMode, int *fpStackUse, int *canHaveDenormalOutput)
{
int func_size=0, parm_size=0;
int pn;
int last_nt_parm=-1,last_nt_parm_mode=0;
void *func_e=NULL;
int n_params;
opcodeRec *parmptrs[NSEEL_MAX_EELFUNC_PARAMETERS];
int cfp_numparams=-1;
int cfp_statesize=0;
EEL_F **cfp_ptrs=NULL;
int func_raw=0;
int do_parms;
int x;
void *func;
for (x=0; x < 3; x ++) parmptrs[x] = op->parms.parms[x];
if (op->opcodeType == OPCODETYPE_FUNCX)
{
n_params=0;
for (x=0;x<3;x++)
{
opcodeRec *prni=op->parms.parms[x];
while (prni && n_params < NSEEL_MAX_EELFUNC_PARAMETERS)
{
const int isMP = prni->opcodeType == OPCODETYPE_MOREPARAMS;
parmptrs[n_params++] = isMP ? prni->parms.parms[0] : prni;
if (!isMP) break;
prni = prni->parms.parms[1];
}
}
}
else
{
n_params = 1 + op->opcodeType - OPCODETYPE_FUNC1;
}
*fpStackUse = 0;
func = nseel_getEELFunctionAddress(ctx, op,
&cfp_numparams,&cfp_statesize,&cfp_ptrs,
computTableSize,
&func_e, &func_raw,
!!bufOut,namespacePathToThis,rvMode,fpStackUse,canHaveDenormalOutput, parmptrs, n_params);
if (func_raw) func_size = (int) ((char*)func_e - (char*)func);
else if (func) func = GLUE_realAddress(func,func_e,&func_size);
if (!func) RET_MINUS1_FAIL("eelfuncaddr")
*fpStackUse += 1;
if (cfp_numparams>0 && n_params != cfp_numparams)
{
RET_MINUS1_FAIL("eelfuncnp")
}
// user defined function
do_parms = cfp_numparams>0 && cfp_ptrs && cfp_statesize>0;
// if function local/parameter state is zero, we need to allocate storage for it
if (cfp_statesize>0 && cfp_ptrs && !cfp_ptrs[0])
{
EEL_F *pstate = newDataBlock(sizeof(EEL_F)*cfp_statesize,8);
if (!pstate) RET_MINUS1_FAIL("eelfuncdb")
for (pn=0;pn<cfp_statesize;pn++)
{
pstate[pn]=0;
cfp_ptrs[pn] = pstate + pn;
}
}
// first process parameters that are non-trivial
for (pn=0; pn < n_params; pn++)
{
int needDenorm=0;
int lsz,sUse=0;
if (!parmptrs[pn] || OPCODE_IS_TRIVIAL(parmptrs[pn])) continue; // skip and process after
if (last_nt_parm >= 0 && do_parms)
{
if (last_nt_parm_mode == RETURNVALUE_FPSTACK)
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_POP_FPSTACK_TOSTACK)) RET_MINUS1_FAIL("eelfunc_size popfpstacktostack")
if (bufOut) memcpy(bufOut + parm_size,GLUE_POP_FPSTACK_TOSTACK,sizeof(GLUE_POP_FPSTACK_TOSTACK));
parm_size+=sizeof(GLUE_POP_FPSTACK_TOSTACK);
}
else
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_PUSH_P1PTR_AS_VALUE)) RET_MINUS1_FAIL("eelfunc_size pushp1ptrasval")
// push
if (bufOut) memcpy(bufOut + parm_size,&GLUE_PUSH_P1PTR_AS_VALUE,sizeof(GLUE_PUSH_P1PTR_AS_VALUE));
parm_size+=sizeof(GLUE_PUSH_P1PTR_AS_VALUE);
}
}
last_nt_parm_mode=0;
lsz = compileOpcodes(ctx,parmptrs[pn],bufOut ? bufOut + parm_size : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis,
do_parms ? (RETURNVALUE_FPSTACK|RETURNVALUE_NORMAL) : RETURNVALUE_IGNORE,&last_nt_parm_mode,&sUse, &needDenorm);
// todo: if needDenorm, denorm convert when copying parameter
if (lsz<0) RET_MINUS1_FAIL("eelfunc, coc fail")
if (last_nt_parm_mode == RETURNVALUE_FPSTACK) sUse++;
if (sUse > *fpStackUse) *fpStackUse=sUse;
parm_size += lsz;
last_nt_parm = pn;
}
// pop non-trivial results into place
if (last_nt_parm >=0 && do_parms)
{
while (--pn >= 0)
{
if (!parmptrs[pn] || OPCODE_IS_TRIVIAL(parmptrs[pn])) continue; // skip and process after
if (pn == last_nt_parm)
{
if (last_nt_parm_mode == RETURNVALUE_FPSTACK)
{
// pop to memory directly
const int cpsize = GLUE_POP_FPSTACK_TO_PTR(NULL,NULL);
if (bufOut_len < parm_size + cpsize) RET_MINUS1_FAIL("eelfunc size popfpstacktoptr")
if (bufOut) GLUE_POP_FPSTACK_TO_PTR((unsigned char *)bufOut + parm_size,cfp_ptrs[pn]);
parm_size += cpsize;
}
else
{
// copy direct p1ptr to mem
const int cpsize = GLUE_COPY_VALUE_AT_P1_TO_PTR(NULL,NULL);
if (bufOut_len < parm_size + cpsize) RET_MINUS1_FAIL("eelfunc size copyvalueatp1toptr")
if (bufOut) GLUE_COPY_VALUE_AT_P1_TO_PTR((unsigned char *)bufOut + parm_size,cfp_ptrs[pn]);
parm_size += cpsize;
}
}
else
{
const int popsize = GLUE_POP_VALUE_TO_ADDR(NULL,NULL);
if (bufOut_len < parm_size + popsize) RET_MINUS1_FAIL("eelfunc size pop value to addr")
if (bufOut) GLUE_POP_VALUE_TO_ADDR((unsigned char *)bufOut + parm_size,cfp_ptrs[pn]);
parm_size+=popsize;
}
}
}
// finally, set any trivial parameters
if (do_parms)
{
const int cpsize = GLUE_MOV_PX_DIRECTVALUE_SIZE + GLUE_COPY_VALUE_AT_P1_TO_PTR(NULL,NULL);
for (pn=0; pn < n_params; pn++)
{
if (!parmptrs[pn] || !OPCODE_IS_TRIVIAL(parmptrs[pn])) continue; // set trivial values, we already set nontrivials
if (bufOut_len < parm_size + cpsize) RET_MINUS1_FAIL("eelfunc size trivial set")
if (bufOut)
{
if (generateValueToReg(ctx,parmptrs[pn],bufOut + parm_size,0,namespacePathToThis, 1)<0) RET_MINUS1_FAIL("eelfunc gvr fail")
GLUE_COPY_VALUE_AT_P1_TO_PTR(bufOut + parm_size + GLUE_MOV_PX_DIRECTVALUE_SIZE,cfp_ptrs[pn]);
}
parm_size += cpsize;
}
}
if (bufOut_len < parm_size + func_size) RET_MINUS1_FAIL("eelfunc size combined")
if (bufOut) memcpy(bufOut + parm_size, func, func_size);
return parm_size + func_size;
// end of EEL function generation
}
#ifdef DUMP_OPS_DURING_COMPILE
void dumpOp(compileContext *ctx, opcodeRec *op, int start);
#endif
#ifdef EEL_DUMP_OPS
void dumpOpcodeTree(compileContext *ctx, FILE *fp, opcodeRec *op, int indent_amt)
{
const char *fname="";
fprintf(fp,"%*sOP TYPE %d", indent_amt, "",
op->opcodeType==OPCODETYPE_DIRECTVALUE_TEMPSTRING ? 10000 : // remap around OPCODETYPE_DIRECTVALUE_TEMPSTRING
op->opcodeType > OPCODETYPE_DIRECTVALUE_TEMPSTRING ? op->opcodeType - 1 :
op->opcodeType);
if ((op->opcodeType == OPCODETYPE_FUNC1 ||
op->opcodeType == OPCODETYPE_FUNC2 ||
op->opcodeType == OPCODETYPE_FUNC3 ||
op->opcodeType == OPCODETYPE_FUNCX))
{
if (op->fntype == FUNCTYPE_FUNCTIONTYPEREC)
{
functionType *fn_ptr = (functionType *)op->fn;
fname = fn_ptr->name;
}
else if (op->fntype == FUNCTYPE_EELFUNC)
{
fname = op->relname;
}
if (!fname) fname ="";
}
switch (op->opcodeType)
{
case OPCODETYPE_DIRECTVALUE:
fprintf(fp," DV=%f\r\n",op->parms.dv.directValue);
break;
case OPCODETYPE_VALUE_FROM_NAMESPACENAME: // this.* or namespace.* are encoded this way
fprintf(fp," NSN=%s(%d)\r\n",op->relname?op->relname : "(null)",op->namespaceidx);
break;
case OPCODETYPE_VARPTR:
{
const char *nm = op->relname;
if (!nm || !*nm)
{
int wb;
for (wb = 0; wb < ctx->varTable_numBlocks; wb ++)
{
char **plist=ctx->varTable_Names[wb];
if (!plist) break;
if (op->parms.dv.valuePtr >= ctx->varTable_Values[wb] && op->parms.dv.valuePtr < ctx->varTable_Values[wb] + NSEEL_VARS_PER_BLOCK)
{
nm = plist[op->parms.dv.valuePtr - ctx->varTable_Values[wb]];
break;
}
}
}
fprintf(fp," VP=%s\r\n", nm?nm : "(null)");
}
break;
case OPCODETYPE_VARPTRPTR:
fprintf(fp, " VPP?\r\n");
break;
case OPCODETYPE_FUNC1:
if (op->fntype == FN_NOT)
fprintf(fp," FUNC1 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_not");
else if (op->fntype == FN_NOTNOT)
fprintf(fp," FUNC1 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_notnot");
else if (op->fntype == FN_MEMORY)
fprintf(fp," FUNC1 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_mem");
else if (op->fntype == FN_GMEMORY)
fprintf(fp," FUNC1 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_gmem");
else if (op->fntype == FN_WHILE)
fprintf(fp," FUNC1 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "while");
else
fprintf(fp," FUNC1 %d %s {\r\n",op->fntype, fname);
if (op->parms.parms[0])
dumpOpcodeTree(ctx,fp,op->parms.parms[0],indent_amt+2);
else
fprintf(fp,"%*sINVALID PARM\r\n",indent_amt+2,"");
fprintf(fp,"%*s}\r\n", indent_amt, "");
break;
case OPCODETYPE_MOREPARAMS:
case OPCODETYPE_FUNC2:
if (op->opcodeType == OPCODETYPE_MOREPARAMS)
fprintf(fp," MOREPARAMS {\r\n");
else
{
if (op->fntype == FN_POW)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "pow");
else if (op->fntype == FN_MOD)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_mod");
else if (op->fntype == FN_XOR)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_xor");
else if (op->fntype == FN_SHL)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_shl");
else if (op->fntype == FN_SHR)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_shr");
else if (op->fntype == FN_LT)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_below");
else if (op->fntype == FN_GT)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_above");
else if (op->fntype == FN_LTE)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_beleq");
else if (op->fntype == FN_GTE)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_aboeq");
else if (op->fntype == FN_EQ)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_equal");
else if (op->fntype == FN_NE)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_noteq");
else if (op->fntype == FN_EQ_EXACT)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_equal_exact");
else if (op->fntype == FN_NE_EXACT)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_noteq_exact");
else if (op->fntype == FN_LOGICAL_AND)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_and");
else if (op->fntype == FN_LOGICAL_OR)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_or");
else if (op->fntype == FN_ASSIGN)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_set");
else if (op->fntype == FN_ADD_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_addop");
else if (op->fntype == FN_SUB_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_subop");
else if (op->fntype == FN_MUL_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_mulop");
else if (op->fntype == FN_DIV_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_divop");
else if (op->fntype == FN_OR_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_orop");
else if (op->fntype == FN_AND_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_andop");
else if (op->fntype == FN_XOR_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_xorop");
else if (op->fntype == FN_MOD_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_modop");
else if (op->fntype == FN_POW_OP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_powop");
else if (op->fntype == FN_LOOP)
fprintf(fp," FUNC2 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "loop");
else
fprintf(fp," FUNC2 %d %s {\r\n",op->fntype, fname);
}
if (op->parms.parms[0])
dumpOpcodeTree(ctx,fp,op->parms.parms[0],indent_amt+2);
else
fprintf(fp,"%*sINVALID PARM\r\n",indent_amt+2,"");
if (op->parms.parms[1])
dumpOpcodeTree(ctx,fp,op->parms.parms[1],indent_amt+2);
else
fprintf(fp,"%*sINVALID PARM\r\n",indent_amt+2,"");
fprintf(fp,"%*s}\r\n", indent_amt, "");
break;
case OPCODETYPE_FUNCX:
case OPCODETYPE_FUNC3:
if (op->opcodeType == OPCODETYPE_FUNCX)
fprintf(fp," FUNCX %d %s {\r\n",op->fntype, fname);
else if (op->fntype == FN_IF_ELSE)
fprintf(fp," FUNC3 %d %s {\r\n",FUNCTYPE_FUNCTIONTYPEREC, "_if");
else
fprintf(fp," FUNC3 %d %s {\r\n",op->fntype, fname);
if (op->parms.parms[0])
dumpOpcodeTree(ctx,fp,op->parms.parms[0],indent_amt+2);
else
fprintf(fp,"%*sINVALID PARM\r\n",indent_amt+2,"");
if (op->parms.parms[1])
dumpOpcodeTree(ctx,fp,op->parms.parms[1],indent_amt+2);
else
fprintf(fp,"%*sINVALID PARM\r\n",indent_amt+2,"");
if (op->parms.parms[2])
dumpOpcodeTree(ctx,fp,op->parms.parms[2],indent_amt+2);
else
fprintf(fp,"%*sINVALID PARM\r\n",indent_amt+2,"");
fprintf(fp,"%*s}\r\n", indent_amt, "");
break;
}
}
#endif
#ifdef GLUE_MAX_JMPSIZE
#define CHECK_SIZE_FORJMP(x,y) if ((x)<0 || (x)>=GLUE_MAX_JMPSIZE) goto y;
#define RET_MINUS1_FAIL_FALLBACK(err,j) goto j;
#else
#define CHECK_SIZE_FORJMP(x,y)
#define RET_MINUS1_FAIL_FALLBACK(err,j) RET_MINUS1_FAIL(err)
#endif
static int compileOpcodesInternal(compileContext *ctx, opcodeRec *op, unsigned char *bufOut, int bufOut_len, int *computTableSize, const namespaceInformation *namespacePathToThis, int *calledRvType, int preferredReturnValues, int *fpStackUse, int *canHaveDenormalOutput)
{
int rv_offset=0, denormal_force=-1;
if (!op) RET_MINUS1_FAIL("coi !op")
*fpStackUse=0;
for (;;)
{
// special case: statement delimiting means we can process the left side into place, and iteratively do the second parameter without recursing
// also we don't need to save/restore anything to the stack (which the normal 2 parameter function processing does)
if (op->opcodeType == OPCODETYPE_FUNC2 && op->fntype == FN_JOIN_STATEMENTS)
{
int fUse1;
int parm_size = compileOpcodes(ctx,op->parms.parms[0],bufOut,bufOut_len, computTableSize, namespacePathToThis, RETURNVALUE_IGNORE, NULL,&fUse1,NULL);
if (parm_size < 0) RET_MINUS1_FAIL("coc join fail")
op = op->parms.parms[1];
if (!op) RET_MINUS1_FAIL("join got to null")
if (fUse1>*fpStackUse) *fpStackUse=fUse1;
if (bufOut) bufOut += parm_size;
bufOut_len -= parm_size;
rv_offset += parm_size;
#ifdef DUMP_OPS_DURING_COMPILE
if (op->opcodeType != OPCODETYPE_FUNC2 || op->fntype != FN_JOIN_STATEMENTS) dumpOp(ctx,op,0);
#endif
denormal_force=-1;
}
// special case: __denormal_likely(), __denormal_unlikely()
else if (op->opcodeType == OPCODETYPE_FUNC1 && (op->fntype == FN_DENORMAL_LIKELY || op->fntype == FN_DENORMAL_UNLIKELY))
{
denormal_force = op->fntype == FN_DENORMAL_LIKELY;
op = op->parms.parms[0];
}
else
{
break;
}
}
if (denormal_force >= 0 && canHaveDenormalOutput)
{
*canHaveDenormalOutput = denormal_force;
canHaveDenormalOutput = &denormal_force; // prevent it from being changed by functions below
}
// special case: BAND/BOR
if (op->opcodeType == OPCODETYPE_FUNC2 && (op->fntype == FN_LOGICAL_AND || op->fntype == FN_LOGICAL_OR))
{
int fUse1=0;
int parm_size;
#ifdef GLUE_MAX_JMPSIZE
int parm_size_pre;
#endif
int retType=RETURNVALUE_IGNORE;
if (preferredReturnValues != RETURNVALUE_IGNORE) retType = RETURNVALUE_BOOL;
*calledRvType = retType;
parm_size = compileOpcodes(ctx,op->parms.parms[0],bufOut,bufOut_len, computTableSize, namespacePathToThis, RETURNVALUE_BOOL, NULL, &fUse1, NULL);
if (parm_size < 0) RET_MINUS1_FAIL("loop band/bor coc fail")
if (fUse1 > *fpStackUse) *fpStackUse=fUse1;
#ifdef GLUE_MAX_JMPSIZE
parm_size_pre=parm_size;
#endif
{
int sz2, fUse2=0;
unsigned char *destbuf;
const int testsz=op->fntype == FN_LOGICAL_OR ? sizeof(GLUE_JMP_IF_P1_NZ) : sizeof(GLUE_JMP_IF_P1_Z);
if (bufOut_len < parm_size+testsz) RET_MINUS1_FAIL_FALLBACK("band/bor size fail",doNonInlinedAndOr_)
if (bufOut) memcpy(bufOut+parm_size,op->fntype == FN_LOGICAL_OR ? GLUE_JMP_IF_P1_NZ : GLUE_JMP_IF_P1_Z,testsz);
parm_size += testsz;
destbuf = bufOut + parm_size;
sz2= compileOpcodes(ctx,op->parms.parms[1],bufOut?bufOut+parm_size:NULL,bufOut_len-parm_size, computTableSize, namespacePathToThis, retType, NULL,&fUse2, NULL);
CHECK_SIZE_FORJMP(sz2,doNonInlinedAndOr_)
if (sz2<0) RET_MINUS1_FAIL("band/bor coc fail")
parm_size+=sz2;
if (bufOut) GLUE_JMP_SET_OFFSET(destbuf, (bufOut + parm_size) - destbuf);
if (fUse2 > *fpStackUse) *fpStackUse=fUse2;
return rv_offset + parm_size;
}
#ifdef GLUE_MAX_JMPSIZE
if (0)
{
void *stub;
int stubsize;
unsigned char *newblock2, *p;
// encode as function call
doNonInlinedAndOr_:
parm_size = parm_size_pre;
if (op->fntype == FN_LOGICAL_AND)
{
stub = GLUE_realAddress(nseel_asm_band,nseel_asm_band_end,&stubsize);
}
else
{
stub = GLUE_realAddress(nseel_asm_bor,nseel_asm_bor_end,&stubsize);
}
if (bufOut_len < parm_size + stubsize) RET_MINUS1_FAIL("band/bor len fail")
if (bufOut)
{
int fUse2=0;
newblock2 = compileCodeBlockWithRet(ctx,op->parms.parms[1],computTableSize,namespacePathToThis, retType, NULL, &fUse2, NULL);
if (!newblock2) RET_MINUS1_FAIL("band/bor ccbwr fail")
if (fUse2 > *fpStackUse) *fpStackUse=fUse2;
p = bufOut + parm_size;
memcpy(p, stub, stubsize);
p=EEL_GLUE_set_immediate(p,(INT_PTR)newblock2);
}
return rv_offset + parm_size + stubsize;
}
#endif
}
if (op->opcodeType == OPCODETYPE_FUNC3 && op->fntype == FN_IF_ELSE) // special case: IF
{
int fUse1=0;
#ifdef GLUE_MAX_JMPSIZE
int parm_size_pre;
#endif
int use_rv = RETURNVALUE_IGNORE;
int rvMode=0;
int parm_size = compileOpcodes(ctx,op->parms.parms[0],bufOut,bufOut_len, computTableSize, namespacePathToThis, RETURNVALUE_BOOL|RETURNVALUE_BOOL_REVERSED, &rvMode,&fUse1, NULL);
if (parm_size < 0) RET_MINUS1_FAIL("if coc fail")
if (fUse1 > *fpStackUse) *fpStackUse=fUse1;
if (preferredReturnValues & RETURNVALUE_NORMAL) use_rv=RETURNVALUE_NORMAL;
else if (preferredReturnValues & RETURNVALUE_FPSTACK) use_rv=RETURNVALUE_FPSTACK;
else if (preferredReturnValues & RETURNVALUE_BOOL) use_rv=RETURNVALUE_BOOL;
*calledRvType = use_rv;
#ifdef GLUE_MAX_JMPSIZE
parm_size_pre = parm_size;
#endif
{
int csz,hasSecondHalf;
if (rvMode & RETURNVALUE_BOOL_REVERSED)
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_JMP_IF_P1_NZ)) RET_MINUS1_FAIL_FALLBACK("if size fail",doNonInlineIf_)
if (bufOut) memcpy(bufOut+parm_size,GLUE_JMP_IF_P1_NZ,sizeof(GLUE_JMP_IF_P1_NZ));
parm_size += sizeof(GLUE_JMP_IF_P1_NZ);
}
else
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_JMP_IF_P1_Z)) RET_MINUS1_FAIL_FALLBACK("if size fail",doNonInlineIf_)
if (bufOut) memcpy(bufOut+parm_size,GLUE_JMP_IF_P1_Z,sizeof(GLUE_JMP_IF_P1_Z));
parm_size += sizeof(GLUE_JMP_IF_P1_Z);
}
csz=compileOpcodes(ctx,op->parms.parms[1],bufOut ? bufOut+parm_size : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, use_rv, NULL,&fUse1, canHaveDenormalOutput);
if (fUse1 > *fpStackUse) *fpStackUse=fUse1;
hasSecondHalf = preferredReturnValues || !OPCODE_IS_TRIVIAL(op->parms.parms[2]);
CHECK_SIZE_FORJMP(csz,doNonInlineIf_)
if (csz<0) RET_MINUS1_FAIL("if coc fial")
if (bufOut) GLUE_JMP_SET_OFFSET(bufOut + parm_size, csz + (hasSecondHalf?sizeof(GLUE_JMP_NC):0));
parm_size+=csz;
if (hasSecondHalf)
{
if (bufOut_len < parm_size + (int)sizeof(GLUE_JMP_NC)) RET_MINUS1_FAIL_FALLBACK("if len fail",doNonInlineIf_)
if (bufOut) memcpy(bufOut+parm_size,GLUE_JMP_NC,sizeof(GLUE_JMP_NC));
parm_size+=sizeof(GLUE_JMP_NC);
csz=compileOpcodes(ctx,op->parms.parms[2],bufOut ? bufOut+parm_size : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, use_rv, NULL, &fUse1, canHaveDenormalOutput);
CHECK_SIZE_FORJMP(csz,doNonInlineIf_)
if (csz<0) RET_MINUS1_FAIL("if coc 2 fail")
// update jump address
if (bufOut) GLUE_JMP_SET_OFFSET(bufOut + parm_size,csz);
parm_size+=csz;
if (fUse1 > *fpStackUse) *fpStackUse=fUse1;
}
return rv_offset + parm_size;
}
#ifdef GLUE_MAX_JMPSIZE
if (0)
{
unsigned char *newblock2,*newblock3,*ptr;
void *stub;
int stubsize;
doNonInlineIf_:
parm_size = parm_size_pre;
stub = GLUE_realAddress(nseel_asm_if,nseel_asm_if_end,&stubsize);
if (!stub || bufOut_len < parm_size + stubsize) RET_MINUS1_FAIL(stub ? "if sz fail" : "if addr fail")
if (bufOut)
{
int fUse2=0;
newblock2 = compileCodeBlockWithRet(ctx,op->parms.parms[1],computTableSize,namespacePathToThis, use_rv, NULL,&fUse2, canHaveDenormalOutput);
if (fUse2 > *fpStackUse) *fpStackUse=fUse2;
newblock3 = compileCodeBlockWithRet(ctx,op->parms.parms[2],computTableSize,namespacePathToThis, use_rv, NULL,&fUse2, canHaveDenormalOutput);
if (fUse2 > *fpStackUse) *fpStackUse=fUse2;
if (!newblock2 || !newblock3) RET_MINUS1_FAIL("if subblock gen fail")
ptr = bufOut + parm_size;
memcpy(ptr, stub, stubsize);
ptr=EEL_GLUE_set_immediate(ptr,(INT_PTR)newblock2);
EEL_GLUE_set_immediate(ptr,(INT_PTR)newblock3);
}
return rv_offset + parm_size + stubsize;
}
#endif
}
{
// special case: while
if (op->opcodeType == OPCODETYPE_FUNC1 && op->fntype == FN_WHILE)
{
*calledRvType = RETURNVALUE_BOOL;
#ifndef GLUE_INLINE_LOOPS
// todo: PPC looping support when loop length is small enough
{
unsigned char *pwr=bufOut;
unsigned char *newblock2;
int stubsz;
void *stubfunc = GLUE_realAddress(nseel_asm_repeatwhile,nseel_asm_repeatwhile_end,&stubsz);
if (!stubfunc || bufOut_len < stubsz) RET_MINUS1_FAIL(stubfunc ? "repeatwhile size fail" :"repeatwhile addr fail")
if (bufOut)
{
newblock2=compileCodeBlockWithRet(ctx,op->parms.parms[0],computTableSize,namespacePathToThis, RETURNVALUE_BOOL, NULL, fpStackUse, NULL);
if (!newblock2) RET_MINUS1_FAIL("repeatwhile ccbwr fail")
memcpy(pwr,stubfunc,stubsz);
pwr=EEL_GLUE_set_immediate(pwr,(INT_PTR)newblock2);
}
return rv_offset+stubsz;
}
#else
{
#ifndef GLUE_WHILE_END_NOJUMP
unsigned char *jzoutpt;
#endif
unsigned char *looppt;
int parm_size=0,subsz;
if (bufOut_len < parm_size + (int)(GLUE_WHILE_SETUP_SIZE + sizeof(GLUE_WHILE_BEGIN))) RET_MINUS1_FAIL("while size fail 1")
if (bufOut) memcpy(bufOut + parm_size,GLUE_WHILE_SETUP,GLUE_WHILE_SETUP_SIZE);
parm_size+=GLUE_WHILE_SETUP_SIZE;
looppt = bufOut + parm_size;
if (bufOut) memcpy(bufOut + parm_size,GLUE_WHILE_BEGIN,sizeof(GLUE_WHILE_BEGIN));
parm_size+=sizeof(GLUE_WHILE_BEGIN);
subsz = compileOpcodes(ctx,op->parms.parms[0],bufOut ? (bufOut + parm_size) : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, RETURNVALUE_BOOL, NULL,fpStackUse, NULL);
if (subsz<0) RET_MINUS1_FAIL("while coc fail")
if (bufOut_len < parm_size + (int)(sizeof(GLUE_WHILE_END) + sizeof(GLUE_WHILE_CHECK_RV))) RET_MINUS1_FAIL("which size fial 2")
parm_size+=subsz;
if (bufOut) memcpy(bufOut + parm_size, GLUE_WHILE_END, sizeof(GLUE_WHILE_END));
parm_size+=sizeof(GLUE_WHILE_END);
#ifndef GLUE_WHILE_END_NOJUMP
jzoutpt = bufOut + parm_size;
#endif
if (bufOut) memcpy(bufOut + parm_size, GLUE_WHILE_CHECK_RV, sizeof(GLUE_WHILE_CHECK_RV));
parm_size+=sizeof(GLUE_WHILE_CHECK_RV);
if (bufOut)
{
GLUE_JMP_SET_OFFSET(bufOut + parm_size,(looppt - (bufOut+parm_size)) );
#ifndef GLUE_WHILE_END_NOJUMP
GLUE_JMP_SET_OFFSET(jzoutpt, (bufOut + parm_size) - jzoutpt);
#endif
}
return rv_offset+parm_size;
}
#endif
}
// special case: loop
if (op->opcodeType == OPCODETYPE_FUNC2 && op->fntype == FN_LOOP)
{
int fUse1;
int parm_size = compileOpcodes(ctx,op->parms.parms[0],bufOut,bufOut_len, computTableSize, namespacePathToThis, RETURNVALUE_FPSTACK, NULL,&fUse1, NULL);
if (parm_size < 0) RET_MINUS1_FAIL("loop coc fail")
*calledRvType = RETURNVALUE_BOOL;
if (fUse1 > *fpStackUse) *fpStackUse=fUse1;
#ifndef GLUE_INLINE_LOOPS
// todo: PPC looping support when loop length is small enough
{
void *stub;
int stubsize;
unsigned char *newblock2, *p;
stub = GLUE_realAddress(nseel_asm_repeat,nseel_asm_repeat_end,&stubsize);
if (bufOut_len < parm_size + stubsize) RET_MINUS1_FAIL("loop size fail")
if (bufOut)
{
newblock2 = compileCodeBlockWithRet(ctx,op->parms.parms[1],computTableSize,namespacePathToThis, RETURNVALUE_IGNORE, NULL,fpStackUse, NULL);
p = bufOut + parm_size;
memcpy(p, stub, stubsize);
p=EEL_GLUE_set_immediate(p,(INT_PTR)newblock2);
}
return rv_offset + parm_size + stubsize;
}
#else
{
int subsz;
int fUse2=0;
unsigned char *skipptr1,*loopdest;
if (bufOut_len < parm_size + (int)(sizeof(GLUE_LOOP_LOADCNT) + GLUE_LOOP_CLAMPCNT_SIZE + GLUE_LOOP_BEGIN_SIZE)) RET_MINUS1_FAIL("loop size fail")
// store, convert to int, compare against 1, if less than, skip to end
if (bufOut) memcpy(bufOut+parm_size,GLUE_LOOP_LOADCNT,sizeof(GLUE_LOOP_LOADCNT));
parm_size += sizeof(GLUE_LOOP_LOADCNT);
skipptr1 = bufOut+parm_size;
// compare aginst max loop length, jump to loop start if not above it
if (bufOut) memcpy(bufOut+parm_size,GLUE_LOOP_CLAMPCNT,GLUE_LOOP_CLAMPCNT_SIZE);
parm_size += GLUE_LOOP_CLAMPCNT_SIZE;
// loop code:
loopdest = bufOut + parm_size;
if (bufOut) memcpy(bufOut+parm_size,GLUE_LOOP_BEGIN,GLUE_LOOP_BEGIN_SIZE);
parm_size += GLUE_LOOP_BEGIN_SIZE;
subsz = compileOpcodes(ctx,op->parms.parms[1],bufOut ? (bufOut + parm_size) : NULL,bufOut_len - parm_size, computTableSize, namespacePathToThis, RETURNVALUE_IGNORE, NULL, &fUse2, NULL);
if (subsz<0) RET_MINUS1_FAIL("loop coc fail")
if (fUse2 > *fpStackUse) *fpStackUse=fUse2;
parm_size += subsz;
if (bufOut_len < parm_size + (int)sizeof(GLUE_LOOP_END)) RET_MINUS1_FAIL("loop size fail 2")
if (bufOut) memcpy(bufOut+parm_size,GLUE_LOOP_END,sizeof(GLUE_LOOP_END));
parm_size += sizeof(GLUE_LOOP_END);
if (bufOut)
{
GLUE_JMP_SET_OFFSET(bufOut + parm_size,loopdest - (bufOut+parm_size));
GLUE_JMP_SET_OFFSET(skipptr1, (bufOut+parm_size) - skipptr1);
}
return rv_offset + parm_size;
}
#endif
}
}
switch (op->opcodeType)
{
case OPCODETYPE_DIRECTVALUE:
if (preferredReturnValues == RETURNVALUE_BOOL)
{
int w = fabs(op->parms.dv.directValue) >= NSEEL_CLOSEFACTOR;
int wsz=(w?sizeof(GLUE_SET_P1_NZ):sizeof(GLUE_SET_P1_Z));
*calledRvType = RETURNVALUE_BOOL;
if (bufOut_len < wsz) RET_MINUS1_FAIL("direct bool size fail3")
if (bufOut) memcpy(bufOut,w?GLUE_SET_P1_NZ:GLUE_SET_P1_Z,wsz);
return rv_offset+wsz;
}
else if (preferredReturnValues & RETURNVALUE_FPSTACK)
{
#ifdef GLUE_HAS_FLDZ
if (op->parms.dv.directValue == 0.0)
{
*fpStackUse = 1;
*calledRvType = RETURNVALUE_FPSTACK;
if (bufOut_len < sizeof(GLUE_FLDZ)) RET_MINUS1_FAIL("direct fp fail 1")
if (bufOut) memcpy(bufOut,GLUE_FLDZ,sizeof(GLUE_FLDZ));
return rv_offset+sizeof(GLUE_FLDZ);
}
#endif
#ifdef GLUE_HAS_FLD1
if (op->parms.dv.directValue == 1.0)
{
*fpStackUse = 1;
*calledRvType = RETURNVALUE_FPSTACK;
if (bufOut_len < sizeof(GLUE_FLD1)) RET_MINUS1_FAIL("direct fp fail 1")
if (bufOut) memcpy(bufOut,GLUE_FLD1,sizeof(GLUE_FLD1));
return rv_offset+sizeof(GLUE_FLD1);
}
#endif
}
// fall through
case OPCODETYPE_DIRECTVALUE_TEMPSTRING:
case OPCODETYPE_VALUE_FROM_NAMESPACENAME:
case OPCODETYPE_VARPTR:
case OPCODETYPE_VARPTRPTR:
#ifdef GLUE_MOV_PX_DIRECTVALUE_TOSTACK_SIZE
if (OPCODE_IS_TRIVIAL(op))
{
if (preferredReturnValues & RETURNVALUE_FPSTACK)
{
*fpStackUse = 1;
if (bufOut_len < GLUE_MOV_PX_DIRECTVALUE_TOSTACK_SIZE) RET_MINUS1_FAIL("direct fp fail 2")
if (bufOut)
{
if (generateValueToReg(ctx,op,bufOut,-1,namespacePathToThis, 1 /*allow caching*/)<0) RET_MINUS1_FAIL("direct fp fail gvr")
}
*calledRvType = RETURNVALUE_FPSTACK;
return rv_offset+GLUE_MOV_PX_DIRECTVALUE_TOSTACK_SIZE;
}
}
#endif
if (bufOut_len < GLUE_MOV_PX_DIRECTVALUE_SIZE)
{
RET_MINUS1_FAIL("direct value fail 1")
}
if (bufOut)
{
if (generateValueToReg(ctx,op,bufOut,0,namespacePathToThis,
(preferredReturnValues&(RETURNVALUE_FPSTACK|RETURNVALUE_CACHEABLE))!=0)<0)
{
RET_MINUS1_FAIL("direct value gvr fail3")
}
}
return rv_offset + GLUE_MOV_PX_DIRECTVALUE_SIZE;
case OPCODETYPE_FUNCX:
case OPCODETYPE_FUNC1:
case OPCODETYPE_FUNC2:
case OPCODETYPE_FUNC3:
if (op->fntype == FUNCTYPE_EELFUNC)
{
int a;
a = compileEelFunctionCall(ctx,op,bufOut,bufOut_len,computTableSize,namespacePathToThis, calledRvType,fpStackUse,canHaveDenormalOutput);
if (a<0) return a;
rv_offset += a;
}
else
{
int a;
a = compileNativeFunctionCall(ctx,op,bufOut,bufOut_len,computTableSize,namespacePathToThis, calledRvType,fpStackUse,preferredReturnValues,canHaveDenormalOutput);
if (a<0)return a;
rv_offset += a;
}
return rv_offset;
}
RET_MINUS1_FAIL("default opcode fail")
}
#ifdef DUMP_OPS_DURING_COMPILE
FILE *g_debugfp;
int g_debugfp_indent;
int g_debugfp_histsz=0;
void dumpOp(compileContext *ctx, opcodeRec *op, int start)
{
if (start>=0)
{
if (g_debugfp)
{
static opcodeRec **hist;
int x;
int hit=0;
if (!hist) hist = (opcodeRec**) calloc(1024,1024*sizeof(opcodeRec*));
for(x=0;x<g_debugfp_histsz;x++)
{
if (hist[x] == op) { hit=1; break; }
}
if (x ==g_debugfp_histsz && g_debugfp_histsz<1024*1024) hist[g_debugfp_histsz++] = op;
if (!start)
{
g_debugfp_indent-=2;
fprintf(g_debugfp,"%*s}(join)\n",g_debugfp_indent," ");
}
if (g_debugfp_indent>=100) *(char *)1=0;
fprintf(g_debugfp,"%*s{ %p : %d%s: ",g_debugfp_indent," ",op,op->opcodeType, hit ? " -- DUPLICATE" : "");
switch (op->opcodeType)
{
case OPCODETYPE_DIRECTVALUE:
fprintf(g_debugfp,"dv %f",op->parms.dv.directValue);
break;
case OPCODETYPE_VARPTR:
if (op->relname && op->relname[0])
{
fprintf(g_debugfp,"var %s",op->relname);
}
else
{
int wb;
for (wb = 0; wb < ctx->varTable_numBlocks; wb ++)
{
char **plist=ctx->varTable_Names[wb];
if (!plist) break;
if (op->parms.dv.valuePtr >= ctx->varTable_Values[wb] && op->parms.dv.valuePtr < ctx->varTable_Values[wb] + NSEEL_VARS_PER_BLOCK)
{
fprintf(g_debugfp,"var %s",plist[op->parms.dv.valuePtr - ctx->varTable_Values[wb]]);
break;
}
}
}
break;
case OPCODETYPE_FUNC1:
case OPCODETYPE_FUNC2:
case OPCODETYPE_FUNC3:
case OPCODETYPE_FUNCX:
if (op->fntype == FUNCTYPE_FUNCTIONTYPEREC)
{
functionType *p=(functionType*)op->fn;
fprintf(g_debugfp,"func %d: %s",p->nParams&0xff,p->name);
}
else
fprintf(g_debugfp,"sf %d",op->fntype);
break;
}
fprintf(g_debugfp,"\n");
g_debugfp_indent+=2;
}
}
else
{
if (g_debugfp)
{
g_debugfp_indent-=2;
fprintf(g_debugfp,"%*s}%p\n",g_debugfp_indent," ",op);
}
}
}
#endif
int compileOpcodes(compileContext *ctx, opcodeRec *op, unsigned char *bufOut, int bufOut_len, int *computTableSize, const namespaceInformation *namespacePathToThis,
int supportedReturnValues, int *rvType, int *fpStackUse, int *canHaveDenormalOutput)
{
int code_returns=RETURNVALUE_NORMAL;
int fpsu=0;
int codesz;
int denorm=0;
#ifdef DUMP_OPS_DURING_COMPILE
dumpOp(ctx,op,1);
#endif
codesz = compileOpcodesInternal(ctx,op,bufOut,bufOut_len,computTableSize,namespacePathToThis,&code_returns, supportedReturnValues,&fpsu,&denorm);
if (denorm && canHaveDenormalOutput) *canHaveDenormalOutput=1;
#ifdef DUMP_OPS_DURING_COMPILE
dumpOp(ctx,op,-1);
#endif
#ifdef EEL_DUMP_OPS
// dump opcode trees for verification, after optimizing
if (g_eel_dump_fp2)
{
fprintf(g_eel_dump_fp2,"-- compileOpcodes generated %d bytes of code!\r\n",codesz);
}
#endif
if (codesz < 0) return codesz;
/*
{
char buf[512];
sprintf(buf,"opcode %d %d (%s): fpu use: %d\n",op->opcodeType,op->fntype,
op->opcodeType >= OPCODETYPE_FUNC1 && op->fntype == FUNCTYPE_FUNCTIONTYPEREC ? (
((functionType *)op->fn)->name
) : "",
fpsu);
OutputDebugString(buf);
}
*/
if (fpStackUse) *fpStackUse=fpsu;
if (bufOut) bufOut += codesz;
bufOut_len -= codesz;
if (code_returns == RETURNVALUE_BOOL && !(supportedReturnValues & RETURNVALUE_BOOL) && supportedReturnValues)
{
int stubsize;
void *stub = GLUE_realAddress(nseel_asm_booltofp,nseel_asm_booltofp_end,&stubsize);
if (!stub || bufOut_len < stubsize) RET_MINUS1_FAIL(stub?"booltofp size":"booltfp addr")
if (bufOut)
{
memcpy(bufOut,stub,stubsize);
bufOut += stubsize;
}
codesz+=stubsize;
bufOut_len -= stubsize;
code_returns = RETURNVALUE_FPSTACK;
}
// default processing of code_returns to meet return value requirements
if (supportedReturnValues & code_returns)
{
if (rvType) *rvType = code_returns;
return codesz;
}
if (rvType) *rvType = RETURNVALUE_IGNORE;
if (code_returns == RETURNVALUE_NORMAL)
{
if (supportedReturnValues & (RETURNVALUE_FPSTACK|RETURNVALUE_BOOL))
{
if (bufOut_len < GLUE_PUSH_VAL_AT_PX_TO_FPSTACK_SIZE) RET_MINUS1_FAIL("pushvalatpxtofpstack,size")
if (bufOut)
{
GLUE_PUSH_VAL_AT_PX_TO_FPSTACK(bufOut,0); // always fld qword [eax] but we might change that later
bufOut += GLUE_PUSH_VAL_AT_PX_TO_FPSTACK_SIZE;
}
codesz += GLUE_PUSH_VAL_AT_PX_TO_FPSTACK_SIZE;
bufOut_len -= GLUE_PUSH_VAL_AT_PX_TO_FPSTACK_SIZE;
if (supportedReturnValues & RETURNVALUE_BOOL)
{
code_returns = RETURNVALUE_FPSTACK;
}
else
{
if (rvType) *rvType = RETURNVALUE_FPSTACK;
}
}
}
if (code_returns == RETURNVALUE_FPSTACK)
{
if (supportedReturnValues & (RETURNVALUE_BOOL|RETURNVALUE_BOOL_REVERSED))
{
int stubsize;
void *stub;
if (supportedReturnValues & RETURNVALUE_BOOL_REVERSED)
{
if (rvType) *rvType = RETURNVALUE_BOOL_REVERSED;
stub = GLUE_realAddress(nseel_asm_fptobool_rev,nseel_asm_fptobool_rev_end,&stubsize);
}
else
{
if (rvType) *rvType = RETURNVALUE_BOOL;
stub = GLUE_realAddress(nseel_asm_fptobool,nseel_asm_fptobool_end,&stubsize);
}
if (!stub || bufOut_len < stubsize) RET_MINUS1_FAIL(stub?"fptobool size":"fptobool addr")
if (bufOut)
{
memcpy(bufOut,stub,stubsize);
bufOut += stubsize;
}
codesz+=stubsize;
bufOut_len -= stubsize;
}
else if (supportedReturnValues & RETURNVALUE_NORMAL)
{
if (computTableSize) (*computTableSize) ++;
if (bufOut_len < GLUE_POP_FPSTACK_TO_WTP_TO_PX_SIZE) RET_MINUS1_FAIL("popfpstacktowtptopxsize")
// generate fp-pop to temp space
if (bufOut) GLUE_POP_FPSTACK_TO_WTP_TO_PX(bufOut,0);
codesz+=GLUE_POP_FPSTACK_TO_WTP_TO_PX_SIZE;
if (rvType) *rvType = RETURNVALUE_NORMAL;
}
else
{
// toss return value that will be ignored
if (bufOut_len < GLUE_POP_FPSTACK_SIZE) RET_MINUS1_FAIL("popfpstack size")
if (bufOut) memcpy(bufOut,GLUE_POP_FPSTACK,GLUE_POP_FPSTACK_SIZE);
codesz+=GLUE_POP_FPSTACK_SIZE;
}
}
return codesz;
}
#if 0
static void movestringover(char *str, int amount)
{
char tmp[1024+8];
int l=(int)strlen(str);
l=wdl_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);
}
#endif
//------------------------------------------------------------------------------
NSEEL_CODEHANDLE NSEEL_code_compile(NSEEL_VMCTX _ctx, const char *_expression, int lineoffs)
{
return NSEEL_code_compile_ex(_ctx,_expression,lineoffs,0);
}
typedef struct topLevelCodeSegmentRec {
struct topLevelCodeSegmentRec *_next;
void *code;
int codesz;
int tmptable_use;
} topLevelCodeSegmentRec;
NSEEL_CODEHANDLE NSEEL_code_compile_ex(NSEEL_VMCTX _ctx, const char *_expression, int lineoffs, int compile_flags)
{
compileContext *ctx = (compileContext *)_ctx;
const char *endptr;
const char *_expression_end;
codeHandleType *handle;
topLevelCodeSegmentRec *startpts_tail=NULL;
topLevelCodeSegmentRec *startpts=NULL;
_codeHandleFunctionRec *oldCommonFunctionList;
int curtabptr_sz=0;
void *curtabptr=NULL;
int had_err=0;
if (!ctx) return 0;
ctx->directValueCache=0;
ctx->optimizeDisableFlags=0;
ctx->gotEndOfInput=0;
ctx->current_compile_flags = compile_flags;
if (compile_flags & NSEEL_CODE_COMPILE_FLAG_COMMONFUNCS_RESET)
{
ctx->functions_common=NULL; // reset common function list
}
else
{
// reset common compiled function code, forcing a recompile if shared
_codeHandleFunctionRec *a = ctx->functions_common;
while (a)
{
_codeHandleFunctionRec *b = a->derivedCopies;
if (a->localstorage)
{
// force local storage actual values to be reallocated if used again
memset(a->localstorage,0,sizeof(EEL_F *) * a->localstorage_size);
}
a->startptr = NULL; // force this copy to be recompiled
a->startptr_size = -1;
while (b)
{
b->startptr = NULL; // force derived copies to get recompiled
b->startptr_size = -1;
// no need to reset b->localstorage, since it points to a->localstorage
b=b->derivedCopies;
}
a=a->next;
}
}
ctx->last_error_string[0]=0;
if (!_expression || !*_expression) return 0;
_expression_end = _expression + strlen(_expression);
oldCommonFunctionList = ctx->functions_common;
ctx->isGeneratingCommonFunction=0;
ctx->isSharedFunctions = !!(compile_flags & NSEEL_CODE_COMPILE_FLAG_COMMONFUNCS);
ctx->functions_local = NULL;
freeBlocks(&ctx->tmpblocks_head); // free blocks
freeBlocks(&ctx->blocks_head); // free blocks
freeBlocks(&ctx->blocks_head_data); // free blocks
memset(ctx->l_stats,0,sizeof(ctx->l_stats));
handle = (codeHandleType*)newDataBlock(sizeof(codeHandleType),8);
if (!handle)
{
return 0;
}
memset(handle,0,sizeof(codeHandleType));
ctx->l_stats[0] += (int)(_expression_end - _expression);
ctx->tmpCodeHandle = handle;
endptr=_expression;
while (*endptr)
{
int computTableTop = 0;
int startptr_size=0;
void *startptr=NULL;
opcodeRec *start_opcode=NULL;
const char *expr=endptr;
int function_numparms=0;
char is_fname[NSEEL_MAX_VARIABLE_NAMELEN+1];
is_fname[0]=0;
memset(ctx->function_localTable_Size,0,sizeof(ctx->function_localTable_Size));
memset(ctx->function_localTable_Names,0,sizeof(ctx->function_localTable_Names));
ctx->function_localTable_ValuePtrs=0;
ctx->function_usesNamespaces=0;
ctx->function_curName=NULL;
ctx->function_globalFlag=0;
ctx->errVar=0;
// single out top level segment
{
int had_something = 0, pcnt=0, pcnt2=0;
int state=0;
for (;;)
{
int l;
const char *p=nseel_simple_tokenizer(&endptr,_expression_end,&l,&state);
if (!p)
{
if (pcnt || pcnt2) ctx->gotEndOfInput|=4;
break;
}
if (*p == ';')
{
if (had_something && !pcnt && !pcnt2) break;
}
else if (*p == '/' && l > 1 && (p[1] == '/' || p[1] == '*'))
{
if (l > 19 && !strnicmp(p,"//#eel-no-optimize:",19))
ctx->optimizeDisableFlags = atoi(p+19);
}
else
{
if (!had_something)
{
expr = p;
had_something = 1;
}
if (*p == '(') pcnt++;
else if (*p == ')') { if (--pcnt<0) pcnt=0; }
else if (*p == '[') pcnt2++;
else if (*p == ']') { if (--pcnt2<0) pcnt2=0; }
}
}
if (!*expr || !had_something) break;
}
// parse
{
int tmplen,funcname_len;
const char *p = expr;
const char *tok1 = nseel_simple_tokenizer(&p,endptr,&tmplen,NULL);
const char *funcname = nseel_simple_tokenizer(&p,endptr,&funcname_len,NULL);
if (tok1 && funcname && tmplen == 8 && !strnicmp(tok1,"function",8) && (isalpha(funcname[0]) || funcname[0] == '_'))
{
int had_parms_locals=0;
if (funcname_len > sizeof(is_fname)-1) funcname_len=sizeof(is_fname)-1;
memcpy(is_fname, funcname, funcname_len);
is_fname[funcname_len]=0;
ctx->function_curName = is_fname; // only assigned for the duration of the loop, cleared later //-V507
while (NULL != (tok1 = nseel_simple_tokenizer(&p,endptr,&tmplen,NULL)))
{
int is_parms = 0, localTableContext = 0;
int maxcnt=0;
const char *sp_save;
if (tok1[0] == '(')
{
if (had_parms_locals)
{
expr = p-1; // begin compilation at this code!
break;
}
is_parms = 1;
}
else
{
if (tmplen == 5 && !strnicmp(tok1,"local",tmplen)) localTableContext=0;
else if (tmplen == 6 && !strnicmp(tok1,"static",tmplen)) localTableContext=0;
else if (tmplen == 8 && !strnicmp(tok1,"instance",tmplen)) localTableContext=1;
else if ((tmplen == 7 && !strnicmp(tok1,"globals",tmplen)) ||
(tmplen == 6 && !strnicmp(tok1,"global",tmplen)))
{
ctx->function_globalFlag = 1;
localTableContext=2;
}
else break; // unknown token!
tok1 = nseel_simple_tokenizer(&p,endptr,&tmplen,NULL);
if (!tok1 || tok1[0] != '(') break;
}
had_parms_locals = 1;
sp_save=p;
while (NULL != (tok1 = nseel_simple_tokenizer(&p,endptr,&tmplen,NULL)))
{
if (tok1[0] == ')') break;
if (*tok1 == '#' && localTableContext!=1 && localTableContext!=2)
{
ctx->errVar = (int) (tok1 - _expression);
lstrcpyn_safe(ctx->last_error_string,"#string can only be in instance() or globals()",sizeof(ctx->last_error_string));
goto had_error;
}
if (isalpha(*tok1) || *tok1 == '_' || *tok1 == '#')
{
maxcnt++;
if (p < endptr && *p == '*')
{
if (!is_parms && localTableContext!=2)
{
ctx->errVar = (int) (p - _expression);
lstrcpyn_safe(ctx->last_error_string,"namespace* can only be used in parameters or globals()",sizeof(ctx->last_error_string));
goto had_error;
}
p++;
}
}
else if (*tok1 != ',')
{
ctx->errVar = (int)(tok1 - _expression);
lstrcpyn_safe(ctx->last_error_string,"unknown character in function parameters",sizeof(ctx->last_error_string));
goto had_error;
}
}
if (tok1 && maxcnt > 0)
{
char **ot = ctx->function_localTable_Names[localTableContext];
const int osz = ctx->function_localTable_Size[localTableContext];
maxcnt += osz;
ctx->function_localTable_Names[localTableContext] = (char **)newTmpBlock(ctx,sizeof(char *) * maxcnt);
if (ctx->function_localTable_Names[localTableContext])
{
int i=osz;
if (osz && ot) memcpy(ctx->function_localTable_Names[localTableContext],ot,sizeof(char *) * osz);
p=sp_save;
while (NULL != (tok1 = nseel_simple_tokenizer(&p,endptr,&tmplen,NULL)))
{
if (tok1[0] == ')') break;
if (isalpha(*tok1) || *tok1 == '_' || *tok1 == '#')
{
char *newstr;
int l = tmplen;
if (*p == '*') // xyz* for namespace
{
p++;
l++;
}
if (l > NSEEL_MAX_VARIABLE_NAMELEN) l = NSEEL_MAX_VARIABLE_NAMELEN;
newstr = newTmpBlock(ctx,l+1);
if (newstr)
{
memcpy(newstr,tok1,l);
newstr[l]=0;
ctx->function_localTable_Names[localTableContext][i++] = newstr;
}
}
}
ctx->function_localTable_Size[localTableContext]=i;
if (is_parms) function_numparms = i;
}
}
}
}
}
if (ctx->function_localTable_Size[0]>0)
{
ctx->function_localTable_ValuePtrs =
ctx->isSharedFunctions ? newDataBlock(ctx->function_localTable_Size[0] * sizeof(EEL_F *),8) :
newTmpBlock(ctx,ctx->function_localTable_Size[0] * sizeof(EEL_F *));
if (!ctx->function_localTable_ValuePtrs)
{
ctx->function_localTable_Size[0]=0;
function_numparms=0;
}
else
{
memset(ctx->function_localTable_ValuePtrs,0,sizeof(EEL_F *) * ctx->function_localTable_Size[0]); // force values to be allocated
}
}
{
int nseelparse(compileContext* context);
void nseelrestart (void *input_file ,void *yyscanner );
ctx->rdbuf_start = _expression;
#ifdef NSEEL_SUPER_MINIMAL_LEXER
ctx->rdbuf = expr;
ctx->rdbuf_end = endptr;
if (!nseelparse(ctx) && !ctx->errVar)
{
start_opcode = ctx->result;
}
#else
nseelrestart(NULL,ctx->scanner);
ctx->rdbuf = expr;
ctx->rdbuf_end = endptr;
if (!nseelparse(ctx) && !ctx->errVar)
{
start_opcode = ctx->result;
}
if (ctx->errVar)
{
const char *p=expr;
ctx->errVar += expr-_expression;
}
#endif
ctx->rdbuf = NULL;
}
if (start_opcode)
{
int rvMode=0, fUse=0;
#ifdef LOG_OPT
char buf[512];
int sd=0;
sprintf(buf,"pre opt sz=%d (tsackDepth=%d)\n",compileOpcodes(ctx,start_opcode,NULL,1024*1024*256,NULL, NULL,RETURNVALUE_IGNORE,NULL,&sd,NULL),sd);
#ifdef _WIN32
OutputDebugString(buf);
#else
printf("%s\n",buf);
#endif
#endif
#ifdef EEL_DUMP_OPS
// dump opcode trees for verification, before optimizing
if (g_eel_dump_fp)
{
fprintf(g_eel_dump_fp,"-- opcode chunk --\r\n");
dumpOpcodeTree(ctx,g_eel_dump_fp,start_opcode,2);
}
#endif
if (!(ctx->optimizeDisableFlags&OPTFLAG_NO_OPTIMIZE)) optimizeOpcodes(ctx,start_opcode,is_fname[0] ? 1 : 0);
#ifdef LOG_OPT
sprintf(buf,"post opt sz=%d, stack depth=%d\n",compileOpcodes(ctx,start_opcode,NULL,1024*1024*256,NULL,NULL, RETURNVALUE_IGNORE,NULL,&sd,NULL),sd);
#ifdef _WIN32
OutputDebugString(buf);
#else
printf("%s\n",buf);
#endif
#endif
#ifdef EEL_DUMP_OPS
// dump opcode trees for verification, after optimizing
if (g_eel_dump_fp2)
{
fprintf(g_eel_dump_fp2,"-- POST-OPTIMIZED opcode chunk --\r\n");
dumpOpcodeTree(ctx,g_eel_dump_fp2,start_opcode,2);
}
#endif
if (is_fname[0])
{
_codeHandleFunctionRec *fr = ctx->isSharedFunctions ? newDataBlock(sizeof(_codeHandleFunctionRec),8) :
newTmpBlock(ctx,sizeof(_codeHandleFunctionRec));
if (fr)
{
memset(fr,0,sizeof(_codeHandleFunctionRec));
fr->startptr_size = -1;
fr->opcodes = start_opcode;
if (ctx->function_localTable_Size[0] > 0 && ctx->function_localTable_ValuePtrs)
{
if (ctx->function_localTable_Names[0])
{
int i;
for(i=0;i<function_numparms;i++)
{
const char *nptr = ctx->function_localTable_Names[0][i];
if (nptr && *nptr && nptr[strlen(nptr)-1] == '*')
{
fr->parameterAsNamespaceMask |= ((unsigned int)1)<<i;
}
}
}
fr->num_params=function_numparms;
fr->localstorage = ctx->function_localTable_ValuePtrs;
fr->localstorage_size = ctx->function_localTable_Size[0];
}
fr->usesNamespaces = ctx->function_usesNamespaces;
fr->isCommonFunction = ctx->isSharedFunctions;
lstrcpyn_safe(fr->fname,is_fname,sizeof(fr->fname));
if (ctx->isSharedFunctions)
{
fr->next = ctx->functions_common;
ctx->functions_common = fr;
}
else
{
fr->next = ctx->functions_local;
ctx->functions_local = fr;
}
}
continue;
}
#ifdef DUMP_OPS_DURING_COMPILE
g_debugfp_indent=0;
g_debugfp_histsz=0;
g_debugfp = fopen("C:/temp/foo.txt","w");
#endif
startptr_size = compileOpcodes(ctx,start_opcode,NULL,1024*1024*256,NULL, NULL,
is_fname[0] ? (RETURNVALUE_NORMAL|RETURNVALUE_FPSTACK) : RETURNVALUE_IGNORE, &rvMode, &fUse, NULL); // if not a function, force return value as address (avoid having to pop it ourselves
// if a function, allow the code to decide how return values are generated
#ifdef DUMP_OPS_DURING_COMPILE
if (g_debugfp) fclose(g_debugfp);
g_debugfp=0;
#endif
if (!startptr_size) continue; // optimized away
if (startptr_size>0)
{
startptr = newTmpBlock(ctx,startptr_size);
if (startptr)
{
startptr_size=compileOpcodes(ctx,start_opcode,(unsigned char*)startptr,startptr_size,&computTableTop, NULL, RETURNVALUE_IGNORE, NULL,NULL, NULL);
if (startptr_size<=0) startptr = NULL;
}
}
}
if (!startptr)
{
had_error:
#ifdef NSEEL_EEL1_COMPAT_MODE
continue;
#else
//if (!ctx->last_error_string[0])
{
int byteoffs = ctx->errVar;
int linenumber;
char cur_err[sizeof(ctx->last_error_string)];
lstrcpyn_safe(cur_err,ctx->last_error_string,sizeof(cur_err));
if (cur_err[0]) lstrcatn(cur_err,": ",sizeof(cur_err));
else lstrcpyn_safe(cur_err,"syntax error: ",sizeof(cur_err));
if (_expression + byteoffs >= _expression_end)
{
if (ctx->gotEndOfInput&4) byteoffs = (int)(expr-_expression);
else byteoffs=(int)(_expression_end-_expression);
}
if (byteoffs < 0) byteoffs=0;
linenumber=findLineNumber(_expression,byteoffs)+1;
if (ctx->gotEndOfInput&4)
{
snprintf(ctx->last_error_string,sizeof(ctx->last_error_string),"%d: %smissing ) or ]",linenumber+lineoffs,cur_err);
}
else
{
const char *p = _expression + byteoffs;
int x=0, right_amt_nospace=0, left_amt_nospace=0;
while (x < 32 && p-x > _expression && p[-x] != '\r' && p[-x] != '\n')
{
if (!isspace(p[-x])) left_amt_nospace=x;
x++;
}
x=0;
while (x < 60 && p[x] && p[x] != '\r' && p[x] != '\n')
{
if (!isspace(p[x])) right_amt_nospace=x;
x++;
}
if (right_amt_nospace<1) right_amt_nospace=1;
// display left_amt >>>> right_amt_nospace
if (left_amt_nospace > 0)
snprintf(ctx->last_error_string,sizeof(ctx->last_error_string),"%d: %s'%.*s <!> %.*s'",linenumber+lineoffs,cur_err,
left_amt_nospace,p-left_amt_nospace,
right_amt_nospace,p);
else
snprintf(ctx->last_error_string,sizeof(ctx->last_error_string),"%d: %s'%.*s'",linenumber+lineoffs,cur_err,right_amt_nospace,p);
}
}
startpts=NULL;
startpts_tail=NULL;
had_err=1;
break;
#endif
}
if (!is_fname[0]) // redundant check (if is_fname[0] is set and we succeeded, it should continue)
// but we'll be on the safe side
{
topLevelCodeSegmentRec *p = newTmpBlock(ctx,sizeof(topLevelCodeSegmentRec));
p->_next=0;
p->code = startptr;
p->codesz = startptr_size;
p->tmptable_use = computTableTop;
if (!startpts_tail) startpts_tail=startpts=p;
else
{
startpts_tail->_next=p;
startpts_tail=p;
}
if (curtabptr_sz < computTableTop)
{
curtabptr_sz=computTableTop;
}
}
}
memset(ctx->function_localTable_Size,0,sizeof(ctx->function_localTable_Size));
memset(ctx->function_localTable_Names,0,sizeof(ctx->function_localTable_Names));
ctx->function_localTable_ValuePtrs=0;
ctx->function_usesNamespaces=0;
ctx->function_curName=NULL;
ctx->function_globalFlag=0;
ctx->tmpCodeHandle = NULL;
if (handle->want_stack)
{
if (!handle->stack) startpts=NULL;
}
if (startpts)
{
curtabptr_sz += 2; // many functions use the worktable for temporary storage of up to 2 EEL_F's
handle->workTable_size = curtabptr_sz;
handle->workTable = curtabptr = newDataBlock((curtabptr_sz+MIN_COMPUTABLE_SIZE + COMPUTABLE_EXTRA_SPACE) * sizeof(EEL_F),32);
#ifdef EEL_VALIDATE_WORKTABLE_USE
if (curtabptr) memset(curtabptr,0x3a,(curtabptr_sz+MIN_COMPUTABLE_SIZE + COMPUTABLE_EXTRA_SPACE) * sizeof(EEL_F));
#endif
if (!curtabptr) startpts=NULL;
}
if (startpts || (!had_err && (compile_flags & NSEEL_CODE_COMPILE_FLAG_COMMONFUNCS)))
{
unsigned char *writeptr;
topLevelCodeSegmentRec *p=startpts;
int size=sizeof(GLUE_RET)+GLUE_FUNC_ENTER_SIZE+GLUE_FUNC_LEAVE_SIZE; // for ret at end :)
int wtpos=0;
// now we build one big code segment out of our list of them, inserting a mov esi, computable before each item as necessary
while (p)
{
if (wtpos <= 0)
{
wtpos=MIN_COMPUTABLE_SIZE;
size += GLUE_RESET_WTP(NULL,0);
}
size+=p->codesz;
wtpos -= p->tmptable_use;
p=p->_next;
}
handle->code = newCodeBlock(size,32);
if (handle->code)
{
writeptr=(unsigned char *)handle->code;
#if GLUE_FUNC_ENTER_SIZE > 0
memcpy(writeptr,&GLUE_FUNC_ENTER,GLUE_FUNC_ENTER_SIZE);
writeptr += GLUE_FUNC_ENTER_SIZE;
#endif
p=startpts;
wtpos=0;
while (p)
{
if (wtpos <= 0)
{
wtpos=MIN_COMPUTABLE_SIZE;
writeptr+=GLUE_RESET_WTP(writeptr,curtabptr);
}
memcpy(writeptr,(char*)p->code,p->codesz);
writeptr += p->codesz;
wtpos -= p->tmptable_use;
p=p->_next;
}
#if GLUE_FUNC_LEAVE_SIZE > 0
memcpy(writeptr,&GLUE_FUNC_LEAVE,GLUE_FUNC_LEAVE_SIZE);
writeptr += GLUE_FUNC_LEAVE_SIZE;
#endif
memcpy(writeptr,&GLUE_RET,sizeof(GLUE_RET)); writeptr += sizeof(GLUE_RET);
ctx->l_stats[1]=size;
handle->code_size = (int) (writeptr - (unsigned char *)handle->code);
#if defined(__arm__) || defined(__aarch64__)
__clear_cache(handle->code,writeptr);
#endif
}
handle->blocks = ctx->blocks_head;
handle->blocks_data = ctx->blocks_head_data;
ctx->blocks_head=0;
ctx->blocks_head_data=0;
}
else
{
// failed compiling, or failed calloc()
handle=NULL; // return NULL (after resetting blocks_head)
}
ctx->directValueCache=0;
ctx->functions_local = NULL;
ctx->isGeneratingCommonFunction=0;
ctx->isSharedFunctions=0;
freeBlocks(&ctx->tmpblocks_head); // free blocks
freeBlocks(&ctx->blocks_head); // free blocks of code (will be nonzero only on error)
freeBlocks(&ctx->blocks_head_data); // free blocks of data (will be nonzero only on error)
if (handle)
{
handle->compile_flags = compile_flags;
handle->ramPtr = ctx->ram_state.blocks;
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]++;
}
else
{
ctx->functions_common = oldCommonFunctionList; // failed compiling, remove any added common functions from the list
// remove any derived copies of functions due to error, since we may have added some that have been freed
while (oldCommonFunctionList)
{
oldCommonFunctionList->derivedCopies=NULL;
oldCommonFunctionList=oldCommonFunctionList->next;
}
}
memset(ctx->l_stats,0,sizeof(ctx->l_stats));
return (NSEEL_CODEHANDLE)handle;
}
//------------------------------------------------------------------------------
void NSEEL_code_execute(NSEEL_CODEHANDLE code)
{
#ifndef GLUE_TABPTR_IGNORED
INT_PTR tabptr;
#endif
INT_PTR codeptr;
codeHandleType *h = (codeHandleType *)code;
if (!h || !h->code) return;
codeptr = (INT_PTR) h->code;
#if 0
{
unsigned int *p=(unsigned int *)codeptr;
while (*p != GLUE_RET[0])
{
printf("instr:%04X:%04X\n",*p>>16,*p&0xffff);
p++;
}
}
#endif
#ifndef GLUE_TABPTR_IGNORED
tabptr=(INT_PTR)h->workTable;
#endif
//printf("calling code!\n");
GLUE_CALL_CODE(tabptr,codeptr,(INT_PTR)h->ramPtr);
}
int NSEEL_code_geterror_flag(NSEEL_VMCTX ctx)
{
compileContext *c=(compileContext *)ctx;
if (c) return (c->gotEndOfInput ? 1 : 0);
return 0;
}
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)
{
#ifdef EEL_VALIDATE_WORKTABLE_USE
if (h->workTable)
{
char *p = ((char*)h->workTable) + h->workTable_size*sizeof(EEL_F);
int x;
for(x=COMPUTABLE_EXTRA_SPACE*sizeof(EEL_F) - 1;x >= 0; x --)
if (p[x] != 0x3a)
{
char buf[512];
snprintf(buf,sizeof(buf),"worktable overrun at byte %d (wts=%d), value = %f\n",x,h->workTable_size, *(EEL_F*)(p+(x&~(sizeof(EEL_F)-1))));
#ifdef _WIN32
OutputDebugString(buf);
#else
printf("%s",buf);
#endif
break;
}
}
#endif
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]--;
#if defined(__ppc__) && defined(__APPLE__)
{
FILE *fp = fopen("/var/db/receipts/com.apple.pkg.Rosetta.plist","r");
if (fp)
{
fclose(fp);
// on PPC, but rosetta installed, do not free h->blocks, as rosetta won't detect changes to these pages
}
else
{
freeBlocks(&h->blocks);
}
}
#else
freeBlocks(&h->blocks);
#endif
freeBlocks(&h->blocks_data);
}
}
//------------------------------------------------------------------------------
NSEEL_VMCTX NSEEL_VM_alloc() // return a handle
{
compileContext *ctx=calloc(1,sizeof(compileContext));
#ifdef NSEEL_SUPER_MINIMAL_LEXER
if (ctx) ctx->scanner = ctx;
#else
if (ctx)
{
int nseellex_init(void ** ptr_yy_globals);
void nseelset_extra(void *user_defined , void *yyscanner);
if (nseellex_init(&ctx->scanner))
{
free(ctx);
return NULL;
}
nseelset_extra(ctx,ctx->scanner);
}
#endif
if (ctx)
{
ctx->ram_state.maxblocks = NSEEL_RAM_BLOCKS_DEFAULTMAX;
ctx->ram_state.closefact = NSEEL_CLOSEFACTOR;
}
return ctx;
}
int NSEEL_VM_setramsize(NSEEL_VMCTX _ctx, int maxent)
{
compileContext *ctx = (compileContext *)_ctx;
if (!ctx) return 0;
if (maxent > 0)
{
maxent = (maxent + NSEEL_RAM_ITEMSPERBLOCK - 1)/NSEEL_RAM_ITEMSPERBLOCK;
if (maxent > NSEEL_RAM_BLOCKS) maxent = NSEEL_RAM_BLOCKS;
ctx->ram_state.maxblocks = maxent;
}
return ctx->ram_state.maxblocks * NSEEL_RAM_ITEMSPERBLOCK;
}
void NSEEL_VM_SetFunctionValidator(NSEEL_VMCTX _ctx, const char * (*validateFunc)(const char *fn_name, void *user), void *user)
{
if (_ctx)
{
compileContext *ctx = (compileContext *)_ctx;
ctx->func_check = validateFunc;
ctx->func_check_user = user;
}
}
void NSEEL_VM_SetFunctionTable(NSEEL_VMCTX _ctx, eel_function_table *tab)
{
if (_ctx)
{
compileContext *ctx = (compileContext *)_ctx;
ctx->registered_func_tab = tab;
}
}
void NSEEL_VM_free(NSEEL_VMCTX _ctx) // free when done with a VM and ALL of its code have been freed, as well
{
if (_ctx)
{
compileContext *ctx=(compileContext *)_ctx;
EEL_GROWBUF_RESIZE(&ctx->varNameList,-1);
NSEEL_VM_freeRAM(_ctx);
freeBlocks(&ctx->pblocks);
// these should be 0 normally but just in case
freeBlocks(&ctx->tmpblocks_head); // free blocks
freeBlocks(&ctx->blocks_head); // free blocks
freeBlocks(&ctx->blocks_head_data); // free blocks
#ifndef NSEEL_SUPER_MINIMAL_LEXER
if (ctx->scanner)
{
int nseellex_destroy(void *yyscanner);
nseellex_destroy(ctx->scanner);
}
#endif
ctx->scanner=0;
if (ctx->has_used_global_vars)
{
nseel_globalVarItem *p = NULL;
NSEEL_HOSTSTUB_EnterMutex();
if (--nseel_vms_referencing_globallist_cnt == 0)
{
// clear and free globals
p = nseel_globalreg_list;
nseel_globalreg_list=0;
}
NSEEL_HOSTSTUB_LeaveMutex();
while (p)
{
nseel_globalVarItem *op = p;
p=p->_next;
free(op);
}
}
free(ctx);
}
}
int *NSEEL_code_getstats(NSEEL_CODEHANDLE code)
{
codeHandleType *h = (codeHandleType *)code;
if (h)
{
return h->code_stats;
}
return 0;
}
void NSEEL_VM_SetStringFunc(NSEEL_VMCTX ctx,
EEL_F (*onString)(void *caller_this, struct eelStringSegmentRec *list),
EEL_F (*onNamedString)(void *caller_this, const char *name))
{
if (ctx)
{
compileContext *c=(compileContext*)ctx;
c->onString = onString;
c->onNamedString = onNamedString;
}
}
void NSEEL_VM_SetCustomFuncThis(NSEEL_VMCTX ctx, void *thisptr)
{
if (ctx)
{
compileContext *c=(compileContext*)ctx;
c->caller_this=thisptr;
}
}
void *NSEEL_PProc_RAM(void *data, int data_size, compileContext *ctx)
{
if (data_size>0) data=EEL_GLUE_set_immediate(data, (INT_PTR)ctx->ram_state.blocks);
return data;
}
void *NSEEL_PProc_THIS(void *data, int data_size, compileContext *ctx)
{
if (data_size>0) data=EEL_GLUE_set_immediate(data, (INT_PTR)ctx->caller_this);
return data;
}
static int vartable_lowerbound(compileContext *ctx, const char *name, int *ismatch)
{
int a = 0, c = EEL_GROWBUF_GET_SIZE(&ctx->varNameList);
varNameRec **list = EEL_GROWBUF_GET(&ctx->varNameList);
while (a != c)
{
const int b = (a+c)/2;
const int cmp = strnicmp(name,list[b]->str,NSEEL_MAX_VARIABLE_NAMELEN);
if (cmp > 0) a = b+1;
else if (cmp < 0) c = b;
else
{
*ismatch = 1;
return b;
}
}
*ismatch = 0;
return a;
}
static void vartable_cull_list(compileContext *ctx, int refcnt_chk)
{
const int ni = EEL_GROWBUF_GET_SIZE(&ctx->varNameList);
int i = ni, ndel = 0;
varNameRec **rd = EEL_GROWBUF_GET(&ctx->varNameList), **wr=rd;
while (i--)
{
varNameRec *v = rd[0];
if ((!refcnt_chk || !v->refcnt) && !v->isreg)
{
ndel++;
}
else
{
if (wr != rd) *wr = *rd;
wr++;
}
rd++;
}
if (ndel) EEL_GROWBUF_RESIZE(&ctx->varNameList,ni - ndel);
}
void NSEEL_VM_remove_unused_vars(NSEEL_VMCTX _ctx)
{
compileContext *ctx = (compileContext *)_ctx;
if (ctx) vartable_cull_list(ctx,1);
}
void NSEEL_VM_remove_all_nonreg_vars(NSEEL_VMCTX _ctx)
{
compileContext *ctx = (compileContext *)_ctx;
if (ctx) vartable_cull_list(ctx,0);
}
void NSEEL_VM_clear_var_refcnts(NSEEL_VMCTX _ctx)
{
compileContext *ctx = (compileContext *)_ctx;
if (ctx)
{
int i = EEL_GROWBUF_GET_SIZE(&ctx->varNameList);
varNameRec **rd = EEL_GROWBUF_GET(&ctx->varNameList);
while (i--)
{
rd[0]->refcnt=0;
rd++;
}
}
}
#ifdef NSEEL_EEL1_COMPAT_MODE
static EEL_F __nseel_global_regs[100];
double *NSEEL_getglobalregs() { return __nseel_global_regs; }
#endif
EEL_F *get_global_var(compileContext *ctx, const char *gv, int addIfNotPresent)
{
nseel_globalVarItem *p;
#ifdef NSEEL_EEL1_COMPAT_MODE
if (!strnicmp(gv,"reg",3) && gv[3]>='0' && gv[3] <= '9' && gv[4] >= '0' && gv[4] <= '9' && !gv[5])
{
return __nseel_global_regs + atoi(gv+3);
}
#endif
NSEEL_HOSTSTUB_EnterMutex();
if (!ctx->has_used_global_vars)
{
ctx->has_used_global_vars++;
nseel_vms_referencing_globallist_cnt++;
}
p = nseel_globalreg_list;
while (p)
{
if (!stricmp(p->name,gv)) break;
p=p->_next;
}
if (!p && addIfNotPresent)
{
size_t gvl = strlen(gv);
p = (nseel_globalVarItem*)malloc(sizeof(nseel_globalVarItem) + gvl);
if (p)
{
p->data=0.0;
strcpy(p->name,gv);
p->_next = nseel_globalreg_list;
nseel_globalreg_list=p;
}
}
NSEEL_HOSTSTUB_LeaveMutex();
return p ? &p->data : NULL;
}
EEL_F *nseel_int_register_var(compileContext *ctx, const char *name, int isReg, const char **namePtrOut)
{
int slot, match;
if (isReg == 0 && ctx->getVariable)
{
EEL_F *ret = ctx->getVariable(ctx->getVariable_userctx, name);
if (ret) return ret;
}
if (!strnicmp(name,"_global.",8) && name[8])
{
EEL_F *a=get_global_var(ctx,name+8,isReg >= 0);
if (a) return a;
}
slot = vartable_lowerbound(ctx,name, &match);
if (match)
{
varNameRec *v = EEL_GROWBUF_GET(&ctx->varNameList)[slot];
if (isReg >= 0)
{
v->refcnt++;
if (isReg) v->isreg=isReg;
if (namePtrOut) *namePtrOut = v->str;
}
return v->value;
}
if (isReg < 0) return NULL;
if (ctx->varValueStore_left<1)
{
const int sz=500;
ctx->varValueStore_left = sz;
ctx->varValueStore = (EEL_F *)newCtxDataBlock((int)sizeof(EEL_F)*sz,8);
}
if (ctx->varValueStore)
{
int listsz = EEL_GROWBUF_GET_SIZE(&ctx->varNameList);
size_t l = strlen(name);
varNameRec *vh;
if (l > NSEEL_MAX_VARIABLE_NAMELEN) l = NSEEL_MAX_VARIABLE_NAMELEN;
vh = (varNameRec*) newCtxDataBlock( (int) (sizeof(varNameRec) + l),8);
if (!vh || EEL_GROWBUF_RESIZE(&ctx->varNameList, (listsz+1))) return NULL; // alloc fail
(vh->value = ctx->varValueStore++)[0]=0.0;
ctx->varValueStore_left--;
vh->refcnt=1;
vh->isreg=isReg;
memcpy(vh->str,name,l);
vh->str[l] = 0;
if (namePtrOut) *namePtrOut = vh->str;
if (slot < listsz)
{
memmove(EEL_GROWBUF_GET(&ctx->varNameList) + slot+1,
EEL_GROWBUF_GET(&ctx->varNameList) + slot, (listsz - slot) * sizeof(EEL_GROWBUF_GET(&ctx->varNameList)[0]));
}
EEL_GROWBUF_GET(&ctx->varNameList)[slot] = vh;
return vh->value;
}
return NULL;
}
//------------------------------------------------------------------------------
void NSEEL_VM_enumallvars(NSEEL_VMCTX ctx, int (*func)(const char *name, EEL_F *val, void *ctx), void *userctx)
{
compileContext *tctx = (compileContext *) ctx;
int ni;
varNameRec **rd;
if (!tctx) return;
ni = EEL_GROWBUF_GET_SIZE(&tctx->varNameList);
rd = EEL_GROWBUF_GET(&tctx->varNameList);
while (ni--)
{
if (!func(rd[0]->str,rd[0]->value,userctx)) break;
rd++;
}
}
//------------------------------------------------------------------------------
EEL_F *NSEEL_VM_regvar(NSEEL_VMCTX _ctx, const char *var)
{
compileContext *ctx = (compileContext *)_ctx;
if (!ctx) return 0;
if (!strnicmp(var,"reg",3) && strlen(var) == 5 && isdigit(var[3]) && isdigit(var[4]))
{
EEL_F *a=get_global_var(ctx,var,1);
if (a) return a;
}
return nseel_int_register_var(ctx,var,1,NULL);
}
EEL_F *NSEEL_VM_getvar(NSEEL_VMCTX _ctx, const char *var)
{
compileContext *ctx = (compileContext *)_ctx;
if (!ctx) return 0;
if (!strnicmp(var,"reg",3) && strlen(var) == 5 && isdigit(var[3]) && isdigit(var[4]))
{
EEL_F *a=get_global_var(ctx,var,0);
if (a) return a;
}
return nseel_int_register_var(ctx,var,-1,NULL);
}
int NSEEL_VM_get_var_refcnt(NSEEL_VMCTX _ctx, const char *name)
{
compileContext *ctx = (compileContext *)_ctx;
int slot,match;
if (!ctx) return -1;
slot = vartable_lowerbound(ctx,name, &match);
return match ? EEL_GROWBUF_GET(&ctx->varNameList)[slot]->refcnt : -1;
}
opcodeRec *nseel_createFunctionByName(compileContext *ctx, const char *name, int np, opcodeRec *code1, opcodeRec *code2, opcodeRec *code3)
{
int chkamt=0;
functionType *f=nseel_getFunctionByName(ctx,name,&chkamt);
if (f) while (chkamt-->=0)
{
if ((f->nParams&FUNCTIONTYPE_PARAMETERCOUNTMASK) == np)
{
opcodeRec *o=newOpCode(ctx,NULL, np==3?OPCODETYPE_FUNC3:np==2?OPCODETYPE_FUNC2:OPCODETYPE_FUNC1);
if (o)
{
o->fntype = FUNCTYPE_FUNCTIONTYPEREC;
o->fn = f;
o->parms.parms[0]=code1;
o->parms.parms[1]=code2;
o->parms.parms[2]=code3;
}
return o;
}
f++;
if (stricmp(f->name,name)) break;
}
return NULL;
}
//------------------------------------------------------------------------------
opcodeRec *nseel_translate(compileContext *ctx, const char *tmp, size_t tmplen) // tmplen 0 = null term
{
// this depends on the string being nul terminated eventually, tmplen is used more as a hint than anything else
if ((tmp[0] == '0' || tmp[0] == '$') && toupper(tmp[1])=='X')
{
char *p;
return nseel_createCompiledValue(ctx,(EEL_F)strtoul(tmp+2,&p,16));
}
else if (tmp[0] == '$')
{
if (tmp[1] == '~')
{
char *p=(char*)tmp+2;
unsigned int v=strtoul(tmp+2,&p,10);
if (v>53) v=53;
return nseel_createCompiledValue(ctx,(EEL_F)((((WDL_INT64)1) << v) - 1));
}
else if (!tmplen ? !stricmp(tmp,"$E") : (tmplen == 2 && !strnicmp(tmp,"$E",2)))
return nseel_createCompiledValue(ctx,(EEL_F)2.71828183);
else if (!tmplen ? !stricmp(tmp, "$PI") : (tmplen == 3 && !strnicmp(tmp, "$PI", 3)))
return nseel_createCompiledValue(ctx,(EEL_F)3.141592653589793);
else if (!tmplen ? !stricmp(tmp, "$PHI") : (tmplen == 4 && !strnicmp(tmp, "$PHI", 4)))
return nseel_createCompiledValue(ctx,(EEL_F)1.61803399);
else if ((!tmplen || tmplen == 4) && tmp[1] == '\'' && tmp[2] && tmp[3] == '\'')
return nseel_createCompiledValue(ctx,(EEL_F)tmp[2]);
else return NULL;
}
else if (tmp[0] == '\'')
{
char b[64];
int x,sz;
unsigned int rv=0;
if (!tmplen) // nul terminated tmplen, calculate a workable length
{
// faster than strlen(tmp) if tmp is large, we'll never need more than ~18 chars anyway
while (tmplen < 32 && tmp[tmplen]) tmplen++;
}
sz = tmplen > 0 ? nseel_filter_escaped_string(b,sizeof(b),tmp+1, tmplen - 1, '\'') : 0;
if (sz > 4)
{
if (ctx->last_error_string[0]) lstrcatn(ctx->last_error_string, ", ", sizeof(ctx->last_error_string));
snprintf_append(ctx->last_error_string,sizeof(ctx->last_error_string),"multi-byte character '%.5s...' too long",b);
return NULL; // do not allow 'xyzxy', limit to 4 bytes
}
for (x=0;x<sz;x++) rv = (rv<<8) + ((unsigned char*)b)[x];
return nseel_createCompiledValue(ctx,(EEL_F)rv);
}
else if (tmp[0] == '#')
{
char buf[2048];
if (!tmplen) while (tmplen < sizeof(buf)-1 && tmp[tmplen]) tmplen++;
else if (tmplen > sizeof(buf)-1) tmplen = sizeof(buf)-1;
memcpy(buf,tmp,tmplen);
buf[tmplen]=0;
if (ctx->onNamedString)
{
if (tmplen>0 && buf[1]&&ctx->function_curName)
{
int err=0;
opcodeRec *r = nseel_resolve_named_symbol(ctx,nseel_createCompiledValuePtr(ctx,NULL,buf),-1, &err);
if (r)
{
if (r->opcodeType!=OPCODETYPE_VALUE_FROM_NAMESPACENAME)
{
r->opcodeType = OPCODETYPE_DIRECTVALUE;
r->parms.dv.directValue = ctx->onNamedString(ctx->caller_this,buf+1);
r->parms.dv.valuePtr=NULL;
}
return r;
}
if (err) return NULL;
}
// if not namespaced symbol, return directly
if (!buf[1])
{
opcodeRec *r=newOpCode(ctx,NULL,OPCODETYPE_DIRECTVALUE_TEMPSTRING);
if (r) r->parms.dv.directValue = -10000.0;
return r;
}
return nseel_createCompiledValue(ctx,ctx->onNamedString(ctx->caller_this,buf+1));
}
}
return nseel_createCompiledValue(ctx,(EEL_F)atof(tmp));
}
void NSEEL_VM_set_var_resolver(NSEEL_VMCTX _ctx, EEL_F *(*res)(void *userctx, const char *name), void *userctx)
{
compileContext *ctx = (compileContext *)_ctx;
if (ctx)
{
ctx->getVariable = res;
ctx->getVariable_userctx = userctx;
}
}
#if defined(__ppc__) || defined(EEL_TARGET_PORTABLE)
// blank stubs
void eel_setfp_round() { }
void eel_setfp_trunc() { }
void eel_enterfp(int s[2]) {}
void eel_leavefp(int s[2]) {}
#endif
Copy Permalink