YAP 7.1.0
prim_absmi_insts.h
1/************************************************************************ \
2 * Basic Primitive Predicates *
3\************************************************************************/
4
5#ifdef INDENT_CODE
6{
7 {
8 {
9#endif /* INDENT_CODE */
10
11 Op(p_plus_vv, xxx);
12 BEGD(d0);
13 BEGD(d1);
14 d0 = XREG(PREG->y_u.xxx.x1);
15 /* first check pt1 */
16 deref_head(d0, plus_vv_unk);
17 plus_vv_nvar:
18 d1 = XREG(PREG->y_u.xxx.x2);
19 /* next check A2 */
20 deref_head(d1, plus_vv_nvar_unk);
21 plus_vv_nvar_nvar:
22 /* d0 and d1 are where I want them */
23 if (IsIntTerm(d0) && IsIntTerm(d1)) {
24 d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1));
25 } else {
26 saveregs();
27 d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
28 setregs();
29 }
30 XREG(PREG->y_u.xxx.x) = d0;
31 PREG = NEXTOP(PREG, xxx);
32 GONext();
33
34 BEGP(pt0);
35 deref_body(d0, pt0, plus_vv_unk, plus_vv_nvar);
36 Yap_AsmError(INSTANTIATION_ERROR, d0);
37 FAIL();
38 ENDP(pt0);
39
40 BEGP(pt0);
41 deref_body(d1, pt0, plus_vv_nvar_unk, plus_vv_nvar_nvar);
42 Yap_AsmError(INSTANTIATION_ERROR, d1);
43 FAIL();
44 ENDP(pt0);
45 ENDD(d1);
46 ENDD(d0);
47 ENDOp();
48
49 Op(p_plus_vc, xxn);
50 BEGD(d0);
51 d0 = XREG(PREG->y_u.xxn.xi);
52 /* first check pt1 */
53 deref_head(d0, plus_vc_unk);
54 plus_vc_nvar : {
55 Int d1 = PREG->y_u.xxn.c;
56 if (IsIntTerm(d0)) {
57 d0 = MkIntegerTerm(IntOfTerm(d0) + d1);
58 } else {
59 saveregs();
60 d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
61 setregs();
62 }
63 }
64 XREG(PREG->y_u.xxn.x) = d0;
65 PREG = NEXTOP(PREG, xxn);
66 GONext();
67
68 BEGP(pt0);
69 deref_body(d0, pt0, plus_vc_unk, plus_vc_nvar);
70 Yap_AsmError(INSTANTIATION_ERROR, d0);
71 FAIL();
72 ENDP(pt0);
73 ENDD(d0);
74 ENDOp();
75
76 Op(p_plus_y_vv, yxx);
77 BEGD(d0);
78 BEGD(d1);
79 d0 = XREG(PREG->y_u.yxx.x1);
80 /* first check pt1 */
81 deref_head(d0, plus_y_vv_unk);
82 plus_y_vv_nvar:
83 d1 = XREG(PREG->y_u.xxx.x2);
84 /* next check A2 */
85 deref_head(d1, plus_y_vv_nvar_unk);
86 plus_y_vv_nvar_nvar:
87 /* d0 and d1 are where I want them */
88 if (IsIntTerm(d0) && IsIntTerm(d1)) {
89 d0 = MkIntegerTerm(IntOfTerm(d0) + IntOfTerm(d1));
90 } else {
91 saveregs();
92 d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
93 setregs();
94 }
95 BEGP(pt0);
96 pt0 = YREG + PREG->y_u.yxx.y;
97 PREG = NEXTOP(PREG, yxx);
98 INITIALIZE_PERMVAR(pt0, d0);
99 ENDP(pt0);
100 GONext();
101
102 BEGP(pt0);
103 deref_body(d0, pt0, plus_y_vv_unk, plus_y_vv_nvar);
104 Yap_AsmError(INSTANTIATION_ERROR, d0);
105 FAIL();
106 ENDP(pt0);
107
108 BEGP(pt0);
109 deref_body(d1, pt0, plus_y_vv_nvar_unk, plus_y_vv_nvar_nvar);
110 Yap_AsmError(INSTANTIATION_ERROR, d1);
111 FAIL();
112 ENDP(pt0);
113 ENDD(d1);
114 ENDD(d0);
115 ENDOp();
116
117 Op(p_plus_y_vc, yxn);
118 BEGD(d0);
119 d0 = XREG(PREG->y_u.yxn.xi);
120 /* first check pt1 */
121 deref_head(d0, plus_y_vc_unk);
122 plus_y_vc_nvar : {
123 Int d1 = PREG->y_u.yxn.c;
124 if (IsIntTerm(d0)) {
125 d0 = MkIntegerTerm(IntOfTerm(d0) + d1);
126 } else {
127 saveregs();
128 d0 = p_plus(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
129 setregs();
130 }
131 }
132 BEGP(pt0);
133 pt0 = YREG + PREG->y_u.yxn.y;
134 PREG = NEXTOP(PREG, yxn);
135 INITIALIZE_PERMVAR(pt0, d0);
136 ENDP(pt0);
137 GONext();
138
139 BEGP(pt0);
140 deref_body(d0, pt0, plus_y_vc_unk, plus_y_vc_nvar);
141 Yap_AsmError(INSTANTIATION_ERROR, d0);
142 FAIL();
143 ENDP(pt0);
144 ENDD(d0);
145 ENDOp();
146
147 Op(p_minus_vv, xxx);
148 BEGD(d0);
149 BEGD(d1);
150 d0 = XREG(PREG->y_u.xxx.x1);
151 /* first check pt1 */
152 deref_head(d0, minus_vv_unk);
153 minus_vv_nvar:
154 d1 = XREG(PREG->y_u.xxx.x2);
155 /* next check A2 */
156 deref_head(d1, minus_vv_nvar_unk);
157 minus_vv_nvar_nvar:
158 /* d0 and d1 are where I want them */
159 if (IsIntTerm(d0) && IsIntTerm(d1)) {
160 d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1));
161 } else {
162 saveregs();
163 d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
164 setregs();
165 }
166 XREG(PREG->y_u.xxx.x) = d0;
167 PREG = NEXTOP(PREG, xxx);
168 GONext();
169
170 BEGP(pt0);
171 deref_body(d0, pt0, minus_vv_unk, minus_vv_nvar);
172 Yap_AsmError(INSTANTIATION_ERROR,d0);
173 FAIL();
174 ENDP(pt0);
175
176 BEGP(pt0);
177 deref_body(d1, pt0, minus_vv_nvar_unk, minus_vv_nvar_nvar);
178 Yap_AsmError(INSTANTIATION_ERROR, d0);
179 FAIL();
180 ENDP(pt0);
181 ENDD(d1);
182 ENDD(d0);
183 ENDOp();
184
185 Op(p_minus_cv, xxn);
186 BEGD(d0);
187 d0 = XREG(PREG->y_u.xxn.xi);
188 /* first check pt1 */
189 deref_head(d0, minus_cv_unk);
190 minus_cv_nvar : {
191 Int d1 = PREG->y_u.xxn.c;
192 if (IsIntTerm(d0)) {
193 d0 = MkIntegerTerm(d1 - IntOfTerm(d0));
194 } else {
195 saveregs();
196 d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
197 setregs();
198 }
199 }
200 XREG(PREG->y_u.xxn.x) = d0;
201 PREG = NEXTOP(PREG, xxn);
202 GONext();
203
204 BEGP(pt0);
205 deref_body(d0, pt0, minus_cv_unk, minus_cv_nvar);
206 Yap_AsmError(INSTANTIATION_ERROR, d0);
207 FAIL();
208 ENDP(pt0);
209 ENDD(d0);
210 ENDOp();
211
212 Op(p_minus_y_vv, yxx);
213 BEGD(d0);
214 BEGD(d1);
215 d0 = XREG(PREG->y_u.yxx.x1);
216 /* first check pt1 */
217 deref_head(d0, minus_y_vv_unk);
218 minus_y_vv_nvar:
219 d1 = XREG(PREG->y_u.xxx.x2);
220 /* next check A2 */
221 deref_head(d1, minus_y_vv_nvar_unk);
222 minus_y_vv_nvar_nvar:
223 /* d0 and d1 are where I want them */
224 if (IsIntTerm(d0) && IsIntTerm(d1)) {
225 d0 = MkIntegerTerm(IntOfTerm(d0) - IntOfTerm(d1));
226 } else {
227 saveregs();
228 d0 = p_minus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
229 setregs();
230 }
231 BEGP(pt0);
232 pt0 = YREG + PREG->y_u.yxx.y;
233 PREG = NEXTOP(PREG, yxx);
234 INITIALIZE_PERMVAR(pt0, d0);
235 ENDP(pt0);
236 GONext();
237
238 BEGP(pt0);
239 deref_body(d0, pt0, minus_y_vv_unk, minus_y_vv_nvar);
240 Yap_AsmError(INSTANTIATION_ERROR, d0);
241 FAIL();
242 ENDP(pt0);
243
244 BEGP(pt0);
245 deref_body(d1, pt0, minus_y_vv_nvar_unk, minus_y_vv_nvar_nvar);
246 Yap_AsmError(INSTANTIATION_ERROR, d1);
247 FAIL();
248 ENDP(pt0);
249 ENDD(d1);
250 ENDD(d0);
251 ENDOp();
252
253 Op(p_minus_y_cv, yxn);
254 BEGD(d0);
255 d0 = XREG(PREG->y_u.yxn.xi);
256 /* first check pt1 */
257 deref_head(d0, minus_y_cv_unk);
258 minus_y_cv_nvar : {
259 Int d1 = PREG->y_u.yxn.c;
260 if (IsIntTerm(d0)) {
261 d0 = MkIntegerTerm(d1 - IntOfTerm(d0));
262 } else {
263 saveregs();
264 d0 = p_minus(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
265 setregs();
266 }
267 }
268 BEGP(pt0);
269 pt0 = YREG + PREG->y_u.yxn.y;
270 PREG = NEXTOP(PREG, yxn);
271 INITIALIZE_PERMVAR(pt0, d0);
272 ENDP(pt0);
273 GONext();
274
275 BEGP(pt0);
276 deref_body(d0, pt0, minus_y_cv_unk, minus_y_cv_nvar);
277 Yap_AsmError(INSTANTIATION_ERROR,d0);
278 FAIL();
279 ENDP(pt0);
280 ENDD(d0);
281 ENDOp();
282
283 Op(p_times_vv, xxx);
284 BEGD(d0);
285 BEGD(d1);
286 d0 = XREG(PREG->y_u.xxx.x1);
287 /* first check pt1 */
288 deref_head(d0, times_vv_unk);
289 times_vv_nvar:
290 d1 = XREG(PREG->y_u.xxx.x2);
291 /* next check A2 */
292 deref_head(d1, times_vv_nvar_unk);
293 times_vv_nvar_nvar:
294 /* d0 and d1 are where I want them */
295 if (IsIntTerm(d0) && IsIntTerm(d1)) {
296 d0 = times_int(IntOfTerm(d0), IntOfTerm(d1) PASS_REGS);
297 } else {
298 saveregs();
299 d0 = p_times(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
300 }
301 XREG(PREG->y_u.xxx.x) = d0;
302 PREG = NEXTOP(PREG, xxx);
303 GONext();
304
305 BEGP(pt0);
306 deref_body(d0, pt0, times_vv_unk, times_vv_nvar);
307 Yap_AsmError(INSTANTIATION_ERROR,d0);
308 FAIL();
309 ENDP(pt0);
310
311 BEGP(pt0);
312 deref_body(d1, pt0, times_vv_nvar_unk, times_vv_nvar_nvar);
313 Yap_AsmError(INSTANTIATION_ERROR,d1);
314 FAIL();
315 ENDP(pt0);
316 ENDD(d1);
317 ENDD(d0);
318 ENDOp();
319
320 Op(p_times_vc, xxn);
321 BEGD(d0);
322 d0 = XREG(PREG->y_u.xxn.xi);
323 /* first check pt1 */
324 deref_head(d0, times_vc_unk);
325 times_vc_nvar : {
326 Int d1 = PREG->y_u.xxn.c;
327 if (IsIntTerm(d0)) {
328 d0 = times_int(IntOfTerm(d0), d1 PASS_REGS);
329 } else {
330 saveregs();
331 d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
332 setregs();
333 }
334 }
335 XREG(PREG->y_u.xxn.x) = d0;
336 PREG = NEXTOP(PREG, xxn);
337 GONext();
338
339 BEGP(pt0);
340 deref_body(d0, pt0, times_vc_unk, times_vc_nvar);
341 Yap_AsmError(INSTANTIATION_ERROR,d0);
342 FAIL();
343 ENDP(pt0);
344 ENDD(d0);
345 ENDOp();
346
347 Op(p_times_y_vv, yxx);
348 BEGD(d0);
349 BEGD(d1);
350 d0 = XREG(PREG->y_u.yxx.x1);
351 /* first check pt1 */
352 deref_head(d0, times_y_vv_unk);
353 times_y_vv_nvar:
354 d1 = XREG(PREG->y_u.xxx.x2);
355 /* next check A2 */
356 deref_head(d1, times_y_vv_nvar_unk);
357 times_y_vv_nvar_nvar:
358 /* d0 and d1 are where I want them */
359 if (IsIntTerm(d0) && IsIntTerm(d1)) {
360 d0 = times_int(IntOfTerm(d0), IntOfTerm(d1) PASS_REGS);
361 } else {
362 saveregs();
363 d0 = p_times(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
364 setregs();
365 }
366 BEGP(pt0);
367 pt0 = YREG + PREG->y_u.yxx.y;
368 PREG = NEXTOP(PREG, yxx);
369 INITIALIZE_PERMVAR(pt0, d0);
370 ENDP(pt0);
371 GONext();
372
373 BEGP(pt0);
374 deref_body(d0, pt0, times_y_vv_unk, times_y_vv_nvar);
375 Yap_AsmError(INSTANTIATION_ERROR,d0);
376 FAIL();
377 ENDP(pt0);
378
379 BEGP(pt0);
380 deref_body(d1, pt0, times_y_vv_nvar_unk, times_y_vv_nvar_nvar);
381 Yap_AsmError(INSTANTIATION_ERROR,d1);
382 FAIL();
383 ENDP(pt0);
384 ENDD(d1);
385 ENDD(d0);
386 ENDOp();
387
388 Op(p_times_y_vc, yxn);
389 BEGD(d0);
390 d0 = XREG(PREG->y_u.yxn.xi);
391 /* first check pt1 */
392 deref_head(d0, times_y_vc_unk);
393 times_y_vc_nvar : {
394 Int d1 = PREG->y_u.yxn.c;
395 if (IsIntTerm(d0)) {
396 d0 = times_int(IntOfTerm(d0), d1 PASS_REGS);
397 } else {
398 saveregs();
399 d0 = p_times(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
400 setregs();
401 }
402 }
403 BEGP(pt0);
404 pt0 = YREG + PREG->y_u.yxn.y;
405 PREG = NEXTOP(PREG, yxn);
406 INITIALIZE_PERMVAR(pt0, d0);
407 ENDP(pt0);
408 GONext();
409
410 BEGP(pt0);
411 deref_body(d0, pt0, times_y_vc_unk, times_y_vc_nvar);
412 Yap_AsmError(INSTANTIATION_ERROR,d0);
413 FAIL();
414 ENDP(pt0);
415 ENDD(d0);
416 ENDOp();
417
418 Op(p_div_vv, xxx);
419 BEGD(d0);
420 BEGD(d1);
421 d0 = XREG(PREG->y_u.xxx.x1);
422 /* first check pt1 */
423 deref_head(d0, div_vv_unk);
424 div_vv_nvar:
425 d1 = XREG(PREG->y_u.xxx.x2);
426 /* next check A2 */
427 deref_head(d1, div_vv_nvar_unk);
428 div_vv_nvar_nvar:
429 /* d0 and d1 are where I want them */
430 if (IsIntTerm(d0) && IsIntTerm(d1)) {
431 Int div = IntOfTerm(d1);
432 if (div == 0) {
433 Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d1);
434 }
435 d0 = MkIntTerm(IntOfTerm(d0) / div);
436 } else {
437 saveregs();
438 d0 = p_div(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
439 setregs();
440 }
441 XREG(PREG->y_u.xxx.x) = d0;
442 PREG = NEXTOP(PREG, xxx);
443 GONext();
444
445 BEGP(pt0);
446 deref_body(d0, pt0, div_vv_unk, div_vv_nvar);
447 Yap_AsmError(INSTANTIATION_ERROR,d0);
448 FAIL();
449 ENDP(pt0);
450
451 BEGP(pt0);
452 deref_body(d1, pt0, div_vv_nvar_unk, div_vv_nvar_nvar);
453 Yap_AsmError(INSTANTIATION_ERROR,d1);
454 FAIL();
455 ENDP(pt0);
456 ENDD(d1);
457 ENDD(d0);
458 ENDOp();
459
460 Op(p_div_vc, xxn);
461 BEGD(d0);
462 d0 = XREG(PREG->y_u.xxn.xi);
463 /* first check pt1 */
464 deref_head(d0, div_vc_unk);
465 div_vc_nvar : {
466 Int d1 = PREG->y_u.xxn.c;
467 if (IsIntTerm(d0)) {
468 d0 = MkIntTerm(IntOfTerm(d0) / d1);
469 } else {
470 saveregs();
471 d0 = p_div(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
472 setregs();
473 }
474 }
475 XREG(PREG->y_u.xxn.x) = d0;
476 PREG = NEXTOP(PREG, xxn);
477 GONext();
478
479 BEGP(pt0);
480 deref_body(d0, pt0, div_vc_unk, div_vc_nvar);
481 Yap_AsmError(INSTANTIATION_ERROR,d0);
482 FAIL();
483 ENDP(pt0);
484 ENDD(d0);
485 ENDOp();
486
487 Op(p_div_cv, xxn);
488 BEGD(d0);
489 d0 = XREG(PREG->y_u.xxn.xi);
490 /* first check pt1 */
491 deref_head(d0, div_cv_unk);
492 div_cv_nvar : {
493 Int d1 = PREG->y_u.xxn.c;
494 if (IsIntTerm(d0)) {
495 Int div = IntOfTerm(d0);
496 if (div == 0) {
497 Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d0);
498 FAIL();
499 }
500 d0 = MkIntegerTerm(d1 / div);
501 } else {
502 saveregs();
503 d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
504 }
505 }
506 XREG(PREG->y_u.xxn.x) = d0;
507 PREG = NEXTOP(PREG, xxn);
508 GONext();
509
510 BEGP(pt0);
511 deref_body(d0, pt0, div_cv_unk, div_cv_nvar);
512 Yap_AsmError(INSTANTIATION_ERROR,d0);
513 FAIL();
514 ENDP(pt0);
515 ENDD(d0);
516 ENDOp();
517
518 Op(p_div_y_vv, yxx);
519 BEGD(d0);
520 BEGD(d1);
521 d0 = XREG(PREG->y_u.yxx.x1);
522 /* first check pt1 */
523 deref_head(d0, div_y_vv_unk);
524 div_y_vv_nvar:
525 d1 = XREG(PREG->y_u.xxx.x2);
526 /* next check A2 */
527 deref_head(d1, div_y_vv_nvar_unk);
528 div_y_vv_nvar_nvar:
529 /* d0 and d1 are where I want them */
530 if (IsIntTerm(d0) && IsIntTerm(d1)) {
531 Int div = IntOfTerm(d1);
532 if (div == 0) {
533 Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR, d0);
534 FAIL();
535 }
536 d0 = MkIntTerm(IntOfTerm(d0) / div);
537 } else {
538 saveregs();
539 d0 = p_div(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
540 setregs();
541 }
542 BEGP(pt0);
543 pt0 = YREG + PREG->y_u.yxx.y;
544 PREG = NEXTOP(PREG, yxx);
545 INITIALIZE_PERMVAR(pt0, d0);
546 ENDP(pt0);
547 GONext();
548
549 BEGP(pt0);
550 deref_body(d0, pt0, div_y_vv_unk, div_y_vv_nvar);
551 Yap_AsmError(INSTANTIATION_ERROR,d0);
552 FAIL();
553 ENDP(pt0);
554
555 BEGP(pt0);
556 deref_body(d1, pt0, div_y_vv_nvar_unk, div_y_vv_nvar_nvar);
557 Yap_AsmError(INSTANTIATION_ERROR,d1);
558 FAIL();
559 ENDP(pt0);
560 ENDD(d1);
561 ENDD(d0);
562 ENDOp();
563
564 Op(p_div_y_vc, yxn);
565 BEGD(d0);
566 d0 = XREG(PREG->y_u.yxn.xi);
567 /* first check pt1 */
568 deref_head(d0, div_y_vc_unk);
569 div_y_vc_nvar : {
570 Int d1 = PREG->y_u.yxn.c;
571 if (IsIntTerm(d0)) {
572 d0 = MkIntTerm(IntOfTerm(d0) / d1);
573 } else {
574 saveregs();
575 d0 = p_div(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
576 setregs();
577 }
578 }
579 BEGP(pt0);
580 pt0 = YREG + PREG->y_u.yxn.y;
581 PREG = NEXTOP(PREG, yxn);
582 INITIALIZE_PERMVAR(pt0, d0);
583 ENDP(pt0);
584 GONext();
585
586 BEGP(pt0);
587 deref_body(d0, pt0, div_y_vc_unk, div_y_vc_nvar);
588 Yap_AsmError(INSTANTIATION_ERROR,d0);
589 FAIL();
590 ENDP(pt0);
591 ENDD(d0);
592 ENDOp();
593
594 Op(p_div_y_cv, yxn);
595 BEGD(d0);
596 d0 = XREG(PREG->y_u.yxn.xi);
597 /* first check pt1 */
598 deref_head(d0, div_y_cv_unk);
599 div_y_cv_nvar : {
600 Int d1 = PREG->y_u.yxn.c;
601 if (IsIntTerm(d0)) {
602 Int div = IntOfTerm(d0);
603 if (div == 0) {
604 Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d0);
605 FAIL();
606 }
607 d0 = MkIntegerTerm(d1 / div);
608 } else {
609 saveregs();
610 d0 = p_div(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
611 setregs();
612 }
613 }
614 BEGP(pt0);
615 pt0 = YREG + PREG->y_u.yxn.y;
616 PREG = NEXTOP(PREG, yxn);
617 INITIALIZE_PERMVAR(pt0, d0);
618 ENDP(pt0);
619 GONext();
620
621 BEGP(pt0);
622 deref_body(d0, pt0, div_y_cv_unk, div_y_cv_nvar);
623 Yap_AbsmiError(INSTANTIATION_ERROR);
624 FAIL();
625 ENDP(pt0);
626 ENDD(d0);
627 ENDOp();
628
629 Op(p_and_vv, xxx);
630 BEGD(d0);
631 BEGD(d1);
632 d0 = XREG(PREG->y_u.xxx.x1);
633 /* first check pt1 */
634 deref_head(d0, and_vv_unk);
635 and_vv_nvar:
636 d1 = XREG(PREG->y_u.xxx.x2);
637 /* next check A2 */
638 deref_head(d1, and_vv_nvar_unk);
639 and_vv_nvar_nvar:
640 /* d0 and d1 are where I want them */
641 if (IsIntTerm(d0) && IsIntTerm(d1)) {
642 d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1));
643 } else {
644 saveregs();
645 d0 = p_and(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
646 setregs();
647 }
648 XREG(PREG->y_u.xxx.x) = d0;
649 PREG = NEXTOP(PREG, xxx);
650 GONext();
651
652 BEGP(pt0);
653 deref_body(d0, pt0, and_vv_unk, and_vv_nvar);
654 Yap_AsmError(INSTANTIATION_ERROR,d0);
655 FAIL();
656 ENDP(pt0);
657
658 BEGP(pt0);
659 deref_body(d1, pt0, and_vv_nvar_unk, and_vv_nvar_nvar);
660 Yap_AsmError(INSTANTIATION_ERROR,d1);
661 FAIL();
662 ENDP(pt0);
663 ENDD(d1);
664 ENDD(d0);
665 ENDOp();
666
667 Op(p_and_vc, xxn);
668 BEGD(d0);
669 d0 = XREG(PREG->y_u.xxn.xi);
670 /* first check pt1 */
671 deref_head(d0, and_vc_unk);
672 and_vc_nvar : {
673 Int d1 = PREG->y_u.xxn.c;
674 if (IsIntTerm(d0)) {
675 d0 = MkIntegerTerm(IntOfTerm(d0) & d1);
676 } else {
677 saveregs();
678 d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
679 setregs();
680 }
681 }
682 XREG(PREG->y_u.xxn.x) = d0;
683 PREG = NEXTOP(PREG, xxn);
684 GONext();
685
686 BEGP(pt0);
687 deref_body(d0, pt0, and_vc_unk, and_vc_nvar);
688 Yap_AbsmiError(INSTANTIATION_ERROR);
689 FAIL();
690 ENDP(pt0);
691 ENDD(d0);
692 ENDOp();
693
694 Op(p_and_y_vv, yxx);
695 BEGD(d0);
696 BEGD(d1);
697 d0 = XREG(PREG->y_u.yxx.x1);
698 /* first check pt1 */
699 deref_head(d0, and_y_vv_unk);
700 and_y_vv_nvar:
701 d1 = XREG(PREG->y_u.xxx.x2);
702 /* next check A2 */
703 deref_head(d1, and_y_vv_nvar_unk);
704 and_y_vv_nvar_nvar:
705 /* d0 and d1 are where I want them */
706 if (IsIntTerm(d0) && IsIntTerm(d1)) {
707 d0 = MkIntegerTerm(IntOfTerm(d0) & IntOfTerm(d1));
708 } else {
709 saveregs();
710 d0 = p_and(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
711 setregs();
712 }
713 BEGP(pt0);
714 pt0 = YREG + PREG->y_u.yxx.y;
715 PREG = NEXTOP(PREG, yxx);
716 INITIALIZE_PERMVAR(pt0, d0);
717 ENDP(pt0);
718 GONext();
719
720 BEGP(pt0);
721 deref_body(d0, pt0, and_y_vv_unk, and_y_vv_nvar);
722 Yap_AsmError(INSTANTIATION_ERROR,d0);
723 FAIL();
724 ENDP(pt0);
725
726 BEGP(pt0);
727 deref_body(d1, pt0, and_y_vv_nvar_unk, and_y_vv_nvar_nvar);
728 Yap_AsmError(INSTANTIATION_ERROR,d1);
729 FAIL();
730 ENDP(pt0);
731 ENDD(d1);
732 ENDD(d0);
733 ENDOp();
734
735 Op(p_and_y_vc, yxn);
736 BEGD(d0);
737 d0 = XREG(PREG->y_u.yxn.xi);
738 /* first check pt1 */
739 deref_head(d0, and_y_vc_unk);
740 and_y_vc_nvar : {
741 Int d1 = PREG->y_u.yxn.c;
742 if (IsIntTerm(d0)) {
743 d0 = MkIntegerTerm(IntOfTerm(d0) & d1);
744 } else {
745 saveregs();
746 d0 = p_and(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
747 setregs();
748 }
749 }
750 BEGP(pt0);
751 pt0 = YREG + PREG->y_u.yxn.y;
752 PREG = NEXTOP(PREG, yxn);
753 INITIALIZE_PERMVAR(pt0, d0);
754 ENDP(pt0);
755 GONext();
756
757 BEGP(pt0);
758 deref_body(d0, pt0, and_y_vc_unk, and_y_vc_nvar);
759 Yap_AbsmiError(INSTANTIATION_ERROR);
760 FAIL();
761 ENDP(pt0);
762 ENDD(d0);
763 ENDOp();
764
765 Op(p_or_vv, xxx);
766 BEGD(d0);
767 BEGD(d1);
768 d0 = XREG(PREG->y_u.xxx.x1);
769 /* first check pt1 */
770 deref_head(d0, or_vv_unk);
771 or_vv_nvar:
772 d1 = XREG(PREG->y_u.xxx.x2);
773 /* next check A2 */
774 deref_head(d1, or_vv_nvar_unk);
775 or_vv_nvar_nvar:
776 /* d0 and d1 are where I want them */
777 if (IsIntTerm(d0) && IsIntTerm(d1)) {
778 d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1));
779 } else {
780 saveregs();
781 d0 = p_or(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
782 setregs();
783 }
784 XREG(PREG->y_u.xxx.x) = d0;
785 PREG = NEXTOP(PREG, xxx);
786 GONext();
787
788 BEGP(pt0);
789 deref_body(d0, pt0, or_vv_unk, or_vv_nvar);
790 Yap_AsmError(INSTANTIATION_ERROR,d0);
791 FAIL();
792 ENDP(pt0);
793
794 BEGP(pt0);
795 deref_body(d1, pt0, or_vv_nvar_unk, or_vv_nvar_nvar);
796 Yap_AsmError(INSTANTIATION_ERROR,d1);
797 FAIL();
798 ENDP(pt0);
799 ENDD(d1);
800 ENDD(d0);
801 ENDOp();
802
803 Op(p_or_vc, xxn);
804 BEGD(d0);
805 d0 = XREG(PREG->y_u.xxn.xi);
806 /* first check pt1 */
807 deref_head(d0, or_vc_unk);
808 or_vc_nvar : {
809 Int d1 = PREG->y_u.xxn.c;
810 if (IsIntTerm(d0)) {
811 d0 = MkIntegerTerm(IntOfTerm(d0) | d1);
812 } else {
813 saveregs();
814 d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
815 }
816 }
817 XREG(PREG->y_u.xxn.x) = d0;
818 PREG = NEXTOP(PREG, xxn);
819 GONext();
820
821 BEGP(pt0);
822 deref_body(d0, pt0, or_vc_unk, or_vc_nvar);
823 Yap_AbsmiError(INSTANTIATION_ERROR);
824 FAIL();
825 ENDP(pt0);
826 ENDD(d0);
827 ENDOp();
828
829 Op(p_or_y_vv, yxx);
830 BEGD(d0);
831 BEGD(d1);
832 d0 = XREG(PREG->y_u.yxx.x1);
833 /* first check pt1 */
834 deref_head(d0, or_y_vv_unk);
835 or_y_vv_nvar:
836 d1 = XREG(PREG->y_u.xxx.x2);
837 /* next check A2 */
838 deref_head(d1, or_y_vv_nvar_unk);
839 or_y_vv_nvar_nvar:
840 /* d0 and d1 are where I want them */
841 if (IsIntTerm(d0) && IsIntTerm(d1)) {
842 d0 = MkIntegerTerm(IntOfTerm(d0) | IntOfTerm(d1));
843 } else {
844 saveregs();
845 d0 = p_or(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
846 setregs();
847 }
848 BEGP(pt0);
849 pt0 = YREG + PREG->y_u.yxx.y;
850 PREG = NEXTOP(PREG, yxx);
851 INITIALIZE_PERMVAR(pt0, d0);
852 ENDP(pt0);
853 GONext();
854
855 BEGP(pt0);
856 deref_body(d0, pt0, or_y_vv_unk, or_y_vv_nvar);
857 Yap_AsmError(INSTANTIATION_ERROR,d0);
858 FAIL();
859 ENDP(pt0);
860
861 BEGP(pt0);
862 deref_body(d1, pt0, or_y_vv_nvar_unk, or_y_vv_nvar_nvar);
863 Yap_AsmError(INSTANTIATION_ERROR,d1);
864 FAIL();
865 ENDP(pt0);
866 ENDD(d1);
867 ENDD(d0);
868 ENDOp();
869
870 Op(p_or_y_vc, yxn);
871 BEGD(d0);
872 d0 = XREG(PREG->y_u.yxn.xi);
873 /* first check pt1 */
874 deref_head(d0, or_y_vc_unk);
875 or_y_vc_nvar : {
876 Int d1 = PREG->y_u.yxn.c;
877 if (IsIntTerm(d0)) {
878 d0 = MkIntegerTerm(IntOfTerm(d0) | d1);
879 } else {
880 saveregs();
881 d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
882 setregs();
883 }
884 }
885 BEGP(pt0);
886 pt0 = YREG + PREG->y_u.yxn.y;
887 PREG = NEXTOP(PREG, yxn);
888 INITIALIZE_PERMVAR(pt0, d0);
889 ENDP(pt0);
890 GONext();
891
892 BEGP(pt0);
893 deref_body(d0, pt0, or_y_vc_unk, or_y_vc_nvar);
894 Yap_AbsmiError(INSTANTIATION_ERROR);
895 FAIL();
896 ENDP(pt0);
897 ENDD(d0);
898 ENDOp();
899
900 Op(p_sll_vv, xxx);
901 BEGD(d0);
902 BEGD(d1);
903 d0 = XREG(PREG->y_u.xxx.x1);
904 /* first check pt1 */
905 deref_head(d0, sll_vv_unk);
906 sll_vv_nvar:
907 d1 = XREG(PREG->y_u.xxx.x2);
908 /* next check A2 */
909 deref_head(d1, sll_vv_nvar_unk);
910 sll_vv_nvar_nvar:
911 /* d0 and d1 are where I want them */
912 if (IsIntTerm(d0) && IsIntTerm(d1)) {
913 Int i2 = IntOfTerm(d1);
914 if (i2 < 0)
915 d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2));
916 else
917 d0 = do_sll(IntOfTerm(d0), i2 PASS_REGS);
918 } else {
919 saveregs();
920 d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
921 setregs();
922 }
923 XREG(PREG->y_u.xxx.x) = d0;
924 PREG = NEXTOP(PREG, xxx);
925 GONext();
926
927 BEGP(pt0);
928 deref_body(d0, pt0, sll_vv_unk, sll_vv_nvar);
929 Yap_AsmError(INSTANTIATION_ERROR,d0);
930 FAIL();
931 ENDP(pt0);
932
933 BEGP(pt0);
934 deref_body(d1, pt0, sll_vv_nvar_unk, sll_vv_nvar_nvar);
935 Yap_AsmError(INSTANTIATION_ERROR,d1);
936 FAIL();
937 ENDP(pt0);
938 ENDD(d1);
939 ENDD(d0);
940 ENDOp();
941
942 Op(p_sll_vc, xxn);
943 BEGD(d0);
944 d0 = XREG(PREG->y_u.xxn.xi);
945 /* first check pt1 */
946 deref_head(d0, sll_vc_unk);
947 sll_vc_nvar : {
948 Int d1 = PREG->y_u.xxn.c;
949 if (IsIntTerm(d0)) {
950 d0 = do_sll(IntOfTerm(d0), (Int)d1 PASS_REGS);
951 } else {
952 saveregs();
953 d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
954 setregs();
955 }
956 }
957 XREG(PREG->y_u.xxn.x) = d0;
958 PREG = NEXTOP(PREG, xxn);
959 GONext();
960
961 BEGP(pt0);
962 deref_body(d0, pt0, sll_vc_unk, sll_vc_nvar);
963 Yap_AsmError(INSTANTIATION_ERROR,d0);
964 FAIL();
965 ENDP(pt0);
966 ENDD(d0);
967 ENDOp();
968
969 Op(p_sll_cv, xxn);
970 BEGD(d0);
971 d0 = XREG(PREG->y_u.xxn.xi);
972 /* first check pt1 */
973 deref_head(d0, sll_cv_unk);
974 sll_cv_nvar : {
975 Int d1 = PREG->y_u.xxn.c;
976 if (IsIntTerm(d0)) {
977 Int i2 = IntOfTerm(d0);
978 if (i2 < 0)
979 d0 = MkIntegerTerm(SLR(d1, -i2));
980 else
981 d0 = do_sll(d1, i2 PASS_REGS);
982 } else {
983 saveregs();
984 d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
985 setregs();
986 }
987 }
988 XREG(PREG->y_u.xxn.x) = d0;
989 PREG = NEXTOP(PREG, xxn);
990 GONext();
991
992 BEGP(pt0);
993 deref_body(d0, pt0, sll_cv_unk, sll_cv_nvar);
994 Yap_AsmError(INSTANTIATION_ERROR,d0);
995 FAIL();
996 ENDP(pt0);
997 ENDD(d0);
998 ENDOp();
999
1000 Op(p_sll_y_vv, yxx);
1001 BEGD(d0);
1002 BEGD(d1);
1003 d0 = XREG(PREG->y_u.yxx.x1);
1004 /* first check pt1 */
1005 deref_head(d0, sll_y_vv_unk);
1006 sll_y_vv_nvar:
1007 d1 = XREG(PREG->y_u.xxx.x2);
1008 /* next check A2 */
1009 deref_head(d1, sll_y_vv_nvar_unk);
1010 sll_y_vv_nvar_nvar:
1011 /* d0 and d1 are where I want them */
1012 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1013 Int i2 = IntOfTerm(d1);
1014 if (i2 < 0)
1015 d0 = MkIntegerTerm(SLR(IntOfTerm(d0), -i2));
1016 else
1017 d0 = do_sll(IntOfTerm(d0), i2 PASS_REGS);
1018 } else {
1019 saveregs();
1020 d0 = p_sll(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
1021 setregs();
1022 }
1023 BEGP(pt0);
1024 pt0 = YREG + PREG->y_u.yxx.y;
1025 PREG = NEXTOP(PREG, yxx);
1026 INITIALIZE_PERMVAR(pt0, d0);
1027 ENDP(pt0);
1028 GONext();
1029
1030 BEGP(pt0);
1031 deref_body(d0, pt0, sll_y_vv_unk, sll_y_vv_nvar);
1032 Yap_AsmError(INSTANTIATION_ERROR,d0);
1033 FAIL();
1034 ENDP(pt0);
1035
1036 BEGP(pt0);
1037 deref_body(d1, pt0, sll_y_vv_nvar_unk, sll_y_vv_nvar_nvar);
1038 Yap_AsmError(INSTANTIATION_ERROR,d1);
1039 FAIL();
1040 ENDP(pt0);
1041 ENDD(d1);
1042 ENDD(d0);
1043 ENDOp();
1044
1045 Op(p_sll_y_vc, yxn);
1046 BEGD(d0);
1047 d0 = XREG(PREG->y_u.yxn.xi);
1048 /* first check pt1 */
1049 deref_head(d0, sll_y_vc_unk);
1050 sll_y_vc_nvar : {
1051 Int d1 = PREG->y_u.yxn.c;
1052 if (IsIntTerm(d0)) {
1053 d0 = do_sll(IntOfTerm(d0), Yap_Eval(d1) PASS_REGS);
1054 } else {
1055 saveregs();
1056 d0 = p_sll(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
1057 setregs();
1058 }
1059 }
1060 BEGP(pt0);
1061 pt0 = YREG + PREG->y_u.yxn.y;
1062 PREG = NEXTOP(PREG, yxn);
1063 INITIALIZE_PERMVAR(pt0, d0);
1064 ENDP(pt0);
1065 GONext();
1066
1067 BEGP(pt0);
1068 deref_body(d0, pt0, sll_y_vc_unk, sll_y_vc_nvar);
1069 Yap_AsmError(INSTANTIATION_ERROR,d0);
1070 FAIL();
1071 ENDP(pt0);
1072 ENDD(d0);
1073 ENDOp();
1074
1075 Op(p_sll_y_cv, yxn);
1076 BEGD(d0);
1077 d0 = XREG(PREG->y_u.yxn.xi);
1078 /* first check pt1 */
1079 deref_head(d0, sll_y_cv_unk);
1080 sll_y_cv_nvar : {
1081 Int d1 = PREG->y_u.yxn.c;
1082 if (IsIntTerm(d0)) {
1083 Int i2 = IntOfTerm(d0);
1084 if (i2 < 0)
1085 d0 = MkIntegerTerm(SLR(d1, -i2));
1086 else
1087 d0 = do_sll(d1, i2 PASS_REGS);
1088 } else {
1089 saveregs();
1090 d0 = p_sll(MkIntegerTerm(d1), Yap_Eval(0) PASS_REGS);
1091 setregs();
1092 }
1093 }
1094 BEGP(pt0);
1095 pt0 = YREG + PREG->y_u.yxn.y;
1096 PREG = NEXTOP(PREG, yxn);
1097 INITIALIZE_PERMVAR(pt0, d0);
1098 ENDP(pt0);
1099 GONext();
1100
1101 BEGP(pt0);
1102 deref_body(d0, pt0, sll_y_cv_unk, sll_y_cv_nvar);
1103 Yap_AsmError(INSTANTIATION_ERROR,d0);
1104 FAIL();
1105 ENDP(pt0);
1106 ENDD(d0);
1107 ENDOp();
1108
1109 Op(p_slr_vv, xxx);
1110 BEGD(d0);
1111 BEGD(d1);
1112 d0 = XREG(PREG->y_u.xxx.x1);
1113 /* first check pt1 */
1114 deref_head(d0, slr_vv_unk);
1115 slr_vv_nvar:
1116 d1 = XREG(PREG->y_u.xxx.x2);
1117 /* next check A2 */
1118 deref_head(d1, slr_vv_nvar_unk);
1119 slr_vv_nvar_nvar:
1120 /* d0 and d1 are where I want them */
1121 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1122 Int i2 = IntOfTerm(d1);
1123 if (i2 < 0)
1124 d0 = do_sll(IntOfTerm(d0), -i2 PASS_REGS);
1125 else
1126 d0 = MkIntTerm(SLR(IntOfTerm(d0), i2));
1127 } else {
1128 saveregs();
1129 d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
1130 setregs();
1131 }
1132 XREG(PREG->y_u.xxx.x) = d0;
1133 PREG = NEXTOP(PREG, xxx);
1134 GONext();
1135
1136 BEGP(pt0);
1137 deref_body(d0, pt0, slr_vv_unk, slr_vv_nvar);
1138 Yap_AsmError(INSTANTIATION_ERROR,d0);
1139 FAIL();
1140 ENDP(pt0);
1141
1142 BEGP(pt0);
1143 deref_body(d1, pt0, slr_vv_nvar_unk, slr_vv_nvar_nvar);
1144 Yap_AsmError(INSTANTIATION_ERROR,d1);
1145 FAIL();
1146 ENDP(pt0);
1147 ENDD(d1);
1148 ENDD(d0);
1149 ENDOp();
1150
1151 Op(p_slr_vc, xxn);
1152 BEGD(d0);
1153 d0 = XREG(PREG->y_u.xxn.xi);
1154 /* first check pt1 */
1155 deref_head(d0, slr_vc_unk);
1156 slr_vc_nvar : {
1157 Int d1 = PREG->y_u.xxn.c;
1158 if (IsIntTerm(d0)) {
1159 d0 = MkIntTerm(SLR(IntOfTerm(d0), d1));
1160 } else {
1161 saveregs();
1162 d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
1163 setregs();
1164 }
1165 }
1166 XREG(PREG->y_u.xxn.x) = d0;
1167 PREG = NEXTOP(PREG, xxn);
1168 GONext();
1169
1170 BEGP(pt0);
1171 deref_body(d0, pt0, slr_vc_unk, slr_vc_nvar);
1172 Yap_AsmError(INSTANTIATION_ERROR,d0);
1173 FAIL();
1174 ENDP(pt0);
1175 ENDD(d0);
1176 ENDOp();
1177
1178 Op(p_slr_cv, xxn);
1179 BEGD(d0);
1180 d0 = XREG(PREG->y_u.xxn.xi);
1181 /* first check pt1 */
1182 deref_head(d0, slr_cv_unk);
1183 slr_cv_nvar : {
1184 Int d1 = PREG->y_u.xxn.c;
1185 if (IsIntTerm(d0)) {
1186 Int i2 = IntOfTerm(d0);
1187 if (i2 < 0)
1188 d0 = do_sll(d1, -i2 PASS_REGS);
1189 else
1190 d0 = MkIntegerTerm(SLR(d1, i2));
1191 } else {
1192 saveregs();
1193 d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
1194 setregs();
1195 }
1196 }
1197 XREG(PREG->y_u.xxn.x) = d0;
1198 PREG = NEXTOP(PREG, xxn);
1199 GONext();
1200
1201 BEGP(pt0);
1202 deref_body(d0, pt0, slr_cv_unk, slr_cv_nvar);
1203 Yap_AsmError(INSTANTIATION_ERROR,d0);
1204 FAIL();
1205 ENDP(pt0);
1206 ENDD(d0);
1207 ENDOp();
1208
1209 Op(p_slr_y_vv, yxx);
1210 BEGD(d0);
1211 BEGD(d1);
1212 d0 = XREG(PREG->y_u.yxx.x1);
1213 /* first check pt1 */
1214 deref_head(d0, slr_y_vv_unk);
1215 slr_y_vv_nvar:
1216 d1 = XREG(PREG->y_u.xxx.x2);
1217 /* next check A2 */
1218 deref_head(d1, slr_y_vv_nvar_unk);
1219 slr_y_vv_nvar_nvar:
1220 /* d0 and d1 are where I want them */
1221 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1222 Int i2 = IntOfTerm(d1);
1223 if (i2 < 0)
1224 d0 = do_sll(IntOfTerm(d0), -i2 PASS_REGS);
1225 else
1226 d0 = MkIntTerm(SLR(IntOfTerm(d0), i2));
1227 } else {
1228 saveregs();
1229 d0 = p_slr(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
1230 setregs();
1231 }
1232 BEGP(pt0);
1233 pt0 = YREG + PREG->y_u.yxx.y;
1234 PREG = NEXTOP(PREG, yxx);
1235 INITIALIZE_PERMVAR(pt0, d0);
1236 ENDP(pt0);
1237 GONext();
1238
1239 BEGP(pt0);
1240 deref_body(d0, pt0, slr_y_vv_unk, slr_y_vv_nvar);
1241 Yap_AsmError(INSTANTIATION_ERROR,d0);
1242 FAIL();
1243 ENDP(pt0);
1244
1245 BEGP(pt0);
1246 deref_body(d1, pt0, slr_y_vv_nvar_unk, slr_y_vv_nvar_nvar);
1247 Yap_AsmError(INSTANTIATION_ERROR,d1);
1248 FAIL();
1249 ENDP(pt0);
1250 ENDD(d1);
1251 ENDD(d0);
1252 ENDOp();
1253
1254 Op(p_slr_y_vc, yxn);
1255 BEGD(d0);
1256 d0 = XREG(PREG->y_u.yxn.xi);
1257 /* first check pt1 */
1258 deref_head(d0, slr_y_vc_unk);
1259 slr_y_vc_nvar : {
1260 Int d1 = PREG->y_u.yxn.c;
1261 if (IsIntTerm(d0)) {
1262 d0 = MkIntTerm(SLR(IntOfTerm(d0), d1));
1263 } else {
1264 saveregs();
1265 d0 = p_slr(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
1266 setregs();
1267 }
1268 }
1269 BEGP(pt0);
1270 pt0 = YREG + PREG->y_u.yxn.y;
1271 PREG = NEXTOP(PREG, yxn);
1272 INITIALIZE_PERMVAR(pt0, d0);
1273 ENDP(pt0);
1274 GONext();
1275
1276 BEGP(pt0);
1277 deref_body(d0, pt0, slr_y_vc_unk, slr_y_vc_nvar);
1278 Yap_AsmError(INSTANTIATION_ERROR,d0);
1279 ENDP(pt0);
1280 ENDD(d0);
1281 ENDOp();
1282
1283 Op(p_slr_y_cv, yxn);
1284 BEGD(d0);
1285 d0 = XREG(PREG->y_u.yxn.xi);
1286 /* first check pt1 */
1287 deref_head(d0, slr_y_cv_unk);
1288 slr_y_cv_nvar : {
1289 Int d1 = PREG->y_u.yxn.c;
1290 if (IsIntTerm(d0)) {
1291 Int i2 = IntOfTerm(d0);
1292 if (i2 < 0)
1293 d0 = do_sll(d1, -i2 PASS_REGS);
1294 else
1295 d0 = MkIntegerTerm(SLR(d1, i2));
1296 } else {
1297 saveregs();
1298 d0 = p_slr(MkIntegerTerm(d1), Yap_Eval(d0) PASS_REGS);
1299 setregs();
1300 }
1301 }
1302 if (d0 == 0L) {
1303 Yap_AsmError(LOCAL_Error_TYPE,d0);
1304 FAIL();
1305 }
1306 BEGP(pt0);
1307 pt0 = YREG + PREG->y_u.yxn.y;
1308 PREG = NEXTOP(PREG, yxn);
1309 INITIALIZE_PERMVAR(pt0, d0);
1310 ENDP(pt0);
1311 GONext();
1312
1313 BEGP(pt0);
1314 deref_body(d0, pt0, slr_y_cv_unk, slr_y_cv_nvar);
1315 Yap_AsmError(INSTANTIATION_ERROR,d0);
1316 FAIL();
1317 ENDP(pt0);
1318 ENDD(d0);
1319 ENDOp();
1320
1321 BOp(call_bfunc_xx, plxxs);
1322 BEGD(d0);
1323 BEGD(d1);
1324 d0 = XREG(PREG->y_u.plxxs.x1);
1325 call_bfunc_xx_nvar:
1326 d1 = XREG(PREG->y_u.plxxs.x2);
1327 call_bfunc_xx2_nvar:
1328 deref_head(d0, call_bfunc_xx_unk);
1329 deref_head(d1, call_bfunc_xx2_unk);
1330 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1331 COUNT flags;
1332
1333 Int v = IntOfTerm(d0) - IntOfTerm(d1);
1334 flags = PREG->y_u.plxxs.flags;
1335 if (v > 0) {
1336 if (flags & GT_OK_IN_CMP) {
1337 yamop *nextp = NEXTOP(PREG, plxxs);
1338 ALWAYS_LOOKAHEAD(nextp->opc);
1339 PREG = nextp;
1340 ALWAYS_GONext();
1341 ALWAYS_END_PREFETCH();
1342 } else {
1343 yamop *nextp = PREG->y_u.plxxs.f;
1344 ALWAYS_LOOKAHEAD(nextp->opc);
1345 PREG = nextp;
1346 ALWAYS_GONext();
1347 ALWAYS_END_PREFETCH();
1348 }
1349 } else if (v < 0) {
1350 if (flags & LT_OK_IN_CMP) {
1351 yamop *nextp = NEXTOP(PREG, plxxs);
1352 ALWAYS_LOOKAHEAD(nextp->opc);
1353 PREG = nextp;
1354 ALWAYS_GONext();
1355 ALWAYS_END_PREFETCH();
1356 } else {
1357 yamop *nextp = PREG->y_u.plxxs.f;
1358 ALWAYS_LOOKAHEAD(nextp->opc);
1359 PREG = nextp;
1360 ALWAYS_GONext();
1361 ALWAYS_END_PREFETCH();
1362 }
1363 } else /* if (v == 0) */ {
1364 if (flags & EQ_OK_IN_CMP) {
1365 yamop *nextp = NEXTOP(PREG, plxxs);
1366 ALWAYS_LOOKAHEAD(nextp->opc);
1367 PREG = nextp;
1368 ALWAYS_GONext();
1369 ALWAYS_END_PREFETCH();
1370 } else {
1371 yamop *nextp = PREG->y_u.plxxs.f;
1372 ALWAYS_LOOKAHEAD(nextp->opc);
1373 PREG = nextp;
1374 ALWAYS_GONext();
1375 ALWAYS_END_PREFETCH();
1376 }
1377 }
1378 }
1379 exec_bin_cmp_xx : {
1380 CmpPredicate f = PREG->y_u.plxxs.p->cs.d_code;
1381 saveregs();
1382 d0 = (CELL)(f)(d0, d1);
1383 setregs();
1384 }
1385 if (PREG == FAILCODE) {
1386 JMPNext();
1387 }
1388 if (!d0) {
1389 PREG = PREG->y_u.plxxs.f;
1390 JMPNext();
1391 }
1392 PREG = NEXTOP(PREG, plxxs);
1393 JMPNext();
1394
1395 BEGP(pt0);
1396 deref_body(d0, pt0, call_bfunc_xx_unk, call_bfunc_xx_nvar);
1397 d1 = Deref(d1);
1398 goto exec_bin_cmp_xx;
1399 ENDP(pt0);
1400
1401 BEGP(pt0);
1402 deref_body(d1, pt0, call_bfunc_xx2_unk, call_bfunc_xx2_nvar);
1403 goto exec_bin_cmp_xx;
1404 ENDP(pt0);
1405
1406 ENDD(d1);
1407 ENDD(d0);
1408 ENDBOp();
1409
1410 BOp(call_bfunc_yx, plxys);
1411 BEGD(d0);
1412 BEGD(d1);
1413 BEGP(pt0);
1414 pt0 = YREG + PREG->y_u.plxys.y;
1415 d1 = XREG(PREG->y_u.plxys.x);
1416 d0 = *pt0;
1417 ENDP(pt0);
1418 deref_head(d0, call_bfunc_yx_unk);
1419 call_bfunc_yx_nvar:
1420 deref_head(d1, call_bfunc_yx2_unk);
1421 call_bfunc_yx2_nvar:
1422 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1423 int flags;
1424
1425 Int v = IntOfTerm(d0) - IntOfTerm(d1);
1426 flags = PREG->y_u.plxys.flags;
1427 if (v > 0) {
1428 if (flags & GT_OK_IN_CMP) {
1429 PREG = NEXTOP(PREG, plxys);
1430 JMPNext();
1431 } else {
1432 PREG = PREG->y_u.plxys.f;
1433 JMPNext();
1434 }
1435 } else if (v < 0) {
1436 if (flags & LT_OK_IN_CMP) {
1437 PREG = NEXTOP(PREG, plxys);
1438 JMPNext();
1439 } else {
1440 PREG = PREG->y_u.plxys.f;
1441 JMPNext();
1442 }
1443 } else /* if (v == 0) */ {
1444 if (flags & EQ_OK_IN_CMP) {
1445 PREG = NEXTOP(PREG, plxys);
1446 JMPNext();
1447 } else {
1448 PREG = PREG->y_u.plxys.f;
1449 JMPNext();
1450 }
1451 }
1452 }
1453 exec_bin_cmp_yx : {
1454 CmpPredicate f = PREG->y_u.plxys.p->cs.d_code;
1455 saveregs();
1456 d0 = (CELL)(f)(d0, d1);
1457 setregs();
1458 }
1459 if (!d0 || PREG == FAILCODE) {
1460 if (PREG != FAILCODE)
1461 PREG = PREG->y_u.plxys.f;
1462 JMPNext();
1463 }
1464 PREG = NEXTOP(PREG, plxys);
1465 JMPNext();
1466
1467 BEGP(pt0);
1468 deref_body(d0, pt0, call_bfunc_yx_unk, call_bfunc_yx_nvar);
1469 d1 = Deref(d1);
1470 goto exec_bin_cmp_yx;
1471 ENDP(pt0);
1472
1473 BEGP(pt0);
1474 deref_body(d1, pt0, call_bfunc_yx2_unk, call_bfunc_yx2_nvar);
1475 goto exec_bin_cmp_yx;
1476 ENDP(pt0);
1477
1478 ENDD(d1);
1479 ENDD(d0);
1480 ENDBOp();
1481
1482 BOp(call_bfunc_xy, plxys);
1483 BEGD(d0);
1484 BEGD(d1);
1485 BEGP(pt0);
1486 pt0 = YREG + PREG->y_u.plxys.y;
1487 d0 = XREG(PREG->y_u.plxys.x);
1488 d1 = *pt0;
1489 ENDP(pt0);
1490 deref_head(d0, call_bfunc_xy_unk);
1491 call_bfunc_xy_nvar:
1492 deref_head(d1, call_bfunc_xy2_unk);
1493 call_bfunc_xy2_nvar:
1494 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1495 int flags;
1496
1497 Int v = IntOfTerm(d0) - IntOfTerm(d1);
1498 flags = PREG->y_u.plxys.flags;
1499 if (v > 0) {
1500 if (flags & GT_OK_IN_CMP) {
1501 PREG = NEXTOP(PREG, plxys);
1502 JMPNext();
1503 } else {
1504 PREG = PREG->y_u.plxys.f;
1505 JMPNext();
1506 }
1507 } else if (v < 0) {
1508 if (flags & LT_OK_IN_CMP) {
1509 PREG = NEXTOP(PREG, plxys);
1510 JMPNext();
1511 } else {
1512 PREG = PREG->y_u.plxys.f;
1513 JMPNext();
1514 }
1515 } else /* if (v == 0) */ {
1516 if (flags & EQ_OK_IN_CMP) {
1517 PREG = NEXTOP(PREG, plxys);
1518 JMPNext();
1519 } else {
1520 PREG = PREG->y_u.plxys.f;
1521 JMPNext();
1522 }
1523 }
1524 }
1525 exec_bin_cmp_xy : {
1526 CmpPredicate f = PREG->y_u.plxys.p->cs.d_code;
1527 saveregs();
1528 d0 = (CELL)(f)(d0, d1);
1529 setregs();
1530 }
1531 if (!d0 || PREG == FAILCODE) {
1532 if (PREG != FAILCODE)
1533 PREG = PREG->y_u.plxys.f;
1534 JMPNext();
1535 }
1536 PREG = NEXTOP(PREG, plxys);
1537 JMPNext();
1538
1539 BEGP(pt0);
1540 deref_body(d0, pt0, call_bfunc_xy_unk, call_bfunc_xy_nvar);
1541 d1 = Deref(d1);
1542 goto exec_bin_cmp_xy;
1543 ENDP(pt0);
1544
1545 BEGP(pt0);
1546 deref_body(d1, pt0, call_bfunc_xy2_unk, call_bfunc_xy2_nvar);
1547 goto exec_bin_cmp_xy;
1548 ENDP(pt0);
1549
1550 ENDD(d1);
1551 ENDD(d0);
1552 ENDBOp();
1553
1554 BOp(call_bfunc_yy, plyys);
1555 BEGD(d0);
1556 BEGD(d1);
1557 BEGP(pt0);
1558 pt0 = YREG + PREG->y_u.plyys.y1;
1559 BEGP(pt1);
1560 pt1 = YREG + PREG->y_u.plyys.y2;
1561 d0 = *pt0;
1562 d1 = *pt1;
1563 ENDP(pt1);
1564 ENDP(pt0);
1565 deref_head(d0, call_bfunc_yy_unk);
1566 call_bfunc_yy_nvar:
1567 deref_head(d1, call_bfunc_yy2_unk);
1568 call_bfunc_yy2_nvar:
1569 if (IsIntTerm(d0) && IsIntTerm(d1)) {
1570 int flags;
1571
1572 Int v = IntOfTerm(d0) - IntOfTerm(d1);
1573 flags = PREG->y_u.plyys.flags;
1574 if (v > 0) {
1575 if (flags & GT_OK_IN_CMP) {
1576 PREG = NEXTOP(PREG, plyys);
1577 JMPNext();
1578 } else {
1579 PREG = PREG->y_u.plyys.f;
1580 JMPNext();
1581 }
1582 } else if (v < 0) {
1583 if (flags & LT_OK_IN_CMP) {
1584 PREG = NEXTOP(PREG, plyys);
1585 JMPNext();
1586 } else {
1587 PREG = PREG->y_u.plyys.f;
1588 JMPNext();
1589 }
1590 } else /* if (v == 0) */ {
1591 if (flags & EQ_OK_IN_CMP) {
1592 PREG = NEXTOP(PREG, plyys);
1593 JMPNext();
1594 } else {
1595 PREG = PREG->y_u.plyys.f;
1596 JMPNext();
1597 }
1598 }
1599 }
1600 exec_bin_cmp_yy : {
1601 CmpPredicate f = PREG->y_u.plyys.p->cs.d_code;
1602 saveregs();
1603 d0 = (CELL)(f)(d0, d1);
1604 setregs();
1605 }
1606 if (!d0 || PREG == FAILCODE) {
1607 if (PREG != FAILCODE)
1608 PREG = PREG->y_u.plyys.f;
1609 JMPNext();
1610 }
1611 PREG = NEXTOP(PREG, plyys);
1612 JMPNext();
1613
1614 BEGP(pt0);
1615 deref_body(d0, pt0, call_bfunc_yy_unk, call_bfunc_yy_nvar);
1616 d1 = Deref(d1);
1617 goto exec_bin_cmp_yy;
1618 ENDP(pt0);
1619
1620 BEGP(pt0);
1621 deref_body(d1, pt0, call_bfunc_yy2_unk, call_bfunc_yy2_nvar);
1622 goto exec_bin_cmp_yy;
1623 ENDP(pt0);
1624
1625 ENDD(d1);
1626 ENDD(d0);
1627 ENDBOp();
1628
1629 Op(p_equal, e);
1630 save_hb();
1631 if (Yap_IUnify(ARG1, ARG2) == false) {
1632 FAIL();
1633 }
1634 PREG = NEXTOP(PREG, e);
1635 GONext();
1636 ENDOp();
1637
1638#if INLINE_BIG_COMPARISONS
1639 Op(p_dif, l);
1640#ifdef LOW_LEVEL_TRACER
1641 if (Yap_do_low_level_trace)
1642 low_level_trace(enter_pred,
1643 RepPredProp(Yap_GetPredPropByFunc(FunctorDiff, 0)),
1644 XREGS + 1);
1645#endif /* LOW_LEVEL_TRACE */
1646 BEGD(d0);
1647 BEGD(d1);
1648 d0 = ARG1;
1649 deref_head(d0, dif_unk1);
1650 dif_nvar1:
1651 /* first argument is bound */
1652 d1 = ARG2;
1653 deref_head(d1, dif_nvar1_unk2);
1654 dif_nvar1_nvar2:
1655 /* both arguments are bound */
1656 if (d0 == d1) {
1657 PREG = PREG->y_u.l.l;
1658 GONext();
1659 }
1660 if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) {
1661 PREG = NEXTOP(PREG, l);
1662 GONext();
1663 }
1664 {
1665 Int opresult;
1666#ifdef COROUTINING
1667 /*
1668 * We may wake up goals during our attempt to unify the
1669 * two terms. If we are adding to the tail of a list of
1670 * woken goals that should be ok, but otherwise we need
1671 * to restore LOCAL_WokenGoals to its previous value.
1672 */
1673 LOCAL_DoNotSuspend = true;
1674
1675
1676#endif
1677 /* We will have to look inside compound terms */
1678 register tr_fr_ptr pt0;
1679 /* store the old value of TR for clearing bindings */
1680 pt0 = TR;
1681 BEGCHO(pt1);
1682 pt1 = B;
1683 /* make B and HB point to H to guarantee all bindings will
1684 * be trailed
1685 */
1686 HBREG = HR;
1687 B = (choiceptr)HR;
1688 B->cp_h = HR;
1689 SET_BB(B);
1690 save_hb();
1691 opresult = Yap_IUnify(d0, d1);
1692#ifdef COROUTINING
1693 LOCAL_DoNotSuspend = false;
1694#endif
1695 /* restore B */
1696 B = pt1;
1697 SET_BB(PROTECT_FROZEN_B(pt1));
1698#ifdef COROUTINING
1699 HR = HBREG;
1700#endif
1701 HBREG = B->cp_h;
1702 /* untrail all bindings made by Yap_IUnify */
1703 while (TR != pt0) {
1704 BEGD(d1);
1705 d1 = TrailTerm(--TR);
1706 if (IsVarTerm(d1)) {
1707#if defined(YAPOR_SBA) && defined(YAPOR)
1708 /* clean up the trail when we backtrack */
1709 if (Unsigned((Int)(d1) - (Int)(H_FZ)) >
1710 Unsigned((Int)(B_FZ) - (Int)(H_FZ))) {
1711 RESET_VARIABLE(STACK_TO_SBA(d1));
1712 } else
1713#endif
1714 /* normal variable */
1715 RESET_VARIABLE(d1);
1716#ifdef MULTI_ASSIGNMENT_VARIABLES
1717 } else /* if (IsApplTerm(d1)) */ {
1718 CELL *pt = RepAppl(d1);
1719/* AbsAppl means */
1720/* multi-assignment variable */
1721/* so the next cell is the old value */
1722#ifdef FROZEN_STACKS
1723 pt[0] = TrailVal(--TR);
1724#else
1725 pt[0] = TrailTerm(--TR);
1726 TR--;
1727#endif /* FROZEN_STACKS */
1728#endif /* MULTI_ASSIGNMENT_VARIABLES */
1729 }
1730 ENDD(d1);
1731 }
1732 if (opresult) {
1733 /* restore B, no need to restore HB */
1734 PREG = PREG->y_u.l.l;
1735 GONext();
1736 }
1737 /* restore B, and later HB */
1738 PREG = NEXTOP(PREG, l);
1739 ENDCHO(pt1);
1740 }
1741 GONext();
1742
1743 BEGP(pt0);
1744 deref_body(d0, pt0, dif_unk1, dif_nvar1);
1745 ENDP(pt0);
1746 /* first argument is unbound */
1747 PREG = PREG->y_u.l.l;
1748 GONext();
1749
1750 BEGP(pt0);
1751 deref_body(d1, pt0, dif_nvar1_unk2, dif_nvar1_nvar2);
1752 ENDP(pt0);
1753 /* second argument is unbound */
1754 PREG = PREG->y_u.l.l;
1755 GONext();
1756 ENDD(d1);
1757 ENDD(d0);
1758 ENDOp();
1759
1760 Op(p_eq, l);
1761#ifdef LOW_LEVEL_TRACER
1762 if (Yap_do_low_level_trace)
1763 low_level_trace(enter_pred,
1764 RepPredProp(Yap_GetPredPropByFunc(FunctorSame, 0)),
1765 XREGS + 1);
1766#endif /* LOW_LEVEL_TRACE */
1767 BEGD(d0);
1768 BEGD(d1);
1769 d0 = ARG1;
1770 deref_head(d0, p_eq_unk1);
1771 p_eq_nvar1:
1772 /* first argument is bound */
1773 d1 = ARG2;
1774 deref_head(d1, p_eq_nvar1_unk2);
1775 p_eq_nvar1_nvar2:
1776 /* both arguments are bound */
1777 if (d0 == d1) {
1778 PREG = NEXTOP(PREG, l);
1779 GONext();
1780 }
1781 if (IsPairTerm(d0)) {
1782 if (!IsPairTerm(d1)) {
1783 PREG = PREG->y_u.l.l;
1784 GONext();
1785 }
1786 BEGD(d2);
1787 always_save_pc();
1788 d2 = iequ_complex(RepPair(d0) - 1, RepPair(d0) + 1, RepPair(d1) - 1);
1789 if (d2 == false) {
1790 PREG = PREG->y_u.l.l;
1791 GONext();
1792 }
1793 ENDD(d2);
1794 always_set_pc();
1795 PREG = NEXTOP(PREG, l);
1796 GONext();
1797 }
1798 if (IsApplTerm(d0)) {
1799 Functor f0 = FunctorOfTerm(d0);
1800 Functor f1;
1801
1802 /* f1 must be a compound term, even if it is a suspension */
1803 if (!IsApplTerm(d1)) {
1804 PREG = PREG->y_u.l.l;
1805 GONext();
1806 }
1807 f1 = FunctorOfTerm(d1);
1808
1809 /* we now know f1 is true */
1810 /* deref if a compound term */
1811 if (IsExtensionFunctor(f0)) {
1812 switch ((CELL)f0) {
1813 case (CELL)FunctorDBRef:
1814 if (d0 == d1) {
1815 PREG = NEXTOP(PREG, l);
1816 GONext();
1817 }
1818 PREG = PREG->y_u.l.l;
1819 GONext();
1820 case (CELL)FunctorLongInt:
1821 if (f1 != FunctorLongInt) {
1822 PREG = PREG->y_u.l.l;
1823 GONext();
1824 }
1825 if (LongIntOfTerm(d0) == LongIntOfTerm(d1)) {
1826 PREG = NEXTOP(PREG, l);
1827 GONext();
1828 }
1829 PREG = PREG->y_u.l.l;
1830 GONext();
1831 case (CELL)FunctorString:
1832 if (f1 != FunctorString) {
1833 PREG = PREG->y_u.l.l;
1834 GONext();
1835 }
1836 if (strcmp((char *)(RepAppl(d0) + 2), (char *)(RepAppl(d1) + 2)) ==
1837 0) {
1838 PREG = NEXTOP(PREG, l);
1839 GONext();
1840 }
1841 PREG = PREG->y_u.l.l;
1842 GONext();
1843 break;
1844#ifdef USE_GMP
1845 case (CELL)FunctorBigInt:
1846 if (f1 != FunctorBigInt) {
1847 PREG = PREG->y_u.l.l;
1848 GONext();
1849 }
1850 if (Yap_gmp_tcmp_big_big(d0, d1) == 0) {
1851 PREG = NEXTOP(PREG, l);
1852 GONext();
1853 }
1854 PREG = PREG->y_u.l.l;
1855 GONext();
1856#endif
1857 case (CELL)FunctorDouble:
1858 if (f1 != FunctorDouble) {
1859 PREG = PREG->y_u.l.l;
1860 GONext();
1861 }
1862 Float fl0=FloatOfTerm(d0);
1863 Float fl1=FloatOfTerm(d1);
1864#if HAVE_ISNAN
1865 if (isnan(fl0) || isnan(fl1)) {
1866 PREG = PREG->y_u.l.l;
1867 GONext();
1868 }
1869#endif
1870#if HAVE_ISINF
1871 if (
1872#endif
1873 isinf(fl0)==isinf(fl1) ||
1874#if HAVE_ISINF
1875 fl0 == fl1) {
1876 PREG = NEXTOP(PREG, l);
1877 GONext();
1878 }
1879#endif
1880 PREG = PREG->y_u.l.l;
1881 GONext();
1882 break;
1883 default:
1884 PREG = PREG->y_u.l.l;
1885 GONext();
1886 }
1887 }
1888 if (f0 != f1) {
1889 PREG = PREG->y_u.l.l;
1890 GONext();
1891 }
1892 always_save_pc();
1893 BEGD(d2);
1894 d2 = iequ_complex(RepAppl(d0), RepAppl(d0) + ArityOfFunctor(f0),
1895 RepAppl(d1));
1896 if (d2 == false) {
1897 PREG = PREG->y_u.l.l;
1898 GONext();
1899 }
1900 ENDD(d2);
1901 always_set_pc();
1902 PREG = NEXTOP(PREG, l);
1903 GONext();
1904 }
1905 PREG = PREG->y_u.l.l;
1906 GONext();
1907
1908 BEGP(pt0);
1909 deref_body(d1, pt0, p_eq_nvar1_unk2, p_eq_nvar1_nvar2);
1910 ENDP(pt0);
1911 /* first argument is bound */
1912 /* second argument is unbound */
1913 /* I don't need to worry about co-routining because an
1914 unbound variable may never be == to a constrained variable!! */
1915 PREG = PREG->y_u.l.l;
1916 GONext();
1917 ENDD(d1);
1918
1919 BEGP(pt0);
1920 deref_body(d0, pt0, p_eq_unk1, p_eq_nvar1);
1921 BEGD(d1);
1922 d1 = ARG2;
1923 deref_head(d1, p_eq_var1_unk2);
1924 p_eq_var1_nvar2:
1925 /* I don't need to worry about co-routining because an
1926 unbound variable may never be == to a constrained variable!! */
1927 PREG = PREG->y_u.l.l;
1928 GONext();
1929
1930 BEGP(pt1);
1931 deref_body(d1, pt1, p_eq_var1_unk2, p_eq_var1_nvar2);
1932 /* first argument is unbound */
1933 /* second argument is unbound */
1934
1935 PREG = PREG->y_u.l.l;
1936 GONext();
1937 }
1938 PREG = NEXTOP(PREG, l);
1939 GONext();
1940 ENDP(pt1);
1941 ENDD(d1);
1942 ENDP(pt0);
1943
1944 ENDD(d0);
1945#ifdef COROUTINING
1946 /* Problem: have I got an environment or not? */
1947 NoStackEq:
1948 PROCESS_INT(interrupt_eq, do_eq);
1949#endif
1950
1951 ENDOp();
1952#endif /* INLINE_BIG_COMPARISONS */
1953
1954 Op(p_arg_vv, xxx);
1955#ifdef LOW_LEVEL_TRACER
1956 if (Yap_do_low_level_trace) {
1957 HR[0] = XREG(PREG->y_u.xxx.x1);
1958 HR[1] = XREG(PREG->y_u.xxx.x2);
1959 RESET_VARIABLE(HR + 2);
1960 low_level_trace(enter_pred,
1961 RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
1962 }
1963#endif /* LOW_LEVEL_TRACE */
1964 BEGD(d0);
1965 d0 = XREG(PREG->y_u.xxx.x1);
1966 deref_head(d0, arg_arg1_unk);
1967 arg_arg1_nvar:
1968 /* ARG1 is ok! */
1969 if (IsIntTerm(d0))
1970 d0 = IntOfTerm(d0);
1971 else if (IsLongIntTerm(d0)) {
1972 d0 = LongIntOfTerm(d0);
1973 } else {
1974 if (IsBigIntTerm(d0))
1975 FAIL();
1976 Yap_AsmError(TYPE_ERROR_INTEGER, d0);
1977 FAIL();
1978 }
1979
1980 /* d0 now got the argument we want */
1981 BEGD(d1);
1982 d1 = XREG(PREG->y_u.xxx.x2);
1983 deref_head(d1, arg_arg2_unk);
1984 arg_arg2_nvar:
1985 /* d1 now got the structure we want to fetch the argument
1986 * from */
1987 if (IsApplTerm(d1)) {
1988 BEGP(pt0);
1989 pt0 = RepAppl(d1);
1990 d1 = *pt0;
1991 if (IsExtensionFunctor((Functor)d1)) {
1992 Yap_AsmError(TYPE_ERROR_COMPOUND, AbsAppl(pt0));
1993 FAIL();
1994 }
1995 if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
1996 /* don't complain here for Prolog compatibility
1997 if ((Int)d0 <= 0) {
1998 saveregs();
1999Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
2000 MkIntegerTerm(d0),"arg 1 of arg/3");
2001 setregs();
2002 }
2003 */
2004 FAIL();
2005 }
2006 XREG(PREG->y_u.xxx.x) = pt0[d0];
2007 PREG = NEXTOP(PREG, xxx);
2008 GONext();
2009 ENDP(pt0);
2010 } else if (IsPairTerm(d1)) {
2011 BEGP(pt0);
2012 pt0 = RepPair(d1);
2013 if (d0 != 1 && d0 != 2) {
2014 if ((Int)d0 < 0) {
2015 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d0) );
2016 }
2017 FAIL();
2018 }
2019 XREG(PREG->y_u.xxx.x) = pt0[d0 - 1];
2020 PREG = NEXTOP(PREG, xxx);
2021 GONext();
2022 ENDP(pt0);
2023 } else {
2024 if (!IsAtomTerm(d1))
2025 Yap_AsmError(TYPE_ERROR_COMPOUND, d1);
2026 FAIL();
2027 }
2028
2029 BEGP(pt0);
2030 deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar);
2031 saveregs();
2032 Yap_AsmError(INSTANTIATION_ERROR,d1);
2033 ;
2034 setregs();
2035 ENDP(pt0);
2036 FAIL();
2037 ENDD(d1);
2038
2039 BEGP(pt0);
2040 deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar);
2041 saveregs();
2042 Yap_AsmError(INSTANTIATION_ERROR,d0);
2043 ;
2044 setregs();
2045 ENDP(pt0);
2046 FAIL();
2047 ENDD(d0);
2048 ENDOp();
2049
2050 Op(p_arg_cv, xxn);
2051#ifdef LOW_LEVEL_TRACER
2052 if (Yap_do_low_level_trace) {
2053 CELL *Ho = HR;
2054 Term t = MkIntegerTerm(PREG->y_u.xxn.c);
2055 HR[0] = t;
2056 HR[1] = XREG(PREG->y_u.xxn.xi);
2057 RESET_VARIABLE(HR + 2);
2058 low_level_trace(enter_pred,
2059 RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
2060 HR = Ho;
2061 }
2062#endif /* LOW_LEVEL_TRACE */
2063 BEGD(d0);
2064 d0 = PREG->y_u.xxn.c;
2065 /* d0 now got the argument we want */
2066 BEGD(d1);
2067 d1 = XREG(PREG->y_u.xxn.xi);
2068 deref_head(d1, arg_arg2_vc_unk);
2069 arg_arg2_vc_nvar:
2070 /* d1 now got the structure we want to fetch the argument
2071 * from */
2072 if (IsApplTerm(d1)) {
2073 BEGP(pt0);
2074 pt0 = RepAppl(d1);
2075 d1 = *pt0;
2076 if (IsExtensionFunctor((Functor)d1)) {
2077 Yap_AsmError(TYPE_ERROR_COMPOUND,XREG(PREG->y_u.xxn.xi));
2078 FAIL();
2079 }
2080 if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
2081 /* don't complain here for Prolog compatibility
2082 if ((Int)d0 <= 0) {
2083 saveregs();
2084Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
2085 MkIntegerTerm(d0),"arg 1 of arg/3");
2086 setregs();
2087 }
2088 */
2089 FAIL();
2090 }
2091 XREG(PREG->y_u.xxn.x) = pt0[d0];
2092 PREG = NEXTOP(PREG, xxn);
2093 GONext();
2094 ENDP(pt0);
2095 } else if (IsPairTerm(d1)) {
2096 BEGP(pt0);
2097 pt0 = RepPair(d1);
2098 if (d0 != 1 && d0 != 2) {
2099 if ((Int)d0 < 0) {
2100 saveregs();
2101 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, XREG(PREG->y_u.xxn.xi));
2102 }
2103 FAIL();
2104 }
2105 XREG(PREG->y_u.xxn.x) = pt0[d0 - 1];
2106 PREG = NEXTOP(PREG, xxn);
2107 GONext();
2108 ENDP(pt0);
2109 } else {
2110 Yap_AsmError(TYPE_ERROR_COMPOUND, XREG(PREG->y_u.xxn.xi));
2111 FAIL();
2112 }
2113
2114 BEGP(pt0);
2115 deref_body(d1, pt0, arg_arg2_vc_unk, arg_arg2_vc_nvar);
2116 Yap_AsmError(INSTANTIATION_ERROR, XREG(PREG->y_u.xxn.xi));
2117 ENDP(pt0);
2118 FAIL();
2119 ENDD(d1);
2120
2121 ENDD(d0);
2122 ENDOp();
2123
2124 Op(p_arg_y_vv, yxx);
2125#ifdef LOW_LEVEL_TRACER
2126 if (Yap_do_low_level_trace) {
2127 HR[0] = XREG(PREG->y_u.yxx.x1);
2128 HR[1] = XREG(PREG->y_u.yxx.x2);
2129 HR[2] = YREG[PREG->y_u.yxx.y];
2130 RESET_VARIABLE(HR + 2);
2131 low_level_trace(enter_pred,
2132 RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
2133 }
2134#endif /* LOW_LEVEL_TRACE */
2135 BEGD(d0);
2136 d0 = XREG(PREG->y_u.yxx.x1);
2137 deref_head(d0, arg_y_arg1_unk);
2138 arg_y_arg1_nvar:
2139 /* ARG1 is ok! */
2140 if (IsIntTerm(d0))
2141 d0 = IntOfTerm(d0);
2142 else if (IsLongIntTerm(d0)) {
2143 d0 = LongIntOfTerm(d0);
2144 } else {
2145 if (IsBigIntTerm(d0))
2146 FAIL();
2147 Yap_AsmError(TYPE_ERROR_INTEGER, XREG(PREG->y_u.yxx.x1));
2148 FAIL();
2149 }
2150
2151 /* d0 now got the argument we want */
2152 BEGD(d1);
2153 d1 = XREG(PREG->y_u.yxx.x2);
2154 deref_head(d1, arg_y_arg2_unk);
2155 arg_y_arg2_nvar:
2156 /* d1 now got the structure we want to fetch the argument
2157 * from */
2158 if (IsApplTerm(d1)) {
2159 BEGP(pt0);
2160 pt0 = RepAppl(d1);
2161 d1 = *pt0;
2162 if (IsExtensionFunctor((Functor)d1)) {
2163 Yap_AsmError(TYPE_ERROR_COMPOUND,XREG(PREG->y_u.yxx.x2));
2164 FAIL();
2165 }
2166 if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
2167 /* don't complain here for Prolog compatibility
2168 if ((Int)d0 <= 0) {
2169 saveregs();
2170Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
2171 MkIntegerTerm(d0),"arg 1 of arg/3");
2172 saveregs();
2173 }
2174 */
2175 FAIL();
2176 }
2177 BEGP(pt1);
2178 pt1 = YREG + PREG->y_u.yxx.y;
2179 PREG = NEXTOP(PREG, yxx);
2180 INITIALIZE_PERMVAR(pt1, pt0[d0]);
2181 ENDP(pt1);
2182 GONext();
2183 ENDP(pt0);
2184 } else if (IsPairTerm(d1)) {
2185 BEGP(pt0);
2186 pt0 = RepPair(d1);
2187 if (d0 != 1 && d0 != 2) {
2188 if ((Int)d0 < 0) {
2189 saveregs();
2190 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, YREG[PREG->y_u.yxx.y]);
2191 }
2192 FAIL();
2193 }
2194 BEGP(pt1);
2195 pt1 = YREG + PREG->y_u.yxx.y;
2196 PREG = NEXTOP(PREG, yxx);
2197 INITIALIZE_PERMVAR(pt1, pt0[d0 - 1]);
2198 GONext();
2199 ENDP(pt1);
2200 ENDP(pt0);
2201 } else {
2202 Yap_AsmError(TYPE_ERROR_COMPOUND, d1);
2203 FAIL();
2204 }
2205
2206 BEGP(pt0);
2207 deref_body(d1, pt0, arg_y_arg2_unk, arg_y_arg2_nvar);
2208 Yap_AsmError(INSTANTIATION_ERROR,d1);
2209 ENDP(pt0);
2210 FAIL();
2211 ENDD(d1);
2212
2213 BEGP(pt0);
2214 deref_body(d0, pt0, arg_y_arg1_unk, arg_y_arg1_nvar);
2215 Yap_AsmError(INSTANTIATION_ERROR,d0);
2216 ENDP(pt0);
2217 FAIL();
2218 ENDD(d0);
2219 ENDOp();
2220
2221 Op(p_arg_y_cv, yxn);
2222#ifdef LOW_LEVEL_TRACER
2223 if (Yap_do_low_level_trace) {
2224 CELL *Ho = HR;
2225 Term t = MkIntegerTerm(PREG->y_u.yxn.c);
2226 HR[0] = t;
2227 HR[1] = XREG(PREG->y_u.yxn.xi);
2228 HR[2] = YREG[PREG->y_u.yxn.y];
2229 RESET_VARIABLE(HR + 2);
2230 low_level_trace(enter_pred,
2231 RepPredProp(Yap_GetPredPropByFunc(FunctorArg, 0)), HR);
2232 HR = Ho;
2233 }
2234#endif /* LOW_LEVEL_TRACE */
2235 BEGD(d0);
2236 d0 = PREG->y_u.yxn.c;
2237 /* d0 now got the argument we want */
2238 BEGD(d1);
2239 d1 = XREG(PREG->y_u.yxn.xi);
2240 deref_head(d1, arg_y_arg2_vc_unk);
2241 arg_y_arg2_vc_nvar:
2242 /* d1 now got the structure we want to fetch the argument
2243 * from */
2244 if (IsApplTerm(d1)) {
2245 BEGP(pt0);
2246 pt0 = RepAppl(d1);
2247 d1 = *pt0;
2248 if (IsExtensionFunctor((Functor)d1)) {
2249 Yap_AsmError(TYPE_ERROR_COMPOUND, XREG(PREG->y_u.yxn.xi));
2250 FAIL();
2251 }
2252 if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
2253 /* don't complain here for Prolog compatibility
2254 if ((Int)d0 <= 0) {
2255Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
2256 }
2257 */
2258 FAIL();
2259 }
2260 BEGP(pt1);
2261 pt1 = YREG + PREG->y_u.yxn.y;
2262 PREG = NEXTOP(PREG, yxn);
2263 INITIALIZE_PERMVAR(pt1, pt0[d0]);
2264 ENDP(pt1);
2265 GONext();
2266 ENDP(pt0);
2267 } else if (IsPairTerm(d1)) {
2268 BEGP(pt0);
2269 pt0 = RepPair(d1);
2270 if (d0 != 1 && d0 != 2) {
2271 if ((Int)d0 < 0) {
2272 saveregs();
2273 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, YREG[PREG->y_u.yxn.y]);
2274 }
2275 FAIL();
2276 }
2277 BEGP(pt1);
2278 pt1 = YREG + PREG->y_u.yxn.y;
2279 PREG = NEXTOP(PREG, yxn);
2280 INITIALIZE_PERMVAR(pt1, pt0[d0 - 1]);
2281 ENDP(pt1);
2282 GONext();
2283 ENDP(pt0);
2284 } else {
2285 Yap_AsmError(TYPE_ERROR_COMPOUND,YREG[PREG->y_u.yxn.y]);
2286 FAIL();
2287 }
2288
2289 BEGP(pt0);
2290 deref_body(d1, pt0, arg_y_arg2_vc_unk, arg_y_arg2_vc_nvar);
2291 Yap_AsmError(INSTANTIATION_ERROR,d1);
2292 ENDP(pt0);
2293 FAIL();
2294 ENDD(d1);
2295
2296 ENDD(d0);
2297 ENDOp();
2298
2299 Op(p_func2s_vv, xxx);
2300 /* A1 is a variable */
2301 restart_func2s:
2302#ifdef LOW_LEVEL_TRACER
2303 if (Yap_do_low_level_trace) {
2304 RESET_VARIABLE(HR);
2305 HR[1] = XREG(PREG->y_u.xxx.x1);
2306 HR[2] = XREG(PREG->y_u.xxx.x2);
2307 low_level_trace(enter_pred,
2308 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2309 HR);
2310 }
2311#endif /* LOW_LEVEL_TRACE */
2312 /* We have to build the structure? */
2313 BEGD(d0);
2314 d0 = XREG(PREG->y_u.xxx.x1);
2315 deref_head(d0, func2s_unk);
2316 func2s_nvar:
2317 /* we do, let's get the third argument */
2318 BEGD(d1);
2319 d1 = XREG(PREG->y_u.xxx.x2);
2320 deref_head(d1, func2s_unk2);
2321 func2s_nvar2:
2322 /* Uuuff, the second and third argument are bound */
2323 if (IsIntegerTerm(d1))
2324 d1 = IntegerOfTerm(d1);
2325 else {
2326 saveregs();
2327 if (IsBigIntTerm(d1)) {
2328 setregs();
2329 Yap_AsmError(RESOURCE_ERROR_STACK,d1);
2330 } else {
2331 setregs();
2332 Yap_AsmError(TYPE_ERROR_INTEGER,d1);
2333 }
2334 FAIL();
2335 }
2336 if (!IsAtomTerm(d0)) {
2337 Yap_AsmError(TYPE_ERROR_ATOM, d0);
2338 FAIL();
2339 }
2340 /* We made it!!!!! we got in d0 the name, in d1 the arity and
2341 * in pt0 the variable to bind it to. */
2342 if (d0 == TermDot && d1 == 2) {
2343 RESET_VARIABLE(HR);
2344 RESET_VARIABLE(HR + 1);
2345 d0 = AbsPair(HR);
2346 HR += 2;
2347 /* else if arity is 0 just pass d0 through */
2348 /* Ding, ding, we made it */
2349 XREG(PREG->y_u.xxx.x) = d0;
2350 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
2351 GONext();
2352 } else if ((Int)d1 > 0) {
2353 /* now let's build a compound term */
2354 if (!IsAtomTerm(d0)) {
2355 Yap_AsmError(TYPE_ERROR_ATOM, d0);
2356 FAIL();
2357 }
2358 BEGP(pt1);
2359 if (!IsAtomTerm(d0)) {
2360 FAIL();
2361 } else
2362 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
2363 pt1 = HR;
2364 *pt1++ = d0;
2365 d0 = AbsAppl(HR);
2366 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
2367 /* make sure we have something to show for our trouble */
2368 saveregs();
2369 if (!Yap_dogcl(d1 PASS_REGS)) {
2370 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2371 JMPNext();
2372 } else {
2373 setregs();
2374 }
2375 goto restart_func2s;
2376 }
2377 while ((Int)d1--) {
2378 RESET_VARIABLE(pt1);
2379 pt1++;
2380 }
2381 HR = pt1;
2382 /* done building the term */
2383 ENDP(pt1);
2384 /* else if arity is 0 just pass d0 through */
2385 /* Ding, ding, we made it */
2386 XREG(PREG->y_u.xxx.x) = d0;
2387 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
2388 GONext();
2389 } else if ((Int)d1 == 0) {
2390 XREG(PREG->y_u.xxx.x) = d0;
2391 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
2392 GONext();
2393 } else {
2394 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
2395 }
2396
2397 BEGP(pt1);
2398 deref_body(d1, pt1, func2s_unk2, func2s_nvar2);
2399 Yap_AsmError(INSTANTIATION_ERROR,d1);
2400 ENDP(pt1);
2401 /* Oops, third argument was unbound */
2402 FAIL();
2403 ENDD(d1);
2404
2405 BEGP(pt1);
2406 deref_body(d0, pt1, func2s_unk, func2s_nvar);
2407 Yap_AsmError(INSTANTIATION_ERROR,d0);
2408 ENDP(pt1);
2409 /* Oops, second argument was unbound too */
2410 FAIL();
2411 ENDD(d0);
2412 ENDOp();
2413
2414 Op(p_func2s_cv, xxc);
2415 /* A1 is a variable */
2416 restart_func2s_cv:
2417#ifdef LOW_LEVEL_TRACER
2418 if (Yap_do_low_level_trace) {
2419 RESET_VARIABLE(HR);
2420 HR[1] = PREG->y_u.xxc.c;
2421 HR[2] = XREG(PREG->y_u.xxc.xi);
2422 low_level_trace(enter_pred,
2423 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2424 HR);
2425 }
2426#endif /* LOW_LEVEL_TRACE */
2427 BEGD(d0);
2428 /* We have to build the structure */
2429 d0 = PREG->y_u.xxc.c;
2430 /* we do, let's get the third argument */
2431 BEGD(d1);
2432 d1 = XREG(PREG->y_u.xxc.xi);
2433 deref_head(d1, func2s_unk2_cv);
2434 func2s_nvar2_cv:
2435 /* Uuuff, the second and third argument are bound */
2436 if (IsIntegerTerm(d1)) {
2437 d1 = IntegerOfTerm(d1);
2438 if (d1 <0) {
2439 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
2440 }
2441 } else {
2442 saveregs();
2443 if (IsBigIntTerm(d1)) {
2444 setregs();
2445 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2446 } else {
2447 setregs();
2448 Yap_AsmError(TYPE_ERROR_INTEGER, d1);
2449 }
2450 FAIL();
2451 }
2452 /* We made it!!!!! we got in d0 the name, in d1 the arity and
2453 * in pt0 the variable to bind it to. */
2454 if (d0 == TermDot && d1 == 2) {
2455 RESET_VARIABLE(HR);
2456 RESET_VARIABLE(HR + 1);
2457 d0 = AbsPair(HR);
2458 HR += 2;
2459 /* else if arity is 0 just pass d0 through */
2460 /* Ding, ding, we made it */
2461 XREG(PREG->y_u.xxc.x) = d0;
2462 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
2463 GONext();
2464 } else if ((Int)d1 > 0) {
2465 /* now let's build a compound term */
2466 if (!IsAtomTerm(d0)) {
2467 Yap_AsmError(TYPE_ERROR_ATOM, d0);
2468 FAIL();
2469 }
2470 BEGP(pt1);
2471 if (!IsAtomTerm(d0)) {
2472 FAIL();
2473 } else
2474 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
2475 pt1 = HR;
2476 *pt1++ = d0;
2477 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
2478 /* make sure we have something to show for our trouble */
2479 saveregs();
2480 if (!Yap_dogcl(d1 PASS_REGS1)) {
2481 setregs();
2482 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2483 JMPNext();
2484 } else {
2485 setregs();
2486 }
2487 goto restart_func2s_cv;
2488 }
2489 d0 = AbsAppl(HR);
2490 while ((Int)d1--) {
2491 RESET_VARIABLE(pt1);
2492 pt1++;
2493 }
2494 /* done building the term */
2495 HR = pt1;
2496 ENDP(pt1);
2497 /* else if arity is 0 just pass d0 through */
2498 /* Ding, ding, we made it */
2499 XREG(PREG->y_u.xxc.x) = d0;
2500 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
2501 GONext();
2502 } else if (d1 == 0) {
2503 XREG(PREG->y_u.xxc.x) = d0;
2504 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
2505 GONext();
2506 } else {
2507 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,d1);
2508 }
2509
2510 BEGP(pt1);
2511 deref_body(d1, pt1, func2s_unk2_cv, func2s_nvar2_cv);
2512 Yap_AsmError(INSTANTIATION_ERROR,d1);
2513 ENDP(pt1);
2514 /* Oops, third argument was unbound */
2515 FAIL();
2516 ENDD(d1);
2517 ENDD(d0);
2518 ENDOp();
2519
2520 Op(p_func2s_vc, xxn);
2521 /* A1 is a variable */
2522 restart_func2s_x_vc:
2523#ifdef LOW_LEVEL_TRACER
2524 if (Yap_do_low_level_trace) {
2525 Term ti;
2526 CELL *hi = HR;
2527
2528 ti = MkIntegerTerm((Int)(PREG->y_u.xxn.c));
2529 RESET_VARIABLE(HR);
2530 HR[1] = XREG(PREG->y_u.xxn.xi);
2531 HR[2] = ti;
2532 low_level_trace(enter_pred,
2533 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2534 HR);
2535 HR = hi;
2536 }
2537#endif /* LOW_LEVEL_TRACE */
2538 /* We have to build the structure */
2539 BEGD(d0);
2540 d0 = XREG(PREG->y_u.xxn.xi);
2541 deref_head(d0, func2s_x_unk_vc);
2542 func2s_x_nvar_vc:
2543 BEGD(d1);
2544 d1 = PREG->y_u.xxn.c;
2545 if (!IsAtomicTerm(d0)) {
2546 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2547 FAIL();
2548 }
2549 /* We made it!!!!! we got in d0 the name, in d1 the arity and
2550 * in pt0 the variable to bind it to. */
2551 if (d0 == TermDot && d1 == 2) {
2552 RESET_VARIABLE(HR);
2553 RESET_VARIABLE(HR + 1);
2554 d0 = AbsPair(HR);
2555 HR += 2;
2556 /* else if arity is 0 just pass d0 through */
2557 /* Ding, ding, we made it */
2558 XREG(PREG->y_u.xxn.x) = d0;
2559 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn), Osbpp), l);
2560 GONext();
2561 }
2562 if (d1 == 0) {
2563 XREG(PREG->y_u.xxn.x) = d0;
2564 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn), Osbpp), l);
2565 GONext();
2566 }
2567 if (!IsAtomTerm(d0)) {
2568 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2569 FAIL();
2570 }
2571 /* now let's build a compound term */
2572 if (!IsAtomTerm(d0)) {
2573 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2574 FAIL();
2575 }
2576 BEGP(pt1);
2577 if (!IsAtomTerm(d0)) {
2578 FAIL();
2579 } else
2580 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
2581 pt1 = HR;
2582 *pt1++ = d0;
2583 d0 = AbsAppl(HR);
2584 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
2585 /* make sure we have something to show for our trouble */
2586 saveregs();
2587 if (!Yap_dogcl(d1 PASS_REGS)) {
2588 setregs();
2589 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2590 JMPNext();
2591 } else {
2592 setregs();
2593 }
2594 goto restart_func2s_x_vc;
2595 }
2596 while ((Int)d1--) {
2597 RESET_VARIABLE(pt1);
2598 pt1++;
2599 }
2600 /* done building the term */
2601 HR = pt1;
2602 /* else if arity is 0 just pass d0 through */
2603 /* Ding, ding, we made it */
2604 XREG(PREG->y_u.xxn.x) = d0;
2605 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxn), Osbpp), l);
2606 ENDP(pt1);
2607 ENDD(d1);
2608 GONext();
2609
2610 BEGP(pt1);
2611 deref_body(d0, pt1, func2s_x_unk_vc, func2s_x_nvar_vc);
2612 Yap_AsmError(INSTANTIATION_ERROR,d0);
2613 ENDP(pt1);
2614 /* Oops, second argument was unbound too */
2615 FAIL();
2616 ENDD(d0);
2617 ENDOp();
2618
2619
2620 Op(p_func2s_y_vv, yxx);
2621 /* A1 is a variable */
2622 restart_func2s_y:
2623#ifdef LOW_LEVEL_TRACER
2624 if (Yap_do_low_level_trace) {
2625 RESET_VARIABLE(HR);
2626 HR[1] = XREG(PREG->y_u.yxx.x1);
2627 HR[2] = XREG(PREG->y_u.yxx.x2);
2628 low_level_trace(enter_pred,
2629 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2630 HR);
2631 }
2632#endif /* LOW_LEVEL_TRACE */
2633 /* We have to build the structure */
2634 BEGD(d0);
2635 d0 = XREG(PREG->y_u.yxx.x1);
2636 deref_head(d0, func2s_y_unk);
2637 func2s_y_nvar:
2638 /* we do, let's get the third argument */
2639 BEGD(d1);
2640 d1 = XREG(PREG->y_u.yxx.x2);
2641 deref_head(d1, func2s_y_unk2);
2642 func2s_y_nvar2:
2643 /* Uuuff, the second and third argument are bound */
2644 if (IsIntegerTerm(d1))
2645 d1 = IntegerOfTerm(d1);
2646 else {
2647 saveregs();
2648 if (IsBigIntTerm(d1)) {
2649 setregs();
2650 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2651 } else {
2652 setregs();
2653 Yap_AsmError(TYPE_ERROR_INTEGER, d1);
2654 }
2655 FAIL();
2656 }
2657 if (!IsAtomicTerm(d0)) {
2658 Yap_AsmError(TYPE_ERROR_ATOM, d0);
2659 FAIL();
2660 }
2661 /* We made it!!!!! we got in d0 the name, in d1 the arity and
2662 * in pt0 the variable to bind it to. */
2663 if (d0 == TermDot && d1 == 2) {
2664 RESET_VARIABLE(HR);
2665 RESET_VARIABLE(HR + 1);
2666 d0 = AbsPair(HR);
2667 HR += 2;
2668 BEGP(pt1);
2669 pt1 = YREG + PREG->y_u.yxx.y;
2670 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx), Osbpp), l);
2671 INITIALIZE_PERMVAR(pt1, d0);
2672 ENDP(pt1);
2673 GONext();
2674 } else if ((Int)d1 > 0) {
2675 /* now let's build a compound term */
2676 if (!IsAtomTerm(d0)) {
2677 Yap_AsmError(TYPE_ERROR_ATOM, d0);
2678 FAIL();
2679 }
2680 BEGP(pt1);
2681 if (!IsAtomTerm(d0)) {
2682 FAIL();
2683 } else
2684 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
2685 pt1 = HR;
2686 *pt1++ = d0;
2687 d0 = AbsAppl(HR);
2688 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
2689 /* make sure we have something to show for our trouble */
2690 saveregs();
2691 if (!Yap_dogcl(d1 PASS_REGS1)) {
2692 setregs();
2693 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2694 JMPNext();
2695 } else {
2696 setregs();
2697 }
2698 goto restart_func2s_y;
2699 }
2700 while ((Int)d1--) {
2701 RESET_VARIABLE(pt1);
2702 pt1++;
2703 }
2704 /* done building the term */
2705 HR = pt1;
2706 ENDP(pt1);
2707 /* else if arity is 0 just pass d0 through */
2708 /* Ding, ding, we made it */
2709 BEGP(pt1);
2710 pt1 = YREG + PREG->y_u.yxx.y;
2711 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx), Osbpp), l);
2712 INITIALIZE_PERMVAR(pt1, d0);
2713 ENDP(pt1);
2714 GONext();
2715 } else if (d1 == 0) {
2716 BEGP(pt1);
2717 pt1 = YREG + PREG->y_u.yxx.y;
2718 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxx), Osbpp), l);
2719 INITIALIZE_PERMVAR(pt1, d0);
2720 ENDP(pt1);
2721 GONext();
2722 } else {
2723 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
2724 }
2725
2726 BEGP(pt1);
2727 deref_body(d1, pt1, func2s_y_unk2, func2s_y_nvar2);
2728 Yap_AsmError(INSTANTIATION_ERROR,d1);
2729 ENDP(pt1);
2730 /* Oops, third argument was unbound */
2731 FAIL();
2732 ENDD(d1);
2733
2734 BEGP(pt1);
2735 deref_body(d0, pt1, func2s_y_unk, func2s_y_nvar);
2736 Yap_AsmError(INSTANTIATION_ERROR,d0);
2737 ENDP(pt1);
2738 /* Oops, second argument was unbound too */
2739 FAIL();
2740 ENDD(d0);
2741 ENDOp();
2742
2743 Op(p_func2s_y_cv, yxc);
2744 /* A1 is a variable */
2745 restart_func2s_y_cv:
2746#ifdef LOW_LEVEL_TRACER
2747 if (Yap_do_low_level_trace) {
2748 RESET_VARIABLE(HR);
2749 HR[1] = PREG->y_u.yxc.c;
2750 HR[2] = XREG(PREG->y_u.yxc.xi);
2751 low_level_trace(enter_pred,
2752 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2753 HR);
2754 }
2755#endif /* LOW_LEVEL_TRACE */
2756 /* We have to build the structure */
2757 BEGD(d0);
2758 d0 = PREG->y_u.yxc.c;
2759 /* we do, let's get the third argument */
2760 BEGD(d1);
2761 d1 = XREG(PREG->y_u.yxc.xi);
2762 deref_head(d1, func2s_y_unk_cv);
2763 func2s_y_nvar_cv:
2764 /* Uuuff, the second and third argument are bound */
2765 if (IsIntegerTerm(d1)) {
2766 d1 = IntegerOfTerm(d1);
2767 } else {
2768 if (IsBigIntTerm(d1)) {
2769 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2770 } else {
2771 Yap_AsmError(TYPE_ERROR_INTEGER, d1);
2772 }
2773 FAIL();
2774 }
2775 /* We made it!!!!! we got in d0 the name, in d1 the arity and
2776 * in pt0 the variable to bind it to. */
2777 if (d0 == TermDot && d1 == 2) {
2778 RESET_VARIABLE(HR);
2779 RESET_VARIABLE(HR + 1);
2780 d0 = AbsPair(HR);
2781 HR += 2;
2782 /* else if arity is 0 just pass d0 through */
2783 /* Ding, ding, we made it */
2784 BEGP(pt1);
2785 pt1 = YREG + PREG->y_u.yxc.y;
2786 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxc), Osbpp), l);
2787 INITIALIZE_PERMVAR(pt1, d0);
2788 ENDP(pt1);
2789 GONext();
2790 } else if ((Int)d1 > 0) {
2791 /* now let's build a compound term */
2792 if (!IsAtomTerm(d0)) {
2793 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2794 FAIL();
2795 }
2796 if (!IsAtomTerm(d0)) {
2797 FAIL();
2798 } else
2799 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
2800 BEGP(pt1);
2801 pt1 = HR;
2802 *pt1++ = d0;
2803 d0 = AbsAppl(HR);
2804 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
2805 /* make sure we have something to show for our trouble */
2806 saveregs();
2807 if (!Yap_dogcl(d1 PASS_REGS1)) {
2808 setregs();
2809 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2810 JMPNext();
2811 } else {
2812 setregs();
2813 }
2814 goto restart_func2s_y_cv;
2815 }
2816 while ((Int)d1--) {
2817 RESET_VARIABLE(pt1);
2818 pt1++;
2819 }
2820 /* done building the term */
2821 HR = pt1;
2822 ENDP(pt1);
2823 /* else if arity is 0 just pass d0 through */
2824 /* Ding, ding, we made it */
2825 BEGP(pt1);
2826 pt1 = YREG + PREG->y_u.yxc.y;
2827 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxc), Osbpp), l);
2828 INITIALIZE_PERMVAR(pt1, d0);
2829 ENDP(pt1);
2830 GONext();
2831 } else if (d1 == 0) {
2832 BEGP(pt1);
2833 pt1 = YREG + PREG->y_u.yxc.y;
2834 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxc), Osbpp), l);
2835 INITIALIZE_PERMVAR(pt1, d0);
2836 ENDP(pt1);
2837 GONext();
2838 } else {
2839 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
2840 }
2841
2842 BEGP(pt1);
2843 deref_body(d1, pt1, func2s_y_unk_cv, func2s_y_nvar_cv);
2844 Yap_AsmError(INSTANTIATION_ERROR,d1);
2845 ENDP(pt1);
2846 /* Oops, third argument was unbound */
2847 FAIL();
2848 ENDD(d1);
2849 ENDD(d0);
2850 ENDOp();
2851
2852 Op(p_func2s_y_vc, yxn);
2853 /* A1 is a variable */
2854 restart_func2s_y_vc:
2855#ifdef LOW_LEVEL_TRACER
2856 if (Yap_do_low_level_trace) {
2857 Term ti;
2858 CELL *hi = HR;
2859
2860 ti = MkIntegerTerm((Int)(PREG->y_u.yxn.c));
2861 RESET_VARIABLE(HR);
2862 HR[1] = XREG(PREG->y_u.yxn.xi);
2863 HR[2] = ti;
2864 low_level_trace(enter_pred,
2865 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2866 HR);
2867 HR = hi;
2868 }
2869#endif /* LOW_LEVEL_TRACE */
2870 /* We have to build the structure */
2871 BEGD(d0);
2872 d0 = XREG(PREG->y_u.yxn.xi);
2873 deref_head(d0, func2s_y_unk_vc);
2874 func2s_y_nvar_vc:
2875 BEGD(d1);
2876 d1 = PREG->y_u.yxn.c;
2877 if (!IsAtomicTerm(d0)) {
2878 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2879 FAIL();
2880 }
2881 /* We made it!!!!! we got in d0 the name, in d1 the arity and
2882 * in pt0 the variable to bind it to. */
2883 if (d0 == TermDot && d1 == 2) {
2884 RESET_VARIABLE(HR);
2885 RESET_VARIABLE(HR + 1);
2886 d0 = AbsPair(HR);
2887 HR += 2;
2888 /* else if arity is 0 just pass d0 through */
2889 /* Ding, ding, we made it */
2890 BEGP(pt1);
2891 pt1 = YREG + PREG->y_u.yxn.y;
2892 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn), Osbpp), l);
2893 INITIALIZE_PERMVAR(pt1, d0);
2894 ENDP(pt1);
2895 GONext();
2896 }
2897 if (d1 == 0) {
2898 BEGP(pt1);
2899 pt1 = YREG + PREG->y_u.yxn.y;
2900 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn), Osbpp), l);
2901 INITIALIZE_PERMVAR(pt1, d0);
2902 ENDP(pt1);
2903 GONext();
2904 }
2905 if (!IsAtomTerm(d0)) {
2906 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2907 FAIL();
2908 }
2909 /* now let's build a compound term */
2910 if (!IsAtomTerm(d0)) {
2911 Yap_AsmError(TYPE_ERROR_ATOM,d0);
2912 FAIL();
2913 }
2914 BEGP(pt1);
2915 if (!IsAtomTerm(d0)) {
2916 FAIL();
2917 } else
2918 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
2919 pt1 = HR;
2920 *pt1++ = d0;
2921 d0 = AbsAppl(HR);
2922 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
2923 /* make sure we have something to show for our trouble */
2924 saveregs();
2925 if (!Yap_dogcl(d1 PASS_REGS)) {
2926 setregs();
2927 Yap_AsmError(RESOURCE_ERROR_STACK, d1);
2928 JMPNext();
2929 } else {
2930 setregs();
2931 }
2932 goto restart_func2s_y_vc;
2933 }
2934 while ((Int)d1--) {
2935 RESET_VARIABLE(pt1);
2936 pt1++;
2937 }
2938 /* done building the term */
2939 HR = pt1;
2940 ENDP(pt1);
2941 /* else if arity is 0 just pass d0 through */
2942 /* Ding, ding, we made it */
2943 BEGP(pt1);
2944 pt1 = YREG + PREG->y_u.yxn.y;
2945 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yxn), Osbpp), l);
2946 INITIALIZE_PERMVAR(pt1, d0);
2947 ENDP(pt1);
2948 ENDD(d1);
2949 GONext();
2950
2951 BEGP(pt1);
2952 deref_body(d0, pt1, func2s_y_unk_vc, func2s_y_nvar_vc);
2953 Yap_AsmError(INSTANTIATION_ERROR,d0);
2954 ENDP(pt1);
2955 /* Oops, second argument was unbound too */
2956 FAIL();
2957 ENDD(d0);
2958 ENDOp();
2959
2960 Op(p_func2f_xx, xxx);
2961#ifdef LOW_LEVEL_TRACER
2962 if (Yap_do_low_level_trace) {
2963 HR[0] = XREG(PREG->y_u.xxx.x);
2964 RESET_VARIABLE(HR + 1);
2965 RESET_VARIABLE(HR + 2);
2966 low_level_trace(enter_pred,
2967 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
2968 HR);
2969 }
2970#endif /* LOW_LEVEL_TRACE */
2971 BEGD(d0);
2972 d0 = XREG(PREG->y_u.xxx.x);
2973 deref_head(d0, func2f_xx_unk);
2974 func2f_xx_nvar:
2975 if (IsApplTerm(d0)) {
2976 Functor d1 = FunctorOfTerm(d0);
2977 if (IsExtensionFunctor(d1)) {
2978 XREG(PREG->y_u.xxx.x1) = d0;
2979 XREG(PREG->y_u.xxx.x2) = MkIntTerm(0);
2980 PREG = NEXTOP(PREG, xxx);
2981 GONext();
2982 }
2983 XREG(PREG->y_u.xxx.x1) = MkAtomTerm(NameOfFunctor(d1));
2984 XREG(PREG->y_u.xxx.x2) = MkIntegerTerm(ArityOfFunctor(d1));
2985 PREG = NEXTOP(PREG, xxx);
2986 GONext();
2987 } else if (IsPairTerm(d0)) {
2988 XREG(PREG->y_u.xxx.x1) = TermDot;
2989 XREG(PREG->y_u.xxx.x2) = MkIntTerm(2);
2990 PREG = NEXTOP(PREG, xxx);
2991 GONext();
2992 } else {
2993 XREG(PREG->y_u.xxx.x1) = d0;
2994 XREG(PREG->y_u.xxx.x2) = MkIntTerm(0);
2995 PREG = NEXTOP(PREG, xxx);
2996 GONext();
2997 }
2998
2999 BEGP(pt1);
3000 deref_body(d0, pt1, func2f_xx_unk, func2f_xx_nvar);
3001 Yap_AsmError(INSTANTIATION_ERROR,d0);
3002 ENDP(pt1);
3003 /* Oops, second argument was unbound too */
3004 FAIL();
3005 ENDD(d0);
3006 ENDOp();
3007
3008 Op(p_func2f_xy, xxy);
3009#ifdef LOW_LEVEL_TRACER
3010 if (Yap_do_low_level_trace) {
3011 HR[0] = XREG(PREG->y_u.xxy.x);
3012 RESET_VARIABLE(HR + 1);
3013 RESET_VARIABLE(HR + 2);
3014 low_level_trace(enter_pred,
3015 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
3016 HR);
3017 }
3018#endif /* LOW_LEVEL_TRACE */
3019 BEGD(d0);
3020 d0 = XREG(PREG->y_u.xxy.x);
3021 deref_head(d0, func2f_xy_unk);
3022 func2f_xy_nvar:
3023 if (IsApplTerm(d0)) {
3024 Functor d1 = FunctorOfTerm(d0);
3025 CELL *pt0 = YREG + PREG->y_u.xxy.y2;
3026 if (IsExtensionFunctor(d1)) {
3027 XREG(PREG->y_u.xxy.x1) = d0;
3028 PREG = NEXTOP(PREG, xxy);
3029 INITIALIZE_PERMVAR(pt0, MkIntTerm(0));
3030 GONext();
3031 }
3032 XREG(PREG->y_u.xxy.x1) = MkAtomTerm(NameOfFunctor(d1));
3033 PREG = NEXTOP(PREG, xxy);
3034 INITIALIZE_PERMVAR(pt0, MkIntegerTerm(ArityOfFunctor(d1)));
3035 GONext();
3036 } else if (IsPairTerm(d0)) {
3037 CELL *pt0 = YREG + PREG->y_u.xxy.y2;
3038 XREG(PREG->y_u.xxy.x1) = TermDot;
3039 PREG = NEXTOP(PREG, xxy);
3040 INITIALIZE_PERMVAR(pt0, MkIntTerm(2));
3041 GONext();
3042 } else {
3043 CELL *pt0 = YREG + PREG->y_u.xxy.y2;
3044 XREG(PREG->y_u.xxy.x1) = d0;
3045 PREG = NEXTOP(PREG, xxy);
3046 INITIALIZE_PERMVAR(pt0, MkIntTerm(0));
3047 GONext();
3048 }
3049
3050 BEGP(pt1);
3051 deref_body(d0, pt1, func2f_xy_unk, func2f_xy_nvar);
3052 Yap_AsmError(INSTANTIATION_ERROR,d0);
3053 ENDP(pt1);
3054 /* Oops, second argument was unbound too */
3055 FAIL();
3056 ENDD(d0);
3057 ENDOp();
3058
3059 Op(p_func2f_yx, yxx);
3060#ifdef LOW_LEVEL_TRACER
3061 if (Yap_do_low_level_trace) {
3062 HR[0] = XREG(PREG->y_u.yxx.x2);
3063 RESET_VARIABLE(HR + 1);
3064 RESET_VARIABLE(HR + 2);
3065 low_level_trace(enter_pred,
3066 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
3067 HR);
3068 }
3069#endif /* LOW_LEVEL_TRACE */
3070 BEGD(d0);
3071 d0 = XREG(PREG->y_u.yxx.x2);
3072 deref_head(d0, func2f_yx_unk);
3073 func2f_yx_nvar:
3074 if (IsApplTerm(d0)) {
3075 Functor d1 = FunctorOfTerm(d0);
3076 CELL *pt0 = YREG + PREG->y_u.yxx.y;
3077 if (IsExtensionFunctor(d1)) {
3078 XREG(PREG->y_u.yxx.x1) = MkIntTerm(0);
3079 PREG = NEXTOP(PREG, yxx);
3080 INITIALIZE_PERMVAR(pt0, d0);
3081 GONext();
3082 }
3083 XREG(PREG->y_u.yxx.x1) = MkIntegerTerm(ArityOfFunctor(d1));
3084 PREG = NEXTOP(PREG, yxx);
3085 INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1)));
3086 GONext();
3087 } else if (IsPairTerm(d0)) {
3088 CELL *pt0 = YREG + PREG->y_u.yxx.y;
3089 XREG(PREG->y_u.yxx.x1) = MkIntTerm(2);
3090 PREG = NEXTOP(PREG, yxx);
3091 INITIALIZE_PERMVAR(pt0, TermDot);
3092 GONext();
3093 } else {
3094 CELL *pt0 = YREG + PREG->y_u.yxx.y;
3095 XREG(PREG->y_u.yxx.x1) = MkIntTerm(0);
3096 PREG = NEXTOP(PREG, yxx);
3097 INITIALIZE_PERMVAR(pt0, d0);
3098 GONext();
3099 }
3100
3101 BEGP(pt1);
3102 deref_body(d0, pt1, func2f_yx_unk, func2f_yx_nvar);
3103 Yap_AsmError(INSTANTIATION_ERROR,d0);
3104 ENDP(pt1);
3105 /* Oops, second argument was unbound too */
3106 FAIL();
3107 ENDD(d0);
3108 ENDOp();
3109
3110 Op(p_func2f_yy, yyx);
3111#ifdef LOW_LEVEL_TRACER
3112 if (Yap_do_low_level_trace) {
3113 HR[0] = XREG(PREG->y_u.yyx.x);
3114 RESET_VARIABLE(HR + 1);
3115 RESET_VARIABLE(HR + 2);
3116 low_level_trace(enter_pred,
3117 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
3118 HR);
3119 }
3120#endif /* LOW_LEVEL_TRACE */
3121 BEGD(d0);
3122 d0 = XREG(PREG->y_u.yyx.x);
3123 deref_head(d0, func2f_yy_unk);
3124 func2f_yy_nvar:
3125 if (IsApplTerm(d0)) {
3126 Functor d1 = FunctorOfTerm(d0);
3127 CELL *pt0 = YREG + PREG->y_u.yyx.y1;
3128 CELL *pt1 = YREG + PREG->y_u.yyx.y2;
3129 if (IsExtensionFunctor(d1)) {
3130 PREG = NEXTOP(PREG, yyx);
3131 INITIALIZE_PERMVAR(pt0, d0);
3132 INITIALIZE_PERMVAR(pt1, MkIntTerm(0));
3133 GONext();
3134 }
3135 PREG = NEXTOP(PREG, yyx);
3136 INITIALIZE_PERMVAR(pt0, MkAtomTerm(NameOfFunctor(d1)));
3137 INITIALIZE_PERMVAR(pt1, MkIntegerTerm(ArityOfFunctor(d1)));
3138 GONext();
3139 } else if (IsPairTerm(d0)) {
3140 CELL *pt0 = YREG + PREG->y_u.yyx.y1;
3141 CELL *pt1 = YREG + PREG->y_u.yyx.y2;
3142 PREG = NEXTOP(PREG, yyx);
3143 INITIALIZE_PERMVAR(pt0, TermDot);
3144 INITIALIZE_PERMVAR(pt1, MkIntTerm(2));
3145 GONext();
3146 } else {
3147 CELL *pt0 = YREG + PREG->y_u.yyx.y1;
3148 CELL *pt1 = YREG + PREG->y_u.yyx.y2;
3149 PREG = NEXTOP(PREG, yyx);
3150 INITIALIZE_PERMVAR(pt0, d0);
3151 INITIALIZE_PERMVAR(pt1, MkIntTerm(0));
3152 GONext();
3153 }
3154
3155 BEGP(pt1);
3156 deref_body(d0, pt1, func2f_yy_unk, func2f_yy_nvar);
3157 Yap_AsmError(INSTANTIATION_ERROR,d0);
3158 ENDP(pt1);
3159 /* Oops, second argument was unbound too */
3160 FAIL();
3161 ENDD(d0);
3162 ENDOp();
3163
3164 Op(p_functor, e);
3165#ifdef LOW_LEVEL_TRACER
3166 if (Yap_do_low_level_trace)
3167 low_level_trace(enter_pred,
3168 RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor, 0)),
3169 XREGS + 1);
3170#endif /* LOW_LEVEL_TRACE */
3171 restart_functor:
3172 BEGD(d0);
3173 d0 = ARG1;
3174 deref_head(d0, func_unk);
3175 func_nvar:
3176 /* A1 is bound */
3177 BEGD(d1);
3178 if (IsApplTerm(d0)) {
3179 d1 = *RepAppl(d0);
3180 if (IsExtensionFunctor((Functor)d1)) {
3181 if (d1 <= (CELL)FunctorDouble && d1 >= (CELL)FunctorLongInt) {
3182 d1 = MkIntTerm(0);
3183 } else
3184 FAIL();
3185 } else {
3186 d0 = MkAtomTerm(NameOfFunctor((Functor)d1));
3187 d1 = MkIntTerm(ArityOfFunctor((Functor)d1));
3188 }
3189 } else if (IsPairTerm(d0)) {
3190 d0 = TermDot;
3191 d1 = MkIntTerm(2);
3192 } else {
3193 d1 = MkIntTerm(0);
3194 }
3195 /* d1 and d0 now have the two arguments */
3196 /* let's go and bind them */
3197 {
3198 register CELL arity = d1;
3199
3200 d1 = ARG2;
3201 deref_head(d1, func_nvar_unk);
3202 func_nvar_nvar:
3203 /* A2 was bound */
3204 if (d0 != d1) {
3205 FAIL();
3206 }
3207 /* I have to this here so that I don't have a jump to a closing bracket
3208 */
3209 d0 = arity;
3210 goto func_bind_x3;
3211
3212 BEGP(pt0);
3213 deref_body(d1, pt0, func_nvar_unk, func_nvar_nvar);
3214 /* A2 is a variable, go and bind it */
3215 YapBind(pt0, d0);
3216 /* I have to this here so that I don't have a jump to a closing bracket
3217 */
3218 d0 = arity;
3219 ENDP(pt0);
3220 func_bind_x3:
3221 /* now let's process A3 */
3222 d1 = ARG3;
3223 deref_head(d1, func_nvar3_unk);
3224 func_nvar3_nvar:
3225 /* A3 was bound */
3226 if (d0 != d1) {
3227 FAIL();
3228 }
3229 /* Done */
3230 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e), Osbmp), l);
3231 GONext();
3232
3233 BEGP(pt0);
3234 deref_body(d1, pt0, func_nvar3_unk, func_nvar3_nvar);
3235 /* A3 is a variable, go and bind it */
3236 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e), Osbmp), l);
3237 YapBind(pt0, d0);
3238 /* Done */
3239 GONext();
3240
3241 ENDP(pt0);
3242 }
3243 ENDD(d1);
3244
3245 BEGP(pt0);
3246 deref_body(d0, pt0, func_unk, func_nvar);
3247 /* A1 is a variable */
3248 /* We have to build the structure */
3249 d0 = ARG2;
3250 deref_head(d0, func_var_2unk);
3251 func_var_2nvar:
3252 /* we do, let's get the third argument */
3253 BEGD(d1);
3254 d1 = ARG3;
3255 deref_head(d1, func_var_3unk);
3256 func_var_3nvar:
3257 /* Uuuff, the second and third argument are bound */
3258 if (IsIntTerm(d1))
3259 d1 = IntOfTerm(d1);
3260 else {
3261 Yap_AsmError(TYPE_ERROR_INTEGER, d1);
3262 FAIL();
3263 }
3264 if (!IsAtomicTerm(d0)) {
3265 Yap_AsmError(TYPE_ERROR_ATOM,d0);
3266 FAIL();
3267 } /* We made it!!!!! we got in d0 the name, in d1 the arity and
3268 * in pt0 the variable to bind it to. */
3269 if (d0 == TermDot && d1 == 2) {
3270 RESET_VARIABLE(HR);
3271 RESET_VARIABLE(HR + 1);
3272 d0 = AbsPair(HR);
3273 HR += 2;
3274 } else if ((Int)d1 > 0) {
3275 /* now let's build a compound term */
3276 if (!IsAtomTerm(d0)) {
3277 Yap_AsmError(TYPE_ERROR_ATOM,d0);
3278 FAIL();
3279 }
3280 BEGP(pt1);
3281 if (!IsAtomTerm(d0)) {
3282 FAIL();
3283 } else
3284 d0 = (CELL)Yap_MkFunctor(AtomOfTerm(d0), (Int)d1);
3285 pt1 = HR;
3286 *pt1++ = d0;
3287 d0 = AbsAppl(HR);
3288 if (pt1 + d1 > ENV || pt1 + d1 > (CELL *)B) {
3289 /* make sure we have something to show for our trouble */
3290 saveregs();
3291 if (!Yap_dogcl(d1 PASS_REGS)) {
3292 setregs();
3293 Yap_AsmError(INSTANTIATION_ERROR,d1);
3294 } else {
3295 setregs();
3296 }
3297 goto restart_functor; /* */
3298 }
3299 while ((Int)d1--) {
3300 RESET_VARIABLE(pt1);
3301 pt1++;
3302 }
3303 /* done building the term */
3304 HR = pt1;
3305 ENDP(pt1);
3306 } else if ((Int)d1 < 0) {
3307 Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
3308 FAIL();
3309 }
3310 /* else if arity is 0 just pass d0 through */
3311 /* Ding, ding, we made it */
3312 PREG = NEXTOP(NEXTOP(NEXTOP(PREG, e), Osbpp), l);
3313 YapBind(pt0, d0);
3314 GONext();
3315
3316 BEGP(pt1);
3317 deref_body(d1, pt1, func_var_3unk, func_var_3nvar);
3318 Yap_AsmError(INSTANTIATION_ERROR,d1);
3319 ENDP(pt1);
3320 /* Oops, third argument was unbound */
3321 FAIL();
3322 ENDD(d1);
3323
3324 BEGP(pt1);
3325 deref_body(d0, pt1, func_var_2unk, func_var_2nvar);
3326 Yap_AsmError(INSTANTIATION_ERROR,d0);
3327 ENDP(pt1);
3328 /* Oops, second argument was unbound too */
3329 FAIL();
3330 ENDP(pt0);
3331 ENDD(d0);
3332 ENDOp();
yami
Definition: amidefs.h:264