iuno

src/console/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2025 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_TARGET_NAME}
+  PRIVATE
+    console.c
+    consolecmd.c
+    consolevar.c
+)

src/console/console.c

@@ -0,0 +1,384 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "console.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+
+console_t CONSOLE;
+
+void consoleInit() {
+  memoryZero(&CONSOLE, sizeof(console_t));
+  pthread_mutex_init(&CONSOLE.lock, NULL); // Initialize the mutex
+
+  // Register the get and set command.
+  CONSOLE.cmdGet = consoleRegCmd("get", cmdGet);
+  CONSOLE.cmdSet = consoleRegCmd("set", cmdSet);
+  consoleRegCmd("echo", cmdEcho);
+}
+
+consolecmd_t * consoleRegCmd(const char_t *name, consolecmdfunc_t function) {
+  pthread_mutex_lock(&CONSOLE.lock); // Lock
+  consolecmd_t *cmd = &CONSOLE.commands[CONSOLE.commandCount++];
+  consoleCmdInit(cmd, name, function);
+  pthread_mutex_unlock(&CONSOLE.lock); // Unlock
+  return cmd;
+}
+
+consolevar_t * consoleRegVar(
+  const char_t *name,
+  const char_t *value,
+  consolevarchanged_t event
+) {
+  pthread_mutex_lock(&CONSOLE.lock); // Lock
+  consolevar_t *var = &CONSOLE.variables[CONSOLE.variableCount++];
+  consoleVarInitListener(var, name, value, event);
+  pthread_mutex_unlock(&CONSOLE.lock); // Unlock
+  return var;
+}
+
+void consolePrint(const char_t *message, ...) {
+  char_t buffer[CONSOLE_LINE_MAX];
+
+  va_list args;
+  va_start(args, message);
+  int32_t len = stringFormatVA(buffer, CONSOLE_LINE_MAX, message, args);
+  va_end(args);
+
+  // Move all lines back
+  memoryMove(
+    CONSOLE.line[0],
+    CONSOLE.line[1],
+    (CONSOLE_HISTORY_MAX - 1) * CONSOLE_LINE_MAX
+  );
+
+  // Copy the new line
+  memoryCopy(
+    CONSOLE.line[CONSOLE_HISTORY_MAX - 1],
+    buffer,
+    len + 1
+  );
+  printf("%s\n", buffer);
+}
+
+void consoleExec(const char_t *line) {
+  pthread_mutex_lock(&CONSOLE.lock); // Lock
+  assertNotNull(line, "line must not be NULL");
+  assertTrue(
+    CONSOLE.execBufferCount < CONSOLE_EXEC_BUFFER_MAX,
+    "Too many commands in the buffer."
+  );
+
+  char_t buffer[CONSOLE_LINE_MAX];
+  size_t i = 0, j = 0;
+  char_t c;
+  consoleexecstate_t state = CONSOLE_EXEC_STATE_INITIAL;
+  consolecmdexec_t *exec = NULL;
+
+  while(state != CONSOLE_EXEC_STATE_FULLY_PARSED) {
+    c = line[i];
+
+    switch(state) {
+      case CONSOLE_EXEC_STATE_INITIAL:
+        assertTrue(j == 0, "Buffer not empty?");
+
+        if(c == '\0') {
+          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
+          break;
+        }
+
+        if(stringIsWhitespace(c) || c == ';') {
+          i++;
+          continue;
+        }
+
+        state = CONSOLE_EXEC_STATE_PARSE_CMD;
+        break;
+
+      case CONSOLE_EXEC_STATE_PARSE_CMD:
+        if(stringIsWhitespace(c) || c == '\0' || c == ';') {
+          state = CONSOLE_EXEC_STATE_CMD_PARSED;
+          continue;
+        }
+
+        if(c == '"') {
+          // Can't handle quotes within the command.
+          consolePrint("Invalid command");
+          while(c != '\0' && c != ';') c = line[++i];
+          continue;
+        }
+        
+        buffer[j++] = c;
+        i++;
+
+        if(j >= CONSOLE_LINE_MAX) {
+          consolePrint("Command too long");
+          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
+          continue;
+        }
+        break;
+
+      case CONSOLE_EXEC_STATE_CMD_PARSED:
+        if(j == 0) {
+          state = CONSOLE_EXEC_STATE_INITIAL;
+          continue;
+        }
+
+        // Create exec
+        assertNull(exec, "Existing command parsing?");
+
+        exec = &CONSOLE.execBuffer[CONSOLE.execBufferCount];
+        memoryZero(exec, sizeof(consolecmdexec_t));
+
+        buffer[j] = '\0';
+        stringCopy(exec->command, buffer, CONSOLE_LINE_MAX);
+        state = CONSOLE_EXEC_STATE_FIND_ARG;
+
+        j = 0;// Free up buffer
+        break;
+
+      case CONSOLE_EXEC_STATE_FIND_ARG:
+        if(c == '\0' || c == ';') {
+          state = CONSOLE_EXEC_STATE_CMD_FINISHED;
+          continue;
+        }
+
+        if(stringIsWhitespace(c)) {
+          i++;
+          continue;
+        }
+
+        if(c == '"') {
+          state = CONSOLE_EXEC_STATE_PARSE_ARG_QUOTED;
+          i++;
+        } else {
+          state = CONSOLE_EXEC_STATE_PARSE_ARG;
+        }
+        break;
+
+      case CONSOLE_EXEC_STATE_PARSE_ARG:
+        if(stringIsWhitespace(c) || c == '\0' || c == ';') {
+          state = CONSOLE_EXEC_STATE_ARG_PARSED;
+          continue;
+        }
+
+        buffer[j++] = c;
+        i++;
+
+        if(j >= CONSOLE_LINE_MAX) {
+          consolePrint("Arg too long");
+          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
+          continue;
+        }
+        break;
+
+      case CONSOLE_EXEC_STATE_PARSE_ARG_QUOTED:
+        if(c == '"') {
+          state = CONSOLE_EXEC_STATE_ARG_PARSED;
+          i++;
+          continue;
+        }
+
+        if(c == '\0' || c == ';') {
+          consolePrint("Unterminated quote");
+          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
+          continue;
+        }
+
+        if(c == '\\') {
+          c = line[++i];
+
+          if(c == '\0' || c == ';') {
+            consolePrint("Unterminated quote");
+            state = CONSOLE_EXEC_STATE_FULLY_PARSED;
+            continue;
+          }
+        }
+
+        buffer[j++] = c;
+        i++;
+
+        if(j >= CONSOLE_LINE_MAX) {
+          consolePrint("Arg too long");
+          state = CONSOLE_EXEC_STATE_FULLY_PARSED;
+          continue;
+        }
+        break;
+
+      case CONSOLE_EXEC_STATE_ARG_PARSED:
+        buffer[j] = '\0';
+        stringCopy(exec->argv[exec->argc++], buffer, CONSOLE_LINE_MAX);
+        state = CONSOLE_EXEC_STATE_FIND_ARG;
+        j = 0;// Free up buffer
+        break;
+
+      case CONSOLE_EXEC_STATE_CMD_FINISHED:
+        assertNotNull(exec, "No command found?");
+
+        // Now, is there a command that matches?
+        for(uint32_t k = 0; k < CONSOLE.commandCount; k++) {
+          consolecmd_t *cmd = &CONSOLE.commands[k];
+          if(stringCompare(cmd->name, exec->command) != 0) continue;
+          exec->cmd = cmd;
+          break;
+        }
+
+        if(exec->cmd == NULL) {
+          // Command wasn't found, is there a variable that matches?
+          for(uint32_t k = 0; k < CONSOLE.variableCount; k++) {
+            consolevar_t *var = &CONSOLE.variables[k];
+            if(stringCompare(var->name, exec->command) != 0) continue;
+
+            // Matching variable found, is this a GET or a SET?
+            if(exec->argc == 0) {
+              exec->cmd = CONSOLE.cmdGet;
+              stringCopy(exec->argv[0], exec->command, CONSOLE_LINE_MAX);
+              exec->argc = 1;
+            } else {
+              exec->cmd = CONSOLE.cmdSet;
+              stringCopy(exec->argv[1], exec->argv[0], CONSOLE_LINE_MAX);
+              stringCopy(exec->argv[0], exec->command, CONSOLE_LINE_MAX);
+              exec->argc = 2;
+            }
+            break;
+          }
+
+          if(exec->cmd == NULL) {
+            consolePrint("Command not found", exec->command);
+            exec = NULL;
+            state = CONSOLE_EXEC_STATE_INITIAL;
+            break;
+          }
+        }
+        
+        // Prep for next command.
+        exec = NULL;
+        state = CONSOLE_EXEC_STATE_INITIAL;
+        CONSOLE.execBufferCount++;
+        break;
+
+      default:
+        assertUnreachable("Invalid state.");
+        break;
+    }
+  }
+
+  pthread_mutex_unlock(&CONSOLE.lock); // Unlock
+}
+
+void consoleProcess() {
+  pthread_mutex_lock(&CONSOLE.lock); // Lock
+  for(uint32_t i = 0; i < CONSOLE.execBufferCount; i++) {
+    consolecmdexec_t *exec = &CONSOLE.execBuffer[i];
+
+    assertNotNull(exec->cmd, "Command execution has no command.");
+
+    exec->cmd->function(exec);
+  }
+
+  // Clear the exec buffer
+  CONSOLE.execBufferCount = 0;
+  pthread_mutex_unlock(&CONSOLE.lock); // Unlock
+}
+
+void cmdGet(const consolecmdexec_t *exec) {
+  assertTrue(
+    exec->argc >= 1,
+    "Get command requires 1 argument."
+  );
+
+  for(uint32_t i = 0; i < CONSOLE.variableCount; i++) {
+    consolevar_t *var = &CONSOLE.variables[i];
+    if(stringCompare(var->name, exec->argv[0]) != 0) continue;
+    consolePrint("%s", var->value);
+    return;
+  }
+
+  consolePrint("Error: Variable '%s' not found.", exec->argv[0]);
+}
+
+void cmdSet(const consolecmdexec_t *exec) {
+  assertTrue(exec->argc >= 2, "set command requires 2 arguments.");
+
+  for(uint32_t i = 0; i < CONSOLE.variableCount; i++) {
+    consolevar_t *var = &CONSOLE.variables[i];
+    if(stringCompare(var->name, exec->argv[0]) != 0) continue;
+    consoleVarSetValue(var, exec->argv[1]);
+    consolePrint("%s %s", var->name, var->value);
+    for(i = 0; i < var->eventCount; i++) {
+      assertNotNull(var->events[i], "Event is NULL");
+      var->events[i](var);
+    }
+    return;
+  }
+
+  consolePrint("Error: Variable '%s' not found.", exec->argv[0]);
+}
+
+void cmdEcho(const consolecmdexec_t *exec) {
+  assertTrue(
+    exec->argc >= 1,
+    "echo command requires 1 argument."
+  );
+
+  consolePrint("%s", exec->argv[0]);
+}
+
+// May move these later
+void consoleUpdate() {
+  int32_t key = GetKeyPressed();
+
+  switch(key) {
+    case 0:
+      break;
+
+    case KEY_ENTER:
+      consoleExec(CONSOLE.inputBuffer);
+      CONSOLE.inputIndex = 0;
+      CONSOLE.inputBuffer[0] = '\0';
+      break;
+
+    case KEY_BACKSPACE:
+      if(CONSOLE.inputIndex > 0) {
+        CONSOLE.inputIndex--;
+        CONSOLE.inputBuffer[CONSOLE.inputIndex] = '\0';
+      }
+      break;
+
+    default:
+      if(key >= 32 && key <= 126 && CONSOLE.inputIndex < CONSOLE_LINE_MAX - 1) {
+        CONSOLE.inputBuffer[CONSOLE.inputIndex++] = (char_t)GetCharPressed();
+        CONSOLE.inputBuffer[CONSOLE.inputIndex] = '\0';
+      }
+      break;
+  }
+
+  consoleProcess();
+}
+
+void consoleDraw() {
+  size_t i = 0;
+  char_t *line;
+  int32_t fontSize = 10;
+  do {
+    line = CONSOLE.line[i];
+    if(line[0] == '\0') {
+      i++;
+      continue;
+    }
+    DrawText(line, 0, i*fontSize, fontSize, BLACK);
+    i++;
+  } while(i < CONSOLE_HISTORY_MAX);
+
+  DrawText(
+    CONSOLE.inputBuffer, 0,
+    (CONSOLE_HISTORY_MAX + 1) * fontSize,
+    fontSize,
+    BLACK
+  );
+}

