From 2e8dd92d89a80104396d14509fb432dde4e65c10 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Tue, 10 Jul 2018 23:21:19 +0100 Subject: [PATCH] jupyter-related-fixes --- C/adtdefs.c | 26 +++ C/c_interface.c | 8 +- C/errors.c | 8 +- C/flags.c | 157 ++++++++-------- C/text.c | 5 +- C/tracer.c | 2 +- C/write.c | 12 +- CXX/yapi.cpp | 171 +++++++++-------- CXX/yapt.hh | 8 +- H/YapGFlagInfo.h | 107 ++++++----- H/YapLFlagInfo.h | 159 ++++++++-------- H/Yapproto.h | 1 + H/Yatom.h | 2 +- include/YapDefs.h | 2 + library/dialect/swi/fli/swi.c | 12 +- os/writeterm.c | 4 +- os/yapio.h | 2 +- packages/python/py2pl.c | 53 +++--- packages/python/swig/yap4py/yapi.py | 12 ++ packages/python/yap_kernel/CMakeLists.txt | 7 +- .../yap_kernel/yap_ipython/prolog/jupyter.yap | 175 +++++++++++++++--- .../yap_kernel/yap_ipython/prolog/verify.yap | 44 ++--- .../python/yap_kernel/yap_ipython/yapi.py | 20 +- pl/absf.yap | 3 +- pl/consult.yap | 29 +-- pl/directives.yap | 12 +- pl/errors.yap | 2 +- pl/messages.yap | 50 +++-- 28 files changed, 641 insertions(+), 452 deletions(-) diff --git a/C/adtdefs.c b/C/adtdefs.c index e486176c2..b5aff1ed3 100755 --- a/C/adtdefs.c +++ b/C/adtdefs.c @@ -147,6 +147,32 @@ static inline Atom SearchAtom(const unsigned char *p, Atom a) { return (NIL); } +Atom +Yap_AtomInUse(const char *atom) { /* lookup atom in atom table */ + uint64_t hash; + const unsigned char *p; + Atom a, na = NIL; + AtomEntry *ae; + size_t sz = AtomHashTableSize; + + /* compute hash */ + p =( const unsigned char *) atom; + + hash = HashFunction(p); + hash = hash % sz; + /* we'll start by holding a read lock in order to avoid contention */ + READ_LOCK(HashChain[hash].AERWLock); + a = HashChain[hash].Entry; + /* search atom in chain */ + na = SearchAtom(p, a); + ae = RepAtom(na); + if (na != NIL ) { + READ_UNLOCK(HashChain[hash].AERWLock); + return (na); + } + READ_UNLOCK(HashChain[hash].AERWLock); + return NIL; +} static Atom LookupAtom(const unsigned char *atom) { /* lookup atom in atom table */ diff --git a/C/c_interface.c b/C/c_interface.c index 84ecd3929..1a30a292a 100755 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -2271,8 +2271,8 @@ X_API int YAP_WriteDynamicBuffer(YAP_Term t, char *buf, size_t sze, char *b; BACKUP_MACHINE_REGS(); - b = Yap_TermToBuffer(t, enc, flags); - strncpy(buf, b, sze); + b = Yap_TermToBuffer(t, flags); + strncpy(buf, b, sze-1); buf[sze] = 0; RECOVER_MACHINE_REGS(); return true; @@ -2371,7 +2371,7 @@ X_API void YAP_FlushAllStreams(void) { X_API void YAP_Throw(Term t) { BACKUP_MACHINE_REGS(); LOCAL_ActiveError->errorNo = THROW_EVENT; - LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, LOCAL_encoding, 0); + LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, 0); Yap_JumpToEnv(); RECOVER_MACHINE_REGS(); } @@ -2381,7 +2381,7 @@ X_API void YAP_AsyncThrow(Term t) { BACKUP_MACHINE_REGS(); LOCAL_PrologMode |= AsyncIntMode; LOCAL_ActiveError->errorNo = THROW_EVENT; - LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, LOCAL_encoding, 0); + LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, 0); Yap_JumpToEnv(); LOCAL_PrologMode &= ~AsyncIntMode; RECOVER_MACHINE_REGS(); diff --git a/C/errors.c b/C/errors.c index 3abd55edb..daf573a35 100755 --- a/C/errors.c +++ b/C/errors.c @@ -324,7 +324,7 @@ bool Yap_PrintWarning(Term twarning) { PredEntry *pred = RepPredProp(PredPropByFunc( FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2; __android_log_print(ANDROID_LOG_INFO, "YAPDroid ", " warning(%s)", - Yap_TermToBuffer(twarning, ENC_ISO_UTF8,Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f)); + Yap_TermToBuffer(twarning, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f)); Term cmod = (CurrentModule == PROLOG_MODULE ? TermProlog : CurrentModule); bool rc; Term ts[2], err; @@ -332,7 +332,7 @@ bool Yap_PrintWarning(Term twarning) { if (LOCAL_PrologMode & InErrorMode && LOCAL_ActiveError && (err = LOCAL_ActiveError->errorNo)) { fprintf(stderr, "%% Warning %s while processing error: %s %s\n", - Yap_TermToBuffer(twarning, ENC_ISO_UTF8, + Yap_TermToBuffer(twarning, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f), Yap_errorClassName(Yap_errorClass(err)), Yap_errorName(err)); return false; @@ -648,7 +648,7 @@ bool Yap_MkErrorRecord(yap_error_descriptor_t *r, const char *file, r->culprit = NULL; } else { r->culprit = Yap_TermToBuffer( - where, ENC_ISO_UTF8, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f); + where, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f); } if (LOCAL_consult_level > 0) { r->prologParserFile = Yap_ConsultingFile(PASS_REGS1)->StrOfAE; @@ -1149,7 +1149,7 @@ yap_error_descriptor_t *Yap_UserError(Term t, yap_error_descriptor_t *i) { n = t2; } i->errorGoal = Yap_TermToBuffer( - n, ENC_ISO_UTF8, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f); + n, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f); } Yap_prolog_add_culprit(i PASS_REGS); return i; diff --git a/C/flags.c b/C/flags.c index 5711565a0..e762e41ce 100644 --- a/C/flags.c +++ b/C/flags.c @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 2015- * -* * -************************************************************************** -* * -* File: flags.c * -* Last rev: * -* mods: * -* comments: abstract machine definitions * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 2015- * + * * + ************************************************************************** + * * + * File: flags.c * + * Last rev: * + * mods: * + * comments: abstract machine definitions * + * * + *************************************************************************/ /** @file C/flags.c @@ -80,22 +80,29 @@ static void newFlag(Term fl, Term val); static Int current_prolog_flag(USES_REGS1); static Int set_prolog_flag(USES_REGS1); -#include "Yatom.h" #include "YapEval.h" +#include "Yatom.h" #include "yapio.h" -#define YAP_FLAG(ID, NAME, WRITABLE, DEF, INIT, HELPER) { NAME, WRITABLE, DEF, INIT, HELPER } +#define YAP_FLAG(ID, NAME, WRITABLE, DEF, INIT, HELPER) \ + { NAME, WRITABLE, DEF, INIT, HELPER } #define START_LOCAL_FLAGS static flag_info local_flags_setup[] = { -#define END_LOCAL_FLAGS LZERO_FLAG}; +#define END_LOCAL_FLAGS \ + LZERO_FLAG \ + } \ + ; #define START_GLOBAL_FLAGS static flag_info global_flags_setup[] = { -#define END_GLOBAL_FLAGS GZERO_FLAG}; - - -#define GZERO_FLAG { NULL, false, NULL, NULL, NULL } -#define LZERO_FLAG { NULL, false, NULL, NULL, NULL } +#define END_GLOBAL_FLAGS \ + GZERO_FLAG \ + } \ + ; +#define GZERO_FLAG \ + { NULL, false, NULL, NULL, NULL } +#define LZERO_FLAG \ + { NULL, false, NULL, NULL, NULL } #include "YapGFlagInfo.h" @@ -111,8 +118,7 @@ static Term indexer(Term inp) { "set_prolog_flag index in {off,single,compact,multi,on,max}"); return TermZERO; } - Yap_Error(TYPE_ERROR_ATOM, inp, - "set_prolog_flag index to an atom"); + Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag index to an atom"); return TermZERO; } @@ -133,14 +139,16 @@ static bool dqf1(ModEntry *new, Term t2 USES_REGS) { return true; } /* bad argument, but still an atom */ - Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted " - "string flag, use one string, " - "atom, codes or chars", + Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, + "bad option %s for backquoted " + "string flag, use one string, " + "atom, codes or chars", RepAtom(AtomOfTerm(t2))->StrOfAE); return false; } else { - Yap_Error(TYPE_ERROR_ATOM, t2, "set_prolog_flag(double_quotes, %s), should " - "be {string,atom,codes,chars}", + Yap_Error(TYPE_ERROR_ATOM, t2, + "set_prolog_flag(double_quotes, %s), should " + "be {string,atom,codes,chars}", RepAtom(AtomOfTerm(t2))->StrOfAE); return false; } @@ -168,9 +176,10 @@ static bool bqf1(ModEntry *new, Term t2 USES_REGS) { new->flags |= BCKQ_CHARS; return true; } - Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted " - "string flag, use one string, " - "atom, codes or chars", + Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, + "bad option %s for backquoted " + "string flag, use one string, " + "atom, codes or chars", RepAtom(AtomOfTerm(t2))->StrOfAE); return false; } else { @@ -186,7 +195,6 @@ static bool bqs(Term t2) { return bqf1(new, t2 PASS_REGS); } - static bool sqf1(ModEntry *new, Term t2 USES_REGS) { new->flags &= ~(SNGQ_CHARS | SNGQ_CODES | SNGQ_ATOM | SNGQ_STRING); if (IsAtomTerm(t2)) { @@ -203,9 +211,10 @@ static bool sqf1(ModEntry *new, Term t2 USES_REGS) { new->flags |= SNGQ_CHARS; return true; } - Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted " - "string flag, use one string, " - "atom, codes or chars", + Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, + "bad option %s for backquoted " + "string flag, use one string, " + "atom, codes or chars", RepAtom(AtomOfTerm(t2))->StrOfAE); return false; } else { @@ -215,7 +224,6 @@ static bool sqf1(ModEntry *new, Term t2 USES_REGS) { } } - static bool sqf(Term t2) { CACHE_REGS ModEntry *new = Yap_GetModuleEntry(CurrentModule); @@ -239,8 +247,9 @@ static Term isaccess(Term inp) { static Term stream(Term inp) { if (IsVarTerm(inp)) return inp; - if (Yap_CheckStream(inp, Input_Stream_f | Output_Stream_f | Append_Stream_f | - Socket_Stream_f, + if (Yap_CheckStream(inp, + Input_Stream_f | Output_Stream_f | Append_Stream_f | + Socket_Stream_f, "yap_flag/3") >= 0) return inp; return 0; @@ -249,19 +258,19 @@ static Term stream(Term inp) { static bool set_error_stream(Term inp) { if (IsVarTerm(inp)) return Yap_unify(inp, Yap_StreamUserName(LOCAL_c_error_stream)); - return Yap_SetErrorStream( inp ); + return Yap_SetErrorStream(inp); } static bool set_input_stream(Term inp) { if (IsVarTerm(inp)) return Yap_unify(inp, Yap_StreamUserName(LOCAL_c_input_stream)); - return Yap_SetInputStream( inp ); + return Yap_SetInputStream(inp); } static bool set_output_stream(Term inp) { if (IsVarTerm(inp)) return Yap_unify(inp, Yap_StreamUserName(LOCAL_c_output_stream)); - return Yap_SetOutputStream( inp ); + return Yap_SetOutputStream(inp); } static Term isground(Term inp) { @@ -731,10 +740,10 @@ static bool setYapFlagInModule(Term tflag, Term t2, Term mod) { if (IsVarTerm(tout)) { Term t; while ((t = Yap_PopTermFromDB(tarr[fv->FlagOfVE].DBT)) == 0) { - if (!Yap_gc(2, ENV, gc_P(P, CP))) { - Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); - return false; - } + if (!Yap_gc(2, ENV, gc_P(P, CP))) { + Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); + return false; + } } } else if (IsAtomOrIntTerm(t2)) tarr[fv->FlagOfVE].at = t2; @@ -782,7 +791,6 @@ static bool setYapFlagInModule(Term tflag, Term t2, Term mod) { return bqf1(me, t2 PASS_REGS); } else if (fv->FlagOfVE == SINGLE_QUOTES_FLAG) { return sqf1(me, t2 PASS_REGS); - } // bad key? return false; @@ -850,8 +858,7 @@ static Int cont_yap_flag(USES_REGS1) { Term modt = CurrentModule; tflag = Yap_StripModule(tflag, &modt); while (i != gmax && i != UNKNOWN_FLAG && i != CHARACTER_ESCAPES_FLAG && - i != BACK_QUOTES_FLAG && - i != SINGLE_QUOTES_FLAG && + i != BACK_QUOTES_FLAG && i != SINGLE_QUOTES_FLAG && i != DOUBLE_QUOTES_FLAG) i++; if (i == gmax) @@ -1056,14 +1063,16 @@ void Yap_setModuleFlags(ModEntry *new, ModEntry *cme) { Atom at = new->AtomOfME; if (at == AtomProlog || CurrentModule == PROLOG_MODULE) { - new->flags = - M_SYSTEM | UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM; + new->flags = M_SYSTEM | UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | + BCKQ_STRING | SNGQ_ATOM; if (at == AtomUser) - new->flags = UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM; + new->flags = + UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING | SNGQ_ATOM; } else if (cme && cme->flags && cme != new) { new->flags = cme->flags; } else { - new->flags = (UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM); + new->flags = + (UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING | SNGQ_ATOM); } // printf("cme=%s new=%s flags=%x\n",cme,at->StrOfAE,new->flags); } @@ -1391,8 +1400,9 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s, return false; } CACHE_REGS - const char *us = (const char *)s; - t0 = Yap_BufferToTermWithPrioBindings(us, TermNil, 0L, strlen(s) + 1, GLOBAL_MaxPriority); + const char *us = (const char *)s; + t0 = Yap_BufferToTermWithPrioBindings(us, TermNil, 0L, strlen(s) + 1, + GLOBAL_MaxPriority); if (!t0) return false; if (IsAtomTerm(t0) || IsIntTerm(t0)) { @@ -1439,8 +1449,9 @@ do_prolog_flag_property(Term tflag, xarg *args; prolog_flag_property_choices_t i; bool rc = true; - args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs, - PROLOG_FLAG_PROPERTY_END, DOMAIN_ERROR_PROLOG_FLAG); + args = + Yap_ArgList2ToVector(opts, prolog_flag_property_defs, + PROLOG_FLAG_PROPERTY_END, DOMAIN_ERROR_PROLOG_FLAG); if (args == NULL) { Yap_Error(LOCAL_Error_TYPE, opts, NULL); return false; @@ -1527,9 +1538,8 @@ static Int cont_prolog_flag_property(USES_REGS1) { /* current_prolog_flag */ lab = MkAtomTerm(Yap_LookupAtom(local_flags_setup[i - gmax].name)); } else { if (i == UNKNOWN_FLAG || i == CHARACTER_ESCAPES_FLAG || - i == SINGLE_QUOTES_FLAG || - i == DOUBLE_QUOTES_FLAG || - i == BACK_QUOTES_FLAG) { + i == SINGLE_QUOTES_FLAG || i == DOUBLE_QUOTES_FLAG || + i == BACK_QUOTES_FLAG) { Term labs[2]; labs[0] = MkVarTerm(); labs[1] = MkAtomTerm(Yap_LookupAtom(global_flags_setup[i].name)); @@ -1607,8 +1617,9 @@ static Int do_create_prolog_flag(USES_REGS1) { prolog_flag_property_choices_t i; Term tflag = Deref(ARG1), tval = Deref(ARG2), opts = Deref(ARG3); - args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs, - PROLOG_FLAG_PROPERTY_END, DOMAIN_ERROR_PROLOG_FLAG); + args = + Yap_ArgList2ToVector(opts, prolog_flag_property_defs, + PROLOG_FLAG_PROPERTY_END, DOMAIN_ERROR_PROLOG_FLAG); if (args == NULL) { Yap_Error(LOCAL_Error_TYPE, opts, NULL); return false; @@ -1660,15 +1671,15 @@ static Int do_create_prolog_flag(USES_REGS1) { } /** -* Init System Prolog flags. This is done in two phases: -* early on, it takes care of the atomic flags that are required by other -*modules; -* later, it looks at flags that are structured terms -* -* @param bootstrap: wether this is done before stack initialization, or -*afterwards. -* Complex terms can only be built in the second step. -*/ + * Init System Prolog flags. This is done in two phases: + * early on, it takes care of the atomic flags that are required by other + *modules; + * later, it looks at flags that are structured terms + * + * @param bootstrap: wether this is done before stack initialization, or + *afterwards. + * Complex terms can only be built in the second step. + */ void Yap_InitFlags(bool bootstrap) { CACHE_REGS @@ -1722,7 +1733,7 @@ void Yap_InitFlags(bool bootstrap) { */ Yap_InitCPredBack("prolog_flag", 3, 1, current_prolog_flag, cont_yap_flag, 0); - Yap_InitCPredBack("yap_flag", 3, 1, prolog_flag, cont_yap_flag, 0); + Yap_InitCPredBack("yap_flag", 3, 1, yap_flag, cont_yap_flag, 0); Yap_InitCPredBack("prolog_flag", 2, 1, current_prolog_flag2, cont_current_prolog_flag, 0); Yap_InitCPredBack("current_prolog_flag", 2, 1, current_prolog_flag2, diff --git a/C/text.c b/C/text.c index f9b4d0c4a..5f225cde7 100644 --- a/C/text.c +++ b/C/text.c @@ -533,9 +533,8 @@ unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) { #endif if (inp->type & YAP_STRING_TERM) { // Yap_DebugPlWriteln(inp->val.t); - char *s = (char *)Yap_TermToBuffer(inp->val.t, ENC_ISO_UTF8, 0); - return inp->val.uc = pop_output_text_stack(lvl, s); - } + char *s = (char *)Yap_TermToBuffer(inp->val.t, 0); + } if (inp->type & YAP_STRING_CHARS) { pop_text_stack(lvl); if (inp->enc == ENC_ISO_LATIN1) { diff --git a/C/tracer.c b/C/tracer.c index 301640d5f..c4de2fb23 100644 --- a/C/tracer.c +++ b/C/tracer.c @@ -87,7 +87,7 @@ static char *send_tracer_message(char *start, char *name, arity_t arity, continue; } } - const char *sn = Yap_TermToBuffer(args[i], LOCAL_encoding, + const char *sn = Yap_TermToBuffer(args[i], Quote_illegal_f | Handle_vars_f); size_t sz; if (sn == NULL) { diff --git a/C/write.c b/C/write.c index a09895663..104e5648b 100644 --- a/C/write.c +++ b/C/write.c @@ -1255,9 +1255,9 @@ void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags, pop_text_stack(lvl); } -char *Yap_TermToBuffer(Term t, encoding_t enc, int flags) { +char *Yap_TermToBuffer(Term t, int flags) { CACHE_REGS - int sno = Yap_open_buf_write_stream(enc, flags); + int sno = Yap_open_buf_write_stream(LOCAL_encoding,flags); const char *sf; if (sno < 0) @@ -1266,17 +1266,13 @@ char *Yap_TermToBuffer(Term t, encoding_t enc, int flags) { return NULL; else t = Deref(t); - if (enc) - GLOBAL_Stream[sno].encoding = enc; - else - GLOBAL_Stream[sno].encoding = LOCAL_encoding; + GLOBAL_Stream[sno].encoding = LOCAL_encoding; GLOBAL_Stream[sno].status |= CloseOnException_Stream_f; Yap_plwrite(t, GLOBAL_Stream + sno, 0, flags, GLOBAL_MaxPriority); sf = Yap_MemExportStreamPtr(sno); size_t len = strlen(sf); - char *new = malloc(len + 1); - strcpy(new, sf); + char *new = realloc((void*)sf,len + 1); Yap_CloseStream(sno); return new; } diff --git a/CXX/yapi.cpp b/CXX/yapi.cpp index d4af76497..3d9e0d9df 100644 --- a/CXX/yapi.cpp +++ b/CXX/yapi.cpp @@ -19,7 +19,7 @@ extern "C" { #include "YapInterface.h" #include "iopreds.h" -X_API char *Yap_TermToBuffer(Term t, encoding_t encodingp, int flags); +X_API char *Yap_TermToBuffer(Term t, int flags); X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity); X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t, @@ -30,35 +30,32 @@ X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, #if YAP_PYTHON X_API bool do_init_python(void); #endif - - } -static void YAPCatchError() - { - if (LOCAL_CommittedError != nullptr && - LOCAL_CommittedError->errorNo != YAP_NO_ERROR ) { - // Yap_PopTermFromDB(info->errorTerm); - // throw throw YAPError( ); - Term es[2]; - es[0] = TermError; - es[1] = MkErrorTerm(LOCAL_CommittedError); - Functor f = Yap_MkFunctor(Yap_LookupAtom("print_message"), 2); - YAP_RunGoalOnce(Yap_MkApplTerm(f, 2, es)); - // Yap_PopTermFromDB(info->errorTerm); - // throw throw YAPError( SOURCE(), ); - } else if (LOCAL_ActiveError != nullptr && - LOCAL_ActiveError->errorNo != YAP_NO_ERROR ) { - // Yap_PopTermFromDB(info->errorTerm); - // throw throw YAPError( ); - Term es[2]; - es[0] = TermError; - es[1] = MkErrorTerm(LOCAL_ActiveError); - Functor f = Yap_MkFunctor(Yap_LookupAtom("print_message"), 2); - YAP_RunGoalOnce(Yap_MkApplTerm(f, 2, es)); - // Yap_PopTermFromDB(info->errorTerm); - // throw throw YAPError( SOURCE(), ); - } +static void YAPCatchError() { + if (LOCAL_CommittedError != nullptr && + LOCAL_CommittedError->errorNo != YAP_NO_ERROR) { + // Yap_PopTermFromDB(info->errorTerm); + // throw throw YAPError( ); + Term es[2]; + es[0] = TermError; + es[1] = MkErrorTerm(LOCAL_CommittedError); + Functor f = Yap_MkFunctor(Yap_LookupAtom("print_message"), 2); + YAP_RunGoalOnce(Yap_MkApplTerm(f, 2, es)); + // Yap_PopTermFromDB(info->errorTerm); + // throw throw YAPError( SOURCE(), ); + } else if (LOCAL_ActiveError != nullptr && + LOCAL_ActiveError->errorNo != YAP_NO_ERROR) { + // Yap_PopTermFromDB(info->errorTerm); + // throw throw YAPError( ); + Term es[2]; + es[0] = TermError; + es[1] = MkErrorTerm(LOCAL_ActiveError); + Functor f = Yap_MkFunctor(Yap_LookupAtom("print_message"), 2); + YAP_RunGoalOnce(Yap_MkApplTerm(f, 2, es)); + // Yap_PopTermFromDB(info->errorTerm); + // throw throw YAPError( SOURCE(), ); + } } YAPPredicate::YAPPredicate(Term &t, Term &tmod, CELL *&ts, const char *pname) { @@ -334,7 +331,7 @@ std::vector YAPPairTerm::listToArray() { if (l < 0) { throw YAPError(SOURCE(), TYPE_ERROR_LIST, (t), nullptr); } - std::vector o = * new std::vector(l); + std::vector o = *new std::vector(l); int i = 0; Term t = gt(); while (t != TermNil) { @@ -483,7 +480,7 @@ const char *YAPAtom::getName(void) { return Yap_AtomToUTF8Text(a); } void YAPQuery::openQuery() { CACHE_REGS - if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) { + if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) { ap = rewriteUndefQuery(); } setNext(); @@ -512,7 +509,7 @@ bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) { YAPCatchError(); Yap_CloseHandles(q.CurSlot); - pop_text_stack(q.lvl+1); + pop_text_stack(q.lvl + 1); RECOVER_MACHINE_REGS(); return result; @@ -522,45 +519,46 @@ bool YAPEngine::mgoal(Term t, Term tmod, bool release) { #if YAP_PYTHON // PyThreadState *_save; - - //std::cerr << "mgoal " << YAPTerm(t).text() << "\n"; + std::cerr << "mgoal " << YAPTerm(t).text() << "\n"; // _save = PyEval_SaveThread(); #endif CACHE_REGS BACKUP_MACHINE_REGS(); Term *ts = nullptr; - q.CurSlot = Yap_StartSlots(); - q.p = P; - q.cp = CP; - PredEntry *ap = nullptr; - if (IsStringTerm(tmod)) - tmod = MkAtomTerm(Yap_LookupAtom(StringOfTerm(tmod))); - YAPPredicate *p = new YAPPredicate(t, tmod, ts, "C++"); - if (p == nullptr || (ap = p->ap) == nullptr || - ap->OpcodeOfPred == UNDEF_OPCODE) { - ap = rewriteUndefEngineQuery(ap, t, tmod); - } - if (IsApplTerm(t)) - ts = RepAppl(t) + 1; - else if (IsPairTerm(t)) - ts = RepPair(t); - /* legal ap */ - arity_t arity = ap->ArityOfPE; + q.CurSlot = Yap_StartSlots(); + q.p = P; + q.cp = CP; + PredEntry *ap = nullptr; + if (IsStringTerm(tmod)) + tmod = MkAtomTerm(Yap_LookupAtom(StringOfTerm(tmod))); + YAPPredicate *p = new YAPPredicate(t, tmod, ts, "C++"); + if (p == nullptr || (ap = p->ap) == nullptr || + ap->OpcodeOfPred == UNDEF_OPCODE) { + ap = rewriteUndefEngineQuery(ap, t, tmod); + } + if (IsApplTerm(t)) + ts = RepAppl(t) + 1; + else if (IsPairTerm(t)) + ts = RepPair(t); + /* legal ap */ + arity_t arity = ap->ArityOfPE; - for (arity_t i = 0; i < arity; i++) { - XREGS[i + 1] = ts[i]; - } - ts = nullptr; - bool result; - // allow Prolog style exception handling - // don't forget, on success these guys may create slots - //__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec "); + for (arity_t i = 0; i < arity; i++) { + XREGS[i + 1] = ts[i]; + } + ts = nullptr; + bool result; + // allow Prolog style exception handling + // don't forget, on success these guys may create slots + //__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec "); - result = (bool)YAP_EnterGoal(ap, nullptr, &q); - YAP_LeaveGoal(result && !release, &q); - // PyEval_RestoreThread(_save); - RECOVER_MACHINE_REGS(); - return result; + result = (bool)YAP_EnterGoal(ap, nullptr, &q); + std::cerr << "mgoal " << YAPTerm(t).text() << "\n"; + + YAP_LeaveGoal(result && !release, &q); + // PyEval_RestoreThread(_save); + RECOVER_MACHINE_REGS(); + return result; } /** * called when a query must be terminated and its state fully recovered, @@ -666,31 +664,29 @@ goal = YAPApplTerm(f, nts); } #endif - YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) { BACKUP_MACHINE_REGS(); try { arity_t arity = p.ap->ArityOfPE; - if (arity) { - goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts).term(); - for (arity_t i = 0; i < arity; i++) - XREGS[i + 1] = ts[i].term(); - openQuery(); - } else { - goal = MkAtomTerm((Atom)(p.ap->FunctorOfPred)); - openQuery(); + if (arity) { + goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts).term(); + for (arity_t i = 0; i < arity; i++) + XREGS[i + 1] = ts[i].term(); + openQuery(); + } else { + goal = MkAtomTerm((Atom)(p.ap->FunctorOfPred)); + openQuery(); + } + names = TermNil; + } catch (...) { } - names = TermNil; -} catch (...) { - - } -RECOVER_MACHINE_REGS(); + RECOVER_MACHINE_REGS(); } bool YAPQuery::next() { CACHE_REGS bool result = false; - //std::cerr << "next " << YAPTerm(goal).text() << "\n"; + // std::cerr << "next " << YAPTerm(goal).text() << "\n"; sigjmp_buf buf, *oldp = LOCAL_RestartEnv; e = nullptr; @@ -702,7 +698,7 @@ bool YAPQuery::next() { __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec "); if (q_state == 0) { - //Yap_do_low_level_trace = 1; + // Yap_do_low_level_trace = 1; result = (bool)YAP_EnterGoal(ap, nullptr, &q_h); } else { LOCAL_AllowRestart = q_open; @@ -710,19 +706,18 @@ bool YAPQuery::next() { } q_state = 1; __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result); -if (!result) { + if (!result) { YAP_LeaveGoal(result, &q_h); q_open = false; } - YAPCatchError(); + YAPCatchError(); RECOVER_MACHINE_REGS(); LOCAL_RestartEnv = oldp; return result; } PredEntry *YAPQuery::rewriteUndefQuery() { - ARG1 = goal = Yap_SaveTerm(Yap_MkApplTerm(FunctorCall - , 1, &goal)); + ARG1 = goal = Yap_SaveTerm(Yap_MkApplTerm(FunctorCall, 1, &goal)); return ap = PredCall; } @@ -894,7 +889,7 @@ PredEntry *YAPPredicate::getPred(Term &t, CELL *&out) { ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m)); return ap; } else if (IsPairTerm(t)) { - Term ts[2], *s = ( out ? out : ts ); + Term ts[2], *s = (out ? out : ts); Functor FunctorConsult = Yap_MkFunctor(Yap_LookupAtom("consult"), 1); s[1] = t; s[0] = m; @@ -909,7 +904,7 @@ PredEntry *YAPPredicate::getPred(Term &t, CELL *&out) { } else { ap = RepPredProp(PredPropByFunc(f, m)); if (out) - memmove( out, RepAppl(t) + 1, ap->ArityOfPE*sizeof(CELL) ); + memmove(out, RepAppl(t) + 1, ap->ArityOfPE * sizeof(CELL)); else out = RepAppl(t) + 1; } @@ -1017,12 +1012,12 @@ std::stringstream s; void YAPEngine::reSet() { /* ignore flags for now */ - if (B && B->cp_b && B->cp_ap != NOCODE ) - YAP_LeaveGoal(false, &q); + if (B && B->cp_b && B->cp_ap != NOCODE) + YAP_LeaveGoal(false, &q); LOCAL_ActiveError->errorNo = YAP_NO_ERROR; if (LOCAL_CommittedError) { LOCAL_CommittedError->errorNo = YAP_NO_ERROR; - free(LOCAL_CommittedError ); + free(LOCAL_CommittedError); LOCAL_CommittedError = NULL; } } diff --git a/CXX/yapt.hh b/CXX/yapt.hh index d841e9cbc..f07505234 100644 --- a/CXX/yapt.hh +++ b/CXX/yapt.hh @@ -223,19 +223,15 @@ public: /// return a string with a textual representation of the term virtual const char *text() { CACHE_REGS - encoding_t enc = LOCAL_encoding; char *os; BACKUP_MACHINE_REGS(); - if (!(os = Yap_TermToBuffer(Yap_GetFromSlot(t), enc, Handle_vars_f))) { + if (!(os = Yap_TermToBuffer(Yap_GetFromSlot(t), Handle_vars_f))) { RECOVER_MACHINE_REGS(); return 0; } RECOVER_MACHINE_REGS(); - size_t length = strlen(os); - char *sm = (char *)malloc(length + 1); - strcpy(sm, os); - return sm; + return os; }; /// return a handle to the term diff --git a/H/YapGFlagInfo.h b/H/YapGFlagInfo.h index 0e626dd11..26f1db738 100644 --- a/H/YapGFlagInfo.h +++ b/H/YapGFlagInfo.h @@ -56,16 +56,14 @@ opportunity. Initial value is 10,000. May be changed. A value of 0 ~~~ */ - - YAP_FLAG(ANSWER_FORMAT_FLAG, "answer_format", true, isatom, "~p", NULL), /**< how to present answers, default is `~p`. */ #if __ANDROID__ YAP_FLAG(ANDROID_FLAG, "android", false, booleanFlag, "true", NULL), /**< - read-only boolean, a machine running an Google's Android version of the Linux Operating System */ + read-only boolean, a machine running an Google's Android version of the + Linux Operating System */ #endif - #if __APPLE__ YAP_FLAG(APPLE_FLAG, "apple", false, booleanFlag, "true", NULL), /**< read-only boolean, a machine running an Apple Operating System */ @@ -132,20 +130,22 @@ opportunity. Initial value is 10,000. May be changed. A value of 0 Writable flag telling whether a character escapes are enabled, `true`, or disabled, `false`. The default value for this flag is `true`. */ - YAP_FLAG(COLON_SETS_CALLING_CONTEXT_FLAG, "colon_sets_calling_context", true, booleanFlag, "true", NULL), + YAP_FLAG(COLON_SETS_CALLING_CONTEXT_FLAG, "colon_sets_calling_context", + true, booleanFlag, "true", NULL), /**< `compiled_at ` - Read-only flag that gives the time when the main YAP binary was compiled. It - is obtained staight from the __TIME__ macro, as defined in the C99. - */ YAP_FLAG(COMPILED_AT_FLAG, "compiled_at", false, isatom, YAP_COMPILED_AT, + Read-only flag that gives the time when the main YAP binary was compiled. + It is obtained staight from the __TIME__ macro, as defined in the C99. + */ + YAP_FLAG(COMPILED_AT_FLAG, "compiled_at", false, isatom, YAP_COMPILED_AT, NULL), YAP_FLAG(DEBUG_FLAG, "debug", true, booleanFlag, "false", NULL), - /**< + /**< - If _Value_ is unbound, tell whether debugging is `true` or - `false`. If _Value_ is bound to `true` enable debugging, and if - it is bound to `false` disable debugging. - */ + If _Value_ is unbound, tell whether debugging is `true` or + `false`. If _Value_ is bound to `true` enable debugging, and if + it is bound to `false` disable debugging. +*/ YAP_FLAG(DEBUG_INFO_FLAG, "debug_info", true, booleanFlag, "true", NULL), YAP_FLAG(DEBUG_ON_ERROR_FLAG, "debug_on_error", true, booleanFlag, "true", NULL), @@ -155,15 +155,18 @@ opportunity. Initial value is 10,000. May be changed. A value of 0 */ YAP_FLAG(DEBUGGER_PRINT_OPTIONS_FLAG, "debugger_print_options", true, list_option, - "[quoted(true),numbervars(true),portrayed(true),max_depth(10)]", + "[quoted(true),numbervars(true),portrayed(true),max_depth(10)]", NULL), YAP_FLAG(DEBUGGER_SHOW_CONTEXT_FLAG, "debugger_show_context", true, booleanFlag, "false", NULL), - YAP_FLAG(DEFAULT_PARENT_MODULE_FLAG, "default_parent_module", true, isatom, "user", NULL), + YAP_FLAG(DEFAULT_PARENT_MODULE_FLAG, "default_parent_module", true, isatom, + "user", NULL), /**< - * A module to be inherited by all other modules. Default is user that reexports prolog. + * A module to be inherited by all other modules. Default is user that + * reexports prolog. * - * Set it to `prolog` for SICStus Prolog like resolution, to `user` for SWI-like. + * Set it to `prolog` for SICStus Prolog like resolution, to `user` for + * SWI-like. */ YAP_FLAG(DIALECT_FLAG, "dialect", false, ro, "yap", NULL), /**< @@ -275,11 +278,11 @@ vxu `on` consider `$` a lower case character. */ YAP_FLAG(INDEX_SUB_TERM_SEARCH_DEPTH_FLAG, "index_sub_term_search_depth", true, nat, "0", NULL), - /**< `Index_sub_term_search_depth ` + /**< `Index_sub_term_search_depth ` - Maximum bound on searching sub-terms for indexing, if `0` (default) no - bound. - */ + Maximum bound on searching sub-terms for indexing, if `0` (default) no + bound. +*/ YAP_FLAG(INFORMATIONAL_MESSAGES_FLAG, "informational_messages", true, isatom, "normal", NULL), /**< `informational_messages ` @@ -297,6 +300,8 @@ vxu `on` consider `$` a lower case character. value `toward_zero` for the current version of YAP. */ YAP_FLAG(ISO_FLAG, "iso", true, booleanFlag, "false", NULL), + YAP_FLAG(JUPYTER_FLAG, "jupyter", false, booleanFlag, "true", NULL), /**< + read-only boolean, a machine running Jupyter */ YAP_FLAG(LANGUAGE_FLAG, "language", true, isatom, "yap", NULL), /**< `language ` @@ -322,7 +327,7 @@ vxu `on` consider `$` a lower case character. Read-only flag telling the maximum arity of a functor. Takes the value `unbounded` for the current version of YAP. */ - YAP_FLAG(MAX_TAGGED_INTEGER_FLAG, "max_tagged_integer", false, at2n, + YAP_FLAG(MAX_TAGGED_INTEGER_FLAG, "max_tagged_integer", false, at2n, "INT_MAX", NULL), YAP_FLAG(MAX_THREADS_FLAG, "max_threads", false, at2n, "MAX_THREADS", NULL), YAP_FLAG(MAX_WORKERS_FLAG, "max_workers", false, at2n, "MAX_WORKERS", NULL), @@ -348,15 +353,14 @@ vxu `on` consider `$` a lower case character. providing access to shared libraries (`.so` files) or to dynamic link libraries (`.DLL` files). */ - /**< `module_independent_operators ` + /**< `module_independent_operators ` - If `true` an operator declaration will be valid for every module in the - program. This is for compatibility with old software that - might expect module-independent operators. - */ - YAP_FLAG(MODULE_INDEPENDENT_OPERATORS_FLAG, - "module_independent_operators", true, booleanFlag, - "false", NULL), + If `true` an operator declaration will be valid for every module in the + program. This is for compatibility with old software that + might expect module-independent operators. +*/ + YAP_FLAG(MODULE_INDEPENDENT_OPERATORS_FLAG, "module_independent_operators", + true, booleanFlag, "false", NULL), YAP_FLAG(OPTIMISE_FLAG, "optimise", true, booleanFlag, "false", NULL), YAP_FLAG(OS_ARGV_FLAG, "os_argv", false, os_argv, "@boot", NULL), @@ -372,14 +376,14 @@ vxu `on` consider `$` a lower case character. */ YAP_FLAG(PROMPT_ALTERNATIVES_ON_FLAG, "prompt_alternatives_on", true, isatom, "determinism", NULL), - /**< `prompt_alternatives_on(atom, - changeable) ` + /**< `prompt_alternatives_on(atom, + changeable) ` - SWI-Compatible option, determines prompting for alternatives in the Prolog - toplevel. Default is groundness, YAP prompts for alternatives if - and only if the query contains variables. The alternative, default in - SWI-Prolog is determinism which implies the system prompts for - alternatives if the goal succeeded while leaving choicepoints. */ + SWI-Compatible option, determines prompting for alternatives in the Prolog + toplevel. Default is groundness, YAP prompts for alternatives if + and only if the query contains variables. The alternative, default in + SWI-Prolog is determinism which implies the system prompts for + alternatives if the goal succeeded while leaving choicepoints. */ YAP_FLAG(QUASI_QUOTATIONS_FLAG, "quasi_quotations", true, booleanFlag, "true", NULL), YAP_FLAG(READLINE_FLAG, "readline", true, booleanFlag, "false", @@ -389,6 +393,15 @@ vxu `on` consider `$` a lower case character. enable the use of the readline library for console interactions, true by default if readline was found. */ + YAP_FLAG(REDEFINE_WARNINGS_FLAG, "redefine_warnings", true, booleanFlag, + "true", NULL), /**< + +If _Value_ is unbound, tell whether warnings for procedures defined +in several different files are `on` or +`off`. If _Value_ is bound to `on` enable these warnings, +and if it is bound to `off` disable them. The default for YAP is +`off`, unless we are in `sicstus` or `iso` mode. +*/ YAP_FLAG(REPORT_ERROR_FLAG, "report_error", true, booleanFlag, "true", NULL), YAP_FLAG(RESOURCE_DATABASE_FLAG, "resource_database", false, isatom, @@ -424,6 +437,15 @@ vxu `on` consider `$` a lower case character. /**< `single_quoted text is usuallly interpreted as atoms. This flagTerm allows other inerpretations such as strings_contains_strings */ + YAP_FLAG(SINGLE_VAR_WARNINGS_FLAG, "single_var_warnings", true, booleanFlag, + "true", NULL), /**< + If `true` (default `true`) YAP checks for singleton + variables when loading files. A singleton variable is a + variable that appears ony once in a clause. The name + must start with a capital letter, variables whose name + starts with underscore are never considered singleton. + + */ YAP_FLAG(SIGNALS_FLAG, "signals", true, booleanFlag, "true", NULL), /**< `signals` @@ -482,8 +504,7 @@ vxu `on` consider `$` a lower case character. */ YAP_FLAG(THREADS_FLAG, "threads", false, ro, "MAX_THREADS", NULL), YAP_FLAG(TIMEZONE_FLAG, "timezone", false, ro, "18000", NULL), - YAP_FLAG(TOPLEVEL_HOOK_FLAG, "toplevel_hook", true, - booleanFlag, "true", + YAP_FLAG(TOPLEVEL_HOOK_FLAG, "toplevel_hook", true, booleanFlag, "true", NULL), /**< `toplevel_hook ` @@ -493,7 +514,7 @@ vxu `on` consider `$` a lower case character. backtracked into. */ - YAP_FLAG(TOPLEVEL_PRINT_ANON_FLAG, "toplevel_print_anon", true, booleanFlag, + YAP_FLAG(TOPLEVEL_PRINT_ANON_FLAG, "toplevel_print_anon", true, booleanFlag, "true", NULL), YAP_FLAG(TOPLEVEL_PRINT_OPTIONS_FLAG, "toplevel_print_options", true, list_option, "[quoted(true),numbervars(true),portrayed(true)]", @@ -527,9 +548,9 @@ vxu `on` consider `$` a lower case character. are `silent`, `warning` and `error`. The first two create the flag on-the-fly, with `warning` printing a message. The value `error` is consistent with ISO: it raises an existence error and does not create the - flag. See also `create_prolog_flag/3`. The default is`error`, and developers - are encouraged to use `create_prolog_flag/3` to create flags for their - library. + flag. See also `create_prolog_flag/3`. The default is`error`, and + developers are encouraged to use `create_prolog_flag/3` to create flags for + their library. */ YAP_FLAG(UNKNOWN_FLAG, "unknown", true, isatom, "error", Yap_unknown), /**< `unknown is iso` diff --git a/H/YapLFlagInfo.h b/H/YapLFlagInfo.h index 24c16cc53..22cce7aa7 100644 --- a/H/YapLFlagInfo.h +++ b/H/YapLFlagInfo.h @@ -1,21 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 2015- * -* * -************************************************************************** -* * -* File: YapLFlagInfo.h * -* Last rev: * -* mods: * -* comments: local flag enumeration. * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 2015- * + * * + ************************************************************************** + * * + * File: YapLFlagInfo.h * Last rev: + ** mods: * comments: local flag enumeration. * + * * + *************************************************************************/ /** @file YapLFlagInfo.h @@ -30,74 +28,75 @@ START_LOCAL_FLAGS - /** + `autoload`: set the system to look for undefined procedures */ -YAP_FLAG( AUTOLOAD_FLAG, "autoload", true, booleanFlag, "false" , NULL ), -/** + `read-only flag, that tells if Prolog is in an inner top-level */ -YAP_FLAG( BREAK_LEVEL_FLAG, "break_level", true, nat, "0" , NULL ), -YAP_FLAG( CALL_COUNTING_FLAG, "call_counting", true, booleanFlag, "true" , NULL ), /** + `call_counting` +/** + `autoload`: set the system to look for undefined procedures */ +YAP_FLAG(AUTOLOAD_FLAG, "autoload", true, booleanFlag, "false", NULL), + /** + `read-only flag, that tells if Prolog is in an inner top-level */ + YAP_FLAG(BREAK_LEVEL_FLAG, "break_level", true, nat, "0", NULL), + YAP_FLAG(CALL_COUNTING_FLAG, "call_counting", true, booleanFlag, "true", + NULL), /** + `call_counting` - Predicates compiled with this flag set maintain a counter on the numbers of proceduree calls and of retries. These counters are decreasing counters, and they can be used as timers. Three counters are available: + Predicates compiled with this flag set maintain a counter + on the numbers of proceduree calls and of retries. These counters + are decreasing counters, and they can be used as timers. Three + counters are available: - calls: number of predicate calls since execution started or since system was reset; - retries: number of retries for predicates called since execution started or since counters were reset; - calls_and_retries: count both on predicate calls and retries. - These counters can be used to find out how many calls a certain goal takes to execute. They can also be force the computatiom yp - stopping. + calls: number of predicate calls since execution started or + since system was reset; retries: number of retries for predicates + called since execution started or since counters were reset; + calls_and_retries: count both on predicate calls and + retries. These counters can be used to find out how many calls a + certain goal takes to execute. They can also be force the + computatiom yp stopping. - If `on` `fileerrors` is `on`, if `off` (default) - `fileerrors` is disabled. - */ -YAP_FLAG( ENCODING_FLAG, "encoding", true, isatom, "utf-8" , getenc ), -YAP_FLAG( FILEERRORS_FLAG, "fileerrors", true, booleanFlag, "true" , NULL ), /** + `fileerrors` + If `on` `fileerrors` is `on`, if `off` (default) + `fileerrors` is disabled. + */ + YAP_FLAG(ENCODING_FLAG, "encoding", true, isatom, "utf-8", getenc), + YAP_FLAG(FILEERRORS_FLAG, "fileerrors", true, booleanFlag, "true", + NULL), /** + `fileerrors` - If `on` `fileerrors` is `on`, if `off` (default) - `fileerrors` is disabled. - */ -YAP_FLAG( LANGUAGE_MODE_FLAG, "language_mode", true, isatom, "yap" , NULL ), /** + `language_mode` + If `on` `fileerrors` is `on`, if `off` (default) + `fileerrors` is disabled. + */ + YAP_FLAG(LANGUAGE_MODE_FLAG, "language_mode", true, isatom, "yap", + NULL), /** + `language_mode` - wweter native mode or trying to emulate a different Prolog. - */ -YAP_FLAG( REDEFINE_WARNINGS_FLAG, "redefine_warnings", true, booleanFlag, "true" , NULL ), /** + `redefine_warnings ` + wweter native mode or trying to emulate a different Prolog. + */ + YAP_FLAG(STACK_DUMP_ON_ERROR_FLAG, "stack_dump_on_error", true, booleanFlag, + "true", NULL), /** + `stack_dump_on_error ` - If _Value_ is unbound, tell whether warnings for procedures defined -in several different files are `on` or -`off`. If _Value_ is bound to `on` enable these warnings, -and if it is bound to `off` disable them. The default for YAP is -`off`, unless we are in `sicstus` or `iso` mode. - */ -YAP_FLAG( SINGLE_VAR_WARNINGS_FLAG, "single_var_warnings", true, booleanFlag, "true" , NULL ), /** + `single_var_warnings` - If `true` (default `true`) YAP checks for singleton variables when loading files. A singleton variable is a variable that appears ony once in a clause. The name must start with a capital letter, variables whose name starts with underscore are never considered singleton. - - */ -YAP_FLAG( STACK_DUMP_ON_ERROR_FLAG, "stack_dump_on_error", true, booleanFlag, "false" , NULL ), /** + `stack_dump_on_error ` - - If `true` show a stack dump when YAP finds an error. The default is +If `true` show a stack dump when YAP finds an error. The default is `off`. - */ -YAP_FLAG( STREAM_TYPE_CHECK_FLAG, "stream_type_check", true, isatom, "loose" , NULL ), -YAP_FLAG( SYNTAX_ERRORS_FLAG, "syntax_errors", true, synerr, "error" , NULL ), /** + `syntax_errors` +*/ + YAP_FLAG(STREAM_TYPE_CHECK_FLAG, "stream_type_check", true, isatom, "loose", + NULL), + YAP_FLAG(SYNTAX_ERRORS_FLAG, "syntax_errors", true, synerr, "error", + NULL), /** + `syntax_errors` - Control action to be taken after syntax errors while executing read/1, +Control action to be taken after syntax errors while executing read/1, `read/2`, or `read_term/3`: - + `dec10` ++ `dec10` Report the syntax error and retry reading the term. - + `fail` ++ `fail` Report the syntax error and fail. - + `error` ++ `error` Report the syntax error and generate an error (default). - + `quiet` ++ `quiet` Just fail - */ -YAP_FLAG( TYPEIN_MODULE_FLAG, "typein_module", true, isatom, "user" , typein ), /** + `typein_module ` +*/ + YAP_FLAG(TYPEIN_MODULE_FLAG, "typein_module", true, isatom, "user", + typein), /** + `typein_module ` - If bound, set the current working or type-in module to the argument, +If bound, set the current working or type-in module to the argument, which must be an atom. If unbound, unify the argument with the current working module. - */ - YAP_FLAG( USER_ERROR_FLAG, "user_error", true, stream, "user_error" , set_error_stream ), /** + `user_error1` +*/ + YAP_FLAG(USER_ERROR_FLAG, "user_error", true, stream, "user_error", + set_error_stream), /** + `user_error1` - If the second argument is bound to a stream, set user_error to +If the second argument is bound to a stream, set user_error to this stream. If the second argument is unbound, unify the argument with the current user_error stream. By default, the user_error stream is set to a stream @@ -105,30 +104,32 @@ corresponding to the Unix `stderr` stream. The next example shows how to use this flag: ~~~{.prolog} - ?- open( '/dev/null', append, Error, - [alias(mauri_tripa)] ). +?- open( '/dev/null', append, Error, +[alias(mauri_tripa)] ). - Error = '$stream'(3) ? ; +Error = '$stream'(3) ? ; - no - ?- set_prolog_flag(user_error, mauri_tripa). +no +?- set_prolog_flag(user_error, mauri_tripa). - close(mauri_tripa). +close(mauri_tripa). - yes - ?- +yes +?- ~~~ - We execute three commands. First, we open a stream in write mode and +We execute three commands. First, we open a stream in write mode and give it an alias, in this case `mauri_tripa`. Next, we set user_error to the stream via the alias. Note that after we did so prompts from the system were redirected to the stream `mauri_tripa`. Last, we close the stream. At this point, YAP automatically redirects the user_error alias to the original `stderr`. - */ -YAP_FLAG( USER_INPUT_FLAG, "user_input", true, stream, "user_input" , set_input_stream ), - YAP_FLAG( USER_OUTPUT_FLAG, "user_output", true, stream, "user_output" , set_output_stream ), +*/ + YAP_FLAG(USER_INPUT_FLAG, "user_input", true, stream, "user_input", + set_input_stream), + YAP_FLAG(USER_OUTPUT_FLAG, "user_output", true, stream, "user_output", + set_output_stream), -END_LOCAL_FLAGS + END_LOCAL_FLAGS -/// @} + /// @} diff --git a/H/Yapproto.h b/H/Yapproto.h index 1d170177e..89c85cc56 100755 --- a/H/Yapproto.h +++ b/H/Yapproto.h @@ -35,6 +35,7 @@ extern int Yap_HasOp(Atom); extern struct operator_entry * Yap_GetOpPropForAModuleHavingALock(struct AtomEntryStruct *, Term); extern Atom Yap_LookupAtom(const char *); +extern Atom Yap_AtomInUse(const char *atom); extern Atom Yap_ULookupAtom(const unsigned char *); extern Atom Yap_LookupAtomWithLength(const char *, size_t); extern Atom Yap_FullLookupAtom(const char *); diff --git a/H/Yatom.h b/H/Yatom.h index 0b1906f7e..522bc507f 100755 --- a/H/Yatom.h +++ b/H/Yatom.h @@ -1298,7 +1298,7 @@ INLINE_ONLY bool IsFlagProperty(PropFlags flags) { /* Proto types */ -extern char *Yap_TermToBuffer(Term t, encoding_t encoding, int flags); +extern char *Yap_TermToBuffer(Term t, int flags); extern Term Yap_BufferToTerm(const char *s, Term opts); diff --git a/include/YapDefs.h b/include/YapDefs.h index fac25cc84..a48254343 100755 --- a/include/YapDefs.h +++ b/include/YapDefs.h @@ -203,6 +203,8 @@ typedef struct yap_boot_params { const char *INPUT_STARTUP; //> bootstrapping mode: YAP is not properly installed bool install; + //> jupyter mode: YAP is in space + bool jupyter; //> generats a saved space at this path const char *OUTPUT_STARTUP; //> if NON-0, minimal size for Heap or Code Area diff --git a/library/dialect/swi/fli/swi.c b/library/dialect/swi/fli/swi.c index b72baf35d..568ecf6a2 100755 --- a/library/dialect/swi/fli/swi.c +++ b/library/dialect/swi/fli/swi.c @@ -817,6 +817,14 @@ X_API int PL_unify_bool(term_t t, int a) { return Yap_unify(Yap_GetFromSlot(t), iterm); } +X_API int PL_put_bool(term_t t, int a) { + CACHE_REGS + CELL *pt = Yap_AddressFromHandle( t ); + Term iterm = (a ? MkAtomTerm(AtomTrue) : MkAtomTerm(AtomFalse)); + *pt = iterm; + return true; +} + #if USE_GMP /******************************* @@ -1272,7 +1280,7 @@ YAP: NO EQUIVALENT */ X_API int PL_raise_exception(term_t exception) { CACHE_REGS LOCAL_Error_TYPE = THROW_EVENT; - LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(Yap_GetFromHandle(exception), LOCAL_encoding, TermNil); + LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(Yap_GetFromHandle(exception), 0); //Yap_PutException(Yap_GetFromSlot(exception)); Yap_RaiseException(); return 0; @@ -1320,7 +1328,7 @@ X_API int PL_unify_atom_chars(term_t t, const char *s) { Atom at; while ((at = Yap_CharsToAtom(s, ENC_ISO_LATIN1 PASS_REGS)) == 0L) { if (LOCAL_Error_TYPE && !Yap_SWIHandleError("PL_unify_atom_nchars")) - return FALSE; + return true; } Yap_AtomIncreaseHold(at); return Yap_unify(Yap_GetFromSlot(t), MkAtomTerm(at)); diff --git a/os/writeterm.c b/os/writeterm.c index fe2b279f3..02f177327 100644 --- a/os/writeterm.c +++ b/os/writeterm.c @@ -672,7 +672,7 @@ static Int term_to_string(USES_REGS1) { Term t2 = Deref(ARG2), rc = false, t1 = Deref(ARG1); const char *s; if (IsVarTerm(t2)) { - s = Yap_TermToBuffer(ARG1, LOCAL_encoding, Quote_illegal_f | Handle_vars_f); + s = Yap_TermToBuffer(t1, Quote_illegal_f | Handle_vars_f); if (!s || !MkStringTerm(s)) { Yap_Error(RESOURCE_ERROR_HEAP, t1, "Could not get memory from the operating system"); @@ -692,7 +692,7 @@ static Int term_to_atom(USES_REGS1) { Term t2 = Deref(ARG2), ctl, rc = false; Atom at; if (IsVarTerm(t2)) { - const char *s = Yap_TermToBuffer(Deref(ARG1), LOCAL_encoding, + const char *s = Yap_TermToBuffer(Deref(ARG1), Quote_illegal_f | Handle_vars_f); if (!s || !(at = Yap_UTF8ToAtom((const unsigned char *)s))) { Yap_Error(RESOURCE_ERROR_HEAP, t2, diff --git a/os/yapio.h b/os/yapio.h index 2fd961bcc..76ee6f0bb 100644 --- a/os/yapio.h +++ b/os/yapio.h @@ -89,7 +89,7 @@ extern int Yap_GetCharForSIGINT(void); extern Int Yap_StreamToFileNo(Term); extern int Yap_OpenStream(Term tin, const char* io_mode, Term user_name, encoding_t enc); extern int Yap_FileStream(FILE*, char *, Term, int, VFS_t *); -extern char *Yap_TermToBuffer(Term t, encoding_t encoding, int flags); +extern char *Yap_TermToBuffer(Term t, int flags); extern char *Yap_HandleToString(yhandle_t l, size_t sz, size_t *length, encoding_t *encoding, int flags); extern int Yap_GetFreeStreamD(void); diff --git a/packages/python/py2pl.c b/packages/python/py2pl.c index 4f8d1a11c..d6606001f 100644 --- a/packages/python/py2pl.c +++ b/packages/python/py2pl.c @@ -50,7 +50,8 @@ foreign_t assign_to_symbol(term_t t, PyObject *e) { return PyObject_SetAttrString(dic, s, e) == 0; } -static int python_to_term__(PyObject *pVal, term_t t) { +foreign_t python_to_term(PyObject *pVal, term_t t) +{ bool rc = true; term_t to = PL_new_term_ref(); // fputs(" <<*** ",stderr); PyObject_Print(pVal,stderr,0); @@ -89,13 +90,10 @@ static int python_to_term__(PyObject *pVal, term_t t) { #else const char *s = PyUnicode_AsUTF8(pVal); #endif - // if (PyDict_GetItemString(py_Atoms, s)) - // rc = rc && PL_unify_atom_chars(t, s); - // else - rc = - rc && (PL_is_string(t) ? PL_unify_string_chars(t, s) - : PL_is_variable(t) ? PL_unify_atom_chars(t, s) - : PL_unify_atom_chars(t, s)); + if (Yap_AtomInUse(s)) + rc = rc && PL_unify_atom_chars(t, s); + else + rc = rc && PL_unify_string_chars(t, s); } else if (PyByteArray_Check(pVal)) { rc = rc && PL_unify_string_chars(t, PyByteArray_AsString(pVal)); #if PY_MAJOR_VERSION < 3 @@ -133,15 +131,18 @@ static int python_to_term__(PyObject *pVal, term_t t) { } if (PL_unify_functor(t, f)) { for (i = 0; i < sz; i++) { - if (!PL_get_arg(i + 1, t, to)) + term_t to = PL_new_term_ref(); + if (!PL_get_arg(i + 1, t, to)) rc = false; PyObject *p = PyTuple_GetItem(pVal, i); if (p == NULL) { PyErr_Clear(); p = Py_None; - } - rc = rc && python_to_term__(p, to); - } + } else { + rc = rc && python_to_term(p, to); + } + PL_reset_term_refs(to); + } } else { rc = false; } @@ -153,11 +154,13 @@ static int python_to_term__(PyObject *pVal, term_t t) { for (i = 0; i < sz; i++) { PyObject *obj; + term_t to = PL_new_term_ref(); rc = rc && PL_unify_list(t, to, t); if ((obj = PyList_GetItem(pVal, i)) == NULL) { obj = Py_None; } - rc = rc && python_to_term__(obj, to); + rc = rc && python_to_term(obj, to); + PL_reset_term_refs(to); if (!rc) return false; } @@ -166,7 +169,6 @@ static int python_to_term__(PyObject *pVal, term_t t) { // Yap_DebugPlWrite(yt); fputs("[***]\n", stderr); } else if (PyDict_Check(pVal)) { Py_ssize_t pos = 0; - term_t to = PL_new_term_ref(), ti = to; int left = PyDict_Size(pVal); PyObject *key, *value; @@ -176,11 +178,12 @@ static int python_to_term__(PyObject *pVal, term_t t) { while (PyDict_Next(pVal, &pos, &key, &value)) { term_t tkey = PL_new_term_ref(), tval = PL_new_term_ref(), tint, tnew = PL_new_term_ref(); + term_t to = PL_new_term_ref(); /* do something interesting with the values... */ - if (!python_to_term__(key, tkey)) { + if (!python_to_term(key, tkey)) { continue; } - if (!python_to_term__(value, tval)) { + if (!python_to_term(value, tval)) { continue; } /* reuse */ @@ -194,25 +197,26 @@ static int python_to_term__(PyObject *pVal, term_t t) { PL_reset_term_refs(tkey); rc = false; } - if (!PL_unify(ti, tint)) { + if (!PL_unify(to, tint)) { rc = false; } - ti = tnew; - PL_reset_term_refs(tkey); } rc = rc && PL_unify(t, to); } } else { rc = rc && repr_term(pVal, t); } - PL_reset_term_refs(to); + return rc; } + + + X_API YAP_Term pythonToYAP(PyObject *pVal) { term_t t = PL_new_term_ref(); - if (pVal == NULL || !python_to_term__(pVal, t)) { + if (pVal == NULL || !python_to_term(pVal, t)) { PL_reset_term_refs(t); return 0; } @@ -224,13 +228,6 @@ X_API YAP_Term pythonToYAP(PyObject *pVal) { PyObject *py_Local, *py_Global; -X_API foreign_t python_to_term(PyObject *pVal, term_t t) { - yap_error_descriptor_t *ctx = malloc(sizeof(yap_error_descriptor_t)); - bool newxp = Yap_pushErrorContext(true, ctx); - int rc = python_to_term(pVal, t); - Yap_popErrorContext(newxp, true); - return rc; -} /** * assigns the Python RHS to a Prolog term LHS, ie LHS = RHS diff --git a/packages/python/swig/yap4py/yapi.py b/packages/python/swig/yap4py/yapi.py index 06aff6c4c..5f135e122 100644 --- a/packages/python/swig/yap4py/yapi.py +++ b/packages/python/swig/yap4py/yapi.py @@ -41,6 +41,18 @@ class Engine( YAPEngine ): self.goal(release) +class JupyterEngine( Engine ): + + def __init__(self, args=None,self_contained=False,**kwargs): + # type: (object) -> object + if not args: + args = EngineArgs(**kwargs) + args.jupyter = True + Engine.__init__(self, args) + self.goal(set_prolog_flag('verbose', 'silent'),True) + self.goal(compile(library('jupyter')), True) + self.goal(set_prolog_flag('verbose', 'normal'), True) + class EngineArgs( YAPEngineArgs ): """ Interface to Engine Options class""" def __init__(self, args=None,**kwargs): diff --git a/packages/python/yap_kernel/CMakeLists.txt b/packages/python/yap_kernel/CMakeLists.txt index 02422978c..aaa190107 100644 --- a/packages/python/yap_kernel/CMakeLists.txt +++ b/packages/python/yap_kernel/CMakeLists.txt @@ -273,14 +273,15 @@ set (RESOURCES #yap_kernel/resources/logo-32x32.png #yap_kernel/resourcess/logo-64x64.png ) - -set (RENAMED_RESOURCES + +set (RENAMED_RESOURCES yap_kernel/resources/logo-32x32.png yap_kernel/resources/logo-64x64.png # yap_kernel/resources/codemirror/mode/prolog/prolog.js ) set (PL_SOURCES yap_ipython/prolog/jupyter.yap yap_ipython/prolog/complete.yap + yap_ipython/prolog/verify.yap ) set(FILES ${PYTHON_SOURCES} ${PL_SOURCES} ${EXTRAS} ${RESOURCES}) @@ -321,7 +322,7 @@ add_custom_target(YAP_KERNEL ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/yap_kernel/resources/logo-32x32.png ${CMAKE_CURRENT_BINARY_DIR}/yap_kernel/resources/logo-64x64.png yap.tgz ${CMAKE_CURRENT_BINARY_DIR}/yap_kernel/resources/kernel.js ${CMAKE_CURRENT_BINARY_DIR}/yap_kernel/resources/prolog.js ${CMAKE_CURRENT_BINARY_DIR}/yap.tgz ) - + install(CODE "execute_process( COMMAND ${PYTHON_EXECUTABLE} ${SETUP_PY} build sdist bdist COMMAND ${PYTHON_EXECUTABLE} -m pip install ${PYTHON_USER_INSTALL} --ignore-installed --no-deps . diff --git a/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap b/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap index 9fda6e2f8..68dc78bf8 100644 --- a/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap +++ b/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap @@ -4,6 +4,7 @@ * @brief JUpyter support. */ +:- yap_flag(gc_trace,verbose). % :- module( jupyter, % [jupyter_query/3, @@ -20,16 +21,11 @@ :- use_module(library(python)). :- use_module(library(yapi)). :- use_module(library(complete)). -:- use_module(library(verify)). :- python_import(sys). -jupyter_query(Caller, Prog, Query ) :- - catch( - jupyter_cell(Caller, Prog, Query), - error(L,E), - system_error(L,E) - ). +jupyter_query(Caller, Cell, Line ) :- + jupyter_cell(Caller, Cell, Line). jupyter_cell(_Caller, Cell, _Line) :- jupyter_consult(Cell), %stack_dump, @@ -38,39 +34,162 @@ jupyter_cell( _Caller, _, '' ) :- !. jupyter_cell( _Caller, _, Line ) :- blank( Line ), !. -jupyter_cell( Self, _, Line ) :- - %Self := Caller.query, - python_query(Self,Line). +jupyter_cell( Caller, _, Line ) :- + Self := Caller.query, + catch( + python_query(Self,Line), + E=error(A,B), + system_error(A,B) + ). +jupyter_cell(_,_,_). + +restreams(call) :- + streams(true). +restreams(fail) :- + streams(false). +restreams(answer). +restreams(exit) :- + streams(false). +restreams(!). +restreams(external_exception(_)). +restreams(exception). jupyter_consult(Text) :- blank( Text ), !. jupyter_consult(Cell) :- - open_mem_read_stream( Cell, Stream), - load_files(user:'jupyter cell',[stream(Stream)]). - - blank(Text) :- - atom(Text), - !, - atom_codes(Text, L), - maplist( code_type(space), L). - blank(Text) :- - string(Text), - !, - string_codes(Text, L), - maplist( code_type(space), L). +% Name = 'Inp', +% stream_property(Stream, file_name(Name) ), +% setup_call_cleanup( + catch( + ( + Options = [], + open_mem_read_stream( Cell, Stream), + load_files(user:'jupyter cell',[stream(Stream)| Options]) + ), + E=error(A,B), + (close(Stream), system_error(A,B)) + ), + fail. +jupyter_consult(_Cell). +blank(Text) :- + atom(Text), + !, + atom_codes(Text, L), + maplist( code_type(space), L). +blank(Text) :- + string(Text), + !, + string_codes(Text, L), + maplist( code_type(space), L). streams(false) :- - nb_setval(jupyter_cell, false), close(user_input), close(user_output), close(user_error). streams(true) :- - nb_setval(jupyter_cell, true), - open('/python/input', read, _Input, [alias(user_input),bom(false),script(false)]), - open('/python/sys.stdout', append, _Output, [alias(user_output)]), - open('/python/sys.stderr', append, _Error, [alias(user_error)]). + open('/python/input', read, Input, [alias(user_input),bom(false),script(false)]), + open('/python/sys.stdout', append, Output, [alias(user_output)]), + open('/python/sys.stderr', append, Error, [alias(user_error)]). + +ready(_Self, Line ) :- + blank( Line ), + !. +ready(Self, Line ) :- + errors( Self, Line ), + \+ syntax_error(_,_). + +errors( Self, Text ) :- + setup_call_cleanup( + open_events( Self, Text, Stream), + goals(Self, Stream), + close_events( Self ) + ). + +clauses(_Self, Stream) :- + repeat, + read_clause(Stream, Cl, [term_position(_Pos), syntax_errors(fail)] ), +% command( Self, Cl ), + Cl == end_of_file, + !. + +goals(_Self, Stream) :- + repeat, + read_term(Stream, Cl, [term_position(_Pos), syntax_errors(fail)] ), +% command( Self, Cl ), + Cl == end_of_file, + !. + +command(_, end_of_file) :- !. + +command( _Self, ( :- op(Prio,Assoc,Name) ) ) :- + addop(Prio,Assoc,Name). + +command( _Self, ( :- module(Name, Exports) )) :- + retract( active_module( M0 ) ), + atom_concat( '__m0_', Name, M ), + assert( active_module(M) ), + assert( undo( active_module(M0) ) ), + maplist( addop2(M), Exports). + + +addop(Prio,Assoc,Name) :- + ( + current_op(OPrio, SimilarAssoc, Name), + op(Prio, Assoc, Name), + matched_op(Assoc, SimilarAssoc) + -> + assertz( undo(op( OPrio, Assoc, Name ) ) ) + ; + assertz( undo(op( 0, Assoc, Name ) ) ) + ). + +addop2(M, op(Prio, Assoc, Name)) :- + addop( Prio, Assoc, M:Name ). + +matched_op(A, B) :- + optype( A, T), + optype( B, T). + +optype(fx,pre). +optype(fy,pre). +optype(xfx,in). +optype(xfy,in). +optype(yfx,in). +optype(yfy,in). +optype(xf,pos). +optype(yf,pos). + +:- dynamic user:portray_message/2. +:- multifile user:portray_message/2. + +:- dynamic syntax_error/4, undo/1. + +user:portray_message(_Severity, error(syntax_error(Cause),info(between(_,LN,_), _FileName, CharPos, Details))) :- + nb_getval(jupyter_cell, on), + assert( syntax_error(Cause,LN,CharPos,Details) ). +user:portray_message(_Severity, error(style_check(_),_) ) :- + nb_getval(jupyter_cell, on). + +open_events(Self, Text, Stream) :- + Self.errors := [], + nb_setval( jupyter, on), + open_mem_read_stream( Text, Stream ). + +:- initialization( nb_setval( jupyter, off ) ). + +close_events( _Self ) :- + nb_setval( jupyter, off ), + retract( undo(G) ), + call(G), + fail. +close_events( Self ) :- + retract( syntax_error( C, L, N, A )), + Self.errors := [t(C,L,N,A)] + Self.errors, + fail. +close_events( _ ). + :- if( current_prolog_flag(apple, true) ). diff --git a/packages/python/yap_kernel/yap_ipython/prolog/verify.yap b/packages/python/yap_kernel/yap_ipython/prolog/verify.yap index 20739cfb0..e951d38bf 100644 --- a/packages/python/yap_kernel/yap_ipython/prolog/verify.yap +++ b/packages/python/yap_kernel/yap_ipython/prolog/verify.yap @@ -22,45 +22,41 @@ s % completion/2, :- python_import(sys). -all_clear( Self, _Cell, P, Q) :- - no_errors( Self, P ), - yap_flag(singleton_variables, Old, false), - no_errors( Self, Q ), - yap_flag(singleton_variables, _, Old). +p_errors( Errors, Cell) :- + blank( Cell ), + !. +p_errors( Errors, Cell) :- + no_errors( Errors , Cell ). -no_errors( _Self, Text ) :- +no_errors( _Errors , Text ) :- blank(Text). -no_errors( Self, Text ) :- +no_errors( Errors , Text ) :- setup_call_cleanup( - open_esh( Self, Text, Stream), - esh(Self, Stream), - close_esh( Self, Stream ) + open_esh( Errors , Text, Stream), + esh(Errors , Stream), + close_esh( Errors , Stream ) ). -syntax(_Self, E) :- writeln(user_error, E), fail. -syntax(Self, error(syntax_error(Cause),info(between(_,LN,_), _FileName, CharPos, Details))) :- - Self.errors := [t(Cause,LN,CharPos,Details)] + Self.errors, +syntax(_Errors , E) :- writeln(user_error, E), fail. +syntax(Errors , error(syntax_error(Cause),info(between(_,LN,_), _FileName, CharPos, Details))) :- + Errors.errors := [t(Cause,LN,CharPos,Details)] + Errors.errors, !. -syntax(_Self, E) :- throw(E). +syntax(_Errors , E) :- throw(E). -open_esh(Self, Text, Stream) :- - Self.errors := [], +open_esh(_Errors , Text, Stream) :- open_mem_read_stream( Text, Stream ). -esh(Self, Stream) :- +esh(Errors , Stream) :- repeat, - catch( + catch( read_clause(Stream, Cl, [term_position(_Pos), syntax_errors(fail)] ), Error, - syntax(Self, Error) + syntax(Errors , Error) ), Cl == end_of_file, - !, - V := Self.errors, - V == []. + !. -close_esh( _Self, Stream ) :- +close_esh( _Errors , Stream ) :- close(Stream). - diff --git a/packages/python/yap_kernel/yap_ipython/yapi.py b/packages/python/yap_kernel/yap_ipython/yapi.py index 437ad643b..562f2bd34 100644 --- a/packages/python/yap_kernel/yap_ipython/yapi.py +++ b/packages/python/yap_kernel/yap_ipython/yapi.py @@ -23,11 +23,11 @@ library = namedtuple('library', 'list') v = namedtuple('_', 'slot') load_files = namedtuple('load_files', 'file ofile args') python_query = namedtuple('python_query', 'query_mgr string') -jupyter_query = namedtuple('jupyter_query', 'self text p q') +jupyter_query = namedtuple('jupyter_query', 'self text query') enter_cell = namedtuple('enter_cell', 'self' ) exit_cell = namedtuple('exit_cell', 'self' ) completions = namedtuple('completions', 'txt self' ) -errors = namedtuple('errors', 'self text p q' ) +errors = namedtuple('errors', 'self text' ) streams = namedtuple('streams', ' text' ) nostreams = namedtuple('nostreams', ' text' ) @@ -114,7 +114,7 @@ class YAPInputSplitter(InputSplitter): if not line: line = text.rstrip() self.errors = [] - engine.mgoal(errors(self, text ,text,''),"user",True) + engine.mgoal(errors(self, line),"user",True) return self.errors != [] @@ -510,17 +510,16 @@ class YAPRun: def __init__(self, shell): self.shell = shell - self.yapeng = Engine() + self.yapeng = JupyterEngine() global engine engine = self.yapeng - self.yapeng.goal(use_module(library("jupyter")),True) self.query = None self.os = None self.it = None self.shell.yapeng = self.yapeng self._get_exc_info = shell._get_exc_info - def syntaxErrors(self, text,program,query): + def syntaxErrors(self, text): """Return whether a legal query """ if not text: @@ -528,7 +527,8 @@ class YAPRun: if text == self.os: return self.errors self.errors=[] - self.yapeng.mgoal(errors(self,text,program,query),"user",True) + (text,_,_,_) = self.clean_end(text) + self.yapeng.mgoal(errors(self,text),"user",True) return self.errors def jupyter_query(self, s): @@ -572,7 +572,6 @@ class YAPRun: except Exception as e: sys.stderr.write('Exception after', self.bindings, '\n') has_raised = True - self.yapeng.mgoal(streams(False),"user", True) return False,[] @@ -654,8 +653,7 @@ class YAPRun: # except SyntaxError: # preprocessing_exc_tuple = self.shell.syntax_error() # sys.exc_info() cell = raw_cell # cell has to exist so it can be stored/logged - (text,program,query,_) = self.clean_end(raw_cell) - for i in self.syntaxErrors(raw_cell,raw_cell,''): + for i in self.syntaxErrors(raw_cell): try: (what,lin,_,text) = i e = SyntaxError(what, ("", lin, 1, text)) @@ -730,13 +728,13 @@ class YAPRun: # state = tracer.runfunc(jupyter_query( self, cell ) ) self.shell.last_execution_succeeded = True self.result.result = (True, dicts) - self.yapeng.mgoal(streams(False),"user", True) except Exception as e: has_raised = True self.result.result = False self.yapeng.mgoal(streams(False),"user", True) + self.yapeng.mgoal(streams(False),"user", True) self.shell.last_execution_succeeded = not has_raised # Reset this so later displayed values do not modify the diff --git a/pl/absf.yap b/pl/absf.yap index 58d56817d..df1967057 100755 --- a/pl/absf.yap +++ b/pl/absf.yap @@ -302,8 +302,7 @@ absolute_file_name(File0,File) :- !, F. '$cat_file_name'(File, S) --> - {string(File), string_to_codes(File, S) }, - !, + {string(File), string_codes(File, S) }, S. diff --git a/pl/consult.yap b/pl/consult.yap index 6cb1e38b9..9a7dcf8b5 100644 --- a/pl/consult.yap +++ b/pl/consult.yap @@ -221,7 +221,9 @@ SWI-compatible option where if _Autoload_ is `true` undefined % register(true, false) => implemented % load_files(Files,Opts) :- - '$load_files'(Files,Opts,load_files(Files,Opts)). + once( '$load_files'(Files,Opts,load_files(Files,Opts)) ), + fail. +load_files(_Files,_Opts). '$lf_option'(autoload, 1, false). '$lf_option'(derived_from, 2, false). @@ -272,13 +274,12 @@ load_files(Files,Opts) :- setarg( Id, TOpts, Val ). '$load_files'(Files, Opts, Call) :- - ( '__NB_getval__'('$lf_status', OldTOpts, fail), nonvar(OldTOpts) -> - '$lf_opt'(autoload, OldTOpts, OldAutoload) + ( '__NB_getval__'('$lf_status', OldTOpts, fail), nonvar(OldTOpts) - '$lf_opt'(autoload, OldTOpts, OldAutoload) ; '$lf_option'(last_opt, LastOpt), functor( OldTOpts, opt, LastOpt ), - '$lf_opt'('$context_module', OldTOpts, user) - ), + '$lf_opt'('$context_module', OldTOpts, user) + ), '$lf_option'(last_opt, LastOpt), functor( TOpts, opt, LastOpt ), ( source_location(ParentF, Line) -> true ; ParentF = user_input, Line = -1 ), @@ -544,10 +545,10 @@ When the files are not module files, ensure_loaded/1 loads them _F_ must be a list containing the names of the files to load. */ ensure_loaded(Fs) :- - '$load_files'(Fs, [if(not_loaded)],ensure_loaded(Fs)). + load_files(Fs, [if(not_loaded)]). compile(Fs) :- - '$load_files'(Fs, [], compile(Fs)). + load_files(Fs, []). /** @pred [ _F_ ] @@ -581,9 +582,9 @@ consult(Fs) :- '$consult'(Fs,Module) :- current_prolog_flag(language_mode, iso), % SICStus Prolog compatibility !, - '$load_files'(Module:Fs,[],consult(Fs)). + load_files(Module:Fs,[]). '$consult'(Fs, Module) :- - '$load_files'(Module:Fs,[consult(consult)],consult(Fs)). + load_files(Module:Fs,[consult(consult)]). /** @@ -616,7 +617,7 @@ Example: */ reconsult(Fs) :- - '$load_files'(Fs, [], reconsult(Fs)). + load_files(Fs, []). /* exo_files(+ _Files_) @@ -636,7 +637,7 @@ different forms of indexing, as shown in @cite x. */ exo_files(Fs) :- - '$load_files'(Fs, [consult(exo), if(not_loaded)], exo_files(Fs)). + load_files(Fs, [consult(exo), if(not_loaded)]). /** @@ -667,7 +668,7 @@ YAP implements load_db/1 as a two-step non-optimised process. First, db_files/1 itself is just a call to load_files/2. */ db_files(Fs) :- - '$load_files'(Fs, [consult(db), if(not_loaded)], exo_files(Fs)). + load_files(Fs, [consult(db), if(not_loaded)]). '$csult'(Fs, _M) :- @@ -677,9 +678,9 @@ db_files(Fs) :- !. '$csult'(Fs, M) :- '$extract_minus'(Fs, MFs), !, - '$load_files'(M:MFs,[],[M:Fs]). + load_files(M:MFs,[]). '$csult'(Fs, M) :- - '$load_files'(M:Fs,[consult(consult)],[M:Fs]). + load_files(M:Fs,[consult(consult)]). '$extract_minus'([], []). '$extract_minus'([-F|Fs], [F|MFs]) :- diff --git a/pl/directives.yap b/pl/directives.yap index 21d403bc1..877d3542f 100644 --- a/pl/directives.yap +++ b/pl/directives.yap @@ -176,23 +176,23 @@ considered. '$exec_directive'(set_prolog_flag(F,V), _, _, _, _) :- set_prolog_flag(F,V). '$exec_directive'(ensure_loaded(Fs), _, M, _, _) :- - '$load_files'(M:Fs, [if(changed)], ensure_loaded(Fs)). + load_files(M:Fs, [if(changed)]). '$exec_directive'(char_conversion(IN,OUT), _, _, _, _) :- char_conversion(IN,OUT). '$exec_directive'(public(P), _, M, _, _) :- '$public'(P, M). '$exec_directive'(compile(Fs), _, M, _, _) :- - '$load_files'(M:Fs, [], compile(Fs)). + load_files(M:Fs, []). '$exec_directive'(reconsult(Fs), _, M, _, _) :- - '$load_files'(M:Fs, [], reconsult(Fs)). + load_files(M:Fs, []). '$exec_directive'(consult(Fs), _, M, _, _) :- - '$load_files'(M:Fs, [consult(consult)], consult(Fs)). + load_files(M:Fs, [consult(consult)]). '$exec_directive'(use_module(F), _, M, _, _) :- use_module(M:F). '$exec_directive'(reexport(F), _, M, _, _) :- - '$load_files'(M:F, [if(not_loaded), silent(true), reexport(true),must_be_module(true)], reexport(F)). + load_files(M:F, [if(not_loaded), silent(true), reexport(true),must_be_module(true)]). '$exec_directive'(reexport(F,Spec), _, M, _, _) :- - '$load_files'(M:F, [if(changed), silent(true), imports(Spec), reexport(true),must_be_module(true)], reexport(F, Spec)). + load_files(M:F, [if(changed), silent(true), imports(Spec), reexport(true),must_be_module(true)]). '$exec_directive'(use_module(F, Is), _, M, _, _) :- use_module(M:F, Is). '$exec_directive'(use_module(Mod,F,Is), _, _, _, _) :- diff --git a/pl/errors.yap b/pl/errors.yap index 38190aa2b..27819fb48 100644 --- a/pl/errors.yap +++ b/pl/errors.yap @@ -57,7 +57,7 @@ Errors are terms of the form: * Generate a system error _Error_, informing the possible cause _Cause_. * */ -system_error(Type,Goal) :- +prolog:system_error(Type,Goal) :- '$do_error'(Type,Goal). diff --git a/pl/messages.yap b/pl/messages.yap index 6abc04b58..7e6115c98 100644 --- a/pl/messages.yap +++ b/pl/messages.yap @@ -259,11 +259,11 @@ location( error(_,Info), Level, LC ) --> { '$error_descriptor'(Info, Desc) }, { - '$query_exception'(prologPredFile, Desc, File), - '$query_exception'(prologPredLine, Desc, FilePos), - '$query_exception'(prologPredModule, Desc, M), - '$query_exception'(prologPredName, Desc, Na), - '$query_exception'(prologPredArity, Desc, Ar) + query_exception(prologPredFile, Desc, File), + query_exception(prologPredLine, Desc, FilePos), + query_exception(prologPredModule, Desc, M), + query_exception(prologPredName, Desc, Na), + query_exception(prologPredArity, Desc, Ar) }, !, display_consulting( File, Level, Info, LC ), @@ -271,9 +271,9 @@ location( error(_,Info), Level, LC ) --> location( error(_,Info), Level, LC ) --> { '$error_descriptor'(Info, Desc) }, { - '$query_exception'(errorFile, Desc, File), - '$query_exception'(errorLine, Desc, FilePos), - '$query_exception'(errorFunction, Desc, F) + query_exception(errorFile, Desc, File), + query_exception(errorLine, Desc, FilePos), + query_exception(errorFunction, Desc, F) }, !, display_consulting( File, Level, Info, LC ), @@ -295,6 +295,10 @@ main_message( error(syntax_error(Msg),info(between(L0,LM,LF),_Stream, _Pos, Term [' ~a: failed_processing syntax error term ~q' - [Level,Term]], [nl] ). +main_message( error(syntax_error(_Msg), Info), Level, LC ) --> + !, + [' ~a: syntax error ~s' - [Level,Msg]], + [nl]. main_message(style_check(singleton(SVs),_Pos,_File,P), _Level, _LC) --> !, % {writeln(ci)}, @@ -342,8 +346,8 @@ main_message(error(uninstantiation_error(T),_), Level, _LC) --> display_consulting( F, Level, Info, LC) --> { LC > 0, '$error_descriptor'(Info, Desc), - '$query_exception'(prologParserFile, Desc, F0), - '$query_exception'(prologarserLine, Desc, L), + query_exception(prologParserFile, Desc, F0), + query_exception(prologarserLine, Desc, L), F \= F0 }, !, [ '~a:~d:0: ~a raised at:'-[F0,L,Level], nl ]. @@ -358,7 +362,7 @@ display_consulting(_F, _, _, _LC) --> caller( Info, _) --> { '$error_descriptor'(Info, Desc) }, - ({ '$query_exception'(errorGoal, Desc, Call), + ({ query_exception(errorGoal, Desc, Call), Call = M:(H :- G) } -> @@ -372,12 +376,12 @@ caller( Info, _) --> ; [] ), - { '$query_exception'(prologPredFile, Desc, File), + { query_exception(prologPredFile, Desc, File), File \= [], - '$query_exception'(prologPredLine, Desc, FilePos), - '$query_exception'(prologPredModule, Desc, M), - '$query_exception'(prologPredName, Desc, Na), - '$query_exception'(prologPredArity, Desc, Ar) + query_exception(prologPredLine, Desc, FilePos), + query_exception(prologPredModule, Desc, M), + query_exception(prologPredName, Desc, Na), + query_exception(prologPredArity, Desc, Ar) }, !, [nl], @@ -388,10 +392,10 @@ caller( _, _) --> c_goal( Info, Level ) --> { '$error_descriptor'(Info, Desc) }, - { '$query_exception'(errorFile, Desc, File), + { query_exception(errorFile, Desc, File), Func \= [], - '$query_exception'(errorFunction, Desc, File), - '$query_exception'(errorLine, Desc, Line) + query_exception(errorFunction, Desc, File), + query_exception(errorLine, Desc, Line) }, !, ['~*|~a raised at C-function ~a() in ~a:~d:0: '-[10, Level, Func, File, Line]], @@ -620,7 +624,7 @@ domain_error(Domain, Opt) --> extra_info( error(_,Extra), _ ) --> { - '$query_exception'(prologPredFile, Extra, Msg), + query_exception(prologPredFile, Extra, Msg), Msg \= [] }, !, @@ -1048,6 +1052,12 @@ prolog:print_message(_Severity, _Term) :- '$error_descriptor'( exception(Info), Info ). +query_exception(K0,[H|L],V) :- + (atom(K0) -> atom_to_string(K0, K) ; K = K0), + !, + lists:member(K=V,[H|L]). +query_exception(K,V) :- + '$query_exception'(K,V). /** @}