/* Buffer manipulation primitives for GNU Emacs.
- Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994, 1995, 1997
+ Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000
Free Software Foundation, Inc.
This file is part of GNU Emacs.
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
+#include <errno.h>
+
+#ifndef USE_CRT_DLL
+extern int errno;
+#endif
#ifndef MAXPATHLEN
/* in 4.1, param.h fails to define this. */
#define MAXPATHLEN 1024
#endif /* not MAXPATHLEN */
-#include <config.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
#include "lisp.h"
#include "intervals.h"
#include "window.h"
#include "region-cache.h"
#include "indent.h"
#include "blockinput.h"
+#include "keyboard.h"
#include "frame.h"
struct buffer *current_buffer; /* the current buffer */
The value has only one nonzero bit.
When a buffer has its own local value for a slot,
- the bit for that slot (found in the same slot in this structure)
- is turned on in the buffer's local_var_flags slot.
+ the entry for that slot (found in the same slot in this structure)
+ is turned on in the buffer's local_flags array.
If a slot in this structure is -1, then even though there may
be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
buffer-local slots. If a slot contains Qnil, then the
corresponding buffer slot may contain a value of any type. If a
slot contains an integer, then prospective values' tags must be
- equal to that integer. When a tag does not match, the function
- buffer_slot_type_mismatch will signal an error. */
+ equal to that integer (except nil is always allowed).
+ When a tag does not match, the function
+ buffer_slot_type_mismatch will signal an error.
+
+ If a slot here contains -1, the corresponding variable is read-only. */
struct buffer buffer_local_types;
/* Flags indicating which built-in buffer-local variables
are permanent locals. */
-static int buffer_permanent_local_flags;
+static char buffer_permanent_local_flags[MAX_PER_BUFFER_VARS];
+
+/* Number of per-buffer variables used. */
+
+int last_per_buffer_idx;
Lisp_Object Fset_buffer ();
void set_buffer_internal ();
Lisp_Object Vbuffer_alist;
/* Functions to call before and after each text change. */
-Lisp_Object Vbefore_change_function;
-Lisp_Object Vafter_change_function;
Lisp_Object Vbefore_change_functions;
Lisp_Object Vafter_change_functions;
Lisp_Object Qbefore_change_functions;
Lisp_Object Qafter_change_functions;
+/* If nonzero, all modification hooks are suppressed. */
+int inhibit_modification_hooks;
+
Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
Lisp_Object Qprotected_field;
Lisp_Object Qinsert_in_front_hooks;
Lisp_Object Qinsert_behind_hooks;
+static void alloc_buffer_text P_ ((struct buffer *, size_t));
+static void free_buffer_text P_ ((struct buffer *b));
+
+
/* For debugging; temporary. See set_buffer_internal. */
/* Lisp_Object Qlisp_mode, Vcheck_symbol; */
+void
nsberror (spec)
Lisp_Object spec;
{
tail = framelist;
while (! NILP (tail))
{
- general = Fdelq (XCONS (tail)->car, general);
- tail = XCONS (tail)->cdr;
+ general = Fdelq (XCAR (tail), general);
+ tail = XCDR (tail);
}
return nconc2 (framelist, general);
}
if (!NILP (handler))
return call2 (handler, Qget_file_buffer, filename);
- for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
{
- buf = Fcdr (XCONS (tail)->car);
+ buf = Fcdr (XCAR (tail));
if (!BUFFERP (buf)) continue;
if (!STRINGP (XBUFFER (buf)->filename)) continue;
tem = Fstring_equal (XBUFFER (buf)->filename, filename);
{
register Lisp_Object tail, buf, tem;
- for (tail = Vbuffer_alist; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
{
- buf = Fcdr (XCONS (tail)->car);
+ buf = Fcdr (XCAR (tail));
if (!BUFFERP (buf)) continue;
if (!STRINGP (XBUFFER (buf)->file_truename)) continue;
tem = Fstring_equal (XBUFFER (buf)->file_truename, filename);
if (XSTRING (name)->size == 0)
error ("Empty string for buffer name is not allowed");
- b = (struct buffer *) xmalloc (sizeof (struct buffer));
+ b = (struct buffer *) allocate_buffer ();
b->size = sizeof (struct buffer) / sizeof (EMACS_INT);
BLOCK_INPUT;
/* We allocate extra 1-byte at the tail and keep it always '\0' for
anchoring a search. */
- BUFFER_ALLOC (BUF_BEG_ADDR (b), (BUF_GAP_SIZE (b) + 1));
+ alloc_buffer_text (b, BUF_GAP_SIZE (b) + 1);
UNBLOCK_INPUT;
if (! BUF_BEG_ADDR (b))
buffer_memory_full ();
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_MODIFF (b) = 1;
BUF_OVERLAY_MODIFF (b) = 1;
BUF_SAVE_MODIFF (b) = 1;
BUF_INTERVALS (b) = 0;
+ BUF_UNCHANGED_MODIFIED (b) = 1;
+ BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
+ BUF_END_UNCHANGED (b) = 0;
+ BUF_BEG_UNCHANGED (b) = 0;
*(BUF_GPT_ADDR (b)) = *(BUF_Z_ADDR (b)) = 0; /* Put an anchor '\0'. */
b->newline_cache = 0;
b->width_run_cache = 0;
b->width_table = Qnil;
+ b->prevent_redisplay_optimizations_p = 1;
/* Put this on the chain of all buffers including killed ones. */
b->next = all_buffers;
b->zv_marker = Qnil;
name = Fcopy_sequence (name);
- INITIALIZE_INTERVAL (XSTRING (name), NULL_INTERVAL);
+ XSTRING (name)->intervals = NULL_INTERVAL;
b->name = name;
if (XSTRING (name)->data[0] != ' ')
return buf;
}
-DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, Smake_indirect_buffer, 2, 2,
+
+/* Clone per-buffer values of buffer FROM.
+
+ Buffer TO gets the same per-buffer values as FROM, with the
+ following exceptions: (1) TO's name is left untouched, (2) markers
+ are copied and made to refer to TO, and (3) overlay lists are
+ copied. */
+
+static void
+clone_per_buffer_values (from, to)
+ struct buffer *from, *to;
+{
+ Lisp_Object to_buffer;
+ int offset;
+
+ XSETBUFFER (to_buffer, to);
+
+ for (offset = PER_BUFFER_VAR_OFFSET (name) + sizeof (Lisp_Object);
+ offset < sizeof *to;
+ offset += sizeof (Lisp_Object))
+ {
+ Lisp_Object obj;
+
+ obj = PER_BUFFER_VALUE (from, offset);
+ if (MARKERP (obj))
+ {
+ struct Lisp_Marker *m = XMARKER (obj);
+ obj = Fmake_marker ();
+ XMARKER (obj)->insertion_type = m->insertion_type;
+ set_marker_both (obj, to_buffer, m->charpos, m->bytepos);
+ }
+
+ PER_BUFFER_VALUE (to, offset) = obj;
+ }
+
+ to->overlays_after = Fcopy_sequence (from->overlays_after);
+ to->overlays_before = Fcopy_sequence (to->overlays_before);
+ bcopy (from->local_flags, to->local_flags, sizeof to->local_flags);
+}
+
+
+DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, Smake_indirect_buffer,
+ 2, 3,
"bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
"Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.\n\
BASE-BUFFER should be an existing buffer (or buffer name).\n\
-NAME should be a string which is not the name of an existing buffer.")
- (base_buffer, name)
- register Lisp_Object base_buffer, name;
+NAME should be a string which is not the name of an existing buffer.\n\
+Optional argument CLONE non-nil means preserve BASE-BUFFER's state,\n\
+such as major and minor modes, in the indirect buffer.\n\
+CLONE nil means the indirect buffer's state is reset to default values.")
+ (base_buffer, name, clone)
+ Lisp_Object base_buffer, name, clone;
{
- register Lisp_Object buf;
- register struct buffer *b;
+ Lisp_Object buf;
+ struct buffer *b;
buf = Fget_buffer (name);
if (!NILP (buf))
if (XSTRING (name)->size == 0)
error ("Empty string for buffer name is not allowed");
- b = (struct buffer *) xmalloc (sizeof (struct buffer));
-
+ b = (struct buffer *) allocate_buffer ();
b->size = sizeof (struct buffer) / sizeof (EMACS_INT);
if (XBUFFER (base_buffer)->base_buffer)
BUF_BEGV (b) = BUF_BEGV (b->base_buffer);
BUF_ZV (b) = BUF_ZV (b->base_buffer);
BUF_PT (b) = BUF_PT (b->base_buffer);
+ BUF_BEGV_BYTE (b) = BUF_BEGV_BYTE (b->base_buffer);
+ BUF_ZV_BYTE (b) = BUF_ZV_BYTE (b->base_buffer);
+ BUF_PT_BYTE (b) = BUF_PT_BYTE (b->base_buffer);
b->newline_cache = 0;
b->width_run_cache = 0;
all_buffers = b;
name = Fcopy_sequence (name);
- INITIALIZE_INTERVAL (XSTRING (name), NULL_INTERVAL);
+ XSTRING (name)->intervals = NULL_INTERVAL;
b->name = name;
reset_buffer (b);
b->mark = Fmake_marker ();
b->name = name;
+ /* The multibyte status belongs to the base buffer. */
+ b->enable_multibyte_characters = b->base_buffer->enable_multibyte_characters;
+
/* Make sure the base buffer has markers for its narrowing. */
if (NILP (b->base_buffer->pt_marker))
{
b->base_buffer->pt_marker = Fmake_marker ();
- Fset_marker (b->base_buffer->pt_marker,
- make_number (BUF_PT (b->base_buffer)), base_buffer);
+ set_marker_both (b->base_buffer->pt_marker, base_buffer,
+ BUF_PT (b->base_buffer),
+ BUF_PT_BYTE (b->base_buffer));
}
if (NILP (b->base_buffer->begv_marker))
{
b->base_buffer->begv_marker = Fmake_marker ();
- Fset_marker (b->base_buffer->begv_marker,
- make_number (BUF_BEGV (b->base_buffer)), base_buffer);
+ set_marker_both (b->base_buffer->begv_marker, base_buffer,
+ BUF_BEGV (b->base_buffer),
+ BUF_BEGV_BYTE (b->base_buffer));
}
if (NILP (b->base_buffer->zv_marker))
{
b->base_buffer->zv_marker = Fmake_marker ();
- Fset_marker (b->base_buffer->zv_marker,
- make_number (BUF_ZV (b->base_buffer)), base_buffer);
+ set_marker_both (b->base_buffer->zv_marker, base_buffer,
+ BUF_ZV (b->base_buffer),
+ BUF_ZV_BYTE (b->base_buffer));
XMARKER (b->base_buffer->zv_marker)->insertion_type = 1;
}
- /* Give the indirect buffer markers for its narrowing. */
- b->pt_marker = Fmake_marker ();
- Fset_marker (b->pt_marker, make_number (BUF_PT (b)), buf);
- b->begv_marker = Fmake_marker ();
- Fset_marker (b->begv_marker, make_number (BUF_BEGV (b)), buf);
- b->zv_marker = Fmake_marker ();
- Fset_marker (b->zv_marker, make_number (BUF_ZV (b)), buf);
-
- XMARKER (b->zv_marker)->insertion_type = 1;
+ if (NILP (clone))
+ {
+ /* Give the indirect buffer markers for its narrowing. */
+ b->pt_marker = Fmake_marker ();
+ set_marker_both (b->pt_marker, buf, BUF_PT (b), BUF_PT_BYTE (b));
+ b->begv_marker = Fmake_marker ();
+ set_marker_both (b->begv_marker, buf, BUF_BEGV (b), BUF_BEGV_BYTE (b));
+ b->zv_marker = Fmake_marker ();
+ set_marker_both (b->zv_marker, buf, BUF_ZV (b), BUF_ZV_BYTE (b));
+ XMARKER (b->zv_marker)->insertion_type = 1;
+ }
+ else
+ clone_per_buffer_values (b->base_buffer, b);
return buf;
}
XSETFASTINT (b->save_length, 0);
b->last_window_start = 1;
/* It is more conservative to start out "changed" than "unchanged". */
- b->clip_changed = 1;
+ b->clip_changed = 0;
+ b->prevent_redisplay_optimizations_p = 1;
b->backed_up = Qnil;
b->auto_save_modified = 0;
b->auto_save_failure_time = -1;
b->file_format = Qnil;
b->last_selected_window = Qnil;
XSETINT (b->display_count, 0);
- b->extra2 = Qnil;
- b->extra3 = Qnil;
+ b->display_time = Qnil;
+ 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;
}
/* Reset buffer B's local variables info.
int permanent_too;
{
register int offset;
- int dont_reset;
-
- /* Decide which built-in local variables to reset. */
- if (permanent_too)
- dont_reset = 0;
- else
- dont_reset = buffer_permanent_local_flags;
+ int i;
/* Reset the major mode to Fundamental, together with all the
things that depend on the major mode.
/* Reset all (or most) per-buffer variables to their defaults. */
b->local_var_alist = Qnil;
- b->local_var_flags &= dont_reset;
+ for (i = 0; i < last_per_buffer_idx; ++i)
+ if (permanent_too || buffer_permanent_local_flags[i] == 0)
+ SET_PER_BUFFER_VALUE_P (b, i, 0);
/* For each slot that has a default value,
copy that into the slot. */
- for (offset = (char *)&buffer_local_flags.name - (char *)&buffer_local_flags;
- offset < sizeof (struct buffer);
- offset += sizeof (Lisp_Object)) /* sizeof EMACS_INT == sizeof Lisp_Object */
+ for (offset = PER_BUFFER_VAR_OFFSET (name);
+ offset < sizeof *b;
+ offset += sizeof (Lisp_Object))
{
- int flag = XINT (*(Lisp_Object *)(offset + (char *)&buffer_local_flags));
- if ((flag > 0
- /* Don't reset a permanent local. */
- && ! (dont_reset & flag))
- || flag == -2)
- *(Lisp_Object *)(offset + (char *)b)
- = *(Lisp_Object *)(offset + (char *)&buffer_defaults);
+ int idx = PER_BUFFER_IDX (offset);
+ if ((idx > 0
+ && (permanent_too
+ || buffer_permanent_local_flags[idx] == 0))
+ /* Is -2 used anywhere? */
+ || idx == -2)
+ PER_BUFFER_VALUE (b, offset) = PER_BUFFER_DEFAULT (offset);
}
}
{
register Lisp_Object tail;
- for (tail = buf->local_var_alist; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object val, elt;
- elt = XCONS (tail)->car;
+ 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 (XCONS (elt)->car);
+ val = find_symbol_value (XCAR (elt));
/* Use the current buffer value only if buf is the current buffer. */
if (buf != current_buffer)
- val = XCONS (elt)->cdr;
+ val = XCDR (elt);
/* If symbol is unbound, put just the symbol in the list. */
if (EQ (val, Qunbound))
- result = Fcons (XCONS (elt)->car, result);
+ result = Fcons (XCAR (elt), result);
/* Otherwise, put (symbol . value) in the list. */
else
- result = Fcons (Fcons (XCONS (elt)->car, val), result);
+ result = Fcons (Fcons (XCAR (elt), val), result);
}
}
/* Add on all the variables stored in special slots. */
{
- register int offset, mask;
+ int offset, idx;
- for (offset = (char *)&buffer_local_symbols.name - (char *)&buffer_local_symbols;
+ for (offset = PER_BUFFER_VAR_OFFSET (name);
offset < sizeof (struct buffer);
- offset += (sizeof (EMACS_INT))) /* sizeof EMACS_INT == sizeof Lisp_Object */
+ /* sizeof EMACS_INT == sizeof Lisp_Object */
+ offset += (sizeof (EMACS_INT)))
{
- mask = XINT (*(Lisp_Object *)(offset + (char *)&buffer_local_flags));
- if (mask == -1 || (buf->local_var_flags & mask))
- if (SYMBOLP (*(Lisp_Object *)(offset
- + (char *)&buffer_local_symbols)))
- result = Fcons (Fcons (*((Lisp_Object *)
- (offset + (char *)&buffer_local_symbols)),
- *(Lisp_Object *)(offset + (char *)buf)),
- result);
+ idx = PER_BUFFER_IDX (offset);
+ if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
+ && SYMBOLP (PER_BUFFER_SYMBOL (offset)))
+ result = Fcons (Fcons (PER_BUFFER_SYMBOL (offset),
+ PER_BUFFER_VALUE (buf, offset)),
+ result);
}
}
{
register int already;
register Lisp_Object fn;
+ Lisp_Object buffer, window;
#ifdef CLASH_DETECTION
/* If buffer becoming modified, lock the file.
If buffer becoming unmodified, unlock the file. */
fn = current_buffer->file_truename;
- if (!NILP (fn))
+ /* Test buffer-file-name so that binding it to nil is effective. */
+ if (!NILP (fn) && ! NILP (current_buffer->filename))
{
already = SAVE_MODIFF < MODIFF;
if (!already && !NILP (flag))
#endif /* CLASH_DETECTION */
SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
- update_mode_lines++;
+
+ /* 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.
+ Setting update_mode_lines makes redisplay consider all windows
+ (on all frames). Stealth fontification of buffers not displayed
+ would incur additional redisplay costs if we'd set
+ update_modes_lines unconditionally.
+
+ Ideally, I think there should be another mechanism for fontifying
+ buffers without "modifying" buffers, or redisplay should be
+ smarter about updating the `*' in mode lines. --gerd */
+ XSETBUFFER (buffer, current_buffer);
+ window = Fget_buffer_window (buffer, Qt);
+ if (WINDOWP (window))
+ update_mode_lines++;
+
+ return flag;
+}
+
+DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p,
+ Srestore_buffer_modified_p, 1, 1, 0,
+ "Like `set-buffer-modified-p', with a differences concerning redisplay.\n\
+It is not ensured that mode lines will be updated to show the modified\n\
+state of the current buffer. Use with care.")
+ (flag)
+ Lisp_Object flag;
+{
+#ifdef CLASH_DETECTION
+ Lisp_Object fn;
+
+ /* If buffer becoming modified, lock the file.
+ If buffer becoming unmodified, unlock the file. */
+
+ fn = current_buffer->file_truename;
+ /* Test buffer-file-name so that binding it to nil is effective. */
+ if (!NILP (fn) && ! NILP (current_buffer->filename))
+ {
+ int already = SAVE_MODIFF < MODIFF;
+ if (!already && !NILP (flag))
+ lock_file (fn);
+ else if (already && NILP (flag))
+ unlock_file (fn);
+ }
+#endif /* CLASH_DETECTION */
+
+ SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
return flag;
}
error ("Empty string is invalid as a buffer name");
tem = Fget_buffer (newname);
- /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
- the buffer automatically so you can create another with the original name.
- It makes UNIQUE equivalent to
- (rename-buffer (generate-new-buffer-name NEWNAME)). */
- if (NILP (unique) && XBUFFER (tem) == current_buffer)
- return current_buffer->name;
if (!NILP (tem))
{
+ /* Don't short-circuit if UNIQUE is t. That is a useful way to
+ rename the buffer automatically so you can create another
+ with the original name. It makes UNIQUE equivalent to
+ (rename-buffer (generate-new-buffer-name NEWNAME)). */
+ if (NILP (unique) && XBUFFER (tem) == current_buffer)
+ return current_buffer->name;
if (!NILP (unique))
newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
else
return current_buffer->name;
}
-DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 2, 0,
+DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0,
"Return most recently selected buffer other than BUFFER.\n\
Buffers not visible in windows are preferred to visible buffers,\n\
unless optional second argument VISIBLE-OK is non-nil.\n\
+If the optional third argument FRAME is non-nil, use that frame's\n\
+buffer list instead of the selected frame's buffer list.\n\
If no other buffer exists, the buffer `*scratch*' is returned.\n\
If BUFFER is omitted or nil, some interesting buffer is returned.")
- (buffer, visible_ok)
- register Lisp_Object buffer, visible_ok;
+ (buffer, visible_ok, frame)
+ register Lisp_Object buffer, visible_ok, frame;
{
Lisp_Object Fset_buffer_major_mode ();
register Lisp_Object tail, buf, notsogood, tem, pred, add_ons;
notsogood = Qnil;
+ if (NILP (frame))
+ frame = selected_frame;
+
tail = Vbuffer_alist;
- pred = frame_buffer_predicate ();
+ pred = frame_buffer_predicate (frame);
/* Consider buffers that have been seen in the selected frame
before other buffers. */
- tem = frame_buffer_list ();
+ tem = frame_buffer_list (frame);
add_ons = Qnil;
while (CONSP (tem))
{
- if (BUFFERP (XCONS (tem)->car))
- add_ons = Fcons (Fcons (Qnil, XCONS (tem)->car), add_ons);
- tem = XCONS (tem)->cdr;
+ if (BUFFERP (XCAR (tem)))
+ add_ons = Fcons (Fcons (Qnil, XCAR (tem)), add_ons);
+ tem = XCDR (tem);
}
tail = nconc2 (Fnreverse (add_ons), tail);
}
if (NILP (visible_ok))
- tem = Fget_buffer_window (buf, Qt);
+ tem = Fget_buffer_window (buf, Qvisible);
else
tem = Qnil;
if (NILP (tem))
}
if (!NILP (notsogood))
return notsogood;
- buf = Fget_buffer_create (build_string ("*scratch*"));
- Fset_buffer_major_mode (buf);
+ buf = Fget_buffer (build_string ("*scratch*"));
+ if (NILP (buf))
+ {
+ buf = Fget_buffer_create (build_string ("*scratch*"));
+ Fset_buffer_major_mode (buf);
+ }
return buf;
}
\f
register struct buffer *b;
register Lisp_Object tem;
register struct Lisp_Marker *m;
- struct gcpro gcpro1, gcpro2;
+ struct gcpro gcpro1;
if (NILP (buffer))
buf = Fcurrent_buffer ();
/* Run hooks with the buffer to be killed the current buffer. */
{
- register Lisp_Object val;
int count = specpdl_ptr - specpdl;
Lisp_Object list;
and give up if so. */
if (b == current_buffer)
{
- tem = Fother_buffer (buf, Qnil);
+ tem = Fother_buffer (buf, Qnil, Qnil);
Fset_buffer (tem);
if (b == current_buffer)
return Qnil;
/* Delete any auto-save file, if we saved it in this session. */
if (STRINGP (b->auto_save_file_name)
&& b->auto_save_modified != 0
- && SAVE_MODIFF < b->auto_save_modified)
+ && BUF_SAVE_MODIFF (b) < b->auto_save_modified)
{
Lisp_Object tem;
tem = Fsymbol_value (intern ("delete-auto-save-files"));
m->chain = Qnil;
}
BUF_MARKERS (b) = Qnil;
-
-#ifdef USE_TEXT_PROPERTIES
BUF_INTERVALS (b) = NULL_INTERVAL;
-#endif
/* Perhaps we should explicitly free the interval tree here... */
}
BLOCK_INPUT;
if (! b->base_buffer)
- BUFFER_FREE (BUF_BEG_ADDR (b));
+ free_buffer_text (b);
if (b->newline_cache)
{
selected buffers are always closer to the front of the list. This
means that other_buffer is more likely to choose a relevant buffer. */
+void
record_buffer (buf)
Lisp_Object buf;
{
register Lisp_Object link, prev;
+ Lisp_Object frame;
+ frame = selected_frame;
prev = Qnil;
- for (link = Vbuffer_alist; CONSP (link); link = XCONS (link)->cdr)
+ for (link = Vbuffer_alist; CONSP (link); link = XCDR (link))
{
- if (EQ (XCONS (XCONS (link)->car)->cdr, buf))
+ if (EQ (XCDR (XCAR (link)), buf))
break;
prev = link;
}
we cannot use Fdelq itself here because it allows quitting. */
if (NILP (prev))
- Vbuffer_alist = XCONS (Vbuffer_alist)->cdr;
+ Vbuffer_alist = XCDR (Vbuffer_alist);
else
- XCONS (prev)->cdr = XCONS (XCONS (prev)->cdr)->cdr;
+ XCDR (prev) = XCDR (XCDR (prev));
- XCONS (link)->cdr = Vbuffer_alist;
+ XCDR (link) = Vbuffer_alist;
Vbuffer_alist = link;
/* Now move this buffer to the front of frame_buffer_list also. */
prev = Qnil;
- for (link = frame_buffer_list (); CONSP (link); link = XCONS (link)->cdr)
+ for (link = frame_buffer_list (frame); CONSP (link);
+ link = XCDR (link))
{
- if (EQ (XCONS (link)->car, buf))
+ if (EQ (XCAR (link), buf))
break;
prev = link;
}
if (CONSP (link))
{
if (NILP (prev))
- set_frame_buffer_list (XCONS (frame_buffer_list ())->cdr);
+ set_frame_buffer_list (frame,
+ XCDR (frame_buffer_list (frame)));
else
- XCONS (prev)->cdr = XCONS (XCONS (prev)->cdr)->cdr;
+ XCDR (prev) = XCDR (XCDR (prev));
- XCONS (link)->cdr = frame_buffer_list ();
- set_frame_buffer_list (link);
+ XCDR (link) = frame_buffer_list (frame);
+ set_frame_buffer_list (frame, link);
}
else
- set_frame_buffer_list (Fcons (buf, frame_buffer_list ()));
+ set_frame_buffer_list (frame, Fcons (buf, frame_buffer_list (frame)));
}
DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, Sset_buffer_major_mode, 1, 1, 0,
return unbind_to (count, Qnil);
}
-DEFUN ("switch-to-buffer", Fswitch_to_buffer, Sswitch_to_buffer, 1, 2, "BSwitch to buffer: ",
- "Select buffer BUFFER in the current window.\n\
-BUFFER may be a buffer or a buffer name.\n\
-Optional second arg NORECORD non-nil means\n\
-do not put this buffer at the front of the list of recently selected ones.\n\
-\n\
-WARNING: This is NOT the way to work on another buffer temporarily\n\
-within a Lisp program! Use `set-buffer' instead. That avoids messing with\n\
-the window-buffer correspondences.")
- (buffer, norecord)
- Lisp_Object buffer, norecord;
+/* If switching buffers in WINDOW would be an error, return
+ a C string saying what the error would be. */
+
+char *
+no_switch_window (window)
+ Lisp_Object window;
{
- register Lisp_Object buf;
Lisp_Object tem;
-
- if (EQ (minibuf_window, selected_window))
- error ("Cannot switch buffers in minibuffer window");
- tem = Fwindow_dedicated_p (selected_window);
+ if (EQ (minibuf_window, window))
+ return "Cannot switch buffers in minibuffer window";
+ tem = Fwindow_dedicated_p (window);
if (!NILP (tem))
- error ("Cannot switch buffers in a dedicated window");
+ return "Cannot switch buffers in a dedicated window";
+ return NULL;
+}
+
+/* Switch to buffer BUFFER in the selected window.
+ If NORECORD is non-nil, don't call record_buffer. */
+
+Lisp_Object
+switch_to_buffer_1 (buffer, norecord)
+ Lisp_Object buffer, norecord;
+{
+ register Lisp_Object buf;
if (NILP (buffer))
- buf = Fother_buffer (Fcurrent_buffer (), Qnil);
+ buf = Fother_buffer (Fcurrent_buffer (), Qnil, Qnil);
else
{
buf = Fget_buffer (buffer);
return buf;
}
+DEFUN ("switch-to-buffer", Fswitch_to_buffer, Sswitch_to_buffer, 1, 2, "BSwitch to buffer: ",
+ "Select buffer BUFFER in the current window.\n\
+BUFFER may be a buffer or a buffer name.\n\
+Optional second arg NORECORD non-nil means\n\
+do not put this buffer at the front of the list of recently selected ones.\n\
+\n\
+WARNING: This is NOT the way to work on another buffer temporarily\n\
+within a Lisp program! Use `set-buffer' instead. That avoids messing with\n\
+the window-buffer correspondences.")
+ (buffer, norecord)
+ Lisp_Object buffer, norecord;
+{
+ char *err;
+
+ err = no_switch_window (selected_window);
+ if (err) error (err);
+
+ return switch_to_buffer_1 (buffer, norecord);
+}
+
DEFUN ("pop-to-buffer", Fpop_to_buffer, Spop_to_buffer, 1, 3, 0,
"Select buffer BUFFER in some window, preferably a different one.\n\
If BUFFER is nil, then some other buffer is chosen.\n\
{
register Lisp_Object buf;
if (NILP (buffer))
- buf = Fother_buffer (Fcurrent_buffer (), Qnil);
+ buf = Fother_buffer (Fcurrent_buffer (), Qnil, Qnil);
else
{
buf = Fget_buffer (buffer);
Fset_buffer (buf);
if (NILP (norecord))
record_buffer (buf);
- Fselect_window (Fdisplay_buffer (buf, other_window));
+ Fselect_window (Fdisplay_buffer (buf, other_window, Qnil));
return buf;
}
return buf;
}
\f
-/* Set the current buffer to B. */
+/* Set the current buffer to B.
+
+ We previously set windows_or_buffers_changed here to invalidate
+ global unchanged information in beg_unchanged and end_unchanged.
+ This is no longer necessary because we now compute unchanged
+ information on a buffer-basis. Every action affecting other
+ windows than the selected one requires a select_window at some
+ time, and that increments windows_or_buffers_changed. */
void
set_buffer_internal (b)
register struct buffer *b;
{
- register struct buffer *old_buf;
- register Lisp_Object tail, valcontents;
- Lisp_Object tem;
-
- if (current_buffer == b)
- return;
-
- windows_or_buffers_changed = 1;
- set_buffer_internal_1 (b);
+ if (current_buffer != b)
+ set_buffer_internal_1 (b);
}
/* Set the current buffer to B, and do not set windows_or_buffers_changed.
register Lisp_Object tail, valcontents;
Lisp_Object tem;
+#ifdef USE_MMAP_FOR_BUFFERS
+ if (b->text->beg == NULL)
+ enlarge_buffer_text (b, 0);
+#endif /* USE_MMAP_FOR_BUFFERS */
+
if (current_buffer == b)
return;
{
Lisp_Object obuf;
XSETBUFFER (obuf, old_buf);
- Fset_marker (old_buf->pt_marker, BUF_PT (old_buf), obuf);
+ set_marker_both (old_buf->pt_marker, obuf,
+ BUF_PT (old_buf), BUF_PT_BYTE (old_buf));
}
if (! NILP (old_buf->begv_marker))
{
Lisp_Object obuf;
XSETBUFFER (obuf, old_buf);
- Fset_marker (old_buf->begv_marker, BUF_BEGV (old_buf), obuf);
+ set_marker_both (old_buf->begv_marker, obuf,
+ BUF_BEGV (old_buf), BUF_BEGV_BYTE (old_buf));
}
if (! NILP (old_buf->zv_marker))
{
Lisp_Object obuf;
XSETBUFFER (obuf, old_buf);
- Fset_marker (old_buf->zv_marker, BUF_ZV (old_buf), obuf);
+ set_marker_both (old_buf->zv_marker, obuf,
+ BUF_ZV (old_buf), BUF_ZV_BYTE (old_buf));
}
}
/* If the new current buffer has markers to record PT, BEGV and ZV
when it is not current, fetch them now. */
if (! NILP (b->pt_marker))
- BUF_PT (b) = marker_position (b->pt_marker);
+ {
+ BUF_PT (b) = marker_position (b->pt_marker);
+ BUF_PT_BYTE (b) = marker_byte_position (b->pt_marker);
+ }
if (! NILP (b->begv_marker))
- BUF_BEGV (b) = marker_position (b->begv_marker);
+ {
+ BUF_BEGV (b) = marker_position (b->begv_marker);
+ BUF_BEGV_BYTE (b) = marker_byte_position (b->begv_marker);
+ }
if (! NILP (b->zv_marker))
- BUF_ZV (b) = marker_position (b->zv_marker);
+ {
+ BUF_ZV (b) = marker_position (b->zv_marker);
+ BUF_ZV_BYTE (b) = marker_byte_position (b->zv_marker);
+ }
/* Look down buffer's list of local Lisp variables
to find and update any that forward into C variables. */
- for (tail = b->local_var_alist; !NILP (tail); tail = XCONS (tail)->cdr)
+ for (tail = b->local_var_alist; !NILP (tail); tail = XCDR (tail))
{
- valcontents = XSYMBOL (XCONS (XCONS (tail)->car)->car)->value;
+ valcontents = XSYMBOL (XCAR (XCAR (tail)))->value;
if ((BUFFER_LOCAL_VALUEP (valcontents)
|| SOME_BUFFER_LOCAL_VALUEP (valcontents))
- && (tem = XBUFFER_LOCAL_VALUE (valcontents)->car,
+ && (tem = XBUFFER_LOCAL_VALUE (valcontents)->realvalue,
(BOOLFWDP (tem) || INTFWDP (tem) || OBJFWDP (tem))))
/* Just reference the variable
to cause it to become set for this buffer. */
- Fsymbol_value (XCONS (XCONS (tail)->car)->car);
+ Fsymbol_value (XCAR (XCAR (tail)));
}
/* Do the same with any others that were local to the previous buffer */
if (old_buf)
- for (tail = old_buf->local_var_alist; !NILP (tail); tail = XCONS (tail)->cdr)
+ for (tail = old_buf->local_var_alist; !NILP (tail); tail = XCDR (tail))
{
- valcontents = XSYMBOL (XCONS (XCONS (tail)->car)->car)->value;
+ valcontents = XSYMBOL (XCAR (XCAR (tail)))->value;
if ((BUFFER_LOCAL_VALUEP (valcontents)
|| SOME_BUFFER_LOCAL_VALUEP (valcontents))
- && (tem = XBUFFER_LOCAL_VALUE (valcontents)->car,
+ && (tem = XBUFFER_LOCAL_VALUE (valcontents)->realvalue,
(BOOLFWDP (tem) || INTFWDP (tem) || OBJFWDP (tem))))
/* Just reference the variable
to cause it to become set for this buffer. */
- Fsymbol_value (XCONS (XCONS (tail)->car)->car);
+ Fsymbol_value (XCAR (XCAR (tail)));
}
}
{
Lisp_Object obuf;
XSETBUFFER (obuf, old_buf);
- Fset_marker (old_buf->pt_marker, BUF_PT (old_buf), obuf);
+ set_marker_both (old_buf->pt_marker, obuf,
+ BUF_PT (old_buf), BUF_PT_BYTE (old_buf));
}
if (! NILP (old_buf->begv_marker))
{
Lisp_Object obuf;
XSETBUFFER (obuf, old_buf);
- Fset_marker (old_buf->begv_marker, BUF_BEGV (old_buf), obuf);
+ set_marker_both (old_buf->begv_marker, obuf,
+ BUF_BEGV (old_buf), BUF_BEGV_BYTE (old_buf));
}
if (! NILP (old_buf->zv_marker))
{
Lisp_Object obuf;
XSETBUFFER (obuf, old_buf);
- Fset_marker (old_buf->zv_marker, BUF_ZV (old_buf), obuf);
+ set_marker_both (old_buf->zv_marker, obuf,
+ BUF_ZV (old_buf), BUF_ZV_BYTE (old_buf));
}
}
/* If the new current buffer has markers to record PT, BEGV and ZV
when it is not current, fetch them now. */
if (! NILP (b->pt_marker))
- BUF_PT (b) = marker_position (b->pt_marker);
+ {
+ BUF_PT (b) = marker_position (b->pt_marker);
+ BUF_PT_BYTE (b) = marker_byte_position (b->pt_marker);
+ }
if (! NILP (b->begv_marker))
- BUF_BEGV (b) = marker_position (b->begv_marker);
+ {
+ BUF_BEGV (b) = marker_position (b->begv_marker);
+ BUF_BEGV_BYTE (b) = marker_byte_position (b->begv_marker);
+ }
if (! NILP (b->zv_marker))
- BUF_ZV (b) = marker_position (b->zv_marker);
+ {
+ BUF_ZV (b) = marker_position (b->zv_marker);
+ BUF_ZV_BYTE (b) = marker_byte_position (b->zv_marker);
+ }
}
DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
set_buffer_internal (XBUFFER (buf));
return buf;
}
+
+/* Set the current buffer to BUFFER provided it is alive. */
+
+Lisp_Object
+set_buffer_if_live (buffer)
+ Lisp_Object buffer;
+{
+ if (! NILP (XBUFFER (buffer)->name))
+ Fset_buffer (buffer);
+ return Qnil;
+}
\f
DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only,
Sbarf_if_buffer_read_only, 0, 0, 0,
XSETBUFFER (buffer, current_buffer);
/* If we're burying the current buffer, unshow it. */
- Fswitch_to_buffer (Fother_buffer (buffer, Qnil), Qnil);
+ Fswitch_to_buffer (Fother_buffer (buffer, Qnil, Qnil), Qnil);
}
else
{
buffer = buf1;
}
- /* Move buffer to the end of the buffer list. */
- {
- register Lisp_Object aelt, link;
+ /* Move buffer to the end of the buffer list. Do nothing if the
+ buffer is killed. */
+ if (!NILP (XBUFFER (buffer)->name))
+ {
+ Lisp_Object aelt, link;
- aelt = Frassq (buffer, Vbuffer_alist);
- link = Fmemq (aelt, Vbuffer_alist);
- Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
- XCONS (link)->cdr = Qnil;
- Vbuffer_alist = nconc2 (Vbuffer_alist, link);
- }
+ aelt = Frassq (buffer, Vbuffer_alist);
+ link = Fmemq (aelt, Vbuffer_alist);
+ Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
+ XCDR (link) = Qnil;
+ Vbuffer_alist = nconc2 (Vbuffer_alist, link);
- frames_bury_buffer (buffer);
+ frames_bury_buffer (buffer);
+ }
return Qnil;
}
()
{
Fwiden ();
+
del_range (BEG, Z);
+
current_buffer->last_window_start = 1;
/* Prevent warnings, or suspension of auto saving, that would happen
if future size is less than past size. Use of erase-buffer
return Qnil;
}
+void
validate_region (b, e)
register Lisp_Object *b, *e;
{
args_out_of_range (*b, *e);
}
\f
+/* Advance BYTE_POS up to a character boundary
+ and return the adjusted position. */
+
+static int
+advance_to_char_boundary (byte_pos)
+ int byte_pos;
+{
+ int c;
+
+ if (byte_pos == BEG)
+ /* Beginning of buffer is always a character boundary. */
+ return 1;
+
+ c = FETCH_BYTE (byte_pos);
+ if (! CHAR_HEAD_P (c))
+ {
+ /* We should advance BYTE_POS only when C is a constituent of a
+ multibyte sequence. */
+ int orig_byte_pos = byte_pos;
+
+ do
+ {
+ byte_pos--;
+ c = FETCH_BYTE (byte_pos);
+ }
+ while (! CHAR_HEAD_P (c) && byte_pos > BEG);
+ INC_POS (byte_pos);
+ if (byte_pos < orig_byte_pos)
+ byte_pos = orig_byte_pos;
+ /* If C is a constituent of a multibyte sequence, BYTE_POS was
+ surely advance to the correct character boundary. If C is
+ not, BYTE_POS was unchanged. */
+ }
+
+ return byte_pos;
+}
+
+DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte, Sset_buffer_multibyte,
+ 1, 1, 0,
+ "Set the multibyte flag of the current buffer to FLAG.\n\
+If FLAG is t, this makes the buffer a multibyte buffer.\n\
+If FLAG is nil, this makes the buffer a single-byte buffer.\n\
+The buffer contents remain unchanged as a sequence of bytes\n\
+but the contents viewed as characters do change.")
+ (flag)
+ Lisp_Object flag;
+{
+ Lisp_Object tail, markers;
+ struct buffer *other;
+ int undo_enabled_p = !EQ (current_buffer->undo_list, Qt);
+ int begv = BEGV, zv = ZV;
+ int narrowed = (BEG != begv || Z != zv);
+ int modified_p = !NILP (Fbuffer_modified_p (Qnil));
+
+ if (current_buffer->base_buffer)
+ error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
+
+ /* Do nothing if nothing actually changes. */
+ if (NILP (flag) == NILP (current_buffer->enable_multibyte_characters))
+ return flag;
+
+ /* It would be better to update the list,
+ but this is good enough for now. */
+ if (undo_enabled_p)
+ current_buffer->undo_list = Qt;
+
+ /* If the cached position is for this buffer, clear it out. */
+ clear_charpos_cache (current_buffer);
+
+ if (narrowed)
+ Fwiden ();
+
+ if (NILP (flag))
+ {
+ int pos, stop;
+ unsigned char *p;
+
+ /* Do this first, so it can use CHAR_TO_BYTE
+ to calculate the old correspondences. */
+ set_intervals_multibyte (0);
+
+ current_buffer->enable_multibyte_characters = Qnil;
+
+ Z = Z_BYTE;
+ BEGV = BEGV_BYTE;
+ ZV = ZV_BYTE;
+ GPT = GPT_BYTE;
+ TEMP_SET_PT_BOTH (PT_BYTE, PT_BYTE);
+
+ tail = BUF_MARKERS (current_buffer);
+ while (! NILP (tail))
+ {
+ XMARKER (tail)->charpos = XMARKER (tail)->bytepos;
+ tail = XMARKER (tail)->chain;
+ }
+
+ /* Convert multibyte form of 8-bit characters to unibyte. */
+ pos = BEG;
+ stop = GPT;
+ p = BEG_ADDR;
+ while (1)
+ {
+ int c, bytes;
+
+ if (pos == stop)
+ {
+ if (pos == Z)
+ break;
+ p = GAP_END_ADDR;
+ stop = Z;
+ }
+ if (MULTIBYTE_STR_AS_UNIBYTE_P (p, bytes))
+ p += bytes, pos += bytes;
+ else
+ {
+ c = STRING_CHAR (p, stop - pos);
+ /* Delete all bytes for this 8-bit character but the
+ last one, and change the last one to the charcter
+ code. */
+ bytes--;
+ del_range_2 (pos, pos, pos + bytes, pos + bytes, 0);
+ p = GAP_END_ADDR;
+ *p++ = c;
+ pos++;
+ if (begv > pos)
+ begv -= bytes;
+ if (zv > pos)
+ zv -= bytes;
+ stop = Z;
+ }
+ }
+ if (narrowed)
+ Fnarrow_to_region (make_number (begv), make_number (zv));
+ }
+ else
+ {
+ int pt = PT;
+ int pos, stop;
+ unsigned char *p;
+
+ /* Be sure not to have a multibyte sequence striding over the GAP.
+ Ex: We change this: "...abc\201 _GAP_ \241def..."
+ to: "...abc _GAP_ \201\241def..." */
+
+ if (GPT_BYTE > 1 && GPT_BYTE < Z_BYTE
+ && ! CHAR_HEAD_P (*(GAP_END_ADDR)))
+ {
+ unsigned char *p = GPT_ADDR - 1;
+
+ while (! CHAR_HEAD_P (*p) && p > BEG_ADDR) p--;
+ if (BASE_LEADING_CODE_P (*p))
+ {
+ int new_gpt = GPT_BYTE - (GPT_ADDR - p);
+
+ move_gap_both (new_gpt, new_gpt);
+ }
+ }
+
+ /* Make the buffer contents valid as multibyte by converting
+ 8-bit characters to multibyte form. */
+ pos = BEG;
+ stop = GPT;
+ p = BEG_ADDR;
+ while (1)
+ {
+ int bytes;
+
+ if (pos == stop)
+ {
+ if (pos == Z)
+ break;
+ p = GAP_END_ADDR;
+ stop = Z;
+ }
+
+ if (UNIBYTE_STR_AS_MULTIBYTE_P (p, stop - pos, bytes))
+ p += bytes, pos += bytes;
+ else
+ {
+ unsigned char tmp[MAX_MULTIBYTE_LENGTH];
+
+ bytes = CHAR_STRING (*p, tmp);
+ *p = tmp[0];
+ TEMP_SET_PT_BOTH (pos + 1, pos + 1);
+ bytes--;
+ insert_1_both (tmp + 1, bytes, bytes, 1, 0, 0);
+ /* Now the gap is after the just inserted data. */
+ pos = GPT;
+ p = GAP_END_ADDR;
+ if (pos <= begv)
+ begv += bytes;
+ if (pos <= zv)
+ zv += bytes;
+ if (pos <= pt)
+ pt += bytes;
+ stop = Z;
+ }
+ }
+
+ if (pt != PT)
+ TEMP_SET_PT (pt);
+
+ if (narrowed)
+ Fnarrow_to_region (make_number (begv), make_number (zv));
+
+ /* Do this first, so that chars_in_text asks the right question.
+ set_intervals_multibyte needs it too. */
+ current_buffer->enable_multibyte_characters = Qt;
+
+ GPT_BYTE = advance_to_char_boundary (GPT_BYTE);
+ GPT = chars_in_text (BEG_ADDR, GPT_BYTE - BEG_BYTE) + BEG;
+
+ Z = chars_in_text (GAP_END_ADDR, Z_BYTE - GPT_BYTE) + GPT;
+
+ BEGV_BYTE = advance_to_char_boundary (BEGV_BYTE);
+ if (BEGV_BYTE > GPT_BYTE)
+ BEGV = chars_in_text (GAP_END_ADDR, BEGV_BYTE - GPT_BYTE) + GPT;
+ else
+ BEGV = chars_in_text (BEG_ADDR, BEGV_BYTE - BEG_BYTE) + BEG;
+
+ ZV_BYTE = advance_to_char_boundary (ZV_BYTE);
+ if (ZV_BYTE > GPT_BYTE)
+ ZV = chars_in_text (GAP_END_ADDR, ZV_BYTE - GPT_BYTE) + GPT;
+ else
+ ZV = chars_in_text (BEG_ADDR, ZV_BYTE - BEG_BYTE) + BEG;
+
+ {
+ int pt_byte = advance_to_char_boundary (PT_BYTE);
+ int pt;
+
+ if (pt_byte > GPT_BYTE)
+ pt = chars_in_text (GAP_END_ADDR, pt_byte - GPT_BYTE) + GPT;
+ else
+ pt = chars_in_text (BEG_ADDR, pt_byte - BEG_BYTE) + BEG;
+ TEMP_SET_PT_BOTH (pt, pt_byte);
+ }
+
+ tail = markers = BUF_MARKERS (current_buffer);
+
+ /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
+ getting confused by the markers that have not yet been updated.
+ It is also a signal that it should never create a marker. */
+ BUF_MARKERS (current_buffer) = Qnil;
+
+ while (! NILP (tail))
+ {
+ XMARKER (tail)->bytepos
+ = advance_to_char_boundary (XMARKER (tail)->bytepos);
+ XMARKER (tail)->charpos = BYTE_TO_CHAR (XMARKER (tail)->bytepos);
+
+ tail = XMARKER (tail)->chain;
+ }
+
+ /* Make sure no markers were put on the chain
+ while the chain value was incorrect. */
+ if (! EQ (BUF_MARKERS (current_buffer), Qnil))
+ abort ();
+
+ BUF_MARKERS (current_buffer) = markers;
+
+ /* Do this last, so it can calculate the new correspondences
+ between chars and bytes. */
+ set_intervals_multibyte (1);
+ }
+
+ if (undo_enabled_p)
+ current_buffer->undo_list = Qnil;
+
+ /* Changing the multibyteness of a buffer means that all windows
+ showing that buffer must be updated thoroughly. */
+ current_buffer->prevent_redisplay_optimizations_p = 1;
+ ++windows_or_buffers_changed;
+
+ /* Copy this buffer's new multibyte status
+ into all of its indirect buffers. */
+ for (other = all_buffers; other; other = other->next)
+ if (other->base_buffer == current_buffer && !NILP (other->name))
+ {
+ other->enable_multibyte_characters
+ = current_buffer->enable_multibyte_characters;
+ other->prevent_redisplay_optimizations_p = 1;
+ }
+
+ /* Restore the modifiedness of the buffer. */
+ if (!modified_p && !NILP (Fbuffer_modified_p (Qnil)))
+ Fset_buffer_modified_p (Qnil);
+
+ return flag;
+}
+\f
DEFUN ("kill-all-local-variables", Fkill_all_local_variables, Skill_all_local_variables,
0, 0, 0,
"Switch to Fundamental mode by killing current buffer's local variables.\n\
/* Any which are supposed to be permanent,
make local again, with the same values they had. */
- for (alist = oalist; !NILP (alist); alist = XCONS (alist)->cdr)
+ for (alist = oalist; !NILP (alist); alist = XCDR (alist))
{
- sym = XCONS (XCONS (alist)->car)->car;
+ sym = XCAR (XCAR (alist));
tem = Fget (sym, Qpermanent_local);
if (! NILP (tem))
{
Fmake_local_variable (sym);
- Fset (sym, XCONS (XCONS (alist)->car)->cdr);
+ Fset (sym, XCDR (XCAR (alist)));
}
}
XSETBUFFER (buffer, b);
oalist = b->local_var_alist;
- for (alist = oalist; !NILP (alist); alist = XCONS (alist)->cdr)
+ for (alist = oalist; !NILP (alist); alist = XCDR (alist))
{
- sym = XCONS (XCONS (alist)->car)->car;
+ sym = XCAR (XCAR (alist));
/* Need not do anything if some other buffer's binding is now encached. */
- tem = XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->cdr)->car;
- if (XBUFFER (tem) == current_buffer)
+ tem = XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->buffer;
+ if (BUFFERP (tem) && XBUFFER (tem) == current_buffer)
{
/* Symbol is set up for this buffer's old local value.
Set it up for the current buffer with the default value. */
- tem = XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->cdr)->cdr;
+ tem = XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->cdr;
/* Store the symbol's current value into the alist entry
it is currently set up for. This is so that, if the
local is marked permanent, and we make it local again
later in Fkill_all_local_variables, we don't lose the value. */
- XCONS (XCONS (tem)->car)->cdr
- = do_symval_forwarding (XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->car);
+ XCDR (XCAR (tem))
+ = do_symval_forwarding (XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->realvalue);
/* Switch to the symbol's default-value alist entry. */
- XCONS (tem)->car = tem;
+ XCAR (tem) = tem;
/* Mark it as current for buffer B. */
- XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->cdr)->car
- = buffer;
+ XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->buffer = buffer;
/* Store the current value into any forwarding in the symbol. */
- store_symval_forwarding (sym, XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->car,
- XCONS (tem)->cdr);
+ store_symval_forwarding (sym,
+ XBUFFER_LOCAL_VALUE (XSYMBOL (sym)->value)->realvalue,
+ XCDR (tem));
}
}
}
Store in *NEXT_PTR the next position after POS where an overlay starts,
or ZV if there are no more overlays.
Store in *PREV_PTR the previous position before POS where an overlay ends,
- or BEGV if there are no previous overlays.
+ or where an overlay starts which ends at or after POS;
+ or BEGV if there are no such overlays.
NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
*VEC_PTR and *LEN_PTR should contain a valid vector and size
If EXTEND is non-zero, we make the vector bigger if necessary.
If EXTEND is zero, we never extend the vector,
and we store only as many overlays as will fit.
- But we still return the total number of overlays. */
+ But we still return the total number of overlays.
+
+ If CHANGE_REQ is true, then any position written into *PREV_PTR or
+ *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
+ default (BEGV or ZV). */
int
-overlays_at (pos, extend, vec_ptr, len_ptr, next_ptr, prev_ptr)
+overlays_at (pos, extend, vec_ptr, len_ptr, next_ptr, prev_ptr, change_req)
int pos;
int extend;
Lisp_Object **vec_ptr;
int *len_ptr;
int *next_ptr;
int *prev_ptr;
+ int change_req;
{
- Lisp_Object tail, overlay, start, end, result;
+ Lisp_Object tail, overlay, start, end;
int idx = 0;
int len = *len_ptr;
Lisp_Object *vec = *vec_ptr;
for (tail = current_buffer->overlays_before;
GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos, endpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
start = OVERLAY_START (overlay);
end = OVERLAY_END (overlay);
prev = endpos;
break;
}
+ startpos = OVERLAY_POSITION (start);
+ /* This one ends at or after POS
+ so its start counts for PREV_PTR if it's before POS. */
+ if (prev < startpos && startpos < pos)
+ prev = startpos;
if (endpos == pos)
continue;
- startpos = OVERLAY_POSITION (start);
if (startpos <= pos)
{
if (idx == len)
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;
}
for (tail = current_buffer->overlays_after;
GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos, endpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
start = OVERLAY_START (overlay);
end = OVERLAY_END (overlay);
if (extend)
{
*len_ptr = len *= 2;
+ if (len == 0)
+ len = *len_ptr = 4;
vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
*vec_ptr = vec;
}
if (!inhibit_storing)
vec[idx] = overlay;
idx++;
+
+ if (startpos < pos && startpos > prev)
+ prev = startpos;
}
else if (endpos < pos && endpos > prev)
prev = endpos;
+ else if (endpos == pos && startpos > prev && !change_req)
+ prev = startpos;
}
if (next_ptr)
int *next_ptr;
int *prev_ptr;
{
- Lisp_Object tail, overlay, ostart, oend, result;
+ Lisp_Object tail, overlay, ostart, oend;
int idx = 0;
int len = *len_ptr;
Lisp_Object *vec = *vec_ptr;
for (tail = current_buffer->overlays_before;
GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos, endpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
ostart = OVERLAY_START (overlay);
oend = OVERLAY_END (overlay);
for (tail = current_buffer->overlays_after;
GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos, endpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
ostart = OVERLAY_START (overlay);
oend = OVERLAY_END (overlay);
Lisp_Object tail, overlay;
for (tail = current_buffer->overlays_before; GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int endpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
if (!GC_OVERLAYP (overlay))
abort ();
}
for (tail = current_buffer->overlays_after; GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
if (!GC_OVERLAYP (overlay))
abort ();
};
static int
-compare_overlays (s1, s2)
- struct sortvec *s1, *s2;
+compare_overlays (v1, v2)
+ const void *v1, *v2;
{
+ const struct sortvec *s1 = (const struct sortvec *) v1;
+ const struct sortvec *s2 = (const struct sortvec *) v2;
if (s1->priority != s2->priority)
return s1->priority - s2->priority;
if (s1->beg != s2->beg)
Lisp_Object str, str2, pri;
int size;
{
+ int nbytes;
+
if (ssl->used == ssl->size)
{
if (ssl->buf)
ssl->buf[ssl->used].size = size;
ssl->buf[ssl->used].priority = (INTEGERP (pri) ? XINT (pri) : 0);
ssl->used++;
- ssl->bytes += XSTRING (str)->size;
- if (STRINGP (str2))
- ssl->bytes += XSTRING (str2)->size;
-}
-/* Return the concatenation of the strings associated with overlays that
- begin or end at POS, ignoring overlays that are specific to a window
- other than W. The strings are concatenated in the appropriate order:
+ if (NILP (current_buffer->enable_multibyte_characters))
+ nbytes = XSTRING (str)->size;
+ else if (! STRING_MULTIBYTE (str))
+ nbytes = count_size_as_multibyte (XSTRING (str)->data,
+ STRING_BYTES (XSTRING (str)));
+ else
+ nbytes = STRING_BYTES (XSTRING (str));
+
+ ssl->bytes += nbytes;
+
+ if (STRINGP (str2))
+ {
+ if (NILP (current_buffer->enable_multibyte_characters))
+ nbytes = XSTRING (str2)->size;
+ else if (! STRING_MULTIBYTE (str2))
+ nbytes = count_size_as_multibyte (XSTRING (str2)->data,
+ STRING_BYTES (XSTRING (str2)));
+ else
+ nbytes = STRING_BYTES (XSTRING (str2));
+
+ ssl->bytes += nbytes;
+ }
+}
+
+/* Return the concatenation of the strings associated with overlays that
+ begin or end at POS, ignoring overlays that are specific to a window
+ other than W. The strings are concatenated in the appropriate order:
shorter overlays nest inside longer ones, and higher priority inside
lower. Normally all of the after-strings come first, but zero-sized
overlays have their after-strings ride along with the before-strings
{
Lisp_Object ov, overlay, window, str;
int startpos, endpos;
+ int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
overlay_heads.used = overlay_heads.bytes = 0;
overlay_tails.used = overlay_tails.bytes = 0;
- for (ov = current_buffer->overlays_before; CONSP (ov); ov = XCONS (ov)->cdr)
+ for (ov = current_buffer->overlays_before; CONSP (ov); ov = XCDR (ov))
{
- overlay = XCONS (ov)->car;
+ overlay = XCAR (ov);
if (!OVERLAYP (overlay))
abort ();
Foverlay_get (overlay, Qpriority),
endpos - startpos);
}
- for (ov = current_buffer->overlays_after; CONSP (ov); ov = XCONS (ov)->cdr)
+ for (ov = current_buffer->overlays_after; CONSP (ov); ov = XCDR (ov))
{
- overlay = XCONS (ov)->car;
+ overlay = XCAR (ov);
if (!OVERLAYP (overlay))
abort ();
p = overlay_str_buf;
for (i = overlay_tails.used; --i >= 0;)
{
+ int nbytes;
tem = overlay_tails.buf[i].string;
- bcopy (XSTRING (tem)->data, p, XSTRING (tem)->size);
- p += XSTRING (tem)->size;
+ nbytes = copy_text (XSTRING (tem)->data, p,
+ STRING_BYTES (XSTRING (tem)),
+ STRING_MULTIBYTE (tem), multibyte);
+ p += nbytes;
}
for (i = 0; i < overlay_heads.used; ++i)
{
+ int nbytes;
tem = overlay_heads.buf[i].string;
- bcopy (XSTRING (tem)->data, p, XSTRING (tem)->size);
- p += XSTRING (tem)->size;
+ nbytes = copy_text (XSTRING (tem)->data, p,
+ STRING_BYTES (XSTRING (tem)),
+ STRING_MULTIBYTE (tem), multibyte);
+ p += nbytes;
tem = overlay_heads.buf[i].string2;
if (STRINGP (tem))
{
- bcopy (XSTRING (tem)->data, p, XSTRING (tem)->size);
- p += XSTRING (tem)->size;
+ nbytes = copy_text (XSTRING (tem)->data, p,
+ STRING_BYTES (XSTRING (tem)),
+ STRING_MULTIBYTE (tem), multibyte);
+ p += nbytes;
}
}
if (p != overlay_str_buf + total)
CONSP (tail);
prev = tail, tail = next)
{
- next = XCONS (tail)->cdr;
- overlay = XCONS (tail)->car;
+ next = XCDR (tail);
+ overlay = XCAR (tail);
/* If the overlay is not valid, get rid of it. */
if (!OVERLAY_VALID (overlay))
{
/* Splice the cons cell TAIL out of overlays_before. */
if (!NILP (prev))
- XCONS (prev)->cdr = next;
+ XCDR (prev) = next;
else
buf->overlays_before = next;
tail = prev;
/* Splice the cons cell TAIL out of overlays_before. */
if (!NILP (prev))
- XCONS (prev)->cdr = next;
+ XCDR (prev) = next;
else
buf->overlays_before = next;
other_prev = Qnil;
for (other = buf->overlays_after;
CONSP (other);
- other_prev = other, other = XCONS (other)->cdr)
+ other_prev = other, other = XCDR (other))
{
- Lisp_Object otherbeg, otheroverlay, follower;
- int win;
+ Lisp_Object otherbeg, otheroverlay;
- otheroverlay = XCONS (other)->car;
+ otheroverlay = XCAR (other);
if (! OVERLAY_VALID (otheroverlay))
abort ();
}
/* Add TAIL to overlays_after before OTHER. */
- XCONS (tail)->cdr = other;
+ XCDR (tail) = other;
if (!NILP (other_prev))
- XCONS (other_prev)->cdr = tail;
+ XCDR (other_prev) = tail;
else
buf->overlays_after = tail;
tail = prev;
CONSP (tail);
prev = tail, tail = next)
{
- next = XCONS (tail)->cdr;
- overlay = XCONS (tail)->car;
+ next = XCDR (tail);
+ overlay = XCAR (tail);
/* If the overlay is not valid, get rid of it. */
if (!OVERLAY_VALID (overlay))
{
/* Splice the cons cell TAIL out of overlays_after. */
if (!NILP (prev))
- XCONS (prev)->cdr = next;
+ XCDR (prev) = next;
else
buf->overlays_after = next;
tail = prev;
/* Splice the cons cell TAIL out of overlays_after. */
if (!NILP (prev))
- XCONS (prev)->cdr = next;
+ XCDR (prev) = next;
else
buf->overlays_after = next;
other_prev = Qnil;
for (other = buf->overlays_before;
CONSP (other);
- other_prev = other, other = XCONS (other)->cdr)
+ other_prev = other, other = XCDR (other))
{
Lisp_Object otherend, otheroverlay;
- int win;
- otheroverlay = XCONS (other)->car;
+ otheroverlay = XCAR (other);
if (! OVERLAY_VALID (otheroverlay))
abort ();
}
/* Add TAIL to overlays_before before OTHER. */
- XCONS (tail)->cdr = other;
+ XCDR (tail) = other;
if (!NILP (other_prev))
- XCONS (other_prev)->cdr = tail;
+ XCDR (other_prev) = tail;
else
buf->overlays_before = tail;
tail = prev;
fix_overlays_in_range (start, end)
register int start, end;
{
- Lisp_Object tem, overlay;
+ Lisp_Object overlay;
Lisp_Object before_list, after_list;
Lisp_Object *ptail, *pbefore = &before_list, *pafter = &after_list;
int startpos, endpos;
it may look strange. */
for (ptail = ¤t_buffer->overlays_before; CONSP (*ptail);)
{
- overlay = XCONS (*ptail)->car;
+ overlay = XCAR (*ptail);
endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
if (endpos < start)
break;
if (startpos > endpos)
{
int tem;
- Fset_marker (OVERLAY_START (overlay), endpos, Qnil);
- Fset_marker (OVERLAY_END (overlay), startpos, Qnil);
+ Fset_marker (OVERLAY_START (overlay), make_number (endpos),
+ Qnil);
+ Fset_marker (OVERLAY_END (overlay), make_number (startpos),
+ Qnil);
tem = startpos; startpos = endpos; endpos = tem;
}
/* Add it to the end of the wrong list. Later on,
if (endpos < XINT (current_buffer->overlay_center))
{
*pafter = *ptail;
- pafter = &XCONS (*ptail)->cdr;
+ pafter = &XCDR (*ptail);
}
else
{
*pbefore = *ptail;
- pbefore = &XCONS (*ptail)->cdr;
+ pbefore = &XCDR (*ptail);
}
- *ptail = XCONS (*ptail)->cdr;
+ *ptail = XCDR (*ptail);
}
else
- ptail = &XCONS (*ptail)->cdr;
+ ptail = &XCDR (*ptail);
}
for (ptail = ¤t_buffer->overlays_after; CONSP (*ptail);)
{
- overlay = XCONS (*ptail)->car;
+ overlay = XCAR (*ptail);
startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
if (startpos >= end)
break;
if (startpos > endpos)
{
int tem;
- Fset_marker (OVERLAY_START (overlay), endpos, Qnil);
- Fset_marker (OVERLAY_END (overlay), startpos, Qnil);
+ Fset_marker (OVERLAY_START (overlay), make_number (endpos),
+ Qnil);
+ Fset_marker (OVERLAY_END (overlay), make_number (startpos),
+ Qnil);
tem = startpos; startpos = endpos; endpos = tem;
}
if (endpos < XINT (current_buffer->overlay_center))
{
*pafter = *ptail;
- pafter = &XCONS (*ptail)->cdr;
+ pafter = &XCDR (*ptail);
}
else
{
*pbefore = *ptail;
- pbefore = &XCONS (*ptail)->cdr;
+ pbefore = &XCDR (*ptail);
}
- *ptail = XCONS (*ptail)->cdr;
+ *ptail = XCDR (*ptail);
}
else
- ptail = &XCONS (*ptail)->cdr;
+ ptail = &XCDR (*ptail);
}
/* Splice the constructed (wrong) lists into the buffer's lists,
`overlays_before' of the buffer *BP. Before the insertion, `point'
was at PREV, and now is at POS. */
+void
fix_overlays_before (bp, prev, pos)
struct buffer *bp;
int prev, pos;
overlay whose ending marker is after-insertion-marker if disorder
exists). */
while (!NILP (*tailp)
- && ((end = OVERLAY_POSITION (OVERLAY_END (XCONS (*tailp)->car)))
+ && ((end = OVERLAY_POSITION (OVERLAY_END (XCAR (*tailp))))
>= pos))
- tailp = &XCONS (*tailp)->cdr;
+ tailp = &XCDR (*tailp);
/* If we don't find such an overlay,
or the found one ends before PREV,
we don't have to fix anything. */
if (NILP (*tailp)
|| end < prev
- || NILP (XCONS (*tailp)->cdr))
+ || NILP (XCDR (*tailp)))
return;
right_place = tailp;
- tailp = &XCONS (*tailp)->cdr;
+ tailp = &XCDR (*tailp);
/* Now, end position of overlays in the list *TAILP should be before
or equal to PREV. In the loop, an overlay which ends at POS is
correct order. */
while (!NILP (*tailp))
{
- end = OVERLAY_POSITION (OVERLAY_END (XCONS (*tailp)->car));
+ end = OVERLAY_POSITION (OVERLAY_END (XCAR (*tailp)));
if (end == pos)
{ /* This overlay is disordered. */
Lisp_Object found = *tailp;
/* Unlink the found overlay. */
- *tailp = XCONS (found)->cdr;
+ *tailp = XCDR (found);
/* Move an overlay at RIGHT_PLACE to the next of the found one. */
- XCONS (found)->cdr = *right_place;
+ XCDR (found) = *right_place;
/* Link it into the right place. */
*right_place = found;
}
else if (end == prev)
- tailp = &XCONS (*tailp)->cdr;
+ tailp = &XCDR (*tailp);
else /* No more disordered overlay. */
break;
}
start = end; end = temp;
}
+ 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))
windows_or_buffers_changed = 1;
- /* If it's not current, we can't use beg_unchanged, end_unchanged for it. */
- else if (buf != current_buffer)
- windows_or_buffers_changed = 1;
/* If multiple windows show this buffer, we must do other windows. */
else if (buffer_shared > 1)
windows_or_buffers_changed = 1;
- else
- {
- if (unchanged_modified == MODIFF
- && overlay_unchanged_modified == OVERLAY_MODIFF)
- {
- beg_unchanged = start - BEG;
- end_unchanged = Z - end;
- }
- else
- {
- if (Z - end < end_unchanged)
- end_unchanged = Z - end;
- if (start - BEG < beg_unchanged)
- beg_unchanged = start - BEG;
- }
- }
- ++OVERLAY_MODIFF;
+ ++BUF_OVERLAY_MODIFF (buf);
}
\f\f
+Lisp_Object Fdelete_overlay ();
+
DEFUN ("move-overlay", Fmove_overlay, Smove_overlay, 3, 4, 0,
"Set the endpoints of OVERLAY to BEG and END in BUFFER.\n\
If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.\n\
obuffer = Fmarker_buffer (OVERLAY_START (overlay));
b = XBUFFER (buffer);
- ob = XBUFFER (obuffer);
+ ob = BUFFERP (obuffer) ? XBUFFER (obuffer) : (struct buffer *) 0;
/* If the overlay has changed buffers, do a thorough redisplay. */
if (!EQ (buffer, obuffer))
/* Redisplay where the overlay was. */
if (!NILP (obuffer))
{
- Lisp_Object o_beg;
- Lisp_Object o_end;
+ int o_beg;
+ int o_end;
o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
- modify_overlay (ob, XINT (o_beg), XINT (o_end));
+ modify_overlay (ob, o_beg, o_end);
}
/* Redisplay where the overlay is going to be. */
else
/* Redisplay the area the overlay has just left, or just enclosed. */
{
- Lisp_Object o_beg;
- Lisp_Object o_end;
- int change_beg, change_end;
+ int o_beg, o_end;
o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
- if (XINT (o_beg) == XINT (beg))
- modify_overlay (b, XINT (o_end), XINT (end));
- else if (XINT (o_end) == XINT (end))
- modify_overlay (b, XINT (o_beg), XINT (beg));
+ if (o_beg == XINT (beg))
+ modify_overlay (b, o_end, XINT (end));
+ else if (o_end == XINT (end))
+ modify_overlay (b, o_beg, XINT (beg));
else
{
- if (XINT (beg) < XINT (o_beg)) o_beg = beg;
- if (XINT (end) > XINT (o_end)) o_end = end;
- modify_overlay (b, XINT (o_beg), XINT (o_end));
+ if (XINT (beg) < o_beg) o_beg = XINT (beg);
+ if (XINT (end) > o_end) o_end = XINT (end);
+ modify_overlay (b, o_beg, o_end);
}
}
b->overlays_after = Fdelq (overlay, b->overlays_after);
modify_overlay (b,
- marker_position (OVERLAY_START (overlay)),
- marker_position (OVERLAY_END (overlay)));
+ marker_position (OVERLAY_START (overlay)),
+ marker_position (OVERLAY_END (overlay)));
Fset_marker (OVERLAY_START (overlay), Qnil, Qnil);
Fset_marker (OVERLAY_END (overlay), Qnil, Qnil);
CHECK_NUMBER_COERCE_MARKER (pos, 0);
len = 10;
+ /* We can't use alloca here because overlays_at can call xrealloc. */
overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len. */
noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
- (int *) 0, (int *) 0);
+ (int *) 0, (int *) 0, 0);
/* Make a list of them all. */
result = Flist (noverlays, overlay_vec);
Store the length in len.
endpos gets the position where the next overlay starts. */
noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
- &endpos, (int *) 0);
+ &endpos, (int *) 0, 1);
/* If any of these overlays ends before endpos,
use its ending point instead. */
int prevpos;
Lisp_Object *overlay_vec;
int len;
- int i;
- Lisp_Object tail;
CHECK_NUMBER_COERCE_MARKER (pos, 0);
- len = 10;
- overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
-
/* At beginning of buffer, we know the answer;
avoid bug subtracting 1 below. */
if (XINT (pos) == BEGV)
return pos;
+ len = 10;
+ overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
+
/* Put all the overlays we want in a vector in overlay_vec.
Store the length in len.
- prevpos gets the position of an overlay end. */
+ prevpos gets the position of the previous change. */
noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
- (int *) 0, &prevpos);
-
- /* If any of these overlays starts after prevpos,
- maybe use its starting point instead. */
- for (i = 0; i < noverlays; i++)
- {
- Lisp_Object ostart;
- int ostartpos;
-
- ostart = OVERLAY_START (overlay_vec[i]);
- ostartpos = OVERLAY_POSITION (ostart);
- if (ostartpos > prevpos && ostartpos < XINT (pos))
- prevpos = ostartpos;
- }
-
- /* If any overlay ends at pos, consider its starting point too. */
- for (tail = current_buffer->overlays_before;
- GC_CONSP (tail);
- tail = XCONS (tail)->cdr)
- {
- Lisp_Object overlay, ostart;
- int ostartpos;
-
- overlay = XCONS (tail)->car;
-
- ostart = OVERLAY_START (overlay);
- ostartpos = OVERLAY_POSITION (ostart);
- if (ostartpos > prevpos && ostartpos < XINT (pos))
- prevpos = ostartpos;
- }
+ (int *) 0, &prevpos, 1);
xfree (overlay_vec);
return make_number (prevpos);
fallback = Qnil;
for (plist = XOVERLAY (overlay)->plist;
- CONSP (plist) && CONSP (XCONS (plist)->cdr);
- plist = XCONS (XCONS (plist)->cdr)->cdr)
+ CONSP (plist) && CONSP (XCDR (plist));
+ plist = XCDR (XCDR (plist)))
{
- if (EQ (XCONS (plist)->car, prop))
- return XCONS (XCONS (plist)->cdr)->car;
- else if (EQ (XCONS (plist)->car, Qcategory))
+ if (EQ (XCAR (plist), prop))
+ return XCAR (XCDR (plist));
+ else if (EQ (XCAR (plist), Qcategory))
{
Lisp_Object tem;
tem = Fcar (Fcdr (plist));
buffer = Fmarker_buffer (OVERLAY_START (overlay));
for (tail = XOVERLAY (overlay)->plist;
- CONSP (tail) && CONSP (XCONS (tail)->cdr);
- tail = XCONS (XCONS (tail)->cdr)->cdr)
- if (EQ (XCONS (tail)->car, prop))
+ CONSP (tail) && CONSP (XCDR (tail));
+ tail = XCDR (XCDR (tail)))
+ if (EQ (XCAR (tail), prop))
{
- changed = !EQ (XCONS (XCONS (tail)->cdr)->car, value);
- XCONS (XCONS (tail)->cdr)->car = value;
+ changed = !EQ (XCAR (XCDR (tail)), value);
+ XCAR (XCDR (tail)) = value;
goto found;
}
/* It wasn't in the list, so add it to the front. */
tail_copied = 0;
for (tail = current_buffer->overlays_before;
CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos, endpos;
Lisp_Object ostart, oend;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
ostart = OVERLAY_START (overlay);
oend = OVERLAY_END (overlay);
tail_copied = 0;
for (tail = current_buffer->overlays_after;
CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos, endpos;
Lisp_Object ostart, oend;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
ostart = OVERLAY_START (overlay);
oend = OVERLAY_END (overlay);
hit_list = Qnil;
if (pos <= XFASTINT (current_buffer->overlay_center))
for (tail = current_buffer->overlays_before; CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int endpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
if (endpos < pos)
break;
}
else
for (tail = current_buffer->overlays_after; CONSP (tail);
- tail = XCONS (tail)->cdr)
+ tail = XCDR (tail))
{
int startpos;
- overlay = XCONS (tail)->car;
+ overlay = XCAR (tail);
startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
if (startpos > pos)
break;
&& ! NILP (Foverlay_get (overlay, Qevaporate)))
hit_list = Fcons (overlay, hit_list);
}
- for (; CONSP (hit_list); hit_list = XCONS (hit_list)->cdr)
- Fdelete_overlay (XCONS (hit_list)->car);
+ for (; CONSP (hit_list); hit_list = XCDR (hit_list))
+ Fdelete_overlay (XCAR (hit_list));
}
\f
/* Somebody has tried to store a value with an unacceptable type
- into the buffer-local slot with offset OFFSET. */
+ in the slot with offset OFFSET. */
+
void
buffer_slot_type_mismatch (offset)
int offset;
{
Lisp_Object sym;
char *type_name;
- sym = *(Lisp_Object *)(offset + (char *)&buffer_local_symbols);
- switch (XINT (*(Lisp_Object *)(offset + (char *)&buffer_local_types)))
+
+ 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;
+ case Lisp_Int:
+ type_name = "integers";
+ break;
+
+ case Lisp_String:
+ type_name = "strings";
+ break;
+
+ case Lisp_Symbol:
+ type_name = "symbols";
+ break;
+
default:
abort ();
}
- error ("only %s should be stored in the buffer-local variable %s",
+ sym = PER_BUFFER_SYMBOL (offset);
+ error ("Only %s should be stored in the buffer-local variable %s",
type_name, XSYMBOL (sym)->name->data);
}
+
\f
+/***********************************************************************
+ Allocation with mmap
+ ***********************************************************************/
+
+#ifdef USE_MMAP_FOR_BUFFERS
+
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#ifndef MAP_ANON
+#ifdef MAP_ANONYMOUS
+#define MAP_ANON MAP_ANONYMOUS
+#else
+#define MAP_ANON 0
+#endif
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+
+#if MAP_ANON == 0
+#include <fcntl.h>
+#endif
+
+#include "coding.h"
+
+
+/* Memory is allocated in regions which are mapped using mmap(2).
+ The current implementation lets the system select mapped
+ addresses; we're not using MAP_FIXED in general, except when
+ trying to enlarge regions.
+
+ Each mapped region starts with a mmap_region structure, the user
+ area starts after that structure, aligned to MEM_ALIGN.
+
+ +-----------------------+
+ | struct mmap_info + |
+ | padding |
+ +-----------------------+
+ | user data |
+ | |
+ | |
+ +-----------------------+ */
+
+struct mmap_region
+{
+ /* User-specified size. */
+ size_t nbytes_specified;
+
+ /* Number of bytes mapped */
+ size_t nbytes_mapped;
+
+ /* Pointer to the location holding the address of the memory
+ allocated with the mmap'd block. The variable actually points
+ after this structure. */
+ POINTER_TYPE **var;
+
+ /* Next and previous in list of all mmap'd regions. */
+ struct mmap_region *next, *prev;
+};
+
+/* Doubly-linked list of mmap'd regions. */
+
+static struct mmap_region *mmap_regions;
+
+/* File descriptor for mmap. If we don't have anonymous mapping,
+ /dev/zero will be opened on it. */
+
+static int mmap_fd;
+
+/* Temporary storage for mmap_set_vars, see there. */
+
+static struct mmap_region *mmap_regions_1;
+static int mmap_fd_1;
+
+/* Page size on this system. */
+
+static int mmap_page_size;
+
+/* 1 means mmap has been intialized. */
+
+static int mmap_initialized_p;
+
+/* Value is X rounded up to the next multiple of N. */
+
+#define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
+
+/* Size of mmap_region structure plus padding. */
+
+#define MMAP_REGION_STRUCT_SIZE \
+ ROUND (sizeof (struct mmap_region), MEM_ALIGN)
+
+/* Given a pointer P to the start of the user-visible part of a mapped
+ region, return a pointer to the start of the region. */
+
+#define MMAP_REGION(P) \
+ ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
+
+/* Given a pointer P to the start of a mapped region, return a pointer
+ to the start of the user-visible part of the region. */
+
+#define MMAP_USER_AREA(P) \
+ ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
+
+#define MEM_ALIGN sizeof (double)
+
+/* Function prototypes. */
+
+static int mmap_free_1 P_ ((struct mmap_region *));
+static int mmap_enlarge P_ ((struct mmap_region *, int));
+static struct mmap_region *mmap_find P_ ((POINTER_TYPE *, POINTER_TYPE *));
+static POINTER_TYPE *mmap_alloc P_ ((POINTER_TYPE **, size_t));
+static POINTER_TYPE *mmap_realloc P_ ((POINTER_TYPE **, size_t));
+static void mmap_free P_ ((POINTER_TYPE **ptr));
+static void mmap_init P_ ((void));
+
+
+/* Return a region overlapping address range START...END, or null if
+ none. END is not including, i.e. the last byte in the range
+ is at END - 1. */
+
+static struct mmap_region *
+mmap_find (start, end)
+ POINTER_TYPE *start, *end;
+{
+ struct mmap_region *r;
+ char *s = (char *) start, *e = (char *) end;
+
+ for (r = mmap_regions; r; r = r->next)
+ {
+ char *rstart = (char *) r;
+ char *rend = rstart + r->nbytes_mapped;
+
+ if (/* First byte of range, i.e. START, in this region? */
+ (s >= rstart && s < rend)
+ /* Last byte of range, i.e. END - 1, in this region? */
+ || (e > rstart && e <= rend)
+ /* First byte of this region in the range? */
+ || (rstart >= s && rstart < e)
+ /* Last byte of this region in the range? */
+ || (rend > s && rend <= e))
+ break;
+ }
+
+ return r;
+}
+
+
+/* Unmap a region. P is a pointer to the start of the user-araa of
+ the region. Value is non-zero if successful. */
+
+static int
+mmap_free_1 (r)
+ struct mmap_region *r;
+{
+ if (r->next)
+ r->next->prev = r->prev;
+ if (r->prev)
+ r->prev->next = r->next;
+ else
+ mmap_regions = r->next;
+
+ if (munmap (r, r->nbytes_mapped) == -1)
+ {
+ fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
+ return 0;
+ }
+
+ return 1;
+}
+
+
+/* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
+ Value is non-zero if successful. */
+
+static int
+mmap_enlarge (r, npages)
+ struct mmap_region *r;
+ int npages;
+{
+ char *region_end = (char *) r + r->nbytes_mapped;
+ size_t nbytes;
+ int success = 0;
+
+ if (npages < 0)
+ {
+ /* Unmap pages at the end of the region. */
+ nbytes = - npages * mmap_page_size;
+ if (munmap (region_end - nbytes, nbytes) == -1)
+ fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
+ else
+ {
+ r->nbytes_mapped -= nbytes;
+ success = 1;
+ }
+ }
+ 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)
+ {
+ 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)
+ fprintf (stderr, "mmap: %s\n", emacs_strerror (errno));
+ else if (p != (POINTER_TYPE *) region_end)
+ {
+ /* Kernels are free to choose a different address. In
+ that case, unmap what we've mapped above; we have
+ no use for it. */
+ if (munmap (p, nbytes) == -1)
+ fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
+ }
+ else
+ {
+ r->nbytes_mapped += nbytes;
+ success = 1;
+ }
+ }
+ }
+
+ return success;
+}
+
+
+/* Set or reset variables holding references to mapped regions. If
+ RESTORE_P is zero, set all variables to null. If RESTORE_P is
+ non-zero, set all variables to the start of the user-areas
+ of mapped regions.
+
+ This function is called from Fdump_emacs to ensure that the dumped
+ Emacs doesn't contain references to memory that won't be mapped
+ when Emacs starts. */
+
+void
+mmap_set_vars (restore_p)
+ int restore_p;
+{
+ struct mmap_region *r;
+
+ if (restore_p)
+ {
+ mmap_regions = mmap_regions_1;
+ mmap_fd = mmap_fd_1;
+ for (r = mmap_regions; r; r = r->next)
+ *r->var = MMAP_USER_AREA (r);
+ }
+ else
+ {
+ for (r = mmap_regions; r; r = r->next)
+ *r->var = NULL;
+ mmap_regions_1 = mmap_regions;
+ mmap_regions = NULL;
+ mmap_fd_1 = mmap_fd;
+ mmap_fd = -1;
+ }
+}
+
+
+/* Allocate a block of storage large enough to hold NBYTES bytes of
+ data. A pointer to the data is returned in *VAR. VAR is thus the
+ address of some variable which will use the data area.
+
+ The allocation of 0 bytes is valid.
+
+ If we can't allocate the necessary memory, set *VAR to null, and
+ return null. */
+
+static POINTER_TYPE *
+mmap_alloc (var, nbytes)
+ POINTER_TYPE **var;
+ size_t nbytes;
+{
+ void *p;
+ size_t map;
+
+ mmap_init ();
+
+ 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)
+ fprintf (stderr, "mmap: %s\n", emacs_strerror (errno));
+ p = NULL;
+ }
+ else
+ {
+ struct mmap_region *r = (struct mmap_region *) p;
+
+ r->nbytes_specified = nbytes;
+ r->nbytes_mapped = map;
+ r->var = var;
+ r->prev = NULL;
+ r->next = mmap_regions;
+ if (r->next)
+ r->next->prev = r;
+ mmap_regions = r;
+
+ p = MMAP_USER_AREA (p);
+ }
+
+ return *var = p;
+}
+
+
+/* Given a pointer at address VAR to data allocated with mmap_alloc,
+ resize it to size NBYTES. Change *VAR to reflect the new block,
+ and return this value. If more memory cannot be allocated, then
+ leave *VAR unchanged, and return null. */
+
+static POINTER_TYPE *
+mmap_realloc (var, nbytes)
+ POINTER_TYPE **var;
+ size_t nbytes;
+{
+ POINTER_TYPE *result;
+
+ mmap_init ();
+
+ if (*var == NULL)
+ result = mmap_alloc (var, nbytes);
+ else if (nbytes == 0)
+ {
+ mmap_free (var);
+ result = mmap_alloc (var, nbytes);
+ }
+ else
+ {
+ struct mmap_region *r = MMAP_REGION (*var);
+ size_t room = r->nbytes_mapped - MMAP_REGION_STRUCT_SIZE;
+
+ if (room < nbytes)
+ {
+ /* Must enlarge. */
+ POINTER_TYPE *old_ptr = *var;
+
+ /* Try to map additional pages at the end of the region.
+ If that fails, allocate a new region, copy data
+ from the old region, then free it. */
+ if (mmap_enlarge (r, (ROUND (nbytes - room, mmap_page_size)
+ / mmap_page_size)))
+ {
+ r->nbytes_specified = nbytes;
+ *var = result = old_ptr;
+ }
+ else if (mmap_alloc (var, nbytes))
+ {
+ bcopy (old_ptr, *var, r->nbytes_specified);
+ mmap_free_1 (MMAP_REGION (old_ptr));
+ result = *var;
+ r = MMAP_REGION (result);
+ r->nbytes_specified = nbytes;
+ }
+ else
+ {
+ *var = old_ptr;
+ result = NULL;
+ }
+ }
+ 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);
+ result = *var;
+ r->nbytes_specified = nbytes;
+ }
+ else
+ {
+ /* Leave it alone. */
+ result = *var;
+ r->nbytes_specified = nbytes;
+ }
+ }
+
+ return result;
+}
+
+
+/* Free a block of relocatable storage whose data is pointed to by
+ PTR. Store 0 in *PTR to show there's no block allocated. */
+
+static void
+mmap_free (var)
+ POINTER_TYPE **var;
+{
+ mmap_init ();
+
+ if (*var)
+ {
+ mmap_free_1 (MMAP_REGION (*var));
+ *var = NULL;
+ }
+}
+
+
+/* Perform necessary intializations for the use of mmap. */
+
+static void
+mmap_init ()
+{
+#if MAP_ANON == 0
+ /* The value of mmap_fd is initially 0 in temacs, and -1
+ in a dumped Emacs. */
+ if (mmap_fd <= 0)
+ {
+ /* No anonymous mmap -- we need the file descriptor. */
+ mmap_fd = open ("/dev/zero", O_RDONLY);
+ if (mmap_fd == -1)
+ fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno));
+ }
+#endif /* MAP_ANON == 0 */
+
+ if (mmap_initialized_p)
+ return;
+ mmap_initialized_p = 1;
+
+#if MAP_ANON != 0
+ mmap_fd = -1;
+#endif
+
+ mmap_page_size = getpagesize ();
+}
+
+#endif /* USE_MMAP_FOR_BUFFERS */
+
+
+\f
+/***********************************************************************
+ Buffer-text Allocation
+ ***********************************************************************/
+
+#ifdef REL_ALLOC
+extern POINTER_TYPE *r_alloc P_ ((POINTER_TYPE **, size_t));
+extern POINTER_TYPE *r_re_alloc P_ ((POINTER_TYPE **, size_t));
+extern void r_alloc_free P_ ((POINTER_TYPE **ptr));
+#endif /* REL_ALLOC */
+
+
+/* Allocate NBYTES bytes for buffer B's text buffer. */
+
+static void
+alloc_buffer_text (b, nbytes)
+ struct buffer *b;
+ size_t nbytes;
+{
+ POINTER_TYPE *p;
+
+ BLOCK_INPUT;
+#if defined USE_MMAP_FOR_BUFFERS
+ p = mmap_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+#elif defined REL_ALLOC
+ p = r_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+#else
+ p = xmalloc (b->text->beg, nbytes);
+#endif
+
+ if (p == NULL)
+ {
+ UNBLOCK_INPUT;
+ memory_full ();
+ }
+
+ b->text->beg = (unsigned char *) p;
+ UNBLOCK_INPUT;
+}
+
+/* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
+ shrink it. */
+
+void
+enlarge_buffer_text (b, delta)
+ struct buffer *b;
+ int delta;
+{
+ POINTER_TYPE *p;
+ size_t nbytes = (BUF_Z_BYTE (b) - BUF_BEG_BYTE (b) + BUF_GAP_SIZE (b) + 1
+ + delta);
+ BLOCK_INPUT;
+#if defined USE_MMAP_FOR_BUFFERS
+ p = mmap_realloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+#elif defined REL_ALLOC
+ p = r_re_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+#else
+ p = xrealloc (b->text->beg, nbytes);
+#endif
+
+ if (p == NULL)
+ {
+ UNBLOCK_INPUT;
+ memory_full ();
+ }
+
+ BUF_BEG_ADDR (b) = (unsigned char *) p;
+ UNBLOCK_INPUT;
+}
+
+
+/* Free buffer B's text buffer. */
+
+static void
+free_buffer_text (b)
+ struct buffer *b;
+{
+ BLOCK_INPUT;
+
+#if defined USE_MMAP_FOR_BUFFERS
+ mmap_free ((POINTER_TYPE **) &b->text->beg);
+#elif defined REL_ALLOC
+ r_alloc_free ((POINTER_TYPE **) &b->text->beg);
+#else
+ xfree (b->text->beg);
+#endif
+
+ BUF_BEG_ADDR (b) = NULL;
+ UNBLOCK_INPUT;
+}
+
+
+\f
+/***********************************************************************
+ Initialization
+ ***********************************************************************/
+
+void
init_buffer_once ()
{
- register Lisp_Object tem;
+ int idx;
- buffer_permanent_local_flags = 0;
+ bzero (buffer_permanent_local_flags, sizeof buffer_permanent_local_flags);
/* Make sure all markable slots in buffer_defaults
are initialized reasonably, so mark_buffer won't choke. */
/* Prevent GC from getting confused. */
buffer_defaults.text = &buffer_defaults.own_text;
buffer_local_symbols.text = &buffer_local_symbols.own_text;
-#ifdef USE_TEXT_PROPERTIES
BUF_INTERVALS (&buffer_defaults) = 0;
BUF_INTERVALS (&buffer_local_symbols) = 0;
-#endif
XSETBUFFER (Vbuffer_defaults, &buffer_defaults);
XSETBUFFER (Vbuffer_local_symbols, &buffer_local_symbols);
/* Set up the default values of various buffer slots. */
/* Must do these before making the first buffer! */
- /* real setup is done in loaddefs.el */
+ /* real setup is done in bindings.el */
buffer_defaults.mode_line_format = build_string ("%-");
+ buffer_defaults.header_line_format = Qnil;
buffer_defaults.abbrev_mode = Qnil;
buffer_defaults.overwrite_mode = Qnil;
buffer_defaults.case_fold_search = Qt;
buffer_defaults.truncate_lines = Qnil;
buffer_defaults.ctl_arrow = Qt;
buffer_defaults.direction_reversed = Qnil;
+ buffer_defaults.cursor_type = Qt;
+ buffer_defaults.extra_line_spacing = Qnil;
#ifdef DOS_NT
buffer_defaults.buffer_file_type = Qnil; /* TEXT */
buffer_defaults.cache_long_line_scans = Qnil;
buffer_defaults.file_truename = Qnil;
XSETFASTINT (buffer_defaults.display_count, 0);
+ buffer_defaults.indicate_empty_lines = Qnil;
+ buffer_defaults.scroll_up_aggressively = Qnil;
+ buffer_defaults.scroll_down_aggressively = Qnil;
+ buffer_defaults.display_time = Qnil;
/* Assign the local-flags to the slots that have default values.
The local flag is a bit that is used in the buffer
XSETINT (buffer_local_flags.invisibility_spec, -1);
XSETINT (buffer_local_flags.file_format, -1);
XSETINT (buffer_local_flags.display_count, -1);
-
- XSETFASTINT (buffer_local_flags.mode_line_format, 1);
- XSETFASTINT (buffer_local_flags.abbrev_mode, 2);
- XSETFASTINT (buffer_local_flags.overwrite_mode, 4);
- XSETFASTINT (buffer_local_flags.case_fold_search, 8);
- XSETFASTINT (buffer_local_flags.auto_fill_function, 0x10);
- XSETFASTINT (buffer_local_flags.selective_display, 0x20);
+ XSETINT (buffer_local_flags.display_time, -1);
+ XSETINT (buffer_local_flags.enable_multibyte_characters, -1);
+
+ idx = 1;
+ XSETFASTINT (buffer_local_flags.mode_line_format, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.abbrev_mode, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.overwrite_mode, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.case_fold_search, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.auto_fill_function, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.selective_display, idx); ++idx;
#ifndef old
- XSETFASTINT (buffer_local_flags.selective_display_ellipses, 0x40);
+ XSETFASTINT (buffer_local_flags.selective_display_ellipses, idx); ++idx;
#endif
- XSETFASTINT (buffer_local_flags.tab_width, 0x80);
- XSETFASTINT (buffer_local_flags.truncate_lines, 0x100);
- XSETFASTINT (buffer_local_flags.ctl_arrow, 0x200);
- XSETFASTINT (buffer_local_flags.fill_column, 0x400);
- XSETFASTINT (buffer_local_flags.left_margin, 0x800);
- XSETFASTINT (buffer_local_flags.abbrev_table, 0x1000);
- XSETFASTINT (buffer_local_flags.display_table, 0x2000);
+ XSETFASTINT (buffer_local_flags.tab_width, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.truncate_lines, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.ctl_arrow, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.fill_column, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.left_margin, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.abbrev_table, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.display_table, idx); ++idx;
#ifdef DOS_NT
- XSETFASTINT (buffer_local_flags.buffer_file_type, 0x4000);
+ XSETFASTINT (buffer_local_flags.buffer_file_type, idx);
/* Make this one a permanent local. */
- buffer_permanent_local_flags |= 0x4000;
+ buffer_permanent_local_flags[idx++] = 1;
#endif
- XSETFASTINT (buffer_local_flags.syntax_table, 0x8000);
- XSETFASTINT (buffer_local_flags.cache_long_line_scans, 0x10000);
- XSETFASTINT (buffer_local_flags.category_table, 0x20000);
- XSETFASTINT (buffer_local_flags.direction_reversed, 0x40000);
- XSETFASTINT (buffer_local_flags.enable_multibyte_characters, 0x80000);
- /* Make this one a permanent local. */
- buffer_permanent_local_flags |= 0x80000;
- XSETFASTINT (buffer_local_flags.buffer_file_coding_system, 0x100000);
+ XSETFASTINT (buffer_local_flags.syntax_table, idx); ++idx;
+ 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);
/* Make this one a permanent local. */
- buffer_permanent_local_flags |= 0x100000;
+ buffer_permanent_local_flags[idx++] = 1;
+ XSETFASTINT (buffer_local_flags.left_margin_width, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.right_margin_width, idx); ++idx;
+ XSETFASTINT (buffer_local_flags.indicate_empty_lines, 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;
+
+ /* Need more room? */
+ if (idx >= MAX_PER_BUFFER_VARS)
+ abort ();
+ last_per_buffer_idx = idx;
Vbuffer_alist = Qnil;
current_buffer = 0;
Vbuffer_alist = Qnil;
Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
+
+ inhibit_modification_hooks = 0;
}
+void
init_buffer ()
{
- char buf[MAXPATHLEN+1];
+ char buf[MAXPATHLEN + 1];
char *pwd;
struct stat dotstat, pwdstat;
Lisp_Object temp;
int rc;
+#ifdef USE_MMAP_FOR_BUFFERS
+ {
+ /* When using the ralloc implementation based on mmap(2), 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 = getenv ("PWD")) != 0 && IS_DIRECTORY_SEP (*pwd)
+ 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
#ifndef VMS
/* Maybe this should really use some standard subroutine
/* Add /: to the front of the name
if it would otherwise be treated as magic. */
temp = Ffind_file_name_handler (current_buffer->directory, Qt);
- if (! NILP (temp))
+ if (! NILP (temp)
+ /* If the default dir is just /, TEMP is non-nil
+ 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))
current_buffer->directory
= concat2 (build_string ("/:"), current_buffer->directory);
}
/* initialize the buffer routines */
+void
syms_of_buffer ()
{
- extern Lisp_Object Qdisabled;
-
staticpro (&last_overlay_modification_hooks);
last_overlay_modification_hooks
= Fmake_vector (make_number (10), Qnil);
"Default value of `mode-line-format' for buffers that don't override it.\n\
This is the same as (default-value 'mode-line-format).");
+ DEFVAR_LISP_NOPRO ("default-header-line-format",
+ &buffer_defaults.header_line_format,
+ "Default value of `header-line-format' for buffers that don't override it.\n\
+This is the same as (default-value 'header-line-format).");
+
+ DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults.cursor_type,
+ "Default value of `cursor-type' for buffers that don't override it.\n\
+This is the same as (default-value 'cursor-type).");
+
+ DEFVAR_LISP_NOPRO ("default-line-spacing",
+ &buffer_defaults.extra_line_spacing,
+ "Default value of `line-spacing' for buffers that don't override it.\n\
+This is the same as (default-value 'line-spacing).");
+
DEFVAR_LISP_NOPRO ("default-abbrev-mode",
&buffer_defaults.abbrev_mode,
"Default value of `abbrev-mode' for buffers that do not override it.\n\
DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
&buffer_defaults.enable_multibyte_characters,
- "Default value of `enable-multibyte-characters' for buffers not overriding it.\n\
- This is the same as (default-value 'enable-multibyte-characters).");
+ "*Default value of `enable-multibyte-characters' for buffers not overriding it.\n\
+This is the same as (default-value 'enable-multibyte-characters).");
DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
&buffer_defaults.buffer_file_coding_system,
"Default value of `buffer-file-coding-system' for buffers not overriding it.\n\
- This is the same as (default-value 'buffer-file-coding-system).");
+This is the same as (default-value 'buffer-file-coding-system).");
DEFVAR_LISP_NOPRO ("default-truncate-lines",
&buffer_defaults.truncate_lines,
The file type is nil for text, t for binary.");
#endif
+ DEFVAR_LISP_NOPRO ("default-left-margin-width",
+ &buffer_defaults.left_margin_width,
+ "Default value of `left-margin-width' for buffers that don't override it.\n\
+This is the same as (default-value 'left-margin-width).");
+
+ DEFVAR_LISP_NOPRO ("default-right-margin-width",
+ &buffer_defaults.right_margin_width,
+ "Default value of `right_margin_width' for buffers that don't override it.\n\
+This is the same as (default-value 'right-margin-width).");
+
+ DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
+ &buffer_defaults.indicate_empty_lines,
+ "Default value of `indicate-empty-lines' for buffers that don't override it.\n\
+This is the same as (default-value 'indicate-empty-lines).");
+
+ DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
+ &buffer_defaults.scroll_up_aggressively,
+ "Default value of `scroll-up-aggressively' for buffers that\n\
+don't override it. This is the same as (default-value\n\
+'scroll-up-aggressively).");
+
+ DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
+ &buffer_defaults.scroll_down_aggressively,
+ "Default value of `scroll-down-aggressively' for buffers that\n\
+don't override it. This is the same as (default-value\n\
+'scroll-down-aggressively).");
+
+ DEFVAR_PER_BUFFER ("header-line-format",
+ ¤t_buffer->header_line_format,
+ Qnil,
+ "Analogous to `mode-line-format', but for a mode line displayed\n\
+at the top of windows.");
+
DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
Qnil, 0);
Qnil,
"Template for displaying mode line for current buffer.\n\
Each buffer has its own value of this variable.\n\
-Value may be a string, a symbol or a list or cons cell.\n\
+Value may be nil, a string, a symbol or a list or cons cell.\n\
+A value of nil means don't display a mode line.\n\
For a symbol, its value is used (but it is ignored if t or nil).\n\
A string appearing directly as the value of a symbol is processed verbatim\n\
in that the %-constructs below are not recognized.\n\
+For a list of the form `(:eval FORM)', FORM is evaluated and the result\n\
+ is used as a mode line element.\n\
For a list whose car is a symbol, the symbol's value is taken,\n\
and if that is non-nil, the cadr of the list is processed recursively.\n\
Otherwise, the caddr of the list (if there is one) is processed.\n\
(%-constructs are allowed when the string is the entire mode-line-format\n\
or when it is found in a cons-cell or a list)\n\
%b -- print buffer name. %f -- print visited file name.\n\
+ %F -- print frame name.\n\
%* -- print %, * or hyphen. %+ -- print *, % or hyphen.\n\
+ %& is like %*, but ignore read-only-ness.\n\
% means buffer is read-only and * means it is modified.\n\
For a modified read-only buffer, %* gives % and %+ gives *.\n\
%s -- print process status. %l -- print the current line number.\n\
%c -- print the current column number (this makes editing slower).\n\
+ To make the column number update correctly in all cases,\n\
+ `column-number-mode' must be non-nil.\n\
%p -- print percent of buffer above top of window, or Top, Bot or All.\n\
%P -- print percent of buffer above bottom of window, perhaps plus Top,\n\
or print Bottom or All.\n\
+ %m -- print the mode name.\n\
%n -- print Narrow if appropriate.\n\
- %t -- print T if file is text, B if binary.\n\
+ %z -- print mnemonics of buffer, terminal, and keyboard coding systems.\n\
+ %Z -- like %z, but including the end-of-line format.\n\
%[ -- print one [ for each recursive editing level. %] similar.\n\
%% -- print %. %- -- print infinitely many dashes.\n\
Decimal digits after the % specify field width to which to pad.");
DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer->case_fold_search,
Qnil,
- "*Non-nil if searches should ignore case.\n\
+ "*Non-nil if searches and matches should ignore case.\n\
Automatically becomes buffer-local when set in any fashion.");
DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer->fill_column,
in the current display table (if there is one).");
DEFVAR_PER_BUFFER ("enable-multibyte-characters",
- ¤t_buffer->enable_multibyte_characters, Qnil,
- "*Non-nil means the buffer contents are regarded as multi-byte form\n\
-of characters, not a binary code. This affects the display, file I/O,\n\
-and behaviors of various editing commands.");
+ ¤t_buffer->enable_multibyte_characters,
+ make_number (-1),
+ "Non-nil means the buffer contents are regarded as multi-byte characters.\n\
+Otherwise they are regarded as unibyte. This affects the display,\n\
+file I/O and the behavior of various editing commands.\n\
+\n\
+This variable is buffer-local but you cannot set it directly;\n\
+use the function `set-buffer-multibyte' to change a buffer's representation.\n\
+Changing its default value with `setq-default' is supported.\n\
+See also variable `default-enable-multibyte-characters' and Info node\n\
+`(elisp)Text Representations'.");
DEFVAR_PER_BUFFER ("buffer-file-coding-system",
¤t_buffer->buffer_file_coding_system, Qnil,
"Coding system to be used for encoding the buffer contents on saving.\n\
-If it is nil, the buffer is saved without any code conversion unless\n\
-some coding system is specified in file-coding-system-alist\n\
+This variable applies to saving the buffer, and also to `write-region'\n\
+and other functions that use `write-region'.\n\
+It does not apply to sending output to subprocesses, however.\n\
+\n\
+If this is nil, the buffer is saved without any code conversion\n\
+unless some coding system is specified in `file-coding-system-alist'\n\
for the buffer file.\n\
\n\
+The variable `coding-system-for-write', if non-nil, overrides this variable.\n\
+\n\
This variable is never applied to a way of decoding\n\
a file while reading it.");
DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer->auto_fill_function,
Qnil,
"Function called (if non-nil) to perform auto-fill.\n\
-It is called after self-inserting a space or newline.\n\
+It is called after self-inserting any character specified in\n\
+the `auto-fill-chars' table.\n\
Each buffer has its own value of this variable.\n\
NOTE: This variable is not a hook;\n\
its value may not be a list of functions.");
DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer->display_table,
Qnil, 0);
+ DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer->left_margin_width,
+ Qnil,
+ "*Width of left marginal area for display of a buffer.\n\
+Automatically becomes buffer-local when set in any fashion.\n\
+A value of nil means no marginal area.");
+
+ DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer->right_margin_width,
+ Qnil,
+ "*Width of right marginal area for display of a buffer.\n\
+Automatically becomes buffer-local when set in any fashion.\n\
+A value of nil means no marginal area.");
+
+ DEFVAR_PER_BUFFER ("indicate-empty-lines",
+ ¤t_buffer->indicate_empty_lines, Qnil,
+ "*Visually indicate empty lines after the buffer end.\n\
+If non-nil, a bitmap is displayed in the left fringe of a window on\n\
+window-systems.\n\
+Automatically becomes buffer-local when set in any fashion.\n");
+
+ DEFVAR_PER_BUFFER ("scroll-up-aggressively",
+ ¤t_buffer->scroll_up_aggressively, Qnil,
+ "*If a number, scroll display up aggressively.\n\
+If scrolling a window because point is above the window start, choose\n\
+a new window start so that point ends up that fraction of the window's\n\
+height from the top of the window.\n\
+Automatically becomes buffer-local when set in any fashion.");
+
+ DEFVAR_PER_BUFFER ("scroll-down-aggressively",
+ ¤t_buffer->scroll_down_aggressively, Qnil,
+ "*If a number, scroll display down aggressively.\n\
+If scrolling a window because point is below the window end, choose\n\
+a new window start so that point ends up that fraction of the window's\n\
+height from the bottom of the window.\n\
+Automatically becomes buffer-local when set in any fashion.");
+
/*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
"Don't ask.");
*/
- DEFVAR_LISP ("before-change-function", &Vbefore_change_function,
- "If non-nil, a function to call before each text change (obsolete).\n\
-Two arguments are passed to the function: the positions of\n\
-the beginning and end of the range of old text to be changed.\n\
-\(For an insertion, the beginning and end are at the same place.)\n\
-No information is given about the length of the text after the change.\n\
-\n\
-Buffer changes made while executing the `before-change-function'\n\
-don't call any before-change or after-change functions.\n\
-That's because these variables are temporarily set to nil.\n\
-As a result, a hook function cannot straightforwardly alter the value of\n\
-these variables. See the Emacs Lisp manual for a way of\n\
-accomplishing an equivalent result by using other variables.\n\n\
-This variable is obsolete; use `before-change-functions' instead.");
- Vbefore_change_function = Qnil;
-
- DEFVAR_LISP ("after-change-function", &Vafter_change_function,
- "If non-nil, a Function to call after each text change (obsolete).\n\
-Three arguments are passed to the function: the positions of\n\
-the beginning and end of the range of changed text,\n\
-and the length of the pre-change text replaced by that range.\n\
-\(For an insertion, the pre-change length is zero;\n\
-for a deletion, that length is the number of characters deleted,\n\
-and the post-change beginning and end are at the same place.)\n\
-\n\
-Buffer changes made while executing the `after-change-function'\n\
-don't call any before-change or after-change functions.\n\
-That's because these variables are temporarily set to nil.\n\
-As a result, a hook function cannot straightforwardly alter the value of\n\
-these variables. See the Emacs Lisp manual for a way of\n\
-accomplishing an equivalent result by using other variables.\n\n\
-This variable is obsolete; use `after-change-functions' instead.");
- Vafter_change_function = Qnil;
DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions,
"List of functions to call before each text change.\n\
That's because these variables are temporarily set to nil.\n\
As a result, a hook function cannot straightforwardly alter the value of\n\
these variables. See the Emacs Lisp manual for a way of\n\
-accomplishing an equivalent result by using other variables.");
+accomplishing an equivalent result by using other variables.\n\
+\n\
+If an unhandled error happens in running these functions,\n\
+the variable's value remains nil. That prevents the error\n\
+from happening repeatedly and making Emacs nonfunctional.");
Vbefore_change_functions = Qnil;
DEFVAR_LISP ("after-change-functions", &Vafter_change_functions,
"List of function to call after each text change.\n\
Three arguments are passed to each function: the positions of\n\
the beginning and end of the range of changed text,\n\
-and the length of the pre-change text replaced by that range.\n\
+and the length in bytes of the pre-change text replaced by that range.\n\
\(For an insertion, the pre-change length is zero;\n\
-for a deletion, that length is the number of characters deleted,\n\
+for a deletion, that length is the number of bytes deleted,\n\
and the post-change beginning and end are at the same place.)\n\
\n\
Buffer changes made while executing the `after-change-functions'\n\
That's because these variables are temporarily set to nil.\n\
As a result, a hook function cannot straightforwardly alter the value of\n\
these variables. See the Emacs Lisp manual for a way of\n\
-accomplishing an equivalent result by using other variables.");
-
+accomplishing an equivalent result by using other variables.\n\
+\n\
+If an unhandled error happens in running these functions,\n\
+the variable's value remains nil. That prevents the error\n\
+from happening repeatedly and making Emacs nonfunctional.");
Vafter_change_functions = Qnil;
DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook,
but make-docfile can find it in this comment. */
DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer->undo_list, Qnil,
"List of undo entries in current buffer.\n\
+This variable is always local in all buffers.\n\
Recent changes come first; older changes follow newer.\n\
\n\
An entry (BEG . END) represents an insertion which begins at\n\
functions; it should only affect their performance.");
DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer->point_before_scroll, Qnil,
- "Value of point before the last series of scroll operations, or nil.");
+ "Value of point before the last series of scroll operations, or nil.\n\
+This variable is always local in all buffers.");
DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer->file_format, Qnil,
"List of formats to use when saving this buffer.\n\
+This variable is always local in all buffers.\n\
Formats are defined by `format-alist'. This variable is\n\
set when a file is visited. Automatically local in all buffers.");
DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
¤t_buffer->invisibility_spec, Qnil,
"Invisibility spec of this buffer.\n\
+This variable is always local in all buffers.\n\
The default is t, which means that text is invisible\n\
if it has a non-nil `invisible' property.\n\
If the value is a list, a text character is invisible if its `invisible'\n\
DEFVAR_PER_BUFFER ("buffer-display-count",
¤t_buffer->display_count, Qnil,
- "A number incremented each time the buffer is displayed in a window.");
+ "A number incremented each time this buffer is displayed in a window.\n\
+This variable is always local in all buffers.\n\
+The function `set-window-buffer increments it.");
+
+ DEFVAR_PER_BUFFER ("buffer-display-time",
+ ¤t_buffer->display_time, Qnil,
+ "Time stamp updated each time this buffer is displayed in a window.\n\
+This variable is always local in all buffers.\n\
+The function `set-window-buffer' updates this variable\n\
+to the value obtained by calling `current-time'.\n\
+If the buffer has never been shown in a window, the value is nil.");
DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode,
"*Non-nil means deactivate the mark when the buffer contents change.\n\
is a member of the list.");
Vinhibit_read_only = Qnil;
+ DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer->cursor_type, Qnil,
+ "Cursor to use in window displaying this buffer.\n\
+Values are interpreted as follows:\n\
+\n\
+ t use the cursor specified for the frame\n\
+ nil don't display a cursor\n\
+ `bar' display a bar cursor with default width\n\
+ (bar . WIDTH) display a bar cursor with width WIDTH\n\
+ others display a box cursor.");
+
+ DEFVAR_PER_BUFFER ("line-spacing",
+ ¤t_buffer->extra_line_spacing, Qnil,
+ "Additional space to put between lines when displaying a buffer.\n\
+The space is measured in pixels, and put below lines on window systems.");
+
DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions,
"List of functions called with no args to query before killing a buffer.");
Vkill_buffer_query_functions = Qnil;
defsubr (&Sbuffer_disable_undo);
defsubr (&Sbuffer_enable_undo);
defsubr (&Skill_buffer);
- defsubr (&Serase_buffer);
defsubr (&Sset_buffer_major_mode);
defsubr (&Sswitch_to_buffer);
defsubr (&Spop_to_buffer);
defsubr (&Sset_buffer);
defsubr (&Sbarf_if_buffer_read_only);
defsubr (&Sbury_buffer);
+ defsubr (&Serase_buffer);
+ defsubr (&Sset_buffer_multibyte);
defsubr (&Skill_all_local_variables);
defsubr (&Soverlayp);
defsubr (&Soverlay_lists);
defsubr (&Soverlay_get);
defsubr (&Soverlay_put);
+ defsubr (&Srestore_buffer_modified_p);
}
+void
keys_of_buffer ()
{
initial_define_key (control_x_map, 'b', "switch-to-buffer");
HCoop / bpt / emacs.git / blobdiff