line.c

/* line.c of ue in gulam -- part of original microEmacs

The functions in this file are a general set of line management
utilities.  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.  These are here for no 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 being displayed, which means that "b_nwnd" is
non zero, which means that the dot and mark values in the buffer
headers are nonsense.

A line may 'belong' to more than one window, but never to more than one buffer.
*/


#include        "ue.h"

#define KBLOCK  256						/* Kill buffer block size       */

static char *kbufp = NULL;				/* Kill buffer data.        */
static RSIZE kused = 0;					/* # of bytes used in KB.   */
static RSIZE ksize = 0;					/* # of bytes allocated in KB.  */
static RSIZE kstart = 0;					/* # of first used byte in KB.  */

/* This routine allocates a block of memory large enough to hold a
ELINE containing "used" characters.  The block is always rounded up a
bit.  Return a pointer to the new block, or NULL if there isn't any
memory left.  Print a message in the message line if no space.  (pm:
We allocate one more byte for the \0; see makelnstr() of misc.c.) */

ELINE *lalloc(int used)
{
	ELINE *lp;
	int size;

	size = used;
	if (size < 4)
		size = 4;						/* Assume that an empty line is for type-in. */
	if ((lp = (ELINE *) malloc(1 + ((uint) sizeof(ELINE)) + size)) != NULL)
	{
#ifndef PMMALLOC
		lp->l_zsize = size;
#endif
		lp->l_used = used;
	} else
		mlwrite("Could not allocate %d bytes for a line", size);
	return lp;
}

/* Link a line at lx.  The content is given by nb bytes beginning at q.
*/
ELINE *lnlink(ELINE *lx, uchar *q, int nb)
{
	ELINE *ly;
	ELINE *lz;

	if ((ly = lalloc(nb)) != NULL)
	{
		cpymem(ly->l_text, q, nb);
		lz = lx->l_bp;
		lz->l_fp = ly;
		ly->l_bp = lz;
		lx->l_bp = ly;
		ly->l_fp = lx;
	}
	return ly;
}

/* Delete line "lp".  Fix all of the links that might point at it
(they are moved to offset 0 of the next line.  Unlink the line from
whatever buffer it might be in.  Release the memory.  The buffers are
updated too.  */

void lfree(ELINE *lp)
{
	BUFFER *bp;
	WINDOW *wp;

	for (wp = wheadp; wp; 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; 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;
	free((char *) lp);
}

/* This routine gets called when a character is changed in place in
the buffer bp.  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 t HARD.  Set
MODE if the mode line needs to be updated (the "*" has to be set).  */

void lbpchange(BUFFER *bp, int flag)
{
	WINDOW *wp;

	if (bp->b_nwnd != 1)				/* Ensure hard.         */
		flag = WFHARD;
	if ((bp->b_flag & BFCHG) == 0)		/* First change, so     */
	{
		flag |= WFMODE;					/* update mode lines.   */
		bp->b_flag |= BFCHG;
	}
	for (wp = wheadp; wp; wp = wp->w_wndp)
		if (wp->w_bufp == bp)
			wp->w_flag |= flag;
}


void lchange(int flag)
{
	lbpchange(curbp, flag);
}

/* 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)
{
	ELINE *lp1;
	ELINE *lp2;
	char *cp1;
	ELINE *lp3;
	char *cp2;
	int doto;
	int i;
	WINDOW *wp;

	lchange(WFEDIT);
	lp1 = curwp->w_dotp;				/* Current line         */
	if (lp1 == curbp->b_linep)			/* At the end: special  */
	{
		if (curwp->w_doto != 0)
		{
			mlwrite("bug: linsert");
			return FALSE;
		}
		if ((lp2 = lalloc(n)) == NULL)
			return FALSE;
		lp3 = lp1->l_bp;
		lp3->l_fp = lp2;
		lp2->l_fp = lp1;
		lp1->l_bp = lp2;
		lp2->l_bp = lp3;
		curwp->w_dotp = lp2;
		curwp->w_doto = n;
		for (cp1 = lp2->l_text; n--;)
			*cp1++ = c;
		return TRUE;
	}
	doto = curwp->w_doto;				/* Save for later.      */
	if (lp1->l_used + n > lsize(lp1))	/* Hard: reallocate     */
	{
		if ((lp2 = lalloc(lp1->l_used + n)) == NULL)
			return FALSE;
		cpymem(lp2->l_text, lp1->l_text, lp1->l_used);
		lp1->l_bp->l_fp = lp2;
		lp2->l_fp = lp1->l_fp;
		lp1->l_fp->l_bp = lp2;
		lp2->l_bp = lp1->l_bp;
		free((char *) lp1);
	} else
	{
		lp1->l_used += n;
		lp2 = lp1;
	}
	for (cp2 = &lp2->l_text[lp2->l_used], cp1 = cp2 - n; cp1 != &lp2->l_text[doto];)
		*--cp2 = *--cp1;
	for (i = 0; i < n; ++i)
		*cp1++ = c;
	for (wp = wheadp; wp; wp = wp->w_wndp)
	{
		if (wp->w_linep == lp1)
			wp->w_linep = lp2;
		if (wp->w_dotp == lp1)
		{
			wp->w_dotp = lp2;
			if (wp == curwp || wp->w_doto > doto)
				wp->w_doto += n;
		}
		if (wp->w_markp == lp1)
		{
			wp->w_markp = lp2;
			if (wp->w_marko > doto)
				wp->w_marko += n;
		}
	}
	return TRUE;
}

