arti/i237
1
0
Fork 0
Code Releases Activity
d6fdf0ac12
i237/lib/helius_microrl/microrl.c
Silver Kits 6fa1c472b1 Fix microrl compile error: 
lib/helius_microrl/microrl.c:476:22: error: comparison between signed and unsigned integer expressions [-Werror=sign-compare]
2016-11-21 10:26:55 +02:00

685 lines
18 KiB
C
Executable File
Raw Blame History

/*
Author: Samoylov Eugene aka Helius (ghelius@gmail.com)
BUGS and TODO:
-- add echo_off feature
-- rewrite history for use more than 256 byte buffer
*/
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include "microrl.h"
#ifdef _USE_LIBC_STDIO
#include <stdio.h>
#endif
//#define DBG(...) fprintf(stderr, "\033[33m");fprintf(stderr,__VA_ARGS__);fprintf(stderr,"\033[0m");
char * prompt_default = _PROMPT_DEFAULT;
#ifdef _USE_HISTORY
#ifdef _HISTORY_DEBUG
//*****************************************************************************
// print buffer content on screen
static void print_hist (ring_history_t * pThis)
{
printf ("\n");
for (int i = 0; i < _RING_HISTORY_LEN; i++) {
if (i == pThis->begin)
printf ("b");
else
printf (" ");
}
printf ("\n");
for (int i = 0; i < _RING_HISTORY_LEN; i++) {
if (isalpha(pThis->ring_buf[i]))
printf ("%c", pThis->ring_buf[i]);
else
printf ("%d", pThis->ring_buf[i]);
}
printf ("\n");
for (int i = 0; i < _RING_HISTORY_LEN; i++) {
if (i == pThis->end)
printf ("e");
else
printf (" ");
}
printf ("\n");
}
#endif
//*****************************************************************************
// remove older message from ring buffer
static void hist_erase_older (ring_history_t * pThis)
{
int new_pos = pThis->begin + pThis->ring_buf [pThis->begin] + 1;
if (new_pos >= _RING_HISTORY_LEN)
new_pos = new_pos - _RING_HISTORY_LEN;
pThis->begin = new_pos;
}
//*****************************************************************************
// check space for new line, remove older while not space
static int hist_is_space_for_new (ring_history_t * pThis, int len)
{
if (pThis->ring_buf [pThis->begin] == 0)
return true;
if (pThis->end >= pThis->begin) {
if (_RING_HISTORY_LEN - pThis->end + pThis->begin - 1 > len)
return true;
} else {
if (pThis->begin - pThis->end - 1> len)
return true;
}
return false;
}
//*****************************************************************************
// put line to ring buffer
static void hist_save_line (ring_history_t * pThis, char * line, int len)
{
if (len > _RING_HISTORY_LEN - 2)
return;
while (!hist_is_space_for_new (pThis, len)) {
hist_erase_older (pThis);
}
// if it's first line
if (pThis->ring_buf [pThis->begin] == 0)
pThis->ring_buf [pThis->begin] = len;
// store line
if (len < _RING_HISTORY_LEN-pThis->end-1)
memcpy (pThis->ring_buf + pThis->end + 1, line, len);
else {
int part_len = _RING_HISTORY_LEN-pThis->end-1;
memcpy (pThis->ring_buf + pThis->end + 1, line, part_len);
memcpy (pThis->ring_buf, line + part_len, len - part_len);
}
pThis->ring_buf [pThis->end] = len;
pThis->end = pThis->end + len + 1;
if (pThis->end >= _RING_HISTORY_LEN)
pThis->end -= _RING_HISTORY_LEN;
pThis->ring_buf [pThis->end] = 0;
pThis->cur = 0;
#ifdef _HISTORY_DEBUG
print_hist (pThis);
#endif
}
//*****************************************************************************
// copy saved line to 'line' and return size of line
static int hist_restore_line (ring_history_t * pThis, char * line, int dir)
{
int cnt = 0;
// count history record
int header = pThis->begin;
while (pThis->ring_buf [header] != 0) {
header += pThis->ring_buf [header] + 1;
if (header >= _RING_HISTORY_LEN)
header -= _RING_HISTORY_LEN;
cnt++;
}
if (dir == _HIST_UP) {
if (cnt >= pThis->cur) {
int header = pThis->begin;
int j = 0;
// found record for 'pThis->cur' index
while ((pThis->ring_buf [header] != 0) && (cnt - j -1 != pThis->cur)) {
header += pThis->ring_buf [header] + 1;
if (header >= _RING_HISTORY_LEN)
header -= _RING_HISTORY_LEN;
j++;
}
if (pThis->ring_buf[header]) {
pThis->cur++;
// obtain saved line
if (pThis->ring_buf [header] + header < _RING_HISTORY_LEN) {
memset (line, 0, _COMMAND_LINE_LEN);
memcpy (line, pThis->ring_buf + header + 1, pThis->ring_buf[header]);
} else {
int part0 = _RING_HISTORY_LEN - header - 1;
memset (line, 0, _COMMAND_LINE_LEN);
memcpy (line, pThis->ring_buf + header + 1, part0);
memcpy (line + part0, pThis->ring_buf, pThis->ring_buf[header] - part0);
}
return pThis->ring_buf[header];
}
}
} else {
if (pThis->cur > 0) {
pThis->cur--;
int header = pThis->begin;
int j = 0;
while ((pThis->ring_buf [header] != 0) && (cnt - j != pThis->cur)) {
header += pThis->ring_buf [header] + 1;
if (header >= _RING_HISTORY_LEN)
header -= _RING_HISTORY_LEN;
j++;
}
if (pThis->ring_buf [header] + header < _RING_HISTORY_LEN) {
memcpy (line, pThis->ring_buf + header + 1, pThis->ring_buf[header]);
} else {
int part0 = _RING_HISTORY_LEN - header - 1;
memcpy (line, pThis->ring_buf + header + 1, part0);
memcpy (line + part0, pThis->ring_buf, pThis->ring_buf[header] - part0);
}
return pThis->ring_buf[header];
} else {
/* empty line */
return 0;
}
}
return -1;
}
#endif
//*****************************************************************************
// split cmdline to tkn array and return nmb of token
static int split (microrl_t * pThis, int limit, char const ** tkn_arr)
{
int i = 0;
int ind = 0;
while (1) {
// go to the first whitespace (zerro for us)
while ((pThis->cmdline [ind] == '\0') && (ind < limit)) {
ind++;
}
if (!(ind < limit)) return i;
tkn_arr[i++] = pThis->cmdline + ind;
if (i >= _COMMAND_TOKEN_NMB) {
return -1;
}
// go to the first NOT whitespace (not zerro for us)
while ((pThis->cmdline [ind] != '\0') && (ind < limit)) {
ind++;
}
if (!(ind < limit)) return i;
}
return i;
}
//*****************************************************************************
inline static void print_prompt (microrl_t * pThis)
{
pThis->print (pThis->prompt_str);
}
//*****************************************************************************
inline static void terminal_backspace (microrl_t * pThis)
{
pThis->print ("\033[D \033[D");
}
//*****************************************************************************
inline static void terminal_newline (microrl_t * pThis)
{
pThis->print (ENDL);
}
#ifndef _USE_LIBC_STDIO
//*****************************************************************************
// convert 16 bit value to string
// 0 value not supported!!! just make empty string
// Returns pointer to a buffer tail
static char *u16bit_to_str (unsigned int nmb, char * buf)
{
char tmp_str [6] = {0,};
int i = 0, j;
if (nmb <= 0xFFFF) {
while (nmb > 0) {
tmp_str[i++] = (nmb % 10) + '0';
nmb /=10;
}
for (j = 0; j < i; ++j)
*(buf++) = tmp_str [i-j-1];
}
*buf = '\0';
return buf;
}
#endif
//*****************************************************************************
// set cursor at position from begin cmdline (after prompt) + offset
static void terminal_move_cursor (microrl_t * pThis, int offset)
{
char str[16] = {0,};
#ifdef _USE_LIBC_STDIO
if (offset > 0) {
snprintf (str, 16, "\033[%dC", offset);
} else if (offset < 0) {
snprintf (str, 16, "\033[%dD", -(offset));
}
#else
char *endstr;
strcpy (str, "\033[");
if (offset > 0) {
endstr = u16bit_to_str (offset, str+2);
strcpy (endstr, "C");
} else if (offset < 0) {
endstr = u16bit_to_str (-(offset), str+2);
strcpy (endstr, "D");
} else
return;
#endif
pThis->print (str);
}
//*****************************************************************************
static void terminal_reset_cursor (microrl_t * pThis)
{
char str[16];
#ifdef _USE_LIBC_STDIO
snprintf (str, 16, "\033[%dD\033[%dC", \
_COMMAND_LINE_LEN + _PROMPT_LEN + 2, _PROMPT_LEN);
#else
char *endstr;
strcpy (str, "\033[");
endstr = u16bit_to_str ( _COMMAND_LINE_LEN + _PROMPT_LEN + 2,str+2);
strcpy (endstr, "D\033["); endstr += 3;
endstr = u16bit_to_str (_PROMPT_LEN, endstr);
strcpy (endstr, "C");
#endif
pThis->print (str);
}
//*****************************************************************************
// print cmdline to screen, replace '\0' to wihitespace
static void terminal_print_line (microrl_t * pThis, int pos, int cursor)
{
pThis->print ("\033[K"); // delete all from cursor to end
char nch [] = {0,0};
int i;
for (i = pos; i < pThis->cmdlen; i++) {
nch [0] = pThis->cmdline [i];
if (nch[0] == '\0')
nch[0] = ' ';
pThis->print (nch);
}
terminal_reset_cursor (pThis);
terminal_move_cursor (pThis, cursor);
}
//*****************************************************************************
void microrl_init (microrl_t * pThis, void (*print) (const char *))
{
memset(pThis->cmdline, 0, _COMMAND_LINE_LEN);
#ifdef _USE_HISTORY
memset(pThis->ring_hist.ring_buf, 0, _RING_HISTORY_LEN);
pThis->ring_hist.begin = 0;
pThis->ring_hist.end = 0;
pThis->ring_hist.cur = 0;
#endif
pThis->cmdlen =0;
pThis->cursor = 0;
pThis->execute = NULL;
pThis->get_completion = NULL;
#ifdef _USE_CTLR_C
pThis->sigint = NULL;
#endif
pThis->prompt_str = prompt_default;
pThis->print = print;
#ifdef _ENABLE_INIT_PROMPT
print_prompt (pThis);
#endif
}
//*****************************************************************************
void microrl_set_complete_callback (microrl_t * pThis, char ** (*get_completion)(int, const char* const*))
{
pThis->get_completion = get_completion;
}
//*****************************************************************************
void microrl_set_execute_callback (microrl_t * pThis, int (*execute)(int, const char* const*))
{
pThis->execute = execute;
}
#ifdef _USE_CTLR_C
//*****************************************************************************
void microrl_set_sigint_callback (microrl_t * pThis, void (*sigintf)(void))
{
pThis->sigint = sigintf;
}
#endif
#ifdef _USE_ESC_SEQ
static void hist_search (microrl_t * pThis, int dir)
{
int len = hist_restore_line (&pThis->ring_hist, pThis->cmdline, dir);
if (len >= 0) {
pThis->cursor = pThis->cmdlen = len;
terminal_reset_cursor (pThis);
terminal_print_line (pThis, 0, pThis->cursor);
}
}
//*****************************************************************************
// handling escape sequences
static int escape_process (microrl_t * pThis, char ch)
{
if (ch == '[') {
pThis->escape_seq = _ESC_BRACKET;
return 0;
} else if (pThis->escape_seq == _ESC_BRACKET) {
if (ch == 'A') {
#ifdef _USE_HISTORY
hist_search (pThis, _HIST_UP);
#endif
return 1;
} else if (ch == 'B') {
#ifdef _USE_HISTORY
hist_search (pThis, _HIST_DOWN);
#endif
return 1;
} else if (ch == 'C') {
if (pThis->cursor < pThis->cmdlen) {
terminal_move_cursor (pThis, 1);
pThis->cursor++;
}
return 1;
} else if (ch == 'D') {
if (pThis->cursor > 0) {
terminal_move_cursor (pThis, -1);
pThis->cursor--;
}
return 1;
} else if (ch == '7') {
pThis->escape_seq = _ESC_HOME;
return 0;
} else if (ch == '8') {
pThis->escape_seq = _ESC_END;
return 0;
}
} else if (ch == '~') {
if (pThis->escape_seq == _ESC_HOME) {
terminal_reset_cursor (pThis);
pThis->cursor = 0;
return 1;
} else if (pThis->escape_seq == _ESC_END) {
terminal_move_cursor (pThis, pThis->cmdlen-pThis->cursor);
pThis->cursor = pThis->cmdlen;
return 1;
}
}
/* unknown escape sequence, stop */
return 1;
}
#endif
//*****************************************************************************
// insert len char of text at cursor position
static int microrl_insert_text (microrl_t * pThis, char * text, int len)
{
int i;
if (pThis->cmdlen + len < _COMMAND_LINE_LEN) {
memmove (pThis->cmdline + pThis->cursor + len,
pThis->cmdline + pThis->cursor,
pThis->cmdlen - pThis->cursor);
for (i = 0; i < len; i++) {
pThis->cmdline [pThis->cursor + i] = text [i];
if (pThis->cmdline [pThis->cursor + i] == ' ') {
pThis->cmdline [pThis->cursor + i] = 0;
}
}
pThis->cursor += len;
pThis->cmdlen += len;
pThis->cmdline [pThis->cmdlen] = '\0';
return true;
}
return false;
}
//*****************************************************************************
// remove one char at cursor
static void microrl_backspace (microrl_t * pThis)
{
if (pThis->cursor > 0) {
terminal_backspace (pThis);
memmove (pThis->cmdline + pThis->cursor-1,
pThis->cmdline + pThis->cursor,
pThis->cmdlen-pThis->cursor+1);
pThis->cursor--;
pThis->cmdline [pThis->cmdlen] = '\0';
pThis->cmdlen--;
}
}
#ifdef _USE_COMPLETE
//*****************************************************************************
static int common_len (char ** arr)
{
unsigned int i;
unsigned int j;
char *shortest = arr[0];
unsigned int shortlen = strlen(shortest);
for (i = 0; arr[i] != NULL; ++i)
if (strlen(arr[i]) < shortlen) {
shortest = arr[i];
shortlen = strlen(shortest);
}
for (i = 0; i < shortlen; ++i)
for (j = 0; arr[j] != 0; ++j)
if (shortest[i] != arr[j][i])
return i;
return i;
}
//*****************************************************************************
static void microrl_get_complite (microrl_t * pThis)
{
char const * tkn_arr[_COMMAND_TOKEN_NMB];
char ** compl_token;
if (pThis->get_completion == NULL) // callback was not set
return;
int status = split (pThis, pThis->cursor, tkn_arr);
if (pThis->cmdline[pThis->cursor-1] == '\0')
tkn_arr[status++] = "";
compl_token = pThis->get_completion (status, tkn_arr);
if (compl_token[0] != NULL) {
int i = 0;
int len;
if (compl_token[1] == NULL) {
len = strlen (compl_token[0]);
} else {
len = common_len (compl_token);
terminal_newline (pThis);
while (compl_token [i] != NULL) {
pThis->print (compl_token[i]);
pThis->print (" ");
i++;
}
terminal_newline (pThis);
print_prompt (pThis);
}
if (len) {
microrl_insert_text (pThis, compl_token[0] + strlen(tkn_arr[status-1]),
len - strlen(tkn_arr[status-1]));
if (compl_token[1] == NULL)
microrl_insert_text (pThis, " ", 1);
}
terminal_reset_cursor (pThis);
terminal_print_line (pThis, 0, pThis->cursor);
}
}
#endif
//*****************************************************************************
void new_line_handler(microrl_t * pThis){
char const * tkn_arr [_COMMAND_TOKEN_NMB];
int status;
terminal_newline (pThis);
#ifdef _USE_HISTORY
if (pThis->cmdlen > 0)
hist_save_line (&pThis->ring_hist, pThis->cmdline, pThis->cmdlen);
#endif
status = split (pThis, pThis->cmdlen, tkn_arr);
if (status == -1){
// pThis->print ("ERROR: Max token amount exseed\n");
pThis->print ("ERROR:too many tokens");
pThis->print (ENDL);
}
if ((status > 0) && (pThis->execute != NULL))
pThis->execute (status, tkn_arr);
print_prompt (pThis);
pThis->cmdlen = 0;
pThis->cursor = 0;
memset(pThis->cmdline, 0, _COMMAND_LINE_LEN);
#ifdef _USE_HISTORY
pThis->ring_hist.cur = 0;
#endif
}
//*****************************************************************************
void microrl_insert_char (microrl_t * pThis, int ch)
{
#ifdef _USE_ESC_SEQ
if (pThis->escape) {
if (escape_process(pThis, ch))
pThis->escape = 0;
} else {
#endif
switch (ch) {
//-----------------------------------------------------
#ifdef _ENDL_CR
case KEY_CR:
new_line_handler(pThis);
break;
case KEY_LF:
break;
#elif defined(_ENDL_CRLF)
case KEY_CR:
pThis->tmpch = KEY_CR;
break;
case KEY_LF:
if (pThis->tmpch == KEY_CR)
new_line_handler(pThis);
break;
#elif defined(_ENDL_LFCR)
case KEY_LF:
pThis->tmpch = KEY_LF;
break;
case KEY_CR:
if (pThis->tmpch == KEY_LF)
new_line_handler(pThis);
break;
#else
case KEY_CR:
break;
case KEY_LF:
new_line_handler(pThis);
break;
#endif
//-----------------------------------------------------
#ifdef _USE_COMPLETE
case KEY_HT:
microrl_get_complite (pThis);
break;
#endif
//-----------------------------------------------------
case KEY_ESC:
#ifdef _USE_ESC_SEQ
pThis->escape = 1;
#endif
break;
//-----------------------------------------------------
case KEY_NAK: // ^U
while (pThis->cursor > 0) {
microrl_backspace (pThis);
}
terminal_print_line (pThis, 0, pThis->cursor);
break;
//-----------------------------------------------------
case KEY_VT: // ^K
pThis->print ("\033[K");
pThis->cmdlen = pThis->cursor;
break;
//-----------------------------------------------------
case KEY_ENQ: // ^E
terminal_move_cursor (pThis, pThis->cmdlen-pThis->cursor);
pThis->cursor = pThis->cmdlen;
break;
//-----------------------------------------------------
case KEY_SOH: // ^A
terminal_reset_cursor (pThis);
pThis->cursor = 0;
break;
//-----------------------------------------------------
case KEY_ACK: // ^F
if (pThis->cursor < pThis->cmdlen) {
terminal_move_cursor (pThis, 1);
pThis->cursor++;
}
break;
//-----------------------------------------------------
case KEY_STX: // ^B
if (pThis->cursor) {
terminal_move_cursor (pThis, -1);
pThis->cursor--;
}
break;
//-----------------------------------------------------
case KEY_DLE: //^P
#ifdef _USE_HISTORY
hist_search (pThis, _HIST_UP);
#endif
break;
//-----------------------------------------------------
case KEY_SO: //^N
#ifdef _USE_HISTORY
hist_search (pThis, _HIST_DOWN);
#endif
break;
//-----------------------------------------------------
case KEY_DEL: // Backspace
case KEY_BS: // ^U
microrl_backspace (pThis);
terminal_print_line (pThis, pThis->cursor, pThis->cursor);
break;
#ifdef _USE_CTLR_C
case KEY_ETX:
if (pThis->sigint != NULL)
pThis->sigint();
break;
#endif
//-----------------------------------------------------
default:
if (((ch == ' ') && (pThis->cmdlen == 0)) || IS_CONTROL_CHAR(ch))
break;
if (microrl_insert_text (pThis, (char*)&ch, 1))
terminal_print_line (pThis, pThis->cursor-1, pThis->cursor);
break;
}
#ifdef _USE_ESC_SEQ
}
#endif
}
View Git Blame Copy Permalink