![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to file.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / sam|
Return to file.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / sam |
1.1 root 1: #include "sam.h"
2:
3: /*
4: * Files are splayed out a factor of NDISC to reduce indirect block access
5: */
6: Discdesc *files[NDISC];
7: Discdesc *transcripts[NDISC];
8: Buffer *undobuf;
9: static String *ftempstr();
10: int fcount;
11:
12: #ifdef SUN
13: #define SKIP 50
14: #define MAXCACHE 25000
15: #else
16: enum{
17: SKIP=50, /* max dist between file changes folded together */
18: MAXCACHE=25000, /* max length of cache. must be < 32K-BLOCKSIZE */
19: };
20: #endif
21:
22: Fstart()
23: {
24: undobuf=Bopen(Dstart());
25: snarfbuf=Bopen(Dstart());
26: }
27: File *
28: Fopen()
29: {
30: register File *f;
31: f=new(File, 1);
32: if(files[fcount]==0){
33: files[fcount]=Dstart();
34: transcripts[fcount]=Dstart();
35: }
36: f->buf=Bopen(files[fcount]);
37: f->transcript=Bopen(transcripts[fcount]);
38: if(++fcount==NDISC)
39: fcount=0;
40: f->nbytes=0;
41: f->markp=0;
42: f->mod=0;
43: f->dot.f=f;
44: strinit(&f->name);
45: straddc(&f->name, '\0');
46: strinit(&f->cache);
47: f->state=Unread;
48: Fmark(f, (Mod)0);
49: return f;
50: }
51: Fclose(f)
52: File *f;
53: {
54: Bclose(f->buf);
55: Bclose(f->transcript);
56: strclose(&f->name);
57: strclose(&f->cache);
58: if(f->rasp)
59: listfree(f->rasp);
60: free((uchar *)f);
61: }
62: Fmark(f, m)
63: register File *f;
64: Mod m;
65: {
66: register Buffer *t=f->transcript;
67: Posn p;
68: if(f->state==Unread) /* this is implicit 'e' of a file */
69: return;
70: p=m==0? -1 : f->markp;
71: f->markp=t->nbytes;
72: puthdr_M(t, p, f->dot.r, f->mark, f->mod, f->state);
73: f->marked=TRUE;
74: f->mod=m;
75: f->hiposn= -1;
76: /* Safety first */
77: f->cp1=f->cp2=0;
78: strzero(&f->cache);
79: }
80: Finsert(f, str, p1)
81: register File *f;
82: String *str;
83: Posn p1;
84: {
85: register Buffer *t=f->transcript;
86: if(str->n==0)
87: return;
88: if(str->n<0 || str->n>32767)
89: panic("Finsert");
90: if(f->mod<modnum)
91: Fmark(f, modnum);
92: if(p1<f->hiposn)
93: error(Esequence);
94: if(str->n>=BLOCKSIZE){ /* don't bother with the cache */
95: Fflush(f);
96: puthdr_csP(t, 'i', str->n, p1);
97: Binsert(t, str, t->nbytes);
98: }else{ /* insert into the cache instead of the transcript */
99: if(f->cp2==0 && f->cp1==0 && f->cache.n==0) /* empty cache */
100: f->cp1=f->cp2=p1;
101: if(p1-f->cp2>SKIP || (long)f->cache.n+(long)str->n>MAXCACHE){
102: Fflush(f);
103: f->cp1=f->cp2=p1;
104: }
105: if(f->cp2!=p1){ /* grab the piece in between */
106: unsigned char buf[SKIP];
107: String s;
108: Fchars(f, buf, f->cp2, p1);
109: s.s=buf;
110: s.n=p1-f->cp2;
111: strinsert(&f->cache, &s, (long)f->cache.n);
112: f->cp2=p1;
113: }
114: strinsert(&f->cache, str, (long)f->cache.n);
115: }
116: if(f!=cmd)
117: quitok=FALSE;
118: f->closeok=FALSE;
119: if(f->state==Clean)
120: state(f, Dirty);
121: f->hiposn=p1;
122: }
123: Fdelete(f, p1, p2)
124: register File *f;
125: Posn p1, p2;
126: {
127: if(p1==p2)
128: return;
129: if(f->mod<modnum)
130: Fmark(f, modnum);
131: if(p1<f->hiposn)
132: error(Esequence);
133: if(p1-f->cp2>SKIP)
134: Fflush(f);
135: if(f->cp2==0 && f->cp1==0 && f->cache.n==0) /* empty cache */
136: f->cp1=f->cp2=p1;
137: if(f->cp2!=p1){ /* grab the piece in between */
138: if(f->cache.n+(p1-f->cp2)>MAXCACHE){
139: Fflush(f);
140: f->cp1=f->cp2=p1;
141: }else{
142: unsigned char buf[SKIP];
143: String s;
144: Fchars(f, buf, f->cp2, p1);
145: s.s=buf;
146: s.n=p1-f->cp2;
147: strinsert(&f->cache, &s, (long)f->cache.n);
148: }
149: }
150: f->cp2=p2;
151: if(f!=cmd)
152: quitok=FALSE;
153: f->closeok=FALSE;
154: if(f->state==Clean)
155: state(f, Dirty);
156: f->hiposn=p2;
157: }
158: Fflush(f)
159: register File *f;
160: {
161: register Buffer *t=f->transcript;
162: register Posn p1=f->cp1, p2=f->cp2;
163: if(p1!=p2)
164: puthdr_cPP(t, 'd', p1, p2);
165: if(f->cache.n){
166: puthdr_csP(t, 'i', f->cache.n, p2);
167: Binsert(t, &f->cache, t->nbytes);
168: strzero(&f->cache);
169: }
170: f->cp1=f->cp2=0;
171: }
172: Fsetname(f)
173: register File *f;
174: {
175: register Buffer *t=f->transcript;
176: if(f->state==Unread){ /* This is setting initial file name */
177: strdupstr(&f->name, &genstr);
178: sortname(f);
179: }else{
180: if(f->mod<modnum)
181: Fmark(f, modnum);
182: if(genstr.n>BLOCKSIZE)
183: error(Elong);
184: puthdr_cs(t, 'f', genstr.n);
185: Binsert(t, &genstr, t->nbytes);
186: }
187: }
188: /*
189: * The heart of it all. Fupdate will run along the transcript list, executing
190: * the commands and converting them into their inverses for a later undo pass.
191: * The pass runs top to bottom, so addresses in the transcript are tracked
192: * (by the var. delta) so they stay valid during the operation. This causes
193: * all operations to appear to happen simultaneously, which is why the addresses
194: * passed to Fdelete and Finsert never take into account other changes occurring
195: * in this command (and is why things are done this way).
196: */
197: Fupdate(f, isundo, toterm)
198: register File *f;
199: {
200: register Buffer *t=f->transcript;
201: register Buffer *u=undobuf;
202: register n, ni;
203: register Posn p0, p1, p2, p, deltadot=0, deltamark=0, delta=0;
204: int changes=FALSE;
205: uchar buf[32];
206: uchar tmp[BLOCKSIZE];
207: Fflush(f);
208: if(f->marked)
209: p0=f->markp+sizeof(Mark);
210: else
211: p0=0;
212: while((n=Bread(t, buf, sizeof buf, p0))>0){
213: switch(buf[0]){
214: default:
215: panic("unknown in Fupdate");
216: case 'd':
217: GETPOSN(p1, buf+1);
218: GETPOSN(p2, buf+1+sizeof(Posn));
219: p0+=1+2*sizeof(Posn);
220: if(p2<=f->dot.r.p1)
221: deltadot-=p2-p1;
222: if(p2<=f->mark.p1)
223: deltamark-=p2-p1;
224: p1+=delta, p2+=delta;
225: delta-=p2-p1;
226: if(!isundo)
227: for(p=p1; p<p2; p+=ni){
228: if(p2-p>BLOCKSIZE)
229: ni=BLOCKSIZE;
230: else
231: ni=p2-p;
232: puthdr_csP(u, 'i', ni, p1);
233: Bread(f->buf, tmp, ni, p);
234: Binsert(u, ftempstr(tmp, ni), u->nbytes);
235: }
236: f->nbytes-=p2-p1;
237: Bdelete(f->buf, p1, p2);
238: changes=TRUE;
239: break;
240: case 'f':
241: n=buf[1]&0xFF;
242: n|=buf[2]<<8;
243: p0+=1+SS;
244: strinsure(&genstr, (ulong)n);
245: Bread(t, tmp, n, p0);
246: p0+=n;
247: strdup(&genstr, tmp);
248: if(!isundo){
249: puthdr_cs(u, 'f', f->name.n);
250: Binsert(u, &f->name, u->nbytes);
251: }
252: strdupstr(&f->name, &genstr);
253: sortname(f);
254: changes=TRUE;
255: break;
256: case 'i':
257: n=buf[1]&0xFF;
258: n|=buf[2]<<8;
259: GETPOSN(p1, (buf+1+SS));
260: p0+=1+SS+sizeof(Posn);
261: if(p1<f->dot.r.p1)
262: deltadot+=n;
263: if(p1<f->mark.p1)
264: deltamark+=n;
265: p1+=delta;
266: delta+=n;
267: if(!isundo)
268: puthdr_cPP(u, 'd', p1, p1+n);
269: changes=TRUE;
270: f->nbytes+=n;
271: while(n>0){
272: if(n>BLOCKSIZE)
273: ni=BLOCKSIZE;
274: else
275: ni=n;
276: Bread(t, tmp, ni, p0);
277: Binsert(f->buf, ftempstr(tmp, ni), p1);
278: n-=ni;
279: p1+=ni;
280: p0+=ni;
281: }
282: break;
283: }
284: }
285: toterminal(f, toterm);
286: f->dot.r.p1+=deltadot;
287: f->dot.r.p2+=deltadot;
288: if(f->dot.r.p1>f->nbytes)
289: f->dot.r.p1=f->nbytes;
290: if(f->dot.r.p2>f->nbytes)
291: f->dot.r.p2=f->nbytes;
292: f->mark.p1+=deltamark;
293: f->mark.p2+=deltamark;
294: if(f->mark.p1>f->nbytes)
295: f->mark.p1=f->nbytes;
296: if(f->mark.p2>f->nbytes)
297: f->mark.p2=f->nbytes;
298: if(n<0)
299: panic("Fupdate read");
300: if(f==cmd)
301: f->mod=0; /* can't undo command file */
302: if(p0>f->markp+sizeof(Posn)){ /* for undo, this throws away the undo transcript */
303: if(f->mod>0){ /* can't undo the dawn of time */
304: Bdelete(t, f->markp+sizeof(Mark), t->nbytes);
305: /* copy the undo list back into the transcript */
306: for(p=0; p<u->nbytes; p+=ni){
307: if(u->nbytes-p>BLOCKSIZE)
308: ni=BLOCKSIZE;
309: else
310: ni=u->nbytes-p;
311: Bread(u, tmp, ni, p);
312: Binsert(t, ftempstr(tmp, ni), t->nbytes);
313: }
314: }
315: Bdelete(u, (Posn)0, u->nbytes);
316: }
317: return f==cmd? FALSE : changes;
318: }
319: puthdr_csP(b, c, s, p)
320: Buffer *b;
321: char c;
322: short s;
323: Posn p;
324: {
325: uchar buf[1+2+sizeof p];
326: register uchar *a=buf;
327: if(p<0)
328: panic("puthdr_csP");
329: *a++=c;
330: *a++=s;
331: *a++=s>>8;
332: PUTPOSN(a, &p);
333: Binsert(b, ftempstr(buf, sizeof buf), b->nbytes);
334: }
335: puthdr_cs(b, c, s)
336: Buffer *b;
337: char c;
338: short s;
339: {
340: uchar buf[1+2];
341: register uchar *a=buf;
342: *a++=c;
343: *a++=s;
344: *a=s>>8;
345: Binsert(b, ftempstr(buf, sizeof buf), b->nbytes);
346: }
347: puthdr_M(b, p, dot, mk, m, s1)
348: Buffer *b;
349: Posn p;
350: Range dot;
351: Range mk;
352: Mod m;
353: short s1;
354: {
355: Mark mark;
356: static first=1;
357: if(!first && p<0)
358: panic("puthdr_M");
359: mark.p=p;
360: mark.dot=dot;
361: mark.mark=mk;
362: mark.m=m;
363: mark.s1=s1;
364: Binsert(b, ftempstr((uchar *)&mark, sizeof mark), b->nbytes);
365: }
366: puthdr_cPP(b, c, p1, p2)
367: Buffer *b;
368: char c;
369: Posn p1, p2;
370: {
371: uchar buf[1+2*sizeof p1];
372: register uchar *a=buf;
373: if(p1<0 || p2<0)
374: panic("puthdr_cPP");
375: *a++=c;
376: PUTPOSN(a, &p1);
377: PUTPOSN(a, &p2);
378: Binsert(b, ftempstr(buf, sizeof buf), b->nbytes);
379: }
380: Fchars(f, addr, p1, p2)
381: register File *f;
382: uchar *addr;
383: Posn p1, p2;
384: {
385: return Bread(f->buf, addr, (int)(p2-p1), p1);
386: }
387: Fgetcset(f, p)
388: File *f;
389: Posn p;
390: {
391: if(p<0 || p>f->nbytes)
392: panic("Fgetcset out of range");
393: if((f->ngetc=Fchars(f, f->getcbuf, p, p+NGETC))<0)
394: panic("Fgetcset Bread fail");
395: f->getcp=p;
396: f->getci=0;
397: return f->ngetc;
398: }
399: Fbgetcset(f, p)
400: File *f;
401: Posn p;
402: {
403: if(p<0 || p>f->nbytes)
404: panic("Fbgetcset out of range");
405: if((f->ngetc=Fchars(f, f->getcbuf, p<NGETC? (Posn)0 : p-NGETC, p))<0)
406: panic("Fbgetcset Bread fail");
407: f->getcp=p;
408: f->getci=f->ngetc;
409: return f->ngetc;
410: }
411: Fgetcload(f, p)
412: File *f;
413: Posn p;
414: {
415: if(Fgetcset(f, p)){
416: --f->ngetc;
417: f->getcp++;
418: return f->getcbuf[f->getci++];
419: }
420: return -1;
421: }
422: Fbgetcload(f, p)
423: File *f;
424: Posn p;
425: {
426: if(Fbgetcset(f, p)){
427: --f->getcp;
428: return f->getcbuf[--f->getci];
429: }
430: return -1;
431: }
432: static String *
433: ftempstr(s, n)
434: uchar *s;
435: {
436: static String p;
437: p.s=(uchar *)s;
438: p.n=n;
439: p.size=n;
440: return &p;
441: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.