428
+ − 1 /* Header file for the buffer manipulation primitives.
+ − 2 Copyright (C) 1985, 1986, 1992, 1993, 1994, 1995
+ − 3 Free Software Foundation, Inc.
+ − 4 Copyright (C) 1995 Sun Microsystems, Inc.
2367
+ − 5 Copyright (C) 2001, 2002, 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: FSF 19.30. */
+ − 25
+ − 26 /* Authorship:
+ − 27
+ − 28 FSF: long ago.
+ − 29 JWZ: separated out bufslots.h, early in Lemacs.
+ − 30 Ben Wing: almost completely rewritten for Mule, 19.12.
+ − 31 */
+ − 32
440
+ − 33 #ifndef INCLUDED_buffer_h_
+ − 34 #define INCLUDED_buffer_h_
428
+ − 35
446
+ − 36 #include "casetab.h"
+ − 37 #include "chartab.h"
+ − 38
428
+ − 39 /************************************************************************/
+ − 40 /* */
+ − 41 /* definition of Lisp buffer object */
+ − 42 /* */
+ − 43 /************************************************************************/
+ − 44
665
+ − 45 /* Note: we keep both Bytebpos and Charbpos versions of some of the
428
+ − 46 important buffer positions because they are accessed so much.
+ − 47 If we didn't do this, we would constantly be invalidating the
665
+ − 48 charbpos<->bytebpos cache under Mule.
428
+ − 49
+ − 50 Note that under non-Mule, both versions will always be the
+ − 51 same so we don't really need to keep track of them. But it
+ − 52 simplifies the logic to go ahead and do so all the time and
+ − 53 the memory loss is insignificant. */
+ − 54
+ − 55 /* Formerly, it didn't much matter what went inside the struct buffer_text
+ − 56 and what went outside it. Now it does, with the advent of "indirect
+ − 57 buffers" that share text with another buffer. An indirect buffer
+ − 58 shares the same *text* as another buffer, but has its own buffer-local
+ − 59 variables, its own accessible region, and its own markers and extents.
+ − 60 (Due to the nature of markers, it doesn't actually matter much whether
+ − 61 we stick them inside or out of the struct buffer_text -- the user won't
+ − 62 notice any difference -- but we go ahead and put them outside for
+ − 63 consistency and overall saneness of algorithm.)
+ − 64
+ − 65 FSFmacs gets away with not maintaining any "children" pointers from
+ − 66 a buffer to the indirect buffers that refer to it by putting the
+ − 67 markers inside of the struct buffer_text, using markers to keep track
+ − 68 of BEGV and ZV in indirect buffers, and relying on the fact that
+ − 69 all intervals (text properties and overlays) use markers for their
+ − 70 start and end points. We don't do this for extents (markers are
+ − 71 inefficient anyway and take up space), so we have to maintain
+ − 72 children pointers. This is not terribly hard, though, and the
+ − 73 code to maintain this is just like the code already present in
+ − 74 extent-parent and extent-children.
+ − 75 */
+ − 76
2367
+ − 77 #define NUM_CACHED_POSITIONS 50
+ − 78 #define NUM_MOVED_POSITIONS 10
+ − 79
428
+ − 80 struct buffer_text
+ − 81 {
3092
+ − 82 #ifdef NEW_GC
+ − 83 struct lrecord_header header;
+ − 84 #endif /* NEW_GC */
867
+ − 85 Ibyte *beg; /* Actual address of buffer contents. */
665
+ − 86 Bytebpos gpt; /* Index of gap in buffer. */
2367
+ − 87 Charbpos bufgpt; /* Equivalent as a Charbpos. */
665
+ − 88 Bytebpos z; /* Index of end of buffer. */
2367
+ − 89 Charbpos bufz; /* Equivalent as a Charbpos. */
665
+ − 90 Bytecount gap_size;/* Size of buffer's gap */
+ − 91 Bytecount end_gap_size;/* Size of buffer's end gap */
428
+ − 92 long modiff; /* This counts buffer-modification events
+ − 93 for this buffer. It is incremented for
+ − 94 each such event, and never otherwise
+ − 95 changed. */
+ − 96 long save_modiff; /* Previous value of modiff, as of last
+ − 97 time buffer visited or saved a file. */
+ − 98
+ − 99 #ifdef MULE
2367
+ − 100
+ − 101 #ifdef OLD_BYTE_CHAR
771
+ − 102 /* We keep track of a "known" region for very fast access. This
+ − 103 information is text-only so it goes here. We update this at each
+ − 104 change to the buffer, so if it's entirely ASCII, these will always
+ − 105 contain the minimum and maximum positions of the buffer. */
665
+ − 106 Charbpos mule_bufmin, mule_bufmax;
+ − 107 Bytebpos mule_bytmin, mule_bytmax;
428
+ − 108 int mule_shifter, mule_three_p;
2367
+ − 109 #endif
428
+ − 110
2367
+ − 111 /* And we also cache NUM_CACHED_POSITIONS positions for fairly fast
+ − 112 access near those positions. */
+ − 113 Charbpos mule_charbpos_cache[NUM_CACHED_POSITIONS];
+ − 114 Bytebpos mule_bytebpos_cache[NUM_CACHED_POSITIONS];
+ − 115 int next_cache_pos;
+ − 116
+ − 117 Charbpos cached_charpos;
+ − 118 Bytebpos cached_bytepos;
771
+ − 119
826
+ − 120 /* True if all chars fit into one byte;
+ − 121 == (format == FORMAT_8_BIT_FIXED ||
+ − 122 (format == FORMAT_DEFAULT && num_ascii_chars == bufz - 1))
+ − 123 kept around to speed up (slightly?) the byte-char conversion routines. */
+ − 124 int entirely_one_byte_p;
+ − 125 /* Number of ASCII chars in buffer (0 - 127) */
+ − 126 Charcount num_ascii_chars;
+ − 127 /* Number of chars in buffer that would fit in an 8-bit-fixed buffer. */
+ − 128 Charcount num_8_bit_fixed_chars;
+ − 129 /* Number of chars in buffer that would fit in an 16-bit-fixed buffer. */
+ − 130 Charcount num_16_bit_fixed_chars;
+ − 131
+ − 132 /* Currently we only handle 8 bit fixed and default */
+ − 133 Internal_Format format;
2367
+ − 134 #endif /* MULE */
428
+ − 135
+ − 136 /* Similar to the above, we keep track of positions for which line
+ − 137 number has last been calculated. See line-number.c. */
+ − 138 Lisp_Object line_number_cache;
+ − 139
+ − 140 /* Change data that goes with the text. */
+ − 141 struct buffer_text_change_data *changes;
+ − 142 };
+ − 143
3092
+ − 144 #ifdef NEW_GC
+ − 145 typedef struct buffer_text Lisp_Buffer_Text;
+ − 146
+ − 147 DECLARE_LRECORD (buffer_text, Lisp_Buffer_Text);
+ − 148
+ − 149 #define XBUFFER_TEXT(x) \
+ − 150 XRECORD (x, buffer_text, Lisp_Buffer_Text)
+ − 151 #define wrap_buffer_text(p) wrap_record (p, buffer_text)
+ − 152 #define BUFFER_TEXT_P(x) RECORDP (x, buffer_text)
+ − 153 #define CHECK_BUFFER_TEXT(x) CHECK_RECORD (x, buffer_text)
+ − 154 #define CONCHECK_BUFFER_TEXT(x) CONCHECK_RECORD (x, buffer_text)
+ − 155 #endif /* NEW_GC */
+ − 156
+ − 157
428
+ − 158 struct buffer
+ − 159 {
3017
+ − 160 struct LCRECORD_HEADER header;
428
+ − 161
+ − 162 /* This structure holds the coordinates of the buffer contents
+ − 163 in ordinary buffers. In indirect buffers, this is not used. */
+ − 164 struct buffer_text own_text;
+ − 165
+ − 166 /* This points to the `struct buffer_text' that is used for this buffer.
+ − 167 In an ordinary buffer, this is the own_text field above.
+ − 168 In an indirect buffer, this is the own_text field of another buffer. */
+ − 169 struct buffer_text *text;
+ − 170
665
+ − 171 Bytebpos pt; /* Position of point in buffer. */
+ − 172 Charbpos bufpt; /* Equivalent as a Charbpos. */
+ − 173 Bytebpos begv; /* Index of beginning of accessible range. */
+ − 174 Charbpos bufbegv; /* Equivalent as a Charbpos. */
+ − 175 Bytebpos zv; /* Index of end of accessible range. */
+ − 176 Charbpos bufzv; /* Equivalent as a Charbpos. */
428
+ − 177
+ − 178 int face_change; /* This is set when a change in how the text should
+ − 179 be displayed (e.g., font, color) is made. */
+ − 180
448
+ − 181 /* Whether buffer specific face is specified. */
+ − 182 int buffer_local_face_property;
+ − 183
428
+ − 184 /* change data indicating what portion of the text has changed
+ − 185 since the last time this was reset. Used by redisplay.
+ − 186 Logically we should keep this with the text structure, but
+ − 187 redisplay resets it for each buffer individually and we don't
+ − 188 want interference between an indirect buffer and its base
+ − 189 buffer. */
+ − 190 struct each_buffer_change_data *changes;
+ − 191
+ − 192 #ifdef REGION_CACHE_NEEDS_WORK
+ − 193 /* If the long line scan cache is enabled (i.e. the buffer-local
+ − 194 variable cache-long-line-scans is non-nil), newline_cache
+ − 195 points to the newline cache, and width_run_cache points to the
+ − 196 width run cache.
+ − 197
+ − 198 The newline cache records which stretches of the buffer are
+ − 199 known *not* to contain newlines, so that they can be skipped
+ − 200 quickly when we search for newlines.
+ − 201
+ − 202 The width run cache records which stretches of the buffer are
+ − 203 known to contain characters whose widths are all the same. If
+ − 204 the width run cache maps a character to a value > 0, that value
+ − 205 is the character's width; if it maps a character to zero, we
+ − 206 don't know what its width is. This allows compute_motion to
+ − 207 process such regions very quickly, using algebra instead of
+ − 208 inspecting each character. See also width_table, below. */
+ − 209 struct region_cache *newline_cache;
+ − 210 struct region_cache *width_run_cache;
+ − 211 #endif /* REGION_CACHE_NEEDS_WORK */
+ − 212
+ − 213 /* The markers that refer to this buffer. This is actually a single
+ − 214 marker -- successive elements in its marker `chain' are the other
+ − 215 markers referring to this buffer */
440
+ − 216 Lisp_Marker *markers;
428
+ − 217
+ − 218 /* The buffer's extent info. This is its own type, an extent-info
+ − 219 object (done this way for ease in marking / finalizing). */
+ − 220 Lisp_Object extent_info;
+ − 221
826
+ − 222 /* The buffer's syntax cache. This caches a known region where the
+ − 223 `syntax-table' property is unchanged, for quick lookup in the routines
+ − 224 that scan a buffer looking for a particular syntax (regex routines,
+ − 225 parse-partial-sexp, etc.). */
+ − 226 struct syntax_cache *syntax_cache;
+ − 227
428
+ − 228 /* ----------------------------------------------------------------- */
+ − 229 /* All the stuff above this line is the responsibility of insdel.c,
826
+ − 230 with some help from marker.c, extents.c and syntax.c.
428
+ − 231 All the stuff below this line is the responsibility of buffer.c. */
+ − 232
+ − 233 /* In an indirect buffer, this points to the base buffer.
+ − 234 In an ordinary buffer, it is 0.
+ − 235 We DO mark through this slot. */
+ − 236 struct buffer *base_buffer;
+ − 237
+ − 238 /* List of indirect buffers whose base is this buffer.
+ − 239 If we are an indirect buffer, this will be nil.
+ − 240 Do NOT mark through this. */
+ − 241 Lisp_Object indirect_children;
+ − 242
+ − 243 /* Flags saying which DEFVAR_PER_BUFFER variables
+ − 244 are local to this buffer. */
+ − 245 int local_var_flags;
+ − 246
+ − 247 /* Set to the modtime of the visited file when read or written.
+ − 248 -1 means visited file was nonexistent.
+ − 249 0 means visited file modtime unknown; in no case complain
+ − 250 about any mismatch on next save attempt. */
+ − 251 int modtime;
+ − 252
+ − 253 /* the value of text->modiff at the last auto-save. */
442
+ − 254 long auto_save_modified;
428
+ − 255
+ − 256 /* The time at which we detected a failure to auto-save,
+ − 257 Or -1 if we didn't have a failure. */
+ − 258 int auto_save_failure_time;
+ − 259
+ − 260 /* Position in buffer at which display started
+ − 261 the last time this buffer was displayed. */
+ − 262 int last_window_start;
+ − 263
+ − 264 /* Everything from here down must be a Lisp_Object */
+ − 265
1204
+ − 266 #define MARKED_SLOT(x) Lisp_Object x;
428
+ − 267 #include "bufslots.h"
+ − 268 #undef MARKED_SLOT
+ − 269 };
+ − 270
+ − 271 DECLARE_LRECORD (buffer, struct buffer);
+ − 272 #define XBUFFER(x) XRECORD (x, buffer, struct buffer)
617
+ − 273 #define wrap_buffer(p) wrap_record (p, buffer)
428
+ − 274 #define BUFFERP(x) RECORDP (x, buffer)
+ − 275 #define CHECK_BUFFER(x) CHECK_RECORD (x, buffer)
+ − 276 #define CONCHECK_BUFFER(x) CONCHECK_RECORD (x, buffer)
+ − 277
+ − 278 #define BUFFER_LIVE_P(b) (!NILP ((b)->name))
+ − 279
+ − 280 #define CHECK_LIVE_BUFFER(x) do { \
+ − 281 CHECK_BUFFER (x); \
+ − 282 if (!BUFFER_LIVE_P (XBUFFER (x))) \
+ − 283 dead_wrong_type_argument (Qbuffer_live_p, (x)); \
+ − 284 } while (0)
+ − 285
+ − 286 #define CONCHECK_LIVE_BUFFER(x) do { \
+ − 287 CONCHECK_BUFFER (x); \
+ − 288 if (!BUFFER_LIVE_P (XBUFFER (x))) \
+ − 289 x = wrong_type_argument (Qbuffer_live_p, (x)); \
+ − 290 } while (0)
+ − 291
+ − 292
+ − 293 #define BUFFER_BASE_BUFFER(b) ((b)->base_buffer ? (b)->base_buffer : (b))
+ − 294
+ − 295 /* Map over buffers sharing the same text as MPS_BUF. MPS_BUFVAR is a
+ − 296 variable that gets the buffer values (beginning with the base
+ − 297 buffer, then the children), and MPS_BUFCONS should be a temporary
+ − 298 Lisp_Object variable. */
647
+ − 299 #define MAP_INDIRECT_BUFFERS(mps_buf, mps_bufvar, mps_bufcons) \
+ − 300 for (mps_bufcons = Qunbound, \
+ − 301 mps_bufvar = BUFFER_BASE_BUFFER (mps_buf); \
+ − 302 UNBOUNDP (mps_bufcons) ? \
+ − 303 (mps_bufcons = mps_bufvar->indirect_children, \
+ − 304 1) \
+ − 305 : (!NILP (mps_bufcons) \
+ − 306 && (mps_bufvar = XBUFFER (XCAR (mps_bufcons)), 1) \
+ − 307 && (mps_bufcons = XCDR (mps_bufcons), 1)); \
428
+ − 308 )
+ − 309
+ − 310
826
+ − 311 /* All macros below follow the three golden rules of macros (see text.h),
+ − 312 with the following exception:
+ − 313
+ − 314 -- 'struct buffer *' arguments can be evaluated more than once.
+ − 315 */
+ − 316
428
+ − 317 /*----------------------------------------------------------------------*/
+ − 318 /* Accessor macros for important positions in a buffer */
+ − 319 /*----------------------------------------------------------------------*/
+ − 320
+ − 321 /* We put them here because some stuff below wants them before the
+ − 322 place where we would normally put them. */
+ − 323
+ − 324 /* None of these are lvalues. Use the settor macros below to change
+ − 325 the positions. */
+ − 326
+ − 327 /* Beginning of buffer. */
826
+ − 328 #define BYTE_BUF_BEG(buf) ((Bytebpos) 1)
665
+ − 329 #define BUF_BEG(buf) ((Charbpos) 1)
428
+ − 330
+ − 331 /* Beginning of accessible range of buffer. */
826
+ − 332 #define BYTE_BUF_BEGV(buf) ((buf)->begv + 0)
428
+ − 333 #define BUF_BEGV(buf) ((buf)->bufbegv + 0)
+ − 334
+ − 335 /* End of accessible range of buffer. */
826
+ − 336 #define BYTE_BUF_ZV(buf) ((buf)->zv + 0)
428
+ − 337 #define BUF_ZV(buf) ((buf)->bufzv + 0)
+ − 338
+ − 339 /* End of buffer. */
826
+ − 340 #define BYTE_BUF_Z(buf) ((buf)->text->z + 0)
428
+ − 341 #define BUF_Z(buf) ((buf)->text->bufz + 0)
+ − 342
2367
+ − 343 /* Gap location. */
+ − 344 #define BYTE_BUF_GPT(buf) ((buf)->text->gpt + 0)
+ − 345 #define BUF_GPT(buf) ((buf)->text->bufgpt + 0)
+ − 346
428
+ − 347 /* Point. */
826
+ − 348 #define BYTE_BUF_PT(buf) ((buf)->pt + 0)
428
+ − 349 #define BUF_PT(buf) ((buf)->bufpt + 0)
+ − 350
826
+ − 351 /* Internal format of buffer. */
+ − 352 #ifdef MULE
+ − 353 #define BUF_FORMAT(buf) ((buf)->text->format)
+ − 354 #else
+ − 355 #define BUF_FORMAT(buf) FORMAT_DEFAULT
+ − 356 #endif
+ − 357
428
+ − 358 /*----------------------------------------------------------------------*/
826
+ − 359 /* Validating byte positions */
428
+ − 360 /*----------------------------------------------------------------------*/
+ − 361
826
+ − 362 /* Address of byte at position POS in buffer, no error checking. */
+ − 363 DECLARE_INLINE_HEADER (
867
+ − 364 Ibyte *
826
+ − 365 BYTE_BUF_BYTE_ADDRESS_NO_VERIFY (struct buffer *buf, Bytebpos pos)
+ − 366 )
428
+ − 367 {
+ − 368 return (buf->text->beg +
+ − 369 ((pos >= buf->text->gpt ? (pos + buf->text->gap_size) : pos)
+ − 370 - 1));
+ − 371 }
+ − 372
826
+ − 373 /* Given a byte position, does it point to the beginning of a character?
+ − 374 */
+ − 375 #ifdef MULE
+ − 376 DECLARE_INLINE_HEADER (
+ − 377 int
+ − 378 VALID_BYTEBPOS_P (struct buffer *buf, Bytebpos x)
+ − 379 )
428
+ − 380 {
826
+ − 381 switch (BUF_FORMAT (buf))
+ − 382 {
+ − 383 case FORMAT_DEFAULT:
867
+ − 384 return ibyte_first_byte_p (*BYTE_BUF_BYTE_ADDRESS_NO_VERIFY (buf, x));
826
+ − 385 case FORMAT_16_BIT_FIXED:
+ − 386 return ((x - 1) & 1) == 0;
+ − 387 case FORMAT_32_BIT_FIXED:
+ − 388 return ((x - 1) & 3) == 0;
+ − 389 default:
+ − 390 return 1;
+ − 391 }
428
+ − 392 }
+ − 393 #else
665
+ − 394 # define VALID_BYTEBPOS_P(buf, x) 1
428
+ − 395 #endif
+ − 396
826
+ − 397 /* If error-checking is enabled, assert that the given char position is
+ − 398 within range. Otherwise, do nothing.
+ − 399 */
+ − 400 # define ASSERT_VALID_CHARBPOS_UNSAFE(buf, x) do { \
+ − 401 text_checking_assert (BUFFER_LIVE_P (buf)); \
+ − 402 text_checking_assert ((x) >= BUF_BEG (buf) && x <= BUF_Z (buf)); \
428
+ − 403 } while (0)
826
+ − 404
+ − 405 /* If error-checking is enabled, assert that the given byte position is
+ − 406 within range and points to the beginning of a character or to the end of
+ − 407 the buffer. Otherwise, do nothing.
+ − 408 */
+ − 409 # define ASSERT_VALID_BYTEBPOS_UNSAFE(buf, x) do { \
+ − 410 text_checking_assert (BUFFER_LIVE_P (buf)); \
+ − 411 text_checking_assert ((x) >= BYTE_BUF_BEG (buf) && x <= BYTE_BUF_Z (buf)); \
+ − 412 text_checking_assert (VALID_BYTEBPOS_P (buf, x)); \
428
+ − 413 } while (0)
826
+ − 414
+ − 415 /* If error-checking is enabled, assert that the given byte position is
+ − 416 within range and satisfies ASSERT_VALID_BYTEBPOS() and also does not
+ − 417 refer to the beginning of the buffer. (i.e. movement backwards is OK.)
+ − 418 Otherwise, do nothing.
+ − 419 */
+ − 420 # define ASSERT_VALID_BYTEBPOS_BACKWARD_UNSAFE(buf, x) do { \
+ − 421 text_checking_assert (BUFFER_LIVE_P (buf)); \
+ − 422 text_checking_assert ((x) > BYTE_BUF_BEG (buf) && x <= BYTE_BUF_Z (buf)); \
+ − 423 text_checking_assert (VALID_BYTEBPOS_P (buf, x)); \
428
+ − 424 } while (0)
+ − 425
826
+ − 426 /* If error-checking is enabled, assert that the given byte position is
+ − 427 within range and satisfies ASSERT_VALID_BYTEBPOS() and also does not
+ − 428 refer to the end of the buffer. (i.e. movement forwards is OK.)
+ − 429 Otherwise, do nothing.
+ − 430 */
+ − 431 # define ASSERT_VALID_BYTEBPOS_FORWARD_UNSAFE(buf, x) do { \
+ − 432 text_checking_assert (BUFFER_LIVE_P (buf)); \
+ − 433 text_checking_assert ((x) >= BYTE_BUF_BEG (buf) && x < BYTE_BUF_Z (buf)); \
+ − 434 text_checking_assert (VALID_BYTEBPOS_P (buf, x)); \
+ − 435 } while (0)
428
+ − 436
+ − 437 #ifdef MULE
826
+ − 438 /* Make sure that the given byte position is pointing to the beginning of a
+ − 439 character. If not, back up until this is the case. Note that there are
+ − 440 not too many places where it is legitimate to do this sort of thing.
+ − 441 It's an error if you're passed an "invalid" byte position.
+ − 442 */
+ − 443 # define VALIDATE_BYTEBPOS_BACKWARD(buf, x) do { \
+ − 444 switch (BUF_FORMAT (buf)) \
+ − 445 { \
+ − 446 case FORMAT_DEFAULT: \
+ − 447 { \
867
+ − 448 Ibyte *VBB_ptr = BYTE_BUF_BYTE_ADDRESS_NO_VERIFY (buf, x); \
+ − 449 while (!ibyte_first_byte_p (*VBB_ptr)) \
826
+ − 450 VBB_ptr--, (x)--; \
+ − 451 } \
+ − 452 break; \
+ − 453 case FORMAT_16_BIT_FIXED: \
+ − 454 if (((x - 1) & 1) != 0) \
+ − 455 x--; \
+ − 456 break; \
+ − 457 case FORMAT_32_BIT_FIXED: \
+ − 458 while (((x - 1) & 3) != 0) \
+ − 459 x--; \
+ − 460 break; \
+ − 461 default: \
+ − 462 break; \
+ − 463 } \
428
+ − 464 } while (0)
+ − 465 #else
665
+ − 466 # define VALIDATE_BYTEBPOS_BACKWARD(buf, x)
428
+ − 467 #endif
+ − 468
+ − 469 #ifdef MULE
826
+ − 470 /* Make sure that the given byte position is pointing to the beginning of a
+ − 471 character. If not, move forward until this is the case. Note that
+ − 472 there are not too many places where it is legitimate to do this sort of
+ − 473 thing. It's an error if you're passed an "invalid" byte position.
+ − 474 */
+ − 475 # define VALIDATE_BYTEBPOS_FORWARD(buf, x) do { \
+ − 476 switch (BUF_FORMAT (buf)) \
+ − 477 { \
+ − 478 case FORMAT_DEFAULT: \
+ − 479 { \
867
+ − 480 Ibyte *VBF_ptr = BYTE_BUF_BYTE_ADDRESS_NO_VERIFY (buf, x); \
+ − 481 while (!ibyte_first_byte_p (*VBF_ptr)) \
826
+ − 482 VBF_ptr++, (x)++; \
+ − 483 } \
+ − 484 break; \
+ − 485 case FORMAT_16_BIT_FIXED: \
+ − 486 if (((x - 1) & 1) != 0) \
+ − 487 x++; \
+ − 488 break; \
+ − 489 case FORMAT_32_BIT_FIXED: \
+ − 490 while (((x - 1) & 3) != 0) \
+ − 491 x++; \
+ − 492 break; \
+ − 493 default: \
+ − 494 break; \
+ − 495 } \
428
+ − 496 } while (0)
+ − 497 #else
665
+ − 498 # define VALIDATE_BYTEBPOS_FORWARD(buf, x)
428
+ − 499 #endif
+ − 500
826
+ − 501 /*----------------------------------------------------------------------*/
+ − 502 /* Working with byte positions */
+ − 503 /*----------------------------------------------------------------------*/
+ − 504
+ − 505
+ − 506 /* Given a byte position (assumed to point at the beginning of a
+ − 507 character), modify that value so it points to the beginning of the next
+ − 508 character.
+ − 509
+ − 510 Note that in the simplest case (no MULE, no ERROR_CHECK_TEXT),
+ − 511 this crap reduces down to simply (x)++. */
428
+ − 512
665
+ − 513 #define INC_BYTEBPOS(buf, x) do \
428
+ − 514 { \
826
+ − 515 ASSERT_VALID_BYTEBPOS_FORWARD_UNSAFE (buf, x); \
428
+ − 516 /* Note that we do the increment first to \
+ − 517 make sure that the pointer in \
665
+ − 518 VALIDATE_BYTEBPOS_FORWARD() ends up on \
428
+ − 519 the correct side of the gap */ \
+ − 520 (x)++; \
665
+ − 521 VALIDATE_BYTEBPOS_FORWARD (buf, x); \
428
+ − 522 } while (0)
+ − 523
826
+ − 524 /* Given a byte position (assumed to point at the beginning of a
+ − 525 character), modify that value so it points to the beginning of the
867
+ − 526 previous character. Unlike for DEC_IBYTEPTR(), we can do all the
826
+ − 527 assert()s because there are sentinels at the beginning of the gap and
+ − 528 the end of the buffer.
+ − 529
+ − 530 Note that in the simplest case (no MULE, no ERROR_CHECK_TEXT), this
+ − 531 crap reduces down to simply (x)--. */
428
+ − 532
665
+ − 533 #define DEC_BYTEBPOS(buf, x) do \
428
+ − 534 { \
771
+ − 535 ASSERT_VALID_BYTEBPOS_BACKWARD_UNSAFE (buf, x); \
428
+ − 536 /* Note that we do the decrement first to \
+ − 537 make sure that the pointer in \
665
+ − 538 VALIDATE_BYTEBPOS_BACKWARD() ends up on \
428
+ − 539 the correct side of the gap */ \
+ − 540 (x)--; \
665
+ − 541 VALIDATE_BYTEBPOS_BACKWARD (buf, x); \
428
+ − 542 } while (0)
+ − 543
826
+ − 544 DECLARE_INLINE_HEADER (
+ − 545 Bytebpos
2333
+ − 546 prev_bytebpos (struct buffer *USED_IF_MULE_OR_CHECK_TEXT (buf), Bytebpos x)
826
+ − 547 )
428
+ − 548 {
665
+ − 549 DEC_BYTEBPOS (buf, x);
428
+ − 550 return x;
+ − 551 }
+ − 552
826
+ − 553 DECLARE_INLINE_HEADER (
+ − 554 Bytebpos
2333
+ − 555 next_bytebpos (struct buffer *USED_IF_MULE_OR_CHECK_TEXT (buf), Bytebpos x)
826
+ − 556 )
428
+ − 557 {
665
+ − 558 INC_BYTEBPOS (buf, x);
428
+ − 559 return x;
+ − 560 }
+ − 561
826
+ − 562 /* A constant representing an invalid Bytebpos. Valid Bytebposes
+ − 563 can never have this value. */
+ − 564
665
+ − 565 #define BYTEBPOS_INVALID ((Bytebpos) -1)
428
+ − 566
+ − 567 /*----------------------------------------------------------------------*/
826
+ − 568 /* Converting between byte and character positions */
428
+ − 569 /*----------------------------------------------------------------------*/
+ − 570
2367
+ − 571 /*
771
+ − 572
2367
+ − 573 Info on Byte-Char conversion:
428
+ − 574
2367
+ − 575 (Info-goto-node "(internals)Byte-Char Position Conversion")
+ − 576 */
428
+ − 577
2367
+ − 578 #ifdef MULE
428
+ − 579
826
+ − 580 Bytebpos charbpos_to_bytebpos_func (struct buffer *buf, Charbpos x);
+ − 581 Charbpos bytebpos_to_charbpos_func (struct buffer *buf, Bytebpos x);
428
+ − 582 extern short three_to_one_table[];
+ − 583
826
+ − 584 #endif /* MULE */
+ − 585
+ − 586 /* Given a Charbpos, return the equivalent Bytebpos. */
+ − 587
+ − 588 DECLARE_INLINE_HEADER (
+ − 589 Bytebpos
2333
+ − 590 charbpos_to_bytebpos (struct buffer *USED_IF_MULE_OR_CHECK_TEXT (buf),
+ − 591 Charbpos x)
826
+ − 592 )
428
+ − 593 {
826
+ − 594 Bytebpos retval;
+ − 595 ASSERT_VALID_CHARBPOS_UNSAFE (buf, x);
+ − 596 #ifdef MULE
+ − 597 if (buf->text->entirely_one_byte_p)
+ − 598 retval = (Bytebpos) x;
+ − 599 else if (BUF_FORMAT (buf) == FORMAT_16_BIT_FIXED)
+ − 600 retval = (Bytebpos) (x << 1);
+ − 601 else if (BUF_FORMAT (buf) == FORMAT_32_BIT_FIXED)
+ − 602 retval = (Bytebpos) (x << 2);
2367
+ − 603 #ifdef OLD_BYTE_CHAR
826
+ − 604 else if (x >= buf->text->mule_bufmin && x <= buf->text->mule_bufmax)
+ − 605 retval = (buf->text->mule_bytmin +
428
+ − 606 ((x - buf->text->mule_bufmin) << buf->text->mule_shifter) +
814
+ − 607 (buf->text->mule_three_p ? (x - buf->text->mule_bufmin) :
+ − 608 (Bytebpos) 0));
2367
+ − 609 #endif /* OLD_BYTE_CHAR */
428
+ − 610 else
826
+ − 611 retval = charbpos_to_bytebpos_func (buf, x);
+ − 612 #else
+ − 613 retval = (Bytebpos) x;
+ − 614 #endif
+ − 615 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, retval);
+ − 616 return retval;
+ − 617 }
+ − 618
+ − 619 /* Given a Bytebpos, return the equivalent Charbpos. */
+ − 620
+ − 621 DECLARE_INLINE_HEADER (
+ − 622 Charbpos
2333
+ − 623 bytebpos_to_charbpos (struct buffer *USED_IF_MULE_OR_CHECK_TEXT (buf),
+ − 624 Bytebpos x)
826
+ − 625 )
+ − 626 {
+ − 627 Charbpos retval;
+ − 628 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, x);
+ − 629 #ifdef MULE
+ − 630 if (buf->text->entirely_one_byte_p)
+ − 631 retval = (Charbpos) x;
+ − 632 else if (BUF_FORMAT (buf) == FORMAT_16_BIT_FIXED)
+ − 633 retval = (Charbpos) (x >> 1);
+ − 634 else if (BUF_FORMAT (buf) == FORMAT_32_BIT_FIXED)
+ − 635 retval = (Charbpos) (x >> 2);
2367
+ − 636 #ifdef OLD_BYTE_CHAR
826
+ − 637 else if (x >= buf->text->mule_bytmin && x <= buf->text->mule_bytmax)
+ − 638 retval = (buf->text->mule_bufmin +
+ − 639 ((buf->text->mule_three_p
+ − 640 ? three_to_one_table[x - buf->text->mule_bytmin]
+ − 641 : (x - buf->text->mule_bytmin) >> buf->text->mule_shifter)));
2367
+ − 642 #endif /* OLD_BYTE_CHAR */
826
+ − 643 else
+ − 644 retval = bytebpos_to_charbpos_func (buf, x);
+ − 645 #else
+ − 646 retval = (Charbpos) x;
+ − 647 #endif
+ − 648 ASSERT_VALID_CHARBPOS_UNSAFE (buf, retval);
+ − 649 return retval;
+ − 650 }
+ − 651
+ − 652 /* Given a Bytebpos, return the equivalent Charbpos as a Lisp Object. */
+ − 653
+ − 654 #define make_charbpos(buf, ind) make_int (bytebpos_to_charbpos (buf, ind))
+ − 655
+ − 656 /*----------------------------------------------------------------------*/
+ − 657 /* Converting between byte and memory positions */
+ − 658 /*----------------------------------------------------------------------*/
+ − 659
+ − 660 DECLARE_INLINE_HEADER (
+ − 661 int
+ − 662 valid_membpos_p (struct buffer *buf, Membpos x)
+ − 663 )
+ − 664 {
+ − 665 return ((x >= 1 && x <= (Membpos) buf->text->gpt) ||
+ − 666 (x > (Membpos) (buf->text->gpt + buf->text->gap_size) &&
+ − 667 x <= (Membpos) (buf->text->z + buf->text->gap_size)));
428
+ − 668 }
+ − 669
826
+ − 670 DECLARE_INLINE_HEADER (
+ − 671 Membpos
+ − 672 bytebpos_to_membpos (struct buffer *buf, Bytebpos x)
+ − 673 )
+ − 674 {
+ − 675 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, x);
+ − 676 return (Membpos) ((x > buf->text->gpt) ? (x + buf->text->gap_size) : x);
+ − 677 }
+ − 678
+ − 679
+ − 680 DECLARE_INLINE_HEADER (
+ − 681 Bytebpos
+ − 682 membpos_to_bytebpos (struct buffer *buf, Membpos x)
+ − 683 )
+ − 684 {
+ − 685 Bytebpos retval;
+ − 686 text_checking_assert (valid_membpos_p (buf, x));
+ − 687 retval = (Bytebpos) ((x > (Membpos) buf->text->gpt) ?
+ − 688 x - buf->text->gap_size :
+ − 689 x);
+ − 690 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, retval);
+ − 691 return retval;
+ − 692 }
+ − 693
+ − 694 DECLARE_INLINE_HEADER (
+ − 695 Charbpos
+ − 696 membpos_to_charbpos (struct buffer *buf, Membpos x)
+ − 697 )
428
+ − 698 {
826
+ − 699 return bytebpos_to_charbpos (buf, membpos_to_bytebpos (buf, x));
+ − 700 }
+ − 701
+ − 702 DECLARE_INLINE_HEADER (
+ − 703 Membpos
+ − 704 charbpos_to_membpos (struct buffer *buf, Charbpos x)
+ − 705 )
+ − 706 {
+ − 707 return bytebpos_to_membpos (buf, charbpos_to_bytebpos (buf, x));
+ − 708 }
+ − 709
+ − 710 /*----------------------------------------------------------------------*/
+ − 711 /* Generalized buffer/string position convertors */
+ − 712 /*----------------------------------------------------------------------*/
+ − 713
+ − 714 /* These macros generalize many standard buffer-position functions to
+ − 715 either a buffer or a string. */
+ − 716
+ − 717 /* Converting between Memxpos's and Bytexpos's, for a buffer-or-string.
+ − 718 For strings, this is a no-op. For buffers, this resolves
+ − 719 to the standard membpos<->bytebpos converters. */
+ − 720
+ − 721 DECLARE_INLINE_HEADER (
+ − 722 Memxpos buffer_or_string_bytexpos_to_memxpos (Lisp_Object obj, Bytexpos pos)
+ − 723 )
+ − 724 {
+ − 725 return (BUFFERP (obj) ? bytebpos_to_membpos (XBUFFER (obj), pos) :
+ − 726 (Memxpos) pos);
428
+ − 727 }
+ − 728
826
+ − 729 DECLARE_INLINE_HEADER (
+ − 730 Bytexpos buffer_or_string_memxpos_to_bytexpos (Lisp_Object obj, Memxpos pos)
+ − 731 )
+ − 732 {
+ − 733 return (BUFFERP (obj) ? membpos_to_bytebpos (XBUFFER (obj), pos) :
+ − 734 (Bytexpos) pos);
+ − 735 }
+ − 736
+ − 737 /* Converting between Charxpos's and Bytexpos's, for a buffer-or-string.
+ − 738 For strings, this maps to the bytecount<->charcount converters. */
+ − 739
+ − 740 DECLARE_INLINE_HEADER (
+ − 741 Bytexpos buffer_or_string_charxpos_to_bytexpos (Lisp_Object obj, Charxpos pos)
+ − 742 )
+ − 743 {
+ − 744 return (BUFFERP (obj) ? charbpos_to_bytebpos (XBUFFER (obj), pos) :
+ − 745 (Bytexpos) string_index_char_to_byte (obj, pos));
+ − 746 }
+ − 747
+ − 748 DECLARE_INLINE_HEADER (
+ − 749 Charxpos buffer_or_string_bytexpos_to_charxpos (Lisp_Object obj, Bytexpos pos)
+ − 750 )
+ − 751 {
+ − 752 return (BUFFERP (obj) ? bytebpos_to_charbpos (XBUFFER (obj), pos) :
+ − 753 (Charxpos) string_index_byte_to_char (obj, pos));
+ − 754 }
428
+ − 755
826
+ − 756 /* Similar for Charxpos's and Memxpos's. */
+ − 757
+ − 758 DECLARE_INLINE_HEADER (
+ − 759 Memxpos buffer_or_string_charxpos_to_memxpos (Lisp_Object obj, Charxpos pos)
+ − 760 )
+ − 761 {
+ − 762 return (BUFFERP (obj) ? charbpos_to_membpos (XBUFFER (obj), pos) :
+ − 763 (Memxpos) string_index_char_to_byte (obj, pos));
+ − 764 }
428
+ − 765
826
+ − 766 DECLARE_INLINE_HEADER (
+ − 767 Charxpos buffer_or_string_memxpos_to_charxpos (Lisp_Object obj, Memxpos pos)
+ − 768 )
+ − 769 {
+ − 770 return (BUFFERP (obj) ? membpos_to_charbpos (XBUFFER (obj), pos) :
+ − 771 (Charxpos) string_index_byte_to_char (obj, pos));
+ − 772 }
428
+ − 773
826
+ − 774 DECLARE_INLINE_HEADER (
+ − 775 Internal_Format buffer_or_other_internal_format (Lisp_Object obj)
+ − 776 )
+ − 777 {
+ − 778 return BUFFERP (obj) ? BUF_FORMAT (XBUFFER (obj)) : FORMAT_DEFAULT;
+ − 779 }
+ − 780
+ − 781 /* Return the index to the character before the one at X,
+ − 782 in a buffer or string. */
428
+ − 783
826
+ − 784 DECLARE_INLINE_HEADER (
+ − 785 Bytebpos
+ − 786 prev_bytexpos (Lisp_Object obj, Bytebpos x)
+ − 787 )
+ − 788 {
+ − 789 return BUFFERP (obj) ? prev_bytebpos (XBUFFER (obj), x) :
+ − 790 prev_string_index (obj, x);
+ − 791 }
+ − 792
+ − 793 /* Return the index to the character after the one at X,
+ − 794 in a buffer or string. */
428
+ − 795
826
+ − 796 DECLARE_INLINE_HEADER (
+ − 797 Bytebpos
+ − 798 next_bytexpos (Lisp_Object obj, Bytebpos x)
+ − 799 )
+ − 800 {
+ − 801 return BUFFERP (obj) ? next_bytebpos (XBUFFER (obj), x) :
+ − 802 next_string_index (obj, x);
+ − 803 }
+ − 804
+ − 805 /*----------------------------------------------------------------------*/
+ − 806 /* Converting between positions and addresses */
+ − 807 /*----------------------------------------------------------------------*/
428
+ − 808
826
+ − 809 /* Convert the address of a byte in the buffer into a position. */
+ − 810 DECLARE_INLINE_HEADER (
+ − 811 Bytebpos
867
+ − 812 BYTE_BUF_PTR_BYTE_POS (struct buffer *buf, Ibyte *ptr)
826
+ − 813 )
+ − 814 {
+ − 815 Bytebpos retval = (ptr - buf->text->beg + 1
+ − 816 - ((ptr - buf->text->beg + 1) > buf->text->gpt
+ − 817 ? buf->text->gap_size : (Bytebpos) 0));
+ − 818 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, retval);
+ − 819 return retval;
+ − 820 }
+ − 821
+ − 822 #define BUF_PTR_BYTE_POS(buf, ptr) \
+ − 823 bytebpos_to_charbpos (buf, BYTE_BUF_PTR_BYTE_POS (buf, ptr))
428
+ − 824
826
+ − 825 /* Address of byte at position POS in buffer. */
+ − 826 DECLARE_INLINE_HEADER (
867
+ − 827 Ibyte *
826
+ − 828 BYTE_BUF_BYTE_ADDRESS (struct buffer *buf, Bytebpos pos)
+ − 829 )
+ − 830 {
+ − 831 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, pos);
+ − 832 return BYTE_BUF_BYTE_ADDRESS_NO_VERIFY (buf, pos);
+ − 833 }
+ − 834
+ − 835 #define BUF_BYTE_ADDRESS(buf, pos) \
+ − 836 BYTE_BUF_BYTE_ADDRESS (buf, charbpos_to_bytebpos (buf, pos))
428
+ − 837
826
+ − 838 /* Address of byte before position POS in buffer. */
+ − 839 DECLARE_INLINE_HEADER (
867
+ − 840 Ibyte *
826
+ − 841 BYTE_BUF_BYTE_ADDRESS_BEFORE (struct buffer *buf, Bytebpos pos)
+ − 842 )
+ − 843 {
+ − 844 ASSERT_VALID_BYTEBPOS_UNSAFE (buf, pos);
+ − 845 return (buf->text->beg +
+ − 846 ((pos > buf->text->gpt ? (pos + buf->text->gap_size) : pos)
+ − 847 - 2));
+ − 848 }
+ − 849
+ − 850 #define BUF_BYTE_ADDRESS_BEFORE(buf, pos) \
+ − 851 BYTE_BUF_BYTE_ADDRESS_BEFORE (buf, charbpos_to_bytebpos (buf, pos))
428
+ − 852
+ − 853 /*----------------------------------------------------------------------*/
+ − 854 /* Converting between buffer bytes and Emacs characters */
+ − 855 /*----------------------------------------------------------------------*/
+ − 856
+ − 857 /* The character at position POS in buffer. */
826
+ − 858
+ − 859 #define BYTE_BUF_FETCH_CHAR(buf, pos) \
867
+ − 860 itext_ichar_fmt (BYTE_BUF_BYTE_ADDRESS (buf, pos), BUF_FORMAT (buf), \
826
+ − 861 wrap_buffer (buf))
428
+ − 862 #define BUF_FETCH_CHAR(buf, pos) \
826
+ − 863 BYTE_BUF_FETCH_CHAR (buf, charbpos_to_bytebpos (buf, pos))
+ − 864
+ − 865 /* The "raw value" of the character at position POS in buffer.
867
+ − 866 See ichar_to_raw(). */
826
+ − 867
+ − 868 #define BYTE_BUF_FETCH_CHAR_RAW(buf, pos) \
867
+ − 869 itext_ichar_raw_fmt (BYTE_BUF_BYTE_ADDRESS (buf, pos), BUF_FORMAT (buf))
826
+ − 870 #define BUF_FETCH_CHAR_RAW(buf, pos) \
+ − 871 BYTE_BUF_FETCH_CHAR_RAW (buf, charbpos_to_bytebpos (buf, pos))
428
+ − 872
+ − 873 /* The character at position POS in buffer, as a string. This is
867
+ − 874 equivalent to set_itext_ichar (str, BUF_FETCH_CHAR (buf, pos))
428
+ − 875 but is faster for Mule. */
+ − 876
867
+ − 877 # define BYTE_BUF_ITEXT_COPY_ICHAR(buf, pos, str) \
826
+ − 878 (BUF_FORMAT (buf) == FORMAT_DEFAULT ? \
867
+ − 879 itext_copy_ichar (BYTE_BUF_BYTE_ADDRESS (buf, pos), str) : \
+ − 880 set_itext_ichar (str, BYTE_BUF_FETCH_CHAR (buf, pos)))
+ − 881 #define BUF_ITEXT_COPY_ICHAR(buf, pos, str) \
+ − 882 BYTE_BUF_ITEXT_COPY_ICHAR (buf, charbpos_to_bytebpos (buf, pos), str)
428
+ − 883
+ − 884
+ − 885 /************************************************************************/
440
+ − 886 /* */
428
+ − 887 /* higher-level buffer-position functions */
+ − 888 /* */
+ − 889 /************************************************************************/
+ − 890
+ − 891 /*----------------------------------------------------------------------*/
+ − 892 /* Settor macros for important positions in a buffer */
+ − 893 /*----------------------------------------------------------------------*/
+ − 894
+ − 895 /* Set beginning of accessible range of buffer. */
826
+ − 896 #define SET_BOTH_BUF_BEGV(buf, val, bpval) \
428
+ − 897 do \
+ − 898 { \
826
+ − 899 (buf)->begv = (bpval); \
428
+ − 900 (buf)->bufbegv = (val); \
+ − 901 } while (0)
+ − 902
+ − 903 /* Set end of accessible range of buffer. */
826
+ − 904 #define SET_BOTH_BUF_ZV(buf, val, bpval) \
428
+ − 905 do \
+ − 906 { \
826
+ − 907 (buf)->zv = (bpval); \
428
+ − 908 (buf)->bufzv = (val); \
+ − 909 } while (0)
+ − 910
+ − 911 /* Set point. */
+ − 912 /* Since BEGV and ZV are almost never set, it's reasonable to enforce
665
+ − 913 the restriction that the Charbpos and Bytebpos values must both be
428
+ − 914 specified. However, point is set in lots and lots of places. So
+ − 915 we provide the ability to specify both (for efficiency) or just
+ − 916 one. */
826
+ − 917 #define BOTH_BUF_SET_PT(buf, val, bpval) set_buffer_point (buf, val, bpval)
+ − 918 #define BYTE_BUF_SET_PT(buf, bpval) \
+ − 919 do \
+ − 920 { \
+ − 921 Bytebpos __bpbsp_bpval = (bpval); \
+ − 922 BOTH_BUF_SET_PT (buf, bytebpos_to_charbpos (buf, __bpbsp_bpval), \
+ − 923 __bpbsp_bpval); \
+ − 924 } while (0)
+ − 925 #define BUF_SET_PT(buf, value) \
+ − 926 do \
+ − 927 { \
+ − 928 Bytebpos __bsp_val = (value); \
+ − 929 BOTH_BUF_SET_PT (buf, __bsp_val, charbpos_to_bytebpos (buf, __bsp_val)); \
+ − 930 } while (0)
428
+ − 931
+ − 932
+ − 933 #if 0 /* FSFmacs */
+ − 934 /* These macros exist in FSFmacs because SET_PT() in FSFmacs incorrectly
+ − 935 does too much stuff, such as moving out of invisible extents. */
+ − 936 #define TEMP_SET_PT(position) (temp_set_point ((position), current_buffer))
+ − 937 #define SET_BUF_PT(buf, value) ((buf)->pt = (value))
+ − 938 #endif /* FSFmacs */
+ − 939
+ − 940 /*----------------------------------------------------------------------*/
+ − 941 /* Miscellaneous buffer values */
+ − 942 /*----------------------------------------------------------------------*/
+ − 943
+ − 944 /* Number of characters in buffer */
+ − 945 #define BUF_SIZE(buf) (BUF_Z (buf) - BUF_BEG (buf))
+ − 946
+ − 947 /* Is this buffer narrowed? */
+ − 948 #define BUF_NARROWED(buf) \
826
+ − 949 ((BYTE_BUF_BEGV (buf) != BYTE_BUF_BEG (buf)) || \
+ − 950 (BYTE_BUF_ZV (buf) != BYTE_BUF_Z (buf)))
428
+ − 951
826
+ − 952 /* Modification count */
428
+ − 953 #define BUF_MODIFF(buf) ((buf)->text->modiff)
+ − 954
826
+ − 955 /* Saved modification count */
428
+ − 956 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
+ − 957
+ − 958 /* Face changed. */
+ − 959 #define BUF_FACECHANGE(buf) ((buf)->face_change)
+ − 960
826
+ − 961 DECLARE_INLINE_HEADER (
+ − 962 int
+ − 963 POINT_MARKER_P (Lisp_Object marker)
+ − 964 )
+ − 965 {
+ − 966 return (XMARKER (marker)->buffer != 0 &&
+ − 967 EQ (marker, XMARKER (marker)->buffer->point_marker));
+ − 968 }
428
+ − 969
+ − 970 #define BUF_MARKERS(buf) ((buf)->markers)
+ − 971
826
+ − 972 #ifdef MULE
+ − 973
+ − 974 DECLARE_INLINE_HEADER (
+ − 975 Lisp_Object
+ − 976 BUFFER_CATEGORY_TABLE (struct buffer *buf)
+ − 977 )
+ − 978 {
+ − 979 return buf ? buf->category_table : Vstandard_category_table;
+ − 980 }
+ − 981
+ − 982 #endif /* MULE */
+ − 983
+ − 984 DECLARE_INLINE_HEADER (
+ − 985 Lisp_Object
+ − 986 BUFFER_SYNTAX_TABLE (struct buffer *buf)
+ − 987 )
+ − 988 {
+ − 989 return buf ? buf->syntax_table : Vstandard_syntax_table;
+ − 990 }
+ − 991
+ − 992 DECLARE_INLINE_HEADER (
+ − 993 Lisp_Object
+ − 994 BUFFER_MIRROR_SYNTAX_TABLE (struct buffer *buf)
+ − 995 )
+ − 996 {
+ − 997 return buf ? buf->mirror_syntax_table :
+ − 998 XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
+ − 999 }
+ − 1000
428
+ − 1001 /* WARNING:
+ − 1002
+ − 1003 The new definitions of CEILING_OF() and FLOOR_OF() differ semantically
+ − 1004 from the old ones (in FSF Emacs and XEmacs 19.11 and before).
+ − 1005 Conversion is as follows:
+ − 1006
826
+ − 1007 OLD_BYTE_CEILING_OF(n) = NEW_BYTE_CEILING_OF(n) - 1
+ − 1008 OLD_BYTE_FLOOR_OF(n) = NEW_BYTE_FLOOR_OF(n + 1)
428
+ − 1009
+ − 1010 The definitions were changed because the new definitions are more
771
+ − 1011 consistent with the way everything else works in XEmacs.
428
+ − 1012 */
+ − 1013
826
+ − 1014 /* Properties of CEILING_OF and FLOOR_OF (also apply to BYTE_ variants):
428
+ − 1015
+ − 1016 1) FLOOR_OF (CEILING_OF (n)) = n
+ − 1017 CEILING_OF (FLOOR_OF (n)) = n
+ − 1018
+ − 1019 2) CEILING_OF (n) = n if and only if n = ZV
+ − 1020 FLOOR_OF (n) = n if and only if n = BEGV
+ − 1021
+ − 1022 3) CEILING_OF (CEILING_OF (n)) = ZV
+ − 1023 FLOOR_OF (FLOOR_OF (n)) = BEGV
+ − 1024
+ − 1025 4) The bytes in the regions
+ − 1026
+ − 1027 [BYTE_ADDRESS (n), BYTE_ADDRESS_BEFORE (CEILING_OF (n))]
+ − 1028
+ − 1029 and
+ − 1030
+ − 1031 [BYTE_ADDRESS (FLOOR_OF (n)), BYTE_ADDRESS_BEFORE (n)]
+ − 1032
+ − 1033 are contiguous.
771
+ − 1034
+ − 1035 A typical loop using CEILING_OF to process contiguous ranges of text
+ − 1036 between [from, to) looks like this:
+ − 1037
+ − 1038 {
+ − 1039 Bytebpos pos = from;
+ − 1040
+ − 1041 while (pos < to)
+ − 1042 {
826
+ − 1043 Bytebpos ceil = BYTE_BUF_CEILING_OF (buf, pos);
771
+ − 1044 ceil = min (to, ceil);
867
+ − 1045 process_ibyte_string (BYTE_BUF_BYTE_ADDRESS (buf, pos), ceil - pos);
771
+ − 1046 pos = ceil;
+ − 1047 }
+ − 1048 }
+ − 1049
+ − 1050 Currently there will be at most two iterations in the loop, but it is
+ − 1051 written in such a way that it will still work if the buffer
+ − 1052 representation is changed to have multiple gaps in it.
+ − 1053 */
428
+ − 1054
826
+ − 1055 /* Return the maximum position in the buffer it is safe to scan forwards
428
+ − 1056 past N to. This is used to prevent buffer scans from running into
+ − 1057 the gap (e.g. search.c). All characters between N and CEILING_OF(N)
+ − 1058 are located contiguous in memory. Note that the character *at*
+ − 1059 CEILING_OF(N) is not contiguous in memory. */
826
+ − 1060 #define BYTE_BUF_CEILING_OF(b, n) \
2367
+ − 1061 ((n) < BYTE_BUF_GPT (b) && BYTE_BUF_GPT (b) < BYTE_BUF_ZV (b) ? \
+ − 1062 BYTE_BUF_GPT (b) : BYTE_BUF_ZV (b))
+ − 1063 #define BUF_CEILING_OF(b, n) \
+ − 1064 ((n) < BUF_GPT (b) && BUF_GPT (b) < BUF_ZV (b) ? \
+ − 1065 BUF_GPT (b) : BUF_ZV (b))
428
+ − 1066
826
+ − 1067 /* Return the minimum position in the buffer it is safe to scan backwards
428
+ − 1068 past N to. All characters between FLOOR_OF(N) and N are located
+ − 1069 contiguous in memory. Note that the character *at* N may not be
+ − 1070 contiguous in memory. */
2367
+ − 1071 #define BYTE_BUF_FLOOR_OF(b, n) \
+ − 1072 (BYTE_BUF_BEGV (b) < BYTE_BUF_GPT (b) && BYTE_BUF_GPT (b) < (n) ? \
+ − 1073 BYTE_BUF_GPT (b) : BYTE_BUF_BEGV (b))
+ − 1074 #define BUF_FLOOR_OF(b, n) \
+ − 1075 (BUF_BEGV (b) < BUF_GPT (b) && BUF_GPT (b) < (n) ? \
+ − 1076 BUF_GPT (b) : BUF_BEGV (b))
428
+ − 1077
826
+ − 1078 #define BYTE_BUF_CEILING_OF_IGNORE_ACCESSIBLE(b, n) \
2367
+ − 1079 ((n) < BYTE_BUF_GPT (b) && BYTE_BUF_GPT (b) < BYTE_BUF_Z (b) ? \
+ − 1080 BYTE_BUF_GPT (b) : BYTE_BUF_Z (b))
+ − 1081 #define BUF_CEILING_OF_IGNORE_ACCESSIBLE(b, n) \
+ − 1082 ((n) < BUF_GPT (b) && BUF_GPT (b) < BUF_Z (b) ? \
+ − 1083 BUF_GPT (b) : BUF_Z (b))
428
+ − 1084
2367
+ − 1085 #define BYTE_BUF_FLOOR_OF_IGNORE_ACCESSIBLE(b, n) \
+ − 1086 (BYTE_BUF_BEG (b) < BYTE_BUF_GPT (b) && BYTE_BUF_GPT (b) < (n) ? \
+ − 1087 BYTE_BUF_GPT (b) : BYTE_BUF_BEG (b))
+ − 1088 #define BUF_FLOOR_OF_IGNORE_ACCESSIBLE(b, n) \
+ − 1089 (BUF_BEG (b) < BUF_GPT (b) && BUF_GPT (b) < (n) ? \
+ − 1090 BUF_GPT (b) : BUF_BEG (b))
826
+ − 1091
+ − 1092 /* Iterate over contiguous chunks of text in buffer BUF, starting at POS,
+ − 1093 of length LEN. Evaluates POS and LEN only once, but BUF multiply. In
+ − 1094 each iteration, store the current chunk into RUNPTR/RUNLEN, which will
+ − 1095 be automatically declared (don't declare them yourself). This does not
+ − 1096 respect the limits of accessibility (BUF_BEGV/BUF_ZV); if you want these
+ − 1097 limits respected, you need to impose them yourself.
+ − 1098
+ − 1099 NOTE: This must be surrounded with braces! */
+ − 1100
+ − 1101 #define BUFFER_TEXT_LOOP(buf, pos, len, runptr, runlen) \
2367
+ − 1102 Ibyte *runptr; \
826
+ − 1103 Bytecount runlen; \
+ − 1104 Bytebpos BTL_pos = (pos); \
+ − 1105 Bytebpos BTL_len = (len); \
+ − 1106 for (runptr = BYTE_BUF_BYTE_ADDRESS (buf, BTL_pos), \
+ − 1107 runlen = BYTE_BUF_CEILING_OF_IGNORE_ACCESSIBLE (buf, BTL_pos) - BTL_pos, \
+ − 1108 runlen = min (BTL_len, runlen); \
+ − 1109 BTL_len > 0; \
+ − 1110 BTL_pos += runlen, \
+ − 1111 BTL_len -= runlen, \
+ − 1112 runptr = BYTE_BUF_BYTE_ADDRESS (buf, BTL_pos), \
+ − 1113 runlen = BYTE_BUF_CEILING_OF_IGNORE_ACCESSIBLE (buf, BTL_pos) - BTL_pos, \
+ − 1114 runlen = min (BTL_len, runlen))
428
+ − 1115
+ − 1116 /* This structure marks which slots in a buffer have corresponding
+ − 1117 default values in Vbuffer_defaults.
+ − 1118 Each such slot has a nonzero value in this structure.
+ − 1119 The value has only one nonzero bit.
+ − 1120
+ − 1121 When a buffer has its own local value for a slot,
+ − 1122 the bit for that slot (found in the same slot in this structure)
+ − 1123 is turned on in the buffer's local_var_flags slot.
+ − 1124
+ − 1125 If a slot in this structure is zero, then even though there may
+ − 1126 be a DEFVAR_BUFFER_LOCAL for the slot, there is no default value for it;
+ − 1127 and the corresponding slot in Vbuffer_defaults is not used. */
+ − 1128
+ − 1129 extern struct buffer buffer_local_flags;
+ − 1130
+ − 1131
+ − 1132 /* Allocation of buffer data. */
+ − 1133
+ − 1134 #ifdef REL_ALLOC
+ − 1135
440
+ − 1136 char *r_alloc (unsigned char **, size_t);
+ − 1137 char *r_re_alloc (unsigned char **, size_t);
428
+ − 1138 void r_alloc_free (unsigned char **);
+ − 1139
+ − 1140 #define BUFFER_ALLOC(data, size) \
867
+ − 1141 ((Ibyte *) r_alloc ((unsigned char **) &data, (size) * sizeof(Ibyte)))
428
+ − 1142 #define BUFFER_REALLOC(data, size) \
867
+ − 1143 ((Ibyte *) r_re_alloc ((unsigned char **) &data, (size) * sizeof(Ibyte)))
428
+ − 1144 #define BUFFER_FREE(data) r_alloc_free ((unsigned char **) &(data))
+ − 1145 #define R_ALLOC_DECLARE(var,data) r_alloc_declare (&(var), data)
+ − 1146
+ − 1147 #else /* !REL_ALLOC */
+ − 1148
+ − 1149 #define BUFFER_ALLOC(data,size)\
867
+ − 1150 (data = xnew_array (Ibyte, size))
428
+ − 1151 #define BUFFER_REALLOC(data,size)\
867
+ − 1152 ((Ibyte *) xrealloc (data, (size) * sizeof(Ibyte)))
428
+ − 1153 /* Avoid excess parentheses, or syntax errors may rear their heads. */
1726
+ − 1154 #define BUFFER_FREE(data) xfree (data, Ibyte *)
428
+ − 1155 #define R_ALLOC_DECLARE(var,data)
+ − 1156
+ − 1157 #endif /* !REL_ALLOC */
+ − 1158
+ − 1159
+ − 1160 /************************************************************************/
+ − 1161 /* Case conversion */
+ − 1162 /************************************************************************/
+ − 1163
+ − 1164 /* A "trt" table is a mapping from characters to other characters,
826
+ − 1165 typically used to convert between uppercase and lowercase.
428
+ − 1166 */
+ − 1167
+ − 1168 /* The _1 macros are named as such because they assume that you have
+ − 1169 already guaranteed that the character values are all in the range
+ − 1170 0 - 255. Bad lossage will happen otherwise. */
+ − 1171
446
+ − 1172 #define MAKE_TRT_TABLE() Fmake_char_table (Qgeneric)
826
+ − 1173 DECLARE_INLINE_HEADER (
867
+ − 1174 Ichar
+ − 1175 TRT_TABLE_OF (Lisp_Object table, Ichar ch)
826
+ − 1176 )
446
+ − 1177 {
+ − 1178 Lisp_Object TRT_char;
826
+ − 1179 TRT_char = get_char_table (ch, table);
446
+ − 1180 if (NILP (TRT_char))
+ − 1181 return ch;
+ − 1182 else
+ − 1183 return XCHAR (TRT_char);
+ − 1184 }
826
+ − 1185 #define SET_TRT_TABLE_OF(table, ch1, ch2) \
+ − 1186 Fput_char_table (make_char (ch1), make_char (ch2), table)
428
+ − 1187
826
+ − 1188 DECLARE_INLINE_HEADER (
+ − 1189 Lisp_Object
771
+ − 1190 BUFFER_CASE_TABLE (struct buffer *buf)
826
+ − 1191 )
771
+ − 1192 {
+ − 1193 return buf ? buf->case_table : Vstandard_case_table;
+ − 1194 }
+ − 1195
428
+ − 1196 /* Macros used below. */
446
+ − 1197 #define DOWNCASE_TABLE_OF(buf, c) \
771
+ − 1198 TRT_TABLE_OF (XCASE_TABLE_DOWNCASE (BUFFER_CASE_TABLE (buf)), c)
446
+ − 1199 #define UPCASE_TABLE_OF(buf, c) \
771
+ − 1200 TRT_TABLE_OF (XCASE_TABLE_UPCASE (BUFFER_CASE_TABLE (buf)), c)
428
+ − 1201
+ − 1202 /* 1 if CH is upper case. */
+ − 1203
826
+ − 1204 DECLARE_INLINE_HEADER (
+ − 1205 int
867
+ − 1206 UPPERCASEP (struct buffer *buf, Ichar ch)
826
+ − 1207 )
428
+ − 1208 {
+ − 1209 return DOWNCASE_TABLE_OF (buf, ch) != ch;
+ − 1210 }
+ − 1211
+ − 1212 /* 1 if CH is lower case. */
+ − 1213
826
+ − 1214 DECLARE_INLINE_HEADER (
+ − 1215 int
867
+ − 1216 LOWERCASEP (struct buffer *buf, Ichar ch)
826
+ − 1217 )
428
+ − 1218 {
+ − 1219 return (UPCASE_TABLE_OF (buf, ch) != ch &&
+ − 1220 DOWNCASE_TABLE_OF (buf, ch) == ch);
+ − 1221 }
+ − 1222
+ − 1223 /* 1 if CH is neither upper nor lower case. */
+ − 1224
826
+ − 1225 DECLARE_INLINE_HEADER (
+ − 1226 int
867
+ − 1227 NOCASEP (struct buffer *buf, Ichar ch)
826
+ − 1228 )
428
+ − 1229 {
+ − 1230 return UPCASE_TABLE_OF (buf, ch) == ch;
+ − 1231 }
+ − 1232
+ − 1233 /* Upcase a character, or make no change if that cannot be done. */
+ − 1234
826
+ − 1235 DECLARE_INLINE_HEADER (
867
+ − 1236 Ichar
+ − 1237 UPCASE (struct buffer *buf, Ichar ch)
826
+ − 1238 )
428
+ − 1239 {
+ − 1240 return (DOWNCASE_TABLE_OF (buf, ch) == ch) ? UPCASE_TABLE_OF (buf, ch) : ch;
+ − 1241 }
+ − 1242
+ − 1243 /* Upcase a character known to be not upper case. Unused. */
+ − 1244
+ − 1245 #define UPCASE1(buf, ch) UPCASE_TABLE_OF (buf, ch)
+ − 1246
+ − 1247 /* Downcase a character, or make no change if that cannot be done. */
+ − 1248
+ − 1249 #define DOWNCASE(buf, ch) DOWNCASE_TABLE_OF (buf, ch)
+ − 1250
440
+ − 1251 #endif /* INCLUDED_buffer_h_ */