/* Insert a newline into the buffer at the current location of dot in
the current window.  The funny ass-backwards way it does things is not
a botch; it just makes the last line in the file not a special case.
Return TRUE if everything works out and FALSE on error (memory
allocation failure).  The update of dot and mark is a bit easier then
in the above case, because the split forces more updating.  */

int lnewline(void)
{
	char *cp1;
	char *cp2;
	ELINE *lp1;
	ELINE *lp2;
	int doto;
	WINDOW *wp;

	lchange(WFHARD);
	lp1 = curwp->w_dotp;				/* Get the address and  */
	doto = curwp->w_doto;				/* offset of "."        */
	if ((lp2 = lalloc(doto)) == NULL)	/* New first half line  */
		return FALSE;
	cp1 = &lp1->l_text[0];				/* Shuffle text around  */
	cp2 = &lp2->l_text[0];
	while (cp1 != &lp1->l_text[doto])
		*cp2++ = *cp1++;
	cp2 = &lp1->l_text[0];
	while (cp1 != &lp1->l_text[lp1->l_used])
		*cp2++ = *cp1++;
	lp1->l_used -= doto;
	lp2->l_bp = lp1->l_bp;
	lp1->l_bp = lp2;
	lp2->l_bp->l_fp = lp2;
	lp2->l_fp = lp1;
	wp = wheadp;						/* Windows              */
	while (wp != NULL)
	{
		if (wp->w_linep == lp1)
			wp->w_linep = lp2;
		if (wp->w_dotp == lp1)
		{
			if (wp->w_doto < doto)
				wp->w_dotp = lp2;
			else
				wp->w_doto -= doto;
		}
		if (wp->w_markp == lp1)
		{
			if (wp->w_marko < doto)
				wp->w_markp = lp2;
			else
				wp->w_marko -= doto;
		}
		wp = wp->w_wndp;
	}
	return TRUE;
}



/* Get more kill buffer for the callee.  back is true if we are trying
to get space at the beginning of the kill buffer.  */
static int kgrow(int back)
{
	int nstart;
	char *nbufp;

	nbufp = malloc(ksize + KBLOCK);
	if (nbufp == NULL)
	{
		mlwrite("Can't get %d bytes for killbuf", ksize + KBLOCK);
		return FALSE;
	}
	nstart = back ? (kstart + KBLOCK) : (KBLOCK / 4);
	if (kbufp)
	{
		cpymem(&(nbufp[nstart]), &(kbufp[kstart]), (int) (kused - kstart));
		free((char *) kbufp);
	}
	kbufp = nbufp;
	ksize += KBLOCK;
	kused = kused - kstart + nstart;
	kstart = nstart;
	return TRUE;
}


