diff --git a/C/args.c b/C/args.c index a67d8d98b..744e0e905 100644 --- a/C/args.c +++ b/C/args.c @@ -43,7 +43,7 @@ int Yap_ArgKey(Atom key, const param_t *def, int n) { static xarg *failed__(yap_error_number e, Term t, xarg *a USES_REGS) { free(a); LOCAL_ActiveError->errorNo = e; - LOCAL_ActiveError->rawErrorTerm = t; + LOCAL_ActiveError->errorRawTerm = t; return NULL; } diff --git a/C/c_interface.c b/C/c_interface.c index 071e5b6e7..71779eb9e 100755 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -1454,8 +1454,7 @@ X_API Term YAP_ReadBuffer(const char *s, Term *tp) { else tv = (Term)0; LOCAL_ErrorMessage = NULL; - const unsigned char *us = (const unsigned char *)s; - while (!(t = Yap_BufferToTermWithPrioBindings(us, TermNil, tv, strlen(s) + 1, GLOBAL_MaxPriority))) { + while (!(t = Yap_BufferToTermWithPrioBindings(s, TermNil, tv, strlen(s) + 1, GLOBAL_MaxPriority))) { if (LOCAL_ErrorMessage) { if (!strcmp(LOCAL_ErrorMessage, "Stack Overflow")) { if (!Yap_dogc(0, NULL PASS_REGS)) { @@ -2091,9 +2090,7 @@ X_API void YAP_PruneGoal(YAP_dogoalinfo *gi) { X_API bool YAP_GoalHasException(Term *t) { CACHE_REGS BACKUP_MACHINE_REGS(); - if (t) - *t = Yap_PeekException(); - return Yap_PeekException(); + return LOCAL_ActiveError->errorNo != YAP_NO_ERROR; } X_API void YAP_ClearExceptions(void) { @@ -2254,12 +2251,13 @@ X_API int YAP_WriteDynamicBuffer(YAP_Term t, char *buf, size_t sze, return true; } -X_API char *YAP_CompileClause(Term t) { +X_API bool YAP_CompileClause(Term t) { CACHE_REGS yamop *codeaddr; Term mod = CurrentModule; Term tn = TermNil; - + bool ok = true; + BACKUP_MACHINE_REGS(); /* allow expansion during stack initialization */ @@ -2267,12 +2265,14 @@ X_API char *YAP_CompileClause(Term t) { ARG1 = t; YAPEnterCriticalSection(); codeaddr = Yap_cclause(t, 0, mod, t); - if (codeaddr != NULL) { + ok = (codeaddr != NULL); + if (ok) { t = Deref(ARG1); /* just in case there was an heap overflow */ if (!Yap_addclause(t, codeaddr, TermAssertz, mod, &tn)) { - YAPLeaveCriticalSection(); - return LOCAL_ErrorMessage; + ok = false; } + } else { + ok = false; } YAPLeaveCriticalSection(); @@ -2280,10 +2280,16 @@ X_API char *YAP_CompileClause(Term t) { if (!Yap_locked_growheap(FALSE, 0, NULL)) { Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "YAP failed to grow heap: %s", LOCAL_ErrorMessage); + ok = false; } } RECOVER_MACHINE_REGS(); - return (LOCAL_ErrorMessage); + if (!ok) { + t = Yap_GetException(); + Yap_DebugPlWrite(t); + return NULL; + } + return ok; } X_API void YAP_PutValue(YAP_Atom at, Term t) { Yap_PutValue(at, t); } @@ -2339,7 +2345,9 @@ X_API void YAP_FlushAllStreams(void) { X_API void YAP_Throw(Term t) { BACKUP_MACHINE_REGS(); - Yap_JumpToEnv(t); + LOCAL_ActiveError->errorNo = THROW_EVENT; + LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, LOCAL_encoding, 0); + Yap_JumpToEnv(); RECOVER_MACHINE_REGS(); } @@ -2347,7 +2355,9 @@ X_API void YAP_AsyncThrow(Term t) { CACHE_REGS BACKUP_MACHINE_REGS(); LOCAL_PrologMode |= AsyncIntMode; - Yap_JumpToEnv(t); + LOCAL_ActiveError->errorNo = THROW_EVENT; + LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, LOCAL_encoding, 0); + Yap_JumpToEnv(); LOCAL_PrologMode &= ~AsyncIntMode; RECOVER_MACHINE_REGS(); } diff --git a/C/cdmgr.c b/C/cdmgr.c index 42e36803f..fd6067b66 100644 --- a/C/cdmgr.c +++ b/C/cdmgr.c @@ -1453,28 +1453,34 @@ static int not_was_reconsulted(PredEntry *p, Term t, int mode) { return TRUE; /* careful */ } -static void addcl_permission_error(AtomEntry *ap, Int Arity, int in_use) { +static yamop * addcl_permission_error(const char *file, const char *function, int lineno, AtomEntry *ap, Int Arity, int in_use) { CACHE_REGS - - LOCAL_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE; - LOCAL_ErrorMessage = Malloc(256); - - if (in_use) { - if (Arity == 0) - sprintf(LOCAL_ErrorMessage, "static predicate %s is in use", ap->StrOfAE); + Term culprit; + if (Arity == 0) + culprit = MkAtomTerm(AbsAtom(ap)); else - sprintf(LOCAL_ErrorMessage, - "static predicate %s/" Int_FORMAT " is in use", ap->StrOfAE, - Arity); - } else { - if (Arity == 0) - sprintf(LOCAL_ErrorMessage, "system predicate %s", ap->StrOfAE); - else - sprintf(LOCAL_ErrorMessage, "system predicate %s/" Int_FORMAT, - ap->StrOfAE, Arity); - } -} + culprit = Yap_MkNewApplTerm(Yap_MkFunctor(AbsAtom(ap),Arity), Arity); +return + (in_use ? + (Arity == 0 ? + Yap_Error__(false, file, function, lineno, PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, culprit, + "static predicate %s is in use", ap->StrOfAE) + : + Yap_Error__(false, file, function, lineno, PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, culprit, + "static predicate %s/" Int_FORMAT " is in use", ap->StrOfAE, Arity) + ) + : + (Arity == 0 ? + Yap_Error__(false, file, function, lineno, PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, culprit, + "system predicate %s is in use", ap->StrOfAE) + : + Yap_Error__(false, file, function, lineno, PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, culprit, + "system predicate %s/" Int_FORMAT, ap->StrOfAE, Arity) + ) + ); + } + PredEntry *Yap_PredFromClause(Term t USES_REGS) { Term cmod = LOCAL_SourceModule; arity_t extra_arity = 0; @@ -1729,7 +1735,7 @@ bool Yap_addclause(Term t, yamop *cp, Term tmode, Term mod, Term *t4ref) PELOCK(20, p); /* we are redefining a prolog module predicate */ if (Yap_constPred(p)) { - addcl_permission_error(RepAtom(at), Arity, FALSE); + addcl_permission_error(__FILE__, __FUNCTION__, __LINE__, RepAtom(at), Arity, FALSE); UNLOCKPE(30, p); return false; } @@ -2430,12 +2436,12 @@ static Int new_multifile(USES_REGS1) { } if (pe->PredFlags & (TabledPredFlag | ForeignPredFlags)) { UNLOCKPE(26, pe); - addcl_permission_error(RepAtom(at), arity, FALSE); + addcl_permission_error(__FILE__, __FUNCTION__, __LINE__,RepAtom(at), arity, FALSE); return false; } if (pe->cs.p_code.NOfClauses) { UNLOCKPE(26, pe); - addcl_permission_error(RepAtom(at), arity, FALSE); + addcl_permission_error(__FILE__, __FUNCTION__, __LINE__,RepAtom(at), arity, FALSE); return false; } pe->PredFlags &= ~UndefPredFlag; @@ -2669,7 +2675,7 @@ static Int mk_dynamic(USES_REGS1) { /* '$make_dynamic'(+P) */ (UserCPredFlag | CArgsPredFlag | NumberDBPredFlag | AtomDBPredFlag | TestPredFlag | AsmPredFlag | CPredFlag | BinaryPredFlag)) { UNLOCKPE(30, pe); - addcl_permission_error(RepAtom(at), arity, FALSE); + addcl_permission_error(__FILE__, __FUNCTION__, __LINE__,RepAtom(at), arity, FALSE); return false; } if (pe->PredFlags & LogUpdatePredFlag) { @@ -2682,7 +2688,7 @@ static Int mk_dynamic(USES_REGS1) { /* '$make_dynamic'(+P) */ } if (pe->cs.p_code.NOfClauses != 0) { UNLOCKPE(26, pe); - addcl_permission_error(RepAtom(at), arity, FALSE); + addcl_permission_error(__FILE__, __FUNCTION__, __LINE__, RepAtom(at), arity, FALSE); return false; } if (pe->OpcodeOfPred == UNDEF_OPCODE) { @@ -2732,7 +2738,7 @@ static Int new_meta_pred(USES_REGS1) { } if (pe->cs.p_code.NOfClauses) { UNLOCKPE(26, pe); - addcl_permission_error(RepAtom(at), arity, FALSE); + addcl_permission_error(__FILE__, __FUNCTION__, __LINE__, RepAtom(at), arity, FALSE); return false; } pe->PredFlags |= MetaPredFlag; diff --git a/C/dbase.c b/C/dbase.c index b94ce8954..2add2d29a 100644 --- a/C/dbase.c +++ b/C/dbase.c @@ -259,7 +259,7 @@ static Int p_rcdz(USES_REGS1); static Int p_rcdzp(USES_REGS1); static Int p_drcdap(USES_REGS1); static Int p_drcdzp(USES_REGS1); -static Term GetDBTerm(DBTerm *, int src CACHE_TYPE); +static Term GetDBTerm(const DBTerm *, int src CACHE_TYPE); static DBProp FetchDBPropFromKey(Term, int, int, char *); static Int i_recorded(DBProp, Term CACHE_TYPE); static Int c_recorded(int CACHE_TYPE); @@ -267,8 +267,8 @@ static Int co_rded(USES_REGS1); static Int in_rdedp(USES_REGS1); static Int co_rdedp(USES_REGS1); static Int p_first_instance(USES_REGS1); -static void ErasePendingRefs(DBTerm *CACHE_TYPE); -static void RemoveDBEntry(DBRef CACHE_TYPE); +static void ErasePendingRefs(const DBTerm *CACHE_TYPE); +static void RemoveDBEntry(const DBRef CACHE_TYPE); static void EraseLogUpdCl(LogUpdClause *); static void MyEraseClause(DynamicClause *CACHE_TYPE); static void PrepareToEraseClause(DynamicClause *, DBRef); @@ -292,10 +292,10 @@ static void sf_include(SFKeep *); #endif static Int p_init_queue(USES_REGS1); static Int p_enqueue(USES_REGS1); -static void keepdbrefs(DBTerm *CACHE_TYPE); +static void keepdbrefs(const DBTerm *ref USES_REGS); static Int p_dequeue(USES_REGS1); static void ErDBE(DBRef CACHE_TYPE); -static void ReleaseTermFromDB(DBTerm *CACHE_TYPE); +static void ReleaseTermFromDB(const DBTerm *ref USES_REGS); static PredEntry *new_lu_entry(Term); static PredEntry *new_lu_int_key(Int); static PredEntry *find_lu_entry(Term); @@ -2519,7 +2519,7 @@ Int Yap_unify_immediate_ref(DBRef ref USES_REGS) { } } -static Term GetDBTerm(DBTerm *DBSP, int src USES_REGS) { +static Term GetDBTerm(const DBTerm *DBSP, int src USES_REGS) { Term t = DBSP->Entry; if (IsVarTerm(t) @@ -3779,7 +3779,7 @@ static Int p_heap_space_info(USES_REGS1) { * This is called when we are erasing a data base clause, because we may have * pending references */ -static void ErasePendingRefs(DBTerm *entryref USES_REGS) { +static void ErasePendingRefs(const DBTerm *entryref USES_REGS) { DBRef *cp; DBRef ref; @@ -4911,21 +4911,21 @@ static Int cont_current_key_integer(USES_REGS1) { return Yap_unify(term, ARG1) && Yap_unify(term, ARG2); } -Term Yap_FetchTermFromDB(void *ref) { +Term Yap_FetchTermFromDB(const void *ref) { CACHE_REGS if (ref == NULL) return 0; return GetDBTerm(ref, FALSE PASS_REGS); } -Term Yap_FetchClauseTermFromDB(void *ref) { +Term Yap_FetchClauseTermFromDB(const void *ref) { CACHE_REGS if (ref == NULL) return 0; return GetDBTerm(ref, TRUE PASS_REGS); } -Term Yap_PopTermFromDB(void *ref) { +Term Yap_PopTermFromDB(const void *ref) { CACHE_REGS Term t = GetDBTerm(ref, FALSE PASS_REGS); @@ -5141,7 +5141,7 @@ static Int p_enqueue_unlocked(USES_REGS1) { entry itself is still accessible from a trail entry, so we could not remove the target entry, */ -static void keepdbrefs(DBTerm *entryref USES_REGS) { +static void keepdbrefs (const DBTerm *entryref USES_REGS) { DBRef *cp; DBRef ref; @@ -5300,7 +5300,7 @@ static Int p_resize_int_keys(USES_REGS1) { return resize_int_keys(IntegerOfTerm(t1)); } -static void ReleaseTermFromDB(DBTerm *ref USES_REGS) { +static void ReleaseTermFromDB(const DBTerm *ref USES_REGS) { if (!ref) return; keepdbrefs(ref PASS_REGS); @@ -5308,7 +5308,7 @@ static void ReleaseTermFromDB(DBTerm *ref USES_REGS) { FreeDBSpace((char *)ref); } -void Yap_ReleaseTermFromDB(void *ref) { +void Yap_ReleaseTermFromDB(const void *ref) { CACHE_REGS ReleaseTermFromDB(ref PASS_REGS); } diff --git a/C/errors.c b/C/errors.c index 28f8b37f3..3248eb57f 100755 --- a/C/errors.c +++ b/C/errors.c @@ -32,6 +32,125 @@ #endif #include "Foreign.h" +static void print_key_b(const char *key, bool v) +{ + const char *b = v ? "true" : "false"; + fprintf(stderr,"%s: %s\n", key, b); +} + +static void print_key_i(const char *key, YAP_Int v) +{ + fprintf(stderr,"%s: " Int_FORMAT "\n", key, v); +} + + + +static void print_key_s(const char *key, const char *v) +{ + fprintf(stderr,"%s: %s\n", key, v); +} + + static void printErr(yap_error_descriptor_t *i) { + + if (i->errorNo == YAP_NO_ERROR) { + return; + } + print_key_i( "errorNo", i->errorNo ); + print_key_i("errorClass", i->errorClass); + print_key_s("errorAsText", i->errorAsText); + print_key_s( "errorGoal", i->errorGoal); + print_key_s( "classAsText", i->classAsText); + print_key_i( "errorLineq", i->errorLine ); + print_key_s( "errorFunction", i->errorFunction); + print_key_s( "errorFile", i->errorFile); + print_key_i( "prologPredLine", i->prologPredLine); + print_key_i( "prologPredFirstLine", i->prologPredFirstLine); + print_key_i( "prologPredLastLine", i->prologPredLastLine); + print_key_s( "prologPredName", i->prologPredName); + print_key_i( "prologPredArity", i->prologPredArity); + print_key_s( "prologPredModule", i->prologPredModule); + print_key_s( "prologPredFile", i->prologPredFile); + print_key_i( "prologParserPos", i->prologParserPos); + print_key_i( "prologParserLine", i->prologParserLine); + print_key_i( "prologParserFirstLine", i->prologParserFirstLine); + print_key_i( "prologParserLastLine", i->prologParserLastLine); + print_key_s( "prologParserText", i->prologParserText); + print_key_s( "prologParserFile", i->prologParserFile); + print_key_b( "prologConsulting", i->prologConsulting); + print_key_s( "culprit", i->culprit); + if (i->errorMsgLen) { + print_key_s( "errorMsg", i->errorMsg); + print_key_i( "errorMsgLen", i->errorMsgLen); + } +} + + +static YAP_Term add_key_b(const char *key, bool v, YAP_Term o0) +{ + YAP_Term tkv[2]; + tkv[1] = v ? TermTrue : TermFalse; + tkv[0] = MkStringTerm(key); + Term node = Yap_MkApplTerm( FunctorEq, 2, tkv); + return MkPairTerm(node, o0); +} + +static YAP_Term add_key_i(const char *key, YAP_Int v, YAP_Term o0) +{ + YAP_Term tkv[2]; + tkv[1] = MkIntegerTerm(v), tkv[0] = MkStringTerm(key); + Term node = Yap_MkApplTerm( FunctorEq, 2, tkv); + return MkPairTerm(node, o0); +} + + + +static YAP_Term add_key_s(const char *key, const char *v, YAP_Term o0) +{ + Term tkv[2]; + if (!v || v[0] == '\n') + return o0; + tkv[1] = MkStringTerm(v), tkv[0] = MkStringTerm(key); + Term node = Yap_MkApplTerm( FunctorEq, 2, tkv); + return MkPairTerm(node, o0); +} + + static Term err2list(yap_error_descriptor_t *i) { + Term o = TermNil; + if (i->errorNo == YAP_NO_ERROR) { + return o; + } + o = add_key_i( "errorNo", i->errorNo, o ); + o = add_key_i("errorClass", i->errorClass, o); + o = add_key_s("errorAsText", i->errorAsText, o); + o = add_key_s( "errorGoal", i->errorGoal, o); + o = add_key_s( "classAsText", i->classAsText, o); + o = add_key_i( "errorLineq", i->errorLine, o ); + o = add_key_s( "errorFunction", i->errorFunction, o); + o = add_key_s( "errorFile", i->errorFile, o); + o = add_key_i( "prologPredLine", i->prologPredLine, o); + o = add_key_i( "prologPredFirstLine", i->prologPredFirstLine, o); + o = add_key_i( "prologPredLastLine", i->prologPredLastLine, o); + o = add_key_s( "prologPredName", i->prologPredName, o); + o = add_key_i( "prologPredArity", i->prologPredArity, o); + o = add_key_s( "prologPredModule", i->prologPredModule, o); + o = add_key_s( "prologPredFile", i->prologPredFile, o); + o = add_key_i( "prologParserPos", i->prologParserPos, o); + o = add_key_i( "prologParserLine", i->prologParserLine, o); + o = add_key_i( "prologParserFirstLine", i->prologParserFirstLine, o); + o = add_key_i( "prologParserLastLine", i->prologParserLastLine, o); + o = add_key_s( "prologParserText", i->prologParserText, o); + o = add_key_s( "prologParserFile", i->prologParserFile, o); + o = add_key_b( "prologConsulting", i->prologConsulting, o); + o = add_key_s( "culprit", i->culprit, o); + if (i->errorMsgLen) { + o = add_key_s( "errorMsg", i->errorMsg, o); + o = add_key_i( "errorMsgLen", i->errorMsgLen, o); + } + return o; + +} + + bool Yap_Warning(const char *s, ...) { CACHE_REGS va_list ap; @@ -92,7 +211,7 @@ void Yap_InitError__(const char *file, const char *function, int lineno, yap_err } else return; va_end(ap); - if (LOCAL_ActiveError->status) { + if (LOCAL_ActiveError->errorNo != YAP_NO_ERROR) { Yap_exit(1); } LOCAL_ActiveError->errorNo = e; @@ -232,7 +351,7 @@ int Yap_SWIHandleError(const char *s, ...) { void Yap_RestartYap(int flag) { CACHE_REGS - fprintf(stderr,"HR=%p\n", HR); + fprintf(stderr,"call siglongjmp HR=%p\n", HR); #if PUSH_REGS restore_absmi_regs(&Yap_standard_regs); #endif @@ -283,47 +402,54 @@ static char tmpbuf[YAP_BUF_SIZE]; #undef E2 #undef END_ERRORS -#define BEGIN_ERROR_CLASSES() \ - static Term mkerrorct(yap_error_class_number c, Term *ts) { \ - switch (c) { +#define BEGIN_ERROR_CLASSES() \ + static Atom mkerrorct(yap_error_class_number c) { \ + switch (c) { -#define ECLASS(CL, A, B) \ - case CL: \ - if (A == 0) \ - return MkAtomTerm(Yap_LookupAtom(A)); \ - else { \ - return Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom(A), B), B, ts); \ - } +#define ECLASS(CL, A, B) \ + case CL: \ + return Yap_LookupAtom(A); \ -#define END_ERROR_CLASSES() \ - } \ - return TermNil; \ +#define END_ERROR_CLASSES() \ + } \ + return NULL; \ } -#define BEGIN_ERRORS() \ - static Term mkerrort(yap_error_number e, Term *ts) { \ - switch (e) { +#define BEGIN_ERRORS() \ + static Term mkerrort(yap_error_number e, Term culprit, Term info) { \ + switch (e) { -#define E0(A, B) \ - case A: \ - return mkerrorct(B, ts); +#define E0(A, B) \ + case A: { \ + Term ft[2]; \ + ft[0] = MkAtomTerm(mkerrorct(A)); \ + ft[1] = info; \ + return Yap_MkApplTerm(FunctorError,2,ft); } -#define E(A, B, C) \ - case A: \ - ts -= 1; \ - ts[0] = MkAtomTerm(Yap_LookupAtom(C)); \ - return mkerrorct(B, ts); +#define E(A, B, C) \ + case A: \ + { Term ft[2], nt[2]; \ + ft[0] = Yap_MkNewApplTerm(Yap_MkFunctor(mkerrorct(B),2), 2); \ + nt[1] = MkAtomTerm(Yap_LookupAtom(C)); \ + RESET_VARIABLE(nt+2); Yap_unify(nt[2], culprit); \ + ft[1] = info; \ + return Yap_MkApplTerm(FunctorError,2,ft); } -#define E2(A, B, C, D) \ - case A: \ - ts -= 2; \ - ts[0] = MkAtomTerm(Yap_LookupAtom(C)); \ - ts[1] = MkAtomTerm(Yap_LookupAtom(D)); \ - return mkerrorct(B, ts); +#define E2(A, B, C, D) \ + case A: \ + { \ + Term ft[3], nt[2]; \ + ft[0] = Yap_MkNewApplTerm(Yap_MkFunctor(mkerrorct(B),3), 3); \ + nt[1] = MkAtomTerm(Yap_LookupAtom(C)); \ + nt[2] = MkAtomTerm(Yap_LookupAtom(D)); \ + RESET_VARIABLE(nt+3); Yap_unify(nt[3], culprit); \ + ft[1] = info; \ + return Yap_MkApplTerm(FunctorError,2,ft); \ + } -#define END_ERRORS() \ - } \ - return TermNil; \ +#define END_ERRORS() \ + } \ + return TermNil; \ } #include "YapErrors.h" @@ -334,14 +460,16 @@ void Yap_pushErrorContext(yap_error_descriptor_t *new_error) { LOCAL_ActiveError = new_error; } -static void -reset_error_description(void) { - yap_error_descriptor_t *bf = LOCAL_ActiveError->top_error; - if (Yap_HasException()) - memset(LOCAL_ActiveError, 0, sizeof(*LOCAL_ActiveError)); - LOCAL_ActiveError->top_error = bf; +/* static void */ +/* reset_error_description(void) { */ +/* yap_error_descriptor_t *bf = LOCAL_ActiveError->top_error; */ +/* if (Yap_HasException()) */ +/* memset(LOCAL_ActiveError, 0, sizeof(*LOCAL_ActiveError)); */ +/* LOCAL_ActiveError->top_error = bf; */ + +/* } */ + -} yap_error_descriptor_t *Yap_popErrorContext(bool pass) { if (pass && LOCAL_ActiveError->top_error->errorNo == YAP_NO_ERROR && @@ -373,9 +501,8 @@ void Yap_ThrowError__(const char *file, const char *function, int lineno, } if (LOCAL_RestartEnv) { Yap_RestartYap(5); - } else { - exit(5); - } + } + Yap_exit(5); } /** @@ -413,268 +540,214 @@ void Yap_ThrowError__(const char *file, const char *function, int lineno, */ yamop *Yap_Error__(bool throw, const char *file, const char *function, int lineno, yap_error_number type, Term where, ...) { - CACHE_REGS - va_list ap; - CELL nt[3]; - Functor fun; - Term error_t; - Term comment; - char *fmt; - char s[MAXPATHLEN]; + CACHE_REGS + va_list ap; + char *fmt; + char s[MAXPATHLEN]; - /* disallow recursive error handling */ - if (LOCAL_PrologMode & InErrorMode) { - fprintf(stderr, "%% ERROR WITHIN ERROR %d: %s\n", LOCAL_Error_TYPE, tmpbuf); - Yap_RestartYap(1); - } - if (LOCAL_DoingUndefp && type == EVALUATION_ERROR_UNDEFINED) { - P = FAILCODE; - CalculateStackGap(PASS_REGS1); - return P; - } - LOCAL_ActiveError->errorNo = type; - LOCAL_ActiveError->errorAsText = Yap_errorName(type); - LOCAL_ActiveError->errorClass = Yap_errorClass(type); - LOCAL_ActiveError->classAsText = - Yap_errorClassName(LOCAL_ActiveError->errorClass); - LOCAL_ActiveError->errorLine = lineno; - LOCAL_ActiveError->errorFunction = function; - LOCAL_ActiveError->errorFile = file; - Yap_find_prolog_culprit(PASS_REGS1); - LOCAL_PrologMode |= InErrorMode; - Yap_ClearExs(); - if (where == 0L) { - where = TermNil; - } - // first, obtain current location - // sprintf(LOCAL_FileNameBuf, "%s:%d in C-function %s ", file, lineno, - // function); - // tf = MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)); -#if DEBUG_STRICT - if (Yap_heap_regs && !(LOCAL_PrologMode & BootMode)) - fprintf(stderr, "***** Processing Error %d (%lx,%x) %s***\n", type, - (unsigned long int)LOCAL_Signals, LOCAL_PrologMode, fmt); - else - fprintf(stderr, "***** Processing Error %d (%x) %s***\n", type, - LOCAL_PrologMode, fmt); -#endif - if (type == INTERRUPT_EVENT) { - fprintf(stderr, "%% YAP exiting: cannot handle signal %d\n", - (int)IntOfTerm(where)); - LOCAL_PrologMode &= ~InErrorMode; - Yap_exit(1); - } - if (LOCAL_within_print_message) { - /* error within error */ - fprintf(stderr, "%% ERROR WITHIN WARNING %d: %s\n", LOCAL_Error_TYPE, - tmpbuf); - LOCAL_PrologMode &= ~InErrorMode; - Yap_exit(1); - } - va_start(ap, where); - fmt = va_arg(ap, char *); - if (fmt != NULL) { -#if HAVE_VSNPRINTF - (void)vsnprintf(s, MAXPATHLEN - 1, fmt, ap); -#else - (void)vsprintf(s, fmt, ap); -#endif - // fprintf(stderr, "warning: "); - comment = MkAtomTerm(Yap_LookupAtom(s)); - } else if (LOCAL_ErrorMessage && LOCAL_ErrorMessage[0]) { - comment = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage)); - } else { - comment = TermNil; - } - va_end(ap); - if (P == (yamop *)(FAILCODE)) { - LOCAL_PrologMode &= ~InErrorMode; - return P; - } - /* PURE_ABORT may not have set where correctly, BootMode may not have the data - * terms ready */ - if (type == ABORT_EVENT || LOCAL_PrologMode & BootMode) { - where = TermNil; - LOCAL_PrologMode &= ~AbortMode; - LOCAL_PrologMode &= ~InErrorMode; - /* make sure failure will be seen at next port */ - // no need to lock & unlock - if (LOCAL_PrologMode & AsyncIntMode) - Yap_signal(YAP_FAIL_SIGNAL); - P = FAILCODE; - } else { - if (IsVarTerm(where)) { - /* we must be careful someone gave us a copy to a local variable */ - Term t = MkVarTerm(); - Yap_unify(t, where); - where = Deref(where); + /* disallow recursive error handling */ + if (LOCAL_PrologMode & InErrorMode) { + fprintf(stderr, "%% ERROR WITHIN ERROR %d: %s\n", LOCAL_Error_TYPE, tmpbuf); + Yap_RestartYap(1); } - /* Exit Abort Mode, if we were there */ - LOCAL_PrologMode &= ~AbortMode; + if (LOCAL_DoingUndefp && type == EVALUATION_ERROR_UNDEFINED) { + P = FAILCODE; + CalculateStackGap(PASS_REGS1); + return P; + } + LOCAL_ActiveError->errorNo = type; + LOCAL_ActiveError->errorAsText = Yap_errorName(type); + LOCAL_ActiveError->errorClass = Yap_errorClass(type); + LOCAL_ActiveError->classAsText = + Yap_errorClassName(LOCAL_ActiveError->errorClass); + LOCAL_ActiveError->errorLine = lineno; + LOCAL_ActiveError->errorFunction = function; + LOCAL_ActiveError->errorFile = file; + Yap_prolog_add_culprit(LOCAL_ActiveError PASS_REGS1); LOCAL_PrologMode |= InErrorMode; - if (!(where = Yap_CopyTerm(where))) { - where = TermNil; - } - } - - if (LOCAL_PrologMode & BootMode) { - /* crash in flames! */ - fprintf(stderr, - "%s:%d:0 YAP Fatal Error %d in function %s:\n %s exiting....\n", - file, lineno, type, function, s); - error_exit_yap(1); - } -#ifdef DEBUG - // DumpActiveGoals( USES_REGS1 ); -#endif /* DEBUG */ - if (!IsVarTerm(where) && IsApplTerm(where) && - FunctorOfTerm(where) == FunctorError) { - error_t = where; - P = (yamop *)FAILCODE; - Yap_JumpToEnv(error_t); - LOCAL_PrologMode &= ~InErrorMode; - return P; - } - switch (type) { - case SYSTEM_ERROR_INTERNAL: { - fprintf(stderr, "%% Internal YAP Error: %s exiting....\n", tmpbuf); - // serious = true; - if (LOCAL_PrologMode & BootMode) { - fprintf(stderr, "%% YAP crashed while booting %s\n", tmpbuf); - } else { - Yap_detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, YAP_BUF_SIZE); - if (tmpbuf[0]) { - fprintf(stderr, "%% Bug found while executing %s\n", tmpbuf); - } -#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); + Yap_ClearExs(); + // first, obtain current location + // sprintf(LOCAL_FileNameBuf, "%s:%d in C-function %s ", file, lineno, + // function); + // tf = MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)); +#if DEBUG_STRICT + if (Yap_heap_regs && !(LOCAL_PrologMode & BootMode)) + fprintf(stderr, "***** Processing Error %d (%lx,%x) %s***\n", type, + (unsigned long int)LOCAL_Signals, LOCAL_PrologMode, fmt); + else + fprintf(stderr, "***** Processing Error %d (%x) %s***\n", type, + LOCAL_PrologMode, fmt); #endif + if (type == INTERRUPT_EVENT) { + fprintf(stderr, "%% YAP exiting: cannot handle signal %d\n", + (int) IntOfTerm(where)); + LOCAL_PrologMode &= ~InErrorMode; + Yap_exit(1); } - error_exit_yap(1); - } - case SYSTEM_ERROR_FATAL: { - fprintf(stderr, "%% Fatal YAP Error: %s exiting....\n", tmpbuf); - error_exit_yap(1); - } - case INTERRUPT_EVENT: { - error_exit_yap(1); - } - case ABORT_EVENT: - nt[0] = MkAtomTerm(AtomDAbort); - fun = FunctorDollarVar; - // serious = true; - break; - case CALL_COUNTER_UNDERFLOW_EVENT: - /* Do a long jump */ - LOCAL_ReductionsCounterOn = FALSE; - LOCAL_PredEntriesCounterOn = FALSE; - LOCAL_RetriesCounterOn = FALSE; - Yap_JumpToEnv(MkAtomTerm(AtomCallCounter)); - P = FAILCODE; - LOCAL_PrologMode &= ~InErrorMode; - return (P); - case PRED_ENTRY_COUNTER_UNDERFLOW_EVENT: - /* Do a long jump */ - LOCAL_ReductionsCounterOn = FALSE; - LOCAL_PredEntriesCounterOn = FALSE; - LOCAL_RetriesCounterOn = FALSE; - Yap_JumpToEnv(MkAtomTerm(AtomCallAndRetryCounter)); - P = FAILCODE; - LOCAL_PrologMode &= ~InErrorMode; - return (P); - case RETRY_COUNTER_UNDERFLOW_EVENT: - /* Do a long jump */ - LOCAL_ReductionsCounterOn = FALSE; - LOCAL_PredEntriesCounterOn = FALSE; - LOCAL_RetriesCounterOn = FALSE; - Yap_JumpToEnv(MkAtomTerm(AtomRetryCounter)); - P = (yamop *)FAILCODE; - LOCAL_PrologMode &= ~InErrorMode; - return (P); - default: { - LOCAL_PrologMode &= ~InErrorMode; - Term ts[3]; - ts[2] = where; - nt[0] = mkerrort(type, ts + 2); - } - } - LOCAL_PrologMode &= ~InErrorMode; - if (type != ABORT_EVENT) { - Term location; - - /* This is used by some complex procedures to detect there was an error */ - if (IsAtomTerm(nt[0])) { - LOCAL_ErrorMessage = RepAtom(AtomOfTerm(nt[0]))->StrOfAE; + if (LOCAL_within_print_message) { + /* error within error */ + fprintf(stderr, "%% ERROR WITHIN WARNING %d: %s\n", LOCAL_Error_TYPE, + tmpbuf); + LOCAL_PrologMode &= ~InErrorMode; + Yap_exit(1); + } + if (where == 0L || where == TermNil) { + LOCAL_ActiveError->culprit = NULL; } else { - LOCAL_ErrorMessage = - (char *)RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE; + LOCAL_ActiveError->culprit = Yap_TermToBuffer(where, LOCAL_encoding, Quote_illegal_f | Handle_vars_f); + } - nt[1] = TermNil; + va_start(ap, where); + fmt = va_arg(ap, char *); + if (fmt != NULL) { +#if HAVE_VSNPRINTF + (void) vsnprintf(s, MAXPATHLEN - 1, fmt, ap); +#else + (void)vsprintf(s, fmt, ap); +#endif + // fprintf(stderr, "warning: "); + if (s[0]) { + LOCAL_ActiveError->errorMsgLen = strlen(s) + 1; + LOCAL_ActiveError->errorMsg = malloc(LOCAL_ActiveError->errorMsgLen); + strcpy(LOCAL_ActiveError->errorMsg, s); + } else if (LOCAL_ErrorMessage && LOCAL_ErrorMessage[0]) { + LOCAL_ActiveError->errorMsgLen = strlen(LOCAL_ErrorMessage) + 1; + LOCAL_ActiveError->errorMsg = malloc(LOCAL_ActiveError->errorMsgLen); + strcpy(LOCAL_ActiveError->errorMsg, LOCAL_ErrorMessage); + } else { + LOCAL_ActiveError->errorMsgLen = 0; + LOCAL_ActiveError->errorMsg = 0; + } + } + va_end(ap); + if (where == 0 || where == TermNil) { + LOCAL_ActiveError->culprit = 0; + } + if (P == (yamop *) (FAILCODE)) { + LOCAL_PrologMode &= ~InErrorMode; + return P; + } + /* PURE_ABORT may not have set where correctly, BootMode may not have the data + * terms ready */ + if (type == ABORT_EVENT || LOCAL_PrologMode & BootMode) { + LOCAL_PrologMode &= ~AbortMode; + LOCAL_PrologMode &= ~InErrorMode; + /* make sure failure will be seen at next port */ + // no need to lock & unlock + if (LOCAL_PrologMode & AsyncIntMode) + Yap_signal(YAP_FAIL_SIGNAL); + P = FAILCODE; + } else { + /* Exit Abort Mode, if we were there */ + LOCAL_PrologMode &= ~AbortMode; + LOCAL_PrologMode |= InErrorMode; + } + + if (LOCAL_PrologMode & BootMode) { + /* crash in flames! */ + fprintf(stderr, + "%s:%d:0 YAP Fatal Error %d in function %s:\n %s exiting....\n", + file, lineno, type, function, s); + error_exit_yap(1); + } +#ifdef DEBUG + // DumpActiveGoals( USES_REGS1 ); +#endif /* DEBUG */ + switch (type) { - case RESOURCE_ERROR_HEAP: - case RESOURCE_ERROR_STACK: - case RESOURCE_ERROR_TRAIL: - comment = MkAtomTerm(Yap_LookupAtom(tmpbuf)); - default: - if (comment != TermNil) - nt[1] = MkPairTerm(MkPairTerm(MkAtomTerm(Yap_LookupAtom("i")), comment), - nt[1]); - if (file && function) { - Term ts[3], t3; - ts[0] = MkAtomTerm(Yap_LookupAtom(file)); - ts[1] = MkIntegerTerm(lineno); - ts[2] = MkAtomTerm(Yap_LookupAtom(function)); - t3 = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("c"), 3), 3, ts); - nt[1] = - MkPairTerm(MkPairTerm(MkAtomTerm(Yap_LookupAtom("c")), t3), nt[1]); - } - if ((location = Yap_pc_location(P, B, ENV)) != TermNil) { - nt[1] = MkPairTerm( - MkPairTerm(MkAtomTerm(Yap_LookupAtom("p")), location), nt[1]); - } - if ((location = Yap_env_location(CP, B, ENV, 0)) != TermNil) { - nt[1] = MkPairTerm( - MkPairTerm(MkAtomTerm(Yap_LookupAtom("e")), location), nt[1]); - } + case SYSTEM_ERROR_INTERNAL: { + fprintf(stderr, "%% Internal YAP Error: %s exiting....\n", tmpbuf); + // serious = true; + if (LOCAL_PrologMode & BootMode) { + fprintf(stderr, "%% YAP crashed while booting %s\n", tmpbuf); + } else { + Yap_detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, YAP_BUF_SIZE); + if (tmpbuf[0]) { + fprintf(stderr, "%% Bug found while executing %s\n", tmpbuf); + } +#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 + } + error_exit_yap(1); + } + case SYSTEM_ERROR_FATAL: { + fprintf(stderr, "%% Fatal YAP Error: %s exiting....\n", tmpbuf); + error_exit_yap(1); + } + case INTERRUPT_EVENT: { + error_exit_yap(1); + } + case ABORT_EVENT: + // fun = FunctorDollarVar; + // serious = true; + LOCAL_ActiveError->errorNo = ABORT_EVENT; + Yap_JumpToEnv(); + P = FAILCODE; + LOCAL_PrologMode &= ~InErrorMode; + return P; + case CALL_COUNTER_UNDERFLOW_EVENT: + /* Do a long jump */ + LOCAL_ReductionsCounterOn = FALSE; + LOCAL_PredEntriesCounterOn = FALSE; + LOCAL_RetriesCounterOn = FALSE; + LOCAL_ActiveError->errorNo = CALL_COUNTER_UNDERFLOW_EVENT; + Yap_JumpToEnv(); + P = FAILCODE; + LOCAL_PrologMode &= ~InErrorMode; + return P; + case PRED_ENTRY_COUNTER_UNDERFLOW_EVENT: + /* Do a long jump */ + LOCAL_ReductionsCounterOn = FALSE; + LOCAL_PredEntriesCounterOn = FALSE; + LOCAL_RetriesCounterOn = FALSE; + LOCAL_ActiveError->errorNo = PRED_ENTRY_COUNTER_UNDERFLOW_EVENT; + Yap_JumpToEnv(); + P = FAILCODE; + LOCAL_PrologMode &= ~InErrorMode; + return P; + case RETRY_COUNTER_UNDERFLOW_EVENT: + /* Do a long jump */ + LOCAL_ReductionsCounterOn = FALSE; + LOCAL_PredEntriesCounterOn = FALSE; + LOCAL_RetriesCounterOn = FALSE; + LOCAL_ActiveError->errorNo = RETRY_COUNTER_UNDERFLOW_EVENT; + Yap_JumpToEnv(); + P = FAILCODE; + LOCAL_PrologMode &= ~InErrorMode; + return P; + default: + if (!Yap_pc_add_location(LOCAL_ActiveError, CP, B, ENV)) + Yap_env_add_location(LOCAL_ActiveError, CP, B, ENV, 0); + break; } - } + /* disable active signals at this point */ - LOCAL_Signals = 0; + LOCAL_Signals = 0; CalculateStackGap(PASS_REGS1); #if DEBUG // DumpActiveGoals( PASS_REGS1 ); #endif /* wait if we we are in user code, it's up to her to decide */ - fun = FunctorError; - error_t = Yap_MkApplTerm(fun, 2, nt); - if (type == ABORT_EVENT) { - error_t = MkAtomTerm(AtomDAbort); - } else { - error_t = Yap_MkApplTerm(fun, 2, nt); - } if (LOCAL_DoingUndefp) { - Yap_PrintWarning(error_t); + Yap_PrintWarning(Yap_GetException()); return P; } //reset_error_description(); - Yap_PutException(error_t); fprintf(stderr,"HR before jmp=%p\n", HR); - if (throw) - LOCAL_BallTerm = Yap_StoreTermInDB(error_t, 5); - else - Yap_JumpToEnv(error_t); - fprintf(stderr,"HR after jmp=%p\n", HR); - LOCAL_PrologMode &= ~InErrorMode; + if (!throw) { + Yap_JumpToEnv(); + } return P; } @@ -835,8 +908,53 @@ const char *Yap_errorClassName(yap_error_class_number e) { return c_error_class_name[e]; } + Term Yap_GetException(void) { + CACHE_REGS + if (LOCAL_ActiveError->errorNo != YAP_NO_ERROR) { + yap_error_descriptor_t *t = LOCAL_ActiveError; + Term rc = mkerrort(t->errorNo, Yap_BufferToTerm(t->culprit, TermNil), err2list(t)); + Yap_DebugPlWriteln(rc); + Yap_ResetException(worker_id); + return rc; + } + return 0; + } + + void Yap_PrintException(void) { + printErr(LOCAL_ActiveError); + } + + bool Yap_RaiseException(void) { + if (LOCAL_ActiveError->errorNo == YAP_NO_ERROR) + return false; + return Yap_JumpToEnv(); + } + + bool Yap_ResetException(int wid) { + // reset error descriptor + yap_error_descriptor_t *bf = REMOTE_ActiveError(wid)->top_error; + memset(REMOTE_ActiveError(wid), 0, sizeof(*LOCAL_ActiveError)); + REMOTE_ActiveError(wid)->top_error = bf; + LOCAL_PrologMode &= ~InErrorMode; + return true; + } + + static Int reset_exception(USES_REGS1) { return Yap_ResetException(worker_id); } + + + static Int get_exception(USES_REGS1) { + Term t; + if (Yap_HasException() && (t = Yap_GetException()) != 0) { + Int rc= Yap_unify(t, ARG1); + return rc; + } + return false; + } + void Yap_InitErrorPreds(void) { CACHE_REGS + Yap_InitCPred("$reset_exception", 1, reset_exception, 0); + Yap_InitCPred("$get_exception", 1, get_exception, 0); Yap_InitCPred("$close_error", 0, close_error, HiddenPredFlag); Yap_InitCPred("is_boolean", 2, is_boolean, TestPredFlag); Yap_InitCPred("is_callable", 2, is_callable, TestPredFlag); diff --git a/C/exec.c b/C/exec.c index b0a44ef92..95eef1bec 100755 --- a/C/exec.c +++ b/C/exec.c @@ -834,7 +834,7 @@ static bool watch_cut(Term ext USES_REGS) { CELL *complete_pt = deref_ptr(RepAppl(task) + 4); complete_pt[0] = TermTrue; if (ex_mode) { - Yap_PutException(e); + //Yap_PutException(e); return true; } if (Yap_RaiseException()) @@ -893,7 +893,7 @@ static bool watch_retry(Term d0 USES_REGS) { port_pt[0] = t; Yap_ignore(cleanup, true); if (ex_mode) { - Yap_PutException(e); + //Yap_PutException(e); return true; } if (Yap_RaiseException()) @@ -1436,7 +1436,8 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) { /* can be called from anywhere, must reset registers, */ while (B) { - Yap_JumpToEnv(TermDAbort); + LOCAL_ActiveError->errorNo = ABORT_EVENT; + Yap_JumpToEnv(); } LOCAL_PrologMode &= ~AbortMode; P = (yamop *) FAILCODE; @@ -1449,7 +1450,7 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) { Yap_regp = old_rs; fprintf(stderr,"HR before jmp=%p\n", HR); - Yap_JumpToEnv(0); + Yap_JumpToEnv(); fprintf(stderr,"HR after jmp=%p\n", HR); LOCAL_PrologMode = UserMode; ASP = (CELL *) B; @@ -1468,7 +1469,7 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) { YENV = ASP; YENV[E_CB] = Unsigned(B); out = Yap_absmi(0); - fprintf(stderr, "HR after absmi=%p\n", HR); + // fprintf(stderr, "HR after absmi=%p\n", HR); /* make sure we don't leave a FAIL signal hanging around */ Yap_get_signal(YAP_FAIL_SIGNAL); if (!Yap_has_a_signal()) @@ -2017,7 +2018,7 @@ bool is_cleanup_cp(choiceptr cp_b) { return pe == PredSafeCallCleanup; } - static Int JumpToEnv() { + static Int JumpToEnv(USES_REGS1) { choiceptr handler = B; /* just keep the throwm object away, we don't need to care about it */ @@ -2040,15 +2041,11 @@ bool is_cleanup_cp(choiceptr cp_b) { return true; } -bool Yap_JumpToEnv(Term t) { +bool Yap_JumpToEnv(void) { CACHE_REGS - if (t) - LOCAL_BallTerm = Yap_StoreTermInDB(t, 0); - if (!LOCAL_BallTerm) - return false; if (LOCAL_PrologMode & TopGoalMode) return true; - return JumpToEnv(PASS_REGS); + return JumpToEnv(PASS_REGS1); } /* This does very nasty stuff!!!!! */ @@ -2059,8 +2056,7 @@ static Int jump_env(USES_REGS1) { return false; } else if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorError) { Term t2; - - Yap_find_prolog_culprit(PASS_REGS1); + Yap_prolog_add_culprit(LOCAL_ActiveError PASS_REGS); // LOCAL_Error_TYPE = ERROR_EVENT; Term t1 = ArgOfTerm(1, t); if (IsApplTerm(t1) && IsAtomTerm((t2 = ArgOfTerm(1, t1)))) { @@ -2071,13 +2067,12 @@ static Int jump_env(USES_REGS1) { LOCAL_ActiveError->classAsText = NULL; } } else { - Yap_find_prolog_culprit(PASS_REGS1); + Yap_prolog_add_culprit(LOCAL_ActiveError PASS_REGS); LOCAL_ActiveError->errorAsText = NULL; LOCAL_ActiveError->classAsText = NULL; //return true; } LOCAL_ActiveError->prologPredName = NULL; - Yap_PutException(t); bool out = JumpToEnv(PASS_REGS1); if (B != NULL && P == FAILCODE && B->cp_ap == NOCODE && LCL0 - (CELL *)B > LOCAL_CBorder) { @@ -2183,61 +2178,6 @@ static Int jump_env(USES_REGS1) { #endif } - Term Yap_GetException(void) { - CACHE_REGS - Term t = 0; - - if (LOCAL_BallTerm) { - t = Yap_PopTermFromDB(LOCAL_BallTerm); - } - LOCAL_BallTerm = NULL; - - return t; - } - - Term Yap_PeekException(void) { return Yap_FetchTermFromDB(LOCAL_BallTerm); } - - bool Yap_RaiseException(void) { - if (LOCAL_BallTerm == NULL) - return false; - return JumpToEnv(); - } - - bool Yap_PutException(Term t) { - CACHE_REGS - if ((LOCAL_BallTerm = Yap_StoreTermInDB(t, 0)) != NULL) - return true; - - return false; - } - - bool Yap_ResetException(int wid) { - // reset errir descriptir - yap_error_descriptor_t *bf = REMOTE_ActiveError(wid)->top_error; - if (REMOTE_ActiveError(wid)->errorTerm) { - Yap_PopTermFromDB(REMOTE_ActiveError(wid)->errorTerm); - } - memset(REMOTE_ActiveError(wid), 0, sizeof(*LOCAL_ActiveError)); - REMOTE_ActiveError(wid)->top_error = bf; - return true; - } - - static Int reset_exception(USES_REGS1) { return Yap_ResetException(worker_id); } - - static Int get_exception(USES_REGS1) { - fprintf(stderr,"HR befo get_xc=%p\n", HR); - Term t = Yap_GetException(); - fprintf(stderr,"HR befo get_xc=%p\n", HR); - if (t == 0) - return false; - Yap_DebugPlWriteln(t); - Yap_ResetException(worker_id); - fprintf(stderr,"HR after get_xc=%p\n", HR); - Int rc= Yap_unify(t, ARG1); - Yap_DebugPlWriteln(t); -return rc; - } - int Yap_dogc(int extra_args, Term *tp USES_REGS) { UInt arity; yamop *nextpc; @@ -2322,10 +2262,8 @@ return rc; SafePredFlag); Yap_InitCPred("$jump_env_and_store_ball", 1, jump_env, 0); Yap_InitCPred("$generate_pred_info", 4, generate_pred_info, 0); - Yap_InitCPred("$reset_exception", 1, reset_exception, 0); Yap_InitCPred("_user_expand_goal", 2, _user_expand_goal, 0); Yap_InitCPred("$do_term_expansion", 2, do_term_expansion, 0); - Yap_InitCPred("$get_exception", 1, get_exception, 0); Yap_InitCPred("$setup_call_catcher_cleanup", 1, setup_call_catcher_cleanup, 0); Yap_InitCPred("$cleanup_on_exit", 2, cleanup_on_exit, 0); diff --git a/C/flags.c b/C/flags.c index aa0304acd..d12c5f078 100644 --- a/C/flags.c +++ b/C/flags.c @@ -1376,7 +1376,7 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s, return false; } CACHE_REGS - const unsigned char *us = (const unsigned char *)s; + const char *us = (const char *)s; t0 = Yap_BufferToTermWithPrioBindings(us, TermNil, 0L, strlen(s) + 1, GLOBAL_MaxPriority); if (!t0) return false; diff --git a/C/stack.c b/C/stack.c index 672e2bb51..b736cd92e 100644 --- a/C/stack.c +++ b/C/stack.c @@ -537,6 +537,40 @@ static Int find_code_in_clause(PredEntry *pp, yamop *codeptr, void **startp, return (0); } +/* +static bool put_clause_loc(yap_error_descriptor_t *t, void *clcode, PredEntry *pp) { + + CACHE_REGS + if (pp->PredFlags & LogUpdatePredFlag) { + LogUpdClause *cl = clcode; + + if (cl->ClFlags & FactMask) { + t->prologPredLine = cl->lusl.ClLine; + } else { + t->prologPredLine = cl->lusl.ClSource->ag.line_number; + } + } else if (pp->PredFlags & DynamicPredFlag) { + // DynamicClause *cl; + // cl = ClauseCodeToDynamicClause(clcode); + + return false; + } else if (pp->PredFlags & MegaClausePredFlag) { + MegaClause *mcl = ClauseCodeToMegaClause(pp->cs.p_code.FirstClause); + t->prologPredLine = mcl->ClLine; + } else { + StaticClause *cl; + cl = clcode; + if (cl->ClFlags & FactMask) { + t->prologPredLine = cl->usc.ClLine; + } else if (cl->ClFlags & SrcMask) { + t->prologPredLine = cl->usc.ClSource->ag.line_number; + } else + return MkIntTerm(0); + } + return MkIntTerm(0); +} +*/ + static Term clause_loc(void *clcode, PredEntry *pp) { CACHE_REGS @@ -1086,54 +1120,52 @@ static Term clause_info(yamop *codeptr, PredEntry *pp) { return Yap_MkApplTerm(FunctorModule, 2, ts); } -bool set_clause_info(yamop *codeptr, PredEntry *pp) { +yap_error_descriptor_t * set_clause_info(yap_error_descriptor_t *t, yamop *codeptr, PredEntry *pp) { CACHE_REGS Term ts[2]; void *begin; if (pp->ArityOfPE == 0) { - LOCAL_ActiveError->prologPredName = - RepAtom((Atom)pp->FunctorOfPred)->StrOfAE; - LOCAL_ActiveError->prologPredArity = 0; + t->prologPredName = + AtomName((Atom)pp->FunctorOfPred); + t->prologPredArity = 0; } else { - LOCAL_ActiveError->prologPredName = - RepAtom(NameOfFunctor(pp->FunctorOfPred))->StrOfAE; - LOCAL_ActiveError->prologPredArity = pp->ArityOfPE; + t->prologPredName = + AtomName(NameOfFunctor(pp->FunctorOfPred)); + t->prologPredArity = pp->ArityOfPE; } - LOCAL_ActiveError->prologPredModule = + t->prologPredModule = (pp->ModuleOfPred ? RepAtom(AtomOfTerm(pp->ModuleOfPred))->StrOfAE : "prolog"); - LOCAL_ActiveError->prologPredFile = RepAtom(pp->src.OwnerFile)->StrOfAE; + t->prologPredFile = RepAtom(pp->src.OwnerFile)->StrOfAE; if (codeptr->opc == UNDEF_OPCODE) { - LOCAL_ActiveError->prologPredFirstLine = 0; - LOCAL_ActiveError->prologPredLine = 0; - LOCAL_ActiveError->prologPredLastLine = 0; - return true; + t->prologPredFirstLine = 0; + t->prologPredLine = 0; + t->prologPredLastLine = 0; + return t; } else if (pp->cs.p_code.NOfClauses) { - if ((LOCAL_ActiveError->prologPredCl = + if ((t->prologPredCl = find_code_in_clause(pp, codeptr, &begin, NULL)) <= 0) { - LOCAL_ActiveError->prologPredLine = 0; + t->prologPredLine = 0; } else { - LOCAL_ActiveError->prologPredLine = IntegerOfTerm(clause_loc(begin, pp)); + t->prologPredLine = IntegerOfTerm(clause_loc(begin, pp)); } if (pp->PredFlags & LogUpdatePredFlag) { - LOCAL_ActiveError->prologPredFirstLine = IntegerOfTerm( - ts[0] = clause_loc( - ClauseCodeToLogUpdClause(pp->cs.p_code.FirstClause), pp)); - LOCAL_ActiveError->prologPredLastLine = IntegerOfTerm( - ts[1] = clause_loc(ClauseCodeToLogUpdClause(pp->cs.p_code.LastClause), - pp)); + t->prologPredFirstLine = clause_loc( + ClauseCodeToLogUpdClause(pp->cs.p_code.FirstClause), pp); + t->prologPredLastLine = clause_loc(ClauseCodeToLogUpdClause(pp->cs.p_code.LastClause), + pp); } else { - LOCAL_ActiveError->prologPredFirstLine = IntegerOfTerm( + t->prologPredFirstLine = IntegerOfTerm( ts[0] = clause_loc( ClauseCodeToStaticClause(pp->cs.p_code.FirstClause), pp)); - LOCAL_ActiveError->prologPredLastLine = IntegerOfTerm( + t->prologPredLastLine = IntegerOfTerm( ts[1] = clause_loc(ClauseCodeToStaticClause(pp->cs.p_code.LastClause), pp)); } - return true; + return t; } else { - return false; + return NULL; } } @@ -1161,13 +1193,13 @@ static Term error_culprit(bool internal USES_REGS) { return TermNil; } -bool Yap_find_prolog_culprit(USES_REGS1) { +yap_error_descriptor_t * Yap_prolog_add_culprit(yap_error_descriptor_t *t PASS_REGS) { PredEntry *pe; void *startp, *endp; // case number 1: Yap_Error called from built-in. pe = ClauseInfoForCode(P, &startp, &endp PASS_REGS); if (pe && (CurrentModule == 0 || !(pe->PredFlags & HiddenPredFlag))) { - return set_clause_info(P, pe); + return set_clause_info(t, P, pe); } else { CELL *curENV = ENV; yamop *curCP = CP; @@ -1183,11 +1215,11 @@ bool Yap_find_prolog_culprit(USES_REGS1) { pe = PredMetaCall; } if (pe->ModuleOfPred) - return set_clause_info(curCP, pe); + return set_clause_info(t, curCP, pe); curCP = (yamop *)(curENV[E_CP]); } } - return TermNil; + return NULL; } static Term all_calls(bool internal USES_REGS) { @@ -1998,26 +2030,24 @@ void Yap_detect_bug_location(yamop *yap_pc, int where_from, int psize) { } } -static Term build_bug_location(yamop *codeptr, PredEntry *pe) { +static yap_error_descriptor_t *add_bug_location(yap_error_descriptor_t *p, yamop *codeptr, PredEntry *pe) { CACHE_REGS - Term p[5]; if (pe->ModuleOfPred == PROLOG_MODULE) - p[0] = TermProlog; + p->prologPredModule = AtomName(AtomProlog); else - p[0] = pe->ModuleOfPred; + p->prologPredModule = AtomName(AtomOfTerm(pe->ModuleOfPred)); if (pe->ArityOfPE) - p[1] = MkAtomTerm(NameOfFunctor(pe->FunctorOfPred)); + p->prologPredName = AtomName(NameOfFunctor(pe->FunctorOfPred)); else - p[1] = MkAtomTerm((Atom)pe->FunctorOfPred); - p[2] = MkIntegerTerm(pe->ArityOfPE); - p[3] = TermNil; - p[4] = MkIntTerm(0); + p->prologPredName = AtomName((Atom)(pe->FunctorOfPred)); + p->prologPredArity = pe->ArityOfPE; + p->prologPredFile = AtomName( pe->src.OwnerFile ); + p->prologPredLine = 0; if (pe->src.OwnerFile) { - p[3] = MkAtomTerm(pe->src.OwnerFile); if (pe->PredFlags & MegaClausePredFlag) { MegaClause *mcl; mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause); - p[4] = MkIntegerTerm(mcl->ClLine); + p->prologPredLine = mcl->ClLine; } else { void *clcode; if (find_code_in_clause(pe, codeptr, &clcode, NULL) > 0) { @@ -2025,93 +2055,135 @@ static Term build_bug_location(yamop *codeptr, PredEntry *pe) { LogUpdClause *cl = clcode; if (cl->ClFlags & FactMask) { - p[4] = MkIntegerTerm(cl->lusl.ClLine); - } else { - p[4] = MkIntegerTerm(cl->lusl.ClSource->ag.line_number); + p->prologPredLine = cl->lusl.ClSource->ag.line_number; } } else if (pe->PredFlags & DynamicPredFlag) { - p[4] = MkIntTerm(0); + p->prologPredLine = 0; } else { StaticClause *cl; cl = clcode; if (cl->ClFlags & FactMask) { - p[4] = MkIntTerm(cl->usc.ClLine); + p->prologPredLine = MkIntTerm(cl->usc.ClLine); } else if (cl->ClFlags & SrcMask) { - p[4] = MkIntTerm(cl->usc.ClSource->ag.line_number); + p->prologPredLine = cl->usc.ClSource->ag.line_number; } else - p[4] = MkIntTerm(0); + p->prologPredLine = 0; } } else { - p[4] = MkIntTerm(0); + p->prologPredLine = 0; } } } else if (pe->OpcodeOfPred == UNDEF_OPCODE) { - RESET_VARIABLE(p + 3); - RESET_VARIABLE(p + 4); - } + p->prologPredFile = "undefined"; + } else { // by default, user_input - p[3] = MkAtomTerm(AtomUserIn); - p[4] = MkIntTerm(0); + p->prologPredFile = AtomName( AtomUserIn ); + p->prologPredLine = 0; } - return Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("p"), 5), 5, p); + return p; } -Term Yap_pc_location(yamop *pc, choiceptr b_ptr, CELL *env) { +yap_error_descriptor_t * Yap_pc_add_location(yap_error_descriptor_t *t, void *pc0, void *b_ptr0, void *env0) { CACHE_REGS - yamop *codeptr = pc; - PredEntry *pe; + yamop *xc = pc0; + // choiceptr b_ptr = b_ptr0; + //CELL *env = env0; + + PredEntry *pe; if (PP == NULL) { - if (PredForCode(pc, NULL, NULL, NULL, &pe) <= 0) - return TermNil; + if (PredForCode(xc, NULL, NULL, NULL, &pe) <= 0) + return NULL; } else pe = PP; if (pe != NULL // pe->ModuleOfPred != PROLOG_MODULE && // &&!(pe->PredFlags & HiddenPredFlag) ) { - return build_bug_location(codeptr, pe); + return add_bug_location(t, xc, pe); } + return NULL; +} + +yap_error_descriptor_t *Yap_env_add_location(yap_error_descriptor_t *t,void *cp0, void *b_ptr0, void *env0, YAP_Int ignore_first) { + yamop *cp = cp0; + choiceptr b_ptr = b_ptr0; + CELL *env = env0; + while (true) { + if (b_ptr == NULL || env == NULL) + return NULL; + PredEntry *pe = EnvPreg(cp); + if (pe == PredTrue) + return NULL; + if (ignore_first <= 0 && + pe + // pe->ModuleOfPred != PROLOG_MODULE &&s + && !(pe->PredFlags & HiddenPredFlag)) { + return add_bug_location(t, cp, pe); + } else { + if (NULL && b_ptr && b_ptr->cp_env < env) { + cp = b_ptr->cp_cp; + env = b_ptr->cp_env; + b_ptr = b_ptr->cp_b; + } else { + cp = (yamop *)env[E_CP]; + env = ENV_Parent(env); + } + ignore_first--; + } + } + } + +/* + Term Yap_env_location(yamop *cp, choiceptr b_ptr, CELL *env, Int ignore_first) { + while (true) { + if (b_ptr == NULL || env == NULL) + return TermNil; + PredEntry *pe = EnvPreg(cp); + if (pe == PredTrue) + return TermNil; + if (ignore_first <= 0 && + pe + // pe->ModuleOfPred != PROLOG_MODULE &&s + && !(pe->PredFlags & HiddenPredFlag)) { + return add_bug_location(cp, pe); + } else { + if (NULL && b_ptr && b_ptr->cp_env < env) { + cp = b_ptr->cp_cp; + env = b_ptr->cp_env; + b_ptr = b_ptr->cp_b; + } else { + cp = (yamop *)env[E_CP]; + env = ENV_Parent(env); + } + ignore_first--; + } + } + } +*/ + +static Term mkloc(yap_error_descriptor_t *t) +{ return TermNil; } -Term Yap_env_location(yamop *cp, choiceptr b_ptr, CELL *env, Int ignore_first) { - while (true) { - if (b_ptr == NULL || env == NULL) - return TermNil; - PredEntry *pe = EnvPreg(cp); - if (pe == PredTrue) - return TermNil; - if (ignore_first <= 0 && - pe - // pe->ModuleOfPred != PROLOG_MODULE &&s - && !(pe->PredFlags & HiddenPredFlag)) { - return build_bug_location(cp, pe); - } else { - if (NULL && b_ptr && b_ptr->cp_env < env) { - cp = b_ptr->cp_cp; - env = b_ptr->cp_env; - b_ptr = b_ptr->cp_b; - } else { - cp = (yamop *)env[E_CP]; - env = ENV_Parent(env); - } - ignore_first--; - } - } -} - static Int clause_location(USES_REGS1) { - return Yap_unify(Yap_pc_location(P, B, ENV), ARG1) && - Yap_unify(Yap_env_location(CP, B, ENV, 1), ARG2); + yap_error_descriptor_t t; + memset( &t, 0, sizeof(yap_error_descriptor_t)); + return Yap_unify(mkloc(Yap_pc_add_location(&t,P, B, ENV)), ARG1) && + Yap_unify(mkloc(Yap_env_add_location(&t,CP, B, ENV, 1)), ARG2); } static Int ancestor_location(USES_REGS1) { - return Yap_unify(Yap_env_location(CP, B, ENV, 2), ARG1) && - Yap_unify(Yap_env_location(CP, B, ENV, 3), ARG2); + yap_error_descriptor_t t; + memset( &t, 0, sizeof(yap_error_descriptor_t)); +return +Yap_unify(mkloc(Yap_env_add_location(&t,CP, B, ENV, 2)), ARG2) && + Yap_unify(mkloc(Yap_env_add_location(&t,CP, B, ENV, 3)), ARG2); + } void Yap_InitStInfo(void) { diff --git a/C/threads.c b/C/threads.c index cbe9b992b..ab6409dab 100644 --- a/C/threads.c +++ b/C/threads.c @@ -1817,7 +1817,8 @@ p_new_mutex(void) if (creeping) { Yap_signal( YAP_CREEP_SIGNAL ); } else if ( excep != 0) { - return Yap_JumpToEnv(excep); + LOCAL_ActiveError->errorNo = IntegerOfTerm(excep); + return Yap_JumpToEnv(); } return rc; } diff --git a/C/write.c b/C/write.c index 6927b4061..ab158b062 100644 --- a/C/write.c +++ b/C/write.c @@ -1255,11 +1255,11 @@ char *Yap_TermToBuffer(Term t, encoding_t enc, int flags) { CACHE_REGS int sno = Yap_open_buf_write_stream(enc, flags); const char *sf; - DBTerm *e = LOCAL_BallTerm; + yap_error_descriptor_t ne; if (sno < 0) return NULL; - LOCAL_c_output_stream = sno; + Yap_pushErrorContext(&ne); if (enc) GLOBAL_Stream[sno].encoding = enc; else @@ -1271,7 +1271,6 @@ char *Yap_TermToBuffer(Term t, encoding_t enc, int flags) { char *new = malloc(len + 1); strcpy(new, sf); Yap_CloseStream(sno); - if (e) - LOCAL_BallTerm = e; + Yap_popErrorContext (true); return new; } diff --git a/C/yap-args.c b/C/yap-args.c index e8abf0ca2..7f6f4ad6b 100755 --- a/C/yap-args.c +++ b/C/yap-args.c @@ -202,12 +202,12 @@ static void consult(const char *b_file USES_REGS) { YAP_RunGoalOnce(t); } } else { - char *ErrorMessage; - ErrorMessage = YAP_CompileClause(t); - if (ErrorMessage) { - fprintf(stderr, "%s", ErrorMessage); - } + YAP_CompileClause(t); } + Term terr; + Yap_PrintException(); + if ((terr = Yap_GetException())) + fprintf(stderr,"Exception Found\n"); } while (t != TermEof); BACKUP_MACHINE_REGS(); YAP_EndConsult(c_stream, &osno, full); diff --git a/CMakeCache.txt b/CMakeCache.txt index 8fa1ab296..51f421b18 100644 --- a/CMakeCache.txt +++ b/CMakeCache.txt @@ -1,6 +1,6 @@ # This is the CMakeCache file. # For build in directory: /home/vsc/github/yap-6.3 -# It was generated by CMake: /usr/bin/cmake +# It was generated by CMake: /home/vsc/clion-2018.1/bin/cmake/bin/cmake # You can edit this file to change values found and used by cmake. # If you do not want to change any of the values, simply exit the editor. # If you do want to change a value, simply edit, save, and exit the editor. @@ -345,7 +345,7 @@ LIBXML2_INCLUDE_DIR:PATH=/home/vsc/anaconda3/conda-bld/yap4py_1522051601517/_h_e LIBXML2_LIBRARIES:FILEPATH=/home/vsc/anaconda3/conda-bld/yap4py_1522051601517/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeho/lib/libxml2.so //Path to a library. -LIBXML2_LIBRARY:FILEPATH=LIBXML2_LIBRARY-NOTFOUND +LIBXML2_LIBRARY:FILEPATH=/home/vsc/anaconda3/conda-bld/yap4py_1522051601517/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placeho/lib/libxml2.so //Path to a program. LIBXML2_XMLLINT_EXECUTABLE:FILEPATH=/usr/bin/xmllint @@ -792,17 +792,17 @@ CMAKE_CACHEFILE_DIR:INTERNAL=/home/vsc/github/yap-6.3 //Major version of cmake used to create the current loaded cache CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 //Minor version of cmake used to create the current loaded cache -CMAKE_CACHE_MINOR_VERSION:INTERNAL=9 +CMAKE_CACHE_MINOR_VERSION:INTERNAL=10 //Patch version of cmake used to create the current loaded cache -CMAKE_CACHE_PATCH_VERSION:INTERNAL=1 +CMAKE_CACHE_PATCH_VERSION:INTERNAL=2 //ADVANCED property for variable: CMAKE_COLOR_MAKEFILE CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 //Path to CMake executable. -CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +CMAKE_COMMAND:INTERNAL=/home/vsc/clion-2018.1/bin/cmake/bin/cmake //Path to cpack program executable. -CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +CMAKE_CPACK_COMMAND:INTERNAL=/home/vsc/clion-2018.1/bin/cmake/bin/cpack //Path to ctest program executable. -CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +CMAKE_CTEST_COMMAND:INTERNAL=/home/vsc/clion-2018.1/bin/cmake/bin/ctest //ADVANCED property for variable: CMAKE_CXX_COMPILER CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 //ADVANCED property for variable: CMAKE_CXX_COMPILER_AR @@ -925,7 +925,7 @@ CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 //ADVANCED property for variable: CMAKE_RANLIB CMAKE_RANLIB-ADVANCED:INTERNAL=1 //Path to CMake installation. -CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.9 +CMAKE_ROOT:INTERNAL=/home/vsc/clion-2018.1/bin/cmake/share/cmake-3.10 //ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 //ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG diff --git a/CXX/yapdb.hh b/CXX/yapdb.hh index 5f76881ad..86080fb52 100644 --- a/CXX/yapdb.hh +++ b/CXX/yapdb.hh @@ -107,10 +107,10 @@ protected: YAPPredicate(const char *s0, Term &tout, Term &tnames) { CACHE_REGS Term *modp = NULL; - const unsigned char *us = (const unsigned char *)s0; + const char *s = (const char *)s0; tnames = MkVarTerm(); tout = - Yap_BufferToTermWithPrioBindings(us, TermNil, tnames, strlen(s0), 1200); + Yap_BufferToTermWithPrioBindings(s, TermNil, tnames, strlen(s0), 1200); // fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s); // Yap_DebugPlWrite(out); if (tout == 0L) { diff --git a/CXX/yapi.cpp b/CXX/yapi.cpp index 5ae52d42d..a3e92f315 100644 --- a/CXX/yapi.cpp +++ b/CXX/yapi.cpp @@ -435,7 +435,7 @@ bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) { result = YAP_LeaveGoal(false, &q); Term terr; - if ((terr = Yap_PeekException()) != 0) { + if ((terr = Yap_GetException()) != 0) { std::cerr << "Exception received by " << __func__ << "( " << YAPTerm(terr).text() << ").\n Forwarded...\n\n"; // Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm); @@ -482,7 +482,7 @@ bool YAPEngine::mgoal(Term t, Term tmod) { result = (bool)YAP_EnterGoal(ap, nullptr, &q); Term terr; - if ((terr = Yap_PeekException()) != 0) { + if ((terr = Yap_GetException()) != 0) { std::cerr << "Exception received by " << __func__ << "( " << YAPTerm(terr).text() << ").\n Forwarded...\n\n"; // Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm); @@ -551,7 +551,7 @@ Term YAPEngine::fun(Term t) { __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec "); bool result = (bool)YAP_EnterGoal(ap, nullptr, &q); - if ((terr = Yap_PeekException()) != 0) { + if ((terr = Yap_GetException()) != 0) { std::cerr << "Exception received by " << __func__ << "( " << YAPTerm(terr).text() << ").\n Forwarded...\n\n"; // Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm); @@ -982,14 +982,6 @@ std::string YAPError::text() { s += "."; s += LOCAL_ActiveError->errorAsText; s += ".\n"; - if (LOCAL_ActiveError->errorTerm) { - Term t = Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm); - if (t) { - s += "error term is: "; - s += YAPTerm(t).text(); - s += "\n"; - } - } // printf("%s\n", s.c_str()); return s.c_str(); } diff --git a/H/Yapproto.h b/H/Yapproto.h index 5a2574150..bd6c85f93 100755 --- a/H/Yapproto.h +++ b/H/Yapproto.h @@ -177,7 +177,11 @@ extern void Yap_InitDBPreds(void); extern const char *Yap_PrintPredName(struct pred_entry *ap); #endif extern void Yap_RestartYap(int); -extern void Yap_exit(int); +extern void Yap_exit(int) +#ifndef MSC_VER +__attribute__((noreturn)) +#endif +; extern bool Yap_Warning(const char *s, ...); extern bool Yap_PrintWarning(Term t); extern bool Yap_HandleError__(const char *file, const char *function, int lineno, @@ -194,7 +198,7 @@ extern void Yap_InitEval(void); extern void Yap_fail_all(choiceptr bb USES_REGS); extern Term Yap_ExecuteCallMetaCall(Term,Term); extern void Yap_InitExecFs(void); -extern bool Yap_JumpToEnv(Term); +extern bool Yap_JumpToEnv(void); extern Term Yap_RunTopGoal(Term, bool); extern bool Yap_execute_goal(Term, int, Term, bool); extern bool Yap_exec_absmi(bool, yap_reset_t); diff --git a/H/Yatom.h b/H/Yatom.h index a7b58b730..c904c4eb6 100755 --- a/H/Yatom.h +++ b/H/Yatom.h @@ -1303,18 +1303,23 @@ INLINE_ONLY inline EXTERN bool IsFlagProperty(PropFlags flags) { /* Proto types */ + +extern char *Yap_TermToBuffer(Term t, encoding_t encoding, int flags); + +extern Term Yap_BufferToTerm(const char *s, Term opts); + /* cdmgr.c */ -int Yap_RemoveIndexation(PredEntry *); -void Yap_UpdateTimestamps(PredEntry *); +extern int Yap_RemoveIndexation(PredEntry *); +extern void Yap_UpdateTimestamps(PredEntry *); /* dbase.c */ -void Yap_ErDBE(DBRef); -DBTerm *Yap_StoreTermInDB(Term, int); +extern void Yap_ErDBE(DBRef); +extern DBTerm *Yap_StoreTermInDB(Term, int); DBTerm *Yap_StoreTermInDBPlusExtraSpace(Term, UInt, UInt *); -Term Yap_FetchTermFromDB(void *); -Term Yap_FetchClauseTermFromDB(void *); -Term Yap_PopTermFromDB(void *); -void Yap_ReleaseTermFromDB(void *); +Term Yap_FetchTermFromDB(const void *); +Term Yap_FetchClauseTermFromDB(const void *); +Term Yap_PopTermFromDB(const void *); +void Yap_ReleaseTermFromDB(const void *); /* init.c */ Atom Yap_GetOp(OpEntry *, int *, int); @@ -1335,6 +1340,7 @@ Prop Yap_GetAPropHavingLock(AtomEntry *, PropFlags); *************************************************************************************************/ #include "YapFlags.h" + INLINE_ONLY EXTERN inline UInt PRED_HASH(FunctorEntry *, Term, UInt); INLINE_ONLY EXTERN inline UInt PRED_HASH(FunctorEntry *fe, Term cur_mod, @@ -1595,22 +1601,14 @@ INLINE_ONLY inline EXTERN const char *AtomTermName(Term t) { return RepAtom(AtomOfTerm(t))->rep.uStrOfAE; } -bool Yap_ResetException(int wid); -bool Yap_HasException(void); -Term Yap_GetException(void); -Term Yap_PeekException(void); -bool Yap_PutException(Term t); +extern bool Yap_ResetException(int wid); +extern bool Yap_HasException(void); +extern Term Yap_GetException(void); +extern void Yap_PrintException(void); INLINE_ONLY inline EXTERN bool Yap_HasException(void) { - return LOCAL_BallTerm != NULL; + return LOCAL_ActiveError->errorNo != YAP_NO_ERROR; } -INLINE_ONLY inline EXTERN void *Yap_RefToException(void) { - void *dbt = LOCAL_BallTerm; - LOCAL_BallTerm = NULL; - return dbt; -} -INLINE_ONLY inline EXTERN void Yap_CopyException(DBTerm *dbt) { - LOCAL_BallTerm = dbt; -} -bool Yap_RaiseException(void); + +extern bool Yap_RaiseException(void); #endif diff --git a/H/clause.h b/H/clause.h index e5768c202..e6bfe515c 100644 --- a/H/clause.h +++ b/H/clause.h @@ -457,12 +457,12 @@ LogUpdClause *Yap_new_ludbe(Term, PredEntry *, UInt); Term Yap_LUInstance(LogUpdClause *, UInt); /* udi.c */ -int Yap_new_udi_clause(PredEntry *, yamop *, Term); -yamop *Yap_udi_search(PredEntry *); +extern int Yap_new_udi_clause(PredEntry *, yamop *, Term); +extern yamop *Yap_udi_search(PredEntry *); -Term Yap_bug_location(yamop *p, yamop *cp, choiceptr b_ptr, CELL *env); -Term Yap_pc_location(yamop *p, choiceptr b_ptr, CELL *env); -Term Yap_env_location(yamop *p, choiceptr b_ptr, CELL *env, Int ignore_first); +extern yap_error_descriptor_t *Yap_bug_location(yap_error_descriptor_t *t, yamop *p, yamop *cp, choiceptr b_ptr, void *env); +extern yap_error_descriptor_t *Yap_pc_add_location(yap_error_descriptor_t *t, void *p, void *b_ptr, void *env); +extern yap_error_descriptor_t * Yap_env_add_location(yap_error_descriptor_t *t, void *p, void *b_ptr, void *env, YAP_Int ignore_first); #if LOW_PROF void Yap_InformOfRemoval(void *); diff --git a/H/rheap.h b/H/rheap.h index 2b0d4a178..17ec48427 100644 --- a/H/rheap.h +++ b/H/rheap.h @@ -943,18 +943,10 @@ static void RestoreForeignCode__(USES_REGS1) { } } -static void RestoreBallTerm(int wid) { - CACHE_REGS - if (LOCAL_BallTerm) { - LOCAL_BallTerm = DBTermAdjust(LOCAL_BallTerm); - RestoreDBTerm(LOCAL_BallTerm, false, 1 PASS_REGS); - } -} static void RestoreYapRecords__(USES_REGS1) { struct record_list *ptr; - RestoreBallTerm(worker_id); Yap_Records = DBRecordAdjust(Yap_Records); ptr = Yap_Records; while (ptr) { diff --git a/YAP.cbp b/YAP.cbp index 4e30b27e9..09ed424ef 100644 --- a/YAP.cbp +++ b/YAP.cbp @@ -1553,6 +1553,90 @@ + + + + + + + + + +