YAP 7.1.0
headclause.h
1
2 /* This file was generated automatically by "yap -L misc/buildops"
3 please do not update */
4
5
6 while (TRUE) {
7 op_numbers op = Yap_op_from_opcode(cl->opc);
8 switch (op) {
9#ifdef YAP_JIT
10 case _jit_handler:
11 cl = NEXTOP(cl,J);
12 break;
13 #endif
14 case _ensure_space:
15 cl = NEXTOP(cl,Osbpa);
16 break;
17 case _get_2atoms:
18 if (iarg == Yap_regnotoreg(1)) {
19 if (IsApplTerm(cl->y_u.cc.c1)) {
20 CELL *pt = RepAppl(cl->y_u.cc.c1);
21 clause->Tag = AbsAppl((CELL *)pt[0]);
22 clause->ucd.t_ptr = cl->y_u.cc.c1;
23 } else
24 clause->Tag = cl->y_u.cc.c1;
25 return;
26 }
27 if (iarg == Yap_regnotoreg(2)) {
28 if (IsApplTerm(cl->y_u.cc.c2)) {
29 CELL *pt = RepAppl(cl->y_u.cc.c2);
30 clause->Tag = AbsAppl((CELL *)pt[0]);
31 clause->ucd.t_ptr = cl->y_u.cc.c2;
32 } else
33 clause->Tag = cl->y_u.cc.c2;
34 return;
35 }
36 cl = NEXTOP(cl,cc);
37 break;
38 case _get_3atoms:
39 if (iarg == Yap_regnotoreg(1)) {
40 if (IsApplTerm(cl->y_u.ccc.c1)) {
41 CELL *pt = RepAppl(cl->y_u.ccc.c1);
42 clause->Tag = AbsAppl((CELL *)pt[0]);
43 clause->ucd.t_ptr = cl->y_u.ccc.c1;
44 } else
45 clause->Tag = cl->y_u.ccc.c1;
46 return;
47 }
48 if (iarg == Yap_regnotoreg(2)) {
49 if (IsApplTerm(cl->y_u.ccc.c2)) {
50 CELL *pt = RepAppl(cl->y_u.ccc.c2);
51 clause->Tag = AbsAppl((CELL *)pt[0]);
52 clause->ucd.t_ptr = cl->y_u.ccc.c2;
53 } else
54 clause->Tag = cl->y_u.ccc.c2;
55 return;
56 }
57 if (iarg == Yap_regnotoreg(3)) {
58 if (IsApplTerm(cl->y_u.ccc.c3)) {
59 CELL *pt = RepAppl(cl->y_u.ccc.c3);
60 clause->Tag = AbsAppl((CELL *)pt[0]);
61 clause->ucd.t_ptr = cl->y_u.ccc.c3;
62 } else
63 clause->Tag = cl->y_u.ccc.c3;
64 return;
65 }
66 cl = NEXTOP(cl,ccc);
67 break;
68 case _get_4atoms:
69 if (iarg == Yap_regnotoreg(1)) {
70 if (IsApplTerm(cl->y_u.cccc.c1)) {
71 CELL *pt = RepAppl(cl->y_u.cccc.c1);
72 clause->Tag = AbsAppl((CELL *)pt[0]);
73 clause->ucd.t_ptr = cl->y_u.cccc.c1;
74 } else
75 clause->Tag = cl->y_u.cccc.c1;
76 return;
77 }
78 if (iarg == Yap_regnotoreg(2)) {
79 if (IsApplTerm(cl->y_u.cccc.c2)) {
80 CELL *pt = RepAppl(cl->y_u.cccc.c2);
81 clause->Tag = AbsAppl((CELL *)pt[0]);
82 clause->ucd.t_ptr = cl->y_u.cccc.c2;
83 } else
84 clause->Tag = cl->y_u.cccc.c2;
85 return;
86 }
87 if (iarg == Yap_regnotoreg(3)) {
88 if (IsApplTerm(cl->y_u.cccc.c3)) {
89 CELL *pt = RepAppl(cl->y_u.cccc.c3);
90 clause->Tag = AbsAppl((CELL *)pt[0]);
91 clause->ucd.t_ptr = cl->y_u.cccc.c3;
92 } else
93 clause->Tag = cl->y_u.cccc.c3;
94 return;
95 }
96 if (iarg == Yap_regnotoreg(4)) {
97 if (IsApplTerm(cl->y_u.cccc.c4)) {
98 CELL *pt = RepAppl(cl->y_u.cccc.c4);
99 clause->Tag = AbsAppl((CELL *)pt[0]);
100 clause->ucd.t_ptr = cl->y_u.cccc.c4;
101 } else
102 clause->Tag = cl->y_u.cccc.c4;
103 return;
104 }
105 cl = NEXTOP(cl,cccc);
106 break;
107 case _get_5atoms:
108 if (iarg == Yap_regnotoreg(1)) {
109 if (IsApplTerm(cl->y_u.ccccc.c1)) {
110 CELL *pt = RepAppl(cl->y_u.ccccc.c1);
111 clause->Tag = AbsAppl((CELL *)pt[0]);
112 clause->ucd.t_ptr = cl->y_u.ccccc.c1;
113 } else
114 clause->Tag = cl->y_u.ccccc.c1;
115 return;
116 }
117 if (iarg == Yap_regnotoreg(2)) {
118 if (IsApplTerm(cl->y_u.ccccc.c2)) {
119 CELL *pt = RepAppl(cl->y_u.ccccc.c2);
120 clause->Tag = AbsAppl((CELL *)pt[0]);
121 clause->ucd.t_ptr = cl->y_u.ccccc.c2;
122 } else
123 clause->Tag = cl->y_u.ccccc.c2;
124 return;
125 }
126 if (iarg == Yap_regnotoreg(3)) {
127 if (IsApplTerm(cl->y_u.ccccc.c3)) {
128 CELL *pt = RepAppl(cl->y_u.ccccc.c3);
129 clause->Tag = AbsAppl((CELL *)pt[0]);
130 clause->ucd.t_ptr = cl->y_u.ccccc.c3;
131 } else
132 clause->Tag = cl->y_u.ccccc.c3;
133 return;
134 }
135 if (iarg == Yap_regnotoreg(4)) {
136 if (IsApplTerm(cl->y_u.ccccc.c4)) {
137 CELL *pt = RepAppl(cl->y_u.ccccc.c4);
138 clause->Tag = AbsAppl((CELL *)pt[0]);
139 clause->ucd.t_ptr = cl->y_u.ccccc.c4;
140 } else
141 clause->Tag = cl->y_u.ccccc.c4;
142 return;
143 }
144 if (iarg == Yap_regnotoreg(5)) {
145 if (IsApplTerm(cl->y_u.ccccc.c5)) {
146 CELL *pt = RepAppl(cl->y_u.ccccc.c5);
147 clause->Tag = AbsAppl((CELL *)pt[0]);
148 clause->ucd.t_ptr = cl->y_u.ccccc.c5;
149 } else
150 clause->Tag = cl->y_u.ccccc.c5;
151 return;
152 }
153 cl = NEXTOP(cl,ccccc);
154 break;
155 case _get_6atoms:
156 if (iarg == Yap_regnotoreg(1)) {
157 if (IsApplTerm(cl->y_u.cccccc.c1)) {
158 CELL *pt = RepAppl(cl->y_u.cccccc.c1);
159 clause->Tag = AbsAppl((CELL *)pt[0]);
160 clause->ucd.t_ptr = cl->y_u.cccccc.c1;
161 } else
162 clause->Tag = cl->y_u.cccccc.c1;
163 return;
164 }
165 if (iarg == Yap_regnotoreg(2)) {
166 if (IsApplTerm(cl->y_u.cccccc.c2)) {
167 CELL *pt = RepAppl(cl->y_u.cccccc.c2);
168 clause->Tag = AbsAppl((CELL *)pt[0]);
169 clause->ucd.t_ptr = cl->y_u.cccccc.c2;
170 } else
171 clause->Tag = cl->y_u.cccccc.c2;
172 return;
173 }
174 if (iarg == Yap_regnotoreg(3)) {
175 if (IsApplTerm(cl->y_u.cccccc.c3)) {
176 CELL *pt = RepAppl(cl->y_u.cccccc.c3);
177 clause->Tag = AbsAppl((CELL *)pt[0]);
178 clause->ucd.t_ptr = cl->y_u.cccccc.c3;
179 } else
180 clause->Tag = cl->y_u.cccccc.c3;
181 return;
182 }
183 if (iarg == Yap_regnotoreg(4)) {
184 if (IsApplTerm(cl->y_u.cccccc.c4)) {
185 CELL *pt = RepAppl(cl->y_u.cccccc.c4);
186 clause->Tag = AbsAppl((CELL *)pt[0]);
187 clause->ucd.t_ptr = cl->y_u.cccccc.c4;
188 } else
189 clause->Tag = cl->y_u.cccccc.c4;
190 return;
191 }
192 if (iarg == Yap_regnotoreg(5)) {
193 if (IsApplTerm(cl->y_u.cccccc.c5)) {
194 CELL *pt = RepAppl(cl->y_u.cccccc.c5);
195 clause->Tag = AbsAppl((CELL *)pt[0]);
196 clause->ucd.t_ptr = cl->y_u.cccccc.c5;
197 } else
198 clause->Tag = cl->y_u.cccccc.c5;
199 return;
200 }
201 if (iarg == Yap_regnotoreg(6)) {
202 if (IsApplTerm(cl->y_u.cccccc.c6)) {
203 CELL *pt = RepAppl(cl->y_u.cccccc.c6);
204 clause->Tag = AbsAppl((CELL *)pt[0]);
205 clause->ucd.t_ptr = cl->y_u.cccccc.c6;
206 } else
207 clause->Tag = cl->y_u.cccccc.c6;
208 return;
209 }
210 cl = NEXTOP(cl,cccccc);
211 break;
212 case _copy_idb_term:
213 if (regno != 2) {
214 clause->Tag = (CELL)NULL;
215 } else {
216 LogUpdClause *lcl = ClauseCodeToLogUpdClause(cl);
217 Term t = lcl->lusl.ClSource->Entry;
218
219 if (!(lcl->ClFlags & FactMask)) {
220 if (IsVarTerm(t)) {
221 clause->Tag = (CELL)NULL;
222 } else if (IsApplTerm(t)) {
223 CELL *pt = RepAppl(t);
224
225 clause->Tag = AbsAppl((CELL *)pt[0]);
226 if (IsExtensionFunctor(FunctorOfTerm(t))) {
227 clause->ucd.t_ptr = t;
228 } else {
229 clause->ucd.c_sreg = pt;
230 }
231 } else if (IsPairTerm(t)) {
232 CELL *pt = RepPair(t);
233
234 clause->Tag = AbsPair(NULL);
235 clause->ucd.c_sreg = pt-1;
236 } else {
237 clause->Tag = t;
238 }
239 }
240 }
241 return;
242 cl = NEXTOP(cl,e);
243 break;
244 case _pop:
245 cl = NEXTOP(cl,e);
246 break;
247 case _unify_idb_term:
248 if (regno != 2) {
249 clause->Tag = (CELL)NULL;
250 } else {
251 LogUpdClause *lcl = ClauseCodeToLogUpdClause(cl);
252 Term t = lcl->lusl.ClSource->Entry;
253
254 if (!(lcl->ClFlags & FactMask)) {
255 if (IsVarTerm(t)) {
256 clause->Tag = (CELL)NULL;
257 } else if (IsApplTerm(t)) {
258 CELL *pt = RepAppl(t);
259
260 clause->Tag = AbsAppl((CELL *)pt[0]);
261 if (IsExtensionFunctor(FunctorOfTerm(t))) {
262 clause->ucd.t_ptr = t;
263 } else {
264 clause->ucd.c_sreg = pt;
265 }
266 } else if (IsPairTerm(t)) {
267 CELL *pt = RepPair(t);
268
269 clause->Tag = AbsPair(NULL);
270 clause->ucd.c_sreg = pt-1;
271 } else {
272 clause->Tag = t;
273 }
274 }
275 }
276 return;
277 cl = NEXTOP(cl,e);
278 break;
279 case _unlock_lu:
280 cl = NEXTOP(cl,e);
281 break;
282 case _unify_l_list:
283 cl = NEXTOP(cl,o);
284 break;
285 case _unify_l_list_write:
286 cl = NEXTOP(cl,o);
287 break;
288 case _unify_l_void:
289 cl = NEXTOP(cl,o);
290 break;
291 case _unify_l_void_write:
292 cl = NEXTOP(cl,o);
293 break;
294 case _unify_list:
295 cl = NEXTOP(cl,o);
296 break;
297 case _unify_list_write:
298 cl = NEXTOP(cl,o);
299 break;
300 case _unify_void:
301 cl = NEXTOP(cl,o);
302 break;
303 case _unify_void_write:
304 cl = NEXTOP(cl,o);
305 break;
306 case _unify_dbterm:
307 cl = NEXTOP(cl,oD);
308 break;
309 case _unify_l_dbterm:
310 cl = NEXTOP(cl,oD);
311 break;
312 case _unify_bigint:
313 cl = NEXTOP(cl,oN);
314 break;
315 case _unify_l_bigint:
316 cl = NEXTOP(cl,oN);
317 break;
318 case _unify_atom:
319 cl = NEXTOP(cl,oc);
320 break;
321 case _unify_atom_write:
322 cl = NEXTOP(cl,oc);
323 break;
324 case _unify_l_atom:
325 cl = NEXTOP(cl,oc);
326 break;
327 case _unify_l_atom_write:
328 cl = NEXTOP(cl,oc);
329 break;
330 case _unify_float:
331 cl = NEXTOP(cl,od);
332 break;
333 case _unify_float_write:
334 cl = NEXTOP(cl,od);
335 break;
336 case _unify_l_float:
337 cl = NEXTOP(cl,od);
338 break;
339 case _unify_l_float_write:
340 cl = NEXTOP(cl,od);
341 break;
342 case _unify_l_struc:
343 cl = NEXTOP(cl,ofa);
344 break;
345 case _unify_l_struc_write:
346 cl = NEXTOP(cl,ofa);
347 break;
348 case _unify_struct:
349 cl = NEXTOP(cl,ofa);
350 break;
351 case _unify_struct_write:
352 cl = NEXTOP(cl,ofa);
353 break;
354 case _unify_l_longint:
355 cl = NEXTOP(cl,oi);
356 break;
357 case _unify_l_longint_write:
358 cl = NEXTOP(cl,oi);
359 break;
360 case _unify_longint:
361 cl = NEXTOP(cl,oi);
362 break;
363 case _unify_longint_write:
364 cl = NEXTOP(cl,oi);
365 break;
366 case _unify_l_n_voids:
367 cl = NEXTOP(cl,os);
368 break;
369 case _unify_l_n_voids_write:
370 cl = NEXTOP(cl,os);
371 break;
372 case _unify_n_voids:
373 cl = NEXTOP(cl,os);
374 break;
375 case _unify_n_voids_write:
376 cl = NEXTOP(cl,os);
377 break;
378 case _unify_n_atoms:
379 cl = NEXTOP(cl,osc);
380 break;
381 case _unify_n_atoms_write:
382 cl = NEXTOP(cl,osc);
383 break;
384 case _unify_l_string:
385 cl = NEXTOP(cl,ou);
386 break;
387 case _unify_string:
388 cl = NEXTOP(cl,ou);
389 break;
390 case _save_appl_x:
391 if (iarg == cl->y_u.ox.x) {
392 clause->Tag = (CELL)NULL;
393 return;
394 }
395 cl = NEXTOP(cl,ox);
396 break;
397 case _save_appl_x_write:
398 if (iarg == cl->y_u.ox.x) {
399 clause->Tag = (CELL)NULL;
400 return;
401 }
402 cl = NEXTOP(cl,ox);
403 break;
404 case _save_pair_x:
405 if (iarg == cl->y_u.ox.x) {
406 clause->Tag = (CELL)NULL;
407 return;
408 }
409 cl = NEXTOP(cl,ox);
410 break;
411 case _save_pair_x_write:
412 if (iarg == cl->y_u.ox.x) {
413 clause->Tag = (CELL)NULL;
414 return;
415 }
416 cl = NEXTOP(cl,ox);
417 break;
418 case _unify_l_x_loc:
419 cl = NEXTOP(cl,ox);
420 break;
421 case _unify_l_x_loc_write:
422 cl = NEXTOP(cl,ox);
423 break;
424 case _unify_l_x_val:
425 cl = NEXTOP(cl,ox);
426 break;
427 case _unify_l_x_val_write:
428 cl = NEXTOP(cl,ox);
429 break;
430 case _unify_l_x_var:
431 if (iarg == cl->y_u.ox.x) {
432 clause->Tag = (CELL)NULL;
433 return;
434 }
435 cl = NEXTOP(cl,ox);
436 break;
437 case _unify_l_x_var_write:
438 if (iarg == cl->y_u.ox.x) {
439 clause->Tag = (CELL)NULL;
440 return;
441 }
442 cl = NEXTOP(cl,ox);
443 break;
444 case _unify_x_loc:
445 cl = NEXTOP(cl,ox);
446 break;
447 case _unify_x_loc_write:
448 cl = NEXTOP(cl,ox);
449 break;
450 case _unify_x_val:
451 cl = NEXTOP(cl,ox);
452 break;
453 case _unify_x_val_write:
454 cl = NEXTOP(cl,ox);
455 break;
456 case _unify_x_var:
457 if (iarg == cl->y_u.ox.x) {
458 clause->Tag = (CELL)NULL;
459 return;
460 }
461 cl = NEXTOP(cl,ox);
462 break;
463 case _unify_x_var_write:
464 if (iarg == cl->y_u.ox.x) {
465 clause->Tag = (CELL)NULL;
466 return;
467 }
468 cl = NEXTOP(cl,ox);
469 break;
470 case _unify_l_x_var2:
471 if (iarg == cl->y_u.oxx.xl) {
472 clause->Tag = (CELL)NULL;
473 return;
474 }
475 if (iarg == cl->y_u.oxx.xr) {
476 clause->Tag = (CELL)NULL;
477 return;
478 }
479 cl = NEXTOP(cl,oxx);
480 break;
481 case _unify_l_x_var2_write:
482 if (iarg == cl->y_u.oxx.xl) {
483 clause->Tag = (CELL)NULL;
484 return;
485 }
486 if (iarg == cl->y_u.oxx.xr) {
487 clause->Tag = (CELL)NULL;
488 return;
489 }
490 cl = NEXTOP(cl,oxx);
491 break;
492 case _unify_x_var2:
493 if (iarg == cl->y_u.oxx.xl) {
494 clause->Tag = (CELL)NULL;
495 return;
496 }
497 if (iarg == cl->y_u.oxx.xr) {
498 clause->Tag = (CELL)NULL;
499 return;
500 }
501 cl = NEXTOP(cl,oxx);
502 break;
503 case _unify_x_var2_write:
504 if (iarg == cl->y_u.oxx.xl) {
505 clause->Tag = (CELL)NULL;
506 return;
507 }
508 if (iarg == cl->y_u.oxx.xr) {
509 clause->Tag = (CELL)NULL;
510 return;
511 }
512 cl = NEXTOP(cl,oxx);
513 break;
514 case _save_appl_y:
515 cl = NEXTOP(cl,oy);
516 break;
517 case _save_appl_y_write:
518 cl = NEXTOP(cl,oy);
519 break;
520 case _save_pair_y:
521 cl = NEXTOP(cl,oy);
522 break;
523 case _save_pair_y_write:
524 cl = NEXTOP(cl,oy);
525 break;
526 case _unify_l_y_loc:
527 cl = NEXTOP(cl,oy);
528 break;
529 case _unify_l_y_loc_write:
530 cl = NEXTOP(cl,oy);
531 break;
532 case _unify_l_y_val:
533 cl = NEXTOP(cl,oy);
534 break;
535 case _unify_l_y_val_write:
536 cl = NEXTOP(cl,oy);
537 break;
538 case _unify_l_y_var:
539 cl = NEXTOP(cl,oy);
540 break;
541 case _unify_l_y_var_write:
542 cl = NEXTOP(cl,oy);
543 break;
544 case _unify_y_loc:
545 cl = NEXTOP(cl,oy);
546 break;
547 case _unify_y_loc_write:
548 cl = NEXTOP(cl,oy);
549 break;
550 case _unify_y_val:
551 cl = NEXTOP(cl,oy);
552 break;
553 case _unify_y_val_write:
554 cl = NEXTOP(cl,oy);
555 break;
556 case _unify_y_var:
557 cl = NEXTOP(cl,oy);
558 break;
559 case _unify_y_var_write:
560 cl = NEXTOP(cl,oy);
561 break;
562 case _pop_n:
563 cl = NEXTOP(cl,s);
564 break;
565 case _get_list:
566 if (iarg == cl->y_u.x.x) {
567 clause->Tag = AbsPair(NULL);
568 clause->ucd.WorkPC = NEXTOP(cl,x);
569 return;
570 }
571 cl = NEXTOP(cl,x);
572 break;
573 case _put_list:
574 if (iarg == cl->y_u.x.x) {
575 clause->Tag = (CELL)NULL;
576 return;
577 }
578 cl = NEXTOP(cl,x);
579 break;
580 case _put_dbterm:
581 if (iarg == cl->y_u.xD.x) {
582 clause->Tag = (CELL)NULL;
583 return;
584 }
585 cl = NEXTOP(cl,xD);
586 break;
587 case _get_bigint:
588 if (iarg == cl->y_u.xN.x) {
589 clause->Tag = AbsAppl((CELL *)FunctorBigInt);
590 clause->ucd.t_ptr = (CELL)NULL;
591 return;
592 }
593 cl = NEXTOP(cl,xN);
594 break;
595 case _put_bigint:
596 if (iarg == cl->y_u.xN.x) {
597 clause->Tag = (CELL)NULL;
598 return;
599 }
600 cl = NEXTOP(cl,xN);
601 break;
602 case _get_atom:
603 if (iarg == cl->y_u.xc.x) {
604 if (IsApplTerm(cl->y_u.xc.c)) {
605 CELL *pt = RepAppl(cl->y_u.xc.c);
606 clause->Tag = AbsAppl((CELL *)pt[0]);
607 clause->ucd.t_ptr = cl->y_u.xc.c;
608 } else
609 clause->Tag = cl->y_u.xc.c;
610 return;
611 }
612 cl = NEXTOP(cl,xc);
613 break;
614 case _put_atom:
615 if (iarg == cl->y_u.xc.x) {
616 clause->Tag = (CELL)NULL;
617 return;
618 }
619 cl = NEXTOP(cl,xc);
620 break;
621 case _get_float:
622 if (iarg == cl->y_u.xd.x) {
623 clause->Tag = AbsAppl((CELL *)FunctorDouble);
624 clause->ucd.t_ptr = AbsAppl(cl->y_u.xd.d);
625 return;
626 }
627 cl = NEXTOP(cl,xd);
628 break;
629 case _put_float:
630 if (iarg == cl->y_u.xd.x) {
631 clause->Tag = (CELL)NULL;
632 return;
633 }
634 cl = NEXTOP(cl,xd);
635 break;
636 case _get_struct:
637 if (iarg == cl->y_u.xfa.x) {
638 clause->Tag = AbsAppl((CELL *)cl->y_u.xfa.f);
639 clause->ucd.WorkPC = NEXTOP(cl,xfa);
640 return;
641 }
642 cl = NEXTOP(cl,xfa);
643 break;
644 case _put_struct:
645 if (iarg == cl->y_u.xfa.x) {
646 clause->Tag = (CELL)NULL;
647 return;
648 }
649 cl = NEXTOP(cl,xfa);
650 break;
651 case _get_longint:
652 if (iarg == cl->y_u.xi.x) {
653 clause->Tag = AbsAppl((CELL *)FunctorLongInt);
654 clause->ucd.t_ptr = AbsAppl(cl->y_u.xi.i);
655 return;
656 }
657 cl = NEXTOP(cl,xi);
658 break;
659 case _put_longint:
660 if (iarg == cl->y_u.xi.x) {
661 clause->Tag = (CELL)NULL;
662 return;
663 }
664 cl = NEXTOP(cl,xi);
665 break;
666 case _get_string:
667 if (iarg == cl->y_u.xu.x) {
668 clause->Tag = AbsAppl((CELL *)FunctorString);
669 clause->ucd.t_ptr = (CELL)NULL;
670 return;
671 }
672 cl = NEXTOP(cl,xu);
673 break;
674 case _get_x_val:
675 if (cl->y_u.xx.xl == iarg ||
676 cl->y_u.xx.xr == iarg) {
677 clause->Tag = (CELL)NULL;
678 return;
679 }
680 cl = NEXTOP(cl,xx);
681 break;
682 case _get_x_var:
683 if (cl->y_u.xx.xr == iarg ||
684 cl->y_u.xx.xl == iarg) {
685 clause->Tag = (CELL)NULL;
686 return;
687 }
688 cl = NEXTOP(cl,xx);
689 break;
690 case _gl_void_valx:
691 if (iarg == cl->y_u.xx.xl) {
692 clause->Tag = AbsPair(NULL);
693 clause->ucd.WorkPC = cl;
694 return;
695 }
696 cl = NEXTOP(cl,xx);
697 break;
698 case _gl_void_varx:
699 if (iarg == cl->y_u.xx.xl) {
700 clause->Tag = AbsPair(NULL);
701 clause->ucd.WorkPC = cl;
702 return;
703 }
704 if (iarg == cl->y_u.xx.xr) {
705 clause->Tag = (CELL)NULL;
706 return;
707 }
708 cl = NEXTOP(cl,xx);
709 break;
710 case _glist_valx:
711 if (iarg == cl->y_u.xx.xl) {
712 clause->Tag = AbsPair(NULL);
713 clause->ucd.WorkPC = cl;
714 return;
715 }
716 cl = NEXTOP(cl,xx);
717 break;
718 case _put_x_val:
719 if (cl->y_u.xx.xl == iarg ||
720 cl->y_u.xx.xr == iarg) {
721 clause->Tag = (CELL)NULL;
722 return;
723 }
724 cl = NEXTOP(cl,xx);
725 break;
726 case _put_x_var:
727 if (iarg == cl->y_u.xx.xl) {
728 clause->Tag = (CELL)NULL;
729 return;
730 }
731 if (iarg == cl->y_u.xx.xr) {
732 clause->Tag = (CELL)NULL;
733 return;
734 }
735 cl = NEXTOP(cl,xx);
736 break;
737 case _put_xx_val:
738 if (cl->y_u.xxxx.xl1 == iarg ||
739 cl->y_u.xxxx.xr1 == iarg) {
740 clause->Tag = (CELL)NULL;
741 return;
742 }
743 if (cl->y_u.xxxx.xl2 == iarg ||
744 cl->y_u.xxxx.xr2 == iarg) {
745 clause->Tag = (CELL)NULL;
746 return;
747 }
748 cl = NEXTOP(cl,xxxx);
749 break;
750 case _get_y_val:
751 if (cl->y_u.yx.x == iarg) {
752 clause->Tag = (CELL)NULL;
753 return;
754 }
755 cl = NEXTOP(cl,yx);
756 break;
757 case _get_y_var:
758 if (cl->y_u.yx.x == iarg) {
759 clause->Tag = (CELL)NULL;
760 return;
761 }
762 cl = NEXTOP(cl,yx);
763 break;
764 case _gl_void_valy:
765 cl = NEXTOP(cl,yx);
766 break;
767 case _gl_void_vary:
768 cl = NEXTOP(cl,yx);
769 break;
770 case _glist_valy:
771 if (iarg == cl->y_u.yx.x) {
772 clause->Tag = AbsPair(NULL);
773 clause->ucd.WorkPC = cl;
774 return;
775 }
776 cl = NEXTOP(cl,yx);
777 break;
778 case _put_unsafe:
779 if (cl->y_u.yx.x == iarg) {
780 clause->Tag = (CELL)NULL;
781 return;
782 }
783 cl = NEXTOP(cl,yx);
784 break;
785 case _put_y_val:
786 if (cl->y_u.yx.x == iarg) {
787 clause->Tag = (CELL)NULL;
788 return;
789 }
790 cl = NEXTOP(cl,yx);
791 break;
792 case _put_y_var:
793 if (iarg == cl->y_u.yx.x) {
794 clause->Tag = (CELL)NULL;
795 return;
796 }
797 cl = NEXTOP(cl,yx);
798 break;
799 case _get_yy_var:
800 if (cl->y_u.yyxx.x1 == iarg) {
801 clause->Tag = (CELL)NULL;
802 return;
803 }
804 if (cl->y_u.yyxx.x2 == iarg) {
805 clause->Tag = (CELL)NULL;
806 return;
807 }
808 cl = NEXTOP(cl,yyxx);
809 break;
810#ifdef YAPOR
811#endif
812#ifdef TABLING
813 case _table_try_single:
814 cl = NEXTOP(cl,Otapl);
815 break;
816#endif
817default:
818 clause->Tag = (CELL)NULL;
819 return;
820 }
821 }
logic_upd_clause
Definition: clause.h:64