src/buffer.h

   1 /* Header file for the buffer manipulation primitives.
   2
   3 Copyright (C) 1985-1986, 1993-1995, 1997-2012
   4                  Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   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.
  12
  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.
  17
  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/>.  */
  20
  21 #include <sys/types.h> /* for off_t, time_t */
  22 #include "systime.h" /* for EMACS_TIME */
  23
  24 INLINE_HEADER_BEGIN
  25 #ifndef BUFFER_INLINE
  26 # define BUFFER_INLINE INLINE
  27 #endif
  28
  29 /* Accessing the parameters of the current buffer.  */
  30
  31 /* These macros come in pairs, one for the char position
  32    and one for the byte position.  */
  33
  34 /* Position of beginning of buffer.  */
  35 #define BEG (1)
  36 #define BEG_BYTE (BEG)
  37
  38 /* Position of beginning of accessible range of buffer.  */
  39 #define BEGV (current_buffer->begv)
  40 #define BEGV_BYTE (current_buffer->begv_byte)
  41
  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)
  46
  47 /* Position of gap in buffer.  */
  48 #define GPT (current_buffer->text->gpt)
  49 #define GPT_BYTE (current_buffer->text->gpt_byte)
  50
  51 /* Position of end of accessible range of buffer.  */
  52 #define ZV (current_buffer->zv)
  53 #define ZV_BYTE (current_buffer->zv_byte)
  54
  55 /* Position of end of buffer.  */
  56 #define Z (current_buffer->text->z)
  57 #define Z_BYTE (current_buffer->text->z_byte)
  58
  59 /* Macros for the addresses of places in the buffer.  */
  60
  61 /* Address of beginning of buffer.  */
  62 #define BEG_ADDR (current_buffer->text->beg)
  63
  64 /* Address of beginning of accessible range of buffer.  */
  65 #define BEGV_ADDR (BYTE_POS_ADDR (current_buffer->begv_byte))
  66
  67 /* Address of point in buffer.  */
  68 #define PT_ADDR (BYTE_POS_ADDR (current_buffer->pt_byte))
  69
  70 /* Address of beginning of gap in buffer.  */
  71 #define GPT_ADDR (current_buffer->text->beg + current_buffer->text->gpt_byte - BEG_BYTE)
  72
  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)
  75
  76 /* Address of end of accessible range of buffer.  */
  77 #define ZV_ADDR (BYTE_POS_ADDR (current_buffer->zv_byte))
  78
  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)
  81
  82 /* Size of gap.  */
  83 #define GAP_SIZE (current_buffer->text->gap_size)
  84
  85 /* Is the current buffer narrowed?  */
  86 #define NARROWED        ((BEGV != BEG) || (ZV != Z))
  87
  88 /* Modification count.  */
  89 #define MODIFF (current_buffer->text->modiff)
  90
  91 /* Character modification count.  */
  92 #define CHARS_MODIFF (current_buffer->text->chars_modiff)
  93
  94 /* Overlay modification count.  */
  95 #define OVERLAY_MODIFF (current_buffer->text->overlay_modiff)
  96
  97 /* Modification count as of last visit or save.  */
  98 #define SAVE_MODIFF (current_buffer->text->save_modiff)
  99
 100 /* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return
 101    the max (resp. min) p such that
 102
 103    BYTE_POS_ADDR (p) - BYTE_POS_ADDR (n) == p - n       */
 104
 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)
 109 \f
 110 /* Similar macros to operate on a specified buffer.
 111    Note that many of these evaluate the buffer argument more than once.  */
 112
 113 /* Position of beginning of buffer.  */
 114 #define BUF_BEG(buf) (BEG)
 115 #define BUF_BEG_BYTE(buf) (BEG_BYTE)
 116
 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.  */
 119
 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)))
 125
 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)))
 130
 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)))
 136
 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)))
 141
 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)))
 147
 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)))
 152
 153 /* Position of gap in buffer.  */
 154 #define BUF_GPT(buf) ((buf)->text->gpt)
 155 #define BUF_GPT_BYTE(buf) ((buf)->text->gpt_byte)
 156
 157 /* Position of end of buffer.  */
 158 #define BUF_Z(buf) ((buf)->text->z)
 159 #define BUF_Z_BYTE(buf) ((buf)->text->z_byte)
 160
 161 /* Address of beginning of buffer.  */
 162 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
 163
 164 /* Address of beginning of gap of buffer.  */
 165 #define BUF_GPT_ADDR(buf) ((buf)->text->beg + (buf)->text->gpt_byte - BEG_BYTE)
 166
 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)
 169
 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)
 172
 173 /* Size of gap.  */
 174 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size)
 175
 176 /* Is this buffer narrowed?  */
 177 #define BUF_NARROWED(buf) ((BUF_BEGV (buf) != BUF_BEG (buf)) \
 178                            || (BUF_ZV (buf) != BUF_Z (buf)))
 179
 180 /* Modification count.  */
 181 #define BUF_MODIFF(buf) ((buf)->text->modiff)
 182
 183 /* Character modification count.  */
 184 #define BUF_CHARS_MODIFF(buf) ((buf)->text->chars_modiff)
 185
 186 /* Modification count as of last visit or save.  */
 187 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
 188
 189 /* Overlay modification count.  */
 190 #define BUF_OVERLAY_MODIFF(buf) ((buf)->text->overlay_modiff)
 191
 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)
 195
 196 /* Marker chain of buffer.  */
 197 #define BUF_MARKERS(buf) ((buf)->text->markers)
 198
 199 #define BUF_UNCHANGED_MODIFIED(buf) \
 200   ((buf)->text->unchanged_modified)
 201
 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)
 206
 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)
 213
 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.  */
 217
 218 #define BUF_COMPUTE_UNCHANGED(buf, start, end)                          \
 219   do                                                                    \
 220     {                                                                   \
 221       if (BUF_UNCHANGED_MODIFIED (buf) == BUF_MODIFF (buf)              \
 222           && (BUF_OVERLAY_UNCHANGED_MODIFIED (buf)                      \
 223               == BUF_OVERLAY_MODIFF (buf)))                             \
 224         {                                                               \
 225           BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf);            \
 226           BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end);                \
 227         }                                                               \
 228       else                                                              \
 229         {                                                               \
 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);          \
 234         }                                                               \
 235     }                                                                   \
 236   while (0)
 237
 238 \f
 239 /* Macros to set PT in the current buffer, or another buffer.  */
 240
 241 #define SET_PT(position) (set_point (position))
 242 #define TEMP_SET_PT(position) (temp_set_point (current_buffer, (position)))
 243
 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)))
 247
 248 #define BUF_TEMP_SET_PT(buffer, position) \
 249   (temp_set_point ((buffer), (position)))
 250
 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);
 257
 258 \f
 259 /* Macros for setting the BEGV, ZV or PT of a given buffer.
 260
 261    The ..._BOTH macros take both a charpos and a bytepos,
 262    which must correspond to each other.
 263
 264    The macros without ..._BOTH take just a charpos,
 265    and compute the bytepos from it.  */
 266
 267 #define SET_BUF_BEGV(buf, charpos)                               \
 268   ((buf)->begv_byte = buf_charpos_to_bytepos ((buf), (charpos)), \
 269    (buf)->begv = (charpos))
 270
 271 #define SET_BUF_ZV(buf, charpos)                                \
 272   ((buf)->zv_byte = buf_charpos_to_bytepos ((buf), (charpos)),  \
 273    (buf)->zv = (charpos))
 274
 275 #define SET_BUF_BEGV_BOTH(buf, charpos, byte)           \
 276   ((buf)->begv = (charpos),                             \
 277    (buf)->begv_byte = (byte))
 278
 279 #define SET_BUF_ZV_BOTH(buf, charpos, byte)             \
 280   ((buf)->zv = (charpos),                               \
 281    (buf)->zv_byte = (byte))
 282
 283 #define SET_BUF_PT_BOTH(buf, charpos, byte)             \
 284   ((buf)->pt = (charpos),                               \
 285    (buf)->pt_byte = (byte))
 286 \f
 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.  */
 290
 291 /* Access a Lisp position value in POS,
 292    and store the charpos in CHARPOS and the bytepos in BYTEPOS.  */
 293
 294 #define DECODE_POSITION(charpos, bytepos, pos)                  \
 295 do                                                              \
 296   {                                                             \
 297     Lisp_Object __pos = (pos);                                  \
 298     if (NUMBERP (__pos))                                        \
 299       {                                                         \
 300         charpos = __pos;                                        \
 301         bytepos = buf_charpos_to_bytepos (current_buffer, __pos);  \
 302       }                                                         \
 303     else if (MARKERP (__pos))                                   \
 304       {                                                         \
 305         charpos = marker_position (__pos);                      \
 306         bytepos = marker_byte_position (__pos);                 \
 307       }                                                         \
 308     else                                                        \
 309       wrong_type_argument (Qinteger_or_marker_p, __pos);        \
 310   }                                                             \
 311 while (0)
 312
 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))
 319
 320 /* Return the address of byte position N in current buffer.  */
 321
 322 #define BYTE_POS_ADDR(n) \
 323   (((n) >= GPT_BYTE ? GAP_SIZE : 0) + (n) + BEG_ADDR - BEG_BYTE)
 324
 325 /* Return the address of char position N.  */
 326
 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)
 331
 332 /* Convert a character position to a byte position.  */
 333
 334 #define CHAR_TO_BYTE(charpos)                   \
 335   (buf_charpos_to_bytepos (current_buffer, charpos))
 336
 337 /* Convert a byte position to a character position.  */
 338
 339 #define BYTE_TO_CHAR(bytepos)                   \
 340   (buf_bytepos_to_charpos (current_buffer, bytepos))
 341
 342 /* Convert PTR, the address of a byte in the buffer, into a byte position.  */
 343
 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)
 348
 349 /* Return character at byte position POS.  See the caveat WARNING for
 350    FETCH_MULTIBYTE_CHAR below.  */
 351
 352 #define FETCH_CHAR(pos)                                 \
 353   (!NILP (BVAR (current_buffer, enable_multibyte_characters))   \
 354    ? FETCH_MULTIBYTE_CHAR ((pos))                       \
 355    : FETCH_BYTE ((pos)))
 356
 357 /* Return the byte at byte position N.  */
 358
 359 #define FETCH_BYTE(n) *(BYTE_POS_ADDR ((n)))
 360
 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.  */
 364
 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))))
 369
 370 \f
 371 /* Macros for accessing a character or byte,
 372    or converting between byte positions and addresses,
 373    in a specified buffer.  */
 374
 375 /* Return the address of character at byte position POS in buffer BUF.
 376    Note that both arguments can be computed more than once.  */
 377
 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))
 381
 382 /* Return the address of character at char position POS in buffer BUF.
 383    Note that both arguments can be computed more than once.  */
 384
 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))
 388
 389 /* Convert PTR, the address of a char in buffer BUF,
 390    into a character position.  */
 391
 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)
 397
 398 /* Return the character at byte position POS in buffer BUF.   */
 399
 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)))
 404
 405 /* Return the byte at byte position N in buffer BUF.   */
 406
 407 #define BUF_FETCH_BYTE(buf, n) \
 408   *(BUF_BYTE_ADDRESS ((buf), (n)))
 409 \f
 410 /* Define the actual buffer data structures.  */
 411
 412 /* This data structure describes the actual text contents of a buffer.
 413    It is shared between indirect buffers and their base buffer.  */
 414
 415 struct buffer_text
 416   {
 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;
 422
 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.  */
 438
 439     EMACS_INT overlay_modiff;   /* Counts modifications to overlays.  */
 440
 441     EMACS_INT compact;          /* Set to modiff each time when compact_buffer
 442                                    is called for this buffer.  */
 443
 444     /* Minimum value of GPT - BEG since last redisplay that finished.  */
 445     ptrdiff_t beg_unchanged;
 446
 447     /* Minimum value of Z - GPT since last redisplay that finished.  */
 448     ptrdiff_t end_unchanged;
 449
 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;
 453
 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;
 458
 459     /* Properties of this buffer's text.  */
 460     INTERVAL intervals;
 461
 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;
 470
 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     int inhibit_shrinking;
 475   };
 476
 477 /* Most code should use this macro to access Lisp fields in struct buffer.  */
 478
 479 #define BVAR(buf, field) ((buf)->INTERNAL_FIELD (field))
 480
 481 /* This is the structure that the buffer Lisp object points to.  */
 482
 483 struct buffer
 484 {
 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;
 491
 492   /* The name of this buffer.  */
 493   Lisp_Object INTERNAL_FIELD (name);
 494
 495   /* The name of the file visited in this buffer, or nil.  */
 496   Lisp_Object INTERNAL_FIELD (filename);
 497
 498   /* Directory for expanding relative file names.  */
 499   Lisp_Object INTERNAL_FIELD (directory);
 500
 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);
 504
 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);
 512
 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);
 517
 518   /* Non-nil if buffer read-only.  */
 519   Lisp_Object INTERNAL_FIELD (read_only);
 520
 521   /* "The mark".  This is a marker which may
 522      point into this buffer or may point nowhere.  */
 523   Lisp_Object INTERNAL_FIELD (mark);
 524
 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);
 529
 530   /* Symbol naming major mode (e.g., lisp-mode).  */
 531   Lisp_Object INTERNAL_FIELD (major_mode);
 532
 533   /* Pretty name of major mode (e.g., "Lisp"). */
 534   Lisp_Object INTERNAL_FIELD (mode_name);
 535
 536   /* Mode line element that controls format of mode line.  */
 537   Lisp_Object INTERNAL_FIELD (mode_line_format);
 538
 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);
 542
 543   /* Keys that are bound local to this buffer.  */
 544   Lisp_Object INTERNAL_FIELD (keymap);
 545
 546   /* This buffer's local abbrev table.  */
 547   Lisp_Object INTERNAL_FIELD (abbrev_table);
 548
 549   /* This buffer's syntax table.  */
 550   Lisp_Object INTERNAL_FIELD (syntax_table);
 551
 552   /* This buffer's category table.  */
 553   Lisp_Object INTERNAL_FIELD (category_table);
 554
 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);
 562
 563   /* Function to call when insert space past fill column.  */
 564   Lisp_Object INTERNAL_FIELD (auto_fill_function);
 565
 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);
 569
 570   /* Char-table mapping each char to its upper-case version.  */
 571   Lisp_Object INTERNAL_FIELD (upcase_table);
 572
 573   /* Char-table for conversion for case-folding search.  */
 574   Lisp_Object INTERNAL_FIELD (case_canon_table);
 575
 576   /* Char-table of equivalences for case-folding search.  */
 577   Lisp_Object INTERNAL_FIELD (case_eqv_table);
 578
 579   /* Non-nil means do not display continuation lines.  */
 580   Lisp_Object INTERNAL_FIELD (truncate_lines);
 581
 582   /* Non-nil means to use word wrapping when displaying continuation lines.  */
 583   Lisp_Object INTERNAL_FIELD (word_wrap);
 584
 585   /* Non-nil means display ctl chars with uparrow.  */
 586   Lisp_Object INTERNAL_FIELD (ctl_arrow);
 587
 588   /* Non-nil means reorder bidirectional text for display in the
 589      visual order.  */
 590   Lisp_Object INTERNAL_FIELD (bidi_display_reordering);
 591
 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);
 596
 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);
 600
 601   /* Non-nil means show ... at end of line followed by invisible lines.  */
 602   Lisp_Object INTERNAL_FIELD (selective_display_ellipses);
 603
 604   /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer.  */
 605   Lisp_Object INTERNAL_FIELD (minor_modes);
 606
 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);
 610
 611   /* Non-nil means abbrev mode is on.  Expand abbrevs automatically.  */
 612   Lisp_Object INTERNAL_FIELD (abbrev_mode);
 613
 614   /* Display table to use for text in this buffer.  */
 615   Lisp_Object INTERNAL_FIELD (display_table);
 616
 617   /* t means the mark and region are currently active.  */
 618   Lisp_Object INTERNAL_FIELD (mark_active);
 619
 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);
 623
 624   /* Coding system to be used for encoding the buffer contents on
 625      saving.  */
 626   Lisp_Object INTERNAL_FIELD (buffer_file_coding_system);
 627
 628   /* List of symbols naming the file format used for visited file.  */
 629   Lisp_Object INTERNAL_FIELD (file_format);
 630
 631   /* List of symbols naming the file format used for auto-save file.  */
 632   Lisp_Object INTERNAL_FIELD (auto_save_file_format);
 633
 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);
 637
 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);
 645
 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);
 650
 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);
 655
 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);
 660
 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);
 664
 665   /* Truename of the visited file, or nil.  */
 666   Lisp_Object INTERNAL_FIELD (file_truename);
 667
 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);
 673
 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);
 677
 678   /* Incremented each time the buffer is displayed in a window.  */
 679   Lisp_Object INTERNAL_FIELD (display_count);
 680
 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);
 685
 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);
 690
 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);
 694
 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);
 699
 700   /* Non-nil means indicate lines not displaying text (in a style
 701      like vi).  */
 702   Lisp_Object INTERNAL_FIELD (indicate_empty_lines);
 703
 704   /* Non-nil means indicate buffer boundaries and scrolling.  */
 705   Lisp_Object INTERNAL_FIELD (indicate_buffer_boundaries);
 706
 707   /* Logical to physical fringe bitmap mappings.  */
 708   Lisp_Object INTERNAL_FIELD (fringe_indicator_alist);
 709
 710   /* Logical to physical cursor bitmap mappings.  */
 711   Lisp_Object INTERNAL_FIELD (fringe_cursor_alist);
 712
 713   /* Time stamp updated each time this buffer is displayed in a window.  */
 714   Lisp_Object INTERNAL_FIELD (display_time);
 715
 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);
 721
 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);
 727
 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);
 731
 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);
 735
 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);
 740
 741   /* No more Lisp_Object beyond this point.  Except undo_list,
 742      which is handled specially in Fgarbage_collect .  */
 743
 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;
 747
 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;
 752
 753   /* Char position of point in buffer.  */
 754   ptrdiff_t pt;
 755
 756   /* Byte position of point in buffer.  */
 757   ptrdiff_t pt_byte;
 758
 759   /* Char position of beginning of accessible range.  */
 760   ptrdiff_t begv;
 761
 762   /* Byte position of beginning of accessible range.  */
 763   ptrdiff_t begv_byte;
 764
 765   /* Char position of end of accessible range.  */
 766   ptrdiff_t zv;
 767
 768   /* Byte position of end of accessible range.  */
 769   ptrdiff_t zv_byte;
 770
 771   /* In an indirect buffer, this points to the base buffer.
 772      In an ordinary buffer, it is 0.  */
 773   struct buffer *base_buffer;
 774
 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;
 779
 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];
 787
 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;
 796
 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;
 803
 804   /* The value of text->modiff at the last auto-save.  */
 805   EMACS_INT auto_save_modified;
 806
 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;
 810
 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;
 814
 815   /* Position in buffer at which display started
 816      the last time this buffer was displayed.  */
 817   ptrdiff_t last_window_start;
 818
 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.
 823
 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.
 827
 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;
 837
 838   /* Non-zero means don't use redisplay optimizations for
 839      displaying this buffer.  */
 840   unsigned prevent_redisplay_optimizations_p : 1;
 841
 842   /* Non-zero whenever the narrowing is changed in this buffer.  */
 843   unsigned clip_changed : 1;
 844
 845   /* List of overlays that end at or before the current center,
 846      in order of end-position.  */
 847   struct Lisp_Overlay *overlays_before;
 848
 849   /* List of overlays that end after  the current center,
 850      in order of start-position.  */
 851   struct Lisp_Overlay *overlays_after;
 852
 853   /* Position where the overlay lists are centered.  */
 854   ptrdiff_t overlay_center;
 855
 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);
 862 };
 863
 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)
 868 {
 869   b->INTERNAL_FIELD (bidi_paragraph_direction) = val;
 870 }
 871 BUFFER_INLINE void
 872 bset_case_canon_table (struct buffer *b, Lisp_Object val)
 873 {
 874   b->INTERNAL_FIELD (case_canon_table) = val;
 875 }
 876 BUFFER_INLINE void
 877 bset_case_eqv_table (struct buffer *b, Lisp_Object val)
 878 {
 879   b->INTERNAL_FIELD (case_eqv_table) = val;
 880 }
 881 BUFFER_INLINE void
 882 bset_directory (struct buffer *b, Lisp_Object val)
 883 {
 884   b->INTERNAL_FIELD (directory) = val;
 885 }
 886 BUFFER_INLINE void
 887 bset_display_count (struct buffer *b, Lisp_Object val)
 888 {
 889   b->INTERNAL_FIELD (display_count) = val;
 890 }
 891 BUFFER_INLINE void
 892 bset_display_time (struct buffer *b, Lisp_Object val)
 893 {
 894   b->INTERNAL_FIELD (display_time) = val;
 895 }
 896 BUFFER_INLINE void
 897 bset_downcase_table (struct buffer *b, Lisp_Object val)
 898 {
 899   b->INTERNAL_FIELD (downcase_table) = val;
 900 }
 901 BUFFER_INLINE void
 902 bset_enable_multibyte_characters (struct buffer *b, Lisp_Object val)
 903 {
 904   b->INTERNAL_FIELD (enable_multibyte_characters) = val;
 905 }
 906 BUFFER_INLINE void
 907 bset_filename (struct buffer *b, Lisp_Object val)
 908 {
 909   b->INTERNAL_FIELD (filename) = val;
 910 }
 911 BUFFER_INLINE void
 912 bset_keymap (struct buffer *b, Lisp_Object val)
 913 {
 914   b->INTERNAL_FIELD (keymap) = val;
 915 }
 916 BUFFER_INLINE void
 917 bset_last_selected_window (struct buffer *b, Lisp_Object val)
 918 {
 919   b->INTERNAL_FIELD (last_selected_window) = val;
 920 }
 921 BUFFER_INLINE void
 922 bset_local_var_alist (struct buffer *b, Lisp_Object val)
 923 {
 924   b->INTERNAL_FIELD (local_var_alist) = val;
 925 }
 926 BUFFER_INLINE void
 927 bset_mark_active (struct buffer *b, Lisp_Object val)
 928 {
 929   b->INTERNAL_FIELD (mark_active) = val;
 930 }
 931 BUFFER_INLINE void
 932 bset_point_before_scroll (struct buffer *b, Lisp_Object val)
 933 {
 934   b->INTERNAL_FIELD (point_before_scroll) = val;
 935 }
 936 BUFFER_INLINE void
 937 bset_read_only (struct buffer *b, Lisp_Object val)
 938 {
 939   b->INTERNAL_FIELD (read_only) = val;
 940 }
 941 BUFFER_INLINE void
 942 bset_truncate_lines (struct buffer *b, Lisp_Object val)
 943 {
 944   b->INTERNAL_FIELD (truncate_lines) = val;
 945 }
 946 BUFFER_INLINE void
 947 bset_undo_list (struct buffer *b, Lisp_Object val)
 948 {
 949   b->INTERNAL_FIELD (undo_list) = val;
 950 }
 951 BUFFER_INLINE void
 952 bset_upcase_table (struct buffer *b, Lisp_Object val)
 953 {
 954   b->INTERNAL_FIELD (upcase_table) = val;
 955 }
 956 BUFFER_INLINE void
 957 bset_width_table (struct buffer *b, Lisp_Object val)
 958 {
 959   b->INTERNAL_FIELD (width_table) = val;
 960 }
 961
 962 \f
 963 /* Chain of all buffers, including killed ones.  */
 964
 965 extern struct buffer *all_buffers;
 966
 967 /* Used to iterate over the chain above.  */
 968
 969 #define FOR_EACH_BUFFER(b) \
 970   for ((b) = all_buffers; (b); (b) = (b)->header.next.buffer)
 971
 972 /* This points to the current buffer.  */
 973
 974 extern struct buffer *current_buffer;
 975
 976 /* This structure holds the default values of the buffer-local variables
 977    that have special slots in each buffer.
 978    The default value occupies the same slot in this structure
 979    as an individual buffer's value occupies in that buffer.
 980    Setting the default value also goes through the alist of buffers
 981    and stores into each buffer that does not say it has a local value.  */
 982
 983 extern struct buffer buffer_defaults;
 984
 985 /* This structure marks which slots in a buffer have corresponding
 986    default values in buffer_defaults.
 987    Each such slot has a nonzero value in this structure.
 988    The value has only one nonzero bit.
 989
 990    When a buffer has its own local value for a slot,
 991    the entry for that slot (found in the same slot in this structure)
 992    is turned on in the buffer's local_flags array.
 993
 994    If a slot in this structure is zero, then even though there may
 995    be a Lisp-level local variable for the slot, it has no default value,
 996    and the corresponding slot in buffer_defaults is not used.  */
 997
 998
 999 extern struct buffer buffer_local_flags;
