start adding skiplist

libr/include/r_anal.h

@@ -15,6 +15,7 @@
 #include <r_io.h>
 #include <r_reg.h>
 #include <r_list.h>
+#include <r_skiplist.h>
 #include <r_util.h>
 #include <r_syscall.h>
 #include <r_flags.h>
@@ -312,7 +313,8 @@ typedef struct r_anal_type_function_t {
 	RAnalDiff *diff;
 	RList *locs; // list of local variables
 	//RList *locals; // list of local labels -> moved to anal->sdb_fcns
-	RList *bbs;
+	//RList *bbs;
+	RSkipList *bbs_sl;
 	RList *vars;
 #if FCN_OLD
 	RList *refs;

libr/include/r_skiplist.h

@@ -0,0 +1,34 @@
+// (c) 2016 Jeffrey Crowell
+// BSD 3 Clause License
+// radare2
+
+// Skiplists are a probabilistic datastructure than can be used as a k-v store
+// with average case O(lg n) lookup time, and worst case O(n).
+
+// https://en.wikipedia.org/wiki/Skip_list
+
+#ifndef R2_SKIP_LIST_H
+#define R2_SKIP_LIST_H
+
+#include <r_list.h>
+
+typedef struct r_skiplist_node_t {
+	void *data;	// pointer to the value
+	struct r_skiplist_node_t *forward[1]; // forward pointer
+} r_skiplist_node;
+
+typedef struct r_skiplist_t {
+	r_skiplist_node *head;	// list header
+	int list_level; // current level of the list.
+	RListFree freefn;
+	RListComparator compare;
+} r_skiplist;
+
+typedef r_skiplist RSkipList;
+
+R_API r_skiplist* r_skiplist_new(RListFree freefn, RListComparator comparefn);
+R_API r_skiplist_node* r_skiplist_insert(r_skiplist* list, void* data);
+R_API void r_skiplist_delete(r_skiplist* list, void* data);
+R_API r_skiplist_node* r_skiplist_find(r_skiplist* list, void* data);
+
+#endif // R2_SKIP_LIST_H

libr/include/r_util.h

@@ -10,6 +10,7 @@
 #include <r_list.h> // radare linked list
 #include <r_flist.h> // radare fixed pointer array iterators
 #include <list.h> // kernel linked list
+#include <r_skiplist.h> // skiplist
 #include <r_th.h>
 #include <dirent.h>
 #include <sys/time.h>

libr/util/r_skiplist.c

@@ -0,0 +1,131 @@
+// (c) 2016 Jeffrey Crowell
+// BSD 3 Clause License
+// radare2
+
+// Skiplists are a probabilistic datastructure than can be used as a k-v store
+// with average case O(lg n) lookup time, and worst case O(n).
+
+// https://en.wikipedia.org/wiki/Skip_list
+
+#include <r_skiplist.h>
+
+const int kSkipListDepth = 15; // max depth
+
+// Takes in a pointer to the function to free a list element, and a pointer to
+// a function that retruns 0 on equality between two elements, and -1 or 1
+// when unequal (for sorting).
+// Returns a new heap-allocated skiplist.
+R_API r_skiplist* r_skiplist_new(RListFree freefn, RListComparator comparefn) {
+	int i;
+	r_skiplist* list = calloc (1, sizeof (r_skiplist));
+	if ((list->head =
+				calloc (1,
+				sizeof (r_skiplist_node) +
+				kSkipListDepth * sizeof (r_skiplist_node*))) == NULL) {
+		eprintf ("can't init skiplist...");
+		return NULL;
+	}
+	for (i = 0; i <= kSkipListDepth; i++) {
+		list->head->forward[i] = list->head;
+	}
+	list->list_level = 0;
+	return list;
+}
+
+// Inserts an element to the skiplist, and returns a pointer to the element's
+// node.
+R_API r_skiplist_node* r_skiplist_insert(r_skiplist* list, void* data) {
+	int i, new_level;
+	r_skiplist_node* update [kSkipListDepth + 1];
+	r_skiplist_node* nnode;
+
+	// Find the spot for it.
+	nnode = list->head;
+	for (i = list->list_level; i >= 0; i--) {
+		while ((nnode->forward[i] != list->head) &&
+				(list->compare (nnode->forward[i]->data, data) < 1)) {
+			nnode = nnode->forward[i];
+		}
+		update[i] = nnode;
+	}
+	nnode = nnode->forward[0];
+	if (nnode != list->head && list->compare (nnode->data, data) == 0) {
+		return nnode;
+	}
+
+	// Determine the level "randomly".
+	// Skiplists are a probabilistic datastructure.
+	for (new_level = 0; rand() % 2 && new_level < kSkipListDepth; new_level++);
+
+	if (new_level < list->list_level) {
+		for (i = list->list_level + 1; i <= new_level; i++) {
+			update[i] = list->head;
+		}
+	}
+
+	// Okie, now make the node actually...
+	if ((nnode = calloc (1,
+					sizeof (r_skiplist_node) +
+					new_level * sizeof (r_skiplist_node*))) == NULL) {
+		eprintf ("can't calloc new node for skiplist");
+		return NULL;
+	}
+	nnode->data = data;
+
+	// update fwd links.
+	for (i = 0; i <= new_level; i++) {
+		nnode->forward[i] = update[i]->forward[i];
+	}
+	return nnode;
+}
+
+R_API void r_skiplist_delete(r_skiplist* list, void* data) {
+	int i;
+	r_skiplist_node *update[kSkipListDepth + 1], *node;
+
+	// Delete node with data as it's payload.
+	node = list->head;
+	for (i = list->list_level; i >=0; i--) {
+		while (node->forward[i] != list->head &&
+				list->compare (node->forward[i]->data, data) < 1) {
+			node = node->forward[i];
+		}
+		update[i] = node;
+	}
+	node = node->forward[0];
+	if (node == list->head || !list->compare(node->data, data)) {
+		return;
+	}
+
+	// Update the fwd pointers.
+	for (i = 0; i <= list->list_level; i++) {
+		if (update[i]->forward[i] != node) {
+			break;
+		} else {
+			update[i]->forward[i] = node->forward[i];
+		}
+	}
+	free (node);
+
+	// Update the level.
+	while ((list->list_level > 0) &&
+			(list->head->forward[list->list_level] == list->head)) {
+		list->list_level--;
+	}
+}
+
+R_API r_skiplist_node* r_skiplist_find(r_skiplist* list, void* data) {
+	int i;
+	r_skiplist_node* node = list->head;
+	for (i = list->list_level; i >= 0; i--) {
+		while (node->forward[i] != list->head &&
+				list->compare (node->forward[i]->data, data) < 0) {
+			node = node->forward[i];
+		}
+	}
+	node = node->forward[0];
+	if (node != list->head && list->compare (node->data, data)) {
+		return node;
+	}
+	return NULL;
+}