ref: e3583a0837891ab2059b91f6500c88baf34982dc
dir: /sys/src/cmd/jam/buff.c/
#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; }