/* Buffer manipulation primitives for GNU Emacs.
- Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 02, 03, 2004
- Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994,
+ 1995, 1997, 1998, 1999, 2000, 2001, 2002,
+ 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include <config.h>
extern int errno;
#endif
-#ifndef MAXPATHLEN
-/* in 4.1 [probably SunOS? -stef] , param.h fails to define this. */
-#define MAXPATHLEN 1024
-#endif /* not MAXPATHLEN */
#ifdef HAVE_UNISTD_H
#include <unistd.h>
static void free_buffer_text P_ ((struct buffer *b));
static struct Lisp_Overlay * copy_overlays P_ ((struct buffer *, struct Lisp_Overlay *));
static void modify_overlay P_ ((struct buffer *, EMACS_INT, EMACS_INT));
+static Lisp_Object buffer_lisp_local_variables P_ ((struct buffer *));
/* For debugging; temporary. See set_buffer_internal. */
clone_per_buffer_values (from, to)
struct buffer *from, *to;
{
- Lisp_Object to_buffer, tem;
+ Lisp_Object to_buffer;
int offset;
XSETBUFFER (to_buffer, to);
to->overlays_before = copy_overlays (to, from->overlays_before);
to->overlays_after = copy_overlays (to, from->overlays_after);
- /* Copy the alist of local variables,
- and all the alist elements too. */
- to->local_var_alist
- = Fcopy_sequence (from->local_var_alist);
- for (tem = to->local_var_alist; CONSP (tem);
- tem = XCDR (tem))
- XSETCAR (tem, Fcons (XCAR (XCAR (tem)), XCDR (XCAR (tem))));
+ /* Get (a copy of) the alist of Lisp-level local variables of FROM
+ and install that in TO. */
+ to->local_var_alist = buffer_lisp_local_variables (from);
}
-
DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, Smake_indirect_buffer,
2, 3,
"bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
XMARKER (b->zv_marker)->insertion_type = 1;
}
else
- clone_per_buffer_values (b->base_buffer, b);
+ {
+ struct buffer *old_b = current_buffer;
+
+ clone_per_buffer_values (b->base_buffer, b);
+ b->filename = Qnil;
+ b->file_truename = Qnil;
+ b->display_count = make_number (0);
+ b->backed_up = Qnil;
+ b->auto_save_file_name = Qnil;
+ set_buffer_internal_1 (b);
+ Fset (intern ("buffer-save-without-query"), Qnil);
+ Fset (intern ("buffer-file-number"), Qnil);
+ Fset (intern ("buffer-stale-function"), Qnil);
+ set_buffer_internal_1 (old_b);
+ }
return buf;
}
b->mark_active = Qnil;
b->point_before_scroll = Qnil;
b->file_format = Qnil;
+ b->auto_save_file_format = Qt;
b->last_selected_window = Qnil;
XSETINT (b->display_count, 0);
b->display_time = Qnil;
Sbuffer_local_value, 2, 2, 0,
doc: /* Return the value of VARIABLE in BUFFER.
If VARIABLE does not have a buffer-local binding in BUFFER, the value
-is the default binding of variable. */)
- (symbol, buffer)
- register Lisp_Object symbol;
+is the default binding of the variable. */)
+ (variable, buffer)
+ register Lisp_Object variable;
register Lisp_Object buffer;
{
register struct buffer *buf;
register Lisp_Object result;
- CHECK_SYMBOL (symbol);
+ CHECK_SYMBOL (variable);
CHECK_BUFFER (buffer);
buf = XBUFFER (buffer);
+ if (SYMBOLP (variable))
+ variable = indirect_variable (variable);
+
/* Look in local_var_list */
- result = Fassoc (symbol, buf->local_var_alist);
+ result = Fassoc (variable, buf->local_var_alist);
if (NILP (result))
{
int offset, idx;
idx = PER_BUFFER_IDX (offset);
if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
&& SYMBOLP (PER_BUFFER_SYMBOL (offset))
- && EQ (PER_BUFFER_SYMBOL (offset), symbol))
+ && EQ (PER_BUFFER_SYMBOL (offset), variable))
{
result = PER_BUFFER_VALUE (buf, offset);
found = 1;
}
if (!found)
- result = Fdefault_value (symbol);
+ result = Fdefault_value (variable);
}
else
{
Lisp_Object current_alist_element;
/* What binding is loaded right now? */
- valcontents = SYMBOL_VALUE (symbol);
+ valcontents = SYMBOL_VALUE (variable);
current_alist_element
= XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr);
}
if (EQ (result, Qunbound))
- return Fsignal (Qvoid_variable, Fcons (symbol, Qnil));
+ return Fsignal (Qvoid_variable, Fcons (variable, Qnil));
+
+ return result;
+}
+
+/* Return an alist of the Lisp-level buffer-local bindings of
+ buffer BUF. That is, don't include the variables maintained
+ in special slots in the buffer object. */
+
+static Lisp_Object
+buffer_lisp_local_variables (buf)
+ struct buffer *buf;
+{
+ Lisp_Object result = Qnil;
+ register Lisp_Object tail;
+ for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
+ {
+ Lisp_Object val, elt;
+
+ elt = XCAR (tail);
+
+ /* Reference each variable in the alist in buf.
+ 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. */
+ val = find_symbol_value (XCAR (elt));
+ /* Use the current buffer value only if buf is the current buffer. */
+ if (buf != current_buffer)
+ val = XCDR (elt);
+
+ /* If symbol is unbound, put just the symbol in the list. */
+ if (EQ (val, Qunbound))
+ result = Fcons (XCAR (elt), result);
+ /* Otherwise, put (symbol . value) in the list. */
+ else
+ result = Fcons (Fcons (XCAR (elt), val), result);
+ }
return result;
}
buf = XBUFFER (buffer);
}
- result = Qnil;
-
- {
- register Lisp_Object tail;
- for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
- {
- Lisp_Object val, elt;
-
- elt = XCAR (tail);
-
- /* Reference each variable in the alist in buf.
- 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. */
- val = find_symbol_value (XCAR (elt));
- /* Use the current buffer value only if buf is the current buffer. */
- if (buf != current_buffer)
- val = XCDR (elt);
-
- /* If symbol is unbound, put just the symbol in the list. */
- if (EQ (val, Qunbound))
- result = Fcons (XCAR (elt), result);
- /* Otherwise, put (symbol . value) in the list. */
- else
- result = Fcons (Fcons (XCAR (elt), val), result);
- }
- }
+ result = buffer_lisp_local_variables (buf);
/* Add on all the variables stored in special slots. */
{
return result;
}
-
\f
DEFUN ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
0, 1, 0,
DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p,
Srestore_buffer_modified_p, 1, 1, 0,
- doc: /* Like `set-buffer-modified-p', with a differences concerning redisplay.
+ doc: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
It is not ensured that mode lines will be updated to show the modified
state of the current buffer. Use with care. */)
(flag)
return buf;
}
\f
-DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, Sbuffer_disable_undo,
- 0, 1, "",
- doc: /* Make BUFFER stop keeping undo information.
-No argument or nil as argument means do this for the current buffer. */)
- (buffer)
- register Lisp_Object buffer;
-{
- Lisp_Object real_buffer;
-
- if (NILP (buffer))
- XSETBUFFER (real_buffer, current_buffer);
- else
- {
- real_buffer = Fget_buffer (buffer);
- if (NILP (real_buffer))
- nsberror (buffer);
- }
-
- XBUFFER (real_buffer)->undo_list = Qt;
-
- return Qnil;
-}
-
DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, Sbuffer_enable_undo,
0, 1, "",
doc: /* Start keeping undo information for buffer BUFFER.
/* First run the query functions; if any query is answered no,
don't kill the buffer. */
arglist[0] = Qkill_buffer_query_functions;
- if (NILP (Frun_hook_with_args_until_failure (1, arglist)))
+ tem = Frun_hook_with_args_until_failure (1, arglist);
+ if (NILP (tem))
return unbind_to (count, Qnil);
/* Then run the hooks. */
}
}
Fset_buffer (buf);
- if (NILP (norecord))
- /* Why bother ? Fselect_window will do it for us anyway. -stef */
- record_buffer (buf);
Fselect_window (Fdisplay_buffer (buf, other_window, Qnil), norecord);
return buf;
}
doc: /* Put BUFFER at the end of the list of all buffers.
There it is the least likely candidate for `other-buffer' to return;
thus, the least likely buffer for \\[switch-to-buffer] to select by default.
+You can specify a buffer name as BUFFER, or an actual buffer object.
If BUFFER is nil or omitted, bury the current buffer.
Also, if BUFFER is nil or omitted, remove the current buffer from the
selected window if it is displayed there. */)
doc: /* Create a new overlay with range BEG to END in BUFFER.
If omitted, BUFFER defaults to the current buffer.
BEG and END may be integers or markers.
-The fourth arg FRONT-ADVANCE, if non-nil, makes the
-front delimiter advance when text is inserted there.
-The fifth arg REAR-ADVANCE, if non-nil, makes the
-rear delimiter advance when text is inserted there. */)
+The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
+for the front of the overlay advance when text is inserted there
+(which means the text *is not* included in the overlay).
+The fifth arg REAR-ADVANCE, if non-nil, makes the marker
+for the rear of the overlay advance when text is inserted there
+(which means the text *is* included in the overlay). */)
(beg, end, buffer, front_advance, rear_advance)
Lisp_Object beg, end, buffer;
Lisp_Object front_advance, rear_advance;
/* If multiple windows show this buffer, we must do other windows. */
else if (buffer_shared > 1)
windows_or_buffers_changed = 1;
+ /* If we modify an overlay at the end of the buffer, we cannot
+ be sure that window end is still valid. */
+ else if (end >= ZV && start <= ZV)
+ windows_or_buffers_changed = 1;
++BUF_OVERLAY_MODIFF (buf);
}
}
DEFUN ("overlay-buffer", Foverlay_buffer, Soverlay_buffer, 1, 1, 0,
- doc: /* Return the buffer OVERLAY belongs to. */)
+ doc: /* Return the buffer OVERLAY belongs to.
+Return nil if OVERLAY has been deleted. */)
(overlay)
Lisp_Object overlay;
{
== OVERLAY_POSITION (OVERLAY_END (overlay))))
Fdelete_overlay (overlay);
}
+
return value;
}
\f
buffer_defaults.undo_list = Qnil;
buffer_defaults.mark_active = Qnil;
buffer_defaults.file_format = Qnil;
+ buffer_defaults.auto_save_file_format = Qt;
buffer_defaults.overlays_before = NULL;
buffer_defaults.overlays_after = NULL;
buffer_defaults.overlay_center = BEG;
buffer_defaults.direction_reversed = Qnil;
buffer_defaults.cursor_type = Qt;
buffer_defaults.extra_line_spacing = Qnil;
+ buffer_defaults.cursor_in_non_selected_windows = Qt;
#ifdef DOS_NT
buffer_defaults.buffer_file_type = Qnil; /* TEXT */
buffer_defaults.vertical_scroll_bar_type = Qt;
buffer_defaults.indicate_empty_lines = Qnil;
buffer_defaults.indicate_buffer_boundaries = Qnil;
+ buffer_defaults.fringe_indicator_alist = Qnil;
+ buffer_defaults.fringe_cursor_alist = Qnil;
buffer_defaults.scroll_up_aggressively = Qnil;
buffer_defaults.scroll_down_aggressively = Qnil;
buffer_defaults.display_time = Qnil;
XSETINT (buffer_local_flags.file_truename, -1);
XSETINT (buffer_local_flags.invisibility_spec, -1);
XSETINT (buffer_local_flags.file_format, -1);
+ XSETINT (buffer_local_flags.auto_save_file_format, -1);
XSETINT (buffer_local_flags.display_count, -1);
XSETINT (buffer_local_flags.display_time, -1);
XSETINT (buffer_local_flags.enable_multibyte_characters, -1);
XSETFASTINT (buffer_local_flags.vertical_scroll_bar_type, idx); ++idx;
XSETFASTINT (buffer_local_flags.indicate_empty_lines, idx); ++idx;
XSETFASTINT (buffer_local_flags.indicate_buffer_boundaries, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.fringe_indicator_alist, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.fringe_cursor_alist, idx); ++idx;
XSETFASTINT (buffer_local_flags.scroll_up_aggressively, idx); ++idx;
XSETFASTINT (buffer_local_flags.scroll_down_aggressively, idx); ++idx;
XSETFASTINT (buffer_local_flags.header_line_format, idx); ++idx;
XSETFASTINT (buffer_local_flags.cursor_type, idx); ++idx;
XSETFASTINT (buffer_local_flags.extra_line_spacing, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.cursor_in_non_selected_windows, idx); ++idx;
/* Need more room? */
if (idx >= MAX_PER_BUFFER_VARS)
void
init_buffer ()
{
- char buf[MAXPATHLEN + 1];
char *pwd;
- struct stat dotstat, pwdstat;
Lisp_Object temp;
- int rc;
+ int len;
#ifdef USE_MMAP_FOR_BUFFERS
{
if (NILP (buffer_defaults.enable_multibyte_characters))
Fset_buffer_multibyte (Qnil);
- /* If PWD is accurate, use it instead of calling getwd. PWD is
- sometimes a nicer name, and using it may avoid a fatal error if a
- parent directory is searchable but not readable. */
- if ((pwd = getenv ("PWD")) != 0
- && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
- && stat (pwd, &pwdstat) == 0
- && stat (".", &dotstat) == 0
- && dotstat.st_ino == pwdstat.st_ino
- && dotstat.st_dev == pwdstat.st_dev
- && strlen (pwd) < MAXPATHLEN)
- strcpy (buf, pwd);
-#ifdef HAVE_GETCWD
- else if (getcwd (buf, MAXPATHLEN+1) == 0)
- fatal ("`getcwd' failed: %s\n", strerror (errno));
-#else
- else if (getwd (buf) == 0)
- fatal ("`getwd' failed: %s\n", buf);
-#endif
+ pwd = get_current_dir_name ();
+
+ if (!pwd)
+ fatal ("`get_current_dir_name' failed: %s\n", strerror (errno));
#ifndef VMS
/* Maybe this should really use some standard subroutine
whose definition is filename syntax dependent. */
- rc = strlen (buf);
- if (!(IS_DIRECTORY_SEP (buf[rc - 1])))
+ len = strlen (pwd);
+ if (!(IS_DIRECTORY_SEP (pwd[len - 1])))
{
- buf[rc] = DIRECTORY_SEP;
- buf[rc + 1] = '\0';
+ /* Grow buffer to add directory separator and '\0'. */
+ pwd = (char *) xrealloc (pwd, len + 2);
+ pwd[len] = DIRECTORY_SEP;
+ pwd[len + 1] = '\0';
}
#endif /* not VMS */
- current_buffer->directory = build_string (buf);
+ current_buffer->directory = make_unibyte_string (pwd, strlen (pwd));
+ if (! NILP (buffer_defaults.enable_multibyte_characters))
+ /* At this moment, we still don't know how to decode the
+ directory name. So, we keep the bytes in multibyte form so
+ that ENCODE_FILE correctly gets the original bytes. */
+ current_buffer->directory
+ = string_to_multibyte (current_buffer->directory);
/* Add /: to the front of the name
if it would otherwise be treated as magic. */
temp = get_minibuffer (0);
XBUFFER (temp)->directory = current_buffer->directory;
+
+ free (pwd);
}
/* initialize the buffer routines */
doc: /* Default value of `line-spacing' for buffers that don't override it.
This is the same as (default-value 'line-spacing). */);
+ DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
+ &buffer_defaults.cursor_in_non_selected_windows,
+ doc: /* Default value of `cursor-in-non-selected-windows'.
+This is the same as (default-value 'cursor-in-non-selected-windows). */);
+
DEFVAR_LISP_NOPRO ("default-abbrev-mode",
&buffer_defaults.abbrev_mode,
doc: /* Default value of `abbrev-mode' for buffers that do not override it.
doc: /* Default value of `ctl-arrow' for buffers that do not override it.
This is the same as (default-value 'ctl-arrow). */);
- DEFVAR_LISP_NOPRO ("default-direction-reversed",
- &buffer_defaults.direction_reversed,
- doc: /* Default value of `direction-reversed' for buffers that do not override it.
+ DEFVAR_LISP_NOPRO ("default-direction-reversed",
+ &buffer_defaults.direction_reversed,
+ doc: /* Default value of `direction-reversed' for buffers that do not override it.
This is the same as (default-value 'direction-reversed). */);
- DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
- &buffer_defaults.enable_multibyte_characters,
- doc: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
+ DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
+ &buffer_defaults.enable_multibyte_characters,
+ doc: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
This is the same as (default-value 'enable-multibyte-characters). */);
- DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
- &buffer_defaults.buffer_file_coding_system,
- doc: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
+ DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
+ &buffer_defaults.buffer_file_coding_system,
+ doc: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
This is the same as (default-value 'buffer-file-coding-system). */);
DEFVAR_LISP_NOPRO ("default-truncate-lines",
doc: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
This is the same as (default-value 'indicate-buffer-boundaries). */);
+ DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
+ &buffer_defaults.fringe_indicator_alist,
+ doc: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
+This is the same as (default-value 'fringe-indicator-alist'). */);
+
+ DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
+ &buffer_defaults.fringe_cursor_alist,
+ doc: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
+This is the same as (default-value 'fringe-cursor-alist'). */);
+
DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
&buffer_defaults.scroll_up_aggressively,
doc: /* Default value of `scroll-up-aggressively'.
DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults.major_mode,
doc: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
-nil here means use current buffer's major mode. */);
+nil here means use current buffer's major mode, provided it is not
+marked as "special".
+
+When a mode is used by default, `find-file' switches to it
+before it reads the contents into the buffer and before
+it finishes setting up the buffer. Thus, the mode and
+its hooks should not expect certain variables such as
+`buffer-read-only' and `buffer-file-coding-system' to be set up. */);
DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer->major_mode,
make_number (Lisp_Symbol),
DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer->vertical_scroll_bar_type,
Qnil,
doc: /* *Position of this buffer's vertical scroll bar.
-A value of left or right means to place the vertical scroll bar at that side
-of the window; a value of nil means that this window has no vertical scroll bar.
-A value of t means to use the vertical scroll bar type from the window's frame. */);
+The value takes effect whenever you tell a window to display this buffer;
+for instance, with `set-window-buffer' or when `display-buffer' displays it.
+
+A value of `left' or `right' means put the vertical scroll bar at that side
+of the window; a value of nil means don't show any vertical scroll bars.
+A value of t (the default) means do whatever the window's frame specifies. */);
DEFVAR_PER_BUFFER ("indicate-empty-lines",
¤t_buffer->indicate_empty_lines, Qnil,
of a window on window-systems with angle bitmaps, or if the window can be
scrolled, the top and bottom line of the window are marked with up and down
arrow bitmaps.
-If value is `left' or `right', both angle and arrow bitmaps are displayed in
-the left or right fringe, resp. Any other non-nil value causes the
-bitmap on the top line to be displayed in the left fringe, and the
-bitmap on the bottom line in the right fringe.
-If value is a cons (ANGLES . ARROWS), the car specifies the position
-of the angle bitmaps, and the cdr specifies the position of the arrow
-bitmaps. For example, (t . right) places the top angle bitmap in left
-fringe, the bottom angle bitmap in right fringe, and both arrow
+
+If value is a symbol `left' or `right', both angle and arrow bitmaps
+are displayed in the left or right fringe, resp. Any other value
+that doesn't look like an alist means display the angle bitmaps in
+the left fringe but no arrows.
+
+You can exercise more precise control by using an alist as the
+value. Each alist element (INDICATOR . POSITION) specifies
+where to show one of the indicators. INDICATOR is one of `top',
+`bottom', `up', `down', or t, which specifies the default position,
+and POSITION is one of `left', `right', or nil, meaning do not show
+this indicator.
+
+For example, ((top . left) (t . right)) places the top angle bitmap in
+left fringe, the bottom angle bitmap in right fringe, and both arrow
bitmaps in right fringe. To show just the angle bitmaps in the left
-fringe, but no arrow bitmaps, use (left . nil). */);
+fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
+
+ DEFVAR_PER_BUFFER ("fringe-indicator-alist",
+ ¤t_buffer->fringe_indicator_alist, Qnil,
+ doc: /* *Mapping from logical to physical fringe indicator bitmaps.
+The value is an alist where each element (INDICATOR . BITMAPS)
+specifies the fringe bitmaps used to display a specific logical
+fringe indicator.
+
+INDICATOR specifies the logical indicator type which is one of the
+following symbols: `truncation' , `continuation', `overlay-arrow',
+`top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
+
+BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
+the actual bitmap shown in the left or right fringe for the logical
+indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
+right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
+are used only for the `bottom' and `one-line' indicators when the last
+(only) line in has no final newline. BITMAPS may also be a single
+symbol which is used in both left and right fringes. */);
+
+ DEFVAR_PER_BUFFER ("fringe-cursor-alist",
+ ¤t_buffer->fringe_cursor_alist, Qnil,
+ doc: /* *Mapping from logical to physical fringe cursor bitmaps.
+The value is an alist where each element (CURSOR . BITMAP)
+specifies the fringe bitmaps used to display a specific logical
+cursor type in the fringe.
+
+CURSOR specifies the logical cursor type which is one of the following
+symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
+one is used to show a hollow cursor on narrow lines display lines
+where the normal hollow cursor will not fit.
+
+BITMAP is the corresponding fringe bitmap shown for the logical
+cursor type. */);
DEFVAR_PER_BUFFER ("scroll-up-aggressively",
¤t_buffer->scroll_up_aggressively, Qnil,
When the value is 0.0, point goes at the bottom line, which in the simple
case that you moved off with C-f means scrolling just one line. 1.0 means
point goes at the top, so that in that simple case, the window
-window scrolls by a full window height. Meaningful values are
+scrolls by a full window height. Meaningful values are
between 0.0 and 1.0, inclusive. */);
DEFVAR_PER_BUFFER ("scroll-down-aggressively",
When the value is 0.0, point goes at the top line, which in the simple
case that you moved off with C-b means scrolling just one line. 1.0 means
point goes at the bottom, so that in that simple case, the window
-window scrolls by a full window height. Meaningful values are
+scrolls by a full window height. Meaningful values are
between 0.0 and 1.0, inclusive. */);
/*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
was modified between BEG and END. PROPERTY is the property name,
and VALUE is the old value.
+An entry (apply FUN-NAME . ARGS) means undo the change with
+\(apply FUN-NAME ARGS).
+
+An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
+in the active region. BEG and END is the range affected by this entry
+and DELTA is the number of bytes added or deleted in that range by
+this change.
+
An entry (MARKER . DISTANCE) indicates that the marker MARKER
was adjusted in position by the offset DISTANCE (an integer).
doc: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
Normally, the line-motion functions work by scanning the buffer for
-newlines. Columnar operations (like move-to-column and
-compute-motion) also work by scanning the buffer, summing character
+newlines. Columnar operations (like `move-to-column' and
+`compute-motion') also work by scanning the buffer, summing character
widths as they go. This works well for ordinary text, but if the
buffer's lines are very long (say, more than 500 characters), these
motion functions will take longer to execute. Emacs may also take
longer to update the display.
-If cache-long-line-scans is non-nil, these motion functions cache the
+If `cache-long-line-scans' is non-nil, these motion functions cache the
results of their scans, and consult the cache to avoid rescanning
regions of the buffer until the text is modified. The caches are most
beneficial when they prevent the most searching---that is, when the
buffer contains long lines and large regions of characters with the
same, fixed screen width.
-When cache-long-line-scans is non-nil, processing short lines will
+When `cache-long-line-scans' is non-nil, processing short lines will
become slightly slower (because of the overhead of consulting the
cache), and the caches will use memory roughly proportional to the
number of newlines and characters whose screen width varies.
Formats are defined by `format-alist'. This variable is
set when a file is visited. */);
+ DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
+ ¤t_buffer->auto_save_file_format, Qnil,
+ doc: /* *Format in which to write auto-save files.
+Should be a list of symbols naming formats that are defined in `format-alist'.
+If it is t, which is the default, auto-save files are written in the
+same format as a regular save would use. */);
+
DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
¤t_buffer->invisibility_spec, Qnil,
doc: /* Invisibility spec of this buffer.
If the value is `lambda', that enables Transient Mark mode temporarily
until the next buffer modification. If a command sets the value to `only',
-that enables Transient Mark mode for the following command only. */);
+that enables Transient Mark mode for the following command only.
+During that following command, the value of `transient-mark-mode'
+is `identity'. If it is still `identity' at the end of that command,
+it changes to nil. */);
Vtransient_mark_mode = Qnil;
DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only,
doc: /* Cursor to use when this buffer is in the selected window.
Values are interpreted as follows:
- t use the cursor specified for the frame
- nil don't display a cursor
- box display a filled box cursor
- hollow display a hollow box cursor
- bar display a vertical bar cursor with default width
- (bar . WIDTH) display a vertical bar cursor with width WIDTH
- hbar display a horisontal bar cursor with default width
- (hbar . WIDTH) display a horisontal bar cursor with width WIDTH
- ANYTHING ELSE display a hollow box cursor.
+ t use the cursor specified for the frame
+ nil don't display a cursor
+ box display a filled box cursor
+ hollow display a hollow box cursor
+ bar display a vertical bar cursor with default width
+ (bar . WIDTH) display a vertical bar cursor with width WIDTH
+ hbar display a horizontal bar cursor with default height
+ (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
+ ANYTHING ELSE display a hollow box cursor
When the buffer is displayed in a nonselected window,
this variable has no effect; the cursor appears as a hollow box. */);
If value is a floating point number, it specifies the spacing relative
to the default frame line height. */);
+ DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
+ ¤t_buffer->cursor_in_non_selected_windows, Qnil,
+ doc: /* *Cursor type to display in non-selected windows.
+t means to use hollow box cursor. See `cursor-type' for other values. */);
+
DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions,
doc: /* List of functions called with no args to query before killing a buffer. */);
Vkill_buffer_query_functions = Qnil;
defsubr (&Sbuffer_modified_tick);
defsubr (&Srename_buffer);
defsubr (&Sother_buffer);
- defsubr (&Sbuffer_disable_undo);
defsubr (&Sbuffer_enable_undo);
defsubr (&Skill_buffer);
defsubr (&Sset_buffer_major_mode);