/* Code for doing intervals.
- Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995, 1997, 1998 Free Software Foundation, Inc.
This file is part of GNU Emacs.
new->total_length = (BUF_Z (XBUFFER (parent))
- BUF_BEG (XBUFFER (parent)));
BUF_INTERVALS (XBUFFER (parent)) = new;
+ new->position = 1;
}
else if (STRINGP (parent))
{
new->total_length = XSTRING (parent)->size;
XSTRING (parent)->intervals = new;
+ new->position = 0;
}
- new->parent = (INTERVAL) parent;
- new->position = 1;
+ new->parent = (INTERVAL) XFASTINT (parent);
return new;
}
INTERVAL i0, i1;
{
register Lisp_Object i0_cdr, i0_sym, i1_val;
- register i1_len;
+ register int i1_len;
if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1))
return 1;
traverse_intervals (tree, position, depth, function, arg)
INTERVAL tree;
int position, depth;
- void (* function) ();
+ void (* function) P_ ((INTERVAL, Lisp_Object));
Lisp_Object arg;
{
if (NULL_INTERVAL_P (tree))
if (interval->parent == NULL_INTERVAL)
return interval;
- parent = (Lisp_Object) (interval->parent);
+ XSETFASTINT (parent, (EMACS_INT) interval->parent);
interval = balance_an_interval (interval);
if (BUFFERP (parent))
{
interval->right = new;
new->total_length = new_length;
-
- return new;
}
-
- /* Insert the new node between INTERVAL and its right child. */
- new->right = interval->right;
- interval->right->parent = new;
- interval->right = new;
- new->total_length = new_length + new->right->total_length;
-
- balance_an_interval (new);
+ else
+ {
+ /* Insert the new node between INTERVAL and its right child. */
+ new->right = interval->right;
+ interval->right->parent = new;
+ interval->right = new;
+ new->total_length = new_length + new->right->total_length;
+ balance_an_interval (new);
+ }
+
balance_possible_root_interval (interval);
return new;
{
interval->left = new;
new->total_length = new_length;
-
- return new;
}
-
- /* Insert the new node between INTERVAL and its left child. */
- new->left = interval->left;
- new->left->parent = new;
- interval->left = new;
- new->total_length = new_length + new->left->total_length;
-
- balance_an_interval (new);
+ else
+ {
+ /* Insert the new node between INTERVAL and its left child. */
+ new->left = interval->left;
+ new->left->parent = new;
+ interval->left = new;
+ new->total_length = new_length + new->left->total_length;
+ balance_an_interval (new);
+ }
+
balance_possible_root_interval (interval);
return new;
}
\f
+/* Return the proper position for the first character
+ described by the interval tree SOURCE.
+ This is 1 if the parent is a buffer,
+ 0 if the parent is a string or if there is no parent.
+
+ Don't use this function on an interval which is the child
+ of another interval! */
+
+int
+interval_start_pos (source)
+ INTERVAL source;
+{
+ Lisp_Object parent;
+
+ if (NULL_INTERVAL_P (source))
+ return 0;
+
+ XSETFASTINT (parent, (EMACS_INT) source->parent);
+ if (BUFFERP (parent))
+ return BUF_BEG (XBUFFER (parent));
+ return 0;
+}
+
/* Find the interval containing text position POSITION in the text
represented by the interval tree TREE. POSITION is a buffer
- position; the earliest position is 1. If POSITION is at the end of
- the buffer, return the interval containing the last character.
+ position (starting from 1) or a string index (starting from 0).
+ If POSITION is at the end of the buffer or string,
+ return the interval containing the last character.
The `position' field, which is a cache of an interval's position,
is updated in the interval found. Other functions (e.g., next_interval)
{
/* The distance from the left edge of the subtree at TREE
to POSITION. */
- register int relative_position = position - BEG;
+ register int relative_position;
+ Lisp_Object parent;
if (NULL_INTERVAL_P (tree))
return NULL_INTERVAL;
+ XSETFASTINT (parent, (EMACS_INT) tree->parent);
+ relative_position = position;
+ if (BUFFERP (parent))
+ relative_position -= BUF_BEG (XBUFFER (parent));
+
if (relative_position > TOTAL_LENGTH (tree))
abort (); /* Paranoia */
}
else
{
- tree->position =
- (position - relative_position /* the left edge of *tree */
- + LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */
+ tree->position
+ = (position - relative_position /* the left edge of *tree */
+ + LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */
return tree;
}
register INTERVAL interval;
{
register INTERVAL i;
- register position_of_previous;
+ register int position_of_previous;
if (NULL_INTERVAL_P (interval))
return NULL_INTERVAL;
}
/* Find the interval containing POS given some non-NULL INTERVAL
- in the same tree. */
+ in the same tree. Note that we need to update interval->position
+ if we go down the tree. */
INTERVAL
update_interval (i, pos)
register INTERVAL i;
if (pos < i->position)
{
/* Move left. */
- if (pos >= i->position - TOTAL_LENGTH (i->left))
- i = i->left; /* Move to the left child */
+ if (pos >= i->position - TOTAL_LENGTH (i->left))
+ {
+ i->left->position = i->position - TOTAL_LENGTH (i->left)
+ + LEFT_TOTAL_LENGTH (i->left);
+ i = i->left; /* Move to the left child */
+ }
else if (NULL_PARENT (i))
error ("Point before start of properties");
- else i = i->parent;
+ else
+ i = i->parent;
continue;
}
else if (pos >= INTERVAL_LAST_POS (i))
{
/* Move right. */
- if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right))
- i = i->right; /* Move to the right child */
+ if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right))
+ {
+ i->right->position = INTERVAL_LAST_POS (i) +
+ LEFT_TOTAL_LENGTH (i->right);
+ i = i->right; /* Move to the right child */
+ }
else if (NULL_PARENT (i))
error ("Point after end of properties");
else
- i = i->parent;
+ i = i->parent;
continue;
}
else
register INTERVAL i;
register INTERVAL temp;
int eobp = 0;
+ Lisp_Object parent;
+ int offset;
if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
abort ();
+ XSETFASTINT (parent, (EMACS_INT) tree->parent);
+ offset = (BUFFERP (parent) ? BUF_BEG (XBUFFER (parent)) : 0);
+
/* If inserting at point-max of a buffer, that position will be out
of range. Remember that buffer positions are 1-based. */
- if (position >= BEG + TOTAL_LENGTH (tree)){
- position = BEG + TOTAL_LENGTH (tree);
- eobp = 1;
- }
+ if (position >= TOTAL_LENGTH (tree) + offset)
+ {
+ position = TOTAL_LENGTH (tree) + offset;
+ eobp = 1;
+ }
i = find_interval (tree, position);
pright = NULL_INTERVAL_P (i) ? Qnil : i->plist;
newi.plist = merge_properties_sticky (pleft, pright);
- if(! prev) /* i.e. position == BEG */
+ if (! prev) /* i.e. position == BEG */
{
if (! intervals_equal (i, &newi))
{
if (ROOT_INTERVAL_P (i))
{
Lisp_Object owner;
- owner = (Lisp_Object) i->parent;
+ XSETFASTINT (owner, (EMACS_INT) i->parent);
parent = delete_node (i);
if (! NULL_INTERVAL_P (parent))
- parent->parent = (INTERVAL) owner;
+ parent->parent = (INTERVAL) XFASTINT (owner);
if (BUFFERP (owner))
BUF_INTERVALS (XBUFFER (owner)) = parent;
register int left_to_delete = length;
register INTERVAL tree = BUF_INTERVALS (buffer);
register int deleted;
+ Lisp_Object parent;
+ int offset;
+
+ XSETFASTINT (parent, (EMACS_INT) tree->parent);
+ offset = (BUFFERP (parent) ? BUF_BEG (XBUFFER (parent)) : 0);
if (NULL_INTERVAL_P (tree))
return;
- if (start > BEG + TOTAL_LENGTH (tree)
- || start + length > BEG + TOTAL_LENGTH (tree))
+ if (start > offset + TOTAL_LENGTH (tree)
+ || start + length > offset + TOTAL_LENGTH (tree))
abort ();
if (length == TOTAL_LENGTH (tree))
return;
}
- if (start > BEG + TOTAL_LENGTH (tree))
- start = BEG + TOTAL_LENGTH (tree);
+ if (start > offset + TOTAL_LENGTH (tree))
+ start = offset + TOTAL_LENGTH (tree);
while (left_to_delete > 0)
{
- left_to_delete -= interval_deletion_adjustment (tree, start - 1,
+ left_to_delete -= interval_deletion_adjustment (tree, start - offset,
left_to_delete);
tree = BUF_INTERVALS (buffer);
if (left_to_delete == tree->total_length)
/* Insert the intervals of SOURCE into BUFFER at POSITION.
LENGTH is the length of the text in SOURCE.
+ The `position' field of the SOURCE intervals is assumed to be
+ consistent with its parent; therefore, SOURCE must be an
+ interval tree made with copy_interval or must be the whole
+ tree of a buffer or a string.
+
This is used in insdel.c when inserting Lisp_Strings into the
buffer. The text corresponding to SOURCE is already in the buffer
when this is called. The intervals of new tree are a copy of those
Lisp_Object buf;
if (!inherit && ! NULL_INTERVAL_P (tree))
{
+ int saved_inhibit_modification_hooks = inhibit_modification_hooks;
XSETBUFFER (buf, buffer);
+ inhibit_modification_hooks = 1;
Fset_text_properties (make_number (position),
make_number (position + length),
Qnil, buf);
+ inhibit_modification_hooks = saved_inhibit_modification_hooks;
}
if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer));
Lisp_Object buf;
XSETBUFFER (buf, buffer);
BUF_INTERVALS (buffer) = reproduce_tree (source, buf);
- /* Explicitly free the old tree here. */
+ BUF_INTERVALS (buffer)->position = 1;
+
+ /* Explicitly free the old tree here? */
return;
}
about inserting properly. For now, just waste the old intervals. */
{
BUF_INTERVALS (buffer) = reproduce_tree (source, tree->parent);
+ BUF_INTERVALS (buffer)->position = 1;
/* Explicitly free the old tree here. */
return;
this = under = find_interval (tree, position);
if (NULL_INTERVAL_P (under)) /* Paranoia */
abort ();
- over = find_interval (source, 1);
+ over = find_interval (source, interval_start_pos (source));
/* Here for insertion in the middle of an interval.
Split off an equivalent interval to the right,
}
\f
-/* Set point in BUFFER to POSITION. If the target position is
+/* Set point "temporarily", without checking any text properties. */
+
+INLINE void
+temp_set_point (buffer, charpos)
+ struct buffer *buffer;
+ int charpos;
+{
+ temp_set_point_both (buffer, charpos,
+ buf_charpos_to_bytepos (buffer, charpos));
+}
+
+/* Set point in BUFFER "temporarily" to CHARPOS, which corresponds to
+ byte position BYTEPOS. */
+
+INLINE void
+temp_set_point_both (buffer, charpos, bytepos)
+ int charpos, bytepos;
+ struct buffer *buffer;
+{
+ /* In a single-byte buffer, the two positions must be equal. */
+ if (BUF_ZV (buffer) == BUF_ZV_BYTE (buffer)
+ && charpos != bytepos)
+ abort ();
+
+ if (charpos > bytepos)
+ abort ();
+
+ if (charpos > BUF_ZV (buffer) || charpos < BUF_BEGV (buffer))
+ abort ();
+
+ BUF_PT_BYTE (buffer) = bytepos;
+ BUF_PT (buffer) = charpos;
+}
+
+/* Set point in BUFFER to CHARPOS. If the target position is
before an intangible character, move to an ok place. */
void
-set_point (position, buffer)
- register int position;
+set_point (buffer, charpos)
register struct buffer *buffer;
+ register int charpos;
+{
+ set_point_both (buffer, charpos, buf_charpos_to_bytepos (buffer, charpos));
+}
+
+/* Set point in BUFFER to CHARPOS, which corresponds to byte
+ position BYTEPOS. If the target position is
+ before an intangible character, move to an ok place. */
+
+void
+set_point_both (buffer, charpos, bytepos)
+ register struct buffer *buffer;
+ register int charpos, bytepos;
{
register INTERVAL to, from, toprev, fromprev, target;
int buffer_point;
register Lisp_Object obj;
int old_position = BUF_PT (buffer);
- int backwards = (position < old_position ? 1 : 0);
+ int backwards = (charpos < old_position ? 1 : 0);
int have_overlays;
int original_position;
buffer->point_before_scroll = Qnil;
- if (position == BUF_PT (buffer))
+ if (charpos == BUF_PT (buffer))
return;
+ /* In a single-byte buffer, the two positions must be equal. */
+ if (BUF_ZV (buffer) == BUF_ZV_BYTE (buffer)
+ && charpos != bytepos)
+ abort ();
+
/* Check this now, before checking if the buffer has any intervals.
That way, we can catch conditions which break this sanity check
whether or not there are intervals in the buffer. */
- if (position > BUF_ZV (buffer) || position < BUF_BEGV (buffer))
+ if (charpos > BUF_ZV (buffer) || charpos < BUF_BEGV (buffer))
abort ();
have_overlays = (! NILP (buffer->overlays_before)
then we can do it quickly. */
if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) && ! have_overlays)
{
- BUF_PT (buffer) = position;
+ temp_set_point_both (buffer, charpos, bytepos);
return;
}
- /* Set TO to the interval containing the char after POSITION,
- and TOPREV to the interval containing the char before POSITION.
+ /* Set TO to the interval containing the char after CHARPOS,
+ and TOPREV to the interval containing the char before CHARPOS.
Either one may be null. They may be equal. */
- to = find_interval (BUF_INTERVALS (buffer), position);
- if (position == BUF_BEGV (buffer))
+ to = find_interval (BUF_INTERVALS (buffer), charpos);
+ if (charpos == BUF_BEGV (buffer))
toprev = 0;
- else if (to && to->position == position)
+ else if (to && to->position == charpos)
toprev = previous_interval (to);
else
toprev = to;
if (to == from && toprev == fromprev && INTERVAL_VISIBLE_P (to)
&& ! have_overlays)
{
- BUF_PT (buffer) = position;
+ temp_set_point_both (buffer, charpos, bytepos);
return;
}
- original_position = position;
+ original_position = charpos;
/* If the new position is between two intangible characters
with the same intangible property value,
|| have_overlays)
/* Intangibility never stops us from positioning at the beginning
or end of the buffer, so don't bother checking in that case. */
- && position != BEGV && position != ZV)
+ && charpos != BEGV && charpos != ZV)
{
Lisp_Object intangible_propval;
Lisp_Object pos;
- XSETINT (pos, position);
+ XSETINT (pos, charpos);
if (backwards)
{
- intangible_propval = Fget_char_property (make_number (position),
+ intangible_propval = Fget_char_property (make_number (charpos),
Qintangible, Qnil);
/* If following char is intangible,
}
else
{
- intangible_propval = Fget_char_property (make_number (position - 1),
+ intangible_propval = Fget_char_property (make_number (charpos - 1),
Qintangible, Qnil);
/* If following char is intangible,
- skip back over all chars with matching intangible property. */
+ skip forward over all chars with matching intangible property. */
if (! NILP (intangible_propval))
while (XINT (pos) < BUF_ZV (buffer)
&& EQ (Fget_char_property (pos, Qintangible, Qnil),
}
- position = XINT (pos);
+ charpos = XINT (pos);
+ bytepos = buf_charpos_to_bytepos (buffer, charpos);
}
- if (position != original_position)
+ if (charpos != original_position)
{
- /* Set TO to the interval containing the char after POSITION,
- and TOPREV to the interval containing the char before POSITION.
+ /* Set TO to the interval containing the char after CHARPOS,
+ and TOPREV to the interval containing the char before CHARPOS.
Either one may be null. They may be equal. */
- to = find_interval (BUF_INTERVALS (buffer), position);
- if (position == BUF_BEGV (buffer))
+ to = find_interval (BUF_INTERVALS (buffer), charpos);
+ if (charpos == BUF_BEGV (buffer))
toprev = 0;
- else if (to && to->position == position)
+ else if (to && to->position == charpos)
toprev = previous_interval (to);
else
toprev = to;
and TOPREV is the interval before the stopping point.
One or the other may be null. */
- BUF_PT (buffer) = position;
+ temp_set_point_both (buffer, charpos, bytepos);
/* We run point-left and point-entered hooks here, iff the
two intervals are not equivalent. These hooks take
enter_before = Qnil;
if (! EQ (leave_before, enter_before) && !NILP (leave_before))
- call2 (leave_before, old_position, position);
+ call2 (leave_before, make_number (old_position),
+ make_number (charpos));
if (! EQ (leave_after, enter_after) && !NILP (leave_after))
- call2 (leave_after, old_position, position);
+ call2 (leave_after, make_number (old_position),
+ make_number (charpos));
if (! EQ (enter_before, leave_before) && !NILP (enter_before))
- call2 (enter_before, old_position, position);
+ call2 (enter_before, make_number (old_position),
+ make_number (charpos));
if (! EQ (enter_after, leave_after) && !NILP (enter_after))
- call2 (enter_after, old_position, position);
+ call2 (enter_after, make_number (old_position),
+ make_number (charpos));
}
}
-
-/* Set point temporarily, without checking any text properties. */
-
-INLINE void
-temp_set_point (position, buffer)
- int position;
- struct buffer *buffer;
-{
- BUF_PT (buffer) = position;
-}
\f
/* Move point to POSITION, unless POSITION is inside an intangible
segment that reaches all the way to point. */
if (! NILP (Vinhibit_point_motion_hooks))
/* If intangible is inhibited, always move point to POSITION. */
;
- else if (PT < position && pos < ZV)
+ else if (PT < position && XINT (pos) < ZV)
{
/* We want to move forward, so check the text before POSITION. */
intangible_propval))
pos = Fprevious_char_property_change (pos, Qnil);
}
- else if (pos > BEGV)
+ else if (XINT (pos) > BEGV)
{
/* We want to move backward, so check the text after POSITION. */
Qintangible, Qnil);
/* If following char is intangible,
- skip back over all chars with matching intangible property. */
+ skip forward over all chars with matching intangible property. */
if (! NILP (intangible_propval))
while (XINT (pos) < ZV
&& EQ (Fget_char_property (pos, Qintangible, Qnil),
register struct buffer *buffer;
{
Lisp_Object prop, tem, lispy_position, lispy_buffer;
- int old_begv, old_zv;
+ int old_begv, old_zv, old_begv_byte, old_zv_byte;
/* Perhaps we should just change `position' to the limit. */
if (position > BUF_Z (buffer) || position < BUF_BEG (buffer))
the visible region contains no characters and hence no properties. */
old_begv = BUF_BEGV (buffer);
old_zv = BUF_ZV (buffer);
+ old_begv_byte = BUF_BEGV_BYTE (buffer);
+ old_zv_byte = BUF_ZV_BYTE (buffer);
BUF_BEGV (buffer) = BUF_BEG (buffer);
BUF_ZV (buffer) = BUF_Z (buffer);
+ BUF_BEGV_BYTE (buffer) = BUF_BEG_BYTE (buffer);
+ BUF_ZV_BYTE (buffer) = BUF_Z_BYTE (buffer);
/* There are no properties at the end of the buffer, so in that case
check for a local map on the last character of the buffer instead. */
BUF_BEGV (buffer) = old_begv;
BUF_ZV (buffer) = old_zv;
+ BUF_BEGV_BYTE (buffer) = old_begv_byte;
+ BUF_ZV_BYTE (buffer) = old_zv_byte;
/* Use the local map only if it is valid. */
/* Do allow symbols that are defined as keymaps. */
}
\f
/* Produce an interval tree reflecting the intervals in
- TREE from START to START + LENGTH. */
+ TREE from START to START + LENGTH.
+ The new interval tree has no parent and has a starting-position of 0. */
INTERVAL
copy_intervals (tree, start, length)
return NULL_INTERVAL;
new = make_interval ();
- new->position = 1;
+ new->position = 0;
got = (LENGTH (i) - (start - i->position));
new->total_length = length;
copy_properties (i, new);
if (NULL_INTERVAL_P (interval_copy))
return;
- interval_copy->parent = (INTERVAL) string;
+ interval_copy->parent = (INTERVAL) XFASTINT (string);
XSTRING (string)->intervals = interval_copy;
}
\f
-/* Return 1 if string S1 and S2 have identical properties; 0 otherwise.
+/* Return 1 if strings S1 and S2 have identical properties; 0 otherwise.
Assume they have identical characters. */
int
Lisp_Object s1, s2;
{
INTERVAL i1, i2;
- int pos = 1;
- int end = XSTRING (s1)->size + 1;
+ int pos = 0;
+ int end = XSTRING (s1)->size;
- /* We specify 1 as position because the interval functions
- always use positions starting at 1. */
- i1 = find_interval (XSTRING (s1)->intervals, 1);
- i2 = find_interval (XSTRING (s2)->intervals, 1);
+ i1 = find_interval (XSTRING (s1)->intervals, 0);
+ i2 = find_interval (XSTRING (s2)->intervals, 0);
while (pos < end)
{
}
return 1;
}
+\f
+/* Recursively adjust interval I in the current buffer
+ for setting enable_multibyte_characters to MULTI_FLAG.
+ The range of interval I is START ... END in characters,
+ START_BYTE ... END_BYTE in bytes. */
+
+static void
+set_intervals_multibyte_1 (i, multi_flag, start, start_byte, end, end_byte)
+ INTERVAL i;
+ int multi_flag;
+ int start, start_byte, end, end_byte;
+{
+ INTERVAL left, right;
+
+ /* Fix the length of this interval. */
+ if (multi_flag)
+ i->total_length = end - start;
+ else
+ i->total_length = end_byte - start_byte;
+
+ /* Recursively fix the length of the subintervals. */
+ if (i->left)
+ {
+ int left_end, left_end_byte;
+
+ if (multi_flag)
+ {
+ left_end_byte = start_byte + LEFT_TOTAL_LENGTH (i);
+ left_end = BYTE_TO_CHAR (left_end_byte);
+ }
+ else
+ {
+ left_end = start + LEFT_TOTAL_LENGTH (i);
+ left_end_byte = CHAR_TO_BYTE (left_end);
+ }
+
+ set_intervals_multibyte_1 (i->left, multi_flag, start, start_byte,
+ left_end, left_end_byte);
+ }
+ if (i->right)
+ {
+ int right_start_byte, right_start;
+
+ if (multi_flag)
+ {
+ right_start_byte = end_byte - RIGHT_TOTAL_LENGTH (i);
+ right_start = BYTE_TO_CHAR (right_start_byte);
+ }
+ else
+ {
+ right_start = end - RIGHT_TOTAL_LENGTH (i);
+ right_start_byte = CHAR_TO_BYTE (right_start);
+ }
+
+ set_intervals_multibyte_1 (i->right, multi_flag,
+ right_start, right_start_byte,
+ end, end_byte);
+ }
+}
+
+/* Update the intervals of the current buffer
+ to fit the contents as multibyte (if MULTI_FLAG is 1)
+ or to fit them as non-multibyte (if MULTI_FLAG is 0). */
+
+void
+set_intervals_multibyte (multi_flag)
+ int multi_flag;
+{
+ if (BUF_INTERVALS (current_buffer))
+ set_intervals_multibyte_1 (BUF_INTERVALS (current_buffer), multi_flag,
+ BEG, BEG_BYTE, Z, Z_BYTE);
+}
#endif /* USE_TEXT_PROPERTIES */
HCoop / bpt / emacs.git / blobdiff