mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
9b29358511
Status lines for Emacs and Vim have been added to Python sources so they'll be easier to edit using Python's preferred coding style. Some DNS helper functions have been broken up into multiple files. It's nice to have one function per file whenever possible, since that way we don't need -ffunction-sections. Another reason it's good to have small source files, is because the build will be enforcing resource limits on compilation and testing soon.
128 lines
4.2 KiB
C
128 lines
4.2 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Python 3 │
|
|
│ https://docs.python.org/3/license.html │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "third_party/python/Modules/rotatingtree.h"
|
|
/* clang-format off */
|
|
|
|
#define KEY_LOWER_THAN(key1, key2) ((char*)(key1) < (char*)(key2))
|
|
|
|
/* The randombits() function below is a fast-and-dirty generator that
|
|
* is probably irregular enough for our purposes. Note that it's biased:
|
|
* I think that ones are slightly more probable than zeroes. It's not
|
|
* important here, though.
|
|
*/
|
|
|
|
static unsigned int random_value = 1;
|
|
static unsigned int random_stream = 0;
|
|
|
|
static int
|
|
randombits(int bits)
|
|
{
|
|
int result;
|
|
if (random_stream < (1U << bits)) {
|
|
random_value *= 1082527;
|
|
random_stream = random_value;
|
|
}
|
|
result = random_stream & ((1<<bits)-1);
|
|
random_stream >>= bits;
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Insert a new node into the tree.
|
|
(*root) is modified to point to the new root. */
|
|
void
|
|
RotatingTree_Add(rotating_node_t **root, rotating_node_t *node)
|
|
{
|
|
while (*root != NULL) {
|
|
if (KEY_LOWER_THAN(node->key, (*root)->key))
|
|
root = &((*root)->left);
|
|
else
|
|
root = &((*root)->right);
|
|
}
|
|
node->left = NULL;
|
|
node->right = NULL;
|
|
*root = node;
|
|
}
|
|
|
|
/* Locate the node with the given key. This is the most complicated
|
|
function because it occasionally rebalances the tree to move the
|
|
resulting node closer to the root. */
|
|
rotating_node_t *
|
|
RotatingTree_Get(rotating_node_t **root, void *key)
|
|
{
|
|
if (randombits(3) != 4) {
|
|
/* Fast path, no rebalancing */
|
|
rotating_node_t *node = *root;
|
|
while (node != NULL) {
|
|
if (node->key == key)
|
|
return node;
|
|
if (KEY_LOWER_THAN(key, node->key))
|
|
node = node->left;
|
|
else
|
|
node = node->right;
|
|
}
|
|
return NULL;
|
|
}
|
|
else {
|
|
rotating_node_t **pnode = root;
|
|
rotating_node_t *node = *pnode;
|
|
rotating_node_t *next;
|
|
int rotate;
|
|
if (node == NULL)
|
|
return NULL;
|
|
while (1) {
|
|
if (node->key == key)
|
|
return node;
|
|
rotate = !randombits(1);
|
|
if (KEY_LOWER_THAN(key, node->key)) {
|
|
next = node->left;
|
|
if (next == NULL)
|
|
return NULL;
|
|
if (rotate) {
|
|
node->left = next->right;
|
|
next->right = node;
|
|
*pnode = next;
|
|
}
|
|
else
|
|
pnode = &(node->left);
|
|
}
|
|
else {
|
|
next = node->right;
|
|
if (next == NULL)
|
|
return NULL;
|
|
if (rotate) {
|
|
node->right = next->left;
|
|
next->left = node;
|
|
*pnode = next;
|
|
}
|
|
else
|
|
pnode = &(node->right);
|
|
}
|
|
node = next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Enumerate all nodes in the tree. The callback enumfn() should return
|
|
zero to continue the enumeration, or non-zero to interrupt it.
|
|
A non-zero value is directly returned by RotatingTree_Enum(). */
|
|
int
|
|
RotatingTree_Enum(rotating_node_t *root, rotating_tree_enum_fn enumfn,
|
|
void *arg)
|
|
{
|
|
int result;
|
|
rotating_node_t *node;
|
|
while (root != NULL) {
|
|
result = RotatingTree_Enum(root->left, enumfn, arg);
|
|
if (result != 0) return result;
|
|
node = root->right;
|
|
result = enumfn(root, arg);
|
|
if (result != 0) return result;
|
|
root = node;
|
|
}
|
|
return 0;
|
|
}
|