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

support for trie compact lists (version 2): this new version uses 

different marks to distinguish the lists ending with the empty list
from the lists ending with a non-empty list term.
This commit is contained in:
Ricardo Rocha 2009-07-05 05:14:08 +01:00
parent 6f2d5679c6
commit 5e4d7078ab
11 changed files with 748 additions and 751 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
C/absmi.c
View File

@ -1883,24 +1883,34 @@ Yap_absmi(int inp)
case _table_answer_resolution: case _table_answer_resolution:
low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL);
break; break;
case _trie_retry_null:
case _trie_trust_null: case _trie_trust_null:
case _trie_retry_var: case _trie_retry_null:
case _trie_trust_null_in_new_pair:
case _trie_retry_null_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_retry_val: case _trie_retry_var:
case _trie_trust_var_in_new_pair:
case _trie_retry_var_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_retry_atom: case _trie_retry_val:
case _trie_trust_val_in_new_pair:
case _trie_retry_val_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_retry_list: case _trie_retry_atom:
case _trie_trust_list: case _trie_trust_atom_in_new_pair:
case _trie_retry_struct: case _trie_retry_atom_in_new_pair:
case _trie_trust_pair:
case _trie_retry_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_retry_extension: case _trie_retry_struct:
case _trie_trust_struct_in_new_pair:
case _trie_retry_struct_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_retry_float: case _trie_retry_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_retry_long: case _trie_retry_float:
case _trie_trust_long: case _trie_trust_long:
case _trie_retry_long:
low_level_trace(retry_table_loader, UndefCode, NULL); low_level_trace(retry_table_loader, UndefCode, NULL);
break; break;
#endif /* TABLING */ #endif /* TABLING */

60
C/cdmgr.c
View File

