YAP 7.1.0
All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
userpreds.c
1
2/*************************************************************************
3* *
4* YAP Prolog *
5* *
6* Yap Prolog was developed at NCCUP - Universidade do Porto *
7* *
8* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
9* *
10**************************************************************************
11* *
12* File: userpreds.c *
13* Last rev: *
14* mods: *
15* comments: an entry for user defined predicates *
16* *
17*************************************************************************/
18#ifdef SCCS
19static char SccsId[] = "%W% %G%";
20#endif
21
22/*
23 * This file is an entry for user defined C-predicates.
24 *
25 * There are two sorts of C-Predicates: deterministic - which should be defined
26 * in the function InitUserCPreds().
27 *
28 * backtrackable - they include a start and a continuation function, the first
29 * one called by the first invocation, the last one called after a fail. This
30 * can be seen as: pred :- init ; repeat, cont. These predicates should be
31 * defined in the function InitUserBacks()
32 *
33 * These two functions are called after any "restore" operation.
34 *
35 * The function InitUserExtensions() is called once, when starting the execution
36 * of the program, and should be used to initialize any user-defined
37 * extensions (like the execution environment or interfaces to other
38 * programs).
39 *
40 */
41
42#include "Yap.h"
43#include "Yatom.h"
44#include "YapHeap.h"
45#if EUROTRA
46#include "yapio.h"
47#if HAVE_UNISTD_H
48#include <unistd.h>
49#endif
50#endif
51
52/* You should include here the prototypes for all static functions */
53
54#ifdef EUROTRA
55static int p_clean(void);
56static int p_namelength(void);
57static int p_getpid(void);
58static int p_exit(void);
59static int p_incrcounter(void);
60static int p_setcounter(void);
61static int p_trapsignal(void);
62static int subsumes(Term, Term);
63static int p_subsumes(void);
64static int p_grab_tokens(void);
65#endif
66#ifdef MACYAP
67static typedef int (*SignalProc)();
68static SignalProc skel_signal(int, SignalProc);
69static int chdir(char *);
70#endif
71
72#ifdef SFUNC
73static int p_softfunctor(void);
74#endif /* SFUNC */
75
76#ifdef USERPREDS
77/* These are some examples of user-defined functions */
78
79/*
80 * unify(A,B) --> unification with occurs-check it uses the functions
81 * full_unification and occurs_in
82 *
83 * occurs_check(V,S) :- var(S), !, S \== V. occurs_check(V,S) :- primitive(S),
84 * !. occurs_check(V,[H|T]) :- !, occurs_check(V,H), occurs_check(V,T).
85 * occurs_check(V,St) :- functor(T,_,N), occurs_check_struct(N,V,St).
86 *
87 * occurs_check_struct(1,V,T) :- !, arg(1,T,A), occurs_check(V,A).
88 * occurs_check_struct(N,V,T) :- N1 is N-1, occurs_check_structure(N1,V,T),
89 * arg(N,T,A), occurs_check(V,A).
90 *
91 * unify(X,Y) :- var(X), var(Y), !, X = Y. unify(X,Y) :- var(X), !,
92 * occurs_check(X,Y), X = Y. unify(X,Y) :- var(Y), !, occurs_check(Y,X), X =
93 * Y. unify([H0|T0],[H1|T1]) :- !, unify(H0,H1), unify(T0,T1). unify(X,Y) :-
94 * functor(X,A,N), functor(Y,A,N), unify_structs(N,X,Y).
95 *
96 * unify_structs(1,X,Y) :- !, arg(1,X,A), arg(1,Y,B), unify(A,B).
97 * unify_structs(N,Y,Z) :- N1 is N-1, unify_structs(N1,X,Y), arg(N,X,A),
98 * arg(N,Y,B), unify(A,B).
99 */
100
101/* occurs-in --> checks if the variable V occurs in term S */
102
103static int occurs_check(V, T) Term V, T;
104{
105 /* V and S are always derefed */
106 if (IsVarTerm(T)) {
107 return (V != T);
108 } else if (IsPrimitiveTerm(T)) {
109 return (TRUE);
110 } else if (IsPairTerm(T)) {
111 return (occurs_check(V, HeadOfTerm(T)) && occurs_check(V, TailOfTerm(T)));
112 } else if (IsApplTerm(T)) {
113 unsigned int i;
114 unsigned int arity = ArityOfFunctor(FunctorOfTerm(T));
115
116 for (i = 1; i <= arity; ++i)
117 if (!occurs_check(V, ArgOfTerm(i, T)))
118 return (FALSE);
119 return (TRUE);
120 }
121 return (FALSE);
122}
123
124/*
125 If you worry about coroutining the routine must receive the
126 arguments before dereferencing, otherwise unify() won't be
127 to wake possible bound variables
128*/
129static int full_unification(T1, T2) Term T1, T2;
130{
131 Term t1 = Deref(T1);
132 Term t2 = Deref(T2);
133 if (IsVarTerm(t1)) {/* Testing for variables should be done first */
134 if (IsVarTerm(t2) || IsPrimitiveTerm(t2))
135 return (Yap_unify(T1, t2));
136 if (occurs_check(t1, t2))
137 return (Yap_unify(T1, t2));
138 return (FALSE);
139 }
140 if (IsVarTerm(t2)) {
141 if (occurs_check(t2, t1))
142 return (Yap_unify(T2, t1));
143 return (FALSE);
144 }
145 if (IsPrimitiveTerm(t1)) {
146 if (IsFloatTerm(t1))
147 return (IsFloatTerm(t2) && FloatOfTerm(t1) == FloatOfTerm(t2));
148 else if (IsRefTerm(t1))
149 return (IsRefTerm(t2) && RefOfTerm(t1) == RefOfTerm(t2));
150 if (IsLongIntTerm(t1))
151 return (IsLongIntTerm(t2) && LongIntOfTerm(t1) == LongIntOfTerm(t2));
152 else
153 return (t1 == t2);
154 }
155 if (IsPairTerm(t1)) {
156 if (!IsPairTerm(t2))
157 return (FALSE);
158 return (full_unification(HeadOfTermCell(t1), HeadOfTermCell(t2)) &&
159 full_unification(TailOfTermCell(t1), TailOfTermCell(t2)));
160 }
161 if (IsApplTerm(t1)) {
162 unsigned int i, arity;
163 if (!IsApplTerm(t2))
164 return (FALSE);
165 if (FunctorOfTerm(t1) != FunctorOfTerm(t2))
166 return (FALSE);
167 arity = ArityOfFunctor(FunctorOfTerm(t1));
168 for (i = 1; i <= arity; ++i)
169 if (!full_unification(ArgOfTermCell(i, t1), ArgOfTerm(i, t2)))
170 return (FALSE);
171 return (TRUE);
172 }
173#ifdef lint
174 return (FALSE);
175#endif
176}
177
178static int p_occurs_check() { /* occurs_check(?,?) */
179 return (occurs_check(Deref(ARG1), Deref(DARG2)));
180}
181
182/* Out of date, use unify_with_occurs_check instead*/
183static int p_unify() { /* unify(?,?) */
184 /* routines that perform unification must receive the original arguments */
185 return (full_unification(ARG1, ARG2));
186}
187
188/*
189 * One example of a counter using the atom value functions counter(Atom,M,N)
190 *
191 * If the second argument is uninstantiated, then it will be unified with the
192 * current value of the counter, otherwyse the counter will be set to its
193 * value. The third argument then be unified with the next integer, which
194 * will become the current counter value.
195 */
196static int p_counter() { /* counter(+Atom,?Number,?Next) */
197 Term TCount, TNext, T1, T2;
198 Atom a;
199 /* Int -> an YAP integer */
200 Int val;
201 T1 = Deref(ARG1);
202 ARG2 = Deref(ARG2);
203
204 /* No need to deref ARG3, we don't want to know what's in there */
205 if (IsVarTerm(T1) || !IsAtomTerm(T1))
206 return (FALSE);
207 a = AtomOfTerm(T1);
208 if (IsVarTerm(T2)) {
209 TCount = Yap_GetValue(a);
210 if (!IsIntTerm(TCount))
211 return (FALSE);
212 Yap_unify_constant(ARG2, TCount); /* always succeeds */
213 val = IntOfTerm(TCount);
214 } else {
215 if (!IsIntTerm(T2))
216 return (FALSE);
217 val = IntOfTerm(T2);
218 }
219 val++;
220 /* The atom will now take the incremented value */
221 Yap_PutValue(a, TNext = MkIntTerm(val));
222 return (Yap_unify_constant(ARG3, TNext));
223}
224
225/*
226 * Concatenate an instantiated list to another list, and unify with third
227 * argument
228 */
229
230/*
231 * In order to be more efficient, iconcat instead of unifying the terms in
232 * the old structure with the ones in the new one just copies them. This is a
233 * dangerous behaviour, though acceptable in this case, and you should try to
234 * avoid it whenever possible
235 */
236#ifdef COMMENT
237static int p_iconcat() { /* iconcat(+L1,+L2,-L) */
238 Term Tkeep[1025]; /* Will do it just for lists less
239 * than 1024 elements long */
240 register Term *Tkp = Tkeep;
241 register Term L0, L1;
242 Term T2;
243
244 L0 = Deref(ARG1);
245 *Tkp++ = Unsigned(0);
246 L1 = TermNil;
247 while (L0 != L1) {
248 /*
249 * Usually you should test if L1 a var, if (!IsPairTerm(L0))
250 * return(FALSE);
251 */
252 *Tkp++ = HeadOfTerm(L0);
253 L0 = TailOfTerm(L0);
254 }
255 L1 = Deref(ARG2);
256 while (L0 = *--Tkp)
257 L1 = MkPairTerm(L0, L1);
258 T2 = L1;
259 return (Yap_unify(T2, ARG3));
260}
261#endif /* COMMENT */
262
263static int p_iconcat() { /* iconcat(+L1,+L2,-L) */
264 register Term *Tkp = H, *tp;
265 register Term L0, L1;
266 Term T2;
267
268 L0 = Deref(ARG1);
269 L1 = TermNil;
270 while (L0 != L1) {
271 /* if (!IsPairTerm(L0)) return(FALSE); */
272 tp = Tkp;
273 *tp = AbsPair(++Tkp);
274 *Tkp++ = HeadOfTerm(L0);
275 L0 = TailOfTerm(L0);
276 }
277 *Tkp++ = Deref(ARG2);
278 T2 = *H;
279 H = Tkp;
280 return (Yap_unify(T2, ARG3));
281}
282
283#endif /* USERPREDS */
284
285#ifdef EUROTRA
286
287static int p_clean() /* predicate clean for ets */
288 /*
289 * clean(FB,CFB) :- FB =.. [fb|L],!, clean1(L,CL), CFB =.. [fb|CL].
290 * clean(FB,CFB) :- var(FB).
291 *
292 * clean1([],[]) :- !. clean1([H|T],[CH|CT]) :- H==$u,!, clean1(T,CT).
293 * clean1([H|T],[H|CT]) :- clean1(T,CT).
294 */
295{
296 unsigned int arity, i;
297 Term t, Args[255];
298 Term t1 = Deref(ARG1);
299
300 if (IsVarTerm(t1))
301 return (TRUE);
302 if (!(IsApplTerm(t1) && NameOfFunctor(FunctorOfTerm(t1)) == AtomFB))
303 return (FALSE);
304 arity = ArityOfFunctor(FunctorOfTerm(t1));
305#ifdef SFUNC
306 if (arity == SFArity) {
307 CELL *pt = H, *ntp = ArgsOfSFTerm(t1);
308 Term tn = AbsAppl(H);
309 *pt++ = FunctorOfTerm(t1);
310 RESET_VARIABLE(pt);
311 pt++;
312 while (*pt++ = *ntp++)
313 if ((*pt++ = *ntp++) == MkAtomTerm(AtomDollarUndef))
314 pt -= 2;
315 H = pt;
316 return (Yap_unify(tn, ARG2));
317 }
318#endif
319 for (i = 1; i <= arity; ++i) {
320 if ((t = ArgOfTerm(i, t1)) == TermDollarU)
321 t = MkVarTerm();
322 Args[i - 1] = t;
323 }
324 t = Yap_MkApplTerm(FunctorOfTerm(t1), arity, Args);
325 return (Yap_unify(ARG2, t));
326}
327
328static Term *subs_table;
329static int subs_entries;
330#define SUBS_TABLE_SIZE 500
331
332static int subsumes(T1, T2) Term T1, T2;
333{
334 int i;
335
336 if (IsVarTerm(T1)) {
337 if (!IsVarTerm(T2))
338 return (FALSE);
339 if (T1 == T2)
340 return (TRUE);
341 for (i = 0; i < subs_entries; ++i)
342 if (subs_table[i] == T2)
343 return (FALSE);
344 if (T2 < T1) {/* T1 gets instantiated with T2 */
345 Yap_unify(T1, T2);
346 for (i = 0; i < subs_entries; ++i)
347 if (subs_table[i] == T1) {
348 subs_table[i] = T2;
349 return (TRUE);
350 }
351 subs_table[subs_entries++] = T2;
352 return (TRUE);
353 }
354 /* T2 gets instantiated with T1 */
355 Yap_unify(T1, T2);
356 for (i = 0; i < subs_entries; ++i)
357 if (subs_table[i] == T1)
358 return (TRUE);
359 subs_table[subs_entries++] = T1;
360 return (TRUE);
361 }
362 if (IsVarTerm(T2)) {
363 for (i = 0; i < subs_entries; ++i)
364 if (subs_table[i] == T2)
365 return (FALSE);
366 return (Yap_unify(T1, T2));
367 }
368 if (IsPrimitiveTerm(T1)) {
369 if (IsFloatTerm(T1))
370 return (IsFloatTerm(T2) && FloatOfTerm(T1) == FloatOfTerm(T2));
371 else if (IsRefTerm(T1))
372 return (IsRefTerm(T2) && RefOfTerm(T1) == RefOfTerm(T2));
373 else if (IsLongIntTerm(T1))
374 return (IsLongIntTerm(T2) && LongIntOfTerm(T1) == LongIntOfTerm(T2));
375 else
376 return (T1 == T2);
377 }
378 if (IsPairTerm(T1)) {
379 if (!IsPairTerm(T2))
380 return (FALSE);
381 return (subsumes(HeadOfTerm(T1), HeadOfTerm(T2)) &&
382 subsumes(TailOfTerm(T1), TailOfTerm(T2)));
383 }
384 if (IsApplTerm(T1)) {
385 int arity;
386 if (!IsApplTerm(T2))
387 return (FALSE);
388 if (FunctorOfTerm(T1) != FunctorOfTerm(T2))
389 return (FALSE);
390 arity = ArityOfFunctor(FunctorOfTerm(T1));
391#ifdef SFUNC
392 if (arity == SFArity) {
393 CELL *a1a = ArgsOfSFTerm(T1), *a2a = ArgsOfSFTerm(T2);
394 CELL *a1p = a1a - 1, *a2p = a2a - 1;
395 CELL *pt = H;
396 int flags = 0;
397 Term t1, t2;
398 *pt++ = FunctorOfTerm(T1);
399 RESET_VARIABLE(pt);
400 pt++;
401 while (1) {
402 if (*a2a < *a1a || *a1a == 0) {
403 if (*a2a) {
404 *pt++ = *a2a++;
405 t2 = Derefa(a2a);
406 ++a2a;
407 if (!IsVarTerm(t2))
408 return (FALSE);
409 for (i = 0; i < subs_entries; ++i)
410 if (subs_table[i] == t2)
411 return (FALSE);
412 subs_table[subs_entries++] = t2;
413 *pt++ = t2;
414 flags |= 1;
415 } else { /* T2 is finished */
416 if ((flags & 1) == 0) {/* containned in first */
417 *a2p = Unsigned(a1p - 1);
418 if (a2p < HB)
419 *TR++ = Unsigned(a2p);
420 return (TRUE);
421 }
422 while ((*pt++ = *a1a++))
423 ;
424 *a1p = Unsigned(H);
425 if (a1p < HB)
426 *TR++ = Unsigned(a1p);
427 *a2p = Unsigned(H);
428 if (a2p < HB)
429 *TR++ = Unsigned(a2p);
430 H = pt;
431 return (TRUE);
432 }
433 } else if (*a2a > *a1a || *a2a == 0) {
434 *pt++ = *a1a++;
435 t1 = Derefa(a1a);
436 ++a1a;
437 if (IsVarTerm(t1)) {
438 for (i = 0; i < subs_entries; ++i)
439 if (subs_table[i] == t1)
440 break;
441 if (i >= subs_entries)
442 subs_table[subs_entries++] = t1;
443 }
444 *pt++ = t1;
445 flags |= 2;
446 } else if (*a1a == *a2a) {
447 *pt++ = *a1a++;
448 ++a2a;
449 t1 = Derefa(a1a);
450 ++a1a;
451 t2 = Derefa(a2a);
452 ++a2a;
453 *pt++ = t1;
454 if (!subsumes(t1, t2))
455 return (FALSE);
456 }
457 }
458 }
459#endif
460 for (i = 1; i <= arity; ++i)
461 if (!subsumes(ArgOfTerm(i, T1), ArgOfTerm(i, T2)))
462 return (FALSE);
463 return (TRUE);
464 }
465 return (FALSE);
466}
467
468static int p_subsumes() {
469 Term work_space[SUBS_TABLE_SIZE];
470 subs_table = work_space;
471 subs_entries = 0;
472 return (subsumes(Deref(ARG1), Deref(ARG2)));
473}
474
475static int p_namelength() {
476 register Term t = Deref(ARG1);
477 Term tf;
478
479 if (IsVarTerm(t)) {
480 return (FALSE);
481 }
482 if (IsAtomTerm(t)) {
483 Term tf = MkIntTerm(strlen(RepAtom(AtomOfTerm(t))->StrOfAE));
484 return (Yap_unify_constant(ARG2, tf));
485 } else if (IsIntTerm(t)) {
486 register int i = 1, k = IntOfTerm(t);
487 if (k < 0)
488 ++i, k = -k;
489 while (k > 10)
490 ++i, k /= 10;
491 tf = MkIntTerm(i);
492 return (Yap_unify_constant(ARG2, tf));
493 } else
494 return (FALSE);
495}
496
497static int p_getpid() {
498#ifndef MPW
499 Term t = MkIntTerm(getpid());
500#else
501 Term t = MkIntTerm(1);
502#endif
503 return (Yap_unify_constant(ARG1, t));
504}
505
506static int p_exit() {
507 register Term t = Deref(ARG1);
508 if (IsVarTerm(t) || !IsIntTerm(t))
509 return (FALSE);
510 Yap_exit((int)IntOfTerm(t));
511 return (FALSE);
512}
513
514static int current_pos;
515
516static int p_incrcounter() {
517 register Term t = Deref(ARG1);
518 if (IsVarTerm(t) || !IsIntTerm(t))
519 return (FALSE);
520 current_pos += IntOfTerm(t);
521 return (TRUE);
522}
523
524static int p_setcounter() {
525 register Term t = Deref(ARG1);
526 if (IsVarTerm(t) || !IsIntTerm(t)) {
527 return (Yap_unify_constant(ARG1, MkIntTerm(current_pos)));
528 } else {
529 current_pos = IntOfTerm(t);
530 return (TRUE);
531 }
532}
533
534#include <signal.h>
535#ifdef MACYAP
536#define signal(A, B) skel_signal(A, B)
537#endif
538
539#ifndef EOF
540#define EOF -1
541#endif
542
543static int p_trapsignal(void) {
544#ifndef MPW
545 signal(SIGINT, SIG_IGN);
546#endif
547 return (TRUE);
548}
549
550#define varstarter(ch) ((ch >= 'A' && ch <= 'Z') || ch == '_')
551#define idstarter(ch) (ch >= 'a' && ch <= 'z')
552#define idchar(ch) \
553 ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || \
554 (ch >= 'a' && ch <= 'z') || ch == '_')
555
556static int p_grab_tokens() {
557 Term *p = ASP - 20, *p0, t;
558 Functor IdFunctor, VarFunctor;
559 char ch, IdChars[256], *chp;
560
561 IdFunctor = FunctorId;
562 VarFunctor = FunctorDollarVar;
563 p0 = p;
564 ch = Yap_PlGetchar();
565 while (1) {
566 while (ch <= ' ' && ch != EOF)
567 ch = Yap_PlGetchar();
568 if (ch == '.' || ch == EOF)
569 break;
570 if (ch == '%') {
571 while ((ch = Yap_PlGetchar()) != 10)
572 ;
573 ch = Yap_PlGetchar();
574 continue;
575 }
576 if (ch == '\'') {
577 chp = IdChars;
578 while (1) {
579 ch = Yap_PlGetchar();
580 if (ch == '\'')
581 break;
582 *chp++ = ch;
583 }
584 *chp = 0;
585 t = MkAtomTerm(Yap_LookupAtom(IdChars));
586 *p-- = Yap_MkApplTerm(IdFunctor, 1, &t);
587 ch = Yap_PlGetchar();
588 continue;
589 }
590 if (varstarter(ch)) {
591 chp = IdChars;
592 *chp++ = ch;
593 while (1) {
594 ch = Yap_PlGetchar();
595 if (!idchar(ch))
596 break;
597 *chp++ = ch;
598 }
599 *chp = 0;
600 t = MkAtomTerm(Yap_LookupAtom(IdChars));
601 *p-- = Yap_MkApplTerm(VarFunctor, 1, &t);
602 continue;
603 }
604 if (idstarter(ch)) {
605 chp = IdChars;
606 *chp++ = ch;
607 while (1) {
608 ch = Yap_PlGetchar();
609 if (!idchar(ch))
610 break;
611 *chp++ = ch;
612 }
613 *chp = 0;
614 t = MkAtomTerm(Yap_LookupAtom(IdChars));
615 *p-- = Yap_MkApplTerm(IdFunctor, 1, &t);
616 continue;
617 }
618 IdChars[0] = ch;
619 IdChars[1] = 0;
620 *p-- = MkAtomTerm(Yap_LookupAtom(IdChars));
621 ch = Yap_PlGetchar();
622 }
623 t = MkAtomTerm(AtomNil);
624 while (p != p0) {
625 t = MkPairTerm(*++p, t);
626 }
627 return (Yap_unify(ARG1, t));
628}
629
630#endif /* EUROTRA */
631
632#ifdef SFUNC
633
634static p_softfunctor() {
635 Term nilvalue = 0;
636 SFEntry *pe;
637 Prop p0;
638 Atom a;
639 Term t1 = Deref(ARG1);
640 Term t2 = Deref(ARG2);
641
642 if (IsAtomTerm(t2))
643 nilvalue = t2;
644 if (!IsAtomTerm(t1))
645 return (FALSE);
646 a = AtomOfTerm(t1);
647 WRITE_LOCK(RepAtom(a)->ARWLock);
648 if ((p0 = Yap_GetAProp(a, SFProperty)) == NIL) {
649 pe = (SFEntry *)Yap_AllocAtomSpace(sizeof(*pe));
650 pe->KindOfPE = SFProperty;
651 AddPropToAtom(RepAtom(a), (PropEntry *)pe);
652 } else
653 pe = RepSFProp(p0);
654 WRITE_UNLOCK(RepAtom(a)->ARWLock);
655 pe->NilValue = nilvalue;
656 return (TRUE);
657}
658
659#endif /* SFUNC */
660
661#include <math.h>
662
663/*
664static Int
665p_matching_distances(void)
666{
667 return(fabs(FloatOfTerm(Deref(ARG1))-FloatOfTerm(Deref(ARG2))) <=
668FloatOfTerm(Deref(ARG3)));
669}
670*/
671
672void Yap_InitUserCPreds(void) {
673#ifdef XINTERFACE
674 Yap_InitXPreds();
675#endif
676#ifdef EUROTRA
677 Yap_InitCPred("clean", 2, p_clean, SafePredFlag | SyncPredFlag);
678 Yap_InitCPred("name_length", 2, p_namelength, SafePredFlag | SyncPredFlag);
679 Yap_InitCPred("get_pid", 1, p_getpid, SafePredFlag);
680 Yap_InitCPred("exit", 1, p_exit, SafePredFlag | SyncPredFlag);
681 Yap_InitCPred("incr_counter", 1, p_incrcounter, SafePredFlag | SyncPredFlag);
682 Yap_InitCPred("set_counter", 1, p_setcounter, SafePredFlag | SyncPredFlag);
683 Yap_InitCPred("trap_signal", 0, p_trapsignal, SafePredFlag | SyncPredFlag);
684 Yap_InitCPred("mark2_grab_tokens", 1, p_grab_tokens,
685 SafePredFlag | SyncPredFlag);
686 Yap_InitCPred("subsumes", 2, p_subsumes, SafePredFlag);
687#endif
688#ifdef SFUNC
689 Yap_InitCPred("sparse_functor", 2, p_softfunctor, SafePredFlag);
690#endif /* SFUNC */
691 /* Yap_InitCPred("match_distances", 3, p_matching_distances, SafePredFlag);
692 */
693 /* Yap_InitCPred("unify",2,p_unify,SafePredFlag); */
694 /* Yap_InitCPred("occurs_check",2,p_occurs_check,SafePredFlag); */
695 /* Yap_InitCPred("counter",3,p_counter,SafePredFlag); */
696 /* Yap_InitCPred("iconcat",3,p_iconcat,SafePredFlag); */
697}
698
699void Yap_InitUserBacks(void) {}
Main definitions.
@ occurs_check
module_independent_operators
Definition: YapGFlagInfo.h:430
If you like being short, use T instead of YapTerm.
Definition: yapt.hh:266