/************************************************************************* * * * Yap Prolog * * * * Yap Prolog Was Developed At Nccup - Universidade Do Porto * * * * Copyright L.Damas, V.S.Costa And Universidade Do Porto 1985-1997 * * * ************************************************************************** * * * File: errors.c * * Last Rev: * * Mods: * * Comments: Yap's error handlers * * * *************************************************************************/ #include "absmi.h" #include "yapio.h" #if HAVE_STDARG_H #include #endif #include #if HAVE_UNISTD_H #include #endif #if HAVE_STRING_H #include #endif #if HAVE_EXECINFO_H #include #endif #include "Foreign.h" bool Yap_Warning(const char *s, ...) { CACHE_REGS va_list ap; PredEntry *pred; bool rc; Term ts[2]; const char *format; char tmpbuf[MAXPATHLEN]; if (LOCAL_within_print_message) { /* error within error */ fprintf(stderr, "%% WARNING WITHIN WARNING\n"); Yap_RestartYap(1); } LOCAL_DoingUndefp = true; LOCAL_within_print_message = true; pred = RepPredProp(PredPropByFunc(FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2 va_start(ap, s); format = va_arg(ap, char *); if (format != NULL) { #if HAVE_VSNPRINTF vsnprintf(tmpbuf, MAXPATHLEN - 1, format, ap); #else (void)vsprintf(tmpbuf, format, ap); #endif } else return false; va_end(ap); if (pred->OpcodeOfPred == UNDEF_OPCODE || pred->OpcodeOfPred == FAIL_OPCODE) { fprintf(stderr, "warning message: %s\n", tmpbuf); LOCAL_DoingUndefp = false; LOCAL_within_print_message = false; return false; } ts[1] = MkAtomTerm(AtomWarning); ts[0] = MkAtomTerm(Yap_LookupAtom(tmpbuf)); rc = Yap_execute_pred(pred, ts, true PASS_REGS); return rc; } void Yap_InitError(yap_error_number e, Term t, const char *msg) { if (LOCAL_ActiveError.status) { Yap_exit(1); } LOCAL_ActiveError.errorNo = e; LOCAL_ActiveError.errorFile = NULL; LOCAL_ActiveError.errorFunction = NULL; LOCAL_ActiveError.errorLine = 0; if (msg) { LOCAL_Error_Size = strlen(msg); strcpy(LOCAL_ActiveError.errorComment, msg); } else { LOCAL_Error_Size = 0; } } bool Yap_PrintWarning(Term twarning) { CACHE_REGS PredEntry *pred = RepPredProp(PredPropByFunc( FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2; Term cmod = (CurrentModule == PROLOG_MODULE ? TermProlog : CurrentModule); bool rc; Term ts[2]; if (LOCAL_within_print_message) { /* error within error */ fprintf(stderr, "%% WARNING WITHIN WARNING\n"); Yap_RestartYap(1); } LOCAL_DoingUndefp = true; LOCAL_within_print_message = true; if (pred->OpcodeOfPred == UNDEF_OPCODE || pred->OpcodeOfPred == FAIL_OPCODE) { fprintf(stderr, "warning message:\n"); Yap_DebugPlWrite(twarning); fprintf(stderr, "\n"); LOCAL_DoingUndefp = false; LOCAL_within_print_message = false; CurrentModule = cmod; return false; } ts[1] = twarning; ts[0] = MkAtomTerm(AtomWarning); HB = B->cp_h = HR; B->cp_tr = TR; rc = Yap_execute_pred(pred, ts, true PASS_REGS); LOCAL_within_print_message = false; LOCAL_DoingUndefp = false; return rc; } bool Yap_HandleError__(const char *file, const char *function, int lineno, const char *s, ...) { CACHE_REGS yap_error_number err = LOCAL_Error_TYPE; const char *serr; if (LOCAL_ErrorMessage) { serr = LOCAL_ErrorMessage; } else { serr = s; } switch (err) { case RESOURCE_ERROR_STACK: if (!Yap_gc(2, ENV, gc_P(P, CP))) { Yap_Error__(file, function, lineno, RESOURCE_ERROR_STACK, ARG1, serr); return false; } return true; case RESOURCE_ERROR_AUXILIARY_STACK: if (LOCAL_MAX_SIZE < (char *)AuxSp - AuxBase) { LOCAL_MAX_SIZE += 1024; } if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) { /* crash in flames */ Yap_Error__(file, function, lineno, RESOURCE_ERROR_AUXILIARY_STACK, ARG1, serr); return false; } return true; case RESOURCE_ERROR_HEAP: if (!Yap_growheap(FALSE, 0, NULL)) { Yap_Error__(file, function, lineno, RESOURCE_ERROR_HEAP, ARG2, serr); return false; } default: Yap_Error__(file, function, lineno, err, LOCAL_Error_Term, serr); return false; } } int Yap_SWIHandleError(const char *s, ...) { CACHE_REGS yap_error_number err = LOCAL_Error_TYPE; char *serr; if (LOCAL_ErrorMessage) { serr = LOCAL_ErrorMessage; } else { serr = (char *)s; } switch (err) { case RESOURCE_ERROR_STACK: if (!Yap_gc(2, ENV, gc_P(P, CP))) { Yap_Error(RESOURCE_ERROR_STACK, TermNil, serr); return (FALSE); } return TRUE; case RESOURCE_ERROR_AUXILIARY_STACK: if (LOCAL_MAX_SIZE < (char *)AuxSp - AuxBase) { LOCAL_MAX_SIZE += 1024; } if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) { /* crash in flames */ Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, serr); return FALSE; } return TRUE; case RESOURCE_ERROR_HEAP: if (!Yap_growheap(FALSE, 0, NULL)) { Yap_Error(RESOURCE_ERROR_HEAP, ARG2, serr); return FALSE; } default: Yap_Error(err, LOCAL_Error_Term, serr); return (FALSE); } } void Yap_RestartYap(int flag) { CACHE_REGS #if PUSH_REGS restore_absmi_regs(&Yap_standard_regs); #endif siglongjmp(LOCAL_RestartEnv, 1); } static void error_exit_yap(int value) { CACHE_REGS if (!(LOCAL_PrologMode & BootMode)) { #if DEBUG #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); } /* This needs to be a static because I can't trust the stack (WIN32), and I can't trust the Yap stacks (error) */ #define YAP_BUF_SIZE 512 static char tmpbuf[YAP_BUF_SIZE]; // error classes: based on OSI errors. // // - The extra argument says whether there different instances // // - Events are treated within the same pipeline as errors. // #undef BEGIN_ERROR_CLASSES #undef ECLASS #undef END_ERROR_CLASSES #undef BEGIN_ERRORS #undef E0 #undef E #undef E2 #undef END_ERRORS #define BEGIN_ERROR_CLASSES() \ static Term mkerrorct(yap_error_class_number c, Term *ts) { \ 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 END_ERROR_CLASSES() \ } \ } #define BEGIN_ERRORS() \ static Term mkerrort(yap_error_number e, Term *ts) { \ switch (e) { #define E0(A, B) \ case A: \ return mkerrorct(B, ts); #define E(A, B, C) \ case A: \ ts -= 1; \ ts[0] = MkAtomTerm(Yap_LookupAtom(C)); \ return mkerrorct(B, ts); #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 END_ERRORS() \ } \ } #include "YapErrors.h" /** * @brief Yap_Error * This function handles errors in the C code. Check errors.yap for the *corresponding Prolog code. * * @param file C source * @param function C function * @param lineno C exact line * @param type the error ID (in YAP this is a single integer) * @param where the culprit * @return usually FAILCODE * * In a good day, the error handler's job is to generate a throw. This includes: * - constructing an ISO style error term; * - constructing a list with all available info on the bug * - generating the throw * - forcing backtracking in order to restart. * * In a bad day, it has to deal with OOM, abort, and errors within errorts. * * The list includes the following options: * + c=c(file, line, function): where the bug was detected; * * + e=p(mod, name, arity, cl, file, lin): where the code was entered; * * + p=p(mod, name, arity, cl, file, line): the prolog procedure that caused *the bug, *and optionally, * * + g=g(Goal): the goal that created this mess * * + i=i(Comment): an user-written comment on this bug. */ yamop *Yap_Error__(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 *format; char s[MAXPATHLEN]; /* disallow recursive error handling */ if (LOCAL_PrologMode & InErrorMode) { fprintf(stderr, "%% ERROR WITHIN ERROR %d: %s\n", LOCAL_CurrentError, tmpbuf); Yap_RestartYap(1); } LOCAL_ActiveError.errorNo = type; LOCAL_ActiveError.errorClass = Yap_errorClass(LOCAL_ActiveError.errorNo); 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, format); else fprintf(stderr, "***** Processing Error %d (%x) %s***\n", type, LOCAL_PrologMode, format); #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_CurrentError, tmpbuf); LOCAL_PrologMode &= ~InErrorMode; Yap_exit(1); } va_start(ap, where); format = va_arg(ap, char *); if (format != NULL) { #if HAVE_VSNPRINTF (void)vsnprintf(s, MAXPATHLEN - 1, format, ap); #else (void)vsprintf(s, format, ap); #endif // fprintf(stderr, "warning: "); comment = MkAtomTerm(Yap_LookupAtom(s)); } else if (LOCAL_ErrorSay && LOCAL_ErrorSay[0]) { comment = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorSay)); } 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_CurrentError = type; 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); } /* Exit Abort Mode, if we were there */ LOCAL_PrologMode &= ~AbortMode; LOCAL_CurrentError = type; 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); #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: 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 = (yamop *)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 = (yamop *)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])) { strncpy(LOCAL_ErrorSay, (char *)RepAtom(AtomOfTerm(nt[0]))->StrOfAE, MAX_ERROR_MSG_SIZE); LOCAL_ErrorMessage = LOCAL_ErrorSay; } else { strncpy(LOCAL_ErrorSay, (char *)RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE, MAX_ERROR_MSG_SIZE); LOCAL_ErrorMessage = LOCAL_ErrorSay; } nt[1] = TermNil; 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]); } } } /* disable active signals at this point */ 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); } Yap_JumpToEnv(error_t); P = (yamop *)FAILCODE; LOCAL_PrologMode &= ~InErrorMode; return P; } static Int is_boolean(USES_REGS1) { Term t = Deref(ARG1); // Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);; if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, NULL); return false; } return t == TermTrue || t == TermFalse; } static Int is_atom(USES_REGS1) { Term t = Deref(ARG1); // Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);; if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, NULL); return false; } return IsAtomTerm(t); } static Int is_callable(USES_REGS1) { Term G = Deref(ARG1); // Term Context = Deref(ARG2); while (true) { if (IsVarTerm(G)) { Yap_Error(INSTANTIATION_ERROR, G, NULL); return false; } if (IsApplTerm(G)) { Functor f = FunctorOfTerm(G); if (IsExtensionFunctor(f)) { Yap_Error(TYPE_ERROR_CALLABLE, G, NULL); } if (f == FunctorModule) { Term tm = ArgOfTerm(1, G); if (IsVarTerm(tm)) { Yap_Error(INSTANTIATION_ERROR, G, NULL); return false; } if (!IsAtomTerm(tm)) { Yap_Error(TYPE_ERROR_CALLABLE, G, NULL); return false; } G = ArgOfTerm(2, G); } else { return true; } } else if (IsPairTerm(G) || IsAtomTerm(G)) { return true; } else { Yap_Error(TYPE_ERROR_CALLABLE, G, NULL); return false; } } return false; } static Int is_predicate_indicator(USES_REGS1) { Term G = Deref(ARG1); // Term Context = Deref(ARG2); Term mod = CurrentModule; G = Yap_YapStripModule(G, &mod); if (IsVarTerm(G)) { Yap_Error(INSTANTIATION_ERROR, G, NULL); return false; } if (!IsVarTerm(mod) && !IsAtomTerm(mod)) { Yap_Error(TYPE_ERROR_ATOM, G, NULL); return false; } if (IsApplTerm(G)) { Functor f = FunctorOfTerm(G); if (IsExtensionFunctor(f)) { Yap_Error(TYPE_ERROR_PREDICATE_INDICATOR, G, NULL); } if (f == FunctorSlash || f == FunctorDoubleSlash) { return true; } } Yap_Error(TYPE_ERROR_PREDICATE_INDICATOR, G, NULL); return false; } static Int close_error(USES_REGS1) { LOCAL_Error_TYPE = YAP_NO_ERROR; return true; } #undef BEGIN_ERROR_CLASSES #undef ECLASS #undef END_ERROR_CLASSES #undef BEGIN_ERRORS #undef E0 #undef E #undef E2 #undef END_ERRORS #define BEGIN_ERROR_CLASSES() typedef enum aux_class { #define ECLASS(CL, A, B) CL##__, #define END_ERROR_CLASSES() \ } \ aux_class_t; #define BEGIN_ERRORS() #define E0(X, Y) #define E(X, Y, Z) #define E2(X, Y, Z, W) #define END_ERRORS() #include #undef BEGIN_ERROR_CLASSES #undef ECLASS #undef END_ERROR_CLASSES #undef BEGIN_ERRORS #undef E0 #undef E #undef E2 #undef END_ERRORS #define BEGIN_ERROR_CLASSES() static const char *c_error_class_name[] = { #define ECLASS(CL, A, B) A, #define END_ERROR_CLASSES() \ NULL \ } typedef struct c_error_info { int class; const char *name; } c_error_t; #define BEGIN_ERRORS() static struct c_error_info c_error_list[] = { #define E0(X, Y) {Y##__, ""}, #define E(X, Y, Z) {Y##__, Z}, #define E2(X, Y, Z, W) {Y##__, Z " " W}, #define END_ERRORS() \ { YAPC_NO_ERROR, "" } \ } \ ; #include yap_error_class_number Yap_errorClass(yap_error_number e) { return c_error_list[e].class; } const char *Yap_errorName(yap_error_number e) { return c_error_list[e].name; } const char *Yap_errorClassName(yap_error_class_number e) { return c_error_class_name[e]; } void Yap_InitErrorPreds(void) { CACHE_REGS Yap_InitCPred("$close_error", 0, close_error, HiddenPredFlag); Yap_InitCPred("is_boolean", 2, is_boolean, TestPredFlag); Yap_InitCPred("is_callable", 2, is_callable, TestPredFlag); Yap_InitCPred("is_atom", 2, is_atom, TestPredFlag); Yap_InitCPred("is_predicate_indicator", 2, is_predicate_indicator, TestPredFlag); }