ESH

// Copyright (C) 2021, Jakob Wakeling

// All rights reserved.

#include "../util/log.h"

#include "../util/util.h"

#include "lineread.h"

#include <sys/ioctl.h>

#include <termios.h>

#include <unistd.h>

#include <errno.h>

#include <stdbool.h>

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct { char *s; uptr sp, sl, sc; } line;

typedef struct { line *a; uptr ap, ah, at, al, ac; } hist;

static struct termios tco, tcn;

static bool rawflag = false, ateflag = false;

static hist h = { NULL, 0, 0, 0, 0 };

static const char *const prompt = "$ ";

static char *linentty(void);

static char *lineedit(void);

static void  line_esc(line *l, register int c);

static inline void tcraw(void);

static inline void tcrestore(void);

static size_t getcols(void);

static void clearscreen(line *l);

static void line_refresh(line *l);

static void line_reset(line *l);

static void line_move_left(line *l);

static void line_move_right(line *l);

static void line_move_word_home(line *l);

static void line_move_word_end(line *l);

static void line_move_home(line *l);

static void line_move_end(line *l);

static void line_push(line *l, char c);

static int  line_insert(line *l, char c);

static void line_backspace(line *l);

static void line_delete(line *l);

static void line_delete_word_home(line *l);

static void line_delete_word_end(line *l);

static void line_delete_home(line *l);

static void line_delete_end(line *l);

static int  hist_init(hist *h);

static void hist_free(hist *h);

static void hist_move_prior(hist *h);

static void hist_move_next(hist *h);

static void hist_move_home(hist *h);

static void hist_move_end(hist *h);

static void hist_push(hist *h, line l);

/* Read a line from stdin */

char *lineread(void) {

	if (!isatty(STDIN_FILENO)) { errno = 0; return linentty(); }

	else { return lineedit(); }

}

/* Free memory allocated by lineread */

void linefree(void) { hist_free(&h); }

/* Read from a non-terminal stdin */

static char *linentty(void) {

	line l; register char *r;

	l.sp = 0; l.sl = 0; l.sc = 1024;

	if (!(l.s = xmalloc(l.sc * sizeof (*l.s)))) { return NULL; }

	for (register int c; (c = fgetc(stdin));) {

		if (c == EOF) { if (l.sl) { break; } r = NULL; goto ret; }

		else { line_push(&l, c); } continue;

	}

end:;

	r = strndup(l.s, l.sl);

ret:;

	free(l.s); return r;

}

#define l h.a[h.ap]

/* Dynamically read a line from stdin */

static char *lineedit(void) {

	register char *r;

	{

		if (h.a == NULL) { if (hist_init(&h)) { return NULL; } }

		line m = { NULL, 0, 0, 1024 };

		// if (!(m.cols = getcols())) { return NULL; }

		if (!(m.s = xmalloc(m.sc * sizeof (*m.s)))) { return NULL; } m.s[0] = 0;

		hist_push(&h, m);

	}

	tcraw(); fputs(prompt, stdout);

	for (register int c; (c = fgetc(stdin));) {

		if (errno) { log_warn("FIXME: %s", strerror(errno)); errno = 0; }

		// printf("%02X\n", c); continue;

		switch (c) {

		case '\x01': { line_move_home(&l);        } continue; // CTRL + A

		case '\x02': { line_move_left(&l);        } continue; // CTRL + B

		case '\x03': { line_reset(&l);            } continue; // CTRL + C

		case '\x04': { r = NULL;                  } goto ret; // CTRL + D

		case '\x05': { line_move_end(&l);         } continue; // CTRL + E

		case '\x06': { line_move_right(&l);       } continue; // CTRL + F

		case '\x07': {} continue;                      // IGNORE CTRL + G

		case '\x08': { line_backspace(&l);        } continue; // CTRL + H

		case '\x09': {} continue;                      // IGNORE CTRL + I

		case '\x0A': {} goto end;                             // CTRL + J

		case '\x0B': { line_delete_end(&l);       } continue; // CTRL + K

		case '\x0C': { clearscreen(&l);           } continue; // CTRL + L

		case '\x0D': {} goto end;                    // ENTER or CTRL + M

		case '\x0E': { /* Next history */         } continue; // CTRL + N

		case '\x0F': {} goto end;                             // CTRL + O

		case '\x10': { /* Prior history */        } continue; // CTRL + P

		case '\x11': { /* Start output */         } continue; // CTRL + Q

		case '\x12': {} continue;                      // IGNORE CTRL + R

		case '\x13': { /* Stop output */          } continue; // CTRL + S

		case '\x14': { /* Swap with prior */      } continue; // CTRL + T

		case '\x15': { line_delete_home(&l);      } continue; // CTRL + U

		case '\x16': { /* Insert char code */     } continue; // CTRL + V

		case '\x17': { line_delete_word_home(&l); } continue; // CTRL + W

		case '\x18': {} continue;                      // IGNORE CTRL + X

		case '\x19': { /* Paste deleted */        } continue; // CTRL + Y

		case '\x1B': switch ((c = fgetc(stdin))) {

			case 'b': { line_move_word_home(&l);  } continue; // ALT + B

			case 'd': { line_delete_word_end(&l); } continue; // ALT + D

			case 'f': { line_move_word_end(&l);   } continue; // ALT + F

			case '[': switch ((c = fgetc(stdin))) {

				case '1': case '2': case '3': case '4': case '5': case '6':

				case '7': case '8': case '9': { line_esc(&l, c); } continue;

				case 'A': { hist_move_prior(&h); } continue; // UP

				case 'B': { hist_move_next(&h);  } continue; // DOWN

				case 'C': { line_move_right(&l); } continue; // RIGHT

				case 'D': { line_move_left(&l);  } continue; // LEFT

				case 'F': { line_move_end(&l);   } continue; // END

				case 'H': { line_move_home(&l);  } continue; // HOME

				default:  {} continue;

			}

			default:  {} continue;

		}

		case '\x7F': { line_backspace(&l);        } continue; // BACKSPACE

		default:     { line_insert(&l, c);        } continue;

		}

	}

end:;

	r = strndup(l.s, l.sl);

ret:;

	tcrestore(); fputc('\n', stdout); return r;

}

