mairix.el fix for bug#13294
[emacs.git] / src / buffer.h
blob9e0e9eef0b17cef7df8f591975fb836fbcf3f763
1 /* Header file for the buffer manipulation primitives.
3 Copyright (C) 1985-1986, 1993-1995, 1997-2012
4 Free Software Foundation, Inc.
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 */
24 INLINE_HEADER_BEGIN
25 #ifndef BUFFER_INLINE
26 # define BUFFER_INLINE INLINE
27 #endif
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. */
35 #define BEG (1)
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)
82 /* Size of gap. */
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)
173 /* Size of gap. */
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 /* Marker chain of buffer. */
197 #define BUF_MARKERS(buf) ((buf)->text->markers)
199 #define BUF_UNCHANGED_MODIFIED(buf) \
200 ((buf)->text->unchanged_modified)
202 #define BUF_OVERLAY_UNCHANGED_MODIFIED(buf) \
203 ((buf)->text->overlay_unchanged_modified)
204 #define BUF_BEG_UNCHANGED(buf) ((buf)->text->beg_unchanged)
205 #define BUF_END_UNCHANGED(buf) ((buf)->text->end_unchanged)
207 #define UNCHANGED_MODIFIED \
208 BUF_UNCHANGED_MODIFIED (current_buffer)
209 #define OVERLAY_UNCHANGED_MODIFIED \
210 BUF_OVERLAY_UNCHANGED_MODIFIED (current_buffer)
211 #define BEG_UNCHANGED BUF_BEG_UNCHANGED (current_buffer)
212 #define END_UNCHANGED BUF_END_UNCHANGED (current_buffer)
214 /* Compute how many characters at the top and bottom of BUF are
215 unchanged when the range START..END is modified. This computation
216 must be done each time BUF is modified. */
218 #define BUF_COMPUTE_UNCHANGED(buf, start, end) \
219 do \
221 if (BUF_UNCHANGED_MODIFIED (buf) == BUF_MODIFF (buf) \
222 && (BUF_OVERLAY_UNCHANGED_MODIFIED (buf) \
223 == BUF_OVERLAY_MODIFF (buf))) \
225 BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf); \
226 BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end); \
228 else \
230 if (BUF_Z (buf) - (end) < BUF_END_UNCHANGED (buf)) \
231 BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end); \
232 if ((start) - BUF_BEG (buf) < BUF_BEG_UNCHANGED (buf)) \
233 BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf); \
236 while (0)
239 /* Macros to set PT in the current buffer, or another buffer. */
241 #define SET_PT(position) (set_point (position))
242 #define TEMP_SET_PT(position) (temp_set_point (current_buffer, (position)))
244 #define SET_PT_BOTH(position, byte) (set_point_both (position, byte))
245 #define TEMP_SET_PT_BOTH(position, byte) \
246 (temp_set_point_both (current_buffer, (position), (byte)))
248 #define BUF_TEMP_SET_PT(buffer, position) \
249 (temp_set_point ((buffer), (position)))
251 extern void set_point (ptrdiff_t);
252 extern void temp_set_point (struct buffer *, ptrdiff_t);
253 extern void set_point_both (ptrdiff_t, ptrdiff_t);
254 extern void temp_set_point_both (struct buffer *,
255 ptrdiff_t, ptrdiff_t);
256 extern void enlarge_buffer_text (struct buffer *, ptrdiff_t);
259 /* Macros for setting the BEGV, ZV or PT of a given buffer.
261 The ..._BOTH macros take both a charpos and a bytepos,
262 which must correspond to each other.
264 The macros without ..._BOTH take just a charpos,
265 and compute the bytepos from it. */
267 #define SET_BUF_BEGV(buf, charpos) \
268 ((buf)->begv_byte = buf_charpos_to_bytepos ((buf), (charpos)), \
269 (buf)->begv = (charpos))
271 #define SET_BUF_ZV(buf, charpos) \
272 ((buf)->zv_byte = buf_charpos_to_bytepos ((buf), (charpos)), \
273 (buf)->zv = (charpos))
275 #define SET_BUF_BEGV_BOTH(buf, charpos, byte) \
276 ((buf)->begv = (charpos), \
277 (buf)->begv_byte = (byte))
279 #define SET_BUF_ZV_BOTH(buf, charpos, byte) \
280 ((buf)->zv = (charpos), \
281 (buf)->zv_byte = (byte))
283 #define SET_BUF_PT_BOTH(buf, charpos, byte) \
284 ((buf)->pt = (charpos), \
285 (buf)->pt_byte = (byte))
287 /* Macros to access a character or byte in the current buffer,
288 or convert between a byte position and an address.
289 These macros do not check that the position is in range. */
291 /* Access a Lisp position value in POS,
292 and store the charpos in CHARPOS and the bytepos in BYTEPOS. */
294 #define DECODE_POSITION(charpos, bytepos, pos) \
295 do \
297 Lisp_Object __pos = (pos); \
298 if (NUMBERP (__pos)) \
300 charpos = __pos; \
301 bytepos = buf_charpos_to_bytepos (current_buffer, __pos); \
303 else if (MARKERP (__pos)) \
305 charpos = marker_position (__pos); \
306 bytepos = marker_byte_position (__pos); \
308 else \
309 wrong_type_argument (Qinteger_or_marker_p, __pos); \
311 while (0)
313 /* Maximum number of bytes in a buffer.
314 A buffer cannot contain more bytes than a 1-origin fixnum can represent,
315 nor can it be so large that C pointer arithmetic stops working.
316 The ptrdiff_t cast ensures that this is signed, not unsigned. */
317 #define BUF_BYTES_MAX \
318 (ptrdiff_t) min (MOST_POSITIVE_FIXNUM - 1, min (SIZE_MAX, PTRDIFF_MAX))
320 /* Return the address of byte position N in current buffer. */
322 #define BYTE_POS_ADDR(n) \
323 (((n) >= GPT_BYTE ? GAP_SIZE : 0) + (n) + BEG_ADDR - BEG_BYTE)
325 /* Return the address of char position N. */
327 #define CHAR_POS_ADDR(n) \
328 (((n) >= GPT ? GAP_SIZE : 0) \
329 + buf_charpos_to_bytepos (current_buffer, n) \
330 + BEG_ADDR - BEG_BYTE)
332 /* Convert a character position to a byte position. */
334 #define CHAR_TO_BYTE(charpos) \
335 (buf_charpos_to_bytepos (current_buffer, charpos))
337 /* Convert a byte position to a character position. */
339 #define BYTE_TO_CHAR(bytepos) \
340 (buf_bytepos_to_charpos (current_buffer, bytepos))
342 /* Convert PTR, the address of a byte in the buffer, into a byte position. */
344 #define PTR_BYTE_POS(ptr) \
345 ((ptr) - (current_buffer)->text->beg \
346 - (ptr - (current_buffer)->text->beg <= GPT_BYTE - BEG_BYTE ? 0 : GAP_SIZE) \
347 + BEG_BYTE)
349 /* Return character at byte position POS. See the caveat WARNING for
350 FETCH_MULTIBYTE_CHAR below. */
352 #define FETCH_CHAR(pos) \
353 (!NILP (BVAR (current_buffer, enable_multibyte_characters)) \
354 ? FETCH_MULTIBYTE_CHAR ((pos)) \
355 : FETCH_BYTE ((pos)))
357 /* Return the byte at byte position N. */
359 #define FETCH_BYTE(n) *(BYTE_POS_ADDR ((n)))
361 /* Return character at byte position POS. If the current buffer is unibyte
362 and the character is not ASCII, make the returning character
363 multibyte. */
365 #define FETCH_CHAR_AS_MULTIBYTE(pos) \
366 (!NILP (BVAR (current_buffer, enable_multibyte_characters)) \
367 ? FETCH_MULTIBYTE_CHAR ((pos)) \
368 : UNIBYTE_TO_CHAR (FETCH_BYTE ((pos))))
371 /* Macros for accessing a character or byte,
372 or converting between byte positions and addresses,
373 in a specified buffer. */
375 /* Return the address of character at byte position POS in buffer BUF.
376 Note that both arguments can be computed more than once. */
378 #define BUF_BYTE_ADDRESS(buf, pos) \
379 ((buf)->text->beg + (pos) - BEG_BYTE \
380 + ((pos) >= (buf)->text->gpt_byte ? (buf)->text->gap_size : 0))
382 /* Return the address of character at char position POS in buffer BUF.
383 Note that both arguments can be computed more than once. */
385 #define BUF_CHAR_ADDRESS(buf, pos) \
386 ((buf)->text->beg + buf_charpos_to_bytepos ((buf), (pos)) - BEG_BYTE \
387 + ((pos) >= (buf)->text->gpt ? (buf)->text->gap_size : 0))
389 /* Convert PTR, the address of a char in buffer BUF,
390 into a character position. */
392 #define BUF_PTR_BYTE_POS(buf, ptr) \
393 ((ptr) - (buf)->text->beg \
394 - (ptr - (buf)->text->beg <= BUF_GPT_BYTE (buf) - BEG_BYTE \
395 ? 0 : BUF_GAP_SIZE ((buf))) \
396 + BEG_BYTE)
398 /* Return the character at byte position POS in buffer BUF. */
400 #define BUF_FETCH_CHAR(buf, pos) \
401 (!NILP (buf->enable_multibyte_characters) \
402 ? BUF_FETCH_MULTIBYTE_CHAR ((buf), (pos)) \
403 : BUF_FETCH_BYTE ((buf), (pos)))
405 /* Return the byte at byte position N in buffer BUF. */
407 #define BUF_FETCH_BYTE(buf, n) \
408 *(BUF_BYTE_ADDRESS ((buf), (n)))
410 /* Define the actual buffer data structures. */
412 /* This data structure describes the actual text contents of a buffer.
413 It is shared between indirect buffers and their base buffer. */
415 struct buffer_text
417 /* Actual address of buffer contents. If REL_ALLOC is defined,
418 this address might change when blocks are relocated which can
419 e.g. happen when malloc is called. So, don't pass a pointer
420 into a buffer's text to functions that malloc. */
421 unsigned char *beg;
423 ptrdiff_t gpt; /* Char pos of gap in buffer. */
424 ptrdiff_t z; /* Char pos of end of buffer. */
425 ptrdiff_t gpt_byte; /* Byte pos of gap in buffer. */
426 ptrdiff_t z_byte; /* Byte pos of end of buffer. */
427 ptrdiff_t gap_size; /* Size of buffer's gap. */
428 EMACS_INT modiff; /* This counts buffer-modification events
429 for this buffer. It is incremented for
430 each such event, and never otherwise
431 changed. */
432 EMACS_INT chars_modiff; /* This is modified with character change
433 events for this buffer. It is set to
434 modiff for each such event, and never
435 otherwise changed. */
436 EMACS_INT save_modiff; /* Previous value of modiff, as of last
437 time buffer visited or saved a file. */
439 EMACS_INT overlay_modiff; /* Counts modifications to overlays. */
441 EMACS_INT compact; /* Set to modiff each time when compact_buffer
442 is called for this buffer. */
444 /* Minimum value of GPT - BEG since last redisplay that finished. */
445 ptrdiff_t beg_unchanged;
447 /* Minimum value of Z - GPT since last redisplay that finished. */
448 ptrdiff_t end_unchanged;
450 /* MODIFF as of last redisplay that finished; if it matches MODIFF,
451 beg_unchanged and end_unchanged contain no useful information. */
452 EMACS_INT unchanged_modified;
454 /* BUF_OVERLAY_MODIFF of current buffer, as of last redisplay that
455 finished; if it matches BUF_OVERLAY_MODIFF, beg_unchanged and
456 end_unchanged contain no useful information. */
457 EMACS_INT overlay_unchanged_modified;
459 /* Properties of this buffer's text. */
460 INTERVAL intervals;
462 /* The markers that refer to this buffer.
463 This is actually a single marker ---
464 successive elements in its marker `chain'
465 are the other markers referring to this buffer.
466 This is a singly linked unordered list, which means that it's
467 very cheap to add a marker to the list and it's also very cheap
468 to move a marker within a buffer. */
469 struct Lisp_Marker *markers;
471 /* Usually 0. Temporarily set to 1 in decode_coding_gap to
472 prevent Fgarbage_collect from shrinking the gap and losing
473 not-yet-decoded bytes. */
474 bool inhibit_shrinking;
477 /* Most code should use this macro to access Lisp fields in struct buffer. */
479 #define BVAR(buf, field) ((buf)->INTERNAL_FIELD (field))
481 /* This is the structure that the buffer Lisp object points to. */
483 struct buffer
485 /* HEADER.NEXT is the next buffer, in chain of all buffers, including killed
486 buffers. This chain, starting from all_buffers, is used only for garbage
487 collection, in order to collect killed buffers properly. Note that large
488 vectors and large pseudo-vector objects are all on another chain starting
489 from large_vectors. */
490 struct vectorlike_header header;
492 /* The name of this buffer. */
493 Lisp_Object INTERNAL_FIELD (name);
495 /* The name of the file visited in this buffer, or nil. */
496 Lisp_Object INTERNAL_FIELD (filename);
498 /* Directory for expanding relative file names. */
499 Lisp_Object INTERNAL_FIELD (directory);
501 /* True if this buffer has been backed up (if you write to the visited
502 file and it hasn't been backed up, then a backup will be made). */
503 Lisp_Object INTERNAL_FIELD (backed_up);
505 /* Length of file when last read or saved.
506 -1 means auto saving turned off because buffer shrank a lot.
507 -2 means don't turn off auto saving if buffer shrinks.
508 (That value is used with buffer-swap-text.)
509 This is not in the struct buffer_text
510 because it's not used in indirect buffers at all. */
511 Lisp_Object INTERNAL_FIELD (save_length);
513 /* File name used for auto-saving this buffer.
514 This is not in the struct buffer_text
515 because it's not used in indirect buffers at all. */
516 Lisp_Object INTERNAL_FIELD (auto_save_file_name);
518 /* Non-nil if buffer read-only. */
519 Lisp_Object INTERNAL_FIELD (read_only);
521 /* "The mark". This is a marker which may
522 point into this buffer or may point nowhere. */
523 Lisp_Object INTERNAL_FIELD (mark);
525 /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER) for all
526 per-buffer variables of this buffer. For locally unbound
527 symbols, just the symbol appears as the element. */
528 Lisp_Object INTERNAL_FIELD (local_var_alist);
530 /* Symbol naming major mode (e.g., lisp-mode). */
531 Lisp_Object INTERNAL_FIELD (major_mode);
533 /* Pretty name of major mode (e.g., "Lisp"). */
534 Lisp_Object INTERNAL_FIELD (mode_name);
536 /* Mode line element that controls format of mode line. */
537 Lisp_Object INTERNAL_FIELD (mode_line_format);
539 /* Analogous to mode_line_format for the line displayed at the top
540 of windows. Nil means don't display that line. */
541 Lisp_Object INTERNAL_FIELD (header_line_format);
543 /* Keys that are bound local to this buffer. */
544 Lisp_Object INTERNAL_FIELD (keymap);
546 /* This buffer's local abbrev table. */
547 Lisp_Object INTERNAL_FIELD (abbrev_table);
549 /* This buffer's syntax table. */
550 Lisp_Object INTERNAL_FIELD (syntax_table);
552 /* This buffer's category table. */
553 Lisp_Object INTERNAL_FIELD (category_table);
555 /* Values of several buffer-local variables. */
556 /* tab-width is buffer-local so that redisplay can find it
557 in buffers that are not current. */
558 Lisp_Object INTERNAL_FIELD (case_fold_search);
559 Lisp_Object INTERNAL_FIELD (tab_width);
560 Lisp_Object INTERNAL_FIELD (fill_column);
561 Lisp_Object INTERNAL_FIELD (left_margin);
563 /* Function to call when insert space past fill column. */
564 Lisp_Object INTERNAL_FIELD (auto_fill_function);
566 /* Case table for case-conversion in this buffer.
567 This char-table maps each char into its lower-case version. */
568 Lisp_Object INTERNAL_FIELD (downcase_table);
570 /* Char-table mapping each char to its upper-case version. */
571 Lisp_Object INTERNAL_FIELD (upcase_table);
573 /* Char-table for conversion for case-folding search. */
574 Lisp_Object INTERNAL_FIELD (case_canon_table);
576 /* Char-table of equivalences for case-folding search. */
577 Lisp_Object INTERNAL_FIELD (case_eqv_table);
579 /* Non-nil means do not display continuation lines. */
580 Lisp_Object INTERNAL_FIELD (truncate_lines);
582 /* Non-nil means to use word wrapping when displaying continuation lines. */
583 Lisp_Object INTERNAL_FIELD (word_wrap);
585 /* Non-nil means display ctl chars with uparrow. */
586 Lisp_Object INTERNAL_FIELD (ctl_arrow);
588 /* Non-nil means reorder bidirectional text for display in the
589 visual order. */
590 Lisp_Object INTERNAL_FIELD (bidi_display_reordering);
592 /* If non-nil, specifies which direction of text to force in all the
593 paragraphs of the buffer. Nil means determine paragraph
594 direction dynamically for each paragraph. */
595 Lisp_Object INTERNAL_FIELD (bidi_paragraph_direction);
597 /* Non-nil means do selective display;
598 see doc string in syms_of_buffer (buffer.c) for details. */
599 Lisp_Object INTERNAL_FIELD (selective_display);
601 /* Non-nil means show ... at end of line followed by invisible lines. */
602 Lisp_Object INTERNAL_FIELD (selective_display_ellipses);
604 /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer. */
605 Lisp_Object INTERNAL_FIELD (minor_modes);
607 /* t if "self-insertion" should overwrite; `binary' if it should also
608 overwrite newlines and tabs - for editing executables and the like. */
609 Lisp_Object INTERNAL_FIELD (overwrite_mode);
611 /* Non-nil means abbrev mode is on. Expand abbrevs automatically. */
612 Lisp_Object INTERNAL_FIELD (abbrev_mode);
614 /* Display table to use for text in this buffer. */
615 Lisp_Object INTERNAL_FIELD (display_table);
617 /* t means the mark and region are currently active. */
618 Lisp_Object INTERNAL_FIELD (mark_active);
620 /* Non-nil means the buffer contents are regarded as multi-byte
621 form of characters, not a binary code. */
622 Lisp_Object INTERNAL_FIELD (enable_multibyte_characters);
624 /* Coding system to be used for encoding the buffer contents on
625 saving. */
626 Lisp_Object INTERNAL_FIELD (buffer_file_coding_system);
628 /* List of symbols naming the file format used for visited file. */
629 Lisp_Object INTERNAL_FIELD (file_format);
631 /* List of symbols naming the file format used for auto-save file. */
632 Lisp_Object INTERNAL_FIELD (auto_save_file_format);
634 /* True if the newline position cache and width run cache are
635 enabled. See search.c and indent.c. */
636 Lisp_Object INTERNAL_FIELD (cache_long_line_scans);
638 /* If the width run cache is enabled, this table contains the
639 character widths width_run_cache (see above) assumes. When we
640 do a thorough redisplay, we compare this against the buffer's
641 current display table to see whether the display table has
642 affected the widths of any characters. If it has, we
643 invalidate the width run cache, and re-initialize width_table. */
644 Lisp_Object INTERNAL_FIELD (width_table);
646 /* In an indirect buffer, or a buffer that is the base of an
647 indirect buffer, this holds a marker that records
648 PT for this buffer when the buffer is not current. */
649 Lisp_Object INTERNAL_FIELD (pt_marker);
651 /* In an indirect buffer, or a buffer that is the base of an
652 indirect buffer, this holds a marker that records
653 BEGV for this buffer when the buffer is not current. */
654 Lisp_Object INTERNAL_FIELD (begv_marker);
656 /* In an indirect buffer, or a buffer that is the base of an
657 indirect buffer, this holds a marker that records
658 ZV for this buffer when the buffer is not current. */
659 Lisp_Object INTERNAL_FIELD (zv_marker);
661 /* This holds the point value before the last scroll operation.
662 Explicitly setting point sets this to nil. */
663 Lisp_Object INTERNAL_FIELD (point_before_scroll);
665 /* Truename of the visited file, or nil. */
666 Lisp_Object INTERNAL_FIELD (file_truename);
668 /* Invisibility spec of this buffer.
669 t => any non-nil `invisible' property means invisible.
670 A list => `invisible' property means invisible
671 if it is memq in that list. */
672 Lisp_Object INTERNAL_FIELD (invisibility_spec);
674 /* This is the last window that was selected with this buffer in it,
675 or nil if that window no longer displays this buffer. */
676 Lisp_Object INTERNAL_FIELD (last_selected_window);
678 /* Incremented each time the buffer is displayed in a window. */
679 Lisp_Object INTERNAL_FIELD (display_count);
681 /* Widths of left and right marginal areas for windows displaying
682 this buffer. */
683 Lisp_Object INTERNAL_FIELD (left_margin_cols);
684 Lisp_Object INTERNAL_FIELD (right_margin_cols);
686 /* Widths of left and right fringe areas for windows displaying
687 this buffer. */
688 Lisp_Object INTERNAL_FIELD (left_fringe_width);
689 Lisp_Object INTERNAL_FIELD (right_fringe_width);
691 /* Non-nil means fringes are drawn outside display margins;
692 othersize draw them between margin areas and text. */
693 Lisp_Object INTERNAL_FIELD (fringes_outside_margins);
695 /* Width and type of scroll bar areas for windows displaying
696 this buffer. */
697 Lisp_Object INTERNAL_FIELD (scroll_bar_width);
698 Lisp_Object INTERNAL_FIELD (vertical_scroll_bar_type);
700 /* Non-nil means indicate lines not displaying text (in a style
701 like vi). */
702 Lisp_Object INTERNAL_FIELD (indicate_empty_lines);
704 /* Non-nil means indicate buffer boundaries and scrolling. */
705 Lisp_Object INTERNAL_FIELD (indicate_buffer_boundaries);
707 /* Logical to physical fringe bitmap mappings. */
708 Lisp_Object INTERNAL_FIELD (fringe_indicator_alist);
710 /* Logical to physical cursor bitmap mappings. */
711 Lisp_Object INTERNAL_FIELD (fringe_cursor_alist);
713 /* Time stamp updated each time this buffer is displayed in a window. */
714 Lisp_Object INTERNAL_FIELD (display_time);
716 /* If scrolling the display because point is below the bottom of a
717 window showing this buffer, try to choose a window start so
718 that point ends up this number of lines from the top of the
719 window. Nil means that scrolling method isn't used. */
720 Lisp_Object INTERNAL_FIELD (scroll_up_aggressively);
722 /* If scrolling the display because point is above the top of a
723 window showing this buffer, try to choose a window start so
724 that point ends up this number of lines from the bottom of the
725 window. Nil means that scrolling method isn't used. */
726 Lisp_Object INTERNAL_FIELD (scroll_down_aggressively);
728 /* Desired cursor type in this buffer. See the doc string of
729 per-buffer variable `cursor-type'. */
730 Lisp_Object INTERNAL_FIELD (cursor_type);
732 /* An integer > 0 means put that number of pixels below text lines
733 in the display of this buffer. */
734 Lisp_Object INTERNAL_FIELD (extra_line_spacing);
736 /* Cursor type to display in non-selected windows.
737 t means to use hollow box cursor.
738 See `cursor-type' for other values. */
739 Lisp_Object INTERNAL_FIELD (cursor_in_non_selected_windows);
741 /* No more Lisp_Object beyond this point. Except undo_list,
742 which is handled specially in Fgarbage_collect . */
744 /* This structure holds the coordinates of the buffer contents
745 in ordinary buffers. In indirect buffers, this is not used. */
746 struct buffer_text own_text;
748 /* This points to the `struct buffer_text' that used for this buffer.
749 In an ordinary buffer, this is the own_text field above.
750 In an indirect buffer, this is the own_text field of another buffer. */
751 struct buffer_text *text;
753 /* Char position of point in buffer. */
754 ptrdiff_t pt;
756 /* Byte position of point in buffer. */
757 ptrdiff_t pt_byte;
759 /* Char position of beginning of accessible range. */
760 ptrdiff_t begv;
762 /* Byte position of beginning of accessible range. */
763 ptrdiff_t begv_byte;
765 /* Char position of end of accessible range. */
766 ptrdiff_t zv;
768 /* Byte position of end of accessible range. */
769 ptrdiff_t zv_byte;
771 /* In an indirect buffer, this points to the base buffer.
772 In an ordinary buffer, it is 0. */
773 struct buffer *base_buffer;
775 /* In an indirect buffer, this is -1. In an ordinary buffer,
776 it's the number of indirect buffers that share our text;
777 zero means that we're the only owner of this text. */
778 int indirections;
780 /* A non-zero value in slot IDX means that per-buffer variable
781 with index IDX has a local value in this buffer. The index IDX
782 for a buffer-local variable is stored in that variable's slot
783 in buffer_local_flags as a Lisp integer. If the index is -1,
784 this means the variable is always local in all buffers. */
785 #define MAX_PER_BUFFER_VARS 50
786 char local_flags[MAX_PER_BUFFER_VARS];
788 /* Set to the modtime of the visited file when read or written.
789 EMACS_NSECS (modtime) == NONEXISTENT_MODTIME_NSECS means
790 visited file was nonexistent. EMACS_NSECS (modtime) ==
791 UNKNOWN_MODTIME_NSECS means visited file modtime unknown;
792 in no case complain about any mismatch on next save attempt. */
793 #define NONEXISTENT_MODTIME_NSECS (-1)
794 #define UNKNOWN_MODTIME_NSECS (-2)
795 EMACS_TIME modtime;
797 /* Size of the file when modtime was set. This is used to detect the
798 case where the file grew while we were reading it, so the modtime
799 is still the same (since it's rounded up to seconds) but we're actually
800 not up-to-date. -1 means the size is unknown. Only meaningful if
801 modtime is actually set. */
802 off_t modtime_size;
804 /* The value of text->modiff at the last auto-save. */
805 EMACS_INT auto_save_modified;
807 /* The value of text->modiff at the last display error.
808 Redisplay of this buffer is inhibited until it changes again. */
809 EMACS_INT display_error_modiff;
811 /* The time at which we detected a failure to auto-save,
812 Or 0 if we didn't have a failure. */
813 time_t auto_save_failure_time;
815 /* Position in buffer at which display started
816 the last time this buffer was displayed. */
817 ptrdiff_t last_window_start;
819 /* If the long line scan cache is enabled (i.e. the buffer-local
820 variable cache-long-line-scans is non-nil), newline_cache
821 points to the newline cache, and width_run_cache points to the
822 width run cache.
824 The newline cache records which stretches of the buffer are
825 known *not* to contain newlines, so that they can be skipped
826 quickly when we search for newlines.
828 The width run cache records which stretches of the buffer are
829 known to contain characters whose widths are all the same. If
830 the width run cache maps a character to a value > 0, that value is
831 the character's width; if it maps a character to zero, we don't
832 know what its width is. This allows compute_motion to process
833 such regions very quickly, using algebra instead of inspecting
834 each character. See also width_table, below. */
835 struct region_cache *newline_cache;
836 struct region_cache *width_run_cache;
838 /* Non-zero means don't use redisplay optimizations for
839 displaying this buffer. */
840 unsigned prevent_redisplay_optimizations_p : 1;
842 /* Non-zero whenever the narrowing is changed in this buffer. */
843 unsigned clip_changed : 1;
845 /* List of overlays that end at or before the current center,
846 in order of end-position. */
847 struct Lisp_Overlay *overlays_before;
849 /* List of overlays that end after the current center,
850 in order of start-position. */
851 struct Lisp_Overlay *overlays_after;
853 /* Position where the overlay lists are centered. */
854 ptrdiff_t overlay_center;
856 /* Changes in the buffer are recorded here for undo, and t means
857 don't record anything. This information belongs to the base
858 buffer of an indirect buffer. But we can't store it in the
859 struct buffer_text because local variables have to be right in
860 the struct buffer. So we copy it around in set_buffer_internal. */
861 Lisp_Object INTERNAL_FIELD (undo_list);
864 /* Most code should use these functions to set Lisp fields in struct
865 buffer. */
866 BUFFER_INLINE void
867 bset_bidi_paragraph_direction (struct buffer *b, Lisp_Object val)
869 b->INTERNAL_FIELD (bidi_paragraph_direction) = val;
871 BUFFER_INLINE void
872 bset_case_canon_table (struct buffer *b, Lisp_Object val)
874 b->INTERNAL_FIELD (case_canon_table) = val;
876 BUFFER_INLINE void
877 bset_case_eqv_table (struct buffer *b, Lisp_Object val)
879 b->INTERNAL_FIELD (case_eqv_table) = val;
881 BUFFER_INLINE void
882 bset_directory (struct buffer *b, Lisp_Object val)
884 b->INTERNAL_FIELD (directory) = val;
886 BUFFER_INLINE void
887 bset_display_count (struct buffer *b, Lisp_Object val)
889 b->INTERNAL_FIELD (display_count) = val;
891 BUFFER_INLINE void
892 bset_display_time (struct buffer *b, Lisp_Object val)
894 b->INTERNAL_FIELD (display_time) = val;
896 BUFFER_INLINE void
897 bset_downcase_table (struct buffer *b, Lisp_Object val)
899 b->INTERNAL_FIELD (downcase_table) = val;
901 BUFFER_INLINE void
902 bset_enable_multibyte_characters (struct buffer *b, Lisp_Object val)
904 b->INTERNAL_FIELD (enable_multibyte_characters) = val;
906 BUFFER_INLINE void
907 bset_filename (struct buffer *b, Lisp_Object val)
909 b->INTERNAL_FIELD (filename) = val;
911 BUFFER_INLINE void
912 bset_keymap (struct buffer *b, Lisp_Object val)
914 b->INTERNAL_FIELD (keymap) = val;
916 BUFFER_INLINE void
917 bset_last_selected_window (struct buffer *b, Lisp_Object val)
919 b->INTERNAL_FIELD (last_selected_window) = val;
921 BUFFER_INLINE void
922 bset_local_var_alist (struct buffer *b, Lisp_Object val)
924 b->INTERNAL_FIELD (local_var_alist) = val;
926 BUFFER_INLINE void
927 bset_mark_active (struct buffer *b, Lisp_Object val)
929 b->INTERNAL_FIELD (mark_active) = val;
931 BUFFER_INLINE void
932 bset_point_before_scroll (struct buffer *b, Lisp_Object val)
934 b->INTERNAL_FIELD (point_before_scroll) = val;
936 BUFFER_INLINE void
937 bset_read_only (struct buffer *b, Lisp_Object val)
939 b->INTERNAL_FIELD (read_only) = val;
941 BUFFER_INLINE void
942 bset_truncate_lines (struct buffer *b, Lisp_Object val)
944 b->INTERNAL_FIELD (truncate_lines) = val;
946 BUFFER_INLINE void
947 bset_undo_list (struct buffer *b, Lisp_Object val)
949 b->INTERNAL_FIELD (undo_list) = val;
951 BUFFER_INLINE void
952 bset_upcase_table (struct buffer *b, Lisp_Object val)
954 b->INTERNAL_FIELD (upcase_table) = val;
956 BUFFER_INLINE void
957 bset_width_table (struct buffer *b, Lisp_Object val)
959 b->INTERNAL_FIELD (width_table) = val;
962 /* Convenient check whether buffer B is live. */
964 #define BUFFER_LIVE_P(b) (!NILP (BVAR (b, name)))
966 /* Verify indirection counters. */
968 #define BUFFER_CHECK_INDIRECTION(b) \
969 do { \
970 if (BUFFER_LIVE_P (b)) \
972 if (b->base_buffer) \
974 eassert (b->indirections == -1); \
975 eassert (b->base_buffer->indirections > 0); \
977 else \
978 eassert (b->indirections >= 0); \
980 } while (0)
982 /* Chain of all buffers, including killed ones. */
984 extern struct buffer *all_buffers;
986 /* Used to iterate over the chain above. */
988 #define FOR_EACH_BUFFER(b) \
989 for ((b) = all_buffers; (b); (b) = (b)->header.next.buffer)
991 /* This points to the current buffer. */
993 extern struct buffer *current_buffer;
995 /* This structure holds the default values of the buffer-local variables
996 that have special slots in each buffer.
997 The default value occupies the same slot in this structure
998 as an individual buffer's value occupies in that buffer.
999 Setting the default value also goes through the alist of buffers
1000 and stores into each buffer that does not say it has a local value. */
1002 extern struct buffer buffer_defaults;
1004 /* This structure marks which slots in a buffer have corresponding
1005 default values in buffer_defaults.
1006 Each such slot has a nonzero value in this structure.
1007 The value has only one nonzero bit.
1009 When a buffer has its own local value for a slot,
1010 the entry for that slot (found in the same slot in this structure)
1011 is turned on in the buffer's local_flags array.
1013 If a slot in this structure is zero, then even though there may
1014 be a Lisp-level local variable for the slot, it has no default value,
1015 and the corresponding slot in buffer_defaults is not used. */
1018 extern struct buffer buffer_local_flags;
1020 /* For each buffer slot, this points to the Lisp symbol name
1021 for that slot in the current buffer. It is 0 for slots
1022 that don't have such names. */
1024 extern struct buffer buffer_local_symbols;
1026 extern void delete_all_overlays (struct buffer *);
1027 extern void reset_buffer (struct buffer *);
1028 extern void compact_buffer (struct buffer *);
1029 extern void evaporate_overlays (ptrdiff_t);
1030 extern ptrdiff_t overlays_at (EMACS_INT, bool, Lisp_Object **,
1031 ptrdiff_t *, ptrdiff_t *, ptrdiff_t *, bool);
1032 extern ptrdiff_t sort_overlays (Lisp_Object *, ptrdiff_t, struct window *);
1033 extern void recenter_overlay_lists (struct buffer *, ptrdiff_t);
1034 extern ptrdiff_t overlay_strings (ptrdiff_t, struct window *, unsigned char **);
1035 extern void validate_region (Lisp_Object *, Lisp_Object *);
1036 extern void set_buffer_internal_1 (struct buffer *);
1037 extern void set_buffer_temp (struct buffer *);
1038 extern Lisp_Object buffer_local_value_1 (Lisp_Object, Lisp_Object);
1039 extern void record_buffer (Lisp_Object);
1040 extern _Noreturn void buffer_slot_type_mismatch (Lisp_Object, int);
1041 extern void fix_overlays_before (struct buffer *, ptrdiff_t, ptrdiff_t);
1042 extern void mmap_set_vars (bool);
1044 /* Set the current buffer to B.
1046 We previously set windows_or_buffers_changed here to invalidate
1047 global unchanged information in beg_unchanged and end_unchanged.
1048 This is no longer necessary because we now compute unchanged
1049 information on a buffer-basis. Every action affecting other
1050 windows than the selected one requires a select_window at some
1051 time, and that increments windows_or_buffers_changed. */
1053 BUFFER_INLINE void
1054 set_buffer_internal (struct buffer *b)
1056 if (current_buffer != b)
1057 set_buffer_internal_1 (b);
1060 /* Arrange to go back to the original buffer after the next
1061 call to unbind_to if the original buffer is still alive. */
1063 BUFFER_INLINE void
1064 record_unwind_current_buffer (void)
1066 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
1069 /* Get overlays at POSN into array OVERLAYS with NOVERLAYS elements.
1070 If NEXTP is non-NULL, return next overlay there.
1071 See overlay_at arg CHANGE_REQ for meaning of CHRQ arg. */
1073 #define GET_OVERLAYS_AT(posn, overlays, noverlays, nextp, chrq) \
1074 do { \
1075 ptrdiff_t maxlen = 40; \
1076 overlays = alloca (maxlen * sizeof *overlays); \
1077 noverlays = overlays_at (posn, 0, &overlays, &maxlen, \
1078 nextp, NULL, chrq); \
1079 if (noverlays > maxlen) \
1081 maxlen = noverlays; \
1082 overlays = alloca (maxlen * sizeof *overlays); \
1083 noverlays = overlays_at (posn, 0, &overlays, &maxlen, \
1084 nextp, NULL, chrq); \
1086 } while (0)
1088 extern Lisp_Object Qbefore_change_functions;
1089 extern Lisp_Object Qafter_change_functions;
1090 extern Lisp_Object Qfirst_change_hook;
1092 /* Get text properties of B. */
1094 BUFFER_INLINE INTERVAL
1095 buffer_intervals (struct buffer *b)
1097 eassert (b->text != NULL);
1098 return b->text->intervals;
1101 /* Set text properties of B to I. */
1103 BUFFER_INLINE void
1104 set_buffer_intervals (struct buffer *b, INTERVAL i)
1106 eassert (b->text != NULL);
1107 b->text->intervals = i;
1110 /* Non-zero if current buffer has overlays. */
1112 BUFFER_INLINE bool
1113 buffer_has_overlays (void)
1115 return current_buffer->overlays_before || current_buffer->overlays_after;
1118 /* Return character code of multi-byte form at byte position POS. If POS
1119 doesn't point the head of valid multi-byte form, only the byte at
1120 POS is returned. No range checking.
1122 WARNING: The character returned by this macro could be "unified"
1123 inside STRING_CHAR, if the original character in the buffer belongs
1124 to one of the Private Use Areas (PUAs) of codepoints that Emacs
1125 uses to support non-unified CJK characters. If that happens,
1126 CHAR_BYTES will return a value that is different from the length of
1127 the original multibyte sequence stored in the buffer. Therefore,
1128 do _not_ use FETCH_MULTIBYTE_CHAR if you need to advance through
1129 the buffer to the next character after fetching this one. Instead,
1130 use either FETCH_CHAR_ADVANCE or STRING_CHAR_AND_LENGTH. */
1132 BUFFER_INLINE int
1133 FETCH_MULTIBYTE_CHAR (ptrdiff_t pos)
1135 unsigned char *p = ((pos >= GPT_BYTE ? GAP_SIZE : 0)
1136 + pos + BEG_ADDR - BEG_BYTE);
1137 return STRING_CHAR (p);
1140 /* Return character code of multi-byte form at byte position POS in BUF.
1141 If POS doesn't point the head of valid multi-byte form, only the byte at
1142 POS is returned. No range checking. */
1144 BUFFER_INLINE int
1145 BUF_FETCH_MULTIBYTE_CHAR (struct buffer *buf, ptrdiff_t pos)
1147 unsigned char *p
1148 = ((pos >= BUF_GPT_BYTE (buf) ? BUF_GAP_SIZE (buf) : 0)
1149 + pos + BUF_BEG_ADDR (buf) - BEG_BYTE);
1150 return STRING_CHAR (p);
1153 /* Overlays */
1155 /* Return the marker that stands for where OV starts in the buffer. */
1157 #define OVERLAY_START(OV) XOVERLAY (OV)->start
1159 /* Return the marker that stands for where OV ends in the buffer. */
1161 #define OVERLAY_END(OV) XOVERLAY (OV)->end
1163 /* Return the plist of overlay OV. */
1165 #define OVERLAY_PLIST(OV) XOVERLAY (OV)->plist
1167 /* Return the actual buffer position for the marker P.
1168 We assume you know which buffer it's pointing into. */
1170 #define OVERLAY_POSITION(P) \
1171 (MARKERP (P) ? marker_position (P) : (emacs_abort (), 0))
1174 /***********************************************************************
1175 Buffer-local Variables
1176 ***********************************************************************/
1178 /* Number of per-buffer variables used. */
1180 extern int last_per_buffer_idx;
1182 /* Return the offset in bytes of member VAR of struct buffer
1183 from the start of a buffer structure. */
1185 #define PER_BUFFER_VAR_OFFSET(VAR) \
1186 offsetof (struct buffer, INTERNAL_FIELD (VAR))
1188 /* Used to iterate over normal Lisp_Object fields of struct buffer (all
1189 Lisp_Objects except undo_list). If you add, remove, or reorder
1190 Lisp_Objects in a struct buffer, make sure that this is still correct. */
1192 #define FOR_EACH_PER_BUFFER_OBJECT_AT(offset) \
1193 for (offset = PER_BUFFER_VAR_OFFSET (name); \
1194 offset <= PER_BUFFER_VAR_OFFSET (cursor_in_non_selected_windows); \
1195 offset += word_size)
1197 /* Return the index of buffer-local variable VAR. Each per-buffer
1198 variable has an index > 0 associated with it, except when it always
1199 has buffer-local values, in which case the index is -1. If this is
1200 0, this is a bug and means that the slot of VAR in
1201 buffer_local_flags wasn't initialized. */
1203 #define PER_BUFFER_VAR_IDX(VAR) \
1204 PER_BUFFER_IDX (PER_BUFFER_VAR_OFFSET (VAR))
1206 /* Value is non-zero if the variable with index IDX has a local value
1207 in buffer B. */
1209 #define PER_BUFFER_VALUE_P(B, IDX) \
1210 (((IDX) < 0 || IDX >= last_per_buffer_idx) \
1211 ? (emacs_abort (), 0) \
1212 : ((B)->local_flags[IDX] != 0))
1214 /* Set whether per-buffer variable with index IDX has a buffer-local
1215 value in buffer B. VAL zero means it hasn't. */
1217 #define SET_PER_BUFFER_VALUE_P(B, IDX, VAL) \
1218 do { \
1219 if ((IDX) < 0 || (IDX) >= last_per_buffer_idx) \
1220 emacs_abort (); \
1221 (B)->local_flags[IDX] = (VAL); \
1222 } while (0)
1224 /* Return the index value of the per-buffer variable at offset OFFSET
1225 in the buffer structure.
1227 If the slot OFFSET has a corresponding default value in
1228 buffer_defaults, the index value is positive and has only one
1229 nonzero bit. When a buffer has its own local value for a slot, the
1230 bit for that slot (found in the same slot in this structure) is
1231 turned on in the buffer's local_flags array.
1233 If the index value is -1, even though there may be a
1234 DEFVAR_PER_BUFFER for the slot, there is no default value for it;
1235 and the corresponding slot in buffer_defaults is not used.
1237 If the index value is -2, then there is no DEFVAR_PER_BUFFER for
1238 the slot, but there is a default value which is copied into each
1239 new buffer.
1241 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
1242 zero, that is a bug */
1245 #define PER_BUFFER_IDX(OFFSET) \
1246 XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
1248 /* Functions to get and set default value of the per-buffer
1249 variable at offset OFFSET in the buffer structure. */
1251 BUFFER_INLINE Lisp_Object
1252 per_buffer_default (int offset)
1254 return *(Lisp_Object *)(offset + (char *) &buffer_defaults);
1257 BUFFER_INLINE void
1258 set_per_buffer_default (int offset, Lisp_Object value)
1260 *(Lisp_Object *)(offset + (char *) &buffer_defaults) = value;
1263 /* Functions to get and set buffer-local value of the per-buffer
1264 variable at offset OFFSET in the buffer structure. */
1266 BUFFER_INLINE Lisp_Object
1267 per_buffer_value (struct buffer *b, int offset)
1269 return *(Lisp_Object *)(offset + (char *) b);
1272 BUFFER_INLINE void
1273 set_per_buffer_value (struct buffer *b, int offset, Lisp_Object value)
1275 *(Lisp_Object *)(offset + (char *) b) = value;
1278 /* Downcase a character C, or make no change if that cannot be done. */
1279 BUFFER_INLINE int
1280 downcase (int c)
1282 Lisp_Object downcase_table = BVAR (current_buffer, downcase_table);
1283 Lisp_Object down = CHAR_TABLE_REF (downcase_table, c);
1284 return NATNUMP (down) ? XFASTINT (down) : c;
1287 /* 1 if C is upper case. */
1288 BUFFER_INLINE bool uppercasep (int c) { return downcase (c) != c; }
1290 /* Upcase a character C known to be not upper case. */
1291 BUFFER_INLINE int
1292 upcase1 (int c)
1294 Lisp_Object upcase_table = BVAR (current_buffer, upcase_table);
1295 Lisp_Object up = CHAR_TABLE_REF (upcase_table, c);
1296 return NATNUMP (up) ? XFASTINT (up) : c;
1299 /* 1 if C is lower case. */
1300 BUFFER_INLINE bool
1301 lowercasep (int c)
1303 return !uppercasep (c) && upcase1 (c) != c;
1306 /* Upcase a character C, or make no change if that cannot be done. */
1307 BUFFER_INLINE int upcase (int c) { return uppercasep (c) ? c : upcase1 (c); }
1309 INLINE_HEADER_END