![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to blk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to blk.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* blk.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
8: */
9:
10:
11: /* This file contains the functions that get/put blocks from the temp file.
12: * It also contains the "do" and "undo" functions.
13: */
14:
15: #include "config.h"
16: #include "vi.h"
17:
18: #ifndef NBUFS
19: # define NBUFS 5 /* must be at least 3 -- more is better */
20: #endif
21:
22:
23: /*------------------------------------------------------------------------*/
24:
25: BLK hdr; /* buffer for the header block */
26:
27: static int b4cnt; /* used to count context of beforedo/afterdo */
28: static struct _blkbuf
29: {
30: BLK buf; /* contents of a text block */
31: unsigned short logical; /* logical block number */
32: int dirty; /* must the buffer be rewritten? */
33: }
34: blk[NBUFS], /* buffers for text[?] blocks */
35: *toonew, /* buffer which shouldn't be recycled yet */
36: *newtoo, /* another buffer which should be recycled */
37: *recycle = blk; /* next block to be recycled */
38:
39:
40:
41: void blkflush P_((REG struct _blkbuf *this));
42:
43:
44:
45:
46: /* This function wipes out all buffers */
47: void blkinit()
48: {
49: int i;
50:
51: for (i = 0; i < NBUFS; i++)
52: {
53: blk[i].logical = 0;
54: blk[i].dirty = FALSE;
55: }
56: for (i = 0; i < MAXBLKS; i++)
57: {
58: hdr.n[i] = 0;
59: }
60: }
61:
62: /* This function allocates a buffer and fills it with a given block's text */
63: BLK *blkget(logical)
64: int logical; /* logical block number to fetch */
65: {
66: REG struct _blkbuf *this; /* used to step through blk[] */
67: REG int i;
68:
69: /* if logical is 0, just return the hdr buffer */
70: if (logical == 0)
71: {
72: return &hdr;
73: }
74:
75: /* see if we have that block in mem already */
76: for (this = blk; this < &blk[NBUFS]; this++)
77: {
78: if (this->logical == logical)
79: {
80: newtoo = toonew;
81: toonew = this;
82: return &this->buf;
83: }
84: }
85:
86: /* choose a block to be recycled */
87: do
88: {
89: this = recycle++;
90: if (recycle == &blk[NBUFS])
91: {
92: recycle = blk;
93: }
94: } while (this == toonew || this == newtoo);
95:
96: /* if it contains a block, flush that block */
97: blkflush(this);
98:
99: /* fill this buffer with the desired block */
100: this->logical = logical;
101: if (hdr.n[logical])
102: {
103: /* it has been used before - fill it from tmp file */
104: lseek(tmpfd, (long)hdr.n[logical] * (long)BLKSIZE, 0);
105: if (read(tmpfd, this->buf.c, (unsigned)BLKSIZE) != BLKSIZE)
106: {
107: msg("Error reading back from tmp file!");
108: }
109: }
110: else
111: {
112: /* it is new - zero it */
113: for (i = 0; i < BLKSIZE; i++)
114: {
115: this->buf.c[i] = 0;
116: }
117: }
118:
119: /* This isn't really a change, but it does potentially invalidate
120: * the kinds of shortcuts that the "changes" variable is supposed
121: * to protect us from... so count it as a change.
122: */
123: changes++;
124:
125: /* mark it as being "not dirty" */
126: this->dirty = 0;
127:
128: /* return it */
129: newtoo = toonew;
130: toonew = this;
131: return &this->buf;
132: }
133:
134:
135:
136: /* This function writes a block out to the temporary file */
137: void blkflush(this)
138: REG struct _blkbuf *this; /* the buffer to flush */
139: {
140: long seekpos; /* seek position of the new block */
141: unsigned short physical; /* physical block number */
142:
143: /* if its empty (an orphan blkadd() maybe?) then make it dirty */
144: if (this->logical && !*this->buf.c)
145: {
146: blkdirty(&this->buf);
147: }
148:
149: /* if it's an empty buffer or a clean version is on disk, quit */
150: if (!this->logical || hdr.n[this->logical] && !this->dirty)
151: {
152: return;
153: }
154:
155: /* find a free place in the file */
156: #ifndef NO_RECYCLE
157: seekpos = allocate();
158: lseek(tmpfd, seekpos, 0);
159: #else
160: seekpos = lseek(tmpfd, 0L, 2);
161: #endif
162: physical = seekpos / BLKSIZE;
163:
164: /* put the block there */
165: if (write(tmpfd, this->buf.c, (unsigned)BLKSIZE) != BLKSIZE)
166: {
167: msg("Trouble writing to tmp file");
168: }
169: this->dirty = FALSE;
170:
171: /* update the header so it knows we put it there */
172: hdr.n[this->logical] = physical;
173: }
174:
175:
176: /* This function sets a block's "dirty" flag or deletes empty blocks */
177: void blkdirty(bp)
178: BLK *bp; /* buffer returned by blkget() */
179: {
180: REG int i, j;
181: REG char *scan;
182: REG int k;
183:
184: /* find the buffer */
185: for (i = 0; i < NBUFS && bp != &blk[i].buf; i++)
186: {
187: }
188: #ifdef DEBUG
189: if (i >= NBUFS)
190: {
191: msg("blkdirty() called with unknown buffer at 0x%lx", bp);
192: return;
193: }
194: if (blk[i].logical == 0)
195: {
196: msg("blkdirty called with freed buffer");
197: return;
198: }
199: #endif
200:
201: /* if this block ends with line# INFINITY, then it must have been
202: * allocated unnecessarily during tmpstart(). Forget it.
203: */
204: if (lnum[blk[i].logical] == INFINITY)
205: {
206: #ifdef DEBUG
207: if (blk[i].buf.c[0])
208: {
209: msg("bkldirty called with non-empty extra BLK");
210: }
211: #endif
212: blk[i].logical = 0;
213: blk[i].dirty = FALSE;
214: return;
215: }
216:
217: /* count lines in this block */
218: for (j = 0, scan = bp->c; *scan && scan < bp->c + BLKSIZE; scan++)
219: {
220: if (*scan == '\n')
221: {
222: j++;
223: }
224: }
225:
226: /* adjust lnum, if necessary */
227: k = blk[i].logical;
228: j += (lnum[k - 1] - lnum[k]);
229: if (j != 0)
230: {
231: nlines += j;
232: while (k < MAXBLKS && lnum[k] != INFINITY)
233: {
234: lnum[k++] += j;
235: }
236: }
237:
238: /* if it still has text, mark it as dirty */
239: if (*bp->c)
240: {
241: blk[i].dirty = TRUE;
242: }
243: else /* empty block, so delete it */
244: {
245: /* adjust the cache */
246: k = blk[i].logical;
247: for (j = 0; j < NBUFS; j++)
248: {
249: if (blk[j].logical >= k)
250: {
251: blk[j].logical--;
252: }
253: }
254:
255: /* delete it from hdr.n[] and lnum[] */
256: blk[i].logical = 0;
257: blk[i].dirty = FALSE;
258: while (k < MAXBLKS - 1)
259: {
260: hdr.n[k] = hdr.n[k + 1];
261: lnum[k] = lnum[k + 1];
262: k++;
263: }
264: hdr.n[MAXBLKS - 1] = 0;
265: lnum[MAXBLKS - 1] = INFINITY;
266: }
267: }
268:
269:
270: /* insert a new block into hdr, and adjust the cache */
271: BLK *blkadd(logical)
272: int logical; /* where to insert the new block */
273: {
274: REG int i;
275:
276: /* adjust hdr and lnum[] */
277: for (i = MAXBLKS - 1; i > logical; i--)
278: {
279: hdr.n[i] = hdr.n[i - 1];
280: lnum[i] = lnum[i - 1];
281: }
282: hdr.n[logical] = 0;
283: lnum[logical] = lnum[logical - 1];
284:
285: /* adjust the cache */
286: for (i = 0; i < NBUFS; i++)
287: {
288: if (blk[i].logical >= logical)
289: {
290: blk[i].logical++;
291: }
292: }
293:
294: /* return the new block, via blkget() */
295: return blkget(logical);
296: }
297:
298:
299: /* This function forces all dirty blocks out to disk */
300: void blksync()
301: {
302: int i;
303:
304: for (i = 0; i < NBUFS; i++)
305: {
306: /* blk[i].dirty = TRUE; */
307: blkflush(&blk[i]);
308: }
309: if (*o_sync)
310: {
311: sync();
312: }
313: }
314:
315: /*------------------------------------------------------------------------*/
316:
317: static MARK undocurs; /* where the cursor should go if undone */
318: static long oldnlines;
319: static long oldlnum[MAXBLKS];
320:
321:
322: /* This function should be called before each command that changes the text.
323: * It defines the state that undo() will reset the file to.
324: */
325: void beforedo(forundo)
326: int forundo; /* boolean: is this for an undo? */
327: {
328: REG int i;
329: REG long l;
330:
331: /* if this is a nested call to beforedo, quit! Use larger context */
332: if (b4cnt++ > 0)
333: {
334: return;
335: }
336:
337: /* force all block buffers to disk */
338: blksync();
339:
340: #ifndef NO_RECYCLE
341: /* perform garbage collection on blocks from tmp file */
342: garbage();
343: #endif
344:
345: /* force the header out to disk */
346: lseek(tmpfd, 0L, 0);
347: if (write(tmpfd, hdr.c, (unsigned)BLKSIZE) != BLKSIZE)
348: {
349: msg("Trouble writing header to tmp file ");
350: }
351:
352: /* copy or swap oldnlines <--> nlines, oldlnum <--> lnum */
353: if (forundo)
354: {
355: for (i = 0; i < MAXBLKS; i++)
356: {
357: l = lnum[i];
358: lnum[i] = oldlnum[i];
359: oldlnum[i] = l;
360: }
361: l = nlines;
362: nlines = oldnlines;
363: oldnlines = l;
364: }
365: else
366: {
367: for (i = 0; i < MAXBLKS; i++)
368: {
369: oldlnum[i] = lnum[i];
370: }
371: oldnlines = nlines;
372: }
373:
374: /* save the cursor position */
375: undocurs = cursor;
376:
377: /* upon return, the calling function continues and makes changes... */
378: }
379:
380: /* This function marks the end of a (nested?) change to the file */
381: void afterdo()
382: {
383: if (--b4cnt)
384: {
385: /* after abortdo(), b4cnt may decribe nested beforedo/afterdo
386: * pairs incorrectly. If it is decremented to often, then
387: * keep b4cnt sane but don't do anything else.
388: */
389: if (b4cnt < 0)
390: b4cnt = 0;
391:
392: return;
393: }
394:
395: /* make sure the cursor wasn't left stranded in deleted text */
396: if (markline(cursor) > nlines)
397: {
398: cursor = MARK_LAST;
399: }
400: /* NOTE: it is still possible that markidx(cursor) is after the
401: * end of a line, so the Vi mode will have to take care of that
402: * itself */
403:
404: /* if a significant change has been made to this file, then set the
405: * MODIFIED flag.
406: */
407: if (significant)
408: {
409: setflag(file, MODIFIED);
410: setflag(file, UNDOABLE);
411: }
412: }
413:
414: /* This function cuts short the current set of changes. It is called after
415: * a SIGINT.
416: */
417: void abortdo()
418: {
419: /* finish the operation immediately. */
420: if (b4cnt > 0)
421: {
422: b4cnt = 1;
423: afterdo();
424: }
425:
426: /* in visual mode, the screen is probably screwed up */
427: if (mode == MODE_COLON)
428: {
429: mode = MODE_VI;
430: }
431: if (mode == MODE_VI)
432: {
433: redraw(MARK_UNSET, FALSE);
434: }
435: }
436:
437: /* This function discards all changes made since the last call to beforedo() */
438: int undo()
439: {
440: BLK oldhdr;
441:
442: /* if beforedo() has never been run, fail */
443: if (!tstflag(file, UNDOABLE))
444: {
445: msg("You haven't modified this file yet.");
446: return FALSE;
447: }
448:
449: /* read the old header form the tmp file */
450: lseek(tmpfd, 0L, 0);
451: if (read(tmpfd, oldhdr.c, (unsigned)BLKSIZE) != BLKSIZE)
452: {
453: msg("Trouble rereading the old header from tmp file");
454: }
455:
456: /* "do" the changed version, so we can undo the "undo" */
457: cursor = undocurs;
458: beforedo(TRUE);
459: afterdo();
460:
461: /* wipe out the block buffers - we can't assume they're correct */
462: blkinit();
463:
464: /* use the old header -- and therefore the old text blocks */
465: hdr = oldhdr;
466:
467: /* This is a change */
468: significant = TRUE;
469: changes++;
470:
471: return TRUE;
472: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.