5e4d7078ab
different marks to distinguish the lists ending with the empty list from the lists ending with a non-empty list term.
1289 lines
51 KiB
OpenEdge ABL
1289 lines
51 KiB
OpenEdge ABL
/**********************************************************************
|
|
|
|
The OPTYap Prolog system
|
|
OPTYap extends the Yap Prolog system to support or-parallel tabling
|
|
|
|
Copyright: R. Rocha and NCC - University of Porto, Portugal
|
|
File: tab.tries.insts.i
|
|
version: $Id: tab.tries.insts.i,v 1.12 2007-04-26 14:11:08 ricroc Exp $
|
|
|
|
**********************************************************************/
|
|
|
|
/* ----------------------------------------------- **
|
|
** Trie instructions: stack organization **
|
|
** ----------------------------------------------- **
|
|
-------------------
|
|
| ha = heap_arity |
|
|
------------------- --
|
|
| heap ptr 1 | |
|
|
------------------- |
|
|
| ... | -- heap_arity
|
|
------------------- |
|
|
| heap ptr ha | |
|
|
------------------- --
|
|
| va = vars_arity |
|
|
-------------------
|
|
| sa = subs_arity |
|
|
------------------- --
|
|
| subs ptr sa | |
|
|
------------------- |
|
|
| ... | -- subs_arity
|
|
------------------- |
|
|
| subs ptr 1 | |
|
|
------------------- --
|
|
| var ptr va | |
|
|
------------------- |
|
|
| ... | -- vars_arity
|
|
------------------- |
|
|
| var ptr 1 | |
|
|
------------------- --
|
|
** ----------------------------------------------- */
|
|
|
|
|
|
|
|
/* --------------------------------------------- **
|
|
** Trie instructions: auxiliary macros **
|
|
** --------------------------------------------- */
|
|
|
|
#define copy_arity_stack() \
|
|
{ int size = heap_arity + subs_arity + vars_arity + 3; \
|
|
YENV -= size; \
|
|
memcpy(YENV, aux_ptr, size * sizeof(CELL *)); \
|
|
aux_ptr = YENV; \
|
|
}
|
|
|
|
#define next_trie_instruction(NODE) \
|
|
PREG = (yamop *) TrNode_child(NODE); \
|
|
PREFETCH_OP(PREG); \
|
|
GONext()
|
|
|
|
#define next_instruction(CONDITION, NODE) \
|
|
if (CONDITION) { \
|
|
PREG = (yamop *) TrNode_child(NODE); \
|
|
} else { \
|
|
/* procceed */ \
|
|
PREG = (yamop *) CPREG; \
|
|
YENV = ENV; \
|
|
} \
|
|
PREFETCH_OP(PREG); \
|
|
GONext()
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------------- **
|
|
** the 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' macros do not **
|
|
** include the 'set_cut' macro because there are no cuts in trie instructions. **
|
|
** ---------------------------------------------------------------------------- */
|
|
|
|
#define store_trie_node(AP) \
|
|
{ register choiceptr cp; \
|
|
YENV = (CELL *) (NORM_CP(YENV) - 1); \
|
|
cp = NORM_CP(YENV); \
|
|
HBREG = H; \
|
|
store_yaam_reg_cpdepth(cp); \
|
|
cp->cp_tr = TR; \
|
|
cp->cp_h = H; \
|
|
cp->cp_b = B; \
|
|
cp->cp_cp = CPREG; \
|
|
cp->cp_ap = (yamop *) AP; \
|
|
cp->cp_env= ENV; \
|
|
B = cp; \
|
|
YAPOR_SET_LOAD(B); \
|
|
SET_BB(B); \
|
|
TABLING_ERRORS_check_stack; \
|
|
} \
|
|
copy_arity_stack()
|
|
|
|
#define restore_trie_node(AP) \
|
|
H = HBREG = PROTECT_FROZEN_H(B); \
|
|
restore_yaam_reg_cpdepth(B); \
|
|
CPREG = B->cp_cp; \
|
|
ENV = B->cp_env; \
|
|
YAPOR_update_alternative(PREG, (yamop *) AP) \
|
|
B->cp_ap = (yamop *) AP; \
|
|
YENV = (CELL *) PROTECT_FROZEN_B(B); \
|
|
SET_BB(NORM_CP(YENV)); \
|
|
copy_arity_stack()
|
|
|
|
#define really_pop_trie_node() \
|
|
YENV = (CELL *) PROTECT_FROZEN_B((B + 1)); \
|
|
H = PROTECT_FROZEN_H(B); \
|
|
pop_yaam_reg_cpdepth(B); \
|
|
CPREG = B->cp_cp; \
|
|
TABLING_close_alt(B); \
|
|
ENV = B->cp_env; \
|
|
B = B->cp_b; \
|
|
HBREG = PROTECT_FROZEN_H(B); \
|
|
SET_BB(PROTECT_FROZEN_B(B)); \
|
|
if ((choiceptr) YENV == B_FZ) { \
|
|
copy_arity_stack(); \
|
|
}
|
|
|
|
#ifdef YAPOR
|
|
#define pop_trie_node() \
|
|
if (SCH_top_shared_cp(B)) { \
|
|
restore_trie_node(NULL); \
|
|
} else { \
|
|
really_pop_trie_node(); \
|
|
}
|
|
#else
|
|
#define pop_trie_node() really_pop_trie_node()
|
|
#endif /* YAPOR */
|
|
|
|
|
|
|
|
/* ------------------- **
|
|
** trie_null **
|
|
** ------------------- */
|
|
|
|
#define stack_trie_null_instr() \
|
|
next_trie_instruction(node)
|
|
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
/* trie compiled code for term 'CompactPairInit' */
|
|
#define stack_trie_null_in_new_pair_instr() \
|
|
if (heap_arity) { \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr-- = (CELL) H; \
|
|
*aux_ptr = heap_arity - 1 + 2; \
|
|
YENV = aux_ptr; \
|
|
} else { \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr-- = (CELL) H; \
|
|
*aux_ptr = 2; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 2 + 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
H += 2; \
|
|
next_trie_instruction(node)
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
|
|
|
|
|
|
/* ------------------ **
|
|
** trie_var **
|
|
** ------------------ */
|
|
|
|
#define stack_trie_var_instr() \
|
|
if (heap_arity) { \
|
|
CELL var; \
|
|
int i; \
|
|
*aux_ptr = heap_arity - 1; \
|
|
var = *++aux_ptr; \
|
|
RESET_VARIABLE(var); \
|
|
for (i = 0; i < heap_arity - 1; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
*aux_ptr++ = vars_arity + 1; \
|
|
*aux_ptr++ = subs_arity; \
|
|
for (i = 0; i < subs_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
*aux_ptr = var; \
|
|
next_instruction(heap_arity - 1 || subs_arity, node); \
|
|
} else { \
|
|
*++aux_ptr = vars_arity + 1; \
|
|
*++aux_ptr = subs_arity - 1; \
|
|
next_instruction(subs_arity - 1, node); \
|
|
}
|
|
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
#define stack_trie_var_in_new_pair_instr() \
|
|
if (heap_arity) { \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr = heap_arity - 1 + 1; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 2; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < heap_arity - 1; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
*aux_ptr++ = vars_arity + 1; \
|
|
*aux_ptr++ = subs_arity; \
|
|
for (i = 0; i < subs_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
*aux_ptr = (CELL) H; \
|
|
} else { \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr = 1; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 2; \
|
|
*aux_ptr++ = vars_arity + 1; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr = (CELL) H; \
|
|
} \
|
|
RESET_VARIABLE((CELL) H); \
|
|
H += 2; \
|
|
next_trie_instruction(node)
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
|
|
|
|
|
|
/* ------------------ **
|
|
** trie_val **
|
|
** ------------------ */
|
|
|
|
#define stack_trie_val_instr() \
|
|
if (heap_arity) { \
|
|
CELL aux, subs, *subs_ptr; \
|
|
YENV = ++aux_ptr; \
|
|
subs_ptr = aux_ptr + heap_arity + 1 + subs_arity + vars_arity - var_index; \
|
|
aux = *aux_ptr; \
|
|
subs = *subs_ptr; \
|
|
if (aux > subs) { \
|
|
Bind_Global((CELL *) aux, subs); \
|
|
} else { \
|
|
RESET_VARIABLE(aux); \
|
|
Bind_Local((CELL *) subs, aux); \
|
|
*subs_ptr = aux; \
|
|
} \
|
|
*aux_ptr = heap_arity - 1; \
|
|
next_instruction(heap_arity - 1 || subs_arity, node); \
|
|
} else { \
|
|
CELL aux, subs, *subs_ptr; \
|
|
int i; \
|
|
aux_ptr += 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
subs_ptr = aux_ptr + vars_arity - var_index; \
|
|
aux = *aux_ptr; \
|
|
subs = *subs_ptr; \
|
|
if (aux > subs) { \
|
|
if ((CELL *) aux <= H) { \
|
|
Bind_Global((CELL *) aux, subs); \
|
|
} else if ((CELL *) subs <= H) { \
|
|
Bind_Local((CELL *) aux, subs); \
|
|
} else { \
|
|
Bind_Local((CELL *) subs, aux); \
|
|
*subs_ptr = aux; \
|
|
} \
|
|
} else { \
|
|
if ((CELL *) subs <= H) { \
|
|
Bind_Global((CELL *) subs, aux); \
|
|
*subs_ptr = aux; \
|
|
} else if ((CELL *) aux <= H) { \
|
|
Bind_Local((CELL *) subs, aux); \
|
|
*subs_ptr = aux; \
|
|
} else { \
|
|
Bind_Local((CELL *) aux, subs); \
|
|
} \
|
|
} \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
next_instruction(subs_arity - 1, node); \
|
|
}
|
|
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
#define stack_trie_val_in_new_pair_instr() \
|
|
if (heap_arity) { \
|
|
CELL aux, subs, *subs_ptr; \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr = (CELL) (H + 1); \
|
|
aux = (CELL) H; \
|
|
subs_ptr = aux_ptr + heap_arity + 1 + subs_arity + vars_arity - var_index; \
|
|
subs = *subs_ptr; \
|
|
if (aux > subs) { \
|
|
Bind_Global((CELL *) aux, subs); \
|
|
} else { \
|
|
RESET_VARIABLE(aux); \
|
|
Bind_Local((CELL *) subs, aux); \
|
|
*subs_ptr = aux; \
|
|
} \
|
|
} else { \
|
|
CELL aux, subs, *subs_ptr; \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr = 1; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 1 + 2; \
|
|
aux = (CELL) H; \
|
|
subs_ptr = aux_ptr + subs_arity + vars_arity - var_index; \
|
|
subs = *subs_ptr; \
|
|
if (aux > subs) { \
|
|
Bind_Global((CELL *) aux, subs); \
|
|
} else { \
|
|
RESET_VARIABLE(aux); \
|
|
Bind_Local((CELL *) subs, aux); \
|
|
*subs_ptr = aux; \
|
|
} \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
H += 2; \
|
|
next_trie_instruction(node)
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
|
|
|
|
|
|
/* ------------------- **
|
|
** trie_atom **
|
|
** ------------------- */
|
|
|
|
#define stack_trie_atom_instr() \
|
|
if (heap_arity) { \
|
|
YENV = ++aux_ptr; \
|
|
Bind_Global((CELL *) *aux_ptr, TrNode_entry(node)); \
|
|
*aux_ptr = heap_arity - 1; \
|
|
next_instruction(heap_arity - 1 || subs_arity, node); \
|
|
} else { \
|
|
int i; \
|
|
aux_ptr += 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, TrNode_entry(node)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
next_instruction(subs_arity - 1, node); \
|
|
}
|
|
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
#define stack_trie_atom_in_new_pair_instr() \
|
|
if (heap_arity) { \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr = (CELL) (H + 1); \
|
|
} else { \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr = 1; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 1 + 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
Bind_Global(H, TrNode_entry(node)); \
|
|
H += 2; \
|
|
next_trie_instruction(node)
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
|
|
|
|
|
|
/* ------------------- **
|
|
** trie_pair **
|
|
** ------------------- */
|
|
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
/* trie compiled code for term 'CompactPairEndList' */
|
|
#define stack_trie_pair_instr() \
|
|
if (heap_arity) { \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr = (CELL) H; \
|
|
} else { \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) H; \
|
|
*aux_ptr = 1; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 1 + 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
Bind_Global(H + 1, TermNil); \
|
|
H += 2; \
|
|
next_trie_instruction(node)
|
|
#else
|
|
#define stack_trie_pair_instr() \
|
|
if (heap_arity) { \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr-- = (CELL) H; \
|
|
*aux_ptr = heap_arity - 1 + 2; \
|
|
YENV = aux_ptr; \
|
|
} else { \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
*aux_ptr-- = (CELL) H; \
|
|
*aux_ptr = 2; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 2 + 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
H += 2; \
|
|
next_trie_instruction(node)
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
|
|
|
|
|
|
/* --------------------- **
|
|
** trie_struct **
|
|
** --------------------- */
|
|
|
|
#define stack_trie_struct_instr() \
|
|
if (heap_arity) { \
|
|
int i; \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsAppl(H)); \
|
|
for (i = 0; i < func_arity; i++) \
|
|
*aux_ptr-- = (CELL) (H + func_arity - i); \
|
|
*aux_ptr = heap_arity - 1 + func_arity; \
|
|
YENV = aux_ptr; \
|
|
} else { \
|
|
int i; \
|
|
for (i = 0; i < func_arity; i++) \
|
|
*aux_ptr-- = (CELL) (H + func_arity - i); \
|
|
*aux_ptr = func_arity; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += func_arity + 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsAppl(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
*H = (CELL) func; \
|
|
H += 1 + func_arity; \
|
|
next_trie_instruction(node)
|
|
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
#define stack_trie_struct_in_new_pair_instr() \
|
|
if (heap_arity) { \
|
|
int i; \
|
|
aux_ptr++; \
|
|
Bind_Global((CELL *) *aux_ptr, AbsPair(H)); \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
for (i = 0; i < func_arity; i++) \
|
|
*aux_ptr-- = (CELL) (H + 2 + func_arity - i); \
|
|
*aux_ptr = heap_arity - 1 + 1 + func_arity; \
|
|
YENV = aux_ptr; \
|
|
} else { \
|
|
int i; \
|
|
*aux_ptr-- = (CELL) (H + 1); \
|
|
for (i = 0; i < func_arity; i++) \
|
|
*aux_ptr-- = (CELL) (H + 2 + func_arity - i); \
|
|
*aux_ptr = 1 + func_arity; \
|
|
YENV = aux_ptr; \
|
|
aux_ptr += 1 + func_arity + 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, AbsPair(H)); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
} \
|
|
Bind_Global(H, AbsAppl(H + 2)); \
|
|
H += 2; \
|
|
*H = (CELL) func; \
|
|
H += 1 + func_arity; \
|
|
next_trie_instruction(node)
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
|
|
|
|
|
|
/* ------------------------ **
|
|
** trie_extension **
|
|
** ------------------------ */
|
|
|
|
#define stack_trie_extension_instr() \
|
|
*aux_ptr-- = TrNode_entry(node); \
|
|
*aux_ptr = heap_arity + 1; \
|
|
YENV = aux_ptr; \
|
|
next_trie_instruction(node)
|
|
|
|
|
|
|
|
/* ---------------------------- **
|
|
** trie_float_longint **
|
|
** ---------------------------- */
|
|
|
|
#define stack_trie_float_longint_instr() \
|
|
if (heap_arity) { \
|
|
YENV = ++aux_ptr; \
|
|
Bind_Global((CELL *) *aux_ptr, t); \
|
|
*aux_ptr = heap_arity - 1; \
|
|
next_instruction(heap_arity - 1 || subs_arity, node); \
|
|
} else { \
|
|
int i; \
|
|
YENV = aux_ptr; \
|
|
*aux_ptr = 0; \
|
|
aux_ptr += 2; \
|
|
*aux_ptr = subs_arity - 1; \
|
|
aux_ptr += subs_arity; \
|
|
Bind((CELL *) *aux_ptr, t); \
|
|
for (i = 0; i < vars_arity; i++) { \
|
|
*aux_ptr = *(aux_ptr + 1); \
|
|
aux_ptr++; \
|
|
} \
|
|
next_instruction(subs_arity - 1, node); \
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------- **
|
|
** Trie instructions **
|
|
** --------------------------- */
|
|
|
|
PBOp(trie_do_null, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
|
|
stack_trie_null_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_null, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_null_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_null, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_null_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_null, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_null_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_null_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
stack_trie_null_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_null_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_null_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_null_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_null_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_null_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_null_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_null_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_null_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_null_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_null_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_var, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
stack_trie_var_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_var, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_var_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_var, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_var_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_var, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_var_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_var_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
stack_trie_var_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_var_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_var_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_var_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_var_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_var_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_var_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_var_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_var_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_var_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_var_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_val, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
stack_trie_val_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_val, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
pop_trie_node();
|
|
stack_trie_val_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_val, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_val_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_val, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_val_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_val_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
stack_trie_val_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_val_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_val_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
pop_trie_node();
|
|
stack_trie_val_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_val_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_val_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_val_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_val_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_val_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
int var_index = VarIndexOfTableTerm(TrNode_entry(node));
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_val_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_val_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_atom, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
stack_trie_atom_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_atom, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_atom_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_atom, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_atom_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_atom, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_atom_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_atom_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
stack_trie_atom_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_atom_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_atom_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_atom_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_atom_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_atom_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_atom_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_atom_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_atom_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_atom_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_atom_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_pair, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
stack_trie_pair_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_pair, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_pair_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_pair, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_pair_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_pair, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_pair_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_struct, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
stack_trie_struct_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_struct, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
pop_trie_node();
|
|
stack_trie_struct_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_struct, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_struct_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_struct, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_struct_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_struct_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
stack_trie_struct_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_do_struct_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_struct_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
pop_trie_node();
|
|
stack_trie_struct_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_struct_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_struct_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_struct_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_struct_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_struct_in_new_pair, e)
|
|
#ifdef TRIE_COMPACT_PAIRS
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Functor func = (Functor) RepAppl(TrNode_entry(node));
|
|
int func_arity = ArityOfFunctor(func);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_struct_in_new_pair_instr();
|
|
#else
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_struct_in_new_pair)");
|
|
#endif /* TRIE_COMPACT_PAIRS */
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_extension, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
|
|
stack_trie_extension_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_trust_extension, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
pop_trie_node();
|
|
stack_trie_extension_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_try_extension, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
store_trie_node(TrNode_next(node));
|
|
stack_trie_extension_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_retry_extension, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = (CELL *) (B + 1);
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
|
|
restore_trie_node(TrNode_next(node));
|
|
stack_trie_extension_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
PBOp(trie_do_float, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
volatile Float dbl;
|
|
volatile Term *t_dbl = (Term *)((void *) &dbl);
|
|
Term t;
|
|
|
|
#if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P
|
|
*t_dbl = *++aux_ptr;
|
|
*(t_dbl + 1) = *++aux_ptr;
|
|
heap_arity -= 2;
|
|
#else /* SIZEOF_DOUBLE == SIZEOF_INT_P */
|
|
*t_dbl = *++aux_ptr;
|
|
heap_arity -= 1;
|
|
#endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */
|
|
t = MkFloatTerm(dbl);
|
|
stack_trie_float_longint_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
BOp(trie_trust_float, e)
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_float)");
|
|
ENDBOp();
|
|
|
|
|
|
BOp(trie_try_float, e)
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_float)");
|
|
ENDBOp();
|
|
|
|
|
|
BOp(trie_retry_float, e)
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_float)");
|
|
ENDBOp();
|
|
|
|
|
|
PBOp(trie_do_long, e)
|
|
register ans_node_ptr node = (ans_node_ptr) PREG;
|
|
register CELL *aux_ptr = YENV;
|
|
int heap_arity = *aux_ptr;
|
|
int vars_arity = *(aux_ptr + heap_arity + 1);
|
|
int subs_arity = *(aux_ptr + heap_arity + 2);
|
|
Term t = MkLongIntTerm(*++aux_ptr);
|
|
|
|
heap_arity -= 1;
|
|
stack_trie_float_longint_instr();
|
|
ENDPBOp();
|
|
|
|
|
|
BOp(trie_trust_long, e)
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_trust_long)");
|
|
ENDBOp();
|
|
|
|
|
|
BOp(trie_try_long, e)
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_try_long)");
|
|
ENDBOp();
|
|
|
|
|
|
BOp(trie_retry_long, e)
|
|
Yap_Error(INTERNAL_ERROR, TermNil, "invalid instruction (trie_retry_long)");
|
|
ENDBOp();
|