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

call cleanup

Browse Source
This commit is contained in:
Vitor Santos Costa
2017-09-06 01:13:00 +01:00
parent af29600f09
commit e3ab36f091
7 changed files with 361 additions and 404 deletions
Download Patch File Download Diff File Expand all files Collapse all files

712
C/fail_absmi_insts.h
View File

@@ -6,455 +6,413 @@
{ {
#endif /* INDENT_CODE */ #endif /* INDENT_CODE */
/* trust_fail */ /* trust_fail */
BOp(trust_fail, e); BOp(trust_fail, e);
{ {
while (POP_CHOICE_POINT(B->cp_b)) while (POP_CHOICE_POINT(B->cp_b)) {
{ POP_EXECUTE();
POP_EXECUTE(); }
} }
}
#ifdef YAPOR #ifdef YAPOR
{ {
choiceptr cut_pt; choiceptr cut_pt;
cut_pt = B->cp_b; cut_pt = B->cp_b;
CUT_prune_to(cut_pt); CUT_prune_to(cut_pt);
B = cut_pt; B = cut_pt;
} }
#else #else
B = B->cp_b; B = B->cp_b;
#endif /* YAPOR */ #endif /* YAPOR */
goto fail; goto fail;
ENDBOp(); ENDBOp();
#ifdef YAPOR #ifdef YAPOR
shared_fail: shared_fail:
B = Get_LOCAL_top_cp(); B = Get_LOCAL_top_cp();
SET_BB(PROTECT_FROZEN_B(B)); SET_BB(PROTECT_FROZEN_B(B));
goto fail; goto fail;
#endif /* YAPOR */ #endif /* YAPOR */
/* fail */ /* fail */
PBOp(op_fail, e); PBOp(op_fail, e);
if (PP) if (PP) {
{ UNLOCK(PP->PELock);
UNLOCK(PP->PELock); PP = NULL;
PP = NULL; }
}
#ifdef COROUTINING #ifdef COROUTINING
CACHE_Y_AS_ENV(YREG); CACHE_Y_AS_ENV(YREG);
check_stack(NoStackFail, HR); check_stack(NoStackFail, HR);
ENDCACHE_Y_AS_ENV(); ENDCACHE_Y_AS_ENV();
#endif #endif
fail: fail : {
{ register tr_fr_ptr pt0 = TR;
register tr_fr_ptr pt0 = TR;
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (PP) if (PP) {
{ UNLOCK(PP->PELock);
UNLOCK(PP->PELock); PP = NULL;
PP = NULL; }
}
#endif #endif
PREG = B->cp_ap; PREG = B->cp_ap;
save_pc(); save_pc();
CACHE_TR(B->cp_tr); CACHE_TR(B->cp_tr);
PREFETCH_OP(PREG); PREFETCH_OP(PREG);
failloop: failloop:
if (pt0 == S_TR) if (pt0 == S_TR) {
{ SP = SP0;
SP = SP0;
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) if (Yap_do_low_level_trace) {
{ int go_on = true;
int go_on = true; yamop *ipc = PREG;
yamop *ipc = PREG;
while (go_on) while (go_on) {
{ op_numbers opnum = Yap_op_from_opcode(ipc->opc);
op_numbers opnum = Yap_op_from_opcode(ipc->opc);
go_on = false; go_on = false;
switch (opnum) switch (opnum) {
{
#ifdef TABLING #ifdef TABLING
case _table_load_answer: case _table_load_answer:
low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL);
break; break;
case _table_try_answer: case _table_try_answer:
case _table_retry_me: case _table_retry_me:
case _table_trust_me: case _table_trust_me:
case _table_retry: case _table_retry:
case _table_trust: case _table_trust:
case _table_completion: case _table_completion:
#ifdef THREADS_CONSUMER_SHARING #ifdef THREADS_CONSUMER_SHARING
case _table_answer_resolution_completion: case _table_answer_resolution_completion:
#endif /* THREADS_CONSUMER_SHARING */ #endif /* THREADS_CONSUMER_SHARING */
#ifdef DETERMINISTIC_TABLING #ifdef DETERMINISTIC_TABLING
if (IS_DET_GEN_CP(B)) if (IS_DET_GEN_CP(B))
low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry,
else NULL);
else
#endif /* DETERMINISTIC_TABLING */ #endif /* DETERMINISTIC_TABLING */
low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry,
break; (CELL *)(GEN_CP(B) + 1));
case _table_answer_resolution: break;
low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); case _table_answer_resolution:
break; low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry,
case _trie_trust_var: NULL);
case _trie_retry_var: break;
case _trie_trust_var_in_pair: case _trie_trust_var:
case _trie_retry_var_in_pair: case _trie_retry_var:
case _trie_trust_val: case _trie_trust_var_in_pair:
case _trie_retry_val: case _trie_retry_var_in_pair:
case _trie_trust_val_in_pair: case _trie_trust_val:
case _trie_retry_val_in_pair: case _trie_retry_val:
case _trie_trust_atom: case _trie_trust_val_in_pair:
case _trie_retry_atom: case _trie_retry_val_in_pair:
case _trie_trust_atom_in_pair: case _trie_trust_atom:
case _trie_retry_atom_in_pair: case _trie_retry_atom:
case _trie_trust_null: case _trie_trust_atom_in_pair:
case _trie_retry_null: case _trie_retry_atom_in_pair:
case _trie_trust_null_in_pair: case _trie_trust_null:
case _trie_retry_null_in_pair: case _trie_retry_null:
case _trie_trust_pair: case _trie_trust_null_in_pair:
case _trie_retry_pair: case _trie_retry_null_in_pair:
case _trie_trust_appl: case _trie_trust_pair:
case _trie_retry_appl: case _trie_retry_pair:
case _trie_trust_appl_in_pair: case _trie_trust_appl:
case _trie_retry_appl_in_pair: case _trie_retry_appl:
case _trie_trust_extension: case _trie_trust_appl_in_pair:
case _trie_retry_extension: case _trie_retry_appl_in_pair:
case _trie_trust_double: case _trie_trust_extension:
case _trie_retry_double: case _trie_retry_extension:
case _trie_trust_longint: case _trie_trust_double:
case _trie_retry_longint: case _trie_retry_double:
case _trie_trust_gterm: case _trie_trust_longint:
case _trie_retry_gterm: case _trie_retry_longint:
low_level_trace(retry_table_loader, UndefCode, NULL); case _trie_trust_gterm:
break; case _trie_retry_gterm:
low_level_trace(retry_table_loader, UndefCode, NULL);
break;
#endif /* TABLING */ #endif /* TABLING */
case _or_else: case _or_else:
case _or_last: case _or_last:
low_level_trace(retry_or, NULL, NULL); low_level_trace(retry_or, NULL, NULL);
break; break;
case _retry2: case _retry2:
case _retry3: case _retry3:
case _retry4: case _retry4:
ipc = NEXTOP(ipc, l); ipc = NEXTOP(ipc, l);
go_on = true; go_on = true;
break; break;
case _jump: case _jump:
ipc = ipc->y_u.l.l; ipc = ipc->y_u.l.l;
go_on = true; go_on = true;
break; break;
case _retry_c: case _retry_c:
case _retry_userc: case _retry_userc:
low_level_trace(retry_pred, ipc->y_u.OtapFs.p, B->cp_args); low_level_trace(retry_pred, ipc->y_u.OtapFs.p, B->cp_args);
break; break;
case _retry_profiled: case _retry_profiled:
case _count_retry: case _count_retry:
ipc = NEXTOP(ipc, p); ipc = NEXTOP(ipc, p);
go_on = true; go_on = true;
break; break;
case _retry_me: case _retry_me:
case _trust_me: case _trust_me:
case _count_retry_me: case _count_retry_me:
case _count_trust_me: case _count_trust_me:
case _profiled_retry_me: case _profiled_retry_me:
case _profiled_trust_me: case _profiled_trust_me:
case _retry_and_mark: case _retry_and_mark:
case _profiled_retry_and_mark: case _profiled_retry_and_mark:
case _retry: case _retry:
case _trust: case _trust:
low_level_trace(retry_pred, ipc->y_u.Otapl.p, B->cp_args); low_level_trace(retry_pred, ipc->y_u.Otapl.p, B->cp_args);
break; break;
case _try_logical: case _try_logical:
case _retry_logical: case _retry_logical:
case _profiled_retry_logical: case _profiled_retry_logical:
case _count_retry_logical: case _count_retry_logical:
case _trust_logical: case _trust_logical:
case _profiled_trust_logical: case _profiled_trust_logical:
case _count_trust_logical: case _count_trust_logical:
low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, B->cp_args); low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, B->cp_args);
break; break;
case _Nstop: case _Nstop:
case _Ystop: case _Ystop:
low_level_trace(retry_pred, NULL, B->cp_args); low_level_trace(retry_pred, NULL, B->cp_args);
break; break;
default: default:
break; break;
} }
} }
} }
#endif /* LOW_LEVEL_TRACER */ #endif /* LOW_LEVEL_TRACER */
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
#ifdef YAPOR_SBA #ifdef YAPOR_SBA
if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop + MinTrailGap) if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop + MinTrailGap)
#else #else
if (pt0 < TR_FZ) if (pt0 < TR_FZ)
#endif /* YAPOR_SBA */ #endif /* YAPOR_SBA */
{ {
TR = TR_FZ; TR = TR_FZ;
TRAIL_LINK(pt0); TRAIL_LINK(pt0);
} } else
else
#endif /* FROZEN_STACKS */ #endif /* FROZEN_STACKS */
RESTORE_TR(); RESTORE_TR();
GONext(); GONext();
} }
BEGD(d1); BEGD(d1);
d1 = TrailTerm(pt0 - 1); d1 = TrailTerm(pt0 - 1);
pt0--; pt0--;
if (IsVarTerm(d1)) if (IsVarTerm(d1)) {
{
#if defined(YAPOR_SBA) && defined(YAPOR) #if defined(YAPOR_SBA) && defined(YAPOR)
/* clean up the trail when we backtrack */ /* clean up the trail when we backtrack */
if (Unsigned((Int)(d1) - (Int)(H_FZ)) > if (Unsigned((Int)(d1) - (Int)(H_FZ)) >
Unsigned((Int)(B_FZ) - (Int)(H_FZ))) Unsigned((Int)(B_FZ) - (Int)(H_FZ))) {
{ RESET_VARIABLE(STACK_TO_SBA(d1));
RESET_VARIABLE(STACK_TO_SBA(d1)); } else
}
else
#endif #endif
/* normal variable */ /* normal variable */
RESET_VARIABLE(d1); RESET_VARIABLE(d1);
goto failloop; goto failloop;
} }
/* pointer to code space */ /* pointer to code space */
/* or updatable variable */ /* or updatable variable */
#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) #if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || \
if (IsPairTerm(d1)) defined(MULTI_ASSIGNMENT_VARIABLES)
if (IsPairTerm(d1))
#endif /* TERM_EXTENSIONS || FROZEN_STACKS || MULTI_ASSIGNMENT_VARIABLES */ #endif /* TERM_EXTENSIONS || FROZEN_STACKS || MULTI_ASSIGNMENT_VARIABLES */
{ {
register CELL flags; register CELL flags;
CELL *pt1 = RepPair(d1); CELL *pt1 = RepPair(d1);
#ifdef LIMIT_TABLING #ifdef LIMIT_TABLING
if ((ADDR)pt1 == LOCAL_TrailBase) if ((ADDR)pt1 == LOCAL_TrailBase) {
{ sg_fr_ptr sg_fr = (sg_fr_ptr)TrailVal(pt0);
sg_fr_ptr sg_fr = (sg_fr_ptr)TrailVal(pt0); TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1));
TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use -->
SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use --> compiled */ compiled */
insert_into_global_sg_fr_list(sg_fr); insert_into_global_sg_fr_list(sg_fr);
goto failloop; goto failloop;
} }
#endif /* LIMIT_TABLING */ #endif /* LIMIT_TABLING */
#ifdef FROZEN_STACKS /* TRAIL */ #ifdef FROZEN_STACKS /* TRAIL */
/* avoid frozen segments */ /* avoid frozen segments */
if ( if (
#ifdef YAPOR_SBA #ifdef YAPOR_SBA
(ADDR)pt1 >= HeapTop (ADDR)pt1 >= HeapTop
#else #else
IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop + MinTrailGap) IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop + MinTrailGap)
#endif /* YAPOR_SBA */ #endif /* YAPOR_SBA */
) ) {
{ pt0 = (tr_fr_ptr)pt1;
pt0 = (tr_fr_ptr)pt1; goto failloop;
goto failloop; } else
}
else
#endif /* FROZEN_STACKS */ #endif /* FROZEN_STACKS */
if (IN_BETWEEN(H0, pt1, HR)) if (IN_BETWEEN(H0, pt1, HR)) {
{ if (IsAttVar(pt1)) {
if (IsAttVar(pt1)) goto failloop;
{ } else {
goto failloop; TR = pt0;
} Yap_CleanOpaqueVariable(d1);
else
{ goto failloop;
TR = pt0; }
Yap_CleanOpaqueVariable(d1); }
goto fail;
}
}
#ifdef FROZEN_STACKS /* TRAIL */ #ifdef FROZEN_STACKS /* TRAIL */
/* don't reset frozen variables */ /* don't reset frozen variables */
if (pt0 < TR_FZ) if (pt0 < TR_FZ)
goto failloop; goto failloop;
#endif #endif
flags = *pt1; flags = *pt1;
#if MULTIPLE_STACKS #if MULTIPLE_STACKS
if (FlagOn(DBClMask, flags)) if (FlagOn(DBClMask, flags)) {
{ DBRef dbr = DBStructFlagsToDBStruct(pt1);
DBRef dbr = DBStructFlagsToDBStruct(pt1); int erase;
int erase;
LOCK(dbr->lock); LOCK(dbr->lock);
DEC_DBREF_COUNT(dbr); DEC_DBREF_COUNT(dbr);
erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0);
UNLOCK(dbr->lock); UNLOCK(dbr->lock);
if (erase) if (erase) {
{ saveregs();
saveregs(); Yap_ErDBE(dbr);
Yap_ErDBE(dbr); setregs();
setregs(); }
} } else {
} if (flags & LogUpdMask) {
else if (flags & IndexMask) {
{ LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1);
if (flags & LogUpdMask) int erase;
{
if (flags & IndexMask)
{
LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1);
int erase;
#if PARALLEL_YAP #if PARALLEL_YAP
PredEntry *ap = cl->ClPred; PredEntry *ap = cl->ClPred;
#endif #endif
PELOCK(8, ap); PELOCK(8, ap);
DEC_CLREF_COUNT(cl); DEC_CLREF_COUNT(cl);
erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
if (erase) if (erase) {
{ saveregs();
saveregs(); /* at this point,
/* at this point, we are the only ones accessing the clause,
we are the only ones accessing the clause, hence we don't need to have a lock it */
hence we don't need to have a lock it */ Yap_ErLogUpdIndex(cl);
Yap_ErLogUpdIndex(cl); setregs();
setregs(); } else if (cl->ClFlags & DirtyMask) {
} saveregs();
else if (cl->ClFlags & DirtyMask) /* at this point,
{ we are the only ones accessing the clause,
saveregs(); hence we don't need to have a lock it */
/* at this point, Yap_CleanUpIndex(cl);
we are the only ones accessing the clause, setregs();
hence we don't need to have a lock it */ }
Yap_CleanUpIndex(cl); UNLOCK(ap->PELock);
setregs(); } else {
} LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1);
UNLOCK(ap->PELock); int erase;
}
else
{
LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1);
int erase;
#if PARALLEL_YAP #if PARALLEL_YAP
PredEntry *ap = cl->ClPred; PredEntry *ap = cl->ClPred;
#endif #endif
/* BB support */ /* BB support */
if (ap) if (ap) {
{
PELOCK(9, ap); PELOCK(9, ap);
DEC_CLREF_COUNT(cl); DEC_CLREF_COUNT(cl);
erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
if (erase) if (erase) {
{ saveregs();
saveregs(); /* at this point,
/* at this point, we are the only ones accessing the clause,
we are the only ones accessing the clause, hence we don't need to have a lock it */
hence we don't need to have a lock it */ Yap_ErLogUpdCl(cl);
Yap_ErLogUpdCl(cl); setregs();
setregs(); }
} UNLOCK(ap->PELock);
UNLOCK(ap->PELock); }
} }
} } else {
} DynamicClause *cl = ClauseFlagsToDynamicClause(pt1);
else int erase;
{
DynamicClause *cl = ClauseFlagsToDynamicClause(pt1);
int erase;
LOCK(cl->ClLock); LOCK(cl->ClLock);
DEC_CLREF_COUNT(cl); DEC_CLREF_COUNT(cl);
erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
UNLOCK(cl->ClLock); UNLOCK(cl->ClLock);
if (erase) if (erase) {
{ saveregs();
saveregs(); /* at this point,
/* at this point, we are the only ones accessing the clause,
we are the only ones accessing the clause, hence we don't need to have a lock it */
hence we don't need to have a lock it */ Yap_ErCl(cl);
Yap_ErCl(cl); setregs();
setregs(); }
} }
} }
}
#else #else
ResetFlag(InUseMask, flags); ResetFlag(InUseMask, flags);
*pt1 = flags; *pt1 = flags;
if (FlagOn((ErasedMask | DirtyMask), flags)) if (FlagOn((ErasedMask | DirtyMask), flags)) {
{ if (FlagOn(DBClMask, flags)) {
if (FlagOn(DBClMask, flags)) saveregs();
{ Yap_ErDBE(DBStructFlagsToDBStruct(pt1));
saveregs(); setregs();
Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); } else {
setregs(); saveregs();
} if (flags & LogUpdMask) {
else if (flags & IndexMask) {
{ if (FlagOn(ErasedMask, flags)) {
saveregs(); Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1));
if (flags & LogUpdMask) } else {
{ Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1));
if (flags & IndexMask) }
{ } else {
if (FlagOn(ErasedMask, flags)) Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1));
{ }
Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); } else {
} Yap_ErCl(ClauseFlagsToDynamicClause(pt1));
else }
{ setregs();
Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); }
} }
}
else
{
Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1));
}
}
else
{
Yap_ErCl(ClauseFlagsToDynamicClause(pt1));
}
setregs();
}
}
#endif #endif
goto failloop; goto failloop;
} }
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
else /* if (IsApplTerm(d1)) */ else /* if (IsApplTerm(d1)) */
{ {
CELL *pt = RepAppl(d1); CELL *pt = RepAppl(d1);
/* AbsAppl means */ /* AbsAppl means */
/* multi-assignment variable */ /* multi-assignment variable */
/* so the next cell is the old value */ /* so the next cell is the old value */
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
--pt0; --pt0;
pt[0] = TrailVal(pt0); pt[0] = TrailVal(pt0);
#else #else
pt[0] = TrailTerm(pt0 - 1); pt[0] = TrailTerm(pt0 - 1);
pt0 -= 2; pt0 -= 2;
#endif /* FROZEN_STACKS */ #endif /* FROZEN_STACKS */
goto failloop; goto failloop;
} }
#endif #endif
ENDD(d1); ENDD(d1);
ENDCACHE_TR(); ENDCACHE_TR();
} }
#ifdef COROUTINING #ifdef COROUTINING
NoStackFail: NoStackFail:
BEGD(d0); BEGD(d0);
#ifdef SHADOW_S #ifdef SHADOW_S
Yap_REGS.S_ = SREG; Yap_REGS.S_ = SREG;
#endif #endif
saveregs(); saveregs();
d0 = interrupt_fail(PASS_REGS1); d0 = interrupt_fail(PASS_REGS1);
setregs(); setregs();
#ifdef SHADOW_S #ifdef SHADOW_S
SREG = Yap_REGS.S_; SREG = Yap_REGS.S_;
#endif #endif
if (!d0) if (!d0)
FAIL(); FAIL();
JMPNext(); JMPNext();
ENDD(d0); ENDD(d0);
#endif /* COROUTINING */ #endif /* COROUTINING */
ENDPBOp(); ENDPBOp();
#ifdef INDENT_CODE #ifdef INDENT_CODE
} }
#endif /* INDENT_CODE */ #endif /* INDENT_CODE */

