#include "sam.h"

enum
{
       Slop = 100,     /* room to grow with reallocation */
};

static
void
sizecache(Buffer *b, uint n)
{
       if(n <= b->cmax)
               return;
       b->cmax = n+Slop;
       b->c = runerealloc(b->c, b->cmax);
}

static
void
addblock(Buffer *b, uint i, uint n)
{
       if(i > b->nbl)
               panic("internal error: addblock");

       b->bl = realloc(b->bl, (b->nbl+1)*sizeof b->bl[0]);
       if(i < b->nbl)
               memmove(b->bl+i+1, b->bl+i, (b->nbl-i)*sizeof(Block*));
       b->bl[i] = disknewblock(disk, n);
       b->nbl++;
}


static
void
delblock(Buffer *b, uint i)
{
       if(i >= b->nbl)
               panic("internal error: delblock");

       diskrelease(disk, b->bl[i]);
       b->nbl--;
       if(i < b->nbl)
               memmove(b->bl+i, b->bl+i+1, (b->nbl-i)*sizeof(Block*));
       b->bl = realloc(b->bl, b->nbl*sizeof b->bl[0]);
}

/*
* Move cache so b->cq <= q0 < b->cq+b->cnc.
* If at very end, q0 will fall on end of cache block.
*/

static
void
flush(Buffer *b)
{
       if(b->cdirty || b->cnc==0){
               if(b->cnc == 0)
                       delblock(b, b->cbi);
               else
                       diskwrite(disk, &b->bl[b->cbi], b->c, b->cnc);
               b->cdirty = FALSE;
       }
}

static
void
setcache(Buffer *b, uint q0)
{
       Block **blp, *bl;
       uint i, q;

       if(q0 > b->nc)
               panic("internal error: setcache");
       /*
        * flush and reload if q0 is not in cache.
        */
       if(b->nc == 0 || (b->cq<=q0 && q0<b->cq+b->cnc))
               return;
       /*
        * if q0 is at end of file and end of cache, continue to grow this block
        */
       if(q0==b->nc && q0==b->cq+b->cnc && b->cnc<=Maxblock)
               return;
       flush(b);
       /* find block */
       if(q0 < b->cq){
               q = 0;
               i = 0;
       }else{
               q = b->cq;
               i = b->cbi;
       }
       blp = &b->bl[i];
       while(q+(*blp)->n <= q0 && q+(*blp)->n < b->nc){
               q += (*blp)->n;
               i++;
               blp++;
               if(i >= b->nbl)
                       panic("block not found");
       }
       bl = *blp;
       /* remember position */
       b->cbi = i;
       b->cq = q;
       sizecache(b, bl->n);
       b->cnc = bl->n;
       /*read block*/
       diskread(disk, bl, b->c, b->cnc);
}

