busybox/editors/ed.c

/* vi: set sw=4 ts=4: */
/*
 * Copyright (c) 2002 by David I. Bell
 * Permission is granted to use, distribute, or modify this source,
 * provided that this copyright notice remains intact.
 *
 * The "ed" built-in command (much simplified)
 */

#include "libbb.h"

typedef struct LINE {
	struct LINE *next;
	struct LINE *prev;
	int len;
	char data[1];
} LINE;


#define searchString bb_common_bufsiz1

enum {
	USERSIZE = sizeof(searchString) > 1024 ? 1024
	         : sizeof(searchString) - 1, /* max line length typed in by user */
	INITBUF_SIZE = 1024, /* initial buffer size */
};

struct globals {
	int curNum;
	int lastNum;
	int bufUsed;
	int bufSize;
	LINE *curLine;
	char *bufBase;
	char *bufPtr;
	char *fileName;
	LINE lines;
	smallint dirty;
	int marks[26];
};
#define G (*ptr_to_globals)
#define curLine            (G.curLine           )
#define bufBase            (G.bufBase           )
#define bufPtr             (G.bufPtr            )
#define fileName           (G.fileName          )
#define curNum             (G.curNum            )
#define lastNum            (G.lastNum           )
#define bufUsed            (G.bufUsed           )
#define bufSize            (G.bufSize           )
#define dirty              (G.dirty             )
#define lines              (G.lines             )
#define marks              (G.marks             )
#define INIT_G() do { \
	SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
} while (0)


static void doCommands(void);
static void subCommand(const char *cmd, int num1, int num2);
static int getNum(const char **retcp, smallint *retHaveNum, int *retNum);
static int setCurNum(int num);
static void addLines(int num);
static int insertLine(int num, const char *data, int len);
static void deleteLines(int num1, int num2);
static int printLines(int num1, int num2, int expandFlag);
static int writeLines(const char *file, int num1, int num2);
static int readLines(const char *file, int num);
static int searchLines(const char *str, int num1, int num2);
static LINE *findLine(int num);
static int findString(const LINE *lp, const char * str, int len, int offset);


static int bad_nums(int num1, int num2, const char *for_what)
{
	if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
		bb_error_msg("bad line range for %s", for_what);
		return 1;
	}
	return 0;
}


static char *skip_blank(const char *cp)
{
	while (isblank(*cp))
		cp++;
	return (char *)cp;
}


int ed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int ed_main(int argc UNUSED_PARAM, char **argv)
{
	INIT_G();

	bufSize = INITBUF_SIZE;
	bufBase = xmalloc(bufSize);
	bufPtr = bufBase;
	lines.next = &lines;
	lines.prev = &lines;

	if (argv[1]) {
		fileName = xstrdup(argv[1]);
		if (!readLines(fileName, 1)) {
			return EXIT_SUCCESS;
		}
		if (lastNum)
			setCurNum(1);
		dirty = FALSE;
	}

	doCommands();
	return EXIT_SUCCESS;
}

/*
 * Read commands until we are told to stop.
 */
static void doCommands(void)
{
	const char *cp;
	char *endbuf, buf[USERSIZE];
	int len, num1, num2;
	smallint have1, have2;

	while (TRUE) {
		/* Returns:
		 * -1 on read errors or EOF, or on bare Ctrl-D.
		 * 0  on ctrl-C,
		 * >0 length of input string, including terminating '\n'
		 */
		len = read_line_input(": ", buf, sizeof(buf), NULL);
		if (len <= 0)
			return;
		endbuf = &buf[len - 1];
		while ((endbuf > buf) && isblank(endbuf[-1]))
			endbuf--;
		*endbuf = '\0';

		cp = skip_blank(buf);
		have1 = FALSE;
		have2 = FALSE;

		if ((curNum == 0) && (lastNum > 0)) {
			curNum = 1;
			curLine = lines.next;
		}

		if (!getNum(&cp, &have1, &num1))
			continue;

		cp = skip_blank(cp);

		if (*cp == ',') {
			cp++;
			if (!getNum(&cp, &have2, &num2))
				continue;
			if (!have1)
				num1 = 1;
			if (!have2)
				num2 = lastNum;
			have1 = TRUE;
			have2 = TRUE;
		}
		if (!have1)
			num1 = curNum;
		if (!have2)
			num2 = num1;

		switch (*cp++) {
		case 'a':
			addLines(num1 + 1);
			break;

		case 'c':
			deleteLines(num1, num2);
			addLines(num1);
			break;

		case 'd':
			deleteLines(num1, num2);
			break;

		case 'f':
			if (*cp && !isblank(*cp)) {
				bb_error_msg("bad file command");
				break;
			}
			cp = skip_blank(cp);
			if (*cp == '\0') {
				if (fileName)
					printf("\"%s\"\n", fileName);
				else
					printf("No file name\n");
				break;
			}
			free(fileName);
			fileName = xstrdup(cp);
			break;

		case 'i':
			addLines(num1);
			break;

		case 'k':
			cp = skip_blank(cp);
			if ((*cp < 'a') || (*cp > 'z') || cp[1]) {
				bb_error_msg("bad mark name");
				break;
			}
			marks[*cp - 'a'] = num2;
			break;

		case 'l':
			printLines(num1, num2, TRUE);
			break;

		case 'p':
			printLines(num1, num2, FALSE);
			break;

		case 'q':
			cp = skip_blank(cp);
			if (have1 || *cp) {
				bb_error_msg("bad quit command");
				break;
			}
			if (!dirty)
				return;
			len = read_line_input("Really quit? ", buf, 16, NULL);
			/* read error/EOF - no way to continue */
			if (len < 0)
				return;
			cp = skip_blank(buf);
			if ((*cp | 0x20) == 'y') /* Y or y */
				return;
			break;

		case 'r':
			if (*cp && !isblank(*cp)) {
				bb_error_msg("bad read command");
				break;
			}
			cp = skip_blank(cp);
			if (*cp == '\0') {
				bb_error_msg("no file name");
				break;
			}
			if (!have1)
				num1 = lastNum;
			if (readLines(cp, num1 + 1))
				break;
			if (fileName == NULL)
				fileName = xstrdup(cp);
			break;

		case 's':
			subCommand(cp, num1, num2);
			break;

		case 'w':
			if (*cp && !isblank(*cp)) {
				bb_error_msg("bad write command");
				break;
			}
			cp = skip_blank(cp);
			if (!have1) {
				num1 = 1;
				num2 = lastNum;
			}
			if (*cp == '\0')
				cp = fileName;
			if (cp == NULL) {
				bb_error_msg("no file name specified");
				break;
			}
			writeLines(cp, num1, num2);
			break;

		case 'z':
			switch (*cp) {
			case '-':
				printLines(curNum - 21, curNum, FALSE);
				break;
			case '.':
				printLines(curNum - 11, curNum + 10, FALSE);
				break;
			default:
				printLines(curNum, curNum + 21, FALSE);
				break;
			}
			break;

		case '.':
			if (have1) {
				bb_error_msg("no arguments allowed");
				break;
			}
			printLines(curNum, curNum, FALSE);
			break;

		case '-':
			if (setCurNum(curNum - 1))
				printLines(curNum, curNum, FALSE);
			break;

		case '=':
			printf("%d\n", num1);
			break;
		case '\0':
			if (have1) {
				printLines(num2, num2, FALSE);
				break;
			}
			if (setCurNum(curNum + 1))
				printLines(curNum, curNum, FALSE);
			break;

		default:
			bb_error_msg("unimplemented command");
			break;
		}
	}
}


