From e3ab36f091705b868c796f607943620985ff3a20 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Wed, 6 Sep 2017 01:13:00 +0100 Subject: [PATCH] call cleanup --- C/fail_absmi_insts.h | 712 +++++++++++++++++++---------------------- C/text.c | 2 +- C/tracer.c | 4 +- C/write.c | 2 +- H/trim_trail.h | 14 +- include/VFS.h | 2 +- include/YapInterface.h | 29 +- 7 files changed, 361 insertions(+), 404 deletions(-) diff --git a/C/fail_absmi_insts.h b/C/fail_absmi_insts.h index d3d725cb9..5d31b381e 100644 --- a/C/fail_absmi_insts.h +++ b/C/fail_absmi_insts.h @@ -6,455 +6,413 @@ { #endif /* INDENT_CODE */ - /* trust_fail */ - BOp(trust_fail, e); - { - while (POP_CHOICE_POINT(B->cp_b)) - { - POP_EXECUTE(); - } - } + /* trust_fail */ + BOp(trust_fail, e); + { + while (POP_CHOICE_POINT(B->cp_b)) { + POP_EXECUTE(); + } + } #ifdef YAPOR - { - choiceptr cut_pt; - cut_pt = B->cp_b; - CUT_prune_to(cut_pt); - B = cut_pt; - } + { + choiceptr cut_pt; + cut_pt = B->cp_b; + CUT_prune_to(cut_pt); + B = cut_pt; + } #else - B = B->cp_b; + B = B->cp_b; #endif /* YAPOR */ - goto fail; - ENDBOp(); + goto fail; + ENDBOp(); #ifdef YAPOR shared_fail: - B = Get_LOCAL_top_cp(); - SET_BB(PROTECT_FROZEN_B(B)); - goto fail; + B = Get_LOCAL_top_cp(); + SET_BB(PROTECT_FROZEN_B(B)); + goto fail; #endif /* YAPOR */ - /* fail */ - PBOp(op_fail, e); + /* fail */ + PBOp(op_fail, e); - if (PP) - { - UNLOCK(PP->PELock); - PP = NULL; - } + if (PP) { + UNLOCK(PP->PELock); + PP = NULL; + } #ifdef COROUTINING - CACHE_Y_AS_ENV(YREG); - check_stack(NoStackFail, HR); - ENDCACHE_Y_AS_ENV(); + CACHE_Y_AS_ENV(YREG); + check_stack(NoStackFail, HR); + ENDCACHE_Y_AS_ENV(); #endif -fail: -{ - register tr_fr_ptr pt0 = TR; +fail : { + register tr_fr_ptr pt0 = TR; #if defined(YAPOR) || defined(THREADS) - if (PP) - { - UNLOCK(PP->PELock); - PP = NULL; - } + if (PP) { + UNLOCK(PP->PELock); + PP = NULL; + } #endif - PREG = B->cp_ap; - save_pc(); - CACHE_TR(B->cp_tr); - PREFETCH_OP(PREG); + PREG = B->cp_ap; + save_pc(); + CACHE_TR(B->cp_tr); + PREFETCH_OP(PREG); failloop: - if (pt0 == S_TR) - { - SP = SP0; + if (pt0 == S_TR) { + SP = SP0; #ifdef LOW_LEVEL_TRACER - if (Yap_do_low_level_trace) - { - int go_on = true; - yamop *ipc = PREG; + if (Yap_do_low_level_trace) { + int go_on = true; + yamop *ipc = PREG; - while (go_on) - { - op_numbers opnum = Yap_op_from_opcode(ipc->opc); + while (go_on) { + op_numbers opnum = Yap_op_from_opcode(ipc->opc); - go_on = false; - switch (opnum) - { + go_on = false; + switch (opnum) { #ifdef TABLING - case _table_load_answer: - low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); - break; - case _table_try_answer: - case _table_retry_me: - case _table_trust_me: - case _table_retry: - case _table_trust: - case _table_completion: + case _table_load_answer: + low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL); + break; + case _table_try_answer: + case _table_retry_me: + case _table_trust_me: + case _table_retry: + case _table_trust: + case _table_completion: #ifdef THREADS_CONSUMER_SHARING - case _table_answer_resolution_completion: + case _table_answer_resolution_completion: #endif /* THREADS_CONSUMER_SHARING */ #ifdef DETERMINISTIC_TABLING - if (IS_DET_GEN_CP(B)) - low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, NULL); - else + if (IS_DET_GEN_CP(B)) + low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry, + NULL); + else #endif /* DETERMINISTIC_TABLING */ - low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, (CELL *)(GEN_CP(B) + 1)); - break; - case _table_answer_resolution: - low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, NULL); - break; - case _trie_trust_var: - case _trie_retry_var: - case _trie_trust_var_in_pair: - case _trie_retry_var_in_pair: - case _trie_trust_val: - case _trie_retry_val: - case _trie_trust_val_in_pair: - case _trie_retry_val_in_pair: - case _trie_trust_atom: - case _trie_retry_atom: - case _trie_trust_atom_in_pair: - case _trie_retry_atom_in_pair: - case _trie_trust_null: - case _trie_retry_null: - case _trie_trust_null_in_pair: - case _trie_retry_null_in_pair: - case _trie_trust_pair: - case _trie_retry_pair: - case _trie_trust_appl: - case _trie_retry_appl: - case _trie_trust_appl_in_pair: - case _trie_retry_appl_in_pair: - case _trie_trust_extension: - case _trie_retry_extension: - case _trie_trust_double: - case _trie_retry_double: - case _trie_trust_longint: - case _trie_retry_longint: - case _trie_trust_gterm: - case _trie_retry_gterm: - low_level_trace(retry_table_loader, UndefCode, NULL); - break; + low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry, + (CELL *)(GEN_CP(B) + 1)); + break; + case _table_answer_resolution: + low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry, + NULL); + break; + case _trie_trust_var: + case _trie_retry_var: + case _trie_trust_var_in_pair: + case _trie_retry_var_in_pair: + case _trie_trust_val: + case _trie_retry_val: + case _trie_trust_val_in_pair: + case _trie_retry_val_in_pair: + case _trie_trust_atom: + case _trie_retry_atom: + case _trie_trust_atom_in_pair: + case _trie_retry_atom_in_pair: + case _trie_trust_null: + case _trie_retry_null: + case _trie_trust_null_in_pair: + case _trie_retry_null_in_pair: + case _trie_trust_pair: + case _trie_retry_pair: + case _trie_trust_appl: + case _trie_retry_appl: + case _trie_trust_appl_in_pair: + case _trie_retry_appl_in_pair: + case _trie_trust_extension: + case _trie_retry_extension: + case _trie_trust_double: + case _trie_retry_double: + case _trie_trust_longint: + case _trie_retry_longint: + case _trie_trust_gterm: + case _trie_retry_gterm: + low_level_trace(retry_table_loader, UndefCode, NULL); + break; #endif /* TABLING */ - case _or_else: - case _or_last: - low_level_trace(retry_or, NULL, NULL); - break; - case _retry2: - case _retry3: - case _retry4: - ipc = NEXTOP(ipc, l); - go_on = true; - break; - case _jump: - ipc = ipc->y_u.l.l; - go_on = true; - break; - case _retry_c: - case _retry_userc: - low_level_trace(retry_pred, ipc->y_u.OtapFs.p, B->cp_args); - break; - case _retry_profiled: - case _count_retry: - ipc = NEXTOP(ipc, p); - go_on = true; - break; - case _retry_me: - case _trust_me: - case _count_retry_me: - case _count_trust_me: - case _profiled_retry_me: - case _profiled_trust_me: - case _retry_and_mark: - case _profiled_retry_and_mark: - case _retry: - case _trust: - low_level_trace(retry_pred, ipc->y_u.Otapl.p, B->cp_args); - break; - case _try_logical: - case _retry_logical: - case _profiled_retry_logical: - case _count_retry_logical: - case _trust_logical: - case _profiled_trust_logical: - case _count_trust_logical: - low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, B->cp_args); - break; - case _Nstop: - case _Ystop: - low_level_trace(retry_pred, NULL, B->cp_args); - break; - default: - break; - } - } - } + case _or_else: + case _or_last: + low_level_trace(retry_or, NULL, NULL); + break; + case _retry2: + case _retry3: + case _retry4: + ipc = NEXTOP(ipc, l); + go_on = true; + break; + case _jump: + ipc = ipc->y_u.l.l; + go_on = true; + break; + case _retry_c: + case _retry_userc: + low_level_trace(retry_pred, ipc->y_u.OtapFs.p, B->cp_args); + break; + case _retry_profiled: + case _count_retry: + ipc = NEXTOP(ipc, p); + go_on = true; + break; + case _retry_me: + case _trust_me: + case _count_retry_me: + case _count_trust_me: + case _profiled_retry_me: + case _profiled_trust_me: + case _retry_and_mark: + case _profiled_retry_and_mark: + case _retry: + case _trust: + low_level_trace(retry_pred, ipc->y_u.Otapl.p, B->cp_args); + break; + case _try_logical: + case _retry_logical: + case _profiled_retry_logical: + case _count_retry_logical: + case _trust_logical: + case _profiled_trust_logical: + case _count_trust_logical: + low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, B->cp_args); + break; + case _Nstop: + case _Ystop: + low_level_trace(retry_pred, NULL, B->cp_args); + break; + default: + break; + } + } + } #endif /* LOW_LEVEL_TRACER */ #ifdef FROZEN_STACKS #ifdef YAPOR_SBA - if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop + MinTrailGap) + if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop + MinTrailGap) #else - if (pt0 < TR_FZ) + if (pt0 < TR_FZ) #endif /* YAPOR_SBA */ - { - TR = TR_FZ; - TRAIL_LINK(pt0); - } - else + { + TR = TR_FZ; + TRAIL_LINK(pt0); + } else #endif /* FROZEN_STACKS */ - RESTORE_TR(); - GONext(); - } - BEGD(d1); - d1 = TrailTerm(pt0 - 1); - pt0--; - if (IsVarTerm(d1)) - { + RESTORE_TR(); + GONext(); + } + BEGD(d1); + d1 = TrailTerm(pt0 - 1); + pt0--; + if (IsVarTerm(d1)) { #if defined(YAPOR_SBA) && defined(YAPOR) - /* clean up the trail when we backtrack */ - if (Unsigned((Int)(d1) - (Int)(H_FZ)) > - Unsigned((Int)(B_FZ) - (Int)(H_FZ))) - { - RESET_VARIABLE(STACK_TO_SBA(d1)); - } - else + /* clean up the trail when we backtrack */ + if (Unsigned((Int)(d1) - (Int)(H_FZ)) > + Unsigned((Int)(B_FZ) - (Int)(H_FZ))) { + RESET_VARIABLE(STACK_TO_SBA(d1)); + } else #endif - /* normal variable */ - RESET_VARIABLE(d1); - goto failloop; - } + /* normal variable */ + RESET_VARIABLE(d1); + goto failloop; + } /* pointer to code space */ /* or updatable variable */ -#if defined(TERM_EXTENSIONS) || defined(FROZEN_STACKS) || defined(MULTI_ASSIGNMENT_VARIABLES) - if (IsPairTerm(d1)) +#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); + { + register CELL flags; + CELL *pt1 = RepPair(d1); #ifdef LIMIT_TABLING - if ((ADDR)pt1 == LOCAL_TrailBase) - { - sg_fr_ptr sg_fr = (sg_fr_ptr)TrailVal(pt0); - TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); - SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use --> compiled */ - insert_into_global_sg_fr_list(sg_fr); - goto failloop; - } -#endif /* LIMIT_TABLING */ + if ((ADDR)pt1 == LOCAL_TrailBase) { + sg_fr_ptr sg_fr = (sg_fr_ptr)TrailVal(pt0); + TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1)); + SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use --> + compiled */ + insert_into_global_sg_fr_list(sg_fr); + goto failloop; + } +#endif /* LIMIT_TABLING */ #ifdef FROZEN_STACKS /* TRAIL */ - /* avoid frozen segments */ - if ( + /* avoid frozen segments */ + if ( #ifdef YAPOR_SBA - (ADDR)pt1 >= HeapTop + (ADDR)pt1 >= HeapTop #else - IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop + MinTrailGap) + IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop + MinTrailGap) #endif /* YAPOR_SBA */ - ) - { - pt0 = (tr_fr_ptr)pt1; - goto failloop; - } - else + ) { + pt0 = (tr_fr_ptr)pt1; + goto failloop; + } else #endif /* FROZEN_STACKS */ - if (IN_BETWEEN(H0, pt1, HR)) - { - if (IsAttVar(pt1)) - { - goto failloop; - } - else - { - TR = pt0; - Yap_CleanOpaqueVariable(d1); - goto fail; - } - } + if (IN_BETWEEN(H0, pt1, HR)) { + if (IsAttVar(pt1)) { + goto failloop; + } else { + TR = pt0; + Yap_CleanOpaqueVariable(d1); + + goto failloop; + } + } #ifdef FROZEN_STACKS /* TRAIL */ - /* don't reset frozen variables */ - if (pt0 < TR_FZ) - goto failloop; + /* don't reset frozen variables */ + if (pt0 < TR_FZ) + goto failloop; #endif - flags = *pt1; + flags = *pt1; #if MULTIPLE_STACKS - if (FlagOn(DBClMask, flags)) - { - DBRef dbr = DBStructFlagsToDBStruct(pt1); - int erase; + if (FlagOn(DBClMask, flags)) { + DBRef dbr = DBStructFlagsToDBStruct(pt1); + int erase; - LOCK(dbr->lock); - DEC_DBREF_COUNT(dbr); - erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); - UNLOCK(dbr->lock); - if (erase) - { - saveregs(); - Yap_ErDBE(dbr); - setregs(); - } - } - else - { - if (flags & LogUpdMask) - { - if (flags & IndexMask) - { - LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); - int erase; + LOCK(dbr->lock); + DEC_DBREF_COUNT(dbr); + erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0); + UNLOCK(dbr->lock); + if (erase) { + saveregs(); + Yap_ErDBE(dbr); + setregs(); + } + } else { + if (flags & LogUpdMask) { + if (flags & IndexMask) { + LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1); + int erase; #if PARALLEL_YAP - PredEntry *ap = cl->ClPred; + PredEntry *ap = cl->ClPred; #endif - PELOCK(8, ap); - DEC_CLREF_COUNT(cl); - erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); - if (erase) - { - saveregs(); - /* at this point, - we are the only ones accessing the clause, - hence we don't need to have a lock it */ - Yap_ErLogUpdIndex(cl); - setregs(); - } - else if (cl->ClFlags & DirtyMask) - { - saveregs(); - /* at this point, - we are the only ones accessing the clause, - hence we don't need to have a lock it */ - Yap_CleanUpIndex(cl); - setregs(); - } - UNLOCK(ap->PELock); - } - else - { - LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); - int erase; + PELOCK(8, ap); + DEC_CLREF_COUNT(cl); + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); + if (erase) { + saveregs(); + /* at this point, +we are the only ones accessing the clause, +hence we don't need to have a lock it */ + Yap_ErLogUpdIndex(cl); + setregs(); + } else if (cl->ClFlags & DirtyMask) { + saveregs(); + /* at this point, +we are the only ones accessing the clause, +hence we don't need to have a lock it */ + Yap_CleanUpIndex(cl); + setregs(); + } + UNLOCK(ap->PELock); + } else { + LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1); + int erase; #if PARALLEL_YAP - PredEntry *ap = cl->ClPred; + PredEntry *ap = cl->ClPred; #endif - /* BB support */ - if (ap) - { + /* BB support */ + if (ap) { - PELOCK(9, ap); - DEC_CLREF_COUNT(cl); - erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); - if (erase) - { - saveregs(); - /* at this point, - we are the only ones accessing the clause, - hence we don't need to have a lock it */ - Yap_ErLogUpdCl(cl); - setregs(); - } - UNLOCK(ap->PELock); - } - } - } - else - { - DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); - int erase; + PELOCK(9, ap); + DEC_CLREF_COUNT(cl); + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); + if (erase) { + saveregs(); + /* at this point, +we are the only ones accessing the clause, +hence we don't need to have a lock it */ + Yap_ErLogUpdCl(cl); + setregs(); + } + UNLOCK(ap->PELock); + } + } + } else { + DynamicClause *cl = ClauseFlagsToDynamicClause(pt1); + int erase; - LOCK(cl->ClLock); - DEC_CLREF_COUNT(cl); - erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); - UNLOCK(cl->ClLock); - if (erase) - { - saveregs(); - /* at this point, - we are the only ones accessing the clause, - hence we don't need to have a lock it */ - Yap_ErCl(cl); - setregs(); - } - } - } + LOCK(cl->ClLock); + DEC_CLREF_COUNT(cl); + erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount); + UNLOCK(cl->ClLock); + if (erase) { + saveregs(); + /* at this point, +we are the only ones accessing the clause, +hence we don't need to have a lock it */ + Yap_ErCl(cl); + setregs(); + } + } + } #else - ResetFlag(InUseMask, flags); - *pt1 = flags; - if (FlagOn((ErasedMask | DirtyMask), flags)) - { - if (FlagOn(DBClMask, flags)) - { - saveregs(); - Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); - setregs(); - } - else - { - saveregs(); - if (flags & LogUpdMask) - { - if (flags & IndexMask) - { - if (FlagOn(ErasedMask, flags)) - { - Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); - } - else - { - Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); - } - } - else - { - Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); - } - } - else - { - Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); - } - setregs(); - } - } + ResetFlag(InUseMask, flags); + *pt1 = flags; + if (FlagOn((ErasedMask | DirtyMask), flags)) { + if (FlagOn(DBClMask, flags)) { + saveregs(); + Yap_ErDBE(DBStructFlagsToDBStruct(pt1)); + setregs(); + } else { + saveregs(); + if (flags & LogUpdMask) { + if (flags & IndexMask) { + if (FlagOn(ErasedMask, flags)) { + Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1)); + } else { + Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1)); + } + } else { + Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1)); + } + } else { + Yap_ErCl(ClauseFlagsToDynamicClause(pt1)); + } + setregs(); + } + } #endif - goto failloop; - } + goto failloop; + } #ifdef MULTI_ASSIGNMENT_VARIABLES - else /* if (IsApplTerm(d1)) */ - { - CELL *pt = RepAppl(d1); + else /* if (IsApplTerm(d1)) */ + { + CELL *pt = RepAppl(d1); /* AbsAppl means */ /* multi-assignment variable */ /* so the next cell is the old value */ #ifdef FROZEN_STACKS - --pt0; - pt[0] = TrailVal(pt0); + --pt0; + pt[0] = TrailVal(pt0); #else - pt[0] = TrailTerm(pt0 - 1); - pt0 -= 2; + pt[0] = TrailTerm(pt0 - 1); + pt0 -= 2; #endif /* FROZEN_STACKS */ - goto failloop; - } + goto failloop; + } #endif - ENDD(d1); - ENDCACHE_TR(); + ENDD(d1); + ENDCACHE_TR(); } #ifdef COROUTINING NoStackFail: - BEGD(d0); + BEGD(d0); #ifdef SHADOW_S - Yap_REGS.S_ = SREG; + Yap_REGS.S_ = SREG; #endif - saveregs(); - d0 = interrupt_fail(PASS_REGS1); - setregs(); + saveregs(); + d0 = interrupt_fail(PASS_REGS1); + setregs(); #ifdef SHADOW_S - SREG = Yap_REGS.S_; + SREG = Yap_REGS.S_; #endif - if (!d0) - FAIL(); - JMPNext(); - ENDD(d0); + if (!d0) + FAIL(); + JMPNext(); + ENDD(d0); #endif /* COROUTINING */ - ENDPBOp(); + ENDPBOp(); #ifdef INDENT_CODE } #endif /* INDENT_CODE */ diff --git a/C/text.c b/C/text.c index 3f2987181..d4ea06e28 100644 --- a/C/text.c +++ b/C/text.c @@ -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); LOCAL_TERM_ERROR(t, 2 * max); unsigned char *buf = buf_from_tstring(HR); diff --git a/C/tracer.c b/C/tracer.c index faa196c13..0a606efca 100644 --- a/C/tracer.c +++ b/C/tracer.c @@ -354,7 +354,7 @@ bool low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) { printf("\n"); } #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); #if defined(THREADS) || defined(YAPOR) 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) { - fprintf(stderr, "Call counter=" Int_FORMAT "\n", vsc_count); + fprintf(stderr, "Call counter=%lld\n", vsc_count); return (TRUE); } diff --git a/C/write.c b/C/write.c index eaaa236a0..4f1d150dd 100644 --- a/C/write.c +++ b/C/write.c @@ -610,7 +610,7 @@ static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) { while (*s) { int32_t ch; s += get_utf8(s, 1, &ch); - write_quoted(ch, '\'', stream); + write_quoted( ch, '\'', stream); } wrputc('\'', stream); } else { diff --git a/H/trim_trail.h b/H/trim_trail.h index a35efcac5..8579272d3 100644 --- a/H/trim_trail.h +++ b/H/trim_trail.h @@ -1,8 +1,7 @@ #ifdef FROZEN_STACKS { - tr_fr_ptr pt0, pt1, pbase; - restart: - pbase = B->cp_tr; + tr_fr_ptr pt0, pt1, pbase, ptop; + pbase = B->cp_tr, ptop = TR; pt0 = pt1 = TR - 1; while (pt1 >= pbase) { BEGD(d1); @@ -33,10 +32,7 @@ Functor f = FunctorOfTerm(t); if (f == FunctorBigInt) { Int tag = Yap_blob_tag(t) - USER_BLOB_START; - RESET_VARIABLE(&TrailTerm(pt1)); - RESET_VARIABLE(&TrailVal(pt1)); GLOBAL_OpaqueHandlers[tag].cut_handler(d1); - goto restart; } else { pt0--; } @@ -91,8 +87,12 @@ if (pt0 != pt1) { int size; pt0++; - size = TR - pt0; + size = ptop - pt0; 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; } } diff --git a/include/VFS.h b/include/VFS.h index 7d00f707d..28894a957 100644 --- a/include/VFS.h +++ b/include/VFS.h @@ -113,7 +113,7 @@ extern VFS_t *GLOBAL_VFS; 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) { VFS_t *me = GLOBAL_VFS; diff --git a/include/YapInterface.h b/include/YapInterface.h index 6c6c74eab..547b1e59d 100755 --- a/include/YapInterface.h +++ b/include/YapInterface.h @@ -7,9 +7,9 @@ * * ************************************************************************** * * - * File: YapInterface.h * + * File: YapInterface.h * * Last rev: 19/2/88 * - * mods: * + * mods: * * comments: c_interface header file for YAP * * * *************************************************************************/ @@ -79,7 +79,6 @@ __BEGIN_DECLS #include "YapFormat.h" - /* Primitive Functions */ #define YAP_Deref(t) (t) @@ -661,18 +660,18 @@ extern X_API int YAP_RequiresExtraStack(size_t); * * @return */ /* - * proccess command line arguments: valid switches are: - * -b boot file - * -l load file - * -L load file, followed by exit. - * -s stack area size (K) - * -h heap area size - * -a aux stack size - * -e emacs_mode -m - * -DVar=Value - * reserved memory for alloc IF DEBUG - * -P only in development versions - */ + * proccess command line arguments: valid switches are: + * -b boot file + * -l load file + * -L load file, followed by exit. + * -s stack area size (K) + * -h heap area size + * -a aux stack size + * -e emacs_mode -m + * -DVar=Value + * reserved memory for alloc IF DEBUG + * -P only in development versions + */ extern X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[], YAP_init_args *iap);