diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix overflow handling in global variables

Browse Source 
fix use of must_be_callable.
This commit is contained in:
Vitor Santos Costa 2019-05-27 15:31:22 +01:00
parent 8f8da92603
commit 07cd79ccb7
5 changed files with 152 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
C/exec.c
View File

@ -980,7 +980,7 @@ static bool watch_retry(Term d0 USES_REGS) {
while (B->cp_ap->opc == FAIL_OPCODE)
B = B->cp_b;
ASP = (CELL *) PROTECT_FROZEN_B(B);
// just do the frrpest
if (B >= B0 && !ex_mode && !active)
return true;

12
C/fail_absmi_insts.h
View File

@ -215,10 +215,7 @@ failloop:
}
/* pointer to code space */
/* or updatable variable */
#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || \
defined(MULTI_ASSIGNMENT_VARIABLES)
if (IsPairTerm(d1))
#endif /* TERM_EXTENSIONS || FROZEN_STACKS || MULTI_ASSIGNMENT_VARIABLES */
{
register CELL flags;
CELL *pt1 = RepPair(d1);
@ -245,19 +242,20 @@ failloop:
goto failloop;
} else
#endif /* FROZEN_STACKS */
if (IN_BETWEEN(H0, pt1, HR)) {
if (IN_BETWEEN(H0, pt1, LCL0)) {
if (IsAttVar(pt1)) {
goto failloop;
} else {
TR = pt0;
Yap_CleanOpaqueVariable(d1);
Yap_CleanOpaqueVariable(d1);
goto failloop;
}
}
#ifdef FROZEN_STACKS /* TRAIL */
/* don't reset frozen variables */
if (pt0 < TR_FZ)
else if (pt0 < TR_FZ)
goto failloop;
#endif
flags = *pt1;
@ -306,9 +304,7 @@ hence we don't need to have a lock it */
} else {
LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1);
int erase;
#if PARALLEL_YAP
PredEntry *ap = cl->ClPred;
#endif
/* BB support */
if (ap) {

78
C/globals.c
View File

@ -286,10 +286,9 @@ static Term GrowArena(Term arena, size_t size,
XREGS[arity + 1] = arena;
if (!Yap_gcl(size * sizeof(CELL), arity + 1, ENV, gc_P(P, CP))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return false;
return 0;
}
arena = XREGS[arity + 1];
adjust_cps(size PASS_REGS);
}
pt = ArenaLimit(arena);
if (pt == HR) {
@ -301,8 +300,8 @@ static Term GrowArena(Term arena, size_t size,
}
arena = XREGS[arity + 1];
}
CreateNewArena(RepAppl(arena), size+old_size);
return size+old_size;
arena = CreateNewArena(RepAppl(arena), size+old_size);
return arena;
}
CELL *Yap_GetFromArena(Term *arenap, UInt cells, UInt arity) {
@ -329,11 +328,11 @@ CELL *Yap_GetFromArena(Term *arenap, UInt cells, UInt arity) {
}
}
static Term CloseArena(cell_space_t *region, Term arena,
static Term CloseArena(cell_space_t *region,
UInt old_size USES_REGS) {
UInt new_size;
new_size = old_size - (HR - RepAppl(arena));
arena = CreateNewArena(HR, new_size);
new_size = old_size - (HR - HB);
Term arena = CreateNewArena(HR, new_size);
exit_cell_space( region );
return arena;
}
@ -649,10 +648,10 @@ static Term CopyTermToArena(Term t, Term arena, bool share, bool copy_att_vars,
cell_space_t cspace;
int res = 0, restarts = 0;
Term tn;
old_size = ArenaSz(arena);
restart:
enter_cell_space(&cspace);
old_size = ArenaSz(arena);
t = Deref(t);
if (IsVarTerm(t)) {
ASP = ArenaLimit(arena);
@ -668,12 +667,12 @@ static Term CopyTermToArena(Term t, Term arena, bool share, bool copy_att_vars,
Hi PASS_REGS)) < 0) {
goto error_handler;
}
*newarena = CloseArena(&cspace, arena, old_size PASS_REGS);
*newarena = CloseArena(&cspace, old_size PASS_REGS);
return Hi[0];
}
#endif
if (share && VarOfTerm(t) > ArenaPt(arena)) {
*newarena = CloseArena(&cspace, arena, old_size PASS_REGS);
*newarena = CloseArena(&cspace, old_size PASS_REGS);
return t;
}
tn = MkVarTerm();
@ -681,7 +680,7 @@ static Term CopyTermToArena(Term t, Term arena, bool share, bool copy_att_vars,
res = -1;
goto error_handler;
}
*newarena = CloseArena(&cspace, arena, old_size PASS_REGS);
*newarena = CloseArena(&cspace, old_size PASS_REGS);
return tn;
} else if (IsAtomOrIntTerm(t)) {
return t;
@ -703,7 +702,7 @@ static Term CopyTermToArena(Term t, Term arena, bool share, bool copy_att_vars,
Hi PASS_REGS)) < 0) {
goto error_handler;
}
*newarena = CloseArena(&cspace, arena, old_size PASS_REGS);
*newarena = CloseArena(&cspace, old_size PASS_REGS);
return tf;
} else {
Functor f;
@ -724,7 +723,7 @@ static Term CopyTermToArena(Term t, Term arena, bool share, bool copy_att_vars,
if (IsExtensionFunctor(f)) {
switch ((CELL) f) {
case (CELL) FunctorDBRef:
*newarena = CloseArena(&cspace, arena, old_size PASS_REGS);
*newarena = CloseArena(&cspace, old_size PASS_REGS);
return t;
case (CELL) FunctorLongInt:
if (HR > ASP - (MIN_ARENA_SIZE + 3)) {
@ -783,32 +782,32 @@ static Term CopyTermToArena(Term t, Term arena, bool share, bool copy_att_vars,
goto error_handler;
}
}
*newarena = CloseArena(&cspace, arena, old_size PASS_REGS);
*newarena = CloseArena(&cspace, old_size PASS_REGS);
return tf;
}
error_handler:
XREGS[arity + 1] = t;
XREGS[arity + 2] = arena;
exit_cell_space(&cspace);
switch (res) {
case -1:
if (arena == LOCAL_GlobalArena)
LOCAL_GlobalArenaOverflows++;
restarts++;
min_grow += (restarts < 16 ? 16*1024*restarts*restarts : 128*1024*1024);
CreateNewArena (RepAppl(arena),old_size);
if((arena=GrowArena(arena, min_grow, arity + 2, &cspace PASS_REGS))==0) {
HR = HB;
arena = CloseArena (&cspace, old_size PASS_REGS);
if((arena=GrowArena(arena, min_grow, arity + 1, &cspace PASS_REGS))==0) {
Yap_ThrowError(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return 0L;
}
break;
t = XREGS[arity+1];
enter_cell_space(&cspace);
old_size = ArenaSz(arena);
break;
default: /* temporary space overflow */
return 0;
exit_cell_space(&cspace);
return 0;
}
enter_cell_space(&cspace);
arena = Deref(XREGS[arity + 2]);
t = XREGS[arity + 1];
goto restart;
}
@ -836,7 +835,7 @@ restart:
// CELL *old_top = ArenaLimit(*nsizeof(CELL)ewarena);
if (arena == LOCAL_GlobalArena)
LOCAL_GlobalArenaOverflows++;
CreateNewArena (RepAppl(arena),old_size);
arena = CreateNewArena (RepAppl(arena),old_size);
if ((arena=GrowArena(arena, Nar * sizeof(CELL),
arity + 1, &cells PASS_REGS))==0) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil,
@ -856,7 +855,7 @@ restart:
HB0[i] = init;
}
}
*newarena = CloseArena(&cells, arena, ArenaSz(arena) PASS_REGS);
*newarena = CloseArena(&cells, ArenaSz(arena) PASS_REGS);
return tf;
}
@ -1658,19 +1657,18 @@ static Int p_nb_queue_enqueue(USES_REGS1) {
} else {
min_size = 0L;
}
to = CopyTermToArena(ARG2, arena, FALSE, TRUE, 2, qd + QUEUE_ARENA,
Term newarena = arena;
to = CopyTermToArena(Deref(ARG2), arena, FALSE, TRUE, 2, &newarena,
min_size PASS_REGS);
if (to == 0L)
return FALSE;
cell_space_t cspace;
qd = GetQueue(ARG1, "enqueue");
arena = GetQueueArena(qd, "enqueue");
arena = newarena;
/* garbage collection ? */
enter_cell_space(&cspace);
HR = HB = ArenaPt(arena);
old_sz = ArenaSz(arena);
qd = GetQueue(ARG1, "enqueue");
qsize = IntegerOfTerm(qd[QUEUE_SIZE]);
qd[QUEUE_SIZE] = Global_MkIntegerTerm(qsize + 1);
if (qsize == 0) {
qd[QUEUE_HEAD] = AbsPair(HR);
@ -1681,7 +1679,7 @@ static Int p_nb_queue_enqueue(USES_REGS1) {
RESET_VARIABLE(HR);
qd[QUEUE_TAIL] = (CELL)HR;
HR++;
qd[QUEUE_ARENA] = CloseArena(&cspace, qd[ QUEUE_ARENA ], old_sz PASS_REGS);
qd[QUEUE_ARENA] =CloseArena(&cspace, old_sz PASS_REGS);
return TRUE;
}
@ -1705,7 +1703,7 @@ static Int p_nb_queue_dequeue(USES_REGS1) {
/* garbage collection ? */
enter_cell_space(&cspace);
qd[QUEUE_SIZE] = Global_MkIntegerTerm(qsz - 1);
qd[QUEUE_ARENA] = CloseArena(&cspace, arena, old_sz PASS_REGS);
qd[QUEUE_ARENA] = CloseArena(&cspace, old_sz PASS_REGS);
return Yap_unify(out, ARG2);
}
@ -1955,7 +1953,7 @@ restart:
old_sz = ArenaSz(arena);
HR = HB = ArenaPt(arena);
qd[HEAP_MAX] = Global_MkIntegerTerm(hmsize);
qd[HEAP_ARENA] = CloseArena(&cspace, arena, old_sz PASS_REGS);
qd[HEAP_ARENA] = CloseArena(&cspace, old_sz PASS_REGS);
goto restart;
}
arena = qd[HEAP_ARENA];
@ -1966,14 +1964,14 @@ restart:
mingrow PASS_REGS);
qd = GetHeap(ARG1, "add_to_heap");
arena = qd[HEAP_ARENA];
to = CopyTermToArena(ARG3, arena, FALSE, TRUE, 3, qd + HEAP_ARENA,
to = CopyTermToArena(ARG3, arena, FALSE, TRUE, 3, &arena,
mingrow PASS_REGS);
/* protect key in ARG2 in case there is an overflow while copying to */
key = ARG2;
if (key == 0 || to == 0L)
return FALSE;
qd = GetHeap(ARG1, "add_to_heap");
arena = qd[HEAP_ARENA];
qd[HEAP_ARENA] = arena;
/* garbage collection ? */
enter_cell_space(&cspace);
HR = HB = ArenaPt(arena);
@ -1987,7 +1985,7 @@ restart:
gsiz = 1024;
}
ARG3 = to;
CreateNewArena (RepAppl(arena),old_sz);
arena = CreateNewArena (RepAppl(arena),old_sz);
if ((arena=GrowArena(arena, gsiz, 3, &cspace PASS_REGS))==0) {
Yap_Error(RESOURCE_ERROR_STACK, arena, LOCAL_ErrorMessage);
return 0L;
@ -2003,7 +2001,7 @@ restart:
pt[2 * hsize + 1] = to;
PushHeap(pt, hsize);
qd[HEAP_SIZE] = Global_MkIntegerTerm(hsize + 1);
qd[HEAP_ARENA] = CloseArena(&cspace, qd[ HEAP_ARENA ], old_sz PASS_REGS);
qd[HEAP_ARENA] = CloseArena(&cspace, old_sz PASS_REGS);
return TRUE;
}
@ -2347,7 +2345,7 @@ cell_space_t cspace;
}
ARG3 = to;
/* fprintf(stderr,"growing %ld cells\n",(unsigned long int)gsiz);*/
CreateNewArena (RepAppl(arena),old_sz);
arena = CreateNewArena (RepAppl(arena),old_sz);
if (!GrowArena(arena, gsiz, 3, &cspace PASS_REGS)) {
Yap_Error(RESOURCE_ERROR_STACK, arena, LOCAL_ErrorMessage);
return 0L;
@ -2360,7 +2358,7 @@ cell_space_t cspace;
pt = qd + HEAP_START;
PushBeam(pt, pt + 2 * hmsize, hsize, key, to);
qd[HEAP_SIZE] = Global_MkIntegerTerm(hsize + 1);
qd[HEAP_ARENA] = CloseArena(&cspace, qd[ HEAP_ARENA ], old_sz PASS_REGS);
qd[HEAP_ARENA] = CloseArena(&cspace, old_sz PASS_REGS);
return TRUE;
}
@ -2383,7 +2381,7 @@ static Int p_nb_beam_del(USES_REGS1) {
/* garbage collection ? */
enter_cell_space(&cspace);
qd[HEAP_SIZE] = Global_MkIntegerTerm(qsz - 1);
qd[ HEAP_ARENA] = CloseArena(&cspace, arena, old_sz PASS_REGS);
qd[ HEAP_ARENA] = CloseArena(&cspace, old_sz PASS_REGS);
tk = qd[HEAP_START];
tv = DelBeamMin(qd + HEAP_START,
qd + (HEAP_START + 2 * IntegerOfTerm(qd[HEAP_MAX])), qsz);

1
C/stdpreds.c
View File

@ -1575,6 +1575,7 @@ void Yap_InitCPreds(void) {
Yap_InitCoroutPreds();
Yap_InitDBPreds();
Yap_InitExecFs();
Yap_InitErrorPreds();
Yap_InitGlobals();
Yap_InitInlines();
Yap_InitIOPreds();

200
C/write.c
View File

@ -74,7 +74,7 @@ typedef struct write_globs {
bool Keep_terms;
bool Write_Loops;
bool Write_strings;
UInt last_atom_minus;
UInt last_atom_minus;
UInt MaxDepth, MaxArgs;
wtype lw;
CELL *visited, *visited0, *visited_top;
@ -410,52 +410,57 @@ static void wrputref(CODEADDR ref, int Quote_illegal,
lastw = alphanum;
}
static inline bool was_visited(Term t, wglbs *wg, Term *ta ) {
Term *tp;
if (IsApplTerm(t)) {
if (IsExtensionFunctor(FunctorOfTerm(t)))
return false;
tp = RepAppl(t);
}
else if (IsPairTerm(t)) tp = RepPair(t);
else return false;
if (IsAtomTerm(*tp)) {
CELL *pt= (CELL*)AtomOfTerm(*tp);
if (pt >= wg->visited0 &&
pt < wg->visited) {
int depth = (wg->visited+1)-pt;
wrputs(" @( ", wg->stream);
wrputn(depth, wg);
wrputs( " ) ", wg->stream);
return true;
}
}
*ta = *tp;
wg->visited[0] = *tp;
*tp = MkAtomTerm( (Atom)wg->visited );
wg->visited++;
static inline bool was_visited(Term t, wglbs *wg, Term *ta) {
Term *tp;
if (IsApplTerm(t)) {
tp = RepAppl(t);
*ta = tp[0];
return false;
if (IsExtensionFunctor(FunctorOfTerm(t))) {
return false;
}
} else if (IsPairTerm(t)) {
tp = RepPair(t);
*ta = tp[0];
return false;
} else
return false;
if (IsAtomTerm(*tp)) {
CELL *pt = (CELL *)AtomOfTerm(*tp);
if (pt >= wg->visited0 && pt < wg->visited) {
int depth = (wg->visited) - pt;
wrputs(" @[-", wg->stream);
wrputn(depth, wg);
wrputs("] ", wg->stream);
return true;
}
}
wg->visited[0] = *tp;
*tp = MkAtomTerm((Atom)wg->visited);
wg->visited++;
return false;
}
static inline Term visited_indirection(Term t, wglbs *wg ) {
static inline Term visited_indirection(Term t, wglbs *wg) {
Term *tp = (CELL *)AtomOfTerm(t);
if (tp >= wg->visited0
&& (CELL *) tp < wg->visited_top)
if (tp >= wg->visited0 && (CELL *)tp < wg->visited_top)
return *tp;
return 0;
}
static inline void done_visiting(Term t, wglbs *wg) {
Term *tp;
if (IsApplTerm(t)) tp = RepAppl(t);
else if (IsPairTerm(t)) tp = RepPair(t);
else return;
*tp = *--wg->visited;
Term *tp;
return;
if (IsApplTerm(t))
tp = RepAppl(t);
else if (IsPairTerm(t))
tp = RepPair(t);
else
return;
*tp = *--wg->visited;
}
/* writes a blob (default) */
static int wrputblob(AtomEntry *ref, int Quote_illegal,
struct write_globs *wglb) {
@ -523,10 +528,10 @@ AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
static void write_quoted(wchar_t ch, wchar_t quote, wrf stream) {
CACHE_REGS
if (!(Yap_GetModuleEntry(CurrentModule)->flags & M_CHARESCAPE)) {
wrputc(ch, stream);
if (ch == '\'')
wrputc('\'', stream); /* be careful about quotes */
return;
wrputc(ch, stream);
if (ch == '\'')
wrputc('\'', stream); /* be careful about quotes */
return;
}
if (!(ch < 0xff && chtype(ch) == BS) && ch != '\'' && ch != '\\' &&
ch != '`') {
@ -628,12 +633,13 @@ static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
unsigned char *s;
wtype atom_or_symbol;
wrf stream = wglb->stream;
if (atom == NULL) return;
if (atom == NULL)
return;
s = RepAtom(atom)->UStrOfAE;
if (s[0] == '\0') {
if (s[0] == '\0') {
if (Quote_illegal) {
wrputc('\'', stream);
wrputc('\'', stream);
wrputc('\'', stream);
wrputc('\'', stream);
}
return;
}
@ -772,19 +778,13 @@ static void write_var(CELL *t, struct write_globs *wglb,
}
}
static void write_list(Term t, int direction, int depth,
static void write_list(Term t, Term hot, int direction, int depth,
struct write_globs *wglb, struct rewind_term *rwt) {
Term ti;
struct rewind_term nrwt;
nrwt.parent = rwt;
nrwt.u_sd.s.ptr = 0;
Term hot;
if (was_visited(t, wglb, &hot)) {
return;
}
bool loop = true;
while (loop) {
loop = false;
while (true) {
PROTECT(t, writeTerm(hot, 999, depth + 1, FALSE, wglb, &nrwt));
ti = TailOfTerm(t);
if (IsVarTerm(ti))
@ -797,25 +797,33 @@ loop = false;
}
wrputc('|', wglb->stream);
putAtom(Atom3Dots, wglb->Quote_illegal, wglb);
done_visiting(t, wglb);
return;
}
lastw = separator;
depth++;
wrputc(',', wglb->stream);
t = ti;
if ((was_visited(ti, wglb, &hot))) {
break;
}
write_list(ti, hot, direction, depth, wglb, &nrwt);
done_visiting(ti, wglb);
return;
}
if (IsPairTerm(ti)) {
/* we found an infinite loop */
/* keep going on the list */
wrputc(',', wglb->stream);
write_list(ti, direction, depth, wglb, &nrwt);
} else if (ti != MkAtomTerm(AtomNil)) {
write_list(ti, hot, direction, depth, wglb, &nrwt);
done_visiting(ti, wglb);
} else if (ti != TermNil) {
if (lastw == symbol || lastw == separator) {
wrputc(' ', wglb->stream);
}
wrputc('|', wglb->stream);
lastw = separator;
writeTerm(ti, 999, depth, FALSE, wglb, &nrwt);
done_visiting(ti, wglb);
}
}
@ -840,19 +848,19 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
wrputn((Int)IntOfTerm(t), wglb);
} else if (IsAtomTerm(t)) {
Term tn;
if ((tn = visited_indirection(t, wglb))!=0) {
writeTerm(tn,p,depth,rinfixarg,wglb,rwt);
if ((tn = visited_indirection(t, wglb)) != 0) {
writeTerm(tn, p, depth, rinfixarg, wglb, rwt);
return;
}
putAtom(AtomOfTerm(t), wglb->Quote_illegal, wglb);
} else if (IsPairTerm(t)) {
Term hot;
if ((was_visited(t, wglb, &hot))) {
return;
}
if (wglb->Ignore_ops) {
wrputs("'.'(", wglb->stream);
wrputs("'.'(", wglb->stream);
lastw = separator;
Term hot;
if ((was_visited(t, wglb, &hot))) {
return;
}
PROTECT(t, writeTerm(hot, 999, depth + 1, FALSE, wglb, &nrwt));
wrputs(",", wglb->stream);
@ -861,17 +869,24 @@ if ((was_visited(t, wglb, &hot))) {
wrclose_bracket(wglb, TRUE);
return;
}
if (wglb->Use_portray)
if (callPortray(t, wglb->stream - GLOBAL_Stream PASS_REGS)) {
if (wglb->Use_portray) {
done_visiting(t, wglb);
if (callPortray(t, wglb->stream - GLOBAL_Stream PASS_REGS)) {
return;
}
if ((was_visited(t, wglb, &hot))) {
return;
}
}
if (trueGlobalPrologFlag(WRITE_STRINGS_FLAG) && IsCodesTerm(t)) {
putString(t, wglb);
} else {
wrputc('[', wglb->stream);
lastw = separator;
/* we assume t was already saved in the stack */
write_list(t, 0, depth, wglb, rwt);
write_list(t, hot, 0, depth, wglb, rwt);
done_visiting(t, wglb);
wrputc(']', wglb->stream);
lastw = separator;
}
@ -882,10 +897,10 @@ if ((was_visited(t, wglb, &hot))) {
int op, lp, rp;
Term argf;
if (was_visited(t, wglb, &argf)) {
return;
}
functor = (Functor)argf;
if (was_visited(t, wglb, &argf)) {
return;
}
functor = (Functor)argf;
if (IsExtensionFunctor(functor)) {
switch ((CELL)functor) {
case (CELL)FunctorDouble:
@ -938,12 +953,16 @@ if ((was_visited(t, wglb, &hot))) {
}
#endif
if (wglb->Use_portray) {
done_visiting(t, wglb);
if (callPortray(t, wglb->stream - GLOBAL_Stream PASS_REGS)) {
return;
}
Term tf;
was_visited(t, wglb, &tf);
functor = (Functor)tf;
}
if (!wglb->Ignore_ops && Arity == 1 && Yap_IsPrefixOp(atom, &op, &rp)) {
if (!wglb->Ignore_ops && Arity == 1 && Yap_IsPrefixOp(atom, &op, &rp)) {
Term tright = ArgOfTerm(1, t);
int bracket_right = !IsVarTerm(tright) && IsAtomTerm(tright) &&
Yap_IsOp(AtomOfTerm(tright));
@ -1003,7 +1022,7 @@ if ((was_visited(t, wglb, &hot))) {
wrputc('{', wglb->stream);
}
lastw = separator;
write_list(tleft, 0, depth, wglb, rwt);
writeTerm(tleft, 0, rinfixarg, depth, wglb, rwt);
if (atom == AtomEmptyBrackets) {
wrputc(')', wglb->stream);
} else if (atom == AtomEmptySquareBrackets) {
@ -1125,10 +1144,10 @@ if ((was_visited(t, wglb, &hot))) {
writeTerm(ArgOfTerm(op, t), 999, depth + 1, FALSE, wglb, &nrwt);
wrputc('}', wglb->stream);
lastw = separator;
} else {
} else {
if (!wglb->Ignore_ops && atom == AtomHeap) {
Arity = 3+2*IntegerOfTerm(ArgOfTerm(1,t));
}
Arity = 3 + 2 * IntegerOfTerm(ArgOfTerm(1, t));
}
putAtom(atom, wglb->Quote_illegal, wglb);
lastw = separator;
wropen_bracket(wglb, FALSE);
@ -1147,7 +1166,7 @@ if ((was_visited(t, wglb, &hot))) {
writeTerm(ArgOfTerm(op, t), 999, depth + 1, FALSE, wglb, &nrwt);
wrclose_bracket(wglb, TRUE);
}
done_visiting(t, wglb);
done_visiting(t, wglb);
}
}
@ -1173,25 +1192,23 @@ void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags,
wglb.Keep_terms = flags & To_heap_f;
wglb.Write_Loops = flags & Handle_cyclics_f;
wglb.Quote_illegal = flags & Quote_illegal_f;
wglb.MaxArgs = 0 ;
wglb.MaxDepth = 0 ;
wglb.MaxArgs = 0;
wglb.MaxDepth = 0;
wglb.lw = separator;
Term tp;
if (true && (flags & Handle_cyclics_f) ){
// tp = Yap_CyclesInTerm(t PASS_REGS);
wglb.visited = Malloc(1024*sizeof(CELL)),
wglb.visited0 = wglb.visited,
wglb.visited_top = wglb.visited+1024;
}
tp = t;
/* protect slots for portray */
if (true && (flags & Handle_cyclics_f)) {
// tp = Yap_CyclesInTerm(t PASS_REGS);
wglb.visited = Malloc(1024 * sizeof(CELL)), wglb.visited0 = wglb.visited,
wglb.visited_top = wglb.visited + 1024;
}
tp = t;
/* protect slots for portray */
writeTerm(tp, priority, 1, false, &wglb, &rwt);
if (flags & New_Line_f) {
if (flags & New_Line_f) {
if (flags & Fullstop_f) {
wrputc('.', wglb.stream);
wrputc('.', wglb.stream);
wrputc('\n', wglb.stream);
} else {
wrputc('\n', wglb.stream);
@ -1203,5 +1220,4 @@ void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags,
}
}
pop_text_stack(lvl);
}
}