YAP 7.1.0
findclause.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 case _write_dbterm:
10 cl = NEXTOP(cl,D);
11 break;
12#ifdef YAP_JIT
13 case _jit_handler:
14#endif
15 cl = NEXTOP(cl,J);
16 break;
17 case _alloc_for_logical_pred:
18 cl = NEXTOP(cl,L);
19 break;
20 case _write_bigint:
21 cl = NEXTOP(cl,N);
22 break;
23 case _ensure_space:
24 cl = NEXTOP(cl,Osbpa);
25 break;
26 case _write_atom:
27 cl = NEXTOP(cl,c);
28 break;
29 case _get_2atoms:
30 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(1))) {
31 if (IsApplTerm(cl->y_u.cc.c1)) {
32 CELL *pt = RepAppl(cl->y_u.cc.c1);
33 clause->Tag = AbsAppl((CELL *)pt[0]);
34 clause->ucd.t_ptr = cl->y_u.cc.c1;
35 } else
36 clause->Tag = cl->y_u.cc.c1;
37 return;
38 }
39 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(2))) {
40 if (IsApplTerm(cl->y_u.cc.c2)) {
41 CELL *pt = RepAppl(cl->y_u.cc.c2);
42 clause->Tag = AbsAppl((CELL *)pt[0]);
43 clause->ucd.t_ptr = cl->y_u.cc.c2;
44 } else
45 clause->Tag = cl->y_u.cc.c2;
46 return;
47 }
48 cl = NEXTOP(cl,cc);
49 break;
50 case _get_3atoms:
51 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(1))) {
52 if (IsApplTerm(cl->y_u.ccc.c1)) {
53 CELL *pt = RepAppl(cl->y_u.ccc.c1);
54 clause->Tag = AbsAppl((CELL *)pt[0]);
55 clause->ucd.t_ptr = cl->y_u.ccc.c1;
56 } else
57 clause->Tag = cl->y_u.ccc.c1;
58 return;
59 }
60 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(2))) {
61 if (IsApplTerm(cl->y_u.ccc.c2)) {
62 CELL *pt = RepAppl(cl->y_u.ccc.c2);
63 clause->Tag = AbsAppl((CELL *)pt[0]);
64 clause->ucd.t_ptr = cl->y_u.ccc.c2;
65 } else
66 clause->Tag = cl->y_u.ccc.c2;
67 return;
68 }
69 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(3))) {
70 if (IsApplTerm(cl->y_u.ccc.c3)) {
71 CELL *pt = RepAppl(cl->y_u.ccc.c3);
72 clause->Tag = AbsAppl((CELL *)pt[0]);
73 clause->ucd.t_ptr = cl->y_u.ccc.c3;
74 } else
75 clause->Tag = cl->y_u.ccc.c3;
76 return;
77 }
78 cl = NEXTOP(cl,ccc);
79 break;
80 case _get_4atoms:
81 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(1))) {
82 if (IsApplTerm(cl->y_u.cccc.c1)) {
83 CELL *pt = RepAppl(cl->y_u.cccc.c1);
84 clause->Tag = AbsAppl((CELL *)pt[0]);
85 clause->ucd.t_ptr = cl->y_u.cccc.c1;
86 } else
87 clause->Tag = cl->y_u.cccc.c1;
88 return;
89 }
90 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(2))) {
91 if (IsApplTerm(cl->y_u.cccc.c2)) {
92 CELL *pt = RepAppl(cl->y_u.cccc.c2);
93 clause->Tag = AbsAppl((CELL *)pt[0]);
94 clause->ucd.t_ptr = cl->y_u.cccc.c2;
95 } else
96 clause->Tag = cl->y_u.cccc.c2;
97 return;
98 }
99 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(3))) {
100 if (IsApplTerm(cl->y_u.cccc.c3)) {
101 CELL *pt = RepAppl(cl->y_u.cccc.c3);
102 clause->Tag = AbsAppl((CELL *)pt[0]);
103 clause->ucd.t_ptr = cl->y_u.cccc.c3;
104 } else
105 clause->Tag = cl->y_u.cccc.c3;
106 return;
107 }
108 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(4))) {
109 if (IsApplTerm(cl->y_u.cccc.c4)) {
110 CELL *pt = RepAppl(cl->y_u.cccc.c4);
111 clause->Tag = AbsAppl((CELL *)pt[0]);
112 clause->ucd.t_ptr = cl->y_u.cccc.c4;
113 } else
114 clause->Tag = cl->y_u.cccc.c4;
115 return;
116 }
117 cl = NEXTOP(cl,cccc);
118 break;
119 case _get_5atoms:
120 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(1))) {
121 if (IsApplTerm(cl->y_u.ccccc.c1)) {
122 CELL *pt = RepAppl(cl->y_u.ccccc.c1);
123 clause->Tag = AbsAppl((CELL *)pt[0]);
124 clause->ucd.t_ptr = cl->y_u.ccccc.c1;
125 } else
126 clause->Tag = cl->y_u.ccccc.c1;
127 return;
128 }
129 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(2))) {
130 if (IsApplTerm(cl->y_u.ccccc.c2)) {
131 CELL *pt = RepAppl(cl->y_u.ccccc.c2);
132 clause->Tag = AbsAppl((CELL *)pt[0]);
133 clause->ucd.t_ptr = cl->y_u.ccccc.c2;
134 } else
135 clause->Tag = cl->y_u.ccccc.c2;
136 return;
137 }
138 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(3))) {
139 if (IsApplTerm(cl->y_u.ccccc.c3)) {
140 CELL *pt = RepAppl(cl->y_u.ccccc.c3);
141 clause->Tag = AbsAppl((CELL *)pt[0]);
142 clause->ucd.t_ptr = cl->y_u.ccccc.c3;
143 } else
144 clause->Tag = cl->y_u.ccccc.c3;
145 return;
146 }
147 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(4))) {
148 if (IsApplTerm(cl->y_u.ccccc.c4)) {
149 CELL *pt = RepAppl(cl->y_u.ccccc.c4);
150 clause->Tag = AbsAppl((CELL *)pt[0]);
151 clause->ucd.t_ptr = cl->y_u.ccccc.c4;
152 } else
153 clause->Tag = cl->y_u.ccccc.c4;
154 return;
155 }
156 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(5))) {
157 if (IsApplTerm(cl->y_u.ccccc.c5)) {
158 CELL *pt = RepAppl(cl->y_u.ccccc.c5);
159 clause->Tag = AbsAppl((CELL *)pt[0]);
160 clause->ucd.t_ptr = cl->y_u.ccccc.c5;
161 } else
162 clause->Tag = cl->y_u.ccccc.c5;
163 return;
164 }
165 cl = NEXTOP(cl,ccccc);
166 break;
167 case _get_6atoms:
168 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(1))) {
169 if (IsApplTerm(cl->y_u.cccccc.c1)) {
170 CELL *pt = RepAppl(cl->y_u.cccccc.c1);
171 clause->Tag = AbsAppl((CELL *)pt[0]);
172 clause->ucd.t_ptr = cl->y_u.cccccc.c1;
173 } else
174 clause->Tag = cl->y_u.cccccc.c1;
175 return;
176 }
177 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(2))) {
178 if (IsApplTerm(cl->y_u.cccccc.c2)) {
179 CELL *pt = RepAppl(cl->y_u.cccccc.c2);
180 clause->Tag = AbsAppl((CELL *)pt[0]);
181 clause->ucd.t_ptr = cl->y_u.cccccc.c2;
182 } else
183 clause->Tag = cl->y_u.cccccc.c2;
184 return;
185 }
186 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(3))) {
187 if (IsApplTerm(cl->y_u.cccccc.c3)) {
188 CELL *pt = RepAppl(cl->y_u.cccccc.c3);
189 clause->Tag = AbsAppl((CELL *)pt[0]);
190 clause->ucd.t_ptr = cl->y_u.cccccc.c3;
191 } else
192 clause->Tag = cl->y_u.cccccc.c3;
193 return;
194 }
195 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(4))) {
196 if (IsApplTerm(cl->y_u.cccccc.c4)) {
197 CELL *pt = RepAppl(cl->y_u.cccccc.c4);
198 clause->Tag = AbsAppl((CELL *)pt[0]);
199 clause->ucd.t_ptr = cl->y_u.cccccc.c4;
200 } else
201 clause->Tag = cl->y_u.cccccc.c4;
202 return;
203 }
204 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(5))) {
205 if (IsApplTerm(cl->y_u.cccccc.c5)) {
206 CELL *pt = RepAppl(cl->y_u.cccccc.c5);
207 clause->Tag = AbsAppl((CELL *)pt[0]);
208 clause->ucd.t_ptr = cl->y_u.cccccc.c5;
209 } else
210 clause->Tag = cl->y_u.cccccc.c5;
211 return;
212 }
213 if (is_regcopy(myregs, nofregs, Yap_regnotoreg(6))) {
214 if (IsApplTerm(cl->y_u.cccccc.c6)) {
215 CELL *pt = RepAppl(cl->y_u.cccccc.c6);
216 clause->Tag = AbsAppl((CELL *)pt[0]);
217 clause->ucd.t_ptr = cl->y_u.cccccc.c6;
218 } else
219 clause->Tag = cl->y_u.cccccc.c6;
220 return;
221 }
222 cl = NEXTOP(cl,cccccc);
223 break;
224 case _write_float:
225 cl = NEXTOP(cl,d);
226 break;
227 case _allocate:
228 cl = NEXTOP(cl,e);
229 break;
230 case _copy_idb_term:
231 if (regno == 2) {
232 LogUpdClause *lcl = ClauseCodeToLogUpdClause(cl);
233 Term t = lcl->lusl.ClSource->Entry;
234 if (!(lcl->ClFlags & FactMask)) {
235 if (IsVarTerm(t)) {
236 clause->Tag = (CELL)NULL;
237 } else if (IsApplTerm(t)) {
238 CELL *pt = RepAppl(t);
239
240 clause->Tag = AbsAppl((CELL *)pt[0]);
241 clause->ucd.c_sreg = pt;
242 } else if (IsPairTerm(t)) {
243 CELL *pt = RepPair(t);
244
245 clause->Tag = AbsPair(NULL);
246 clause->ucd.c_sreg = pt-1;
247 } else {
248 clause->Tag = t;
249 }
250 }
251 } else {
252 clause->Tag = (CELL)NULL;
253 }
254 return;
255 cl = NEXTOP(cl,e);
256 break;
257 case _pop:
258 cl = NEXTOP(cl,e);
259 break;
260#ifdef BEAM
261 case _retry_eam:
262#endif
263 cl = NEXTOP(cl,e);
264 break;
265 case _unify_idb_term:
266 if (regno == 2) {
267 LogUpdClause *lcl = ClauseCodeToLogUpdClause(cl);
268 Term t = lcl->lusl.ClSource->Entry;
269 if (!(lcl->ClFlags & FactMask)) {
270 if (IsVarTerm(t)) {
271 clause->Tag = (CELL)NULL;
272 } else if (IsApplTerm(t)) {
273 CELL *pt = RepAppl(t);
274
275 clause->Tag = AbsAppl((CELL *)pt[0]);
276 clause->ucd.c_sreg = pt;
277 } else if (IsPairTerm(t)) {
278 CELL *pt = RepPair(t);
279
280 clause->Tag = AbsPair(NULL);
281 clause->ucd.c_sreg = pt-1;
282 } else {
283 clause->Tag = t;
284 }
285 }
286 } else {
287 clause->Tag = (CELL)NULL;
288 }
289 return;
290 cl = NEXTOP(cl,e);
291 break;
292 case _unlock_lu:
293 cl = NEXTOP(cl,e);
294 break;
295 case _write_l_list:
296 cl = NEXTOP(cl,e);
297 break;
298 case _write_list:
299 cl = NEXTOP(cl,e);
300 break;
301 case _write_void:
302 cl = NEXTOP(cl,e);
303 break;
304 case _write_l_struc:
305 cl = NEXTOP(cl,fa);
306 break;
307 case _write_longint:
308 cl = NEXTOP(cl,i);
309 break;
310 case _unify_l_list:
311 cl = NEXTOP(cl,o);
312 break;
313 case _unify_l_list_write:
314 cl = NEXTOP(cl,o);
315 break;
316 case _unify_l_void:
317 cl = NEXTOP(cl,o);
318 break;
319 case _unify_l_void_write:
320 cl = NEXTOP(cl,o);
321 break;
322 case _unify_list:
323 cl = NEXTOP(cl,o);
324 break;
325 case _unify_list_write:
326 cl = NEXTOP(cl,o);
327 break;
328 case _unify_void:
329 cl = NEXTOP(cl,o);
330 break;
331 case _unify_void_write:
332 cl = NEXTOP(cl,o);
333 break;
334 case _unify_dbterm:
335 cl = NEXTOP(cl,oD);
336 break;
337 case _unify_l_dbterm:
338 cl = NEXTOP(cl,oD);
339 break;
340 case _unify_bigint:
341 cl = NEXTOP(cl,oN);
342 break;
343 case _unify_l_bigint:
344 cl = NEXTOP(cl,oN);
345 break;
346 case _unify_atom:
347 cl = NEXTOP(cl,oc);
348 break;
349 case _unify_atom_write:
350 cl = NEXTOP(cl,oc);
351 break;
352 case _unify_l_atom:
353 cl = NEXTOP(cl,oc);
354 break;
355 case _unify_l_atom_write:
356 cl = NEXTOP(cl,oc);
357 break;
358 case _unify_float:
359 cl = NEXTOP(cl,od);
360 break;
361 case _unify_float_write:
362 cl = NEXTOP(cl,od);
363 break;
364 case _unify_l_float:
365 cl = NEXTOP(cl,od);
366 break;
367 case _unify_l_float_write:
368 cl = NEXTOP(cl,od);
369 break;
370 case _unify_l_struc:
371 cl = NEXTOP(cl,ofa);
372 break;
373 case _unify_l_struc_write:
374 cl = NEXTOP(cl,ofa);
375 break;
376 case _unify_struct:
377 cl = NEXTOP(cl,ofa);
378 break;
379 case _unify_struct_write:
380 cl = NEXTOP(cl,ofa);
381 break;
382 case _unify_l_longint:
383 cl = NEXTOP(cl,oi);
384 break;
385 case _unify_l_longint_write:
386 cl = NEXTOP(cl,oi);
387 break;
388 case _unify_longint:
389 cl = NEXTOP(cl,oi);
390 break;
391 case _unify_longint_write:
392 cl = NEXTOP(cl,oi);
393 break;
394#ifdef BEAM
395 case _run_eam:
396#endif
397 cl = NEXTOP(cl,os);
398 break;
399 case _unify_l_n_voids:
400 cl = NEXTOP(cl,os);
401 break;
402 case _unify_l_n_voids_write:
403 cl = NEXTOP(cl,os);
404 break;
405 case _unify_n_voids:
406 cl = NEXTOP(cl,os);
407 break;
408 case _unify_n_voids_write:
409 cl = NEXTOP(cl,os);
410 break;
411 case _unify_n_atoms:
412 cl = NEXTOP(cl,osc);
413 break;
414 case _unify_n_atoms_write:
415 cl = NEXTOP(cl,osc);
416 break;
417 case _unify_l_string:
418 cl = NEXTOP(cl,ou);
419 break;
420 case _unify_string:
421 cl = NEXTOP(cl,ou);
422 break;
423 case _save_appl_x:
424 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
425 clause->Tag = (CELL)NULL;
426 return;
427 }
428 cl = NEXTOP(cl,ox);
429 break;
430 case _save_appl_x_write:
431 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
432 clause->Tag = (CELL)NULL;
433 return;
434 }
435 cl = NEXTOP(cl,ox);
436 break;
437 case _save_pair_x:
438 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
439 clause->Tag = (CELL)NULL;
440 return;
441 }
442 cl = NEXTOP(cl,ox);
443 break;
444 case _save_pair_x_write:
445 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
446 clause->Tag = (CELL)NULL;
447 return;
448 }
449 cl = NEXTOP(cl,ox);
450 break;
451 case _unify_l_x_loc:
452 cl = NEXTOP(cl,ox);
453 break;
454 case _unify_l_x_loc_write:
455 cl = NEXTOP(cl,ox);
456 break;
457 case _unify_l_x_val:
458 cl = NEXTOP(cl,ox);
459 break;
460 case _unify_l_x_val_write:
461 cl = NEXTOP(cl,ox);
462 break;
463 case _unify_l_x_var:
464 if (!(nofregs = delete_regcopy(myregs, nofregs, 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_var_write:
471 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
472 clause->Tag = (CELL)NULL;
473 return;
474 }
475 cl = NEXTOP(cl,ox);
476 break;
477 case _unify_x_loc:
478 cl = NEXTOP(cl,ox);
479 break;
480 case _unify_x_loc_write:
481 cl = NEXTOP(cl,ox);
482 break;
483 case _unify_x_val:
484 cl = NEXTOP(cl,ox);
485 break;
486 case _unify_x_val_write:
487 cl = NEXTOP(cl,ox);
488 break;
489 case _unify_x_var:
490 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
491 clause->Tag = (CELL)NULL;
492 return;
493 }
494 cl = NEXTOP(cl,ox);
495 break;
496 case _unify_x_var_write:
497 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.ox.x))) {
498 clause->Tag = (CELL)NULL;
499 return;
500 }
501 cl = NEXTOP(cl,ox);
502 break;
503 case _unify_l_x_var2:
504 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xl))) {
505 clause->Tag = (CELL)NULL;
506 return;
507 }
508 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xr))) {
509 clause->Tag = (CELL)NULL;
510 return;
511 }
512 cl = NEXTOP(cl,oxx);
513 break;
514 case _unify_l_x_var2_write:
515 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xl))) {
516 clause->Tag = (CELL)NULL;
517 return;
518 }
519 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xr))) {
520 clause->Tag = (CELL)NULL;
521 return;
522 }
523 cl = NEXTOP(cl,oxx);
524 break;
525 case _unify_x_var2:
526 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xl))) {
527 clause->Tag = (CELL)NULL;
528 return;
529 }
530 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xr))) {
531 clause->Tag = (CELL)NULL;
532 return;
533 }
534 cl = NEXTOP(cl,oxx);
535 break;
536 case _unify_x_var2_write:
537 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xl))) {
538 clause->Tag = (CELL)NULL;
539 return;
540 }
541 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oxx.xr))) {
542 clause->Tag = (CELL)NULL;
543 return;
544 }
545 cl = NEXTOP(cl,oxx);
546 break;
547 case _save_appl_y:
548 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
549 clause->Tag = (CELL)NULL;
550 return;
551 }
552 cl = NEXTOP(cl,oy);
553 break;
554 case _save_appl_y_write:
555 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
556 clause->Tag = (CELL)NULL;
557 return;
558 }
559 cl = NEXTOP(cl,oy);
560 break;
561 case _save_pair_y:
562 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
563 clause->Tag = (CELL)NULL;
564 return;
565 }
566 cl = NEXTOP(cl,oy);
567 break;
568 case _save_pair_y_write:
569 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
570 clause->Tag = (CELL)NULL;
571 return;
572 }
573 cl = NEXTOP(cl,oy);
574 break;
575 case _unify_l_y_loc:
576 cl = NEXTOP(cl,oy);
577 break;
578 case _unify_l_y_loc_write:
579 cl = NEXTOP(cl,oy);
580 break;
581 case _unify_l_y_val:
582 cl = NEXTOP(cl,oy);
583 break;
584 case _unify_l_y_val_write:
585 cl = NEXTOP(cl,oy);
586 break;
587 case _unify_l_y_var:
588 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
589 clause->Tag = (CELL)NULL;
590 return;
591 }
592 cl = NEXTOP(cl,oy);
593 break;
594 case _unify_l_y_var_write:
595 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
596 clause->Tag = (CELL)NULL;
597 return;
598 }
599 cl = NEXTOP(cl,oy);
600 break;
601 case _unify_y_loc:
602 cl = NEXTOP(cl,oy);
603 break;
604 case _unify_y_loc_write:
605 cl = NEXTOP(cl,oy);
606 break;
607 case _unify_y_val:
608 cl = NEXTOP(cl,oy);
609 break;
610 case _unify_y_val_write:
611 cl = NEXTOP(cl,oy);
612 break;
613 case _unify_y_var:
614 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
615 clause->Tag = (CELL)NULL;
616 return;
617 }
618 cl = NEXTOP(cl,oy);
619 break;
620 case _unify_y_var_write:
621 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.oy.y))) {
622 clause->Tag = (CELL)NULL;
623 return;
624 }
625 cl = NEXTOP(cl,oy);
626 break;
627 case _deallocate:
628 cl = NEXTOP(cl,p);
629 break;
630 case _lock_lu:
631 cl = NEXTOP(cl,p);
632 break;
633 case _call_bfunc_xx:
634 cl = NEXTOP(cl,plxxs);
635 break;
636 case _call_bfunc_xy:
637 cl = NEXTOP(cl,plxys);
638 break;
639 case _call_bfunc_yx:
640 cl = NEXTOP(cl,plxys);
641 break;
642 case _call_bfunc_yy:
643 cl = NEXTOP(cl,plyys);
644 break;
645 case _pop_n:
646 cl = NEXTOP(cl,s);
647 break;
648 case _write_n_voids:
649 cl = NEXTOP(cl,s);
650 break;
651 case _write_n_atoms:
652 cl = NEXTOP(cl,sc);
653 break;
654 case _get_list:
655 if (is_regcopy(myregs, nofregs, cl->y_u.x.x)) {
656 clause->Tag = AbsPair(NULL);
657 clause->ucd.WorkPC = NEXTOP(cl,x);
658 return;
659 }
660 cl = NEXTOP(cl,x);
661 break;
662 case _put_list:
663 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.x.x))) {
664 clause->Tag = (CELL)NULL;
665 return;
666 }
667 cl = NEXTOP(cl,x);
668 break;
669 case _save_b_x:
670 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.x.x))) {
671 clause->Tag = (CELL)NULL;
672 return;
673 }
674 cl = NEXTOP(cl,x);
675 break;
676 case _write_x_loc:
677 cl = NEXTOP(cl,x);
678 break;
679 case _write_x_var:
680 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.x.x))) {
681 clause->Tag = (CELL)NULL;
682 return;
683 }
684 cl = NEXTOP(cl,x);
685 break;
686 case _put_dbterm:
687 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xD.x))) {
688 clause->Tag = (CELL)NULL;
689 return;
690 }
691 cl = NEXTOP(cl,xD);
692 break;
693 case _get_bigint:
694 if (is_regcopy(myregs, nofregs, cl->y_u.xN.x)) {
695 clause->Tag = AbsAppl((CELL *)FunctorBigInt);
696 clause->ucd.t_ptr = (CELL)NULL;
697 return;
698 }
699 cl = NEXTOP(cl,xN);
700 break;
701 case _put_bigint:
702 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xN.x))) {
703 clause->Tag = (CELL)NULL;
704 return;
705 }
706 cl = NEXTOP(cl,xN);
707 break;
708 case _get_atom:
709 if (is_regcopy(myregs, nofregs, cl->y_u.xc.x)) {
710 if (IsApplTerm(cl->y_u.xc.c)) {
711 CELL *pt = RepAppl(cl->y_u.xc.c);
712 clause->Tag = AbsAppl((CELL *)pt[0]);
713 clause->ucd.t_ptr = cl->y_u.xc.c;
714 } else
715 clause->Tag = cl->y_u.xc.c;
716 return;
717 }
718 cl = NEXTOP(cl,xc);
719 break;
720 case _put_atom:
721 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xc.x))) {
722 clause->Tag = (CELL)NULL;
723 return;
724 }
725 cl = NEXTOP(cl,xc);
726 break;
727 case _get_float:
728 if (is_regcopy(myregs, nofregs, cl->y_u.xd.x)) {
729 clause->Tag = AbsAppl((CELL *)FunctorDouble);
730 clause->ucd.t_ptr = AbsAppl(cl->y_u.xd.d);
731 return;
732 }
733 cl = NEXTOP(cl,xd);
734 break;
735 case _put_float:
736 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xd.x))) {
737 clause->Tag = (CELL)NULL;
738 return;
739 }
740 cl = NEXTOP(cl,xd);
741 break;
742 case _get_struct:
743 if (is_regcopy(myregs, nofregs, cl->y_u.xfa.x)) {
744 clause->Tag = AbsAppl((CELL *)cl->y_u.xfa.f);
745 clause->ucd.WorkPC = NEXTOP(cl,xfa);
746 return;
747 }
748 cl = NEXTOP(cl,xfa);
749 break;
750 case _put_struct:
751 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xfa.x))) {
752 clause->Tag = (CELL)NULL;
753 return;
754 }
755 cl = NEXTOP(cl,xfa);
756 break;
757 case _get_longint:
758 if (is_regcopy(myregs, nofregs, cl->y_u.xi.x)) {
759 clause->Tag = AbsAppl((CELL *)FunctorLongInt);
760 clause->ucd.t_ptr = AbsAppl(cl->y_u.xi.i);
761 return;
762 }
763 cl = NEXTOP(cl,xi);
764 break;
765 case _put_longint:
766 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xi.x))) {
767 clause->Tag = (CELL)NULL;
768 return;
769 }
770 cl = NEXTOP(cl,xi);
771 break;
772 case _p_atom_x:
773 if (cl->y_u.xl.F != FAILCODE) {
774 clause->Tag = (CELL)NULL;
775 return;
776 }
777 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
778 clause->Tag = (_atom+1)*sizeof(CELL);
779 clause->ucd.t_ptr = (CELL)NULL;
780 return;
781 }
782 cl = NEXTOP(cl,xl);
783 break;
784 case _p_atomic_x:
785 if (cl->y_u.xl.F != FAILCODE) {
786 clause->Tag = (CELL)NULL;
787 return;
788 }
789 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
790 clause->Tag = (_atomic+1)*sizeof(CELL);
791 clause->ucd.t_ptr = (CELL)NULL;
792 return;
793 }
794 cl = NEXTOP(cl,xl);
795 break;
796 case _p_compound_x:
797 if (cl->y_u.xl.F != FAILCODE) {
798 clause->Tag = (CELL)NULL;
799 return;
800 }
801 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
802 clause->Tag = (_compound+1)*sizeof(CELL);
803 clause->ucd.t_ptr = (CELL)NULL;
804 return;
805 }
806 cl = NEXTOP(cl,xl);
807 break;
808 case _p_db_ref_x:
809 if (cl->y_u.xl.F != FAILCODE) {
810 clause->Tag = (CELL)NULL;
811 return;
812 }
813 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
814 clause->Tag = AbsAppl((CELL *)FunctorDBRef);
815 clause->ucd.t_ptr = (CELL)NULL;
816 return;
817 }
818 cl = NEXTOP(cl,xl);
819 break;
820 case _p_float_x:
821 if (cl->y_u.xl.F != FAILCODE) {
822 clause->Tag = (CELL)NULL;
823 return;
824 }
825 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
826 clause->Tag = AbsAppl((CELL *)FunctorDouble);
827 clause->ucd.t_ptr = (CELL)NULL;
828 return;
829 }
830 cl = NEXTOP(cl,xl);
831 break;
832 case _p_integer_x:
833 if (cl->y_u.xl.F != FAILCODE) {
834 clause->Tag = (CELL)NULL;
835 return;
836 }
837 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
838 clause->Tag = (_integer+1)*sizeof(CELL);
839 clause->ucd.t_ptr = (CELL)NULL;
840 return;
841 }
842 cl = NEXTOP(cl,xl);
843 break;
844 case _p_nonvar_x:
845 if (cl->y_u.xl.F != FAILCODE) {
846 clause->Tag = (CELL)NULL;
847 return;
848 }
849 cl = NEXTOP(cl,xl);
850 break;
851 case _p_number_x:
852 if (cl->y_u.xl.F != FAILCODE) {
853 clause->Tag = (CELL)NULL;
854 return;
855 }
856 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
857 clause->Tag = (_number+1)*sizeof(CELL);
858 clause->ucd.t_ptr = (CELL)NULL;
859 return;
860 }
861 cl = NEXTOP(cl,xl);
862 break;
863 case _p_primitive_x:
864 if (cl->y_u.xl.F != FAILCODE) {
865 clause->Tag = (CELL)NULL;
866 return;
867 }
868 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
869 clause->Tag = (_primitive+1)*sizeof(CELL);
870 clause->ucd.t_ptr = (CELL)NULL;
871 return;
872 }
873 cl = NEXTOP(cl,xl);
874 break;
875 case _p_var_x:
876 if (cl->y_u.xl.F != FAILCODE) {
877 clause->Tag = (CELL)NULL;
878 return;
879 }
880 if (is_regcopy(myregs, nofregs, cl->y_u.xl.x)) {
881 clause->Tag = (_var+1)*sizeof(CELL);
882 clause->ucd.t_ptr = (CELL)NULL;
883 return;
884 }
885 cl = NEXTOP(cl,xl);
886 break;
887 case _get_string:
888 if (is_regcopy(myregs, nofregs, cl->y_u.xu.x)) {
889 clause->Tag = AbsAppl((CELL *)FunctorString);
890 clause->ucd.t_ptr = (CELL)NULL;
891 return;
892 }
893 cl = NEXTOP(cl,xu);
894 break;
895 case _get_x_val:
896 if (!(nofregs = link_regcopies(myregs, nofregs, cl->y_u.xx.xl, cl->y_u.xx.xr))) {
897 clause->Tag = (CELL)NULL;
898 return;
899 }
900 cl = NEXTOP(cl,xx);
901 break;
902 case _get_x_var:
903 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.xx.xr, cl->y_u.xx.xl))) {
904 clause->Tag = (CELL)NULL;
905 return;
906 }
907 cl = NEXTOP(cl,xx);
908 break;
909 case _gl_void_valx:
910 if (is_regcopy(myregs, nofregs, cl->y_u.xx.xl)) {
911 clause->Tag = AbsPair(NULL);
912 clause->ucd.WorkPC = cl;
913 return;
914 }
915 cl = NEXTOP(cl,xx);
916 break;
917 case _gl_void_varx:
918 if (is_regcopy(myregs, nofregs, cl->y_u.xx.xl)) {
919 clause->Tag = AbsPair(NULL);
920 clause->ucd.WorkPC = cl;
921 return;
922 }
923 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xx.xr))) {
924 clause->Tag = (CELL)NULL;
925 return;
926 }
927 cl = NEXTOP(cl,xx);
928 break;
929 case _glist_valx:
930 if (is_regcopy(myregs, nofregs, cl->y_u.xx.xl)) {
931 clause->Tag = AbsPair(NULL);
932 clause->ucd.WorkPC = cl;
933 return;
934 }
935 cl = NEXTOP(cl,xx);
936 break;
937 case _put_x_val:
938 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.xx.xl, cl->y_u.xx.xr))) {
939 clause->Tag = (CELL)NULL;
940 return;
941 }
942 cl = NEXTOP(cl,xx);
943 break;
944 case _put_x_var:
945 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xx.xl))) {
946 clause->Tag = (CELL)NULL;
947 return;
948 }
949 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xx.xr))) {
950 clause->Tag = (CELL)NULL;
951 return;
952 }
953 cl = NEXTOP(cl,xx);
954 break;
955 case _p_func2s_cv:
956 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxc.x))) {
957 clause->Tag = (CELL)NULL;
958 return;
959 }
960 cl = NEXTOP(cl,xxc);
961 break;
962 case _p_and_vc:
963 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
964 clause->Tag = (CELL)NULL;
965 return;
966 }
967 cl = NEXTOP(cl,xxn);
968 break;
969 case _p_arg_cv:
970 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
971 clause->Tag = (CELL)NULL;
972 return;
973 }
974 cl = NEXTOP(cl,xxn);
975 break;
976 case _p_div_cv:
977 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
978 clause->Tag = (CELL)NULL;
979 return;
980 }
981 cl = NEXTOP(cl,xxn);
982 break;
983 case _p_div_vc:
984 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
985 clause->Tag = (CELL)NULL;
986 return;
987 }
988 cl = NEXTOP(cl,xxn);
989 break;
990 case _p_func2s_vc:
991 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
992 clause->Tag = (CELL)NULL;
993 return;
994 }
995 cl = NEXTOP(cl,xxn);
996 break;
997 case _p_or_vc:
998 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
999 clause->Tag = (CELL)NULL;
1000 return;
1001 }
1002 cl = NEXTOP(cl,xxn);
1003 break;
1004 case _p_plus_vc:
1005 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
1006 clause->Tag = (CELL)NULL;
1007 return;
1008 }
1009 cl = NEXTOP(cl,xxn);
1010 break;
1011 case _p_sll_cv:
1012 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
1013 clause->Tag = (CELL)NULL;
1014 return;
1015 }
1016 cl = NEXTOP(cl,xxn);
1017 break;
1018 case _p_sll_vc:
1019 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
1020 clause->Tag = (CELL)NULL;
1021 return;
1022 }
1023 cl = NEXTOP(cl,xxn);
1024 break;
1025 case _p_slr_cv:
1026 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
1027 clause->Tag = (CELL)NULL;
1028 return;
1029 }
1030 cl = NEXTOP(cl,xxn);
1031 break;
1032 case _p_slr_vc:
1033 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
1034 clause->Tag = (CELL)NULL;
1035 return;
1036 }
1037 cl = NEXTOP(cl,xxn);
1038 break;
1039 case _p_times_vc:
1040 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxn.x))) {
1041 clause->Tag = (CELL)NULL;
1042 return;
1043 }
1044 cl = NEXTOP(cl,xxn);
1045 break;
1046 case _p_and_vv:
1047 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1048 clause->Tag = (CELL)NULL;
1049 return;
1050 }
1051 cl = NEXTOP(cl,xxx);
1052 break;
1053 case _p_arg_vv:
1054 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1055 clause->Tag = (CELL)NULL;
1056 return;
1057 }
1058 cl = NEXTOP(cl,xxx);
1059 break;
1060 case _p_div_vv:
1061 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1062 clause->Tag = (CELL)NULL;
1063 return;
1064 }
1065 cl = NEXTOP(cl,xxx);
1066 break;
1067 case _p_func2f_xx:
1068 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1069 clause->Tag = (CELL)NULL;
1070 return;
1071 }
1072 cl = NEXTOP(cl,xxx);
1073 break;
1074 case _p_func2s_vv:
1075 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1076 clause->Tag = (CELL)NULL;
1077 return;
1078 }
1079 cl = NEXTOP(cl,xxx);
1080 break;
1081 case _p_minus_vv:
1082 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1083 clause->Tag = (CELL)NULL;
1084 return;
1085 }
1086 cl = NEXTOP(cl,xxx);
1087 break;
1088 case _p_or_vv:
1089 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1090 clause->Tag = (CELL)NULL;
1091 return;
1092 }
1093 cl = NEXTOP(cl,xxx);
1094 break;
1095 case _p_plus_vv:
1096 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1097 clause->Tag = (CELL)NULL;
1098 return;
1099 }
1100 cl = NEXTOP(cl,xxx);
1101 break;
1102 case _p_sll_vv:
1103 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1104 clause->Tag = (CELL)NULL;
1105 return;
1106 }
1107 cl = NEXTOP(cl,xxx);
1108 break;
1109 case _p_slr_vv:
1110 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1111 clause->Tag = (CELL)NULL;
1112 return;
1113 }
1114 cl = NEXTOP(cl,xxx);
1115 break;
1116 case _p_times_vv:
1117 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxx.x))) {
1118 clause->Tag = (CELL)NULL;
1119 return;
1120 }
1121 cl = NEXTOP(cl,xxx);
1122 break;
1123 case _put_xx_val:
1124 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.xxxx.xl1, cl->y_u.xxxx.xr1))) {
1125 clause->Tag = (CELL)NULL;
1126 return;
1127 }
1128 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.xxxx.xl2, cl->y_u.xxxx.xr2))) {
1129 clause->Tag = (CELL)NULL;
1130 return;
1131 }
1132 cl = NEXTOP(cl,xxxx);
1133 break;
1134 case _p_func2f_xy:
1135 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.xxy.x))) {
1136 clause->Tag = (CELL)NULL;
1137 return;
1138 }
1139 cl = NEXTOP(cl,xxy);
1140 break;
1141 case _save_b_y:
1142 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.y.y))) {
1143 clause->Tag = (CELL)NULL;
1144 return;
1145 }
1146 cl = NEXTOP(cl,y);
1147 break;
1148 case _write_y_loc:
1149 cl = NEXTOP(cl,y);
1150 break;
1151 case _write_y_val:
1152 cl = NEXTOP(cl,y);
1153 break;
1154 case _write_y_var:
1155 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.y.y))) {
1156 clause->Tag = (CELL)NULL;
1157 return;
1158 }
1159 cl = NEXTOP(cl,y);
1160 break;
1161 case _p_atom_y:
1162 if (cl->y_u.yl.F != FAILCODE) {
1163 clause->Tag = (CELL)NULL;
1164 return;
1165 }
1166 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1167 clause->Tag = (_atom+1)*sizeof(CELL);
1168 clause->ucd.t_ptr = (CELL)NULL;
1169 return;
1170 }
1171 cl = NEXTOP(cl,yl);
1172 break;
1173 case _p_atomic_y:
1174 if (cl->y_u.yl.F != FAILCODE) {
1175 clause->Tag = (CELL)NULL;
1176 return;
1177 }
1178 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1179 clause->Tag = (_atomic+1)*sizeof(CELL);
1180 clause->ucd.t_ptr = (CELL)NULL;
1181 return;
1182 }
1183 cl = NEXTOP(cl,yl);
1184 break;
1185 case _p_compound_y:
1186 if (cl->y_u.yl.F != FAILCODE) {
1187 clause->Tag = (CELL)NULL;
1188 return;
1189 }
1190 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1191 clause->Tag = (_compound+1)*sizeof(CELL);
1192 clause->ucd.t_ptr = (CELL)NULL;
1193 return;
1194 }
1195 cl = NEXTOP(cl,yl);
1196 break;
1197 case _p_db_ref_y:
1198 if (cl->y_u.yl.F != FAILCODE) {
1199 clause->Tag = (CELL)NULL;
1200 return;
1201 }
1202 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1203 clause->Tag = AbsAppl((CELL *)FunctorDBRef);
1204 clause->ucd.t_ptr = (CELL)NULL;
1205 return;
1206 }
1207 cl = NEXTOP(cl,yl);
1208 break;
1209 case _p_float_y:
1210 if (cl->y_u.yl.F != FAILCODE) {
1211 clause->Tag = (CELL)NULL;
1212 return;
1213 }
1214 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1215 clause->Tag = AbsAppl((CELL *)FunctorDouble);
1216 clause->ucd.t_ptr = (CELL)NULL;
1217 return;
1218 }
1219 cl = NEXTOP(cl,yl);
1220 break;
1221 case _p_integer_y:
1222 if (cl->y_u.yl.F != FAILCODE) {
1223 clause->Tag = (CELL)NULL;
1224 return;
1225 }
1226 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1227 clause->Tag = (_integer+1)*sizeof(CELL);
1228 clause->ucd.t_ptr = (CELL)NULL;
1229 return;
1230 }
1231 cl = NEXTOP(cl,yl);
1232 break;
1233 case _p_nonvar_y:
1234 if (cl->y_u.yl.F != FAILCODE) {
1235 clause->Tag = (CELL)NULL;
1236 return;
1237 }
1238 cl = NEXTOP(cl,yl);
1239 break;
1240 case _p_number_y:
1241 if (cl->y_u.yl.F != FAILCODE) {
1242 clause->Tag = (CELL)NULL;
1243 return;
1244 }
1245 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1246 clause->Tag = (_number+1)*sizeof(CELL);
1247 clause->ucd.t_ptr = (CELL)NULL;
1248 return;
1249 }
1250 cl = NEXTOP(cl,yl);
1251 break;
1252 case _p_primitive_y:
1253 if (cl->y_u.yl.F != FAILCODE) {
1254 clause->Tag = (CELL)NULL;
1255 return;
1256 }
1257 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1258 clause->Tag = (_primitive+1)*sizeof(CELL);
1259 clause->ucd.t_ptr = (CELL)NULL;
1260 return;
1261 }
1262 cl = NEXTOP(cl,yl);
1263 break;
1264 case _p_var_y:
1265 if (cl->y_u.yl.F != FAILCODE) {
1266 clause->Tag = (CELL)NULL;
1267 return;
1268 }
1269 if (is_regcopy(myregs, nofregs, cl->y_u.yl.y)) {
1270 clause->Tag = (_var+1)*sizeof(CELL);
1271 clause->ucd.t_ptr = (CELL)NULL;
1272 return;
1273 }
1274 cl = NEXTOP(cl,yl);
1275 break;
1276 case _get_y_val:
1277 if (!(nofregs = link_regcopies(myregs, nofregs, cl->y_u.yx.x, cl->y_u.yx.y))) {
1278 clause->Tag = (CELL)NULL;
1279 return;
1280 }
1281 cl = NEXTOP(cl,yx);
1282 break;
1283 case _get_y_var:
1284 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.yx.x, cl->y_u.yx.y))) {
1285 clause->Tag = (CELL)NULL;
1286 return;
1287 }
1288 cl = NEXTOP(cl,yx);
1289 break;
1290 case _gl_void_valy:
1291 if (is_regcopy(myregs, nofregs, cl->y_u.yx.y)) {
1292 clause->Tag = AbsPair(NULL);
1293 clause->ucd.WorkPC = cl;
1294 return;
1295 }
1296 cl = NEXTOP(cl,yx);
1297 break;
1298 case _gl_void_vary:
1299 if (is_regcopy(myregs, nofregs, cl->y_u.yx.y)) {
1300 clause->Tag = AbsPair(NULL);
1301 clause->ucd.WorkPC = cl;
1302 return;
1303 }
1304 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yx.y))) {
1305 clause->Tag = (CELL)NULL;
1306 return;
1307 }
1308 cl = NEXTOP(cl,yx);
1309 break;
1310 case _glist_valy:
1311 if (is_regcopy(myregs, nofregs, cl->y_u.yx.x)) {
1312 clause->Tag = AbsPair(NULL);
1313 clause->ucd.WorkPC = cl;
1314 return;
1315 }
1316 cl = NEXTOP(cl,yx);
1317 break;
1318 case _put_unsafe:
1319 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.yx.y, cl->y_u.yx.x))) {
1320 clause->Tag = (CELL)NULL;
1321 return;
1322 }
1323 cl = NEXTOP(cl,yx);
1324 break;
1325 case _put_y_val:
1326 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.yx.y, cl->y_u.yx.x))) {
1327 clause->Tag = (CELL)NULL;
1328 return;
1329 }
1330 cl = NEXTOP(cl,yx);
1331 break;
1332 case _put_y_var:
1333 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yx.x))) {
1334 clause->Tag = (CELL)NULL;
1335 return;
1336 }
1337 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yx.y))) {
1338 clause->Tag = (CELL)NULL;
1339 return;
1340 }
1341 cl = NEXTOP(cl,yx);
1342 break;
1343 case _p_func2s_y_cv:
1344 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxc.y))) {
1345 clause->Tag = (CELL)NULL;
1346 return;
1347 }
1348 cl = NEXTOP(cl,yxc);
1349 break;
1350 case _p_and_y_vc:
1351 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1352 clause->Tag = (CELL)NULL;
1353 return;
1354 }
1355 cl = NEXTOP(cl,yxn);
1356 break;
1357 case _p_arg_y_cv:
1358 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1359 clause->Tag = (CELL)NULL;
1360 return;
1361 }
1362 cl = NEXTOP(cl,yxn);
1363 break;
1364 case _p_div_y_cv:
1365 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1366 clause->Tag = (CELL)NULL;
1367 return;
1368 }
1369 cl = NEXTOP(cl,yxn);
1370 break;
1371 case _p_div_y_vc:
1372 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1373 clause->Tag = (CELL)NULL;
1374 return;
1375 }
1376 cl = NEXTOP(cl,yxn);
1377 break;
1378 case _p_func2s_y_vc:
1379 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1380 clause->Tag = (CELL)NULL;
1381 return;
1382 }
1383 cl = NEXTOP(cl,yxn);
1384 break;
1385 case _p_or_y_vc:
1386 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1387 clause->Tag = (CELL)NULL;
1388 return;
1389 }
1390 cl = NEXTOP(cl,yxn);
1391 break;
1392 case _p_plus_y_vc:
1393 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1394 clause->Tag = (CELL)NULL;
1395 return;
1396 }
1397 cl = NEXTOP(cl,yxn);
1398 break;
1399 case _p_sll_y_cv:
1400 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1401 clause->Tag = (CELL)NULL;
1402 return;
1403 }
1404 cl = NEXTOP(cl,yxn);
1405 break;
1406 case _p_sll_y_vc:
1407 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1408 clause->Tag = (CELL)NULL;
1409 return;
1410 }
1411 cl = NEXTOP(cl,yxn);
1412 break;
1413 case _p_slr_y_cv:
1414 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1415 clause->Tag = (CELL)NULL;
1416 return;
1417 }
1418 cl = NEXTOP(cl,yxn);
1419 break;
1420 case _p_slr_y_vc:
1421 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1422 clause->Tag = (CELL)NULL;
1423 return;
1424 }
1425 cl = NEXTOP(cl,yxn);
1426 break;
1427 case _p_times_y_vc:
1428 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxn.y))) {
1429 clause->Tag = (CELL)NULL;
1430 return;
1431 }
1432 cl = NEXTOP(cl,yxn);
1433 break;
1434 case _p_and_y_vv:
1435 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1436 clause->Tag = (CELL)NULL;
1437 return;
1438 }
1439 cl = NEXTOP(cl,yxx);
1440 break;
1441 case _p_arg_y_vv:
1442 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1443 clause->Tag = (CELL)NULL;
1444 return;
1445 }
1446 cl = NEXTOP(cl,yxx);
1447 break;
1448 case _p_div_y_vv:
1449 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1450 clause->Tag = (CELL)NULL;
1451 return;
1452 }
1453 cl = NEXTOP(cl,yxx);
1454 break;
1455 case _p_func2f_yx:
1456 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1457 clause->Tag = (CELL)NULL;
1458 return;
1459 }
1460 cl = NEXTOP(cl,yxx);
1461 break;
1462 case _p_func2s_y_vv:
1463 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1464 clause->Tag = (CELL)NULL;
1465 return;
1466 }
1467 cl = NEXTOP(cl,yxx);
1468 break;
1469 case _p_minus_y_vv:
1470 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1471 clause->Tag = (CELL)NULL;
1472 return;
1473 }
1474 cl = NEXTOP(cl,yxx);
1475 break;
1476 case _p_or_y_vv:
1477 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1478 clause->Tag = (CELL)NULL;
1479 return;
1480 }
1481 cl = NEXTOP(cl,yxx);
1482 break;
1483 case _p_plus_y_vv:
1484 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1485 clause->Tag = (CELL)NULL;
1486 return;
1487 }
1488 cl = NEXTOP(cl,yxx);
1489 break;
1490 case _p_sll_y_vv:
1491 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1492 clause->Tag = (CELL)NULL;
1493 return;
1494 }
1495 cl = NEXTOP(cl,yxx);
1496 break;
1497 case _p_slr_y_vv:
1498 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1499 clause->Tag = (CELL)NULL;
1500 return;
1501 }
1502 cl = NEXTOP(cl,yxx);
1503 break;
1504 case _p_times_y_vv:
1505 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yxx.y))) {
1506 clause->Tag = (CELL)NULL;
1507 return;
1508 }
1509 cl = NEXTOP(cl,yxx);
1510 break;
1511 case _p_func2f_yy:
1512 if (!(nofregs = delete_regcopy(myregs, nofregs, cl->y_u.yyx.x))) {
1513 clause->Tag = (CELL)NULL;
1514 return;
1515 }
1516 cl = NEXTOP(cl,yyx);
1517 break;
1518 case _get_yy_var:
1519 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.yyxx.x1, cl->y_u.yyxx.y1))) {
1520 clause->Tag = (CELL)NULL;
1521 return;
1522 }
1523 if (!(nofregs = add_regcopy(myregs, nofregs, cl->y_u.yyxx.x2, cl->y_u.yyxx.y2))) {
1524 clause->Tag = (CELL)NULL;
1525 return;
1526 }
1527 cl = NEXTOP(cl,yyxx);
1528 break;
1529#ifdef YAPOR
1530#endif
1531#ifdef TABLING
1532 case _table_try_single:
1533 cl = NEXTOP(cl,Otapl);
1534 break;
1535#endif
1536default:
1537 clause->Tag = (CELL)NULL;
1538 return;
1539 }
1540 }
logic_upd_clause
Definition: clause.h:64