statusline api implemented

include/slash/slash.h

@@ -189,6 +189,10 @@ struct slash {
 	 * for instance, typing: "w<TAB>g<TAB>s<TAB>" would result in the completed command line "watch get serial0" in 6 keystrokes
 	 */
 	bool complete_in_completion;
+
+	/* Statusline */
+	bool statusline_enabled;   /* scroll region is active for statusline */
+	int statusline_rows;       /* terminal rows when scroll region was last set */
 };
 
 /**
@@ -207,6 +211,7 @@ void slash_destroy(struct slash *slash);
 char *slash_readline(struct slash *slash);
 
 void slash_sigint(struct slash *slash, int signum);
+void slash_sigwinch(struct slash *slash);
 
 /**
  * @brief Implement this function to do something with the current line (logging, etc)

include/slash/statusline.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <slash/slash.h>
+
+#define SLASH_STATUSLINE_MAX_ITEMS  16
+#define SLASH_STATUSLINE_KEY_SIZE   32
+#define SLASH_STATUSLINE_TEXT_SIZE  128
+
+typedef enum {
+    SLASH_STATUS_NORMAL = 0,
+    SLASH_STATUS_WARNING,
+    SLASH_STATUS_ERROR
+} slash_status_type_t;
+
+typedef struct {
+    slash_status_type_t type;
+    //int timeout_sec;
+    //bool blink;
+} slash_status_opts_t;
+
+/**
+ * @brief Set or update a statusline item by key with formatting and options.
+ * If key already exists, update its text and options. Otherwise add a new item.
+ *
+ * @param key        Identifier string (max 31 chars).
+ * @param opts_brace Configuration options wrapped in curly braces (e.g., { .type = SLASH_STATUS_ERROR }).
+ * Pass {0} to use default options (NORMAL type, no timeout).
+ * @param format     Printf-style format string for the display text (rendered max 127 chars).
+ * @param ...        Variadic arguments matching the format string.
+ * @return 0 on success, -1 if no space available.
+ * * @note This is a macro that wraps slash_statusline_set_impl to allow inline struct initialization.
+ */
+int _slash_statusline_set_impl(const char *key, const slash_status_opts_t *opts, const char *format, ...) __attribute__((format(printf, 3, 4)));
+
+#define slash_statusline_set(key, opts_brace, ...) \
+    _slash_statusline_set_impl(key, &(slash_status_opts_t)opts_brace, __VA_ARGS__)
+
+/**
+ * @brief Remove a statusline item by key.
+ * @param key   Identifier string to remove
+ * @return 0 on success, -1 if key not found
+ */
+int slash_statusline_remove(const char *key);
+
+/**
+ * @brief Get the number of active statusline items.
+ * @return count of active items
+ */
+int slash_statusline_count(void);
+
+/**
+ * @brief Render the statusline content to the terminal.
+ *        Called internally by slash_refresh(). Not normally called by users.
+ * @param slash  Slash context (for slash_write)
+ */
+void slash_statusline_render(struct slash *slash);

meson.build

@@ -6,6 +6,7 @@ slash_sources = files([
 	'src/completer.c',
 	'src/optparse.c',
 	'src/slash_list.c',
+	'src/statusline.c',
 	])
 
 if get_option('builtins')

src/slash.c

@@ -24,6 +24,7 @@
 #include <slash/slash.h>
 #include <slash/optparse.h>
 #include <slash/completer.h>
+#include <slash/statusline.h>
 
 #include <dlfcn.h>
 #include <stdio.h>
@@ -48,6 +49,10 @@
 #include <sys/select.h>
 #endif
 
+#ifdef SLASH_HAVE_TERMIOS_H
+#include <sys/ioctl.h>
+#endif
+
 #include "builtins.h"
 
 /* Terminal codes */
@@ -137,31 +142,92 @@ static int slash_rawmode_disable(struct slash *slash)
 	return 0;
 }
 
+static void slash_statusline_activate(struct slash *slash)
+{
+#ifdef SLASH_HAVE_TERMIOS_H
+	struct winsize ws;
+	if (ioctl(slash->fd_write, TIOCGWINSZ, &ws) == -1)
+		return;
+
+	int rows = ws.ws_row;
+	char esc[32];
+
+	//Set scroll region to all rows except the last.
+	//DECSTBM resets cursor to (1,1) per VT100 spec.
+	snprintf(esc, sizeof(esc), "\033[1;%dr", rows - 1);
+	slash_write(slash, esc, strlen(esc));
+
+	// Move cursor to bottom of scroll region (prompt row)
+	snprintf(esc, sizeof(esc), "\033[%d;1H", rows - 1);
+	slash_write(slash, esc, strlen(esc));
+
+	// Draw statusline on the reserved bottom row
+	slash_write(slash, "\0337", 2);  // DEC save cursor
+	snprintf(esc, sizeof(esc), "\033[%d;1H", rows);
+	slash_write(slash, esc, strlen(esc));
+	slash_statusline_render(slash);
+	slash_write(slash, "\0338", 2);  // DEC restore cursor
+
+	slash->statusline_enabled = true;
+	slash->statusline_rows = rows;
+#endif
+}
+
+static void slash_statusline_deactivate(struct slash *slash)
+{
+#ifdef SLASH_HAVE_TERMIOS_H
+	if (!slash->statusline_enabled)
+		return;
+
+	char esc[32];
+
+	// Save cursor so we can restore after scroll region reset
+	slash_write(slash, "\0337", 2);
+
+	// Clear the statusline row
+	snprintf(esc, sizeof(esc), "\033[%d;1H\033[K", slash->statusline_rows);
+	slash_write(slash, esc, strlen(esc));
+
+	// Reset scroll region to full terminal (moves cursor to 1,1)
+	slash_write(slash, "\033[r", 3);
+
+	// Restore cursor to where it was
+	slash_write(slash, "\0338", 2);
+
+	slash->statusline_enabled = false;
+#endif
+}
+
 static int slash_configure_term(struct slash *slash)
 {
 	if (slash_rawmode_enable(slash) < 0)
 		return -ENOTTY;
 
+	if (slash_statusline_count() > 0)
+		slash_statusline_activate(slash);
+
 	return 0;
 }
 
 static int slash_restore_term(struct slash *slash)
 {
+	slash_statusline_deactivate(slash);
+
 	if (slash_rawmode_disable(slash) < 0)
 		return -ENOTTY;
 
 	return 0;
 }
 
 static int slash_wait_select(void *slashp, unsigned int ms);