/*
 * Do the substitute command.
 * The current line is set to the last substitution done.
 */
static void subCommand(const char *cmd, int num1, int num2)
{
	char *cp, *oldStr, *newStr, buf[USERSIZE];
	int delim, oldLen, newLen, deltaLen, offset;
	LINE *lp, *nlp;
	int globalFlag, printFlag, didSub, needPrint;

	if (bad_nums(num1, num2, "substitute"))
		return;

	globalFlag = FALSE;
	printFlag = FALSE;
	didSub = FALSE;
	needPrint = FALSE;

	/*
	 * Copy the command so we can modify it.
	 */
	strcpy(buf, cmd);
	cp = buf;

	if (isblank(*cp) || (*cp == '\0')) {
		bb_error_msg("bad delimiter for substitute");
		return;
	}

	delim = *cp++;
	oldStr = cp;

	cp = strchr(cp, delim);
	if (cp == NULL) {
		bb_error_msg("missing 2nd delimiter for substitute");
		return;
	}

	*cp++ = '\0';

	newStr = cp;
	cp = strchr(cp, delim);

	if (cp)
		*cp++ = '\0';
	else
		cp = (char*)"";

	while (*cp) switch (*cp++) {
		case 'g':
			globalFlag = TRUE;
			break;
		case 'p':
			printFlag = TRUE;
			break;
		default:
			bb_error_msg("unknown option for substitute");
			return;
	}

	if (*oldStr == '\0') {
		if (searchString[0] == '\0') {
			bb_error_msg("no previous search string");
			return;
		}
		oldStr = searchString;
	}

	if (oldStr != searchString)
		strcpy(searchString, oldStr);

	lp = findLine(num1);
	if (lp == NULL)
		return;

	oldLen = strlen(oldStr);
	newLen = strlen(newStr);
	deltaLen = newLen - oldLen;
	offset = 0;
	nlp = NULL;

	while (num1 <= num2) {
		offset = findString(lp, oldStr, oldLen, offset);

		if (offset < 0) {
			if (needPrint) {
				printLines(num1, num1, FALSE);
				needPrint = FALSE;
			}
			offset = 0;
			lp = lp->next;
			num1++;
			continue;
		}

		needPrint = printFlag;
		didSub = TRUE;
		dirty = TRUE;

		/*
		 * If the replacement string is the same size or shorter
		 * than the old string, then the substitution is easy.
		 */
		if (deltaLen <= 0) {
			memcpy(&lp->data[offset], newStr, newLen);
			if (deltaLen) {
				memcpy(&lp->data[offset + newLen],
					&lp->data[offset + oldLen],
					lp->len - offset - oldLen);

				lp->len += deltaLen;
			}
			offset += newLen;
			if (globalFlag)
				continue;
			if (needPrint) {
				printLines(num1, num1, FALSE);
				needPrint = FALSE;
			}
			lp = lp->next;
			num1++;
			continue;
		}

		/*
		 * The new string is larger, so allocate a new line
		 * structure and use that.  Link it in in place of
		 * the old line structure.
		 */
		nlp = malloc(sizeof(LINE) + lp->len + deltaLen);
		if (nlp == NULL) {
			bb_error_msg("cannot get memory for line");
			return;
		}

		nlp->len = lp->len + deltaLen;

		memcpy(nlp->data, lp->data, offset);
		memcpy(&nlp->data[offset], newStr, newLen);
		memcpy(&nlp->data[offset + newLen],
			&lp->data[offset + oldLen],
			lp->len - offset - oldLen);

		nlp->next = lp->next;
		nlp->prev = lp->prev;
		nlp->prev->next = nlp;
		nlp->next->prev = nlp;

		if (curLine == lp)
			curLine = nlp;

		free(lp);
		lp = nlp;

		offset += newLen;

		if (globalFlag)
			continue;

		if (needPrint) {
			printLines(num1, num1, FALSE);
			needPrint = FALSE;
		}

		lp = lp->next;
		num1++;
	}

	if (!didSub)
		bb_error_msg("no substitutions found for \"%s\"", oldStr);
}


/*
 * Search a line for the specified string starting at the specified
 * offset in the line.  Returns the offset of the found string, or -1.
 */
static int findString(const LINE *lp, const char *str, int len, int offset)
{
	int left;
	const char *cp, *ncp;

	cp = &lp->data[offset];
	left = lp->len - offset;

	while (left >= len) {
		ncp = memchr(cp, *str, left);
		if (ncp == NULL)
			return -1;
		left -= (ncp - cp);
		if (left < len)
			return -1;
		cp = ncp;
		if (memcmp(cp, str, len) == 0)
			return (cp - lp->data);
		cp++;
		left--;
	}

	return -1;
}


/*
 * Add lines which are typed in by the user.
 * The lines are inserted just before the specified line number.
 * The lines are terminated by a line containing a single dot (ugly!),
 * or by an end of file.
 */