void
bufinsert(Buffer *b, uint q0, Rune *s, uint n)
{
       uint i, m, t, off;

       if(q0 > b->nc)
               panic("internal error: bufinsert");

       while(n > 0){
               setcache(b, q0);
               off = q0-b->cq;
               if(b->cnc+n <= Maxblock){
                       /* Everything fits in one block. */
                       t = b->cnc+n;
                       m = n;
                       if(b->bl == nil){       /* allocate */
                               if(b->cnc != 0)
                                       panic("internal error: bufinsert1 cnc!=0");
                               addblock(b, 0, t);
                               b->cbi = 0;
                       }
                       sizecache(b, t);
                       runemove(b->c+off+m, b->c+off, b->cnc-off);
                       runemove(b->c+off, s, m);
                       b->cnc = t;
                       goto Tail;
               }
               /*
                * We must make a new block.  If q0 is at
                * the very beginning or end of this block,
                * just make a new block and fill it.
                */
               if(q0==b->cq || q0==b->cq+b->cnc){
                       if(b->cdirty)
                               flush(b);
                       m = min(n, Maxblock);
                       if(b->bl == nil){       /* allocate */
                               if(b->cnc != 0)
                                       panic("internal error: bufinsert2 cnc!=0");
                               i = 0;
                       }else{
                               i = b->cbi;
                               if(q0 > b->cq)
                                       i++;
                       }
                       addblock(b, i, m);
                       sizecache(b, m);
                       runemove(b->c, s, m);
                       b->cq = q0;
                       b->cbi = i;
                       b->cnc = m;
                       goto Tail;
               }
               /*
                * Split the block; cut off the right side and
                * let go of it.
                */
               m = b->cnc-off;
               if(m > 0){
                       i = b->cbi+1;
                       addblock(b, i, m);
                       diskwrite(disk, &b->bl[i], b->c+off, m);
                       b->cnc -= m;
               }
               /*
                * Now at end of block.  Take as much input
                * as possible and tack it on end of block.
                */
               m = min(n, Maxblock-b->cnc);
               sizecache(b, b->cnc+m);
               runemove(b->c+b->cnc, s, m);
               b->cnc += m;
 Tail:
               b->nc += m;
               q0 += m;
               s += m;
               n -= m;
               b->cdirty = TRUE;
       }
}

void
bufdelete(Buffer *b, uint q0, uint q1)
{
       uint m, n, off;

       if(!(q0<=q1 && q0<=b->nc && q1<=b->nc))
               panic("internal error: bufdelete");
       while(q1 > q0){
               setcache(b, q0);
               off = q0-b->cq;
               if(q1 > b->cq+b->cnc)
                       n = b->cnc - off;
               else
                       n = q1-q0;
               m = b->cnc - (off+n);
               if(m > 0)
                       runemove(b->c+off, b->c+off+n, m);
               b->cnc -= n;
               b->cdirty = TRUE;
               q1 -= n;
               b->nc -= n;
       }
}

uint
bufload(Buffer *b, uint q0, int fd, int *nulls)
{
       char *p;
       Rune *r;
       int l, m, n, nb, nr;
       uint q1;

       if(q0 > b->nc)
               panic("internal error: bufload");
       p = malloc((Maxblock+UTFmax+1)*sizeof p[0]);
       if(p == nil)
               panic("bufload: malloc failed");
       r = runemalloc(Maxblock);
       m = 0;
       n = 1;
       q1 = q0;
       /*
        * At top of loop, may have m bytes left over from
        * last pass, possibly representing a partial rune.
        */
       while(n > 0){
               n = read(fd, p+m, Maxblock);
               if(n < 0){
                       error(Ebufload);
                       break;
               }
               m += n;
               p[m] = 0;
               l = m;
               if(n > 0)
                       l -= UTFmax;
               cvttorunes(p, l, r, &nb, &nr, nulls);
               memmove(p, p+nb, m-nb);
               m -= nb;
               bufinsert(b, q1, r, nr);
               q1 += nr;
       }
       free(p);
       free(r);
       return q1-q0;
}

void
bufread(Buffer *b, uint q0, Rune *s, uint n)
{
       uint m;

       if(!(q0<=b->nc && q0+n<=b->nc))
               panic("bufread: internal error");

       while(n > 0){
               setcache(b, q0);
               m = min(n, b->cnc-(q0-b->cq));
               runemove(s, b->c+(q0-b->cq), m);
               q0 += m;
               s += m;
               n -= m;
       }
}

void
bufreset(Buffer *b)
{
       int i;

       b->nc = 0;
       b->cnc = 0;
       b->cq = 0;
       b->cdirty = 0;
       b->cbi = 0;
       /* delete backwards to avoid n² behavior */
       for(i=b->nbl-1; --i>=0; )
               delblock(b, i);
}

void
bufclose(Buffer *b)
{
       bufreset(b);
       free(b->c);
       b->c = nil;
       b->cnc = 0;
       free(b->bl);
       b->bl = nil;
       b->nbl = 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.