/* Buffer manipulation primitives for GNU Emacs.
- Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993
+ Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#define MAXPATHLEN 1024
#endif /* not MAXPATHLEN */
-#include "config.h"
+#include <config.h>
#include "lisp.h"
#include "intervals.h"
#include "window.h"
#include "commands.h"
#include "buffer.h"
-#include "syntax.h"
#include "indent.h"
#include "blockinput.h"
/* Functions to call before and after each text change. */
Lisp_Object Vbefore_change_function;
Lisp_Object Vafter_change_function;
+Lisp_Object Vbefore_change_functions;
+Lisp_Object Vafter_change_functions;
Lisp_Object Vtransient_mark_mode;
Any non-nil value means ignore buffer-read-only. */
Lisp_Object Vinhibit_read_only;
+/* List of functions to call that can query about killing a buffer.
+ If any of these functions returns nil, we don't kill it. */
+Lisp_Object Vkill_buffer_query_functions;
+
/* List of functions to call before changing an unmodified buffer. */
Lisp_Object Vfirst_change_hook;
Lisp_Object Qfirst_change_hook;
Lisp_Object Qkill_buffer_hook;
+Lisp_Object Qget_file_buffer;
+
Lisp_Object Qoverlayp;
+Lisp_Object Qpriority, Qwindow;
+
+Lisp_Object Qmodification_hooks;
+Lisp_Object Qinsert_in_front_hooks;
+Lisp_Object Qinsert_behind_hooks;
+
/* For debugging; temporary. See set_buffer_internal. */
/* Lisp_Object Qlisp_mode, Vcheck_symbol; */
DEFUN ("get-file-buffer", Fget_file_buffer, Sget_file_buffer, 1, 1, 0,
"Return the buffer visiting file FILENAME (a string).\n\
+The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.\n\
If there is no such live buffer, return nil.")
(filename)
register Lisp_Object filename;
{
register Lisp_Object tail, buf, tem;
+ Lisp_Object handler;
+
CHECK_STRING (filename, 0);
filename = Fexpand_file_name (filename, Qnil);
+ /* If the file name has special constructs in it,
+ call the corresponding file handler. */
+ handler = Ffind_file_name_handler (filename, Qget_file_buffer);
+ if (!NILP (handler))
+ return call2 (handler, Qget_file_buffer, filename);
+
for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
{
buf = Fcdr (XCONS (tail)->car);
if (!NILP (buf))
return buf;
+ if (XSTRING (name)->size == 0)
+ error ("Empty string for buffer name is not allowed");
+
b = (struct buffer *) xmalloc (sizeof (struct buffer));
BUF_GAP_SIZE (b) = 20;
b->last_window_start = 1;
b->backed_up = Qnil;
b->auto_save_modified = 0;
+ b->auto_save_failure_time = -1;
b->auto_save_file_name = Qnil;
b->read_only = Qnil;
b->overlays_before = Qnil;
b->minor_modes = Qnil;
b->downcase_table = Vascii_downcase_table;
b->upcase_table = Vascii_upcase_table;
- b->case_canon_table = Vascii_downcase_table;
- b->case_eqv_table = Vascii_upcase_table;
+ b->case_canon_table = Vascii_canon_table;
+ b->case_eqv_table = Vascii_eqv_table;
#if 0
b->sort_table = XSTRING (Vascii_sort_table);
b->folding_sort_table = XSTRING (Vascii_folding_sort_table);
DEFUN ("buffer-local-variables", Fbuffer_local_variables,
Sbuffer_local_variables, 0, 1, 0,
"Return an alist of variables that are buffer-local in BUFFER.\n\
-Each element looks like (SYMBOL . VALUE) and describes one variable.\n\
+Most elements look like (SYMBOL . VALUE), describing one variable.\n\
+For a symbol that is locally unbound, just the symbol appears in the value.\n\
Note that storing new VALUEs in these elements doesn't change the variables.\n\
No argument or nil as argument means use current buffer as BUFFER.")
(buffer)
register Lisp_Object buffer;
{
register struct buffer *buf;
- register Lisp_Object val;
+ register Lisp_Object result;
if (NILP (buffer))
buf = current_buffer;
buf = XBUFFER (buffer);
}
+ result = Qnil;
+
{
/* Reference each variable in the alist in our current buffer.
If inquiring about the current buffer, this gets the current values,
so store them into the alist so the alist is up to date.
If inquiring about some other buffer, this swaps out any values
for that buffer, making the alist up to date automatically. */
- register Lisp_Object tem;
- for (tem = buf->local_var_alist; CONSP (tem); tem = XCONS (tem)->cdr)
+ register Lisp_Object tail;
+ for (tail = buf->local_var_alist; CONSP (tail); tail = XCONS (tail)->cdr)
{
- Lisp_Object v1 = Fsymbol_value (XCONS (XCONS (tem)->car)->car);
+ Lisp_Object val, elt;
+
+ elt = XCONS (tail)->car;
+
if (buf == current_buffer)
- XCONS (XCONS (tem)->car)->cdr = v1;
+ val = find_symbol_value (XCONS (elt)->car);
+ else
+ val = XCONS (elt)->cdr;
+
+ /* If symbol is unbound, put just the symbol in the list. */
+ if (EQ (val, Qunbound))
+ result = Fcons (XCONS (elt)->car, result);
+ /* Otherwise, put (symbol . value) in the list. */
+ else
+ result = Fcons (Fcons (XCONS (elt)->car, val), result);
}
}
- /* Make a copy of the alist, to return it. */
- val = Fcopy_alist (buf->local_var_alist);
-
/* Add on all the variables stored in special slots. */
{
register int offset, mask;
if (mask == -1 || (buf->local_var_flags & mask))
if (XTYPE (*(Lisp_Object *)(offset + (char *)&buffer_local_symbols))
== Lisp_Symbol)
- val = Fcons (Fcons (*(Lisp_Object *)(offset + (char *)&buffer_local_symbols),
- *(Lisp_Object *)(offset + (char *)buf)),
- val);
+ result = Fcons (Fcons (*(Lisp_Object *)(offset + (char *)&buffer_local_symbols),
+ *(Lisp_Object *)(offset + (char *)buf)),
+ result);
}
}
- return (val);
+
+ return result;
}
\f
register Lisp_Object tem, buf;
CHECK_STRING (name, 0);
+
+ if (XSTRING (name)->size == 0)
+ error ("Empty string is invalid as a buffer name");
+
tem = Fget_buffer (name);
- if (XBUFFER (tem) == current_buffer)
+ /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
+ the buffer automatically so you can create another with the original name.
+ It makes UNIQUE equivalent to
+ (rename-buffer (generate-new-buffer-name NAME)). */
+ if (NILP (unique) && XBUFFER (tem) == current_buffer)
return current_buffer->name;
if (!NILP (tem))
{
return Fget_buffer_create (build_string ("*scratch*"));
}
\f
-DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, Sbuffer_disable_undo, 1,1,
+DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, Sbuffer_disable_undo, 0, 1,
0,
- "Make BUFFER stop keeping undo information.")
+ "Make BUFFER stop keeping undo information.\n\
+No argument or nil as argument means do this for the current buffer.")
(buffer)
register Lisp_Object buffer;
{
return Qnil;
}
- /* Run kill-buffer hook with the buffer to be killed the current buffer. */
+ /* Run hooks with the buffer to be killed the current buffer. */
{
register Lisp_Object val;
int count = specpdl_ptr - specpdl;
+ Lisp_Object list;
record_unwind_protect (save_excursion_restore, save_excursion_save ());
set_buffer_internal (b);
- call1 (Vrun_hooks, Qkill_buffer_hook);
+
+ /* First run the query functions; if any query is answered no,
+ don't kill the buffer. */
+ for (list = Vkill_buffer_query_functions; !NILP (list); list = Fcdr (list))
+ {
+ tem = call0 (Fcar (list));
+ if (NILP (tem))
+ return unbind_to (count, Qnil);
+ }
+
+ /* Then run the hooks. */
+ if (!NILP (Vrun_hooks))
+ call1 (Vrun_hooks, Qkill_buffer_hook);
unbind_to (count, Qnil);
}
\f
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\
+Any narrowing restriction in effect (see `narrow-to-region') is removed,\n\
so the buffer is truly empty after this.")
()
{
args_out_of_range (*b, *e);
}
\f
-Lisp_Object
+static Lisp_Object
list_buffers_1 (files)
Lisp_Object files;
{
XFASTINT (minspace) = 1;
Fset_buffer (Vstandard_output);
-
- tail = intern ("Buffer-menu-mode");
- if (!EQ (tail, current_buffer->major_mode)
- && (tem = Ffboundp (tail), !NILP (tem)))
- call0 (tail);
Fbuffer_disable_undo (Vstandard_output);
current_buffer->read_only = Qnil;
write_string ("\n", -1);
}
- current_buffer->read_only = Qt;
+ tail = intern ("Buffer-menu-mode");
+ if ((tem = Ffboundp (tail), !NILP (tem)))
+ call0 (tail);
set_buffer_internal (old);
return desired_point;
}
{
Lisp_Object desired_point;
- desired_point =
- internal_with_output_to_temp_buffer ("*Buffer List*",
- list_buffers_1, files);
+ desired_point
+ = internal_with_output_to_temp_buffer ("*Buffer List*",
+ list_buffers_1, files);
if (NUMBERP (desired_point))
{
SET_PT (XINT (desired_point));
return unbind_to (count, Qnil);
}
+ return Qnil;
}
DEFUN ("kill-all-local-variables", Fkill_all_local_variables, Skill_all_local_variables,
Every function to select a new major mode starts by\n\
calling this function.\n\n\
As a special exception, local variables whose names have\n\
-a non-nil `permanent-local' property are not eliminated by this function.")
+a non-nil `permanent-local' property are not eliminated by this function.\n\
+\n\
+The first thing this function does is run\n\
+the normal hook `change-major-mode-hook'.")
()
{
register Lisp_Object alist, sym, tem;
Lisp_Object oalist;
+
+ if (!NILP (Vrun_hooks))
+ call1 (Vrun_hooks, intern ("change-major-mode-hook"));
oalist = current_buffer->local_var_alist;
/* Make sure no local variables remain set up with this buffer
it is currently set up for. This is so that, if the
local is marked permanent, and we make it local again below,
we don't lose the value. */
- XCONS (XCONS (tem)->car)->cdr = XCONS (XSYMBOL (sym)->value)->car;
+ XCONS (XCONS (tem)->car)->cdr
+ = do_symval_forwarding (XCONS (XSYMBOL (sym)->value)->car);
/* Switch to the symbol's default-value alist entry. */
XCONS (tem)->car = tem;
/* Mark it as current for the current buffer. */
int inhibit_storing = 0;
for (tail = current_buffer->overlays_before;
- CONSP (tail);
+ XGCTYPE (tail) == Lisp_Cons;
tail = XCONS (tail)->cdr)
{
int startpos;
overlay = XCONS (tail)->car;
- if (! OVERLAY_VALID (overlay))
+ if (XGCTYPE (overlay) != Lisp_Overlay)
abort ();
start = OVERLAY_START (overlay);
}
for (tail = current_buffer->overlays_after;
- CONSP (tail);
+ XGCTYPE (tail) == Lisp_Cons;
tail = XCONS (tail)->cdr)
{
int startpos;
overlay = XCONS (tail)->car;
- if (! OVERLAY_VALID (overlay))
+ if (XGCTYPE (overlay) != Lisp_Overlay)
abort ();
start = OVERLAY_START (overlay);
return idx;
}
\f
+struct sortvec
+{
+ Lisp_Object overlay;
+ int beg, end;
+ int priority;
+};
+
+static int
+compare_overlays (s1, s2)
+ struct sortvec *s1, *s2;
+{
+ if (s1->priority != s2->priority)
+ return s1->priority - s2->priority;
+ if (s1->beg != s2->beg)
+ return s1->beg - s2->beg;
+ if (s1->end != s2->end)
+ return s2->end - s1->end;
+ return 0;
+}
+
+/* Sort an array of overlays by priority. The array is modified in place.
+ The return value is the new size; this may be smaller than the original
+ size if some of the overlays were invalid or were window-specific. */
+int
+sort_overlays (overlay_vec, noverlays, w)
+ Lisp_Object *overlay_vec;
+ int noverlays;
+ struct window *w;
+{
+ int i, j;
+ struct sortvec *sortvec;
+ sortvec = (struct sortvec *) alloca (noverlays * sizeof (struct sortvec));
+
+ /* Put the valid and relevant overlays into sortvec. */
+
+ for (i = 0, j = 0; i < noverlays; i++)
+ {
+ Lisp_Object tem;
+ Lisp_Object overlay;
+
+ overlay = overlay_vec[i];
+ if (OVERLAY_VALID (overlay)
+ && OVERLAY_POSITION (OVERLAY_START (overlay)) > 0
+ && OVERLAY_POSITION (OVERLAY_END (overlay)) > 0)
+ {
+ /* If we're interested in a specific window, then ignore
+ overlays that are limited to some other window. */
+ if (w)
+ {
+ Lisp_Object window;
+
+ window = Foverlay_get (overlay, Qwindow);
+ if (XTYPE (window) == Lisp_Window && XWINDOW (window) != w)
+ continue;
+ }
+
+ /* This overlay is good and counts: put it into sortvec. */
+ sortvec[j].overlay = overlay;
+ sortvec[j].beg = OVERLAY_POSITION (OVERLAY_START (overlay));
+ sortvec[j].end = OVERLAY_POSITION (OVERLAY_END (overlay));
+ tem = Foverlay_get (overlay, Qpriority);
+ if (INTEGERP (tem))
+ sortvec[j].priority = XINT (tem);
+ else
+ sortvec[j].priority = 0;
+ j++;
+ }
+ }
+ noverlays = j;
+
+ /* Sort the overlays into the proper order: increasing priority. */
+
+ if (noverlays > 1)
+ qsort (sortvec, noverlays, sizeof (struct sortvec), compare_overlays);
+
+ for (i = 0; i < noverlays; i++)
+ overlay_vec[i] = sortvec[i].overlay;
+ return (noverlays);
+}
+\f
/* Shift overlays in BUF's overlay lists, to center the lists at POS. */
void
XFASTINT (buf->overlay_center) = pos;
}
+
+/* Fix up overlays that were garbled as a result of permuting markers
+ in the range START through END. Any overlay with at least one
+ endpoint in this range will need to be unlinked from the overlay
+ list and reinserted in its proper place.
+ Such an overlay might even have negative size at this point.
+ If so, we'll reverse the endpoints. Can you think of anything
+ better to do in this situation? */
+void
+fix_overlays_in_range (start, end)
+ register int start, end;
+{
+ Lisp_Object tem, overlay;
+ Lisp_Object before_list, after_list;
+ Lisp_Object *ptail, *pbefore = &before_list, *pafter = &after_list;
+ int startpos, endpos;
+
+ /* This algorithm shifts links around instead of consing and GCing.
+ The loop invariant is that before_list (resp. after_list) is a
+ well-formed list except that its last element, the one that
+ *pbefore (resp. *pafter) points to, is still uninitialized.
+ So it's not a bug that before_list isn't initialized, although
+ it may look strange. */
+ for (ptail = ¤t_buffer->overlays_before; CONSP (*ptail);)
+ {
+ overlay = XCONS (*ptail)->car;
+ endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
+ if (endpos < start)
+ break;
+ startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
+ if (endpos < end
+ || (startpos >= start && startpos < end))
+ {
+ /* If the overlay is backwards, fix that now. */
+ if (startpos > endpos)
+ {
+ int tem;
+ Fset_marker (OVERLAY_START (overlay), endpos, Qnil);
+ Fset_marker (OVERLAY_END (overlay), startpos, Qnil);
+ tem = startpos; startpos = endpos; endpos = tem;
+ }
+ /* Add it to the end of the wrong list. Later on,
+ recenter_overlay_lists will move it to the right place. */
+ if (endpos < XINT (current_buffer->overlay_center))
+ {
+ *pafter = *ptail;
+ pafter = &XCONS (*ptail)->cdr;
+ }
+ else
+ {
+ *pbefore = *ptail;
+ pbefore = &XCONS (*ptail)->cdr;
+ }
+ *ptail = XCONS (*ptail)->cdr;
+ }
+ else
+ ptail = &XCONS (*ptail)->cdr;
+ }
+ for (ptail = ¤t_buffer->overlays_after; CONSP (*ptail);)
+ {
+ overlay = XCONS (*ptail)->car;
+ startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
+ if (startpos >= end)
+ break;
+ endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
+ if (startpos >= start
+ || (endpos >= start && endpos < end))
+ {
+ if (startpos > endpos)
+ {
+ int tem;
+ Fset_marker (OVERLAY_START (overlay), endpos, Qnil);
+ Fset_marker (OVERLAY_END (overlay), startpos, Qnil);
+ tem = startpos; startpos = endpos; endpos = tem;
+ }
+ if (endpos < XINT (current_buffer->overlay_center))
+ {
+ *pafter = *ptail;
+ pafter = &XCONS (*ptail)->cdr;
+ }
+ else
+ {
+ *pbefore = *ptail;
+ pbefore = &XCONS (*ptail)->cdr;
+ }
+ *ptail = XCONS (*ptail)->cdr;
+ }
+ else
+ ptail = &XCONS (*ptail)->cdr;
+ }
+
+ /* Splice the constructed (wrong) lists into the buffer's lists,
+ and let the recenter function make it sane again. */
+ *pbefore = current_buffer->overlays_before;
+ current_buffer->overlays_before = before_list;
+ recenter_overlay_lists (current_buffer,
+ XINT (current_buffer->overlay_center));
+
+ *pafter = current_buffer->overlays_after;
+ current_buffer->overlays_after = after_list;
+ recenter_overlay_lists (current_buffer,
+ XINT (current_buffer->overlay_center));
+}
\f
DEFUN ("overlayp", Foverlayp, Soverlayp, 1, 1, 0,
"Return t if OBJECT is an overlay.")
if (XINT (beg) > XINT (end))
{
- Lisp_Object temp = beg;
- beg = end; end = temp;
+ Lisp_Object temp;
+ temp = beg; beg = end; end = temp;
}
b = XBUFFER (buffer);
if (XINT (beg) > XINT (end))
{
- Lisp_Object temp = beg;
- beg = end; end = temp;
+ Lisp_Object temp;
+ temp = beg; beg = end; end = temp;
}
obuffer = Fmarker_buffer (OVERLAY_START (overlay));
else
/* Redisplay the area the overlay has just left, or just enclosed. */
{
- Lisp_Object o_beg = OVERLAY_START (overlay);
- Lisp_Object o_end = OVERLAY_END (overlay);
+ Lisp_Object o_beg;
+ Lisp_Object o_end;
int change_beg, change_end;
+ o_beg = OVERLAY_START (overlay);
+ o_end = OVERLAY_END (overlay);
o_beg = OVERLAY_POSITION (o_beg);
o_end = OVERLAY_POSITION (o_end);
b->overlays_after = Fdelq (overlay, b->overlays_after);
redisplay_region (b,
- OVERLAY_POSITION (OVERLAY_START (overlay)),
- OVERLAY_POSITION (OVERLAY_END (overlay)));
+ marker_position (OVERLAY_START (overlay)),
+ marker_position (OVERLAY_END (overlay)));
Fset_marker (OVERLAY_START (overlay), Qnil, Qnil);
Fset_marker (OVERLAY_END (overlay), Qnil, Qnil);
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.")
+ "Return the next position after POS where an overlay starts or ends.\n\
+If there are no more overlay boundaries after POS, return (point-max).")
(pos)
Lisp_Object pos;
{
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\
+the cdr has all the overlays after 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.")
CHECK_OVERLAY (overlay, 0);
- redisplay_region (XMARKER (OVERLAY_START (overlay))->buffer,
- OVERLAY_POSITION (OVERLAY_START (overlay)),
- OVERLAY_POSITION (OVERLAY_END (overlay)));
+ tail = Fmarker_buffer (OVERLAY_START (overlay));
+ if (! NILP (tail))
+ redisplay_region (XMARKER (OVERLAY_START (overlay))->buffer,
+ marker_position (OVERLAY_START (overlay)),
+ marker_position (OVERLAY_END (overlay)));
plist = Fcdr_safe (XCONS (overlay)->cdr);
{
Lisp_Object prop, overlay, tail;
int insertion = EQ (start, end);
+ int tail_copied;
+ struct gcpro gcpro1, gcpro2;
+ overlay = Qnil;
+ tail = Qnil;
+ GCPRO2 (overlay, tail);
+
+ tail_copied = 0;
for (tail = current_buffer->overlays_before;
CONSP (tail);
tail = XCONS (tail)->cdr)
{
int startpos, endpos;
- int ostart, oend;
+ Lisp_Object ostart, oend;
overlay = XCONS (tail)->car;
if (XFASTINT (end) == startpos && insertion)
{
prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
- call_overlay_mod_hooks (prop, overlay, start, end);
+ if (!NILP (prop))
+ {
+ /* Copy TAIL in case the hook recenters the overlay lists. */
+ if (!tail_copied)
+ tail = Fcopy_sequence (tail);
+ tail_copied = 1;
+ call_overlay_mod_hooks (prop, overlay, start, end);
+ }
}
if (XFASTINT (start) == endpos && insertion)
{
prop = Foverlay_get (overlay, Qinsert_behind_hooks);
- call_overlay_mod_hooks (prop, overlay, start, end);
+ if (!NILP (prop))
+ {
+ if (!tail_copied)
+ tail = Fcopy_sequence (tail);
+ tail_copied = 1;
+ call_overlay_mod_hooks (prop, overlay, start, end);
+ }
}
- if (insertion
- ? (XFASTINT (start) > startpos && XFASTINT (end) < endpos)
- : (XFASTINT (start) >= startpos && XFASTINT (end) <= endpos))
+ /* Test for intersecting intervals. This does the right thing
+ for both insertion and deletion. */
+ if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
{
prop = Foverlay_get (overlay, Qmodification_hooks);
- call_overlay_mod_hooks (prop, overlay, start, end);
+ if (!NILP (prop))
+ {
+ if (!tail_copied)
+ tail = Fcopy_sequence (tail);
+ tail_copied = 1;
+ call_overlay_mod_hooks (prop, overlay, start, end);
+ }
}
}
+ tail_copied = 0;
for (tail = current_buffer->overlays_after;
CONSP (tail);
tail = XCONS (tail)->cdr)
{
int startpos, endpos;
- int ostart, oend;
+ Lisp_Object ostart, oend;
overlay = XCONS (tail)->car;
ostart = OVERLAY_START (overlay);
oend = OVERLAY_END (overlay);
startpos = OVERLAY_POSITION (ostart);
+ endpos = OVERLAY_POSITION (oend);
if (XFASTINT (end) < startpos)
break;
if (XFASTINT (end) == startpos && insertion)
{
prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
- call_overlay_mod_hooks (prop, overlay, start, end);
+ if (!NILP (prop))
+ {
+ if (!tail_copied)
+ tail = Fcopy_sequence (tail);
+ tail_copied = 1;
+ call_overlay_mod_hooks (prop, overlay, start, end);
+ }
}
if (XFASTINT (start) == endpos && insertion)
{
prop = Foverlay_get (overlay, Qinsert_behind_hooks);
- call_overlay_mod_hooks (prop, overlay, start, end);
+ if (!NILP (prop))
+ {
+ if (!tail_copied)
+ tail = Fcopy_sequence (tail);
+ tail_copied = 1;
+ call_overlay_mod_hooks (prop, overlay, start, end);
+ }
}
- if (insertion
- ? (XFASTINT (start) > startpos && XFASTINT (end) < endpos)
- : (XFASTINT (start) >= startpos && XFASTINT (end) <= endpos))
+ /* Test for intersecting intervals. This does the right thing
+ for both insertion and deletion. */
+ if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
{
prop = Foverlay_get (overlay, Qmodification_hooks);
- call_overlay_mod_hooks (prop, overlay, start, end);
+ if (!NILP (prop))
+ {
+ if (!tail_copied)
+ tail = Fcopy_sequence (tail);
+ tail_copied = 1;
+ call_overlay_mod_hooks (prop, overlay, start, end);
+ }
}
}
+
+ UNGCPRO;
}
static void
buffer_defaults.truncate_lines = Qnil;
buffer_defaults.ctl_arrow = Qt;
+#ifdef MSDOS
+ buffer_defaults.buffer_file_type = Qnil; /* TEXT */
+#endif
XFASTINT (buffer_defaults.fill_column) = 70;
XFASTINT (buffer_defaults.left_margin) = 0;
XFASTINT (buffer_local_flags.abbrev_table) = 0x1000;
XFASTINT (buffer_local_flags.display_table) = 0x2000;
XFASTINT (buffer_local_flags.syntax_table) = 0x8000;
+#ifdef MSDOS
+ XFASTINT (buffer_local_flags.buffer_file_type) = 0x4000;
+#endif
Vbuffer_alist = Qnil;
current_buffer = 0;
staticpro (&Qpermanent_local);
staticpro (&Qkill_buffer_hook);
staticpro (&Qoverlayp);
+ staticpro (&Qmodification_hooks);
+ Qmodification_hooks = intern ("modification-hooks");
+ staticpro (&Qinsert_in_front_hooks);
+ Qinsert_in_front_hooks = intern ("insert-in-front-hooks");
+ staticpro (&Qinsert_behind_hooks);
+ Qinsert_behind_hooks = intern ("insert-behind-hooks");
+ staticpro (&Qget_file_buffer);
+ Qget_file_buffer = intern ("get-file-buffer");
+ Qpriority = intern ("priority");
+ staticpro (&Qpriority);
+ Qwindow = intern ("window");
+ staticpro (&Qwindow);
Qoverlayp = intern ("overlayp");
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. */
"Default value of `case-fold-search' for buffers that don't override it.\n\
This is the same as (default-value 'case-fold-search).");
+#ifdef MSDOS
+ DEFVAR_LISP_NOPRO ("default-buffer-file-type",
+ &buffer_defaults.buffer_file_type,
+ "Default file type for buffers that do not override it.\n\
+This is the same as (default-value 'buffer-file-type).\n\
+The file type is nil for text, t for binary.");
+#endif
+
DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
Qnil, 0);
%b -- print buffer name. %f -- print visited file name.\n\
%* -- print *, % or hyphen. %m -- print value of mode-name (obsolete).\n\
%s -- print process status. %l -- print the current line number.\n\
- %p -- print percent of buffer above top of window, or top, bot or all.\n\
+ %p -- print percent of buffer above top of window, or Top, Bot or All.\n\
+ %P -- print percent of buffer above bottom of window, perhaps plus Top,\n\
+ or print Bottom or All.\n\
%n -- print Narrow if appropriate.\n\
+ %t -- print T if files is text, B if binary.\n\
%[ -- print one [ for each recursive editing level. %] similar.\n\
%% -- print %. %- -- print infinitely many dashes.\n\
Decimal digits after the % specify field width to which to pad.");
`truncate-partial-width-windows' if that variable is non-nil\n\
and this buffer is not full-frame width.");
+#ifdef MSDOS
+ DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer->buffer_file_type,
+ Qnil,
+ "*If visited file is text, nil; otherwise, t.");
+#endif
+
DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer->directory,
make_number (Lisp_String),
"Name of default directory of current buffer. Should end with slash.\n\
If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
Automatically becomes buffer-local when set in any fashion.");
+#if 0 /* The doc string is too long for some compilers,
+ but make-docfile can find it in this comment. */
DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer->display_table,
Qnil,
"Display table that controls display of the contents of current buffer.\n\
a vector of characters).\n\
If this variable is nil, the value of `standard-display-table' is used.\n\
Each window can have its own, overriding display table.");
+#endif
+ DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer->display_table,
+ Qnil, 0);
/*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
"Don't ask.");
the beginning and end of the range of old text to be changed.\n\
\(For an insertion, the beginning and end are at the same place.)\n\
No information is given about the length of the text after the change.\n\
-position of the change\n\
\n\
-While executing the `before-change-function', changes to buffers do not\n\
-cause calls to any `before-change-function' or `after-change-function'.");
+Buffer changes made while executing the `before-change-function'\n\
+don't call any before-change or after-change functions.\n\
+That's because these variables are temporarily set to nil.\n\
+As a result, a hook function cannot straightforwardly alter the value of\n\
+these variables. See the Emacs Lisp manual for a way of\n\
+accomplishing an equivalent result by using other variables.");
Vbefore_change_function = Qnil;
DEFVAR_LISP ("after-change-function", &Vafter_change_function,
for a deletion, that length is the number of characters deleted,\n\
and the post-change beginning and end are at the same place.)\n\
\n\
-While executing the `after-change-function', changes to buffers do not\n\
-cause calls to any `before-change-function' or `after-change-function'.");
+Buffer changes made while executing the `after-change-function'\n\
+don't call any before-change or after-change functions.\n\
+That's because these variables are temporarily set to nil.\n\
+As a result, a hook function cannot straightforwardly alter the value of\n\
+these variables. See the Emacs Lisp manual for a way of\n\
+accomplishing an equivalent result by using other variables.");
Vafter_change_function = Qnil;
+ DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions,
+ "List of functions to call before each text change.\n\
+Two arguments are passed to each function: the positions of\n\
+the beginning and end of the range of old text to be changed.\n\
+\(For an insertion, the beginning and end are at the same place.)\n\
+No information is given about the length of the text after the change.\n\
+\n\
+Buffer changes made while executing the `before-change-functions'\n\
+don't call any before-change or after-change functions.\n\
+That's because these variables are temporarily set to nil.\n\
+As a result, a hook function cannot straightforwardly alter the value of\n\
+these variables. See the Emacs Lisp manual for a way of\n\
+accomplishing an equivalent result by using other variables.");
+ Vbefore_change_functions = Qnil;
+
+ DEFVAR_LISP ("after-change-functions", &Vafter_change_functions,
+ "List of function to call after each text change.\n\
+Three arguments are passed to each function: the positions of\n\
+the beginning and end of the range of changed text,\n\
+and the length of the pre-change text replaced by that range.\n\
+\(For an insertion, the pre-change length is zero;\n\
+for a deletion, that length is the number of characters deleted,\n\
+and the post-change beginning and end are at the same place.)\n\
+\n\
+Buffer changes made while executing the `after-change-functions'\n\
+don't call any before-change or after-change functions.\n\
+That's because these variables are temporarily set to nil.\n\
+As a result, a hook function cannot straightforwardly alter the value of\n\
+these variables. See the Emacs Lisp manual for a way of\n\
+accomplishing an equivalent result by using other variables.");
+
+ Vafter_change_functions = 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.");
Qfirst_change_hook = intern ("first-change-hook");
staticpro (&Qfirst_change_hook);
+#if 0 /* The doc string is too long for some compilers,
+ but make-docfile can find it in this comment. */
DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer->undo_list, Qnil,
"List of undo entries in current buffer.\n\
Recent changes come first; older changes follow newer.\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.");
+#endif
+ DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer->undo_list, Qnil,
+ 0);
DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer->mark_active, Qnil,
"Non-nil means the mark and region are currently active in this buffer.\n\
is a member of the list.");
Vinhibit_read_only = Qnil;
+ DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions,
+ "List of functions called with no args to query before killing a buffer.");
+ Vkill_buffer_query_functions = Qnil;
+
defsubr (&Sbuffer_list);
defsubr (&Sget_buffer);
defsubr (&Sget_file_buffer);
initial_define_key (control_x_map, 'b', "switch-to-buffer");
initial_define_key (control_x_map, 'k', "kill-buffer");
initial_define_key (control_x_map, Ctl ('B'), "list-buffers");
+
+ /* This must not be in syms_of_buffer, because Qdisabled is not
+ initialized when that function gets called. */
+ Fput (intern ("erase-buffer"), Qdisabled, Qt);
}
HCoop / bpt / emacs.git / blobdiff