2
C/text.c
View File

@@ -537,7 +537,7 @@ static Term write_strings(unsigned char *s0, seq_tv_t *out,
} }
} }
char *s = (char *)s0, *lim = s + max; char *s = (char *)s0;
Term t = init_tstring(PASS_REGS1); Term t = init_tstring(PASS_REGS1);
LOCAL_TERM_ERROR(t, 2 * max); LOCAL_TERM_ERROR(t, 2 * max);
unsigned char *buf = buf_from_tstring(HR); unsigned char *buf = buf_from_tstring(HR);

4
C/tracer.c
View File

@@ -354,7 +354,7 @@ bool low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
printf("\n"); printf("\n");
} }
#endif #endif
b += snprintf(b, top - b, Int_FORMAT " "UInt_FORMAT " ", vsc_count, LCL0 - (CELL *)B); b += snprintf(b, top - b, "%llud "UInt_FORMAT " ", vsc_count, LCL0 - (CELL *)B);
b += snprintf(b, top - b, Int_FORMAT " ", LCL0 - (CELL *)Yap_REGS.CUT_C_TOP); b += snprintf(b, top - b, Int_FORMAT " ", LCL0 - (CELL *)Yap_REGS.CUT_C_TOP);
#if defined(THREADS) || defined(YAPOR) #if defined(THREADS) || defined(YAPOR)
b += snprintf(b, top - b, "(%d)", worker_id); b += snprintf(b, top - b, "(%d)", worker_id);
@@ -482,7 +482,7 @@ static Int reset_total_choicepoints(USES_REGS1) {
} }
static Int show_low_level_trace(USES_REGS1) { static Int show_low_level_trace(USES_REGS1) {
fprintf(stderr, "Call counter=" Int_FORMAT "\n", vsc_count); fprintf(stderr, "Call counter=%lld\n", vsc_count);
return (TRUE); return (TRUE);
} }

