tema5002/noom
1
0
Fork 0
forked from NeoFlock/noom
Code Pull Requests 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 { typedef struct noomC_Local {
unsigned int startpc; unsigned int startpc;
unsigned int endpc; unsigned int endpc;
const char *name; const char* name;
unsigned int namelen; unsigned int namelen;
unsigned int stackslot; unsigned int stackslot;
noom_bool_t dropped; noom_bool_t dropped;
@@ -14,7 +14,7 @@ typedef struct noomC_Local {
} noomC_Local; } noomC_Local;
typedef struct noomC_Upval { typedef struct noomC_Upval {
const char *name; const char* name;
unsigned int namelen; unsigned int namelen;
unsigned short slot; unsigned short slot;
// if stolen, this means that slot is actually an upvalue index // if stolen, this means that slot is actually an upvalue index
@@ -27,8 +27,8 @@ typedef struct noomC_Upval {
typedef struct noomC_Compiler { typedef struct noomC_Compiler {
// steal constants from this // steal constants from this
struct noomC_Compiler *parent; struct noomC_Compiler* parent;
noomV_Function *target; noomV_Function* target;
unsigned localc; unsigned localc;
unsigned upvalc; unsigned upvalc;
unsigned curstack; unsigned curstack;
@@ -39,4 +39,4 @@ typedef struct noomC_Compiler {
void noomC_compiler_init(noomC_Compiler* compiler); void noomC_compiler_init(noomC_Compiler* compiler);
// pushes the compiled function on the stack, or just crashes lol // 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_startswith(const char* str, const char* compare);
int noom_memeq(const char* stra, noom_uint_t lena, const char* strb, noom_uint_t lenb); 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); noom_uint_t noom_strlen(const char* s);
int noom_strcmp(const char *a, const char* b); 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); 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); 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; noom_uint_t order = 0;
int succ = 0; int succ = 0;
while (s[len] == '=') { while (s[len] == '=') order++, len++;
order++;
len++;
}
if (s[len] == '[') { if (s[len] == '[') len++, succ = 1;
len++;
succ = 1;
}
if (succ) { // it is a multi-line string. if (succ) { // it is a multi-line string.
while (1) { 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 order2 = 0;
noom_uint_t startp = len; // intentionally after the `]` noom_uint_t startp = len; // intentionally after the `]`
while (s[len] == '=') { while (s[len] == '=') order2++, len++;
order2++;
len++;
}
if (s[len] == ']' && order == order2) { // holy shit it's real if (s[len] == ']' && order == order2) { // holy shit it's real
len++; len++;

6
src/lexer.h
View File

@@ -35,7 +35,6 @@ typedef struct noomL_Token {
noom_uint_t length; noom_uint_t length;
} noomL_Token; } noomL_Token;
int noomL_isalpha(char c); int noomL_isalpha(char c);
int noomL_isnumber(char c); int noomL_isnumber(char c);
int noomL_isalphanum(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_getsymbol(const char* s, noom_LuaVersion version);
noom_uint_t noomL_getnumber(const char* s, noomL_ErrorType* error, 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 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 // 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_MAJOR 0
#define NOOM_VERSION_MINOR 0 #define NOOM_VERSION_MINOR 0
#define NOOM_VERSION_PATCH 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) #define NOOM_VERSION_FULL NN_XSTR(NOOM_VERSION_MAJOR) "." NN_XSTR(NOOM_VERSION_MINOR)
#else #else
#define NOOM_VERSION_FULL NN_XSTR(NOOM_VERSION_MAJOR) "." NN_XSTR(NOOM_VERSION_MINOR) "." NN_XSTR(NOOM_VERSION_PATCH) #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 struct noom_LuaVM noom_LuaVM;
typedef noom_Exit noom_CFunction(noom_LuaVM *vm); 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_KFunction(noom_LuaVM* vm, noom_Exit status, void* ctx);
noom_LuaVM *noom_createVM(noom_LuaVersion version); noom_LuaVM* noom_createVM(noom_LuaVersion version);
void noom_destroyVM(noom_LuaVM *vm); void noom_destroyVM(noom_LuaVM* vm);
// type of a stack slot. // type of a stack slot.
// If negative, its relative to the top where -1 is the top. // 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 // Push data
noom_Exit noom_pushint(noom_LuaVM *vm, noom_int_t integer); 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_pushnumber(noom_LuaVM* vm, noom_float_t number);
noom_Exit noom_pushbool(noom_LuaVM *vm, noom_bool_t boolean); noom_Exit noom_pushbool(noom_LuaVM* vm, noom_bool_t boolean);
noom_Exit noom_pushstring(noom_LuaVM *vm, const char *s); 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_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_createtable(noom_LuaVM* vm, noom_uint_t prealloc);
// Push a C closure using the top [upvalues] stackslots as upvalues // 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) #define noom_pushcfunction(vm, f) noom_pushcclosure((vm), (f), 0)
noom_Exit noom_pushuserdata(noom_LuaVM *vm, void *userdata); noom_Exit noom_pushuserdata(noom_LuaVM* vm, void* userdata);
noom_Exit noom_pushlightuserdata(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 // 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 // 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 // Pushes the globals table itself
noom_Exit noom_pushglobals(noom_LuaVM *vm); noom_Exit noom_pushglobals(noom_LuaVM* vm);
// Pushes the registry itself // Pushes the registry itself
noom_Exit noom_pushregistry(noom_LuaVM *vm); noom_Exit noom_pushregistry(noom_LuaVM* vm);
// Pushes the running coroutine // Pushes the running coroutine
noom_Exit noom_pushrunning(noom_LuaVM *vm); noom_Exit noom_pushrunning(noom_LuaVM* vm);
// Stack stuff // Stack stuff
// Gets the amount of values on the stack // 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 // 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. // 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 // 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); 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_pushnils(vm, x) noom_setstacksize((vm), noom_getstacksize((vm)) + (x))
#define noom_pushnil(vm) noom_pushnils((vm), 1) #define noom_pushnil(vm) noom_pushnils((vm), 1)
#define noom_popn(vm, n) noom_setstacksize((vm), noom_getstacksize((vm)) - (n)) #define noom_popn(vm, n) noom_setstacksize((vm), noom_getstacksize((vm)) - (n))
#define noom_pop(vm) noom_popn((vm), 1) #define noom_pop(vm) noom_popn((vm), 1)
// Marks a stackslot as to-be-closed // 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* // 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] // 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]. // Set the value at [dst] to be a pointer to [src].
// This is used to link upvalues. // This is used to link upvalues.
// This means that writes to either are reflected in both. // 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 // 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 // Operations
// Dupes the top [n] values [m] times // 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_dupen(vm, n) noom_dupearr((vm), 1, (n))
#define noom_dupe(vm) noom_dupen((vm), 1) #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. // 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. // [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. // 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) #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. // 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. // 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. // 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 // If the continuation function's memory address is 0, it is replaced with a default function which
// does nothing and returns no values. // does nothing and returns no values.
// When the coroutine is resumed, the continuation function is invoked. // 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) #define noom_yield(vm, n) noom_yieldk((vm), (n), 0, 0)
// Like a noom_call, except instead of calling, it resumes coroutines. // Like a noom_call, except instead of calling, it resumes coroutines.
// This cannot yield but allows yields. // 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 // 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. // Pops a coroutine, closes it.
// This means it'll unwind the callstack of the coroutine and call to-be-closed values as needed. // 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. // 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] // 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 // TODO: evaluate if k variants of these should be used, as
// these *could* yield due to metatables // these *could* yield due to metatables
// Pops the top 2 values and pushes the result of the operation // 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 // 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]` // 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` // 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 // 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] // 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]`. // 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. // 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 lets you iterate stuff with like `pairs`.
// This DOES NOT account for __pairs. // This DOES NOT account for __pairs.
noom_Exit noom_next(noom_LuaVM *vm); noom_Exit noom_next(noom_LuaVM* vm);
// Taking data out // Taking data out
noom_Exit noom_tobool(noom_LuaVM *vm, noom_slot_t x, noom_bool_t *b); 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_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_tonumber(noom_LuaVM* vm, noom_slot_t x, noom_float_t* n);
// NOTE: the string is not automatically retained until function exit. // NOTE: the string is not automatically retained until function exit.
// KEEP THE VALUE SOMEWHERE OR GC MAY FREE IT. // 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) #define noom_tostring(vm, x, s) noom_tolstring((vm), (x), (s), 0)
// Casts to a pointer if applicable, memory address 0x0 if not. // Casts to a pointer if applicable, memory address 0x0 if not.
// The pointer is effectively meaningless, and only really matters // The pointer is effectively meaningless, and only really matters
// for the %p format specifier in `string.format()` // 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 // Type coercion
// Converts the value at [x] to a boolean // 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 // 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. // 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 // Misc
// Run the garbage collector to clean up memory. // 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. // 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 #ifdef __cplusplus
} }

3
src/parser.h
View File

@@ -152,7 +152,7 @@ typedef struct noomP_Parser { // todo: track location in code with line/column?
noomP_Node* last_node; noomP_Node* last_node;
} noomP_Parser; } 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); int noomP_peek(noomP_Parser* parser, noomL_Token* token);
void noomP_skip(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_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); int noomP_initParser(noomP_Parser* parser, const char* code, const char* filename, noom_LuaVersion version);

70
src/vm.h
View File

@@ -8,7 +8,7 @@
#endif #endif
#ifndef NOOM_MAXCALL #ifndef NOOM_MAXCALL
#define NOOM_MAXCALL (NOOM_MAXSTACK/32) #define NOOM_MAXCALL (NOOM_MAXSTACK / 32)
#endif #endif
// Defines values, threads, bullshit, idc // Defines values, threads, bullshit, idc
@@ -25,8 +25,8 @@ typedef enum noomV_ObjTag {
typedef struct noomV_Object { typedef struct noomV_Object {
noomV_ObjTag tag; noomV_ObjTag tag;
noom_bool_t marked; noom_bool_t marked;
struct noomV_Object *next; struct noomV_Object* next;
struct noomV_Object *nextGray; struct noomV_Object* nextGray;
} noomV_Object; } noomV_Object;
typedef enum noomV_ValueTag : unsigned char { typedef enum noomV_ValueTag : unsigned char {
@@ -49,9 +49,9 @@ typedef struct noomV_Value {
noom_bool_t boolean; noom_bool_t boolean;
noom_int_t integer; noom_int_t integer;
noom_float_t number; noom_float_t number;
void *lightuserdata; void* lightuserdata;
noomV_Object *obj; noomV_Object* obj;
struct noomV_Pointer *ptr; struct noomV_Pointer* ptr;
}; };
} noomV_Value; } noomV_Value;
@@ -64,7 +64,7 @@ typedef struct noomV_String {
typedef struct noomV_Table { typedef struct noomV_Table {
noomV_Object obj; noomV_Object obj;
struct noomV_Table *meta; struct noomV_Table* meta;
// amount of entries allocated // amount of entries allocated
noom_uint_t entries; noom_uint_t entries;
// how many entries are defined. // how many entries are defined.
@@ -74,7 +74,7 @@ typedef struct noomV_Table {
noom_uint_t len; noom_uint_t len;
// actual values. Given index i, V[i] is the key and V[i+entries] is the value. // 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. // This is because we mostly read the key, so we should put more keys in cache.
noomV_Value *entrydata; noomV_Value* entrydata;
} noomV_Table; } noomV_Table;
typedef struct noomV_Pointer { typedef struct noomV_Pointer {
@@ -188,14 +188,14 @@ typedef struct noomV_Inst {
} noomV_Inst; } noomV_Inst;
typedef struct noomV_UpvalDesc { typedef struct noomV_UpvalDesc {
char *name; char* name;
unsigned char idx; unsigned char idx;
// whether the index is a stack index // whether the index is a stack index
noom_bool_t isStack; noom_bool_t isStack;
} noomV_UpvalDesc; } noomV_UpvalDesc;
typedef struct noomV_LocalDesc { typedef struct noomV_LocalDesc {
char *name; char* name;
unsigned char stackIdx; unsigned char stackIdx;
// to forbid changing it with debug.setlocal // to forbid changing it with debug.setlocal
noom_bool_t isConst; noom_bool_t isConst;
@@ -208,14 +208,14 @@ typedef struct noomV_LocalDesc {
typedef struct noomV_Function { typedef struct noomV_Function {
noomV_Object obj; noomV_Object obj;
// source location string // source location string
noomV_String *chunkname; noomV_String* chunkname;
// globals. Lua 5.1 only, use the _ENV upvalue for Lua 5.2+ // globals. Lua 5.1 only, use the _ENV upvalue for Lua 5.2+
noomV_Table *env; noomV_Table* env;
noomV_Inst *code; noomV_Inst* code;
noomV_Value *consts; noomV_Value* consts;
struct noomV_Function **protos; struct noomV_Function** protos;
noomV_UpvalDesc *upvals; noomV_UpvalDesc* upvals;
noomV_LocalDesc *locals; noomV_LocalDesc* locals;
unsigned int codesize; unsigned int codesize;
// line of function // line of function
unsigned int linedefined; unsigned int linedefined;
@@ -236,8 +236,8 @@ typedef struct noomV_Function {
// ░░░░░░░░░░ ░░░░ ░░ ░ // ░░░░░░░░░░ ░░░░ ░░ ░
// ░ ░░░░░░░░░ ░░░░ ░ ░ ░ ░░ ░░░ ░░░ ░ ░░ // ░ ░░░░░░░░░ ░░░░ ░ ░ ░ ░░ ░░░ ░░░ ░ ░░
// ░░░░░░░░░ ░ █████ ▒████ ░▓███▓░ ░████░ ░████▓ ░████░ ░▓███▓ ░████░ // ░░░░░░░░░ ░ █████ ▒████ ░▓███▓░ ░████░ ░████▓ ░████░ ░▓███▓ ░████░
//░░ ░░░░░░░░░ █▓▒██░░██▓██▒░░██▒██░░██▒▓██░▒██▒██ ██▓▓██ ░██▒██░ ██▒▓██ // ░░ ░░░░░░░░░ █▓▒██░░██▓██▒░░██▒██░░██▒▓██░▒██▒██ ██▓▓██ ░██▒██░ ██▒▓██
//░░ ░░░░░░░░░░ ██░▒█▓ ░██░██▒ ▒█▒░██ ░██ ██░ ▓█▒░██ ░██░██░ ▓█▒░██ ██░ // ░░ ░░░░░░░░░░ ██░▒█▓ ░██░██▒ ▒█▒░██ ░██ ██░ ▓█▒░██ ░██░██░ ▓█▒░██ ██░
// ░░░░░░░░░░░ ░▓███░▒█▓ ██░██░ ▒██▒██ ░██░██ ▒█▒░██ ░██░██░ ▒█▓▒█▓ ░██░ // ░░░░░░░░░░░ ░▓███░▒█▓ ██░██░ ▒██▒██ ░██░██ ▒█▒░██ ░██░██░ ▒█▓▒█▓ ░██░
// ░░░░░░░░░░ ░ ░▒███░ ▓████░▓█▒ ░██░██░ ▒██▒█▓ ░██░██ ░▒█▒░██ ░██░██░ ░██▒█▓ ░██░░ // ░░░░░░░░░░ ░ ░▒███░ ▓████░▓█▒ ░██░██░ ▒██▒█▓ ░██░██ ░▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
// ░░░░░░░░░ ░░ ░ ░░██▓▓█▓░░██ ██░ ▒█▓▒█▓ ██░██░ ▒█▒░██ ░██░██░ ░██▒█▓ ░██░░ // ░░░░░░░░░ ░░ ░ ░░██▓▓█▓░░██ ██░ ▒█▓▒█▓ ██░██░ ▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
@@ -300,8 +300,8 @@ typedef struct noomV_CallFrame {
unsigned int varargc; unsigned int varargc;
} lua; } lua;
struct { struct {
noom_KFunction *resumeFunc; noom_KFunction* resumeFunc;
void *resumeCtx; void* resumeCtx;
} c; } c;
}; };
} noomV_CallFrame; } noomV_CallFrame;
@@ -311,26 +311,26 @@ typedef struct noomV_Thread {
unsigned int stacklen, calldepth; unsigned int stacklen, calldepth;
unsigned int stackcap, callcap; unsigned int stackcap, callcap;
// can have pointers! // can have pointers!
noomV_Value *stack; noomV_Value* stack;
noomV_CallFrame *calls; noomV_CallFrame* calls;
struct noomV_Thread *resumedBy; struct noomV_Thread* resumedBy;
struct noomV_Thread *resuming; struct noomV_Thread* resuming;
} noomV_Thread; } noomV_Thread;
struct noom_LuaVM { struct noom_LuaVM {
noomV_Object *heap; noomV_Object* heap;
noomV_Object *graySet; noomV_Object* graySet;
noomV_Table *globals; noomV_Table* globals;
noomV_Table *registry; noomV_Table* registry;
noomV_Thread *mainThread; noomV_Thread* mainThread;
noomV_Thread *currentThread; noomV_Thread* currentThread;
noom_LuaVersion version; noom_LuaVersion version;
}; };
// Allocating objects // Allocating objects
noomV_Object *noomV_allocObj(noom_LuaVM *vm, noomV_ObjTag tag, noom_uint_t size); 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_String* noomV_allocStr(noom_LuaVM* vm, const char* str, noom_uint_t len);
noomV_Function *noomV_allocFunc(noom_LuaVM *vm, noomV_String *chunkname); noomV_Function* noomV_allocFunc(noom_LuaVM* vm, noomV_String* chunkname);
void noomV_freeObj(noomV_Object *obj); void noomV_freeObj(noomV_Object* obj);
#endif #endif