#undef l // h.a[h.ap]

/* Handle an extended ^[ sequence */

static void line_esc(line *l, register int c) {

	switch (c) {

	case '2': switch ((c = fgetc(stdin))) {

		case '~': { /* Insert char code */ } return; // INSERT

	}

	case '3': switch ((c = fgetc(stdin))) {

		case '~': { line_delete(l); } return; // DELETE

	}

	case '5': switch ((c = fgetc(stdin))) {

		case '~': { hist_move_home(&h); } return; // PAGE UP

	}

	case '6': switch ((c = fgetc(stdin))) {

		case '~': { hist_move_end(&h); } return; // PAGE DOWN

	}

	}

}

/* Put stdin into raw mode */

static inline void tcraw(void) {

	if (rawflag) { return; }

	tcgetattr(STDIN_FILENO, &tco); tcn = tco;

	if (!ateflag) { atexit(tcrestore); ateflag = true; }

	/* No break, no CR to NL, no parity check, no strip bit, no flow control */

	tcn.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);

	/* No post process, 8-bit chars */

	tcn.c_oflag &= ~(OPOST); tcn.c_cflag |= (CS8);

	/* Canonical off, echo off, no extensions, no signal characters */

	tcn.c_lflag &= ~(ICANON | ECHO | IEXTEN | ISIG);

	/* Read every byte with no delay */

	tcn.c_cc[VMIN] = 1; tcn.c_cc[VTIME] = 0;

	tcsetattr(STDIN_FILENO, TCSAFLUSH, &tcn); rawflag = true; return;

}

/* Restore stdin to canonical mode */

static inline void tcrestore(void) {

	tcsetattr(STDIN_FILENO, TCSAFLUSH, &tco); rawflag = false; return;

}

/* Get the number of columns in the terminal */

static size_t getcols(void) {

	struct winsize ws;

	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == -1) { return 0; }

	return ws.ws_col;

}

/* Clear the screen */

static void clearscreen(line *l) {

	fputs("\x1B[H\x1B[2J", stdout); line_refresh(l); return;

}

/* Refresh line */

static void line_refresh(line *l) {

	fputs("\r\x1B[0K", stdout);

	fputs(prompt, stdout); fputs(l->s, stdout);

	fprintf(stdout, "\r\x1B[%zuC", strlen(prompt) + l->sp);

	return;

}

/* Reset line */

static void line_reset(line *l) {

	l->s[0] = 0; l->sp = 0; l->sl = 0;

	fputs("^C\n", stdout); line_refresh(l); return;

}

/* Move cursor left */

static void line_move_left(line *l) {

	if (l->sp) { --l->sp; fputs("\x1B[D", stdout); } return;

}

/* Move cursor right */

static void line_move_right(line *l) {

	if (l->sp != l->sl) { ++l->sp; fputs("\x1B[C", stdout); } return;

}

/* Move cursor to the word home */

static void line_move_word_home(line *l) {

	for (; l->sp && l->s[l->sp - 1] == ' '; --l->sp);

	for (; l->sp && l->s[l->sp - 1] != ' '; --l->sp);

	line_refresh(l); return;

}

/* Move cursor to the word end */

