This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/H/headclause.h

817 lines
18 KiB
C
Raw Normal View History

/* This file was generated automatically by "yap -L misc/buildops"
please do not update */
while (TRUE) {
op_numbers op = Yap_op_from_opcode(cl->opc);
switch (op) {
2013-07-22 16:43:38 +01:00
case _ensure_space:
cl = NEXTOP(cl,Osbpa);
break;
case _native_me:
cl = NEXTOP(cl,aFlp);
break;
case _get_2atoms:
if (iarg == Yap_regnotoreg(1)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cc.c1)) {
CELL *pt = RepAppl(cl->y_u.cc.c1);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cc.c1;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cc.c1;
return;
}
if (iarg == Yap_regnotoreg(2)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cc.c2)) {
CELL *pt = RepAppl(cl->y_u.cc.c2);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cc.c2;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cc.c2;
return;
}
cl = NEXTOP(cl,cc);
break;
case _get_3atoms:
if (iarg == Yap_regnotoreg(1)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccc.c1)) {
CELL *pt = RepAppl(cl->y_u.ccc.c1);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccc.c1;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccc.c1;
return;
}
if (iarg == Yap_regnotoreg(2)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccc.c2)) {
CELL *pt = RepAppl(cl->y_u.ccc.c2);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccc.c2;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccc.c2;
return;
}
if (iarg == Yap_regnotoreg(3)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccc.c3)) {
CELL *pt = RepAppl(cl->y_u.ccc.c3);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccc.c3;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccc.c3;
return;
}
cl = NEXTOP(cl,ccc);
break;
case _get_4atoms:
if (iarg == Yap_regnotoreg(1)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccc.c1)) {
CELL *pt = RepAppl(cl->y_u.cccc.c1);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccc.c1;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccc.c1;
return;
}
if (iarg == Yap_regnotoreg(2)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccc.c2)) {
CELL *pt = RepAppl(cl->y_u.cccc.c2);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccc.c2;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccc.c2;
return;
}
if (iarg == Yap_regnotoreg(3)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccc.c3)) {
CELL *pt = RepAppl(cl->y_u.cccc.c3);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccc.c3;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccc.c3;
return;
}
if (iarg == Yap_regnotoreg(4)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccc.c4)) {
CELL *pt = RepAppl(cl->y_u.cccc.c4);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccc.c4;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccc.c4;
return;
}
cl = NEXTOP(cl,cccc);
break;
case _get_5atoms:
if (iarg == Yap_regnotoreg(1)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccccc.c1)) {
CELL *pt = RepAppl(cl->y_u.ccccc.c1);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccccc.c1;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccccc.c1;
return;
}
if (iarg == Yap_regnotoreg(2)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccccc.c2)) {
CELL *pt = RepAppl(cl->y_u.ccccc.c2);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccccc.c2;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccccc.c2;
return;
}
if (iarg == Yap_regnotoreg(3)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccccc.c3)) {
CELL *pt = RepAppl(cl->y_u.ccccc.c3);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccccc.c3;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccccc.c3;
return;
}
if (iarg == Yap_regnotoreg(4)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccccc.c4)) {
CELL *pt = RepAppl(cl->y_u.ccccc.c4);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccccc.c4;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccccc.c4;
return;
}
if (iarg == Yap_regnotoreg(5)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.ccccc.c5)) {
CELL *pt = RepAppl(cl->y_u.ccccc.c5);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.ccccc.c5;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.ccccc.c5;
return;
}
cl = NEXTOP(cl,ccccc);
break;
case _get_6atoms:
if (iarg == Yap_regnotoreg(1)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccccc.c1)) {
CELL *pt = RepAppl(cl->y_u.cccccc.c1);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccccc.c1;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccccc.c1;
return;
}
if (iarg == Yap_regnotoreg(2)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccccc.c2)) {
CELL *pt = RepAppl(cl->y_u.cccccc.c2);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccccc.c2;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccccc.c2;
return;
}
if (iarg == Yap_regnotoreg(3)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccccc.c3)) {
CELL *pt = RepAppl(cl->y_u.cccccc.c3);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccccc.c3;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccccc.c3;
return;
}
if (iarg == Yap_regnotoreg(4)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccccc.c4)) {
CELL *pt = RepAppl(cl->y_u.cccccc.c4);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccccc.c4;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccccc.c4;
return;
}
if (iarg == Yap_regnotoreg(5)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccccc.c5)) {
CELL *pt = RepAppl(cl->y_u.cccccc.c5);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccccc.c5;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccccc.c5;
return;
}
if (iarg == Yap_regnotoreg(6)) {
2014-05-30 01:06:09 +01:00
if (IsApplTerm(cl->y_u.cccccc.c6)) {
CELL *pt = RepAppl(cl->y_u.cccccc.c6);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.cccccc.c6;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.cccccc.c6;
return;
}
cl = NEXTOP(cl,cccccc);
break;
case _copy_idb_term:
if (regno != 2) {
clause->Tag = (CELL)NULL;
} else {
LogUpdClause *lcl = ClauseCodeToLogUpdClause(cl);
Term t = lcl->lusl.ClSource->Entry;
if (!(lcl->ClFlags & FactMask)) {
if (IsVarTerm(t)) {
clause->Tag = (CELL)NULL;
} else if (IsApplTerm(t)) {
CELL *pt = RepAppl(t);
clause->Tag = AbsAppl((CELL *)pt[0]);
if (IsExtensionFunctor(FunctorOfTerm(t))) {
clause->ucd.t_ptr = t;
} else {
clause->ucd.c_sreg = pt;
}
} else if (IsPairTerm(t)) {
CELL *pt = RepPair(t);
clause->Tag = AbsPair(NULL);
clause->ucd.c_sreg = pt-1;
} else {
clause->Tag = t;
}
}
}
return;
cl = NEXTOP(cl,e);
break;
case _pop:
cl = NEXTOP(cl,e);
break;
case _unify_idb_term:
if (regno != 2) {
clause->Tag = (CELL)NULL;
} else {
LogUpdClause *lcl = ClauseCodeToLogUpdClause(cl);
Term t = lcl->lusl.ClSource->Entry;
if (!(lcl->ClFlags & FactMask)) {
if (IsVarTerm(t)) {
clause->Tag = (CELL)NULL;
} else if (IsApplTerm(t)) {
CELL *pt = RepAppl(t);
clause->Tag = AbsAppl((CELL *)pt[0]);
if (IsExtensionFunctor(FunctorOfTerm(t))) {
clause->ucd.t_ptr = t;
} else {
clause->ucd.c_sreg = pt;
}
} else if (IsPairTerm(t)) {
CELL *pt = RepPair(t);
clause->Tag = AbsPair(NULL);
clause->ucd.c_sreg = pt-1;
} else {
clause->Tag = t;
}
}
}
return;
cl = NEXTOP(cl,e);
break;
case _unify_l_list:
cl = NEXTOP(cl,o);
break;
case _unify_l_list_write:
cl = NEXTOP(cl,o);
break;
case _unify_l_void:
cl = NEXTOP(cl,o);
break;
case _unify_l_void_write:
cl = NEXTOP(cl,o);
break;
case _unify_list:
cl = NEXTOP(cl,o);
break;
case _unify_list_write:
cl = NEXTOP(cl,o);
break;
case _unify_void:
cl = NEXTOP(cl,o);
break;
case _unify_void_write:
cl = NEXTOP(cl,o);
break;
case _unify_dbterm:
cl = NEXTOP(cl,oD);
break;
case _unify_l_dbterm:
cl = NEXTOP(cl,oD);
break;
2010-12-16 22:21:46 +00:00
case _unify_bigint:
cl = NEXTOP(cl,oN);
break;
case _unify_l_bigint:
cl = NEXTOP(cl,oN);
break;
case _unify_atom:
cl = NEXTOP(cl,oc);
break;
case _unify_atom_write:
cl = NEXTOP(cl,oc);
break;
case _unify_l_atom:
cl = NEXTOP(cl,oc);
break;
case _unify_l_atom_write:
cl = NEXTOP(cl,oc);
break;
case _unify_float:
cl = NEXTOP(cl,od);
break;
case _unify_float_write:
cl = NEXTOP(cl,od);
break;
case _unify_l_float:
cl = NEXTOP(cl,od);
break;
case _unify_l_float_write:
cl = NEXTOP(cl,od);
break;
2012-12-07 23:43:00 +00:00
case _unify_l_struc:
cl = NEXTOP(cl,ofa);
break;
case _unify_l_struc_write:
cl = NEXTOP(cl,ofa);
break;
case _unify_struct:
cl = NEXTOP(cl,ofa);
break;
case _unify_struct_write:
cl = NEXTOP(cl,ofa);
break;
case _unify_l_longint:
cl = NEXTOP(cl,oi);
break;
case _unify_l_longint_write:
cl = NEXTOP(cl,oi);
break;
case _unify_longint:
cl = NEXTOP(cl,oi);
break;
case _unify_longint_write:
cl = NEXTOP(cl,oi);
break;
case _unify_l_n_voids:
cl = NEXTOP(cl,os);
break;
case _unify_l_n_voids_write:
cl = NEXTOP(cl,os);
break;
case _unify_n_voids:
cl = NEXTOP(cl,os);
break;
case _unify_n_voids_write:
cl = NEXTOP(cl,os);
break;
case _unify_n_atoms:
cl = NEXTOP(cl,osc);
break;
case _unify_n_atoms_write:
cl = NEXTOP(cl,osc);
break;
case _unify_l_string:
cl = NEXTOP(cl,ou);
break;
case _unify_string:
cl = NEXTOP(cl,ou);
break;
case _save_appl_x:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _save_appl_x_write:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _save_pair_x:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _save_pair_x_write:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_loc:
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_loc_write:
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_val:
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_val_write:
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_var:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_var_write:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _unify_x_loc:
cl = NEXTOP(cl,ox);
break;
case _unify_x_loc_write:
cl = NEXTOP(cl,ox);
break;
case _unify_x_val:
cl = NEXTOP(cl,ox);
break;
case _unify_x_val_write:
cl = NEXTOP(cl,ox);
break;
case _unify_x_var:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _unify_x_var_write:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.ox.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,ox);
break;
case _unify_l_x_var2:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xl) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xr) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,oxx);
break;
case _unify_l_x_var2_write:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xl) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xr) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,oxx);
break;
case _unify_x_var2:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xl) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xr) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,oxx);
break;
case _unify_x_var2_write:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xl) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.oxx.xr) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,oxx);
break;
case _save_appl_y:
cl = NEXTOP(cl,oy);
break;
case _save_appl_y_write:
cl = NEXTOP(cl,oy);
break;
case _save_pair_y:
cl = NEXTOP(cl,oy);
break;
case _save_pair_y_write:
cl = NEXTOP(cl,oy);
break;
case _unify_l_y_loc:
cl = NEXTOP(cl,oy);
break;
case _unify_l_y_loc_write:
cl = NEXTOP(cl,oy);
break;
case _unify_l_y_val:
cl = NEXTOP(cl,oy);
break;
case _unify_l_y_val_write:
cl = NEXTOP(cl,oy);
break;
case _unify_l_y_var:
cl = NEXTOP(cl,oy);
break;
case _unify_l_y_var_write:
cl = NEXTOP(cl,oy);
break;
case _unify_y_loc:
cl = NEXTOP(cl,oy);
break;
case _unify_y_loc_write:
cl = NEXTOP(cl,oy);
break;
case _unify_y_val:
cl = NEXTOP(cl,oy);
break;
case _unify_y_val_write:
cl = NEXTOP(cl,oy);
break;
case _unify_y_var:
cl = NEXTOP(cl,oy);
break;
case _unify_y_var_write:
cl = NEXTOP(cl,oy);
break;
case _pop_n:
cl = NEXTOP(cl,s);
break;
case _get_list:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.x.x) {
clause->Tag = AbsPair(NULL);
clause->ucd.WorkPC = NEXTOP(cl,x);
return;
}
cl = NEXTOP(cl,x);
break;
case _put_list:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.x.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,x);
break;
2010-12-16 22:21:46 +00:00
case _put_dbterm:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xD.x) {
2010-12-16 22:21:46 +00:00
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xD);
break;
case _get_bigint:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xN.x) {
2011-11-02 00:25:59 +00:00
clause->Tag = AbsAppl((CELL *)FunctorBigInt);
clause->ucd.t_ptr = (CELL)NULL;
2010-12-16 22:21:46 +00:00
return;
}
cl = NEXTOP(cl,xN);
break;
case _put_bigint:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xN.x) {
2010-12-16 22:21:46 +00:00
clause->Tag = (CELL)NULL;
return;
}
2010-12-16 22:21:46 +00:00
cl = NEXTOP(cl,xN);
break;
case _get_atom:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xc.x) {
if (IsApplTerm(cl->y_u.xc.c)) {
CELL *pt = RepAppl(cl->y_u.xc.c);
clause->Tag = AbsAppl((CELL *)pt[0]);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = cl->y_u.xc.c;
} else
2014-05-30 01:06:09 +01:00
clause->Tag = cl->y_u.xc.c;
return;
}
cl = NEXTOP(cl,xc);
break;
case _put_atom:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xc.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xc);
break;
case _get_float:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xd.x) {
clause->Tag = AbsAppl((CELL *)FunctorDouble);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = AbsAppl(cl->y_u.xd.d);
return;
}
cl = NEXTOP(cl,xd);
break;
case _put_float:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xd.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xd);
break;
case _get_struct:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xfa.x) {
clause->Tag = AbsAppl((CELL *)cl->y_u.xfa.f);
clause->ucd.WorkPC = NEXTOP(cl,xfa);
return;
}
cl = NEXTOP(cl,xfa);
break;
case _put_struct:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xfa.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xfa);
break;
case _get_longint:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xi.x) {
clause->Tag = AbsAppl((CELL *)FunctorLongInt);
2014-05-30 01:06:09 +01:00
clause->ucd.t_ptr = AbsAppl(cl->y_u.xi.i);
return;
}
cl = NEXTOP(cl,xi);
break;
case _put_longint:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xi.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xi);
break;
case _get_string:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xu.x) {
clause->Tag = AbsAppl((CELL *)FunctorString);
clause->ucd.t_ptr = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xu);
break;
case _get_x_val:
2014-05-30 01:06:09 +01:00
if (cl->y_u.xx.xl == iarg ||
cl->y_u.xx.xr == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xx);
break;
case _get_x_var:
2014-05-30 01:06:09 +01:00
if (cl->y_u.xx.xr == iarg ||
cl->y_u.xx.xl == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xx);
break;
case _gl_void_valx:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xx.xl) {
clause->Tag = AbsPair(NULL);
clause->ucd.WorkPC = cl;
return;
}
cl = NEXTOP(cl,xx);
break;
case _gl_void_varx:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xx.xl) {
clause->Tag = AbsPair(NULL);
clause->ucd.WorkPC = cl;
return;
}
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xx.xr) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xx);
break;
case _glist_valx:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xx.xl) {
clause->Tag = AbsPair(NULL);
clause->ucd.WorkPC = cl;
return;
}
cl = NEXTOP(cl,xx);
break;
case _put_x_val:
2014-05-30 01:06:09 +01:00
if (cl->y_u.xx.xl == iarg ||
cl->y_u.xx.xr == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xx);
break;
case _put_x_var:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xx.xl) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.xx.xr) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xx);
break;
case _put_xx_val:
2014-05-30 01:06:09 +01:00
if (cl->y_u.xxxx.xl1 == iarg ||
cl->y_u.xxxx.xr1 == iarg) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (cl->y_u.xxxx.xl2 == iarg ||
cl->y_u.xxxx.xr2 == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,xxxx);
break;
case _get_y_val:
2014-05-30 01:06:09 +01:00
if (cl->y_u.yx.x == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,yx);
break;
case _get_y_var:
2014-05-30 01:06:09 +01:00
if (cl->y_u.yx.x == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,yx);
break;
case _gl_void_valy:
cl = NEXTOP(cl,yx);
break;
case _gl_void_vary:
cl = NEXTOP(cl,yx);
break;
case _glist_valy:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.yx.x) {
clause->Tag = AbsPair(NULL);
clause->ucd.WorkPC = cl;
return;
}
cl = NEXTOP(cl,yx);
break;
case _put_unsafe:
2014-05-30 01:06:09 +01:00
if (cl->y_u.yx.x == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,yx);
break;
case _put_y_val:
2014-05-30 01:06:09 +01:00
if (cl->y_u.yx.x == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,yx);
break;
case _put_y_var:
2014-05-30 01:06:09 +01:00
if (iarg == cl->y_u.yx.x) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,yx);
break;
case _get_yy_var:
2014-05-30 01:06:09 +01:00
if (cl->y_u.yyxx.x1 == iarg) {
clause->Tag = (CELL)NULL;
return;
}
2014-05-30 01:06:09 +01:00
if (cl->y_u.yyxx.x2 == iarg) {
clause->Tag = (CELL)NULL;
return;
}
cl = NEXTOP(cl,yyxx);
break;
#ifdef YAPOR
#endif
#ifdef TABLING
case _table_try_single:
cl = NEXTOP(cl,Otapl);
break;
#endif
default:
clause->Tag = (CELL)NULL;
return;
}
}