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

call_cleanup in C plus indenting

Browse Source
This commit is contained in:
Vítor Santos Costa 2016-03-29 01:55:12 +01:00
parent fa69950c67
commit 1be002558c
17 changed files with 2014 additions and 2306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

814
C/absmi.c
View File

File diff suppressed because it is too large Load Diff

38
C/absmi_insts.h
View File

@ -8,8 +8,8 @@
{
#endif /* INDENT_CODE */
BOp(Ystop, l);
LOCAL_CBorder = 0;
SET_ASP(YREG, E_CB * sizeof(CELL));
/* make sure ASP is initialized */
saveregs();
@ -20,6 +20,7 @@ BOp(Ystop, l);
#if BP_FREE
P1REG = PCBACKUP;
#endif
LOCAL_CBorder = 0;
return 1;
ENDBOp();
@ -32,18 +33,19 @@ BOp(Ystop, l);
#if BP_FREE
P1REG = PCBACKUP;
#endif
if (LOCAL_Error_TYPE == THROW_EVENT) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return 1;
}
return 0;
ENDBOp();
/************************************************************************\
* Native Code Execution *
\************************************************************************/
#if YAP_JIT
static void *OpAddress_JIT[] =
{
static void *OpAddress_JIT[] = {
#define OPCODE(OP, TYPE) &&_##OP
#include "YapOpcodes.h"
#undef OPCODE
@ -51,19 +53,23 @@ BOp(Ystop, l);
/* native_me */
BOp(jit_handler, J);
if (!PREG->y_u.J.jh->fi.bcst.c) PREG->y_u.J.jh->mf.isground = IsGround(PREG);
if (!PREG->y_u.J.jh->fi.bcst.c)
PREG->y_u.J.jh->mf.isground = IsGround(PREG);
PREG->y_u.J.jh->fi.bcst.c++;
/* Did PREG reach threshold value to become critical? */
if (PREG->y_u.J.jh->fi.bcst.c == (COUNT)(ExpEnv.config_struc.frequency_bound*(ExpEnv.config_struc.profiling_startp)) && !PREG->y_u.J.jh->mf.isground) {
if (PREG->y_u.J.jh->fi.bcst.c ==
(COUNT)(ExpEnv.config_struc.frequency_bound *
(ExpEnv.config_struc.profiling_startp)) &&
!PREG->y_u.J.jh->mf.isground) {
#if YAP_DBG_PREDS
if (ExpEnv.debug_struc.pprint_me.criticals != 0 && ExpEnv.debug_struc.pprint_me.criticals != 0x1) {
if (ExpEnv.debug_struc.pprint_me.criticals != 0 &&
ExpEnv.debug_struc.pprint_me.criticals != 0x1) {
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
fprintf(stderr, "%s", (char *)ExpEnv.debug_struc.pprint_me.criticals);
}
#endif
traced_absmi();
}
#if YAP_DBG_PREDS
print_main_when_head(PREG, ON_INTERPRETER);
@ -73,14 +79,14 @@ BOp(Ystop, l);
ENDBOp();
#endif
#include "cp_absmi_insts.h"
#include "lu_absmi_insts.h"
#include "fail_absmi_insts.h"
#include "control_absmi_insts.h"
#include "unify_absmi_insts.h"
#include "cp_absmi_insts.h"
#include "fail_absmi_insts.h"
#include "fli_absmi_insts.h"
#include "or_absmi_insts.h"
#include "index_absmi_insts.h"
#include "type_absmi_insts.h"
#include "prim_absmi_insts.h"
#include "lu_absmi_insts.h"
#include "meta_absmi_insts.h"
#include "or_absmi_insts.h"
#include "prim_absmi_insts.h"
#include "type_absmi_insts.h"
#include "unify_absmi_insts.h"

3
C/absmi_insts.i
View File

@ -6440,7 +6440,8 @@
#endif /* YAPOR */
CACHE_Y(YREG);
/* Alocate space for the cut_c structure*/
CUT_C_PUSH(NEXTOP(NEXTOP(PREG,OtapFs),OtapFs),S_YREG);
(NEXTOP(NEXTOP(PREG,OtapFs),OtapFs),S_YREG);
S_YREG = S_YREG - PREG->y_u.OtapFs.extra;
store_args(PREG->y_u.OtapFs.s);
store_yaam_regs(NEXTOP(PREG, OtapFs), 0);

181
C/c_interface.c
View File

@ -25,12 +25,12 @@
#define C_INTERFACE_C 1
#include <stdlib.h>
#include "Yap.h"
#include "attvar.h"
#include "clause.h"
#include "yapio.h"
#include "Foreign.h"
#include "attvar.h"
#include <stdlib.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
@ -53,8 +53,8 @@
#ifdef YAPOR
#include "or.macros.h"
#endif /* YAPOR */
#include "threads.h"
#include "cut_c.h"
#include "threads.h"
#if HAVE_MALLOC_H
#include <malloc.h>
#endif
@ -987,7 +987,7 @@ static uintptr_t execute_cargs_back(PredEntry *pe, CPredicate exec_code,
static uintptr_t complete_fail(choiceptr ptr, int has_cp USES_REGS) {
// this case is easy, jut be sure to throw everything
// after the old B;
while (B != ptr) {
while (B && B->cp_b && B->cp_b <= ptr) {
B = B->cp_b;
}
if (has_cp)
@ -1066,14 +1066,7 @@ Int YAP_Execute(PredEntry *pe, CPredicate exec_code) {
complete_fail(((choiceptr)(LCL0 - OASP)), FALSE PASS_REGS);
// CurrentModule = omod;
if (!ret) {
Term t;
LOCAL_BallTerm = EX;
EX = NULL;
if ((t = Yap_GetException())) {
Yap_JumpToEnv(t);
return FALSE;
}
Yap_RaiseException();
}
return ret;
}
@ -1107,15 +1100,8 @@ Int YAP_ExecuteFirst(PredEntry *pe, CPredicate exec_code) {
Yap_CloseSlots(CurSlot);
PP = NULL;
if (val == 0) {
Term t;
LOCAL_BallTerm = EX;
EX = NULL;
if ((t = Yap_GetException())) {
cut_c_pop();
B = B->cp_b;
Yap_JumpToEnv(t);
return FALSE;
if (Yap_RaiseException()) {
return false;
}
return complete_fail(((choiceptr)(LCL0 - ocp)), TRUE PASS_REGS);
} else if (val == 1) { /* TRUE */
@ -1132,14 +1118,7 @@ Int YAP_ExecuteFirst(PredEntry *pe, CPredicate exec_code) {
Int ret = (exec_code)(PASS_REGS1);
Yap_CloseSlots(CurSlot);
if (!ret) {
Term t;
LOCAL_BallTerm = EX;
EX = NULL;
if ((t = Yap_GetException())) {
Yap_JumpToEnv(t);
return FALSE;
}
Yap_RaiseException();
}
return ret;
}
@ -1148,13 +1127,16 @@ Int YAP_ExecuteFirst(PredEntry *pe, CPredicate exec_code) {
Int YAP_ExecuteOnCut(PredEntry *pe, CPredicate exec_code,
struct cut_c_str *top) {
CACHE_REGS
choiceptr oB = B;
Int oB = LCL0-(CELL*)B;
Int val;
/* for slots to work */
yhandle_t CurSlot = Yap_StartSlots();
/* find out where we belong */
while (B->cp_b < (choiceptr)top)
while (B < (choiceptr)top) {
oB = LCL0 - (CELL *)B;
B = B->cp_b;
}
PP = pe;
if (pe->PredFlags & (SWIEnvPredFlag | CArgsPredFlag)) {
// SWI Emulation
@ -1163,7 +1145,7 @@ Int YAP_ExecuteOnCut(PredEntry *pe, CPredicate exec_code,
(struct foreign_context *)(&EXTRA_CBACK_ARG(pe->ArityOfPE, 1));
CELL *args = B->cp_args;
B = oB;
B = (choiceptr)(LCL0 - oB);
ctx->control = FRG_CUTTED;
ctx->engine = NULL; //(PL_local_data *)Yap_regp;
if (pe->PredFlags & CArgsPredFlag) {
@ -1172,27 +1154,22 @@ Int YAP_ExecuteOnCut(PredEntry *pe, CPredicate exec_code,
val = codev(Yap_InitSlots(pe->ArityOfPE, args), 0, ctx);
}
} else {
Int oYENV = LCL0 - YENV;
yamop *oP = P, *oCP = CP;
// YAP Native
B = (choiceptr)(LCL0 - oB);
val = exec_code(PASS_REGS1);
B = oB;
YENV = LCL0 - oYENV;
P = oP;
CP = oCP;
}
Yap_CloseSlots(CurSlot);
PP = NULL;
// B = LCL0-(CELL*)oB;
if (val == 0) {
Term t;
LOCAL_BallTerm = EX;
EX = NULL;
if ((t = Yap_GetException())) {
cut_c_pop();
Yap_JumpToEnv(t);
return FALSE;
}
return FALSE;
if (false && Yap_RaiseException()) {
return false;
} else { /* TRUE */
return TRUE;
return true;
}
}
@ -1220,14 +1197,7 @@ Int YAP_ExecuteNext(PredEntry *pe, CPredicate exec_code) {
/* make sure we clean up the frames left by the user */
PP = NULL;
if (val == 0) {
Term t;
LOCAL_BallTerm = EX;
EX = NULL;
if ((t = Yap_GetException())) {
cut_c_pop();
B = B->cp_b;
Yap_JumpToEnv(t);
if (Yap_RaiseException()) {
return FALSE;
} else {
return complete_fail(((choiceptr)(LCL0 - ocp)), TRUE PASS_REGS);
@ -1246,14 +1216,7 @@ Int YAP_ExecuteNext(PredEntry *pe, CPredicate exec_code) {
Int ret = (exec_code)(PASS_REGS1);
Yap_CloseSlots(CurSlot);
if (!ret) {
Term t;
LOCAL_BallTerm = EX;
EX = NULL;
if ((t = Yap_GetException())) {
Yap_JumpToEnv(t);
return FALSE;
}
Yap_RaiseException();
}
return ret;
}
@ -1292,6 +1255,7 @@ X_API void *YAP_ReallocSpaceFromYap(void *ptr, size_t size) {
RECOVER_MACHINE_REGS();
return new_ptr;
}
X_API void *YAP_AllocSpaceFromYap(size_t size) {
CACHE_REGS
void *ptr;
@ -1531,8 +1495,8 @@ X_API Term YAP_NWideBufferToAtomList(const wchar_t *s, size_t len) {
}
/* copy a string of size len to a buffer */
X_API Term
YAP_NWideBufferToAtomDiffList(const wchar_t *s, Term t0, size_t len) {
X_API Term YAP_NWideBufferToAtomDiffList(const wchar_t *s, Term t0,
size_t len) {
Term t;
BACKUP_H();
@ -1802,16 +1766,11 @@ X_API Int YAP_RunGoal(Term t) {
LOCAL_AllowRestart = FALSE;
LOCAL_PrologMode = UserMode;
out = Yap_RunTopGoal(t);
out = Yap_RunTopGoal(t, true);
LOCAL_PrologMode = UserCCallMode;
// should we catch the exception or pass it through?
// We'll pass it through
if (EX) {
Term ball = Yap_PopTermFromDB(EX);
EX = NULL;
Yap_JumpToEnv(ball);
return FALSE;
}
Yap_RaiseException();
if (out) {
P = (yamop *)ENV[E_CP];
ENV = (CELL *)ENV[E_E];
@ -1896,7 +1855,7 @@ X_API Int YAP_RunGoalOnce(Term t) {
CSlot = Yap_StartSlots();
LOCAL_PrologMode = UserMode;
// Yap_heap_regs->yap_do_low_level_trace=true;
out = Yap_RunTopGoal(t);
out = Yap_RunTopGoal(t, true);
LOCAL_PrologMode = oldPrologMode;
Yap_CloseSlots(CSlot);
if (!(oldPrologMode & UserCCallMode)) {
@ -1907,12 +1866,7 @@ X_API Int YAP_RunGoalOnce(Term t) {
}
// should we catch the exception or pass it through?
// We'll pass it through
if (EX) {
Term ball = Yap_PopTermFromDB(EX);
EX = NULL;
Yap_JumpToEnv(ball);
return FALSE;
}
Yap_RaiseException();
if (out) {
choiceptr cut_pt, ob;
@ -2044,47 +1998,16 @@ X_API void YAP_PruneGoal(YAP_dogoalinfo *gi) {
X_API bool YAP_GoalHasException(Term *t) {
CACHE_REGS
int out = FALSE;
BACKUP_MACHINE_REGS();
if (EX) {
do {
LOCAL_Error_TYPE = YAP_NO_ERROR;
*t = Yap_FetchTermFromDB(EX);
if (LOCAL_Error_TYPE == YAP_NO_ERROR) {
RECOVER_MACHINE_REGS();
return TRUE;
} else if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_growglobal(NULL)) {
Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil,
LOCAL_ErrorMessage);
RECOVER_MACHINE_REGS();
return FALSE;
}
} else {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_growstack(EX->NOfCells * CellSize)) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
RECOVER_MACHINE_REGS();
return FALSE;
}
}
} while (*t == (CELL)0);
out = TRUE;
}
RECOVER_MACHINE_REGS();
return out;
if (t)
*t = Yap_PeekException();
return Yap_PeekException();
}
X_API void YAP_ClearExceptions(void) {
CACHE_REGS
if (EX) {
LOCAL_BallTerm = EX;
}
EX = NULL;
Yap_ResetExceptionTerm(0);
LOCAL_UncaughtThrow = FALSE;
Yap_ResetException(worker_id);
}
X_API int YAP_InitConsult(int mode, const char *filename, int *osnop) {
@ -2154,7 +2077,6 @@ X_API Term YAP_Read(FILE *f) {
return o;
}
X_API Term YAP_ReadFromStream(int sno) {
Term o;
@ -2283,7 +2205,7 @@ static void do_bootfile(char *bootfilename USES_REGS) {
YAP_Reset(YAP_FULL_RESET);
Yap_StartSlots();
t = YAP_ReadClauseFromStream(bootfile);
// Yap_DebugPlWrite(t);fprintf(stderr, "\n");
//Yap_DebugPlWriteln(t);
if (t == 0) {
fprintf(stderr,
"[ SYNTAX ERROR: while parsing bootfile %s at line %d ]\n",
@ -2368,7 +2290,8 @@ Int YAP_Init(YAP_init_args *yap_init) {
GLOBAL_argc = yap_init->Argc;
#if BOOT_FROM_SAVED_STATE
if (!yap_init->SavedState) {
yap_init->SavedState = Yap_locateFile(YAP_STARTUP, boot_file, sizeof(boot_file)-1);
yap_init->SavedState =
Yap_locateFile(YAP_STARTUP, boot_file, sizeof(boot_file) - 1);
}
#else
@ -2717,24 +2640,30 @@ X_API void YAP_PredicateInfo(void *p, Atom *a, UInt *arity, Term *m) {
*m = TermProlog;
}
X_API void YAP_UserCPredicate(const char *name, CPredicate def, UInt arity) {
X_API void YAP_UserCPredicate(const char *name, CPredicate def, arity_t arity) {
Yap_InitCPred(name, arity, def, UserCPredFlag);
}
X_API void YAP_UserBackCPredicate(const char *name, CPredicate init,
CPredicate cont, UInt arity,
unsigned int extra) {
X_API void YAP_UserBackCPredicate_(const char *name, CPredicate init,
CPredicate cont, arity_t arity,
arity_t extra) {
Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag);
}
X_API void YAP_UserBackCutCPredicate(const char *name, CPredicate init,
CPredicate cont, CPredicate cut,
UInt arity, unsigned int extra) {
arity_t arity, arity_t extra) {
Yap_InitCPredBackCut(name, arity, extra, init, cont, cut, UserCPredFlag);
}
X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f, UInt arity,
Term mod) {
X_API void YAP_UserBackCPredicate(const char *name, CPredicate init,
CPredicate cont, arity_t arity,
arity_t extra) {
Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag);
}
X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f,
arity_t arity, Term mod) {
CACHE_REGS
PredEntry *pe;
Term cm = CurrentModule;
@ -3438,8 +3367,8 @@ X_API Int YAP_FunctorToInt(Functor f) {
Yap_PutAtomTranslation(At, arity, FunctorTranslations);
FunctorTranslations++;
if (FunctorTranslations == MaxFunctorTranslations) {
functor_t *nt =
(functor_t *)malloc(sizeof(functor_t) * 2 * MaxFunctorTranslations),
functor_t *nt = (functor_t *)malloc(sizeof(functor_t) * 2 *
MaxFunctorTranslations),
*ot = TR_Functors;
if (nt == NULL) {
Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At),

19
C/cdmgr.c
View File

@ -20,9 +20,9 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
#include "Yap.h"
#include "clause.h"
#include "yapio.h"
#include "eval.h"
#include "tracer.h"
#include "yapio.h"
#ifdef YAPOR
#include "or.macros.h"
#endif /* YAPOR */
@ -32,9 +32,9 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
#if HAVE_STRING_H
#include <string.h>
#endif
#include <assert.h>
#include <heapgc.h>
#include <iopreds.h>
#include <assert.h>
static void retract_all(PredEntry *, int);
static void add_first_static(PredEntry *, yamop *, int);
@ -63,7 +63,6 @@ static Int p_optimizer_on(USES_REGS1);
static Int p_optimizer_off(USES_REGS1);
static Int p_is_dynamic(USES_REGS1);
static Int p_kill_dynamic(USES_REGS1);
static Int p_compile_mode(USES_REGS1);
static Int p_is_profiled(USES_REGS1);
static Int p_profile_info(USES_REGS1);
static Int p_profile_reset(USES_REGS1);
@ -1936,7 +1935,6 @@ static Int p_compile(USES_REGS1) { /* '$compile'(+C,+Flags,+C0,-Ref) */
Term t1 = Deref(ARG2);
Term mod = Deref(ARG4);
yamop *code_adr;
int mode;
if (IsVarTerm(t1) || !IsAtomicTerm(t1))
return false;
@ -2712,18 +2710,6 @@ static Int p_optimizer_off(USES_REGS1) { /* '$optimizer_off' */
return (TRUE);
}
static Int p_compile_mode(USES_REGS1) { /* $compile_mode(Old,New) */
Term t2, t3 = MkIntTerm(compile_mode);
if (!Yap_unify_constant(ARG1, t3))
return (FALSE);
t2 = Deref(ARG2);
if (IsVarTerm(t2) || !IsIntTerm(t2))
return (FALSE);
compile_mode = IntOfTerm(t2) & 1;
return (TRUE);
}
static Int p_is_profiled(USES_REGS1) {
Term t = Deref(ARG1);
char *s;
@ -2908,7 +2894,6 @@ static Int p_clean_up_dead_clauses(USES_REGS1) {
}
void Yap_HidePred(PredEntry *pe) {
Prop p0 = AbsPredProp(pe);
pe->PredFlags |= (HiddenPredFlag | NoSpyPredFlag | NoTracePredFlag);
}

26
C/cp_absmi_insts.h
View File

@ -64,8 +64,7 @@
S_YREG = (CELL *)PROTECT_FROZEN_B(B_YREG);
#endif /* FROZEN_STACKS */
set_cut(S_YREG, B->cp_b);
}
else
} else
#endif /* YAPOR */
{
pop_yaam_regs();
@ -112,7 +111,8 @@
CACHE_Y(YREG);
{
struct index_t *i = (struct index_t *)(PREG->y_u.lp.l);
S_YREG[-1] = (CELL)LINK_TO_ADDRESS(i,i->links[EXO_ADDRESS_TO_OFFSET(i, SREG)]);
S_YREG[-1] =
(CELL)LINK_TO_ADDRESS(i, i->links[EXO_ADDRESS_TO_OFFSET(i, SREG)]);
}
S_YREG--;
/* store arguments for procedure */
@ -171,9 +171,7 @@
* register, but sometimes (X86) not. In this case, have a
* new register to point at YREG =*/
CACHE_Y(YREG);
{
S_YREG[-1] = (CELL)SREG; /* the udi code did S = (CELL*)judyp; */
}
{ S_YREG[-1] = (CELL)SREG; /* the udi code did S = (CELL*)judyp; */ }
S_YREG--;
/* store arguments for procedure */
store_at_least_one_arg(PREG->y_u.lp.p->ArityOfPE);
@ -235,7 +233,8 @@
CACHE_Y(B);
{
struct index_t *it = (struct index_t *)(PREG->y_u.lp.l);
BITS32 offset = ADDRESS_TO_LINK(it,(BITS32 *)((CELL *)(B+1))[it->arity]);
BITS32 offset =
ADDRESS_TO_LINK(it, (BITS32 *)((CELL *)(B + 1))[it->arity]);
d0 = it->links[offset];
((CELL *)(B + 1))[it->arity] = (CELL)LINK_TO_ADDRESS(it, d0);
SREG = EXO_OFFSET_TO_ADDRESS(it, offset);
@ -338,7 +337,8 @@
BEGD(d0);
CACHE_Y(B);
{
// struct udi_index_t *jp = (struct udi_index_t *)((CELL *)(B+1))[it->arity];
// struct udi_index_t *jp = (struct udi_index_t *)((CELL
// *)(B+1))[it->arity];
/* operation has a side-effect: S = (CELL*)NextClause */
saveregs();
d0 = 0L; // Yap_UDI_NextAlt(jp);
@ -494,8 +494,7 @@
S_YREG = (CELL *)PROTECT_FROZEN_B(B_YREG);
#endif /* FROZEN_STACKS */
set_cut(S_YREG, B->cp_b);
}
else
} else
#endif /* YAPOR */
{
pop_yaam_regs();
@ -616,8 +615,7 @@
S_YREG = (CELL *)PROTECT_FROZEN_B(B_YREG);
#endif /* FROZEN_STACKS */
set_cut(S_YREG, B->cp_b);
}
else
} else
#endif /* YAPOR */
{
pop_yaam_regs();
@ -821,7 +819,6 @@
JMPNext();
ENDBOp();
/************************************************************************\
* Try / Retry / Trust for main indexing blocks *
@ -990,8 +987,7 @@
S_YREG = (CELL *)PROTECT_FROZEN_B(B_YREG);
#endif /* FROZEN_STACKS */
set_cut(S_YREG, B->cp_b);
}
else
} else
#endif /* YAPOR */
{
pop_yaam_regs();

31
C/errors.c
View File

@ -262,6 +262,18 @@ static void error_exit_yap(int value) {
#endif
}
fprintf(stderr, "\n Exiting ....\n");
#if HAVE_BACKTRACE
void *callstack[256];
int i;
int frames = backtrace(callstack, 256);
char** strs = backtrace_symbols(callstack, frames);
fprintf(stderr, "Execution stack:\n");
for (i = 0; i < frames; ++i) {
fprintf(stderr, " %s\n", strs[i]);
}
free(strs);
#endif
Yap_exit(value);
}
@ -370,7 +382,7 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
CELL nt[3];
Functor fun;
bool serious;
Term tf, error_t, comment, culprit = TermNil;
Term tf, error_t, comment;
char *format;
char s[MAXPATHLEN];
@ -470,8 +482,8 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
IsApplTerm(where) &&
FunctorOfTerm(where) == FunctorError) {
error_t = where;
Yap_JumpToEnv(error_t);
P = (yamop *)FAILCODE;
Yap_JumpToEnv(error_t);
LOCAL_PrologMode &= ~InErrorMode;
return P;
}
@ -596,25 +608,14 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
LOCAL_Signals = 0;
CalculateStackGap(PASS_REGS1);
LOCAL_PrologMode &= ~InErrorMode;
/* we might be in the middle of a critical region */
if (LOCAL_InterruptsDisabled) {
LOCAL_InterruptsDisabled = 0;
LOCAL_UncaughtThrow = TRUE;
Yap_RestartYap(1);
}
#if DEBUG
// DumpActiveGoals( PASS_REGS1 );
#endif
/* wait if we we are in user code,
it's up to her to decide */
fun = FunctorError;
if (LOCAL_PrologMode & UserCCallMode) {
error_t = Yap_MkApplTerm(fun, 2, nt);
if (!(EX = Yap_StoreTermInDB(error_t, 2))) {
/* fat chance */
Yap_RestartYap(1);
}
} else {
if (type == ABORT_EVENT) {
error_t = MkAtomTerm(AtomDAbort);
} else {
@ -622,7 +623,7 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
}
Yap_JumpToEnv(error_t);
P = (yamop *)FAILCODE;
}
LOCAL_PrologMode &= ~InErrorMode;
return P;

771
C/exec.c
View File

File diff suppressed because it is too large Load Diff

74
C/fli_absmi_insts.h
View File

@ -2,7 +2,6 @@
* Call C predicates instructions *
\************************************************************************/
#ifdef INDENT_CODE
{
{
@ -11,7 +10,8 @@
BOp(call_cpred, Osbpp);
#if __ANDROID__ && STRONG_DEBUG
char *s; Atom name;
char *s;
Atom name;
if (PREG->y_u.Osbpp.p->ArityOfPE) {
Functor f = PREG->y_u.Osbpp.p->FunctorOfPred;
name = f->NameOfFE;
@ -23,7 +23,8 @@
LOG(" %s ", s);
#endif
check_trail(TR);
if (!(PREG->y_u.Osbpp.p->PredFlags & (SafePredFlag|NoTracePredFlag|HiddenPredFlag))) {
if (!(PREG->y_u.Osbpp.p->PredFlags &
(SafePredFlag | NoTracePredFlag | HiddenPredFlag))) {
CACHE_Y_AS_ENV(YREG);
check_stack(NoStackCCall, HR);
ENDCACHE_Y_AS_ENV();
@ -34,11 +35,14 @@
choiceptr top_b = PROTECT_FROZEN_B(B);
#ifdef YAPOR_SBA
if (YREG > (CELL *) top_b || YREG < HR) ASP = (CELL *)top_b;
if (YREG > (CELL *)top_b || YREG < HR)
ASP = (CELL *)top_b;
#else
if (YREG > (CELL *) top_b) ASP = (CELL *)top_b;
if (YREG > (CELL *)top_b)
ASP = (CELL *)top_b;
#endif /* YAPOR_SBA */
else ASP = (CELL *)(((char *)YREG) + PREG->y_u.Osbpp.s);
else
ASP = (CELL *)(((char *)YREG) + PREG->y_u.Osbpp.s);
}
#else
SET_ASP(YREG, PREG->y_u.Osbpp.s);
@ -86,11 +90,14 @@
choiceptr top_b = PROTECT_FROZEN_B(B);
#ifdef YAPOR_SBA
if (YREG > (CELL *) top_b || YREG < HR) ASP = (CELL *)top_b;
if (YREG > (CELL *)top_b || YREG < HR)
ASP = (CELL *)top_b;
#else
if (YREG > (CELL *) top_b) ASP = (CELL *)top_b;
if (YREG > (CELL *)top_b)
ASP = (CELL *)top_b;
#endif /* YAPOR_SBA */
else ASP = YREG+E_CB;
else
ASP = YREG + E_CB;
}
#else
SET_ASP(YREG, E_CB * sizeof(CELL));
@ -176,18 +183,22 @@
{
choiceptr top_b = PROTECT_FROZEN_B(B);
#ifdef YAPOR_SBA
if (YREG > (CELL *) top_b || YREG < HR) ASP = (CELL *) top_b;
if (YREG > (CELL *)top_b || YREG < HR)
ASP = (CELL *)top_b;
#else
if (YREG > (CELL *) top_b) ASP = (CELL *) top_b;
if (YREG > (CELL *)top_b)
ASP = (CELL *)top_b;
#endif /* YAPOR_SBA */
else ASP = (CELL *)(((char *)YREG) + PREG->y_u.Osbpp.s);
else
ASP = (CELL *)(((char *)YREG) + PREG->y_u.Osbpp.s);
}
#else
SET_ASP(YREG, PREG->y_u.Osbpp.s);
/* for slots to work */
#endif /* FROZEN_STACKS */
{
/* make sure that we can still have access to our old PREG after calling user defined goals and backtracking or failing */
/* make sure that we can still have access to our old PREG after calling
* user defined goals and backtracking or failing */
yamop *savedP;
LOCAL_PrologMode |= UserCCallMode;
@ -206,10 +217,8 @@
restore_machine_regs();
PREG = savedP;
}
if (EX) {
struct DB_TERM *exp = EX;
EX = NULL;
Yap_JumpToEnv(Yap_PopTermFromDB(exp));
if (Yap_HasException()) {
Yap_RaiseException();
SREG = NULL;
}
if (!SREG) {
@ -235,9 +244,11 @@
{
choiceptr top_b = PROTECT_FROZEN_B(B);
#ifdef YAPOR_SBA
if (YREG > (CELL *) top_b || YREG < HR) ASP = (CELL *) top_b;
if (YREG > (CELL *)top_b || YREG < HR)
ASP = (CELL *)top_b;
#else
if (YREG > (CELL *) top_b) ASP = (CELL *) top_b;
if (YREG > (CELL *)top_b)
ASP = (CELL *)top_b;
#endif /* YAPOR_SBA */
else {
BEGD(d0);
@ -282,7 +293,7 @@
CUT_C_PUSH(NEXTOP(NEXTOP(PREG, OtapFs), OtapFs), S_YREG);
S_YREG = S_YREG - PREG->y_u.OtapFs.extra;
store_args(PREG->y_u.OtapFs.s);
store_yaam_regs(NEXTOP(PREG, OtapFs), 0);
store_yaam_regs(NEXTOP(P, OtapFs), 0);
B = B_YREG;
#ifdef YAPOR
SCH_set_load(B_YREG);
@ -345,7 +356,8 @@
#ifdef DEBUG
/*If WAM executes this instruction, probably there's an error
when we put this instruction, cut_c, after retry_c*/
printf ("ERROR: Should not print this message FILE: absmi.c %d\n",__LINE__);
printf("ERROR: Should not print this message FILE: absmi.c %d\n",
__LINE__);
#endif /*DEBUG*/
ENDBOp();
@ -369,8 +381,9 @@
ASP = YREG;
saveregs();
save_machine_regs();
SREG = (CELL *) YAP_ExecuteFirst(PREG->y_u.OtapFs.p, (CPredicate)(PREG->y_u.OtapFs.f));
EX = NULL;
SREG = (CELL *)YAP_ExecuteFirst(PREG->y_u.OtapFs.p,
(CPredicate)(PREG->y_u.OtapFs.f));
Yap_ResetException( worker_id );
restore_machine_regs();
setregs();
LOCAL_PrologMode &= UserMode;
@ -409,8 +422,9 @@
SET_ASP(YREG, E_CB * sizeof(CELL));
saveregs();
save_machine_regs();
SREG = (CELL *) YAP_ExecuteNext(PREG->y_u.OtapFs.p, (CPredicate)(PREG->y_u.OtapFs.f));
EX = NULL;
SREG = (CELL *)YAP_ExecuteNext(PREG->y_u.OtapFs.p,
(CPredicate)(PREG->y_u.OtapFs.f));
Yap_ResetException( worker_id);
restore_machine_regs();
setregs();
LOCAL_PrologMode &= ~UserCCallMode;
@ -440,13 +454,13 @@
#ifdef DEBUG
/*If WAM executes this instruction, probably there's an error
when we put this instruction, cut_userc, after retry_userc*/
printf ("ERROR: Should not print this message FILE: absmi.c %d\n",__LINE__);
printf("ERROR: Should not print this message FILE: absmi.c %d\n",
__LINE__);
#endif /*DEBUG*/
CACHE_A1();
JMPNext();
ENDBOp();
/************************************************************************\
* support instructions *
\************************************************************************/
@ -470,7 +484,8 @@
SET_ASP(YREG, E_CB * sizeof(CELL));
saveregs();
Yap_IPred(ap, 0, CP);
/* IPred can generate errors, it thus must get rid of the lock itself */
/* IPred can generate errors, it thus must get rid of the lock itself
*/
setregs();
CACHE_A1();
/* for profiler */
@ -517,7 +532,6 @@
if (!PP)
#endif
UNLOCKPE(14, ap);
}
JMPNext();
ENDBOp();
@ -624,5 +638,3 @@
CACHE_A1();
JMPNext();
ENDBOp();

24
C/init.c
View File

@ -25,11 +25,12 @@ static char SccsId[] = "%W% %G%";
#define __INIT_C__ 1
#include <stdlib.h>
#include "Yap.h"
#include "alloc.h"
#include "clause.h"
#include "yapio.h"
#include "alloc.h"
#include <stdlib.h>
#include "Foreign.h"
#ifdef LOW_LEVEL_TRACER
@ -462,7 +463,7 @@ static UInt update_flags_from_prolog(UInt flags, PredEntry *pe) {
return flags;
}
void Yap_InitCPred(const char *Name, UInt Arity, CPredicate code,
void Yap_InitCPred(const char *Name, arity_t Arity, CPredicate code,
pred_flags_t flags) {
CACHE_REGS
Atom atom = NIL;
@ -606,7 +607,7 @@ bool Yap_AddCutToFli(PredEntry *pe, CPredicate CUT) {
}
}
void Yap_InitCmpPred(const char *Name, UInt Arity, CmpPredicate cmp_code,
void Yap_InitCmpPred(const char *Name, arity_t Arity, CmpPredicate cmp_code,
pred_flags_t flags) {
CACHE_REGS
Atom atom = NIL;
@ -685,7 +686,7 @@ void Yap_InitCmpPred(const char *Name, UInt Arity, CmpPredicate cmp_code,
p_code->y_u.l.l = cl->ClCode;
}
void Yap_InitAsmPred(const char *Name, UInt Arity, int code, CPredicate def,
void Yap_InitAsmPred(const char *Name, arity_t Arity, int code, CPredicate def,
pred_flags_t flags) {
CACHE_REGS
Atom atom = NIL;
@ -825,18 +826,18 @@ static void CleanBack(PredEntry *pe, CPredicate Start, CPredicate Cont,
code->y_u.OtapFs.f = Cut;
}
void Yap_InitCPredBack(const char *Name, UInt Arity, unsigned int Extra,
CPredicate Start, CPredicate Cont, pred_flags_t flags) {
Yap_InitCPredBack_(Name, Arity, Extra, Start, Cont, NULL, flags);
void Yap_InitCPredBack(const char *Name, arity_t Arity, arity_t Extra,
CPredicate Call, CPredicate Retry, pred_flags_t flags) {
Yap_InitCPredBack_(Name, Arity, Extra, Call, Retry, NULL, flags);
}
void Yap_InitCPredBackCut(const char *Name, UInt Arity, unsigned int Extra,
void Yap_InitCPredBackCut(const char *Name, arity_t Arity, arity_t Extra,
CPredicate Start, CPredicate Cont, CPredicate Cut,
pred_flags_t flags) {
Yap_InitCPredBack_(Name, Arity, Extra, Start, Cont, Cut, flags);
}
void Yap_InitCPredBack_(const char *Name, UInt Arity, unsigned int Extra,
void Yap_InitCPredBack_(const char *Name, arity_t Arity, arity_t Extra,
CPredicate Start, CPredicate Cont, CPredicate Cut,
pred_flags_t flags) {
CACHE_REGS
@ -1022,8 +1023,7 @@ static void InitLogDBErasedMarker(void) {
LogDBErasedMarker->ClExt = NULL;
LogDBErasedMarker->ClPrev = NULL;
LogDBErasedMarker->ClNext = NULL;
LogDBErasedMarker->ClSize =
(UInt)NEXTOP(((LogUpdClause *)NULL)->ClCode, e);
LogDBErasedMarker->ClSize = (UInt)NEXTOP(((LogUpdClause *)NULL)->ClCode, e);
LogDBErasedMarker->ClCode->opc = Yap_opcode(_op_fail);
INIT_CLREF_COUNT(LogDBErasedMarker);
}

37
C/modules.c
View File

@ -19,8 +19,8 @@ static char SccsId[] = "%W% %G%";
#endif
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "Yatom.h"
static Int current_module(USES_REGS1);
static Int current_module1(USES_REGS1);
@ -37,8 +37,7 @@ static ModEntry *FetchModuleEntry(Atom at);
*
* @return a new module structure
*/ /** */
static ModEntry *
initMod( AtomEntry *toname, AtomEntry *ae) {
static ModEntry *initMod(AtomEntry *toname, AtomEntry *ae) {
CACHE_REGS
ModEntry *n, *parent;
@ -67,8 +66,7 @@ initMod( AtomEntry *toname, AtomEntry *ae) {
*
* @return module descriptorxs
*/
static ModEntry *GetModuleEntry(Atom at USES_REGS)
{
static ModEntry *GetModuleEntry(Atom at USES_REGS) {
Prop p0;
AtomEntry *ae = RepAtom(at);
@ -84,12 +82,12 @@ initMod( AtomEntry *toname, AtomEntry *ae) {
}
READ_UNLOCK(ae->ARWLock);
return initMod( ( CurrentModule == PROLOG_MODULE ? NULL : AtomOfTerm( CurrentModule ) ), at );
return initMod(
(CurrentModule == PROLOG_MODULE ? NULL : AtomOfTerm(CurrentModule)), at);
}
/** get entry for ap/arity; assumes one is there. */
static ModEntry *FetchModuleEntry(Atom at)
{
static ModEntry *FetchModuleEntry(Atom at) {
Prop p0;
AtomEntry *ae = RepAtom(at);
@ -124,14 +122,13 @@ bool Yap_getUnknown ( Term mod) {
return Yap_getUnknownModule(m);
}
bool Yap_CharacterEscapes(Term mt) {
CACHE_REGS
if (mt == PROLOG_MODULE) mt = TermProlog;
if (mt == PROLOG_MODULE)
mt = TermProlog;
return GetModuleEntry(AtomOfTerm(mt) PASS_REGS)->flags & M_CHARESCAPE;
}
#define ByteAdr(X) ((char *)&(X))
Term Yap_Module_Name(PredEntry *ap) {
CACHE_REGS
@ -150,7 +147,6 @@ Term Yap_Module_Name(PredEntry *ap) {
else {
return ap->ModuleOfPred;
}
}
static ModEntry *LookupSystemModule(Term a) {
@ -158,7 +154,6 @@ static ModEntry *LookupSystemModule(Term a) {
Atom at;
ModEntry *me;
/* prolog module */
if (a == 0) {
a = TermProlog;
@ -172,7 +167,6 @@ static ModEntry *LookupSystemModule(Term a) {
return me;
}
static ModEntry *LookupModule(Term a) {
CACHE_REGS
Atom at;
@ -189,9 +183,7 @@ static ModEntry *LookupModule(Term a) {
bool Yap_isSystemModule(Term a) {
ModEntry *me = LookupModule(a);
return
me != NULL &&
me->flags & M_SYSTEM;
return me != NULL && me->flags & M_SYSTEM;
}
Term Yap_Module(Term tmod) {
@ -204,7 +196,6 @@ ModEntry *Yap_GetModuleEntry(Term mod) {
if (!(me = LookupModule(mod)))
return NULL;
return me;
}
Term Yap_GetModuleFromEntry(ModEntry *me) {
@ -270,7 +261,6 @@ static Int current_module1(USES_REGS1) { /* $current_module(Old)
return Yap_unify_constant(ARG1, TermProlog);
}
static Int cont_current_module(USES_REGS1) {
ModEntry *imod = AddressOfTerm(EXTRA_CBACK_ARG(1, 1)), *next;
Term t = MkAtomTerm(imod->AtomOfME);
@ -334,8 +324,7 @@ static Int init_ground_module(USES_REGS1) {
}
cut_fail();
}
if (!Yap_unify(ARG2, tmod) ||
!Yap_unify(ARG3, t3) ) {
if (!Yap_unify(ARG2, tmod) || !Yap_unify(ARG3, t3)) {
cut_fail();
}
// make sure we keep the binding
@ -352,8 +341,7 @@ static Int init_ground_module(USES_REGS1) {
*
* @return
*/
static Int is_system_module( USES_REGS1 )
{
static Int is_system_module(USES_REGS1) {
Term t;
if (IsVarTerm(t = Deref(ARG1))) {
return false;
@ -365,8 +353,7 @@ static Int is_system_module( USES_REGS1 )
return Yap_isSystemModule(t);
}
static Int new_system_module( USES_REGS1 )
{
static Int new_system_module(USES_REGS1) {
ModEntry *me;
Term t;
if (IsVarTerm(t = Deref(ARG1))) {

323
C/qlyr.c
View File

@ -17,11 +17,11 @@
*************************************************************************/
#include "absmi.h"
#include "Foreign.h"
#include "alloc.h"
#include "yapio.h"
#include "iopreds.h"
#include "attvar.h"
#include "iopreds.h"
#include "yapio.h"
#include <Foreign.h>
#if HAVE_STRING_H
#include <string.h>
#endif
@ -47,8 +47,8 @@ typedef enum {
BAD_HEADER = 12
} qlfr_err_t;
static char *
qlyr_error[] = { "out of temporary space",
static char *qlyr_error[] = {
"out of temporary space",
"out of temporary space",
"out of code space",
"unknown atom in saved space",
@ -61,9 +61,7 @@ qlyr_error[] = { "out of temporary space",
"foreign predicate has different definition in saved space",
"bad read"};
static char *
Yap_AlwaysAllocCodeSpace(UInt size)
{
static char *Yap_AlwaysAllocCodeSpace(UInt size) {
char *out;
while (!(out = Yap_AllocCodeSpace(size))) {
if (!Yap_growheap(FALSE, size, NULL)) {
@ -73,17 +71,15 @@ Yap_AlwaysAllocCodeSpace(UInt size)
return out;
}
static void
QLYR_ERROR(qlfr_err_t my_err)
{
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]);
Yap_Error(SYSTEM_ERROR_SAVED_STATE,TermNil,"error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]);
static void QLYR_ERROR(qlfr_err_t my_err) {
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %s in saved state
// %s",GLOBAL_RestoreFile, qlyr_error[my_err]);
Yap_Error(SYSTEM_ERROR_SAVED_STATE, TermNil, "error %s in saved state %s",
GLOBAL_RestoreFile, qlyr_error[my_err]);
Yap_exit(1);
}
static Atom
LookupAtom(Atom oat)
{
static Atom LookupAtom(Atom oat) {
CACHE_REGS
CELL hash = (CELL)(oat) % LOCAL_ImportAtomHashTableSize;
import_atom_hash_entry_t *a;
@ -95,14 +91,13 @@ LookupAtom(Atom oat)
}
a = a->next;
}
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %p in saved state ", oat);
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %p in saved state ",
// oat);
QLYR_ERROR(UNKNOWN_ATOM);
return NIL;
}
static void
InsertAtom(Atom oat, Atom at)
{
static void InsertAtom(Atom oat, Atom at) {
CACHE_REGS
CELL hash = (CELL)(oat) % LOCAL_ImportAtomHashTableSize;
import_atom_hash_entry_t *a;
@ -124,9 +119,7 @@ InsertAtom(Atom oat, Atom at)
LOCAL_ImportAtomHashChain[hash] = a;
}
static Functor
LookupFunctor(Functor ofun)
{
static Functor LookupFunctor(Functor ofun) {
CACHE_REGS
CELL hash = (CELL)(ofun) % LOCAL_ImportFunctorHashTableSize;
import_functor_hash_entry_t *f;
@ -142,9 +135,7 @@ LookupFunctor(Functor ofun)
return NIL;
}
static void
InsertFunctor(Functor ofun, Functor fun)
{
static void InsertFunctor(Functor ofun, Functor fun) {
CACHE_REGS
CELL hash = (CELL)(ofun) % LOCAL_ImportFunctorHashTableSize;
import_functor_hash_entry_t *f;
@ -156,7 +147,8 @@ InsertFunctor(Functor ofun, Functor fun)
}
f = f->next;
}
f = (import_functor_hash_entry_t *)malloc(sizeof(import_functor_hash_entry_t));
f = (import_functor_hash_entry_t *)malloc(
sizeof(import_functor_hash_entry_t));
if (!f) {
return;
}
@ -166,9 +158,7 @@ InsertFunctor(Functor ofun, Functor fun)
LOCAL_ImportFunctorHashChain[hash] = f;
}
static PredEntry *
LookupPredEntry(PredEntry *op)
{
static PredEntry *LookupPredEntry(PredEntry *op) {
CACHE_REGS
CELL hash;
import_pred_entry_hash_entry_t *p;
@ -187,9 +177,7 @@ LookupPredEntry(PredEntry *op)
return NIL;
}
static void
InsertPredEntry(PredEntry *op, PredEntry *pe)
{
static void InsertPredEntry(PredEntry *op, PredEntry *pe) {
CACHE_REGS
CELL hash;
import_pred_entry_hash_entry_t *p;
@ -204,7 +192,8 @@ InsertPredEntry(PredEntry *op, PredEntry *pe)
}
p = p->next;
}
p = (import_pred_entry_hash_entry_t *)malloc(sizeof(import_pred_entry_hash_entry_t));
p = (import_pred_entry_hash_entry_t *)malloc(
sizeof(import_pred_entry_hash_entry_t));
if (!p) {
return;
}
@ -214,9 +203,7 @@ InsertPredEntry(PredEntry *op, PredEntry *pe)
LOCAL_ImportPredEntryHashChain[hash] = p;
}
static OPCODE
LookupOPCODE(OPCODE op)
{
static OPCODE LookupOPCODE(OPCODE op) {
CACHE_REGS
CELL hash = (CELL)(op) % LOCAL_ImportOPCODEHashTableSize;
import_opcode_hash_entry_t *f;
@ -232,9 +219,7 @@ LookupOPCODE(OPCODE op)
return NIL;
}
static int
OpcodeID(OPCODE op)
{
static int OpcodeID(OPCODE op) {
CACHE_REGS
CELL hash = (CELL)(op) % LOCAL_ImportOPCODEHashTableSize;
import_opcode_hash_entry_t *f;
@ -250,9 +235,7 @@ OpcodeID(OPCODE op)
return NIL;
}
static void
InsertOPCODE(OPCODE op0, int i, OPCODE op)
{
static void InsertOPCODE(OPCODE op0, int i, OPCODE op) {
CACHE_REGS
CELL hash = (CELL)(op0) % LOCAL_ImportOPCODEHashTableSize;
import_opcode_hash_entry_t *f;
@ -274,9 +257,7 @@ InsertOPCODE(OPCODE op0, int i, OPCODE op)
LOCAL_ImportOPCODEHashChain[hash] = f;
}
static DBRef
LookupDBRef(DBRef dbr, int inc_ref)
{
static DBRef LookupDBRef(DBRef dbr, int inc_ref) {
CACHE_REGS
CELL hash;
import_dbref_hash_entry_t *p;
@ -298,9 +279,7 @@ LookupDBRef(DBRef dbr, int inc_ref)
return NIL;
}
static LogUpdClause *
LookupMayFailDBRef(DBRef dbr)
{
static LogUpdClause *LookupMayFailDBRef(DBRef dbr) {
CACHE_REGS
CELL hash;
import_dbref_hash_entry_t *p;
@ -319,9 +298,7 @@ LookupMayFailDBRef(DBRef dbr)
return NULL;
}
static void
InsertDBRef(DBRef dbr0, DBRef dbr)
{
static void InsertDBRef(DBRef dbr0, DBRef dbr) {
CACHE_REGS
CELL hash = (CELL)(dbr0) % LOCAL_ImportDBRefHashTableSize;
import_dbref_hash_entry_t *p;
@ -344,17 +321,15 @@ InsertDBRef(DBRef dbr0, DBRef dbr)
LOCAL_ImportDBRefHashChain[hash] = p;
}
static void
InitHash(void)
{
static void InitHash(void) {
CACHE_REGS
LOCAL_ImportOPCODEHashTableSize = EXPORT_OPCODE_TABLE_SIZE;
LOCAL_ImportOPCODEHashChain = (import_opcode_hash_entry_t **)calloc(1, sizeof(import_opcode_hash_entry_t *)* LOCAL_ImportOPCODEHashTableSize);
LOCAL_ImportOPCODEHashChain = (import_opcode_hash_entry_t **)calloc(
1,
sizeof(import_opcode_hash_entry_t *) * LOCAL_ImportOPCODEHashTableSize);
}
static void
CloseHash(void)
{
static void CloseHash(void) {
CACHE_REGS
UInt i;
for (i = 0; i < LOCAL_ImportFunctorHashTableSize; i++) {
@ -419,29 +394,18 @@ CloseHash(void)
LOCAL_ImportDBRefHashChain = NULL;
}
static inline Atom
AtomAdjust(Atom a)
{
return LookupAtom(a);
}
static inline Atom AtomAdjust(Atom a) { return LookupAtom(a); }
static inline Functor
FuncAdjust(Functor f)
{
static inline Functor FuncAdjust(Functor f) {
return LookupFunctor(f);
return f;
}
static inline Term
AtomTermAdjust(Term t)
{
static inline Term AtomTermAdjust(Term t) {
return MkAtomTerm(LookupAtom(AtomOfTerm(t)));
}
static inline Term
TermToGlobalOrAtomAdjust(Term t)
{
static inline Term TermToGlobalOrAtomAdjust(Term t) {
if (t && IsAtomTerm(t))
return AtomTermAdjust(t);
return t;
@ -471,9 +435,7 @@ TermToGlobalOrAtomAdjust(Term t)
#define MFileAdjust(P) (P)
#define CodeVarAdjust(P) CodeVarAdjust__(P PASS_REGS)
static inline Term
CodeVarAdjust__ (Term var USES_REGS)
{
static inline Term CodeVarAdjust__(Term var USES_REGS) {
if (var == 0L)
return var;
return (Term)(CharP(var) + LOCAL_HDiff);
@ -484,25 +446,17 @@ CodeVarAdjust__ (Term var USES_REGS)
#define DoubleInCodeAdjust(P)
#define IntegerInCodeAdjust(Pxb)
static inline PredEntry *
PtoPredAdjust(PredEntry *p)
{
static inline PredEntry *PtoPredAdjust(PredEntry *p) {
return LookupPredEntry(p);
}
static inline PredEntry *
PredEntryAdjust(PredEntry *p)
{
static inline PredEntry *PredEntryAdjust(PredEntry *p) {
return LookupPredEntry(p);
}
static inline OPCODE
OpcodeAdjust(OPCODE OP) {
return LookupOPCODE(OP);
}
static inline OPCODE OpcodeAdjust(OPCODE OP) { return LookupOPCODE(OP); }
static inline Term
ModuleAdjust(Term M) {
static inline Term ModuleAdjust(Term M) {
if (!M)
return M;
return AtomTermAdjust(M);
@ -515,29 +469,21 @@ ModuleAdjust(Term M) {
#define GlobalEntryAdjust(P) (P)
#define BlobTermInCodeAdjust(P) BlobTermInCodeAdjust__(P PASS_REGS)
#if TAGS_FAST_OPS
static inline Term
BlobTermInCodeAdjust__ (Term t USES_REGS)
{
static inline Term BlobTermInCodeAdjust__(Term t USES_REGS) {
return (Term)((char *)(t)-LOCAL_HDiff);
}
#else
static inline Term
BlobTermInCodeAdjust__ (Term t USES_REGS)
{
static inline Term BlobTermInCodeAdjust__(Term t USES_REGS) {
return (Term)((char *)(t) + LOCAL_HDiff);
}
#endif
#define DBTermAdjust(P) DBTermAdjust__(P PASS_REGS)
static inline DBTerm *
DBTermAdjust__ (DBTerm * dbtp USES_REGS)
{
static inline DBTerm *DBTermAdjust__(DBTerm *dbtp USES_REGS) {
return (DBTerm *)(CharP(dbtp) + LOCAL_HDiff);
}
#define CellPtoHeapAdjust(P) CellPtoHeapAdjust__(P PASS_REGS)
static inline CELL *
CellPtoHeapAdjust__ (CELL * dbtp USES_REGS)
{
static inline CELL *CellPtoHeapAdjust__(CELL *dbtp USES_REGS) {
return (CELL *)(CharP(dbtp) + LOCAL_HDiff);
}
@ -551,16 +497,12 @@ CellPtoHeapAdjust__ (CELL * dbtp USES_REGS)
#define GlobalAdjust(P) (P)
#define DBRefAdjust(P, Ref) DBRefAdjust__(P, Ref PASS_REGS)
static inline DBRef
DBRefAdjust__ (DBRef dbtp, int do_reference USES_REGS)
{
static inline DBRef DBRefAdjust__(DBRef dbtp, int do_reference USES_REGS) {
return LookupDBRef(dbtp, do_reference);
}
#define DBRefPAdjust(P) DBRefPAdjust__(P PASS_REGS)
static inline DBRef *
DBRefPAdjust__ (DBRef * dbtp USES_REGS)
{
static inline DBRef *DBRefPAdjust__(DBRef *dbtp USES_REGS) {
return (DBRef *)((char *)(dbtp) + LOCAL_HDiff);
}
@ -572,9 +514,7 @@ DBRefPAdjust__ (DBRef * dbtp USES_REGS)
#define PtoLUCAdjust(P) PtoLUCAdjust__(P PASS_REGS)
#define PtoLUClauseAdjust(P) PtoLUCAdjust__(P PASS_REGS)
static inline LogUpdClause *
PtoLUCAdjust__ (LogUpdClause * dbtp USES_REGS)
{
static inline LogUpdClause *PtoLUCAdjust__(LogUpdClause *dbtp USES_REGS) {
return (LogUpdClause *)((char *)(dbtp) + LOCAL_HDiff);
}
@ -587,9 +527,7 @@ PtoLUCAdjust__ (LogUpdClause * dbtp USES_REGS)
#define PtoLocAdjust(P) (P)
#define PtoHeapCellAdjust(P) PtoHeapCellAdjust__(P PASS_REGS)
static inline CELL *
PtoHeapCellAdjust__ (CELL * ptr USES_REGS)
{
static inline CELL *PtoHeapCellAdjust__(CELL *ptr USES_REGS) {
LogUpdClause *out;
if ((out = LookupMayFailDBRef((DBRef)ptr)))
return (CELL *)out;
@ -615,9 +553,7 @@ static inline yamop *PtoOpAdjust__(yamop *ptr USES_REGS) {
#define TrailAddrAdjust(P) (P)
#if PRECOMPUTE_REGADDRESS
#define XAdjust(P) XAdjust__(P PASS_REGS)
static inline wamreg
XAdjust__ (wamreg reg USES_REGS)
{
static inline wamreg XAdjust__(wamreg reg USES_REGS) {
return (wamreg)((wamreg)((reg) + LOCAL_XDiff));
}
#else
@ -638,77 +574,50 @@ XAdjust__ (wamreg reg USES_REGS)
#define Yap_op_from_opcode(OP) OpcodeID(OP)
static void RestoreFlags( UInt NFlags )
{
}
static void RestoreFlags(UInt NFlags) {}
#include "rheap.h"
static void
RestoreHashPreds( USES_REGS1 )
{
}
static void RestoreHashPreds(USES_REGS1) {}
static void RestoreAtomList(Atom atm USES_REGS) {}
static void
RestoreAtomList(Atom atm USES_REGS)
{
}
static size_t
read_bytes(FILE *stream, void *ptr, size_t sz)
{
static size_t read_bytes(FILE *stream, void *ptr, size_t sz) {
return fread(ptr, sz, 1, stream);
}
static unsigned char
read_byte(FILE *stream)
{
return getc(stream);
}
static unsigned char read_byte(FILE *stream) { return getc(stream); }
static BITS16
read_bits16(FILE *stream)
{
static BITS16 read_bits16(FILE *stream) {
BITS16 v;
read_bytes(stream, &v, sizeof(BITS16));
return v;
}
static UInt
read_UInt(FILE *stream)
{
static UInt read_UInt(FILE *stream) {
UInt v;
read_bytes(stream, &v, sizeof(UInt));
return v;
}
static Int
read_Int(FILE *stream)
{
static Int read_Int(FILE *stream) {
Int v;
read_bytes(stream, &v, sizeof(Int));
return v;
}
static qlf_tag_t
read_tag(FILE *stream)
{
static qlf_tag_t read_tag(FILE *stream) {
int ch = read_byte(stream);
return ch;
}
static pred_flags_t
read_predFlags(FILE *stream)
{
static pred_flags_t read_predFlags(FILE *stream) {
pred_flags_t v;
read_bytes(stream, &v, sizeof(pred_flags_t));
return v;
}
static bool
checkChars(FILE *stream, char s[])
{
static bool checkChars(FILE *stream, char s[]) {
int ch, c;
char *p = s;
@ -720,28 +629,26 @@ checkChars(FILE *stream, char s[])
return TRUE;
}
static Atom
do_header(FILE *stream)
{
static Atom do_header(FILE *stream) {
char s[256], *p = s, ch;
Atom at;
if (!checkChars(stream, "#!/bin/sh\nexec_dir=${YAPBINDIR:-"))
return NIL;
while ((ch = read_byte(stream)) != '\n');
while ((ch = read_byte(stream)) != '\n')
;
if (!checkChars(stream, "exec $exec_dir/yap $0 \"$@\"\nsaved "))
return NIL;
while ((ch = read_byte(stream)) != ',')
*p++ = ch;
*p++ = '\0';
at = Yap_LookupAtom(s);
while ((ch = read_byte(stream)));
while ((ch = read_byte(stream)))
;
return at;
}
static Int
get_header( USES_REGS1 )
{
static Int get_header(USES_REGS1) {
FILE *stream;
Term t1 = Deref(ARG1);
Atom at;
@ -756,13 +663,12 @@ get_header( USES_REGS1 )
}
if ((at = do_header(stream)) == NIL)
rc = FALSE;
else rc = Yap_unify( ARG2, MkAtomTerm( at ) );
else
rc = Yap_unify(ARG2, MkAtomTerm(at));
return rc;
}
static void
ReadHash(FILE *stream)
{
static void ReadHash(FILE *stream) {
CACHE_REGS
UInt i;
RCHECK(read_tag(stream) == QLY_START_X);
@ -775,7 +681,8 @@ ReadHash(FILE *stream)
RCHECK(read_tag(stream) == QLY_START_ATOMS);
LOCAL_ImportAtomHashTableNum = read_UInt(stream);
LOCAL_ImportAtomHashTableSize = LOCAL_ImportAtomHashTableNum * 2;
LOCAL_ImportAtomHashChain = (import_atom_hash_entry_t **)calloc(LOCAL_ImportAtomHashTableSize, sizeof(import_atom_hash_entry_t *));
LOCAL_ImportAtomHashChain = (import_atom_hash_entry_t **)calloc(
LOCAL_ImportAtomHashTableSize, sizeof(import_atom_hash_entry_t *));
for (i = 0; i < LOCAL_ImportAtomHashTableNum; i++) {
Atom oat = (Atom)read_UInt(stream);
Atom at;
@ -786,27 +693,31 @@ ReadHash(FILE *stream)
UInt len;
len = read_UInt(stream);
if (!EnoughTempSpace(len)) QLYR_ERROR(OUT_OF_TEMP_SPACE);
if (!EnoughTempSpace(len))
QLYR_ERROR(OUT_OF_TEMP_SPACE);
read_bytes(stream, rep, (len + 1) * sizeof(wchar_t));
while (!(at = Yap_LookupWideAtom(rep))) {
if (!Yap_growheap(FALSE, 0, NULL)) {
exit(1);
}
}
if (at == NIL) QLYR_ERROR(OUT_OF_ATOM_SPACE);
if (at == NIL)
QLYR_ERROR(OUT_OF_ATOM_SPACE);
} else if (tg == QLY_ATOM) {
char *rep = (char *)AllocTempSpace();
UInt len;
len = read_UInt(stream);
if (!EnoughTempSpace(len)) QLYR_ERROR(OUT_OF_TEMP_SPACE);
if (!EnoughTempSpace(len))
QLYR_ERROR(OUT_OF_TEMP_SPACE);
read_bytes(stream, rep, (len + 1) * sizeof(char));
while (!(at = Yap_FullLookupAtom(rep))) {
if (!Yap_growheap(FALSE, 0, NULL)) {
exit(1);
}
}
if (at == NIL) QLYR_ERROR(OUT_OF_ATOM_SPACE);
if (at == NIL)
QLYR_ERROR(OUT_OF_ATOM_SPACE);
} else {
QLYR_ERROR(BAD_ATOM);
return;
@ -817,7 +728,8 @@ ReadHash(FILE *stream)
RCHECK(read_tag(stream) == QLY_START_FUNCTORS);
LOCAL_ImportFunctorHashTableNum = read_UInt(stream);
LOCAL_ImportFunctorHashTableSize = 2 * LOCAL_ImportFunctorHashTableNum;
LOCAL_ImportFunctorHashChain = (import_functor_hash_entry_t **)calloc(LOCAL_ImportFunctorHashTableSize, sizeof(import_functor_hash_entry_t *));
LOCAL_ImportFunctorHashChain = (import_functor_hash_entry_t **)calloc(
LOCAL_ImportFunctorHashTableSize, sizeof(import_functor_hash_entry_t *));
for (i = 0; i < LOCAL_ImportFunctorHashTableNum; i++) {
Functor of = (Functor)read_UInt(stream);
UInt arity = read_UInt(stream);
@ -834,7 +746,9 @@ ReadHash(FILE *stream)
RCHECK(read_tag(stream) == QLY_START_PRED_ENTRIES);
LOCAL_ImportPredEntryHashTableNum = read_UInt(stream);
LOCAL_ImportPredEntryHashTableSize = 2 * LOCAL_ImportPredEntryHashTableNum;
LOCAL_ImportPredEntryHashChain = (import_pred_entry_hash_entry_t **)calloc( LOCAL_ImportPredEntryHashTableSize, sizeof(import_pred_entry_hash_entry_t *));
LOCAL_ImportPredEntryHashChain = (import_pred_entry_hash_entry_t **)calloc(
LOCAL_ImportPredEntryHashTableSize,
sizeof(import_pred_entry_hash_entry_t *));
for (i = 0; i < LOCAL_ImportPredEntryHashTableNum; i++) {
PredEntry *ope = (PredEntry *)read_UInt(stream), *pe;
UInt arity = read_UInt(stream);
@ -843,7 +757,8 @@ ReadHash(FILE *stream)
if (omod) {
mod = MkAtomTerm(AtomAdjust(omod));
if (mod == TermProlog) mod = 0;
if (mod == TermProlog)
mod = 0;
} else {
mod = TermProlog;
}
@ -889,7 +804,8 @@ ReadHash(FILE *stream)
RCHECK(read_tag(stream) == QLY_START_DBREFS);
LOCAL_ImportDBRefHashTableNum = read_UInt(stream);
LOCAL_ImportDBRefHashTableSize = 2 * LOCAL_ImportDBRefHashTableNum + 17;
LOCAL_ImportDBRefHashChain = (import_dbref_hash_entry_t **)calloc(LOCAL_ImportDBRefHashTableSize, sizeof(import_dbref_hash_entry_t *));
LOCAL_ImportDBRefHashChain = (import_dbref_hash_entry_t **)calloc(
LOCAL_ImportDBRefHashTableSize, sizeof(import_dbref_hash_entry_t *));
for (i = 0; i < LOCAL_ImportDBRefHashTableNum; i++) {
LogUpdClause *ocl = (LogUpdClause *)read_UInt(stream);
UInt sz = read_UInt(stream);
@ -906,8 +822,8 @@ ReadHash(FILE *stream)
LOCAL_ImportFAILCODE = (yamop *)read_UInt(stream);
}
static void
read_clauses(FILE *stream, PredEntry *pp, UInt nclauses, pred_flags_t flags) {
static void read_clauses(FILE *stream, PredEntry *pp, UInt nclauses,
pred_flags_t flags) {
CACHE_REGS
if (flags & LogUpdatePredFlag) {
/* first, clean up whatever was there */
@ -954,9 +870,7 @@ read_clauses(FILE *stream, PredEntry *pp, UInt nclauses, pred_flags_t flags) {
LOCAL_HDiff = (char *)cl - base;
read_bytes(stream, cl, size);
cl->ClFlags = mask;
pp->cs.p_code.FirstClause =
pp->cs.p_code.LastClause =
cl->ClCode;
pp->cs.p_code.FirstClause = pp->cs.p_code.LastClause = cl->ClCode;
pp->PredFlags |= MegaClausePredFlag;
/* enter index mode */
if (mask & ExoMask) {
@ -967,7 +881,8 @@ read_clauses(FILE *stream, PredEntry *pp, UInt nclauses, pred_flags_t flags) {
} else {
pp->OpcodeOfPred = INDEX_OPCODE;
}
pp->CodeOfPred = pp->cs.p_code.TrueCodeOfPred = (yamop *)(&(pp->OpcodeOfPred));
pp->CodeOfPred = pp->cs.p_code.TrueCodeOfPred =
(yamop *)(&(pp->OpcodeOfPred));
/* This must be set for restoremegaclause */
pp->cs.p_code.NOfClauses = nclauses;
RestoreMegaClause(cl PASS_REGS);
@ -989,7 +904,6 @@ read_clauses(FILE *stream, PredEntry *pp, UInt nclauses, pred_flags_t flags) {
} else {
UInt i;
if (flags & SYSTEM_PRED_FLAGS) {
if (nclauses) {
QLYR_ERROR(INCONSISTENT_CPRED);
@ -1010,9 +924,8 @@ read_clauses(FILE *stream, PredEntry *pp, UInt nclauses, pred_flags_t flags) {
}
}
static void
read_pred(FILE *stream, Term mod) {
pred_flags_t flags, fl1;
static void read_pred(FILE *stream, Term mod) {
pred_flags_t flags;
UInt nclauses;
PredEntry *ap;
@ -1067,8 +980,7 @@ read_pred(FILE *stream, Term mod) {
}
}
static void
read_ops(FILE *stream) {
static void read_ops(FILE *stream) {
Int x;
while ((x = read_tag(stream)) != QLY_END_OPS) {
Atom at = (Atom)read_UInt(stream);
@ -1086,9 +998,7 @@ read_ops(FILE *stream) {
}
}
static void
read_module(FILE *stream) {
static void read_module(FILE *stream) {
qlf_tag_t x;
InitHash();
@ -1107,9 +1017,7 @@ read_module(FILE *stream) {
CloseHash();
}
static Int
p_read_module_preds( USES_REGS1 )
{
static Int p_read_module_preds(USES_REGS1) {
FILE *stream;
Term t1 = Deref(ARG1);
@ -1128,18 +1036,12 @@ p_read_module_preds( USES_REGS1 )
return TRUE;
}
static void
ReInitProlog(void)
{
static void ReInitProlog(void) {
Term t = MkAtomTerm(AtomInitProlog);
YAP_RunGoalOnce(t);
}
static Int
qload_program( USES_REGS1 )
{
static Int qload_program(USES_REGS1) {
FILE *stream;
Term t1 = Deref(ARG1);
@ -1160,9 +1062,7 @@ qload_program( USES_REGS1 )
return true;
}
int
Yap_Restore(const char *s, char *lib_dir)
{
int Yap_Restore(const char *s, char *lib_dir) {
CACHE_REGS
FILE *stream = Yap_OpenRestore(s, lib_dir);
@ -1174,16 +1074,17 @@ Yap_Restore(const char *s, char *lib_dir)
read_module(stream);
fclose(stream);
GLOBAL_RestoreFile = NULL;
CurrentModule = USER_MODULE;
LOCAL_SourceModule = CurrentModule = USER_MODULE;
return DO_ONLY_CODE;
}
void Yap_InitQLYR(void)
{
Yap_InitCPred("$qload_module_preds", 1, p_read_module_preds, SyncPredFlag|UserCPredFlag|HiddenPredFlag);
Yap_InitCPred("$qload_file_preds", 1, p_read_module_preds, SyncPredFlag|HiddenPredFlag);
Yap_InitCPred("$qload_program", 1, qload_program, SyncPredFlag|HiddenPredFlag);
void Yap_InitQLYR(void) {
Yap_InitCPred("$qload_module_preds", 1, p_read_module_preds,
SyncPredFlag | UserCPredFlag | HiddenPredFlag);
Yap_InitCPred("$qload_file_preds", 1, p_read_module_preds,
SyncPredFlag | HiddenPredFlag);
Yap_InitCPred("$qload_program", 1, qload_program,
SyncPredFlag | HiddenPredFlag);
Yap_InitCPred("$q_header", 2, get_header, SyncPredFlag | HiddenPredFlag);
if (FALSE) {
restore_codes();

15
C/save.c
View File

@ -413,8 +413,6 @@ save_regs(int mode USES_REGS)
return -1;
if (putout(EventFlag) < 0)
return -1;
if (putcellptr((CELL *)EX) < 0)
return -1;
#if defined(YAPOR_SBA) || defined(TABLING)
if (putcellptr(H_FZ) < 0)
return -1;
@ -859,9 +857,6 @@ get_regs(int flag USES_REGS)
EventFlag = get_cell();
if (LOCAL_ErrorMessage)
return -1;
EX = (struct DB_TERM *)get_cellptr();
if (LOCAL_ErrorMessage)
return -1;
#if defined(YAPOR_SBA) || defined(TABLING)
H_FZ = get_cellptr();
if (LOCAL_ErrorMessage)
@ -1067,10 +1062,6 @@ restore_regs(int flag USES_REGS)
HB = PtoLocAdjust(HB);
YENV = PtoLocAdjust(YENV);
S = PtoGloAdjust(S);
if (EX) {
EX = DBTermAdjust(EX);
RestoreDBTerm(EX, false, TRUE PASS_REGS);
}
LOCAL_WokenGoals = AbsAppl(PtoGloAdjust(RepAppl(LOCAL_WokenGoals)));
}
}
@ -1203,12 +1194,6 @@ rehash(CELL *oldcode, int NOfE, int KindOfEntries USES_REGS)
}
}
static void
RestoreSWIHash(void)
{
// Yap_InitSWIHash();
}
static void RestoreFlags( UInt NFlags )
{

15
C/signals.c
View File

@ -183,6 +183,21 @@ inline static bool get_signal(yap_signals sig USES_REGS) {
#endif
}
bool Yap_DisableInterrupts(int wid)
{
LOCAL_InterruptsDisabled = true;
YAPEnterCriticalSection();
return true;
}
bool Yap_EnableInterrupts(int wid)
{
LOCAL_InterruptsDisabled = false;
YAPLeaveCriticalSection();
return true;
}
/**
Function called to handle delayed interrupts.
*/

1
C/stdpreds.c
View File

@ -1415,6 +1415,7 @@ static Int p_break(USES_REGS1) {
return FALSE;
}
void Yap_InitBackCPreds(void) {
Yap_InitCPredBack("$current_predicate", 4, 1, current_predicate,
cont_current_predicate, SafePredFlag | SyncPredFlag);

5
C/tracer.c
View File

@ -19,12 +19,12 @@
#ifdef LOW_LEVEL_TRACER
#include "Yatom.h"
#include "YapHeap.h"
#include "Yatom.h"
#include "attvar.h"
#include "yapio.h"
#include "clause.h"
#include "tracer.h"
#include "yapio.h"
static void send_tracer_message(char *start, char *name, Int arity, char *mname,
CELL *args) {
@ -321,6 +321,7 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
}
#endif
fprintf(stderr, "%lld %ld ", vsc_count, LCL0 - (CELL *)B);
fprintf(stderr, "%ld ", LCL0 - (CELL *)Yap_REGS.CUT_C_TOP);
#if defined(THREADS) || defined(YAPOR)
fprintf(stderr, "(%d)", worker_id);
#endif

53
C/write.c
View File

@ -19,14 +19,14 @@
static char SccsId[] = "%W% %G%";
#endif
#include <stdlib.h>
#include <math.h>
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "YapText.h"
#include "yapio.h"
#include "Yatom.h"
#include "clause.h"
#include "yapio.h"
#include <math.h>
#include <stdlib.h>
#if COROUTINING
#include "attvar.h"
#endif
@ -88,21 +88,21 @@ static bool callPortray(Term t, struct DB_TERM **old_EXp, int sno USES_REGS) {
PredEntry *pe;
Int b0 = LCL0 - (CELL *)B;
EX = NULL;
*old_EXp = Yap_RefToException();
UNLOCK(GLOBAL_Stream[sno].streamlock);
if ((pe = RepPredProp(Yap_GetPredPropByFunc(FunctorPortray, USER_MODULE))) &&
pe->OpcodeOfPred != FAIL_OPCODE && pe->OpcodeOfPred != UNDEF_OPCODE &&
Yap_execute_pred(pe, &t, true PASS_REGS)) {
choiceptr B0 = (choiceptr)(LCL0 - b0);
if (EX && !*old_EXp)
*old_EXp = EX;
if (Yap_HasException() && !*old_EXp)
*old_EXp = Yap_RefToException();
Yap_fail_all(B0 PASS_REGS);
LOCK(GLOBAL_Stream[sno].streamlock);
return true;
}
LOCK(GLOBAL_Stream[sno].streamlock);
if (EX && !*old_EXp)
*old_EXp = EX;
if (Yap_HasException() && !*old_EXp)
*old_EXp = Yap_RefToException();
return false;
}
@ -472,9 +472,7 @@ static wtype
AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
{
int ch;
if ( Yap_chtype[(int)s[0]] == SL &&
s[1] == '\0'
)
if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0')
return (separator);
while ((ch = *s++) != '\0') {
if (Yap_chtype[ch] != SY)
@ -901,8 +899,8 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
putAtom(Atom3Dots, wglb->Quote_illegal, wglb);
return;
}
DBTerm *oEX = EX;
EX = NULL;
DBTerm *ex;
Yap_ResetException(worker_id);
t = Deref(t);
if (IsVarTerm(t)) {
write_var((CELL *)t, wglb, &nrwt);
@ -924,12 +922,12 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
FALSE, wglb, &nrwt);
restore_from_write(&nrwt, wglb);
wrclose_bracket(wglb, TRUE);
EX = oEX;
return;
}
if (wglb->Use_portray)
if (callPortray(t, &EX, wglb->stream - GLOBAL_Stream PASS_REGS)) {
EX = oEX;
if (callPortray(t, &ex, wglb->stream - GLOBAL_Stream PASS_REGS)) {
Yap_CopyException(ex);
Yap_RaiseException();
return;
}
if (trueGlobalPrologFlag(WRITE_STRINGS_FLAG) && IsCodesTerm(t)) {
@ -1002,8 +1000,9 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
}
#endif
if (wglb->Use_portray) {
if (callPortray(t, &EX, wglb->stream - GLOBAL_Stream PASS_REGS)) {
EX = oEX;
if (callPortray(t, &ex, wglb->stream - GLOBAL_Stream PASS_REGS)) {
Yap_CopyException(ex);
Yap_RaiseException();
return;
}
}
@ -1138,11 +1137,8 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
if (lastw == alphanum) {
wrputc(' ', wglb->stream);
}
if (wglb->Handle_vars &&
!IsVarTerm(ti) &&
(IsIntTerm(ti) ||
IsCodesTerm(ti) ||
IsAtomTerm(ti) ||
if (wglb->Handle_vars && !IsVarTerm(ti) &&
(IsIntTerm(ti) || IsCodesTerm(ti) || IsAtomTerm(ti) ||
IsStringTerm(ti))) {
if (IsIntTerm(ti)) {
Int k = IntOfTerm(ti);
@ -1177,8 +1173,8 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
} else if (!wglb->Ignore_ops && functor == FunctorBraces) {
wrputc('{', wglb->stream);
lastw = separator;
writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), GLOBAL_MaxPriority, depth + 1,
FALSE, wglb, &nrwt);
writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), GLOBAL_MaxPriority,
depth + 1, FALSE, wglb, &nrwt);
restore_from_write(&nrwt, wglb);
wrputc('}', wglb->stream);
lastw = separator;
@ -1222,7 +1218,6 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
wrclose_bracket(wglb, TRUE);
}
}
EX = oEX;
}
void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags,
@ -1292,7 +1287,7 @@ char *Yap_TermToString(Term t, char *s, size_t sz, size_t *length,
s = Yap_MemExportStreamPtr(sno);
Yap_CloseStream(sno);
LOCAL_c_output_stream = old_output_stream;
if (EX == 0)
return s;
if (Yap_HasException())
return NULL;
return s;
}