static struct buffer *cached_buffer;
static int cached_modiff;
+static void byte_char_debug_check P_ ((struct buffer *, int, int));
+
/* Nonzero means enable debugging checks on byte/char correspondences. */
static int byte_debug_flag;
/* Converting between character positions and byte positions. */
/* There are several places in the buffer where we know
- the corrspondence: BEG, BEGV, PT, GPT, ZV and Z,
+ the correspondence: BEG, BEGV, PT, GPT, ZV and Z,
and everywhere there is a marker. So we find the one of these places
that is closest to the specified position, and scan from there. */
} \
}
-int
+static void
byte_char_debug_check (b, charpos, bytepos)
struct buffer *b;
int charpos, bytepos;
if (best_above == best_above_byte)
return charpos;
- best_below = 1;
- best_below_byte = 1;
+ best_below = BEG;
+ best_below_byte = BEG_BYTE;
/* We find in best_above and best_above_byte
the closest known point above CHARPOS,
}
#undef CONSIDER
+
+/* Used for debugging: recompute the bytepos corresponding to CHARPOS
+ in the simplest, most reliable way. */
+
+int
+verify_bytepos (charpos)
+{
+ int below = 1;
+ int below_byte = 1;
+
+ while (below != charpos)
+ {
+ below++;
+ BUF_INC_POS (current_buffer, below_byte);
+ }
+
+ return below_byte;
+}
\f
/* bytepos_to_charpos returns the char position corresponding to BYTEPOS. */
if (best_above == best_above_byte)
return bytepos;
- best_below = 1;
- best_below_byte = 1;
+ best_below = BEG;
+ best_below_byte = BEG_BYTE;
CONSIDER (BUF_PT_BYTE (b), BUF_PT (b));
CONSIDER (BUF_GPT_BYTE (b), BUF_GPT (b));
/* Operations on markers. */
DEFUN ("marker-buffer", Fmarker_buffer, Smarker_buffer, 1, 1, 0,
- "Return the buffer that MARKER points into, or nil if none.\n\
-Returns nil if MARKER points into a dead buffer.")
- (marker)
+ doc: /* Return the buffer that MARKER points into, or nil if none.
+Returns nil if MARKER points into a dead buffer. */)
+ (marker)
register Lisp_Object marker;
{
register Lisp_Object buf;
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
if (XMARKER (marker)->buffer)
{
XSETBUFFER (buf, XMARKER (marker)->buffer);
}
DEFUN ("marker-position", Fmarker_position, Smarker_position, 1, 1, 0,
- "Return the position MARKER points at, as a character number.")
- (marker)
+ doc: /* Return the position MARKER points at, as a character number. */)
+ (marker)
Lisp_Object marker;
{
- register Lisp_Object pos;
- register int i;
- register struct buffer *buf;
-
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
if (XMARKER (marker)->buffer)
return make_number (XMARKER (marker)->charpos);
}
\f
DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
- "Position MARKER before character number POSITION in BUFFER.\n\
-BUFFER defaults to the current buffer.\n\
-If POSITION is nil, makes marker point nowhere.\n\
-Then it no longer slows down editing in any buffer.\n\
-Returns MARKER.")
- (marker, position, buffer)
+ doc: /* Position MARKER before character number POSITION in BUFFER.
+BUFFER defaults to the current buffer.
+If POSITION is nil, makes marker point nowhere.
+Then it no longer slows down editing in any buffer.
+Returns MARKER. */)
+ (marker, position, buffer)
Lisp_Object marker, position, buffer;
{
register int charno, bytepos;
register struct buffer *b;
register struct Lisp_Marker *m;
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
/* If position is nil or a marker that points nowhere,
make this marker point nowhere. */
if (NILP (position)
b = current_buffer;
else
{
- CHECK_BUFFER (buffer, 1);
+ CHECK_BUFFER (buffer);
b = XBUFFER (buffer);
/* If buffer is dead, set marker to point nowhere. */
if (EQ (b->name, Qnil))
return marker;
}
- CHECK_NUMBER_COERCE_MARKER (position, 1);
+ CHECK_NUMBER_COERCE_MARKER (position);
charno = XINT (position);
m->chain = BUF_MARKERS (b);
BUF_MARKERS (b) = marker;
}
-
+
return marker;
}
/* This version of Fset_marker won't let the position
be outside the visible part. */
-Lisp_Object
+Lisp_Object
set_marker_restricted (marker, pos, buffer)
Lisp_Object marker, pos, buffer;
{
register struct buffer *b;
register struct Lisp_Marker *m;
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
/* If position is nil or a marker that points nowhere,
make this marker point nowhere. */
if (NILP (pos)
b = current_buffer;
else
{
- CHECK_BUFFER (buffer, 1);
+ CHECK_BUFFER (buffer);
b = XBUFFER (buffer);
/* If buffer is dead, set marker to point nowhere. */
if (EQ (b->name, Qnil))
return marker;
}
- CHECK_NUMBER_COERCE_MARKER (pos, 1);
+ CHECK_NUMBER_COERCE_MARKER (pos);
charno = XINT (pos);
m->chain = BUF_MARKERS (b);
BUF_MARKERS (b) = marker;
}
-
+
return marker;
}
\f
/* Set the position of MARKER, specifying both the
character position and the corresponding byte position. */
-Lisp_Object
+Lisp_Object
set_marker_both (marker, buffer, charpos, bytepos)
Lisp_Object marker, buffer;
int charpos, bytepos;
register struct buffer *b;
register struct Lisp_Marker *m;
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
if (NILP (buffer))
b = current_buffer;
else
{
- CHECK_BUFFER (buffer, 1);
+ CHECK_BUFFER (buffer);
b = XBUFFER (buffer);
/* If buffer is dead, set marker to point nowhere. */
if (EQ (b->name, Qnil))
m->chain = BUF_MARKERS (b);
BUF_MARKERS (b) = marker;
}
-
+
return marker;
}
/* This version of set_marker_both won't let the position
be outside the visible part. */
-Lisp_Object
+Lisp_Object
set_marker_restricted_both (marker, buffer, charpos, bytepos)
Lisp_Object marker, buffer;
int charpos, bytepos;
register struct buffer *b;
register struct Lisp_Marker *m;
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
if (NILP (buffer))
b = current_buffer;
else
{
- CHECK_BUFFER (buffer, 1);
+ CHECK_BUFFER (buffer);
b = XBUFFER (buffer);
/* If buffer is dead, set marker to point nowhere. */
if (EQ (b->name, Qnil))
m->chain = BUF_MARKERS (b);
BUF_MARKERS (b) = marker;
}
-
+
return marker;
}
\f
-/* This is called during garbage collection,
+/* Remove MARKER from the chain of whatever buffer it is in.
+ Leave it "in no buffer".
+
+ This is called during garbage collection,
so we must be careful to ignore and preserve mark bits,
including those in chain fields of markers. */
}
\f
DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 1, 2, 0,
- "Return a new marker pointing at the same place as MARKER.\n\
-If argument is a number, makes a new marker pointing\n\
-at that position in the current buffer.\n\
-The optional argument TYPE specifies the insertion type of the new marker;\n\
-see `marker-insertion-type'.")
- (marker, type)
+ doc: /* Return a new marker pointing at the same place as MARKER.
+If argument is a number, makes a new marker pointing
+at that position in the current buffer.
+The optional argument TYPE specifies the insertion type of the new marker;
+see `marker-insertion-type'. */)
+ (marker, type)
register Lisp_Object marker, type;
{
register Lisp_Object new;
DEFUN ("marker-insertion-type", Fmarker_insertion_type,
Smarker_insertion_type, 1, 1, 0,
- "Return insertion type of MARKER: t if it stays after inserted text.\n\
-nil means the marker stays before text inserted there.")
- (marker)
+ doc: /* Return insertion type of MARKER: t if it stays after inserted text.
+nil means the marker stays before text inserted there. */)
+ (marker)
register Lisp_Object marker;
{
- register Lisp_Object buf;
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
return XMARKER (marker)->insertion_type ? Qt : Qnil;
}
DEFUN ("set-marker-insertion-type", Fset_marker_insertion_type,
Sset_marker_insertion_type, 2, 2, 0,
- "Set the insertion-type of MARKER to TYPE.\n\
-If TYPE is t, it means the marker advances when you insert text at it.\n\
-If TYPE is nil, it means the marker stays behind when you insert text at it.")
- (marker, type)
+ doc: /* Set the insertion-type of MARKER to TYPE.
+If TYPE is t, it means the marker advances when you insert text at it.
+If TYPE is nil, it means the marker stays behind when you insert text at it. */)
+ (marker, type)
Lisp_Object marker, type;
{
- CHECK_MARKER (marker, 0);
+ CHECK_MARKER (marker);
XMARKER (marker)->insertion_type = ! NILP (type);
return type;
}
DEFUN ("buffer-has-markers-at", Fbuffer_has_markers_at, Sbuffer_has_markers_at,
- 1, 1, 0,
- "Return t if there are markers pointing at POSITION in the current buffer.")
- (position)
- Lisp_Object position;
+ 1, 1, 0,
+ doc: /* Return t if there are markers pointing at POSITION in the current buffer. */)
+ (position)
+ Lisp_Object position;
{
register Lisp_Object tail;
register int charno;
return Qnil;
}
+
+/* For debugging -- count the markers in buffer BUF. */
+
+int
+count_markers (buf)
+ struct buffer *buf;
+{
+ int total = 0;
+ Lisp_Object tail;
+
+ for (tail = BUF_MARKERS (buf);
+ !NILP (tail);
+ tail = XMARKER (tail)->chain)
+ total++;
+
+ return total;
+}
\f
void
syms_of_marker ()
defsubr (&Sbuffer_has_markers_at);
DEFVAR_BOOL ("byte-debug-flag", &byte_debug_flag,
- "Non-nil enables debugging checks in byte/char position conversions.");
+ doc: /* Non-nil enables debugging checks in byte/char position conversions. */);
byte_debug_flag = 0;
-
}