path: root/main/common/edit.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.
 *
 **************************************************************************
 *
 * edit.c:
 *
 * A simple buffer editor. It allows a user to pull a TFS file into RAM,
 * make some "ed-like" modifications to the ASCII data and then write
 * that data back to TFS.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#if INCLUDE_EDIT
#include "stddefs.h"
#include "genlib.h"
#include "tfs.h"
#include "tfsprivate.h"
#include <ctype.h>
#include "cli.h"

extern char *file_line_edit(char *);
static int	rmCR(char *,int);
static int	gotoline(char *,char *,char **,char *,int);
static int	searchfor(char *,char *,char **,char *);
static int	whatlineisthis(char *,char *);
static int	getrange(char *,int *,int *,char *,char *,char *);
static void	lnprbuf(char *,char *,char *);
static void	prbuf(char *,char *);
static void prlno(int,int);
static void deletelines(char *,int,char *,char **,char **);
static char	*prline(char *,char *);
static char *skipwhite(char *);

#define BREAK			1
#define CONTINUE		2
#define FALLTHROUGH		3
#define INSERT			4
#define COMMAND			5
#define ESCAPE	 		0x1b

#define ILCMAX		8

void
efree(int size, char *buffer)
{
	if (size != 0)
		free(buffer);
}

/* Help text while in the editor: */
char *edithelp[] = {
	"Editor commands:",
	"d{LRNG}    delete line",
#if INCLUDE_LINEEDIT
	"e#         edit line # (uses 'ksh/vi-like' command line editing)",
#endif
	"i          enter insert mode (use '.' to exit insert mode)",
	"a          enter append mode (use '.' to exit append mode)",
	"j#         join line '#' with line '#+1'",
	"P[LRNG]    print buffer with line numbers",
	"p          print buffer",
	"q[fname]   quit edit, write file",
	"s[srchstr] goto line containing search string",
	"x          exit edit, do not write file",
	"#          goto line # (use '$' to go to last line)",
	".+/-#      goto line relative to current position",
	"",
	"Where...",
	"# represents a decimal number;",
	"LRNG represents a line number or inclusive line range (# or #-#);",
	0,
};

/* Help text outside the editor: */

char *EditHelp[] = {
	"Edit file or buffer",
	"-[b:c:f:i:m:rs:t] [filename]",
#if INCLUDE_VERBOSEHELP
	" -b {adr}  specify buffer base address",
	" -c {cmd}  in-line command",
	" -f {flgs} file flags (see tfs)",
	" -i {info} file info (see tfs)",
	" -m {size} specify allocation size for buffer",
	" -r        do not automatically remove carriage returns from file",
	" -s {size} size of buffer",
	" -t        convert tabs to spaces",
#endif
	0,
};