2
C/write.c
View File

@@ -610,7 +610,7 @@ static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
while (*s) { while (*s) {
int32_t ch; int32_t ch;
s += get_utf8(s, 1, &ch); s += get_utf8(s, 1, &ch);
write_quoted(ch, '\'', stream); write_quoted( ch, '\'', stream);
} }
wrputc('\'', stream); wrputc('\'', stream);
} else { } else {

14
H/trim_trail.h
View File

@@ -1,8 +1,7 @@
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
{ {
tr_fr_ptr pt0, pt1, pbase; tr_fr_ptr pt0, pt1, pbase, ptop;
restart: pbase = B->cp_tr, ptop = TR;
pbase = B->cp_tr;
pt0 = pt1 = TR - 1; pt0 = pt1 = TR - 1;
while (pt1 >= pbase) { while (pt1 >= pbase) {
BEGD(d1); BEGD(d1);
@@ -33,10 +32,7 @@
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (f == FunctorBigInt) { if (f == FunctorBigInt) {
Int tag = Yap_blob_tag(t) - USER_BLOB_START; Int tag = Yap_blob_tag(t) - USER_BLOB_START;
RESET_VARIABLE(&TrailTerm(pt1));
RESET_VARIABLE(&TrailVal(pt1));
GLOBAL_OpaqueHandlers[tag].cut_handler(d1); GLOBAL_OpaqueHandlers[tag].cut_handler(d1);
goto restart;
} else { } else {
pt0--; pt0--;
} }
@@ -91,8 +87,12 @@
if (pt0 != pt1) { if (pt0 != pt1) {
int size; int size;
pt0++; pt0++;
size = TR - pt0; size = ptop - pt0;
memmove(pbase, pt0, size * sizeof(struct trail_frame)); memmove(pbase, pt0, size * sizeof(struct trail_frame));
if (ptop != TR) {
memmove(pbase + size, ptop, (TR - ptop) * sizeof(struct trail_frame));
size += (TR - ptop);
}
TR = pbase + size; TR = pbase + size;
} }
} }

2
include/VFS.h
View File

@@ -113,7 +113,7 @@ extern VFS_t *GLOBAL_VFS;
extern void init_android_stream(void); extern void init_android_stream(void);
extern void Yap_InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp); extern void Yap_InitStdStream(int sno, unsigned int flags, FILE *file, VFS_t *vfsp);
static inline VFS_t *vfs_owner(const char *fname) { static inline VFS_t *vfs_owner(const char *fname) {
VFS_t *me = GLOBAL_VFS; VFS_t *me = GLOBAL_VFS;

29
include/YapInterface.h
View File

@@ -7,9 +7,9 @@
* * * *
************************************************************************** **************************************************************************
* * * *
* File: YapInterface.h * * File: YapInterface.h *
* Last rev: 19/2/88 * * Last rev: 19/2/88 *
* mods: * * mods: *
* comments: c_interface header file for YAP * * comments: c_interface header file for YAP *
* * * *
*************************************************************************/ *************************************************************************/
@@ -79,7 +79,6 @@ __BEGIN_DECLS
#include "YapFormat.h" #include "YapFormat.h"
/* Primitive Functions */ /* Primitive Functions */
#define YAP_Deref(t) (t) #define YAP_Deref(t) (t)
@@ -661,18 +660,18 @@ extern X_API int YAP_RequiresExtraStack(size_t);
* *
* @return * @return
*/ /* */ /*
* proccess command line arguments: valid switches are: * proccess command line arguments: valid switches are:
* -b boot file * -b boot file
* -l load file * -l load file
* -L load file, followed by exit. * -L load file, followed by exit.
* -s stack area size (K) * -s stack area size (K)
* -h heap area size * -h heap area size
* -a aux stack size * -a aux stack size
* -e emacs_mode -m * -e emacs_mode -m
* -DVar=Value * -DVar=Value
* reserved memory for alloc IF DEBUG * reserved memory for alloc IF DEBUG
* -P only in development versions * -P only in development versions
*/ */
extern X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[], extern X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[],
YAP_init_args *iap); YAP_init_args *iap);