Mercurial > emacs
annotate src/intervals.c @ 6734:6e61dbbfce80
(hack-one-local-variable): Test for risky-local-variable property.
Put such properties on some variables, including minor-mode-map-alist.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Thu, 07 Apr 1994 19:03:17 +0000 |
parents | e42af7949b19 |
children | 873e8baf5727 |
rev | line source |
---|---|
1157 | 1 /* Code for doing intervals. |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
2 Copyright (C) 1993 Free Software Foundation, Inc. |
1157 | 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 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
8 the Free Software Foundation; either version 2, or (at your option) |
1157 | 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 /* NOTES: | |
22 | |
23 Have to ensure that we can't put symbol nil on a plist, or some | |
24 functions may work incorrectly. | |
25 | |
26 An idea: Have the owner of the tree keep count of splits and/or | |
27 insertion lengths (in intervals), and balance after every N. | |
28 | |
29 Need to call *_left_hook when buffer is killed. | |
30 | |
31 Scan for zero-length, or 0-length to see notes about handling | |
32 zero length interval-markers. | |
33 | |
34 There are comments around about freeing intervals. It might be | |
35 faster to explicitly free them (put them on the free list) than | |
36 to GC them. | |
37 | |
38 */ | |
39 | |
40 | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
4638
diff
changeset
|
41 #include <config.h> |
1157 | 42 #include "lisp.h" |
43 #include "intervals.h" | |
44 #include "buffer.h" | |
4962 | 45 #include "puresize.h" |
1157 | 46 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
47 /* The rest of the file is within this conditional. */ |
1301
5a27062b8b7f
* intervals.c: Conditionalize all functions on
Joseph Arceneaux <jla@gnu.org>
parents:
1288
diff
changeset
|
48 #ifdef USE_TEXT_PROPERTIES |
5a27062b8b7f
* intervals.c: Conditionalize all functions on
Joseph Arceneaux <jla@gnu.org>
parents:
1288
diff
changeset
|
49 |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
50 /* Test for membership, allowing for t (actually any non-cons) to mean the |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
51 universal set. */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
52 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
53 #define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
54 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
55 /* Factor for weight-balancing interval trees. */ |
1157 | 56 Lisp_Object interval_balance_threshold; |
5173
d48ba25b35bf
(merge_properties_sticky): Declared.
Richard M. Stallman <rms@gnu.org>
parents:
5169
diff
changeset
|
57 |
d48ba25b35bf
(merge_properties_sticky): Declared.
Richard M. Stallman <rms@gnu.org>
parents:
5169
diff
changeset
|
58 Lisp_Object merge_properties_sticky (); |
1157 | 59 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
60 /* Utility functions for intervals. */ |
1157 | 61 |
62 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
63 /* Create the root interval of some object, a buffer or string. */ |
1157 | 64 |
65 INTERVAL | |
66 create_root_interval (parent) | |
67 Lisp_Object parent; | |
68 { | |
4962 | 69 INTERVAL new; |
70 | |
71 CHECK_IMPURE (parent); | |
72 | |
73 new = make_interval (); | |
1157 | 74 |
75 if (XTYPE (parent) == Lisp_Buffer) | |
76 { | |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
77 new->total_length = (BUF_Z (XBUFFER (parent)) |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
78 - BUF_BEG (XBUFFER (parent))); |
1157 | 79 XBUFFER (parent)->intervals = new; |
80 } | |
81 else if (XTYPE (parent) == Lisp_String) | |
82 { | |
83 new->total_length = XSTRING (parent)->size; | |
84 XSTRING (parent)->intervals = new; | |
85 } | |
86 | |
87 new->parent = (INTERVAL) parent; | |
88 new->position = 1; | |
89 | |
90 return new; | |
91 } | |
92 | |
93 /* Make the interval TARGET have exactly the properties of SOURCE */ | |
94 | |
95 void | |
96 copy_properties (source, target) | |
97 register INTERVAL source, target; | |
98 { | |
99 if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target)) | |
100 return; | |
101 | |
102 COPY_INTERVAL_CACHE (source, target); | |
103 target->plist = Fcopy_sequence (source->plist); | |
104 } | |
105 | |
106 /* Merge the properties of interval SOURCE into the properties | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
107 of interval TARGET. That is to say, each property in SOURCE |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
108 is added to TARGET if TARGET has no such property as yet. */ |
1157 | 109 |
110 static void | |
111 merge_properties (source, target) | |
112 register INTERVAL source, target; | |
113 { | |
114 register Lisp_Object o, sym, val; | |
115 | |
116 if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target)) | |
117 return; | |
118 | |
119 MERGE_INTERVAL_CACHE (source, target); | |
120 | |
121 o = source->plist; | |
122 while (! EQ (o, Qnil)) | |
123 { | |
124 sym = Fcar (o); | |
125 val = Fmemq (sym, target->plist); | |
126 | |
127 if (NILP (val)) | |
128 { | |
129 o = Fcdr (o); | |
130 val = Fcar (o); | |
131 target->plist = Fcons (sym, Fcons (val, target->plist)); | |
132 o = Fcdr (o); | |
133 } | |
134 else | |
135 o = Fcdr (Fcdr (o)); | |
136 } | |
137 } | |
138 | |
139 /* Return 1 if the two intervals have the same properties, | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
140 0 otherwise. */ |
1157 | 141 |
142 int | |
143 intervals_equal (i0, i1) | |
144 INTERVAL i0, i1; | |
145 { | |
146 register Lisp_Object i0_cdr, i0_sym, i1_val; | |
147 register i1_len; | |
148 | |
149 if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1)) | |
150 return 1; | |
151 | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
152 if (DEFAULT_INTERVAL_P (i0) || DEFAULT_INTERVAL_P (i1)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
153 return 0; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
154 |
1157 | 155 i1_len = XFASTINT (Flength (i1->plist)); |
156 if (i1_len & 0x1) /* Paranoia -- plists are always even */ | |
157 abort (); | |
158 i1_len /= 2; | |
159 i0_cdr = i0->plist; | |
160 while (!NILP (i0_cdr)) | |
161 { | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
162 /* Lengths of the two plists were unequal. */ |
1157 | 163 if (i1_len == 0) |
164 return 0; | |
165 | |
166 i0_sym = Fcar (i0_cdr); | |
167 i1_val = Fmemq (i0_sym, i1->plist); | |
168 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
169 /* i0 has something i1 doesn't. */ |
1157 | 170 if (EQ (i1_val, Qnil)) |
171 return 0; | |
172 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
173 /* i0 and i1 both have sym, but it has different values in each. */ |
1157 | 174 i0_cdr = Fcdr (i0_cdr); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
175 if (! EQ (Fcar (Fcdr (i1_val)), Fcar (i0_cdr))) |
1157 | 176 return 0; |
177 | |
178 i0_cdr = Fcdr (i0_cdr); | |
179 i1_len--; | |
180 } | |
181 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
182 /* Lengths of the two plists were unequal. */ |
1157 | 183 if (i1_len > 0) |
184 return 0; | |
185 | |
186 return 1; | |
187 } | |
188 | |
189 static int icount; | |
190 static int idepth; | |
191 static int zero_length; | |
192 | |
193 /* Traverse an interval tree TREE, performing FUNCTION on each node. | |
1958
8bc716df45e3
(traverse_intervals): New arg ARG.
Richard M. Stallman <rms@gnu.org>
parents:
1412
diff
changeset
|
194 Pass FUNCTION two args: an interval, and ARG. */ |
1157 | 195 |
196 void | |
1958
8bc716df45e3
(traverse_intervals): New arg ARG.
Richard M. Stallman <rms@gnu.org>
parents:
1412
diff
changeset
|
197 traverse_intervals (tree, position, depth, function, arg) |
1157 | 198 INTERVAL tree; |
1412
6097878fbd46
* intervals.c (traverse_intervals): New parameter `depth'.
Joseph Arceneaux <jla@gnu.org>
parents:
1316
diff
changeset
|
199 int position, depth; |
1157 | 200 void (* function) (); |
1958
8bc716df45e3
(traverse_intervals): New arg ARG.
Richard M. Stallman <rms@gnu.org>
parents:
1412
diff
changeset
|
201 Lisp_Object arg; |
1157 | 202 { |
203 if (NULL_INTERVAL_P (tree)) | |
204 return; | |
205 | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
206 traverse_intervals (tree->left, position, depth + 1, function, arg); |
1157 | 207 position += LEFT_TOTAL_LENGTH (tree); |
208 tree->position = position; | |
1958
8bc716df45e3
(traverse_intervals): New arg ARG.
Richard M. Stallman <rms@gnu.org>
parents:
1412
diff
changeset
|
209 (*function) (tree, arg); |
1157 | 210 position += LENGTH (tree); |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
211 traverse_intervals (tree->right, position, depth + 1, function, arg); |
1157 | 212 } |
213 | |
214 #if 0 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
215 /* These functions are temporary, for debugging purposes only. */ |
1157 | 216 |
217 INTERVAL search_interval, found_interval; | |
218 | |
219 void | |
220 check_for_interval (i) | |
221 register INTERVAL i; | |
222 { | |
223 if (i == search_interval) | |
224 { | |
225 found_interval = i; | |
226 icount++; | |
227 } | |
228 } | |
229 | |
230 INTERVAL | |
231 search_for_interval (i, tree) | |
232 register INTERVAL i, tree; | |
233 { | |
234 icount = 0; | |
235 search_interval = i; | |
236 found_interval = NULL_INTERVAL; | |
1958
8bc716df45e3
(traverse_intervals): New arg ARG.
Richard M. Stallman <rms@gnu.org>
parents:
1412
diff
changeset
|
237 traverse_intervals (tree, 1, 0, &check_for_interval, Qnil); |
1157 | 238 return found_interval; |
239 } | |
240 | |
241 static void | |
242 inc_interval_count (i) | |
243 INTERVAL i; | |
244 { | |
245 icount++; | |
246 if (LENGTH (i) == 0) | |
247 zero_length++; | |
248 if (depth > idepth) | |
249 idepth = depth; | |
250 } | |
251 | |
252 int | |
253 count_intervals (i) | |
254 register INTERVAL i; | |
255 { | |
256 icount = 0; | |
257 idepth = 0; | |
258 zero_length = 0; | |
1958
8bc716df45e3
(traverse_intervals): New arg ARG.
Richard M. Stallman <rms@gnu.org>
parents:
1412
diff
changeset
|
259 traverse_intervals (i, 1, 0, &inc_interval_count, Qnil); |
1157 | 260 |
261 return icount; | |
262 } | |
263 | |
264 static INTERVAL | |
265 root_interval (interval) | |
266 INTERVAL interval; | |
267 { | |
268 register INTERVAL i = interval; | |
269 | |
270 while (! ROOT_INTERVAL_P (i)) | |
271 i = i->parent; | |
272 | |
273 return i; | |
274 } | |
275 #endif | |
276 | |
277 /* Assuming that a left child exists, perform the following operation: | |
278 | |
279 A B | |
280 / \ / \ | |
281 B => A | |
282 / \ / \ | |
283 c c | |
284 */ | |
285 | |
286 static INTERVAL | |
287 rotate_right (interval) | |
288 INTERVAL interval; | |
289 { | |
290 INTERVAL i; | |
291 INTERVAL B = interval->left; | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
292 int old_total = interval->total_length; |
1157 | 293 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
294 /* Deal with any Parent of A; make it point to B. */ |
1157 | 295 if (! ROOT_INTERVAL_P (interval)) |
296 if (AM_LEFT_CHILD (interval)) | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
297 interval->parent->left = B; |
1157 | 298 else |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
299 interval->parent->right = B; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
300 B->parent = interval->parent; |
1157 | 301 |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
302 /* Make B the parent of A */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
303 i = B->right; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
304 B->right = interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
305 interval->parent = B; |
1157 | 306 |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
307 /* Make A point to c */ |
1157 | 308 interval->left = i; |
309 if (! NULL_INTERVAL_P (i)) | |
310 i->parent = interval; | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
311 |
5760
ffe89784cef2
(merge_properties_sticky): Preserve original order of properties.
Karl Heuer <kwzh@gnu.org>
parents:
5666
diff
changeset
|
312 /* A's total length is decreased by the length of B and its left child. */ |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
313 interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
314 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
315 /* B must have the same total length of A. */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
316 B->total_length = old_total; |
1157 | 317 |
318 return B; | |
319 } | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
320 |
1157 | 321 /* Assuming that a right child exists, perform the following operation: |
322 | |
323 A B | |
324 / \ / \ | |
325 B => A | |
326 / \ / \ | |
327 c c | |
328 */ | |
329 | |
330 static INTERVAL | |
331 rotate_left (interval) | |
332 INTERVAL interval; | |
333 { | |
334 INTERVAL i; | |
335 INTERVAL B = interval->right; | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
336 int old_total = interval->total_length; |
1157 | 337 |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
338 /* Deal with any parent of A; make it point to B. */ |
1157 | 339 if (! ROOT_INTERVAL_P (interval)) |
340 if (AM_LEFT_CHILD (interval)) | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
341 interval->parent->left = B; |
1157 | 342 else |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
343 interval->parent->right = B; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
344 B->parent = interval->parent; |
1157 | 345 |
346 /* Make B the parent of A */ | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
347 i = B->left; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
348 B->left = interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
349 interval->parent = B; |
1157 | 350 |
351 /* Make A point to c */ | |
352 interval->right = i; | |
353 if (! NULL_INTERVAL_P (i)) | |
354 i->parent = interval; | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
355 |
5760
ffe89784cef2
(merge_properties_sticky): Preserve original order of properties.
Karl Heuer <kwzh@gnu.org>
parents:
5666
diff
changeset
|
356 /* A's total length is decreased by the length of B and its right child. */ |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
357 interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
358 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
359 /* B must have the same total length of A. */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
360 B->total_length = old_total; |
1157 | 361 |
362 return B; | |
363 } | |
364 | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
365 /* Balance an interval tree with the assumption that the subtrees |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
366 themselves are already balanced. */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
367 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
368 static INTERVAL |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
369 balance_an_interval (i) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
370 INTERVAL i; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
371 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
372 register int old_diff, new_diff; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
373 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
374 while (1) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
375 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
376 old_diff = LEFT_TOTAL_LENGTH (i) - RIGHT_TOTAL_LENGTH (i); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
377 if (old_diff > 0) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
378 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
379 new_diff = i->total_length - i->left->total_length |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
380 + RIGHT_TOTAL_LENGTH (i->left) - LEFT_TOTAL_LENGTH (i->left); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
381 if (abs (new_diff) >= old_diff) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
382 break; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
383 i = rotate_right (i); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
384 balance_an_interval (i->right); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
385 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
386 else if (old_diff < 0) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
387 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
388 new_diff = i->total_length - i->right->total_length |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
389 + LEFT_TOTAL_LENGTH (i->right) - RIGHT_TOTAL_LENGTH (i->right); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
390 if (abs (new_diff) >= -old_diff) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
391 break; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
392 i = rotate_left (i); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
393 balance_an_interval (i->left); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
394 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
395 else |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
396 break; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
397 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
398 return i; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
399 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
400 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
401 /* Balance INTERVAL, potentially stuffing it back into its parent |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
402 Lisp Object. */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
403 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
404 static INLINE INTERVAL |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
405 balance_possible_root_interval (interval) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
406 register INTERVAL interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
407 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
408 Lisp_Object parent; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
409 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
410 if (interval->parent == NULL_INTERVAL) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
411 return interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
412 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
413 parent = (Lisp_Object) (interval->parent); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
414 interval = balance_an_interval (interval); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
415 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
416 if (XTYPE (parent) == Lisp_Buffer) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
417 XBUFFER (parent)->intervals = interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
418 else if (XTYPE (parent) == Lisp_String) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
419 XSTRING (parent)->intervals = interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
420 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
421 return interval; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
422 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
423 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
424 /* Balance the interval tree TREE. Balancing is by weight |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
425 (the amount of text). */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
426 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
427 static INTERVAL |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
428 balance_intervals_internal (tree) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
429 register INTERVAL tree; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
430 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
431 /* Balance within each side. */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
432 if (tree->left) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
433 balance_intervals (tree->left); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
434 if (tree->right) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
435 balance_intervals (tree->right); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
436 return balance_an_interval (tree); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
437 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
438 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
439 /* Advertised interface to balance intervals. */ |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
440 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
441 INTERVAL |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
442 balance_intervals (tree) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
443 INTERVAL tree; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
444 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
445 if (tree == NULL_INTERVAL) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
446 return NULL_INTERVAL; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
447 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
448 return balance_intervals_internal (tree); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
449 } |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
450 |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
451 /* Split INTERVAL into two pieces, starting the second piece at |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
452 character position OFFSET (counting from 0), relative to INTERVAL. |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
453 INTERVAL becomes the left-hand piece, and the right-hand piece |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
454 (second, lexicographically) is returned. |
1164 | 455 |
456 The size and position fields of the two intervals are set based upon | |
457 those of the original interval. The property list of the new interval | |
458 is reset, thus it is up to the caller to do the right thing with the | |
459 result. | |
1157 | 460 |
461 Note that this does not change the position of INTERVAL; if it is a root, | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
462 it is still a root after this operation. */ |
1157 | 463 |
464 INTERVAL | |
1164 | 465 split_interval_right (interval, offset) |
1157 | 466 INTERVAL interval; |
1164 | 467 int offset; |
1157 | 468 { |
469 INTERVAL new = make_interval (); | |
470 int position = interval->position; | |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
471 int new_length = LENGTH (interval) - offset; |
1157 | 472 |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
473 new->position = position + offset; |
1157 | 474 new->parent = interval; |
475 | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
476 if (NULL_RIGHT_CHILD (interval)) |
1157 | 477 { |
478 interval->right = new; | |
479 new->total_length = new_length; | |
480 | |
481 return new; | |
482 } | |
483 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
484 /* Insert the new node between INTERVAL and its right child. */ |
1157 | 485 new->right = interval->right; |
486 interval->right->parent = new; | |
487 interval->right = new; | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
488 new->total_length = new_length + new->right->total_length; |
1157 | 489 |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
490 balance_an_interval (new); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
491 balance_possible_root_interval (interval); |
1157 | 492 |
493 return new; | |
494 } | |
495 | |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
496 /* Split INTERVAL into two pieces, starting the second piece at |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
497 character position OFFSET (counting from 0), relative to INTERVAL. |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
498 INTERVAL becomes the right-hand piece, and the left-hand piece |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
499 (first, lexicographically) is returned. |
1157 | 500 |
1164 | 501 The size and position fields of the two intervals are set based upon |
502 those of the original interval. The property list of the new interval | |
503 is reset, thus it is up to the caller to do the right thing with the | |
504 result. | |
505 | |
506 Note that this does not change the position of INTERVAL; if it is a root, | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
507 it is still a root after this operation. */ |
1157 | 508 |
509 INTERVAL | |
1164 | 510 split_interval_left (interval, offset) |
1157 | 511 INTERVAL interval; |
1164 | 512 int offset; |
1157 | 513 { |
514 INTERVAL new = make_interval (); | |
515 int position = interval->position; | |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
516 int new_length = offset; |
1157 | 517 |
518 new->position = interval->position; | |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
519 interval->position = interval->position + offset; |
1157 | 520 new->parent = interval; |
521 | |
522 if (NULL_LEFT_CHILD (interval)) | |
523 { | |
524 interval->left = new; | |
525 new->total_length = new_length; | |
526 | |
527 return new; | |
528 } | |
529 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
530 /* Insert the new node between INTERVAL and its left child. */ |
1157 | 531 new->left = interval->left; |
532 new->left->parent = new; | |
533 interval->left = new; | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
534 new->total_length = new_length + new->left->total_length; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
535 |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
536 balance_an_interval (new); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
537 balance_possible_root_interval (interval); |
1157 | 538 |
539 return new; | |
540 } | |
541 | |
1164 | 542 /* Find the interval containing text position POSITION in the text |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
543 represented by the interval tree TREE. POSITION is a buffer |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
544 position; the earliest position is 1. If POSITION is at the end of |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
545 the buffer, return the interval containing the last character. |
1157 | 546 |
1164 | 547 The `position' field, which is a cache of an interval's position, |
548 is updated in the interval found. Other functions (e.g., next_interval) | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
549 will update this cache based on the result of find_interval. */ |
1164 | 550 |
551 INLINE INTERVAL | |
1157 | 552 find_interval (tree, position) |
553 register INTERVAL tree; | |
554 register int position; | |
555 { | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
556 /* The distance from the left edge of the subtree at TREE |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
557 to POSITION. */ |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
558 register int relative_position = position - BEG; |
1157 | 559 |
560 if (NULL_INTERVAL_P (tree)) | |
561 return NULL_INTERVAL; | |
562 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
563 if (relative_position > TOTAL_LENGTH (tree)) |
1157 | 564 abort (); /* Paranoia */ |
565 | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
566 tree = balance_possible_root_interval (tree); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
567 |
1157 | 568 while (1) |
569 { | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
570 if (relative_position < LEFT_TOTAL_LENGTH (tree)) |
1157 | 571 { |
572 tree = tree->left; | |
573 } | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
574 else if (! NULL_RIGHT_CHILD (tree) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
575 && relative_position >= (TOTAL_LENGTH (tree) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
576 - RIGHT_TOTAL_LENGTH (tree))) |
1157 | 577 { |
578 relative_position -= (TOTAL_LENGTH (tree) | |
579 - RIGHT_TOTAL_LENGTH (tree)); | |
580 tree = tree->right; | |
581 } | |
582 else | |
583 { | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
584 tree->position = |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
585 (position - relative_position /* the left edge of *tree */ |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
586 + LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */ |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
587 |
1157 | 588 return tree; |
589 } | |
590 } | |
591 } | |
592 | |
593 /* Find the succeeding interval (lexicographically) to INTERVAL. | |
1164 | 594 Sets the `position' field based on that of INTERVAL (see |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
595 find_interval). */ |
1157 | 596 |
597 INTERVAL | |
598 next_interval (interval) | |
599 register INTERVAL interval; | |
600 { | |
601 register INTERVAL i = interval; | |
602 register int next_position; | |
603 | |
604 if (NULL_INTERVAL_P (i)) | |
605 return NULL_INTERVAL; | |
606 next_position = interval->position + LENGTH (interval); | |
607 | |
608 if (! NULL_RIGHT_CHILD (i)) | |
609 { | |
610 i = i->right; | |
611 while (! NULL_LEFT_CHILD (i)) | |
612 i = i->left; | |
613 | |
614 i->position = next_position; | |
615 return i; | |
616 } | |
617 | |
618 while (! NULL_PARENT (i)) | |
619 { | |
620 if (AM_LEFT_CHILD (i)) | |
621 { | |
622 i = i->parent; | |
623 i->position = next_position; | |
624 return i; | |
625 } | |
626 | |
627 i = i->parent; | |
628 } | |
629 | |
630 return NULL_INTERVAL; | |
631 } | |
632 | |
633 /* Find the preceding interval (lexicographically) to INTERVAL. | |
1164 | 634 Sets the `position' field based on that of INTERVAL (see |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
635 find_interval). */ |
1157 | 636 |
637 INTERVAL | |
638 previous_interval (interval) | |
639 register INTERVAL interval; | |
640 { | |
641 register INTERVAL i; | |
642 register position_of_previous; | |
643 | |
644 if (NULL_INTERVAL_P (interval)) | |
645 return NULL_INTERVAL; | |
646 | |
647 if (! NULL_LEFT_CHILD (interval)) | |
648 { | |
649 i = interval->left; | |
650 while (! NULL_RIGHT_CHILD (i)) | |
651 i = i->right; | |
652 | |
653 i->position = interval->position - LENGTH (i); | |
654 return i; | |
655 } | |
656 | |
657 i = interval; | |
658 while (! NULL_PARENT (i)) | |
659 { | |
660 if (AM_RIGHT_CHILD (i)) | |
661 { | |
662 i = i->parent; | |
663 | |
664 i->position = interval->position - LENGTH (i); | |
665 return i; | |
666 } | |
667 i = i->parent; | |
668 } | |
669 | |
670 return NULL_INTERVAL; | |
671 } | |
672 | |
1164 | 673 #if 0 |
1157 | 674 /* Traverse a path down the interval tree TREE to the interval |
675 containing POSITION, adjusting all nodes on the path for | |
676 an addition of LENGTH characters. Insertion between two intervals | |
677 (i.e., point == i->position, where i is second interval) means | |
678 text goes into second interval. | |
679 | |
680 Modifications are needed to handle the hungry bits -- after simply | |
681 finding the interval at position (don't add length going down), | |
682 if it's the beginning of the interval, get the previous interval | |
683 and check the hugry bits of both. Then add the length going back up | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
684 to the root. */ |
1157 | 685 |
686 static INTERVAL | |
687 adjust_intervals_for_insertion (tree, position, length) | |
688 INTERVAL tree; | |
689 int position, length; | |
690 { | |
691 register int relative_position; | |
692 register INTERVAL this; | |
693 | |
694 if (TOTAL_LENGTH (tree) == 0) /* Paranoia */ | |
695 abort (); | |
696 | |
697 /* If inserting at point-max of a buffer, that position | |
698 will be out of range */ | |
699 if (position > TOTAL_LENGTH (tree)) | |
700 position = TOTAL_LENGTH (tree); | |
701 relative_position = position; | |
702 this = tree; | |
703 | |
704 while (1) | |
705 { | |
706 if (relative_position <= LEFT_TOTAL_LENGTH (this)) | |
707 { | |
708 this->total_length += length; | |
709 this = this->left; | |
710 } | |
711 else if (relative_position > (TOTAL_LENGTH (this) | |
712 - RIGHT_TOTAL_LENGTH (this))) | |
713 { | |
714 relative_position -= (TOTAL_LENGTH (this) | |
715 - RIGHT_TOTAL_LENGTH (this)); | |
716 this->total_length += length; | |
717 this = this->right; | |
718 } | |
719 else | |
720 { | |
721 /* If we are to use zero-length intervals as buffer pointers, | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
722 then this code will have to change. */ |
1157 | 723 this->total_length += length; |
724 this->position = LEFT_TOTAL_LENGTH (this) | |
725 + position - relative_position + 1; | |
726 return tree; | |
727 } | |
728 } | |
729 } | |
1164 | 730 #endif |
731 | |
732 /* Effect an adjustment corresponding to the addition of LENGTH characters | |
733 of text. Do this by finding the interval containing POSITION in the | |
5760
ffe89784cef2
(merge_properties_sticky): Preserve original order of properties.
Karl Heuer <kwzh@gnu.org>
parents:
5666
diff
changeset
|
734 interval tree TREE, and then adjusting all of its ancestors by adding |
1164 | 735 LENGTH to them. |
736 | |
737 If POSITION is the first character of an interval, meaning that point | |
738 is actually between the two intervals, make the new text belong to | |
739 the interval which is "sticky". | |
740 | |
1189 | 741 If both intervals are "sticky", then make them belong to the left-most |
1164 | 742 interval. Another possibility would be to create a new interval for |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
743 this text, and make it have the merged properties of both ends. */ |
1164 | 744 |
745 static INTERVAL | |
746 adjust_intervals_for_insertion (tree, position, length) | |
747 INTERVAL tree; | |
748 int position, length; | |
749 { | |
750 register INTERVAL i; | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
751 register INTERVAL temp; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
752 int eobp = 0; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
753 |
1164 | 754 if (TOTAL_LENGTH (tree) == 0) /* Paranoia */ |
755 abort (); | |
756 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
757 /* If inserting at point-max of a buffer, that position will be out |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
758 of range. Remember that buffer positions are 1-based. */ |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
759 if (position >= BEG + TOTAL_LENGTH (tree)){ |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
760 position = BEG + TOTAL_LENGTH (tree); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
761 eobp = 1; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
762 } |
1164 | 763 |
764 i = find_interval (tree, position); | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
765 |
4638
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
766 /* If in middle of an interval which is not sticky either way, |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
767 we must not just give its properties to the insertion. |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
768 So split this interval at the insertion point. */ |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
769 if (! (position == i->position || eobp) |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
770 && END_NONSTICKY_P (i) |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
771 && ! FRONT_STICKY_P (i)) |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
772 { |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
773 temp = split_interval_right (i, position - i->position); |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
774 copy_properties (i, temp); |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
775 i = temp; |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
776 } |
3872f91770fc
(adjust_intervals_for_insertion): If inserting in middle
Richard M. Stallman <rms@gnu.org>
parents:
4383
diff
changeset
|
777 |
1164 | 778 /* If we are positioned between intervals, check the stickiness of |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
779 both of them. We have to do this too, if we are at BEG or Z. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
780 if (position == i->position || eobp) |
1164 | 781 { |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
782 register INTERVAL prev; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
783 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
784 if (position == BEG) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
785 prev = 0; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
786 else if (eobp) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
787 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
788 prev = i; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
789 i = 0; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
790 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
791 else |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
792 prev = previous_interval (i); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
793 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
794 /* Even if we are positioned between intervals, we default |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
795 to the left one if it exists. We extend it now and split |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
796 off a part later, if stickyness demands it. */ |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
797 for (temp = prev ? prev : i;! NULL_INTERVAL_P (temp); temp = temp->parent) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
798 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
799 temp->total_length += length; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
800 temp = balance_possible_root_interval (temp); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
801 } |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
802 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
803 /* If at least one interval has sticky properties, |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
804 we check the stickyness property by property. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
805 if (END_NONSTICKY_P (prev) || FRONT_STICKY_P (i)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
806 { |
6501
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
807 Lisp_Object pleft, pright; |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
808 struct interval newi; |
1164 | 809 |
6501
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
810 pleft = NULL_INTERVAL_P (prev) ? Qnil : prev->plist; |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
811 pright = NULL_INTERVAL_P (i) ? Qnil : i->plist; |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
812 newi.plist = merge_properties_sticky (pleft, pright); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
813 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
814 if(! prev) /* i.e. position == BEG */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
815 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
816 if (! intervals_equal (i, &newi)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
817 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
818 i = split_interval_left (i, length); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
819 i->plist = newi.plist; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
820 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
821 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
822 else if (! intervals_equal (prev, &newi)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
823 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
824 prev = split_interval_right (prev, |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
825 position - prev->position); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
826 prev->plist = newi.plist; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
827 if (! NULL_INTERVAL_P (i) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
828 && intervals_equal (prev, i)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
829 merge_interval_right (prev); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
830 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
831 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
832 /* We will need to update the cache here later. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
833 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
834 else if (! prev && ! NILP (i->plist)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
835 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
836 /* Just split off a new interval at the left. |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
837 Since I wasn't front-sticky, the empty plist is ok. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
838 i = split_interval_left (i, length); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
839 } |
1164 | 840 } |
841 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
842 /* Otherwise just extend the interval. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
843 else |
1164 | 844 { |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
845 for (temp = i; ! NULL_INTERVAL_P (temp); temp = temp->parent) |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
846 { |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
847 temp->total_length += length; |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
848 temp = balance_possible_root_interval (temp); |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
849 } |
1164 | 850 } |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
851 |
1164 | 852 return tree; |
853 } | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
854 |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
855 /* Any property might be front-sticky on the left, rear-sticky on the left, |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
856 front-sticky on the right, or rear-sticky on the right; the 16 combinations |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
857 can be arranged in a matrix with rows denoting the left conditions and |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
858 columns denoting the right conditions: |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
859 _ __ _ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
860 _ FR FR FR FR |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
861 FR__ 0 1 2 3 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
862 _FR 4 5 6 7 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
863 FR 8 9 A B |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
864 FR C D E F |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
865 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
866 left-props = '(front-sticky (p8 p9 pa pb pc pd pe pf) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
867 rear-nonsticky (p4 p5 p6 p7 p8 p9 pa pb) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
868 p0 L p1 L p2 L p3 L p4 L p5 L p6 L p7 L |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
869 p8 L p9 L pa L pb L pc L pd L pe L pf L) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
870 right-props = '(front-sticky (p2 p3 p6 p7 pa pb pe pf) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
871 rear-nonsticky (p1 p2 p5 p6 p9 pa pd pe) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
872 p0 R p1 R p2 R p3 R p4 R p5 R p6 R p7 R |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
873 p8 R p9 R pa R pb R pc R pd R pe R pf R) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
874 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
875 We inherit from whoever has a sticky side facing us. If both sides |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
876 do (cases 2, 3, E, and F), then we inherit from whichever side has a |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
877 non-nil value for the current property. If both sides do, then we take |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
878 from the left. |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
879 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
880 When we inherit a property, we get its stickiness as well as its value. |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
881 So, when we merge the above two lists, we expect to get this: |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
882 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
883 result = '(front-sticky (p6 p7 pa pb pc pd pe pf) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
884 rear-nonsticky (p6 pa) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
885 p0 L p1 L p2 L p3 L p6 R p7 R |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
886 pa R pb R pc L pd L pe L pf L) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
887 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
888 The optimizable special cases are: |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
889 left rear-nonsticky = nil, right front-sticky = nil (inherit left) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
890 left rear-nonsticky = t, right front-sticky = t (inherit right) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
891 left rear-nonsticky = t, right front-sticky = nil (inherit none) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
892 */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
893 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
894 Lisp_Object |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
895 merge_properties_sticky (pleft, pright) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
896 Lisp_Object pleft, pright; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
897 { |
6501
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
898 register Lisp_Object props, front, rear; |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
899 Lisp_Object lfront, lrear, rfront, rrear; |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
900 register Lisp_Object tail1, tail2, sym, lval, rval; |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
901 int use_left, use_right; |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
902 |
6501
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
903 props = Qnil; |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
904 front = Qnil; |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
905 rear = Qnil; |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
906 lfront = textget (pleft, Qfront_sticky); |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
907 lrear = textget (pleft, Qrear_nonsticky); |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
908 rfront = textget (pright, Qfront_sticky); |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
909 rrear = textget (pright, Qrear_nonsticky); |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
910 |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
911 /* Go through each element of PRIGHT. */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
912 for (tail1 = pright; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1))) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
913 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
914 sym = Fcar (tail1); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
915 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
916 /* Sticky properties get special treatment. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
917 if (EQ (sym, Qrear_nonsticky) || EQ (sym, Qfront_sticky)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
918 continue; |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
919 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
920 rval = Fcar (Fcdr (tail1)); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
921 for (tail2 = pleft; ! NILP (tail2); tail2 = Fcdr (Fcdr (tail2))) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
922 if (EQ (sym, Fcar (tail2))) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
923 break; |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
924 lval = (NILP (tail2) ? Qnil : Fcar( Fcdr (tail2))); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
925 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
926 use_left = ! TMEM (sym, lrear); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
927 use_right = TMEM (sym, rfront); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
928 if (use_left && use_right) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
929 { |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
930 use_left = ! NILP (lval); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
931 use_right = ! NILP (rval); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
932 } |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
933 if (use_left) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
934 { |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
935 /* We build props as (value sym ...) rather than (sym value ...) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
936 because we plan to nreverse it when we're done. */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
937 if (! NILP (lval)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
938 props = Fcons (lval, Fcons (sym, props)); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
939 if (TMEM (sym, lfront)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
940 front = Fcons (sym, front); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
941 if (TMEM (sym, lrear)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
942 rear = Fcons (sym, rear); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
943 } |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
944 else if (use_right) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
945 { |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
946 if (! NILP (rval)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
947 props = Fcons (rval, Fcons (sym, props)); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
948 if (TMEM (sym, rfront)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
949 front = Fcons (sym, front); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
950 if (TMEM (sym, rrear)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
951 rear = Fcons (sym, rear); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
952 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
953 } |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
954 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
955 /* Now go through each element of PLEFT. */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
956 for (tail2 = pleft; ! NILP (tail2); tail2 = Fcdr (Fcdr (tail2))) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
957 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
958 sym = Fcar (tail2); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
959 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
960 /* Sticky properties get special treatment. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
961 if (EQ (sym, Qrear_nonsticky) || EQ (sym, Qfront_sticky)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
962 continue; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
963 |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
964 /* If sym is in PRIGHT, we've already considered it. */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
965 for (tail1 = pright; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1))) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
966 if (EQ (sym, Fcar (tail1))) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
967 break; |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
968 if (! NILP (tail1)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
969 continue; |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
970 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
971 lval = Fcar (Fcdr (tail2)); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
972 |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
973 /* Since rval is known to be nil in this loop, the test simplifies. */ |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
974 if (! TMEM (sym, lrear)) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
975 { |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
976 if (! NILP (lval)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
977 props = Fcons (lval, Fcons (sym, props)); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
978 if (TMEM (sym, lfront)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
979 front = Fcons (sym, front); |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
980 } |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
981 else if (TMEM (sym, rfront)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
982 { |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
983 /* The value is nil, but we still inherit the stickiness |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
984 from the right. */ |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
985 front = Fcons (sym, front); |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
986 if (TMEM (sym, rrear)) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
987 rear = Fcons (sym, rear); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
988 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
989 } |
5760
ffe89784cef2
(merge_properties_sticky): Preserve original order of properties.
Karl Heuer <kwzh@gnu.org>
parents:
5666
diff
changeset
|
990 props = Fnreverse (props); |
5768
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
991 if (! NILP (rear)) |
ab11e2af95ef
Add comments describing the rules used by the merge algorithm.
Karl Heuer <kwzh@gnu.org>
parents:
5760
diff
changeset
|
992 props = Fcons (Qrear_nonsticky, Fcons (Fnreverse (rear), props)); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
993 if (! NILP (front)) |
5760
ffe89784cef2
(merge_properties_sticky): Preserve original order of properties.
Karl Heuer <kwzh@gnu.org>
parents:
5666
diff
changeset
|
994 props = Fcons (Qfront_sticky, Fcons (Fnreverse (front), props)); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
995 return props; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
996 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
997 |
1157 | 998 |
1164 | 999 /* Delete an node I from its interval tree by merging its subtrees |
1000 into one subtree which is then returned. Caller is responsible for | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1001 storing the resulting subtree into its parent. */ |
1157 | 1002 |
1003 static INTERVAL | |
1004 delete_node (i) | |
1005 register INTERVAL i; | |
1006 { | |
1007 register INTERVAL migrate, this; | |
1008 register int migrate_amt; | |
1009 | |
1010 if (NULL_INTERVAL_P (i->left)) | |
1011 return i->right; | |
1012 if (NULL_INTERVAL_P (i->right)) | |
1013 return i->left; | |
1014 | |
1015 migrate = i->left; | |
1016 migrate_amt = i->left->total_length; | |
1017 this = i->right; | |
1018 this->total_length += migrate_amt; | |
1019 while (! NULL_INTERVAL_P (this->left)) | |
1020 { | |
1021 this = this->left; | |
1022 this->total_length += migrate_amt; | |
1023 } | |
1024 this->left = migrate; | |
1025 migrate->parent = this; | |
1026 | |
1027 return i->right; | |
1028 } | |
1029 | |
1030 /* Delete interval I from its tree by calling `delete_node' | |
1031 and properly connecting the resultant subtree. | |
1032 | |
1033 I is presumed to be empty; that is, no adjustments are made | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1034 for the length of I. */ |
1157 | 1035 |
1036 void | |
1037 delete_interval (i) | |
1038 register INTERVAL i; | |
1039 { | |
1040 register INTERVAL parent; | |
1041 int amt = LENGTH (i); | |
1042 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1043 if (amt > 0) /* Only used on zero-length intervals now. */ |
1157 | 1044 abort (); |
1045 | |
1046 if (ROOT_INTERVAL_P (i)) | |
1047 { | |
6501
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
1048 Lisp_Object owner; |
d7ac9a417f87
(adjust_intervals_for_insertion, merge_properties_sticky, delete_interval):
Karl Heuer <kwzh@gnu.org>
parents:
5780
diff
changeset
|
1049 owner = (Lisp_Object) i->parent; |
1157 | 1050 parent = delete_node (i); |
1051 if (! NULL_INTERVAL_P (parent)) | |
1052 parent->parent = (INTERVAL) owner; | |
1053 | |
1054 if (XTYPE (owner) == Lisp_Buffer) | |
1055 XBUFFER (owner)->intervals = parent; | |
1056 else if (XTYPE (owner) == Lisp_String) | |
1057 XSTRING (owner)->intervals = parent; | |
1058 else | |
1059 abort (); | |
1060 | |
1061 return; | |
1062 } | |
1063 | |
1064 parent = i->parent; | |
1065 if (AM_LEFT_CHILD (i)) | |
1066 { | |
1067 parent->left = delete_node (i); | |
1068 if (! NULL_INTERVAL_P (parent->left)) | |
1069 parent->left->parent = parent; | |
1070 } | |
1071 else | |
1072 { | |
1073 parent->right = delete_node (i); | |
1074 if (! NULL_INTERVAL_P (parent->right)) | |
1075 parent->right->parent = parent; | |
1076 } | |
1077 } | |
1078 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1079 /* Find the interval in TREE corresponding to the relative position |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1080 FROM and delete as much as possible of AMOUNT from that interval. |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1081 Return the amount actually deleted, and if the interval was |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1082 zeroed-out, delete that interval node from the tree. |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1083 |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1084 Note that FROM is actually origin zero, aka relative to the |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1085 leftmost edge of tree. This is appropriate since we call ourselves |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1086 recursively on subtrees. |
1157 | 1087 |
1189 | 1088 Do this by recursing down TREE to the interval in question, and |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1089 deleting the appropriate amount of text. */ |
1157 | 1090 |
1091 static int | |
1092 interval_deletion_adjustment (tree, from, amount) | |
1093 register INTERVAL tree; | |
1094 register int from, amount; | |
1095 { | |
1096 register int relative_position = from; | |
1097 | |
1098 if (NULL_INTERVAL_P (tree)) | |
1099 return 0; | |
1100 | |
1101 /* Left branch */ | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1102 if (relative_position < LEFT_TOTAL_LENGTH (tree)) |
1157 | 1103 { |
1104 int subtract = interval_deletion_adjustment (tree->left, | |
1105 relative_position, | |
1106 amount); | |
1107 tree->total_length -= subtract; | |
1108 return subtract; | |
1109 } | |
1110 /* Right branch */ | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1111 else if (relative_position >= (TOTAL_LENGTH (tree) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1112 - RIGHT_TOTAL_LENGTH (tree))) |
1157 | 1113 { |
1114 int subtract; | |
1115 | |
1116 relative_position -= (tree->total_length | |
1117 - RIGHT_TOTAL_LENGTH (tree)); | |
1118 subtract = interval_deletion_adjustment (tree->right, | |
1119 relative_position, | |
1120 amount); | |
1121 tree->total_length -= subtract; | |
1122 return subtract; | |
1123 } | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1124 /* Here -- this node. */ |
1157 | 1125 else |
1126 { | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1127 /* How much can we delete from this interval? */ |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1128 int my_amount = ((tree->total_length |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1129 - RIGHT_TOTAL_LENGTH (tree)) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1130 - relative_position); |
1157 | 1131 |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1132 if (amount > my_amount) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1133 amount = my_amount; |
1157 | 1134 |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1135 tree->total_length -= amount; |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1136 if (LENGTH (tree) == 0) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1137 delete_interval (tree); |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1138 |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1139 return amount; |
1157 | 1140 } |
1141 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1142 /* Never reach here. */ |
1157 | 1143 } |
1144 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1145 /* Effect the adjustments necessary to the interval tree of BUFFER to |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1146 correspond to the deletion of LENGTH characters from that buffer |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1147 text. The deletion is effected at position START (which is a |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1148 buffer position, i.e. origin 1). */ |
1189 | 1149 |
1157 | 1150 static void |
1151 adjust_intervals_for_deletion (buffer, start, length) | |
1152 struct buffer *buffer; | |
1153 int start, length; | |
1154 { | |
1155 register int left_to_delete = length; | |
1156 register INTERVAL tree = buffer->intervals; | |
1157 register int deleted; | |
1158 | |
1159 if (NULL_INTERVAL_P (tree)) | |
1160 return; | |
1161 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1162 if (start > BEG + TOTAL_LENGTH (tree) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1163 || start + length > BEG + TOTAL_LENGTH (tree)) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1164 abort (); |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1165 |
1157 | 1166 if (length == TOTAL_LENGTH (tree)) |
1167 { | |
1168 buffer->intervals = NULL_INTERVAL; | |
1169 return; | |
1170 } | |
1171 | |
1172 if (ONLY_INTERVAL_P (tree)) | |
1173 { | |
1174 tree->total_length -= length; | |
1175 return; | |
1176 } | |
1177 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1178 if (start > BEG + TOTAL_LENGTH (tree)) |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1179 start = BEG + TOTAL_LENGTH (tree); |
1157 | 1180 while (left_to_delete > 0) |
1181 { | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1182 left_to_delete -= interval_deletion_adjustment (tree, start - 1, |
1157 | 1183 left_to_delete); |
1184 tree = buffer->intervals; | |
1185 if (left_to_delete == tree->total_length) | |
1186 { | |
1187 buffer->intervals = NULL_INTERVAL; | |
1188 return; | |
1189 } | |
1190 } | |
1191 } | |
1192 | |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
3490
diff
changeset
|
1193 /* Make the adjustments necessary to the interval tree of BUFFER to |
1189 | 1194 represent an addition or deletion of LENGTH characters starting |
1195 at position START. Addition or deletion is indicated by the sign | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1196 of LENGTH. */ |
1157 | 1197 |
1198 INLINE void | |
1199 offset_intervals (buffer, start, length) | |
1200 struct buffer *buffer; | |
1201 int start, length; | |
1202 { | |
1203 if (NULL_INTERVAL_P (buffer->intervals) || length == 0) | |
1204 return; | |
1205 | |
1206 if (length > 0) | |
1207 adjust_intervals_for_insertion (buffer->intervals, start, length); | |
1208 else | |
1209 adjust_intervals_for_deletion (buffer, start, -length); | |
1210 } | |
1211 | 1211 |
1212 /* Merge interval I with its lexicographic successor. The resulting | |
1213 interval is returned, and has the properties of the original | |
1214 successor. The properties of I are lost. I is removed from the | |
1215 interval tree. | |
1157 | 1216 |
1211 | 1217 IMPORTANT: |
1218 The caller must verify that this is not the last (rightmost) | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1219 interval. */ |
1211 | 1220 |
1221 INTERVAL | |
1222 merge_interval_right (i) | |
1223 register INTERVAL i; | |
1224 { | |
1225 register int absorb = LENGTH (i); | |
1226 register INTERVAL successor; | |
1227 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1228 /* Zero out this interval. */ |
1211 | 1229 i->total_length -= absorb; |
1230 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1231 /* Find the succeeding interval. */ |
1211 | 1232 if (! NULL_RIGHT_CHILD (i)) /* It's below us. Add absorb |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1233 as we descend. */ |
1211 | 1234 { |
1235 successor = i->right; | |
1236 while (! NULL_LEFT_CHILD (successor)) | |
1237 { | |
1238 successor->total_length += absorb; | |
1239 successor = successor->left; | |
1240 } | |
1241 | |
1242 successor->total_length += absorb; | |
1243 delete_interval (i); | |
1244 return successor; | |
1245 } | |
1246 | |
1247 successor = i; | |
1248 while (! NULL_PARENT (successor)) /* It's above us. Subtract as | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1249 we ascend. */ |
1211 | 1250 { |
1251 if (AM_LEFT_CHILD (successor)) | |
1252 { | |
1253 successor = successor->parent; | |
1254 delete_interval (i); | |
1255 return successor; | |
1256 } | |
1257 | |
1258 successor = successor->parent; | |
1259 successor->total_length -= absorb; | |
1260 } | |
1261 | |
1262 /* This must be the rightmost or last interval and cannot | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1263 be merged right. The caller should have known. */ |
1211 | 1264 abort (); |
1265 } | |
1266 | |
1267 /* Merge interval I with its lexicographic predecessor. The resulting | |
1268 interval is returned, and has the properties of the original predecessor. | |
1269 The properties of I are lost. Interval node I is removed from the tree. | |
1270 | |
1271 IMPORTANT: | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1272 The caller must verify that this is not the first (leftmost) interval. */ |
1211 | 1273 |
1274 INTERVAL | |
1275 merge_interval_left (i) | |
1276 register INTERVAL i; | |
1277 { | |
1278 register int absorb = LENGTH (i); | |
1279 register INTERVAL predecessor; | |
1280 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1281 /* Zero out this interval. */ |
1211 | 1282 i->total_length -= absorb; |
1283 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1284 /* Find the preceding interval. */ |
1211 | 1285 if (! NULL_LEFT_CHILD (i)) /* It's below us. Go down, |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1286 adding ABSORB as we go. */ |
1211 | 1287 { |
1288 predecessor = i->left; | |
1289 while (! NULL_RIGHT_CHILD (predecessor)) | |
1290 { | |
1291 predecessor->total_length += absorb; | |
1292 predecessor = predecessor->right; | |
1293 } | |
1294 | |
1295 predecessor->total_length += absorb; | |
1296 delete_interval (i); | |
1297 return predecessor; | |
1298 } | |
1299 | |
1300 predecessor = i; | |
1301 while (! NULL_PARENT (predecessor)) /* It's above us. Go up, | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1302 subtracting ABSORB. */ |
1211 | 1303 { |
1304 if (AM_RIGHT_CHILD (predecessor)) | |
1305 { | |
1306 predecessor = predecessor->parent; | |
1307 delete_interval (i); | |
1308 return predecessor; | |
1309 } | |
1310 | |
1311 predecessor = predecessor->parent; | |
1312 predecessor->total_length -= absorb; | |
1313 } | |
1314 | |
1315 /* This must be the leftmost or first interval and cannot | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1316 be merged left. The caller should have known. */ |
1211 | 1317 abort (); |
1318 } | |
1319 | |
1189 | 1320 /* Make an exact copy of interval tree SOURCE which descends from |
1321 PARENT. This is done by recursing through SOURCE, copying | |
1322 the current interval and its properties, and then adjusting | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1323 the pointers of the copy. */ |
1189 | 1324 |
1157 | 1325 static INTERVAL |
1326 reproduce_tree (source, parent) | |
1327 INTERVAL source, parent; | |
1328 { | |
1329 register INTERVAL t = make_interval (); | |
1330 | |
1331 bcopy (source, t, INTERVAL_SIZE); | |
1332 copy_properties (source, t); | |
1333 t->parent = parent; | |
1334 if (! NULL_LEFT_CHILD (source)) | |
1335 t->left = reproduce_tree (source->left, t); | |
1336 if (! NULL_RIGHT_CHILD (source)) | |
1337 t->right = reproduce_tree (source->right, t); | |
1338 | |
1339 return t; | |
1340 } | |
1341 | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1342 #if 0 |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1343 /* Nobody calls this. Perhaps it's a vestige of an earlier design. */ |
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1344 |
1189 | 1345 /* Make a new interval of length LENGTH starting at START in the |
1346 group of intervals INTERVALS, which is actually an interval tree. | |
1347 Returns the new interval. | |
1348 | |
1349 Generate an error if the new positions would overlap an existing | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1350 interval. */ |
1189 | 1351 |
1157 | 1352 static INTERVAL |
1353 make_new_interval (intervals, start, length) | |
1354 INTERVAL intervals; | |
1355 int start, length; | |
1356 { | |
1357 INTERVAL slot; | |
1358 | |
1359 slot = find_interval (intervals, start); | |
1360 if (start + length > slot->position + LENGTH (slot)) | |
1361 error ("Interval would overlap"); | |
1362 | |
1363 if (start == slot->position && length == LENGTH (slot)) | |
1364 return slot; | |
1365 | |
1366 if (slot->position == start) | |
1367 { | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1368 /* New right node. */ |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1369 split_interval_right (slot, length); |
1157 | 1370 return slot; |
1371 } | |
1372 | |
1373 if (slot->position + LENGTH (slot) == start + length) | |
1374 { | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1375 /* New left node. */ |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1376 split_interval_left (slot, LENGTH (slot) - length); |
1157 | 1377 return slot; |
1378 } | |
1379 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1380 /* Convert interval SLOT into three intervals. */ |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1381 split_interval_left (slot, start - slot->position); |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1382 split_interval_right (slot, length); |
1157 | 1383 return slot; |
1384 } | |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1385 #endif |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1386 |
1211 | 1387 /* Insert the intervals of SOURCE into BUFFER at POSITION. |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1388 LENGTH is the length of the text in SOURCE. |
1157 | 1389 |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1390 This is used in insdel.c when inserting Lisp_Strings into the |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1391 buffer. The text corresponding to SOURCE is already in the buffer |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1392 when this is called. The intervals of new tree are a copy of those |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1393 belonging to the string being inserted; intervals are never |
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1394 shared. |
1157 | 1395 |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1396 If the inserted text had no intervals associated, and we don't |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1397 want to inherit the surrounding text's properties, this function |
1157 | 1398 simply returns -- offset_intervals should handle placing the |
1164 | 1399 text in the correct interval, depending on the sticky bits. |
1157 | 1400 |
1401 If the inserted text had properties (intervals), then there are two | |
1402 cases -- either insertion happened in the middle of some interval, | |
1403 or between two intervals. | |
1404 | |
1405 If the text goes into the middle of an interval, then new | |
1406 intervals are created in the middle with only the properties of | |
1407 the new text, *unless* the macro MERGE_INSERTIONS is true, in | |
1408 which case the new text has the union of its properties and those | |
1409 of the text into which it was inserted. | |
1410 | |
1411 If the text goes between two intervals, then if neither interval | |
1164 | 1412 had its appropriate sticky property set (front_sticky, rear_sticky), |
1413 the new text has only its properties. If one of the sticky properties | |
1157 | 1414 is set, then the new text "sticks" to that region and its properties |
3591
507f64624555
Apply typo patches from Paul Eggert.
Jim Blandy <jimb@redhat.com>
parents:
3490
diff
changeset
|
1415 depend on merging as above. If both the preceding and succeeding |
1164 | 1416 intervals to the new text are "sticky", then the new text retains |
1417 only its properties, as if neither sticky property were set. Perhaps | |
1157 | 1418 we should consider merging all three sets of properties onto the new |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1419 text... */ |
1157 | 1420 |
1421 void | |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1422 graft_intervals_into_buffer (source, position, length, buffer, inherit) |
1211 | 1423 INTERVAL source; |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1424 int position, length; |
1211 | 1425 struct buffer *buffer; |
4718
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1426 int inherit; |
1157 | 1427 { |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1428 register INTERVAL under, over, this, prev; |
1211 | 1429 register INTERVAL tree = buffer->intervals; |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1430 int middle; |
1157 | 1431 |
1432 /* If the new text has no properties, it becomes part of whatever | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1433 interval it was inserted into. */ |
1211 | 1434 if (NULL_INTERVAL_P (source)) |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1435 { |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1436 Lisp_Object buf; |
5250
63a865489a1e
(graft_intervals_into_buffer): If SOURCE is null
Richard M. Stallman <rms@gnu.org>
parents:
5173
diff
changeset
|
1437 if (!inherit && ! NULL_INTERVAL_P (tree)) |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1438 { |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1439 XSET (buf, Lisp_Buffer, buffer); |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1440 Fset_text_properties (make_number (position), |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1441 make_number (position + length), |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1442 Qnil, buf); |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1443 } |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
1444 if (! NULL_INTERVAL_P (buffer->intervals)) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
1445 buffer->intervals = balance_an_interval (buffer->intervals); |
5169
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1446 return; |
d040c1a8ccbe
(graft_intervals_into_buffer): New arg LENGTH.
Richard M. Stallman <rms@gnu.org>
parents:
4962
diff
changeset
|
1447 } |
1157 | 1448 |
1449 if (NULL_INTERVAL_P (tree)) | |
1450 { | |
1451 /* The inserted text constitutes the whole buffer, so | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1452 simply copy over the interval structure. */ |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1453 if ((BUF_Z (buffer) - BUF_BEG (buffer)) == TOTAL_LENGTH (source)) |
1157 | 1454 { |
4223
b044f6d3c4cb
(graft_intervals_into_buffer): When TREE is null,
Richard M. Stallman <rms@gnu.org>
parents:
4135
diff
changeset
|
1455 Lisp_Object buf; |
b044f6d3c4cb
(graft_intervals_into_buffer): When TREE is null,
Richard M. Stallman <rms@gnu.org>
parents:
4135
diff
changeset
|
1456 XSET (buf, Lisp_Buffer, buffer); |
b044f6d3c4cb
(graft_intervals_into_buffer): When TREE is null,
Richard M. Stallman <rms@gnu.org>
parents:
4135
diff
changeset
|
1457 buffer->intervals = reproduce_tree (source, buf); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1458 /* Explicitly free the old tree here. */ |
1157 | 1459 |
1460 return; | |
1461 } | |
1462 | |
1463 /* Create an interval tree in which to place a copy | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1464 of the intervals of the inserted string. */ |
1157 | 1465 { |
1307 | 1466 Lisp_Object buf; |
1467 XSET (buf, Lisp_Buffer, buffer); | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1468 tree = create_root_interval (buf); |
1157 | 1469 } |
1470 } | |
4718
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1471 else if (TOTAL_LENGTH (tree) == TOTAL_LENGTH (source)) |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1472 /* If the buffer contains only the new string, but |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1473 there was already some interval tree there, then it may be |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1474 some zero length intervals. Eventually, do something clever |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1475 about inserting properly. For now, just waste the old intervals. */ |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1476 { |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1477 buffer->intervals = reproduce_tree (source, tree->parent); |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1478 /* Explicitly free the old tree here. */ |
1157 | 1479 |
4718
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1480 return; |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1481 } |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1482 /* Paranoia -- the text has already been added, so this buffer |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1483 should be of non-zero length. */ |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1484 else if (TOTAL_LENGTH (tree) == 0) |
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1485 abort (); |
1157 | 1486 |
1487 this = under = find_interval (tree, position); | |
1488 if (NULL_INTERVAL_P (under)) /* Paranoia */ | |
1489 abort (); | |
1211 | 1490 over = find_interval (source, 1); |
1157 | 1491 |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1492 /* Here for insertion in the middle of an interval. |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1493 Split off an equivalent interval to the right, |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1494 then don't bother with it any more. */ |
1157 | 1495 |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1496 if (position > under->position) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1497 { |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1498 INTERVAL end_unchanged |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1499 = split_interval_left (this, position - under->position); |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1500 copy_properties (under, end_unchanged); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1501 under->position = position; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1502 prev = 0; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1503 middle = 1; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1504 } |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1505 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1506 { |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1507 prev = previous_interval (under); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1508 if (prev && !END_NONSTICKY_P (prev)) |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1509 prev = 0; |
1157 | 1510 } |
1511 | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1512 /* Insertion is now at beginning of UNDER. */ |
1157 | 1513 |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1514 /* The inserted text "sticks" to the interval `under', |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1515 which means it gets those properties. |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1516 The properties of under are the result of |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1517 adjust_intervals_for_insertion, so stickyness has |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1518 already been taken care of. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1519 |
1157 | 1520 while (! NULL_INTERVAL_P (over)) |
1521 { | |
5666
ceed2e32b303
(graft_intervals_into_buffer): Fix one-off
Richard M. Stallman <rms@gnu.org>
parents:
5415
diff
changeset
|
1522 if (LENGTH (over) < LENGTH (under)) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1523 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1524 this = split_interval_left (under, LENGTH (over)); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1525 copy_properties (under, this); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1526 } |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1527 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1528 this = under; |
1157 | 1529 copy_properties (over, this); |
4718
a05b833e61c4
(graft_intervals_into_buffer): New arg INHERIT.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
1530 if (inherit) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1531 merge_properties (over, this); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1532 else |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1533 copy_properties (over, this); |
1157 | 1534 over = next_interval (over); |
1535 } | |
1536 | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
1537 if (! NULL_INTERVAL_P (buffer->intervals)) |
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
1538 buffer->intervals = balance_an_interval (buffer->intervals); |
1157 | 1539 return; |
1540 } | |
1541 | |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1542 /* Get the value of property PROP from PLIST, |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1543 which is the plist of an interval. |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1544 We check for direct properties and for categories with property PROP. */ |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1545 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1546 Lisp_Object |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1547 textget (plist, prop) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1548 Lisp_Object plist; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1549 register Lisp_Object prop; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1550 { |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1551 register Lisp_Object tail, fallback; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1552 fallback = Qnil; |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1553 |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1554 for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail))) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1555 { |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1556 register Lisp_Object tem; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1557 tem = Fcar (tail); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1558 if (EQ (prop, tem)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1559 return Fcar (Fcdr (tail)); |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1560 if (EQ (tem, Qcategory)) |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1561 fallback = Fget (Fcar (Fcdr (tail)), prop); |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1562 } |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1563 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1564 return fallback; |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1565 } |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1566 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1567 /* Get the value of property PROP from PLIST, |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1568 which is the plist of an interval. |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1569 We check for direct properties only! */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1570 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1571 Lisp_Object |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1572 textget_direct (plist, prop) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1573 Lisp_Object plist; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1574 register Lisp_Object prop; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1575 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1576 register Lisp_Object tail; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1577 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1578 for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail))) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1579 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1580 if (EQ (prop, Fcar (tail))) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1581 return Fcar (Fcdr (tail)); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1582 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1583 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1584 return Qnil; |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1585 } |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1586 |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1587 /* Set point in BUFFER to POSITION. If the target position is |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1588 before an invisible character which is not displayed with a special glyph, |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1589 move back to an ok place to display. */ |
1157 | 1590 |
1591 void | |
1592 set_point (position, buffer) | |
1593 register int position; | |
1594 register struct buffer *buffer; | |
1595 { | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1596 register INTERVAL to, from, toprev, fromprev, target; |
1157 | 1597 int buffer_point; |
1598 register Lisp_Object obj; | |
1599 int backwards = (position < BUF_PT (buffer)) ? 1 : 0; | |
1211 | 1600 int old_position = buffer->text.pt; |
1157 | 1601 |
1602 if (position == buffer->text.pt) | |
1603 return; | |
1604 | |
2779
857bb0f59668
* intervals.c (set_point): Check for point out of bounds before
Jim Blandy <jimb@redhat.com>
parents:
2090
diff
changeset
|
1605 /* Check this now, before checking if the buffer has any intervals. |
857bb0f59668
* intervals.c (set_point): Check for point out of bounds before
Jim Blandy <jimb@redhat.com>
parents:
2090
diff
changeset
|
1606 That way, we can catch conditions which break this sanity check |
857bb0f59668
* intervals.c (set_point): Check for point out of bounds before
Jim Blandy <jimb@redhat.com>
parents:
2090
diff
changeset
|
1607 whether or not there are intervals in the buffer. */ |
857bb0f59668
* intervals.c (set_point): Check for point out of bounds before
Jim Blandy <jimb@redhat.com>
parents:
2090
diff
changeset
|
1608 if (position > BUF_Z (buffer) || position < BUF_BEG (buffer)) |
857bb0f59668
* intervals.c (set_point): Check for point out of bounds before
Jim Blandy <jimb@redhat.com>
parents:
2090
diff
changeset
|
1609 abort (); |
857bb0f59668
* intervals.c (set_point): Check for point out of bounds before
Jim Blandy <jimb@redhat.com>
parents:
2090
diff
changeset
|
1610 |
1157 | 1611 if (NULL_INTERVAL_P (buffer->intervals)) |
1612 { | |
1613 buffer->text.pt = position; | |
1614 return; | |
1615 } | |
1616 | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1617 /* Set TO to the interval containing the char after POSITION, |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1618 and TOPREV to the interval containing the char before POSITION. |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1619 Either one may be null. They may be equal. */ |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1620 to = find_interval (buffer->intervals, position); |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1621 if (position == BUF_BEGV (buffer)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1622 toprev = 0; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1623 else if (to->position == position) |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1624 toprev = previous_interval (to); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1625 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1626 toprev = to; |
1211 | 1627 |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1628 buffer_point = (BUF_PT (buffer) == BUF_ZV (buffer) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1629 ? BUF_ZV (buffer) - 1 |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1630 : BUF_PT (buffer)); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1631 |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1632 /* Set FROM to the interval containing the char after PT, |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1633 and FROMPREV to the interval containing the char before PT. |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1634 Either one may be null. They may be equal. */ |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1635 /* We could cache this and save time. */ |
1157 | 1636 from = find_interval (buffer->intervals, buffer_point); |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1637 if (buffer_point == BUF_BEGV (buffer)) |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1638 fromprev = 0; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1639 else if (from->position == BUF_PT (buffer)) |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1640 fromprev = previous_interval (from); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1641 else if (buffer_point != BUF_PT (buffer)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1642 fromprev = from, from = 0; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1643 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1644 fromprev = from; |
1157 | 1645 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1646 /* Moving within an interval. */ |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1647 if (to == from && toprev == fromprev && INTERVAL_VISIBLE_P (to)) |
1157 | 1648 { |
1649 buffer->text.pt = position; | |
1650 return; | |
1651 } | |
1652 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1653 /* If the new position is before an invisible character |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1654 that has an `invisible' property of value `hidden', |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1655 move forward over all such. */ |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1656 while (! NULL_INTERVAL_P (to) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1657 && EQ (textget (to->plist, Qinvisible), Qhidden) |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1658 && ! DISPLAY_INVISIBLE_GLYPH (to)) |
1157 | 1659 { |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1660 toprev = to; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1661 to = next_interval (to); |
3734
5ada670e1fd8
(set_point): When moving over invis chars,
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
1662 if (NULL_INTERVAL_P (to)) |
5ada670e1fd8
(set_point): When moving over invis chars,
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
1663 position = BUF_ZV (buffer); |
5ada670e1fd8
(set_point): When moving over invis chars,
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
1664 else |
5ada670e1fd8
(set_point): When moving over invis chars,
Richard M. Stallman <rms@gnu.org>
parents:
3591
diff
changeset
|
1665 position = to->position; |
1157 | 1666 } |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1667 |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1668 buffer->text.pt = position; |
1157 | 1669 |
1288 | 1670 /* We run point-left and point-entered hooks here, iff the |
1671 two intervals are not equivalent. These hooks take | |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1672 (old_point, new_point) as arguments. */ |
4243
23fe7f6c9ae4
(set_point): Test Vinhibit_point_motion_hooks.
Richard M. Stallman <rms@gnu.org>
parents:
4223
diff
changeset
|
1673 if (NILP (Vinhibit_point_motion_hooks) |
23fe7f6c9ae4
(set_point): Test Vinhibit_point_motion_hooks.
Richard M. Stallman <rms@gnu.org>
parents:
4223
diff
changeset
|
1674 && (! intervals_equal (from, to) |
23fe7f6c9ae4
(set_point): Test Vinhibit_point_motion_hooks.
Richard M. Stallman <rms@gnu.org>
parents:
4223
diff
changeset
|
1675 || ! intervals_equal (fromprev, toprev))) |
1211 | 1676 { |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1677 Lisp_Object leave_after, leave_before, enter_after, enter_before; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1678 |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1679 if (fromprev) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1680 leave_after = textget (fromprev->plist, Qpoint_left); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1681 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1682 leave_after = Qnil; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1683 if (from) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1684 leave_before = textget (from->plist, Qpoint_left); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1685 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1686 leave_before = Qnil; |
1211 | 1687 |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1688 if (toprev) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1689 enter_after = textget (toprev->plist, Qpoint_entered); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1690 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1691 enter_after = Qnil; |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1692 if (to) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1693 enter_before = textget (to->plist, Qpoint_entered); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1694 else |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1695 enter_before = Qnil; |
1211 | 1696 |
1964
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1697 if (! EQ (leave_before, enter_before) && !NILP (leave_before)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1698 call2 (leave_before, old_position, position); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1699 if (! EQ (leave_after, enter_after) && !NILP (leave_after)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1700 call2 (leave_after, old_position, position); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1701 |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1702 if (! EQ (enter_before, leave_before) && !NILP (enter_before)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1703 call2 (enter_before, old_position, position); |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1704 if (! EQ (enter_after, leave_after) && !NILP (enter_after)) |
e6c49ff3a53c
(intervals_equal): Handle one arg null and other not.
Richard M. Stallman <rms@gnu.org>
parents:
1958
diff
changeset
|
1705 call2 (enter_after, old_position, position); |
1211 | 1706 } |
1157 | 1707 } |
1708 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1709 /* Set point temporarily, without checking any text properties. */ |
1157 | 1710 |
1211 | 1711 INLINE void |
1712 temp_set_point (position, buffer) | |
1713 int position; | |
1714 struct buffer *buffer; | |
1715 { | |
1716 buffer->text.pt = position; | |
1717 } | |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1718 |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1719 /* Return the proper local map for position POSITION in BUFFER. |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1720 Use the map specified by the local-map property, if any. |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1721 Otherwise, use BUFFER's local map. */ |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1722 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1723 Lisp_Object |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1724 get_local_map (position, buffer) |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1725 register int position; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1726 register struct buffer *buffer; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1727 { |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1728 register INTERVAL interval; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1729 Lisp_Object prop, tem; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1730 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1731 if (NULL_INTERVAL_P (buffer->intervals)) |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1732 return current_buffer->keymap; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1733 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1734 /* Perhaps we should just change `position' to the limit. */ |
2090
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1735 if (position > BUF_Z (buffer) || position < BUF_BEG (buffer)) |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1736 abort (); |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1737 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1738 interval = find_interval (buffer->intervals, position); |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1739 prop = textget (interval->plist, Qlocal_map); |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1740 if (NILP (prop)) |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1741 return current_buffer->keymap; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1742 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1743 /* Use the local map only if it is valid. */ |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1744 tem = Fkeymapp (prop); |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1745 if (!NILP (tem)) |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1746 return prop; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1747 |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1748 return current_buffer->keymap; |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1749 } |
c7e1308a7184
(set_point): Check invisibility of following character, not previous character.
Richard M. Stallman <rms@gnu.org>
parents:
2052
diff
changeset
|
1750 |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1751 /* Call the modification hook functions in LIST, each with START and END. */ |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1752 |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1753 static void |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1754 call_mod_hooks (list, start, end) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1755 Lisp_Object list, start, end; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1756 { |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1757 struct gcpro gcpro1; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1758 GCPRO1 (list); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1759 while (!NILP (list)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1760 { |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1761 call2 (Fcar (list), start, end); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1762 list = Fcdr (list); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1763 } |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1764 UNGCPRO; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1765 } |
1211 | 1766 |
1767 /* Check for read-only intervals and signal an error if we find one. | |
1768 Then check for any modification hooks in the range START up to | |
1769 (but not including) TO. Create a list of all these hooks in | |
1770 lexicographic order, eliminating consecutive extra copies of the | |
1771 same hook. Then call those hooks in order, with START and END - 1 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1772 as arguments. */ |
1157 | 1773 |
1774 void | |
1775 verify_interval_modification (buf, start, end) | |
1776 struct buffer *buf; | |
1777 int start, end; | |
1778 { | |
1779 register INTERVAL intervals = buf->intervals; | |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1780 register INTERVAL i, prev; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1781 Lisp_Object hooks; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1782 register Lisp_Object prev_mod_hooks; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1783 Lisp_Object mod_hooks; |
1211 | 1784 struct gcpro gcpro1; |
1157 | 1785 |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1786 hooks = Qnil; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1787 prev_mod_hooks = Qnil; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1788 mod_hooks = Qnil; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1789 |
1157 | 1790 if (NULL_INTERVAL_P (intervals)) |
1791 return; | |
1792 | |
1793 if (start > end) | |
1794 { | |
1795 int temp = start; | |
1796 start = end; | |
1797 end = temp; | |
1798 } | |
1799 | |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1800 /* For an insert operation, check the two chars around the position. */ |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1801 if (start == end) |
1157 | 1802 { |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1803 INTERVAL prev; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1804 Lisp_Object before, after; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1805 |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1806 /* Set I to the interval containing the char after START, |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1807 and PREV to the interval containing the char before START. |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1808 Either one may be null. They may be equal. */ |
4005
da8962f65741
* intervals.c (find_interval): Doc fixes, computation of
Jim Blandy <jimb@redhat.com>
parents:
3998
diff
changeset
|
1809 i = find_interval (intervals, start); |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1810 |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1811 if (start == BUF_BEGV (buf)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1812 prev = 0; |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1813 else if (i->position == start) |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1814 prev = previous_interval (i); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1815 else if (i->position < start) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1816 prev = i; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1817 if (start == BUF_ZV (buf)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1818 i = 0; |
1157 | 1819 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1820 /* If Vinhibit_read_only is set and is not a list, we can |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1821 skip the read_only checks. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1822 if (NILP (Vinhibit_read_only) || CONSP (Vinhibit_read_only)) |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1823 { |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1824 /* If I and PREV differ we need to check for the read-only |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1825 property together with its stickyness. If either I or |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1826 PREV are 0, this check is all we need. |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1827 We have to take special care, since read-only may be |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1828 indirectly defined via the category property. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1829 if (i != prev) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1830 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1831 if (! NULL_INTERVAL_P (i)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1832 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1833 after = textget (i->plist, Qread_only); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1834 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1835 /* If interval I is read-only and read-only is |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1836 front-sticky, inhibit insertion. |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1837 Check for read-only as well as category. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1838 if (! NILP (after) |
5780
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1839 && NILP (Fmemq (after, Vinhibit_read_only))) |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1840 { |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1841 Lisp_Object tem; |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1842 |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1843 tem = textget (i->plist, Qfront_sticky); |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1844 if (TMEM (Qread_only, tem) |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1845 || (NILP (textget_direct (i->plist, Qread_only)) |
5780
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1846 && TMEM (Qcategory, tem))) |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1847 error ("Attempt to insert within read-only text"); |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1848 } |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1849 } |
6541
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1850 |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1851 if (! NULL_INTERVAL_P (prev)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1852 { |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1853 before = textget (prev->plist, Qread_only); |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1854 |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1855 /* If interval PREV is read-only and read-only isn't |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1856 rear-nonsticky, inhibit insertion. |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1857 Check for read-only as well as category. */ |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1858 if (! NILP (before) |
5780
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1859 && NILP (Fmemq (before, Vinhibit_read_only))) |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1860 { |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1861 Lisp_Object tem; |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1862 |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1863 tem = textget (prev->plist, Qrear_nonsticky); |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1864 if (! TMEM (Qread_only, tem) |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1865 && (! NILP (textget_direct (prev->plist,Qread_only)) |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1866 || ! TMEM (Qcategory, tem))) |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1867 error ("Attempt to insert within read-only text"); |
07449eefd453
(verify_interval_modification): When checking read-only, allow for the case
Karl Heuer <kwzh@gnu.org>
parents:
5768
diff
changeset
|
1868 } |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1869 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1870 } |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1871 else if (! NULL_INTERVAL_P (i)) |
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1872 { |
6541
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1873 after = textget (i->plist, Qread_only); |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1874 |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1875 /* If interval I is read-only and read-only is |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1876 front-sticky, inhibit insertion. |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1877 Check for read-only as well as category. */ |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1878 if (! NILP (after) && NILP (Fmemq (after, Vinhibit_read_only))) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1879 { |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1880 Lisp_Object tem; |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1881 |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1882 tem = textget (i->plist, Qfront_sticky); |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1883 if (TMEM (Qread_only, tem) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1884 || (NILP (textget_direct (i->plist, Qread_only)) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1885 && TMEM (Qcategory, tem))) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1886 error ("Attempt to insert within read-only text"); |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1887 |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1888 tem = textget (prev->plist, Qrear_nonsticky); |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1889 if (! TMEM (Qread_only, tem) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1890 && (! NILP (textget_direct (prev->plist, Qread_only)) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1891 || ! TMEM (Qcategory, tem))) |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1892 error ("Attempt to insert within read-only text"); |
e42af7949b19
(verify_interval_modification): For insertion in
Richard M. Stallman <rms@gnu.org>
parents:
6501
diff
changeset
|
1893 } |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1894 } |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1895 } |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1896 |
4066
bb9478383bde
(verify_interval_modification):
Richard M. Stallman <rms@gnu.org>
parents:
4005
diff
changeset
|
1897 /* Run both insert hooks (just once if they're the same). */ |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1898 if (!NULL_INTERVAL_P (prev)) |
4080
8200d631e3f3
(verify_interval_modification): Use Qinsert_in_front_hooks and
Richard M. Stallman <rms@gnu.org>
parents:
4066
diff
changeset
|
1899 prev_mod_hooks = textget (prev->plist, Qinsert_behind_hooks); |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1900 if (!NULL_INTERVAL_P (i)) |
4080
8200d631e3f3
(verify_interval_modification): Use Qinsert_in_front_hooks and
Richard M. Stallman <rms@gnu.org>
parents:
4066
diff
changeset
|
1901 mod_hooks = textget (i->plist, Qinsert_in_front_hooks); |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1902 GCPRO1 (mod_hooks); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1903 if (! NILP (prev_mod_hooks)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1904 call_mod_hooks (prev_mod_hooks, make_number (start), |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1905 make_number (end)); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1906 UNGCPRO; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1907 if (! NILP (mod_hooks) && ! EQ (mod_hooks, prev_mod_hooks)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1908 call_mod_hooks (mod_hooks, make_number (start), make_number (end)); |
1157 | 1909 } |
1910 else | |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1911 { |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1912 /* Loop over intervals on or next to START...END, |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1913 collecting their hooks. */ |
1157 | 1914 |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1915 i = find_interval (intervals, start); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1916 do |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1917 { |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1918 if (! INTERVAL_WRITABLE_P (i)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1919 error ("Attempt to modify read-only text"); |
1211 | 1920 |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1921 mod_hooks = textget (i->plist, Qmodification_hooks); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1922 if (! NILP (mod_hooks) && ! EQ (mod_hooks, prev_mod_hooks)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1923 { |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1924 hooks = Fcons (mod_hooks, hooks); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1925 prev_mod_hooks = mod_hooks; |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1926 } |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1927 |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1928 i = next_interval (i); |
1211 | 1929 } |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1930 /* Keep going thru the interval containing the char before END. */ |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1931 while (! NULL_INTERVAL_P (i) && i->position < end); |
1157 | 1932 |
2052
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1933 GCPRO1 (hooks); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1934 hooks = Fnreverse (hooks); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1935 while (! EQ (hooks, Qnil)) |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1936 { |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1937 call_mod_hooks (Fcar (hooks), make_number (start), |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1938 make_number (end)); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1939 hooks = Fcdr (hooks); |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1940 } |
48c83a34c005
(verify_interval_modification): Handle insertions
Richard M. Stallman <rms@gnu.org>
parents:
1964
diff
changeset
|
1941 UNGCPRO; |
1211 | 1942 } |
1157 | 1943 } |
1944 | |
1211 | 1945 /* Produce an interval tree reflecting the intervals in |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1946 TREE from START to START + LENGTH. */ |
1157 | 1947 |
1316
f09c5c6563b8
* intervals.c: `copy_intervals()' no longer static.
Joseph Arceneaux <jla@gnu.org>
parents:
1307
diff
changeset
|
1948 INTERVAL |
1157 | 1949 copy_intervals (tree, start, length) |
1950 INTERVAL tree; | |
1951 int start, length; | |
1952 { | |
1953 register INTERVAL i, new, t; | |
3490
07b454ddc666
(copy_intervals): Don't adjust total_length at the end.
Richard M. Stallman <rms@gnu.org>
parents:
3333
diff
changeset
|
1954 register int got, prevlen; |
1157 | 1955 |
1956 if (NULL_INTERVAL_P (tree) || length <= 0) | |
1957 return NULL_INTERVAL; | |
1958 | |
1959 i = find_interval (tree, start); | |
1960 if (NULL_INTERVAL_P (i) || LENGTH (i) == 0) | |
1961 abort (); | |
1962 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1963 /* If there is only one interval and it's the default, return nil. */ |
1157 | 1964 if ((start - i->position + 1 + length) < LENGTH (i) |
1965 && DEFAULT_INTERVAL_P (i)) | |
1966 return NULL_INTERVAL; | |
1967 | |
1968 new = make_interval (); | |
1969 new->position = 1; | |
1970 got = (LENGTH (i) - (start - i->position)); | |
1211 | 1971 new->total_length = length; |
1157 | 1972 copy_properties (i, new); |
1973 | |
1974 t = new; | |
3490
07b454ddc666
(copy_intervals): Don't adjust total_length at the end.
Richard M. Stallman <rms@gnu.org>
parents:
3333
diff
changeset
|
1975 prevlen = got; |
1157 | 1976 while (got < length) |
1977 { | |
1978 i = next_interval (i); | |
4135
84ea8ebc9858
* intervals.c (split_interval_left, split_interval_right): Change
Jim Blandy <jimb@redhat.com>
parents:
4080
diff
changeset
|
1979 t = split_interval_right (t, prevlen); |
1157 | 1980 copy_properties (i, t); |
3490
07b454ddc666
(copy_intervals): Don't adjust total_length at the end.
Richard M. Stallman <rms@gnu.org>
parents:
3333
diff
changeset
|
1981 prevlen = LENGTH (i); |
07b454ddc666
(copy_intervals): Don't adjust total_length at the end.
Richard M. Stallman <rms@gnu.org>
parents:
3333
diff
changeset
|
1982 got += prevlen; |
1157 | 1983 } |
1984 | |
5415
95882472f2da
(rotate_right, rotate_left): Simplify
Richard M. Stallman <rms@gnu.org>
parents:
5250
diff
changeset
|
1985 return balance_an_interval (new); |
1157 | 1986 } |
1987 | |
4383
d4a36c1669e6
(adjust_intervals_for_insertion): Handle insertion
Richard M. Stallman <rms@gnu.org>
parents:
4243
diff
changeset
|
1988 /* Give STRING the properties of BUFFER from POSITION to LENGTH. */ |
1157 | 1989 |
1288 | 1990 INLINE void |
1157 | 1991 copy_intervals_to_string (string, buffer, position, length) |
1992 Lisp_Object string, buffer; | |
1993 int position, length; | |
1994 { | |
1995 INTERVAL interval_copy = copy_intervals (XBUFFER (buffer)->intervals, | |
1996 position, length); | |
1997 if (NULL_INTERVAL_P (interval_copy)) | |
1998 return; | |
1999 | |
2000 interval_copy->parent = (INTERVAL) string; | |
2001 XSTRING (string)->intervals = interval_copy; | |
2002 } | |
1301
5a27062b8b7f
* intervals.c: Conditionalize all functions on
Joseph Arceneaux <jla@gnu.org>
parents:
1288
diff
changeset
|
2003 |
5a27062b8b7f
* intervals.c: Conditionalize all functions on
Joseph Arceneaux <jla@gnu.org>
parents:
1288
diff
changeset
|
2004 #endif /* USE_TEXT_PROPERTIES */ |