/************************************************************************ ** ** ** The YapTab/YapOr/OPTYap systems ** ** ** ** YapTab extends the Yap Prolog engine to support sequential tabling ** ** YapOr extends the Yap Prolog engine to support or-parallelism ** ** OPTYap extends the Yap Prolog engine to support or-parallel tabling ** ** ** ** ** ** Yap Prolog was developed at University of Porto, Portugal ** ** ** ************************************************************************/ /************************************************************************ ** Trie instructions: auxiliary stack organization ** ************************************************************************* ------------------- | ha = heap_arity | ------------------- -- | heap ptr 1 | | ------------------- | | ... | -- heap_arity (0 if in global trie) ------------------- | | heap ptr ha | | ------------------- -- | va = vars_arity | ------------------- -- | var ptr va | | ------------------- | | ... | -- vars_arity ------------------- | | var ptr 1 | | ------------------- -- | sa = subs_arity | ------------------- -- | subs ptr sa | | ------------------- | | ... | -- subs_arity ------------------- | | subs ptr 1 | | ------------------- -- ************************************************************************/ /************************************************************************ ** Trie instructions: macros ** ************************************************************************/ #define TOP_STACK YENV #define HEAP_ARITY_ENTRY (0) #define VARS_ARITY_ENTRY (1 + heap_arity) #define SUBS_ARITY_ENTRY (1 + heap_arity + 1 + vars_arity) /* macros 'HEAP_ENTRY', 'VARS_ENTRY' and 'SUBS_ENTRY' ** ** assume that INDEX starts at 1 (and not at 0 !!!) */ #define HEAP_ENTRY(INDEX) (HEAP_ARITY_ENTRY + (INDEX)) #define VARS_ENTRY(INDEX) (VARS_ARITY_ENTRY + 1 + vars_arity - (INDEX)) #define SUBS_ENTRY(INDEX) (SUBS_ARITY_ENTRY + 1 + subs_arity - (INDEX)) #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; \ TOP_STACK = ENV; \ } \ PREFETCH_OP(PREG); \ GONext() #define copy_aux_stack() \ { int size = 3 + heap_arity + subs_arity + vars_arity; \ TOP_STACK -= size; \ memmove(TOP_STACK, aux_stack, size * sizeof(CELL *)); \ aux_stack = TOP_STACK; \ }/* macros 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' ** ** do not include 'set_cut' because trie instructions are cut safe */ #define store_trie_node(AP) \ { register choiceptr cp; \ TOP_STACK = (CELL *) (NORM_CP(TOP_STACK) - 1); \ cp = NORM_CP(TOP_STACK); \ HBREG = HR; \ store_yaam_reg_cpdepth(cp); \ cp->cp_tr = TR; \ cp->cp_h = HR; \ 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_ERROR_CHECKING_STACK; \ } \ copy_aux_stack() #define restore_trie_node(AP) \ HR = 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; \ TOP_STACK = (CELL *) PROTECT_FROZEN_B(B); \ SET_BB(NORM_CP(TOP_STACK)); \ copy_aux_stack() #define really_pop_trie_node() \ TOP_STACK = (CELL *) PROTECT_FROZEN_B((B + 1)); \ HR = 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) TOP_STACK == B_FZ) { \ copy_aux_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 */ /************************************************************************ ** aux_stack_null_instr ** ************************************************************************/ #define aux_stack_null_instr() \ next_trie_instruction(node) /************************************************************************ ** aux_stack_extension_instr ** ************************************************************************/ #define aux_stack_extension_instr() \ TOP_STACK = &aux_stack[-2]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + 2; \ TOP_STACK[HEAP_ENTRY(1)] = TrNode_entry(node); \ TOP_STACK[HEAP_ENTRY(2)] = 0; /* extension mark */ \ next_trie_instruction(node) /************************************************************************ ** aux_stack_term_(in_pair_)instr ** ************************************************************************/ #define aux_stack_term_instr() \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], t); \ TOP_STACK = &aux_stack[1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity - 1; \ next_instruction(heap_arity - 1 || subs_arity, node); \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], t); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ next_instruction(subs_arity - 1, node); \ } #define aux_stack_term_in_pair_instr() \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ } \ Bind_Global(HR, TrNode_entry(node)); \ TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ HR += 2; \ next_trie_instruction(node) /************************************************************************ ** aux_stack_(new_)pair_instr ** ************************************************************************/ #define aux_stack_new_pair_instr() /* for term 'CompactPairInit' */ \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ TOP_STACK = &aux_stack[-1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + 1; \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-2]; \ TOP_STACK[HEAP_ARITY_ENTRY] = 2; \ } \ TOP_STACK[HEAP_ENTRY(1)] = (CELL) HR; \ TOP_STACK[HEAP_ENTRY(2)] = (CELL) (HR + 1); \ HR += 2; \ next_trie_instruction(node) #ifdef TRIE_COMPACT_PAIRS #define aux_stack_pair_instr() /* for term 'CompactPairEndList' */ \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ } \ TOP_STACK[HEAP_ENTRY(1)] = (CELL) HR; \ Bind_Global(HR + 1, TermNil); \ HR += 2; \ next_trie_instruction(node) #else #define aux_stack_pair_instr() \ aux_stack_new_pair_instr() #endif /* TRIE_COMPACT_PAIRS */ /************************************************************************ ** aux_stack_appl_(in_pair_)instr ** ************************************************************************/ #define aux_stack_appl_instr() \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsAppl(HR)); \ TOP_STACK = &aux_stack[-func_arity + 1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + func_arity - 1; \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsAppl(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-func_arity]; \ TOP_STACK[HEAP_ARITY_ENTRY] = func_arity; \ } \ *HR = (CELL) func; \ { int i; \ for (i = 1; i <= func_arity; i++) \ TOP_STACK[HEAP_ENTRY(i)] = (CELL) (HR + i); \ } \ HR += 1 + func_arity; \ next_trie_instruction(node) #define aux_stack_appl_in_pair_instr() \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ TOP_STACK = &aux_stack[-func_arity]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity + func_arity; \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-func_arity - 1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = func_arity + 1; \ } \ TOP_STACK[HEAP_ENTRY(func_arity + 1)] = (CELL) (HR + 1); \ Bind_Global(HR, AbsAppl(HR + 2)); \ HR += 2; \ *HR = (CELL) func; \ { int i; \ for (i = 1; i <= func_arity; i++) \ TOP_STACK[HEAP_ENTRY(i)] = (CELL) (HR + i); \ } \ HR += 1 + func_arity; \ next_trie_instruction(node) /************************************************************************ ** aux_stack_var_(in_pair_)instr ** ************************************************************************/ #define aux_stack_var_instr() \ if (heap_arity) { \ int i; \ CELL var = aux_stack[HEAP_ENTRY(1)]; \ RESET_VARIABLE(var); \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity - 1; \ for (i = 2; i <= heap_arity; i++) \ TOP_STACK[HEAP_ENTRY(i - 1)] = aux_stack[HEAP_ENTRY(i)]; \ aux_stack[VARS_ARITY_ENTRY - 1] = vars_arity + 1; \ aux_stack[VARS_ENTRY(vars_arity + 1)] = var; \ next_instruction(heap_arity - 1 || subs_arity, node); \ } else { \ CELL var = aux_stack[SUBS_ENTRY(1)]; \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = 0; \ aux_stack[VARS_ARITY_ENTRY - 1] = vars_arity + 1; \ aux_stack[VARS_ENTRY(vars_arity + 1)] = var; \ next_instruction(subs_arity - 1, node); \ } #define aux_stack_var_in_pair_instr() \ if (heap_arity) { \ int i; \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ TOP_STACK = &aux_stack[-1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity; \ TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ for (i = 2; i <= heap_arity; i++) \ TOP_STACK[HEAP_ENTRY(i)] = aux_stack[HEAP_ENTRY(i)]; \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-2]; \ TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ } \ aux_stack[VARS_ARITY_ENTRY - 1] = vars_arity + 1; \ aux_stack[VARS_ENTRY(vars_arity + 1)] = (CELL) HR; \ RESET_VARIABLE((CELL) HR); \ HR += 2; \ next_trie_instruction(node) /************************************************************************ ** aux_stack_val_(in_pair_)instr ** ************************************************************************/ #define aux_stack_val_instr() \ if (heap_arity) { \ CELL aux_sub, aux_var; \ aux_sub = aux_stack[HEAP_ENTRY(1)]; \ aux_var = aux_stack[VARS_ENTRY(var_index + 1)]; \ if (aux_sub > aux_var) { \ Bind_Global((CELL *) aux_sub, aux_var); \ } else { \ RESET_VARIABLE(aux_sub); \ Bind_Local((CELL *) aux_var, aux_sub); \ aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ } \ TOP_STACK = &aux_stack[1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity - 1; \ next_instruction(heap_arity - 1 || subs_arity, node); \ } else { \ CELL aux_sub, aux_var; \ aux_sub = aux_stack[SUBS_ENTRY(1)]; \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ aux_var = aux_stack[VARS_ENTRY(var_index + 1)]; \ if (aux_sub > aux_var) { \ if ((CELL *) aux_sub <= HR) { \ Bind_Global((CELL *) aux_sub, aux_var); \ } else if ((CELL *) aux_var <= HR) { \ Bind_Local((CELL *) aux_sub, aux_var); \ } else { \ Bind_Local((CELL *) aux_var, aux_sub); \ aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ } \ } else { \ if ((CELL *) aux_var <= HR) { \ Bind_Global((CELL *) aux_var, aux_sub); \ aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ } else if ((CELL *) aux_sub <= HR) { \ Bind_Local((CELL *) aux_var, aux_sub); \ aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ } else { \ Bind_Local((CELL *) aux_sub, aux_var); \ } \ } \ next_instruction(subs_arity - 1, node); \ } #define aux_stack_val_in_pair_instr() \ if (heap_arity) { \ Bind_Global((CELL *) aux_stack[HEAP_ENTRY(1)], AbsPair(HR)); \ } else { \ YapBind((CELL *) aux_stack[SUBS_ENTRY(1)], AbsPair(HR)); \ aux_stack[SUBS_ARITY_ENTRY] = subs_arity - 1; \ TOP_STACK = &aux_stack[-1]; \ TOP_STACK[HEAP_ARITY_ENTRY] = 1; \ } \ { CELL aux_sub, aux_var; \ aux_sub = (CELL) HR; \ aux_var = aux_stack[VARS_ENTRY(var_index + 1)]; \ if (aux_sub > aux_var) { \ Bind_Global((CELL *) aux_sub, aux_var); \ } else { \ RESET_VARIABLE(aux_sub); \ Bind_Local((CELL *) aux_var, aux_sub); \ aux_stack[VARS_ENTRY(var_index + 1)] = aux_sub; \ } \ } \ TOP_STACK[HEAP_ENTRY(1)] = (CELL) (HR + 1); \ HR += 2; \ next_trie_instruction(node) /************************************************************************ ** Trie instructions ** ************************************************************************/ PBOp(trie_do_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_var, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_var_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_val, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_val_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_atom, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_atom_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_null, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_null_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_appl, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_appl_in_pair, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_extension, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_do_double, e) register ans_node_ptr node = (ans_node_ptr) PREG; register CELL *aux_stack = TOP_STACK; int heap_arity = aux_stack[HEAP_ARITY_ENTRY]; int vars_arity = aux_stack[VARS_ARITY_ENTRY]; int subs_arity = aux_stack[SUBS_ARITY_ENTRY]; volatile union { Float dbl; Term ts[SIZEOF_DOUBLE/SIZEOF_INT_P]; } td; Term t; #if SIZEOF_DOUBLE == 2 * SIZEOF_INT_P td.ts[0] = aux_stack[HEAP_ENTRY(1)]; td.ts[1] = aux_stack[HEAP_ENTRY(3)]; /* jump the first extension mark */ heap_arity -= 4; TOP_STACK = aux_stack = &aux_stack[4]; /* jump until the second extension mark */ #else /* SIZEOF_DOUBLE == SIZEOF_INT_P */ td.ts[0] = aux_stack[HEAP_ENTRY(1)]; heap_arity -= 2; TOP_STACK = aux_stack = &aux_stack[2]; /* jump until the extension mark */ #endif /* SIZEOF_DOUBLE x SIZEOF_INT_P */ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity; t = MkFloatTerm(td.dbl); aux_stack_term_instr(); { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); BOp(trie_trust_double, e) Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "trie_trust_double: invalid instruction"); ENDBOp(); BOp(trie_try_double, e) Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "trie_try_double: invalid instruction"); ENDBOp(); BOp(trie_retry_double, e) Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "trie_retry_double: invalid instruction"); ENDBOp(); PBOp(trie_do_longint, e) register ans_node_ptr node = (ans_node_ptr) PREG; register CELL *aux_stack = TOP_STACK; int heap_arity = aux_stack[HEAP_ARITY_ENTRY]; int vars_arity = aux_stack[VARS_ARITY_ENTRY]; int subs_arity = aux_stack[SUBS_ARITY_ENTRY]; Term t = MkLongIntTerm(aux_stack[HEAP_ENTRY(1)]); heap_arity -= 2; TOP_STACK = aux_stack = &aux_stack[2]; /* jump until the extension mark */ TOP_STACK[HEAP_ARITY_ENTRY] = heap_arity; aux_stack_term_instr(); { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); BOp(trie_trust_longint, e) Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "trie_trust_longint: invalid instruction"); ENDBOp(); BOp(trie_try_longint, e) Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "trie_try_longint: invalid instruction"); ENDBOp(); BOp(trie_retry_longint, e) ENDBOp(); PBOp(trie_do_bigint, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); BOp(trie_trust_bigint, e) ENDBOp(); BOp(trie_try_bigint, e) ENDBOp(); BOp(trie_retry_bigint, e) ENDBOp(); PBOp(trie_do_gterm, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_trust_gterm, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_try_gterm, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp(); PBOp(trie_retry_gterm, e) { printf("Tries not supported by JIT!!\n"); exit(1); } ENDPBOp();