#include "sam.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;
typedef struct Merge Merge;

struct Undo
{
       short   type;           /* Delete, Insert, Filename, Dot, Mark */
       short   mod;            /* modify bit */
       uint    seq;            /* sequence number */
       uint    p0;             /* location of change (unused in f) */
       uint    n;              /* # runes in string or file name */
};

struct Merge
{
       File    *f;
       uint    seq;            /* of logged change */
       uint    p0;             /* location of change (unused in f) */
       uint    n;              /* # runes to delete */
       uint    nbuf;           /* # runes to insert */
       Rune    buf[RBUFSIZE];
};

enum
{
       Maxmerge = 50,
       Undosize = sizeof(Undo)/sizeof(Rune),
};

static Merge    merge;

File*
fileopen(void)
{
       File *f;

       f = emalloc(sizeof(File));
       f->dot.f = f;
       f->ndot.f = f;
       f->seq = 0;
       f->mod = FALSE;
       f->unread = TRUE;
       Strinit0(&f->name);
       return f;
}

int
fileisdirty(File *f)
{
       return f->seq != f->cleanseq;
}

static void
wrinsert(Buffer *delta, int seq, int mod, uint p0, Rune *s, uint ns)
{
       Undo u;

       u.type = Insert;
       u.mod = mod;
       u.seq = seq;
       u.p0 = p0;
       u.n = ns;
       bufinsert(delta, delta->nc, s, ns);
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}

static void
wrdelete(Buffer *delta, int seq, int mod, uint p0, uint p1)
{
       Undo u;

       u.type = Delete;
       u.mod = mod;
       u.seq = seq;
       u.p0 = p0;
       u.n = p1 - p0;
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}

void
flushmerge(void)
{
       File *f;

       f = merge.f;
       if(f == nil)
               return;
       if(merge.seq != f->seq)
               panic("flushmerge seq mismatch");
       if(merge.n != 0)
               wrdelete(&f->epsilon, f->seq, TRUE, merge.p0, merge.p0+merge.n);
       if(merge.nbuf != 0)
               wrinsert(&f->epsilon, f->seq, TRUE, merge.p0+merge.n, merge.buf, merge.nbuf);
       merge.f = nil;
       merge.n = 0;
       merge.nbuf = 0;
}

void
mergeextend(File *f, uint p0)
{
       uint mp0n;

       mp0n = merge.p0+merge.n;
       if(mp0n != p0){
               bufread(f, mp0n, merge.buf+merge.nbuf, p0-mp0n);
               merge.nbuf += p0-mp0n;
               merge.n = p0-merge.p0;
       }
}

/*
* like fileundelete, but get the data from arguments
*/
void
loginsert(File *f, uint p0, Rune *s, uint ns)
{
       if(f->rescuing)
               return;
       if(ns == 0)
               return;
       if(ns>STRSIZE)
               panic("loginsert");
       if(f->seq < seq)
               filemark(f);
       if(p0 < f->hiposn)
               error(Esequence);

       if(merge.f != f
       || p0-(merge.p0+merge.n)>Maxmerge                       /* too far */
       || merge.nbuf+((p0+ns)-(merge.p0+merge.n))>=RBUFSIZE)   /* too long */
               flushmerge();

       if(ns>=RBUFSIZE){
               if(!(merge.n == 0 && merge.nbuf == 0 && merge.f == nil))
                       panic("loginsert bad merge state");
               wrinsert(&f->epsilon, f->seq, TRUE, p0, s, ns);
       }else{
               if(merge.f != f){
                       merge.f = f;
                       merge.p0 = p0;
                       merge.seq = f->seq;
               }
               mergeextend(f, p0);

               /* append string to merge */
               runemove(merge.buf+merge.nbuf, s, ns);
               merge.nbuf += ns;
       }

       f->hiposn = p0;
       if(!f->unread && !f->mod)
               state(f, Dirty);
}

