#include "buffer.h"
static Lisp_Object
-mark_marker (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_marker (Lisp_Object obj)
{
- struct Lisp_Marker *marker = XMARKER (obj);
+ Lisp_Marker *marker = XMARKER (obj);
Lisp_Object buf;
/* DO NOT mark through the marker's chain.
The buffer's markers chain does not preserve markers from gc;
static void
print_marker (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
- struct Lisp_Marker *marker = XMARKER (obj);
+ Lisp_Marker *marker = XMARKER (obj);
char buf[200];
if (print_readably)
write_c_string (GETTEXT ("in no buffer"), printcharfun);
else
{
- sprintf (buf, "at %d in ", marker_position (obj));
+ sprintf (buf, "at %ld in ", (long) marker_position (obj));
write_c_string (buf, printcharfun);
print_internal (marker->buffer->name, printcharfun, 0);
}
static int
marker_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
{
- struct Lisp_Marker *marker1 = XMARKER (obj1);
- struct Lisp_Marker *marker2 = XMARKER (obj2);
+ Lisp_Marker *marker1 = XMARKER (obj1);
+ Lisp_Marker *marker2 = XMARKER (obj2);
return ((marker1->buffer == marker2->buffer) &&
(marker1->memind == marker2->memind ||
return hash;
}
+static const struct lrecord_description marker_description[] = {
+ { XD_LISP_OBJECT, offsetof (Lisp_Marker, next) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Marker, prev) },
+ { XD_LISP_OBJECT, offsetof (Lisp_Marker, buffer) },
+ { XD_END }
+};
+
DEFINE_BASIC_LRECORD_IMPLEMENTATION ("marker", marker,
mark_marker, print_marker, 0,
- marker_equal, marker_hash,
- struct Lisp_Marker);
+ marker_equal, marker_hash, marker_description,
+ Lisp_Marker);
\f
/* Operations on markers. */
static void
check_marker_circularities (struct buffer *buf)
{
- struct Lisp_Marker *tortoise, *hare;
+ Lisp_Marker *tortoise, *hare;
tortoise = BUF_MARKERS (buf);
hare = tortoise;
#endif
static Lisp_Object
-set_marker_internal (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer,
- int restricted_p)
+set_marker_internal (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer, int restricted_p)
{
Bufpos charno;
struct buffer *b;
- struct Lisp_Marker *m;
+ Lisp_Marker *m;
int point_p;
CHECK_MARKER (marker);
/* If position is nil or a marker that points nowhere,
make this marker point nowhere. */
- if (NILP (pos) ||
- (MARKERP (pos) && !XMARKER (pos)->buffer))
+ if (NILP (position) ||
+ (MARKERP (position) && !XMARKER (position)->buffer))
{
if (point_p)
signal_simple_error ("Can't make point-marker point nowhere",
return marker;
}
- CHECK_INT_COERCE_MARKER (pos);
+ CHECK_INT_COERCE_MARKER (position);
if (NILP (buffer))
b = current_buffer;
else
}
}
- charno = XINT (pos);
+ charno = XINT (position);
m = XMARKER (marker);
if (restricted_p)
DEFUN ("set-marker", Fset_marker, 2, 3, 0, /*
-Position MARKER before character number NUMBER in BUFFER.
+Move MARKER to position POSITION in BUFFER.
+POSITION can be a marker, an integer or nil. If POSITION is an
+integer, make MARKER point before the POSITIONth character in BUFFER.
+If POSITION is nil, makes MARKER point nowhere. Then it no longer
+slows down editing in any buffer. If POSITION is less than 1, move
+MARKER to the beginning of BUFFER. If POSITION is greater than the
+size of BUFFER, move MARKER to the end of BUFFER.
BUFFER defaults to the current buffer.
-If NUMBER is nil, makes marker point nowhere.
-Then it no longer slows down editing in any buffer.
-If this marker was returned by (point-marker t), then changing its position
-moves point. You cannot change its buffer or make it point nowhere.
-Returns MARKER.
+If this marker was returned by (point-marker t), then changing its
+position moves point. You cannot change its buffer or make it point
+nowhere.
+The return value is MARKER.
*/
- (marker, number, buffer))
+ (marker, position, buffer))
{
- return set_marker_internal (marker, number, buffer, 0);
+ return set_marker_internal (marker, position, buffer, 0);
}
/* This version of Fset_marker won't let the position
be outside the visible part. */
Lisp_Object
-set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
+set_marker_restricted (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer)
{
- return set_marker_internal (marker, pos, buffer, 1);
+ return set_marker_internal (marker, position, buffer, 1);
}
void
unchain_marker (Lisp_Object m)
{
- struct Lisp_Marker *marker = XMARKER (m);
+ Lisp_Marker *marker = XMARKER (m);
struct buffer *b = marker->buffer;
if (b == 0)
Bytind
bi_marker_position (Lisp_Object marker)
{
- struct Lisp_Marker *m = XMARKER (marker);
+ Lisp_Marker *m = XMARKER (marker);
struct buffer *buf = m->buffer;
Bytind pos;
#ifdef ERROR_CHECK_BUFPOS
if (pos < BI_BUF_BEG (buf) || pos > BI_BUF_Z (buf))
- abort ();
+ ABORT ();
#endif
return pos;
void
set_bi_marker_position (Lisp_Object marker, Bytind pos)
{
- struct Lisp_Marker *m = XMARKER (marker);
+ Lisp_Marker *m = XMARKER (marker);
struct buffer *buf = m->buffer;
if (!buf)
#ifdef ERROR_CHECK_BUFPOS
if (pos < BI_BUF_BEG (buf) || pos > BI_BUF_Z (buf))
- abort ();
+ ABORT ();
#endif
m->memind = bytind_to_memind (buf, pos);
}
DEFUN ("copy-marker", Fcopy_marker, 1, 2, 0, /*
-Return a new marker pointing at the same place as MARKER.
-If argument is a number, makes a new marker pointing
+Return a new marker pointing at the same place as MARKER-OR-INTEGER.
+If MARKER-OR-INTEGER is an integer, return 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'.
+Optional argument MARKER-TYPE specifies the insertion type of the new
+marker; see `marker-insertion-type'.
*/
- (marker, type))
+ (marker_or_integer, marker_type))
{
- return copy_marker_1 (marker, type, 0);
+ return copy_marker_1 (marker_or_integer, marker_type, 0);
}
Lisp_Object
-noseeum_copy_marker (Lisp_Object marker, Lisp_Object type)
+noseeum_copy_marker (Lisp_Object marker, Lisp_Object marker_type)
{
- return copy_marker_1 (marker, type, 1);
+ return copy_marker_1 (marker, marker_type, 1);
}
DEFUN ("marker-insertion-type", Fmarker_insertion_type, 1, 1, 0, /*
*/
(position))
{
- struct Lisp_Marker *marker;
+ Lisp_Marker *marker;
Memind pos;
/* A small optimization trick: convert POS to memind now, rather
int
compute_buffer_marker_usage (struct buffer *b, struct overhead_stats *ovstats)
{
- struct Lisp_Marker *m;
+ Lisp_Marker *m;
int total = 0;
int overhead;
for (m = BUF_MARKERS (b); m; m = m->next)
- total += sizeof (struct Lisp_Marker);
+ total += sizeof (Lisp_Marker);
ovstats->was_requested += total;
overhead = fixed_type_block_overhead (total);
/* #### claiming this is all malloc overhead is not really right,
void
syms_of_marker (void)
{
+ INIT_LRECORD_IMPLEMENTATION (marker);
+
DEFSUBR (Fmarker_position);
DEFSUBR (Fmarker_buffer);
DEFSUBR (Fset_marker);
{
/* Unchain all markers of this buffer
and leave them pointing nowhere. */
- REGISTER struct Lisp_Marker *m, *next;
+ REGISTER Lisp_Marker *m, *next;
for (m = BUF_MARKERS (b); m; m = next)
{
m->buffer = 0;
projects / chise / xemacs-chise.git.1 / blobdiff