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

redo lost updates

Browse Source
This commit is contained in:
Vítor Santos Costa 2008-08-21 13:38:25 +01:00
parent 258796098e
commit f499115573
19 changed files with 2120 additions and 2276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1504
C/absmi.c
View File

File diff suppressed because it is too large Load Diff

357
C/amasm.c
View File

@ -230,10 +230,10 @@ STATIC_PROTO(OPCODE emit_op, (op_numbers));
STATIC_PROTO(yamop *a_cle, (op_numbers, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_cle, (op_numbers, yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *a_e, (op_numbers, yamop *, int)); STATIC_PROTO(yamop *a_e, (op_numbers, yamop *, int));
STATIC_PROTO(yamop *a_ue, (op_numbers, op_numbers, yamop *, int)); STATIC_PROTO(yamop *a_ue, (op_numbers, op_numbers, yamop *, int));
STATIC_PROTO(yamop *a_v, (op_numbers, yamop *, int, struct PSEUDO *)); STATIC_PROTO(yamop *a_v, (op_numbers, op_numbers, yamop *, int, struct PSEUDO *));
STATIC_PROTO(yamop *a_uv, (Ventry *,op_numbers, op_numbers, yamop *, int)); STATIC_PROTO(yamop *a_uv, (Ventry *,op_numbers, op_numbers, op_numbers, op_numbers, yamop *, int));
STATIC_PROTO(yamop *a_vr, (op_numbers, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_vr, (op_numbers, op_numbers, yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *a_rv, (op_numbers, OPREG, yamop *, int, struct PSEUDO *)); STATIC_PROTO(yamop *a_rv, (op_numbers, op_numbers, OPREG, yamop *, int, struct PSEUDO *));
STATIC_PROTO(yamop *a_vv, (op_numbers, op_numbers, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_vv, (op_numbers, op_numbers, yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *a_glist, (int *, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_glist, (int *, yamop *, int, struct intermediates *));
STATIC_PROTO(void a_pair, (CELL *, int, struct intermediates *)); STATIC_PROTO(void a_pair, (CELL *, int, struct intermediates *));
@ -260,7 +260,8 @@ STATIC_PROTO(yamop *a_either, (op_numbers, CELL, CELL, yamop *, int, struct int
#endif /* YAPOR */ #endif /* YAPOR */
STATIC_PROTO(yamop *a_gl, (op_numbers, yamop *, int, struct PSEUDO *, struct intermediates *)); STATIC_PROTO(yamop *a_gl, (op_numbers, yamop *, int, struct PSEUDO *, struct intermediates *));
STATIC_PROTO(yamop *a_bfunc, (CELL, clause_info *, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_bfunc, (CELL, clause_info *, yamop *, int, struct intermediates *));
STATIC_PROTO(wamreg compile_cmp_flags, (char *)); STATIC_PROTO(
COUNT compile_cmp_flags, (char *));
STATIC_PROTO(yamop *a_igl, (CELL, op_numbers, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_igl, (CELL, op_numbers, yamop *, int, struct intermediates *));
STATIC_PROTO(yamop *a_xigl, (op_numbers, yamop *, int, struct PSEUDO *)); STATIC_PROTO(yamop *a_xigl, (op_numbers, yamop *, int, struct PSEUDO *));
STATIC_PROTO(yamop *a_ucons, (int *, compiler_vm_op, yamop *, int, struct intermediates *)); STATIC_PROTO(yamop *a_ucons, (int *, compiler_vm_op, yamop *, int, struct intermediates *));
@ -482,15 +483,12 @@ a_lucl(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip,
if (pass_no) { if (pass_no) {
LogUpdIndex *lcl = (LogUpdIndex *)cip->code_addr; LogUpdIndex *lcl = (LogUpdIndex *)cip->code_addr;
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.Ill.I = lcl; code_p->u.Ills.I = lcl;
cip->current_try_lab = &code_p->u.Ill.l1; cip->current_try_lab = &code_p->u.Ills.l1;
cip->current_trust_lab = &code_p->u.Ill.l2; cip->current_trust_lab = &code_p->u.Ills.l2;
code_p->u.Ill.s = cip->cpc->rnd3; code_p->u.Ills.s = cip->cpc->rnd3;
#if defined(YAPOR) || defined(THREADS)
code_p->u.Ill.p = cip->CurrentPred;
#endif
} }
GONEXT(Ill); GONEXT(Ills);
return code_p; return code_p;
} }
@ -501,17 +499,11 @@ a_cle(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip)
LogUpdClause *cl = (LogUpdClause *)cip->code_addr; LogUpdClause *cl = (LogUpdClause *)cip->code_addr;
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.EC.ClTrail = 0; code_p->u.L.ClBase = cl;
code_p->u.EC.ClENV = 0;
code_p->u.EC.ClRefs = 0;
code_p->u.EC.ClBase = cl;
#if defined(THREADS) || defined(YAPOR)
code_p->u.EC.p = cip->CurrentPred;
#endif
cl->ClExt = code_p; cl->ClExt = code_p;
cl->ClFlags |= LogUpdRuleMask; cl->ClFlags |= LogUpdRuleMask;
} }
GONEXT(EC); GONEXT(L);
return code_p; return code_p;
} }
@ -537,23 +529,23 @@ a_ue(op_numbers opcode, op_numbers opcodew, yamop *code_p, int pass_no)
} }
inline static yamop * inline static yamop *
a_v(op_numbers opcode, yamop *code_p, int pass_no, struct PSEUDO *cpc) a_v(op_numbers opcodex, op_numbers opcodey, yamop *code_p, int pass_no, struct PSEUDO *cpc)
{ {
Ventry *ve = (Ventry *) cpc->rnd1; Ventry *ve = (Ventry *) cpc->rnd1;
OPREG var_offset; OPREG var_offset;
int is_y_var = (ve->KindOfVE == PermVar); int is_y_var = (ve->KindOfVE == PermVar);
var_offset = Var_Ref(ve, is_y_var); var_offset = Var_Ref(ve, is_y_var);
if (ve->KindOfVE == PermVar) { if (is_y_var) {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodey);
code_p->u.y.y = emit_yreg(var_offset); code_p->u.y.y = emit_yreg(var_offset);
} }
GONEXT(y); GONEXT(y);
} }
else { else {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodex);
code_p->u.x.x = emit_xreg(var_offset); code_p->u.x.x = emit_xreg(var_offset);
} }
GONEXT(x); GONEXT(x);
@ -562,7 +554,7 @@ a_v(op_numbers opcode, yamop *code_p, int pass_no, struct PSEUDO *cpc)
} }
inline static yamop * inline static yamop *
a_uv(Ventry *ve, op_numbers opcode, op_numbers opcodew, yamop *code_p, int pass_no) a_uv(Ventry *ve, op_numbers opcodex, op_numbers opcodexw, op_numbers opcodey, op_numbers opcodeyw, yamop *code_p, int pass_no)
{ {
OPREG var_offset; OPREG var_offset;
int is_y_var = (ve->KindOfVE == PermVar); int is_y_var = (ve->KindOfVE == PermVar);
@ -570,16 +562,16 @@ a_uv(Ventry *ve, op_numbers opcode, op_numbers opcodew, yamop *code_p, int pass_
var_offset = Var_Ref(ve, is_y_var); var_offset = Var_Ref(ve, is_y_var);
if (is_y_var) { if (is_y_var) {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodey);
code_p->u.oy.opcw = emit_op((op_numbers)((int)opcodew + is_y_var)); code_p->u.oy.opcw = emit_op(opcodeyw);
code_p->u.oy.y = emit_yreg(var_offset); code_p->u.oy.y = emit_yreg(var_offset);
} }
GONEXT(oy); GONEXT(oy);
} }
else { else {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodex);
code_p->u.ox.opcw = emit_op((op_numbers)((int)opcodew + is_y_var)); code_p->u.ox.opcw = emit_op(opcodexw);
code_p->u.ox.x = emit_xreg(var_offset); code_p->u.ox.x = emit_xreg(var_offset);
} }
GONEXT(ox); GONEXT(ox);
@ -614,7 +606,7 @@ a_vv(op_numbers opcode, op_numbers opcodew, yamop *code_p, int pass_no, struct i
} }
inline static yamop * inline static yamop *
a_vr(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip) a_vr(op_numbers opcodex, op_numbers opcodey, yamop *code_p, int pass_no, struct intermediates *cip)
{ {
struct PSEUDO *cpc = cip->cpc; struct PSEUDO *cpc = cip->cpc;
Ventry *ve = (Ventry *) cpc->rnd1; Ventry *ve = (Ventry *) cpc->rnd1;
@ -625,13 +617,13 @@ a_vr(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip)
OPREG var_offset; OPREG var_offset;
var_offset = Var_Ref(ve, is_y_var); var_offset = Var_Ref(ve, is_y_var);
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodey);
code_p->u.yx.y = emit_yreg(var_offset); code_p->u.yx.y = emit_yreg(var_offset);
code_p->u.yx.x = emit_x(cpc->rnd2); code_p->u.yx.x = emit_x(cpc->rnd2);
} }
GONEXT(yx); GONEXT(yx);
} }
else if (opcode == _put_x_val && else if (opcodex == _put_x_val &&
cpc->nextInst && cpc->nextInst &&
cpc->nextInst->op == put_val_op && cpc->nextInst->op == put_val_op &&
!(((Ventry *) cpc->nextInst->rnd1)->KindOfVE == PermVar)) { !(((Ventry *) cpc->nextInst->rnd1)->KindOfVE == PermVar)) {
@ -656,7 +648,7 @@ a_vr(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip)
OPREG var_offset; OPREG var_offset;
var_offset = Var_Ref(ve, is_y_var); var_offset = Var_Ref(ve, is_y_var);
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodex);
code_p->u.xx.xl = emit_xreg(var_offset); code_p->u.xx.xl = emit_xreg(var_offset);
code_p->u.xx.xr = emit_x(cpc->rnd2); code_p->u.xx.xr = emit_x(cpc->rnd2);
} }
@ -666,14 +658,14 @@ a_vr(op_numbers opcode, yamop *code_p, int pass_no, struct intermediates *cip)
} }
inline static yamop * inline static yamop *
a_rv(op_numbers opcode, OPREG var_offset, yamop *code_p, int pass_no, struct PSEUDO *cpc) a_rv(op_numbers opcodex, op_numbers opcodey, OPREG var_offset, yamop *code_p, int pass_no, struct PSEUDO *cpc)
{ {
Ventry *ve = (Ventry *) cpc->rnd1; Ventry *ve = (Ventry *) cpc->rnd1;
int is_y_var = (ve->KindOfVE == PermVar); int is_y_var = (ve->KindOfVE == PermVar);
if (is_y_var) { if (is_y_var) {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodey);
code_p->u.xy.x = emit_x(cpc->rnd2); code_p->u.xy.x = emit_x(cpc->rnd2);
code_p->u.xy.y = emit_yreg(var_offset); code_p->u.xy.y = emit_yreg(var_offset);
} }
@ -681,7 +673,7 @@ a_rv(op_numbers opcode, OPREG var_offset, yamop *code_p, int pass_no, struct PSE
} }
else { else {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op((op_numbers)((int)opcode + is_y_var)); code_p->opc = emit_op(opcodex);
code_p->u.xx.xl = emit_x(cpc->rnd2); code_p->u.xx.xl = emit_x(cpc->rnd2);
code_p->u.xx.xr = emit_xreg(var_offset); code_p->u.xx.xr = emit_xreg(var_offset);
} }
@ -792,10 +784,10 @@ a_f(CELL rnd1, op_numbers opcode, yamop *code_p, int pass_no)
Functor f = emit_f(rnd1); Functor f = emit_f(rnd1);
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.f.f = f; code_p->u.fa.f = f;
code_p->u.f.a = ArityOfFunctor(f); code_p->u.fa.a = ArityOfFunctor(f);
} }
GONEXT(f); GONEXT(fa);
return code_p; return code_p;
} }
@ -806,11 +798,11 @@ a_uf(CELL rnd1, op_numbers opcode, op_numbers opcodew, yamop *code_p, int pass_n
Functor f = emit_f(rnd1); Functor f = emit_f(rnd1);
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.of.opcw = emit_op(opcodew); code_p->u.ofa.opcw = emit_op(opcodew);
code_p->u.of.f = f; code_p->u.ofa.f = f;
code_p->u.of.a = ArityOfFunctor(f); code_p->u.ofa.a = ArityOfFunctor(f);
} }
GONEXT(of); GONEXT(ofa);
return code_p; return code_p;
} }
@ -978,11 +970,11 @@ a_rf(op_numbers opcode, yamop *code_p, int pass_no, struct PSEUDO *cpc)
{ {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.xf.x = emit_x(cpc->rnd2); code_p->u.xfa.x = emit_x(cpc->rnd2);
code_p->u.xf.f = emit_f(cpc->rnd1); code_p->u.xfa.f = emit_f(cpc->rnd1);
code_p->u.xf.a = ArityOfFunctor(emit_f(cpc->rnd1)); code_p->u.xfa.a = ArityOfFunctor(emit_f(cpc->rnd1));
} }
GONEXT(xf); GONEXT(xfa);
return code_p; return code_p;
} }
@ -1243,14 +1235,14 @@ a_p(op_numbers opcode, clause_info *clinfo, yamop *code_p, int pass_no, struct i
longjmp(cip->CompilerBotch, 1); longjmp(cip->CompilerBotch, 1);
} else } else
code_p->opc = emit_op(_call_c_wfail); code_p->opc = emit_op(_call_c_wfail);
code_p->u.sdl.s = code_p->u.sdlp.s =
emit_count(-Signed(RealEnvSize) - CELLSIZE * cip->cpc->rnd2); emit_count(-Signed(RealEnvSize) - CELLSIZE * cip->cpc->rnd2);
code_p->u.sdl.l = code_p->u.sdlp.l =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]);
code_p->u.sdl.p = code_p->u.sdlp.p =
emit_pe(RepPredProp(fe)); emit_pe(RepPredProp(fe));
} }
GONEXT(sdl); GONEXT(sdlp);
clinfo->commit_lab = 0; clinfo->commit_lab = 0;
} else { } else {
if (pass_no) { if (pass_no) {
@ -1265,22 +1257,22 @@ a_p(op_numbers opcode, clause_info *clinfo, yamop *code_p, int pass_no, struct i
code_p->opc = emit_op(_call_cpred); code_p->opc = emit_op(_call_cpred);
} }
} }
code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - CELLSIZE code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize) - CELLSIZE
* (cip->cpc->rnd2)); * (cip->cpc->rnd2));
if (RepPredProp(fe)->FunctorOfPred != FunctorExecuteInMod) { if (RepPredProp(fe)->FunctorOfPred != FunctorExecuteInMod) {
code_p->u.sla.sla_u.p = RepPredProp(fe); code_p->u.sbpp.p = RepPredProp(fe);
} else { } else {
code_p->u.sla.sla_u.mod = cip->cpc->rnd4; code_p->u.sbmp.mod = cip->cpc->rnd4;
} }
code_p->u.sla.p0 = clinfo->CurrentPred; code_p->u.sbpp.p0 = clinfo->CurrentPred;
if (cip->cpc->rnd2) { if (cip->cpc->rnd2) {
code_p->u.sla.bmap = emit_bmlabel(cip->cpc->arnds[1], cip); code_p->u.sbpp.bmap = emit_bmlabel(cip->cpc->arnds[1], cip);
} else { } else {
/* there is no bitmap as there are no variables in the environment */ /* there is no bitmap as there are no variables in the environment */
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
} }
} }
GONEXT(sla); GONEXT(sbpp);
} }
return code_p; return code_p;
} }
@ -1300,17 +1292,17 @@ a_p(op_numbers opcode, clause_info *clinfo, yamop *code_p, int pass_no, struct i
} }
if (opcode == _call) { if (opcode == _call) {
if (pass_no) { if (pass_no) {
code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - CELLSIZE * code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize) - CELLSIZE *
cip->cpc->rnd2); cip->cpc->rnd2);
code_p->u.sla.sla_u.p = RepPredProp(fe); code_p->u.sbpp.p = RepPredProp(fe);
code_p->u.sla.p0 = clinfo->CurrentPred; code_p->u.sbpp.p0 = clinfo->CurrentPred;
if (cip->cpc->rnd2) if (cip->cpc->rnd2)
code_p->u.sla.bmap = emit_bmlabel(cip->cpc->arnds[1], cip); code_p->u.sbpp.bmap = emit_bmlabel(cip->cpc->arnds[1], cip);
else else
/* there is no bitmap as there are no variables in the environment */ /* there is no bitmap as there are no variables in the environment */
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
} }
GONEXT(sla); GONEXT(sbpp);
} }
else if (opcode == _execute || else if (opcode == _execute ||
opcode == _dexecute) { opcode == _dexecute) {
@ -1347,17 +1339,17 @@ a_empty_call(clause_info *clinfo, yamop *code_p, int pass_no, struct intermedia
} }
if (pass_no) { if (pass_no) {
PredEntry *pe = RepPredProp(Yap_GetPredPropByAtom(AtomTrue,0)); PredEntry *pe = RepPredProp(Yap_GetPredPropByAtom(AtomTrue,0));
code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - CELLSIZE * code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize) - CELLSIZE *
cip->cpc->rnd2); cip->cpc->rnd2);
code_p->u.sla.sla_u.p = pe; code_p->u.sbpp.p = pe;
code_p->u.sla.p0 = clinfo->CurrentPred; code_p->u.sbpp.p0 = clinfo->CurrentPred;
if (cip->cpc->rnd2) if (cip->cpc->rnd2)
code_p->u.sla.bmap = emit_bmlabel(cip->cpc->rnd1, cip); code_p->u.sbpp.bmap = emit_bmlabel(cip->cpc->rnd1, cip);
else else
/* there is no bitmap as there are no variables in the environment */ /* there is no bitmap as there are no variables in the environment */
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
} }
GONEXT(sla); GONEXT(sbpp);
return code_p; return code_p;
} }
@ -1372,7 +1364,7 @@ a_pl(op_numbers opcode, PredEntry *pred, yamop *code_p, int pass_no)
return code_p; return code_p;
} }
static wamreg static COUNT
compile_cmp_flags(char *s) compile_cmp_flags(char *s)
{ {
if (strcmp(s,"=<") == 0) if (strcmp(s,"=<") == 0)
@ -1401,7 +1393,7 @@ compile_cmp_flags(char *s)
return(0); return(0);
} }
wamreg COUNT
Yap_compile_cmp_flags(PredEntry *pred) Yap_compile_cmp_flags(PredEntry *pred)
{ {
return return
@ -1425,35 +1417,35 @@ a_bfunc(CELL pred, clause_info *clinfo, yamop *code_p, int pass_no, struct inter
if (is_y_var) { if (is_y_var) {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(_call_bfunc_yy); code_p->opc = emit_op(_call_bfunc_yy);
code_p->u.llyy.p = RepPredProp(((Prop)pred)); code_p->u.plyys.p = RepPredProp(((Prop)pred));
if (clinfo->commit_lab) { if (clinfo->commit_lab) {
code_p->u.llyy.f = code_p->u.plyys.f =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]);
clinfo->commit_lab = 0; clinfo->commit_lab = 0;
} else { } else {
code_p->u.llyy.f = FAILCODE; code_p->u.plyys.f = FAILCODE;
} }
code_p->u.llyy.y1 = v1; code_p->u.plyys.y1 = v1;
code_p->u.llyy.y2 = emit_yreg(var_offset); code_p->u.plyys.y2 = emit_yreg(var_offset);
code_p->u.llyy.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE); code_p->u.plyys.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE);
} }
GONEXT(llyy); GONEXT(plyys);
} else { } else {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(_call_bfunc_yx); code_p->opc = emit_op(_call_bfunc_yx);
code_p->u.llxy.p = RepPredProp(((Prop)pred)); code_p->u.plxys.p = RepPredProp(((Prop)pred));
if (clinfo->commit_lab) { if (clinfo->commit_lab) {
code_p->u.llxy.f = code_p->u.plxys.f =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]);
clinfo->commit_lab = 0; clinfo->commit_lab = 0;
} else { } else {
code_p->u.llxy.f = FAILCODE; code_p->u.plxys.f = FAILCODE;
} }
code_p->u.llxy.x = emit_xreg(var_offset); code_p->u.plxys.x = emit_xreg(var_offset);
code_p->u.llxy.y = v1; code_p->u.plxys.y = v1;
code_p->u.llxy.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE); code_p->u.plxys.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE);
} }
GONEXT(llxy); GONEXT(plxys);
} }
} else { } else {
wamreg x1 = emit_xreg(var_offset); wamreg x1 = emit_xreg(var_offset);
@ -1466,35 +1458,35 @@ a_bfunc(CELL pred, clause_info *clinfo, yamop *code_p, int pass_no, struct inter
if (is_y_var) { if (is_y_var) {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(_call_bfunc_xy); code_p->opc = emit_op(_call_bfunc_xy);
code_p->u.llxy.p = RepPredProp(((Prop)pred)); code_p->u.plxys.p = RepPredProp(((Prop)pred));
if (clinfo->commit_lab) { if (clinfo->commit_lab) {
code_p->u.llxy.f = code_p->u.plxys.f =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]);
clinfo->commit_lab = 0; clinfo->commit_lab = 0;
} else { } else {
code_p->u.llxy.f = FAILCODE; code_p->u.plxys.f = FAILCODE;
} }
code_p->u.llxy.x = x1; code_p->u.plxys.x = x1;
code_p->u.llxy.y = emit_yreg(var_offset); code_p->u.plxys.y = emit_yreg(var_offset);
code_p->u.llxy.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE); code_p->u.plxys.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE);
} }
GONEXT(llxy); GONEXT(plxys);
} else { } else {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(_call_bfunc_xx); code_p->opc = emit_op(_call_bfunc_xx);
code_p->u.llxx.p = RepPredProp(((Prop)pred)); code_p->u.plxxs.p = RepPredProp(((Prop)pred));
if (clinfo->commit_lab) { if (clinfo->commit_lab) {
code_p->u.llxx.f = code_p->u.plxxs.f =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[clinfo->commit_lab]);
clinfo->commit_lab = 0; clinfo->commit_lab = 0;
} else { } else {
code_p->u.llxx.f = FAILCODE; code_p->u.plxxs.f = FAILCODE;
} }
code_p->u.llxx.x1 = x1; code_p->u.plxxs.x1 = x1;
code_p->u.llxx.x2 = emit_xreg(var_offset); code_p->u.plxxs.x2 = emit_xreg(var_offset);
code_p->u.llxx.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE); code_p->u.plxxs.flags = compile_cmp_flags(RepAtom(NameOfFunctor(RepPredProp(((Prop)pred))->FunctorOfPred))->StrOfAE);
} }
GONEXT(llxx); GONEXT(plxxs);
} }
} }
return code_p; return code_p;
@ -1793,7 +1785,7 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
yamop *newcp; yamop *newcp;
/* emit a special instruction and then a label for backpatching */ /* emit a special instruction and then a label for backpatching */
if (pass_no) { if (pass_no) {
UInt size = (UInt)NEXTOP((yamop *)NULL,lld); UInt size = (UInt)NEXTOP((yamop *)NULL,aLl);
if ((newcp = (yamop *)Yap_AllocCodeSpace(size)) == NULL) { if ((newcp = (yamop *)Yap_AllocCodeSpace(size)) == NULL) {
/* OOOPS, got in trouble, must do a longjmp and recover space */ /* OOOPS, got in trouble, must do a longjmp and recover space */
save_machine_regs(); save_machine_regs();
@ -1810,15 +1802,15 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
try-retry-trust try-retry-trust
instructions allocated in this run instructions allocated in this run
*/ */
newcp->u.lld.n = cip->try_instructions; newcp->u.aLl.n = cip->try_instructions;
cip->try_instructions = newcp; cip->try_instructions = newcp;
} else { } else {
newcp->u.lld.n = *cip->current_try_lab; newcp->u.aLl.n = *cip->current_try_lab;
*cip->current_try_lab = newcp; *cip->current_try_lab = newcp;
} }
if (opcode == _try_clause) { if (opcode == _try_clause) {
newcp->opc = emit_op(_try_logical); newcp->opc = emit_op(_try_logical);
newcp->u.lld.t.s = emit_count(opr); newcp->u.aLl.s = emit_count(opr);
} else if (opcode == _retry) { } else if (opcode == _retry) {
if (ap->PredFlags & CountPredFlag) if (ap->PredFlags & CountPredFlag)
newcp->opc = emit_op(_count_retry_logical); newcp->opc = emit_op(_count_retry_logical);
@ -1826,7 +1818,7 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
newcp->opc = emit_op(_profiled_retry_logical); newcp->opc = emit_op(_profiled_retry_logical);
else else
newcp->opc = emit_op(_retry_logical); newcp->opc = emit_op(_retry_logical);
newcp->u.lld.t.s = emit_count(opr); newcp->u.aLl.s = emit_count(opr);
} else { } else {
if (ap->PredFlags & CountPredFlag) if (ap->PredFlags & CountPredFlag)
newcp->opc = emit_op(_count_trust_logical); newcp->opc = emit_op(_count_trust_logical);
@ -1834,11 +1826,11 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
newcp->opc = emit_op(_profiled_trust_logical); newcp->opc = emit_op(_profiled_trust_logical);
else else
newcp->opc = emit_op(_trust_logical); newcp->opc = emit_op(_trust_logical);
newcp->u.lld.t.block = (LogUpdIndex *)(cip->code_addr); newcp->u.ILl.block = (LogUpdIndex *)(cip->code_addr);
*cip->current_trust_lab = newcp; *cip->current_trust_lab = newcp;
} }
newcp->u.lld.d = ClauseCodeToLogUpdClause(emit_a(lab)); newcp->u.aLl.d = ClauseCodeToLogUpdClause(emit_a(lab));
cip->current_try_lab = &(newcp->u.lld.n); cip->current_try_lab = &(newcp->u.aLl.n);
} }
return code_p; return code_p;
} }
@ -1894,11 +1886,11 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
} }
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.ld.d = emit_a(lab); code_p->u.apl.d = emit_a(lab);
code_p->u.ld.s = emit_count(opr); code_p->u.apl.s = emit_count(opr);
code_p->u.ld.p = ap; code_p->u.apl.p = ap;
#ifdef TABLING #ifdef TABLING
code_p->u.ld.te = ap->TableOfPred; code_p->u.apl.te = ap->TableOfPred;
#endif #endif
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(code_p, nofalts); INIT_YAMOP_LTT(code_p, nofalts);
@ -1908,7 +1900,7 @@ a_try(op_numbers opcode, CELL lab, CELL opr, int nofalts, int hascut, yamop *cod
PUT_YAMOP_SEQ(code_p); PUT_YAMOP_SEQ(code_p);
#endif /* YAPOR */ #endif /* YAPOR */
} }
GONEXT(ld); GONEXT(apl);
return code_p; return code_p;
} }
@ -1921,9 +1913,9 @@ a_either(op_numbers opcode, CELL opr, CELL lab, yamop *code_p, int pass_no, stru
{ {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.sla.s = emit_count(opr); code_p->u.sblp.s = emit_count(opr);
code_p->u.sla.sla_u.l = emit_a(lab); code_p->u.sblp.l = emit_a(lab);
code_p->u.sla.p0 = cip->CurrentPred; code_p->u.sblp.p0 = cip->CurrentPred;
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(code_p, nofalts); INIT_YAMOP_LTT(code_p, nofalts);
if (hascut) if (hascut)
@ -1931,13 +1923,13 @@ a_either(op_numbers opcode, CELL opr, CELL lab, yamop *code_p, int pass_no, stru
if (cip->CurrentPred->PredFlags & SequentialPredFlag) if (cip->CurrentPred->PredFlags & SequentialPredFlag)
PUT_YAMOP_SEQ(code_p); PUT_YAMOP_SEQ(code_p);
if(opcode != _or_last) { if(opcode != _or_last) {
code_p->u.sla.bmap = emit_bmlabel(cip->cpc->arnds[1], cip); code_p->u.sblp.bmap = emit_bmlabel(cip->cpc->arnds[1], cip);
} }
#else #else
code_p->u.sla.bmap = emit_bmlabel(cip->cpc->arnds[1], cip); code_p->u.sblp.bmap = emit_bmlabel(cip->cpc->arnds[1], cip);
#endif /* YAPOR */ #endif /* YAPOR */
} }
GONEXT(sla); GONEXT(sblp);
return code_p; return code_p;
} }
@ -2017,7 +2009,7 @@ a_uvar(yamop *code_p, int pass_no, struct intermediates *cip)
} }
} }
#endif /* AGGREGATE_OPS */ #endif /* AGGREGATE_OPS */
return a_uv((Ventry *) cip->cpc->rnd1, _unify_x_var, _unify_x_var_write, code_p, pass_no); return a_uv((Ventry *) cip->cpc->rnd1, _unify_x_var, _unify_x_var_write, _unify_y_var, _unify_y_var_write, code_p, pass_no);
} }
else { else {
#if AGGREGATE_OPS #if AGGREGATE_OPS
@ -2054,7 +2046,7 @@ static yamop *
a_wvar(yamop *code_p, int pass_no, struct intermediates *cip) a_wvar(yamop *code_p, int pass_no, struct intermediates *cip)
{ {
if (!no_ref_var()) if (!no_ref_var())
return a_v(_write_x_var, code_p, pass_no, cip->cpc); return a_v(_write_x_var, _write_y_var, code_p, pass_no, cip->cpc);
else { else {
#if AGGREGATE_OPS #if AGGREGATE_OPS
int i = 0; int i = 0;
@ -2091,7 +2083,7 @@ a_glist(int *do_not_optimise_uatomp, yamop *code_p, int pass_no, struct intermed
cip->cpc = pnext; cip->cpc = pnext;
is_y_var = (ve->KindOfVE == PermVar); is_y_var = (ve->KindOfVE == PermVar);
var_offset = Var_Ref(ve, is_y_var); var_offset = Var_Ref(ve, is_y_var);
return a_rv(_glist_valx, var_offset, code_p, pass_no, cip->cpc); return a_rv(_glist_valx, _glist_valy, var_offset, code_p, pass_no, cip->cpc);
} else if (cip->cpc->rnd2 == 1 && pnext->op == unify_atom_op) { } else if (cip->cpc->rnd2 == 1 && pnext->op == unify_atom_op) {
*do_not_optimise_uatomp = TRUE; *do_not_optimise_uatomp = TRUE;
return a_r(cip->cpc->rnd2, _get_list, code_p, pass_no); return a_r(cip->cpc->rnd2, _get_list, code_p, pass_no);
@ -2108,7 +2100,10 @@ a_glist(int *do_not_optimise_uatomp, yamop *code_p, int pass_no, struct intermed
ppnext->rnd2 = cip->cpc->rnd2; ppnext->rnd2 = cip->cpc->rnd2;
cip->cpc = ppnext; cip->cpc = ppnext;
var_offset = Var_Ref(ve, is_y_var); var_offset = Var_Ref(ve, is_y_var);
return a_rv((op_numbers)((int)_gl_void_varx + (cip->cpc->op == unify_last_var_op ? 0 : 2)), var_offset, code_p, pass_no, cip->cpc); if (cip->cpc->op == unify_last_var_op)
return a_rv(_gl_void_varx, _gl_void_vary, var_offset, code_p, pass_no, cip->cpc);
else
return a_rv(_gl_void_valx, _gl_void_valy, var_offset, code_p, pass_no, cip->cpc);
} else { } else {
return a_r(cip->cpc->rnd2, _get_list, code_p, pass_no); return a_r(cip->cpc->rnd2, _get_list, code_p, pass_no);
} }
@ -2269,7 +2264,7 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
if (opc <= _primitive) { if (opc <= _primitive) {
if (is_y_var) { if (is_y_var) {
if (pass_no) { if (pass_no) {
code_p->u.yF.y = emit_y(ve); code_p->u.yl.y = emit_y(ve);
switch (opc) { switch (opc) {
case _atom: case _atom:
code_p->opc = opcode(_p_atom_y); code_p->opc = opcode(_p_atom_y);
@ -2306,18 +2301,18 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
break; break;
} }
if (cmp_info->cl_info->commit_lab) { if (cmp_info->cl_info->commit_lab) {
code_p->u.yF.F = code_p->u.yl.F =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[cmp_info->cl_info->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[cmp_info->cl_info->commit_lab]);
cmp_info->cl_info->commit_lab = 0; cmp_info->cl_info->commit_lab = 0;
} else { } else {
code_p->u.yF.F = FAILCODE; code_p->u.yl.F = FAILCODE;
} }
} }
GONEXT(yF); GONEXT(yl);
return code_p; return code_p;
} else { } else {
if (pass_no) { if (pass_no) {
code_p->u.xF.x = emit_x(ve->NoOfVE & MaskVarAdrs); code_p->u.xl.x = emit_x(ve->NoOfVE & MaskVarAdrs);
switch (opc) { switch (opc) {
case _atom: case _atom:
code_p->opc = opcode(_p_atom_x); code_p->opc = opcode(_p_atom_x);
@ -2354,14 +2349,14 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
break; break;
} }
if (cmp_info->cl_info->commit_lab) { if (cmp_info->cl_info->commit_lab) {
code_p->u.xF.F = code_p->u.xl.F =
emit_a(Unsigned(cip->code_addr) + cip->label_offset[cmp_info->cl_info->commit_lab]); emit_a(Unsigned(cip->code_addr) + cip->label_offset[cmp_info->cl_info->commit_lab]);
cmp_info->cl_info->commit_lab = 0; cmp_info->cl_info->commit_lab = 0;
} else { } else {
code_p->u.xF.F = FAILCODE; code_p->u.xl.F = FAILCODE;
} }
} }
GONEXT(xF); GONEXT(xl);
return code_p; return code_p;
} }
} }
@ -2394,11 +2389,11 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
if (nve->KindOfVE == PermVar) { if (nve->KindOfVE == PermVar) {
if (pass_no) { if (pass_no) {
code_p->opc = emit_op(_p_func2f_xy); code_p->opc = emit_op(_p_func2f_xy);
code_p->u.xyx.x1 = emit_x(ve->NoOfVE & MaskVarAdrs); code_p->u.xxy.x1 = emit_x(ve->NoOfVE & MaskVarAdrs);
code_p->u.xyx.y2 = emit_y(nve); code_p->u.xxy.y2 = emit_y(nve);
code_p->u.xyx.x = cmp_info->x1_arg; code_p->u.xxy.x = cmp_info->x1_arg;
} }
GONEXT(xyx); GONEXT(xxy);
return code_p; return code_p;
} else { } else {
if (pass_no) { if (pass_no) {
@ -2496,11 +2491,11 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
code_p->opc = emit_op(_p_func2s_y_cv); code_p->opc = emit_op(_p_func2s_y_cv);
break; break;
} }
code_p->u.ycx.y = emit_y(ve); code_p->u.yxc.y = emit_y(ve);
code_p->u.ycx.c = cmp_info->c_arg; code_p->u.yxc.c = cmp_info->c_arg;
code_p->u.ycx.xi = cmp_info->x1_arg; code_p->u.yxc.xi = cmp_info->x1_arg;
} }
GONEXT(ycx); GONEXT(yxc);
break; break;
case TYPE_XC: case TYPE_XC:
if (pass_no) { if (pass_no) {
@ -2695,11 +2690,11 @@ a_f2(int var, cmp_op_info *cmp_info, yamop *code_p, int pass_no, struct intermed
code_p->opc = emit_op(_p_func2s_vc); code_p->opc = emit_op(_p_func2s_vc);
break; break;
} }
code_p->u.xcx.x = emit_x(ve->NoOfVE & MaskVarAdrs); code_p->u.xxc.x = emit_x(ve->NoOfVE & MaskVarAdrs);
code_p->u.xcx.c = cmp_info->c_arg; code_p->u.xxc.c = cmp_info->c_arg;
code_p->u.xcx.xi = cmp_info->x1_arg; code_p->u.xxc.xi = cmp_info->x1_arg;
} }
GONEXT(xcx); GONEXT(xxc);
break; break;
} }
} }
@ -2926,16 +2921,16 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
break; break;
#endif #endif
case get_var_op: case get_var_op:
code_p = a_vr(_get_x_var, code_p, pass_no, cip); code_p = a_vr(_get_x_var, _get_y_var, code_p, pass_no, cip);
break; break;
case put_var_op: case put_var_op:
code_p = a_vr(_put_x_var, code_p, pass_no, cip); code_p = a_vr(_put_x_var, _put_y_var, code_p, pass_no, cip);
break; break;
case get_val_op: case get_val_op:
code_p = a_vr(_get_x_val, code_p, pass_no, cip); code_p = a_vr(_get_x_val, _get_y_val, code_p, pass_no, cip);
break; break;
case put_val_op: case put_val_op:
code_p = a_vr(_put_x_val, code_p, pass_no, cip); code_p = a_vr(_put_x_val, _put_y_val, code_p, pass_no, cip);
break; break;
case get_num_op: case get_num_op:
case get_atom_op: case get_atom_op:
@ -2986,34 +2981,34 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
code_p = a_rf(_put_struct, code_p, pass_no, cip->cpc); code_p = a_rf(_put_struct, code_p, pass_no, cip->cpc);
break; break;
case put_unsafe_op: case put_unsafe_op:
code_p = a_vr((op_numbers)((int)_put_unsafe - 1), code_p, pass_no, cip); code_p = a_vr(_put_unsafe, _put_unsafe, code_p, pass_no, cip);
break; break;
case unify_var_op: case unify_var_op:
code_p = a_uvar(code_p, pass_no, cip); code_p = a_uvar(code_p, pass_no, cip);
break; break;
case unify_last_var_op: case unify_last_var_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_l_x_var, _unify_l_x_var_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_l_x_var, _unify_l_x_var_write, _unify_l_y_var, _unify_l_y_var_write, code_p, pass_no);
break; break;
case write_var_op: case write_var_op:
code_p = a_wvar(code_p, pass_no, cip); code_p = a_wvar(code_p, pass_no, cip);
break; break;
case unify_local_op: case unify_local_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_x_loc, _unify_x_loc_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_x_loc, _unify_x_loc_write, _unify_y_loc, _unify_y_loc_write, code_p, pass_no);
break; break;
case unify_val_op: case unify_val_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_x_val, _unify_x_val_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_x_val, _unify_x_val_write, _unify_y_val, _unify_y_val_write, code_p, pass_no);
break; break;
case unify_last_local_op: case unify_last_local_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_l_x_loc, _unify_l_x_loc_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_l_x_loc, _unify_l_x_loc_write, _unify_l_y_loc, _unify_l_y_loc_write, code_p, pass_no);
break; break;
case unify_last_val_op: case unify_last_val_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_l_x_val, _unify_l_x_val_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _unify_l_x_val, _unify_l_x_val_write, _unify_l_y_val, _unify_l_y_val_write, code_p, pass_no);
break; break;
case write_local_op: case write_local_op:
code_p = a_v(_write_x_loc, code_p, pass_no, cip->cpc); code_p = a_v(_write_x_loc, _write_y_loc, code_p, pass_no, cip->cpc);
break; break;
case write_val_op: case write_val_op:
code_p = a_v(_write_x_val, code_p, pass_no, cip->cpc); code_p = a_v(_write_x_val, _write_y_val, code_p, pass_no, cip->cpc);
break; break;
case unify_num_op: case unify_num_op:
case unify_atom_op: case unify_atom_op:
@ -3095,16 +3090,16 @@ do_pass(int pass_no, yamop **entry_codep, int assembling, int *clause_has_blobsp
break; break;
case save_b_op: case save_b_op:
case patch_b_op: case patch_b_op:
code_p = a_v(_save_b_x, code_p, pass_no, cip->cpc); code_p = a_v(_save_b_x, _save_b_y, code_p, pass_no, cip->cpc);
break; break;
case commit_b_op: case commit_b_op:
code_p = a_v(_commit_b_x, code_p, pass_no, cip->cpc); code_p = a_v(_commit_b_x, _commit_b_y, code_p, pass_no, cip->cpc);
break; break;
case save_pair_op: case save_pair_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _save_pair_x, _save_pair_x_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _save_pair_x, _save_pair_x_write, _save_pair_y, _save_pair_y_write, code_p, pass_no);
break; break;
case save_appl_op: case save_appl_op:
code_p = a_uv((Ventry *) cip->cpc->rnd1, _save_appl_x, _save_appl_x_write, code_p, pass_no); code_p = a_uv((Ventry *) cip->cpc->rnd1, _save_appl_x, _save_appl_x_write, _save_appl_y, _save_appl_y_write, code_p, pass_no);
break; break;
case fail_op: case fail_op:
code_p = a_e(_op_fail, code_p, pass_no); code_p = a_e(_op_fail, code_p, pass_no);
@ -3558,7 +3553,7 @@ Yap_assemble(int mode, Term t, PredEntry *ap, int is_fact, struct intermediates
} }
if (ap->PredFlags & DynamicPredFlag) { if (ap->PredFlags & DynamicPredFlag) {
size = size =
(CELL)NEXTOP(NEXTOP(NEXTOP((yamop *)(((DynamicClause *)NULL)->ClCode),ld),sla),e); (CELL)NEXTOP(NEXTOP(NEXTOP((yamop *)(((DynamicClause *)NULL)->ClCode),apl),sbpp),e);
} }
if ((CELL)code_p > size) if ((CELL)code_p > size)
size = (CELL)code_p; size = (CELL)code_p;
@ -3631,28 +3626,28 @@ Yap_InitComma(void)
{ {
yamop *code_p = COMMA_CODE; yamop *code_p = COMMA_CODE;
code_p->opc = opcode(_call); code_p->opc = opcode(_call);
code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - sizeof(CELL) * 3); code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize) - sizeof(CELL) * 3);
code_p->u.sla.sla_u.p = code_p->u.sbpp.p =
code_p->u.sla.p0 = code_p->u.sbpp.p0 =
RepPredProp(PredPropByFunc(FunctorComma,0)); RepPredProp(PredPropByFunc(FunctorComma,0));
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
GONEXT(sla); GONEXT(sbpp);
if (PRED_GOAL_EXPANSION_ON) { if (PRED_GOAL_EXPANSION_ON) {
Functor fp = Yap_MkFunctor(Yap_FullLookupAtom("$generate_pred_info"),4); Functor fp = Yap_MkFunctor(Yap_FullLookupAtom("$generate_pred_info"),4);
code_p->opc = emit_op(_call_cpred); code_p->opc = emit_op(_call_cpred);
code_p->u.sla.s = emit_count(-Signed(RealEnvSize)); code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize));
code_p->u.sla.sla_u.p = code_p->u.sbpp.p =
code_p->u.sla.p0 = code_p->u.sbpp.p0 =
RepPredProp(Yap_GetPredPropByFunc(fp,0)); RepPredProp(Yap_GetPredPropByFunc(fp,0));
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
GONEXT(sla); GONEXT(sbpp);
code_p->opc = emit_op(_call); code_p->opc = emit_op(_call);
code_p->u.sla.s = emit_count(-Signed(RealEnvSize)); code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize));
code_p->u.sla.sla_u.p = code_p->u.sbpp.p =
code_p->u.sla.p0 = code_p->u.sbpp.p0 =
PredMetaCall; PredMetaCall;
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
GONEXT(sla); GONEXT(sbpp);
code_p->opc = emit_op(_deallocate); code_p->opc = emit_op(_deallocate);
GONEXT(e); GONEXT(e);
code_p->opc = emit_op(_procceed); code_p->opc = emit_op(_procceed);
@ -3668,11 +3663,11 @@ Yap_InitComma(void)
GONEXT(e); GONEXT(e);
} }
code_p->opc = opcode(_p_execute_tail); code_p->opc = opcode(_p_execute_tail);
code_p->u.sla.s = emit_count(-Signed(RealEnvSize)-3*sizeof(CELL)); code_p->u.sbpp.s = emit_count(-Signed(RealEnvSize)-3*sizeof(CELL));
code_p->u.sla.bmap = NULL; code_p->u.sbpp.bmap = NULL;
code_p->u.sla.sla_u.p = code_p->u.sbpp.p =
code_p->u.sla.p0 = code_p->u.sbpp.p0 =
RepPredProp(PredPropByFunc(FunctorComma,0)); RepPredProp(PredPropByFunc(FunctorComma,0));
GONEXT(sla); GONEXT(sbpp);
} }
} }