void
logdelete(File *f, uint p0, uint p1)
{
       if(f->rescuing)
               return;
       if(p0 == p1)
               return;
       if(f->seq < seq)
               filemark(f);
       if(p0 < f->hiposn)
               error(Esequence);

       if(merge.f != f
       || p0-(merge.p0+merge.n)>Maxmerge                       /* too far */
       || merge.nbuf+(p0-(merge.p0+merge.n))>=RBUFSIZE){       /* too long */
               flushmerge();
               merge.f = f;
               merge.p0 = p0;
               merge.seq = f->seq;
       }

       mergeextend(f, p0);

       /* add to deletion */
       merge.n = p1-merge.p0;

       f->hiposn = p1;
       if(!f->unread && !f->mod)
               state(f, Dirty);
}

/*
* like fileunsetname, but get the data from arguments
*/
void
logsetname(File *f, String *s)
{
       Undo u;
       Buffer *delta;

       if(f->rescuing)
               return;

       if(f->unread){  /* This is setting initial file name */
               filesetname(f, s);
               return;
       }

       if(f->seq < seq)
               filemark(f);

       /* undo a file name change by restoring old name */
       delta = &f->epsilon;
       u.type = Filename;
       u.mod = TRUE;
       u.seq = f->seq;
       u.p0 = 0;       /* unused */
       u.n = s->n;
       if(s->n)
               bufinsert(delta, delta->nc, s->s, s->n);
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
       if(!f->unread && !f->mod)
               state(f, Dirty);
}

#ifdef NOTEXT
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;
       panic("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];
}
#endif

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
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, i, buf, n);
               bufinsert(delta, delta->nc, buf, n);
       }
       fbuffree(buf);
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);

}

int
filereadc(File *f, uint q)
{
       Rune r;

       if(q >= f->nc)
               return -1;
       bufread(f, q, &r, 1);
       return r;
}

void
filesetname(File *f, String *s)
{
       if(!f->unread)  /* This is setting initial file name */
               fileunsetname(f, &f->delta);
       Strduplstr(&f->name, s);
       sortname(f);
       f->unread = TRUE;
}

void
fileunsetname(File *f, Buffer *delta)
{
       String s;
       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 */
       Strinit(&s);
       Strduplstr(&s, &f->name);
       fullname(&s);
       u.n = s.n;
       if(s.n)
               bufinsert(delta, delta->nc, s.s, s.n);
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
       Strclose(&s);
}

void
fileunsetdot(File *f, Buffer *delta, Range dot)
{
       Undo u;

       u.type = Dot;
       u.mod = f->mod;
       u.seq = f->seq;
       u.p0 = dot.p1;
       u.n = dot.p2 - dot.p1;
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}

void
fileunsetmark(File *f, Buffer *delta, Range mark)
{
       Undo u;

       u.type = Mark;
       u.mod = f->mod;
       u.seq = f->seq;
       u.p0 = mark.p1;
       u.n = mark.p2 - mark.p1;
       bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}

uint
fileload(File *f, uint p0, int fd, int *nulls)
{
       if(f->seq > 0)
               panic("undo in file.load unimplemented");
       return bufload(f, p0, fd, nulls);
}

int
fileupdate(File *f, int notrans, int toterm)
{
       uint p1, p2;
       int mod;

       if(f->rescuing)
               return FALSE;

       flushmerge();

       /*
        * fix the modification bit
        * subtle point: don't save it away in the log.
        *
        * if another change is made, the correct f->mod
        * state is saved  in the undo log by filemark
        * when setting the dot and mark.
        *
        * if the change is undone, the correct state is
        * saved from f in the fileun... routines.
        */
       mod = f->mod;
       f->mod = f->prevmod;
       if(f == cmd)
               notrans = TRUE;
       else{
               fileunsetdot(f, &f->delta, f->prevdot);
               fileunsetmark(f, &f->delta, f->prevmark);
       }
       f->dot = f->ndot;
       fileundo(f, FALSE, !notrans, &p1, &p2, toterm);
       f->mod = mod;

       if(f->delta.nc == 0)
               f->seq = 0;

       if(f == cmd)
               return FALSE;

       if(f->mod){
               f->closeok = 0;
               quitok = 0;
       }else
               f->closeok = 1;
       return TRUE;
}

