/* Buffer manipulation primitives for GNU Emacs.
- Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001
+ Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 2002
Free Software Foundation, Inc.
This file is part of GNU Emacs.
/* 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;
+Lisp_Object Qkill_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 Qbefore_change_functions;
Lisp_Object Qafter_change_functions;
+Lisp_Object Qucs_set_table_for_input;
/* If nonzero, all modification hooks are suppressed. */
int inhibit_modification_hooks;
Lisp_Object spec;
{
if (STRINGP (spec))
- error ("No buffer named %s", XSTRING (spec)->data);
+ error ("No buffer named %s", SDATA (spec));
error ("Invalid buffer argument");
}
\f
DEFUN ("buffer-list", Fbuffer_list, Sbuffer_list, 0, 1, 0,
doc: /* Return a list of all existing live buffers.
-If the optional arg FRAME is a frame, we return that frame's buffer list. */)
+If the optional arg FRAME is a frame, we return the buffer list
+in the proper order for that frame: the buffers in FRAME's `buffer-list'
+frame parameter come first, followed by the rest of the buffers. */)
(frame)
Lisp_Object frame;
{
Lisp_Object list;
{
register Lisp_Object tail;
- for (tail = list; !NILP (tail); tail = Fcdr (tail))
+ for (tail = list; CONSP (tail); tail = XCDR (tail))
{
register Lisp_Object elt, tem;
- elt = Fcar (tail);
+ elt = XCAR (tail);
tem = Fstring_equal (Fcar (elt), key);
if (!NILP (tem))
return elt;
if (!NILP (buf))
return buf;
- if (XSTRING (name)->size == 0)
+ if (SCHARS (name) == 0)
error ("Empty string for buffer name is not allowed");
b = (struct buffer *) allocate_buffer ();
if (! BUF_BEG_ADDR (b))
buffer_memory_full ();
- BUF_PT (b) = 1;
- BUF_GPT (b) = 1;
- BUF_BEGV (b) = 1;
- BUF_ZV (b) = 1;
- BUF_Z (b) = 1;
- BUF_PT_BYTE (b) = 1;
- BUF_GPT_BYTE (b) = 1;
- BUF_BEGV_BYTE (b) = 1;
- BUF_ZV_BYTE (b) = 1;
- BUF_Z_BYTE (b) = 1;
+ BUF_PT (b) = BEG;
+ BUF_GPT (b) = BEG;
+ BUF_BEGV (b) = BEG;
+ BUF_ZV (b) = BEG;
+ BUF_Z (b) = BEG;
+ BUF_PT_BYTE (b) = BEG_BYTE;
+ BUF_GPT_BYTE (b) = BEG_BYTE;
+ BUF_BEGV_BYTE (b) = BEG_BYTE;
+ BUF_ZV_BYTE (b) = BEG_BYTE;
+ BUF_Z_BYTE (b) = BEG_BYTE;
BUF_MODIFF (b) = 1;
BUF_OVERLAY_MODIFF (b) = 1;
BUF_SAVE_MODIFF (b) = 1;
b->zv_marker = Qnil;
name = Fcopy_sequence (name);
- XSTRING (name)->intervals = NULL_INTERVAL;
+ STRING_SET_INTERVALS (name, NULL_INTERVAL);
b->name = name;
- if (XSTRING (name)->data[0] != ' ')
+ if (SREF (name, 0) != ' ')
b->undo_list = Qnil;
else
b->undo_list = Qt;
reset_buffer (b);
reset_buffer_local_variables (b, 1);
+ b->mark = Fmake_marker ();
+ BUF_MARKERS (b) = Qnil;
+ b->name = name;
+
/* Put this in the alist of all live buffers. */
XSETBUFFER (buf, b);
Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));
- b->mark = Fmake_marker ();
- BUF_MARKERS (b) = Qnil;
- b->name = name;
+ /* Fixme: Protect against errors, which would trigger infinite
+ regress? */
+ if (!NILP (Ffboundp (Qucs_set_table_for_input)))
+ /* buff is on buffer-alist, so no gcpro */
+ call1 (Qucs_set_table_for_input, buf);
+
return buf;
}
OVERLAY_START (overlay) = start;
OVERLAY_END (overlay) = end;
OVERLAY_PLIST (overlay) = Fcopy_sequence (OVERLAY_PLIST (old_overlay));
-
+
result = Fcons (overlay, result);
}
return Fnreverse (result);
}
-
+
/* Clone per-buffer values of buffer FROM.
int offset;
XSETBUFFER (to_buffer, to);
-
+
for (offset = PER_BUFFER_VAR_OFFSET (name) + sizeof (Lisp_Object);
offset < sizeof *to;
offset += sizeof (Lisp_Object))
}
bcopy (from->local_flags, to->local_flags, sizeof to->local_flags);
-
+
to->overlays_before = copy_overlays (to, from->overlays_before);
to->overlays_after = copy_overlays (to, from->overlays_after);
}
buf = Fget_buffer (name);
if (!NILP (buf))
- error ("Buffer name `%s' is in use", XSTRING (name)->data);
+ error ("Buffer name `%s' is in use", SDATA (name));
base_buffer = Fget_buffer (base_buffer);
if (NILP (base_buffer))
- error ("No such buffer: `%s'", XSTRING (name)->data);
+ error ("No such buffer: `%s'", SDATA (name));
- if (XSTRING (name)->size == 0)
+ if (SCHARS (name) == 0)
error ("Empty string for buffer name is not allowed");
b = (struct buffer *) allocate_buffer ();
all_buffers = b;
name = Fcopy_sequence (name);
- XSTRING (name)->intervals = NULL_INTERVAL;
+ STRING_SET_INTERVALS (name, NULL_INTERVAL);
b->name = name;
reset_buffer (b);
b->enable_multibyte_characters = buffer_defaults.enable_multibyte_characters;
b->cursor_type = buffer_defaults.cursor_type;
b->extra_line_spacing = buffer_defaults.extra_line_spacing;
+
+ b->display_error_modiff = 0;
}
/* Reset buffer B's local variables info.
b->buffer_file_type = Qnil;
#endif
-#if 0
- b->sort_table = XSTRING (Vascii_sort_table);
- b->folding_sort_table = XSTRING (Vascii_folding_sort_table);
-#endif /* 0 */
-
/* Reset all (or most) per-buffer variables to their defaults. */
b->local_var_alist = Qnil;
for (i = 0; i < last_per_buffer_idx; ++i)
}
DEFUN ("buffer-local-value", Fbuffer_local_value,
- Sbuffer_local_value, 2, 2, 0,
+ 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. */)
/* Look in local_var_list */
result = Fassoc (symbol, buf->local_var_alist);
- if (NILP (result))
+ if (NILP (result))
{
int offset, idx;
int found = 0;
{
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))
+ && SYMBOLP (PER_BUFFER_SYMBOL (offset))
+ && EQ (PER_BUFFER_SYMBOL (offset), symbol))
{
result = PER_BUFFER_VALUE (buf, offset);
found = 1;
result = Fdefault_value (symbol);
}
else
- result = XCDR (result);
+ {
+ Lisp_Object valcontents;
+ Lisp_Object current_alist_element;
+
+ /* What binding is loaded right now? */
+ valcontents = SYMBOL_VALUE (symbol);
+ current_alist_element
+ = XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr);
+
+ /* The value of the currently loaded binding is not
+ stored in it, but rather in the realvalue slot.
+ Store that value into the binding it belongs to
+ in case that is the one we are about to use. */
+
+ Fsetcdr (current_alist_element,
+ do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
+
+ /* Now get the (perhaps updated) value out of the binding. */
+ result = XCDR (result);
+ }
if (EQ (result, Qunbound))
return Fsignal (Qvoid_variable, Fcons (symbol, Qnil));
#endif /* CLASH_DETECTION */
SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
-
+
/* Set update_mode_lines only if buffer is displayed in some window.
Packages like jit-lock or lazy-lock preserve a buffer's modified
state by recording/restoring the state around blocks of code.
++update_mode_lines;
current_buffer->prevent_redisplay_optimizations_p = 1;
}
-
+
return flag;
}
{
#ifdef CLASH_DETECTION
Lisp_Object fn;
-
+
/* If buffer becoming modified, lock the file.
If buffer becoming unmodified, unlock the file. */
unlock_file (fn);
}
#endif /* CLASH_DETECTION */
-
+
SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
return flag;
}
CHECK_STRING (newname);
- if (XSTRING (newname)->size == 0)
+ if (SCHARS (newname) == 0)
error ("Empty string is invalid as a buffer name");
tem = Fget_buffer (newname);
if (!NILP (unique))
newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
else
- error ("Buffer name `%s' is in use", XSTRING (newname)->data);
+ error ("Buffer name `%s' is in use", SDATA (newname));
}
current_buffer->name = newname;
/* Consider buffers that have been seen in the selected frame
before other buffers. */
-
+
tem = frame_buffer_list (frame);
add_ons = Qnil;
while (CONSP (tem))
}
tail = nconc2 (Fnreverse (add_ons), tail);
- for (; !NILP (tail); tail = Fcdr (tail))
+ for (; CONSP (tail); tail = XCDR (tail))
{
- buf = Fcdr (Fcar (tail));
+ buf = Fcdr (XCAR (tail));
if (EQ (buf, buffer))
continue;
- if (XSTRING (XBUFFER (buf)->name)->data[0] == ' ')
+ if (SREF (XBUFFER (buf)->name, 0) == ' ')
continue;
/* If the selected frame has a buffer_predicate,
disregard buffers that don't fit the predicate. */
&& BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
{
GCPRO1 (buf);
- tem = do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
- XSTRING (b->name)->data));
+ tem = do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
+ b->name, make_number (0)));
UNGCPRO;
if (NILP (tem))
return Qnil;
/* Run hooks with the buffer to be killed the current buffer. */
{
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
Lisp_Object list;
+ Lisp_Object arglist[1];
record_unwind_protect (save_excursion_restore, save_excursion_save ());
set_buffer_internal (b);
/* 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);
- }
+ arglist[0] = Qkill_buffer_query_functions;
+ if (NILP (Frun_hook_with_args_until_failure (1, arglist)))
+ return unbind_to (count, Qnil);
/* Then run the hooks. */
- if (!NILP (Vrun_hooks))
- call1 (Vrun_hooks, Qkill_buffer_hook);
+ Frun_hooks (1, &Qkill_buffer_hook);
unbind_to (count, Qnil);
}
UNGCPRO;
}
-
+
/* Make this buffer not be current.
In the process, notice if this is the sole visible buffer
and give up if so. */
Vbuffer_alist = XCDR (Vbuffer_alist);
else
XSETCDR (prev, XCDR (XCDR (prev)));
-
+
XSETCDR (link, Vbuffer_alist);
Vbuffer_alist = link;
XCDR (frame_buffer_list (frame)));
else
XSETCDR (prev, XCDR (XCDR (prev)));
-
+
XSETCDR (link, frame_buffer_list (frame));
set_frame_buffer_list (frame, link);
}
Lisp_Object function;
if (STRINGP (XBUFFER (buffer)->name)
- && strcmp (XSTRING (XBUFFER (buffer)->name)->data, "*scratch*") == 0)
+ && strcmp (SDATA (XBUFFER (buffer)->name), "*scratch*") == 0)
function = find_symbol_value (intern ("initial-major-mode"));
else
{
&& NILP (Fget (current_buffer->major_mode, Qmode_class)))
function = current_buffer->major_mode;
}
-
+
if (NILP (function) || EQ (function, Qfundamental_mode))
return Qnil;
- count = specpdl_ptr - specpdl;
+ count = SPECPDL_INDEX ();
/* To select a nonfundamental mode,
select the buffer temporarily and then call the mode function. */
if (EQ (minibuf_window, window))
return "Cannot switch buffers in minibuffer window";
tem = Fwindow_dedicated_p (window);
- if (!NILP (tem))
+ if (EQ (tem, Qt))
return "Cannot switch buffers in a dedicated window";
return NULL;
}
if (b->text->beg == NULL)
enlarge_buffer_text (b, 0);
#endif /* USE_MMAP_FOR_BUFFERS */
-
+
if (current_buffer == b)
return;
tem = Fwindow_buffer (selected_window);
/* If we're burying the current buffer, unshow it. */
if (EQ (buffer, tem))
- if (NILP (Fwindow_dedicated_p (selected_window)))
- Fswitch_to_buffer (Fother_buffer (buffer, Qnil, Qnil), Qnil);
- else if (NILP (XWINDOW (selected_window)->parent))
- Ficonify_frame (Fwindow_frame (selected_window));
- else
- Fdelete_window (selected_window);
+ {
+ if (NILP (Fwindow_dedicated_p (selected_window)))
+ Fswitch_to_buffer (Fother_buffer (buffer, Qnil, Qnil), Qnil);
+ else if (NILP (XWINDOW (selected_window)->parent))
+ Ficonify_frame (Fwindow_frame (selected_window));
+ else
+ Fdelete_window (selected_window);
+ }
}
else
{
Lisp_Object buf1;
-
+
buf1 = Fget_buffer (buffer);
if (NILP (buf1))
nsberror (buffer);
XSETCDR (link, Qnil);
Vbuffer_alist = nconc2 (Vbuffer_alist, link);
- frames_bury_buffer (buffer);
+ /* Removing BUFFER from frame-specific lists
+ has the effect of putting BUFFER at the end
+ of the combined list in each frame. */
+ frames_discard_buffer (buffer);
}
return Qnil;
if (byte_pos == BEG)
/* Beginning of buffer is always a character boundary. */
- return 1;
+ return BEG;
c = FETCH_BYTE (byte_pos);
if (! CHAR_HEAD_P (c))
p = GAP_END_ADDR;
stop = Z;
}
-
+
if (UNIBYTE_STR_AS_MULTIBYTE_P (p, stop - pos, bytes))
p += bytes, pos += bytes;
else
if (!modified_p && !NILP (Fbuffer_modified_p (Qnil)))
Fset_buffer_modified_p (Qnil);
+#ifdef subprocesses
+ /* Update coding systems of this buffer's process (if any). */
+ {
+ Lisp_Object process;
+
+ process = Fget_buffer_process (Fcurrent_buffer ());
+ if (PROCESSP (process))
+ setup_process_coding_systems (process);
+ }
+#endif /* subprocesses */
+
return flag;
}
\f
reset_buffer_local_variables (current_buffer, 0);
- /* Redisplay mode lines; we are changing major mode. */
-
- update_mode_lines++;
-
/* Any which are supposed to be permanent,
make local again, with the same values they had. */
-
+
for (alist = oalist; !NILP (alist); alist = XCDR (alist))
{
sym = XCAR (XCAR (alist));
}
\f
/* 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.
+ 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,
or ZV if there are no more overlays.
{
if (extend)
{
- *len_ptr = len *= 2;
+ /* Make it work with an initial len == 0. */
+ len *= 2;
if (len == 0)
- len = *len_ptr = 4;
+ len = 4;
+ *len_ptr = len;
vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
*vec_ptr = vec;
}
/* Find all the overlays in the current buffer that overlap the range BEG-END
or are empty at BEG.
- Return the number found, and store them in a vector in *VEC_PTR.
+ 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,
or ZV if there are no more overlays.
and we store only as many overlays as will fit.
But we still return the total number of overlays. */
-int
+static int
overlays_in (beg, end, extend, vec_ptr, len_ptr, next_ptr, prev_ptr)
int beg, end;
int extend;
Either make it bigger, or don't store any more in it. */
if (extend)
{
- *len_ptr = len *= 2;
+ /* Make it work with an initial len == 0. */
+ len *= 2;
+ if (len == 0)
+ len = 4;
+ *len_ptr = len;
vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
*vec_ptr = vec;
}
{
if (extend)
{
- *len_ptr = len *= 2;
+ /* Make it work with an initial len == 0. */
+ len *= 2;
+ if (len == 0)
+ len = 4;
+ *len_ptr = len;
vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
*vec_ptr = vec;
}
int end = OVERLAY_POSITION (OVERLAY_END (overlay));
int n, i, size;
Lisp_Object *v, tem;
-
+
size = 10;
v = (Lisp_Object *) alloca (size * sizeof *v);
n = overlays_in (start, end, 0, &v, &size, NULL, NULL);
ssl->used++;
if (NILP (current_buffer->enable_multibyte_characters))
- nbytes = XSTRING (str)->size;
+ nbytes = SCHARS (str);
else if (! STRING_MULTIBYTE (str))
- nbytes = count_size_as_multibyte (XSTRING (str)->data,
- STRING_BYTES (XSTRING (str)));
+ nbytes = count_size_as_multibyte (SDATA (str),
+ SBYTES (str));
else
- nbytes = STRING_BYTES (XSTRING (str));
+ nbytes = SBYTES (str);
ssl->bytes += nbytes;
if (STRINGP (str2))
{
if (NILP (current_buffer->enable_multibyte_characters))
- nbytes = XSTRING (str2)->size;
+ nbytes = SCHARS (str2);
else if (! STRING_MULTIBYTE (str2))
- nbytes = count_size_as_multibyte (XSTRING (str2)->data,
- STRING_BYTES (XSTRING (str2)));
+ nbytes = count_size_as_multibyte (SDATA (str2),
+ SBYTES (str2));
else
- nbytes = STRING_BYTES (XSTRING (str2));
+ nbytes = SBYTES (str2);
ssl->bytes += nbytes;
}
{
int nbytes;
tem = overlay_tails.buf[i].string;
- nbytes = copy_text (XSTRING (tem)->data, p,
- STRING_BYTES (XSTRING (tem)),
+ nbytes = copy_text (SDATA (tem), p,
+ SBYTES (tem),
STRING_MULTIBYTE (tem), multibyte);
p += nbytes;
}
{
int nbytes;
tem = overlay_heads.buf[i].string;
- nbytes = copy_text (XSTRING (tem)->data, p,
- STRING_BYTES (XSTRING (tem)),
+ nbytes = copy_text (SDATA (tem), p,
+ SBYTES (tem),
STRING_MULTIBYTE (tem), multibyte);
p += nbytes;
tem = overlay_heads.buf[i].string2;
if (STRINGP (tem))
{
- nbytes = copy_text (XSTRING (tem)->data, p,
- STRING_BYTES (XSTRING (tem)),
+ nbytes = copy_text (SDATA (tem), p,
+ SBYTES (tem),
STRING_MULTIBYTE (tem), multibyte);
p += nbytes;
}
{
Lisp_Object overlay;
Lisp_Object before_list, after_list;
- Lisp_Object *ptail, *pbefore = &before_list, *pafter = &after_list;
+ /* These are either nil, indicating that before_list or after_list
+ should be assigned, or the cons cell the cdr of which should be
+ assigned. */
+ Lisp_Object beforep = Qnil, afterp = Qnil;
+ /* 'Parent', likewise, indicates a cons cell or
+ current_buffer->overlays_before or overlays_after, depending
+ which loop we're in. */
+ Lisp_Object tail, parent;
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);)
+ well-formed list except that its last element, the CDR of beforep
+ (resp. afterp) if beforep (afterp) isn't nil or before_list
+ (after_list) if it is, is still uninitialized. So it's not a bug
+ that before_list isn't initialized, although it may look
+ strange. */
+ for (parent = Qnil, tail = current_buffer->overlays_before; CONSP (tail);)
{
- overlay = XCAR (*ptail);
+ overlay = XCAR (tail);
endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
if (endpos < start)
break;
recenter_overlay_lists will move it to the right place. */
if (endpos < XINT (current_buffer->overlay_center))
{
- *pafter = *ptail;
- pafter = &XCDR (*ptail);
+ if (NILP (afterp))
+ after_list = tail;
+ else
+ XSETCDR (afterp, tail);
+ afterp = tail;
}
else
{
- *pbefore = *ptail;
- pbefore = &XCDR (*ptail);
+ if (NILP (beforep))
+ before_list = tail;
+ else
+ XSETCDR (beforep, tail);
+ beforep = tail;
}
- *ptail = XCDR (*ptail);
+ if (NILP (parent))
+ current_buffer->overlays_before = XCDR (tail);
+ else
+ XSETCDR (parent, XCDR (tail));
+ tail = XCDR (tail);
}
else
- ptail = &XCDR (*ptail);
+ parent = tail, tail = XCDR (parent);
}
- for (ptail = ¤t_buffer->overlays_after; CONSP (*ptail);)
+ for (parent = Qnil, tail = current_buffer->overlays_after; CONSP (tail);)
{
- overlay = XCAR (*ptail);
+ overlay = XCAR (tail);
startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
if (startpos >= end)
break;
}
if (endpos < XINT (current_buffer->overlay_center))
{
- *pafter = *ptail;
- pafter = &XCDR (*ptail);
+ if (NILP (afterp))
+ after_list = tail;
+ else
+ XSETCDR (afterp, tail);
+ afterp = tail;
}
else
{
- *pbefore = *ptail;
- pbefore = &XCDR (*ptail);
+ if (NILP (beforep))
+ before_list = tail;
+ else
+ XSETCDR (beforep, tail);
+ beforep = tail;
}
- *ptail = XCDR (*ptail);
+ if (NILP (parent))
+ current_buffer->overlays_after = XCDR (tail);
+ else
+ XSETCDR (parent, XCDR (tail));
+ tail = XCDR (tail);
}
else
- ptail = &XCDR (*ptail);
+ parent = tail, tail = XCDR (parent);
}
/* 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;
+ if (!NILP (beforep))
+ {
+ XSETCDR (beforep, 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;
+ if (!NILP (afterp))
+ {
+ XSETCDR (afterp, current_buffer->overlays_after);
+ current_buffer->overlays_after = after_list;
+ }
recenter_overlay_lists (current_buffer,
XINT (current_buffer->overlay_center));
}
struct buffer *bp;
int prev, pos;
{
- Lisp_Object *tailp = &bp->overlays_before;
- Lisp_Object *right_place;
+ /* If parent is nil, replace overlays_before; otherwise, XCDR(parent). */
+ Lisp_Object tail = bp->overlays_before, parent = Qnil;
+ Lisp_Object right_pair;
int end;
/* After the insertion, the several overlays may be in incorrect
in. It is where an overlay which end before POS exists. (i.e. an
overlay whose ending marker is after-insertion-marker if disorder
exists). */
- while (!NILP (*tailp)
- && ((end = OVERLAY_POSITION (OVERLAY_END (XCAR (*tailp))))
+ while (!NILP (tail)
+ && ((end = OVERLAY_POSITION (OVERLAY_END (XCAR (tail))))
>= pos))
- tailp = &XCDR (*tailp);
+ {
+ parent = tail;
+ tail = XCDR (tail);
+ }
/* If we don't find such an overlay,
or the found one ends before PREV,
or the found one is the last one in the list,
we don't have to fix anything. */
- if (NILP (*tailp)
+ if (NILP (tail)
|| end < prev
- || NILP (XCDR (*tailp)))
+ || NILP (XCDR (tail)))
return;
- right_place = tailp;
- tailp = &XCDR (*tailp);
+ right_pair = parent;
+ parent = tail;
+ tail = XCDR (tail);
- /* Now, end position of overlays in the list *TAILP should be before
+ /* Now, end position of overlays in the list TAIL should be before
or equal to PREV. In the loop, an overlay which ends at POS is
- moved ahead to the place pointed by RIGHT_PLACE. If we found an
- overlay which ends before PREV, the remaining overlays are in
- correct order. */
- while (!NILP (*tailp))
+ moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
+ we found an overlay which ends before PREV, the remaining
+ overlays are in correct order. */
+ while (!NILP (tail))
{
- end = OVERLAY_POSITION (OVERLAY_END (XCAR (*tailp)));
+ end = OVERLAY_POSITION (OVERLAY_END (XCAR (tail)));
if (end == pos)
{ /* This overlay is disordered. */
- Lisp_Object found = *tailp;
+ Lisp_Object found = tail;
/* Unlink the found overlay. */
- *tailp = XCDR (found);
- /* Move an overlay at RIGHT_PLACE to the next of the found one. */
- XCDR (found) = *right_place;
- /* Link it into the right place. */
- *right_place = found;
+ tail = XCDR (found);
+ XSETCDR (parent, tail);
+ /* Move an overlay at RIGHT_PLACE to the next of the found one,
+ and link it into the right place. */
+ if (NILP (right_pair))
+ {
+ XSETCDR (found, bp->overlays_before);
+ bp->overlays_before = found;
+ }
+ else
+ {
+ XSETCDR (found, XCDR (right_pair));
+ XSETCDR (right_pair, found);
+ }
}
else if (end == prev)
- tailp = &XCDR (*tailp);
+ {
+ parent = tail;
+ tail = XCDR (tail);
+ }
else /* No more disordered overlay. */
break;
}
XOVERLAY (overlay)->end = end;
XOVERLAY (overlay)->plist = Qnil;
- /* Put the new overlay on the wrong list. */
+ /* Put the new overlay on the wrong list. */
end = OVERLAY_END (overlay);
if (OVERLAY_POSITION (end) < XINT (b->overlay_center))
b->overlays_after = Fcons (overlay, b->overlays_after);
}
BUF_COMPUTE_UNCHANGED (buf, start, end);
-
+
/* If this is a buffer not in the selected window,
we must do other windows. */
if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
{
struct buffer *b, *ob;
Lisp_Object obuffer;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
CHECK_OVERLAY (overlay);
if (NILP (buffer))
Fset_marker (OVERLAY_START (overlay), beg, buffer);
Fset_marker (OVERLAY_END (overlay), end, buffer);
- /* Put the overlay on the wrong list. */
+ /* Put the overlay on the wrong list. */
end = OVERLAY_END (overlay);
if (OVERLAY_POSITION (end) < XINT (b->overlay_center))
b->overlays_after = Fcons (overlay, b->overlays_after);
{
Lisp_Object buffer;
struct buffer *b;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
CHECK_OVERLAY (overlay);
b = XBUFFER (buffer);
specbind (Qinhibit_quit, Qt);
-
+
b->overlays_before = Fdelq (overlay, b->overlays_before);
b->overlays_after = Fdelq (overlay, b->overlays_after);
modify_overlay (b,
}
DEFUN ("overlay-recenter", Foverlay_recenter, Soverlay_recenter, 1, 1, 0,
- doc: /* Recenter the overlays of the current buffer around position POS. */)
+ doc: /* Recenter the overlays of the current buffer around position POS.
+That makes overlay lookup faster for positions near POS (but perhaps slower
+for positions far away from POS). */)
(pos)
Lisp_Object pos;
{
(overlay, prop)
Lisp_Object overlay, prop;
{
- Lisp_Object plist, fallback;
-
CHECK_OVERLAY (overlay);
-
- fallback = Qnil;
-
- for (plist = XOVERLAY (overlay)->plist;
- CONSP (plist) && CONSP (XCDR (plist));
- plist = XCDR (XCDR (plist)))
- {
- if (EQ (XCAR (plist), prop))
- return XCAR (XCDR (plist));
- else if (EQ (XCAR (plist), Qcategory))
- {
- Lisp_Object tem;
- tem = Fcar (Fcdr (plist));
- if (SYMBOLP (tem))
- fallback = Fget (tem, prop);
- }
- }
-
- return fallback;
+ return lookup_char_property (XOVERLAY (overlay)->plist, prop, 0);
}
DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
if (! after)
add_overlay_mod_hooklist (list, overlay);
- while (!NILP (list))
+ while (CONSP (list))
{
if (NILP (arg3))
- call4 (Fcar (list), overlay, after ? Qt : Qnil, arg1, arg2);
+ call4 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2);
else
- call5 (Fcar (list), overlay, after ? Qt : Qnil, arg1, arg2, arg3);
- list = Fcdr (list);
+ call5 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2, arg3);
+ list = XCDR (list);
}
UNGCPRO;
}
{
Lisp_Object sym;
char *type_name;
-
+
switch (XINT (PER_BUFFER_TYPE (offset)))
{
case Lisp_Int:
type_name = "integers";
break;
-
+
case Lisp_String:
type_name = "strings";
break;
-
+
case Lisp_Symbol:
type_name = "symbols";
break;
-
+
default:
abort ();
}
sym = PER_BUFFER_SYMBOL (offset);
error ("Only %s should be stored in the buffer-local variable %s",
- type_name, XSYMBOL (sym)->name->data);
+ type_name, SDATA (SYMBOL_NAME (sym)));
}
\f
{
/* User-specified size. */
size_t nbytes_specified;
-
+
/* Number of bytes mapped */
size_t nbytes_mapped;
#define MEM_ALIGN sizeof (double)
+/* Predicate returning true if part of the address range [START .. END]
+ is currently mapped. Used to prevent overwriting an existing
+ memory mapping.
+
+ Default is to conservativly assume the address range is occupied by
+ something else. This can be overridden by system configuration
+ files if system-specific means to determine this exists. */
+
+#ifndef MMAP_ALLOCATED_P
+#define MMAP_ALLOCATED_P(start, end) 1
+#endif
+
/* Function prototypes. */
static int mmap_free_1 P_ ((struct mmap_region *));
{
struct mmap_region *r;
char *s = (char *) start, *e = (char *) end;
-
+
for (r = mmap_regions; r; r = r->next)
{
char *rstart = (char *) r;
r->prev->next = r->next;
else
mmap_regions = r->next;
-
+
if (munmap ((POINTER_TYPE *) r, r->nbytes_mapped) == -1)
{
fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
}
else if (npages > 0)
{
- struct mmap_region *r2;
-
nbytes = npages * mmap_page_size;
-
+
/* Try to map additional pages at the end of the region. We
cannot do this if the address range is already occupied by
something else because mmap deletes any previous mapping.
I'm not sure this is worth doing, let's see. */
- r2 = mmap_find (region_end, region_end + nbytes);
- if (r2 == NULL)
+ if (!MMAP_ALLOCATED_P (region_end, region_end + nbytes))
{
POINTER_TYPE *p;
-
+
p = mmap (region_end, nbytes, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE | MAP_FIXED, mmap_fd, 0);
if (p == MAP_FAILED)
map = ROUND (nbytes + MMAP_REGION_STRUCT_SIZE, mmap_page_size);
p = mmap (NULL, map, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
mmap_fd, 0);
-
+
if (p == MAP_FAILED)
{
if (errno != ENOMEM)
else
{
struct mmap_region *r = (struct mmap_region *) p;
-
+
r->nbytes_specified = nbytes;
r->nbytes_mapped = map;
r->var = var;
if (r->next)
r->next->prev = r;
mmap_regions = r;
-
+
p = MMAP_USER_AREA (p);
}
-
+
return *var = p;
}
size_t nbytes;
{
POINTER_TYPE *result;
-
+
mmap_init ();
if (*var == NULL)
result = mmap_alloc (var, nbytes);
- else if (nbytes == 0)
+ else if (nbytes == 0)
{
mmap_free (var);
result = mmap_alloc (var, nbytes);
{
struct mmap_region *r = MMAP_REGION (*var);
size_t room = r->nbytes_mapped - MMAP_REGION_STRUCT_SIZE;
-
+
if (room < nbytes)
{
/* Must enlarge. */
else if (room - nbytes >= mmap_page_size)
{
/* Shrinking by at least a page. Let's give some
- memory back to the system. */
- mmap_enlarge (r, - (room - nbytes) / mmap_page_size);
+ memory back to the system.
+
+ The extra parens are to make the division happens first,
+ on positive values, so we know it will round towards
+ zero. */
+ mmap_enlarge (r, - ((room - nbytes) / mmap_page_size));
result = *var;
r->nbytes_specified = nbytes;
}
POINTER_TYPE **var;
{
mmap_init ();
-
+
if (*var)
{
mmap_free_1 (MMAP_REGION (*var));
if (mmap_initialized_p)
return;
mmap_initialized_p = 1;
-
+
#if MAP_ANON != 0
mmap_fd = -1;
#endif
-
+
mmap_page_size = getpagesize ();
}
size_t nbytes;
{
POINTER_TYPE *p;
-
+
BLOCK_INPUT;
#if defined USE_MMAP_FOR_BUFFERS
p = mmap_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
#else
p = xmalloc (nbytes);
#endif
-
+
if (p == NULL)
{
UNBLOCK_INPUT;
#else
p = xrealloc (b->text->beg, nbytes);
#endif
-
+
if (p == NULL)
{
UNBLOCK_INPUT;
#else
xfree (b->text->beg);
#endif
-
+
BUF_BEG_ADDR (b) = NULL;
UNBLOCK_INPUT;
}
XSETFASTINT (buffer_local_flags.cache_long_line_scans, idx); ++idx;
XSETFASTINT (buffer_local_flags.category_table, idx); ++idx;
XSETFASTINT (buffer_local_flags.direction_reversed, idx); ++idx;
- XSETFASTINT (buffer_local_flags.buffer_file_coding_system, idx);
+ XSETFASTINT (buffer_local_flags.buffer_file_coding_system, idx);
/* Make this one a permanent local. */
buffer_permanent_local_flags[idx++] = 1;
XSETFASTINT (buffer_local_flags.left_margin_width, idx); ++idx;
if (idx >= MAX_PER_BUFFER_VARS)
abort ();
last_per_buffer_idx = idx;
-
+
Vbuffer_alist = Qnil;
current_buffer = 0;
all_buffers = 0;
Qkill_buffer_hook = intern ("kill-buffer-hook");
+ Qucs_set_table_for_input = intern ("ucs-set-table-for-input");
+
Vprin1_to_string_buffer = Fget_buffer_create (build_string (" prin1"));
/* super-magic invisible buffer */
text pointers will have been set to null in the dumped Emacs.
Map new memory. */
struct buffer *b;
-
+
for (b = all_buffers; b; b = b->next)
if (b->text->beg == NULL)
enlarge_buffer_text (b, 0);
}
#endif /* USE_MMAP_FOR_BUFFERS */
-
+
Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
if (NILP (buffer_defaults.enable_multibyte_characters))
Fset_buffer_multibyte (Qnil);
- /* If PWD is accurate, use it instead of calling getwd. This is faster
- when PWD is right, and may avoid a fatal error. */
+ /* 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
because of the ange-ftp completion handler.
However, it is not necessary to turn / into /:/.
So avoid doing that. */
- && strcmp ("/", XSTRING (current_buffer->directory)->data))
+ && strcmp ("/", SDATA (current_buffer->directory)))
current_buffer->directory
= concat2 (build_string ("/:"), current_buffer->directory);
staticpro (&Qbefore_change_functions);
Qafter_change_functions = intern ("after-change-functions");
staticpro (&Qafter_change_functions);
+ staticpro (&Qucs_set_table_for_input);
+
+ Qkill_buffer_query_functions = intern ("kill-buffer-query-functions");
+ staticpro (&Qkill_buffer_query_functions);
Fput (Qprotected_field, Qerror_conditions,
Fcons (Qprotected_field, Fcons (Qerror, Qnil)));
&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.
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.
This is the same as (default-value 'buffer-file-coding-system). */);
-
+
DEFVAR_LISP_NOPRO ("default-truncate-lines",
&buffer_defaults.truncate_lines,
doc: /* Default value of `truncate-lines' for buffers that do not override it.
This is the same as (default-value 'case-fold-search). */);
#ifdef DOS_NT
- DEFVAR_LISP_NOPRO ("default-buffer-file-type",
+ DEFVAR_LISP_NOPRO ("default-buffer-file-type",
&buffer_defaults.buffer_file_type,
doc: /* Default file type for buffers that do not override it.
This is the same as (default-value 'buffer-file-type).
&buffer_defaults.right_margin_width,
doc: /* Default value of `right_margin_width' for buffers that don't override it.
This is the same as (default-value 'right-margin-width). */);
-
+
DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
&buffer_defaults.indicate_empty_lines,
doc: /* Default value of `indicate-empty-lines' for buffers that don't override it.
This is the same as (default-value 'indicate-empty-lines). */);
-
+
DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
&buffer_defaults.scroll_up_aggressively,
- doc: /* Default value of `scroll-up-aggressively' for buffers that
-don't override it. This is the same as (default-value
-'scroll-up-aggressively). */);
-
+ doc: /* Default value of `scroll-up-aggressively'.
+This value applies in buffers that don't have their own local values.
+This variable is an alias for (default-value 'scroll-up-aggressively). */);
+
DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
&buffer_defaults.scroll_down_aggressively,
- doc: /* Default value of `scroll-down-aggressively' for buffers that
-don't override it. This is the same as (default-value
-'scroll-down-aggressively). */);
-
+ doc: /* Default value of `scroll-down-aggressively'.
+This value applies in buffers that don't have their own local values.
+This variable is an alias for (default-value 'scroll-down-aggressively). */);
+
DEFVAR_PER_BUFFER ("header-line-format",
¤t_buffer->header_line_format,
Qnil,
- doc: /* Analogous to `mode-line-format', but for the mode line that can be
-displayed at the top of a window. */);
-
+ doc: /* Analogous to `mode-line-format', but controls the header line.
+The header line appears, optionally, at the top of a window;
+the mode line appears at the bottom. */);
+
DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
Qnil,
doc: /* Template for displaying mode line for current buffer.
For a symbol, its value is used (but it is ignored if t or nil).
A string appearing directly as the value of a symbol is processed verbatim
in that the %-constructs below are not recognized.
+ Note that unless the symbol is marked as a `risky-local-variable', all
+ properties in any strings, as well as all :eval and :propertize forms
+ in the value of that symbol will be ignored.
For a list of the form `(:eval FORM)', FORM is evaluated and the result
- is used as a mode line element.
+ is used as a mode line element. Be careful--FORM should not load any files,
+ because that can cause an infinite recursion.
+For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
+ with the specified properties PROPS applied.
For a list whose car is a symbol, the symbol's value is taken,
and if that is non-nil, the cadr of the list is processed recursively.
Otherwise, the caddr of the list (if there is one) is processed.
doc: /* Symbol for current buffer's major mode. */);
DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer->mode_name,
- make_number (Lisp_String),
+ Qnil,
doc: /* Pretty name of current buffer's major mode (a string). */);
DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer->abbrev_mode, Qnil,
DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer->fill_column,
make_number (Lisp_Int),
- doc: /* *Column beyond which automatic line-wrapping should happen. */);
+ doc: /* *Column beyond which automatic line-wrapping should happen.
+Interactively, you can set this using \\[set-fill-column]. */);
DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer->left_margin,
make_number (Lisp_Int),
DEFVAR_PER_BUFFER ("enable-multibyte-characters",
¤t_buffer->enable_multibyte_characters,
- make_number (-1),
+ Qnil,
doc: /* Non-nil means the buffer contents are regarded as multi-byte characters.
Otherwise they are regarded as unibyte. This affects the display,
file I/O and the behavior of various editing commands.
Changing its default value with `setq-default' is supported.
See also variable `default-enable-multibyte-characters' and Info node
`(elisp)Text Representations'. */);
+ XSYMBOL (intern ("enable-multibyte-characters"))->constant = 1;
DEFVAR_PER_BUFFER ("buffer-file-coding-system",
¤t_buffer->buffer_file_coding_system, Qnil,
unless some coding system is specified in `file-coding-system-alist'
for the buffer file.
+If the text to be saved cannot be encoded as specified by this variable,
+an alternative encoding is selected by `select-safe-coding-system', which see.
+
The variable `coding-system-for-write', if non-nil, overrides this variable.
This variable is never applied to a way of decoding a file while reading it. */);
doc: /* *Non-nil means lines in the buffer are displayed right to left. */);
DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer->truncate_lines, Qnil,
- doc: /* *Non-nil means do not display continuation lines;
-give each line of text one screen line.
+ doc: /* *Non-nil means do not display continuation lines.
+Instead, give each line of text just one screen line.
Note that this is overridden by the variable
`truncate-partial-width-windows' if that variable is non-nil
DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
¤t_buffer->auto_save_file_name,
make_number (Lisp_String),
- doc: /* Name of file for auto-saving current buffer,
-or nil if buffer should not be auto-saved. */);
+ doc: /* Name of file for auto-saving current buffer.
+If it is nil, that means don't auto-save this buffer. */);
DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer->read_only, Qnil,
doc: /* Non-nil if this buffer is read-only. */);
DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer->selective_display,
Qnil,
- doc: /* Non-nil enables selective display:
-Integer N as value means display only lines
- that start with less than n columns of space.
-A value of t means, after a ^M, all the rest of the line is invisible.
- Then ^M's in the file are written into files as newlines. */);
+ doc: /* Non-nil enables selective display.
+An Integer N as value means display only lines
+that start with less than n columns of space.
+A value of t means that the character ^M makes itself and
+all the rest of the line invisible; also, when saving the buffer
+in a file, save the ^M as a newline. */);
#ifndef old
DEFVAR_PER_BUFFER ("selective-display-ellipses",
Qnil,
doc: /* *Width of left marginal area for display of a buffer.
A value of nil means no marginal area. */);
-
+
DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer->right_margin_width,
Qnil,
doc: /* *Width of right marginal area for display of a buffer.
A value of nil means no marginal area. */);
-
+
DEFVAR_PER_BUFFER ("indicate-empty-lines",
¤t_buffer->indicate_empty_lines, Qnil,
doc: /* *Visually indicate empty lines after the buffer end.
If non-nil, a bitmap is displayed in the left fringe of a window on
window-systems. */);
-
+
DEFVAR_PER_BUFFER ("scroll-up-aggressively",
¤t_buffer->scroll_up_aggressively, Qnil,
- doc: /* *If a number, scroll display up aggressively.
-If scrolling a window because point is above the window start, choose
-a new window start so that point ends up that fraction of the window's
-height from the top of the window. */);
-
+ doc: /* How far to scroll windows upward.
+If you move point off the bottom, the window scrolls automatically.
+This variable controls how far it scrolls. nil, the default,
+means scroll to center point. A fraction means scroll to put point
+that fraction of the window's height from the bottom of the window.
+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
+between 0.0 and 1.0, inclusive. */);
+
DEFVAR_PER_BUFFER ("scroll-down-aggressively",
¤t_buffer->scroll_down_aggressively, Qnil,
- doc: /* *If a number, scroll display down aggressively.
-If scrolling a window because point is below the window end, choose
-a new window start so that point ends up that fraction of the window's
-height from the bottom of the window. */);
-
+ doc: /* How far to scroll windows downward.
+If you move point off the top, the window scrolls automatically.
+This variable controls how far it scrolls. nil, the default,
+means scroll to center point. A fraction means scroll to put point
+that fraction of the window's height from the top of the window.
+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
+between 0.0 and 1.0, inclusive. */);
+
/*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
"Don't ask.");
*/
Vbefore_change_functions = Qnil;
DEFVAR_LISP ("after-change-functions", &Vafter_change_functions,
- doc: /* List of function to call after each text change.
+ doc: /* List of functions to call after each text change.
Three arguments are passed to each function: the positions of
the beginning and end of the range of changed text,
and the length in bytes of the pre-change text replaced by that range.
DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer->file_format, Qnil,
doc: /* List of formats to use when saving this buffer.
Formats are defined by `format-alist'. This variable is
-set when a file is visited. Automatically local in all buffers. */);
+set when a file is visited. */);
DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
¤t_buffer->invisibility_spec, Qnil,
Vinhibit_read_only = Qnil;
DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer->cursor_type, Qnil,
- doc: /* Cursor to use in window displaying this buffer.
+ 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
- `bar' display a bar cursor with default width
- (bar . WIDTH) display a bar cursor with width WIDTH
- others display a box cursor. */);
+ t use the cursor specified for the frame
+ nil don't display a cursor
+ bar display a bar cursor with default width
+ (bar . WIDTH) display a bar cursor with width WIDTH
+ ANYTHING ELSE display a box cursor.
+
+When the buffer is displayed in a nonselected window,
+this variable has no effect; the cursor appears as a hollow box. */);
DEFVAR_PER_BUFFER ("line-spacing",
¤t_buffer->extra_line_spacing, Qnil,
HCoop / bpt / emacs.git / blobdiff