src/console/console.h

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "consolevar.h"
+#include "consolecmd.h"
+
+typedef enum {
+  CONSOLE_EXEC_STATE_INITIAL,
+  CONSOLE_EXEC_STATE_PARSE_CMD,
+  CONSOLE_EXEC_STATE_CMD_PARSED,
+  
+  CONSOLE_EXEC_STATE_FIND_ARG,
+  CONSOLE_EXEC_STATE_PARSE_ARG,
+  CONSOLE_EXEC_STATE_PARSE_ARG_QUOTED,
+  CONSOLE_EXEC_STATE_ARG_PARSED,
+
+  CONSOLE_EXEC_STATE_CMD_FINISHED,
+  CONSOLE_EXEC_STATE_FULLY_PARSED
+} consoleexecstate_t;
+
+typedef struct {
+  consolecmd_t commands[CONSOLE_COMMANDS_MAX];
+  uint32_t commandCount;
+
+  consolevar_t variables[CONSOLE_VARIABLES_MAX];
+  uint32_t variableCount;
+
+  char_t line[CONSOLE_HISTORY_MAX][CONSOLE_LINE_MAX];
+
+  consolecmdexec_t execBuffer[CONSOLE_EXEC_BUFFER_MAX];
+  uint32_t execBufferCount;
+
+  consolecmd_t *cmdGet;
+  consolecmd_t *cmdSet;
+  pthread_mutex_t lock; // Mutex for thread safety
+
+  // May move these later
+  char_t inputBuffer[CONSOLE_LINE_MAX];
+  int32_t inputIndex;
+} console_t;
+
+extern console_t CONSOLE;
+
+/**
+ * Initializes the console.
+ */
+void consoleInit();
+
+/**
+ * Registers a console command.
+ * 
+ * @param name The name of the command.
+ * @param function The function to execute when the command is called.
+ * @return The registered command.
+ */
+consolecmd_t * consoleRegCmd(const char_t *name, consolecmdfunc_t function);
+
+/**
+ * Registers a console variable.
+ * 
+ * @param name The name of the variable.
+ * @param value The initial value of the variable.
+ * @param event The event to register.
+ * @return The registered variable.
+ */
+consolevar_t * consoleRegVar(
+  const char_t *name,
+  const char_t *value,
+  consolevarchanged_t event
+);
+
+/**
+ * Sets the value of a console variable.
+ * 
+ * @param name The name of the variable.
+ * @param value The new value of the variable.
+ */
+void consolePrint(
+  const char_t *message,
+  ...
+);
+
+/**
+ * Executes a console command.
+ * 
+ * @param line The line to execute.
+ */
+void consoleExec(const char_t *line);
+
+/**
+ * Processes the console's pending commands.
+ */
+void consoleProcess();
+
+/**
+ * Updates the console's input buffer and handles user input.
+ */
+void consoleUpdate();
+
+/**
+ * Draws the console's output.
+ */
+void consoleDraw();
+
+void cmdGet(const consolecmdexec_t *exec);
+void cmdSet(const consolecmdexec_t *exec);
+void cmdEcho(const consolecmdexec_t *exec);

