From 5ff0594791982168696f84fe6169a876aa8c5030 Mon Sep 17 00:00:00 2001 From: tema5002 Date: Mon, 8 Jun 2026 22:13:05 +0200 Subject: [PATCH] compiler: basic code in place + all: rename streql to memeq Reviewed-on: https://gitea.codersquack.nl/NeoFlock/noom/pulls/5 Co-authored-by: tema5002 Co-committed-by: tema5002 --- build.zig | 1 + shitass.lua | 1 - src/compiler.c | 281 +++++++++++++++++++++++++++++++++++++++++++++++++ src/compiler.h | 12 ++- src/helper.c | 26 ++++- src/helper.h | 7 +- src/lexer.c | 44 ++++---- src/main.c | 3 + src/noom.h | 4 + src/parser.c | 248 +++++++++++++++++++++---------------------- 10 files changed, 473 insertions(+), 154 deletions(-) delete mode 100644 shitass.lua diff --git a/build.zig b/build.zig index fde3e22..a43cdb6 100644 --- a/build.zig +++ b/build.zig @@ -22,6 +22,7 @@ pub fn build(b: *std.Build) void { "src/parser.c", "src/compiler.c", "src/vm.c", + "src/error.c", "src/main.c", } }); diff --git a/shitass.lua b/shitass.lua deleted file mode 100644 index b671a20..0000000 --- a/shitass.lua +++ /dev/null @@ -1 +0,0 @@ -local t = {6; 2} diff --git a/src/compiler.c b/src/compiler.c index e69de29..ed94304 100644 --- a/src/compiler.c +++ b/src/compiler.c @@ -0,0 +1,281 @@ +#include "noom.h" +#include "compiler.h" +#include "helper.h" + +// COMPILATION!!!!!!!!!!!!!!!!!!! +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣴⢲⣞⣭⣟⣿⣻⣷⢶⢦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⣤⣞⣵⢯⣿⣞⣷⣿⣷⣿⣿⣿⣿⣜⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⣤⣶⢿⣾⣽⣿⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⣯⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⡤⢿⣿⣿⣿⣿⣯⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⢫⡀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⢆⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣯⡗⡇⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⢠⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⢰⣾⣿⣿⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡑⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠋⠉⠀⠀⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡷⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠻⠿⢿⣿⠟⠛⠛⠻⣿⣿⣿⣿⡿⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣿⣇⠀⠀⠀⠉⢿⡟⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⠀⠀⠀⠀⣼⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠁⠀⠀⠀⢨⣿⡷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⠀⣿⠿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⡀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⢼⣿⣧⡴⢤⣶⡴⢻⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠘⠛⠿⠻⠷⠾⠶⠷⠾⠶⡷⣿⣿⣀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⣀⠴⠮⠃⠉⠛⢷⣦⣠⡄⠀⣸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⣠⠶⠘⠁⠀⠀⠀⠀⠀⠙⢮⡿⣧⢾⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⣤⠓⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣈⣽⡿⢿⣤⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢀⣠⣠⣴⣮⠾⠟⠋⠉⢹⠌⠈⠙⠻⢷⣶⣤⣤⣀⡀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠙⠛⠛⠉⠁⠀⠀⠀⠀⠀⠀⡘⠂⠀⠀⠀⠀⠈⠉⠛⠛⠻⠿⠷⠦ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡘⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ + +void noomC_compiler_init(noomC_Compiler *compiler) { + compiler->parent = 0; // who is bro 😂✌️🥀 + + compiler->localc = 0; + compiler->localcap = 0; + compiler->locals = 0; + + compiler->constidx = 0; + compiler->constc = 0; + compiler->constcap = 0; +} + +noomV_String *noomV_String_alloc(noom_LuaVM *vm, const char *str, const noom_uint_t len) { + noomV_String *s = (noomV_String*)noomV_allocObj(vm, NOOMV_OSTR, sizeof(noomV_String) + len + 1); + if (s == 0) return 0; + noom_memcpy(s->data, str, len); + s->data[len] = '\0'; + return s; +} + +noomV_Function *noomV_Function_alloc(noom_LuaVM *vm, const char *str, const noom_uint_t len) { + noomV_Function *f = (noomV_Function*)noomV_allocObj(vm, NOOMV_OFUNC, sizeof(noomV_Function)); + if (f == 0) return 0; + f->chunkname = noomV_String_alloc(vm, str, len); + if (f->chunkname == 0) return 0; + f->code = 0; + f->consts = 0; + f->protos = 0; + f->upvals = 0; + f->locals = 0; + f->codesize = 0; + f->linedefined = 0; + f->lastlinedefined = 0; + f->argc = 0; + f->flags = 0; + f->constsize = 0; + f->protosize = 0; + f->upvalsize = 0; + f->localsize = 0; + return f; +} + +noomV_Table *noomV_Table_alloc(noom_LuaVM *vm) { + noomV_Table *t = (noomV_Table *)noomV_allocObj(vm, NOOMV_OTABLE, sizeof(noomV_Table)); + if (t == 0) return 0; + t->meta = 0; + t->entries = 0; + t->used = 0; + t->len = 0; + t->entrydata = 0; + return t; +} + +static noom_Exit noomC_emit(noomV_Function *func, const noomV_Inst inst) { + func->code = noom_realloc(func->code, sizeof(noomV_Inst) * (func->codesize + 1)); + if (func->code == 0) return NOOM_ENOMEM; + func->code[func->codesize++] = inst; + return NOOM_OK; +} + +static noom_Exit noomC_emit_Aus(noomV_Function *func, const noomV_Opcode op, const unsigned char a, const unsigned short us) { + return noomC_emit(func, (noomV_Inst){.op = op, .a = a, .us = us}); +} + +static noom_Exit noomC_addconst(noomV_Function *func, const noomV_Value val) { + if (func->constsize == NOOM_USHORT_MAX) return NOOM_PLEASEHELPMEIAMSCARED; + func->consts = noom_realloc(func->consts, sizeof(noomV_Value) * (func->constsize + 1)); + if (func->consts == 0) return NOOM_ENOMEM; + func->consts[func->constsize++] = val; + return NOOM_OK; +} + +static noom_Exit noomC_addconst_nil(noomV_Function *func) { + return noomC_addconst(func, (noomV_Value){.tag = NOOMV_VNIL, .autoclose = 0, .isptr = 0}); +} + +static noom_Exit noomC_addconst_bool(noomV_Function *func, const noom_bool_t b) { + return noomC_addconst(func, (noomV_Value){.tag = NOOMV_VBOOL, .autoclose = 0, .isptr = 0, .boolean = b}); +} + +static noomL_Token noomC_token_at(const noomP_Parser *parser, noom_uint_t offset) { + noomL_Token token; + noomL_lex(parser->code, offset, &token, parser->version); + return token; +} + +static noom_Exit noomC_compile_expr(noom_LuaVM *vm, const noomC_Compiler *compiler, const noomP_Parser *parser, noomV_Function *func, const noomP_Node *node) { + if (node->type == NOOMP_NODE_NILLITERAL) { + noom_Exit result = noomC_addconst_nil(func); + if (result != NOOM_OK) return result; + result = noomC_emit_Aus(func, NOOMV_INSTR_LOADC, compiler->curstack, func->constsize - 1); + if (result != NOOM_OK) return result; + return NOOM_OK; + } + if (node->type == NOOMP_NODE_BOOLEANLITERAL) { + noomL_Token bool_token = noomC_token_at(parser, node->source_offset); + noom_bool_t val = noom_memeq(parser->code + bool_token.offset, bool_token.length, "true", 4); + noom_Exit result = noomC_addconst_bool(func, val); + if (result != NOOM_OK) return result; + result = noomC_emit_Aus(func, NOOMV_INSTR_LOADC, compiler->curstack, func->constsize - 1); + if (result != NOOM_OK) return result; + return NOOM_OK; + } + if (node->type == NOOMP_NODE_NUMBERLITERAL) { + return NOOM_PLEASEHELPMEIAMSCARED; // 😭😭😭😭😭😭😭😭 + } + if (node->type == NOOMP_NODE_STRINGLITERAL) { + return NOOM_IAMNOTSCAREDJUSTLAZYTHISTIME; + } + return NOOM_EINTERNAL; // Idk what else I forgot +} + +static noom_Exit noomC_add_stuff_to_function(noom_LuaVM *vm, noomC_Compiler *compiler, const noomP_Parser *parser, noomV_Function *func, const noomP_Node *node); + +static noom_Exit noomC_compile_block(noom_LuaVM *vm, noomC_Compiler *compiler, const noomP_Parser *parser, noomV_Function *func, const noomP_Node *node) { + noom_Exit r = NOOM_OK; + for (noom_uint_t i = 0; i < node->subnodec; i++) { + r = noomC_add_stuff_to_function(vm, compiler, parser, func, node->subnodes[i]); + if (r != NOOM_OK) break; + } + return r; +} + +// They say you use only 10% of your brain +// Keep it +// If you think too much you will get headaches + +// I remember atom said there is a memory leak somewhere but I don't rememeememember where uhhhhhhhhhhhhhhhhh +static noom_Exit noomC_add_stuff_to_function(noom_LuaVM *vm, noomC_Compiler *compiler, const noomP_Parser *parser, noomV_Function *func, const noomP_Node *node) { + // local name = expression i think + if (node->type == NOOMP_NODE_LOCALDECLARATION) { + if (node->subnodec != 1 && node->subnodec != 2) return NOOM_EINTERNAL; + + const noomP_Node *varname_node = node->subnodes[0]; + if (varname_node->type != NOOMP_NODE_ASSIGNPLACE) return NOOM_EINTERNAL; + + noomC_Local local; + local.startpc = func->codesize; + local.endpc = 0; + local.dropped = 0; // FIXME? + local.close = 0; + local.constant = 0; + local.name = noom_strndup(parser->code + varname_node->source_offset, varname_node->source_offset); + + for (noom_uint_t i = 0; i < varname_node->subnodec; i++) { + if (varname_node->subnodes[i]->type != NOOMP_NODE_ATTRIBUTE) return NOOM_EINTERNAL; + + noomL_Token attr_token = noomC_token_at(parser, varname_node->subnodes[i]->source_offset); + const char *ap = parser->code + attr_token.offset; + noom_uint_t al = attr_token.length; + if (noom_memeq(ap, al, "close", 5)) { + if (local.close) return NOOM_EINTERNAL; + local.close = 1; + } + else if (noom_memeq(ap, al, "const", 5)) { + if (local.constant) return NOOM_EINTERNAL; + local.constant = 1; + } + else { + return NOOM_EINTERNAL; + } + } + + const unsigned destination = compiler->curstack; + if (compiler->curstack++ == NOOM_MAXSTACK) return NOOM_ENOSTACK; + + if (node->subnodec == 1) { + // according to atom this should be nil + const unsigned short constptr = func->constsize; + const noom_Exit result = noomC_addconst_nil(func); + if (result != NOOM_OK) return result; + if (noomC_emit_Aus(func, NOOMV_INSTR_LOADC, destination, constptr) < 0) return NOOM_ENOMEM; + } + else { + const noomP_Node *value_node = node->subnodes[1]; + const unsigned saved = compiler->curstack; + compiler->curstack = destination; + const noom_Exit r = noomC_compile_expr(vm, compiler, parser, func, value_node); + if (r != NOOM_OK) return r; + compiler->curstack = saved; + } + + compiler->locals = noom_realloc(compiler->locals, sizeof(noomC_Local) * (compiler->localc + 1)); + if (compiler->locals == 0) return NOOM_ENOMEM; + compiler->locals[compiler->localc++] = local; + // I guess??????? + if (compiler->localc > compiler->localcap) compiler->localcap = compiler->localc; + + return NOOM_OK; + } + + // local function name(...) ... end + if (node->type == NOOMP_NODE_LOCALFUNCTIONDECLARATION) { + if (node->subnodec != 3) return NOOM_EINTERNAL; + // Funny staircase huh + const noomP_Node *varname_node = node->subnodes[0]; + const noomP_Node *params_node = node->subnodes[1]; + const noomP_Node *block_node = node->subnodes[2]; + if (varname_node->type != NOOMP_NODE_VARNAME) return NOOM_EINTERNAL; + if (params_node->type != NOOMP_NODE_FUNCTIONPARAMETERS) return NOOM_EINTERNAL; + if (block_node->type != NOOMP_NODE_BLOCK) return NOOM_EINTERNAL; + + const noomL_Token name_token = noomC_token_at(parser, varname_node->source_offset); + noomV_Function *proto = noomV_Function_alloc(vm, parser->code + name_token.offset, name_token.length); + if (proto == 0) return NOOM_ENOMEM; + + proto->argc = (unsigned char)params_node->subnodec; + + noomC_Compiler child; + noomC_compiler_init(&child); + child.parent = compiler; // Is this correct????? Is this correct????????????????? It probably is + child.curstack = proto->argc; + + const noom_Exit result = noomC_compile_block(vm, &child, parser, proto, block_node); + if (result != NOOM_OK) return result; + + func->protos = noom_realloc(func->protos, sizeof(noomV_Function *) * (func->protosize + 1)); + if (func->protos == 0) return NOOM_ENOMEM; + func->protos[func->protosize++] = proto; + + // I think something should be here but idfk what + // TODO + noomC_emit_Aus(func, NOOMV_INSTR_NOP, 0, 0); + + return NOOM_OK; + } + + // TODO + if (node->type == NOOMP_NODE_RETURN) { + noomC_emit_Aus(func, NOOMV_INSTR_NOP, 0, 0); + return NOOM_OK; + } + + if (node->type == NOOMP_NODE_DOBLOCK || node->type == NOOMP_NODE_BLOCK) { + return noomC_compile_block(vm, compiler, parser, func, node); + } + + return NOOM_EINTERNAL; +} + +noom_Exit noomC_compile(noom_LuaVM *vm, const noomP_Parser *parser, const noomP_Node *node) { + if (node->type != NOOMP_NODE_PROGRAM) return NOOM_EINTERNAL; + + noomV_Function* program = noomV_Function_alloc(vm, "main", 4); + + noomC_Compiler compiler; + noomC_compiler_init(&compiler); + + return noomC_compile_block(vm, &compiler, parser, program, node); +} diff --git a/src/compiler.h b/src/compiler.h index 2070c55..bb366c9 100644 --- a/src/compiler.h +++ b/src/compiler.h @@ -5,10 +5,10 @@ typedef struct noomC_Local { unsigned int startpc; unsigned int endpc; - char *name; - bool dropped; - bool constant; - bool close; + const char *name; + noom_bool_t dropped; + noom_bool_t constant; + noom_bool_t close; } noomC_Local; typedef struct noomC_Compiler { @@ -23,5 +23,7 @@ typedef struct noomC_Compiler { noomC_Local *locals; } 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, noomP_Node *node); +noom_Exit noomC_compile(noom_LuaVM *vm, const noomP_Parser *parser, const noomP_Node *node); diff --git a/src/helper.c b/src/helper.c index dc03e42..64faf6d 100644 --- a/src/helper.c +++ b/src/helper.c @@ -1,4 +1,5 @@ #include "helper.h" + #include "types.h" int noom_startswith(const char* str, const char* compare) { @@ -16,7 +17,7 @@ int noom_startswith(const char* str, const char* compare) { return 0; // unreachable but whatevs } -int noom_streql(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) { if (lena != lenb) return 0; for (noom_uint_t i = 0; i < lena; i++) { @@ -53,6 +54,29 @@ void noom_safe_strcpy(char* buffer, noom_uint_t* pos, noom_uint_t buffer_size, c } } +char *noom_strndup(const char *s, const noom_uint_t len) { + char *whar = noom_alloc(len + 1); + if (whar == 0) return 0; + noom_memcpy(whar, s, len); + whar[len] = '\0'; + return whar; +} + +void noom_memcpy(void* dst, const void* src, noom_uint_t n) { +#ifdef __has_builtin +#if __has_builtin(__builtin_memcpy) + __builtin_memcpy(dst, src, n); + return; +#endif +#endif + unsigned char *d = dst; + const unsigned char *s = src; + + while (n--) { + *d++ = *s++; + } +} + #include // TODO: remove void* noom_alloc(noom_uint_t size) { diff --git a/src/helper.h b/src/helper.h index 614c503..5f50c0a 100644 --- a/src/helper.h +++ b/src/helper.h @@ -1,10 +1,15 @@ #include "types.h" +#define NOOM_USHORT_MAX 0xffff + int noom_startswith(const char* str, const char* compare); -int noom_streql(const char* stra, noom_uint_t lena, const char* strb, noom_uint_t lenb); // rename to something better? +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); 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); + +void noom_memcpy(void* dst, const void* src, noom_uint_t n); void* noom_alloc(noom_uint_t size); void noom_free(void* ptr); diff --git a/src/lexer.c b/src/lexer.c index c1cbd0a..d1c6e22 100644 --- a/src/lexer.c +++ b/src/lexer.c @@ -433,34 +433,34 @@ noom_uint_t noomL_getstring(const char* s, noomL_ErrorType* error, noom_LuaVersi } int noomL_iskeyword(const char* s, noom_uint_t len, noom_LuaVersion version) { - if (noom_streql(s, len, "true", 4)) return 1; - if (noom_streql(s, len, "false", 5)) return 1; - if (noom_streql(s, len, "nil", 3)) return 1; + if (noom_memeq(s, len, "true", 4)) return 1; + if (noom_memeq(s, len, "false", 5)) return 1; + if (noom_memeq(s, len, "nil", 3)) return 1; - if (noom_streql(s, len, "if", 2)) return 1; - if (noom_streql(s, len, "then", 4)) return 1; - if (noom_streql(s, len, "else", 4)) return 1; - if (noom_streql(s, len, "elseif", 6)) return 1; + if (noom_memeq(s, len, "if", 2)) return 1; + if (noom_memeq(s, len, "then", 4)) return 1; + if (noom_memeq(s, len, "else", 4)) return 1; + if (noom_memeq(s, len, "elseif", 6)) return 1; - if (noom_streql(s, len, "and", 3)) return 1; - if (noom_streql(s, len, "or", 2)) return 1; - if (noom_streql(s, len, "not", 3)) return 1; + if (noom_memeq(s, len, "and", 3)) return 1; + if (noom_memeq(s, len, "or", 2)) return 1; + if (noom_memeq(s, len, "not", 3)) return 1; - if (noom_streql(s, len, "local", 5)) return 1; + if (noom_memeq(s, len, "local", 5)) return 1; - if (noom_streql(s, len, "for", 3)) return 1; - if (noom_streql(s, len, "function", 8)) return 1; - if (noom_streql(s, len, "do", 2)) return 1; - if (noom_streql(s, len, "until", 5)) return 1; - if (noom_streql(s, len, "while", 5)) return 1; - if (noom_streql(s, len, "repeat", 6)) return 1; - if (noom_streql(s, len, "end", 3)) return 1; - if (noom_streql(s, len, "in", 2)) return 1; - if (noom_streql(s, len, "return", 6)) return 1; - if (noom_streql(s, len, "break", 5)) return 1; + if (noom_memeq(s, len, "for", 3)) return 1; + if (noom_memeq(s, len, "function", 8)) return 1; + if (noom_memeq(s, len, "do", 2)) return 1; + if (noom_memeq(s, len, "until", 5)) return 1; + if (noom_memeq(s, len, "while", 5)) return 1; + if (noom_memeq(s, len, "repeat", 6)) return 1; + if (noom_memeq(s, len, "end", 3)) return 1; + if (noom_memeq(s, len, "in", 2)) return 1; + if (noom_memeq(s, len, "return", 6)) return 1; + if (noom_memeq(s, len, "break", 5)) return 1; if (version >= NOOM_VERSION_52) { - if (noom_streql(s, len, "goto", 4)) return 1; + if (noom_memeq(s, len, "goto", 4)) return 1; } return 0; diff --git a/src/main.c b/src/main.c index b4706cc..d390f29 100644 --- a/src/main.c +++ b/src/main.c @@ -7,6 +7,9 @@ void tab(noom_uint_t amount) { amount *= 2; for (noom_uint_t i = 0; i < amount; i++) { putchar(' '); + putchar(' '); + putchar(' '); + putchar(' '); } } diff --git a/src/noom.h b/src/noom.h index 157ac92..45dcddb 100644 --- a/src/noom.h +++ b/src/noom.h @@ -38,6 +38,10 @@ typedef enum noom_LuaType { typedef enum noom_Exit { NOOM_OK = 0, + NOOM_PLEASEHELPMEIAMSCARED, + NOOM_IAMNOTSCAREDJUSTLAZYTHISTIME, + // unknown internal error + NOOM_EINTERNAL, NOOM_YIELD, // out of memory NOOM_ENOMEM, diff --git a/src/parser.c b/src/parser.c index 36fcbd3..183bb95 100644 --- a/src/parser.c +++ b/src/parser.c @@ -169,7 +169,7 @@ noomP_Node* noomP_parseTableLiteral(noomP_Parser* parser) { noomL_Token token; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "{", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "{", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_LCURLY; return 0; } @@ -185,14 +185,14 @@ noomP_Node* noomP_parseTableLiteral(noomP_Parser* parser) { while (1) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "}", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "}", 1)) { // noomP_skip(parser, &token); break; } if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "[", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "[", 1)) { noomP_skip(parser, &token); noom_uint_t bloc = token.offset; @@ -200,14 +200,14 @@ noomP_Node* noomP_parseTableLiteral(noomP_Parser* parser) { if (idx == 0) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "]", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "]", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_RBRACKET_AFTER_KEY; return 0; } noomP_skip(parser, &token); if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "=", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "=", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_EQUALS_AFTER_KEY; return 0; } @@ -233,7 +233,7 @@ noomP_Node* noomP_parseTableLiteral(noomP_Parser* parser) { noomP_skip(parser, &token); if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "=", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "=", 1)) { noomP_skip(parser, &token); // conveniently opos is also the thingamajig @@ -274,9 +274,9 @@ noomP_Node* noomP_parseTableLiteral(noomP_Parser* parser) { // check for , if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); - } else if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ";", 1)) { + } else if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ";", 1)) { noomP_skip(parser, &token); } else { break; @@ -284,7 +284,7 @@ noomP_Node* noomP_parseTableLiteral(noomP_Parser* parser) { } if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "}", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "}", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_RCURLY; return 0; } @@ -301,7 +301,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, ".", 1)) { // field + if (noom_memeq(parser->code + token.offset, token.length, ".", 1)) { // field noomP_skip(parser, &token); // skip the . noom_uint_t dotLoc = token.offset; @@ -328,7 +328,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_addSubnode(parser, new, fname)) return 0; node = new; - } else if (noom_streql(parser->code + token.offset, token.length, "[", 1)) { // index + } else if (noom_memeq(parser->code + token.offset, token.length, "[", 1)) { // index noomP_skip(parser, &token); // skip the [ noom_uint_t brackLoc = token.offset; @@ -336,7 +336,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (expr == 0) return 0; if (noomP_peek(parser, &token)) return 0; // look for ] - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, "]", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, "]", 1))) { // damn it :( parser->error_state = NOOMP_ERROR_EXPECTED_RBRACKET_AFTER_INDEX; return 0; @@ -353,7 +353,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_addSubnode(parser, new, expr)) return 0; node = new; - } else if (noom_streql(parser->code + token.offset, token.length, "(", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "(", 1)) { noomP_skip(parser, &token); // bye ( noom_uint_t parenLoc = token.offset; @@ -367,7 +367,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, ")", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, ")", 1))) { while (1) { noomP_Node* expr = noomP_parseExpression(parser); if (expr == 0) return 0; @@ -375,7 +375,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_addSubnode(parser, new, expr)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, ",", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, ",", 1))) { break; } noomP_skip(parser, &token); @@ -384,7 +384,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode // check for ) if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, ")", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, ")", 1))) { parser->error_state = NOOMP_ERROR_EXPECTED_RPAREN_AFTER_EXPRESSION; return 0; } @@ -392,7 +392,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode noomP_skip(parser, &token); node = new; - } else if (noom_streql(parser->code + token.offset, token.length, "{", 1)) { // table call + } else if (noom_memeq(parser->code + token.offset, token.length, "{", 1)) { // table call noomP_Node* new = noomP_allocNode(parser); if (new == 0) return 0; @@ -406,7 +406,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_addSubnode(parser, new, table)) return 0; node = new; - } else if (noom_streql(parser->code + token.offset, token.length, ":", 1)) { // method call + } else if (noom_memeq(parser->code + token.offset, token.length, ":", 1)) { // method call noomP_skip(parser, &token); noom_uint_t sym_loc = token.offset; @@ -432,12 +432,12 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "(", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "(", 1)) { noomP_skip(parser, &token); // new->type = NOOMP_NODE_METHODCALL; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, ")", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, ")", 1))) { while (1) { noomP_Node* expr = noomP_parseExpression(parser); if (expr == 0) return 0; @@ -445,7 +445,7 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode if (noomP_addSubnode(parser, new, expr)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, ",", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, ",", 1))) { break; } noomP_skip(parser, &token); @@ -454,12 +454,12 @@ noomP_Node* noomP_parseComplexExpression(noomP_Parser* parser, noomP_Node* snode // check for ) if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || (!noom_streql(parser->code + token.offset, token.length, ")", 1))) { + if (token.type != NOOML_TOKEN_SYMBOL || (!noom_memeq(parser->code + token.offset, token.length, ")", 1))) { parser->error_state = NOOMP_ERROR_EXPECTED_RPAREN_AFTER_EXPRESSION; return 0; } noomP_skip(parser, &token); - } else if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "{", 1)) { + } else if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "{", 1)) { noomP_Node* table = noomP_parseTableLiteral(parser); if (table == 0) return 0; @@ -541,7 +541,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { return varNode; } else if (token.type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token.offset, token.length, "true", 4)) { + if (noom_memeq(parser->code + token.offset, token.length, "true", 4)) { noomP_skip(parser, &token); noomP_Node* litNode = noomP_allocNode(parser); @@ -551,7 +551,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { litNode->source_offset = token.offset; return litNode; - } else if (noom_streql(parser->code + token.offset, token.length, "false", 5)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "false", 5)) { noomP_skip(parser, &token); noomP_Node* litNode = noomP_allocNode(parser); @@ -561,7 +561,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { litNode->source_offset = token.offset; return litNode; - } else if (noom_streql(parser->code + token.offset, token.length, "nil", 3)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "nil", 3)) { noomP_skip(parser, &token); noomP_Node* litNode = noomP_allocNode(parser); @@ -571,7 +571,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { litNode->source_offset = token.offset; return litNode; - } else if (noom_streql(parser->code + token.offset, token.length, "function", 8)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "function", 8)) { noomP_skip(parser, &token); noomP_Node* funcNode = noomP_allocNode(parser); @@ -589,7 +589,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { if (noomP_addSubnode(parser, funcNode, block)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { return 0; } noomP_skip(parser, &token); @@ -597,7 +597,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { return funcNode; } } else if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, "(", 1)) { // parenthesized + if (noom_memeq(parser->code + token.offset, token.length, "(", 1)) { // parenthesized noomP_skip(parser, &token); noom_uint_t sym_loc = token.offset; @@ -607,7 +607,7 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { // now to close the parentheses if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, ")", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, ")", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_RPAREN_AFTER_EXPRESSION; return 0; // unexpected } @@ -624,12 +624,12 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { // buttt we're not done YET! it could still go :dsg().dsdh():dsh() return noomP_parseComplexExpression(parser, paren); // thank you for being a function :heart: - } else if (noom_streql(parser->code + token.offset, token.length, "{", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "{", 1)) { noomP_Node* table = noomP_parseTableLiteral(parser); if (table == 0) return 0; return table; - } else if (noom_streql(parser->code + token.offset, token.length, "...", 3)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "...", 3)) { noomP_skip(parser, &token); noomP_Node* new = noomP_allocNode(parser); @@ -647,97 +647,97 @@ noomP_Node* noomP_parseRawExpression(noomP_Parser* parser) { int noomP_infixOperatorBP(noomP_Parser* parser, noomL_Token* token, noom_uint_t* a, noom_uint_t* b) { // todo: maybe make this not pointer? we'll see if (token->type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token->offset, token->length, "+", 1)) { + if (noom_memeq(parser->code + token->offset, token->length, "+", 1)) { *a = 90; *b = 100; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "-", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "-", 1)) { *a = 90; *b = 100; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "*", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "*", 1)) { *a = 110; *b = 120; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "/", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "/", 1)) { *a = 110; *b = 120; return 1; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, "//", 2)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, "//", 2)) { *a = 110; *b = 120; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "%", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "%", 1)) { *a = 110; *b = 120; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "^", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "^", 1)) { *a = 140; *b = 130; // right associative return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "..", 2)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "..", 2)) { *a = 80; *b = 70; // right ass. return 1; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, ">>", 2)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, ">>", 2)) { *a = 68; *b = 69; return 1; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, "<<", 2)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, "<<", 2)) { *a = 68; *b = 69; return 1; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, "&", 1)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, "&", 1)) { *a = 66; *b = 67; return 1; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, "~", 1)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, "~", 1)) { *a = 64; *b = 65; return 1; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, "|", 1)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, "|", 1)) { *a = 62; *b = 63; return 1; // oh boy. - } else if (noom_streql(parser->code + token->offset, token->length, "<", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "<", 1)) { *a = 50; *b = 60; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, ">", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, ">", 1)) { *a = 50; *b = 60; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "<=", 2)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "<=", 2)) { *a = 50; *b = 60; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, ">=", 2)) { + } else if (noom_memeq(parser->code + token->offset, token->length, ">=", 2)) { *a = 50; *b = 60; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "~=", 2)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "~=", 2)) { *a = 50; *b = 60; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "==", 2)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "==", 2)) { *a = 50; *b = 60; return 1; } } else if (token->type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token->offset, token->length, "and", 3)) { + if (noom_memeq(parser->code + token->offset, token->length, "and", 3)) { *a = 30; *b = 40; return 1; - } else if (noom_streql(parser->code + token->offset, token->length, "or", 2)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "or", 2)) { *a = 10; *b = 20; return 1; @@ -749,15 +749,15 @@ int noomP_infixOperatorBP(noomP_Parser* parser, noomL_Token* token, noom_uint_t* noom_uint_t noomP_prefixOperatorBP(noomP_Parser* parser, noomL_Token* token) { // todo: maybe make this not pointer? we'll see if (token->type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token->offset, token->length, "-", 1)) { + if (noom_memeq(parser->code + token->offset, token->length, "-", 1)) { return 125; - } else if (noom_streql(parser->code + token->offset, token->length, "#", 1)) { + } else if (noom_memeq(parser->code + token->offset, token->length, "#", 1)) { return 125; - } else if (parser->version >= NOOM_VERSION_53 && noom_streql(parser->code + token->offset, token->length, "~", 1)) { + } else if (parser->version >= NOOM_VERSION_53 && noom_memeq(parser->code + token->offset, token->length, "~", 1)) { return 125; } } else if (token->type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token->offset, token->length, "not", 3)) { + if (noom_memeq(parser->code + token->offset, token->length, "not", 3)) { return 125; } } @@ -843,7 +843,7 @@ noomP_Node* noomP_parseFunctionParameters(noomP_Parser* parser) { noomL_Token token; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "(", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "(", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_LPAREN_FOR_PARAMETERS; return 0; } @@ -870,7 +870,7 @@ noomP_Node* noomP_parseFunctionParameters(noomP_Parser* parser) { var->source_offset = token.offset; if (noomP_addSubnode(parser, params, var)) return 0; - } else if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "...", 3)) { + } else if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "...", 3)) { noomP_skip(parser, &token); noomP_Node* vararg = noomP_allocNode(parser); @@ -886,7 +886,7 @@ noomP_Node* noomP_parseFunctionParameters(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -895,7 +895,7 @@ noomP_Node* noomP_parseFunctionParameters(noomP_Parser* parser) { // closing paren if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, ")", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, ")", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_RPAREN_FOR_PARAMETERS; return 0; } @@ -919,13 +919,13 @@ noomP_Node* noomP_parseBlock(noomP_Parser* parser) { // stops on end, else or el if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (noom_memeq(parser->code + token.offset, token.length, "end", 3)) { break; - } else if (noom_streql(parser->code + token.offset, token.length, "elseif", 6)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "elseif", 6)) { break; - } else if (noom_streql(parser->code + token.offset, token.length, "else", 4)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "else", 4)) { break; - } else if (noom_streql(parser->code + token.offset, token.length, "until", 5)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "until", 5)) { break; } } @@ -944,12 +944,12 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token.offset, token.length, "local", 5)) { + if (noom_memeq(parser->code + token.offset, token.length, "local", 5)) { noomP_skip(parser, &token); if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_KEYWORD && noom_streql(parser->code + token.offset, token.length, "function", 8)) { + if (token.type == NOOML_TOKEN_KEYWORD && noom_memeq(parser->code + token.offset, token.length, "function", 8)) { noomP_skip(parser, &token); noomP_Node* funcNode = noomP_allocNode(parser); @@ -982,7 +982,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, funcNode, block)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { parser->error_state = NOOMP_ERROR_EXPECTED_END_AFTER_LOCAL_FUNCTION; return 0; } @@ -1015,7 +1015,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (parser->version >= NOOM_VERSION_54) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "<", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "<", 1)) { // attribute yay noomP_skip(parser, &token); @@ -1028,13 +1028,13 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { noom_uint_t attr = token.offset; noomP_skip(parser, &token); - if (!noom_streql(parser->code + token.offset, token.length, "const", 5) && !noom_streql(parser->code + token.offset, token.length, "close", 5)) { + if (!noom_memeq(parser->code + token.offset, token.length, "const", 5) && !noom_memeq(parser->code + token.offset, token.length, "close", 5)) { parser->error_state = NOOMP_ERROR_FAKEATTRIBUTE; return 0; // not a real attribute smh my head } if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, ">", 1)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, ">", 1)) { parser->error_state = NOOMP_ERROR_EXPECTED_RANGLE_TO_CLOSE_ATTRIBUTE; return 0; } @@ -1055,7 +1055,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -1069,7 +1069,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { // local with no equals initializes to nil if (token.type != NOOML_TOKEN_SYMBOL) return localNode; - if (!noom_streql(parser->code + token.offset, token.length, "=", 1)) return localNode; + if (!noom_memeq(parser->code + token.offset, token.length, "=", 1)) return localNode; noomP_skip(parser, &token); // equals has already been eaten by loop (thank you loop) @@ -1083,7 +1083,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -1094,7 +1094,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { } return localNode; - } else if (noom_streql(parser->code + token.offset, token.length, "if", 2)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "if", 2)) { noomP_skip(parser, &token); noomP_Node* ifStatement = noomP_allocNode(parser); @@ -1110,7 +1110,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "then", 4)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "then", 4)) { parser->error_state = NOOMP_ERROR_EXPECTED_THEN_AFTER_EXPRESSION; return 0; // unexpected } @@ -1130,7 +1130,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { return 0; // unexpected } - if (noom_streql(parser->code + token.offset, token.length, "elseif", 6)) { + if (noom_memeq(parser->code + token.offset, token.length, "elseif", 6)) { noomP_skip(parser, &token); noomP_Node* elseIfCondition = noomP_parseExpression(parser); if (elseIfCondition == 0) return 0; @@ -1140,7 +1140,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { // now we need to check for "then" if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "then", 4)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "then", 4)) { parser->error_state = NOOMP_ERROR_EXPECTED_THEN_AFTER_EXPRESSION; return 0; // unexpected } @@ -1153,7 +1153,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, ifStatement, elseIfBlock)) return 0; // could be even more - } else if (noom_streql(parser->code + token.offset, token.length, "else", 4)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "else", 4)) { noomP_skip(parser, &token); noomP_Node* elseBlock = noomP_parseBlock(parser); @@ -1163,7 +1163,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, ifStatement, elseBlock)) return 0; break; // this must be the last one; end is handled after the loop - } else if (noom_streql(parser->code + token.offset, token.length, "end", 3)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "end", 3)) { break; // will check for end outside the loop because else and things } else { // unexpected @@ -1173,14 +1173,14 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { } if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { parser->error_state = NOOMP_ERROR_EXPECTED_END_AFTER_IF; return 0; // unexpected } noomP_skip(parser, &token); return ifStatement; - } else if (noom_streql(parser->code + token.offset, token.length, "while", 5)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "while", 5)) { noomP_skip(parser, &token); // skip `while` noomP_Node* node = noomP_allocNode(parser); @@ -1196,7 +1196,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "do", 2)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "do", 2)) { parser->error_state = NOOMP_ERROR_EXPECTED_DO_AFTER_EXPRESSION; return 0; // unexpected } @@ -1208,14 +1208,14 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, node, block)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { parser->error_state = NOOMP_ERROR_EXPECTED_END_AFTER_WHILE; return 0; // unexpected } noomP_skip(parser, &token); // skip `end` return node; - } else if (noom_streql(parser->code + token.offset, token.length, "break", 5)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "break", 5)) { noomP_skip(parser, &token); // skip `break` // uhh yeah that's it i guess? idk. maybe parsers should figure out what loop? @@ -1227,7 +1227,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { node->source_offset = token.offset; return node; - } else if (noom_streql(parser->code + token.offset, token.length, "function", 8)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "function", 8)) { noomP_skip(parser, &token); noomP_Node* func = noomP_allocNode(parser); @@ -1265,7 +1265,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (token.type != NOOML_TOKEN_SYMBOL) return 0; // unexp. - if (noom_streql(parser->code + token.offset, token.length, ".", 1)) { + if (noom_memeq(parser->code + token.offset, token.length, ".", 1)) { // just keep on going at it noomP_skip(parser, &token); @@ -1284,7 +1284,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { new->source_offset = token.offset; if (noomP_addSubnode(parser, fname, new)) return 0; - } else if (noom_streql(parser->code + token.offset, token.length, ":", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, ":", 1)) { noomP_skip(parser, &token); if (noomP_peek(parser, &token)) return 0; @@ -1303,7 +1303,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, fname, new)) return 0; break; // ( checked later. - } else if (noom_streql(parser->code + token.offset, token.length, "(", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "(", 1)) { break; } else { return 0; @@ -1322,14 +1322,14 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { // remove `end` if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { parser->error_state = NOOMP_ERROR_EXPECTED_END_AFTER_FUNCTION; return 0; } noomP_skip(parser, &token); return func; - } else if (noom_streql(parser->code + token.offset, token.length, "return", 6)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "return", 6)) { noomP_skip(parser, &token); noomP_Node* ret = noomP_allocNode(parser); @@ -1346,17 +1346,17 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { int is_empty = 0; if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, ";", 1)) { + if (noom_memeq(parser->code + token.offset, token.length, ";", 1)) { is_empty = 1; } } else if (token.type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (noom_memeq(parser->code + token.offset, token.length, "end", 3)) { is_empty = 1; - } else if (noom_streql(parser->code + token.offset, token.length, "elseif", 6)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "elseif", 6)) { is_empty = 1; - } else if (noom_streql(parser->code + token.offset, token.length, "else", 4)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "else", 4)) { is_empty = 1; - } else if (noom_streql(parser->code + token.offset, token.length, "until", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "until", 1)) { is_empty = 1; } } else if (token.type == NOOML_TOKEN_EOF) { @@ -1372,7 +1372,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -1383,7 +1383,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { while (1) { // remove semis so we can check for ender after. if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ";", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ";", 1)) { noomP_skip(parser, &token); } else { break; @@ -1394,13 +1394,13 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { // now we have to make sure we he have an ender; int is_done = 0; if (token.type == NOOML_TOKEN_KEYWORD) { - if (noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (noom_memeq(parser->code + token.offset, token.length, "end", 3)) { is_done = 1; - } else if (noom_streql(parser->code + token.offset, token.length, "elseif", 6)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "elseif", 6)) { is_done = 1; - } else if (noom_streql(parser->code + token.offset, token.length, "else", 4)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "else", 4)) { is_done = 1; - } else if (noom_streql(parser->code + token.offset, token.length, "until", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "until", 1)) { is_done = 1; } } else if (token.type == NOOML_TOKEN_EOF) { @@ -1413,7 +1413,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { } return ret; - } else if (noom_streql(parser->code + token.offset, token.length, "for", 3)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "for", 3)) { // yay... noomP_skip(parser, &token); @@ -1441,7 +1441,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "=", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "=", 1)) { noomP_skip(parser, &token); // ehhh i'll do a stupid @@ -1455,7 +1455,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -1469,7 +1469,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { } else { forl->type = NOOMP_NODE_FORLOOPIN; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); while (1) { @@ -1490,7 +1490,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -1500,7 +1500,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { // okay. that took a while. now for the in and the expressions if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "in", 2)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "in", 2)) { parser->error_state = NOOMP_ERROR_EXPECTED_IN; return 0; } @@ -1515,7 +1515,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); } else { break; @@ -1525,7 +1525,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { // making this the same for all of them: do [block] end if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "do", 2)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "do", 2)) { parser->error_state = NOOMP_ERROR_EXPECTED_DO_AFTER_EXPRESSION; return 0; } @@ -1537,14 +1537,14 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, forl, block)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { parser->error_state = NOOMP_ERROR_EXPECTED_END_AFTER_FOR; return 0; } noomP_skip(parser, &token); return forl; - } else if (noom_streql(parser->code + token.offset, token.length, "goto", 4)) { // this keyword can't exist if not on the right version + } else if (noom_memeq(parser->code + token.offset, token.length, "goto", 4)) { // this keyword can't exist if not on the right version noomP_skip(parser, &token); noomP_Node* thing = noomP_allocNode(parser); @@ -1569,7 +1569,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, thing, name)) return 0; return thing; - } else if (noom_streql(parser->code + token.offset, token.length, "repeat", 6)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "repeat", 6)) { noomP_skip(parser, &token); noomP_Node* repeat = noomP_allocNode(parser); @@ -1584,7 +1584,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, repeat, block)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "until", 5)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "until", 5)) { parser->error_state = NOOMP_ERROR_EXPECTED_UNTIL; return 0; } @@ -1597,7 +1597,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, repeat, condition)) return 0; return repeat; - } else if (noom_streql(parser->code + token.offset, token.length, "do", 2)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "do", 2)) { noomP_skip(parser, &token); noomP_Node* doblock = noomP_allocNode(parser); @@ -1612,7 +1612,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, doblock, block)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_KEYWORD || !noom_streql(parser->code + token.offset, token.length, "end", 3)) { + if (token.type != NOOML_TOKEN_KEYWORD || !noom_memeq(parser->code + token.offset, token.length, "end", 3)) { parser->error_state = NOOMP_ERROR_EXPECTED_END_AFTER_DO; return 0; } @@ -1621,7 +1621,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { return doblock; } } else if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, "::", 2)) { // symbol doesn't exist on wrong versions + if (noom_memeq(parser->code + token.offset, token.length, "::", 2)) { // symbol doesn't exist on wrong versions noomP_skip(parser, &token); noomP_Node* thing = noomP_allocNode(parser); @@ -1643,7 +1643,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, thing, name)) return 0; if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "::", 2)) { + if (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "::", 2)) { parser->error_state = NOOMP_ERROR_EXPECTED_COLONCOLON; return 0; } @@ -1653,7 +1653,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { } } - if (token.type == NOOML_TOKEN_IDENTIFIER || (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, "(", 1))) { + if (token.type == NOOML_TOKEN_IDENTIFIER || (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, "(", 1))) { noomP_Node* base = noomP_parseRawExpression(parser); if (base == 0) return 0; @@ -1680,12 +1680,12 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); if (noomP_peek(parser, &token)) return 0; - if (token.type != NOOML_TOKEN_IDENTIFIER && (token.type != NOOML_TOKEN_SYMBOL || !noom_streql(parser->code + token.offset, token.length, "(", 1))) { + if (token.type != NOOML_TOKEN_IDENTIFIER && (token.type != NOOML_TOKEN_SYMBOL || !noom_memeq(parser->code + token.offset, token.length, "(", 1))) { // unexpected parser->error_state = NOOMP_ERROR_EXPECTED_ASSIGNABLE; return 0; @@ -1709,7 +1709,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_addSubnode(parser, container, item)) return 0; if (noomP_addSubnode(parser, assignment, container)) return 0; - } else if (noom_streql(parser->code + token.offset, token.length, "=", 1)) { + } else if (noom_memeq(parser->code + token.offset, token.length, "=", 1)) { assignment->source_offset = token.offset; noomP_skip(parser, &token); break; @@ -1731,7 +1731,7 @@ noomP_Node* noomP_parseRawStatement(noomP_Parser* parser) { if (noomP_peek(parser, &token)) return 0; - if (token.type == NOOML_TOKEN_SYMBOL && noom_streql(parser->code + token.offset, token.length, ",", 1)) { + if (token.type == NOOML_TOKEN_SYMBOL && noom_memeq(parser->code + token.offset, token.length, ",", 1)) { noomP_skip(parser, &token); continue; // explicit cause felt like it } else { @@ -1762,7 +1762,7 @@ noomP_Node* noomP_parseStatement(noomP_Parser* parser) { while (1) { if (noomP_peek(parser, &token)) return 0; if (token.type == NOOML_TOKEN_SYMBOL) { - if (noom_streql(parser->code + token.offset, token.length, ";", 1)) { + if (noom_memeq(parser->code + token.offset, token.length, ";", 1)) { noomP_skip(parser, &token); continue; }