YAP 7.1.0
rclause.h
1
2 /* This file was generated automatically by "yap -L misc/buildops"
3 please do not update */
4
5
6static void
7restore_opcodes(yamop *pc, yamop *max USES_REGS)
8{
9 yamop *opc = NULL;
10 do {
11 op_numbers op;
12 if (max && pc >= max) return;
13 op = Yap_op_from_opcode(pc->opc);
14 pc->opc = Yap_opcode(op);
15#ifdef DEBUG_RESTORE2
16 fprintf(stderr, "%s ", Yap_op_names[op]);
17#endif
18 switch (op) {
19 /* instructions type D */
20 case _write_dbterm:
21 pc->y_u.D.D = DBGroundTermAdjust(pc->y_u.D.D);
22 pc = NEXTOP(pc,D);
23 break;
24 /* instructions type Illss */
25 case _enter_lu_pred:
26 pc->y_u.Illss.I = PtoLUIndexAdjust(pc->y_u.Illss.I);
27 pc->y_u.Illss.l1 = PtoOpAdjust(pc->y_u.Illss.l1);
28 pc->y_u.Illss.l2 = PtoOpAdjust(pc->y_u.Illss.l2);
29 pc->y_u.Illss.s = ConstantAdjust(pc->y_u.Illss.s);
30 pc->y_u.Illss.e = ConstantAdjust(pc->y_u.Illss.e);
31 opc = NEXTOP(pc,Illss);
32 pc = pc->y_u.Illss.l1;
33 break;
34 /* instructions type J */
35#ifdef YAP_JIT
36 case _jit_handler:
37#endif
38 /* instructions type L */
39 case _alloc_for_logical_pred:
40 pc->y_u.L.ClBase = PtoLUClauseAdjust(pc->y_u.L.ClBase);
41 pc = NEXTOP(pc,L);
42 break;
43 /* instructions type N */
44 case _write_bigint:
45 pc->y_u.N.b = BlobTermInCodeAdjust(pc->y_u.N.b);
46 pc = NEXTOP(pc,N);
47 break;
48 /* instructions type Osblp */
49 case _either:
50 case _or_else:
51 OrArgAdjust(pc->y_u.Osblp.or_arg);
52 pc->y_u.Osblp.s = ConstantAdjust(pc->y_u.Osblp.s);
53 pc->y_u.Osblp.bmap = CellPtoHeapAdjust(pc->y_u.Osblp.bmap);
54 pc->y_u.Osblp.l = PtoOpAdjust(pc->y_u.Osblp.l);
55 pc->y_u.Osblp.p0 = PtoPredAdjust(pc->y_u.Osblp.p0);
56 pc = NEXTOP(pc,Osblp);
57 break;
58 /* instructions type Osbmp */
59 case _p_execute:
60 case _p_execute_tail:
61 OrArgAdjust(pc->y_u.Osbmp.or_arg);
62 pc->y_u.Osbmp.s = ConstantAdjust(pc->y_u.Osbmp.s);
63 pc->y_u.Osbmp.bmap = CellPtoHeapAdjust(pc->y_u.Osbmp.bmap);
64 pc->y_u.Osbmp.mod = ModuleAdjust(pc->y_u.Osbmp.mod);
65 pc->y_u.Osbmp.p0 = PtoPredAdjust(pc->y_u.Osbmp.p0);
66 pc = NEXTOP(pc,Osbmp);
67 break;
68 /* instructions type Osbpa */
69 case _ensure_space:
70 OrArgAdjust(pc->y_u.Osbpa.or_arg);
71 pc->y_u.Osbpa.s = ConstantAdjust(pc->y_u.Osbpa.s);
72 pc->y_u.Osbpa.bmap = CellPtoHeapAdjust(pc->y_u.Osbpa.bmap);
73 pc->y_u.Osbpa.p = PtoPredAdjust(pc->y_u.Osbpa.p);
74 pc->y_u.Osbpa.i = ArityAdjust(pc->y_u.Osbpa.i);
75 pc = NEXTOP(pc,Osbpa);
76 break;
77 /* instructions type Osbpp */
78 case _call:
79 case _call_cpred:
80 case _call_usercpred:
81 case _dexecute:
82 case _execute:
83 case _execute_cpred:
84 case _fcall:
85 case _p_execute2:
86 OrArgAdjust(pc->y_u.Osbpp.or_arg);
87 pc->y_u.Osbpp.s = ConstantAdjust(pc->y_u.Osbpp.s);
88 pc->y_u.Osbpp.bmap = CellPtoHeapAdjust(pc->y_u.Osbpp.bmap);
89 pc->y_u.Osbpp.p = PtoPredAdjust(pc->y_u.Osbpp.p);
90 pc->y_u.Osbpp.p0 = PtoPredAdjust(pc->y_u.Osbpp.p0);
91 pc = NEXTOP(pc,Osbpp);
92 break;
93 /* instructions type OtILl */
94 case _count_trust_logical:
95 case _profiled_trust_logical:
96 case _trust_logical:
97 OrArgAdjust(pc->y_u.OtILl.or_arg);
98 TabEntryAdjust(pc->y_u.OtILl.te);
99 pc->y_u.OtILl.block = PtoLUIndexAdjust(pc->y_u.OtILl.block);
100 pc->y_u.OtILl.d = PtoLUClauseAdjust(pc->y_u.OtILl.d);
101 pc->y_u.OtILl.n = PtoOpAdjust(pc->y_u.OtILl.n);
102 pc = opc;
103 break;
104 /* instructions type OtaLl */
105 case _count_retry_logical:
106 case _profiled_retry_logical:
107 case _retry_logical:
108 case _try_logical:
109 OrArgAdjust(pc->y_u.OtaLl.or_arg);
110 TabEntryAdjust(pc->y_u.OtaLl.te);
111 pc->y_u.OtaLl.s = ArityAdjust(pc->y_u.OtaLl.s);
112 pc->y_u.OtaLl.d = PtoLUClauseAdjust(pc->y_u.OtaLl.d);
113 pc->y_u.OtaLl.n = PtoOpAdjust(pc->y_u.OtaLl.n);
114 pc = pc->y_u.OtaLl.n;
115 break;
116 /* instructions type OtapFs */
117 case _cut_c:
118 case _cut_userc:
119 case _retry_c:
120 case _retry_userc:
121 case _try_c:
122 case _try_userc:
123 OrArgAdjust(pc->y_u.OtapFs.or_arg);
124 TabEntryAdjust(pc->y_u.OtapFs.te);
125 pc->y_u.OtapFs.s = ArityAdjust(pc->y_u.OtapFs.s);
126 pc->y_u.OtapFs.p = PtoPredAdjust(pc->y_u.OtapFs.p);
127 pc->y_u.OtapFs.f = ExternalFunctionAdjust(pc->y_u.OtapFs.f);
128 pc->y_u.OtapFs.extra = ConstantAdjust(pc->y_u.OtapFs.extra);
129 pc = NEXTOP(pc,OtapFs);
130 break;
131 /* instructions type Otapl */
132 case _count_retry_and_mark:
133 case _count_retry_me:
134 case _count_trust_me:
135 case _profiled_retry_and_mark:
136 case _profiled_retry_me:
137 case _profiled_trust_me:
138 case _retry:
139 case _retry_and_mark:
140 case _retry_me:
141 case _spy_or_trymark:
142 case _trust:
143 case _trust_me:
144 case _try_and_mark:
145 case _try_clause:
146 case _try_me:
147 OrArgAdjust(pc->y_u.Otapl.or_arg);
148 TabEntryAdjust(pc->y_u.Otapl.te);
149 pc->y_u.Otapl.s = ArityAdjust(pc->y_u.Otapl.s);
150 pc->y_u.Otapl.p = PtoPredAdjust(pc->y_u.Otapl.p);
151 pc->y_u.Otapl.d = PtoOpAdjust(pc->y_u.Otapl.d);
152 pc = NEXTOP(pc,Otapl);
153 break;
154 /* instructions type c */
155 case _write_atom:
156 pc->y_u.c.c = ConstantTermAdjust(pc->y_u.c.c);
157 pc = NEXTOP(pc,c);
158 break;
159 /* instructions type cc */
160 case _get_2atoms:
161 pc->y_u.cc.c1 = ConstantTermAdjust(pc->y_u.cc.c1);
162 pc->y_u.cc.c2 = ConstantTermAdjust(pc->y_u.cc.c2);
163 pc = NEXTOP(pc,cc);
164 break;
165 /* instructions type ccc */
166 case _get_3atoms:
167 pc->y_u.ccc.c1 = ConstantTermAdjust(pc->y_u.ccc.c1);
168 pc->y_u.ccc.c2 = ConstantTermAdjust(pc->y_u.ccc.c2);
169 pc->y_u.ccc.c3 = ConstantTermAdjust(pc->y_u.ccc.c3);
170 pc = NEXTOP(pc,ccc);
171 break;
172 /* instructions type cccc */
173 case _get_4atoms:
174 pc->y_u.cccc.c1 = ConstantTermAdjust(pc->y_u.cccc.c1);
175 pc->y_u.cccc.c2 = ConstantTermAdjust(pc->y_u.cccc.c2);
176 pc->y_u.cccc.c3 = ConstantTermAdjust(pc->y_u.cccc.c3);
177 pc->y_u.cccc.c4 = ConstantTermAdjust(pc->y_u.cccc.c4);
178 pc = NEXTOP(pc,cccc);
179 break;
180 /* instructions type ccccc */
181 case _get_5atoms:
182 pc->y_u.ccccc.c1 = ConstantTermAdjust(pc->y_u.ccccc.c1);
183 pc->y_u.ccccc.c2 = ConstantTermAdjust(pc->y_u.ccccc.c2);
184 pc->y_u.ccccc.c3 = ConstantTermAdjust(pc->y_u.ccccc.c3);
185 pc->y_u.ccccc.c4 = ConstantTermAdjust(pc->y_u.ccccc.c4);
186 pc->y_u.ccccc.c5 = ConstantTermAdjust(pc->y_u.ccccc.c5);
187 pc = NEXTOP(pc,ccccc);
188 break;
189 /* instructions type cccccc */
190 case _get_6atoms:
191 pc->y_u.cccccc.c1 = ConstantTermAdjust(pc->y_u.cccccc.c1);
192 pc->y_u.cccccc.c2 = ConstantTermAdjust(pc->y_u.cccccc.c2);
193 pc->y_u.cccccc.c3 = ConstantTermAdjust(pc->y_u.cccccc.c3);
194 pc->y_u.cccccc.c4 = ConstantTermAdjust(pc->y_u.cccccc.c4);
195 pc->y_u.cccccc.c5 = ConstantTermAdjust(pc->y_u.cccccc.c5);
196 pc->y_u.cccccc.c6 = ConstantTermAdjust(pc->y_u.cccccc.c6);
197 pc = NEXTOP(pc,cccccc);
198 break;
199 /* instructions type clll */
200 case _if_not_then:
201 pc->y_u.clll.c = ConstantTermAdjust(pc->y_u.clll.c);
202 pc->y_u.clll.l1 = PtoOpAdjust(pc->y_u.clll.l1);
203 pc->y_u.clll.l2 = PtoOpAdjust(pc->y_u.clll.l2);
204 pc->y_u.clll.l3 = PtoOpAdjust(pc->y_u.clll.l3);
205 pc = NEXTOP(pc,clll);
206 break;
207 /* instructions type d */
208 case _write_float:
209 DoubleInCodeAdjust(pc->y_u.d.d);
210 pc = NEXTOP(pc,d);
211 break;
212 /* instructions type e */
213 case _Nstop:
214 case _allocate:
215 case _copy_idb_term:
216 case _enter_exo:
217 case _expand_index:
218 case _index_blob:
219 case _index_dbref:
220 case _index_long:
221 case _index_pred:
222 case _lock_pred:
223 case _op_fail:
224 case _p_equal:
225 case _p_functor:
226 case _pop:
227#ifdef BEAM
228 case _retry_eam:
229#endif
230 case _spy_pred:
231#ifdef THREADS
232 case _thread_local:
233#endif
234 case _trust_fail:
235 case _undef_p:
236 case _unify_idb_term:
237 case _unlock_lu:
238 case _write_l_list:
239 case _write_list:
240 case _write_void:
241 if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return;
242 pc = NEXTOP(pc,e);
243 break;
244 /* instructions type fa */
245 case _write_l_struc:
246 case _write_struct:
247 pc->y_u.fa.f = FuncAdjust(pc->y_u.fa.f);
248 pc->y_u.fa.a = ArityAdjust(pc->y_u.fa.a);
249 pc = NEXTOP(pc,fa);
250 break;
251 /* instructions type i */
252 case _write_longint:
253 IntegerInCodeAdjust(pc->y_u.i.i);
254 pc = NEXTOP(pc,i);
255 break;
256 /* instructions type l */
257 case _Ystop:
258 case _jump:
259 case _jump_if_var:
260 case _move_back:
261 case _retry2:
262 case _retry3:
263 case _retry4:
264 case _skip:
265 case _try_clause2:
266 case _try_clause3:
267 case _try_clause4:
268 case _try_in:
269 pc->y_u.l.l = PtoOpAdjust(pc->y_u.l.l);
270 if (op == _Ystop) return;
271 pc = NEXTOP(pc,l);
272 break;
273 /* instructions type llll */
274 case _switch_on_type:
275 pc->y_u.llll.l1 = PtoOpAdjust(pc->y_u.llll.l1);
276 pc->y_u.llll.l2 = PtoOpAdjust(pc->y_u.llll.l2);
277 pc->y_u.llll.l3 = PtoOpAdjust(pc->y_u.llll.l3);
278 pc->y_u.llll.l4 = PtoOpAdjust(pc->y_u.llll.l4);
279 pc = NEXTOP(pc,llll);
280 break;
281 /* instructions type lp */
282 case _retry_all_exo:
283 case _retry_exo:
284 case _retry_exo_udi:
285 case _try_all_exo:
286 case _try_exo:
287 case _try_exo_udi:
288 case _user_switch:
289 pc->y_u.lp.l = PtoOpAdjust(pc->y_u.lp.l);
290 pc->y_u.lp.p = PtoPredAdjust(pc->y_u.lp.p);
291 pc = NEXTOP(pc,lp);
292 break;
293 /* instructions type o */
294 case _unify_l_list:
295 case _unify_l_list_write:
296 case _unify_l_void:
297 case _unify_l_void_write:
298 case _unify_list:
299 case _unify_list_write:
300 case _unify_void:
301 case _unify_void_write:
302 pc->y_u.o.opcw = OpcodeAdjust(pc->y_u.o.opcw);
303 pc = NEXTOP(pc,o);
304 break;
305 /* instructions type oD */
306 case _unify_dbterm:
307 case _unify_l_dbterm:
308 pc->y_u.oD.opcw = OpcodeAdjust(pc->y_u.oD.opcw);
309 pc->y_u.oD.D = DBGroundTermAdjust(pc->y_u.oD.D);
310 pc = NEXTOP(pc,oD);
311 break;
312 /* instructions type oN */
313 case _unify_bigint:
314 case _unify_l_bigint:
315 pc->y_u.oN.opcw = OpcodeAdjust(pc->y_u.oN.opcw);
316 pc->y_u.oN.b = BlobTermInCodeAdjust(pc->y_u.oN.b);
317 pc = NEXTOP(pc,oN);
318 break;
319 /* instructions type oc */
320 case _unify_atom:
321 case _unify_atom_write:
322 case _unify_l_atom:
323 case _unify_l_atom_write:
324 pc->y_u.oc.opcw = OpcodeAdjust(pc->y_u.oc.opcw);
325 pc->y_u.oc.c = ConstantTermAdjust(pc->y_u.oc.c);
326 pc = NEXTOP(pc,oc);
327 break;
328 /* instructions type od */
329 case _unify_float:
330 case _unify_float_write:
331 case _unify_l_float:
332 case _unify_l_float_write:
333 pc->y_u.od.opcw = OpcodeAdjust(pc->y_u.od.opcw);
334 DoubleInCodeAdjust(pc->y_u.od.d);
335 pc = NEXTOP(pc,od);
336 break;
337 /* instructions type ofa */
338 case _unify_l_struc:
339 case _unify_l_struc_write:
340 case _unify_struct:
341 case _unify_struct_write:
342 pc->y_u.ofa.opcw = OpcodeAdjust(pc->y_u.ofa.opcw);
343 pc->y_u.ofa.f = FuncAdjust(pc->y_u.ofa.f);
344 pc->y_u.ofa.a = ArityAdjust(pc->y_u.ofa.a);
345 pc = NEXTOP(pc,ofa);
346 break;
347 /* instructions type oi */
348 case _unify_l_longint:
349 case _unify_l_longint_write:
350 case _unify_longint:
351 case _unify_longint_write:
352 pc->y_u.oi.opcw = OpcodeAdjust(pc->y_u.oi.opcw);
353 IntegerInCodeAdjust(pc->y_u.oi.i);
354 pc = NEXTOP(pc,oi);
355 break;
356 /* instructions type ollll */
357 case _switch_list_nl:
358 pc->y_u.ollll.pop = OpcodeAdjust(pc->y_u.ollll.pop);
359 pc->y_u.ollll.l1 = PtoOpAdjust(pc->y_u.ollll.l1);
360 pc->y_u.ollll.l2 = PtoOpAdjust(pc->y_u.ollll.l2);
361 pc->y_u.ollll.l3 = PtoOpAdjust(pc->y_u.ollll.l3);
362 pc->y_u.ollll.l4 = PtoOpAdjust(pc->y_u.ollll.l4);
363 pc = NEXTOP(pc,ollll);
364 break;
365 /* instructions type os */
366#ifdef BEAM
367 case _run_eam:
368#endif
369 case _unify_l_n_voids:
370 case _unify_l_n_voids_write:
371 case _unify_n_voids:
372 case _unify_n_voids_write:
373 pc->y_u.os.opcw = OpcodeAdjust(pc->y_u.os.opcw);
374 pc->y_u.os.s = ConstantAdjust(pc->y_u.os.s);
375 pc = NEXTOP(pc,os);
376 break;
377 /* instructions type osc */
378 case _unify_n_atoms:
379 case _unify_n_atoms_write:
380 pc->y_u.osc.opcw = OpcodeAdjust(pc->y_u.osc.opcw);
381 pc->y_u.osc.s = ConstantAdjust(pc->y_u.osc.s);
382 pc->y_u.osc.c = ConstantTermAdjust(pc->y_u.osc.c);
383 pc = NEXTOP(pc,osc);
384 break;
385 /* instructions type ou */
386 case _unify_l_string:
387 case _unify_string:
388 pc->y_u.ou.opcw = OpcodeAdjust(pc->y_u.ou.opcw);
389 pc->y_u.ou.ut = BlobTermInCodeAdjust(pc->y_u.ou.ut);
390 pc = NEXTOP(pc,ou);
391 break;
392 /* instructions type ox */
393 case _save_appl_x:
394 case _save_appl_x_write:
395 case _save_pair_x:
396 case _save_pair_x_write:
397 case _unify_l_x_loc:
398 case _unify_l_x_loc_write:
399 case _unify_l_x_val:
400 case _unify_l_x_val_write:
401 case _unify_l_x_var:
402 case _unify_l_x_var_write:
403 case _unify_x_loc:
404 case _unify_x_loc_write:
405 case _unify_x_val:
406 case _unify_x_val_write:
407 case _unify_x_var:
408 case _unify_x_var_write:
409 pc->y_u.ox.opcw = OpcodeAdjust(pc->y_u.ox.opcw);
410 pc->y_u.ox.x = XAdjust(pc->y_u.ox.x);
411 pc = NEXTOP(pc,ox);
412 break;
413 /* instructions type oxx */
414 case _unify_l_x_var2:
415 case _unify_l_x_var2_write:
416 case _unify_x_var2:
417 case _unify_x_var2_write:
418 pc->y_u.oxx.opcw = OpcodeAdjust(pc->y_u.oxx.opcw);
419 pc->y_u.oxx.xl = XAdjust(pc->y_u.oxx.xl);
420 pc->y_u.oxx.xr = XAdjust(pc->y_u.oxx.xr);
421 pc = NEXTOP(pc,oxx);
422 break;
423 /* instructions type oy */
424 case _save_appl_y:
425 case _save_appl_y_write:
426 case _save_pair_y:
427 case _save_pair_y_write:
428 case _unify_l_y_loc:
429 case _unify_l_y_loc_write:
430 case _unify_l_y_val:
431 case _unify_l_y_val_write:
432 case _unify_l_y_var:
433 case _unify_l_y_var_write:
434 case _unify_y_loc:
435 case _unify_y_loc_write:
436 case _unify_y_val:
437 case _unify_y_val_write:
438 case _unify_y_var:
439 case _unify_y_var_write:
440 pc->y_u.oy.opcw = OpcodeAdjust(pc->y_u.oy.opcw);
441 pc->y_u.oy.y = YAdjust(pc->y_u.oy.y);
442 pc = NEXTOP(pc,oy);
443 break;
444 /* instructions type p */
445 case _count_call:
446 case _count_retry:
447 case _deallocate:
448 case _enter_profiling:
449 case _lock_lu:
450 case _procceed:
451 case _retry_profiled:
452 case _retry_udi:
453 case _try_udi:
454 pc->y_u.p.p = PtoPredAdjust(pc->y_u.p.p);
455 pc = NEXTOP(pc,p);
456 break;
457 /* instructions type plxxs */
458 case _call_bfunc_xx:
459 pc->y_u.plxxs.p = PtoPredAdjust(pc->y_u.plxxs.p);
460 pc->y_u.plxxs.f = PtoOpAdjust(pc->y_u.plxxs.f);
461 pc->y_u.plxxs.x1 = XAdjust(pc->y_u.plxxs.x1);
462 pc->y_u.plxxs.x2 = XAdjust(pc->y_u.plxxs.x2);
463 pc->y_u.plxxs.flags = ConstantAdjust(pc->y_u.plxxs.flags);
464 pc = NEXTOP(pc,plxxs);
465 break;
466 /* instructions type plxys */
467 case _call_bfunc_xy:
468 case _call_bfunc_yx:
469 pc->y_u.plxys.p = PtoPredAdjust(pc->y_u.plxys.p);
470 pc->y_u.plxys.f = PtoOpAdjust(pc->y_u.plxys.f);
471 pc->y_u.plxys.x = XAdjust(pc->y_u.plxys.x);
472 pc->y_u.plxys.y = YAdjust(pc->y_u.plxys.y);
473 pc->y_u.plxys.flags = ConstantAdjust(pc->y_u.plxys.flags);
474 pc = NEXTOP(pc,plxys);
475 break;
476 /* instructions type plyys */
477 case _call_bfunc_yy:
478 pc->y_u.plyys.p = PtoPredAdjust(pc->y_u.plyys.p);
479 pc->y_u.plyys.f = PtoOpAdjust(pc->y_u.plyys.f);
480 pc->y_u.plyys.y1 = YAdjust(pc->y_u.plyys.y1);
481 pc->y_u.plyys.y2 = YAdjust(pc->y_u.plyys.y2);
482 pc->y_u.plyys.flags = ConstantAdjust(pc->y_u.plyys.flags);
483 pc = NEXTOP(pc,plyys);
484 break;
485 /* instructions type s */
486 case _cut:
487 case _cut_e:
488 case _cut_t:
489 case _pop_n:
490 case _write_n_voids:
491 pc->y_u.s.s = ConstantAdjust(pc->y_u.s.s);
492 pc = NEXTOP(pc,s);
493 break;
494 /* instructions type sc */
495 case _write_n_atoms:
496 pc->y_u.sc.s = ConstantAdjust(pc->y_u.sc.s);
497 pc->y_u.sc.c = ConstantTermAdjust(pc->y_u.sc.c);
498 pc = NEXTOP(pc,sc);
499 break;
500 /* instructions type sllll */
501 case _switch_on_sub_arg_type:
502 pc->y_u.sllll.s = ConstantAdjust(pc->y_u.sllll.s);
503 pc->y_u.sllll.l1 = PtoOpAdjust(pc->y_u.sllll.l1);
504 pc->y_u.sllll.l2 = PtoOpAdjust(pc->y_u.sllll.l2);
505 pc->y_u.sllll.l3 = PtoOpAdjust(pc->y_u.sllll.l3);
506 pc->y_u.sllll.l4 = PtoOpAdjust(pc->y_u.sllll.l4);
507 pc = NEXTOP(pc,sllll);
508 break;
509 /* instructions type slpp */
510 case _call_c_wfail:
511 pc->y_u.slpp.s = ConstantAdjust(pc->y_u.slpp.s);
512 pc->y_u.slpp.l = PtoOpAdjust(pc->y_u.slpp.l);
513 pc->y_u.slpp.p = PtoPredAdjust(pc->y_u.slpp.p);
514 pc->y_u.slpp.p0 = PtoPredAdjust(pc->y_u.slpp.p0);
515 pc = NEXTOP(pc,slpp);
516 break;
517 /* instructions type sssl */
518 case _go_on_cons:
519 case _go_on_func:
520 case _if_cons:
521 case _if_func:
522 case _switch_on_cons:
523 case _switch_on_func:
524 pc->y_u.sssl.s = ConstantAdjust(pc->y_u.sssl.s);
525 pc->y_u.sssl.e = ConstantAdjust(pc->y_u.sssl.e);
526 pc->y_u.sssl.w = ConstantAdjust(pc->y_u.sssl.w);
527 pc->y_u.sssl.l = PtoOpAdjust(pc->y_u.sssl.l);
528 AdjustSwitchTable(op, pc->y_u.sssl.l, pc->y_u.sssl.s);
529 pc = NEXTOP(pc,sssl);
530 break;
531 /* instructions type sssllp */
532 case _expand_clauses:
533 pc->y_u.sssllp.s1 = ConstantAdjust(pc->y_u.sssllp.s1);
534 pc->y_u.sssllp.s2 = ConstantAdjust(pc->y_u.sssllp.s2);
535 pc->y_u.sssllp.s3 = ConstantAdjust(pc->y_u.sssllp.s3);
536 pc->y_u.sssllp.sprev = PtoOpAdjust(pc->y_u.sssllp.sprev);
537 pc->y_u.sssllp.snext = PtoOpAdjust(pc->y_u.sssllp.snext);
538 pc->y_u.sssllp.p = PtoPredAdjust(pc->y_u.sssllp.p);
539 pc = NEXTOP(pc,sssllp);
540 break;
541 /* instructions type x */
542 case _get_atom_exo:
543 case _get_list:
544 case _put_list:
545 case _save_b_x:
546 case _write_x_loc:
547 case _write_x_val:
548 case _write_x_var:
549 pc->y_u.x.x = XAdjust(pc->y_u.x.x);
550 pc = NEXTOP(pc,x);
551 break;
552 /* instructions type xD */
553 case _get_dbterm:
554 case _put_dbterm:
555 pc->y_u.xD.x = XAdjust(pc->y_u.xD.x);
556 pc->y_u.xD.D = DBGroundTermAdjust(pc->y_u.xD.D);
557 pc = NEXTOP(pc,xD);
558 break;
559 /* instructions type xN */
560 case _get_bigint:
561 case _put_bigint:
562 pc->y_u.xN.x = XAdjust(pc->y_u.xN.x);
563 pc->y_u.xN.b = BlobTermInCodeAdjust(pc->y_u.xN.b);
564 pc = NEXTOP(pc,xN);
565 break;
566 /* instructions type xc */
567 case _get_atom:
568 case _put_atom:
569 pc->y_u.xc.x = XAdjust(pc->y_u.xc.x);
570 pc->y_u.xc.c = ConstantTermAdjust(pc->y_u.xc.c);
571 pc = NEXTOP(pc,xc);
572 break;
573 /* instructions type xd */
574 case _get_float:
575 case _put_float:
576 pc->y_u.xd.x = XAdjust(pc->y_u.xd.x);
577 DoubleInCodeAdjust(pc->y_u.xd.d);
578 pc = NEXTOP(pc,xd);
579 break;
580 /* instructions type xfa */
581 case _get_struct:
582 case _put_struct:
583 pc->y_u.xfa.x = XAdjust(pc->y_u.xfa.x);
584 pc->y_u.xfa.f = FuncAdjust(pc->y_u.xfa.f);
585 pc->y_u.xfa.a = ArityAdjust(pc->y_u.xfa.a);
586 pc = NEXTOP(pc,xfa);
587 break;
588 /* instructions type xi */
589 case _get_longint:
590 case _put_longint:
591 pc->y_u.xi.x = XAdjust(pc->y_u.xi.x);
592 IntegerInCodeAdjust(pc->y_u.xi.i);
593 pc = NEXTOP(pc,xi);
594 break;
595 /* instructions type xl */
596 case _p_atom_x:
597 case _p_atomic_x:
598 case _p_compound_x:
599 case _p_db_ref_x:
600 case _p_float_x:
601 case _p_integer_x:
602 case _p_nonvar_x:
603 case _p_number_x:
604 case _p_primitive_x:
605 case _p_var_x:
606 pc->y_u.xl.x = XAdjust(pc->y_u.xl.x);
607 pc->y_u.xl.F = PtoOpAdjust(pc->y_u.xl.F);
608 pc = NEXTOP(pc,xl);
609 break;
610 /* instructions type xll */
611 case _jump_if_nonvar:
612 pc->y_u.xll.x = XAdjust(pc->y_u.xll.x);
613 pc->y_u.xll.l1 = PtoOpAdjust(pc->y_u.xll.l1);
614 pc->y_u.xll.l2 = PtoOpAdjust(pc->y_u.xll.l2);
615 pc = NEXTOP(pc,xll);
616 break;
617 /* instructions type xllll */
618 case _switch_on_arg_type:
619 pc->y_u.xllll.x = XAdjust(pc->y_u.xllll.x);
620 pc->y_u.xllll.l1 = PtoOpAdjust(pc->y_u.xllll.l1);
621 pc->y_u.xllll.l2 = PtoOpAdjust(pc->y_u.xllll.l2);
622 pc->y_u.xllll.l3 = PtoOpAdjust(pc->y_u.xllll.l3);
623 pc->y_u.xllll.l4 = PtoOpAdjust(pc->y_u.xllll.l4);
624 pc = NEXTOP(pc,xllll);
625 break;
626 /* instructions type xps */
627 case _commit_b_x:
628 case _soft_cut_b_x:
629 pc->y_u.xps.x = XAdjust(pc->y_u.xps.x);
630 pc->y_u.xps.p0 = PtoPredAdjust(pc->y_u.xps.p0);
631 pc->y_u.xps.s = ConstantAdjust(pc->y_u.xps.s);
632 pc = NEXTOP(pc,xps);
633 break;
634 /* instructions type xu */
635 case _get_string:
636 pc->y_u.xu.x = XAdjust(pc->y_u.xu.x);
637 pc->y_u.xu.ut = BlobTermInCodeAdjust(pc->y_u.xu.ut);
638 pc = NEXTOP(pc,xu);
639 break;
640 /* instructions type xx */
641 case _get_x_val:
642 case _get_x_var:
643 case _gl_void_valx:
644 case _gl_void_varx:
645 case _glist_valx:
646 case _put_x_val:
647 case _put_x_var:
648 pc->y_u.xx.xl = XAdjust(pc->y_u.xx.xl);
649 pc->y_u.xx.xr = XAdjust(pc->y_u.xx.xr);
650 pc = NEXTOP(pc,xx);
651 break;
652 /* instructions type xxc */
653 case _p_func2s_cv:
654 pc->y_u.xxc.x = XAdjust(pc->y_u.xxc.x);
655 pc->y_u.xxc.xi = XAdjust(pc->y_u.xxc.xi);
656 pc->y_u.xxc.c = ConstantTermAdjust(pc->y_u.xxc.c);
657 pc = NEXTOP(pc,xxc);
658 break;
659 /* instructions type xxn */
660 case _p_and_vc:
661 case _p_arg_cv:
662 case _p_div_cv:
663 case _p_div_vc:
664 case _p_func2s_vc:
665 case _p_minus_cv:
666 case _p_or_vc:
667 case _p_plus_vc:
668 case _p_sll_cv:
669 case _p_sll_vc:
670 case _p_slr_cv:
671 case _p_slr_vc:
672 case _p_times_vc:
673 pc->y_u.xxn.x = XAdjust(pc->y_u.xxn.x);
674 pc->y_u.xxn.xi = XAdjust(pc->y_u.xxn.xi);
675 pc->y_u.xxn.c = IntegerAdjust(pc->y_u.xxn.c);
676 pc = NEXTOP(pc,xxn);
677 break;
678 /* instructions type xxx */
679 case _p_and_vv:
680 case _p_arg_vv:
681 case _p_div_vv:
682 case _p_func2f_xx:
683 case _p_func2s_vv:
684 case _p_minus_vv:
685 case _p_or_vv:
686 case _p_plus_vv:
687 case _p_sll_vv:
688 case _p_slr_vv:
689 case _p_times_vv:
690 pc->y_u.xxx.x = XAdjust(pc->y_u.xxx.x);
691 pc->y_u.xxx.x1 = XAdjust(pc->y_u.xxx.x1);
692 pc->y_u.xxx.x2 = XAdjust(pc->y_u.xxx.x2);
693 pc = NEXTOP(pc,xxx);
694 break;
695 /* instructions type xxxx */
696 case _put_xx_val:
697 pc->y_u.xxxx.xl1 = XAdjust(pc->y_u.xxxx.xl1);
698 pc->y_u.xxxx.xl2 = XAdjust(pc->y_u.xxxx.xl2);
699 pc->y_u.xxxx.xr1 = XAdjust(pc->y_u.xxxx.xr1);
700 pc->y_u.xxxx.xr2 = XAdjust(pc->y_u.xxxx.xr2);
701 pc = NEXTOP(pc,xxxx);
702 break;
703 /* instructions type xxy */
704 case _p_func2f_xy:
705 pc->y_u.xxy.x = XAdjust(pc->y_u.xxy.x);
706 pc->y_u.xxy.x1 = XAdjust(pc->y_u.xxy.x1);
707 pc->y_u.xxy.y2 = YAdjust(pc->y_u.xxy.y2);
708 pc = NEXTOP(pc,xxy);
709 break;
710 /* instructions type y */
711 case _save_b_y:
712 case _write_y_loc:
713 case _write_y_val:
714 case _write_y_var:
715 pc->y_u.y.y = YAdjust(pc->y_u.y.y);
716 pc = NEXTOP(pc,y);
717 break;
718 /* instructions type yl */
719 case _p_atom_y:
720 case _p_atomic_y:
721 case _p_compound_y:
722 case _p_db_ref_y:
723 case _p_float_y:
724 case _p_integer_y:
725 case _p_nonvar_y:
726 case _p_number_y:
727 case _p_primitive_y:
728 case _p_var_y:
729 pc->y_u.yl.y = YAdjust(pc->y_u.yl.y);
730 pc->y_u.yl.F = PtoOpAdjust(pc->y_u.yl.F);
731 pc = NEXTOP(pc,yl);
732 break;
733 /* instructions type yps */
734 case _commit_b_y:
735 case _soft_cut_b_y:
736 pc->y_u.yps.y = YAdjust(pc->y_u.yps.y);
737 pc->y_u.yps.p0 = PtoPredAdjust(pc->y_u.yps.p0);
738 pc->y_u.yps.s = ConstantAdjust(pc->y_u.yps.s);
739 pc = NEXTOP(pc,yps);
740 break;
741 /* instructions type yx */
742 case _get_y_val:
743 case _get_y_var:
744 case _gl_void_valy:
745 case _gl_void_vary:
746 case _glist_valy:
747 case _put_unsafe:
748 case _put_y_val:
749 case _put_y_var:
750 pc->y_u.yx.y = YAdjust(pc->y_u.yx.y);
751 pc->y_u.yx.x = XAdjust(pc->y_u.yx.x);
752 pc = NEXTOP(pc,yx);
753 break;
754 /* instructions type yxc */
755 case _p_func2s_y_cv:
756 pc->y_u.yxc.y = YAdjust(pc->y_u.yxc.y);
757 pc->y_u.yxc.xi = XAdjust(pc->y_u.yxc.xi);
758 pc->y_u.yxc.c = ConstantTermAdjust(pc->y_u.yxc.c);
759 pc = NEXTOP(pc,yxc);
760 break;
761 /* instructions type yxn */
762 case _p_and_y_vc:
763 case _p_arg_y_cv:
764 case _p_div_y_cv:
765 case _p_div_y_vc:
766 case _p_func2s_y_vc:
767 case _p_minus_y_cv:
768 case _p_or_y_vc:
769 case _p_plus_y_vc:
770 case _p_sll_y_cv:
771 case _p_sll_y_vc:
772 case _p_slr_y_cv:
773 case _p_slr_y_vc:
774 case _p_times_y_vc:
775 pc->y_u.yxn.y = YAdjust(pc->y_u.yxn.y);
776 pc->y_u.yxn.xi = XAdjust(pc->y_u.yxn.xi);
777 pc->y_u.yxn.c = IntegerAdjust(pc->y_u.yxn.c);
778 pc = NEXTOP(pc,yxn);
779 break;
780 /* instructions type yxx */
781 case _p_and_y_vv:
782 case _p_arg_y_vv:
783 case _p_div_y_vv:
784 case _p_func2f_yx:
785 case _p_func2s_y_vv:
786 case _p_minus_y_vv:
787 case _p_or_y_vv:
788 case _p_plus_y_vv:
789 case _p_sll_y_vv:
790 case _p_slr_y_vv:
791 case _p_times_y_vv:
792 pc->y_u.yxx.y = YAdjust(pc->y_u.yxx.y);
793 pc->y_u.yxx.x1 = XAdjust(pc->y_u.yxx.x1);
794 pc->y_u.yxx.x2 = XAdjust(pc->y_u.yxx.x2);
795 pc = NEXTOP(pc,yxx);
796 break;
797 /* instructions type yyx */
798 case _p_func2f_yy:
799 pc->y_u.yyx.y1 = YAdjust(pc->y_u.yyx.y1);
800 pc->y_u.yyx.y2 = YAdjust(pc->y_u.yyx.y2);
801 pc->y_u.yyx.x = XAdjust(pc->y_u.yyx.x);
802 pc = NEXTOP(pc,yyx);
803 break;
804 /* instructions type yyxx */
805 case _get_yy_var:
806 case _put_y_vals:
807 pc->y_u.yyxx.y1 = YAdjust(pc->y_u.yyxx.y1);
808 pc->y_u.yyxx.y2 = YAdjust(pc->y_u.yyxx.y2);
809 pc->y_u.yyxx.x1 = XAdjust(pc->y_u.yyxx.x1);
810 pc->y_u.yyxx.x2 = XAdjust(pc->y_u.yyxx.x2);
811 pc = NEXTOP(pc,yyxx);
812 break;
813#ifdef YAPOR
814 /* instructions type Otapl */
815 case _getwork:
816 case _getwork_seq:
817 case _sync:
818 OrArgAdjust(pc->y_u.Otapl.or_arg);
819 TabEntryAdjust(pc->y_u.Otapl.te);
820 pc->y_u.Otapl.s = ArityAdjust(pc->y_u.Otapl.s);
821 pc->y_u.Otapl.p = PtoPredAdjust(pc->y_u.Otapl.p);
822 pc->y_u.Otapl.d = PtoOpAdjust(pc->y_u.Otapl.d);
823 pc = NEXTOP(pc,Otapl);
824 break;
825 /* instructions type e */
826 case _getwork_first_time:
827 if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return;
828 pc = NEXTOP(pc,e);
829 break;
830#endif
831#ifdef TABLING
832 /* instructions type Otapl */
833 case _table_answer_resolution:
834#ifdef THREADS_CONSUMER_SHARING
835 case _table_answer_resolution_completion:
836#endif
837 case _table_completion:
838 case _table_load_answer:
839 case _table_retry:
840 case _table_retry_me:
841 case _table_trust:
842 case _table_trust_me:
843 case _table_try:
844 case _table_try_answer:
845 case _table_try_me:
846 case _table_try_single:
847 OrArgAdjust(pc->y_u.Otapl.or_arg);
848 TabEntryAdjust(pc->y_u.Otapl.te);
849 pc->y_u.Otapl.s = ArityAdjust(pc->y_u.Otapl.s);
850 pc->y_u.Otapl.p = PtoPredAdjust(pc->y_u.Otapl.p);
851 pc->y_u.Otapl.d = PtoOpAdjust(pc->y_u.Otapl.d);
852 pc = NEXTOP(pc,Otapl);
853 break;
854 /* instructions type e */
855#ifdef TABLING_INNER_CUTS
856 case _clause_with_cut:
857#endif
858 if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return;
859 pc = NEXTOP(pc,e);
860 break;
861 /* instructions type s */
862 case _table_new_answer:
863 pc->y_u.s.s = ConstantAdjust(pc->y_u.s.s);
864 pc = NEXTOP(pc,s);
865 break;
866 /* instructions type e */
867 case _trie_do_appl:
868 case _trie_do_appl_in_pair:
869 case _trie_do_atom:
870 case _trie_do_atom_in_pair:
871 case _trie_do_bigint:
872 case _trie_do_double:
873 case _trie_do_extension:
874 case _trie_do_gterm:
875 case _trie_do_longint:
876 case _trie_do_null:
877 case _trie_do_null_in_pair:
878 case _trie_do_pair:
879 case _trie_do_val:
880 case _trie_do_val_in_pair:
881 case _trie_do_var:
882 case _trie_do_var_in_pair:
883 case _trie_retry_appl:
884 case _trie_retry_appl_in_pair:
885 case _trie_retry_atom:
886 case _trie_retry_atom_in_pair:
887 case _trie_retry_bigint:
888 case _trie_retry_double:
889 case _trie_retry_extension:
890 case _trie_retry_gterm:
891 case _trie_retry_longint:
892 case _trie_retry_null:
893 case _trie_retry_null_in_pair:
894 case _trie_retry_pair:
895 case _trie_retry_val:
896 case _trie_retry_val_in_pair:
897 case _trie_retry_var:
898 case _trie_retry_var_in_pair:
899 case _trie_trust_appl:
900 case _trie_trust_appl_in_pair:
901 case _trie_trust_atom:
902 case _trie_trust_atom_in_pair:
903 case _trie_trust_bigint:
904 case _trie_trust_double:
905 case _trie_trust_extension:
906 case _trie_trust_gterm:
907 case _trie_trust_longint:
908 case _trie_trust_null:
909 case _trie_trust_null_in_pair:
910 case _trie_trust_pair:
911 case _trie_trust_val:
912 case _trie_trust_val_in_pair:
913 case _trie_trust_var:
914 case _trie_trust_var_in_pair:
915 case _trie_try_appl:
916 case _trie_try_appl_in_pair:
917 case _trie_try_atom:
918 case _trie_try_atom_in_pair:
919 case _trie_try_bigint:
920 case _trie_try_double:
921 case _trie_try_extension:
922 case _trie_try_gterm:
923 case _trie_try_longint:
924 case _trie_try_null:
925 case _trie_try_null_in_pair:
926 case _trie_try_pair:
927 case _trie_try_val:
928 case _trie_try_val_in_pair:
929 case _trie_try_var:
930 case _trie_try_var_in_pair:
931 if (op == _Nstop || op == _copy_idb_term || op == _unify_idb_term) return;
932 pc = NEXTOP(pc,e);
933 break;
934#endif
935 /* this instruction is hardwired */
936 case _or_last:
937#ifdef YAPOR
938 OrArgAdjust(pc->y_u.Osblp.or_arg);
939 pc->y_u.Osblp.s = ConstantAdjust(pc->y_u.Osblp.s);
940 pc->y_u.Osblp.bmap = CellPtoHeapAdjust(pc->y_u.Osblp.bmap);
941 pc->y_u.Osblp.l = PtoOpAdjust(pc->y_u.Osblp.l);
942 pc->y_u.Osblp.p0 = PtoPredAdjust(pc->y_u.Osblp.p0);
943 pc = NEXTOP(pc,Osblp);
944 break;
945#else
946 pc->y_u.p.p = PtoPredAdjust(pc->y_u.p.p);
947 pc = NEXTOP(pc,p);
948 break;
949#endif
950 }
951 } while (TRUE);
952}
yami
Definition: amidefs.h:264