restored folder structure

interpreter/method_dispatcher/method_dispatcher.c

@@ -0,0 +1,158 @@
+#include <stdlib.h>
+#include "method_dispatcher.h"
+
+
+dispatch_tree_t dispatch_tree_t_new(void)
+{
+	dispatch_tree_t tree = malloc(sizeof(struct dispatch_tree_s));
+	tree->root = NULL;
+	return tree;
+}
+
+void dispatch_tree_t_del(dispatch_tree_t tree)
+{
+	dispatch_tree_node_t_del(tree->root);
+	free(tree);
+}
+
+dispatch_tree_node_t dispatch_tree_node_t_new(uint16_t word
+					, bci_core_method_t method)
+{
+	dispatch_tree_node_t node = malloc(sizeof(struct dispatch_tree_node_s));
+	node->higher = NULL;
+	node->lower = 0;
+	node->method = method;
+	node->word = word;
+	return node;
+}
+
+void dispatch_tree_node_t_del(dispatch_tree_node_t node)
+{
+	if(node->higher)
+	{
+		dispatch_tree_node_t_del(node->higher);
+	}
+	if(node->lower)
+	{
+		dispatch_tree_node_t_del(node->lower);
+	}
+	free(node);
+}
+
+char dispatch_tree_t_insert(dispatch_tree_t tree
+			, uint16_t word
+			, bci_core_method_t method)
+{
+	dispatch_tree_node_t new_node = dispatch_tree_node_t_new(word, method);
+	if(!new_node)
+	{
+		return 1;
+	}
+	// explicitly handle empty tree
+	if(!tree->root)
+	{
+		tree->root = new_node;
+		return 0;
+	}
+
+	// non-empty tree
+	dispatch_tree_node_t this_node = tree->root;
+	dispatch_tree_node_t parent_node = NULL;
+	// search for place
+	do
+	{
+		parent_node = this_node;
+		if(parent_node->word < word)
+		{
+			this_node = parent_node->higher;
+			continue;
+		}
+		if(parent_node->word > word)
+		{
+			this_node = parent_node->lower;
+			continue;
+		}
+		if(parent_node->word == word)
+		{
+			// we already have that key.
+			return 2;
+		}
+
+	} 
+	while(this_node);
+	if(parent_node->word < word)
+	{
+		parent_node->higher = new_node;
+	}
+	if(parent_node->word > word)
+	{
+		parent_node->lower = new_node;
+	}
+
+	return 0;
+
+}
+
+
+bci_core_method_t dispatch_tree_t_dispatch(dispatch_tree_t tree
+					, uint16_t word)
+{
+	dispatch_tree_node_t this_node = tree->root;
+	while(this_node)
+	{
+		if(this_node->word < word)
+		{
+			this_node = this_node->higher;
+			continue;
+		}
+		if(this_node->word > word)
+		{
+			this_node = this_node->lower;
+			continue;
+		}
+		if(this_node->word == word)
+		{
+			return this_node->method;
+		}
+	}
+	return NULL;
+}
+	
+dispatch_tree_autoinserter_t dispatch_tree_autoinserter_t_new(dispatch_tree_t tree)
+{
+	dispatch_tree_autoinserter_t autoinserter = malloc(
+			sizeof(struct dispatch_tree_autoinserter_s));
+	if(!autoinserter)
+	{
+		return NULL;
+	}
+	autoinserter->mayor = 2;
+	autoinserter->minor = 1;
+	autoinserter->tree = tree;
+	return autoinserter;
+}
+
+void dispatch_tree_autoinserter_t_del(dispatch_tree_autoinserter_t autoinserter)
+{
+	free(autoinserter);
+}
+
+
+uint16_t dispatch_tree_autoinserter_t_insert(
+			dispatch_tree_autoinserter_t autoinserter
+			, bci_core_method_t method)
+{
+	uint16_t opcode = 0b1111111111;
+	opcode *= autoinserter->minor;
+	opcode /= autoinserter->mayor;
+	opcode <<= 6;
+
+	dispatch_tree_t_insert(autoinserter->tree, opcode, method);
+
+	autoinserter->minor = (autoinserter->minor + 2) % autoinserter->mayor;
+	if(autoinserter->minor == 1)
+	{
+		autoinserter->mayor *= 2;
+	}
+	return opcode;
+}

interpreter/method_dispatcher/method_dispatcher.h

