1 /* Buffer insertion/deletion and gap motion for XEmacs.
2 Copyright (C) 1985, 1986, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
4 Copyright (C) 1995 Sun Microsystems, Inc.
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: Mule 2.0, FSF 19.30. Diverges significantly. */
25 /* This file has been Mule-ized. */
27 /* Overhauled by Ben Wing, December 1994, for Mule implementation. */
30 There are three possible ways to specify positions in a buffer. All
31 of these are one-based: the beginning of the buffer is position or
32 index 1, and 0 is not a valid position.
34 As a "buffer position" (typedef Bufpos):
36 This is an index specifying an offset in characters from the
37 beginning of the buffer. Note that buffer positions are
38 logically *between* characters, not on a character. The
39 difference between two buffer positions specifies the number of
40 characters between those positions. Buffer positions are the
41 only kind of position externally visible to the user.
43 As a "byte index" (typedef Bytind):
45 This is an index over the bytes used to represent the characters
46 in the buffer. If there is no Mule support, this is identical
47 to a buffer position, because each character is represented
48 using one byte. However, with Mule support, many characters
49 require two or more bytes for their representation, and so a
50 byte index may be greater than the corresponding buffer
53 As a "memory index" (typedef Memind):
55 This is the byte index adjusted for the gap. For positions
56 before the gap, this is identical to the byte index. For
57 positions after the gap, this is the byte index plus the gap
58 size. There are two possible memory indices for the gap
59 position; the memory index at the beginning of the gap should
60 always be used, except in code that deals with manipulating the
61 gap, where both indices may be seen. The address of the
62 character "at" (i.e. following) a particular position can be
63 obtained from the formula
65 buffer_start_address + memory_index(position) - 1
67 except in the case of characters at the gap position.
74 This typedef represents a single Emacs character, which can be
75 ASCII, ISO-8859, or some extended character, as would typically
76 be used for Kanji. Note that the representation of a character
77 as an Emchar is *not* the same as the representation of that
78 same character in a string; thus, you cannot do the standard
79 C trick of passing a pointer to a character to a function that
82 An Emchar takes up 19 bits of representation and (for code
83 compatibility and such) is compatible with an int. This
84 representation is visible on the Lisp level. The important
85 characteristics of the Emchar representation are
87 -- values 0x00 - 0x7f represent ASCII.
88 -- values 0x80 - 0xff represent the right half of ISO-8859-1.
89 -- values 0x100 and up represent all other characters.
91 This means that Emchar values are upwardly compatible with
92 the standard 8-bit representation of ASCII/ISO-8859-1.
96 The data in a buffer or string is logically made up of Bufbyte
97 objects, where a Bufbyte takes up the same amount of space as a
98 char. (It is declared differently, though, to catch invalid
99 usages.) Strings stored using Bufbytes are said to be in
100 "internal format". The important characteristics of internal
103 -- ASCII characters are represented as a single Bufbyte,
104 in the range 0 - 0x7f.
105 -- All other characters are represented as a Bufbyte in
106 the range 0x80 - 0x9f followed by one or more Bufbytes
107 in the range 0xa0 to 0xff.
109 This leads to a number of desirable properties:
111 -- Given the position of the beginning of a character,
112 you can find the beginning of the next or previous
113 character in constant time.
114 -- When searching for a substring or an ASCII character
115 within the string, you need merely use standard
120 Strings that go in or out of Emacs are in "external format",
121 typedef'ed as an array of char or a char *. There is more
122 than one external format (JIS, EUC, etc.) but they all
123 have similar properties. They are modal encodings,
124 which is to say that the meaning of particular bytes is
125 not fixed but depends on what "mode" the string is currently
126 in (e.g. bytes in the range 0 - 0x7f might be
127 interpreted as ASCII, or as Hiragana, or as 2-byte Kanji,
128 depending on the current mode). The mode starts out in
129 ASCII/ISO-8859-1 and is switched using escape sequences --
130 for example, in the JIS encoding, 'ESC $ B' switches to a
131 mode where pairs of bytes in the range 0 - 0x7f
132 are interpreted as Kanji characters.
134 External-formatted data is generally desirable for passing
135 data between programs because it is upwardly compatible
136 with standard ASCII/ISO-8859-1 strings and may require
137 less space than internal encodings such as the one
138 described above. In addition, some encodings (e.g. JIS)
139 keep all characters (except the ESC used to switch modes)
140 in the printing ASCII range 0x20 - 0x7e, which results in
141 a much higher probability that the data will avoid being
142 garbled in transmission. Externally-formatted data is
143 generally not very convenient to work with, however, and
144 for this reason is usually converted to internal format
145 before any work is done on the string.
147 NOTE: filenames need to be in external format so that
148 ISO-8859-1 characters come out correctly.
152 This typedef represents a count of characters, such as
153 a character offset into a string or the number of
154 characters between two positions in a buffer. The
155 difference between two Bufpos's is a Charcount, and
156 character positions in a string are represented using
161 Similar to a Charcount but represents a count of bytes.
162 The difference between two Bytind's is a Bytecount.
165 Usage of the various representations:
166 =====================================
168 Memory indices are used in low-level functions in insdel.c and for
169 extent endpoints and marker positions. The reason for this is that
170 this way, the extents and markers don't need to be updated for most
171 insertions, which merely shrink the gap and don't move any
172 characters around in memory.
174 (The beginning-of-gap memory index simplifies insertions w.r.t.
175 markers, because text usually gets inserted after markers. For
176 extents, it is merely for consistency, because text can get
177 inserted either before or after an extent's endpoint depending on
178 the open/closedness of the endpoint.)
180 Byte indices are used in other code that needs to be fast,
181 such as the searching, redisplay, and extent-manipulation code.
183 Buffer positions are used in all other code. This is because this
184 representation is easiest to work with (especially since Lisp
185 code always uses buffer positions), necessitates the fewest
186 changes to existing code, and is the safest (e.g. if the text gets
187 shifted underneath a buffer position, it will still point to a
188 character; if text is shifted under a byte index, it might point
189 to the middle of a character, which would be bad).
191 Similarly, Charcounts are used in all code that deals with strings
192 except for code that needs to be fast, which used Bytecounts.
194 Strings are always passed around internally using internal format.
195 Conversions between external format are performed at the time
196 that the data goes in or out of Emacs.
198 Working with the various representations:
199 ========================================= */
211 #include "redisplay.h"
212 #include "line-number.h"
214 /* We write things this way because it's very important the
215 MAX_BYTIND_GAP_SIZE_3 is a multiple of 3. (As it happens,
216 65535 is a multiple of 3, but this may not always be the
219 #define MAX_BUFPOS_GAP_SIZE_3 (65535/3)
220 #define MAX_BYTIND_GAP_SIZE_3 (3 * MAX_BUFPOS_GAP_SIZE_3)
222 short three_to_one_table[1 + MAX_BYTIND_GAP_SIZE_3];
224 /* Various macros modelled along the lines of those in buffer.h.
225 Purposefully omitted from buffer.h because files other than this
226 one should not be using them. */
228 /* Address of beginning of buffer. This is an lvalue because
229 BUFFER_ALLOC needs it to be. */
230 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
232 /* Set the address of beginning of buffer. */
233 #define SET_BUF_BEG_ADDR(buf, addr) do { (buf)->text->beg = (addr); } while (0)
236 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size + 0)
237 #define BUF_END_GAP_SIZE(buf) ((buf)->text->end_gap_size + 0)
239 #define SET_BUF_GAP_SIZE(buf, value) \
240 do { (buf)->text->gap_size = (value); } while (0)
241 #define SET_BUF_END_GAP_SIZE(buf, value) \
242 do { (buf)->text->end_gap_size = (value); } while (0)
245 #define BI_BUF_GPT(buf) ((buf)->text->gpt + 0)
246 #define BUF_GPT_ADDR(buf) (BUF_BEG_ADDR (buf) + BI_BUF_GPT (buf) - 1)
248 /* Set gap location. */
249 #define SET_BI_BUF_GPT(buf, value) do { (buf)->text->gpt = (value); } while (0)
251 /* Set end of buffer. */
252 #define SET_BOTH_BUF_Z(buf, val, bival) \
255 (buf)->text->z = (bival); \
256 (buf)->text->bufz = (val); \
259 /* Under Mule, we maintain two sentinels in the buffer: one at the
260 beginning of the gap, and one at the end of the buffer. This
261 allows us to move forward, examining bytes looking for the
262 end of a character, and not worry about running off the end.
263 We do not need corresponding sentinels when moving backwards
264 because we do not have to look past the beginning of a character
265 to find the beginning of the character.
267 Every time we change the beginning of the gap, we have to
268 call SET_GAP_SENTINEL().
270 Every time we change the total size (characters plus gap)
271 of the buffer, we have to call SET_END_SENTINEL().
276 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len) + 1)
277 # define SET_GAP_SENTINEL(buf) (*BUF_GPT_ADDR (buf) = 0)
278 # define BUF_END_SENTINEL_SIZE 1
279 # define SET_END_SENTINEL(buf) \
280 (*(BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + BI_BUF_Z (buf) - 1) = 0)
282 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len))
283 # define SET_GAP_SENTINEL(buf)
284 # define BUF_END_SENTINEL_SIZE 0
285 # define SET_END_SENTINEL(buf)
289 /************************************************************************/
290 /* Charcount/Bytecount conversion */
291 /************************************************************************/
293 /* Optimization. Do it. Live it. Love it. */
297 /* We include the basic functions here that require no specific
298 knowledge of how data is Mule-encoded into a buffer other
299 than the basic (00 - 7F), (80 - 9F), (A0 - FF) scheme.
300 Anything that requires more specific knowledge goes into
303 /* Given a pointer to a text string and a length in bytes, return
304 the equivalent length in characters. */
307 bytecount_to_charcount (CONST Bufbyte *ptr, Bytecount len)
310 CONST Bufbyte *end = ptr + len;
312 #if (LONGBITS == 32 || LONGBITS == 64)
314 # if (LONGBITS == 32)
315 # define LONG_BYTES 4
316 # define ALIGN_MASK 0xFFFFFFFCU
317 # define HIGH_BIT_MASK 0x80808080U
319 # define LONG_BYTES 8
320 # define ALIGN_MASK 0xFFFFFFFFFFFFFFF8UL
321 /* I had a dream, I was being overrun with early Intel processors ... */
322 # define HIGH_BIT_MASK 0x8080808080808080UL
325 /* When we have a large number of bytes to scan, we can be trickier
326 and significantly faster by scanning them in chunks of the CPU word
327 size (assuming that they're all ASCII -- we cut out as soon as
328 we find something non-ASCII). */
331 /* Determine the section in the middle of the string that's
332 amenable to this treatment. Everything has to be aligned
333 on CPU word boundaries. */
334 CONST Bufbyte *aligned_ptr =
335 (CONST Bufbyte *) (((unsigned long) (ptr + LONG_BYTES - 1)) &
337 CONST Bufbyte *aligned_end =
338 (CONST Bufbyte *) (((unsigned long) end) & ALIGN_MASK);
340 /* Handle unaligned stuff at the beginning. */
341 while (ptr < aligned_ptr)
343 if (!BYTE_ASCII_P (*ptr))
348 while (ptr < aligned_end)
351 if ((* (unsigned long *) ptr) & HIGH_BIT_MASK)
358 #endif /* LONGBITS == 32 || LONGBITS == 64 */
366 #ifdef ERROR_CHECK_BUFPOS
367 /* Bomb out if the specified substring ends in the middle
368 of a character. Note that we might have already gotten
369 a core dump above from an invalid reference, but at least
370 we will get no farther than here. */
377 /* Given a pointer to a text string and a length in characters, return
378 the equivalent length in bytes. */
381 charcount_to_bytecount (CONST Bufbyte *ptr, Charcount len)
383 CONST Bufbyte *newptr = ptr;
387 INC_CHARPTR (newptr);
393 /* The next two functions are the actual meat behind the
394 bufpos-to-bytind and bytind-to-bufpos conversions. Currently
395 the method they use is fairly unsophisticated; see buffer.h.
397 Note that bufpos_to_bytind_func() is probably the most-called
398 function in all of XEmacs. Therefore, it must be FAST FAST FAST.
399 This is the reason why so much of the code is duplicated.
401 Similar considerations apply to bytind_to_bufpos_func(), although
402 less so because the function is not called so often.
404 #### At some point this should use a more sophisticated method;
407 static int not_very_random_number;
410 bufpos_to_bytind_func (struct buffer *buf, Bufpos x)
420 int add_to_cache = 0;
422 /* Check for some cached positions, for speed. */
423 if (x == BUF_PT (buf))
424 return BI_BUF_PT (buf);
425 if (x == BUF_ZV (buf))
426 return BI_BUF_ZV (buf);
427 if (x == BUF_BEGV (buf))
428 return BI_BUF_BEGV (buf);
430 bufmin = buf->text->mule_bufmin;
431 bufmax = buf->text->mule_bufmax;
432 bytmin = buf->text->mule_bytmin;
433 bytmax = buf->text->mule_bytmax;
434 size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
436 /* The basic idea here is that we shift the "known region" up or down
437 until it overlaps the specified position. We do this by moving
438 the upper bound of the known region up one character at a time,
439 and moving the lower bound of the known region up as necessary
440 when the size of the character just seen changes.
442 We optimize this, however, by first shifting the known region to
443 one of the cached points if it's close by. (We don't check BEG or
444 Z, even though they're cached; most of the time these will be the
445 same as BEGV and ZV, and when they're not, they're not likely
450 Bufpos diffmax = x - bufmax;
451 Bufpos diffpt = x - BUF_PT (buf);
452 Bufpos diffzv = BUF_ZV (buf) - x;
453 /* #### This value could stand some more exploration. */
454 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
456 /* Check if the position is closer to PT or ZV than to the
457 end of the known region. */
464 /* But also implement a heuristic that favors the known region
465 over PT or ZV. The reason for this is that switching to
466 PT or ZV will wipe out the knowledge in the known region,
467 which might be annoying if the known region is large and
468 PT or ZV is not that much closer than the end of the known
471 diffzv += heuristic_hack;
472 diffpt += heuristic_hack;
473 if (diffpt < diffmax && diffpt <= diffzv)
475 bufmax = bufmin = BUF_PT (buf);
476 bytmax = bytmin = BI_BUF_PT (buf);
477 /* We set the size to 1 even though it doesn't really
478 matter because the new known region contains no
479 characters. We do this because this is the most
480 likely size of the characters around the new known
481 region, and we avoid potential yuckiness that is
482 done when size == 3. */
485 if (diffzv < diffmax)
487 bufmax = bufmin = BUF_ZV (buf);
488 bytmax = bytmin = BI_BUF_ZV (buf);
492 #ifdef ERROR_CHECK_BUFPOS
493 else if (x >= bufmin)
498 Bufpos diffmin = bufmin - x;
499 Bufpos diffpt = BUF_PT (buf) - x;
500 Bufpos diffbegv = x - BUF_BEGV (buf);
501 /* #### This value could stand some more exploration. */
502 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
507 diffbegv = -diffbegv;
509 /* But also implement a heuristic that favors the known region --
512 diffbegv += heuristic_hack;
513 diffpt += heuristic_hack;
515 if (diffpt < diffmin && diffpt <= diffbegv)
517 bufmax = bufmin = BUF_PT (buf);
518 bytmax = bytmin = BI_BUF_PT (buf);
519 /* We set the size to 1 even though it doesn't really
520 matter because the new known region contains no
521 characters. We do this because this is the most
522 likely size of the characters around the new known
523 region, and we avoid potential yuckiness that is
524 done when size == 3. */
527 if (diffbegv < diffmin)
529 bufmax = bufmin = BUF_BEGV (buf);
530 bytmax = bytmin = BI_BUF_BEGV (buf);
535 diff_so_far = x > bufmax ? x - bufmax : bufmin - x;
536 if (diff_so_far > 50)
538 /* If we have to move more than a certain amount, then look
540 int minval = INT_MAX;
545 /* I considered keeping the positions ordered. This would speed
546 up this loop, but updating the cache would take longer, so
547 it doesn't seem like it would really matter. */
548 for (i = 0; i < 16; i++)
550 int diff = buf->text->mule_bufpos_cache[i] - x;
561 if (minval < diff_so_far)
563 bufmax = bufmin = buf->text->mule_bufpos_cache[found];
564 bytmax = bytmin = buf->text->mule_bytind_cache[found];
569 /* It's conceivable that the caching above could lead to X being
570 the same as one of the range edges. */
581 INC_BYTIND (buf, newmax);
582 newsize = newmax - bytmax;
594 /* #### Should go past the found location to reduce the number
595 of times that this function is called */
597 else /* x < bufmin */
607 DEC_BYTIND (buf, newmin);
608 newsize = bytmin - newmin;
620 /* #### Should go past the found location to reduce the number
621 of times that this function is called
625 /* If size is three, than we have to max sure that the range we
626 discovered isn't too large, because we use a fixed-length
627 table to divide by 3. */
631 int gap = bytmax - bytmin;
632 buf->text->mule_three_p = 1;
633 buf->text->mule_shifter = 1;
635 if (gap > MAX_BYTIND_GAP_SIZE_3)
639 bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
640 bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
644 bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
645 bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
651 buf->text->mule_three_p = 0;
653 buf->text->mule_shifter = 2;
655 buf->text->mule_shifter = size - 1;
658 buf->text->mule_bufmin = bufmin;
659 buf->text->mule_bufmax = bufmax;
660 buf->text->mule_bytmin = bytmin;
661 buf->text->mule_bytmax = bytmax;
667 /* We throw away a "random" cached value and replace it with
668 the new value. It doesn't actually have to be very random
669 at all, just evenly distributed.
671 #### It would be better to use a least-recently-used algorithm
672 or something that tries to space things out, but I'm not sure
673 it's worth it to go to the trouble of maintaining that. */
674 not_very_random_number += 621;
675 replace_loc = not_very_random_number & 15;
676 buf->text->mule_bufpos_cache[replace_loc] = x;
677 buf->text->mule_bytind_cache[replace_loc] = retval;
683 /* The logic in this function is almost identical to the logic in
684 the previous function. */
687 bytind_to_bufpos_func (struct buffer *buf, Bytind x)
697 int add_to_cache = 0;
699 /* Check for some cached positions, for speed. */
700 if (x == BI_BUF_PT (buf))
702 if (x == BI_BUF_ZV (buf))
704 if (x == BI_BUF_BEGV (buf))
705 return BUF_BEGV (buf);
707 bufmin = buf->text->mule_bufmin;
708 bufmax = buf->text->mule_bufmax;
709 bytmin = buf->text->mule_bytmin;
710 bytmax = buf->text->mule_bytmax;
711 size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
713 /* The basic idea here is that we shift the "known region" up or down
714 until it overlaps the specified position. We do this by moving
715 the upper bound of the known region up one character at a time,
716 and moving the lower bound of the known region up as necessary
717 when the size of the character just seen changes.
719 We optimize this, however, by first shifting the known region to
720 one of the cached points if it's close by. (We don't check BI_BEG or
721 BI_Z, even though they're cached; most of the time these will be the
722 same as BI_BEGV and BI_ZV, and when they're not, they're not likely
727 Bytind diffmax = x - bytmax;
728 Bytind diffpt = x - BI_BUF_PT (buf);
729 Bytind diffzv = BI_BUF_ZV (buf) - x;
730 /* #### This value could stand some more exploration. */
731 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
733 /* Check if the position is closer to PT or ZV than to the
734 end of the known region. */
741 /* But also implement a heuristic that favors the known region
742 over BI_PT or BI_ZV. The reason for this is that switching to
743 BI_PT or BI_ZV will wipe out the knowledge in the known region,
744 which might be annoying if the known region is large and
745 BI_PT or BI_ZV is not that much closer than the end of the known
748 diffzv += heuristic_hack;
749 diffpt += heuristic_hack;
750 if (diffpt < diffmax && diffpt <= diffzv)
752 bufmax = bufmin = BUF_PT (buf);
753 bytmax = bytmin = BI_BUF_PT (buf);
754 /* We set the size to 1 even though it doesn't really
755 matter because the new known region contains no
756 characters. We do this because this is the most
757 likely size of the characters around the new known
758 region, and we avoid potential yuckiness that is
759 done when size == 3. */
762 if (diffzv < diffmax)
764 bufmax = bufmin = BUF_ZV (buf);
765 bytmax = bytmin = BI_BUF_ZV (buf);
769 #ifdef ERROR_CHECK_BUFPOS
770 else if (x >= bytmin)
775 Bytind diffmin = bytmin - x;
776 Bytind diffpt = BI_BUF_PT (buf) - x;
777 Bytind diffbegv = x - BI_BUF_BEGV (buf);
778 /* #### This value could stand some more exploration. */
779 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
784 diffbegv = -diffbegv;
786 /* But also implement a heuristic that favors the known region --
789 diffbegv += heuristic_hack;
790 diffpt += heuristic_hack;
792 if (diffpt < diffmin && diffpt <= diffbegv)
794 bufmax = bufmin = BUF_PT (buf);
795 bytmax = bytmin = BI_BUF_PT (buf);
796 /* We set the size to 1 even though it doesn't really
797 matter because the new known region contains no
798 characters. We do this because this is the most
799 likely size of the characters around the new known
800 region, and we avoid potential yuckiness that is
801 done when size == 3. */
804 if (diffbegv < diffmin)
806 bufmax = bufmin = BUF_BEGV (buf);
807 bytmax = bytmin = BI_BUF_BEGV (buf);
812 diff_so_far = x > bytmax ? x - bytmax : bytmin - x;
813 if (diff_so_far > 50)
815 /* If we have to move more than a certain amount, then look
817 int minval = INT_MAX;
822 /* I considered keeping the positions ordered. This would speed
823 up this loop, but updating the cache would take longer, so
824 it doesn't seem like it would really matter. */
825 for (i = 0; i < 16; i++)
827 int diff = buf->text->mule_bytind_cache[i] - x;
838 if (minval < diff_so_far)
840 bufmax = bufmin = buf->text->mule_bufpos_cache[found];
841 bytmax = bytmin = buf->text->mule_bytind_cache[found];
846 /* It's conceivable that the caching above could lead to X being
847 the same as one of the range edges. */
858 INC_BYTIND (buf, newmax);
859 newsize = newmax - bytmax;
871 /* #### Should go past the found location to reduce the number
872 of times that this function is called */
874 else /* x <= bytmin */
884 DEC_BYTIND (buf, newmin);
885 newsize = bytmin - newmin;
897 /* #### Should go past the found location to reduce the number
898 of times that this function is called
902 /* If size is three, than we have to max sure that the range we
903 discovered isn't too large, because we use a fixed-length
904 table to divide by 3. */
908 int gap = bytmax - bytmin;
909 buf->text->mule_three_p = 1;
910 buf->text->mule_shifter = 1;
912 if (gap > MAX_BYTIND_GAP_SIZE_3)
916 bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
917 bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
921 bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
922 bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
928 buf->text->mule_three_p = 0;
930 buf->text->mule_shifter = 2;
932 buf->text->mule_shifter = size - 1;
935 buf->text->mule_bufmin = bufmin;
936 buf->text->mule_bufmax = bufmax;
937 buf->text->mule_bytmin = bytmin;
938 buf->text->mule_bytmax = bytmax;
944 /* We throw away a "random" cached value and replace it with
945 the new value. It doesn't actually have to be very random
946 at all, just evenly distributed.
948 #### It would be better to use a least-recently-used algorithm
949 or something that tries to space things out, but I'm not sure
950 it's worth it to go to the trouble of maintaining that. */
951 not_very_random_number += 621;
952 replace_loc = not_very_random_number & 15;
953 buf->text->mule_bufpos_cache[replace_loc] = retval;
954 buf->text->mule_bytind_cache[replace_loc] = x;
960 /* Text of length BYTELENGTH and CHARLENGTH (in different units)
961 was inserted at bufpos START. */
964 buffer_mule_signal_inserted_region (struct buffer *buf, Bufpos start,
965 Bytecount bytelength,
966 Charcount charlength)
968 int size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
971 /* Adjust the cache of known positions. */
972 for (i = 0; i < 16; i++)
975 if (buf->text->mule_bufpos_cache[i] > start)
977 buf->text->mule_bufpos_cache[i] += charlength;
978 buf->text->mule_bytind_cache[i] += bytelength;
982 if (start >= buf->text->mule_bufmax)
985 /* The insertion is either before the known region, in which case
986 it shoves it forward; or within the known region, in which case
987 it shoves the end forward. (But it may make the known region
988 inconsistent, so we may have to shorten it.) */
990 if (start <= buf->text->mule_bufmin)
992 buf->text->mule_bufmin += charlength;
993 buf->text->mule_bufmax += charlength;
994 buf->text->mule_bytmin += bytelength;
995 buf->text->mule_bytmax += bytelength;
999 Bufpos end = start + charlength;
1000 /* the insertion point divides the known region in two.
1001 Keep the longer half, at least, and expand into the
1002 inserted chunk as much as possible. */
1004 if (start - buf->text->mule_bufmin > buf->text->mule_bufmax - start)
1006 Bytind bytestart = (buf->text->mule_bytmin
1007 + size * (start - buf->text->mule_bufmin));
1012 bytenew = bytestart;
1013 INC_BYTIND (buf, bytenew);
1014 if (bytenew - bytestart != size)
1017 bytestart = bytenew;
1021 buf->text->mule_bufmax = start;
1022 buf->text->mule_bytmax = bytestart;
1026 buf->text->mule_bufmax += charlength;
1027 buf->text->mule_bytmax += bytelength;
1032 Bytind byteend = (buf->text->mule_bytmin
1033 + size * (start - buf->text->mule_bufmin)
1037 buf->text->mule_bufmax += charlength;
1038 buf->text->mule_bytmax += bytelength;
1043 DEC_BYTIND (buf, bytenew);
1044 if (byteend - bytenew != size)
1051 buf->text->mule_bufmin = end;
1052 buf->text->mule_bytmin = byteend;
1058 /* Text from START to END (equivalent in Bytinds: from BI_START to
1059 BI_END) was deleted. */
1062 buffer_mule_signal_deleted_region (struct buffer *buf, Bufpos start,
1063 Bufpos end, Bytind bi_start,
1068 /* Adjust the cache of known positions. */
1069 for (i = 0; i < 16; i++)
1071 /* After the end; gets shoved backward */
1072 if (buf->text->mule_bufpos_cache[i] > end)
1074 buf->text->mule_bufpos_cache[i] -= end - start;
1075 buf->text->mule_bytind_cache[i] -= bi_end - bi_start;
1077 /* In the range; moves to start of range */
1078 else if (buf->text->mule_bufpos_cache[i] > start)
1080 buf->text->mule_bufpos_cache[i] = start;
1081 buf->text->mule_bytind_cache[i] = bi_start;
1085 /* We don't care about any text after the end of the known region. */
1087 end = min (end, buf->text->mule_bufmax);
1088 bi_end = min (bi_end, buf->text->mule_bytmax);
1092 /* The end of the known region offsets by the total amount of deletion,
1093 since it's all before it. */
1095 buf->text->mule_bufmax -= end - start;
1096 buf->text->mule_bytmax -= bi_end - bi_start;
1098 /* Now we don't care about any text after the start of the known region. */
1100 end = min (end, buf->text->mule_bufmin);
1101 bi_end = min (bi_end, buf->text->mule_bytmin);
1105 buf->text->mule_bufmin -= end - start;
1106 buf->text->mule_bytmin -= bi_end - bi_start;
1111 #ifdef ERROR_CHECK_BUFPOS
1114 bufpos_to_bytind (struct buffer *buf, Bufpos x)
1116 Bytind retval = real_bufpos_to_bytind (buf, x);
1117 ASSERT_VALID_BYTIND_UNSAFE (buf, retval);
1122 bytind_to_bufpos (struct buffer *buf, Bytind x)
1124 ASSERT_VALID_BYTIND_UNSAFE (buf, x);
1125 return real_bytind_to_bufpos (buf, x);
1128 #endif /* ERROR_CHECK_BUFPOS */
1131 /************************************************************************/
1132 /* verifying buffer and string positions */
1133 /************************************************************************/
1135 /* Functions below are tagged with either _byte or _char indicating
1136 whether they return byte or character positions. For a buffer,
1137 a character position is a "Bufpos" and a byte position is a "Bytind".
1138 For strings, these are sometimes typed using "Charcount" and
1141 /* Flags for the functions below are:
1143 GB_ALLOW_PAST_ACCESSIBLE
1145 Allow positions to range over the entire buffer (BUF_BEG to BUF_Z),
1146 rather than just the accessible portion (BUF_BEGV to BUF_ZV).
1147 For strings, this flag has no effect.
1151 If the position is outside the allowable range, return the lower
1152 or upper bound of the range, whichever is closer to the specified
1157 If the position is outside the allowable range, return -1.
1159 GB_NEGATIVE_FROM_END
1161 If a value is negative, treat it as an offset from the end.
1162 Only applies to strings.
1164 The following additional flags apply only to the functions
1169 Either or both positions can be nil. If FROM is nil,
1170 FROM_OUT will contain the lower bound of the allowed range.
1171 If TO is nil, TO_OUT will contain the upper bound of the
1176 FROM must contain the lower bound and TO the upper bound
1177 of the range. If the positions are reversed, an error is
1180 The following is a combination flag:
1182 GB_HISTORICAL_STRING_BEHAVIOR
1184 Equivalent to (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL).
1187 /* Return a buffer position stored in a Lisp_Object. Full
1188 error-checking is done on the position. Flags can be specified to
1189 control the behavior of out-of-range values. The default behavior
1190 is to require that the position is within the accessible part of
1191 the buffer (BEGV and ZV), and to signal an error if the position is
1197 get_buffer_pos_char (struct buffer *b, Lisp_Object pos, unsigned int flags)
1200 Bufpos min_allowed, max_allowed;
1202 CHECK_INT_COERCE_MARKER (pos);
1204 min_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_BEG (b) : BUF_BEGV (b);
1205 max_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_Z (b) : BUF_ZV (b);
1207 if (ind < min_allowed || ind > max_allowed)
1209 if (flags & GB_COERCE_RANGE)
1210 ind = ind < min_allowed ? min_allowed : max_allowed;
1211 else if (flags & GB_NO_ERROR_IF_BAD)
1216 XSETBUFFER (buffer, b);
1217 args_out_of_range (buffer, pos);
1225 get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, unsigned int flags)
1227 Bufpos bpos = get_buffer_pos_char (b, pos, flags);
1228 if (bpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
1230 return bufpos_to_bytind (b, bpos);
1233 /* Return a pair of buffer positions representing a range of text,
1234 taken from a pair of Lisp_Objects. Full error-checking is
1235 done on the positions. Flags can be specified to control the
1236 behavior of out-of-range values. The default behavior is to
1237 allow the range bounds to be specified in either order
1238 (however, FROM_OUT will always be the lower bound of the range
1239 and TO_OUT the upper bound),to require that the positions
1240 are within the accessible part of the buffer (BEGV and ZV),
1241 and to signal an error if the positions are out of range.
1245 get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to,
1246 Bufpos *from_out, Bufpos *to_out, unsigned int flags)
1248 Bufpos min_allowed, max_allowed;
1250 min_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
1251 BUF_BEG (b) : BUF_BEGV (b);
1252 max_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
1253 BUF_Z (b) : BUF_ZV (b);
1255 if (NILP (from) && (flags & GB_ALLOW_NIL))
1256 *from_out = min_allowed;
1258 *from_out = get_buffer_pos_char (b, from, flags | GB_NO_ERROR_IF_BAD);
1260 if (NILP (to) && (flags & GB_ALLOW_NIL))
1261 *to_out = max_allowed;
1263 *to_out = get_buffer_pos_char (b, to, flags | GB_NO_ERROR_IF_BAD);
1265 if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
1268 XSETBUFFER (buffer, b);
1269 args_out_of_range_3 (buffer, from, to);
1272 if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
1274 if (flags & GB_CHECK_ORDER)
1275 signal_simple_error_2 ("start greater than end", from, to);
1278 Bufpos temp = *from_out;
1279 *from_out = *to_out;
1286 get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to,
1287 Bytind *from_out, Bytind *to_out, unsigned int flags)
1291 get_buffer_range_char (b, from, to, &s, &e, flags);
1293 *from_out = bufpos_to_bytind (b, s);
1294 else /* could happen with GB_NO_ERROR_IF_BAD */
1297 *to_out = bufpos_to_bytind (b, e);
1303 get_string_pos_char_1 (Lisp_Object string, Lisp_Object pos, unsigned int flags,
1304 Charcount known_length)
1307 Charcount min_allowed = 0;
1308 Charcount max_allowed = known_length;
1310 /* Computation of KNOWN_LENGTH is potentially expensive so we pass
1314 if (ccpos < 0 && flags & GB_NEGATIVE_FROM_END)
1315 ccpos += max_allowed;
1317 if (ccpos < min_allowed || ccpos > max_allowed)
1319 if (flags & GB_COERCE_RANGE)
1320 ccpos = ccpos < min_allowed ? min_allowed : max_allowed;
1321 else if (flags & GB_NO_ERROR_IF_BAD)
1324 args_out_of_range (string, pos);
1331 get_string_pos_char (Lisp_Object string, Lisp_Object pos, unsigned int flags)
1333 return get_string_pos_char_1 (string, pos, flags,
1334 XSTRING_CHAR_LENGTH (string));
1338 get_string_pos_byte (Lisp_Object string, Lisp_Object pos, unsigned int flags)
1340 Charcount ccpos = get_string_pos_char (string, pos, flags);
1341 if (ccpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
1343 return charcount_to_bytecount (XSTRING_DATA (string), ccpos);
1347 get_string_range_char (Lisp_Object string, Lisp_Object from, Lisp_Object to,
1348 Charcount *from_out, Charcount *to_out,
1351 Charcount min_allowed = 0;
1352 Charcount max_allowed = XSTRING_CHAR_LENGTH (string);
1354 if (NILP (from) && (flags & GB_ALLOW_NIL))
1355 *from_out = min_allowed;
1357 *from_out = get_string_pos_char_1 (string, from,
1358 flags | GB_NO_ERROR_IF_BAD,
1361 if (NILP (to) && (flags & GB_ALLOW_NIL))
1362 *to_out = max_allowed;
1364 *to_out = get_string_pos_char_1 (string, to,
1365 flags | GB_NO_ERROR_IF_BAD,
1368 if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
1369 args_out_of_range_3 (string, from, to);
1371 if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
1373 if (flags & GB_CHECK_ORDER)
1374 signal_simple_error_2 ("start greater than end", from, to);
1377 Bufpos temp = *from_out;
1378 *from_out = *to_out;
1385 get_string_range_byte (Lisp_Object string, Lisp_Object from, Lisp_Object to,
1386 Bytecount *from_out, Bytecount *to_out,
1391 get_string_range_char (string, from, to, &s, &e, flags);
1393 *from_out = charcount_to_bytecount (XSTRING_DATA (string), s);
1394 else /* could happen with GB_NO_ERROR_IF_BAD */
1397 *to_out = charcount_to_bytecount (XSTRING_DATA (string), e);
1404 get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos,
1407 return STRINGP (object) ?
1408 get_string_pos_char (object, pos, flags) :
1409 get_buffer_pos_char (XBUFFER (object), pos, flags);
1413 get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos,
1416 return STRINGP (object) ?
1417 get_string_pos_byte (object, pos, flags) :
1418 get_buffer_pos_byte (XBUFFER (object), pos, flags);
1422 get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from,
1423 Lisp_Object to, Bufpos *from_out,
1424 Bufpos *to_out, unsigned int flags)
1426 if (STRINGP (object))
1427 get_string_range_char (object, from, to, from_out, to_out, flags);
1429 get_buffer_range_char (XBUFFER (object), from, to, from_out, to_out, flags);
1433 get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from,
1434 Lisp_Object to, Bytind *from_out,
1435 Bytind *to_out, unsigned int flags)
1437 if (STRINGP (object))
1438 get_string_range_byte (object, from, to, from_out, to_out, flags);
1440 get_buffer_range_byte (XBUFFER (object), from, to, from_out, to_out, flags);
1444 buffer_or_string_accessible_begin_char (Lisp_Object object)
1446 return STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object));
1450 buffer_or_string_accessible_end_char (Lisp_Object object)
1452 return STRINGP (object) ?
1453 XSTRING_CHAR_LENGTH (object) : BUF_ZV (XBUFFER (object));
1457 buffer_or_string_accessible_begin_byte (Lisp_Object object)
1459 return STRINGP (object) ? 0 : BI_BUF_BEGV (XBUFFER (object));
1463 buffer_or_string_accessible_end_byte (Lisp_Object object)
1465 return STRINGP (object) ?
1466 XSTRING_LENGTH (object) : BI_BUF_ZV (XBUFFER (object));
1470 buffer_or_string_absolute_begin_char (Lisp_Object object)
1472 return STRINGP (object) ? 0 : BUF_BEG (XBUFFER (object));
1476 buffer_or_string_absolute_end_char (Lisp_Object object)
1478 return STRINGP (object) ?
1479 XSTRING_CHAR_LENGTH (object) : BUF_Z (XBUFFER (object));
1483 buffer_or_string_absolute_begin_byte (Lisp_Object object)
1485 return STRINGP (object) ? 0 : BI_BUF_BEG (XBUFFER (object));
1489 buffer_or_string_absolute_end_byte (Lisp_Object object)
1491 return STRINGP (object) ?
1492 XSTRING_LENGTH (object) : BI_BUF_Z (XBUFFER (object));
1496 /************************************************************************/
1497 /* point and marker adjustment */
1498 /************************************************************************/
1500 /* just_set_point() is the only place `PT' is an lvalue in all of emacs.
1501 This function is called from set_buffer_point(), which is the function
1502 that the SET_PT and BUF_SET_PT macros expand into, and from the
1503 routines below that insert and delete text. (This is in cases where
1504 the point marker logically doesn't move but PT (being a byte index)
1505 needs to get adjusted.) */
1507 /* Set point to a specified value. This is used only when the value
1508 of point changes due to an insert or delete; it does not represent
1509 a conceptual change in point as a marker. In particular, point is
1510 not crossing any interval boundaries, so there's no need to use the
1511 usual SET_PT macro. In fact it would be incorrect to do so, because
1512 either the old or the new value of point is out of synch with the
1513 current set of intervals. */
1515 /* This gets called more than enough to make the function call
1516 overhead a significant factor so we've turned it into a macro. */
1517 #define JUST_SET_POINT(buf, bufpos, ind) \
1520 buf->bufpt = (bufpos); \
1524 /* Set a buffer's point. */
1527 set_buffer_point (struct buffer *buf, Bufpos bufpos, Bytind bytpos)
1529 assert (bytpos >= BI_BUF_BEGV (buf) && bytpos <= BI_BUF_ZV (buf));
1530 if (bytpos == BI_BUF_PT (buf))
1532 JUST_SET_POINT (buf, bufpos, bytpos);
1534 assert (MARKERP (buf->point_marker));
1535 XMARKER (buf->point_marker)->memind =
1536 bytind_to_memind (buf, bytpos);
1538 /* FSF makes sure that PT is not being set within invisible text.
1539 However, this is the wrong place for that check. The check
1540 should happen only at the next redisplay. */
1542 /* Some old coder said:
1544 "If there were to be hooks which were run when point entered/left an
1545 extent, this would be the place to put them.
1547 However, it's probably the case that such hooks should be implemented
1548 using a post-command-hook instead, to avoid running the hooks as a
1549 result of intermediate motion inside of save-excursions, for example."
1551 I definitely agree with this. PT gets moved all over the place
1552 and it would be a Bad Thing for any hooks to get called, both for
1553 the reason above and because many callers are not prepared for
1554 a GC within this function. --ben
1558 /* Do the correct marker-like adjustment on MPOS (see below). FROM, TO,
1559 and AMOUNT are as in adjust_markers(). If MPOS doesn't need to be
1560 adjusted, nothing will happen. */
1562 do_marker_adjustment (Memind mpos, Memind from,
1563 Memind to, Bytecount amount)
1567 if (mpos > to && mpos < to + amount)
1572 if (mpos > from + amount && mpos <= from)
1573 mpos = from + amount;
1575 if (mpos > from && mpos <= to)
1580 /* Do the following:
1582 (1) Add `amount' to the position of every marker in the current buffer
1583 whose current position is between `from' (exclusive) and `to' (inclusive).
1585 (2) Also, any markers past the outside of that interval, in the direction
1586 of adjustment, are first moved back to the near end of the interval
1587 and then adjusted by `amount'.
1589 This function is called in two different cases: when a region of
1590 characters adjacent to the gap is moved, causing the gap to shift
1591 to the other side of the region (in this case, `from' and `to'
1592 point to the old position of the region and there should be no
1593 markers affected by (2) because they would be inside the gap),
1594 or when a region of characters adjacent to the gap is wiped out,
1595 causing the gap to increase to include the region (in this case,
1596 `from' and `to' are the same, both pointing to the boundary
1597 between the gap and the deleted region, and there are no markers
1600 The reason for the use of exclusive and inclusive is that markers at
1601 the gap always sit at the beginning, not at the end.
1605 adjust_markers (struct buffer *buf, Memind from, Memind to,
1608 struct Lisp_Marker *m;
1610 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
1611 m->memind = do_marker_adjustment (m->memind, from, to, amount);
1614 /* Adjust markers whose insertion-type is t
1615 for an insertion of AMOUNT characters at POS. */
1618 adjust_markers_for_insert (struct buffer *buf, Memind ind, Bytecount amount)
1620 struct Lisp_Marker *m;
1622 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
1624 if (m->insertion_type && m->memind == ind)
1625 m->memind += amount;
1630 /************************************************************************/
1631 /* Routines for dealing with the gap */
1632 /************************************************************************/
1634 /* XEmacs requires an ANSI C compiler, and it damn well better have a
1635 working memmove() */
1636 #define GAP_USE_BCOPY
1637 #ifdef BCOPY_UPWARD_SAFE
1638 # undef BCOPY_UPWARD_SAFE
1640 #ifdef BCOPY_DOWNWARD_SAFE
1641 # undef BCOPY_DOWNWARD_SAFE
1643 #define BCOPY_UPWARD_SAFE 1
1644 #define BCOPY_DOWNWARD_SAFE 1
1646 /* maximum amount of memory moved in a single chunk. Increasing this
1647 value improves gap-motion efficiency but decreases QUIT responsiveness
1648 time. Was 32000 but today's processors are faster and files are
1650 #define GAP_MOVE_CHUNK 300000
1652 /* Move the gap to POS, which is less than the current GPT. */
1655 gap_left (struct buffer *buf, Bytind pos)
1660 struct buffer *mbuf;
1661 Lisp_Object bufcons;
1663 from = BUF_GPT_ADDR (buf);
1664 to = from + BUF_GAP_SIZE (buf);
1665 new_s1 = BI_BUF_GPT (buf);
1667 /* Now copy the characters. To move the gap down,
1668 copy characters up. */
1672 /* I gets number of characters left to copy. */
1676 /* If a quit is requested, stop copying now.
1677 Change POS to be where we have actually moved the gap to. */
1683 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
1684 if (i > GAP_MOVE_CHUNK)
1686 #ifdef GAP_USE_BCOPY
1688 /* bcopy is safe if the two areas of memory do not overlap
1689 or on systems where bcopy is always safe for moving upward. */
1690 && (BCOPY_UPWARD_SAFE
1691 || to - from >= 128))
1693 /* If overlap is not safe, avoid it by not moving too many
1694 characters at once. */
1695 if (!BCOPY_UPWARD_SAFE && i > to - from)
1699 memmove (to, from, i);
1710 /* Adjust markers, and buffer data structure, to put the gap at POS.
1711 POS is where the loop above stopped, which may be what was specified
1712 or may be where a quit was detected. */
1713 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1715 adjust_markers (mbuf, pos, BI_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
1717 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1719 adjust_extents (make_buffer (mbuf), pos, BI_BUF_GPT (mbuf),
1720 BUF_GAP_SIZE (mbuf));
1722 SET_BI_BUF_GPT (buf, pos);
1723 SET_GAP_SENTINEL (buf);
1724 #ifdef ERROR_CHECK_EXTENTS
1725 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1727 sledgehammer_extent_check (make_buffer (mbuf));
1734 gap_right (struct buffer *buf, Bytind pos)
1739 struct buffer *mbuf;
1740 Lisp_Object bufcons;
1742 to = BUF_GPT_ADDR (buf);
1743 from = to + BUF_GAP_SIZE (buf);
1744 new_s1 = BI_BUF_GPT (buf);
1746 /* Now copy the characters. To move the gap up,
1747 copy characters down. */
1751 /* I gets number of characters left to copy. */
1755 /* If a quit is requested, stop copying now.
1756 Change POS to be where we have actually moved the gap to. */
1762 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
1763 if (i > GAP_MOVE_CHUNK)
1765 #ifdef GAP_USE_BCOPY
1767 /* bcopy is safe if the two areas of memory do not overlap
1768 or on systems where bcopy is always safe for moving downward. */
1769 && (BCOPY_DOWNWARD_SAFE
1770 || from - to >= 128))
1772 /* If overlap is not safe, avoid it by not moving too many
1773 characters at once. */
1774 if (!BCOPY_DOWNWARD_SAFE && i > from - to)
1777 memmove (to, from, i);
1790 int gsize = BUF_GAP_SIZE (buf);
1791 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1793 adjust_markers (mbuf, BI_BUF_GPT (mbuf) + gsize, pos + gsize, - gsize);
1795 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1797 adjust_extents (make_buffer (mbuf), BI_BUF_GPT (mbuf) + gsize,
1798 pos + gsize, - gsize);
1800 SET_BI_BUF_GPT (buf, pos);
1801 SET_GAP_SENTINEL (buf);
1802 #ifdef ERROR_CHECK_EXTENTS
1803 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1805 sledgehammer_extent_check (make_buffer (mbuf));
1809 if (pos == BI_BUF_Z (buf))
1811 /* merge gap with end gap */
1813 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + BUF_END_GAP_SIZE (buf));
1814 SET_BUF_END_GAP_SIZE (buf, 0);
1815 SET_END_SENTINEL (buf);
1821 /* Move gap to position `pos'.
1822 Note that this can quit! */
1825 move_gap (struct buffer *buf, Bytind pos)
1827 if (! BUF_BEG_ADDR (buf))
1829 if (pos < BI_BUF_GPT (buf))
1830 gap_left (buf, pos);
1831 else if (pos > BI_BUF_GPT (buf))
1832 gap_right (buf, pos);
1835 /* Merge the end gap into the gap */
1838 merge_gap_with_end_gap (struct buffer *buf)
1841 Bytind real_gap_loc;
1842 Bytecount old_gap_size;
1843 Bytecount increment;
1845 increment = BUF_END_GAP_SIZE (buf);
1846 SET_BUF_END_GAP_SIZE (buf, 0);
1850 /* Prevent quitting in move_gap. */
1851 tem = Vinhibit_quit;
1854 real_gap_loc = BI_BUF_GPT (buf);
1855 old_gap_size = BUF_GAP_SIZE (buf);
1857 /* Pretend the end gap is the gap */
1858 SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
1859 SET_BUF_GAP_SIZE (buf, increment);
1861 /* Move the new gap down to be consecutive with the end of the old one.
1862 This adjusts the markers properly too. */
1863 gap_left (buf, real_gap_loc + old_gap_size);
1865 /* Now combine the two into one large gap. */
1866 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
1867 SET_BI_BUF_GPT (buf, real_gap_loc);
1868 SET_GAP_SENTINEL (buf);
1870 /* We changed the total size of the buffer (including gap),
1871 so we need to fix up the end sentinel. */
1872 SET_END_SENTINEL (buf);
1874 Vinhibit_quit = tem;
1878 /* Make the gap INCREMENT bytes longer. */
1881 make_gap (struct buffer *buf, Bytecount increment)
1885 Bytind real_gap_loc;
1886 Bytecount old_gap_size;
1888 /* If we have to get more space, get enough to last a while. We use
1889 a geometric progression that saves on realloc space. */
1890 increment += 2000 + ((BI_BUF_Z (buf) - BI_BUF_BEG (buf)) / 8);
1892 if (increment > BUF_END_GAP_SIZE (buf))
1894 /* Don't allow a buffer size that won't fit in an int
1895 even if it will fit in a Lisp integer.
1896 That won't work because so many places use `int'. */
1898 if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment
1900 error ("Maximum buffer size exceeded");
1902 result = BUFFER_REALLOC (buf->text->beg,
1903 BI_BUF_Z (buf) - BI_BUF_BEG (buf) +
1904 BUF_GAP_SIZE (buf) + increment +
1905 BUF_END_SENTINEL_SIZE);
1909 SET_BUF_BEG_ADDR (buf, result);
1912 increment = BUF_END_GAP_SIZE (buf);
1914 /* Prevent quitting in move_gap. */
1915 tem = Vinhibit_quit;
1918 real_gap_loc = BI_BUF_GPT (buf);
1919 old_gap_size = BUF_GAP_SIZE (buf);
1921 /* Call the newly allocated space a gap at the end of the whole space. */
1922 SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
1923 SET_BUF_GAP_SIZE (buf, increment);
1925 SET_BUF_END_GAP_SIZE (buf, 0);
1927 /* Move the new gap down to be consecutive with the end of the old one.
1928 This adjusts the markers properly too. */
1929 gap_left (buf, real_gap_loc + old_gap_size);
1931 /* Now combine the two into one large gap. */
1932 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
1933 SET_BI_BUF_GPT (buf, real_gap_loc);
1934 SET_GAP_SENTINEL (buf);
1936 /* We changed the total size of the buffer (including gap),
1937 so we need to fix up the end sentinel. */
1938 SET_END_SENTINEL (buf);
1940 Vinhibit_quit = tem;
1944 /************************************************************************/
1945 /* Before/after-change processing */
1946 /************************************************************************/
1948 /* Those magic changes ... */
1951 buffer_signal_changed_region (struct buffer *buf, Bufpos start,
1954 /* The changed region is recorded as the number of unchanged
1955 characters from the beginning and from the end of the
1956 buffer. This obviates much of the need of shifting the
1957 region around to compensate for insertions and deletions.
1959 if (buf->changes->begin_unchanged < 0 ||
1960 buf->changes->begin_unchanged > start - BUF_BEG (buf))
1961 buf->changes->begin_unchanged = start - BUF_BEG (buf);
1962 if (buf->changes->end_unchanged < 0 ||
1963 buf->changes->end_unchanged > BUF_Z (buf) - end)
1964 buf->changes->end_unchanged = BUF_Z (buf) - end;
1968 buffer_extent_signal_changed_region (struct buffer *buf, Bufpos start,
1971 if (buf->changes->begin_extent_unchanged < 0 ||
1972 buf->changes->begin_extent_unchanged > start - BUF_BEG (buf))
1973 buf->changes->begin_extent_unchanged = start - BUF_BEG (buf);
1974 if (buf->changes->end_extent_unchanged < 0 ||
1975 buf->changes->end_extent_unchanged > BUF_Z (buf) - end)
1976 buf->changes->end_extent_unchanged = BUF_Z (buf) - end;
1980 buffer_reset_changes (struct buffer *buf)
1982 buf->changes->begin_unchanged = -1;
1983 buf->changes->end_unchanged = -1;
1984 buf->changes->begin_extent_unchanged = -1;
1985 buf->changes->end_extent_unchanged = -1;
1986 buf->changes->newline_was_deleted = 0;
1990 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
1994 /* Call the after-change-functions according to the changes made so far
1995 and treat all further changes as single until the outermost
1996 multiple change exits. This is called when the outermost multiple
1997 change exits and when someone is trying to make a change that violates
1998 the constraints specified in begin_multiple_change(), typically
1999 when nested multiple-change sessions occur. (There are smarter ways of
2000 dealing with nested multiple changes, but these rarely occur so there's
2001 probably no point in it.) */
2003 /* #### This needs to keep track of what actually changed and only
2004 call the after-change functions on that region. */
2007 cancel_multiple_change (struct buffer *buf)
2009 /* This function can GC */
2010 /* Call the after-change-functions except when they've already been
2011 called or when there were no changes made to the buffer at all. */
2012 if (buf->text->changes->mc_begin != 0 &&
2013 buf->text->changes->mc_begin_signaled)
2015 Bufpos real_mc_begin = buf->text->changes->mc_begin;
2016 buf->text->changes->mc_begin = 0;
2018 signal_after_change (buf, real_mc_begin, buf->text->changes->mc_orig_end,
2019 buf->text->changes->mc_new_end);
2023 buf->text->changes->mc_begin = 0;
2027 /* this is an unwind_protect, to ensure that the after-change-functions
2028 get called even in a non-local exit. */
2031 multiple_change_finish_up (Lisp_Object buffer)
2033 struct buffer *buf = XBUFFER (buffer);
2035 /* #### I don't know whether or not it should even be possible to
2036 get here with a dead buffer (though given how it is called I can
2037 see how it might be). In any case, there isn't time before 19.14
2039 if (!BUFFER_LIVE_P (buf))
2042 /* This function can GC */
2043 buf->text->changes->in_multiple_change = 0; /* do this first so that
2044 errors in the after-change
2045 functions don't mess things
2047 cancel_multiple_change (buf);
2051 /* Call this function when you're about to make a number of buffer changes
2052 that should be considered a single change. (e.g. `replace-match' calls
2053 this.) You need to specify the START and END of the region that is
2054 going to be changed so that the before-change-functions are called
2055 with the correct arguments. The after-change region is calculated
2056 automatically, however, and if changes somehow or other happen outside
2057 of the specified region, that will also be handled correctly.
2059 begin_multiple_change() returns a number (actually a specpdl depth)
2060 that you must pass to end_multiple_change() when you are done.
2062 FSF Emacs 20 implements a similar feature, accessible from Lisp
2063 through a `combine-after-change-calls' special form, which is
2064 essentially equivalent to this function. We should consider
2065 whether we want to introduce a similar Lisp form. */
2068 begin_multiple_change (struct buffer *buf, Bufpos start, Bufpos end)
2070 /* This function can GC */
2072 if (buf->text->changes->in_multiple_change)
2074 if (buf->text->changes->mc_begin != 0 &&
2075 (start < buf->text->changes->mc_begin ||
2076 end > buf->text->changes->mc_new_end))
2077 cancel_multiple_change (buf);
2083 buf->text->changes->mc_begin = start;
2084 buf->text->changes->mc_orig_end = buf->text->changes->mc_new_end = end;
2085 buf->text->changes->mc_begin_signaled = 0;
2086 count = specpdl_depth ();
2087 XSETBUFFER (buffer, buf);
2088 record_unwind_protect (multiple_change_finish_up, buffer);
2090 buf->text->changes->in_multiple_change++;
2091 /* We don't call before-change-functions until signal_before_change()
2092 is called, in case there is a read-only or other error. */
2097 end_multiple_change (struct buffer *buf, int count)
2099 assert (buf->text->changes->in_multiple_change > 0);
2100 buf->text->changes->in_multiple_change--;
2101 if (!buf->text->changes->in_multiple_change)
2102 unbind_to (count, Qnil);
2105 static int inside_change_hook;
2108 change_function_restore (Lisp_Object buffer)
2110 /* We should first reset the variable and then change the buffer,
2111 because Fset_buffer() can throw. */
2112 inside_change_hook = 0;
2113 if (XBUFFER (buffer) != current_buffer)
2114 Fset_buffer (buffer);
2118 static int in_first_change;
2121 first_change_hook_restore (Lisp_Object buffer)
2123 in_first_change = 0;
2124 Fset_buffer (buffer);
2128 /* Signal an initial modification to the buffer. */
2131 signal_first_change (struct buffer *buf)
2133 /* This function can GC */
2135 XSETBUFFER (buffer, current_buffer);
2137 if (!in_first_change)
2139 if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
2141 int speccount = specpdl_depth ();
2142 record_unwind_protect (first_change_hook_restore, buffer);
2143 set_buffer_internal (buf);
2144 in_first_change = 1;
2145 run_hook (Qfirst_change_hook);
2146 unbind_to (speccount, Qnil);
2151 /* Signal a change to the buffer immediately before it happens.
2152 START and END are the bounds of the text to be changed. */
2155 signal_before_change (struct buffer *buf, Bufpos start, Bufpos end)
2157 /* This function can GC */
2158 struct buffer *mbuf;
2159 Lisp_Object bufcons;
2161 if (!inside_change_hook)
2166 /* Are we in a multiple-change session? */
2167 if (buf->text->changes->in_multiple_change &&
2168 buf->text->changes->mc_begin != 0)
2170 /* If we're violating the constraints of the session,
2171 call the after-change-functions as necessary for the
2172 changes already made and treat further changes as
2174 if (start < buf->text->changes->mc_begin ||
2175 end > buf->text->changes->mc_new_end)
2176 cancel_multiple_change (buf);
2177 /* Do nothing if this is not the first change in the session. */
2178 else if (buf->text->changes->mc_begin_signaled)
2182 /* First time through; call the before-change-functions
2183 specifying the entire region to be changed. (Note that
2184 we didn't call before-change-functions in
2185 begin_multiple_change() because the buffer might be
2187 start = buf->text->changes->mc_begin;
2188 end = buf->text->changes->mc_new_end;
2192 /* If buffer is unmodified, run a special hook for that case. */
2193 if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
2195 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2197 signal_first_change (mbuf);
2201 /* Now in any case run the before-change-functions if any. */
2202 speccount = specpdl_depth ();
2203 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
2204 inside_change_hook = 1;
2206 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2208 XSETBUFFER (buffer, mbuf);
2209 if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
2210 /* Obsolete, for compatibility */
2211 || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
2213 set_buffer_internal (buf);
2214 va_run_hook_with_args (Qbefore_change_functions, 2,
2215 make_int (start), make_int (end));
2216 /* Obsolete, for compatibility */
2217 va_run_hook_with_args (Qbefore_change_function, 2,
2218 make_int (start), make_int (end));
2222 /* Make sure endpoints remain valid. before-change-functions
2223 might have modified the buffer. */
2224 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
2225 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
2226 if (end < BUF_BEGV (buf)) end = BUF_BEGV (buf);
2227 if (end > BUF_ZV (buf)) end = BUF_ZV (buf);
2229 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2231 XSETBUFFER (buffer, mbuf);
2232 report_extent_modification (buffer, start, end, 0);
2234 unbind_to (speccount, Qnil);
2236 /* Only now do we indicate that the before-change-functions have
2237 been called, in case some function throws out. */
2238 buf->text->changes->mc_begin_signaled = 1;
2242 /* Signal a change immediately after it happens.
2243 START is the bufpos of the start of the changed text.
2244 ORIG_END is the bufpos of the end of the before-changed text.
2245 NEW_END is the bufpos of the end of the after-changed text.
2249 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
2252 /* This function can GC */
2253 struct buffer *mbuf;
2254 Lisp_Object bufcons;
2256 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2258 /* always do this. */
2259 buffer_signal_changed_region (mbuf, start, new_end);
2261 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2263 /* #### This seems inefficient. Wouldn't it be better to just
2264 keep one cache per base buffer? */
2265 font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
2268 if (!inside_change_hook)
2273 if (buf->text->changes->in_multiple_change &&
2274 buf->text->changes->mc_begin != 0)
2276 assert (start >= buf->text->changes->mc_begin &&
2277 start <= buf->text->changes->mc_new_end);
2278 assert (orig_end >= buf->text->changes->mc_begin &&
2279 orig_end <= buf->text->changes->mc_new_end);
2280 buf->text->changes->mc_new_end += new_end - orig_end;
2281 return; /* after-change-functions signalled when all changes done */
2284 speccount = specpdl_depth ();
2285 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
2286 inside_change_hook = 1;
2287 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2289 XSETBUFFER (buffer, mbuf);
2291 if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
2292 /* Obsolete, for compatibility */
2293 || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
2295 set_buffer_internal (buf);
2296 /* The actual after-change functions take slightly
2297 different arguments than what we were passed. */
2298 va_run_hook_with_args (Qafter_change_functions, 3,
2299 make_int (start), make_int (new_end),
2300 make_int (orig_end - start));
2301 /* Obsolete, for compatibility */
2302 va_run_hook_with_args (Qafter_change_function, 3,
2303 make_int (start), make_int (new_end),
2304 make_int (orig_end - start));
2308 /* Make sure endpoints remain valid. after-change-functions
2309 might have modified the buffer. */
2310 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
2311 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
2312 if (new_end < BUF_BEGV (buf)) new_end = BUF_BEGV (buf);
2313 if (new_end > BUF_ZV (buf)) new_end = BUF_ZV (buf);
2314 if (orig_end < BUF_BEGV (buf)) orig_end = BUF_BEGV (buf);
2315 if (orig_end > BUF_ZV (buf)) orig_end = BUF_ZV (buf);
2317 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2319 XSETBUFFER (buffer, mbuf);
2320 report_extent_modification (buffer, start, new_end, 1);
2322 unbind_to (speccount, Qnil); /* sets inside_change_hook back to 0 */
2326 /* Call this if you're about to change the region of BUFFER from START
2327 to END. This checks the read-only properties of the region, calls
2328 the necessary modification hooks, and warns the next redisplay that
2329 it should pay attention to that area. */
2332 prepare_to_modify_buffer (struct buffer *buf, Bufpos start, Bufpos end,
2335 /* This function can GC */
2336 /* dmoore - This function can also kill the buffer buf, the current
2337 buffer, and do anything it pleases. So if you call it, be
2339 struct buffer *mbuf;
2340 Lisp_Object buffer, bufcons;
2341 struct gcpro gcpro1;
2343 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2345 barf_if_buffer_read_only (mbuf, start, end);
2348 /* if this is the first modification, see about locking the buffer's
2350 XSETBUFFER (buffer, buf);
2352 if (!NILP (buf->filename) && lockit &&
2353 BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
2355 #ifdef CLASH_DETECTION
2356 if (!NILP (buf->file_truename))
2357 /* Make binding buffer-file-name to nil effective. */
2358 lock_file (buf->file_truename);
2360 /* At least warn if this file has changed on disk since it was visited.*/
2361 if (NILP (Fverify_visited_file_modtime (buffer))
2362 && !NILP (Ffile_exists_p (buf->filename)))
2363 call1_in_buffer (buf, intern ("ask-user-about-supersession-threat"),
2365 #endif /* not CLASH_DETECTION */
2369 /* #### dmoore - is this reasonable in case of buf being killed above? */
2370 if (!BUFFER_LIVE_P (buf))
2373 signal_before_change (buf, start, end);
2375 #ifdef REGION_CACHE_NEEDS_WORK
2376 if (buf->newline_cache)
2377 invalidate_region_cache (buf,
2379 start - BUF_BEG (buf), BUF_Z (buf) - end);
2380 if (buf->width_run_cache)
2381 invalidate_region_cache (buf,
2382 buf->width_run_cache,
2383 start - BUF_BEG (buf), BUF_Z (buf) - end);
2387 Vdeactivate_mark = Qt;
2390 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2392 mbuf->point_before_scroll = Qnil;
2397 /************************************************************************/
2398 /* Insertion of strings */
2399 /************************************************************************/
2402 fixup_internal_substring (CONST Bufbyte *nonreloc, Lisp_Object reloc,
2403 Bytecount offset, Bytecount *len)
2405 assert ((nonreloc && NILP (reloc)) || (!nonreloc && STRINGP (reloc)));
2410 *len = strlen ((CONST char *) nonreloc) - offset;
2412 *len = XSTRING_LENGTH (reloc) - offset;
2414 #ifdef ERROR_CHECK_BUFPOS
2416 if (STRINGP (reloc))
2418 assert (offset >= 0 && offset <= XSTRING_LENGTH (reloc));
2419 assert (offset + *len <= XSTRING_LENGTH (reloc));
2424 /* Insert a string into BUF at Bufpos POS. The string data comes
2425 from one of two sources: constant, non-relocatable data (specified
2426 in NONRELOC), or a Lisp string object (specified in RELOC), which
2427 is relocatable and may have extent data that needs to be copied
2428 into the buffer. OFFSET and LENGTH specify the substring of the
2429 data that is actually to be inserted. As a special case, if POS
2430 is -1, insert the string at point and move point to the end of the
2433 Normally, markers at the insertion point end up before the
2434 inserted string. If INSDEL_BEFORE_MARKERS is set in flags, however,
2435 they end up after the string.
2437 INSDEL_NO_LOCKING is kludgy and is used when insert-file-contents is
2438 visiting a new file; it inhibits the locking checks normally done
2439 before modifying a buffer. Similar checks were already done
2440 in the higher-level Lisp functions calling insert-file-contents. */
2443 buffer_insert_string_1 (struct buffer *buf, Bufpos pos,
2444 CONST Bufbyte *nonreloc, Lisp_Object reloc,
2445 Bytecount offset, Bytecount length,
2448 /* This function can GC */
2449 struct gcpro gcpro1;
2453 struct buffer *mbuf;
2454 Lisp_Object bufcons;
2456 /* Defensive steps just in case a buffer gets deleted and a calling
2457 function doesn't notice it. */
2458 if (!BUFFER_LIVE_P (buf))
2461 fixup_internal_substring (nonreloc, reloc, offset, &length);
2470 /* #### See the comment in print_internal(). If this buffer is marked
2471 as translatable, then Fgettext() should be called on obj if it
2475 /* Make sure that point-max won't exceed the size of an emacs int. */
2476 if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
2477 error ("Maximum buffer size exceeded");
2479 /* theoretically not necessary -- caller should GCPRO.
2480 #### buffer_insert_from_buffer_1() doesn't! */
2483 prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
2485 /* Defensive steps in case the before-change-functions fuck around */
2486 if (!BUFFER_LIVE_P (buf))
2489 /* Bad bad pre-change function. */
2493 /* Make args be valid again. prepare_to_modify_buffer() might have
2494 modified the buffer. */
2495 if (pos < BUF_BEGV (buf))
2496 pos = BUF_BEGV (buf);
2497 if (pos > BUF_ZV (buf))
2500 /* string may have been relocated up to this point */
2501 if (STRINGP (reloc))
2502 nonreloc = XSTRING_DATA (reloc);
2504 ind = bufpos_to_bytind (buf, pos);
2505 cclen = bytecount_to_charcount (nonreloc + offset, length);
2507 if (ind != BI_BUF_GPT (buf))
2508 /* #### if debug-on-quit is invoked and the user changes the
2509 buffer, bad things can happen. This is a rampant problem
2511 move_gap (buf, ind); /* may QUIT */
2512 if (! GAP_CAN_HOLD_SIZE_P (buf, length))
2514 if (BUF_END_GAP_SIZE (buf) >= length)
2515 merge_gap_with_end_gap (buf);
2517 make_gap (buf, length - BUF_GAP_SIZE (buf));
2520 insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
2522 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2524 record_insert (mbuf, pos, cclen);
2528 MARK_BUFFERS_CHANGED;
2530 /* string may have been relocated up to this point */
2531 if (STRINGP (reloc))
2532 nonreloc = XSTRING_DATA (reloc);
2534 memcpy (BUF_GPT_ADDR (buf), nonreloc + offset, length);
2536 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length);
2537 SET_BI_BUF_GPT (buf, BI_BUF_GPT (buf) + length);
2538 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2540 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen, BI_BUF_ZV (mbuf) + length);
2542 SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BI_BUF_Z (buf) + length);
2543 SET_GAP_SENTINEL (buf);
2546 buffer_mule_signal_inserted_region (buf, pos, length, cclen);
2549 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2551 process_extents_for_insertion (make_buffer (mbuf), ind, length);
2554 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2556 /* We know the gap is at IND so the cast is OK. */
2557 adjust_markers_for_insert (mbuf, (Memind) ind, length);
2560 /* Point logically doesn't move, but may need to be adjusted because
2561 it's a byte index. point-marker doesn't change because it's a
2563 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2565 if (BI_BUF_PT (mbuf) > ind)
2566 JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
2567 BI_BUF_PT (mbuf) + length);
2570 /* Well, point might move. */
2572 BI_BUF_SET_PT (buf, ind + length);
2574 if (STRINGP (reloc))
2576 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2578 splice_in_string_extents (reloc, mbuf, ind, length, offset);
2582 if (flags & INSDEL_BEFORE_MARKERS)
2584 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2586 /* ind - 1 is correct because the FROM argument is exclusive.
2587 I formerly used DEC_BYTIND() but that caused problems at the
2588 beginning of the buffer. */
2589 adjust_markers (mbuf, ind - 1, ind, length);
2593 signal_after_change (buf, pos, pos, pos + cclen);
2601 /* The following functions are interfaces onto the above function,
2602 for inserting particular sorts of data. In all the functions,
2603 BUF and POS specify the buffer and location where the insertion is
2604 to take place. (If POS is -1, text is inserted at point and point
2605 moves forward past the text.) FLAGS is as above. */
2608 buffer_insert_raw_string_1 (struct buffer *buf, Bufpos pos,
2609 CONST Bufbyte *nonreloc, Bytecount length,
2612 /* This function can GC */
2613 return buffer_insert_string_1 (buf, pos, nonreloc, Qnil, 0, length,
2618 buffer_insert_lisp_string_1 (struct buffer *buf, Bufpos pos, Lisp_Object str,
2621 /* This function can GC */
2622 #ifdef ERROR_CHECK_TYPECHECK
2623 assert (STRINGP (str));
2625 return buffer_insert_string_1 (buf, pos, 0, str, 0,
2626 XSTRING_LENGTH (str),
2630 /* Insert the null-terminated string S (in external format). */
2633 buffer_insert_c_string_1 (struct buffer *buf, Bufpos pos, CONST char *s,
2636 /* This function can GC */
2637 CONST char *translated = GETTEXT (s);
2638 return buffer_insert_string_1 (buf, pos, (CONST Bufbyte *) translated, Qnil,
2639 0, strlen (translated), flags);
2643 buffer_insert_emacs_char_1 (struct buffer *buf, Bufpos pos, Emchar ch,
2646 /* This function can GC */
2647 Bufbyte str[MAX_EMCHAR_LEN];
2648 Bytecount len = set_charptr_emchar (str, ch);
2649 return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
2653 buffer_insert_c_char_1 (struct buffer *buf, Bufpos pos, char c,
2656 /* This function can GC */
2657 return buffer_insert_emacs_char_1 (buf, pos, (Emchar) (unsigned char) c,
2662 buffer_insert_from_buffer_1 (struct buffer *buf, Bufpos pos,
2663 struct buffer *buf2, Bufpos pos2,
2664 Charcount length, int flags)
2666 /* This function can GC */
2667 Lisp_Object str = make_string_from_buffer (buf2, pos2, length);
2668 return buffer_insert_string_1 (buf, pos, 0, str, 0,
2669 XSTRING_LENGTH (str), flags);
2673 /************************************************************************/
2674 /* Deletion of ranges */
2675 /************************************************************************/
2677 /* Delete characters in buffer from FROM up to (but not including) TO. */
2680 buffer_delete_range (struct buffer *buf, Bufpos from, Bufpos to, int flags)
2682 /* This function can GC */
2684 Bytind bi_from, bi_to;
2685 Bytecount bc_numdel;
2687 struct buffer *mbuf;
2688 Lisp_Object bufcons;
2690 /* Defensive steps just in case a buffer gets deleted and a calling
2691 function doesn't notice it. */
2692 if (!BUFFER_LIVE_P (buf))
2695 /* Make args be valid */
2696 if (from < BUF_BEGV (buf))
2697 from = BUF_BEGV (buf);
2698 if (to > BUF_ZV (buf))
2700 if ((numdel = to - from) <= 0)
2703 prepare_to_modify_buffer (buf, from, to, !(flags & INSDEL_NO_LOCKING));
2705 /* Defensive steps in case the before-change-functions fuck around */
2706 if (!BUFFER_LIVE_P (buf))
2707 /* Bad bad pre-change function. */
2710 /* Make args be valid again. prepare_to_modify_buffer() might have
2711 modified the buffer. */
2712 if (from < BUF_BEGV (buf))
2713 from = BUF_BEGV (buf);
2714 if (to > BUF_ZV (buf))
2716 if ((numdel = to - from) <= 0)
2719 /* Redisplay needs to know if a newline was in the deleted region.
2720 If we've already marked the changed region as having a deleted
2721 newline there is no use in performing the check. */
2722 if (!buf->changes->newline_was_deleted)
2724 scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
2727 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2729 mbuf->changes->newline_was_deleted = 1;
2734 bi_from = bufpos_to_bytind (buf, from);
2735 bi_to = bufpos_to_bytind (buf, to);
2736 bc_numdel = bi_to - bi_from;
2738 delete_invalidate_line_number_cache (buf, from, to);
2740 if (to == BUF_Z (buf) &&
2741 bi_from > BI_BUF_GPT (buf))
2743 /* avoid moving the gap just to delete from the bottom. */
2745 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2747 record_delete (mbuf, from, numdel);
2750 MARK_BUFFERS_CHANGED;
2752 /* #### Point used to be modified here, but this causes problems
2753 with MULE, as point is used to calculate bytinds, and if the
2754 offset in bc_numdel causes point to move to a non first-byte
2755 location, causing some other function to throw an assertion
2756 in ASSERT_VALID_BYTIND. I've moved the code to right after
2757 the other movements and adjustments, but before the gap is
2758 moved. -- jh 970813 */
2760 /* Detach any extents that are completely within the range [FROM, TO],
2761 if the extents are detachable.
2763 This must come AFTER record_delete(), so that the appropriate
2764 extents will be present to be recorded, and BEFORE the gap
2765 size is increased, as otherwise we will be confused about
2766 where the extents end. */
2767 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2769 process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
2772 /* Relocate all markers pointing into the new, larger gap to
2773 point at the end of the text before the gap. */
2774 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2776 adjust_markers (mbuf,
2777 (bi_to + BUF_GAP_SIZE (mbuf)),
2778 (bi_to + BUF_GAP_SIZE (mbuf)),
2782 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2784 /* Relocate any extent endpoints just like markers. */
2785 adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
2786 BUF_GAP_SIZE (mbuf), bc_numdel, 0);
2789 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2791 /* Relocate point as if it were a marker. */
2792 if (bi_from < BI_BUF_PT (mbuf))
2794 if (BI_BUF_PT (mbuf) < bi_to)
2795 JUST_SET_POINT (mbuf, from, bi_from);
2797 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
2798 BI_BUF_PT (mbuf) - bc_numdel);
2802 SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + bc_numdel);
2804 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2806 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
2807 BI_BUF_ZV (mbuf) - bc_numdel);
2809 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
2810 SET_GAP_SENTINEL (buf);
2814 /* Make sure the gap is somewhere in or next to what we are deleting. */
2815 if (bi_to < BI_BUF_GPT (buf))
2816 gap_left (buf, bi_to);
2817 if (bi_from > BI_BUF_GPT (buf))
2818 gap_right (buf, bi_from);
2820 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2822 record_delete (mbuf, from, numdel);
2825 MARK_BUFFERS_CHANGED;
2827 /* #### Point used to be modified here, but this causes problems
2828 with MULE, as point is used to calculate bytinds, and if the
2829 offset in bc_numdel causes point to move to a non first-byte
2830 location, causing some other function to throw an assertion
2831 in ASSERT_VALID_BYTIND. I've moved the code to right after
2832 the other movements and adjustments, but before the gap is
2833 moved. -- jh 970813 */
2835 /* Detach any extents that are completely within the range [FROM, TO],
2836 if the extents are detachable.
2838 This must come AFTER record_delete(), so that the appropriate extents
2839 will be present to be recorded, and BEFORE the gap size is increased,
2840 as otherwise we will be confused about where the extents end. */
2841 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2843 process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
2846 /* Relocate all markers pointing into the new, larger gap to
2847 point at the end of the text before the gap. */
2848 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2850 adjust_markers (mbuf,
2851 (bi_to + BUF_GAP_SIZE (mbuf)),
2852 (bi_to + BUF_GAP_SIZE (mbuf)),
2853 (- bc_numdel - BUF_GAP_SIZE (mbuf)));
2856 /* Relocate any extent endpoints just like markers. */
2857 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2859 adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
2860 BUF_GAP_SIZE (mbuf),
2861 bc_numdel, BUF_GAP_SIZE (mbuf));
2864 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2866 /* Relocate point as if it were a marker. */
2867 if (bi_from < BI_BUF_PT (mbuf))
2869 if (BI_BUF_PT (mbuf) < bi_to)
2870 JUST_SET_POINT (mbuf, from, bi_from);
2872 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
2873 BI_BUF_PT (mbuf) - bc_numdel);
2877 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + bc_numdel);
2878 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2880 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
2881 BI_BUF_ZV (mbuf) - bc_numdel);
2883 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
2884 SET_BI_BUF_GPT (buf, bi_from);
2885 SET_GAP_SENTINEL (buf);
2889 buffer_mule_signal_deleted_region (buf, from, to, bi_from, bi_to);
2892 #ifdef ERROR_CHECK_EXTENTS
2893 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2895 sledgehammer_extent_check (make_buffer (mbuf));
2899 signal_after_change (buf, from, to, from);
2903 /************************************************************************/
2904 /* Replacement of characters */
2905 /************************************************************************/
2907 /* Replace the character at POS in buffer B with CH. */
2910 buffer_replace_char (struct buffer *buf, Bufpos pos, Emchar ch,
2911 int not_real_change, int force_lock_check)
2913 /* This function can GC */
2914 Bufbyte curstr[MAX_EMCHAR_LEN];
2915 Bufbyte newstr[MAX_EMCHAR_LEN];
2916 Bytecount curlen, newlen;
2918 /* Defensive steps just in case a buffer gets deleted and a calling
2919 function doesn't notice it. */
2920 if (!BUFFER_LIVE_P (buf))
2923 curlen = BUF_CHARPTR_COPY_CHAR (buf, pos, curstr);
2924 newlen = set_charptr_emchar (newstr, ch);
2926 if (curlen == newlen)
2928 struct buffer *mbuf;
2929 Lisp_Object bufcons;
2931 /* then we can just replace the text. */
2932 prepare_to_modify_buffer (buf, pos, pos + 1,
2933 !not_real_change || force_lock_check);
2934 /* Defensive steps in case the before-change-functions fuck around */
2935 if (!BUFFER_LIVE_P (buf))
2936 /* Bad bad pre-change function. */
2939 /* Make args be valid again. prepare_to_modify_buffer() might have
2940 modified the buffer. */
2941 if (pos < BUF_BEGV (buf))
2942 pos = BUF_BEGV (buf);
2943 if (pos >= BUF_ZV (buf))
2944 pos = BUF_ZV (buf) - 1;
2945 if (pos < BUF_BEGV (buf))
2946 /* no more characters in buffer! */
2949 if (BUF_FETCH_CHAR (buf, pos) == '\n')
2951 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2953 mbuf->changes->newline_was_deleted = 1;
2956 MARK_BUFFERS_CHANGED;
2957 if (!not_real_change)
2959 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2961 record_change (mbuf, pos, 1);
2965 memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
2967 signal_after_change (buf, pos, pos + 1, pos + 1);
2969 /* We do not have to adjust the Mule data; we just replaced a
2970 character with another of the same number of bytes. */
2975 * Must implement as deletion followed by insertion.
2977 * Make a note to move point forward later in the one situation
2978 * where it is needed, a delete/insert one position behind
2979 * point. Point will drift backward by one position and stay
2982 int movepoint = (pos == BUF_PT (buf) - 1);
2984 buffer_delete_range (buf, pos, pos + 1, 0);
2985 /* Defensive steps in case the before-change-functions fuck around */
2986 if (!BUFFER_LIVE_P (buf))
2987 /* Bad bad pre-change function. */
2990 /* Make args be valid again. prepare_to_modify_buffer() might have
2991 modified the buffer. */
2992 if (pos < BUF_BEGV (buf))
2993 pos = BUF_BEGV (buf);
2994 if (pos >= BUF_ZV (buf))
2995 pos = BUF_ZV (buf) - 1;
2996 if (pos < BUF_BEGV (buf))
2997 /* no more characters in buffer! */
3000 * -1 as the pos argument means to move point forward with the
3001 * insertion, which we must do if the deletion moved point
3002 * backward so that it now equals the insertion point.
3004 buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
3005 newstr, Qnil, 0, newlen, 0);
3010 /************************************************************************/
3011 /* Other functions */
3012 /************************************************************************/
3014 /* Make a string from a buffer. This needs to take into account the gap,
3015 and add any necessary extents from the buffer. */
3018 make_string_from_buffer_1 (struct buffer *buf, Bufpos pos, Charcount length,
3021 /* This function can GC */
3022 Bytind bi_ind = bufpos_to_bytind (buf, pos);
3023 Bytecount bi_len = bufpos_to_bytind (buf, pos + length) - bi_ind;
3024 Lisp_Object val = make_uninit_string (bi_len);
3026 struct gcpro gcpro1;
3030 add_string_extents (val, buf, bi_ind, bi_len);
3033 Bytecount len1 = BI_BUF_GPT (buf) - bi_ind;
3034 Bufbyte *start1 = BI_BUF_BYTE_ADDRESS (buf, bi_ind);
3035 Bufbyte *dest = XSTRING_DATA (val);
3039 /* Completely after gap */
3040 memcpy (dest, start1, bi_len);
3042 else if (bi_len <= len1)
3044 /* Completely before gap */
3045 memcpy (dest, start1, bi_len);
3050 Bytind pos2 = bi_ind + len1;
3051 Bufbyte *start2 = BI_BUF_BYTE_ADDRESS (buf, pos2);
3053 memcpy (dest, start1, len1);
3054 memcpy (dest + len1, start2, bi_len - len1);
3063 make_string_from_buffer (struct buffer *buf, Bufpos pos, Charcount length)
3065 return make_string_from_buffer_1 (buf, pos, length, 0);
3069 make_string_from_buffer_no_extents (struct buffer *buf, Bufpos pos,
3072 return make_string_from_buffer_1 (buf, pos, length, 1);
3076 barf_if_buffer_read_only (struct buffer *buf, Bufpos from, Bufpos to)
3081 XSETBUFFER (buffer, buf);
3083 iro = (buf == current_buffer ? Vinhibit_read_only :
3084 symbol_value_in_buffer (Qinhibit_read_only, buffer));
3087 if (NILP (iro) && !NILP (buf->read_only))
3089 Fsignal (Qbuffer_read_only, (list1 (buffer)));
3096 verify_extent_modification (buffer,
3097 bufpos_to_bytind (buf, from),
3098 bufpos_to_bytind (buf, to),
3104 find_charsets_in_bufbyte_string (unsigned char *charsets, CONST Bufbyte *str,
3108 /* Telescope this. */
3111 CONST Bufbyte *strend = str + len;
3112 memset (charsets, 0, NUM_LEADING_BYTES);
3114 while (str < strend)
3116 charsets[CHAR_LEADING_BYTE (charptr_emchar (str)) - 128] = 1;
3123 find_charsets_in_emchar_string (unsigned char *charsets, CONST Emchar *str,
3127 /* Telescope this. */
3132 memset (charsets, 0, NUM_LEADING_BYTES);
3133 for (i = 0; i < len; i++)
3135 charsets[CHAR_LEADING_BYTE (str[i]) - 128] = 1;
3141 bufbyte_string_displayed_columns (CONST Bufbyte *str, Bytecount len)
3144 CONST Bufbyte *end = str + len;
3149 Emchar ch = charptr_emchar (str);
3150 cols += XCHARSET_COLUMNS (CHAR_CHARSET (ch));
3161 emchar_string_displayed_columns (CONST Emchar *str, Charcount len)
3167 for (i = 0; i < len; i++)
3168 cols += XCHARSET_COLUMNS (CHAR_CHARSET (str[i]));
3171 #else /* not MULE */
3176 /* NOTE: Does not reset the Dynarr. */
3179 convert_bufbyte_string_into_emchar_dynarr (CONST Bufbyte *str, Bytecount len,
3182 CONST Bufbyte *strend = str + len;
3184 while (str < strend)
3186 Emchar ch = charptr_emchar (str);
3187 Dynarr_add (dyn, ch);
3193 convert_bufbyte_string_into_emchar_string (CONST Bufbyte *str, Bytecount len,
3196 CONST Bufbyte *strend = str + len;
3197 Charcount newlen = 0;
3198 while (str < strend)
3200 Emchar ch = charptr_emchar (str);
3207 /* Convert an array of Emchars into the equivalent string representation.
3208 Store into the given Bufbyte dynarr. Does not reset the dynarr.
3209 Does not add a terminating zero. */
3212 convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
3213 Bufbyte_dynarr *dyn)
3215 Bufbyte str[MAX_EMCHAR_LEN];
3218 for (i = 0; i < nels; i++)
3220 Bytecount len = set_charptr_emchar (str, arr[i]);
3221 Dynarr_add_many (dyn, str, len);
3225 /* Convert an array of Emchars into the equivalent string representation.
3226 Malloc the space needed for this and return it. If LEN_OUT is not a
3227 NULL pointer, store into LEN_OUT the number of Bufbytes in the
3228 malloc()ed string. Note that the actual number of Bufbytes allocated
3229 is one more than this: the returned string is zero-terminated. */
3232 convert_emchar_string_into_malloced_string (Emchar *arr, int nels,
3235 /* Damn zero-termination. */
3236 Bufbyte *str = (Bufbyte *) alloca (nels * MAX_EMCHAR_LEN + 1);
3237 Bufbyte *strorig = str;
3242 for (i = 0; i < nels; i++)
3243 str += set_charptr_emchar (str, arr[i]);
3245 len = str - strorig;
3246 str = (Bufbyte *) xmalloc (1 + len);
3247 memcpy (str, strorig, 1 + len);
3254 /************************************************************************/
3255 /* initialization */
3256 /************************************************************************/
3259 reinit_vars_of_insdel (void)
3263 inside_change_hook = 0;
3264 in_first_change = 0;
3266 for (i = 0; i <= MAX_BYTIND_GAP_SIZE_3; i++)
3267 three_to_one_table[i] = i / 3;
3271 vars_of_insdel (void)
3273 reinit_vars_of_insdel ();
3277 init_buffer_text (struct buffer *b)
3279 if (!b->base_buffer)
3281 SET_BUF_GAP_SIZE (b, 20);
3282 BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
3283 if (! BUF_BEG_ADDR (b))
3286 SET_BUF_END_GAP_SIZE (b, 0);
3287 SET_BI_BUF_GPT (b, 1);
3288 SET_BOTH_BUF_Z (b, 1, 1);
3289 SET_GAP_SENTINEL (b);
3290 SET_END_SENTINEL (b);
3295 b->text->mule_bufmin = b->text->mule_bufmax = 1;
3296 b->text->mule_bytmin = b->text->mule_bytmax = 1;
3297 b->text->mule_shifter = 0;
3298 b->text->mule_three_p = 0;
3300 for (i = 0; i < 16; i++)
3302 b->text->mule_bufpos_cache[i] = 1;
3303 b->text->mule_bytind_cache[i] = 1;
3307 b->text->line_number_cache = Qnil;
3310 BUF_SAVE_MODIFF (b) = 1;
3312 JUST_SET_POINT (b, 1, 1);
3313 SET_BOTH_BUF_BEGV (b, 1, 1);
3314 SET_BOTH_BUF_ZV (b, 1, 1);
3316 b->text->changes = xnew_and_zero (struct buffer_text_change_data);
3320 JUST_SET_POINT (b, BUF_PT (b->base_buffer), BI_BUF_PT (b->base_buffer));
3321 SET_BOTH_BUF_BEGV (b, BUF_BEGV (b->base_buffer),
3322 BI_BUF_BEGV (b->base_buffer));
3323 SET_BOTH_BUF_ZV (b, BUF_ZV (b->base_buffer),
3324 BI_BUF_ZV (b->base_buffer));
3327 b->changes = xnew_and_zero (struct each_buffer_change_data);
3328 BUF_FACECHANGE (b) = 1;
3330 #ifdef REGION_CACHE_NEEDS_WORK
3331 b->newline_cache = 0;
3332 b->width_run_cache = 0;
3333 b->width_table = Qnil;
3338 uninit_buffer_text (struct buffer *b)
3340 if (!b->base_buffer)
3342 BUFFER_FREE (b->text->beg);
3343 xfree (b->text->changes);
3347 #ifdef REGION_CACHE_NEEDS_WORK
3348 if (b->newline_cache)
3350 free_region_cache (b->newline_cache);
3351 b->newline_cache = 0;
3353 if (b->width_run_cache)
3355 free_region_cache (b->width_run_cache);
3356 b->width_run_cache = 0;
3358 b->width_table = Qnil;