diff --git a/src/compiler.h b/src/compiler.h index d500edc..14171e1 100644 --- a/src/compiler.h +++ b/src/compiler.h @@ -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); diff --git a/src/helper.h b/src/helper.h index 38374db..91f19f2 100644 --- a/src/helper.h +++ b/src/helper.h @@ -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); diff --git a/src/lexer.c b/src/lexer.c index 12e4b99..cfe27e7 100644 --- a/src/lexer.c +++ b/src/lexer.c @@ -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++; diff --git a/src/lexer.h b/src/lexer.h index 6a77982..466b519 100644 --- a/src/lexer.h +++ b/src/lexer.h @@ -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); diff --git a/src/noom.h b/src/noom.h index e362319..bb3619b 100644 --- a/src/noom.h +++ b/src/noom.h @@ -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 } diff --git a/src/parser.h b/src/parser.h index 49bb476..0f896de 100644 --- a/src/parser.h +++ b/src/parser.h @@ -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); - diff --git a/src/vm.h b/src/vm.h index 035de37..d7d0171 100644 --- a/src/vm.h +++ b/src/vm.h @@ -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