/* Markers: examining, setting and deleting.
- Copyright (C) 1985, 1997-1998, 2001-2012 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1997-1998, 2001-2013 Free Software Foundation,
+ Inc.
This file is part of GNU Emacs.
#include <config.h>
-#include <setjmp.h>
+
#include "lisp.h"
#include "character.h"
#include "buffer.h"
static ptrdiff_t cached_charpos;
static ptrdiff_t cached_bytepos;
static struct buffer *cached_buffer;
-static int cached_modiff;
+static EMACS_INT cached_modiff;
/* Juanma Barranquero <lekktu@gmail.com> reported ~3x increased
bootstrap time when byte_char_debug_check is enabled; so this
bytepos - BUF_BEG_BYTE (b));
if (charpos - 1 != nchars)
- abort ();
+ emacs_abort ();
}
#else /* not MARKER_DEBUG */
-#define byte_char_debug_check(b,charpos,bytepos) do { } while (0)
+#define byte_char_debug_check(b, charpos, bytepos) do { } while (0)
#endif /* MARKER_DEBUG */
-
+
void
clear_charpos_cache (struct buffer *b)
{
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. */
-/* charpos_to_bytepos returns the byte position corresponding to CHARPOS. */
-
-/* This macro is a subroutine of charpos_to_bytepos.
+/* This macro is a subroutine of buf_charpos_to_bytepos.
Note that it is desirable that BYTEPOS is not evaluated
except when we really want its value. */
#define CONSIDER(CHARPOS, BYTEPOS) \
{ \
ptrdiff_t this_charpos = (CHARPOS); \
- int changed = 0; \
+ bool changed = 0; \
\
if (this_charpos == charpos) \
{ \
} \
}
-ptrdiff_t
-charpos_to_bytepos (ptrdiff_t charpos)
+static void
+CHECK_MARKER (Lisp_Object x)
{
- return buf_charpos_to_bytepos (current_buffer, charpos);
+ CHECK_TYPE (MARKERP (x), Qmarkerp, x);
}
+/* Return the byte position corresponding to CHARPOS in B. */
+
ptrdiff_t
buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
{
ptrdiff_t best_above, best_above_byte;
ptrdiff_t best_below, best_below_byte;
- if (charpos < BUF_BEG (b) || charpos > BUF_Z (b))
- abort ();
+ eassert (BUF_BEG (b) <= charpos && charpos <= BUF_Z (b));
best_above = BUF_Z (b);
best_above_byte = BUF_Z_BYTE (b);
if (charpos - best_below < best_above - charpos)
{
- int record = charpos - best_below > 5000;
+ bool record = charpos - best_below > 5000;
while (best_below != charpos)
{
}
else
{
- int record = best_above - charpos > 5000;
+ bool record = best_above - charpos > 5000;
while (best_above != charpos)
{
#undef CONSIDER
-/* buf_bytepos_to_charpos returns the char position corresponding to
- BYTEPOS. */
-
/* This macro is a subroutine of buf_bytepos_to_charpos.
It is used when BYTEPOS is actually the byte position. */
} \
}
+/* Return the character position corresponding to BYTEPOS in B. */
+
ptrdiff_t
buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
{
ptrdiff_t best_above, best_above_byte;
ptrdiff_t best_below, best_below_byte;
- if (bytepos < BUF_BEG_BYTE (b) || bytepos > BUF_Z_BYTE (b))
- abort ();
+ eassert (BUF_BEG_BYTE (b) <= bytepos && bytepos <= BUF_Z_BYTE (b));
best_above = BUF_Z (b);
best_above_byte = BUF_Z_BYTE (b);
if (bytepos - best_below_byte < best_above_byte - bytepos)
{
- int record = bytepos - best_below_byte > 5000;
+ bool record = bytepos - best_below_byte > 5000;
while (best_below_byte < bytepos)
{
}
else
{
- int record = best_above_byte - bytepos > 5000;
+ bool record = best_above_byte - bytepos > 5000;
while (best_above_byte > bytepos)
{
does not preserve the buffer from being GC'd (it's weak), so
markers have to be unlinked from their buffer as soon as the buffer
is killed. */
- eassert (!NILP (BVAR (XBUFFER (buf), name)));
+ eassert (BUFFER_LIVE_P (XBUFFER (buf)));
return buf;
}
return Qnil;
/* Change M so it points to B at CHARPOS and BYTEPOS. */
-static inline void
+static void
attach_marker (struct Lisp_Marker *m, struct buffer *b,
ptrdiff_t charpos, ptrdiff_t bytepos)
{
- /* Every character is at least one byte. */
- eassert (charpos <= bytepos);
+ /* In a single-byte buffer, two positions must be equal.
+ Otherwise, every character is at least one byte. */
+ if (BUF_Z (b) == BUF_Z_BYTE (b))
+ eassert (charpos == bytepos);
+ else
+ eassert (charpos <= bytepos);
m->charpos = charpos;
m->bytepos = bytepos;
}
}
-DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
- 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. */)
- (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
-{
- register ptrdiff_t charpos;
- register ptrdiff_t bytepos;
- register struct buffer *b;
- register struct Lisp_Marker *m;
+/* If BUFFER is nil, return current buffer pointer. Next, check
+ whether BUFFER is a buffer object and return buffer pointer
+ corresponding to BUFFER if BUFFER is live, or NULL otherwise. */
- CHECK_MARKER (marker);
- m = XMARKER (marker);
+static struct buffer *
+live_buffer (Lisp_Object buffer)
+{
+ struct buffer *b;
- /* If position is nil or a marker that points nowhere,
- make this marker point nowhere. */
- if (NILP (position)
- || (MARKERP (position) && !XMARKER (position)->buffer))
+ if (NILP (buffer))
{
- unchain_marker (m);
- return marker;
+ b = current_buffer;
+ eassert (BUFFER_LIVE_P (b));
}
-
- if (NILP (buffer))
- b = current_buffer;
else
{
CHECK_BUFFER (buffer);
b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
- {
- unchain_marker (m);
- return marker;
- }
- }
-
- /* Optimize the special case where we are copying the position
- of an existing marker, and MARKER is already in the same buffer. */
- if (MARKERP (position) && b == XMARKER (position)->buffer
- && b == m->buffer)
- {
- m->bytepos = XMARKER (position)->bytepos;
- m->charpos = XMARKER (position)->charpos;
- return marker;
+ if (!BUFFER_LIVE_P (b))
+ b = NULL;
}
-
- CHECK_NUMBER_COERCE_MARKER (position);
- charpos = clip_to_bounds (BUF_BEG (b), XINT (position), BUF_Z (b));
- bytepos = buf_charpos_to_bytepos (b, charpos);
-
- attach_marker (m, b, charpos, bytepos);
- return marker;
+ return b;
}
-/* This version of Fset_marker won't let the position
- be outside the visible part. */
+/* Internal function to set MARKER in BUFFER at POSITION. Non-zero
+ RESTRICTED means limit the POSITION by the visible part of BUFFER. */
-Lisp_Object
-set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
+static Lisp_Object
+set_marker_internal (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer, bool restricted)
{
- register ptrdiff_t charpos;
- register ptrdiff_t bytepos;
- register struct buffer *b;
- register struct Lisp_Marker *m;
+ struct Lisp_Marker *m;
+ struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
- /* If position is nil or a marker that points nowhere,
- make this marker point nowhere. */
- if (NILP (pos)
- || (MARKERP (pos) && !XMARKER (pos)->buffer))
+ /* Set MARKER to point nowhere if BUFFER is dead, or
+ POSITION is nil or a marker points to nowhere. */
+ if (NILP (position)
+ || (MARKERP (position) && !XMARKER (position)->buffer)
+ || !b)
+ unchain_marker (m);
+
+ /* Optimize the special case where we are copying the position of
+ an existing marker, and MARKER is already in the same buffer. */
+ else if (MARKERP (position) && b == XMARKER (position)->buffer
+ && b == m->buffer)
{
- unchain_marker (m);
- return marker;
+ m->bytepos = XMARKER (position)->bytepos;
+ m->charpos = XMARKER (position)->charpos;
}
- if (NILP (buffer))
- b = current_buffer;
else
{
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
+ register ptrdiff_t charpos, bytepos;
+
+ /* Do not use CHECK_NUMBER_COERCE_MARKER because we
+ don't want to call buf_charpos_to_bytepos if POSITION
+ is a marker and so we know the bytepos already. */
+ if (INTEGERP (position))
+ charpos = XINT (position), bytepos = -1;
+ else if (MARKERP (position))
{
- unchain_marker (m);
- return marker;
+ charpos = XMARKER (position)->charpos;
+ bytepos = XMARKER (position)->bytepos;
}
+ else
+ wrong_type_argument (Qinteger_or_marker_p, position);
+
+ charpos = clip_to_bounds
+ (restricted ? BUF_BEGV (b) : BUF_BEG (b), charpos,
+ restricted ? BUF_ZV (b) : BUF_Z (b));
+ if (bytepos == -1)
+ bytepos = buf_charpos_to_bytepos (b, charpos);
+ else
+ bytepos = clip_to_bounds
+ (restricted ? BUF_BEGV_BYTE (b) : BUF_BEG_BYTE (b),
+ bytepos, restricted ? BUF_ZV_BYTE (b) : BUF_Z_BYTE (b));
+
+ attach_marker (m, b, charpos, bytepos);
}
+ return marker;
+}
- /* Optimize the special case where we are copying the position
- of an existing marker, and MARKER is already in the same buffer. */
- if (MARKERP (pos) && b == XMARKER (pos)->buffer
- && b == m->buffer)
- {
- m->bytepos = XMARKER (pos)->bytepos;
- m->charpos = XMARKER (pos)->charpos;
- return marker;
- }
+DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
+ doc: /* Position MARKER before character number POSITION in BUFFER.
+If BUFFER is omitted or nil, it defaults to the current buffer. If
+POSITION is nil, makes marker point nowhere so it no longer slows down
+editing in any buffer. Returns MARKER. */)
+ (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
+{
+ return set_marker_internal (marker, position, buffer, 0);
+}
- CHECK_NUMBER_COERCE_MARKER (pos);
- charpos = clip_to_bounds (BUF_BEGV (b), XINT (pos), BUF_ZV (b));
- bytepos = buf_charpos_to_bytepos (b, charpos);
+/* Like the above, but won't let the position be outside the visible part. */
- attach_marker (m, b, charpos, bytepos);
- return marker;
+Lisp_Object
+set_marker_restricted (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer)
+{
+ return set_marker_internal (marker, position, buffer, 1);
}
-\f
+
/* Set the position of MARKER, specifying both the
character position and the corresponding byte position. */
Lisp_Object
-set_marker_both (Lisp_Object marker, Lisp_Object buffer, ptrdiff_t charpos, ptrdiff_t bytepos)
+set_marker_both (Lisp_Object marker, Lisp_Object buffer,
+ ptrdiff_t charpos, ptrdiff_t bytepos)
{
- register struct buffer *b;
register struct Lisp_Marker *m;
+ register struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
- if (NILP (buffer))
- b = current_buffer;
+ if (b)
+ attach_marker (m, b, charpos, bytepos);
else
- {
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
- {
- unchain_marker (m);
- return marker;
- }
- }
-
- /* In a single-byte buffer, the two positions must be equal. */
- if (BUF_Z (b) == BUF_Z_BYTE (b)
- && charpos != bytepos)
- abort ();
-
- attach_marker (m, b, charpos, bytepos);
+ unchain_marker (m);
return marker;
}
-/* This version of set_marker_both won't let the position
- be outside the visible part. */
+/* Like the above, but won't let the position be outside the visible part. */
Lisp_Object
-set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, ptrdiff_t charpos, ptrdiff_t bytepos)
+set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer,
+ ptrdiff_t charpos, ptrdiff_t bytepos)
{
- register struct buffer *b;
register struct Lisp_Marker *m;
+ register struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
- if (NILP (buffer))
- b = current_buffer;
- else
+ if (b)
{
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
- {
- unchain_marker (m);
- return marker;
- }
+ attach_marker
+ (m, b,
+ clip_to_bounds (BUF_BEGV (b), charpos, BUF_ZV (b)),
+ clip_to_bounds (BUF_BEGV_BYTE (b), bytepos, BUF_ZV_BYTE (b)));
}
-
- charpos = clip_to_bounds (BUF_BEGV (b), charpos, BUF_ZV (b));
- bytepos = clip_to_bounds (BUF_BEGV_BYTE (b), bytepos, BUF_ZV_BYTE (b));
-
- /* In a single-byte buffer, the two positions must be equal. */
- if (BUF_Z (b) == BUF_Z_BYTE (b)
- && charpos != bytepos)
- abort ();
-
- attach_marker (m, b, charpos, bytepos);
+ else
+ unchain_marker (m);
return marker;
}
-\f
+
/* Remove MARKER from the chain of whatever buffer it is in,
leaving it points to nowhere. This is called during garbage
collection, so we must be careful to ignore and preserve
register struct Lisp_Marker *tail, **prev;
/* No dead buffers here. */
- eassert (!NILP (BVAR (b, name)));
+ eassert (BUFFER_LIVE_P (b));
marker->buffer = NULL;
prev = &BUF_MARKERS (b);
{
if (*prev == BUF_MARKERS (b))
{
- /* Deleting first marker from the buffer's chain. Crash
+ /* Deleting first marker from the buffer's chain. Crash
if new first marker in chain does not say it belongs
to the same buffer, or at least that they have the same
base buffer. */
if (tail->next && b->text != tail->next->buffer->text)
- abort ();
+ emacs_abort ();
}
*prev = tail->next;
/* We have removed the marker from the chain;