plan9port

file.c (5789B)

---

 #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"
 
 /*
  * Structure of Undo list:
  * 	The Undo structure follows any associated data, so the list
  *	can be read backwards: read the structure, then read whatever
  *	data is associated (insert string, file name) and precedes it.
  *	The structure includes the previous value of the modify bit
  *	and a sequence number; successive Undo structures with the
  *	same sequence number represent simultaneous changes.
  */
 
 typedef struct Undo Undo;
 struct Undo
 {
 	short	type;		/* Delete, Insert, Filename */
 	short	mod;	/* modify bit */
 	uint		seq;		/* sequence number */
 	uint		p0;		/* location of change (unused in f) */
 	uint		n;		/* # runes in string or file name */
 };
 
 enum
 {
 	Undosize = sizeof(Undo)/sizeof(Rune)
 };
 
 File*
 fileaddtext(File *f, Text *t)
 {
 	if(f == nil){
 		f = emalloc(sizeof(File));
 		f->unread = TRUE;
 	}
 	f->text = realloc(f->text, (f->ntext+1)*sizeof(Text*));
 	f->text[f->ntext++] = t;
 	f->curtext = t;
 	return f;
 }
 
 void
 filedeltext(File *f, Text *t)
 {
 	int i;
 
 	for(i=0; i<f->ntext; i++)
 		if(f->text[i] == t)
 			goto Found;
 	error("can't find text in filedeltext");
 
     Found:
 	f->ntext--;
 	if(f->ntext == 0){
 		fileclose(f);
 		return;
 	}
 	memmove(f->text+i, f->text+i+1, (f->ntext-i)*sizeof(Text*));
 	if(f->curtext == t)
 		f->curtext = f->text[0];
 }
 
 void
 fileinsert(File *f, uint p0, Rune *s, uint ns)
 {
 	if(p0 > f->b.nc)
 		error("internal error: fileinsert");
 	if(f->seq > 0)
 		fileuninsert(f, &f->delta, p0, ns);
 	bufinsert(&f->b, p0, s, ns);
 	if(ns)
 		f->mod = TRUE;
 }
 
 void
 fileuninsert(File *f, Buffer *delta, uint p0, uint ns)
 {
 	Undo u;
 
 	/* undo an insertion by deleting */
 	u.type = Delete;
 	u.mod = f->mod;
 	u.seq = f->seq;
 	u.p0 = p0;
 	u.n = ns;
 	bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
 }
 
 void
 filedelete(File *f, uint p0, uint p1)
 {
 	if(!(p0<=p1 && p0<=f->b.nc && p1<=f->b.nc))
 		error("internal error: filedelete");
 	if(f->seq > 0)
 		fileundelete(f, &f->delta, p0, p1);
 	bufdelete(&f->b, p0, p1);
 	if(p1 > p0)
 		f->mod = TRUE;
 }
 
 void
 fileundelete(File *f, Buffer *delta, uint p0, uint p1)
 {
 	Undo u;
 	Rune *buf;
 	uint i, n;
 
 	/* undo a deletion by inserting */
 	u.type = Insert;
 	u.mod = f->mod;
 	u.seq = f->seq;
 	u.p0 = p0;
 	u.n = p1-p0;
 	buf = fbufalloc();
 	for(i=p0; i<p1; i+=n){
 		n = p1 - i;
 		if(n > RBUFSIZE)
 			n = RBUFSIZE;
 		bufread(&f->b, i, buf, n);
 		bufinsert(delta, delta->nc, buf, n);
 	}
 	fbuffree(buf);
 	bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
 
 }
 
 void
 filesetname(File *f, Rune *name, int n)
 {
 	if(f->seq > 0)
 		fileunsetname(f, &f->delta);
 	free(f->name);
 	f->name = runemalloc(n);
 	runemove(f->name, name, n);
 	f->nname = n;
 	f->unread = TRUE;
 }
 
 void
 fileunsetname(File *f, Buffer *delta)
 {
 	Undo u;
 
 	/* undo a file name change by restoring old name */
 	u.type = Filename;
 	u.mod = f->mod;
 	u.seq = f->seq;
 	u.p0 = 0;	/* unused */
 	u.n = f->nname;
 	if(f->nname)
 		bufinsert(delta, delta->nc, f->name, f->nname);
 	bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
 }
 
 uint
 fileload(File *f, uint p0, int fd, int *nulls, DigestState *h)
 {
 	if(f->seq > 0)
 		error("undo in file.load unimplemented");
 	return bufload(&f->b, p0, fd, nulls, h);
 }
 
 /* return sequence number of pending redo */
 uint
 fileredoseq(File *f)
 {
 	Undo u;
 	Buffer *delta;
 
 	delta = &f->epsilon;
 	if(delta->nc == 0)
 		return 0;
 	bufread(delta, delta->nc-Undosize, (Rune*)&u, Undosize);
 	return u.seq;
 }
 
 void
 fileundo(File *f, int isundo, uint *q0p, uint *q1p)
 {
 	Undo u;
 	Rune *buf;
 	uint i, j, n, up;
 	uint stop;
 	Buffer *delta, *epsilon;
 
 	if(isundo){
 		/* undo; reverse delta onto epsilon, seq decreases */
 		delta = &f->delta;
 		epsilon = &f->epsilon;
 		stop = f->seq;
 	}else{
 		/* redo; reverse epsilon onto delta, seq increases */
 		delta = &f->epsilon;
 		epsilon = &f->delta;
 		stop = 0;	/* don't know yet */
 	}
 
 	buf = fbufalloc();
 	while(delta->nc > 0){
 		up = delta->nc-Undosize;
 		bufread(delta, up, (Rune*)&u, Undosize);
 		if(isundo){
 			if(u.seq < stop){
 				f->seq = u.seq;
 				goto Return;
 			}
 		}else{
 			if(stop == 0)
 				stop = u.seq;
 			if(u.seq > stop)
 				goto Return;
 		}
 		switch(u.type){
 		default:
 			fprint(2, "undo: 0x%ux\n", u.type);
 			abort();
 			break;
 
 		case Delete:
 			f->seq = u.seq;
 			fileundelete(f, epsilon, u.p0, u.p0+u.n);
 			f->mod = u.mod;
 			bufdelete(&f->b, u.p0, u.p0+u.n);
 			for(j=0; j<f->ntext; j++)
 				textdelete(f->text[j], u.p0, u.p0+u.n, FALSE);
 			*q0p = u.p0;
 			*q1p = u.p0;
 			break;
 
 		case Insert:
 			f->seq = u.seq;
 			fileuninsert(f, epsilon, u.p0, u.n);
 			f->mod = u.mod;
 			up -= u.n;
 			for(i=0; i<u.n; i+=n){
 				n = u.n - i;
 				if(n > RBUFSIZE)
 					n = RBUFSIZE;
 				bufread(delta, up+i, buf, n);
 				bufinsert(&f->b, u.p0+i, buf, n);
 				for(j=0; j<f->ntext; j++)
 					textinsert(f->text[j], u.p0+i, buf, n, FALSE);
 			}
 			*q0p = u.p0;
 			*q1p = u.p0+u.n;
 			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(delta, up, delta->nc);
 	}
 	if(isundo)
 		f->seq = 0;
     Return:
 	fbuffree(buf);
 }
 
 void
 filereset(File *f)
 {
 	bufreset(&f->delta);
 	bufreset(&f->epsilon);
 	f->seq = 0;
 }
 
 void
 fileclose(File *f)
 {
 	free(f->name);
 	f->nname = 0;
 	f->name = nil;
 	free(f->text);
 	f->ntext = 0;
 	f->text = nil;
 	bufclose(&f->b);
 	bufclose(&f->delta);
 	bufclose(&f->epsilon);
 	elogclose(f);
 	free(f);
 }
 
 void
 filemark(File *f)
 {
 	if(f->epsilon.nc)
 		bufdelete(&f->epsilon, 0, f->epsilon.nc);
 	f->seq = seq;
 }