/* Buffer manipulation primitives for GNU Emacs.
- Copyright (C) 1985, 1986, 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1989, 1992, 1993
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
buffer_slot_type_mismatch will signal an error. */
struct buffer buffer_local_types;
-/* Nonzero means don't allow modification of protected fields. */
-
-int check_protected_fields;
-
Lisp_Object Fset_buffer ();
void set_buffer_internal ();
Lisp_Object Vbefore_change_function;
Lisp_Object Vafter_change_function;
-/* Function to call before changing an unmodified buffer. */
-Lisp_Object Vfirst_change_function;
+Lisp_Object Vtransient_mark_mode;
+
+/* List of functions to call before changing an unmodified buffer. */
+Lisp_Object Vfirst_change_hook;
+Lisp_Object Qfirst_change_hook;
Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
b->auto_save_modified = 0;
b->auto_save_file_name = Qnil;
b->read_only = Qnil;
- b->fieldlist = Qnil;
+ b->overlays_before = Qnil;
+ b->overlays_after = Qnil;
+ XFASTINT (b->overlay_center) = 1;
/* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
INITIALIZE_INTERVAL (b, NULL_INTERVAL);
reset_buffer_local_variables(b);
}
-reset_buffer_local_variables(b)
+reset_buffer_local_variables (b)
register struct buffer *b;
{
register int offset;
b->upcase_table = Vascii_upcase_table;
b->case_canon_table = Vascii_downcase_table;
b->case_eqv_table = Vascii_upcase_table;
+ b->mark_active = Qnil;
#if 0
b->sort_table = XSTRING (Vascii_sort_table);
b->folding_sort_table = XSTRING (Vascii_folding_sort_table);
}
\f
DEFUN ("rename-buffer", Frename_buffer, Srename_buffer, 1, 2,
- "sRename buffer (to new name): ",
+ "sRename buffer (to new name): \nP",
"Change current buffer's name to NEWNAME (a string).\n\
-If second arg DISTINGUISH is nil or omitted, it is an error if a\n\
+If second arg UNIQUE is nil or omitted, it is an error if a\n\
buffer named NEWNAME already exists.\n\
-If DISTINGUISH is non-nil, come up with a new name using\n\
+If UNIQUE is non-nil, come up with a new name using\n\
`generate-new-buffer-name'.\n\
-Return the name we actually gave the buffer.\n\
+Interactively, you can set UNIQUE with a prefix argument.\n\
+We return the name we actually gave the buffer.\n\
This does not change the name of the visited file (if any).")
- (name, distinguish)
- register Lisp_Object name, distinguish;
+ (name, unique)
+ register Lisp_Object name, unique;
{
register Lisp_Object tem, buf;
return current_buffer->name;
if (!NILP (tem))
{
- if (!NILP (distinguish))
+ if (!NILP (unique))
name = Fgenerate_new_buffer_name (name);
else
error ("Buffer name \"%s\" is in use", XSTRING (name)->data);
record_buffer (buf);
Fset_window_buffer (EQ (selected_window, minibuf_window)
- ? Fnext_window (minibuf_window, Qnil) : selected_window,
+ ? Fnext_window (minibuf_window, Qnil, Qnil)
+ : selected_window,
buf);
return Qnil;
XSET (buf, Lisp_Buffer, current_buffer);
/* If we're burying the current buffer, unshow it. */
- Fswitch_to_buffer (Fother_buffer (buf), Qnil);
+ Fswitch_to_buffer (Fother_buffer (buf, Qnil), Qnil);
}
else
{
return Qnil;
}
\f
-DEFUN ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 0, 0,
+DEFUN ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 0, "*",
"Delete the entire contents of the current buffer.\n\
Any clipping restriction in effect (see `narrow-to-region') is removed,\n\
so the buffer is truly empty after this.")
return Qnil;
}
\f
-DEFUN ("region-fields", Fregion_fields, Sregion_fields, 2, 4, "",
- "Return list of fields overlapping a given portion of a buffer.\n\
-The portion is specified by arguments START, END and BUFFER.\n\
-BUFFER defaults to the current buffer.\n\
-Optional 4th arg ERROR-CHECK non nil means just report an error\n\
-if any protected fields overlap this portion.")
- (start, end, buffer, error_check)
- Lisp_Object start, end, buffer, error_check;
+/* Find all the overlays in the current buffer that contain position POS.
+ Return the number found, and store them in a vector in *VEC_PTR.
+ Store in *LEN_PTR the size allocated for the vector.
+ Store in *NEXT_PTR the next position after POS where an overlay starts.
+
+ *VEC_PTR and *LEN_PTR should contain a valid vector and size
+ when this function is called. */
+
+int
+overlays_at (pos, vec_ptr, len_ptr, next_ptr)
+ int pos;
+ Lisp_Object **vec_ptr;
+ int *len_ptr;
+ int *next_ptr;
{
- register int start_loc, end_loc;
- Lisp_Object fieldlist;
- Lisp_Object collector;
+ Lisp_Object tail, overlay, start, end, result;
+ int idx = 0;
+ int len = *len_ptr;
+ Lisp_Object *vec = *vec_ptr;
+ int next = ZV;
+ int startpos;
+
+ for (tail = current_buffer->overlays_before;
+ CONSP (tail);
+ tail = XCONS (tail)->cdr)
+ {
+ overlay = XCONS (tail)->car;
+ if (! OVERLAY_VALID (overlay))
+ continue;
- if (NILP (buffer))
- fieldlist = current_buffer->fieldlist;
- else
+ start = OVERLAY_START (overlay);
+ end = OVERLAY_END (overlay);
+ if (OVERLAY_POSITION (end) <= pos)
+ break;
+ startpos = OVERLAY_POSITION (start);
+ if (startpos <= pos)
+ {
+ if (idx == len)
+ {
+ *len_ptr = len *= 2;
+ vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
+ *vec_ptr = vec;
+ }
+ vec[idx++] = overlay;
+ }
+ else if (startpos < next)
+ next = startpos;
+ }
+
+ for (tail = current_buffer->overlays_after;
+ CONSP (tail);
+ tail = XCONS (tail)->cdr)
{
- CHECK_BUFFER (buffer, 1);
- fieldlist = XBUFFER (buffer)->fieldlist;
+ overlay = XCONS (tail)->car;
+ if (! OVERLAY_VALID (overlay))
+ continue;
+
+ start = OVERLAY_START (overlay);
+ end = OVERLAY_END (overlay);
+ startpos = OVERLAY_POSITION (start);
+ if (startpos > pos)
+ {
+ if (startpos < next)
+ next = startpos;
+ break;
+ }
+ if (OVERLAY_POSITION (end) > pos)
+ {
+ if (idx == len)
+ {
+ *len_ptr = len *= 2;
+ vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
+ *vec_ptr = vec;
+ }
+ vec[idx++] = overlay;
+ }
}
- CHECK_NUMBER_COERCE_MARKER (start, 2);
- start_loc = XINT (start);
+ *next_ptr = next;
+ return idx;
+}
+\f
+/* Shift overlays in the current buffer's overlay lists,
+ to center the lists at POS. */
- CHECK_NUMBER_COERCE_MARKER (end, 2);
- end_loc = XINT (end);
-
- collector = Qnil;
-
- while (XTYPE (fieldlist) == Lisp_Cons)
+void
+recenter_overlay_lists (pos)
+ int pos;
+{
+ Lisp_Object overlay, tail, next, prev, beg, end;
+
+ /* See if anything in overlays_before should move to overlays_after. */
+
+ /* We don't strictly need prev in this loop; it should always be nil.
+ But we use it for symmetry and in case that should cease to be true
+ with some future change. */
+ prev = Qnil;
+ for (tail = current_buffer->overlays_before;
+ CONSP (tail);
+ prev = tail, tail = next)
+ {
+ next = XCONS (tail)->cdr;
+ overlay = XCONS (tail)->car;
+
+ /* If the overlay is not valid, get rid of it. */
+ if (!OVERLAY_VALID (overlay))
+ {
+ /* Splice the cons cell TAIL out of overlays_before. */
+ if (!NILP (prev))
+ XCONS (prev)->cdr = next;
+ else
+ current_buffer->overlays_before = next;
+ tail = prev;
+ continue;
+ }
+
+ beg = OVERLAY_START (overlay);
+ end = OVERLAY_END (overlay);
+
+ if (OVERLAY_POSITION (end) > pos)
+ {
+ /* OVERLAY needs to be moved. */
+ int where = OVERLAY_POSITION (beg);
+ Lisp_Object other, other_prev;
+
+ /* Splice the cons cell TAIL out of overlays_before. */
+ if (!NILP (prev))
+ XCONS (prev)->cdr = next;
+ else
+ current_buffer->overlays_before = next;
+
+ /* Search thru overlays_after for where to put it. */
+ other_prev = Qnil;
+ for (other = current_buffer->overlays_after;
+ CONSP (other);
+ other_prev = other, other = XCONS (other)->cdr)
+ {
+ Lisp_Object otherbeg, otheroverlay, follower;
+ int win;
+
+ otheroverlay = XCONS (other)->car;
+ if (! OVERLAY_VALID (otheroverlay))
+ continue;
+
+ otherbeg = OVERLAY_START (otheroverlay);
+ if (OVERLAY_POSITION (otherbeg) >= where)
+ break;
+ }
+
+ /* Add TAIL to overlays_after before OTHER. */
+ XCONS (tail)->cdr = other;
+ if (!NILP (other_prev))
+ XCONS (other_prev)->cdr = tail;
+ else
+ current_buffer->overlays_after = tail;
+ tail = prev;
+ }
+ else
+ /* We've reached the things that should stay in overlays_before.
+ All the rest of overlays_before must end even earlier,
+ so stop now. */
+ break;
+ }
+
+ /* See if anything in overlays_after should be in overlays_before. */
+ prev = Qnil;
+ for (tail = current_buffer->overlays_after;
+ CONSP (tail);
+ prev = tail, tail = next)
{
- register Lisp_Object field;
- register int field_start, field_end;
+ next = XCONS (tail)->cdr;
+ overlay = XCONS (tail)->car;
- field = XCONS (fieldlist)->car;
- field_start = marker_position (FIELD_START_MARKER (field)) - 1;
- field_end = marker_position (FIELD_END_MARKER (field));
+ /* If the overlay is not valid, get rid of it. */
+ if (!OVERLAY_VALID (overlay))
+ {
+ /* Splice the cons cell TAIL out of overlays_after. */
+ if (!NILP (prev))
+ XCONS (prev)->cdr = next;
+ else
+ current_buffer->overlays_after = next;
+ tail = prev;
+ continue;
+ }
+
+ beg = OVERLAY_START (overlay);
+ end = OVERLAY_END (overlay);
+
+ /* Stop looking, when we know that nothing further
+ can possibly end before POS. */
+ if (OVERLAY_POSITION (beg) > pos)
+ break;
- if ((start_loc < field_start && end_loc > field_start)
- || (start_loc >= field_start && start_loc < field_end))
+ if (OVERLAY_POSITION (end) <= pos)
{
- if (!NILP (error_check))
+ /* OVERLAY needs to be moved. */
+ int where = OVERLAY_POSITION (end);
+ Lisp_Object other, other_prev;
+
+ /* Splice the cons cell TAIL out of overlays_after. */
+ if (!NILP (prev))
+ XCONS (prev)->cdr = next;
+ else
+ current_buffer->overlays_after = next;
+
+ /* Search thru overlays_before for where to put it. */
+ other_prev = Qnil;
+ for (other = current_buffer->overlays_before;
+ CONSP (other);
+ other_prev = other, other = XCONS (other)->cdr)
{
- if (!NILP (FIELD_PROTECTED_FLAG (field)))
- {
- struct gcpro gcpro1;
- GCPRO1 (fieldlist);
- Fsignal (Qprotected_field, Fcons (field, Qnil));
- UNGCPRO;
- }
+ Lisp_Object otherend, otheroverlay;
+ int win;
+
+ otheroverlay = XCONS (other)->car;
+ if (! OVERLAY_VALID (otheroverlay))
+ continue;
+
+ otherend = OVERLAY_END (otheroverlay);
+ if (OVERLAY_POSITION (otherend) <= where)
+ break;
}
+
+ /* Add TAIL to overlays_before before OTHER. */
+ XCONS (tail)->cdr = other;
+ if (!NILP (other_prev))
+ XCONS (other_prev)->cdr = tail;
else
- collector = Fcons (field, collector);
+ current_buffer->overlays_before = tail;
+ tail = prev;
}
-
- fieldlist = XCONS (fieldlist)->cdr;
}
- return collector;
+ XFASTINT (current_buffer->overlay_center) = pos;
+}
+\f
+DEFUN ("make-overlay", Fmake_overlay, Smake_overlay, 2, 2, 0,
+ "Create a new overlay in the current buffer, with range BEG to END.\n\
+BEG and END may be integers or markers.")
+ (beg, end)
+ Lisp_Object beg, end;
+{
+ Lisp_Object overlay;
+
+ if (MARKERP (beg) && XBUFFER (Fmarker_buffer (beg)) != current_buffer)
+ error ("Marker points into wrong buffer");
+ if (MARKERP (end) && XBUFFER (Fmarker_buffer (end)) != current_buffer)
+ error ("Marker points into wrong buffer");
+
+ overlay = Fcons (Fcons (Fcopy_marker (beg), Fcopy_marker (end)), Qnil);
+
+ /* Put the new overlay on the wrong list. */
+ end = OVERLAY_END (overlay);
+ if (OVERLAY_POSITION (end) < XINT (current_buffer->overlay_center))
+ current_buffer->overlays_after
+ = Fcons (overlay, current_buffer->overlays_after);
+ else
+ current_buffer->overlays_before
+ = Fcons (overlay, current_buffer->overlays_before);
+
+ /* This puts it in the right list, and in the right order. */
+ recenter_overlay_lists (XINT (current_buffer->overlay_center));
+
+ return overlay;
+}
+
+DEFUN ("move-overlay", Fmove_overlay, Smove_overlay, 3, 3, 0,
+ "Set the endpoints of OVERLAY to BEG and END.")
+ (overlay, beg, end)
+ Lisp_Object overlay, beg, end;
+{
+ if (!OVERLAY_VALID (overlay))
+ error ("Invalid overlay object");
+
+ current_buffer->overlays_before
+ = Fdelq (overlay, current_buffer->overlays_before);
+ current_buffer->overlays_after
+ = Fdelq (overlay, current_buffer->overlays_after);
+
+ Fset_marker (OVERLAY_START (overlay), beg, Qnil);
+ Fset_marker (OVERLAY_END (overlay), end, Qnil);
+
+ /* Put the overlay on the wrong list. */
+ end = OVERLAY_END (overlay);
+ if (OVERLAY_POSITION (end) < XINT (current_buffer->overlay_center))
+ current_buffer->overlays_after
+ = Fcons (overlay, current_buffer->overlays_after);
+ else
+ current_buffer->overlays_before
+ = Fcons (overlay, current_buffer->overlays_before);
+
+ /* This puts it in the right list, and in the right order. */
+ recenter_overlay_lists (XINT (current_buffer->overlay_center));
+
+ return overlay;
+}
+
+DEFUN ("delete-overlay", Fdelete_overlay, Sdelete_overlay, 1, 1, 0,
+ "Delete the overlay OVERLAY from the current buffer.")
+ (overlay)
+{
+ current_buffer->overlays_before
+ = Fdelq (overlay, current_buffer->overlays_before);
+ current_buffer->overlays_after
+ = Fdelq (overlay, current_buffer->overlays_after);
+ return Qnil;
+}
+\f
+DEFUN ("overlays-at", Foverlays_at, Soverlays_at, 1, 1, 0,
+ "Return a list of the overays that contain position POS.")
+ (pos)
+ Lisp_Object pos;
+{
+ int noverlays;
+ int endpos;
+ Lisp_Object *overlay_vec;
+ int len;
+ Lisp_Object result;
+
+ CHECK_NUMBER_COERCE_MARKER (pos, 0);
+
+ len = 10;
+ overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
+
+ /* Put all the overlays we want in a vector in overlay_vec.
+ Store the length in len. */
+ noverlays = overlays_at (XINT (pos), &overlay_vec, &len, &endpos);
+
+ /* Make a list of them all. */
+ result = Flist (noverlays, overlay_vec);
+
+ free (overlay_vec);
+ return result;
+}
+
+DEFUN ("next-overlay-change", Fnext_overlay_change, Snext_overlay_change,
+ 1, 1, 0,
+ "Return the next position after POS where an overlay starts or ends.")
+ (pos)
+ Lisp_Object pos;
+{
+ int noverlays;
+ int endpos;
+ Lisp_Object *overlay_vec;
+ int len;
+ Lisp_Object result;
+ int i;
+
+ CHECK_NUMBER_COERCE_MARKER (pos, 0);
+
+ len = 10;
+ overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
+
+ /* Put all the overlays we want in a vector in overlay_vec.
+ Store the length in len.
+ endpos gets the position where the next overlay starts. */
+ noverlays = overlays_at (XINT (pos), &overlay_vec, &len, &endpos);
+
+ /* If any of these overlays ends before endpos,
+ use its ending point instead. */
+ for (i = 0; i < noverlays; i++)
+ {
+ Lisp_Object oend;
+ int oendpos;
+
+ oend = OVERLAY_END (overlay_vec[i]);
+ oendpos = OVERLAY_POSITION (oend);
+ if (oendpos < endpos)
+ endpos = oendpos;
+ }
+
+ free (overlay_vec);
+ return make_number (endpos);
+}
+\f
+/* These functions are for debugging overlays. */
+
+DEFUN ("overlay-lists", Foverlay_lists, Soverlay_lists, 0, 0, 0,
+ "Return a pair of lists giving all the overlays of the current buffer.\n\
+The car has all the overlays before the overlay center;\n\
+the cdr has all the overlays before the overlay center.\n\
+Recentering overlays moves overlays between these lists.\n\
+The lists you get are copies, so that changing them has no effect.\n\
+However, the overlays you get are the real objects that the buffer uses.")
+ ()
+{
+ Lisp_Object before, after;
+ before = current_buffer->overlays_before;
+ if (CONSP (before))
+ before = Fcopy_sequence (before);
+ after = current_buffer->overlays_after;
+ if (CONSP (after))
+ after = Fcopy_sequence (after);
+
+ return Fcons (before, after);
+}
+
+DEFUN ("overlay-recenter", Foverlay_recenter, Soverlay_recenter, 1, 1, 0,
+ "Recenter the overlays of the current buffer around position POS.")
+ (pos)
+ Lisp_Object pos;
+{
+ CHECK_NUMBER_COERCE_MARKER (pos, 0);
+
+ recenter_overlay_lists (XINT (pos));
+ return Qnil;
+}
+\f
+DEFUN ("overlay-get", Foverlay_get, Soverlay_get, 2, 2, 0,
+ "Get the property of overlay OVERLAY with property name NAME.")
+ (overlay, prop)
+ Lisp_Object overlay, prop;
+{
+ Lisp_Object plist;
+ for (plist = Fcdr_safe (Fcdr_safe (overlay));
+ CONSP (plist) && CONSP (XCONS (plist)->cdr);
+ plist = XCONS (XCONS (plist)->cdr)->cdr)
+ {
+ if (EQ (XCONS (plist)->car, prop))
+ return XCONS (XCONS (plist)->cdr)->car;
+ }
+}
+
+DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
+ "Set one property of overlay OVERLAY: give property PROP value VALUE.")
+ (overlay, prop, value)
+ Lisp_Object overlay, prop, value;
+{
+ Lisp_Object plist, tail;
+
+ plist = Fcdr_safe (Fcdr_safe (overlay));
+
+ for (tail = plist;
+ CONSP (tail) && CONSP (XCONS (tail)->cdr);
+ tail = XCONS (XCONS (tail)->cdr)->cdr)
+ {
+ if (EQ (XCONS (tail)->car, prop))
+ return XCONS (XCONS (tail)->cdr)->car = value;
+ }
+
+ if (! CONSP (XCONS (overlay)->cdr))
+ XCONS (overlay)->cdr = Fcons (Qnil, Qnil);
+
+ XCONS (XCONS (overlay)->cdr)->cdr
+ = Fcons (prop, Fcons (value, plist));
+
+ return value;
}
\f
/* Somebody has tried to store NEWVAL into the buffer-local slot with
Lisp_Object valcontents, newval;
{
unsigned int offset = XUINT (valcontents);
- char *symbol_name =
+ unsigned char *symbol_name =
(XSYMBOL (*(Lisp_Object *)(offset + (char *)&buffer_local_symbols))
->name->data);
char *type_name;
case Lisp_Marker: type_name = "markers"; break;
case Lisp_Symbol: type_name = "symbols"; break;
case Lisp_Cons: type_name = "lists"; break;
- case Lisp_Vector: type_name = "vector"; break;
+ case Lisp_Vector: type_name = "vectors"; break;
default:
abort ();
}
#endif
buffer_defaults.abbrev_table = Qnil;
buffer_defaults.display_table = Qnil;
- buffer_defaults.fieldlist = Qnil;
buffer_defaults.undo_list = Qnil;
+ buffer_defaults.mark_active = Qnil;
+ buffer_defaults.overlays_before = Qnil;
+ buffer_defaults.overlays_after = Qnil;
+ XFASTINT (buffer_defaults.overlay_center) = 1;
XFASTINT (buffer_defaults.tab_width) = 8;
buffer_defaults.truncate_lines = Qnil;
XFASTINT (buffer_local_flags.major_mode) = -1;
XFASTINT (buffer_local_flags.mode_name) = -1;
XFASTINT (buffer_local_flags.undo_list) = -1;
+ XFASTINT (buffer_local_flags.mark_active) = -1;
XFASTINT (buffer_local_flags.mode_line_format) = 1;
XFASTINT (buffer_local_flags.abbrev_mode) = 2;
XFASTINT (buffer_local_flags.left_margin) = 0x800;
XFASTINT (buffer_local_flags.abbrev_table) = 0x1000;
XFASTINT (buffer_local_flags.display_table) = 0x2000;
- XFASTINT (buffer_local_flags.fieldlist) = 0x4000;
XFASTINT (buffer_local_flags.syntax_table) = 0x8000;
Vbuffer_alist = Qnil;
/* initialize the buffer routines */
syms_of_buffer ()
{
+ extern Lisp_Object Qdisabled;
+
staticpro (&Vbuffer_defaults);
staticpro (&Vbuffer_local_symbols);
staticpro (&Qfundamental_mode);
Fput (Qprotected_field, Qerror_message,
build_string ("Attempt to modify a protected field"));
+ Fput (intern ("erase-buffer"), Qdisabled, Qt);
+
/* All these use DEFVAR_LISP_NOPRO because the slots in
buffer_defaults will all be marked via Vbuffer_defaults. */
/* This doc string is too long for cpp; cpp dies if it isn't in a comment.
But make-docfile finds it!
DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
+ Qnil,
"Template for displaying mode line for current buffer.\n\
Each buffer has its own value of this variable.\n\
Value may be a string, a symbol or a list or cons cell.\n\
DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer->overwrite_mode, Qnil,
"Non-nil if self-insertion should replace existing text.\n\
+If non-nil and not `overwrite-mode-binary', self-insertion still\n\
+inserts at the end of a line, and inserts when point is before a tab,\n\
+until the tab is filled in.\n\
+If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
Automatically becomes buffer-local when set in any fashion.");
DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer->display_table,
If this variable is nil, the value of `standard-display-table' is used.\n\
Each window can have its own, overriding display table.");
- DEFVAR_PER_BUFFER ("buffer-field-list", ¤t_buffer->fieldlist, Qnil,
- "List of fields in the current buffer. See `add-field'.");
-
- DEFVAR_BOOL ("check-protected-fields", check_protected_fields,
- "Non-nil means don't allow modification of a protected field.\n\
-See `add-field'.");
- check_protected_fields = 0;
-
/*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
"Don't ask.");
*/
cause calls to any `before-change-function' or `after-change-function'.");
Vafter_change_function = Qnil;
- DEFVAR_LISP ("first-change-function", &Vfirst_change_function,
- "Function to call before changing a buffer which is unmodified.\n\
-The function is called, with no arguments, if it is non-nil.");
- Vfirst_change_function = Qnil;
+ DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook,
+ "A list of functions to call before changing a buffer which is unmodified.\n\
+The functions are run using the `run-hooks' function.");
+ Vfirst_change_hook = Qnil;
+ Qfirst_change_hook = intern ("first-change-hook");
+ staticpro (&Qfirst_change_hook);
DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer->undo_list, Qnil,
"List of undo entries in current buffer.\n\
modification count of the most recent save is different, this entry is\n\
obsolete.\n\
\n\
+An entry (nil PROP VAL BEG . END) indicates that a text property\n\
+was modified between BEG and END. PROP is the property name,\n\
+and VAL is the old value.\n\
+\n\
+An entry of the form POSITION indicates that point was at the buffer\n\
+location given by the integer. Undoing an entry of this form places\n\
+point at POSITION.\n\
+\n\
nil marks undo boundaries. The undo command treats the changes\n\
between two undo boundaries as a single step to be undone.\n\
\n\
-If the value of the variable is t, undo information is not recorded.\n\
-");
+If the value of the variable is t, undo information is not recorded.");
+
+ DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer->mark_active, Qnil,
+ "Non-nil means the mark and region are currently active in this buffer.\n\
+Automatically local in all buffers.");
+
+ DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode,
+ "*Non-nil means deactivate the mark when the buffer contents change.");
+ Vtransient_mark_mode = Qnil;
defsubr (&Sbuffer_list);
defsubr (&Sget_buffer);
defsubr (&Sbury_buffer);
defsubr (&Slist_buffers);
defsubr (&Skill_all_local_variables);
- defsubr (&Sregion_fields);
+
+ defsubr (&Smake_overlay);
+ defsubr (&Sdelete_overlay);
+ defsubr (&Smove_overlay);
+ defsubr (&Soverlays_at);
+ defsubr (&Snext_overlay_change);
+ defsubr (&Soverlay_recenter);
+ defsubr (&Soverlay_lists);
+ defsubr (&Soverlay_get);
+ defsubr (&Soverlay_put);
}
keys_of_buffer ()