@@ -0,0 +1,87 @@
+#ifndef bci_method_dispatcher_h__
+#define bci_method_dispatcher_h__
+
+#include <inttypes.h>
+#include "../base.h"
+
+typedef struct dispatch_tree_node_s
+{
+	struct dispatch_tree_node_s * higher;
+	struct dispatch_tree_node_s * lower;
+	uint16_t word;
+	bci_core_method_t method;
+} * dispatch_tree_node_t;
+
+typedef struct dispatch_tree_s
+{
+	dispatch_tree_node_t root;
+} * dispatch_tree_t;
+
+dispatch_tree_t dispatch_tree_t_new(void);
+/*
+ * This deletes the tree and will invoke dispatch_tree_node_t_del on 
+ * tree->root (which will delete all the other nodes recursively). 
+ * If you want to keep nodes you have to explicityl remove the reference to
+ * them by setting them to NULL.
+ * */
+void dispatch_tree_t_del(dispatch_tree_t tree);
+
+
+dispatch_tree_node_t dispatch_tree_node_t_new(uint16_t word
+				, bci_core_method_t method);
+/*
+ * This deletes the node an will invoke dispatch_tree_node_t_del on
+ * node->higher and node->lower. If you want to keep those nodes 
+ * you have to explicitly clear the reference by setting them to NULL.
+ * */
+void dispatch_tree_node_t_del(dispatch_tree_node_t node);
+
+
+/*
+ * Insert a new key-value-pair into the tree.
+ *
+ * Return codes:
+ * 0: OK
+ * 1: out of memory
+ * 2: key already in tree
+ * */
+char dispatch_tree_t_insert(dispatch_tree_t tree
+			, uint16_t word
+			, bci_core_method_t method);
+
+
+bci_core_method_t dispatch_tree_t_dispatch(dispatch_tree_t tree
+					, uint16_t word);
+
+
+
+typedef struct dispatch_tree_autoinserter_s
+{
+	uint16_t mayor;
+	uint16_t minor;
+	dispatch_tree_t tree;
+} * dispatch_tree_autoinserter_t;
+
+dispatch_tree_autoinserter_t dispatch_tree_autoinserter_t_new(dispatch_tree_t tree);
+void dispatch_tree_autoinserter_t_del(dispatch_tree_autoinserter_t autoinserter);
+
+/*
+ * This function inserts a new method into the tree and automatically 
+ * chooses the optimal word to prevent degeneration.
+ *
+ * NOTE:
+ * When inserting mutliple methods this function acts deterministic,
+ * IF AND ONLY IF the order of the methods is not changed.
+ *
+ * The assembler will bring an analogous function that allows one 
+ * to determine the opcodes of the methods.
+ *
+ * NOTE:
+ * This algorithm will not work for more that 1023 registered opcodes.
+ * This limit is however considered acceptable.
+ *
+ * */
+uint16_t dispatch_tree_autoinserter_t_insert(
+			dispatch_tree_autoinserter_t autoinserter
+			, bci_core_method_t method);
+#endif

interpreter/method_dispatcher/test/Makefile

@@ -0,0 +1,14 @@
+CC=gcc
+
+all: test_method_dispatcher
+
+method_dispatcher: clean
+	$(CC) -g ../method_dispatcher.c test_method_dispatcher.c -o method_dispatcher
+
+test_method_dispatcher: method_dispatcher
+	valgrind ./method_dispatcher
+
+
+
+clean:
+	-rm method_dispatcher

interpreter/method_dispatcher/test/test_method_dispatcher.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include "../method_dispatcher.h"
+
+char m1(uint8_t small_arg, void * state);
+char m2(uint8_t small_arg, void * state);
+char m3(uint8_t small_arg, void * state);
+char m4(uint8_t small_arg, void * state);
+char m5(uint8_t small_arg, void * state);
+
+int main(void)
+{
+	printf("sizeof struct dispatch_tree_node_s: %zd\n", sizeof(struct dispatch_tree_node_s));
+	dispatch_tree_t tree = dispatch_tree_t_new();
+
+	dispatch_tree_t_insert(tree, 3 << 6, m3);
+	dispatch_tree_t_insert(tree, 2 << 6, m2);
+	dispatch_tree_t_insert(tree, 1 << 6, m1);
+	dispatch_tree_t_insert(tree, 4 << 6, m4);
+	dispatch_tree_t_insert(tree, 5 << 6, m5);
+
+	int i;
+	for(i = 1; i < 6; i++)
+	{
+		dispatch_tree_t_dispatch(tree, i << 6)(i, NULL);
+	}
+	dispatch_tree_t_del(tree);
+
+
+	bci_core_method_t methods[5] = {m1, m2, m3, m4, m5};
+	tree = dispatch_tree_t_new();
+	dispatch_tree_autoinserter_t inserter = dispatch_tree_autoinserter_t_new(tree);
+	for(i = 0; i < 5; i++)
+	{
+		printf("%u\n", dispatch_tree_autoinserter_t_insert(inserter, methods[i]));
+	}
+	dispatch_tree_autoinserter_t_del(inserter);
+	dispatch_tree_t_del(tree);
+
+	return 0;
+}
+
+
+
+char m1(uint8_t small_arg, void * state)
+{
+	printf("m1: %d\n", small_arg);
+}
+char m2(uint8_t small_arg, void * state)
+{
+	printf("m2: %d\n", small_arg);
+}
+char m3(uint8_t small_arg, void * state)
+{
+	printf("m3: %d\n", small_arg);
+}
+char m4(uint8_t small_arg, void * state)
+{
+	printf("m4: %d\n", small_arg);
+}
+char m5(uint8_t small_arg, void * state)
+{
+	printf("m5: %d\n", small_arg);
+}