src/console/consolecmd.c

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "consolecmd.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+
+void consoleCmdInit(
+  consolecmd_t *cmd,
+  const char_t *name,
+  consolecmdfunc_t function
+) {
+  assertNotNull(cmd, "Command is NULL.");
+  assertNotNull(name, "Name is NULL.");
+  assertNotNull(function, "Function is NULL.");
+  assertStrLenMin(name, 1, "Name is empty.");
+  assertStrLenMax(name, CONSOLE_CMD_NAME_MAX, "Name is too long.");
+
+  memoryZero(cmd, sizeof(consolecmd_t));
+  stringCopy(cmd->name, name, CONSOLE_CMD_NAME_MAX);
+  cmd->function = function;
+}

src/console/consolecmd.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "consoledefs.h"
+
+typedef struct consolecmd_s consolecmd_t;
+
+typedef struct {
+  consolecmd_t *cmd;
+  char_t command[CONSOLE_LINE_MAX];
+  char_t argv[CONSOLE_CMD_ARGC_MAX][CONSOLE_LINE_MAX];
+  uint32_t argc;
+} consolecmdexec_t;
+
+typedef void (*consolecmdfunc_t)(const consolecmdexec_t *exec);
+
+typedef struct consolecmd_s {
+  char_t name[CONSOLE_CMD_NAME_MAX];
+  consolecmdfunc_t function;
+} consolecmd_t;
+
+/**
+ * Initializes a console command.
+ * 
+ * @param cmd Pointer to the console command.
+ * @param name The name of the command.
+ * @param function The function to execute when the command is called.
+ */
+void consoleCmdInit(
+  consolecmd_t *cmd,
+  const char_t *name,
+  consolecmdfunc_t function
+);

