HomePhorge
Diffusion Ant (mir/inline-method) Code

ant/src/readline.c
3fa05edd2fe3mir/inline-method

Last Change
Raw File

readline.c
View Options

#include <ctype.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#ifdef _WIN32
#include <conio.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <direct.h>
#define STDIN_FILENO 0
#define mkdir_p(path) _mkdir(path)
#else
#include <sys/ioctl.h>
#include <termios.h>
#include <unistd.h>
#define mkdir_p(path) mkdir(path, 0755)
#endif
#include <crprintf.h>
#include "highlight.h"
#include "readline.h"
#include "utf8.h"
#define MAX_LINE_LENGTH 4096
static volatile sig_atomic_t ctrl_c_pressed = 0;
static crprintf_compiled *hl_prog = NULL;
static highlight_state hl_line_state = HL_STATE_INIT;
static int repl_last_cursor_row = 0;
static void sigint_handler(int sig) {
(void)sig;
ctrl_c_pressed++;
}
void ant_readline_install_signal_handler(void) {
#ifdef _WIN32
signal(SIGINT, sigint_handler);
#else
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigint_handler;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
#endif
}
void ant_readline_shutdown(void) {
if (hl_prog) {
crprintf_compiled_free(hl_prog);
hl_prog = NULL;
}
}
void ant_history_init(ant_history_t *hist, int capacity) {
hist->capacity = (capacity > 0) ? capacity : 512;
hist->lines = malloc(sizeof(char *) * (size_t)hist->capacity);
if (!hist->lines) hist->capacity = 0;
hist->count = 0;
hist->current = -1;
}
void ant_history_add(ant_history_t *hist, const char *line) {
if (!hist || !hist->lines || hist->capacity <= 0 || !line || line[0] == '\0') return;
if (hist->count > 0 && strcmp(hist->lines[hist->count - 1], line) == 0) return;
if (hist->count >= hist->capacity) {
free(hist->lines[0]);
memmove(hist->lines, hist->lines + 1, sizeof(char *) * (size_t)(hist->capacity - 1));
hist->count--;
}
hist->lines[hist->count++] = strdup(line);
hist->current = hist->count;
}
const char *ant_history_prev(ant_history_t *hist) {
if (!hist || !hist->lines || hist->count == 0) return NULL;
if (hist->current > 0) hist->current--;
return hist->lines[hist->current];
}
const char *ant_history_next(ant_history_t *hist) {
if (!hist || !hist->lines || hist->count == 0) return NULL;
if (hist->current < hist->count - 1) {
hist->current++;
return hist->lines[hist->current];
}
hist->current = hist->count;
return "";
}
void ant_history_free(ant_history_t *hist) {
if (!hist || !hist->lines) return;
for (int i = 0; i < hist->count; i++) free(hist->lines[i]);
free(hist->lines);
hist->lines = NULL;
hist->count = 0;
hist->capacity = 0;
hist->current = -1;
}
static char *get_history_path(void) {
const char *home = getenv("HOME");
if (!home) home = getenv("USERPROFILE");
if (!home) return NULL;
size_t len = strlen(home) + 32;
char *path = malloc(len);
snprintf(path, len, "%s/.ant", home);
mkdir_p(path);
snprintf(path, len, "%s/.ant/repl_history", home);
return path;
}
void ant_history_load(ant_history_t *hist) {
if (!hist || !hist->lines || hist->capacity <= 0) return;
char *path = get_history_path();
if (!path) return;
FILE *fp = fopen(path, "r");
free(path);
if (!fp) return;
char line[MAX_LINE_LENGTH];
while (fgets(line, sizeof(line), fp)) {
size_t len = strlen(line);
if (len > 0 && line[len - 1] == '\n') line[len - 1] = '\0';
if (line[0]) ant_history_add(hist, line);
}
fclose(fp);
}
void ant_history_save(const ant_history_t *hist) {
if (!hist || !hist->lines) return;
char *path = get_history_path();
if (!path) return;
FILE *fp = fopen(path, "w");
free(path);
if (!fp) return;
for (int i = 0; i < hist->count; i++) {
fprintf(fp, "%s\n", hist->lines[i]);
}
fclose(fp);
}
typedef enum {
KEY_NONE, KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT,
KEY_HOME, KEY_END, KEY_DELETE, KEY_BACKSPACE, KEY_ENTER, KEY_EOF, KEY_CHAR
} key_type_t;
typedef struct {
key_type_t type;
int ch;
} key_event_t;
static int repl_terminal_cols(void) {
int cols = 80;
#ifdef _WIN32
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) {
cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
}
#else
struct winsize ws;
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) {
cols = ws.ws_col;
}
#endif
return (cols > 0) ? cols : 80;
}
static void repl_jump_cursor(int x_pos, int y_offset) {
#ifdef _WIN32
if (y_offset != 0) {
char seq[32];
snprintf(seq, sizeof(seq), "\033[%d%c", abs(y_offset), (y_offset > 0) ? 'B' : 'A');
fputs(seq, stdout);
}
char seq[32];
snprintf(seq, sizeof(seq), "\033[%dG", x_pos + 1);
fputs(seq, stdout);
#else
if (y_offset != 0) {
char seq[32];
snprintf(seq, sizeof(seq), "\033[%d%c", abs(y_offset), (y_offset > 0) ? 'B' : 'A');
fputs(seq, stdout);
}
char seq[32];
snprintf(seq, sizeof(seq), "\033[%dG", x_pos + 1);
fputs(seq, stdout);
#endif
}
static void repl_clear_to_end(void) {
fputs("\033[J", stdout);
}
static void repl_set_cursor_visible(bool visible) {
#ifdef _WIN32
(void)visible;
#else
fputs(visible ? "\033[?25h" : "\033[?25l", stdout);
#endif
}
static size_t repl_skip_ansi_escape(const char *s, size_t len, size_t i) {
if (i >= len || (unsigned char)s[i] != 0x1B) return i;
if (i + 1 >= len) return i + 1;
unsigned char next = (unsigned char)s[i + 1];
if (next == '[') {
i += 2;
while (i < len) {
unsigned char ch = (unsigned char)s[i++];
if (ch >= 0x40 && ch <= 0x7E) break;
}
return i;
}
if (next == ']') {
i += 2;
while (i < len) {
unsigned char ch = (unsigned char)s[i];
if (ch == '\a') return i + 1;
if (ch == 0x1B && i + 1 < len && s[i + 1] == '\\') return i + 2;
i++;
}
return i;
}
return i + 2;
}
static void repl_virtual_render(
const char *s, size_t n,
int screen_cols, int prompt_len,
int *x, int *y
) {
bool wrapped = false;
size_t i = 0;
while (i < n) {
unsigned char c = (unsigned char)s[i];
if (c == '\n' || c == '\r') {
if (c == '\n' && !wrapped) (*y)++;
*x = prompt_len;
i++;
wrapped = false;
continue;
}
if (c == 0x1B) {
i = repl_skip_ansi_escape(s, n, i);
continue;
}
utf8proc_int32_t cp = 0;
utf8proc_ssize_t clen =
utf8_next((const utf8proc_uint8_t *)(s + i), (utf8proc_ssize_t)(n - i), &cp);
if (clen <= 0) {
clen = 1;
cp = c;
}
int w = utf8proc_charwidth(cp);
if (w < 0) w = 1;
if (w > 0) {
*x += w;
wrapped = false;
if (*x >= screen_cols) {
*x = 0;
(*y)++;
wrapped = true;
}
}
i += (size_t)clen;
}
}
static int repl_prompt_width(const char *prompt, int cols) {
int x = 0;
int y = 0;
repl_virtual_render(prompt, strlen(prompt), cols, 0, &x, &y);
return x;
}
static void refresh_line(const char *line, int len, int pos, const char *prompt) {
int cols = repl_terminal_cols();
int prompt_len = repl_prompt_width(prompt, cols);
int x_cursor = prompt_len;
int y_cursor = 0;
int x_end = prompt_len;
int y_end = 0;
repl_virtual_render(line, (size_t)pos, cols, prompt_len, &x_cursor, &y_cursor);
repl_virtual_render(line, (size_t)len, cols, prompt_len, &x_end, &y_end);
repl_set_cursor_visible(false);
repl_jump_cursor(prompt_len, -repl_last_cursor_row);
repl_clear_to_end();
if (crprintf_get_color() && len > 0) {
if (len <= 2048) {
char tagged[8192];
char rendered[8192];
highlight_state state = hl_line_state;
ant_highlight_stateful(line, (size_t)len, tagged, sizeof(tagged), &state);
hl_prog = crprintf_recompile(hl_prog, tagged);
crprintf_state *rs = crprintf_state_new();
crsprintf_compiled(rendered, sizeof(rendered), rs, hl_prog);
crprintf_state_free(rs);
fputs(rendered, stdout);
} else fwrite(line, 1, (size_t)len, stdout);
} else if (len > 0) fwrite(line, 1, (size_t)len, stdout);
#ifndef _WIN32
if ((x_end == 0) && (y_end > 0) && (len > 0) && (line[len - 1] != '\n')) {
fputs("\n", stdout);
}
#endif
repl_jump_cursor(x_cursor, -(y_end - y_cursor));
repl_set_cursor_visible(true);
repl_last_cursor_row = y_cursor;
fflush(stdout);
}
static void move_cursor_only(const char *line, int pos, const char *prompt) {
int cols = repl_terminal_cols();
int prompt_len = repl_prompt_width(prompt, cols);
int x_cursor = prompt_len;
int y_cursor = 0;
repl_virtual_render(line, (size_t)pos, cols, prompt_len, &x_cursor, &y_cursor);
repl_jump_cursor(x_cursor, -(repl_last_cursor_row - y_cursor));
repl_last_cursor_row = y_cursor;
fflush(stdout);
}
static int utf8_prev_pos(const char *line, int pos) {
if (pos <= 0) return 0;
int prev = 0;
int i = 0;
while (i < pos) {
prev = i;
utf8proc_int32_t cp = 0;
utf8proc_ssize_t n = utf8_next(
(const utf8proc_uint8_t *)(line + i),
(utf8proc_ssize_t)(pos - i),
&cp
);
i += (int)((n > 0) ? n : 1);
}
return prev;
}
static int utf8_next_pos(const char *line, int len, int pos) {
if (pos >= len) return len;
utf8proc_int32_t cp = 0;
utf8proc_ssize_t n = utf8_next(
(const utf8proc_uint8_t *)(line + pos),
(utf8proc_ssize_t)(len - pos),
&cp
);
int next = pos + (int)((n > 0) ? n : 1);
return (next > len) ? len : next;
}
static void line_set(char *line, int *pos, int *len, const char *str, const char *prompt) {
size_t n = strlen(str);
if (n >= (size_t)MAX_LINE_LENGTH) n = (size_t)MAX_LINE_LENGTH - 1;
memcpy(line, str, n);
line[n] = '\0';
*len = (int)strlen(line);
*pos = *len;
refresh_line(line, *len, *pos, prompt);
}
static void line_backspace(char *line, int *pos, int *len, const char *prompt) {
if (*pos <= 0) return;
int prev = utf8_prev_pos(line, *pos);
memmove(line + prev, line + *pos, (size_t)(*len - *pos + 1));
*len -= (*pos - prev);
*pos = prev;
refresh_line(line, *len, *pos, prompt);
}
static void line_delete(char *line, int *pos, int *len, const char *prompt) {
if (*pos >= *len) return;
int next = utf8_next_pos(line, *len, *pos);
memmove(line + *pos, line + next, (size_t)(*len - next + 1));
*len -= (next - *pos);
refresh_line(line, *len, *pos, prompt);
}
static void line_insert(char *line, int *pos, int *len, int c, const char *prompt) {
if (*len >= MAX_LINE_LENGTH - 1) return;
memmove(line + *pos + 1, line + *pos, (size_t)(*len - *pos + 1));
line[*pos] = (char)c;
(*pos)++;
(*len)++;
refresh_line(line, *len, *pos, prompt);
}
#ifdef _WIN32
static key_event_t read_key(void) {
if (ctrl_c_pressed > 0) return (key_event_t){ KEY_EOF, 0 };
int c = _getch();
if (c == 0 || c == 0xE0) {
int ext = _getch();
switch (ext) {
case 72: return (key_event_t){ KEY_UP, 0 };
case 80: return (key_event_t){ KEY_DOWN, 0 };
case 77: return (key_event_t){ KEY_RIGHT, 0 };
case 75: return (key_event_t){ KEY_LEFT, 0 };
case 71: return (key_event_t){ KEY_HOME, 0 };
case 79: return (key_event_t){ KEY_END, 0 };
case 83: return (key_event_t){ KEY_DELETE, 0 };
default: return (key_event_t){ KEY_NONE, 0 };
}
}
if (c == 8) return (key_event_t){ KEY_BACKSPACE, 0 };
if (c == '\r' || c == '\n') return (key_event_t){ KEY_ENTER, 0 };
if (c == 3) {
ctrl_c_pressed++;
return (key_event_t){ KEY_EOF, 0 };
}
if (c == 4 || c == 26) return (key_event_t){ KEY_EOF, 0 };
if (isprint(c) || (unsigned char)c >= 0x80) return (key_event_t){ KEY_CHAR, c };
return (key_event_t){ KEY_NONE, 0 };
}
#else
static struct termios saved_tio;
static key_event_t read_key(void) {
if (ctrl_c_pressed > 0) return (key_event_t){ KEY_EOF, 0 };
int c = getchar();
if (c == EOF && !feof(stdin)) {
clearerr(stdin);
return (key_event_t){ KEY_EOF, 0 };
}
if (c == EOF) return (key_event_t){ KEY_EOF, 0 };
if (c == 27) {
int seq1 = getchar();
if (seq1 == EOF) return (key_event_t){ KEY_NONE, 0 };
if (seq1 == 'O') {
int seq2 = getchar();
if (seq2 == 'H') return (key_event_t){ KEY_HOME, 0 };
if (seq2 == 'F') return (key_event_t){ KEY_END, 0 };
return (key_event_t){ KEY_NONE, 0 };
}
if (seq1 != '[') return (key_event_t){ KEY_NONE, 0 };
int seq2 = getchar();
if (seq2 == EOF) return (key_event_t){ KEY_NONE, 0 };
switch (seq2) {
case 'A': return (key_event_t){ KEY_UP, 0 };
case 'B': return (key_event_t){ KEY_DOWN, 0 };
case 'C': return (key_event_t){ KEY_RIGHT, 0 };
case 'D': return (key_event_t){ KEY_LEFT, 0 };
case 'H': return (key_event_t){ KEY_HOME, 0 };
case 'F': return (key_event_t){ KEY_END, 0 };
default: {
if (seq2 >= '0' && seq2 <= '9') {
int seq3 = getchar();
if (seq3 == '~') {
if (seq2 == '1' || seq2 == '7') return (key_event_t){ KEY_HOME, 0 };
if (seq2 == '4' || seq2 == '8') return (key_event_t){ KEY_END, 0 };
if (seq2 == '3') return (key_event_t){ KEY_DELETE, 0 };
}
}
return (key_event_t){ KEY_NONE, 0 };
}
}
}
if (c == 127 || c == 8) return (key_event_t){ KEY_BACKSPACE, 0 };
if (c == '\n' || c == '\r') return (key_event_t){ KEY_ENTER, 0 };
if (isprint(c) || (unsigned char)c >= 0x80) return (key_event_t){ KEY_CHAR, c };
return (key_event_t){ KEY_NONE, 0 };
}
#endif
static void term_restore(void) {
#ifndef _WIN32
tcsetattr(STDIN_FILENO, TCSANOW, &saved_tio);
#endif
}
static char *read_line_with_history(ant_history_t *hist, const char *prompt) {
char *line = malloc(MAX_LINE_LENGTH);
if (!line) return NULL;
int pos = 0;
int len = 0;
line[0] = '\0';
repl_last_cursor_row = 0;
#ifndef _WIN32
struct termios new_tio;
tcgetattr(STDIN_FILENO, &saved_tio);
new_tio = saved_tio;
new_tio.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &new_tio);
#endif
for (;;) {
key_event_t key = read_key();
static const void *dispatch[] = {
[KEY_NONE] = &&l_none,
[KEY_UP] = &&l_up,
[KEY_DOWN] = &&l_down,
[KEY_LEFT] = &&l_left,
[KEY_RIGHT] = &&l_right,
[KEY_HOME] = &&l_home,
[KEY_END] = &&l_end,
[KEY_DELETE] = &&l_delete,
[KEY_BACKSPACE] = &&l_backspace,
[KEY_ENTER] = &&l_enter,
[KEY_EOF] = &&l_eof,
[KEY_CHAR] = &&l_char,
};
unsigned int t = (unsigned int)key.type;
if (t < (sizeof(dispatch) / sizeof(*dispatch)) && dispatch[t]) goto *dispatch[t];
goto l_none;
l_enter:
putchar('\n');
term_restore();
return line;
l_eof:
putchar('\n');
term_restore();
free(line);
return NULL;
l_up: {
const char *h = ant_history_prev(hist);
if (h) line_set(line, &pos, &len, h, prompt);
continue;
}
l_down: {
const char *h = ant_history_next(hist);
if (h) line_set(line, &pos, &len, h, prompt);
continue;
}
l_left:
if (pos > 0) {
pos = utf8_prev_pos(line, pos);
move_cursor_only(line, pos, prompt);
}
continue;
l_right:
if (pos < len) {
pos = utf8_next_pos(line, len, pos);
move_cursor_only(line, pos, prompt);
}
continue;
l_home:
if (pos != 0) {
pos = 0;
move_cursor_only(line, pos, prompt);
}
continue;
l_end:
if (pos != len) {
pos = len;
move_cursor_only(line, pos, prompt);
}
continue;
l_delete:
line_delete(line, &pos, &len, prompt);
continue;
l_backspace:
line_backspace(line, &pos, &len, prompt);
continue;
l_char:
line_insert(line, &pos, &len, key.ch, prompt);
continue;
l_none:
continue;
}
}
ant_readline_result_t ant_readline(
ant_history_t *hist,
const char *prompt,
highlight_state line_state,
char **out_line
) {
if (out_line) *out_line = NULL;
hl_line_state = line_state;
ctrl_c_pressed = 0;
char *line = read_line_with_history(hist, prompt);
if (ctrl_c_pressed > 0) {
if (line) free(line);
return ANT_READLINE_INTERRUPT;
}
if (!line) return ANT_READLINE_EOF;
if (out_line) *out_line = line;
return ANT_READLINE_LINE;
}

Owner Packages

  • No Owners