12
C/c_interface.c
View File

@ -515,8 +515,8 @@ dogc(void)
{ {
UInt arity; UInt arity;
if (P && PREVOP(P,sla)->opc == Yap_opcode(_call_usercpred)) { if (P && PREVOP(P,sbpp)->opc == Yap_opcode(_call_usercpred)) {
arity = PREVOP(P,sla)->u.sla.sla_u.p->ArityOfPE; arity = PREVOP(P,sbpp)->u.sbpp.p->ArityOfPE;
} else { } else {
arity = 0; arity = 0;
} }
@ -531,8 +531,8 @@ doexpand(UInt sz)
{ {
UInt arity; UInt arity;
if (P && PREVOP(P,sla)->opc == Yap_opcode(_call_usercpred)) { if (P && PREVOP(P,sbpp)->opc == Yap_opcode(_call_usercpred)) {
arity = PREVOP(P,sla)->u.sla.sla_u.p->ArityOfPE; arity = PREVOP(P,sbpp)->u.sbpp.p->ArityOfPE;
} else { } else {
arity = 0; arity = 0;
} }
@ -950,7 +950,7 @@ YAP_ExtraSpaceCut(void)
void *ptr; void *ptr;
BACKUP_B(); BACKUP_B();
ptr = (void *)(((CELL *)(Yap_REGS.CUT_C_TOP))-(((yamop *)Yap_REGS.CUT_C_TOP->try_userc_cut_yamop)->u.lds.extra)); ptr = (void *)(((CELL *)(Yap_REGS.CUT_C_TOP))-(((yamop *)Yap_REGS.CUT_C_TOP->try_userc_cut_yamop)->u.apFs.extra));
RECOVER_B(); RECOVER_B();
return(ptr); return(ptr);
@ -965,7 +965,7 @@ YAP_ExtraSpace(void)
BACKUP_H(); BACKUP_H();
/* find a pointer to extra space allocable */ /* find a pointer to extra space allocable */
ptr = (void *)((CELL *)(B+1)+P->u.lds.s); ptr = (void *)((CELL *)(B+1)+P->u.apFs.s);
B->cp_h = H; B->cp_h = H;
RECOVER_H(); RECOVER_H();

235
C/cdmgr.c
View File

@ -546,7 +546,7 @@ PredForChoicePt(yamop *p_code) {
break; break;
case _retry_me: case _retry_me:
case _trust_me: case _trust_me:
return p_code->u.ld.p; return p_code->u.apl.p;
case _try_logical: case _try_logical:
case _retry_logical: case _retry_logical:
case _trust_logical: case _trust_logical:
@ -554,7 +554,7 @@ PredForChoicePt(yamop *p_code) {
case _count_trust_logical: case _count_trust_logical:
case _profiled_retry_logical: case _profiled_retry_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
return p_code->u.lld.d->ClPred; return p_code->u.aLl.d->ClPred;
#ifdef TABLING #ifdef TABLING
case _trie_retry_null: case _trie_retry_null:
case _trie_trust_null: case _trie_trust_null:
@ -583,17 +583,17 @@ PredForChoicePt(yamop *p_code) {
/* compile error --> return ENV_ToP(gc_B->cp_cp); */ /* compile error --> return ENV_ToP(gc_B->cp_cp); */
#endif /* TABLING */ #endif /* TABLING */
case _or_else: case _or_else:
if (p_code == p_code->u.sla.sla_u.l) { if (p_code == p_code->u.sblp.l) {
/* repeat */ /* repeat */
Atom at = Yap_LookupAtom("repeat "); Atom at = Yap_LookupAtom("repeat ");
return RepPredProp(PredPropByAtom(at, PROLOG_MODULE)); return RepPredProp(PredPropByAtom(at, PROLOG_MODULE));
} else { } else {
return p_code->u.sla.p0; return p_code->u.sblp.p0;
} }
break; break;
case _or_last: case _or_last:
#ifdef YAPOR #ifdef YAPOR
return p_code->u.sla.p0; return p_code->u.sblp.p0;
#else #else
return p_code->u.p.p; return p_code->u.p.p;
#endif /* YAPOR */ #endif /* YAPOR */
@ -606,7 +606,7 @@ PredForChoicePt(yamop *p_code) {
p_code = NEXTOP(p_code,l); p_code = NEXTOP(p_code,l);
break; break;
default: default:
return p_code->u.ld.p; return p_code->u.apl.p;
} }
} }
return NULL; return NULL;
@ -1014,29 +1014,29 @@ static yamop *
release_wcls(yamop *cop, OPCODE ecs) release_wcls(yamop *cop, OPCODE ecs)
{ {
if (cop->opc == ecs) { if (cop->opc == ecs) {
cop->u.sp.s3--; cop->u.sssllp.s3--;
if (!cop->u.sp.s3) { if (!cop->u.sssllp.s3) {
UInt sz = (UInt)NEXTOP((yamop *)NULL,sp)+cop->u.sp.s1*sizeof(yamop *); UInt sz = (UInt)NEXTOP((yamop *)NULL,sssllp)+cop->u.sssllp.s1*sizeof(yamop *);
LOCK(ExpandClausesListLock); LOCK(ExpandClausesListLock);
#ifdef DEBUG #ifdef DEBUG
Yap_expand_clauses_sz -= sz; Yap_expand_clauses_sz -= sz;
Yap_ExpandClauses--; Yap_ExpandClauses--;
#endif #endif
if (cop->u.sp.p->PredFlags & LogUpdatePredFlag) { if (cop->u.sssllp.p->PredFlags & LogUpdatePredFlag) {
Yap_LUIndexSpace_EXT -= sz; Yap_LUIndexSpace_EXT -= sz;
} else { } else {
Yap_IndexSpace_EXT -= sz; Yap_IndexSpace_EXT -= sz;
} }
if (ExpandClausesFirst == cop) if (ExpandClausesFirst == cop)
ExpandClausesFirst = cop->u.sp.snext; ExpandClausesFirst = cop->u.sssllp.snext;
if (ExpandClausesLast == cop) { if (ExpandClausesLast == cop) {
ExpandClausesLast = cop->u.sp.sprev; ExpandClausesLast = cop->u.sssllp.sprev;
} }
if (cop->u.sp.sprev) { if (cop->u.sssllp.sprev) {
cop->u.sp.sprev->u.sp.snext = cop->u.sp.snext; cop->u.sssllp.sprev->u.sssllp.snext = cop->u.sssllp.snext;
} }
if (cop->u.sp.snext) { if (cop->u.sssllp.snext) {
cop->u.sp.snext->u.sp.sprev = cop->u.sp.sprev; cop->u.sssllp.snext->u.sssllp.sprev = cop->u.sssllp.sprev;
} }
UNLOCK(ExpandClausesListLock); UNLOCK(ExpandClausesListLock);
Yap_InformOfRemoval((CODEADDR)cop); Yap_InformOfRemoval((CODEADDR)cop);
@ -1084,8 +1084,8 @@ cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end, yamop *suspend_code
break; break;
case _retry: case _retry:
case _trust: case _trust:
decrease_ref_counter(ipc->u.ld.d, beg, end, suspend_code); decrease_ref_counter(ipc->u.apl.d, beg, end, suspend_code);
ipc = NEXTOP(ipc,ld); ipc = NEXTOP(ipc,apl);
break; break;
case _try_clause: case _try_clause:
case _try_me: case _try_me:
@ -1093,7 +1093,7 @@ cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end, yamop *suspend_code
case _profiled_trust_me: case _profiled_trust_me:
case _trust_me: case _trust_me:
case _count_trust_me: case _count_trust_me:
ipc = NEXTOP(ipc,ld); ipc = NEXTOP(ipc,apl);
break; break;
case _try_logical: case _try_logical:
case _retry_logical: case _retry_logical:
@ -1101,9 +1101,9 @@ cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end, yamop *suspend_code
case _profiled_retry_logical: case _profiled_retry_logical:
{ {
yamop *oipc = ipc; yamop *oipc = ipc;
decrease_ref_counter(ipc->u.lld.d->ClCode, beg, end, suspend_code); decrease_ref_counter(ipc->u.aLl.d->ClCode, beg, end, suspend_code);
ipc = ipc->u.lld.n; ipc = ipc->u.aLl.n;
Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL,lld); Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL,aLl);
Yap_FreeCodeSpace((ADDR)oipc); Yap_FreeCodeSpace((ADDR)oipc);
#ifdef DEBUG #ifdef DEBUG
Yap_DirtyCps--; Yap_DirtyCps--;
@ -1118,23 +1118,23 @@ cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end, yamop *suspend_code
Yap_DirtyCps--; Yap_DirtyCps--;
Yap_FreedCps++; Yap_FreedCps++;
#endif #endif
decrease_ref_counter(ipc->u.lld.d->ClCode, beg, end, suspend_code); decrease_ref_counter(ipc->u.ILl.d->ClCode, beg, end, suspend_code);
Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL,lld); Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL,ILl);
Yap_FreeCodeSpace((ADDR)ipc); Yap_FreeCodeSpace((ADDR)ipc);
return; return;
case _enter_lu_pred: case _enter_lu_pred:
{ {
yamop *oipc = ipc; yamop *oipc = ipc;
if (ipc->u.Ill.I->ClFlags & InUseMask || ipc->u.Ill.I->ClRefCount) if (ipc->u.Ills.I->ClFlags & InUseMask || ipc->u.Ills.I->ClRefCount)
return; return;
#ifdef DEBUG #ifdef DEBUG
Yap_DirtyCps+=ipc->u.Ill.s; Yap_DirtyCps+=ipc->u.Ills.s;
Yap_LiveCps-=ipc->u.Ill.s; Yap_LiveCps-=ipc->u.Ills.s;
#endif #endif
ipc = ipc->u.Ill.l1; ipc = ipc->u.Ills.l1;
/* in case we visit again */ /* in case we visit again */
oipc->u.Ill.l1 = FAILCODE; oipc->u.Ills.l1 = FAILCODE;
oipc->u.Ill.s = 0; oipc->u.Ills.s = 0;
} }
break; break;
case _try_in: case _try_in:
@ -1637,12 +1637,12 @@ add_first_dynamic(PredEntry *p, yamop *cp, int spy_flag)
/* allocate starter block, containing info needed to start execution, /* allocate starter block, containing info needed to start execution,
* that is a try_mark to start the code and a fail to finish things up */ * that is a try_mark to start the code and a fail to finish things up */
cl = cl =
(DynamicClause *) Yap_AllocCodeSpace((Int)NEXTOP(NEXTOP(NEXTOP(ncp,ld),e),l)); (DynamicClause *) Yap_AllocCodeSpace((Int)NEXTOP(NEXTOP(NEXTOP(ncp,apl),e),l));
if (cl == NIL) { if (cl == NIL) {
Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"Heap crashed against Stacks"); Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"Heap crashed against Stacks");
return; return;
} }
Yap_ClauseSpace += (Int)NEXTOP(NEXTOP(NEXTOP(ncp,ld),e),l); Yap_ClauseSpace += (Int)NEXTOP(NEXTOP(NEXTOP(ncp,apl),e),l);
/* skip the first entry, this contains the back link and will always be /* skip the first entry, this contains the back link and will always be
empty for this entry */ empty for this entry */
ncp = (yamop *)(((CELL *)ncp)+1); ncp = (yamop *)(((CELL *)ncp)+1);
@ -1658,9 +1658,9 @@ add_first_dynamic(PredEntry *p, yamop *cp, int spy_flag)
p->OpcodeOfPred = ncp->opc = Yap_opcode(_spy_or_trymark); p->OpcodeOfPred = ncp->opc = Yap_opcode(_spy_or_trymark);
else else
p->OpcodeOfPred = ncp->opc = Yap_opcode(_try_and_mark); p->OpcodeOfPred = ncp->opc = Yap_opcode(_try_and_mark);
ncp->u.ld.s = p->ArityOfPE; ncp->u.apl.s = p->ArityOfPE;
ncp->u.ld.p = p; ncp->u.apl.p = p;
ncp->u.ld.d = cp; ncp->u.apl.d = cp;
/* This is the point we enter the code */ /* This is the point we enter the code */
p->cs.p_code.TrueCodeOfPred = p->CodeOfPred = ncp; p->cs.p_code.TrueCodeOfPred = p->CodeOfPred = ncp;
p->cs.p_code.NOfClauses = 1; p->cs.p_code.NOfClauses = 1;
@ -1679,9 +1679,9 @@ add_first_dynamic(PredEntry *p, yamop *cp, int spy_flag)
cp->opc = Yap_opcode(_count_retry_and_mark); cp->opc = Yap_opcode(_count_retry_and_mark);
else else
cp->opc = Yap_opcode(_retry_and_mark); cp->opc = Yap_opcode(_retry_and_mark);
cp->u.ld.s = p->ArityOfPE; cp->u.apl.s = p->ArityOfPE;
cp->u.ld.p = p; cp->u.apl.p = p;
cp->u.ld.d = ncp; cp->u.apl.d = ncp;
/* also, keep a backpointer for the days you delete the clause */ /* also, keep a backpointer for the days you delete the clause */
ClauseCodeToDynamicClause(cp)->ClPrevious = ncp; ClauseCodeToDynamicClause(cp)->ClPrevious = ncp;
/* Don't forget to say who is the only clause for the predicate so /* Don't forget to say who is the only clause for the predicate so
@ -1689,7 +1689,7 @@ add_first_dynamic(PredEntry *p, yamop *cp, int spy_flag)
p->cs.p_code.LastClause = p->cs.p_code.FirstClause = cp; p->cs.p_code.LastClause = p->cs.p_code.FirstClause = cp;
/* we're only missing what to do when we actually exit the procedure /* we're only missing what to do when we actually exit the procedure
*/ */
ncp = NEXTOP(ncp,ld); ncp = NEXTOP(ncp,apl);
/* and the last instruction to execute to exit the predicate, note /* and the last instruction to execute to exit the predicate, note
the retry is pointing to this pseudo clause */ the retry is pointing to this pseudo clause */
ncp->opc = Yap_opcode(_trust_fail); ncp->opc = Yap_opcode(_trust_fail);
@ -1741,7 +1741,7 @@ asserta_stat_clause(PredEntry *p, yamop *q, int spy_flag)
p->OpcodeOfPred = INDEX_OPCODE; p->OpcodeOfPred = INDEX_OPCODE;
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred)); p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
} }
p->cs.p_code.LastClause->u.ld.d = q; p->cs.p_code.LastClause->u.apl.d = q;
} }
/* p is already locked */ /* p is already locked */
@ -1757,22 +1757,22 @@ asserta_dynam_clause(PredEntry *p, yamop *cp)
cl->ClPrevious = (yamop *)(p->CodeOfPred); cl->ClPrevious = (yamop *)(p->CodeOfPred);
cl->ClFlags |= DynamicMask; cl->ClFlags |= DynamicMask;
UNLOCK(ClauseCodeToDynamicClause(p->cs.p_code.FirstClause)->ClLock); UNLOCK(ClauseCodeToDynamicClause(p->cs.p_code.FirstClause)->ClLock);
q->u.ld.d = p->cs.p_code.FirstClause; q->u.apl.d = p->cs.p_code.FirstClause;
q->u.ld.s = p->ArityOfPE; q->u.apl.s = p->ArityOfPE;
q->u.ld.p = p; q->u.apl.p = p;
if (p->PredFlags & ProfiledPredFlag) if (p->PredFlags & ProfiledPredFlag)
cp->opc = Yap_opcode(_profiled_retry_and_mark); cp->opc = Yap_opcode(_profiled_retry_and_mark);
else if (p->PredFlags & CountPredFlag) else if (p->PredFlags & CountPredFlag)
cp->opc = Yap_opcode(_count_retry_and_mark); cp->opc = Yap_opcode(_count_retry_and_mark);
else else
cp->opc = Yap_opcode(_retry_and_mark); cp->opc = Yap_opcode(_retry_and_mark);
cp->u.ld.s = p->ArityOfPE; cp->u.apl.s = p->ArityOfPE;
cp->u.ld.p = p; cp->u.apl.p = p;
p->cs.p_code.FirstClause = cp; p->cs.p_code.FirstClause = cp;
q = p->CodeOfPred; q = p->CodeOfPred;
q->u.ld.d = cp; q->u.apl.d = cp;
q->u.ld.s = p->ArityOfPE; q->u.apl.s = p->ArityOfPE;
q->u.ld.p = p; q->u.apl.p = p;
} }
@ -1830,7 +1830,7 @@ assertz_dynam_clause(PredEntry *p, yamop *cp)
q = p->cs.p_code.LastClause; q = p->cs.p_code.LastClause;
LOCK(ClauseCodeToDynamicClause(q)->ClLock); LOCK(ClauseCodeToDynamicClause(q)->ClLock);
q->u.ld.d = cp; q->u.apl.d = cp;
p->cs.p_code.LastClause = cp; p->cs.p_code.LastClause = cp;
/* also, keep backpointers for the days we'll delete all the clause */ /* also, keep backpointers for the days we'll delete all the clause */
cl->ClPrevious = q; cl->ClPrevious = q;
@ -1843,9 +1843,9 @@ assertz_dynam_clause(PredEntry *p, yamop *cp)
q->opc = Yap_opcode(_count_retry_and_mark); q->opc = Yap_opcode(_count_retry_and_mark);
else else
q->opc = Yap_opcode(_retry_and_mark); q->opc = Yap_opcode(_retry_and_mark);
q->u.ld.d = p->CodeOfPred; q->u.apl.d = p->CodeOfPred;
q->u.ld.s = p->ArityOfPE; q->u.apl.s = p->ArityOfPE;
q->u.ld.p = p; q->u.apl.p = p;
p->cs.p_code.NOfClauses++; p->cs.p_code.NOfClauses++;
} }
@ -3202,16 +3202,16 @@ search_for_static_predicate_in_use(PredEntry *p, int check_everything)
if (p->PredFlags & LogUpdatePredFlag) { if (p->PredFlags & LogUpdatePredFlag) {
LogUpdIndex *cl = ClauseCodeToLogUpdIndex(code_beg); LogUpdIndex *cl = ClauseCodeToLogUpdIndex(code_beg);
if (find_owner_log_index(cl, code_p)) if (find_owner_log_index(cl, code_p))
b_ptr->cp_ap = cur_log_upd_clause(pe, b_ptr->cp_ap->u.ld.d); b_ptr->cp_ap = cur_log_upd_clause(pe, b_ptr->cp_ap->u.apl.d);
} else if (p->PredFlags & MegaClausePredFlag) { } else if (p->PredFlags & MegaClausePredFlag) {
StaticIndex *cl = ClauseCodeToStaticIndex(code_beg); StaticIndex *cl = ClauseCodeToStaticIndex(code_beg);
if (find_owner_static_index(cl, code_p)) if (find_owner_static_index(cl, code_p))
b_ptr->cp_ap = cur_clause(pe, b_ptr->cp_ap->u.ld.d); b_ptr->cp_ap = cur_clause(pe, b_ptr->cp_ap->u.apl.d);
} else { } else {
/* static clause */ /* static clause */
StaticIndex *cl = ClauseCodeToStaticIndex(code_beg); StaticIndex *cl = ClauseCodeToStaticIndex(code_beg);
if (find_owner_static_index(cl, code_p)) { if (find_owner_static_index(cl, code_p)) {
b_ptr->cp_ap = cur_clause(pe, b_ptr->cp_ap->u.ld.d); b_ptr->cp_ap = cur_clause(pe, b_ptr->cp_ap->u.apl.d);
} }
} }
} }
@ -3797,19 +3797,19 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _table_answer_resolution: case _table_answer_resolution:
case _table_completion: case _table_completion:
#endif /* TABLING */ #endif /* TABLING */
pc = NEXTOP(pc,ld); pc = NEXTOP(pc, apl);
break; break;
case _try_logical: case _try_logical:
case _retry_logical: case _retry_logical:
case _count_retry_logical: case _count_retry_logical:
case _profiled_retry_logical: case _profiled_retry_logical:
pc = pc->u.lld.n; pc = pc->u.aLl.n;
break; break;
case _trust_logical: case _trust_logical:
case _count_trust_logical: case _count_trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
{ {
LogUpdIndex *cl = pc->u.lld.t.block; LogUpdIndex *cl = pc->u.ILl.block;
pp = cl->ClPred; pp = cl->ClPred;
*startp = (CODEADDR)cl; *startp = (CODEADDR)cl;
*endp = (CODEADDR)cl+cl->ClSize; *endp = (CODEADDR)cl+cl->ClSize;
@ -3817,7 +3817,7 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
} }
case _enter_lu_pred: case _enter_lu_pred:
{ {
LogUpdIndex *cl = pc->u.Ill.I; LogUpdIndex *cl = pc->u.Ills.I;
pp = cl->ClPred; pp = cl->ClPred;
*startp = (CODEADDR)cl; *startp = (CODEADDR)cl;
*endp = (CODEADDR)cl+cl->ClSize; *endp = (CODEADDR)cl+cl->ClSize;
@ -3873,7 +3873,7 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
/* instructions type EC */ /* instructions type EC */
case _alloc_for_logical_pred: case _alloc_for_logical_pred:
{ {
LogUpdClause *cl = pc->u.EC.ClBase; LogUpdClause *cl = pc->u.L.ClBase;
*startp = (CODEADDR)cl; *startp = (CODEADDR)cl;
*endp = (CODEADDR)cl+cl->ClSize; *endp = (CODEADDR)cl+cl->ClSize;
@ -3967,7 +3967,7 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _write_x_loc: case _write_x_loc:
pc = NEXTOP(pc,x); pc = NEXTOP(pc,x);
break; break;
/* instructions type xF */ /* instructions type xl */
case _p_atom_x: case _p_atom_x:
case _p_atomic_x: case _p_atomic_x:
case _p_integer_x: case _p_integer_x:
@ -3979,7 +3979,7 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _p_compound_x: case _p_compound_x:
case _p_float_x: case _p_float_x:
case _p_cut_by_x: case _p_cut_by_x:
pc = NEXTOP(pc,xF); pc = NEXTOP(pc,xl);
break; break;
/* instructions type y */ /* instructions type y */
case _save_b_y: case _save_b_y:
@ -3989,7 +3989,7 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _write_y_loc: case _write_y_loc:
pc = NEXTOP(pc,y); pc = NEXTOP(pc,y);
break; break;
/* instructions type yF */ /* instructions type yl */
case _p_atom_y: case _p_atom_y:
case _p_atomic_y: case _p_atomic_y:
case _p_integer_y: case _p_integer_y:
@ -4001,9 +4001,9 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _p_compound_y: case _p_compound_y:
case _p_float_y: case _p_float_y:
case _p_cut_by_y: case _p_cut_by_y:
pc = NEXTOP(pc,yF); pc = NEXTOP(pc,yl);
break; break;
/* instructions type sla */ /* instructions type sbpp or sbmp */
case _p_execute_tail: case _p_execute_tail:
case _p_execute: case _p_execute:
case _p_execute2: case _p_execute2:
@ -4018,17 +4018,21 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _or_last: case _or_last:
#endif #endif
clause_code = TRUE; clause_code = TRUE;
pp = pc->u.sla.sla_u.p; pp = pc->u.sbpp.p;
pc = NEXTOP(pc,sla); pc = NEXTOP(pc,sbpp);
break; break;
/* instructions type sla, but for disjunctions */ /* instructions type sbpp, but for disjunctions */
case _either: case _either:
case _or_else: case _or_else:
clause_code = TRUE;
pp = pc->u.sblp.p0;
pc = NEXTOP(pc,sblp);
break;
case _call_cpred: case _call_cpred:
case _call_usercpred: case _call_usercpred:
clause_code = TRUE; clause_code = TRUE;
pp = pc->u.sla.p0; pp = pc->u.sbpp.p0;
pc = NEXTOP(pc,sla); pc = NEXTOP(pc,sbpp);
break; break;
/* instructions type xx */ /* instructions type xx */
case _get_x_var: case _get_x_var:
@ -4088,10 +4092,10 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _get_6atoms: case _get_6atoms:
pc = NEXTOP(pc,cccccc); pc = NEXTOP(pc,cccccc);
break; break;
/* instructions type xf */ /* instructions type xfa */
case _get_struct: case _get_struct:
case _put_struct: case _put_struct:
pc = NEXTOP(pc,xf); pc = NEXTOP(pc,xfa);
break; break;
/* instructions type xy */ /* instructions type xy */
case _glist_valy: case _glist_valy:
@ -4196,7 +4200,7 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _unify_struct: case _unify_struct:
case _unify_l_struc_write: case _unify_l_struc_write:
case _unify_l_struc: case _unify_l_struc:
pc = NEXTOP(pc,of); pc = NEXTOP(pc,ofa);
break; break;
/* instructions type s */ /* instructions type s */
case _write_n_voids: case _write_n_voids:
@ -4228,22 +4232,22 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
/* instructions type f */ /* instructions type f */
case _write_struct: case _write_struct:
case _write_l_struc: case _write_l_struc:
pc = NEXTOP(pc,f); pc = NEXTOP(pc,fa);
break; break;
/* instructions type sdl */ /* instructions type sdlp */
case _call_c_wfail: case _call_c_wfail:
clause_code = TRUE; clause_code = TRUE;
pp = pc->u.sdl.p; pp = pc->u.sdlp.p;
pc = NEXTOP(pc,sdl); pc = NEXTOP(pc,sdlp);
break; break;
/* instructions type lds */ /* instructions type apFs */
case _try_c: case _try_c:
case _try_userc: case _try_userc:
case _retry_c: case _retry_c:
case _retry_userc: case _retry_userc:
clause_code = TRUE; clause_code = TRUE;
pp = pc->u.lds.p; pp = pc->u.apFs.p;
pc = NEXTOP(pc,lds); pc = NEXTOP(pc,apFs);
break; break;
#ifdef CUT_C #ifdef CUT_C
case _cut_c: case _cut_c:
@ -4315,16 +4319,16 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
case _p_slr_cv: case _p_slr_cv:
case _p_arg_cv: case _p_arg_cv:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,xcx); pc = NEXTOP(pc,xxc);
break; break;
case _p_func2s_cv: case _p_func2s_cv:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,xcx); pc = NEXTOP(pc,xxc);
break; break;
/* instructions type xyx */ /* instructions type xxy */
case _p_func2f_xy: case _p_func2f_xy:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,xyx); pc = NEXTOP(pc,xxy);
break; break;
/* instructions type yxx */ /* instructions type yxx */
case _p_plus_y_vv: case _p_plus_y_vv:
@ -4360,32 +4364,33 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,yxc); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type ycx */ /* instructions type yxc */
case _p_sll_y_cv: case _p_sll_y_cv:
case _p_slr_y_cv: case _p_slr_y_cv:
case _p_arg_y_cv: case _p_arg_y_cv:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,ycx); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type ycx */ /* instructions type yxc */
case _p_func2s_y_cv: case _p_func2s_y_cv:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,ycx); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type llxx */ /* instructions type plxxs */
case _call_bfunc_xx: case _call_bfunc_xx:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,llxx); pc = NEXTOP(pc,plxxs);
break; break;
/* instructions type llxy */ /* instructions type plxys */
case _call_bfunc_yx: case _call_bfunc_yx:
case _call_bfunc_xy: case _call_bfunc_xy:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,llxy); pc = NEXTOP(pc,plxys);
break; break;
/* instructions type plyys */
case _call_bfunc_yy: case _call_bfunc_yy:
clause_code = TRUE; clause_code = TRUE;
pc = NEXTOP(pc,llyy); pc = NEXTOP(pc,plyys);
break; break;
case _expand_index: case _expand_index:
pp = ((PredEntry *)(Unsigned(pc)-(CELL)(&(((PredEntry *)NULL)->cs.p_code.ExpandCode)))); pp = ((PredEntry *)(Unsigned(pc)-(CELL)(&(((PredEntry *)NULL)->cs.p_code.ExpandCode))));
@ -4404,10 +4409,10 @@ ClauseInfoForCode(yamop *codeptr, CODEADDR *startp, CODEADDR *endp) {
return pp; return pp;
case _expand_clauses: case _expand_clauses:
/* expansion points may not be found when following the indices tree */ /* expansion points may not be found when following the indices tree */
pp = codeptr->u.sp.p; pp = codeptr->u.sssllp.p;
if (pc == codeptr) { if (pc == codeptr) {
*startp = (CODEADDR)codeptr; *startp = (CODEADDR)codeptr;
*endp = (CODEADDR)NEXTOP(codeptr,sp); *endp = (CODEADDR)NEXTOP(codeptr,sssllp);
} }
return pp; return pp;
case _op_fail: case _op_fail:
@ -4895,7 +4900,7 @@ fetch_next_lu_clause(PredEntry *pe, yamop *i_code, Term th, Term tb, Term tr, ya
Terms[0] = th; Terms[0] = th;
Terms[1] = tb; Terms[1] = tb;
Terms[2] = tr; Terms[2] = tr;
cl = Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredLogUpdClause->CodeOfPred,ld), cp_ptr); cl = Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredLogUpdClause->CodeOfPred,apl), cp_ptr);
th = Terms[0]; th = Terms[0];
tb = Terms[1]; tb = Terms[1];
tr = Terms[2]; tr = Terms[2];
@ -5028,7 +5033,7 @@ fetch_next_lu_clause_erase(PredEntry *pe, yamop *i_code, Term th, Term tb, Term
Terms[0] = th; Terms[0] = th;
Terms[1] = tb; Terms[1] = tb;
Terms[2] = tr; Terms[2] = tr;
cl = Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredLogUpdClauseErase->CodeOfPred,ld), cp_ptr); cl = Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredLogUpdClauseErase->CodeOfPred,apl), cp_ptr);
th = Terms[0]; th = Terms[0];
tb = Terms[1]; tb = Terms[1];
tr = Terms[2]; tr = Terms[2];
@ -5165,7 +5170,7 @@ fetch_next_lu_clause0(PredEntry *pe, yamop *i_code, Term th, Term tb, yamop *cp_
Terms[0] = th; Terms[0] = th;
Terms[1] = tb; Terms[1] = tb;
Terms[2] = TermNil; Terms[2] = TermNil;
cl = Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredLogUpdClause0->CodeOfPred,ld), cp_ptr); cl = Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredLogUpdClause0->CodeOfPred,apl), cp_ptr);
th = Terms[0]; th = Terms[0];
tb = Terms[1]; tb = Terms[1];
/* don't do this!! I might have stored a choice-point and changed ASP /* don't do this!! I might have stored a choice-point and changed ASP
@ -5307,9 +5312,9 @@ void /* $hidden_predicate(P) */
Yap_UpdateTimestamps(PredEntry *ap) Yap_UpdateTimestamps(PredEntry *ap)
{ {
choiceptr bptr = B; choiceptr bptr = B;
yamop *cl0 = NEXTOP(PredLogUpdClause0->CodeOfPred,ld); yamop *cl0 = NEXTOP(PredLogUpdClause0->CodeOfPred,apl);
yamop *cl = NEXTOP(PredLogUpdClause->CodeOfPred,ld); yamop *cl = NEXTOP(PredLogUpdClause->CodeOfPred,apl);
yamop *cle = NEXTOP(PredLogUpdClauseErase->CodeOfPred,ld); yamop *cle = NEXTOP(PredLogUpdClauseErase->CodeOfPred,apl);
UInt ar = ap->ArityOfPE; UInt ar = ap->ArityOfPE;
UInt *arp, *top, *base; UInt *arp, *top, *base;
LogUpdClause *lcl; LogUpdClause *lcl;
@ -5333,7 +5338,7 @@ Yap_UpdateTimestamps(PredEntry *ap)
case _trust_logical: case _trust_logical:
case _count_trust_logical: case _count_trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
if (bptr->cp_ap->u.lld.d->ClPred == ap) { if (bptr->cp_ap->u.aLl.d->ClPred == ap) {
UInt ts = IntegerOfTerm(bptr->cp_args[ar]); UInt ts = IntegerOfTerm(bptr->cp_args[ar]);
if (ts != arp[0]) { if (ts != arp[0]) {
if (arp-H < 1024) { if (arp-H < 1024) {
@ -5397,7 +5402,7 @@ Yap_UpdateTimestamps(PredEntry *ap)
case _trust_logical: case _trust_logical:
case _count_trust_logical: case _count_trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
if (bptr->cp_ap->u.lld.d->ClPred == ap) { if (bptr->cp_ap->u.aLl.d->ClPred == ap) {
UInt ts = IntegerOfTerm(bptr->cp_args[ar]); UInt ts = IntegerOfTerm(bptr->cp_args[ar]);
while (ts != arp[0]) while (ts != arp[0])
arp--; arp--;
@ -5439,7 +5444,7 @@ fetch_next_static_clause(PredEntry *pe, yamop *i_code, Term th, Term tb, Term tr
Terms[0] = th; Terms[0] = th;
Terms[1] = tb; Terms[1] = tb;
Terms[2] = tr; Terms[2] = tr;
cl = (StaticClause *)Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredStaticClause->CodeOfPred,ld), cp_ptr); cl = (StaticClause *)Yap_FollowIndexingCode(pe, i_code, Terms, NEXTOP(PredStaticClause->CodeOfPred,apl), cp_ptr);
UNLOCK(pe->PELock); UNLOCK(pe->PELock);
th = Terms[0]; th = Terms[0];
tb = Terms[1]; tb = Terms[1];
@ -5954,7 +5959,7 @@ p_env_info(void)
env_b = MkIntegerTerm((Int)(LCL0-(CELL *)env[E_CB])); env_b = MkIntegerTerm((Int)(LCL0-(CELL *)env[E_CB]));
env_cp = (yamop *)env[E_CP]; env_cp = (yamop *)env[E_CP];
pe = PREVOP(env_cp,sla)->u.sla.p0; pe = PREVOP(env_cp,sbpp)->u.sbpp.p0;
taddr = MkIntegerTerm((Int)env); taddr = MkIntegerTerm((Int)env);
return Yap_unify(ARG3,MkIntegerTerm((Int)env_cp)) && return Yap_unify(ARG3,MkIntegerTerm((Int)env_cp)) &&
Yap_unify(ARG2, taddr) && Yap_unify(ARG2, taddr) &&
@ -5967,7 +5972,7 @@ p_cpc_info(void)
PredEntry *pe; PredEntry *pe;
yamop *ipc = (yamop *)IntegerOfTerm(Deref(ARG1)); yamop *ipc = (yamop *)IntegerOfTerm(Deref(ARG1));
pe = PREVOP(ipc,sla)->u.sla.p0; pe = PREVOP(ipc,sbpp)->u.sbpp.p0;
return UnifyPredInfo(pe, 2) && return UnifyPredInfo(pe, 2) &&
Yap_unify(ARG5,MkIntegerTerm(ClauseId(ipc,pe))); Yap_unify(ARG5,MkIntegerTerm(ClauseId(ipc,pe)));
} }
@ -6047,12 +6052,12 @@ p_choicepoint_info(void)
case _count_trust_logical: case _count_trust_logical:
case _profiled_retry_logical: case _profiled_retry_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
ncl = ipc->u.lld.d->ClCode; ncl = ipc->u.aLl.d->ClCode;
pe = ipc->u.lld.d->ClPred; pe = ipc->u.aLl.d->ClPred;
t = BuildActivePred(pe, cptr->cp_args); t = BuildActivePred(pe, cptr->cp_args);
break; break;
case _or_else: case _or_else:
pe = ipc->u.sla.p0; pe = ipc->u.sblp.p0;
ncl = ipc; ncl = ipc;
t = Yap_MkNewApplTerm(FunctorOr, 2); t = Yap_MkNewApplTerm(FunctorOr, 2);
break; break;
@ -6068,7 +6073,7 @@ p_choicepoint_info(void)
t = TermNil; t = TermNil;
ipc = NEXTOP(ipc,l); ipc = NEXTOP(ipc,l);
if (!ncl) if (!ncl)
ncl = ipc->u.ld.d; ncl = ipc->u.apl.d;
go_on = TRUE; go_on = TRUE;
break; break;
case _jump: case _jump:
@ -6079,15 +6084,15 @@ p_choicepoint_info(void)
break; break;
case _retry_c: case _retry_c:
case _retry_userc: case _retry_userc:
ncl = ipc->u.ld.d; ncl = NEXTOP(ipc,apFs);
pe = ipc->u.lds.p; pe = ipc->u.apFs.p;
t = BuildActivePred(pe, cptr->cp_args); t = BuildActivePred(pe, cptr->cp_args);
break; break;
case _retry_profiled: case _retry_profiled:
case _count_retry: case _count_retry:
pe = NULL; pe = NULL;
t = TermNil; t = TermNil;
ncl = ipc->u.ld.d; ncl = ipc->u.apl.d;
ipc = NEXTOP(ipc,p); ipc = NEXTOP(ipc,p);
go_on = TRUE; go_on = TRUE;
break; break;
@ -6102,8 +6107,8 @@ p_choicepoint_info(void)
case _retry: case _retry:
case _trust: case _trust:
if (!ncl) if (!ncl)
ncl = ipc->u.ld.d; ncl = ipc->u.apl.d;
pe = ipc->u.ld.p; pe = ipc->u.apl.p;
t = BuildActivePred(pe, cptr->cp_args); t = BuildActivePred(pe, cptr->cp_args);
break; break;
case _Nstop: case _Nstop:

39
C/dbase.c
View File

@ -3696,14 +3696,14 @@ index_sz(LogUpdIndex *x)
endop = Yap_opcode(_profiled_trust_logical); endop = Yap_opcode(_profiled_trust_logical);
else else
endop = Yap_opcode(_trust_logical); endop = Yap_opcode(_trust_logical);
start = start->u.Ill.l1; start = start->u.Ills.l1;
do { do {
sz += (UInt)NEXTOP((yamop*)NULL,lld); sz += (UInt)NEXTOP((yamop*)NULL,aLl);
op1 = start->opc; op1 = start->opc;
count++; count++;
if (start->u.lld.d->ClFlags & ErasedMask) if (start->u.aLl.d->ClFlags & ErasedMask)
dead++; dead++;
start = start->u.lld.n; start = start->u.aLl.n;
} while (op1 != endop); } while (op1 != endop);
} }
x = x->ChildIndex; x = x->ChildIndex;
@ -3989,7 +3989,7 @@ find_next_clause(DBRef ref0)
static Int static Int
p_jump_to_next_dynamic_clause(void) p_jump_to_next_dynamic_clause(void)
{ {
DBRef ref = (DBRef)(((yamop *)((CODEADDR)P-(CELL)NEXTOP((yamop *)NULL,sla)))->u.sla.bmap); DBRef ref = (DBRef)(((yamop *)((CODEADDR)P-(CELL)NEXTOP((yamop *)NULL,sbpp)))->u.sbpp.bmap);
yamop *newp = find_next_clause(ref); yamop *newp = find_next_clause(ref);
if (newp == NULL) { if (newp == NULL) {
@ -3998,7 +3998,7 @@ p_jump_to_next_dynamic_clause(void)
/* the next alternative to try must be obtained from this clause */ /* the next alternative to try must be obtained from this clause */
B->cp_ap = newp; B->cp_ap = newp;
/* and next, enter the clause */ /* and next, enter the clause */
P = NEXTOP(newp,ld); P = NEXTOP(newp,apl);
/* and return like if nothing had happened. */ /* and return like if nothing had happened. */
return TRUE; return TRUE;
} }
@ -4015,11 +4015,6 @@ complete_lu_erase(LogUpdClause *clau)
if (CL_IN_USE(clau)) { if (CL_IN_USE(clau)) {
return; return;
} }
if (clau->ClFlags & LogUpdRuleMask &&
clau->ClExt &&
clau->ClExt->u.EC.ClRefs > 0) {
return;
}
#ifndef THREADS #ifndef THREADS
if (clau->ClNext) if (clau->ClNext)
clau->ClNext->ClPrev = clau->ClPrev; clau->ClNext->ClPrev = clau->ClPrev;
@ -4150,20 +4145,20 @@ MyEraseClause(DynamicClause *clau)
I don't need to lock the clause at this point because I don't need to lock the clause at this point because
I am the last one using it anyway. I am the last one using it anyway.
*/ */
ref = (DBRef) NEXTOP(clau->ClCode,ld)->u.sla.bmap; ref = (DBRef) NEXTOP(clau->ClCode,apl)->u.sbpp.bmap;
/* don't do nothing if the reference is still in use */ /* don't do nothing if the reference is still in use */
if (DBREF_IN_USE(ref)) if (DBREF_IN_USE(ref))
return; return;
if ( P == clau->ClCode ) { if ( P == clau->ClCode ) {
yamop *np = RTRYCODE; yamop *np = RTRYCODE;
/* make it the next alternative */ /* make it the next alternative */
np->u.ld.d = find_next_clause((DBRef)(NEXTOP(P,ld)->u.sla.bmap)); np->u.apl.d = find_next_clause((DBRef)(NEXTOP(P,apl)->u.sbpp.bmap));
if (np->u.ld.d == NULL) if (np->u.apl.d == NULL)
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
else { else {
/* with same arity as before */ /* with same arity as before */
np->u.ld.s = P->u.ld.s; np->u.apl.s = P->u.apl.s;
np->u.ld.p = P->u.ld.p; np->u.apl.p = P->u.apl.p;
/* go ahead and try this code */ /* go ahead and try this code */
P = np; P = np;
} }
@ -4213,7 +4208,7 @@ PrepareToEraseLogUpdClause(LogUpdClause *clau, DBRef dbr)
if (p->cs.p_code.FirstClause != cl) { if (p->cs.p_code.FirstClause != cl) {
/* we are not the first clause... */ /* we are not the first clause... */
yamop *prev_code_p = (yamop *)(dbr->Prev->Code); yamop *prev_code_p = (yamop *)(dbr->Prev->Code);
prev_code_p->u.ld.d = code_p->u.ld.d; prev_code_p->u.apl.d = code_p->u.apl.d;
/* are we the last? */ /* are we the last? */
if (p->cs.p_code.LastClause == cl) if (p->cs.p_code.LastClause == cl)
p->cs.p_code.LastClause = prev_code_p; p->cs.p_code.LastClause = prev_code_p;
@ -4222,7 +4217,7 @@ PrepareToEraseLogUpdClause(LogUpdClause *clau, DBRef dbr)
if (p->cs.p_code.LastClause == p->cs.p_code.FirstClause) { if (p->cs.p_code.LastClause == p->cs.p_code.FirstClause) {
p->cs.p_code.LastClause = p->cs.p_code.FirstClause = NULL; p->cs.p_code.LastClause = p->cs.p_code.FirstClause = NULL;
} else { } else {
p->cs.p_code.FirstClause = code_p->u.ld.d; p->cs.p_code.FirstClause = code_p->u.apl.d;
p->cs.p_code.FirstClause->opc = p->cs.p_code.FirstClause->opc =
Yap_opcode(_try_me); Yap_opcode(_try_me);
} }
@ -4237,8 +4232,8 @@ PrepareToEraseLogUpdClause(LogUpdClause *clau, DBRef dbr)
if (p->cs.p_code.FirstClause == p->cs.p_code.LastClause) { if (p->cs.p_code.FirstClause == p->cs.p_code.LastClause) {
if (p->cs.p_code.FirstClause != NULL) { if (p->cs.p_code.FirstClause != NULL) {
code_p = p->cs.p_code.FirstClause; code_p = p->cs.p_code.FirstClause;
code_p->u.ld.d = p->cs.p_code.FirstClause; code_p->u.apl.d = p->cs.p_code.FirstClause;
p->cs.p_code.TrueCodeOfPred = NEXTOP(code_p, ld); p->cs.p_code.TrueCodeOfPred = NEXTOP(code_p, apl);
if (p->PredFlags & SpiedPredFlag) { if (p->PredFlags & SpiedPredFlag) {
p->OpcodeOfPred = Yap_opcode(_spy_pred); p->OpcodeOfPred = Yap_opcode(_spy_pred);
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred)); p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
@ -5450,9 +5445,9 @@ void
Yap_InitBackDB(void) Yap_InitBackDB(void)
{ {
Yap_InitCPredBack("$recorded_with_key", 3, 3, in_rded_with_key, co_rded, SyncPredFlag|HiddenPredFlag); Yap_InitCPredBack("$recorded_with_key", 3, 3, in_rded_with_key, co_rded, SyncPredFlag|HiddenPredFlag);
RETRY_C_RECORDED_K_CODE = NEXTOP(PredRecordedWithKey->cs.p_code.FirstClause,lds); RETRY_C_RECORDED_K_CODE = NEXTOP(PredRecordedWithKey->cs.p_code.FirstClause,apFs);
Yap_InitCPredBack("$recordedp", 3, 3, in_rdedp, co_rdedp, SyncPredFlag|HiddenPredFlag); Yap_InitCPredBack("$recordedp", 3, 3, in_rdedp, co_rdedp, SyncPredFlag|HiddenPredFlag);
RETRY_C_RECORDEDP_CODE = NEXTOP(RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("$recordedp"), 3),0))->cs.p_code.FirstClause,lds); RETRY_C_RECORDEDP_CODE = NEXTOP(RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("$recordedp"), 3),0))->cs.p_code.FirstClause,apFs);
Yap_InitCPredBack("$current_immediate_key", 2, 4, init_current_key, cont_current_key, Yap_InitCPredBack("$current_immediate_key", 2, 4, init_current_key, cont_current_key,
SyncPredFlag|HiddenPredFlag); SyncPredFlag|HiddenPredFlag);
} }

6
C/gprof.c
View File

@ -790,7 +790,7 @@ showprofres(UInt type) {
InCCall++; /* I Was in a C Call */ InCCall++; /* I Was in a C Call */
pc_ptr=y; pc_ptr=y;
/* /*
printf("Aqui está um call_cpred(%p) \n",y->u.sla.sla_u.p->cs.f_code); printf("Aqui está um call_cpred(%p) \n",y->u.sbpp.p->cs.f_code);
for(i=0;i<_std_top && pc_ptr->opc!=Yap_ABSMI_OPCODES[i];i++); for(i=0;i<_std_top && pc_ptr->opc!=Yap_ABSMI_OPCODES[i];i++);
printf("Outro syscall diferente %s\n", Yap_op_names[i]); printf("Outro syscall diferente %s\n", Yap_op_names[i]);
*/ */
@ -973,11 +973,11 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
current_p = P; current_p = P;
#endif #endif
} else { } else {
op_numbers oop = Yap_op_from_opcode(PREVOP(P,sla)->opc); op_numbers oop = Yap_op_from_opcode(PREVOP(P,sbpp)->opc);
if (oop == _call_cpred || oop == _call_usercpred) { if (oop == _call_cpred || oop == _call_usercpred) {
/* doing C-code */ /* doing C-code */
current_p = PREVOP(P,sla)->u.sla.sla_u.p->CodeOfPred; current_p = PREVOP(P,sbpp)->u.sbpp.p->CodeOfPred;
} else { } else {
current_p = P; current_p = P;
} }

62
C/heapgc.c
View File

@ -1817,10 +1817,10 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
{ {
OPCODE trust_lu = Yap_opcode(_trust_logical); OPCODE trust_lu = Yap_opcode(_trust_logical);
yamop *lu_cl0 = NEXTOP(PredLogUpdClause0->CodeOfPred,ld), yamop *lu_cl0 = NEXTOP(PredLogUpdClause0->CodeOfPred,apl),
*lu_cl = NEXTOP(PredLogUpdClause->CodeOfPred,ld), *lu_cl = NEXTOP(PredLogUpdClause->CodeOfPred,apl),
*lu_cle = NEXTOP(PredLogUpdClauseErase->CodeOfPred,ld), *lu_cle = NEXTOP(PredLogUpdClauseErase->CodeOfPred,apl),
*su_cl = NEXTOP(PredStaticClause->CodeOfPred,ld); *su_cl = NEXTOP(PredStaticClause->CodeOfPred,apl);
#ifdef TABLING #ifdef TABLING
dep_fr_ptr depfr = LOCAL_top_dep_fr; dep_fr_ptr depfr = LOCAL_top_dep_fr;
#endif /* TABLING */ #endif /* TABLING */
@ -1889,13 +1889,8 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
if (opnum == _or_else || opnum == _or_last) { if (opnum == _or_else || opnum == _or_last) {
/* ; choice point */ /* ; choice point */
mark_environments((CELL_PTR) (gc_B->cp_a1), mark_environments((CELL_PTR) (gc_B->cp_a1),
#ifdef YAPOR -gc_B->cp_cp->u.sblp.s / ((OPREG)sizeof(CELL)),
-gc_B->cp_cp->u.ldl.s / ((OPREG)sizeof(CELL)), gc_B->cp_cp->u.sblp.bmap
(CELL *)(gc_B->cp_cp->u.ldl.bl)
#else
-gc_B->cp_cp->u.sla.s / ((OPREG)sizeof(CELL)),
gc_B->cp_cp->u.sla.bmap
#endif
); );
} else { } else {
/* choicepoint with arguments */ /* choicepoint with arguments */
@ -1943,7 +1938,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
} }
B = old_b; B = old_b;
} }
nargs = rtp->u.lds.s+rtp->u.lds.extra; nargs = rtp->u.apFs.s+rtp->u.apFs.extra;
break; break;
case _jump: case _jump:
rtp = rtp->u.l.l; rtp = rtp->u.l.l;
@ -1980,7 +1975,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
{ {
CELL *vars_ptr, vars; CELL *vars_ptr, vars;
vars_ptr = (CELL *)(GEN_CP(gc_B) + 1); vars_ptr = (CELL *)(GEN_CP(gc_B) + 1);
nargs = rtp->u.ld.s; nargs = rtp->u.apl.s;
while (nargs--) { while (nargs--) {
mark_external_reference(vars_ptr); mark_external_reference(vars_ptr);
vars_ptr++; vars_ptr++;
@ -2096,20 +2091,20 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
on the other hand it's the only way we can be sure we can reclaim on the other hand it's the only way we can be sure we can reclaim
space space
*/ */
yamop *end = rtp->u.lld.n; yamop *end = rtp->u.aLl.n;
while (end->opc != trust_lu) while (end->opc != trust_lu)
end = end->u.lld.n; end = end->u.aLl.n;
mark_ref_in_use((DBRef)end->u.lld.t.block); mark_ref_in_use((DBRef)end->u.ILl.block);
} }
/* mark timestamp */ /* mark timestamp */
nargs = rtp->u.lld.t.s+1; nargs = rtp->u.aLl.s+1;
break; break;
case _trust_logical: case _trust_logical:
case _count_trust_logical: case _count_trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
/* mark timestamp */ /* mark timestamp */
mark_ref_in_use((DBRef)rtp->u.lld.t.block); mark_ref_in_use((DBRef)rtp->u.ILl.block);
nargs = rtp->u.lld.d->ClPred->ArityOfPE+1; nargs = rtp->u.ILl.d->ClPred->ArityOfPE+1;
break; break;
#ifdef DEBUG #ifdef DEBUG
case _retry_me: case _retry_me:
@ -2120,14 +2115,14 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
case _count_trust_me: case _count_trust_me:
case _retry: case _retry:
case _trust: case _trust:
nargs = rtp->u.ld.s; nargs = rtp->u.apl.s;
break; break;
default: default:
fprintf(Yap_stderr, "OOps in GC: Unexpected opcode: %d\n", opnum); fprintf(Yap_stderr, "OOps in GC: Unexpected opcode: %d\n", opnum);
nargs = 0; nargs = 0;
#else #else
default: default:
nargs = rtp->u.ld.s; nargs = rtp->u.apl.s;
#endif #endif
} }
@ -2141,8 +2136,8 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
mark_db_fixed((CELL *)pt); mark_db_fixed((CELL *)pt);
} else { } else {
while (pt->opc != trust_lu) while (pt->opc != trust_lu)
pt = pt->u.lld.n; pt = pt->u.aLl.n;
mark_ref_in_use((DBRef)pt->u.lld.t.block); mark_ref_in_use((DBRef)pt->u.ILl.block);
} }
} }
/* for each saved register */ /* for each saved register */
@ -2752,13 +2747,8 @@ sweep_choicepoints(choiceptr gc_B)
case _or_last: case _or_last:
sweep_environments((CELL_PTR)(gc_B->cp_a1), sweep_environments((CELL_PTR)(gc_B->cp_a1),
#ifdef YAPOR -gc_B->cp_cp->u.sblp.s / ((OPREG)sizeof(CELL)),
-gc_B->cp_cp->u.ldl.s / ((OPREG)sizeof(CELL)), gc_B->cp_cp->u.sblp.bmap
(CELL *)(gc_B->cp_cp->u.ldl.bl)
#else
-gc_B->cp_cp->u.sla.s / ((OPREG)sizeof(CELL)),
gc_B->cp_cp->u.sla.bmap
#endif
); );
break; break;
case _retry_profiled: case _retry_profiled:
@ -2801,7 +2791,7 @@ sweep_choicepoints(choiceptr gc_B)
CELL *vars_ptr, vars; CELL *vars_ptr, vars;
sweep_environments(gc_B->cp_env, EnvSize((CELL_PTR) (gc_B->cp_cp)), EnvBMap((CELL_PTR) (gc_B->cp_cp))); sweep_environments(gc_B->cp_env, EnvSize((CELL_PTR) (gc_B->cp_cp)), EnvBMap((CELL_PTR) (gc_B->cp_cp)));
vars_ptr = (CELL *)(GEN_CP(gc_B) + 1); vars_ptr = (CELL *)(GEN_CP(gc_B) + 1);
nargs = rtp->u.ld.s; nargs = rtp->u.apl.s;
while(nargs--) { while(nargs--) {
CELL cp_cell = *vars_ptr; CELL cp_cell = *vars_ptr;
if (MARKED_PTR(vars_ptr)) { if (MARKED_PTR(vars_ptr)) {
@ -2947,12 +2937,12 @@ sweep_choicepoints(choiceptr gc_B)
case _count_retry_logical: case _count_retry_logical:
case _profiled_retry_logical: case _profiled_retry_logical:
/* sweep timestamp */ /* sweep timestamp */
sweep_b(gc_B, rtp->u.lld.t.s+1); sweep_b(gc_B, rtp->u.aLl.s+1);
break; break;
case _trust_logical: case _trust_logical:
case _count_trust_logical: case _count_trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
sweep_b(gc_B, rtp->u.lld.d->ClPred->ArityOfPE+1); sweep_b(gc_B, rtp->u.ILl.d->ClPred->ArityOfPE+1);
break; break;
case _retry2: case _retry2:
sweep_b(gc_B, 2); sweep_b(gc_B, 2);
@ -2969,8 +2959,8 @@ sweep_choicepoints(choiceptr gc_B)
register CELL_PTR saved_reg; register CELL_PTR saved_reg;
/* for each extra saved register */ /* for each extra saved register */
for (saved_reg = &(gc_B->cp_a1)+rtp->u.lds.s; for (saved_reg = &(gc_B->cp_a1)+rtp->u.apFs.s;
saved_reg < &(gc_B->cp_a1)+rtp->u.lds.s+rtp->u.lds.extra; saved_reg < &(gc_B->cp_a1)+rtp->u.apFs.s+rtp->u.apFs.extra;
saved_reg++) { saved_reg++) {
CELL cp_cell = *saved_reg; CELL cp_cell = *saved_reg;
if (MARKED_PTR(saved_reg)) { if (MARKED_PTR(saved_reg)) {
@ -2983,7 +2973,7 @@ sweep_choicepoints(choiceptr gc_B)
} }
/* continue to clean environments and arguments */ /* continue to clean environments and arguments */
default: default:
sweep_b(gc_B,rtp->u.ld.s); sweep_b(gc_B,rtp->u.apl.s);
} }
/* link to prev choicepoint */ /* link to prev choicepoint */

645
C/index.c
View File

File diff suppressed because it is too large Load Diff

102
C/init.c
View File

@ -504,9 +504,9 @@ Yap_InitCPred(char *Name, unsigned long int Arity, CPredicate code, int flags)
UInt sz; UInt sz;
if (flags & SafePredFlag) { if (flags & SafePredFlag) {
sz = (CELL)NEXTOP(NEXTOP(NEXTOP(p_code,sla),p),l); sz = (CELL)NEXTOP(NEXTOP(NEXTOP(p_code,sbpp),p),l);
} else { } else {
sz = (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(NEXTOP(p_code,e),sla),e),p),l); sz = (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(NEXTOP(p_code,e),sbpp),e),p),l);
} }
cl = (StaticClause *)Yap_AllocCodeSpace(sz); cl = (StaticClause *)Yap_AllocCodeSpace(sz);
if (!cl) { if (!cl) {
@ -535,12 +535,12 @@ Yap_InitCPred(char *Name, unsigned long int Arity, CPredicate code, int flags)
p_code->opc = Yap_opcode(_call_usercpred); p_code->opc = Yap_opcode(_call_usercpred);
else else
p_code->opc = Yap_opcode(_call_cpred); p_code->opc = Yap_opcode(_call_cpred);
p_code->u.sla.bmap = NULL; p_code->u.sbpp.bmap = NULL;
p_code->u.sla.s = -Signed(RealEnvSize); p_code->u.sbpp.s = -Signed(RealEnvSize);
p_code->u.sla.sla_u.p = p_code->u.sbpp.p =
p_code->u.sla.p0 = p_code->u.sbpp.p0 =
pe; pe;
p_code = NEXTOP(p_code,sla); p_code = NEXTOP(p_code,sbpp);
if (!(flags & SafePredFlag)) { if (!(flags & SafePredFlag)) {
p_code->opc = Yap_opcode(_deallocate); p_code->opc = Yap_opcode(_deallocate);
p_code = NEXTOP(p_code,e); p_code = NEXTOP(p_code,e);
@ -571,7 +571,7 @@ Yap_InitCmpPred(char *Name, unsigned long int Arity, CmpPredicate cmp_code, int
/* already exists */ /* already exists */
} else { } else {
while (!cl) { while (!cl) {
UInt sz = sizeof(StaticClause)+(CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)NULL),llxx),p),l); UInt sz = sizeof(StaticClause)+(CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)NULL),plxxs),p),l);
cl = (StaticClause *)Yap_AllocCodeSpace(sz); cl = (StaticClause *)Yap_AllocCodeSpace(sz);
if (!cl) { if (!cl) {
if (!Yap_growheap(FALSE, sz, NULL)) { if (!Yap_growheap(FALSE, sz, NULL)) {
@ -594,12 +594,12 @@ Yap_InitCmpPred(char *Name, unsigned long int Arity, CmpPredicate cmp_code, int
pe->cs.d_code = cmp_code; pe->cs.d_code = cmp_code;
pe->ModuleOfPred = CurrentModule; pe->ModuleOfPred = CurrentModule;
p_code->opc = pe->OpcodeOfPred = Yap_opcode(_call_bfunc_xx); p_code->opc = pe->OpcodeOfPred = Yap_opcode(_call_bfunc_xx);
p_code->u.llxx.p = pe; p_code->u.plxxs.p = pe;
p_code->u.llxx.f = FAILCODE; p_code->u.plxxs.f = FAILCODE;
p_code->u.llxx.x1 = Yap_emit_x(1); p_code->u.plxxs.x1 = Yap_emit_x(1);
p_code->u.llxx.x2 = Yap_emit_x(2); p_code->u.plxxs.x2 = Yap_emit_x(2);
p_code->u.llxx.flags = Yap_compile_cmp_flags(pe); p_code->u.plxxs.flags = Yap_compile_cmp_flags(pe);
p_code = NEXTOP(p_code,llxx); p_code = NEXTOP(p_code,plxxs);
p_code->opc = Yap_opcode(_procceed); p_code->opc = Yap_opcode(_procceed);
p_code->u.p.p = pe; p_code->u.p.p = pe;
p_code = NEXTOP(p_code,p); p_code = NEXTOP(p_code,p);
@ -625,26 +625,26 @@ Yap_InitAsmPred(char *Name, unsigned long int Arity, int code, CPredicate def,
StaticClause *cl; StaticClause *cl;
if (pe->CodeOfPred == (yamop *)(&(pe->OpcodeOfPred))) { if (pe->CodeOfPred == (yamop *)(&(pe->OpcodeOfPred))) {
cl = (StaticClause *)Yap_AllocCodeSpace((CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sla),p),l)); cl = (StaticClause *)Yap_AllocCodeSpace((CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sbpp),p),l));
if (!cl) { if (!cl) {
Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"No Heap Space in InitAsmPred"); Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"No Heap Space in InitAsmPred");
return; return;
} }
Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sla),p),l); Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sbpp),p),l);
} else { } else {
cl = ClauseCodeToStaticClause(pe->CodeOfPred); cl = ClauseCodeToStaticClause(pe->CodeOfPred);
} }
cl->ClFlags = StaticMask; cl->ClFlags = StaticMask;
cl->ClNext = NULL; cl->ClNext = NULL;
cl->ClSize = (CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sla),e),e); cl->ClSize = (CELL)NEXTOP(NEXTOP(NEXTOP(((yamop *)p_code),sbpp),e),e);
cl->usc.ClPred = pe; cl->usc.ClPred = pe;
p_code = cl->ClCode; p_code = cl->ClCode;
pe->CodeOfPred = p_code; pe->CodeOfPred = p_code;
p_code->opc = pe->OpcodeOfPred = Yap_opcode(_call_cpred); p_code->opc = pe->OpcodeOfPred = Yap_opcode(_call_cpred);
p_code->u.sla.bmap = NULL; p_code->u.sbpp.bmap = NULL;
p_code->u.sla.s = -Signed(RealEnvSize); p_code->u.sbpp.s = -Signed(RealEnvSize);
p_code->u.sla.sla_u.p = p_code->u.sla.p0 = pe; p_code->u.sbpp.p = p_code->u.sbpp.p0 = pe;
p_code = NEXTOP(p_code,sla); p_code = NEXTOP(p_code,sbpp);
p_code->opc = Yap_opcode(_procceed); p_code->opc = Yap_opcode(_procceed);
p_code->u.p.p = pe; p_code->u.p.p = pe;
p_code = NEXTOP(p_code,p); p_code = NEXTOP(p_code,p);
@ -681,8 +681,8 @@ CleanBack(PredEntry *pe, CPredicate Start, CPredicate Cont)
INIT_YAMOP_LTT(code, 2); INIT_YAMOP_LTT(code, 2);
PUT_YAMOP_SEQ(code); PUT_YAMOP_SEQ(code);
#endif /* YAPOR */ #endif /* YAPOR */
code->u.lds.f = Start; code->u.apFs.f = Start;
code = NEXTOP(code,lds); code = NEXTOP(code,apFs);
if (pe->PredFlags & UserCPredFlag) if (pe->PredFlags & UserCPredFlag)
code->opc = Yap_opcode(_retry_userc); code->opc = Yap_opcode(_retry_userc);
else else
@ -691,14 +691,14 @@ CleanBack(PredEntry *pe, CPredicate Start, CPredicate Cont)
INIT_YAMOP_LTT(code, 1); INIT_YAMOP_LTT(code, 1);
PUT_YAMOP_SEQ(code); PUT_YAMOP_SEQ(code);
#endif /* YAPOR */ #endif /* YAPOR */
code->u.lds.f = Cont; code->u.apFs.f = Cont;
#ifdef CUT_C #ifdef CUT_C
code = NEXTOP(code,lds); code = NEXTOP(code,apFs);
if (pe->PredFlags & UserCPredFlag) if (pe->PredFlags & UserCPredFlag)
code->opc = Yap_opcode(_cut_c); code->opc = Yap_opcode(_cut_c);
else else
code->opc = Yap_opcode(_cut_userc); code->opc = Yap_opcode(_cut_userc);
code->u.lds.f = Cut; code->u.apFs.f = Cut;
#endif #endif
} }
@ -758,9 +758,9 @@ Yap_InitCPredBack(char *Name, unsigned long int Arity,
#endif /* YAPOR */ #endif /* YAPOR */
#ifdef CUT_C #ifdef CUT_C
cl = (StaticClause *)Yap_AllocCodeSpace((CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,lds),lds),lds),l)); cl = (StaticClause *)Yap_AllocCodeSpace((CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,apFs),apFs),apFs),l));
#else #else
cl = (StaticClause *)Yap_AllocCodeSpace((CELL)NEXTOP(NEXTOP(NEXTOP(code,lds),lds),l)); cl = (StaticClause *)Yap_AllocCodeSpace((CELL)NEXTOP(NEXTOP(NEXTOP(code,apFs),apFs),l));
#endif #endif
if (cl == NULL) { if (cl == NULL) {
@ -770,13 +770,13 @@ Yap_InitCPredBack(char *Name, unsigned long int Arity,
cl->ClFlags = StaticMask; cl->ClFlags = StaticMask;
cl->ClNext = NULL; cl->ClNext = NULL;
#ifdef CUT_C #ifdef CUT_C
Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,lds),lds),lds),l); Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,apFs),apFs),apFs),l);
cl->ClSize = cl->ClSize =
(CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,lds),lds),lds),e); (CELL)NEXTOP(NEXTOP(NEXTOP(NEXTOP(code,apFs),apFs),apFs),e);
#else #else
Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(code,lds),lds),l); Yap_ClauseSpace += (CELL)NEXTOP(NEXTOP(NEXTOP(code,apFs),apFs),l);
cl->ClSize = cl->ClSize =
(CELL)NEXTOP(NEXTOP(NEXTOP(code,lds),lds),e); (CELL)NEXTOP(NEXTOP(NEXTOP(code,apFs),apFs),e);
#endif #endif
cl->usc.ClPred = pe; cl->usc.ClPred = pe;
@ -787,38 +787,38 @@ Yap_InitCPredBack(char *Name, unsigned long int Arity,
pe->OpcodeOfPred = code->opc = Yap_opcode(_try_userc); pe->OpcodeOfPred = code->opc = Yap_opcode(_try_userc);
else else
pe->OpcodeOfPred = code->opc = Yap_opcode(_try_c); pe->OpcodeOfPred = code->opc = Yap_opcode(_try_c);
code->u.lds.f = Start; code->u.apFs.f = Start;
code->u.lds.p = pe; code->u.apFs.p = pe;
code->u.lds.s = Arity; code->u.apFs.s = Arity;
code->u.lds.extra = Extra; code->u.apFs.extra = Extra;
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(code, 2); INIT_YAMOP_LTT(code, 2);
PUT_YAMOP_SEQ(code); PUT_YAMOP_SEQ(code);
#endif /* YAPOR */ #endif /* YAPOR */
code = NEXTOP(code,lds); code = NEXTOP(code,apFs);
if (flags & UserCPredFlag) if (flags & UserCPredFlag)
code->opc = Yap_opcode(_retry_userc); code->opc = Yap_opcode(_retry_userc);
else else
code->opc = Yap_opcode(_retry_c); code->opc = Yap_opcode(_retry_c);
code->u.lds.f = Cont; code->u.apFs.f = Cont;
code->u.lds.p = pe; code->u.apFs.p = pe;
code->u.lds.s = Arity; code->u.apFs.s = Arity;
code->u.lds.extra = Extra; code->u.apFs.extra = Extra;
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(code, 1); INIT_YAMOP_LTT(code, 1);
PUT_YAMOP_SEQ(code); PUT_YAMOP_SEQ(code);
#endif /* YAPOR */ #endif /* YAPOR */
code = NEXTOP(code,lds); code = NEXTOP(code,apFs);
#ifdef CUT_C #ifdef CUT_C
if (flags & UserCPredFlag) if (flags & UserCPredFlag)
code->opc = Yap_opcode(_cut_userc); code->opc = Yap_opcode(_cut_userc);
else else
code->opc = Yap_opcode(_cut_c); code->opc = Yap_opcode(_cut_c);
code->u.lds.f = Cut; code->u.apFs.f = Cut;
code->u.lds.p = pe; code->u.apFs.p = pe;
code->u.lds.s = Arity; code->u.apFs.s = Arity;
code->u.lds.extra = Extra; code->u.apFs.extra = Extra;
code = NEXTOP(code,lds); code = NEXTOP(code,apFs);
#endif /* CUT_C */ #endif /* CUT_C */
code->opc = Yap_opcode(_Ystop); code->opc = Yap_opcode(_Ystop);
code->u.l.l = cl->ClCode; code->u.l.l = cl->ClCode;
@ -958,8 +958,8 @@ InitCodes(void)
Yap_heap_regs->nocode.opc = Yap_opcode(_Nstop); Yap_heap_regs->nocode.opc = Yap_opcode(_Nstop);
Yap_heap_regs->rtrycode.opc = Yap_opcode(_retry_and_mark); Yap_heap_regs->rtrycode.opc = Yap_opcode(_retry_and_mark);
Yap_heap_regs->rtrycode.u.ld.s = 0; Yap_heap_regs->rtrycode.u.apl.s = 0;
Yap_heap_regs->rtrycode.u.ld.d = NIL; Yap_heap_regs->rtrycode.u.apl.d = NIL;
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(&(Yap_heap_regs->rtrycode), 1); INIT_YAMOP_LTT(&(Yap_heap_regs->rtrycode), 1);
#endif /* YAPOR */ #endif /* YAPOR */
@ -1309,8 +1309,8 @@ InitCodes(void)
modp->PredFlags |= MetaPredFlag; modp->PredFlags |= MetaPredFlag;
} }
#ifdef YAPOR #ifdef YAPOR
Yap_heap_regs->getwork_code.u.ld.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork"), PROLOG_MODULE)); Yap_heap_regs->getwork_code.u.apl.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork"), PROLOG_MODULE));
Yap_heap_regs->getwork_seq_code.u.ld.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork_seq"), PROLOG_MODULE)); Yap_heap_regs->getwork_seq_code.u.apl.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork_seq"), PROLOG_MODULE));
#endif /* YAPOR */ #endif /* YAPOR */
Yap_heap_regs->db_erased_marker = Yap_heap_regs->db_erased_marker =
(DBRef)Yap_AllocCodeSpace(sizeof(DBStruct)); (DBRef)Yap_AllocCodeSpace(sizeof(DBStruct));

