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