int
Edit(int argc,char *argv[])
{
	int		i, opt, tfd, quit, mode, bsize;
	char	ln[CMDLINESIZE], *lp, *cp, *cp1, *filename, *flags, *info;
	char	*buffer, *bp;	/* Buffer and pointer into buffer. */
	char	*eob;			/* Current EOF  pointer (max distance between */
							/* bp and buffer). */
	char	*inlinecmd[ILCMAX];	/* If non-NULL, it points to a list of */
								/* commands to be executed prior to going */
								/* into interactive mode. */
	int	ilcidx;				/* Index into in-line command table. */
	int	len;				/* Length of the incoming line. */
	int	size;				/* Size of buffer specified on command line. */
	int	cmdtot;				/* Running total of incoming lines. */
	int delcnt;				/* Used by :d when a range is specified. */
	int noCR;				/* Set by -r option to remove Carriage Returns */
	TFILE	tstruct, *tfp;

	tfp = (TFILE *)0;
	size = bsize = 0;
	flags = filename = (char*)0;
	buffer = (char *)getAppRamStart();
	info = (char *)0;
	noCR = 1;
	ilcidx = 0;
	for(i=0;i<8;i++)
		inlinecmd[i] = (char *)0;

	while ((opt = getopt(argc, argv, "b:c:f:i:m:rs:")) != -1) {
		switch (opt) {
		case 'b':
			buffer = (char *)strtol(optarg,(char **)0,0);
			break;
		case 'c':
			if (ilcidx < ILCMAX-1)
				inlinecmd[ilcidx++] = optarg;
			break;
		case 'f':
			flags = optarg;
			break;
		case 'i':
			info = optarg;
			break;
		case 'm':
			bsize = strtol(optarg,0,0);
			break;
		case 'r':
			noCR = 0;
			break;
		case 's':
			size = (int)strtol(optarg,(char **)0,0);
			break;
		default:
			return (CMD_PARAM_ERROR);
		}
	}

	if (bsize != 0) {
		buffer = malloc(bsize);
		if (!buffer)
			return(CMD_FAILURE);
	}

	if (argc == optind+1) {
		filename = argv[optind];
		if (tfsfstat(filename,&tstruct) != -1) {
			tfp = &tstruct;
			size = TFS_SIZE(tfp);
			if ((bsize > 0) && (size > bsize)) {
				printf("Allocation too small\n");
				efree(bsize,buffer);
				return(CMD_FAILURE);
			}
			tfd = tfsopen(filename,TFS_RDONLY,0);
			if (tfd < 0) {
				printf("%s: %s\n",filename,(char *)tfsctrl(TFS_ERRMSG,tfd,0));
				efree(bsize,buffer);
				return(CMD_FAILURE);
			}
			else {
				tfsread(tfd,buffer,size);
				tfsclose(tfd,0);
			}
		}
	}

	if ((noCR) && (size != 0)) {
		if ((buffer[size-1] != 0x0d) && (buffer[size-1] != 0x0a)) {
			printf("EOF linefeed inserted.\n");
			buffer[size++] =  0x0a;
			buffer[size] = 0;
		}
		size -= rmCR(buffer,size);
	}
	
	bp = buffer;
	eob = buffer + size;

	if (!ilcidx)
		printf("Edit buffer = 0x%lx.\nType '?' for help\n",(ulong)buffer);

	quit = 0;
	cmdtot = 0;
	mode = COMMAND;
	while(!quit) {
		lp = ln;
		if (ilcidx > cmdtot)
			strcpy(ln,inlinecmd[cmdtot]);
		else if (ilcidx) {		/* If ILC command set doesn't terminate */
								/* the edit session, force it here. */
			efree(bsize,buffer);
			return(CMD_SUCCESS);
		}
		else
			getline(ln,CMDLINESIZE,0);
		cmdtot++;
		if (mode == INSERT) {
			if (!strcmp(lp,"."))
				mode = COMMAND;
			else {
				len = strlen(lp) + 1;
				cp1 = eob + len;
				cp = eob;
				while(cp > bp) *--cp1 = *--cp;
				while(*lp) *bp++ = *lp++;
				*bp++ = '\n';
				eob += len;
			}
			continue;
		}
		if (!strcmp(ln,"x")) {				/* Exit editor now. */
			efree(bsize,buffer);
			return(CMD_SUCCESS);
		}
		else if (!strcmp(ln,"?")) {			/* Display help info. */
			char	**eh;

			eh = edithelp;
			while(*eh)
				printf("%s\n",*eh++);
		}
		else if (!strcmp(ln,"p"))			/* Print buffer. */
			prbuf(buffer,eob);
		else if (!strcmp(ln,"P"))			/* Print buffer with lines. */
			lnprbuf(buffer,bp,eob);
		else if (!strcmp(ln,"i"))			/* Enter insert mode. */
			mode = INSERT;
		else if (!strcmp(ln,"a")) {			/* Enter insert mode at */
			mode = INSERT;					/* next line */
			gotoline(".+1",buffer,&bp,eob,0);
		}
		else if (!strcmp(ln,"$")) {			/* Goto last line. */
			gotoline(ln,buffer,&bp,eob,0);
			gotoline(".-1",buffer,&bp,eob,1);
		}
		else if (isdigit(ln[0]) || (ln[0]=='.'))	/* Goto line. */
			gotoline(ln,buffer,&bp,eob,1);
		else if (ln[0] == 's') {			/* Go to line containing string. */
			char *str;
			str = skipwhite(&ln[1]);
			if (!*str)
				gotoline(".+1",buffer,&bp,eob,0);
			searchfor(str,buffer,&bp,eob);
		}
#if INCLUDE_LINEEDIT
		else if (ln[0] == 'e') {
			char	*copy, *eoc, *cp2, crlf[2];
			int		oldlnsize, newlnsize, toendsize;

			if (gotoline(&ln[1],buffer,&bp,eob,0) == -1)
				continue;
			copy = malloc(CMDLINESIZE);
			if (!copy)
				continue;
			eoc = copy + CMDLINESIZE - 3;
			cp = bp;
			cp1 = copy;
			oldlnsize = 0;
			while ((*cp != 0x0a) && (*cp != 0x0d) && (cp1 != eoc)) {
				if (*cp == '\t')	/* Tabs are replaced with spaces to */
					*cp = ' ';		/* eliminate whitespace confusion in */
				putchar(*cp);		/* the line editor. */
				*cp1++ = *cp++;
				oldlnsize++;
			}
			crlf[0] = *cp;
			if (*cp != *(cp+1)) {
				crlf[1] = *(cp+1);
				if (*(cp+1) == 0x0a || *(cp+1) == 0x0d)
					oldlnsize++;
			}
			else {
				crlf[1] = 0;
			}
			oldlnsize++;
			*cp1++ = ESCAPE;
			*cp1 = 0;
			if (file_line_edit(copy) != (char *)0) {
				newlnsize = strlen(copy);
				toendsize = eob - (bp+oldlnsize);
				copy[newlnsize++] = crlf[0];
				if (crlf[1] == 0x0d || crlf[1] == 0x0a)
					copy[newlnsize++] = crlf[1];
				copy[newlnsize] = 0;
				if (oldlnsize == newlnsize) {
					memcpy(bp,copy,newlnsize);
				}
				else if (oldlnsize > newlnsize) {
					strcpy(bp,copy);
					memcpy(bp+newlnsize,cp+1,toendsize);
				}
				else {
					cp1 = eob-1;
					cp2 = (char *)(eob+(newlnsize-oldlnsize)-1);
					for(i=0;i<toendsize;i++)
						*cp2-- = *cp1--;
					memcpy(bp,copy,newlnsize);
				}
				eob -= oldlnsize;
				eob += newlnsize;
			}
			free(copy);
		}
#endif
		else if (ln[0] == 'P') {
			int	range, first, last, currentline;

			range = getrange(&ln[1],&first,&last,buffer,bp,eob);
			if (range > 0) {
				char *bpcpy;

				bpcpy = bp;
				gotoline(".",buffer,&bpcpy,eob,0);
				currentline = whatlineisthis(buffer,bpcpy);
				if (gotoline(&ln[1],buffer,&bpcpy,eob,0) == -1)
					continue;
				for(i=first;i<=last;i++) {
					prlno(i,currentline);
					bpcpy = prline(bpcpy,eob);
				}
			}				
		}
		else if (ln[0] == 'j') {	/* Join line specified with next line */
			char *tmpeob;

			if (gotoline(&ln[1],buffer,&bp,eob,0) == -1)
				continue;
			tmpeob=eob-1;
			while(bp < tmpeob) {
				if (*bp ==  '\n') {
					memcpy(bp,bp+1,eob-bp);
					eob--;
					break;
				}
				bp++;
			}
		}
		else if (ln[0] == 'd') {	/* Delete line (or range of lines) */
			delcnt = getrange(&ln[1],0,0,buffer,bp,eob);
			deletelines(&ln[1],delcnt,buffer,&bp,&eob);
		}
		else if (ln[0] == 'q') { 	/* Quit edit, if filename is present */
			lp = &ln[1];			/* use it. */
			lp = skipwhite(lp);
			if (*lp)
				filename = lp;
			quit = 1;
		}
		else {
			printf("huh?\n");
		}
	}

	if (filename) {
		int err;
		char	buf[16];

		if (tfp) {
			int	link;

			/* If filename and TFS_NAME(tfp) differ, then we are editing
			 * a file through a symbolic link.  If it is a link, then we
			 * use the info/flags/filename from the source file (using the
			 * file pointer and ignoring user input stuff).
			 */
			link = strcmp(filename,TFS_NAME(tfp));

			if ((!flags) || (link))
				flags = (char *)tfsctrl(TFS_FBTOA,TFS_FLAGS(tfp),(long)buf);
			if ((!info) || (link))
				info = TFS_INFO(tfp);
			if (link) {
				printf("Updating source file '%s' thru link '%s'\n",
					TFS_NAME(tfp),filename);
				filename = TFS_NAME(tfp);
			}
		}
		if (!flags)
			flags = (char *)0;
		if (!info)
			info = (char *)0;
		err = tfsadd(filename,info,flags,(unsigned char *)buffer,eob-buffer);
		if (err != TFS_OKAY)
			printf("%s: %s\n",filename,(char *)tfsctrl(TFS_ERRMSG,err,0));
	}
	efree(bsize,buffer);
	return(CMD_SUCCESS);
}

