/* Record one cached position found recently by
buf_charpos_to_bytepos or buf_bytepos_to_charpos. */
-static int cached_charpos;
-static int cached_bytepos;
+static EMACS_INT cached_charpos;
+static EMACS_INT cached_bytepos;
static struct buffer *cached_buffer;
static int cached_modiff;
-static void byte_char_debug_check P_ ((struct buffer *, int, int));
+static void byte_char_debug_check (struct buffer *, EMACS_INT, EMACS_INT);
/* Nonzero means enable debugging checks on byte/char correspondences. */
static int byte_debug_flag;
void
-clear_charpos_cache (b)
- struct buffer *b;
+clear_charpos_cache (struct buffer *b)
{
if (cached_buffer == b)
cached_buffer = 0;
#define CONSIDER(CHARPOS, BYTEPOS) \
{ \
- int this_charpos = (CHARPOS); \
+ EMACS_INT this_charpos = (CHARPOS); \
int changed = 0; \
\
if (this_charpos == charpos) \
{ \
- int value = (BYTEPOS); \
+ EMACS_INT value = (BYTEPOS); \
if (byte_debug_flag) \
byte_char_debug_check (b, charpos, value); \
return value; \
{ \
if (best_above - best_below == best_above_byte - best_below_byte) \
{ \
- int value = best_below_byte + (charpos - best_below); \
+ EMACS_INT value = best_below_byte + (charpos - best_below); \
if (byte_debug_flag) \
byte_char_debug_check (b, charpos, value); \
return value; \
}
static void
-byte_char_debug_check (b, charpos, bytepos)
- struct buffer *b;
- int charpos, bytepos;
+byte_char_debug_check (struct buffer *b, EMACS_INT charpos, EMACS_INT bytepos)
{
- int nchars = 0;
+ EMACS_INT nchars = 0;
if (bytepos > BUF_GPT_BYTE (b))
{
abort ();
}
-int
-charpos_to_bytepos (charpos)
- int charpos;
+EMACS_INT
+charpos_to_bytepos (EMACS_INT charpos)
{
return buf_charpos_to_bytepos (current_buffer, charpos);
}
-int
-buf_charpos_to_bytepos (b, charpos)
- struct buffer *b;
- int charpos;
+EMACS_INT
+buf_charpos_to_bytepos (struct buffer *b, EMACS_INT charpos)
{
struct Lisp_Marker *tail;
- int best_above, best_above_byte;
- int best_below, best_below_byte;
+ EMACS_INT best_above, best_above_byte;
+ EMACS_INT best_below, best_below_byte;
if (charpos < BUF_BEG (b) || charpos > BUF_Z (b))
abort ();
/* Used for debugging: recompute the bytepos corresponding to CHARPOS
in the simplest, most reliable way. */
-int
-verify_bytepos (charpos)
- int charpos;
+EMACS_INT
+verify_bytepos (EMACS_INT charpos)
{
- int below = 1;
- int below_byte = 1;
+ EMACS_INT below = 1;
+ EMACS_INT below_byte = 1;
while (below != charpos)
{
#define CONSIDER(BYTEPOS, CHARPOS) \
{ \
- int this_bytepos = (BYTEPOS); \
+ EMACS_INT this_bytepos = (BYTEPOS); \
int changed = 0; \
\
if (this_bytepos == bytepos) \
{ \
- int value = (CHARPOS); \
+ EMACS_INT value = (CHARPOS); \
if (byte_debug_flag) \
byte_char_debug_check (b, value, bytepos); \
return value; \
{ \
if (best_above - best_below == best_above_byte - best_below_byte) \
{ \
- int value = best_below + (bytepos - best_below_byte); \
+ EMACS_INT value = best_below + (bytepos - best_below_byte); \
if (byte_debug_flag) \
byte_char_debug_check (b, value, bytepos); \
return value; \
} \
}
-int
-bytepos_to_charpos (bytepos)
- int bytepos;
+EMACS_INT
+bytepos_to_charpos (EMACS_INT bytepos)
{
return buf_bytepos_to_charpos (current_buffer, bytepos);
}
-int
-buf_bytepos_to_charpos (b, bytepos)
- struct buffer *b;
- int bytepos;
+EMACS_INT
+buf_bytepos_to_charpos (struct buffer *b, EMACS_INT bytepos)
{
struct Lisp_Marker *tail;
- int best_above, best_above_byte;
- int best_below, best_below_byte;
+ EMACS_INT best_above, best_above_byte;
+ EMACS_INT best_below, best_below_byte;
if (bytepos < BUF_BEG_BYTE (b) || bytepos > BUF_Z_BYTE (b))
abort ();
DEFUN ("marker-buffer", Fmarker_buffer, Smarker_buffer, 1, 1, 0,
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 marker)
{
register Lisp_Object buf;
CHECK_MARKER (marker);
DEFUN ("marker-position", Fmarker_position, Smarker_position, 1, 1, 0,
doc: /* Return the position MARKER points at, as a character number.
Returns nil if MARKER points nowhere. */)
- (marker)
- Lisp_Object marker;
+ (Lisp_Object marker)
{
CHECK_MARKER (marker);
if (XMARKER (marker)->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;
+ (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
{
- register int charno, bytepos;
+ register EMACS_INT charno, bytepos;
register struct buffer *b;
register struct Lisp_Marker *m;
be outside the visible part. */
Lisp_Object
-set_marker_restricted (marker, pos, buffer)
- Lisp_Object marker, pos, buffer;
+set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
{
- register int charno, bytepos;
+ register EMACS_INT charno, bytepos;
register struct buffer *b;
register struct Lisp_Marker *m;
character position and the corresponding byte position. */
Lisp_Object
-set_marker_both (marker, buffer, charpos, bytepos)
- Lisp_Object marker, buffer;
- int charpos, bytepos;
+set_marker_both (Lisp_Object marker, Lisp_Object buffer, EMACS_INT charpos, EMACS_INT bytepos)
{
register struct buffer *b;
register struct Lisp_Marker *m;
be outside the visible part. */
Lisp_Object
-set_marker_restricted_both (marker, buffer, charpos, bytepos)
- Lisp_Object marker, buffer;
- int charpos, bytepos;
+set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, EMACS_INT charpos, EMACS_INT bytepos)
{
register struct buffer *b;
register struct Lisp_Marker *m;
including those in chain fields of markers. */
void
-unchain_marker (marker)
- register struct Lisp_Marker *marker;
+unchain_marker (register struct Lisp_Marker *marker)
{
register struct Lisp_Marker *tail, *prev, *next;
register struct buffer *b;
/* Return the char position of marker MARKER, as a C integer. */
-int
-marker_position (marker)
- Lisp_Object marker;
+EMACS_INT
+marker_position (Lisp_Object marker)
{
register struct Lisp_Marker *m = XMARKER (marker);
register struct buffer *buf = m->buffer;
/* Return the byte position of marker MARKER, as a C integer. */
-int
-marker_byte_position (marker)
- Lisp_Object marker;
+EMACS_INT
+marker_byte_position (Lisp_Object marker)
{
register struct Lisp_Marker *m = XMARKER (marker);
register struct buffer *buf = m->buffer;
- register int i = m->bytepos;
+ register EMACS_INT i = m->bytepos;
if (!buf)
error ("Marker does not point anywhere");
return i;
}
\f
-DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 1, 2, 0,
+DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 0, 2, 0,
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.
+If MARKER is not specified, the new marker does not point anywhere.
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 marker, Lisp_Object type)
{
register Lisp_Object new;
+ if (!NILP (marker))
CHECK_TYPE (INTEGERP (marker) || MARKERP (marker), Qinteger_or_marker_p, marker);
new = Fmake_marker ();
Smarker_insertion_type, 1, 1, 0,
doc: /* Return insertion type of MARKER: t if it stays after inserted text.
The value nil means the marker stays before text inserted there. */)
- (marker)
- register Lisp_Object marker;
+ (register Lisp_Object marker)
{
CHECK_MARKER (marker);
return XMARKER (marker)->insertion_type ? Qt : Qnil;
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;
+ (Lisp_Object marker, Lisp_Object type)
{
CHECK_MARKER (marker);
DEFUN ("buffer-has-markers-at", Fbuffer_has_markers_at, Sbuffer_has_markers_at,
1, 1, 0,
doc: /* Return t if there are markers pointing at POSITION in the current buffer. */)
- (position)
- Lisp_Object position;
+ (Lisp_Object position)
{
register struct Lisp_Marker *tail;
- register int charno;
+ register EMACS_INT charno;
charno = XINT (position);
/* For debugging -- count the markers in buffer BUF. */
int
-count_markers (buf)
- struct buffer *buf;
+count_markers (struct buffer *buf)
{
int total = 0;
struct Lisp_Marker *tail;
}
\f
void
-syms_of_marker ()
+syms_of_marker (void)
{
defsubr (&Smarker_position);
defsubr (&Smarker_buffer);