1 /* Header file for the buffer manipulation primitives.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software Foundation,
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <sys/types.h> /* for off_t, time_t */
22 #include "systime.h" /* for EMACS_TIME */
26 # define BUFFER_INLINE INLINE
29 /* Accessing the parameters of the current buffer. */
31 /* These macros come in pairs, one for the char position
32 and one for the byte position. */
34 /* Position of beginning of buffer. */
36 #define BEG_BYTE (BEG)
38 /* Position of beginning of accessible range of buffer. */
39 #define BEGV (current_buffer->begv)
40 #define BEGV_BYTE (current_buffer->begv_byte)
42 /* Position of point in buffer. The "+ 0" makes this
43 not an l-value, so you can't assign to it. Use SET_PT instead. */
44 #define PT (current_buffer->pt + 0)
45 #define PT_BYTE (current_buffer->pt_byte + 0)
47 /* Position of gap in buffer. */
48 #define GPT (current_buffer->text->gpt)
49 #define GPT_BYTE (current_buffer->text->gpt_byte)
51 /* Position of end of accessible range of buffer. */
52 #define ZV (current_buffer->zv)
53 #define ZV_BYTE (current_buffer->zv_byte)
55 /* Position of end of buffer. */
56 #define Z (current_buffer->text->z)
57 #define Z_BYTE (current_buffer->text->z_byte)
59 /* Macros for the addresses of places in the buffer. */
61 /* Address of beginning of buffer. */
62 #define BEG_ADDR (current_buffer->text->beg)
64 /* Address of beginning of accessible range of buffer. */
65 #define BEGV_ADDR (BYTE_POS_ADDR (current_buffer->begv_byte))
67 /* Address of point in buffer. */
68 #define PT_ADDR (BYTE_POS_ADDR (current_buffer->pt_byte))
70 /* Address of beginning of gap in buffer. */
71 #define GPT_ADDR (current_buffer->text->beg + current_buffer->text->gpt_byte - BEG_BYTE)
73 /* Address of end of gap in buffer. */
74 #define GAP_END_ADDR (current_buffer->text->beg + current_buffer->text->gpt_byte + current_buffer->text->gap_size - BEG_BYTE)
76 /* Address of end of accessible range of buffer. */
77 #define ZV_ADDR (BYTE_POS_ADDR (current_buffer->zv_byte))
79 /* Address of end of buffer. */
80 #define Z_ADDR (current_buffer->text->beg + current_buffer->text->gap_size + current_buffer->text->z_byte - BEG_BYTE)
83 #define GAP_SIZE (current_buffer->text->gap_size)
85 /* Is the current buffer narrowed? */
86 #define NARROWED ((BEGV != BEG) || (ZV != Z))
88 /* Modification count. */
89 #define MODIFF (current_buffer->text->modiff)
91 /* Character modification count. */
92 #define CHARS_MODIFF (current_buffer->text->chars_modiff)
94 /* Overlay modification count. */
95 #define OVERLAY_MODIFF (current_buffer->text->overlay_modiff)
97 /* Modification count as of last visit or save. */
98 #define SAVE_MODIFF (current_buffer->text->save_modiff)
100 /* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return
101 the max (resp. min) p such that
103 BYTE_POS_ADDR (p) - BYTE_POS_ADDR (n) == p - n */
105 #define BUFFER_CEILING_OF(BYTEPOS) \
106 (((BYTEPOS) < GPT_BYTE && GPT < ZV ? GPT_BYTE : ZV_BYTE) - 1)
107 #define BUFFER_FLOOR_OF(BYTEPOS) \
108 (BEGV <= GPT && GPT_BYTE <= (BYTEPOS) ? GPT_BYTE : BEGV_BYTE)
110 /* Similar macros to operate on a specified buffer.
111 Note that many of these evaluate the buffer argument more than once. */
113 /* Position of beginning of buffer. */
114 #define BUF_BEG(buf) (BEG)
115 #define BUF_BEG_BYTE(buf) (BEG_BYTE)
117 /* The BUF_BEGV[_BYTE], BUF_ZV[_BYTE], and BUF_PT[_BYTE] macros cannot
118 be used for assignment; use SET_BUF_* macros below for that. */
120 /* Position of beginning of accessible range of buffer. */
121 #define BUF_BEGV(buf) \
122 (buf == current_buffer ? BEGV \
123 : NILP (BVAR (buf, begv_marker)) ? buf->begv \
124 : marker_position (BVAR (buf, begv_marker)))
126 #define BUF_BEGV_BYTE(buf) \
127 (buf == current_buffer ? BEGV_BYTE \
128 : NILP (BVAR (buf, begv_marker)) ? buf->begv_byte \
129 : marker_byte_position (BVAR (buf, begv_marker)))
131 /* Position of point in buffer. */
132 #define BUF_PT(buf) \
133 (buf == current_buffer ? PT \
134 : NILP (BVAR (buf, pt_marker)) ? buf->pt \
135 : marker_position (BVAR (buf, pt_marker)))
137 #define BUF_PT_BYTE(buf) \
138 (buf == current_buffer ? PT_BYTE \
139 : NILP (BVAR (buf, pt_marker)) ? buf->pt_byte \
140 : marker_byte_position (BVAR (buf, pt_marker)))
142 /* Position of end of accessible range of buffer. */
143 #define BUF_ZV(buf) \
144 (buf == current_buffer ? ZV \
145 : NILP (BVAR (buf, zv_marker)) ? buf->zv \
146 : marker_position (BVAR (buf, zv_marker)))
148 #define BUF_ZV_BYTE(buf) \
149 (buf == current_buffer ? ZV_BYTE \
150 : NILP (BVAR (buf, zv_marker)) ? buf->zv_byte \
151 : marker_byte_position (BVAR (buf, zv_marker)))
153 /* Position of gap in buffer. */
154 #define BUF_GPT(buf) ((buf)->text->gpt)
155 #define BUF_GPT_BYTE(buf) ((buf)->text->gpt_byte)
157 /* Position of end of buffer. */
158 #define BUF_Z(buf) ((buf)->text->z)
159 #define BUF_Z_BYTE(buf) ((buf)->text->z_byte)
161 /* Address of beginning of buffer. */
162 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
164 /* Address of beginning of gap of buffer. */
165 #define BUF_GPT_ADDR(buf) ((buf)->text->beg + (buf)->text->gpt_byte - BEG_BYTE)
167 /* Address of end of buffer. */
168 #define BUF_Z_ADDR(buf) ((buf)->text->beg + (buf)->text->gap_size + (buf)->text->z_byte - BEG_BYTE)
170 /* Address of end of gap in buffer. */
171 #define BUF_GAP_END_ADDR(buf) ((buf)->text->beg + (buf)->text->gpt_byte + (buf)->text->gap_size - BEG_BYTE)
174 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size)
176 /* Is this buffer narrowed? */
177 #define BUF_NARROWED(buf) ((BUF_BEGV (buf) != BUF_BEG (buf)) \
178 || (BUF_ZV (buf) != BUF_Z (buf)))
180 /* Modification count. */
181 #define BUF_MODIFF(buf) ((buf)->text->modiff)
183 /* Character modification count. */
184 #define BUF_CHARS_MODIFF(buf) ((buf)->text->chars_modiff)
186 /* Modification count as of last visit or save. */
187 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
189 /* Overlay modification count. */
190 #define BUF_OVERLAY_MODIFF(buf) ((buf)->text->overlay_modiff)
192 /* Modification count as of last auto-save. */
193 /* FIXME: should we move this into ->text->auto_save_modiff? */
194 #define BUF_AUTOSAVE_MODIFF(buf) ((buf)->auto_save_modified)
196 /* Compaction count. */
197 #define BUF_COMPACT(buf) ((buf)->text->compact)
199 /* Marker chain of buffer. */
200 #define BUF_MARKERS(buf) ((buf)->text->markers)
202 #define BUF_UNCHANGED_MODIFIED(buf) \
203 ((buf)->text->unchanged_modified)
205 #define BUF_OVERLAY_UNCHANGED_MODIFIED(buf) \
206 ((buf)->text->overlay_unchanged_modified)
207 #define BUF_BEG_UNCHANGED(buf) ((buf)->text->beg_unchanged)
208 #define BUF_END_UNCHANGED(buf) ((buf)->text->end_unchanged)
210 #define UNCHANGED_MODIFIED \
211 BUF_UNCHANGED_MODIFIED (current_buffer)
212 #define OVERLAY_UNCHANGED_MODIFIED \
213 BUF_OVERLAY_UNCHANGED_MODIFIED (current_buffer)
214 #define BEG_UNCHANGED BUF_BEG_UNCHANGED (current_buffer)
215 #define END_UNCHANGED BUF_END_UNCHANGED (current_buffer)
217 /* Compute how many characters at the top and bottom of BUF are
218 unchanged when the range START..END is modified. This computation
219 must be done each time BUF is modified. */
221 #define BUF_COMPUTE_UNCHANGED(buf, start, end) \
224 if (BUF_UNCHANGED_MODIFIED (buf) == BUF_MODIFF (buf) \
225 && (BUF_OVERLAY_UNCHANGED_MODIFIED (buf) \
226 == BUF_OVERLAY_MODIFF (buf))) \
228 BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf); \
229 BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end); \
233 if (BUF_Z (buf) - (end) < BUF_END_UNCHANGED (buf)) \
234 BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end); \
235 if ((start) - BUF_BEG (buf) < BUF_BEG_UNCHANGED (buf)) \
236 BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf); \
242 /* Macros to set PT in the current buffer, or another buffer. */
244 #define SET_PT(position) (set_point (position))
245 #define TEMP_SET_PT(position) (temp_set_point (current_buffer, (position)))
247 #define SET_PT_BOTH(position, byte) (set_point_both (position, byte))
248 #define TEMP_SET_PT_BOTH(position, byte) \
249 (temp_set_point_both (current_buffer, (position), (byte)))
251 #define BUF_TEMP_SET_PT(buffer, position) \
252 (temp_set_point ((buffer), (position)))
254 extern void set_point (ptrdiff_t);
255 extern void temp_set_point (struct buffer
*, ptrdiff_t);
256 extern void set_point_both (ptrdiff_t, ptrdiff_t);
257 extern void temp_set_point_both (struct buffer
*,
258 ptrdiff_t, ptrdiff_t);
259 extern void enlarge_buffer_text (struct buffer
*, ptrdiff_t);
262 /* Macros for setting the BEGV, ZV or PT of a given buffer.
264 The ..._BOTH macros take both a charpos and a bytepos,
265 which must correspond to each other.
267 The macros without ..._BOTH take just a charpos,
268 and compute the bytepos from it. */
270 #define SET_BUF_BEGV(buf, charpos) \
271 ((buf)->begv_byte = buf_charpos_to_bytepos ((buf), (charpos)), \
272 (buf)->begv = (charpos))
274 #define SET_BUF_ZV(buf, charpos) \
275 ((buf)->zv_byte = buf_charpos_to_bytepos ((buf), (charpos)), \
276 (buf)->zv = (charpos))
278 #define SET_BUF_BEGV_BOTH(buf, charpos, byte) \
279 ((buf)->begv = (charpos), \
280 (buf)->begv_byte = (byte))
282 #define SET_BUF_ZV_BOTH(buf, charpos, byte) \
283 ((buf)->zv = (charpos), \
284 (buf)->zv_byte = (byte))
286 #define SET_BUF_PT_BOTH(buf, charpos, byte) \
287 ((buf)->pt = (charpos), \
288 (buf)->pt_byte = (byte))
290 /* Macros to access a character or byte in the current buffer,
291 or convert between a byte position and an address.
292 These macros do not check that the position is in range. */
294 /* Access a Lisp position value in POS,
295 and store the charpos in CHARPOS and the bytepos in BYTEPOS. */
297 #define DECODE_POSITION(charpos, bytepos, pos) \
300 Lisp_Object __pos = (pos); \
301 if (NUMBERP (__pos)) \
304 bytepos = buf_charpos_to_bytepos (current_buffer, __pos); \
306 else if (MARKERP (__pos)) \
308 charpos = marker_position (__pos); \
309 bytepos = marker_byte_position (__pos); \
312 wrong_type_argument (Qinteger_or_marker_p, __pos); \
316 /* Maximum number of bytes in a buffer.
317 A buffer cannot contain more bytes than a 1-origin fixnum can represent,
318 nor can it be so large that C pointer arithmetic stops working.
319 The ptrdiff_t cast ensures that this is signed, not unsigned. */
320 #define BUF_BYTES_MAX \
321 (ptrdiff_t) min (MOST_POSITIVE_FIXNUM - 1, min (SIZE_MAX, PTRDIFF_MAX))
323 /* Maximum gap size after compact_buffer, in bytes. Also
324 used in make_gap_larger to get some extra reserved space. */
326 #define GAP_BYTES_DFL 2000
328 /* Minimum gap size after compact_buffer, in bytes. Also
329 used in make_gap_smaller to avoid too small gap size. */
331 #define GAP_BYTES_MIN 20
333 /* Return the address of byte position N in current buffer. */
335 #define BYTE_POS_ADDR(n) \
336 (((n) >= GPT_BYTE ? GAP_SIZE : 0) + (n) + BEG_ADDR - BEG_BYTE)
338 /* Return the address of char position N. */
340 #define CHAR_POS_ADDR(n) \
341 (((n) >= GPT ? GAP_SIZE : 0) \
342 + buf_charpos_to_bytepos (current_buffer, n) \
343 + BEG_ADDR - BEG_BYTE)
345 /* Convert a character position to a byte position. */
347 #define CHAR_TO_BYTE(charpos) \
348 (buf_charpos_to_bytepos (current_buffer, charpos))
350 /* Convert a byte position to a character position. */
352 #define BYTE_TO_CHAR(bytepos) \
353 (buf_bytepos_to_charpos (current_buffer, bytepos))
355 /* Convert PTR, the address of a byte in the buffer, into a byte position. */
357 #define PTR_BYTE_POS(ptr) \
358 ((ptr) - (current_buffer)->text->beg \
359 - (ptr - (current_buffer)->text->beg <= GPT_BYTE - BEG_BYTE ? 0 : GAP_SIZE) \
362 /* Return character at byte position POS. See the caveat WARNING for
363 FETCH_MULTIBYTE_CHAR below. */
365 #define FETCH_CHAR(pos) \
366 (!NILP (BVAR (current_buffer, enable_multibyte_characters)) \
367 ? FETCH_MULTIBYTE_CHAR ((pos)) \
368 : FETCH_BYTE ((pos)))
370 /* Return the byte at byte position N. */
372 #define FETCH_BYTE(n) *(BYTE_POS_ADDR ((n)))
374 /* Return character at byte position POS. If the current buffer is unibyte
375 and the character is not ASCII, make the returning character
378 #define FETCH_CHAR_AS_MULTIBYTE(pos) \
379 (!NILP (BVAR (current_buffer, enable_multibyte_characters)) \
380 ? FETCH_MULTIBYTE_CHAR ((pos)) \
381 : UNIBYTE_TO_CHAR (FETCH_BYTE ((pos))))
384 /* Macros for accessing a character or byte,
385 or converting between byte positions and addresses,
386 in a specified buffer. */
388 /* Return the address of character at byte position POS in buffer BUF.
389 Note that both arguments can be computed more than once. */
391 #define BUF_BYTE_ADDRESS(buf, pos) \
392 ((buf)->text->beg + (pos) - BEG_BYTE \
393 + ((pos) >= (buf)->text->gpt_byte ? (buf)->text->gap_size : 0))
395 /* Return the address of character at char position POS in buffer BUF.
396 Note that both arguments can be computed more than once. */
398 #define BUF_CHAR_ADDRESS(buf, pos) \
399 ((buf)->text->beg + buf_charpos_to_bytepos ((buf), (pos)) - BEG_BYTE \
400 + ((pos) >= (buf)->text->gpt ? (buf)->text->gap_size : 0))
402 /* Convert PTR, the address of a char in buffer BUF,
403 into a character position. */
405 #define BUF_PTR_BYTE_POS(buf, ptr) \
406 ((ptr) - (buf)->text->beg \
407 - (ptr - (buf)->text->beg <= BUF_GPT_BYTE (buf) - BEG_BYTE \
408 ? 0 : BUF_GAP_SIZE ((buf))) \
411 /* Return the character at byte position POS in buffer BUF. */
413 #define BUF_FETCH_CHAR(buf, pos) \
414 (!NILP (buf->enable_multibyte_characters) \
415 ? BUF_FETCH_MULTIBYTE_CHAR ((buf), (pos)) \
416 : BUF_FETCH_BYTE ((buf), (pos)))
418 /* Return the byte at byte position N in buffer BUF. */
420 #define BUF_FETCH_BYTE(buf, n) \
421 *(BUF_BYTE_ADDRESS ((buf), (n)))
423 /* Define the actual buffer data structures. */
425 /* This data structure describes the actual text contents of a buffer.
426 It is shared between indirect buffers and their base buffer. */
430 /* Actual address of buffer contents. If REL_ALLOC is defined,
431 this address might change when blocks are relocated which can
432 e.g. happen when malloc is called. So, don't pass a pointer
433 into a buffer's text to functions that malloc. */
436 ptrdiff_t gpt
; /* Char pos of gap in buffer. */
437 ptrdiff_t z
; /* Char pos of end of buffer. */
438 ptrdiff_t gpt_byte
; /* Byte pos of gap in buffer. */
439 ptrdiff_t z_byte
; /* Byte pos of end of buffer. */
440 ptrdiff_t gap_size
; /* Size of buffer's gap. */
441 EMACS_INT modiff
; /* This counts buffer-modification events
442 for this buffer. It is incremented for
443 each such event, and never otherwise
445 EMACS_INT chars_modiff
; /* This is modified with character change
446 events for this buffer. It is set to
447 modiff for each such event, and never
448 otherwise changed. */
449 EMACS_INT save_modiff
; /* Previous value of modiff, as of last
450 time buffer visited or saved a file. */
452 EMACS_INT overlay_modiff
; /* Counts modifications to overlays. */
454 EMACS_INT compact
; /* Set to modiff each time when compact_buffer
455 is called for this buffer. */
457 /* Minimum value of GPT - BEG since last redisplay that finished. */
458 ptrdiff_t beg_unchanged
;
460 /* Minimum value of Z - GPT since last redisplay that finished. */
461 ptrdiff_t end_unchanged
;
463 /* MODIFF as of last redisplay that finished; if it matches MODIFF,
464 beg_unchanged and end_unchanged contain no useful information. */
465 EMACS_INT unchanged_modified
;
467 /* BUF_OVERLAY_MODIFF of current buffer, as of last redisplay that
468 finished; if it matches BUF_OVERLAY_MODIFF, beg_unchanged and
469 end_unchanged contain no useful information. */
470 EMACS_INT overlay_unchanged_modified
;
472 /* Properties of this buffer's text. */
475 /* The markers that refer to this buffer.
476 This is actually a single marker ---
477 successive elements in its marker `chain'
478 are the other markers referring to this buffer.
479 This is a singly linked unordered list, which means that it's
480 very cheap to add a marker to the list and it's also very cheap
481 to move a marker within a buffer. */
482 struct Lisp_Marker
*markers
;
484 /* Usually 0. Temporarily set to 1 in decode_coding_gap to
485 prevent Fgarbage_collect from shrinking the gap and losing
486 not-yet-decoded bytes. */
487 bool inhibit_shrinking
;
490 /* Most code should use this macro to access Lisp fields in struct buffer. */
492 #define BVAR(buf, field) ((buf)->INTERNAL_FIELD (field))
494 /* This is the structure that the buffer Lisp object points to. */
498 struct vectorlike_header header
;
500 /* The name of this buffer. */
501 Lisp_Object
INTERNAL_FIELD (name
);
503 /* The name of the file visited in this buffer, or nil. */
504 Lisp_Object
INTERNAL_FIELD (filename
);
506 /* Directory for expanding relative file names. */
507 Lisp_Object
INTERNAL_FIELD (directory
);
509 /* True if this buffer has been backed up (if you write to the visited
510 file and it hasn't been backed up, then a backup will be made). */
511 Lisp_Object
INTERNAL_FIELD (backed_up
);
513 /* Length of file when last read or saved.
514 -1 means auto saving turned off because buffer shrank a lot.
515 -2 means don't turn off auto saving if buffer shrinks.
516 (That value is used with buffer-swap-text.)
517 This is not in the struct buffer_text
518 because it's not used in indirect buffers at all. */
519 Lisp_Object
INTERNAL_FIELD (save_length
);
521 /* File name used for auto-saving this buffer.
522 This is not in the struct buffer_text
523 because it's not used in indirect buffers at all. */
524 Lisp_Object
INTERNAL_FIELD (auto_save_file_name
);
526 /* Non-nil if buffer read-only. */
527 Lisp_Object
INTERNAL_FIELD (read_only
);
529 /* "The mark". This is a marker which may
530 point into this buffer or may point nowhere. */
531 Lisp_Object
INTERNAL_FIELD (mark
);
533 /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER) for all
534 per-buffer variables of this buffer. For locally unbound
535 symbols, just the symbol appears as the element. */
536 Lisp_Object
INTERNAL_FIELD (local_var_alist
);
538 /* Symbol naming major mode (e.g., lisp-mode). */
539 Lisp_Object
INTERNAL_FIELD (major_mode
);
541 /* Pretty name of major mode (e.g., "Lisp"). */
542 Lisp_Object
INTERNAL_FIELD (mode_name
);
544 /* Mode line element that controls format of mode line. */
545 Lisp_Object
INTERNAL_FIELD (mode_line_format
);
547 /* Analogous to mode_line_format for the line displayed at the top
548 of windows. Nil means don't display that line. */
549 Lisp_Object
INTERNAL_FIELD (header_line_format
);
551 /* Keys that are bound local to this buffer. */
552 Lisp_Object
INTERNAL_FIELD (keymap
);
554 /* This buffer's local abbrev table. */
555 Lisp_Object
INTERNAL_FIELD (abbrev_table
);
557 /* This buffer's syntax table. */
558 Lisp_Object
INTERNAL_FIELD (syntax_table
);
560 /* This buffer's category table. */
561 Lisp_Object
INTERNAL_FIELD (category_table
);
563 /* Values of several buffer-local variables. */
564 /* tab-width is buffer-local so that redisplay can find it
565 in buffers that are not current. */
566 Lisp_Object
INTERNAL_FIELD (case_fold_search
);
567 Lisp_Object
INTERNAL_FIELD (tab_width
);
568 Lisp_Object
INTERNAL_FIELD (fill_column
);
569 Lisp_Object
INTERNAL_FIELD (left_margin
);
571 /* Function to call when insert space past fill column. */
572 Lisp_Object
INTERNAL_FIELD (auto_fill_function
);
574 /* Case table for case-conversion in this buffer.
575 This char-table maps each char into its lower-case version. */
576 Lisp_Object
INTERNAL_FIELD (downcase_table
);
578 /* Char-table mapping each char to its upper-case version. */
579 Lisp_Object
INTERNAL_FIELD (upcase_table
);
581 /* Char-table for conversion for case-folding search. */
582 Lisp_Object
INTERNAL_FIELD (case_canon_table
);
584 /* Char-table of equivalences for case-folding search. */
585 Lisp_Object
INTERNAL_FIELD (case_eqv_table
);
587 /* Non-nil means do not display continuation lines. */
588 Lisp_Object
INTERNAL_FIELD (truncate_lines
);
590 /* Non-nil means to use word wrapping when displaying continuation lines. */
591 Lisp_Object
INTERNAL_FIELD (word_wrap
);
593 /* Non-nil means display ctl chars with uparrow. */
594 Lisp_Object
INTERNAL_FIELD (ctl_arrow
);
596 /* Non-nil means reorder bidirectional text for display in the
598 Lisp_Object
INTERNAL_FIELD (bidi_display_reordering
);
600 /* If non-nil, specifies which direction of text to force in all the
601 paragraphs of the buffer. Nil means determine paragraph
602 direction dynamically for each paragraph. */
603 Lisp_Object
INTERNAL_FIELD (bidi_paragraph_direction
);
605 /* Non-nil means do selective display;
606 see doc string in syms_of_buffer (buffer.c) for details. */
607 Lisp_Object
INTERNAL_FIELD (selective_display
);
609 /* Non-nil means show ... at end of line followed by invisible lines. */
610 Lisp_Object
INTERNAL_FIELD (selective_display_ellipses
);
612 /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer. */
613 Lisp_Object
INTERNAL_FIELD (minor_modes
);
615 /* t if "self-insertion" should overwrite; `binary' if it should also
616 overwrite newlines and tabs - for editing executables and the like. */
617 Lisp_Object
INTERNAL_FIELD (overwrite_mode
);
619 /* Non-nil means abbrev mode is on. Expand abbrevs automatically. */
620 Lisp_Object
INTERNAL_FIELD (abbrev_mode
);
622 /* Display table to use for text in this buffer. */
623 Lisp_Object
INTERNAL_FIELD (display_table
);
625 /* t means the mark and region are currently active. */
626 Lisp_Object
INTERNAL_FIELD (mark_active
);
628 /* Non-nil means the buffer contents are regarded as multi-byte
629 form of characters, not a binary code. */
630 Lisp_Object
INTERNAL_FIELD (enable_multibyte_characters
);
632 /* Coding system to be used for encoding the buffer contents on
634 Lisp_Object
INTERNAL_FIELD (buffer_file_coding_system
);
636 /* List of symbols naming the file format used for visited file. */
637 Lisp_Object
INTERNAL_FIELD (file_format
);
639 /* List of symbols naming the file format used for auto-save file. */
640 Lisp_Object
INTERNAL_FIELD (auto_save_file_format
);
642 /* True if the newline position cache and width run cache are
643 enabled. See search.c and indent.c. */
644 Lisp_Object
INTERNAL_FIELD (cache_long_line_scans
);
646 /* If the width run cache is enabled, this table contains the
647 character widths width_run_cache (see above) assumes. When we
648 do a thorough redisplay, we compare this against the buffer's
649 current display table to see whether the display table has
650 affected the widths of any characters. If it has, we
651 invalidate the width run cache, and re-initialize width_table. */
652 Lisp_Object
INTERNAL_FIELD (width_table
);
654 /* In an indirect buffer, or a buffer that is the base of an
655 indirect buffer, this holds a marker that records
656 PT for this buffer when the buffer is not current. */
657 Lisp_Object
INTERNAL_FIELD (pt_marker
);
659 /* In an indirect buffer, or a buffer that is the base of an
660 indirect buffer, this holds a marker that records
661 BEGV for this buffer when the buffer is not current. */
662 Lisp_Object
INTERNAL_FIELD (begv_marker
);
664 /* In an indirect buffer, or a buffer that is the base of an
665 indirect buffer, this holds a marker that records
666 ZV for this buffer when the buffer is not current. */
667 Lisp_Object
INTERNAL_FIELD (zv_marker
);
669 /* This holds the point value before the last scroll operation.
670 Explicitly setting point sets this to nil. */
671 Lisp_Object
INTERNAL_FIELD (point_before_scroll
);
673 /* Truename of the visited file, or nil. */
674 Lisp_Object
INTERNAL_FIELD (file_truename
);
676 /* Invisibility spec of this buffer.
677 t => any non-nil `invisible' property means invisible.
678 A list => `invisible' property means invisible
679 if it is memq in that list. */
680 Lisp_Object
INTERNAL_FIELD (invisibility_spec
);
682 /* This is the last window that was selected with this buffer in it,
683 or nil if that window no longer displays this buffer. */
684 Lisp_Object
INTERNAL_FIELD (last_selected_window
);
686 /* Incremented each time the buffer is displayed in a window. */
687 Lisp_Object
INTERNAL_FIELD (display_count
);
689 /* Widths of left and right marginal areas for windows displaying
691 Lisp_Object
INTERNAL_FIELD (left_margin_cols
);
692 Lisp_Object
INTERNAL_FIELD (right_margin_cols
);
694 /* Widths of left and right fringe areas for windows displaying
696 Lisp_Object
INTERNAL_FIELD (left_fringe_width
);
697 Lisp_Object
INTERNAL_FIELD (right_fringe_width
);
699 /* Non-nil means fringes are drawn outside display margins;
700 othersize draw them between margin areas and text. */
701 Lisp_Object
INTERNAL_FIELD (fringes_outside_margins
);
703 /* Width and type of scroll bar areas for windows displaying
705 Lisp_Object
INTERNAL_FIELD (scroll_bar_width
);
706 Lisp_Object
INTERNAL_FIELD (vertical_scroll_bar_type
);
708 /* Non-nil means indicate lines not displaying text (in a style
710 Lisp_Object
INTERNAL_FIELD (indicate_empty_lines
);
712 /* Non-nil means indicate buffer boundaries and scrolling. */
713 Lisp_Object
INTERNAL_FIELD (indicate_buffer_boundaries
);
715 /* Logical to physical fringe bitmap mappings. */
716 Lisp_Object
INTERNAL_FIELD (fringe_indicator_alist
);
718 /* Logical to physical cursor bitmap mappings. */
719 Lisp_Object
INTERNAL_FIELD (fringe_cursor_alist
);
721 /* Time stamp updated each time this buffer is displayed in a window. */
722 Lisp_Object
INTERNAL_FIELD (display_time
);
724 /* If scrolling the display because point is below the bottom of a
725 window showing this buffer, try to choose a window start so
726 that point ends up this number of lines from the top of the
727 window. Nil means that scrolling method isn't used. */
728 Lisp_Object
INTERNAL_FIELD (scroll_up_aggressively
);
730 /* If scrolling the display because point is above the top of a
731 window showing this buffer, try to choose a window start so
732 that point ends up this number of lines from the bottom of the
733 window. Nil means that scrolling method isn't used. */
734 Lisp_Object
INTERNAL_FIELD (scroll_down_aggressively
);
736 /* Desired cursor type in this buffer. See the doc string of
737 per-buffer variable `cursor-type'. */
738 Lisp_Object
INTERNAL_FIELD (cursor_type
);
740 /* An integer > 0 means put that number of pixels below text lines
741 in the display of this buffer. */
742 Lisp_Object
INTERNAL_FIELD (extra_line_spacing
);
744 /* Cursor type to display in non-selected windows.
745 t means to use hollow box cursor.
746 See `cursor-type' for other values. */
747 Lisp_Object
INTERNAL_FIELD (cursor_in_non_selected_windows
);
749 /* No more Lisp_Object beyond this point. Except undo_list,
750 which is handled specially in Fgarbage_collect . */
752 /* This structure holds the coordinates of the buffer contents
753 in ordinary buffers. In indirect buffers, this is not used. */
754 struct buffer_text own_text
;
756 /* This points to the `struct buffer_text' that used for this buffer.
757 In an ordinary buffer, this is the own_text field above.
758 In an indirect buffer, this is the own_text field of another buffer. */
759 struct buffer_text
*text
;
761 /* Next buffer, in chain of all buffers, including killed ones. */
764 /* Char position of point in buffer. */
767 /* Byte position of point in buffer. */
770 /* Char position of beginning of accessible range. */
773 /* Byte position of beginning of accessible range. */
776 /* Char position of end of accessible range. */
779 /* Byte position of end of accessible range. */
782 /* In an indirect buffer, this points to the base buffer.
783 In an ordinary buffer, it is 0. */
784 struct buffer
*base_buffer
;
786 /* In an indirect buffer, this is -1. In an ordinary buffer,
787 it's the number of indirect buffers that share our text;
788 zero means that we're the only owner of this text. */
791 /* Number of windows showing this buffer. Always -1 for
792 an indirect buffer since it counts as its base buffer. */
795 /* A non-zero value in slot IDX means that per-buffer variable
796 with index IDX has a local value in this buffer. The index IDX
797 for a buffer-local variable is stored in that variable's slot
798 in buffer_local_flags as a Lisp integer. If the index is -1,
799 this means the variable is always local in all buffers. */
800 #define MAX_PER_BUFFER_VARS 50
801 char local_flags
[MAX_PER_BUFFER_VARS
];
803 /* Set to the modtime of the visited file when read or written.
804 EMACS_NSECS (modtime) == NONEXISTENT_MODTIME_NSECS means
805 visited file was nonexistent. EMACS_NSECS (modtime) ==
806 UNKNOWN_MODTIME_NSECS means visited file modtime unknown;
807 in no case complain about any mismatch on next save attempt. */
808 #define NONEXISTENT_MODTIME_NSECS (-1)
809 #define UNKNOWN_MODTIME_NSECS (-2)
812 /* Size of the file when modtime was set. This is used to detect the
813 case where the file grew while we were reading it, so the modtime
814 is still the same (since it's rounded up to seconds) but we're actually
815 not up-to-date. -1 means the size is unknown. Only meaningful if
816 modtime is actually set. */
819 /* The value of text->modiff at the last auto-save. */
820 EMACS_INT auto_save_modified
;
822 /* The value of text->modiff at the last display error.
823 Redisplay of this buffer is inhibited until it changes again. */
824 EMACS_INT display_error_modiff
;
826 /* The time at which we detected a failure to auto-save,
827 Or 0 if we didn't have a failure. */
828 time_t auto_save_failure_time
;
830 /* Position in buffer at which display started
831 the last time this buffer was displayed. */
832 ptrdiff_t last_window_start
;
834 /* If the long line scan cache is enabled (i.e. the buffer-local
835 variable cache-long-line-scans is non-nil), newline_cache
836 points to the newline cache, and width_run_cache points to the
839 The newline cache records which stretches of the buffer are
840 known *not* to contain newlines, so that they can be skipped
841 quickly when we search for newlines.
843 The width run cache records which stretches of the buffer are
844 known to contain characters whose widths are all the same. If
845 the width run cache maps a character to a value > 0, that value is
846 the character's width; if it maps a character to zero, we don't
847 know what its width is. This allows compute_motion to process
848 such regions very quickly, using algebra instead of inspecting
849 each character. See also width_table, below. */
850 struct region_cache
*newline_cache
;
851 struct region_cache
*width_run_cache
;
853 /* Non-zero means don't use redisplay optimizations for
854 displaying this buffer. */
855 unsigned prevent_redisplay_optimizations_p
: 1;
857 /* Non-zero whenever the narrowing is changed in this buffer. */
858 unsigned clip_changed
: 1;
860 /* List of overlays that end at or before the current center,
861 in order of end-position. */
862 struct Lisp_Overlay
*overlays_before
;
864 /* List of overlays that end after the current center,
865 in order of start-position. */
866 struct Lisp_Overlay
*overlays_after
;
868 /* Position where the overlay lists are centered. */
869 ptrdiff_t overlay_center
;
871 /* Changes in the buffer are recorded here for undo, and t means
872 don't record anything. This information belongs to the base
873 buffer of an indirect buffer. But we can't store it in the
874 struct buffer_text because local variables have to be right in
875 the struct buffer. So we copy it around in set_buffer_internal. */
876 Lisp_Object
INTERNAL_FIELD (undo_list
);
879 /* Most code should use these functions to set Lisp fields in struct
882 bset_bidi_paragraph_direction (struct buffer
*b
, Lisp_Object val
)
884 b
->INTERNAL_FIELD (bidi_paragraph_direction
) = val
;
887 bset_case_canon_table (struct buffer
*b
, Lisp_Object val
)
889 b
->INTERNAL_FIELD (case_canon_table
) = val
;
892 bset_case_eqv_table (struct buffer
*b
, Lisp_Object val
)
894 b
->INTERNAL_FIELD (case_eqv_table
) = val
;
897 bset_directory (struct buffer
*b
, Lisp_Object val
)
899 b
->INTERNAL_FIELD (directory
) = val
;
902 bset_display_count (struct buffer
*b
, Lisp_Object val
)
904 b
->INTERNAL_FIELD (display_count
) = val
;
907 bset_display_time (struct buffer
*b
, Lisp_Object val
)
909 b
->INTERNAL_FIELD (display_time
) = val
;
912 bset_downcase_table (struct buffer
*b
, Lisp_Object val
)
914 b
->INTERNAL_FIELD (downcase_table
) = val
;
917 bset_enable_multibyte_characters (struct buffer
*b
, Lisp_Object val
)
919 b
->INTERNAL_FIELD (enable_multibyte_characters
) = val
;
922 bset_filename (struct buffer
*b
, Lisp_Object val
)
924 b
->INTERNAL_FIELD (filename
) = val
;
927 bset_keymap (struct buffer
*b
, Lisp_Object val
)
929 b
->INTERNAL_FIELD (keymap
) = val
;
932 bset_last_selected_window (struct buffer
*b
, Lisp_Object val
)
934 b
->INTERNAL_FIELD (last_selected_window
) = val
;
937 bset_local_var_alist (struct buffer
*b
, Lisp_Object val
)
939 b
->INTERNAL_FIELD (local_var_alist
) = val
;
942 bset_mark_active (struct buffer
*b
, Lisp_Object val
)
944 b
->INTERNAL_FIELD (mark_active
) = val
;
947 bset_point_before_scroll (struct buffer
*b
, Lisp_Object val
)
949 b
->INTERNAL_FIELD (point_before_scroll
) = val
;
952 bset_read_only (struct buffer
*b
, Lisp_Object val
)
954 b
->INTERNAL_FIELD (read_only
) = val
;
957 bset_truncate_lines (struct buffer
*b
, Lisp_Object val
)
959 b
->INTERNAL_FIELD (truncate_lines
) = val
;
962 bset_undo_list (struct buffer
*b
, Lisp_Object val
)
964 b
->INTERNAL_FIELD (undo_list
) = val
;
967 bset_upcase_table (struct buffer
*b
, Lisp_Object val
)
969 b
->INTERNAL_FIELD (upcase_table
) = val
;
972 bset_width_table (struct buffer
*b
, Lisp_Object val
)
974 b
->INTERNAL_FIELD (width_table
) = val
;
977 /* Number of Lisp_Objects at the beginning of struct buffer.
978 If you add, remove, or reorder Lisp_Objects within buffer
979 structure, make sure that this is still correct. */
981 #define BUFFER_LISP_SIZE \
982 ((offsetof (struct buffer, own_text) - header_size) / word_size)
984 /* Size of the struct buffer part beyond leading Lisp_Objects, in word_size
985 units. Rounding is needed for --with-wide-int configuration. */
987 #define BUFFER_REST_SIZE \
988 ((((sizeof (struct buffer) - offsetof (struct buffer, own_text)) \
989 + (word_size - 1)) & ~(word_size - 1)) / word_size)
991 /* Initialize the pseudovector header of buffer object. BUFFER_LISP_SIZE
992 is required for GC, but BUFFER_REST_SIZE is set up just to be consistent
993 with other pseudovectors. */
995 #define BUFFER_PVEC_INIT(b) \
996 XSETPVECTYPESIZE (b, PVEC_BUFFER, BUFFER_LISP_SIZE, BUFFER_REST_SIZE)
998 /* Convenient check whether buffer B is live. */
1000 #define BUFFER_LIVE_P(b) (!NILP (BVAR (b, name)))
1002 /* Convenient check whether buffer B is hidden (i.e. its name
1003 starts with a space). Caller must ensure that B is live. */
1005 #define BUFFER_HIDDEN_P(b) (SREF (BVAR (b, name), 0) == ' ')
1007 /* Verify indirection counters. */
1009 #define BUFFER_CHECK_INDIRECTION(b) \
1011 if (BUFFER_LIVE_P (b)) \
1013 if (b->base_buffer) \
1015 eassert (b->indirections == -1); \
1016 eassert (b->base_buffer->indirections > 0); \
1019 eassert (b->indirections >= 0); \
1023 /* Chain of all buffers, including killed ones. */
1025 extern struct buffer
*all_buffers
;
1027 /* Used to iterate over the chain above. */
1029 #define FOR_EACH_BUFFER(b) \
1030 for ((b) = all_buffers; (b); (b) = (b)->next)
1032 /* This points to the current buffer. */
1034 extern struct buffer
*current_buffer
;
1036 /* This structure holds the default values of the buffer-local variables
1037 that have special slots in each buffer.
1038 The default value occupies the same slot in this structure
1039 as an individual buffer's value occupies in that buffer.
1040 Setting the default value also goes through the alist of buffers
1041 and stores into each buffer that does not say it has a local value. */
1043 extern struct buffer buffer_defaults
;
1045 /* This structure marks which slots in a buffer have corresponding
1046 default values in buffer_defaults.
1047 Each such slot has a nonzero value in this structure.
1048 The value has only one nonzero bit.
1050 When a buffer has its own local value for a slot,
1051 the entry for that slot (found in the same slot in this structure)
1052 is turned on in the buffer's local_flags array.
1054 If a slot in this structure is zero, then even though there may
1055 be a Lisp-level local variable for the slot, it has no default value,
1056 and the corresponding slot in buffer_defaults is not used. */
1059 extern struct buffer buffer_local_flags
;
1061 /* For each buffer slot, this points to the Lisp symbol name
1062 for that slot in the current buffer. It is 0 for slots
1063 that don't have such names. */
1065 extern struct buffer buffer_local_symbols
;
1067 extern void delete_all_overlays (struct buffer
*);
1068 extern void reset_buffer (struct buffer
*);
1069 extern void compact_buffer (struct buffer
*);
1070 extern void evaporate_overlays (ptrdiff_t);
1071 extern ptrdiff_t overlays_at (EMACS_INT
, bool, Lisp_Object
**,
1072 ptrdiff_t *, ptrdiff_t *, ptrdiff_t *, bool);
1073 extern ptrdiff_t sort_overlays (Lisp_Object
*, ptrdiff_t, struct window
*);
1074 extern void recenter_overlay_lists (struct buffer
*, ptrdiff_t);
1075 extern ptrdiff_t overlay_strings (ptrdiff_t, struct window
*, unsigned char **);
1076 extern void validate_region (Lisp_Object
*, Lisp_Object
*);
1077 extern void set_buffer_internal_1 (struct buffer
*);
1078 extern void set_buffer_temp (struct buffer
*);
1079 extern Lisp_Object
buffer_local_value_1 (Lisp_Object
, Lisp_Object
);
1080 extern void record_buffer (Lisp_Object
);
1081 extern _Noreturn
void buffer_slot_type_mismatch (Lisp_Object
, int);
1082 extern void fix_overlays_before (struct buffer
*, ptrdiff_t, ptrdiff_t);
1083 extern void mmap_set_vars (bool);
1085 /* Set the current buffer to B.
1087 We previously set windows_or_buffers_changed here to invalidate
1088 global unchanged information in beg_unchanged and end_unchanged.
1089 This is no longer necessary because we now compute unchanged
1090 information on a buffer-basis. Every action affecting other
1091 windows than the selected one requires a select_window at some
1092 time, and that increments windows_or_buffers_changed. */
1095 set_buffer_internal (struct buffer
*b
)
1097 if (current_buffer
!= b
)
1098 set_buffer_internal_1 (b
);
1101 /* Arrange to go back to the original buffer after the next
1102 call to unbind_to if the original buffer is still alive. */
1105 record_unwind_current_buffer (void)
1107 record_unwind_protect (set_buffer_if_live
, Fcurrent_buffer ());
1110 /* Get overlays at POSN into array OVERLAYS with NOVERLAYS elements.
1111 If NEXTP is non-NULL, return next overlay there.
1112 See overlay_at arg CHANGE_REQ for meaning of CHRQ arg. */
1114 #define GET_OVERLAYS_AT(posn, overlays, noverlays, nextp, chrq) \
1116 ptrdiff_t maxlen = 40; \
1117 overlays = alloca (maxlen * sizeof *overlays); \
1118 noverlays = overlays_at (posn, 0, &overlays, &maxlen, \
1119 nextp, NULL, chrq); \
1120 if (noverlays > maxlen) \
1122 maxlen = noverlays; \
1123 overlays = alloca (maxlen * sizeof *overlays); \
1124 noverlays = overlays_at (posn, 0, &overlays, &maxlen, \
1125 nextp, NULL, chrq); \
1129 extern Lisp_Object Qbefore_change_functions
;
1130 extern Lisp_Object Qafter_change_functions
;
1131 extern Lisp_Object Qfirst_change_hook
;
1133 /* Get text properties of B. */
1135 BUFFER_INLINE INTERVAL
1136 buffer_intervals (struct buffer
*b
)
1138 eassert (b
->text
!= NULL
);
1139 return b
->text
->intervals
;
1142 /* Set text properties of B to I. */
1145 set_buffer_intervals (struct buffer
*b
, INTERVAL i
)
1147 eassert (b
->text
!= NULL
);
1148 b
->text
->intervals
= i
;
1151 /* Non-zero if current buffer has overlays. */
1154 buffer_has_overlays (void)
1156 return current_buffer
->overlays_before
|| current_buffer
->overlays_after
;
1159 /* Return character code of multi-byte form at byte position POS. If POS
1160 doesn't point the head of valid multi-byte form, only the byte at
1161 POS is returned. No range checking.
1163 WARNING: The character returned by this macro could be "unified"
1164 inside STRING_CHAR, if the original character in the buffer belongs
1165 to one of the Private Use Areas (PUAs) of codepoints that Emacs
1166 uses to support non-unified CJK characters. If that happens,
1167 CHAR_BYTES will return a value that is different from the length of
1168 the original multibyte sequence stored in the buffer. Therefore,
1169 do _not_ use FETCH_MULTIBYTE_CHAR if you need to advance through
1170 the buffer to the next character after fetching this one. Instead,
1171 use either FETCH_CHAR_ADVANCE or STRING_CHAR_AND_LENGTH. */
1174 FETCH_MULTIBYTE_CHAR (ptrdiff_t pos
)
1176 unsigned char *p
= ((pos
>= GPT_BYTE
? GAP_SIZE
: 0)
1177 + pos
+ BEG_ADDR
- BEG_BYTE
);
1178 return STRING_CHAR (p
);
1181 /* Return character code of multi-byte form at byte position POS in BUF.
1182 If POS doesn't point the head of valid multi-byte form, only the byte at
1183 POS is returned. No range checking. */
1186 BUF_FETCH_MULTIBYTE_CHAR (struct buffer
*buf
, ptrdiff_t pos
)
1189 = ((pos
>= BUF_GPT_BYTE (buf
) ? BUF_GAP_SIZE (buf
) : 0)
1190 + pos
+ BUF_BEG_ADDR (buf
) - BEG_BYTE
);
1191 return STRING_CHAR (p
);
1194 /* Return number of windows showing B. */
1197 buffer_window_count (struct buffer
*b
)
1201 eassert (b
->window_count
>= 0);
1202 return b
->window_count
;
1207 /* Return the marker that stands for where OV starts in the buffer. */
1209 #define OVERLAY_START(OV) XOVERLAY (OV)->start
1211 /* Return the marker that stands for where OV ends in the buffer. */
1213 #define OVERLAY_END(OV) XOVERLAY (OV)->end
1215 /* Return the plist of overlay OV. */
1217 #define OVERLAY_PLIST(OV) XOVERLAY (OV)->plist
1219 /* Return the actual buffer position for the marker P.
1220 We assume you know which buffer it's pointing into. */
1222 #define OVERLAY_POSITION(P) \
1223 (MARKERP (P) ? marker_position (P) : (emacs_abort (), 0))
1226 /***********************************************************************
1227 Buffer-local Variables
1228 ***********************************************************************/
1230 /* Number of per-buffer variables used. */
1232 extern int last_per_buffer_idx
;
1234 /* Return the offset in bytes of member VAR of struct buffer
1235 from the start of a buffer structure. */
1237 #define PER_BUFFER_VAR_OFFSET(VAR) \
1238 offsetof (struct buffer, INTERNAL_FIELD (VAR))
1240 /* Used to iterate over normal Lisp_Object fields of struct buffer (all
1241 Lisp_Objects except undo_list). If you add, remove, or reorder
1242 Lisp_Objects in a struct buffer, make sure that this is still correct. */
1244 #define FOR_EACH_PER_BUFFER_OBJECT_AT(offset) \
1245 for (offset = PER_BUFFER_VAR_OFFSET (name); \
1246 offset <= PER_BUFFER_VAR_OFFSET (cursor_in_non_selected_windows); \
1247 offset += word_size)
1249 /* Return the index of buffer-local variable VAR. Each per-buffer
1250 variable has an index > 0 associated with it, except when it always
1251 has buffer-local values, in which case the index is -1. If this is
1252 0, this is a bug and means that the slot of VAR in
1253 buffer_local_flags wasn't initialized. */
1255 #define PER_BUFFER_VAR_IDX(VAR) \
1256 PER_BUFFER_IDX (PER_BUFFER_VAR_OFFSET (VAR))
1258 /* Value is non-zero if the variable with index IDX has a local value
1261 #define PER_BUFFER_VALUE_P(B, IDX) \
1262 (((IDX) < 0 || IDX >= last_per_buffer_idx) \
1263 ? (emacs_abort (), 0) \
1264 : ((B)->local_flags[IDX] != 0))
1266 /* Set whether per-buffer variable with index IDX has a buffer-local
1267 value in buffer B. VAL zero means it hasn't. */
1269 #define SET_PER_BUFFER_VALUE_P(B, IDX, VAL) \
1271 if ((IDX) < 0 || (IDX) >= last_per_buffer_idx) \
1273 (B)->local_flags[IDX] = (VAL); \
1276 /* Return the index value of the per-buffer variable at offset OFFSET
1277 in the buffer structure.
1279 If the slot OFFSET has a corresponding default value in
1280 buffer_defaults, the index value is positive and has only one
1281 nonzero bit. When a buffer has its own local value for a slot, the
1282 bit for that slot (found in the same slot in this structure) is
1283 turned on in the buffer's local_flags array.
1285 If the index value is -1, even though there may be a
1286 DEFVAR_PER_BUFFER for the slot, there is no default value for it;
1287 and the corresponding slot in buffer_defaults is not used.
1289 If the index value is -2, then there is no DEFVAR_PER_BUFFER for
1290 the slot, but there is a default value which is copied into each
1293 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
1294 zero, that is a bug */
1297 #define PER_BUFFER_IDX(OFFSET) \
1298 XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
1300 /* Functions to get and set default value of the per-buffer
1301 variable at offset OFFSET in the buffer structure. */
1303 BUFFER_INLINE Lisp_Object
1304 per_buffer_default (int offset
)
1306 return *(Lisp_Object
*)(offset
+ (char *) &buffer_defaults
);
1310 set_per_buffer_default (int offset
, Lisp_Object value
)
1312 *(Lisp_Object
*)(offset
+ (char *) &buffer_defaults
) = value
;
1315 /* Functions to get and set buffer-local value of the per-buffer
1316 variable at offset OFFSET in the buffer structure. */
1318 BUFFER_INLINE Lisp_Object
1319 per_buffer_value (struct buffer
*b
, int offset
)
1321 return *(Lisp_Object
*)(offset
+ (char *) b
);
1325 set_per_buffer_value (struct buffer
*b
, int offset
, Lisp_Object value
)
1327 *(Lisp_Object
*)(offset
+ (char *) b
) = value
;
1330 /* Downcase a character C, or make no change if that cannot be done. */
1334 Lisp_Object downcase_table
= BVAR (current_buffer
, downcase_table
);
1335 Lisp_Object down
= CHAR_TABLE_REF (downcase_table
, c
);
1336 return NATNUMP (down
) ? XFASTINT (down
) : c
;
1339 /* 1 if C is upper case. */
1340 BUFFER_INLINE
bool uppercasep (int c
) { return downcase (c
) != c
; }
1342 /* Upcase a character C known to be not upper case. */
1346 Lisp_Object upcase_table
= BVAR (current_buffer
, upcase_table
);
1347 Lisp_Object up
= CHAR_TABLE_REF (upcase_table
, c
);
1348 return NATNUMP (up
) ? XFASTINT (up
) : c
;
1351 /* 1 if C is lower case. */
1355 return !uppercasep (c
) && upcase1 (c
) != c
;
1358 /* Upcase a character C, or make no change if that cannot be done. */
1359 BUFFER_INLINE
int upcase (int c
) { return uppercasep (c
) ? c
: upcase1 (c
); }