1000
1001 /* For each buffer slot, this points to the Lisp symbol name
1002    for that slot in the current buffer.  It is 0 for slots
1003    that don't have such names.  */
1004
1005 extern struct buffer buffer_local_symbols;
1006 \f
1007 extern void delete_all_overlays (struct buffer *);
1008 extern void reset_buffer (struct buffer *);
1009 extern int compact_buffer (struct buffer *);
1010 extern void evaporate_overlays (ptrdiff_t);
1011 extern ptrdiff_t overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr,
1012                               ptrdiff_t *len_ptr, ptrdiff_t *next_ptr,
1013                               ptrdiff_t *prev_ptr, int change_req);
1014 extern ptrdiff_t sort_overlays (Lisp_Object *, ptrdiff_t, struct window *);
1015 extern void recenter_overlay_lists (struct buffer *, ptrdiff_t);
1016 extern ptrdiff_t overlay_strings (ptrdiff_t, struct window *, unsigned char **);
1017 extern void validate_region (Lisp_Object *, Lisp_Object *);
1018 extern void set_buffer_internal (struct buffer *);
1019 extern void set_buffer_internal_1 (struct buffer *);
1020 extern void set_buffer_temp (struct buffer *);
1021 extern Lisp_Object buffer_local_value_1 (Lisp_Object, Lisp_Object);
1022 extern void record_buffer (Lisp_Object);
1023 extern _Noreturn void buffer_slot_type_mismatch (Lisp_Object, int);
1024 extern void fix_overlays_before (struct buffer *, ptrdiff_t, ptrdiff_t);
1025 extern void mmap_set_vars (int);
1026
1027 /* Get overlays at POSN into array OVERLAYS with NOVERLAYS elements.
1028    If NEXTP is non-NULL, return next overlay there.
1029    See overlay_at arg CHANGE_REQ for meaning of CHRQ arg.  */
1030
1031 #define GET_OVERLAYS_AT(posn, overlays, noverlays, nextp, chrq)         \
1032   do {                                                                  \
1033     ptrdiff_t maxlen = 40;                                              \
1034     overlays = alloca (maxlen * sizeof *overlays);                      \
1035     noverlays = overlays_at (posn, 0, &overlays, &maxlen,               \
1036                              nextp, NULL, chrq);                        \
1037     if (noverlays > maxlen)                                             \
1038       {                                                                 \
1039         maxlen = noverlays;                                             \
1040         overlays = alloca (maxlen * sizeof *overlays);                  \
1041         noverlays = overlays_at (posn, 0, &overlays, &maxlen,           \
1042                                  nextp, NULL, chrq);                    \
1043       }                                                                 \
1044   } while (0)
1045
1046 extern Lisp_Object Qbefore_change_functions;
1047 extern Lisp_Object Qafter_change_functions;
1048 extern Lisp_Object Qfirst_change_hook;
1049
1050 /* Get text properties of B.  */
1051
1052 BUFFER_INLINE INTERVAL
1053 buffer_intervals (struct buffer *b)
1054 {
1055   eassert (b->text != NULL);
1056   return b->text->intervals;
1057 }
1058
1059 /* Set text properties of B to I.  */
1060
1061 BUFFER_INLINE void
1062 set_buffer_intervals (struct buffer *b, INTERVAL i)
1063 {
1064   eassert (b->text != NULL);
1065   b->text->intervals = i;
1066 }
1067
1068 /* Non-zero if current buffer has overlays.  */
1069
1070 BUFFER_INLINE int
1071 buffer_has_overlays (void)
1072 {
1073   return current_buffer->overlays_before || current_buffer->overlays_after;
1074 }
1075
1076 /* Return character code of multi-byte form at byte position POS.  If POS
1077    doesn't point the head of valid multi-byte form, only the byte at
1078    POS is returned.  No range checking.
1079
1080    WARNING: The character returned by this macro could be "unified"
1081    inside STRING_CHAR, if the original character in the buffer belongs
1082    to one of the Private Use Areas (PUAs) of codepoints that Emacs
1083    uses to support non-unified CJK characters.  If that happens,
1084    CHAR_BYTES will return a value that is different from the length of
1085    the original multibyte sequence stored in the buffer.  Therefore,
1086    do _not_ use FETCH_MULTIBYTE_CHAR if you need to advance through
1087    the buffer to the next character after fetching this one.  Instead,
1088    use either FETCH_CHAR_ADVANCE or STRING_CHAR_AND_LENGTH.  */
1089
1090 BUFFER_INLINE int
1091 FETCH_MULTIBYTE_CHAR (ptrdiff_t pos)
1092 {
1093   unsigned char *p = ((pos >= GPT_BYTE ? GAP_SIZE : 0)
1094                       + pos + BEG_ADDR - BEG_BYTE);
1095   return STRING_CHAR (p);
1096 }
1097
1098 /* Return character code of multi-byte form at byte position POS in BUF.
1099    If POS doesn't point the head of valid multi-byte form, only the byte at
1100    POS is returned.  No range checking.  */
1101
1102 BUFFER_INLINE int
1103 BUF_FETCH_MULTIBYTE_CHAR (struct buffer *buf, ptrdiff_t pos)
1104 {
1105   unsigned char *p
1106     = ((pos >= BUF_GPT_BYTE (buf) ? BUF_GAP_SIZE (buf) : 0)
1107        + pos + BUF_BEG_ADDR (buf) - BEG_BYTE);
1108   return STRING_CHAR (p);
1109 }
1110 \f
1111 /* Overlays */
1112
1113 /* Return the marker that stands for where OV starts in the buffer.  */
1114
1115 #define OVERLAY_START(OV) XOVERLAY (OV)->start
1116
1117 /* Return the marker that stands for where OV ends in the buffer.  */
1118
1119 #define OVERLAY_END(OV) XOVERLAY (OV)->end
1120
1121 /* Return the plist of overlay OV.  */
1122
1123 #define OVERLAY_PLIST(OV) XOVERLAY (OV)->plist
1124
1125 /* Return the actual buffer position for the marker P.
1126    We assume you know which buffer it's pointing into.  */
1127
1128 #define OVERLAY_POSITION(P) \
1129  (MARKERP (P) ? marker_position (P) : (abort (), 0))
1130
1131 \f
1132 /***********************************************************************
1133                         Buffer-local Variables
1134  ***********************************************************************/
1135
1136 /* Number of per-buffer variables used.  */
1137
1138 extern int last_per_buffer_idx;
1139
1140 /* Return the offset in bytes of member VAR of struct buffer
1141    from the start of a buffer structure.  */
1142
1143 #define PER_BUFFER_VAR_OFFSET(VAR) \
1144   offsetof (struct buffer, INTERNAL_FIELD (VAR))
1145
1146 /* Used to iterate over normal Lisp_Object fields of struct buffer (all
1147    Lisp_Objects except undo_list).  If you add, remove, or reorder
1148    Lisp_Objects in a struct buffer, make sure that this is still correct.  */
1149
1150 #define FOR_EACH_PER_BUFFER_OBJECT_AT(offset)                            \
1151   for (offset = PER_BUFFER_VAR_OFFSET (name);                            \
1152        offset <= PER_BUFFER_VAR_OFFSET (cursor_in_non_selected_windows); \
1153        offset += word_size)
1154
1155 /* Return the index of buffer-local variable VAR.  Each per-buffer
1156    variable has an index > 0 associated with it, except when it always
1157    has buffer-local values, in which case the index is -1.  If this is
1158    0, this is a bug and means that the slot of VAR in
1159    buffer_local_flags wasn't initialized.  */
1160
1161 #define PER_BUFFER_VAR_IDX(VAR) \
1162     PER_BUFFER_IDX (PER_BUFFER_VAR_OFFSET (VAR))
1163
1164 /* Value is non-zero if the variable with index IDX has a local value
1165    in buffer B.  */
1166
1167 #define PER_BUFFER_VALUE_P(B, IDX)              \
1168     (((IDX) < 0 || IDX >= last_per_buffer_idx)  \
1169      ? (abort (), 0)                            \
1170      : ((B)->local_flags[IDX] != 0))
1171
1172 /* Set whether per-buffer variable with index IDX has a buffer-local
1173    value in buffer B.  VAL zero means it hasn't.  */
1174
1175 #define SET_PER_BUFFER_VALUE_P(B, IDX, VAL)     \
1176      do {                                               \
1177        if ((IDX) < 0 || (IDX) >= last_per_buffer_idx)   \
1178          abort ();                                      \
1179        (B)->local_flags[IDX] = (VAL);                   \
1180      } while (0)
1181
1182 /* Return the index value of the per-buffer variable at offset OFFSET
1183    in the buffer structure.
1184
1185    If the slot OFFSET has a corresponding default value in
1186    buffer_defaults, the index value is positive and has only one
1187    nonzero bit.  When a buffer has its own local value for a slot, the
1188    bit for that slot (found in the same slot in this structure) is
1189    turned on in the buffer's local_flags array.
1190
1191    If the index value is -1, even though there may be a
1192    DEFVAR_PER_BUFFER for the slot, there is no default value for it;
1193    and the corresponding slot in buffer_defaults is not used.
1194
1195    If the index value is -2, then there is no DEFVAR_PER_BUFFER for
1196    the slot, but there is a default value which is copied into each
1197    new buffer.
1198
1199    If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
1200    zero, that is a bug */
1201
1202
1203 #define PER_BUFFER_IDX(OFFSET) \
1204       XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
1205
1206 /* Functions to get and set default value of the per-buffer
1207    variable at offset OFFSET in the buffer structure.  */
1208
1209 BUFFER_INLINE Lisp_Object
1210 per_buffer_default (int offset)
1211 {
1212   return *(Lisp_Object *)(offset + (char *) &buffer_defaults);
1213 }
1214
1215 BUFFER_INLINE void
1216 set_per_buffer_default (int offset, Lisp_Object value)
1217 {
1218   *(Lisp_Object *)(offset + (char *) &buffer_defaults) = value;
1219 }
1220
1221 /* Functions to get and set buffer-local value of the per-buffer
1222    variable at offset OFFSET in the buffer structure.  */
1223
1224 BUFFER_INLINE Lisp_Object
1225 per_buffer_value (struct buffer *b, int offset)
1226 {
1227   return *(Lisp_Object *)(offset + (char *) b);
1228 }
1229
1230 BUFFER_INLINE void
1231 set_per_buffer_value (struct buffer *b, int offset, Lisp_Object value)
1232 {
1233   *(Lisp_Object *)(offset + (char *) b) = value;
1234 }
1235
1236 /* Downcase a character C, or make no change if that cannot be done.  */
1237 BUFFER_INLINE int
1238 downcase (int c)
1239 {
1240   Lisp_Object downcase_table = BVAR (current_buffer, downcase_table);
1241   Lisp_Object down = CHAR_TABLE_REF (downcase_table, c);
1242   return NATNUMP (down) ? XFASTINT (down) : c;
1243 }
1244
1245 /* 1 if C is upper case.  */
1246 BUFFER_INLINE int uppercasep (int c) { return downcase (c) != c; }
1247
1248 /* Upcase a character C known to be not upper case.  */
1249 BUFFER_INLINE int
1250 upcase1 (int c)
1251 {
1252   Lisp_Object upcase_table = BVAR (current_buffer, upcase_table);
1253   Lisp_Object up = CHAR_TABLE_REF (upcase_table, c);
1254   return NATNUMP (up) ? XFASTINT (up) : c;
1255 }
1256
1257 /* 1 if C is lower case.  */
1258 BUFFER_INLINE int lowercasep (int c)
1259 { return !uppercasep (c) && upcase1 (c) != c; }
1260
1261 /* Upcase a character C, or make no change if that cannot be done.  */
1262 BUFFER_INLINE int upcase (int c) { return uppercasep (c) ? c : upcase1 (c); }
1263
1264 INLINE_HEADER_END