diff options
Diffstat (limited to 'Src/ns-eel2/ns-eel-int.h')
| -rw-r--r-- | Src/ns-eel2/ns-eel-int.h | 331 |
1 files changed, 331 insertions, 0 deletions
diff --git a/Src/ns-eel2/ns-eel-int.h b/Src/ns-eel2/ns-eel-int.h new file mode 100644 index 00000000..a13478e0 --- /dev/null +++ b/Src/ns-eel2/ns-eel-int.h @@ -0,0 +1,331 @@ +/* + Nullsoft Expression Evaluator Library (NS-EEL) + Copyright (C) 1999-2003 Nullsoft, Inc. + + ns-eel-int.h: internal code definition header. + + 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. +*/ + +#ifndef __NS_EELINT_H__ +#define __NS_EELINT_H__ + +#ifdef _WIN32 +#include <windows.h> +#else +#include "../wdltypes.h" +#endif + +#include "ns-eel.h" +#include "ns-eel-addfuncs.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +enum { + + // these ignore fn in opcodes, just use fntype to determine function + FN_MULTIPLY=0, + FN_DIVIDE, + FN_JOIN_STATEMENTS, + FN_DENORMAL_LIKELY, + FN_DENORMAL_UNLIKELY, + FN_ADD, + FN_SUB, + FN_AND, + FN_OR, + FN_UMINUS, + FN_NOT, + FN_NOTNOT, + FN_XOR, + FN_SHL, + FN_SHR, + FN_MOD, + FN_POW, + FN_LT, + FN_GT, + FN_LTE, + FN_GTE, + FN_EQ, + FN_EQ_EXACT, + FN_NE, + FN_NE_EXACT, + FN_LOGICAL_AND, + FN_LOGICAL_OR, + FN_IF_ELSE, + FN_MEMORY, + FN_GMEMORY, + FN_NONCONST_BEGIN, + FN_ASSIGN=FN_NONCONST_BEGIN, + + FN_ADD_OP, + FN_SUB_OP, + FN_MOD_OP, + FN_OR_OP, + FN_AND_OP, + FN_XOR_OP, + FN_DIV_OP, + FN_MUL_OP, + FN_POW_OP, + + FN_WHILE, + FN_LOOP, + + FUNCTYPE_SIMPLEMAX, + + + FUNCTYPE_FUNCTIONTYPEREC=1000, // fn is a functionType * + FUNCTYPE_EELFUNC, // fn is a _codeHandleFunctionRec * +}; + + + +#define YYSTYPE opcodeRec * + +#define NSEEL_CLOSEFACTOR 0.00001 + + +typedef struct opcodeRec opcodeRec; + +typedef struct _codeHandleFunctionRec +{ + struct _codeHandleFunctionRec *next; // main linked list (only used for high level functions) + struct _codeHandleFunctionRec *derivedCopies; // separate linked list, _head being the main function, other copies being derived versions + + void *startptr; // compiled code (may be cleared + recompiled when shared) + opcodeRec *opcodes; + + int startptr_size; // 0=no code. -1 = needs calculation. >0 = size. + int tmpspace_req; + + int num_params; + + int rvMode; // RETURNVALUE_* + int fpStackUsage; // 0-8, usually + int canHaveDenormalOutput; + + // local storage's first items are the parameters, then locals. Note that the opcodes will reference localstorage[] via VARPTRPTR, but + // the values localstorage[x] points are reallocated from context-to-context, if it is a common function. + + // separately allocated list of pointers, the contents of the list should be zeroed on context changes if a common function + // note that when making variations on a function (context), it is shared, but since it is zeroed on context changes, it is context-local + int localstorage_size; + EEL_F **localstorage; + + int isCommonFunction; + int usesNamespaces; + unsigned int parameterAsNamespaceMask; + + char fname[NSEEL_MAX_FUNCSIG_NAME+1]; +} _codeHandleFunctionRec; + +#define LLB_DSIZE (65536-64) +typedef struct _llBlock { + struct _llBlock *next; + int sizeused; + char block[LLB_DSIZE]; +} llBlock; + +typedef struct { + llBlock *blocks, + *blocks_data; + void *workTable; // references a chunk in blocks_data + + void *code; + int code_size; // in case the caller wants to write it out + int code_stats[4]; + + int want_stack; + void *stack; // references a chunk in blocks_data, somewhere within the complete NSEEL_STACK_SIZE aligned at NSEEL_STACK_SIZE + + void *ramPtr; + + int workTable_size; // size (minus padding/extra space) of workTable -- only used if EEL_VALIDATE_WORKTABLE_USE set, but might be handy to have around too + int compile_flags; +} codeHandleType; + +typedef struct +{ + EEL_F *value; + int refcnt; + char isreg; + char str[1]; +} varNameRec; + +typedef struct +{ + void *ptr; + int size, alloc; +} eel_growbuf; +#define EEL_GROWBUF(type) union { eel_growbuf _growbuf; type *_tval; } +#define EEL_GROWBUF_RESIZE(gb, newsz) __growbuf_resize(&(gb)->_growbuf, (newsz)*(int)sizeof((gb)->_tval[0])) // <0 to free, does not realloc down otherwise +#define EEL_GROWBUF_GET(gb) ((gb)->_tval) +#define EEL_GROWBUF_GET_SIZE(gb) ((gb)->_growbuf.size/(int)sizeof((gb)->_tval[0])) + +typedef struct _compileContext +{ + eel_function_table *registered_func_tab; + const char *(*func_check)(const char *fn_name, void *user); // return error message if not permitted + void *func_check_user; + + EEL_GROWBUF(varNameRec *) varNameList; + EEL_F *varValueStore; + int varValueStore_left; + + int errVar,gotEndOfInput; + opcodeRec *result; + char last_error_string[256]; + + void *scanner; + const char *rdbuf_start, *rdbuf, *rdbuf_end; + + llBlock *tmpblocks_head, // used while compiling, and freed after compiling + + *blocks_head, // used while compiling, transferred to code context (these are pages marked as executable) + *blocks_head_data, // used while compiling, transferred to code context + + *pblocks; // persistent blocks, stores data used by varTable_Names, varTable_Values, etc. + + int l_stats[4]; // source bytes, static code bytes, call code bytes, data bytes + int has_used_global_vars; + + _codeHandleFunctionRec *functions_local, *functions_common; + + // state used while generating functions + int optimizeDisableFlags; + int current_compile_flags; + struct opcodeRec *directValueCache; // linked list using fn as next + + int isSharedFunctions; + int isGeneratingCommonFunction; + int function_usesNamespaces; + int function_globalFlag; // set if restrict globals to function_localTable_Names[2] + // [0] is parameter+local symbols (combined space) + // [1] is symbols which get implied "this." if used + // [2] is globals permitted + int function_localTable_Size[3]; // for parameters only + char **function_localTable_Names[3]; // lists of pointers + EEL_F **function_localTable_ValuePtrs; + const char *function_curName; // name of current function + + EEL_F (*onString)(void *caller_this, struct eelStringSegmentRec *list); + EEL_F (*onNamedString)(void *caller_this, const char *name); + + EEL_F *(*getVariable)(void *userctx, const char *name); + void *getVariable_userctx; + + codeHandleType *tmpCodeHandle; + + struct + { + int needfree; + int maxblocks; + double closefact; + EEL_F *blocks[NSEEL_RAM_BLOCKS]; + } ram_state +#ifdef __GNUC__ + __attribute__ ((aligned (8))) +#endif + ; + + void *gram_blocks; + + void *caller_this; +} +compileContext; + +#define NSEEL_NPARAMS_FLAG_CONST 0x80000 +typedef struct functionType { + const char *name; + void *afunc; + void *func_e; + int nParams; + void *replptrs[4]; + NSEEL_PPPROC pProc; +} functionType; + +functionType *nseel_getFunctionByName(compileContext *ctx, const char *name, int *mchk); // sets mchk (if non-NULL) to how far allowed to scan forward for duplicate names + +opcodeRec *nseel_createCompiledValue(compileContext *ctx, EEL_F value); +opcodeRec *nseel_createCompiledValuePtr(compileContext *ctx, EEL_F *addrValue, const char *namestr); + +opcodeRec *nseel_createMoreParametersOpcode(compileContext *ctx, opcodeRec *code1, opcodeRec *code2); +opcodeRec *nseel_createSimpleCompiledFunction(compileContext *ctx, int fn, int np, opcodeRec *code1, opcodeRec *code2); +opcodeRec *nseel_createMemoryAccess(compileContext *ctx, opcodeRec *code1, opcodeRec *code2); +opcodeRec *nseel_createIfElse(compileContext *ctx, opcodeRec *code1, opcodeRec *code2, opcodeRec *code3); +opcodeRec *nseel_createFunctionByName(compileContext *ctx, const char *name, int np, opcodeRec *code1, opcodeRec *code2, opcodeRec *code3); + +// converts a generic identifier (VARPTR) opcode into either an actual variable reference (parmcnt = -1), +// or if parmcnt >= 0, to a function call (see nseel_setCompiledFunctionCallParameters()) +opcodeRec *nseel_resolve_named_symbol(compileContext *ctx, opcodeRec *rec, int parmcnt, int *errOut); + +// sets parameters and calculates parameter count for opcode, and calls nseel_resolve_named_symbol() with the right +// parameter count +opcodeRec *nseel_setCompiledFunctionCallParameters(compileContext *ctx, opcodeRec *fn, opcodeRec *code1, opcodeRec *code2, opcodeRec *code3, opcodeRec *postCode, int *errOut); +// errOut will be set if return NULL: +// -1 if postCode set when not wanted (i.e. not while()) +// 0 if func not found, +// 1 if function requires 2+ parameters but was given more +// 2 if function needs more parameters +// 4 if function requires 1 parameter but was given more + + + +struct eelStringSegmentRec *nseel_createStringSegmentRec(compileContext *ctx, const char *str, int len); +opcodeRec *nseel_eelMakeOpcodeFromStringSegments(compileContext *ctx, struct eelStringSegmentRec *rec); + +EEL_F *nseel_int_register_var(compileContext *ctx, const char *name, int isReg, const char **namePtrOut); +_codeHandleFunctionRec *eel_createFunctionNamespacedInstance(compileContext *ctx, _codeHandleFunctionRec *fr, const char *nameptr); + +typedef struct nseel_globalVarItem +{ + EEL_F data; + struct nseel_globalVarItem *_next; + char name[1]; // varlen, does not include _global. prefix +} nseel_globalVarItem; + +extern nseel_globalVarItem *nseel_globalreg_list; // if NSEEL_EEL1_COMPAT_MODE, must use NSEEL_getglobalregs() for regxx values + +#include "y.tab.h" + +// nseel_simple_tokenizer will return comments as tokens if state is non-NULL +const char *nseel_simple_tokenizer(const char **ptr, const char *endptr, int *lenOut, int *state); +int nseel_filter_escaped_string(char *outbuf, int outbuf_sz, const char *rdptr, size_t rdptr_size, char delim_char); // returns length used, minus NUL char + +opcodeRec *nseel_translate(compileContext *ctx, const char *tmp, size_t tmplen); // tmplen=0 for nul-term +int nseel_lookup(compileContext *ctx, opcodeRec **opOut, const char *sname); + +EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAlloc(EEL_F **blocks, unsigned int w); +EEL_F * NSEEL_CGEN_CALL __NSEEL_RAMAllocGMEM(EEL_F ***blocks, unsigned int w); +EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemSet(EEL_F **blocks,EEL_F *dest, EEL_F *v, EEL_F *lenptr); +EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemFree(void *blocks, EEL_F *which); +EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemTop(void *blocks, EEL_F *which); +EEL_F * NSEEL_CGEN_CALL __NSEEL_RAM_MemCpy(EEL_F **blocks,EEL_F *dest, EEL_F *src, EEL_F *lenptr); +EEL_F NSEEL_CGEN_CALL __NSEEL_RAM_Mem_SetValues(EEL_F **blocks, INT_PTR np, EEL_F **parms); +EEL_F NSEEL_CGEN_CALL __NSEEL_RAM_Mem_GetValues(EEL_F **blocks, INT_PTR np, EEL_F **parms); + +extern EEL_F nseel_ramalloc_onfail; // address returned by __NSEEL_RAMAlloc et al on failure +extern EEL_F * volatile nseel_gmembuf_default; // can free/zero this on DLL unload if needed + +#ifdef __cplusplus +} +#endif + + +#endif//__NS_EELINT_H__ |