YAP 7.1.0
writeterm.c
Go to the documentation of this file.
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: iopreds.c *
12 * Last rev: 5/2/88 *
13 * mods: *
14 * comments: Input/Output C implemented predicates *
15 * *
16 *************************************************************************/
17#ifdef SCCS
18static char SccsId[] = "%W% %G%";
19#endif
20
36#include "Yap.h"
37#include "YapEval.h"
38#include "YapHeap.h"
39#include "YapText.h"
40#include "Yatom.h"
41#include "yapio.h"
42#include <stdlib.h>
43#if HAVE_STDARG_H
44#include <stdarg.h>
45#endif
46#if HAVE_CTYPE_H
47#include <ctype.h>
48#endif
49#if HAVE_WCTYPE_H
50#include <wctype.h>
51#endif
52#if HAVE_SYS_TIME_H
53#include <sys/time.h>
54#endif
55#if HAVE_SYS_TYPES_H
56#include <sys/types.h>
57#endif
58#ifdef HAVE_SYS_STAT_H
59#include <sys/stat.h>
60#endif
61#if HAVE_SYS_SELECT_H && !_MSC_VER && !defined(__MINGW32__)
62#include <sys/select.h>
63#endif
64#ifdef HAVE_UNISTD_H
65#include <unistd.h>
66#endif
67#if HAVE_STRING_H
68#include <string.h>
69#endif
70#if HAVE_SIGNAL_H
71#include <signal.h>
72#endif
73#if HAVE_FCNTL_H
74/* for O_BINARY and O_TEXT in WIN32 */
75#include <fcntl.h>
76#endif
77#ifdef _WIN32
78#if HAVE_IO_H
79/* Windows */
80#include <io.h>
81#endif
82#endif
83#if !HAVE_STRNCAT
84#define strncat(X, Y, Z) strcat(X, Y)
85#endif
86#if !HAVE_STRNCPY
87#define strncpy(X, Y, Z) strcpy(X, Y)
88#endif
89#if _MSC_VER || defined(__MINGW32__)
90#if HAVE_SOCKET
91#include <winsock2.h>
92#endif
93#include <windows.h>
94#ifndef S_ISDIR
95#define S_ISDIR(x) (((x)&_S_IFDIR) == _S_IFDIR)
96#endif
97#endif
98#include "iopreds.h"
99#include "clause.h"
100
101static yap_error_number bind_variable_names(Term t USES_REGS) {
102 while (!IsVarTerm(t) && IsPairTerm(t)) {
103 Term th = HeadOfTerm(t);
104 Functor f;
105 Term t2, t1;
106
107 if (!IsApplTerm(th))
108 return FALSE;
109 if ((f = FunctorOfTerm(th)) != FunctorEq) {
110 return false;
111 }
112 t1 = ArgOfTerm(1, th);
113 if (IsVarTerm(t1)) {
114 Yap_ThrowError(INSTANTIATION_ERROR, t1, "variable_names");
115 return false;
116 }
117 t2 = ArgOfTerm(2, th);
118 if (IsVarTerm(t2)) {
119 Term nt2 = Yap_MkApplTerm(FunctorDollarVar, 1, &t1);
120 if (ASP < HR+1024)
121 return RESOURCE_ERROR_STACK;
122
123 YapBind(VarOfTerm(t2), nt2);
124
125 }
126 t = TailOfTerm(t);
127 }
128 return YAP_NO_ERROR;
129}
130
131static Term readFromBuffer(const char *s, Term opts) {
132 Term rval;
133 int sno;
134 encoding_t enc = ENC_ISO_UTF8;
135 sno = Yap_open_buf_read_stream( NULL,
136 (char *)s, strlen_utf8((unsigned char *)s), &enc, MEM_BUF_USER,
137 Yap_LookupAtom(Yap_StrPrefix((char *)s, 16)), TermNone);
138
139 rval = Yap_read_term(sno, opts, 3);
140 Yap_CloseStream(sno);
141 return rval;
142}
143
144#if _MSC_VER || defined(__MINGW32__)
145#define SYSTEM_STAT _stat
146#else
147#define SYSTEM_STAT stat
148#endif
149
150static bool write_term(int output_stream, Term t, bool b, yap_error_number *errp, xarg *args USES_REGS) {
151 bool rc;
152 Term cm = CurrentModule;
153 if (t==0) {
154 return false;
155 }
156 yhandle_t ynames = 0;
157 int depth, flags = 0;
158
159 t = Deref(t);
160 HB = HR;
161 *errp = YAP_NO_ERROR;
162 if (args[WRITE_VARIABLE_NAMES].used ||
163 args[WRITE_SINGLETONS].used ||
164 args[WRITE_CYCLES].used
165 ) {
166 Term l = TermNil, *lp;
167 if (!args[WRITE_CYCLES].used || (args[WRITE_CYCLES].used
168 && args[WRITE_CYCLES].tvalue == TermTrue)) {
169 flags |= Handle_cyclics_f;
170 lp = &l;
171 } else{
172 lp = NULL;
173 }
174 Term t1 = CopyTermToArena(t, false, false, errp, NULL, lp PASS_REGS);
175 if (*errp) {
176 return false;
177 }
178 t = t1;
179 if (args[WRITE_VARIABLE_NAMES].used) {
180 Term tnames;
181 if (!ynames) {
182 tnames = args[WRITE_VARIABLE_NAMES].tvalue;
183 ynames = Yap_InitHandle(tnames);
184 } else{
185 tnames = Yap_GetFromHandle(ynames);
186 }
187 if ((*errp = bind_variable_names(tnames PASS_REGS))==YAP_NO_ERROR) {
188 flags |= Named_vars_f;
189 } else {
190 return false;
191 }
192 }
193
194 if (args[WRITE_SINGLETONS].used) {
195 if (Yap_NumberVars(t,0,true PASS_REGS) < 0) {
196 *errp = RESOURCE_ERROR_STACK;
197 return false;
198 }
199 flags |= Singleton_vars_f;
200 }
201 }
202 if (args[WRITE_ATTRIBUTES].used) {
203 Term ctl = args[WRITE_ATTRIBUTES].tvalue;
204 if (ctl == TermWrite) {
205 flags |= AttVar_None_f;
206 } else if (ctl == TermPortray) {
207 flags |= AttVar_None_f | AttVar_Portray_f;
208 } else if (ctl == TermDots) {
209 flags |= AttVar_Dots_f;
210 } else if (ctl != TermIgnore) {
211 Yap_ThrowError(
212 DOMAIN_ERROR_WRITE_OPTION, ctl,
213 "write attributes should be one of {dots,ignore,portray,write}");
214 rc = false;
215 goto end;
216 }
217 }
218 if (args[WRITE_NUMBERVARS].used) {
219 if (args[WRITE_NUMBERVARS].tvalue == TermTrue) {
220 flags |= Handle_vars_f;
221 }
222 } else {
223 flags |= Handle_vars_f;
224 }
225
226 if (args[WRITE_QUOTED].used && args[WRITE_QUOTED].tvalue == TermTrue) {
227 flags |= Quote_illegal_f;
228 }
229 if (args[WRITE_IGNORE_OPS].used &&
230 args[WRITE_IGNORE_OPS].tvalue == TermTrue) {
231 flags |= Ignore_ops_f;
232 }
233 if (args[WRITE_PORTRAY].used && args[WRITE_IGNORE_OPS].tvalue == TermTrue) {
234 flags |= Ignore_ops_f;
235 }
236 if (args[WRITE_PORTRAYED].used && args[WRITE_PORTRAYED].tvalue == TermTrue) {
237 flags |= Use_portray_f;
238 }
239 if (args[WRITE_CHARACTER_ESCAPES].used &&
240 args[WRITE_CHARACTER_ESCAPES].tvalue == TermFalse) {
241 flags |= No_Escapes_f;
242 }
243 if (args[WRITE_BACKQUOTES].used &&
244 args[WRITE_BACKQUOTES].tvalue == TermTrue) {
245 flags |= BackQuote_String_f;
246 }
247 if (args[WRITE_BRACE_TERMS].used &&
248 args[WRITE_BRACE_TERMS].tvalue == TermFalse) {
249 flags |= No_Brace_Terms_f;
250 }
251 if (args[WRITE_FULLSTOP].used && args[WRITE_FULLSTOP].tvalue == TermTrue) {
252 flags |= Fullstop_f;
253 }
254 if (args[WRITE_NL].used && args[WRITE_NL].tvalue == TermTrue) {
255 flags |= New_Line_f;
256 }
257
258 if (args[WRITE_MAX_DEPTH].used) {
259 depth = IntegerOfTerm(args[WRITE_MAX_DEPTH].tvalue);
260 } else
261 depth = LOCAL_max_depth;
262 Yap_plwrite(t, GLOBAL_Stream + output_stream, depth,HR, flags, args)
263 ;
264 UNLOCK(GLOBAL_Stream[output_stream].streamlock);
265 rc = true;
266end:
267 CurrentModule = cm;
268 return rc;
269}
270
271
272#undef PAR
273
274#define PAR(x, y, z) \
275 { x, y, z }
276
277static const param_t write_defs[] = {WRITE_DEFS()};
278#undef PAR
279
283bool Yap_WriteTerm(int output_stream, Term t, Term opts USES_REGS) {
284 yap_error_number err = YAP_NO_ERROR;
285 int lvl = push_text_stack();
286 xarg *args = NULL;
287 yhandle_t y0 = Yap_StartHandles(),
288 ylow = Yap_InitHandle(MkVarTerm()),
289 yt = Yap_InitHandle(t),
290 yargs = Yap_InitHandle(opts);
291 int mytr = TR-B->cp_tr;
292 LOCK(GLOBAL_Stream[output_stream].streamlock);
293 while (true) {
294 if (err != YAP_NO_ERROR) {
295 HR = VarOfTerm(Yap_GetFromHandle(ylow));
296 HB = B->cp_h;
297 clean_tr(B->cp_tr+mytr PASS_REGS);
298 Yap_CloseHandles(y0);
299
300 if (err == RESOURCE_ERROR_TRAIL) {
301
302 if (!Yap_growtrail(0, false)) {
303 Yap_ThrowError(RESOURCE_ERROR_TRAIL, TermNil, "while visiting terms");
304 }
305 } else if (err == RESOURCE_ERROR_STACK) {
306 // printf("In H0=%p Hb=%ld H=%ld G0=%ld GF=%ld ASP=%ld\n",H0, cs->oHB-H0,
307 // cs->oH-H0, ArenaPt(*arenap)-H0,ArenaLimit(*arenap)-H0,(LCL0-cs->oASP)-H0) ;
308 if (!Yap_dogcl(0)) {
309 Yap_ThrowError(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
310 }
311 // printf("In H0=%p Hb=%ld H=%ld G0=%ld GF=%ld ASP=%ld\n",H0, cs->oHB-H0,
312 // cs->oH-H0, ArenaPt(*arenap)-H0,ArenaLimit(*arenap)-H0,LCL0-cs->oASP-H0) ;
313 }
314 t = Yap_GetFromHandle(yt);
315 opts = Yap_GetFromHandle(yargs);
316 }
317 args = Yap_ArgListToVector(opts, write_defs, WRITE_END,NULL,
318 DOMAIN_ERROR_WRITE_OPTION);
319 if (args == NULL) {
320 return false;
321 }
322 bool o = write_term(output_stream, t, false,&err, args PASS_REGS);
323 if (args) free(args);
324 if (o) break;
325 }
326 HB = B->cp_h;
327 clean_tr(B->cp_tr+mytr PASS_REGS);
328 Yap_CloseHandles(y0);
329 UNLOCK(GLOBAL_Stream[output_stream].streamlock);
330 Yap_CloseHandles(y0);
331 pop_text_stack(lvl);
332 return true;
333}
334
378static Int write_term2(USES_REGS1) {
379
380 /* '$write'(+Flags,?Term) */
381 /* notice: we must have ASP well set when using portray, otherwise
382 we cannot make recursive Prolog calls */
383 return Yap_WriteTerm(LOCAL_c_output_stream, ARG1, ARG2 PASS_REGS);
384}
385
393static Int write_term3(USES_REGS1) {
394
395 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
396 if (output_stream < 0) {
397 return false;
398 }
399 return Yap_WriteTerm(output_stream, ARG2, ARG3 PASS_REGS);
400}
401
409static Int write2(USES_REGS1) {
410
411 /* notice: we must have ASP well set when using portray, otherwise
412 we cannot make recursive Prolog calls */
413
414 Term t = TermTrue;
415 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
416 if (output_stream < 0)
417 return false;
418 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorSingletons,1,&t), TermNil);
419 return Yap_WriteTerm(output_stream, ARG2, opts PASS_REGS);
420}
421
422
430static Int write1(USES_REGS1) {
431
432 Term t = TermTrue;
433 int output_stream = LOCAL_c_output_stream;
434 if (output_stream == -1)
435 output_stream = 1;
436 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorSingletons,1,&t), TermNil);
437 return Yap_WriteTerm(output_stream, ARG1, opts PASS_REGS);
438}
439
447static Int write_canonical1(USES_REGS1) {
448
449 Term t = TermTrue;
450 Term nv = getAtomicLocalPrologFlag(NUMBERVARS_FUNCTOR_FLAG);
451 setAtomicLocalPrologFlag(NUMBERVARS_FUNCTOR_FLAG,TermDollarUVar);
452 int output_stream = LOCAL_c_output_stream;
453 if (output_stream == -1)
454 output_stream = 1;
455 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorSingletons,1,&t),
456 MkPairTerm(Yap_MkApplTerm(FunctorIgnoreOps,1,&t),
457 MkPairTerm(Yap_MkApplTerm(FunctorQuoted,1,&t),
458 MkPairTerm(Yap_MkApplTerm(FunctorCycles,1,&t),
459 TermNil))));
460 Int f = Yap_WriteTerm(output_stream, ARG1, opts PASS_REGS);
461 setAtomicLocalPrologFlag(NUMBERVARS_FUNCTOR_FLAG,nv);
462 return f;
463
464}
465
473static Int write_canonical(USES_REGS1) {
474 Term t = TermTrue;
475 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
476 if (output_stream < 0) {
477 return false;
478 }
479 Term nv = getAtomicLocalPrologFlag(NUMBERVARS_FUNCTOR_FLAG);
480 setAtomicLocalPrologFlag(NUMBERVARS_FUNCTOR_FLAG,TermDollarUVar);
481 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorSingletons,1,&t),
482 MkPairTerm(Yap_MkApplTerm(FunctorIgnoreOps,1,&t),
483 MkPairTerm(Yap_MkApplTerm(FunctorNumberVars,1,&t),
484 MkPairTerm(Yap_MkApplTerm(FunctorQuoted,1,&t),
485 MkPairTerm(Yap_MkApplTerm(FunctorCycles,1,&t),
486 TermNil)))));
487 Int f = Yap_WriteTerm(output_stream, ARG2, opts PASS_REGS);
488 setAtomicLocalPrologFlag(NUMBERVARS_FUNCTOR_FLAG,nv);
489 return f;
490}
491
492static Int writeq1(USES_REGS1) {
493
494 Term t = TermTrue;
495 int output_stream = LOCAL_c_output_stream;
496 if (output_stream == -1)
497 output_stream = 1;
498 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorQuoted,1,&t),
499 TermNil);
500 return Yap_WriteTerm(output_stream, ARG1, opts PASS_REGS);
501}
502
509static Int writeq(USES_REGS1) {
510
511 Term t = TermTrue;
512 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
513 if (output_stream < 0) {
514 return false;
515 }
516 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorQuoted,1,&t),
517 MkPairTerm(Yap_MkApplTerm(FunctorNumberVars,1,&t),
518 TermNil));
519 return Yap_WriteTerm(output_stream, ARG2, opts PASS_REGS);
520}
521
522static Int print1(USES_REGS1) {
523 Term t = TermTrue;
524 int output_stream = LOCAL_c_output_stream;
525 if (output_stream == -1)
526 output_stream = 1;
527 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorPortray,1,&t),
528 MkPairTerm(Yap_MkApplTerm(FunctorNumberVars,1,&t),
529 TermNil));
530 return Yap_WriteTerm(output_stream, ARG1, opts PASS_REGS);
531}
532
540static Int print(USES_REGS1) {
541 Term t = TermTrue;
542 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
543 if (output_stream < 0) {
544 return false;
545 }
546 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorPortray,1,&t),
547 MkPairTerm(Yap_MkApplTerm(FunctorNumberVars,1,&t),
548 TermNil));
549 return Yap_WriteTerm(output_stream, ARG2, opts PASS_REGS);
550}
551
560static Int display1(USES_REGS1) {
561 Term t = TermTrue;
562 int output_stream = LOCAL_c_output_stream;
563 if (output_stream == -1)
564 output_stream = 1;
565 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorIgnoreOps,1,&t),TermNil);
566 return Yap_WriteTerm(output_stream, ARG1, opts PASS_REGS);
567}
568
575static Int display(USES_REGS1) {
576 Term t = TermTrue;
577 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "writeln/2");
578 if (output_stream < 0) {
579 return false;
580 }
581 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorIgnoreOps,1,&t),TermNil);
582 return Yap_WriteTerm(output_stream, ARG2, opts PASS_REGS);
583}
584
585
586static Int writeln1(USES_REGS1) {
587 Term t = TermTrue;
588 int output_stream = LOCAL_c_output_stream;
589 if (output_stream == -1)
590 output_stream = 1;
591 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorNl,1,&t),
592 MkPairTerm(Yap_MkApplTerm(FunctorNumberVars,1,&t),
593 MkPairTerm(Yap_MkApplTerm(FunctorCycles,1,&t),
594 TermNil)));
595 return Yap_WriteTerm(output_stream, ARG1, opts PASS_REGS);
596}
597
598static Int writeln(USES_REGS1) {
599 Term t = TermTrue;
600 int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "writeln/2");
601 if (output_stream < 0) {
602 return false;
603 }
604 Term opts = MkPairTerm(Yap_MkApplTerm(FunctorNl,1,&t),
605
606 MkPairTerm(Yap_MkApplTerm(FunctorNumberVars,1,&t),
607 MkPairTerm(Yap_MkApplTerm(FunctorCycles,1,&t),
608 TermNil)));
609 return Yap_WriteTerm(output_stream, ARG2, opts PASS_REGS);
610}
611
612static Int p_write_depth(USES_REGS1) { /* write_depth(Old,New) */
613 Term t1 = Deref(ARG1);
614 Term t2 = Deref(ARG2);
615 Term t3 = Deref(ARG3);
616
617 if (!IsVarTerm(t1) && !IsIntegerTerm(t1)) {
618 Yap_ThrowError(TYPE_ERROR_INTEGER, t1, "write_depth/3");
619 return FALSE;
620 }
621 if (!IsVarTerm(t2)) {
622 Term t = MkIntegerTerm(LOCAL_max_list);
623 if (!Yap_unify_constant(t2, t))
624 return FALSE;
625 } else
626 LOCAL_max_list = IntegerOfTerm(t2);
627 if (IsVarTerm(t3)) {
628 Term t = MkIntegerTerm(LOCAL_max_write_args);
629 if (!Yap_unify_constant(t3, t))
630 return FALSE;
631 } else
632 LOCAL_max_write_args = IntegerOfTerm(t3);
633 return TRUE;
634}
635
636static Int dollar_var(USES_REGS1) {
637 Term t2;
638
639
640 Term tv = Yap_MkNewApplTerm(FunctorDollarVar, 1);
641 if(!Yap_unify(tv, ARG1)) return false;
642 if (!IsVarTerm((t2 = Deref(ARG2)))) {
643 if (IsApplTerm(t2) && ArityOfFunctor(FunctorOfTerm(t2)) == 1) {
644 FunctorDollarVar= FunctorOfTerm(t2);
645 return true;
646 }
647 Yap_ThrowError(TYPE_ERROR_COMPOUND, ARG2, "");
648 return false;
649 } else {
650 Yap_ThrowError(INSTANTIATION_ERROR, ARG2, "");
651 }
652 return true;
653}
654
655
656
657static Int term_to_string(USES_REGS1) {
658 Term t2 = Deref(ARG2), t1 = Deref(ARG1);
659 const char *s;
660 if (IsVarTerm(t2)) {
661 s = Yap_TermToBuffer(t1, Quote_illegal_f | Handle_vars_f);
662 if (!s || !MkStringTerm(s)) {
663 Yap_ThrowError(RESOURCE_ERROR_HEAP, t1,
664 "Could not get memory from the operating system");
665 return false;
666 }
667 return Yap_unify(ARG2, MkStringTerm(s));
668 } else if (!IsStringTerm(t2)) {
669 Yap_ThrowError(TYPE_ERROR_STRING, t2, "term_to_string/3");
670 return false;
671 } else {
672 s = StringOfTerm(t2);
673 }
674 yhandle_t y0 = Yap_StartHandles();
675 yhandle_t y1 = Yap_InitHandle( t1 );
676 Term tf = readFromBuffer(s, TermNil);
677 Int rc = Yap_unify(tf, Yap_PopHandle(y1));
678 Yap_CloseHandles(y0);
679 return rc;
680}
681
686static Int term_to_atom(USES_REGS1) {
687 Term t2 = Deref(ARG2), ctl, rc = false;
688 Atom at;
689 if (IsVarTerm(t2)) {
690 const char *s =
691 Yap_TermToBuffer(Deref(ARG1), Quote_illegal_f | Handle_vars_f);
692 if (!s || !(at = Yap_UTF8ToAtom((const unsigned char *)s))) {
693 Yap_ThrowError(RESOURCE_ERROR_HEAP, t2,
694 "Could not get memory from the operating system");
695 return false;
696 }
697 return Yap_unify(ARG2, MkAtomTerm(at));
698 } else if (!IsAtomTerm(t2)) {
699 Yap_ThrowError(TYPE_ERROR_ATOM, t2, "atom_to_term/2");
700 return (FALSE);
701 } else {
702 at = AtomOfTerm(t2);
703 }
704 ctl = TermNil;
705 return ((rc = Yap_UBufferToTerm(RepAtom(at)->UStrOfAE, ctl))) &&
706 Yap_unify(rc, ARG1);
707}
708
709
710
711char *Yap_TermToBuffer(Term t, int flags) {
712 CACHE_REGS
713 int sno = Yap_open_buf_write_stream(LOCAL_encoding, flags);
714
715 if (sno < 0)
716 return NULL;
717 if (t == 0)
718 return NULL;
719 else
720 t = Deref(t);
721 GLOBAL_Stream[sno].encoding = LOCAL_encoding;
722 GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
723 GLOBAL_Stream[sno].status &= ~FreeOnClose_Stream_f;
724 Yap_plwrite(t, GLOBAL_Stream + sno, LOCAL_max_depth,HR, flags, NULL);
725 char *new = Yap_MemExportStreamPtr(sno);
726 Yap_CloseStream(sno);
727 return new;
728}
729
730void Yap_InitWriteTPreds(void) {
731 Yap_InitCPred("write_term", 2, write_term2, SyncPredFlag);
732 Yap_InitCPred("write_term", 3, write_term3, SyncPredFlag);
733 Yap_InitCPred("write", 1, write1, SyncPredFlag);
734 Yap_InitCPred("write", 2, write2, SyncPredFlag);
735 Yap_InitCPred("writeq", 1, writeq1, SyncPredFlag);
736 Yap_InitCPred("writeq", 2, writeq, SyncPredFlag);
737 Yap_InitCPred("writeln", 1, writeln1, SyncPredFlag);
738 Yap_InitCPred("writeln", 2, writeln, SyncPredFlag);
739 Yap_InitCPred("write_canonical", 1, write_canonical1, SyncPredFlag);
740 Yap_InitCPred("write_canonical", 2, write_canonical, SyncPredFlag);
741 Yap_InitCPred("display", 1, display1, SyncPredFlag);
742 Yap_InitCPred("display", 2, display, SyncPredFlag);
743 Yap_InitCPred("print", 1, print1, SyncPredFlag);
744 Yap_InitCPred("print", 2, print, SyncPredFlag);
745 Yap_InitCPred("write_depth", 3, p_write_depth, SafePredFlag | SyncPredFlag);
746 Yap_InitCPred("term_to_string", 2, term_to_string, 0);
747 Yap_InitCPred("term_to_atom", 2, term_to_atom, 0);
748 Yap_InitCPred("write_depth", 3, p_write_depth, SafePredFlag | SyncPredFlag);
749 ;
750 Yap_InitCPred("current_dollar_var", 2, dollar_var, SafePredFlag);
751 ;
752}
753
Yap.h
Main definitions.
Yap_NumberVars
int Yap_NumberVars(Term t, int numbv, bool handle_singles USES_REGS)
numbervariables in term t
Definition: terms.c:770
Yap_read_term
Term Yap_read_term(int sno, Term opts, bool clause)
generic routine to read terms from a stream
Definition: readterm.c:1324
struct_param
Definition: YapFlags.h:157
x_el
Definition: YapFlags.h:152