/* This function deletes n bytes, starting at dot; n >= 0.  It understands
how do 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)
{
	char *cp1;
	char *cp2;
	ELINE *dotp;
	RSIZE doto;
	RSIZE chunk;
	WINDOW *wp;

	/*
	 * HACK - doesn't matter, and fixes back-over-nl bug for empty
	 *  kill buffers.
	 */
	if (kused == kstart)
		kflag = KFORW;

	while (n > 0)
	{
		dotp = curwp->w_dotp;
		doto = curwp->w_doto;
		if (dotp == curbp->b_linep)
			return FALSE;
		chunk = dotp->l_used - doto;	/* Size of chunk.   */
		if (chunk > n)
			chunk = n;
		if (chunk == 0)					/* End of line, merge.  */
		{
			lchange(WFHARD);
			if (ldelnewline() == FALSE || (kflag != KNONE && kinsert('\n', kflag) == FALSE))
				return FALSE;
			--n;
			continue;
		}
		lchange(WFEDIT);
		cp1 = &dotp->l_text[doto];
		cp2 = cp1 + chunk;
		if (kflag == KFORW)
		{
			while (ksize - kused < chunk)
				if (kgrow(FALSE) == FALSE)
					return FALSE;
			cpymem(&(kbufp[kused]), cp1, (int) chunk);
			kused += chunk;
		} else if (kflag == KBACK)
		{
			while (kstart < chunk)
				if (kgrow(TRUE) == FALSE)
					return FALSE;
			cpymem(&(kbufp[kstart - chunk]), cp1, (int) chunk);
			kstart -= chunk;
		}
		while (cp2 != &dotp->l_text[dotp->l_used])
			*cp1++ = *cp2++;
		dotp->l_used -= chunk;
		for (wp = wheadp; wp; wp = wp->w_wndp)
		{
			if (wp->w_dotp == dotp && wp->w_doto >= doto)
			{
				wp->w_doto -= chunk;
				if (wp->w_doto < doto)
					wp->w_doto = doto;
			}
			if (wp->w_markp == dotp && wp->w_marko >= doto)
			{
				wp->w_marko -= chunk;
				if (wp->w_marko < doto)
					wp->w_marko = doto;
			}
		}
		n -= chunk;
	}
	return TRUE;
}

/* Delete a newline.  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, and this makes the kill
buffer work "right".  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.  Called by "ldelete" only.  */

int ldelnewline(void)
{
	char *cp1;
	char *cp2;
	ELINE *lp1;
	ELINE *lp2;
	ELINE *lp3;
	WINDOW *wp;

	lp1 = curwp->w_dotp;
	lp2 = lp1->l_fp;
	if (lp2 == curbp->b_linep)			/* At the buffer end.   */
	{
		if (lp1->l_used == 0)			/* Blank line.          */
			lfree(lp1);
		return TRUE;
	}
	if (lp2->l_used <= lsize(lp1) - lp1->l_used)
	{
		cpymem(&lp1->l_text[lp1->l_used], lp2->l_text, lp2->l_used);
		for (wp = wheadp; wp; 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((char *) lp2);
		return TRUE;
	}
	if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)
		return FALSE;
	cp1 = &lp1->l_text[0];
	cp2 = &lp3->l_text[0];
	while (cp1 != &lp1->l_text[lp1->l_used])
		*cp2++ = *cp1++;
	cp1 = &lp2->l_text[0];
	while (cp1 != &lp2->l_text[lp2->l_used])
		*cp2++ = *cp1++;
	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; 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((char *) lp1);
	free((char *) lp2);
	return TRUE;
}

/* Delete all of the text saved in the kill buffer.  Called by
commands when a new kill context is being created.  The kill buffer
array is released, just in case the buffer has grown to immense size.
No errors.  */

void kdelete(void)
{
	if (kbufp)
	{
		free((char *) kbufp);
		kbufp = NULL;
		kstart = kused = ksize = 0;
	}
}

/* Insert a character to the kill buffer, enlarging the buffer if
there isn't any room.  Always grow the buffer in chunks, on the
assumption that if you put something in the kill buffer you are going
to put more stuff there too later.  Return TRUE if all is well, and
FALSE on errors.  Dir says whether to put it at back or front.  */

int kinsert(int c, int dir)
{
	if (dir == KBACK)
	{
		if (kstart == 0 && kgrow(TRUE) == FALSE)
			return FALSE;
		kbufp[--kstart] = c;
	} else
	{
		if (kused == ksize && kgrow(FALSE) == FALSE)
			return FALSE;
		kbufp[kused++] = c;
	}
	return TRUE;
}

/* This function gets characters from the kill buffer.  If the
character index "n" is off the end, it returns "-1".  This lets the
caller just scan along until it gets a "-1" back.  */

int kremove(int n)
{
	if (n < 0 || n + kstart >= kused)
		return -1;
	return kbufp[n + kstart] & 0xFF;
}