![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to insdel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to insdel.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* Buffer insertion/deletion and gap motion for GNU Emacs.
2: Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GNU Emacs is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Emacs; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include "config.h"
22: #include "lisp.h"
23: #include "buffer.h"
24: #include "window.h"
25:
26: /* Move gap to position `pos'.
27: Note that this can quit! */
28:
29: move_gap (pos)
30: int pos;
31: {
32: if (pos < GPT)
33: gap_left (pos, 0);
34: else if (pos > GPT)
35: gap_right (pos);
36: }
37:
38: /* Move the gap to POS, which is less than the current GPT.
39: If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
40:
41: gap_left (pos, newgap)
42: register int pos;
43: int newgap;
44: {
45: register unsigned char *to, *from;
46: register int i;
47: int new_s1;
48:
49: pos--;
50:
51: if (!newgap)
52: {
53: if (unchanged_modified == MODIFF)
54: {
55: beg_unchanged = pos;
56: end_unchanged = Z - pos - 1;
57: }
58: else
59: {
60: if (Z - GPT < end_unchanged)
61: end_unchanged = Z - GPT;
62: if (pos < beg_unchanged)
63: beg_unchanged = pos;
64: }
65: }
66:
67: i = GPT;
68: to = GAP_END_ADDR;
69: from = GPT_ADDR;
70: new_s1 = GPT - BEG;
71:
72: /* Now copy the characters. To move the gap down,
73: copy characters up. */
74:
75: while (1)
76: {
77: /* I gets number of characters left to copy. */
78: i = new_s1 - pos;
79: if (i == 0)
80: break;
81: /* If a quit is requested, stop copying now.
82: Change POS to be where we have actually moved the gap to. */
83: if (QUITP)
84: {
85: pos = new_s1;
86: break;
87: }
88: /* Move at most 32000 chars before checking again for a quit. */
89: if (i > 32000)
90: i = 32000;
91: new_s1 -= i;
92: while (--i >= 0)
93: *--to = *--from;
94: }
95:
96: /* Adjust markers, and buffer data structure, to put the gap at POS.
97: POS is where the loop above stopped, which may be what was specified
98: or may be where a quit was detected. */
99: adjust_markers (pos + 1, GPT, GAP_SIZE);
100: GPT = pos + 1;
101: QUIT;
102: }
103:
104: gap_right (pos)
105: register int pos;
106: {
107: register unsigned char *to, *from;
108: register int i;
109: int new_s1;
110:
111: pos--;
112:
113: if (unchanged_modified == MODIFF)
114: {
115: beg_unchanged = pos;
116: end_unchanged = Z - pos - 1;
117: }
118: else
119: {
120: if (Z - pos - 1 < end_unchanged)
121: end_unchanged = Z - pos - 1;
122: if (GPT - BEG < beg_unchanged)
123: beg_unchanged = GPT - BEG;
124: }
125:
126: i = GPT;
127: from = GAP_END_ADDR;
128: to = GPT_ADDR;
129: new_s1 = GPT - 1;
130:
131: /* Now copy the characters. To move the gap up,
132: copy characters down. */
133:
134: while (1)
135: {
136: /* I gets number of characters left to copy. */
137: i = pos - new_s1;
138: if (i == 0)
139: break;
140: /* If a quit is requested, stop copying now.
141: Change POS to be where we have actually moved the gap to. */
142: if (QUITP)
143: {
144: pos = new_s1;
145: break;
146: }
147: /* Move at most 32000 chars before checking again for a quit. */
148: if (i > 32000)
149: i = 32000;
150: new_s1 += i;
151: while (--i >= 0)
152: *to++ = *from++;
153: }
154:
155: adjust_markers (GPT + GAP_SIZE, pos + 1 + GAP_SIZE, - GAP_SIZE);
156: GPT = pos + 1;
157: QUIT;
158: }
159:
160: /* Add `amount' to the position of every marker in the current buffer
161: whose current position is between `from' (exclusive) and `to' (inclusive).
162: Also, any markers past the outside of that interval, in the direction
163: of adjustment, are first moved back to the near end of the interval
164: and then adjusted by `amount'. */
165:
166: adjust_markers (from, to, amount)
167: register int from, to, amount;
168: {
169: Lisp_Object marker;
170: register struct Lisp_Marker *m;
171: register int mpos;
172:
173: marker = current_buffer->markers;
174:
175: while (!NULL (marker))
176: {
177: m = XMARKER (marker);
178: mpos = m->bufpos;
179: if (amount > 0)
180: {
181: if (mpos > to && mpos < to + amount)
182: mpos = to + amount;
183: }
184: else
185: {
186: if (mpos > from + amount && mpos <= from)
187: mpos = from + amount;
188: }
189: if (mpos > from && mpos <= to)
190: mpos += amount;
191: m->bufpos = mpos;
192: marker = m->chain;
193: }
194: }
195:
196: /* Make the gap INCREMENT characters longer. */
197:
198: make_gap (increment)
199: int increment;
200: {
201: unsigned char *memory;
202: Lisp_Object tem;
203: int real_gap_loc;
204: int old_gap_size;
205:
206: /* If we have to get more space, get enough to last a while. */
207: increment += 2000;
208:
209: memory = (unsigned char *) realloc (BEG_ADDR,
210: Z - BEG + GAP_SIZE + increment);
211: if (memory == 0)
212: memory_full ();
213: BEG_ADDR = memory;
214:
215: /* Prevent quitting in move_gap. */
216: tem = Vinhibit_quit;
217: Vinhibit_quit = Qt;
218:
219: real_gap_loc = GPT;
220: old_gap_size = GAP_SIZE;
221: /* Call the newly allocated space a gap at the end of the whole space. */
222: GPT = Z + GAP_SIZE;
223: GAP_SIZE = increment;
224: /* Move the new gap down to be consecutive with the end of the old one.
225: This adjusts the markers properly too. */
226: gap_left (real_gap_loc + old_gap_size, 1);
227: /* Now combine the two into one large gap. */
228: GAP_SIZE += old_gap_size;
229: GPT = real_gap_loc;
230:
231: Vinhibit_quit = tem;
232: }
233:
234: /* Insert the character c before point */
235:
236: insert_char (c)
237: unsigned char c;
238: {
239: insert (&c, 1);
240: }
241:
242: /* Insert the null-terminated string s before point */
243:
244: InsStr (s)
245: char *s;
246: {
247: insert (s, strlen (s));
248: }
249:
250: /* Insert a string of specified length before point.
251: DO NOT use this for the contents of a Lisp string!
252: prepare_to_modify_buffer could relocate the string. */
253:
254: insert (string, length)
255: register unsigned char *string;
256: register length;
257: {
258: register Lisp_Object temp;
259:
260: if (length < 1)
261: return;
262:
263: /* Make sure point-max won't overflow after this insertion. */
264: XSET (temp, Lisp_Int, length + Z);
265: if (length + Z != XINT (temp))
266: error ("maximum buffer size exceeded");
267:
268: prepare_to_modify_buffer ();
269:
270: if (point != GPT)
271: move_gap (point);
272: if (GAP_SIZE < length)
273: make_gap (length - GAP_SIZE);
274:
275: record_insert (point, length);
276: MODIFF++;
277:
278: bcopy (string, GPT_ADDR, length);
279:
280: GAP_SIZE -= length;
281: GPT += length;
282: ZV += length;
283: Z += length;
284: point += length;
285: }
286:
287: /* Function to insert part of the text of a string (STRING) consisting
288: of LENGTH characters at position POS.
289: It does not work to use `insert' for this, becase a GC could happen
290: before we bcopy the stuff into the buffer, and relocate the string
291: without insert noticing. */
292: insert_from_string (string, pos, length)
293: Lisp_Object string;
294: register int pos, length;
295: {
296: register Lisp_Object temp;
297: struct gcpro gcpro1;
298:
299: if (length < 1)
300: return;
301:
302: /* Make sure point-max won't overflow after this insertion. */
303: XSET (temp, Lisp_Int, length + Z);
304: if (length + Z != XINT (temp))
305: error ("maximum buffer size exceeded");
306:
307: GCPRO1 (string);
308: prepare_to_modify_buffer ();
309:
310: if (point != GPT)
311: move_gap (point);
312: if (GAP_SIZE < length)
313: make_gap (length - GAP_SIZE);
314:
315: record_insert (point, length);
316: MODIFF++;
317: UNGCPRO;
318:
319: bcopy (XSTRING (string)->data, GPT_ADDR, length);
320:
321: GAP_SIZE -= length;
322: GPT += length;
323: ZV += length;
324: Z += length;
325: point += length;
326: }
327:
328: /* Like `insert' except that all markers pointing at the place where
329: the insertion happens are adjusted to point after it.
330: Don't use this function to insert part of a Lisp string,
331: since gc could happen and relocate it. */
332:
333: insert_before_markers (string, length)
334: unsigned char *string;
335: register int length;
336: {
337: register int opoint = point;
338: insert (string, length);
339: adjust_markers (opoint - 1, opoint, length);
340: }
341:
342: /* Insert part of a Lisp string, relocating markers after. */
343:
344: insert_from_string_before_markers (string, pos, length)
345: Lisp_Object string;
346: register int pos, length;
347: {
348: register int opoint = point;
349: insert_from_string (string, pos, length);
350: adjust_markers (opoint - 1, opoint, length);
351: }
352:
353: /* Delete characters in current buffer
354: from `from' up to (but not incl) `to' */
355:
356: del_range (from, to)
357: register int from, to;
358: {
359: register int numdel;
360:
361: /* Make args be valid */
362: if (from < BEGV)
363: from = BEGV;
364: if (to > ZV)
365: to = ZV;
366:
367: if ((numdel = to - from) <= 0)
368: return;
369:
370: /* Make sure the gap is somewhere in or next to what we are deleting */
371: if (from > GPT)
372: gap_right (from);
373: if (to < GPT)
374: gap_left (to, 0);
375:
376: prepare_to_modify_buffer ();
377: record_delete (from, numdel);
378: MODIFF++;
379:
380: /* Relocate point as if it were a marker. */
381: if (from < point)
382: {
383: if (point < to)
384: point = from;
385: else
386: point -= numdel;
387: }
388:
389: /* Relocate all markers pointing into the new, larger gap
390: to point at the end of the text before the gap. */
391: adjust_markers (to + GAP_SIZE, to + GAP_SIZE, - numdel - GAP_SIZE);
392:
393: GAP_SIZE += numdel;
394: ZV -= numdel;
395: Z -= numdel;
396: GPT = from;
397:
398: if (GPT - BEG < beg_unchanged)
399: beg_unchanged = GPT - BEG;
400: if (Z - GPT < end_unchanged)
401: end_unchanged = Z - GPT;
402: }
403:
404: modify_region (start, end)
405: int start, end;
406: {
407: prepare_to_modify_buffer ();
408: if (start - 1 < beg_unchanged || unchanged_modified == MODIFF)
409: beg_unchanged = start - 1;
410: if (Z - end < end_unchanged
411: || unchanged_modified == MODIFF)
412: end_unchanged = Z - end;
413: MODIFF++;
414: }
415:
416: prepare_to_modify_buffer ()
417: {
418: if (!NULL (current_buffer->read_only))
419: Fbarf_if_buffer_read_only();
420:
421: #ifdef CLASH_DETECTION
422: if (!NULL (current_buffer->filename)
423: && current_buffer->save_modified >= MODIFF)
424: lock_file (current_buffer->filename);
425: #else
426: /* At least warn if this file has changed on disk since it was visited. */
427: if (!NULL (current_buffer->filename)
428: && current_buffer->save_modified >= MODIFF
429: && NULL (Fverify_visited_file_modtime (Fcurrent_buffer ()))
430: && !NULL (Ffile_exists_p (current_buffer->filename)))
431: call1 (intern ("ask-user-about-supersession-threat"),
432: current_buffer->filename);
433: #endif /* not CLASH_DETECTION */
434: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.