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

if number of left-over < 1/5 keep list of clauses to expand around

Browse Source 
fix call to stack expander


git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@1030 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
This commit is contained in:
vsc 2004-03-31 01:02:18 +00:00
parent 30c2f0e570
commit 545b12a808
1 changed files with 371 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

513
C/index.c
View File

@ -11,8 +11,11 @@
* File: index.c * * File: index.c *
* comments: Indexing a Prolog predicate * * comments: Indexing a Prolog predicate *
* * * *
* Last rev: $Date: 2004-03-25 02:19:10 $,$Author: pmoura $ * * Last rev: $Date: 2004-03-31 01:02:18 $,$Author: vsc $ *
* $Log: not supported by cvs2svn $ * $Log: not supported by cvs2svn $
* Revision 1.81 2004/03/25 02:19:10 pmoura
* Removed debugging line to allow compilation.
*
* Revision 1.80 2004/03/19 11:35:42 vsc * Revision 1.80 2004/03/19 11:35:42 vsc
* trim_trail for default machine * trim_trail for default machine
* be more aggressive about try-retry-trust chains. * be more aggressive about try-retry-trust chains.
@ -481,6 +484,9 @@ has_cut(yamop *pc)
#endif #endif
pc = NEXTOP(pc,e); pc = NEXTOP(pc,e);
break; break;
case _expand_clauses:
pc = NEXTOP(pc,sp);
break;
/* instructions type x */ /* instructions type x */
case _save_b_x: case _save_b_x:
case _get_list: case _get_list:
@ -1630,6 +1636,7 @@ add_info(ClauseDef *clause, UInt regno)
case _thread_local: case _thread_local:
#endif #endif
case _expand_index: case _expand_index:
case _expand_clauses:
case _undef_p: case _undef_p:
case _spy_pred: case _spy_pred:
case _p_equal: case _p_equal:
@ -2438,7 +2445,7 @@ emit_switch_space(UInt n, UInt item_size, struct intermediates *cint)
UInt sz = sizeof(LogUpdIndex)+n*item_size; UInt sz = sizeof(LogUpdIndex)+n*item_size;
LogUpdIndex *cl = (LogUpdIndex *)Yap_AllocCodeSpace(sz); LogUpdIndex *cl = (LogUpdIndex *)Yap_AllocCodeSpace(sz);
if (cl == NULL) { if (cl == NULL) {
Yap_Error_Size = sizeof(LogUpdIndex)+n*item_size; Yap_Error_Size = sz;
/* grow stack */ /* grow stack */
longjmp(cint->CompilerBotch,2); longjmp(cint->CompilerBotch,2);
} }
@ -2733,6 +2740,31 @@ suspend_indexing(ClauseDef *min, ClauseDef *max, PredEntry *ap)
return (UInt)&(ap->cs.p_code.ExpandCode); return (UInt)&(ap->cs.p_code.ExpandCode);
} }
static UInt
suspend_indexing_in_switch(ClauseDef *min, ClauseDef *max, PredEntry *ap)
{
UInt tcls = ap->cs.p_code.NOfClauses;
UInt cls = (max-min)+1;
yamop *ncode;
if (cls < tcls/8 &&
(ncode = (yamop *)Yap_AllocCodeSpace((UInt)(NEXTOP((yamop *)NULL,sp)+cls*sizeof(yamop *))))) {
/* create an expand_block */
yamop **st;
ncode->opc = Yap_opcode(_expand_clauses);
ncode->u.sp.p = ap;
ncode->u.sp.s1 = ncode->u.sp.s2 = cls;
st = (yamop **)NEXTOP(ncode,sp);
while (min <= max) {
*st++ = min->Code;
min++;
}
return (UInt)ncode;
}
return (UInt)&(ap->cs.p_code.ExpandCode);
}
static UInt static UInt
do_var_entries(GroupDef *grp, Term t, struct intermediates *cint, UInt argno, int first, int clleft, UInt nxtlbl){ do_var_entries(GroupDef *grp, Term t, struct intermediates *cint, UInt argno, int first, int clleft, UInt nxtlbl){
@ -2774,11 +2806,11 @@ do_consts(GroupDef *grp, Term t, struct intermediates *cint, int compound_term,
if (min != max) { if (min != max) {
if (sreg != NULL) { if (sreg != NULL) {
if (ap->PredFlags & LogUpdatePredFlag && max > min) if (ap->PredFlags & LogUpdatePredFlag && max > min)
ics->Label = suspend_indexing(min, max, ap); ics->Label = suspend_indexing_in_switch(min, max, ap);
else else
ics->Label = do_compound_index(min, max, sreg, cint, compound_term, arity, argno+1, nxtlbl, first, last_arg, clleft, top, TRUE); ics->Label = do_compound_index(min, max, sreg, cint, compound_term, arity, argno+1, nxtlbl, first, last_arg, clleft, top, TRUE);
} else if (ap->PredFlags & LogUpdatePredFlag) { } else if (ap->PredFlags & LogUpdatePredFlag) {
ics->Label = suspend_indexing(min, max, cint->CurrentPred); ics->Label = suspend_indexing_in_switch(min, max, cint->CurrentPred);
} else { } else {
ics->Label = do_index(min, max, cint, argno+1, nxtlbl, first, clleft, top); ics->Label = do_index(min, max, cint, argno+1, nxtlbl, first, clleft, top);
} }
@ -2812,7 +2844,7 @@ do_blobs(GroupDef *grp, Term t, struct intermediates *cint, UInt argno, int firs
max != grp->LastClause) max++; max != grp->LastClause) max++;
if (min != max && if (min != max &&
(ap->PredFlags & LogUpdatePredFlag)) { (ap->PredFlags & LogUpdatePredFlag)) {
ics->Label = suspend_indexing(min, max, ap); ics->Label = suspend_indexing_in_switch(min, max, ap);
} else { } else {
ics->Label = do_index(min, max, cint, argno+1, nxtlbl, first, clleft, top); ics->Label = do_index(min, max, cint, argno+1, nxtlbl, first, clleft, top);
} }
@ -3110,13 +3142,12 @@ do_index(ClauseDef *min, ClauseDef* max, struct intermediates *cint, UInt argno,
found_pvar = cls_info(min, max, argno); found_pvar = cls_info(min, max, argno);
} }
ngroups = groups_in(min, max, group); ngroups = groups_in(min, max, group);
if (IsVarTerm(t) && if (IsVarTerm(t)) {
max - min > 2 &&
ap->ModuleOfPred != IDB_MODULE) {
lablx = new_label(); lablx = new_label();
Yap_emit(label_op, lablx, Zero, cint); Yap_emit(label_op, lablx, Zero, cint);
while (IsVarTerm(t)) { while (IsVarTerm(t)) {
Yap_emit(jump_nv_op, (CELL)(&(ap->cs.p_code.ExpandCode)), argno, cint); if (ngroups > 1 || !group->VarClauses)
Yap_emit(jump_nv_op, (CELL)(&(ap->cs.p_code.ExpandCode)), argno, cint);
if (argno == ap->ArityOfPE) { if (argno == ap->ArityOfPE) {
do_var_clauses(min, max, FALSE, cint, first, clleft, fail_l, argno0); do_var_clauses(min, max, FALSE, cint, first, clleft, fail_l, argno0);
return lablx; return lablx;
@ -3294,7 +3325,7 @@ do_compound_index(ClauseDef *min0, ClauseDef* max0, Term* sreg, struct intermedi
if (!lu_pred || !done_work) if (!lu_pred || !done_work)
*newlabp = do_index(min0, max0, cint, argno+1, fail_l, first, clleft, top); *newlabp = do_index(min0, max0, cint, argno+1, fail_l, first, clleft, top);
else else
*newlabp = suspend_indexing(min0, max0, ap); *newlabp = suspend_indexing_in_switch(min0, max0, ap);
} }
return ret_lab; return ret_lab;
} }
@ -3584,6 +3615,40 @@ install_clauses(ClauseDef *cls, PredEntry *ap, istack_entry *stack, yamop *beg,
} }
} }
static ClauseDef *
install_clauseseq(ClauseDef *cls, PredEntry *ap, istack_entry *stack, yamop **beg, yamop **end)
{
istack_entry *sp = stack;
if (stack[0].pos == 0) {
while (TRUE) {
if (*beg) {
cls->Code = cls->CurrentCode = *beg;
cls->Tag = 0;
cls++;
}
beg++;
if (beg == end) {
return cls-1;
}
}
}
while (TRUE) {
if (*beg) {
cls->Code = cls->CurrentCode = *beg;
sp = install_clause(cls, ap, stack);
/* we reached a matching clause */
if (!sp->pos && (sp[-1].val == 0L || cls->Tag == sp[-1].val)) {
cls++;
}
}
beg++;
if (beg == end) {
return cls-1;
}
}
}
static void static void
reinstall_clauses(ClauseDef *cls, ClauseDef *end, PredEntry *ap, istack_entry *stack) reinstall_clauses(ClauseDef *cls, ClauseDef *end, PredEntry *ap, istack_entry *stack)
{ {
@ -3672,6 +3737,40 @@ install_log_upd_clauses(ClauseDef *cls, PredEntry *ap, istack_entry *stack, yamo
} }
} }
static ClauseDef *
install_log_upd_clauseseq(ClauseDef *cls, PredEntry *ap, istack_entry *stack, yamop **beg, yamop **end)
{
istack_entry *sp = stack;
if (stack[0].pos == 0) {
while (TRUE) {
if (beg) {
cls->Code = cls->CurrentCode = *beg;
cls->Tag = 0;
cls++;
}
beg++;
if (beg == end) {
return cls-1;
}
}
}
while (TRUE) {
if (*beg) {
cls->Code = cls->CurrentCode = *beg;
sp = install_log_upd_clause(cls, ap, stack);
/* we reached a matching clause */
if (!sp->pos && (sp[-1].val == 0L || cls->Tag == sp[-1].val)) {
cls++;
}
}
beg++;
if (beg == end) {
return cls-1;
}
}
}
static void static void
reinstall_log_upd_clauses(ClauseDef *cls, ClauseDef *end, PredEntry *ap, istack_entry *stack) reinstall_log_upd_clauses(ClauseDef *cls, ClauseDef *end, PredEntry *ap, istack_entry *stack)
{ {
@ -4002,15 +4101,15 @@ expand_index(struct intermediates *cint) {
s_reg = RepAppl(t); s_reg = RepAppl(t);
f = (Functor)(*s_reg++); f = (Functor)(*s_reg++);
if (op == _switch_on_func) { if (op == _switch_on_func) {
fe = lookup_f_hash(f,ipc->u.sl.l,ipc->u.sl.s); fe = lookup_f_hash(f,ipc->u.sssl.l,ipc->u.sssl.s);
} else { } else {
fe = lookup_f(f,ipc->u.sl.l,ipc->u.sl.s); fe = lookup_f(f,ipc->u.sssl.l,ipc->u.sssl.s);
} }
newpc = (yamop *)(fe->Label); newpc = (yamop *)(fe->Label);
labp = (yamop **)(&(fe->Label));
if (newpc == (yamop *)&(ap->cs.p_code.ExpandCode)) { if (newpc == (yamop *)&(ap->cs.p_code.ExpandCode)) {
/* we found it */ /* we found it */
labp = (yamop **)(&(fe->Label));
ipc = NULL; ipc = NULL;
} else { } else {
ipc = newpc; ipc = newpc;
@ -4024,14 +4123,14 @@ expand_index(struct intermediates *cint) {
AtomSwiEntry *ae; AtomSwiEntry *ae;
if (op == _switch_on_cons) { if (op == _switch_on_cons) {
ae = lookup_c_hash(t,ipc->u.sl.l,ipc->u.sl.s); ae = lookup_c_hash(t,ipc->u.sssl.l,ipc->u.sssl.s);
} else { } else {
ae = lookup_c(t,ipc->u.sl.l,ipc->u.sl.s); ae = lookup_c(t,ipc->u.sssl.l,ipc->u.sssl.s);
} }
labp = (yamop **)(&(ae->Label));
if (ae->Label == (CELL)&(ap->cs.p_code.ExpandCode)) { if (ae->Label == (CELL)&(ap->cs.p_code.ExpandCode)) {
/* we found it */ /* we found it */
labp = (yamop **)(&(ae->Label));
ipc = NULL; ipc = NULL;
} else { } else {
ipc = (yamop *)(ae->Label); ipc = (yamop *)(ae->Label);
@ -4039,6 +4138,7 @@ expand_index(struct intermediates *cint) {
} }
break; break;
case _expand_index: case _expand_index:
case _expand_clauses:
if (alt != NULL && ap->PredFlags & LogUpdatePredFlag) { if (alt != NULL && ap->PredFlags & LogUpdatePredFlag) {
op_numbers fop = Yap_op_from_opcode(alt->opc); op_numbers fop = Yap_op_from_opcode(alt->opc);
if (fop == _enter_lu_pred) if (fop == _enter_lu_pred)
@ -4094,17 +4194,40 @@ expand_index(struct intermediates *cint) {
clleft = count_clauses_left(last,ap); clleft = count_clauses_left(last,ap);
} }
if (cls+2*NClauses > (ClauseDef *)(ASP-4096)) { if (Yap_op_from_opcode((*labp)->opc) == _expand_clauses) {
/* tell how much space we need (worst case) */ /* ok, we know how many clauses */
Yap_Error_Size += NClauses*sizeof(ClauseDef); yamop *ipc = *labp;
/* grow stack */ COUNT nclauses = ipc->u.sp.s2;
longjmp(cint->CompilerBotch,3); yamop **clp = (yamop **)NEXTOP(ipc,sp);
}
if (ap->PredFlags & LogUpdatePredFlag) { if (cls+2*nclauses > (ClauseDef *)(ASP-4096)) {
max = install_log_upd_clauses(cls, ap, stack, first, last); /* tell how much space we need (worst case) */
Yap_Error_Size += NClauses*sizeof(ClauseDef);
/* grow stack */
longjmp(cint->CompilerBotch,3);
}
if (ap->PredFlags & LogUpdatePredFlag) {
max = install_log_upd_clauseseq(cls, ap, stack, clp, clp+nclauses);
} else {
max = install_clauseseq(cls, ap, stack, clp, clp+nclauses);
}
} else { } else {
max = install_clauses(cls, ap, stack, first, last); if (cls+2*NClauses > (ClauseDef *)(ASP-4096)) {
/* tell how much space we need (worst case) */
Yap_Error_Size += NClauses*sizeof(ClauseDef);
/* grow stack */
longjmp(cint->CompilerBotch,3);
}
if (ap->PredFlags & LogUpdatePredFlag) {
max = install_log_upd_clauses(cls, ap, stack, first, last);
} else {
max = install_clauses(cls, ap, stack, first, last);
}
} }
<<<<<<< index.c
fprintf(stderr,"expanding %d/%d %d\n",(max-cls)+1,NClauses, (Yap_op_from_opcode((*labp)->opc) == _expand_clauses));
=======
>>>>>>> 1.81
/* don't count last clause if you don't have to */ /* don't count last clause if you don't have to */
if (alt && max->Code == last) max--; if (alt && max->Code == last) max--;
if (max < cls && labp != NULL) { if (max < cls && labp != NULL) {
@ -4415,48 +4538,36 @@ pop_path(path_stack_entry **spp, ClauseDef *clp, PredEntry *ap)
static int static int
table_fe_overflow(yamop *pc, Functor f) table_fe_overflow(yamop *pc, Functor f)
{ {
if (pc->u.sl.s <= MIN_HASH_ENTRIES) { if (pc->u.sssl.s <= MIN_HASH_ENTRIES) {
/* we cannot expand otherwise */ /* we cannot expand otherwise */
COUNT i; COUNT i;
FuncSwiEntry *csw = (FuncSwiEntry *)pc->u.sl.l; FuncSwiEntry *csw = (FuncSwiEntry *)pc->u.sssl.l;
for (i=0; i < pc->u.sl.s; i++,csw++) { for (i=0; i < pc->u.sssl.s; i++,csw++) {
if (csw->Tag == f) return FALSE; if (csw->Tag == f) return FALSE;
} }
return TRUE; return TRUE;
} else { } else {
COUNT i, free = 0, used; COUNT free = pc->u.sssl.s-pc->u.sssl.e;
FuncSwiEntry *fsw = (FuncSwiEntry *)pc->u.sl.l; return (!free || pc->u.sssl.s/free > 4);
for (i=0; i<pc->u.sl.s; i++,fsw++) {
if (fsw->Tag == NULL) free++;
}
used = pc->u.sl.s-free;
used += 1+used/4;
return (!free || pc->u.sl.s/free > 4);
} }
} }
static int static int
table_ae_overflow(yamop *pc, Term at) table_ae_overflow(yamop *pc, Term at)
{ {
if (pc->u.sl.s <= MIN_HASH_ENTRIES) { if (pc->u.sssl.s <= MIN_HASH_ENTRIES) {
/* check if we are already there */ /* check if we are already there */
COUNT i; COUNT i;
AtomSwiEntry *csw = (AtomSwiEntry *)pc->u.sl.l; AtomSwiEntry *csw = (AtomSwiEntry *)pc->u.sssl.l;
for (i=0; i < pc->u.sl.s; i++,csw++) { for (i=0; i < pc->u.sssl.s; i++,csw++) {
if (csw->Tag == at) return FALSE; if (csw->Tag == at) return FALSE;
} }
return TRUE; return TRUE;
} else { } else {
COUNT i, free = 0, used; COUNT free = pc->u.sssl.s-pc->u.sssl.e;
AtomSwiEntry *csw = (AtomSwiEntry *)pc->u.sl.l; return (!free || pc->u.sssl.s/free > 4);
for (i=0; i<pc->u.sl.s; i++,csw++) {
if (csw->Tag == 0L) free++;
}
used = pc->u.sl.s-free;
used += 1+used/4;
return (!free || used >= pc->u.sl.s);
} }
} }
@ -4509,16 +4620,16 @@ static AtomSwiEntry *
expand_ctable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Term at) expand_ctable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Term at)
{ {
PredEntry *ap = cint->CurrentPred; PredEntry *ap = cint->CurrentPred;
int n = pc->u.sl.s, i, i0 = n; int n = pc->u.sssl.s, i, i0 = n;
UInt fail_l = Zero; UInt fail_l = Zero;
AtomSwiEntry *old_ae = (AtomSwiEntry *)(pc->u.sl.l), *target; AtomSwiEntry *old_ae = (AtomSwiEntry *)(pc->u.sssl.l), *target;
if (n > MIN_HASH_ENTRIES) { if (n > MIN_HASH_ENTRIES) {
AtomSwiEntry *tmp = old_ae; AtomSwiEntry *tmp = old_ae;
int i; int i;
n = 1; n = 1;
for (i = 0; i < pc->u.sl.s; i++,tmp++) { for (i = 0; i < pc->u.sssl.s; i++,tmp++) {
if (tmp->Tag != Zero) n++; if (tmp->Tag != Zero) n++;
else fail_l = tmp->Label; else fail_l = tmp->Label;
} }
@ -4530,20 +4641,20 @@ expand_ctable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Term at)
int cases = MIN_HASH_ENTRIES, i, n0; int cases = MIN_HASH_ENTRIES, i, n0;
n0 = n+1+n/4; n0 = n+1+n/4;
while (cases < n0) cases *= 2; while (cases < n0) cases *= 2;
if (cases == pc->u.sl.s) { if (cases == pc->u.sssl.s) {
return fetch_centry(old_ae, at, n-1, n); return fetch_centry(old_ae, at, n-1, n);
} }
/* initialise */ /* initialise */
target = (AtomSwiEntry *)emit_switch_space(cases, sizeof(AtomSwiEntry), cint); target = (AtomSwiEntry *)emit_switch_space(cases, sizeof(AtomSwiEntry), cint);
pc->opc = Yap_opcode(_switch_on_cons); pc->opc = Yap_opcode(_switch_on_cons);
pc->u.sl.s = cases; pc->u.sssl.s = cases;
for (i=0; i<cases; i++) { for (i=0; i<cases; i++) {
target[i].Tag = Zero; target[i].Tag = Zero;
target[i].Label = fail_l; target[i].Label = fail_l;
} }
} else { } else {
pc->opc = Yap_opcode(_if_cons); pc->opc = Yap_opcode(_if_cons);
pc->u.sl.s = n; pc->u.sssl.s = n;
target = (AtomSwiEntry *)emit_switch_space(n+1, sizeof(AtomSwiEntry), cint); target = (AtomSwiEntry *)emit_switch_space(n+1, sizeof(AtomSwiEntry), cint);
target[n].Tag = Zero; target[n].Tag = Zero;
target[n].Label = fail_l; target[n].Label = fail_l;
@ -4559,8 +4670,8 @@ expand_ctable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Term at)
} }
/* support for threads */ /* support for threads */
if (blk) if (blk)
replace_index_block(blk, pc->u.sl.l, (yamop *)target, ap); replace_index_block(blk, pc->u.sssl.l, (yamop *)target, ap);
pc->u.sl.l = (yamop *)target; pc->u.sssl.l = (yamop *)target;
return fetch_centry(target, at, n-1, n); return fetch_centry(target, at, n-1, n);
} }
@ -4568,16 +4679,16 @@ static FuncSwiEntry *
expand_ftable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Functor f) expand_ftable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Functor f)
{ {
PredEntry *ap = cint->CurrentPred; PredEntry *ap = cint->CurrentPred;
int n = pc->u.sl.s, i, i0 = n; int n = pc->u.sssl.s, i, i0 = n;
UInt fail_l = Zero; UInt fail_l = Zero;
FuncSwiEntry *old_fe = (FuncSwiEntry *)(pc->u.sl.l), *target; FuncSwiEntry *old_fe = (FuncSwiEntry *)(pc->u.sssl.l), *target;
if (n > MIN_HASH_ENTRIES) { if (n > MIN_HASH_ENTRIES) {
FuncSwiEntry *tmp = old_fe; FuncSwiEntry *tmp = old_fe;
int i; int i;
n = 1; n = 1;
for (i = 0; i < pc->u.sl.s; i++,tmp++) { for (i = 0; i < pc->u.sssl.s; i++,tmp++) {
if (tmp->Tag != Zero) n++; if (tmp->Tag != Zero) n++;
else fail_l = tmp->Label; else fail_l = tmp->Label;
} }
@ -4590,11 +4701,13 @@ expand_ftable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Functor f
n0 = n+1+n/4; n0 = n+1+n/4;
while (cases < n0) cases *= 2; while (cases < n0) cases *= 2;
if (cases == pc->u.sl.s) { if (cases == pc->u.sssl.s) {
return fetch_fentry(old_fe, f, n-1, n); return fetch_fentry(old_fe, f, n-1, n);
} }
pc->opc = Yap_opcode(_switch_on_func); pc->opc = Yap_opcode(_switch_on_func);
pc->u.sl.s = cases; pc->u.sssl.s = cases;
pc->u.sssl.e = n;
pc->u.sssl.w = 0;
/* initialise */ /* initialise */
target = (FuncSwiEntry *)emit_switch_space(cases, sizeof(FuncSwiEntry), cint); target = (FuncSwiEntry *)emit_switch_space(cases, sizeof(FuncSwiEntry), cint);
for (i=0; i<cases; i++) { for (i=0; i<cases; i++) {
@ -4603,7 +4716,9 @@ expand_ftable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Functor f
} }
} else { } else {
pc->opc = Yap_opcode(_if_func); pc->opc = Yap_opcode(_if_func);
pc->u.sl.s = n; pc->u.sssl.s = n;
pc->u.sssl.e = n;
pc->u.sssl.w = 0;
target = (FuncSwiEntry *)emit_switch_space(n+1, sizeof(FuncSwiEntry), cint); target = (FuncSwiEntry *)emit_switch_space(n+1, sizeof(FuncSwiEntry), cint);
target[n].Tag = Zero; target[n].Tag = Zero;
target[n].Label = fail_l; target[n].Label = fail_l;
@ -4617,8 +4732,8 @@ expand_ftable(yamop *pc, ClauseUnion *blk, struct intermediates *cint, Functor f
ifs->Label = old_fe->Label; ifs->Label = old_fe->Label;
} }
} }
replace_index_block(blk, pc->u.sl.l, (yamop *)target, ap); replace_index_block(blk, pc->u.sssl.l, (yamop *)target, ap);
pc->u.sl.l = (yamop *)target; pc->u.sssl.l = (yamop *)target;
return fetch_fentry(target, f, n-1, n); return fetch_fentry(target, f, n-1, n);
} }
@ -5199,9 +5314,40 @@ expandz_block(path_stack_entry *sp, PredEntry *ap, ClauseDef *cls, int group1, y
return sp; return sp;
} }
static LogUpdClause *
lu_clause(yamop *ipc)
{
LogUpdClause *c;
CELL *p = (CELL *)ipc;
if (ipc == FAILCODE)
return NULL;
while ((c = ClauseCodeToLogUpdClause(p))->Id != FunctorDBRef ||
!(c->ClFlags & LogUpdMask) ||
(c->ClFlags & (IndexMask|DynamicMask|SwitchTableMask|SwitchRootMask))) {
p--;
}
return c;
}
static StaticClause *
static_clause(yamop *ipc)
{
StaticClause *c;
CELL *p = (CELL *)ipc;
if (ipc == FAILCODE)
return NULL;
while ((c = ClauseCodeToStaticClause(p))->Id != FunctorDBRef ||
(c->ClFlags & (LogUpdMask|IndexMask|DynamicMask|SwitchTableMask|SwitchRootMask))) {
p--;
}
return c;
}
/* this code should be called when we jumped to clauses */ /* this code should be called when we jumped to clauses */
static path_stack_entry * path_stack_entry *
kill_unsafe_block(path_stack_entry *sp, op_numbers op, PredEntry *ap) kill_unsafe_block(path_stack_entry *sp, op_numbers op, PredEntry *ap, int first, int remove, ClauseDef *cls)
{ {
yamop *ipc; yamop *ipc;
while ((--sp)->flag != block_entry); while ((--sp)->flag != block_entry);
@ -5210,13 +5356,102 @@ kill_unsafe_block(path_stack_entry *sp, op_numbers op, PredEntry *ap)
ipc = *sp->u.cle.entry_code; ipc = *sp->u.cle.entry_code;
if (Yap_op_from_opcode(ipc->opc) == op) { if (Yap_op_from_opcode(ipc->opc) == op) {
/* the new block was the current clause */ /* the new block was the current clause */
*sp->u.cle.entry_code = (yamop *)&(ap->cs.p_code.ExpandCode); ClauseDef cld[2];
if (remove) {
*sp->u.cle.entry_code = FAILCODE;
return sp;
}
if (ap->PredFlags & LogUpdatePredFlag) {
LogUpdClause *lc = lu_clause(ipc);
if (first) {
cld[0].Code = lc->ClCode;
cld[1].Code = cls[0].Code;
} else {
cld[0].Code = cls[0].Code;
cld[1].Code = lc->ClCode;
}
} else {
StaticClause *lc = static_clause(ipc);
if (first) {
cld[0].Code = lc->ClCode;
cld[1].Code = cls[0].Code;
} else {
cld[0].Code = cls[0].Code;
cld[1].Code = lc->ClCode;
}
}
*sp->u.cle.entry_code = (yamop *)suspend_indexing_in_switch(cld, cld+1, ap);
return sp; return sp;
} }
/* we didn't have protection, should kill now */ /* we didn't have protection, should kill now */
return kill_block(sp+1, ap); return kill_block(sp+1, ap);
} }
/* this code should be called when we jumped to clauses */
static yamop *
add_to_expand_clauses(path_stack_entry **spp, yamop *ipc, ClauseDef *cls, PredEntry *ap, int first)
{
path_stack_entry *sp = *spp;
yamop **clar = (yamop **)NEXTOP(ipc,sp);
while ((--sp)->flag != block_entry);
if (first) {
if (*clar == NULL) {
while (*clar++ == NULL);
clar[-1] = cls->Code;
ipc->u.sp.s2++;
return pop_path(spp, cls, ap);
}
} else {
clar += ipc->u.sp.s1;
while (*--clar == NULL);
if (clar[0] == NULL) {
clar[0] = cls->Code;
ipc->u.sp.s2++;
return pop_path(spp, cls, ap);
}
}
if (sp->u.cle.entry_code) {
*sp->u.cle.entry_code = (yamop *)&(ap->cs.p_code.ExpandCode);
}
*spp = sp;
Yap_FreeCodeSpace((char *)ipc);
return (yamop *)&(ap->cs.p_code.ExpandCode);
}
/* this code should be called when we jumped to clauses */
static void
nullify_expand_clause(yamop *ipc, path_stack_entry *sp, ClauseDef *cls)
{
yamop **st = (yamop **)NEXTOP(ipc,sp);
if (ipc->u.sp.s2 == 2) {
yamop *cl;
while ((--sp)->flag != block_entry);
while (TRUE) {
if (*st && *st != cls->Code) {
cl = *st;
break;
}
st++;
}
if (sp->u.cle.entry_code) {
*sp->u.cle.entry_code = cl;
}
Yap_FreeCodeSpace((char *)ipc);
} else {
ipc->u.sp.s2--;
while (TRUE) {
if (*st && *st == cls->Code) {
*st = NULL;
return;
}
st++;
}
}
}
static void static void
add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, ClauseDef *cls) { add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, ClauseDef *cls) {
@ -5546,9 +5781,9 @@ add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, Clause
Functor f = (Functor)RepAppl(cls->Tag); Functor f = (Functor)RepAppl(cls->Tag);
if (op == _switch_on_func) { if (op == _switch_on_func) {
fe = lookup_f_hash(f, ipc->u.sl.l, ipc->u.sl.s); fe = lookup_f_hash(f, ipc->u.sssl.l, ipc->u.sssl.s);
} else { } else {
fe = lookup_f(f, ipc->u.sl.l, ipc->u.sl.s); fe = lookup_f(f, ipc->u.sssl.l, ipc->u.sssl.s);
} }
if (!IsExtensionFunctor(f)) { if (!IsExtensionFunctor(f)) {
current_arity = ArityOfFunctor(f); current_arity = ArityOfFunctor(f);
@ -5562,7 +5797,7 @@ add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, Clause
/* oops, nothing there */ /* oops, nothing there */
if (fe->Tag != f) { if (fe->Tag != f) {
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
sp = kill_unsafe_block(sp, op, ap); sp = kill_unsafe_block(sp, op, ap, first, FALSE, cls);
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
break; break;
} }
@ -5570,12 +5805,13 @@ add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, Clause
fe = expand_ftable(ipc, current_block(sp), cint, f); fe = expand_ftable(ipc, current_block(sp), cint, f);
} }
fe->Tag = f; fe->Tag = f;
ipc->u.sssl.e++;
} }
fe->Label = (UInt)cls->CurrentCode; fe->Label = (UInt)cls->CurrentCode;
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
} else { } else {
yamop *newpc = (yamop *)(fe->Label); yamop *newpc = (yamop *)(fe->Label);
sp = fetch_new_block(sp, &(ipc->u.sl.l), ap); sp = fetch_new_block(sp, &(ipc->u.sssl.l), ap);
sp = cross_block(sp, (yamop **)&(fe->Label), ap); sp = cross_block(sp, (yamop **)&(fe->Label), ap);
ipc = newpc; ipc = newpc;
} }
@ -5598,9 +5834,9 @@ add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, Clause
Term at = cls->Tag; Term at = cls->Tag;
if (op == _switch_on_cons) { if (op == _switch_on_cons) {
ae = lookup_c_hash(at,ipc->u.sl.l,ipc->u.sl.s); ae = lookup_c_hash(at,ipc->u.sssl.l,ipc->u.sssl.s);
} else { } else {
ae = lookup_c(at, ipc->u.sl.l, ipc->u.sl.s); ae = lookup_c(at, ipc->u.sssl.l, ipc->u.sssl.s);
} }
newpc = (yamop *)(ae->Label); newpc = (yamop *)(ae->Label);
@ -5614,17 +5850,22 @@ add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, Clause
ae = expand_ctable(ipc, current_block(sp), cint, at); ae = expand_ctable(ipc, current_block(sp), cint, at);
} }
ae->Tag = at; ae->Tag = at;
ipc->u.sssl.e++;
} }
ae->Label = (UInt)cls->CurrentCode; ae->Label = (UInt)cls->CurrentCode;
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
} else { } else {
yamop *newpc = (yamop *)(ae->Label); yamop *newpc = (yamop *)(ae->Label);
sp = fetch_new_block(sp, &(ipc->u.sl.l), ap);
sp = fetch_new_block(sp, &(ipc->u.sssl.l), ap);
sp = cross_block(sp, (yamop **)&(ae->Label), ap); sp = cross_block(sp, (yamop **)&(ae->Label), ap);
ipc = newpc; ipc = newpc;
} }
} }
break; break;
case _expand_clauses:
ipc = add_to_expand_clauses(&sp, ipc, cls, ap, first);
break;
case _expand_index: case _expand_index:
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
break; break;
@ -5635,7 +5876,7 @@ add_to_index(struct intermediates *cint, int first, path_stack_entry *sp, Clause
ipc = NEXTOP(ipc,e); ipc = NEXTOP(ipc,e);
break; break;
default: default:
sp = kill_unsafe_block(sp, op, ap); sp = kill_unsafe_block(sp, op, ap, first, FALSE, cls);
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
} }
} }
@ -5735,13 +5976,13 @@ Yap_AddClauseToIndex(PredEntry *ap, yamop *beg, int first) {
static void static void
contract_ftable(yamop *ipc, ClauseUnion *blk, PredEntry *ap, Functor f) { contract_ftable(yamop *ipc, ClauseUnion *blk, PredEntry *ap, Functor f) {
int n = ipc->u.sl.s; int n = ipc->u.sssl.s;
FuncSwiEntry *fep; FuncSwiEntry *fep;
if (n > MIN_HASH_ENTRIES) { if (n > MIN_HASH_ENTRIES) {
fep = lookup_f_hash(f, ipc->u.sl.l, n); fep = lookup_f_hash(f, ipc->u.sssl.l, n);
} else { } else {
fep = (FuncSwiEntry *)(ipc->u.sl.l); fep = (FuncSwiEntry *)(ipc->u.sssl.l);
while (fep->Tag != f) fep++; while (fep->Tag != f) fep++;
} }
fep->Label = (CELL)FAILCODE; fep->Label = (CELL)FAILCODE;
@ -5749,13 +5990,13 @@ contract_ftable(yamop *ipc, ClauseUnion *blk, PredEntry *ap, Functor f) {
static void static void
contract_ctable(yamop *ipc, ClauseUnion *blk, PredEntry *ap, Term at) { contract_ctable(yamop *ipc, ClauseUnion *blk, PredEntry *ap, Term at) {
int n = ipc->u.sl.s; int n = ipc->u.sssl.s;
AtomSwiEntry *cep; AtomSwiEntry *cep;
if (n > MIN_HASH_ENTRIES) { if (n > MIN_HASH_ENTRIES) {
cep = lookup_c_hash(at, ipc->u.sl.l, n); cep = lookup_c_hash(at, ipc->u.sssl.l, n);
} else { } else {
cep = (AtomSwiEntry *)(ipc->u.sl.l); cep = (AtomSwiEntry *)(ipc->u.sssl.l);
while (cep->Tag != at) cep++; while (cep->Tag != at) cep++;
} }
cep->Label = (CELL)FAILCODE; cep->Label = (CELL)FAILCODE;
@ -6065,9 +6306,9 @@ remove_from_index(PredEntry *ap, path_stack_entry *sp, ClauseDef *cls, yamop *bg
Functor f = (Functor)RepAppl(cls->Tag); Functor f = (Functor)RepAppl(cls->Tag);
if (op == _switch_on_func) { if (op == _switch_on_func) {
fe = lookup_f_hash(f, ipc->u.sl.l, ipc->u.sl.s); fe = lookup_f_hash(f, ipc->u.sssl.l, ipc->u.sssl.s);
} else { } else {
fe = lookup_f(f, ipc->u.sl.l, ipc->u.sl.s); fe = lookup_f(f, ipc->u.sssl.l, ipc->u.sssl.s);
} }
if (!IsExtensionFunctor(f)) { if (!IsExtensionFunctor(f)) {
current_arity = ArityOfFunctor(f); current_arity = ArityOfFunctor(f);
@ -6085,7 +6326,7 @@ remove_from_index(PredEntry *ap, path_stack_entry *sp, ClauseDef *cls, yamop *bg
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
} else { } else {
yamop *newpc = (yamop *)(fe->Label); yamop *newpc = (yamop *)(fe->Label);
sp = fetch_new_block(sp, &(ipc->u.sl.l), ap); sp = fetch_new_block(sp, &(ipc->u.sssl.l), ap);
sp = cross_block(sp, (yamop **)&(fe->Label), ap); sp = cross_block(sp, (yamop **)&(fe->Label), ap);
ipc = newpc; ipc = newpc;
} }
@ -6108,9 +6349,9 @@ remove_from_index(PredEntry *ap, path_stack_entry *sp, ClauseDef *cls, yamop *bg
Term at = cls->Tag; Term at = cls->Tag;
if (op == _switch_on_cons) { if (op == _switch_on_cons) {
ae = lookup_c_hash(at,ipc->u.sl.l,ipc->u.sl.s); ae = lookup_c_hash(at,ipc->u.sssl.l,ipc->u.sssl.s);
} else { } else {
ae = lookup_c(at, ipc->u.sl.l, ipc->u.sl.s); ae = lookup_c(at, ipc->u.sssl.l, ipc->u.sssl.s);
} }
newpc = (yamop *)(ae->Label); newpc = (yamop *)(ae->Label);
@ -6126,7 +6367,7 @@ remove_from_index(PredEntry *ap, path_stack_entry *sp, ClauseDef *cls, yamop *bg
} else { } else {
yamop *newpc = (yamop *)(ae->Label); yamop *newpc = (yamop *)(ae->Label);
sp = fetch_new_block(sp, &(ipc->u.sl.l), ap); sp = fetch_new_block(sp, &(ipc->u.sssl.l), ap);
sp = cross_block(sp, (yamop **)&(ae->Label), ap); sp = cross_block(sp, (yamop **)&(ae->Label), ap);
ipc = newpc; ipc = newpc;
} }
@ -6135,6 +6376,10 @@ remove_from_index(PredEntry *ap, path_stack_entry *sp, ClauseDef *cls, yamop *bg
case _expand_index: case _expand_index:
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
break; break;
case _expand_clauses:
nullify_expand_clause(ipc, sp, cls);
ipc = pop_path(&sp, cls, ap);
break;
case _lock_lu: case _lock_lu:
ipc = NEXTOP(ipc,p); ipc = NEXTOP(ipc,p);
break; break;
@ -6143,7 +6388,7 @@ remove_from_index(PredEntry *ap, path_stack_entry *sp, ClauseDef *cls, yamop *bg
break; break;
default: default:
if (IN_BETWEEN(bg,ipc,lt)) { if (IN_BETWEEN(bg,ipc,lt)) {
sp = kill_unsafe_block(sp, op, ap); sp = kill_unsafe_block(sp, op, ap, TRUE, TRUE, cls);
} }
ipc = pop_path(&sp, cls, ap); ipc = pop_path(&sp, cls, ap);
} }
@ -6256,37 +6501,6 @@ Yap_RemoveClauseFromIndex(PredEntry *ap, yamop *beg) {
} }
static LogUpdClause *
lu_clause(yamop *ipc)
{
LogUpdClause *c;
CELL *p = (CELL *)ipc;
if (ipc == FAILCODE)
return NULL;
while ((c = ClauseCodeToLogUpdClause(p))->Id != FunctorDBRef ||
!(c->ClFlags & LogUpdMask) ||
(c->ClFlags & (IndexMask|DynamicMask|SwitchTableMask|SwitchRootMask))) {
p--;
}
return c;
}
static LogUpdClause *
static_clause(yamop *ipc)
{
StaticClause *c;
CELL *p = (CELL *)ipc;
if (ipc == FAILCODE)
return NULL;
while ((c = ClauseCodeToStaticClause(p))->Id != FunctorDBRef ||
(c->ClFlags & (LogUpdMask|IndexMask|DynamicMask|SwitchTableMask|SwitchRootMask))) {
p--;
}
return (LogUpdClause *)c;
}
static void static void
store_clause_choice_point(Term t1, Term tb, Term tr, yamop *ipc, PredEntry *pe, yamop *ap_pc, yamop *cp_pc) store_clause_choice_point(Term t1, Term tb, Term tr, yamop *ipc, PredEntry *pe, yamop *ap_pc, yamop *cp_pc)
{ {
@ -6334,11 +6548,11 @@ to_clause(yamop *ipc, PredEntry *ap)
if (ap->PredFlags & LogUpdatePredFlag) if (ap->PredFlags & LogUpdatePredFlag)
return lu_clause(ipc); return lu_clause(ipc);
else else
return static_clause(ipc); return (LogUpdClause *)static_clause(ipc);
} }
LogUpdClause * LogUpdClause *
Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yamop *ap_pc, yamop *cp_pc) Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term Terms[3], yamop *ap_pc, yamop *cp_pc)
{ {
CELL *s_reg = NULL; CELL *s_reg = NULL;
Term t = TermNil; Term t = TermNil;
@ -6349,7 +6563,7 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
if (ap->ModuleOfPred != IDB_MODULE) { if (ap->ModuleOfPred != IDB_MODULE) {
if (ap->ArityOfPE) { if (ap->ArityOfPE) {
CELL *tar = RepAppl(t1); CELL *tar = RepAppl(Terms[0]);
UInt i; UInt i;
for (i = 1; i <= ap->ArityOfPE; i++) { for (i = 1; i <= ap->ArityOfPE; i++) {
@ -6367,24 +6581,24 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
if (lu_pred) if (lu_pred)
return lu_clause(ipc->u.l.l); return lu_clause(ipc->u.l.l);
else else
return static_clause(ipc->u.l.l); return (LogUpdClause *)static_clause(ipc->u.l.l);
break; break;
case _try_clause: case _try_clause:
if (b0 == NULL) if (b0 == NULL)
store_clause_choice_point(t1, tb, tr, NEXTOP(ipc,ld), ap, ap_pc, cp_pc); store_clause_choice_point(Terms[0], Terms[1], Terms[2], NEXTOP(ipc,ld), ap, ap_pc, cp_pc);
else else
update_clause_choice_point(NEXTOP(ipc,ld), ap_pc); update_clause_choice_point(NEXTOP(ipc,ld), ap_pc);
if (lu_pred) if (lu_pred)
return lu_clause(ipc->u.ld.d); return lu_clause(ipc->u.ld.d);
else else
return static_clause(ipc->u.ld.d); return (LogUpdClause *)static_clause(ipc->u.ld.d);
case _try_me: case _try_me:
case _try_me1: case _try_me1:
case _try_me2: case _try_me2:
case _try_me3: case _try_me3:
case _try_me4: case _try_me4:
if (b0 == NULL) if (b0 == NULL)
store_clause_choice_point(t1, tb, tr, ipc->u.ld.d, ap, ap_pc, cp_pc); store_clause_choice_point(Terms[0], Terms[1], Terms[2], ipc->u.ld.d, ap, ap_pc, cp_pc);
else else
update_clause_choice_point(ipc->u.ld.d, ap_pc); update_clause_choice_point(ipc->u.ld.d, ap_pc);
ipc = NEXTOP(ipc,ld); ipc = NEXTOP(ipc,ld);
@ -6398,7 +6612,7 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
if (lu_pred) if (lu_pred)
return lu_clause(ipc->u.ld.d); return lu_clause(ipc->u.ld.d);
else else
return static_clause(ipc->u.ld.d); return (LogUpdClause *)static_clause(ipc->u.ld.d);
case _retry_me: case _retry_me:
case _retry_me1: case _retry_me1:
case _retry_me2: case _retry_me2:
@ -6420,7 +6634,7 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
if (lu_pred) if (lu_pred)
return lu_clause(ipc->u.ld.d); return lu_clause(ipc->u.ld.d);
else else
return static_clause(ipc->u.ld.d); return (LogUpdClause *)static_clause(ipc->u.ld.d);
case _profiled_trust_me: case _profiled_trust_me:
case _trust_me: case _trust_me:
case _count_trust_me: case _count_trust_me:
@ -6478,9 +6692,9 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
yamop *nipc = clean_up_index(ipc->u.Ill.I, jlbl, ap); yamop *nipc = clean_up_index(ipc->u.Ill.I, jlbl, ap);
if (nipc == NULL) { if (nipc == NULL) {
/* not enough space */ /* not enough space */
H[0] = t1; H[0] = Terms[0];
H[1] = tb; H[1] = Terms[1];
H[2] = tr; H[2] = Terms[2];
H += 3; H += 3;
if (!Yap_growheap(FALSE, Yap_Error_Size, NULL)) { if (!Yap_growheap(FALSE, Yap_Error_Size, NULL)) {
UNLOCK(ap->PELock); UNLOCK(ap->PELock);
@ -6488,9 +6702,9 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
return NULL; return NULL;
} }
H -= 3; H -= 3;
t1 = H[0]; Terms[0] = H[0];
tb = H[1]; Terms[1] = H[1];
tr = H[2]; Terms[2] = H[2];
} else { } else {
UNLOCK(ap->PELock); UNLOCK(ap->PELock);
ipc = nipc; ipc = nipc;
@ -6636,9 +6850,9 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
f = (Functor)s_reg[0]; f = (Functor)s_reg[0];
s_reg++; s_reg++;
if (op == _switch_on_func) { if (op == _switch_on_func) {
fe = lookup_f_hash(f, ipc->u.sl.l, ipc->u.sl.s); fe = lookup_f_hash(f, ipc->u.sssl.l, ipc->u.sssl.s);
} else { } else {
fe = lookup_f(f, ipc->u.sl.l, ipc->u.sl.s); fe = lookup_f(f, ipc->u.sssl.l, ipc->u.sssl.s);
} }
jlbl = (yamop **)(&fe->Label); jlbl = (yamop **)(&fe->Label);
ipc = (yamop *)(fe->Label); ipc = (yamop *)(fe->Label);
@ -6659,15 +6873,22 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
AtomSwiEntry *ae; AtomSwiEntry *ae;
if (op == _switch_on_cons) { if (op == _switch_on_cons) {
ae = lookup_c_hash(t, ipc->u.sl.l, ipc->u.sl.s); ae = lookup_c_hash(t, ipc->u.sssl.l, ipc->u.sssl.s);
} else { } else {
ae = lookup_c(t, ipc->u.sl.l, ipc->u.sl.s); ae = lookup_c(t, ipc->u.sssl.l, ipc->u.sssl.s);
} }
jlbl = (yamop **)(&ae->Label); jlbl = (yamop **)(&ae->Label);
ipc = (yamop *)(ae->Label); ipc = (yamop *)(ae->Label);
} }
break; break;
case _expand_index: case _expand_index:
case _expand_clauses:
*H++ = (CELL)s_reg;
*H++ = t;
H[0] = Terms[0];
H[1] = Terms[1];
H[2] = Terms[2];
H += 3;
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
LOCK(ap->PELock); LOCK(ap->PELock);
if (*jlbl != ipc) { if (*jlbl != ipc) {
@ -6678,6 +6899,12 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
#endif #endif
ipc = ExpandIndex(ap); ipc = ExpandIndex(ap);
UNLOCK(ap->PELock); UNLOCK(ap->PELock);
H -= 3;
Terms[0] = H[0];
Terms[1] = H[1];
Terms[2] = H[2];
t = *--H;
s_reg = (CELL *)(*--H);
break; break;
case _op_fail: case _op_fail:
/* /*
@ -6718,7 +6945,7 @@ Yap_FollowIndexingCode(PredEntry *ap, yamop *ipc, Term t1, Term tb, Term tr, yam
if (lu_pred) if (lu_pred)
return lu_clause(ipc); return lu_clause(ipc);
else else
return static_clause(ipc); return (LogUpdClause *)static_clause(ipc);
} }
} }
if (b0) { if (b0) {
@ -6896,6 +7123,7 @@ Yap_NthClause(PredEntry *ap, Int ncls)
ipc = ipc->u.clll.l3; ipc = ipc->u.clll.l3;
break; break;
case _expand_index: case _expand_index:
case _expand_clauses:
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
LOCK(ap->PELock); LOCK(ap->PELock);
if (*jlbl != (yamop *)&(ap->cs.p_code.ExpandCode)) { if (*jlbl != (yamop *)&(ap->cs.p_code.ExpandCode)) {
@ -7100,9 +7328,9 @@ find_caller(PredEntry *ap, yamop *code) {
s_reg = RepAppl(t); s_reg = RepAppl(t);
f = (Functor)(*s_reg++); f = (Functor)(*s_reg++);
if (op == _switch_on_func) { if (op == _switch_on_func) {
fe = lookup_f_hash(f,ipc->u.sl.l,ipc->u.sl.s); fe = lookup_f_hash(f,ipc->u.sssl.l,ipc->u.sssl.s);
} else { } else {
fe = lookup_f(f,ipc->u.sl.l,ipc->u.sl.s); fe = lookup_f(f,ipc->u.sssl.l,ipc->u.sssl.s);
} }
newpc = (yamop *)(fe->Label); newpc = (yamop *)(fe->Label);
@ -7124,9 +7352,9 @@ find_caller(PredEntry *ap, yamop *code) {
yamop *newpc; yamop *newpc;
if (op == _switch_on_cons) { if (op == _switch_on_cons) {
ae = lookup_c_hash(t,ipc->u.sl.l,ipc->u.sl.s); ae = lookup_c_hash(t,ipc->u.sssl.l,ipc->u.sssl.s);
} else { } else {
ae = lookup_c(t,ipc->u.sl.l,ipc->u.sl.s); ae = lookup_c(t,ipc->u.sssl.l,ipc->u.sssl.s);
} }
newpc = (yamop *)(ae->Label); newpc = (yamop *)(ae->Label);
@ -7143,6 +7371,7 @@ find_caller(PredEntry *ap, yamop *code) {
} }
break; break;
case _expand_index: case _expand_index:
case _expand_clauses:
ipc = alt; ipc = alt;
alt = NULL; alt = NULL;
break; break;