path: root/main/common/ledit_vi.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * lineedit.c:
 *
 * This code supports the monitor's command line editing capability and
 * command history log.  The command line editing is a subset of KSH's
 * vi-mode editing.
 *
 * This code includes a few suggestions/fixed from Martin Carroll.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */

#include "config.h"
#if INCLUDE_LINEEDIT
#include <ctype.h>
#include "genlib.h"
#include "stddefs.h"
#include "cli.h"

#define HMAX			16
#define ESC				0x1B
#define CTLC			0x03
#define BACKSPACE		0x08
#define CMD				100
#define EDIT			101
#define EDIT1			102
#define INSERT			103
#define NEXT			104
#define PREV			105
#define NEITHER			106

#define EDITFILELINE	1
#define EDITCMDLINE		2

static int		stridx;			/* store index */
static int		shwidx;			/* show index */
static int		srchidx;		/* search index */
static int		lastsize;		/* size of last command */
static char		curChar;		/* latest input character */
static char		*curPos;		/* current position on command line */
static char		*startOfLine;	/* start of command line */
static int		lineLen;		/* length of line */
static int		lMode;			/* present mode of entry */
static char		cmdhistory[HMAX+1][CMDLINESIZE];/* array for command history */

static void		ledit(), lcmd(), showprev(), ldelete(), linsert(), lerase();
static void		gotobegin(), gotoend(), backup(), shownext(), linsertbs();
static void		delete_to_end(), delete_something();
static void		historysearch(void), ledit1(void);
static char 	*lineeditor();

/* line_edit() & file_line_edit():
 * These two functions are simply front-ends to the lineeditor()
 * function.  The line_edit() function is called by the command line
 * interface and file_line_edit() is called by the flash file editor
 * to provide a convenient single line editor when modifying a file.
 */

char *
line_edit(char *line_to_edit)
{
	return(lineeditor(line_to_edit,EDITCMDLINE));
}

char *
file_line_edit(char *line_to_edit)
{
	return(lineeditor(line_to_edit,EDITFILELINE));
}

/* lineeditor():
 * This function is fed a pointer to a command line.
 * It sets up a command line editor for that particular line.
 * The line is modified in place so, if successful, the function
 * returns the same pointer but with its contents modified based
 * on the editor commands executed.
 * If failure, the function returns (char *)0.
 */
static char *
lineeditor(char *line_to_edit,int type)
{
	lMode = CMD;
	startOfLine = line_to_edit;
	curPos = line_to_edit;
	while(*curPos != ESC) 
		curPos++;
	*curPos = 0;	/* Remove the escape character from the line */
	lineLen = (ulong)curPos - (ulong)startOfLine;
	if (lineLen > 0) {
		curPos--;
		putstr(" \b\b");
	}
	else
		putstr(" \b");
	lastsize = 0;
	shwidx = stridx;
	srchidx = stridx;
	while(1) {
		curChar = getchar();
		switch(curChar) {
			case ESC:
				if (lMode != CMD) {
					lMode = CMD;
					continue;
				}
				else {
					putchar('\n');
					return((char *)0);
				}
			case '\r':
			case '\n':
				putchar('\n');
				if (lineLen == 0) 
					return((char *)0);
				*(char *)(startOfLine + lineLen) = '\0';
				return(startOfLine);
			case CTLC:
				putchar('\n');
				*startOfLine = 0;
				lineLen = 0;
				return((char *)0);
		}
		switch(lMode) {
			case CMD:
				lcmd(type);
				if (lMode == NEITHER)
					return((char *)0);
				break;
			case INSERT:
				linsert();
				break;
			case EDIT1:
				ledit1();
				break;
			case EDIT:
				ledit();
				break;
		}
		if (lineLen >= (CMDLINESIZE - 2)) {
			printf("line overflow\n");
				return((char *)0);
		}
	}
}

static void
ledit(void)
{
	int	len;

	if (curChar == '\b') 
		curPos--;
	else
		*curPos++ = curChar;

	len = (curPos - startOfLine);	/* line may get longer than original */
	if (len > lineLen)
		lineLen = len;

	putchar(curChar);
	switch(lMode) {
		case EDIT1:
			lMode = CMD;
			break;
	}
}

static void
ledit1(void)
{
	*curPos = curChar;
	putchar(curChar);
	putchar('\b');
	lMode = CMD;
}

static void
lcmd(int type)
{
	switch(curChar) {
		case '0':
			gotobegin();
			return;
		case '$':
			gotoend();
			return;
		case 'A':
			gotoend();
			putchar(*curPos++);
			lMode = INSERT;
			return;
		case 'a':
			if (curPos != startOfLine)
				putchar(*curPos++);
			lMode = INSERT;
			return;
		case 'i':
			lMode = INSERT;
			return;
		case 'D':
			delete_to_end();
			return;
		case 'd':
			delete_something();
			return;
		case 'c':
			delete_something();
			lMode = INSERT;
			return;
		case 'x':
			ldelete();
			return;
		case ' ':
		case 'l':
			if (curPos < startOfLine+lineLen-1) {
				putchar(*curPos);
				curPos++;
			}
			return;
		case '\b':
		case 'h':
			if (curPos > startOfLine) {
				putchar('\b');
				curPos--;
			}
			return;
		case 'r':
			lMode = EDIT1;
			return;
		case 'R':
			lMode = EDIT;
			return;
	}

	/* The remaining commands should only be processed if we are editing
	 * a command line.  For editing a line in a file, the commands that
	 * relate to command line history are not applicable and should be
	 * blocked.
	 */
	if (type == EDITCMDLINE) {
		switch(curChar) {
			case '/':
				putchar('/');
				historysearch();
				return;
			case '+':
			case 'j':
				shownext();
				return;
			case '-':
			case 'k':
				showprev();
				return;
		}
	}

	/* Beep to indicate an error. */
	putchar(0x07);
}

