diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of ssh://git.dcc.fc.up.pt/yap-6.3

Browse Source
This commit is contained in:
Vítor Santos Costa 2014-11-25 12:04:05 +00:00
commit 1ca062f558
8 changed files with 316 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
C/absmi.c
View File

@ -1493,12 +1493,16 @@ spy_goal( USES_REGS1 )
HR += 2; HR += 2;
{ {
PredEntry *pt0; PredEntry *pt0;
#if THREADS
LOCK(GLOBAL_ThreadHandlesLock); LOCK(GLOBAL_ThreadHandlesLock);
#endif
pt0 = SpyCode; pt0 = SpyCode;
P_before_spy = P; P_before_spy = P;
P = pt0->CodeOfPred; P = pt0->CodeOfPred;
/* for profiler */ /* for profiler */
#if THREADS
UNLOCK(GLOBAL_ThreadHandlesLock); UNLOCK(GLOBAL_ThreadHandlesLock);
#endif
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) if (Yap_do_low_level_trace)
low_level_trace(enter_pred,pt0,XREGS+1); low_level_trace(enter_pred,pt0,XREGS+1);

4
OPTYap/locks_x86.h
View File

@ -71,10 +71,10 @@ extern int debug_locks;
__BASE_FILE__, __LINE__,&(LOCK_VAR)); \ __BASE_FILE__, __LINE__,&(LOCK_VAR)); \
spin_unlock((spinlock_t *)&(LOCK_VAR)) spin_unlock((spinlock_t *)&(LOCK_VAR))
#else #else
#define LOCK(LOCK_VAR) do { \ #define LOCK(LOCK_VAR) { do { \
if (TRY_LOCK(&(LOCK_VAR))) break; \ if (TRY_LOCK(&(LOCK_VAR))) break; \
while (IS_LOCKED(LOCK_VAR)) continue; \ while (IS_LOCKED(LOCK_VAR)) continue; \
} while (1) } while (1); }
#define IS_LOCKED(LOCK_VAR) ((LOCK_VAR) != 0) #define IS_LOCKED(LOCK_VAR) ((LOCK_VAR) != 0)
#define IS_UNLOCKED(LOCK_VAR) ((LOCK_VAR) == 0) #define IS_UNLOCKED(LOCK_VAR) ((LOCK_VAR) == 0)
#define UNLOCK(LOCK_VAR) spin_unlock((spinlock_t *)&(LOCK_VAR)) #define UNLOCK(LOCK_VAR) spin_unlock((spinlock_t *)&(LOCK_VAR))

6
library/tries/base_dbtries.c
View File