685
H/YapOpcodes.h
View File

@ -1,467 +1,275 @@
/*************************************************************************
* * /* This file was generated automatically by "yap -L misc/buildops"
* YAP Prolog * please do not update */
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: YapOpcodes.h *
* comments: Central Table with all YAP opcodes *
* *
* Last rev: $Date: 2008-07-24 16:02:01 $ *
* $Log: not supported by cvs2svn $
* Revision 1.45 2008/07/16 10:58:59 vsc
* small fixes
*
* Revision 1.44 2008/03/25 22:03:13 vsc
* fix some icc warnings
*
* Revision 1.43 2007/11/26 23:43:09 vsc
* fixes to support threads and assert correctly, even if inefficiently.
*
* Revision 1.42 2007/11/07 09:25:27 vsc
* speedup meta-calls
*
* Revision 1.41 2007/11/06 17:02:12 vsc
* compile ground terms away.
*
* Revision 1.40 2006/10/10 14:08:17 vsc
* small fixes on threaded implementation.
*
* Revision 1.39 2006/09/20 20:03:51 vsc
* improve indexing on floats
* fix sending large lists to DB
*
* Revision 1.38 2006/04/27 14:13:24 rslopes
* *** empty log message ***
*
* Revision 1.37 2006/03/24 16:34:21 rslopes
* New update to BEAM engine.
* BEAM now uses YAP Indexing (JITI)
*
* Revision 1.36 2005/12/17 03:25:39 vsc
* major changes to support online event-based profiling
* improve error discovery and restart on scanner.
*
* Revision 1.35 2005/11/18 18:50:34 tiagosoares
* support for executing c code when a cut occurs
*
* Revision 1.34 2005/09/08 21:55:48 rslopes
* BEAM for YAP update...
*
* Revision 1.33 2005/08/01 15:40:38 ricroc
* TABLING NEW: better support for incomplete tabling
*
* Revision 1.32 2005/07/06 19:34:11 ricroc
* TABLING: answers for completed calls can now be obtained by loading (new option) or executing (default) them from the trie data structure.
*
* Revision 1.31 2005/07/06 15:10:15 vsc
* improvements to compiler: merged instructions and fixes for ->
*
* Revision 1.30 2005/06/04 07:26:43 ricroc
* long int support for tabling
*
* Revision 1.29 2005/06/03 08:18:25 ricroc
* float support for tabling
*
* Revision 1.28 2005/06/01 20:25:23 vsc
* == and \= should not need a choice-point in ->
*
* Revision 1.27 2005/06/01 14:02:52 vsc
* get_rid of try_me?, retry_me? and trust_me? instructions: they are not
* significantly used nowadays.
*
* Revision 1.26 2005/04/10 04:01:13 vsc
* bug fixes, I hope!
*
* Revision 1.25 2004/10/26 20:16:04 vsc
* More bug fixes for overflow handling
*
* Revision 1.24 2004/09/27 20:45:04 vsc
* Mega clauses
* Fixes to sizeof(expand_clauses) which was being overestimated
* Fixes to profiling+indexing
* Fixes to reallocation of memory after restoring
* Make sure all clauses, even for C, end in _Ystop
* Don't reuse space for Streams
* Fix Stream_F on StreaNo+1
*
* Revision 1.23 2004/03/31 01:03:10 vsc
* support expand group of clauses
*
* Revision 1.22 2004/03/19 11:35:42 vsc
* trim_trail for default machine
* be more aggressive about try-retry-trust chains.
* - handle cases where block starts with a wait
* - don't use _killed instructions, just let the thing rot by itself.
*
* Revision 1.21 2004/03/10 14:59:55 vsc
* optimise -> for type tests
* *
* *
*************************************************************************/
OPCODE(Ystop ,l), OPCODE(Ystop ,l),
OPCODE(Nstop ,e), OPCODE(Nstop ,e),
OPCODE(try_me ,apl),
OPCODE(retry_me ,apl),
OPCODE(trust_me ,apl),
OPCODE(enter_profiling ,p),
OPCODE(enter_a_profiling ,e),
OPCODE(retry_profiled ,p),
OPCODE(profiled_retry_me ,apl),
OPCODE(profiled_trust_me ,apl),
OPCODE(profiled_retry_logical ,aLl),
OPCODE(profiled_trust_logical ,ILl),
OPCODE(count_call ,p),
OPCODE(count_a_call ,e),
OPCODE(count_retry ,p),
OPCODE(count_retry_me ,apl),
OPCODE(count_trust_me ,apl),
OPCODE(count_retry_logical ,aLl),
OPCODE(count_trust_logical ,ILl),
OPCODE(lock_lu ,e),
OPCODE(unlock_lu ,e),
OPCODE(alloc_for_logical_pred ,L),
OPCODE(copy_idb_term ,e),
OPCODE(unify_idb_term ,e),
OPCODE(spy_or_trymark ,apl),
OPCODE(try_and_mark ,apl),
OPCODE(count_retry_and_mark ,apl),
OPCODE(profiled_retry_and_mark ,apl),
OPCODE(retry_and_mark ,apl),
OPCODE(trust_fail ,e),
OPCODE(op_fail ,e),
OPCODE(cut ,e),
OPCODE(cut_t ,e),
OPCODE(cut_e ,e),
OPCODE(save_b_x ,x),
OPCODE(save_b_y ,y),
OPCODE(commit_b_x ,x),
OPCODE(commit_b_y ,y),
OPCODE(execute ,pp), OPCODE(execute ,pp),
OPCODE(call ,sla), OPCODE(dexecute ,pp),
OPCODE(fcall ,sbpp),
OPCODE(call ,sbpp),
OPCODE(procceed ,p), OPCODE(procceed ,p),
OPCODE(allocate ,e), OPCODE(allocate ,e),
OPCODE(deallocate ,e), OPCODE(deallocate ,e),
OPCODE(op_fail ,e), #ifdef BEAM
#ifdef YAPOR OPCODE(retry_eam ,e),
OPCODE(getwork_first_time ,e),
OPCODE(getwork ,ld),
OPCODE(getwork_seq ,ld),
OPCODE(sync ,ld),
#endif /* YAPOR */
#ifdef TABLING_INNER_CUTS
OPCODE(clause_with_cut ,e),
#endif /* TABLING_INNER_CUTS */
#ifdef TABLING
OPCODE(table_load_answer ,ld),
OPCODE(table_try_answer ,ld),
OPCODE(table_try_single ,ld),
OPCODE(table_try_me ,ld),
OPCODE(table_try ,ld),
OPCODE(table_retry_me ,ld),
OPCODE(table_retry ,ld),
OPCODE(table_trust_me ,ld),
OPCODE(table_trust ,ld),
OPCODE(table_new_answer ,s),
OPCODE(table_answer_resolution ,ld),
OPCODE(table_completion ,ld),
OPCODE(trie_do_null ,e),
OPCODE(trie_trust_null ,e),
OPCODE(trie_try_null ,e),
OPCODE(trie_retry_null ,e),
OPCODE(trie_do_var ,e),
OPCODE(trie_trust_var ,e),
OPCODE(trie_try_var ,e),
OPCODE(trie_retry_var ,e),
OPCODE(trie_do_val ,e),
OPCODE(trie_trust_val ,e),
OPCODE(trie_try_val ,e),
OPCODE(trie_retry_val ,e),
OPCODE(trie_do_atom ,e),
OPCODE(trie_trust_atom ,e),
OPCODE(trie_try_atom ,e),
OPCODE(trie_retry_atom ,e),
OPCODE(trie_do_list ,e),
OPCODE(trie_trust_list ,e),
OPCODE(trie_try_list ,e),
OPCODE(trie_retry_list ,e),
OPCODE(trie_do_struct ,e),
OPCODE(trie_trust_struct ,e),
OPCODE(trie_try_struct ,e),
OPCODE(trie_retry_struct ,e),
OPCODE(trie_do_extension ,e),
OPCODE(trie_trust_extension ,e),
OPCODE(trie_try_extension ,e),
OPCODE(trie_retry_extension ,e),
OPCODE(trie_do_float ,e),
OPCODE(trie_trust_float ,e),
OPCODE(trie_try_float ,e),
OPCODE(trie_retry_float ,e),
OPCODE(trie_do_long ,e),
OPCODE(trie_trust_long ,e),
OPCODE(trie_try_long ,e),
OPCODE(trie_retry_long ,e),
#endif /* TABLING */
OPCODE(try_me ,ld),
OPCODE(retry_me ,ld),
OPCODE(trust_me ,ld),
OPCODE(try_and_mark ,ld),
OPCODE(retry_and_mark ,ld),
OPCODE(try_c ,lds),
OPCODE(retry_c ,lds),
#ifdef CUT_C
OPCODE(cut_c ,lds),
#endif #endif
OPCODE(try_userc ,lds), #ifdef BEAM
OPCODE(retry_userc ,lds), OPCODE(run_eam ,os),
#ifdef CUT_C
OPCODE(cut_userc ,lds),
#endif #endif
OPCODE(cut ,e),
OPCODE(get_x_var ,xx), OPCODE(get_x_var ,xx),
OPCODE(get_y_var ,yx), OPCODE(get_y_var ,yx),
OPCODE(get_x_val ,xx), OPCODE(get_x_val ,xx),
OPCODE(get_y_val ,yx), OPCODE(get_y_val ,yx),
OPCODE(get_atom ,xc), OPCODE(get_atom ,xc),
OPCODE(get_2atoms ,cc), /* peephole */ OPCODE(get_2atoms ,cc),
OPCODE(get_3atoms ,ccc), /* peephole */ OPCODE(get_3atoms ,ccc),
OPCODE(get_4atoms ,cccc), /* peephole */ OPCODE(get_4atoms ,cccc),
OPCODE(get_5atoms ,ccccc), /* peephole */ OPCODE(get_5atoms ,ccccc),
OPCODE(get_6atoms ,cccccc), /* peephole */ OPCODE(get_6atoms ,cccccc),
OPCODE(get_list ,x),
OPCODE(get_struct ,xfa),
OPCODE(get_float ,xd), OPCODE(get_float ,xd),
OPCODE(get_longint ,xi), OPCODE(get_longint ,xi),
OPCODE(get_bigint ,xc), OPCODE(get_bigint ,xc),
OPCODE(get_dbterm ,xc), OPCODE(get_dbterm ,xc),
OPCODE(get_list ,x), OPCODE(glist_valx ,xx),
OPCODE(get_struct ,xf), OPCODE(glist_valy ,xy),
OPCODE(gl_void_varx ,xx),
OPCODE(gl_void_vary ,xy),
OPCODE(gl_void_valx ,xx),
OPCODE(gl_void_valy ,xy),
OPCODE(unify_x_var ,ox), OPCODE(unify_x_var ,ox),
OPCODE(unify_x_var_write ,ox),
OPCODE(unify_l_x_var ,ox),
OPCODE(unify_l_x_var_write ,ox),
OPCODE(unify_x_var2 ,oxx),
OPCODE(unify_x_var2_write ,oxx),
OPCODE(unify_l_x_var2 ,oxx),
OPCODE(unify_l_x_var2_write ,oxx),
OPCODE(unify_y_var ,oy), OPCODE(unify_y_var ,oy),
OPCODE(unify_y_var_write ,oy),
OPCODE(unify_l_y_var ,oy),
OPCODE(unify_l_y_var_write ,oy),
OPCODE(unify_x_val ,ox), OPCODE(unify_x_val ,ox),
OPCODE(unify_x_val_write ,ox),
OPCODE(unify_l_x_val ,ox),
OPCODE(unify_l_x_val_write ,ox),
OPCODE(unify_y_val ,oy), OPCODE(unify_y_val ,oy),
OPCODE(unify_y_val_write ,oy),
OPCODE(unify_l_y_val ,oy),
OPCODE(unify_l_y_val_write ,oy),
OPCODE(unify_x_loc ,ox),
OPCODE(unify_x_loc_write ,ox),
OPCODE(unify_l_x_loc ,ox),
OPCODE(unify_l_x_loc_write ,ox),
OPCODE(unify_y_loc ,oy),
OPCODE(unify_y_loc_write ,oy),
OPCODE(unify_l_y_loc ,oy),
OPCODE(unify_l_y_loc_write ,oy),
OPCODE(unify_void ,o),
OPCODE(unify_void_write ,o),
OPCODE(unify_l_void ,o),
OPCODE(unify_l_void_write ,o),
OPCODE(unify_n_voids ,os),
OPCODE(unify_n_voids_write ,os),
OPCODE(unify_l_n_voids ,os),
OPCODE(unify_l_n_voids_write ,os),
OPCODE(unify_atom ,oc), OPCODE(unify_atom ,oc),
OPCODE(unify_atom_write ,oc),
OPCODE(unify_l_atom ,oc),
OPCODE(unify_l_atom_write ,oc),
OPCODE(unify_n_atoms ,osc),
OPCODE(unify_n_atoms_write ,osc),
OPCODE(unify_float ,od), OPCODE(unify_float ,od),
OPCODE(unify_float_write ,od),
OPCODE(unify_l_float ,od),
OPCODE(unify_l_float_write ,od),
OPCODE(unify_longint ,oi), OPCODE(unify_longint ,oi),
OPCODE(unify_longint_write ,oi),
OPCODE(unify_l_longint ,oi),
OPCODE(unify_l_longint_write ,oi),
OPCODE(unify_bigint ,oc), OPCODE(unify_bigint ,oc),
OPCODE(unify_l_bigint ,oc),
OPCODE(unify_dbterm ,oc), OPCODE(unify_dbterm ,oc),
OPCODE(unify_l_dbterm ,oc),
OPCODE(unify_list ,o), OPCODE(unify_list ,o),
OPCODE(unify_struct ,of), OPCODE(unify_list_write ,o),
OPCODE(unify_l_list ,o),
OPCODE(unify_l_list_write ,o),
OPCODE(unify_struct ,ofa),
OPCODE(unify_struct_write ,ofa),
OPCODE(unify_l_struc ,ofa),
OPCODE(unify_l_struc_write ,ofa),
OPCODE(put_x_var ,xx), OPCODE(put_x_var ,xx),
OPCODE(put_y_var ,yx), OPCODE(put_y_var ,yx),
OPCODE(put_x_val ,xx), OPCODE(put_x_val ,xx),
OPCODE(put_xx_val ,xxxx),
OPCODE(put_y_val ,yx), OPCODE(put_y_val ,yx),
OPCODE(put_unsafe ,yx), OPCODE(put_unsafe ,yx),
OPCODE(put_xx_val ,xxxx), /* peephole */
OPCODE(put_atom ,xc), OPCODE(put_atom ,xc),
OPCODE(put_float ,xd), OPCODE(put_float ,xd),
OPCODE(put_longint ,xi), OPCODE(put_longint ,xi),
OPCODE(put_list ,x), OPCODE(put_list ,x),
OPCODE(put_struct ,xf), OPCODE(put_struct ,xfa),
OPCODE(write_x_var ,x), OPCODE(write_x_var ,x),
OPCODE(write_void ,e),
OPCODE(write_n_voids ,s),
OPCODE(write_y_var ,y), OPCODE(write_y_var ,y),
OPCODE(write_x_val ,x), OPCODE(write_x_val ,x),
OPCODE(write_x_loc ,x),
OPCODE(write_y_val ,y), OPCODE(write_y_val ,y),
OPCODE(write_y_loc ,y),
OPCODE(write_atom ,c), OPCODE(write_atom ,c),
OPCODE(write_float ,d), OPCODE(write_float ,d),
OPCODE(write_longint ,i), OPCODE(write_longint ,i),
OPCODE(write_n_atoms ,sc),
OPCODE(write_list ,e), OPCODE(write_list ,e),
OPCODE(write_struct ,f), OPCODE(write_l_list ,e),
OPCODE(pop ,e), OPCODE(write_struct ,fa),
OPCODE(pop_n ,s), OPCODE(write_l_struc ,fa),
OPCODE(save_pair_x ,ox),
OPCODE(save_pair_x_write ,ox),
OPCODE(save_pair_y ,oy),
OPCODE(save_pair_y_write ,oy),
OPCODE(save_appl_x ,ox),
OPCODE(save_appl_x_write ,ox),
OPCODE(save_appl_y ,oy),
OPCODE(save_appl_y_write ,oy),
OPCODE(jump ,l), OPCODE(jump ,l),
OPCODE(move_back ,l), OPCODE(move_back ,l),
OPCODE(skip ,l), OPCODE(skip ,l),
OPCODE(either ,sla), OPCODE(either ,sblp),
OPCODE(or_else ,sla), OPCODE(or_else ,sblp),
#ifdef YAPOR OPCODE(pop_n ,s),
OPCODE(or_last ,sla), OPCODE(pop ,e),
#else OPCODE(call_cpred ,sbpp),
OPCODE(or_last ,p), OPCODE(call_usercpred ,sbpp),
#endif /* YAPOR */ OPCODE(call_c_wfail ,sdlp),
#ifdef BEAM OPCODE(try_c ,apFs),
OPCODE(retry_eam ,e), OPCODE(retry_c ,apFs),
OPCODE(run_eam ,os), #ifdef CUT_C
OPCODE(cut_c ,apFs),
#endif #endif
OPCODE(call_cpred ,sla), OPCODE(try_userc ,apFs),
OPCODE(call_usercpred ,sla), OPCODE(retry_userc ,apFs),
OPCODE(call_c_wfail ,sdl), #ifdef CUT_C
OPCODE(call_bfunc_xx ,llxx), OPCODE(cut_userc ,apFs),
OPCODE(call_bfunc_xy ,llxy), #endif
OPCODE(call_bfunc_yx ,llxy), OPCODE(lock_pred ,e),
OPCODE(call_bfunc_yy ,llyy), OPCODE(index_pred ,e),
OPCODE(cut_t ,e), #ifdef THREADS
OPCODE(cut_e ,sla), OPCODE(thread_local ,e),
OPCODE(try_clause ,ld), #endif
OPCODE(expand_index ,e),
OPCODE(expand_clauses ,sssllp),
OPCODE(undef_p ,e),
OPCODE(spy_pred ,e),
OPCODE(try_clause ,apl),
OPCODE(try_clause2 ,l), OPCODE(try_clause2 ,l),
OPCODE(try_clause3 ,l), OPCODE(try_clause3 ,l),
OPCODE(try_clause4 ,l), OPCODE(try_clause4 ,l),
OPCODE(retry ,ld), OPCODE(retry ,apl),
OPCODE(retry2 ,l), OPCODE(retry2 ,l),
OPCODE(retry3 ,l), OPCODE(retry3 ,l),
OPCODE(retry4 ,l), OPCODE(retry4 ,l),
OPCODE(trust ,ld), OPCODE(trust ,apl),
OPCODE(try_in ,l), OPCODE(try_in ,l),
OPCODE(enter_lu_pred ,Ill), OPCODE(enter_lu_pred ,Ills),
OPCODE(try_logical ,lld), OPCODE(try_logical ,aLl),
OPCODE(retry_logical ,lld), OPCODE(retry_logical ,aLl),
OPCODE(trust_logical ,lld), OPCODE(trust_logical ,ILl),
OPCODE(count_retry_logical ,lld),
OPCODE(count_trust_logical ,lld),
OPCODE(profiled_retry_logical ,lld),
OPCODE(profiled_trust_logical ,lld),
OPCODE(jump_if_var ,l),
OPCODE(jump_if_nonvar ,xll),
OPCODE(switch_on_cons ,sssl),
OPCODE(switch_on_type ,llll), OPCODE(switch_on_type ,llll),
OPCODE(switch_list_nl ,ollll), OPCODE(switch_list_nl ,ollll),
OPCODE(switch_on_arg_type ,xllll), OPCODE(switch_on_arg_type ,xllll),
OPCODE(switch_on_sub_arg_type ,sllll), OPCODE(switch_on_sub_arg_type ,sllll),
OPCODE(go_on_cons ,sssl), OPCODE(jump_if_var ,l),
OPCODE(if_cons ,sssl), OPCODE(jump_if_nonvar ,xll),
OPCODE(switch_on_func ,sssl),
OPCODE(go_on_func ,sssl),
OPCODE(if_func ,sssl),
OPCODE(if_not_then ,clll), OPCODE(if_not_then ,clll),
OPCODE(switch_on_func ,sssl),
OPCODE(switch_on_cons ,sssl),
OPCODE(go_on_func ,sssl),
OPCODE(go_on_cons ,sssl),
OPCODE(if_func ,sssl),
OPCODE(if_cons ,sssl),
OPCODE(index_dbref ,e), OPCODE(index_dbref ,e),
OPCODE(index_blob ,e), OPCODE(index_blob ,e),
OPCODE(trust_fail ,e), OPCODE(p_atom_x ,xl),
OPCODE(index_pred ,e), OPCODE(p_atom_y ,yl),
OPCODE(lock_pred ,e), OPCODE(p_atomic_x ,xl),
OPCODE(expand_index ,e), OPCODE(p_atomic_y ,yl),
OPCODE(expand_clauses ,sp), OPCODE(p_integer_x ,xl),
OPCODE(save_b_x ,x), OPCODE(p_integer_y ,yl),
OPCODE(save_b_y ,y), OPCODE(p_nonvar_x ,xl),
OPCODE(commit_b_x ,x), OPCODE(p_nonvar_y ,yl),
OPCODE(commit_b_y ,y), OPCODE(p_number_x ,xl),
OPCODE(undef_p ,e), OPCODE(p_number_y ,xl),
OPCODE(spy_pred ,e), OPCODE(p_var_x ,xl),
OPCODE(spy_or_trymark ,ld), OPCODE(p_var_y ,yl),
OPCODE(unify_void ,o), OPCODE(p_db_ref_x ,xl),
OPCODE(write_void ,e), OPCODE(p_db_ref_y ,yl),
OPCODE(save_pair_x ,ox), OPCODE(p_primitive_x ,xl),
OPCODE(save_pair_y ,oy), OPCODE(p_primitive_y ,yl),
OPCODE(save_appl_x ,ox), OPCODE(p_compound_x ,xl),
OPCODE(save_appl_y ,oy), OPCODE(p_compound_y ,yl),
OPCODE(unify_n_atoms ,osc), OPCODE(p_float_x ,xl),
OPCODE(write_n_atoms ,sc), OPCODE(p_float_y ,yl),
OPCODE(unify_n_voids ,os), OPCODE(p_cut_by_x ,xl),
OPCODE(write_n_voids ,s), OPCODE(p_cut_by_y ,yl),
OPCODE(glist_valx ,xx), /* peephole */
OPCODE(glist_valy ,xy), /* peephole */
OPCODE(fcall ,sla),
OPCODE(dexecute ,pp),
OPCODE(gl_void_varx ,xx), /* peephole */
OPCODE(gl_void_vary ,xy), /* peephole */
OPCODE(gl_void_valx ,xx), /* peephole */
OPCODE(gl_void_valy ,xy), /* peephole */
OPCODE(unify_x_loc ,ox),
OPCODE(unify_y_loc ,oy),
OPCODE(write_x_loc ,ox),
OPCODE(write_y_loc ,oy),
OPCODE(unify_x_var2 ,oxx),
OPCODE(unify_l_struc ,of),
OPCODE(unify_l_list ,o),
OPCODE(write_l_struc ,f),
OPCODE(write_l_list ,e),
OPCODE(unify_l_x_var ,ox),
OPCODE(unify_l_y_var ,oy),
OPCODE(unify_l_x_val ,ox),
OPCODE(unify_l_y_val ,oy),
OPCODE(unify_l_atom ,oc),
OPCODE(unify_l_float ,od),
OPCODE(unify_l_longint ,oi),
OPCODE(unify_l_bigint ,oc),
OPCODE(unify_l_dbterm ,oc),
OPCODE(unify_l_void ,o),
OPCODE(unify_l_n_voids ,os),
OPCODE(unify_l_x_loc ,ox),
OPCODE(unify_l_y_loc ,oy),
OPCODE(unify_l_x_var2 ,oxx),
OPCODE(unify_x_var_write ,ox),
OPCODE(unify_y_var_write ,oy),
OPCODE(unify_x_val_write ,ox),
OPCODE(unify_y_val_write ,oy),
OPCODE(unify_atom_write ,oc),
OPCODE(unify_float_write ,od),
OPCODE(unify_longint_write ,oi),
OPCODE(unify_n_atoms_write ,osc),
OPCODE(unify_list_write ,o),
OPCODE(unify_x_var2_write ,oxx),
OPCODE(unify_struct_write ,of),
OPCODE(unify_void_write ,o),
OPCODE(unify_n_voids_write ,os),
OPCODE(unify_x_loc_write ,ox),
OPCODE(unify_y_loc_write ,oy),
OPCODE(unify_l_x_var_write ,ox),
OPCODE(unify_l_y_var_write ,oy),
OPCODE(unify_l_x_val_write ,ox),
OPCODE(unify_l_y_val_write ,oy),
OPCODE(unify_l_atom_write ,oc),
OPCODE(unify_l_float_write ,od),
OPCODE(unify_l_longint_write ,oi),
OPCODE(unify_l_void_write ,o),
OPCODE(unify_l_n_voids_write ,os),
OPCODE(unify_l_x_loc_write ,ox),
OPCODE(unify_l_y_loc_write ,oy),
OPCODE(unify_l_x_var2_write ,oxx),
OPCODE(unify_l_list_write ,o),
OPCODE(unify_l_struc_write ,of),
OPCODE(save_pair_x_write ,ox),
OPCODE(save_pair_y_write ,oy),
OPCODE(save_appl_x_write ,ox),
OPCODE(save_appl_y_write ,oy),
OPCODE(enter_profiling ,l),
OPCODE(enter_a_profiling ,e),
OPCODE(retry_profiled ,l),
OPCODE(profiled_retry_me ,ld),
OPCODE(profiled_trust_me ,ld),
OPCODE(profiled_retry_and_mark ,ld),
OPCODE(count_call ,l),
OPCODE(count_a_call ,e),
OPCODE(count_retry ,l),
OPCODE(count_retry_me ,ld),
OPCODE(count_trust_me ,ld),
OPCODE(count_retry_and_mark ,ld),
OPCODE(lock_lu ,p),
OPCODE(unlock_lu ,e),
OPCODE(alloc_for_logical_pred ,EC),
OPCODE(unify_idb_term ,e),
OPCODE(copy_idb_term ,e),
#if defined(THREADS)
OPCODE(thread_local ,e),
#endif
#ifdef SFUNC
OPCODE(get_s_f ,),
OPCODE(put_s_f ,),
OPCODE(unify_s_f ,),
OPCODE(write_s_f ,),
OPCODE(unify_s_xvar ,),
OPCODE(unify_s_yvar ,),
OPCODE(write_s_xvar ,),
OPCODE(write_s_yvar ,),
OPCODE(unify_s_xval ,),
OPCODE(unify_s_yval ,),
OPCODE(write_s_xval ,),
OPCODE(write_s_yval ,),
OPCODE(unify_s_a ,),
OPCODE(write_s_a ,),
OPCODE(get_s_end ,),
OPCODE(put_s_end ,),
OPCODE(unify_s_end ,),
OPCODE(write_s_end ,),
#endif /* SFUNC */
OPCODE(p_atom_x ,xF),
OPCODE(p_atom_y ,yF),
OPCODE(p_atomic_x ,xF),
OPCODE(p_atomic_y ,yF),
OPCODE(p_integer_x ,xF),
OPCODE(p_integer_y ,yF),
OPCODE(p_nonvar_x ,xF),
OPCODE(p_nonvar_y ,yF),
OPCODE(p_number_x ,xF),
OPCODE(p_number_y ,yF),
OPCODE(p_var_x ,xF),
OPCODE(p_var_y ,yF),
OPCODE(p_compound_x ,xF),
OPCODE(p_compound_y ,yF),
OPCODE(p_float_x ,xF),
OPCODE(p_float_y ,yF),
OPCODE(p_db_ref_x ,xF),
OPCODE(p_db_ref_y ,yF),
OPCODE(p_cut_by_x ,xF),
OPCODE(p_cut_by_y ,yF),
OPCODE(p_primitive_x ,xF),
OPCODE(p_primitive_y ,yF),
OPCODE(p_equal ,e),
OPCODE(p_dif ,l),
OPCODE(p_eq ,l),
OPCODE(p_functor ,e),
OPCODE(p_plus_vv ,xxx), OPCODE(p_plus_vv ,xxx),
OPCODE(p_plus_vc ,xxc), OPCODE(p_plus_vc ,xxc),
OPCODE(p_plus_y_vv ,yxx), OPCODE(p_plus_y_vv ,yxx),
OPCODE(p_plus_y_vc ,yxc), OPCODE(p_plus_y_vc ,yxc),
OPCODE(p_minus_vv ,xxx), OPCODE(p_minus_vv ,xxx),
OPCODE(p_minus_cv ,xcx), OPCODE(p_minus_cv ,xxc),
OPCODE(p_minus_y_vv ,yxx), OPCODE(p_minus_y_vv ,yxx),
OPCODE(p_minus_y_cv ,ycx), OPCODE(p_minus_y_cv ,yxc),
OPCODE(p_times_vv ,xxx), OPCODE(p_times_vv ,xxx),
OPCODE(p_times_vc ,xxc), OPCODE(p_times_vc ,xxc),
OPCODE(p_times_y_vv ,yxx), OPCODE(p_times_y_vv ,yxx),
OPCODE(p_times_y_vc ,yxc), OPCODE(p_times_y_vc ,yxc),
OPCODE(p_div_vv ,xxx), OPCODE(p_div_vv ,xxx),
OPCODE(p_div_cv ,xcx),
OPCODE(p_div_vc ,xxc), OPCODE(p_div_vc ,xxc),
OPCODE(p_div_cv ,xxc),
OPCODE(p_div_y_vv ,yxx), OPCODE(p_div_y_vv ,yxx),
OPCODE(p_div_y_cv ,ycx),
OPCODE(p_div_y_vc ,yxc), OPCODE(p_div_y_vc ,yxc),
OPCODE(p_div_y_cv ,yxc),
OPCODE(p_and_vv ,xxx), OPCODE(p_and_vv ,xxx),
OPCODE(p_and_vc ,xxc), OPCODE(p_and_vc ,xxc),
OPCODE(p_and_y_vv ,yxx), OPCODE(p_and_y_vv ,yxx),
@ -471,33 +279,102 @@
OPCODE(p_or_y_vv ,yxx), OPCODE(p_or_y_vv ,yxx),
OPCODE(p_or_y_vc ,yxc), OPCODE(p_or_y_vc ,yxc),
OPCODE(p_sll_vv ,xxx), OPCODE(p_sll_vv ,xxx),
OPCODE(p_sll_cv ,xcx),
OPCODE(p_sll_vc ,xxc), OPCODE(p_sll_vc ,xxc),
OPCODE(p_sll_cv ,xxc),
OPCODE(p_sll_y_vv ,yxx), OPCODE(p_sll_y_vv ,yxx),
OPCODE(p_sll_y_cv ,ycx),
OPCODE(p_sll_y_vc ,yxc), OPCODE(p_sll_y_vc ,yxc),
OPCODE(p_slr_vv ,xcx), OPCODE(p_sll_y_cv ,yxc),
OPCODE(p_slr_vv ,xxx),
OPCODE(p_slr_vc ,xxc), OPCODE(p_slr_vc ,xxc),
OPCODE(p_slr_cv ,xcx), OPCODE(p_slr_cv ,xxc),
OPCODE(p_slr_y_vv ,yxx), OPCODE(p_slr_y_vv ,yxx),
OPCODE(p_slr_y_vc ,yxc), OPCODE(p_slr_y_vc ,yxc),
OPCODE(p_slr_y_cv ,ycx), OPCODE(p_slr_y_cv ,yxc),
OPCODE(call_bfunc_xx ,plxxs),
OPCODE(call_bfunc_yx ,plxys),
OPCODE(call_bfunc_xy ,plxys),
OPCODE(call_bfunc_yy ,plyys),
OPCODE(p_equal ,e),
OPCODE(p_dif ,l),
OPCODE(p_eq ,l),
OPCODE(p_arg_vv ,xxx), OPCODE(p_arg_vv ,xxx),
OPCODE(p_arg_cv ,xxc), OPCODE(p_arg_cv ,xxc),
OPCODE(p_arg_y_vv ,yxx), OPCODE(p_arg_y_vv ,yxx),
OPCODE(p_arg_y_cv ,yxc), OPCODE(p_arg_y_cv ,xxc),
OPCODE(p_func2s_vv ,xxx), OPCODE(p_func2s_vv ,xxx),
OPCODE(p_func2s_cv ,xcx), OPCODE(p_func2s_cv ,xxc),
OPCODE(p_func2s_vc ,xxc), OPCODE(p_func2s_vc ,xxc),
OPCODE(p_func2s_y_vv ,xxx), OPCODE(p_func2s_y_vv ,yxx),
OPCODE(p_func2s_y_cv ,xcx), OPCODE(p_func2s_y_cv ,yxc),
OPCODE(p_func2s_y_vc ,xxc), OPCODE(p_func2s_y_vc ,yxc),
OPCODE(p_func2f_xx ,xxx), OPCODE(p_func2f_xx ,xxx),
OPCODE(p_func2f_xy ,xyx), OPCODE(p_func2f_xy ,xxy),
OPCODE(p_func2f_yx ,yxx), OPCODE(p_func2f_yx ,yxx),
OPCODE(p_func2f_yy ,yyx), OPCODE(p_func2f_yy ,yyx),
OPCODE(p_execute ,sla), OPCODE(p_functor ,e),
OPCODE(p_execute2 ,sla), OPCODE(p_execute2 ,sbpp),
OPCODE(p_execute_tail ,e) OPCODE(p_execute ,sbmp),
OPCODE(p_execute_tail ,sbpp),
#ifdef YAPOR
OPCODE(getwork_first_time ,e),
OPCODE(getwork ,apl),
OPCODE(getwork_seq ,apl),
OPCODE(sync ,apl),
#endif
#ifdef TABLING
OPCODE(clause_with_cut ,e),
OPCODE(table_load_answer ,apl),
OPCODE(table_try_answer ,apl),
OPCODE(table_try_single ,apl),
OPCODE(table_try_me ,apl),
OPCODE(table_try ,apl),
OPCODE(table_retry_me ,apl),
OPCODE(table_retry ,apl),
OPCODE(table_trust_me ,apl),
OPCODE(table_trust ,apl),
OPCODE(table_new_answer ,s),
OPCODE(table_answer_resolution ,apl),
OPCODE(table_completion ,apl),
OPCODE(trie_do_null ,e),
OPCODE(trie_try_null ,e),
OPCODE(trie_retry_null ,e),
OPCODE(trie_trust_null ,e),
OPCODE(trie_do_var ,e),
OPCODE(trie_try_var ,e),
OPCODE(trie_retry_var ,e),
OPCODE(trie_trust_var ,e),
OPCODE(trie_do_val ,e),
OPCODE(trie_try_val ,e),
OPCODE(trie_retry_val ,e),
OPCODE(trie_trust_val ,e),
OPCODE(trie_do_atom ,e),
OPCODE(trie_try_atom ,e),
OPCODE(trie_retry_atom ,e),
OPCODE(trie_trust_atom ,e),
OPCODE(trie_do_list ,e),
OPCODE(trie_try_list ,e),
OPCODE(trie_retry_list ,e),
OPCODE(trie_trust_list ,e),
OPCODE(trie_do_struct ,e),
OPCODE(trie_try_struct ,e),
OPCODE(trie_retry_struct ,e),
OPCODE(trie_trust_struct ,e),
OPCODE(trie_do_extension ,e),
OPCODE(trie_try_extension ,e),
OPCODE(trie_retry_extension ,e),
OPCODE(trie_trust_extension ,e),
OPCODE(trie_do_float ,e),
OPCODE(trie_try_float ,e),
OPCODE(trie_retry_float ,e),
OPCODE(trie_trust_float ,e),
OPCODE(trie_do_long ,e),
OPCODE(trie_try_long ,e),
OPCODE(trie_retry_long ,e),
OPCODE(trie_trust_long ,e),
#endif
/* this instruction is hardwired */
#ifdef YAPOR
OPCODE(or_last ,sblp)
#else
OPCODE(or_last ,p)
#endif