static void
lnprbuf(char *buffer,char *bp,char *eob)
{
	int	lno, currentline;

	if (buffer == eob)
		return;

	lno = 1;
	currentline = whatlineisthis(buffer,bp);
	prlno(lno++,currentline);
	while(buffer < eob) {
		putchar(*buffer);
		if ((*buffer == '\n') && ((buffer + 1) != eob))
			prlno(lno++,currentline);
		buffer++;
	}
}

static void
prlno(int lno,int currentline)
{
	char	*fmt;

	if (lno == currentline)
		fmt = ">%2d: ";
	else
		fmt = "%3d: ";
	printf(fmt,lno);
}

static void
prbuf(char *bp,char *eob)
{
	while(bp < eob)
		putchar(*bp++);
}

char *
prline(char *bp,char *eob)
{
	while(bp < eob) {
		putchar(*bp);
		if (*bp == '\n')
			break;
		bp++;
	}
	return(bp+1);
}

/* searchfor():
 *	Step through the buffer starting at 'bp' and search for a memory match
 *	with the incoming string pointed to by 'srch'.  If not found, simply 
 *	return after the entire buffer has been searched (wrap to start if
 *	necessary).  If found, then adjust '*bp' to point to the beginning of
 *	of the line that contains the match.
 */
static int
searchfor(char *srch,char *buffer,char **bp,char *eob)
{
	static	char *lastsrchstring;
	char	*startedhere, *tbp;
	int	len;

	tbp = *bp;
	if (tbp < eob)
		startedhere = *bp;
	else
		tbp = startedhere = buffer;

	if (*srch) {
		len = strlen(srch);
		if (lastsrchstring)
			free(lastsrchstring);
		lastsrchstring = malloc(len+1);	
		if (lastsrchstring)
			strcpy(lastsrchstring,srch);
	}
	else if (lastsrchstring) {
		len = strlen(lastsrchstring);
		srch = lastsrchstring;
	}
	else
		return(-1);
	do {
		if ((tbp + len) > eob) {
			tbp = buffer;
		}
		else {
			if (!memcmp(tbp,srch,len)) {
				while(1) {
					if (tbp <= buffer) {
						*bp = buffer;
						break;
					}
					if (*tbp == '\n') {
						*bp = tbp+1;
						break;
					}
					tbp--;
				}
				prline(*bp,eob);
				return(0);
			}
			else
				tbp++;
		}
	} while(tbp != startedhere);
	printf("'%s' not found\n",srch);
	return(-1);
}