@ -558,24 +558,34 @@ PredForChoicePt(yamop *p_code) {
case _profiled_trust_logical: case _profiled_trust_logical:
return p_code->u.OtaLl.d->ClPred; return p_code->u.OtaLl.d->ClPred;
#ifdef TABLING #ifdef TABLING
case _trie_retry_null:
case _trie_trust_null: case _trie_trust_null:
case _trie_retry_var: case _trie_retry_null:
case _trie_trust_null_in_new_pair:
case _trie_retry_null_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_retry_val: case _trie_retry_var:
case _trie_trust_var_in_new_pair:
case _trie_retry_var_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_retry_atom: case _trie_retry_val:
case _trie_trust_val_in_new_pair:
case _trie_retry_val_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_retry_list: case _trie_retry_atom:
case _trie_trust_list: case _trie_trust_atom_in_new_pair:
case _trie_retry_struct: case _trie_retry_atom_in_new_pair:
case _trie_trust_pair:
case _trie_retry_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_retry_extension: case _trie_retry_struct:
case _trie_trust_struct_in_new_pair:
case _trie_retry_struct_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_retry_float: case _trie_retry_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_retry_long: case _trie_retry_float:
case _trie_trust_long: case _trie_trust_long:
case _trie_retry_long:
return NULL; return NULL;
case _table_load_answer: case _table_load_answer:
case _table_try_answer: case _table_try_answer:
@ -5415,24 +5425,34 @@ p_choicepoint_info(void)
#endif #endif
t = MkVarTerm(); t = MkVarTerm();
break; break;
case _trie_retry_null:
case _trie_trust_null: case _trie_trust_null:
case _trie_retry_var: case _trie_retry_null:
case _trie_trust_null_in_new_pair:
case _trie_retry_null_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_retry_val: case _trie_retry_var:
case _trie_trust_var_in_new_pair:
case _trie_retry_var_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_retry_atom: case _trie_retry_val:
case _trie_trust_val_in_new_pair:
case _trie_retry_val_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_retry_list: case _trie_retry_atom:
case _trie_trust_list: case _trie_trust_atom_in_new_pair:
case _trie_retry_struct: case _trie_retry_atom_in_new_pair:
case _trie_trust_pair:
case _trie_retry_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_retry_extension: case _trie_retry_struct:
case _trie_trust_struct_in_new_pair:
case _trie_retry_struct_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_retry_float: case _trie_retry_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_retry_long: case _trie_retry_float:
case _trie_trust_long: case _trie_trust_long:
case _trie_retry_long:
pe = UndefCode; pe = UndefCode;
t = MkVarTerm(); t = MkVarTerm();
break; break;

60
C/heapgc.c
View File

@ -2065,24 +2065,34 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
} }
nargs = 0; nargs = 0;
break; break;
case _trie_retry_null:
case _trie_trust_null: case _trie_trust_null:
case _trie_retry_var: case _trie_retry_null:
case _trie_trust_null_in_new_pair:
case _trie_retry_null_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_retry_val: case _trie_retry_var:
case _trie_trust_var_in_new_pair:
case _trie_retry_var_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_retry_atom: case _trie_retry_val:
case _trie_trust_val_in_new_pair:
case _trie_retry_val_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_retry_list: case _trie_retry_atom:
case _trie_trust_list: case _trie_trust_atom_in_new_pair:
case _trie_retry_struct: case _trie_retry_atom_in_new_pair:
case _trie_trust_pair:
case _trie_retry_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_retry_extension: case _trie_retry_struct:
case _trie_trust_struct_in_new_pair:
case _trie_retry_struct_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_retry_float: case _trie_retry_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_retry_long: case _trie_retry_float:
case _trie_trust_long: case _trie_trust_long:
case _trie_retry_long:
{ {
CELL *vars_ptr; CELL *vars_ptr;
int heap_arity, vars_arity, subs_arity; int heap_arity, vars_arity, subs_arity;
@ -2945,24 +2955,34 @@ sweep_choicepoints(choiceptr gc_B)
} }
} }
break; break;
case _trie_retry_null:
case _trie_trust_null: case _trie_trust_null:
case _trie_retry_var: case _trie_retry_null:
case _trie_trust_null_in_new_pair:
case _trie_retry_null_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_retry_val: case _trie_retry_var:
case _trie_trust_var_in_new_pair:
case _trie_retry_var_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_retry_atom: case _trie_retry_val:
case _trie_trust_val_in_new_pair:
case _trie_retry_val_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_retry_list: case _trie_retry_atom:
case _trie_trust_list: case _trie_trust_atom_in_new_pair:
case _trie_retry_struct: case _trie_retry_atom_in_new_pair:
case _trie_trust_pair:
case _trie_retry_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_retry_extension: case _trie_retry_struct:
case _trie_trust_struct_in_new_pair:
case _trie_retry_struct_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_retry_float: case _trie_retry_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_retry_long: case _trie_retry_float:
case _trie_trust_long: case _trie_trust_long:
case _trie_retry_long:
{ {
CELL *vars_ptr; CELL *vars_ptr;
int heap_arity, vars_arity, subs_arity; int heap_arity, vars_arity, subs_arity;

28
C/index.c
View File

@ -1069,26 +1069,46 @@ has_cut(yamop *pc)
case _trie_trust_null: case _trie_trust_null:
case _trie_try_null: case _trie_try_null:
case _trie_retry_null: case _trie_retry_null:
case _trie_do_null_in_new_pair:
case _trie_trust_null_in_new_pair:
case _trie_try_null_in_new_pair:
case _trie_retry_null_in_new_pair:
case _trie_do_var: case _trie_do_var:
case _trie_trust_var: case _trie_trust_var:
case _trie_try_var: case _trie_try_var:
case _trie_retry_var: case _trie_retry_var:
case _trie_do_var_in_new_pair:
case _trie_trust_var_in_new_pair:
case _trie_try_var_in_new_pair:
case _trie_retry_var_in_new_pair:
case _trie_do_val: case _trie_do_val:
case _trie_trust_val: case _trie_trust_val:
case _trie_try_val: case _trie_try_val:
case _trie_retry_val: case _trie_retry_val:
case _trie_do_val_in_new_pair:
case _trie_trust_val_in_new_pair:
case _trie_try_val_in_new_pair:
case _trie_retry_val_in_new_pair:
case _trie_do_atom: case _trie_do_atom:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_try_atom: case _trie_try_atom:
case _trie_retry_atom: case _trie_retry_atom:
case _trie_do_list: case _trie_do_atom_in_new_pair:
case _trie_trust_list: case _trie_trust_atom_in_new_pair:
case _trie_try_list: case _trie_try_atom_in_new_pair:
case _trie_retry_list: case _trie_retry_atom_in_new_pair:
case _trie_do_pair:
case _trie_trust_pair:
case _trie_try_pair:
case _trie_retry_pair:
case _trie_do_struct: case _trie_do_struct:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_try_struct: case _trie_try_struct:
case _trie_retry_struct: case _trie_retry_struct:
case _trie_do_struct_in_new_pair:
case _trie_trust_struct_in_new_pair:
case _trie_try_struct_in_new_pair:
case _trie_retry_struct_in_new_pair:
case _trie_do_extension: case _trie_do_extension:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_try_extension: case _trie_try_extension:

52
H/YapOpcodes.h
View File

@ -345,50 +345,46 @@
OPCODE(trie_trust_null ,e), OPCODE(trie_trust_null ,e),
OPCODE(trie_try_null ,e), OPCODE(trie_try_null ,e),
OPCODE(trie_retry_null ,e), OPCODE(trie_retry_null ,e),
OPCODE(trie_do_null_in_new_list ,e), OPCODE(trie_do_null_in_new_pair ,e),
OPCODE(trie_trust_null_in_new_list,e), OPCODE(trie_trust_null_in_new_pair,e),
OPCODE(trie_try_null_in_new_list ,e), OPCODE(trie_try_null_in_new_pair ,e),
OPCODE(trie_retry_null_in_new_list,e), OPCODE(trie_retry_null_in_new_pair,e),
OPCODE(trie_do_var ,e), OPCODE(trie_do_var ,e),
OPCODE(trie_trust_var ,e), OPCODE(trie_trust_var ,e),
OPCODE(trie_try_var ,e), OPCODE(trie_try_var ,e),
OPCODE(trie_retry_var ,e), OPCODE(trie_retry_var ,e),
OPCODE(trie_do_var_in_new_list ,e), OPCODE(trie_do_var_in_new_pair ,e),
OPCODE(trie_trust_var_in_new_list ,e), OPCODE(trie_trust_var_in_new_pair ,e),
OPCODE(trie_try_var_in_new_list ,e), OPCODE(trie_try_var_in_new_pair ,e),
OPCODE(trie_retry_var_in_new_list ,e), OPCODE(trie_retry_var_in_new_pair ,e),
OPCODE(trie_do_val ,e), OPCODE(trie_do_val ,e),
OPCODE(trie_trust_val ,e), OPCODE(trie_trust_val ,e),
OPCODE(trie_try_val ,e), OPCODE(trie_try_val ,e),
OPCODE(trie_retry_val ,e), OPCODE(trie_retry_val ,e),
OPCODE(trie_do_val_in_new_list ,e), OPCODE(trie_do_val_in_new_pair ,e),
OPCODE(trie_trust_val_in_new_list ,e), OPCODE(trie_trust_val_in_new_pair ,e),
OPCODE(trie_try_val_in_new_list ,e), OPCODE(trie_try_val_in_new_pair ,e),
OPCODE(trie_retry_val_in_new_list ,e), OPCODE(trie_retry_val_in_new_pair ,e),
OPCODE(trie_do_atom ,e), OPCODE(trie_do_atom ,e),
OPCODE(trie_trust_atom ,e), OPCODE(trie_trust_atom ,e),
OPCODE(trie_try_atom ,e), OPCODE(trie_try_atom ,e),
OPCODE(trie_retry_atom ,e), OPCODE(trie_retry_atom ,e),
OPCODE(trie_do_atom_in_new_list ,e), OPCODE(trie_do_atom_in_new_pair ,e),
OPCODE(trie_trust_atom_in_new_list,e), OPCODE(trie_trust_atom_in_new_pair,e),
OPCODE(trie_try_atom_in_new_list ,e), OPCODE(trie_try_atom_in_new_pair ,e),
OPCODE(trie_retry_atom_in_new_list,e), OPCODE(trie_retry_atom_in_new_pair,e),
OPCODE(trie_do_list ,e), OPCODE(trie_do_pair ,e),
OPCODE(trie_trust_list ,e), OPCODE(trie_trust_pair ,e),
OPCODE(trie_try_list ,e), OPCODE(trie_try_pair ,e),
OPCODE(trie_retry_list ,e), OPCODE(trie_retry_pair ,e),
OPCODE(trie_do_list_in_new_list ,e),
OPCODE(trie_trust_list_in_new_list,e),
OPCODE(trie_try_list_in_new_list ,e),
OPCODE(trie_retry_list_in_new_list,e),
OPCODE(trie_do_struct ,e), OPCODE(trie_do_struct ,e),
OPCODE(trie_trust_struct ,e), OPCODE(trie_trust_struct ,e),
OPCODE(trie_try_struct ,e), OPCODE(trie_try_struct ,e),
OPCODE(trie_retry_struct ,e), OPCODE(trie_retry_struct ,e),
OPCODE(trie_do_struct_in_new_list ,e), OPCODE(trie_do_struct_in_new_pair ,e),
OPCODE(trie_trust_struct_in_new_list,e), OPCODE(trie_trust_struct_in_new_pair,e),
OPCODE(trie_try_struct_in_new_list,e), OPCODE(trie_try_struct_in_new_pair,e),
OPCODE(trie_retry_struct_in_new_list,e), OPCODE(trie_retry_struct_in_new_pair,e),
OPCODE(trie_do_extension ,e), OPCODE(trie_do_extension ,e),
OPCODE(trie_trust_extension ,e), OPCODE(trie_trust_extension ,e),
OPCODE(trie_try_extension ,e), OPCODE(trie_try_extension ,e),

52
H/rclause.h
View File

@ -793,65 +793,61 @@ restore_opcodes(yamop *pc)
break; break;
/* instructions type e */ /* instructions type e */
case _trie_do_atom: case _trie_do_atom:
case _trie_do_atom_in_new_list: case _trie_do_atom_in_new_pair:
case _trie_do_extension: case _trie_do_extension:
case _trie_do_float: case _trie_do_float:
case _trie_do_list:
case _trie_do_list_in_new_list:
case _trie_do_long: case _trie_do_long:
case _trie_do_null: case _trie_do_null:
case _trie_do_null_in_new_list: case _trie_do_null_in_new_pair:
case _trie_do_pair:
case _trie_do_struct: case _trie_do_struct:
case _trie_do_struct_in_new_list: case _trie_do_struct_in_new_pair:
case _trie_do_val: case _trie_do_val:
case _trie_do_val_in_new_list: case _trie_do_val_in_new_pair:
case _trie_do_var: case _trie_do_var:
case _trie_do_var_in_new_list: case _trie_do_var_in_new_pair:
case _trie_retry_atom: case _trie_retry_atom:
case _trie_retry_atom_in_new_list: case _trie_retry_atom_in_new_pair:
case _trie_retry_extension: case _trie_retry_extension:
case _trie_retry_float: case _trie_retry_float:
case _trie_retry_list:
case _trie_retry_list_in_new_list:
case _trie_retry_long: case _trie_retry_long:
case _trie_retry_null: case _trie_retry_null:
case _trie_retry_null_in_new_list: case _trie_retry_null_in_new_pair:
case _trie_retry_pair:
case _trie_retry_struct: case _trie_retry_struct:
case _trie_retry_struct_in_new_list: case _trie_retry_struct_in_new_pair:
case _trie_retry_val: case _trie_retry_val:
case _trie_retry_val_in_new_list: case _trie_retry_val_in_new_pair:
case _trie_retry_var: case _trie_retry_var:
case _trie_retry_var_in_new_list: case _trie_retry_var_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_trust_atom_in_new_list: case _trie_trust_atom_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_trust_list:
case _trie_trust_list_in_new_list:
case _trie_trust_long: case _trie_trust_long:
case _trie_trust_null: case _trie_trust_null:
case _trie_trust_null_in_new_list: case _trie_trust_null_in_new_pair:
case _trie_trust_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_trust_struct_in_new_list: case _trie_trust_struct_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_trust_val_in_new_list: case _trie_trust_val_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_trust_var_in_new_list: case _trie_trust_var_in_new_pair:
case _trie_try_atom: case _trie_try_atom:
case _trie_try_atom_in_new_list: case _trie_try_atom_in_new_pair:
case _trie_try_extension: case _trie_try_extension:
case _trie_try_float: case _trie_try_float:
case _trie_try_list:
case _trie_try_list_in_new_list:
case _trie_try_long: case _trie_try_long:
case _trie_try_null: case _trie_try_null:
case _trie_try_null_in_new_list: case _trie_try_null_in_new_pair:
case _trie_try_pair:
case _trie_try_struct: case _trie_try_struct:
case _trie_try_struct_in_new_list: case _trie_try_struct_in_new_pair:
case _trie_try_val: case _trie_try_val:
case _trie_try_val_in_new_list: case _trie_try_val_in_new_pair:
case _trie_try_var: case _trie_try_var:
case _trie_try_var_in_new_list: case _trie_try_var_in_new_pair:
if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return; if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return;
pc = NEXTOP(pc,e); pc = NEXTOP(pc,e);
break; break;

52
H/walkclause.h
View File

@ -612,65 +612,61 @@
break; break;
/* instructions type e */ /* instructions type e */
case _trie_do_atom: case _trie_do_atom:
case _trie_do_atom_in_new_list: case _trie_do_atom_in_new_pair:
case _trie_do_extension: case _trie_do_extension:
case _trie_do_float: case _trie_do_float:
case _trie_do_list:
case _trie_do_list_in_new_list:
case _trie_do_long: case _trie_do_long:
case _trie_do_null: case _trie_do_null:
case _trie_do_null_in_new_list: case _trie_do_null_in_new_pair:
case _trie_do_pair:
case _trie_do_struct: case _trie_do_struct:
case _trie_do_struct_in_new_list: case _trie_do_struct_in_new_pair:
case _trie_do_val: case _trie_do_val:
case _trie_do_val_in_new_list: case _trie_do_val_in_new_pair:
case _trie_do_var: case _trie_do_var:
case _trie_do_var_in_new_list: case _trie_do_var_in_new_pair:
case _trie_retry_atom: case _trie_retry_atom:
case _trie_retry_atom_in_new_list: case _trie_retry_atom_in_new_pair:
case _trie_retry_extension: case _trie_retry_extension:
case _trie_retry_float: case _trie_retry_float:
case _trie_retry_list:
case _trie_retry_list_in_new_list:
case _trie_retry_long: case _trie_retry_long:
case _trie_retry_null: case _trie_retry_null:
case _trie_retry_null_in_new_list: case _trie_retry_null_in_new_pair:
case _trie_retry_pair:
case _trie_retry_struct: case _trie_retry_struct:
case _trie_retry_struct_in_new_list: case _trie_retry_struct_in_new_pair:
case _trie_retry_val: case _trie_retry_val:
case _trie_retry_val_in_new_list: case _trie_retry_val_in_new_pair:
case _trie_retry_var: case _trie_retry_var:
case _trie_retry_var_in_new_list: case _trie_retry_var_in_new_pair:
case _trie_trust_atom: case _trie_trust_atom:
case _trie_trust_atom_in_new_list: case _trie_trust_atom_in_new_pair:
case _trie_trust_extension: case _trie_trust_extension:
case _trie_trust_float: case _trie_trust_float:
case _trie_trust_list:
case _trie_trust_list_in_new_list:
case _trie_trust_long: case _trie_trust_long:
case _trie_trust_null: case _trie_trust_null:
case _trie_trust_null_in_new_list: case _trie_trust_null_in_new_pair:
case _trie_trust_pair:
case _trie_trust_struct: case _trie_trust_struct:
case _trie_trust_struct_in_new_list: case _trie_trust_struct_in_new_pair:
case _trie_trust_val: case _trie_trust_val:
case _trie_trust_val_in_new_list: case _trie_trust_val_in_new_pair:
case _trie_trust_var: case _trie_trust_var:
case _trie_trust_var_in_new_list: case _trie_trust_var_in_new_pair:
case _trie_try_atom: case _trie_try_atom:
case _trie_try_atom_in_new_list: case _trie_try_atom_in_new_pair:
case _trie_try_extension: case _trie_try_extension:
case _trie_try_float: case _trie_try_float:
case _trie_try_list:
case _trie_try_list_in_new_list:
case _trie_try_long: case _trie_try_long:
case _trie_try_null: case _trie_try_null:
case _trie_try_null_in_new_list: case _trie_try_null_in_new_pair:
case _trie_try_pair:
case _trie_try_struct: case _trie_try_struct:
case _trie_try_struct_in_new_list: case _trie_try_struct_in_new_pair:
case _trie_try_val: case _trie_try_val:
case _trie_try_val_in_new_list: case _trie_try_val_in_new_pair:
case _trie_try_var: case _trie_try_var:
case _trie_try_var_in_new_list: case _trie_try_var_in_new_pair:
pc = NEXTOP(pc,e); pc = NEXTOP(pc,e);
break; break;
#endif #endif

6
OPTYap/opt.config.h
View File

@ -50,9 +50,9 @@
/* #define INCOMPLETE_TABLING 1 */ /* #define INCOMPLETE_TABLING 1 */
/* ------------------------------------------------ ** /* ------------------------------------------------ **
** support trie compact lists? (optional) ** ** support trie compact pairs? (optional) **
** ------------------------------------------------ */ ** ------------------------------------------------ */
/* #define TRIE_COMPACT_LISTS 1 */ #define TRIE_COMPACT_PAIRS 1
/* --------------------------------------------------- ** /* --------------------------------------------------- **
** support deterministic tabling? (optional) ** ** support deterministic tabling? (optional) **
@ -222,7 +222,7 @@
#undef BBREG_TRAIL_SCHEME #undef BBREG_TRAIL_SCHEME
#undef LIMIT_TABLING #undef LIMIT_TABLING
#undef INCOMPLETE_TABLING #undef INCOMPLETE_TABLING
#undef TRIE_COMPACT_LISTS #undef TRIE_COMPACT_PAIRS
#undef DETERMINISTIC_TABLING #undef DETERMINISTIC_TABLING
#undef TABLING_ERRORS #undef TABLING_ERRORS
#endif /* !TABLING */ #endif /* !TABLING */

11
OPTYap/tab.macros.h
View File

@ -118,11 +118,12 @@ STD_PROTO(static inline tg_sol_fr_ptr CUT_prune_tg_solution_frames, (tg_sol_fr_p
#define IsTableVarTerm(TERM) \ #define IsTableVarTerm(TERM) \
((CELL) TERM) >= GLOBAL_table_var_enumerator(0) && \ ((CELL) TERM) >= GLOBAL_table_var_enumerator(0) && \
((CELL) TERM) <= GLOBAL_table_var_enumerator(MAX_TABLE_VARS - 1) ((CELL) TERM) <= GLOBAL_table_var_enumerator(MAX_TABLE_VARS - 1)
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
#define PairTermMark NULL #define PairTermMark NULL
#define PairTermInit ((Term *) 0) #define CompactPairInit AbsPair((Term *) 0)
#define PairTermLast ((Term *) (LowTagBits + 1)) #define CompactPairEndTerm AbsPair((Term *) (LowTagBits + 1))
#endif /* TRIE_COMPACT_LISTS */ #define CompactPairEndList AbsPair((Term *) (2*(LowTagBits + 1)))
#endif /* TRIE_COMPACT_PAIRS */
#define HASH_TABLE_LOCK(NODE) ((((unsigned long int)NODE) >> 5) & (TABLE_LOCK_BUCKETS - 1)) #define HASH_TABLE_LOCK(NODE) ((((unsigned long int)NODE) >> 5) & (TABLE_LOCK_BUCKETS - 1))
#define LOCK_TABLE(NODE) LOCK(GLOBAL_table_lock(HASH_TABLE_LOCK(NODE))) #define LOCK_TABLE(NODE) LOCK(GLOBAL_table_lock(HASH_TABLE_LOCK(NODE)))

276
OPTYap/tab.tries.c
View File

@ -695,9 +695,9 @@ sg_fr_ptr subgoal_search(yamop *preg, CELL **Yaddr) {
#endif /* TABLE_LOCK_LEVEL */ #endif /* TABLE_LOCK_LEVEL */
for (i = 1; i <= arity; i++) { for (i = 1; i <= arity; i++) {
STACK_CHECK_EXPAND(stack_terms, stack_terms_limit, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_terms_limit, stack_terms_base);
STACK_PUSH_UP(XREGS[i], stack_terms); STACK_PUSH_UP(Deref(XREGS[i]), stack_terms);
do { do {
Term t = Deref(STACK_POP_DOWN(stack_terms)); Term t = STACK_POP_DOWN(stack_terms);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
if (IsTableVarTerm(t)) { if (IsTableVarTerm(t)) {
t = MakeTableVarTerm(VarIndexOfTerm(t)); t = MakeTableVarTerm(VarIndexOfTerm(t));
@ -714,35 +714,45 @@ sg_fr_ptr subgoal_search(yamop *preg, CELL **Yaddr) {
} else if (IsAtomOrIntTerm(t)) { } else if (IsAtomOrIntTerm(t)) {
current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, t); current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, t);
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
CELL *aux = RepPair(t); CELL *aux = RepPair(t);
if (aux == PairTermMark) { if (aux == PairTermMark) {
t = Deref(STACK_POP_DOWN(stack_terms)); t = STACK_POP_DOWN(stack_terms);
if (IsPairTerm(t)) { if (IsPairTerm(t)) {
aux = RepPair(t); aux = RepPair(t);
/* STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2, stack_terms_base); */ t = Deref(*(aux + 1));
/* STACK_CHECK_EXPAND is not necessary here because the situation of pushing ** if (t == TermNil) {
** up 3 terms has already initially checked for the PairTermInit term */ current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, CompactPairEndList);
STACK_PUSH_UP(*(aux + 1), stack_terms); } else {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); /* STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2, stack_terms_base); */
STACK_PUSH_UP(*(aux), stack_terms); /* STACK_CHECK_EXPAND is not necessary here because the situation of pushing **
** up 3 terms has already initially checked for the CompactPairInit term */
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
}
STACK_PUSH_UP(Deref(*aux), stack_terms);
} else { } else {
current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, AbsPair(PairTermLast)); current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, CompactPairEndTerm);
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(t, stack_terms);
} }
} else { } else {
current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, AbsPair(PairTermInit)); current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, CompactPairInit);
STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2, stack_terms_base); t = Deref(*(aux + 1));
STACK_PUSH_UP(*(aux + 1), stack_terms); if (t == TermNil) {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, CompactPairEndList);
STACK_PUSH_UP(*(aux), stack_terms); } else {
STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 2, stack_terms_base);
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
}
STACK_PUSH_UP(Deref(*aux), stack_terms);
} }
#else #else
current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, AbsPair(NULL)); current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, AbsPair(NULL));
STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 1, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + 1, stack_terms_base);
STACK_PUSH_UP(*(RepPair(t) + 1), stack_terms); STACK_PUSH_UP(Deref(*(RepPair(t) + 1)), stack_terms);
STACK_PUSH_UP(*(RepPair(t)), stack_terms); STACK_PUSH_UP(Deref(*(RepPair(t))), stack_terms);
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, AbsAppl((Term *)f)); current_sg_node = subgoal_trie_node_check_insert(tab_ent, current_sg_node, AbsAppl((Term *)f));
@ -763,7 +773,7 @@ sg_fr_ptr subgoal_search(yamop *preg, CELL **Yaddr) {
} else { } else {
STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + ArityOfFunctor(f) - 1, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_terms_limit + ArityOfFunctor(f) - 1, stack_terms_base);
for (j = ArityOfFunctor(f); j >= 1; j--) for (j = ArityOfFunctor(f); j >= 1; j--)
STACK_PUSH_UP(*(RepAppl(t) + j), stack_terms); STACK_PUSH_UP(Deref(*(RepAppl(t) + j)), stack_terms);
} }
} else { } else {
Yap_Error(INTERNAL_ERROR, TermNil, "unknown type tag (subgoal_search)"); Yap_Error(INTERNAL_ERROR, TermNil, "unknown type tag (subgoal_search)");
@ -811,11 +821,11 @@ ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
int i, j, count_vars, subs_arity; int i, j, count_vars, subs_arity;
CELL *stack_vars, *stack_terms_base, *stack_terms; CELL *stack_vars, *stack_terms_base, *stack_terms;
ans_node_ptr current_ans_node; ans_node_ptr current_ans_node;
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
int in_new_list = 0; int in_new_pair = 0;
#else #else
#define in_new_list 0 #define in_new_pair 0
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
count_vars = 0; count_vars = 0;
subs_arity = *subs_ptr; subs_arity = *subs_ptr;
@ -825,17 +835,18 @@ ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
for (i = subs_arity; i >= 1; i--) { for (i = subs_arity; i >= 1; i--) {
STACK_CHECK_EXPAND(stack_terms, stack_vars, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_vars, stack_terms_base);
STACK_PUSH_UP(*(subs_ptr + i), stack_terms); STACK_PUSH_UP(Deref(*(subs_ptr + i)), stack_terms);
#ifdef TABLING_ERRORS #ifdef TABLING_ERRORS
if (IsNonVarTerm(*stack_terms)) if (IsNonVarTerm(*stack_terms))
TABLING_ERROR_MESSAGE("IsNonVarTem(*stack_terms) (answer_search)"); TABLING_ERROR_MESSAGE("IsNonVarTem(*stack_terms) (answer_search)");
#endif /* TABLING_ERRORS */ #endif /* TABLING_ERRORS */
do { do {
Term t = Deref(STACK_POP_DOWN(stack_terms)); Term t = STACK_POP_DOWN(stack_terms);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
t = Deref(t);
if (IsTableVarTerm(t)) { if (IsTableVarTerm(t)) {
t = MakeTableVarTerm(VarIndexOfTerm(t)); t = MakeTableVarTerm(VarIndexOfTerm(t));
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, t, _trie_retry_val + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, t, _trie_retry_val + in_new_pair);
} else { } else {
if (count_vars == MAX_TABLE_VARS) if (count_vars == MAX_TABLE_VARS)
Yap_Error(INTERNAL_ERROR, TermNil, "MAX_TABLE_VARS exceeded (answer_search)"); Yap_Error(INTERNAL_ERROR, TermNil, "MAX_TABLE_VARS exceeded (answer_search)");
@ -843,54 +854,65 @@ ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
*((CELL *)t) = GLOBAL_table_var_enumerator(count_vars); *((CELL *)t) = GLOBAL_table_var_enumerator(count_vars);
t = MakeTableVarTerm(count_vars); t = MakeTableVarTerm(count_vars);
count_vars++; count_vars++;
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, t, _trie_retry_var + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, t, _trie_retry_var + in_new_pair);
} }
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
in_new_list = 0; in_new_pair = 0;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else if (IsAtomOrIntTerm(t)) { } else if (IsAtomOrIntTerm(t)) {
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, t, _trie_retry_atom + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, t, _trie_retry_atom + in_new_pair);
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
in_new_list = 0; in_new_pair = 0;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
CELL *aux = RepPair(t); CELL *aux = RepPair(t);
if (aux == PairTermMark) { if (aux == PairTermMark) {
t = Deref(STACK_POP_DOWN(stack_terms)); t = STACK_POP_DOWN(stack_terms);
if (IsPairTerm(t)) { if (IsPairTerm(t)) {
aux = RepPair(t); aux = RepPair(t);
/* STACK_CHECK_EXPAND(stack_terms, stack_vars + 2, stack_terms_base); */ t = Deref(*(aux + 1));
/* STACK_CHECK_EXPAND is not necessary here because the situation of pushing ** if (t == TermNil) {
** up 3 terms has already initially checked for the PairTermInit term */ current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, CompactPairEndList, _trie_retry_pair);
STACK_PUSH_UP(*(aux + 1), stack_terms); } else {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); /* STACK_CHECK_EXPAND(stack_terms, stack_vars + 2, stack_terms_base); */
STACK_PUSH_UP(*(aux), stack_terms); /* STACK_CHECK_EXPAND is not necessary here because the situation of pushing **
in_new_list = 4; ** up 3 terms has already initially checked for the CompactPairInit term */
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
in_new_pair = 4;
}
STACK_PUSH_UP(Deref(*aux), stack_terms);
} else { } else {
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsPair(PairTermLast), _trie_retry_null); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, CompactPairEndTerm, _trie_retry_null);
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(t, stack_terms);
} }
} else { } else {
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsPair(PairTermInit), _trie_retry_list + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, CompactPairInit, _trie_retry_null + in_new_pair);
STACK_CHECK_EXPAND(stack_terms, stack_vars + 2, stack_terms_base); t = Deref(*(aux + 1));
STACK_PUSH_UP(*(aux + 1), stack_terms); if (t == TermNil) {
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, CompactPairEndList, _trie_retry_pair);
STACK_PUSH_UP(*(aux), stack_terms); in_new_pair = 0;
in_new_list = 0; } else {
STACK_CHECK_EXPAND(stack_terms, stack_vars + 2, stack_terms_base);
STACK_PUSH_UP(t, stack_terms);
STACK_PUSH_UP(AbsPair(PairTermMark), stack_terms);
in_new_pair = 4;
}
STACK_PUSH_UP(Deref(*aux), stack_terms);
} }
#else #else
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsPair(NULL), _trie_retry_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsPair(NULL), _trie_retry_pair);
STACK_CHECK_EXPAND(stack_terms, stack_vars + 1, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_vars + 1, stack_terms_base);
STACK_PUSH_UP(*(RepPair(t) + 1), stack_terms); STACK_PUSH_UP(Deref(*(RepPair(t) + 1)), stack_terms);
STACK_PUSH_UP(*(RepPair(t)), stack_terms); STACK_PUSH_UP(Deref(*(RepPair(t))), stack_terms);
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (f == FunctorDouble) { if (f == FunctorDouble) {
volatile Float dbl = FloatOfTerm(t); volatile Float dbl = FloatOfTerm(t);
volatile Term *t_dbl = (Term *)((void *) &dbl); volatile Term *t_dbl = (Term *)((void *) &dbl);
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_null + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_null + in_new_pair);
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, *(t_dbl + 1), _trie_retry_extension); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, *(t_dbl + 1), _trie_retry_extension);
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */ #endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
@ -898,7 +920,7 @@ ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_float); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_float);
} else if (f == FunctorLongInt) { } else if (f == FunctorLongInt) {
Int li = LongIntOfTerm (t); Int li = LongIntOfTerm (t);
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_null + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_null + in_new_pair);
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, li, _trie_retry_extension); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, li, _trie_retry_extension);
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_long); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_long);
} else if (f == FunctorDBRef) { } else if (f == FunctorDBRef) {
@ -906,14 +928,14 @@ ans_node_ptr answer_search(sg_fr_ptr sg_fr, CELL *subs_ptr) {
} else if (f == FunctorBigInt) { } else if (f == FunctorBigInt) {
Yap_Error(INTERNAL_ERROR, TermNil, "unsupported type tag (FunctorBigInt in answer_search)"); Yap_Error(INTERNAL_ERROR, TermNil, "unsupported type tag (FunctorBigInt in answer_search)");
} else { } else {
current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_struct + in_new_list); current_ans_node = answer_trie_node_check_insert(sg_fr, current_ans_node, AbsAppl((Term *)f), _trie_retry_struct + in_new_pair);
STACK_CHECK_EXPAND(stack_terms, stack_vars + ArityOfFunctor(f) - 1, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_vars + ArityOfFunctor(f) - 1, stack_terms_base);
for (j = ArityOfFunctor(f); j >= 1; j--) for (j = ArityOfFunctor(f); j >= 1; j--)
STACK_PUSH_UP(*(RepAppl(t) + j), stack_terms); STACK_PUSH_UP(Deref(*(RepAppl(t) + j)), stack_terms);
} }
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
in_new_list = 0; in_new_pair = 0;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else { } else {
Yap_Error(INTERNAL_ERROR, TermNil, "unknown type tag (answer_search)"); Yap_Error(INTERNAL_ERROR, TermNil, "unknown type tag (answer_search)");
} }
@ -934,9 +956,9 @@ void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr) {
CELL *stack_vars_base, *stack_vars, *stack_terms_base, *stack_terms; CELL *stack_vars_base, *stack_vars, *stack_terms_base, *stack_terms;
int subs_arity, i, n_vars = -1; int subs_arity, i, n_vars = -1;
Term t; Term t;
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
int stack_terms_pair_offset = 0; int stack_terms_pair_offset = 0;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
if ((subs_arity = *subs_ptr) == 0) if ((subs_arity = *subs_ptr) == 0)
return; return;
@ -967,8 +989,8 @@ void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr) {
STACK_CHECK_EXPAND(stack_terms, stack_vars, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_vars, stack_terms_base);
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(t, stack_terms);
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
if (t == AbsPair(PairTermInit)) { if (t == CompactPairInit) {
Term *stack_aux = stack_terms_base - stack_terms_pair_offset; Term *stack_aux = stack_terms_base - stack_terms_pair_offset;
Term head, tail = STACK_POP_UP(stack_aux); Term head, tail = STACK_POP_UP(stack_aux);
while (STACK_NOT_EMPTY(stack_aux, stack_terms)) { while (STACK_NOT_EMPTY(stack_aux, stack_terms)) {
@ -978,12 +1000,14 @@ void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr) {
stack_terms = stack_terms_base - stack_terms_pair_offset; stack_terms = stack_terms_base - stack_terms_pair_offset;
stack_terms_pair_offset = (int) STACK_POP_DOWN(stack_terms); stack_terms_pair_offset = (int) STACK_POP_DOWN(stack_terms);
STACK_PUSH_UP(tail, stack_terms); STACK_PUSH_UP(tail, stack_terms);
} else { /* AbsPair(PairTermLast)) */ } else { /* CompactPairEndList / CompactPairEndTerm */
Term last; Term last;
STACK_CHECK_EXPAND(stack_terms, stack_vars, stack_terms_base); STACK_CHECK_EXPAND(stack_terms, stack_vars + 1, stack_terms_base);
last = STACK_POP_DOWN(stack_terms); last = STACK_POP_DOWN(stack_terms);
STACK_PUSH_UP(stack_terms_pair_offset, stack_terms); STACK_PUSH_UP(stack_terms_pair_offset, stack_terms);
stack_terms_pair_offset = (int) (stack_terms_base - stack_terms); stack_terms_pair_offset = (int) (stack_terms_base - stack_terms);
if (t == CompactPairEndList)
STACK_PUSH_UP(TermNil, stack_terms);
STACK_PUSH_UP(last, stack_terms); STACK_PUSH_UP(last, stack_terms);
} }
#else #else
@ -991,7 +1015,7 @@ void load_answer_trie(ans_node_ptr ans_node, CELL *subs_ptr) {
Term tail = STACK_POP_DOWN(stack_terms); Term tail = STACK_POP_DOWN(stack_terms);
t = MkPairTerm(head, tail); t = MkPairTerm(head, tail);
STACK_PUSH_UP(t, stack_terms); STACK_PUSH_UP(t, stack_terms);
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = (Functor) RepAppl(t); Functor f = (Functor) RepAppl(t);
if (f == FunctorDouble) { if (f == FunctorDouble) {
@ -1085,17 +1109,17 @@ void free_subgoal_trie_branch(sg_node_ptr node, int nodes_left, int nodes_extra)
free_subgoal_trie_branch(TrNode_next(node), nodes_left, nodes_extra); free_subgoal_trie_branch(TrNode_next(node), nodes_left, nodes_extra);
if (nodes_extra) { if (nodes_extra) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
if (nodes_extra < 0) { if (nodes_extra < 0) {
Term t = TrNode_entry(node); Term t = TrNode_entry(node);
if (IsPairTerm(t)) { if (IsPairTerm(t)) {
if (t == AbsPair(PairTermInit)) if (t == CompactPairInit)
nodes_extra--; nodes_extra--;
else /* AbsPair(PairTermLast) */ else /* CompactPairEndList / CompactPairEndTerm */
nodes_extra++; nodes_extra++;
} }
} else } else
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
if (--nodes_extra == 0) if (--nodes_extra == 0)
nodes_left--; nodes_left--;
} else { } else {
@ -1103,12 +1127,12 @@ void free_subgoal_trie_branch(sg_node_ptr node, int nodes_left, int nodes_extra)
if (IsVarTerm(t) || IsAtomOrIntTerm(t)) if (IsVarTerm(t) || IsAtomOrIntTerm(t))
nodes_left--; nodes_left--;
else if (IsPairTerm(t)) else if (IsPairTerm(t))
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
/* AbsPair(PairTermInit) */ /* CompactPairInit */
nodes_extra = -1; nodes_extra = -1;
#else #else
nodes_left++; nodes_left++;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
else if (IsApplTerm(t)) { else if (IsApplTerm(t)) {
Functor f = (Functor) RepAppl(t); Functor f = (Functor) RepAppl(t);
if (f == FunctorDouble) if (f == FunctorDouble)
@ -1409,12 +1433,13 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
sg_node = *bucket; sg_node = *bucket;
traverse_subgoal_trie(sg_node, str, str_index, arity, depth, mode); traverse_subgoal_trie(sg_node, str, str_index, arity, depth, mode);
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1)); memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
#ifdef TRIE_COMPACT_PAIRS
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#else
if (arity[arity[0]] == -1) if (arity[arity[0]] == -1)
str[str_index - 1] = '|'; str[str_index - 1] = '|';
#ifdef TRIE_COMPACT_LISTS #endif /* TRIE_COMPACT_PAIRS */
else if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#endif /* TRIE_COMPACT_LISTS */
} }
} while (++bucket != last_bucket); } while (++bucket != last_bucket);
free(current_arity); free(current_arity);
@ -1428,12 +1453,13 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
traverse_subgoal_trie(TrNode_next(sg_node), str, str_index, arity, depth, mode); traverse_subgoal_trie(TrNode_next(sg_node), str, str_index, arity, depth, mode);
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1)); memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
free(current_arity); free(current_arity);
#ifdef TRIE_COMPACT_PAIRS
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#else
if (arity[arity[0]] == -1) if (arity[arity[0]] == -1)
str[str_index - 1] = '|'; str[str_index - 1] = '|';
#ifdef TRIE_COMPACT_LISTS #endif /* TRIE_COMPACT_PAIRS */
else if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#endif /* TRIE_COMPACT_LISTS */
} }
/* test the node type */ /* test the node type */
@ -1468,12 +1494,12 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1501,12 +1527,12 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1533,12 +1559,12 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1564,12 +1590,12 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1578,10 +1604,12 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} }
} else if (IsAtomTerm(t)) { } else if (IsAtomTerm(t)) {
if (arity[arity[0]] == -1 && !strcmp("[]", AtomName(AtomOfTerm(t)))) { #ifndef TRIE_COMPACT_PAIRS
if (arity[arity[0]] == -1 && t == TermNil) {
str[str_index - 1] = ']'; str[str_index - 1] = ']';
arity[0]--; arity[0]--;
} else } else
#endif /* TRIE_COMPACT_PAIRS */
str_index += sprintf(& str[str_index], "%s", AtomName(AtomOfTerm(t))); str_index += sprintf(& str[str_index], "%s", AtomName(AtomOfTerm(t)));
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] > 0) { if (arity[arity[0]] > 0) {
@ -1595,12 +1623,12 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1609,15 +1637,17 @@ void traverse_subgoal_trie(sg_node_ptr sg_node, char *str, int str_index, int *a
} }
} }
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
if (t == AbsPair(PairTermLast)) { if (t == CompactPairEndList)
arity[arity[0]] = -1;
else if (t == CompactPairEndTerm) {
str[str_index - 1] = '|'; str[str_index - 1] = '|';
arity[arity[0]] = -1; arity[arity[0]] = -1;
#else #else
if (arity[arity[0]] == -1) { if (arity[arity[0]] == -1) {
str[str_index - 1] = ','; str[str_index - 1] = ',';
arity[arity[0]] = -2; arity[arity[0]] = -2;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else { } else {
str_index += sprintf(& str[str_index], "["); str_index += sprintf(& str[str_index], "[");
arity[0]++; arity[0]++;
@ -1706,12 +1736,13 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
ans_node = *bucket; ans_node = *bucket;
traverse_answer_trie(ans_node, str, str_index, arity, var_index, depth, mode); traverse_answer_trie(ans_node, str, str_index, arity, var_index, depth, mode);
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1)); memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
#ifdef TRIE_COMPACT_PAIRS
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#else
if (arity[arity[0]] == -1) if (arity[arity[0]] == -1)
str[str_index - 1] = '|'; str[str_index - 1] = '|';
#ifdef TRIE_COMPACT_LISTS #endif /* TRIE_COMPACT_PAIRS */
else if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#endif /* TRIE_COMPACT_LISTS */
} }
} while (++bucket != last_bucket); } while (++bucket != last_bucket);
free(current_arity); free(current_arity);
@ -1725,12 +1756,13 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
traverse_answer_trie(TrNode_next(ans_node), str, str_index, arity, var_index, depth, mode); traverse_answer_trie(TrNode_next(ans_node), str, str_index, arity, var_index, depth, mode);
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1)); memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
free(current_arity); free(current_arity);
#ifdef TRIE_COMPACT_PAIRS
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#else
if (arity[arity[0]] == -1) if (arity[arity[0]] == -1)
str[str_index - 1] = '|'; str[str_index - 1] = '|';
#ifdef TRIE_COMPACT_LISTS #endif /* TRIE_COMPACT_PAIRS */
else if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
str[str_index - 1] = ',';
#endif /* TRIE_COMPACT_LISTS */
} }
/* print VAR when starting a term */ /* print VAR when starting a term */
@ -1770,12 +1802,12 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1805,12 +1837,12 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1839,12 +1871,12 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1870,12 +1902,12 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1884,10 +1916,12 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} }
} else if (IsAtomTerm(t)) { } else if (IsAtomTerm(t)) {
if (arity[arity[0]] == -1 && !strcmp("[]", AtomName(AtomOfTerm(t)))) { #ifndef TRIE_COMPACT_PAIRS
if (arity[arity[0]] == -1 && t == TermNil) {
str[str_index - 1] = ']'; str[str_index - 1] = ']';
arity[0]--; arity[0]--;
} else } else
#endif /* TRIE_COMPACT_PAIRS */
str_index += sprintf(& str[str_index], "%s", AtomName(AtomOfTerm(t))); str_index += sprintf(& str[str_index], "%s", AtomName(AtomOfTerm(t)));
while (arity[0]) { while (arity[0]) {
if (arity[arity[0]] > 0) { if (arity[arity[0]] > 0) {
@ -1901,12 +1935,12 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} else { } else {
if (arity[arity[0]] == -2) { if (arity[arity[0]] == -2) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
str_index += sprintf(& str[str_index], ","); str_index += sprintf(& str[str_index], ",");
#else #else
str_index += sprintf(& str[str_index], "|"); str_index += sprintf(& str[str_index], "|");
arity[arity[0]] = -1; arity[arity[0]] = -1;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
break; break;
} else { } else {
str_index += sprintf(& str[str_index], "]"); str_index += sprintf(& str[str_index], "]");
@ -1915,15 +1949,17 @@ void traverse_answer_trie(ans_node_ptr ans_node, char *str, int str_index, int *
} }
} }
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
#ifdef TRIE_COMPACT_LISTS #ifdef TRIE_COMPACT_PAIRS
if (t == AbsPair(PairTermLast)) { if (t == CompactPairEndList)
arity[arity[0]] = -1;
else if (t == CompactPairEndTerm) {
str[str_index - 1] = '|'; str[str_index - 1] = '|';
arity[arity[0]] = -1; arity[arity[0]] = -1;
#else #else
if (arity[arity[0]] == -1) { if (arity[arity[0]] == -1) {
str[str_index - 1] = ','; str[str_index - 1] = ',';
arity[arity[0]] = -2; arity[arity[0]] = -2;
#endif /* TRIE_COMPACT_LISTS */ #endif /* TRIE_COMPACT_PAIRS */
} else { } else {
str_index += sprintf(& str[str_index], "["); str_index += sprintf(& str[str_index], "[");
arity[0]++; arity[0]++;

872
OPTYap/tab.tries.insts.i
View File

File diff suppressed because it is too large Load Diff