src/console/consoledefs.h

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+
+#define CONSOLE_CMD_NAME_MAX 32
+#define CONSOLE_CMD_ARGC_MAX 16
+
+#define CONSOLE_COMMANDS_MAX 128
+#define CONSOLE_VARIABLES_MAX 128
+#define CONSOLE_LINE_MAX 256
+#define CONSOLE_HISTORY_MAX 32
+#define CONSOLE_EXEC_BUFFER_MAX 16
+
+#define CONSOLE_VAR_NAME_MAX 32
+#define CONSOLE_VAR_VALUE_MAX 128
+#define CONSOLE_VAR_EVENTS_MAX 8

src/console/consolevar.c

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "consolevar.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+
+void consoleVarInit(
+  consolevar_t *var,
+  const char_t *name,
+  const char_t *value
+) {
+  assertNotNull(var, "var must not be NULL");
+  assertNotNull(name, "name must not be NULL");
+  assertNotNull(value, "value must not be NULL");
+
+  assertStrLenMin(name, 1, "name must not be empty");
+  assertStrLenMax(name, CONSOLE_VAR_NAME_MAX, "name is too long");
+  assertStrLenMax(value, CONSOLE_VAR_VALUE_MAX, "value is too long");
+
+  memoryZero(var, sizeof(consolevar_t));
+  stringCopy(var->name, name, CONSOLE_VAR_NAME_MAX);
+  stringCopy(var->value, value, CONSOLE_VAR_VALUE_MAX);
+}
+
+void consoleVarInitListener(
+  consolevar_t *var,
+  const char_t *name,
+  const char_t *value,
+  consolevarchanged_t event
+) {
+  consoleVarInit(var, name, value);
+  if(event) consoleVarListen(var, event);
+}
+
+void consoleVarSetValue(consolevar_t *var, const char_t *value) {
+  assertNotNull(var, "var must not be NULL");
+  assertNotNull(value, "value must not be NULL");
+  assertStrLenMax(value, CONSOLE_VAR_VALUE_MAX, "value is too long");
+
+  stringCopy(var->value, value, CONSOLE_VAR_VALUE_MAX);
+  
+  uint8_t i = 0;
+  while (i < var->eventCount) {
+    var->events[i](var);
+    i++;
+  }
+}
+
+void consoleVarListen(consolevar_t *var, consolevarchanged_t event) {
+  assertNotNull(var, "var must not be NULL");
+  assertNotNull(event, "event must not be NULL");
+  assertTrue(
+    var->eventCount < CONSOLE_VAR_EVENTS_MAX,
+    "Event count is too high"
+  );
+  var->events[var->eventCount++] = event;
+}
+

