/* Markers: examining, setting and deleting.
- Copyright (C) 1985, 1997-1998, 2001-2012 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1997-1998, 2001-2014 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)
{
whether BUFFER is a buffer object and return buffer pointer
corresponding to BUFFER if BUFFER is live, or NULL otherwise. */
-static inline struct buffer *
+static struct buffer *
live_buffer (Lisp_Object buffer)
{
struct buffer *b;
if (NILP (buffer))
{
b = current_buffer;
- eassert (!NILP (BVAR (b, name)));
+ eassert (BUFFER_LIVE_P (b));
}
else
{
CHECK_BUFFER (buffer);
b = XBUFFER (buffer);
- if (NILP (BVAR (b, name)))
+ if (!BUFFER_LIVE_P (b))
b = NULL;
}
return b;
/* Internal function to set MARKER in BUFFER at POSITION. Non-zero
RESTRICTED means limit the POSITION by the visible part of BUFFER. */
-static inline Lisp_Object
+static Lisp_Object
set_marker_internal (Lisp_Object marker, Lisp_Object position,
- Lisp_Object buffer, int restricted)
+ Lisp_Object buffer, bool restricted)
{
- register struct Lisp_Marker *m;
- register struct buffer *b = live_buffer (buffer);
+ struct Lisp_Marker *m;
+ struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
else
{
register ptrdiff_t charpos, bytepos;
-
- CHECK_NUMBER_COERCE_MARKER (position);
- charpos = clip_to_bounds (restricted ? BUF_BEGV (b) : BUF_BEG (b),
- XINT (position),
- restricted ? BUF_ZV (b) : BUF_Z (b));
- bytepos = buf_charpos_to_bytepos (b, charpos);
+
+ /* 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))
+ {
+ 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;
}
DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
- doc: /* Position MARKER before character number POSITION in BUFFER,
-which defaults to the current buffer. If POSITION is nil,
-makes marker point nowhere so it no longer slows down
+ 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)
{
if (b)
{
- attach_marker
- (m, b,
+ 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)));
}
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;
HCoop / bpt / emacs.git / blobdiff