0,0 → 1,378 |
/* |
* Termios command line History and Editting for NetBSD sh (ash) |
* Copyright (c) 1999 |
* Main code: Adam Rogoyski <rogoyski@cs.utexas.edu> |
* Etc: Dave Cinege <dcinege@psychosis.com> |
* |
* You may use this code as you wish, so long as the original author(s) |
* are attributed in any redistributions of the source code. |
* This code is 'as is' with no warranty. |
* This code may safely be consumed by a BSD or GPL license. |
* |
* v 0.5 19990328 Initial release |
* |
* Future plans: Simple file and path name completion. (like BASH) |
* |
*/ |
|
/* |
Usage and Known bugs: |
Terminal key codes are not extensive, and more will probably |
need to be added. This version was created on Debian GNU/Linux 2.x. |
Delete, Backspace, Home, End, and the arrow keys were tested |
to work in an Xterm and console. Ctrl-A also works as Home. |
Ctrl-E also works as End. The binary size increase is <3K. |
|
Editting will not display correctly for lines greater then the |
terminal width. (more then one line.) However, history will. |
*/ |
|
#include <stdio.h> |
#include <unistd.h> |
#include <stdlib.h> |
#include <string.h> |
#include <termios.h> |
#include <ctype.h> |
#include <sys/ioctl.h> |
|
#include "input.h" |
#include "output.h" |
|
#ifdef HETIO |
|
#include "hetio.h" |
|
|
#define MAX_HISTORY 15 /* Maximum length of the linked list for the command line history */ |
|
#define ESC 27 |
#define DEL 127 |
|
static struct history *his_front = NULL; /* First element in command line list */ |
static struct history *his_end = NULL; /* Last element in command line list */ |
static struct termios old_term, new_term; /* Current termio and the previous termio before starting ash */ |
|
static int history_counter = 0; /* Number of commands in history list */ |
static int reset_term = 0; /* Set to true if the terminal needs to be reset upon exit */ |
//static int hetio_inter = 0; |
int hetio_inter = 0; |
|
struct history |
{ |
char *s; |
struct history *p; |
struct history *n; |
}; |
|
|
void input_delete (int); |
void input_home (int *); |
void input_end (int *, int); |
void input_backspace (int *, int *); |
|
|
|
void hetio_init(void) |
{ |
hetio_inter = 1; |
} |
|
|
void hetio_reset_term(void) |
{ |
if (reset_term) |
tcsetattr(1, TCSANOW, &old_term); |
} |
|
|
void setIO(struct termios *new, struct termios *old) /* Set terminal IO to canonical mode, and save old term settings. */ |
{ |
tcgetattr(0, old); |
memcpy(new, old, sizeof(*new)); |
new->c_cc[VMIN] = 1; |
new->c_cc[VTIME] = 0; |
new->c_lflag &= ~ICANON; /* unbuffered input */ |
new->c_lflag &= ~ECHO; |
tcsetattr(0, TCSANOW, new); |
} |
|
void input_home(int *cursor) /* Command line input routines */ |
{ |
while (*cursor > 0) { |
out1c('\b'); |
--*cursor; |
} |
flushout(&output); |
} |
|
|
void input_delete(int cursor) |
{ |
int j = 0; |
|
memmove(parsenextc + cursor, parsenextc + cursor + 1, |
BUFSIZ - cursor - 1); |
for (j = cursor; j < (BUFSIZ - 1); j++) { |
if (!*(parsenextc + j)) |
break; |
else |
out1c(*(parsenextc + j)); |
} |
|
out1str(" \b"); |
|
while (j-- > cursor) |
out1c('\b'); |
flushout(&output); |
} |
|
|
void input_end(int *cursor, int len) |
{ |
while (*cursor < len) { |
out1str("\033[C"); |
++*cursor; |
} |
flushout(&output); |
} |
|
|
void |
input_backspace(int *cursor, int *len) |
{ |
int j = 0; |
|
if (*cursor > 0) { |
out1str("\b \b"); |
--*cursor; |
memmove(parsenextc + *cursor, parsenextc + *cursor + 1, |
BUFSIZ - *cursor + 1); |
|
for (j = *cursor; j < (BUFSIZ - 1); j++) { |
if (!*(parsenextc + j)) |
break; |
else |
out1c(*(parsenextc + j)); |
} |
|
out1str(" \b"); |
|
while (j-- > *cursor) |
out1c('\b'); |
|
--*len; |
flushout(&output); |
} |
} |
|
int hetio_read_input(int fd) |
{ |
int nr = 0; |
|
if (!hetio_inter) { /* Are we an interactive shell? */ |
return -255; |
} else { |
int len = 0; |
int j = 0; |
int cursor = 0; |
int break_out = 0; |
int ret = 0; |
char c = 0; |
struct history *hp = his_end; |
|
if (!reset_term) { |
setIO(&new_term, &old_term); |
reset_term = 1; |
} else { |
tcsetattr(0, TCSANOW, &new_term); |
} |
|
memset(parsenextc, 0, BUFSIZ); |
|
while (1) { |
if ((ret = read(fd, &c, 1)) < 1) |
return ret; |
|
switch (c) { |
case 1: /* Control-A Beginning of line */ |
input_home(&cursor); |
break; |
case 5: /* Control-E EOL */ |
input_end(&cursor, len); |
break; |
case 4: /* Control-D */ |
#ifndef CTRL_D_DELETE |
return 0; |
#else |
if (cursor != len) { |
input_delete(cursor); |
len--; |
} |
break; |
#endif |
case '\b': /* Backspace */ |
case DEL: |
input_backspace(&cursor, &len); |
break; |
case '\n': /* Enter */ |
*(parsenextc + len++ + 1) = c; |
out1c(c); |
flushout(&output); |
break_out = 1; |
break; |
case ESC: /* escape sequence follows */ |
if ((ret = read(fd, &c, 1)) < 1) |
return ret; |
|
if (c == '[' || c == 'O' ) { /* 91 */ |
if ((ret = read(fd, &c, 1)) < 1) |
return ret; |
|
switch (c) { |
case 'A': |
if (hp && hp->p) { /* Up */ |
hp = hp->p; |
goto hop; |
} |
break; |
case 'B': |
if (hp && hp->n && hp->n->s) { /* Down */ |
hp = hp->n; |
goto hop; |
} |
break; |
|
hop: /* hop */ |
len = strlen(parsenextc); |
|
for (; cursor > 0; cursor--) /* return to begining of line */ |
out1c('\b'); |
|
for (j = 0; j < len; j++) /* erase old command */ |
out1c(' '); |
|
for (j = len; j > 0; j--) /* return to begining of line */ |
out1c('\b'); |
|
strcpy (parsenextc, hp->s); /* write new command */ |
len = strlen (hp->s); |
out1str(parsenextc); |
flushout(&output); |
cursor = len; |
break; |
case 'C': /* Right */ |
if (cursor < len) { |
out1str("\033[C"); |
cursor++; |
flushout(&output); |
} |
break; |
case 'D': /* Left */ |
if (cursor > 0) { |
out1str("\033[D"); |
cursor--; |
flushout(&output); |
} |
break; |
case '3': /* Delete */ |
if (cursor != len) { |
input_delete(cursor); |
len--; |
} |
break; |
case 'H': /* Home (xterm) */ |
case '1': /* Home (Ctrl-A) */ |
input_home(&cursor); |
break; |
case 'F': /* End (xterm_ */ |
case '4': /* End (Ctrl-E) */ |
input_end(&cursor, len); |
break; |
} |
if (c == '1' || c == '3' || c == '4') |
if ((ret = read(fd, &c, 1)) < 1) |
return ret; /* read 126 (~) */ |
} |
|
c = 0; |
break; |
|
default: /* If it's regular input, do the normal thing */ |
|
if (!isprint(c)) /* Skip non-printable characters */ |
break; |
|
if (len >= (BUFSIZ - 2)) /* Need to leave space for enter */ |
break; |
|
len++; |
|
if (cursor == (len - 1)) { /* Append if at the end of the line */ |
*(parsenextc + cursor) = c; |
} else { /* Insert otherwise */ |
memmove(parsenextc + cursor + 1, parsenextc + cursor, |
len - cursor - 1); |
|
*(parsenextc + cursor) = c; |
|
for (j = cursor; j < len; j++) |
out1c(*(parsenextc + j)); |
for (; j > cursor; j--) |
out1str("\033[D"); |
} |
|
cursor++; |
out1c(c); |
flushout(&output); |
break; |
} |
|
if (break_out) /* Enter is the command terminator, no more input. */ |
break; |
} |
|
nr = len + 1; |
tcsetattr(0, TCSANOW, &old_term); |
|
|
if (*(parsenextc)) { /* Handle command history log */ |
struct history *h = his_end; |
|
if (!h) { /* No previous history */ |
h = his_front = malloc(sizeof (struct history)); |
h->n = malloc(sizeof (struct history)); |
h->p = NULL; |
h->s = strdup(parsenextc); |
|
h->n->p = h; |
h->n->n = NULL; |
h->n->s = NULL; |
his_end = h->n; |
history_counter++; |
} else { /* Add a new history command */ |
|
h->n = malloc(sizeof (struct history)); |
|
h->n->p = h; |
h->n->n = NULL; |
h->n->s = NULL; |
h->s = strdup(parsenextc); |
his_end = h->n; |
|
if (history_counter >= MAX_HISTORY) { /* After max history, remove the last known command */ |
struct history *p = his_front->n; |
|
p->p = NULL; |
free(his_front->s); |
free(his_front); |
his_front = p; |
} else { |
history_counter++; |
} |
} |
} |
} |
|
return nr; |
} |
#endif |