static int
gotoline(char *ln,char *buffer,char **bp,char *eob,int verbose)
{
	int		lno, i, moveforward;
	char	*tbp, *base;

	base = buffer;
	moveforward = 1;

	/* If destination line number is '.', assume you're already there.
	 * If the '.' is followed by a '+' or '-' then the following number
	 * is considered an offset from the current line instead of from the
	 * start of the buffer.
	 */
	if (ln[0] == '.') {
		base = *bp;
		if (ln[1] == '+')
			lno = atoi(&ln[2]) + 1;
		else if (ln[1] == '-') {
			lno = atoi(&ln[2]) + 2;
			moveforward = 0;
		}
		else
			goto end;
	}
	else if (ln[0] == '$') {
		lno = 99999999;
	}
	else
		lno = atoi(ln);

	if (lno < 1) {
		printf("Invalid line\n");
		return(-1);
	}

	if (moveforward) {
		for(tbp=base,i=1;i<lno&&tbp<eob;tbp++)
			if (*tbp == '\n') i++;
		if (tbp == eob) {
			if (verbose)
				printf("Pointer set to end of buffer.\n");
			/* If out of range, set pointer to end of buffer. */
			*bp = eob;
			return(-1);
		}
	}
	else {
		for(tbp=base,i=1;i<lno&&tbp>=buffer;tbp--)
			if (*tbp == '\n') i++;
		if (tbp < buffer) {
			if (verbose)
				printf("Pointer set to start of buffer.\n");
			/* If out of range, set pointer to beginning of buffer. */
			*bp = buffer;
			return(-1);
		}
		tbp+=2;
	}
	*bp = tbp;

end:
	if (verbose) {
		printf("%3d: ",whatlineisthis(buffer,*bp));
		prline(*bp,eob);
	}
	return(0);
}

