YAP 7.1.0
debug.c
1/*************************************************************************
2 * *
3 * YAP Prolog *
4 * *
5 * Yap Prolog was developed at NCCUP - Universidade do Porto *
6 * *
7 * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
8 * *
9 **************************************************************************
10 * *
11 * File: exec.c *
12 * Last rev: 8/2/88 *
13 * mods: *
14 * comments: Execute Prolog code *
15 * *
16 *************************************************************************/
17
18#ifdef SCCS
19static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
20#endif
21
22#include "Yap.h"
23#include "absmi.h"
24#include "attvar.h"
25#include "cut_c.h"
26#include "yapio.h"
27
28static Int get_debugger_state(USES_REGS1) {
29 const char *s = RepAtom(AtomOfTerm(Deref(ARG1)))->StrOfAE;
30 if (!strcmp(s, "creep")) {
31 return Yap_unify(ARG2, LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP]);
32 }
33 if (!strcmp(s, "goal_number")) {
34 return Yap_unify(ARG2, LOCAL_debugger_state[DEBUG_GOAL_NUMBER]);
35 }
36 if (!strcmp(s, "spy")) {
37 return Yap_unify(ARG2, LOCAL_debugger_state[DEBUG_SPY]);
38 }
39 if (!strcmp(s, "trace")) {
40 return Yap_unify(ARG2, LOCAL_debugger_state[DEBUG_TRACE]);
41 }
42 if (!strcmp(s, "debug")) {
43 return Yap_unify(ARG2, LOCAL_debugger_state[DEBUG_DEBUG]);
44 }
45 return false;
46}
47
48static Int set_debugger_state(USES_REGS1) {
49 const char *s = RepAtom(AtomOfTerm(Deref(ARG1)))->StrOfAE;
50 if (!strcmp(s, "creep")) {
51 LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP] = Deref(ARG2);
52 return true;
53 }
54 if (!strcmp(s, "goal_number")) {
55 LOCAL_debugger_state[DEBUG_GOAL_NUMBER] = Deref(ARG2);
56 return true;
57 }
58 if (!strcmp(s, "spy")) {
59 LOCAL_debugger_state[DEBUG_SPY] = Deref(ARG2);
60 return true;
61 }
62 if (!strcmp(s, "trace")) {
63 LOCAL_debugger_state[DEBUG_TRACE] = Deref(ARG2);
64 return true;
65 }
66 if (!strcmp(s, "debug")) {
67 LOCAL_debugger_state[DEBUG_DEBUG] = Deref(ARG2);
68 return true;
69 }
70 return false;
71}
72
73static void init_debugger_state(void) {
74
75 LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP] = TermCreep;
76 LOCAL_debugger_state[DEBUG_GOAL_NUMBER] = MkIntTerm(0);
77 LOCAL_debugger_state[DEBUG_SPY] = TermOff;
78 LOCAL_debugger_state[DEBUG_TRACE] = TermFalse;
79 LOCAL_debugger_state[DEBUG_DEBUG] = TermFalse;
80}
81
82static Int set_debugger_state5(USES_REGS1) {
83 Term t1 = Deref(ARG1);
84 if (!IsVarTerm(t1)) {
85
86 LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP] = t1;
87 }
88 t1 = Deref(ARG2);
89 if (!IsVarTerm(t1)) {
90 LOCAL_debugger_state[DEBUG_GOAL_NUMBER] = t1;
91 }
92 t1 = Deref(ARG3);
93 if (!IsVarTerm(t1)) {
94 LOCAL_debugger_state[DEBUG_SPY] = t1;
95 }
96 t1 = Deref(ARG4);
97 if (!IsVarTerm(t1)) {
98 LOCAL_debugger_state[DEBUG_TRACE] = t1;
99 }
100 t1 = Deref(ARG5);
101 if (!IsVarTerm(t1)) {
102 LOCAL_debugger_state[DEBUG_DEBUG] = t1;
103 }
104 return true;
105}
106
107static Int get_debugger_state5(USES_REGS1) {
108 Term t1 = Deref(ARG1);
109 if (!Yap_unify(LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP], t1))
110 return false;
111 t1 = Deref(ARG2);
112 if (!Yap_unify(LOCAL_debugger_state[DEBUG_GOAL_NUMBER], t1))
113 return false;
114 t1 = Deref(ARG3);
115 if (!Yap_unify(LOCAL_debugger_state[DEBUG_SPY], t1))
116 return false;
117 t1 = Deref(ARG4);
118 if (!Yap_unify(LOCAL_debugger_state[DEBUG_TRACE], t1))
119 return false;
120 t1 = Deref(ARG5);
121 if (!Yap_unify(LOCAL_debugger_state[DEBUG_DEBUG], t1))
122 return false;
123 return true;
124}
125
126/******************************************************************
127
128 MANAGING SPY-POINTS
129
130******************************************************************/
131
132static Int p_is_no_trace(USES_REGS1) { /* '$undefined'(P,Mod) */
133 PredEntry *pe;
134
135 pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "undefined/1");
136 if (EndOfPAEntr(pe))
137 return true;
138 PELOCK(36, pe);
139 if (pe->PredFlags & (NoTracePredFlag | HiddenPredFlag)) {
140 UNLOCKPE(57, pe);
141 return true;
142 }
143 UNLOCKPE(59, pe);
144 return false;
145}
146
147static Int p_set_no_trace(USES_REGS1) { /* '$set_no_trace'(+Fun,+M) */
148 PredEntry *pe;
149
150 pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "undefined/1");
151 if (EndOfPAEntr(pe))
152 return FALSE;
153 PELOCK(36, pe);
154 pe->PredFlags |= NoTracePredFlag;
155 UNLOCKPE(57, pe);
156 return TRUE;
157}
158
159int Yap_SetNoTrace(char *name, arity_t arity, Term tmod) {
160 PredEntry *pe;
161
162 if (arity == 0) {
163 pe = Yap_get_pred(MkAtomTerm(Yap_LookupAtom(name)), tmod, "no_trace");
164 } else {
165 pe = RepPredProp(
166 PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(name), arity), tmod));
167 }
168 if (EndOfPAEntr(pe))
169 return FALSE;
170 PELOCK(36, pe);
171 pe->PredFlags |= NoTracePredFlag;
172 UNLOCKPE(57, pe);
173 return TRUE;
174}
175
176static Int p_setspy(USES_REGS1) { /* '$set_spy'(+Fun,+M) */
177 Atom at;
178 PredEntry *pred;
179 pred_flags_t fg;
180 Term t, mod;
181
182 at = AtomSpy;
183 pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1), 0));
184 SpyCode = pred;
185 t = Deref(ARG1);
186 mod = Deref(ARG2);
187 if (IsVarTerm(mod) || !IsAtomTerm(mod))
188 return (FALSE);
189 if (IsVarTerm(t))
190 return (FALSE);
191 if (IsAtomTerm(t)) {
192 Atom at = AtomOfTerm(t);
193 pred = RepPredProp(Yap_PredPropByAtomNonThreadLocal(at, mod));
194 } else if (IsApplTerm(t)) {
195 Functor fun = FunctorOfTerm(t);
196 pred = RepPredProp(Yap_PredPropByFunctorNonThreadLocal(fun, mod));
197 } else {
198 return (FALSE);
199 }
200 PELOCK(22, pred);
201restart_spy:
202 if (pred->PredFlags & (CPredFlag | SafePredFlag)) {
203 UNLOCKPE(35, pred);
204 return FALSE;
205 }
206 if (pred->OpcodeOfPred == UNDEF_OPCODE || pred->OpcodeOfPred == FAIL_OPCODE) {
207 UNLOCKPE(36, pred);
208 return FALSE;
209 }
210 if (pred->OpcodeOfPred == INDEX_OPCODE) {
211 int i = 0;
212 for (i = 0; i < pred->ArityOfPE; i++) {
213 XREGS[i + 1] = MkVarTerm();
214 }
215 Yap_IPred(pred, 0, CP);
216 goto restart_spy;
217 }
218 fg = pred->PredFlags;
219 if (fg & DynamicPredFlag) {
220 pred->OpcodeOfPred = ((yamop *)(pred->CodeOfPred))->opc =
221 Yap_opcode(_spy_or_trymark);
222 } else {
223 pred->OpcodeOfPred = Yap_opcode(_spy_pred);
224 pred->CodeOfPred = (yamop *)(&(pred->OpcodeOfPred));
225 }
226 pred->PredFlags |= SpiedPredFlag;
227 UNLOCKPE(37, pred);
228 return TRUE;
229}
230
231static Int p_rmspy(USES_REGS1) { /* '$rm_spy'(+T,+Mod) */
232 Atom at;
233 PredEntry *pred;
234 Term t;
235 Term mod;
236
237 t = Deref(ARG1);
238 mod = Deref(ARG2);
239 if (IsVarTerm(mod) || !IsAtomTerm(mod))
240 return (FALSE);
241 if (IsVarTerm(t))
242 return (FALSE);
243 if (IsAtomTerm(t)) {
244 at = AtomOfTerm(t);
245 pred = RepPredProp(Yap_PredPropByAtomNonThreadLocal(at, mod));
246 } else if (IsApplTerm(t)) {
247 Functor fun = FunctorOfTerm(t);
248 pred = RepPredProp(Yap_PredPropByFunctorNonThreadLocal(fun, mod));
249 } else
250 return FALSE;
251 PELOCK(23, pred);
252 if (!(pred->PredFlags & SpiedPredFlag)) {
253 UNLOCKPE(38, pred);
254 return FALSE;
255 }
256#if THREADS
257 if (pred->PredFlags & ThreadLocalPredFlag) {
258 pred->OpcodeOfPred = Yap_opcode(_thread_local);
259 pred->PredFlags ^= SpiedPredFlag;
260 UNLOCKPE(39, pred);
261 return TRUE;
262 }
263#endif
264 if (!(pred->PredFlags & (CountPredFlag | ProfiledPredFlag))) {
265 if (!(pred->PredFlags & DynamicPredFlag)) {
266#if defined(YAPOR) || defined(THREADS)
267 if (pred->PredFlags & LogUpdatePredFlag &&
268 !(pred->PredFlags & ThreadLocalPredFlag) &&
269 pred->ModuleOfPred != IDB_MODULE) {
270 pred->OpcodeOfPred = LOCKPRED_OPCODE;
271 pred->CodeOfPred = (yamop *)(&(pred->OpcodeOfPred));
272 } else {
273#endif
274 pred->CodeOfPred = pred->cs.p_code.TrueCodeOfPred;
275 pred->OpcodeOfPred = pred->CodeOfPred->opc;
276#if defined(YAPOR) || defined(THREADS)
277 }
278#endif
279 } else if (pred->OpcodeOfPred == Yap_opcode(_spy_or_trymark)) {
280 pred->OpcodeOfPred = Yap_opcode(_try_and_mark);
281 } else {
282 UNLOCKPE(39, pred);
283 return FALSE;
284 }
285 }
286 pred->PredFlags ^= SpiedPredFlag;
287 UNLOCKPE(40, pred);
288 return (TRUE);
289}
290
291static Int p_creep(USES_REGS1) {
292 Atom at;
293 PredEntry *pred;
294
295 if (LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP] == TermZip ||
296 LOCAL_debugger_state[DEBUG_DEBUG] == TermFalse)
297 return true;
298 at = AtomCreep;
299 pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1), 0));
300 CreepCode = pred;
301 Yap_signal( YAP_CREEP_SIGNAL);
302 return TRUE;
303}
304
305static Int p_creep_fail(USES_REGS1) {
306 Atom at;
307 PredEntry *pred;
308 if (LOCAL_debugger_state[DEBUG_CREEP_LEAP_OR_ZIP] == TermZip ||
309 LOCAL_debugger_state[DEBUG_DEBUG] == TermFalse)
310 return true;
311 at = AtomCreep;
312 pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1), 0));
313 CreepCode = pred;
314 Yap_signal(YAP_CREEP_SIGNAL);
315 return FALSE;
316}
317
318static Int stop_creeping(USES_REGS1) {
319 LOCAL_debugger_state[DEBUG_DEBUG] = TermFalse;
320 if (Yap_get_signal(YAP_CREEP_SIGNAL)) {
321 return Yap_unify(ARG1, TermTrue);
322 }
323 return Yap_unify(ARG1, TermFalse);
324}
325
326static Int disable_debugging(USES_REGS1) {
327 Yap_get_signal(YAP_CREEP_SIGNAL);
328 return true;
329}
330
331static Int creep_allowed(USES_REGS1) {
332 if (PP != NULL) {
333 Yap_get_signal(YAP_CREEP_SIGNAL);
334 return true;
335 }
336 return false;
337}
338
339void Yap_InitDebugFs(void) {
340 CACHE_REGS
341
342 init_debugger_state();
343 Yap_InitCPred("$creep", 0, p_creep, SafePredFlag);
344 Yap_InitCPred("$creep_fail", 0, p_creep_fail, SafePredFlag);
345 Yap_InitCPred("$stop_creeping", 1, stop_creeping,
346 NoTracePredFlag | HiddenPredFlag | SafePredFlag);
347 Yap_InitCPred("$set_spy", 2, p_setspy, SyncPredFlag);
348 Yap_InitCPred("$rm_spy", 2, p_rmspy, SafePredFlag | SyncPredFlag);
349 Yap_InitCPred("$get_debugger_state", 2, get_debugger_state, NoTracePredFlag);
350 Yap_InitCPred("$get_debugger_state", 5, get_debugger_state5, NoTracePredFlag);
351 Yap_InitCPred("$set_debugger_state", 2, set_debugger_state, NoTracePredFlag);
352 Yap_InitCPred("$set_debugger_state", 5, set_debugger_state5, NoTracePredFlag);
353 Yap_InitCPred("$is_no_trace", 2, p_is_no_trace, TestPredFlag | SafePredFlag);
354 Yap_InitCPred("$set_no_trace", 2, p_set_no_trace,
355 TestPredFlag | SafePredFlag);
356 Yap_InitCPred("creep_allowed", 0, creep_allowed, 0);
357 Yap_InitCPred("$disable_debugging", 0, disable_debugging,
358 NoTracePredFlag | HiddenPredFlag | SafePredFlag);
359}
Yap.h
Main definitions.
pred_entry
Definition: Yatom.h:544
yami
Definition: amidefs.h:264