NeoFlock/noom
7
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

get owned

Browse Source
This commit is contained in:
IonutParau
2026-06-18 22:38:01 +02:00
parent 3e1d0ba5d9
commit 2d043ca39f
7 changed files with 156 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/compiler.h
View File

@@ -5,7 +5,7 @@
typedef struct noomC_Local {
unsigned int startpc;
unsigned int endpc;
const char *name;
const char* name;
unsigned int namelen;
unsigned int stackslot;
noom_bool_t dropped;
@@ -14,7 +14,7 @@ typedef struct noomC_Local {
} noomC_Local;
typedef struct noomC_Upval {
const char *name;
const char* name;
unsigned int namelen;
unsigned short slot;
// if stolen, this means that slot is actually an upvalue index
@@ -27,8 +27,8 @@ typedef struct noomC_Upval {
typedef struct noomC_Compiler {
// steal constants from this
struct noomC_Compiler *parent;
noomV_Function *target;
struct noomC_Compiler* parent;
noomV_Function* target;
unsigned localc;
unsigned upvalc;
unsigned curstack;
@@ -39,4 +39,4 @@ typedef struct noomC_Compiler {
void noomC_compiler_init(noomC_Compiler* compiler);
// pushes the compiled function on the stack, or just crashes lol
noom_Exit noomC_compile(noom_LuaVM *vm, const noomP_Parser *parser, const noomP_Node *node, noomV_String *chunkname, noomV_Table *env);
noom_Exit noomC_compile(noom_LuaVM* vm, const noomP_Parser* parser, const noomP_Node* node, noomV_String* chunkname, noomV_Table* env);

6
src/helper.h
View File

@@ -4,10 +4,10 @@
int noom_startswith(const char* str, const char* compare);
int noom_memeq(const char* stra, noom_uint_t lena, const char* strb, noom_uint_t lenb);
noom_uint_t noom_strlen(const char *s);
int noom_strcmp(const char *a, const char* b);
noom_uint_t noom_strlen(const char* s);
int noom_strcmp(const char* a, const char* b);
void noom_safe_strcpy(char* buffer, noom_uint_t* pos, noom_uint_t buffer_size, const char* src);
char *noom_strndup(const char *s, noom_uint_t len);
char* noom_strndup(const char* s, noom_uint_t len);
void noom_memcpy(void* dst, const void* src, noom_uint_t n);

15
src/lexer.c
View File

@@ -403,15 +403,9 @@ noom_uint_t noomL_getstring(const char* s, noomL_ErrorType* error, noom_LuaVersi
noom_uint_t order = 0;
int succ = 0;
while (s[len] == '=') {
order++;
len++;
}
while (s[len] == '=') order++, len++;
if (s[len] == '[') {
len++;
succ = 1;
}
if (s[len] == '[') len++, succ = 1;
if (succ) { // it is a multi-line string.
while (1) {
@@ -420,10 +414,7 @@ noom_uint_t noomL_getstring(const char* s, noomL_ErrorType* error, noom_LuaVersi
noom_uint_t order2 = 0;
noom_uint_t startp = len; // intentionally after the `]`
while (s[len] == '=') {
order2++;
len++;
}
while (s[len] == '=') order2++, len++;
if (s[len] == ']' && order == order2) { // holy shit it's real
len++;

8
src/lexer.h
View File

@@ -17,7 +17,7 @@ typedef enum noomL_ErrorType {
NOOML_ERROR_NONE = 0,
NOOML_ERROR_UNKNOWN,
NOOML_ERROR_MALFORMED_NUM,
NOOML_ERROR_UNFINISHED_COMMENT,
NOOML_ERROR_UNFINISHED_STRING,
NOOML_ERROR_UNFINISHED_LONG_STRING,
@@ -35,7 +35,6 @@ typedef struct noomL_Token {
noom_uint_t length;
} noomL_Token;
int noomL_isalpha(char c);
int noomL_isnumber(char c);
int noomL_isalphanum(char c);
@@ -46,9 +45,8 @@ int noomL_ishex(char c);
noom_uint_t noomL_getsymbol(const char* s, noom_LuaVersion version);
noom_uint_t noomL_getnumber(const char* s, noomL_ErrorType* error, noom_LuaVersion version);
const char *noomL_formatTokenType(noomL_TokenType token_type);
const char* noomL_formatTokenType(noomL_TokenType token_type);
noomL_ErrorType noomL_lex(const char* s, noom_uint_t start, noomL_Token* token, noom_LuaVersion version); // TODO: add more error data
// UB if syntax error
noom_uint_t noomL_tokenlen(const char *s, noom_uint_t start, noom_LuaVersion version);
noom_uint_t noomL_tokenlen(const char* s, noom_uint_t start, noom_LuaVersion version);

102
src/noom.h
View File

@@ -7,7 +7,7 @@
#define NOOM_VERSION_MAJOR 0
#define NOOM_VERSION_MINOR 0
#define NOOM_VERSION_PATCH 0
#if NOOM_VERSION_PATCH==0
#if NOOM_VERSION_PATCH == 0
#define NOOM_VERSION_FULL NN_XSTR(NOOM_VERSION_MAJOR) "." NN_XSTR(NOOM_VERSION_MINOR)
#else
#define NOOM_VERSION_FULL NN_XSTR(NOOM_VERSION_MAJOR) "." NN_XSTR(NOOM_VERSION_MINOR) "." NN_XSTR(NOOM_VERSION_PATCH)
@@ -140,11 +140,11 @@ typedef enum noom_CoroutineStatus {
typedef struct noom_LuaVM noom_LuaVM;
typedef noom_Exit noom_CFunction(noom_LuaVM *vm);
typedef noom_Exit noom_KFunction(noom_LuaVM *vm, noom_Exit status, void *ctx);
typedef noom_Exit noom_CFunction(noom_LuaVM* vm);
typedef noom_Exit noom_KFunction(noom_LuaVM* vm, noom_Exit status, void* ctx);
noom_LuaVM *noom_createVM(noom_LuaVersion version);
void noom_destroyVM(noom_LuaVM *vm);
noom_LuaVM* noom_createVM(noom_LuaVersion version);
void noom_destroyVM(noom_LuaVM* vm);
// type of a stack slot.
// If negative, its relative to the top where -1 is the top.
@@ -154,57 +154,57 @@ typedef noom_int_t noom_slot_t;
// Push data
noom_Exit noom_pushint(noom_LuaVM *vm, noom_int_t integer);
noom_Exit noom_pushnumber(noom_LuaVM *vm, noom_float_t number);
noom_Exit noom_pushbool(noom_LuaVM *vm, noom_bool_t boolean);
noom_Exit noom_pushstring(noom_LuaVM *vm, const char *s);
noom_Exit noom_pushlstring(noom_LuaVM *vm, const char *s, noom_uint_t len);
noom_Exit noom_createtable(noom_LuaVM *vm, noom_uint_t prealloc);
noom_Exit noom_pushint(noom_LuaVM* vm, noom_int_t integer);
noom_Exit noom_pushnumber(noom_LuaVM* vm, noom_float_t number);
noom_Exit noom_pushbool(noom_LuaVM* vm, noom_bool_t boolean);
noom_Exit noom_pushstring(noom_LuaVM* vm, const char* s);
noom_Exit noom_pushlstring(noom_LuaVM* vm, const char* s, noom_uint_t len);
noom_Exit noom_createtable(noom_LuaVM* vm, noom_uint_t prealloc);
// Push a C closure using the top [upvalues] stackslots as upvalues
noom_Exit noom_pushcclosure(noom_LuaVM *vm, noom_CFunction *f, noom_uint_t upvalues);
noom_Exit noom_pushcclosure(noom_LuaVM* vm, noom_CFunction* f, noom_uint_t upvalues);
#define noom_pushcfunction(vm, f) noom_pushcclosure((vm), (f), 0)
noom_Exit noom_pushuserdata(noom_LuaVM *vm, void *userdata);
noom_Exit noom_pushlightuserdata(noom_LuaVM *vm, void *userdata);
noom_Exit noom_pushuserdata(noom_LuaVM* vm, void* userdata);
noom_Exit noom_pushlightuserdata(noom_LuaVM* vm, void* userdata);
// Pops the top function and pushes a new coroutine with that function being called
noom_Exit noom_pushcoroutine(noom_LuaVM *vm);
noom_Exit noom_pushcoroutine(noom_LuaVM* vm);
// Pushes the error object, if any. If no error, nil is pushed
noom_Exit noom_pusherror(noom_LuaVM *vm);
noom_Exit noom_pusherror(noom_LuaVM* vm);
// Pushes the globals table itself
noom_Exit noom_pushglobals(noom_LuaVM *vm);
noom_Exit noom_pushglobals(noom_LuaVM* vm);
// Pushes the registry itself
noom_Exit noom_pushregistry(noom_LuaVM *vm);
noom_Exit noom_pushregistry(noom_LuaVM* vm);
// Pushes the running coroutine
noom_Exit noom_pushrunning(noom_LuaVM *vm);
noom_Exit noom_pushrunning(noom_LuaVM* vm);
// Stack stuff
// Gets the amount of values on the stack
// Signed because of C math rules, but it cannot be negative and is perfectly safe to cast to unsigned
noom_int_t noom_getstacksize(noom_LuaVM *vm);
noom_int_t noom_getstacksize(noom_LuaVM* vm);
// Sets the stack size, popping or pushing nil as need be.
// Its signed so it gives a stack *underflow* on negative values, instead of a confusing stack overflow
noom_Exit noom_setstacksize(noom_LuaVM *vm, noom_int_t amount);
#define noom_pushnils(vm, x) noom_setstacksize((vm), noom_getstacksize((vm))+(x))
noom_Exit noom_setstacksize(noom_LuaVM* vm, noom_int_t amount);
#define noom_pushnils(vm, x) noom_setstacksize((vm), noom_getstacksize((vm)) + (x))
#define noom_pushnil(vm) noom_pushnils((vm), 1)
#define noom_popn(vm, n) noom_setstacksize((vm), noom_getstacksize((vm)) - (n))
#define noom_pop(vm) noom_popn((vm), 1)
// Marks a stackslot as to-be-closed
noom_Exit noom_markTBC(noom_LuaVM *vm, noom_slot_t slot);
noom_Exit noom_markTBC(noom_LuaVM* vm, noom_slot_t slot);
// Preallocate stack space to OOM/stack overflow *early*
noom_Exit noom_preallocStack(noom_LuaVM *vm, noom_uint_t amount);
noom_Exit noom_preallocStack(noom_LuaVM* vm, noom_uint_t amount);
// Set the value at [dst] to [src]
noom_Exit noom_copyto(noom_LuaVM *vm, noom_slot_t dst, noom_slot_t src);
noom_Exit noom_copyto(noom_LuaVM* vm, noom_slot_t dst, noom_slot_t src);
// Set the value at [dst] to be a pointer to [src].
// This is used to link upvalues.
// This means that writes to either are reflected in both.
noom_Exit noom_linkto(noom_LuaVM *vm, noom_slot_t dst, noom_slot_t src);
noom_Exit noom_linkto(noom_LuaVM* vm, noom_slot_t dst, noom_slot_t src);
// Stack rotation
noom_Exit noom_rotate(noom_LuaVM *vm, noom_int_t amount);
noom_Exit noom_rotate(noom_LuaVM* vm, noom_int_t amount);
// Operations
// Dupes the top [n] values [m] times
noom_Exit noom_dupearr(noom_LuaVM *vm, noom_uint_t n, noom_uint_t m);
noom_Exit noom_dupearr(noom_LuaVM* vm, noom_uint_t n, noom_uint_t m);
#define noom_dupen(vm, n) noom_dupearr((vm), 1, (n))
#define noom_dupe(vm) noom_dupen((vm), 1)
@@ -215,82 +215,82 @@ noom_Exit noom_dupearr(noom_LuaVM *vm, noom_uint_t n, noom_uint_t m);
// This will pop argc+1 values, where the first one, at [-argc-1], is the value being called, and everything after is arguments.
// [retc] is the desired return count. It is signed, as negative values mean to return ALL values, regardless of how many.
// If the function returns too many values, the excess is popped. If it returns too few, nils are pushed.
noom_Exit noom_callk(noom_LuaVM *vm, noom_uint_t argc, noom_int_t retc, noom_KFunction *f, void *ctx);
noom_Exit noom_callk(noom_LuaVM* vm, noom_uint_t argc, noom_int_t retc, noom_KFunction* f, void* ctx);
#define noom_call(vm, argc, retc) noom_callk((vm), (argc), (retc), 0, 0)
// Sets the return count of the function. Should be the last statement to prevent confusing behavior.
// The actual *values* returned are the top [retc] values on the stack after the function exits.
noom_Exit noom_return(noom_LuaVM *vm, noom_uint_t retc);
noom_Exit noom_return(noom_LuaVM* vm, noom_uint_t retc);
// Attempts to yield the current coroutine with the top [n] values and a supplied continuation function.
// If the continuation function's memory address is 0, it is replaced with a default function which
// does nothing and returns no values.
// When the coroutine is resumed, the continuation function is invoked.
noom_Exit noom_yieldk(noom_LuaVM *vm, noom_uint_t n, noom_KFunction *f, void *ctx);
noom_Exit noom_yieldk(noom_LuaVM* vm, noom_uint_t n, noom_KFunction* f, void* ctx);
#define noom_yield(vm, n) noom_yieldk((vm), (n), 0, 0)
// Like a noom_call, except instead of calling, it resumes coroutines.
// This cannot yield but allows yields.
noom_Exit noom_resume(noom_LuaVM *vm, noom_uint_t argc, noom_uint_t retc);
noom_Exit noom_resume(noom_LuaVM* vm, noom_uint_t argc, noom_uint_t retc);
// Pops a coroutine, gives its status through the out-pointer
noom_Exit noom_corostatus(noom_LuaVM *vm, noom_CoroutineStatus *status);
noom_Exit noom_corostatus(noom_LuaVM* vm, noom_CoroutineStatus* status);
// Pops a coroutine, closes it.
// This means it'll unwind the callstack of the coroutine and call to-be-closed values as needed.
// If those error, which can happen, this errors as well.
noom_Exit noom_coroclose(noom_LuaVM *vm);
noom_Exit noom_coroclose(noom_LuaVM* vm);
// Get the type of a slot. Invalid slots are just [nil]
noom_LuaType noom_typeof(noom_LuaVM *vm, noom_slot_t x);
noom_LuaType noom_typeof(noom_LuaVM* vm, noom_slot_t x);
// TODO: evaluate if k variants of these should be used, as
// these *could* yield due to metatables
// Pops the top 2 values and pushes the result of the operation
noom_Exit noom_binop(noom_LuaVM *vm, noom_BinOp op);
noom_Exit noom_binop(noom_LuaVM* vm, noom_BinOp op);
// Pops the top 2 values and pushes the result of the operation
noom_Exit noom_unaryop(noom_LuaVM *vm, noom_UnaryOp op);
noom_Exit noom_unaryop(noom_LuaVM* vm, noom_UnaryOp op);
// Pops (table, key) and pushes `table[key]`
noom_Exit noom_gettable(noom_LuaVM *vm);
noom_Exit noom_gettable(noom_LuaVM* vm);
// Pops (table, key, value) and sets `table[key] = value`
noom_Exit noom_settable(noom_LuaVM *vm);
noom_Exit noom_settable(noom_LuaVM* vm);
// Gets the metatable. This gets the actual metatable, __metatable is ignored
noom_Exit noom_getmetatable(noom_LuaVM *vm);
noom_Exit noom_getmetatable(noom_LuaVM* vm);
// Pops (table, metatable) and sets the metatable of [table] to [metatable]
noom_Exit noom_setmetatable(noom_LuaVM *vm);
noom_Exit noom_setmetatable(noom_LuaVM* vm);
// Given stack values (table, key), it pops key and pushes the next key as well as `table[nkey]`.
// If key is nil, the next key is actually the first key of the table, as nil cannot be a key.
// This lets you iterate stuff with like `pairs`.
// This DOES NOT account for __pairs.
noom_Exit noom_next(noom_LuaVM *vm);
noom_Exit noom_next(noom_LuaVM* vm);
// Taking data out
noom_Exit noom_tobool(noom_LuaVM *vm, noom_slot_t x, noom_bool_t *b);
noom_Exit noom_toint(noom_LuaVM *vm, noom_slot_t x, noom_int_t *n);
noom_Exit noom_tonumber(noom_LuaVM *vm, noom_slot_t x, noom_float_t *n);
noom_Exit noom_tobool(noom_LuaVM* vm, noom_slot_t x, noom_bool_t* b);
noom_Exit noom_toint(noom_LuaVM* vm, noom_slot_t x, noom_int_t* n);
noom_Exit noom_tonumber(noom_LuaVM* vm, noom_slot_t x, noom_float_t* n);
// NOTE: the string is not automatically retained until function exit.
// KEEP THE VALUE SOMEWHERE OR GC MAY FREE IT.
noom_Exit noom_tolstring(noom_LuaVM *vm, noom_slot_t x, const char **s, noom_uint_t *len);
noom_Exit noom_tolstring(noom_LuaVM* vm, noom_slot_t x, const char** s, noom_uint_t* len);
#define noom_tostring(vm, x, s) noom_tolstring((vm), (x), (s), 0)
// Casts to a pointer if applicable, memory address 0x0 if not.
// The pointer is effectively meaningless, and only really matters
// for the %p format specifier in `string.format()`
noom_Exit noom_topointer(noom_LuaVM *vm, noom_slot_t x, const void **p);
noom_Exit noom_topointer(noom_LuaVM* vm, noom_slot_t x, const void** p);
// Type coercion
// Converts the value at [x] to a boolean
noom_Exit noom_cast2truthy(noom_LuaVM *vm, noom_slot_t x);
noom_Exit noom_cast2truthy(noom_LuaVM* vm, noom_slot_t x);
// Converts the value at [x] to a number
noom_Exit noom_cast2num(noom_LuaVM *vm, noom_slot_t x);
noom_Exit noom_cast2num(noom_LuaVM* vm, noom_slot_t x);
// Converts the value at [x] to a string, ignoring __tostring and __name.
noom_Exit noom_cast2str(noom_LuaVM *vm, noom_slot_t x);
noom_Exit noom_cast2str(noom_LuaVM* vm, noom_slot_t x);
// Misc
// Run the garbage collector to clean up memory.
// DO NOT RUN IN THE ALLOCATOR IF ANY IS SUPPLIED, OR YOU WILL GET THE WORST POSSIBLE ERRORS.
void noom_gc(noom_LuaVM *vm);
void noom_gc(noom_LuaVM* vm);
#ifdef __cplusplus
}

13
src/parser.h
View File

@@ -3,9 +3,9 @@
typedef enum noomP_NodeType {
NOOMP_NODE_PROGRAM,
NOOMP_NODE_VARNAME,
NOOMP_NODE_LOCALDECLARATION,
NOOMP_NODE_IFSTATEMENT,
NOOMP_NODE_WHILELOOP,
@@ -18,7 +18,7 @@ typedef enum noomP_NodeType {
NOOMP_NODE_ATTRIBUTE,
NOOMP_NODE_BREAK,
NOOMP_NODE_VARIABLE,
NOOMP_NODE_NUMBERLITERAL,
NOOMP_NODE_BOOLEANLITERAL,
@@ -129,7 +129,7 @@ typedef struct noomP_Node {
noomP_NodeType type;
noom_uint_t source_offset;
noom_uint_t subnodec;
noom_uint_t subnode_cap;
struct noomP_Node** subnodes;
@@ -139,7 +139,7 @@ typedef struct noomP_Node {
typedef struct noomP_Parser { // todo: track location in code with line/column?
noom_LuaVersion version;
const char* code;
const char* filename;
noom_uint_t last_token_offset;
@@ -152,7 +152,7 @@ typedef struct noomP_Parser { // todo: track location in code with line/column?
noomP_Node* last_node;
} noomP_Parser;
const char *noomP_formatNodeType(noomP_NodeType node_type);
const char* noomP_formatNodeType(noomP_NodeType node_type);
int noomP_peek(noomP_Parser* parser, noomL_Token* token);
void noomP_skip(noomP_Parser* parser, noomL_Token* token);
@@ -168,4 +168,3 @@ noomP_Node* noomP_parseStatement(noomP_Parser* parser);
int noomP_parse(const char* code, const char* filename, noom_LuaVersion version, noomP_Node** outpointer, noomP_Parser* parser);
int noomP_initParser(noomP_Parser* parser, const char* code, const char* filename, noom_LuaVersion version);

170
src/vm.h
View File

@@ -8,7 +8,7 @@
#endif
#ifndef NOOM_MAXCALL
#define NOOM_MAXCALL (NOOM_MAXSTACK/32)
#define NOOM_MAXCALL (NOOM_MAXSTACK / 32)
#endif
// Defines values, threads, bullshit, idc
@@ -25,8 +25,8 @@ typedef enum noomV_ObjTag {
typedef struct noomV_Object {
noomV_ObjTag tag;
noom_bool_t marked;
struct noomV_Object *next;
struct noomV_Object *nextGray;
struct noomV_Object* next;
struct noomV_Object* nextGray;
} noomV_Object;
typedef enum noomV_ValueTag : unsigned char {
@@ -49,9 +49,9 @@ typedef struct noomV_Value {
noom_bool_t boolean;
noom_int_t integer;
noom_float_t number;
void *lightuserdata;
noomV_Object *obj;
struct noomV_Pointer *ptr;
void* lightuserdata;
noomV_Object* obj;
struct noomV_Pointer* ptr;
};
} noomV_Value;
@@ -64,7 +64,7 @@ typedef struct noomV_String {
typedef struct noomV_Table {
noomV_Object obj;
struct noomV_Table *meta;
struct noomV_Table* meta;
// amount of entries allocated
noom_uint_t entries;
// how many entries are defined.
@@ -74,7 +74,7 @@ typedef struct noomV_Table {
noom_uint_t len;
// actual values. Given index i, V[i] is the key and V[i+entries] is the value.
// This is because we mostly read the key, so we should put more keys in cache.
noomV_Value *entrydata;
noomV_Value* entrydata;
} noomV_Table;
typedef struct noomV_Pointer {
@@ -109,7 +109,7 @@ typedef enum noomV_Opcode : unsigned char {
NOOMV_INSTR_PUSHCLOSURE,
// High-level ops
// Call the function stored at stack[op.a]. All values after that are treated at arguments. op.uD is the expected return count plus one, and if op.uD is 0,
// all returns are pushed.
NOOMV_INSTR_CALL,
@@ -142,7 +142,7 @@ typedef enum noomV_Opcode : unsigned char {
NOOMV_INSTR_SETGLOBAL,
// Control flow
// returns from a function. The amount returned is from op.uD
NOOMV_INSTR_RET,
@@ -188,14 +188,14 @@ typedef struct noomV_Inst {
} noomV_Inst;
typedef struct noomV_UpvalDesc {
char *name;
char* name;
unsigned char idx;
// whether the index is a stack index
noom_bool_t isStack;
} noomV_UpvalDesc;
typedef struct noomV_LocalDesc {
char *name;
char* name;
unsigned char stackIdx;
// to forbid changing it with debug.setlocal
noom_bool_t isConst;
@@ -208,78 +208,78 @@ typedef struct noomV_LocalDesc {
typedef struct noomV_Function {
noomV_Object obj;
// source location string
noomV_String *chunkname;
noomV_String* chunkname;
// globals. Lua 5.1 only, use the _ENV upvalue for Lua 5.2+
noomV_Table *env;
noomV_Inst *code;
noomV_Value *consts;
struct noomV_Function **protos;
noomV_UpvalDesc *upvals;
noomV_LocalDesc *locals;
noomV_Table* env;
noomV_Inst* code;
noomV_Value* consts;
struct noomV_Function** protos;
noomV_UpvalDesc* upvals;
noomV_LocalDesc* locals;
unsigned int codesize;
// line of function
unsigned int linedefined;
// line of end
unsigned int lastlinedefined;
// very size limited
// ░░░░░░░░░ ░ ▒░░▒ ▒░ ░░ ░
// ░░░░░░░░░ ░ ▒░░▒ ▒░ ░░ ░
// ░░░░░░░░░ █░█░▓▓ ░█▒████▒░ █░░████▓
// ░░░░░░░░░ ▓████████░█░▒████▓░████ ░█░
// ░░░░░░░░░ ░░░ ░█▓░█▒█░█░▒▒█▓████▒ ░█▒█ ░█░░
// ░░░░░░░░░ ░░░░░ ░█▓▓███▒█ ▓▓▒▒▒▓▓▒ ▒█▒█▓██▓▓
// ░░░░░░░░░ ░░ ░▓▓███▓█▒░░█▒▓█▓██▓ ▒▓█▓▓▓█▒▒
// ░░░░░░░░░░ ░░ ▒▓█░█▒█░ ░▓▓██████░░██░░▒█
// ░░░░░░░░░░ ░░░░ ░░ ▓▓█▒█▓█▒░ ▒▒▒█▒░█░ ███░░█
// ░░░░░░░░░░ ░░ ▓▒▓███░█▒ ▒░░░▓▓█░░██░▓▒██
// ░░░░░░░░░░ ░░ ░ ░░ ░░ ░░ ░░ ▒░ ░░░ ░░
// ░░░░░░░░░░ ░ ░░░ ░ ░ ░ ░
// ░░░░░░░░░░ ░░░░ ░░ ░
// ░ ░░░░░░░░░ ░░░░ ░ ░ ░ ░░ ░░░ ░░░ ░ ░░
// ░░░░░░░░░ ░ █████ ▒████ ░▓███▓░ ░████░ ░████▓ ░████░ ░▓███▓ ░████░
//░░ ░░░░░░░░░ █▓▒██░░██▓██▒░░██▒██░░██▒▓██░▒██▒██ ██▓▓██ ░██▒██░ ██▒▓██
//░░ ░░░░░░░░░░ ██░▒█▓ ░██░██▒ ▒█▒░██ ░██ ██░ ▓█▒░██ ░██░██░ ▓█▒░██ ██░
// ░░░░░░░░░░░ ░▓███░▒█▓ ██░██░ ▒██▒██ ░██░██ ▒█▒░██ ░██░██░ ▒█▓▒█▓ ░██░
// ░░░░░░░░░░ ░ ░▒███░ ▓████░▓█▒ ░██░██░ ▒██▒█▓ ░██░██ ░▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
// ░░░░░░░░░ ░░ ░ ░░██▓▓█▓░░██ ██░ ▒█▓▒█▓ ██░██░ ▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
// ░░░░░░░░░░ ░░░░ ░ ░███▒██ ░██ ██▒ ▓█▒▒██ ░██░██░ ██░░██░░██ ██▒ ▓█░░██ ░██
// ░░░░░░░░░ ░░░ ░█████▒░█████▒▒▓█████ ░█████▒ ▒█████▓██████▓ ▒██▓██░ █████▒
// ░░░░░░░░░ ░░ ░████▒ ░░███▒░█▒▒███░ ░███▓ ▓███░▓█░███▓░ ▒███░ ░███▒
// ░░░░░░░░░░ ░█░ ░ ░ ▒▒ ░
// ░░░░░░░░░ ░ ░
// ░░░░░░░░░ ░░░░
// ░░░░░░░░░ ░░░░░ ░░ ░ ░ ░ ░
// ░░░░░░░░░ ░░ ░░▒░░ ░▓▒ ░█▓ ░ ░ ░
// ░░░░░░░░░ ░░ ▒█████░ ░██ ░██ ░ ░
// ░░░░░░░░░░░░░ ██▒▒███ ░░ ░ ░ ░░ ░░ ░██
// ░ ░░░░░░░░░░░░░░░ ██░ ░▓▓ ░████ ░████░░█▓ ▒███▓░░██
// ░░░░░░░░░░░░░░░░░░░░░▓███░░ ░██████░██▓██▓▒██░██▓██▒▒██░
// ░░░░░░░░░░░░░░░░░░░░ ░████░░█▓ ██░██ ▓▓░██ ░░▒██▓▒██░ ░
// ░░░░░░░░░░░░░░░░░░░ ░░░░███▒█▓ ██▒██ ░░██░█████▓▒██░ ░░ ░
// ░░░░░░░░░░░░░░░░░░ ░██▒ ░██▒██░░██░██ ░█▓░██░██░▓█▓░██░ ░ ██▓████████▓▒██▒
// ░░░░░░░░░░░░░░░░░ ░██████▓ █████▓ █████▓▒██░█████▓░██░ ░ ░░░███████████▓█▓
// ░░░░░░░░░░░░░░░░░░ ░▓███▒ ░███▒ ░▓██▓ ░█▓ ▒██▓█▓░██░ ░████████████▓█░
// ░░░░░░░░░░░░░░░░░ ░ ░ ░█████████▓██
// ░░░░░░░░░░░░░░ ░░ ▒███████▓█▓
// ░ ░░░░░░░░░░░░░░ ░░░░ ██▓██▓▓▓███ ░
// ░░░░░░░░░░░░░░░ ░░ ░ ░███████████
// ░░░░░░░░░░░░ ░░ ░ ████████████ ▒
// ░░░░░░░░░░░░ ░░▒▒░░ ░ ░██░▓█░ ░ ░░████ ▒██████ █
// ░░░░░░░░░░ ░░ ▒▓█░█▒█░ ░▓▓██████░░██░░▒█
// ░░░░░░░░░░ ░░░░ ░░ ▓▓█▒█▓█▒░ ▒▒▒█▒░█░ ███░░█
// ░░░░░░░░░░ ░░ ▓▒▓███░█▒ ▒░░░▓▓█░░██░▓▒██
// ░░░░░░░░░░ ░░ ░ ░░ ░░ ░░ ░░ ▒░ ░░░ ░░
// ░░░░░░░░░░ ░ ░░░ ░ ░ ░ ░
// ░░░░░░░░░░ ░░░░ ░░ ░
// ░ ░░░░░░░░░ ░░░░ ░ ░ ░ ░░ ░░░ ░░░ ░ ░░
// ░░░░░░░░░ ░ █████ ▒████ ░▓███▓░ ░████░ ░████▓ ░████░ ░▓███▓ ░████░
// ░░ ░░░░░░░░░ █▓▒██░░██▓██▒░░██▒██░░██▒▓██░▒██▒██ ██▓▓██ ░██▒██░ ██▒▓██
// ░░ ░░░░░░░░░░ ██░▒█▓ ░██░██▒ ▒█▒░██ ░██ ██░ ▓█▒░██ ░██░██░ ▓█▒░██ ██░
// ░░░░░░░░░░░ ░▓███░▒█▓ ██░██░ ▒██▒██ ░██░██ ▒█▒░██ ░██░██░ ▒█▓▒█▓ ░██░
// ░░░░░░░░░░ ░ ░▒███░ ▓████░▓█▒ ░██░██░ ▒██▒█▓ ░██░██ ░▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
// ░░░░░░░░░ ░░ ░ ░░██▓▓█▓░░██ ██░ ▒█▓▒█▓ ██░██░ ▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
// ░░░░░░░░░░ ░░░░ ░ ░███▒██ ░██ ██▒ ▓█▒▒██ ░██░██░ ██░░██░░██ ██▒ ▓█░░██ ░██
// ░░░░░░░░░ ░░░ ░█████▒░█████▒▒▓█████ ░█████▒ ▒█████▓██████▓ ▒██▓██░ █████▒
// ░░░░░░░░░ ░░ ░████▒ ░░███▒░█▒▒███░ ░███▓ ▓███░▓█░███▓░ ▒███░ ░███▒
// ░░░░░░░░░░ ░█░ ░ ░ ▒▒ ░
// ░░░░░░░░░ ░ ░
// ░░░░░░░░░ ░░░░
// ░░░░░░░░░ ░░░░░ ░░ ░ ░ ░ ░
// ░░░░░░░░░ ░░ ░░▒░░ ░▓▒ ░█▓ ░ ░ ░
// ░░░░░░░░░ ░░ ▒█████░ ░██ ░██ ░ ░
// ░░░░░░░░░░░░░ ██▒▒███ ░░ ░ ░ ░░ ░░ ░██
// ░ ░░░░░░░░░░░░░░░ ██░ ░▓▓ ░████ ░████░░█▓ ▒███▓░░██
// ░░░░░░░░░░░░░░░░░░░░░▓███░░ ░██████░██▓██▓▒██░██▓██▒▒██░
// ░░░░░░░░░░░░░░░░░░░░ ░████░░█▓ ██░██ ▓▓░██ ░░▒██▓▒██░ ░
// ░░░░░░░░░░░░░░░░░░░ ░░░░███▒█▓ ██▒██ ░░██░█████▓▒██░ ░░ ░
// ░░░░░░░░░░░░░░░░░░ ░██▒ ░██▒██░░██░██ ░█▓░██░██░▓█▓░██░ ░ ██▓████████▓▒██▒
// ░░░░░░░░░░░░░░░░░ ░██████▓ █████▓ █████▓▒██░█████▓░██░ ░ ░░░███████████▓█▓
// ░░░░░░░░░░░░░░░░░░ ░▓███▒ ░███▒ ░▓██▓ ░█▓ ▒██▓█▓░██░ ░████████████▓█░
// ░░░░░░░░░░░░░░░░░ ░ ░ ░█████████▓██
// ░░░░░░░░░░░░░░ ░░ ▒███████▓█▓
// ░ ░░░░░░░░░░░░░░ ░░░░ ██▓██▓▓▓███ ░
// ░░░░░░░░░░░░░░░ ░░ ░ ░███████████
// ░░░░░░░░░░░░ ░░ ░ ████████████ ▒
// ░░░░░░░░░░░░ ░░▒▒░░ ░ ░██░▓█░ ░ ░░████ ▒██████ █
// ░░░░░░░░░░░ ▓█████░ ░██ ██░░█▓░ ▓████ ▓█████ ░█ ▒▒
// ░░░░░░░░░░░ ▒██░░██▒░░░░░ ░░░░░ ░░░░██ ░░░██░ █████ ▒█████ ▒█ ▒█░
// ░░░░░░░░░░░░░ ██▒ ░█▓░████░████░ ░█████ ██▒████ █████ ▓████▒ ████░
// ░░░░░░░░░░░░░ ██▒ ░█▓░████░████░ ░█████ ██▒████ █████ ▓████▒ ████░
// ░░░░░░░░░░░░ ██░ ▒███▓██▓▓██ ██▒▒██ ██░▒██░ ████▒ █████ ▒████████
// ░░░░░░░░░░ ██░ ░ ▒██░ ██▒▒██░██ ░██ ██ ░██░ ░████ ░█████ ▓██▓▒░░
// ░░░░░░░░░░ ██▒ ░▒░▒██ ░██████▒██ ░██░██░░██ ▒███▒ █████▒
// ░ ░░░░░░░░░ ▓█▓░ ▓█▓▒██ ░██░ ░░░██ ░██ ██░░██░ ░███░░░█████
// ░░░░░░░░░ ██████ ▒█▓ ▓█████ ██████ ██░░███░ ░██▒ █████▒
// ░░░░░░░░░ ░▓███░░░█▓ ░░▒███░░░██▓█▓ ▓█░ ▒█▓░ ▓▓ ░█████
// ░░░░░░░░░ ░░░░ ░░ ░░ ░ ░ ▓▒ ▓████░
// ░░░░░░░░ ░░ ░░ ░ ▒▓ ████▒
// ░ ░░░░░ ░ ░ ▒░▓███▒
// ░░░░ ░ ░▓▓██
// ░░░
// ░░░
// ░░
// ░░░░░░░░░░ ██▒ ░▒░▒██ ░██████▒██ ░██░██░░██ ▒███▒ █████▒
// ░ ░░░░░░░░░ ▓█▓░ ▓█▓▒██ ░██░ ░░░██ ░██ ██░░██░ ░███░░░█████
// ░░░░░░░░░ ██████ ▒█▓ ▓█████ ██████ ██░░███░ ░██▒ █████▒
// ░░░░░░░░░ ░▓███░░░█▓ ░░▒███░░░██▓█▓ ▓█░ ▒█▓░ ▓▓ ░█████
// ░░░░░░░░░ ░░░░ ░░ ░░ ░ ░ ▓▒ ▓████░
// ░░░░░░░░ ░░ ░░ ░ ▒▓ ████▒
// ░ ░░░░░ ░ ░ ▒░▓███▒
// ░░░░ ░ ░▓▓██
// ░░░
// ░░░
// ░░
unsigned char argc;
unsigned char flags;
unsigned short constsize;
@@ -294,14 +294,14 @@ typedef struct noomV_CallFrame {
noom_bool_t isC;
union {
struct {
//
//
unsigned int pc;
// amount of varargs
unsigned int varargc;
} lua;
struct {
noom_KFunction *resumeFunc;
void *resumeCtx;
noom_KFunction* resumeFunc;
void* resumeCtx;
} c;
};
} noomV_CallFrame;
@@ -311,26 +311,26 @@ typedef struct noomV_Thread {
unsigned int stacklen, calldepth;
unsigned int stackcap, callcap;
// can have pointers!
noomV_Value *stack;
noomV_CallFrame *calls;
struct noomV_Thread *resumedBy;
struct noomV_Thread *resuming;
noomV_Value* stack;
noomV_CallFrame* calls;
struct noomV_Thread* resumedBy;
struct noomV_Thread* resuming;
} noomV_Thread;
struct noom_LuaVM {
noomV_Object *heap;
noomV_Object *graySet;
noomV_Table *globals;
noomV_Table *registry;
noomV_Thread *mainThread;
noomV_Thread *currentThread;
noomV_Object* heap;
noomV_Object* graySet;
noomV_Table* globals;
noomV_Table* registry;
noomV_Thread* mainThread;
noomV_Thread* currentThread;
noom_LuaVersion version;
};
// Allocating objects
noomV_Object *noomV_allocObj(noom_LuaVM *vm, noomV_ObjTag tag, noom_uint_t size);
noomV_String *noomV_allocStr(noom_LuaVM *vm, const char *str, noom_uint_t len);
noomV_Function *noomV_allocFunc(noom_LuaVM *vm, noomV_String *chunkname);
void noomV_freeObj(noomV_Object *obj);
noomV_Object* noomV_allocObj(noom_LuaVM* vm, noomV_ObjTag tag, noom_uint_t size);
noomV_String* noomV_allocStr(noom_LuaVM* vm, const char* str, noom_uint_t len);
noomV_Function* noomV_allocFunc(noom_LuaVM* vm, noomV_String* chunkname);
void noomV_freeObj(noomV_Object* obj);
#endif