--- /dev/null
+/* Buffer insertion/deletion and gap motion for XEmacs.
+ Copyright (C) 1985, 1986, 1991, 1992, 1993, 1994, 1995
+ Free Software Foundation, Inc.
+ Copyright (C) 1995 Sun Microsystems, Inc.
+
+This file is part of XEmacs.
+
+XEmacs is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+XEmacs is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with XEmacs; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
+/* Synched up with: Mule 2.0, FSF 19.30. Diverges significantly. */
+
+/* This file has been Mule-ized. */
+
+/* Overhauled by Ben Wing, December 1994, for Mule implementation. */
+
+/*
+ There are three possible ways to specify positions in a buffer. All
+ of these are one-based: the beginning of the buffer is position or
+ index 1, and 0 is not a valid position.
+
+ As a "buffer position" (typedef Bufpos):
+
+ This is an index specifying an offset in characters from the
+ beginning of the buffer. Note that buffer positions are
+ logically *between* characters, not on a character. The
+ difference between two buffer positions specifies the number of
+ characters between those positions. Buffer positions are the
+ only kind of position externally visible to the user.
+
+ As a "byte index" (typedef Bytind):
+
+ This is an index over the bytes used to represent the characters
+ in the buffer. If there is no Mule support, this is identical
+ to a buffer position, because each character is represented
+ using one byte. However, with Mule support, many characters
+ require two or more bytes for their representation, and so a
+ byte index may be greater than the corresponding buffer
+ position.
+
+ As a "memory index" (typedef Memind):
+
+ This is the byte index adjusted for the gap. For positions
+ before the gap, this is identical to the byte index. For
+ positions after the gap, this is the byte index plus the gap
+ size. There are two possible memory indices for the gap
+ position; the memory index at the beginning of the gap should
+ always be used, except in code that deals with manipulating the
+ gap, where both indices may be seen. The address of the
+ character "at" (i.e. following) a particular position can be
+ obtained from the formula
+
+ buffer_start_address + memory_index(position) - 1
+
+ except in the case of characters at the gap position.
+
+ Other typedefs:
+ ===============
+
+ Emchar:
+ -------
+ This typedef represents a single Emacs character, which can be
+ ASCII, ISO-8859, or some extended character, as would typically
+ be used for Kanji. Note that the representation of a character
+ as an Emchar is *not* the same as the representation of that
+ same character in a string; thus, you cannot do the standard
+ C trick of passing a pointer to a character to a function that
+ expects a string.
+
+ An Emchar takes up 19 bits of representation and (for code
+ compatibility and such) is compatible with an int. This
+ representation is visible on the Lisp level. The important
+ characteristics of the Emchar representation are
+
+ -- values 0x00 - 0x7f represent ASCII.
+ -- values 0x80 - 0xff represent the right half of ISO-8859-1.
+ -- values 0x100 and up represent all other characters.
+
+ This means that Emchar values are upwardly compatible with
+ the standard 8-bit representation of ASCII/ISO-8859-1.
+
+ Bufbyte:
+ --------
+ The data in a buffer or string is logically made up of Bufbyte
+ objects, where a Bufbyte takes up the same amount of space as a
+ char. (It is declared differently, though, to catch invalid
+ usages.) Strings stored using Bufbytes are said to be in
+ "internal format". The important characteristics of internal
+ format are
+
+ -- ASCII characters are represented as a single Bufbyte,
+ in the range 0 - 0x7f.
+ -- All other characters are represented as a Bufbyte in
+ the range 0x80 - 0x9f followed by one or more Bufbytes
+ in the range 0xa0 to 0xff.
+
+ This leads to a number of desirable properties:
+
+ -- Given the position of the beginning of a character,
+ you can find the beginning of the next or previous
+ character in constant time.
+ -- When searching for a substring or an ASCII character
+ within the string, you need merely use standard
+ searching routines.
+
+ array of char:
+ --------------
+ Strings that go in or out of Emacs are in "external format",
+ typedef'ed as an array of char or a char *. There is more
+ than one external format (JIS, EUC, etc.) but they all
+ have similar properties. They are modal encodings,
+ which is to say that the meaning of particular bytes is
+ not fixed but depends on what "mode" the string is currently
+ in (e.g. bytes in the range 0 - 0x7f might be
+ interpreted as ASCII, or as Hiragana, or as 2-byte Kanji,
+ depending on the current mode). The mode starts out in
+ ASCII/ISO-8859-1 and is switched using escape sequences --
+ for example, in the JIS encoding, 'ESC $ B' switches to a
+ mode where pairs of bytes in the range 0 - 0x7f
+ are interpreted as Kanji characters.
+
+ External-formatted data is generally desirable for passing
+ data between programs because it is upwardly compatible
+ with standard ASCII/ISO-8859-1 strings and may require
+ less space than internal encodings such as the one
+ described above. In addition, some encodings (e.g. JIS)
+ keep all characters (except the ESC used to switch modes)
+ in the printing ASCII range 0x20 - 0x7e, which results in
+ a much higher probability that the data will avoid being
+ garbled in transmission. Externally-formatted data is
+ generally not very convenient to work with, however, and
+ for this reason is usually converted to internal format
+ before any work is done on the string.
+
+ NOTE: filenames need to be in external format so that
+ ISO-8859-1 characters come out correctly.
+
+ Charcount:
+ ----------
+ This typedef represents a count of characters, such as
+ a character offset into a string or the number of
+ characters between two positions in a buffer. The
+ difference between two Bufpos's is a Charcount, and
+ character positions in a string are represented using
+ a Charcount.
+
+ Bytecount:
+ ----------
+ Similar to a Charcount but represents a count of bytes.
+ The difference between two Bytind's is a Bytecount.
+
+
+ Usage of the various representations:
+ =====================================
+
+ Memory indices are used in low-level functions in insdel.c and for
+ extent endpoints and marker positions. The reason for this is that
+ this way, the extents and markers don't need to be updated for most
+ insertions, which merely shrink the gap and don't move any
+ characters around in memory.
+
+ (The beginning-of-gap memory index simplifies insertions w.r.t.
+ markers, because text usually gets inserted after markers. For
+ extents, it is merely for consistency, because text can get
+ inserted either before or after an extent's endpoint depending on
+ the open/closedness of the endpoint.)
+
+ Byte indices are used in other code that needs to be fast,
+ such as the searching, redisplay, and extent-manipulation code.
+
+ Buffer positions are used in all other code. This is because this
+ representation is easiest to work with (especially since Lisp
+ code always uses buffer positions), necessitates the fewest
+ changes to existing code, and is the safest (e.g. if the text gets
+ shifted underneath a buffer position, it will still point to a
+ character; if text is shifted under a byte index, it might point
+ to the middle of a character, which would be bad).
+
+ Similarly, Charcounts are used in all code that deals with strings
+ except for code that needs to be fast, which used Bytecounts.
+
+ Strings are always passed around internally using internal format.
+ Conversions between external format are performed at the time
+ that the data goes in or out of Emacs.
+
+ Working with the various representations:
+ ========================================= */
+
+#include <config.h>
+#include "lisp.h"
+
+#include "buffer.h"
+#include "device.h"
+#include "frame.h"
+#include "extents.h"
+#include "insdel.h"
+#include "lstream.h"
+#include "redisplay.h"
+#include "line-number.h"
+
+/* We write things this way because it's very important the
+ MAX_BYTIND_GAP_SIZE_3 is a multiple of 3. (As it happens,
+ 65535 is a multiple of 3, but this may not always be the
+ case.) */
+
+#define MAX_BUFPOS_GAP_SIZE_3 (65535/3)
+#define MAX_BYTIND_GAP_SIZE_3 (3 * MAX_BUFPOS_GAP_SIZE_3)
+
+short three_to_one_table[1 + MAX_BYTIND_GAP_SIZE_3];
+
+/* Various macros modelled along the lines of those in buffer.h.
+ Purposefully omitted from buffer.h because files other than this
+ one should not be using them. */
+
+/* Address of beginning of buffer. This is an lvalue because
+ BUFFER_ALLOC needs it to be. */
+#define BUF_BEG_ADDR(buf) ((buf)->text->beg)
+
+/* Set the address of beginning of buffer. */
+#define SET_BUF_BEG_ADDR(buf, addr) do { (buf)->text->beg = (addr); } while (0)
+
+/* Gap size. */
+#define BUF_GAP_SIZE(buf) ((buf)->text->gap_size + 0)
+#define BUF_END_GAP_SIZE(buf) ((buf)->text->end_gap_size + 0)
+/* Set gap size. */
+#define SET_BUF_GAP_SIZE(buf, value) \
+ do { (buf)->text->gap_size = (value); } while (0)
+#define SET_BUF_END_GAP_SIZE(buf, value) \
+ do { (buf)->text->end_gap_size = (value); } while (0)
+
+/* Gap location. */
+#define BI_BUF_GPT(buf) ((buf)->text->gpt + 0)
+#define BUF_GPT_ADDR(buf) (BUF_BEG_ADDR (buf) + BI_BUF_GPT (buf) - 1)
+
+/* Set gap location. */
+#define SET_BI_BUF_GPT(buf, value) do { (buf)->text->gpt = (value); } while (0)
+
+/* Set end of buffer. */
+#define SET_BOTH_BUF_Z(buf, val, bival) \
+do \
+{ \
+ (buf)->text->z = (bival); \
+ (buf)->text->bufz = (val); \
+} while (0)
+
+/* Under Mule, we maintain two sentinels in the buffer: one at the
+ beginning of the gap, and one at the end of the buffer. This
+ allows us to move forward, examining bytes looking for the
+ end of a character, and not worry about running off the end.
+ We do not need corresponding sentinels when moving backwards
+ because we do not have to look past the beginning of a character
+ to find the beginning of the character.
+
+ Every time we change the beginning of the gap, we have to
+ call SET_GAP_SENTINEL().
+
+ Every time we change the total size (characters plus gap)
+ of the buffer, we have to call SET_END_SENTINEL().
+ */
+
+
+#ifdef MULE
+# define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len) + 1)
+# define SET_GAP_SENTINEL(buf) (*BUF_GPT_ADDR (buf) = 0)
+# define BUF_END_SENTINEL_SIZE 1
+# define SET_END_SENTINEL(buf) \
+ (*(BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + BI_BUF_Z (buf) - 1) = 0)
+#else
+# define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len))
+# define SET_GAP_SENTINEL(buf)
+# define BUF_END_SENTINEL_SIZE 0
+# define SET_END_SENTINEL(buf)
+#endif
+
+\f
+/************************************************************************/
+/* Charcount/Bytecount conversion */
+/************************************************************************/
+
+/* Optimization. Do it. Live it. Love it. */
+
+#ifdef MULE
+
+/* We include the basic functions here that require no specific
+ knowledge of how data is Mule-encoded into a buffer other
+ than the basic (00 - 7F), (80 - 9F), (A0 - FF) scheme.
+ Anything that requires more specific knowledge goes into
+ mule-charset.c. */
+
+/* Given a pointer to a text string and a length in bytes, return
+ the equivalent length in characters. */
+
+Charcount
+bytecount_to_charcount (const Bufbyte *ptr, Bytecount len)
+{
+ Charcount count = 0;
+ const Bufbyte *end = ptr + len;
+
+#if SIZEOF_LONG == 8
+# define STRIDE_TYPE long
+# define HIGH_BIT_MASK 0x8080808080808080UL
+#elif SIZEOF_LONG_LONG == 8 && !(defined (i386) || defined (__i386__))
+# define STRIDE_TYPE long long
+# define HIGH_BIT_MASK 0x8080808080808080ULL
+#elif SIZEOF_LONG == 4
+# define STRIDE_TYPE long
+# define HIGH_BIT_MASK 0x80808080UL
+#else
+# error Add support for 128-bit systems here
+#endif
+
+#define ALIGN_BITS ((EMACS_UINT) (ALIGNOF (STRIDE_TYPE) - 1))
+#define ALIGN_MASK (~ ALIGN_BITS)
+#define ALIGNED(ptr) ((((EMACS_UINT) ptr) & ALIGN_BITS) == 0)
+#define STRIDE sizeof (STRIDE_TYPE)
+
+ while (ptr < end)
+ {
+ if (BYTE_ASCII_P (*ptr))
+ {
+ /* optimize for long stretches of ASCII */
+ if (! ALIGNED (ptr))
+ ptr++, count++;
+ else
+ {
+ const unsigned STRIDE_TYPE *ascii_end =
+ (const unsigned STRIDE_TYPE *) ptr;
+ /* This loop screams, because we can typically
+ detect ASCII characters 8 at a time. */
+ while ((const Bufbyte *) ascii_end + STRIDE <= end
+ && !(*ascii_end & HIGH_BIT_MASK))
+ ascii_end++;
+ if ((Bufbyte *) ascii_end == ptr)
+ ptr++, count++;
+ else
+ {
+ count += (Bufbyte *) ascii_end - ptr;
+ ptr = (Bufbyte *) ascii_end;
+ }
+ }
+ }
+ else
+ {
+ /* optimize for successive characters from the same charset */
+ Bufbyte leading_byte = *ptr;
+ size_t bytes = REP_BYTES_BY_FIRST_BYTE (leading_byte);
+ while ((ptr < end) && (*ptr == leading_byte))
+ ptr += bytes, count++;
+ }
+ }
+
+#ifdef ERROR_CHECK_BUFPOS
+ /* Bomb out if the specified substring ends in the middle
+ of a character. Note that we might have already gotten
+ a core dump above from an invalid reference, but at least
+ we will get no farther than here. */
+ assert (ptr == end);
+#endif
+
+ return count;
+}
+
+/* Given a pointer to a text string and a length in characters, return
+ the equivalent length in bytes. */
+
+Bytecount
+charcount_to_bytecount (const Bufbyte *ptr, Charcount len)
+{
+ const Bufbyte *newptr = ptr;
+
+ while (len > 0)
+ {
+ INC_CHARPTR (newptr);
+ len--;
+ }
+ return newptr - ptr;
+}
+
+/* The next two functions are the actual meat behind the
+ bufpos-to-bytind and bytind-to-bufpos conversions. Currently
+ the method they use is fairly unsophisticated; see buffer.h.
+
+ Note that bufpos_to_bytind_func() is probably the most-called
+ function in all of XEmacs. Therefore, it must be FAST FAST FAST.
+ This is the reason why so much of the code is duplicated.
+
+ Similar considerations apply to bytind_to_bufpos_func(), although
+ less so because the function is not called so often.
+
+ #### At some point this should use a more sophisticated method;
+ see buffer.h. */
+
+static int not_very_random_number;
+
+Bytind
+bufpos_to_bytind_func (struct buffer *buf, Bufpos x)
+{
+ Bufpos bufmin;
+ Bufpos bufmax;
+ Bytind bytmin;
+ Bytind bytmax;
+ int size;
+ int forward_p;
+ Bytind retval;
+ int diff_so_far;
+ int add_to_cache = 0;
+
+ /* Check for some cached positions, for speed. */
+ if (x == BUF_PT (buf))
+ return BI_BUF_PT (buf);
+ if (x == BUF_ZV (buf))
+ return BI_BUF_ZV (buf);
+ if (x == BUF_BEGV (buf))
+ return BI_BUF_BEGV (buf);
+
+ bufmin = buf->text->mule_bufmin;
+ bufmax = buf->text->mule_bufmax;
+ bytmin = buf->text->mule_bytmin;
+ bytmax = buf->text->mule_bytmax;
+ size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
+
+ /* The basic idea here is that we shift the "known region" up or down
+ until it overlaps the specified position. We do this by moving
+ the upper bound of the known region up one character at a time,
+ and moving the lower bound of the known region up as necessary
+ when the size of the character just seen changes.
+
+ We optimize this, however, by first shifting the known region to
+ one of the cached points if it's close by. (We don't check BEG or
+ Z, even though they're cached; most of the time these will be the
+ same as BEGV and ZV, and when they're not, they're not likely
+ to be used.) */
+
+ if (x > bufmax)
+ {
+ Bufpos diffmax = x - bufmax;
+ Bufpos diffpt = x - BUF_PT (buf);
+ Bufpos diffzv = BUF_ZV (buf) - x;
+ /* #### This value could stand some more exploration. */
+ Charcount heuristic_hack = (bufmax - bufmin) >> 2;
+
+ /* Check if the position is closer to PT or ZV than to the
+ end of the known region. */
+
+ if (diffpt < 0)
+ diffpt = -diffpt;
+ if (diffzv < 0)
+ diffzv = -diffzv;
+
+ /* But also implement a heuristic that favors the known region
+ over PT or ZV. The reason for this is that switching to
+ PT or ZV will wipe out the knowledge in the known region,
+ which might be annoying if the known region is large and
+ PT or ZV is not that much closer than the end of the known
+ region. */
+
+ diffzv += heuristic_hack;
+ diffpt += heuristic_hack;
+ if (diffpt < diffmax && diffpt <= diffzv)
+ {
+ bufmax = bufmin = BUF_PT (buf);
+ bytmax = bytmin = BI_BUF_PT (buf);
+ /* We set the size to 1 even though it doesn't really
+ matter because the new known region contains no
+ characters. We do this because this is the most
+ likely size of the characters around the new known
+ region, and we avoid potential yuckiness that is
+ done when size == 3. */
+ size = 1;
+ }
+ if (diffzv < diffmax)
+ {
+ bufmax = bufmin = BUF_ZV (buf);
+ bytmax = bytmin = BI_BUF_ZV (buf);
+ size = 1;
+ }
+ }
+#ifdef ERROR_CHECK_BUFPOS
+ else if (x >= bufmin)
+ ABORT ();
+#endif
+ else
+ {
+ Bufpos diffmin = bufmin - x;
+ Bufpos diffpt = BUF_PT (buf) - x;
+ Bufpos diffbegv = x - BUF_BEGV (buf);
+ /* #### This value could stand some more exploration. */
+ Charcount heuristic_hack = (bufmax - bufmin) >> 2;
+
+ if (diffpt < 0)
+ diffpt = -diffpt;
+ if (diffbegv < 0)
+ diffbegv = -diffbegv;
+
+ /* But also implement a heuristic that favors the known region --
+ see above. */
+
+ diffbegv += heuristic_hack;
+ diffpt += heuristic_hack;
+
+ if (diffpt < diffmin && diffpt <= diffbegv)
+ {
+ bufmax = bufmin = BUF_PT (buf);
+ bytmax = bytmin = BI_BUF_PT (buf);
+ /* We set the size to 1 even though it doesn't really
+ matter because the new known region contains no
+ characters. We do this because this is the most
+ likely size of the characters around the new known
+ region, and we avoid potential yuckiness that is
+ done when size == 3. */
+ size = 1;
+ }
+ if (diffbegv < diffmin)
+ {
+ bufmax = bufmin = BUF_BEGV (buf);
+ bytmax = bytmin = BI_BUF_BEGV (buf);
+ size = 1;
+ }
+ }
+
+ diff_so_far = x > bufmax ? x - bufmax : bufmin - x;
+ if (diff_so_far > 50)
+ {
+ /* If we have to move more than a certain amount, then look
+ into our cache. */
+ int minval = INT_MAX;
+ int found = 0;
+ int i;
+
+ add_to_cache = 1;
+ /* I considered keeping the positions ordered. This would speed
+ up this loop, but updating the cache would take longer, so
+ it doesn't seem like it would really matter. */
+ for (i = 0; i < 16; i++)
+ {
+ int diff = buf->text->mule_bufpos_cache[i] - x;
+
+ if (diff < 0)
+ diff = -diff;
+ if (diff < minval)
+ {
+ minval = diff;
+ found = i;
+ }
+ }
+
+ if (minval < diff_so_far)
+ {
+ bufmax = bufmin = buf->text->mule_bufpos_cache[found];
+ bytmax = bytmin = buf->text->mule_bytind_cache[found];
+ size = 1;
+ }
+ }
+
+ /* It's conceivable that the caching above could lead to X being
+ the same as one of the range edges. */
+ if (x >= bufmax)
+ {
+ Bytind newmax;
+ Bytecount newsize;
+
+ forward_p = 1;
+ while (x > bufmax)
+ {
+ newmax = bytmax;
+
+ INC_BYTIND (buf, newmax);
+ newsize = newmax - bytmax;
+ if (newsize != size)
+ {
+ bufmin = bufmax;
+ bytmin = bytmax;
+ size = newsize;
+ }
+ bytmax = newmax;
+ bufmax++;
+ }
+ retval = bytmax;
+
+ /* #### Should go past the found location to reduce the number
+ of times that this function is called */
+ }
+ else /* x < bufmin */
+ {
+ Bytind newmin;
+ Bytecount newsize;
+
+ forward_p = 0;
+ while (x < bufmin)
+ {
+ newmin = bytmin;
+
+ DEC_BYTIND (buf, newmin);
+ newsize = bytmin - newmin;
+ if (newsize != size)
+ {
+ bufmax = bufmin;
+ bytmax = bytmin;
+ size = newsize;
+ }
+ bytmin = newmin;
+ bufmin--;
+ }
+ retval = bytmin;
+
+ /* #### Should go past the found location to reduce the number
+ of times that this function is called
+ */
+ }
+
+ /* If size is three, than we have to max sure that the range we
+ discovered isn't too large, because we use a fixed-length
+ table to divide by 3. */
+
+ if (size == 3)
+ {
+ int gap = bytmax - bytmin;
+ buf->text->mule_three_p = 1;
+ buf->text->mule_shifter = 1;
+
+ if (gap > MAX_BYTIND_GAP_SIZE_3)
+ {
+ if (forward_p)
+ {
+ bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
+ bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
+ }
+ else
+ {
+ bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
+ bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
+ }
+ }
+ }
+ else
+ {
+ buf->text->mule_three_p = 0;
+ if (size == 4)
+ buf->text->mule_shifter = 2;
+ else
+ buf->text->mule_shifter = size - 1;
+ }
+
+ buf->text->mule_bufmin = bufmin;
+ buf->text->mule_bufmax = bufmax;
+ buf->text->mule_bytmin = bytmin;
+ buf->text->mule_bytmax = bytmax;
+
+ if (add_to_cache)
+ {
+ int replace_loc;
+
+ /* We throw away a "random" cached value and replace it with
+ the new value. It doesn't actually have to be very random
+ at all, just evenly distributed.
+
+ #### It would be better to use a least-recently-used algorithm
+ or something that tries to space things out, but I'm not sure
+ it's worth it to go to the trouble of maintaining that. */
+ not_very_random_number += 621;
+ replace_loc = not_very_random_number & 15;
+ buf->text->mule_bufpos_cache[replace_loc] = x;
+ buf->text->mule_bytind_cache[replace_loc] = retval;
+ }
+
+ return retval;
+}
+
+/* The logic in this function is almost identical to the logic in
+ the previous function. */
+
+Bufpos
+bytind_to_bufpos_func (struct buffer *buf, Bytind x)
+{
+ Bufpos bufmin;
+ Bufpos bufmax;
+ Bytind bytmin;
+ Bytind bytmax;
+ int size;
+ int forward_p;
+ Bufpos retval;
+ int diff_so_far;
+ int add_to_cache = 0;
+
+ /* Check for some cached positions, for speed. */
+ if (x == BI_BUF_PT (buf))
+ return BUF_PT (buf);
+ if (x == BI_BUF_ZV (buf))
+ return BUF_ZV (buf);
+ if (x == BI_BUF_BEGV (buf))
+ return BUF_BEGV (buf);
+
+ bufmin = buf->text->mule_bufmin;
+ bufmax = buf->text->mule_bufmax;
+ bytmin = buf->text->mule_bytmin;
+ bytmax = buf->text->mule_bytmax;
+ size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
+
+ /* The basic idea here is that we shift the "known region" up or down
+ until it overlaps the specified position. We do this by moving
+ the upper bound of the known region up one character at a time,
+ and moving the lower bound of the known region up as necessary
+ when the size of the character just seen changes.
+
+ We optimize this, however, by first shifting the known region to
+ one of the cached points if it's close by. (We don't check BI_BEG or
+ BI_Z, even though they're cached; most of the time these will be the
+ same as BI_BEGV and BI_ZV, and when they're not, they're not likely
+ to be used.) */
+
+ if (x > bytmax)
+ {
+ Bytind diffmax = x - bytmax;
+ Bytind diffpt = x - BI_BUF_PT (buf);
+ Bytind diffzv = BI_BUF_ZV (buf) - x;
+ /* #### This value could stand some more exploration. */
+ Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
+
+ /* Check if the position is closer to PT or ZV than to the
+ end of the known region. */
+
+ if (diffpt < 0)
+ diffpt = -diffpt;
+ if (diffzv < 0)
+ diffzv = -diffzv;
+
+ /* But also implement a heuristic that favors the known region
+ over BI_PT or BI_ZV. The reason for this is that switching to
+ BI_PT or BI_ZV will wipe out the knowledge in the known region,
+ which might be annoying if the known region is large and
+ BI_PT or BI_ZV is not that much closer than the end of the known
+ region. */
+
+ diffzv += heuristic_hack;
+ diffpt += heuristic_hack;
+ if (diffpt < diffmax && diffpt <= diffzv)
+ {
+ bufmax = bufmin = BUF_PT (buf);
+ bytmax = bytmin = BI_BUF_PT (buf);
+ /* We set the size to 1 even though it doesn't really
+ matter because the new known region contains no
+ characters. We do this because this is the most
+ likely size of the characters around the new known
+ region, and we avoid potential yuckiness that is
+ done when size == 3. */
+ size = 1;
+ }
+ if (diffzv < diffmax)
+ {
+ bufmax = bufmin = BUF_ZV (buf);
+ bytmax = bytmin = BI_BUF_ZV (buf);
+ size = 1;
+ }
+ }
+#ifdef ERROR_CHECK_BUFPOS
+ else if (x >= bytmin)
+ ABORT ();
+#endif
+ else
+ {
+ Bytind diffmin = bytmin - x;
+ Bytind diffpt = BI_BUF_PT (buf) - x;
+ Bytind diffbegv = x - BI_BUF_BEGV (buf);
+ /* #### This value could stand some more exploration. */
+ Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
+
+ if (diffpt < 0)
+ diffpt = -diffpt;
+ if (diffbegv < 0)
+ diffbegv = -diffbegv;
+
+ /* But also implement a heuristic that favors the known region --
+ see above. */
+
+ diffbegv += heuristic_hack;
+ diffpt += heuristic_hack;
+
+ if (diffpt < diffmin && diffpt <= diffbegv)
+ {
+ bufmax = bufmin = BUF_PT (buf);
+ bytmax = bytmin = BI_BUF_PT (buf);
+ /* We set the size to 1 even though it doesn't really
+ matter because the new known region contains no
+ characters. We do this because this is the most
+ likely size of the characters around the new known
+ region, and we avoid potential yuckiness that is
+ done when size == 3. */
+ size = 1;
+ }
+ if (diffbegv < diffmin)
+ {
+ bufmax = bufmin = BUF_BEGV (buf);
+ bytmax = bytmin = BI_BUF_BEGV (buf);
+ size = 1;
+ }
+ }
+
+ diff_so_far = x > bytmax ? x - bytmax : bytmin - x;
+ if (diff_so_far > 50)
+ {
+ /* If we have to move more than a certain amount, then look
+ into our cache. */
+ int minval = INT_MAX;
+ int found = 0;
+ int i;
+
+ add_to_cache = 1;
+ /* I considered keeping the positions ordered. This would speed
+ up this loop, but updating the cache would take longer, so
+ it doesn't seem like it would really matter. */
+ for (i = 0; i < 16; i++)
+ {
+ int diff = buf->text->mule_bytind_cache[i] - x;
+
+ if (diff < 0)
+ diff = -diff;
+ if (diff < minval)
+ {
+ minval = diff;
+ found = i;
+ }
+ }
+
+ if (minval < diff_so_far)
+ {
+ bufmax = bufmin = buf->text->mule_bufpos_cache[found];
+ bytmax = bytmin = buf->text->mule_bytind_cache[found];
+ size = 1;
+ }
+ }
+
+ /* It's conceivable that the caching above could lead to X being
+ the same as one of the range edges. */
+ if (x >= bytmax)
+ {
+ Bytind newmax;
+ Bytecount newsize;
+
+ forward_p = 1;
+ while (x > bytmax)
+ {
+ newmax = bytmax;
+
+ INC_BYTIND (buf, newmax);
+ newsize = newmax - bytmax;
+ if (newsize != size)
+ {
+ bufmin = bufmax;
+ bytmin = bytmax;
+ size = newsize;
+ }
+ bytmax = newmax;
+ bufmax++;
+ }
+ retval = bufmax;
+
+ /* #### Should go past the found location to reduce the number
+ of times that this function is called */
+ }
+ else /* x <= bytmin */
+ {
+ Bytind newmin;
+ Bytecount newsize;
+
+ forward_p = 0;
+ while (x < bytmin)
+ {
+ newmin = bytmin;
+
+ DEC_BYTIND (buf, newmin);
+ newsize = bytmin - newmin;
+ if (newsize != size)
+ {
+ bufmax = bufmin;
+ bytmax = bytmin;
+ size = newsize;
+ }
+ bytmin = newmin;
+ bufmin--;
+ }
+ retval = bufmin;
+
+ /* #### Should go past the found location to reduce the number
+ of times that this function is called
+ */
+ }
+
+ /* If size is three, than we have to max sure that the range we
+ discovered isn't too large, because we use a fixed-length
+ table to divide by 3. */
+
+ if (size == 3)
+ {
+ int gap = bytmax - bytmin;
+ buf->text->mule_three_p = 1;
+ buf->text->mule_shifter = 1;
+
+ if (gap > MAX_BYTIND_GAP_SIZE_3)
+ {
+ if (forward_p)
+ {
+ bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
+ bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
+ }
+ else
+ {
+ bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
+ bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
+ }
+ }
+ }
+ else
+ {
+ buf->text->mule_three_p = 0;
+ if (size == 4)
+ buf->text->mule_shifter = 2;
+ else
+ buf->text->mule_shifter = size - 1;
+ }
+
+ buf->text->mule_bufmin = bufmin;
+ buf->text->mule_bufmax = bufmax;
+ buf->text->mule_bytmin = bytmin;
+ buf->text->mule_bytmax = bytmax;
+
+ if (add_to_cache)
+ {
+ int replace_loc;
+
+ /* We throw away a "random" cached value and replace it with
+ the new value. It doesn't actually have to be very random
+ at all, just evenly distributed.
+
+ #### It would be better to use a least-recently-used algorithm
+ or something that tries to space things out, but I'm not sure
+ it's worth it to go to the trouble of maintaining that. */
+ not_very_random_number += 621;
+ replace_loc = not_very_random_number & 15;
+ buf->text->mule_bufpos_cache[replace_loc] = retval;
+ buf->text->mule_bytind_cache[replace_loc] = x;
+ }
+
+ return retval;
+}
+
+/* Text of length BYTELENGTH and CHARLENGTH (in different units)
+ was inserted at bufpos START. */
+
+static void
+buffer_mule_signal_inserted_region (struct buffer *buf, Bufpos start,
+ Bytecount bytelength,
+ Charcount charlength)
+{
+ int size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
+ int i;
+
+ /* Adjust the cache of known positions. */
+ for (i = 0; i < 16; i++)
+ {
+
+ if (buf->text->mule_bufpos_cache[i] > start)
+ {
+ buf->text->mule_bufpos_cache[i] += charlength;
+ buf->text->mule_bytind_cache[i] += bytelength;
+ }
+ }
+
+ if (start >= buf->text->mule_bufmax)
+ return;
+
+ /* The insertion is either before the known region, in which case
+ it shoves it forward; or within the known region, in which case
+ it shoves the end forward. (But it may make the known region
+ inconsistent, so we may have to shorten it.) */
+
+ if (start <= buf->text->mule_bufmin)
+ {
+ buf->text->mule_bufmin += charlength;
+ buf->text->mule_bufmax += charlength;
+ buf->text->mule_bytmin += bytelength;
+ buf->text->mule_bytmax += bytelength;
+ }
+ else
+ {
+ Bufpos end = start + charlength;
+ /* the insertion point divides the known region in two.
+ Keep the longer half, at least, and expand into the
+ inserted chunk as much as possible. */
+
+ if (start - buf->text->mule_bufmin > buf->text->mule_bufmax - start)
+ {
+ Bytind bytestart = (buf->text->mule_bytmin
+ + size * (start - buf->text->mule_bufmin));
+ Bytind bytenew;
+
+ while (start < end)
+ {
+ bytenew = bytestart;
+ INC_BYTIND (buf, bytenew);
+ if (bytenew - bytestart != size)
+ break;
+ start++;
+ bytestart = bytenew;
+ }
+ if (start != end)
+ {
+ buf->text->mule_bufmax = start;
+ buf->text->mule_bytmax = bytestart;
+ }
+ else
+ {
+ buf->text->mule_bufmax += charlength;
+ buf->text->mule_bytmax += bytelength;
+ }
+ }
+ else
+ {
+ Bytind byteend = (buf->text->mule_bytmin
+ + size * (start - buf->text->mule_bufmin)
+ + bytelength);
+ Bytind bytenew;
+
+ buf->text->mule_bufmax += charlength;
+ buf->text->mule_bytmax += bytelength;
+
+ while (end > start)
+ {
+ bytenew = byteend;
+ DEC_BYTIND (buf, bytenew);
+ if (byteend - bytenew != size)
+ break;
+ end--;
+ byteend = bytenew;
+ }
+ if (start != end)
+ {
+ buf->text->mule_bufmin = end;
+ buf->text->mule_bytmin = byteend;
+ }
+ }
+ }
+}
+
+/* Text from START to END (equivalent in Bytinds: from BI_START to
+ BI_END) was deleted. */
+
+static void
+buffer_mule_signal_deleted_region (struct buffer *buf, Bufpos start,
+ Bufpos end, Bytind bi_start,
+ Bytind bi_end)
+{
+ int i;
+
+ /* Adjust the cache of known positions. */
+ for (i = 0; i < 16; i++)
+ {
+ /* After the end; gets shoved backward */
+ if (buf->text->mule_bufpos_cache[i] > end)
+ {
+ buf->text->mule_bufpos_cache[i] -= end - start;
+ buf->text->mule_bytind_cache[i] -= bi_end - bi_start;
+ }
+ /* In the range; moves to start of range */
+ else if (buf->text->mule_bufpos_cache[i] > start)
+ {
+ buf->text->mule_bufpos_cache[i] = start;
+ buf->text->mule_bytind_cache[i] = bi_start;
+ }
+ }
+
+ /* We don't care about any text after the end of the known region. */
+
+ end = min (end, buf->text->mule_bufmax);
+ bi_end = min (bi_end, buf->text->mule_bytmax);
+ if (start >= end)
+ return;
+
+ /* The end of the known region offsets by the total amount of deletion,
+ since it's all before it. */
+
+ buf->text->mule_bufmax -= end - start;
+ buf->text->mule_bytmax -= bi_end - bi_start;
+
+ /* Now we don't care about any text after the start of the known region. */
+
+ end = min (end, buf->text->mule_bufmin);
+ bi_end = min (bi_end, buf->text->mule_bytmin);
+ if (start >= end)
+ return;
+
+ buf->text->mule_bufmin -= end - start;
+ buf->text->mule_bytmin -= bi_end - bi_start;
+}
+
+#endif /* MULE */
+
+#ifdef ERROR_CHECK_BUFPOS
+
+Bytind
+bufpos_to_bytind (struct buffer *buf, Bufpos x)
+{
+ Bytind retval = real_bufpos_to_bytind (buf, x);
+ ASSERT_VALID_BYTIND_UNSAFE (buf, retval);
+ return retval;
+}
+
+Bufpos
+bytind_to_bufpos (struct buffer *buf, Bytind x)
+{
+ ASSERT_VALID_BYTIND_UNSAFE (buf, x);
+ return real_bytind_to_bufpos (buf, x);
+}
+
+#endif /* ERROR_CHECK_BUFPOS */
+
+\f
+/************************************************************************/
+/* verifying buffer and string positions */
+/************************************************************************/
+
+/* Functions below are tagged with either _byte or _char indicating
+ whether they return byte or character positions. For a buffer,
+ a character position is a "Bufpos" and a byte position is a "Bytind".
+ For strings, these are sometimes typed using "Charcount" and
+ "Bytecount". */
+
+/* Flags for the functions below are:
+
+ GB_ALLOW_PAST_ACCESSIBLE
+
+ Allow positions to range over the entire buffer (BUF_BEG to BUF_Z),
+ rather than just the accessible portion (BUF_BEGV to BUF_ZV).
+ For strings, this flag has no effect.
+
+ GB_COERCE_RANGE
+
+ If the position is outside the allowable range, return the lower
+ or upper bound of the range, whichever is closer to the specified
+ position.
+
+ GB_NO_ERROR_IF_BAD
+
+ If the position is outside the allowable range, return -1.
+
+ GB_NEGATIVE_FROM_END
+
+ If a value is negative, treat it as an offset from the end.
+ Only applies to strings.
+
+ The following additional flags apply only to the functions
+ that return ranges:
+
+ GB_ALLOW_NIL
+
+ Either or both positions can be nil. If FROM is nil,
+ FROM_OUT will contain the lower bound of the allowed range.
+ If TO is nil, TO_OUT will contain the upper bound of the
+ allowed range.
+
+ GB_CHECK_ORDER
+
+ FROM must contain the lower bound and TO the upper bound
+ of the range. If the positions are reversed, an error is
+ signalled.
+
+ The following is a combination flag:
+
+ GB_HISTORICAL_STRING_BEHAVIOR
+
+ Equivalent to (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL).
+ */
+
+/* Return a buffer position stored in a Lisp_Object. Full
+ error-checking is done on the position. Flags can be specified to
+ control the behavior of out-of-range values. The default behavior
+ is to require that the position is within the accessible part of
+ the buffer (BEGV and ZV), and to signal an error if the position is
+ out of range.
+
+*/
+
+Bufpos
+get_buffer_pos_char (struct buffer *b, Lisp_Object pos, unsigned int flags)
+{
+ /* Does not GC */
+ Bufpos ind;
+ Bufpos min_allowed, max_allowed;
+
+ CHECK_INT_COERCE_MARKER (pos);
+ ind = XINT (pos);
+ min_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_BEG (b) : BUF_BEGV (b);
+ max_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_Z (b) : BUF_ZV (b);
+
+ if (ind < min_allowed || ind > max_allowed)
+ {
+ if (flags & GB_COERCE_RANGE)
+ ind = ind < min_allowed ? min_allowed : max_allowed;
+ else if (flags & GB_NO_ERROR_IF_BAD)
+ ind = -1;
+ else
+ {
+ Lisp_Object buffer;
+ XSETBUFFER (buffer, b);
+ args_out_of_range (buffer, pos);
+ }
+ }
+
+ return ind;
+}
+
+Bytind
+get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, unsigned int flags)
+{
+ Bufpos bpos = get_buffer_pos_char (b, pos, flags);
+ if (bpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
+ return -1;
+ return bufpos_to_bytind (b, bpos);
+}
+
+/* Return a pair of buffer positions representing a range of text,
+ taken from a pair of Lisp_Objects. Full error-checking is
+ done on the positions. Flags can be specified to control the
+ behavior of out-of-range values. The default behavior is to
+ allow the range bounds to be specified in either order
+ (however, FROM_OUT will always be the lower bound of the range
+ and TO_OUT the upper bound),to require that the positions
+ are within the accessible part of the buffer (BEGV and ZV),
+ and to signal an error if the positions are out of range.
+*/
+
+void
+get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to,
+ Bufpos *from_out, Bufpos *to_out, unsigned int flags)
+{
+ /* Does not GC */
+ Bufpos min_allowed, max_allowed;
+
+ min_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
+ BUF_BEG (b) : BUF_BEGV (b);
+ max_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
+ BUF_Z (b) : BUF_ZV (b);
+
+ if (NILP (from) && (flags & GB_ALLOW_NIL))
+ *from_out = min_allowed;
+ else
+ *from_out = get_buffer_pos_char (b, from, flags | GB_NO_ERROR_IF_BAD);
+
+ if (NILP (to) && (flags & GB_ALLOW_NIL))
+ *to_out = max_allowed;
+ else
+ *to_out = get_buffer_pos_char (b, to, flags | GB_NO_ERROR_IF_BAD);
+
+ if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
+ {
+ Lisp_Object buffer;
+ XSETBUFFER (buffer, b);
+ args_out_of_range_3 (buffer, from, to);
+ }
+
+ if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
+ {
+ if (flags & GB_CHECK_ORDER)
+ signal_simple_error_2 ("start greater than end", from, to);
+ else
+ {
+ Bufpos temp = *from_out;
+ *from_out = *to_out;
+ *to_out = temp;
+ }
+ }
+}
+
+void
+get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to,
+ Bytind *from_out, Bytind *to_out, unsigned int flags)
+{
+ Bufpos s, e;
+
+ get_buffer_range_char (b, from, to, &s, &e, flags);
+ if (s >= 0)
+ *from_out = bufpos_to_bytind (b, s);
+ else /* could happen with GB_NO_ERROR_IF_BAD */
+ *from_out = -1;
+ if (e >= 0)
+ *to_out = bufpos_to_bytind (b, e);
+ else
+ *to_out = -1;
+}
+
+static Charcount
+get_string_pos_char_1 (Lisp_Object string, Lisp_Object pos, unsigned int flags,
+ Charcount known_length)
+{
+ Charcount ccpos;
+ Charcount min_allowed = 0;
+ Charcount max_allowed = known_length;
+
+ /* Computation of KNOWN_LENGTH is potentially expensive so we pass
+ it in. */
+ CHECK_INT (pos);
+ ccpos = XINT (pos);
+ if (ccpos < 0 && flags & GB_NEGATIVE_FROM_END)
+ ccpos += max_allowed;
+
+ if (ccpos < min_allowed || ccpos > max_allowed)
+ {
+ if (flags & GB_COERCE_RANGE)
+ ccpos = ccpos < min_allowed ? min_allowed : max_allowed;
+ else if (flags & GB_NO_ERROR_IF_BAD)
+ ccpos = -1;
+ else
+ args_out_of_range (string, pos);
+ }
+
+ return ccpos;
+}
+
+Charcount
+get_string_pos_char (Lisp_Object string, Lisp_Object pos, unsigned int flags)
+{
+ return get_string_pos_char_1 (string, pos, flags,
+ XSTRING_CHAR_LENGTH (string));
+}
+
+Bytecount
+get_string_pos_byte (Lisp_Object string, Lisp_Object pos, unsigned int flags)
+{
+ Charcount ccpos = get_string_pos_char (string, pos, flags);
+ if (ccpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
+ return -1;
+ return charcount_to_bytecount (XSTRING_DATA (string), ccpos);
+}
+
+void
+get_string_range_char (Lisp_Object string, Lisp_Object from, Lisp_Object to,
+ Charcount *from_out, Charcount *to_out,
+ unsigned int flags)
+{
+ Charcount min_allowed = 0;
+ Charcount max_allowed = XSTRING_CHAR_LENGTH (string);
+
+ if (NILP (from) && (flags & GB_ALLOW_NIL))
+ *from_out = min_allowed;
+ else
+ *from_out = get_string_pos_char_1 (string, from,
+ flags | GB_NO_ERROR_IF_BAD,
+ max_allowed);
+
+ if (NILP (to) && (flags & GB_ALLOW_NIL))
+ *to_out = max_allowed;
+ else
+ *to_out = get_string_pos_char_1 (string, to,
+ flags | GB_NO_ERROR_IF_BAD,
+ max_allowed);
+
+ if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
+ args_out_of_range_3 (string, from, to);
+
+ if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
+ {
+ if (flags & GB_CHECK_ORDER)
+ signal_simple_error_2 ("start greater than end", from, to);
+ else
+ {
+ Bufpos temp = *from_out;
+ *from_out = *to_out;
+ *to_out = temp;
+ }
+ }
+}
+
+void
+get_string_range_byte (Lisp_Object string, Lisp_Object from, Lisp_Object to,
+ Bytecount *from_out, Bytecount *to_out,
+ unsigned int flags)
+{
+ Charcount s, e;
+
+ get_string_range_char (string, from, to, &s, &e, flags);
+ if (s >= 0)
+ *from_out = charcount_to_bytecount (XSTRING_DATA (string), s);
+ else /* could happen with GB_NO_ERROR_IF_BAD */
+ *from_out = -1;
+ if (e >= 0)
+ *to_out = charcount_to_bytecount (XSTRING_DATA (string), e);
+ else
+ *to_out = -1;
+
+}
+
+Bufpos
+get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos,
+ unsigned int flags)
+{
+ return STRINGP (object) ?
+ get_string_pos_char (object, pos, flags) :
+ get_buffer_pos_char (XBUFFER (object), pos, flags);
+}
+
+Bytind
+get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos,
+ unsigned int flags)
+{
+ return STRINGP (object) ?
+ get_string_pos_byte (object, pos, flags) :
+ get_buffer_pos_byte (XBUFFER (object), pos, flags);
+}
+
+void
+get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from,
+ Lisp_Object to, Bufpos *from_out,
+ Bufpos *to_out, unsigned int flags)
+{
+ if (STRINGP (object))
+ get_string_range_char (object, from, to, from_out, to_out, flags);
+ else
+ get_buffer_range_char (XBUFFER (object), from, to, from_out, to_out, flags);
+}
+
+void
+get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from,
+ Lisp_Object to, Bytind *from_out,
+ Bytind *to_out, unsigned int flags)
+{
+ if (STRINGP (object))
+ get_string_range_byte (object, from, to, from_out, to_out, flags);
+ else
+ get_buffer_range_byte (XBUFFER (object), from, to, from_out, to_out, flags);
+}
+
+Bufpos
+buffer_or_string_accessible_begin_char (Lisp_Object object)
+{
+ return STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object));
+}
+
+Bufpos
+buffer_or_string_accessible_end_char (Lisp_Object object)
+{
+ return STRINGP (object) ?
+ XSTRING_CHAR_LENGTH (object) : BUF_ZV (XBUFFER (object));
+}
+
+Bytind
+buffer_or_string_accessible_begin_byte (Lisp_Object object)
+{
+ return STRINGP (object) ? 0 : BI_BUF_BEGV (XBUFFER (object));
+}
+
+Bytind
+buffer_or_string_accessible_end_byte (Lisp_Object object)
+{
+ return STRINGP (object) ?
+ XSTRING_LENGTH (object) : BI_BUF_ZV (XBUFFER (object));
+}
+
+Bufpos
+buffer_or_string_absolute_begin_char (Lisp_Object object)
+{
+ return STRINGP (object) ? 0 : BUF_BEG (XBUFFER (object));
+}
+
+Bufpos
+buffer_or_string_absolute_end_char (Lisp_Object object)
+{
+ return STRINGP (object) ?
+ XSTRING_CHAR_LENGTH (object) : BUF_Z (XBUFFER (object));
+}
+
+Bytind
+buffer_or_string_absolute_begin_byte (Lisp_Object object)
+{
+ return STRINGP (object) ? 0 : BI_BUF_BEG (XBUFFER (object));
+}
+
+Bytind
+buffer_or_string_absolute_end_byte (Lisp_Object object)
+{
+ return STRINGP (object) ?
+ XSTRING_LENGTH (object) : BI_BUF_Z (XBUFFER (object));
+}
+
+\f
+/************************************************************************/
+/* point and marker adjustment */
+/************************************************************************/
+
+/* just_set_point() is the only place `PT' is an lvalue in all of emacs.
+ This function is called from set_buffer_point(), which is the function
+ that the SET_PT and BUF_SET_PT macros expand into, and from the
+ routines below that insert and delete text. (This is in cases where
+ the point marker logically doesn't move but PT (being a byte index)
+ needs to get adjusted.) */
+
+/* Set point to a specified value. This is used only when the value
+ of point changes due to an insert or delete; it does not represent
+ a conceptual change in point as a marker. In particular, point is
+ not crossing any interval boundaries, so there's no need to use the
+ usual SET_PT macro. In fact it would be incorrect to do so, because
+ either the old or the new value of point is out of synch with the
+ current set of intervals. */
+
+/* This gets called more than enough to make the function call
+ overhead a significant factor so we've turned it into a macro. */
+#define JUST_SET_POINT(buf, bufpos, ind) \
+do \
+{ \
+ buf->bufpt = (bufpos); \
+ buf->pt = (ind); \
+} while (0)
+
+/* Set a buffer's point. */
+
+void
+set_buffer_point (struct buffer *buf, Bufpos bufpos, Bytind bytpos)
+{
+ assert (bytpos >= BI_BUF_BEGV (buf) && bytpos <= BI_BUF_ZV (buf));
+ if (bytpos == BI_BUF_PT (buf))
+ return;
+ JUST_SET_POINT (buf, bufpos, bytpos);
+ MARK_POINT_CHANGED;
+ assert (MARKERP (buf->point_marker));
+ XMARKER (buf->point_marker)->memind =
+ bytind_to_memind (buf, bytpos);
+
+ /* FSF makes sure that PT is not being set within invisible text.
+ However, this is the wrong place for that check. The check
+ should happen only at the next redisplay. */
+
+ /* Some old coder said:
+
+ "If there were to be hooks which were run when point entered/left an
+ extent, this would be the place to put them.
+
+ However, it's probably the case that such hooks should be implemented
+ using a post-command-hook instead, to avoid running the hooks as a
+ result of intermediate motion inside of save-excursions, for example."
+
+ I definitely agree with this. PT gets moved all over the place
+ and it would be a Bad Thing for any hooks to get called, both for
+ the reason above and because many callers are not prepared for
+ a GC within this function. --ben
+ */
+}
+
+/* Do the correct marker-like adjustment on MPOS (see below). FROM, TO,
+ and AMOUNT are as in adjust_markers(). If MPOS doesn't need to be
+ adjusted, nothing will happen. */
+Memind
+do_marker_adjustment (Memind mpos, Memind from,
+ Memind to, Bytecount amount)
+{
+ if (amount > 0)
+ {
+ if (mpos > to && mpos < to + amount)
+ mpos = to + amount;
+ }
+ else
+ {
+ if (mpos > from + amount && mpos <= from)
+ mpos = from + amount;
+ }
+ if (mpos > from && mpos <= to)
+ mpos += amount;
+ return mpos;
+}
+
+/* Do the following:
+
+ (1) Add `amount' to the position of every marker in the current buffer
+ whose current position is between `from' (exclusive) and `to' (inclusive).
+
+ (2) Also, any markers past the outside of that interval, in the direction
+ of adjustment, are first moved back to the near end of the interval
+ and then adjusted by `amount'.
+
+ This function is called in two different cases: when a region of
+ characters adjacent to the gap is moved, causing the gap to shift
+ to the other side of the region (in this case, `from' and `to'
+ point to the old position of the region and there should be no
+ markers affected by (2) because they would be inside the gap),
+ or when a region of characters adjacent to the gap is wiped out,
+ causing the gap to increase to include the region (in this case,
+ `from' and `to' are the same, both pointing to the boundary
+ between the gap and the deleted region, and there are no markers
+ affected by (1)).
+
+ The reason for the use of exclusive and inclusive is that markers at
+ the gap always sit at the beginning, not at the end.
+*/
+
+static void
+adjust_markers (struct buffer *buf, Memind from, Memind to,
+ Bytecount amount)
+{
+ Lisp_Marker *m;
+
+ for (m = BUF_MARKERS (buf); m; m = marker_next (m))
+ m->memind = do_marker_adjustment (m->memind, from, to, amount);
+}
+
+/* Adjust markers whose insertion-type is t
+ for an insertion of AMOUNT characters at POS. */
+
+static void
+adjust_markers_for_insert (struct buffer *buf, Memind ind, Bytecount amount)
+{
+ Lisp_Marker *m;
+
+ for (m = BUF_MARKERS (buf); m; m = marker_next (m))
+ {
+ if (m->insertion_type && m->memind == ind)
+ m->memind += amount;
+ }
+}
+
+\f
+/************************************************************************/
+/* Routines for dealing with the gap */
+/************************************************************************/
+
+/* maximum amount of memory moved in a single chunk. Increasing this
+ value improves gap-motion efficiency but decreases QUIT responsiveness
+ time. Was 32000 but today's processors are faster and files are
+ bigger. --ben */
+#define GAP_MOVE_CHUNK 300000
+
+/* Move the gap to POS, which is less than the current GPT. */
+
+static void
+gap_left (struct buffer *buf, Bytind pos)
+{
+ Bufbyte *to, *from;
+ Bytecount i;
+ Bytind new_s1;
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ from = BUF_GPT_ADDR (buf);
+ to = from + BUF_GAP_SIZE (buf);
+ new_s1 = BI_BUF_GPT (buf);
+
+ /* Now copy the characters. To move the gap down,
+ copy characters up. */
+
+ while (1)
+ {
+ /* I gets number of characters left to copy. */
+ i = new_s1 - pos;
+ if (i == 0)
+ break;
+ /* If a quit is requested, stop copying now.
+ Change POS to be where we have actually moved the gap to. */
+ if (QUITP)
+ {
+ pos = new_s1;
+ break;
+ }
+ /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
+ if (i > GAP_MOVE_CHUNK)
+ i = GAP_MOVE_CHUNK;
+
+ if (i >= 128)
+ {
+ new_s1 -= i;
+ from -= i;
+ to -= i;
+ memmove (to, from, i);
+ }
+ else
+ {
+ new_s1 -= i;
+ while (--i >= 0)
+ *--to = *--from;
+ }
+ }
+
+ /* Adjust markers, and buffer data structure, to put the gap at POS.
+ POS is where the loop above stopped, which may be what was specified
+ or may be where a quit was detected. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_markers (mbuf, pos, BI_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
+ }
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_extents (make_buffer (mbuf), pos, BI_BUF_GPT (mbuf),
+ BUF_GAP_SIZE (mbuf));
+ }
+ SET_BI_BUF_GPT (buf, pos);
+ SET_GAP_SENTINEL (buf);
+#ifdef ERROR_CHECK_EXTENTS
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ sledgehammer_extent_check (make_buffer (mbuf));
+ }
+#endif
+ QUIT;
+}
+
+static void
+gap_right (struct buffer *buf, Bytind pos)
+{
+ Bufbyte *to, *from;
+ Bytecount i;
+ Bytind new_s1;
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ to = BUF_GPT_ADDR (buf);
+ from = to + BUF_GAP_SIZE (buf);
+ new_s1 = BI_BUF_GPT (buf);
+
+ /* Now copy the characters. To move the gap up,
+ copy characters down. */
+
+ while (1)
+ {
+ /* I gets number of characters left to copy. */
+ i = pos - new_s1;
+ if (i == 0)
+ break;
+ /* If a quit is requested, stop copying now.
+ Change POS to be where we have actually moved the gap to. */
+ if (QUITP)
+ {
+ pos = new_s1;
+ break;
+ }
+ /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
+ if (i > GAP_MOVE_CHUNK)
+ i = GAP_MOVE_CHUNK;
+
+ if (i >= 128)
+ {
+ new_s1 += i;
+ memmove (to, from, i);
+ from += i;
+ to += i;
+ }
+ else
+ {
+ new_s1 += i;
+ while (--i >= 0)
+ *to++ = *from++;
+ }
+ }
+
+ {
+ int gsize = BUF_GAP_SIZE (buf);
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_markers (mbuf, BI_BUF_GPT (mbuf) + gsize, pos + gsize, - gsize);
+ }
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_extents (make_buffer (mbuf), BI_BUF_GPT (mbuf) + gsize,
+ pos + gsize, - gsize);
+ }
+ SET_BI_BUF_GPT (buf, pos);
+ SET_GAP_SENTINEL (buf);
+#ifdef ERROR_CHECK_EXTENTS
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ sledgehammer_extent_check (make_buffer (mbuf));
+ }
+#endif
+ }
+ if (pos == BI_BUF_Z (buf))
+ {
+ /* merge gap with end gap */
+
+ SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + BUF_END_GAP_SIZE (buf));
+ SET_BUF_END_GAP_SIZE (buf, 0);
+ SET_END_SENTINEL (buf);
+ }
+
+ QUIT;
+}
+
+/* Move gap to position `pos'.
+ Note that this can quit! */
+
+static void
+move_gap (struct buffer *buf, Bytind pos)
+{
+ if (! BUF_BEG_ADDR (buf))
+ ABORT ();
+ if (pos < BI_BUF_GPT (buf))
+ gap_left (buf, pos);
+ else if (pos > BI_BUF_GPT (buf))
+ gap_right (buf, pos);
+}
+
+/* Merge the end gap into the gap */
+
+static void
+merge_gap_with_end_gap (struct buffer *buf)
+{
+ Lisp_Object tem;
+ Bytind real_gap_loc;
+ Bytecount old_gap_size;
+ Bytecount increment;
+
+ increment = BUF_END_GAP_SIZE (buf);
+ SET_BUF_END_GAP_SIZE (buf, 0);
+
+ if (increment > 0)
+ {
+ /* Prevent quitting in move_gap. */
+ tem = Vinhibit_quit;
+ Vinhibit_quit = Qt;
+
+ real_gap_loc = BI_BUF_GPT (buf);
+ old_gap_size = BUF_GAP_SIZE (buf);
+
+ /* Pretend the end gap is the gap */
+ SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
+ SET_BUF_GAP_SIZE (buf, increment);
+
+ /* Move the new gap down to be consecutive with the end of the old one.
+ This adjusts the markers properly too. */
+ gap_left (buf, real_gap_loc + old_gap_size);
+
+ /* Now combine the two into one large gap. */
+ SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
+ SET_BI_BUF_GPT (buf, real_gap_loc);
+ SET_GAP_SENTINEL (buf);
+
+ /* We changed the total size of the buffer (including gap),
+ so we need to fix up the end sentinel. */
+ SET_END_SENTINEL (buf);
+
+ Vinhibit_quit = tem;
+ }
+}
+
+/* Make the gap INCREMENT bytes longer. */
+
+static void
+make_gap (struct buffer *buf, Bytecount increment)
+{
+ Bufbyte *result;
+ Lisp_Object tem;
+ Bytind real_gap_loc;
+ Bytecount old_gap_size;
+
+ /* If we have to get more space, get enough to last a while. We use
+ a geometric progression that saves on realloc space. */
+ increment += 2000 + ((BI_BUF_Z (buf) - BI_BUF_BEG (buf)) / 8);
+
+ if (increment > BUF_END_GAP_SIZE (buf))
+ {
+ /* Don't allow a buffer size that won't fit in an int
+ even if it will fit in a Lisp integer.
+ That won't work because so many places use `int'. */
+
+ if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment
+ > EMACS_INT_MAX)
+ error ("Maximum buffer size exceeded");
+
+ result = BUFFER_REALLOC (buf->text->beg,
+ BI_BUF_Z (buf) - BI_BUF_BEG (buf) +
+ BUF_GAP_SIZE (buf) + increment +
+ BUF_END_SENTINEL_SIZE);
+ if (result == 0)
+ memory_full ();
+
+ SET_BUF_BEG_ADDR (buf, result);
+ }
+ else
+ increment = BUF_END_GAP_SIZE (buf);
+
+ /* Prevent quitting in move_gap. */
+ tem = Vinhibit_quit;
+ Vinhibit_quit = Qt;
+
+ real_gap_loc = BI_BUF_GPT (buf);
+ old_gap_size = BUF_GAP_SIZE (buf);
+
+ /* Call the newly allocated space a gap at the end of the whole space. */
+ SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
+ SET_BUF_GAP_SIZE (buf, increment);
+
+ SET_BUF_END_GAP_SIZE (buf, 0);
+
+ /* Move the new gap down to be consecutive with the end of the old one.
+ This adjusts the markers properly too. */
+ gap_left (buf, real_gap_loc + old_gap_size);
+
+ /* Now combine the two into one large gap. */
+ SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
+ SET_BI_BUF_GPT (buf, real_gap_loc);
+ SET_GAP_SENTINEL (buf);
+
+ /* We changed the total size of the buffer (including gap),
+ so we need to fix up the end sentinel. */
+ SET_END_SENTINEL (buf);
+
+ Vinhibit_quit = tem;
+}
+
+\f
+/************************************************************************/
+/* Before/after-change processing */
+/************************************************************************/
+
+/* Those magic changes ... */
+
+static void
+buffer_signal_changed_region (struct buffer *buf, Bufpos start,
+ Bufpos end)
+{
+ /* The changed region is recorded as the number of unchanged
+ characters from the beginning and from the end of the
+ buffer. This obviates much of the need of shifting the
+ region around to compensate for insertions and deletions.
+ */
+ if (buf->changes->begin_unchanged < 0 ||
+ buf->changes->begin_unchanged > start - BUF_BEG (buf))
+ buf->changes->begin_unchanged = start - BUF_BEG (buf);
+ if (buf->changes->end_unchanged < 0 ||
+ buf->changes->end_unchanged > BUF_Z (buf) - end)
+ buf->changes->end_unchanged = BUF_Z (buf) - end;
+}
+
+void
+buffer_extent_signal_changed_region (struct buffer *buf, Bufpos start,
+ Bufpos end)
+{
+ if (buf->changes->begin_extent_unchanged < 0 ||
+ buf->changes->begin_extent_unchanged > start - BUF_BEG (buf))
+ buf->changes->begin_extent_unchanged = start - BUF_BEG (buf);
+ if (buf->changes->end_extent_unchanged < 0 ||
+ buf->changes->end_extent_unchanged > BUF_Z (buf) - end)
+ buf->changes->end_extent_unchanged = BUF_Z (buf) - end;
+}
+
+void
+buffer_reset_changes (struct buffer *buf)
+{
+ buf->changes->begin_unchanged = -1;
+ buf->changes->end_unchanged = -1;
+ buf->changes->begin_extent_unchanged = -1;
+ buf->changes->end_extent_unchanged = -1;
+ buf->changes->newline_was_deleted = 0;
+}
+
+static void
+signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
+ Bufpos new_end);
+
+
+/* Call the after-change-functions according to the changes made so far
+ and treat all further changes as single until the outermost
+ multiple change exits. This is called when the outermost multiple
+ change exits and when someone is trying to make a change that violates
+ the constraints specified in begin_multiple_change(), typically
+ when nested multiple-change sessions occur. (There are smarter ways of
+ dealing with nested multiple changes, but these rarely occur so there's
+ probably no point in it.) */
+
+/* #### This needs to keep track of what actually changed and only
+ call the after-change functions on that region. */
+
+static void
+cancel_multiple_change (struct buffer *buf)
+{
+ /* This function can GC */
+ /* Call the after-change-functions except when they've already been
+ called or when there were no changes made to the buffer at all. */
+ if (buf->text->changes->mc_begin != 0 &&
+ buf->text->changes->mc_begin_signaled)
+ {
+ Bufpos real_mc_begin = buf->text->changes->mc_begin;
+ buf->text->changes->mc_begin = 0;
+
+ signal_after_change (buf, real_mc_begin, buf->text->changes->mc_orig_end,
+ buf->text->changes->mc_new_end);
+ }
+ else
+ {
+ buf->text->changes->mc_begin = 0;
+ }
+}
+
+/* this is an unwind_protect, to ensure that the after-change-functions
+ get called even in a non-local exit. */
+
+static Lisp_Object
+multiple_change_finish_up (Lisp_Object buffer)
+{
+ struct buffer *buf = XBUFFER (buffer);
+
+ /* #### I don't know whether or not it should even be possible to
+ get here with a dead buffer (though given how it is called I can
+ see how it might be). In any case, there isn't time before 19.14
+ to find out. */
+ if (!BUFFER_LIVE_P (buf))
+ return Qnil;
+
+ /* This function can GC */
+ buf->text->changes->in_multiple_change = 0; /* do this first so that
+ errors in the after-change
+ functions don't mess things
+ up. */
+ cancel_multiple_change (buf);
+ return Qnil;
+}
+
+/* Call this function when you're about to make a number of buffer changes
+ that should be considered a single change. (e.g. `replace-match' calls
+ this.) You need to specify the START and END of the region that is
+ going to be changed so that the before-change-functions are called
+ with the correct arguments. The after-change region is calculated
+ automatically, however, and if changes somehow or other happen outside
+ of the specified region, that will also be handled correctly.
+
+ begin_multiple_change() returns a number (actually a specpdl depth)
+ that you must pass to end_multiple_change() when you are done.
+
+ FSF Emacs 20 implements a similar feature, accessible from Lisp
+ through a `combine-after-change-calls' special form, which is
+ essentially equivalent to this function. We should consider
+ whether we want to introduce a similar Lisp form. */
+
+int
+begin_multiple_change (struct buffer *buf, Bufpos start, Bufpos end)
+{
+ /* This function can GC */
+ int count = -1;
+ if (buf->text->changes->in_multiple_change)
+ {
+ if (buf->text->changes->mc_begin != 0 &&
+ (start < buf->text->changes->mc_begin ||
+ end > buf->text->changes->mc_new_end))
+ cancel_multiple_change (buf);
+ }
+ else
+ {
+ Lisp_Object buffer;
+
+ buf->text->changes->mc_begin = start;
+ buf->text->changes->mc_orig_end = buf->text->changes->mc_new_end = end;
+ buf->text->changes->mc_begin_signaled = 0;
+ count = specpdl_depth ();
+ XSETBUFFER (buffer, buf);
+ record_unwind_protect (multiple_change_finish_up, buffer);
+ }
+ buf->text->changes->in_multiple_change++;
+ /* We don't call before-change-functions until signal_before_change()
+ is called, in case there is a read-only or other error. */
+ return count;
+}
+
+void
+end_multiple_change (struct buffer *buf, int count)
+{
+ assert (buf->text->changes->in_multiple_change > 0);
+ buf->text->changes->in_multiple_change--;
+ if (!buf->text->changes->in_multiple_change)
+ unbind_to (count, Qnil);
+}
+
+static int inside_change_hook;
+
+static Lisp_Object
+change_function_restore (Lisp_Object buffer)
+{
+ /* We should first reset the variable and then change the buffer,
+ because Fset_buffer() can throw. */
+ inside_change_hook = 0;
+ if (XBUFFER (buffer) != current_buffer)
+ Fset_buffer (buffer);
+ return Qnil;
+}
+
+static int in_first_change;
+
+static Lisp_Object
+first_change_hook_restore (Lisp_Object buffer)
+{
+ in_first_change = 0;
+ Fset_buffer (buffer);
+ return Qnil;
+}
+
+/* Signal an initial modification to the buffer. */
+
+static void
+signal_first_change (struct buffer *buf)
+{
+ /* This function can GC */
+ Lisp_Object buffer;
+ XSETBUFFER (buffer, current_buffer);
+
+ if (!in_first_change)
+ {
+ if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
+ {
+ int speccount = specpdl_depth ();
+ record_unwind_protect (first_change_hook_restore, buffer);
+ set_buffer_internal (buf);
+ in_first_change = 1;
+ run_hook (Qfirst_change_hook);
+ unbind_to (speccount, Qnil);
+ }
+ }
+}
+
+/* Signal a change to the buffer immediately before it happens.
+ START and END are the bounds of the text to be changed. */
+
+static void
+signal_before_change (struct buffer *buf, Bufpos start, Bufpos end)
+{
+ /* This function can GC */
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ if (!inside_change_hook)
+ {
+ Lisp_Object buffer;
+ int speccount;
+
+ /* Are we in a multiple-change session? */
+ if (buf->text->changes->in_multiple_change &&
+ buf->text->changes->mc_begin != 0)
+ {
+ /* If we're violating the constraints of the session,
+ call the after-change-functions as necessary for the
+ changes already made and treat further changes as
+ single. */
+ if (start < buf->text->changes->mc_begin ||
+ end > buf->text->changes->mc_new_end)
+ cancel_multiple_change (buf);
+ /* Do nothing if this is not the first change in the session. */
+ else if (buf->text->changes->mc_begin_signaled)
+ return;
+ else
+ {
+ /* First time through; call the before-change-functions
+ specifying the entire region to be changed. (Note that
+ we didn't call before-change-functions in
+ begin_multiple_change() because the buffer might be
+ read-only, etc.) */
+ start = buf->text->changes->mc_begin;
+ end = buf->text->changes->mc_new_end;
+ }
+ }
+
+ /* If buffer is unmodified, run a special hook for that case. */
+ if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
+ {
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ signal_first_change (mbuf);
+ }
+ }
+
+ /* Now in any case run the before-change-functions if any. */
+ speccount = specpdl_depth ();
+ record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ inside_change_hook = 1;
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ XSETBUFFER (buffer, mbuf);
+ if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
+ /* Obsolete, for compatibility */
+ || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
+ {
+ set_buffer_internal (buf);
+ va_run_hook_with_args (Qbefore_change_functions, 2,
+ make_int (start), make_int (end));
+ /* Obsolete, for compatibility */
+ va_run_hook_with_args (Qbefore_change_function, 2,
+ make_int (start), make_int (end));
+ }
+ }
+
+ /* Make sure endpoints remain valid. before-change-functions
+ might have modified the buffer. */
+ if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
+ if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
+ if (end < BUF_BEGV (buf)) end = BUF_BEGV (buf);
+ if (end > BUF_ZV (buf)) end = BUF_ZV (buf);
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ XSETBUFFER (buffer, mbuf);
+ report_extent_modification (buffer, start, end, 0);
+ }
+ unbind_to (speccount, Qnil);
+
+ /* Only now do we indicate that the before-change-functions have
+ been called, in case some function throws out. */
+ buf->text->changes->mc_begin_signaled = 1;
+ }
+}
+
+/* Signal a change immediately after it happens.
+ START is the bufpos of the start of the changed text.
+ ORIG_END is the bufpos of the end of the before-changed text.
+ NEW_END is the bufpos of the end of the after-changed text.
+ */
+
+static void
+signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
+ Bufpos new_end)
+{
+ /* This function can GC */
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* always do this. */
+ buffer_signal_changed_region (mbuf, start, new_end);
+ }
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* #### This seems inefficient. Wouldn't it be better to just
+ keep one cache per base buffer? */
+ font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
+ }
+
+ if (!inside_change_hook)
+ {
+ Lisp_Object buffer;
+ int speccount;
+
+ if (buf->text->changes->in_multiple_change &&
+ buf->text->changes->mc_begin != 0)
+ {
+ assert (start >= buf->text->changes->mc_begin &&
+ start <= buf->text->changes->mc_new_end);
+ assert (orig_end >= buf->text->changes->mc_begin &&
+ orig_end <= buf->text->changes->mc_new_end);
+ buf->text->changes->mc_new_end += new_end - orig_end;
+ return; /* after-change-functions signalled when all changes done */
+ }
+
+ speccount = specpdl_depth ();
+ record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ inside_change_hook = 1;
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ XSETBUFFER (buffer, mbuf);
+
+ if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
+ /* Obsolete, for compatibility */
+ || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
+ {
+ set_buffer_internal (buf);
+ /* The actual after-change functions take slightly
+ different arguments than what we were passed. */
+ va_run_hook_with_args (Qafter_change_functions, 3,
+ make_int (start), make_int (new_end),
+ make_int (orig_end - start));
+ /* Obsolete, for compatibility */
+ va_run_hook_with_args (Qafter_change_function, 3,
+ make_int (start), make_int (new_end),
+ make_int (orig_end - start));
+ }
+ }
+
+ /* Make sure endpoints remain valid. after-change-functions
+ might have modified the buffer. */
+ if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
+ if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
+ if (new_end < BUF_BEGV (buf)) new_end = BUF_BEGV (buf);
+ if (new_end > BUF_ZV (buf)) new_end = BUF_ZV (buf);
+ if (orig_end < BUF_BEGV (buf)) orig_end = BUF_BEGV (buf);
+ if (orig_end > BUF_ZV (buf)) orig_end = BUF_ZV (buf);
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ XSETBUFFER (buffer, mbuf);
+ report_extent_modification (buffer, start, new_end, 1);
+ }
+ unbind_to (speccount, Qnil); /* sets inside_change_hook back to 0 */
+ }
+}
+
+/* Call this if you're about to change the region of BUFFER from START
+ to END. This checks the read-only properties of the region, calls
+ the necessary modification hooks, and warns the next redisplay that
+ it should pay attention to that area. */
+
+static void
+prepare_to_modify_buffer (struct buffer *buf, Bufpos start, Bufpos end,
+ int lockit)
+{
+ /* This function can GC */
+ /* dmoore - This function can also kill the buffer buf, the current
+ buffer, and do anything it pleases. So if you call it, be
+ careful. */
+ struct buffer *mbuf;
+ Lisp_Object buffer, bufcons;
+ struct gcpro gcpro1;
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ barf_if_buffer_read_only (mbuf, start, end);
+ }
+
+ /* if this is the first modification, see about locking the buffer's
+ file */
+ XSETBUFFER (buffer, buf);
+ GCPRO1 (buffer);
+ if (!NILP (buf->filename) && lockit &&
+ BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
+ {
+ /* At least warn if this file has changed on disk since it was visited.*/
+ if (NILP (Fverify_visited_file_modtime (buffer))
+ && !NILP (Ffile_exists_p (buf->filename)))
+ call1_in_buffer (buf, intern ("ask-user-about-supersession-threat"),
+ buf->filename);
+#ifdef CLASH_DETECTION
+ if (!NILP (buf->file_truename))
+ /* Make binding buffer-file-name to nil effective. */
+ lock_file (buf->file_truename);
+#endif /* not CLASH_DETECTION */
+ }
+ UNGCPRO;
+
+ /* #### dmoore - is this reasonable in case of buf being killed above? */
+ if (!BUFFER_LIVE_P (buf))
+ return;
+
+ signal_before_change (buf, start, end);
+
+#ifdef REGION_CACHE_NEEDS_WORK
+ if (buf->newline_cache)
+ invalidate_region_cache (buf,
+ buf->newline_cache,
+ start - BUF_BEG (buf), BUF_Z (buf) - end);
+ if (buf->width_run_cache)
+ invalidate_region_cache (buf,
+ buf->width_run_cache,
+ start - BUF_BEG (buf), BUF_Z (buf) - end);
+#endif
+
+#if 0 /* FSFmacs */
+ Vdeactivate_mark = Qt;
+#endif
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ mbuf->point_before_scroll = Qnil;
+ }
+}
+
+\f
+/************************************************************************/
+/* Insertion of strings */
+/************************************************************************/
+
+void
+fixup_internal_substring (const Bufbyte *nonreloc, Lisp_Object reloc,
+ Bytecount offset, Bytecount *len)
+{
+ assert ((nonreloc && NILP (reloc)) || (!nonreloc && STRINGP (reloc)));
+
+ if (*len < 0)
+ {
+ if (nonreloc)
+ *len = strlen ((const char *) nonreloc) - offset;
+ else
+ *len = XSTRING_LENGTH (reloc) - offset;
+ }
+#ifdef ERROR_CHECK_BUFPOS
+ assert (*len >= 0);
+ if (STRINGP (reloc))
+ {
+ assert (offset >= 0 && offset <= XSTRING_LENGTH (reloc));
+ assert (offset + *len <= XSTRING_LENGTH (reloc));
+ }
+#endif
+}
+
+/* Insert a string into BUF at Bufpos POS. The string data comes
+ from one of two sources: constant, non-relocatable data (specified
+ in NONRELOC), or a Lisp string object (specified in RELOC), which
+ is relocatable and may have extent data that needs to be copied
+ into the buffer. OFFSET and LENGTH specify the substring of the
+ data that is actually to be inserted. As a special case, if POS
+ is -1, insert the string at point and move point to the end of the
+ string.
+
+ Normally, markers at the insertion point end up before the
+ inserted string. If INSDEL_BEFORE_MARKERS is set in flags, however,
+ they end up after the string.
+
+ INSDEL_NO_LOCKING is kludgy and is used when insert-file-contents is
+ visiting a new file; it inhibits the locking checks normally done
+ before modifying a buffer. Similar checks were already done
+ in the higher-level Lisp functions calling insert-file-contents. */
+
+Charcount
+buffer_insert_string_1 (struct buffer *buf, Bufpos pos,
+ const Bufbyte *nonreloc, Lisp_Object reloc,
+ Bytecount offset, Bytecount length,
+ int flags)
+{
+ /* This function can GC */
+ struct gcpro gcpro1;
+ Bytind ind;
+ Charcount cclen;
+ int move_point = 0;
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ /* Defensive steps just in case a buffer gets deleted and a calling
+ function doesn't notice it. */
+ if (!BUFFER_LIVE_P (buf))
+ return 0;
+
+ fixup_internal_substring (nonreloc, reloc, offset, &length);
+
+ if (pos == -1)
+ {
+ pos = BUF_PT (buf);
+ move_point = 1;
+ }
+
+#ifdef I18N3
+ /* #### See the comment in print_internal(). If this buffer is marked
+ as translatable, then Fgettext() should be called on obj if it
+ is a string. */
+#endif
+
+ /* Make sure that point-max won't exceed the size of an emacs int. */
+ if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
+ error ("Maximum buffer size exceeded");
+
+ /* theoretically not necessary -- caller should GCPRO.
+ #### buffer_insert_from_buffer_1() doesn't! */
+ GCPRO1 (reloc);
+
+ prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
+
+ /* Defensive steps in case the before-change-functions fuck around */
+ if (!BUFFER_LIVE_P (buf))
+ {
+ UNGCPRO;
+ /* Bad bad pre-change function. */
+ return 0;
+ }
+
+ /* Make args be valid again. prepare_to_modify_buffer() might have
+ modified the buffer. */
+ if (pos < BUF_BEGV (buf))
+ pos = BUF_BEGV (buf);
+ if (pos > BUF_ZV (buf))
+ pos = BUF_ZV (buf);
+
+ /* string may have been relocated up to this point */
+ if (STRINGP (reloc))
+ nonreloc = XSTRING_DATA (reloc);
+
+ ind = bufpos_to_bytind (buf, pos);
+ cclen = bytecount_to_charcount (nonreloc + offset, length);
+
+ if (ind != BI_BUF_GPT (buf))
+ /* #### if debug-on-quit is invoked and the user changes the
+ buffer, bad things can happen. This is a rampant problem
+ in Emacs. */
+ move_gap (buf, ind); /* may QUIT */
+ if (! GAP_CAN_HOLD_SIZE_P (buf, length))
+ {
+ if (BUF_END_GAP_SIZE (buf) >= length)
+ merge_gap_with_end_gap (buf);
+ else
+ make_gap (buf, length - BUF_GAP_SIZE (buf));
+ }
+
+ insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ record_insert (mbuf, pos, cclen);
+ }
+
+ BUF_MODIFF (buf)++;
+ MARK_BUFFERS_CHANGED;
+
+ /* string may have been relocated up to this point */
+ if (STRINGP (reloc))
+ nonreloc = XSTRING_DATA (reloc);
+
+ memcpy (BUF_GPT_ADDR (buf), nonreloc + offset, length);
+
+ SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length);
+ SET_BI_BUF_GPT (buf, BI_BUF_GPT (buf) + length);
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen, BI_BUF_ZV (mbuf) + length);
+ }
+ SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BI_BUF_Z (buf) + length);
+ SET_GAP_SENTINEL (buf);
+
+#ifdef MULE
+ buffer_mule_signal_inserted_region (buf, pos, length, cclen);
+#endif
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ process_extents_for_insertion (make_buffer (mbuf), ind, length);
+ }
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* We know the gap is at IND so the cast is OK. */
+ adjust_markers_for_insert (mbuf, (Memind) ind, length);
+ }
+
+ /* Point logically doesn't move, but may need to be adjusted because
+ it's a byte index. point-marker doesn't change because it's a
+ memory index. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ if (BI_BUF_PT (mbuf) > ind)
+ JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
+ BI_BUF_PT (mbuf) + length);
+ }
+
+ /* Well, point might move. */
+ if (move_point)
+ BI_BUF_SET_PT (buf, ind + length);
+
+ if (STRINGP (reloc))
+ {
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ splice_in_string_extents (reloc, mbuf, ind, length, offset);
+ }
+ }
+
+ if (flags & INSDEL_BEFORE_MARKERS)
+ {
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* ind - 1 is correct because the FROM argument is exclusive.
+ I formerly used DEC_BYTIND() but that caused problems at the
+ beginning of the buffer. */
+ adjust_markers (mbuf, ind - 1, ind, length);
+ }
+ }
+
+ signal_after_change (buf, pos, pos, pos + cclen);
+
+ UNGCPRO;
+
+ return cclen;
+}
+
+
+/* The following functions are interfaces onto the above function,
+ for inserting particular sorts of data. In all the functions,
+ BUF and POS specify the buffer and location where the insertion is
+ to take place. (If POS is -1, text is inserted at point and point
+ moves forward past the text.) FLAGS is as above. */
+
+Charcount
+buffer_insert_raw_string_1 (struct buffer *buf, Bufpos pos,
+ const Bufbyte *nonreloc, Bytecount length,
+ int flags)
+{
+ /* This function can GC */
+ return buffer_insert_string_1 (buf, pos, nonreloc, Qnil, 0, length,
+ flags);
+}
+
+Charcount
+buffer_insert_lisp_string_1 (struct buffer *buf, Bufpos pos, Lisp_Object str,
+ int flags)
+{
+ /* This function can GC */
+#ifdef ERROR_CHECK_TYPECHECK
+ assert (STRINGP (str));
+#endif
+ return buffer_insert_string_1 (buf, pos, 0, str, 0,
+ XSTRING_LENGTH (str),
+ flags);
+}
+
+/* Insert the null-terminated string S (in external format). */
+
+Charcount
+buffer_insert_c_string_1 (struct buffer *buf, Bufpos pos, const char *s,
+ int flags)
+{
+ /* This function can GC */
+ const char *translated = GETTEXT (s);
+ return buffer_insert_string_1 (buf, pos, (const Bufbyte *) translated, Qnil,
+ 0, strlen (translated), flags);
+}
+
+Charcount
+buffer_insert_emacs_char_1 (struct buffer *buf, Bufpos pos, Emchar ch,
+ int flags)
+{
+ /* This function can GC */
+ Bufbyte str[MAX_EMCHAR_LEN];
+ Bytecount len = set_charptr_emchar (str, ch);
+ return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
+}
+
+Charcount
+buffer_insert_c_char_1 (struct buffer *buf, Bufpos pos, char c,
+ int flags)
+{
+ /* This function can GC */
+ return buffer_insert_emacs_char_1 (buf, pos, (Emchar) (unsigned char) c,
+ flags);
+}
+
+Charcount
+buffer_insert_from_buffer_1 (struct buffer *buf, Bufpos pos,
+ struct buffer *buf2, Bufpos pos2,
+ Charcount length, int flags)
+{
+ /* This function can GC */
+ Lisp_Object str = make_string_from_buffer (buf2, pos2, length);
+ return buffer_insert_string_1 (buf, pos, 0, str, 0,
+ XSTRING_LENGTH (str), flags);
+}
+
+\f
+/************************************************************************/
+/* Deletion of ranges */
+/************************************************************************/
+
+/* Delete characters in buffer from FROM up to (but not including) TO. */
+
+void
+buffer_delete_range (struct buffer *buf, Bufpos from, Bufpos to, int flags)
+{
+ /* This function can GC */
+ Charcount numdel;
+ Bytind bi_from, bi_to;
+ Bytecount bc_numdel;
+ EMACS_INT shortage;
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ /* Defensive steps just in case a buffer gets deleted and a calling
+ function doesn't notice it. */
+ if (!BUFFER_LIVE_P (buf))
+ return;
+
+ /* Make args be valid */
+ if (from < BUF_BEGV (buf))
+ from = BUF_BEGV (buf);
+ if (to > BUF_ZV (buf))
+ to = BUF_ZV (buf);
+ if ((numdel = to - from) <= 0)
+ return;
+
+ prepare_to_modify_buffer (buf, from, to, !(flags & INSDEL_NO_LOCKING));
+
+ /* Defensive steps in case the before-change-functions fuck around */
+ if (!BUFFER_LIVE_P (buf))
+ /* Bad bad pre-change function. */
+ return;
+
+ /* Make args be valid again. prepare_to_modify_buffer() might have
+ modified the buffer. */
+ if (from < BUF_BEGV (buf))
+ from = BUF_BEGV (buf);
+ if (to > BUF_ZV (buf))
+ to = BUF_ZV (buf);
+ if ((numdel = to - from) <= 0)
+ return;
+
+ /* Redisplay needs to know if a newline was in the deleted region.
+ If we've already marked the changed region as having a deleted
+ newline there is no use in performing the check. */
+ if (!buf->changes->newline_was_deleted)
+ {
+ scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
+ if (!shortage)
+ {
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ mbuf->changes->newline_was_deleted = 1;
+ }
+ }
+ }
+
+ bi_from = bufpos_to_bytind (buf, from);
+ bi_to = bufpos_to_bytind (buf, to);
+ bc_numdel = bi_to - bi_from;
+
+ delete_invalidate_line_number_cache (buf, from, to);
+
+ if (to == BUF_Z (buf) &&
+ bi_from > BI_BUF_GPT (buf))
+ {
+ /* avoid moving the gap just to delete from the bottom. */
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ record_delete (mbuf, from, numdel);
+ }
+ BUF_MODIFF (buf)++;
+ MARK_BUFFERS_CHANGED;
+
+ /* #### Point used to be modified here, but this causes problems
+ with MULE, as point is used to calculate bytinds, and if the
+ offset in bc_numdel causes point to move to a non first-byte
+ location, causing some other function to throw an assertion
+ in ASSERT_VALID_BYTIND. I've moved the code to right after
+ the other movements and adjustments, but before the gap is
+ moved. -- jh 970813 */
+
+ /* Detach any extents that are completely within the range [FROM, TO],
+ if the extents are detachable.
+
+ This must come AFTER record_delete(), so that the appropriate
+ extents will be present to be recorded, and BEFORE the gap
+ size is increased, as otherwise we will be confused about
+ where the extents end. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
+ }
+
+ /* Relocate all markers pointing into the new, larger gap to
+ point at the end of the text before the gap. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_markers (mbuf,
+ (bi_to + BUF_GAP_SIZE (mbuf)),
+ (bi_to + BUF_GAP_SIZE (mbuf)),
+ (- bc_numdel));
+ }
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* Relocate any extent endpoints just like markers. */
+ adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
+ BUF_GAP_SIZE (mbuf), bc_numdel, 0);
+ }
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* Relocate point as if it were a marker. */
+ if (bi_from < BI_BUF_PT (mbuf))
+ {
+ if (BI_BUF_PT (mbuf) < bi_to)
+ JUST_SET_POINT (mbuf, from, bi_from);
+ else
+ JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+ BI_BUF_PT (mbuf) - bc_numdel);
+ }
+ }
+
+ SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + bc_numdel);
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+ BI_BUF_ZV (mbuf) - bc_numdel);
+ }
+ SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
+ SET_GAP_SENTINEL (buf);
+ }
+ else
+ {
+ /* Make sure the gap is somewhere in or next to what we are deleting. */
+ if (bi_to < BI_BUF_GPT (buf))
+ gap_left (buf, bi_to);
+ if (bi_from > BI_BUF_GPT (buf))
+ gap_right (buf, bi_from);
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ record_delete (mbuf, from, numdel);
+ }
+ BUF_MODIFF (buf)++;
+ MARK_BUFFERS_CHANGED;
+
+ /* #### Point used to be modified here, but this causes problems
+ with MULE, as point is used to calculate bytinds, and if the
+ offset in bc_numdel causes point to move to a non first-byte
+ location, causing some other function to throw an assertion
+ in ASSERT_VALID_BYTIND. I've moved the code to right after
+ the other movements and adjustments, but before the gap is
+ moved. -- jh 970813 */
+
+ /* Detach any extents that are completely within the range [FROM, TO],
+ if the extents are detachable.
+
+ This must come AFTER record_delete(), so that the appropriate extents
+ will be present to be recorded, and BEFORE the gap size is increased,
+ as otherwise we will be confused about where the extents end. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
+ }
+
+ /* Relocate all markers pointing into the new, larger gap to
+ point at the end of the text before the gap. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_markers (mbuf,
+ (bi_to + BUF_GAP_SIZE (mbuf)),
+ (bi_to + BUF_GAP_SIZE (mbuf)),
+ (- bc_numdel - BUF_GAP_SIZE (mbuf)));
+ }
+
+ /* Relocate any extent endpoints just like markers. */
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
+ BUF_GAP_SIZE (mbuf),
+ bc_numdel, BUF_GAP_SIZE (mbuf));
+ }
+
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ /* Relocate point as if it were a marker. */
+ if (bi_from < BI_BUF_PT (mbuf))
+ {
+ if (BI_BUF_PT (mbuf) < bi_to)
+ JUST_SET_POINT (mbuf, from, bi_from);
+ else
+ JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+ BI_BUF_PT (mbuf) - bc_numdel);
+ }
+ }
+
+ SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + bc_numdel);
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+ BI_BUF_ZV (mbuf) - bc_numdel);
+ }
+ SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
+ SET_BI_BUF_GPT (buf, bi_from);
+ SET_GAP_SENTINEL (buf);
+ }
+
+#ifdef MULE
+ buffer_mule_signal_deleted_region (buf, from, to, bi_from, bi_to);
+#endif
+
+#ifdef ERROR_CHECK_EXTENTS
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ sledgehammer_extent_check (make_buffer (mbuf));
+ }
+#endif
+
+ signal_after_change (buf, from, to, from);
+}
+
+\f
+/************************************************************************/
+/* Replacement of characters */
+/************************************************************************/
+
+/* Replace the character at POS in buffer B with CH. */
+
+void
+buffer_replace_char (struct buffer *buf, Bufpos pos, Emchar ch,
+ int not_real_change, int force_lock_check)
+{
+ /* This function can GC */
+ Bufbyte curstr[MAX_EMCHAR_LEN];
+ Bufbyte newstr[MAX_EMCHAR_LEN];
+ Bytecount curlen, newlen;
+
+ /* Defensive steps just in case a buffer gets deleted and a calling
+ function doesn't notice it. */
+ if (!BUFFER_LIVE_P (buf))
+ return;
+
+ curlen = BUF_CHARPTR_COPY_CHAR (buf, pos, curstr);
+ newlen = set_charptr_emchar (newstr, ch);
+
+ if (curlen == newlen)
+ {
+ struct buffer *mbuf;
+ Lisp_Object bufcons;
+
+ /* then we can just replace the text. */
+ prepare_to_modify_buffer (buf, pos, pos + 1,
+ !not_real_change || force_lock_check);
+ /* Defensive steps in case the before-change-functions fuck around */
+ if (!BUFFER_LIVE_P (buf))
+ /* Bad bad pre-change function. */
+ return;
+
+ /* Make args be valid again. prepare_to_modify_buffer() might have
+ modified the buffer. */
+ if (pos < BUF_BEGV (buf))
+ pos = BUF_BEGV (buf);
+ if (pos >= BUF_ZV (buf))
+ pos = BUF_ZV (buf) - 1;
+ if (pos < BUF_BEGV (buf))
+ /* no more characters in buffer! */
+ return;
+
+ if (BUF_FETCH_CHAR (buf, pos) == '\n')
+ {
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ mbuf->changes->newline_was_deleted = 1;
+ }
+ }
+ MARK_BUFFERS_CHANGED;
+ if (!not_real_change)
+ {
+ MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ {
+ record_change (mbuf, pos, 1);
+ }
+ BUF_MODIFF (buf)++;
+ }
+ memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
+
+ signal_after_change (buf, pos, pos + 1, pos + 1);
+
+ /* We do not have to adjust the Mule data; we just replaced a
+ character with another of the same number of bytes. */
+ }
+ else
+ {
+ /*
+ * Must implement as deletion followed by insertion.
+ *
+ * Make a note to move point forward later in the one situation
+ * where it is needed, a delete/insert one position behind
+ * point. Point will drift backward by one position and stay
+ * there otherwise.
+ */
+ int movepoint = (pos == BUF_PT (buf) - 1);
+
+ buffer_delete_range (buf, pos, pos + 1, 0);
+ /* Defensive steps in case the before-change-functions fuck around */
+ if (!BUFFER_LIVE_P (buf))
+ /* Bad bad pre-change function. */
+ return;
+
+ /* Make args be valid again. prepare_to_modify_buffer() might have
+ modified the buffer. */
+ if (pos < BUF_BEGV (buf))
+ pos = BUF_BEGV (buf);
+ if (pos >= BUF_ZV (buf))
+ pos = BUF_ZV (buf) - 1;
+ if (pos < BUF_BEGV (buf))
+ /* no more characters in buffer! */
+ return;
+ /*
+ * -1 as the pos argument means to move point forward with the
+ * insertion, which we must do if the deletion moved point
+ * backward so that it now equals the insertion point.
+ */
+ buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
+ newstr, Qnil, 0, newlen, 0);
+ }
+}
+
+\f
+/************************************************************************/
+/* Other functions */
+/************************************************************************/
+
+/* Make a string from a buffer. This needs to take into account the gap,
+ and add any necessary extents from the buffer. */
+
+static Lisp_Object
+make_string_from_buffer_1 (struct buffer *buf, Bufpos pos, Charcount length,
+ int no_extents)
+{
+ /* This function can GC */
+ Bytind bi_ind = bufpos_to_bytind (buf, pos);
+ Bytecount bi_len = bufpos_to_bytind (buf, pos + length) - bi_ind;
+ Lisp_Object val = make_uninit_string (bi_len);
+
+ struct gcpro gcpro1;
+ GCPRO1 (val);
+
+ if (!no_extents)
+ add_string_extents (val, buf, bi_ind, bi_len);
+
+ {
+ Bytecount len1 = BI_BUF_GPT (buf) - bi_ind;
+ Bufbyte *start1 = BI_BUF_BYTE_ADDRESS (buf, bi_ind);
+ Bufbyte *dest = XSTRING_DATA (val);
+
+ if (len1 < 0)
+ {
+ /* Completely after gap */
+ memcpy (dest, start1, bi_len);
+ }
+ else if (bi_len <= len1)
+ {
+ /* Completely before gap */
+ memcpy (dest, start1, bi_len);
+ }
+ else
+ {
+ /* Spans gap */
+ Bytind pos2 = bi_ind + len1;
+ Bufbyte *start2 = BI_BUF_BYTE_ADDRESS (buf, pos2);
+
+ memcpy (dest, start1, len1);
+ memcpy (dest + len1, start2, bi_len - len1);
+ }
+ }
+
+ UNGCPRO;
+ return val;
+}
+
+Lisp_Object
+make_string_from_buffer (struct buffer *buf, Bufpos pos, Charcount length)
+{
+ return make_string_from_buffer_1 (buf, pos, length, 0);
+}
+
+Lisp_Object
+make_string_from_buffer_no_extents (struct buffer *buf, Bufpos pos,
+ Charcount length)
+{
+ return make_string_from_buffer_1 (buf, pos, length, 1);
+}
+
+void
+barf_if_buffer_read_only (struct buffer *buf, Bufpos from, Bufpos to)
+{
+ Lisp_Object buffer;
+ Lisp_Object iro;
+
+ XSETBUFFER (buffer, buf);
+ back:
+ iro = (buf == current_buffer ? Vinhibit_read_only :
+ symbol_value_in_buffer (Qinhibit_read_only, buffer));
+ if (!LISTP (iro))
+ return;
+ if (NILP (iro) && !NILP (buf->read_only))
+ {
+ Fsignal (Qbuffer_read_only, (list1 (buffer)));
+ goto back;
+ }
+ if (from > 0)
+ {
+ if (to < 0)
+ to = from;
+ verify_extent_modification (buffer,
+ bufpos_to_bytind (buf, from),
+ bufpos_to_bytind (buf, to),
+ iro);
+ }
+}
+
+void
+find_charsets_in_bufbyte_string (unsigned char *charsets, const Bufbyte *str,
+ Bytecount len)
+{
+#ifndef MULE
+ /* Telescope this. */
+ charsets[0] = 1;
+#else
+ const Bufbyte *strend = str + len;
+ memset (charsets, 0, NUM_LEADING_BYTES);
+
+ /* #### SJT doesn't like this. */
+ if (len == 0)
+ {
+ charsets[XCHARSET_LEADING_BYTE (Vcharset_ascii) - 128] = 1;
+ return;
+ }
+
+ while (str < strend)
+ {
+ charsets[CHAR_LEADING_BYTE (charptr_emchar (str)) - 128] = 1;
+ INC_CHARPTR (str);
+ }
+#endif
+}
+
+void
+find_charsets_in_emchar_string (unsigned char *charsets, const Emchar *str,
+ Charcount len)
+{
+#ifndef MULE
+ /* Telescope this. */
+ charsets[0] = 1;
+#else
+ int i;
+
+ memset (charsets, 0, NUM_LEADING_BYTES);
+
+ /* #### SJT doesn't like this. */
+ if (len == 0)
+ {
+ charsets[XCHARSET_LEADING_BYTE (Vcharset_ascii) - 128] = 1;
+ return;
+ }
+
+ for (i = 0; i < len; i++)
+ {
+ charsets[CHAR_LEADING_BYTE (str[i]) - 128] = 1;
+ }
+#endif
+}
+
+int
+bufbyte_string_displayed_columns (const Bufbyte *str, Bytecount len)
+{
+ int cols = 0;
+ const Bufbyte *end = str + len;
+
+ while (str < end)
+ {
+#ifdef MULE
+ Emchar ch = charptr_emchar (str);
+ cols += XCHARSET_COLUMNS (CHAR_CHARSET (ch));
+#else
+ cols++;
+#endif
+ INC_CHARPTR (str);
+ }
+
+ return cols;
+}
+
+int
+emchar_string_displayed_columns (const Emchar *str, Charcount len)
+{
+#ifdef MULE
+ int cols = 0;
+ int i;
+
+ for (i = 0; i < len; i++)
+ cols += XCHARSET_COLUMNS (CHAR_CHARSET (str[i]));
+
+ return cols;
+#else /* not MULE */
+ return len;
+#endif
+}
+
+/* NOTE: Does not reset the Dynarr. */
+
+void
+convert_bufbyte_string_into_emchar_dynarr (const Bufbyte *str, Bytecount len,
+ Emchar_dynarr *dyn)
+{
+ const Bufbyte *strend = str + len;
+
+ while (str < strend)
+ {
+ Emchar ch = charptr_emchar (str);
+ Dynarr_add (dyn, ch);
+ INC_CHARPTR (str);
+ }
+}
+
+Charcount
+convert_bufbyte_string_into_emchar_string (const Bufbyte *str, Bytecount len,
+ Emchar *arr)
+{
+ const Bufbyte *strend = str + len;
+ Charcount newlen = 0;
+ while (str < strend)
+ {
+ Emchar ch = charptr_emchar (str);
+ arr[newlen++] = ch;
+ INC_CHARPTR (str);
+ }
+ return newlen;
+}
+
+/* Convert an array of Emchars into the equivalent string representation.
+ Store into the given Bufbyte dynarr. Does not reset the dynarr.
+ Does not add a terminating zero. */
+
+void
+convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
+ Bufbyte_dynarr *dyn)
+{
+ Bufbyte str[MAX_EMCHAR_LEN];
+ int i;
+
+ for (i = 0; i < nels; i++)
+ {
+ Bytecount len = set_charptr_emchar (str, arr[i]);
+ Dynarr_add_many (dyn, str, len);
+ }
+}
+
+/* Convert an array of Emchars into the equivalent string representation.
+ Malloc the space needed for this and return it. If LEN_OUT is not a
+ NULL pointer, store into LEN_OUT the number of Bufbytes in the
+ malloc()ed string. Note that the actual number of Bufbytes allocated
+ is one more than this: the returned string is zero-terminated. */
+
+Bufbyte *
+convert_emchar_string_into_malloced_string (Emchar *arr, int nels,
+ Bytecount *len_out)
+{
+ /* Damn zero-termination. */
+ Bufbyte *str = (Bufbyte *) alloca (nels * MAX_EMCHAR_LEN + 1);
+ Bufbyte *strorig = str;
+ Bytecount len;
+
+ int i;
+
+ for (i = 0; i < nels; i++)
+ str += set_charptr_emchar (str, arr[i]);
+ *str = '\0';
+ len = str - strorig;
+ str = (Bufbyte *) xmalloc (1 + len);
+ memcpy (str, strorig, 1 + len);
+ if (len_out)
+ *len_out = len;
+ return str;
+}
+
+\f
+/************************************************************************/
+/* initialization */
+/************************************************************************/
+
+void
+reinit_vars_of_insdel (void)
+{
+ int i;
+
+ inside_change_hook = 0;
+ in_first_change = 0;
+
+ for (i = 0; i <= MAX_BYTIND_GAP_SIZE_3; i++)
+ three_to_one_table[i] = i / 3;
+}
+
+void
+vars_of_insdel (void)
+{
+ reinit_vars_of_insdel ();
+}
+
+void
+init_buffer_text (struct buffer *b)
+{
+ if (!b->base_buffer)
+ {
+ SET_BUF_GAP_SIZE (b, 20);
+ BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
+ if (! BUF_BEG_ADDR (b))
+ memory_full ();
+
+ SET_BUF_END_GAP_SIZE (b, 0);
+ SET_BI_BUF_GPT (b, 1);
+ SET_BOTH_BUF_Z (b, 1, 1);
+ SET_GAP_SENTINEL (b);
+ SET_END_SENTINEL (b);
+#ifdef MULE
+ {
+ int i;
+
+ b->text->mule_bufmin = b->text->mule_bufmax = 1;
+ b->text->mule_bytmin = b->text->mule_bytmax = 1;
+ b->text->mule_shifter = 0;
+ b->text->mule_three_p = 0;
+
+ for (i = 0; i < 16; i++)
+ {
+ b->text->mule_bufpos_cache[i] = 1;
+ b->text->mule_bytind_cache[i] = 1;
+ }
+ }
+#endif /* MULE */
+ b->text->line_number_cache = Qnil;
+
+ BUF_MODIFF (b) = 1;
+ BUF_SAVE_MODIFF (b) = 1;
+
+ JUST_SET_POINT (b, 1, 1);
+ SET_BOTH_BUF_BEGV (b, 1, 1);
+ SET_BOTH_BUF_ZV (b, 1, 1);
+
+ b->text->changes = xnew_and_zero (struct buffer_text_change_data);
+ }
+ else
+ {
+ JUST_SET_POINT (b, BUF_PT (b->base_buffer), BI_BUF_PT (b->base_buffer));
+ SET_BOTH_BUF_BEGV (b, BUF_BEGV (b->base_buffer),
+ BI_BUF_BEGV (b->base_buffer));
+ SET_BOTH_BUF_ZV (b, BUF_ZV (b->base_buffer),
+ BI_BUF_ZV (b->base_buffer));
+ }
+
+ b->changes = xnew_and_zero (struct each_buffer_change_data);
+ BUF_FACECHANGE (b) = 1;
+
+#ifdef REGION_CACHE_NEEDS_WORK
+ b->newline_cache = 0;
+ b->width_run_cache = 0;
+ b->width_table = Qnil;
+#endif
+}
+
+void
+uninit_buffer_text (struct buffer *b)
+{
+ if (!b->base_buffer)
+ {
+ BUFFER_FREE (b->text->beg);
+ xfree (b->text->changes);
+ }
+ xfree (b->changes);
+
+#ifdef REGION_CACHE_NEEDS_WORK
+ if (b->newline_cache)
+ {
+ free_region_cache (b->newline_cache);
+ b->newline_cache = 0;
+ }
+ if (b->width_run_cache)
+ {
+ free_region_cache (b->width_run_cache);
+ b->width_run_cache = 0;
+ }
+ b->width_table = Qnil;
+#endif
+}
projects / chise / xemacs-chise.git- / blobdiff