long
prevseq(Buffer *b)
{
       Undo u;
       uint up;

       up = b->nc;
       if(up == 0)
               return 0;
       up -= Undosize;
       bufread(b, up, (Rune*)&u, Undosize);
       return u.seq;
}

long
undoseq(File *f, int isundo)
{
       if(isundo)
               return f->seq;

       return prevseq(&f->epsilon);
}

void
fileundo(File *f, int isundo, int canredo, uint *q0p, uint *q1p, int flag)
{
       Undo u;
       Rune *buf;
       uint i, 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 */
       }

       raspstart(f);
       while(delta->nc > 0){
               /* rasp and buffer are in sync; sync with wire if needed */
               if(needoutflush())
                       raspflush(f);
               up = delta->nc-Undosize;
               bufread(delta, up, (Rune*)&u, Undosize);
               if(isundo){
                       if(u.seq < stop){
                               f->seq = u.seq;
                               raspdone(f, flag);
                               return;
                       }
               }else{
                       if(stop == 0)
                               stop = u.seq;
                       if(u.seq > stop){
                               raspdone(f, flag);
                               return;
                       }
               }
               switch(u.type){
               default:
                       panic("undo unknown u.type");
                       break;

               case Delete:
                       f->seq = u.seq;
                       if(canredo)
                               fileundelete(f, epsilon, u.p0, u.p0+u.n);
                       f->mod = u.mod;
                       bufdelete(f, u.p0, u.p0+u.n);
                       raspdelete(f, u.p0, u.p0+u.n, flag);
                       *q0p = u.p0;
                       *q1p = u.p0;
                       break;

               case Insert:
                       f->seq = u.seq;
                       if(canredo)
                               fileuninsert(f, epsilon, u.p0, u.n);
                       f->mod = u.mod;
                       up -= u.n;
                       buf = fbufalloc();
                       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, u.p0+i, buf, n);
                               raspinsert(f, u.p0+i, buf, n, flag);
                       }
                       fbuffree(buf);
                       *q0p = u.p0;
                       *q1p = u.p0+u.n;
                       break;

               case Filename:
                       f->seq = u.seq;
                       if(canredo)
                               fileunsetname(f, epsilon);
                       f->mod = u.mod;
                       up -= u.n;

                       Strinsure(&f->name, u.n+1);
                       bufread(delta, up, f->name.s, u.n);
                       f->name.s[u.n] = 0;
                       f->name.n = u.n;
                       fixname(&f->name);
                       sortname(f);
                       break;
               case Dot:
                       f->seq = u.seq;
                       if(canredo)
                               fileunsetdot(f, epsilon, f->dot.r);
                       f->mod = u.mod;
                       f->dot.r.p1 = u.p0;
                       f->dot.r.p2 = u.p0 + u.n;
                       break;
               case Mark:
                       f->seq = u.seq;
                       if(canredo)
                               fileunsetmark(f, epsilon, f->mark);
                       f->mod = u.mod;
                       f->mark.p1 = u.p0;
                       f->mark.p2 = u.p0 + u.n;
                       break;
               }
               bufdelete(delta, up, delta->nc);
       }
       if(isundo)
               f->seq = 0;
       raspdone(f, flag);
}

void
filereset(File *f)
{
       bufreset(&f->delta);
       bufreset(&f->epsilon);
       f->seq = 0;
}

void
fileclose(File *f)
{
       Strclose(&f->name);
       bufclose(f);
       bufclose(&f->delta);
       bufclose(&f->epsilon);
       if(f->rasp)
               listfree(f->rasp);
       free(f);
}

void
filemark(File *f)
{

       if(f->unread)
               return;
       if(f->epsilon.nc)
               bufdelete(&f->epsilon, 0, f->epsilon.nc);

       if(f != cmd){
               f->prevdot = f->dot.r;
               f->prevmark = f->mark;
               f->prevseq = f->seq;
               f->prevmod = f->mod;
       }

       f->ndot = f->dot;
       f->seq = seq;
       f->hiposn = 0;
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.