![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to undo.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to undo.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* Support routines for the undo facility.
2: Copyright (C) 1985, 1986 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU Emacs General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU Emacs, but only under the conditions described in the
15: GNU Emacs General Public License. A copy of this license is
16: supposed to have been given to you along with GNU Emacs so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: #include "config.h"
23: #include "lisp.h"
24: #include "undo.h"
25: #include "commands.h"
26: #include "buffer.h"
27:
28: /* Access undo records of current buffer */
29: /* These assume that `u' points to the buffer's undodata */
30: #define UndoRQ (u->undorecs)
31: #define UndoCQ (u->undochars)
32: #define FillRQ (u->nextrec)
33: #define FillCQ (u->nextchar)
34:
35: /* Record last undo record made, and what buffer made in */
36: static struct UndoRec *LastUndoRec;
37: static struct buffer *LastUndoBuf;
38:
39: /* Record progress of undoing */
40: static int NUndone;
41: static int NCharsLeft;
42: static int LastUndoneC;
43: static int LastUndone;
44: static struct buffer *LastUndoneBuf;
45:
46: Lisp_Object Fundo_boundary ();
47:
48: make_undo_records (b)
49: struct buffer *b;
50: {
51: register struct UndoData *u;
52: b->undodata = u = (struct UndoData *) xmalloc (sizeof (struct UndoData));
53: u->undorecs
54: = (struct UndoRec *) xmalloc (sizeof (struct UndoRec) * InitNUndoR);
55: u->undochars = (char *) xmalloc (InitNUndoC);
56: u->undorecs[InitNUndoR - 1].kind = Unundoable;
57: u->nextrec = 0;
58: u->nextchar = 0;
59: u->num_undorecs = InitNUndoR;
60: u->num_undochars = InitNUndoC;
61: }
62:
63: free_undo_records (b)
64: struct buffer *b;
65: {
66: register struct UndoData *u = b->undodata;
67: free (u->undorecs);
68: free (u->undochars);
69: free (u);
70: }
71:
72: struct UndoRec *
73: record_undo (kind, pos, len)
74: enum Ukinds kind;
75: {
76: register struct UndoData *u = bf_cur->undodata;
77: register struct UndoRec *p = &UndoRQ[FillRQ];
78: register struct UndoRec *np;
79:
80: FillRQ++;
81: if (FillRQ >= NUndoR)
82: FillRQ = 0;
83: else if (FillRQ >= u->num_undorecs)
84: {
85: np = (struct UndoRec *) xrealloc (UndoRQ, NUndoR * sizeof *p);
86: if (np)
87: {
88: UndoRQ = np;
89: p = &UndoRQ[FillRQ-1];
90: u->num_undorecs = NUndoR;
91: np[NUndoR - 1].kind = Unundoable;
92: }
93: else
94: FillRQ = 0;
95: }
96: UndoRQ[FillRQ].kind = Unundoable;
97: p -> kind = kind;
98: p -> pos = pos;
99: p -> len = len;
100: LastUndoRec = p;
101: LastUndoBuf = bf_cur;
102: if (kind != Uboundary)
103: LastUndone = -1;
104: return p;
105: }
106:
107: record_insert (pos, n)
108: {
109: register struct UndoRec *p = LastUndoRec;
110: if (!bf_cur->undodata)
111: return;
112: if (LastUndoBuf != bf_cur)
113: {
114: Fundo_boundary ();
115: p = 0;
116: }
117:
118: if (bf_modified <= bf_cur->save_modified)
119: record_undo (Uunmod, pos, bf_cur->modtime);
120:
121: if (p && p -> kind == Udelete && p -> pos + p -> len == pos)
122: p -> len += n;
123: else
124: record_undo (Udelete, pos, n);
125: }
126:
127: record_delete (pos, n)
128: int pos, n;
129: {
130: register struct UndoRec *p = LastUndoRec;
131:
132: if (!bf_cur->undodata)
133: return;
134: if (LastUndoBuf != bf_cur)
135: {
136: Fundo_boundary ();
137: p = 0;
138: }
139:
140: if (bf_modified <= bf_cur->save_modified)
141: record_undo (Uunmod, pos, bf_cur->modtime);
142:
143: if (p && p->kind == Uinsert && p->pos == pos && p->len > 0)
144: p->len += n;
145: else if (point == pos + n)
146: record_undo (Uinsert, pos + n, - n);
147: else
148: record_undo (Uinsert, pos, n);
149:
150: record_chars (pos, n);
151: }
152:
153: record_chars (pos, n)
154: register int pos, n;
155: {
156: if (pos < bf_s1 + 1 && pos + n > bf_s1 + 1)
157: {
158: record_block (&CharAt (pos), bf_s1 + 1 - pos);
159: n -= bf_s1 + 1 - pos;
160: pos = bf_s1 + 1;
161: }
162:
163: record_block (&CharAt (pos), n);
164: }
165:
166: record_block (p, n)
167: register char *p;
168: register int n;
169: {
170: register char *cp;
171: register struct UndoData *u = bf_cur->undodata;
172: register int i;
173:
174: NCharsLeft -= n;
175: cp = &UndoCQ[FillCQ];
176:
177: while (n > 0)
178: {
179: i = u->num_undochars - FillCQ;
180: if (i > n) i = n;
181: if (i > 0)
182: {
183: bcopy (p, cp, i);
184: p += i;
185: FillCQ += i;
186: n -= i;
187: }
188:
189: if (n == 0)
190: break;
191:
192: if (FillCQ >= NUndoC)
193: {
194: FillCQ = 0;
195: cp = UndoCQ;
196: }
197: else
198: {
199: cp = (char *) xrealloc (UndoCQ, NUndoC);
200: UndoCQ = cp;
201: cp += FillCQ;
202: NCharsLeft += NUndoC - u->num_undochars;
203: u->num_undochars = NUndoC;
204: }
205: }
206: }
207:
208: record_change (pos, n)
209: int pos, n;
210: {
211: register struct UndoRec *p = LastUndoRec;
212: if (!bf_cur->undodata)
213: return;
214: if (LastUndoBuf != bf_cur)
215: {
216: Fundo_boundary ();
217: p = 0;
218: }
219:
220: if (bf_modified <= bf_cur->save_modified)
221: record_undo (Uunmod, pos, bf_cur->modtime);
222:
223: if (p && p->kind == Uchange && p->len > 0 && p->pos + p->len == pos)
224: p->len += n;
225: else if (point == pos + n)
226: record_undo (Uchange, pos + n, -n);
227: else
228: record_undo (Uchange, pos, n);
229:
230: record_chars (pos, n);
231: }
232:
233: record_change1 (pos, bufp, n)
234: int pos;
235: char *bufp;
236: int n;
237: {
238: register struct UndoRec *p = LastUndoRec;
239: if (!bf_cur->undodata)
240: return;
241: if (LastUndoBuf != bf_cur)
242: {
243: Fundo_boundary ();
244: p = 0;
245: }
246: if (p && p->kind == Uchange && p->len > 0 && p->pos + p->len == pos)
247: p -> len += n;
248: else
249: record_undo (Uchange, pos, n);
250:
251: record_block (bufp, n);
252: }
253:
254: DoneIsDone ()
255: {
256: register struct UndoData *u = bf_cur->undodata;
257: register struct UndoRec *p;
258:
259: if (!u)
260: return 0;
261:
262: p = &UndoRQ[(FillRQ + u->num_undorecs - 1) % u->num_undorecs];
263: if (p->kind != Unundoable)
264: record_undo (Unundoable, point, 0);
265: return 0;
266: }
267:
268: DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
269: "Mark a boundary between units of undo.\n\
270: An undo command will stop at this point,\n\
271: but another undo command will undo to the previous boundary.")
272: ()
273: {
274: register struct UndoData *u = bf_cur->undodata;
275: register struct UndoRec *p;
276:
277: if (!u)
278: return Qnil;
279:
280: p = &UndoRQ[(FillRQ + u->num_undorecs - 1) % u->num_undorecs];
281: if (p->kind != Uboundary)
282: record_undo (Uboundary, point, 0);
283: return Qnil;
284: }
285:
286: DEFUN ("undo-more", Fundo_more, Sundo_more, 1, 1, 0,
287: "Undo back N undo-boundaries beyond what was already undone recently.\n\
288: Call undo-start to get ready to undo recent changes,\n\
289: then call undo-more one or more times to undo them.")
290: (pfxarg)
291: Lisp_Object pfxarg;
292: {
293: register struct UndoData *u = bf_cur->undodata;
294: register int n = 0;
295: register int chars;
296: register int i = LastUndone;
297: register int arg = XINT (pfxarg);
298: register int len, pos;
299: char tembuf[NUndoC];
300:
301: if (!u)
302: return Qnil;
303:
304: if (LastUndoneBuf != bf_cur ||
305: i == -1)
306: error ("Cannot undo more: changes have been made since the last undo");
307:
308: while (1)
309: {
310: while (UndoRQ[i = (!i ? u->num_undorecs-1 : i-1)].kind != Uboundary)
311: {
312: len = UndoRQ[i].len;
313: if (len < 0) len = - len;
314: if (((UndoRQ[i].kind == Uinsert || UndoRQ[i].kind == Uchange)
315: && (NCharsLeft -= len) < 0)
316: || UndoRQ[i].kind == Unundoable || NUndone >= u->num_undorecs)
317: error ("No further undo information available");
318: NUndone++;
319: n++;
320: }
321: NUndone++;
322: n++;
323: if (--arg <= 0)
324: break;
325: }
326:
327: i = LastUndone;
328: chars = LastUndoneC;
329: while (--n >= 0)
330: {
331: if (!i)
332: i = u->num_undorecs;
333: i--;
334:
335: len = UndoRQ[i].len;
336: pos = UndoRQ[i].pos;
337:
338: if (UndoRQ[i].kind == Uchange || UndoRQ[i].kind == Uinsert)
339: if (len < 0)
340: {
341: pos += len;
342: len = - len;
343: }
344:
345: #ifdef SWITCH_ENUM_BUG
346: switch ((int) UndoRQ[i].kind)
347: #else
348: switch (UndoRQ[i].kind)
349: #endif
350: {
351: case Uchange:
352: case Udelete:
353: if (pos < FirstCharacter || pos + len > NumCharacters + 1)
354: error ("Changes to be undone are outside visible portion of buffer");
355: SetPoint (pos);
356: break;
357:
358: case Uinsert:
359: if (pos < FirstCharacter || pos > NumCharacters + 1)
360: error ("Changes to be undone are outside visible portion of buffer");
361: SetPoint (pos);
362: }
363:
364: #ifdef SWITCH_ENUM_BUG
365: switch ((int) UndoRQ[i].kind)
366: #else
367: switch (UndoRQ[i].kind)
368: #endif
369: {
370: case Uboundary:
371: break;
372:
373: case Udelete:
374: del_range (point, point + len);
375: break;
376:
377: case Uchange:
378: if (len > NUndoC)
379: /* Should have already said "No more undo info available" */
380: abort ();
381: save_undone_chars (pos, len, tembuf);
382: chars -= len;
383: if (chars < 0)
384: {
385: replace_chars (point - chars, len + chars, UndoCQ);
386: replace_chars (point, - chars, UndoCQ + chars + u->num_undochars);
387: chars += u->num_undochars;
388: }
389: else
390: replace_chars (point, len, UndoCQ + chars);
391: record_change1 (point, tembuf, len);
392: SetPoint (UndoRQ[i].pos);
393: break;
394:
395: case Uinsert:
396: chars -= len;
397: if (chars < 0)
398: {
399: InsCStr (UndoCQ + chars + u->num_undochars, - chars);
400: InsCStr (UndoCQ, len + chars);
401: chars += u->num_undochars;
402: }
403: else
404: InsCStr (UndoCQ + chars, len);
405: SetPoint (UndoRQ[i].pos);
406: break;
407:
408: case Uunmod:
409: /* If this Uunmod records an obsolete save
410: (not matching the actual disk file)
411: then don't mark unmodified. */
412: if (len != bf_cur->modtime)
413: break;
414: #ifdef CLASH_DETECTION
415: Funlock_buffer ();
416: #endif /* CLASH_DETECTION */
417: bf_cur->save_modified = bf_modified;
418: RedoModes++;
419: break;
420:
421: default:
422: error ("Changes to great to be undone");
423: return Qnil;
424: }
425: }
426: LastUndone = i;
427: LastUndoneC = chars;
428: return Qnil;
429: }
430:
431: replace_chars (pos, n, string)
432: register int pos, n;
433: register unsigned char *string;
434: {
435: modify_region (pos, pos + n);
436: while (--n >= 0)
437: {
438: CharAt (pos) = *string++;
439: pos++;
440: }
441: }
442:
443: save_undone_chars (pos, n, p)
444: register int pos, n;
445: register char *p;
446: {
447: if (pos < bf_s1 + 1 && pos + n > bf_s1 + 1)
448: {
449: bcopy (&CharAt (pos), p, bf_s1 + 1 - pos);
450: p += bf_s1 + 1 - pos;
451: n -= bf_s1 + 1 - pos;
452: pos = bf_s1 + 1;
453: }
454:
455: bcopy (&CharAt (pos), p, n);
456: }
457:
458: DEFUN ("undo-start", Fundo_start, Sundo_start, 0, 0, 0,
459: "Move undo-pointer to front of undo records.\n\
460: The next call to undo-more will undo the most recently made change.")
461: ()
462: {
463: register struct UndoData *u = bf_cur->undodata;
464:
465: if (!u)
466: error ("Undo information not kept for this buffer");
467: LastUndoneBuf = bf_cur;
468: NCharsLeft = u->num_undochars;
469: NUndone = 0;
470: LastUndone = FillRQ;
471: LastUndoneC = FillCQ;
472: return Qnil;
473: }
474:
475: syms_of_undo ()
476: {
477: defsubr (&Sundo_start);
478: defsubr (&Sundo_boundary);
479: defsubr (&Sundo_more);
480: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.