feat: MontaukOS installer app, toml config, app directory with manifests, and more
This commit is contained in:
@@ -0,0 +1,331 @@
|
||||
/*
|
||||
* config.h
|
||||
* Config file manager for MontaukOS programs
|
||||
* Loads, modifies, and saves TOML config files from 0:/config/
|
||||
* Copyright (c) 2026 Daniel Hammer
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <montauk/toml.h>
|
||||
#include <montauk/syscall.h>
|
||||
|
||||
namespace montauk {
|
||||
namespace config {
|
||||
|
||||
static constexpr const char* CONFIG_DIR = "0:/config";
|
||||
|
||||
// ---- Serializer (Doc -> TOML text) ----
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct Writer {
|
||||
char* buf;
|
||||
int len;
|
||||
int cap;
|
||||
|
||||
void init() {
|
||||
cap = 1024;
|
||||
buf = (char*)montauk::malloc(cap);
|
||||
len = 0;
|
||||
buf[0] = '\0';
|
||||
}
|
||||
|
||||
void destroy() {
|
||||
if (buf) montauk::mfree(buf);
|
||||
buf = nullptr;
|
||||
len = 0;
|
||||
cap = 0;
|
||||
}
|
||||
|
||||
void grow(int need) {
|
||||
if (len + need < cap) return;
|
||||
int newCap = cap;
|
||||
while (newCap <= len + need) newCap *= 2;
|
||||
char* nb = (char*)montauk::malloc(newCap);
|
||||
montauk::memcpy(nb, buf, len);
|
||||
montauk::mfree(buf);
|
||||
buf = nb;
|
||||
cap = newCap;
|
||||
}
|
||||
|
||||
void put(char c) {
|
||||
grow(2);
|
||||
buf[len++] = c;
|
||||
buf[len] = '\0';
|
||||
}
|
||||
|
||||
void puts(const char* s) {
|
||||
int n = montauk::slen(s);
|
||||
grow(n + 1);
|
||||
montauk::memcpy(buf + len, s, n);
|
||||
len += n;
|
||||
buf[len] = '\0';
|
||||
}
|
||||
|
||||
void put_int(int64_t v) {
|
||||
if (v < 0) { put('-'); v = -v; }
|
||||
if (v == 0) { put('0'); return; }
|
||||
char tmp[24];
|
||||
int n = 0;
|
||||
while (v > 0) { tmp[n++] = '0' + (v % 10); v /= 10; }
|
||||
for (int i = n - 1; i >= 0; i--) put(tmp[i]);
|
||||
}
|
||||
|
||||
// Write a TOML-escaped string value
|
||||
void put_string(const char* s) {
|
||||
put('"');
|
||||
while (*s) {
|
||||
switch (*s) {
|
||||
case '"': puts("\\\""); break;
|
||||
case '\\': puts("\\\\"); break;
|
||||
case '\n': puts("\\n"); break;
|
||||
case '\t': puts("\\t"); break;
|
||||
case '\r': puts("\\r"); break;
|
||||
default: put(*s); break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
put('"');
|
||||
}
|
||||
|
||||
void write_value(toml::Value* v) {
|
||||
switch (v->type) {
|
||||
case toml::Type::String:
|
||||
put_string(v->str);
|
||||
break;
|
||||
case toml::Type::Int:
|
||||
put_int(v->ival);
|
||||
break;
|
||||
case toml::Type::Bool:
|
||||
puts(v->bval ? "true" : "false");
|
||||
break;
|
||||
case toml::Type::Array: {
|
||||
put('[');
|
||||
for (int i = 0; i < v->array.count; i++) {
|
||||
if (i > 0) puts(", ");
|
||||
write_value(v->array.items[i]);
|
||||
}
|
||||
put(']');
|
||||
break;
|
||||
}
|
||||
case toml::Type::Table:
|
||||
// Inline tables are not re-serialized here;
|
||||
// their entries are flattened in the doc
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Extract the table prefix from a dotted key (everything before last dot)
|
||||
// Returns length of prefix, or 0 if no dot
|
||||
inline int key_table(const char* key, char* out, int outSz) {
|
||||
int lastDot = -1;
|
||||
int n = montauk::slen(key);
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (key[i] == '.') lastDot = i;
|
||||
}
|
||||
if (lastDot <= 0) { out[0] = '\0'; return 0; }
|
||||
int cp = lastDot < outSz - 1 ? lastDot : outSz - 1;
|
||||
montauk::memcpy(out, key, cp);
|
||||
out[cp] = '\0';
|
||||
return cp;
|
||||
}
|
||||
|
||||
// Extract the bare key (after last dot)
|
||||
inline const char* key_bare(const char* key) {
|
||||
const char* last = key;
|
||||
while (*key) {
|
||||
if (*key == '.') last = key + 1;
|
||||
key++;
|
||||
}
|
||||
return last;
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Serialize a Doc back to TOML text. Caller must montauk::mfree() the result.
|
||||
inline char* serialize(toml::Doc* doc) {
|
||||
detail::Writer w;
|
||||
w.init();
|
||||
|
||||
char currentTable[256] = {};
|
||||
|
||||
for (int i = 0; i < doc->entries.count; i++) {
|
||||
auto* v = doc->entries.items[i];
|
||||
if (!v->key) continue;
|
||||
|
||||
// Skip Table entries that only serve as section markers —
|
||||
// we emit [table] headers based on the keys of actual values
|
||||
if (v->type == toml::Type::Table && v->array.count == 0)
|
||||
continue;
|
||||
|
||||
// Determine table prefix for this key
|
||||
char table[256];
|
||||
detail::key_table(v->key, table, sizeof(table));
|
||||
|
||||
// Emit [table] header if the section changed
|
||||
if (!montauk::streq(table, currentTable)) {
|
||||
montauk::strcpy(currentTable, table);
|
||||
if (table[0]) {
|
||||
if (w.len > 0) w.put('\n');
|
||||
w.put('[');
|
||||
w.puts(table);
|
||||
w.puts("]\n");
|
||||
}
|
||||
}
|
||||
|
||||
// Emit key = value
|
||||
w.puts(detail::key_bare(v->key));
|
||||
w.puts(" = ");
|
||||
w.write_value(v);
|
||||
w.put('\n');
|
||||
}
|
||||
|
||||
return w.buf;
|
||||
}
|
||||
|
||||
// ---- File operations ----
|
||||
|
||||
// Ensure the config directory exists
|
||||
inline void ensure_dir() {
|
||||
montauk::fmkdir(CONFIG_DIR);
|
||||
}
|
||||
|
||||
// Build full path: "0:/config/<name>.toml"
|
||||
inline void build_path(char* out, int outSz, const char* name) {
|
||||
int p = 0;
|
||||
const char* dir = CONFIG_DIR;
|
||||
while (*dir && p < outSz - 2) out[p++] = *dir++;
|
||||
out[p++] = '/';
|
||||
while (*name && p < outSz - 6) out[p++] = *name++;
|
||||
// Append ".toml"
|
||||
const char* ext = ".toml";
|
||||
while (*ext && p < outSz - 1) out[p++] = *ext++;
|
||||
out[p] = '\0';
|
||||
}
|
||||
|
||||
// Load a config file by name (without extension).
|
||||
// Returns an initialized Doc (empty if file doesn't exist).
|
||||
inline toml::Doc load(const char* name) {
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
|
||||
int handle = montauk::open(path);
|
||||
if (handle < 0) {
|
||||
toml::Doc doc;
|
||||
doc.init();
|
||||
return doc;
|
||||
}
|
||||
|
||||
uint64_t size = montauk::getsize(handle);
|
||||
if (size == 0) {
|
||||
montauk::close(handle);
|
||||
toml::Doc doc;
|
||||
doc.init();
|
||||
return doc;
|
||||
}
|
||||
|
||||
char* text = (char*)montauk::malloc(size + 1);
|
||||
montauk::read(handle, (uint8_t*)text, 0, size);
|
||||
montauk::close(handle);
|
||||
text[size] = '\0';
|
||||
|
||||
toml::Doc doc = toml::parse(text);
|
||||
montauk::mfree(text);
|
||||
return doc;
|
||||
}
|
||||
|
||||
// Save a Doc to disk as a TOML file.
|
||||
// Creates the file if it doesn't exist.
|
||||
// Returns 0 on success, negative on error.
|
||||
inline int save(const char* name, toml::Doc* doc) {
|
||||
ensure_dir();
|
||||
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
|
||||
char* text = serialize(doc);
|
||||
int textLen = montauk::slen(text);
|
||||
|
||||
// Try to open existing file, create if not found
|
||||
int handle = montauk::open(path);
|
||||
if (handle < 0) {
|
||||
handle = montauk::fcreate(path);
|
||||
if (handle < 0) {
|
||||
montauk::mfree(text);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int ret = montauk::fwrite(handle, (const uint8_t*)text, 0, textLen);
|
||||
montauk::close(handle);
|
||||
montauk::mfree(text);
|
||||
return ret < 0 ? ret : 0;
|
||||
}
|
||||
|
||||
// Delete a config file. Returns 0 on success.
|
||||
inline int remove(const char* name) {
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
return montauk::fdelete(path);
|
||||
}
|
||||
|
||||
// ---- In-place modification helpers ----
|
||||
|
||||
// Set or overwrite a string value in the doc.
|
||||
inline void set_string(toml::Doc* doc, const char* key, const char* val) {
|
||||
auto* existing = doc->get(key);
|
||||
if (existing) {
|
||||
if (existing->type == toml::Type::String && existing->str)
|
||||
montauk::mfree(existing->str);
|
||||
existing->type = toml::Type::String;
|
||||
existing->str = toml::Value::dup(val);
|
||||
} else {
|
||||
doc->entries.push(toml::Value::make_string(key, val, montauk::slen(val)));
|
||||
}
|
||||
}
|
||||
|
||||
// Set or overwrite an integer value in the doc.
|
||||
inline void set_int(toml::Doc* doc, const char* key, int64_t val) {
|
||||
auto* existing = doc->get(key);
|
||||
if (existing) {
|
||||
if (existing->type == toml::Type::String && existing->str)
|
||||
montauk::mfree(existing->str);
|
||||
existing->type = toml::Type::Int;
|
||||
existing->ival = val;
|
||||
} else {
|
||||
doc->entries.push(toml::Value::make_int(key, val));
|
||||
}
|
||||
}
|
||||
|
||||
// Set or overwrite a boolean value in the doc.
|
||||
inline void set_bool(toml::Doc* doc, const char* key, bool val) {
|
||||
auto* existing = doc->get(key);
|
||||
if (existing) {
|
||||
if (existing->type == toml::Type::String && existing->str)
|
||||
montauk::mfree(existing->str);
|
||||
existing->type = toml::Type::Bool;
|
||||
existing->bval = val;
|
||||
} else {
|
||||
doc->entries.push(toml::Value::make_bool(key, val));
|
||||
}
|
||||
}
|
||||
|
||||
// Remove a key from the doc.
|
||||
inline bool unset(toml::Doc* doc, const char* key) {
|
||||
for (int i = 0; i < doc->entries.count; i++) {
|
||||
auto* v = doc->entries.items[i];
|
||||
if (v->key && montauk::streq(v->key, key)) {
|
||||
v->destroy();
|
||||
// Shift remaining entries down
|
||||
for (int j = i; j < doc->entries.count - 1; j++)
|
||||
doc->entries.items[j] = doc->entries.items[j + 1];
|
||||
doc->entries.count--;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace config
|
||||
} // namespace montauk
|
||||
Reference in New Issue
Block a user