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.
2367
+ − 5 Copyright (C) 2001, 2002, 2003, 2004 Ben Wing.
428
+ − 6
+ − 7 This file is part of XEmacs.
+ − 8
+ − 9 XEmacs is free software; you can redistribute it and/or modify it
+ − 10 under the terms of the GNU General Public License as published by the
+ − 11 Free Software Foundation; either version 2, or (at your option) any
+ − 12 later version.
+ − 13
+ − 14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
+ − 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ − 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ − 17 for more details.
+ − 18
+ − 19 You should have received a copy of the GNU General Public License
+ − 20 along with XEmacs; see the file COPYING. If not, write to
+ − 21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ − 22 Boston, MA 02111-1307, USA. */
+ − 23
+ − 24 /* Synched up with: Mule 2.0, FSF 19.30. Diverges significantly. */
+ − 25
+ − 26 /* This file has been Mule-ized. */
+ − 27
853
+ − 28 /* Original file from FSF, 1991.
+ − 29 Some changes for extents, c. 1991 by unknown Lucid author.
+ − 30 Completely rewritten December 1994, for Mule implementation by Ben Wing;
+ − 31 all buffer modification code ripped out of other files and consolidated
+ − 32 here.
+ − 33 Indirect buffers written c. 1997? by Hrvoje Niksic.
+ − 34 */
428
+ − 35
+ − 36 #include <config.h>
+ − 37 #include "lisp.h"
+ − 38
+ − 39 #include "buffer.h"
+ − 40 #include "device.h"
+ − 41 #include "frame.h"
+ − 42 #include "extents.h"
+ − 43 #include "insdel.h"
+ − 44 #include "lstream.h"
+ − 45 #include "redisplay.h"
+ − 46 #include "line-number.h"
+ − 47
+ − 48 /* Various macros modelled along the lines of those in buffer.h.
+ − 49 Purposefully omitted from buffer.h because files other than this
+ − 50 one should not be using them. */
+ − 51
+ − 52 /* Address of beginning of buffer. This is an lvalue because
+ − 53 BUFFER_ALLOC needs it to be. */
+ − 54 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
+ − 55
+ − 56 /* Set the address of beginning of buffer. */
+ − 57 #define SET_BUF_BEG_ADDR(buf, addr) do { (buf)->text->beg = (addr); } while (0)
+ − 58
+ − 59 /* Gap size. */
+ − 60 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size + 0)
+ − 61 #define BUF_END_GAP_SIZE(buf) ((buf)->text->end_gap_size + 0)
+ − 62 /* Set gap size. */
+ − 63 #define SET_BUF_GAP_SIZE(buf, value) \
+ − 64 do { (buf)->text->gap_size = (value); } while (0)
+ − 65 #define SET_BUF_END_GAP_SIZE(buf, value) \
+ − 66 do { (buf)->text->end_gap_size = (value); } while (0)
+ − 67
826
+ − 68 #define BUF_GPT_ADDR(buf) (BUF_BEG_ADDR (buf) + BYTE_BUF_GPT (buf) - 1)
428
+ − 69
+ − 70 /* Set gap location. */
2367
+ − 71 #define SET_BOTH_BUF_GPT(buf, cval, bval) \
+ − 72 do \
+ − 73 { \
+ − 74 (buf)->text->gpt = (bval); \
+ − 75 (buf)->text->bufgpt = (cval); \
+ − 76 } while (0)
428
+ − 77
+ − 78 /* Set end of buffer. */
2367
+ − 79 #define SET_BOTH_BUF_Z(buf, cval, bval) \
428
+ − 80 do \
+ − 81 { \
2367
+ − 82 (buf)->text->z = (bval); \
+ − 83 (buf)->text->bufz = (cval); \
428
+ − 84 } while (0)
+ − 85
+ − 86 /* Under Mule, we maintain two sentinels in the buffer: one at the
+ − 87 beginning of the gap, and one at the end of the buffer. This
+ − 88 allows us to move forward, examining bytes looking for the
+ − 89 end of a character, and not worry about running off the end.
+ − 90 We do not need corresponding sentinels when moving backwards
+ − 91 because we do not have to look past the beginning of a character
+ − 92 to find the beginning of the character.
+ − 93
+ − 94 Every time we change the beginning of the gap, we have to
+ − 95 call SET_GAP_SENTINEL().
+ − 96
+ − 97 Every time we change the total size (characters plus gap)
+ − 98 of the buffer, we have to call SET_END_SENTINEL().
+ − 99 */
+ − 100
+ − 101
+ − 102 #ifdef MULE
+ − 103 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len) + 1)
+ − 104 # define SET_GAP_SENTINEL(buf) (*BUF_GPT_ADDR (buf) = 0)
+ − 105 # define BUF_END_SENTINEL_SIZE 1
+ − 106 # define SET_END_SENTINEL(buf) \
826
+ − 107 (*(BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + BYTE_BUF_Z (buf) - 1) = 0)
428
+ − 108 #else
+ − 109 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len))
+ − 110 # define SET_GAP_SENTINEL(buf)
+ − 111 # define BUF_END_SENTINEL_SIZE 0
+ − 112 # define SET_END_SENTINEL(buf)
+ − 113 #endif
+ − 114
+ − 115
+ − 116 /************************************************************************/
+ − 117 /* point and marker adjustment */
+ − 118 /************************************************************************/
+ − 119
+ − 120 /* just_set_point() is the only place `PT' is an lvalue in all of emacs.
+ − 121 This function is called from set_buffer_point(), which is the function
+ − 122 that the SET_PT and BUF_SET_PT macros expand into, and from the
+ − 123 routines below that insert and delete text. (This is in cases where
+ − 124 the point marker logically doesn't move but PT (being a byte index)
+ − 125 needs to get adjusted.) */
+ − 126
+ − 127 /* Set point to a specified value. This is used only when the value
+ − 128 of point changes due to an insert or delete; it does not represent
+ − 129 a conceptual change in point as a marker. In particular, point is
+ − 130 not crossing any interval boundaries, so there's no need to use the
+ − 131 usual SET_PT macro. In fact it would be incorrect to do so, because
+ − 132 either the old or the new value of point is out of synch with the
+ − 133 current set of intervals. */
+ − 134
+ − 135 /* This gets called more than enough to make the function call
+ − 136 overhead a significant factor so we've turned it into a macro. */
665
+ − 137 #define JUST_SET_POINT(buf, charbpos, ind) \
428
+ − 138 do \
+ − 139 { \
665
+ − 140 buf->bufpt = (charbpos); \
428
+ − 141 buf->pt = (ind); \
+ − 142 } while (0)
+ − 143
+ − 144 /* Set a buffer's point. */
+ − 145
+ − 146 void
665
+ − 147 set_buffer_point (struct buffer *buf, Charbpos charbpos, Bytebpos bytpos)
428
+ − 148 {
826
+ − 149 assert (bytpos >= BYTE_BUF_BEGV (buf) && bytpos <= BYTE_BUF_ZV (buf));
+ − 150 if (bytpos == BYTE_BUF_PT (buf))
428
+ − 151 return;
665
+ − 152 JUST_SET_POINT (buf, charbpos, bytpos);
428
+ − 153 MARK_POINT_CHANGED;
+ − 154 assert (MARKERP (buf->point_marker));
665
+ − 155 XMARKER (buf->point_marker)->membpos =
+ − 156 bytebpos_to_membpos (buf, bytpos);
428
+ − 157
+ − 158 /* FSF makes sure that PT is not being set within invisible text.
+ − 159 However, this is the wrong place for that check. The check
+ − 160 should happen only at the next redisplay. */
+ − 161
+ − 162 /* Some old coder said:
+ − 163
+ − 164 "If there were to be hooks which were run when point entered/left an
+ − 165 extent, this would be the place to put them.
+ − 166
+ − 167 However, it's probably the case that such hooks should be implemented
+ − 168 using a post-command-hook instead, to avoid running the hooks as a
+ − 169 result of intermediate motion inside of save-excursions, for example."
+ − 170
+ − 171 I definitely agree with this. PT gets moved all over the place
+ − 172 and it would be a Bad Thing for any hooks to get called, both for
+ − 173 the reason above and because many callers are not prepared for
+ − 174 a GC within this function. --ben
+ − 175 */
+ − 176 }
+ − 177
+ − 178 /* Do the correct marker-like adjustment on MPOS (see below). FROM, TO,
+ − 179 and AMOUNT are as in adjust_markers(). If MPOS doesn't need to be
+ − 180 adjusted, nothing will happen. */
665
+ − 181 Membpos
+ − 182 do_marker_adjustment (Membpos mpos, Membpos from,
+ − 183 Membpos to, Bytecount amount)
428
+ − 184 {
+ − 185 if (amount > 0)
+ − 186 {
+ − 187 if (mpos > to && mpos < to + amount)
+ − 188 mpos = to + amount;
+ − 189 }
+ − 190 else
+ − 191 {
+ − 192 if (mpos > from + amount && mpos <= from)
+ − 193 mpos = from + amount;
+ − 194 }
+ − 195 if (mpos > from && mpos <= to)
+ − 196 mpos += amount;
+ − 197 return mpos;
+ − 198 }
+ − 199
+ − 200 /* Do the following:
+ − 201
+ − 202 (1) Add `amount' to the position of every marker in the current buffer
+ − 203 whose current position is between `from' (exclusive) and `to' (inclusive).
+ − 204
+ − 205 (2) Also, any markers past the outside of that interval, in the direction
+ − 206 of adjustment, are first moved back to the near end of the interval
+ − 207 and then adjusted by `amount'.
+ − 208
+ − 209 This function is called in two different cases: when a region of
+ − 210 characters adjacent to the gap is moved, causing the gap to shift
+ − 211 to the other side of the region (in this case, `from' and `to'
+ − 212 point to the old position of the region and there should be no
+ − 213 markers affected by (2) because they would be inside the gap),
+ − 214 or when a region of characters adjacent to the gap is wiped out,
+ − 215 causing the gap to increase to include the region (in this case,
+ − 216 `from' and `to' are the same, both pointing to the boundary
+ − 217 between the gap and the deleted region, and there are no markers
+ − 218 affected by (1)).
+ − 219
+ − 220 The reason for the use of exclusive and inclusive is that markers at
+ − 221 the gap always sit at the beginning, not at the end.
+ − 222 */
+ − 223
+ − 224 static void
665
+ − 225 adjust_markers (struct buffer *buf, Membpos from, Membpos to,
428
+ − 226 Bytecount amount)
+ − 227 {
440
+ − 228 Lisp_Marker *m;
428
+ − 229
+ − 230 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
665
+ − 231 m->membpos = do_marker_adjustment (m->membpos, from, to, amount);
428
+ − 232 }
+ − 233
+ − 234 /* Adjust markers whose insertion-type is t
+ − 235 for an insertion of AMOUNT characters at POS. */
+ − 236
+ − 237 static void
665
+ − 238 adjust_markers_for_insert (struct buffer *buf, Membpos ind, Bytecount amount)
428
+ − 239 {
440
+ − 240 Lisp_Marker *m;
428
+ − 241
+ − 242 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
+ − 243 {
665
+ − 244 if (m->insertion_type && m->membpos == ind)
+ − 245 m->membpos += amount;
428
+ − 246 }
+ − 247 }
+ − 248
+ − 249
+ − 250 /************************************************************************/
+ − 251 /* Routines for dealing with the gap */
+ − 252 /************************************************************************/
+ − 253
+ − 254 /* maximum amount of memory moved in a single chunk. Increasing this
+ − 255 value improves gap-motion efficiency but decreases QUIT responsiveness
+ − 256 time. Was 32000 but today's processors are faster and files are
+ − 257 bigger. --ben */
+ − 258 #define GAP_MOVE_CHUNK 300000
+ − 259
2367
+ − 260 /* Move the gap to CPOS/BPOS, which is less than the current GPT. */
428
+ − 261
+ − 262 static void
2367
+ − 263 gap_left (struct buffer *buf, Charbpos cpos, Bytebpos bpos)
428
+ − 264 {
867
+ − 265 Ibyte *to, *from;
428
+ − 266 Bytecount i;
665
+ − 267 Bytebpos new_s1;
428
+ − 268 struct buffer *mbuf;
+ − 269 Lisp_Object bufcons;
+ − 270
+ − 271 from = BUF_GPT_ADDR (buf);
+ − 272 to = from + BUF_GAP_SIZE (buf);
826
+ − 273 new_s1 = BYTE_BUF_GPT (buf);
428
+ − 274
+ − 275 /* Now copy the characters. To move the gap down,
+ − 276 copy characters up. */
+ − 277
+ − 278 while (1)
+ − 279 {
+ − 280 /* I gets number of characters left to copy. */
2367
+ − 281 i = new_s1 - bpos;
428
+ − 282 if (i == 0)
+ − 283 break;
+ − 284 /* If a quit is requested, stop copying now.
2367
+ − 285 Change BPOS to be where we have actually moved the gap to. */
428
+ − 286 if (QUITP)
+ − 287 {
2367
+ − 288 bpos = new_s1;
+ − 289 cpos = bytebpos_to_charbpos (buf, bpos);
428
+ − 290 break;
+ − 291 }
+ − 292 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
+ − 293 if (i > GAP_MOVE_CHUNK)
+ − 294 i = GAP_MOVE_CHUNK;
440
+ − 295
2367
+ − 296 if (i >= 10) /* was 128 but memmove() should be extremely efficient
+ − 297 nowadays */
428
+ − 298 {
+ − 299 new_s1 -= i;
440
+ − 300 from -= i;
+ − 301 to -= i;
428
+ − 302 memmove (to, from, i);
+ − 303 }
+ − 304 else
+ − 305 {
+ − 306 new_s1 -= i;
+ − 307 while (--i >= 0)
+ − 308 *--to = *--from;
+ − 309 }
+ − 310 }
+ − 311
2367
+ − 312 /* Adjust markers, and buffer data structure, to put the gap at BPOS.
+ − 313 BPOS is where the loop above stopped, which may be what was specified
428
+ − 314 or may be where a quit was detected. */
+ − 315 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 316 {
2367
+ − 317 adjust_markers (mbuf, bpos, BYTE_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
428
+ − 318 }
+ − 319 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 320 {
2367
+ − 321 adjust_extents (wrap_buffer (mbuf), bpos, BYTE_BUF_GPT (mbuf),
428
+ − 322 BUF_GAP_SIZE (mbuf));
+ − 323 }
2367
+ − 324 SET_BOTH_BUF_GPT (buf, cpos, bpos);
428
+ − 325 SET_GAP_SENTINEL (buf);
+ − 326 #ifdef ERROR_CHECK_EXTENTS
+ − 327 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 328 {
771
+ − 329 sledgehammer_extent_check (wrap_buffer (mbuf));
428
+ − 330 }
+ − 331 #endif
+ − 332 QUIT;
+ − 333 }
+ − 334
+ − 335 static void
2367
+ − 336 gap_right (struct buffer *buf, Charbpos cpos, Bytebpos bpos)
428
+ − 337 {
867
+ − 338 Ibyte *to, *from;
428
+ − 339 Bytecount i;
665
+ − 340 Bytebpos new_s1;
428
+ − 341 struct buffer *mbuf;
+ − 342 Lisp_Object bufcons;
+ − 343
+ − 344 to = BUF_GPT_ADDR (buf);
+ − 345 from = to + BUF_GAP_SIZE (buf);
826
+ − 346 new_s1 = BYTE_BUF_GPT (buf);
428
+ − 347
+ − 348 /* Now copy the characters. To move the gap up,
+ − 349 copy characters down. */
+ − 350
+ − 351 while (1)
+ − 352 {
+ − 353 /* I gets number of characters left to copy. */
2367
+ − 354 i = bpos - new_s1;
428
+ − 355 if (i == 0)
+ − 356 break;
+ − 357 /* If a quit is requested, stop copying now.
2367
+ − 358 Change BPOS to be where we have actually moved the gap to. */
428
+ − 359 if (QUITP)
+ − 360 {
2367
+ − 361 bpos = new_s1;
+ − 362 cpos = bytebpos_to_charbpos (buf, bpos);
428
+ − 363 break;
+ − 364 }
+ − 365 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
+ − 366 if (i > GAP_MOVE_CHUNK)
+ − 367 i = GAP_MOVE_CHUNK;
440
+ − 368
2367
+ − 369 if (i >= 10) /* was 128 but memmove() should be extremely efficient
+ − 370 nowadays */
428
+ − 371 {
+ − 372 new_s1 += i;
+ − 373 memmove (to, from, i);
440
+ − 374 from += i;
+ − 375 to += i;
428
+ − 376 }
+ − 377 else
+ − 378 {
+ − 379 new_s1 += i;
+ − 380 while (--i >= 0)
+ − 381 *to++ = *from++;
+ − 382 }
+ − 383 }
+ − 384
+ − 385 {
+ − 386 int gsize = BUF_GAP_SIZE (buf);
+ − 387 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 388 {
2367
+ − 389 adjust_markers (mbuf, BYTE_BUF_GPT (mbuf) + gsize, bpos + gsize, - gsize);
428
+ − 390 }
+ − 391 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 392 {
826
+ − 393 adjust_extents (wrap_buffer (mbuf), BYTE_BUF_GPT (mbuf) + gsize,
2367
+ − 394 bpos + gsize, - gsize);
428
+ − 395 }
2367
+ − 396 SET_BOTH_BUF_GPT (buf, cpos, bpos);
428
+ − 397 SET_GAP_SENTINEL (buf);
+ − 398 #ifdef ERROR_CHECK_EXTENTS
+ − 399 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 400 {
771
+ − 401 sledgehammer_extent_check (wrap_buffer (mbuf));
428
+ − 402 }
+ − 403 #endif
+ − 404 }
2367
+ − 405 if (bpos == BYTE_BUF_Z (buf))
428
+ − 406 {
+ − 407 /* merge gap with end gap */
+ − 408
+ − 409 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + BUF_END_GAP_SIZE (buf));
+ − 410 SET_BUF_END_GAP_SIZE (buf, 0);
+ − 411 SET_END_SENTINEL (buf);
+ − 412 }
+ − 413
+ − 414 QUIT;
+ − 415 }
+ − 416
2367
+ − 417 /* Move gap to position `bpos'.
428
+ − 418 Note that this can quit! */
+ − 419
+ − 420 static void
2367
+ − 421 move_gap (struct buffer *buf, Charbpos cpos, Bytebpos bpos)
428
+ − 422 {
+ − 423 if (! BUF_BEG_ADDR (buf))
2500
+ − 424 ABORT ();
2367
+ − 425 if (bpos < BYTE_BUF_GPT (buf))
+ − 426 gap_left (buf, cpos, bpos);
+ − 427 else if (bpos > BYTE_BUF_GPT (buf))
+ − 428 gap_right (buf, cpos, bpos);
428
+ − 429 }
+ − 430
+ − 431 /* Merge the end gap into the gap */
+ − 432
+ − 433 static void
+ − 434 merge_gap_with_end_gap (struct buffer *buf)
+ − 435 {
+ − 436 Lisp_Object tem;
2367
+ − 437 Charbpos real_gap_loc_char;
+ − 438 Bytebpos real_gap_loc_byte;
428
+ − 439 Bytecount old_gap_size;
+ − 440 Bytecount increment;
+ − 441
+ − 442 increment = BUF_END_GAP_SIZE (buf);
+ − 443 SET_BUF_END_GAP_SIZE (buf, 0);
+ − 444
+ − 445 if (increment > 0)
+ − 446 {
+ − 447 /* Prevent quitting in move_gap. */
+ − 448 tem = Vinhibit_quit;
+ − 449 Vinhibit_quit = Qt;
+ − 450
2367
+ − 451 real_gap_loc_char = BUF_GPT (buf);
+ − 452 real_gap_loc_byte = BYTE_BUF_GPT (buf);
428
+ − 453 old_gap_size = BUF_GAP_SIZE (buf);
+ − 454
+ − 455 /* Pretend the end gap is the gap */
2367
+ − 456 SET_BOTH_BUF_GPT (buf, BUF_Z (buf) + BUF_GAP_SIZE (buf),
+ − 457 BYTE_BUF_Z (buf) + BUF_GAP_SIZE (buf));
428
+ − 458 SET_BUF_GAP_SIZE (buf, increment);
+ − 459
+ − 460 /* Move the new gap down to be consecutive with the end of the old one.
+ − 461 This adjusts the markers properly too. */
2367
+ − 462 gap_left (buf, real_gap_loc_char + old_gap_size,
+ − 463 real_gap_loc_byte + old_gap_size);
428
+ − 464
+ − 465 /* Now combine the two into one large gap. */
+ − 466 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
2367
+ − 467 SET_BOTH_BUF_GPT (buf, real_gap_loc_char, real_gap_loc_byte);
428
+ − 468 SET_GAP_SENTINEL (buf);
+ − 469
+ − 470 /* We changed the total size of the buffer (including gap),
+ − 471 so we need to fix up the end sentinel. */
+ − 472 SET_END_SENTINEL (buf);
+ − 473
+ − 474 Vinhibit_quit = tem;
+ − 475 }
+ − 476 }
+ − 477
+ − 478 /* Make the gap INCREMENT bytes longer. */
+ − 479
+ − 480 static void
+ − 481 make_gap (struct buffer *buf, Bytecount increment)
+ − 482 {
867
+ − 483 Ibyte *result;
428
+ − 484 Lisp_Object tem;
2367
+ − 485 Charbpos real_gap_loc_char;
+ − 486 Bytebpos real_gap_loc_byte;
428
+ − 487 Bytecount old_gap_size;
+ − 488
+ − 489 /* If we have to get more space, get enough to last a while. We use
+ − 490 a geometric progression that saves on realloc space. */
826
+ − 491 increment += 2000 + ((BYTE_BUF_Z (buf) - BYTE_BUF_BEG (buf)) / 8);
+ − 492 /* Make sure the gap is always aligned properly in case we're using a
+ − 493 16-bit or 32-bit fixed-width format. (Other sizes should already be
+ − 494 aligned in such a case.) */
+ − 495 increment = MAX_ALIGN_SIZE (increment);
428
+ − 496
+ − 497 if (increment > BUF_END_GAP_SIZE (buf))
+ − 498 {
+ − 499 /* Don't allow a buffer size that won't fit in an int
+ − 500 even if it will fit in a Lisp integer.
+ − 501 That won't work because so many places use `int'. */
+ − 502
+ − 503 if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment
+ − 504 > EMACS_INT_MAX)
563
+ − 505 out_of_memory ("Maximum buffer size exceeded", Qunbound);
428
+ − 506
+ − 507 result = BUFFER_REALLOC (buf->text->beg,
826
+ − 508 BYTE_BUF_Z (buf) - BYTE_BUF_BEG (buf) +
428
+ − 509 BUF_GAP_SIZE (buf) + increment +
+ − 510 BUF_END_SENTINEL_SIZE);
+ − 511 if (result == 0)
+ − 512 memory_full ();
+ − 513
+ − 514 SET_BUF_BEG_ADDR (buf, result);
+ − 515 }
+ − 516 else
+ − 517 increment = BUF_END_GAP_SIZE (buf);
+ − 518
+ − 519 /* Prevent quitting in move_gap. */
+ − 520 tem = Vinhibit_quit;
+ − 521 Vinhibit_quit = Qt;
+ − 522
2367
+ − 523 real_gap_loc_char = BUF_GPT (buf);
+ − 524 real_gap_loc_byte = BYTE_BUF_GPT (buf);
428
+ − 525 old_gap_size = BUF_GAP_SIZE (buf);
+ − 526
+ − 527 /* Call the newly allocated space a gap at the end of the whole space. */
2367
+ − 528 SET_BOTH_BUF_GPT (buf, BUF_Z (buf) + BUF_GAP_SIZE (buf),
+ − 529 BYTE_BUF_Z (buf) + BUF_GAP_SIZE (buf));
428
+ − 530 SET_BUF_GAP_SIZE (buf, increment);
+ − 531
+ − 532 SET_BUF_END_GAP_SIZE (buf, 0);
+ − 533
+ − 534 /* Move the new gap down to be consecutive with the end of the old one.
+ − 535 This adjusts the markers properly too. */
2367
+ − 536 gap_left (buf, real_gap_loc_char + old_gap_size,
+ − 537 real_gap_loc_byte + old_gap_size);
428
+ − 538
+ − 539 /* Now combine the two into one large gap. */
+ − 540 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
2367
+ − 541 SET_BOTH_BUF_GPT (buf, real_gap_loc_char, real_gap_loc_byte);
428
+ − 542 SET_GAP_SENTINEL (buf);
+ − 543
+ − 544 /* We changed the total size of the buffer (including gap),
+ − 545 so we need to fix up the end sentinel. */
+ − 546 SET_END_SENTINEL (buf);
+ − 547
+ − 548 Vinhibit_quit = tem;
+ − 549 }
+ − 550
+ − 551
+ − 552 /************************************************************************/
+ − 553 /* Before/after-change processing */
+ − 554 /************************************************************************/
+ − 555
+ − 556 /* Those magic changes ... */
+ − 557
+ − 558 static void
665
+ − 559 buffer_signal_changed_region (struct buffer *buf, Charbpos start,
+ − 560 Charbpos end)
428
+ − 561 {
+ − 562 /* The changed region is recorded as the number of unchanged
+ − 563 characters from the beginning and from the end of the
+ − 564 buffer. This obviates much of the need of shifting the
+ − 565 region around to compensate for insertions and deletions.
+ − 566 */
+ − 567 if (buf->changes->begin_unchanged < 0 ||
+ − 568 buf->changes->begin_unchanged > start - BUF_BEG (buf))
+ − 569 buf->changes->begin_unchanged = start - BUF_BEG (buf);
+ − 570 if (buf->changes->end_unchanged < 0 ||
+ − 571 buf->changes->end_unchanged > BUF_Z (buf) - end)
+ − 572 buf->changes->end_unchanged = BUF_Z (buf) - end;
+ − 573 }
+ − 574
+ − 575 void
665
+ − 576 buffer_extent_signal_changed_region (struct buffer *buf, Charbpos start,
+ − 577 Charbpos end)
428
+ − 578 {
+ − 579 if (buf->changes->begin_extent_unchanged < 0 ||
+ − 580 buf->changes->begin_extent_unchanged > start - BUF_BEG (buf))
+ − 581 buf->changes->begin_extent_unchanged = start - BUF_BEG (buf);
+ − 582 if (buf->changes->end_extent_unchanged < 0 ||
+ − 583 buf->changes->end_extent_unchanged > BUF_Z (buf) - end)
+ − 584 buf->changes->end_extent_unchanged = BUF_Z (buf) - end;
+ − 585 }
+ − 586
+ − 587 void
+ − 588 buffer_reset_changes (struct buffer *buf)
+ − 589 {
+ − 590 buf->changes->begin_unchanged = -1;
+ − 591 buf->changes->end_unchanged = -1;
+ − 592 buf->changes->begin_extent_unchanged = -1;
+ − 593 buf->changes->end_extent_unchanged = -1;
+ − 594 buf->changes->newline_was_deleted = 0;
+ − 595 }
+ − 596
+ − 597 static void
665
+ − 598 signal_after_change (struct buffer *buf, Charbpos start, Charbpos orig_end,
+ − 599 Charbpos new_end);
428
+ − 600
+ − 601
+ − 602 /* Call the after-change-functions according to the changes made so far
+ − 603 and treat all further changes as single until the outermost
+ − 604 multiple change exits. This is called when the outermost multiple
+ − 605 change exits and when someone is trying to make a change that violates
+ − 606 the constraints specified in begin_multiple_change(), typically
+ − 607 when nested multiple-change sessions occur. (There are smarter ways of
+ − 608 dealing with nested multiple changes, but these rarely occur so there's
+ − 609 probably no point in it.) */
+ − 610
+ − 611 /* #### This needs to keep track of what actually changed and only
+ − 612 call the after-change functions on that region. */
+ − 613
+ − 614 static void
+ − 615 cancel_multiple_change (struct buffer *buf)
+ − 616 {
+ − 617 /* This function can GC */
+ − 618 /* Call the after-change-functions except when they've already been
+ − 619 called or when there were no changes made to the buffer at all. */
+ − 620 if (buf->text->changes->mc_begin != 0 &&
+ − 621 buf->text->changes->mc_begin_signaled)
+ − 622 {
665
+ − 623 Charbpos real_mc_begin = buf->text->changes->mc_begin;
428
+ − 624 buf->text->changes->mc_begin = 0;
+ − 625
+ − 626 signal_after_change (buf, real_mc_begin, buf->text->changes->mc_orig_end,
+ − 627 buf->text->changes->mc_new_end);
+ − 628 }
+ − 629 else
+ − 630 {
+ − 631 buf->text->changes->mc_begin = 0;
+ − 632 }
+ − 633 }
+ − 634
+ − 635 /* this is an unwind_protect, to ensure that the after-change-functions
+ − 636 get called even in a non-local exit. */
+ − 637
+ − 638 static Lisp_Object
+ − 639 multiple_change_finish_up (Lisp_Object buffer)
+ − 640 {
+ − 641 struct buffer *buf = XBUFFER (buffer);
+ − 642
+ − 643 /* #### I don't know whether or not it should even be possible to
+ − 644 get here with a dead buffer (though given how it is called I can
+ − 645 see how it might be). In any case, there isn't time before 19.14
+ − 646 to find out. */
+ − 647 if (!BUFFER_LIVE_P (buf))
+ − 648 return Qnil;
+ − 649
+ − 650 /* This function can GC */
+ − 651 buf->text->changes->in_multiple_change = 0; /* do this first so that
+ − 652 errors in the after-change
+ − 653 functions don't mess things
+ − 654 up. */
+ − 655 cancel_multiple_change (buf);
+ − 656 return Qnil;
+ − 657 }
+ − 658
+ − 659 /* Call this function when you're about to make a number of buffer changes
+ − 660 that should be considered a single change. (e.g. `replace-match' calls
+ − 661 this.) You need to specify the START and END of the region that is
+ − 662 going to be changed so that the before-change-functions are called
+ − 663 with the correct arguments. The after-change region is calculated
+ − 664 automatically, however, and if changes somehow or other happen outside
+ − 665 of the specified region, that will also be handled correctly.
+ − 666
+ − 667 begin_multiple_change() returns a number (actually a specpdl depth)
438
+ − 668 that you must pass to end_multiple_change() when you are done.
+ − 669
+ − 670 FSF Emacs 20 implements a similar feature, accessible from Lisp
+ − 671 through a `combine-after-change-calls' special form, which is
+ − 672 essentially equivalent to this function. We should consider
+ − 673 whether we want to introduce a similar Lisp form. */
428
+ − 674
+ − 675 int
665
+ − 676 begin_multiple_change (struct buffer *buf, Charbpos start, Charbpos end)
428
+ − 677 {
+ − 678 /* This function can GC */
+ − 679 int count = -1;
+ − 680 if (buf->text->changes->in_multiple_change)
+ − 681 {
+ − 682 if (buf->text->changes->mc_begin != 0 &&
+ − 683 (start < buf->text->changes->mc_begin ||
+ − 684 end > buf->text->changes->mc_new_end))
+ − 685 cancel_multiple_change (buf);
+ − 686 }
+ − 687 else
+ − 688 {
+ − 689 Lisp_Object buffer;
+ − 690
+ − 691 buf->text->changes->mc_begin = start;
+ − 692 buf->text->changes->mc_orig_end = buf->text->changes->mc_new_end = end;
+ − 693 buf->text->changes->mc_begin_signaled = 0;
+ − 694 count = specpdl_depth ();
793
+ − 695 buffer = wrap_buffer (buf);
428
+ − 696 record_unwind_protect (multiple_change_finish_up, buffer);
+ − 697 }
+ − 698 buf->text->changes->in_multiple_change++;
+ − 699 /* We don't call before-change-functions until signal_before_change()
+ − 700 is called, in case there is a read-only or other error. */
+ − 701 return count;
+ − 702 }
+ − 703
+ − 704 void
+ − 705 end_multiple_change (struct buffer *buf, int count)
+ − 706 {
+ − 707 assert (buf->text->changes->in_multiple_change > 0);
+ − 708 buf->text->changes->in_multiple_change--;
+ − 709 if (!buf->text->changes->in_multiple_change)
771
+ − 710 unbind_to (count);
428
+ − 711 }
+ − 712
+ − 713 static int inside_change_hook;
+ − 714
+ − 715 static Lisp_Object
+ − 716 change_function_restore (Lisp_Object buffer)
+ − 717 {
+ − 718 /* We should first reset the variable and then change the buffer,
+ − 719 because Fset_buffer() can throw. */
+ − 720 inside_change_hook = 0;
438
+ − 721 if (XBUFFER (buffer) != current_buffer)
+ − 722 Fset_buffer (buffer);
428
+ − 723 return Qnil;
+ − 724 }
+ − 725
+ − 726 static int in_first_change;
+ − 727
+ − 728 static Lisp_Object
+ − 729 first_change_hook_restore (Lisp_Object buffer)
+ − 730 {
+ − 731 in_first_change = 0;
+ − 732 Fset_buffer (buffer);
+ − 733 return Qnil;
+ − 734 }
+ − 735
+ − 736 /* Signal an initial modification to the buffer. */
+ − 737
+ − 738 static void
+ − 739 signal_first_change (struct buffer *buf)
+ − 740 {
+ − 741 /* This function can GC */
793
+ − 742 Lisp_Object buffer = wrap_buffer (current_buffer);
+ − 743
428
+ − 744
+ − 745 if (!in_first_change)
+ − 746 {
+ − 747 if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
+ − 748 {
+ − 749 int speccount = specpdl_depth ();
+ − 750 record_unwind_protect (first_change_hook_restore, buffer);
+ − 751 set_buffer_internal (buf);
+ − 752 in_first_change = 1;
853
+ − 753 run_hook_trapping_problems
1333
+ − 754 (Qchange, Qfirst_change_hook,
853
+ − 755 INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION);
771
+ − 756 unbind_to (speccount);
428
+ − 757 }
+ − 758 }
+ − 759 }
+ − 760
+ − 761 /* Signal a change to the buffer immediately before it happens.
+ − 762 START and END are the bounds of the text to be changed. */
+ − 763
+ − 764 static void
665
+ − 765 signal_before_change (struct buffer *buf, Charbpos start, Charbpos end)
428
+ − 766 {
+ − 767 /* This function can GC */
+ − 768 struct buffer *mbuf;
+ − 769 Lisp_Object bufcons;
+ − 770
+ − 771 if (!inside_change_hook)
+ − 772 {
+ − 773 Lisp_Object buffer;
438
+ − 774 int speccount;
428
+ − 775
+ − 776 /* Are we in a multiple-change session? */
+ − 777 if (buf->text->changes->in_multiple_change &&
+ − 778 buf->text->changes->mc_begin != 0)
+ − 779 {
+ − 780 /* If we're violating the constraints of the session,
+ − 781 call the after-change-functions as necessary for the
+ − 782 changes already made and treat further changes as
+ − 783 single. */
+ − 784 if (start < buf->text->changes->mc_begin ||
+ − 785 end > buf->text->changes->mc_new_end)
+ − 786 cancel_multiple_change (buf);
+ − 787 /* Do nothing if this is not the first change in the session. */
+ − 788 else if (buf->text->changes->mc_begin_signaled)
+ − 789 return;
+ − 790 else
+ − 791 {
+ − 792 /* First time through; call the before-change-functions
+ − 793 specifying the entire region to be changed. (Note that
+ − 794 we didn't call before-change-functions in
+ − 795 begin_multiple_change() because the buffer might be
+ − 796 read-only, etc.) */
+ − 797 start = buf->text->changes->mc_begin;
+ − 798 end = buf->text->changes->mc_new_end;
+ − 799 }
+ − 800 }
+ − 801
+ − 802 /* If buffer is unmodified, run a special hook for that case. */
+ − 803 if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
+ − 804 {
+ − 805 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 806 {
+ − 807 signal_first_change (mbuf);
+ − 808 }
+ − 809 }
+ − 810
+ − 811 /* Now in any case run the before-change-functions if any. */
438
+ − 812 speccount = specpdl_depth ();
+ − 813 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ − 814 inside_change_hook = 1;
428
+ − 815
+ − 816 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 817 {
793
+ − 818 buffer = wrap_buffer (mbuf);
428
+ − 819 if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
+ − 820 /* Obsolete, for compatibility */
+ − 821 || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
+ − 822 {
+ − 823 set_buffer_internal (buf);
853
+ − 824 va_run_hook_with_args_trapping_problems
1333
+ − 825 (Qchange, Qbefore_change_functions, 2,
853
+ − 826 make_int (start), make_int (end),
+ − 827 INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION);
428
+ − 828 /* Obsolete, for compatibility */
853
+ − 829 va_run_hook_with_args_trapping_problems
1333
+ − 830 (Qchange, Qbefore_change_function, 2,
853
+ − 831 make_int (start), make_int (end),
+ − 832 INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION);
428
+ − 833 }
+ − 834 }
+ − 835
438
+ − 836 /* Make sure endpoints remain valid. before-change-functions
+ − 837 might have modified the buffer. */
+ − 838 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
+ − 839 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
+ − 840 if (end < BUF_BEGV (buf)) end = BUF_BEGV (buf);
+ − 841 if (end > BUF_ZV (buf)) end = BUF_ZV (buf);
+ − 842
428
+ − 843 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 844 {
826
+ − 845 report_extent_modification (wrap_buffer (mbuf), start, end, 0);
428
+ − 846 }
771
+ − 847 unbind_to (speccount);
428
+ − 848
+ − 849 /* Only now do we indicate that the before-change-functions have
+ − 850 been called, in case some function throws out. */
+ − 851 buf->text->changes->mc_begin_signaled = 1;
+ − 852 }
+ − 853 }
+ − 854
+ − 855 /* Signal a change immediately after it happens.
665
+ − 856 START is the charbpos of the start of the changed text.
+ − 857 ORIG_END is the charbpos of the end of the before-changed text.
+ − 858 NEW_END is the charbpos of the end of the after-changed text.
428
+ − 859 */
+ − 860
+ − 861 static void
665
+ − 862 signal_after_change (struct buffer *buf, Charbpos start, Charbpos orig_end,
+ − 863 Charbpos new_end)
428
+ − 864 {
+ − 865 /* This function can GC */
+ − 866 struct buffer *mbuf;
+ − 867 Lisp_Object bufcons;
+ − 868
+ − 869 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 870 {
+ − 871 /* always do this. */
+ − 872 buffer_signal_changed_region (mbuf, start, new_end);
+ − 873 }
826
+ − 874 #ifdef USE_C_FONT_LOCK
428
+ − 875 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 876 {
+ − 877 /* #### This seems inefficient. Wouldn't it be better to just
+ − 878 keep one cache per base buffer? */
+ − 879 font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
+ − 880 }
826
+ − 881 #endif /* USE_C_FONT_LOCK */
428
+ − 882
+ − 883 if (!inside_change_hook)
+ − 884 {
+ − 885 Lisp_Object buffer;
438
+ − 886 int speccount;
428
+ − 887
+ − 888 if (buf->text->changes->in_multiple_change &&
+ − 889 buf->text->changes->mc_begin != 0)
+ − 890 {
+ − 891 assert (start >= buf->text->changes->mc_begin &&
+ − 892 start <= buf->text->changes->mc_new_end);
+ − 893 assert (orig_end >= buf->text->changes->mc_begin &&
+ − 894 orig_end <= buf->text->changes->mc_new_end);
+ − 895 buf->text->changes->mc_new_end += new_end - orig_end;
+ − 896 return; /* after-change-functions signalled when all changes done */
+ − 897 }
+ − 898
438
+ − 899 speccount = specpdl_depth ();
+ − 900 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ − 901 inside_change_hook = 1;
428
+ − 902 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 903 {
793
+ − 904 buffer = wrap_buffer (mbuf);
428
+ − 905
+ − 906 if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
+ − 907 /* Obsolete, for compatibility */
+ − 908 || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
+ − 909 {
+ − 910 set_buffer_internal (buf);
+ − 911 /* The actual after-change functions take slightly
+ − 912 different arguments than what we were passed. */
853
+ − 913 va_run_hook_with_args_trapping_problems
1333
+ − 914 (Qchange, Qafter_change_functions, 3,
853
+ − 915 make_int (start), make_int (new_end),
+ − 916 make_int (orig_end - start),
+ − 917 INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION);
428
+ − 918 /* Obsolete, for compatibility */
853
+ − 919 va_run_hook_with_args_trapping_problems
1333
+ − 920 (Qchange, Qafter_change_function, 3,
853
+ − 921 make_int (start), make_int (new_end),
+ − 922 make_int (orig_end - start),
+ − 923 INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION);
428
+ − 924 }
+ − 925 }
+ − 926
438
+ − 927 /* Make sure endpoints remain valid. after-change-functions
+ − 928 might have modified the buffer. */
+ − 929 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
+ − 930 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
+ − 931 if (new_end < BUF_BEGV (buf)) new_end = BUF_BEGV (buf);
+ − 932 if (new_end > BUF_ZV (buf)) new_end = BUF_ZV (buf);
+ − 933 if (orig_end < BUF_BEGV (buf)) orig_end = BUF_BEGV (buf);
+ − 934 if (orig_end > BUF_ZV (buf)) orig_end = BUF_ZV (buf);
+ − 935
428
+ − 936 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 937 {
793
+ − 938 buffer = wrap_buffer (mbuf);
438
+ − 939 report_extent_modification (buffer, start, new_end, 1);
428
+ − 940 }
771
+ − 941 unbind_to (speccount); /* sets inside_change_hook back to 0 */
428
+ − 942 }
+ − 943 }
+ − 944
+ − 945 /* Call this if you're about to change the region of BUFFER from START
+ − 946 to END. This checks the read-only properties of the region, calls
+ − 947 the necessary modification hooks, and warns the next redisplay that
+ − 948 it should pay attention to that area. */
+ − 949
+ − 950 static void
665
+ − 951 prepare_to_modify_buffer (struct buffer *buf, Charbpos start, Charbpos end,
428
+ − 952 int lockit)
+ − 953 {
+ − 954 /* This function can GC */
+ − 955 /* dmoore - This function can also kill the buffer buf, the current
+ − 956 buffer, and do anything it pleases. So if you call it, be
+ − 957 careful. */
+ − 958 struct buffer *mbuf;
+ − 959 Lisp_Object buffer, bufcons;
+ − 960 struct gcpro gcpro1;
+ − 961
+ − 962 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 963 {
853
+ − 964 check_allowed_operation (OPERATION_MODIFY_BUFFER_TEXT,
+ − 965 wrap_buffer (mbuf), Qnil);
428
+ − 966 barf_if_buffer_read_only (mbuf, start, end);
+ − 967 }
+ − 968
+ − 969 /* if this is the first modification, see about locking the buffer's
+ − 970 file */
793
+ − 971 buffer = wrap_buffer (buf);
428
+ − 972 GCPRO1 (buffer);
+ − 973 if (!NILP (buf->filename) && lockit &&
+ − 974 BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
+ − 975 {
758
+ − 976 #ifdef CLASH_DETECTION
+ − 977 if (!NILP (buf->file_truename))
+ − 978 /* Make binding buffer-file-name to nil effective. */
+ − 979 lock_file (buf->file_truename);
+ − 980 #else
428
+ − 981 /* At least warn if this file has changed on disk since it was visited.*/
+ − 982 if (NILP (Fverify_visited_file_modtime (buffer))
+ − 983 && !NILP (Ffile_exists_p (buf->filename)))
+ − 984 call1_in_buffer (buf, intern ("ask-user-about-supersession-threat"),
+ − 985 buf->filename);
+ − 986 #endif /* not CLASH_DETECTION */
+ − 987 }
+ − 988 UNGCPRO;
+ − 989
+ − 990 /* #### dmoore - is this reasonable in case of buf being killed above? */
+ − 991 if (!BUFFER_LIVE_P (buf))
+ − 992 return;
+ − 993
+ − 994 signal_before_change (buf, start, end);
+ − 995
+ − 996 #ifdef REGION_CACHE_NEEDS_WORK
+ − 997 if (buf->newline_cache)
+ − 998 invalidate_region_cache (buf,
+ − 999 buf->newline_cache,
+ − 1000 start - BUF_BEG (buf), BUF_Z (buf) - end);
+ − 1001 if (buf->width_run_cache)
+ − 1002 invalidate_region_cache (buf,
+ − 1003 buf->width_run_cache,
+ − 1004 start - BUF_BEG (buf), BUF_Z (buf) - end);
+ − 1005 #endif
+ − 1006
+ − 1007 #if 0 /* FSFmacs */
+ − 1008 Vdeactivate_mark = Qt;
+ − 1009 #endif
+ − 1010
+ − 1011 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1012 {
+ − 1013 mbuf->point_before_scroll = Qnil;
+ − 1014 }
+ − 1015 }
+ − 1016
+ − 1017
+ − 1018 /************************************************************************/
+ − 1019 /* Insertion of strings */
+ − 1020 /************************************************************************/
+ − 1021
+ − 1022 void
867
+ − 1023 fixup_internal_substring (const Ibyte *nonreloc, Lisp_Object reloc,
428
+ − 1024 Bytecount offset, Bytecount *len)
+ − 1025 {
+ − 1026 assert ((nonreloc && NILP (reloc)) || (!nonreloc && STRINGP (reloc)));
+ − 1027
+ − 1028 if (*len < 0)
+ − 1029 {
+ − 1030 if (nonreloc)
442
+ − 1031 *len = strlen ((const char *) nonreloc) - offset;
428
+ − 1032 else
+ − 1033 *len = XSTRING_LENGTH (reloc) - offset;
+ − 1034 }
800
+ − 1035 #ifdef ERROR_CHECK_TEXT
428
+ − 1036 assert (*len >= 0);
+ − 1037 if (STRINGP (reloc))
+ − 1038 {
+ − 1039 assert (offset >= 0 && offset <= XSTRING_LENGTH (reloc));
+ − 1040 assert (offset + *len <= XSTRING_LENGTH (reloc));
+ − 1041 }
+ − 1042 #endif
+ − 1043 }
+ − 1044
665
+ − 1045 /* Insert a string into BUF at Charbpos POS. The string data comes
428
+ − 1046 from one of two sources: constant, non-relocatable data (specified
+ − 1047 in NONRELOC), or a Lisp string object (specified in RELOC), which
+ − 1048 is relocatable and may have extent data that needs to be copied
+ − 1049 into the buffer. OFFSET and LENGTH specify the substring of the
+ − 1050 data that is actually to be inserted. As a special case, if POS
+ − 1051 is -1, insert the string at point and move point to the end of the
+ − 1052 string.
+ − 1053
+ − 1054 Normally, markers at the insertion point end up before the
+ − 1055 inserted string. If INSDEL_BEFORE_MARKERS is set in flags, however,
+ − 1056 they end up after the string.
+ − 1057
+ − 1058 INSDEL_NO_LOCKING is kludgy and is used when insert-file-contents is
+ − 1059 visiting a new file; it inhibits the locking checks normally done
+ − 1060 before modifying a buffer. Similar checks were already done
+ − 1061 in the higher-level Lisp functions calling insert-file-contents. */
+ − 1062
+ − 1063 Charcount
665
+ − 1064 buffer_insert_string_1 (struct buffer *buf, Charbpos pos,
867
+ − 1065 const Ibyte *nonreloc, Lisp_Object reloc,
428
+ − 1066 Bytecount offset, Bytecount length,
+ − 1067 int flags)
+ − 1068 {
+ − 1069 /* This function can GC */
+ − 1070 struct gcpro gcpro1;
826
+ − 1071 Bytebpos bytepos;
+ − 1072 Bytecount length_in_buffer;
428
+ − 1073 Charcount cclen;
+ − 1074 int move_point = 0;
+ − 1075 struct buffer *mbuf;
+ − 1076 Lisp_Object bufcons;
+ − 1077
+ − 1078 /* Defensive steps just in case a buffer gets deleted and a calling
+ − 1079 function doesn't notice it. */
+ − 1080 if (!BUFFER_LIVE_P (buf))
+ − 1081 return 0;
+ − 1082
+ − 1083 fixup_internal_substring (nonreloc, reloc, offset, &length);
+ − 1084
+ − 1085 if (pos == -1)
+ − 1086 {
+ − 1087 pos = BUF_PT (buf);
+ − 1088 move_point = 1;
+ − 1089 }
+ − 1090
+ − 1091 #ifdef I18N3
+ − 1092 /* #### See the comment in print_internal(). If this buffer is marked
+ − 1093 as translatable, then Fgettext() should be called on obj if it
+ − 1094 is a string. */
+ − 1095 #endif
+ − 1096
+ − 1097 /* Make sure that point-max won't exceed the size of an emacs int. */
+ − 1098 if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
563
+ − 1099 out_of_memory ("Maximum buffer size exceeded", Qunbound);
428
+ − 1100
+ − 1101 /* theoretically not necessary -- caller should GCPRO.
+ − 1102 #### buffer_insert_from_buffer_1() doesn't! */
+ − 1103 GCPRO1 (reloc);
+ − 1104
+ − 1105 prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
+ − 1106
+ − 1107 /* Defensive steps in case the before-change-functions fuck around */
+ − 1108 if (!BUFFER_LIVE_P (buf))
+ − 1109 {
+ − 1110 UNGCPRO;
+ − 1111 /* Bad bad pre-change function. */
+ − 1112 return 0;
+ − 1113 }
+ − 1114
+ − 1115 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 1116 modified the buffer. */
+ − 1117 if (pos < BUF_BEGV (buf))
+ − 1118 pos = BUF_BEGV (buf);
+ − 1119 if (pos > BUF_ZV (buf))
+ − 1120 pos = BUF_ZV (buf);
+ − 1121
826
+ − 1122 bytepos = charbpos_to_bytebpos (buf, pos);
771
+ − 1123
428
+ − 1124 /* string may have been relocated up to this point */
+ − 1125 if (STRINGP (reloc))
771
+ − 1126 {
793
+ − 1127 cclen = string_offset_byte_to_char_len (reloc, offset, length);
771
+ − 1128 nonreloc = XSTRING_DATA (reloc);
+ − 1129 }
+ − 1130 else
+ − 1131 cclen = bytecount_to_charcount (nonreloc + offset, length);
826
+ − 1132 /* &&#### Here we check if the text can't fit into the format of the buffer,
+ − 1133 and if so convert it to another format (either default or 32-bit-fixed,
+ − 1134 according to some flag; if no flag, use default). */
+ − 1135
+ − 1136 length_in_buffer = copy_text_between_formats (nonreloc + offset, length,
+ − 1137 FORMAT_DEFAULT,
+ − 1138 STRINGP (reloc) ? reloc : Qnil,
+ − 1139 NULL, 0,
+ − 1140 BUF_FORMAT (buf),
+ − 1141 wrap_buffer (buf),
+ − 1142 NULL);
428
+ − 1143
826
+ − 1144 if (bytepos != BYTE_BUF_GPT (buf))
428
+ − 1145 /* #### if debug-on-quit is invoked and the user changes the
+ − 1146 buffer, bad things can happen. This is a rampant problem
+ − 1147 in Emacs. */
2367
+ − 1148 move_gap (buf, pos, bytepos); /* may QUIT */
826
+ − 1149 if (! GAP_CAN_HOLD_SIZE_P (buf, length_in_buffer))
428
+ − 1150 {
826
+ − 1151 if (BUF_END_GAP_SIZE (buf) >= length_in_buffer)
428
+ − 1152 merge_gap_with_end_gap (buf);
+ − 1153 else
826
+ − 1154 make_gap (buf, length_in_buffer - BUF_GAP_SIZE (buf));
428
+ − 1155 }
+ − 1156
826
+ − 1157 /* At this point, no more QUITting or processing of Lisp code. Buffer is
+ − 1158 in a consistent state. Following code puts buffer in an inconsistent
+ − 1159 state and can be considered a "critical section". */
+ − 1160
428
+ − 1161 insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
+ − 1162
+ − 1163 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1164 {
+ − 1165 record_insert (mbuf, pos, cclen);
+ − 1166 }
+ − 1167
+ − 1168 BUF_MODIFF (buf)++;
+ − 1169 MARK_BUFFERS_CHANGED;
+ − 1170
826
+ − 1171 /* string may have been relocated up to this point #### if string is
+ − 1172 modified during quit processing, bad things can happen. */
428
+ − 1173 if (STRINGP (reloc))
+ − 1174 nonreloc = XSTRING_DATA (reloc);
+ − 1175
853
+ − 1176 memcpy (BUF_GPT_ADDR (buf), nonreloc + offset, length);
+ − 1177
826
+ − 1178 copy_text_between_formats (nonreloc + offset, length, FORMAT_DEFAULT,
+ − 1179 STRINGP (reloc) ? reloc : Qnil,
+ − 1180 BUF_GPT_ADDR (buf), length_in_buffer,
+ − 1181 BUF_FORMAT (buf), wrap_buffer (buf), NULL);
+ − 1182
+ − 1183 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length_in_buffer);
2367
+ − 1184 SET_BOTH_BUF_GPT (buf, BUF_GPT (buf) + cclen,
+ − 1185 BYTE_BUF_GPT (buf) + length_in_buffer);
428
+ − 1186 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1187 {
826
+ − 1188 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen,
+ − 1189 BYTE_BUF_ZV (mbuf) + length_in_buffer);
428
+ − 1190 }
826
+ − 1191 SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BYTE_BUF_Z (buf) + length_in_buffer);
428
+ − 1192 SET_GAP_SENTINEL (buf);
771
+ − 1193
+ − 1194
428
+ − 1195 #ifdef MULE
826
+ − 1196 buffer_mule_signal_inserted_region (buf, pos, length_in_buffer, cclen);
+ − 1197 /* Update our count of ASCII, 8-bit and 16-bit chars and the
+ − 1198 entirely-one-byte flag */
+ − 1199 {
867
+ − 1200 const Ibyte *ptr = nonreloc + offset;
+ − 1201 const Ibyte *ptrend = ptr + length;
826
+ − 1202
+ − 1203 while (ptr < ptrend)
+ − 1204 {
867
+ − 1205 Ichar ch = itext_ichar (ptr);
+ − 1206 if (ichar_ascii_p (ch))
826
+ − 1207 buf->text->num_ascii_chars++;
867
+ − 1208 if (ichar_8_bit_fixed_p (ch, wrap_buffer (buf)))
826
+ − 1209 buf->text->num_8_bit_fixed_chars++;
867
+ − 1210 if (ichar_16_bit_fixed_p (ch, wrap_buffer (buf)))
826
+ − 1211 buf->text->num_16_bit_fixed_chars++;
867
+ − 1212 INC_IBYTEPTR (ptr);
826
+ − 1213 }
+ − 1214
+ − 1215 buf->text->entirely_one_byte_p =
+ − 1216 (BUF_FORMAT (buf) == FORMAT_8_BIT_FIXED ||
+ − 1217 (BUF_FORMAT (buf) == FORMAT_DEFAULT && BUF_Z (buf) == BYTE_BUF_Z (buf)));
+ − 1218 }
428
+ − 1219 #endif
+ − 1220
+ − 1221 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1222 {
826
+ − 1223 process_extents_for_insertion (wrap_buffer (mbuf), bytepos,
+ − 1224 length_in_buffer);
428
+ − 1225 }
+ − 1226
+ − 1227 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1228 {
826
+ − 1229 /* We know the gap is at BYTEPOS so the cast is OK. */
+ − 1230 adjust_markers_for_insert (mbuf, (Membpos) bytepos, length_in_buffer);
428
+ − 1231 }
+ − 1232
+ − 1233 /* Point logically doesn't move, but may need to be adjusted because
+ − 1234 it's a byte index. point-marker doesn't change because it's a
+ − 1235 memory index. */
+ − 1236 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1237 {
826
+ − 1238 if (BYTE_BUF_PT (mbuf) > bytepos)
428
+ − 1239 JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
826
+ − 1240 BYTE_BUF_PT (mbuf) + length_in_buffer);
428
+ − 1241 }
+ − 1242
+ − 1243 /* Well, point might move. */
+ − 1244 if (move_point)
826
+ − 1245 BYTE_BUF_SET_PT (buf, bytepos + length_in_buffer);
428
+ − 1246
+ − 1247 if (STRINGP (reloc))
+ − 1248 {
+ − 1249 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1250 {
826
+ − 1251 splice_in_string_extents (reloc, mbuf, bytepos, length, offset);
428
+ − 1252 }
+ − 1253 }
+ − 1254
+ − 1255 if (flags & INSDEL_BEFORE_MARKERS)
+ − 1256 {
+ − 1257 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1258 {
826
+ − 1259 /* bytepos - 1 is correct because the FROM argument is exclusive.
665
+ − 1260 I formerly used DEC_BYTEBPOS() but that caused problems at the
428
+ − 1261 beginning of the buffer. */
826
+ − 1262 adjust_markers (mbuf, bytepos - 1, bytepos, length_in_buffer);
428
+ − 1263 }
+ − 1264 }
+ − 1265
826
+ − 1266 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1267 {
3250
+ − 1268 signal_syntax_cache_extent_adjust (mbuf);
826
+ − 1269 }
+ − 1270
428
+ − 1271 signal_after_change (buf, pos, pos, pos + cclen);
+ − 1272
+ − 1273 UNGCPRO;
+ − 1274
+ − 1275 return cclen;
+ − 1276 }
+ − 1277
+ − 1278
+ − 1279 /* The following functions are interfaces onto the above function,
+ − 1280 for inserting particular sorts of data. In all the functions,
+ − 1281 BUF and POS specify the buffer and location where the insertion is
+ − 1282 to take place. (If POS is -1, text is inserted at point and point
+ − 1283 moves forward past the text.) FLAGS is as above. */
+ − 1284
+ − 1285 Charcount
665
+ − 1286 buffer_insert_raw_string_1 (struct buffer *buf, Charbpos pos,
867
+ − 1287 const Ibyte *nonreloc, Bytecount length,
428
+ − 1288 int flags)
+ − 1289 {
+ − 1290 /* This function can GC */
+ − 1291 return buffer_insert_string_1 (buf, pos, nonreloc, Qnil, 0, length,
+ − 1292 flags);
+ − 1293 }
+ − 1294
+ − 1295 Charcount
665
+ − 1296 buffer_insert_lisp_string_1 (struct buffer *buf, Charbpos pos, Lisp_Object str,
428
+ − 1297 int flags)
+ − 1298 {
+ − 1299 /* This function can GC */
+ − 1300 return buffer_insert_string_1 (buf, pos, 0, str, 0,
+ − 1301 XSTRING_LENGTH (str),
+ − 1302 flags);
+ − 1303 }
+ − 1304
+ − 1305 /* Insert the null-terminated string S (in external format). */
+ − 1306
+ − 1307 Charcount
665
+ − 1308 buffer_insert_c_string_1 (struct buffer *buf, Charbpos pos, const char *s,
428
+ − 1309 int flags)
+ − 1310 {
+ − 1311 /* This function can GC */
442
+ − 1312 const char *translated = GETTEXT (s);
867
+ − 1313 return buffer_insert_string_1 (buf, pos, (const Ibyte *) translated, Qnil,
428
+ − 1314 0, strlen (translated), flags);
+ − 1315 }
+ − 1316
+ − 1317 Charcount
867
+ − 1318 buffer_insert_emacs_char_1 (struct buffer *buf, Charbpos pos, Ichar ch,
428
+ − 1319 int flags)
+ − 1320 {
+ − 1321 /* This function can GC */
867
+ − 1322 Ibyte str[MAX_ICHAR_LEN];
+ − 1323 Bytecount len = set_itext_ichar (str, ch);
428
+ − 1324 return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
+ − 1325 }
+ − 1326
+ − 1327 Charcount
665
+ − 1328 buffer_insert_c_char_1 (struct buffer *buf, Charbpos pos, char c,
428
+ − 1329 int flags)
+ − 1330 {
+ − 1331 /* This function can GC */
867
+ − 1332 return buffer_insert_emacs_char_1 (buf, pos, (Ichar) (unsigned char) c,
428
+ − 1333 flags);
+ − 1334 }
+ − 1335
+ − 1336 Charcount
665
+ − 1337 buffer_insert_from_buffer_1 (struct buffer *buf, Charbpos pos,
+ − 1338 struct buffer *buf2, Charbpos pos2,
428
+ − 1339 Charcount length, int flags)
+ − 1340 {
+ − 1341 /* This function can GC */
+ − 1342 Lisp_Object str = make_string_from_buffer (buf2, pos2, length);
+ − 1343 return buffer_insert_string_1 (buf, pos, 0, str, 0,
+ − 1344 XSTRING_LENGTH (str), flags);
+ − 1345 }
+ − 1346
+ − 1347
+ − 1348 /************************************************************************/
+ − 1349 /* Deletion of ranges */
+ − 1350 /************************************************************************/
+ − 1351
+ − 1352 /* Delete characters in buffer from FROM up to (but not including) TO. */
+ − 1353
+ − 1354 void
665
+ − 1355 buffer_delete_range (struct buffer *buf, Charbpos from, Charbpos to, int flags)
428
+ − 1356 {
+ − 1357 /* This function can GC */
+ − 1358 Charcount numdel;
826
+ − 1359 Bytebpos byte_from, byte_to;
+ − 1360 Bytecount byte_numdel;
428
+ − 1361 EMACS_INT shortage;
+ − 1362 struct buffer *mbuf;
+ − 1363 Lisp_Object bufcons;
826
+ − 1364 int do_move_gap = 0;
428
+ − 1365
+ − 1366 /* Defensive steps just in case a buffer gets deleted and a calling
+ − 1367 function doesn't notice it. */
+ − 1368 if (!BUFFER_LIVE_P (buf))
+ − 1369 return;
+ − 1370
+ − 1371 /* Make args be valid */
+ − 1372 if (from < BUF_BEGV (buf))
+ − 1373 from = BUF_BEGV (buf);
+ − 1374 if (to > BUF_ZV (buf))
+ − 1375 to = BUF_ZV (buf);
+ − 1376 if ((numdel = to - from) <= 0)
+ − 1377 return;
+ − 1378
+ − 1379 prepare_to_modify_buffer (buf, from, to, !(flags & INSDEL_NO_LOCKING));
+ − 1380
+ − 1381 /* Defensive steps in case the before-change-functions fuck around */
+ − 1382 if (!BUFFER_LIVE_P (buf))
+ − 1383 /* Bad bad pre-change function. */
+ − 1384 return;
+ − 1385
+ − 1386 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 1387 modified the buffer. */
+ − 1388 if (from < BUF_BEGV (buf))
+ − 1389 from = BUF_BEGV (buf);
+ − 1390 if (to > BUF_ZV (buf))
+ − 1391 to = BUF_ZV (buf);
+ − 1392 if ((numdel = to - from) <= 0)
+ − 1393 return;
+ − 1394
826
+ − 1395 byte_from = charbpos_to_bytebpos (buf, from);
+ − 1396 byte_to = charbpos_to_bytebpos (buf, to);
+ − 1397 byte_numdel = byte_to - byte_from;
+ − 1398
+ − 1399 if (to == BUF_Z (buf) &&
+ − 1400 byte_from > BYTE_BUF_GPT (buf))
+ − 1401 /* avoid moving the gap just to delete from the bottom. */
+ − 1402 do_move_gap = 0;
+ − 1403 else
+ − 1404 {
+ − 1405 /* Make sure the gap is somewhere in or next to what we are deleting. */
+ − 1406 /* NOTE: Can QUIT! */
+ − 1407 if (byte_to < BYTE_BUF_GPT (buf))
2367
+ − 1408 gap_left (buf, to, byte_to);
826
+ − 1409 if (byte_from > BYTE_BUF_GPT (buf))
2367
+ − 1410 gap_right (buf, from, byte_from);
826
+ − 1411 do_move_gap = 1;
+ − 1412 }
+ − 1413
+ − 1414 /* At this point, no more QUITting or processing of Lisp code. Buffer is
+ − 1415 in a consistent state. Following code puts buffer in an inconsistent
+ − 1416 state and can be considered a "critical section". */
+ − 1417
+ − 1418 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1419 {
+ − 1420 record_delete (mbuf, from, numdel);
+ − 1421 }
+ − 1422 BUF_MODIFF (buf)++;
+ − 1423 MARK_BUFFERS_CHANGED;
+ − 1424
+ − 1425 /* We used to do the following before the gap move. But that might QUIT,
+ − 1426 and (as a result of this) the gap code always leaves the buffer in
+ − 1427 a consistent state. Therefore, it's totally safe to do these operations
+ − 1428 now, and just as well not before, as we're making state changes
+ − 1429 related to the deletion. */
+ − 1430
428
+ − 1431 /* Redisplay needs to know if a newline was in the deleted region.
+ − 1432 If we've already marked the changed region as having a deleted
+ − 1433 newline there is no use in performing the check. */
+ − 1434 if (!buf->changes->newline_was_deleted)
+ − 1435 {
+ − 1436 scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
+ − 1437 if (!shortage)
+ − 1438 {
+ − 1439 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1440 {
+ − 1441 mbuf->changes->newline_was_deleted = 1;
+ − 1442 }
+ − 1443 }
+ − 1444 }
+ − 1445
+ − 1446 delete_invalidate_line_number_cache (buf, from, to);
+ − 1447
826
+ − 1448 #ifdef MULE
+ − 1449 /* Update our count of ASCII, 8-bit and 16-bit chars and the
+ − 1450 entirely-one-byte flag */
+ − 1451 {
+ − 1452 Bytebpos i;
428
+ − 1453
826
+ − 1454 for (i = byte_from; i < byte_to; i = next_bytebpos (buf, i))
+ − 1455 {
867
+ − 1456 Ichar ch = BYTE_BUF_FETCH_CHAR (buf, i);
+ − 1457 if (ichar_ascii_p (ch))
826
+ − 1458 buf->text->num_ascii_chars--;
867
+ − 1459 if (ichar_8_bit_fixed_p (ch, wrap_buffer (buf)))
826
+ − 1460 buf->text->num_8_bit_fixed_chars--;
867
+ − 1461 if (ichar_16_bit_fixed_p (ch, wrap_buffer (buf)))
826
+ − 1462 buf->text->num_16_bit_fixed_chars--;
+ − 1463 }
+ − 1464 }
+ − 1465 #endif /* MULE */
428
+ − 1466
826
+ − 1467 /* #### Point used to be modified here, but this causes problems
+ − 1468 with MULE, as point is used to calculate bytebpos's, and if the
+ − 1469 offset in byte_numdel causes point to move to a non first-byte
+ − 1470 location, causing some other function to throw an assertion
+ − 1471 in ASSERT_VALID_BYTEBPOS. I've moved the code to right after
+ − 1472 the other movements and adjustments, but before the gap is
+ − 1473 moved. -- jh 970813 */
428
+ − 1474
826
+ − 1475 /* Detach any extents that are completely within the range [FROM, TO],
+ − 1476 if the extents are detachable.
+ − 1477
+ − 1478 This must come AFTER record_delete(), so that the appropriate extents
+ − 1479 will be present to be recorded, and BEFORE the gap size is increased,
+ − 1480 as otherwise we will be confused about where the extents end. */
+ − 1481 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1482 {
+ − 1483 process_extents_for_deletion (wrap_buffer (mbuf), byte_from, byte_to, 0);
428
+ − 1484 }
+ − 1485
826
+ − 1486 /* Relocate all markers pointing into the new, larger gap to
+ − 1487 point at the end of the text before the gap. */
+ − 1488 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1489 {
+ − 1490 adjust_markers (mbuf,
+ − 1491 (byte_to + BUF_GAP_SIZE (mbuf)),
+ − 1492 (byte_to + BUF_GAP_SIZE (mbuf)),
+ − 1493 (- byte_numdel -
+ − 1494 (do_move_gap ? BUF_GAP_SIZE (mbuf) : 0)));
+ − 1495 }
+ − 1496
+ − 1497 /* Relocate any extent endpoints just like markers. */
+ − 1498 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1499 {
+ − 1500 adjust_extents_for_deletion (wrap_buffer (mbuf), byte_from, byte_to,
+ − 1501 BUF_GAP_SIZE (mbuf),
+ − 1502 byte_numdel,
+ − 1503 do_move_gap ? BUF_GAP_SIZE (mbuf) : 0);
+ − 1504 }
+ − 1505
+ − 1506 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1507 {
+ − 1508 /* Relocate point as if it were a marker. */
+ − 1509 if (byte_from < BYTE_BUF_PT (mbuf))
+ − 1510 {
+ − 1511 if (BYTE_BUF_PT (mbuf) < byte_to)
+ − 1512 JUST_SET_POINT (mbuf, from, byte_from);
+ − 1513 else
+ − 1514 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+ − 1515 BYTE_BUF_PT (mbuf) - byte_numdel);
+ − 1516 }
+ − 1517 }
+ − 1518
+ − 1519 if (do_move_gap)
+ − 1520 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + byte_numdel);
+ − 1521 else
+ − 1522 SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + byte_numdel);
+ − 1523 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1524 {
+ − 1525 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+ − 1526 BYTE_BUF_ZV (mbuf) - byte_numdel);
+ − 1527 }
+ − 1528 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BYTE_BUF_Z (buf) - byte_numdel);
+ − 1529 if (do_move_gap)
2367
+ − 1530 SET_BOTH_BUF_GPT (buf, from, byte_from);
826
+ − 1531 SET_GAP_SENTINEL (buf);
+ − 1532
428
+ − 1533 #ifdef MULE
826
+ − 1534 buffer_mule_signal_deleted_region (buf, from, to, byte_from, byte_to);
+ − 1535 buf->text->entirely_one_byte_p =
+ − 1536 (BUF_FORMAT (buf) == FORMAT_8_BIT_FIXED ||
+ − 1537 (BUF_FORMAT (buf) == FORMAT_DEFAULT && BUF_Z (buf) == BYTE_BUF_Z (buf)));
428
+ − 1538 #endif
+ − 1539
+ − 1540 #ifdef ERROR_CHECK_EXTENTS
+ − 1541 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1542 {
771
+ − 1543 sledgehammer_extent_check (wrap_buffer (mbuf));
428
+ − 1544 }
+ − 1545 #endif
+ − 1546
826
+ − 1547 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1548 {
3250
+ − 1549 signal_syntax_cache_extent_adjust (mbuf);
826
+ − 1550 }
+ − 1551
+ − 1552 /* &&#### Here we consider converting the buffer from default to
+ − 1553 8-bit-fixed if is entirely 8-bit-fixed chars and has been that way for
+ − 1554 a long time, e.g. 20 minutes. And if the buffer just switched to all
+ − 1555 8-bit-fixed chars, start the timer. */
428
+ − 1556 signal_after_change (buf, from, to, from);
+ − 1557 }
+ − 1558
+ − 1559
+ − 1560 /************************************************************************/
+ − 1561 /* Replacement of characters */
+ − 1562 /************************************************************************/
+ − 1563
+ − 1564 /* Replace the character at POS in buffer B with CH. */
+ − 1565
+ − 1566 void
867
+ − 1567 buffer_replace_char (struct buffer *buf, Charbpos pos, Ichar ch,
428
+ − 1568 int not_real_change, int force_lock_check)
+ − 1569 {
+ − 1570 /* This function can GC */
867
+ − 1571 Ibyte newstr[MAX_ICHAR_LEN];
826
+ − 1572 Bytecount newlen;
867
+ − 1573 Ichar oldch;
428
+ − 1574
+ − 1575 /* Defensive steps just in case a buffer gets deleted and a calling
+ − 1576 function doesn't notice it. */
+ − 1577 if (!BUFFER_LIVE_P (buf))
+ − 1578 return;
+ − 1579
867
+ − 1580 newlen = set_itext_ichar_fmt (newstr, ch, BUF_FORMAT (buf),
826
+ − 1581 wrap_buffer (buf));
+ − 1582 oldch = BUF_FETCH_CHAR (buf, pos);
867
+ − 1583 if (ichar_fits_in_format (ch, BUF_FORMAT (buf), wrap_buffer (buf)) &&
+ − 1584 newlen == ichar_len_fmt (oldch, BUF_FORMAT (buf)))
428
+ − 1585 {
+ − 1586 struct buffer *mbuf;
+ − 1587 Lisp_Object bufcons;
+ − 1588
+ − 1589 /* then we can just replace the text. */
+ − 1590 prepare_to_modify_buffer (buf, pos, pos + 1,
+ − 1591 !not_real_change || force_lock_check);
+ − 1592 /* Defensive steps in case the before-change-functions fuck around */
+ − 1593 if (!BUFFER_LIVE_P (buf))
+ − 1594 /* Bad bad pre-change function. */
+ − 1595 return;
+ − 1596
+ − 1597 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 1598 modified the buffer. */
+ − 1599 if (pos < BUF_BEGV (buf))
+ − 1600 pos = BUF_BEGV (buf);
+ − 1601 if (pos >= BUF_ZV (buf))
+ − 1602 pos = BUF_ZV (buf) - 1;
+ − 1603 if (pos < BUF_BEGV (buf))
+ − 1604 /* no more characters in buffer! */
+ − 1605 return;
+ − 1606
+ − 1607 if (BUF_FETCH_CHAR (buf, pos) == '\n')
+ − 1608 {
+ − 1609 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1610 {
+ − 1611 mbuf->changes->newline_was_deleted = 1;
+ − 1612 }
+ − 1613 }
+ − 1614 MARK_BUFFERS_CHANGED;
+ − 1615 if (!not_real_change)
+ − 1616 {
+ − 1617 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ − 1618 {
+ − 1619 record_change (mbuf, pos, 1);
+ − 1620 }
+ − 1621 BUF_MODIFF (buf)++;
+ − 1622 }
826
+ − 1623
+ − 1624 #ifdef MULE
867
+ − 1625 if (ichar_ascii_p (oldch))
826
+ − 1626 buf->text->num_ascii_chars--;
867
+ − 1627 if (ichar_8_bit_fixed_p (oldch, wrap_buffer (buf)))
826
+ − 1628 buf->text->num_8_bit_fixed_chars--;
867
+ − 1629 if (ichar_16_bit_fixed_p (oldch, wrap_buffer (buf)))
826
+ − 1630 buf->text->num_16_bit_fixed_chars--;
867
+ − 1631 if (ichar_ascii_p (ch))
826
+ − 1632 buf->text->num_ascii_chars++;
867
+ − 1633 if (ichar_8_bit_fixed_p (ch, wrap_buffer (buf)))
826
+ − 1634 buf->text->num_8_bit_fixed_chars++;
867
+ − 1635 if (ichar_16_bit_fixed_p (ch, wrap_buffer (buf)))
826
+ − 1636 buf->text->num_16_bit_fixed_chars++;
+ − 1637 #endif /* MULE */
+ − 1638
428
+ − 1639 memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
+ − 1640
+ − 1641 signal_after_change (buf, pos, pos + 1, pos + 1);
+ − 1642
+ − 1643 /* We do not have to adjust the Mule data; we just replaced a
+ − 1644 character with another of the same number of bytes. */
+ − 1645 }
+ − 1646 else
+ − 1647 {
+ − 1648 /*
+ − 1649 * Must implement as deletion followed by insertion.
+ − 1650 *
+ − 1651 * Make a note to move point forward later in the one situation
+ − 1652 * where it is needed, a delete/insert one position behind
+ − 1653 * point. Point will drift backward by one position and stay
+ − 1654 * there otherwise.
+ − 1655 */
+ − 1656 int movepoint = (pos == BUF_PT (buf) - 1);
+ − 1657
+ − 1658 buffer_delete_range (buf, pos, pos + 1, 0);
+ − 1659 /* Defensive steps in case the before-change-functions fuck around */
+ − 1660 if (!BUFFER_LIVE_P (buf))
+ − 1661 /* Bad bad pre-change function. */
+ − 1662 return;
+ − 1663
+ − 1664 /* Make args be valid again. prepare_to_modify_buffer() might have
+ − 1665 modified the buffer. */
+ − 1666 if (pos < BUF_BEGV (buf))
+ − 1667 pos = BUF_BEGV (buf);
+ − 1668 if (pos >= BUF_ZV (buf))
+ − 1669 pos = BUF_ZV (buf) - 1;
+ − 1670 if (pos < BUF_BEGV (buf))
+ − 1671 /* no more characters in buffer! */
+ − 1672 return;
+ − 1673 /*
+ − 1674 * -1 as the pos argument means to move point forward with the
+ − 1675 * insertion, which we must do if the deletion moved point
+ − 1676 * backward so that it now equals the insertion point.
+ − 1677 */
+ − 1678 buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
+ − 1679 newstr, Qnil, 0, newlen, 0);
+ − 1680 }
+ − 1681 }
+ − 1682
+ − 1683
+ − 1684 /************************************************************************/
+ − 1685 /* Other functions */
+ − 1686 /************************************************************************/
+ − 1687
+ − 1688 /* Make a string from a buffer. This needs to take into account the gap,
+ − 1689 and add any necessary extents from the buffer. */
+ − 1690
+ − 1691 static Lisp_Object
665
+ − 1692 make_string_from_buffer_1 (struct buffer *buf, Charbpos pos, Charcount length,
428
+ − 1693 int no_extents)
+ − 1694 {
+ − 1695 /* This function can GC */
826
+ − 1696 Bytebpos bytepos = charbpos_to_bytebpos (buf, pos);
+ − 1697 Bytecount bytelen = charbpos_to_bytebpos (buf, pos + length) - bytepos;
+ − 1698 Bytecount needed = copy_buffer_text_out (buf, bytepos, bytelen, NULL, 0,
+ − 1699 FORMAT_DEFAULT, Qnil, NULL);
+ − 1700 Lisp_Object val = make_uninit_string (needed);
428
+ − 1701
+ − 1702 struct gcpro gcpro1;
+ − 1703 GCPRO1 (val);
+ − 1704
+ − 1705 if (!no_extents)
826
+ − 1706 add_string_extents (val, buf, bytepos, bytelen);
+ − 1707 copy_buffer_text_out (buf, bytepos, bytelen, XSTRING_DATA (val), needed,
+ − 1708 FORMAT_DEFAULT, Qnil, NULL);
771
+ − 1709 init_string_ascii_begin (val);
+ − 1710 sledgehammer_check_ascii_begin (val);
+ − 1711
428
+ − 1712 UNGCPRO;
+ − 1713 return val;
+ − 1714 }
+ − 1715
+ − 1716 Lisp_Object
665
+ − 1717 make_string_from_buffer (struct buffer *buf, Charbpos pos, Charcount length)
428
+ − 1718 {
+ − 1719 return make_string_from_buffer_1 (buf, pos, length, 0);
+ − 1720 }
+ − 1721
+ − 1722 Lisp_Object
665
+ − 1723 make_string_from_buffer_no_extents (struct buffer *buf, Charbpos pos,
428
+ − 1724 Charcount length)
+ − 1725 {
+ − 1726 return make_string_from_buffer_1 (buf, pos, length, 1);
+ − 1727 }
+ − 1728
+ − 1729 void
665
+ − 1730 barf_if_buffer_read_only (struct buffer *buf, Charbpos from, Charbpos to)
428
+ − 1731 {
+ − 1732 Lisp_Object buffer;
+ − 1733 Lisp_Object iro;
+ − 1734
793
+ − 1735 buffer = wrap_buffer (buf);
428
+ − 1736 back:
+ − 1737 iro = (buf == current_buffer ? Vinhibit_read_only :
+ − 1738 symbol_value_in_buffer (Qinhibit_read_only, buffer));
+ − 1739 if (!LISTP (iro))
+ − 1740 return;
+ − 1741 if (NILP (iro) && !NILP (buf->read_only))
+ − 1742 {
+ − 1743 Fsignal (Qbuffer_read_only, (list1 (buffer)));
+ − 1744 goto back;
+ − 1745 }
+ − 1746 if (from > 0)
+ − 1747 {
+ − 1748 if (to < 0)
+ − 1749 to = from;
+ − 1750 verify_extent_modification (buffer,
665
+ − 1751 charbpos_to_bytebpos (buf, from),
+ − 1752 charbpos_to_bytebpos (buf, to),
428
+ − 1753 iro);
+ − 1754 }
+ − 1755 }
+ − 1756
+ − 1757
+ − 1758 /************************************************************************/
+ − 1759 /* initialization */
+ − 1760 /************************************************************************/
+ − 1761
+ − 1762 void
+ − 1763 reinit_vars_of_insdel (void)
+ − 1764 {
+ − 1765 inside_change_hook = 0;
+ − 1766 in_first_change = 0;
+ − 1767 }
+ − 1768
+ − 1769 void
+ − 1770 vars_of_insdel (void)
+ − 1771 {
+ − 1772 }
+ − 1773
+ − 1774 void
+ − 1775 init_buffer_text (struct buffer *b)
+ − 1776 {
+ − 1777 if (!b->base_buffer)
+ − 1778 {
+ − 1779 SET_BUF_GAP_SIZE (b, 20);
+ − 1780 BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
+ − 1781 if (! BUF_BEG_ADDR (b))
+ − 1782 memory_full ();
+ − 1783
+ − 1784 SET_BUF_END_GAP_SIZE (b, 0);
2367
+ − 1785 SET_BOTH_BUF_GPT (b, 1, 1);
428
+ − 1786 SET_BOTH_BUF_Z (b, 1, 1);
+ − 1787 SET_GAP_SENTINEL (b);
+ − 1788 SET_END_SENTINEL (b);
2367
+ − 1789
428
+ − 1790 #ifdef MULE
2367
+ − 1791 b->text->entirely_one_byte_p = 1;
428
+ − 1792
2367
+ − 1793 #ifdef OLD_BYTE_CHAR
+ − 1794 b->text->mule_bufmin = b->text->mule_bufmax = 1;
+ − 1795 b->text->mule_bytmin = b->text->mule_bytmax = 1;
+ − 1796 #endif
428
+ − 1797
2367
+ − 1798 b->text->cached_charpos = 1;
+ − 1799 b->text->cached_bytepos = 1;
+ − 1800
826
+ − 1801 /* &&#### Set to FORMAT_8_BIT_FIXED when that code is working */
+ − 1802 BUF_FORMAT (b) = FORMAT_DEFAULT;
428
+ − 1803 #endif /* MULE */
+ − 1804 b->text->line_number_cache = Qnil;
+ − 1805
+ − 1806 BUF_MODIFF (b) = 1;
+ − 1807 BUF_SAVE_MODIFF (b) = 1;
+ − 1808
+ − 1809 JUST_SET_POINT (b, 1, 1);
+ − 1810 SET_BOTH_BUF_BEGV (b, 1, 1);
+ − 1811 SET_BOTH_BUF_ZV (b, 1, 1);
+ − 1812
+ − 1813 b->text->changes = xnew_and_zero (struct buffer_text_change_data);
+ − 1814 }
+ − 1815 else
+ − 1816 {
826
+ − 1817 JUST_SET_POINT (b, BUF_PT (b->base_buffer), BYTE_BUF_PT (b->base_buffer));
428
+ − 1818 SET_BOTH_BUF_BEGV (b, BUF_BEGV (b->base_buffer),
826
+ − 1819 BYTE_BUF_BEGV (b->base_buffer));
428
+ − 1820 SET_BOTH_BUF_ZV (b, BUF_ZV (b->base_buffer),
826
+ − 1821 BYTE_BUF_ZV (b->base_buffer));
428
+ − 1822 }
+ − 1823
+ − 1824 b->changes = xnew_and_zero (struct each_buffer_change_data);
+ − 1825 BUF_FACECHANGE (b) = 1;
+ − 1826
+ − 1827 #ifdef REGION_CACHE_NEEDS_WORK
+ − 1828 b->newline_cache = 0;
+ − 1829 b->width_run_cache = 0;
+ − 1830 b->width_table = Qnil;
+ − 1831 #endif
+ − 1832 }
+ − 1833
+ − 1834 void
+ − 1835 uninit_buffer_text (struct buffer *b)
+ − 1836 {
+ − 1837 if (!b->base_buffer)
+ − 1838 {
+ − 1839 BUFFER_FREE (b->text->beg);
1726
+ − 1840 xfree (b->text->changes, struct buffer_text_change_data *);
428
+ − 1841 }
1726
+ − 1842 xfree (b->changes, struct each_buffer_change_data *);
428
+ − 1843
+ − 1844 #ifdef REGION_CACHE_NEEDS_WORK
+ − 1845 if (b->newline_cache)
+ − 1846 {
+ − 1847 free_region_cache (b->newline_cache);
+ − 1848 b->newline_cache = 0;
+ − 1849 }
+ − 1850 if (b->width_run_cache)
+ − 1851 {
+ − 1852 free_region_cache (b->width_run_cache);
+ − 1853 b->width_run_cache = 0;
+ − 1854 }
+ − 1855 b->width_table = Qnil;
+ − 1856 #endif
+ − 1857 }