src/console/consolevar.h

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dusk.h"
+#include "consoledefs.h"
+
+typedef struct consolevar_s consolevar_t;
+
+typedef void (*consolevarchanged_t)(const consolevar_t *var);
+
+typedef struct consolevar_s {
+  char_t name[CONSOLE_VAR_NAME_MAX];
+  char_t value[CONSOLE_VAR_VALUE_MAX];
+  consolevarchanged_t events[CONSOLE_VAR_EVENTS_MAX];
+  uint8_t eventCount;
+} consolevar_t;
+
+/**
+ * Initializes a console variable.
+ * 
+ * @param var Pointer to the console variable.
+ * @param name The name of the variable.
+ * @param value The initial value of the variable.
+ */
+void consoleVarInit(
+  consolevar_t *var,
+  const char_t *name,
+  const char_t *value
+);
+
+/**
+ * Initializes a console variable with a listener.
+ * 
+ * @param var Pointer to the console variable.
+ * @param name The name of the variable.
+ * @param value The initial value of the variable.
+ * @param event The event to register.
+ */
+void consoleVarInitListener(
+  consolevar_t *var,
+  const char_t *name,
+  const char_t *value,
+  consolevarchanged_t event
+);
+
+/**
+ * Sets the value of a console variable.
+ * 
+ * @param var Pointer to the console variable.
+ * @param value The new value of the variable.
+ */
+void consoleVarSetValue(consolevar_t *var, const char_t *value);
+
+/**
+ * Registers an event to be called when the value of a console variable changes.
+ * 
+ * @param var Pointer to the console variable.
+ * @param event The event to register.
+ */
+void consoleVarListen(consolevar_t *var, consolevarchanged_t event);