diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
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.
Files
3938ed71506b190bb26ef5aca920f61e94a5f881
yap-6.3/C/prim_absmi_insts.h

3326 lines
89 KiB
C
Raw Normal View History

split absmi
2015-01-18 03:00:19 +00:00
/************************************************************************ \
* Basic Primitive Predicates *
\************************************************************************/
#ifdef INDENT_CODE
{
{
{
#endif /* INDENT_CODE */
JIT
2015-01-20 03:00:42 +00:00
Op(p_plus_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, plus_vv_unk);
plus_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, plus_vv_nvar_unk);
plus_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, plus_vv_unk, plus_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, plus_vv_nvar_unk, plus_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_plus_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, plus_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
plus_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(IntOfTerm(d0) + d1);
} else {
saveregs();
d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, plus_vc_unk, plus_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_plus_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, plus_y_vv_unk);
plus_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, plus_y_vv_nvar_unk);
plus_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, plus_y_vv_unk, plus_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, plus_y_vv_nvar_unk, plus_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_plus_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, plus_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
plus_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(IntOfTerm(d0) + d1);
} else {
saveregs();
d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, plus_y_vc_unk, plus_y_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_minus_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, minus_vv_unk);
minus_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, minus_vv_nvar_unk);
minus_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, minus_vv_unk, minus_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, minus_vv_nvar_unk, minus_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_minus_cv, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, minus_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
minus_cv_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(d1 - IntOfTerm(d0));
} else {
saveregs();
d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, minus_cv_unk, minus_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_minus_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, minus_y_vv_unk);
minus_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, minus_y_vv_nvar_unk);
minus_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, minus_y_vv_unk, minus_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, minus_y_vv_nvar_unk, minus_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_minus_y_cv, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, minus_y_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
minus_y_cv_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(d1 - IntOfTerm(d0));
} else {
saveregs();
d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, minus_y_cv_unk, minus_y_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_times_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, times_vv_unk);
times_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, times_vv_nvar_unk);
times_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = times_int(IntOfTerm(d0), IntOfTerm(d1) PASS_REGS);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_times(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, times_vv_unk, times_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, times_vv_nvar_unk, times_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_times_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, times_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
times_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = times_int(IntOfTerm(d0), d1 PASS_REGS);
} else {
saveregs();
d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, times_vc_unk, times_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_times_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, times_y_vv_unk);
times_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, times_y_vv_nvar_unk);
times_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = times_int(IntOfTerm(d0), IntOfTerm(d1) PASS_REGS);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_times(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, times_y_vv_unk, times_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, times_y_vv_nvar_unk, times_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_times_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, times_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
times_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = times_int(IntOfTerm(d0), d1 PASS_REGS);
} else {
saveregs();
d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, times_y_vc_unk, times_y_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_div_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, div_vv_unk);
div_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, div_vv_nvar_unk);
div_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int div = IntOfTerm(d1);
if (div == 0) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d1);
JIT
2015-01-20 03:00:42 +00:00
}
d0 = MkIntTerm(IntOfTerm(d0) / div);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_div(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, div_vv_unk, div_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, div_vv_nvar_unk, div_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_div_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, div_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
div_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntTerm(IntOfTerm(d0) / d1);
} else {
saveregs();
d0 = p_div(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, div_vc_unk, div_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_div_cv, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, div_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
div_cv_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
Int div = IntOfTerm(d0);
if (div == 0) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
FAIL();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = MkIntegerTerm(d1 / div);
} else {
saveregs();
d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, div_cv_unk, div_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_div_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, div_y_vv_unk);
div_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, div_y_vv_nvar_unk);
div_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int div = IntOfTerm(d1);
if (div == 0) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR, d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
}
d0 = MkIntTerm(IntOfTerm(d0) / div);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_div(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, div_y_vv_unk, div_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, div_y_vv_nvar_unk, div_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_div_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, div_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
div_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntTerm(IntOfTerm(d0) / d1);
} else {
saveregs();
d0 = p_div(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, div_y_vc_unk, div_y_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_div_y_cv, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, div_y_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
div_y_cv_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
Int div = IntOfTerm(d0);
if (div == 0) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
FAIL();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = MkIntegerTerm(d1 / div);
} else {
saveregs();
d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, div_y_cv_unk, div_y_cv_nvar);
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AbsmiError(INSTANTIATION_ERROR);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_and_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, and_vv_unk);
and_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, and_vv_nvar_unk);
and_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_and(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, and_vv_unk, and_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, and_vv_nvar_unk, and_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_and_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, and_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
and_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(IntOfTerm(d0) & d1);
} else {
saveregs();
d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, and_vc_unk, and_vc_nvar);
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AbsmiError(INSTANTIATION_ERROR);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_and_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, and_y_vv_unk);
and_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, and_y_vv_nvar_unk);
and_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_and(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, and_y_vv_unk, and_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, and_y_vv_nvar_unk, and_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_and_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, and_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
and_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(IntOfTerm(d0) & d1);
} else {
saveregs();
d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, and_y_vc_unk, and_y_vc_nvar);
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AbsmiError(INSTANTIATION_ERROR);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_or_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, or_vv_unk);
or_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, or_vv_nvar_unk);
or_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_or(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, or_vv_unk, or_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, or_vv_nvar_unk, or_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_or_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, or_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
or_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(IntOfTerm(d0) | d1);
} else {
saveregs();
d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, or_vc_unk, or_vc_nvar);
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AbsmiError(INSTANTIATION_ERROR);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_or_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, or_y_vv_unk);
or_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, or_y_vv_nvar_unk);
or_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_or(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, or_y_vv_unk, or_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, or_y_vv_nvar_unk, or_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_or_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, or_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
or_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntegerTerm(IntOfTerm(d0) | d1);
} else {
saveregs();
d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, or_y_vc_unk, or_y_vc_nvar);
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AbsmiError(INSTANTIATION_ERROR);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_sll_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, sll_vv_unk);
sll_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, sll_vv_nvar_unk);
sll_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int i2 = IntOfTerm(d1);
if (i2 < 0)
d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2));
else
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = do_sll(IntOfTerm(d0), i2 PASS_REGS);
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, sll_vv_unk, sll_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, sll_vv_nvar_unk, sll_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_sll_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, sll_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
sll_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = do_sll(IntOfTerm(d0), (Int)d1 PASS_REGS);
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
setregs();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, sll_vc_unk, sll_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_sll_cv, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, sll_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
sll_cv_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
Int i2 = IntOfTerm(d0);
if (i2 < 0)
d0 = MkIntegerTerm(SLR(d1, -i2));
else
d0 = do_sll(d1, i2 PASS_REGS);
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
setregs();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, sll_cv_unk, sll_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_sll_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, sll_y_vv_unk);
sll_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, sll_y_vv_nvar_unk);
sll_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int i2 = IntOfTerm(d1);
if (i2 < 0)
d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2));
else
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = do_sll(IntOfTerm(d0), i2 PASS_REGS);
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, sll_y_vv_unk, sll_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, sll_y_vv_nvar_unk, sll_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_sll_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, sll_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
sll_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = do_sll(IntOfTerm(d0), Yap_Eval(d1) PASS_REGS);
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
setregs();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, sll_y_vc_unk, sll_y_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_sll_y_cv, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, sll_y_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
sll_y_cv_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
Int i2 = IntOfTerm(d0);
if (i2 < 0)
d0 = MkIntegerTerm(SLR(d1, -i2));
else
d0 = do_sll(d1, i2 PASS_REGS);
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(0) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
setregs();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, sll_y_cv_unk, sll_y_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_slr_vv, xxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.xxx.x1);
/* first check pt1 */
deref_head(d0, slr_vv_unk);
slr_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, slr_vv_nvar_unk);
slr_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int i2 = IntOfTerm(d1);
if (i2 < 0)
d0 = do_sll(IntOfTerm(d0), -i2 PASS_REGS);
else
d0 = MkIntTerm(SLR(IntOfTerm(d0), i2));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);
GONext();
BEGP(pt0);
deref_body(d0, pt0, slr_vv_unk, slr_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, slr_vv_nvar_unk, slr_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_slr_vc, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, slr_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
slr_vc_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntTerm(SLR(IntOfTerm(d0), d1));
} else {
saveregs();
d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
JIT
2015-01-20 03:00:42 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, slr_vc_unk, slr_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_slr_cv, xxn);
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
/* first check pt1 */
deref_head(d0, slr_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
slr_cv_nvar : {
Int d1 = PREG->y_u.xxn.c;
if (IsIntTerm(d0)) {
Int i2 = IntOfTerm(d0);
if (i2 < 0)
d0 = do_sll(d1, -i2 PASS_REGS);
else
d0 = MkIntegerTerm(SLR(d1, i2));
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
JIT
2015-01-20 03:00:42 +00:00
setregs();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
JIT
2015-01-20 03:00:42 +00:00
XREG(PREG->y_u.xxn.x) = d0;
PREG = NEXTOP(PREG, xxn);
GONext();
BEGP(pt0);
deref_body(d0, pt0, slr_cv_unk, slr_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_slr_y_vv, yxx);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.yxx.x1);
/* first check pt1 */
deref_head(d0, slr_y_vv_unk);
slr_y_vv_nvar:
d1 = XREG(PREG->y_u.xxx.x2);
/* next check A2 */
deref_head(d1, slr_y_vv_nvar_unk);
slr_y_vv_nvar_nvar:
/* d0 and d1 are where I want them */
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int i2 = IntOfTerm(d1);
if (i2 < 0)
d0 = do_sll(IntOfTerm(d0), -i2 PASS_REGS);
else
d0 = MkIntTerm(SLR(IntOfTerm(d0), i2));
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
JIT
2015-01-20 03:00:42 +00:00
saveregs();
d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
BEGP(pt0);
JIT
2015-01-20 03:00:42 +00:00
pt0 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
JIT
2015-01-20 03:00:42 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, slr_y_vv_unk, slr_y_vv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, slr_y_vv_nvar_unk, slr_y_vv_nvar_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
JIT
2015-01-20 03:00:42 +00:00
FAIL();
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDOp();
split absmi
2015-01-18 03:00:19 +00:00
Op(p_slr_y_vc, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, slr_y_vc_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
slr_y_vc_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
d0 = MkIntTerm(SLR(IntOfTerm(d0), d1));
} else {
saveregs();
d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
setregs();
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
}
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, slr_y_vc_unk, slr_y_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
ENDD(d0);
ENDOp();
Op(p_slr_y_cv, yxn);
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
/* first check pt1 */
deref_head(d0, slr_y_cv_unk);
less invasive error handling
2016-10-19 22:44:59 -05:00
slr_y_cv_nvar : {
Int d1 = PREG->y_u.yxn.c;
if (IsIntTerm(d0)) {
Int i2 = IntOfTerm(d0);
if (i2 < 0)
d0 = do_sll(d1, -i2 PASS_REGS);
else
d0 = MkIntegerTerm(SLR(d1, i2));
} else {
split absmi
2015-01-18 03:00:19 +00:00
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
split absmi
2015-01-18 03:00:19 +00:00
setregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
}
}
if (d0 == 0L) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(LOCAL_Error_TYPE,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt0);
pt0 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
GONext();
BEGP(pt0);
deref_body(d0, pt0, slr_y_cv_unk, slr_y_cv_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
BOp(call_bfunc_xx, plxxs);
BEGD(d0);
BEGD(d1);
d0 = XREG(PREG->y_u.plxxs.x1);
call_bfunc_xx_nvar:
d1 = XREG(PREG->y_u.plxxs.x2);
call_bfunc_xx2_nvar:
deref_head(d0, call_bfunc_xx_unk);
deref_head(d1, call_bfunc_xx2_unk);
if (IsIntTerm(d0) && IsIntTerm(d1)) {
COUNT flags;
Int v = IntOfTerm(d0) - IntOfTerm(d1);
flags = PREG->y_u.plxxs.flags;
if (v > 0) {
if (flags & GT_OK_IN_CMP) {
yamop *nextp = NEXTOP(PREG, plxxs);
ALWAYS_LOOKAHEAD(nextp->opc);
PREG = nextp;
ALWAYS_GONext();
ALWAYS_END_PREFETCH();
} else {
yamop *nextp = PREG->y_u.plxxs.f;
ALWAYS_LOOKAHEAD(nextp->opc);
PREG = nextp;
ALWAYS_GONext();
ALWAYS_END_PREFETCH();
}
} else if (v < 0) {
if (flags & LT_OK_IN_CMP) {
yamop *nextp = NEXTOP(PREG, plxxs);
ALWAYS_LOOKAHEAD(nextp->opc);
PREG = nextp;
ALWAYS_GONext();
ALWAYS_END_PREFETCH();
} else {
yamop *nextp = PREG->y_u.plxxs.f;
ALWAYS_LOOKAHEAD(nextp->opc);
PREG = nextp;
ALWAYS_GONext();
ALWAYS_END_PREFETCH();
}
} else /* if (v == 0) */ {
if (flags & EQ_OK_IN_CMP) {
yamop *nextp = NEXTOP(PREG, plxxs);
ALWAYS_LOOKAHEAD(nextp->opc);
PREG = nextp;
ALWAYS_GONext();
ALWAYS_END_PREFETCH();
} else {
yamop *nextp = PREG->y_u.plxxs.f;
ALWAYS_LOOKAHEAD(nextp->opc);
PREG = nextp;
ALWAYS_GONext();
ALWAYS_END_PREFETCH();
}
}
}
less invasive error handling
2016-10-19 22:44:59 -05:00
exec_bin_cmp_xx : {
CmpPredicate f = PREG->y_u.plxxs.p->cs.d_code;
saveregs();
d0 = (CELL)(f)(d0, d1);
setregs();
}
split absmi
2015-01-18 03:00:19 +00:00
if (PREG == FAILCODE) {
JMPNext();
}
if (!d0) {
PREG = PREG->y_u.plxxs.f;
JMPNext();
}
PREG = NEXTOP(PREG, plxxs);
JMPNext();
BEGP(pt0);
deref_body(d0, pt0, call_bfunc_xx_unk, call_bfunc_xx_nvar);
d1 = Deref(d1);
goto exec_bin_cmp_xx;
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, call_bfunc_xx2_unk, call_bfunc_xx2_nvar);
goto exec_bin_cmp_xx;
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDBOp();
BOp(call_bfunc_yx, plxys);
BEGD(d0);
BEGD(d1);
BEGP(pt0);
pt0 = YREG + PREG->y_u.plxys.y;
d1 = XREG(PREG->y_u.plxys.x);
d0 = *pt0;
ENDP(pt0);
deref_head(d0, call_bfunc_yx_unk);
call_bfunc_yx_nvar:
deref_head(d1, call_bfunc_yx2_unk);
call_bfunc_yx2_nvar:
if (IsIntTerm(d0) && IsIntTerm(d1)) {
int flags;
Int v = IntOfTerm(d0) - IntOfTerm(d1);
flags = PREG->y_u.plxys.flags;
if (v > 0) {
if (flags & GT_OK_IN_CMP) {
PREG = NEXTOP(PREG, plxys);
JMPNext();
} else {
PREG = PREG->y_u.plxys.f;
JMPNext();
}
} else if (v < 0) {
if (flags & LT_OK_IN_CMP) {
PREG = NEXTOP(PREG, plxys);
JMPNext();
} else {
PREG = PREG->y_u.plxys.f;
JMPNext();
}
} else /* if (v == 0) */ {
if (flags & EQ_OK_IN_CMP) {
PREG = NEXTOP(PREG, plxys);
JMPNext();
} else {
PREG = PREG->y_u.plxys.f;
JMPNext();
}
}
}
less invasive error handling
2016-10-19 22:44:59 -05:00
exec_bin_cmp_yx : {
CmpPredicate f = PREG->y_u.plxys.p->cs.d_code;
saveregs();
d0 = (CELL)(f)(d0, d1);
setregs();
}
split absmi
2015-01-18 03:00:19 +00:00
if (!d0 || PREG == FAILCODE) {
if (PREG != FAILCODE)
PREG = PREG->y_u.plxys.f;
JMPNext();
}
PREG = NEXTOP(PREG, plxys);
JMPNext();
BEGP(pt0);
deref_body(d0, pt0, call_bfunc_yx_unk, call_bfunc_yx_nvar);
d1 = Deref(d1);
goto exec_bin_cmp_yx;
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, call_bfunc_yx2_unk, call_bfunc_yx2_nvar);
goto exec_bin_cmp_yx;
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDBOp();
BOp(call_bfunc_xy, plxys);
BEGD(d0);
BEGD(d1);
BEGP(pt0);
pt0 = YREG + PREG->y_u.plxys.y;
d0 = XREG(PREG->y_u.plxys.x);
d1 = *pt0;
ENDP(pt0);
deref_head(d0, call_bfunc_xy_unk);
call_bfunc_xy_nvar:
deref_head(d1, call_bfunc_xy2_unk);
call_bfunc_xy2_nvar:
if (IsIntTerm(d0) && IsIntTerm(d1)) {
int flags;
Int v = IntOfTerm(d0) - IntOfTerm(d1);
flags = PREG->y_u.plxys.flags;
if (v > 0) {
if (flags & GT_OK_IN_CMP) {
PREG = NEXTOP(PREG, plxys);
JMPNext();
} else {
PREG = PREG->y_u.plxys.f;
JMPNext();
}
} else if (v < 0) {
if (flags & LT_OK_IN_CMP) {
PREG = NEXTOP(PREG, plxys);
JMPNext();
} else {
PREG = PREG->y_u.plxys.f;
JMPNext();
}
} else /* if (v == 0) */ {
if (flags & EQ_OK_IN_CMP) {
PREG = NEXTOP(PREG, plxys);
JMPNext();
} else {
PREG = PREG->y_u.plxys.f;
JMPNext();
}
}
}
less invasive error handling
2016-10-19 22:44:59 -05:00
exec_bin_cmp_xy : {
CmpPredicate f = PREG->y_u.plxys.p->cs.d_code;
saveregs();
d0 = (CELL)(f)(d0, d1);
setregs();
}
split absmi
2015-01-18 03:00:19 +00:00
if (!d0 || PREG == FAILCODE) {
if (PREG != FAILCODE)
PREG = PREG->y_u.plxys.f;
JMPNext();
}
PREG = NEXTOP(PREG, plxys);
JMPNext();
BEGP(pt0);
deref_body(d0, pt0, call_bfunc_xy_unk, call_bfunc_xy_nvar);
d1 = Deref(d1);
goto exec_bin_cmp_xy;
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, call_bfunc_xy2_unk, call_bfunc_xy2_nvar);
goto exec_bin_cmp_xy;
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDBOp();
BOp(call_bfunc_yy, plyys);
BEGD(d0);
BEGD(d1);
BEGP(pt0);
pt0 = YREG + PREG->y_u.plyys.y1;
BEGP(pt1);
pt1 = YREG + PREG->y_u.plyys.y2;
d0 = *pt0;
d1 = *pt1;
ENDP(pt1);
ENDP(pt0);
deref_head(d0, call_bfunc_yy_unk);
call_bfunc_yy_nvar:
deref_head(d1, call_bfunc_yy2_unk);
call_bfunc_yy2_nvar:
if (IsIntTerm(d0) && IsIntTerm(d1)) {
int flags;
Int v = IntOfTerm(d0) - IntOfTerm(d1);
flags = PREG->y_u.plyys.flags;
if (v > 0) {
if (flags & GT_OK_IN_CMP) {
PREG = NEXTOP(PREG, plyys);
JMPNext();
} else {
PREG = PREG->y_u.plyys.f;
JMPNext();
}
} else if (v < 0) {
if (flags & LT_OK_IN_CMP) {
PREG = NEXTOP(PREG, plyys);
JMPNext();
} else {
PREG = PREG->y_u.plyys.f;
JMPNext();
}
} else /* if (v == 0) */ {
if (flags & EQ_OK_IN_CMP) {
PREG = NEXTOP(PREG, plyys);
JMPNext();
} else {
PREG = PREG->y_u.plyys.f;
JMPNext();
}
}
}
less invasive error handling
2016-10-19 22:44:59 -05:00
exec_bin_cmp_yy : {
CmpPredicate f = PREG->y_u.plyys.p->cs.d_code;
saveregs();
d0 = (CELL)(f)(d0, d1);
setregs();
}
split absmi
2015-01-18 03:00:19 +00:00
if (!d0 || PREG == FAILCODE) {
if (PREG != FAILCODE)
PREG = PREG->y_u.plyys.f;
JMPNext();
}
PREG = NEXTOP(PREG, plyys);
JMPNext();
BEGP(pt0);
deref_body(d0, pt0, call_bfunc_yy_unk, call_bfunc_yy_nvar);
d1 = Deref(d1);
goto exec_bin_cmp_yy;
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, call_bfunc_yy2_unk, call_bfunc_yy2_nvar);
goto exec_bin_cmp_yy;
ENDP(pt0);
ENDD(d1);
ENDD(d0);
ENDBOp();
Op(p_equal, e);
save_hb();
if (Yap_IUnify(ARG1, ARG2) == false) {
FAIL();
}
PREG = NEXTOP(PREG, e);
GONext();
ENDOp();
don't inline == and \= for now.
2016-03-30 01:24:34 +01:00
#if INLINE_BIG_COMPARISONS
split absmi
2015-01-18 03:00:19 +00:00
Op(p_dif, l);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace)
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorDiff, 0)),
XREGS + 1);
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
BEGD(d1);
d0 = ARG1;
deref_head(d0, dif_unk1);
dif_nvar1:
/* first argument is bound */
d1 = ARG2;
deref_head(d1, dif_nvar1_unk2);
dif_nvar1_nvar2:
/* both arguments are bound */
if (d0 == d1) {
PREG = PREG->y_u.l.l;
GONext();
}
if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) {
PREG = NEXTOP(PREG, l);
GONext();
}
{
Int opresult;
#ifdef COROUTINING
/*
* We may wake up goals during our attempt to unify the
* two terms. If we are adding to the tail of a list of
* woken goals that should be ok, but otherwise we need
* to restore LOCAL_WokenGoals to its previous value.
*/
CELL OldWokenGoals = Yap_ReadTimedVar(LOCAL_WokenGoals);
#endif
/* We will have to look inside compound terms */
register tr_fr_ptr pt0;
/* store the old value of TR for clearing bindings */
pt0 = TR;
BEGCHO(pt1);
pt1 = B;
/* make B and HB point to H to guarantee all bindings will
* be trailed
*/
HBREG = HR;
less invasive error handling
2016-10-19 22:44:59 -05:00
B = (choiceptr)HR;
split absmi
2015-01-18 03:00:19 +00:00
B->cp_h = HR;
SET_BB(B);
save_hb();
opresult = Yap_IUnify(d0, d1);
#ifdef COROUTINING
/* now restore Woken Goals to its old value */
Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals);
if (OldWokenGoals == TermNil) {
Yap_get_signal(YAP_WAKEUP_SIGNAL);
}
#endif
/* restore B */
B = pt1;
SET_BB(PROTECT_FROZEN_B(pt1));
#ifdef COROUTINING
HR = HBREG;
#endif
HBREG = B->cp_h;
/* untrail all bindings made by Yap_IUnify */
while (TR != pt0) {
BEGD(d1);
d1 = TrailTerm(--TR);
if (IsVarTerm(d1)) {
#if defined(YAPOR_SBA) && defined(YAPOR)
/* clean up the trail when we backtrack */
less invasive error handling
2016-10-19 22:44:59 -05:00
if (Unsigned((Int)(d1) - (Int)(H_FZ)) >
Unsigned((Int)(B_FZ) - (Int)(H_FZ))) {
split absmi
2015-01-18 03:00:19 +00:00
RESET_VARIABLE(STACK_TO_SBA(d1));
} else
#endif
/* normal variable */
RESET_VARIABLE(d1);
#ifdef MULTI_ASSIGNMENT_VARIABLES
} else /* if (IsApplTerm(d1)) */ {
CELL *pt = RepAppl(d1);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* AbsAppl means */
/* multi-assignment variable */
/* so the next cell is the old value */
split absmi
2015-01-18 03:00:19 +00:00
#ifdef FROZEN_STACKS
pt[0] = TrailVal(--TR);
#else
pt[0] = TrailTerm(--TR);
TR--;
#endif /* FROZEN_STACKS */
#endif /* MULTI_ASSIGNMENT_VARIABLES */
}
ENDD(d1);
}
if (opresult) {
/* restore B, no need to restore HB */
PREG = PREG->y_u.l.l;
GONext();
}
/* restore B, and later HB */
PREG = NEXTOP(PREG, l);
ENDCHO(pt1);
}
GONext();
BEGP(pt0);
deref_body(d0, pt0, dif_unk1, dif_nvar1);
ENDP(pt0);
/* first argument is unbound */
PREG = PREG->y_u.l.l;
GONext();
BEGP(pt0);
deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2);
ENDP(pt0);
/* second argument is unbound */
PREG = PREG->y_u.l.l;
GONext();
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_eq, l);
don't inline == and \= for now.
2016-03-30 01:24:34 +01:00
#ifdef COROUTINING
CACHE_Y_AS_ENV(YREG);
check_stack(NoStackEq, HR);
ENDCACHE_Y_AS_ENV();
do_eq:
#endif
split absmi
2015-01-18 03:00:19 +00:00
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace)
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorSame, 0)),
XREGS + 1);
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
BEGD(d1);
d0 = ARG1;
deref_head(d0, p_eq_unk1);
p_eq_nvar1:
/* first argument is bound */
d1 = ARG2;
deref_head(d1, p_eq_nvar1_unk2);
p_eq_nvar1_nvar2:
/* both arguments are bound */
if (d0 == d1) {
PREG = NEXTOP(PREG, l);
GONext();
}
if (IsPairTerm(d0)) {
if (!IsPairTerm(d1)) {
PREG = PREG->y_u.l.l;
GONext();
}
BEGD(d2);
always_save_pc();
less invasive error handling
2016-10-19 22:44:59 -05:00
d2 = iequ_complex(RepPair(d0) - 1, RepPair(d0) + 1, RepPair(d1) - 1);
split absmi
2015-01-18 03:00:19 +00:00
if (d2 == false) {
PREG = PREG->y_u.l.l;
GONext();
}
ENDD(d2);
always_set_pc();
PREG = NEXTOP(PREG, l);
GONext();
}
if (IsApplTerm(d0)) {
Functor f0 = FunctorOfTerm(d0);
Functor f1;
/* f1 must be a compound term, even if it is a suspension */
if (!IsApplTerm(d1)) {
PREG = PREG->y_u.l.l;
GONext();
}
f1 = FunctorOfTerm(d1);
/* we now know f1 is true */
/* deref if a compound term */
if (IsExtensionFunctor(f0)) {
switch ((CELL)f0) {
case (CELL)FunctorDBRef:
if (d0 == d1) {
PREG = NEXTOP(PREG, l);
GONext();
}
PREG = PREG->y_u.l.l;
GONext();
case (CELL)FunctorLongInt:
if (f1 != FunctorLongInt) {
PREG = PREG->y_u.l.l;
GONext();
}
if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) {
PREG = NEXTOP(PREG, l);
GONext();
}
PREG = PREG->y_u.l.l;
GONext();
case (CELL)FunctorString:
if (f1 != FunctorString) {
PREG = PREG->y_u.l.l;
GONext();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
if (strcmp((char *)(RepAppl(d0) + 2), (char *)(RepAppl(d1) + 2)) ==
0) {
split absmi
2015-01-18 03:00:19 +00:00
PREG = NEXTOP(PREG, l);
GONext();
}
PREG = PREG->y_u.l.l;
GONext();
break;
#ifdef USE_GMP
case (CELL)FunctorBigInt:
if (f1 != FunctorBigInt) {
PREG = PREG->y_u.l.l;
GONext();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
if (Yap_gmp_tcmp_big_big(d0, d1) == 0) {
split absmi
2015-01-18 03:00:19 +00:00
PREG = NEXTOP(PREG, l);
GONext();
}
PREG = PREG->y_u.l.l;
GONext();
#endif
case (CELL)FunctorDouble:
if (f1 != FunctorDouble) {
PREG = PREG->y_u.l.l;
GONext();
}
if (FloatOfTerm(d0) == FloatOfTerm(d1)) {
PREG = NEXTOP(PREG, l);
GONext();
}
PREG = PREG->y_u.l.l;
GONext();
break;
default:
PREG = PREG->y_u.l.l;
GONext();
}
}
if (f0 != f1) {
PREG = PREG->y_u.l.l;
GONext();
}
always_save_pc();
BEGD(d2);
less invasive error handling
2016-10-19 22:44:59 -05:00
d2 = iequ_complex(RepAppl(d0), RepAppl(d0) + ArityOfFunctor(f0),
RepAppl(d1));
split absmi
2015-01-18 03:00:19 +00:00
if (d2 == false) {
PREG = PREG->y_u.l.l;
GONext();
}
ENDD(d2);
always_set_pc();
PREG = NEXTOP(PREG, l);
GONext();
}
PREG = PREG->y_u.l.l;
GONext();
BEGP(pt0);
deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2);
ENDP(pt0);
/* first argument is bound */
/* second argument is unbound */
/* I don't need to worry about co-routining because an
unbound variable may never be == to a constrained variable!! */
PREG = PREG->y_u.l.l;
GONext();
ENDD(d1);
BEGP(pt0);
deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1);
BEGD(d1);
d1 = ARG2;
deref_head(d1, p_eq_var1_unk2);
p_eq_var1_nvar2:
/* I don't need to worry about co-routining because an
unbound variable may never be == to a constrained variable!! */
PREG = PREG->y_u.l.l;
GONext();
BEGP(pt1);
deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2);
/* first argument is unbound */
/* second argument is unbound */
if (pt1 != pt0) {
PREG = PREG->y_u.l.l;
GONext();
}
PREG = NEXTOP(PREG, l);
GONext();
ENDP(pt1);
ENDD(d1);
ENDP(pt0);
ENDD(d0);
don't inline == and \= for now.
2016-03-30 01:24:34 +01:00
#ifdef COROUTINING
less invasive error handling
2016-10-19 22:44:59 -05:00
/* Problem: have I got an environment or not? */
don't inline == and \= for now.
2016-03-30 01:24:34 +01:00
NoStackEq:
PROCESS_INT(interrupt_eq, do_eq);
#endif
split absmi
2015-01-18 03:00:19 +00:00
ENDOp();
don't inline == and \= for now.
2016-03-30 01:24:34 +01:00
#endif /* INLINE_BIG_COMPARISONS */
split absmi
2015-01-18 03:00:19 +00:00
Op(p_arg_vv, xxx);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
HR[0] = XREG(PREG->y_u.xxx.x1);
HR[1] = XREG(PREG->y_u.xxx.x2);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.xxx.x1);
deref_head(d0, arg_arg1_unk);
arg_arg1_nvar:
/* ARG1 is ok! */
if (IsIntTerm(d0))
d0 = IntOfTerm(d0);
else if (IsLongIntTerm(d0)) {
d0 = LongIntOfTerm(d0);
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsBigIntTerm(d0))
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* d0 now got the argument we want */
BEGD(d1);
d1 = XREG(PREG->y_u.xxx.x2);
deref_head(d1, arg_arg2_unk);
arg_arg2_nvar:
/* d1 now got the structure we want to fetch the argument
* from */
if (IsApplTerm(d1)) {
BEGP(pt0);
pt0 = RepAppl(d1);
d1 = *pt0;
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsExtensionFunctor((Functor)d1)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND, AbsAppl(pt0));
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
split absmi
2015-01-18 03:00:19 +00:00
/* don't complain here for Prolog compatibility
if ((Int)d0 <= 0) {
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
split absmi
2015-01-18 03:00:19 +00:00
MkIntegerTerm(d0),"arg 1 of arg/3");
setregs();
}
*/
FAIL();
}
XREG(PREG->y_u.xxx.x) = pt0[d0];
PREG = NEXTOP(PREG, xxx);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (IsPairTerm(d1)) {
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt0);
pt0 = RepPair(d1);
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d0) );
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
XREG(PREG->y_u.xxx.x) = pt0[d0 - 1];
split absmi
2015-01-18 03:00:19 +00:00
PREG = NEXTOP(PREG, xxx);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND, d1);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar);
saveregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
less invasive error handling
2016-10-19 22:44:59 -05:00
;
split absmi
2015-01-18 03:00:19 +00:00
setregs();
ENDP(pt0);
FAIL();
ENDD(d1);
BEGP(pt0);
deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar);
saveregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
;
split absmi
2015-01-18 03:00:19 +00:00
setregs();
ENDP(pt0);
FAIL();
ENDD(d0);
ENDOp();
Op(p_arg_cv, xxn);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
CELL *Ho = HR;
Term t = MkIntegerTerm(PREG->y_u.xxn.c);
less invasive error handling
2016-10-19 22:44:59 -05:00
HR[0] = t;
split absmi
2015-01-18 03:00:19 +00:00
HR[1] = XREG(PREG->y_u.xxn.xi);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
split absmi
2015-01-18 03:00:19 +00:00
HR = Ho;
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = PREG->y_u.xxn.c;
/* d0 now got the argument we want */
BEGD(d1);
d1 = XREG(PREG->y_u.xxn.xi);
deref_head(d1, arg_arg2_vc_unk);
arg_arg2_vc_nvar:
/* d1 now got the structure we want to fetch the argument
* from */
if (IsApplTerm(d1)) {
BEGP(pt0);
pt0 = RepAppl(d1);
d1 = *pt0;
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsExtensionFunctor((Functor)d1)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND,XREG(PREG->y_u.xxn.xi));
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
split absmi
2015-01-18 03:00:19 +00:00
/* don't complain here for Prolog compatibility
if ((Int)d0 <= 0) {
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
split absmi
2015-01-18 03:00:19 +00:00
MkIntegerTerm(d0),"arg 1 of arg/3");
setregs();
}
*/
FAIL();
}
XREG(PREG->y_u.xxn.x) = pt0[d0];
PREG = NEXTOP(PREG, xxn);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (IsPairTerm(d1)) {
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt0);
pt0 = RepPair(d1);
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
saveregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, XREG(PREG->y_u.xxn.xi));
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
XREG(PREG->y_u.xxn.x) = pt0[d0 - 1];
split absmi
2015-01-18 03:00:19 +00:00
PREG = NEXTOP(PREG, xxn);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND, XREG(PREG->y_u.xxn.xi));
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_arg2_vc_unk, arg_arg2_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR, XREG(PREG->y_u.xxn.xi));
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
FAIL();
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_arg_y_vv, yxx);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
HR[0] = XREG(PREG->y_u.yxx.x1);
HR[1] = XREG(PREG->y_u.yxx.x2);
HR[2] = YREG[PREG->y_u.yxx.y];
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.yxx.x1);
deref_head(d0, arg_y_arg1_unk);
arg_y_arg1_nvar:
/* ARG1 is ok! */
if (IsIntTerm(d0))
d0 = IntOfTerm(d0);
else if (IsLongIntTerm(d0)) {
d0 = LongIntOfTerm(d0);
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsBigIntTerm(d0))
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER, XREG(PREG->y_u.yxx.x1));
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* d0 now got the argument we want */
BEGD(d1);
d1 = XREG(PREG->y_u.yxx.x2);
deref_head(d1, arg_y_arg2_unk);
arg_y_arg2_nvar:
/* d1 now got the structure we want to fetch the argument
* from */
if (IsApplTerm(d1)) {
BEGP(pt0);
pt0 = RepAppl(d1);
d1 = *pt0;
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsExtensionFunctor((Functor)d1)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND,XREG(PREG->y_u.yxx.x2));
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
less invasive error handling
2016-10-19 22:44:59 -05:00
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
split absmi
2015-01-18 03:00:19 +00:00
/* don't complain here for Prolog compatibility
if ((Int)d0 <= 0) {
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
split absmi
2015-01-18 03:00:19 +00:00
MkIntegerTerm(d0),"arg 1 of arg/3");
saveregs();
}
*/
FAIL();
}
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt1, pt0[d0]);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (IsPairTerm(d1)) {
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt0);
pt0 = RepPair(d1);
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
saveregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, YREG[PREG->y_u.yxx.y]);
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxx.y;
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt1, pt0[d0 - 1]);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
ENDP(pt1);
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND, d1);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_y_arg2_unk, arg_y_arg2_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
FAIL();
ENDD(d1);
BEGP(pt0);
deref_body(d0, pt0, arg_y_arg1_unk, arg_y_arg1_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
FAIL();
ENDD(d0);
ENDOp();
Op(p_arg_y_cv, yxn);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
CELL *Ho = HR;
Term t = MkIntegerTerm(PREG->y_u.yxn.c);
less invasive error handling
2016-10-19 22:44:59 -05:00
HR[0] = t;
split absmi
2015-01-18 03:00:19 +00:00
HR[1] = XREG(PREG->y_u.yxn.xi);
HR[2] = YREG[PREG->y_u.yxn.y];
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
split absmi
2015-01-18 03:00:19 +00:00
HR = Ho;
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = PREG->y_u.yxn.c;
/* d0 now got the argument we want */
BEGD(d1);
d1 = XREG(PREG->y_u.yxn.xi);
deref_head(d1, arg_y_arg2_vc_unk);
arg_y_arg2_vc_nvar:
/* d1 now got the structure we want to fetch the argument
* from */
if (IsApplTerm(d1)) {
BEGP(pt0);
pt0 = RepAppl(d1);
d1 = *pt0;
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsExtensionFunctor((Functor)d1)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND, XREG(PREG->y_u.yxn.xi));
less invasive error handling
2016-10-19 22:44:59 -05:00
FAIL();
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
split absmi
2015-01-18 03:00:19 +00:00
/* don't complain here for Prolog compatibility
if ((Int)d0 <= 0) {
less invasive error handling
2016-10-19 22:44:59 -05:00
Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
split absmi
2015-01-18 03:00:19 +00:00
}
*/
FAIL();
}
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt1, pt0[d0]);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (IsPairTerm(d1)) {
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt0);
pt0 = RepPair(d1);
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
saveregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, YREG[PREG->y_u.yxn.y]);
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxn.y;
PREG = NEXTOP(PREG, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt1, pt0[d0 - 1]);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
ENDP(pt0);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_COMPOUND,YREG[PREG->y_u.yxn.y]);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_y_arg2_vc_unk, arg_y_arg2_vc_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt0);
FAIL();
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_func2s_vv, xxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* A1 is a variable */
split absmi
2015-01-18 03:00:19 +00:00
restart_func2s:
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
RESET_VARIABLE(HR);
HR[1] = XREG(PREG->y_u.xxx.x1);
HR[2] = XREG(PREG->y_u.xxx.x2);
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.xxx.x1);
deref_head(d0, func2s_unk);
func2s_nvar:
/* we do, let's get the third argument */
BEGD(d1);
d1 = XREG(PREG->y_u.xxx.x2);
deref_head(d1, func2s_unk2);
func2s_nvar2:
/* Uuuff, the second and third argument are bound */
if (IsIntegerTerm(d1))
d1 = IntegerOfTerm(d1);
else {
saveregs();
if (IsBigIntTerm(d1)) {
less invasive error handling
2016-10-19 22:44:59 -05:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK,d1);
split absmi
2015-01-18 03:00:19 +00:00
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER,d1);
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
if (!IsAtomicTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
XREG(PREG->y_u.xxx.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if ((Int)d1 > 0) {
split absmi
2015-01-18 03:00:19 +00:00
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt1);
if (!IsAtomTerm(d0)) {
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
split absmi
2015-01-18 03:00:19 +00:00
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
split absmi
2015-01-18 03:00:19 +00:00
/* make sure we have something to show for our trouble */
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, xxx), Osbpp))) {
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1 );
split absmi
2015-01-18 03:00:19 +00:00
JMPNext();
} else {
setregs();
}
goto restart_func2s;
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
HR = pt1;
/* done building the term */
ENDP(pt1);
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
XREG(PREG->y_u.xxx.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if ((Int)d1 == 0) {
split absmi
2015-01-18 03:00:19 +00:00
XREG(PREG->y_u.xxx.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
split absmi
2015-01-18 03:00:19 +00:00
}
BEGP(pt1);
deref_body(d1, pt1, func2s_unk2, func2s_nvar2);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
ENDD(d1);
BEGP(pt1);
deref_body(d0, pt1, func2s_unk, func2s_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2s_cv, xxc);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* A1 is a variable */
split absmi
2015-01-18 03:00:19 +00:00
restart_func2s_cv:
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
RESET_VARIABLE(HR);
HR[1] = PREG->y_u.xxc.c;
HR[2] = XREG(PREG->y_u.xxc.xi);
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
/* We have to build the structure */
d0 = PREG->y_u.xxc.c;
/* we do, let's get the third argument */
BEGD(d1);
d1 = XREG(PREG->y_u.xxc.xi);
deref_head(d1, func2s_unk2_cv);
func2s_nvar2_cv:
/* Uuuff, the second and third argument are bound */
if (IsIntegerTerm(d1))
d1 = IntegerOfTerm(d1);
else {
saveregs();
if (IsBigIntTerm(d1)) {
less invasive error handling
2016-10-19 22:44:59 -05:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
XREG(PREG->y_u.xxc.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt1);
if (!IsAtomTerm(d0)) {
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
split absmi
2015-01-18 03:00:19 +00:00
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
split absmi
2015-01-18 03:00:19 +00:00
/* make sure we have something to show for our trouble */
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, xxc), Osbpp))) {
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
JMPNext();
} else {
setregs();
}
goto restart_func2s_cv;
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
/* done building the term */
HR = pt1;
ENDP(pt1);
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
XREG(PREG->y_u.xxc.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (d1 == 0) {
split absmi
2015-01-18 03:00:19 +00:00
XREG(PREG->y_u.xxc.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,d1);
split absmi
2015-01-18 03:00:19 +00:00
}
BEGP(pt1);
deref_body(d1, pt1, func2s_unk2_cv, func2s_nvar2_cv);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_func2s_vc, xxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* A1 is a variable */
split absmi
2015-01-18 03:00:19 +00:00
restart_func2s_vc:
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
Term ti;
CELL *hi = HR;
ti = MkIntegerTerm(PREG->y_u.xxn.c);
RESET_VARIABLE(HR);
HR[1] = XREG(PREG->y_u.xxn.xi);
HR[2] = ti;
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
HR = hi;
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.xxn.xi);
deref_head(d0, func2s_unk_vc);
func2s_nvar_vc:
BEGD(d1);
d1 = PREG->y_u.xxn.c;
if (!IsAtomicTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
XREG(PREG->y_u.xxn.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
}
/* now let's build a compound term */
if (d1 == 0) {
XREG(PREG->y_u.xxn.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
}
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt1);
if (!IsAtomTerm(d0)) {
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
split absmi
2015-01-18 03:00:19 +00:00
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
split absmi
2015-01-18 03:00:19 +00:00
/* make sure we have something to show for our trouble */
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!Yap_gc(0, YREG, NEXTOP(NEXTOP(PREG, xxn), Osbpp))) {
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
JMPNext();
} else {
setregs();
}
goto restart_func2s_vc;
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
/* done building the term */
HR = pt1;
ENDP(pt1);
ENDD(d1);
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
XREG(PREG->y_u.xxn.x) = d0;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
BEGP(pt1);
deref_body(d0, pt1, func2s_unk_vc, func2s_nvar_vc);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2s_y_vv, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* A1 is a variable */
split absmi
2015-01-18 03:00:19 +00:00
restart_func2s_y:
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
RESET_VARIABLE(HR);
HR[1] = XREG(PREG->y_u.yxx.x1);
HR[2] = XREG(PREG->y_u.yxx.x2);
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.yxx.x1);
deref_head(d0, func2s_y_unk);
func2s_y_nvar:
/* we do, let's get the third argument */
BEGD(d1);
d1 = XREG(PREG->y_u.yxx.x2);
deref_head(d1, func2s_y_unk2);
func2s_y_nvar2:
/* Uuuff, the second and third argument are bound */
if (IsIntegerTerm(d1))
d1 = IntegerOfTerm(d1);
else {
saveregs();
if (IsBigIntTerm(d1)) {
less invasive error handling
2016-10-19 22:44:59 -05:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
if (!IsAtomicTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxx.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM, d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt1);
if (!IsAtomTerm(d0)) {
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
split absmi
2015-01-18 03:00:19 +00:00
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
split absmi
2015-01-18 03:00:19 +00:00
/* make sure we have something to show for our trouble */
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, yxx), Osbpp))) {
split absmi
2015-01-18 03:00:19 +00:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
JMPNext();
} else {
setregs();
}
goto restart_func2s_y;
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
/* done building the term */
HR = pt1;
ENDP(pt1);
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxx.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (d1 == 0) {
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxx.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
split absmi
2015-01-18 03:00:19 +00:00
}
BEGP(pt1);
deref_body(d1, pt1, func2s_y_unk2, func2s_y_nvar2);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
ENDD(d1);
BEGP(pt1);
deref_body(d0, pt1, func2s_y_unk, func2s_y_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2s_y_cv, yxc);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* A1 is a variable */
split absmi
2015-01-18 03:00:19 +00:00
restart_func2s_y_cv:
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
RESET_VARIABLE(HR);
HR[1] = PREG->y_u.yxc.c;
HR[2] = XREG(PREG->y_u.yxc.xi);
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = PREG->y_u.yxc.c;
/* we do, let's get the third argument */
BEGD(d1);
d1 = XREG(PREG->y_u.yxc.xi);
deref_head(d1, func2s_y_unk_cv);
func2s_y_nvar_cv:
/* Uuuff, the second and third argument are bound */
if (IsIntegerTerm(d1)) {
d1 = IntegerOfTerm(d1);
} else {
if (IsBigIntTerm(d1)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
split absmi
2015-01-18 03:00:19 +00:00
}
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxc.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxc), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if ((Int)d1 > 0) {
split absmi
2015-01-18 03:00:19 +00:00
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
if (!IsAtomTerm(d0)) {
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt1);
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
split absmi
2015-01-18 03:00:19 +00:00
/* make sure we have something to show for our trouble */
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, yxc), Osbpp))) {
split absmi
2015-01-18 03:00:19 +00:00
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
JMPNext();
} else {
setregs();
}
goto restart_func2s_y_cv;
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
/* done building the term */
HR = pt1;
ENDP(pt1);
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxc.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxc), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (d1 == 0) {
split absmi
2015-01-18 03:00:19 +00:00
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxc.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxc), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
split absmi
2015-01-18 03:00:19 +00:00
}
BEGP(pt1);
deref_body(d1, pt1, func2s_y_unk_cv, func2s_y_nvar_cv);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
ENDD(d1);
ENDD(d0);
ENDOp();
Op(p_func2s_y_vc, yxn);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* A1 is a variable */
split absmi
2015-01-18 03:00:19 +00:00
restart_func2s_y_vc:
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
Term ti;
CELL *hi = HR;
ti = MkIntegerTerm((Int)(PREG->y_u.yxn.c));
RESET_VARIABLE(HR);
HR[1] = XREG(PREG->y_u.yxn.xi);
HR[2] = ti;
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
HR = hi;
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.yxn.xi);
deref_head(d0, func2s_y_unk_vc);
func2s_y_nvar_vc:
BEGD(d1);
d1 = PREG->y_u.yxn.c;
if (!IsAtomicTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxn.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
}
if (d1 == 0) {
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxn.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
GONext();
}
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
BEGP(pt1);
if (!IsAtomTerm(d0)) {
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
split absmi
2015-01-18 03:00:19 +00:00
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
split absmi
2015-01-18 03:00:19 +00:00
/* make sure we have something to show for our trouble */
saveregs();
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, yxn), Osbpp))) {
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
split absmi
2015-01-18 03:00:19 +00:00
JMPNext();
} else {
setregs();
}
goto restart_func2s_y_vc;
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
/* done building the term */
HR = pt1;
ENDP(pt1);
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
BEGP(pt1);
pt1 = YREG + PREG->y_u.yxn.y;
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn), Osbpp), l);
INITIALIZE_PERMVAR(pt1, d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
ENDD(d1);
GONext();
BEGP(pt1);
deref_body(d0, pt1, func2s_y_unk_vc, func2s_y_nvar_vc);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2f_xx, xxx);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
HR[0] = XREG(PREG->y_u.xxx.x);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.xxx.x);
deref_head(d0, func2f_xx_unk);
func2f_xx_nvar:
if (IsApplTerm(d0)) {
Functor d1 = FunctorOfTerm(d0);
if (IsExtensionFunctor(d1)) {
XREG(PREG->y_u.xxx.x1) = d0;
XREG(PREG->y_u.xxx.x2) = MkIntTerm(0);
PREG = NEXTOP(PREG, xxx);
GONext();
}
XREG(PREG->y_u.xxx.x1) = MkAtomTerm(NameOfFunctor(d1));
XREG(PREG->y_u.xxx.x2) = MkIntegerTerm(ArityOfFunctor(d1));
PREG = NEXTOP(PREG, xxx);
GONext();
} else if (IsPairTerm(d0)) {
XREG(PREG->y_u.xxx.x1) = TermDot;
XREG(PREG->y_u.xxx.x2) = MkIntTerm(2);
PREG = NEXTOP(PREG, xxx);
GONext();
} else {
XREG(PREG->y_u.xxx.x1) = d0;
XREG(PREG->y_u.xxx.x2) = MkIntTerm(0);
PREG = NEXTOP(PREG, xxx);
GONext();
}
BEGP(pt1);
deref_body(d0, pt1, func2f_xx_unk, func2f_xx_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2f_xy, xxy);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
HR[0] = XREG(PREG->y_u.xxy.x);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.xxy.x);
deref_head(d0, func2f_xy_unk);
func2f_xy_nvar:
if (IsApplTerm(d0)) {
Functor d1 = FunctorOfTerm(d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.xxy.y2;
split absmi
2015-01-18 03:00:19 +00:00
if (IsExtensionFunctor(d1)) {
XREG(PREG->y_u.xxy.x1) = d0;
PREG = NEXTOP(PREG, xxy);
INITIALIZE_PERMVAR(pt0, MkIntTerm(0));
GONext();
}
XREG(PREG->y_u.xxy.x1) = MkAtomTerm(NameOfFunctor(d1));
PREG = NEXTOP(PREG, xxy);
INITIALIZE_PERMVAR(pt0, MkIntegerTerm(ArityOfFunctor(d1)));
GONext();
} else if (IsPairTerm(d0)) {
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.xxy.y2;
split absmi
2015-01-18 03:00:19 +00:00
XREG(PREG->y_u.xxy.x1) = TermDot;
PREG = NEXTOP(PREG, xxy);
INITIALIZE_PERMVAR(pt0, MkIntTerm(2));
GONext();
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.xxy.y2;
split absmi
2015-01-18 03:00:19 +00:00
XREG(PREG->y_u.xxy.x1) = d0;
PREG = NEXTOP(PREG, xxy);
INITIALIZE_PERMVAR(pt0, MkIntTerm(0));
GONext();
}
BEGP(pt1);
deref_body(d0, pt1, func2f_xy_unk, func2f_xy_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2f_yx, yxx);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
HR[0] = XREG(PREG->y_u.yxx.x2);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.yxx.x2);
deref_head(d0, func2f_yx_unk);
func2f_yx_nvar:
if (IsApplTerm(d0)) {
Functor d1 = FunctorOfTerm(d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.yxx.y;
split absmi
2015-01-18 03:00:19 +00:00
if (IsExtensionFunctor(d1)) {
XREG(PREG->y_u.yxx.x1) = MkIntTerm(0);
PREG = NEXTOP(PREG, yxx);
INITIALIZE_PERMVAR(pt0, d0);
GONext();
}
XREG(PREG->y_u.yxx.x1) = MkIntegerTerm(ArityOfFunctor(d1));
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1)));
split absmi
2015-01-18 03:00:19 +00:00
GONext();
} else if (IsPairTerm(d0)) {
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.yxx.y;
split absmi
2015-01-18 03:00:19 +00:00
XREG(PREG->y_u.yxx.x1) = MkIntTerm(2);
PREG = NEXTOP(PREG, yxx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, TermDot);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.yxx.y;
split absmi
2015-01-18 03:00:19 +00:00
XREG(PREG->y_u.yxx.x1) = MkIntTerm(0);
PREG = NEXTOP(PREG, yxx);
INITIALIZE_PERMVAR(pt0, d0);
GONext();
}
BEGP(pt1);
deref_body(d0, pt1, func2f_yx_unk, func2f_yx_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_func2f_yy, yyx);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) {
HR[0] = XREG(PREG->y_u.yyx.x);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
RESET_VARIABLE(HR + 2);
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
HR);
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
BEGD(d0);
d0 = XREG(PREG->y_u.yyx.x);
deref_head(d0, func2f_yy_unk);
func2f_yy_nvar:
if (IsApplTerm(d0)) {
Functor d1 = FunctorOfTerm(d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.yyx.y1;
CELL *pt1 = YREG + PREG->y_u.yyx.y2;
split absmi
2015-01-18 03:00:19 +00:00
if (IsExtensionFunctor(d1)) {
PREG = NEXTOP(PREG, yyx);
less invasive error handling
2016-10-19 22:44:59 -05:00
INITIALIZE_PERMVAR(pt0, d0);
split absmi
2015-01-18 03:00:19 +00:00
INITIALIZE_PERMVAR(pt1, MkIntTerm(0));
GONext();
}
PREG = NEXTOP(PREG, yyx);
INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1)));
INITIALIZE_PERMVAR(pt1, MkIntegerTerm(ArityOfFunctor(d1)));
GONext();
} else if (IsPairTerm(d0)) {
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.yyx.y1;
CELL *pt1 = YREG + PREG->y_u.yyx.y2;
split absmi
2015-01-18 03:00:19 +00:00
PREG = NEXTOP(PREG, yyx);
INITIALIZE_PERMVAR(pt0, TermDot);
INITIALIZE_PERMVAR(pt1, MkIntTerm(2));
GONext();
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
CELL *pt0 = YREG + PREG->y_u.yyx.y1;
CELL *pt1 = YREG + PREG->y_u.yyx.y2;
split absmi
2015-01-18 03:00:19 +00:00
PREG = NEXTOP(PREG, yyx);
INITIALIZE_PERMVAR(pt0, d0);
INITIALIZE_PERMVAR(pt1, MkIntTerm(0));
GONext();
}
BEGP(pt1);
deref_body(d0, pt1, func2f_yy_unk, func2f_yy_nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDD(d0);
ENDOp();
Op(p_functor, e);
#ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace)
less invasive error handling
2016-10-19 22:44:59 -05:00
low_level_trace(enter_pred,
RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
XREGS + 1);
#endif /* LOW_LEVEL_TRACE */
split absmi
2015-01-18 03:00:19 +00:00
restart_functor:
BEGD(d0);
d0 = ARG1;
deref_head(d0, func_unk);
func_nvar:
/* A1 is bound */
BEGD(d1);
if (IsApplTerm(d0)) {
d1 = *RepAppl(d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
if (IsExtensionFunctor((Functor)d1)) {
if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt) {
split absmi
2015-01-18 03:00:19 +00:00
d1 = MkIntTerm(0);
} else
FAIL();
} else {
less invasive error handling
2016-10-19 22:44:59 -05:00
d0 = MkAtomTerm(NameOfFunctor((Functor)d1));
d1 = MkIntTerm(ArityOfFunctor((Functor)d1));
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if (IsPairTerm(d0)) {
split absmi
2015-01-18 03:00:19 +00:00
d0 = TermDot;
d1 = MkIntTerm(2);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
split absmi
2015-01-18 03:00:19 +00:00
d1 = MkIntTerm(0);
}
/* d1 and d0 now have the two arguments */
/* let's go and bind them */
{
register CELL arity = d1;
d1 = ARG2;
deref_head(d1, func_nvar_unk);
func_nvar_nvar:
/* A2 was bound */
if (d0 != d1) {
JIT
2015-01-20 03:00:42 +00:00
FAIL();
split absmi
2015-01-18 03:00:19 +00:00
}
less invasive error handling
2016-10-19 22:44:59 -05:00
/* I have to this here so that I don't have a jump to a closing bracket
*/
split absmi
2015-01-18 03:00:19 +00:00
d0 = arity;
goto func_bind_x3;
BEGP(pt0);
deref_body(d1, pt0, func_nvar_unk, func_nvar_nvar);
/* A2 is a variable, go and bind it */
YapBind(pt0, d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
/* I have to this here so that I don't have a jump to a closing bracket
*/
split absmi
2015-01-18 03:00:19 +00:00
d0 = arity;
ENDP(pt0);
func_bind_x3:
/* now let's process A3 */
d1 = ARG3;
deref_head(d1, func_nvar3_unk);
func_nvar3_nvar:
/* A3 was bound */
if (d0 != d1) {
FAIL();
}
/* Done */
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e), Osbmp), l);
split absmi
2015-01-18 03:00:19 +00:00
GONext();
BEGP(pt0);
deref_body(d1, pt0, func_nvar3_unk, func_nvar3_nvar);
/* A3 is a variable, go and bind it */
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e), Osbmp), l);
split absmi
2015-01-18 03:00:19 +00:00
YapBind(pt0, d0);
/* Done */
GONext();
ENDP(pt0);
}
ENDD(d1);
BEGP(pt0);
deref_body(d0, pt0, func_unk, func_nvar);
/* A1 is a variable */
/* We have to build the structure */
d0 = ARG2;
deref_head(d0, func_var_2unk);
func_var_2nvar:
/* we do, let's get the third argument */
BEGD(d1);
d1 = ARG3;
deref_head(d1, func_var_3unk);
func_var_3nvar:
/* Uuuff, the second and third argument are bound */
if (IsIntTerm(d1))
d1 = IntOfTerm(d1);
else {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
}
if (!IsAtomicTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
split absmi
2015-01-18 03:00:19 +00:00
FAIL();
less invasive error handling
2016-10-19 22:44:59 -05:00
} /* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
split absmi
2015-01-18 03:00:19 +00:00
if (d0 == TermDot && d1 == 2) {
RESET_VARIABLE(HR);
less invasive error handling
2016-10-19 22:44:59 -05:00
RESET_VARIABLE(HR + 1);
split absmi
2015-01-18 03:00:19 +00:00
d0 = AbsPair(HR);
HR += 2;
less invasive error handling
2016-10-19 22:44:59 -05:00
} else if ((Int)d1 > 0) {
split absmi
2015-01-18 03:00:19 +00:00
/* now let's build a compound term */
less invasive error handling
2016-10-19 22:44:59 -05:00
if (!IsAtomTerm(d0)) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(TYPE_ERROR_ATOM,d0);
less invasive error handling
2016-10-19 22:44:59 -05:00
FAIL();
}
BEGP(pt1);
if (!IsAtomTerm(d0)) {
FAIL();
} else
d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
pt1 = HR;
*pt1++ = d0;
d0 = AbsAppl(HR);
if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
/* make sure we have something to show for our trouble */
saveregs();
if (!Yap_gcl((1 + d1) * sizeof(CELL), 3, YREG,
NEXTOP(NEXTOP(PREG, e), Osbmp))) {
setregs();
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
less invasive error handling
2016-10-19 22:44:59 -05:00
} else {
setregs();
}
goto restart_functor; /* */
}
while ((Int)d1--) {
RESET_VARIABLE(pt1);
pt1++;
}
/* done building the term */
HR = pt1;
ENDP(pt1);
} else if ((Int)d1 < 0) {
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
less invasive error handling
2016-10-19 22:44:59 -05:00
FAIL();
split absmi
2015-01-18 03:00:19 +00:00
}
/* else if arity is 0 just pass d0 through */
/* Ding, ding, we made it */
less invasive error handling
2016-10-19 22:44:59 -05:00
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e), Osbpp), l);
split absmi
2015-01-18 03:00:19 +00:00
YapBind(pt0, d0);
GONext();
BEGP(pt1);
deref_body(d1, pt1, func_var_3unk, func_var_3nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d1);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
ENDD(d1);
BEGP(pt1);
deref_body(d0, pt1, func_var_2unk, func_var_2nvar);
fixes + win64
2016-11-08 01:37:36 -06:00
Yap_AsmError(INSTANTIATION_ERROR,d0);
split absmi
2015-01-18 03:00:19 +00:00
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
ENDP(pt0);
ENDD(d0);
ENDOp();
Reference in New Issue Copy Permalink