static void line_move_word_end(line *l) {

	for (; l->sp != l->sl && l->s[l->sp] == ' '; ++l->sp);

	for (; l->sp != l->sl && l->s[l->sp] != ' '; ++l->sp);

	line_refresh(l); return;

}

/* Move cursor to the line home */

static void line_move_home(line *l) {

	l->sp = 0; line_refresh(l); return;

}

/* Move cursor to the line end */

static void line_move_end(line *l) {

	l->sp = l->sl; line_refresh(l); return;

}

/* Push character onto end of line */

static void line_push(line *l, char c) {

	if (l->sl + 1 > l->sc) { l->sc *= 2;

		l->s = xrealloc(l->s, l->sc * sizeof (*l->s));

	} l->s[l->sl] = c; l->s[++l->sl] = 0; return;

}

/* Insert character at cursor */

static int line_insert(line *l, char c) {

	if (l->sl + 1 == l->sc) { /* TODO expand string */ }

	if (l->sp == l->sl) { // Cursor is at line end

		l->s[l->sp++] = c; l->s[++l->sl] = 0;

		return fputc(c, stdout);

	}

	else {

		memmove(l->s + l->sp + 1, l->s + l->sp, l->sl - l->sp);

		l->s[l->sp++] = c; l->s[++l->sl] = 0; line_refresh(l);

	} return c;

}

/* Delete character before cursor */

static void line_backspace(line *l) {

	if (l->sp) {

		memmove(l->s + l->sp - 1, l->s + l->sp, l->sl - l->sp);

		--l->sp; l->s[--l->sl] = 0; line_refresh(l);

	} return;

}

/* Delete character at cursor */

static void line_delete(line *l) {

	if (l->sp != l->sl) {

		memmove(l->s + l->sp, l->s + l->sp + 1, l->sl - l->sp);

		l->s[--l->sl] = 0; line_refresh(l);

	} return;

}

/* Delete the word preceeding the cursor */

static void line_delete_word_home(line *l) {

	size_t p = l->sp;

	for (; l->sp && l->s[l->sp - 1] == ' '; --l->sp);

	for (; l->sp && l->s[l->sp - 1] != ' '; --l->sp);

	memmove(l->s + l->sp, l->s + p, l->sl - p + 1);

	l->sl -= p - l->sp; line_refresh(l); return;

}

/* Delete the word following the cursor */

static void line_delete_word_end(line *l) {

	size_t p = l->sp;

	for (; p != l->sl && l->s[p] == ' '; ++p);

	for (; p != l->sl && l->s[p] != ' '; ++p);

	memmove(l->s + l->sp, l->s + p, l->sl - p + 1);

	l->sl -= p - l->sp; line_refresh(l); return;

}

/* Delete characters from cursor to home */

static void line_delete_home(line *l) {

	memmove(l->s, l->s + l->sp, l->sl - l->sp + 1);

	l->sl -= l->sp; l->sp = 0; line_refresh(l); return;

}

/* Delete characters from cursor to end */

static void line_delete_end(line *l) {

	l->s[(l->sl = l->sp)] = 0; line_refresh(l); return;

}

/* Initialise history */

static int hist_init(hist *h) {

	/* FIXME do not hardcode history size */

	h->ap = 0; h->ah = 0; h->at = 0; h->al = 0; h->ac = 1000 + 1;

	if (!(h->a = xcalloc(h->ac, sizeof (*h->a)))) { return 1; }

	/* TODO load history from file */ return 0;

}

/* Free history */

static void hist_free(hist *h) {

	for (size_t i = 0; i != h->ac; ++i) { free(h->a[i].s); } free(h->a);

}

/* Move backwards in history */

static void hist_move_prior(hist *h) {

	if (h->ap != h->ah) { h->ap == 0 ? h->ap = h->ac - 1 : --h->ap; }

	line_refresh(&h->a[h->ap]); return;

}

/* Move forwards in history */

static void hist_move_next(hist *h) {

	register size_t an = h->ap == h->ac - 1 ? 0 : h->ap + 1;

	if (an != h->at) { h->ap = an; }

	line_refresh(&h->a[h->ap]); return;

}

/* Move to the start of history */

static void hist_move_home(hist *h) {

	/* TODO */

	h->ap = h->ah; line_refresh(&h->a[h->ap]); return;

}

/* Move to the end of history */

static void hist_move_end(hist *h) {

	/* TODO */

	// h->ap = h->at; lineRefresh(&h->a[h->ap]); return;

}

/* Push a line onto the end of history */

static void hist_push(hist *h, line l) {

	if (h->al != h->ac) {

		++h->al; h->ap = h->at; if (++h->at == h->ac) { h->at = 0; }

	}

	else { h->ap = h->at; if (++h->at == h->ac) { h->at = 0; } h->ah = h->at; }

	free(h->a[h->ap].s); h->a[h->ap] = l; return;

}