| 1 | /* Header file for the buffer manipulation primitives. |
| 2 | Copyright (C) 1985, 1986, 1990, 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| 19 | |
| 20 | |
| 21 | #ifdef USE_TEXT_PROPERTIES |
| 22 | #define SET_PT(position) (set_point ((position), current_buffer)) |
| 23 | #define TEMP_SET_PT(position) (temp_set_point ((position), current_buffer)) |
| 24 | |
| 25 | #define BUF_SET_PT(buffer, position) (set_point ((position), (buffer))) |
| 26 | #define BUF_TEMP_SET_PT(buffer, position) (temp_set_point ((position), (buffer))) |
| 27 | |
| 28 | #else /* don't support text properties */ |
| 29 | |
| 30 | #define SET_PT(position) (current_buffer->text.pt = (position)) |
| 31 | #define TEMP_SET_PT(position) (current_buffer->text.pt = (position)) |
| 32 | |
| 33 | #define BUF_SET_PT(buffer, position) (buffer->text.pt = (position)) |
| 34 | #define BUF_TEMP_SET_PT(buffer, position) (buffer->text.pt = (position)) |
| 35 | #endif /* don't support text properties */ |
| 36 | |
| 37 | /* Character position of beginning of buffer. */ |
| 38 | #define BEG (1) |
| 39 | |
| 40 | /* Character position of beginning of accessible range of buffer. */ |
| 41 | #define BEGV (current_buffer->text.begv) |
| 42 | |
| 43 | /* Character position of point in buffer. The "+ 0" makes this |
| 44 | not an l-value, so you can't assign to it. Use SET_PT instead. */ |
| 45 | #define PT (current_buffer->text.pt + 0) |
| 46 | |
| 47 | /* Character position of gap in buffer. */ |
| 48 | #define GPT (current_buffer->text.gpt) |
| 49 | |
| 50 | /* Character position of end of accessible range of buffer. */ |
| 51 | #define ZV (current_buffer->text.zv) |
| 52 | |
| 53 | /* Character position of end of buffer. */ |
| 54 | #define Z (current_buffer->text.z) |
| 55 | |
| 56 | /* Is the current buffer narrowed? */ |
| 57 | #define NARROWED ((BEGV != BEG) || (ZV != Z)) |
| 58 | |
| 59 | /* Modification count. */ |
| 60 | #define MODIFF (current_buffer->text.modiff) |
| 61 | |
| 62 | /* Address of beginning of buffer. */ |
| 63 | #define BEG_ADDR (current_buffer->text.beg) |
| 64 | |
| 65 | /* Address of beginning of accessible range of buffer. */ |
| 66 | #define BEGV_ADDR (&FETCH_CHAR (current_buffer->text.begv)) |
| 67 | |
| 68 | /* Address of point in buffer. */ |
| 69 | #define PT_ADDR (&FETCH_CHAR (current_buffer->text.pt)) |
| 70 | |
| 71 | /* Address of beginning of gap in buffer. */ |
| 72 | #define GPT_ADDR (current_buffer->text.beg + current_buffer->text.gpt - 1) |
| 73 | |
| 74 | /* Address of end of gap in buffer. */ |
| 75 | #define GAP_END_ADDR (current_buffer->text.beg + current_buffer->text.gpt + current_buffer->text.gap_size - 1) |
| 76 | |
| 77 | /* Address of end of accessible range of buffer. */ |
| 78 | #define ZV_ADDR (&FETCH_CHAR (current_buffer->text.zv)) |
| 79 | |
| 80 | /* Size of gap. */ |
| 81 | #define GAP_SIZE (current_buffer->text.gap_size) |
| 82 | |
| 83 | /* Now similar macros for a specified buffer. |
| 84 | Note that many of these evaluate the buffer argument more than once. */ |
| 85 | |
| 86 | /* Character position of beginning of buffer. */ |
| 87 | #define BUF_BEG(buf) (1) |
| 88 | |
| 89 | /* Character position of beginning of accessible range of buffer. */ |
| 90 | #define BUF_BEGV(buf) ((buf)->text.begv) |
| 91 | |
| 92 | /* Character position of point in buffer. */ |
| 93 | #define BUF_PT(buf) ((buf)->text.pt) |
| 94 | |
| 95 | /* Character position of gap in buffer. */ |
| 96 | #define BUF_GPT(buf) ((buf)->text.gpt) |
| 97 | |
| 98 | /* Character position of end of accessible range of buffer. */ |
| 99 | #define BUF_ZV(buf) ((buf)->text.zv) |
| 100 | |
| 101 | /* Character position of end of buffer. */ |
| 102 | #define BUF_Z(buf) ((buf)->text.z) |
| 103 | |
| 104 | /* Is this buffer narrowed? */ |
| 105 | #define BUF_NARROWED(buf) ((BUF_BEGV(buf) != BUF_BEG(buf)) \ |
| 106 | || (BUF_ZV(buf) != BUF_Z(buf))) |
| 107 | |
| 108 | /* Modification count. */ |
| 109 | #define BUF_MODIFF(buf) ((buf)->text.modiff) |
| 110 | |
| 111 | /* Address of beginning of buffer. */ |
| 112 | #define BUF_BEG_ADDR(buf) ((buf)->text.beg) |
| 113 | |
| 114 | /* Macro for setting the value of BUF_ZV (BUF) to VALUE, |
| 115 | by varying the end of the accessible region. */ |
| 116 | #define SET_BUF_ZV(buf, value) ((buf)->text.zv = (value)) |
| 117 | #define SET_BUF_PT(buf, value) ((buf)->text.pt = (value)) |
| 118 | |
| 119 | /* Size of gap. */ |
| 120 | #define BUF_GAP_SIZE(buf) ((buf)->text.gap_size) |
| 121 | |
| 122 | /* Return the address of character at position POS in buffer BUF. |
| 123 | Note that both arguments can be computed more than once. */ |
| 124 | #define BUF_CHAR_ADDRESS(buf, pos) \ |
| 125 | ((buf)->text.beg + (pos) - 1 \ |
| 126 | + ((pos) >= (buf)->text.gpt ? (buf)->text.gap_size : 0)) |
| 127 | |
| 128 | /* Convert the address of a char in the buffer into a character position. */ |
| 129 | #define PTR_CHAR_POS(ptr) \ |
| 130 | ((ptr) - (current_buffer)->text.beg \ |
| 131 | - (ptr - (current_buffer)->text.beg < (unsigned) GPT ? 0 : GAP_SIZE) \ |
| 132 | + 1) |
| 133 | \f |
| 134 | struct buffer_text |
| 135 | { |
| 136 | unsigned char *beg; /* Actual address of buffer contents. */ |
| 137 | int begv; /* Index of beginning of accessible range. */ |
| 138 | int pt; /* Position of point in buffer. */ |
| 139 | int gpt; /* Index of gap in buffer. */ |
| 140 | int zv; /* Index of end of accessible range. */ |
| 141 | int z; /* Index of end of buffer. */ |
| 142 | int gap_size; /* Size of buffer's gap */ |
| 143 | int modiff; /* This counts buffer-modification events |
| 144 | for this buffer. It is incremented for |
| 145 | each such event, and never otherwise |
| 146 | changed. */ |
| 147 | }; |
| 148 | |
| 149 | struct buffer |
| 150 | { |
| 151 | /* Everything before the `name' slot must be of a non-Lisp_Object type, |
| 152 | and every slot after `name' must be a Lisp_Object. |
| 153 | |
| 154 | Check out mark_buffer (alloc.c) to see why. |
| 155 | */ |
| 156 | |
| 157 | /* This structure holds the coordinates of the buffer contents. */ |
| 158 | struct buffer_text text; |
| 159 | /* Next buffer, in chain of all buffers including killed buffers. |
| 160 | This chain is used only for garbage collection, in order to |
| 161 | collect killed buffers properly. */ |
| 162 | struct buffer *next; |
| 163 | /* Flags saying which DEFVAR_PER_BUFFER variables |
| 164 | are local to this buffer. */ |
| 165 | int local_var_flags; |
| 166 | /* Value of text.modiff as of when visited file was read or written. */ |
| 167 | int save_modified; |
| 168 | /* Set to the modtime of the visited file when read or written. |
| 169 | -1 means visited file was nonexistent. |
| 170 | 0 means visited file modtime unknown; in no case complain |
| 171 | about any mismatch on next save attempt. */ |
| 172 | int modtime; |
| 173 | /* the value of text.modiff at the last auto-save. */ |
| 174 | int auto_save_modified; |
| 175 | /* Position in buffer at which display started |
| 176 | the last time this buffer was displayed */ |
| 177 | int last_window_start; |
| 178 | |
| 179 | /* Properties of this buffer's text -- conditionally compiled. */ |
| 180 | DECLARE_INTERVALS |
| 181 | |
| 182 | /* This is a special exception -- as this slot should not be |
| 183 | marked by gc_sweep, and as it is not lisp-accessible as |
| 184 | a local variable -- so we regard it as not really being of type |
| 185 | Lisp_Object */ |
| 186 | /* the markers that refer to this buffer. |
| 187 | This is actually a single marker --- |
| 188 | successive elements in its marker `chain' |
| 189 | are the other markers referring to this |
| 190 | buffer */ |
| 191 | Lisp_Object markers; |
| 192 | |
| 193 | |
| 194 | /* Everything from here down must be a Lisp_Object */ |
| 195 | |
| 196 | |
| 197 | /* the name of this buffer */ |
| 198 | Lisp_Object name; |
| 199 | /* Nuked: buffer number, assigned when buffer made Lisp_Object number;*/ |
| 200 | /* the name of the file associated with this buffer */ |
| 201 | Lisp_Object filename; |
| 202 | /* Dir for expanding relative pathnames */ |
| 203 | Lisp_Object directory; |
| 204 | /* true iff this buffer has been been backed |
| 205 | up (if you write to its associated file |
| 206 | and it hasn't been backed up, then a |
| 207 | backup will be made) */ |
| 208 | /* This isn't really used by the C code, so could be deleted. */ |
| 209 | Lisp_Object backed_up; |
| 210 | /* Length of file when last read or saved. */ |
| 211 | Lisp_Object save_length; |
| 212 | /* file name used for auto-saving this buffer */ |
| 213 | Lisp_Object auto_save_file_name; |
| 214 | /* Non-nil if buffer read-only */ |
| 215 | Lisp_Object read_only; |
| 216 | /* "The mark"; no longer allowed to be nil */ |
| 217 | Lisp_Object mark; |
| 218 | |
| 219 | /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER) |
| 220 | for all per-buffer variables of this buffer. */ |
| 221 | Lisp_Object local_var_alist; |
| 222 | |
| 223 | |
| 224 | /* Symbol naming major mode (eg lisp-mode) */ |
| 225 | Lisp_Object major_mode; |
| 226 | /* Pretty name of major mode (eg "Lisp") */ |
| 227 | Lisp_Object mode_name; |
| 228 | /* Format string for mode line */ |
| 229 | Lisp_Object mode_line_format; |
| 230 | |
| 231 | /* Keys that are bound local to this buffer */ |
| 232 | Lisp_Object keymap; |
| 233 | /* This buffer's local abbrev table */ |
| 234 | Lisp_Object abbrev_table; |
| 235 | /* This buffer's syntax table. */ |
| 236 | Lisp_Object syntax_table; |
| 237 | |
| 238 | /* Values of several buffer-local variables */ |
| 239 | /* tab-width is buffer-local so that redisplay can find it |
| 240 | in buffers that are not current */ |
| 241 | Lisp_Object case_fold_search; |
| 242 | Lisp_Object tab_width; |
| 243 | Lisp_Object fill_column; |
| 244 | Lisp_Object left_margin; |
| 245 | /* Function to call when insert space past fill column */ |
| 246 | Lisp_Object auto_fill_function; |
| 247 | |
| 248 | /* String of length 256 mapping each char to its lower-case version. */ |
| 249 | Lisp_Object downcase_table; |
| 250 | /* String of length 256 mapping each char to its upper-case version. */ |
| 251 | Lisp_Object upcase_table; |
| 252 | |
| 253 | /* Non-nil means do not display continuation lines */ |
| 254 | Lisp_Object truncate_lines; |
| 255 | /* Non-nil means display ctl chars with uparrow */ |
| 256 | Lisp_Object ctl_arrow; |
| 257 | /* Non-nil means do selective display; |
| 258 | See doc string in syms_of_buffer (buffer.c) for details. */ |
| 259 | Lisp_Object selective_display; |
| 260 | #ifndef old |
| 261 | /* Non-nil means show ... at end of line followed by invisible lines. */ |
| 262 | Lisp_Object selective_display_ellipses; |
| 263 | #endif |
| 264 | /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer. */ |
| 265 | Lisp_Object minor_modes; |
| 266 | /* t if "self-insertion" should overwrite; `binary' if it should also |
| 267 | overwrite newlines and tabs - for editing executables and the like. */ |
| 268 | Lisp_Object overwrite_mode; |
| 269 | /* non-nil means abbrev mode is on. Expand abbrevs automatically. */ |
| 270 | Lisp_Object abbrev_mode; |
| 271 | /* Display table to use for text in this buffer. */ |
| 272 | Lisp_Object display_table; |
| 273 | /* Translate table for case-folding search. */ |
| 274 | Lisp_Object case_canon_table; |
| 275 | /* Inverse translate (equivalence class) table for case-folding search. */ |
| 276 | Lisp_Object case_eqv_table; |
| 277 | /* Changes in the buffer are recorded here for undo. |
| 278 | t means don't record anything. */ |
| 279 | Lisp_Object undo_list; |
| 280 | /* t means the mark and region are currently active. */ |
| 281 | Lisp_Object mark_active; |
| 282 | |
| 283 | /* List of overlays that end at or before the current center, |
| 284 | in order of end-position. */ |
| 285 | Lisp_Object overlays_before; |
| 286 | |
| 287 | /* List of overlays that end after the current center, |
| 288 | in order of start-position. */ |
| 289 | Lisp_Object overlays_after; |
| 290 | |
| 291 | /* Position where the overlay lists are centered. */ |
| 292 | Lisp_Object overlay_center; |
| 293 | }; |
| 294 | \f |
| 295 | /* This points to the current buffer. */ |
| 296 | |
| 297 | extern struct buffer *current_buffer; |
| 298 | |
| 299 | /* This structure holds the default values of the buffer-local variables |
| 300 | that have special slots in each buffer. |
| 301 | The default value occupies the same slot in this structure |
| 302 | as an individual buffer's value occupies in that buffer. |
| 303 | Setting the default value also goes through the alist of buffers |
| 304 | and stores into each buffer that does not say it has a local value. */ |
| 305 | |
| 306 | extern struct buffer buffer_defaults; |
| 307 | |
| 308 | /* This structure marks which slots in a buffer have corresponding |
| 309 | default values in buffer_defaults. |
| 310 | Each such slot has a nonzero value in this structure. |
| 311 | The value has only one nonzero bit. |
| 312 | |
| 313 | When a buffer has its own local value for a slot, |
| 314 | the bit for that slot (found in the same slot in this structure) |
| 315 | is turned on in the buffer's local_var_flags slot. |
| 316 | |
| 317 | If a slot in this structure is zero, then even though there may |
| 318 | be a Lisp-level local variable for the slot, it has no default value, |
| 319 | and the corresponding slot in buffer_defaults is not used. */ |
| 320 | |
| 321 | extern struct buffer buffer_local_flags; |
| 322 | |
| 323 | /* For each buffer slot, this points to the Lisp symbol name |
| 324 | for that slot in the current buffer. It is 0 for slots |
| 325 | that don't have such names. */ |
| 326 | |
| 327 | extern struct buffer buffer_local_symbols; |
| 328 | |
| 329 | /* This structure holds the required types for the values in the |
| 330 | buffer-local slots. If a slot contains Qnil, then the |
| 331 | corresponding buffer slot may contain a value of any type. If a |
| 332 | slot contains an integer, then prospective values' tags must be |
| 333 | equal to that integer. When a tag does not match, the function |
| 334 | buffer_slot_type_mismatch will signal an error. The value Qnil may |
| 335 | always be safely stored in any slot. */ |
| 336 | extern struct buffer buffer_local_types; |
| 337 | \f |
| 338 | /* Point in the current buffer. This is an obsolete alias |
| 339 | and should be eliminated. */ |
| 340 | #define point (current_buffer->text.pt + 0) |
| 341 | |
| 342 | /* Return character at position n. No range checking. */ |
| 343 | #define FETCH_CHAR(n) *(((n)>= GPT ? GAP_SIZE : 0) + (n) + BEG_ADDR - 1) |
| 344 | |
| 345 | /* BUFFER_CEILING_OF (resp. BUFFER_FLOOR_OF), when applied to n, return |
| 346 | the max (resp. min) p such that |
| 347 | |
| 348 | &FETCH_CHAR (p) - &FETCH_CHAR (n) == p - n */ |
| 349 | |
| 350 | #define BUFFER_CEILING_OF(n) (((n) < GPT && GPT < ZV ? GPT : ZV) - 1) |
| 351 | #define BUFFER_FLOOR_OF(n) (BEGV <= GPT && GPT <= (n) ? GPT : BEGV) |
| 352 | |
| 353 | extern void reset_buffer (); |
| 354 | |
| 355 | extern Lisp_Object Fbuffer_name (); |
| 356 | extern Lisp_Object Fget_file_buffer (); |
| 357 | |
| 358 | /* Functions to call before and after each text change. */ |
| 359 | extern Lisp_Object Vbefore_change_function; |
| 360 | extern Lisp_Object Vafter_change_function; |
| 361 | extern Lisp_Object Vfirst_change_hook; |
| 362 | extern Lisp_Object Qfirst_change_hook; |
| 363 | |
| 364 | extern Lisp_Object Vdeactivate_mark; |
| 365 | extern Lisp_Object Vtransient_mark_mode; |
| 366 | \f |
| 367 | /* Overlays */ |
| 368 | |
| 369 | /* Overlays are ordinary Lisp objects, and users can alter their contents. |
| 370 | Therefore, we cannot assume that they remain valid--we must check. */ |
| 371 | |
| 372 | /* 1 if the OV is a cons cell whose car is a cons cell. */ |
| 373 | #define OVERLAY_VALID(OV) (CONSP ((OV)) && CONSP (XCONS ((OV))->car)) |
| 374 | |
| 375 | /* Return the marker that stands for where OV starts in the buffer. */ |
| 376 | #define OVERLAY_START(OV) (XCONS (XCONS ((OV))->car)->car) |
| 377 | |
| 378 | /* Return the marker that stands for where OV ends in the buffer. */ |
| 379 | #define OVERLAY_END(OV) (XCONS (XCONS ((OV))->car)->cdr) |
| 380 | |
| 381 | /* Return the actual buffer position for the marker P, |
| 382 | if it is a marker and points into the current buffer. |
| 383 | Otherwise, zero. */ |
| 384 | |
| 385 | #define OVERLAY_POSITION(P) \ |
| 386 | ((MARKERP ((P)) && XMARKER ((P))->buffer == current_buffer) \ |
| 387 | ? marker_position ((P)) : 0) |
| 388 | |
| 389 | |
| 390 | /* Allocation of buffer text. */ |
| 391 | |
| 392 | #ifdef REL_ALLOC |
| 393 | #define BUFFER_ALLOC(data,size) ((unsigned char *) r_alloc (&data, (size))) |
| 394 | #define BUFFER_REALLOC(data,size) ((unsigned char *) r_re_alloc (&data, (size))) |
| 395 | #define BUFFER_FREE(data) (r_alloc_free (&data)) |
| 396 | #define R_ALLOC_DECLARE(var,data) (r_alloc_declare (&var, (data))) |
| 397 | #else |
| 398 | #define BUFFER_ALLOC(data,size) (data = (unsigned char *) malloc ((size))) |
| 399 | #define BUFFER_REALLOC(data,size) ((unsigned char *) realloc ((data), (size))) |
| 400 | #define BUFFER_FREE(data) (free ((data))) |
| 401 | #define R_ALLOC_DECLARE(var,data) |
| 402 | #endif |