static void
linsert()
{
	char	string[CMDLINESIZE];

	if (curChar == BACKSPACE) {
		linsertbs();
		return;
	}
	if (!isprint(curChar))
		return;
	putchar(curChar);
	putstr(curPos);
	backup((int)strlen(curPos));
	strncpy(string,curPos,CMDLINESIZE-1);
	*curPos++ = curChar;
	strcpy(curPos,string);
	lineLen++;
}

/* linsertbs():
 * Handle the backspace when in 'INSERT' mode.
 */

static void
linsertbs()
{
	char	*eol, *now;
	int	cnt;

	if (curPos == startOfLine)
		return;
	backup(1);
	curPos--;
	cnt = 0;
	eol = startOfLine + lineLen - 1;
	now = curPos;
	while(curPos <= eol) {
		*curPos = *(curPos+1);
		curPos++;
		cnt++;
	}
	putbytes(now,cnt-1);
	putchar(' ');
	backup((int)cnt);
	curPos = now;
	lineLen--;
}

static void
delete_something()
{
	char	*eol, *now, C, *new;
	int	cnt;

	C = getchar();
	if (C == 'w') {		/* word */
		now = curPos;
		eol = startOfLine + lineLen -1;
		while (curPos <= eol) {
			if (*curPos == ' ')
				break;
			curPos++;
		}
		if (curPos < eol) {
			new = curPos;
			strcpy(now,new);
			cnt = strlen(now);
			putbytes(now,cnt);
			curPos = now + cnt;
			while(curPos <= eol) {
				putchar(' ');
				curPos++;
				cnt++;
			}
			backup(cnt);
		}
		else {
			curPos = now;
			delete_to_end();
			return;
		}
		curPos = now;
		lineLen = strlen(startOfLine);
	}
	else if (C == 'f') {		/* find */
		C = getchar();
		now = curPos;
		eol = startOfLine + lineLen -1;
		while (curPos <= eol) {
			if (*curPos == C)
				break;
			curPos++;
		}
		if (curPos < eol) {
			new = curPos+1;
			strcpy(now,new);
			cnt = strlen(now);
			putbytes(now,cnt);
			curPos = now + cnt;
			while(curPos <= eol) {
				putchar(' ');
				curPos++;
				cnt++;
			}
			backup(cnt);
		}
		else {
			curPos = now;
			delete_to_end();
			return;
		}
		curPos = now;
		lineLen = strlen(startOfLine);
	}
}

static void
delete_to_end()
{
	char	*eol, *now, *sol;

	eol = startOfLine + lineLen;
	now = curPos;
	if (curPos == eol)
		return;
	while(curPos < eol) {
		putchar(' ');
		curPos++;
	}
	if (now == startOfLine)
		sol = now+1;
	else
		sol = now;
	while(curPos >= sol) {
		putchar('\b');
		curPos--;
	}
	lineLen = now - startOfLine;
	if (lineLen == 0) {
		curPos = startOfLine;
		*curPos = 0;
	}
	else
		*(curPos+1) = '\0';
}

static void
ldelete()
{
	char	*eol, *now;
	int	cnt;

	if (lineLen == 0)
		return;
	cnt = 0;
	eol = startOfLine + lineLen - 1;
	now = curPos;
	if (curPos != eol) {
		while(curPos <= eol) {
			*curPos = *(curPos+1);
			curPos++;
			cnt++;
		}
		putbytes(now,cnt-1);
		putchar(' ');
		backup((int)cnt);
	}
	else {
		putstr(" \b\b");
		*eol = '\0';
		now--;
	}
	curPos = now;
	lineLen--;
	if (lineLen == 0)
		curPos = startOfLine;
}

/* showdone():
 * Used as common completion code for the showprev() and
 * shownext() functions below.
 */
static void
showdone(int idx)
{
	if (idx == HMAX) {
		printf("History buffer empty.\007\n");
		lMode = NEITHER;
		return;
	}

	backup((int)(curPos - startOfLine));
	lineLen = strlen(cmdhistory[shwidx]);
	putbytes(cmdhistory[shwidx],lineLen);
	lerase((int)(lastsize-lineLen));
	backup((int)(lineLen));
	strcpy(startOfLine,cmdhistory[shwidx]);
	curPos = startOfLine;
	lastsize = lineLen;
}

