src/buffer.h

   1 /* Header file for the buffer manipulation primitives.
   2    Copyright (C) 1985, 1986, 1993, 1994, 1995 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #ifdef USE_TEXT_PROPERTIES
  23 #define SET_PT(position) (set_point ((position), current_buffer))
  24 #define TEMP_SET_PT(position) (temp_set_point ((position), current_buffer))
  25
  26 #define BUF_SET_PT(buffer, position) (set_point ((position), (buffer)))
  27 #define BUF_TEMP_SET_PT(buffer, position) (temp_set_point ((position), (buffer)))
  28
  29 #else  /* don't support text properties */
  30
  31 #define SET_PT(position) (current_buffer->pt = (position))
  32 #define TEMP_SET_PT(position) (current_buffer->pt = (position))
  33
  34 #define BUF_SET_PT(buffer, position) (buffer->pt = (position))
  35 #define BUF_TEMP_SET_PT(buffer, position) (buffer->pt = (position))
  36 #endif /* don't support text properties */
  37
  38 /* Character position of beginning of buffer.  */
  39 #define BEG (1)
  40
  41 /* Character position of beginning of accessible range of buffer.  */
  42 #define BEGV (current_buffer->begv)
  43
  44 /* Character position of point in buffer.  The "+ 0" makes this
  45    not an l-value, so you can't assign to it.  Use SET_PT instead.  */
  46 #define PT (current_buffer->pt + 0)
  47
  48 /* Character position of gap in buffer.  */
  49 #define GPT (current_buffer->text->gpt)
  50
  51 /* Character position of end of accessible range of buffer.  */
  52 #define ZV (current_buffer->zv)
  53
  54 /* Character position of end of buffer.  */
  55 #define Z (current_buffer->text->z)
  56
  57 /* Is the current buffer narrowed? */
  58 #define NARROWED        ((BEGV != BEG) || (ZV != Z))
  59
  60 /* Modification count.  */
  61 #define MODIFF (current_buffer->text->modiff)
  62
  63 /* Modification count as of last visit or save.  */
  64 #define SAVE_MODIFF (current_buffer->text->save_modiff)
  65
  66 /* Address of beginning of buffer.  */
  67 #define BEG_ADDR (current_buffer->text->beg)
  68
  69 /* Address of beginning of accessible range of buffer.  */
  70 #define BEGV_ADDR (&FETCH_CHAR (current_buffer->begv))
  71
  72 /* Address of point in buffer.  */
  73 #define PT_ADDR (&FETCH_CHAR (current_buffer->pt))
  74
  75 /* Address of beginning of gap in buffer.  */
  76 #define GPT_ADDR (current_buffer->text->beg + current_buffer->text->gpt - 1)
  77
  78 /* Address of end of gap in buffer.  */
  79 #define GAP_END_ADDR (current_buffer->text->beg + current_buffer->text->gpt + current_buffer->text->gap_size - 1)
  80
  81 /* Address of end of accessible range of buffer.  */
  82 #define ZV_ADDR (&FETCH_CHAR (current_buffer->zv))
  83
  84 /* Size of gap.  */
  85 #define GAP_SIZE (current_buffer->text->gap_size)
  86
  87 /* Now similar macros for a specified buffer.
  88    Note that many of these evaluate the buffer argument more than once.  */
  89
  90 /* Character position of beginning of buffer.  */
  91 #define BUF_BEG(buf) (1)
  92
  93 /* Character position of beginning of accessible range of buffer.  */
  94 #define BUF_BEGV(buf) ((buf)->begv)
  95
  96 /* Character position of point in buffer.  */
  97 #define BUF_PT(buf) ((buf)->pt)
  98
  99 /* Character position of gap in buffer.  */
 100 #define BUF_GPT(buf) ((buf)->text->gpt)
 101
 102 /* Character position of end of accessible range of buffer.  */
 103 #define BUF_ZV(buf) ((buf)->zv)
 104
 105 /* Character position of end of buffer.  */
 106 #define BUF_Z(buf) ((buf)->text->z)
 107
 108 /* Is this buffer narrowed? */
 109 #define BUF_NARROWED(buf) ((BUF_BEGV (buf) != BUF_BEG (buf)) \
 110                            || (BUF_ZV (buf) != BUF_Z (buf)))
 111
 112 /* Modification count.  */
 113 #define BUF_MODIFF(buf) ((buf)->text->modiff)
 114
 115 /* Modification count as of last visit or save.  */
 116 #define BUF_SAVE_MODIFF(buf) ((buf)->text->save_modiff)
 117
 118 /* Interval tree of buffer.  */
 119 #define BUF_INTERVALS(buf) ((buf)->text->intervals)
 120
 121 /* Marker chain of buffer.  */
 122 #define BUF_MARKERS(buf) ((buf)->text->markers)
 123
 124 /* Address of beginning of buffer.  */
 125 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
 126
 127 /* Macro for setting the value of BUF_ZV (BUF) to VALUE,
 128    by varying the end of the accessible region.  */
 129 #define SET_BUF_ZV(buf, value) ((buf)->zv = (value))
 130 #define SET_BUF_PT(buf, value) ((buf)->pt = (value))
 131
 132 /* Size of gap.  */
 133 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size)
 134
 135 /* Return the address of character at position POS in buffer BUF.
 136    Note that both arguments can be computed more than once.  */
 137 #define BUF_CHAR_ADDRESS(buf, pos) \
 138 ((buf)->text->beg + (pos) - 1           \
 139  + ((pos) >= (buf)->text->gpt ? (buf)->text->gap_size : 0))
 140
 141 /* Convert the address of a char in the buffer into a character position.  */
 142 #define PTR_CHAR_POS(ptr) \
 143 ((ptr) - (current_buffer)->text->beg                                    \
 144  - (ptr - (current_buffer)->text->beg < (unsigned) GPT ? 0 : GAP_SIZE)  \
 145  + 1)
 146
 147 /* Convert the address of a char in the buffer into a character position.  */
 148 #define BUF_PTR_CHAR_POS(buf, ptr)                      \
 149 ((ptr) - (buf)->text->beg                               \
 150  - (ptr - (buf)->text->beg < (unsigned) BUF_GPT ((buf)) \
 151     ? 0 : BUF_GAP_SIZE ((buf)))                         \
 152  + 1)
 153 \f
 154 struct buffer_text
 155   {
 156     unsigned char *beg;         /* Actual address of buffer contents.  */
 157     int gpt;                    /* Index of gap in buffer.  */
 158     int z;                      /* Index of end of buffer.  */
 159     int gap_size;               /* Size of buffer's gap.  */
 160     int modiff;                 /* This counts buffer-modification events
 161                                    for this buffer.  It is incremented for
 162                                    each such event, and never otherwise
 163                                    changed.  */
 164     int save_modiff;            /* Previous value of modiff, as of last
 165                                    time buffer visited or saved a file.  */
 166
 167     /* Properties of this buffer's text -- conditionally compiled.  */
 168     DECLARE_INTERVALS
 169
 170     /* The markers that refer to this buffer.
 171        This is actually a single marker ---
 172        successive elements in its marker `chain'
 173        are the other markers referring to this buffer.  */
 174     Lisp_Object markers;
 175   };
 176
 177 struct buffer
 178   {
 179     /* Everything before the `name' slot must be of a non-Lisp_Object type,
 180        and every slot after `name' must be a Lisp_Object.
 181
 182        Check out mark_buffer (alloc.c) to see why.  */
 183
 184     EMACS_INT size;
 185
 186     /* Next buffer, in chain of all buffers including killed buffers.
 187        This chain is used only for garbage collection, in order to
 188        collect killed buffers properly.
 189        Note that vectors and most pseudovectors are all on one chain,
 190        but buffers are on a separate chain of their own.  */
 191     struct buffer *next;
 192
 193     /* This structure holds the coordinates of the buffer contents
 194        in ordinary buffers.  In indirect buffers, this is not used.  */
 195     struct buffer_text own_text;
 196
 197     /* This points to the `struct buffer_text' that used for this buffer.
 198        In an ordinary buffer, this is the own_text field above.
 199        In an indirect buffer, this is the own_text field of another buffer.  */
 200     struct buffer_text *text;
 201
 202     /* Position of point in buffer.  */
 203     int pt;
 204     /* Index of beginning of accessible range.  */
 205     int begv;
 206     /* Index of end of accessible range.  */
 207     int zv;
 208
 209     /* In an indirect buffer, this points to the base buffer.
 210        In an ordinary buffer, it is 0.  */
 211     struct buffer *base_buffer;
 212
 213     /* Flags saying which DEFVAR_PER_BUFFER variables
 214        are local to this buffer.  */
 215     int local_var_flags;
 216     /* Set to the modtime of the visited file when read or written.
 217        -1 means visited file was nonexistent.
 218        0 means visited file modtime unknown; in no case complain
 219        about any mismatch on next save attempt.  */
 220     int modtime;
 221     /* the value of text->modiff at the last auto-save.  */
 222     int auto_save_modified;
 223     /* The time at which we detected a failure to auto-save,
 224        Or -1 if we didn't have a failure.  */
 225     int auto_save_failure_time;
 226     /* Position in buffer at which display started
 227        the last time this buffer was displayed.  */
 228     int last_window_start;
 229
 230     /* Set nonzero whenever the narrowing is changed in this buffer.  */
 231     int clip_changed;
 232
 233     /* If the long line scan cache is enabled (i.e. the buffer-local
 234        variable cache-long-line-scans is non-nil), newline_cache
 235        points to the newline cache, and width_run_cache points to the
 236        width run cache.
 237
 238        The newline cache records which stretches of the buffer are
 239        known *not* to contain newlines, so that they can be skipped
 240        quickly when we search for newlines.
 241
 242        The width run cache records which stretches of the buffer are
 243        known to contain characters whose widths are all the same.  If
 244        the width run cache maps a character to a value > 0, that value is
 245        the character's width; if it maps a character to zero, we don't
 246        know what its width is.  This allows compute_motion to process
 247        such regions very quickly, using algebra instead of inspecting
 248        each character.   See also width_table, below.  */
 249     struct region_cache *newline_cache;
 250     struct region_cache *width_run_cache;
 251
 252     /* Everything from here down must be a Lisp_Object */
 253
 254
 255     /* The name of this buffer.  */
 256     Lisp_Object name;
 257     /* The name of the file visited in this buffer, or nil.  */
 258     Lisp_Object filename;
 259     /* Dir for expanding relative file names.  */
 260     Lisp_Object directory;
 261     /* True iff this buffer has been backed up (if you write to the
 262        visited file and it hasn't been backed up, then a backup will
 263        be made).  */
 264     /* This isn't really used by the C code, so could be deleted.  */
 265     Lisp_Object backed_up;
 266     /* Length of file when last read or saved.
 267        This is not in the  struct buffer_text
 268        because it's not used in indirect buffers at all.  */
 269     Lisp_Object save_length;
 270     /* File name used for auto-saving this buffer.
 271        This is not in the  struct buffer_text
 272        because it's not used in indirect buffers at all.  */
 273     Lisp_Object auto_save_file_name;
 274
 275     /* Non-nil if buffer read-only.  */
 276     Lisp_Object read_only;
 277     /* "The mark".  This is a marker which may
 278        point into this buffer or may point nowhere.  */
 279     Lisp_Object mark;
 280
 281     /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER)
 282        for all per-buffer variables of this buffer.  */
 283     Lisp_Object local_var_alist;
 284
 285     /* Symbol naming major mode (eg, lisp-mode).  */
 286     Lisp_Object major_mode;
 287     /* Pretty name of major mode (eg, "Lisp"). */
 288     Lisp_Object mode_name;
 289     /* Mode line element that controls format of mode line.  */
 290     Lisp_Object mode_line_format;
 291
 292     /* Keys that are bound local to this buffer.  */
 293     Lisp_Object keymap;
 294     /* This buffer's local abbrev table.  */
 295     Lisp_Object abbrev_table;
 296     /* This buffer's syntax table.  */
 297     Lisp_Object syntax_table;
 298
 299     /* Values of several buffer-local variables */
 300     /* tab-width is buffer-local so that redisplay can find it
 301        in buffers that are not current */
 302     Lisp_Object case_fold_search;
 303     Lisp_Object tab_width;
 304     Lisp_Object fill_column;
 305     Lisp_Object left_margin;
 306     /* Function to call when insert space past fill column.  */
 307     Lisp_Object auto_fill_function;
 308     /* nil: text, t: binary.
 309        This value is meaningful only on certain operating systems.  */
 310     Lisp_Object buffer_file_type;
 311
 312     /* Case table for case-conversion in this buffer.
 313        This char-table maps each char into its lower-case version.  */
 314     Lisp_Object downcase_table;
 315     /* Char-table mapping each char to its upper-case version.  */
 316     Lisp_Object upcase_table;
 317     /* Char-table for conversion for case-folding search.  */
 318     Lisp_Object case_canon_table;
 319     /* Char-table of equivalences for case-folding search.  */
 320     Lisp_Object case_eqv_table;
 321
 322     /* Non-nil means do not display continuation lines.  */
 323     Lisp_Object truncate_lines;
 324     /* Non-nil means display ctl chars with uparrow.  */
 325     Lisp_Object ctl_arrow;
 326     /* Non-nil means do selective display;
 327        see doc string in syms_of_buffer (buffer.c) for details.  */
 328     Lisp_Object selective_display;
 329 #ifndef old
 330     /* Non-nil means show ... at end of line followed by invisible lines.  */
 331     Lisp_Object selective_display_ellipses;
 332 #endif
 333     /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer.  */
 334     Lisp_Object minor_modes;
 335     /* t if "self-insertion" should overwrite; `binary' if it should also
 336        overwrite newlines and tabs - for editing executables and the like.  */
 337     Lisp_Object overwrite_mode;
 338     /* non-nil means abbrev mode is on.  Expand abbrevs automatically.  */
 339     Lisp_Object abbrev_mode;
 340     /* Display table to use for text in this buffer.  */
 341     Lisp_Object display_table;
 342     /* t means the mark and region are currently active.  */
 343     Lisp_Object mark_active;
 344
 345     /* Changes in the buffer are recorded here for undo.
 346        t means don't record anything.
 347        This information belongs to the base buffer of an indirect buffer,
 348        But we can't store it in the  struct buffer_text
 349        because local variables have to be right in the  struct buffer.
 350        So we copy it around in set_buffer_internal.  */
 351     Lisp_Object undo_list;
 352
 353     /* List of overlays that end at or before the current center,
 354        in order of end-position.  */
 355     Lisp_Object overlays_before;
 356
 357     /* List of overlays that end after  the current center,
 358        in order of start-position.  */
 359     Lisp_Object overlays_after;
 360
 361     /* Position where the overlay lists are centered.  */
 362     Lisp_Object overlay_center;
 363
 364     /* Lisp of symbols naming the file format used for visited file. */
 365     Lisp_Object file_format;
 366
 367     /* True if the newline position cache and width run cache are
 368        enabled.  See search.c and indent.c.  */
 369     Lisp_Object cache_long_line_scans;
 370
 371     /* If the width run cache is enabled, this table contains the
 372        character widths width_run_cache (see above) assumes.  When we
 373        do a thorough redisplay, we compare this against the buffer's
 374        current display table to see whether the display table has
 375        affected the widths of any characters.  If it has, we
 376        invalidate the width run cache, and re-initialize width_table.  */
 377     Lisp_Object width_table;
 378
 379     /* In an indirect buffer, or a buffer that is the base of an
 380        indirect buffer, this holds a marker that records
 381        PT for this buffer when the buffer is not current.  */
 382     Lisp_Object pt_marker;
 383
 384     /* In an indirect buffer, or a buffer that is the base of an
 385        indirect buffer, this holds a marker that records
 386        BEGV for this buffer when the buffer is not current.  */
 387     Lisp_Object begv_marker;
 388
 389     /* In an indirect buffer, or a buffer that is the base of an
 390        indirect buffer, this holds a marker that records
 391        ZV for this buffer when the buffer is not current.  */
 392     Lisp_Object zv_marker;
 393
 394     /* This holds the point value before the last scroll operation.
 395        Explicitly setting point sets this to nil.  */
 396     Lisp_Object point_before_scroll;
 397
 398     /* Truename of the visited file, or nil.  */
 399     Lisp_Object file_truename;
 400
 401     /* Invisibility spec of this buffer.
 402        t => any non-nil `invisible' property means invisible.
 403        A list => `invisible' property means invisible
 404                  if it is memq in that list.  */
 405     Lisp_Object invisibility_spec;
 406
 407     /* These are so we don't have to recompile everything
 408        the next few times we add a new slot.  */
 409     Lisp_Object extra1, extra2, extra3;
 410   };
 411 \f
 412 /* This points to the current buffer.  */
 413
 414 extern struct buffer *current_buffer;
 415
 416 /* This structure holds the default values of the buffer-local variables
 417    that have special slots in each buffer.
 418    The default value occupies the same slot in this structure
 419    as an individual buffer's value occupies in that buffer.
 420    Setting the default value also goes through the alist of buffers
 421    and stores into each buffer that does not say it has a local value.  */
 422
 423 extern struct buffer buffer_defaults;
 424
 425 /* This structure marks which slots in a buffer have corresponding
 426    default values in buffer_defaults.
 427    Each such slot has a nonzero value in this structure.
 428    The value has only one nonzero bit.
 429
 430    When a buffer has its own local value for a slot,
 431    the bit for that slot (found in the same slot in this structure)
 432    is turned on in the buffer's local_var_flags slot.
 433
 434    If a slot in this structure is zero, then even though there may
 435    be a Lisp-level local variable for the slot, it has no default value,
 436    and the corresponding slot in buffer_defaults is not used.  */
 437
 438 extern struct buffer buffer_local_flags;
 439
 440 /* For each buffer slot, this points to the Lisp symbol name
 441    for that slot in the current buffer.  It is 0 for slots
 442    that don't have such names.  */
 443
 444 extern struct buffer buffer_local_symbols;
 445
 446 /* This structure holds the required types for the values in the
 447    buffer-local slots.  If a slot contains Qnil, then the
 448    corresponding buffer slot may contain a value of any type.  If a
 449    slot contains an integer, then prospective values' tags must be
 450    equal to that integer.  When a tag does not match, the function
 451    buffer_slot_type_mismatch will signal an error.  The value Qnil may
 452    always be safely stored in any slot.  */
 453 extern struct buffer buffer_local_types;
 454 \f
 455 /* Point in the current buffer.  This is an obsolete alias
 456    and should be eliminated.  */
 457 #define point (current_buffer->pt + 0)
 458
 459 /* Return character at position n.  No range checking.  */
 460 #define FETCH_CHAR(n) *(((n)>= GPT ? GAP_SIZE : 0) + (n) + BEG_ADDR - 1)
 461
 462 /* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return
 463    the max (resp. min) p such that
 464
 465    &FETCH_CHAR (p) - &FETCH_CHAR (n) == p - n       */
 466
 467 #define BUFFER_CEILING_OF(n) (((n) < GPT && GPT < ZV ? GPT : ZV) - 1)
 468 #define BUFFER_FLOOR_OF(n) (BEGV <= GPT && GPT <= (n) ? GPT : BEGV)
 469
 470 extern void reset_buffer ();
 471 extern void evaporate_overlays ();
 472
 473 extern Lisp_Object Fbuffer_name ();
 474 extern Lisp_Object Fget_file_buffer ();
 475 extern Lisp_Object Fnext_overlay_change ();
 476 extern Lisp_Object Fdelete_overlay ();
 477
 478 /* Functions to call before and after each text change.  */
 479 extern Lisp_Object Vbefore_change_function;
 480 extern Lisp_Object Vafter_change_function;
 481 extern Lisp_Object Vbefore_change_functions;
 482 extern Lisp_Object Vafter_change_functions;
 483 extern Lisp_Object Vfirst_change_hook;
 484 extern Lisp_Object Qbefore_change_functions;
 485 extern Lisp_Object Qafter_change_functions;
 486 extern Lisp_Object Qfirst_change_hook;
 487
 488 extern Lisp_Object Vdeactivate_mark;
 489 extern Lisp_Object Vtransient_mark_mode;
 490 \f
 491 /* Overlays */
 492
 493 /* 1 if the OV is an overlay object.  */
 494 #define OVERLAY_VALID(OV) (OVERLAYP (OV))
 495
 496 /* Return the marker that stands for where OV starts in the buffer.  */
 497 #define OVERLAY_START(OV) (XOVERLAY (OV)->start)
 498
 499 /* Return the marker that stands for where OV ends in the buffer.  */
 500 #define OVERLAY_END(OV) (XOVERLAY (OV)->end)
 501
 502 /* Return the actual buffer position for the marker P.
 503    We assume you know which buffer it's pointing into.  */
 504
 505 #define OVERLAY_POSITION(P) \
 506  (GC_MARKERP (P) ? marker_position (P) : (abort (), 0))
 507
 508 /* Allocation of buffer text.  */
 509
 510 #ifdef REL_ALLOC
 511 #define BUFFER_ALLOC(data,size) ((unsigned char *) r_alloc (&data, (size)))
 512 #define BUFFER_REALLOC(data,size) ((unsigned char *) r_re_alloc (&data, (size)))
 513 #define BUFFER_FREE(data) (r_alloc_free (&data))
 514 #define R_ALLOC_DECLARE(var,data) (r_alloc_declare (&var, (data)))
 515 #else
 516 #define BUFFER_ALLOC(data,size) (data = (unsigned char *) malloc ((size)))
 517 #define BUFFER_REALLOC(data,size) ((unsigned char *) realloc ((data), (size)))
 518 #define BUFFER_FREE(data) (free ((data)))
 519 #define R_ALLOC_DECLARE(var,data)
 520 #endif