428
+ − 1 /* Buffer insertion/deletion and gap motion for XEmacs.
+ − 2 Copyright (C) 1985, 1986, 1991, 1992, 1993, 1994, 1995
+ − 3 Free Software Foundation, Inc.
+ − 4 Copyright (C) 1995 Sun Microsystems, Inc.
+ − 5
+ − 6 This file is part of XEmacs.
+ − 7
+ − 8 XEmacs is free software; you can redistribute it and/or modify it
+ − 9 under the terms of the GNU General Public License as published by the
+ − 10 Free Software Foundation; either version 2, or (at your option) any
+ − 11 later version.
+ − 12
+ − 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
+ − 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ − 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ − 16 for more details.
+ − 17
+ − 18 You should have received a copy of the GNU General Public License
+ − 19 along with XEmacs; see the file COPYING. If not, write to
+ − 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ − 21 Boston, MA 02111-1307, USA. */
+ − 22
+ − 23 /* Synched up with: Mule 2.0, FSF 19.30. Diverges significantly. */
+ − 24
+ − 25 /* This file has been Mule-ized. */
+ − 26
+ − 27 /* Overhauled by Ben Wing, December 1994, for Mule implementation. */
+ − 28
+ − 29 /*
+ − 30 There are three possible ways to specify positions in a buffer. All
+ − 31 of these are one-based: the beginning of the buffer is position or
+ − 32 index 1, and 0 is not a valid position.
+ − 33
+ − 34 As a "buffer position" (typedef Bufpos):
+ − 35
+ − 36 This is an index specifying an offset in characters from the
+ − 37 beginning of the buffer. Note that buffer positions are
+ − 38 logically *between* characters, not on a character. The
+ − 39 difference between two buffer positions specifies the number of
+ − 40 characters between those positions. Buffer positions are the
+ − 41 only kind of position externally visible to the user.
+ − 42
+ − 43 As a "byte index" (typedef Bytind):
+ − 44
+ − 45 This is an index over the bytes used to represent the characters
+ − 46 in the buffer. If there is no Mule support, this is identical
+ − 47 to a buffer position, because each character is represented
+ − 48 using one byte. However, with Mule support, many characters
+ − 49 require two or more bytes for their representation, and so a
+ − 50 byte index may be greater than the corresponding buffer
+ − 51 position.
+ − 52
+ − 53 As a "memory index" (typedef Memind):
+ − 54
+ − 55 This is the byte index adjusted for the gap. For positions
+ − 56 before the gap, this is identical to the byte index. For
+ − 57 positions after the gap, this is the byte index plus the gap
+ − 58 size. There are two possible memory indices for the gap
+ − 59 position; the memory index at the beginning of the gap should
+ − 60 always be used, except in code that deals with manipulating the
+ − 61 gap, where both indices may be seen. The address of the
+ − 62 character "at" (i.e. following) a particular position can be
+ − 63 obtained from the formula
+ − 64
+ − 65 buffer_start_address + memory_index(position) - 1
+ − 66
+ − 67 except in the case of characters at the gap position.
+ − 68
+ − 69 Other typedefs:
+ − 70 ===============
+ − 71
+ − 72 Emchar:
+ − 73 -------
+ − 74 This typedef represents a single Emacs character, which can be
+ − 75 ASCII, ISO-8859, or some extended character, as would typically
+ − 76 be used for Kanji. Note that the representation of a character
+ − 77 as an Emchar is *not* the same as the representation of that
+ − 78 same character in a string; thus, you cannot do the standard
+ − 79 C trick of passing a pointer to a character to a function that
+ − 80 expects a string.
+ − 81
+ − 82 An Emchar takes up 19 bits of representation and (for code
+ − 83 compatibility and such) is compatible with an int. This
+ − 84 representation is visible on the Lisp level. The important
+ − 85 characteristics of the Emchar representation are
+ − 86
+ − 87 -- values 0x00 - 0x7f represent ASCII.
+ − 88 -- values 0x80 - 0xff represent the right half of ISO-8859-1.
+ − 89 -- values 0x100 and up represent all other characters.
+ − 90
+ − 91 This means that Emchar values are upwardly compatible with
+ − 92 the standard 8-bit representation of ASCII/ISO-8859-1.
+ − 93
+ − 94 Bufbyte:
+ − 95 --------
+ − 96 The data in a buffer or string is logically made up of Bufbyte
+ − 97 objects, where a Bufbyte takes up the same amount of space as a
+ − 98 char. (It is declared differently, though, to catch invalid
+ − 99 usages.) Strings stored using Bufbytes are said to be in
+ − 100 "internal format". The important characteristics of internal
+ − 101 format are
+ − 102
+ − 103 -- ASCII characters are represented as a single Bufbyte,
+ − 104 in the range 0 - 0x7f.
+ − 105 -- All other characters are represented as a Bufbyte in
+ − 106 the range 0x80 - 0x9f followed by one or more Bufbytes
+ − 107 in the range 0xa0 to 0xff.
+ − 108
+ − 109 This leads to a number of desirable properties:
+ − 110
+ − 111 -- Given the position of the beginning of a character,
+ − 112 you can find the beginning of the next or previous
+ − 113 character in constant time.
+ − 114 -- When searching for a substring or an ASCII character
+ − 115 within the string, you need merely use standard
+ − 116 searching routines.
+ − 117
+ − 118 array of char:
+ − 119 --------------
+ − 120 Strings that go in or out of Emacs are in "external format",
+ − 121 typedef'ed as an array of char or a char *. There is more
+ − 122 than one external format (JIS, EUC, etc.) but they all
+ − 123 have similar properties. They are modal encodings,
+ − 124 which is to say that the meaning of particular bytes is
+ − 125 not fixed but depends on what "mode" the string is currently
+ − 126 in (e.g. bytes in the range 0 - 0x7f might be
+ − 127 interpreted as ASCII, or as Hiragana, or as 2-byte Kanji,
+ − 128 depending on the current mode). The mode starts out in
+ − 129 ASCII/ISO-8859-1 and is switched using escape sequences --
+ − 130 for example, in the JIS encoding, 'ESC $ B' switches to a
+ − 131 mode where pairs of bytes in the range 0 - 0x7f
+ − 132 are interpreted as Kanji characters.
+ − 133
+ − 134 External-formatted data is generally desirable for passing
+ − 135 data between programs because it is upwardly compatible
+ − 136 with standard ASCII/ISO-8859-1 strings and may require
+ − 137 less space than internal encodings such as the one
+ − 138 described above. In addition, some encodings (e.g. JIS)
+ − 139 keep all characters (except the ESC used to switch modes)
+ − 140 in the printing ASCII range 0x20 - 0x7e, which results in
+ − 141 a much higher probability that the data will avoid being
+ − 142 garbled in transmission. Externally-formatted data is
+ − 143 generally not very convenient to work with, however, and
+ − 144 for this reason is usually converted to internal format
+ − 145 before any work is done on the string.
+ − 146
+ − 147 NOTE: filenames need to be in external format so that
+ − 148 ISO-8859-1 characters come out correctly.
+ − 149
+ − 150 Charcount:
+ − 151 ----------
+ − 152 This typedef represents a count of characters, such as
+ − 153 a character offset into a string or the number of
+ − 154 characters between two positions in a buffer. The
+ − 155 difference between two Bufpos's is a Charcount, and
+ − 156 character positions in a string are represented using
+ − 157 a Charcount.
+ − 158
+ − 159 Bytecount:
+ − 160 ----------
+ − 161 Similar to a Charcount but represents a count of bytes.
+ − 162 The difference between two Bytind's is a Bytecount.
+ − 163
+ − 164
+ − 165 Usage of the various representations:
+ − 166 =====================================
+ − 167
+ − 168 Memory indices are used in low-level functions in insdel.c and for
+ − 169 extent endpoints and marker positions. The reason for this is that
+ − 170 this way, the extents and markers don't need to be updated for most
+ − 171 insertions, which merely shrink the gap and don't move any
+ − 172 characters around in memory.
+ − 173
+ − 174 (The beginning-of-gap memory index simplifies insertions w.r.t.
+ − 175 markers, because text usually gets inserted after markers. For
+ − 176 extents, it is merely for consistency, because text can get
+ − 177 inserted either before or after an extent's endpoint depending on
+ − 178 the open/closedness of the endpoint.)
+ − 179
+ − 180 Byte indices are used in other code that needs to be fast,
+ − 181 such as the searching, redisplay, and extent-manipulation code.
+ − 182
+ − 183 Buffer positions are used in all other code. This is because this
+ − 184 representation is easiest to work with (especially since Lisp
+ − 185 code always uses buffer positions), necessitates the fewest
+ − 186 changes to existing code, and is the safest (e.g. if the text gets
+ − 187 shifted underneath a buffer position, it will still point to a
+ − 188 character; if text is shifted under a byte index, it might point
+ − 189 to the middle of a character, which would be bad).
+ − 190
+ − 191 Similarly, Charcounts are used in all code that deals with strings
+ − 192 except for code that needs to be fast, which used Bytecounts.
+ − 193
+ − 194 Strings are always passed around internally using internal format.
+ − 195 Conversions between external format are performed at the time
+ − 196 that the data goes in or out of Emacs.
+ − 197
+ − 198 Working with the various representations:
+ − 199 ========================================= */
+ − 200
+ − 201 #include <config.h>
+ − 202 #include "lisp.h"
+ − 203
+ − 204 #include "buffer.h"
+ − 205 #include "device.h"
+ − 206 #include "frame.h"
+ − 207 #include "extents.h"
+ − 208 #include "insdel.h"
+ − 209 #include "lstream.h"
+ − 210 #include "redisplay.h"
+ − 211 #include "line-number.h"
+ − 212
+ − 213 /* We write things this way because it's very important the
+ − 214 MAX_BYTIND_GAP_SIZE_3 is a multiple of 3. (As it happens,
+ − 215 65535 is a multiple of 3, but this may not always be the
+ − 216 case.) */
+ − 217
+ − 218 #define MAX_BUFPOS_GAP_SIZE_3 (65535/3)
+ − 219 #define MAX_BYTIND_GAP_SIZE_3 (3 * MAX_BUFPOS_GAP_SIZE_3)
+ − 220
+ − 221 short three_to_one_table[1 + MAX_BYTIND_GAP_SIZE_3];
+ − 222
+ − 223 /* Various macros modelled along the lines of those in buffer.h.
+ − 224 Purposefully omitted from buffer.h because files other than this
+ − 225 one should not be using them. */
+ − 226
+ − 227 /* Address of beginning of buffer. This is an lvalue because
+ − 228 BUFFER_ALLOC needs it to be. */
+ − 229 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
+ − 230
+ − 231 /* Set the address of beginning of buffer. */
+ − 232 #define SET_BUF_BEG_ADDR(buf, addr) do { (buf)->text->beg = (addr); } while (0)
+ − 233
+ − 234 /* Gap size. */
+ − 235 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size + 0)
+ − 236 #define BUF_END_GAP_SIZE(buf) ((buf)->text->end_gap_size + 0)
+ − 237 /* Set gap size. */
+ − 238 #define SET_BUF_GAP_SIZE(buf, value) \
+ − 239 do { (buf)->text->gap_size = (value); } while (0)
+ − 240 #define SET_BUF_END_GAP_SIZE(buf, value) \
+ − 241 do { (buf)->text->end_gap_size = (value); } while (0)
+ − 242
+ − 243 /* Gap location. */
+ − 244 #define BI_BUF_GPT(buf) ((buf)->text->gpt + 0)
+ − 245 #define BUF_GPT_ADDR(buf) (BUF_BEG_ADDR (buf) + BI_BUF_GPT (buf) - 1)
+ − 246
+ − 247 /* Set gap location. */
+ − 248 #define SET_BI_BUF_GPT(buf, value) do { (buf)->text->gpt = (value); } while (0)
+ − 249
+ − 250 /* Set end of buffer. */
+ − 251 #define SET_BOTH_BUF_Z(buf, val, bival) \
+ − 252 do \
+ − 253 { \
+ − 254 (buf)->text->z = (bival); \
+ − 255 (buf)->text->bufz = (val); \
+ − 256 } while (0)
+ − 257
+ − 258 /* Under Mule, we maintain two sentinels in the buffer: one at the
+ − 259 beginning of the gap, and one at the end of the buffer. This
+ − 260 allows us to move forward, examining bytes looking for the
+ − 261 end of a character, and not worry about running off the end.
+ − 262 We do not need corresponding sentinels when moving backwards
+ − 263 because we do not have to look past the beginning of a character
+ − 264 to find the beginning of the character.
+ − 265
+ − 266 Every time we change the beginning of the gap, we have to
+ − 267 call SET_GAP_SENTINEL().
+ − 268
+ − 269 Every time we change the total size (characters plus gap)
+ − 270 of the buffer, we have to call SET_END_SENTINEL().
+ − 271 */
+ − 272
+ − 273
+ − 274 #ifdef MULE
+ − 275 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len) + 1)
+ − 276 # define SET_GAP_SENTINEL(buf) (*BUF_GPT_ADDR (buf) = 0)
+ − 277 # define BUF_END_SENTINEL_SIZE 1
+ − 278 # define SET_END_SENTINEL(buf) \
+ − 279 (*(BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + BI_BUF_Z (buf) - 1) = 0)
+ − 280 #else
+ − 281 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len))
+ − 282 # define SET_GAP_SENTINEL(buf)
+ − 283 # define BUF_END_SENTINEL_SIZE 0
+ − 284 # define SET_END_SENTINEL(buf)
+ − 285 #endif
+ − 286
+ − 287
+ − 288 /************************************************************************/
+ − 289 /* Charcount/Bytecount conversion */
+ − 290 /************************************************************************/
+ − 291
+ − 292 /* Optimization. Do it. Live it. Love it. */
+ − 293
+ − 294 #ifdef MULE
+ − 295
+ − 296 /* We include the basic functions here that require no specific
+ − 297 knowledge of how data is Mule-encoded into a buffer other
+ − 298 than the basic (00 - 7F), (80 - 9F), (A0 - FF) scheme.
+ − 299 Anything that requires more specific knowledge goes into
+ − 300 mule-charset.c. */
+ − 301
+ − 302 /* Given a pointer to a text string and a length in bytes, return
+ − 303 the equivalent length in characters. */
+ − 304
+ − 305 Charcount
442
+ − 306 bytecount_to_charcount (const Bufbyte *ptr, Bytecount len)
428
+ − 307 {
+ − 308 Charcount count = 0;
442
+ − 309 const Bufbyte *end = ptr + len;
+ − 310
+ − 311 #if SIZEOF_LONG == 8
+ − 312 # define STRIDE_TYPE long
+ − 313 # define HIGH_BIT_MASK 0x8080808080808080UL
+ − 314 #elif SIZEOF_LONG_LONG == 8 && !(defined (i386) || defined (__i386__))
+ − 315 # define STRIDE_TYPE long long
+ − 316 # define HIGH_BIT_MASK 0x8080808080808080ULL
+ − 317 #elif SIZEOF_LONG == 4
+ − 318 # define STRIDE_TYPE long
+ − 319 # define HIGH_BIT_MASK 0x80808080UL
+ − 320 #else
+ − 321 # error Add support for 128-bit systems here
+ − 322 #endif
+ − 323
+ − 324 #define ALIGN_BITS ((EMACS_UINT) (ALIGNOF (STRIDE_TYPE) - 1))
+ − 325 #define ALIGN_MASK (~ ALIGN_BITS)
+ − 326 #define ALIGNED(ptr) ((((EMACS_UINT) ptr) & ALIGN_BITS) == 0)
+ − 327 #define STRIDE sizeof (STRIDE_TYPE)
+ − 328
+ − 329 while (ptr < end)
428
+ − 330 {
442
+ − 331 if (BYTE_ASCII_P (*ptr))
428
+ − 332 {
442
+ − 333 /* optimize for long stretches of ASCII */
+ − 334 if (! ALIGNED (ptr))
+ − 335 ptr++, count++;
+ − 336 else
+ − 337 {
+ − 338 const unsigned STRIDE_TYPE *ascii_end =
+ − 339 (const unsigned STRIDE_TYPE *) ptr;
+ − 340 /* This loop screams, because we can typically
+ − 341 detect ASCII characters 8 at a time. */
+ − 342 while ((const Bufbyte *) ascii_end + STRIDE <= end
+ − 343 && !(*ascii_end & HIGH_BIT_MASK))
+ − 344 ascii_end++;
+ − 345 if ((Bufbyte *) ascii_end == ptr)
+ − 346 ptr++, count++;
+ − 347 else
+ − 348 {
+ − 349 count += (Bufbyte *) ascii_end - ptr;
+ − 350 ptr = (Bufbyte *) ascii_end;
+ − 351 }
+ − 352 }
428
+ − 353 }
442
+ − 354 else
428
+ − 355 {
442
+ − 356 /* optimize for successive characters from the same charset */
+ − 357 Bufbyte leading_byte = *ptr;
+ − 358 size_t bytes = REP_BYTES_BY_FIRST_BYTE (leading_byte);
+ − 359 while ((ptr < end) && (*ptr == leading_byte))
+ − 360 ptr += bytes, count++;
428
+ − 361 }
+ − 362 }
+ − 363
+ − 364 #ifdef ERROR_CHECK_BUFPOS
+ − 365 /* Bomb out if the specified substring ends in the middle
+ − 366 of a character. Note that we might have already gotten
+ − 367 a core dump above from an invalid reference, but at least
+ − 368 we will get no farther than here. */
+ − 369 assert (ptr == end);
+ − 370 #endif
+ − 371
+ − 372 return count;
+ − 373 }
+ − 374
+ − 375 /* Given a pointer to a text string and a length in characters, return
+ − 376 the equivalent length in bytes. */
+ − 377
+ − 378 Bytecount
442
+ − 379 charcount_to_bytecount (const Bufbyte *ptr, Charcount len)
428
+ − 380 {
442
+ − 381 const Bufbyte *newptr = ptr;
428
+ − 382
+ − 383 while (len > 0)
+ − 384 {
+ − 385 INC_CHARPTR (newptr);
+ − 386 len--;
+ − 387 }
+ − 388 return newptr - ptr;
+ − 389 }
+ − 390
+ − 391 /* The next two functions are the actual meat behind the
+ − 392 bufpos-to-bytind and bytind-to-bufpos conversions. Currently
+ − 393 the method they use is fairly unsophisticated; see buffer.h.
+ − 394
+ − 395 Note that bufpos_to_bytind_func() is probably the most-called
+ − 396 function in all of XEmacs. Therefore, it must be FAST FAST FAST.
+ − 397 This is the reason why so much of the code is duplicated.
+ − 398
+ − 399 Similar considerations apply to bytind_to_bufpos_func(), although
+ − 400 less so because the function is not called so often.
+ − 401
+ − 402 #### At some point this should use a more sophisticated method;
+ − 403 see buffer.h. */
+ − 404
+ − 405 static int not_very_random_number;
+ − 406
+ − 407 Bytind
+ − 408 bufpos_to_bytind_func (struct buffer *buf, Bufpos x)
+ − 409 {
+ − 410 Bufpos bufmin;
+ − 411 Bufpos bufmax;
+ − 412 Bytind bytmin;
+ − 413 Bytind bytmax;
+ − 414 int size;
+ − 415 int forward_p;
+ − 416 Bytind retval;
+ − 417 int diff_so_far;
+ − 418 int add_to_cache = 0;
+ − 419
+ − 420 /* Check for some cached positions, for speed. */
+ − 421 if (x == BUF_PT (buf))
+ − 422 return BI_BUF_PT (buf);
+ − 423 if (x == BUF_ZV (buf))
+ − 424 return BI_BUF_ZV (buf);
+ − 425 if (x == BUF_BEGV (buf))
+ − 426 return BI_BUF_BEGV (buf);
+ − 427
+ − 428 bufmin = buf->text->mule_bufmin;
+ − 429 bufmax = buf->text->mule_bufmax;
+ − 430 bytmin = buf->text->mule_bytmin;
+ − 431 bytmax = buf->text->mule_bytmax;
+ − 432 size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
+ − 433
+ − 434 /* The basic idea here is that we shift the "known region" up or down
+ − 435 until it overlaps the specified position. We do this by moving
+ − 436 the upper bound of the known region up one character at a time,
+ − 437 and moving the lower bound of the known region up as necessary
+ − 438 when the size of the character just seen changes.
+ − 439
+ − 440 We optimize this, however, by first shifting the known region to
+ − 441 one of the cached points if it's close by. (We don't check BEG or
+ − 442 Z, even though they're cached; most of the time these will be the
+ − 443 same as BEGV and ZV, and when they're not, they're not likely
+ − 444 to be used.) */
+ − 445
+ − 446 if (x > bufmax)
+ − 447 {
+ − 448 Bufpos diffmax = x - bufmax;
+ − 449 Bufpos diffpt = x - BUF_PT (buf);
+ − 450 Bufpos diffzv = BUF_ZV (buf) - x;
+ − 451 /* #### This value could stand some more exploration. */
+ − 452 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
+ − 453
+ − 454 /* Check if the position is closer to PT or ZV than to the
+ − 455 end of the known region. */
+ − 456
+ − 457 if (diffpt < 0)
+ − 458 diffpt = -diffpt;
+ − 459 if (diffzv < 0)
+ − 460 diffzv = -diffzv;
+ − 461
+ − 462 /* But also implement a heuristic that favors the known region
+ − 463 over PT or ZV. The reason for this is that switching to
+ − 464 PT or ZV will wipe out the knowledge in the known region,
+ − 465 which might be annoying if the known region is large and
+ − 466 PT or ZV is not that much closer than the end of the known
+ − 467 region. */
+ − 468
+ − 469 diffzv += heuristic_hack;
+ − 470 diffpt += heuristic_hack;
+ − 471 if (diffpt < diffmax && diffpt <= diffzv)
+ − 472 {
+ − 473 bufmax = bufmin = BUF_PT (buf);
+ − 474 bytmax = bytmin = BI_BUF_PT (buf);
+ − 475 /* We set the size to 1 even though it doesn't really
+ − 476 matter because the new known region contains no
+ − 477 characters. We do this because this is the most
+ − 478 likely size of the characters around the new known
+ − 479 region, and we avoid potential yuckiness that is
+ − 480 done when size == 3. */
+ − 481 size = 1;
+ − 482 }
+ − 483 if (diffzv < diffmax)
+ − 484 {
+ − 485 bufmax = bufmin = BUF_ZV (buf);
+ − 486 bytmax = bytmin = BI_BUF_ZV (buf);
+ − 487 size = 1;
+ − 488 }
+ − 489 }
+ − 490 #ifdef ERROR_CHECK_BUFPOS
+ − 491 else if (x >= bufmin)
+ − 492 abort ();
+ − 493 #endif
+ − 494 else
+ − 495 {
+ − 496 Bufpos diffmin = bufmin - x;
+ − 497 Bufpos diffpt = BUF_PT (buf) - x;
+ − 498 Bufpos diffbegv = x - BUF_BEGV (buf);
+ − 499 /* #### This value could stand some more exploration. */
+ − 500 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
+ − 501
+ − 502 if (diffpt < 0)
+ − 503 diffpt = -diffpt;
+ − 504 if (diffbegv < 0)
+ − 505 diffbegv = -diffbegv;
+ − 506
+ − 507 /* But also implement a heuristic that favors the known region --
+ − 508 see above. */
+ − 509
+ − 510 diffbegv += heuristic_hack;
+ − 511 diffpt += heuristic_hack;
+ − 512
+ − 513 if (diffpt < diffmin && diffpt <= diffbegv)
+ − 514 {
+ − 515 bufmax = bufmin = BUF_PT (buf);
+ − 516 bytmax = bytmin = BI_BUF_PT (buf);
+ − 517 /* We set the size to 1 even though it doesn't really
+ − 518 matter because the new known region contains no
+ − 519 characters. We do this because this is the most
+ − 520 likely size of the characters around the new known
+ − 521 region, and we avoid potential yuckiness that is
+ − 522 done when size == 3. */
+ − 523 size = 1;
+ − 524 }
+ − 525 if (diffbegv < diffmin)
+ − 526 {
+ − 527 bufmax = bufmin = BUF_BEGV (buf);
+ − 528 bytmax = bytmin = BI_BUF_BEGV (buf);
+ − 529 size = 1;
+ − 530 }
+ − 531 }
+ − 532
+ − 533 diff_so_far = x > bufmax ? x - bufmax : bufmin - x;
+ − 534 if (diff_so_far > 50)
+ − 535 {
+ − 536 /* If we have to move more than a certain amount, then look
+ − 537 into our cache. */
+ − 538 int minval = INT_MAX;
+ − 539 int found = 0;
+ − 540 int i;
+ − 541
+ − 542 add_to_cache = 1;
+ − 543 /* I considered keeping the positions ordered. This would speed
+ − 544 up this loop, but updating the cache would take longer, so
+ − 545 it doesn't seem like it would really matter. */
+ − 546 for (i = 0; i < 16; i++)
+ − 547 {
+ − 548 int diff = buf->text->mule_bufpos_cache[i] - x;
+ − 549
+ − 550 if (diff < 0)
+ − 551 diff = -diff;
+ − 552 if (diff < minval)
+ − 553 {
+ − 554 minval = diff;
+ − 555 found = i;
+ − 556 }
+ − 557 }
+ − 558
+ − 559 if (minval < diff_so_far)
+ − 560 {
+ − 561 bufmax = bufmin = buf->text->mule_bufpos_cache[found];
+ − 562 bytmax = bytmin = buf->text->mule_bytind_cache[found];
+ − 563 size = 1;
+ − 564 }
+ − 565 }
+ − 566
+ − 567 /* It's conceivable that the caching above could lead to X being
+ − 568 the same as one of the range edges. */
+ − 569 if (x >= bufmax)
+ − 570 {
+ − 571 Bytind newmax;
+ − 572 Bytecount newsize;
+ − 573
+ − 574 forward_p = 1;
+ − 575 while (x > bufmax)
+ − 576 {
+ − 577 newmax = bytmax;
+ − 578
+ − 579 INC_BYTIND (buf, newmax);
+ − 580 newsize = newmax - bytmax;
+ − 581 if (newsize != size)
+ − 582 {
+ − 583 bufmin = bufmax;
+ − 584 bytmin = bytmax;
+ − 585 size = newsize;
+ − 586 }
+ − 587 bytmax = newmax;
+ − 588 bufmax++;
+ − 589 }
+ − 590 retval = bytmax;
+ − 591
+ − 592 /* #### Should go past the found location to reduce the number
+ − 593 of times that this function is called */
+ − 594 }
+ − 595 else /* x < bufmin */
+ − 596 {
+ − 597 Bytind newmin;
+ − 598 Bytecount newsize;
+ − 599
+ − 600 forward_p = 0;
+ − 601 while (x < bufmin)
+ − 602 {
+ − 603 newmin = bytmin;
+ − 604
+ − 605 DEC_BYTIND (buf, newmin);
+ − 606 newsize = bytmin - newmin;
+ − 607 if (newsize != size)
+ − 608 {
+ − 609 bufmax = bufmin;
+ − 610 bytmax = bytmin;
+ − 611 size = newsize;
+ − 612 }
+ − 613 bytmin = newmin;
+ − 614 bufmin--;
+ − 615 }
+ − 616 retval = bytmin;
+ − 617
+ − 618 /* #### Should go past the found location to reduce the number
+ − 619 of times that this function is called
+ − 620 */
+ − 621 }
+ − 622
+ − 623 /* If size is three, than we have to max sure that the range we
+ − 624 discovered isn't too large, because we use a fixed-length
+ − 625 table to divide by 3. */
+ − 626
+ − 627 if (size == 3)
+ − 628 {
+ − 629 int gap = bytmax - bytmin;
+ − 630 buf->text->mule_three_p = 1;
+ − 631 buf->text->mule_shifter = 1;
+ − 632
+ − 633 if (gap > MAX_BYTIND_GAP_SIZE_3)
+ − 634 {
+ − 635 if (forward_p)
+ − 636 {
+ − 637 bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
+ − 638 bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
+ − 639 }
+ − 640 else
+ − 641 {
+ − 642 bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
+ − 643 bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
+ − 644 }
+ − 645 }
+ − 646 }
+ − 647 else
+ − 648 {
+ − 649 buf->text->mule_three_p = 0;
+ − 650 if (size == 4)
+ − 651 buf->text->mule_shifter = 2;
+ − 652 else
+ − 653 buf->text->mule_shifter = size - 1;
+ − 654 }
+ − 655
+ − 656 buf->text->mule_bufmin = bufmin;
+ − 657 buf->text->mule_bufmax = bufmax;
+ − 658 buf->text->mule_bytmin = bytmin;
+ − 659 buf->text->mule_bytmax = bytmax;
+ − 660
+ − 661 if (add_to_cache)
+ − 662 {
+ − 663 int replace_loc;
+ − 664
+ − 665 /* We throw away a "random" cached value and replace it with
+ − 666 the new value. It doesn't actually have to be very random
+ − 667 at all, just evenly distributed.
+ − 668
+ − 669 #### It would be better to use a least-recently-used algorithm
+ − 670 or something that tries to space things out, but I'm not sure
+ − 671 it's worth it to go to the trouble of maintaining that. */
+ − 672 not_very_random_number += 621;
+ − 673 replace_loc = not_very_random_number & 15;
+ − 674 buf->text->mule_bufpos_cache[replace_loc] = x;
+ − 675 buf->text->mule_bytind_cache[replace_loc] = retval;
+ − 676 }
+ − 677
+ − 678 return retval;
+ − 679 }
+ − 680
+ − 681 /* The logic in this function is almost identical to the logic in
+ − 682 the previous function. */
+ − 683
+ − 684 Bufpos
+ − 685 bytind_to_bufpos_func (struct buffer *buf, Bytind x)
+ − 686 {
+ − 687 Bufpos bufmin;
+ − 688 Bufpos bufmax;
+ − 689 Bytind bytmin;
+ − 690 Bytind bytmax;
+ − 691 int size;
+ − 692 int forward_p;
+ − 693 Bufpos retval;
+ − 694 int diff_so_far;
+ − 695 int add_to_cache = 0;
+ − 696
+ − 697 /* Check for some cached positions, for speed. */
+ − 698 if (x == BI_BUF_PT (buf))
+ − 699 return BUF_PT (buf);
+ − 700 if (x == BI_BUF_ZV (buf))
+ − 701 return BUF_ZV (buf);
+ − 702 if (x == BI_BUF_BEGV (buf))
+ − 703 return BUF_BEGV (buf);
+ − 704
+ − 705 bufmin = buf->text->mule_bufmin;
+ − 706 bufmax = buf->text->mule_bufmax;
+ − 707 bytmin = buf->text->mule_bytmin;
+ − 708 bytmax = buf->text->mule_bytmax;
+ − 709 size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
+ − 710
+ − 711 /* The basic idea here is that we shift the "known region" up or down
+ − 712 until it overlaps the specified position. We do this by moving
+ − 713 the upper bound of the known region up one character at a time,
+ − 714 and moving the lower bound of the known region up as necessary
+ − 715 when the size of the character just seen changes.
+ − 716
+ − 717 We optimize this, however, by first shifting the known region to
+ − 718 one of the cached points if it's close by. (We don't check BI_BEG or
+ − 719 BI_Z, even though they're cached; most of the time these will be the
+ − 720 same as BI_BEGV and BI_ZV, and when they're not, they're not likely
+ − 721 to be used.) */
+ − 722
+ − 723 if (x > bytmax)
+ − 724 {
+ − 725 Bytind diffmax = x - bytmax;
+ − 726 Bytind diffpt = x - BI_BUF_PT (buf);
+ − 727 Bytind diffzv = BI_BUF_ZV (buf) - x;
+ − 728 /* #### This value could stand some more exploration. */
+ − 729 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
+ − 730
+ − 731 /* Check if the position is closer to PT or ZV than to the
+ − 732 end of the known region. */
+ − 733
+ − 734 if (diffpt < 0)
+ − 735 diffpt = -diffpt;
+ − 736 if (diffzv < 0)
+ − 737 diffzv = -diffzv;
+ − 738
+ − 739 /* But also implement a heuristic that favors the known region
+ − 740 over BI_PT or BI_ZV. The reason for this is that switching to
+ − 741 BI_PT or BI_ZV will wipe out the knowledge in the known region,
+ − 742 which might be annoying if the known region is large and
+ − 743 BI_PT or BI_ZV is not that much closer than the end of the known
+ − 744 region. */
+ − 745
+ − 746 diffzv += heuristic_hack;
+ − 747 diffpt += heuristic_hack;
+ − 748 if (diffpt < diffmax && diffpt <= diffzv)
+ − 749 {
+ − 750 bufmax = bufmin = BUF_PT (buf);
+ − 751 bytmax = bytmin = BI_BUF_PT (buf);
+ − 752 /* We set the size to 1 even though it doesn't really
+ − 753 matter because the new known region contains no
+ − 754 characters. We do this because this is the most
+ − 755 likely size of the characters around the new known
+ − 756 region, and we avoid potential yuckiness that is
+ − 757 done when size == 3. */
+ − 758 size = 1;
+ − 759 }
+ − 760 if (diffzv < diffmax)
+ − 761 {
+ − 762 bufmax = bufmin = BUF_ZV (buf);
+ − 763 bytmax = bytmin = BI_BUF_ZV (buf);
+ − 764 size = 1;
+ − 765 }
+ − 766 }
+ − 767 #ifdef ERROR_CHECK_BUFPOS
+ − 768 else if (x >= bytmin)
+ − 769 abort ();
+ − 770 #endif
+ − 771 else
+ − 772 {
+ − 773 Bytind diffmin = bytmin - x;
+ − 774 Bytind diffpt = BI_BUF_PT (buf) - x;
+ − 775 Bytind diffbegv = x - BI_BUF_BEGV (buf);
+ − 776 /* #### This value could stand some more exploration. */
+ − 777 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
+ − 778
+ − 779 if (diffpt < 0)
+ − 780 diffpt = -diffpt;
+ − 781 if (diffbegv < 0)
+ − 782 diffbegv = -diffbegv;
+ − 783
+ − 784 /* But also implement a heuristic that favors the known region --
+ − 785 see above. */
+ − 786
+ − 787 diffbegv += heuristic_hack;
+ − 788 diffpt += heuristic_hack;
+ − 789
+ − 790 if (diffpt < diffmin && diffpt <= diffbegv)
+ − 791 {
+ − 792 bufmax = bufmin = BUF_PT (buf);
+ − 793 bytmax = bytmin = BI_BUF_PT (buf);
+ − 794 /* We set the size to 1 even though it doesn't really
+ − 795 matter because the new known region contains no
+ − 796 characters. We do this because this is the most
+ − 797 likely size of the characters around the new known
+ − 798 region, and we avoid potential yuckiness that is
+ − 799 done when size == 3. */
+ − 800 size = 1;
+ − 801 }
+ − 802 if (diffbegv < diffmin)
+ − 803 {
+ − 804 bufmax = bufmin = BUF_BEGV (buf);
+ − 805 bytmax = bytmin = BI_BUF_BEGV (buf);
+ − 806 size = 1;
+ − 807 }
+ − 808 }
+ − 809
+ − 810 diff_so_far = x > bytmax ? x - bytmax : bytmin - x;
+ − 811 if (diff_so_far > 50)
+ − 812 {
+ − 813 /* If we have to move more than a certain amount, then look
+ − 814 into our cache. */
+ − 815 int minval = INT_MAX;
+ − 816 int found = 0;
+ − 817 int i;
+ − 818
+ − 819 add_to_cache = 1;
+ − 820 /* I considered keeping the positions ordered. This would speed
+ − 821 up this loop, but updating the cache would take longer, so
+ − 822 it doesn't seem like it would really matter. */
+ − 823 for (i = 0; i < 16; i++)
+ − 824 {
+ − 825 int diff = buf->text->mule_bytind_cache[i] - x;
+ − 826
+ − 827 if (diff < 0)
+ − 828 diff = -diff;
+ − 829 if (diff < minval)
+ − 830 {
+ − 831 minval = diff;
+ − 832 found = i;
+ − 833 }
+ − 834 }
+ − 835
+ − 836 if (minval < diff_so_far)
+ − 837 {
+ − 838 bufmax = bufmin = buf->text->mule_bufpos_cache[found];
+ − 839 bytmax = bytmin = buf->text->mule_bytind_cache[found];
+ − 840 size = 1;
+ − 841 }
+ − 842 }
+ − 843
+ − 844 /* It's conceivable that the caching above could lead to X being
+ − 845 the same as one of the range edges. */
+ − 846 if (x >= bytmax)
+ − 847 {
+ − 848 Bytind newmax;
+ − 849 Bytecount newsize;
+ − 850
+ − 851 forward_p = 1;
+ − 852 while (x > bytmax)
+ − 853 {
+ − 854 newmax = bytmax;
+ − 855
+ − 856 INC_BYTIND (buf, newmax);
+ − 857 newsize = newmax - bytmax;
+ − 858 if (newsize != size)
+ − 859 {
+ − 860 bufmin = bufmax;
+ − 861 bytmin = bytmax;
+ − 862 size = newsize;
+ − 863 }
+ − 864 bytmax = newmax;
+ − 865 bufmax++;
+ − 866 }
+ − 867 retval = bufmax;
+ − 868
+ − 869 /* #### Should go past the found location to reduce the number
+ − 870 of times that this function is called */
+ − 871 }
+ − 872 else /* x <= bytmin */
+ − 873 {
+ − 874 Bytind newmin;
+ − 875 Bytecount newsize;
+ − 876
+ − 877 forward_p = 0;
+ − 878 while (x < bytmin)
+ − 879 {
+ − 880 newmin = bytmin;
+ − 881
+ − 882 DEC_BYTIND (buf, newmin);
+ − 883 newsize = bytmin - newmin;
+ − 884 if (newsize != size)
+ − 885 {
+ − 886 bufmax = bufmin;
+ − 887 bytmax = bytmin;
+ − 888 size = newsize;
+ − 889 }
+ − 890 bytmin = newmin;
+ − 891 bufmin--;
+ − 892 }
+ − 893 retval = bufmin;
+ − 894
+ − 895 /* #### Should go past the found location to reduce the number
+ − 896 of times that this function is called
+ − 897 */
+ − 898 }
+ − 899
+ − 900 /* If size is three, than we have to max sure that the range we
+ − 901 discovered isn't too large, because we use a fixed-length
+ − 902 table to divide by 3. */
+ − 903
+ − 904 if (size == 3)
+ − 905 {
+ − 906 int gap = bytmax - bytmin;
+ − 907 buf->text->mule_three_p = 1;
+ − 908 buf->text->mule_shifter = 1;
+ − 909
+ − 910 if (gap > MAX_BYTIND_GAP_SIZE_3)
+ − 911 {
+ − 912 if (forward_p)
+ − 913 {
+ − 914 bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
+ − 915 bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
+ − 916 }
+ − 917 else
+ − 918 {
+ − 919 bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
+ − 920 bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
+ − 921 }
+ − 922 }
+ − 923 }
+ − 924 else
+ − 925 {
+ − 926 buf->text->mule_three_p = 0;
+ − 927 if (size == 4)
+ − 928 buf->text->mule_shifter = 2;
+ − 929 else
+ − 930 buf->text->mule_shifter = size - 1;
+ − 931 }
+ − 932
+ − 933 buf->text->mule_bufmin = bufmin;
+ − 934 buf->text->mule_bufmax = bufmax;
+ − 935 buf->text->mule_bytmin = bytmin;
+ − 936 buf->text->mule_bytmax = bytmax;
+ − 937
+ − 938 if (add_to_cache)
+ − 939 {
+ − 940 int replace_loc;
+ − 941
+ − 942 /* We throw away a "random" cached value and replace it with
+ − 943 the new value. It doesn't actually have to be very random
+ − 944 at all, just evenly distributed.
+ − 945
+ − 946 #### It would be better to use a least-recently-used algorithm
+ − 947 or something that tries to space things out, but I'm not sure
+ − 948 it's worth it to go to the trouble of maintaining that. */
+ − 949 not_very_random_number += 621;
+ − 950 replace_loc = not_very_random_number & 15;
+ − 951 buf->text->mule_bufpos_cache[replace_loc] = retval;
+ − 952 buf->text->mule_bytind_cache[replace_loc] = x;
+ − 953 }
+ − 954
+ − 955 return retval;
+ − 956 }
+ − 957
+ − 958 /* Text of length BYTELENGTH and CHARLENGTH (in different units)
+ − 959 was inserted at bufpos START. */
+ − 960
+ − 961 static void
+ − 962 buffer_mule_signal_inserted_region (struct buffer *buf, Bufpos start,
+ − 963 Bytecount bytelength,
+ − 964 Charcount charlength)
+ − 965 {
+ − 966 int size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
+ − 967 int i;
+ − 968
+ − 969 /* Adjust the cache of known positions. */
+ − 970 for (i = 0; i < 16; i++)
+ − 971 {
+ − 972
+ − 973 if (buf->text->mule_bufpos_cache[i] > start)
+ − 974 {
+ − 975 buf->text->mule_bufpos_cache[i] += charlength;
+ − 976 buf->text->mule_bytind_cache[i] += bytelength;
+ − 977 }
+ − 978 }
+ − 979
+ − 980 if (start >= buf->text->mule_bufmax)
+ − 981 return;
+ − 982
+ − 983 /* The insertion is either before the known region, in which case
+ − 984 it shoves it forward; or within the known region, in which case
+ − 985 it shoves the end forward. (But it may make the known region
+ − 986 inconsistent, so we may have to shorten it.) */
+ − 987
+ − 988 if (start <= buf->text->mule_bufmin)
+ − 989 {
+ − 990 buf->text->mule_bufmin += charlength;
+ − 991 buf->text->mule_bufmax += charlength;
+ − 992 buf->text->mule_bytmin += bytelength;
+ − 993 buf->text->mule_bytmax += bytelength;
+ − 994 }
+ − 995 else
+ − 996 {
+ − 997 Bufpos end = start + charlength;
+ − 998 /* the insertion point divides the known region in two.
+ − 999 Keep the longer half, at least, and expand into the
+ − 1000 inserted chunk as much as possible. */
+ − 1001
+ − 1002 if (start - buf->text->mule_bufmin > buf->text->mule_bufmax - start)
+ − 1003 {
+ − 1004 Bytind bytestart = (buf->text->mule_bytmin
+ − 1005 + size * (start - buf->text->mule_bufmin));
+ − 1006 Bytind bytenew;
+ − 1007
+ − 1008 while (start < end)
+ − 1009 {
+ − 1010 bytenew = bytestart;
+ − 1011 INC_BYTIND (buf, bytenew);
+ − 1012 if (bytenew - bytestart != size)
+ − 1013 break;
+ − 1014 start++;
+ − 1015 bytestart = bytenew;
+ − 1016 }
+ − 1017 if (start != end)
+ − 1018 {
+ − 1019 buf->text->mule_bufmax = start;
+ − 1020 buf->text->mule_bytmax = bytestart;
+ − 1021 }
+ − 1022 else
+ − 1023 {
+ − 1024 buf->text->mule_bufmax += charlength;
+ − 1025 buf->text->mule_bytmax += bytelength;
+ − 1026 }
+ − 1027 }
+ − 1028 else
+ − 1029 {
+ − 1030 Bytind byteend = (buf->text->mule_bytmin
+ − 1031 + size * (start - buf->text->mule_bufmin)
+ − 1032 + bytelength);
+ − 1033 Bytind bytenew;
+ − 1034
+ − 1035 buf->text->mule_bufmax += charlength;
+ − 1036 buf->text->mule_bytmax += bytelength;
+ − 1037
+ − 1038 while (end > start)
+ − 1039 {
+ − 1040 bytenew = byteend;
+ − 1041 DEC_BYTIND (buf, bytenew);
+ − 1042 if (byteend - bytenew != size)
+ − 1043 break;
+ − 1044 end--;
+ − 1045 byteend = bytenew;
+ − 1046 }
+ − 1047 if (start != end)
+ − 1048 {
+ − 1049 buf->text->mule_bufmin = end;
+ − 1050 buf->text->mule_bytmin = byteend;
+ − 1051 }
+ − 1052 }
+ − 1053 }
+ − 1054 }
+ − 1055
+ − 1056 /* Text from START to END (equivalent in Bytinds: from BI_START to
+ − 1057 BI_END) was deleted. */
+ − 1058
+ − 1059 static void
+ − 1060 buffer_mule_signal_deleted_region (struct buffer *buf, Bufpos start,
+ − 1061 Bufpos end, Bytind bi_start,
+ − 1062 Bytind bi_end)
+ − 1063 {
+ − 1064 int i;
+ − 1065
+ − 1066 /* Adjust the cache of known positions. */
+ − 1067 for (i = 0; i < 16; i++)
+ − 1068 {
+ − 1069 /* After the end; gets shoved backward */
+ − 1070 if (buf->text->mule_bufpos_cache[i] > end)
+ − 1071 {
+ − 1072 buf->text->mule_bufpos_cache[i] -= end - start;
+ − 1073 buf->text->mule_bytind_cache[i] -= bi_end - bi_start;
+ − 1074 }
+ − 1075 /* In the range; moves to start of range */
+ − 1076 else if (buf->text->mule_bufpos_cache[i] > start)
+ − 1077 {
+ − 1078 buf->text->mule_bufpos_cache[i] = start;
+ − 1079 buf->text->mule_bytind_cache[i] = bi_start;
+ − 1080 }
+ − 1081 }
+ − 1082
+ − 1083 /* We don't care about any text after the end of the known region. */
+ − 1084
+ − 1085 end = min (end, buf->text->mule_bufmax);
+ − 1086 bi_end = min (bi_end, buf->text->mule_bytmax);
+ − 1087 if (start >= end)
+ − 1088 return;
+ − 1089
+ − 1090 /* The end of the known region offsets by the total amount of deletion,
+ − 1091 since it's all before it. */
+ − 1092
+ − 1093 buf->text->mule_bufmax -= end - start;
+ − 1094 buf->text->mule_bytmax -= bi_end - bi_start;
+ − 1095
+ − 1096 /* Now we don't care about any text after the start of the known region. */
+ − 1097
+ − 1098 end = min (end, buf->text->mule_bufmin);
+ − 1099 bi_end = min (bi_end, buf->text->mule_bytmin);
+ − 1100 if (start >= end)
+ − 1101 return;
+ − 1102
+ − 1103 buf->text->mule_bufmin -= end - start;
+ − 1104 buf->text->mule_bytmin -= bi_end - bi_start;
+ − 1105 }
+ − 1106
+ − 1107 #endif /* MULE */
+ − 1108
+ − 1109 #ifdef ERROR_CHECK_BUFPOS
+ − 1110
+ − 1111 Bytind
+ − 1112 bufpos_to_bytind (struct buffer *buf, Bufpos x)
+ − 1113 {
+ − 1114 Bytind retval = real_bufpos_to_bytind (buf, x);
+ − 1115 ASSERT_VALID_BYTIND_UNSAFE (buf, retval);
+ − 1116 return retval;
+ − 1117 }
+ − 1118
+ − 1119 Bufpos
+ − 1120 bytind_to_bufpos (struct buffer *buf, Bytind x)
+ − 1121 {
+ − 1122 ASSERT_VALID_BYTIND_UNSAFE (buf, x);
+ − 1123 return real_bytind_to_bufpos (buf, x);
+ − 1124 }
+ − 1125
+ − 1126 #endif /* ERROR_CHECK_BUFPOS */
+ − 1127
+ − 1128
+ − 1129 /************************************************************************/
+ − 1130 /* verifying buffer and string positions */
+ − 1131 /************************************************************************/
+ − 1132
+ − 1133 /* Functions below are tagged with either _byte or _char indicating
+ − 1134 whether they return byte or character positions. For a buffer,
+ − 1135 a character position is a "Bufpos" and a byte position is a "Bytind".
+ − 1136 For strings, these are sometimes typed using "Charcount" and
+ − 1137 "Bytecount". */
+ − 1138
+ − 1139 /* Flags for the functions below are:
+ − 1140
+ − 1141 GB_ALLOW_PAST_ACCESSIBLE
+ − 1142
+ − 1143 Allow positions to range over the entire buffer (BUF_BEG to BUF_Z),
+ − 1144 rather than just the accessible portion (BUF_BEGV to BUF_ZV).
+ − 1145 For strings, this flag has no effect.
+ − 1146
+ − 1147 GB_COERCE_RANGE
+ − 1148
+ − 1149 If the position is outside the allowable range, return the lower
+ − 1150 or upper bound of the range, whichever is closer to the specified
+ − 1151 position.
+ − 1152
+ − 1153 GB_NO_ERROR_IF_BAD
+ − 1154
+ − 1155 If the position is outside the allowable range, return -1.
+ − 1156
+ − 1157 GB_NEGATIVE_FROM_END
+ − 1158
+ − 1159 If a value is negative, treat it as an offset from the end.
+ − 1160 Only applies to strings.
+ − 1161
+ − 1162 The following additional flags apply only to the functions
+ − 1163 that return ranges:
+ − 1164
+ − 1165 GB_ALLOW_NIL
+ − 1166
+ − 1167 Either or both positions can be nil. If FROM is nil,
+ − 1168 FROM_OUT will contain the lower bound of the allowed range.
+ − 1169 If TO is nil, TO_OUT will contain the upper bound of the
+ − 1170 allowed range.
+ − 1171
+ − 1172 GB_CHECK_ORDER
+ − 1173
+ − 1174 FROM must contain the lower bound and TO the upper bound
+ − 1175 of the range. If the positions are reversed, an error is
+ − 1176 signalled.
+ − 1177
+ − 1178 The following is a combination flag:
+ − 1179
+ − 1180 GB_HISTORICAL_STRING_BEHAVIOR
+ − 1181
+ − 1182 Equivalent to (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL).
+ − 1183 */
+ − 1184
+ − 1185 /* Return a buffer position stored in a Lisp_Object. Full
+ − 1186 error-checking is done on the position. Flags can be specified to
+ − 1187 control the behavior of out-of-range values. The default behavior
+ − 1188 is to require that the position is within the accessible part of
+ − 1189 the buffer (BEGV and ZV), and to signal an error if the position is
+ − 1190 out of range.
+ − 1191
+ − 1192 */
+ − 1193
+ − 1194 Bufpos
+ − 1195 get_buffer_pos_char (struct buffer *b, Lisp_Object pos, unsigned int flags)
+ − 1196 {
442
+ − 1197 /* Does not GC */
428
+ − 1198 Bufpos ind;
+ − 1199 Bufpos min_allowed, max_allowed;
+ − 1200
+ − 1201 CHECK_INT_COERCE_MARKER (pos);
+ − 1202 ind = XINT (pos);
+ − 1203 min_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_BEG (b) : BUF_BEGV (b);
+ − 1204 max_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_Z (b) : BUF_ZV (b);
+ − 1205
+ − 1206 if (ind < min_allowed || ind > max_allowed)
+ − 1207 {
+ − 1208 if (flags & GB_COERCE_RANGE)
+ − 1209 ind = ind < min_allowed ? min_allowed : max_allowed;
+ − 1210 else if (flags & GB_NO_ERROR_IF_BAD)
+ − 1211 ind = -1;
+ − 1212 else
+ − 1213 {
+ − 1214 Lisp_Object buffer;
+ − 1215 XSETBUFFER (buffer, b);
+ − 1216 args_out_of_range (buffer, pos);
+ − 1217 }
+ − 1218 }
+ − 1219
+ − 1220 return ind;
+ − 1221 }
+ − 1222
+ − 1223 Bytind
+ − 1224 get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, unsigned int flags)
+ − 1225 {
+ − 1226 Bufpos bpos = get_buffer_pos_char (b, pos, flags);
+ − 1227 if (bpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
+ − 1228 return -1;
+ − 1229 return bufpos_to_bytind (b, bpos);
+ − 1230 }
+ − 1231
+ − 1232 /* Return a pair of buffer positions representing a range of text,
+ − 1233 taken from a pair of Lisp_Objects. Full error-checking is
+ − 1234 done on the positions. Flags can be specified to control the
+ − 1235 behavior of out-of-range values. The default behavior is to
+ − 1236 allow the range bounds to be specified in either order
+ − 1237 (however, FROM_OUT will always be the lower bound of the range
+ − 1238 and TO_OUT the upper bound),to require that the positions
+ − 1239 are within the accessible part of the buffer (BEGV and ZV),
+ − 1240 and to signal an error if the positions are out of range.
+ − 1241 */
+ − 1242
+ − 1243 void
+ − 1244 get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to,
+ − 1245 Bufpos *from_out, Bufpos *to_out, unsigned int flags)
+ − 1246 {
442
+ − 1247 /* Does not GC */
428
+ − 1248 Bufpos min_allowed, max_allowed;
+ − 1249
+ − 1250 min_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
+ − 1251 BUF_BEG (b) : BUF_BEGV (b);
+ − 1252 max_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
+ − 1253 BUF_Z (b) : BUF_ZV (b);
+ − 1254
+ − 1255 if (NILP (from) && (flags & GB_ALLOW_NIL))
+ − 1256 *from_out = min_allowed;
+ − 1257 else
+ − 1258 *from_out = get_buffer_pos_char (b, from, flags | GB_NO_ERROR_IF_BAD);
+ − 1259
+ − 1260 if (NILP (to) && (flags & GB_ALLOW_NIL))
+ − 1261 *to_out = max_allowed;
+ − 1262 else
+ − 1263 *to_out = get_buffer_pos_char (b, to, flags | GB_NO_ERROR_IF_BAD);
+ − 1264
+ − 1265 if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
+ − 1266 {
+ − 1267 Lisp_Object buffer;
+ − 1268 XSETBUFFER (buffer, b);
+ − 1269 args_out_of_range_3 (buffer, from, to);
+ − 1270 }
+ − 1271
+ − 1272 if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
+ − 1273 {
+ − 1274 if (flags & GB_CHECK_ORDER)
+ − 1275 signal_simple_error_2 ("start greater than end", from, to);
+ − 1276 else
+ − 1277 {
+ − 1278 Bufpos temp = *from_out;
+ − 1279 *from_out = *to_out;
+ − 1280 *to_out = temp;
+ − 1281 }
+ − 1282 }
+ − 1283 }
+ − 1284
+ − 1285 void
+ − 1286 get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to,
+ − 1287 Bytind *from_out, Bytind *to_out, unsigned int flags)
+ − 1288 {
+ − 1289 Bufpos s, e;
+ − 1290
+ − 1291 get_buffer_range_char (b, from, to, &s, &e, flags);
+ − 1292 if (s >= 0)
+ − 1293 *from_out = bufpos_to_bytind (b, s);
+ − 1294 else /* could happen with GB_NO_ERROR_IF_BAD */
+ − 1295 *from_out = -1;
+ − 1296 if (e >= 0)
+ − 1297 *to_out = bufpos_to_bytind (b, e);
+ − 1298 else
+ − 1299 *to_out = -1;
+ − 1300 }
+ − 1301
+ − 1302 static Charcount
+ − 1303 get_string_pos_char_1 (Lisp_Object string, Lisp_Object pos, unsigned int flags,
+ − 1304 Charcount known_length)
+ − 1305 {
+ − 1306 Charcount ccpos;
+ − 1307 Charcount min_allowed = 0;
+ − 1308 Charcount max_allowed = known_length;
+ − 1309
+ − 1310 /* Computation of KNOWN_LENGTH is potentially expensive so we pass
+ − 1311 it in. */
+ − 1312 CHECK_INT (pos);
+ − 1313 ccpos = XINT (pos);
+ − 1314 if (ccpos < 0 && flags & GB_NEGATIVE_FROM_END)
+ − 1315 ccpos += max_allowed;
+ − 1316
+ − 1317 if (ccpos < min_allowed || ccpos > max_allowed)
+ − 1318 {
+ − 1319 if (flags & GB_COERCE_RANGE)
+ − 1320 ccpos = ccpos < min_allowed ? min_allowed : max_allowed;
+ − 1321 else if (flags & GB_NO_ERROR_IF_BAD)
+ − 1322 ccpos = -1;
+ − 1323 else
+ − 1324 args_out_of_range (string, pos);
+ − 1325 }
+ − 1326
+ − 1327 return ccpos;
+ − 1328 }
+ − 1329
+ − 1330 Charcount
+ − 1331 get_string_pos_char (Lisp_Object string, Lisp_Object pos, unsigned int flags)
+ − 1332 {
+ − 1333 return get_string_pos_char_1 (string, pos, flags,
+ − 1334 XSTRING_CHAR_LENGTH (string));
+ − 1335 }
+ − 1336
+ − 1337 Bytecount
+ − 1338 get_string_pos_byte (Lisp_Object string, Lisp_Object pos, unsigned int flags)
+ − 1339 {
+ − 1340 Charcount ccpos = get_string_pos_char (string, pos, flags);
+ − 1341 if (ccpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
+ − 1342 return -1;
+ − 1343 return charcount_to_bytecount (XSTRING_DATA (string), ccpos);
+ − 1344 }
+ − 1345
+ − 1346 void
+ − 1347 get_string_range_char (Lisp_Object string, Lisp_Object from, Lisp_Object to,
+ − 1348 Charcount *from_out, Charcount *to_out,
+ − 1349 unsigned int flags)
+ − 1350 {
+ − 1351 Charcount min_allowed = 0;
+ − 1352 Charcount max_allowed = XSTRING_CHAR_LENGTH (string);
+ − 1353
+ − 1354 if (NILP (from) && (flags & GB_ALLOW_NIL))
+ − 1355 *from_out = min_allowed;
+ − 1356 else
+ − 1357 *from_out = get_string_pos_char_1 (string, from,
+ − 1358 flags | GB_NO_ERROR_IF_BAD,
+ − 1359 max_allowed);
+ − 1360
+ − 1361 if (NILP (to) && (flags & GB_ALLOW_NIL))
+ − 1362 *to_out = max_allowed;
+ − 1363 else
+ − 1364 *to_out = get_string_pos_char_1 (string, to,
+ − 1365 flags | GB_NO_ERROR_IF_BAD,
+ − 1366 max_allowed);
+ − 1367
+ − 1368 if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
+ − 1369 args_out_of_range_3 (string, from, to);
+ − 1370
+ − 1371 if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
+ − 1372 {
+ − 1373 if (flags & GB_CHECK_ORDER)
+ − 1374 signal_simple_error_2 ("start greater than end", from, to);
+ − 1375 else
+ − 1376 {
+ − 1377 Bufpos temp = *from_out;
+ − 1378 *from_out = *to_out;
+ − 1379 *to_out = temp;
+ − 1380 }
+ − 1381 }
+ − 1382 }
+ − 1383
+ − 1384 void
+ − 1385 get_string_range_byte (Lisp_Object string, Lisp_Object from, Lisp_Object to,
+ − 1386 Bytecount *from_out, Bytecount *to_out,
+ − 1387 unsigned int flags)
+ − 1388 {
+ − 1389 Charcount s, e;
+ − 1390
+ − 1391 get_string_range_char (string, from, to, &s, &e, flags);
+ − 1392 if (s >= 0)
+ − 1393 *from_out = charcount_to_bytecount (XSTRING_DATA (string), s);
+ − 1394 else /* could happen with GB_NO_ERROR_IF_BAD */
+ − 1395 *from_out = -1;
+ − 1396 if (e >= 0)
+ − 1397 *to_out = charcount_to_bytecount (XSTRING_DATA (string), e);
+ − 1398 else
+ − 1399 *to_out = -1;
+ − 1400
+ − 1401 }
+ − 1402
+ − 1403 Bufpos
+ − 1404 get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos,
+ − 1405 unsigned int flags)
+ − 1406 {
+ − 1407 return STRINGP (object) ?
+ − 1408 get_string_pos_char (object, pos, flags) :
+ − 1409 get_buffer_pos_char (XBUFFER (object), pos, flags);
+ − 1410 }
+ − 1411
+ − 1412 Bytind
+ − 1413 get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos,
+ − 1414 unsigned int flags)
+ − 1415 {
+ − 1416 return STRINGP (object) ?
+ − 1417 get_string_pos_byte (object, pos, flags) :
+ − 1418 get_buffer_pos_byte (XBUFFER (object), pos, flags);
+ − 1419 }
+ − 1420
+ − 1421 void
+ − 1422 get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from,
+ − 1423 Lisp_Object to, Bufpos *from_out,
+ − 1424 Bufpos *to_out, unsigned int flags)
+ − 1425 {
+ − 1426 if (STRINGP (object))
+ − 1427 get_string_range_char (object, from, to, from_out, to_out, flags);
+ − 1428 else
+ − 1429 get_buffer_range_char (XBUFFER (object), from, to, from_out, to_out, flags);
+ − 1430 }
+ − 1431
+ − 1432 void
+ − 1433 get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from,
+ − 1434 Lisp_Object to, Bytind *from_out,
+ − 1435 Bytind *to_out, unsigned int flags)
+ − 1436 {
+ − 1437 if (STRINGP (object))
+ − 1438 get_string_range_byte (object, from, to, from_out, to_out, flags);
+ − 1439 else
+ − 1440 get_buffer_range_byte (XBUFFER (object), from, to, from_out, to_out, flags);
+ − 1441 }
+ − 1442
+ − 1443 Bufpos
+ − 1444 buffer_or_string_accessible_begin_char (Lisp_Object object)
+ − 1445 {
+ − 1446 return STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object));
+ − 1447 }
+ − 1448
+ − 1449 Bufpos
+ − 1450 buffer_or_string_accessible_end_char (Lisp_Object object)
+ − 1451 {
+ − 1452 return STRINGP (object) ?
+ − 1453 XSTRING_CHAR_LENGTH (object) : BUF_ZV (XBUFFER (object));
+ − 1454 }
+ − 1455
+ − 1456 Bytind
+ − 1457 buffer_or_string_accessible_begin_byte (Lisp_Object object)
+ − 1458 {
+ − 1459 return STRINGP (object) ? 0 : BI_BUF_BEGV (XBUFFER (object));
+ − 1460 }
+ − 1461
+ − 1462 Bytind
+ − 1463 buffer_or_string_accessible_end_byte (Lisp_Object object)
+ − 1464 {
+ − 1465 return STRINGP (object) ?
+ − 1466 XSTRING_LENGTH (object) : BI_BUF_ZV (XBUFFER (object));
+ − 1467 }
+ − 1468
+ − 1469 Bufpos
+ − 1470 buffer_or_string_absolute_begin_char (Lisp_Object object)
+ − 1471 {
+ − 1472 return STRINGP (object) ? 0 : BUF_BEG (XBUFFER (object));
+ − 1473 }
+ − 1474
+ − 1475 Bufpos
+ − 1476 buffer_or_string_absolute_end_char (Lisp_Object object)
+ − 1477 {
+ − 1478 return STRINGP (object) ?
+ − 1479 XSTRING_CHAR_LENGTH (object) : BUF_Z (XBUFFER (object));
+ − 1480 }
+ − 1481
+ − 1482 Bytind
+ − 1483 buffer_or_string_absolute_begin_byte (Lisp_Object object)
+ − 1484 {
+ − 1485 return STRINGP (object) ? 0 : BI_BUF_BEG (XBUFFER (object));
+ − 1486 }
+ − 1487
+ − 1488 Bytind
+ − 1489 buffer_or_string_absolute_end_byte (Lisp_Object object)
+ − 1490 {
+ − 1491 return STRINGP (object) ?
+ − 1492 XSTRING_LENGTH (object) : BI_BUF_Z (XBUFFER (object));
+ − 1493 }
+ − 1494
+ − 1495
+ − 1496 /************************************************************************/
+ − 1497 /* point and marker adjustment */
+ − 1498 /************************************************************************/
+ − 1499
+ − 1500 /* just_set_point() is the only place `PT' is an lvalue in all of emacs.
+ − 1501 This function is called from set_buffer_point(), which is the function
+ − 1502 that the SET_PT and BUF_SET_PT macros expand into, and from the
+ − 1503 routines below that insert and delete text. (This is in cases where
+ − 1504 the point marker logically doesn't move but PT (being a byte index)
+ − 1505 needs to get adjusted.) */
+ − 1506
+ − 1507 /* Set point to a specified value. This is used only when the value
+ − 1508 of point changes due to an insert or delete; it does not represent
+ − 1509 a conceptual change in point as a marker. In particular, point is
+ − 1510 not crossing any interval boundaries, so there's no need to use the
+ − 1511 usual SET_PT macro. In fact it would be incorrect to do so, because
+ − 1512 either the old or the new value of point is out of synch with the
+ − 1513 current set of intervals. */
+ − 1514
+ − 1515 /* This gets called more than enough to make the function call
+ − 1516 overhead a significant factor so we've turned it into a macro. */
+ − 1517 #define JUST_SET_POINT(buf, bufpos, ind) \
+ − 1518 do \
+ − 1519 { \
+ − 1520 buf->bufpt = (bufpos); \
+ − 1521 buf->pt = (ind); \
+ − 1522 } while (0)
+ − 1523
+ − 1524 /* Set a buffer's point. */
+ − 1525
+ − 1526 void
+ − 1527 set_buffer_point (struct buffer *buf, Bufpos bufpos, Bytind bytpos)
+ − 1528 {
+ − 1529 assert (bytpos >= BI_BUF_BEGV (buf) && bytpos <= BI_BUF_ZV (buf));
+ − 1530 if (bytpos == BI_BUF_PT (buf))
+ − 1531 return;
+ − 1532 JUST_SET_POINT (buf, bufpos, bytpos);
+ − 1533 MARK_POINT_CHANGED;
+ − 1534 assert (MARKERP (buf->point_marker));
+ − 1535 XMARKER (buf->point_marker)->memind =
+ − 1536 bytind_to_memind (buf, bytpos);
+ − 1537
+ − 1538 /* FSF makes sure that PT is not being set within invisible text.
+ − 1539 However, this is the wrong place for that check. The check
+ − 1540 should happen only at the next redisplay. */
+ − 1541
+ − 1542 /* Some old coder said:
+ − 1543
+ − 1544 "If there were to be hooks which were run when point entered/left an
+ − 1545 extent, this would be the place to put them.
+ − 1546
+ − 1547 However, it's probably the case that such hooks should be implemented
+ − 1548 using a post-command-hook instead, to avoid running the hooks as a
+ − 1549 result of intermediate motion inside of save-excursions, for example."
+ − 1550
+ − 1551 I definitely agree with this. PT gets moved all over the place
+ − 1552 and it would be a Bad Thing for any hooks to get called, both for
+ − 1553 the reason above and because many callers are not prepared for
+ − 1554 a GC within this function. --ben
+ − 1555 */
+ − 1556 }
+ − 1557
+ − 1558 /* Do the correct marker-like adjustment on MPOS (see below). FROM, TO,
+ − 1559 and AMOUNT are as in adjust_markers(). If MPOS doesn't need to be
+ − 1560 adjusted, nothing will happen. */
+ − 1561 Memind
+ − 1562 do_marker_adjustment (Memind mpos, Memind from,
+ − 1563 Memind to, Bytecount amount)
+ − 1564 {
+ − 1565 if (amount > 0)
+ − 1566 {
+ − 1567 if (mpos > to && mpos < to + amount)
+ − 1568 mpos = to + amount;
+ − 1569 }
+ − 1570 else
+ − 1571 {
+ − 1572 if (mpos > from + amount && mpos <= from)
+ − 1573 mpos = from + amount;
+ − 1574 }
+ − 1575 if (mpos > from && mpos <= to)
+ − 1576 mpos += amount;
+ − 1577 return mpos;
+ − 1578 }
+ − 1579
+ − 1580 /* Do the following:
+ − 1581
+ − 1582 (1) Add `amount' to the position of every marker in the current buffer
+ − 1583 whose current position is between `from' (exclusive) and `to' (inclusive).
+ − 1584
+ − 1585 (2) Also, any markers past the outside of that interval, in the direction
+ − 1586 of adjustment, are first moved back to the near end of the interval
+ − 1587 and then adjusted by `amount'.
+ − 1588
+ − 1589 This function is called in two different cases: when a region of
+ − 1590 characters adjacent to the gap is moved, causing the gap to shift
+ − 1591 to the other side of the region (in this case, `from' and `to'
+ − 1592 point to the old position of the region and there should be no
+ − 1593 markers affected by (2) because they would be inside the gap),
+ − 1594 or when a region of characters adjacent to the gap is wiped out,
+ − 1595 causing the gap to increase to include the region (in this case,
+ − 1596 `from' and `to' are the same, both pointing to the boundary
+ − 1597 between the gap and the deleted region, and there are no markers
+ − 1598 affected by (1)).
+ − 1599
+ − 1600 The reason for the use of exclusive and inclusive is that markers at
+ − 1601 the gap always sit at the beginning, not at the end.
+ − 1602 */
+ − 1603
+ − 1604 static void
+ − 1605 adjust_markers (struct buffer *buf, Memind from, Memind to,
+ − 1606 Bytecount amount)
+ − 1607 {
440
+ − 1608 Lisp_Marker *m;
428
+ − 1609
+ − 1610 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
+ − 1611 m->memind = do_marker_adjustment (m->memind, from, to, amount);
+ − 1612 }
+ − 1613
+ − 1614 /* Adjust markers whose insertion-type is t
+ − 1615 for an insertion of AMOUNT characters at POS. */
+ − 1616
+ − 1617 static void
+ − 1618 adjust_markers_for_insert (struct buffer *buf, Memind ind, Bytecount amount)
+ − 1619 {
440
+ − 1620 Lisp_Marker *m;
428
+ − 1621
+ − 1622 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
+ − 1623 {
+ − 1624 if (m->insertion_type && m->memind == ind)
+ − 1625 m->memind += amount;
+ − 1626 }
+ − 1627 }
+ − 1628
+ − 1629
+ − 1630 /************************************************************************/
+ − 1631 /* Routines for dealing with the gap */
+ − 1632 /************************************************************************/
+ − 1633
+ − 1634 /* maximum amount of memory moved in a single chunk. Increasing this
+ − 1635 value improves gap-motion efficiency but decreases QUIT responsiveness
+ − 1636 time. Was 32000 but today's processors are faster and files are
+ − 1637 bigger. --ben */
+ − 1638 #define GAP_MOVE_CHUNK 300000
+ − 1639
+ − 1640 /* Move the gap to POS, which is less than the current GPT. */
+ − 1641
+ − 1642 static void
+ − 1643 gap_left (struct buffer *buf, Bytind pos)
+ − 1644 {
+ − 1645 Bufbyte *to, *from;
+ − 1646 Bytecount i;
+ − 1647 Bytind new_s1;
+ − 1648 struct buffer *mbuf;
+ − 1649 Lisp_Object bufcons;
+ − 1650
+ − 1651 from = BUF_GPT_ADDR (buf);
+ − 1652 to = from + BUF_GAP_SIZE (buf);
+ − 1653 new_s1 = BI_BUF_GPT (buf);
+ − 1654
+ − 1655 /* Now copy the characters. To move the gap down,
+ − 1656 copy characters up. */
+ − 1657
+ − 1658 while (1)
+ − 1659 {
+ − 1660 /* I gets number of characters left to copy. */
+ − 1661 i = new_s1 - pos;
+ − 1662 if (i == 0)
+ − 1663 break;
+ − 1664 /* If a quit is requested, stop copying now.
+ − 1665 Change POS to be where we have actually moved the gap to. */
+ − 1666 if (QUITP)
+ − 1667 {
+ − 1668 pos = new_s1;
+ − 1669 break;
+ − 1670 }
+ − 1671 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
+ − 1672 if (i > GAP_MOVE_CHUNK)
+ − 1673 i = GAP_MOVE_CHUNK;
440
+ − 1674
+ − 1675 if (i >= 128)
428
+ − 1676 {
+ − 1677 new_s1 -= i;
440
+ − 1678 from -= i;
+ − 1679 to -= i;
428
+ − 1680 memmove (to, from, i);
+ − 1681 }
+ − 1682 else
+ − 1683 {
+ − 1684 new_s1 -= i;
+ − 1685 while (--i >= 0)
+ − 1686 *--to = *--from;
+ − 1687 }
+ − 1688 }
+ − 1689
+ − 1690 /* Adjust markers, and buffer data structure, to put the gap at POS.
+ − 1691 POS is where the loop above stopped, which may be what was specified
+ − 1692 or may be where a quit was detected. */
+ − 1693 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1694 {
+ − 1695 adjust_markers (mbuf, pos, BI_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
+ − 1696 }
+ − 1697 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1698 {
+ − 1699 adjust_extents (make_buffer (mbuf), pos, BI_BUF_GPT (mbuf),
+ − 1700 BUF_GAP_SIZE (mbuf));
+ − 1701 }
+ − 1702 SET_BI_BUF_GPT (buf, pos);
+ − 1703 SET_GAP_SENTINEL (buf);
+ − 1704 #ifdef ERROR_CHECK_EXTENTS
+ − 1705 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1706 {
+ − 1707 sledgehammer_extent_check (make_buffer (mbuf));
+ − 1708 }
+ − 1709 #endif
+ − 1710 QUIT;
+ − 1711 }
+ − 1712
+ − 1713 static void
+ − 1714 gap_right (struct buffer *buf, Bytind pos)
+ − 1715 {
+ − 1716 Bufbyte *to, *from;
+ − 1717 Bytecount i;
+ − 1718 Bytind new_s1;
+ − 1719 struct buffer *mbuf;
+ − 1720 Lisp_Object bufcons;
+ − 1721
+ − 1722 to = BUF_GPT_ADDR (buf);
+ − 1723 from = to + BUF_GAP_SIZE (buf);
+ − 1724 new_s1 = BI_BUF_GPT (buf);
+ − 1725
+ − 1726 /* Now copy the characters. To move the gap up,
+ − 1727 copy characters down. */
+ − 1728
+ − 1729 while (1)
+ − 1730 {
+ − 1731 /* I gets number of characters left to copy. */
+ − 1732 i = pos - new_s1;
+ − 1733 if (i == 0)
+ − 1734 break;
+ − 1735 /* If a quit is requested, stop copying now.
+ − 1736 Change POS to be where we have actually moved the gap to. */
+ − 1737 if (QUITP)
+ − 1738 {
+ − 1739 pos = new_s1;
+ − 1740 break;
+ − 1741 }
+ − 1742 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
+ − 1743 if (i > GAP_MOVE_CHUNK)
+ − 1744 i = GAP_MOVE_CHUNK;
440
+ − 1745
+ − 1746 if (i >= 128)
428
+ − 1747 {
+ − 1748 new_s1 += i;
+ − 1749 memmove (to, from, i);
440
+ − 1750 from += i;
+ − 1751 to += i;
428
+ − 1752 }
+ − 1753 else
+ − 1754 {
+ − 1755 new_s1 += i;
+ − 1756 while (--i >= 0)
+ − 1757 *to++ = *from++;
+ − 1758 }
+ − 1759 }
+ − 1760
+ − 1761 {
+ − 1762 int gsize = BUF_GAP_SIZE (buf);
+ − 1763 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1764 {
+ − 1765 adjust_markers (mbuf, BI_BUF_GPT (mbuf) + gsize, pos + gsize, - gsize);
+ − 1766 }
+ − 1767 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1768 {
+ − 1769 adjust_extents (make_buffer (mbuf), BI_BUF_GPT (mbuf) + gsize,
+ − 1770 pos + gsize, - gsize);
+ − 1771 }
+ − 1772 SET_BI_BUF_GPT (buf, pos);
+ − 1773 SET_GAP_SENTINEL (buf);
+ − 1774 #ifdef ERROR_CHECK_EXTENTS
+ − 1775 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1776 {
+ − 1777 sledgehammer_extent_check (make_buffer (mbuf));
+ − 1778 }
+ − 1779 #endif
+ − 1780 }
+ − 1781 if (pos == BI_BUF_Z (buf))
+ − 1782 {
+ − 1783 /* merge gap with end gap */
+ − 1784
+ − 1785 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + BUF_END_GAP_SIZE (buf));
+ − 1786 SET_BUF_END_GAP_SIZE (buf, 0);
+ − 1787 SET_END_SENTINEL (buf);
+ − 1788 }
+ − 1789
+ − 1790 QUIT;
+ − 1791 }
+ − 1792
+ − 1793 /* Move gap to position `pos'.
+ − 1794 Note that this can quit! */
+ − 1795
+ − 1796 static void
+ − 1797 move_gap (struct buffer *buf, Bytind pos)
+ − 1798 {
+ − 1799 if (! BUF_BEG_ADDR (buf))
+ − 1800 abort ();
+ − 1801 if (pos < BI_BUF_GPT (buf))
+ − 1802 gap_left (buf, pos);
+ − 1803 else if (pos > BI_BUF_GPT (buf))
+ − 1804 gap_right (buf, pos);
+ − 1805 }
+ − 1806
+ − 1807 /* Merge the end gap into the gap */
+ − 1808
+ − 1809 static void
+ − 1810 merge_gap_with_end_gap (struct buffer *buf)
+ − 1811 {
+ − 1812 Lisp_Object tem;
+ − 1813 Bytind real_gap_loc;
+ − 1814 Bytecount old_gap_size;
+ − 1815 Bytecount increment;
+ − 1816
+ − 1817 increment = BUF_END_GAP_SIZE (buf);
+ − 1818 SET_BUF_END_GAP_SIZE (buf, 0);
+ − 1819
+ − 1820 if (increment > 0)
+ − 1821 {
+ − 1822 /* Prevent quitting in move_gap. */
+ − 1823 tem = Vinhibit_quit;
+ − 1824 Vinhibit_quit = Qt;
+ − 1825
+ − 1826 real_gap_loc = BI_BUF_GPT (buf);
+ − 1827 old_gap_size = BUF_GAP_SIZE (buf);
+ − 1828
+ − 1829 /* Pretend the end gap is the gap */
+ − 1830 SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
+ − 1831 SET_BUF_GAP_SIZE (buf, increment);
+ − 1832
+ − 1833 /* Move the new gap down to be consecutive with the end of the old one.
+ − 1834 This adjusts the markers properly too. */
+ − 1835 gap_left (buf, real_gap_loc + old_gap_size);
+ − 1836
+ − 1837 /* Now combine the two into one large gap. */
+ − 1838 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
+ − 1839 SET_BI_BUF_GPT (buf, real_gap_loc);
+ − 1840 SET_GAP_SENTINEL (buf);
+ − 1841
+ − 1842 /* We changed the total size of the buffer (including gap),
+ − 1843 so we need to fix up the end sentinel. */
+ − 1844 SET_END_SENTINEL (buf);
+ − 1845
+ − 1846 Vinhibit_quit = tem;
+ − 1847 }
+ − 1848 }
+ − 1849
+ − 1850 /* Make the gap INCREMENT bytes longer. */
+ − 1851
+ − 1852 static void
+ − 1853 make_gap (struct buffer *buf, Bytecount increment)
+ − 1854 {
+ − 1855 Bufbyte *result;
+ − 1856 Lisp_Object tem;
+ − 1857 Bytind real_gap_loc;
+ − 1858 Bytecount old_gap_size;
+ − 1859
+ − 1860 /* If we have to get more space, get enough to last a while. We use
+ − 1861 a geometric progression that saves on realloc space. */
+ − 1862 increment += 2000 + ((BI_BUF_Z (buf) - BI_BUF_BEG (buf)) / 8);
+ − 1863
+ − 1864 if (increment > BUF_END_GAP_SIZE (buf))
+ − 1865 {
+ − 1866 /* Don't allow a buffer size that won't fit in an int
+ − 1867 even if it will fit in a Lisp integer.
+ − 1868 That won't work because so many places use `int'. */
+ − 1869
+ − 1870 if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment
+ − 1871 > EMACS_INT_MAX)
+ − 1872 error ("Maximum buffer size exceeded");
+ − 1873
+ − 1874 result = BUFFER_REALLOC (buf->text->beg,
+ − 1875 BI_BUF_Z (buf) - BI_BUF_BEG (buf) +
+ − 1876 BUF_GAP_SIZE (buf) + increment +
+ − 1877 BUF_END_SENTINEL_SIZE);
+ − 1878 if (result == 0)
+ − 1879 memory_full ();
+ − 1880
+ − 1881 SET_BUF_BEG_ADDR (buf, result);
+ − 1882 }
+ − 1883 else
+ − 1884 increment = BUF_END_GAP_SIZE (buf);
+ − 1885
+ − 1886 /* Prevent quitting in move_gap. */
+ − 1887 tem = Vinhibit_quit;
+ − 1888 Vinhibit_quit = Qt;
+ − 1889
+ − 1890 real_gap_loc = BI_BUF_GPT (buf);
+ − 1891 old_gap_size = BUF_GAP_SIZE (buf);
+ − 1892
+ − 1893 /* Call the newly allocated space a gap at the end of the whole space. */
+ − 1894 SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
+ − 1895 SET_BUF_GAP_SIZE (buf, increment);
+ − 1896
+ − 1897 SET_BUF_END_GAP_SIZE (buf, 0);
+ − 1898
+ − 1899 /* Move the new gap down to be consecutive with the end of the old one.
+ − 1900 This adjusts the markers properly too. */
+ − 1901 gap_left (buf, real_gap_loc + old_gap_size);
+ − 1902
+ − 1903 /* Now combine the two into one large gap. */
+ − 1904 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
+ − 1905 SET_BI_BUF_GPT (buf, real_gap_loc);
+ − 1906 SET_GAP_SENTINEL (buf);
+ − 1907
+ − 1908 /* We changed the total size of the buffer (including gap),
+ − 1909 so we need to fix up the end sentinel. */
+ − 1910 SET_END_SENTINEL (buf);
+ − 1911
+ − 1912 Vinhibit_quit = tem;
+ − 1913 }
+ − 1914
+ − 1915
+ − 1916 /************************************************************************/
+ − 1917 /* Before/after-change processing */
+ − 1918 /************************************************************************/
+ − 1919
+ − 1920 /* Those magic changes ... */
+ − 1921
+ − 1922 static void
+ − 1923 buffer_signal_changed_region (struct buffer *buf, Bufpos start,
+ − 1924 Bufpos end)
+ − 1925 {
+ − 1926 /* The changed region is recorded as the number of unchanged
+ − 1927 characters from the beginning and from the end of the
+ − 1928 buffer. This obviates much of the need of shifting the
+ − 1929 region around to compensate for insertions and deletions.
+ − 1930 */
+ − 1931 if (buf->changes->begin_unchanged < 0 ||
+ − 1932 buf->changes->begin_unchanged > start - BUF_BEG (buf))
+ − 1933 buf->changes->begin_unchanged = start - BUF_BEG (buf);
+ − 1934 if (buf->changes->end_unchanged < 0 ||
+ − 1935 buf->changes->end_unchanged > BUF_Z (buf) - end)
+ − 1936 buf->changes->end_unchanged = BUF_Z (buf) - end;
+ − 1937 }
+ − 1938
+ − 1939 void
+ − 1940 buffer_extent_signal_changed_region (struct buffer *buf, Bufpos start,
+ − 1941 Bufpos end)
+ − 1942 {
+ − 1943 if (buf->changes->begin_extent_unchanged < 0 ||
+ − 1944 buf->changes->begin_extent_unchanged > start - BUF_BEG (buf))
+ − 1945 buf->changes->begin_extent_unchanged = start - BUF_BEG (buf);
+ − 1946 if (buf->changes->end_extent_unchanged < 0 ||
+ − 1947 buf->changes->end_extent_unchanged > BUF_Z (buf) - end)
+ − 1948 buf->changes->end_extent_unchanged = BUF_Z (buf) - end;
+ − 1949 }
+ − 1950
+ − 1951 void
+ − 1952 buffer_reset_changes (struct buffer *buf)
+ − 1953 {
+ − 1954 buf->changes->begin_unchanged = -1;
+ − 1955 buf->changes->end_unchanged = -1;
+ − 1956 buf->changes->begin_extent_unchanged = -1;
+ − 1957 buf->changes->end_extent_unchanged = -1;
+ − 1958 buf->changes->newline_was_deleted = 0;
+ − 1959 }
+ − 1960
+ − 1961 static void
+ − 1962 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
+ − 1963 Bufpos new_end);
+ − 1964
+ − 1965
+ − 1966 /* Call the after-change-functions according to the changes made so far
+ − 1967 and treat all further changes as single until the outermost
+ − 1968 multiple change exits. This is called when the outermost multiple
+ − 1969 change exits and when someone is trying to make a change that violates
+ − 1970 the constraints specified in begin_multiple_change(), typically
+ − 1971 when nested multiple-change sessions occur. (There are smarter ways of
+ − 1972 dealing with nested multiple changes, but these rarely occur so there's
+ − 1973 probably no point in it.) */
+ − 1974
+ − 1975 /* #### This needs to keep track of what actually changed and only
+ − 1976 call the after-change functions on that region. */
+ − 1977
+ − 1978 static void
+ − 1979 cancel_multiple_change (struct buffer *buf)
+ − 1980 {
+ − 1981 /* This function can GC */
+ − 1982 /* Call the after-change-functions except when they've already been
+ − 1983 called or when there were no changes made to the buffer at all. */
+ − 1984 if (buf->text->changes->mc_begin != 0 &&
+ − 1985 buf->text->changes->mc_begin_signaled)
+ − 1986 {
+ − 1987 Bufpos real_mc_begin = buf->text->changes->mc_begin;
+ − 1988 buf->text->changes->mc_begin = 0;
+ − 1989
+ − 1990 signal_after_change (buf, real_mc_begin, buf->text->changes->mc_orig_end,
+ − 1991 buf->text->changes->mc_new_end);
+ − 1992 }
+ − 1993 else
+ − 1994 {
+ − 1995 buf->text->changes->mc_begin = 0;
+ − 1996 }
+ − 1997 }
+ − 1998
+ − 1999 /* this is an unwind_protect, to ensure that the after-change-functions
+ − 2000 get called even in a non-local exit. */
+ − 2001
+ − 2002 static Lisp_Object
+ − 2003 multiple_change_finish_up (Lisp_Object buffer)
+ − 2004 {
+ − 2005 struct buffer *buf = XBUFFER (buffer);
+ − 2006
+ − 2007 /* #### I don't know whether or not it should even be possible to
+ − 2008 get here with a dead buffer (though given how it is called I can
+ − 2009 see how it might be). In any case, there isn't time before 19.14
+ − 2010 to find out. */
+ − 2011 if (!BUFFER_LIVE_P (buf))
+ − 2012 return Qnil;
+ − 2013
+ − 2014 /* This function can GC */
+ − 2015 buf->text->changes->in_multiple_change = 0; /* do this first so that
+ − 2016 errors in the after-change
+ − 2017 functions don't mess things
+ − 2018 up. */
+ − 2019 cancel_multiple_change (buf);
+ − 2020 return Qnil;
+ − 2021 }
+ − 2022
+ − 2023 /* Call this function when you're about to make a number of buffer changes
+ − 2024 that should be considered a single change. (e.g. `replace-match' calls
+ − 2025 this.) You need to specify the START and END of the region that is
+ − 2026 going to be changed so that the before-change-functions are called
+ − 2027 with the correct arguments. The after-change region is calculated
+ − 2028 automatically, however, and if changes somehow or other happen outside
+ − 2029 of the specified region, that will also be handled correctly.
+ − 2030
+ − 2031 begin_multiple_change() returns a number (actually a specpdl depth)
438
+ − 2032 that you must pass to end_multiple_change() when you are done.
+ − 2033
+ − 2034 FSF Emacs 20 implements a similar feature, accessible from Lisp
+ − 2035 through a `combine-after-change-calls' special form, which is
+ − 2036 essentially equivalent to this function. We should consider
+ − 2037 whether we want to introduce a similar Lisp form. */
428
+ − 2038
+ − 2039 int
+ − 2040 begin_multiple_change (struct buffer *buf, Bufpos start, Bufpos end)
+ − 2041 {
+ − 2042 /* This function can GC */
+ − 2043 int count = -1;
+ − 2044 if (buf->text->changes->in_multiple_change)
+ − 2045 {
+ − 2046 if (buf->text->changes->mc_begin != 0 &&
+ − 2047 (start < buf->text->changes->mc_begin ||
+ − 2048 end > buf->text->changes->mc_new_end))
+ − 2049 cancel_multiple_change (buf);
+ − 2050 }
+ − 2051 else
+ − 2052 {
+ − 2053 Lisp_Object buffer;
+ − 2054
+ − 2055 buf->text->changes->mc_begin = start;
+ − 2056 buf->text->changes->mc_orig_end = buf->text->changes->mc_new_end = end;
+ − 2057 buf->text->changes->mc_begin_signaled = 0;
+ − 2058 count = specpdl_depth ();
+ − 2059 XSETBUFFER (buffer, buf);
+ − 2060 record_unwind_protect (multiple_change_finish_up, buffer);
+ − 2061 }
+ − 2062 buf->text->changes->in_multiple_change++;
+ − 2063 /* We don't call before-change-functions until signal_before_change()
+ − 2064 is called, in case there is a read-only or other error. */
+ − 2065 return count;
+ − 2066 }
+ − 2067
+ − 2068 void
+ − 2069 end_multiple_change (struct buffer *buf, int count)
+ − 2070 {
+ − 2071 assert (buf->text->changes->in_multiple_change > 0);
+ − 2072 buf->text->changes->in_multiple_change--;
+ − 2073 if (!buf->text->changes->in_multiple_change)
+ − 2074 unbind_to (count, Qnil);
+ − 2075 }
+ − 2076
+ − 2077 static int inside_change_hook;
+ − 2078
+ − 2079 static Lisp_Object
+ − 2080 change_function_restore (Lisp_Object buffer)
+ − 2081 {
+ − 2082 /* We should first reset the variable and then change the buffer,
+ − 2083 because Fset_buffer() can throw. */
+ − 2084 inside_change_hook = 0;
438
+ − 2085 if (XBUFFER (buffer) != current_buffer)
+ − 2086 Fset_buffer (buffer);
428
+ − 2087 return Qnil;
+ − 2088 }
+ − 2089
+ − 2090 static int in_first_change;
+ − 2091
+ − 2092 static Lisp_Object
+ − 2093 first_change_hook_restore (Lisp_Object buffer)
+ − 2094 {
+ − 2095 in_first_change = 0;
+ − 2096 Fset_buffer (buffer);
+ − 2097 return Qnil;
+ − 2098 }
+ − 2099
+ − 2100 /* Signal an initial modification to the buffer. */
+ − 2101
+ − 2102 static void
+ − 2103 signal_first_change (struct buffer *buf)
+ − 2104 {
+ − 2105 /* This function can GC */
+ − 2106 Lisp_Object buffer;
+ − 2107 XSETBUFFER (buffer, current_buffer);
+ − 2108
+ − 2109 if (!in_first_change)
+ − 2110 {
+ − 2111 if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
+ − 2112 {
+ − 2113 int speccount = specpdl_depth ();
+ − 2114 record_unwind_protect (first_change_hook_restore, buffer);
+ − 2115 set_buffer_internal (buf);
+ − 2116 in_first_change = 1;
+ − 2117 run_hook (Qfirst_change_hook);
+ − 2118 unbind_to (speccount, Qnil);
+ − 2119 }
+ − 2120 }
+ − 2121 }
+ − 2122
+ − 2123 /* Signal a change to the buffer immediately before it happens.
+ − 2124 START and END are the bounds of the text to be changed. */
+ − 2125
+ − 2126 static void
+ − 2127 signal_before_change (struct buffer *buf, Bufpos start, Bufpos end)
+ − 2128 {
+ − 2129 /* This function can GC */
+ − 2130 struct buffer *mbuf;
+ − 2131 Lisp_Object bufcons;
+ − 2132
+ − 2133 if (!inside_change_hook)
+ − 2134 {
+ − 2135 Lisp_Object buffer;
438
+ − 2136 int speccount;
428
+ − 2137
+ − 2138 /* Are we in a multiple-change session? */
+ − 2139 if (buf->text->changes->in_multiple_change &&
+ − 2140 buf->text->changes->mc_begin != 0)
+ − 2141 {
+ − 2142 /* If we're violating the constraints of the session,
+ − 2143 call the after-change-functions as necessary for the
+ − 2144 changes already made and treat further changes as
+ − 2145 single. */
+ − 2146 if (start < buf->text->changes->mc_begin ||
+ − 2147 end > buf->text->changes->mc_new_end)
+ − 2148 cancel_multiple_change (buf);
+ − 2149 /* Do nothing if this is not the first change in the session. */
+ − 2150 else if (buf->text->changes->mc_begin_signaled)
+ − 2151 return;
+ − 2152 else
+ − 2153 {
+ − 2154 /* First time through; call the before-change-functions
+ − 2155 specifying the entire region to be changed. (Note that
+ − 2156 we didn't call before-change-functions in
+ − 2157 begin_multiple_change() because the buffer might be
+ − 2158 read-only, etc.) */
+ − 2159 start = buf->text->changes->mc_begin;
+ − 2160 end = buf->text->changes->mc_new_end;
+ − 2161 }
+ − 2162 }
+ − 2163
+ − 2164 /* If buffer is unmodified, run a special hook for that case. */
+ − 2165 if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
+ − 2166 {
+ − 2167 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2168 {
+ − 2169 signal_first_change (mbuf);
+ − 2170 }
+ − 2171 }
+ − 2172
+ − 2173 /* Now in any case run the before-change-functions if any. */
438
+ − 2174 speccount = specpdl_depth ();
+ − 2175 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ − 2176 inside_change_hook = 1;
428
+ − 2177
+ − 2178 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2179 {
+ − 2180 XSETBUFFER (buffer, mbuf);
+ − 2181 if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
+ − 2182 /* Obsolete, for compatibility */
+ − 2183 || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
+ − 2184 {
+ − 2185 set_buffer_internal (buf);
+ − 2186 va_run_hook_with_args (Qbefore_change_functions, 2,
+ − 2187 make_int (start), make_int (end));
+ − 2188 /* Obsolete, for compatibility */
+ − 2189 va_run_hook_with_args (Qbefore_change_function, 2,
+ − 2190 make_int (start), make_int (end));
+ − 2191 }
+ − 2192 }
+ − 2193
438
+ − 2194 /* Make sure endpoints remain valid. before-change-functions
+ − 2195 might have modified the buffer. */
+ − 2196 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
+ − 2197 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
+ − 2198 if (end < BUF_BEGV (buf)) end = BUF_BEGV (buf);
+ − 2199 if (end > BUF_ZV (buf)) end = BUF_ZV (buf);
+ − 2200
428
+ − 2201 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2202 {
+ − 2203 XSETBUFFER (buffer, mbuf);
438
+ − 2204 report_extent_modification (buffer, start, end, 0);
428
+ − 2205 }
438
+ − 2206 unbind_to (speccount, Qnil);
428
+ − 2207
+ − 2208 /* Only now do we indicate that the before-change-functions have
+ − 2209 been called, in case some function throws out. */
+ − 2210 buf->text->changes->mc_begin_signaled = 1;
+ − 2211 }
+ − 2212 }
+ − 2213
+ − 2214 /* Signal a change immediately after it happens.
+ − 2215 START is the bufpos of the start of the changed text.
+ − 2216 ORIG_END is the bufpos of the end of the before-changed text.
+ − 2217 NEW_END is the bufpos of the end of the after-changed text.
+ − 2218 */
+ − 2219
+ − 2220 static void
+ − 2221 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
+ − 2222 Bufpos new_end)
+ − 2223 {
+ − 2224 /* This function can GC */
+ − 2225 struct buffer *mbuf;
+ − 2226 Lisp_Object bufcons;
+ − 2227
+ − 2228 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2229 {
+ − 2230 /* always do this. */
+ − 2231 buffer_signal_changed_region (mbuf, start, new_end);
+ − 2232 }
+ − 2233 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2234 {
+ − 2235 /* #### This seems inefficient. Wouldn't it be better to just
+ − 2236 keep one cache per base buffer? */
+ − 2237 font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
+ − 2238 }
+ − 2239
+ − 2240 if (!inside_change_hook)
+ − 2241 {
+ − 2242 Lisp_Object buffer;
438
+ − 2243 int speccount;
428
+ − 2244
+ − 2245 if (buf->text->changes->in_multiple_change &&
+ − 2246 buf->text->changes->mc_begin != 0)
+ − 2247 {
+ − 2248 assert (start >= buf->text->changes->mc_begin &&
+ − 2249 start <= buf->text->changes->mc_new_end);
+ − 2250 assert (orig_end >= buf->text->changes->mc_begin &&
+ − 2251 orig_end <= buf->text->changes->mc_new_end);
+ − 2252 buf->text->changes->mc_new_end += new_end - orig_end;
+ − 2253 return; /* after-change-functions signalled when all changes done */
+ − 2254 }
+ − 2255
438
+ − 2256 speccount = specpdl_depth ();
+ − 2257 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ − 2258 inside_change_hook = 1;
428
+ − 2259 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2260 {
+ − 2261 XSETBUFFER (buffer, mbuf);
+ − 2262
+ − 2263 if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
+ − 2264 /* Obsolete, for compatibility */
+ − 2265 || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
+ − 2266 {
+ − 2267 set_buffer_internal (buf);
+ − 2268 /* The actual after-change functions take slightly
+ − 2269 different arguments than what we were passed. */
+ − 2270 va_run_hook_with_args (Qafter_change_functions, 3,
+ − 2271 make_int (start), make_int (new_end),
+ − 2272 make_int (orig_end - start));
+ − 2273 /* Obsolete, for compatibility */
+ − 2274 va_run_hook_with_args (Qafter_change_function, 3,
+ − 2275 make_int (start), make_int (new_end),
+ − 2276 make_int (orig_end - start));
+ − 2277 }
+ − 2278 }
+ − 2279
438
+ − 2280 /* Make sure endpoints remain valid. after-change-functions
+ − 2281 might have modified the buffer. */
+ − 2282 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
+ − 2283 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
+ − 2284 if (new_end < BUF_BEGV (buf)) new_end = BUF_BEGV (buf);
+ − 2285 if (new_end > BUF_ZV (buf)) new_end = BUF_ZV (buf);
+ − 2286 if (orig_end < BUF_BEGV (buf)) orig_end = BUF_BEGV (buf);
+ − 2287 if (orig_end > BUF_ZV (buf)) orig_end = BUF_ZV (buf);
+ − 2288
428
+ − 2289 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2290 {
+ − 2291 XSETBUFFER (buffer, mbuf);
438
+ − 2292 report_extent_modification (buffer, start, new_end, 1);
428
+ − 2293 }
438
+ − 2294 unbind_to (speccount, Qnil); /* sets inside_change_hook back to 0 */
428
+ − 2295 }
+ − 2296 }
+ − 2297
+ − 2298 /* Call this if you're about to change the region of BUFFER from START
+ − 2299 to END. This checks the read-only properties of the region, calls
+ − 2300 the necessary modification hooks, and warns the next redisplay that
+ − 2301 it should pay attention to that area. */
+ − 2302
+ − 2303 static void
+ − 2304 prepare_to_modify_buffer (struct buffer *buf, Bufpos start, Bufpos end,
+ − 2305 int lockit)
+ − 2306 {
+ − 2307 /* This function can GC */
+ − 2308 /* dmoore - This function can also kill the buffer buf, the current
+ − 2309 buffer, and do anything it pleases. So if you call it, be
+ − 2310 careful. */
+ − 2311 struct buffer *mbuf;
+ − 2312 Lisp_Object buffer, bufcons;
+ − 2313 struct gcpro gcpro1;
+ − 2314
+ − 2315 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2316 {
+ − 2317 barf_if_buffer_read_only (mbuf, start, end);
+ − 2318 }
+ − 2319
+ − 2320 /* if this is the first modification, see about locking the buffer's
+ − 2321 file */
+ − 2322 XSETBUFFER (buffer, buf);
+ − 2323 GCPRO1 (buffer);
+ − 2324 if (!NILP (buf->filename) && lockit &&
+ − 2325 BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
+ − 2326 {
+ − 2327 /* At least warn if this file has changed on disk since it was visited.*/
+ − 2328 if (NILP (Fverify_visited_file_modtime (buffer))
+ − 2329 && !NILP (Ffile_exists_p (buf->filename)))
+ − 2330 call1_in_buffer (buf, intern ("ask-user-about-supersession-threat"),
+ − 2331 buf->filename);
460
+ − 2332 #ifdef CLASH_DETECTION
+ − 2333 if (!NILP (buf->file_truename))
+ − 2334 /* Make binding buffer-file-name to nil effective. */
+ − 2335 lock_file (buf->file_truename);
428
+ − 2336 #endif /* not CLASH_DETECTION */
+ − 2337 }
+ − 2338 UNGCPRO;
+ − 2339
+ − 2340 /* #### dmoore - is this reasonable in case of buf being killed above? */
+ − 2341 if (!BUFFER_LIVE_P (buf))
+ − 2342 return;
+ − 2343
+ − 2344 signal_before_change (buf, start, end);
+ − 2345
+ − 2346 #ifdef REGION_CACHE_NEEDS_WORK
+ − 2347 if (buf->newline_cache)
+ − 2348 invalidate_region_cache (buf,
+ − 2349 buf->newline_cache,
+ − 2350 start - BUF_BEG (buf), BUF_Z (buf) - end);
+ − 2351 if (buf->width_run_cache)
+ − 2352 invalidate_region_cache (buf,
+ − 2353 buf->width_run_cache,
+ − 2354 start - BUF_BEG (buf), BUF_Z (buf) - end);
+ − 2355 #endif
+ − 2356
+ − 2357 #if 0 /* FSFmacs */
+ − 2358 Vdeactivate_mark = Qt;
+ − 2359 #endif
+ − 2360
+ − 2361 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2362 {
+ − 2363 mbuf->point_before_scroll = Qnil;
+ − 2364 }
+ − 2365 }
+ − 2366
+ − 2367
+ − 2368 /************************************************************************/
+ − 2369 /* Insertion of strings */
+ − 2370 /************************************************************************/
+ − 2371
+ − 2372 void
442
+ − 2373 fixup_internal_substring (const Bufbyte *nonreloc, Lisp_Object reloc,
428
+ − 2374 Bytecount offset, Bytecount *len)
+ − 2375 {
+ − 2376 assert ((nonreloc && NILP (reloc)) || (!nonreloc && STRINGP (reloc)));
+ − 2377
+ − 2378 if (*len < 0)
+ − 2379 {
+ − 2380 if (nonreloc)
442
+ − 2381 *len = strlen ((const char *) nonreloc) - offset;
428
+ − 2382 else
+ − 2383 *len = XSTRING_LENGTH (reloc) - offset;
+ − 2384 }
+ − 2385 #ifdef ERROR_CHECK_BUFPOS
+ − 2386 assert (*len >= 0);
+ − 2387 if (STRINGP (reloc))
+ − 2388 {
+ − 2389 assert (offset >= 0 && offset <= XSTRING_LENGTH (reloc));
+ − 2390 assert (offset + *len <= XSTRING_LENGTH (reloc));
+ − 2391 }
+ − 2392 #endif
+ − 2393 }
+ − 2394
+ − 2395 /* Insert a string into BUF at Bufpos POS. The string data comes
+ − 2396 from one of two sources: constant, non-relocatable data (specified
+ − 2397 in NONRELOC), or a Lisp string object (specified in RELOC), which
+ − 2398 is relocatable and may have extent data that needs to be copied
+ − 2399 into the buffer. OFFSET and LENGTH specify the substring of the
+ − 2400 data that is actually to be inserted. As a special case, if POS
+ − 2401 is -1, insert the string at point and move point to the end of the
+ − 2402 string.
+ − 2403
+ − 2404 Normally, markers at the insertion point end up before the
+ − 2405 inserted string. If INSDEL_BEFORE_MARKERS is set in flags, however,
+ − 2406 they end up after the string.
+ − 2407
+ − 2408 INSDEL_NO_LOCKING is kludgy and is used when insert-file-contents is
+ − 2409 visiting a new file; it inhibits the locking checks normally done
+ − 2410 before modifying a buffer. Similar checks were already done
+ − 2411 in the higher-level Lisp functions calling insert-file-contents. */
+ − 2412
+ − 2413 Charcount
+ − 2414 buffer_insert_string_1 (struct buffer *buf, Bufpos pos,
442
+ − 2415 const Bufbyte *nonreloc, Lisp_Object reloc,
428
+ − 2416 Bytecount offset, Bytecount length,
+ − 2417 int flags)
+ − 2418 {
+ − 2419 /* This function can GC */
+ − 2420 struct gcpro gcpro1;
+ − 2421 Bytind ind;
+ − 2422 Charcount cclen;
+ − 2423 int move_point = 0;
+ − 2424 struct buffer *mbuf;
+ − 2425 Lisp_Object bufcons;
+ − 2426
+ − 2427 /* Defensive steps just in case a buffer gets deleted and a calling
+ − 2428 function doesn't notice it. */
+ − 2429 if (!BUFFER_LIVE_P (buf))
+ − 2430 return 0;
+ − 2431
+ − 2432 fixup_internal_substring (nonreloc, reloc, offset, &length);
+ − 2433
+ − 2434 if (pos == -1)
+ − 2435 {
+ − 2436 pos = BUF_PT (buf);
+ − 2437 move_point = 1;
+ − 2438 }
+ − 2439
+ − 2440 #ifdef I18N3
+ − 2441 /* #### See the comment in print_internal(). If this buffer is marked
+ − 2442 as translatable, then Fgettext() should be called on obj if it
+ − 2443 is a string. */
+ − 2444 #endif
+ − 2445
+ − 2446 /* Make sure that point-max won't exceed the size of an emacs int. */
+ − 2447 if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
+ − 2448 error ("Maximum buffer size exceeded");
+ − 2449
+ − 2450 /* theoretically not necessary -- caller should GCPRO.
+ − 2451 #### buffer_insert_from_buffer_1() doesn't! */
+ − 2452 GCPRO1 (reloc);
+ − 2453
+ − 2454 prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
+ − 2455
+ − 2456 /* Defensive steps in case the before-change-functions fuck around */
+ − 2457 if (!BUFFER_LIVE_P (buf))
+ − 2458 {
+ − 2459 UNGCPRO;
+ − 2460 /* Bad bad pre-change function. */
+ − 2461 return 0;
+ − 2462 }
+ − 2463
+ − 2464 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 2465 modified the buffer. */
+ − 2466 if (pos < BUF_BEGV (buf))
+ − 2467 pos = BUF_BEGV (buf);
+ − 2468 if (pos > BUF_ZV (buf))
+ − 2469 pos = BUF_ZV (buf);
+ − 2470
+ − 2471 /* string may have been relocated up to this point */
+ − 2472 if (STRINGP (reloc))
+ − 2473 nonreloc = XSTRING_DATA (reloc);
+ − 2474
+ − 2475 ind = bufpos_to_bytind (buf, pos);
+ − 2476 cclen = bytecount_to_charcount (nonreloc + offset, length);
+ − 2477
+ − 2478 if (ind != BI_BUF_GPT (buf))
+ − 2479 /* #### if debug-on-quit is invoked and the user changes the
+ − 2480 buffer, bad things can happen. This is a rampant problem
+ − 2481 in Emacs. */
+ − 2482 move_gap (buf, ind); /* may QUIT */
+ − 2483 if (! GAP_CAN_HOLD_SIZE_P (buf, length))
+ − 2484 {
+ − 2485 if (BUF_END_GAP_SIZE (buf) >= length)
+ − 2486 merge_gap_with_end_gap (buf);
+ − 2487 else
+ − 2488 make_gap (buf, length - BUF_GAP_SIZE (buf));
+ − 2489 }
+ − 2490
+ − 2491 insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
+ − 2492
+ − 2493 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2494 {
+ − 2495 record_insert (mbuf, pos, cclen);
+ − 2496 }
+ − 2497
+ − 2498 BUF_MODIFF (buf)++;
+ − 2499 MARK_BUFFERS_CHANGED;
+ − 2500
+ − 2501 /* string may have been relocated up to this point */
+ − 2502 if (STRINGP (reloc))
+ − 2503 nonreloc = XSTRING_DATA (reloc);
+ − 2504
+ − 2505 memcpy (BUF_GPT_ADDR (buf), nonreloc + offset, length);
+ − 2506
+ − 2507 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length);
+ − 2508 SET_BI_BUF_GPT (buf, BI_BUF_GPT (buf) + length);
+ − 2509 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2510 {
+ − 2511 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen, BI_BUF_ZV (mbuf) + length);
+ − 2512 }
+ − 2513 SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BI_BUF_Z (buf) + length);
+ − 2514 SET_GAP_SENTINEL (buf);
+ − 2515
+ − 2516 #ifdef MULE
+ − 2517 buffer_mule_signal_inserted_region (buf, pos, length, cclen);
+ − 2518 #endif
+ − 2519
+ − 2520 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2521 {
+ − 2522 process_extents_for_insertion (make_buffer (mbuf), ind, length);
+ − 2523 }
+ − 2524
+ − 2525 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2526 {
+ − 2527 /* We know the gap is at IND so the cast is OK. */
+ − 2528 adjust_markers_for_insert (mbuf, (Memind) ind, length);
+ − 2529 }
+ − 2530
+ − 2531 /* Point logically doesn't move, but may need to be adjusted because
+ − 2532 it's a byte index. point-marker doesn't change because it's a
+ − 2533 memory index. */
+ − 2534 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2535 {
+ − 2536 if (BI_BUF_PT (mbuf) > ind)
+ − 2537 JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
+ − 2538 BI_BUF_PT (mbuf) + length);
+ − 2539 }
+ − 2540
+ − 2541 /* Well, point might move. */
+ − 2542 if (move_point)
+ − 2543 BI_BUF_SET_PT (buf, ind + length);
+ − 2544
+ − 2545 if (STRINGP (reloc))
+ − 2546 {
+ − 2547 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2548 {
+ − 2549 splice_in_string_extents (reloc, mbuf, ind, length, offset);
+ − 2550 }
+ − 2551 }
+ − 2552
+ − 2553 if (flags & INSDEL_BEFORE_MARKERS)
+ − 2554 {
+ − 2555 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2556 {
+ − 2557 /* ind - 1 is correct because the FROM argument is exclusive.
+ − 2558 I formerly used DEC_BYTIND() but that caused problems at the
+ − 2559 beginning of the buffer. */
+ − 2560 adjust_markers (mbuf, ind - 1, ind, length);
+ − 2561 }
+ − 2562 }
+ − 2563
+ − 2564 signal_after_change (buf, pos, pos, pos + cclen);
+ − 2565
+ − 2566 UNGCPRO;
+ − 2567
+ − 2568 return cclen;
+ − 2569 }
+ − 2570
+ − 2571
+ − 2572 /* The following functions are interfaces onto the above function,
+ − 2573 for inserting particular sorts of data. In all the functions,
+ − 2574 BUF and POS specify the buffer and location where the insertion is
+ − 2575 to take place. (If POS is -1, text is inserted at point and point
+ − 2576 moves forward past the text.) FLAGS is as above. */
+ − 2577
+ − 2578 Charcount
+ − 2579 buffer_insert_raw_string_1 (struct buffer *buf, Bufpos pos,
442
+ − 2580 const Bufbyte *nonreloc, Bytecount length,
428
+ − 2581 int flags)
+ − 2582 {
+ − 2583 /* This function can GC */
+ − 2584 return buffer_insert_string_1 (buf, pos, nonreloc, Qnil, 0, length,
+ − 2585 flags);
+ − 2586 }
+ − 2587
+ − 2588 Charcount
+ − 2589 buffer_insert_lisp_string_1 (struct buffer *buf, Bufpos pos, Lisp_Object str,
+ − 2590 int flags)
+ − 2591 {
+ − 2592 /* This function can GC */
+ − 2593 #ifdef ERROR_CHECK_TYPECHECK
+ − 2594 assert (STRINGP (str));
+ − 2595 #endif
+ − 2596 return buffer_insert_string_1 (buf, pos, 0, str, 0,
+ − 2597 XSTRING_LENGTH (str),
+ − 2598 flags);
+ − 2599 }
+ − 2600
+ − 2601 /* Insert the null-terminated string S (in external format). */
+ − 2602
+ − 2603 Charcount
442
+ − 2604 buffer_insert_c_string_1 (struct buffer *buf, Bufpos pos, const char *s,
428
+ − 2605 int flags)
+ − 2606 {
+ − 2607 /* This function can GC */
442
+ − 2608 const char *translated = GETTEXT (s);
+ − 2609 return buffer_insert_string_1 (buf, pos, (const Bufbyte *) translated, Qnil,
428
+ − 2610 0, strlen (translated), flags);
+ − 2611 }
+ − 2612
+ − 2613 Charcount
+ − 2614 buffer_insert_emacs_char_1 (struct buffer *buf, Bufpos pos, Emchar ch,
+ − 2615 int flags)
+ − 2616 {
+ − 2617 /* This function can GC */
+ − 2618 Bufbyte str[MAX_EMCHAR_LEN];
+ − 2619 Bytecount len = set_charptr_emchar (str, ch);
+ − 2620 return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
+ − 2621 }
+ − 2622
+ − 2623 Charcount
+ − 2624 buffer_insert_c_char_1 (struct buffer *buf, Bufpos pos, char c,
+ − 2625 int flags)
+ − 2626 {
+ − 2627 /* This function can GC */
+ − 2628 return buffer_insert_emacs_char_1 (buf, pos, (Emchar) (unsigned char) c,
+ − 2629 flags);
+ − 2630 }
+ − 2631
+ − 2632 Charcount
+ − 2633 buffer_insert_from_buffer_1 (struct buffer *buf, Bufpos pos,
+ − 2634 struct buffer *buf2, Bufpos pos2,
+ − 2635 Charcount length, int flags)
+ − 2636 {
+ − 2637 /* This function can GC */
+ − 2638 Lisp_Object str = make_string_from_buffer (buf2, pos2, length);
+ − 2639 return buffer_insert_string_1 (buf, pos, 0, str, 0,
+ − 2640 XSTRING_LENGTH (str), flags);
+ − 2641 }
+ − 2642
+ − 2643
+ − 2644 /************************************************************************/
+ − 2645 /* Deletion of ranges */
+ − 2646 /************************************************************************/
+ − 2647
+ − 2648 /* Delete characters in buffer from FROM up to (but not including) TO. */
+ − 2649
+ − 2650 void
+ − 2651 buffer_delete_range (struct buffer *buf, Bufpos from, Bufpos to, int flags)
+ − 2652 {
+ − 2653 /* This function can GC */
+ − 2654 Charcount numdel;
+ − 2655 Bytind bi_from, bi_to;
+ − 2656 Bytecount bc_numdel;
+ − 2657 EMACS_INT shortage;
+ − 2658 struct buffer *mbuf;
+ − 2659 Lisp_Object bufcons;
+ − 2660
+ − 2661 /* Defensive steps just in case a buffer gets deleted and a calling
+ − 2662 function doesn't notice it. */
+ − 2663 if (!BUFFER_LIVE_P (buf))
+ − 2664 return;
+ − 2665
+ − 2666 /* Make args be valid */
+ − 2667 if (from < BUF_BEGV (buf))
+ − 2668 from = BUF_BEGV (buf);
+ − 2669 if (to > BUF_ZV (buf))
+ − 2670 to = BUF_ZV (buf);
+ − 2671 if ((numdel = to - from) <= 0)
+ − 2672 return;
+ − 2673
+ − 2674 prepare_to_modify_buffer (buf, from, to, !(flags & INSDEL_NO_LOCKING));
+ − 2675
+ − 2676 /* Defensive steps in case the before-change-functions fuck around */
+ − 2677 if (!BUFFER_LIVE_P (buf))
+ − 2678 /* Bad bad pre-change function. */
+ − 2679 return;
+ − 2680
+ − 2681 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 2682 modified the buffer. */
+ − 2683 if (from < BUF_BEGV (buf))
+ − 2684 from = BUF_BEGV (buf);
+ − 2685 if (to > BUF_ZV (buf))
+ − 2686 to = BUF_ZV (buf);
+ − 2687 if ((numdel = to - from) <= 0)
+ − 2688 return;
+ − 2689
+ − 2690 /* Redisplay needs to know if a newline was in the deleted region.
+ − 2691 If we've already marked the changed region as having a deleted
+ − 2692 newline there is no use in performing the check. */
+ − 2693 if (!buf->changes->newline_was_deleted)
+ − 2694 {
+ − 2695 scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
+ − 2696 if (!shortage)
+ − 2697 {
+ − 2698 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2699 {
+ − 2700 mbuf->changes->newline_was_deleted = 1;
+ − 2701 }
+ − 2702 }
+ − 2703 }
+ − 2704
+ − 2705 bi_from = bufpos_to_bytind (buf, from);
+ − 2706 bi_to = bufpos_to_bytind (buf, to);
+ − 2707 bc_numdel = bi_to - bi_from;
+ − 2708
+ − 2709 delete_invalidate_line_number_cache (buf, from, to);
+ − 2710
+ − 2711 if (to == BUF_Z (buf) &&
+ − 2712 bi_from > BI_BUF_GPT (buf))
+ − 2713 {
+ − 2714 /* avoid moving the gap just to delete from the bottom. */
+ − 2715
+ − 2716 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2717 {
+ − 2718 record_delete (mbuf, from, numdel);
+ − 2719 }
+ − 2720 BUF_MODIFF (buf)++;
+ − 2721 MARK_BUFFERS_CHANGED;
+ − 2722
+ − 2723 /* #### Point used to be modified here, but this causes problems
+ − 2724 with MULE, as point is used to calculate bytinds, and if the
+ − 2725 offset in bc_numdel causes point to move to a non first-byte
+ − 2726 location, causing some other function to throw an assertion
+ − 2727 in ASSERT_VALID_BYTIND. I've moved the code to right after
+ − 2728 the other movements and adjustments, but before the gap is
+ − 2729 moved. -- jh 970813 */
+ − 2730
+ − 2731 /* Detach any extents that are completely within the range [FROM, TO],
+ − 2732 if the extents are detachable.
+ − 2733
+ − 2734 This must come AFTER record_delete(), so that the appropriate
+ − 2735 extents will be present to be recorded, and BEFORE the gap
+ − 2736 size is increased, as otherwise we will be confused about
+ − 2737 where the extents end. */
+ − 2738 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2739 {
+ − 2740 process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
+ − 2741 }
+ − 2742
+ − 2743 /* Relocate all markers pointing into the new, larger gap to
+ − 2744 point at the end of the text before the gap. */
+ − 2745 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2746 {
+ − 2747 adjust_markers (mbuf,
+ − 2748 (bi_to + BUF_GAP_SIZE (mbuf)),
+ − 2749 (bi_to + BUF_GAP_SIZE (mbuf)),
+ − 2750 (- bc_numdel));
+ − 2751 }
+ − 2752
+ − 2753 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2754 {
+ − 2755 /* Relocate any extent endpoints just like markers. */
+ − 2756 adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
+ − 2757 BUF_GAP_SIZE (mbuf), bc_numdel, 0);
+ − 2758 }
+ − 2759
+ − 2760 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2761 {
+ − 2762 /* Relocate point as if it were a marker. */
+ − 2763 if (bi_from < BI_BUF_PT (mbuf))
+ − 2764 {
+ − 2765 if (BI_BUF_PT (mbuf) < bi_to)
+ − 2766 JUST_SET_POINT (mbuf, from, bi_from);
+ − 2767 else
+ − 2768 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+ − 2769 BI_BUF_PT (mbuf) - bc_numdel);
+ − 2770 }
+ − 2771 }
+ − 2772
+ − 2773 SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + bc_numdel);
+ − 2774
+ − 2775 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2776 {
+ − 2777 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+ − 2778 BI_BUF_ZV (mbuf) - bc_numdel);
+ − 2779 }
+ − 2780 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
+ − 2781 SET_GAP_SENTINEL (buf);
+ − 2782 }
+ − 2783 else
+ − 2784 {
+ − 2785 /* Make sure the gap is somewhere in or next to what we are deleting. */
+ − 2786 if (bi_to < BI_BUF_GPT (buf))
+ − 2787 gap_left (buf, bi_to);
+ − 2788 if (bi_from > BI_BUF_GPT (buf))
+ − 2789 gap_right (buf, bi_from);
+ − 2790
+ − 2791 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2792 {
+ − 2793 record_delete (mbuf, from, numdel);
+ − 2794 }
+ − 2795 BUF_MODIFF (buf)++;
+ − 2796 MARK_BUFFERS_CHANGED;
+ − 2797
+ − 2798 /* #### Point used to be modified here, but this causes problems
+ − 2799 with MULE, as point is used to calculate bytinds, and if the
+ − 2800 offset in bc_numdel causes point to move to a non first-byte
+ − 2801 location, causing some other function to throw an assertion
+ − 2802 in ASSERT_VALID_BYTIND. I've moved the code to right after
+ − 2803 the other movements and adjustments, but before the gap is
+ − 2804 moved. -- jh 970813 */
+ − 2805
+ − 2806 /* Detach any extents that are completely within the range [FROM, TO],
+ − 2807 if the extents are detachable.
+ − 2808
+ − 2809 This must come AFTER record_delete(), so that the appropriate extents
+ − 2810 will be present to be recorded, and BEFORE the gap size is increased,
+ − 2811 as otherwise we will be confused about where the extents end. */
+ − 2812 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2813 {
+ − 2814 process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
+ − 2815 }
+ − 2816
+ − 2817 /* Relocate all markers pointing into the new, larger gap to
+ − 2818 point at the end of the text before the gap. */
+ − 2819 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2820 {
+ − 2821 adjust_markers (mbuf,
+ − 2822 (bi_to + BUF_GAP_SIZE (mbuf)),
+ − 2823 (bi_to + BUF_GAP_SIZE (mbuf)),
+ − 2824 (- bc_numdel - BUF_GAP_SIZE (mbuf)));
+ − 2825 }
+ − 2826
+ − 2827 /* Relocate any extent endpoints just like markers. */
+ − 2828 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2829 {
+ − 2830 adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
+ − 2831 BUF_GAP_SIZE (mbuf),
+ − 2832 bc_numdel, BUF_GAP_SIZE (mbuf));
+ − 2833 }
+ − 2834
+ − 2835 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2836 {
+ − 2837 /* Relocate point as if it were a marker. */
+ − 2838 if (bi_from < BI_BUF_PT (mbuf))
+ − 2839 {
+ − 2840 if (BI_BUF_PT (mbuf) < bi_to)
+ − 2841 JUST_SET_POINT (mbuf, from, bi_from);
+ − 2842 else
+ − 2843 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+ − 2844 BI_BUF_PT (mbuf) - bc_numdel);
+ − 2845 }
+ − 2846 }
+ − 2847
+ − 2848 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + bc_numdel);
+ − 2849 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2850 {
+ − 2851 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+ − 2852 BI_BUF_ZV (mbuf) - bc_numdel);
+ − 2853 }
+ − 2854 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
+ − 2855 SET_BI_BUF_GPT (buf, bi_from);
+ − 2856 SET_GAP_SENTINEL (buf);
+ − 2857 }
+ − 2858
+ − 2859 #ifdef MULE
+ − 2860 buffer_mule_signal_deleted_region (buf, from, to, bi_from, bi_to);
+ − 2861 #endif
+ − 2862
+ − 2863 #ifdef ERROR_CHECK_EXTENTS
+ − 2864 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2865 {
+ − 2866 sledgehammer_extent_check (make_buffer (mbuf));
+ − 2867 }
+ − 2868 #endif
+ − 2869
+ − 2870 signal_after_change (buf, from, to, from);
+ − 2871 }
+ − 2872
+ − 2873
+ − 2874 /************************************************************************/
+ − 2875 /* Replacement of characters */
+ − 2876 /************************************************************************/
+ − 2877
+ − 2878 /* Replace the character at POS in buffer B with CH. */
+ − 2879
+ − 2880 void
+ − 2881 buffer_replace_char (struct buffer *buf, Bufpos pos, Emchar ch,
+ − 2882 int not_real_change, int force_lock_check)
+ − 2883 {
+ − 2884 /* This function can GC */
+ − 2885 Bufbyte curstr[MAX_EMCHAR_LEN];
+ − 2886 Bufbyte newstr[MAX_EMCHAR_LEN];
+ − 2887 Bytecount curlen, newlen;
+ − 2888
+ − 2889 /* Defensive steps just in case a buffer gets deleted and a calling
+ − 2890 function doesn't notice it. */
+ − 2891 if (!BUFFER_LIVE_P (buf))
+ − 2892 return;
+ − 2893
+ − 2894 curlen = BUF_CHARPTR_COPY_CHAR (buf, pos, curstr);
+ − 2895 newlen = set_charptr_emchar (newstr, ch);
+ − 2896
+ − 2897 if (curlen == newlen)
+ − 2898 {
+ − 2899 struct buffer *mbuf;
+ − 2900 Lisp_Object bufcons;
+ − 2901
+ − 2902 /* then we can just replace the text. */
+ − 2903 prepare_to_modify_buffer (buf, pos, pos + 1,
+ − 2904 !not_real_change || force_lock_check);
+ − 2905 /* Defensive steps in case the before-change-functions fuck around */
+ − 2906 if (!BUFFER_LIVE_P (buf))
+ − 2907 /* Bad bad pre-change function. */
+ − 2908 return;
+ − 2909
+ − 2910 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 2911 modified the buffer. */
+ − 2912 if (pos < BUF_BEGV (buf))
+ − 2913 pos = BUF_BEGV (buf);
+ − 2914 if (pos >= BUF_ZV (buf))
+ − 2915 pos = BUF_ZV (buf) - 1;
+ − 2916 if (pos < BUF_BEGV (buf))
+ − 2917 /* no more characters in buffer! */
+ − 2918 return;
+ − 2919
+ − 2920 if (BUF_FETCH_CHAR (buf, pos) == '\n')
+ − 2921 {
+ − 2922 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2923 {
+ − 2924 mbuf->changes->newline_was_deleted = 1;
+ − 2925 }
+ − 2926 }
+ − 2927 MARK_BUFFERS_CHANGED;
+ − 2928 if (!not_real_change)
+ − 2929 {
+ − 2930 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 2931 {
+ − 2932 record_change (mbuf, pos, 1);
+ − 2933 }
+ − 2934 BUF_MODIFF (buf)++;
+ − 2935 }
+ − 2936 memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
+ − 2937
+ − 2938 signal_after_change (buf, pos, pos + 1, pos + 1);
+ − 2939
+ − 2940 /* We do not have to adjust the Mule data; we just replaced a
+ − 2941 character with another of the same number of bytes. */
+ − 2942 }
+ − 2943 else
+ − 2944 {
+ − 2945 /*
+ − 2946 * Must implement as deletion followed by insertion.
+ − 2947 *
+ − 2948 * Make a note to move point forward later in the one situation
+ − 2949 * where it is needed, a delete/insert one position behind
+ − 2950 * point. Point will drift backward by one position and stay
+ − 2951 * there otherwise.
+ − 2952 */
+ − 2953 int movepoint = (pos == BUF_PT (buf) - 1);
+ − 2954
+ − 2955 buffer_delete_range (buf, pos, pos + 1, 0);
+ − 2956 /* Defensive steps in case the before-change-functions fuck around */
+ − 2957 if (!BUFFER_LIVE_P (buf))
+ − 2958 /* Bad bad pre-change function. */
+ − 2959 return;
+ − 2960
+ − 2961 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 2962 modified the buffer. */
+ − 2963 if (pos < BUF_BEGV (buf))
+ − 2964 pos = BUF_BEGV (buf);
+ − 2965 if (pos >= BUF_ZV (buf))
+ − 2966 pos = BUF_ZV (buf) - 1;
+ − 2967 if (pos < BUF_BEGV (buf))
+ − 2968 /* no more characters in buffer! */
+ − 2969 return;
+ − 2970 /*
+ − 2971 * -1 as the pos argument means to move point forward with the
+ − 2972 * insertion, which we must do if the deletion moved point
+ − 2973 * backward so that it now equals the insertion point.
+ − 2974 */
+ − 2975 buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
+ − 2976 newstr, Qnil, 0, newlen, 0);
+ − 2977 }
+ − 2978 }
+ − 2979
+ − 2980
+ − 2981 /************************************************************************/
+ − 2982 /* Other functions */
+ − 2983 /************************************************************************/
+ − 2984
+ − 2985 /* Make a string from a buffer. This needs to take into account the gap,
+ − 2986 and add any necessary extents from the buffer. */
+ − 2987
+ − 2988 static Lisp_Object
+ − 2989 make_string_from_buffer_1 (struct buffer *buf, Bufpos pos, Charcount length,
+ − 2990 int no_extents)
+ − 2991 {
+ − 2992 /* This function can GC */
+ − 2993 Bytind bi_ind = bufpos_to_bytind (buf, pos);
+ − 2994 Bytecount bi_len = bufpos_to_bytind (buf, pos + length) - bi_ind;
+ − 2995 Lisp_Object val = make_uninit_string (bi_len);
+ − 2996
+ − 2997 struct gcpro gcpro1;
+ − 2998 GCPRO1 (val);
+ − 2999
+ − 3000 if (!no_extents)
+ − 3001 add_string_extents (val, buf, bi_ind, bi_len);
+ − 3002
+ − 3003 {
+ − 3004 Bytecount len1 = BI_BUF_GPT (buf) - bi_ind;
+ − 3005 Bufbyte *start1 = BI_BUF_BYTE_ADDRESS (buf, bi_ind);
+ − 3006 Bufbyte *dest = XSTRING_DATA (val);
+ − 3007
+ − 3008 if (len1 < 0)
+ − 3009 {
+ − 3010 /* Completely after gap */
+ − 3011 memcpy (dest, start1, bi_len);
+ − 3012 }
+ − 3013 else if (bi_len <= len1)
+ − 3014 {
+ − 3015 /* Completely before gap */
+ − 3016 memcpy (dest, start1, bi_len);
+ − 3017 }
+ − 3018 else
+ − 3019 {
+ − 3020 /* Spans gap */
+ − 3021 Bytind pos2 = bi_ind + len1;
+ − 3022 Bufbyte *start2 = BI_BUF_BYTE_ADDRESS (buf, pos2);
+ − 3023
+ − 3024 memcpy (dest, start1, len1);
+ − 3025 memcpy (dest + len1, start2, bi_len - len1);
+ − 3026 }
+ − 3027 }
+ − 3028
+ − 3029 UNGCPRO;
+ − 3030 return val;
+ − 3031 }
+ − 3032
+ − 3033 Lisp_Object
+ − 3034 make_string_from_buffer (struct buffer *buf, Bufpos pos, Charcount length)
+ − 3035 {
+ − 3036 return make_string_from_buffer_1 (buf, pos, length, 0);
+ − 3037 }
+ − 3038
+ − 3039 Lisp_Object
+ − 3040 make_string_from_buffer_no_extents (struct buffer *buf, Bufpos pos,
+ − 3041 Charcount length)
+ − 3042 {
+ − 3043 return make_string_from_buffer_1 (buf, pos, length, 1);
+ − 3044 }
+ − 3045
+ − 3046 void
+ − 3047 barf_if_buffer_read_only (struct buffer *buf, Bufpos from, Bufpos to)
+ − 3048 {
+ − 3049 Lisp_Object buffer;
+ − 3050 Lisp_Object iro;
+ − 3051
+ − 3052 XSETBUFFER (buffer, buf);
+ − 3053 back:
+ − 3054 iro = (buf == current_buffer ? Vinhibit_read_only :
+ − 3055 symbol_value_in_buffer (Qinhibit_read_only, buffer));
+ − 3056 if (!LISTP (iro))
+ − 3057 return;
+ − 3058 if (NILP (iro) && !NILP (buf->read_only))
+ − 3059 {
+ − 3060 Fsignal (Qbuffer_read_only, (list1 (buffer)));
+ − 3061 goto back;
+ − 3062 }
+ − 3063 if (from > 0)
+ − 3064 {
+ − 3065 if (to < 0)
+ − 3066 to = from;
+ − 3067 verify_extent_modification (buffer,
+ − 3068 bufpos_to_bytind (buf, from),
+ − 3069 bufpos_to_bytind (buf, to),
+ − 3070 iro);
+ − 3071 }
+ − 3072 }
+ − 3073
+ − 3074 void
442
+ − 3075 find_charsets_in_bufbyte_string (unsigned char *charsets, const Bufbyte *str,
428
+ − 3076 Bytecount len)
+ − 3077 {
+ − 3078 #ifndef MULE
+ − 3079 /* Telescope this. */
+ − 3080 charsets[0] = 1;
+ − 3081 #else
442
+ − 3082 const Bufbyte *strend = str + len;
428
+ − 3083 memset (charsets, 0, NUM_LEADING_BYTES);
+ − 3084
442
+ − 3085 /* #### SJT doesn't like this. */
+ − 3086 if (len == 0)
+ − 3087 {
+ − 3088 charsets[XCHARSET_LEADING_BYTE (Vcharset_ascii) - 128] = 1;
+ − 3089 return;
+ − 3090 }
+ − 3091
428
+ − 3092 while (str < strend)
+ − 3093 {
+ − 3094 charsets[CHAR_LEADING_BYTE (charptr_emchar (str)) - 128] = 1;
+ − 3095 INC_CHARPTR (str);
+ − 3096 }
+ − 3097 #endif
+ − 3098 }
+ − 3099
+ − 3100 void
442
+ − 3101 find_charsets_in_emchar_string (unsigned char *charsets, const Emchar *str,
428
+ − 3102 Charcount len)
+ − 3103 {
+ − 3104 #ifndef MULE
+ − 3105 /* Telescope this. */
+ − 3106 charsets[0] = 1;
+ − 3107 #else
+ − 3108 int i;
+ − 3109
+ − 3110 memset (charsets, 0, NUM_LEADING_BYTES);
442
+ − 3111
+ − 3112 /* #### SJT doesn't like this. */
+ − 3113 if (len == 0)
+ − 3114 {
+ − 3115 charsets[XCHARSET_LEADING_BYTE (Vcharset_ascii) - 128] = 1;
+ − 3116 return;
+ − 3117 }
+ − 3118
428
+ − 3119 for (i = 0; i < len; i++)
+ − 3120 {
+ − 3121 charsets[CHAR_LEADING_BYTE (str[i]) - 128] = 1;
+ − 3122 }
+ − 3123 #endif
+ − 3124 }
+ − 3125
+ − 3126 int
442
+ − 3127 bufbyte_string_displayed_columns (const Bufbyte *str, Bytecount len)
428
+ − 3128 {
+ − 3129 int cols = 0;
442
+ − 3130 const Bufbyte *end = str + len;
428
+ − 3131
+ − 3132 while (str < end)
+ − 3133 {
+ − 3134 #ifdef MULE
+ − 3135 Emchar ch = charptr_emchar (str);
+ − 3136 cols += XCHARSET_COLUMNS (CHAR_CHARSET (ch));
+ − 3137 #else
+ − 3138 cols++;
+ − 3139 #endif
+ − 3140 INC_CHARPTR (str);
+ − 3141 }
+ − 3142
+ − 3143 return cols;
+ − 3144 }
+ − 3145
+ − 3146 int
442
+ − 3147 emchar_string_displayed_columns (const Emchar *str, Charcount len)
428
+ − 3148 {
+ − 3149 #ifdef MULE
+ − 3150 int cols = 0;
+ − 3151 int i;
+ − 3152
+ − 3153 for (i = 0; i < len; i++)
+ − 3154 cols += XCHARSET_COLUMNS (CHAR_CHARSET (str[i]));
+ − 3155
+ − 3156 return cols;
+ − 3157 #else /* not MULE */
+ − 3158 return len;
+ − 3159 #endif
+ − 3160 }
+ − 3161
+ − 3162 /* NOTE: Does not reset the Dynarr. */
+ − 3163
+ − 3164 void
442
+ − 3165 convert_bufbyte_string_into_emchar_dynarr (const Bufbyte *str, Bytecount len,
428
+ − 3166 Emchar_dynarr *dyn)
+ − 3167 {
442
+ − 3168 const Bufbyte *strend = str + len;
428
+ − 3169
+ − 3170 while (str < strend)
+ − 3171 {
+ − 3172 Emchar ch = charptr_emchar (str);
+ − 3173 Dynarr_add (dyn, ch);
+ − 3174 INC_CHARPTR (str);
+ − 3175 }
+ − 3176 }
+ − 3177
+ − 3178 Charcount
442
+ − 3179 convert_bufbyte_string_into_emchar_string (const Bufbyte *str, Bytecount len,
428
+ − 3180 Emchar *arr)
+ − 3181 {
442
+ − 3182 const Bufbyte *strend = str + len;
428
+ − 3183 Charcount newlen = 0;
+ − 3184 while (str < strend)
+ − 3185 {
+ − 3186 Emchar ch = charptr_emchar (str);
+ − 3187 arr[newlen++] = ch;
+ − 3188 INC_CHARPTR (str);
+ − 3189 }
+ − 3190 return newlen;
+ − 3191 }
+ − 3192
+ − 3193 /* Convert an array of Emchars into the equivalent string representation.
+ − 3194 Store into the given Bufbyte dynarr. Does not reset the dynarr.
+ − 3195 Does not add a terminating zero. */
+ − 3196
+ − 3197 void
+ − 3198 convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
+ − 3199 Bufbyte_dynarr *dyn)
+ − 3200 {
+ − 3201 Bufbyte str[MAX_EMCHAR_LEN];
+ − 3202 int i;
+ − 3203
+ − 3204 for (i = 0; i < nels; i++)
+ − 3205 {
+ − 3206 Bytecount len = set_charptr_emchar (str, arr[i]);
+ − 3207 Dynarr_add_many (dyn, str, len);
+ − 3208 }
+ − 3209 }
+ − 3210
+ − 3211 /* Convert an array of Emchars into the equivalent string representation.
+ − 3212 Malloc the space needed for this and return it. If LEN_OUT is not a
+ − 3213 NULL pointer, store into LEN_OUT the number of Bufbytes in the
+ − 3214 malloc()ed string. Note that the actual number of Bufbytes allocated
+ − 3215 is one more than this: the returned string is zero-terminated. */
+ − 3216
+ − 3217 Bufbyte *
+ − 3218 convert_emchar_string_into_malloced_string (Emchar *arr, int nels,
+ − 3219 Bytecount *len_out)
+ − 3220 {
+ − 3221 /* Damn zero-termination. */
+ − 3222 Bufbyte *str = (Bufbyte *) alloca (nels * MAX_EMCHAR_LEN + 1);
+ − 3223 Bufbyte *strorig = str;
+ − 3224 Bytecount len;
+ − 3225
+ − 3226 int i;
+ − 3227
+ − 3228 for (i = 0; i < nels; i++)
+ − 3229 str += set_charptr_emchar (str, arr[i]);
+ − 3230 *str = '\0';
+ − 3231 len = str - strorig;
+ − 3232 str = (Bufbyte *) xmalloc (1 + len);
+ − 3233 memcpy (str, strorig, 1 + len);
+ − 3234 if (len_out)
+ − 3235 *len_out = len;
+ − 3236 return str;
+ − 3237 }
+ − 3238
+ − 3239
+ − 3240 /************************************************************************/
+ − 3241 /* initialization */
+ − 3242 /************************************************************************/
+ − 3243
+ − 3244 void
+ − 3245 reinit_vars_of_insdel (void)
+ − 3246 {
+ − 3247 int i;
+ − 3248
+ − 3249 inside_change_hook = 0;
+ − 3250 in_first_change = 0;
+ − 3251
+ − 3252 for (i = 0; i <= MAX_BYTIND_GAP_SIZE_3; i++)
+ − 3253 three_to_one_table[i] = i / 3;
+ − 3254 }
+ − 3255
+ − 3256 void
+ − 3257 vars_of_insdel (void)
+ − 3258 {
+ − 3259 reinit_vars_of_insdel ();
+ − 3260 }
+ − 3261
+ − 3262 void
+ − 3263 init_buffer_text (struct buffer *b)
+ − 3264 {
+ − 3265 if (!b->base_buffer)
+ − 3266 {
+ − 3267 SET_BUF_GAP_SIZE (b, 20);
+ − 3268 BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
+ − 3269 if (! BUF_BEG_ADDR (b))
+ − 3270 memory_full ();
+ − 3271
+ − 3272 SET_BUF_END_GAP_SIZE (b, 0);
+ − 3273 SET_BI_BUF_GPT (b, 1);
+ − 3274 SET_BOTH_BUF_Z (b, 1, 1);
+ − 3275 SET_GAP_SENTINEL (b);
+ − 3276 SET_END_SENTINEL (b);
+ − 3277 #ifdef MULE
+ − 3278 {
+ − 3279 int i;
+ − 3280
+ − 3281 b->text->mule_bufmin = b->text->mule_bufmax = 1;
+ − 3282 b->text->mule_bytmin = b->text->mule_bytmax = 1;
+ − 3283 b->text->mule_shifter = 0;
+ − 3284 b->text->mule_three_p = 0;
+ − 3285
+ − 3286 for (i = 0; i < 16; i++)
+ − 3287 {
+ − 3288 b->text->mule_bufpos_cache[i] = 1;
+ − 3289 b->text->mule_bytind_cache[i] = 1;
+ − 3290 }
+ − 3291 }
+ − 3292 #endif /* MULE */
+ − 3293 b->text->line_number_cache = Qnil;
+ − 3294
+ − 3295 BUF_MODIFF (b) = 1;
+ − 3296 BUF_SAVE_MODIFF (b) = 1;
+ − 3297
+ − 3298 JUST_SET_POINT (b, 1, 1);
+ − 3299 SET_BOTH_BUF_BEGV (b, 1, 1);
+ − 3300 SET_BOTH_BUF_ZV (b, 1, 1);
+ − 3301
+ − 3302 b->text->changes = xnew_and_zero (struct buffer_text_change_data);
+ − 3303 }
+ − 3304 else
+ − 3305 {
+ − 3306 JUST_SET_POINT (b, BUF_PT (b->base_buffer), BI_BUF_PT (b->base_buffer));
+ − 3307 SET_BOTH_BUF_BEGV (b, BUF_BEGV (b->base_buffer),
+ − 3308 BI_BUF_BEGV (b->base_buffer));
+ − 3309 SET_BOTH_BUF_ZV (b, BUF_ZV (b->base_buffer),
+ − 3310 BI_BUF_ZV (b->base_buffer));
+ − 3311 }
+ − 3312
+ − 3313 b->changes = xnew_and_zero (struct each_buffer_change_data);
+ − 3314 BUF_FACECHANGE (b) = 1;
+ − 3315
+ − 3316 #ifdef REGION_CACHE_NEEDS_WORK
+ − 3317 b->newline_cache = 0;
+ − 3318 b->width_run_cache = 0;
+ − 3319 b->width_table = Qnil;
+ − 3320 #endif
+ − 3321 }
+ − 3322
+ − 3323 void
+ − 3324 uninit_buffer_text (struct buffer *b)
+ − 3325 {
+ − 3326 if (!b->base_buffer)
+ − 3327 {
+ − 3328 BUFFER_FREE (b->text->beg);
+ − 3329 xfree (b->text->changes);
+ − 3330 }
+ − 3331 xfree (b->changes);
+ − 3332
+ − 3333 #ifdef REGION_CACHE_NEEDS_WORK
+ − 3334 if (b->newline_cache)
+ − 3335 {
+ − 3336 free_region_cache (b->newline_cache);
+ − 3337 b->newline_cache = 0;
+ − 3338 }
+ − 3339 if (b->width_run_cache)
+ − 3340 {
+ − 3341 free_region_cache (b->width_run_cache);
+ − 3342 b->width_run_cache = 0;
+ − 3343 }
+ − 3344 b->width_table = Qnil;
+ − 3345 #endif
+ − 3346 }