mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-17 11:20:39 -08:00
Code Issues Projects Releases Wiki Activity

Prefix all itree.h type names with itree_

Browse source 
Rename interval_node -> itree_node, interval_tree -> itree_tree,
interval_tree_order -> itree_order.

* src/alloc.c: Renames.
* src/buffer.c: ditto.
* src/itree.c: ditto.
* src/itree.h: ditto.
* src/lisp.h: ditto.
* src/pdumper.h: ditto.
* src/textprop.h: ditto.
* src/xdisp.h: ditto.
This commit is contained in:
Matt Armstrong 2022-10-19 15:56:07 -07:00 • committed by Stefan Monnier
parent 06252617b2
commit f421b58db5
9 changed files with 135 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/alloc.c
View file

@ -3711,7 +3711,7 @@ build_overlay (bool front_advance, bool rear_advance,
struct Lisp_Overlay *p = ALLOCATE_PSEUDOVECTOR (struct Lisp_Overlay, plist, struct Lisp_Overlay *p = ALLOCATE_PSEUDOVECTOR (struct Lisp_Overlay, plist,
PVEC_OVERLAY); PVEC_OVERLAY);
Lisp_Object overlay = make_lisp_ptr (p, Lisp_Vectorlike); Lisp_Object overlay = make_lisp_ptr (p, Lisp_Vectorlike);
struct interval_node *node = xmalloc (sizeof (*node)); struct itree_node *node = xmalloc (sizeof (*node));
interval_node_init (node, front_advance, rear_advance, overlay); interval_node_init (node, front_advance, rear_advance, overlay);
p->interval = node; p->interval = node;
p->buffer = NULL; p->buffer = NULL;
@ -6518,7 +6518,7 @@ mark_overlay (struct Lisp_Overlay *ov)
/* Mark the overlay subtree rooted at NODE. */ /* Mark the overlay subtree rooted at NODE. */
static void static void
mark_overlays (struct interval_node *node) mark_overlays (struct itree_node *node)
{ {
if (node == NULL) if (node == NULL)
return; return;

40
src/buffer.c
View file

@ -655,7 +655,7 @@ static void
copy_overlays (struct buffer *from, struct buffer *to) copy_overlays (struct buffer *from, struct buffer *to)
{ {
eassert (to && ! to->overlays); eassert (to && ! to->overlays);
struct interval_node *node; struct itree_node *node;
ITREE_FOREACH (node, from->overlays, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING) ITREE_FOREACH (node, from->overlays, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING)
{ {
@ -932,13 +932,13 @@ drop_overlay (struct Lisp_Overlay *ov)
void void
delete_all_overlays (struct buffer *b) delete_all_overlays (struct buffer *b)
{ {
struct interval_node *node; struct itree_node *node;
if (! b->overlays) if (! b->overlays)
return; return;
/* FIXME: This loop sets the overlays' `buffer` field to NULL but /* FIXME: This loop sets the overlays' `buffer` field to NULL but
doesn't set the interval_nodes' `parent`, `left` and `right` doesn't set the itree_nodes' `parent`, `left` and `right`
fields accordingly. I believe it's harmless, but a bit untidy since fields accordingly. I believe it's harmless, but a bit untidy since
other parts of the code are careful to set those fields to NULL when other parts of the code are careful to set those fields to NULL when
the overlay is deleted. the overlay is deleted.
@ -978,8 +978,8 @@ set_overlays_multibyte (bool multibyte)
if (! current_buffer->overlays || Z == Z_BYTE) if (! current_buffer->overlays || Z == Z_BYTE)
return; return;
struct interval_node **nodes = NULL; struct itree_node **nodes = NULL;
struct interval_tree *tree = current_buffer->overlays; struct itree_tree *tree = current_buffer->overlays;
const intmax_t size = interval_tree_size (tree); const intmax_t size = interval_tree_size (tree);
/* We can't use `interval_node_set_region` at the same time /* We can't use `interval_node_set_region` at the same time
@ -988,14 +988,14 @@ set_overlays_multibyte (bool multibyte)
USE_SAFE_ALLOCA; USE_SAFE_ALLOCA;
SAFE_NALLOCA (nodes, 1, size); SAFE_NALLOCA (nodes, 1, size);
{ {
struct interval_node *node, **cursor = nodes; struct itree_node *node, **cursor = nodes;
ITREE_FOREACH (node, tree, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING) ITREE_FOREACH (node, tree, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING)
*(cursor++) = node; *(cursor++) = node;
} }
for (int i = 0; i < size; ++i, ++nodes) for (int i = 0; i < size; ++i, ++nodes)
{ {
struct interval_node * const node = *nodes; struct itree_node * const node = *nodes;
if (multibyte) if (multibyte)
{ {
@ -2436,7 +2436,7 @@ advance_to_char_boundary (ptrdiff_t byte_pos)
static void static void
swap_buffer_overlays (struct buffer *buffer, struct buffer *other) swap_buffer_overlays (struct buffer *buffer, struct buffer *other)
{ {
struct interval_node *node; struct itree_node *node;
ITREE_FOREACH (node, buffer->overlays, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING) ITREE_FOREACH (node, buffer->overlays, PTRDIFF_MIN, PTRDIFF_MAX, ASCENDING)
XOVERLAY (node->data)->buffer = other; XOVERLAY (node->data)->buffer = other;
@ -2965,7 +2965,7 @@ overlays_in (ptrdiff_t beg, ptrdiff_t end, bool extend,
ptrdiff_t len = *len_ptr; ptrdiff_t len = *len_ptr;
ptrdiff_t next = ZV; ptrdiff_t next = ZV;
Lisp_Object *vec = *vec_ptr; Lisp_Object *vec = *vec_ptr;
struct interval_node *node; struct itree_node *node;
ITREE_FOREACH (node, current_buffer->overlays, beg, ITREE_FOREACH (node, current_buffer->overlays, beg,
/* Find empty OV at Z ? */ /* Find empty OV at Z ? */
@ -3026,7 +3026,7 @@ ptrdiff_t
next_overlay_change (ptrdiff_t pos) next_overlay_change (ptrdiff_t pos)
{ {
ptrdiff_t next = ZV; ptrdiff_t next = ZV;
struct interval_node *node; struct itree_node *node;
ITREE_FOREACH (node, current_buffer->overlays, pos, next, ASCENDING) ITREE_FOREACH (node, current_buffer->overlays, pos, next, ASCENDING)
{ {
@ -3052,7 +3052,7 @@ next_overlay_change (ptrdiff_t pos)
ptrdiff_t ptrdiff_t
previous_overlay_change (ptrdiff_t pos) previous_overlay_change (ptrdiff_t pos)
{ {
struct interval_node *node; struct itree_node *node;
ptrdiff_t prev = BEGV; ptrdiff_t prev = BEGV;
ITREE_FOREACH (node, current_buffer->overlays, prev, pos, DESCENDING) ITREE_FOREACH (node, current_buffer->overlays, prev, pos, DESCENDING)
@ -3135,7 +3135,7 @@ disable_line_numbers_overlay_at_eob (void)
bool bool
overlay_touches_p (ptrdiff_t pos) overlay_touches_p (ptrdiff_t pos)
{ {
struct interval_node *node; struct itree_node *node;
/* We need to find overlays ending in pos, as well as empty ones at /* We need to find overlays ending in pos, as well as empty ones at
pos. */ pos. */
@ -3347,7 +3347,7 @@ ptrdiff_t
overlay_strings (ptrdiff_t pos, struct window *w, unsigned char **pstr) overlay_strings (ptrdiff_t pos, struct window *w, unsigned char **pstr)
{ {
bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters)); bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
struct interval_node *node; struct itree_node *node;
overlay_heads.used = overlay_heads.bytes = 0; overlay_heads.used = overlay_heads.bytes = 0;
overlay_tails.used = overlay_tails.bytes = 0; overlay_tails.used = overlay_tails.bytes = 0;
@ -3848,7 +3848,7 @@ However, the overlays you get are the real objects that the buffer uses. */)
(void) (void)
{ {
Lisp_Object overlays = Qnil; Lisp_Object overlays = Qnil;
struct interval_node *node; struct itree_node *node;
ITREE_FOREACH (node, current_buffer->overlays, BEG, Z, DESCENDING) ITREE_FOREACH (node, current_buffer->overlays, BEG, Z, DESCENDING)
overlays = Fcons (node->data, overlays); overlays = Fcons (node->data, overlays);
@ -3980,7 +3980,7 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
if (!after) if (!after)
{ {
struct interval_node *node; struct itree_node *node;
EMACS_INT begin_arg = XFIXNUM (start); EMACS_INT begin_arg = XFIXNUM (start);
EMACS_INT end_arg = XFIXNUM (end); EMACS_INT end_arg = XFIXNUM (end);
/* We are being called before a change. /* We are being called before a change.
@ -4072,7 +4072,7 @@ void
evaporate_overlays (ptrdiff_t pos) evaporate_overlays (ptrdiff_t pos)
{ {
Lisp_Object hit_list = Qnil; Lisp_Object hit_list = Qnil;
struct interval_node *node; struct itree_node *node;
ITREE_FOREACH (node, current_buffer->overlays, pos, pos, ASCENDING) ITREE_FOREACH (node, current_buffer->overlays, pos, pos, ASCENDING)
{ {
@ -4913,7 +4913,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
#ifdef ITREE_DEBUG #ifdef ITREE_DEBUG
static Lisp_Object static Lisp_Object
make_lispy_interval_node (const struct interval_node *node) make_lispy_itree_node (const struct itree_node *node)
{ {
return listn (12, return listn (12,
intern (":begin"), intern (":begin"),
@ -4931,12 +4931,12 @@ make_lispy_interval_node (const struct interval_node *node)
} }
static Lisp_Object static Lisp_Object
overlay_tree (const struct interval_tree *tree, overlay_tree (const struct itree_tree *tree,
const struct interval_node *node) const struct itree_node *node)
{ {
if (node == ITREE_NULL) if (node == ITREE_NULL)
return Qnil; return Qnil;
return list3 (make_lispy_interval_node (node), return list3 (make_lispy_itree_node (node),
overlay_tree (tree, node->left), overlay_tree (tree, node->left),
overlay_tree (tree, node->right)); overlay_tree (tree, node->right));
} }

2
src/buffer.h
View file

@ -698,7 +698,7 @@ struct buffer
bool_bf long_line_optimizations_p : 1; bool_bf long_line_optimizations_p : 1;
/* The inveral tree containing this buffer's overlays. */ /* The inveral tree containing this buffer's overlays. */
struct interval_tree *overlays; struct itree_tree *overlays;
/* Changes in the buffer are recorded here for undo, and t means /* Changes in the buffer are recorded here for undo, and t means
don't record anything. This information belongs to the base don't record anything. This information belongs to the base

160
src/itree.c
View file

@ -135,7 +135,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
typedef uintptr_t nodeptr_and_flag; typedef uintptr_t nodeptr_and_flag;
static inline nodeptr_and_flag static inline nodeptr_and_flag
make_nav (struct interval_node *ptr, bool flag) make_nav (struct itree_node *ptr, bool flag)
{ {
uintptr_t v = (uintptr_t) ptr; uintptr_t v = (uintptr_t) ptr;
/* We assume alignment imposes the LSB is clear for us to use it. */ /* We assume alignment imposes the LSB is clear for us to use it. */
@ -143,10 +143,10 @@ make_nav (struct interval_node *ptr, bool flag)
return v | !!flag; return v | !!flag;
} }
static inline struct interval_node * static inline struct itree_node *
nav_nodeptr (nodeptr_and_flag nav) nav_nodeptr (nodeptr_and_flag nav)
{ {
return (struct interval_node *) (nav & (~(uintptr_t)1)); return (struct itree_node *) (nav & (~(uintptr_t)1));
} }
static inline bool static inline bool
@ -170,7 +170,7 @@ interval_stack_create (intmax_t initial_size)
{ {
struct interval_stack *stack = xmalloc (sizeof (struct interval_stack)); struct interval_stack *stack = xmalloc (sizeof (struct interval_stack));
stack->size = max (0, initial_size); stack->size = max (0, initial_size);
stack->nodes = xmalloc (stack->size * sizeof (struct interval_node*)); stack->nodes = xmalloc (stack->size * sizeof (struct itree_node*));
stack->length = 0; stack->length = 0;
return stack; return stack;
} }
@ -206,7 +206,7 @@ interval_stack_ensure_space (struct interval_stack *stack, intmax_t nelements)
static inline void static inline void
interval_stack_push_flagged (struct interval_stack *stack, interval_stack_push_flagged (struct interval_stack *stack,
struct interval_node *node, bool flag) struct itree_node *node, bool flag)
{ {
eassert (node && node != NULL); eassert (node && node != NULL);
@ -223,7 +223,7 @@ interval_stack_push_flagged (struct interval_stack *stack,
} }
static inline void static inline void
interval_stack_push (struct interval_stack *stack, struct interval_node *node) interval_stack_push (struct interval_stack *stack, struct itree_node *node)
{ {
interval_stack_push_flagged (stack, node, false); interval_stack_push_flagged (stack, node, false);
} }
@ -246,7 +246,7 @@ struct itree_iterator
ptrdiff_t begin; ptrdiff_t begin;
ptrdiff_t end; ptrdiff_t end;
uintmax_t otick; /* A copy of the tree's `otick`. */ uintmax_t otick; /* A copy of the tree's `otick`. */
enum interval_tree_order order; enum itree_order order;
bool running; bool running;
const char* file; const char* file;
int line; int line;
@ -260,7 +260,7 @@ struct itree_iterator
static struct itree_iterator *iter; static struct itree_iterator *iter;
static int static int
interval_tree_max_height (const struct interval_tree *tree) interval_tree_max_height (const struct itree_tree *tree)
{ {
return 2 * log (tree->size + 1) / log (2) + 0.5; return 2 * log (tree->size + 1) / log (2) + 0.5;
} }
@ -268,7 +268,7 @@ interval_tree_max_height (const struct interval_tree *tree)
/* Allocate a new iterator for TREE. */ /* Allocate a new iterator for TREE. */
static struct itree_iterator * static struct itree_iterator *
itree_iterator_create (struct interval_tree *tree) itree_iterator_create (struct itree_tree *tree)
{ {
struct itree_iterator *g = xmalloc (sizeof *g); struct itree_iterator *g = xmalloc (sizeof *g);
/* 19 here just avoids starting with a silly-small stack. /* 19 here just avoids starting with a silly-small stack.
@ -300,7 +300,7 @@ struct check_subtree_result
}; };
static struct check_subtree_result static struct check_subtree_result
check_subtree (struct interval_node *node, check_subtree (struct itree_node *node,
bool check_red_black_invariants, uintmax_t tree_otick, bool check_red_black_invariants, uintmax_t tree_otick,
ptrdiff_t offset, ptrdiff_t min_begin, ptrdiff_t offset, ptrdiff_t min_begin,
ptrdiff_t max_begin) ptrdiff_t max_begin)
@ -369,7 +369,7 @@ check_subtree (struct interval_node *node,
entire tree and validates all invariants. entire tree and validates all invariants.
*/ */
static bool static bool
check_tree (struct interval_tree *tree, check_tree (struct itree_tree *tree,
bool check_red_black_invariants) bool check_red_black_invariants)
{ {
eassert (tree != NULL); eassert (tree != NULL);
@ -380,7 +380,7 @@ check_tree (struct interval_tree *tree,
eassert (tree->root->parent == NULL); eassert (tree->root->parent == NULL);
eassert (!check_red_black_invariants || !tree->root->red); eassert (!check_red_black_invariants || !tree->root->red);
struct interval_node *node = tree->root; struct itree_node *node = tree->root;
struct check_subtree_result result struct check_subtree_result result
= check_subtree (node, check_red_black_invariants, tree->otick, = check_subtree (node, check_red_black_invariants, tree->otick,
node->offset, PTRDIFF_MIN, node->offset, PTRDIFF_MIN,
@ -396,19 +396,19 @@ check_tree (struct interval_tree *tree,
* +=======================================================================+ */ * +=======================================================================+ */
static bool static bool
null_safe_is_red (struct interval_node *node) null_safe_is_red (struct itree_node *node)
{ {
return node != NULL && node->red; return node != NULL && node->red;
} }
static bool static bool
null_safe_is_black (struct interval_node *node) null_safe_is_black (struct itree_node *node)
{ {
return node == NULL || !node->red; /* NULL nodes are black */ return node == NULL || !node->red; /* NULL nodes are black */
} }
static inline ptrdiff_t static inline ptrdiff_t
itree_newlimit (struct interval_node *node) itree_newlimit (struct itree_node *node)
{ {
eassert (node != NULL); eassert (node != NULL);
return max (node->end, return max (node->end,
@ -423,7 +423,7 @@ itree_newlimit (struct interval_node *node)
/* Update NODE's limit attribute according to its children. */ /* Update NODE's limit attribute according to its children. */
static void static void
interval_tree_update_limit (struct interval_node *node) interval_tree_update_limit (struct itree_node *node)
{ {
if (node == NULL) if (node == NULL)
return; return;
@ -438,7 +438,7 @@ interval_tree_update_limit (struct interval_node *node)
*/ */
static void static void
interval_tree_inherit_offset (uintmax_t otick, struct interval_node *node) interval_tree_inherit_offset (uintmax_t otick, struct itree_node *node)
{ {
eassert (node->parent == NULL || node->parent->otick >= node->otick); eassert (node->parent == NULL || node->parent->otick >= node->otick);
if (node->otick == otick) if (node->otick == otick)
@ -475,7 +475,7 @@ interval_tree_inherit_offset (uintmax_t otick, struct interval_node *node)
stable, i.e. new_limit = old_limit. */ stable, i.e. new_limit = old_limit. */
static void static void
interval_tree_propagate_limit (struct interval_node *node) interval_tree_propagate_limit (struct itree_node *node)
{ {
if (node == NULL) if (node == NULL)
return; return;
@ -491,8 +491,8 @@ interval_tree_propagate_limit (struct interval_node *node)
} }
} }
static struct interval_node* static struct itree_node*
interval_tree_validate (struct interval_tree *tree, struct interval_node *node) interval_tree_validate (struct itree_tree *tree, struct itree_node *node)
{ {
if (tree->otick == node->otick || node == NULL) if (tree->otick == node->otick || node == NULL)
@ -511,7 +511,7 @@ interval_tree_validate (struct interval_tree *tree, struct interval_node *node)
/* Initialize an allocated node. */ /* Initialize an allocated node. */
void void
interval_node_init (struct interval_node *node, interval_node_init (struct itree_node *node,
bool front_advance, bool rear_advance, bool front_advance, bool rear_advance,
Lisp_Object data) Lisp_Object data)
{ {
@ -528,8 +528,8 @@ interval_node_init (struct interval_node *node,
/* Return NODE's begin value, computing it if necessary. */ /* Return NODE's begin value, computing it if necessary. */
ptrdiff_t ptrdiff_t
interval_node_begin (struct interval_tree *tree, interval_node_begin (struct itree_tree *tree,
struct interval_node *node) struct itree_node *node)
{ {
interval_tree_validate (tree, node); interval_tree_validate (tree, node);
return node->begin; return node->begin;
@ -538,8 +538,8 @@ interval_node_begin (struct interval_tree *tree,
/* Return NODE's end value, computing it if necessary. */ /* Return NODE's end value, computing it if necessary. */
ptrdiff_t ptrdiff_t
interval_node_end (struct interval_tree *tree, interval_node_end (struct itree_tree *tree,
struct interval_node *node) struct itree_node *node)
{ {
interval_tree_validate (tree, node); interval_tree_validate (tree, node);
return node->end; return node->end;
@ -547,7 +547,7 @@ interval_node_end (struct interval_tree *tree,
/* Allocate an interval_tree. Free with interval_tree_destroy. */ /* Allocate an interval_tree. Free with interval_tree_destroy. */
struct interval_tree* struct itree_tree*
interval_tree_create (void) interval_tree_create (void)
{ {
/* FIXME? Maybe avoid the initialization of itree_null in the same /* FIXME? Maybe avoid the initialization of itree_null in the same
@ -555,7 +555,7 @@ interval_tree_create (void)
important though. */ important though. */
itree_init (); itree_init ();
struct interval_tree *tree = xmalloc (sizeof (*tree)); struct itree_tree *tree = xmalloc (sizeof (*tree));
interval_tree_clear (tree); interval_tree_clear (tree);
return tree; return tree;
} }
@ -563,7 +563,7 @@ interval_tree_create (void)
/* Reset the tree TREE to its empty state. */ /* Reset the tree TREE to its empty state. */
void void
interval_tree_clear (struct interval_tree *tree) interval_tree_clear (struct itree_tree *tree)
{ {
tree->root = NULL; tree->root = NULL;
tree->otick = 1; tree->otick = 1;
@ -583,7 +583,7 @@ interval_tree_init (struct interval_tree *tree)
/* Release a tree, freeing its allocated memory. */ /* Release a tree, freeing its allocated memory. */
void void
interval_tree_destroy (struct interval_tree *tree) interval_tree_destroy (struct itree_tree *tree)
{ {
eassert (tree->root == NULL); eassert (tree->root == NULL);
/* if (tree->iter) /* if (tree->iter)
@ -594,7 +594,7 @@ interval_tree_destroy (struct interval_tree *tree)
/* Return the number of nodes in TREE. */ /* Return the number of nodes in TREE. */
intmax_t intmax_t
interval_tree_size (struct interval_tree *tree) interval_tree_size (struct itree_tree *tree)
{ {
return tree->size; return tree->size;
} }
@ -602,12 +602,12 @@ interval_tree_size (struct interval_tree *tree)
/* Perform the familiar left-rotation on node NODE. */ /* Perform the familiar left-rotation on node NODE. */
static void static void
interval_tree_rotate_left (struct interval_tree *tree, interval_tree_rotate_left (struct itree_tree *tree,
struct interval_node *node) struct itree_node *node)
{ {
eassert (node->right != NULL); eassert (node->right != NULL);
struct interval_node *right = node->right; struct itree_node *right = node->right;
interval_tree_inherit_offset (tree->otick, node); interval_tree_inherit_offset (tree->otick, node);
interval_tree_inherit_offset (tree->otick, right); interval_tree_inherit_offset (tree->otick, right);
@ -645,12 +645,12 @@ interval_tree_rotate_left (struct interval_tree *tree,
/* Perform the familiar right-rotation on node NODE. */ /* Perform the familiar right-rotation on node NODE. */
static void static void
interval_tree_rotate_right (struct interval_tree *tree, interval_tree_rotate_right (struct itree_tree *tree,
struct interval_node *node) struct itree_node *node)
{ {
eassert (tree && node && node->left != NULL); eassert (tree && node && node->left != NULL);
struct interval_node *left = node->left; struct itree_node *left = node->left;
interval_tree_inherit_offset (tree->otick, node); interval_tree_inherit_offset (tree->otick, node);
interval_tree_inherit_offset (tree->otick, left); interval_tree_inherit_offset (tree->otick, left);
@ -684,8 +684,8 @@ interval_tree_rotate_right (struct interval_tree *tree,
Rebalance the parents as needed to re-establish the RB invariants. */ Rebalance the parents as needed to re-establish the RB invariants. */
static void static void
interval_tree_insert_fix (struct interval_tree *tree, interval_tree_insert_fix (struct itree_tree *tree,
struct interval_node *node) struct itree_node *node)
{ {
eassert (tree->root->red == false); eassert (tree->root->red == false);
@ -699,7 +699,7 @@ interval_tree_insert_fix (struct interval_tree *tree,
{ {
/* We're on the left side of our grandparent, and OTHER is /* We're on the left side of our grandparent, and OTHER is
our "uncle". */ our "uncle". */
struct interval_node *uncle = node->parent->parent->right; struct itree_node *uncle = node->parent->parent->right;
if (null_safe_is_red (uncle)) /* case 1.a */ if (null_safe_is_red (uncle)) /* case 1.a */
{ {
@ -729,7 +729,7 @@ interval_tree_insert_fix (struct interval_tree *tree,
else else
{ {
/* This is the symmetrical case of above. */ /* This is the symmetrical case of above. */
struct interval_node *uncle = node->parent->parent->left; struct itree_node *uncle = node->parent->parent->left;
if (null_safe_is_red (uncle)) /* case 1.b */ if (null_safe_is_red (uncle)) /* case 1.b */
{ {
@ -763,7 +763,7 @@ interval_tree_insert_fix (struct interval_tree *tree,
Note, that inserting a node twice results in undefined behaviour. */ Note, that inserting a node twice results in undefined behaviour. */
static void static void
interval_tree_insert (struct interval_tree *tree, struct interval_node *node) interval_tree_insert (struct itree_tree *tree, struct itree_node *node)
{ {
eassert (node->begin <= node->end && node != NULL); eassert (node->begin <= node->end && node != NULL);
/* FIXME: The assertion below fails because `delete_all_overlays` /* FIXME: The assertion below fails because `delete_all_overlays`
@ -772,8 +772,8 @@ interval_tree_insert (struct interval_tree *tree, struct interval_node *node)
&& node->parent == NULL) */; && node->parent == NULL) */;
eassert (check_tree (tree, true)); /* FIXME: Too expensive. */ eassert (check_tree (tree, true)); /* FIXME: Too expensive. */
struct interval_node *parent = NULL; struct itree_node *parent = NULL;
struct interval_node *child = tree->root; struct itree_node *child = tree->root;
uintmax_t otick = tree->otick; uintmax_t otick = tree->otick;
/* It's the responsability of the caller to set `otick` on the node, /* It's the responsability of the caller to set `otick` on the node,
to "confirm" that the begin/end fields are up to date. */ to "confirm" that the begin/end fields are up to date. */
@ -821,7 +821,7 @@ interval_tree_insert (struct interval_tree *tree, struct interval_node *node)
} }
void void
itree_insert_node (struct interval_tree *tree, struct interval_node *node, itree_insert_node (struct itree_tree *tree, struct itree_node *node,
ptrdiff_t begin, ptrdiff_t end) ptrdiff_t begin, ptrdiff_t end)
{ {
node->begin = begin; node->begin = begin;
@ -833,8 +833,8 @@ itree_insert_node (struct interval_tree *tree, struct interval_node *node,
/* Safely modify a node's interval. */ /* Safely modify a node's interval. */
void void
interval_node_set_region (struct interval_tree *tree, interval_node_set_region (struct itree_tree *tree,
struct interval_node *node, struct itree_node *node,
ptrdiff_t begin, ptrdiff_t end) ptrdiff_t begin, ptrdiff_t end)
{ {
interval_tree_validate (tree, node); interval_tree_validate (tree, node);
@ -856,10 +856,10 @@ interval_node_set_region (struct interval_tree *tree,
/* Return true, if NODE is a member of TREE. */ /* Return true, if NODE is a member of TREE. */
static bool static bool
interval_tree_contains (struct interval_tree *tree, struct interval_node *node) interval_tree_contains (struct itree_tree *tree, struct itree_node *node)
{ {
eassert (node); eassert (node);
struct interval_node *other; struct itree_node *other;
ITREE_FOREACH (other, tree, node->begin, PTRDIFF_MAX, ASCENDING) ITREE_FOREACH (other, tree, node->begin, PTRDIFF_MAX, ASCENDING)
if (other == node) if (other == node)
{ {
@ -871,7 +871,7 @@ interval_tree_contains (struct interval_tree *tree, struct interval_node *node)
} }
static bool static bool
itree_limit_is_stable (struct interval_node *node) itree_limit_is_stable (struct itree_node *node)
{ {
if (node == NULL) if (node == NULL)
return true; return true;
@ -879,8 +879,8 @@ itree_limit_is_stable (struct interval_node *node)
return (newlimit == node->limit); return (newlimit == node->limit);
} }
static struct interval_node* static struct itree_node*
interval_tree_subtree_min (uintmax_t otick, struct interval_node *node) interval_tree_subtree_min (uintmax_t otick, struct itree_node *node)
{ {
if (node == NULL) if (node == NULL)
return node; return node;
@ -895,9 +895,9 @@ interval_tree_subtree_min (uintmax_t otick, struct interval_node *node)
so re-balance the parents to re-establish the RB invariants. */ so re-balance the parents to re-establish the RB invariants. */
static void static void
interval_tree_remove_fix (struct interval_tree *tree, interval_tree_remove_fix (struct itree_tree *tree,
struct interval_node *node, struct itree_node *node,
struct interval_node *parent) struct itree_node *parent)
{ {
if (parent == NULL) if (parent == NULL)
eassert (node == tree->root); eassert (node == tree->root);
@ -910,7 +910,7 @@ interval_tree_remove_fix (struct interval_tree *tree,
if (node == parent->left) if (node == parent->left)
{ {
struct interval_node *other = parent->right; struct itree_node *other = parent->right;
if (null_safe_is_red (other)) /* case 1.a */ if (null_safe_is_red (other)) /* case 1.a */
{ {
@ -947,7 +947,7 @@ interval_tree_remove_fix (struct interval_tree *tree,
} }
else else
{ {
struct interval_node *other = parent->left; struct itree_node *other = parent->left;
if (null_safe_is_red (other)) /* 1.b */ if (null_safe_is_red (other)) /* 1.b */
{ {
@ -991,7 +991,7 @@ interval_tree_remove_fix (struct interval_tree *tree,
/* Return accumulated offsets of NODE's parents. */ /* Return accumulated offsets of NODE's parents. */
static ptrdiff_t static ptrdiff_t
itree_total_offset (struct interval_node *node) itree_total_offset (struct itree_node *node)
{ {
eassert (node != NULL); eassert (node != NULL);
ptrdiff_t offset = 0; ptrdiff_t offset = 0;
@ -1011,9 +1011,9 @@ itree_total_offset (struct interval_node *node)
unchanged. Caller is responsible for recalculation of `limit`. unchanged. Caller is responsible for recalculation of `limit`.
Requires both nodes to be using the same effective `offset`. */ Requires both nodes to be using the same effective `offset`. */
static void static void
interval_tree_replace_child (struct interval_tree *tree, interval_tree_replace_child (struct itree_tree *tree,
struct interval_node *source, struct itree_node *source,
struct interval_node *dest) struct itree_node *dest)
{ {
eassert (tree && dest != NULL); eassert (tree && dest != NULL);
eassert (source == NULL eassert (source == NULL
@ -1037,9 +1037,9 @@ interval_tree_replace_child (struct interval_tree *tree,
recalculation of `limit`. Requires both nodes to be using the same recalculation of `limit`. Requires both nodes to be using the same
effective `offset`. */ effective `offset`. */
static void static void
interval_tree_transplant (struct interval_tree *tree, interval_tree_transplant (struct itree_tree *tree,
struct interval_node *source, struct itree_node *source,
struct interval_node *dest) struct itree_node *dest)
{ {
interval_tree_replace_child (tree, source, dest); interval_tree_replace_child (tree, source, dest);
source->left = dest->left; source->left = dest->left;
@ -1053,8 +1053,8 @@ interval_tree_transplant (struct interval_tree *tree,
/* Remove NODE from TREE and return it. NODE must exist in TREE. */ /* Remove NODE from TREE and return it. NODE must exist in TREE. */
struct interval_node* struct itree_node*
interval_tree_remove (struct interval_tree *tree, struct interval_node *node) interval_tree_remove (struct itree_tree *tree, struct itree_node *node)
{ {
eassert (interval_tree_contains (tree, node)); eassert (interval_tree_contains (tree, node));
eassert (check_tree (tree, true)); /* FIXME: Too expensive. */ eassert (check_tree (tree, true)); /* FIXME: Too expensive. */
@ -1063,7 +1063,7 @@ interval_tree_remove (struct interval_tree *tree, struct interval_node *node)
`node` has at most one child this is `node` itself. Otherwise, `node` has at most one child this is `node` itself. Otherwise,
it is the in order successor of `node`. */ it is the in order successor of `node`. */
interval_tree_inherit_offset (tree->otick, node); interval_tree_inherit_offset (tree->otick, node);
struct interval_node *splice struct itree_node *splice
= (node->left == NULL || node->right == NULL) = (node->left == NULL || node->right == NULL)
? node ? node
: interval_tree_subtree_min (tree->otick, node->right); : interval_tree_subtree_min (tree->otick, node->right);
@ -1072,12 +1072,12 @@ interval_tree_remove (struct interval_tree *tree, struct interval_node *node)
`subtree` will not be modified other than changing its parent to `subtree` will not be modified other than changing its parent to
`splice`. */ `splice`. */
eassert (splice->left == NULL || splice->right == NULL); eassert (splice->left == NULL || splice->right == NULL);
struct interval_node *subtree struct itree_node *subtree
= (splice->left != NULL) ? splice->left : splice->right; = (splice->left != NULL) ? splice->left : splice->right;
/* Save a pointer to the parent of where `subtree` will eventually /* Save a pointer to the parent of where `subtree` will eventually
be in `subtree_parent`. */ be in `subtree_parent`. */
struct interval_node *subtree_parent struct itree_node *subtree_parent
= (splice->parent != node) ? splice->parent : splice; = (splice->parent != node) ? splice->parent : splice;
/* If `splice` is black removing it may violate Red-Black /* If `splice` is black removing it may violate Red-Black
@ -1135,8 +1135,8 @@ itree_iterator_busy_p (void)
given ORDER. Only one iterator per tree can be running at any time. */ given ORDER. Only one iterator per tree can be running at any time. */
struct itree_iterator * struct itree_iterator *
itree_iterator_start (struct interval_tree *tree, ptrdiff_t begin, itree_iterator_start (struct itree_tree *tree, ptrdiff_t begin,
ptrdiff_t end, enum interval_tree_order order, ptrdiff_t end, enum itree_order order,
const char *file, int line) const char *file, int line)
{ {
/* struct itree_iterator *iter = tree->iter; */ /* struct itree_iterator *iter = tree->iter; */
@ -1181,7 +1181,7 @@ itree_iterator_finish (struct itree_iterator *iter)
front_advance setting. */ front_advance setting. */
void void
interval_tree_insert_gap (struct interval_tree *tree, interval_tree_insert_gap (struct itree_tree *tree,
ptrdiff_t pos, ptrdiff_t length) ptrdiff_t pos, ptrdiff_t length)
{ {
if (length <= 0 || tree->root == NULL) if (length <= 0 || tree->root == NULL)
@ -1193,7 +1193,7 @@ interval_tree_insert_gap (struct interval_tree *tree,
/* Nodes with front_advance starting at pos may mess up the tree /* Nodes with front_advance starting at pos may mess up the tree
order, so we need to remove them first. */ order, so we need to remove them first. */
struct interval_stack *saved = interval_stack_create (0); struct interval_stack *saved = interval_stack_create (0);
struct interval_node *node = NULL; struct itree_node *node = NULL;
ITREE_FOREACH (node, tree, pos, pos + 1, PRE_ORDER) ITREE_FOREACH (node, tree, pos, pos + 1, PRE_ORDER)
{ {
if (node->begin == pos && node->front_advance if (node->begin == pos && node->front_advance
@ -1265,7 +1265,7 @@ interval_tree_insert_gap (struct interval_tree *tree,
intersecting it. */ intersecting it. */
void void
interval_tree_delete_gap (struct interval_tree *tree, interval_tree_delete_gap (struct itree_tree *tree,
ptrdiff_t pos, ptrdiff_t length) ptrdiff_t pos, ptrdiff_t length)
{ {
if (length <= 0 || tree->root == NULL) if (length <= 0 || tree->root == NULL)
@ -1277,7 +1277,7 @@ interval_tree_delete_gap (struct interval_tree *tree,
might unintentionally bring shifted nodes back into our search space. */ might unintentionally bring shifted nodes back into our search space. */
const int size = interval_tree_max_height (tree) + 1; const int size = interval_tree_max_height (tree) + 1;
struct interval_stack *stack = interval_stack_create (size); struct interval_stack *stack = interval_stack_create (size);
struct interval_node *node; struct itree_node *node;
interval_stack_push (stack, tree->root); interval_stack_push (stack, tree->root);
nodeptr_and_flag nav; nodeptr_and_flag nav;
@ -1327,7 +1327,7 @@ interval_tree_delete_gap (struct interval_tree *tree,
a NODE2 strictly bigger than NODE1 should also be included). */ a NODE2 strictly bigger than NODE1 should also be included). */
static inline bool static inline bool
interval_node_intersects (const struct interval_node *node, interval_node_intersects (const struct itree_node *node,
ptrdiff_t begin, ptrdiff_t end) ptrdiff_t begin, ptrdiff_t end)
{ {
return (begin < node->end && node->begin < end) return (begin < node->end && node->begin < end)
@ -1337,13 +1337,13 @@ interval_node_intersects (const struct interval_node *node,
/* Return the next node of the iterator in the order given when it was /* Return the next node of the iterator in the order given when it was
started; or NULL if there are no more nodes. */ started; or NULL if there are no more nodes. */
struct interval_node * struct itree_node *
itree_iterator_next (struct itree_iterator *g) itree_iterator_next (struct itree_iterator *g)
{ {
eassert (g->running); eassert (g->running);
struct interval_node * const null = NULL; struct itree_node * const null = NULL;
struct interval_node *node; struct itree_node *node;
/* The `visited` flag stored in each node is used here (and only here): /* The `visited` flag stored in each node is used here (and only here):
We keep a "workstack" of nodes we need to consider. This stack We keep a "workstack" of nodes we need to consider. This stack
@ -1363,8 +1363,8 @@ itree_iterator_next (struct itree_iterator *g)
visited = nav_flag (nav), visited = nav_flag (nav),
node && !visited)) node && !visited))
{ {
struct interval_node * const left = node->left; struct itree_node * const left = node->left;
struct interval_node * const right = node->right; struct itree_node * const right = node->right;
interval_tree_inherit_offset (g->otick, node); interval_tree_inherit_offset (g->otick, node);
eassert (itree_limit_is_stable (node)); eassert (itree_limit_is_stable (node));

47
src/itree.h
View file

@ -36,15 +36,14 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
returns as a side-effect. See ITREE_FOREACH. returns as a side-effect. See ITREE_FOREACH.
*/ */
struct interval_node; struct itree_node
struct interval_node
{ {
/* The normal parent, left and right links found in binary trees. /* The normal parent, left and right links found in binary trees.
See also `red`, below, which completes the Red-Black tree See also `red`, below, which completes the Red-Black tree
representation. */ representation. */
struct interval_node *parent; struct itree_node *parent;
struct interval_node *left; struct itree_node *left;
struct interval_node *right; struct itree_node *right;
/* The following five fields comprise the interval abstraction. /* The following five fields comprise the interval abstraction.
@ -63,7 +62,7 @@ struct interval_node
OTICK determines whether BEGIN, END, LIMIT and OFFSET are OTICK determines whether BEGIN, END, LIMIT and OFFSET are
considered dirty. A node is clean when its OTICK is equal to the considered dirty. A node is clean when its OTICK is equal to the
OTICK of its tree (see struct interval_tree). Otherwise, it is OTICK of its tree (see struct itree_tree). Otherwise, it is
dirty. dirty.
In a clean node, BEGIN, END and LIMIT are correct buffer In a clean node, BEGIN, END and LIMIT are correct buffer
@ -95,44 +94,44 @@ struct interval_node
bool_bf front_advance : 1; /* Same as for marker and overlays. */ bool_bf front_advance : 1; /* Same as for marker and overlays. */
}; };
struct interval_tree struct itree_tree
{ {
struct interval_node *root; struct itree_node *root;
uintmax_t otick; /* offset tick, compared with node's otick. */ uintmax_t otick; /* offset tick, compared with node's otick. */
intmax_t size; /* Number of nodes in the tree. */ intmax_t size; /* Number of nodes in the tree. */
}; };
enum interval_tree_order { enum itree_order {
ITREE_ASCENDING, ITREE_ASCENDING,
ITREE_DESCENDING, ITREE_DESCENDING,
ITREE_PRE_ORDER, ITREE_PRE_ORDER,
}; };
void interval_node_init (struct interval_node *, bool, bool, Lisp_Object); void interval_node_init (struct itree_node *, bool, bool, Lisp_Object);
ptrdiff_t interval_node_begin (struct interval_tree *, struct interval_node *); ptrdiff_t interval_node_begin (struct itree_tree *, struct itree_node *);
ptrdiff_t interval_node_end (struct interval_tree *, struct interval_node *); ptrdiff_t interval_node_end (struct itree_tree *, struct itree_node *);
void interval_node_set_region (struct interval_tree *, struct interval_node *, ptrdiff_t, ptrdiff_t); void interval_node_set_region (struct itree_tree *, struct itree_node *, ptrdiff_t, ptrdiff_t);
struct interval_tree *interval_tree_create (void); struct itree_tree *interval_tree_create (void);
void interval_tree_destroy (struct interval_tree *); void interval_tree_destroy (struct itree_tree *);
intmax_t interval_tree_size (struct interval_tree *); intmax_t interval_tree_size (struct itree_tree *);
void interval_tree_clear (struct interval_tree *); void interval_tree_clear (struct itree_tree *);
void itree_insert_node (struct interval_tree *tree, struct interval_node *node, void itree_insert_node (struct itree_tree *tree, struct itree_node *node,
ptrdiff_t begin, ptrdiff_t end); ptrdiff_t begin, ptrdiff_t end);
struct interval_node *interval_tree_remove (struct interval_tree *, struct interval_node *); struct itree_node *interval_tree_remove (struct itree_tree *, struct itree_node *);
void interval_tree_insert_gap (struct interval_tree *, ptrdiff_t, ptrdiff_t); void interval_tree_insert_gap (struct itree_tree *, ptrdiff_t, ptrdiff_t);
void interval_tree_delete_gap (struct interval_tree *, ptrdiff_t, ptrdiff_t); void interval_tree_delete_gap (struct itree_tree *, ptrdiff_t, ptrdiff_t);
/* Iteration functions. Almost all code should use ITREE_FOREACH /* Iteration functions. Almost all code should use ITREE_FOREACH
instead. */ instead. */
bool itree_iterator_busy_p (void); bool itree_iterator_busy_p (void);
struct itree_iterator * struct itree_iterator *
itree_iterator_start (struct interval_tree *tree, ptrdiff_t begin, itree_iterator_start (struct itree_tree *tree, ptrdiff_t begin,
ptrdiff_t end, enum interval_tree_order order, ptrdiff_t end, enum itree_order order,
const char *file, int line); const char *file, int line);
void itree_iterator_narrow (struct itree_iterator *, ptrdiff_t, void itree_iterator_narrow (struct itree_iterator *, ptrdiff_t,
ptrdiff_t); ptrdiff_t);
void itree_iterator_finish (struct itree_iterator *); void itree_iterator_finish (struct itree_iterator *);
struct interval_node *itree_iterator_next (struct itree_iterator *); struct itree_node *itree_iterator_next (struct itree_iterator *);
/* Iterate over the intervals between BEG and END in the tree T. /* Iterate over the intervals between BEG and END in the tree T.
N will hold successive nodes. ORDER can be one of : `ASCENDING`, N will hold successive nodes. ORDER can be one of : `ASCENDING`,

2
src/lisp.h
View file

@ -2604,7 +2604,7 @@ struct Lisp_Overlay
union vectorlike_header header; union vectorlike_header header;
Lisp_Object plist; Lisp_Object plist;
struct buffer *buffer; /* eassert (live buffer || NULL). */ struct buffer *buffer; /* eassert (live buffer || NULL). */
struct interval_node *interval; struct itree_node *interval;
} GCALIGNED_STRUCT; } GCALIGNED_STRUCT;
struct Lisp_Misc_Ptr struct Lisp_Misc_Ptr

10
src/pdumper.c
View file

@ -2134,13 +2134,13 @@ dump_marker (struct dump_context *ctx, const struct Lisp_Marker *marker)
} }
static dump_off static dump_off
dump_interval_node (struct dump_context *ctx, struct interval_node *node, dump_interval_node (struct dump_context *ctx, struct itree_node *node,
dump_off parent_offset) dump_off parent_offset)
{ {
#if CHECK_STRUCTS && !defined (HASH_interval_node_5765524F7E) #if CHECK_STRUCTS && !defined (HASH_interval_node_5765524F7E)
# error "interval_node changed. See CHECK_STRUCTS comment in config.h." # error "interval_node changed. See CHECK_STRUCTS comment in config.h."
#endif #endif
struct interval_node out; struct itree_node out;
dump_object_start (ctx, &out, sizeof (out)); dump_object_start (ctx, &out, sizeof (out));
if (node->parent) if (node->parent)
dump_field_fixup_later (ctx, &out, node, &node->parent); dump_field_fixup_later (ctx, &out, node, &node->parent);
@ -2161,17 +2161,17 @@ dump_interval_node (struct dump_context *ctx, struct interval_node *node,
if (node->parent) if (node->parent)
dump_remember_fixup_ptr_raw dump_remember_fixup_ptr_raw
(ctx, (ctx,
offset + dump_offsetof (struct interval_node, parent), offset + dump_offsetof (struct itree_node, parent),
dump_interval_node (ctx, node->parent, offset)); dump_interval_node (ctx, node->parent, offset));
if (node->left) if (node->left)
dump_remember_fixup_ptr_raw dump_remember_fixup_ptr_raw
(ctx, (ctx,
offset + dump_offsetof (struct interval_node, left), offset + dump_offsetof (struct itree_node, left),
dump_interval_node (ctx, node->left, offset)); dump_interval_node (ctx, node->left, offset));
if (node->right) if (node->right)
dump_remember_fixup_ptr_raw dump_remember_fixup_ptr_raw
(ctx, (ctx,
offset + dump_offsetof (struct interval_node, right), offset + dump_offsetof (struct itree_node, right),
dump_interval_node (ctx, node->right, offset)); dump_interval_node (ctx, node->right, offset));
return offset; return offset;
} }

2
src/textprop.c
View file

@ -634,7 +634,7 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
if (BUFFERP (object)) if (BUFFERP (object))
{ {
struct buffer *b = XBUFFER (object); struct buffer *b = XBUFFER (object);
struct interval_node *node; struct itree_node *node;
struct sortvec items[2]; struct sortvec items[2];
struct sortvec *result = NULL; struct sortvec *result = NULL;
Lisp_Object result_tem = Qnil; Lisp_Object result_tem = Qnil;

4
src/xdisp.c
View file

@ -6534,7 +6534,7 @@ load_overlay_strings (struct it *it, ptrdiff_t charpos)
struct overlay_entry entriesbuf[20]; struct overlay_entry entriesbuf[20];
ptrdiff_t size = ARRAYELTS (entriesbuf); ptrdiff_t size = ARRAYELTS (entriesbuf);
struct overlay_entry *entries = entriesbuf; struct overlay_entry *entries = entriesbuf;
struct interval_node *node; struct itree_node *node;
USE_SAFE_ALLOCA; USE_SAFE_ALLOCA;
@ -7001,7 +7001,7 @@ back_to_previous_line_start (struct it *it)
static bool static bool
strings_with_newlines (ptrdiff_t startpos, ptrdiff_t endpos, struct window *w) strings_with_newlines (ptrdiff_t startpos, ptrdiff_t endpos, struct window *w)
{ {
struct interval_node *node; struct itree_node *node;
/* Process overlays. */ /* Process overlays. */
ITREE_FOREACH (node, current_buffer->overlays, startpos, endpos, DESCENDING) ITREE_FOREACH (node, current_buffer->overlays, startpos, endpos, DESCENDING)
{ {