173
H/amidefs.h
View File

@ -105,7 +105,7 @@ typedef enum {
#undef OPCODE #undef OPCODE
} op_numbers; } op_numbers;
#define _std_top _p_execute_tail #define _std_top _or_last
/* use similar trick for keeping instruction names */ /* use similar trick for keeping instruction names */
#if defined(ANALYST) || defined(DEBUG) #if defined(ANALYST) || defined(DEBUG)
@ -164,12 +164,20 @@ typedef enum {
The meaning of the symbols in a abstract machine instruction is: The meaning of the symbols in a abstract machine instruction is:
c: constant, is a Term c: constant, is a Term
d: double (functor + unaligned) b: bitmap (CELL *)
d: double (functor + unaligned double)
f: functor
F: Function, CPredicate
i: large integer (functor + long)
l: label, yamop * l: label, yamop *
L: logic upd clause, logic_upd_clause *
m: module, Term
o: opcode, OPCODE
s: small integer, COUNT
x: wam register, wamreg
d: predicate definition d: predicate definition
f: functor
n: small number n: small number
x: argument or temporary register x: argument or temporary register
y: environment slot y: environment slot
@ -232,38 +240,15 @@ typedef struct yami {
CELL next; CELL next;
} d; } d;
struct { struct {
Int ClTrail;
Int ClENV;
Int ClRefs;
struct logic_upd_clause *ClBase; struct logic_upd_clause *ClBase;
#if defined(THREADS) || defined(YAPOR)
struct pred_entry *p;
#endif
CELL next; CELL next;
} EC; } L;
struct { struct {
Functor f; Functor f;
Int a; Int a;
CELL next; CELL next;
} f; } fa;
struct { struct {
Functor f;
CODEADDR l1;
CODEADDR l2;
CELL next;
} fll;
struct {
wamreg x;
struct yami *f;
CELL next;
} fx;
struct {
yslot y;
struct yami *f;
CELL next;
} fy;
struct {
OPCODE opcw;
CELL i[2]; CELL i[2];
CELL next; CELL next;
} i; } i;
@ -272,11 +257,8 @@ typedef struct yami {
struct yami *l1; struct yami *l1;
struct yami *l2; struct yami *l2;
COUNT s; COUNT s;
#if defined(YAPOR) || defined(THREADS)
struct pred_entry *p;
#endif
CELL next; CELL next;
} Ill; } Ills;
struct { struct {
struct yami *l; struct yami *l;
CELL next; CELL next;
@ -288,11 +270,16 @@ typedef struct yami {
#ifdef TABLING #ifdef TABLING
struct table_entry *te; /* pointer to table entry */ struct table_entry *te; /* pointer to table entry */
#endif /* TABLING */ #endif /* TABLING */
COUNT s; Int s;
struct pred_entry *p; struct pred_entry *p;
struct yami *d; struct yami *d;
CELL next; CELL next;
} ld; } apl;
/* The next two instructions are twin: they both correspond to the old ldd.
The first one, aLl, handles try_logical and retry_logical,
Ill handles trust_logical.
They must have the same fields.
*/
struct { struct {
#ifdef YAPOR #ifdef YAPOR
unsigned int or_arg; unsigned int or_arg;
@ -300,16 +287,12 @@ typedef struct yami {
#ifdef TABLING #ifdef TABLING
struct table_entry *te; /* pointer to table entry */ struct table_entry *te; /* pointer to table entry */
#endif /* TABLING */ #endif /* TABLING */
union { /* number of arguments */
/* either number of arguments or */
COUNT s; COUNT s;
/* timestamp it was entered */
struct logic_upd_index *block;
} t;
struct logic_upd_clause *d; struct logic_upd_clause *d;
struct yami *n; struct yami *n;
CELL next; CELL next;
} lld; } aLl;
struct { struct {
#ifdef YAPOR #ifdef YAPOR
unsigned int or_arg; unsigned int or_arg;
@ -317,17 +300,12 @@ typedef struct yami {
#ifdef TABLING #ifdef TABLING
struct table_entry *te; /* pointer to table entry */ struct table_entry *te; /* pointer to table entry */
#endif /* TABLING */ #endif /* TABLING */
COUNT s; /* number of arguments */
struct pred_entry *p; struct logic_upd_index *block;
struct yami *d; struct logic_upd_clause *d;
struct yami *bl; struct yami *n;
CELL next; CELL next;
} ldl; } ILl;
struct {
CODEADDR l;
SMALLUNSGN flags;
CELL next;
} lf;
struct { struct {
#ifdef YAPOR #ifdef YAPOR
unsigned int or_arg; unsigned int or_arg;
@ -335,12 +313,12 @@ typedef struct yami {
#ifdef TABLING #ifdef TABLING
struct table_entry *te; /* pointer to table entry */ struct table_entry *te; /* pointer to table entry */
#endif /* TABLING */ #endif /* TABLING */
COUNT s; Int s;
struct pred_entry *p; struct pred_entry *p;
CPredicate f; CPredicate f;
COUNT extra; COUNT extra;
CELL next; CELL next;
} lds; } apFs;
struct { struct {
struct yami *l1; struct yami *l1;
struct yami *l2; struct yami *l2;
@ -348,20 +326,6 @@ typedef struct yami {
CELL next; CELL next;
} lll; } lll;
struct { struct {
#ifdef YAPOR
unsigned int or_arg;
#endif /* YAPOR */
#ifdef TABLING
struct table_entry *te; /* pointer to table entry */
#endif /* TABLING */
COUNT s;
struct pred_entry *p;
struct yami *l1;
struct yami *l2;
struct yami *l3;
CELL next;
} slll;
struct {
struct yami *l1; struct yami *l1;
struct yami *l2; struct yami *l2;
struct yami *l3; struct yami *l3;
@ -389,25 +353,25 @@ typedef struct yami {
struct yami *f; struct yami *f;
wamreg x1; wamreg x1;
wamreg x2; wamreg x2;
wamreg flags; COUNT flags;
CELL next; CELL next;
} llxx; } plxxs;
struct { struct {
struct pred_entry *p; struct pred_entry *p;
struct yami *f; struct yami *f;
wamreg x; wamreg x;
yslot y; yslot y;
wamreg flags; COUNT flags;
CELL next; CELL next;
} llxy; } plxys;
struct { struct {
struct pred_entry *p; struct pred_entry *p;
struct yami *f; struct yami *f;
wamreg y1; wamreg y1;
yslot y2; yslot y2;
wamreg flags; COUNT flags;
CELL next; CELL next;
} llyy; } plyys;
struct { struct {
OPCODE pop; OPCODE pop;
struct yami *l1; struct yami *l1;
@ -422,7 +386,7 @@ typedef struct yami {
} o; } o;
struct { struct {
OPCODE opcw; OPCODE opcw;
CELL c; Term c;
CELL next; CELL next;
} oc; } oc;
struct { struct {
@ -435,7 +399,7 @@ typedef struct yami {
Functor f; Functor f;
Int a; Int a;
CELL next; CELL next;
} of; } ofa;
struct { struct {
OPCODE opcw; OPCODE opcw;
CELL i[2]; CELL i[2];
@ -481,6 +445,7 @@ typedef struct yami {
COUNT s; COUNT s;
CELL next; CELL next;
} s; } s;
/* format of expand_clauses */
struct { struct {
COUNT s1; COUNT s1;
COUNT s2; COUNT s2;
@ -488,7 +453,7 @@ typedef struct yami {
struct yami *sprev, *snext; struct yami *sprev, *snext;
struct pred_entry *p; struct pred_entry *p;
CELL next; CELL next;
} sp; } sssllp;
struct { struct {
COUNT s; COUNT s;
CELL c; CELL c;
@ -500,21 +465,39 @@ typedef struct yami {
struct yami *l; struct yami *l;
struct pred_entry *p; struct pred_entry *p;
CELL next; CELL next;
} sdl; } sdlp;
/* the next 3 instructions must have same size and have fields in same order! */
/* also check env for yes and trustfail code before making any changes */
struct { struct {
#ifdef YAPOR #ifdef YAPOR
unsigned int or_arg; unsigned int or_arg;
#endif /* YAPOR */ #endif /* YAPOR */
COUNT s; COUNT s;
CELL *bmap; CELL *bmap;
union {
struct yami *l; struct yami *l;
struct pred_entry *p;
Term mod;
} sla_u;
struct pred_entry *p0; struct pred_entry *p0;
CELL next; CELL next;
} sla; /* also check env for yes and trustfail code before making any changes */ } sblp;
struct {
#ifdef YAPOR
unsigned int or_arg;
#endif /* YAPOR */
COUNT s;
CELL *bmap;
struct pred_entry *p;
struct pred_entry *p0;
CELL next;
} sbpp;
struct {
#ifdef YAPOR
unsigned int or_arg;
#endif /* YAPOR */
COUNT s;
CELL *bmap;
Term mod;
struct pred_entry *p0;
CELL next;
} sbmp;
struct { struct {
COUNT s; /* size of table */ COUNT s; /* size of table */
COUNT e; /* live entries */ COUNT e; /* live entries */
@ -541,12 +524,12 @@ typedef struct yami {
Functor f; Functor f;
Int a; Int a;
CELL next; CELL next;
} xf; } xfa;
struct { struct {
wamreg x; wamreg x;
struct yami *F; struct yami *F;
CELL next; CELL next;
} xF; } xl;
struct { struct {
wamreg x; wamreg x;
CELL i[2]; CELL i[2];
@ -578,10 +561,10 @@ typedef struct yami {
} xxxx; } xxxx;
struct { struct {
wamreg x; wamreg x;
Int c;
wamreg xi; wamreg xi;
COUNT c;
CELL next; CELL next;
} xcx, xxc; } xxc;
struct { struct {
wamreg x; wamreg x;
yslot y; yslot y;
@ -589,10 +572,10 @@ typedef struct yami {
} xy; } xy;
struct { struct {
wamreg x; wamreg x;
yslot y2;
wamreg x1; wamreg x1;
yslot y2;
CELL next; CELL next;
} xyx; } xxy;
struct { struct {
yslot y; yslot y;
CELL next; CELL next;
@ -601,7 +584,7 @@ typedef struct yami {
yslot y; yslot y;
struct yami *F; struct yami *F;
CELL next; CELL next;
} yF; } yl;
struct { struct {
yslot y; yslot y;
wamreg x; wamreg x;
@ -626,11 +609,11 @@ typedef struct yami {
CELL next; CELL next;
} yyy; } yyy;
struct { struct {
wamreg xi;
yslot y; yslot y;
Int c; Int c;
wamreg xi;
CELL next; CELL next;
} ycx, yxc; } yxc;
} u; } u;
} yamop; } yamop;
@ -780,12 +763,12 @@ typedef struct choicept {
#endif #endif
#define RealEnvSize (EnvSizeInCells*sizeof(CELL)) #define RealEnvSize (EnvSizeInCells*sizeof(CELL))
#define ENV_Size(cp) (((yamop *)((CODEADDR)(cp) - (CELL)NEXTOP((yamop *)NULL,sla)))->u.sla.s) #define ENV_Size(cp) (((yamop *)((CODEADDR)(cp) - (CELL)NEXTOP((yamop *)NULL,sbpp)))->u.sbpp.s)
#define ENV_ToP(cp) (((yamop *)((CODEADDR)(cp) - (CELL)NEXTOP((yamop *)NULL,sla)))->u.sla.sla_u.p) #define ENV_ToP(cp) (((yamop *)((CODEADDR)(cp) - (CELL)NEXTOP((yamop *)NULL,sbpp)))->u.sla.p)
#define ENV_ToOp(cp) (((yamop *)((CODEADDR)(cp) - (CELL)NEXTOP((yamop *)NULL,sla)))->opc) #define ENV_ToOp(cp) (((yamop *)((CODEADDR)(cp) - (CELL)NEXTOP((yamop *)NULL,sbpp)))->opc)
#define EnvSize(cp) ((-ENV_Size(cp))/(OPREG)sizeof(CELL)) #define EnvSize(cp) ((-ENV_Size(cp))/(OPREG)sizeof(CELL))
#define EnvBMap(p) (((yamop *)((CODEADDR)(p) - (CELL)NEXTOP((yamop *)NULL,sla)))->u.sla.bmap) #define EnvBMap(p) (((yamop *)((CODEADDR)(p) - (CELL)NEXTOP((yamop *)NULL,sbpp)))->u.sbpp.bmap)
#define EnvPreg(p) (((yamop *)((CODEADDR)(p) - (CELL)NEXTOP((yamop *)NULL,sla)))->u.sla.p0) #define EnvPreg(p) (((yamop *)((CODEADDR)(p) - (CELL)NEXTOP((yamop *)NULL,sbpp)))->u.sbpp.p0)
/* access to instructions */ /* access to instructions */

4
H/clause.h
View File

@ -33,7 +33,7 @@ typedef union CONSULT_OBJ {
#define ASSEMBLING_INDEX 1 #define ASSEMBLING_INDEX 1
#define ASSEMBLING_EINDEX 2 #define ASSEMBLING_EINDEX 2
#define NextDynamicClause(X) (((yamop *)X)->u.ld.d) #define NextDynamicClause(X) (((yamop *)X)->u.apl.d)
#define PredFirstClause 0 #define PredFirstClause 0
#define PredMiddleClause 1 #define PredMiddleClause 1
@ -197,7 +197,7 @@ typedef struct dbterm_list {
/* amasm.c */ /* amasm.c */
wamreg STD_PROTO(Yap_emit_x,(CELL)); wamreg STD_PROTO(Yap_emit_x,(CELL));
wamreg STD_PROTO(Yap_compile_cmp_flags,(PredEntry *)); COUNT STD_PROTO(Yap_compile_cmp_flags,(PredEntry *));
void STD_PROTO(Yap_InitComma,(void)); void STD_PROTO(Yap_InitComma,(void));
/* cdmgr.c */ /* cdmgr.c */

232
H/rclause.h
View File

@ -192,30 +192,30 @@ restore_opcodes(yamop *pc)
case _table_answer_resolution: case _table_answer_resolution:
case _table_completion: case _table_completion:
#endif /* TABLING */ #endif /* TABLING */
pc->u.ld.p = PtoPredAdjust(pc->u.ld.p); pc->u.apl.p = PtoPredAdjust(pc->u.apl.p);
pc->u.ld.d = PtoOpAdjust(pc->u.ld.d); pc->u.apl.d = PtoOpAdjust(pc->u.apl.d);
pc = NEXTOP(pc,ld); pc = NEXTOP(pc,apl);
break; break;
case _try_logical: case _try_logical:
case _retry_logical: case _retry_logical:
case _count_retry_logical: case _count_retry_logical:
case _profiled_retry_logical: case _profiled_retry_logical:
pc->u.lld.n = PtoOpAdjust(pc->u.lld.n); pc->u.aLl.n = PtoOpAdjust(pc->u.aLl.n);
pc->u.lld.d = PtoLUClauseAdjust(pc->u.lld.d); pc->u.aLl.d = PtoLUClauseAdjust(pc->u.aLl.d);
pc = pc->u.lld.n; pc = pc->u.aLl.n;
break; break;
case _trust_logical: case _trust_logical:
case _count_trust_logical: case _count_trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
pc->u.lld.n = PtoOpAdjust(pc->u.lld.n); pc->u.ILl.n = PtoOpAdjust(pc->u.ILl.n);
pc->u.lld.d = PtoLUClauseAdjust(pc->u.lld.d); pc->u.ILl.d = PtoLUClauseAdjust(pc->u.ILl.d);
pc->u.lld.t.block = PtoLUIndexAdjust(pc->u.lld.t.block); pc->u.ILl.block = PtoLUIndexAdjust(pc->u.ILl.block);
return; return;
case _enter_lu_pred: case _enter_lu_pred:
pc->u.Ill.I = (LogUpdIndex *)PtoOpAdjust((yamop *)(pc->u.Ill.I)); pc->u.Ills.I = (LogUpdIndex *)PtoOpAdjust((yamop *)(pc->u.Ills.I));
pc->u.Ill.l1 = PtoOpAdjust(pc->u.Ill.l1); pc->u.Ills.l1 = PtoOpAdjust(pc->u.Ills.l1);
pc->u.Ill.l2 = PtoOpAdjust(pc->u.Ill.l2); pc->u.Ills.l2 = PtoOpAdjust(pc->u.Ills.l2);
pc = pc->u.Ill.l1; pc = pc->u.Ills.l1;
break; break;
/* instructions type p */ /* instructions type p */
#if !defined(YAPOR) #if !defined(YAPOR)
@ -259,13 +259,10 @@ restore_opcodes(yamop *pc)
pc->u.xll.x = XAdjust(pc->u.xll.x); pc->u.xll.x = XAdjust(pc->u.xll.x);
pc = NEXTOP(pc,xll); pc = NEXTOP(pc,xll);
break; break;
/* instructions type EC */ /* instructions type L */
case _alloc_for_logical_pred: case _alloc_for_logical_pred:
pc->u.EC.ClBase = (struct logic_upd_clause *)PtoOpAdjust((yamop *)pc->u.EC.ClBase); pc->u.L.ClBase = (struct logic_upd_clause *)PtoOpAdjust((yamop *)pc->u.L.ClBase);
#if defined(THREADS) || defined(YAPOR) pc = NEXTOP(pc,L);
pc->u.EC.p = PtoPredAdjust(pc->u.EC.p);
#endif
pc = NEXTOP(pc,EC);
break; break;
/* instructions type e */ /* instructions type e */
case _unify_idb_term: case _unify_idb_term:
@ -358,7 +355,7 @@ restore_opcodes(yamop *pc)
pc->u.x.x = XAdjust(pc->u.x.x); pc->u.x.x = XAdjust(pc->u.x.x);
pc = NEXTOP(pc,x); pc = NEXTOP(pc,x);
break; break;
/* instructions type xF */ /* instructions type xl */
case _p_atom_x: case _p_atom_x:
case _p_atomic_x: case _p_atomic_x:
case _p_integer_x: case _p_integer_x:
@ -370,9 +367,9 @@ restore_opcodes(yamop *pc)
case _p_compound_x: case _p_compound_x:
case _p_float_x: case _p_float_x:
case _p_cut_by_x: case _p_cut_by_x:
pc->u.xF.x = XAdjust(pc->u.xF.x); pc->u.xl.x = XAdjust(pc->u.xl.x);
pc->u.xF.F = PtoOpAdjust(pc->u.xF.F); pc->u.xl.F = PtoOpAdjust(pc->u.xl.F);
pc = NEXTOP(pc,xF); pc = NEXTOP(pc,xl);
break; break;
case _expand_clauses: case _expand_clauses:
Yap_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
@ -387,7 +384,7 @@ restore_opcodes(yamop *pc)
pc->u.y.y = YAdjust(pc->u.y.y); pc->u.y.y = YAdjust(pc->u.y.y);
pc = NEXTOP(pc,y); pc = NEXTOP(pc,y);
break; break;
/* instructions type yF */ /* instructions type yl */
case _p_atom_y: case _p_atom_y:
case _p_atomic_y: case _p_atomic_y:
case _p_integer_y: case _p_integer_y:
@ -399,57 +396,61 @@ restore_opcodes(yamop *pc)
case _p_compound_y: case _p_compound_y:
case _p_float_y: case _p_float_y:
case _p_cut_by_y: case _p_cut_by_y:
pc->u.yF.y = YAdjust(pc->u.yF.y); pc->u.yl.y = YAdjust(pc->u.yl.y);
pc->u.yF.F = PtoOpAdjust(pc->u.yF.F); pc->u.yl.F = PtoOpAdjust(pc->u.yl.F);
pc = NEXTOP(pc,yF); pc = NEXTOP(pc,yl);
break; break;
/* instructions type sla */ /* instructions type sbpp */
case _p_execute_tail:
case _p_execute: case _p_execute:
if (pc->u.sbmp.mod != 0) {
pc->u.sbmp.mod = AtomTermAdjust(pc->u.sbmp.mod);
}
pc->u.sbmp.p0 = PtoPredAdjust(pc->u.sbmp.p0);
if (pc->u.sbmp.bmap != NULL) {
pc->u.sbmp.bmap = CellPtoHeapAdjust(pc->u.sbmp.bmap);
}
pc = NEXTOP(pc,sbmp);
break;
case _p_execute_tail:
case _p_execute2: case _p_execute2:
if (pc->u.sla.sla_u.mod != 0) { pc->u.sbpp.p = PtoPredAdjust(pc->u.sbpp.p);
if (IsAtomTerm(pc->u.sla.sla_u.mod)) pc->u.sbpp.p0 = PtoPredAdjust(pc->u.sbpp.p0);
pc->u.sla.sla_u.mod = AtomTermAdjust(pc->u.sla.sla_u.mod); if (pc->u.sbpp.bmap != NULL) {
else pc->u.sbpp.bmap = CellPtoHeapAdjust(pc->u.sbpp.bmap);
pc->u.sla.sla_u.p = PtoPredAdjust(pc->u.sla.sla_u.p);
} }
pc->u.sla.p0 = PtoPredAdjust(pc->u.sla.p0); pc = NEXTOP(pc,sbpp);
if (pc->u.sla.bmap != NULL) {
pc->u.sla.bmap = CellPtoHeapAdjust(pc->u.sla.bmap);
}
pc = NEXTOP(pc,sla);
break; break;
case _fcall: case _fcall:
case _call: case _call:
#ifdef YAPOR #ifdef YAPOR
case _or_last: case _or_last:
#endif #endif
pc->u.sla.sla_u.p = PtoPredAdjust(pc->u.sla.sla_u.p); pc->u.sbpp.p = PtoPredAdjust(pc->u.sbpp.p);
if (pc->u.sla.bmap != NULL) { if (pc->u.sbpp.bmap != NULL) {
pc->u.sla.bmap = CellPtoHeapAdjust(pc->u.sla.bmap); pc->u.sbpp.bmap = CellPtoHeapAdjust(pc->u.sbpp.bmap);
} }
pc->u.sla.p0 = PtoPredAdjust(pc->u.sla.p0); pc->u.sbpp.p0 = PtoPredAdjust(pc->u.sbpp.p0);
pc = NEXTOP(pc,sla); pc = NEXTOP(pc,sbpp);
break; break;
/* instructions type sla, but for disjunctions */ /* instructions type sbpp, but for disjunctions */
case _either: case _either:
case _or_else: case _or_else:
if (pc->u.sla.bmap != NULL) { if (pc->u.sblp.bmap != NULL) {
pc->u.sla.bmap = CellPtoHeapAdjust(pc->u.sla.bmap); pc->u.sblp.bmap = CellPtoHeapAdjust(pc->u.sblp.bmap);
} }
pc->u.sla.sla_u.l = PtoOpAdjust(pc->u.sla.sla_u.l); pc->u.sblp.l = PtoOpAdjust(pc->u.sblp.l);
pc->u.sla.p0 = PtoPredAdjust(pc->u.sla.p0); pc->u.sblp.p0 = PtoPredAdjust(pc->u.sblp.p0);
pc = NEXTOP(pc,sla); pc = NEXTOP(pc,sblp);
break; break;
/* instructions type sla, but for functions */ /* instructions type sbpp, but for functions */
case _call_cpred: case _call_cpred:
case _call_usercpred: case _call_usercpred:
pc->u.sla.sla_u.p = PtoPredAdjust(pc->u.sla.sla_u.p); pc->u.sbpp.p = PtoPredAdjust(pc->u.sbpp.p);
pc->u.sla.p0 = PtoPredAdjust(pc->u.sla.p0); pc->u.sbpp.p0 = PtoPredAdjust(pc->u.sbpp.p0);
if (pc->u.sla.bmap != NULL) { if (pc->u.sbpp.bmap != NULL) {
pc->u.sla.bmap = CellPtoHeapAdjust(pc->u.sla.bmap); pc->u.sbpp.bmap = CellPtoHeapAdjust(pc->u.sbpp.bmap);
} }
pc = NEXTOP(pc,sla); pc = NEXTOP(pc,sbpp);
break; break;
/* instructions type xx */ /* instructions type xx */
case _get_x_var: case _get_x_var:
@ -682,12 +683,12 @@ restore_opcodes(yamop *pc)
} }
pc = NEXTOP(pc,cccccc); pc = NEXTOP(pc,cccccc);
break; break;
/* instructions type xf */ /* instructions type xfa */
case _get_struct: case _get_struct:
case _put_struct: case _put_struct:
pc->u.xf.x = XAdjust(pc->u.xf.x); pc->u.xfa.x = XAdjust(pc->u.xfa.x);
pc->u.xf.f = FuncAdjust(pc->u.xf.f); pc->u.xfa.f = FuncAdjust(pc->u.xfa.f);
pc = NEXTOP(pc,xf); pc = NEXTOP(pc,xfa);
break; break;
/* instructions type xy */ /* instructions type xy */
case _glist_valy: case _glist_valy:
@ -819,14 +820,14 @@ restore_opcodes(yamop *pc)
} }
pc = NEXTOP(pc,osc); pc = NEXTOP(pc,osc);
break; break;
/* instructions type of */ /* instructions type ofa */
case _unify_struct_write: case _unify_struct_write:
case _unify_struct: case _unify_struct:
case _unify_l_struc_write: case _unify_l_struc_write:
case _unify_l_struc: case _unify_l_struc:
pc->u.of.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.of.opcw)); pc->u.ofa.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.ofa.opcw));
pc->u.of.f = FuncAdjust(pc->u.of.f); pc->u.ofa.f = FuncAdjust(pc->u.ofa.f);
pc = NEXTOP(pc,of); pc = NEXTOP(pc,ofa);
break; break;
/* instructions type s */ /* instructions type s */
case _write_n_voids: case _write_n_voids:
@ -872,29 +873,29 @@ restore_opcodes(yamop *pc)
/* instructions type f */ /* instructions type f */
case _write_struct: case _write_struct:
case _write_l_struc: case _write_l_struc:
pc->u.f.f = FuncAdjust(pc->u.f.f); pc->u.fa.f = FuncAdjust(pc->u.fa.f);
pc = NEXTOP(pc,f); pc = NEXTOP(pc,fa);
break; break;
/* instructions type sdl */ /* instructions type sdlp */
case _call_c_wfail: case _call_c_wfail:
pc->u.sdl.p = PtoPredAdjust(pc->u.sdl.p); pc->u.sdlp.p = PtoPredAdjust(pc->u.sdlp.p);
pc->u.sdl.l = PtoOpAdjust(pc->u.sdl.l); pc->u.sdlp.l = PtoOpAdjust(pc->u.sdlp.l);
pc = NEXTOP(pc,sdl); pc = NEXTOP(pc,sdlp);
break; break;
/* instructions type lds */ /* instructions type apFs */
case _try_c: case _try_c:
case _try_userc: case _try_userc:
/* don't need to do no nothing here, initstaff will do it for us /* don't need to do no nothing here, initstaff will do it for us
*/ */
pc->u.lds.p = PtoPredAdjust(pc->u.lds.p); pc->u.apFs.p = PtoPredAdjust(pc->u.apFs.p);
pc = NEXTOP(pc,lds); pc = NEXTOP(pc,apFs);
break; break;
case _retry_c: case _retry_c:
case _retry_userc: case _retry_userc:
/* don't need to do no nothing here, initstaff will do it for us /* don't need to do no nothing here, initstaff will do it for us
pc->u.lds.d = CCodeAdjust(pc->u.lds.d); */ pc->u.apFs.d = CCodeAdjust(pc->u.apFs.d); */
pc->u.lds.p = PtoPredAdjust(pc->u.lds.p); pc->u.apFs.p = PtoPredAdjust(pc->u.apFs.p);
pc = NEXTOP(pc,lds); pc = NEXTOP(pc,apFs);
break; break;
#ifdef CUT_C #ifdef CUT_C
case _cut_c: case _cut_c:
@ -1095,23 +1096,23 @@ restore_opcodes(yamop *pc)
case _p_sll_cv: case _p_sll_cv:
case _p_slr_cv: case _p_slr_cv:
case _p_arg_cv: case _p_arg_cv:
pc->u.xcx.x = XAdjust(pc->u.xcx.x); pc->u.xxc.x = XAdjust(pc->u.xxc.x);
pc->u.xcx.xi = XAdjust(pc->u.xcx.xi); pc->u.xxc.xi = XAdjust(pc->u.xxc.xi);
pc = NEXTOP(pc,xcx); pc = NEXTOP(pc,xxc);
break; break;
case _p_func2s_cv: case _p_func2s_cv:
pc->u.xcx.x = XAdjust(pc->u.xcx.x); pc->u.xxc.x = XAdjust(pc->u.xxc.x);
if (IsAtomTerm(pc->u.xcx.c)) if (IsAtomTerm(pc->u.xxc.c))
pc->u.xcx.c = AtomTermAdjust(pc->u.xcx.c); pc->u.xxc.c = AtomTermAdjust(pc->u.xxc.c);
pc->u.xcx.xi = XAdjust(pc->u.xcx.xi); pc->u.xxc.xi = XAdjust(pc->u.xxc.xi);
pc = NEXTOP(pc,xcx); pc = NEXTOP(pc,xxc);
break; break;
/* instructions type xyx */ /* instructions type xxy */
case _p_func2f_xy: case _p_func2f_xy:
pc->u.xyx.x = XAdjust(pc->u.xyx.x); pc->u.xxy.x = XAdjust(pc->u.xxy.x);
pc->u.xyx.x1 = XAdjust(pc->u.xyx.x1); pc->u.xxy.x1 = XAdjust(pc->u.xxy.x1);
pc->u.xyx.y2 = YAdjust(pc->u.xyx.y2); pc->u.xxy.y2 = YAdjust(pc->u.xxy.y2);
pc = NEXTOP(pc,xyx); pc = NEXTOP(pc,xxy);
break; break;
/* instructions type yxx */ /* instructions type yxx */
case _p_plus_y_vv: case _p_plus_y_vv:
@ -1152,45 +1153,44 @@ restore_opcodes(yamop *pc)
pc->u.yxc.xi = XAdjust(pc->u.yxc.xi); pc->u.yxc.xi = XAdjust(pc->u.yxc.xi);
pc = NEXTOP(pc,yxc); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type ycx */ /* instructions type yxc */
case _p_sll_y_cv: case _p_sll_y_cv:
case _p_slr_y_cv: case _p_slr_y_cv:
case _p_arg_y_cv: case _p_arg_y_cv:
pc->u.ycx.y = YAdjust(pc->u.ycx.y); pc->u.yxc.y = YAdjust(pc->u.yxc.y);
pc->u.ycx.xi = XAdjust(pc->u.ycx.xi); pc->u.yxc.xi = XAdjust(pc->u.yxc.xi);
pc = NEXTOP(pc,ycx); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type ycx */
case _p_func2s_y_cv: case _p_func2s_y_cv:
pc->u.ycx.y = YAdjust(pc->u.ycx.y); pc->u.yxc.y = YAdjust(pc->u.yxc.y);
if (IsAtomTerm(pc->u.ycx.c)) if (IsAtomTerm(pc->u.yxc.c))
pc->u.ycx.c = AtomTermAdjust(pc->u.ycx.c); pc->u.yxc.c = AtomTermAdjust(pc->u.yxc.c);
pc->u.ycx.xi = XAdjust(pc->u.ycx.xi); pc->u.yxc.xi = XAdjust(pc->u.yxc.xi);
pc = NEXTOP(pc,ycx); pc = NEXTOP(pc,yxc);
break; break;
/* instructions type llxx */ /* instructions type plxxs */
case _call_bfunc_xx: case _call_bfunc_xx:
pc->u.llxx.p = PtoPredAdjust(pc->u.llxx.p); pc->u.plxxs.p = PtoPredAdjust(pc->u.plxxs.p);
pc->u.llxx.f = PtoOpAdjust(pc->u.llxx.f); pc->u.plxxs.f = PtoOpAdjust(pc->u.plxxs.f);
pc->u.llxx.x1 = XAdjust(pc->u.llxx.x1); pc->u.plxxs.x1 = XAdjust(pc->u.plxxs.x1);
pc->u.llxx.x2 = XAdjust(pc->u.llxx.x2); pc->u.plxxs.x2 = XAdjust(pc->u.plxxs.x2);
pc = NEXTOP(pc,llxx); pc = NEXTOP(pc,plxxs);
break; break;
/* instructions type llxy */ /* instructions type plxys */
case _call_bfunc_yx: case _call_bfunc_yx:
case _call_bfunc_xy: case _call_bfunc_xy:
pc->u.llxy.p = PtoPredAdjust(pc->u.llxy.p); pc->u.plxys.p = PtoPredAdjust(pc->u.plxys.p);
pc->u.llxy.f = PtoOpAdjust(pc->u.llxy.f); pc->u.plxys.f = PtoOpAdjust(pc->u.plxys.f);
pc->u.llxy.x = XAdjust(pc->u.llxy.x); pc->u.plxys.x = XAdjust(pc->u.plxys.x);
pc->u.llxy.y = YAdjust(pc->u.llxy.y); pc->u.plxys.y = YAdjust(pc->u.plxys.y);
pc = NEXTOP(pc,llxy); pc = NEXTOP(pc,plxys);
break; break;
case _call_bfunc_yy: case _call_bfunc_yy:
pc->u.llyy.p = PtoPredAdjust(pc->u.llyy.p); pc->u.plyys.p = PtoPredAdjust(pc->u.plyys.p);
pc->u.llyy.f = PtoOpAdjust(pc->u.llxy.f); pc->u.plyys.f = PtoOpAdjust(pc->u.plyys.f);
pc->u.llyy.y1 = YAdjust(pc->u.llyy.y1); pc->u.plyys.y1 = YAdjust(pc->u.plyys.y1);
pc->u.llyy.y2 = YAdjust(pc->u.llyy.y2); pc->u.plyys.y2 = YAdjust(pc->u.plyys.y2);
pc = NEXTOP(pc,llyy); pc = NEXTOP(pc,plyys);
break; break;
} }
} while (TRUE); } while (TRUE);

22
H/rheap.h
View File

@ -244,17 +244,17 @@ static char SccsId[] = "@(#)rheap.c 1.3 3/15/90";
static void static void
do_clean_susp_clauses(yamop *ipc) { do_clean_susp_clauses(yamop *ipc) {
COUNT i; COUNT i;
yamop **st = (yamop **)NEXTOP(ipc,sp); yamop **st = (yamop **)NEXTOP(ipc,sssllp);
ipc->opc = Yap_opcode(_expand_clauses); ipc->opc = Yap_opcode(_expand_clauses);
ipc->u.sp.p = PtoPredAdjust(ipc->u.sp.p); ipc->u.sssllp.p = PtoPredAdjust(ipc->u.sssllp.p);
if (ipc->u.sp.sprev) { if (ipc->u.sssllp.sprev) {
ipc->u.sp.sprev = PtoOpAdjust(ipc->u.sp.sprev); ipc->u.sssllp.sprev = PtoOpAdjust(ipc->u.sssllp.sprev);
} }
if (ipc->u.sp.snext) { if (ipc->u.sssllp.snext) {
ipc->u.sp.snext = PtoOpAdjust(ipc->u.sp.snext); ipc->u.sssllp.snext = PtoOpAdjust(ipc->u.sssllp.snext);
} }
for (i = 0; i < ipc->u.sp.s1; i++, st++) { for (i = 0; i < ipc->u.sssllp.s1; i++, st++) {
if (*st) { if (*st) {
*st = PtoOpAdjust(*st); *st = PtoOpAdjust(*st);
} }
@ -516,7 +516,7 @@ restore_codes(void)
yamop *ptr = Yap_heap_regs->expand_clauses_first; yamop *ptr = Yap_heap_regs->expand_clauses_first;
while (ptr) { while (ptr) {
do_clean_susp_clauses(ptr); do_clean_susp_clauses(ptr);
ptr = ptr->u.sp.snext; ptr = ptr->u.sssllp.snext;
} }
} }
Yap_heap_regs->failcode->opc = Yap_opcode(_op_fail); Yap_heap_regs->failcode->opc = Yap_opcode(_op_fail);
@ -542,9 +542,9 @@ restore_codes(void)
INIT_YAMOP_LTT(&(Yap_heap_regs->nocode), 1); INIT_YAMOP_LTT(&(Yap_heap_regs->nocode), 1);
INIT_YAMOP_LTT(&(Yap_heap_regs->rtrycode), 1); INIT_YAMOP_LTT(&(Yap_heap_regs->rtrycode), 1);
#endif /* YAPOR */ #endif /* YAPOR */
if (((yamop *)(&Yap_heap_regs->rtrycode))->u.ld.d != NIL) if (((yamop *)(&Yap_heap_regs->rtrycode))->u.apl.d != NIL)
((yamop *)(&Yap_heap_regs->rtrycode))->u.ld.d = ((yamop *)(&Yap_heap_regs->rtrycode))->u.apl.d =
PtoOpAdjust(((yamop *)(&Yap_heap_regs->rtrycode))->u.ld.d); PtoOpAdjust(((yamop *)(&Yap_heap_regs->rtrycode))->u.apl.d);
{ {
int arity; int arity;
arity = Yap_heap_regs->clausecode->arity; arity = Yap_heap_regs->clausecode->arity;

8
OPTYap/or.insts.i
View File

@ -41,7 +41,7 @@
PBOp(getwork,ld) PBOp(getwork,apl)
#ifdef TABLING #ifdef TABLING
if (DepFr_leader_cp(LOCAL_top_dep_fr) == LOCAL_top_cp) { if (DepFr_leader_cp(LOCAL_top_dep_fr) == LOCAL_top_cp) {
/* the current top node is a leader node with consumer nodes below */ /* the current top node is a leader node with consumer nodes below */
@ -93,7 +93,7 @@
/* The idea is to check whether we are the last worker in the node. /* The idea is to check whether we are the last worker in the node.
If we are, we can go ahead, otherwise we should call the scheduler. */ If we are, we can go ahead, otherwise we should call the scheduler. */
PBOp(getwork_seq,ld) PBOp(getwork_seq,apl)
LOCK_OR_FRAME(LOCAL_top_or_fr); LOCK_OR_FRAME(LOCAL_top_or_fr);
if (OrFr_alternative(LOCAL_top_or_fr) && if (OrFr_alternative(LOCAL_top_or_fr) &&
BITMAP_alone(OrFr_members(LOCAL_top_or_fr), worker_id)) { BITMAP_alone(OrFr_members(LOCAL_top_or_fr), worker_id)) {
@ -108,9 +108,9 @@
PBOp(sync,ld) PBOp(sync,apl)
CUT_wait_leftmost(); CUT_wait_leftmost();
PREG = NEXTOP(PREG, ld); PREG = NEXTOP(PREG, apl);
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
GONext(); GONext();
ENDPBOp(); ENDPBOp();

18
OPTYap/or.macros.h
View File

@ -75,16 +75,16 @@ STD_PROTO(static inline qg_sol_fr_ptr CUT_prune_solution_frames, (qg_sol_fr_ptr,
#define YAMOP_LTT_BITS OOOOPPS!!! Unknown Integer Sizeof #define YAMOP_LTT_BITS OOOOPPS!!! Unknown Integer Sizeof
#endif /* SIZEOF_INT */ #endif /* SIZEOF_INT */
#define YAMOP_OR_ARG(INST) ((INST)->u.ld.or_arg) #define YAMOP_OR_ARG(INST) ((INST)->u.apl.or_arg)
#define YAMOP_LTT(INST) (((INST)->u.ld.or_arg) & YAMOP_LTT_BITS) #define YAMOP_LTT(INST) (((INST)->u.apl.or_arg) & YAMOP_LTT_BITS)
#define YAMOP_SEQ(INST) (((INST)->u.ld.or_arg) & YAMOP_SEQ_FLAG) #define YAMOP_SEQ(INST) (((INST)->u.apl.or_arg) & YAMOP_SEQ_FLAG)
#define YAMOP_CUT(INST) (((INST)->u.ld.or_arg) & YAMOP_CUT_FLAG) #define YAMOP_CUT(INST) (((INST)->u.apl.or_arg) & YAMOP_CUT_FLAG)
#define YAMOP_FLAGS(INST) (((INST)->u.ld.or_arg) & YAMOP_FLAGS_BITS) #define YAMOP_FLAGS(INST) (((INST)->u.apl.or_arg) & YAMOP_FLAGS_BITS)
#define INIT_YAMOP_LTT(INST, LTT) (INST)->u.ld.or_arg = LTT #define INIT_YAMOP_LTT(INST, LTT) (INST)->u.apl.or_arg = LTT
#define PUT_YAMOP_LTT(INST, LTT) (INST)->u.ld.or_arg = YAMOP_FLAGS(INST) | (LTT) #define PUT_YAMOP_LTT(INST, LTT) (INST)->u.apl.or_arg = YAMOP_FLAGS(INST) | (LTT)
#define PUT_YAMOP_SEQ(INST) (INST)->u.ld.or_arg |= YAMOP_SEQ_FLAG #define PUT_YAMOP_SEQ(INST) (INST)->u.apl.or_arg |= YAMOP_SEQ_FLAG
#define PUT_YAMOP_CUT(INST) (INST)->u.ld.or_arg |= YAMOP_CUT_FLAG #define PUT_YAMOP_CUT(INST) (INST)->u.apl.or_arg |= YAMOP_CUT_FLAG
#define BRANCH(WORKER, DEPTH) GLOBAL_branch(WORKER, DEPTH) #define BRANCH(WORKER, DEPTH) GLOBAL_branch(WORKER, DEPTH)
#define BRANCH_LTT(WORKER, DEPTH) (BRANCH(WORKER, DEPTH) & YAMOP_LTT_BITS) #define BRANCH_LTT(WORKER, DEPTH) (BRANCH(WORKER, DEPTH) & YAMOP_LTT_BITS)

74
OPTYap/tab.insts.i
View File

@ -272,7 +272,7 @@
PBOp(table_load_answer, ld) PBOp(table_load_answer, apl)
CELL *subs_ptr; CELL *subs_ptr;
ans_node_ptr ans_node; ans_node_ptr ans_node;
@ -299,7 +299,7 @@
PBOp(table_try_answer, ld) PBOp(table_try_answer, apl)
#ifdef INCOMPLETE_TABLING #ifdef INCOMPLETE_TABLING
sg_fr_ptr sg_fr; sg_fr_ptr sg_fr;
ans_node_ptr ans_node; ans_node_ptr ans_node;
@ -330,16 +330,16 @@
PREG = SgFr_code(sg_fr); PREG = SgFr_code(sg_fr);
if (PREG->opc == Yap_opcode(_table_try)) { if (PREG->opc == Yap_opcode(_table_try)) {
/* table_try */ /* table_try */
code_ap = NEXTOP(PREG,ld); code_ap = NEXTOP(PREG,apl);
PREG = PREG->u.ld.d; PREG = PREG->u.apl.d;
} else if (PREG->opc == Yap_opcode(_table_try_single)) { } else if (PREG->opc == Yap_opcode(_table_try_single)) {
/* table_try_single */ /* table_try_single */
code_ap = COMPLETION; code_ap = COMPLETION;
PREG = PREG->u.ld.d; PREG = PREG->u.apl.d;
} else { } else {
/* table_try_me */ /* table_try_me */
code_ap = PREG->u.ld.d; code_ap = PREG->u.apl.d;
PREG = NEXTOP(PREG,ld); PREG = NEXTOP(PREG,apl);
} }
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
restore_generator_node(SgFr_arity(sg_fr), code_ap); restore_generator_node(SgFr_arity(sg_fr), code_ap);
@ -350,7 +350,7 @@
GONext(); GONext();
} }
#else #else
PREG = PREG->u.ld.d; PREG = PREG->u.apl.d;
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
GONext(); GONext();
#endif /* INCOMPLETE_TABLING */ #endif /* INCOMPLETE_TABLING */
@ -358,12 +358,12 @@
PBOp(table_try_single, ld) PBOp(table_try_single, apl)
tab_ent_ptr tab_ent; tab_ent_ptr tab_ent;
sg_fr_ptr sg_fr; sg_fr_ptr sg_fr;
check_trail(TR); check_trail(TR);
tab_ent = PREG->u.ld.te; tab_ent = PREG->u.apl.te;
YENV2MEM; YENV2MEM;
sg_fr = subgoal_search(PREG, YENV_ADDRESS); sg_fr = subgoal_search(PREG, YENV_ADDRESS);
MEM2YENV; MEM2YENV;
@ -372,8 +372,8 @@
/* subgoal new */ /* subgoal new */
init_subgoal_frame(sg_fr); init_subgoal_frame(sg_fr);
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
store_generator_node(tab_ent, sg_fr, PREG->u.ld.s, COMPLETION); store_generator_node(tab_ent, sg_fr, PREG->u.apl.s, COMPLETION);
PREG = PREG->u.ld.d; /* should work also with PREG = NEXTOP(PREG,ld); */ PREG = PREG->u.apl.d; /* should work also with PREG = NEXTOP(PREG,apl); */
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
allocate_environment(); allocate_environment();
GONext(); GONext();
@ -385,7 +385,7 @@
init_subgoal_frame(sg_fr); init_subgoal_frame(sg_fr);
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
SgFr_try_answer(sg_fr) = ans_node; SgFr_try_answer(sg_fr) = ans_node;
store_generator_node(tab_ent, sg_fr, PREG->u.ld.s, TRY_ANSWER); store_generator_node(tab_ent, sg_fr, PREG->u.apl.s, TRY_ANSWER);
PREG = (yamop *) CPREG; PREG = (yamop *) CPREG;
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
load_answer_trie(ans_node, subs_ptr); load_answer_trie(ans_node, subs_ptr);
@ -467,12 +467,12 @@
PBOp(table_try_me, ld) PBOp(table_try_me, apl)
tab_ent_ptr tab_ent; tab_ent_ptr tab_ent;
sg_fr_ptr sg_fr; sg_fr_ptr sg_fr;
check_trail(TR); check_trail(TR);
tab_ent = PREG->u.ld.te; tab_ent = PREG->u.apl.te;
YENV2MEM; YENV2MEM;
sg_fr = subgoal_search(PREG, YENV_ADDRESS); sg_fr = subgoal_search(PREG, YENV_ADDRESS);
MEM2YENV; MEM2YENV;
@ -481,8 +481,8 @@
/* subgoal new */ /* subgoal new */
init_subgoal_frame(sg_fr); init_subgoal_frame(sg_fr);
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
store_generator_node(tab_ent, sg_fr, PREG->u.ld.s, PREG->u.ld.d); store_generator_node(tab_ent, sg_fr, PREG->u.apl.s, PREG->u.apl.d);
PREG = NEXTOP(PREG, ld); PREG = NEXTOP(PREG, apl);
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
allocate_environment(); allocate_environment();
GONext(); GONext();
@ -494,7 +494,7 @@
init_subgoal_frame(sg_fr); init_subgoal_frame(sg_fr);
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
SgFr_try_answer(sg_fr) = ans_node; SgFr_try_answer(sg_fr) = ans_node;
store_generator_node(tab_ent, sg_fr, PREG->u.ld.s, TRY_ANSWER); store_generator_node(tab_ent, sg_fr, PREG->u.apl.s, TRY_ANSWER);
PREG = (yamop *) CPREG; PREG = (yamop *) CPREG;
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
load_answer_trie(ans_node, subs_ptr); load_answer_trie(ans_node, subs_ptr);
@ -576,12 +576,12 @@
PBOp(table_try, ld) PBOp(table_try, apl)
tab_ent_ptr tab_ent; tab_ent_ptr tab_ent;
sg_fr_ptr sg_fr; sg_fr_ptr sg_fr;
check_trail(TR); check_trail(TR);
tab_ent = PREG->u.ld.te; tab_ent = PREG->u.apl.te;
YENV2MEM; YENV2MEM;
sg_fr = subgoal_search(PREG, YENV_ADDRESS); sg_fr = subgoal_search(PREG, YENV_ADDRESS);
MEM2YENV; MEM2YENV;
@ -590,8 +590,8 @@
/* subgoal new */ /* subgoal new */
init_subgoal_frame(sg_fr); init_subgoal_frame(sg_fr);
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
store_generator_node(tab_ent, sg_fr, PREG->u.ld.s, NEXTOP(PREG,ld)); store_generator_node(tab_ent, sg_fr, PREG->u.apl.s, NEXTOP(PREG,apl));
PREG = PREG->u.ld.d; PREG = PREG->u.apl.d;
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
allocate_environment(); allocate_environment();
GONext(); GONext();
@ -603,7 +603,7 @@
init_subgoal_frame(sg_fr); init_subgoal_frame(sg_fr);
UNLOCK(SgFr_lock(sg_fr)); UNLOCK(SgFr_lock(sg_fr));
SgFr_try_answer(sg_fr) = ans_node; SgFr_try_answer(sg_fr) = ans_node;
store_generator_node(tab_ent, sg_fr, PREG->u.ld.s, TRY_ANSWER); store_generator_node(tab_ent, sg_fr, PREG->u.apl.s, TRY_ANSWER);
PREG = (yamop *) CPREG; PREG = (yamop *) CPREG;
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
load_answer_trie(ans_node, subs_ptr); load_answer_trie(ans_node, subs_ptr);
@ -685,49 +685,49 @@
Op(table_retry_me, ld) Op(table_retry_me, apl)
restore_generator_node(PREG->u.ld.s, PREG->u.ld.d); restore_generator_node(PREG->u.apl.s, PREG->u.apl.d);
YENV = (CELL *) PROTECT_FROZEN_B(B); YENV = (CELL *) PROTECT_FROZEN_B(B);
set_cut(YENV, B->cp_b); set_cut(YENV, B->cp_b);
SET_BB(NORM_CP(YENV)); SET_BB(NORM_CP(YENV));
allocate_environment(); allocate_environment();
PREG = NEXTOP(PREG,ld); PREG = NEXTOP(PREG,apl);
GONext(); GONext();
ENDOp(); ENDOp();
Op(table_retry, ld) Op(table_retry, apl)
restore_generator_node(PREG->u.ld.s, NEXTOP(PREG,ld)); restore_generator_node(PREG->u.apl.s, NEXTOP(PREG,apl));
YENV = (CELL *) PROTECT_FROZEN_B(B); YENV = (CELL *) PROTECT_FROZEN_B(B);
set_cut(YENV, B->cp_b); set_cut(YENV, B->cp_b);
SET_BB(NORM_CP(YENV)); SET_BB(NORM_CP(YENV));
allocate_environment(); allocate_environment();
PREG = PREG->u.ld.d; PREG = PREG->u.apl.d;
GONext(); GONext();
ENDOp(); ENDOp();
Op(table_trust_me, ld) Op(table_trust_me, apl)
restore_generator_node(PREG->u.ld.s, COMPLETION); restore_generator_node(PREG->u.apl.s, COMPLETION);
YENV = (CELL *) PROTECT_FROZEN_B(B); YENV = (CELL *) PROTECT_FROZEN_B(B);
set_cut(YENV, B->cp_b); set_cut(YENV, B->cp_b);
SET_BB(NORM_CP(YENV)); SET_BB(NORM_CP(YENV));
allocate_environment(); allocate_environment();
PREG = NEXTOP(PREG,ld); PREG = NEXTOP(PREG,apl);
GONext(); GONext();
ENDOp(); ENDOp();
Op(table_trust, ld) Op(table_trust, apl)
restore_generator_node(PREG->u.ld.s, COMPLETION); restore_generator_node(PREG->u.apl.s, COMPLETION);
YENV = (CELL *) PROTECT_FROZEN_B(B); YENV = (CELL *) PROTECT_FROZEN_B(B);
set_cut(YENV, B->cp_b); set_cut(YENV, B->cp_b);
SET_BB(NORM_CP(YENV)); SET_BB(NORM_CP(YENV));
allocate_environment(); allocate_environment();
PREG = PREG->u.ld.d; PREG = PREG->u.apl.d;
GONext(); GONext();
ENDOp(); ENDOp();
@ -973,7 +973,7 @@
BOp(table_answer_resolution, ld) BOp(table_answer_resolution, apl)
#ifdef YAPOR #ifdef YAPOR
if (SCH_top_shared_cp(B)) { if (SCH_top_shared_cp(B)) {
UNLOCK_OR_FRAME(LOCAL_top_or_fr); UNLOCK_OR_FRAME(LOCAL_top_or_fr);
@ -1259,7 +1259,7 @@
BOp(table_completion, ld) BOp(table_completion, apl)
#ifdef YAPOR #ifdef YAPOR
if (SCH_top_shared_cp(B)) { if (SCH_top_shared_cp(B)) {
if (IS_BATCHED_GEN_CP(B)) { if (IS_BATCHED_GEN_CP(B)) {

6
OPTYap/tab.structs.h
View File

@ -88,7 +88,7 @@ typedef struct subgoal_trie_node {
typedef struct answer_trie_node { typedef struct answer_trie_node {
OPCODE trie_instruction; /* u.opc */ OPCODE trie_instruction; /* u.opc */
#ifdef YAPOR #ifdef YAPOR
int or_arg; /* u.ld.or_arg */ int or_arg; /* u.apl.or_arg */
#endif /* YAPOR */ #endif /* YAPOR */
Term entry; Term entry;
#ifdef TABLE_LOCK_AT_NODE_LEVEL #ifdef TABLE_LOCK_AT_NODE_LEVEL
@ -182,8 +182,8 @@ typedef struct subgoal_frame {
#define SgFr_gen_worker(X) ((X)->generator_worker) #define SgFr_gen_worker(X) ((X)->generator_worker)
#define SgFr_gen_top_or_fr(X) ((X)->top_or_frame_on_generator_branch) #define SgFr_gen_top_or_fr(X) ((X)->top_or_frame_on_generator_branch)
#define SgFr_code(X) ((X)->code_of_subgoal) #define SgFr_code(X) ((X)->code_of_subgoal)
#define SgFr_tab_ent(X) (((X)->code_of_subgoal)->u.ld.te) #define SgFr_tab_ent(X) (((X)->code_of_subgoal)->u.apl.te)
#define SgFr_arity(X) (((X)->code_of_subgoal)->u.ld.s) #define SgFr_arity(X) (((X)->code_of_subgoal)->u.apl.s)
#define SgFr_state(X) ((X)->state_flag) #define SgFr_state(X) ((X)->state_flag)
#define SgFr_gen_cp(X) ((X)->generator_choice_point) #define SgFr_gen_cp(X) ((X)->generator_choice_point)
#define SgFr_hash_chain(X) ((X)->hash_chain) #define SgFr_hash_chain(X) ((X)->hash_chain)

4
OPTYap/tab.tries.c
View File

@ -682,8 +682,8 @@ sg_fr_ptr subgoal_search(yamop *preg, CELL **Yaddr) {
tab_ent_ptr tab_ent; tab_ent_ptr tab_ent;
sg_fr_ptr sg_fr; sg_fr_ptr sg_fr;
arity = preg->u.ld.s; arity = preg->u.apl.s;
tab_ent = preg->u.ld.te; tab_ent = preg->u.apl.te;
count_vars = 0; count_vars = 0;
stack_vars = *Yaddr; stack_vars = *Yaddr;
stack_terms_limit = (CELL *)TR; stack_terms_limit = (CELL *)TR;