plan9port

elog.c (7458B)

---

 #include <u.h>
 #include <libc.h>
 #include <draw.h>
 #include <thread.h>
 #include <cursor.h>
 #include <mouse.h>
 #include <keyboard.h>
 #include <frame.h>
 #include <fcall.h>
 #include <plumb.h>
 #include <libsec.h>
 #include "dat.h"
 #include "fns.h"
 #include "edit.h"
 
 static char Wsequence[] = "warning: changes out of sequence\n";
 static int	warned = FALSE;
 
 /*
  * Log of changes made by editing commands.  Three reasons for this:
  * 1) We want addresses in commands to apply to old file, not file-in-change.
  * 2) It's difficult to track changes correctly as things move, e.g. ,x m$
  * 3) This gives an opportunity to optimize by merging adjacent changes.
  * It's a little bit like the Undo/Redo log in Files, but Point 3) argues for a
  * separate implementation.  To do this well, we use Replace as well as
  * Insert and Delete
  */
 
 typedef struct Buflog Buflog;
 struct Buflog
 {
 	short	type;		/* Replace, Filename */
 	uint		q0;		/* location of change (unused in f) */
 	uint		nd;		/* # runes to delete */
 	uint		nr;		/* # runes in string or file name */
 };
 
 enum
 {
 	Buflogsize = sizeof(Buflog)/sizeof(Rune)
 };
 
 /*
  * Minstring shouldn't be very big or we will do lots of I/O for small changes.
  * Maxstring is RBUFSIZE so we can fbufalloc() once and not realloc elog.r.
  */
 enum
 {
 	Minstring = 16,		/* distance beneath which we merge changes */
 	Maxstring = RBUFSIZE	/* maximum length of change we will merge into one */
 };
 
 void
 eloginit(File *f)
 {
 	if(f->elog.type != Empty)
 		return;
 	f->elog.type = Null;
 	if(f->elogbuf == nil)
 		f->elogbuf = emalloc(sizeof(Buffer));
 	if(f->elog.r == nil)
 		f->elog.r = fbufalloc();
 	bufreset(f->elogbuf);
 }
 
 void
 elogclose(File *f)
 {
 	if(f->elogbuf){
 		bufclose(f->elogbuf);
 		free(f->elogbuf);
 		f->elogbuf = nil;
 	}
 }
 
 void
 elogreset(File *f)
 {
 	f->elog.type = Null;
 	f->elog.nd = 0;
 	f->elog.nr = 0;
 }
 
 void
 elogterm(File *f)
 {
 	elogreset(f);
 	if(f->elogbuf)
 		bufreset(f->elogbuf);
 	f->elog.type = Empty;
 	fbuffree(f->elog.r);
 	f->elog.r = nil;
 	warned = FALSE;
 }
 
 void
 elogflush(File *f)
 {
 	Buflog b;
 
 	b.type = f->elog.type;
 	b.q0 = f->elog.q0;
 	b.nd = f->elog.nd;
 	b.nr = f->elog.nr;
 	switch(f->elog.type){
 	default:
 		warning(nil, "unknown elog type 0x%ux\n", f->elog.type);
 		break;
 	case Null:
 		break;
 	case Insert:
 	case Replace:
 		if(f->elog.nr > 0)
 			bufinsert(f->elogbuf, f->elogbuf->nc, f->elog.r, f->elog.nr);
 		/* fall through */
 	case Delete:
 		bufinsert(f->elogbuf, f->elogbuf->nc, (Rune*)&b, Buflogsize);
 		break;
 	}
 	elogreset(f);
 }
 
 void
 elogreplace(File *f, int q0, int q1, Rune *r, int nr)
 {
 	uint gap;
 
 	if(q0==q1 && nr==0)
 		return;
 	eloginit(f);
 	if(f->elog.type!=Null && q0<f->elog.q0){
 		if(warned++ == 0)
 			warning(nil, Wsequence);
 		elogflush(f);
 	}
 	/* try to merge with previous */
 	gap = q0 - (f->elog.q0+f->elog.nd);	/* gap between previous and this */
 	if(f->elog.type==Replace && f->elog.nr+gap+nr<Maxstring){
 		if(gap < Minstring){
 			if(gap > 0){
 				bufread(&f->b, f->elog.q0+f->elog.nd, f->elog.r+f->elog.nr, gap);
 				f->elog.nr += gap;
 			}
 			f->elog.nd += gap + q1-q0;
 			runemove(f->elog.r+f->elog.nr, r, nr);
 			f->elog.nr += nr;
 			return;
 		}
 	}
 	elogflush(f);
 	f->elog.type = Replace;
 	f->elog.q0 = q0;
 	f->elog.nd = q1-q0;
 	f->elog.nr = nr;
 	if(nr > RBUFSIZE)
 		editerror("internal error: replacement string too large(%d)", nr);
 	runemove(f->elog.r, r, nr);
 }
 
 void
 eloginsert(File *f, int q0, Rune *r, int nr)
 {
 	int n;
 
 	if(nr == 0)
 		return;
 	eloginit(f);
 	if(f->elog.type!=Null && q0<f->elog.q0){
 		if(warned++ == 0)
 			warning(nil, Wsequence);
 		elogflush(f);
 	}
 	/* try to merge with previous */
 	if(f->elog.type==Insert && q0==f->elog.q0 && f->elog.nr+nr<Maxstring){
 		runemove(f->elog.r+f->elog.nr, r, nr);
 		f->elog.nr += nr;
 		return;
 	}
 	while(nr > 0){
 		elogflush(f);
 		f->elog.type = Insert;
 		f->elog.q0 = q0;
 		n = nr;
 		if(n > RBUFSIZE)
 			n = RBUFSIZE;
 		f->elog.nr = n;
 		runemove(f->elog.r, r, n);
 		r += n;
 		nr -= n;
 	}
 }
 
 void
 elogdelete(File *f, int q0, int q1)
 {
 	if(q0 == q1)
 		return;
 	eloginit(f);
 	if(f->elog.type!=Null && q0<f->elog.q0+f->elog.nd){
 		if(warned++ == 0)
 			warning(nil, Wsequence);
 		elogflush(f);
 	}
 	/* try to merge with previous */
 	if(f->elog.type==Delete && f->elog.q0+f->elog.nd==q0){
 		f->elog.nd += q1-q0;
 		return;
 	}
 	elogflush(f);
 	f->elog.type = Delete;
 	f->elog.q0 = q0;
 	f->elog.nd = q1-q0;
 }
 
 #define tracelog 0
 void
 elogapply(File *f)
 {
 	Buflog b;
 	Rune *buf;
 	uint i, n, up, mod;
 	uint tq0, tq1;
 	Buffer *log;
 	Text *t;
 	int owner;
 
 	elogflush(f);
 	log = f->elogbuf;
 	t = f->curtext;
 
 	buf = fbufalloc();
 	mod = FALSE;
 
 	owner = 0;
 	if(t->w){
 		owner = t->w->owner;
 		if(owner == 0)
 			t->w->owner = 'E';
 	}
 
 	/*
 	 * The edit commands have already updated the selection in t->q0, t->q1,
 	 * but using coordinates relative to the unmodified buffer.  As we apply the log,
 	 * we have to update the coordinates to be relative to the modified buffer.
 	 * Textinsert and textdelete will do this for us; our only work is to apply the
 	 * convention that an insertion at t->q0==t->q1 is intended to select the
 	 * inserted text.
 	 */
 
 	/*
 	 * We constrain the addresses in here (with textconstrain()) because
 	 * overlapping changes will generate bogus addresses.   We will warn
 	 * about changes out of sequence but proceed anyway; here we must
 	 * keep things in range.
 	 */
 
 	while(log->nc > 0){
 		up = log->nc-Buflogsize;
 		bufread(log, up, (Rune*)&b, Buflogsize);
 		switch(b.type){
 		default:
 			fprint(2, "elogapply: 0x%ux\n", b.type);
 			abort();
 			break;
 
 		case Replace:
 			if(tracelog)
 				warning(nil, "elog replace %d %d (%d %d)\n",
 					b.q0, b.q0+b.nd, t->q0, t->q1);
 			if(!mod){
 				mod = TRUE;
 				filemark(f);
 			}
 			textconstrain(t, b.q0, b.q0+b.nd, &tq0, &tq1);
 			textdelete(t, tq0, tq1, TRUE);
 			up -= b.nr;
 			for(i=0; i<b.nr; i+=n){
 				n = b.nr - i;
 				if(n > RBUFSIZE)
 					n = RBUFSIZE;
 				bufread(log, up+i, buf, n);
 				textinsert(t, tq0+i, buf, n, TRUE);
 			}
 			if(t->q0 == b.q0 && t->q1 == b.q0)
 				t->q1 += b.nr;
 			break;
 
 		case Delete:
 			if(tracelog)
 				warning(nil, "elog delete %d %d (%d %d)\n",
 					b.q0, b.q0+b.nd, t->q0, t->q1);
 			if(!mod){
 				mod = TRUE;
 				filemark(f);
 			}
 			textconstrain(t, b.q0, b.q0+b.nd, &tq0, &tq1);
 			textdelete(t, tq0, tq1, TRUE);
 			break;
 
 		case Insert:
 			if(tracelog)
 				warning(nil, "elog insert %d %d (%d %d)\n",
 					b.q0, b.q0+b.nr, t->q0, t->q1);
 			if(!mod){
 				mod = TRUE;
 				filemark(f);
 			}
 			textconstrain(t, b.q0, b.q0, &tq0, &tq1);
 			up -= b.nr;
 			for(i=0; i<b.nr; i+=n){
 				n = b.nr - i;
 				if(n > RBUFSIZE)
 					n = RBUFSIZE;
 				bufread(log, up+i, buf, n);
 				textinsert(t, tq0+i, buf, n, TRUE);
 			}
 			if(t->q0 == b.q0 && t->q1 == b.q0)
 				t->q1 += b.nr;
 			break;
 
 /*		case Filename:
 			f->seq = u.seq;
 			fileunsetname(f, epsilon);
 			f->mod = u.mod;
 			up -= u.n;
 			free(f->name);
 			if(u.n == 0)
 				f->name = nil;
 			else
 				f->name = runemalloc(u.n);
 			bufread(delta, up, f->name, u.n);
 			f->nname = u.n;
 			break;
 */
 		}
 		bufdelete(log, up, log->nc);
 	}
 	fbuffree(buf);
 	elogterm(f);
 
 	/*
 	 * Bad addresses will cause bufload to crash, so double check.
 	 * If changes were out of order, we expect problems so don't complain further.
 	 */
 	if(t->q0 > f->b.nc || t->q1 > f->b.nc || t->q0 > t->q1){
 		if(!warned)
 			warning(nil, "elogapply: can't happen %d %d %d\n", t->q0, t->q1, f->b.nc);
 		t->q1 = min(t->q1, f->b.nc);
 		t->q0 = min(t->q0, t->q1);
 	}
 
 	if(t->w)
 		t->w->owner = owner;
 }