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

Merge pull request 'Random changes with varying usefulness' (#9) from tema5002/noom:main into main

Browse Source 
Reviewed-on: #9
Reviewed-by: IonutParau <ionut.alex.parau@gmail.com>
This commit was merged in pull request #9.
This commit is contained in:
IonutParau
2026-06-22 22:13:46 +02:00
parent 97ea1e60b1 4107afb842
commit d8b893ad77
8 changed files with 261 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/compiler.c
View File

@@ -87,7 +87,7 @@ static noom_Exit noomC_emit_ABC(noomV_Function* func, const noomV_Opcode op, con
return noomC_emit(func, (noomV_Inst){.op = op, .a = a, .b = b, .c = c});
}
static noom_Exit noomC_emit_Aus(noomV_Function* func, const noomV_Opcode op, const unsigned char a, const unsigned short us) {
static noom_Exit noomC_emit_AuD(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});
}
@@ -122,6 +122,10 @@ static noom_Exit noomC_addconst_str(noomC_Compiler* c, noom_LuaVM* vm, const cha
return noomC_addconst(c->target, (noomV_Value){.tag = NOOMV_VOBJ, .autoclose = 0, .isptr = 0, .obj = (noomV_Object*)s});
}
static noom_Exit noomC_addconst_num(noomC_Compiler *c, noom_LuaVM *vm, double num) {
// TODO :(
}
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);
@@ -141,8 +145,6 @@ static noom_BinOp noomC_what_bop_is_this(const noomP_Parser* parser, noom_uint_t
// no .., that is special cased due to funky behavior
if (parser->version >= NOOM_VERSION_53) {
// Fucking atom forgot to put make an instruction
// update no i am unable to read
if (noom_startswith(op, "//")) return NOOM_BIN_IDIV;
if (noom_startswith(op, ">>")) return NOOM_BIN_BSHIFTR;
if (noom_startswith(op, "<<")) return NOOM_BIN_BSHIFTL;
@@ -171,30 +173,37 @@ static noom_Exit noomC_compile_expr(
// retc of -1 means all values!!!!!!!!!!!
int retc) {
noom_Exit result;
// Baba is You OST is a very cool soundtrack to code to Can recommend
if (node->type == NOOMP_NODE_NILLITERAL) {
compiler->curstack++;
// TODO: analyze last instruction to optimize automatically
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHNIL, 0, 0);
if (func->codesize > 0 && func->code[func->codesize - 1].op == NOOMV_INSTR_PUSHNIL) {
func->code[func->codesize - 1].us++;
}
else {
if ((result = noomC_emit_AuD(func, NOOMV_INSTR_PUSHNIL, 0, 0)) != NOOM_OK) return result;
}
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHNIL, 0, 0);
}
if (node->type == NOOMP_NODE_BOOLEANLITERAL) {
unsigned char fucking_destination = compiler->curstack++;
unsigned char where = compiler->curstack++;
unsigned short fucking_constant = func->constsize;
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);
// TODO: analyze last instruction to optimize automatically
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHBOOLS, 0, val ? 1 : 0);
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHBOOLS, 0, val ? 1 : 0);
}
if (node->type == NOOMP_NODE_NUMBERLITERAL) {
unsigned char fucking_destination = compiler->curstack++;
return NOOM_PLEASEHELPMEIAMSCARED; // 😭😭😭😭😭😭😭😭
noomL_Token number_token = noomC_token_at(parser, node->source_offset);
double val = noom_strtod(parser->code + number_token.offset, 0, 0);
if ((result = noomC_addconst_num(compiler, vm, val)) != NOOM_OK) return result;
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHCONST, 0, fucking_destination);
}
if (node->type == NOOMP_NODE_STRINGLITERAL) {
compiler->curstack++;
unsigned char fucking_destination = func->constsize;
noom_Exit result = noomC_addconst_str(compiler, vm, "but DID YOU KNOW", 16);
if (result) return result;
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHCONST, 0, fucking_destination);
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHCONST, 0, fucking_destination);
}
if (node->type == NOOMP_NODE_BINARYOPERATOR) {
if (node->subnodec != 2) return NOOM_EINTERNAL;
@@ -221,7 +230,7 @@ static noom_Exit noomC_compile_expr(
}
compiler->curstack -= amount;
compiler->curstack++;
return noomC_emit_Aus(func, NOOMV_INSTR_CONCAT, 0, amount - 1);
return noomC_emit_AuD(func, NOOMV_INSTR_CONCAT, 0, amount - 1);
}
if ((result = noomC_compile_expr(vm, compiler, parser, func, node->subnodes[0], 1))) return result;
@@ -242,13 +251,13 @@ static noom_Exit noomC_compile_expr(
noom_uint_t fieldlen = noomL_tokenlen(fieldname, 0, parser->version);
noom_uint_t constidx = func->constsize;
if ((result = noomC_addconst_str(compiler, vm, fieldname, fieldlen))) return result;
if ((result = noomC_emit_Aus(func, NOOMV_INSTR_GETMETHOD, 0, constidx))) return result;
if ((result = noomC_emit_AuD(func, NOOMV_INSTR_GETMETHOD, 0, constidx))) return result;
}
for (int i = isMethod ? 2 : 1; i < node->subnodec; i++) {
noom_bool_t isLast = i == (node->subnodec - 1);
if ((result = noomC_compile_expr(vm, compiler, parser, func, node->subnodes[i], isLast ? -1 : 1))) return result;
}
return noomC_emit_Aus(func, NOOMV_INSTR_CALL, funcIdx, retc + 1);
return noomC_emit_AuD(func, NOOMV_INSTR_CALL, funcIdx, retc + 1);
}
if (node->type == NOOMP_NODE_VARIABLE) {
noomC_LocalInfo info;
@@ -259,14 +268,14 @@ static noom_Exit noomC_compile_expr(
switch (info.type) {
case NOOMC_LOCAL:
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHVAL, 0, info.idx);
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHVAL, 0, info.idx);
case NOOMC_UPVAL:
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHUPVAL, 0, info.idx);
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHUPVAL, 0, info.idx);
case NOOMC_GLOBAL: {
noom_uint_t constidx = compiler->target->constsize;
if ((result = noomC_addconst_str(compiler, vm, varname, namelen))) return result;
if (parser->version == NOOM_VERSION_51) {
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHGLOBAL, 0, constidx);
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHGLOBAL, 0, constidx);
}
noomC_LocalInfo _ENV;
if ((result = noomC_identifyLocal(compiler, &_ENV, "_ENV", 4))) return result;
@@ -274,11 +283,11 @@ static noom_Exit noomC_compile_expr(
if (_ENV.type == NOOMC_GLOBAL) return NOOM_EINTERNAL;
// most likely branch in human history
if (_ENV.type == NOOMC_UPVAL) {
return noomC_emit_Aus(func, NOOMV_INSTR_PUSHUPVAL, _ENV.idx, constidx);
return noomC_emit_AuD(func, NOOMV_INSTR_PUSHUPVAL, _ENV.idx, constidx);
}
// bitchass
if ((result = noomC_emit_Aus(func, NOOMV_INSTR_PUSHVAL, 0, _ENV.idx))) return result;
return noomC_emit_Aus(func, NOOMV_INSTR_GETFIELD, 0, constidx);
if ((result = noomC_emit_AuD(func, NOOMV_INSTR_PUSHVAL, 0, _ENV.idx))) return result;
return noomC_emit_AuD(func, NOOMV_INSTR_GETFIELD, 0, constidx);
}
}
// forgot a case
@@ -305,10 +314,11 @@ static noom_Exit noomC_compile_block(noom_LuaVM* vm, noomC_Compiler* compiler, c
// 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) {
noom_Exit result;
// local name <attr> = expression i think
// local name <attr> = expression
if (node->type == NOOMP_NODE_LOCALDECLARATION) {
// FIXME: there can be multiple locals defined
// This code is awful for several reasons and we shall burn it
// :(
if (node->subnodec != 1 && node->subnodec != 2) return NOOM_EINTERNAL;
const noomP_Node* varname_node = node->subnodes[0];
@@ -347,7 +357,7 @@ static noom_Exit noomC_add_stuff_to_function(noom_LuaVM* vm, noomC_Compiler* com
if (node->subnodec == 1) {
const unsigned short constptr = func->constsize;
result = noomC_emit_Aus(func, NOOMV_INSTR_PUSHNIL, 0, 0);
result = noomC_emit_AuD(func, NOOMV_INSTR_PUSHNIL, 0, 0);
if (result != NOOM_OK) return result;
compiler->curstack++;
} else {
@@ -405,7 +415,7 @@ static noom_Exit noomC_add_stuff_to_function(noom_LuaVM* vm, noomC_Compiler* com
// TODO
if (node->type == NOOMP_NODE_RETURN) {
noomC_emit_Aus(func, NOOMV_INSTR_NOP, 0, 0);
noomC_emit_AuD(func, NOOMV_INSTR_NOP, 0, 0);
return NOOM_OK;
}

8
src/error.c
View File

@@ -42,8 +42,6 @@ noom_uint_t noom_format_error(const noomP_Parser* parser, const char* program_na
[NOOMP_ERROR_EXPECTED_IDENTIFIER_AFTER_GOTO] = {"expected identifier after goto\n", 0},
[NOOMP_ERROR_EXPECTED_COLONCOLON] = {"expected :: to end label identifier", 1},
[NOOMP_ERROR_INVALID_STATEMENT] = {"expected statement, got", 2},
// I want someone smarter than me [tema5002] to give these a proper description
// ^ alrighty then
[NOOMP_ERROR_EXPECTED_ASSIGNABLE] = {"expected assignable expression after comma in assignment", 1},
[NOOMP_ERROR_NOT_ASSIGNABLE] = {"expression in assignment is not assignable", 1},
[NOOMP_ERROR_EXPECTED_COMMA_OR_EQUAL_IN_ASSIGNMENT] = {"expected a comma or equals after assignable in assignment", 1},
@@ -77,7 +75,7 @@ noom_uint_t noom_format_error(const noomP_Parser* parser, const char* program_na
lexer_code = parser->error_state & ~NOOMP_ERROR_LEXER;
}
struct noom_error err = (base_err == NOOMP_ERROR_LEXER) ? lexer_errors[lexer_code] : parser_errors[base_err];
struct noom_error err = base_err == NOOMP_ERROR_LEXER ? lexer_errors[lexer_code] : parser_errors[base_err];
noom_uint_t row = 1, column = 1;
for (noom_uint_t i = 0; i < parser->lex_offset; i++) {
@@ -105,7 +103,7 @@ noom_uint_t noom_format_error(const noomP_Parser* parser, const char* program_na
linedig +
sizeof(": ") - 1 +
noom_strlen(err.s) +
+1; // \0;
1; // \0;
if (err.near) space +=
(err.near == 1 ? sizeof(" near") - 1 : 0) +
@@ -133,7 +131,7 @@ noom_uint_t noom_format_error(const noomP_Parser* parser, const char* program_na
noom_uint_t divisor = 1;
while (temp / divisor >= 10) divisor *= 10;
while (divisor > 0) {
num_buf[num_len++] = '0' + (temp / divisor);
num_buf[num_len++] = (char)(temp / divisor + '0');
temp %= divisor;
divisor /= 10;
}

118
src/helper.c
View File

@@ -1,7 +1,114 @@
#include "helper.h"
#include "lexer.h"
#include "noom.h"
double noom_strtod(const char* s, const char** endptr, int* error) {
// Num???? Is that a fucking noom reference???????
double num = 0.0;
int error_but_different = 1;
const noom_bool_t negative = *s == '-';
if (*s == '-' || *s == '+')
s++;
if (!noomL_isnumber(s[*s == '.'])) goto fuck;
if (*s == '0' && noomL_lower(s[1]) == 'x') {
s += 2;
// if the string starts with "0x" but does not contain digits it's invalid
noom_bool_t are_we_cooked = 1;
while (noomL_ishex(*s)) {
int digit;
if (noomL_isnumber(*s)) digit = *s - '0';
else digit = noomL_lower(*s) - 'a' + 10;
num = num * 16.0 + digit;
are_we_cooked = 0;
s++;
}
if (are_we_cooked) goto fuck;
if (noomL_lower(*s) == 'p') {
// damn then
s++;
int exponent = 0;
const noom_bool_t exponent_negative = *s == '-';
if (*s == '-' || *s == '+')
s++;
if (!noomL_isnumber(*s)) goto fuck;
while (noomL_isnumber(*s)) {
exponent = exponent * 10 + (*s - '0');
s++;
}
num *= noom_pow(2.0, exponent_negative ? -exponent : exponent);
}
} else {
noom_bool_t are_we_cooked = 1;
while (noomL_isnumber(*s)) {
num = num * 10.0 + (*s - '0');
are_we_cooked = 0;
s++;
}
if (*s == '.') {
s++;
double fraction_divisor = 10.0;
while (noomL_isnumber(*s)) {
are_we_cooked = 0;
num += (double)(*s - '0') / fraction_divisor;
fraction_divisor *= 10.0;
s++;
}
}
if (are_we_cooked) goto fuck;
if (noomL_lower(*s) == 'e') {
s++;
int exponent = 0;
const noom_bool_t exponent_negative = *s == '-';
if (*s == '-' || *s == '+')
s++;
if (!noomL_isnumber(*s)) goto fuck;
while (noomL_isnumber(*s)) {
exponent = exponent * 10 + (*s - '0');
s++;
}
num *= noom_pow(10.0, exponent_negative ? -exponent : exponent);
}
}
error_but_different = 0;
fuck:
if (endptr) *endptr = s;
if (error) *error = error_but_different;
return negative ? -num : num;
}
// made by some stranger on stack overflow
double noom_pow(double x, int y) {
if (y == 0)
return 1;
const double temp = noom_pow(x, y / 2);
if (y % 2 == 0) {
return temp * temp;
}
if (y > 0)
return x * temp * temp;
return temp * temp / x;
}
int noom_startswith(const char* str, const char* compare) {
#ifdef __has_builtin
#if __has_builtin(__builtin_strncmp)
@@ -90,3 +197,12 @@ void noom_free(void* ptr) {
void* noom_realloc(void* ptr, noom_uint_t size) {
return realloc(ptr, size);
}
void* noom_realloc_free(void* ptr, noom_uint_t size) {
void* newptr = noom_realloc(ptr, size);
if (newptr == 0) {
noom_free(ptr);
return 0;
}
return newptr;
}

7
src/helper.h
View File

@@ -2,15 +2,20 @@
#define NOOM_USHORT_MAX 0xffff
// isn't quite strtod, is it
// doesn't skip whitespace unlike actual C stdlib strtod!!!!
double noom_strtod(const char* s, const char** endptr, int* error);
double noom_pow(double x, int y);
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);
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);
void* noom_realloc(void* ptr, noom_uint_t size);
void *noom_realloc_free(void* ptr, noom_uint_t size);

13
src/lexer.c
View File

@@ -29,6 +29,14 @@ int noomL_ishex(char c) {
return noomL_isnumber(c) || (noomL_lower(c) >= 'a' && noomL_lower(c) <= 'f');
}
int noomL_is_ident_start(char c) {
return noomL_isalpha(c) || c == '_';
}
int noomL_is_ident_continue(char c) {
return noomL_isalphanum(c) || c == '_';
}
noom_uint_t noomL_getsymbol(const char* s, noom_LuaVersion version) { // TODO: maybe find some less shit crap holy crap
if (noom_startswith(s, "...")) return 3;
@@ -514,10 +522,9 @@ noomL_ErrorType noomL_lex(const char* s, noom_uint_t start, noomL_Token* token,
return NOOML_ERROR_NONE;
}
if (str[0] == '_' || noomL_isalpha(str[0])) { // TODO: maybe abstract into function for "can start ident"?
if (noomL_is_ident_start(str[0])) {
noom_uint_t len = 1;
while (str[len] == '_' || noomL_isalphanum(str[len])) // same here
len++;
while (noomL_is_ident_continue(str[len])) len++;
token->type = NOOML_TOKEN_IDENTIFIER;
if (noomL_iskeyword(str, len, version)) token->type = NOOML_TOKEN_KEYWORD;

2
src/lexer.h
View File

@@ -44,6 +44,8 @@ int noomL_isalphanum(char c);
int noomL_iswhitespace(char c);
int noomL_lower(char c);
int noomL_ishex(char c);
int noomL_is_ident_start(char c);
int noomL_is_ident_continue(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);

135
src/main.c
View File

@@ -1,5 +1,4 @@
#include <stdio.h> // for now
#include <stdlib.h>
#include "helper.h"
#include "error.h"
#include "noom.h"
@@ -37,14 +36,12 @@ void print_node(const noomP_Node* node, noom_uint_t depth) {
printf("}\n");
}
int the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(const char* code, const char* program_name, const char* filename) {
int execute(const char* code, noom_LuaVersion version, const char* program_name, const char* filename) {
noomP_Parser parser;
noomP_Node* program;
noom_LuaVM* vm = noom_createVM(NOOM_VERSION_51);
// goodbye "shitass" you will be missed
int success = noomP_parse(code, filename, NOOM_VERSION_51, &program, &parser);
int success = noomP_parse(code, filename, version, &program, &parser);
if (success == 0) {
puts("LEX OUTPUT:");
fputs("\x1b[48;2;10;10;10m", stdout);
@@ -52,7 +49,7 @@ int the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(
while (1) {
noomL_Token token;
noomL_ErrorType err = noomL_lex(code, pos, &token, NOOM_VERSION_54);
noomL_ErrorType err = noomL_lex(code, pos, &token, version);
if (err) break;
if (token.type == NOOML_TOKEN_KEYWORD) {
@@ -95,38 +92,6 @@ int the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(
noom_free(buf);
}
noomV_Value peak;
noom_Exit e = noomC_compile(vm, &parser, program, 0, 0, &peak);
if (e) {
printf("error: %d\n", e);
exit(e);
}
noomV_Function* f = (noomV_Function*)peak.obj;
for (int i = 0; i < f->codesize; i++) {
noomV_Inst inst = f->code[i];
noomV_DisInfo dis = noomV_disInfo[inst.op];
printf("%s %d ", dis.name, inst.a);
switch (dis.arg) {
case NOOMV_DIS_NONE:
break;
case NOOMV_DIS_BC:
printf("%d, %d", inst.b, inst.c);
break;
case NOOMV_DIS_uD:
printf("%d", inst.us);
break;
case NOOMV_DIS_sD:
printf("%d", inst.ss);
break;
}
printf("\n");
}
// freeing time
noomP_Node* last_node = parser.last_node;
while (last_node) {
@@ -137,7 +102,41 @@ int the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(
last_node = next;
}
noom_destroyVM(vm);
if (success) {
noom_LuaVM* vm = noom_createVM(version);
noomV_Value peak;
noom_Exit e = noomC_compile(vm, &parser, program, 0, 0, &peak);
if (e) {
printf("error: %d\n", e);
return 1;
}
noomV_Function* f = (noomV_Function*)peak.obj;
for (int i = 0; i < f->codesize; i++) {
noomV_Inst inst = f->code[i];
noomV_DisInfo dis = noomV_disInfo[inst.op];
printf("%s %d ", dis.name, inst.a);
switch (dis.arg) {
case NOOMV_DIS_NONE:
break;
case NOOMV_DIS_BC:
printf("%d, %d", inst.b, inst.c);
break;
case NOOMV_DIS_uD:
printf("%d", inst.us);
break;
case NOOMV_DIS_sD:
printf("%d", inst.ss);
break;
}
printf("\n");
}
noom_destroyVM(vm);
}
return success;
}
@@ -154,9 +153,11 @@ static char* read_file(const char* filename) {
fseek(file, 0, SEEK_SET);
char* buffer = noom_alloc(filesize + 1);
if (buffer == 0) return 0;
if (fread(buffer, 1, filesize, file) != filesize) {
fprintf(stderr, "Reached the end of the file\n");
noom_free(buffer);
return 0;
}
buffer[filesize] = '\0';
@@ -169,13 +170,15 @@ static char* read_stdin() {
noom_uint_t capacity = 4096;
noom_uint_t size = 0;
char* buffer = noom_alloc(capacity);
if (buffer == 0) return 0;
size_t n;
while ((n = fread(buffer + size, 1, capacity - size, stdin)) > 0) {
size += n;
if (size == capacity) {
capacity *= 2;
buffer = noom_realloc(buffer, capacity);
buffer = noom_realloc_free(buffer, capacity);
if (buffer == 0) return 0;
}
}
@@ -183,7 +186,6 @@ static char* read_stdin() {
return buffer;
}
// code stolen from my different project
static int read_prompt(char* buf, int buf_size, char* prompt, const int required) {
do {
printf("%s", prompt);
@@ -207,6 +209,7 @@ int main(int argc, char** argv) {
const char* script_exec;
const char* script_path;
noom_bool_t do_i_already_know_what_to_do;
noom_LuaVersion lua_version;
} params = {0};
if (argc < 2) {
@@ -246,7 +249,7 @@ int main(int argc, char** argv) {
if (params.do_i_already_know_what_to_do) {
goto die;
}
/* "-estat" or "-e stat" */
// "-estat" or "-e stat"
if (argv[i][2] != '\0') {
params.script_exec = argv[i] + 2;
params.do_i_already_know_what_to_do = 1;
@@ -261,6 +264,28 @@ int main(int argc, char** argv) {
params.do_i_already_know_what_to_do = 1;
}
if (argv[i][1] == 'l') {
const char* version_string = 0;
if (argv[i][2] != '\0') {
version_string = argv[i] + 2;
} else {
if (++i >= argc) {
err = "-l needs an argument";
goto die;
}
version_string = argv[i];
}
if (noom_strcmp(version_string, "51") == 0) params.lua_version = NOOM_VERSION_51;
else if (noom_strcmp(version_string, "52") == 0) params.lua_version = NOOM_VERSION_52;
else if (noom_strcmp(version_string, "53") == 0) params.lua_version = NOOM_VERSION_53;
else if (noom_strcmp(version_string, "54") == 0) params.lua_version = NOOM_VERSION_54;
else {
err = "unknown lua version";
goto die;
}
continue;
}
if (argv[i][1] == 'v') {
puts(NOOM_VERSION_TEXT);
return 0;
@@ -269,27 +294,34 @@ int main(int argc, char** argv) {
err = "unknown option";
goto die;
}
if (params.lua_version != 0) {
params.lua_version = NOOM_VERSION_54;
if (!params.do_i_already_know_what_to_do) {
params.enter_repl = 1;
params.do_i_already_know_what_to_do = 1;
}
}
if (!params.do_i_already_know_what_to_do) {
err = "script not set";
goto die;
}
if (params.script_exec || params.script_path) {
if (params.script_exec) {
return the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(params.script_exec, argv[0], "(command line)");
return execute(params.script_exec, params.lua_version, argv[0], "(command line)");
}
char* code = read_file(params.script_path);
if (code == 0) return 1;
int offset = 0;
if (code[0] == '#' && code[1] == '!')
for (offset = 2; code[offset] && code[offset] != '\n'; offset++);
int e = the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(code + offset, argv[0], params.script_path);
const int e = execute(code + offset, params.lua_version, argv[0], params.script_path);
noom_free(code);
return e;
}
if (params.use_stdin) {
char* code = read_stdin();
if (code == 0) return 1;
int e = the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(code, argv[0], "stdin");
const int e = execute(code, params.lua_version, argv[0], "stdin");
noom_free(code);
return e;
}
@@ -298,18 +330,17 @@ int main(int argc, char** argv) {
for (;;) {
char code[4096];
if (read_prompt(code, sizeof(code), "> ", 1)) return 0;
the_theoretical_function_to_execute_your_code_that_should_be_replaced_later(code, 0, "(noom input)");
execute(code, params.lua_version, 0, "(noom input)");
}
}
die:
fprintf(stderr, "%s: %s\n"
"usage: %s [options] [script [args]]\n"
"Available options are:\n"
" - execute stdin\n"
" -e stat execute string 'stat'\n"
" -v show version\n",
argv[0],
err,
argv[0]);
" - execute stdin\n"
" -e stat execute string 'stat'\n"
" -v show version\n"
" -l [51|52|53|54] select lua version\n",
argv[0], err, argv[0]);
return 1;
}

8
src/noom.h
View File

@@ -4,15 +4,19 @@
#define NN_STR(x) #x
#define NN_XSTR(x) NN_STR(x)
/*
#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)
#endif
#define NOOM_VERSION_TEXT "Noom " NOOM_VERSION_FULL " (C) 2026 NeoFlock and Noom contributors"
*/
#define NOOM_VERSION_FULL "development build"
#define NOOM_VERSION_TEXT "Noom " NOOM_VERSION_FULL " (c) 2026 NeoFlock and Noom contributors"
#ifdef __cplusplus
extern "C" {