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;
}
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->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)
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));
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;
}
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. */
{
GCPRO1 (buf);
tem = do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
- XSTRING (b->name)->data));
+ SDATA (b->name)));
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;
record_unwind_protect (save_excursion_restore, save_excursion_save ());
/* 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))
+ for (list = Vkill_buffer_query_functions; CONSP (list); list = XCDR (list))
{
- tem = call0 (Fcar (list));
+ tem = call0 (XCAR (list));
if (NILP (tem))
return unbind_to (count, Qnil);
}
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
{
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. */
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))
{
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;
}
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;
}
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;
}
{
struct buffer *b, *ob;
Lisp_Object obuffer;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
CHECK_OVERLAY (overlay);
if (NILP (buffer))
{
Lisp_Object buffer;
struct buffer *b;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
CHECK_OVERLAY (overlay);
(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;
}
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
#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
+/* 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
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;
}
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 */
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);
Fput (Qprotected_field, Qerror_conditions,
Fcons (Qprotected_field, Fcons (Qerror, Qnil)));
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.
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),
doc: /* *If a number, scroll display up 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. */);
+height from the bottom of the window. 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 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. */);
+height from the top of the window. 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.
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,