X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=mg%2Fline.c;fp=mg%2Fline.c;h=bafd64f5569618a2441b3a794876dda9497e645f;hb=a9843085ec916c175bd245a8398f30e6cc03f984;hp=0000000000000000000000000000000000000000;hpb=26fe4e09c6c3c250334fdeed60ce3061febecde2;p=pd_readline

diff --git a/mg/line.c b/mg/line.c
new file mode 100644
index 0000000..bafd64f
--- /dev/null
+++ b/mg/line.c
@@ -0,0 +1,635 @@
+/*	$OpenBSD: line.c,v 1.50 2011/01/18 16:28:00 kjell Exp $	*/
+
+/* This file is in the public domain. */
+
+/*
+ *		Text line handling.
+ *
+ * The functions in this file are a general set of line management
+ * utilities. They are the only routines that touch the text. They
+ * also touch the buffer and window structures to make sure that the
+ * necessary updating gets done.  There are routines in this file that
+ * handle the kill buffer too.  It isn't here for any good reason.
+ *
+ * Note that this code only updates the dot and mark values in the window
+ * list.  Since all the code acts on the current window, the buffer that
+ * we are editing must be displayed, which means that "b_nwnd" is non-zero,
+ * which means that the dot and mark values in the buffer headers are
+ * nonsense.
+ */
+
+#include "def.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * Allocate a new line of size `used'.  lrealloc() can be called if the line
+ * ever needs to grow beyond that.
+ */
+struct line *
+lalloc(int used)
+{
+	struct line *lp;
+
+	if ((lp = malloc(sizeof(*lp))) == NULL)
+		return (NULL);
+	lp->l_text = NULL;
+	lp->l_size = 0;
+	lp->l_used = used;	/* XXX */
+	if (lrealloc(lp, used) == FALSE) {
+		free(lp);
+		return (NULL);
+	}
+	return (lp);
+}
+
+int
+lrealloc(struct line *lp, int newsize)
+{
+	char *tmp;
+
+	if (lp->l_size < newsize) {
+		if ((tmp = realloc(lp->l_text, newsize)) == NULL)
+			return (FALSE);
+		lp->l_text = tmp;
+		lp->l_size = newsize;
+	}
+	return (TRUE);
+}
+
+/*
+ * Delete line "lp".  Fix all of the links that might point to it (they are
+ * moved to offset 0 of the next line.  Unlink the line from whatever buffer
+ * it might be in, and release the memory.  The buffers are updated too; the
+ * magic conditions described in the above comments don't hold here.
+ */
+void
+lfree(struct line *lp)
+{
+	struct buffer	*bp;
+	struct mgwin	*wp;
+
+	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+		if (wp->w_linep == lp)
+			wp->w_linep = lp->l_fp;
+		if (wp->w_dotp == lp) {
+			wp->w_dotp = lp->l_fp;
+			wp->w_doto = 0;
+		}
+		if (wp->w_markp == lp) {
+			wp->w_markp = lp->l_fp;
+			wp->w_marko = 0;
+		}
+	}
+	for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
+		if (bp->b_nwnd == 0) {
+			if (bp->b_dotp == lp) {
+				bp->b_dotp = lp->l_fp;
+				bp->b_doto = 0;
+			}
+			if (bp->b_markp == lp) {
+				bp->b_markp = lp->l_fp;
+				bp->b_marko = 0;
+			}
+		}
+	}
+	lp->l_bp->l_fp = lp->l_fp;
+	lp->l_fp->l_bp = lp->l_bp;
+	if (lp->l_text != NULL)
+		free(lp->l_text);
+	free(lp);
+}
+
+/*
+ * This routine is called when a character changes in place in the current
+ * buffer. It updates all of the required flags in the buffer and window
+ * system. The flag used is passed as an argument; if the buffer is being
+ * displayed in more than 1 window we change EDIT to HARD. Set MODE if the
+ * mode line needs to be updated (the "*" has to be set).
+ */
+void
+lchange(int flag)
+{
+	struct mgwin	*wp;
+
+	/* update mode lines if this is the first change. */
+	if ((curbp->b_flag & BFCHG) == 0) {
+		flag |= WFMODE;
+		curbp->b_flag |= BFCHG;
+	}
+	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+		if (wp->w_bufp == curbp) {
+			wp->w_rflag |= flag;
+			if (wp != curwp)
+				wp->w_rflag |= WFFULL;
+		}
+	}
+}
+
+/*
+ * Insert "n" bytes from "s" at the current location of dot.
+ * In the easy case all that happens is the text is stored in the line.
+ * In the hard case, the line has to be reallocated.  When the window list
+ * is updated, take special care; I screwed it up once.  You always update
+ * dot in the current window.  You update mark and a dot in another window
+ * if it is greater than the place where you did the insert. Return TRUE
+ * if all is well, and FALSE on errors.
+ */
+int
+linsert_str(const char *s, int n)
+{
+	struct line	*lp1;
+	struct mgwin	*wp;
+	RSIZE	 i;
+	int	 doto, k;
+
+	if ((k = checkdirty(curbp)) != TRUE)
+		return (k);
+
+	if (curbp->b_flag & BFREADONLY) {
+		ewprintf("Buffer is read only");
+		return (FALSE);
+	}
+
+	if (!n)
+		return (TRUE);
+
+	lchange(WFFULL);
+
+	/* current line */
+	lp1 = curwp->w_dotp;
+
+	/* special case for the end */
+	if (lp1 == curbp->b_headp) {
+		struct line *lp2, *lp3;
+
+		/* now should only happen in empty buffer */
+		if (curwp->w_doto != 0)
+			panic("bug: linsert_str");
+		/* allocate a new line */
+		if ((lp2 = lalloc(n)) == NULL)
+			return (FALSE);
+		/* previous line */
+		lp3 = lp1->l_bp;
+		/* link in */
+		lp3->l_fp = lp2;
+		lp2->l_fp = lp1;
+		lp1->l_bp = lp2;
+		lp2->l_bp = lp3;
+		for (i = 0; i < n; ++i)
+			lp2->l_text[i] = s[i];
+		for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+			if (wp->w_linep == lp1)
+				wp->w_linep = lp2;
+			if (wp->w_dotp == lp1)
+				wp->w_dotp = lp2;
+			if (wp->w_markp == lp1)
+				wp->w_markp = lp2;
+		}
+		undo_add_insert(lp2, 0, n);
+		curwp->w_doto = n;
+		return (TRUE);
+	}
+	/* save for later */
+	doto = curwp->w_doto;
+
+	if ((lp1->l_used + n) > lp1->l_size) {
+		if (lrealloc(lp1, lp1->l_used + n) == FALSE)
+			return (FALSE);
+	}
+	lp1->l_used += n;
+	if (lp1->l_used != n)
+		memmove(&lp1->l_text[doto + n], &lp1->l_text[doto],
+		    lp1->l_used - n - doto);
+
+	/* Add the characters */
+	for (i = 0; i < n; ++i)
+		lp1->l_text[doto + i] = s[i];
+	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+		if (wp->w_dotp == lp1) {
+			if (wp == curwp || wp->w_doto > doto)
+				wp->w_doto += n;
+		}
+		if (wp->w_markp == lp1) {
+			if (wp->w_marko > doto)
+				wp->w_marko += n;
+		}
+	}
+	undo_add_insert(curwp->w_dotp, doto, n);
+	return (TRUE);
+}
+
+/*
+ * Insert "n" copies of the character "c" at the current location of dot.
+ * In the easy case all that happens is the text is stored in the line.
+ * In the hard case, the line has to be reallocated.  When the window list
+ * is updated, take special care; I screwed it up once.  You always update
+ * dot in the current window.  You update mark and a dot in another window
+ * if it is greater than the place where you did the insert. Return TRUE
+ * if all is well, and FALSE on errors.
+ */
+int
+linsert(int n, int c)
+{
+	struct line	*lp1;
+	struct mgwin	*wp;
+	RSIZE	 i;
+	int	 doto;
+	int s;
+
+	if (!n)
+		return (TRUE);
+
+	if ((s = checkdirty(curbp)) != TRUE)
+		return (s);
+	
+	if (curbp->b_flag & BFREADONLY) {
+		ewprintf("Buffer is read only");
+		return (FALSE);
+	}
+
+	lchange(WFEDIT);
+
+	/* current line */
+	lp1 = curwp->w_dotp;
+
+	/* special case for the end */
+	if (lp1 == curbp->b_headp) {
+		struct line *lp2, *lp3;
+
+		/* now should only happen in empty buffer */
+		if (curwp->w_doto != 0) {
+			ewprintf("bug: linsert");
+			return (FALSE);
+		}
+		/* allocate a new line */
+		if ((lp2 = lalloc(n)) == NULL)
+			return (FALSE);
+		/* previous line */
+		lp3 = lp1->l_bp;
+		/* link in */
+		lp3->l_fp = lp2;
+		lp2->l_fp = lp1;
+		lp1->l_bp = lp2;
+		lp2->l_bp = lp3;
+		for (i = 0; i < n; ++i)
+			lp2->l_text[i] = c;
+		for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+			if (wp->w_linep == lp1)
+				wp->w_linep = lp2;
+			if (wp->w_dotp == lp1)
+				wp->w_dotp = lp2;
+			if (wp->w_markp == lp1)
+				wp->w_markp = lp2;
+		}
+		undo_add_insert(lp2, 0, n);
+		curwp->w_doto = n;
+		return (TRUE);
+	}
+	/* save for later */
+	doto = curwp->w_doto;
+
+	if ((lp1->l_used + n) > lp1->l_size) {
+		if (lrealloc(lp1, lp1->l_used + n) == FALSE)
+			return (FALSE);
+	}
+	lp1->l_used += n;
+	if (lp1->l_used != n)
+		memmove(&lp1->l_text[doto + n], &lp1->l_text[doto],
+		    lp1->l_used - n - doto);
+
+	/* Add the characters */
+	for (i = 0; i < n; ++i)
+		lp1->l_text[doto + i] = c;
+	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+		if (wp->w_dotp == lp1) {
+			if (wp == curwp || wp->w_doto > doto)
+				wp->w_doto += n;
+		}
+		if (wp->w_markp == lp1) {
+			if (wp->w_marko > doto)
+				wp->w_marko += n;
+		}
+	}
+	undo_add_insert(curwp->w_dotp, doto, n);
+	return (TRUE);
+}
+
+/*
+ * Do the work of inserting a newline at the given line/offset.
+ * If mark is on the current line, we may have to move the markline
+ * to keep line numbers in sync.
+ * lnewline_at assumes the current buffer is writable. Checking for
+ * this fact should be done by the caller.
+ */
+int
+lnewline_at(struct line *lp1, int doto)
+{
+	struct line	*lp2;
+	int	 nlen;
+	struct mgwin	*wp;
+
+	lchange(WFFULL);
+
+	curwp->w_bufp->b_lines++;
+	/* Check if mark is past dot (even on current line) */
+	if (curwp->w_markline > curwp->w_dotline  ||
+	   (curwp->w_dotline == curwp->w_markline &&
+	    curwp->w_marko >= doto))
+		curwp->w_markline++;
+	curwp->w_dotline++;
+
+	/* If start of line, allocate a new line instead of copying */
+	if (doto == 0) {
+		/* new first part */
+		if ((lp2 = lalloc(0)) == NULL)
+			return (FALSE);
+		lp2->l_bp = lp1->l_bp;
+		lp1->l_bp->l_fp = lp2;
+		lp2->l_fp = lp1;
+		lp1->l_bp = lp2;
+		for (wp = wheadp; wp != NULL; wp = wp->w_wndp)
+			if (wp->w_linep == lp1)
+				wp->w_linep = lp2;
+		undo_add_boundary(FFRAND, 1);
+		undo_add_insert(lp2, 0, 1);
+		undo_add_boundary(FFRAND, 1);
+		return (TRUE);
+	}
+
+	/* length of new part */
+	nlen = llength(lp1) - doto;
+
+	/* new second half line */
+	if ((lp2 = lalloc(nlen)) == NULL)
+		return (FALSE);
+	if (nlen != 0)
+		bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen);
+	lp1->l_used = doto;
+	lp2->l_bp = lp1;
+	lp2->l_fp = lp1->l_fp;
+	lp1->l_fp = lp2;
+	lp2->l_fp->l_bp = lp2;
+	/* Windows */
+	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+		if (wp->w_dotp == lp1 && wp->w_doto >= doto) {
+			wp->w_dotp = lp2;
+			wp->w_doto -= doto;
+		}
+		if (wp->w_markp == lp1 && wp->w_marko >= doto) {
+			wp->w_markp = lp2;
+			wp->w_marko -= doto;
+		}
+	}
+	undo_add_boundary(FFRAND, 1);
+	undo_add_insert(lp1, llength(lp1), 1);
+	undo_add_boundary(FFRAND, 1);
+	return (TRUE);
+}
+
+/*
+ * Insert a newline into the buffer at the current location of dot in the
+ * current window.
+ */
+int
+lnewline(void)
+{
+	int s;
+
+	if ((s = checkdirty(curbp)) != TRUE)
+		return (s);
+	if (curbp->b_flag & BFREADONLY) {
+		ewprintf("Buffer is read only");
+		return (FALSE);
+	}
+	return (lnewline_at(curwp->w_dotp, curwp->w_doto));
+}
+
+/*
+ * This function deletes "n" bytes, starting at dot. (actually, n+1, as the
+ * newline is included) It understands how to deal with end of lines, etc.
+ * It returns TRUE if all of the characters were deleted, and FALSE if
+ * they were not (because dot ran into the end of the buffer).
+ * The "kflag" indicates either no insertion, or direction  of insertion
+ * into the kill buffer.
+ */
+int
+ldelete(RSIZE n, int kflag)
+{
+	struct line	*dotp;
+	RSIZE		 chunk;
+	struct mgwin	*wp;
+	int		 doto;
+	char		*cp1, *cp2;
+	size_t		 len;
+	char		*sv = NULL;
+	int		 end;
+	int		 s;
+	int		 rval = FALSE;
+
+	if ((s = checkdirty(curbp)) != TRUE)
+		return (s);
+	if (curbp->b_flag & BFREADONLY) {
+		ewprintf("Buffer is read only");
+		goto out;
+	}
+	len = n;
+	if ((sv = calloc(1, len + 1)) == NULL)
+		goto out;
+	end = 0;
+
+	undo_add_delete(curwp->w_dotp, curwp->w_doto, n, (kflag & KREG));
+
+	while (n != 0) {
+		dotp = curwp->w_dotp;
+		doto = curwp->w_doto;
+		/* Hit the end of the buffer */
+		if (dotp == curbp->b_headp)
+			goto out;
+		/* Size of the chunk */
+		chunk = dotp->l_used - doto;
+
+		if (chunk > n)
+			chunk = n;
+		/* End of line, merge */
+		if (chunk == 0) {
+			if (dotp == blastlp(curbp))
+				goto out;
+			lchange(WFFULL);
+			if (ldelnewline() == FALSE)
+				goto out;
+			end = strlcat(sv, "\n", len + 1);
+			--n;
+			continue;
+		}
+		lchange(WFEDIT);
+		/* Scrunch text */
+		cp1 = &dotp->l_text[doto];
+		memcpy(&sv[end], cp1, chunk);
+		end += chunk;
+		sv[end] = '\0';
+		for (cp2 = cp1 + chunk; cp2 < &dotp->l_text[dotp->l_used];
+		    cp2++)
+			*cp1++ = *cp2;
+		dotp->l_used -= (int)chunk;
+		for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+			if (wp->w_dotp == dotp && wp->w_doto >= doto) {
+				/* NOSTRICT */
+				wp->w_doto -= chunk;
+				if (wp->w_doto < doto)
+					wp->w_doto = doto;
+			}
+			if (wp->w_markp == dotp && wp->w_marko >= doto) {
+				/* NOSTRICT */
+				wp->w_marko -= chunk;
+				if (wp->w_marko < doto)
+					wp->w_marko = doto;
+			}
+		}
+		n -= chunk;
+	}
+	if (kchunk(sv, (RSIZE)len, kflag) != TRUE)
+		goto out;
+	rval = TRUE;
+out:
+	free(sv);
+	return (rval);
+}
+
+/*
+ * Delete a newline and join the current line with the next line. If the next
+ * line is the magic header line always return TRUE; merging the last line
+ * with the header line can be thought of as always being a successful
+ * operation.  Even if nothing is done, this makes the kill buffer work
+ * "right". If the mark is past the dot (actually, markline > dotline),
+ * decrease the markline accordingly to keep line numbers in sync.
+ * Easy cases can be done by shuffling data around.  Hard cases
+ * require that lines be moved about in memory.  Return FALSE on error and
+ * TRUE if all looks ok. We do not update w_dotline here, as deletes are done
+ * after moves.
+ */
+int
+ldelnewline(void)
+{
+	struct line	*lp1, *lp2, *lp3;
+	struct mgwin	*wp;
+	int s;
+
+	if ((s = checkdirty(curbp)) != TRUE)
+		return (s);
+	if (curbp->b_flag & BFREADONLY) {
+		ewprintf("Buffer is read only");
+		return (FALSE);
+	}
+
+	lp1 = curwp->w_dotp;
+	lp2 = lp1->l_fp;
+	/* at the end of the buffer */
+	if (lp2 == curbp->b_headp)
+		return (TRUE);
+	/* Keep line counts in sync */
+	curwp->w_bufp->b_lines--;
+	if (curwp->w_markline > curwp->w_dotline)
+		curwp->w_markline--;
+	if (lp2->l_used <= lp1->l_size - lp1->l_used) {
+		bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used);
+		for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+			if (wp->w_linep == lp2)
+				wp->w_linep = lp1;
+			if (wp->w_dotp == lp2) {
+				wp->w_dotp = lp1;
+				wp->w_doto += lp1->l_used;
+			}
+			if (wp->w_markp == lp2) {
+				wp->w_markp = lp1;
+				wp->w_marko += lp1->l_used;
+			}
+		}
+		lp1->l_used += lp2->l_used;
+		lp1->l_fp = lp2->l_fp;
+		lp2->l_fp->l_bp = lp1;
+		free(lp2);
+		return (TRUE);
+	}
+	if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)
+		return (FALSE);
+	bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used);
+	bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used);
+	lp1->l_bp->l_fp = lp3;
+	lp3->l_fp = lp2->l_fp;
+	lp2->l_fp->l_bp = lp3;
+	lp3->l_bp = lp1->l_bp;
+	for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
+		if (wp->w_linep == lp1 || wp->w_linep == lp2)
+			wp->w_linep = lp3;
+		if (wp->w_dotp == lp1)
+			wp->w_dotp = lp3;
+		else if (wp->w_dotp == lp2) {
+			wp->w_dotp = lp3;
+			wp->w_doto += lp1->l_used;
+		}
+		if (wp->w_markp == lp1)
+			wp->w_markp = lp3;
+		else if (wp->w_markp == lp2) {
+			wp->w_markp = lp3;
+			wp->w_marko += lp1->l_used;
+		}
+	}
+	free(lp1);
+	free(lp2);
+	return (TRUE);
+}
+
+/*
+ * Replace plen characters before dot with argument string.  Control-J
+ * characters in st are interpreted as newlines.  There is a casehack
+ * disable flag (normally it likes to match case of replacement to what
+ * was there).
+ */
+int
+lreplace(RSIZE plen, char *st)
+{
+	RSIZE	rlen;	/* replacement length		 */
+	int s;
+
+	if ((s = checkdirty(curbp)) != TRUE)
+		return (s);
+	if (curbp->b_flag & BFREADONLY) {
+		ewprintf("Buffer is read only");
+		return (FALSE);
+	}
+	undo_boundary_enable(FFRAND, 0);
+
+	(void)backchar(FFARG | FFRAND, (int)plen);
+	(void)ldelete(plen, KNONE);
+
+	rlen = strlen(st);
+	region_put_data(st, rlen);
+	lchange(WFFULL);
+
+	undo_boundary_enable(FFRAND, 1);
+	return (TRUE);
+}
+
+/*
+ * Allocate and return the supplied line as a C string
+ */
+char *
+linetostr(const struct line *ln)
+{
+	int	 len;
+	char	*line;
+
+	len = llength(ln);
+	if (len == INT_MAX)  /* (len + 1) overflow */
+		return (NULL);
+
+	if ((line = malloc(len + 1)) == NULL)
+		return (NULL);
+
+	(void)memcpy(line, ltext(ln), len);
+	line[len] = '\0';
+
+	return (line);
+}