![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to modify.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 modify.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* modify.c */
2:
3: /* This file contains the low-level file modification functions:
4: * delete(frommark, tomark) - removes line or portions of lines
5: * add(frommark, text) - inserts new text
6: * change(frommark, tomark, text) - delete, then add
7: */
8:
9: #include "config.h"
10: #include "vi.h"
11:
12: #ifdef DEBUG2
13: # include <stdio.h>
14: static FILE *dbg;
15:
16: /*VARARGS1*/
17: debout(msg, arg1, arg2, arg3, arg4, arg5)
18: char *msg, *arg1, *arg2, *arg3, *arg4, *arg5;
19: {
20: if (!dbg)
21: {
22: dbg = fopen("debug.out", "w");
23: if (!dbg)
24: return;
25: setbuf(dbg, (FILE *)0);
26: }
27: fprintf(dbg, msg, arg1, arg2, arg3, arg4, arg5);
28: }
29: #endif /* DEBUG2 */
30:
31: /* delete a range of text from the file */
32: void delete(frommark, tomark)
33: MARK frommark; /* first char to be deleted */
34: MARK tomark; /* AFTER last char to be deleted */
35: {
36: int i; /* used to move thru logical blocks */
37: REG char *scan; /* used to scan thru text of the blk */
38: REG char *cpy; /* used when copying chars */
39: BLK *blk; /* a text block */
40: long l; /* a line number */
41: MARK m; /* a traveling version of frommark */
42:
43: #ifdef DEBUG2
44: debout("delete(%ld.%d, %ld.%d)\n", markline(frommark), markidx(frommark), markline(tomark), markidx(tomark));
45: #endif
46:
47: /* if not deleting anything, quit now */
48: if (frommark == tomark)
49: {
50: return;
51: }
52:
53: /* This is a change */
54: changes++;
55: significant = TRUE;
56:
57: /* supply clues to the redraw module */
58: redrawrange(markline(frommark), markline(tomark), markline(frommark));
59:
60: /* adjust marks 'a through 'z and '' as needed */
61: l = markline(tomark);
62: for (i = 0; i < NMARKS; i++)
63: {
64: if (mark[i] < frommark)
65: {
66: continue;
67: }
68: else if (mark[i] < tomark)
69: {
70: mark[i] = MARK_UNSET;
71: }
72: else if (markline(mark[i]) == l)
73: {
74: if (markline(frommark) == l)
75: {
76: mark[i] -= markidx(tomark) - markidx(frommark);
77: }
78: else
79: {
80: mark[i] -= markidx(tomark);
81: }
82: }
83: else
84: {
85: mark[i] -= MARK_AT_LINE(l - markline(frommark));
86: }
87: }
88:
89: /* Reporting... */
90: if (markidx(frommark) == 0 && markidx(tomark) == 0)
91: {
92: rptlines = markline(tomark) - markline(frommark);
93: rptlabel = "deleted";
94: }
95:
96: /* find the block containing frommark */
97: l = markline(frommark);
98: for (i = 1; lnum[i] < l; i++)
99: {
100: }
101:
102: /* process each affected block... */
103: for (m = frommark;
104: m < tomark && lnum[i] < INFINITY;
105: m = MARK_AT_LINE(lnum[i - 1] + 1))
106: {
107: /* fetch the block */
108: blk = blkget(i);
109:
110: /* find the mark in the block */
111: scan = blk->c;
112: for (l = markline(m) - lnum[i - 1] - 1; l > 0; l--)
113: {
114: while (*scan++ != '\n')
115: {
116: }
117: }
118: scan += markidx(m);
119:
120: /* figure out where the changes to this block end */
121: if (markline(tomark) > lnum[i])
122: {
123: cpy = blk->c + BLKSIZE;
124: }
125: else if (markline(tomark) == markline(m))
126: {
127: cpy = scan - markidx(m) + markidx(tomark);
128: }
129: else
130: {
131: cpy = scan;
132: for (l = markline(tomark) - markline(m);
133: l > 0;
134: l--)
135: {
136: while (*cpy++ != '\n')
137: {
138: }
139: }
140: cpy += markidx(tomark);
141: }
142:
143: /* delete the stuff by moving chars within this block */
144: while (cpy < blk->c + BLKSIZE)
145: {
146: *scan++ = *cpy++;
147: }
148: while (scan < blk->c + BLKSIZE)
149: {
150: *scan++ = '\0';
151: }
152:
153: /* adjust tomark to allow for lines deleted from this block */
154: tomark -= MARK_AT_LINE(lnum[i] + 1 - markline(m));
155:
156: /* if this block isn't empty now, then advance i */
157: if (*blk->c)
158: {
159: i++;
160: }
161:
162: /* the buffer has changed. Update hdr and lnum. */
163: blkdirty(blk);
164: }
165:
166: /* must have at least 1 line */
167: if (nlines == 0)
168: {
169: blk = blkadd(1);
170: blk->c[0] = '\n';
171: blkdirty(blk);
172: cursor = MARK_FIRST;
173: }
174: }
175:
176:
177: /* add some text at a specific place in the file */
178: void add(atmark, newtext)
179: MARK atmark; /* where to insert the new text */
180: char *newtext; /* NUL-terminated string to insert */
181: {
182: REG char *scan; /* used to move through string */
183: REG char *build; /* used while copying chars */
184: int addlines; /* number of lines we're adding */
185: int lastpart; /* size of last partial line */
186: BLK *blk; /* the block to be modified */
187: int blkno; /* the logical block# of (*blk) */
188: REG char *newptr; /* where new text starts in blk */
189: BLK buf; /* holds chars from orig blk */
190: BLK linebuf; /* holds part of line that didn't fit */
191: BLK *following; /* the BLK following the last BLK */
192: int i;
193: long l;
194:
195: #ifdef DEBUG2
196: debout("add(%ld.%d, \"%s\")\n", markline(atmark), markidx(atmark), newtext);
197: #endif
198: #ifdef lint
199: buf.c[0] = 0;
200: #endif
201: /* if not adding anything, return now */
202: if (!*newtext)
203: {
204: return;
205: }
206:
207: /* This is a change */
208: changes++;
209: significant = TRUE;
210:
211: /* count the number of lines in the new text */
212: for (scan = newtext, lastpart = addlines = 0; *scan; )
213: {
214: if (*scan++ == '\n')
215: {
216: addlines++;
217: lastpart = 0;
218: }
219: else
220: {
221: lastpart++;
222: }
223: }
224:
225: /* Reporting... */
226: if (lastpart == 0 && markidx(atmark) == 0)
227: {
228: rptlines = addlines;
229: rptlabel = "added";
230: }
231:
232: /* extract the line# from atmark */
233: l = markline(atmark);
234:
235: /* supply clues to the redraw module */
236: if ((markidx(atmark) == 0 && lastpart == 0) || addlines == 0)
237: {
238: redrawrange(l, l, l + addlines);
239: }
240: else
241: {
242: /* make sure the last line gets redrawn -- it was
243: * split, so its appearance has changed
244: */
245: redrawrange(l, l + 1L, l + addlines + 1L);
246: }
247:
248: /* adjust marks 'a through 'z and '' as needed */
249: for (i = 0; i < NMARKS; i++)
250: {
251: if (mark[i] < atmark)
252: {
253: /* earlier line, or earlier in same line: no change */
254: continue;
255: }
256: else if (markline(mark[i]) > l)
257: {
258: /* later line: move down a whole number of lines */
259: mark[i] += MARK_AT_LINE(addlines);
260: }
261: else
262: {
263: /* later in same line */
264: if (addlines > 0)
265: {
266: /* multi-line add, which split this line:
267: * move down, and possibly left or right,
268: * depending on where the split was and how
269: * much text was inserted after the last \n
270: */
271: mark[i] += MARK_AT_LINE(addlines) + lastpart - markidx(atmark);
272: }
273: else
274: {
275: /* totally within this line: move right */
276: mark[i] += lastpart;
277: }
278: }
279: }
280:
281: /* get the block to be modified */
282: for (blkno = 1; lnum[blkno] < l && lnum[blkno + 1] < INFINITY; blkno++)
283: {
284: }
285: blk = blkget(blkno);
286: buf = *blk;
287:
288: /* figure out where the new text starts */
289: for (newptr = buf.c, l = markline(atmark) - lnum[blkno - 1] - 1;
290: l > 0;
291: l--)
292: {
293: while (*newptr++ != '\n')
294: {
295: }
296: }
297: newptr += markidx(atmark);
298:
299: /* keep start of old block */
300: build = blk->c + (int)(newptr - buf.c);
301:
302: /* fill this block (or blocks) from the newtext string */
303: while (*newtext)
304: {
305: while (*newtext && build < blk->c + BLKSIZE - 1)
306: {
307: *build++ = *newtext++;
308: }
309: if (*newtext)
310: {
311: /* save the excess */
312: for (scan = linebuf.c + BLKSIZE;
313: build > blk->c && build[-1] != '\n';
314: )
315: {
316: *--scan = *--build;
317: }
318:
319: /* write the block */
320: while (build < blk->c + BLKSIZE)
321: {
322: *build++ = '\0';
323: }
324: blkdirty(blk);
325:
326: /* add another block */
327: blkno++;
328: blk = blkadd(blkno);
329:
330: /* copy in the excess from last time */
331: for (build = blk->c; scan < linebuf.c + BLKSIZE; )
332: {
333: *build++ = *scan++;
334: }
335: }
336: }
337:
338: /* fill this block(s) from remainder of orig block */
339: while (newptr < buf.c + BLKSIZE && *newptr)
340: {
341: while (newptr < buf.c + BLKSIZE
342: && *newptr
343: && build < blk->c + BLKSIZE - 1)
344: {
345: *build++ = *newptr++;
346: }
347: if (newptr < buf.c + BLKSIZE && *newptr)
348: {
349: /* save the excess */
350: for (scan = linebuf.c + BLKSIZE;
351: build > blk->c && build[-1] != '\n';
352: )
353: {
354: *--scan = *--build;
355: }
356:
357: /* write the block */
358: while (build < blk->c + BLKSIZE)
359: {
360: *build++ = '\0';
361: }
362: blkdirty(blk);
363:
364: /* add another block */
365: blkno++;
366: blk = blkadd(blkno);
367:
368: /* copy in the excess from last time */
369: for (build = blk->c; scan < linebuf.c + BLKSIZE; )
370: {
371: *build++ = *scan++;
372: }
373: }
374: }
375:
376: /* see if we can combine our last block with the following block */
377: if (lnum[blkno] < nlines && lnum[blkno + 1] - lnum[blkno] < (BLKSIZE >> 6))
378: {
379: /* hey, we probably can! Get the following block & see... */
380: following = blkget(blkno + 1);
381: if (strlen(following->c) + (build - blk->c) < BLKSIZE - 1)
382: {
383: /* we can! Copy text from following to blk */
384: for (scan = following->c; *scan; )
385: {
386: *build++ = *scan++;
387: }
388: while (build < blk->c + BLKSIZE)
389: {
390: *build++ = '\0';
391: }
392: blkdirty(blk);
393:
394: /* pretend the following was the last blk */
395: blk = following;
396: build = blk->c;
397: }
398: }
399:
400: /* that last block is dirty by now */
401: while (build < blk->c + BLKSIZE)
402: {
403: *build++ = '\0';
404: }
405: blkdirty(blk);
406: }
407:
408:
409: /* change the text of a file */
410: void change(frommark, tomark, newtext)
411: MARK frommark, tomark;
412: char *newtext;
413: {
414: int i;
415: long l;
416: char *text;
417: BLK *blk;
418:
419: #ifdef DEBUG2
420: debout("change(%ld.%d, %ld.%d, \"%s\")\n", markline(frommark), markidx(frommark), markline(tomark), markidx(tomark), newtext);
421: #endif
422:
423: /* optimize for single-character replacement */
424: if (frommark + 1 == tomark && newtext[0] && !newtext[1] && newtext[0] != '\n')
425: {
426: /* find the block containing frommark */
427: l = markline(frommark);
428: for (i = 1; lnum[i] < l; i++)
429: {
430: }
431:
432: /* get the block */
433: blk = blkget(i);
434:
435: /* find the line within the block */
436: for (text = blk->c, i = l - lnum[i - 1] - 1; i > 0; text++)
437: {
438: if (*text == '\n')
439: {
440: i--;
441: }
442: }
443:
444: /* replace the char */
445: text += markidx(frommark);
446: if (*text == newtext[0])
447: {
448: /* no change was needed - same char */
449: return;
450: }
451: else if (*text != '\n')
452: {
453: /* This is a change */
454: changes++;
455: significant = TRUE;
456: ChangeText
457: {
458: *text = newtext[0];
459: blkdirty(blk);
460: }
461: redrawrange(markline(frommark), markline(tomark), markline(frommark));
462: return;
463: }
464: /* else it is a complex change involving newline... */
465: }
466:
467: /* couldn't optimize, so do delete & add */
468: ChangeText
469: {
470: delete(frommark, tomark);
471: add(frommark, newtext);
472: rptlabel = "changed";
473: }
474: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.