/* showprev() & shownext():
 * Show previous or next command in history list based on 
 * the current position in the list being established by
 * the shwidx variable.
 */
static void
showprev()
{
	int	i;

	if (shwidx == 0)
		shwidx = HMAX-1;
	else
		shwidx--;

	for(i=0;i<HMAX;i++) {
		if (*cmdhistory[shwidx])
			break;
		if (shwidx == 0)
			shwidx = HMAX-1;
		else
			shwidx--;
	}
	showdone(i);
}


static void
shownext()
{
	int	i;

	if (shwidx == HMAX-1)
		shwidx = 0;
	else
		shwidx++;

	for(i=0;i<HMAX;i++) {
		if (*cmdhistory[shwidx])
			break;
		if (shwidx == HMAX)
			shwidx = 0;
		else
			shwidx++;
	}
	showdone(i);
}

static void
backup(count)
int	count;
{
	char	string[CMDLINESIZE];
	int	i;

	if (count <= 0)
		return;
	*string = '\0';
	for(i=0;i<count;i++)
		strcat(string,"\b");
	putbytes(string,count);
}

static void
lerase(int count)
{
	char	string[CMDLINESIZE];
	int	i;

	if (count <= 0)
		return;
	*string = '\0';
	for(i=0;i<count;i++)
		strcat(string," ");
	for(i=0;i<count;i++)
		strcat(string,"\b");
	putbytes(string,count*2);
}

static void
gotoend()
{
	char	string[CMDLINESIZE], *eol;
	int	i;

	eol = startOfLine + lineLen -1;
	for (i=0;i<CMDLINESIZE-1;i++) {
		if (curPos == eol)
			break;
		string[i] = *curPos++;
	}
	if (i)
		putbytes(string,i);
}

static void
gotobegin()
{
	char	string[CMDLINESIZE];
	int	i;

	i = 0;
	while(curPos != startOfLine) {
		string[i++] = '\b';
		curPos--;
	}
	putbytes(string,i);
}

/* History():
 * Command used at the CLI to allow the user to dump the content
 * of the history buffer.
 */
char * HistoryHelp[] = {
		"Display command history",
		"",
		0,
};
	
int
History(int argc,char *argv[])
{
	int	i;

	for(i=stridx;i<HMAX;i++) {
		if (cmdhistory[i][0])
			printf("%s\n",cmdhistory[i]);
	}
	if (stridx) {
		for(i=0;i<stridx;i++) {
			if (cmdhistory[i][0])
				printf("%s\n",cmdhistory[i]);
		}
	}
	return(CMD_SUCCESS);
}

/* historyinit():
 * Initialize the command history...
 */
void
historyinit()
{
	int	i;

	shwidx = stridx = 0;
	for (i=0;i<HMAX;i++)
		cmdhistory[i][0] = 0;
}

/* historylog():
 * This function is called by the CLI retrieval code to store away
 * the command in the CLI history list, a circular queue
 * (size HMAX) of most recent commands.
 */
void
historylog(char *cmdline)
{
	int	idx;

	if (strlen(cmdline) >= CMDLINESIZE)
		return;

	if (stridx == 0)
		idx = HMAX-1;
	else
		idx = stridx -1;

	/* don't store if this command is same as last command */
	if (strcmp(cmdhistory[idx],cmdline) == 0)
		return;

	if (stridx == HMAX)
		stridx = 0;

	strcpy(cmdhistory[stridx++],cmdline);
}


static void
historysearch(void)
{
	static char	string[100];
	char	*s, *ptr, *last, C;
	int	size, len, count;

	lerase((int)lastsize);
	s = string;
	size = 0;
	while(1) {
		C = getchar();
		if (C == '\b') {
			if (size == 0)
				continue;
			putstr("\b \b");
			s--;
			size--;
			continue;
		}
		if ((C == '\r') || (C == '\n'))
			break;
		putchar(C);
		size++;
		*s++ = C;
	}
	backup((int)(size+1));
	if (size != 0)
		*s = '\0';
	else 
		size = strlen(string);

	count = 0;

	while(1) {
		ptr = cmdhistory[srchidx];
		len = strlen(ptr);
		last = ptr + len - size + 1;
		while(ptr < last) {
			if (strncmp(ptr,string,size) == 0) 
				goto gotmatch;
			ptr++;
		}
		if (srchidx == 0)
			srchidx = HMAX-1;
		else
			srchidx--;
		if (++count == HMAX) {
			backup((int)(curPos - startOfLine));
			lineLen = 0;
			lerase((int)(size+1));
			backup((int)(lineLen));
			*startOfLine = '\0';
			curPos = startOfLine;
			lastsize = lineLen;
			return;
		}
	}
gotmatch:
	backup((int)(curPos - startOfLine));
	lineLen = strlen(cmdhistory[srchidx]);
	putbytes(cmdhistory[srchidx],lineLen);
	lerase((int)(lastsize-lineLen));
	backup((int)(lineLen));
	strcpy(startOfLine,cmdhistory[srchidx]);
	curPos = startOfLine;
	lastsize = lineLen;
	if (srchidx == 0)
		srchidx = HMAX-1;
	else
		srchidx--;
	return;
}

#endif