static void addLines(int num)
{
	int len;
	char buf[USERSIZE + 1];

	while (1) {
		/* Returns:
		 * -1 on read errors or EOF, or on bare Ctrl-D.
		 * 0  on ctrl-C,
		 * >0 length of input string, including terminating '\n'
		 */
		len = read_line_input("", buf, sizeof(buf), NULL);
		if (len <= 0) {
			/* Previously, ctrl-C was exiting to shell.
			 * Now we exit to ed prompt. Is in important? */
			return;
		}
		if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '\0'))
			return;
		if (!insertLine(num++, buf, len))
			return;
	}
}


/*
 * Parse a line number argument if it is present.  This is a sum
 * or difference of numbers, '.', '$', 'x, or a search string.
 * Returns TRUE if successful (whether or not there was a number).
 * Returns FALSE if there was a parsing error, with a message output.
 * Whether there was a number is returned indirectly, as is the number.
 * The character pointer which stopped the scan is also returned.
 */
static int getNum(const char **retcp, smallint *retHaveNum, int *retNum)
{
	const char *cp;
	char *endStr, str[USERSIZE];
	int value, num;
	smallint haveNum, minus;

	cp = *retcp;
	value = 0;
	haveNum = FALSE;
	minus = 0;

	while (TRUE) {
		cp = skip_blank(cp);

		switch (*cp) {
			case '.':
				haveNum = TRUE;
				num = curNum;
				cp++;
				break;

			case '$':
				haveNum = TRUE;
				num = lastNum;
				cp++;
				break;

			case '\'':
				cp++;
				if ((*cp < 'a') || (*cp > 'z')) {
					bb_error_msg("bad mark name");
					return FALSE;
				}
				haveNum = TRUE;
				num = marks[*cp++ - 'a'];
				break;

			case '/':
				strcpy(str, ++cp);
				endStr = strchr(str, '/');
				if (endStr) {
					*endStr++ = '\0';
					cp += (endStr - str);
				} else
					cp = "";
				num = searchLines(str, curNum, lastNum);
				if (num == 0)
					return FALSE;
				haveNum = TRUE;
				break;

			default:
				if (!isdigit(*cp)) {
					*retcp = cp;
					*retHaveNum = haveNum;
					*retNum = value;
					return TRUE;
				}
				num = 0;
				while (isdigit(*cp))
					num = num * 10 + *cp++ - '0';
				haveNum = TRUE;
				break;
		}

		value += (minus ? -num : num);

		cp = skip_blank(cp);

		switch (*cp) {
			case '-':
				minus = 1;
				cp++;
				break;

			case '+':
				minus = 0;
				cp++;
				break;

			default:
				*retcp = cp;
				*retHaveNum = haveNum;
				*retNum = value;
				return TRUE;
		}
	}
}


/*
 * Read lines from a file at the specified line number.
 * Returns TRUE if the file was successfully read.
 */
static int readLines(const char *file, int num)
{
	int fd, cc;
	int len, lineCount, charCount;
	char *cp;

	if ((num < 1) || (num > lastNum + 1)) {
		bb_error_msg("bad line for read");
		return FALSE;
	}

	fd = open(file, 0);
	if (fd < 0) {
		perror(file);
		return FALSE;
	}

	bufPtr = bufBase;
	bufUsed = 0;
	lineCount = 0;
	charCount = 0;
	cc = 0;

	printf("\"%s\", ", file);
	fflush(stdout);

	do {
		cp = memchr(bufPtr, '\n', bufUsed);

		if (cp) {
			len = (cp - bufPtr) + 1;
			if (!insertLine(num, bufPtr, len)) {
				close(fd);
				return FALSE;
			}
			bufPtr += len;
			bufUsed -= len;
			charCount += len;
			lineCount++;
			num++;
			continue;
		}

		if (bufPtr != bufBase) {
			memcpy(bufBase, bufPtr, bufUsed);
			bufPtr = bufBase + bufUsed;
		}

		if (bufUsed >= bufSize) {
			len = (bufSize * 3) / 2;
			cp = realloc(bufBase, len);
			if (cp == NULL) {
				bb_error_msg("no memory for buffer");
				close(fd);
				return FALSE;
			}
			bufBase = cp;
			bufPtr = bufBase + bufUsed;
			bufSize = len;
		}

		cc = safe_read(fd, bufPtr, bufSize - bufUsed);
		bufUsed += cc;
		bufPtr = bufBase;

	} while (cc > 0);

	if (cc < 0) {
		perror(file);
		close(fd);
		return FALSE;
	}

	if (bufUsed) {
		if (!insertLine(num, bufPtr, bufUsed)) {
			close(fd);
			return -1;
		}
		lineCount++;
		charCount += bufUsed;
	}

	close(fd);

	printf("%d lines%s, %d chars\n", lineCount,
		(bufUsed ? " (incomplete)" : ""), charCount);

	return TRUE;
}


/*
 * Write the specified lines out to the specified file.
 * Returns TRUE if successful, or FALSE on an error with a message output.
 */
static int writeLines(const char *file, int num1, int num2)
{
	LINE *lp;
	int fd, lineCount, charCount;

	if (bad_nums(num1, num2, "write"))
		return FALSE;

	lineCount = 0;
	charCount = 0;

	fd = creat(file, 0666);
	if (fd < 0) {
		perror(file);
		return FALSE;
	}

	printf("\"%s\", ", file);
	fflush(stdout);

	lp = findLine(num1);
	if (lp == NULL) {
		close(fd);
		return FALSE;
	}

	while (num1++ <= num2) {
		if (full_write(fd, lp->data, lp->len) != lp->len) {
			perror(file);
			close(fd);
			return FALSE;
		}
		charCount += lp->len;
		lineCount++;
		lp = lp->next;
	}

	if (close(fd) < 0) {
		perror(file);
		return FALSE;
	}

	printf("%d lines, %d chars\n", lineCount, charCount);
	return TRUE;
}


/*
 * Print lines in a specified range.
 * The last line printed becomes the current line.
 * If expandFlag is TRUE, then the line is printed specially to
 * show magic characters.
 */
