HomePhorge
Diffusion Ant (feature/nursery) Code

ant/src/repl.c
ddfe6237cab5feature/nursery

Last Change
Raw File

repl.c
View Options

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <signal.h>
#include <sys/stat.h>
#ifdef _WIN32
#include <conio.h>
#include <windows.h>
#include <io.h>
#include <direct.h>
#define STDIN_FILENO 0
#define mkdir_p(path) _mkdir(path)
#else
#include <termios.h>
#include <unistd.h>
#define mkdir_p(path) mkdir(path, 0755)
#endif
#include "ant.h"
#include "repl.h"
#include "reactor.h"
#include "config.h"
#include "runtime.h"
#include "internal.h"
#include "modules/io.h"
#define MAX_HISTORY 512
#define MAX_LINE_LENGTH 4096
#define MAX_MULTILINE_LENGTH 65536
#define INPUT char *line, int *pos, int *len, key_event_t *key, history_t *hist, const char *prompt
static volatile sig_atomic_t ctrl_c_pressed = 0;
typedef struct {
char **lines;
int count;
int capacity;
int current;
} history_t;
typedef enum {
CMD_OK,
CMD_EXIT,
CMD_NOT_FOUND
} cmd_result_t;
typedef struct {
const char *name;
const char *description;
bool has_arg;
cmd_result_t (*handler)(struct js *js, history_t *history, const char *arg);
} repl_command_t;
static void sigint_handler(int sig) {
(void)sig;
ctrl_c_pressed++;
}
static cmd_result_t cmd_help(struct js *js, history_t *history, const char *arg);
static cmd_result_t cmd_exit(struct js *js, history_t *history, const char *arg);
static cmd_result_t cmd_load(struct js *js, history_t *history, const char *arg);
static cmd_result_t cmd_save(struct js *js, history_t *history, const char *arg);
static cmd_result_t cmd_gc(struct js *js, history_t *history, const char *arg);
static cmd_result_t cmd_stats(struct js *js, history_t *history, const char *arg);
static const repl_command_t commands[] = {
{ "help", "Show this help message", false, cmd_help },
{ "exit", "Exit the REPL", false, cmd_exit },
{ "load", "Load JS from a file into the REPL session", true, cmd_load },
{ "save", "Save all evaluated commands in this REPL session to a file", true, cmd_save },
{ "gc", "Run garbage collector", false, cmd_gc },
{ "stats", "Show memory statistics", false, cmd_stats },
{ NULL, NULL, false, NULL }
};
static cmd_result_t cmd_help(struct js *js, history_t *history, const char *arg) {
for (const repl_command_t *cmd = commands; cmd->name; cmd++) {
printf(" .%-7s - %s\n", cmd->name, cmd->description);
}
printf("\nPress Ctrl+C to abort current expression.\n");
return CMD_OK;
}
static cmd_result_t cmd_exit(struct js *js, history_t *history, const char *arg) {
return CMD_EXIT;
}
static cmd_result_t cmd_load(struct js *js, history_t *history, const char *arg) {
(void)history;
if (!arg || *arg == '\0') {
fprintf(stderr, "Usage: .load <filename>\n");
return CMD_OK;
}
FILE *fp = fopen(arg, "r");
if (fp == NULL) {
fprintf(stderr, "Failed to open file: %s\n", arg);
return CMD_OK;
}
fseek(fp, 0, SEEK_END);
long file_size = ftell(fp);
fseek(fp, 0, SEEK_SET);
char *file_buffer = malloc(file_size + 1);
if (file_buffer) {
size_t len = fread(file_buffer, 1, file_size, fp);
file_buffer[len] = '\0';
jsval_t result = js_eval(js, file_buffer, len);
js_run_event_loop(js);
if (vtype(result) == T_ERR) {
fprintf(stderr, "%s\n", js_str(js, result));
} else if (vtype(result) != T_UNDEF) {
printf("%s\n", js_str(js, result));
}
free(file_buffer);
}
fclose(fp);
return CMD_OK;
}
static cmd_result_t cmd_save(struct js *js, history_t *history, const char *arg) {
(void)js;
if (!arg || *arg == '\0') {
fprintf(stderr, "Usage: .save <filename>\n");
return CMD_OK;
}
FILE *fp = fopen(arg, "w");
if (fp == NULL) {
fprintf(stderr, "Failed to open file for writing: %s\n", arg);
return CMD_OK;
}
for (int i = 0; i < history->count; i++) {
fprintf(fp, "%s\n", history->lines[i]);
}
fclose(fp);
printf("Session saved to %s\n", arg);
return CMD_OK;
}
static cmd_result_t cmd_gc(struct js *js, history_t *history, const char *arg) {
jsval_t gc_fn = js_get(js, rt->ant_obj, "gc");
jsval_t result = js_call(js, gc_fn, NULL, 0);
console_print(js, &result, 1, NULL, stdout);
return CMD_OK;
}
static cmd_result_t cmd_stats(struct js *js, history_t *history, const char *arg) {
jsval_t stats_fn = js_get(js, rt->ant_obj, "stats");
jsval_t result = js_call(js, stats_fn, NULL, 0);
console_print(js, &result, 1, NULL, stdout);
return CMD_OK;
}
static cmd_result_t execute_command(struct js *js, history_t *history, const char *line) {
const char *cmd_start = line + 1;
for (const repl_command_t *cmd = commands; cmd->name; cmd++) {
size_t n = strlen(cmd->name);
if (strncmp(cmd_start, cmd->name, n) != 0) continue;
char next = cmd_start[n];
if (cmd->has_arg && (next == ' ' || next == '\0')) {
const char *arg = cmd_start + n;
while (*arg == ' ') arg++;
return cmd->handler(js, history, arg);
}
if (!cmd->has_arg && next == '\0') return cmd->handler(js, history, NULL);
}
return CMD_NOT_FOUND;
}
static void history_init(history_t *hist) {
hist->capacity = MAX_HISTORY;
hist->lines = malloc(sizeof(char*) * hist->capacity);
hist->count = 0;
hist->current = -1;
}
static void history_add(history_t *hist, const char *line) {
if (strlen(line) == 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*) * (hist->capacity - 1));
hist->count--;
}
hist->lines[hist->count++] = strdup(line);
hist->current = hist->count;
}
static const char* history_prev(history_t *hist) {
if (hist->count == 0) return NULL;
if (hist->current > 0) hist->current--;
return hist->lines[hist->current];
}
static const char* history_next(history_t *hist) {
if (hist->count == 0) return NULL;
if (hist->current < hist->count - 1) {
hist->current++;
return hist->lines[hist->current];
}
hist->current = hist->count;
return "";
}
static void history_free(history_t *hist) {
for (int i = 0; i < hist->count; i++) free(hist->lines[i]);
free(hist->lines);
}
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;
}
static void history_load(history_t *hist) {
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]) history_add(hist, line);
}
fclose(fp);
}
static void history_save(history_t *hist) {
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_BACKSPACE, KEY_ENTER, KEY_EOF, KEY_CHAR
} key_type_t;
typedef struct { key_type_t type; int ch; } key_event_t;
typedef void (*key_handler_t)(INPUT);
static void cursor_move(int *pos, int len, int dir) {
if (dir < 0 && *pos > 0) { printf("\033[D"); fflush(stdout); (*pos)--; }
else if (dir > 0 && *pos < len) { printf("\033[C"); fflush(stdout); (*pos)++; }
}
static void line_set(char *line, int *pos, int *len, const char *str, const char *prompt) {
printf("\r\033[K%s%s", prompt, str);
fflush(stdout); strcpy(line, str);
*len = (int)strlen(line); *pos = *len;
}
static void line_backspace(char *line, int *pos, int *len) {
if (*pos <= 0) return;
memmove(line + *pos - 1, line + *pos, *len - *pos + 1);
(*pos)--; (*len)--;
printf("\b\033[K%s", line + *pos);
for (int i = 0; i < *len - *pos; i++) printf("\033[D");
fflush(stdout);
}
static void line_insert(char *line, int *pos, int *len, int c) {
if (*len >= MAX_LINE_LENGTH - 1) return;
memmove(line + *pos + 1, line + *pos, *len - *pos + 1);
line[*pos] = (char)c;
(*pos)++; (*len)++;
printf("%c%s", c, line + *pos);
for (int i = 0; i < *len - *pos; i++) printf("\033[D");
fflush(stdout);
}
#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 };
}
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 };
}
#define TERM_INIT()
#define TERM_RESTORE()
#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) {
if (getchar() == '[') {
switch (getchar()) {
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 };
}
}
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 };
}
#define TERM_INIT() do { \
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); \
} while(0)
#define TERM_RESTORE() tcsetattr(STDIN_FILENO, TCSANOW, &saved_tio)
#endif
static void handle_up(INPUT) {
const char *h = history_prev(hist);
if (h) line_set(line, pos, len, h, prompt);
}
static void handle_down(INPUT) {
const char *h = history_next(hist);
if (h) line_set(line, pos, len, h, prompt);
}
static void handle_left(INPUT) { cursor_move(pos, *len, -1); }
static void handle_right(INPUT) { cursor_move(pos, *len, 1); }
static void handle_backspace(INPUT) { line_backspace(line, pos, len); }
static void handle_char(INPUT) { line_insert(line, pos, len, key->ch); }
static key_handler_t handlers[] = {
[KEY_UP] = handle_up, [KEY_DOWN] = handle_down,
[KEY_LEFT] = handle_left, [KEY_RIGHT] = handle_right,
[KEY_BACKSPACE] = handle_backspace, [KEY_CHAR] = handle_char,
};
static char* read_line_with_history(history_t *hist, struct js *js, const char *prompt) {
char *line = malloc(MAX_LINE_LENGTH);
int pos = 0, len = 0; line[0] = '\0';
TERM_INIT();
do {
key_event_t key = read_key();
if (key.type == KEY_ENTER) {
printf("\n"); fflush(stdout);
TERM_RESTORE(); return line;
}
if (key.type == KEY_EOF) {
printf("\n"); fflush(stdout);
TERM_RESTORE();
free(line); return NULL;
}
if (handlers[key.type]) {
handlers[key.type](line, &pos, &len, &key, hist, prompt);
}
} while (1);
}
typedef struct {
int paren, bracket, brace;
int *templates;
int template_count, template_cap;
char string_char;
bool in_string, escaped;
} parse_state_t;
static void push_template(parse_state_t *s) {
if (s->template_count >= s->template_cap) {
s->template_cap = s->template_cap ? s->template_cap * 2 : 8;
int *new_templates = realloc(s->templates, s->template_cap * sizeof(int));
if (!new_templates) { return; } s->templates = new_templates;
}
s->templates[s->template_count++] = s->brace;
}
static bool in_template_text(parse_state_t *s) {
return s->template_count > 0 && s->brace == s->templates[s->template_count - 1];
}
static bool is_incomplete_input(const char *code, size_t len) {
parse_state_t s = {0};
for (size_t i = 0; i < len; i++) {
char c = code[i];
if (s.escaped) { s.escaped = false; continue; }
if (c == '\\' && (s.in_string || s.template_count > 0)) { s.escaped = true; continue; }
if (s.in_string) { if (c == s.string_char) s.in_string = false; continue; }
if (in_template_text(&s)) {
if (c == '`') s.template_count--;
else if (c == '$' && i + 1 < len && code[i + 1] == '{') { s.brace++; i++; }
continue;
}
if (c == '/' && i + 1 < len) {
if (code[i + 1] == '/') { while (i < len && code[i] != '\n') i++; continue; }
if (code[i + 1] == '*') {
for (i += 2; i + 1 < len && !(code[i] == '*' && code[i + 1] == '/'); i++);
if (i + 1 >= len) { free(s.templates); return true; }
i++; continue;
}
}
switch (c) {
case '"': case '\'': s.in_string = true; s.string_char = c; break;
case '`': push_template(&s); break;
case '(': s.paren++; break; case ')': s.paren--; break;
case '[': s.bracket++; break; case ']': s.bracket--; break;
case '{': s.brace++; break; case '}': s.brace--; break;
}
}
bool incomplete = s.in_string || s.template_count > 0 || s.paren > 0 || s.bracket > 0 || s.brace > 0;
free(s.templates);
return incomplete;
}
void ant_repl_run() {
struct js *js = rt->js;
js_set_filename(js, "[repl]");
js_setup_import_meta(js, "[repl]");
js_mkscope(js);
printf("Welcome to Ant JavaScript v%s\n", ANT_VERSION);
printf("Type \".help\" for more information.\n");
#ifdef _WIN32
signal(SIGINT, sigint_handler);
#else
struct sigaction sa;
sa.sa_handler = sigint_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
#endif
history_t history;
history_init(&history);
history_load(&history);
js_set(js, js_glob(js), "__dirname", js_mkstr(js, ".", 1));
js_set(js, js_glob(js), "__filename", js_mkstr(js, "[repl]", 6));
int prev_ctrl_c_count = 0;
char *multiline_buf = NULL;
size_t multiline_len = 0;
size_t multiline_cap = 0;
while (1) {
const char *prompt = multiline_buf ? "| " : "> ";
fputs(prompt, stdout);
fflush(stdout);
ctrl_c_pressed = 0;
char *line = read_line_with_history(&history, js, prompt);
if (ctrl_c_pressed > 0) {
if (multiline_buf) {
free(multiline_buf);
multiline_buf = NULL;
multiline_len = 0;
multiline_cap = 0;
prev_ctrl_c_count = 0;
if (line) free(line);
continue;
}
if (prev_ctrl_c_count > 0) {
if (line) free(line);
break;
}
printf("(To exit, press Ctrl+C again or type .exit)\n");
prev_ctrl_c_count++;
if (line) free(line);
continue;
}
if (line == NULL) {
if (multiline_buf) {
free(multiline_buf);
multiline_buf = NULL;
multiline_len = 0;
multiline_cap = 0;
continue;
}
break;
}
prev_ctrl_c_count = 0;
size_t line_len = strlen(line);
if (line_len == 0 && multiline_buf) {
if (multiline_len + 1 >= multiline_cap) {
multiline_cap = multiline_cap ? multiline_cap * 2 : 256;
multiline_buf = realloc(multiline_buf, multiline_cap);
}
multiline_buf[multiline_len++] = '\n';
multiline_buf[multiline_len] = '\0';
free(line);
continue;
}
if (line_len == 0) {
free(line);
continue;
}
if (!multiline_buf && line[0] == '.') {
cmd_result_t result = execute_command(js, &history, line);
if (result == CMD_EXIT) {
free(line);
break;
} else if (result == CMD_NOT_FOUND) {
printf("Unknown command: %s\n", line);
printf("Type \".help\" for more information.\n");
}
free(line);
continue;
}
size_t new_len = multiline_len + line_len + 1;
if (new_len >= multiline_cap || !multiline_buf) {
multiline_cap = multiline_cap ? multiline_cap * 2 : 256;
if (multiline_cap < new_len + 1) multiline_cap = new_len + 1;
multiline_buf = realloc(multiline_buf, multiline_cap);
}
if (multiline_len > 0) {
multiline_buf[multiline_len++] = '\n';
}
memcpy(multiline_buf + multiline_len, line, line_len);
multiline_len += line_len;
multiline_buf[multiline_len] = '\0';
free(line);
if (is_incomplete_input(multiline_buf, multiline_len)) continue;
history_add(&history, multiline_buf);
jsval_t eval_result = js_eval(js, multiline_buf, multiline_len);
js_run_event_loop(js);
char cbuf_stack[512]; js_cstr_t cstr = js_to_cstr(
js, eval_result, cbuf_stack, sizeof(cbuf_stack)
);
if (vtype(eval_result) == T_ERR)
fprintf(stderr, "%s\n", cstr.ptr);
else if (vtype(eval_result) == T_STR)
printf("%s\n", cstr.ptr ? cstr.ptr : "");
else {
print_value_colored(cstr.ptr, stdout);
printf("\n");
} if (cstr.needs_free) free((void *)cstr.ptr);
free(multiline_buf);
multiline_buf = NULL;
multiline_len = 0;
multiline_cap = 0;
}
if (multiline_buf) free(multiline_buf);
history_save(&history);
history_free(&history);
}

Owner Packages

  • No Owners