fix up old kinput subsystem

Author: braindigitalis

include/basic/context.h

@@ -9,6 +9,7 @@
 #include "buddy_allocator.h"
 #include "audio.h"
 #include "data.h"
+#include <input.h>
 
 typedef enum memory_model_t {
 	mm_small = 25,
@@ -168,6 +169,11 @@ typedef struct basic_ctx {
 	 */
 	const char* error_handler;
 
+	/**
+	 * @brief Context for INPUT statement
+	 */
+	buffered_input_context_t input;
+
 	/**
 	 * @brief True if the program has "claimed flipping".
 	 *

include/input.h

@@ -1,80 +1,81 @@
 /**
  * @file input.h
  * @author Craig Edwards (craigedwards@brainbox.cc)
- * @brief Console line input API for Retro Rocket.
- * @copyright Copyright (c) 2012-2026
+ * @brief Simple line input API backed by a per-context buffer.
  *
- * This interface provides buffered, line-based input for consoles. It handles
- * character input, backspace editing, line completion detection, and safe
- * buffer allocation. The functions in this header are backed by the
- * implementation in @ref input.c.
+ * Provides minimal, line-based input suitable for BASIC `INPUT` and
+ * similar use cases. Input is accumulated into a caller-owned context
+ * and completed when a carriage return is received.
  *
- * ## Usage Lifecycle
- * 1. Call `kinput(maxlen, cons)` repeatedly until it returns `1` (line complete).
- * 2. Retrieve the full line with `kgetinput(cons)`.
- * 3. Process the string as needed.
- * 4. Call `kfreeinput(cons)` when finished to release the internal buffer.
- *
- * The buffer is lazily allocated by `kinput()` when the first character arrives,
- * so you must not call `kgetinput()` until after at least one successful call to
- * `kinput()`.
+ * ## Usage
+ * 1. Initialise with `kinitinput(ctx)`.
+ * 2. Call `kinput(ctx)` until it returns true (line complete).
+ * 3. Read the line with `kgetinput(ctx)`.
+ * 4. Call `kfreeinput(ctx)` when finished.
  *
  * ## Behaviour
- * - Input is null-terminated automatically.
- * - Carriage return (`'\r'`) signals end-of-line and is echoed as newline (`'\n'`).
- * - Backspace (`8`) removes the previous character (with console cursor handling).
- * - Arrow keys (↑ ↓ ← →) are recognised but ignored.
- * - If the buffer limit is reached, no more characters are added and a beep is
- *   emitted as feedback.
- *
- * @note This input API is retained primarily to support the BASIC INPUT
- *       statement and similar minimal line-reading requirements. Modern
- *       interactive shells and tools use the ANSI console library, which
- *       provides line editing, history, and richer input handling.
+ * - Input is null-terminated.
+ * - `'\r'` completes the line and is echoed as `'\n'`.
+ * - Backspace (`8`) deletes the previous character with cursor update.
+ * - Arrow keys are ignored.
+ * - Buffer grows dynamically as needed.
  *
- *       `kinput()` is intentionally simple and blocking; it does not support
- *       advanced editing or multiple input sources.
+ * @note This API is polled and intended for cooperative scheduling.
+ *       It performs no advanced line editing.
  */
 
 #pragma once
 
+struct basic_ctx;
+
 /**
- * @brief Poll for a single character of input from the console.
+ * @brief Per-input context state.
  *
- * This function reads a single character from the console associated
- * with the specified process, storing it in the input buffer.
- *
- * When the user completes a line (e.g. by pressing Enter), the function
- * returns 1 to indicate the input line is ready for retrieval.
- * Until then, it returns 0, allowing the caller to yield or retry later.
+ * Stores the buffer and cursor state for a single line input operation.
+ */
+typedef struct buffered_input_context_t {
+	bool stopped;		/**< Line completion flag */
+	uint8_t last;		/**< Last character read */
+	char* internalbuffer;	/**< Base pointer to allocated buffer */
+	char* buffer;		/**< Current write pointer */
+	size_t bufcnt;		/**< Number of characters in buffer */
+	size_t buflen;		/**< Allocated buffer size */
+} buffered_input_context_t;
+
+/**
+ * @brief Initialise an input context.
  *
- * @note This function is typically called repeatedly inside a loop or
- * idle callback, until a full line of input is received.
+ * Clears all state. Must be called before first use.
  *
- * @param maxlen Maximum length of the input line.
- * @param cons Console to read input from.
- * @return 1 if a full line is available, 0 otherwise.
+ * @param ctx Input context
  */
-size_t kinput(size_t maxlen);
+void kinitinput(struct buffered_input_context_t* ctx);
 
 /**
- * @brief Free the internal input buffer associated with a console.
+ * @brief Poll for input and update the buffer.
+ *
+ * Reads a single character and updates the context buffer.
  *
- * This function releases the memory used to store a pending line of
- * input for the specified console. It should be called after input
- * has been processed, to prevent memory leaks and prepare the console
- * for the next `kinput()` cycle.
+ * @param basic BASIC context
+ * @param ctx Input context
+ * @return true if a full line has been entered, false otherwise
+ */
+bool kinput(struct basic_ctx* basic, struct buffered_input_context_t* ctx);
+
+/**
+ * @brief Free any allocated input buffer and reset the context.
  *
- * @param cons Console whose input buffer should be freed.
+ * @param basic BASIC context
+ * @param ctx Input context
  */
-void kfreeinput();
+void kfreeinput(struct basic_ctx* basic, struct buffered_input_context_t* ctx);
 
 /**
- * @brief Retrieve the accumulated input string for a console.
+ * @brief Get the current input buffer.
  *
- * @param cons Pointer to the console.
- * @return Pointer to the null-terminated input string, or NULL if no buffer exists.
+ * @param ctx Input context
+ * @return Pointer to null-terminated string, or NULL if not initialised
  *
- * @warning Do not free the returned pointer directly; use @ref kfreeinput().
+ * @warning Do not free the returned pointer directly
  */
-char* kgetinput();
+const char* kgetinput(struct buffered_input_context_t* ctx);

src/basic/console.c

@@ -83,21 +83,23 @@ int64_t basic_capslock(struct basic_ctx* ctx)
 /**
  * Check if input is complete yet
  * @param proc process
+ * @param opaque BASIC context
  * @return true if input is still waiting for completion, false if done
  */
 bool check_input_in_progress(process_t* proc, void* opaque)
 {
+	basic_ctx* ctx = opaque;
 	if (basic_esc()) {
 		return false;
 	}
-	return kinput(MAX_STRINGLEN) == 0;
+	return kinput(ctx, &ctx->input) == 0;
 }
 
 /**
  * @brief Deferred cooperative input via idle process callback.
  *
  * When a BASIC `INPUT` statement is encountered, the interpreter checks whether
- * a complete line of user input is available via `kinput()`. If not, the process
+ * a complete line of user input is available via `kinput(ctx, )`. If not, the process
  * voluntarily yields using `proc_set_idle()` and assigns a custom callback
  * (`check_input_in_progress`) to periodically test for input readiness.
  *
@@ -120,9 +122,9 @@ void input_statement(struct basic_ctx* ctx)
 
 	process_t* proc = ctx->proc;
 
-	/* Clear buffer */
-	if (kinput(MAX_STRINGLEN) == 0) {
-		proc_set_idle(proc, check_input_in_progress, NULL);
+	/* Poll for pending input */
+	if (kinput(ctx, &ctx->input) == 0) {
+		proc_set_idle(proc, check_input_in_progress, ctx);
 		jump_linenum(ctx->current_linenum, ctx);
 		proc->state = PROC_IO_BOUND;
 		return;
@@ -132,44 +134,44 @@ void input_statement(struct basic_ctx* ctx)
 
 	if (varname_is_int_array_access(ctx, var)) {
 		int64_t index = arr_target_index(ctx);
-		int64_t value = atoll(kgetinput(), 10);
+		int64_t value = atoll(kgetinput(&ctx->input), 10);
 
 		if (index == -1) {
 			basic_set_int_array(var, value, ctx);
 		} else {
 			basic_set_int_array_variable(var, index, value, ctx);
 		}
 
-		kfreeinput();
+		kfreeinput(ctx, &ctx->input);
 		accept_or_return(NEWLINE, ctx);
 		proc->state = PROC_RUNNING;
 		return;
 	} else if (varname_is_string_array_access(ctx, var)) {
 		int64_t index = arr_target_index(ctx);
-		const char* value = kgetinput();
+		const char* value = kgetinput(&ctx->input);
 
 		if (index == -1) {
 			basic_set_string_array(var, value, ctx);
 		} else {
 			basic_set_string_array_variable(var, index, value, ctx);
 		}
 
-		kfreeinput();
+		kfreeinput(ctx, &ctx->input);
 		accept_or_return(NEWLINE, ctx);
 		proc->state = PROC_RUNNING;
 		return;
 	} else if (varname_is_double_array_access(ctx, var)) {
 		int64_t index = arr_target_index(ctx);
 		double value = 0;
-		atof(kgetinput(), &value);
+		atof(kgetinput(&ctx->input), &value);
 
 		if (index == -1) {
 			basic_set_double_array(var, value, ctx);
 		} else {
 			basic_set_double_array_variable(var, index, value, ctx);
 		}
 
-		kfreeinput();
+		kfreeinput(ctx, &ctx->input);
 		accept_or_return(NEWLINE, ctx);
 		proc->state = PROC_RUNNING;
 		return;
@@ -179,21 +181,21 @@ void input_statement(struct basic_ctx* ctx)
 
 	switch (var[var_length - 1]) {
 		case '$':
-			basic_set_string_variable(var, kgetinput(), ctx, false, false);
+			basic_set_string_variable(var, kgetinput(&ctx->input), ctx, false, false);
 			break;
 
 		case '#': {
 			double f = 0;
-			atof(kgetinput(), &f);
+			atof(kgetinput(&ctx->input), &f);
 			basic_set_double_variable(var, f, ctx, false, false);
 			break;
 		}
 
 		default:
-			basic_set_int_variable(var, atoll(kgetinput(), 10), ctx, false, false);
+			basic_set_int_variable(var, atoll(kgetinput(&ctx->input), 10), ctx, false, false);
 			break;
 	}
-	kfreeinput();
+	kfreeinput(ctx, &ctx->input);
 	accept_or_return(NEWLINE, ctx);
 	proc->state = PROC_RUNNING;
 }
@@ -647,9 +649,9 @@ char* printable_syntax(struct basic_ctx* ctx)
 		return NULL;
 	}
 
-	char* result = gc_strdup(ctx, out);
+	const char* result = gc_strdup(ctx, out);
 	buddy_free(ctx->allocator, out);
-	return result;
+	return (char*)result;
 }
 
 void keymap_statement(struct basic_ctx* ctx)

src/basic/main.c

@@ -304,6 +304,7 @@ struct basic_ctx *basic_init(const char *program, uint32_t pid, const char *file
 	memset(&ctx->last_packet, 0, sizeof(queued_udp_packet));
 	memset(&ctx->audio_streams, 0, sizeof(ctx->audio_streams));
 	memset(&ctx->envelopes, 0, sizeof(ctx->envelopes));
+	kinitinput(&ctx->input);
 	ctx->sounds = NULL;
 	ctx->if_nest_level = 0;
 	ctx->errored = false;
@@ -552,6 +553,7 @@ struct basic_ctx *basic_clone(struct basic_ctx *old) {
 	ctx->sleep_until = old->sleep_until;
 	ctx->match_ctx = NULL;
 	ctx->proc = old->proc;
+	kinitinput(&ctx->input);
 	memset(&ctx->last_packet, 0, sizeof(queued_udp_packet));
 	ctx->int_variables = old->int_variables;
 	ctx->str_variables = old->str_variables;