static int printLines(int num1, int num2, int expandFlag)
{
	const LINE *lp;
	const char *cp;
	int ch, count;

	if (bad_nums(num1, num2, "print"))
		return FALSE;

	lp = findLine(num1);
	if (lp == NULL)
		return FALSE;

	while (num1 <= num2) {
		if (!expandFlag) {
			write(STDOUT_FILENO, lp->data, lp->len);
			setCurNum(num1++);
			lp = lp->next;
			continue;
		}

		/*
		 * Show control characters and characters with the
		 * high bit set specially.
		 */
		cp = lp->data;
		count = lp->len;

		if ((count > 0) && (cp[count - 1] == '\n'))
			count--;

		while (count-- > 0) {
			ch = (unsigned char) *cp++;
			fputc_printable(ch | PRINTABLE_META, stdout);
		}

		fputs("$\n", stdout);

		setCurNum(num1++);
		lp = lp->next;
	}

	return TRUE;
}


/*
 * Insert a new line with the specified text.
 * The line is inserted so as to become the specified line,
 * thus pushing any existing and further lines down one.
 * The inserted line is also set to become the current line.
 * Returns TRUE if successful.
 */
static int insertLine(int num, const char *data, int len)
{
	LINE *newLp, *lp;

	if ((num < 1) || (num > lastNum + 1)) {
		bb_error_msg("inserting at bad line number");
		return FALSE;
	}

	newLp = malloc(sizeof(LINE) + len - 1);
	if (newLp == NULL) {
		bb_error_msg("failed to allocate memory for line");
		return FALSE;
	}

	memcpy(newLp->data, data, len);
	newLp->len = len;

	if (num > lastNum)
		lp = &lines;
	else {
		lp = findLine(num);
		if (lp == NULL) {
			free((char *) newLp);
			return FALSE;
		}
	}

	newLp->next = lp;
	newLp->prev = lp->prev;
	lp->prev->next = newLp;
	lp->prev = newLp;

	lastNum++;
	dirty = TRUE;
	return setCurNum(num);
}


/*
 * Delete lines from the given range.
 */
static void deleteLines(int num1, int num2)
{
	LINE *lp, *nlp, *plp;
	int count;

	if (bad_nums(num1, num2, "delete"))
		return;

	lp = findLine(num1);
	if (lp == NULL)
		return;

	if ((curNum >= num1) && (curNum <= num2)) {
		if (num2 < lastNum)
			setCurNum(num2 + 1);
		else if (num1 > 1)
			setCurNum(num1 - 1);
		else
			curNum = 0;
	}

	count = num2 - num1 + 1;
	if (curNum > num2)
		curNum -= count;
	lastNum -= count;

	while (count-- > 0) {
		nlp = lp->next;
		plp = lp->prev;
		plp->next = nlp;
		nlp->prev = plp;
		free(lp);
		lp = nlp;
	}

	dirty = TRUE;
}


/*
 * Search for a line which contains the specified string.
 * If the string is "", then the previously searched for string
 * is used.  The currently searched for string is saved for future use.
 * Returns the line number which matches, or 0 if there was no match
 * with an error printed.
 */
static int searchLines(const char *str, int num1, int num2)
{
	const LINE *lp;
	int len;

	if (bad_nums(num1, num2, "search"))
		return 0;

	if (*str == '\0') {
		if (searchString[0] == '\0') {
			bb_error_msg("no previous search string");
			return 0;
		}
		str = searchString;
	}

	if (str != searchString)
		strcpy(searchString, str);

	len = strlen(str);

	lp = findLine(num1);
	if (lp == NULL)
		return 0;

	while (num1 <= num2) {
		if (findString(lp, str, len, 0) >= 0)
			return num1;
		num1++;
		lp = lp->next;
	}

	bb_error_msg("cannot find string \"%s\"", str);
	return 0;
}


/*
 * Return a pointer to the specified line number.
 */
static LINE *findLine(int num)
{
	LINE *lp;
	int lnum;

	if ((num < 1) || (num > lastNum)) {
		bb_error_msg("line number %d does not exist", num);
		return NULL;
	}

	if (curNum <= 0) {
		curNum = 1;
		curLine = lines.next;
	}

	if (num == curNum)
		return curLine;

	lp = curLine;
	lnum = curNum;
	if (num < (curNum / 2)) {
		lp = lines.next;
		lnum = 1;
	} else if (num > ((curNum + lastNum) / 2)) {
		lp = lines.prev;
		lnum = lastNum;
	}

	while (lnum < num) {
		lp = lp->next;
		lnum++;
	}

	while (lnum > num) {
		lp = lp->prev;
		lnum--;
	}
	return lp;
}


/*
 * Set the current line number.
 * Returns TRUE if successful.
 */
