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++;

6
src/lexer.h
View File

@@ -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
}

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_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);

70
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 {
@@ -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,14 +208,14 @@ 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;
@@ -236,8 +236,8 @@ typedef struct noomV_Function {
// ░░░░░░░░░░ ░░░░ ░░ ░
// ░ ░░░░░░░░░ ░░░░ ░ ░ ░ ░░ ░░░ ░░░ ░ ░░
// ░░░░░░░░░ ░ █████ ▒████ ░▓███▓░ ░████░ ░████▓ ░████░ ░▓███▓ ░████░
//░░ ░░░░░░░░░ █▓▒██░░██▓██▒░░██▒██░░██▒▓██░▒██▒██ ██▓▓██ ░██▒██░ ██▒▓██
//░░ ░░░░░░░░░░ ██░▒█▓ ░██░██▒ ▒█▒░██ ░██ ██░ ▓█▒░██ ░██░██░ ▓█▒░██ ██░
// ░░ ░░░░░░░░░ █▓▒██░░██▓██▒░░██▒██░░██▒▓██░▒██▒██ ██▓▓██ ░██▒██░ ██▒▓██
// ░░ ░░░░░░░░░░ ██░▒█▓ ░██░██▒ ▒█▒░██ ░██ ██░ ▓█▒░██ ░██░██░ ▓█▒░██ ██░
// ░░░░░░░░░░░ ░▓███░▒█▓ ██░██░ ▒██▒██ ░██░██ ▒█▒░██ ░██░██░ ▒█▓▒█▓ ░██░
// ░░░░░░░░░░ ░ ░▒███░ ▓████░▓█▒ ░██░██░ ▒██▒█▓ ░██░██ ░▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
// ░░░░░░░░░ ░░ ░ ░░██▓▓█▓░░██ ██░ ▒█▓▒█▓ ██░██░ ▒█▒░██ ░██░██░ ░██▒█▓ ░██░░
@@ -300,8 +300,8 @@ typedef struct noomV_CallFrame {
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