version 1.1.2.1, 2010/06/02 17:17:56
|
version 1.1.2.4, 2010/06/04 11:05:18
|
Line 5
|
Line 5
|
#include <termios.h> |
#include <termios.h> |
#include <poll.h> |
#include <poll.h> |
#include <aitio.h> |
#include <aitio.h> |
|
#include <sys/types.h> |
#include <sys/param.h> |
#include <sys/param.h> |
#include <sys/stat.h> |
#include <sys/stat.h> |
#include <sys/queue.h> |
#include <sys/queue.h> |
Line 14
|
Line 15
|
int freeLineCLI(linebuffer_t * __restrict buffer); |
int freeLineCLI(linebuffer_t * __restrict buffer); |
|
|
|
|
|
static inline void |
|
clrscrEOL(linebuffer_t * __restrict buf) |
|
{ |
|
register int i; |
|
|
|
if (buf) { |
|
write(buf->line_out, K_CR, 1); |
|
|
|
for (i = 0; i < buf->line_len; i++) |
|
write(buf->line_out, K_SPACE, 1); |
|
} |
|
} |
|
|
|
static inline void |
|
printfEOL(linebuffer_t * __restrict buf, int len, int prompt) |
|
{ |
|
if (buf) { |
|
write(buf->line_out, K_CR, 1); |
|
|
|
if (prompt && buf->line_prompt) |
|
write(buf->line_out, buf->line_prompt, buf->line_bol); |
|
|
|
write(buf->line_out, buf->line_buf, len == -1 ? buf->line_eol - buf->line_bol: len); |
|
} |
|
} |
|
|
|
static inline void |
|
printfCR(linebuffer_t * __restrict buf, int prompt) |
|
{ |
|
if (buf) { |
|
write(buf->line_out, K_CR, 1); |
|
|
|
if (prompt) |
|
if (prompt && buf->line_prompt) |
|
write(buf->line_out, buf->line_prompt, buf->line_bol); |
|
} |
|
} |
|
|
|
static inline void |
|
printfCLI(linebuffer_t * __restrict buf, const unsigned char *text, int textlen, int prompt) |
|
{ |
|
if (buf && text && textlen) { |
|
if (prompt && buf->line_prompt) |
|
write(buf->line_out, buf->line_prompt, buf->line_bol); |
|
|
|
write(buf->line_out, text, textlen); |
|
} |
|
} |
|
|
|
|
static int |
static int |
catCh2Buf(int idx, void * __restrict buffer) |
catCh2Buf(int idx, void * __restrict buffer) |
{ |
{ |
linebuffer_t *buf = buffer; |
linebuffer_t *buf = buffer; |
char *ptr; | int pos; |
| unsigned char b[BUFSIZ]; |
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
|
|
ptr = realloc(buf->line_buf, buf->line_len + buf->line_keys[idx].key_len); | pos = buf->line_eol - buf->line_bol; |
if (!ptr) | |
return RETCODE_ERR; | if (buf->line_mode == LINEMODE_INS) |
else | memmove(buf->line_buf + pos + buf->line_keys[idx].key_len, buf->line_buf + pos, |
| buf->line_len - buf->line_eol); |
| if (buf->line_mode == LINEMODE_INS || buf->line_eol == buf->line_len - 1) |
buf->line_len += buf->line_keys[idx].key_len; |
buf->line_len += buf->line_keys[idx].key_len; |
|
buf->line_eol += buf->line_keys[idx].key_len; |
|
|
memcpy(ptr + buf->line_eol, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); | memcpy(buf->line_buf + pos, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); |
ptr[buf->line_len - 1] = 0; | buf->line_buf[buf->line_len - 1] = 0; |
|
|
/* show */ |
|
write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); |
write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); |
|
|
buf->line_eol += buf->line_keys[idx].key_len; | if (buf->line_mode == LINEMODE_INS) { |
buf->line_buf = ptr; | printfCLI(buf, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len, |
| buf->line_len - buf->line_eol, 0); |
| printfEOL(buf, -1, 1); |
| } |
return RETCODE_OK; |
return RETCODE_OK; |
} |
} |
|
|
static int |
static int |
bufEOL(int idx, void * __restrict buffer) |
bufEOL(int idx, void * __restrict buffer) |
{ |
{ |
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
|
|
/* show */ | printfCR(buffer, 1); |
write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); | |
| |
return RETCODE_EOL; |
return RETCODE_EOL; |
} |
} |
|
|
Line 62 bufEOF(int idx, void * __restrict buffer)
|
Line 115 bufEOF(int idx, void * __restrict buffer)
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
|
|
/* show */ |
|
write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); |
write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len); |
|
|
return RETCODE_EOF; |
return RETCODE_EOF; |
} |
} |
|
|
Line 86 static int
|
Line 137 static int
|
bufUP(int idx, void * __restrict buffer) |
bufUP(int idx, void * __restrict buffer) |
{ |
{ |
linebuffer_t *buf = buffer; |
linebuffer_t *buf = buffer; |
char *ptr; | int pos; |
register int i; | |
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
Line 99 bufUP(int idx, void * __restrict buffer)
|
Line 149 bufUP(int idx, void * __restrict buffer)
|
if (!buf->line_h) |
if (!buf->line_h) |
return RETCODE_OK; |
return RETCODE_OK; |
|
|
/* clear line */ | clrscrEOL(buf); |
write(buf->line_out, K_CR, 1); | freeLineCLI(buf); |
for (i = 0; i < buf->line_len; i++) | |
write(buf->line_out, K_SPACE, 1); | |
|
|
freeLineCLI(buffer); | pos = buf->line_eol - buf->line_bol; |
ptr = realloc(buf->line_buf, buf->line_len + buf->line_h->hist_len); | |
if (!ptr) | |
return RETCODE_ERR; | |
else | |
buf->line_len += buf->line_h->hist_len; | |
|
|
memcpy(ptr + buf->line_eol, buf->line_h->hist_line, buf->line_h->hist_len); | buf->line_len += buf->line_h->hist_len; |
ptr[buf->line_len - 1] = 0; | |
| |
buf->line_eol += buf->line_h->hist_len; |
buf->line_eol += buf->line_h->hist_len; |
buf->line_buf = ptr; |
|
|
|
/* show */ | memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len); |
write(buf->line_out, K_CR, 1); | buf->line_buf[buf->line_len - 1] = 0; |
write(buf->line_out, buf->line_buf, buf->line_len); | |
|
|
|
printfEOL(buf, -1, 1); |
return RETCODE_OK; |
return RETCODE_OK; |
} |
} |
|
|
Line 128 static int
|
Line 168 static int
|
bufDOWN(int idx, void * __restrict buffer) |
bufDOWN(int idx, void * __restrict buffer) |
{ |
{ |
linebuffer_t *buf = buffer; |
linebuffer_t *buf = buffer; |
char *ptr; | int pos; |
register int i; | |
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
Line 141 bufDOWN(int idx, void * __restrict buffer)
|
Line 180 bufDOWN(int idx, void * __restrict buffer)
|
if (!buf->line_h) |
if (!buf->line_h) |
return RETCODE_OK; |
return RETCODE_OK; |
|
|
/* clear line */ | clrscrEOL(buf); |
write(buf->line_out, K_CR, 1); | freeLineCLI(buf); |
for (i = 0; i < buf->line_len; i++) | |
write(buf->line_out, K_SPACE, 1); | |
|
|
|
pos = buf->line_eol - buf->line_bol; |
|
|
|
buf->line_len += buf->line_h->hist_len; |
|
buf->line_eol += buf->line_h->hist_len; |
|
|
|
memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len); |
|
buf->line_buf[buf->line_len - 1] = 0; |
|
|
|
printfEOL(buf, -1, 1); |
|
return RETCODE_OK; |
|
} |
|
|
|
static int |
|
bufClr(int idx, void * __restrict buffer) |
|
{ |
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
clrscrEOL(buffer); |
freeLineCLI(buffer); |
freeLineCLI(buffer); |
ptr = realloc(buf->line_buf, buf->line_len + buf->line_h->hist_len); | |
if (!ptr) | printfCR(buffer, 1); |
| return RETCODE_OK; |
| } |
| |
| static int |
| bufBS(int idx, void * __restrict buffer) |
| { |
| linebuffer_t *buf = buffer; |
| |
| if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
else |
|
buf->line_len += buf->line_h->hist_len; |
|
|
|
memcpy(ptr + buf->line_eol, buf->line_h->hist_line, buf->line_h->hist_len); | if (buf->line_bol < buf->line_eol) { |
ptr[buf->line_len - 1] = 0; | clrscrEOL(buf); |
|
|
buf->line_eol += buf->line_h->hist_len; | buf->line_eol--; |
buf->line_buf = ptr; | buf->line_len--; |
| memmove(buf->line_buf + buf->line_eol - buf->line_bol, |
| buf->line_buf + buf->line_eol - buf->line_bol + 1, |
| buf->line_len - buf->line_eol); |
| buf->line_buf[buf->line_len - 1] = 0; |
|
|
/* show */ | printfEOL(buf, buf->line_len - 1, 1); |
write(buf->line_out, K_CR, 1); | printfEOL(buf, -1, 1); |
write(buf->line_out, buf->line_buf, buf->line_len); | } |
|
|
return RETCODE_OK; |
return RETCODE_OK; |
} |
} |
|
|
static int |
static int |
bufClr(int idx, void * __restrict buffer) | bufBTAB(int idx, void * __restrict buffer) |
{ |
{ |
linebuffer_t *buf = buffer; |
linebuffer_t *buf = buffer; |
register int i; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
return RETCODE_ERR; |
return RETCODE_ERR; |
|
|
/* clear line */ | if (buf->line_bol < buf->line_eol) { |
write(buf->line_out, K_CR, 1); | clrscrEOL(buf); |
for (i = 0; i < buf->line_len; i++) | |
write(buf->line_out, K_SPACE, 1); | |
|
|
freeLineCLI(buffer); | buf->line_len = buf->line_eol - buf->line_bol + 1; |
| buf->line_buf[buf->line_len - 1] = 0; |
|
|
write(buf->line_out, K_CR, 1); | printfEOL(buf, -1, 1); |
| } |
| |
return RETCODE_OK; |
return RETCODE_OK; |
} |
} |
|
|
|
static int |
|
bufMode(int idx, void * __restrict buffer) |
|
{ |
|
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
buf->line_mode = !buf->line_mode ? LINEMODE_OVER : LINEMODE_INS; |
|
return RETCODE_OK; |
|
} |
|
|
|
static int |
|
bufBegin(int idx, void * __restrict buffer) |
|
{ |
|
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
buf->line_eol = buf->line_bol; |
|
|
|
printfCR(buf, 1); |
|
return RETCODE_OK; |
|
} |
|
|
|
static int |
|
bufEnd(int idx, void * __restrict buffer) |
|
{ |
|
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
buf->line_eol = buf->line_len - 1; |
|
|
|
printfEOL(buf, -1, 1); |
|
return RETCODE_OK; |
|
} |
|
|
|
static int |
|
bufLEFT(int idx, void * __restrict buffer) |
|
{ |
|
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
if (buf->line_bol < buf->line_eol) |
|
printfEOL(buf, --buf->line_eol - buf->line_bol, 1); |
|
|
|
return RETCODE_OK; |
|
} |
|
|
|
static int |
|
bufRIGHT(int idx, void * __restrict buffer) |
|
{ |
|
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
if (buf->line_eol < buf->line_len - 1) |
|
printfEOL(buf, ++buf->line_eol - buf->line_bol, 1); |
|
|
|
return RETCODE_OK; |
|
} |
|
|
|
static int |
|
bufDel(int idx, void * __restrict buffer) |
|
{ |
|
linebuffer_t *buf = buffer; |
|
|
|
if (!buffer || idx < 0 || idx > MAX_BINDKEY) |
|
return RETCODE_ERR; |
|
|
|
clrscrEOL(buf); |
|
|
|
buf->line_len--; |
|
memmove(buf->line_buf + buf->line_eol - buf->line_bol, |
|
buf->line_buf + buf->line_eol - buf->line_bol + 1, |
|
buf->line_len - buf->line_eol); |
|
buf->line_buf[buf->line_len - 1] = 0; |
|
|
|
printfEOL(buf, buf->line_len - 1, 1); |
|
printfEOL(buf, -1, 1); |
|
|
|
return RETCODE_OK; |
|
} |
|
|
// --------------------------------------------------------------- |
// --------------------------------------------------------------- |
|
|
int |
int |
Line 206 bindKeyCLI(bindkey_t * __restrict key, linebuffer_t *
|
Line 363 bindKeyCLI(bindkey_t * __restrict key, linebuffer_t *
|
} |
} |
|
|
linebuffer_t * |
linebuffer_t * |
initCLI(int fin, int fout) | initCLI(int fin, int fout, const char *prompt) |
{ |
{ |
linebuffer_t *buffer; |
linebuffer_t *buffer; |
bindkey_t *keys; |
bindkey_t *keys; |
Line 225 initCLI(int fin, int fout)
|
Line 382 initCLI(int fin, int fout)
|
buffer->line_out = fout; |
buffer->line_out = fout; |
|
|
TAILQ_INIT(&buffer->line_history); |
TAILQ_INIT(&buffer->line_history); |
|
|
|
if (prompt) { |
|
buffer->line_prompt = strdup(prompt); |
|
if (!buffer->line_prompt) { |
|
free(buffer); |
|
return NULL; |
|
} else { |
|
buffer->line_bol = strlen(buffer->line_prompt); |
|
buffer->line_eol = buffer->line_bol; |
|
} |
|
} |
} |
} |
buffer->line_buf = malloc(1); | buffer->line_buf = malloc(BUFSIZ); |
if (!buffer->line_buf) { |
if (!buffer->line_buf) { |
|
if (buffer->line_prompt) |
|
free(buffer->line_prompt); |
free(buffer); |
free(buffer); |
return NULL; |
return NULL; |
} else { |
} else { |
*buffer->line_buf = 0; | memset(buffer->line_buf, 0, BUFSIZ); |
buffer->line_len = 1; | buffer->line_len = 1 + buffer->line_eol; |
} |
} |
keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t)); |
keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t)); |
if (!keys) { |
if (!keys) { |
|
if (buffer->line_prompt) |
|
free(buffer->line_prompt); |
free(buffer->line_buf); |
free(buffer->line_buf); |
free(buffer); |
free(buffer); |
return NULL; |
return NULL; |
Line 252 initCLI(int fin, int fout)
|
Line 424 initCLI(int fin, int fout)
|
keys[i].key_func = bufEOF; |
keys[i].key_func = bufEOF; |
if (i == *K_CTRL_M || i == *K_CTRL_J) |
if (i == *K_CTRL_M || i == *K_CTRL_J) |
keys[i].key_func = bufEOL; |
keys[i].key_func = bufEOL; |
|
if (i == *K_CTRL_H || i == *K_BACKSPACE) |
|
keys[i].key_func = bufBS; |
if (i == *K_CTRL_C) |
if (i == *K_CTRL_C) |
keys[i].key_func = bufClr; |
keys[i].key_func = bufClr; |
|
if (i == *K_CTRL_A) |
|
keys[i].key_func = bufBegin; |
|
if (i == *K_CTRL_E) |
|
keys[i].key_func = bufEnd; |
if (i >= *K_SPACE && i < *K_BACKSPACE) |
if (i >= *K_SPACE && i < *K_BACKSPACE) |
keys[i].key_func = catCh2Buf; |
keys[i].key_func = catCh2Buf; |
if (i > *K_BACKSPACE && i < 0xff) |
if (i > *K_BACKSPACE && i < 0xff) |
Line 324 initCLI(int fin, int fout)
|
Line 502 initCLI(int fin, int fout)
|
keys[i].key_len = sizeof K_CTRL_F12 - 1; |
keys[i].key_len = sizeof K_CTRL_F12 - 1; |
memcpy(keys[i].key_ch, K_CTRL_F12, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_CTRL_F12, keys[i++].key_len); |
keys[i].key_len = sizeof K_HOME - 1; |
keys[i].key_len = sizeof K_HOME - 1; |
|
keys[i].key_func = bufBegin; |
memcpy(keys[i].key_ch, K_HOME, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_HOME, keys[i++].key_len); |
keys[i].key_len = sizeof K_END - 1; |
keys[i].key_len = sizeof K_END - 1; |
|
keys[i].key_func = bufEnd; |
memcpy(keys[i].key_ch, K_END, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_END, keys[i++].key_len); |
keys[i].key_len = sizeof K_UP - 1; |
keys[i].key_len = sizeof K_UP - 1; |
keys[i].key_func = bufUP; |
keys[i].key_func = bufUP; |
Line 334 initCLI(int fin, int fout)
|
Line 514 initCLI(int fin, int fout)
|
keys[i].key_func = bufDOWN; |
keys[i].key_func = bufDOWN; |
memcpy(keys[i].key_ch, K_DOWN, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_DOWN, keys[i++].key_len); |
keys[i].key_len = sizeof K_RIGHT - 1; |
keys[i].key_len = sizeof K_RIGHT - 1; |
|
keys[i].key_func = bufRIGHT; |
memcpy(keys[i].key_ch, K_RIGHT, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_RIGHT, keys[i++].key_len); |
keys[i].key_len = sizeof K_LEFT - 1; |
keys[i].key_len = sizeof K_LEFT - 1; |
|
keys[i].key_func = bufLEFT; |
memcpy(keys[i].key_ch, K_LEFT, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_LEFT, keys[i++].key_len); |
keys[i].key_len = sizeof K_BTAB - 1; |
keys[i].key_len = sizeof K_BTAB - 1; |
|
keys[i].key_func = bufBTAB; |
memcpy(keys[i].key_ch, K_BTAB, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_BTAB, keys[i++].key_len); |
// 4 bytes |
// 4 bytes |
keys[i].key_len = sizeof K_INS - 1; |
keys[i].key_len = sizeof K_INS - 1; |
|
keys[i].key_func = bufMode; |
memcpy(keys[i].key_ch, K_INS, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_INS, keys[i++].key_len); |
keys[i].key_len = sizeof K_DEL - 1; |
keys[i].key_len = sizeof K_DEL - 1; |
|
keys[i].key_func = bufDel; |
memcpy(keys[i].key_ch, K_DEL, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_DEL, keys[i++].key_len); |
keys[i].key_len = sizeof K_PGUP - 1; |
keys[i].key_len = sizeof K_PGUP - 1; |
memcpy(keys[i].key_ch, K_PGUP, keys[i++].key_len); |
memcpy(keys[i].key_ch, K_PGUP, keys[i++].key_len); |
Line 388 endCLI(linebuffer_t * __restrict buffer)
|
Line 573 endCLI(linebuffer_t * __restrict buffer)
|
free(h); |
free(h); |
} |
} |
|
|
|
if (buffer->line_prompt) |
|
free(buffer->line_prompt); |
|
|
if (buffer->line_keys) |
if (buffer->line_keys) |
free(buffer->line_keys); |
free(buffer->line_keys); |
if (buffer->line_buf) |
if (buffer->line_buf) |
Line 398 endCLI(linebuffer_t * __restrict buffer)
|
Line 586 endCLI(linebuffer_t * __restrict buffer)
|
} |
} |
} |
} |
|
|
|
void |
|
setPromptCLI(linebuffer_t * __restrict buffer, const char *prompt) |
|
{ |
|
if (buffer) { |
|
if (buffer->line_prompt) { |
|
free(buffer->line_prompt); |
|
buffer->line_prompt = NULL; |
|
buffer->line_bol = 0; |
|
} |
|
|
|
if (prompt) { |
|
buffer->line_prompt = strdup(prompt); |
|
if (buffer->line_prompt) { |
|
buffer->line_bol = strlen(buffer->line_prompt); |
|
buffer->line_eol = buffer->line_bol; |
|
buffer->line_len = 1 + buffer->line_eol; |
|
} |
|
} |
|
} |
|
} |
|
|
int |
int |
freeLineCLI(linebuffer_t * __restrict buffer) |
freeLineCLI(linebuffer_t * __restrict buffer) |
{ |
{ |
Line 407 freeLineCLI(linebuffer_t * __restrict buffer)
|
Line 616 freeLineCLI(linebuffer_t * __restrict buffer)
|
if (buffer->line_buf) |
if (buffer->line_buf) |
free(buffer->line_buf); |
free(buffer->line_buf); |
|
|
buffer->line_buf = malloc(1); | buffer->line_buf = malloc(BUFSIZ); |
if (buffer->line_buf) { |
if (buffer->line_buf) { |
*buffer->line_buf = 0; | memset(buffer->line_buf, 0, BUFSIZ); |
buffer->line_eol = 0; | buffer->line_eol = buffer->line_bol; |
buffer->line_len = 1; | buffer->line_len = 1 + buffer->line_eol; |
|
|
code = RETCODE_OK; |
code = RETCODE_OK; |
} |
} |
Line 435 readLineCLI(linebuffer_t * __restrict buffer)
|
Line 644 readLineCLI(linebuffer_t * __restrict buffer)
|
fds.fd = buffer->line_in; |
fds.fd = buffer->line_in; |
fds.events = POLLIN; |
fds.events = POLLIN; |
|
|
|
printfCR(buffer, 1); |
while (42) { |
while (42) { |
if (poll(&fds, 1, -1) < 1) |
if (poll(&fds, 1, -1) < 1) |
return RETCODE_ERR; |
return RETCODE_ERR; |
Line 511 addHistoryCLI(linebuffer_t * __restrict buffer, const
|
Line 721 addHistoryCLI(linebuffer_t * __restrict buffer, const
|
} |
} |
|
|
int |
int |
saveHistoryCLI(linebuffer_t * __restrict buffer, const char *histfile) | saveHistoryCLI(linebuffer_t * __restrict buffer, const char *histfile, int lines) |
{ |
{ |
FILE *f; |
FILE *f; |
mode_t mode; |
mode_t mode; |
Line 529 saveHistoryCLI(linebuffer_t * __restrict buffer, const
|
Line 739 saveHistoryCLI(linebuffer_t * __restrict buffer, const
|
f = fopen(szFName, "w"); |
f = fopen(szFName, "w"); |
if (!f) |
if (!f) |
return RETCODE_ERR; |
return RETCODE_ERR; |
TAILQ_FOREACH(h, &buffer->line_history, hist_next) | TAILQ_FOREACH(h, &buffer->line_history, hist_next) { |
fprintf(f, "%s\n", h->hist_line); |
fprintf(f, "%s\n", h->hist_line); |
|
|
|
if (lines) |
|
lines--; |
|
else |
|
break; |
|
} |
fclose(f); |
fclose(f); |
umask(mode); |
umask(mode); |
|
|
Line 580 resetHistoryCLI(linebuffer_t * __restrict buffer)
|
Line 796 resetHistoryCLI(linebuffer_t * __restrict buffer)
|
buffer->line_h = NULL; |
buffer->line_h = NULL; |
} |
} |
|
|
|
// ------------------------------------------------------------ |
|
|
int |
int |
main() |
main() |
{ |
{ |
int ret; |
int ret; |
bindkey_t key = { sizeof K_TAB - 1, K_TAB, bufTab }; |
bindkey_t key = { sizeof K_TAB - 1, K_TAB, bufTab }; |
linebuffer_t *buffer = initCLI(STDIN_FILENO, STDOUT_FILENO); | linebuffer_t *buffer = initCLI(STDIN_FILENO, STDOUT_FILENO, CLI_PROMPT); |
|
|
bindKeyCLI(&key, buffer); |
bindKeyCLI(&key, buffer); |
|
|
Line 596 main()
|
Line 813 main()
|
ret = readLineCLI(buffer); |
ret = readLineCLI(buffer); |
addHistoryCLI(buffer, NULL); |
addHistoryCLI(buffer, NULL); |
|
|
printf("LINE=%s (%d)/%d CODE=%d\n", buffer->line_buf, buffer->line_len, buffer->line_eol, ret); | printf("LINE=%s (%d)/%d/%d CODE=%d\n", buffer->line_buf, buffer->line_len, buffer->line_eol, buffer->line_bol, ret); |
|
|
freeLineCLI(buffer); |
freeLineCLI(buffer); |
resetHistoryCLI(buffer); |
resetHistoryCLI(buffer); |
Line 605 main()
|
Line 822 main()
|
break; |
break; |
} |
} |
|
|
saveHistoryCLI(buffer, NULL); | saveHistoryCLI(buffer, NULL, HISTORY_LINES); |
|
|
endCLI(buffer); |
endCLI(buffer); |
return 0; |
return 0; |