mirror of
https://github.com/git/git
synced 2024-08-28 12:09:19 +00:00
![Elijah Newren](/assets/img/avatar_default.png)
We had several C files ignoring the rule to include one of the appropriate headers first; fix that. While at it, the rule in Documentation/CodingGuidelines about which header to include has also fallen out of sync, so update the wording to mention other allowed headers. Unfortunately, C files in reftable/ don't actually follow the previous or updated rule. If you follow the #include chain in its C files, reftable/system.h _tends_ to be first (i.e. record.c first includes record.h, which first includes basics.h, which first includees system.h), but not always (e.g. publicbasics.c includes another header first that does not include system.h). However, I'm going to punt on making actual changes to the C files in reftable/ since I do not want to risk bringing it out-of-sync with any version being used externally. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
137 lines
3.4 KiB
C
137 lines
3.4 KiB
C
/*
|
|
* crit-bit tree implementation, does no allocations internally
|
|
* For more information on crit-bit trees: https://cr.yp.to/critbit.html
|
|
* Based on Adam Langley's adaptation of Dan Bernstein's public domain code
|
|
* git clone https://github.com/agl/critbit.git
|
|
*/
|
|
#include "git-compat-util.h"
|
|
#include "cbtree.h"
|
|
|
|
static struct cb_node *cb_node_of(const void *p)
|
|
{
|
|
return (struct cb_node *)((uintptr_t)p - 1);
|
|
}
|
|
|
|
/* locate the best match, does not do a final comparision */
|
|
static struct cb_node *cb_internal_best_match(struct cb_node *p,
|
|
const uint8_t *k, size_t klen)
|
|
{
|
|
while (1 & (uintptr_t)p) {
|
|
struct cb_node *q = cb_node_of(p);
|
|
uint8_t c = q->byte < klen ? k[q->byte] : 0;
|
|
size_t direction = (1 + (q->otherbits | c)) >> 8;
|
|
|
|
p = q->child[direction];
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/* returns NULL if successful, existing cb_node if duplicate */
|
|
struct cb_node *cb_insert(struct cb_tree *t, struct cb_node *node, size_t klen)
|
|
{
|
|
size_t newbyte, newotherbits;
|
|
uint8_t c;
|
|
int newdirection;
|
|
struct cb_node **wherep, *p;
|
|
|
|
assert(!((uintptr_t)node & 1)); /* allocations must be aligned */
|
|
|
|
if (!t->root) { /* insert into empty tree */
|
|
t->root = node;
|
|
return NULL; /* success */
|
|
}
|
|
|
|
/* see if a node already exists */
|
|
p = cb_internal_best_match(t->root, node->k, klen);
|
|
|
|
/* find first differing byte */
|
|
for (newbyte = 0; newbyte < klen; newbyte++) {
|
|
if (p->k[newbyte] != node->k[newbyte])
|
|
goto different_byte_found;
|
|
}
|
|
return p; /* element exists, let user deal with it */
|
|
|
|
different_byte_found:
|
|
newotherbits = p->k[newbyte] ^ node->k[newbyte];
|
|
newotherbits |= newotherbits >> 1;
|
|
newotherbits |= newotherbits >> 2;
|
|
newotherbits |= newotherbits >> 4;
|
|
newotherbits = (newotherbits & ~(newotherbits >> 1)) ^ 255;
|
|
c = p->k[newbyte];
|
|
newdirection = (1 + (newotherbits | c)) >> 8;
|
|
|
|
node->byte = newbyte;
|
|
node->otherbits = newotherbits;
|
|
node->child[1 - newdirection] = node;
|
|
|
|
/* find a place to insert it */
|
|
wherep = &t->root;
|
|
for (;;) {
|
|
struct cb_node *q;
|
|
size_t direction;
|
|
|
|
p = *wherep;
|
|
if (!(1 & (uintptr_t)p))
|
|
break;
|
|
q = cb_node_of(p);
|
|
if (q->byte > newbyte)
|
|
break;
|
|
if (q->byte == newbyte && q->otherbits > newotherbits)
|
|
break;
|
|
c = q->byte < klen ? node->k[q->byte] : 0;
|
|
direction = (1 + (q->otherbits | c)) >> 8;
|
|
wherep = q->child + direction;
|
|
}
|
|
|
|
node->child[newdirection] = *wherep;
|
|
*wherep = (struct cb_node *)(1 + (uintptr_t)node);
|
|
|
|
return NULL; /* success */
|
|
}
|
|
|
|
struct cb_node *cb_lookup(struct cb_tree *t, const uint8_t *k, size_t klen)
|
|
{
|
|
struct cb_node *p = cb_internal_best_match(t->root, k, klen);
|
|
|
|
return p && !memcmp(p->k, k, klen) ? p : NULL;
|
|
}
|
|
|
|
static enum cb_next cb_descend(struct cb_node *p, cb_iter fn, void *arg)
|
|
{
|
|
if (1 & (uintptr_t)p) {
|
|
struct cb_node *q = cb_node_of(p);
|
|
enum cb_next n = cb_descend(q->child[0], fn, arg);
|
|
|
|
return n == CB_BREAK ? n : cb_descend(q->child[1], fn, arg);
|
|
} else {
|
|
return fn(p, arg);
|
|
}
|
|
}
|
|
|
|
void cb_each(struct cb_tree *t, const uint8_t *kpfx, size_t klen,
|
|
cb_iter fn, void *arg)
|
|
{
|
|
struct cb_node *p = t->root;
|
|
struct cb_node *top = p;
|
|
size_t i = 0;
|
|
|
|
if (!p) return; /* empty tree */
|
|
|
|
/* Walk tree, maintaining top pointer */
|
|
while (1 & (uintptr_t)p) {
|
|
struct cb_node *q = cb_node_of(p);
|
|
uint8_t c = q->byte < klen ? kpfx[q->byte] : 0;
|
|
size_t direction = (1 + (q->otherbits | c)) >> 8;
|
|
|
|
p = q->child[direction];
|
|
if (q->byte < klen)
|
|
top = p;
|
|
}
|
|
|
|
for (i = 0; i < klen; i++) {
|
|
if (p->k[i] != kpfx[i])
|
|
return; /* "best" match failed */
|
|
}
|
|
cb_descend(top, fn, arg);
|
|
}
|