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

jupyter

Browse Source
This commit is contained in:
Vitor Santos Costa 2018-07-21 01:56:48 +01:00
parent abc11dcfaa
commit 562e9e5af3
28 changed files with 1266 additions and 1567 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
C/adtdefs.c
View File

@ -251,9 +251,8 @@ Atom Yap_LookupAtomWithLength(const char *atom,
return NIL; return NIL;
memmove(ptr, atom, len0); memmove(ptr, atom, len0);
ptr[len0] = '\0'; ptr[len0] = '\0';
if (atom[0] '\0') {
at = LookupAtom(ptr); at = LookupAtom(ptr);
Yap_FreeCodeSpace(ptr); Yap_FreeCodeSpace(ptr);
return at; return at;
} }

67
C/flags.c
View File

@ -109,6 +109,9 @@ static Int set_prolog_flag(USES_REGS1);
#include "YapLFlagInfo.h" #include "YapLFlagInfo.h"
static Term indexer(Term inp) { static Term indexer(Term inp) {
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (inp == TermOff || inp == TermSingle || inp == TermCompact || if (inp == TermOff || inp == TermSingle || inp == TermCompact ||
inp == TermMulti || inp == TermOn || inp == TermMax) inp == TermMulti || inp == TermOn || inp == TermMax)
return inp; return inp;
@ -124,6 +127,9 @@ static Term indexer(Term inp) {
static bool dqf1(ModEntry *new, Term t2 USES_REGS) { static bool dqf1(ModEntry *new, Term t2 USES_REGS) {
new->flags &= ~(DBLQ_CHARS | DBLQ_CODES | DBLQ_ATOM | DBLQ_STRING); new->flags &= ~(DBLQ_CHARS | DBLQ_CODES | DBLQ_ATOM | DBLQ_STRING);
if (IsStringTerm(t2)) {
t2 = MkStringTerm(RepAtom(AtomOfTerm(t2))->StrOfAE);
}
if (IsAtomTerm(t2)) { if (IsAtomTerm(t2)) {
if (t2 == TermString) { if (t2 == TermString) {
new->flags |= DBLQ_STRING; new->flags |= DBLQ_STRING;
@ -162,6 +168,9 @@ static bool dqs(Term t2) {
static bool bqf1(ModEntry *new, Term t2 USES_REGS) { static bool bqf1(ModEntry *new, Term t2 USES_REGS) {
new->flags &= ~(BCKQ_CHARS | BCKQ_CODES | BCKQ_ATOM | BCKQ_STRING); new->flags &= ~(BCKQ_CHARS | BCKQ_CODES | BCKQ_ATOM | BCKQ_STRING);
if (IsStringTerm(t2)) {
t2 = MkStringTerm(RepAtom(AtomOfTerm(t2))->StrOfAE);
}
if (IsAtomTerm(t2)) { if (IsAtomTerm(t2)) {
if (t2 == TermString) { if (t2 == TermString) {
new->flags |= BCKQ_STRING; new->flags |= BCKQ_STRING;
@ -197,6 +206,9 @@ static bool bqs(Term t2) {
static bool sqf1(ModEntry *new, Term t2 USES_REGS) { static bool sqf1(ModEntry *new, Term t2 USES_REGS) {
new->flags &= ~(SNGQ_CHARS | SNGQ_CODES | SNGQ_ATOM | SNGQ_STRING); new->flags &= ~(SNGQ_CHARS | SNGQ_CODES | SNGQ_ATOM | SNGQ_STRING);
if (IsStringTerm(t2)) {
t2 = MkStringTerm(RepAtom(AtomOfTerm(t2))->StrOfAE);
}
if (IsAtomTerm(t2)) { if (IsAtomTerm(t2)) {
if (t2 == TermString) { if (t2 == TermString) {
new->flags |= SNGQ_STRING; new->flags |= SNGQ_STRING;
@ -234,6 +246,9 @@ static Term isaccess(Term inp) {
if (inp == TermReadWrite || inp == TermReadOnly) if (inp == TermReadWrite || inp == TermReadOnly)
return inp; return inp;
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (IsAtomTerm(inp)) { if (IsAtomTerm(inp)) {
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, inp, Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, inp,
"set_prolog_flag access in {read_write,read_only}"); "set_prolog_flag access in {read_write,read_only}");
@ -281,6 +296,9 @@ static Term flagscope(Term inp) {
if (inp == TermGlobal || inp == TermThread || inp == TermModule) if (inp == TermGlobal || inp == TermThread || inp == TermModule)
return inp; return inp;
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (IsAtomTerm(inp)) { if (IsAtomTerm(inp)) {
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, inp, Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, inp,
"set_prolog_flag access in {global,module,thread}"); "set_prolog_flag access in {global,module,thread}");
@ -295,8 +313,11 @@ static bool mkprompt(Term inp) {
CACHE_REGS CACHE_REGS
if (IsVarTerm(inp)) { if (IsVarTerm(inp)) {
return Yap_unify(inp, MkAtomTerm(Yap_LookupAtom(LOCAL_Prompt))); return Yap_unify(inp, MkAtomTerm(Yap_LookupAtom(LOCAL_Prompt)));
}
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
} }
if (!IsAtomTerm(inp)) { if (!IsAtomTerm(inp)) {
Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag"); Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag");
return false; return false;
} }
@ -307,6 +328,9 @@ static bool mkprompt(Term inp) {
static bool getenc(Term inp) { static bool getenc(Term inp) {
CACHE_REGS CACHE_REGS
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (!IsVarTerm(inp) && !IsAtomTerm(inp)) { if (!IsVarTerm(inp) && !IsAtomTerm(inp)) {
Yap_Error(TYPE_ERROR_ATOM, inp, "get_encoding"); Yap_Error(TYPE_ERROR_ATOM, inp, "get_encoding");
return false; return false;
@ -338,6 +362,9 @@ static bool typein(Term inp) {
tin = TermProlog; tin = TermProlog;
return Yap_unify(inp, tin); return Yap_unify(inp, tin);
} }
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (!IsAtomTerm(inp)) { if (!IsAtomTerm(inp)) {
Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag"); Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag");
return false; return false;
@ -448,6 +475,9 @@ static bool typein(Term inp) {
if (IsAtomTerm(hd)) { if (IsAtomTerm(hd)) {
do { do {
Term hd = HeadOfTerm(inp); Term hd = HeadOfTerm(inp);
if (IsStringTerm(hd)) {
hd = MkStringTerm(RepAtom(AtomOfTerm(hd))->StrOfAE);
}
if (!IsAtomTerm(hd)) { if (!IsAtomTerm(hd)) {
Yap_Error(TYPE_ERROR_TEXT, inp0, "set_prolog_flag in \"...\""); Yap_Error(TYPE_ERROR_TEXT, inp0, "set_prolog_flag in \"...\"");
return false; return false;
@ -486,6 +516,10 @@ x static bool list_atom( Term inp ) {
if (IsPairTerm(inp)) { if (IsPairTerm(inp)) {
Term hd = HeadOfTerm(inp); Term hd = HeadOfTerm(inp);
do { do {
if (IsStringTerm(hd)) {
hd = MkStringTerm(RepAtom(AtomOfTerm(hd))->StrOfAE);
}
if (!IsAtomTerm(hd)) { if (!IsAtomTerm(hd)) {
Yap_Error(TYPE_ERROR_ATOM, inp0, "set_prolog_flag in \"...\""); Yap_Error(TYPE_ERROR_ATOM, inp0, "set_prolog_flag in \"...\"");
return false; return false;
@ -510,6 +544,9 @@ static Term list_option(Term inp) {
do { do {
Term hd = HeadOfTerm(inp); Term hd = HeadOfTerm(inp);
inp = TailOfTerm(inp); inp = TailOfTerm(inp);
if (IsStringTerm(hd)) {
hd = MkStringTerm(RepAtom(AtomOfTerm(hd))->StrOfAE);
}
if (IsAtomTerm(hd)) { if (IsAtomTerm(hd)) {
continue; continue;
} }
@ -530,6 +567,9 @@ static Term list_option(Term inp) {
Yap_Error(TYPE_ERROR_LIST, inp0, "set_prolog_flag in [...]"); Yap_Error(TYPE_ERROR_LIST, inp0, "set_prolog_flag in [...]");
return TermZERO; return TermZERO;
} else /* lone option */ { } else /* lone option */ {
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (IsAtomTerm(inp)) { if (IsAtomTerm(inp)) {
return inp; return inp;
} else if (IsApplTerm(inp)) { } else if (IsApplTerm(inp)) {
@ -1035,6 +1075,9 @@ static Int current_prolog_flag2(USES_REGS1) {
return cont_yap_flag(PASS_REGS1); return cont_yap_flag(PASS_REGS1);
} }
do_cut(0); do_cut(0);
if (IsStringTerm(tflag)) {
tflag = MkStringTerm(RepAtom(AtomOfTerm(tflag))->StrOfAE);
}
if (!IsAtomTerm(tflag)) { if (!IsAtomTerm(tflag)) {
Yap_Error(TYPE_ERROR_ATOM, tflag, "current_prolog_flag/3"); Yap_Error(TYPE_ERROR_ATOM, tflag, "current_prolog_flag/3");
return (FALSE); return (FALSE);
@ -1084,6 +1127,10 @@ bool setYapFlag(Term tflag, Term t2) {
Yap_Error(INSTANTIATION_ERROR, tflag, "yap_flag/2"); Yap_Error(INSTANTIATION_ERROR, tflag, "yap_flag/2");
return (FALSE); return (FALSE);
} }
if (IsStringTerm(tflag)) {
tflag = MkStringTerm(RepAtom(AtomOfTerm(tflag))->StrOfAE);
}
if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) { if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) {
Term modt; Term modt;
tflag = Yap_StripModule(tflag, &modt); tflag = Yap_StripModule(tflag, &modt);
@ -1165,11 +1212,20 @@ Term getYapFlag(Term tflag) {
Yap_Error(INSTANTIATION_ERROR, tflag, "yap_flag/2"); Yap_Error(INSTANTIATION_ERROR, tflag, "yap_flag/2");
return (FALSE); return (FALSE);
} }
if (IsStringTerm(tflag)) {
tflag = MkStringTerm(RepAtom(AtomOfTerm(tflag))->StrOfAE);
}
if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) { if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) {
Term modt; Term modt;
tflag = Yap_StripModule(tflag, &modt); tflag = Yap_StripModule(tflag, &modt);
if (IsStringTerm(tflag)) {
tflag = MkStringTerm(RepAtom(AtomOfTerm(tflag))->StrOfAE);
}
if (!isatom(tflag)) if (!isatom(tflag))
return false; return false;
if (IsStringTerm(modt)) {
modt = MkStringTerm(RepAtom(AtomOfTerm(modt))->StrOfAE);
}
if (!isatom(modt)) if (!isatom(modt))
return false; return false;
return getYapFlagInModule(tflag, modt); return getYapFlagInModule(tflag, modt);
@ -1405,6 +1461,9 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
GLOBAL_MaxPriority); GLOBAL_MaxPriority);
if (!t0) if (!t0)
return false; return false;
if (IsStringTerm(t0)) {
t0 = MkStringTerm(RepAtom(AtomOfTerm(t0))->StrOfAE);
}
if (IsAtomTerm(t0) || IsIntTerm(t0)) { if (IsAtomTerm(t0) || IsIntTerm(t0)) {
// do yourself flags // do yourself flags
if (t0 == MkAtomTerm(AtomQuery)) { if (t0 == MkAtomTerm(AtomQuery)) {
@ -1456,6 +1515,9 @@ do_prolog_flag_property(Term tflag,
Yap_Error(LOCAL_Error_TYPE, opts, NULL); Yap_Error(LOCAL_Error_TYPE, opts, NULL);
return false; return false;
} }
if (IsStringTerm(tflag)) {
tflag = MkStringTerm(RepAtom(AtomOfTerm(tflag))->StrOfAE);
}
if (!IsAtomTerm(tflag)) { if (!IsAtomTerm(tflag)) {
if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) { if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) {
Term modt = CurrentModule; Term modt = CurrentModule;
@ -1572,6 +1634,9 @@ static Int prolog_flag_property(USES_REGS1) { /* Init current_prolog_flag */
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
/* make valgrind happy by always filling in memory */ /* make valgrind happy by always filling in memory */
EXTRA_CBACK_ARG(2, 1) = MkIntTerm(0); EXTRA_CBACK_ARG(2, 1) = MkIntTerm(0);
if (IsStringTerm(t1)) {
t1 = MkStringTerm(RepAtom(AtomOfTerm(t1))->StrOfAE);
}
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
return (cont_prolog_flag_property(PASS_REGS1)); return (cont_prolog_flag_property(PASS_REGS1));
} else { } else {

1
C/load_foreign.c
View File

@ -286,4 +286,5 @@ void Yap_ReOpenLoadForeign(void) {
X_API bool load_none(void) X_API bool load_none(void)
{ {
return true;
} }

512
C/text.c
View File

@ -91,11 +91,11 @@ void *pop_output_text_stack__(int i, const void *export) {
while (p) { while (p) {
struct mblock *np = p->next; struct mblock *np = p->next;
if (p + 1 == export) { if (p + 1 == export) {
size_t sz = p->sz - sizeof(struct mblock); size_t sz = p->sz - sizeof(struct mblock);
memmove(p, p + 1, sz); memmove(p, p + 1, sz);
export = p; export = p;
} else { } else {
free(p); free(p);
} }
p = np; p = np;
} }
@ -229,9 +229,9 @@ static Term Globalize(Term v USES_REGS) {
} }
static void *codes2buf(Term t0, void *b0, bool get_codes, static void *codes2buf(Term t0, void *b0, bool get_codes,
bool fixed USES_REGS) { bool fixed USES_REGS) {
unsigned char *st0, *st, ar[16]; unsigned char *st0, *st, ar[16];
Term t = Deref(t0); Term t = t0;
size_t length = 0; size_t length = 0;
if (t == TermNil) { if (t == TermNil) {
@ -247,7 +247,7 @@ static void *codes2buf(Term t0, void *b0, bool get_codes,
if (get_codes != codes && fixed) { if (get_codes != codes && fixed) {
if (codes) { if (codes) {
Yap_ThrowError(TYPE_ERROR_INTEGER, HeadOfTerm(t), Yap_ThrowError(TYPE_ERROR_INTEGER, HeadOfTerm(t),
"scanning list of codes"); "scanning list of codes");
} else { } else {
Yap_ThrowError(TYPE_ERROR_ATOM, HeadOfTerm(t), "scanning list of atoms"); Yap_ThrowError(TYPE_ERROR_ATOM, HeadOfTerm(t), "scanning list of atoms");
} }
@ -256,55 +256,55 @@ static void *codes2buf(Term t0, void *b0, bool get_codes,
while (IsPairTerm(t)) { while (IsPairTerm(t)) {
Term hd = HeadOfTerm(t); Term hd = HeadOfTerm(t);
if (IsVarTerm(hd)) { if (IsVarTerm(hd)) {
Yap_ThrowError(INSTANTIATION_ERROR, hd, "scanning list of codes"); Yap_ThrowError(INSTANTIATION_ERROR, hd, "scanning list of codes");
return NULL; return NULL;
} }
if (!IsIntegerTerm(hd)) { if (!IsIntegerTerm(hd)) {
Yap_ThrowError(TYPE_ERROR_CHARACTER_CODE, hd, "scanning list of codes"); Yap_ThrowError(TYPE_ERROR_CHARACTER_CODE, hd, "scanning list of codes");
return NULL; return NULL;
} }
Int code = IntegerOfTerm(hd); Int code = IntegerOfTerm(hd);
if (code < 0) { if (code < 0) {
Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER_CODE, hd, Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER_CODE, hd,
"scanning list of character codes, found %d", code); "scanning list of character codes, found %d", code);
return NULL; return NULL;
} }
length += put_utf8(ar, code); length += put_utf8(ar, code);
t = TailOfTerm(t); t = TailOfTerm(t);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_ThrowError(INSTANTIATION_ERROR, t, "scanning list of codes"); Yap_ThrowError(INSTANTIATION_ERROR, t, "scanning list of codes");
return NULL; return NULL;
} }
if (!IsPairTerm(t) && t != TermNil) { if (!IsPairTerm(t) && t != TermNil) {
Yap_ThrowError(TYPE_ERROR_LIST, t, "scanning list of codes"); Yap_ThrowError(TYPE_ERROR_LIST, t, "scanning list of codes");
return NULL; return NULL;
} }
} }
} else { } else {
while (IsPairTerm(t)) { while (IsPairTerm(t)) {
Term hd = HeadOfTerm(t); Term hd = HeadOfTerm(t);
if (IsVarTerm(hd)) { if (IsVarTerm(hd)) {
Yap_ThrowError(INSTANTIATION_ERROR, hd, "scanning list of codes"); Yap_ThrowError(INSTANTIATION_ERROR, hd, "scanning list of codes");
return NULL; return NULL;
} }
if (!IsAtomTerm(hd)) { if (!IsAtomTerm(hd)) {
Yap_ThrowError(TYPE_ERROR_CHARACTER, hd, "scanning list of texts"); Yap_ThrowError(TYPE_ERROR_CHARACTER, hd, "scanning list of texts");
return NULL; return NULL;
} }
const char *code = RepAtom(AtomOfTerm(hd))->StrOfAE; const char *code = RepAtom(AtomOfTerm(hd))->StrOfAE;
if (code < 0) { if (code < 0) {
Yap_ThrowError(TYPE_ERROR_CHARACTER, hd, "scanning list of atoms"); Yap_ThrowError(TYPE_ERROR_CHARACTER, hd, "scanning list of atoms");
return NULL; return NULL;
} }
length += strlen(code); length += strlen(code);
t = TailOfTerm(t); t = TailOfTerm(t);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_ThrowError(INSTANTIATION_ERROR, t, "scanning list of codes"); Yap_ThrowError(INSTANTIATION_ERROR, t, "scanning list of codes");
return NULL; return NULL;
} }
if (!IsPairTerm(t) && t != TermNil) { if (!IsPairTerm(t) && t != TermNil) {
Yap_ThrowError(TYPE_ERROR_LIST, t, "scanning list of codes"); Yap_ThrowError(TYPE_ERROR_LIST, t, "scanning list of codes");
return NULL; return NULL;
} }
} }
} }
@ -374,33 +374,33 @@ static unsigned char *wchar2utf8(seq_tv_t *inp) {
static void *slice(size_t min, size_t max, const unsigned char *buf USES_REGS); static void *slice(size_t min, size_t max, const unsigned char *buf USES_REGS);
static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t, static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp USES_REGS) { seq_tv_t *inp USES_REGS) {
bool codes = true, fixed = true; bool codes = true, fixed = true;
unsigned char *nbuf = codes2buf(t, buf, codes, fixed PASS_REGS); unsigned char *nbuf = codes2buf(t, buf, codes, fixed PASS_REGS);
return nbuf; return nbuf;
} }
static unsigned char *Yap_ListOfAtomsToBuffer(unsigned char *buf, Term t, static unsigned char *Yap_ListOfAtomsToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp USES_REGS) { seq_tv_t *inp USES_REGS) {
bool codes = false; bool codes = false;
unsigned char *nbuf = codes2buf(t, buf, codes, true PASS_REGS); unsigned char *nbuf = codes2buf(t, buf, codes, true PASS_REGS);
return nbuf; return nbuf;
} }
static unsigned char *Yap_ListToBuffer(unsigned char *buf, Term t, static unsigned char *Yap_ListToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp USES_REGS) { seq_tv_t *inp USES_REGS) {
return codes2buf(t, buf, NULL, false PASS_REGS); return codes2buf(t, buf, NULL, false PASS_REGS);
} }
#if USE_GEN_TYPE_ERROR #if USE_GEN_TYPE_ERROR
static yap_error_number gen_type_error(int flags) { static yap_error_number gen_type_error(int flags) {
if ((flags & (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | if ((flags & (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
YAP_STRING_FLOAT | YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) == YAP_STRING_FLOAT | YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) ==
(YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) YAP_STRING_ATOMS_CODES | YAP_STRING_BIG))
return TYPE_ERROR_TEXT; return TYPE_ERROR_TEXT;
if ((flags & (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | if ((flags & (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
YAP_STRING_FLOAT | YAP_STRING_BIG)) == YAP_STRING_FLOAT | YAP_STRING_BIG)) ==
(YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
YAP_STRING_BIG)) YAP_STRING_BIG))
return TYPE_ERROR_ATOMIC; return TYPE_ERROR_ATOMIC;
@ -417,183 +417,149 @@ static yap_error_number gen_type_error(int flags) {
} }
#endif #endif
static yap_error_number type_error(seq_tv_t *inp) { // static int cnt;
if ((inp->type & YAP_STRING_ATOMS_CODES) == YAP_STRING_ATOMS_CODES)
{
return TYPE_ERROR_IN_CHARACTER;
}
if ((inp->type & YAP_STRING_ATOMS) == YAP_STRING_ATOMS) {
return TYPE_ERROR_CHARACTER;
}
if ((inp->type & YAP_STRING_CODES) == YAP_STRING_CODES) {
return TYPE_ERROR_CHARACTER_CODE;
}
if ((inp->type & YAP_STRING_STRING) == YAP_STRING_STRING) {
return TYPE_ERROR_IN_CHARACTER;
}
if ((inp->type & YAP_STRING_CODES) == YAP_STRING_CODES) {
return TYPE_ERROR_IN_CHARACTER;
}
if ((inp->type & (YAP_STRING_ATOM|YAP_STRING_STRING)) == (YAP_STRING_ATOM|YAP_STRING_STRING)) {
return TYPE_ERROR_ATOMIC;
}
if ((inp->type & YAP_STRING_ATOM) == YAP_STRING_ATOM) {
return TYPE_ERROR_IN_CHARACTER;
}
return SYSTEM_ERROR_INTERNAL;
}
/// @brief translate anything to bufffer UTF-8
///
/// @arg input descriptor
unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) { unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) {
#define POPRET(x) return pop_output_text_stack(lvl, x) #define POPRET(x) return pop_output_text_stack(lvl, x)
int lvl = push_text_stack(); int lvl = push_text_stack();
char *out = NULL; char *out = NULL;
yap_error_number err0 = LOCAL_Error_TYPE;
/* we know what the term is */ /* we know what the term is */
if ((inp->type & (YAP_STRING_CHARS | YAP_STRING_WCHARS))) { if (!(inp->type & (YAP_STRING_CHARS | YAP_STRING_WCHARS))) {
//> buffer processing if (!(inp->type & YAP_STRING_TERM)) {
//> must convert: if (IsVarTerm(inp->val.t)) {
if (inp->type & YAP_STRING_CHARS) { LOCAL_Error_TYPE = INSTANTIATION_ERROR;
//> - ASCII to UTF-8 } else if (!IsAtomTerm(inp->val.t) && inp->type == YAP_STRING_ATOM) {
if (inp->enc == ENC_ISO_ASCII) { LOCAL_Error_TYPE = TYPE_ERROR_ATOM;
pop_text_stack(lvl); } else if (!IsStringTerm(inp->val.t) && inp->type == YAP_STRING_STRING) {
return inp->val.uc; LOCAL_Error_TYPE = TYPE_ERROR_STRING;
} } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
//> - ISO-LATIN-1 to UTF-8 inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) {
if (inp->enc == ENC_ISO_LATIN1) { LOCAL_ActiveError->errorRawTerm = inp->val.t;
POPRET( (char*)latin2utf8(inp)); } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
} !IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) {
LOCAL_Error_TYPE = TYPE_ERROR_TEXT;
//> - assume UTF-8
if (inp->enc == ENC_ISO_UTF8) {
pop_text_stack(lvl);
return inp->val.uc;
} }
} }
if (inp->type & YAP_STRING_WCHARS) { if (err0 != LOCAL_Error_TYPE) {
// printf("%S\n",inp->val.w); Yap_ThrowError(LOCAL_Error_TYPE, inp->val.t, "while reading text in");
//> wide includes everything else
POPRET( (char *)wchar2utf8(inp) );
} }
} else { }
if (inp->type & YAP_STRING_TERM) { if (IsAtomTerm(inp->val.t) && inp->type & YAP_STRING_ATOM) {
//> term: anything goes // this is a term, extract to a buffer, and representation is wide
pop_text_stack(lvl); // Yap_DebugPlWriteln(inp->val.t);
return (unsigned char *)Yap_TermToBuffer(inp->val.t, 0); Atom at = AtomOfTerm(inp->val.t);
} if (RepAtom(at)->UStrOfAE[0] == 0) {
if (IsVarTerm(inp->val.t)) { out = Malloc(4);
Yap_ThrowError(INSTANTIATION_ERROR, inp->val.t, NULL); memset(out, 0, 4);
}
if (IsPairOrNilTerm(inp->val.t)) {
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS))) {
// Yap_DebugPlWriteln(inp->val.t);
out = (char *)Yap_ListToBuffer(NULL, inp->val.t, inp PASS_REGS);
POPRET( out );
// this is a term, extract to a sfer, and representation is wide
}
if (inp->type & YAP_STRING_CODES) {
// Yap_DebugPlWriteln(inp->val.t);
out = (char *)Yap_ListOfCodesToBuffer(NULL, inp->val.t, inp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide
POPRET( out );
}
if (inp->type & YAP_STRING_ATOMS) {
// Yap_DebugPlWriteln(inp->val.t);
out = (char *)Yap_ListOfAtomsToBuffer(NULL, inp->val.t, inp PASS_REGS);
// this is a term, extract to a buffer, and representation is wide
POPRET( out );
}
}
if (IsStringTerm(inp->val.t)) {
if(!(inp->type & (YAP_STRING_STRING))) {
Yap_ThrowError(type_error(inp), inp->val.t, NULL);
}
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
const char *s = StringOfTerm(inp->val.t);
if (s[0] == 0) {
out = Malloc(4);
memset(out, 0, 4);
POPRET( out );
}
if (inp->type & YAP_STRING_WITH_BUFFER) {
pop_text_stack(lvl);
return (unsigned char *)UStringOfTerm(inp->val.t);
}
{
inp->type |= YAP_STRING_IN_TMP;
size_t sz = strlen(s);
out = Malloc(sz + 1);
strcpy(out, s);
POPRET( out );
}
}
if (IsAtomTerm(inp->val.t)) {
if(!(inp->type & (YAP_STRING_ATOM))) {
Yap_ThrowError(type_error(inp), inp->val.t, NULL);
}
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
Atom at = AtomOfTerm(inp->val.t);
if (RepAtom(at)->UStrOfAE[0] == '\0') {
out = Malloc(4);
memset(out, 0, 4);
POPRET( out );
}
if (inp->type & YAP_STRING_WITH_BUFFER) {
pop_text_stack(lvl);
return at->UStrOfAE;
} else
{
size_t sz = strlen(at->StrOfAE);
out = Malloc(sz + 1);
strcpy(out, at->StrOfAE);
POPRET( out );
}
}
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
if(!(inp->type & (YAP_STRING_INT))) {
Yap_ThrowError(type_error(inp), inp->val.t, NULL);
} // ASCII, so both LATIN1 and UTF-8
// Yap_DebugPlWriteln(inp->val.t);
out = Malloc(2 * MaxTmp(PASS_REGS1));
if (snprintf(out, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
IntegerOfTerm(inp->val.t)) < 0) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), out, char);
}
POPRET( out ); POPRET( out );
} }
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) { if (inp->type & YAP_STRING_WITH_BUFFER) {
if(!(inp->type & (YAP_STRING_FLOAT))) { pop_text_stack(lvl);
Yap_ThrowError(type_error(inp), inp->val.t, NULL); return at->UStrOfAE;
} // ASCII, so both LATIN1 and UTF-8
out = Malloc(2 * MaxTmp(PASS_REGS1));
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &out, 1024)) {
pop_text_stack(lvl);
return NULL;
}
POPRET(out);
} }
#if USE_GMP {
if ( IsBigIntTerm(inp->val.t)) { size_t sz = strlen(at->StrOfAE);
if(!(inp->type & (YAP_STRING_BIG))) { out = Malloc(sz + 1);
Yap_ThrowError(type_error(inp), inp->val.t, NULL); strcpy(out, at->StrOfAE);
} // ASCII, so both LATIN1 and UTF-8 POPRET( out );
}
}
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
const char *s = StringOfTerm(inp->val.t);
if (s[0] == 0) {
out = Malloc(4);
memset(out, 0, 4);
POPRET( out );
}
if (inp->type & YAP_STRING_WITH_BUFFER) {
pop_text_stack(lvl);
return (unsigned char *)UStringOfTerm(inp->val.t);
}
{
inp->type |= YAP_STRING_IN_TMP;
size_t sz = strlen(s);
out = Malloc(sz + 1);
strcpy(out, s);
POPRET( out );
}
} else if (IsPairOrNilTerm(inp->val.t)) {
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS))) {
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
out = Malloc(MaxTmp()); out = (char *)Yap_ListToBuffer(NULL, inp->val.t, inp PASS_REGS);
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), out, MaxTmp() - 1, POPRET( out );
10)) { // this is a term, extract to a sfer, and representation is wide
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), out, char);
}
POPRET(out);
} }
if (inp->type & YAP_STRING_CODES) {
// Yap_DebugPlWriteln(inp->val.t);
out = (char *)Yap_ListOfCodesToBuffer(NULL, inp->val.t, inp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide
POPRET( out );
}
if (inp->type & YAP_STRING_ATOMS) {
// Yap_DebugPlWriteln(inp->val.t);
out = (char *)Yap_ListOfAtomsToBuffer(NULL, inp->val.t, inp PASS_REGS);
// this is a term, extract to a buffer, and representation is wide
POPRET( out );
}
}
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
// ASCII, so both LATIN1 and UTF-8
// Yap_DebugPlWriteln(inp->val.t);
out = Malloc(2 * MaxTmp(PASS_REGS1));
if (snprintf(out, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
IntegerOfTerm(inp->val.t)) < 0) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), out, char);
}
POPRET( out );
}
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
out = Malloc(2 * MaxTmp(PASS_REGS1));
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &out, 1024)) {
pop_text_stack(lvl);
return NULL;
}
POPRET(out);
}
#if USE_GMP
if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
out = Malloc(MaxTmp());
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), out, MaxTmp() - 1,
10)) {
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), out, char);
}
POPRET(out);
}
#endif #endif
if (inp->type & YAP_STRING_TERM) {
pop_text_stack(lvl);
return Yap_TermToBuffer(inp->val.t, 0);
}
if (inp->type & YAP_STRING_CHARS) {
if (inp->enc == ENC_ISO_ASCII) {
pop_text_stack(lvl);
return inp->val.uc;
}
if (inp->enc == ENC_ISO_LATIN1) {
POPRET( (char*)latin2utf8(inp));
}
if (inp->enc == ENC_ISO_UTF8) {
pop_text_stack(lvl);
return inp->val.c;
}
}
if (inp->type & YAP_STRING_WCHARS) {
// printf("%S\n",inp->val.w);
POPRET( (char *)wchar2utf8(inp) );
} }
pop_text_stack(lvl); pop_text_stack(lvl);
Yap_ThrowError(type_error(inp), inp->val.t, NULL);
return NULL; return NULL;
} }
@ -761,11 +727,11 @@ void *write_buffer(unsigned char *s0, seq_tv_t *out USES_REGS) {
utf8proc_int32_t chr; utf8proc_int32_t chr;
int off = get_utf8(cp, -1, &chr); int off = get_utf8(cp, -1, &chr);
if (off <= 0 || chr > 255) { if (off <= 0 || chr > 255) {
pop_text_stack(l); pop_text_stack(l);
return NULL; return NULL;
} }
if (off == max) if (off == max)
break; break;
cp += off; cp += off;
*buf++ = chr; *buf++ = chr;
} }
@ -773,10 +739,10 @@ void *write_buffer(unsigned char *s0, seq_tv_t *out USES_REGS) {
*buf++ = '\0'; *buf++ = '\0';
else else
while (max < min) { while (max < min) {
utf8proc_int32_t chr; utf8proc_int32_t chr;
max++; max++;
cp += get_utf8(cp, -1, &chr); cp += get_utf8(cp, -1, &chr);
*buf++ = chr; *buf++ = chr;
} }
} else if (out->enc == ENC_WCHAR) { } else if (out->enc == ENC_WCHAR) {
unsigned char *s = s0, *lim = s + (max = strnlen((char *)s0, max)); unsigned char *s = s0, *lim = s + (max = strnlen((char *)s0, max));
@ -797,10 +763,10 @@ void *write_buffer(unsigned char *s0, seq_tv_t *out USES_REGS) {
*buf++ = '\0'; *buf++ = '\0';
else else
while (max < min) { while (max < min) {
utf8proc_int32_t chr; utf8proc_int32_t chr;
max++; max++;
cp += get_utf8(cp, -1, &chr); cp += get_utf8(cp, -1, &chr);
*buf++ = chr; *buf++ = chr;
} }
*buf = '\0'; *buf = '\0';
} else { } else {
@ -817,7 +783,7 @@ static size_t write_length(const unsigned char *s0, seq_tv_t *out USES_REGS) {
} }
static Term write_number(unsigned char *s, seq_tv_t *out, static Term write_number(unsigned char *s, seq_tv_t *out,
bool error_on USES_REGS) { bool error_on USES_REGS) {
Term t; Term t;
LOCAL_delay = !error_on; LOCAL_delay = !error_on;
t = Yap_StringToNumberTerm((char *)s, &out->enc, error_on); t = Yap_StringToNumberTerm((char *)s, &out->enc, error_on);
@ -846,7 +812,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS) {
if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) { if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) {
if ((out->val.t = write_number( if ((out->val.t = write_number(
inp, out, !(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) { inp, out, !(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) {
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return true; return true;
@ -859,7 +825,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS) {
if ((out->val.a = write_atom(inp, out PASS_REGS)) != NIL) { if ((out->val.a = write_atom(inp, out PASS_REGS)) != NIL) {
Atom at = out->val.a; Atom at = out->val.a;
if (at && (out->type & YAP_STRING_OUTPUT_TERM)) if (at && (out->type & YAP_STRING_OUTPUT_TERM))
out->val.t = MkAtomTerm(at); out->val.t = MkAtomTerm(at);
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return at != NIL; return at != NIL;
} }
@ -959,12 +925,12 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
size_t leng = strlen_utf8(buf); size_t leng = strlen_utf8(buf);
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
if (out->max < leng) { if (out->max < leng) {
const unsigned char *ptr = skip_utf8(buf, out->max); const unsigned char *ptr = skip_utf8(buf, out->max);
size_t diff = (ptr - buf); size_t diff = (ptr - buf);
char *nbuf = Malloc(diff + 1); char *nbuf = Malloc(diff + 1);
memmove(nbuf, buf, diff); memmove(nbuf, buf, diff);
nbuf[diff] = '\0'; nbuf[diff] = '\0';
leng = diff; leng = diff;
} }
// else if (out->type & YAP_STRING_NCHARS && // else if (out->type & YAP_STRING_NCHARS &&
// const unsigned char *ptr = skip_utf8(buf) // const unsigned char *ptr = skip_utf8(buf)
@ -972,32 +938,32 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
if (out->type & (YAP_STRING_UPCASE | YAP_STRING_DOWNCASE)) { if (out->type & (YAP_STRING_UPCASE | YAP_STRING_DOWNCASE)) {
if (out->type & YAP_STRING_UPCASE) { if (out->type & YAP_STRING_UPCASE) {
if (!upcase(buf, out)) { if (!upcase(buf, out)) {
pop_text_stack(l); pop_text_stack(l);
return false; return false;
} }
} }
if (out->type & YAP_STRING_DOWNCASE) { if (out->type & YAP_STRING_DOWNCASE) {
if (!downcase(buf, out)) { if (!downcase(buf, out)) {
pop_text_stack(l); pop_text_stack(l);
return false; return false;
} }
} }
} }
} }
rc = write_Text(buf, out PASS_REGS); rc = write_Text(buf, out PASS_REGS);
/* fprintf(stderr, " -> "); /* fprintf(stderr, " -> ");
if (!rc) fprintf(stderr, "NULL"); if (!rc) fprintf(stderr, "NULL");
else if (out->type & else if (out->type &
(YAP_STRING_TERM|YAP_STRING_ATOMS_CODES (YAP_STRING_TERM|YAP_STRING_ATOMS_CODES
|YAP_STRING_STRING)) //Yap_DebugPlWrite(out->val.t); |YAP_STRING_STRING)) //Yap_DebugPlWrite(out->val.t);
else if (out->type & else if (out->type &
YAP_STRING_ATOM) //Yap_DebugPlWriteln(MkAtomTerm(out->val.a)); YAP_STRING_ATOM) //Yap_DebugPlWriteln(MkAtomTerm(out->val.a));
else if (out->type & YAP_STRING_WCHARS) fprintf(stderr, "%S", else if (out->type & YAP_STRING_WCHARS) fprintf(stderr, "%S",
out->val.w); out->val.w);
else else
fprintf(stderr, "%s", out->val.c); fprintf(stderr, "%s", out->val.c);
fprintf(stderr, "\n]\n"); */ fprintf(stderr, "\n]\n"); */
pop_text_stack(l); pop_text_stack(l);
return rc; return rc;
} }
@ -1083,7 +1049,7 @@ bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
// //
bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
seq_tv_t outv[] USES_REGS) { seq_tv_t outv[] USES_REGS) {
int lvl = push_text_stack(); int lvl = push_text_stack();
const unsigned char *buf; const unsigned char *buf;
size_t b_l, u_l; size_t b_l, u_l;
@ -1106,46 +1072,46 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
unsigned char *buf0, *buf1; unsigned char *buf0, *buf1;
if (outv[0].val.t) { if (outv[0].val.t) {
buf0 = Yap_readText(outv PASS_REGS); buf0 = Yap_readText(outv PASS_REGS);
if (!buf0) { if (!buf0) {
return false; return false;
} }
b_l0 = strlen((const char *)buf0); b_l0 = strlen((const char *)buf0);
if (memcmp(buf, buf0, b_l0) != 0) { if (memcmp(buf, buf0, b_l0) != 0) {
pop_text_stack(lvl); pop_text_stack(lvl);
return false; return false;
} }
u_l0 = strlen_utf8(buf0); u_l0 = strlen_utf8(buf0);
u_l1 = u_l - u_l0; u_l1 = u_l - u_l0;
b_l1 = b_l - b_l0; b_l1 = b_l - b_l0;
buf1 = slice(u_l0, u_l, buf PASS_REGS); buf1 = slice(u_l0, u_l, buf PASS_REGS);
b_l1 = strlen((const char *)buf1); b_l1 = strlen((const char *)buf1);
bool rc = write_Text(buf1, outv + 1 PASS_REGS); bool rc = write_Text(buf1, outv + 1 PASS_REGS);
pop_text_stack(lvl); pop_text_stack(lvl);
if (!rc) { if (!rc) {
return false; return false;
} }
return rc; return rc;
} else /* if (outv[1].val.t) */ { } else /* if (outv[1].val.t) */ {
buf1 = Yap_readText(outv + 1 PASS_REGS); buf1 = Yap_readText(outv + 1 PASS_REGS);
if (!buf1) { if (!buf1) {
pop_text_stack(lvl); pop_text_stack(lvl);
return false; return false;
} }
b_l1 = strlen((char *)buf1); b_l1 = strlen((char *)buf1);
u_l1 = strlen_utf8(buf1); u_l1 = strlen_utf8(buf1);
b_l0 = b_l - b_l1; b_l0 = b_l - b_l1;
u_l0 = u_l - u_l1; u_l0 = u_l - u_l1;
if (memcmp(skip_utf8((const unsigned char *)buf, b_l0), buf1, b_l1) != if (memcmp(skip_utf8((const unsigned char *)buf, b_l0), buf1, b_l1) !=
0) { 0) {
pop_text_stack(lvl); pop_text_stack(lvl);
return false; return false;
} }
buf0 = slice(0, u_l0, buf PASS_REGS); buf0 = slice(0, u_l0, buf PASS_REGS);
buf0 = pop_output_text_stack(lvl, buf0); buf0 = pop_output_text_stack(lvl, buf0);
bool rc = write_Text(buf0, outv PASS_REGS); bool rc = write_Text(buf0, outv PASS_REGS);
return rc; return rc;
} }
} }
} }
@ -1181,7 +1147,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
*/ */
const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) { const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
CACHE_REGS CACHE_REGS
Atom at; Atom at;
arity_t arity = 0; arity_t arity = 0;
Functor f; Functor f;
char *s, *smax, *s0; char *s, *smax, *s0;
@ -1213,7 +1179,7 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
} else if (ap->PredFlags & AtomDBPredFlag) { } else if (ap->PredFlags & AtomDBPredFlag) {
at = (Atom)(ap->FunctorOfPred); at = (Atom)(ap->FunctorOfPred);
if (!stpcpy(s, Yap_AtomToUTF8Text(at))) if (!stpcpy(s, Yap_AtomToUTF8Text(at)))
return NULL; return NULL;
} else { } else {
f = ap->FunctorOfPred; f = ap->FunctorOfPred;
at = NameOfFunctor(f); at = NameOfFunctor(f);

1238
C/text.c.new
View File

File diff suppressed because it is too large Load Diff

1
C/write.c
View File

@ -375,7 +375,6 @@ int Yap_FormatFloat(Float f, char **s, size_t sz) {
CACHE_REGS CACHE_REGS
struct write_globs wglb; struct write_globs wglb;
int sno; int sno;
char *so;
sno = Yap_open_buf_write_stream(GLOBAL_Stream[LOCAL_c_output_stream].encoding, sno = Yap_open_buf_write_stream(GLOBAL_Stream[LOCAL_c_output_stream].encoding,
0); 0);

1
CXX/yapdb.hh
View File

@ -53,6 +53,7 @@ public:
YAPModule(YAP_Term t) : YAPAtomTerm(t){}; YAPModule(YAP_Term t) : YAPAtomTerm(t){};
YAPModule() : YAPAtomTerm(curModule()){}; YAPModule() : YAPAtomTerm(curModule()){};
YAPModule(YAPAtom t) : YAPAtomTerm(t){}; YAPModule(YAPAtom t) : YAPAtomTerm(t){};
YAPModule(YAPStringTerm t) : YAPAtomTerm(t.getString()){};
Term term() { return gt(); }; Term term() { return gt(); };
}; };

8
CXX/yapi.cpp
View File

@ -517,6 +517,7 @@ bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) {
bool YAPEngine::mgoal(Term t, Term tmod, bool release) { bool YAPEngine::mgoal(Term t, Term tmod, bool release) {
#if YAP_PYTHON #if YAP_PYTHON
// std::cerr << "mgoal(in) " << YAPTerm(tmod).text() << ":" << YAPTerm(t).text() << "\n";
// PyThreadState *_save; // PyThreadState *_save;
// std::cerr << "mgoal " << YAPTerm(t).text() << "\n"; // std::cerr << "mgoal " << YAPTerm(t).text() << "\n";
@ -529,8 +530,6 @@ bool YAPEngine::mgoal(Term t, Term tmod, bool release) {
q.p = P; q.p = P;
q.cp = CP; q.cp = CP;
PredEntry *ap = nullptr; PredEntry *ap = nullptr;
std::cerr << "mgoal " << YAPTerm(t).text() << "\n";
std::cerr << "mgoal " << YAPTerm(tmod).text() << "\n";
if (IsStringTerm(tmod)) if (IsStringTerm(tmod))
tmod = MkAtomTerm(Yap_LookupAtom(StringOfTerm(tmod))); tmod = MkAtomTerm(Yap_LookupAtom(StringOfTerm(tmod)));
YAPPredicate *p = new YAPPredicate(t, tmod, ts, "C++"); YAPPredicate *p = new YAPPredicate(t, tmod, ts, "C++");
@ -554,9 +553,8 @@ bool YAPEngine::mgoal(Term t, Term tmod, bool release) {
// don't forget, on success these guys may create slots // don't forget, on success these guys may create slots
//__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec "); //__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
result = (bool)YAP_EnterGoal(ap, nullptr, &q); result = (bool)YAP_EnterGoal(ap, nullptr, &q);
std::cerr << "mgoal " << YAPTerm(t).text() << "\n"; // std::cerr << "mgoal " << YAPTerm(tmod).text() << ":" << YAPTerm(t).text() << "\n";
std::cerr << "mgoal " << YAPTerm(tmod).text() << "\n";
YAP_LeaveGoal(result && !release, &q); YAP_LeaveGoal(result && !release, &q);
// PyEval_RestoreThread(_save); // PyEval_RestoreThread(_save);

2
H/ATOMS
View File

@ -269,7 +269,7 @@ A NotLessThanZero N "not_less_than_zero"
A NotNewline N "not_newline" A NotNewline N "not_newline"
A NotZero N "not_zero" A NotZero N "not_zero"
A Number N "number" A Number N "number"
A Obj N "o__bj__" A Obj N "__obj__"
A Off N "off" A Off N "off"
A Offline N "offline" A Offline N "offline"
A On N "on" A On N "on"

9
H/YapFlags.h
View File

@ -119,6 +119,9 @@ INLINE_ONLY Term aro(Term inp) {
// INLINE_ONLY Term booleanFlag( Term inp ); // INLINE_ONLY Term booleanFlag( Term inp );
static inline Term booleanFlag(Term inp) { static inline Term booleanFlag(Term inp) {
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (inp == TermTrue || inp == TermOn) if (inp == TermTrue || inp == TermOn)
return TermTrue; return TermTrue;
if (inp == TermFalse || inp == TermOff) if (inp == TermFalse || inp == TermOff)
@ -139,6 +142,9 @@ static inline Term booleanFlag(Term inp) {
} }
static Term synerr(Term inp) { static Term synerr(Term inp) {
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (inp == TermDec10 || inp == TermFail || inp == TermError || if (inp == TermDec10 || inp == TermFail || inp == TermError ||
inp == TermQuiet) inp == TermQuiet)
return inp; return inp;
@ -172,6 +178,9 @@ static inline Term isatom(Term inp) {
"value must be bound"); "value must be bound");
return TermZERO; return TermZERO;
} }
if (IsStringTerm(inp)) {
inp = MkStringTerm(RepAtom(AtomOfTerm(inp))->StrOfAE);
}
if (IsAtomTerm(inp)) if (IsAtomTerm(inp))
return inp; return inp;
Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag"); Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag");

14
H/YapHeap.h
View File

@ -156,10 +156,10 @@ typedef struct various_codes {
} all_heap_codes; } all_heap_codes;
#include "hglobals.h" #include "generated/hglobals.h"
#include "dhstruct.h" #include "generated/dhstruct.h"
#include "dglobals.h" #include "generated/dglobals.h"
#else #else
typedef struct various_codes { typedef struct various_codes {
/* memory allocation and management */ /* memory allocation and management */
@ -169,15 +169,15 @@ typedef struct various_codes {
} all_heap_codes; } all_heap_codes;
#include "tatoms.h" #include "generated/tatoms.h"
#include "h0struct.h" #include "generated/h0struct.h"
#include "h0globals.h" #include "generated/h0globals.h"
#endif #endif
#include "hlocals.h" #include "generated/hlocals.h"
#include "dlocals.h" #include "dlocals.h"

2
H/generated/iatoms.h
View File

@ -264,7 +264,7 @@
AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline); AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline);
AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero); AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero);
AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber); AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber);
AtomObj = Yap_LookupAtom("o__bj__"); TermObj = MkAtomTerm(AtomObj); AtomObj = Yap_LookupAtom("__obj__"); TermObj = MkAtomTerm(AtomObj);
AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff); AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff);
AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline); AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline);
AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn); AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn);

30
library/dialect/swi/fli/swi.c
View File

@ -1326,7 +1326,7 @@ YAP long int unify(YAP_Term* a, Term* b) */
X_API int PL_unify_atom_chars(term_t t, const char *s) { X_API int PL_unify_atom_chars(term_t t, const char *s) {
CACHE_REGS CACHE_REGS
Atom at; Atom at;
while ((at = Yap_CharsToAtom(s, ENC_ISO_LATIN1 PASS_REGS)) == 0L) { while ((at = Yap_LookupAtom(s)) == 0L) {
if (LOCAL_Error_TYPE && !Yap_SWIHandleError("PL_unify_atom_nchars")) if (LOCAL_Error_TYPE && !Yap_SWIHandleError("PL_unify_atom_nchars"))
return true; return true;
} }
@ -1451,16 +1451,28 @@ X_API int PL_unify_list(term_t tt, term_t h, term_t tail) {
} }
t = Deref(Yap_GetFromSlot(tt)); t = Deref(Yap_GetFromSlot(tt));
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Term pairterm = Yap_MkNewPairTerm(); Term ttail =Yap_GetFromSlot(tail),
Yap_unify(t, pairterm); pairterm = MkPairTerm(Yap_GetFromSlot(h)
/* avoid calling deref */ , ttail);
t = pairterm; if (tt == tail) {
Yap_PutInSlot(tt, pairterm);
return true;
} else {
return Yap_unify(t, pairterm);
}
} else if (!IsPairTerm(t)) { } else if (!IsPairTerm(t)) {
return FALSE; return FALSE;
} }
Yap_PutInSlot(h, HeadOfTerm(t)); bool rc = Yap_unify(h, HeadOfTerm(t));
Yap_PutInSlot(tail, TailOfTerm(t)); if (rc) {
return TRUE; if (tt == tail) {
Yap_PutInSlot(tail, TailOfTerm(t));
return true;
} else {
return Yap_unify(Yap_GetFromSlot(tail), TailOfTerm(t));
}
}
return false;
} }
/* int PL_unify_list(term_t ?t, term_t +h, term_t -t) /* int PL_unify_list(term_t ?t, term_t +h, term_t -t)
@ -1548,7 +1560,7 @@ YAP long int unify(YAP_Term* a, Term* b) */
X_API int PL_unify_string_chars(term_t t, const char *chars) { X_API int PL_unify_string_chars(term_t t, const char *chars) {
CACHE_REGS CACHE_REGS
Term chterm; Term chterm;
while ((chterm = Yap_CharsToString(chars, ENC_ISO_LATIN1 PASS_REGS)) == 0L) { while ((chterm = MkStringTerm(chars)) == 0L) {
if (LOCAL_Error_TYPE && !Yap_SWIHandleError("PL_unify_list_ncodes")) if (LOCAL_Error_TYPE && !Yap_SWIHandleError("PL_unify_list_ncodes"))
return FALSE; return FALSE;
} }

1
library/expand_macros.yap
View File

@ -86,6 +86,7 @@ aux_args([Arg|Args], [Arg|MVars], [PVar|PArgs], [PVar|PVars], ['_'|ProtoArgs]) :
pred_name(Macro, Arity, _ , Name) :- pred_name(Macro, Arity, _ , Name) :-
transformation_id(Id), transformation_id(Id),
atomic_concat(['$$$__Auxiliary_predicate__ for',Macro,'/',Arity,' ',Id], Name). atomic_concat(['$$$__Auxiliary_predicate__ for',Macro,'/',Arity,' ',Id], Name).
transformation_id(Id) :- transformation_id(Id) :-

11
library/maputils.yap
View File

@ -85,13 +85,16 @@ pred_name(Macro, Arity, _ , Name) :-
transformation_id(Id), transformation_id(Id),
atomic_concat(['$$$ for ',Macro,'/',Arity,', line ',Line,' in ',File,' ',Id], Name). atomic_concat(['$$$ for ',Macro,'/',Arity,', line ',Line,' in ',File,' ',Id], Name).
pred_name(Macro, Arity, _ , Name) :- pred_name(Macro, Arity, _ , Name) :-
transformation_id(Id), transformation_id(Id),
stop_low_level_trace,
atomic_concat(['$$$__expansion__ for ',Macro,'/',Arity,' ',Id], Name). atomic_concat(['$$$__expansion__ for ',Macro,'/',Arity,' ',Id], Name).
transformation_id(Id) :- transformation_id(Id) :-
retract(number_of_expansions(Id)), retract(number_of_expansions(Id)),
Id1 is Id+1, !,
assert(number_of_expansions(Id1)). Id1 is Id+1,
assert(number_of_expansions(Id1)).
transformation_id(0).
%% goal_expansion_allowed is semidet. %% goal_expansion_allowed is semidet.
% %

5
os/fmem.c
View File

@ -213,18 +213,13 @@ int Yap_open_buf_write_stream(encoding_t enc, memBufSource src) {
st->vfs = NULL; st->vfs = NULL;
st->buf.on = true; st->buf.on = true;
st->nbuf = NULL; st->nbuf = NULL;
st->nsize = 0;
st->status |= Seekable_Stream_f; st->status |= Seekable_Stream_f;
#if HAVE_OPEN_MEMSTREAM #if HAVE_OPEN_MEMSTREAM
st->file = open_memstream(&st->nbuf, &st->nsize); st->file = open_memstream(&st->nbuf, &st->nsize);
// setbuf(st->file, NULL); // setbuf(st->file, NULL);
if (!st->nbuf) {
return -1;
}
#else #else
st->file = fmemopen((void *)st->nbuf, st->nsize, "w+"); st->file = fmemopen((void *)st->nbuf, st->nsize, "w+");
#endif #endif
st->vfs = NULL;
Yap_DefaultStreamOps(st); Yap_DefaultStreamOps(st);
UNLOCK(st->streamlock); UNLOCK(st->streamlock);
return sno; return sno;

2
packages/python/CMakeLists.txt
View File

@ -6,7 +6,7 @@ set (PYTHON_HEADERS py4yap.h)
set (CMAKE_POSITION_INDEPENDENT_CODE TRUE) set (CMAKE_POSITION_INDEPENDENT_CODE TRUE)
include_directories( BEFORE ${PYTHON_INCLUDE_DIRS} ${CMAKE_BINARY_DIR} include_directories( BEFORE ${PYTHON_INCLUDE_DIRS} ${CMAKE_BINARY_DIR}
${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/os ) ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/os ${CMAKE_SOURCE_DIR}/H ${CMAKE_SOURCE_DIR}/OPTYap )
#talk to python.pl #talk to python.pl
add_lib(YAPPython pyload.c ${PYTHON_HEADERS} ) add_lib(YAPPython pyload.c ${PYTHON_HEADERS} )

27
packages/python/pl2py.c
View File

@ -1,4 +1,5 @@
#include "Yap.h"
#include "py4yap.h" #include "py4yap.h"
@ -109,7 +110,7 @@ static bool copy_to_dictionary(PyObject *dict, term_t targ, term_t taux,
PyObject *term_to_python(term_t t, bool eval, PyObject *o, bool cvt) { PyObject *term_to_python(term_t t, bool eval, PyObject *o, bool cvt) {
// o≈ // o≈
YAP_Term yt = YAP_GetFromSlot(t); YAP_Term yt = YAP_GetFromSlot(t);
// Yap_DebugPlWriteln(yt); Yap_DebugPlWriteln(yt);
switch (PL_term_type(t)) { switch (PL_term_type(t)) {
case PL_VARIABLE: { case PL_VARIABLE: {
if (yt == 0) { if (yt == 0) {
@ -186,31 +187,24 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o, bool cvt) {
} }
default: default:
if (PL_is_pair(t)) { if (PL_is_pair(t)) {
term_t tail = PL_new_term_ref(); Term t0 = Yap_GetFromHandle(t);
term_t arg = PL_new_term_ref(); Term *tail;
size_t len, i; size_t len,i;
if (PL_skip_list(t, tail, &len) && PL_get_nil(tail)) { if ((len = Yap_SkipList(&t0, &tail))>=0 && *tail == TermNil) {
PyObject *out, *a; PyObject *out, *a;
out = PyList_New(len); out = PyList_New(len);
if (!out) {
PL_reset_term_refs(tail);
YAPPy_ThrowError(SYSTEM_ERROR_INTERNAL, t, "list->python");
}
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (!PL_get_list(t, arg, t)) { Term ai = HeadOfTerm(t0);
PL_reset_term_refs(tail); a = term_to_python(Yap_InitHandle(ai), eval, o, cvt);
YAPPy_ThrowError(SYSTEM_ERROR_INTERNAL, t, "list->python");
}
a = term_to_python(arg, eval, o, cvt);
if (a) { if (a) {
if (PyList_SetItem(out, i, a) < 0) { if (PyList_SetItem(out, i, a) < 0) {
YAPPy_ThrowError(SYSTEM_ERROR_INTERNAL, t, "list->python"); YAPPy_ThrowError(SYSTEM_ERROR_INTERNAL, t, "list->python");
} }
} }
t0 = TailOfTerm(t0);
} }
PL_reset_term_refs(tail);
return out; return out;
} else { } else {
PyObject *no = find_obj(o, t, false); PyObject *no = find_obj(o, t, false);
@ -343,7 +337,7 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o, bool cvt) {
AOK(PL_get_arg(1, t, t), NULL); AOK(PL_get_arg(1, t, t), NULL);
if (!(dict = PyDict_New())) if (!(dict = PyDict_New()))
return NULL; return NULL;
Py_INCREF(dict); Py_INCREF(dict);
DebugPrintf("Dict %p\n", dict); DebugPrintf("Dict %p\n", dict);
while (PL_is_functor(t, FUNCTOR_comma2)) { while (PL_is_functor(t, FUNCTOR_comma2)) {
@ -360,6 +354,7 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o, bool cvt) {
return dict; return dict;
} }
AOK(PL_get_name_arity(t, &name, &arity), NULL); AOK(PL_get_name_arity(t, &name, &arity), NULL);
if (name == ATOM_t) { if (name == ATOM_t) {
int i; int i;
rc = PyTuple_New(arity); rc = PyTuple_New(arity);

281
packages/python/py2pl.c
View File

@ -1,5 +1,9 @@
#include "Yap.h"
#include "py4yap.h" #include "py4yap.h"
#include <frameobject.h> #include <frameobject.h>
void YAPPy_ThrowError__(const char *file, const char *function, int lineno, void YAPPy_ThrowError__(const char *file, const char *function, int lineno,
@ -28,12 +32,9 @@ void YAPPy_ThrowError__(const char *file, const char *function, int lineno,
} }
} }
static foreign_t repr_term(PyObject *pVal, term_t t) { static Term repr_term(PyObject *pVal) {
term_t to = PL_new_term_ref(), t1 = PL_new_term_ref(); Term t = MkAddressTerm(pVal);
PL_put_pointer(t1, pVal); return Yap_MkApplTerm(FunctorObj, 1, &t);
PL_cons_functor(to, FUNCTOR_pointer1, t1);
Py_INCREF(pVal);
return PL_unify(t, to);
} }
foreign_t assign_to_symbol(term_t t, PyObject *e); foreign_t assign_to_symbol(term_t t, PyObject *e);
@ -50,185 +51,157 @@ foreign_t assign_to_symbol(term_t t, PyObject *e) {
return PyObject_SetAttrString(dic, s, e) == 0; return PyObject_SetAttrString(dic, s, e) == 0;
} }
foreign_t python_to_term(PyObject *pVal, term_t t) static Term python_to_term__(PyObject *pVal) {
{
bool rc = true;
term_t to = PL_new_term_ref();
// fputs(" <<*** ",stderr); PyObject_Print(pVal,stderr,0);
// fputs("<<***\n",stderr);
if (pVal == Py_None) { if (pVal == Py_None) {
// fputs("<<*** ",stderr);Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs(" // fputs("<<*** ",stderr);Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs("
// >>***\n",stderr); // >>***\n",stderr);
rc = true; return YAP_MkVarTerm();
// fputs("<<*** ",stderr);Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs(" // fputs("<<*** ",stderr);Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs("
// >>***\n",stderr); // >>***\n",stderr);
} else if (PyBool_Check(pVal)) { } else if (PyBool_Check(pVal)) {
rc = rc && PL_unify_bool(t, PyObject_IsTrue(pVal)); if(PyObject_IsTrue(pVal)) return TermTrue;
return TermFalse;
} else if (PyLong_Check(pVal)) { } else if (PyLong_Check(pVal)) {
rc = rc && PL_unify_int64(t, PyLong_AsLong(pVal)); return MkIntegerTerm(PyLong_AsLong(pVal));
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
} else if (PyInt_Check(pVal)) { } else if (PyInt_Check(pVal)) {
rc = rc && PL_unify_int64(t, PyInt_AsLong(pVal)); return MkIntegerTerm(PyInt_AsLong(pVal));
#endif #endif
} else if (PyFloat_Check(pVal)) { } else if (PyFloat_Check(pVal)) {
rc = rc && PL_unify_float(t, PyFloat_AsDouble(pVal)); return MkFloatTerm(PyFloat_AsDouble(pVal));
} else if (PyComplex_Check(pVal)) { } else if (PyComplex_Check(pVal)) {
term_t t1 = PL_new_term_ref(), t2 = PL_new_term_ref(); Term t[2];
if (!PL_put_float(t1, PyComplex_RealAsDouble(pVal)) || t[0] = MkFloatTerm(PyComplex_RealAsDouble(pVal));
!PL_put_float(t2, PyComplex_ImagAsDouble(pVal)) || t[1] = MkFloatTerm(PyComplex_ImagAsDouble(pVal));
!PL_cons_functor(to, FUNCTOR_complex2, t1, t2)) { return Yap_MkApplTerm(FunctorI, 2, t);
rc = false;
} else { }
rc = rc && PL_unify(t, to); else if (PyUnicode_Check(pVal)) {
}
} else if (PyUnicode_Check(pVal)) {
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
size_t sz = PyUnicode_GetSize(pVal) + 1; size_t sz = PyUnicode_GetSize(pVal) + 1;
wchar_t *s = malloc(sizeof(wchar_t) * sz); wchar_t *s = malloc(sizeof(wchar_t) * sz);
sz = PyUnicode_AsWideChar((PyUnicodeObject *)pVal, a, sz - 1); sz = PyUnicode_AsWideChar((PyUnicodeObject *)pVal, a, sz - 1);
free(ptr); free(ptr);
#else #else
const char *s = PyUnicode_AsUTF8(pVal); const char *s = PyUnicode_AsUTF8(pVal);
#endif #endif
if (Yap_AtomInUse(s)) #if 0
if (false && Yap_AtomInUse(s))
rc = rc && PL_unify_atom_chars(t, s); rc = rc && PL_unify_atom_chars(t, s);
else 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
} else if (PyString_Check(pVal)) {
rc = rc && PL_unify_string_chars(t, PyString_AsString(pVal));
#endif #endif
} else if (PyTuple_Check(pVal)) { return MkStringTerm(s);
Py_ssize_t i, sz = PyTuple_Size(pVal); }
functor_t f; else if (PyByteArray_Check(pVal)) {
const char *s; return MkStringTerm(PyByteArray_AsString(pVal));
if (sz == 0) { #if PY_MAJOR_VERSION < 3
rc = rc && PL_unify_atom(t, ATOM_brackets); }
} else { else if (PyString_Check(pVal)) {
if ((s = (Py_TYPE(pVal)->tp_name))) { return MkStringTerm(PyString_AsString(pVal));
if (!strcmp(s, "v")) { #endif
pVal = PyTuple_GetItem(pVal, 0); }
if (pVal == NULL) { else if (PyTuple_Check(pVal)) {
pVal = Py_None; Py_ssize_t sz = PyTuple_Size(pVal);
PyErr_Clear(); const char *s;
} s = Py_TYPE(pVal)->tp_name;
term_t v = YAP_InitSlot(PyLong_AsLong(pVal)); if (s == NULL)
return PL_unify(v, t); s = "t";
} if (sz == 0) {
if (s[0] == '$') { return MkAtomTerm(YAP_LookupAtom(Py_TYPE(pVal)->tp_name));
char *ns = malloc(strlen(s) + 5); }
strcpy(ns, "__"); else {
strcat(ns, s + 1); Functor f = Yap_MkFunctor(Yap_LookupAtom(s), sz);
strcat(ns, "__"); Term t = Yap_MkNewApplTerm(f, sz);
f = PL_new_functor(PL_new_atom(ns), sz); long i;
} else { CELL *ptr = RepAppl(t) + 1;
f = PL_new_functor(PL_new_atom(s), sz); for (i = 0; i < sz; i++) {
} PyObject *p = PyTuple_GetItem(pVal, i);
} else { if (p == NULL) {
f = PL_new_functor(ATOM_t, sz); PyErr_Clear();
} return false;
if (PL_unify_functor(t, f)) {
for (i = 0; i < sz; i++) {
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;
} else {
rc = rc && python_to_term(p, to);
}
PL_reset_term_refs(to);
}
} else {
rc = false;
}
// fputs(" ||*** ",stderr); Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs("
// ||***\n",stderr);
} }
} else if (PyList_Check(pVal)) { *ptr++ = python_to_term__(p);
Py_ssize_t i, sz = PyList_GET_SIZE(pVal);
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);
PL_reset_term_refs(to);
if (!rc)
return false;
}
return rc && PL_unify_nil(t);
// fputs("[***] ", stderr);
// Yap_DebugPlWrite(yt); fputs("[***]\n", stderr);
} else if (PyDict_Check(pVal)) {
Py_ssize_t pos = 0;
int left = PyDict_Size(pVal);
PyObject *key, *value;
if (left == 0) {
rc = rc && PL_unify_atom(t, ATOM_curly_brackets);
} else {
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)) {
continue;
}
if (!python_to_term(value, tval)) {
continue;
}
/* reuse */
tint = tkey;
if (!PL_cons_functor(tint, FUNCTOR_colon2, tkey, tval)) {
rc = false;
continue;
}
if (--left) {
if (!PL_cons_functor(tint, FUNCTOR_comma2, tint, tnew))
PL_reset_term_refs(tkey);
rc = false;
}
if (!PL_unify(to, tint)) {
rc = false;
}
}
rc = rc && PL_unify(t, to);
}
} else {
rc = rc && repr_term(pVal, t);
} }
return t;
}
// PL_reset_term_refs(to);
// fputs(" ||*** ",stderr); Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs("
// ||***\n",stderr);
}
else if (PyList_Check(pVal)) {
Py_ssize_t i, sz = PyList_GET_SIZE(pVal);
if (sz == 0)
return TermNil;
Term t = TermNil;
for (i = sz; i > 0; --i) {
PyObject *p = PyTuple_GetItem(pVal, i);
if (p == NULL) {
PyErr_Clear();
return false;
}
if (!python_to_term__(p))
return false;
t = MkPairTerm(python_to_term__(p), t);
}
return t;
}
else if (PyDict_Check(pVal)) {
Py_ssize_t pos = 0;
int left = PyDict_Size(pVal);
PyObject *key, *value;
Term f, *opt = &f, t;
if (left == 0) {
return ATOM_curly_brackets;
} else {
while (PyDict_Next(pVal, &pos, &key, &value)) {
Term t0[2], to;
t0[0] = python_to_term__(key);
t0[1] = python_to_term__(value);
to = Yap_MkApplTerm(FunctorEq, 2, t0);
if (left--) {
t = Yap_MkNewApplTerm(FunctorOr, 2);
*opt = t;
CELL *pt = RepAppl(t) + 1;
pt[0] = to;
opt = pt + 1;
} else {
*opt = t = to;
}
}
return Yap_MkApplTerm(FunctorBraces, 1, &t);
}
}else {
return repr_term(pVal);
}
}
foreign_t python_to_term(PyObject *pVal, term_t t) {
term_t t0 = PL_new_term_ref();
bool rc = python_to_term__(pVal);
PL_reset_term_refs(t0);
return rc; return rc;
} }
// extern bool Yap_do_low_level_trace;
X_API YAP_Term pythonToYAP(PyObject *pVal) { X_API YAP_Term pythonToYAP(PyObject *pVal) {
// Yap_do_low_level_trace=1;
term_t t = PL_new_term_ref(); /* fputs(" *** ", stderr); */
if (pVal == NULL || !python_to_term(pVal, t)) { /* PyObject_Print(pVal, stderr, 0); */
PL_reset_term_refs(t); /* fputs("***>>\n", stderr); */
return 0; if (pVal == NULL)
} Yap_ThrowError(SYSTEM_ERROR_INTERNAL, 0, NULL);
YAP_Term tt = YAP_GetFromSlot(t); Term t = python_to_term__(pVal);
PL_reset_term_refs(t); /* fputs("<< *** ", stderr); */
/* Yap_DebugPlWrite(t); */
/* fputs(" ***\n", stderr); */
// Py_DECREF(pVal); // Py_DECREF(pVal);
return tt; return t;
} }
PyObject *py_Local, *py_Global; PyObject *py_Local, *py_Global;
/** /**
* assigns the Python RHS to a Prolog term LHS, ie LHS = RHS * assigns the Python RHS to a Prolog term LHS, ie LHS = RHS
* *

6
packages/python/pypreds.c
View File

@ -23,6 +23,11 @@ static foreign_t python_len(term_t tobj, term_t tf) {
len = PyObject_Length(o); len = PyObject_Length(o);
pyErrorAndReturn(PL_unify_int64(tf, len)); pyErrorAndReturn(PL_unify_int64(tf, len));
} }
static foreign_t python_clear_errors(void) {
PyErr_Clear();
return true;
}
static foreign_t python_dir(term_t tobj, term_t tf) { static foreign_t python_dir(term_t tobj, term_t tf) {
PyObject *dir; PyObject *dir;
@ -701,6 +706,7 @@ install_t install_pypreds(void) {
PL_register_foreign("python_import", 2, python_import, 0); PL_register_foreign("python_import", 2, python_import, 0);
PL_register_foreign("python_access", 3, python_access, 0); PL_register_foreign("python_access", 3, python_access, 0);
PL_register_foreign("python_threaded", 0, p_python_threaded, 0); PL_register_foreign("python_threaded", 0, p_python_threaded, 0);
PL_register_foreign("python_clear_errors", 0, python_clear_errors, 0);
init_python_vfs(); init_python_vfs();
} }

1
packages/python/python.pl
View File

@ -32,6 +32,7 @@
release_GIL/0, release_GIL/0,
python_threaded/0, python_threaded/0,
prolog_list_to_python_list/3, prolog_list_to_python_list/3,
python_clear_errors/0,
op(100,fy,$), op(100,fy,$),
op(950,fy,:=), op(950,fy,:=),
op(950,yfx,:=), op(950,yfx,:=),

23
packages/python/swig/prolog/yapi.yap
View File

@ -3,20 +3,20 @@
%% @brief support yap shell %% @brief support yap shell
%% %%
%:- start_low_level_trace. %:- start_low_level_trace.
:- module(yapi, [ %% :- module(yapi, [
python_ouput/0, %% python_ouput/0,
show_answer/2, %% show_answer/2,
show_answer/3, %% show_answer/3,
yap_query/4, %% yap_query/4,
python_query/2, %% python_query/2,
python_query/3, %% python_query/3,
python_import/1, %% python_import/1,
yapi_query/2 %% yapi_query/2
]). %% ]).
:- yap_flag(verbose, silent). :- yap_flag(verbose, silent).
:- use_module(library(python)). :- use_module(library(python)).
:- use_module( library(lists) ). :- use_module( library(lists) ).
:- use_module( library(maplist) ). :- use_module( library(maplist) ).
@ -88,3 +88,4 @@ in_dict(Dict, nonvar([V0|Vs],G)) :- !,
in_dict( Dict, nonvar(Vs, G) ). in_dict( Dict, nonvar(Vs, G) ).
in_dict(_Dict, nonvar([],_G)) :- !. in_dict(_Dict, nonvar([],_G)) :- !.
in_dict(_, _) in_dict(_, _)

32
packages/python/swig/yap4py/yapi.py
View File

@ -6,16 +6,17 @@ import sys
yap_lib_path = dirname(__file__) yap_lib_path = dirname(__file__)
compile = namedtuple('compile', 'file')
bindvars = namedtuple('bindvars', 'list') bindvars = namedtuple('bindvars', 'list')
library = namedtuple('library', 'list') compile = namedtuple('compile', 'file')
jupyter_query = namedtuple('jupyter_query', 'vars dict')
library = namedtuple('library', 'listfiles')
prolog_library = namedtuple('prolog_library', 'listfiles')
python_query = namedtuple('python_query', 'vars dict')
set_prolog_flag = namedtuple('set_prolog_flag', 'flag new_value')
show_answer = namedtuple('show_answer', 'vars dict')
v0 = namedtuple('v', 'slot') v0 = namedtuple('v', 'slot')
yap_query = namedtuple('yap_query', 'query owner') yap_query = namedtuple('yap_query', 'query owner')
jupyter_query = namedtuple('jupyter_query', 'vars dict')
python_query = namedtuple('python_query', 'vars dict')
yapi_query = namedtuple('yapi_query', 'vars dict') yapi_query = namedtuple('yapi_query', 'vars dict')
show_answer = namedtuple('show_answer', 'vars dict')
set_prolog_flag = namedtuple('set_prolog_flag', 'flag new_value')
class Engine( YAPEngine ): class Engine( YAPEngine ):
@ -30,17 +31,18 @@ class Engine( YAPEngine ):
args.setYapPLDIR(yap_lib_path) args.setYapPLDIR(yap_lib_path)
args.setSavedState(join(yap_lib_path, "startup.yss")) args.setSavedState(join(yap_lib_path, "startup.yss"))
YAPEngine.__init__(self, args) YAPEngine.__init__(self, args)
self.goal(set_prolog_flag('verbose', 'silent'),True) self.run(compile(library('yapi')),m="user",release=True)
self.goal(compile(library('yapi')), True)
self.goal(set_prolog_flag('verbose', 'normal'), True)
def run(self, g, m=None, release=False): def run(self, g, m=None, release=False):
if m: if m:
self.mgoal(g, m, release) self.mgoal(g, m, release)
else: else:
self.goal(release) self.goal(g, release)
def prolog_library(self, file):
g = prolog_library(file)
self.run(g)
class JupyterEngine( Engine ): class JupyterEngine( Engine ):
def __init__(self, args=None,self_contained=False,**kwargs): def __init__(self, args=None,self_contained=False,**kwargs):
@ -50,11 +52,9 @@ class JupyterEngine( Engine ):
args.jupyter = True args.jupyter = True
Engine.__init__(self, args) Engine.__init__(self, args)
self.errors = None self.errors = None
self.goal(set_prolog_flag('verbose', 'silent'),True) self.run(compile(library('jupyter')),"user")
self.goal(compile(library('verify')), True) self.run(compile(library('complete')),"user")
self.goal(compile(library('complete')), True) self.run(compile(library('verify')),"user")
self.goal(compile(library('jupyter')), True)
self.goal(set_prolog_flag('verbose', 'normal'), True)
class EngineArgs( YAPEngineArgs ): class EngineArgs( YAPEngineArgs ):
""" Interface to Engine Options class""" """ Interface to Engine Options class"""

6
packages/python/yap_kernel/yap_ipython/prolog/complete.yap
View File

@ -4,12 +4,12 @@
* @brief Prolog completer. * @brief Prolog completer.
*/ */
:- module( completer, %% %% :- module( completer,
[completions/2 ]). %% %% [completions/2 ]).
:- use_module(library(lists)). :- use_module(library(lists)).
:- use_module(library(maplist)). :- use_module(library(maplist)).
:- use_module(library(python)). :- use_module(library(python)).
%% completions( +Text, +PythonCell ) %% completions( +Text, +PythonCell )
% %

27
packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap
View File

@ -6,36 +6,38 @@
*/ */
:- yap_flag(gc_trace,verbose). :- yap_flag(gc_trace,verbose).
/*
:- module( jupyter, :- module( jupyter,
[jupyter_query/3, [jupyter_query/3,
blank/1 blank/1,
streams/1
] ]
). ).
*/
:- use_module(library(hacks)). :- use_module(library(hacks)).
:- use_module(library(lists)). :- use_module(library(lists)).
:- use_module(library(maplist)). :- use_module(library(maplist)).
:- reexport(library(python)). %% :- reexport(library(python)).
:- reexport(library(yapi)). %% :- reexport(library(yapi)).
:- reexport(library(complete)). %% :- reexport(library(complete)).
:- reexport(library(verify)). %% :- reexport(library(verify)).
:- python_import(sys). :- python_import(sys).
jupyter_query(Caller, Cell, Line ) :- jupyter_query(Caller, Cell, Line ) :-
jupyter_cell(Caller, Cell, Line). jupyter_cell(Caller, Cell, Line).
jupyter_cell(_Caller, Cell, _Line) :- jupyter_cell(_Caller, Cell, _Line) :-
jupyter_consult(Cell), %stack_dump, jupyter_consult(Cell), %stack_dump,
fail. fail.
jupyter_cell( _Caller, _, '' ) :- !. jupyter_cell( _Caller, _, `` ) :- !.
jupyter_cell( _Caller, _, Line ) :- jupyter_cell( _Caller, _, Line ) :-
blank( Line ), blank( Line ),
!. !.
jupyter_cell( Caller, _, Line ) :- jupyter_cell(Self, _, Line ) :-
Self := Caller.query,
catch( catch(
python_query(Self,Line), python_query(Self,Line),
E=error(A,B), E=error(A,B),
@ -83,7 +85,8 @@ blank(Text) :-
string_codes(Text, L), string_codes(Text, L),
maplist( code_type(space), L). maplist( code_type(space), L).
streams(false) :-
streams(false) :-
close(user_input), close(user_input),
close(user_output), close(user_output),
close(user_error). close(user_error).
@ -109,4 +112,4 @@ plot_inline :-
:- endif. :- endif.
%:- ( start_low_level_trace ). %y:- ( start_low_level_trace ).

75
packages/python/yap_kernel/yap_ipython/prolog/verify.yap
View File

@ -5,19 +5,22 @@
*/ */
:- module( verify, %% :- module( verify,
[errors/2,q %% [errors/2,
ready/2] %% ready/2]
). %% ).
:- use_module(library(hacks)). :- use_module(library(hacks)).
:- use_module(library(jupyter)). %% :- use_module(library(jupyter)).
:- use_module(library(lists)). :- use_module(library(lists)).
:- use_module(library(maplist)). :- use_module(library(maplist)).
:- use_module(library(python)). :- use_module(library(python)).
:- use_module(library(yapi)). %% :- use_module(library(yapi)).
:- dynamic jupyter/1.
jupyter( []).
ready( Engine, Query) :- ready( Engine, Query) :-
errors( Engine , Cell ), errors( Engine , Cell ),
@ -27,10 +30,10 @@ ready( Engine, Query) :-
errors( _Engine , Text ) :- errors( _Engine , Text ) :-
blank(Text). blank(Text),
!. !.
errors( Engine , Text ) :- errors( Engine , Text ) :-
jupyter..shell := Engine, %start_low_level_trace,
setup_call_cleanup( setup_call_cleanup(
open_esh( Engine , Text, Stream, Name ), open_esh( Engine , Text, Stream, Name ),
esh(Engine , Name, Stream), esh(Engine , Name, Stream),
@ -40,50 +43,55 @@ errors( Engine , Text ) :-
errors( _Engine , _Text ). errors( _Engine , _Text ).
open_esh(Engine , Text, Stream, Name) :- open_esh(Engine , Text, Stream, Name) :-
Engine.errors := [], Engine.errors := [],
retractall(jupyter(_)),
assertz(jupyter(Engine)),
b_setval( jupyter, Engine), b_setval( jupyter, Engine),
Name := Engine.stream_name, Name := Engine.stream_name,
open_mem_read_stream( Text, Stream ). open_mem_read_stream( Text, Stream ).
esh(Engine , Name, Stream) :- esh(Engine , Name, Stream) :-
b_setval(code,python),
repeat, repeat,
catch( catch(
( read_clause(Stream, Cl, [ syntax_errors(fail)]), read_clause(Stream, Cl, [ syntax_errors(dec10)]),
writeln(cl:Cl),
error(C,E), error(C,E),
p_message(C,E) p3_message(C,Engine,E)
),
Cl == end_of_file, Cl == end_of_file,
!. !.
user:print_message() :- p_message
:- multifile user:portray_message/2.
user:portray_message(S,E) :-
jupyter(En),
En \= [],
python_clear_errors,
p3_message(S,En,E).
close_esh( _Engine , Stream ) :- close_esh( _Engine , Stream ) :-
b_delete retractall(jupyter(_)),
assertz(jupyter([])),
close(Stream). close(Stream).
p_message(Severity, Error) :-
writeln((Severity->Error)),
p_message(Severity, Engine, Error).
p_message( _Severity, Engine, error(syntax_error(Cause),info(between(_,LN,_), _FileName, CharPos, Details))) :- p3_message( _Severity, Engine, error(syntax_error(Cause),info(between(_,LN,_), _FileName, CharPos, Details))) :-
%% nb_getval(jupyter_cell, on), python_clear_errors,
%% assert( syntax_error(Cause,LN,CharPos,Details) ). !,
%% user:portray_message(_Severity, error(style_check(_),_) ) :-
%% nb_getval(jupyter_cell, on).
Engine.errors := [t(Cause,LN,CharPos,Details)] + Engine.errors,
!.
p_message(error, Engine, E) :-
writeln(E),
!.
p_message(warning, Engine, E) :-
writeln(E), writeln(E),
NE := [t(Cause,LN,CharPos,Details)]+Engine.errors,
writeln(E),
writeln(NE),
Engine.errors := NE.
p3_message(error, Engine, E) :-
python_clear_errors,
!.
p3_message(warning, Engine, E) :-
!. !.
p_message(error, Engine, E) :- p3_message(error, Engine, E) :-
Engine.errors := [E] + Engine.errors. Engine.errors := [E] + Engine.errors.
p_message(warning, Engine, E) :- p3_message(warning, Engine, E) :-
Engine.errors := [E] + Engine.errors. Engine.errors := [E] + Engine.errors.
%% ready(_Self, Line ) :- %% ready(_Self, Line ) :-
%% blank( Line ), %% blank( Line ),
@ -173,3 +181,4 @@ p_message( _Severity, Engine, error(syntax_error(Cause),info(between(_,LN,_), _
%% Self.errors := [t(C,L,N,A)] + Self.errors, %% Self.errors := [t(C,L,N,A)] + Self.errors,
%% fail. %% fail.
%% close_events( _ ). %% close_events( _ ).

442
packages/python/yap_kernel/yap_ipython/yapi.py
View File

@ -113,424 +113,9 @@ class YAPInputSplitter(InputSplitter):
return True return True
if not line: if not line:
line = text.rstrip() line = text.rstrip()
engine.errors = [] self.errors = []
engine.goal(errors(engine, text),True) engine.mgoal(errors(self, line),"user",True)
print(engine.errors) return self.errors != []
return engine.errors != []
def reset(self):
"""Reset the input buffer and associated state."""
#super(YAPInputSplitter, self).reset()
self._buffer_raw[:] = []
self.source_raw = ''
self.transformer_accumulating = False
for t in self.transforms:
try:
t.reset()
except SyntaxError:
# Nothing that calls reset() expects to handle transformer
# errors
pass
def flush_transformers(self):
def _flush(transform, outs):
"""yield transformed lines
always strings, never None
transform: the current transform
outs: an iterable of previously transformed inputs.
Each may be multiline, which will be passed
one line at a time to transform.
"""
for out in outs:
for line in out.splitlines():
# push one line at a time
tmp = transform.push(line)
if tmp is not None:
yield tmp
# reset the transform
tmp = transform.reset()
if tmp is not None:
yield tmp
out = []
for t in self.transforms:
out = _flush(t, out)
out = list(out)
if out:
self._store('\n'.join(out))
def raw_reset(self):
"""Return raw input only and perform a full reset.
"""
out = self.source_raw
self.reset()
return out
def source_reset(self):
try:
self.flush_transformers()
return self.source
finally:
self.reset()
def push_accepts_more(self):
if self.transformer_accumulating:
return True
else:
return self.validQuery(self.source, engine, self.shell)
def transform_cell(self, cell):
"""Process and translate a cell of input.
"""
self.reset()
try:
self.push(cell)
self.flush_transformers()
return self.source
finally:
self.reset()
def push(self, lines):
"""Push one or more lines of yap_ipython input.
This stores the given lines and returns a status code indicating
whether the code forms a complete Python block or not, after processing
all input lines for special yap_ipython syntax.
Any exceptions generated in compilation are swallowed, but if an
exception was produced, the method returns True.
Parameters
----------
lines : string
One or more lines of Python input.
Returns
-------
is_complete : boolean
True if the current input source (the result of the current input
plus prior inputs) forms a complete Python execution block. Note that
this value is also stored as a private attribute (_is_complete), so it
can be queried at any time.
"""
# We must ensure all input is pure unicode
lines = cast_unicode(lines, self.encoding)
# ''.splitlines() --> [], but we need to push the empty line to transformers
lines_list = lines.splitlines()
if not lines_list:
lines_list = ['']
# Store raw source before applying any transformations to it. Note
# that this must be done *after* the reset() call that would otherwise
# flush the buffer.
self._store(lines, self._buffer_raw, 'source_raw')
transformed_lines_list = []
for line in lines_list:
transformed = self._transform_line(line)
if transformed is not None:
transformed_lines_list.append(transformed)
if transformed_lines_list:
transformed_lines = '\n'.join(transformed_lines_list)
else:
# Got nothing back from transformers - they must be waiting for
# more input.
return False
def _transform_line(self, line):
"""Push a line of input code through the various transformers.
Returns any output from the transformers, or None if a transformer
is accumulating lines.
Sets self.transformer_accumulating as a side effect.
"""
def _accumulating(dbg):
#print(dbg)
self.transformer_accumulating = True
return None
for transformer in self.physical_line_transforms:
line = transformer.push(line)
if line is None:
return _accumulating(transformer)
for transformer in self.logical_line_transforms:
line = transformer.push(line)
if line is None:
return _accumulating(transformer)
#print("transformers clear") #debug
self.transformer_accumulating = False
return line
class YAPCompleter(Completer):
greedy = Bool(False,
help="""Activate greedy completion
PENDING DEPRECTION. this is now mostly taken care of with Jedi.
This will enable completion on elements of lists, self.results of function calls, etc.,
but can be unsafe because the code is actually evaluated on TAB.
"""
).tag(config=True)
debug = Bool(default_value=False,
help='Enable debug for the Completer. Mostly print extra '
'information for experimental jedi integration.') \
.tag(config=True)
backslash_combining_completions = Bool(True,
help="Enable unicode completions, e.g. \\alpha<tab> . "
"Includes completion of latex commands, unicode names, and expanding "
"unicode characters back to latex commands.").tag(config=True)
def __init__(self, namespace=None, global_namespace=None, shell=None, **kwargs):
"""Create a new completer for the command line.
Completer(namespace=ns, global_namespace=ns2) -> completer instance.
"""
self.shell = shell
self.magic_escape = ESC_MAGIC
super(Completer, self).__init__(**kwargs)
def complete(self, text, line=None, cursor_pos=None):
"""Return the completed text and a list of completions.
Parameters
----------
text : string
A string of text to be completed on. It can be given as empty and
instead a line/position pair are given. In this case, the
completer itself will split the line like readline does.
This is called successively with state == 0, 1, 2, ... until it
returns None. The completion should begin with 'text'.
line : string, optional
The complete line that text is part of.
cursor_pos : int, optional
The position of the cursor on the input line.
Returns
-------
text : string
The actual text that was completed.
matches : list
A sorted list with all possible completions.
The optional arguments allow the completion to take more context into
account, and are part of the low-level completion API.
This is a wrapper around the completion mechanism, similar to what
readline does at the command line when the TAB key is hit. By
exposing it as a method, it can be used by other non-readline
environments (such as GUIs) for text completion.
Simple usage example:
In [1]: x = 'hello'
In [2]: _ip.complete('x.l')
Out[2]: ('x.l', ['x.ljust', 'x.lower', 'x.lstrip'])
"""
if not text:
text = line[:cursor_pos]
return self.completions(text, cursor_pos)
def magic_matches(self, text):
"""Match magics"""
# Get all shell magics now rather than statically, so magics loaded at
# runtime show up too.
lsm = self.shell.magics_manager.lsmagic()
line_magics = lsm['line']
cell_magics = lsm['cell']
pre = self.magic_escape
pre2 = pre+pre
explicit_magic = text.startswith(pre)
# Completion logic:
# - user gives %%: only do cell magics
# - user gives %: do both line and cell magics
# - no prefix: do both
# In other words, line magics are skipped if the user gives %% explicitly
#
# We also exclude magics that match any currently visible names:
# https://github.com/ipython/ipython/issues/4877, unless the user has
# typed a %:
# https://github.com/ipython/ipython/issues/10754
bare_text = text.lstrip(pre)
global_matches = []
if not explicit_magic:
def matches(magic):
"""
Filter magics, in particular remove magics that match
a name present in global namespace.
"""
return ( magic.startswith(bare_text) and
magic not in global_matches )
else:
def matches(magic):
return magic.startswith(bare_text)
comp = [ pre2+m for m in cell_magics if matches(m)]
if not text.startswith(pre2):
comp += [ pre+m for m in line_magics if matches(m)]
return comp
def magic_config_matches(self, text): #:str) -> List[str]:
""" Match class names and attributes for %config magic """
texts = text.strip().split()
if len(texts) > 0 and (texts[0] == 'config' or texts[0] == '%config'):
# get all configuration classes
classes = sorted(set([ c for c in self.shell.configurables
if c.__class__.class_traits(config=True)
]), key=lambda x: x.__class__.__name__)
classnames = [ c.__class__.__name__ for c in classes ]
# return all classnames if config or %config is given
if len(texts) == 1:
return classnames
# match classname
classname_texts = texts[1].split('.')
classname = classname_texts[0]
classname_matches = [ c for c in classnames
if c.startswith(classname) ]
# return matched classes or the matched class with attributes
if texts[1].find('.') < 0:
return classname_matches
elif len(classname_matches) == 1 and \
classname_matches[0] == classname:
cls = classes[classnames.index(classname)].__class__
help = cls.class_get_help()
# strip leading '--' from cl-args:
help = re.sub(re.compile(r'^--', re.MULTILINE), '', help)
return [ attr.split('=')[0]
for attr in help.strip().splitlines()
if attr.startswith(texts[1]) ]
return []
def magic_color_matches(self, text): #:str) -> List[str] :
""" Match color schemes for %colors magic"""
texts = text.split()
if text.endswith(' '):
# .split() strips off the trailing whitespace. Add '' back
# so that: '%colors ' -> ['%colors', '']
texts.append('')
if len(texts) == 2 and (texts[0] == 'colors' or texts[0] == '%colors'):
prefix = texts[1]
return [ color for color in InspectColors.keys()
if color.startswith(prefix) ]
return []
def completions(self, text, offset):
"""
Returns an iterator over the possible completions
.. warning:: Unstable
This function is unstable, API may change without warning.
It will also raise unless use in proper context manager.
Parameters
----------
text:str
Full text of the current input, multi line string.
offset:int
Integer representing the position of the cursor in ``text``. Offset
is 0-based indexed.
Yields
------
:any:`Completion` object
The cursor on a text can either be seen as being "in between"
characters or "On" a character depending on the interface visible to
the user. For consistency the cursor being on "in between" characters X
and Y is equivalent to the cursor being "on" character Y, that is to say
the character the cursor is on is considered as being after the cursor.
Combining characters may span more that one position in the
text.
.. note::
If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
fake Completion token to distinguish completion returned by Jedi
and usual yap_ipython completion.
.. note::
Completions are not completely deduplicated yet. If identical
completions are coming from different sources this function does not
ensure that each completion object will only be present once.
"""
self.matches = []
prolog_res = self.shell.yapeng.goal(completions(text, self),True)
if self.matches:
return text, self.matches
magic_res = self.magic_matches(text)
return text, magic_res
class YAPRun:
"""An enhanced, interactive shell for YAP."""
def __init__(self, shell):
self.shell = shell
self.yapeng = JupyterEngine()
global engine
engine = self.yapeng
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):
"""Return whether a legal query
"""
if not text:
return []
if text == self.os:
return self.yapeng.errors
(text,_,_,_) = self.clean_end(text)
self.yapeng.goal(errors(self.yapeng,text),True)
print( self.yapeng.errors )
return self.yapeng.errors != []
def reset(self): def reset(self):
@ -911,7 +496,7 @@ class YAPCompleter(Completer):
ensure that each completion object will only be present once. ensure that each completion object will only be present once.
""" """
self.matches = [] self.matches = []
prolog_res = self.shell.yapeng.goal(completions(text, self),True) prolog_res = self.shell.yapeng.mgoal(completions(text, self), "user",True)
if self.matches: if self.matches:
return text, self.matches return text, self.matches
magic_res = self.magic_matches(text) magic_res = self.magic_matches(text)
@ -940,11 +525,11 @@ class YAPRun:
if not text: if not text:
return [] return []
if text == self.os: if text == self.os:
return self.yapeng.errors return self.errors
self.errors=[]
(text,_,_,_) = self.clean_end(text) (text,_,_,_) = self.clean_end(text)
self.yapeng.goal(errors(self.yapeng,text),True) self.yapeng.mgoal(errors(self,text),"user",True)
print( self.yapeng.errors ) return self.errors
return self.yapeng.errors
def jupyter_query(self, s): def jupyter_query(self, s):
# #
@ -1027,6 +612,7 @@ class YAPRun:
# you can print it out, the left-side is the variable name, # you can print it out, the left-side is the variable name,
# the right side wraps a handle to a variable # the right side wraps a handle to a variable
#import pdb; pdb.set_trace() #import pdb; pdb.set_trace()
# #pdb.set_trace()
# atom match either symbols, or if no symbol exists, strings, In this case # atom match either symbols, or if no symbol exists, strings, In this case
# variable names should match strings # variable names should match strings
# ask = True # ask = True
@ -1067,9 +653,7 @@ class YAPRun:
# except SyntaxError: # except SyntaxError:
# preprocessing_exc_tuple = self.shell.syntax_error() # sys.exc_info() # preprocessing_exc_tuple = self.shell.syntax_error() # sys.exc_info()
cell = raw_cell # cell has to exist so it can be stored/logged cell = raw_cell # cell has to exist so it can be stored/logged
self.yapeng.goal(streams(True), True) for i in self.syntaxErrors(raw_cell):
errors = self.syntaxErrors(raw_cell)
for i in errors:
try: try:
(what,lin,_,text) = i (what,lin,_,text) = i
e = SyntaxError(what, ("<string>", lin, 1, text)) e = SyntaxError(what, ("<string>", lin, 1, text))
@ -1095,7 +679,6 @@ class YAPRun:
# compiler # compiler
# compiler = self.shell.compile if shell_futures else CachingCompiler() # compiler = self.shell.compile if shell_futures else CachingCompiler()
cell_name = str( self.shell.execution_count) cell_name = str( self.shell.execution_count)
engine.stream_name = cell_name
if cell[0] == '%': if cell[0] == '%':
if cell[1] == '%': if cell[1] == '%':
linec = False linec = False
@ -1124,6 +707,7 @@ class YAPRun:
self.shell.displayhook.exec_result = self.result self.shell.displayhook.exec_result = self.result
has_raised = False has_raised = False
try: try:
self.yapeng.mgoal(streams(True),"user", True)
self.bindings = dicts = [] self.bindings = dicts = []
if cell.strip('\n \t'): if cell.strip('\n \t'):
#create a Trace object, telling it what to ignore, and whether to #create a Trace object, telling it what to ignore, and whether to
@ -1148,9 +732,9 @@ class YAPRun:
except Exception as e: except Exception as e:
has_raised = True has_raised = True
self.result.result = False self.result.result = False
self.yapeng.goal(streams(False), True) self.yapeng.mgoal(streams(False),"user", True)
self.yapeng.goal(ODstreams(False), True) self.yapeng.mgoal(streams(False),"user", True)
self.shell.last_execution_succeeded = not has_raised self.shell.last_execution_succeeded = not has_raised
# Reset this so later displayed values do not modify the # Reset this so later displayed values do not modify the

6
pl/consult.yap
View File

@ -308,7 +308,6 @@ load_files(Files0,Opts) :-
'$load_files__'(Files, M, Opts, Call) :- '$load_files__'(Files, M, Opts, Call) :-
'$lf_option'(last_opt, LastOpt), '$lf_option'(last_opt, LastOpt),
'$show_consult_level'(LC), '$show_consult_level'(LC),
writeln(user_error,innbbbbbb),
( LC > 0 ( LC > 0
-> ->
'__NB_getval__'('$lf_status', OldTOpts, fail), '__NB_getval__'('$lf_status', OldTOpts, fail),
@ -1672,6 +1671,11 @@ End of conditional compilation.
consult_depth(LV) :- '$show_consult_level'(LV). consult_depth(LV) :- '$show_consult_level'(LV).
prolog_library(File) :-
yap_flag(verbose,Old,silent),
ensure_loaded(library(File)),
yap_flag(verbose,_,Old).
:- '$add_multifile'(dot_qualified_goal,2,user). :- '$add_multifile'(dot_qualified_goal,2,user).
/** /**