1802 lines
56 KiB
C
1802 lines
56 KiB
C
/*********************************************
|
|
File: core_tries.c
|
|
Author: Ricardo Rocha
|
|
Comments: Tries core module for Yap Prolog
|
|
version: $ID$
|
|
*********************************************/
|
|
|
|
|
|
|
|
/* -------------------------- */
|
|
/* Includes */
|
|
/* -------------------------- */
|
|
|
|
#include <YapInterface.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "core_tries.h"
|
|
|
|
|
|
|
|
/* -------------------------- */
|
|
/* Local Procedures */
|
|
/* -------------------------- */
|
|
|
|
static TrNode put_entry(TrNode node, YAP_Term entry);
|
|
static TrNode check_entry(TrNode node, YAP_Term entry);
|
|
static YAP_Term get_entry(TrNode node, YAP_Term *stack_list, TrNode *cur_node);
|
|
static void remove_entry(TrNode node);
|
|
static void remove_child_nodes(TrNode node);
|
|
static TrNode copy_child_nodes(TrNode parent_dest, TrNode node_source);
|
|
static void traverse_and_add(TrNode parent_dest, TrNode parent_source);
|
|
static void traverse_and_join(TrNode parent_dest, TrNode parent_source);
|
|
static void traverse_and_intersect(TrNode parent_dest, TrNode parent_source);
|
|
static YAP_Int traverse_and_count_common_entries(TrNode parent1, TrNode parent2);
|
|
static YAP_Int traverse_and_count_entries(TrNode node);
|
|
static void traverse_and_get_usage(TrNode node, YAP_Int depth);
|
|
static void traverse_and_save(TrNode node, FILE *file, int float_block);
|
|
static void traverse_and_load(TrNode parent, FILE *file);
|
|
static void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int mode);
|
|
|
|
static YAP_Term trie_to_list(TrNode node);
|
|
static YAP_Term trie_to_list_node(TrNode node);
|
|
static YAP_Term trie_to_list_floats(TrNode node);
|
|
|
|
|
|
/* -------------------------- */
|
|
/* Local Variables */
|
|
/* -------------------------- */
|
|
|
|
static TrEngine CURRENT_TRIE_ENGINE;
|
|
|
|
static YAP_Int USAGE_ENTRIES, USAGE_NODES, USAGE_VIRTUAL_NODES;
|
|
static YAP_Int CURRENT_AUXILIARY_TERM_STACK_SIZE, CURRENT_TRIE_MODE, CURRENT_LOAD_VERSION, CURRENT_DEPTH, CURRENT_INDEX;
|
|
static YAP_Term *AUXILIARY_TERM_STACK;
|
|
YAP_Term *stack_args, *stack_args_base, *stack_vars, *stack_vars_base;
|
|
static YAP_Functor FunctorComma;
|
|
static void (*DATA_SAVE_FUNCTION)(TrNode, FILE *);
|
|
static void (*DATA_LOAD_FUNCTION)(TrNode, YAP_Int, FILE *);
|
|
static void (*DATA_PRINT_FUNCTION)(TrNode);
|
|
static void (*DATA_ADD_FUNCTION)(TrNode, TrNode);
|
|
static void (*DATA_COPY_FUNCTION)(TrNode, TrNode);
|
|
static void (*DATA_DESTRUCT_FUNCTION)(TrNode);
|
|
|
|
static YAP_Int TRIE_DISABLE_HASH_TABLE = 0;
|
|
|
|
|
|
/* -------------------------- */
|
|
/* Inline Procedures */
|
|
/* -------------------------- */
|
|
|
|
static
|
|
TrNode trie_node_check_insert(TrNode parent, YAP_Term t) {
|
|
TrNode child;
|
|
|
|
CURRENT_DEPTH++;
|
|
child = TrNode_child(parent);
|
|
if (child == NULL) {
|
|
new_trie_node(child, t, parent, NULL, NULL, NULL);
|
|
TrNode_child(parent) = child;
|
|
} else if (IS_HASH_NODE(child)) {
|
|
TrHash hash;
|
|
TrNode *bucket;
|
|
int count;
|
|
hash = (TrHash) child;
|
|
bucket = TrHash_bucket(hash, HASH_TERM(t, TrHash_seed(hash)));
|
|
child = *bucket;
|
|
count = 0;
|
|
while (child) {
|
|
if ((TrNode_entry(child) == t) || (((TrNode_entry(child) == PairEndTermTag) || (TrNode_entry(child) == PairEndEmptyTag)) && ((CURRENT_TRIE_MODE & TRIE_MODE_MINIMAL) == TRIE_MODE_MINIMAL)))
|
|
return child;
|
|
count++;
|
|
child = TrNode_next(child);
|
|
} while (child);
|
|
TrHash_num_nodes(hash)++;
|
|
new_trie_node(child, t, parent, NULL, *bucket, AS_TR_NODE_NEXT(bucket));
|
|
if (*bucket)
|
|
TrNode_previous(*bucket) = child;
|
|
*bucket = child;
|
|
if (count > MAX_NODES_PER_BUCKET && TrHash_num_nodes(hash) > TrHash_num_buckets(hash)) {
|
|
/* expand trie hash */
|
|
TrNode chain, next, *first_bucket, *new_bucket;
|
|
int seed;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
TrHash_num_buckets(hash) *= 2;
|
|
new_hash_buckets(hash, TrHash_num_buckets(hash));
|
|
seed = TrHash_num_buckets(hash) - 1;
|
|
do {
|
|
if (*--bucket) {
|
|
chain = *bucket;
|
|
do {
|
|
new_bucket = TrHash_bucket(hash, HASH_TERM(TrNode_entry(chain), seed));
|
|
next = TrNode_next(chain);
|
|
TrNode_next(chain) = *new_bucket;
|
|
TrNode_previous(chain) = AS_TR_NODE_NEXT(bucket);
|
|
if (*new_bucket)
|
|
TrNode_previous(*new_bucket) = chain;
|
|
*new_bucket = chain;
|
|
chain = next;
|
|
} while (chain);
|
|
}
|
|
} while (bucket != first_bucket);
|
|
free_hash_buckets(first_bucket, TrHash_num_buckets(hash) / 2);
|
|
}
|
|
} else {
|
|
int count = 0;
|
|
do {
|
|
if ((TrNode_entry(child) == t) || (((TrNode_entry(child) == PairEndTermTag) || (TrNode_entry(child) == PairEndEmptyTag)) && ((CURRENT_TRIE_MODE & TRIE_MODE_MINIMAL) == TRIE_MODE_MINIMAL)))
|
|
return child;
|
|
count++;
|
|
child = TrNode_next(child);
|
|
} while (child);
|
|
new_trie_node(child, t, parent, NULL, TrNode_child(parent), NULL);
|
|
TrNode_previous(TrNode_child(parent)) = child;
|
|
if ((++count > MAX_NODES_PER_TRIE_LEVEL) && (TRIE_DISABLE_HASH_TABLE == 0)) {
|
|
/* alloc a new trie hash */
|
|
TrHash hash;
|
|
TrNode chain, next, *bucket;
|
|
new_trie_hash(hash, count, BASE_HASH_BUCKETS);
|
|
chain = child;
|
|
do {
|
|
bucket = TrHash_bucket(hash, HASH_TERM(TrNode_entry(chain), BASE_HASH_BUCKETS - 1));
|
|
next = TrNode_next(chain);
|
|
TrNode_next(chain) = *bucket;
|
|
TrNode_previous(chain) = AS_TR_NODE_NEXT(bucket);
|
|
if (*bucket)
|
|
TrNode_previous(*bucket) = chain;
|
|
*bucket = chain;
|
|
chain = next;
|
|
} while (chain);
|
|
TrNode_child(parent) = (TrNode) hash;
|
|
} else
|
|
TrNode_child(parent) = child;
|
|
}
|
|
return child;
|
|
}
|
|
|
|
|
|
static
|
|
TrNode trie_node_insert(TrNode parent, YAP_Term t, TrHash hash) {
|
|
TrNode child;
|
|
|
|
CURRENT_DEPTH++;
|
|
if (hash) {
|
|
/* is trie hash */
|
|
TrNode *bucket;
|
|
TrHash_num_nodes(hash)++;
|
|
bucket = TrHash_bucket(hash, HASH_TERM(t, TrHash_seed(hash)));
|
|
new_trie_node(child, t, parent, NULL, *bucket, AS_TR_NODE_NEXT(bucket));
|
|
if (*bucket)
|
|
TrNode_previous(*bucket) = child;
|
|
*bucket = child;
|
|
} else {
|
|
new_trie_node(child, t, parent, NULL, TrNode_child(parent), NULL);
|
|
if (TrNode_child(parent))
|
|
TrNode_previous(TrNode_child(parent)) = child;
|
|
TrNode_child(parent) = child;
|
|
}
|
|
return child;
|
|
}
|
|
|
|
|
|
static
|
|
TrNode trie_node_check(TrNode parent, YAP_Term t) {
|
|
TrNode child;
|
|
|
|
child = TrNode_child(parent);
|
|
if (IS_HASH_NODE(child)) {
|
|
TrHash hash;
|
|
TrNode *bucket;
|
|
hash = (TrHash) child;
|
|
bucket = TrHash_bucket(hash, HASH_TERM(t, TrHash_seed(hash)));
|
|
child = *bucket;
|
|
if (!child)
|
|
return NULL;
|
|
}
|
|
do {
|
|
if (TrNode_entry(child) == t)
|
|
return child;
|
|
child = TrNode_next(child);
|
|
} while (child);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Term trie_to_list_create_simple(const char *atom_name, TrNode node) {
|
|
YAP_Functor f = YAP_MkFunctor(YAP_LookupAtom(atom_name), 1);
|
|
YAP_Term child = trie_to_list(TrNode_child(node));
|
|
|
|
return YAP_MkApplTerm(f, 1, &child);
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Term trie_to_list_create_simple_end(const char *atom_name, TrNode node) {
|
|
YAP_Atom atom = YAP_LookupAtom(atom_name);
|
|
|
|
if (IS_LEAF_TRIE_NODE(node)) {
|
|
return YAP_MkAtomTerm(atom);
|
|
} else {
|
|
YAP_Functor f = YAP_MkFunctor(atom, 1);
|
|
YAP_Term child = trie_to_list(TrNode_child(node));
|
|
return YAP_MkApplTerm(f, 1, &child);
|
|
}
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Term trie_to_list_create_two(const char *atom_name, TrNode node, YAP_Term operand) {
|
|
YAP_Atom atom = YAP_LookupAtom(atom_name);
|
|
|
|
if(IS_LEAF_TRIE_NODE(node)) {
|
|
YAP_Functor f = YAP_MkFunctor(atom, 1);
|
|
return YAP_MkApplTerm(f, 1, &operand);
|
|
} else {
|
|
YAP_Functor f = YAP_MkFunctor(atom, 2);
|
|
YAP_Term args[2] = {
|
|
operand, trie_to_list(TrNode_child(node))
|
|
};
|
|
return YAP_MkApplTerm(f, 2, args);
|
|
}
|
|
}
|
|
|
|
|
|
/* -------------------------- */
|
|
/* API */
|
|
/* -------------------------- */
|
|
|
|
TrEngine core_trie_init_module(void) {
|
|
static int init_once = 1;
|
|
TrEngine engine;
|
|
|
|
if (init_once) {
|
|
new_struct(AUXILIARY_TERM_STACK, YAP_Term, BASE_AUXILIARY_TERM_STACK_SIZE * sizeof(YAP_Term));
|
|
CURRENT_AUXILIARY_TERM_STACK_SIZE = BASE_AUXILIARY_TERM_STACK_SIZE;
|
|
CURRENT_TRIE_MODE = TRIE_MODE_STANDARD;
|
|
FunctorComma = YAP_MkFunctor(YAP_LookupAtom(","), 2);
|
|
init_once = 0;
|
|
}
|
|
new_trie_engine(engine);
|
|
return engine;
|
|
}
|
|
|
|
|
|
|
|
TrNode core_trie_open(TrEngine engine) {
|
|
TrNode node;
|
|
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
new_trie_node(node, 0, NULL, NULL, TrEngine_trie(engine), AS_TR_NODE_NEXT(&TrEngine_trie(engine)));
|
|
if (TrEngine_trie(engine))
|
|
TrNode_previous(TrEngine_trie(engine)) = node;
|
|
TrEngine_trie(engine) = node;
|
|
INCREMENT_TRIES(CURRENT_TRIE_ENGINE);
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_close(TrEngine engine, TrNode node, void (*destruct_function)(TrNode)) {
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
DATA_DESTRUCT_FUNCTION = destruct_function;
|
|
if (TrNode_child(node))
|
|
remove_child_nodes(TrNode_child(node));
|
|
if (TrNode_next(node)) {
|
|
TrNode_previous(TrNode_next(node)) = TrNode_previous(node);
|
|
TrNode_next(TrNode_previous(node)) = TrNode_next(node);
|
|
} else
|
|
TrNode_next(TrNode_previous(node)) = NULL;
|
|
free_trie_node(node);
|
|
DECREMENT_TRIES(CURRENT_TRIE_ENGINE);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_close_all(TrEngine engine, void (*destruct_function)(TrNode)) {
|
|
while (TrEngine_trie(engine))
|
|
core_trie_close(engine, TrEngine_trie(engine), destruct_function);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_set_mode(YAP_Int mode) {
|
|
CURRENT_TRIE_MODE = mode;
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
YAP_Int core_trie_get_mode(void) {
|
|
return CURRENT_TRIE_MODE;
|
|
}
|
|
|
|
|
|
|
|
TrNode core_trie_put_entry(TrEngine engine, TrNode node, YAP_Term entry, YAP_Int *depth) {
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
CURRENT_DEPTH = 0;
|
|
stack_args_base = stack_args = AUXILIARY_TERM_STACK;
|
|
stack_vars_base = stack_vars = AUXILIARY_TERM_STACK + CURRENT_AUXILIARY_TERM_STACK_SIZE - 1;
|
|
node = put_entry(node, entry);
|
|
if (!IS_LEAF_TRIE_NODE(node)) {
|
|
MARK_AS_LEAF_TRIE_NODE(node);
|
|
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
}
|
|
/* reset var terms */
|
|
while (STACK_NOT_EMPTY(stack_vars++, stack_vars_base)) {
|
|
(void) POP_DOWN(stack_vars);
|
|
*((YAP_Term *)*stack_vars) = *stack_vars;
|
|
}
|
|
if (depth)
|
|
*depth = CURRENT_DEPTH;
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
TrNode core_trie_check_entry(TrNode node, YAP_Term entry) {
|
|
if (!TrNode_child(node))
|
|
return NULL;
|
|
stack_args_base = stack_args = AUXILIARY_TERM_STACK;
|
|
stack_vars_base = stack_vars = AUXILIARY_TERM_STACK + CURRENT_AUXILIARY_TERM_STACK_SIZE - 1;
|
|
node = check_entry(node, entry);
|
|
/* reset var terms */
|
|
while (STACK_NOT_EMPTY(stack_vars++, stack_vars_base)) {
|
|
(void) POP_DOWN(stack_vars);
|
|
*((YAP_Term *)*stack_vars) = *stack_vars;
|
|
}
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
YAP_Term core_trie_get_entry(TrNode node) {
|
|
CURRENT_INDEX = -1;
|
|
stack_vars_base = stack_vars = AUXILIARY_TERM_STACK;
|
|
stack_args_base = stack_args = AUXILIARY_TERM_STACK + CURRENT_AUXILIARY_TERM_STACK_SIZE - 1;
|
|
return get_entry(node, stack_args, &node);
|
|
}
|
|
|
|
|
|
|
|
void core_trie_remove_entry(TrEngine engine, TrNode node, void (*destruct_function)(TrNode)) {
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
DATA_DESTRUCT_FUNCTION = destruct_function;
|
|
if (DATA_DESTRUCT_FUNCTION)
|
|
(*DATA_DESTRUCT_FUNCTION)(node);
|
|
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
remove_entry(node);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_remove_subtree(TrEngine engine, TrNode node, void (*destruct_function)(TrNode)) {
|
|
TrNode parent;
|
|
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
DATA_DESTRUCT_FUNCTION = destruct_function;
|
|
parent = TrNode_parent(node);
|
|
remove_child_nodes(TrNode_child(parent));
|
|
remove_entry(parent);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_add(TrNode node_dest, TrNode node_source, void (*add_function)(TrNode, TrNode)) {
|
|
DATA_ADD_FUNCTION = add_function;
|
|
if (TrNode_child(node_dest) && TrNode_child(node_source))
|
|
traverse_and_add(node_dest, node_source);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_join(TrEngine engine, TrNode node_dest, TrNode node_source, void (*add_function)(TrNode, TrNode), void (*copy_function)(TrNode, TrNode)) {
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
DATA_ADD_FUNCTION = add_function;
|
|
DATA_COPY_FUNCTION = copy_function;
|
|
if (TrNode_child(node_dest)) {
|
|
if (TrNode_child(node_source))
|
|
traverse_and_join(node_dest, node_source);
|
|
} else if (TrNode_child(node_source))
|
|
TrNode_child(node_dest) = copy_child_nodes(node_dest, TrNode_child(node_source));
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_intersect(TrEngine engine, TrNode node_dest, TrNode node_source, void (*add_function)(TrNode, TrNode), void (*destruct_function)(TrNode)) {
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
DATA_ADD_FUNCTION = add_function;
|
|
DATA_DESTRUCT_FUNCTION = destruct_function;
|
|
if (TrNode_child(node_dest)) {
|
|
if (TrNode_child(node_source))
|
|
traverse_and_intersect(node_dest, node_source);
|
|
else {
|
|
remove_child_nodes(TrNode_child(node_dest));
|
|
TrNode_child(node_dest) = NULL;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
YAP_Int core_trie_count_join(TrNode node1, TrNode node2) {
|
|
YAP_Int count = 0;
|
|
|
|
if (TrNode_child(node1)) {
|
|
count += traverse_and_count_entries(TrNode_child(node1));
|
|
if (TrNode_child(node2)) {
|
|
count += traverse_and_count_entries(TrNode_child(node2));
|
|
count -= traverse_and_count_common_entries(node1, node2);
|
|
}
|
|
} else if (TrNode_child(node2))
|
|
count += traverse_and_count_entries(TrNode_child(node2));
|
|
return count;
|
|
}
|
|
|
|
|
|
|
|
YAP_Int core_trie_count_intersect(TrNode node1, TrNode node2) {
|
|
YAP_Int count = 0;
|
|
|
|
if (TrNode_child(node1))
|
|
if (TrNode_child(node2))
|
|
count = traverse_and_count_common_entries(node1, node2);
|
|
return count;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_save(TrNode node, FILE *file, void (*save_function)(TrNode, FILE *)) {
|
|
CURRENT_INDEX = -1;
|
|
DATA_SAVE_FUNCTION = save_function;
|
|
if (TrNode_child(node)) {
|
|
fprintf(file, "BEGIN_TRIE_v2 ");
|
|
traverse_and_save(TrNode_child(node), file, 0);
|
|
fprintf(file, "END_TRIE_v2");
|
|
fflush(file);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
TrNode core_trie_load(TrEngine engine, FILE *file, void (*load_function)(TrNode, YAP_Int, FILE *)) {
|
|
TrNode node;
|
|
char version[15];
|
|
fpos_t curpos;
|
|
int n;
|
|
|
|
n = fscanf(file, "%14s", version);
|
|
if (fgetpos(file, &curpos))
|
|
return NULL;
|
|
|
|
if (!strcmp(version, "BEGIN_TRIE_v2")) {
|
|
fseek(file, -11, SEEK_END);
|
|
n = fscanf(file, "%s", version);
|
|
if (strcmp(version, "END_TRIE_v2")) {
|
|
fprintf(stderr, "******************************************\n");
|
|
fprintf(stderr, " Tries core module: trie file corrupted\n");
|
|
fprintf(stderr, "******************************************\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
if (fsetpos(file, &curpos))
|
|
return NULL;
|
|
CURRENT_LOAD_VERSION = 2;
|
|
} else if (!strcmp(version, "BEGIN_TRIE")) {
|
|
fseek(file, -8, SEEK_END);
|
|
n = fscanf(file, "%s", version);
|
|
if (strcmp(version, "END_TRIE")) {
|
|
fprintf(stderr, "******************************************\n");
|
|
fprintf(stderr, " Tries core module: trie file corrupted\n");
|
|
fprintf(stderr, "******************************************\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
if (fsetpos(file, &curpos))
|
|
return NULL;
|
|
CURRENT_LOAD_VERSION = 1;
|
|
} else {
|
|
fprintf(stderr, "****************************************\n");
|
|
fprintf(stderr, " Tries core module: invalid trie file\n");
|
|
fprintf(stderr, "****************************************\n");
|
|
fflush(stderr);
|
|
return NULL;
|
|
}
|
|
CURRENT_TRIE_ENGINE = engine;
|
|
CURRENT_INDEX = -1;
|
|
CURRENT_DEPTH = 0;
|
|
DATA_LOAD_FUNCTION = load_function;
|
|
node = core_trie_open(engine);
|
|
traverse_and_load(node, file);
|
|
if (n) n = 0; // just added to remove the warning of not used!
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_stats(TrEngine engine, YAP_Int *memory, YAP_Int *tries, YAP_Int *entries, YAP_Int *nodes) {
|
|
*memory = TrEngine_memory(engine);
|
|
*tries = TrEngine_tries(engine);
|
|
*entries = TrEngine_entries(engine);
|
|
*nodes = TrEngine_nodes(engine);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_max_stats(TrEngine engine, YAP_Int *memory, YAP_Int *tries, YAP_Int *entries, YAP_Int *nodes) {
|
|
*memory = TrEngine_memory_max(engine);
|
|
*tries = TrEngine_tries_max(engine);
|
|
*entries = TrEngine_entries_max(engine);
|
|
*nodes = TrEngine_nodes_max(engine);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_usage(TrNode node, YAP_Int *entries, YAP_Int *nodes, YAP_Int *virtual_nodes) {
|
|
USAGE_ENTRIES = 0;
|
|
USAGE_NODES = 0;
|
|
USAGE_VIRTUAL_NODES = 0;
|
|
if (TrNode_child(node))
|
|
traverse_and_get_usage(TrNode_child(node), 0);
|
|
*entries = USAGE_ENTRIES;
|
|
*nodes = USAGE_NODES;
|
|
*virtual_nodes = USAGE_VIRTUAL_NODES;
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_trie_print(TrNode node, void (*print_function)(TrNode)) {
|
|
DATA_PRINT_FUNCTION = print_function;
|
|
if (TrNode_child(node)) {
|
|
int arity[1000];
|
|
char str[10000];
|
|
arity[0] = 0;
|
|
traverse_and_print(TrNode_child(node), arity, str, 0, TRIE_PRINT_NORMAL);
|
|
} else
|
|
fprintf(stdout, "(empty)\n");
|
|
fflush(stdout);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
void core_disable_hash_table(void) {
|
|
TRIE_DISABLE_HASH_TABLE = 1;
|
|
}
|
|
|
|
|
|
|
|
void core_enable_hash_table(void) {
|
|
TRIE_DISABLE_HASH_TABLE = 0;
|
|
}
|
|
|
|
|
|
|
|
YAP_Term core_trie_to_list(TrNode node) {
|
|
TrNode root = TrNode_child(node);
|
|
|
|
if (root)
|
|
return trie_to_list(root);
|
|
else
|
|
return YAP_MkAtomTerm(YAP_LookupAtom("empty"));
|
|
}
|
|
|
|
|
|
/* -------------------------- */
|
|
/* Local Procedures */
|
|
/* -------------------------- */
|
|
|
|
static
|
|
TrNode put_entry(TrNode node, YAP_Term entry) {
|
|
YAP_Term t = YAP_Deref(entry);
|
|
if (YAP_IsVarTerm(t)) {
|
|
if (IsTrieVar(t, stack_vars, stack_vars_base)) {
|
|
node = trie_node_check_insert(node, MkTrieVar((stack_vars_base - 1 - (YAP_Term *)t) / 2));
|
|
} else {
|
|
node = trie_node_check_insert(node, MkTrieVar((stack_vars_base - stack_vars) / 2));
|
|
PUSH_UP(stack_vars, t, stack_args);
|
|
*((YAP_Term *)t) = (YAP_Term)stack_vars;
|
|
PUSH_UP(stack_vars, stack_vars, stack_args);
|
|
}
|
|
} else if (YAP_IsAtomTerm(t)) {
|
|
node = trie_node_check_insert(node, t);
|
|
} else if (YAP_IsIntTerm(t)) {
|
|
node = trie_node_check_insert(node, t);
|
|
} else if (YAP_IsFloatTerm(t)) {
|
|
volatile union {
|
|
double f;
|
|
YAP_Term p[SIZE_FLOAT_AS_TERM];
|
|
} tf; /* to avoid gcc warning */
|
|
tf.f = YAP_FloatOfTerm(t);
|
|
node = trie_node_check_insert(node, FloatInitTag);
|
|
node = trie_node_check_insert(node, tf.p[0]);
|
|
#ifdef TAG_LOW_BITS_32
|
|
node = trie_node_check_insert(node, tf.p[1]);
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
node = trie_node_check_insert(node, FloatEndTag);
|
|
} else if (YAP_IsPairTerm(t)) {
|
|
node = trie_node_check_insert(node, PairInitTag);
|
|
if ((CURRENT_TRIE_MODE & TRIE_MODE_REVERSE) == TRIE_MODE_STANDARD) {
|
|
do {
|
|
node = put_entry(node, YAP_HeadOfTerm(t));
|
|
t = YAP_Deref(YAP_TailOfTerm(t));
|
|
} while (YAP_IsPairTerm(t));
|
|
if (t == YAP_TermNil()) {
|
|
node = trie_node_check_insert(node, PairEndEmptyTag);
|
|
} else {
|
|
node = put_entry(node, t);
|
|
node = trie_node_check_insert(node, PairEndTermTag);
|
|
}
|
|
} else if (CURRENT_TRIE_MODE & TRIE_MODE_REVERSE) { /* TRIE_MODE_REVERSE */
|
|
YAP_Term *stack_list = stack_args;
|
|
do {
|
|
PUSH_DOWN(stack_args, YAP_HeadOfTerm(t), stack_vars);
|
|
t = YAP_Deref(YAP_TailOfTerm(t));
|
|
} while (YAP_IsPairTerm(t));
|
|
if (t == YAP_TermNil()) {
|
|
while (STACK_NOT_EMPTY(stack_args, stack_list))
|
|
node = put_entry(node, POP_UP(stack_args));
|
|
node = trie_node_check_insert(node, PairEndEmptyTag);
|
|
} else {
|
|
PUSH_DOWN(stack_args, t, stack_vars);
|
|
while (STACK_NOT_EMPTY(stack_args, stack_list))
|
|
node = put_entry(node, POP_UP(stack_args));
|
|
node = trie_node_check_insert(node, PairEndTermTag);
|
|
}
|
|
}
|
|
} else if (YAP_IsApplTerm(t)) {
|
|
YAP_Functor f = YAP_FunctorOfTerm(t);
|
|
if (f == FunctorComma) {
|
|
node = trie_node_check_insert(node, CommaInitTag);
|
|
do {
|
|
node = put_entry(node, YAP_ArgOfTerm(1, t));
|
|
t = YAP_Deref(YAP_ArgOfTerm(2, t));
|
|
} while (YAP_IsApplTerm(t) && YAP_FunctorOfTerm(t) == FunctorComma);
|
|
node = put_entry(node, t);
|
|
node = trie_node_check_insert(node, CommaEndTag);
|
|
} else {
|
|
int i;
|
|
node = trie_node_check_insert(node, ApplTag | ((YAP_Term) f));
|
|
for (i = 1; i <= YAP_ArityOfFunctor(f); i++)
|
|
node = put_entry(node, YAP_ArgOfTerm(i, t));
|
|
}
|
|
} else {
|
|
fprintf(stderr, "***************************************\n");
|
|
fprintf(stderr, " Tries core module: unknown type tag\n");
|
|
fprintf(stderr, "***************************************\n");
|
|
fflush(stderr);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
static
|
|
TrNode check_entry(TrNode node, YAP_Term entry) {
|
|
YAP_Term t = YAP_Deref(entry);
|
|
if (YAP_IsVarTerm(t)) {
|
|
if (IsTrieVar(t, stack_vars, stack_vars_base)) {
|
|
if (!(node = trie_node_check(node, MkTrieVar((stack_vars_base - 1 - (YAP_Term *)t) / 2))))
|
|
return NULL;
|
|
} else {
|
|
if (!(node = trie_node_check(node, MkTrieVar((stack_vars_base - stack_vars) / 2))))
|
|
return NULL;
|
|
PUSH_UP(stack_vars, t, stack_args);
|
|
*((YAP_Term *)t) = (YAP_Term)stack_vars;
|
|
PUSH_UP(stack_vars, stack_vars, stack_args);
|
|
}
|
|
} else if (YAP_IsAtomTerm(t)) {
|
|
if (!(node = trie_node_check(node, t)))
|
|
return NULL;
|
|
} else if (YAP_IsIntTerm(t)) {
|
|
if (!(node = trie_node_check(node, t)))
|
|
return NULL;
|
|
} else if (YAP_IsFloatTerm(t)) {
|
|
volatile union {
|
|
double f;
|
|
YAP_Term p[SIZE_FLOAT_AS_TERM];
|
|
} tf; /* to avoid gcc warning */
|
|
tf.f = YAP_FloatOfTerm(t);
|
|
if (!(node = trie_node_check(node, FloatInitTag)))
|
|
return NULL;
|
|
if (!(node = trie_node_check(node, tf.p[0])))
|
|
return NULL;
|
|
#ifdef TAG_LOW_BITS_32
|
|
if (!(node = trie_node_check(node, tf.p[1])))
|
|
return NULL;
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
if (!(node = trie_node_check(node, FloatEndTag)))
|
|
return NULL;
|
|
} else if (YAP_IsPairTerm(t)) {
|
|
if (!(node = trie_node_check(node, PairInitTag)))
|
|
return NULL;
|
|
if ((CURRENT_TRIE_MODE & TRIE_MODE_REVERSE) == TRIE_MODE_STANDARD) {
|
|
do {
|
|
if (!(node = check_entry(node, YAP_HeadOfTerm(t))))
|
|
return NULL;
|
|
t = YAP_Deref(YAP_TailOfTerm(t));
|
|
} while (YAP_IsPairTerm(t));
|
|
if (t == YAP_TermNil()) {
|
|
if (!(node = trie_node_check(node, PairEndEmptyTag)))
|
|
return NULL;
|
|
} else {
|
|
if (!(node = check_entry(node, t)))
|
|
return NULL;
|
|
if (!(node = trie_node_check(node, PairEndTermTag)))
|
|
return NULL;
|
|
}
|
|
} else if (CURRENT_TRIE_MODE & TRIE_MODE_REVERSE) { /* TRIE_MODE_REVERSE */
|
|
YAP_Term *stack_list = stack_args;
|
|
do {
|
|
PUSH_DOWN(stack_args, YAP_HeadOfTerm(t), stack_vars);
|
|
t = YAP_Deref(YAP_TailOfTerm(t));
|
|
} while (YAP_IsPairTerm(t));
|
|
if (t == YAP_TermNil()) {
|
|
while (STACK_NOT_EMPTY(stack_args, stack_list))
|
|
if (!(node = check_entry(node, POP_UP(stack_args))))
|
|
return NULL;
|
|
if (!(node = trie_node_check(node, PairEndEmptyTag)))
|
|
return NULL;
|
|
} else {
|
|
PUSH_DOWN(stack_args, t, stack_vars);
|
|
while (STACK_NOT_EMPTY(stack_args, stack_list))
|
|
if (!(node = check_entry(node, POP_UP(stack_args))))
|
|
return NULL;
|
|
if (!(node = trie_node_check(node, PairEndTermTag)))
|
|
return NULL;
|
|
}
|
|
}
|
|
} else if (YAP_IsApplTerm(t)) {
|
|
YAP_Functor f = YAP_FunctorOfTerm(t);
|
|
if (f == FunctorComma) {
|
|
if (!(node = trie_node_check(node, CommaInitTag)))
|
|
return NULL;
|
|
do {
|
|
if (!(node = check_entry(node, YAP_ArgOfTerm(1, t))))
|
|
return NULL;
|
|
t = YAP_Deref(YAP_ArgOfTerm(2, t));
|
|
} while (YAP_IsApplTerm(t) && YAP_FunctorOfTerm(t) == FunctorComma);
|
|
if (!(node = check_entry(node, t)))
|
|
return NULL;
|
|
if (!(node = trie_node_check(node, CommaEndTag)))
|
|
return NULL;
|
|
} else {
|
|
int i;
|
|
if (!(node = trie_node_check(node, ApplTag | ((YAP_Term) f))))
|
|
return NULL;
|
|
for (i = 1; i <= YAP_ArityOfFunctor(f); i++)
|
|
if (!(node = check_entry(node, YAP_ArgOfTerm(i, t))))
|
|
return NULL;
|
|
}
|
|
} else {
|
|
fprintf(stderr, "***************************************\n");
|
|
fprintf(stderr, " Tries core module: unknown type tag\n");
|
|
fprintf(stderr, "***************************************\n");
|
|
fflush(stderr);
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Term get_entry(TrNode node, YAP_Term *stack_mark, TrNode *cur_node) {
|
|
YAP_Term t = (YAP_Term) &t;
|
|
while (TrNode_parent(node)) {
|
|
t = TrNode_entry(node);
|
|
if (YAP_IsVarTerm(t)) {
|
|
int index = TrieVarIndex(t);
|
|
if (index > CURRENT_INDEX) {
|
|
int i;
|
|
stack_vars = &stack_vars_base[index + 1];
|
|
if (stack_vars > stack_args + 1) {
|
|
fprintf(stderr, "**************************************\n");
|
|
fprintf(stderr, " Tries core module: term stack full\n");
|
|
fprintf(stderr, "**************************************\n");
|
|
fflush(stderr);
|
|
}
|
|
for (i = index; i > CURRENT_INDEX; i--)
|
|
stack_vars_base[i] = 0;
|
|
CURRENT_INDEX = index;
|
|
}
|
|
if (stack_vars_base[index]) {
|
|
t = stack_vars_base[index];
|
|
} else {
|
|
t = YAP_MkVarTerm();
|
|
stack_vars_base[index] = t;
|
|
}
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (YAP_IsAtomTerm(t)) {
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (YAP_IsIntTerm(t)) {
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (YAP_IsPairTerm(t)) {
|
|
if (t == PairInitTag) {
|
|
YAP_Term t2;
|
|
if ((CURRENT_TRIE_MODE & TRIE_MODE_REVERSE) == TRIE_MODE_STANDARD) {
|
|
YAP_Term *stack_aux = stack_mark;
|
|
t = *stack_aux--;
|
|
while (STACK_NOT_EMPTY(stack_aux, stack_args)) {
|
|
t2 = *stack_aux--;
|
|
t = YAP_MkPairTerm(t2, t);
|
|
}
|
|
} else if (CURRENT_TRIE_MODE & TRIE_MODE_REVERSE) { /* TRIE_MODE_REVERSE */
|
|
YAP_Term *stack_aux = stack_mark;
|
|
t = *stack_aux;
|
|
if (t == YAP_TermNil())
|
|
stack_aux--;
|
|
else
|
|
t = POP_DOWN(stack_args);
|
|
while (STACK_NOT_EMPTY(stack_args, stack_aux)) {
|
|
t2 = POP_DOWN(stack_args);
|
|
t = YAP_MkPairTerm(t2, t);
|
|
}
|
|
}
|
|
stack_args = stack_mark;
|
|
*cur_node = node;
|
|
return t;
|
|
} else if (t == PairEndEmptyTag) {
|
|
t = YAP_TermNil();
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
node = TrNode_parent(node);
|
|
t = get_entry(node, &stack_args[1], &node);
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (t == PairEndTermTag) {
|
|
node = TrNode_parent(node);
|
|
t = get_entry(node, stack_args, &node);
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (t == CommaEndTag) {
|
|
node = TrNode_parent(node);
|
|
t = get_entry(node, stack_args, &node);
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (t == CommaInitTag) {
|
|
YAP_Term *stack_aux = stack_mark;
|
|
stack_aux--;
|
|
while (STACK_NOT_EMPTY(stack_aux, stack_args)) {
|
|
t = YAP_MkApplTerm(FunctorComma, 2, stack_aux);
|
|
*stack_aux = t;
|
|
stack_aux--;
|
|
}
|
|
stack_args = stack_mark;
|
|
*cur_node = node;
|
|
return t;
|
|
} else if (t == FloatEndTag) {
|
|
volatile union {
|
|
double f;
|
|
YAP_Term p[SIZE_FLOAT_AS_TERM];
|
|
} tf; /* to avoid gcc warning */
|
|
#ifdef TAG_LOW_BITS_32
|
|
node = TrNode_parent(node);
|
|
tf.p[1] = TrNode_entry(node);
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
node = TrNode_parent(node);
|
|
tf.p[0] = TrNode_entry(node);
|
|
node = TrNode_parent(node); /* ignore FloatInitTag */
|
|
t = YAP_MkFloatTerm(tf.f);
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else if (t == FloatInitTag) {
|
|
}
|
|
} else if (ApplTag & t) {
|
|
YAP_Functor f = (YAP_Functor)(~ApplTag & t);
|
|
int arity = YAP_ArityOfFunctor(f);
|
|
t = YAP_MkApplTerm(f, arity, &stack_args[1]);
|
|
stack_args += arity;
|
|
PUSH_UP(stack_args, t, stack_vars);
|
|
} else {
|
|
fprintf(stderr, "***************************************\n");
|
|
fprintf(stderr, " Tries core module: unknown type tag\n");
|
|
fprintf(stderr, "***************************************\n");
|
|
fflush(stderr);
|
|
}
|
|
node = TrNode_parent(node);
|
|
}
|
|
*cur_node = node;
|
|
return t;
|
|
}
|
|
|
|
|
|
static
|
|
void remove_entry(TrNode node) {
|
|
TrNode parent = TrNode_parent(node);
|
|
while (parent) {
|
|
if (TrNode_previous(node)) {
|
|
if (IS_HASH_NODE(TrNode_child(parent))) {
|
|
TrHash hash = (TrHash) TrNode_child(parent);
|
|
TrHash_num_nodes(hash)--;
|
|
if (TrHash_num_nodes(hash)) {
|
|
if (TrNode_next(node)) {
|
|
TrNode_next(TrNode_previous(node)) = TrNode_next(node);
|
|
TrNode_previous(TrNode_next(node)) = TrNode_previous(node);
|
|
} else {
|
|
TrNode_next(TrNode_previous(node)) = NULL;
|
|
}
|
|
free_trie_node(node);
|
|
return;
|
|
}
|
|
free_hash_buckets(TrHash_buckets(hash), TrHash_num_buckets(hash));
|
|
free_trie_hash(hash);
|
|
} else {
|
|
if (TrNode_next(node)) {
|
|
TrNode_next(TrNode_previous(node)) = TrNode_next(node);
|
|
TrNode_previous(TrNode_next(node)) = TrNode_previous(node);
|
|
} else {
|
|
TrNode_next(TrNode_previous(node)) = NULL;
|
|
}
|
|
free_trie_node(node);
|
|
return;
|
|
}
|
|
} else if (TrNode_next(node)) {
|
|
TrNode_child(parent) = TrNode_next(node);
|
|
TrNode_previous(TrNode_next(node)) = NULL;
|
|
free_trie_node(node);
|
|
return;
|
|
}
|
|
free_trie_node(node);
|
|
node = parent;
|
|
parent = TrNode_parent(node);
|
|
}
|
|
TrNode_child(node) = NULL;
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
void remove_child_nodes(TrNode node) {
|
|
if (IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash = (TrHash) node;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
do {
|
|
if (*--bucket)
|
|
remove_child_nodes(*bucket);
|
|
} while (bucket != first_bucket);
|
|
free_hash_buckets(first_bucket, TrHash_num_buckets(hash));
|
|
free_trie_hash(hash);
|
|
return;
|
|
}
|
|
if (TrNode_next(node))
|
|
remove_child_nodes(TrNode_next(node));
|
|
if (!IS_LEAF_TRIE_NODE(node)) {
|
|
remove_child_nodes(TrNode_child(node));
|
|
} else {
|
|
if (DATA_DESTRUCT_FUNCTION)
|
|
(*DATA_DESTRUCT_FUNCTION)(node);
|
|
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
}
|
|
free_trie_node(node);
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
TrNode copy_child_nodes(TrNode parent_dest, TrNode child_source) {
|
|
TrNode child_dest, next_dest;
|
|
|
|
if (IS_HASH_NODE(child_source)) {
|
|
TrNode *bucket_dest, *first_bucket_source, *bucket_source;
|
|
TrHash hash_dest, hash_source;
|
|
hash_source = (TrHash) child_source;
|
|
first_bucket_source = TrHash_buckets(hash_source);
|
|
bucket_source = first_bucket_source + TrHash_num_buckets(hash_source);
|
|
new_trie_hash(hash_dest, TrHash_num_nodes(hash_source), TrHash_num_buckets(hash_source));
|
|
bucket_dest = TrHash_buckets(hash_dest) + TrHash_num_buckets(hash_dest);
|
|
do {
|
|
bucket_dest--;
|
|
if (*--bucket_source) {
|
|
*bucket_dest = copy_child_nodes(parent_dest, *bucket_source);
|
|
TrNode_previous(*bucket_dest) = AS_TR_NODE_NEXT(bucket_dest);
|
|
} else
|
|
*bucket_dest = NULL;
|
|
} while (bucket_source != first_bucket_source);
|
|
return (TrNode) hash_dest;
|
|
}
|
|
|
|
if (TrNode_next(child_source))
|
|
next_dest = copy_child_nodes(parent_dest, TrNode_next(child_source));
|
|
else
|
|
next_dest = NULL;
|
|
new_trie_node(child_dest, TrNode_entry(child_source), parent_dest, NULL, next_dest, NULL);
|
|
if (next_dest)
|
|
TrNode_previous(next_dest) = child_dest;
|
|
if (IS_LEAF_TRIE_NODE(child_source)) {
|
|
MARK_AS_LEAF_TRIE_NODE(child_dest);
|
|
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
if (DATA_COPY_FUNCTION)
|
|
(*DATA_COPY_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source));
|
|
return child_dest;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_add(TrNode parent_dest, TrNode parent_source) {
|
|
TrNode child_dest, child_source;
|
|
|
|
/* parent_source is not a leaf node */
|
|
child_source = TrNode_child(parent_source);
|
|
if (IS_HASH_NODE(child_source)) {
|
|
TrNode *first_bucket_source, *bucket_source;
|
|
TrHash hash_source;
|
|
hash_source = (TrHash) child_source;
|
|
first_bucket_source = TrHash_buckets(hash_source);
|
|
bucket_source = first_bucket_source + TrHash_num_buckets(hash_source);
|
|
do {
|
|
child_source = *--bucket_source;
|
|
while (child_source) {
|
|
/* parent_dest is not a leaf node */
|
|
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
|
|
if (child_dest) {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
/* child_source is a leaf node */
|
|
if (DATA_ADD_FUNCTION)
|
|
(*DATA_ADD_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
/* child_dest and child_source are not leaf nodes */
|
|
traverse_and_add(child_dest, child_source);
|
|
}
|
|
child_source = TrNode_next(child_source);
|
|
}
|
|
} while (bucket_source != first_bucket_source);
|
|
return;
|
|
}
|
|
while (child_source) {
|
|
/* parent_dest is not a leaf node */
|
|
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
|
|
if (child_dest) {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
/* child_source is a leaf node */
|
|
if (DATA_ADD_FUNCTION)
|
|
(*DATA_ADD_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
/* child_dest and child_source are not leaf nodes */
|
|
traverse_and_add(child_dest, child_source);
|
|
}
|
|
child_source = TrNode_next(child_source);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_join(TrNode parent_dest, TrNode parent_source) {
|
|
TrNode child_dest, child_source;
|
|
|
|
/* parent_source is not a leaf node */
|
|
child_source = TrNode_child(parent_source);
|
|
if (IS_HASH_NODE(child_source)) {
|
|
TrNode *first_bucket_source, *bucket_source;
|
|
TrHash hash_source;
|
|
hash_source = (TrHash) child_source;
|
|
first_bucket_source = TrHash_buckets(hash_source);
|
|
bucket_source = first_bucket_source + TrHash_num_buckets(hash_source);
|
|
do {
|
|
child_source = *--bucket_source;
|
|
while (child_source) {
|
|
/* parent_dest is not a leaf node */
|
|
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
|
|
if (child_dest) {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
/* child_source is a leaf node */
|
|
if (DATA_ADD_FUNCTION)
|
|
(*DATA_ADD_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
/* child_dest and child_source are not leaf nodes */
|
|
traverse_and_join(child_dest, child_source);
|
|
} else {
|
|
child_dest = trie_node_check_insert(parent_dest, TrNode_entry(child_source));
|
|
if (IS_LEAF_TRIE_NODE(child_source)) {
|
|
MARK_AS_LEAF_TRIE_NODE(child_dest);
|
|
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
if (DATA_COPY_FUNCTION)
|
|
(*DATA_COPY_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source));
|
|
}
|
|
child_source = TrNode_next(child_source);
|
|
}
|
|
} while (bucket_source != first_bucket_source);
|
|
return;
|
|
}
|
|
while (child_source) {
|
|
/* parent_dest is not a leaf node */
|
|
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
|
|
if (child_dest) {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
/* child_source is a leaf node */
|
|
if (DATA_ADD_FUNCTION)
|
|
(*DATA_ADD_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
/* child_dest and child_source are not leaf nodes */
|
|
traverse_and_join(child_dest, child_source);
|
|
} else {
|
|
child_dest = trie_node_check_insert(parent_dest, TrNode_entry(child_source));
|
|
if (IS_LEAF_TRIE_NODE(child_source)) {
|
|
MARK_AS_LEAF_TRIE_NODE(child_dest);
|
|
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
if (DATA_COPY_FUNCTION)
|
|
(*DATA_COPY_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source));
|
|
}
|
|
child_source = TrNode_next(child_source);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_intersect(TrNode parent_dest, TrNode parent_source) {
|
|
TrNode child_dest, child_source, child_next;
|
|
|
|
/* parent_dest is not a leaf node */
|
|
child_dest = TrNode_child(parent_dest);
|
|
if (IS_HASH_NODE(child_dest)) {
|
|
TrNode *first_bucket_dest, *bucket_dest;
|
|
TrHash hash_dest;
|
|
hash_dest = (TrHash) child_dest;
|
|
first_bucket_dest = TrHash_buckets(hash_dest);
|
|
bucket_dest = first_bucket_dest + TrHash_num_buckets(hash_dest);
|
|
do {
|
|
child_dest = *--bucket_dest;
|
|
while (child_dest) {
|
|
child_next = TrNode_next(child_dest);
|
|
/* parent_source is not a leaf node */
|
|
child_source = trie_node_check(parent_source, TrNode_entry(child_dest));
|
|
if (child_source) {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
/* child_source is a leaf node */
|
|
if (DATA_ADD_FUNCTION)
|
|
(*DATA_ADD_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
/* child_dest and child_source are not leaf nodes */
|
|
traverse_and_intersect(child_dest, child_source);
|
|
} else {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
if (DATA_DESTRUCT_FUNCTION)
|
|
(*DATA_DESTRUCT_FUNCTION)(child_dest);
|
|
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
} else
|
|
remove_child_nodes(TrNode_child(child_dest));
|
|
remove_entry(child_dest);
|
|
}
|
|
child_dest = child_next;
|
|
}
|
|
} while (bucket_dest != first_bucket_dest);
|
|
return;
|
|
}
|
|
while (child_dest) {
|
|
child_next = TrNode_next(child_dest);
|
|
/* parent_source is not a leaf node */
|
|
child_source = trie_node_check(parent_source, TrNode_entry(child_dest));
|
|
if (child_source) {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
/* child_source is a leaf node */
|
|
if (DATA_ADD_FUNCTION)
|
|
(*DATA_ADD_FUNCTION)(child_dest, child_source);
|
|
} else
|
|
/* child_dest and child_source are not leaf nodes */
|
|
traverse_and_intersect(child_dest, child_source);
|
|
} else {
|
|
if (IS_LEAF_TRIE_NODE(child_dest)) {
|
|
if (DATA_DESTRUCT_FUNCTION)
|
|
(*DATA_DESTRUCT_FUNCTION)(child_dest);
|
|
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
} else
|
|
remove_child_nodes(TrNode_child(child_dest));
|
|
remove_entry(child_dest);
|
|
}
|
|
child_dest = child_next;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Int traverse_and_count_common_entries(TrNode parent1, TrNode parent2) {
|
|
TrNode child1, child2;
|
|
YAP_Int count = 0;
|
|
|
|
/* parent1 is not a leaf node */
|
|
child1 = TrNode_child(parent1);
|
|
if (IS_HASH_NODE(child1)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash;
|
|
hash = (TrHash) child1;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
do {
|
|
child1 = *--bucket;
|
|
while (child1) {
|
|
/* parent2 is not a leaf node */
|
|
child2 = trie_node_check(parent2, TrNode_entry(child1));
|
|
if (child2) {
|
|
if (IS_LEAF_TRIE_NODE(child1))
|
|
/* child2 is a leaf node */
|
|
count++;
|
|
else
|
|
/* child1 and child2 are not leaf nodes */
|
|
count += traverse_and_count_common_entries(child1, child2);
|
|
}
|
|
child1 = TrNode_next(child1);
|
|
}
|
|
} while (bucket != first_bucket);
|
|
return count;
|
|
}
|
|
while (child1) {
|
|
/* parent2 is not a leaf node */
|
|
child2 = trie_node_check(parent2, TrNode_entry(child1));
|
|
if (child2) {
|
|
if (IS_LEAF_TRIE_NODE(child1))
|
|
/* child2 is a leaf node */
|
|
count++;
|
|
else
|
|
/* child1 and child2 are not leaf nodes */
|
|
count += traverse_and_count_common_entries(child1, child2);
|
|
}
|
|
child1 = TrNode_next(child1);
|
|
}
|
|
return count;
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Int traverse_and_count_entries(TrNode node) {
|
|
YAP_Int count = 0;
|
|
|
|
if (IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash;
|
|
hash = (TrHash) node;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
do {
|
|
if (*--bucket) {
|
|
node = *bucket;
|
|
count += traverse_and_count_entries(node);
|
|
}
|
|
} while (bucket != first_bucket);
|
|
return count;
|
|
}
|
|
|
|
if (TrNode_next(node))
|
|
count += traverse_and_count_entries(TrNode_next(node));
|
|
if (!IS_LEAF_TRIE_NODE(node))
|
|
count += traverse_and_count_entries(TrNode_child(node));
|
|
else
|
|
count++;
|
|
return count;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_get_usage(TrNode node, YAP_Int depth) {
|
|
if (IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash;
|
|
hash = (TrHash) node;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
do {
|
|
if (*--bucket) {
|
|
node = *bucket;
|
|
traverse_and_get_usage(node, depth);
|
|
}
|
|
} while (bucket != first_bucket);
|
|
return;
|
|
}
|
|
|
|
USAGE_NODES++;
|
|
if (TrNode_next(node))
|
|
traverse_and_get_usage(TrNode_next(node), depth);
|
|
depth++;
|
|
if (!IS_LEAF_TRIE_NODE(node)) {
|
|
traverse_and_get_usage(TrNode_child(node), depth);
|
|
} else {
|
|
USAGE_ENTRIES++;
|
|
USAGE_VIRTUAL_NODES+= depth;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_save(TrNode node, FILE *file, int float_block) {
|
|
YAP_Term t;
|
|
|
|
if (IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash;
|
|
hash = (TrHash) node;
|
|
fprintf(file, UInt_FORMAT " %d ", HASH_SAVE_MARK, TrHash_num_buckets(hash));
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
do {
|
|
if (*--bucket) {
|
|
node = *bucket;
|
|
traverse_and_save(node, file, float_block);
|
|
}
|
|
} while (bucket != first_bucket);
|
|
return;
|
|
}
|
|
|
|
if (TrNode_next(node))
|
|
traverse_and_save(TrNode_next(node), file, float_block);
|
|
|
|
t = TrNode_entry(node);
|
|
if (float_block) {
|
|
float_block--;
|
|
fprintf(file, UInt_FORMAT " " UInt_FORMAT " ", FLOAT_SAVE_MARK, t);
|
|
} else if (YAP_IsPairTerm(t)) {
|
|
if (t == FloatInitTag) {
|
|
#ifdef TAG_LOW_BITS_32
|
|
float_block++;
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
float_block ++;
|
|
}
|
|
fprintf(file, UInt_FORMAT " ", t);
|
|
} else if (YAP_IsVarTerm(t) || YAP_IsIntTerm(t))
|
|
fprintf(file, UInt_FORMAT" ", t);
|
|
else {
|
|
int index;
|
|
for (index = 0; index <= CURRENT_INDEX; index++)
|
|
if (AUXILIARY_TERM_STACK[index] == t)
|
|
break;
|
|
if (index > CURRENT_INDEX) {
|
|
CURRENT_INDEX = index;
|
|
if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE)
|
|
expand_auxiliary_term_stack();
|
|
AUXILIARY_TERM_STACK[CURRENT_INDEX] = t;
|
|
if (YAP_IsAtomTerm(t))
|
|
fprintf(file, UInt_FORMAT " %d %s%c ", ATOM_SAVE_MARK, index, YAP_AtomName(YAP_AtomOfTerm(t)), '\0');
|
|
else /* (ApplTag & t) */
|
|
fprintf(file, UInt_FORMAT " %d %s " UInt_FORMAT " ", FUNCTOR_SAVE_MARK, index,
|
|
YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & t))),
|
|
YAP_ArityOfFunctor((YAP_Functor)(~ApplTag & t)));
|
|
} else
|
|
if (YAP_IsAtomTerm(t))
|
|
fprintf(file, UInt_FORMAT " %d ", ATOM_SAVE_MARK, index);
|
|
else
|
|
fprintf(file, UInt_FORMAT " %d ", FUNCTOR_SAVE_MARK, index);
|
|
}
|
|
if (IS_LEAF_TRIE_NODE(node)) {
|
|
fprintf(file, "- ");
|
|
if (DATA_SAVE_FUNCTION)
|
|
(*DATA_SAVE_FUNCTION)(node, file);
|
|
}
|
|
else {
|
|
traverse_and_save(TrNode_child(node), file, float_block);
|
|
fprintf(file, "- ");
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_load(TrNode parent, FILE *file) {
|
|
TrHash hash = NULL;
|
|
YAP_Term t;
|
|
int n;
|
|
|
|
if (!fscanf(file, UInt_FORMAT , &t)) {
|
|
MARK_AS_LEAF_TRIE_NODE(parent);
|
|
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
|
|
if (DATA_LOAD_FUNCTION)
|
|
(*DATA_LOAD_FUNCTION)(parent, CURRENT_DEPTH, file);
|
|
CURRENT_DEPTH--;
|
|
return;
|
|
}
|
|
if (t == HASH_SAVE_MARK) {
|
|
/* alloc a new trie hash */
|
|
int num_buckets;
|
|
n = fscanf(file, "%d", &num_buckets);
|
|
new_trie_hash(hash, 0, num_buckets);
|
|
TrNode_child(parent) = (TrNode) hash;
|
|
n = fscanf(file, UInt_FORMAT , &t);
|
|
}
|
|
do {
|
|
TrNode child;
|
|
if (t == ATOM_SAVE_MARK) {
|
|
int index;
|
|
n = fscanf(file, "%d", &index);
|
|
if (index > CURRENT_INDEX) {
|
|
char atom[1000];
|
|
if (CURRENT_LOAD_VERSION == 2) {
|
|
char *ptr, ch;
|
|
ptr = atom;
|
|
fgetc(file); /* skip the first empty space */
|
|
while ((ch = fgetc(file)))
|
|
*ptr++ = ch;
|
|
*ptr = '\0';
|
|
} else if (CURRENT_LOAD_VERSION == 1) {
|
|
n = fscanf(file, "%s", atom);
|
|
}
|
|
CURRENT_INDEX = index;
|
|
if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE)
|
|
expand_auxiliary_term_stack();
|
|
AUXILIARY_TERM_STACK[CURRENT_INDEX] = YAP_MkAtomTerm(YAP_LookupAtom(atom));
|
|
}
|
|
t = AUXILIARY_TERM_STACK[index];
|
|
} else if (t == FUNCTOR_SAVE_MARK) {
|
|
int index;
|
|
n = fscanf(file, "%d", &index);
|
|
if (index > CURRENT_INDEX) {
|
|
char atom[1000];
|
|
int arity;
|
|
n = fscanf(file, "%s %d", atom, &arity);
|
|
CURRENT_INDEX = index;
|
|
if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE)
|
|
expand_auxiliary_term_stack();
|
|
AUXILIARY_TERM_STACK[CURRENT_INDEX] = ApplTag | ((YAP_Term) YAP_MkFunctor(YAP_LookupAtom(atom), arity));
|
|
}
|
|
t = AUXILIARY_TERM_STACK[index];
|
|
} else if (t == FLOAT_SAVE_MARK)
|
|
n = fscanf(file, UInt_FORMAT , &t);
|
|
child = trie_node_insert(parent, t, hash);
|
|
traverse_and_load(child, file);
|
|
} while (fscanf(file, UInt_FORMAT , &t));
|
|
CURRENT_DEPTH--;
|
|
if (n) n = 0; // just added to remove the warning of not used!
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int mode) {
|
|
YAP_Term t;
|
|
int last_pair_mark = -arity[arity[0]];
|
|
|
|
if (IS_HASH_NODE(node)) {
|
|
int *current_arity = (int *) malloc(sizeof(int) * (arity[0] + 1));
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash;
|
|
hash = (TrHash) node;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
|
do {
|
|
if (*--bucket) {
|
|
node = *bucket;
|
|
traverse_and_print(node, arity, str, str_index, mode);
|
|
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
|
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) {
|
|
/* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */
|
|
if (str_index > 0 && str[str_index - 1] != '[')
|
|
str[str_index - 1] = ',';
|
|
/* restore possible PairEndTermTag side-effect */
|
|
if (str[last_pair_mark] == '|')
|
|
str[last_pair_mark] = ',';
|
|
}
|
|
}
|
|
} while (bucket != first_bucket);
|
|
free(current_arity);
|
|
return;
|
|
}
|
|
|
|
if (TrNode_next(node)) {
|
|
int *current_arity = (int *) malloc(sizeof(int) * (arity[0] + 1));
|
|
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
|
traverse_and_print(TrNode_next(node), arity, str, str_index, mode);
|
|
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
|
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) {
|
|
/* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */
|
|
if (str_index > 0 && str[str_index - 1] != '[')
|
|
str[str_index - 1] = ',';
|
|
/* restore possible PairEndTermTag side-effect */
|
|
if (str[last_pair_mark] == '|')
|
|
str[last_pair_mark] = ',';
|
|
}
|
|
free(current_arity);
|
|
}
|
|
|
|
/* update position for possible PairEndTermTag side-effect */
|
|
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0 && str_index > 1)
|
|
arity[arity[0]] = -str_index + 1;
|
|
|
|
t = TrNode_entry(node);
|
|
if (mode == TRIE_PRINT_FLOAT) {
|
|
#ifdef TAG_LOW_BITS_32
|
|
arity[arity[0]] = (YAP_Int) t;
|
|
mode = TRIE_PRINT_FLOAT2;
|
|
} else if (mode == TRIE_PRINT_FLOAT2) {
|
|
volatile union {
|
|
double f;
|
|
YAP_Term p[SIZE_FLOAT_AS_TERM];
|
|
} tf; /* to avoid gcc warning */
|
|
tf.p[1] = t;
|
|
tf.p[0] = (YAP_Term) arity[arity[0]];
|
|
arity[arity[0]] = -1;
|
|
#else /* TAG_64BITS */
|
|
volatile union {
|
|
double f;
|
|
YAP_Term p[SIZE_FLOAT_AS_TERM];
|
|
} tf; /* to avoid gcc warning */
|
|
tf.p[0] = t;
|
|
#endif /* TAG_SCHEME */
|
|
str_index += sprintf(& str[str_index], "%.15g", tf.f);
|
|
mode = TRIE_PRINT_FLOAT_END;
|
|
} else if (mode == TRIE_PRINT_FLOAT_END) {
|
|
arity[0]--;
|
|
while (arity[0]) {
|
|
if (arity[arity[0]] == 1) {
|
|
str_index += sprintf(& str[str_index], ")");
|
|
arity[0]--;
|
|
} else {
|
|
if (arity[arity[0]] > 1)
|
|
arity[arity[0]]--;
|
|
str_index += sprintf(& str[str_index], ",");
|
|
break;
|
|
}
|
|
}
|
|
mode = TRIE_PRINT_NORMAL;
|
|
} else if (YAP_IsVarTerm(t)) {
|
|
str_index += sprintf(& str[str_index], "VAR" UInt_FORMAT, TrieVarIndex(t));
|
|
while (arity[0]) {
|
|
if (arity[arity[0]] == 1) {
|
|
str_index += sprintf(& str[str_index], ")");
|
|
arity[0]--;
|
|
} else {
|
|
if (arity[arity[0]] > 1)
|
|
arity[arity[0]]--;
|
|
str_index += sprintf(& str[str_index], ",");
|
|
break;
|
|
}
|
|
}
|
|
} else if (YAP_IsAtomTerm(t)) {
|
|
str_index += sprintf(& str[str_index], "%s", YAP_AtomName(YAP_AtomOfTerm(t)));
|
|
while (arity[0]) {
|
|
if (arity[arity[0]] == 1) {
|
|
str_index += sprintf(& str[str_index], ")");
|
|
arity[0]--;
|
|
} else {
|
|
if (arity[arity[0]] > 1)
|
|
arity[arity[0]]--;
|
|
str_index += sprintf(& str[str_index], ",");
|
|
break;
|
|
}
|
|
}
|
|
} else if (YAP_IsIntTerm(t)) {
|
|
str_index += sprintf(& str[str_index], UInt_FORMAT , YAP_IntOfTerm(t));
|
|
while (arity[0]) {
|
|
if (arity[arity[0]] == 1) {
|
|
str_index += sprintf(& str[str_index], ")");
|
|
arity[0]--;
|
|
} else {
|
|
if (arity[arity[0]] > 1)
|
|
arity[arity[0]]--;
|
|
str_index += sprintf(& str[str_index], ",");
|
|
break;
|
|
}
|
|
}
|
|
} else if (YAP_IsPairTerm(t)) {
|
|
if (t == FloatInitTag) {
|
|
mode = TRIE_PRINT_FLOAT;
|
|
arity[0]++;
|
|
arity[arity[0]] = -1;
|
|
} else if (t == PairInitTag) {
|
|
str_index += sprintf(& str[str_index], "[");
|
|
arity[0]++;
|
|
arity[arity[0]] = -1;
|
|
} else if (t == CommaInitTag) {
|
|
str_index += sprintf(& str[str_index], "(");
|
|
arity[0]++;
|
|
arity[arity[0]] = -1;
|
|
} else {
|
|
if (t == PairEndEmptyTag)
|
|
str[str_index - 1] = ']';
|
|
else if (t == PairEndTermTag) {
|
|
str[last_pair_mark] = '|';
|
|
str[str_index - 1] = ']';
|
|
} else /* (t == CommaEndTag) */
|
|
str[str_index - 1] = ')';
|
|
arity[0]--;
|
|
while (arity[0]) {
|
|
if (arity[arity[0]] == 1) {
|
|
str_index += sprintf(& str[str_index], ")");
|
|
arity[0]--;
|
|
} else {
|
|
if (arity[arity[0]] > 1)
|
|
arity[arity[0]]--;
|
|
str_index += sprintf(& str[str_index], ",");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else if (ApplTag & t) {
|
|
str_index += sprintf(& str[str_index], "%s(", YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & t))));
|
|
arity[0]++;
|
|
arity[arity[0]] = YAP_ArityOfFunctor((YAP_Functor)(~ApplTag & t));
|
|
} else {
|
|
fprintf(stderr, "***************************************\n");
|
|
fprintf(stderr, " Tries core module: unknown type tag\n");
|
|
fprintf(stderr, "***************************************\n");
|
|
fflush(stderr);
|
|
}
|
|
|
|
if (arity[0]) {
|
|
traverse_and_print(TrNode_child(node), arity, str, str_index, mode);
|
|
} else {
|
|
str[str_index] = 0;
|
|
fprintf(stdout, "%s\n", str);
|
|
if (DATA_PRINT_FUNCTION)
|
|
(*DATA_PRINT_FUNCTION)(node);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Term trie_to_list(TrNode node) {
|
|
YAP_Term tail = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
|
|
|
|
#define CONSUME_NODE_LIST \
|
|
do { \
|
|
/* add node result to list */ \
|
|
tail = YAP_MkPairTerm(trie_to_list_node(node), tail); \
|
|
} while((node = TrNode_next(node)));
|
|
|
|
if (IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash = (TrHash) node;
|
|
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
|
|
/* iterate through valid hash positions and consume each list */
|
|
do {
|
|
if (*--bucket) {
|
|
node = *bucket;
|
|
CONSUME_NODE_LIST;
|
|
}
|
|
} while (bucket != first_bucket);
|
|
} else {
|
|
CONSUME_NODE_LIST;
|
|
}
|
|
#undef CONSUME_NODE_LIST
|
|
|
|
/* return list of trie options at this level */
|
|
return tail;
|
|
}
|
|
|
|
|
|
static
|
|
YAP_Term trie_to_list_node(TrNode node) {
|
|
YAP_Term t = TrNode_entry(node);
|
|
|
|
if(YAP_IsIntTerm(t) || YAP_IsAtomTerm(t)) {
|
|
return trie_to_list_create_two(YAP_IsIntTerm(t) ? "int" : "atom", node, t);
|
|
} else if (YAP_IsVarTerm(t)) {
|
|
int index = TrieVarIndex(t);
|
|
YAP_Term index_term = YAP_MkIntTerm((YAP_Int)index);
|
|
return trie_to_list_create_two("var", node, index_term);
|
|
} else if (YAP_IsPairTerm(t)) {
|
|
if(t == FloatInitTag) {
|
|
node = TrNode_child(node); /* consume FloatInitTag */
|
|
YAP_Functor f = YAP_MkFunctor(YAP_LookupAtom("floats"), 1);
|
|
YAP_Term child = trie_to_list_floats(node);
|
|
return YAP_MkApplTerm(f, 1, &child);
|
|
} else if(t == PairInitTag) {
|
|
return trie_to_list_create_simple("list", node);
|
|
} else if (t == PairEndEmptyTag) {
|
|
return trie_to_list_create_simple_end("endlist", node);
|
|
} else if (t == CommaInitTag) {
|
|
return trie_to_list_create_simple("comma", node);
|
|
} else if (t == CommaEndTag) {
|
|
return trie_to_list_create_simple_end("endcomma", node);
|
|
}
|
|
} else if (ApplTag & t) {
|
|
YAP_Functor f = (YAP_Functor)(~ApplTag & t);
|
|
int arity = YAP_ArityOfFunctor(f);
|
|
YAP_Functor new_f = YAP_MkFunctor(YAP_LookupAtom("functor"), 3);
|
|
YAP_Term args[3] = {
|
|
YAP_MkAtomTerm(YAP_NameOfFunctor(f)),
|
|
YAP_MkIntTerm((YAP_Int)arity),
|
|
trie_to_list(TrNode_child(node))
|
|
};
|
|
return YAP_MkApplTerm(new_f, 3, args);
|
|
}
|
|
fprintf(stderr, "***************************************\n");
|
|
fprintf(stderr, " Tries core module: unknown type tag\n");
|
|
fprintf(stderr, "***************************************\n");
|
|
fflush(stderr);
|
|
|
|
return YAP_MkAtomTerm(YAP_LookupAtom("fail"));
|
|
}
|
|
|
|
|
|
#define PUSH_NEW_FLOAT_TERM(val) \
|
|
result = YAP_MkPairTerm( \
|
|
trie_to_list_create_two("float", TrNode_child(node), YAP_MkFloatTerm(val)), \
|
|
result);
|
|
|
|
|
|
#ifdef TAG_LOW_BITS_32
|
|
|
|
YAP_Term trie_to_list_floats_tag_low_32(YAP_Term result, TrNode node, volatile YAP_Term *p, volatile double *f) {
|
|
if(IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash = (TrHash) node;
|
|
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
|
|
do {
|
|
if(*--bucket) {
|
|
node = *bucket;
|
|
do {
|
|
p[1] = TrNode_entry(node);
|
|
PUSH_NEW_FLOAT_TERM(*f);
|
|
} while((node = TrNode_next(node)));
|
|
}
|
|
} while (bucket != first_bucket);
|
|
} else {
|
|
do {
|
|
p[1] = TrNode_entry(node);
|
|
PUSH_NEW_FLOAT_TERM(*f);
|
|
} while((node = TrNode_next(node)));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
|
|
|
|
static
|
|
YAP_Term trie_to_list_floats(TrNode node) {
|
|
volatile union {
|
|
double f;
|
|
YAP_Term p[SIZE_FLOAT_AS_TERM];
|
|
} tf; /* to avoid gcc warning */
|
|
YAP_Term result = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
|
|
|
|
if (IS_HASH_NODE(node)) {
|
|
TrNode *first_bucket, *bucket;
|
|
TrHash hash = (TrHash) node;
|
|
first_bucket = TrHash_buckets(hash);
|
|
bucket = first_bucket + TrHash_num_buckets(hash);
|
|
do {
|
|
if (*--bucket) {
|
|
node = *bucket;
|
|
do {
|
|
tf.p[0] = TrNode_entry(node);
|
|
#ifdef TAG_LOW_BITS_32
|
|
result = trie_to_list_floats_tag_low_32(result, TrNode_child(node), &tf.p, &tf.f);
|
|
#else
|
|
PUSH_NEW_FLOAT_TERM(tf.f);
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
} while((node = TrNode_next(node)));
|
|
}
|
|
} while (bucket != first_bucket);
|
|
} else {
|
|
do {
|
|
tf.p[0] = TrNode_entry(node);
|
|
#ifdef TAG_LOW_BITS_32
|
|
result = trie_to_list_floats_tag_low_32(result, TrNode_child(node), &tf.p, &tf.f);
|
|
#else
|
|
PUSH_NEW_FLOAT_TERM(tf.f);
|
|
#endif /* TAG_LOW_BITS_32 */
|
|
} while((node = TrNode_next(node)));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
#undef PUSH_NEW_FLOAT_TERM
|
|
|
|
|
|
#include "core_dbtries.c"
|