@ -238,9 +238,11 @@ YAP_Term trie_depth_breadth(TrEntry trie, TrEntry db_trie, YAP_Int opt_level, YA
set_depth_breadth_reduction_current_data(NULL); set_depth_breadth_reduction_current_data(NULL);
/* We only need to simplify the trie once! */ /* We only need to simplify the trie once! */
/* This can be a 10% overhead for sld cases :-( */ /* This can be a 10% overhead for sld cases :-( */
// printf("simplification\n"); trie_print(trie);
if (TrNode_child(TrEntry_trie(trie))) if (TrNode_child(TrEntry_trie(trie)))
simplification_reduction(trie); simplification_reduction(trie);
while (TrNode_child(TrEntry_trie(trie))) { while (TrNode_child(TrEntry_trie(trie))) {
// printf("depth\n"); trie_print(trie);
nested_trie = depth_reduction(trie, depth_node, opt_level); nested_trie = depth_reduction(trie, depth_node, opt_level);
if (nested_trie) { if (nested_trie) {
set_depth_breadth_reduction_current_data(get_data_from_trie_node(nested_trie)); set_depth_breadth_reduction_current_data(get_data_from_trie_node(nested_trie));
@ -248,6 +250,7 @@ YAP_Term trie_depth_breadth(TrEntry trie, TrEntry db_trie, YAP_Int opt_level, YA
*end_counter = core_get_label_counter(); *end_counter = core_get_label_counter();
return YAP_MkApplTerm((YAP_Functor)(~ApplTag & TrNode_entry(TrNode_parent(nested_trie))), 1, &TrNode_entry(nested_trie)); return YAP_MkApplTerm((YAP_Functor)(~ApplTag & TrNode_entry(TrNode_parent(nested_trie))), 1, &TrNode_entry(nested_trie));
} }
// printf("breadth\n"); trie_print(trie);
nested_trie = breadth_reduction(trie, breadth_node, opt_level); nested_trie = breadth_reduction(trie, breadth_node, opt_level);
if (nested_trie) { if (nested_trie) {
set_depth_breadth_reduction_current_data(get_data_from_trie_node(nested_trie)); set_depth_breadth_reduction_current_data(get_data_from_trie_node(nested_trie));
@ -276,7 +279,8 @@ TrData trie_get_depth_breadth_reduction_current_data(void) {
void trie_replace_nested_trie(TrEntry trie, YAP_Int nested_trie_id, YAP_Term new_term) { void trie_replace_nested_trie(TrEntry trie, YAP_Int nested_trie_id, YAP_Term new_term) {
core_depth_breadth_trie_replace_nested_trie(TrNode_child(TrEntry_trie(trie)), nested_trie_id, new_term); CURRENT_TRIE = trie;
core_depth_breadth_trie_replace_nested_trie(TrNode_child(TrEntry_trie(trie)), nested_trie_id, new_term, &trie_data_construct, &trie_data_destruct);
return; return;
} }

35
library/tries/base_tries.c
View File

@ -74,8 +74,23 @@ void trie_data_destruct(TrNode node) {
data = (TrData) GET_DATA_FROM_LEAF_TRIE_NODE(node); data = (TrData) GET_DATA_FROM_LEAF_TRIE_NODE(node);
trie = TrData_trie(data); trie = TrData_trie(data);
if (data == TrEntry_traverse_data(trie)) if (data == TrEntry_traverse_data(trie)) {
TrEntry_traverse_data(trie) = TrData_previous(data); if (CURRENT_TRAVERSE_MODE == TRAVERSE_MODE_FORWARD) {
TrEntry_traverse_data(trie) = TrData_previous(data);
} else {
if (TrData_next(data)) {
TrEntry_traverse_data(trie) = TrData_next(data);
} else {
TrData special;
new_struct(special, TYPE_TR_DATA, SIZEOF_TR_DATA);
TrData_next(special) = NULL;
TrData_previous(special) = TrData_previous(data);
TrData_trie(special) = NULL;
TrData_leaf(special) = NULL;
TrEntry_traverse_data(trie) = special; /* This special data is necessery to allow proper backwards traverse when the last entry is removed this is freed only if the trie is kept traversing */
}
}
}
if (TrData_next(data)) { if (TrData_next(data)) {
TrData_previous(TrData_next(data)) = TrData_previous(data); TrData_previous(TrData_next(data)) = TrData_previous(data);
TrData_next(TrData_previous(data)) = TrData_next(data); TrData_next(TrData_previous(data)) = TrData_next(data);
@ -211,10 +226,19 @@ TrData trie_traverse_init(TrEntry trie, TrData init_data) {
TrData trie_traverse_cont(TrEntry trie) { TrData trie_traverse_cont(TrEntry trie) {
TrData data; TrData data, temp = NULL;
data = TrEntry_traverse_data(trie); data = TrEntry_traverse_data(trie);
if (data) { if (data) {
if (!TrData_trie(data)) {
if (TrEntry_first_data(trie)) {
temp = data;
} else {
free_trie_data(data);
data = NULL;
TrEntry_traverse_data(trie) = NULL;
return NULL;
}
}
if (CURRENT_TRAVERSE_MODE == TRAVERSE_MODE_FORWARD) if (CURRENT_TRAVERSE_MODE == TRAVERSE_MODE_FORWARD)
data = TrData_next(data); data = TrData_next(data);
else { else {
@ -223,6 +247,8 @@ TrData trie_traverse_cont(TrEntry trie) {
data = NULL; data = NULL;
} }
TrEntry_traverse_data(trie) = data; TrEntry_traverse_data(trie) = data;
if (temp)
free_trie_data(temp);
} }
return data; return data;
} }
@ -325,7 +351,6 @@ void trie_print(TrEntry trie) {
void trie_data_construct(TrNode node) { void trie_data_construct(TrNode node) {
TrData data; TrData data;
new_trie_data(data, CURRENT_TRIE, node); new_trie_data(data, CURRENT_TRIE, node);
PUT_DATA_IN_LEAF_TRIE_NODE(node, data); PUT_DATA_IN_LEAF_TRIE_NODE(node, data);
return; return;

110
library/tries/core_dbtries.c
View File

@ -210,9 +210,9 @@ int traverse_get_counter(TrNode node);
YAP_Term generate_label(YAP_Int Index); YAP_Term generate_label(YAP_Int Index);
YAP_Term update_depth_breadth_trie(TrEngine engine, TrNode root, YAP_Int opt_level, void (*construct_function)(TrNode), void (*destruct_function)(TrNode), void (*copy_function)(TrNode, TrNode), void (*correct_order_function)(void)); YAP_Term update_depth_breadth_trie(TrEngine engine, TrNode root, YAP_Int opt_level, void (*construct_function)(TrNode), void (*destruct_function)(TrNode), void (*copy_function)(TrNode, TrNode), void (*correct_order_function)(void));
YAP_Term get_return_node_term(TrNode node); YAP_Term get_return_node_term(TrNode node);
void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term); void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term); TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
void check_attach_childs(TrNode search_child, TrNode existing_child); void check_attach_childs(TrNode parent, TrNode search_child, TrNode existing_child, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
TrNode get_simplification_sibling(TrNode node); TrNode get_simplification_sibling(TrNode node);
TrNode check_parent_first(TrNode node); TrNode check_parent_first(TrNode node);
TrNode TrNode_myparent(TrNode node); TrNode TrNode_myparent(TrNode node);
@ -257,18 +257,18 @@ void core_set_trie_db_opt_min_prefix(YAP_Int min_prefix) {
void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term) { void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
traverse_and_replace_nested_trie(node, nested_trie_id, new_term); traverse_and_replace_nested_trie(node, nested_trie_id, new_term, construct_function, destruct_function);
return; return;
} }
inline inline
void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term) { void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
TrNode child, temp; TrNode child, temp;
if (TrNode_entry(node) == PairEndTag) { if (TrNode_entry(node) == PairEndTag) {
if (TrNode_next(node)) if (TrNode_next(node))
traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term); traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term, construct_function, destruct_function);
return; return;
} else if (IS_HASH_NODE(node)) { } else if (IS_HASH_NODE(node)) {
printf("HASH NODE ERROR: db_tries do not support hash nodes.\n"); printf("HASH NODE ERROR: db_tries do not support hash nodes.\n");
@ -280,7 +280,7 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
do { do {
if ((node = *--bucket)) { if ((node = *--bucket)) {
do { do {
traverse_and_replace_nested_trie(node, nested_trie_id, new_term); traverse_and_replace_nested_trie(node, nested_trie_id, new_term, construct_function, destruct_function);
node = TrNode_next(node); node = TrNode_next(node);
} while(node); } while(node);
} }
@ -303,13 +303,13 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
do { do {
if (YAP_IntOfTerm(TrNode_entry(child)) == nested_trie_id) { if (YAP_IntOfTerm(TrNode_entry(child)) == nested_trie_id) {
temp = TrNode_previous(node); temp = TrNode_previous(node);
node = replace_nested_trie(node, child, new_term); node = replace_nested_trie(node, child, new_term, construct_function, destruct_function);
if (temp) { if (temp) {
temp = TrNode_next(node); temp = TrNode_next(node);
if (temp) if (temp)
node = temp; node = temp;
} else { } else {
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term); traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term, construct_function, destruct_function);
return; return;
} }
} }
@ -322,10 +322,10 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
do { do {
if (YAP_IntOfTerm(TrNode_entry(child)) == nested_trie_id) { if (YAP_IntOfTerm(TrNode_entry(child)) == nested_trie_id) {
temp = TrNode_next(node); temp = TrNode_next(node);
node = replace_nested_trie(node, child, new_term); node = replace_nested_trie(node, child, new_term, construct_function, destruct_function);
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term); traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term, construct_function, destruct_function);
if(temp) if(temp)
traverse_and_replace_nested_trie(temp, nested_trie_id, new_term); traverse_and_replace_nested_trie(temp, nested_trie_id, new_term, construct_function, destruct_function);
return; return;
} }
child = TrNode_next(child); child = TrNode_next(child);
@ -333,17 +333,16 @@ void traverse_and_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_T
} }
} }
} }
traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term); traverse_and_replace_nested_trie(TrNode_child(node), nested_trie_id, new_term, construct_function, destruct_function);
if (TrNode_next(node)) if (TrNode_next(node))
traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term); traverse_and_replace_nested_trie(TrNode_next(node), nested_trie_id, new_term, construct_function, destruct_function);
} }
return; return;
} }
/* fixmeeee */ /* fixmeeee */
TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term) { TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
TrNode newnode, temp, newnodef = NULL; TrNode newnode, temp, newnodef = NULL;
YAP_Term term_search = (YAP_Term) NULL;
if (YAP_IsApplTerm(new_term)) { if (YAP_IsApplTerm(new_term)) {
YAP_Term new_term_functor = ApplTag | ((YAP_Term) YAP_FunctorOfTerm(new_term)); YAP_Term new_term_functor = ApplTag | ((YAP_Term) YAP_FunctorOfTerm(new_term));
YAP_Int arity = YAP_ArityOfFunctor(YAP_FunctorOfTerm(new_term)); YAP_Int arity = YAP_ArityOfFunctor(YAP_FunctorOfTerm(new_term));
@ -369,27 +368,19 @@ TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term) {
TrNode_previous(TrNode_child(newnodef)) = newnode; TrNode_previous(TrNode_child(newnodef)) = newnode;
TrNode_child(newnodef) = newnode; TrNode_child(newnodef) = newnode;
} else { } else {
// Rewind to first uncle node /* Check if one of the node siblings have new_term */
temp = TrNode_parent(node); temp = node;
if (IS_FUNCTOR_NODE(temp))
term_search = TrNode_entry(temp);
while (TrNode_previous(temp)) while (TrNode_previous(temp))
temp = TrNode_previous(temp); temp = TrNode_previous(temp);
// Handles cases like not(t(?)) but doesn't handle case like not(not(...)
if (term_search) {
while (temp && TrNode_entry(temp) != term_search)
temp = TrNode_next(temp);
if (temp)
temp = TrNode_child(temp);
}
while (temp && TrNode_entry(temp) != new_term) while (temp && TrNode_entry(temp) != new_term)
temp = TrNode_next(temp); temp = TrNode_next(temp);
if (temp) { // Found a node we can reuse if (temp) {
newnode = temp; newnode = temp;
// Check if the childs of node/child exist already otherwise attach them // Check if the childs of node/child exist already otherwise attach them
check_attach_childs(TrNode_child(child), TrNode_child(newnode)); check_attach_childs(newnode, TrNode_child(child), TrNode_child(newnode), construct_function, destruct_function);
//DATA_DESTRUCT_FUNCTION = destruct_function; DATA_DESTRUCT_FUNCTION = destruct_function;
remove_child_nodes(TrNode_child(child)); remove_child_nodes(TrNode_child(child));
TrNode_child(child) = NULL;
remove_entry(child); remove_entry(child);
return newnode; return newnode;
} else { // Make a new node } else { // Make a new node
@ -426,20 +417,56 @@ TrNode replace_nested_trie(TrNode node, TrNode child, YAP_Term new_term) {
} }
void check_attach_childs(TrNode search_child, TrNode existing_child) { void check_attach_childs(TrNode parent, TrNode search_child, TrNode existing_child, void (*construct_function)(TrNode), void (*destruct_function)(TrNode)) {
TrNode newnode;
// Check if the childs of node/child exist already otherwise attach them // Check if the childs of node/child exist already otherwise attach them
do { do {
while(existing_child && (TrNode_entry(existing_child) != TrNode_entry(search_child))) while(existing_child && (TrNode_entry(existing_child) != PairEndTag) && (TrNode_entry(existing_child) != TrNode_entry(search_child)))
existing_child = TrNode_next(existing_child); existing_child = TrNode_next(existing_child);
if (existing_child) { if (existing_child) {
if (TrNode_entry(existing_child) != PairEndTag) { if (TrNode_entry(existing_child) != PairEndTag)
check_attach_childs(TrNode_child(search_child), TrNode_child(existing_child)); check_attach_childs(existing_child, TrNode_child(search_child), TrNode_child(existing_child), construct_function, destruct_function);
} existing_child = TrNode_child(parent);
search_child = TrNode_next(search_child);
} else if (TrNode_entry(search_child) == PairEndTag) {
newnode = parent;
DATA_DESTRUCT_FUNCTION = destruct_function;
remove_child_nodes(TrNode_child(newnode));
TrNode_child(newnode) = NULL;
newnode = trie_node_check_insert(newnode, PairEndTag);
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
(*construct_function)(newnode);
return;
} else { } else {
printf("Need to attach child!\n"); existing_child = search_child;
abort(); search_child = TrNode_next(search_child);
if(TrNode_child(TrNode_parent(existing_child)) == existing_child) {
if(TrNode_next(existing_child)) {
TrNode_child(TrNode_parent(existing_child)) = TrNode_next(existing_child);
} else {
newnode = TrNode_parent(existing_child);
// DATA_DESTRUCT_FUNCTION = destruct_function;
// remove_child_nodes(TrNode_child(newnode));
TrNode_child(newnode) = NULL;
newnode = trie_node_check_insert(newnode, PairEndTag);
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
(*construct_function)(newnode);
}
}
if (TrNode_next(existing_child))
TrNode_previous(TrNode_next(existing_child)) = TrNode_previous(existing_child);
if (TrNode_previous(existing_child))
TrNode_next(TrNode_previous(existing_child)) = TrNode_next(existing_child);
TrNode_parent(existing_child) = parent;
TrNode_previous(existing_child) = NULL;
TrNode_next(existing_child) = TrNode_child(parent);
TrNode_previous(TrNode_child(parent)) = existing_child;
TrNode_child(parent) = existing_child;
existing_child = TrNode_child(parent);
} }
search_child = TrNode_next(search_child);
} while(search_child); } while(search_child);
} }
@ -624,7 +651,7 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_node,
stack_args_base = stack_args = AUXILIARY_TERM_STACK; stack_args_base = stack_args = AUXILIARY_TERM_STACK;
stack_top = AUXILIARY_TERM_STACK + CURRENT_AUXILIARY_TERM_STACK_SIZE - 1; stack_top = AUXILIARY_TERM_STACK + CURRENT_AUXILIARY_TERM_STACK_SIZE - 1;
node = TrNode_parent(TrNode_parent(node)); node = TrNode_parent(TrNode_parent(node));
// printf("start node: "); displaynode(node); // printf("start node: "); displaynode(node);
if (IS_FUNCTOR_NODE(node)) { if (IS_FUNCTOR_NODE(node)) {
while(IS_FUNCTOR_NODE(node)) while(IS_FUNCTOR_NODE(node))
node = TrNode_parent(node); node = TrNode_parent(node);
@ -633,7 +660,7 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_node,
child = TrNode_child(child); child = TrNode_child(child);
} else } else
child = TrNode_child(node); child = TrNode_child(node);
// printf("Chosen start node: "); displaynode(child); // printf("Chosen start node: "); displaynode(child);
if (IS_HASH_NODE(child)) { if (IS_HASH_NODE(child)) {
printf("HASH NODE ERROR: db_tries do not support hash nodes.\n"); printf("HASH NODE ERROR: db_tries do not support hash nodes.\n");
abort(); abort();
@ -729,7 +756,6 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_node,
/* nested trie: stop procedure and return nested trie node */ /* nested trie: stop procedure and return nested trie node */
if (IS_FUNCTOR_NODE(TrNode_parent(child)) && (strcmp(YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & TrNode_entry(TrNode_parent(child))))), NESTED_TRIE_TERM) == 0)) if (IS_FUNCTOR_NODE(TrNode_parent(child)) && (strcmp(YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & TrNode_entry(TrNode_parent(child))))), NESTED_TRIE_TERM) == 0))
return child; return child;
PUSH_DOWN(stack_args, TrNode_entry(child), stack_top); PUSH_DOWN(stack_args, TrNode_entry(child), stack_top);
count++; count++;
if (IS_FUNCTOR_NODE(TrNode_parent(child))) { if (IS_FUNCTOR_NODE(TrNode_parent(child))) {

2
library/tries/core_dbtries.h
View File

@ -225,6 +225,6 @@ TrNode core_breadth_reduction(TrEngine engine, TrNode node, TrNode breadth_no
YAP_Term core_get_trie_db_return_term(void); YAP_Term core_get_trie_db_return_term(void);
void core_set_trie_db_return_term(YAP_Term return_value); void core_set_trie_db_return_term(YAP_Term return_value);
YAP_Int core_db_trie_get_optimization_level_count(YAP_Int opt_level); YAP_Int core_db_trie_get_optimization_level_count(YAP_Int opt_level);
void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term); void core_depth_breadth_trie_replace_nested_trie(TrNode node, YAP_Int nested_trie_id, YAP_Term new_term, void (*construct_function)(TrNode), void (*destruct_function)(TrNode));
YAP_Int core_get_trie_db_opt_min_prefix(void); YAP_Int core_get_trie_db_opt_min_prefix(void);
void core_set_trie_db_opt_min_prefix(YAP_Int min_prefix); void core_set_trie_db_opt_min_prefix(YAP_Int min_prefix);

406
library/tries/core_tries.c
View File

@ -807,7 +807,7 @@ YAP_Term get_entry(TrNode node, YAP_Term *stack_mark, TrNode *cur_node) {
fprintf(stderr, "**************************************\n"); fprintf(stderr, "**************************************\n");
fprintf(stderr, " Tries core module: term stack full\n"); fprintf(stderr, " Tries core module: term stack full\n");
fprintf(stderr, "**************************************\n"); fprintf(stderr, "**************************************\n");
fflush(stderr); fflush(stderr);
} }
for (i = index; i > CURRENT_INDEX; i--) for (i = index; i > CURRENT_INDEX; i--)
stack_vars_base[i] = 0; stack_vars_base[i] = 0;
@ -875,10 +875,10 @@ YAP_Term get_entry(TrNode node, YAP_Term *stack_mark, TrNode *cur_node) {
*cur_node = node; *cur_node = node;
return t; return t;
} else if (t == FloatEndTag) { } else if (t == FloatEndTag) {
volatile union { volatile union {
double f; double f;
YAP_Term p[SIZE_FLOAT_AS_TERM]; YAP_Term p[SIZE_FLOAT_AS_TERM];
} tf; /* to avoid gcc warning */ } tf; /* to avoid gcc warning */
#ifdef TAG_LOW_BITS_32 #ifdef TAG_LOW_BITS_32
node = TrNode_parent(node); node = TrNode_parent(node);
tf.p[1] = TrNode_entry(node); tf.p[1] = TrNode_entry(node);
@ -915,29 +915,29 @@ void remove_entry(TrNode node) {
while (parent) { while (parent) {
if (TrNode_previous(node)) { if (TrNode_previous(node)) {
if (IS_HASH_NODE(TrNode_child(parent))) { if (IS_HASH_NODE(TrNode_child(parent))) {
TrHash hash = (TrHash) TrNode_child(parent); TrHash hash = (TrHash) TrNode_child(parent);
TrHash_num_nodes(hash)--; TrHash_num_nodes(hash)--;
if (TrHash_num_nodes(hash)) { if (TrHash_num_nodes(hash)) {
if (TrNode_next(node)) { if (TrNode_next(node)) {
TrNode_next(TrNode_previous(node)) = TrNode_next(node); TrNode_next(TrNode_previous(node)) = TrNode_next(node);
TrNode_previous(TrNode_next(node)) = TrNode_previous(node); TrNode_previous(TrNode_next(node)) = TrNode_previous(node);
} else { } else {
TrNode_next(TrNode_previous(node)) = NULL; TrNode_next(TrNode_previous(node)) = NULL;
} }
free_trie_node(node); free_trie_node(node);
return; return;
} }
free_hash_buckets(TrHash_buckets(hash), TrHash_num_buckets(hash)); free_hash_buckets(TrHash_buckets(hash), TrHash_num_buckets(hash));
free_trie_hash(hash); free_trie_hash(hash);
} else { } else {
if (TrNode_next(node)) { if (TrNode_next(node)) {
TrNode_next(TrNode_previous(node)) = TrNode_next(node); TrNode_next(TrNode_previous(node)) = TrNode_next(node);
TrNode_previous(TrNode_next(node)) = TrNode_previous(node); TrNode_previous(TrNode_next(node)) = TrNode_previous(node);
} else { } else {
TrNode_next(TrNode_previous(node)) = NULL; TrNode_next(TrNode_previous(node)) = NULL;
} }
free_trie_node(node); free_trie_node(node);
return; return;
} }
} else if (TrNode_next(node)) { } else if (TrNode_next(node)) {
TrNode_child(parent) = TrNode_next(node); TrNode_child(parent) = TrNode_next(node);
@ -963,7 +963,7 @@ void remove_child_nodes(TrNode node) {
bucket = first_bucket + TrHash_num_buckets(hash); bucket = first_bucket + TrHash_num_buckets(hash);
do { do {
if (*--bucket) if (*--bucket)
remove_child_nodes(*bucket); remove_child_nodes(*bucket);
} while (bucket != first_bucket); } while (bucket != first_bucket);
free_hash_buckets(first_bucket, TrHash_num_buckets(hash)); free_hash_buckets(first_bucket, TrHash_num_buckets(hash));
free_trie_hash(hash); free_trie_hash(hash);
@ -971,9 +971,9 @@ void remove_child_nodes(TrNode node) {
} }
if (TrNode_next(node)) if (TrNode_next(node))
remove_child_nodes(TrNode_next(node)); remove_child_nodes(TrNode_next(node));
if (!IS_LEAF_TRIE_NODE(node)) if (!IS_LEAF_TRIE_NODE(node)) {
remove_child_nodes(TrNode_child(node)); remove_child_nodes(TrNode_child(node));
else { } else {
if (DATA_DESTRUCT_FUNCTION) if (DATA_DESTRUCT_FUNCTION)
(*DATA_DESTRUCT_FUNCTION)(node); (*DATA_DESTRUCT_FUNCTION)(node);
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE); DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
@ -998,10 +998,10 @@ TrNode copy_child_nodes(TrNode parent_dest, TrNode child_source) {
do { do {
bucket_dest--; bucket_dest--;
if (*--bucket_source) { if (*--bucket_source) {
*bucket_dest = copy_child_nodes(parent_dest, *bucket_source); *bucket_dest = copy_child_nodes(parent_dest, *bucket_source);
TrNode_previous(*bucket_dest) = AS_TR_NODE_NEXT(bucket_dest); TrNode_previous(*bucket_dest) = AS_TR_NODE_NEXT(bucket_dest);
} else } else
*bucket_dest = NULL; *bucket_dest = NULL;
} while (bucket_source != first_bucket_source); } while (bucket_source != first_bucket_source);
return (TrNode) hash_dest; return (TrNode) hash_dest;
} }
@ -1039,18 +1039,18 @@ void traverse_and_add(TrNode parent_dest, TrNode parent_source) {
do { do {
child_source = *--bucket_source; child_source = *--bucket_source;
while (child_source) { while (child_source) {
/* parent_dest is not a leaf node */ /* parent_dest is not a leaf node */
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source)); child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
if (child_dest) { if (child_dest) {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
/* child_source is a leaf node */ /* child_source is a leaf node */
if (DATA_ADD_FUNCTION) if (DATA_ADD_FUNCTION)
(*DATA_ADD_FUNCTION)(child_dest, child_source); (*DATA_ADD_FUNCTION)(child_dest, child_source);
} else } else
/* child_dest and child_source are not leaf nodes */ /* child_dest and child_source are not leaf nodes */
traverse_and_add(child_dest, child_source); traverse_and_add(child_dest, child_source);
} }
child_source = TrNode_next(child_source); child_source = TrNode_next(child_source);
} }
} while (bucket_source != first_bucket_source); } while (bucket_source != first_bucket_source);
return; return;
@ -1060,12 +1060,12 @@ void traverse_and_add(TrNode parent_dest, TrNode parent_source) {
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source)); child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
if (child_dest) { if (child_dest) {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
/* child_source is a leaf node */ /* child_source is a leaf node */
if (DATA_ADD_FUNCTION) if (DATA_ADD_FUNCTION)
(*DATA_ADD_FUNCTION)(child_dest, child_source); (*DATA_ADD_FUNCTION)(child_dest, child_source);
} else } else
/* child_dest and child_source are not leaf nodes */ /* child_dest and child_source are not leaf nodes */
traverse_and_add(child_dest, child_source); traverse_and_add(child_dest, child_source);
} }
child_source = TrNode_next(child_source); child_source = TrNode_next(child_source);
} }
@ -1088,27 +1088,27 @@ void traverse_and_join(TrNode parent_dest, TrNode parent_source) {
do { do {
child_source = *--bucket_source; child_source = *--bucket_source;
while (child_source) { while (child_source) {
/* parent_dest is not a leaf node */ /* parent_dest is not a leaf node */
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source)); child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
if (child_dest) { if (child_dest) {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
/* child_source is a leaf node */ /* child_source is a leaf node */
if (DATA_ADD_FUNCTION) if (DATA_ADD_FUNCTION)
(*DATA_ADD_FUNCTION)(child_dest, child_source); (*DATA_ADD_FUNCTION)(child_dest, child_source);
} else } else
/* child_dest and child_source are not leaf nodes */ /* child_dest and child_source are not leaf nodes */
traverse_and_join(child_dest, child_source); traverse_and_join(child_dest, child_source);
} else { } else {
child_dest = trie_node_check_insert(parent_dest, TrNode_entry(child_source)); child_dest = trie_node_check_insert(parent_dest, TrNode_entry(child_source));
if (IS_LEAF_TRIE_NODE(child_source)) { if (IS_LEAF_TRIE_NODE(child_source)) {
MARK_AS_LEAF_TRIE_NODE(child_dest); MARK_AS_LEAF_TRIE_NODE(child_dest);
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE); INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
if (DATA_COPY_FUNCTION) if (DATA_COPY_FUNCTION)
(*DATA_COPY_FUNCTION)(child_dest, child_source); (*DATA_COPY_FUNCTION)(child_dest, child_source);
} else } else
TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source)); TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source));
} }
child_source = TrNode_next(child_source); child_source = TrNode_next(child_source);
} }
} while (bucket_source != first_bucket_source); } while (bucket_source != first_bucket_source);
return; return;
@ -1118,19 +1118,19 @@ void traverse_and_join(TrNode parent_dest, TrNode parent_source) {
child_dest = trie_node_check(parent_dest, TrNode_entry(child_source)); child_dest = trie_node_check(parent_dest, TrNode_entry(child_source));
if (child_dest) { if (child_dest) {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
/* child_source is a leaf node */ /* child_source is a leaf node */
if (DATA_ADD_FUNCTION) if (DATA_ADD_FUNCTION)
(*DATA_ADD_FUNCTION)(child_dest, child_source); (*DATA_ADD_FUNCTION)(child_dest, child_source);
} else } else
/* child_dest and child_source are not leaf nodes */ /* child_dest and child_source are not leaf nodes */
traverse_and_join(child_dest, child_source); traverse_and_join(child_dest, child_source);
} else { } else {
child_dest = trie_node_check_insert(parent_dest, TrNode_entry(child_source)); child_dest = trie_node_check_insert(parent_dest, TrNode_entry(child_source));
if (IS_LEAF_TRIE_NODE(child_source)) { if (IS_LEAF_TRIE_NODE(child_source)) {
MARK_AS_LEAF_TRIE_NODE(child_dest); MARK_AS_LEAF_TRIE_NODE(child_dest);
INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE); INCREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
if (DATA_COPY_FUNCTION) if (DATA_COPY_FUNCTION)
(*DATA_COPY_FUNCTION)(child_dest, child_source); (*DATA_COPY_FUNCTION)(child_dest, child_source);
} else } else
TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source)); TrNode_child(child_dest) = copy_child_nodes(child_dest, TrNode_child(child_source));
} }
@ -1155,27 +1155,27 @@ void traverse_and_intersect(TrNode parent_dest, TrNode parent_source) {
do { do {
child_dest = *--bucket_dest; child_dest = *--bucket_dest;
while (child_dest) { while (child_dest) {
child_next = TrNode_next(child_dest); child_next = TrNode_next(child_dest);
/* parent_source is not a leaf node */ /* parent_source is not a leaf node */
child_source = trie_node_check(parent_source, TrNode_entry(child_dest)); child_source = trie_node_check(parent_source, TrNode_entry(child_dest));
if (child_source) { if (child_source) {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
/* child_source is a leaf node */ /* child_source is a leaf node */
if (DATA_ADD_FUNCTION) if (DATA_ADD_FUNCTION)
(*DATA_ADD_FUNCTION)(child_dest, child_source); (*DATA_ADD_FUNCTION)(child_dest, child_source);
} else } else
/* child_dest and child_source are not leaf nodes */ /* child_dest and child_source are not leaf nodes */
traverse_and_intersect(child_dest, child_source); traverse_and_intersect(child_dest, child_source);
} else { } else {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
if (DATA_DESTRUCT_FUNCTION) if (DATA_DESTRUCT_FUNCTION)
(*DATA_DESTRUCT_FUNCTION)(child_dest); (*DATA_DESTRUCT_FUNCTION)(child_dest);
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE); DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
} else } else
remove_child_nodes(TrNode_child(child_dest)); remove_child_nodes(TrNode_child(child_dest));
remove_entry(child_dest); remove_entry(child_dest);
} }
child_dest = child_next; child_dest = child_next;
} }
} while (bucket_dest != first_bucket_dest); } while (bucket_dest != first_bucket_dest);
return; return;
@ -1186,19 +1186,19 @@ void traverse_and_intersect(TrNode parent_dest, TrNode parent_source) {
child_source = trie_node_check(parent_source, TrNode_entry(child_dest)); child_source = trie_node_check(parent_source, TrNode_entry(child_dest));
if (child_source) { if (child_source) {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
/* child_source is a leaf node */ /* child_source is a leaf node */
if (DATA_ADD_FUNCTION) if (DATA_ADD_FUNCTION)
(*DATA_ADD_FUNCTION)(child_dest, child_source); (*DATA_ADD_FUNCTION)(child_dest, child_source);
} else } else
/* child_dest and child_source are not leaf nodes */ /* child_dest and child_source are not leaf nodes */
traverse_and_intersect(child_dest, child_source); traverse_and_intersect(child_dest, child_source);
} else { } else {
if (IS_LEAF_TRIE_NODE(child_dest)) { if (IS_LEAF_TRIE_NODE(child_dest)) {
if (DATA_DESTRUCT_FUNCTION) if (DATA_DESTRUCT_FUNCTION)
(*DATA_DESTRUCT_FUNCTION)(child_dest); (*DATA_DESTRUCT_FUNCTION)(child_dest);
DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE); DECREMENT_ENTRIES(CURRENT_TRIE_ENGINE);
} else } else
remove_child_nodes(TrNode_child(child_dest)); remove_child_nodes(TrNode_child(child_dest));
remove_entry(child_dest); remove_entry(child_dest);
} }
child_dest = child_next; child_dest = child_next;
@ -1223,17 +1223,17 @@ YAP_Int traverse_and_count_common_entries(TrNode parent1, TrNode parent2) {
do { do {
child1 = *--bucket; child1 = *--bucket;
while (child1) { while (child1) {
/* parent2 is not a leaf node */ /* parent2 is not a leaf node */
child2 = trie_node_check(parent2, TrNode_entry(child1)); child2 = trie_node_check(parent2, TrNode_entry(child1));
if (child2) { if (child2) {
if (IS_LEAF_TRIE_NODE(child1)) if (IS_LEAF_TRIE_NODE(child1))
/* child2 is a leaf node */ /* child2 is a leaf node */
count++; count++;
else else
/* child1 and child2 are not leaf nodes */ /* child1 and child2 are not leaf nodes */
count += traverse_and_count_common_entries(child1, child2); count += traverse_and_count_common_entries(child1, child2);
} }
child1 = TrNode_next(child1); child1 = TrNode_next(child1);
} }
} while (bucket != first_bucket); } while (bucket != first_bucket);
return count; return count;
@ -1243,11 +1243,11 @@ YAP_Int traverse_and_count_common_entries(TrNode parent1, TrNode parent2) {
child2 = trie_node_check(parent2, TrNode_entry(child1)); child2 = trie_node_check(parent2, TrNode_entry(child1));
if (child2) { if (child2) {
if (IS_LEAF_TRIE_NODE(child1)) if (IS_LEAF_TRIE_NODE(child1))
/* child2 is a leaf node */ /* child2 is a leaf node */
count++; count++;
else else
/* child1 and child2 are not leaf nodes */ /* child1 and child2 are not leaf nodes */
count += traverse_and_count_common_entries(child1, child2); count += traverse_and_count_common_entries(child1, child2);
} }
child1 = TrNode_next(child1); child1 = TrNode_next(child1);
} }
@ -1329,7 +1329,7 @@ void traverse_and_save(TrNode node, FILE *file, int float_block) {
do { do {
if (*--bucket) { if (*--bucket) {
node = *bucket; node = *bucket;
traverse_and_save(node, file, float_block); traverse_and_save(node, file, float_block);
} }
} while (bucket != first_bucket); } while (bucket != first_bucket);
return; return;
@ -1356,23 +1356,23 @@ void traverse_and_save(TrNode node, FILE *file, int float_block) {
int index; int index;
for (index = 0; index <= CURRENT_INDEX; index++) for (index = 0; index <= CURRENT_INDEX; index++)
if (AUXILIARY_TERM_STACK[index] == t) if (AUXILIARY_TERM_STACK[index] == t)
break; break;
if (index > CURRENT_INDEX) { if (index > CURRENT_INDEX) {
CURRENT_INDEX = index; CURRENT_INDEX = index;
if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE) if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE)
expand_auxiliary_term_stack(); expand_auxiliary_term_stack();
AUXILIARY_TERM_STACK[CURRENT_INDEX] = t; AUXILIARY_TERM_STACK[CURRENT_INDEX] = t;
if (YAP_IsAtomTerm(t)) if (YAP_IsAtomTerm(t))
fprintf(file, UInt_FORMAT " %d %s%c ", ATOM_SAVE_MARK, index, YAP_AtomName(YAP_AtomOfTerm(t)), '\0'); fprintf(file, UInt_FORMAT " %d %s%c ", ATOM_SAVE_MARK, index, YAP_AtomName(YAP_AtomOfTerm(t)), '\0');
else /* (ApplTag & t) */ else /* (ApplTag & t) */
fprintf(file, UInt_FORMAT " %d %s " UInt_FORMAT " ", FUNCTOR_SAVE_MARK, index, fprintf(file, UInt_FORMAT " %d %s " UInt_FORMAT " ", FUNCTOR_SAVE_MARK, index,
YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & t))), YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)(~ApplTag & t))),
YAP_ArityOfFunctor((YAP_Functor)(~ApplTag & t))); YAP_ArityOfFunctor((YAP_Functor)(~ApplTag & t)));
} else } else
if (YAP_IsAtomTerm(t)) if (YAP_IsAtomTerm(t))
fprintf(file, UInt_FORMAT " %d ", ATOM_SAVE_MARK, index); fprintf(file, UInt_FORMAT " %d ", ATOM_SAVE_MARK, index);
else else
fprintf(file, UInt_FORMAT " %d ", FUNCTOR_SAVE_MARK, index); fprintf(file, UInt_FORMAT " %d ", FUNCTOR_SAVE_MARK, index);
} }
if (IS_LEAF_TRIE_NODE(node)) { if (IS_LEAF_TRIE_NODE(node)) {
fprintf(file, "- "); fprintf(file, "- ");
@ -1415,34 +1415,34 @@ void traverse_and_load(TrNode parent, FILE *file) {
int index; int index;
n = fscanf(file, "%d", &index); n = fscanf(file, "%d", &index);
if (index > CURRENT_INDEX) { if (index > CURRENT_INDEX) {
char atom[1000]; char atom[1000];
if (CURRENT_LOAD_VERSION == 2) { if (CURRENT_LOAD_VERSION == 2) {
char *ptr, ch; char *ptr, ch;
ptr = atom; ptr = atom;
fgetc(file); /* skip the first empty space */ fgetc(file); /* skip the first empty space */
while ((ch = fgetc(file))) while ((ch = fgetc(file)))
*ptr++ = ch; *ptr++ = ch;
*ptr = '\0'; *ptr = '\0';
} else if (CURRENT_LOAD_VERSION == 1) { } else if (CURRENT_LOAD_VERSION == 1) {
n = fscanf(file, "%s", atom); n = fscanf(file, "%s", atom);
} }
CURRENT_INDEX = index; CURRENT_INDEX = index;
if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE) if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE)
expand_auxiliary_term_stack(); expand_auxiliary_term_stack();
AUXILIARY_TERM_STACK[CURRENT_INDEX] = YAP_MkAtomTerm(YAP_LookupAtom(atom)); AUXILIARY_TERM_STACK[CURRENT_INDEX] = YAP_MkAtomTerm(YAP_LookupAtom(atom));
} }
t = AUXILIARY_TERM_STACK[index]; t = AUXILIARY_TERM_STACK[index];
} else if (t == FUNCTOR_SAVE_MARK) { } else if (t == FUNCTOR_SAVE_MARK) {
int index; int index;
n = fscanf(file, "%d", &index); n = fscanf(file, "%d", &index);
if (index > CURRENT_INDEX) { if (index > CURRENT_INDEX) {
char atom[1000]; char atom[1000];
int arity; int arity;
n = fscanf(file, "%s %d", atom, &arity); n = fscanf(file, "%s %d", atom, &arity);
CURRENT_INDEX = index; CURRENT_INDEX = index;
if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE) if (CURRENT_INDEX == CURRENT_AUXILIARY_TERM_STACK_SIZE)
expand_auxiliary_term_stack(); expand_auxiliary_term_stack();
AUXILIARY_TERM_STACK[CURRENT_INDEX] = ApplTag | ((YAP_Term) YAP_MkFunctor(YAP_LookupAtom(atom), arity)); AUXILIARY_TERM_STACK[CURRENT_INDEX] = ApplTag | ((YAP_Term) YAP_MkFunctor(YAP_LookupAtom(atom), arity));
} }
t = AUXILIARY_TERM_STACK[index]; t = AUXILIARY_TERM_STACK[index];
} else if (t == FLOAT_SAVE_MARK) } else if (t == FLOAT_SAVE_MARK)
@ -1473,15 +1473,15 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
if (*--bucket) { if (*--bucket) {
node = *bucket; node = *bucket;
traverse_and_print(node, arity, str, str_index, mode); traverse_and_print(node, arity, str, str_index, mode);
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1)); memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) { if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) {
/* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */ /* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */
if (str_index > 0 && str[str_index - 1] != '[') if (str_index > 0 && str[str_index - 1] != '[')
str[str_index - 1] = ','; str[str_index - 1] = ',';
/* restore possible PairEndTermTag side-effect */ /* restore possible PairEndTermTag side-effect */
if (str[last_pair_mark] == '|') if (str[last_pair_mark] == '|')
str[last_pair_mark] = ','; str[last_pair_mark] = ',';
} }
} }
} while (bucket != first_bucket); } while (bucket != first_bucket);
free(current_arity); free(current_arity);
@ -1496,10 +1496,10 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) { if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) {
/* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */ /* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */
if (str_index > 0 && str[str_index - 1] != '[') if (str_index > 0 && str[str_index - 1] != '[')
str[str_index - 1] = ','; str[str_index - 1] = ',';
/* restore possible PairEndTermTag side-effect */ /* restore possible PairEndTermTag side-effect */
if (str[last_pair_mark] == '|') if (str[last_pair_mark] == '|')
str[last_pair_mark] = ','; str[last_pair_mark] = ',';
} }
free(current_arity); free(current_arity);
} }
@ -1534,13 +1534,13 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
arity[0]--; arity[0]--;
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] == 1) { if (arity[arity[0]] == 1) {
str_index += sprintf(& str[str_index], ")"); str_index += sprintf(& str[str_index], ")");
arity[0]--; arity[0]--;
} else { } else {
if (arity[arity[0]] > 1) if (arity[arity[0]] > 1)
arity[arity[0]]--; arity[arity[0]]--;
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
break; break;
} }
} }
mode = TRIE_PRINT_NORMAL; mode = TRIE_PRINT_NORMAL;
@ -1548,39 +1548,39 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
str_index += sprintf(& str[str_index], "VAR" UInt_FORMAT, TrieVarIndex(t)); str_index += sprintf(& str[str_index], "VAR" UInt_FORMAT, TrieVarIndex(t));
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] == 1) { if (arity[arity[0]] == 1) {
str_index += sprintf(& str[str_index], ")"); str_index += sprintf(& str[str_index], ")");
arity[0]--; arity[0]--;
} else { } else {
if (arity[arity[0]] > 1) if (arity[arity[0]] > 1)
arity[arity[0]]--; arity[arity[0]]--;
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
break; break;
} }
} }
} else if (YAP_IsAtomTerm(t)) { } else if (YAP_IsAtomTerm(t)) {
str_index += sprintf(& str[str_index], "%s", YAP_AtomName(YAP_AtomOfTerm(t))); str_index += sprintf(& str[str_index], "%s", YAP_AtomName(YAP_AtomOfTerm(t)));
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] == 1) { if (arity[arity[0]] == 1) {
str_index += sprintf(& str[str_index], ")"); str_index += sprintf(& str[str_index], ")");
arity[0]--; arity[0]--;
} else { } else {
if (arity[arity[0]] > 1) if (arity[arity[0]] > 1)
arity[arity[0]]--; arity[arity[0]]--;
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
break; break;
} }
} }
} else if (YAP_IsIntTerm(t)) { } else if (YAP_IsIntTerm(t)) {
str_index += sprintf(& str[str_index], UInt_FORMAT , YAP_IntOfTerm(t)); str_index += sprintf(& str[str_index], UInt_FORMAT , YAP_IntOfTerm(t));
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] == 1) { if (arity[arity[0]] == 1) {
str_index += sprintf(& str[str_index], ")"); str_index += sprintf(& str[str_index], ")");
arity[0]--; arity[0]--;
} else { } else {
if (arity[arity[0]] > 1) if (arity[arity[0]] > 1)
arity[arity[0]]--; arity[arity[0]]--;
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
break; break;
} }
} }
} else if (YAP_IsPairTerm(t)) { } else if (YAP_IsPairTerm(t)) {
@ -1598,23 +1598,23 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
arity[arity[0]] = -1; arity[arity[0]] = -1;
} else { } else {
if (t == PairEndEmptyTag) if (t == PairEndEmptyTag)
str[str_index - 1] = ']'; str[str_index - 1] = ']';
else if (t == PairEndTermTag) { else if (t == PairEndTermTag) {
str[last_pair_mark] = '|'; str[last_pair_mark] = '|';
str[str_index - 1] = ']'; str[str_index - 1] = ']';
} else /* (t == CommaEndTag) */ } else /* (t == CommaEndTag) */
str[str_index - 1] = ')'; str[str_index - 1] = ')';
arity[0]--; arity[0]--;
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] == 1) { if (arity[arity[0]] == 1) {
str_index += sprintf(& str[str_index], ")"); str_index += sprintf(& str[str_index], ")");
arity[0]--; arity[0]--;
} else { } else {
if (arity[arity[0]] > 1) if (arity[arity[0]] > 1)
arity[arity[0]]--; arity[arity[0]]--;
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
break; break;
} }
} }
} }
} else if (ApplTag & t) { } else if (ApplTag & t) {

4
pl/messages.yap
View File

@ -404,8 +404,10 @@ domain_error(delete_file_option, Opt) --> !,
[ 'invalid list of options ~w' - [Opt] ]. [ 'invalid list of options ~w' - [Opt] ].
domain_error(encoding, Opt) --> !, domain_error(encoding, Opt) --> !,
[ 'invalid encoding ~w' - [Opt] ]. [ 'invalid encoding ~w' - [Opt] ].
domain_error(flag_value, [Opt,Flag]) --> !,
[ 'invalid value ~w for flag ~w' - [Opt,Flag] ].
domain_error(flag_value, Opt) --> !, domain_error(flag_value, Opt) --> !,
[ 'invalid value ~w for flag ~w' - [Opt] ]. [ 'invalid value ~w for flag' - [Opt] ].
domain_error(io_mode, Opt) --> !, domain_error(io_mode, Opt) --> !,
[ 'invalid io mode ~w' - [Opt] ]. [ 'invalid io mode ~w' - [Opt] ].
domain_error(mutable, Opt) --> !, domain_error(mutable, Opt) --> !,