set_string_intervals (parent, new);
new->position = 0;
}
-
+ eassert (LENGTH (new) > 0);
+
set_interval_object (new, parent);
return new;
}
-/* Make the interval TARGET have exactly the properties of SOURCE */
+/* Make the interval TARGET have exactly the properties of SOURCE. */
void
copy_properties (register INTERVAL source, register INTERVAL target)
Lisp_Object i1_cdr, i1_val;
if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1))
- return 1;
+ return true;
if (DEFAULT_INTERVAL_P (i0) || DEFAULT_INTERVAL_P (i1))
- return 0;
+ return false;
i0_cdr = i0->plist;
i1_cdr = i1->plist;
i0_sym = XCAR (i0_cdr);
i0_cdr = XCDR (i0_cdr);
if (!CONSP (i0_cdr))
- return 0;
+ return false;
i1_val = i1->plist;
while (CONSP (i1_val) && !EQ (XCAR (i1_val), i0_sym))
{
i1_val = XCDR (i1_val);
if (!CONSP (i1_val))
- return 0;
+ return false;
i1_val = XCDR (i1_val);
}
/* i0 has something i1 doesn't. */
if (EQ (i1_val, Qnil))
- return 0;
+ return false;
/* i0 and i1 both have sym, but it has different values in each. */
if (!CONSP (i1_val)
|| (i1_val = XCDR (i1_val), !CONSP (i1_val))
|| !EQ (XCAR (i1_val), XCAR (i0_cdr)))
- return 0;
+ return false;
i0_cdr = XCDR (i0_cdr);
i1_cdr = XCDR (i1_cdr);
if (!CONSP (i1_cdr))
- return 0;
+ return false;
i1_cdr = XCDR (i1_cdr);
}
ptrdiff_t old_total = A->total_length;
eassert (old_total > 0);
- eassert (old_total
- > TOTAL_LENGTH (B) + TOTAL_LENGTH (A->right));
- eassert (TOTAL_LENGTH (B)
- > TOTAL_LENGTH (B->left) + TOTAL_LENGTH (c));
+ eassert (LENGTH (A) > 0);
+ eassert (LENGTH (B) > 0);
/* Deal with any Parent of A; make it point to B. */
if (! ROOT_INTERVAL_P (A))
/* A's total length is decreased by the length of B and its left child. */
A->total_length -= B->total_length - TOTAL_LENGTH (c);
eassert (TOTAL_LENGTH (A) > 0);
+ eassert (LENGTH (A) > 0);
/* B must have the same total length of A. */
B->total_length = old_total;
+ eassert (LENGTH (B) > 0);
return B;
}
ptrdiff_t old_total = A->total_length;
eassert (old_total > 0);
- eassert (old_total
- > TOTAL_LENGTH (B) + TOTAL_LENGTH (A->left));
- eassert (TOTAL_LENGTH (B)
- > TOTAL_LENGTH (B->right) + TOTAL_LENGTH (c));
+ eassert (LENGTH (A) > 0);
+ eassert (LENGTH (B) > 0);
/* Deal with any parent of A; make it point to B. */
if (! ROOT_INTERVAL_P (A))
/* A's total length is decreased by the length of B and its right child. */
A->total_length -= B->total_length - TOTAL_LENGTH (c);
eassert (TOTAL_LENGTH (A) > 0);
+ eassert (LENGTH (A) > 0);
/* B must have the same total length of A. */
B->total_length = old_total;
+ eassert (LENGTH (B) > 0);
return B;
}
{
register ptrdiff_t old_diff, new_diff;
+ eassert (LENGTH (i) > 0);
+ eassert (TOTAL_LENGTH (i) >= LENGTH (i));
+
while (1)
{
old_diff = LEFT_TOTAL_LENGTH (i) - RIGHT_TOTAL_LENGTH (i);
balance_possible_root_interval (INTERVAL interval)
{
Lisp_Object parent;
- bool have_parent = 0;
-
- if (!INTERVAL_HAS_OBJECT (interval) && !INTERVAL_HAS_PARENT (interval))
- return interval;
+ bool have_parent = false;
if (INTERVAL_HAS_OBJECT (interval))
{
- have_parent = 1;
+ have_parent = true;
GET_INTERVAL_OBJECT (parent, interval);
}
+ else if (!INTERVAL_HAS_PARENT (interval))
+ return interval;
+
interval = balance_an_interval (interval);
if (have_parent)
{
set_interval_right (interval, new);
new->total_length = new_length;
- eassert (TOTAL_LENGTH (new) >= 0);
+ eassert (LENGTH (new) > 0);
}
else
{
set_interval_parent (interval->right, new);
set_interval_right (interval, new);
new->total_length = new_length + new->right->total_length;
- eassert (TOTAL_LENGTH (new) >= 0);
balance_an_interval (new);
}
{
set_interval_left (interval, new);
new->total_length = new_length;
- eassert (TOTAL_LENGTH (new) >= 0);
+ eassert (LENGTH (new) > 0);
}
else
{
set_interval_parent (new->left, new);
set_interval_left (interval, new);
new->total_length = new_length + new->left->total_length;
- eassert (TOTAL_LENGTH (new) >= 0);
balance_an_interval (new);
}
{
if (pos < i->position)
{
- /* Move left. */
+ /* Move left. */
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 */
+ i = i->left; /* Move to the left child. */
}
else if (NULL_PARENT (i))
error ("Point before start of properties");
}
else if (pos >= INTERVAL_LAST_POS (i))
{
- /* Move right. */
+ /* Move right. */
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 */
+ i = i->right; /* Move to the right child. */
}
else if (NULL_PARENT (i))
error ("Point %"pD"d after end of properties", pos);
for (temp = prev ? prev : i; temp; temp = INTERVAL_PARENT_OR_NULL (temp))
{
temp->total_length += length;
- eassert (TOTAL_LENGTH (temp) >= 0);
temp = balance_possible_root_interval (temp);
}
for (temp = i; temp; temp = INTERVAL_PARENT_OR_NULL (temp))
{
temp->total_length += length;
- eassert (TOTAL_LENGTH (temp) >= 0);
temp = balance_possible_root_interval (temp);
}
}
this = this->left;
this->total_length += migrate_amt;
}
- eassert (TOTAL_LENGTH (this) >= 0);
set_interval_left (this, migrate);
set_interval_parent (migrate, this);
+ eassert (LENGTH (this) > 0);
+ eassert (LENGTH (i->right) > 0);
return i->right;
}
relative_position,
amount);
tree->total_length -= subtract;
- eassert (TOTAL_LENGTH (tree) >= 0);
+ eassert (LENGTH (tree) > 0);
return subtract;
}
/* Right branch. */
relative_position,
amount);
tree->total_length -= subtract;
- eassert (TOTAL_LENGTH (tree) >= 0);
+ eassert (LENGTH (tree) > 0);
return subtract;
}
/* Here -- this node. */
amount = my_amount;
tree->total_length -= amount;
- eassert (TOTAL_LENGTH (tree) >= 0);
+ eassert (LENGTH (tree) >= 0);
if (LENGTH (tree) == 0)
delete_interval (tree);
if (ONLY_INTERVAL_P (tree))
{
tree->total_length -= length;
- eassert (TOTAL_LENGTH (tree) >= 0);
+ eassert (LENGTH (tree) > 0);
return;
}
while (! NULL_LEFT_CHILD (successor))
{
successor->total_length += absorb;
- eassert (TOTAL_LENGTH (successor) >= 0);
+ eassert (LENGTH (successor) > 0);
successor = successor->left;
}
successor->total_length += absorb;
- eassert (TOTAL_LENGTH (successor) >= 0);
+ eassert (LENGTH (successor) > 0);
delete_interval (i);
return successor;
}
successor = INTERVAL_PARENT (successor);
successor->total_length -= absorb;
- eassert (TOTAL_LENGTH (successor) >= 0);
+ eassert (LENGTH (successor) > 0);
}
/* This must be the rightmost or last interval and cannot
while (! NULL_RIGHT_CHILD (predecessor))
{
predecessor->total_length += absorb;
- eassert (TOTAL_LENGTH (predecessor) >= 0);
+ eassert (LENGTH (predecessor) > 0);
predecessor = predecessor->right;
}
predecessor->total_length += absorb;
- eassert (TOTAL_LENGTH (predecessor) >= 0);
+ eassert (LENGTH (predecessor) > 0);
delete_interval (i);
return predecessor;
}
predecessor = INTERVAL_PARENT (predecessor);
predecessor->total_length -= absorb;
- eassert (TOTAL_LENGTH (predecessor) >= 0);
+ eassert (LENGTH (predecessor) > 0);
}
/* This must be the leftmost or first interval and cannot
{
register INTERVAL target = make_interval ();
+ eassert (LENGTH (source) > 0);
+
target->total_length = source->total_length;
target->position = source->position;
if (! NULL_RIGHT_CHILD (source))
set_interval_right (target, reproduce_tree (source->right, target));
+ eassert (LENGTH (target) > 0);
return target;
}
if (! NILP (fallback))
return fallback;
- /* Check for alternative properties */
+ /* Check for alternative properties. */
tail = Fassq (prop, Vchar_property_alias_alist);
if (! NILP (tail))
{
end, end_byte);
}
- /* Rounding to char boundaries can theoretically ake this interval
+ /* Rounding to char boundaries can theoretically make this interval
spurious. If so, delete one child, and copy its property list
to this interval. */
if (LEFT_TOTAL_LENGTH (i) + RIGHT_TOTAL_LENGTH (i) >= TOTAL_LENGTH (i))