static int setCurNum(int num)
{
	LINE *lp;

	lp = findLine(num);
	if (lp == NULL)
		return FALSE;
	curNum = num;
	curLine = lp;
	return TRUE;
}
1	/* vi: set sw=4 ts=4: */
2	/*
3	* Copyright (c) 2002 by David I. Bell
4	* Permission is granted to use, distribute, or modify this source,
5	* provided that this copyright notice remains intact.
6	*
7	* The "ed" built-in command (much simplified)
8	*/
9
10	#include "libbb.h"
11
12	typedef struct LINE {
13	struct LINE *next;
14	struct LINE *prev;
15	int len;
16	char data[1];
17	} LINE;
18
19
20	#define searchString bb_common_bufsiz1
21
22	enum {
23	USERSIZE = sizeof(searchString) > 1024 ? 1024
24	: sizeof(searchString) - 1, /* max line length typed in by user */
25	INITBUF_SIZE = 1024, /* initial buffer size */
26	};
27
28	struct globals {
29	int curNum;
30	int lastNum;
31	int bufUsed;
32	int bufSize;
33	LINE *curLine;
34	char *bufBase;
35	char *bufPtr;
36	char *fileName;
37	LINE lines;
38	smallint dirty;
39	int marks[26];
40	};
41	#define G (*ptr_to_globals)
42	#define curLine (G.curLine )
43	#define bufBase (G.bufBase )
44	#define bufPtr (G.bufPtr )
45	#define fileName (G.fileName )
46	#define curNum (G.curNum )
47	#define lastNum (G.lastNum )
48	#define bufUsed (G.bufUsed )
49	#define bufSize (G.bufSize )
50	#define dirty (G.dirty )
51	#define lines (G.lines )
52	#define marks (G.marks )
53	#define INIT_G() do { \
54	SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
55	} while (0)
56
57
58	static void doCommands(void);
59	static void subCommand(const char *cmd, int num1, int num2);
60	static int getNum(const char *retcp, smallint retHaveNum, int *retNum);
61	static int setCurNum(int num);
62	static void addLines(int num);
63	static int insertLine(int num, const char *data, int len);
64	static void deleteLines(int num1, int num2);
65	static int printLines(int num1, int num2, int expandFlag);
66	static int writeLines(const char *file, int num1, int num2);
67	static int readLines(const char *file, int num);
68	static int searchLines(const char *str, int num1, int num2);
69	static LINE *findLine(int num);
70	static int findString(const LINE lp, const char str, int len, int offset);
71
72
73	static int bad_nums(int num1, int num2, const char *for_what)
74	{
75	if ((num1 < 1) \|\| (num2 > lastNum) \|\| (num1 > num2)) {
76	bb_error_msg("bad line range for %s", for_what);
77	return 1;
78	}
79	return 0;
80	}
81
82
83	static char skip_blank(const char cp)
84	{
85	while (isblank(*cp))
86	cp++;
87	return (char *)cp;
88	}
89
90
91	int ed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
92	int ed_main(int argc UNUSED_PARAM, char **argv)
93	{
94	INIT_G();
95
96	bufSize = INITBUF_SIZE;
97	bufBase = xmalloc(bufSize);
98	bufPtr = bufBase;
99	lines.next = &lines;
100	lines.prev = &lines;
101
102	if (argv[1]) {
103	fileName = xstrdup(argv[1]);
104	if (!readLines(fileName, 1)) {
105	return EXIT_SUCCESS;
106	}
107	if (lastNum)
108	setCurNum(1);
109	dirty = FALSE;
110	}
111
112	doCommands();
113	return EXIT_SUCCESS;
114	}
115
116	/*
117	* Read commands until we are told to stop.
118	*/
119	static void doCommands(void)
120	{
121	const char *cp;
122	char *endbuf, buf[USERSIZE];
123	int len, num1, num2;
124	smallint have1, have2;
125
126	while (TRUE) {
127	/* Returns:
128	* -1 on read errors or EOF, or on bare Ctrl-D.
129	* 0 on ctrl-C,
130	* >0 length of input string, including terminating '\n'
131	*/
132	len = read_line_input(": ", buf, sizeof(buf), NULL);
133	if (len <= 0)
134	return;
135	endbuf = &buf[len - 1];
136	while ((endbuf > buf) && isblank(endbuf[-1]))
137	endbuf--;
138	*endbuf = '\0';
139
140	cp = skip_blank(buf);
141	have1 = FALSE;
142	have2 = FALSE;
143
144	if ((curNum == 0) && (lastNum > 0)) {
145	curNum = 1;
146	curLine = lines.next;
147	}
148
149	if (!getNum(&cp, &have1, &num1))
150	continue;
151
152	cp = skip_blank(cp);
153
154	if (*cp == ',') {
155	cp++;
156	if (!getNum(&cp, &have2, &num2))
157	continue;
158	if (!have1)
159	num1 = 1;
160	if (!have2)
161	num2 = lastNum;
162	have1 = TRUE;
163	have2 = TRUE;
164	}
165	if (!have1)
166	num1 = curNum;
167	if (!have2)
168	num2 = num1;
169
170	switch (*cp++) {
171	case 'a':
172	addLines(num1 + 1);
173	break;
174
175	case 'c':
176	deleteLines(num1, num2);
177	addLines(num1);
178	break;
179
180	case 'd':
181	deleteLines(num1, num2);
182	break;
183
184	case 'f':
185	if (cp && !isblank(cp)) {
186	bb_error_msg("bad file command");
187	break;
188	}
189	cp = skip_blank(cp);
190	if (*cp == '\0') {
191	if (fileName)
192	printf("\"%s\"\n", fileName);
193	else
194	printf("No file name\n");
195	break;
196	}
197	free(fileName);
198	fileName = xstrdup(cp);
199	break;
200
201	case 'i':
202	addLines(num1);
203	break;
204
205	case 'k':
206	cp = skip_blank(cp);
207	if ((cp < 'a') \|\| (cp > 'z') \|\| cp[1]) {
208	bb_error_msg("bad mark name");
209	break;
210	}
211	marks[*cp - 'a'] = num2;
212	break;
213
214	case 'l':
215	printLines(num1, num2, TRUE);
216	break;
217
218	case 'p':
219	printLines(num1, num2, FALSE);
220	break;
221
222	case 'q':
223	cp = skip_blank(cp);
224	if (have1 \|\| *cp) {
225	bb_error_msg("bad quit command");
226	break;
227	}
228	if (!dirty)
229	return;
230	len = read_line_input("Really quit? ", buf, 16, NULL);
231	/* read error/EOF - no way to continue */
232	if (len < 0)
233	return;
234	cp = skip_blank(buf);
235	if ((cp \| 0x20) == 'y') / Y or y */
236	return;
237	break;
238
239	case 'r':
240	if (cp && !isblank(cp)) {
241	bb_error_msg("bad read command");
242	break;
243	}
244	cp = skip_blank(cp);
245	if (*cp == '\0') {
246	bb_error_msg("no file name");
247	break;
248	}
249	if (!have1)
250	num1 = lastNum;
251	if (readLines(cp, num1 + 1))
252	break;
253	if (fileName == NULL)
254	fileName = xstrdup(cp);
255	break;
256
257	case 's':
258	subCommand(cp, num1, num2);
259	break;
260
261	case 'w':
262	if (cp && !isblank(cp)) {
263	bb_error_msg("bad write command");
264	break;
265	}
266	cp = skip_blank(cp);
267	if (!have1) {
268	num1 = 1;
269	num2 = lastNum;
270	}
271	if (*cp == '\0')
272	cp = fileName;
273	if (cp == NULL) {
274	bb_error_msg("no file name specified");
275	break;
276	}
277	writeLines(cp, num1, num2);
278	break;
279
280	case 'z':
281	switch (*cp) {
282	case '-':
283	printLines(curNum - 21, curNum, FALSE);
284	break;
285	case '.':
286	printLines(curNum - 11, curNum + 10, FALSE);
287	break;
288	default:
289	printLines(curNum, curNum + 21, FALSE);
290	break;
291	}
292	break;
293
294	case '.':
295	if (have1) {
296	bb_error_msg("no arguments allowed");
297	break;
298	}
299	printLines(curNum, curNum, FALSE);
300	break;
301
302	case '-':
303	if (setCurNum(curNum - 1))
304	printLines(curNum, curNum, FALSE);
305	break;
306
307	case '=':
308	printf("%d\n", num1);
309	break;
310	case '\0':
311	if (have1) {
312	printLines(num2, num2, FALSE);
313	break;
314	}
315	if (setCurNum(curNum + 1))
316	printLines(curNum, curNum, FALSE);
317	break;
318
319	default:
320	bb_error_msg("unimplemented command");
321	break;
322	}
323	}
324	}
325
326
327	/*
328	* Do the substitute command.
329	* The current line is set to the last substitution done.
330	*/
331	static void subCommand(const char *cmd, int num1, int num2)
332	{
333	char cp, oldStr, *newStr, buf[USERSIZE];
334	int delim, oldLen, newLen, deltaLen, offset;
335	LINE lp, nlp;
336	int globalFlag, printFlag, didSub, needPrint;
337
338	if (bad_nums(num1, num2, "substitute"))
339	return;
340
341	globalFlag = FALSE;
342	printFlag = FALSE;
343	didSub = FALSE;
344	needPrint = FALSE;
345
346	/*
347	* Copy the command so we can modify it.
348	*/
349	strcpy(buf, cmd);
350	cp = buf;
351
352	if (isblank(cp) \|\| (cp == '\0')) {
353	bb_error_msg("bad delimiter for substitute");
354	return;
355	}
356
357	delim = *cp++;
358	oldStr = cp;
359
360	cp = strchr(cp, delim);
361	if (cp == NULL) {
362	bb_error_msg("missing 2nd delimiter for substitute");
363	return;
364	}
365
366	*cp++ = '\0';
367
368	newStr = cp;
369	cp = strchr(cp, delim);
370
371	if (cp)
372	*cp++ = '\0';
373	else
374	cp = (char*)"";
375
376	while (cp) switch (cp++) {
377	case 'g':
378	globalFlag = TRUE;
379	break;
380	case 'p':
381	printFlag = TRUE;
382	break;
383	default:
384	bb_error_msg("unknown option for substitute");
385	return;
386	}
387
388	if (*oldStr == '\0') {
389	if (searchString[0] == '\0') {
390	bb_error_msg("no previous search string");
391	return;
392	}
393	oldStr = searchString;
394	}
395
396	if (oldStr != searchString)
397	strcpy(searchString, oldStr);
398
399	lp = findLine(num1);
400	if (lp == NULL)
401	return;
402
403	oldLen = strlen(oldStr);
404	newLen = strlen(newStr);
405	deltaLen = newLen - oldLen;
406	offset = 0;
407	nlp = NULL;
408
409	while (num1 <= num2) {
410	offset = findString(lp, oldStr, oldLen, offset);
411
412	if (offset < 0) {
413	if (needPrint) {
414	printLines(num1, num1, FALSE);
415	needPrint = FALSE;
416	}
417	offset = 0;
418	lp = lp->next;
419	num1++;
420	continue;
421	}
422
423	needPrint = printFlag;
424	didSub = TRUE;
425	dirty = TRUE;
426
427	/*
428	* If the replacement string is the same size or shorter
429	* than the old string, then the substitution is easy.
430	*/
431	if (deltaLen <= 0) {
432	memcpy(&lp->data[offset], newStr, newLen);
433	if (deltaLen) {
434	memcpy(&lp->data[offset + newLen],
435	&lp->data[offset + oldLen],
436	lp->len - offset - oldLen);
437
438	lp->len += deltaLen;
439	}
440	offset += newLen;
441	if (globalFlag)
442	continue;
443	if (needPrint) {
444	printLines(num1, num1, FALSE);
445	needPrint = FALSE;
446	}
447	lp = lp->next;
448	num1++;
449	continue;
450	}
451
452	/*
453	* The new string is larger, so allocate a new line
454	* structure and use that. Link it in in place of
455	* the old line structure.
456	*/
457	nlp = malloc(sizeof(LINE) + lp->len + deltaLen);
458	if (nlp == NULL) {
459	bb_error_msg("cannot get memory for line");
460	return;
461	}
462
463	nlp->len = lp->len + deltaLen;
464
465	memcpy(nlp->data, lp->data, offset);
466	memcpy(&nlp->data[offset], newStr, newLen);
467	memcpy(&nlp->data[offset + newLen],
468	&lp->data[offset + oldLen],
469	lp->len - offset - oldLen);
470
471	nlp->next = lp->next;
472	nlp->prev = lp->prev;
473	nlp->prev->next = nlp;
474	nlp->next->prev = nlp;
475
476	if (curLine == lp)
477	curLine = nlp;
478
479	free(lp);
480	lp = nlp;
481
482	offset += newLen;
483
484	if (globalFlag)
485	continue;
486
487	if (needPrint) {
488	printLines(num1, num1, FALSE);
489	needPrint = FALSE;
490	}
491
492	lp = lp->next;
493	num1++;
494	}
495
496	if (!didSub)
497	bb_error_msg("no substitutions found for \"%s\"", oldStr);
498	}
499
500
501	/*
502	* Search a line for the specified string starting at the specified
503	* offset in the line. Returns the offset of the found string, or -1.
504	*/
505	static int findString(const LINE lp, const char str, int len, int offset)
506	{
507	int left;
508	const char cp, ncp;
509
510	cp = &lp->data[offset];
511	left = lp->len - offset;
512
513	while (left >= len) {
514	ncp = memchr(cp, *str, left);
515	if (ncp == NULL)
516	return -1;
517	left -= (ncp - cp);
518	if (left < len)
519	return -1;
520	cp = ncp;
521	if (memcmp(cp, str, len) == 0)
522	return (cp - lp->data);
523	cp++;
524	left--;
525	}
526
527	return -1;
528	}
529
530
531	/*
532	* Add lines which are typed in by the user.
533	* The lines are inserted just before the specified line number.
534	* The lines are terminated by a line containing a single dot (ugly!),
535	* or by an end of file.
536	*/
537	static void addLines(int num)
538	{
539	int len;
540	char buf[USERSIZE + 1];
541
542	while (1) {
543	/* Returns:
544	* -1 on read errors or EOF, or on bare Ctrl-D.
545	* 0 on ctrl-C,
546	* >0 length of input string, including terminating '\n'
547	*/
548	len = read_line_input("", buf, sizeof(buf), NULL);
549	if (len <= 0) {
550	/* Previously, ctrl-C was exiting to shell.
551	* Now we exit to ed prompt. Is in important? */
552	return;
553	}
554	if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '\0'))
555	return;
556	if (!insertLine(num++, buf, len))
557	return;
558	}
559	}
560
561
562	/*
563	* Parse a line number argument if it is present. This is a sum
564	* or difference of numbers, '.', '$', 'x, or a search string.
565	* Returns TRUE if successful (whether or not there was a number).
566	* Returns FALSE if there was a parsing error, with a message output.
567	* Whether there was a number is returned indirectly, as is the number.
568	* The character pointer which stopped the scan is also returned.
569	*/
570	static int getNum(const char *retcp, smallint retHaveNum, int *retNum)
571	{
572	const char *cp;
573	char *endStr, str[USERSIZE];
574	int value, num;
575	smallint haveNum, minus;
576
577	cp = *retcp;
578	value = 0;
579	haveNum = FALSE;
580	minus = 0;
581
582	while (TRUE) {
583	cp = skip_blank(cp);
584
585	switch (*cp) {
586	case '.':
587	haveNum = TRUE;
588	num = curNum;
589	cp++;
590	break;
591
592	case '$':
593	haveNum = TRUE;
594	num = lastNum;
595	cp++;
596	break;
597
598	case '\'':
599	cp++;
600	if ((cp < 'a') \|\| (cp > 'z')) {
601	bb_error_msg("bad mark name");
602	return FALSE;
603	}
604	haveNum = TRUE;
605	num = marks[*cp++ - 'a'];
606	break;
607
608	case '/':
609	strcpy(str, ++cp);
610	endStr = strchr(str, '/');
611	if (endStr) {
612	*endStr++ = '\0';
613	cp += (endStr - str);
614	} else
615	cp = "";
616	num = searchLines(str, curNum, lastNum);
617	if (num == 0)
618	return FALSE;
619	haveNum = TRUE;
620	break;
621
622	default:
623	if (!isdigit(*cp)) {
624	*retcp = cp;
625	*retHaveNum = haveNum;
626	*retNum = value;
627	return TRUE;
628	}
629	num = 0;
630	while (isdigit(*cp))
631	num = num * 10 + *cp++ - '0';
632	haveNum = TRUE;
633	break;
634	}
635
636	value += (minus ? -num : num);
637
638	cp = skip_blank(cp);
639
640	switch (*cp) {
641	case '-':
642	minus = 1;
643	cp++;
644	break;
645
646	case '+':
647	minus = 0;
648	cp++;
649	break;
650
651	default:
652	*retcp = cp;
653	*retHaveNum = haveNum;
654	*retNum = value;
655	return TRUE;
656	}
657	}
658	}
659
660
661	/*
662	* Read lines from a file at the specified line number.
663	* Returns TRUE if the file was successfully read.
664	*/
665	static int readLines(const char *file, int num)
666	{
667	int fd, cc;
668	int len, lineCount, charCount;
669	char *cp;
670
671	if ((num < 1) \|\| (num > lastNum + 1)) {
672	bb_error_msg("bad line for read");
673	return FALSE;
674	}
675
676	fd = open(file, 0);
677	if (fd < 0) {
678	perror(file);
679	return FALSE;
680	}
681
682	bufPtr = bufBase;
683	bufUsed = 0;
684	lineCount = 0;
685	charCount = 0;
686	cc = 0;
687
688	printf("\"%s\", ", file);
689	fflush(stdout);
690
691	do {
692	cp = memchr(bufPtr, '\n', bufUsed);
693
694	if (cp) {
695	len = (cp - bufPtr) + 1;
696	if (!insertLine(num, bufPtr, len)) {
697	close(fd);
698	return FALSE;
699	}
700	bufPtr += len;
701	bufUsed -= len;
702	charCount += len;
703	lineCount++;
704	num++;
705	continue;
706	}
707
708	if (bufPtr != bufBase) {
709	memcpy(bufBase, bufPtr, bufUsed);
710	bufPtr = bufBase + bufUsed;
711	}
712
713	if (bufUsed >= bufSize) {
714	len = (bufSize * 3) / 2;
715	cp = realloc(bufBase, len);
716	if (cp == NULL) {
717	bb_error_msg("no memory for buffer");
718	close(fd);
719	return FALSE;
720	}
721	bufBase = cp;
722	bufPtr = bufBase + bufUsed;
723	bufSize = len;
724	}
725
726	cc = safe_read(fd, bufPtr, bufSize - bufUsed);
727	bufUsed += cc;
728	bufPtr = bufBase;
729
730	} while (cc > 0);
731
732	if (cc < 0) {
733	perror(file);
734	close(fd);
735	return FALSE;
736	}
737
738	if (bufUsed) {
739	if (!insertLine(num, bufPtr, bufUsed)) {
740	close(fd);
741	return -1;
742	}
743	lineCount++;
744	charCount += bufUsed;
745	}
746
747	close(fd);
748
749	printf("%d lines%s, %d chars\n", lineCount,
750	(bufUsed ? " (incomplete)" : ""), charCount);
751
752	return TRUE;
753	}
754
755
756	/*
757	* Write the specified lines out to the specified file.
758	* Returns TRUE if successful, or FALSE on an error with a message output.
759	*/
760	static int writeLines(const char *file, int num1, int num2)
761	{
762	LINE *lp;
763	int fd, lineCount, charCount;
764
765	if (bad_nums(num1, num2, "write"))
766	return FALSE;
767
768	lineCount = 0;
769	charCount = 0;
770
771	fd = creat(file, 0666);
772	if (fd < 0) {
773	perror(file);
774	return FALSE;
775	}
776
777	printf("\"%s\", ", file);
778	fflush(stdout);
779
780	lp = findLine(num1);
781	if (lp == NULL) {
782	close(fd);
783	return FALSE;
784	}
785
786	while (num1++ <= num2) {
787	if (full_write(fd, lp->data, lp->len) != lp->len) {
788	perror(file);
789	close(fd);
790	return FALSE;
791	}
792	charCount += lp->len;
793	lineCount++;
794	lp = lp->next;
795	}
796
797	if (close(fd) < 0) {
798	perror(file);
799	return FALSE;
800	}
801
802	printf("%d lines, %d chars\n", lineCount, charCount);
803	return TRUE;
804	}
805
806
807	/*
808	* Print lines in a specified range.
809	* The last line printed becomes the current line.
810	* If expandFlag is TRUE, then the line is printed specially to
811	* show magic characters.
812	*/
813	static int printLines(int num1, int num2, int expandFlag)
814	{
815	const LINE *lp;
816	const char *cp;
817	int ch, count;
818
819	if (bad_nums(num1, num2, "print"))
820	return FALSE;
821
822	lp = findLine(num1);
823	if (lp == NULL)
824	return FALSE;
825
826	while (num1 <= num2) {
827	if (!expandFlag) {
828	write(STDOUT_FILENO, lp->data, lp->len);
829	setCurNum(num1++);
830	lp = lp->next;
831	continue;
832	}
833
834	/*
835	* Show control characters and characters with the
836	* high bit set specially.
837	*/
838	cp = lp->data;
839	count = lp->len;
840
841	if ((count > 0) && (cp[count - 1] == '\n'))
842	count--;
843
844	while (count-- > 0) {
845	ch = (unsigned char) *cp++;
846	fputc_printable(ch \| PRINTABLE_META, stdout);
847	}
848
849	fputs("$\n", stdout);
850
851	setCurNum(num1++);
852	lp = lp->next;
853	}
854
855	return TRUE;
856	}
857
858
859	/*
860	* Insert a new line with the specified text.
861	* The line is inserted so as to become the specified line,
862	* thus pushing any existing and further lines down one.
863	* The inserted line is also set to become the current line.
864	* Returns TRUE if successful.
865	*/
866	static int insertLine(int num, const char *data, int len)
867	{
868	LINE newLp, lp;
869
870	if ((num < 1) \|\| (num > lastNum + 1)) {
871	bb_error_msg("inserting at bad line number");
872	return FALSE;
873	}
874
875	newLp = malloc(sizeof(LINE) + len - 1);
876	if (newLp == NULL) {
877	bb_error_msg("failed to allocate memory for line");
878	return FALSE;
879	}
880
881	memcpy(newLp->data, data, len);
882	newLp->len = len;
883
884	if (num > lastNum)
885	lp = &lines;
886	else {
887	lp = findLine(num);
888	if (lp == NULL) {
889	free((char *) newLp);
890	return FALSE;
891	}
892	}
893
894	newLp->next = lp;
895	newLp->prev = lp->prev;
896	lp->prev->next = newLp;
897	lp->prev = newLp;
898
899	lastNum++;
900	dirty = TRUE;
901	return setCurNum(num);
902	}
903
904
905	/*
906	* Delete lines from the given range.
907	*/
908	static void deleteLines(int num1, int num2)
909	{
910	LINE lp, nlp, *plp;
911	int count;
912
913	if (bad_nums(num1, num2, "delete"))
914	return;
915
916	lp = findLine(num1);
917	if (lp == NULL)
918	return;
919
920	if ((curNum >= num1) && (curNum <= num2)) {
921	if (num2 < lastNum)
922	setCurNum(num2 + 1);
923	else if (num1 > 1)
924	setCurNum(num1 - 1);
925	else
926	curNum = 0;
927	}
928
929	count = num2 - num1 + 1;
930	if (curNum > num2)
931	curNum -= count;
932	lastNum -= count;
933
934	while (count-- > 0) {
935	nlp = lp->next;
936	plp = lp->prev;
937	plp->next = nlp;
938	nlp->prev = plp;
939	free(lp);
940	lp = nlp;
941	}
942
943	dirty = TRUE;
944	}
945
946
947	/*
948	* Search for a line which contains the specified string.
949	* If the string is "", then the previously searched for string
950	* is used. The currently searched for string is saved for future use.
951	* Returns the line number which matches, or 0 if there was no match
952	* with an error printed.
953	*/
954	static int searchLines(const char *str, int num1, int num2)
955	{
956	const LINE *lp;
957	int len;
958
959	if (bad_nums(num1, num2, "search"))
960	return 0;
961
962	if (*str == '\0') {
963	if (searchString[0] == '\0') {
964	bb_error_msg("no previous search string");
965	return 0;
966	}
967	str = searchString;
968	}
969
970	if (str != searchString)
971	strcpy(searchString, str);
972
973	len = strlen(str);
974
975	lp = findLine(num1);
976	if (lp == NULL)
977	return 0;
978
979	while (num1 <= num2) {
980	if (findString(lp, str, len, 0) >= 0)
981	return num1;
982	num1++;
983	lp = lp->next;
984	}
985
986	bb_error_msg("cannot find string \"%s\"", str);
987	return 0;
988	}
989
990
991	/*
992	* Return a pointer to the specified line number.
993	*/
994	static LINE *findLine(int num)
995	{
996	LINE *lp;
997	int lnum;
998
999	if ((num < 1) \|\| (num > lastNum)) {
1000	bb_error_msg("line number %d does not exist", num);
1001	return NULL;
1002	}
1003
1004	if (curNum <= 0) {
1005	curNum = 1;
1006	curLine = lines.next;
1007	}
1008
1009	if (num == curNum)
1010	return curLine;
1011
1012	lp = curLine;
1013	lnum = curNum;
1014	if (num < (curNum / 2)) {
1015	lp = lines.next;
1016	lnum = 1;
1017	} else if (num > ((curNum + lastNum) / 2)) {
1018	lp = lines.prev;
1019	lnum = lastNum;
1020	}
1021
1022	while (lnum < num) {
1023	lp = lp->next;
1024	lnum++;
1025	}
1026
1027	while (lnum > num) {
1028	lp = lp->prev;
1029	lnum--;
1030	}
1031	return lp;
1032	}
1033
1034
1035	/*
1036	* Set the current line number.
1037	* Returns TRUE if successful.
1038	*/
1039	static int setCurNum(int num)
1040	{
1041	LINE *lp;
1042
1043	lp = findLine(num);
1044	if (lp == NULL)
1045	return FALSE;
1046	curNum = num;
1047	curLine = lp;
1048	return TRUE;
1049	}