-void slash_acquire_std_in_out(struct slash *slash) {	
+void slash_acquire_std_in_out(struct slash *slash) {
 	slash_configure_term(slash);
 #ifdef SLASH_HAVE_SELECT
 	slash->waitfunc = slash_wait_select;
 #endif
 }
 
-void slash_release_std_in_out(struct slash *slash) {	
+void slash_release_std_in_out(struct slash *slash) {
 	slash_restore_term(slash);
 #ifdef SLASH_HAVE_SELECT
 	slash->waitfunc = NULL;
@@ -175,7 +241,11 @@ int slash_write(struct slash *slash, const char *buf, size_t count)
 
 static int slash_read(struct slash *slash, void *buf, size_t count)
 {
-	return read(slash->fd_read, buf, count);
+	int ret;
+	do {
+		ret = read(slash->fd_read, buf, count);
+	} while (ret < 0 && errno == EINTR);
+	return ret;
 }
 
 int slash_putchar(struct slash *slash, char c)
@@ -813,6 +883,29 @@ int slash_refresh(struct slash *slash, int printtime)
 	if (slash_write(slash, esc, strlen(esc)) < 0)
 		return -1;
 
+	/* Update statusline on the fixed bottom row */
+#ifdef SLASH_HAVE_TERMIOS_H
+	if (slash_statusline_count() > 0) {
+		if (!slash->statusline_enabled) {
+			slash_statusline_activate(slash);
+			/* Activation moved cursor; re-run refresh at new position */
+			return slash_refresh(slash, printtime);
+		}
+		struct winsize ws;
+		if (ioctl(slash->fd_write, TIOCGWINSZ, &ws) == 0 &&
+		    ws.ws_row != slash->statusline_rows) {
+			slash_statusline_activate(slash);
+			return slash_refresh(slash, printtime);
+		}
+		char pos[16];
+		slash_write(slash, "\0337", 2);  /* DEC save cursor */
+		snprintf(pos, sizeof(pos), "\033[%d;1H", slash->statusline_rows);
+		slash_write(slash, pos, strlen(pos));
+		slash_statusline_render(slash);
+		slash_write(slash, "\0338", 2);  /* DEC restore cursor */
+	}
+#endif
+
 	return 0;
 }
 
@@ -918,17 +1011,24 @@ static void slash_swap(struct slash *slash)
 void slash_clear_screen(struct slash *slash) {
 	const char *esc = ESCAPE("H") ESCAPE("2J");
 	slash_write(slash, esc, strlen(esc));
+	/* Force statusline scroll region re-setup on next refresh */
+	slash->statusline_enabled = false;
 }
 
 void slash_sigint(struct slash *slash, int signum) {
 	if (slash->busy) {
 		slash->signal = signum;
 	} else {
-		slash_reset(slash);	
+		slash_reset(slash);
 		slash_refresh(slash, 0);
 	}
 }
 
+void slash_sigwinch(struct slash *slash) {
+	slash->statusline_enabled = false;  /* force scroll region re-setup */
+	slash_refresh(slash, 0);
+}
+
 #include <stdlib.h>
 char *slash_readline(struct slash *slash)
 {
@@ -1153,6 +1253,11 @@ int slash_loop(struct slash *slash)
 		if (!slash_line_empty(line, strlen(line))) {
 			/* Run command */
 			ret = slash_execute(slash, line);
+			#ifdef SLASH_HAVE_TERMIOS_H
+			if(ret != SLASH_SUCCESS) {
+				slash_statusline_set("slash", {.type = SLASH_STATUS_ERROR},"FAILED: %s", line);
+			}
+			#endif
 			if (ret == SLASH_EXIT)
 				break;
 		}
@@ -1239,6 +1344,7 @@ void slash_create_static(struct slash *slash, char * line_buf, size_t line_size,
     slash->cmd_list = 0;
 
 	slash->complete_in_completion = true;
+	slash->statusline_enabled = false;
 
 	tcgetattr(slash->fd_read, &slash->original);
 }