static int
whatlineisthis(char *buffer,char *bp)
{
	int		lno;
	char	*cp;
	cp = buffer;

	lno = 1;
	while(cp < bp) {
		if (*cp == '\n')
			lno++;
		cp++;
	}
	return(lno);
}

static int
getrange(char *cp,int *begin,int *end,char *buffer,char *bp,char *eob)
{
	char	*dash;
	int		b, e, lastline, thisline;

	if (!*cp)
		return(0);

	lastline = whatlineisthis(buffer,eob) - 1;
	thisline = whatlineisthis(buffer,bp);

	if (*cp == '.')
		b = thisline;
	else
		b = atoi(cp);
	dash = strchr(cp,'-');
	if (dash) {
		if (*(dash+1) == '$')
			e = lastline;
		else if (*(dash+1) == '.')
			e = thisline;
		else
			e = atoi(dash+1);
	}
	else
		e = b;

	if (e > lastline)
		e = lastline;
	if (begin)
		*begin = b;
	if (end)
		*end = e;
	if ((e <= 0) || (b <=0) || (e < b))
		printf("Bad range\n");
	return(e - b + 1);
}

static void
deletelines(char *lp,int lcnt,char *buffer,char **bp,char **eob)
{
	char	*cp, *cp1, *t_bp, *t_eob;

	if (lcnt <= 0)
		return;

	t_bp = *bp;
	t_eob = *eob;

	if (gotoline(lp,buffer,&t_bp,t_eob,0) == -1)
		return;
	cp = cp1 = t_bp;
	while(lcnt>0) {
		if (cp >= t_eob) {
			printf("Pointer set to end of buffer.\n");
			break;
		}
		if (*cp == '\n')
			lcnt--;
		cp++;
	}
	while(cp != t_eob)
		*cp1++ = *cp++;

	*eob = cp1;
	*bp = t_bp;
}

static char *
skipwhite(char *cp)
{
	while((*cp == ' ') || (*cp == '\t'))
		cp++;
	return(cp);
}

/* rmCR():
 *	Given the source and size of the buffer, remove all instances of 0x0d
 *	(carriage return) from the buffer.  Return the number of CRs removed.
*/
static int
rmCR(char *src,int size)
{
	int	i;				/* Index into src array. */
	int	tot;			/* Keep track of total # of 0x0d's removed. */
	int	remaining;		/* Keep track of how far to go. */
	
	tot = 0;
	remaining = size;
	for (i=0;i<size;i++) {
		remaining--;
		if (src[i] == 0x0d) {
			src[i] = 0;			/* Make sure memory is writeable. */
			if (src[i] != 0)
				continue;
			memcpy(&src[i],&src[i+1],remaining);
			tot++;
		}
	}
	if (tot)
		printf("Removed %d CRs\n",tot);
	return(tot);
}

#endif