src/buffer.h

   1 /* Header file for the buffer manipulation primitives.
   2
   3 Copyright (C) 1985-1986, 1993-1995, 1997-2011
   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
  22 /* Accessing the parameters of the current buffer.  */
  23
  24 /* These macros come in pairs, one for the char position
  25    and one for the byte position.  */
  26
  27 /* Position of beginning of buffer.  */
  28 #define BEG (1)
  29 #define BEG_BYTE (BEG)
  30
  31 /* Position of beginning of accessible range of buffer.  */
  32 #define BEGV (current_buffer->begv)
  33 #define BEGV_BYTE (current_buffer->begv_byte)
  34
  35 /* Position of point in buffer.  The "+ 0" makes this
  36    not an l-value, so you can't assign to it.  Use SET_PT instead.  */
  37 #define PT (current_buffer->pt + 0)
  38 #define PT_BYTE (current_buffer->pt_byte + 0)
  39
  40 /* Position of gap in buffer.  */
  41 #define GPT (current_buffer->text->gpt)
  42 #define GPT_BYTE (current_buffer->text->gpt_byte)
  43
  44 /* Position of end of accessible range of buffer.  */
  45 #define ZV (current_buffer->zv)
  46 #define ZV_BYTE (current_buffer->zv_byte)
  47
  48 /* Position of end of buffer.  */
  49 #define Z (current_buffer->text->z)
  50 #define Z_BYTE (current_buffer->text->z_byte)
  51
  52 /* Macros for the addresses of places in the buffer.  */
  53
  54 /* Address of beginning of buffer.  */
  55 #define BEG_ADDR (current_buffer->text->beg)
  56
  57 /* Address of beginning of accessible range of buffer.  */
  58 #define BEGV_ADDR (BYTE_POS_ADDR (current_buffer->begv_byte))
  59
  60 /* Address of point in buffer.  */
  61 #define PT_ADDR (BYTE_POS_ADDR (current_buffer->pt_byte))
  62
  63 /* Address of beginning of gap in buffer.  */
  64 #define GPT_ADDR (current_buffer->text->beg + current_buffer->text->gpt_byte - BEG_BYTE)
  65
  66 /* Address of end of gap in buffer.  */
  67 #define GAP_END_ADDR (current_buffer->text->beg + current_buffer->text->gpt_byte + current_buffer->text->gap_size - BEG_BYTE)
  68
  69 /* Address of end of accessible range of buffer.  */
  70 #define ZV_ADDR (BYTE_POS_ADDR (current_buffer->zv_byte))
  71
  72 /* Address of end of buffer.  */
  73 #define Z_ADDR (current_buffer->text->beg + current_buffer->text->gap_size + current_buffer->text->z_byte - BEG_BYTE)
  74
  75 /* Size of gap.  */
  76 #define GAP_SIZE (current_buffer->text->gap_size)
  77
  78 /* Is the current buffer narrowed?  */
  79 #define NARROWED        ((BEGV != BEG) || (ZV != Z))
  80
  81 /* Modification count.  */
  82 #define MODIFF (current_buffer->text->modiff)
  83
  84 /* Character modification count.  */
  85 #define CHARS_MODIFF (current_buffer->text->chars_modiff)
  86
  87 /* Overlay modification count.  */
  88 #define OVERLAY_MODIFF (current_buffer->text->overlay_modiff)
  89
  90 /* Modification count as of last visit or save.  */
  91 #define SAVE_MODIFF (current_buffer->text->save_modiff)
  92
  93 /* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return
  94    the max (resp. min) p such that
  95
  96    BYTE_POS_ADDR (p) - BYTE_POS_ADDR (n) == p - n       */
  97
  98 #define BUFFER_CEILING_OF(BYTEPOS) \
  99   (((BYTEPOS) < GPT_BYTE && GPT < ZV ? GPT_BYTE : ZV_BYTE) - 1)
 100 #define BUFFER_FLOOR_OF(BYTEPOS) \
 101   (BEGV <= GPT && GPT_BYTE <= (BYTEPOS) ? GPT_BYTE : BEGV_BYTE)
 102 \f
 103 /* Similar macros to operate on a specified buffer.
 104    Note that many of these evaluate the buffer argument more than once.  */
 105
 106 /* Position of beginning of buffer.  */
 107 #define BUF_BEG(buf) (BEG)
 108 #define BUF_BEG_BYTE(buf) (BEG_BYTE)
 109
 110 /* The BUF_BEGV[_BYTE], BUF_ZV[_BYTE], and BUF_PT[_BYTE] macros cannot
 111    be used for assignment; use SET_BUF_* macros below for that.  */
 112
 113 /* Position of beginning of accessible range of buffer.  */
 114 #define BUF_BEGV(buf)                                   \
 115    (buf == current_buffer ? BEGV                        \
 116     : NILP (BVAR (buf, begv_marker)) ? buf->begv        \
 117     : marker_position (BVAR (buf, begv_marker)))
 118
 119 #define BUF_BEGV_BYTE(buf)                              \
 120    (buf == current_buffer ? BEGV_BYTE                   \
 121     : NILP (BVAR (buf, begv_marker)) ? buf->begv_byte   \
 122     : marker_byte_position (BVAR (buf, begv_marker)))
 123
 124 /* Position of point in buffer.  */
 125 #define BUF_PT(buf)                                     \
 126    (buf == current_buffer ? PT                          \
 127     : NILP (BVAR (buf, pt_marker)) ? buf->pt            \
 128     : marker_position (BVAR (buf, pt_marker)))
 129
 130 #define BUF_PT_BYTE(buf)                                \
 131    (buf == current_buffer ? PT_BYTE                     \
 132     : NILP (BVAR (buf, pt_marker)) ? buf->pt_byte       \
 133     : marker_byte_position (BVAR (buf, pt_marker)))
 134
 135 /* Position of end of accessible range of buffer.  */
 136 #define BUF_ZV(buf)                                     \
 137    (buf == current_buffer ? ZV                          \
 138     : NILP (BVAR (buf, zv_marker)) ? buf->zv            \
 139     : marker_position (BVAR (buf, zv_marker)))
 140
 141 #define BUF_ZV_BYTE(buf)                                \
 142    (buf == current_buffer ? ZV_BYTE                     \
 143     : NILP (BVAR (buf, zv_marker)) ? buf->zv_byte       \
 144     : marker_byte_position (BVAR (buf, zv_marker)))
 145
 146 /* Position of gap in buffer.  */
 147 #define BUF_GPT(buf) ((buf)->text->gpt)
 148 #define BUF_GPT_BYTE(buf) ((buf)->text->gpt_byte)
 149
 150 /* Position of end of buffer.  */
 151 #define BUF_Z(buf) ((buf)->text->z)
 152 #define BUF_Z_BYTE(buf) ((buf)->text->z_byte)
 153
 154 /* Address of beginning of buffer.  */
 155 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
 156
 157 /* Address of beginning of gap of buffer.  */
 158 #define BUF_GPT_ADDR(buf) ((buf)->text->beg + (buf)->text->gpt_byte - BEG_BYTE)
 159
 160 /* Address of end of buffer.  */
 161 #define BUF_Z_ADDR(buf) ((buf)->text->beg + (buf)->text->gap_size + (buf)->text->z_byte - BEG_BYTE)
 162
 163 /* Address of end of gap in buffer.  */
 164 #define BUF_GAP_END_ADDR(buf) ((buf)->text->beg + (buf)->text->gpt_byte + (buf)->text->gap_size - BEG_BYTE)
 165
 166 /* Size of gap.  */
 167 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size)
 168
 169 /* Is this buffer narrowed?  */
 170 #define BUF_NARROWED(buf) ((BUF_BEGV (buf) != BUF_BEG (buf)) \
 171                            || (BUF_ZV (buf) != BUF_Z (buf)))
 172
 173 /* Modification count.  */
 174 #define BUF_MODIFF(buf) ((buf)->text->modiff)
 175
 176 /* Character modification count.  */
 177 #define BUF_CHARS_MODIFF(buf) ((buf)->text->chars_modiff)
 178
 179 /* Modification count as of last visit or save.  */
 180 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
 181
 182 /* Overlay modification count.  */
 183 #define BUF_OVERLAY_MODIFF(buf) ((buf)->text->overlay_modiff)
 184
 185 /* Modification count as of last auto-save.  */
 186 /* FIXME: should we move this into ->text->auto_save_modiff?  */
 187 #define BUF_AUTOSAVE_MODIFF(buf) ((buf)->auto_save_modified)
 188
 189 /* Interval tree of buffer.  */
 190 #define BUF_INTERVALS(buf) ((buf)->text->intervals)
 191
 192 /* Marker chain of buffer.  */
 193 #define BUF_MARKERS(buf) ((buf)->text->markers)
 194
 195 #define BUF_UNCHANGED_MODIFIED(buf) \
 196   ((buf)->text->unchanged_modified)
 197
 198 #define BUF_OVERLAY_UNCHANGED_MODIFIED(buf) \
 199   ((buf)->text->overlay_unchanged_modified)
 200 #define BUF_BEG_UNCHANGED(buf) ((buf)->text->beg_unchanged)
 201 #define BUF_END_UNCHANGED(buf) ((buf)->text->end_unchanged)
 202
 203 #define UNCHANGED_MODIFIED \
 204   BUF_UNCHANGED_MODIFIED (current_buffer)
 205 #define OVERLAY_UNCHANGED_MODIFIED \
 206   BUF_OVERLAY_UNCHANGED_MODIFIED (current_buffer)
 207 #define BEG_UNCHANGED BUF_BEG_UNCHANGED (current_buffer)
 208 #define END_UNCHANGED BUF_END_UNCHANGED (current_buffer)
 209
 210 /* Compute how many characters at the top and bottom of BUF are
 211    unchanged when the range START..END is modified.  This computation
 212    must be done each time BUF is modified.  */
 213
 214 #define BUF_COMPUTE_UNCHANGED(buf, start, end)                          \
 215   do                                                                    \
 216     {                                                                   \
 217       if (BUF_UNCHANGED_MODIFIED (buf) == BUF_MODIFF (buf)              \
 218           && (BUF_OVERLAY_UNCHANGED_MODIFIED (buf)                      \
 219               == BUF_OVERLAY_MODIFF (buf)))                             \
 220         {                                                               \
 221           BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf);            \
 222           BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end);                \
 223         }                                                               \
 224       else                                                              \
 225         {                                                               \
 226           if (BUF_Z (buf) - (end) < BUF_END_UNCHANGED (buf))            \
 227             BUF_END_UNCHANGED (buf) = BUF_Z (buf) - (end);              \
 228           if ((start) - BUF_BEG (buf) < BUF_BEG_UNCHANGED (buf))        \
 229             BUF_BEG_UNCHANGED (buf) = (start) - BUF_BEG (buf);          \
 230         }                                                               \
 231     }                                                                   \
 232   while (0)
 233
 234 \f
 235 /* Macros to set PT in the current buffer, or another buffer.  */
 236
 237 #define SET_PT(position) (set_point (position))
 238 #define TEMP_SET_PT(position) (temp_set_point (current_buffer, (position)))
 239
 240 #define SET_PT_BOTH(position, byte) (set_point_both (position, byte))
 241 #define TEMP_SET_PT_BOTH(position, byte) \
 242   (temp_set_point_both (current_buffer, (position), (byte)))
 243
 244 #define BUF_TEMP_SET_PT(buffer, position) \
 245   (temp_set_point ((buffer), (position)))
 246
 247 extern void set_point (EMACS_INT);
 248 extern void temp_set_point (struct buffer *, EMACS_INT);
 249 extern void set_point_both (EMACS_INT, EMACS_INT);
 250 extern void temp_set_point_both (struct buffer *,
 251                                  EMACS_INT, EMACS_INT);
 252 extern void enlarge_buffer_text (struct buffer *, EMACS_INT);
 253
 254 \f
 255 /* Macros for setting the BEGV, ZV or PT of a given buffer.
 256
 257    The ..._BOTH macros take both a charpos and a bytepos,
 258    which must correspond to each other.
 259
 260    The macros without ..._BOTH take just a charpos,
 261    and compute the bytepos from it.  */
 262
 263 #define SET_BUF_BEGV(buf, charpos)                               \
 264   ((buf)->begv_byte = buf_charpos_to_bytepos ((buf), (charpos)), \
 265    (buf)->begv = (charpos))
 266
 267 #define SET_BUF_ZV(buf, charpos)                                \
 268   ((buf)->zv_byte = buf_charpos_to_bytepos ((buf), (charpos)),  \
 269    (buf)->zv = (charpos))
 270
 271 #define SET_BUF_BEGV_BOTH(buf, charpos, byte)           \
 272   ((buf)->begv = (charpos),                             \
 273    (buf)->begv_byte = (byte))
 274
 275 #define SET_BUF_ZV_BOTH(buf, charpos, byte)             \
 276   ((buf)->zv = (charpos),                               \
 277    (buf)->zv_byte = (byte))
 278
 279 #define SET_BUF_PT_BOTH(buf, charpos, byte)             \
 280   ((buf)->pt = (charpos),                               \
 281    (buf)->pt_byte = (byte))
 282 \f
 283 /* Macros to access a character or byte in the current buffer,
 284    or convert between a byte position and an address.
 285    These macros do not check that the position is in range.  */
 286
 287 /* Access a Lisp position value in POS,
 288    and store the charpos in CHARPOS and the bytepos in BYTEPOS.  */
 289
 290 #define DECODE_POSITION(charpos, bytepos, pos)                  \
 291 do                                                              \
 292   {                                                             \
 293     Lisp_Object __pos = (pos);                                  \
 294     if (NUMBERP (__pos))                                        \
 295       {                                                         \
 296         charpos = __pos;                                        \
 297         bytepos = buf_charpos_to_bytepos (current_buffer, __pos);  \
 298       }                                                         \
 299     else if (MARKERP (__pos))                                   \
 300       {                                                         \
 301         charpos = marker_position (__pos);                      \
 302         bytepos = marker_byte_position (__pos);                 \
 303       }                                                         \
 304     else                                                        \
 305       wrong_type_argument (Qinteger_or_marker_p, __pos);        \
 306   }                                                             \
 307 while (0)
 308
 309 /* Return the address of byte position N in current buffer.  */
 310
 311 #define BYTE_POS_ADDR(n) \
 312   (((n) >= GPT_BYTE ? GAP_SIZE : 0) + (n) + BEG_ADDR - BEG_BYTE)
 313
 314 /* Return the address of char position N.  */
 315
 316 #define CHAR_POS_ADDR(n)                        \
 317   (((n) >= GPT ? GAP_SIZE : 0)                  \
 318    + buf_charpos_to_bytepos (current_buffer, n) \
 319    + BEG_ADDR - BEG_BYTE)
 320
 321 /* Convert a character position to a byte position.  */
 322
 323 #define CHAR_TO_BYTE(charpos)                   \
 324   (buf_charpos_to_bytepos (current_buffer, charpos))
 325
 326 /* Convert a byte position to a character position.  */
 327
 328 #define BYTE_TO_CHAR(bytepos)                   \
 329   (buf_bytepos_to_charpos (current_buffer, bytepos))
 330
 331 /* Convert PTR, the address of a byte in the buffer, into a byte position.  */
 332
 333 #define PTR_BYTE_POS(ptr) \
 334 ((ptr) - (current_buffer)->text->beg                                        \
 335  - (ptr - (current_buffer)->text->beg <= (unsigned) (GPT_BYTE - BEG_BYTE) ? 0 : GAP_SIZE) \
 336  + BEG_BYTE)
 337
 338 /* Return character at byte position POS.  */
 339
 340 #define FETCH_CHAR(pos)                                 \
 341   (!NILP (BVAR (current_buffer, enable_multibyte_characters))   \
 342    ? FETCH_MULTIBYTE_CHAR ((pos))                       \
 343    : FETCH_BYTE ((pos)))
 344
 345 /* Return the byte at byte position N.  */
 346
 347 #define FETCH_BYTE(n) *(BYTE_POS_ADDR ((n)))
 348
 349 /* Variables used locally in FETCH_MULTIBYTE_CHAR.  */
 350 extern unsigned char *_fetch_multibyte_char_p;
 351
 352 /* Return character code of multi-byte form at byte position POS.  If POS
 353    doesn't point the head of valid multi-byte form, only the byte at
 354    POS is returned.  No range checking.  */
 355
 356 #define FETCH_MULTIBYTE_CHAR(pos)                                       \
 357   (_fetch_multibyte_char_p = (((pos) >= GPT_BYTE ? GAP_SIZE : 0)        \
 358                                + (pos) + BEG_ADDR - BEG_BYTE),          \
 359    STRING_CHAR (_fetch_multibyte_char_p))
 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 <= (unsigned) (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
 410 /* Return character code of multi-byte form at byte position POS in BUF.
 411    If POS doesn't point the head of valid multi-byte form, only the byte at
 412    POS is returned.  No range checking.  */
 413
 414 #define BUF_FETCH_MULTIBYTE_CHAR(buf, pos)                              \
 415   (_fetch_multibyte_char_p                                              \
 416      = (((pos) >= BUF_GPT_BYTE (buf) ? BUF_GAP_SIZE (buf) : 0)          \
 417         + (pos) + BUF_BEG_ADDR (buf) - BEG_BYTE),                       \
 418    STRING_CHAR (_fetch_multibyte_char_p))
 419 \f
 420 /* Define the actual buffer data structures.  */
 421
 422 /* This data structure describes the actual text contents of a buffer.
 423    It is shared between indirect buffers and their base buffer.  */
 424
 425 struct buffer_text
 426   {
 427     /* Actual address of buffer contents.  If REL_ALLOC is defined,
 428        this address might change when blocks are relocated which can
 429        e.g. happen when malloc is called.  So, don't pass a pointer
 430        into a buffer's text to functions that malloc.  */
 431     unsigned char *beg;
 432
 433     EMACS_INT gpt;              /* Char pos of gap in buffer.  */
 434     EMACS_INT z;                /* Char pos of end of buffer.  */
 435     EMACS_INT gpt_byte;         /* Byte pos of gap in buffer.  */
 436     EMACS_INT z_byte;           /* Byte pos of end of buffer.  */
 437     EMACS_INT gap_size;         /* Size of buffer's gap.  */
 438     int modiff;                 /* This counts buffer-modification events
 439                                    for this buffer.  It is incremented for
 440                                    each such event, and never otherwise
 441                                    changed.  */
 442     int chars_modiff;           /* This is modified with character change
 443                                    events for this buffer.  It is set to
 444                                    modiff for each such event, and never
 445                                    otherwise changed.  */
 446     int save_modiff;            /* Previous value of modiff, as of last
 447                                    time buffer visited or saved a file.  */
 448
 449     int overlay_modiff;         /* Counts modifications to overlays.  */
 450
 451     /* Minimum value of GPT - BEG since last redisplay that finished.  */
 452     EMACS_INT beg_unchanged;
 453
 454     /* Minimum value of Z - GPT since last redisplay that finished.  */
 455     EMACS_INT end_unchanged;
 456
 457     /* MODIFF as of last redisplay that finished; if it matches MODIFF,
 458        beg_unchanged and end_unchanged contain no useful information.  */
 459     int unchanged_modified;
 460
 461     /* BUF_OVERLAY_MODIFF of current buffer, as of last redisplay that
 462        finished; if it matches BUF_OVERLAY_MODIFF, beg_unchanged and
 463        end_unchanged contain no useful information.  */
 464     int overlay_unchanged_modified;
 465
 466     /* Properties of this buffer's text.  */
 467     INTERVAL intervals;
 468
 469     /* The markers that refer to this buffer.
 470        This is actually a single marker ---
 471        successive elements in its marker `chain'
 472        are the other markers referring to this buffer.
 473        This is a singly linked unordered list, which means that it's
 474        very cheap to add a marker to the list and it's also very cheap
 475        to move a marker within a buffer.  */
 476     struct Lisp_Marker *markers;
 477
 478     /* Usually 0.  Temporarily set to 1 in decode_coding_gap to
 479        prevent Fgarbage_collect from shrinking the gap and losing
 480        not-yet-decoded bytes.  */
 481     int inhibit_shrinking;
 482   };
 483
 484 /* Lisp fields in struct buffer are hidden from most code and accessed
 485    via the BVAR macro, below.  Only select pieces of code, like the GC,
 486    are allowed to use BUFFER_INTERNAL_FIELD.  */
 487 #define BUFFER_INTERNAL_FIELD(field) field ## _
 488
 489 /* Most code should use this macro to access Lisp fields in struct
 490    buffer.  */
 491 #define BVAR(buf, field) ((buf)->BUFFER_INTERNAL_FIELD (field))
 492
 493 /* This is the structure that the buffer Lisp object points to.  */
 494
 495 struct buffer
 496 {
 497   /* Everything before the `name' slot must be of a non-Lisp_Object type,
 498      and every slot after `name' must be a Lisp_Object.
 499
 500      Check out mark_buffer (alloc.c) to see why.  */
 501
 502   /* HEADER.NEXT is the next buffer, in chain of all buffers,
 503      including killed buffers.
 504      This chain is used only for garbage collection, in order to
 505      collect killed buffers properly.
 506      Note that vectors and most pseudovectors are all on one chain,
 507      but buffers are on a separate chain of their own.  */
 508   struct vectorlike_header header;
 509
 510   /* This structure holds the coordinates of the buffer contents
 511      in ordinary buffers.  In indirect buffers, this is not used.  */
 512   struct buffer_text own_text;
 513
 514   /* This points to the `struct buffer_text' that used for this buffer.
 515      In an ordinary buffer, this is the own_text field above.
 516      In an indirect buffer, this is the own_text field of another buffer.  */
 517   struct buffer_text *text;
 518
 519   /* Char position of point in buffer.  */
 520   EMACS_INT pt;
 521   /* Byte position of point in buffer.  */
 522   EMACS_INT pt_byte;
 523   /* Char position of beginning of accessible range.  */
 524   EMACS_INT begv;
 525   /* Byte position of beginning of accessible range.  */
 526   EMACS_INT begv_byte;
 527   /* Char position of end of accessible range.  */
 528   EMACS_INT zv;
 529   /* Byte position of end of accessible range.  */
 530   EMACS_INT zv_byte;
 531
 532   /* In an indirect buffer, this points to the base buffer.
 533      In an ordinary buffer, it is 0.  */
 534   struct buffer *base_buffer;
 535
 536   /* A non-zero value in slot IDX means that per-buffer variable
 537      with index IDX has a local value in this buffer.  The index IDX
 538      for a buffer-local variable is stored in that variable's slot
 539      in buffer_local_flags as a Lisp integer.  If the index is -1,
 540      this means the variable is always local in all buffers.  */
 541 #define MAX_PER_BUFFER_VARS 50
 542   char local_flags[MAX_PER_BUFFER_VARS];
 543
 544   /* Set to the modtime of the visited file when read or written.
 545      -1 means visited file was nonexistent.
 546      0 means visited file modtime unknown; in no case complain
 547      about any mismatch on next save attempt.  */
 548   int modtime;
 549   /* Size of the file when modtime was set.  This is used to detect the
 550      case where the file grew while we were reading it, so the modtime
 551      is still the same (since it's rounded up to seconds) but we're actually
 552      not up-to-date.  -1 means the size is unknown.  Only meaningful if
 553      modtime is actually set.  */
 554   EMACS_INT modtime_size;
 555   /* The value of text->modiff at the last auto-save.  */
 556   int auto_save_modified;
 557   /* The value of text->modiff at the last display error.
 558      Redisplay of this buffer is inhibited until it changes again.  */
 559   int display_error_modiff;
 560   /* The time at which we detected a failure to auto-save,
 561      Or -1 if we didn't have a failure.  */
 562   int auto_save_failure_time;
 563   /* Position in buffer at which display started
 564      the last time this buffer was displayed.  */
 565   EMACS_INT last_window_start;
 566
 567   /* Set nonzero whenever the narrowing is changed in this buffer.  */
 568   int clip_changed;
 569
 570   /* If the long line scan cache is enabled (i.e. the buffer-local
 571      variable cache-long-line-scans is non-nil), newline_cache
 572      points to the newline cache, and width_run_cache points to the
 573      width run cache.
 574
 575      The newline cache records which stretches of the buffer are
 576      known *not* to contain newlines, so that they can be skipped
 577      quickly when we search for newlines.
 578
 579      The width run cache records which stretches of the buffer are
 580      known to contain characters whose widths are all the same.  If
 581      the width run cache maps a character to a value > 0, that value is
 582      the character's width; if it maps a character to zero, we don't
 583      know what its width is.  This allows compute_motion to process
 584      such regions very quickly, using algebra instead of inspecting
 585      each character.   See also width_table, below.  */
 586   struct region_cache *newline_cache;
 587   struct region_cache *width_run_cache;
 588
 589   /* Non-zero means don't use redisplay optimizations for
 590      displaying this buffer.  */
 591   unsigned prevent_redisplay_optimizations_p : 1;
 592
 593   /* List of overlays that end at or before the current center,
 594      in order of end-position.  */
 595   struct Lisp_Overlay *overlays_before;
 596
 597   /* List of overlays that end after  the current center,
 598      in order of start-position.  */
 599   struct Lisp_Overlay *overlays_after;
 600
 601   /* Position where the overlay lists are centered.  */
 602   EMACS_INT overlay_center;
 603
 604   /* Everything from here down must be a Lisp_Object.  */
 605   /* buffer-local Lisp variables start at `undo_list',
 606      tho only the ones from `name' on are GC'd normally.  */
 607
 608   /* Changes in the buffer are recorded here for undo.
 609      t means don't record anything.
 610      This information belongs to the base buffer of an indirect buffer,
 611      But we can't store it in the  struct buffer_text
 612      because local variables have to be right in the  struct buffer.
 613      So we copy it around in set_buffer_internal.
 614      This comes before `name' because it is marked in a special way.  */
 615   Lisp_Object BUFFER_INTERNAL_FIELD (undo_list);
 616
 617   /* The name of this buffer.  */
 618   Lisp_Object BUFFER_INTERNAL_FIELD (name);
 619
 620   /* The name of the file visited in this buffer, or nil.  */
 621   Lisp_Object BUFFER_INTERNAL_FIELD (filename);
 622   /* Dir for expanding relative file names.  */
 623   Lisp_Object BUFFER_INTERNAL_FIELD (directory);
 624   /* True if this buffer has been backed up (if you write to the
 625      visited file and it hasn't been backed up, then a backup will
 626      be made).  */
 627   /* This isn't really used by the C code, so could be deleted.  */
 628   Lisp_Object BUFFER_INTERNAL_FIELD (backed_up);
 629   /* Length of file when last read or saved.
 630      -1 means auto saving turned off because buffer shrank a lot.
 631      -2 means don't turn off auto saving if buffer shrinks.
 632        (That value is used with buffer-swap-text.)
 633      This is not in the  struct buffer_text
 634      because it's not used in indirect buffers at all.  */
 635   Lisp_Object BUFFER_INTERNAL_FIELD (save_length);
 636   /* File name used for auto-saving this buffer.
 637      This is not in the  struct buffer_text
 638      because it's not used in indirect buffers at all.  */
 639   Lisp_Object BUFFER_INTERNAL_FIELD (auto_save_file_name);
 640
 641   /* Non-nil if buffer read-only.  */
 642   Lisp_Object BUFFER_INTERNAL_FIELD (read_only);
 643   /* "The mark".  This is a marker which may
 644      point into this buffer or may point nowhere.  */
 645   Lisp_Object BUFFER_INTERNAL_FIELD (mark);
 646
 647   /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER) for all
 648      per-buffer variables of this buffer.  For locally unbound
 649      symbols, just the symbol appears as the element.  */
 650   Lisp_Object BUFFER_INTERNAL_FIELD (local_var_alist);
 651
 652   /* Symbol naming major mode (eg, lisp-mode).  */
 653   Lisp_Object BUFFER_INTERNAL_FIELD (major_mode);
 654   /* Pretty name of major mode (eg, "Lisp"). */
 655   Lisp_Object BUFFER_INTERNAL_FIELD (mode_name);
 656   /* Mode line element that controls format of mode line.  */
 657   Lisp_Object BUFFER_INTERNAL_FIELD (mode_line_format);
 658
 659   /* Analogous to mode_line_format for the line displayed at the top
 660      of windows.  Nil means don't display that line.  */
 661   Lisp_Object BUFFER_INTERNAL_FIELD (header_line_format);
 662
 663   /* Keys that are bound local to this buffer.  */
 664   Lisp_Object BUFFER_INTERNAL_FIELD (keymap);
 665   /* This buffer's local abbrev table.  */
 666   Lisp_Object BUFFER_INTERNAL_FIELD (abbrev_table);
 667   /* This buffer's syntax table.  */
 668   Lisp_Object BUFFER_INTERNAL_FIELD (syntax_table);
 669   /* This buffer's category table.  */
 670   Lisp_Object BUFFER_INTERNAL_FIELD (category_table);
 671
 672   /* Values of several buffer-local variables.  */
 673   /* tab-width is buffer-local so that redisplay can find it
 674      in buffers that are not current.  */
 675   Lisp_Object BUFFER_INTERNAL_FIELD (case_fold_search);
 676   Lisp_Object BUFFER_INTERNAL_FIELD (tab_width);
 677   Lisp_Object BUFFER_INTERNAL_FIELD (fill_column);
 678   Lisp_Object BUFFER_INTERNAL_FIELD (left_margin);
 679   /* Function to call when insert space past fill column.  */
 680   Lisp_Object BUFFER_INTERNAL_FIELD (auto_fill_function);
 681
 682   /* Case table for case-conversion in this buffer.
 683      This char-table maps each char into its lower-case version.  */
 684   Lisp_Object BUFFER_INTERNAL_FIELD (downcase_table);
 685   /* Char-table mapping each char to its upper-case version.  */
 686   Lisp_Object BUFFER_INTERNAL_FIELD (upcase_table);
 687   /* Char-table for conversion for case-folding search.  */
 688   Lisp_Object BUFFER_INTERNAL_FIELD (case_canon_table);
 689   /* Char-table of equivalences for case-folding search.  */
 690   Lisp_Object BUFFER_INTERNAL_FIELD (case_eqv_table);
 691
 692   /* Non-nil means do not display continuation lines.  */
 693   Lisp_Object BUFFER_INTERNAL_FIELD (truncate_lines);
 694   /* Non-nil means to use word wrapping when displaying continuation lines.  */
 695   Lisp_Object BUFFER_INTERNAL_FIELD (word_wrap);
 696   /* Non-nil means display ctl chars with uparrow.  */
 697   Lisp_Object BUFFER_INTERNAL_FIELD (ctl_arrow);
 698   /* Non-nil means reorder bidirectional text for display in the
 699      visual order.  */
 700   Lisp_Object BUFFER_INTERNAL_FIELD (bidi_display_reordering);
 701   /* If non-nil, specifies which direction of text to force in all the
 702      paragraphs of the buffer.  Nil means determine paragraph
 703      direction dynamically for each paragraph.  */
 704   Lisp_Object BUFFER_INTERNAL_FIELD (bidi_paragraph_direction);
 705   /* Non-nil means do selective display;
 706      see doc string in syms_of_buffer (buffer.c) for details.  */
 707   Lisp_Object BUFFER_INTERNAL_FIELD (selective_display);
 708 #ifndef old
 709   /* Non-nil means show ... at end of line followed by invisible lines.  */
 710   Lisp_Object BUFFER_INTERNAL_FIELD (selective_display_ellipses);
 711 #endif
 712   /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer.  */
 713   Lisp_Object BUFFER_INTERNAL_FIELD (minor_modes);
 714   /* t if "self-insertion" should overwrite; `binary' if it should also
 715      overwrite newlines and tabs - for editing executables and the like.  */
 716   Lisp_Object BUFFER_INTERNAL_FIELD (overwrite_mode);
 717   /* non-nil means abbrev mode is on.  Expand abbrevs automatically.  */
 718   Lisp_Object BUFFER_INTERNAL_FIELD (abbrev_mode);
 719   /* Display table to use for text in this buffer.  */
 720   Lisp_Object BUFFER_INTERNAL_FIELD (display_table);
 721   /* t means the mark and region are currently active.  */
 722   Lisp_Object BUFFER_INTERNAL_FIELD (mark_active);
 723
 724   /* Non-nil means the buffer contents are regarded as multi-byte
 725      form of characters, not a binary code.  */
 726   Lisp_Object BUFFER_INTERNAL_FIELD (enable_multibyte_characters);
 727
 728   /* Coding system to be used for encoding the buffer contents on
 729      saving.  */
 730   Lisp_Object BUFFER_INTERNAL_FIELD (buffer_file_coding_system);
 731
 732   /* List of symbols naming the file format used for visited file.  */
 733   Lisp_Object BUFFER_INTERNAL_FIELD (file_format);
 734
 735   /* List of symbols naming the file format used for auto-save file.  */
 736   Lisp_Object BUFFER_INTERNAL_FIELD (auto_save_file_format);
 737
 738   /* True if the newline position cache and width run cache are
 739      enabled.  See search.c and indent.c.  */
 740   Lisp_Object BUFFER_INTERNAL_FIELD (cache_long_line_scans);
 741
 742   /* If the width run cache is enabled, this table contains the
 743      character widths width_run_cache (see above) assumes.  When we
 744      do a thorough redisplay, we compare this against the buffer's
 745      current display table to see whether the display table has
 746      affected the widths of any characters.  If it has, we
 747      invalidate the width run cache, and re-initialize width_table.  */
 748   Lisp_Object BUFFER_INTERNAL_FIELD (width_table);
 749
 750   /* In an indirect buffer, or a buffer that is the base of an
 751      indirect buffer, this holds a marker that records
 752      PT for this buffer when the buffer is not current.  */
 753   Lisp_Object BUFFER_INTERNAL_FIELD (pt_marker);
 754
 755   /* In an indirect buffer, or a buffer that is the base of an
 756      indirect buffer, this holds a marker that records
 757      BEGV for this buffer when the buffer is not current.  */
 758   Lisp_Object BUFFER_INTERNAL_FIELD (begv_marker);
 759
 760   /* In an indirect buffer, or a buffer that is the base of an
 761      indirect buffer, this holds a marker that records
 762      ZV for this buffer when the buffer is not current.  */
 763   Lisp_Object BUFFER_INTERNAL_FIELD (zv_marker);
 764
 765   /* This holds the point value before the last scroll operation.
 766      Explicitly setting point sets this to nil.  */
 767   Lisp_Object BUFFER_INTERNAL_FIELD (point_before_scroll);
 768
 769   /* Truename of the visited file, or nil.  */
 770   Lisp_Object BUFFER_INTERNAL_FIELD (file_truename);
 771
 772   /* Invisibility spec of this buffer.
 773      t => any non-nil `invisible' property means invisible.
 774      A list => `invisible' property means invisible
 775      if it is memq in that list.  */
 776   Lisp_Object BUFFER_INTERNAL_FIELD (invisibility_spec);
 777
 778   /* This is the last window that was selected with this buffer in it,
 779      or nil if that window no longer displays this buffer.  */
 780   Lisp_Object BUFFER_INTERNAL_FIELD (last_selected_window);
 781
 782   /* Incremented each time the buffer is displayed in a window.  */
 783   Lisp_Object BUFFER_INTERNAL_FIELD (display_count);
 784
 785   /* Widths of left and right marginal areas for windows displaying
 786      this buffer.  */
 787   Lisp_Object BUFFER_INTERNAL_FIELD (left_margin_cols), BUFFER_INTERNAL_FIELD (right_margin_cols);
 788
 789   /* Widths of left and right fringe areas for windows displaying
 790      this buffer.  */
 791   Lisp_Object BUFFER_INTERNAL_FIELD (left_fringe_width), BUFFER_INTERNAL_FIELD (right_fringe_width);
 792
 793   /* Non-nil means fringes are drawn outside display margins;
 794      othersize draw them between margin areas and text.  */
 795   Lisp_Object BUFFER_INTERNAL_FIELD (fringes_outside_margins);
 796
 797   /* Width and type of scroll bar areas for windows displaying
 798      this buffer.  */
 799   Lisp_Object BUFFER_INTERNAL_FIELD (scroll_bar_width), BUFFER_INTERNAL_FIELD (vertical_scroll_bar_type);
 800
 801   /* Non-nil means indicate lines not displaying text (in a style
 802      like vi).  */
 803   Lisp_Object BUFFER_INTERNAL_FIELD (indicate_empty_lines);
 804
 805   /* Non-nil means indicate buffer boundaries and scrolling.  */
 806   Lisp_Object BUFFER_INTERNAL_FIELD (indicate_buffer_boundaries);
 807
 808   /* Logical to physical fringe bitmap mappings.  */
 809   Lisp_Object BUFFER_INTERNAL_FIELD (fringe_indicator_alist);
 810
 811   /* Logical to physical cursor bitmap mappings.  */
 812   Lisp_Object BUFFER_INTERNAL_FIELD (fringe_cursor_alist);
 813
 814   /* Time stamp updated each time this buffer is displayed in a window.  */
 815   Lisp_Object BUFFER_INTERNAL_FIELD (display_time);
 816
 817   /* If scrolling the display because point is below the bottom of a
 818      window showing this buffer, try to choose a window start so
 819      that point ends up this number of lines from the top of the
 820      window.  Nil means that scrolling method isn't used.  */
 821   Lisp_Object BUFFER_INTERNAL_FIELD (scroll_up_aggressively);
 822
 823   /* If scrolling the display because point is above the top of a
 824      window showing this buffer, try to choose a window start so
 825      that point ends up this number of lines from the bottom of the
 826      window.  Nil means that scrolling method isn't used.  */
 827   Lisp_Object BUFFER_INTERNAL_FIELD (scroll_down_aggressively);
 828
 829   /* Desired cursor type in this buffer.  See the doc string of
 830      per-buffer variable `cursor-type'.  */
 831   Lisp_Object BUFFER_INTERNAL_FIELD (cursor_type);
 832
 833   /* An integer > 0 means put that number of pixels below text lines
 834      in the display of this buffer.  */
 835   Lisp_Object BUFFER_INTERNAL_FIELD (extra_line_spacing);
 836
 837   /* *Cursor type to display in non-selected windows.
 838      t means to use hollow box cursor.
 839      See `cursor-type' for other values.  */
 840   Lisp_Object BUFFER_INTERNAL_FIELD (cursor_in_non_selected_windows);
 841 };
 842
 843 \f
 844 /* This points to the current buffer.  */
 845
 846 extern struct buffer *current_buffer;
 847
 848 /* This structure holds the default values of the buffer-local variables
 849    that have special slots in each buffer.
 850    The default value occupies the same slot in this structure
 851    as an individual buffer's value occupies in that buffer.
 852    Setting the default value also goes through the alist of buffers
 853    and stores into each buffer that does not say it has a local value.  */
 854
 855 extern struct buffer buffer_defaults;
 856
 857 /* This structure marks which slots in a buffer have corresponding
 858    default values in buffer_defaults.
 859    Each such slot has a nonzero value in this structure.
 860    The value has only one nonzero bit.
 861
 862    When a buffer has its own local value for a slot,
 863    the entry for that slot (found in the same slot in this structure)
 864    is turned on in the buffer's local_flags array.
 865
 866    If a slot in this structure is zero, then even though there may
 867    be a Lisp-level local variable for the slot, it has no default value,
 868    and the corresponding slot in buffer_defaults is not used.  */
 869
 870
 871 extern struct buffer buffer_local_flags;
 872
 873 /* For each buffer slot, this points to the Lisp symbol name
 874    for that slot in the current buffer.  It is 0 for slots
 875    that don't have such names.  */
 876
 877 extern struct buffer buffer_local_symbols;
 878 \f
 879 extern void delete_all_overlays (struct buffer *);
 880 extern void reset_buffer (struct buffer *);
 881 extern void evaporate_overlays (EMACS_INT);
 882 extern int overlays_at (EMACS_INT pos, int extend, Lisp_Object **vec_ptr,
 883                         int *len_ptr, EMACS_INT *next_ptr,
 884                         EMACS_INT *prev_ptr, int change_req);
 885 extern int sort_overlays (Lisp_Object *, int, struct window *);
 886 extern void recenter_overlay_lists (struct buffer *, EMACS_INT);
 887 extern EMACS_INT overlay_strings (EMACS_INT, struct window *, unsigned char **);
 888 extern void validate_region (Lisp_Object *, Lisp_Object *);
 889 extern void set_buffer_internal (struct buffer *);
 890 extern void set_buffer_internal_1 (struct buffer *);
 891 extern void set_buffer_temp (struct buffer *);
 892 extern void record_buffer (Lisp_Object);
 893 extern void buffer_slot_type_mismatch (Lisp_Object, int) NO_RETURN;
 894 extern void fix_overlays_before (struct buffer *, EMACS_INT, EMACS_INT);
 895 extern void mmap_set_vars (int);
 896
 897 /* Get overlays at POSN into array OVERLAYS with NOVERLAYS elements.
 898    If NEXTP is non-NULL, return next overlay there.
 899    See overlay_at arg CHANGE_REQ for meaning of CHRQ arg.  */
 900
 901 #define GET_OVERLAYS_AT(posn, overlays, noverlays, nextp, chrq)         \
 902   do {                                                                  \
 903     int maxlen = 40;                                                    \
 904     overlays = (Lisp_Object *) alloca (maxlen * sizeof (Lisp_Object));  \
 905     noverlays = overlays_at (posn, 0, &overlays, &maxlen,               \
 906                              nextp, NULL, chrq);                                \
 907     if (noverlays > maxlen)                                             \
 908       {                                                                 \
 909         maxlen = noverlays;                                             \
 910         overlays = (Lisp_Object *) alloca (maxlen * sizeof (Lisp_Object)); \
 911         noverlays = overlays_at (posn, 0, &overlays, &maxlen,           \
 912                                  nextp, NULL, chrq);                    \
 913       }                                                                 \
 914   } while (0)
 915
 916 EXFUN (Fbuffer_live_p, 1);
 917 EXFUN (Fbuffer_name, 1);
 918 EXFUN (Fnext_overlay_change, 1);
 919 EXFUN (Fbuffer_local_value, 2);
 920
 921 extern Lisp_Object Qbefore_change_functions;
 922 extern Lisp_Object Qafter_change_functions;
 923 extern Lisp_Object Qfirst_change_hook;
 924
 925 \f
 926 /* Overlays */
 927
 928 /* 1 if the OV is an overlay object.  */
 929
 930 #define OVERLAY_VALID(OV) (OVERLAYP (OV))
 931
 932 /* Return the marker that stands for where OV starts in the buffer.  */
 933
 934 #define OVERLAY_START(OV) (XOVERLAY (OV)->start)
 935
 936 /* Return the marker that stands for where OV ends in the buffer.  */
 937
 938 #define OVERLAY_END(OV) (XOVERLAY (OV)->end)
 939
 940 /* Return the plist of overlay OV.  */
 941
 942 #define OVERLAY_PLIST(OV) XOVERLAY ((OV))->plist
 943
 944 /* Return the actual buffer position for the marker P.
 945    We assume you know which buffer it's pointing into.  */
 946
 947 #define OVERLAY_POSITION(P) \
 948  (MARKERP (P) ? marker_position (P) : (abort (), 0))
 949
 950 \f
 951 /***********************************************************************
 952                         Buffer-local Variables
 953  ***********************************************************************/
 954
 955 /* Number of per-buffer variables used.  */
 956
 957 extern int last_per_buffer_idx;
 958
 959 /* Return the offset in bytes of member VAR of struct buffer
 960    from the start of a buffer structure.  */
 961
 962 #define PER_BUFFER_VAR_OFFSET(VAR) \
 963   offsetof (struct buffer, BUFFER_INTERNAL_FIELD (VAR))
 964
 965 /* Return the index of buffer-local variable VAR.  Each per-buffer
 966    variable has an index > 0 associated with it, except when it always
 967    has buffer-local values, in which case the index is -1.  If this is
 968    0, this is a bug and means that the slot of VAR in
 969    buffer_local_flags wasn't intiialized.  */
 970
 971 #define PER_BUFFER_VAR_IDX(VAR) \
 972     PER_BUFFER_IDX (PER_BUFFER_VAR_OFFSET (VAR))
 973
 974 /* Value is non-zero if the variable with index IDX has a local value
 975    in buffer B.  */
 976
 977 #define PER_BUFFER_VALUE_P(B, IDX)              \
 978     (((IDX) < 0 || IDX >= last_per_buffer_idx)  \
 979      ? (abort (), 0)                            \
 980      : ((B)->local_flags[IDX] != 0))
 981
 982 /* Set whether per-buffer variable with index IDX has a buffer-local
 983    value in buffer B.  VAL zero means it hasn't.  */
 984
 985 #define SET_PER_BUFFER_VALUE_P(B, IDX, VAL)     \
 986      do {                                               \
 987        if ((IDX) < 0 || (IDX) >= last_per_buffer_idx)   \
 988          abort ();                                      \
 989        (B)->local_flags[IDX] = (VAL);                   \
 990      } while (0)
 991
 992 /* Return the index value of the per-buffer variable at offset OFFSET
 993    in the buffer structure.
 994
 995    If the slot OFFSET has a corresponding default value in
 996    buffer_defaults, the index value is positive and has only one
 997    nonzero bit.  When a buffer has its own local value for a slot, the
 998    bit for that slot (found in the same slot in this structure) is
 999    turned on in the buffer's local_flags array.
1000
1001    If the index value is -1, even though there may be a
1002    DEFVAR_PER_BUFFER for the slot, there is no default value for it;
1003    and the corresponding slot in buffer_defaults is not used.
1004
1005    If the index value is -2, then there is no DEFVAR_PER_BUFFER for
1006    the slot, but there is a default value which is copied into each
1007    new buffer.
1008
1009    If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
1010    zero, that is a bug */
1011
1012
1013 #define PER_BUFFER_IDX(OFFSET) \
1014       XINT (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_flags))
1015
1016 /* Return the default value of the per-buffer variable at offset
1017    OFFSET in the buffer structure.  */
1018
1019 #define PER_BUFFER_DEFAULT(OFFSET) \
1020       (*(Lisp_Object *)((OFFSET) + (char *) &buffer_defaults))
1021
1022 /* Return the buffer-local value of the per-buffer variable at offset
1023    OFFSET in the buffer structure.  */
1024
1025 #define PER_BUFFER_VALUE(BUFFER, OFFSET) \
1026       (*(Lisp_Object *)((OFFSET) + (char *) (BUFFER)))
1027 \f
1028 /* Downcase a character C, or make no change if that cannot be done.  */
1029 static inline int
1030 downcase (int c)
1031 {
1032   Lisp_Object downcase_table = BVAR (current_buffer, downcase_table);
1033   Lisp_Object down = CHAR_TABLE_REF (downcase_table, c);
1034   return NATNUMP (down) ? XFASTINT (down) : c;
1035 }
1036
1037 /* 1 if C is upper case.  */
1038 static inline int uppercasep (int c) { return downcase (c) != c; }
1039
1040 /* Upcase a character C known to be not upper case.  */
1041 static inline int
1042 upcase1 (int c)
1043 {
1044   Lisp_Object upcase_table = BVAR (current_buffer, upcase_table);
1045   Lisp_Object up = CHAR_TABLE_REF (upcase_table, c);
1046   return NATNUMP (up) ? XFASTINT (up) : c;
1047 }
1048
1049 /* 1 if C is lower case.  */
1050 static inline int lowercasep (int c)
1051 { return !uppercasep (c) && upcase1 (c) != c; }
1052
1053 /* Upcase a character C, or make no change if that cannot be done.  */
1054 static inline int upcase (int c) { return uppercasep (c) ? c : upcase1 (c); }