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

memory mgmt

Browse Source
This commit is contained in:
Vitor Santos Costa 2017-09-23 02:17:55 +01:00
parent 70f4f7adcf
commit a40fbe420f
24 changed files with 4238 additions and 4265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -12,6 +12,7 @@
*.dll *.dll
docs/yap.info* docs/yap.info*
.build .build
build
tags tags
TGSautom4te.cache TGSautom4te.cache
cscope.* cscope.*
@ -24,7 +25,6 @@ tmtags*
.Rhistory .Rhistory
.zedstate .zedstate
config.h config.h
Yap.h
YapConfig.h YapConfig.h
YapTermConfig.h YapTermConfig.h
.graffiti .graffiti
@ -42,7 +42,6 @@ groups
.cproject .cproject
.dir-locals.el .dir-locals.el
.DS_store .DS_store
.kateproject
.project .project
.pydevproject .pydevproject
.Rhistory .Rhistory

15
C/atomic.c
View File

@ -268,12 +268,11 @@ static Int char_code(USES_REGS1) {
Atom at = AtomOfTerm(t0); Atom at = AtomOfTerm(t0);
Term tf; Term tf;
unsigned char *c = RepAtom(at)->UStrOfAE; unsigned char *c = RepAtom(at)->UStrOfAE;
int32_t v; int32_t v = IntegerOfTerm(ARG1);
c += get_utf8(c, 1, &v);
if (c[0] != '\0') { get_utf8(c, -1, &v);
Yap_Error(TYPE_ERROR_CHARACTER, t0, "char_code/2"); if (!v)
return FALSE; return false;
}
tf = MkIntTerm(v); tf = MkIntTerm(v);
return Yap_unify(ARG2, tf); return Yap_unify(ARG2, tf);
} }
@ -308,12 +307,12 @@ static Int char_code(USES_REGS1) {
*/ */
static Int name(USES_REGS1) { /* name(?Atomic,?String) */ static Int name(USES_REGS1) { /* name(?Atomic,?String) */
Term t2 = Deref(ARG2), NewT, t1 = Deref(ARG1); Term t2 = Deref(ARG2), NewT, t1 = Deref(ARG1);
LOCAL_MAX_SIZE = 1024; LOCAL_MAX_SIZE = 1024;
int l = push_text_stack(); int l = push_text_stack();
restart_aux: restart_aux:
if (Yap_IsGroundTerm(t1)) { if (Yap_IsGroundTerm(t1)) {
if (!IsVarTerm(t2) && !IsPairTerm(t2) && t2 != TermNil) { if (!IsVarTerm(t2) && !IsPairTerm(t2) && t2 != TermNil) {
Yap_Error(TYPE_ERROR_LIST, ARG2, "name/2"); Yap_Error(TYPE_ERROR_LIST, ARG2, "name/2");

341
C/c_interface.c
View File

@ -2239,10 +2239,9 @@ X_API int YAP_WriteDynamicBuffer(YAP_Term t, char *buf, size_t sze,
char *b; char *b;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
b = Yap_TermToString(t, lengthp, enc, flags); b = Yap_TermToString(t, enc, flags);
if (*lengthp >= sze)
*lengthp = sze;
strncpy(buf, b, sze); strncpy(buf, b, sze);
buf[sze] = 0;
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return true; return true;
} }
@ -2341,9 +2340,9 @@ static void do_bootfile(const char *bootfilename USES_REGS) {
if (Yap_output_msg) if (Yap_output_msg)
fprintf(stderr, "Boot loaded\n"); fprintf(stderr, "Boot loaded\n");
#endif #endif
} }
/** /**
YAP_DelayInit() YAP_DelayInit()
ensures initialization is done after engine creation. ensures initialization is done after engine creation.
@ -2351,11 +2350,11 @@ static void do_bootfile(const char *bootfilename USES_REGS) {
the module. the module.
*/ */
X_API bool YAP_initialized = false; X_API bool YAP_initialized = false;
static int n_mdelays = 0; static int n_mdelays = 0;
static YAP_delaymodule_t *m_delays; static YAP_delaymodule_t *m_delays;
X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) { X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) {
if (m_delays) { if (m_delays) {
m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t)); m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t));
} else { } else {
@ -2365,9 +2364,9 @@ X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) {
m_delays[n_mdelays].s = s; m_delays[n_mdelays].s = s;
n_mdelays++; n_mdelays++;
return true; return true;
} }
bool Yap_LateInit(const char s[]) { bool Yap_LateInit(const char s[]) {
int i; int i;
for (i = 0; i < n_mdelays; i++) { for (i = 0; i < n_mdelays; i++) {
if (!strcmp(m_delays[i].s, s)) { if (!strcmp(m_delays[i].s, s)) {
@ -2376,9 +2375,9 @@ bool Yap_LateInit(const char s[]) {
} }
} }
return false; return false;
} }
static void start_modules(void) { static void start_modules(void) {
Term cm = CurrentModule; Term cm = CurrentModule;
size_t i; size_t i;
for (i = 0; i < n_mdelays; i++) { for (i = 0; i < n_mdelays; i++) {
@ -2386,15 +2385,15 @@ static void start_modules(void) {
m_delays[i].f(); m_delays[i].f();
} }
CurrentModule = cm; CurrentModule = cm;
} }
/// whether Yap is under control of some other system /// whether Yap is under control of some other system
bool Yap_embedded = true; bool Yap_embedded = true;
/* this routine is supposed to be called from an external program /* this routine is supposed to be called from an external program
that wants to control Yap */ that wants to control Yap */
X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
YAP_file_type_t restore_result = yap_init->boot_file_type; YAP_file_type_t restore_result = yap_init->boot_file_type;
bool do_bootstrap = (restore_result & YAP_CONSULT_MODE); bool do_bootstrap = (restore_result & YAP_CONSULT_MODE);
CELL Trail = 0, Stack = 0, Heap = 0, Atts = 0; CELL Trail = 0, Stack = 0, Heap = 0, Atts = 0;
@ -2610,7 +2609,7 @@ X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
start_modules(); start_modules();
YAP_initialized = true; YAP_initialized = true;
return rc; return rc;
} }
#if (DefTrailSpace < MinTrailSpace) #if (DefTrailSpace < MinTrailSpace)
#undef DefTrailSpace #undef DefTrailSpace
@ -2631,7 +2630,7 @@ X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
#define DEFAULT_SCHEDULERLOOP 10 #define DEFAULT_SCHEDULERLOOP 10
#define DEFAULT_DELAYEDRELEASELOAD 3 #define DEFAULT_DELAYEDRELEASELOAD 3
X_API YAP_file_type_t YAP_FastInit(char saved_state[], int argc, char *argv[]) { X_API YAP_file_type_t YAP_FastInit(char saved_state[], int argc, char *argv[]) {
YAP_init_args init_args; YAP_init_args init_args;
YAP_file_type_t out; YAP_file_type_t out;
@ -2642,84 +2641,84 @@ X_API YAP_file_type_t YAP_FastInit(char saved_state[], int argc, char *argv[]) {
Yap_Error(init_args.ErrorNo, TermNil, init_args.ErrorCause); Yap_Error(init_args.ErrorNo, TermNil, init_args.ErrorCause);
} }
return out; return out;
} }
X_API void YAP_PutValue(Atom at, Term t) { Yap_PutValue(at, t); } X_API void YAP_PutValue(Atom at, Term t) { Yap_PutValue(at, t); }
X_API Term YAP_GetValue(Atom at) { return (Yap_GetValue(at)); } X_API Term YAP_GetValue(Atom at) { return (Yap_GetValue(at)); }
X_API int YAP_CompareTerms(Term t1, Term t2) { X_API int YAP_CompareTerms(Term t1, Term t2) {
return Yap_compare_terms(t1, t2); return Yap_compare_terms(t1, t2);
} }
X_API int YAP_Reset(yap_reset_t mode) { X_API int YAP_Reset(yap_reset_t mode) {
int res = TRUE; int res = TRUE;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
res = Yap_Reset(mode); res = Yap_Reset(mode);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return res; return res;
} }
X_API void YAP_Exit(int retval) { Yap_exit(retval); } X_API void YAP_Exit(int retval) { Yap_exit(retval); }
X_API int YAP_InitSocks(const char *host, long port) { return 0; } X_API int YAP_InitSocks(const char *host, long port) { return 0; }
X_API void YAP_SetOutputMessage(void) { X_API void YAP_SetOutputMessage(void) {
#if DEBUG #if DEBUG
Yap_output_msg = TRUE; Yap_output_msg = TRUE;
#endif #endif
} }
X_API int YAP_StreamToFileNo(Term t) { return (Yap_StreamToFileNo(t)); } X_API int YAP_StreamToFileNo(Term t) { return (Yap_StreamToFileNo(t)); }
X_API void YAP_CloseAllOpenStreams(void) { X_API void YAP_CloseAllOpenStreams(void) {
BACKUP_H(); BACKUP_H();
Yap_CloseStreams(FALSE); Yap_CloseStreams(FALSE);
RECOVER_H(); RECOVER_H();
} }
X_API void YAP_FlushAllStreams(void) { X_API void YAP_FlushAllStreams(void) {
BACKUP_H(); BACKUP_H();
// VSC?? Yap_FlushStreams(); // VSC?? Yap_FlushStreams();
RECOVER_H(); RECOVER_H();
} }
X_API void YAP_Throw(Term t) { X_API void YAP_Throw(Term t) {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Yap_JumpToEnv(t); Yap_JumpToEnv(t);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
X_API void YAP_AsyncThrow(Term t) { X_API void YAP_AsyncThrow(Term t) {
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
LOCAL_PrologMode |= AsyncIntMode; LOCAL_PrologMode |= AsyncIntMode;
Yap_JumpToEnv(t); Yap_JumpToEnv(t);
LOCAL_PrologMode &= ~AsyncIntMode; LOCAL_PrologMode &= ~AsyncIntMode;
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
X_API void YAP_Halt(int i) { Yap_exit(i); } X_API void YAP_Halt(int i) { Yap_exit(i); }
X_API CELL *YAP_TopOfLocalStack(void) { X_API CELL *YAP_TopOfLocalStack(void) {
CACHE_REGS CACHE_REGS
return (ASP); return (ASP);
} }
X_API void *YAP_Predicate(Atom a, UInt arity, Term m) { X_API void *YAP_Predicate(Atom a, UInt arity, Term m) {
if (arity == 0) { if (arity == 0) {
return ((void *) RepPredProp(PredPropByAtom(a, m))); return ((void *) RepPredProp(PredPropByAtom(a, m)));
} else { } else {
Functor f = Yap_MkFunctor(a, arity); Functor f = Yap_MkFunctor(a, arity);
return ((void *) RepPredProp(PredPropByFunc(f, m))); return ((void *) RepPredProp(PredPropByFunc(f, m)));
} }
} }
X_API void YAP_PredicateInfo(void *p, Atom *a, UInt *arity, Term *m) { X_API void YAP_PredicateInfo(void *p, Atom *a, UInt *arity, Term *m) {
PredEntry *pd = (PredEntry *) p; PredEntry *pd = (PredEntry *) p;
if (pd->ArityOfPE) { if (pd->ArityOfPE) {
*arity = pd->ArityOfPE; *arity = pd->ArityOfPE;
@ -2732,31 +2731,31 @@ X_API void YAP_PredicateInfo(void *p, Atom *a, UInt *arity, Term *m) {
*m = pd->ModuleOfPred; *m = pd->ModuleOfPred;
else else
*m = TermProlog; *m = TermProlog;
} }
X_API void YAP_UserCPredicate(const char *name, CPredicate def, arity_t arity) { X_API void YAP_UserCPredicate(const char *name, CPredicate def, arity_t arity) {
Yap_InitCPred(name, arity, def, UserCPredFlag); Yap_InitCPred(name, arity, def, UserCPredFlag);
} }
X_API void YAP_UserBackCPredicate_(const char *name, CPredicate init, X_API void YAP_UserBackCPredicate_(const char *name, CPredicate init,
CPredicate cont, arity_t arity, CPredicate cont, arity_t arity,
arity_t extra) { arity_t extra) {
Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag); Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag);
} }
X_API void YAP_UserBackCutCPredicate(const char *name, CPredicate init, X_API void YAP_UserBackCutCPredicate(const char *name, CPredicate init,
CPredicate cont, CPredicate cut, CPredicate cont, CPredicate cut,
arity_t arity, arity_t extra) { arity_t arity, arity_t extra) {
Yap_InitCPredBackCut(name, arity, extra, init, cont, cut, UserCPredFlag); Yap_InitCPredBackCut(name, arity, extra, init, cont, cut, UserCPredFlag);
} }
X_API void YAP_UserBackCPredicate(const char *name, CPredicate init, X_API void YAP_UserBackCPredicate(const char *name, CPredicate init,
CPredicate cont, arity_t arity, CPredicate cont, arity_t arity,
arity_t extra) { arity_t extra) {
Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag); Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag);
} }
X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f, X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f,
arity_t arity, Term mod) { arity_t arity, Term mod) {
CACHE_REGS CACHE_REGS
PredEntry *pe; PredEntry *pe;
@ -2771,91 +2770,91 @@ X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f,
} }
pe->PredFlags |= CArgsPredFlag; pe->PredFlags |= CArgsPredFlag;
CurrentModule = cm; CurrentModule = cm;
} }
X_API Term YAP_CurrentModule(void) { X_API Term YAP_CurrentModule(void) {
CACHE_REGS CACHE_REGS
return (CurrentModule); return (CurrentModule);
} }
X_API Term YAP_SetCurrentModule(Term new) { X_API Term YAP_SetCurrentModule(Term new) {
CACHE_REGS CACHE_REGS
Term omod = CurrentModule; Term omod = CurrentModule;
LOCAL_SourceModule = CurrentModule = new; LOCAL_SourceModule = CurrentModule = new;
return omod; return omod;
} }
X_API Term YAP_CreateModule(Atom at) { X_API Term YAP_CreateModule(Atom at) {
Term t; Term t;
WRITE_LOCK(RepAtom(at)->ARWLock); WRITE_LOCK(RepAtom(at)->ARWLock);
t = Yap_Module(MkAtomTerm(at)); t = Yap_Module(MkAtomTerm(at));
WRITE_UNLOCK(RepAtom(at)->ARWLock); WRITE_UNLOCK(RepAtom(at)->ARWLock);
return t; return t;
} }
X_API Term YAP_StripModule(Term t, Term *modp) { X_API Term YAP_StripModule(Term t, Term *modp) {
return Yap_StripModule(t, modp); return Yap_StripModule(t, modp);
} }
X_API int YAP_ThreadSelf(void) { X_API int YAP_ThreadSelf(void) {
#if THREADS #if THREADS
return Yap_thread_self(); return Yap_thread_self();
#else #else
return -2; return -2;
#endif #endif
} }
X_API int YAP_ThreadCreateEngine(struct YAP_thread_attr_struct *attr) { X_API int YAP_ThreadCreateEngine(struct YAP_thread_attr_struct *attr) {
#if THREADS #if THREADS
return Yap_thread_create_engine(attr); return Yap_thread_create_engine(attr);
#else #else
return -1; return -1;
#endif #endif
} }
X_API int YAP_ThreadAttachEngine(int wid) { X_API int YAP_ThreadAttachEngine(int wid) {
#if THREADS #if THREADS
return Yap_thread_attach_engine(wid); return Yap_thread_attach_engine(wid);
#else #else
return FALSE; return FALSE;
#endif #endif
} }
X_API int YAP_ThreadDetachEngine(int wid) { X_API int YAP_ThreadDetachEngine(int wid) {
#if THREADS #if THREADS
return Yap_thread_detach_engine(wid); return Yap_thread_detach_engine(wid);
#else #else
return FALSE; return FALSE;
#endif #endif
} }
X_API int YAP_ThreadDestroyEngine(int wid) { X_API int YAP_ThreadDestroyEngine(int wid) {
#if THREADS #if THREADS
return Yap_thread_destroy_engine(wid); return Yap_thread_destroy_engine(wid);
#else #else
return FALSE; return FALSE;
#endif #endif
} }
X_API Term YAP_TermNil(void) { return TermNil; } X_API Term YAP_TermNil(void) { return TermNil; }
X_API int YAP_IsTermNil(Term t) { return t == TermNil; } X_API int YAP_IsTermNil(Term t) { return t == TermNil; }
X_API int YAP_AtomGetHold(Atom at) { return Yap_AtomIncreaseHold(at); } X_API int YAP_AtomGetHold(Atom at) { return Yap_AtomIncreaseHold(at); }
X_API int YAP_AtomReleaseHold(Atom at) { return Yap_AtomDecreaseHold(at); } X_API int YAP_AtomReleaseHold(Atom at) { return Yap_AtomDecreaseHold(at); }
X_API Agc_hook YAP_AGCRegisterHook(Agc_hook hook) { X_API Agc_hook YAP_AGCRegisterHook(Agc_hook hook) {
Agc_hook old = GLOBAL_AGCHook; Agc_hook old = GLOBAL_AGCHook;
GLOBAL_AGCHook = hook; GLOBAL_AGCHook = hook;
return old; return old;
} }
X_API int YAP_HaltRegisterHook(HaltHookFunc hook, void *closure) { X_API int YAP_HaltRegisterHook(HaltHookFunc hook, void *closure) {
return Yap_HaltRegisterHook(hook, closure); return Yap_HaltRegisterHook(hook, closure);
} }
X_API char *YAP_cwd(void) { X_API char *YAP_cwd(void) {
CACHE_REGS CACHE_REGS
char *buf = NULL; char *buf = NULL;
int len; int len;
@ -2867,9 +2866,9 @@ X_API char *YAP_cwd(void) {
return NULL; return NULL;
strncpy(buf, LOCAL_FileNameBuf, len); strncpy(buf, LOCAL_FileNameBuf, len);
return buf; return buf;
} }
X_API Term YAP_FloatsToList(double *dblp, size_t sz) { X_API Term YAP_FloatsToList(double *dblp, size_t sz) {
CACHE_REGS CACHE_REGS
Term t; Term t;
CELL *oldH; CELL *oldH;
@ -2900,9 +2899,9 @@ X_API Term YAP_FloatsToList(double *dblp, size_t sz) {
oldH[1] = TermNil; oldH[1] = TermNil;
RECOVER_H(); RECOVER_H();
return t; return t;
} }
X_API Int YAP_ListToFloats(Term t, double *dblp, size_t sz) { X_API Int YAP_ListToFloats(Term t, double *dblp, size_t sz) {
size_t i = 0; size_t i = 0;
t = Deref(t); t = Deref(t);
@ -2935,9 +2934,9 @@ X_API Int YAP_ListToFloats(Term t, double *dblp, size_t sz) {
return sz; return sz;
t = TailOfTerm(t); t = TailOfTerm(t);
} while (TRUE); } while (TRUE);
} }
X_API Term YAP_IntsToList(Int *dblp, size_t sz) { X_API Term YAP_IntsToList(Int *dblp, size_t sz) {
CACHE_REGS CACHE_REGS
Term t; Term t;
CELL *oldH; CELL *oldH;
@ -2968,9 +2967,9 @@ X_API Term YAP_IntsToList(Int *dblp, size_t sz) {
oldH[1] = TermNil; oldH[1] = TermNil;
RECOVER_H(); RECOVER_H();
return t; return t;
} }
X_API Int YAP_ListToInts(Term t, Int *dblp, size_t sz) { X_API Int YAP_ListToInts(Term t, Int *dblp, size_t sz) {
size_t i = 0; size_t i = 0;
t = Deref(t); t = Deref(t);
@ -2990,9 +2989,9 @@ X_API Int YAP_ListToInts(Term t, Int *dblp, size_t sz) {
return sz; return sz;
t = TailOfTerm(t); t = TailOfTerm(t);
} while (TRUE); } while (TRUE);
} }
X_API Term YAP_OpenList(int n) { X_API Term YAP_OpenList(int n) {
CACHE_REGS CACHE_REGS
Term t; Term t;
BACKUP_H(); BACKUP_H();
@ -3008,9 +3007,9 @@ X_API Term YAP_OpenList(int n) {
RECOVER_H(); RECOVER_H();
return t; return t;
} }
X_API Term YAP_ExtendList(Term t0, Term inp) { X_API Term YAP_ExtendList(Term t0, Term inp) {
Term t; Term t;
CELL *ptr = RepPair(t0); CELL *ptr = RepPair(t0);
BACKUP_H(); BACKUP_H();
@ -3021,26 +3020,26 @@ X_API Term YAP_ExtendList(Term t0, Term inp) {
RECOVER_H(); RECOVER_H();
return t; return t;
} }
X_API int YAP_CloseList(Term t0, Term tail) { X_API int YAP_CloseList(Term t0, Term tail) {
CELL *ptr = RepPair(t0); CELL *ptr = RepPair(t0);
RESET_VARIABLE(ptr - 1); RESET_VARIABLE(ptr - 1);
if (!Yap_unify((Term) (ptr - 1), tail)) if (!Yap_unify((Term) (ptr - 1), tail))
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
X_API int YAP_IsAttVar(Term t) { X_API int YAP_IsAttVar(Term t) {
CACHE_REGS CACHE_REGS
t = Deref(t); t = Deref(t);
if (!IsVarTerm(t)) if (!IsVarTerm(t))
return FALSE; return FALSE;
return IsAttVar(VarOfTerm(t)); return IsAttVar(VarOfTerm(t));
} }
X_API Term YAP_AttsOfVar(Term t) { X_API Term YAP_AttsOfVar(Term t) {
CACHE_REGS CACHE_REGS
attvar_record *attv; attvar_record *attv;
@ -3051,25 +3050,25 @@ X_API Term YAP_AttsOfVar(Term t) {
return TermNil; return TermNil;
attv = RepAttVar(VarOfTerm(t)); attv = RepAttVar(VarOfTerm(t));
return attv->Atts; return attv->Atts;
} }
X_API int YAP_FileNoFromStream(Term t) { X_API int YAP_FileNoFromStream(Term t) {
t = Deref(t); t = Deref(t);
if (IsVarTerm(t)) if (IsVarTerm(t))
return -1; return -1;
return Yap_StreamToFileNo(t); return Yap_StreamToFileNo(t);
} }
X_API void *YAP_FileDescriptorFromStream(Term t) { X_API void *YAP_FileDescriptorFromStream(Term t) {
t = Deref(t); t = Deref(t);
if (IsVarTerm(t)) if (IsVarTerm(t))
return NULL; return NULL;
return Yap_FileDescriptorFromStream(t); return Yap_FileDescriptorFromStream(t);
} }
X_API void *YAP_Record(Term t) { X_API void *YAP_Record(Term t) {
DBTerm *dbterm; DBTerm *dbterm;
DBRecordList *dbt; DBRecordList *dbt;
@ -3093,9 +3092,9 @@ X_API void *YAP_Record(Term t) {
dbt->dbrecord = dbterm; dbt->dbrecord = dbterm;
Yap_Records = dbt; Yap_Records = dbt;
return dbt; return dbt;
} }
X_API Term YAP_Recorded(void *handle) { X_API Term YAP_Recorded(void *handle) {
CACHE_REGS CACHE_REGS
Term t; Term t;
DBTerm *dbterm = ((DBRecordList *) handle)->dbrecord; DBTerm *dbterm = ((DBRecordList *) handle)->dbrecord;
@ -3126,9 +3125,9 @@ X_API Term YAP_Recorded(void *handle) {
} while (t == (CELL) 0); } while (t == (CELL) 0);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return t; return t;
} }
X_API int YAP_Erase(void *handle) { X_API int YAP_Erase(void *handle) {
DBRecordList *dbr = (DBRecordList *) handle; DBRecordList *dbr = (DBRecordList *) handle;
if (dbr->next_rec) if (dbr->next_rec)
dbr->next_rec->prev_rec = dbr->prev_rec; dbr->next_rec->prev_rec = dbr->prev_rec;
@ -3140,43 +3139,43 @@ X_API int YAP_Erase(void *handle) {
Yap_ReleaseTermFromDB(dbr->dbrecord); Yap_ReleaseTermFromDB(dbr->dbrecord);
Yap_FreeCodeSpace(handle); Yap_FreeCodeSpace(handle);
return 1; return 1;
} }
X_API yhandle_t YAP_ArgsToSlots(int n) { X_API yhandle_t YAP_ArgsToSlots(int n) {
CACHE_REGS CACHE_REGS
return Yap_NewSlots(n); return Yap_NewSlots(n);
} }
X_API void YAP_SlotsToArgs(int n, yhandle_t slot) { X_API void YAP_SlotsToArgs(int n, yhandle_t slot) {
CACHE_REGS CACHE_REGS
CELL *ptr0 = Yap_AddressFromSlot(slot), *ptr1 = &ARG1; CELL *ptr0 = Yap_AddressFromSlot(slot), *ptr1 = &ARG1;
while (n--) { while (n--) {
*ptr1++ = *ptr0++; *ptr1++ = *ptr0++;
} }
} }
X_API void YAP_signal(int sig) { Yap_signal(sig); } X_API void YAP_signal(int sig) { Yap_signal(sig); }
X_API int YAP_SetYAPFlag(Term flag, Term val) { return setYapFlag(flag, val); } X_API int YAP_SetYAPFlag(Term flag, Term val) { return setYapFlag(flag, val); }
/* yhandle_t YAP_VarSlotToNumber(yhandle_t) */ /* yhandle_t YAP_VarSlotToNumber(yhandle_t) */
X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) { X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) {
CACHE_REGS CACHE_REGS
Term *t = (CELL *) Deref(Yap_GetFromSlot(s)); Term *t = (CELL *) Deref(Yap_GetFromSlot(s));
if (t < HR) if (t < HR)
return t - H0; return t - H0;
return t - LCL0; return t - LCL0;
} }
/* Term YAP_ModuleUser() */ /* Term YAP_ModuleUser() */
X_API Term YAP_ModuleUser(void) { return MkAtomTerm(AtomUser); } X_API Term YAP_ModuleUser(void) { return MkAtomTerm(AtomUser); }
/* int YAP_PredicateHasClauses() */ /* int YAP_PredicateHasClauses() */
X_API yhandle_t YAP_NumberOfClausesForPredicate(PredEntry *pe) { X_API yhandle_t YAP_NumberOfClausesForPredicate(PredEntry *pe) {
return pe->cs.p_code.NOfClauses; return pe->cs.p_code.NOfClauses;
} }
X_API int YAP_MaxOpPriority(Atom at, Term module) { X_API int YAP_MaxOpPriority(Atom at, Term module) {
AtomEntry *ae = RepAtom(at); AtomEntry *ae = RepAtom(at);
OpEntry *info; OpEntry *info;
WRITE_LOCK(ae->ARWLock); WRITE_LOCK(ae->ARWLock);
@ -3192,9 +3191,9 @@ X_API int YAP_MaxOpPriority(Atom at, Term module) {
ret = info->Posfix; ret = info->Posfix;
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
return ret; return ret;
} }
X_API int YAP_OpInfo(Atom at, Term module, int opkind, int *yap_type, int *prio) { X_API int YAP_OpInfo(Atom at, Term module, int opkind, int *yap_type, int *prio) {
AtomEntry *ae = RepAtom(at); AtomEntry *ae = RepAtom(at);
OpEntry *info; OpEntry *info;
int n; int n;
@ -3254,16 +3253,16 @@ X_API int YAP_OpInfo(Atom at, Term module, int opkind, int *yap_type, int *prio)
*yap_type = n; *yap_type = n;
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
return 1; return 1;
} }
X_API int YAP_Argv(char ***argvp) { X_API int YAP_Argv(char ***argvp) {
if (argvp) { if (argvp) {
*argvp = GLOBAL_argv; *argvp = GLOBAL_argv;
} }
return GLOBAL_argc; return GLOBAL_argc;
} }
X_API YAP_tag_t YAP_TagOfTerm(Term t) { X_API YAP_tag_t YAP_TagOfTerm(Term t) {
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
CELL *pt = VarOfTerm(t); CELL *pt = VarOfTerm(t);
if (IsUnboundVar(pt)) { if (IsUnboundVar(pt)) {
@ -3304,12 +3303,12 @@ X_API YAP_tag_t YAP_TagOfTerm(Term t) {
} }
return YAP_TAG_APPL; return YAP_TAG_APPL;
} }
} }
int YAP_BPROLOG_exception; int YAP_BPROLOG_exception;
Term YAP_BPROLOG_curr_toam_status; Term YAP_BPROLOG_curr_toam_status;
/** /**
* Output the number of bytes needed to represent a string in UTF-8 * Output the number of bytes needed to represent a string in UTF-8
* Note that the terminating zero is not included. No error checking * Note that the terminating zero is not included. No error checking
* is performed (the programmer should have that done). * is performed (the programmer should have that done).
@ -3318,7 +3317,7 @@ Term YAP_BPROLOG_curr_toam_status;
* *
* @return a positive number with the size, or 0. * @return a positive number with the size, or 0.
*/ */
X_API size_t YAP_UTF8_TextLength(Term t) { X_API size_t YAP_UTF8_TextLength(Term t) {
utf8proc_uint8_t dst[8]; utf8proc_uint8_t dst[8];
size_t sz = 0; size_t sz = 0;
@ -3350,9 +3349,9 @@ X_API size_t YAP_UTF8_TextLength(Term t) {
sz = strlen(StringOfTerm(t)); sz = strlen(StringOfTerm(t));
} }
return sz; return sz;
} }
X_API Int YAP_ListLength(Term t) { X_API Int YAP_ListLength(Term t) {
Term *aux; Term *aux;
Int n = Yap_SkipList(&t, &aux); Int n = Yap_SkipList(&t, &aux);
@ -3361,35 +3360,35 @@ X_API Int YAP_ListLength(Term t) {
if (*aux == TermNil) if (*aux == TermNil)
return n; return n;
return -1; return -1;
} }
X_API Int YAP_NumberVars(Term t, Int nbv) { return Yap_NumberVars(t, nbv, FALSE); } X_API Int YAP_NumberVars(Term t, Int nbv) { return Yap_NumberVars(t, nbv, FALSE); }
X_API Term YAP_UnNumberVars(Term t) { X_API Term YAP_UnNumberVars(Term t) {
/* don't allow sharing of ground terms */ /* don't allow sharing of ground terms */
return Yap_UnNumberTerm(t, FALSE); return Yap_UnNumberTerm(t, FALSE);
} }
X_API int YAP_IsNumberedVariable(Term t) { X_API int YAP_IsNumberedVariable(Term t) {
return IsApplTerm(t) && FunctorOfTerm(t) == FunctorDollarVar && return IsApplTerm(t) && FunctorOfTerm(t) == FunctorDollarVar &&
IsIntegerTerm(ArgOfTerm(1, t)); IsIntegerTerm(ArgOfTerm(1, t));
} }
X_API size_t YAP_ExportTerm(Term inp, char *buf, size_t len) { X_API size_t YAP_ExportTerm(Term inp, char *buf, size_t len) {
if (!len) if (!len)
return 0; return 0;
return Yap_ExportTerm(inp, buf, len, current_arity()); return Yap_ExportTerm(inp, buf, len, current_arity());
} }
X_API size_t YAP_SizeOfExportedTerm(char *buf) { X_API size_t YAP_SizeOfExportedTerm(char *buf) {
if (!buf) if (!buf)
return 0; return 0;
return Yap_SizeOfExportedTerm(buf); return Yap_SizeOfExportedTerm(buf);
} }
X_API Term YAP_ImportTerm(char *buf) { return Yap_ImportTerm(buf); } X_API Term YAP_ImportTerm(char *buf) { return Yap_ImportTerm(buf); }
X_API int YAP_RequiresExtraStack(size_t sz) { X_API int YAP_RequiresExtraStack(size_t sz) {
CACHE_REGS CACHE_REGS
if (sz < 16 * 1024) if (sz < 16 * 1024)
@ -3408,14 +3407,14 @@ X_API int YAP_RequiresExtraStack(size_t sz) {
} }
RECOVER_H(); RECOVER_H();
return TRUE; return TRUE;
} }
atom_t *TR_Atoms; atom_t *TR_Atoms;
functor_t *TR_Functors; functor_t *TR_Functors;
size_t AtomTranslations, MaxAtomTranslations; size_t AtomTranslations, MaxAtomTranslations;
size_t FunctorTranslations, MaxFunctorTranslations; size_t FunctorTranslations, MaxFunctorTranslations;
X_API Int YAP_AtomToInt(Atom At) { X_API Int YAP_AtomToInt(Atom At) {
TranslationEntry *te = Yap_GetTranslationProp(At, 0); TranslationEntry *te = Yap_GetTranslationProp(At, 0);
if (te != NIL) if (te != NIL)
return te->Translation; return te->Translation;
@ -3436,11 +3435,11 @@ X_API Int YAP_AtomToInt(Atom At) {
MaxAtomTranslations *= 2; MaxAtomTranslations *= 2;
} }
return AtomTranslations - 1; return AtomTranslations - 1;
} }
X_API Atom YAP_IntToAtom(Int i) { return TR_Atoms[i]; } X_API Atom YAP_IntToAtom(Int i) { return TR_Atoms[i]; }
X_API Int YAP_FunctorToInt(Functor f) { X_API Int YAP_FunctorToInt(Functor f) {
Atom At = NameOfFunctor(f); Atom At = NameOfFunctor(f);
arity_t arity = ArityOfFunctor(f); arity_t arity = ArityOfFunctor(f);
TranslationEntry *te = Yap_GetTranslationProp(At, arity); TranslationEntry *te = Yap_GetTranslationProp(At, arity);
@ -3464,25 +3463,25 @@ X_API Int YAP_FunctorToInt(Functor f) {
MaxFunctorTranslations *= 2; MaxFunctorTranslations *= 2;
} }
return FunctorTranslations - 1; return FunctorTranslations - 1;
} }
X_API void *YAP_foreign_stream(int sno) { return GLOBAL_Stream[sno].u.private_data; } X_API void *YAP_foreign_stream(int sno) { return GLOBAL_Stream[sno].u.private_data; }
X_API Functor YAP_IntToFunctor(Int i) { return TR_Functors[i]; } X_API Functor YAP_IntToFunctor(Int i) { return TR_Functors[i]; }
X_API void *YAP_shared(void) { return LOCAL_shared; } X_API void *YAP_shared(void) { return LOCAL_shared; }
X_API PredEntry *YAP_TopGoal(void) { X_API PredEntry *YAP_TopGoal(void) {
YAP_Functor f = Yap_MkFunctor(Yap_LookupAtom("yap_query"), 3); YAP_Functor f = Yap_MkFunctor(Yap_LookupAtom("yap_query"), 3);
Term tmod = MkAtomTerm(Yap_LookupAtom("yapi")); Term tmod = MkAtomTerm(Yap_LookupAtom("yapi"));
PredEntry *p = RepPredProp(Yap_GetPredPropByFunc(f, tmod)); PredEntry *p = RepPredProp(Yap_GetPredPropByFunc(f, tmod));
return p; return p;
} }
void yap_init(void) {} void yap_init(void) {}
#endif // C_INTERFACE_C #endif // C_INTERFACE_C
/** /**
@} @}
*/ */

19
C/modules.c
View File

@ -53,6 +53,7 @@ static ModEntry *initMod(AtomEntry *toname, AtomEntry *ae) {
n->NextME = CurrentModules; n->NextME = CurrentModules;
CurrentModules = n; CurrentModules = n;
n->AtomOfME = ae; n->AtomOfME = ae;
n->NextOfPE =NULL;
n->OwnerFile = Yap_ConsultingFile(PASS_REGS1); n->OwnerFile = Yap_ConsultingFile(PASS_REGS1);
AddPropToAtom(ae, (PropEntry *)n); AddPropToAtom(ae, (PropEntry *)n);
Yap_setModuleFlags(n, parent); Yap_setModuleFlags(n, parent);
@ -385,24 +386,19 @@ static Int strip_module(USES_REGS1) {
} }
static Int yap_strip_clause(USES_REGS1) { static Int yap_strip_clause(USES_REGS1) {
Functor f;
Term t1 = Deref(ARG1), tmod = LOCAL_SourceModule; Term t1 = Deref(ARG1), tmod = LOCAL_SourceModule;
if (tmod == PROLOG_MODULE) { if (tmod == PROLOG_MODULE) {
tmod = TermProlog; tmod = TermProlog;
} }
t1 = Yap_StripModule(t1, &tmod); t1 = Yap_StripModule(t1, &tmod);
if (IsVarTerm(t1)) { if (IsVarTerm(t1) || IsVarTerm(tmod)) {
Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module"); Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module");
return false; return false;
} else if (IsVarTerm(tmod)) { } else if (IsApplTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, tmod, "trying to obtain module"); Functor f = FunctorOfTerm(t1);
return false; if (IsExtensionFunctor(f)) {
} else if (IsIntTerm(t1) || (IsApplTerm(t1) && IsExtensionFunctor((f = FunctorOfTerm(t1))))) {
Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module"); Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
return false; return false;
} else if (!IsAtomTerm(tmod)) {
Yap_Error(TYPE_ERROR_ATOM, tmod, "trying to obtain module");
return false;
} }
if (f == FunctorAssert || f == FunctorDoubleArrow) { if (f == FunctorAssert || f == FunctorDoubleArrow) {
Term thmod = tmod; Term thmod = tmod;
@ -422,6 +418,11 @@ static Int yap_strip_clause(USES_REGS1) {
return false; return false;
} }
} }
} else if (IsIntTerm(t1) || IsIntTerm(tmod) ) {
Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
return false;
}
return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod); return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
} }

36
C/scanner.c
View File

@ -1,19 +1,19 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog * * YAP Prolog *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: %W% %G% * * File: %W% %G% *
* Last rev: 22-1-03 * * Last rev: 22-1-03 *
* mods: * * mods: *
* comments: Prolog's scanner * * comments: Prolog's scanner *
* * * *
*************************************************************************/ *************************************************************************/
/* /*
* Description: * Description:
@ -404,10 +404,10 @@ writing, writing a BOM can be requested using the option
*/ */
#include "Yap.h" #include "Yap.h"
#include "YapEval.h"
#include "YapHeap.h" #include "YapHeap.h"
#include "Yatom.h" #include "Yatom.h"
#include "alloc.h" #include "alloc.h"
#include "YapEval.h"
#include "yapio.h" #include "yapio.h"
/* stuff we want to use in standard YAP code */ /* stuff we want to use in standard YAP code */
#include "YapText.h" #include "YapText.h"
@ -1104,7 +1104,7 @@ Term Yap_scan_num(StreamDesc *inp, bool error_on) {
CACHE_REGS CACHE_REGS
Term out; Term out;
int sign = 1; int sign = 1;
int ch, cherr; int ch, cherr = 0;
char *ptr; char *ptr;
void *old_tr = TR; void *old_tr = TR;
@ -1604,7 +1604,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
if (!(t->TokInfo)) { if (!(t->TokInfo)) {
return CodeSpaceError(t, p, l); return CodeSpaceError(t, p, l);
} }
Free(TokImage);
t->Tok = Ord(kind = String_tok); t->Tok = Ord(kind = String_tok);
} else if (quote == '`') { } else if (quote == '`') {
t->TokInfo = Yap_CharsToTBQ((char *)TokImage, CurrentModule, t->TokInfo = Yap_CharsToTBQ((char *)TokImage, CurrentModule,
@ -1612,7 +1611,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
if (!(t->TokInfo)) { if (!(t->TokInfo)) {
return CodeSpaceError(t, p, l); return CodeSpaceError(t, p, l);
} }
Free(TokImage);
t->Tok = Ord(kind = String_tok); t->Tok = Ord(kind = String_tok);
} else { } else {
t->TokInfo = MkAtomTerm(Yap_ULookupAtom(TokImage)); t->TokInfo = MkAtomTerm(Yap_ULookupAtom(TokImage));

7
C/stdpreds.c
View File

@ -948,9 +948,10 @@ static Int current_predicate(USES_REGS1) {
static OpEntry *NextOp(Prop pp USES_REGS) { static OpEntry *NextOp(Prop pp USES_REGS) {
while (!EndOfPAEntr(pp) && pp->KindOfPE != OpProperty && while (!EndOfPAEntr(pp) &&
(RepOpProp(pp)->OpModule != PROLOG_MODULE pp->KindOfPE != OpProperty &&
|| RepOpProp(pp)->OpModule != CurrentModule) ) (RepOpProp(pp)->OpModule != PROLOG_MODULE || RepOpProp(pp)->OpModule != CurrentModule)
)
pp = pp->NextOfPE; pp = pp->NextOfPE;
return RepOpProp(pp); return RepOpProp(pp);
} }

432
C/text.c
View File

@ -1,19 +1,19 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog * * YAP Prolog *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985-- * * Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985-- *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: strings.c * * File: strings.c *
* comments: General-conversion of character sequences. * * comments: General-conversion of character sequences. *
* * * *
* Last rev: $Date: 2008-07-24 16:02:00 $,$Author: vsc $ * * Last rev: $Date: 2008-07-24 16:02:00 $,$Author: vsc $ *
* * * *
*************************************************************************/ *************************************************************************/
#include "Yap.h" #include "Yap.h"
#include "YapEval.h" #include "YapEval.h"
@ -51,10 +51,7 @@ typedef struct TextBuffer_manager {
int lvl; int lvl;
} text_buffer_t; } text_buffer_t;
int push_text_stack(USES_REGS1) { int push_text_stack(USES_REGS1) { return LOCAL_TextBuffer->lvl++; }
return LOCAL_TextBuffer->lvl++;
}
int pop_text_stack(int i) { int pop_text_stack(int i) {
int lvl = LOCAL_TextBuffer->lvl; int lvl = LOCAL_TextBuffer->lvl;
@ -73,43 +70,9 @@ int pop_text_stack(int i) {
return lvl; return lvl;
} }
void *protected_pop_text_stack(int i, void *protected, bool tmp,
size_t sz USES_REGS) {
void *out = protected;
int lvl = LOCAL_TextBuffer->lvl;
while (lvl > i) {
struct mblock *p = LOCAL_TextBuffer->first[lvl];
while (p) {
struct mblock *np = p->next;
if (p + 1 == protected) {
if (tmp)
out = LOCAL_FileNameBuf;
else
out = p;
memcpy(out, protected, sz);
} else {
free(p);
}
p = np;
}
LOCAL_TextBuffer->first[lvl] = NULL;
LOCAL_TextBuffer->last[lvl] = NULL;
lvl--;
}
LOCAL_TextBuffer->lvl = lvl;
return out;
}
// void pop_text_stack(int i) { LOCAL_TextBuffer->lvl = i; } // void pop_text_stack(int i) { LOCAL_TextBuffer->lvl = i; }
void insert_block(struct mblock *o) {
void *Malloc(size_t sz USES_REGS) { int lvl = o->lvl;
int lvl = LOCAL_TextBuffer->lvl;
if (sz == 0)
sz = 1024;
sz = ALIGN_BY_TYPE(sz + sizeof(struct mblock), CELL);
struct mblock *o = malloc(sz);
if (!o)
return NULL;
o->prev = LOCAL_TextBuffer->last[lvl]; o->prev = LOCAL_TextBuffer->last[lvl];
if (o->prev) { if (o->prev) {
o->prev->next = o; o->prev->next = o;
@ -120,8 +83,36 @@ void *Malloc(size_t sz USES_REGS) {
LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = o; LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = o;
} }
o->next = NULL; o->next = NULL;
}
void release_block(struct mblock *o) {
if (o->prev)
o->prev->next = o->next;
if (o->next)
o->next->prev = o->prev;
int lvl = o->lvl;
if (LOCAL_TextBuffer->first[lvl] == o) {
if (LOCAL_TextBuffer->last[lvl] == o) {
LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = NULL;
}
LOCAL_TextBuffer->first[lvl] = o->next;
} else if (LOCAL_TextBuffer->last[lvl] == o) {
LOCAL_TextBuffer->last[lvl] = o->prev;
}
}
void *Malloc(size_t sz USES_REGS) {
int lvl = LOCAL_TextBuffer->lvl;
if (sz == 0)
sz = 1024;
sz = ALIGN_BY_TYPE(sz + sizeof(struct mblock), CELL);
struct mblock *o = malloc(sz);
if (!o)
return NULL;
o->sz = sz; o->sz = sz;
o->lvl = lvl; o->lvl = lvl;
o->prev = o->next = 0;
insert_block(o);
return o + 1; return o + 1;
} }
@ -141,26 +132,28 @@ void *Realloc(void *pt, size_t sz USES_REGS) {
if (LOCAL_TextBuffer->last[lvl] == old) { if (LOCAL_TextBuffer->last[lvl] == old) {
LOCAL_TextBuffer->last[lvl] = o; LOCAL_TextBuffer->last[lvl] = o;
} }
o->sz = sz;
return o + 1; return o + 1;
} }
void *export_block(int i, void *protected USES_REGS) {
struct mblock *o = ((struct mblock *)protected) - 1;
release_block(o);
if (i >= 0) {
o->lvl = i;
insert_block(o);
return protected;
} else {
memcpy(o, protected, o->sz);
return o;
}
}
void Free(void *pt USES_REGS) { void Free(void *pt USES_REGS) {
struct mblock *o = pt; struct mblock *o = pt;
o--; o--;
if (o->prev) release_block(o);
o->prev->next = o->next;
if (o->next)
o->next->prev = o->prev;
int lvl = o->lvl;
if (LOCAL_TextBuffer->first[lvl] == o) {
if (LOCAL_TextBuffer->last[lvl] == o) {
LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = NULL;
}
LOCAL_TextBuffer->first[lvl] = o->next;
} else if (LOCAL_TextBuffer->last[lvl] == o) {
LOCAL_TextBuffer->last[lvl] = o->prev;
}
free(o); free(o);
} }
@ -171,8 +164,8 @@ void *Yap_InitTextAllocator(void) {
static size_t MaxTmp(USES_REGS1) { static size_t MaxTmp(USES_REGS1) {
return ((char *) LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) - return ((char *)LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) -
(char *) LOCAL_TextBuffer->ptr; (char *)LOCAL_TextBuffer->ptr;
} }
static Term Globalize(Term v USES_REGS) { static Term Globalize(Term v USES_REGS) {
@ -239,7 +232,7 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
return -REPRESENTATION_ERROR_CHARACTER; return -REPRESENTATION_ERROR_CHARACTER;
} else { } else {
AtomEntry *ae = RepAtom(AtomOfTerm(hd)); AtomEntry *ae = RepAtom(AtomOfTerm(hd));
st = (unsigned char *) stpcpy((char *) st, ae->StrOfAE); st = (unsigned char *)stpcpy((char *)st, ae->StrOfAE);
} }
} else if (IsIntegerTerm(hd)) { } else if (IsIntegerTerm(hd)) {
ch = IntegerOfTerm(hd); ch = IntegerOfTerm(hd);
@ -262,7 +255,6 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
l = RepPair(*l) + 1; l = RepPair(*l) + 1;
do_derefa(v, l, derefa2_unk, derefa2_nonvar); do_derefa(v, l, derefa2_unk, derefa2_nonvar);
} }
} }
if (IsVarTerm(*l)) { if (IsVarTerm(*l)) {
@ -279,13 +271,12 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
return length; return length;
} }
static unsigned char *latin2utf8(seq_tv_t *inp, size_t *lengp) { static unsigned char *latin2utf8(seq_tv_t *inp) {
unsigned char *b0 = inp->val.uc; unsigned char *b0 = inp->val.uc;
size_t sz = *lengp = strlen(inp->val.c); size_t sz = strlen(inp->val.c);
sz *= 2; sz *= 2;
int ch; int ch;
unsigned char *buf = Malloc(sz + 1), *pt = buf; unsigned char *buf = Malloc(sz + 1), *pt = buf;
*lengp = strlen(inp->val.c);
if (!buf) if (!buf)
return NULL; return NULL;
while ((ch = *b0++)) { while ((ch = *b0++)) {
@ -298,9 +289,8 @@ static unsigned char *latin2utf8(seq_tv_t *inp, size_t *lengp) {
return buf; return buf;
} }
static unsigned char *wchar2utf8(seq_tv_t *inp, size_t *lengp) { static unsigned char *wchar2utf8(seq_tv_t *inp) {
*lengp = wcslen(inp->val.w); size_t sz = wcslen(inp->val.w) * 4;
size_t sz = *lengp * 4;
wchar_t *b0 = inp->val.w; wchar_t *b0 = inp->val.w;
unsigned char *buf = Malloc(sz + 1), *pt = buf; unsigned char *buf = Malloc(sz + 1), *pt = buf;
int ch; int ch;
@ -315,43 +305,40 @@ static unsigned char *wchar2utf8(seq_tv_t *inp, size_t *lengp) {
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 *to_buffer(unsigned char *buf, Term t, seq_tv_t *inp, static unsigned char *to_buffer(unsigned char *buf, Term t, seq_tv_t *inp,
bool *widep, Int *atoms, bool *widep, Int *atoms USES_REGS) {
size_t *lenp USES_REGS) {
CELL *r = NULL; CELL *r = NULL;
Int n; Int n;
if (!buf) {
inp->max = *lenp;
}
unsigned char *bufc = buf; unsigned char *bufc = buf;
if (bufc == NULL) {
bufc = malloc(1024);
}
n = SkipListCodes(&bufc, &t, &r, atoms, widep, inp PASS_REGS); n = SkipListCodes(&bufc, &t, &r, atoms, widep, inp PASS_REGS);
if (n < 0) { if (n < 0) {
LOCAL_Error_TYPE = -n; LOCAL_Error_TYPE = -n;
return NULL; return NULL;
} }
*lenp = n;
return bufc; return bufc;
} }
static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t, static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp, bool *widep, seq_tv_t *inp,
size_t *lenp USES_REGS) { bool *widep USES_REGS) {
Int atoms = 1; // we only want lists of atoms Int atoms = 1; // we only want lists of atoms
return to_buffer(buf, t, inp, widep, &atoms, lenp PASS_REGS); return to_buffer(buf, t, inp, widep, &atoms PASS_REGS);
} }
static unsigned char *Yap_ListOfAtomsToBuffer(unsigned char *buf, Term t, static unsigned char *Yap_ListOfAtomsToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp, bool *widep, seq_tv_t *inp,
size_t *lenp USES_REGS) { bool *widep USES_REGS) {
Int atoms = 2; // we only want lists of integer codes Int atoms = 2; // we only want lists of integer codes
return to_buffer(buf, t, inp, widep, &atoms, lenp PASS_REGS); return to_buffer(buf, t, inp, widep, &atoms PASS_REGS);
} }
static unsigned char *Yap_ListToBuffer(unsigned char *buf, Term t, static unsigned char *Yap_ListToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp, bool *widep, seq_tv_t *inp, bool *widep USES_REGS) {
size_t *lenp USES_REGS) {
Int atoms = 0; // we accept both types of lists. Int atoms = 0; // we accept both types of lists.
return to_buffer(buf, t, inp, widep, &atoms, lenp PASS_REGS); return to_buffer(buf, t, inp, widep, &atoms PASS_REGS);
} }
#if USE_GEN_TYPE_ERROR #if USE_GEN_TYPE_ERROR
@ -381,7 +368,7 @@ static yap_error_number gen_type_error(int flags) {
// static int cnt; // static int cnt;
unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) { unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) {
unsigned char *s0 = NULL; unsigned char *s0 = NULL;
bool wide; bool wide;
@ -401,8 +388,8 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
} else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) && } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) { inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) {
LOCAL_Error_TYPE = TYPE_ERROR_LIST; LOCAL_Error_TYPE = TYPE_ERROR_LIST;
} else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
&& !IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) { !IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) {
LOCAL_Error_TYPE = TYPE_ERROR_TEXT; LOCAL_Error_TYPE = TYPE_ERROR_TEXT;
} }
} }
@ -414,59 +401,55 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
// this is a term, extract to a buffer, and representation is wide // this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
Atom at = AtomOfTerm(inp->val.t); Atom at = AtomOfTerm(inp->val.t);
size_t sz = strlen(at->StrOfAE);
if (lengp)
*lengp = sz;
if (inp->type & YAP_STRING_WITH_BUFFER) if (inp->type & YAP_STRING_WITH_BUFFER)
return at->UStrOfAE; return at->UStrOfAE;
size_t sz = strlen(at->StrOfAE);
inp->type |= YAP_STRING_IN_TMP; inp->type |= YAP_STRING_IN_TMP;
char *o = Malloc(sz + 1); char *o = Malloc(sz + 1);
strcpy(o, at->StrOfAE); strcpy(o, at->StrOfAE);
return (unsigned char *) o; o = export_block(0, o);
return (unsigned char *)o;
} }
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) { if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
// this is a term, extract to a buffer, and representation is wide // this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
const char *s = StringOfTerm(inp->val.t); const char *s = StringOfTerm(inp->val.t);
size_t sz = strlen(s);
if (lengp)
*lengp = sz;
if (inp->type & YAP_STRING_WITH_BUFFER) if (inp->type & YAP_STRING_WITH_BUFFER)
return (unsigned char *) UStringOfTerm(inp->val.t); return (unsigned char *)UStringOfTerm(inp->val.t);
inp->type |= YAP_STRING_IN_TMP; inp->type |= YAP_STRING_IN_TMP;
size_t sz = strlen(s);
char *o = Malloc(sz + 1); char *o = Malloc(sz + 1);
o = export_block(0, o);
strcpy(o, s); strcpy(o, s);
return (unsigned char *) o; return (unsigned char *)o;
} }
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) == if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS)) && (YAP_STRING_CODES | YAP_STRING_ATOMS)) &&
IsPairOrNilTerm(inp->val.t)) { IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
return Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS); return Yap_ListToBuffer(s0, inp->val.t, inp, &wide PASS_REGS);
// this is a term, extract to a sfer, and representation is wide // this is a term, extract to a sfer, and representation is wide
} }
if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) { if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS); return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide PASS_REGS);
// this is a term, extract to a sfer, and representation is wide // this is a term, extract to a sfer, and representation is wide
} }
if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) { if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS); return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide PASS_REGS);
// this is a term, extract to a buffer, and representation is wide // this is a term, extract to a buffer, and representation is wide
} }
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) { if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
// ASCII, so both LATIN1 and UTF-8 // ASCII, so both LATIN1 and UTF-8
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
char *s; char *s;
s = Malloc(0); s = Malloc(2 * MaxTmp(PASS_REGS1));
if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT, if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
IntegerOfTerm(inp->val.t)) < 0) { IntegerOfTerm(inp->val.t)) < 0) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char); AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
} }
if (lengp) return (unsigned char *)s;
*lengp = strlen(s);
return (unsigned char *) s;
} }
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) { if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
char *s; char *s;
@ -474,51 +457,42 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, 1024)) { if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, 1024)) {
return NULL; return NULL;
} }
if (lengp) return (unsigned char *)s;
*lengp = strlen(s);
return (unsigned char *) s;
} }
#if USE_GMP #if USE_GMP
if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) { if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
char *s; char *s;
s = Malloc(0); s = Malloc(MaxTmp());
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) { if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) {
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char); AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
} }
if (lengp) return inp->val.uc = (unsigned char *)s;
*lengp = strlen(s);
return inp->val.uc = (unsigned char *) s;
} }
#endif #endif
if (inp->type & YAP_STRING_TERM) { if (inp->type & YAP_STRING_TERM) {
// Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
char *s = (char *) Yap_TermToString(inp->val.t, lengp, ENC_ISO_UTF8, 0); char *s = (char *)Yap_TermToString(inp->val.t, ENC_ISO_UTF8, 0);
return inp->val.uc = (unsigned char *) s; return inp->val.uc = (unsigned char *)s;
} }
if (inp->type & YAP_STRING_CHARS) { if (inp->type & YAP_STRING_CHARS) {
if (inp->enc == ENC_ISO_LATIN1) { if (inp->enc == ENC_ISO_LATIN1) {
return latin2utf8(inp, lengp); return latin2utf8(inp);
} else if (inp->enc == ENC_ISO_ASCII) { } else if (inp->enc == ENC_ISO_ASCII) {
if (lengp)
*lengp = strlen(inp->val.c);
return inp->val.uc; return inp->val.uc;
} else { //if (inp->enc == ENC_ISO_UTF8) { } else { // if (inp->enc == ENC_ISO_UTF8) {
if (lengp)
*lengp = strlen(inp->val.c);
return inp->val.uc; return inp->val.uc;
} }
} }
if (inp->type & YAP_STRING_WCHARS) { if (inp->type & YAP_STRING_WCHARS) {
// printf("%S\n",inp->val.w); // printf("%S\n",inp->val.w);
return wchar2utf8(inp, lengp); return wchar2utf8(inp);
} }
return NULL; return NULL;
} }
static Term write_strings(unsigned char *s0, seq_tv_t *out, static Term write_strings(unsigned char *s0, seq_tv_t *out USES_REGS) {
size_t leng USES_REGS) { size_t min = 0, max = strlen((char *)s0);
size_t min = 0, max = leng;
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
if (out->type & YAP_STRING_NCHARS) if (out->type & YAP_STRING_NCHARS)
@ -529,11 +503,11 @@ static Term write_strings(unsigned char *s0, seq_tv_t *out,
} }
} }
char *s = (char *) s0; char *s = (char *)s0;
Term t = init_tstring(PASS_REGS1); Term t = init_tstring(PASS_REGS1);
LOCAL_TERM_ERROR(t, 2 * max); LOCAL_TERM_ERROR(t, 2 * max);
unsigned char *buf = buf_from_tstring(HR); unsigned char *buf = buf_from_tstring(HR);
strcpy((char *) buf, s); strcpy((char *)buf, s);
if (max + 1 < min) { if (max + 1 < min) {
LOCAL_TERM_ERROR(t, 2 * min); LOCAL_TERM_ERROR(t, 2 * min);
memset(buf + min, '\0', max); memset(buf + min, '\0', max);
@ -547,12 +521,13 @@ static Term write_strings(unsigned char *s0, seq_tv_t *out,
return out->val.t; return out->val.t;
} }
static Term write_atoms(void *s0, seq_tv_t *out, size_t leng USES_REGS) { static Term write_atoms(void *s0, seq_tv_t *out USES_REGS) {
Term t = AbsPair(HR); Term t = AbsPair(HR);
char *s1 = (char *)s0;
size_t sz = 0; size_t sz = 0;
size_t max = leng; size_t max = strlen(s1);
if (leng == 0) { if (s1[0] == '\0') {
out->val.t = t; out->val.t = TermNil;
return TermNil; return TermNil;
} }
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
@ -560,7 +535,7 @@ static Term write_atoms(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
max = out->max; max = out->max;
} }
unsigned char *s = s0, *lim = s + strnlen((char *) s, max); unsigned char *s = s0, *lim = s + strnlen((char *)s, max);
unsigned char *cp = s; unsigned char *cp = s;
unsigned char w[10]; unsigned char w[10];
int wp = 0; int wp = 0;
@ -598,23 +573,23 @@ static Term write_atoms(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
return (t); return (t);
} }
static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) { static Term write_codes(void *s0, seq_tv_t *out USES_REGS) {
Term t = AbsPair(HR); Term t;
size_t sz = 0; size_t sz = strlen(s0);
size_t max = leng; if (sz == 0) {
if (leng == 0) { if (out->type & YAP_STRING_DIFF) {
out->val.t = t; out->val.t = Globalize(out->dif PASS_REGS);
return TermNil; } else {
out->val.t = TermNil;
} }
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { return out->val.t;
if (out->type & YAP_STRING_TRUNC && out->max < max)
max = out->max;
} }
unsigned char *s = s0, *lim = s + sz;
unsigned char *s = s0, *lim = s + strlen((char *) s);
unsigned char *cp = s; unsigned char *cp = s;
t = AbsPair(HR);
LOCAL_TERM_ERROR(t, 2 * (lim - s)); LOCAL_TERM_ERROR(t, 2 * (lim - s));
t = AbsPair(HR);
while (*cp) { while (*cp) {
utf8proc_int32_t chr; utf8proc_int32_t chr;
CELL *cl; CELL *cl;
@ -625,28 +600,20 @@ static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
HR += 2; HR += 2;
cl[0] = MkIntegerTerm(chr); cl[0] = MkIntegerTerm(chr);
cl[1] = AbsPair(HR); cl[1] = AbsPair(HR);
sz++;
if (sz == max)
break;
} }
if (out->type & YAP_STRING_DIFF) { if (sz == 0) {
if (sz == 0)
t = out->dif;
else
HR[-1] = Globalize(out->dif PASS_REGS); HR[-1] = Globalize(out->dif PASS_REGS);
} else { } else {
if (sz == 0)
t = TermNil;
else
HR[-1] = TermNil; HR[-1] = TermNil;
} }
out->val.t = t; out->val.t = t;
return (t); return (t);
} }
static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) { static Atom write_atom(void *s0, seq_tv_t *out USES_REGS) {
unsigned char *s = s0; unsigned char *s = s0;
int32_t ch; int32_t ch;
size_t leng = strlen(s0);
if (leng == 0) { if (leng == 0) {
return Yap_LookupAtom(""); return Yap_LookupAtom("");
} }
@ -660,18 +627,19 @@ static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
} }
} }
size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) { size_t write_buffer(unsigned char *s0, seq_tv_t *out USES_REGS) {
size_t leng = strlen((char *)s0);
size_t min = 0, max = leng, room_end; size_t min = 0, max = leng, room_end;
if (out->enc == ENC_ISO_UTF8) { if (out->enc == ENC_ISO_UTF8) {
room_end = strlen((char *) s0) + 1; room_end = strlen((char *)s0) + 1;
if (out->val.uc == NULL) { // this should always be the case if (out->val.uc == NULL) { // this should always be the case
out->val.uc = malloc(room_end < 16 ? 16 : room_end); out->val.uc = malloc(room_end < 16 ? 16 : room_end);
} }
if (out->val.uc != s0) { if (out->val.uc != s0) {
strcpy(out->val.c, (char *) s0); strcpy(out->val.c, (char *)s0);
} }
} else if (out->enc == ENC_ISO_LATIN1) { } else if (out->enc == ENC_ISO_LATIN1) {
room_end = strlen((char *) s0) + 1; room_end = strlen((char *)s0) + 1;
unsigned char *s = s0; unsigned char *s = s0;
unsigned char *cp = s; unsigned char *cp = s;
unsigned char *buf = out->val.uc; unsigned char *buf = out->val.uc;
@ -698,7 +666,7 @@ size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) {
} }
room_end = buf - out->val.uc; room_end = buf - out->val.uc;
} 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));
unsigned char *cp = s; unsigned char *cp = s;
wchar_t *buf0, *buf; wchar_t *buf0, *buf;
@ -728,44 +696,43 @@ size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) {
return room_end; return room_end;
} }
static size_t write_length(const unsigned char *s0, seq_tv_t *out, static size_t write_length(const unsigned char *s0, seq_tv_t *out USES_REGS) {
size_t leng USES_REGS) { return strlen_utf8(s0);
return leng;
} }
static Term write_number(unsigned char *s, seq_tv_t *out, int size, 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;
yap_error_number erro = LOCAL_Error_TYPE; yap_error_number erro = LOCAL_Error_TYPE;
int i = push_text_stack(); int i = push_text_stack();
t = Yap_StringToNumberTerm((char *) s, &out->enc, error_on); t = Yap_StringToNumberTerm((char *)s, &out->enc, error_on);
pop_text_stack(i); pop_text_stack(i);
LOCAL_Error_TYPE = erro; LOCAL_Error_TYPE = erro;
return t; return t;
} }
static Term string_to_term(void *s, seq_tv_t *out, size_t leng USES_REGS) { static Term string_to_term(void *s, seq_tv_t *out USES_REGS) {
Term o; Term o;
yap_error_number erro = LOCAL_Error_TYPE; yap_error_number erro = LOCAL_Error_TYPE;
o = out->val.t = Yap_BufferToTerm(s, strlen(s) + 1, TermNil); o = out->val.t = Yap_BufferToTerm(s, TermNil);
LOCAL_Error_TYPE = erro; LOCAL_Error_TYPE = erro;
return o; return o;
} }
bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) { bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS) {
/* we know what the term is */ /* we know what the term is */
if (out->type == 0) { if (out->type == 0) {
return true; return true;
} }
if (out->type & YAP_STRING_DATUM) { if (out->type & YAP_STRING_DATUM) {
if ((out->val.t = string_to_term(inp, out, leng PASS_REGS)) != 0L) if ((out->val.t = string_to_term(inp, out PASS_REGS)) != 0L)
return out->val.t != 0; return out->val.t != 0;
} }
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, leng, !(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;
@ -775,7 +742,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
return false; return false;
} }
if (out->type & (YAP_STRING_ATOM)) { if (out->type & (YAP_STRING_ATOM)) {
if ((out->val.a = write_atom(inp, out, leng 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);
@ -786,42 +753,40 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
switch (out->type & YAP_TYPE_MASK) { switch (out->type & YAP_TYPE_MASK) {
case YAP_STRING_CHARS: { case YAP_STRING_CHARS: {
size_t room = write_buffer(inp, out, leng PASS_REGS); size_t room = write_buffer(inp, out PASS_REGS);
// printf("%s\n", out->val.c); // printf("%s\n", out->val.c);
return ((Int) room > 0); return ((Int)room > 0);
} }
case YAP_STRING_WCHARS: { case YAP_STRING_WCHARS: {
size_t room = write_buffer(inp, out, leng PASS_REGS); size_t room = write_buffer(inp, out PASS_REGS);
// printf("%S\n", out->val.w); // printf("%S\n", out->val.w);
return ((Int) room > 0); return ((Int)room > 0);
} }
case YAP_STRING_STRING: case YAP_STRING_STRING:
out->val.t = write_strings(inp, out, leng PASS_REGS); out->val.t = write_strings(inp, out PASS_REGS);
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
case YAP_STRING_ATOMS: case YAP_STRING_ATOMS:
out->val.t = write_atoms(inp, out, leng PASS_REGS); out->val.t = write_atoms(inp, out PASS_REGS);
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
case YAP_STRING_CODES: case YAP_STRING_CODES:
out->val.t = write_codes(inp, out, leng PASS_REGS); out->val.t = write_codes(inp, out PASS_REGS);
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
case YAP_STRING_LENGTH: case YAP_STRING_LENGTH:
out->val.l = write_length(inp, out, leng PASS_REGS); out->val.l = write_length(inp, out PASS_REGS);
// printf("s\n",out->val.l); // printf("s\n",out->val.l);
return out->val.l != (size_t) (-1); return out->val.l != (size_t)(-1);
case YAP_STRING_ATOM: case YAP_STRING_ATOM:
out->val.a = write_atom(inp, out, leng PASS_REGS); out->val.a = write_atom(inp, out PASS_REGS);
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.a != NULL; return out->val.a != NULL;
case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG: case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG:
out->val.t = write_number(inp, out, leng, true PASS_REGS); out->val.t = write_number(inp, out, true PASS_REGS);
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
default: { default: { return true; }
return true;
}
} }
return false; return false;
} }
@ -855,8 +820,6 @@ static size_t downcase(void *s0, seq_tv_t *out USES_REGS) {
bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) { bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
unsigned char *buf; unsigned char *buf;
bool rc; bool rc;
size_t leng;
/* /*
f//printfmark(stderr, "[ %d ", n++) ; f//printfmark(stderr, "[ %d ", n++) ;
if (inp->type & (YAP_STRING_TERM|YAP_STRING_ATOM|YAP_STRING_ATOMS_CODES if (inp->type & (YAP_STRING_TERM|YAP_STRING_ATOM|YAP_STRING_ATOMS_CODES
@ -867,10 +830,13 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
else fprintf(stderr,"s %s\n", inp->val.c); else fprintf(stderr,"s %s\n", inp->val.c);
*/ */
// cnt++; // cnt++;
buf = Yap_readText(inp, &leng PASS_REGS); int l = push_text_stack();
buf = Yap_readText(inp PASS_REGS);
if (!buf) { if (!buf) {
pop_text_stack(l);
return 0L; return 0L;
} }
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);
@ -881,23 +847,25 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
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, leng) // const unsigned char *ptr = skip_utf8(buf)
} }
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);
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);
return false; return false;
} }
} }
} }
rc = write_Text(buf, out, leng 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 &
@ -910,10 +878,10 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
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);
return rc; return rc;
} }
static unsigned char *concat(int n, void *sv[] USES_REGS) { static unsigned char *concat(int n, void *sv[] USES_REGS) {
void *buf; void *buf;
unsigned char *buf0; unsigned char *buf0;
@ -921,16 +889,21 @@ static unsigned char *concat(int n, void *sv[] USES_REGS) {
int i; int i;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
room += strlen((char *) sv[i]); char *s = sv[i];
if (s[0])
room += strlen(s);
} }
buf = Malloc(room + 1); buf = Malloc(room + 1);
buf0 = buf; buf0 = buf;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
char *s = sv[i];
if (!s[0])
continue;
#if _WIN32 || defined(__ANDROID__) #if _WIN32 || defined(__ANDROID__)
strcpy(buf, sv[i]); strcpy(buf, s);
buf = (char *)buf + strlen(buf); buf = (char *)buf + strlen(buf);
#else #else
buf = stpcpy(buf, sv[i]); buf = stpcpy(buf, s);
#endif #endif
} }
return buf0; return buf0;
@ -955,25 +928,32 @@ static void *slice(size_t min, size_t max, const unsigned char *buf USES_REGS) {
bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) { bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
void **bufv; void **bufv;
unsigned char *buf; unsigned char *buf;
int i; int i, j;
size_t leng;
bufv = Malloc(tot * sizeof(unsigned char *)); bufv = Malloc(tot * sizeof(unsigned char *));
if (!bufv) { if (!bufv) {
return NULL; return NULL;
} }
for (i = 0; i < tot; i++) { for (i = 0, j = 0; i < tot; i++) {
inp[i].type |= YAP_STRING_WITH_BUFFER; inp[j].type |= YAP_STRING_WITH_BUFFER;
unsigned char *nbuf = Yap_readText(inp + i, &leng PASS_REGS); unsigned char *nbuf = Yap_readText(inp + i PASS_REGS);
if (!nbuf) { if (!nbuf) {
return NULL; return NULL;
} }
bufv[i] = nbuf; if (!nbuf[0])
continue;
bufv[j++] = nbuf;
} }
if (j == 0) {
buf = malloc(8);
memset(buf, 0, 4);
} else if (j == 1) {
buf = bufv[0];
} else {
buf = concat(tot, bufv PASS_REGS); buf = concat(tot, bufv PASS_REGS);
bool rc = write_Text(buf, out, strlen_utf8(buf) PASS_REGS); }
bool rc = write_Text(buf, out PASS_REGS);
return rc; return rc;
} }
@ -985,10 +965,11 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
size_t b_l, u_l; size_t b_l, u_l;
inp->type |= YAP_STRING_IN_TMP; inp->type |= YAP_STRING_IN_TMP;
buf = Yap_readText(inp, &b_l PASS_REGS); buf = Yap_readText(inp PASS_REGS);
if (!buf) { if (!buf) {
return false; return false;
} }
b_l = strlen((char *)buf);
u_l = strlen_utf8(buf); u_l = strlen_utf8(buf);
if (!cuts) { if (!cuts) {
if (n == 2) { if (n == 2) {
@ -996,37 +977,40 @@ 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, &b_l0 PASS_REGS); buf0 = Yap_readText(outv PASS_REGS);
if (!buf0) { if (!buf0) {
return false; return false;
} }
b_l0 = strlen((const char *)buf0);
if (bcmp(buf, buf0, b_l0) != 0) { if (bcmp(buf, buf0, b_l0) != 0) {
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;
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, b_l1 PASS_REGS); bool rc = write_Text(buf1, outv + 1 PASS_REGS);
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, &b_l1 PASS_REGS); buf1 = Yap_readText(outv + 1 PASS_REGS);
if (!buf1) { if (!buf1) {
return false; return false;
} }
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 (bcmp(skip_utf8((const unsigned char *) buf, b_l0), buf1, b_l1) != if (bcmp(skip_utf8((const unsigned char *)buf, b_l0), buf1, b_l1) !=
0) { 0) {
return false; return false;
} }
buf0 = slice(0, u_l0, buf PASS_REGS); buf0 = slice(0, u_l0, buf PASS_REGS);
bool rc = write_Text(buf0, outv, b_l0 PASS_REGS); bool rc = write_Text(buf0, outv PASS_REGS);
return rc; return rc;
} }
} }
@ -1040,7 +1024,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
if (i > 0 && cuts[i] == 0) if (i > 0 && cuts[i] == 0)
break; break;
void *bufi = slice(next, cuts[i], buf PASS_REGS); void *bufi = slice(next, cuts[i], buf PASS_REGS);
if (!write_Text(bufi, outv + i, strlen(bufi) PASS_REGS)) { if (!write_Text(bufi, outv + i PASS_REGS)) {
return false; return false;
} }
} }
@ -1063,8 +1047,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
* @return the buffer, or NULL in case of failure. If so, Yap_Error may be * @return the buffer, or NULL in case of failure. If so, Yap_Error may be
called. called.
*/ */
const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) { const char *Yap_TextTermToText(Term t, char *buf, encoding_t enc USES_REGS) {
CACHE_REGS
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t; inp.val.t = t;
if (IsAtomTerm(t) && t != TermNil) { if (IsAtomTerm(t) && t != TermNil) {
@ -1127,11 +1110,10 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
if (ap->ModuleOfPred == IDB_MODULE) { if (ap->ModuleOfPred == IDB_MODULE) {
if (ap->PredFlags & NumberDBPredFlag) { if (ap->PredFlags & NumberDBPredFlag) {
Int key = ap->src.IndxId; Int key = ap->src.IndxId;
snprintf(s, smax - s, "%" snprintf(s, smax - s, "%" PRIdPTR, key);
PRIdPTR, key);
return LOCAL_FileNameBuf; return LOCAL_FileNameBuf;
} else if (ap->PredFlags & AtomDBPredFlag) { } else if (ap->PredFlags & AtomDBPredFlag) {
at = (Atom) (ap->FunctorOfPred); at = (Atom)(ap->FunctorOfPred);
if (!Yap_AtomToUTF8Text(at, s)) if (!Yap_AtomToUTF8Text(at, s))
return NULL; return NULL;
} else { } else {
@ -1144,15 +1126,14 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
if (arity) { if (arity) {
at = NameOfFunctor(ap->FunctorOfPred); at = NameOfFunctor(ap->FunctorOfPred);
} else { } else {
at = (Atom) (ap->FunctorOfPred); at = (Atom)(ap->FunctorOfPred);
} }
} }
if (!Yap_AtomToUTF8Text(at, s)) { if (!Yap_AtomToUTF8Text(at, s)) {
return NULL; return NULL;
} }
s += strlen(s); s += strlen(s);
snprintf(s, smax - s, "/%" snprintf(s, smax - s, "/%" PRIdPTR, arity);
PRIdPTR, arity);
return s0; return s0;
} }
@ -1165,8 +1146,7 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
* *
≈ * @return the term ≈ * @return the term
*/ */
Term Yap_MkTextTerm(const char *s, encoding_t enc, Term tguide) { Term Yap_MkTextTerm(const char *s, encoding_t enc, Term tguide USES_REGS) {
CACHE_REGS
if (IsAtomTerm(tguide)) if (IsAtomTerm(tguide))
return MkAtomTerm(Yap_LookupAtom(s)); return MkAtomTerm(Yap_LookupAtom(s));
if (IsStringTerm(tguide)) if (IsStringTerm(tguide))

2
C/tracer.c
View File

@ -87,7 +87,7 @@ static char *send_tracer_message(char *start, char *name, arity_t arity,
continue; continue;
} }
} }
const char *sn = Yap_TermToString(args[i], NULL, LOCAL_encoding, const char *sn = Yap_TermToString(args[i], LOCAL_encoding,
Quote_illegal_f | Handle_vars_f); Quote_illegal_f | Handle_vars_f);
size_t sz; size_t sz;
if (sn == NULL) { if (sn == NULL) {

4
C/utilpreds.c
View File

@ -4585,6 +4585,9 @@ renumbervar(Term t, Int id USES_REGS)
ts[1] = MkIntegerTerm(id); ts[1] = MkIntegerTerm(id);
} }
extern int vsc;
int vsc;
static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Int numbv, int singles USES_REGS) static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Int numbv, int singles USES_REGS)
{ {
@ -4604,6 +4607,7 @@ static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end
deref_head(d0, vars_in_term_unk); deref_head(d0, vars_in_term_unk);
vars_in_term_nvar: vars_in_term_nvar:
{ {
vsc++;
if (IsPairTerm(d0)) { if (IsPairTerm(d0)) {
if (to_visit + 1024 >= (CELL **)AuxSp) { if (to_visit + 1024 >= (CELL **)AuxSp) {
goto aux_overflow; goto aux_overflow;

114
C/write.c
View File

@ -390,7 +390,7 @@ int Yap_FormatFloat(Float f, char **s, size_t sz) {
wglb.stream = GLOBAL_Stream + sno; wglb.stream = GLOBAL_Stream + sno;
wrputf(f, &wglb); wrputf(f, &wglb);
so = Yap_MemExportStreamPtr(sno); so = Yap_MemExportStreamPtr(sno);
*s = Malloc( strlen(so) )+1; *s = Malloc( strlen(so)+1 );
strcpy(*s, so ); strcpy(*s, so );
Yap_CloseStream(sno); Yap_CloseStream(sno);
return true; return true;
@ -410,10 +410,10 @@ static void wrputref(CODEADDR ref, int Quote_illegal,
#endif #endif
wrputs(s, stream); wrputs(s, stream);
lastw = alphanum; lastw = alphanum;
} }
/* writes a blob (default) */ /* writes a blob (default) */
static int wrputblob(AtomEntry *ref, int Quote_illegal, static int wrputblob(AtomEntry *ref, int Quote_illegal,
struct write_globs *wglb) { struct write_globs *wglb) {
wrf stream = wglb->stream; wrf stream = wglb->stream;
int rc; int rc;
@ -424,10 +424,10 @@ static int wrputblob(AtomEntry *ref, int Quote_illegal,
} }
lastw = alphanum; lastw = alphanum;
return 1; return 1;
} }
static int legalAtom(unsigned char *s) /* Is this a legal atom ? */ static int legalAtom(unsigned char *s) /* Is this a legal atom ? */
{ {
wchar_t ch = *s; wchar_t ch = *s;
if (ch == '\0') if (ch == '\0')
@ -461,11 +461,11 @@ static int legalAtom(unsigned char *s) /* Is this a legal atom ? */
if (Yap_chtype[ch] > NU) if (Yap_chtype[ch] > NU)
return false; return false;
return true; return true;
} }
static wtype static wtype
AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */ AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
{ {
int ch; int ch;
if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0') if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0')
return (separator); return (separator);
@ -474,9 +474,9 @@ AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
return alphanum; return alphanum;
} }
return symbol; return symbol;
} }
static void write_quoted(wchar_t ch, wchar_t quote, wrf stream) { static void write_quoted(wchar_t ch, wchar_t quote, wrf stream) {
CACHE_REGS CACHE_REGS
if (!(Yap_GetModuleEntry(CurrentModule)->flags & M_CHARESCAPE)) { if (!(Yap_GetModuleEntry(CurrentModule)->flags & M_CHARESCAPE)) {
wrputc(ch, stream); wrputc(ch, stream);
@ -550,11 +550,11 @@ static void write_quoted(wchar_t ch, wchar_t quote, wrf stream) {
} }
} }
} }
} }
static void write_string(const unsigned char *s, static void write_string(const unsigned char *s,
struct write_globs *wglb) /* writes an integer */ struct write_globs *wglb) /* writes an integer */
{ {
StreamDesc *stream = wglb->stream; StreamDesc *stream = wglb->stream;
utf8proc_int32_t chr, qt; utf8proc_int32_t chr, qt;
unsigned char *ptr = (unsigned char *)s; unsigned char *ptr = (unsigned char *)s;
@ -575,10 +575,10 @@ static void write_string(const unsigned char *s,
write_quoted(chr, qt, stream); write_quoted(chr, qt, stream);
} while (true); } while (true);
wrputc(qt, stream); wrputc(qt, stream);
} }
/* writes an atom */ /* writes an atom */
static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) { static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
unsigned char *s; unsigned char *s;
wtype atom_or_symbol; wtype atom_or_symbol;
wrf stream = wglb->stream; wrf stream = wglb->stream;
@ -615,17 +615,17 @@ static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
} else { } else {
wrputs((char *)s, stream); wrputs((char *)s, stream);
} }
} }
void Yap_WriteAtom(StreamDesc *s, Atom atom) { void Yap_WriteAtom(StreamDesc *s, Atom atom) {
struct write_globs wglb; struct write_globs wglb;
wglb.stream = s; wglb.stream = s;
wglb.Quote_illegal = FALSE; wglb.Quote_illegal = FALSE;
putAtom(atom, 0, &wglb); putAtom(atom, 0, &wglb);
} }
static int IsCodesTerm(Term string) /* checks whether this is a string */ static int IsCodesTerm(Term string) /* checks whether this is a string */
{ {
if (IsVarTerm(string)) if (IsVarTerm(string))
return FALSE; return FALSE;
do { do {
@ -647,12 +647,12 @@ static int IsCodesTerm(Term string) /* checks whether this is a string */
return (FALSE); return (FALSE);
} while (string != TermNil); } while (string != TermNil);
return (TRUE); return (TRUE);
} }
/* writes a string */ /* writes a string */
static void putString(Term string, struct write_globs *wglb) static void putString(Term string, struct write_globs *wglb)
{ {
wrf stream = wglb->stream; wrf stream = wglb->stream;
wrputc('"', stream); wrputc('"', stream);
while (string != TermNil) { while (string != TermNil) {
@ -662,12 +662,12 @@ static void putString(Term string, struct write_globs *wglb)
} }
wrputc('"', stream); wrputc('"', stream);
lastw = alphanum; lastw = alphanum;
} }
/* writes a string */ /* writes a string */
static void putUnquotedString(Term string, struct write_globs *wglb) static void putUnquotedString(Term string, struct write_globs *wglb)
{ {
wrf stream = wglb->stream; wrf stream = wglb->stream;
while (string != TermNil) { while (string != TermNil) {
int ch = IntOfTerm(HeadOfTerm(string)); int ch = IntOfTerm(HeadOfTerm(string));
@ -675,9 +675,9 @@ static void putUnquotedString(Term string, struct write_globs *wglb)
string = TailOfTerm(string); string = TailOfTerm(string);
} }
lastw = alphanum; lastw = alphanum;
} }
static Term from_pointer(CELL *ptr0, struct rewind_term *rwt, static Term from_pointer(CELL *ptr0, struct rewind_term *rwt,
struct write_globs *wglb) { struct write_globs *wglb) {
CACHE_REGS CACHE_REGS
Term t; Term t;
@ -713,9 +713,9 @@ static Term from_pointer(CELL *ptr0, struct rewind_term *rwt,
} }
} }
return t; return t;
} }
static CELL *restore_from_write(struct rewind_term *rwt, static CELL *restore_from_write(struct rewind_term *rwt,
struct write_globs *wglb) { struct write_globs *wglb) {
CACHE_REGS CACHE_REGS
CELL *ptr; CELL *ptr;
@ -729,10 +729,10 @@ static CELL *restore_from_write(struct rewind_term *rwt,
} }
rwt->u_sd.s.ptr = 0; rwt->u_sd.s.ptr = 0;
return ptr; return ptr;
} }
/* writes an unbound variable */ /* writes an unbound variable */
static void write_var(CELL *t, struct write_globs *wglb, static void write_var(CELL *t, struct write_globs *wglb,
struct rewind_term *rwt) { struct rewind_term *rwt) {
CACHE_REGS CACHE_REGS
if (lastw == alphanum) { if (lastw == alphanum) {
@ -773,9 +773,9 @@ static void write_var(CELL *t, struct write_globs *wglb,
} else { } else {
wrputn(((Int)(t - H0)), wglb); wrputn(((Int)(t - H0)), wglb);
} }
} }
static Term check_infinite_loop(Term t, struct rewind_term *x, static Term check_infinite_loop(Term t, struct rewind_term *x,
struct write_globs *wglb) { struct write_globs *wglb) {
CACHE_REGS CACHE_REGS
if (wglb->Keep_terms) { if (wglb->Keep_terms) {
@ -792,9 +792,9 @@ static Term check_infinite_loop(Term t, struct rewind_term *x,
} }
} }
return t; return t;
} }
static void write_list(Term t, int direction, int depth, static void write_list(Term t, int direction, int depth,
struct write_globs *wglb, struct rewind_term *rwt) { struct write_globs *wglb, struct rewind_term *rwt) {
Term ti; Term ti;
struct rewind_term nrwt; struct rewind_term nrwt;
@ -867,14 +867,14 @@ static void write_list(Term t, int direction, int depth,
wglb, &nrwt); wglb, &nrwt);
restore_from_write(&nrwt, wglb); restore_from_write(&nrwt, wglb);
} }
} }
static void writeTerm(Term t, int p, int depth, int rinfixarg, static void writeTerm(Term t, int p, int depth, int rinfixarg,
struct write_globs *wglb, struct rewind_term *rwt) struct write_globs *wglb, struct rewind_term *rwt)
/* term to write */ /* term to write */
/* context priority */ /* context priority */
{ {
CACHE_REGS CACHE_REGS
struct rewind_term nrwt; struct rewind_term nrwt;
nrwt.parent = rwt; nrwt.parent = rwt;
@ -1203,14 +1203,14 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
wrclose_bracket(wglb, TRUE); wrclose_bracket(wglb, TRUE);
} }
} }
} }
void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags, void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags,
int priority) int priority)
/* term to be written */ /* term to be written */
/* consumer */ /* consumer */
/* write options */ /* write options */
{ {
CACHE_REGS CACHE_REGS
struct write_globs wglb; struct write_globs wglb;
struct rewind_term rwt; struct rewind_term rwt;
@ -1253,9 +1253,9 @@ void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags,
} }
restore_from_write(&rwt, &wglb); restore_from_write(&rwt, &wglb);
Yap_CloseSlots(sls); Yap_CloseSlots(sls);
} }
char *Yap_TermToString(Term t, size_t *lengthp, encoding_t enc, int flags) { char *Yap_TermToString(Term t, encoding_t enc, int flags) {
CACHE_REGS CACHE_REGS
int sno = Yap_open_buf_write_stream(enc, flags); int sno = Yap_open_buf_write_stream(enc, flags);
const char *sf; const char *sf;
@ -1278,4 +1278,4 @@ char *Yap_TermToString(Term t, size_t *lengthp, encoding_t enc, int flags) {
if (e) if (e)
LOCAL_BallTerm = e; LOCAL_BallTerm = e;
return new; return new;
} }

12
CXX/yapi.cpp
View File

@ -12,18 +12,18 @@ extern "C" {
#include "YapInterface.h" #include "YapInterface.h"
#include "blobs.h" #include "blobs.h"
X_API char *Yap_TermToString(Term t, size_t *length, encoding_t encodingp, X_API char *Yap_TermToString(Term t, encoding_t encodingp,
int flags); int flags);
X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity); X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity);
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t, X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t,
YAP_Term); YAP_Term);
X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
arity_t, arity_t); arity_t, arity_t);
#if YAP_PYTHON #if YAP_PYTHON
X_API bool do_init_python(void); X_API bool do_init_python(void);
#endif #endif
} }

5
CXX/yapt.hh
View File

@ -226,18 +226,17 @@ public:
/// return a string with a textual representation of the term /// return a string with a textual representation of the term
virtual const char *text() { virtual const char *text() {
CACHE_REGS CACHE_REGS
size_t length = 0;
encoding_t enc = LOCAL_encoding; encoding_t enc = LOCAL_encoding;
char *os; char *os;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc, if (!(os = Yap_TermToString(Yap_GetFromSlot(t), enc,
Handle_vars_f))) { Handle_vars_f))) {
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return 0; return 0;
} }
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
length = strlen(os) + 1; size_t length = strlen(os);
char *sm = (char *)malloc(length + 1); char *sm = (char *)malloc(length + 1);
strcpy(sm, os); strcpy(sm, os);
return sm; return sm;

381
H/YapText.h
View File

@ -1,19 +1,19 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog * * YAP Prolog *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: YapMirror.c * * File: YapMirror.c *
* Last rev: 5/2/88 * * Last rev: 5/2/88 *
* mods: * * mods: *
* comments: Term conversion C implemented support * * comments: Term conversion C implemented support *
* * * *
*************************************************************************/ *************************************************************************/
#ifndef YAP_TEXT_H #ifndef YAP_TEXT_H
#define YAP_TEXT_H #define YAP_TEXT_H
@ -47,7 +47,6 @@
cut_succeed(); \ cut_succeed(); \
} }
/// allocate a temporary text block /// allocate a temporary text block
/// ///
extern void *Malloc(size_t sz USES_REGS); extern void *Malloc(size_t sz USES_REGS);
@ -56,8 +55,7 @@ extern void Free(void *buf USES_REGS);
extern int push_text_stack(USES_REGS1); extern int push_text_stack(USES_REGS1);
extern int pop_text_stack(int lvl USES_REGS); extern int pop_text_stack(int lvl USES_REGS);
extern void *protected_pop_text_stack(int lvl, void *safe, bool tmp, extern void *export_block(int lvl, void *exp USES_REGS);
size_t sz USES_REGS);
#ifndef Yap_Min #ifndef Yap_Min
#define Yap_Min(x, y) (x < y ? x : y) #define Yap_Min(x, y) (x < y ? x : y)
@ -187,8 +185,10 @@ INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr,
utf8proc_int32_t *valp) { utf8proc_int32_t *valp) {
utf8proc_ssize_t rc = utf8proc_iterate(ptr, n, valp); utf8proc_ssize_t rc = utf8proc_iterate(ptr, n, valp);
if (rc < 0) { if (rc < 0) {
if (rc == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("get_utf8 found bad UTF-8 char %s, skipping...", ptr); if (rc == UTF8PROC_ERROR_INVALIDUTF8)
else Yap_Warning("UTF-8 error %d, skipping...", *ptr); Yap_Warning("get_utf8 found bad UTF-8 char %s, skipping...", ptr);
else
Yap_Warning("UTF-8 error %d, skipping...", *ptr);
rc = 1; rc = 1;
} }
return rc; return rc;
@ -200,7 +200,8 @@ INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr,
INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr, INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr,
utf8proc_int32_t val) { utf8proc_int32_t val) {
utf8proc_ssize_t rc = utf8proc_encode_char(val, ptr); utf8proc_ssize_t rc = utf8proc_encode_char(val, ptr);
if (rc == 0) Yap_Warning("UTF-8 error at %s", ptr); if (rc == 0)
Yap_Warning("UTF-8 error at %s", ptr);
return rc; return rc;
} }
@ -213,8 +214,11 @@ inline static const utf8proc_uint8_t *skip_utf8(const utf8proc_uint8_t *pt,
if (b == 0) if (b == 0)
return pt; return pt;
if (l < 0) { if (l < 0) {
if (l == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("skip_utf8: found bad UTF-8 in char %s[%d], skipping...", pt, i); if (l == UTF8PROC_ERROR_INVALIDUTF8)
else Yap_Warning("UTF-8 error %d at %s[%d], skipping...", l,pt,i); Yap_Warning("skip_utf8: found bad UTF-8 in char %s[%d], skipping...",
pt, i);
else
Yap_Warning("UTF-8 error %d at %s[%d], skipping...", l, pt, i);
l = 1; l = 1;
} }
pt += l; pt += l;
@ -237,8 +241,10 @@ inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) {
pt += l; pt += l;
rc++; rc++;
} else { } else {
if (l == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("found bad UTF-8 char %d, skipping %s...", *pt, pt); if (l == UTF8PROC_ERROR_INVALIDUTF8)
else Yap_Warning("UTF-8 error %d, skipping...", l); Yap_Warning("found bad UTF-8 char %d, skipping %s...", *pt, pt);
else
Yap_Warning("UTF-8 error %d, skipping...", l);
pt++; pt++;
} }
} }
@ -451,9 +457,8 @@ static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
// the routines // the routines
extern unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp USES_REGS); extern unsigned char *Yap_readText(seq_tv_t *inp USES_REGS);
extern bool write_Text(unsigned char *inp, seq_tv_t *out, extern bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS);
size_t leng USES_REGS);
extern bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS); extern bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS);
extern bool Yap_Concat_Text(int n, seq_tv_t inp[], seq_tv_t *out USES_REGS); extern bool Yap_Concat_Text(int n, seq_tv_t inp[], seq_tv_t *out USES_REGS);
extern bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, extern bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
@ -563,7 +568,7 @@ static inline size_t Yap_AtomicToUnicodeLength(Term t0 USES_REGS) {
inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
YAP_STRING_BIG | YAP_STRING_TERM; YAP_STRING_BIG | YAP_STRING_TERM;
out.type = YAP_STRING_CHARS|YAP_STRING_OUTPUT_TERM; out.type = YAP_STRING_CHARS | YAP_STRING_OUTPUT_TERM;
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return strlen_utf8(out.val.uc0); return strlen_utf8(out.val.uc0);
@ -611,14 +616,14 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
return strlen(RepAtom(AtomOfTerm(t0))->StrOfAE); return strlen(RepAtom(AtomOfTerm(t0))->StrOfAE);
} }
static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) { static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) {
if (!IsAtomTerm(t0)) { if (!IsAtomTerm(t0)) {
return -TYPE_ERROR_ATOM; return -TYPE_ERROR_ATOM;
} }
return strlen_utf8(RepAtom(AtomOfTerm(t0))->UStrOfAE); return strlen_utf8(RepAtom(AtomOfTerm(t0))->UStrOfAE);
} }
static inline Term Yap_AtomToListOfAtoms(Term t0 USES_REGS) { static inline Term Yap_AtomToListOfAtoms(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
@ -627,9 +632,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) { static inline Term Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -642,9 +647,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) { static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
@ -653,9 +658,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomToNumber(Term t0 USES_REGS) { static inline Term Yap_AtomToNumber(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
@ -665,9 +670,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomToString(Term t0 USES_REGS) { static inline Term Yap_AtomToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -678,9 +683,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomSWIToString(Term t0 USES_REGS) { static inline Term Yap_AtomSWIToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -693,9 +698,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomicToString(Term t0 USES_REGS) { static inline Term Yap_AtomicToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -707,9 +712,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) { static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -722,9 +727,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline wchar_t *Yap_AtomToWide(Atom at USES_REGS) { static inline wchar_t *Yap_AtomToWide(Atom at USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.a = at; inp.val.a = at;
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
@ -733,9 +738,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return NIL; return NIL;
return out.val.w; return out.val.w;
} }
static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) { static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -747,9 +752,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_CharsToAtom(const char *s, encoding_t enc USES_REGS) { static inline Atom Yap_CharsToAtom(const char *s, encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.c0 = s; inp.val.c0 = s;
@ -761,9 +766,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_CharsToListOfAtoms(const char *s, static inline Term Yap_CharsToListOfAtoms(const char *s,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -775,9 +780,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_CharsToListOfCodes(const char *s, static inline Term Yap_CharsToListOfCodes(const char *s,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -789,9 +794,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) { static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.c0 = s; inp.val.c0 = s;
@ -801,9 +806,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) { static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.uc0 = s; inp.val.uc0 = s;
@ -813,9 +818,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail, static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -828,9 +833,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_UTF8ToDiffListOfCodes(const char *s, static inline Term Yap_UTF8ToDiffListOfCodes(const char *s,
Term tail USES_REGS) { Term tail USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -843,9 +848,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s, static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s,
Term tail USES_REGS) { Term tail USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -858,9 +863,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_CharsToString(const char *s, encoding_t enc USES_REGS) { static inline Term Yap_CharsToString(const char *s, encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.c0 = s; inp.val.c0 = s;
@ -871,9 +876,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline char *Yap_AtomToUTF8Text(Atom at, const char *s USES_REGS) { static inline char *Yap_AtomToUTF8Text(Atom at, const char *s USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.a = at; inp.val.a = at;
@ -891,9 +896,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.c; return out.val.c;
} }
static inline Term Yap_CharsToTDQ(const char *s, Term mod, static inline Term Yap_CharsToTDQ(const char *s, Term mod,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -906,9 +911,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_CharsToTBQ(const char *s, Term mod, static inline Term Yap_CharsToTBQ(const char *s, Term mod,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -921,9 +926,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_ListOfAtomsToAtom(Term t0 USES_REGS) { static inline Atom Yap_ListOfAtomsToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOMS; inp.type = YAP_STRING_ATOMS;
@ -934,9 +939,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return out.val.a; return out.val.a;
} }
static inline Term Yap_ListOfAtomsToNumber(Term t0 USES_REGS) { static inline Term Yap_ListOfAtomsToNumber(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOMS; inp.type = YAP_STRING_ATOMS;
@ -947,9 +952,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_ListOfAtomsToString(Term t0 USES_REGS) { static inline Term Yap_ListOfAtomsToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOMS; inp.type = YAP_STRING_ATOMS;
@ -959,9 +964,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_ListOfCodesToAtom(Term t0 USES_REGS) { static inline Atom Yap_ListOfCodesToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_CODES; inp.type = YAP_STRING_CODES;
@ -971,9 +976,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return out.val.a; return out.val.a;
} }
static inline Term Yap_ListOfCodesToNumber(Term t0 USES_REGS) { static inline Term Yap_ListOfCodesToNumber(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_CODES; inp.type = YAP_STRING_CODES;
@ -983,9 +988,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_ListOfCodesToString(Term t0 USES_REGS) { static inline Term Yap_ListOfCodesToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_CODES; inp.type = YAP_STRING_CODES;
@ -995,9 +1000,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_ListToAtom(Term t0 USES_REGS) { static inline Atom Yap_ListToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_ATOMS_CODES; inp.type = YAP_STRING_ATOMS_CODES;
@ -1007,9 +1012,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_ListToAtomic(Term t0 USES_REGS) { static inline Term Yap_ListToAtomic(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM;
@ -1020,9 +1025,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_ListToNumber(Term t0 USES_REGS) { static inline Term Yap_ListToNumber(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1034,9 +1039,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_ListToString(Term t0 USES_REGS) { static inline Term Yap_ListToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1048,9 +1053,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_ListSWIToString(Term t0 USES_REGS) { static inline Term Yap_ListSWIToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1064,9 +1069,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term YapListToTDQ(Term t0, Term mod USES_REGS) { static inline Term YapListToTDQ(Term t0, Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1078,9 +1083,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term YapListToTBQ(Term t0, Term mod USES_REGS) { static inline Term YapListToTBQ(Term t0, Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1092,9 +1097,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_NCharsToAtom(const char *s, size_t len, static inline Atom Yap_NCharsToAtom(const char *s, size_t len,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1108,9 +1113,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_CharsToDiffListOfAtoms(const char *s, encoding_t enc, static inline Term Yap_CharsToDiffListOfAtoms(const char *s, encoding_t enc,
Term tail USES_REGS) { Term tail USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1122,9 +1127,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NCharsToListOfCodes(const char *s, size_t len, static inline Term Yap_NCharsToListOfCodes(const char *s, size_t len,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1136,9 +1141,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NCharsToString(const char *s, size_t len, static inline Term Yap_NCharsToString(const char *s, size_t len,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1150,9 +1155,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NCharsToTDQ(const char *s, size_t len, encoding_t enc, static inline Term Yap_NCharsToTDQ(const char *s, size_t len, encoding_t enc,
Term mod USES_REGS) { Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1165,9 +1170,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc, static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc,
Term mod USES_REGS) { Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1180,9 +1185,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_NumberToAtom(Term t0 USES_REGS) { static inline Atom Yap_NumberToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = inp.type =
@ -1191,9 +1196,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_NumberToListOfAtoms(Term t0 USES_REGS) { static inline Term Yap_NumberToListOfAtoms(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = inp.type =
@ -1202,9 +1207,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NumberToListOfCodes(Term t0 USES_REGS) { static inline Term Yap_NumberToListOfCodes(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = inp.type =
@ -1213,9 +1218,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NumberToString(Term t0 USES_REGS) { static inline Term Yap_NumberToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = inp.type =
@ -1224,9 +1229,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_NWCharsToAtom(const wchar_t *s, size_t len USES_REGS) { static inline Atom Yap_NWCharsToAtom(const wchar_t *s, size_t len USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w0 = s; inp.val.w0 = s;
@ -1236,9 +1241,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_NWCharsToListOfAtoms(const wchar_t *s, static inline Term Yap_NWCharsToListOfAtoms(const wchar_t *s,
size_t len USES_REGS) { size_t len USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1249,9 +1254,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NWCharsToListOfCodes(const wchar_t *s, static inline Term Yap_NWCharsToListOfCodes(const wchar_t *s,
size_t len USES_REGS) { size_t len USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1263,9 +1268,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_NWCharsToString(const wchar_t *s, size_t len USES_REGS) { static inline Term Yap_NWCharsToString(const wchar_t *s, size_t len USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w0 = s; inp.val.w0 = s;
@ -1276,9 +1281,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_StringToAtom(Term t0 USES_REGS) { static inline Atom Yap_StringToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
@ -1287,9 +1292,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Atom Yap_StringSWIToAtom(Term t0 USES_REGS) { static inline Atom Yap_StringSWIToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
@ -1300,9 +1305,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline size_t Yap_StringToAtomic(Term t0 USES_REGS) { static inline size_t Yap_StringToAtomic(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
@ -1312,16 +1317,16 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline size_t Yap_StringToUnicodeLength(Term t0 USES_REGS) { static inline size_t Yap_StringToUnicodeLength(Term t0 USES_REGS) {
if (!IsStringTerm(t0)) { if (!IsStringTerm(t0)) {
return -TYPE_ERROR_STRING; return -TYPE_ERROR_STRING;
} }
return strlen_utf8(UStringOfTerm(t0)); return strlen_utf8(UStringOfTerm(t0));
} }
static inline size_t Yap_StringToListOfAtoms(Term t0 USES_REGS) { static inline size_t Yap_StringToListOfAtoms(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
@ -1330,9 +1335,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline size_t Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) { static inline size_t Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
@ -1343,9 +1348,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline size_t Yap_StringToListOfCodes(Term t0 USES_REGS) { static inline size_t Yap_StringToListOfCodes(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
@ -1354,9 +1359,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline size_t Yap_StringSWIToListOfCodes(Term t0 USES_REGS) { static inline size_t Yap_StringSWIToListOfCodes(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
@ -1367,21 +1372,22 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_StringToNumber(Term t0 USES_REGS) { static inline Term Yap_StringToNumber(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
out.type = out.type =
YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
out.val.uc = NULL; out.val.uc = NULL;
out.enc = ENC_ISO_UTF8;
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_TextToAtom(Term t0 USES_REGS) { static inline Atom Yap_TextToAtom(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1393,9 +1399,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_TextToString(Term t0 USES_REGS) { static inline Term Yap_TextToString(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1407,9 +1413,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline void Yap_OverwriteUTF8BufferToLowCase(void *buf USES_REGS) { static inline void Yap_OverwriteUTF8BufferToLowCase(void *buf USES_REGS) {
unsigned char *s = (unsigned char *)buf; unsigned char *s = (unsigned char *)buf;
while (*s) { while (*s) {
// assumes the two code have always the same size; // assumes the two code have always the same size;
@ -1418,9 +1424,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
chr = utf8proc_tolower(chr); chr = utf8proc_tolower(chr);
s += put_utf8(s, chr); s += put_utf8(s, chr);
} }
} }
static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) { static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
@ -1433,13 +1439,13 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.uc0; return out.val.uc0;
} }
static inline Term Yap_UTF8ToString(const char *s USES_REGS) { static inline Term Yap_UTF8ToString(const char *s USES_REGS) {
return MkStringTerm(s); return MkStringTerm(s);
} }
static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) { static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w0 = s; inp.val.w0 = s;
@ -1449,9 +1455,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.a; return out.val.a;
} }
static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) { static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w0 = s; inp.val.w0 = s;
inp.type = YAP_STRING_WCHARS; inp.type = YAP_STRING_WCHARS;
@ -1460,9 +1466,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_WCharsToTDQ(wchar_t *s, Term mod USES_REGS) { static inline Term Yap_WCharsToTDQ(wchar_t *s, Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w0 = s; inp.val.w0 = s;
@ -1474,9 +1480,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_WCharsToTBQ(wchar_t *s, Term mod USES_REGS) { static inline Term Yap_WCharsToTBQ(wchar_t *s, Term mod USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w = s; inp.val.w = s;
@ -1487,9 +1493,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Term Yap_WCharsToString(const wchar_t *s USES_REGS) { static inline Term Yap_WCharsToString(const wchar_t *s USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w0 = s; inp.val.w0 = s;
inp.type = YAP_STRING_WCHARS; inp.type = YAP_STRING_WCHARS;
@ -1498,9 +1504,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) { static inline Atom Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) {
seq_tv_t inpv[2], out; seq_tv_t inpv[2], out;
inpv[0].val.t = t1; inpv[0].val.t = t1;
inpv[0].type = YAP_STRING_ATOM; inpv[0].type = YAP_STRING_ATOM;
@ -1511,9 +1517,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) if (!Yap_Concat_Text(2, inpv, &out PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return out.val.a; return out.val.a;
} }
static inline Atom Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) { static inline Atom Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) {
seq_tv_t inpv[2], out; seq_tv_t inpv[2], out;
inpv[0].val.t = t1; inpv[0].val.t = t1;
inpv[0].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | inpv[0].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
@ -1526,9 +1532,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) if (!Yap_Concat_Text(2, inpv, &out PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return out.val.a; return out.val.a;
} }
static inline Term Yap_ConcatStrings(Term t1, Term t2 USES_REGS) { static inline Term Yap_ConcatStrings(Term t1, Term t2 USES_REGS) {
seq_tv_t inpv[2], out; seq_tv_t inpv[2], out;
inpv[0].val.t = t1; inpv[0].val.t = t1;
inpv[0].type = YAP_STRING_STRING; inpv[0].type = YAP_STRING_STRING;
@ -1539,9 +1545,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) if (!Yap_Concat_Text(2, inpv, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
} }
static inline Atom Yap_SpliceAtom(Term t1, Atom ats[], size_t cut, static inline Atom Yap_SpliceAtom(Term t1, Atom ats[], size_t cut,
size_t max USES_REGS) { size_t max USES_REGS) {
seq_tv_t outv[2], inp; seq_tv_t outv[2], inp;
size_t cuts[2]; size_t cuts[2];
@ -1556,9 +1562,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
ats[0] = outv[0].val.a; ats[0] = outv[0].val.a;
ats[1] = outv[1].val.a; ats[1] = outv[1].val.a;
return ats[0]; return ats[0];
} }
static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) { static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) {
seq_tv_t outv[2], inp; seq_tv_t outv[2], inp;
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
inp.val.t = t1; inp.val.t = t1;
@ -1569,9 +1575,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return outv[1].val.a; return outv[1].val.a;
} }
static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) { static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) {
seq_tv_t outv[2], inp; seq_tv_t outv[2], inp;
inp.type = YAP_STRING_ATOM; inp.type = YAP_STRING_ATOM;
inp.val.t = t1; inp.val.t = t1;
@ -1582,9 +1588,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return outv[0].val.a; return outv[0].val.a;
} }
static inline Term Yap_SpliceString(Term t1, Term ts[], size_t cut, static inline Term Yap_SpliceString(Term t1, Term ts[], size_t cut,
size_t max USES_REGS) { size_t max USES_REGS) {
seq_tv_t outv[2], inp; seq_tv_t outv[2], inp;
size_t cuts[2]; size_t cuts[2];
@ -1599,9 +1605,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
ts[0] = outv[0].val.t; ts[0] = outv[0].val.t;
ts[1] = outv[1].val.t; ts[1] = outv[1].val.t;
return ts[0]; return ts[0];
} }
static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) { static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) {
seq_tv_t outv[2], inp; seq_tv_t outv[2], inp;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
inp.val.t = t1; inp.val.t = t1;
@ -1612,9 +1618,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
return 0L; return 0L;
return outv[1].val.t; return outv[1].val.t;
} }
static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) { static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) {
seq_tv_t outv[2], inp; seq_tv_t outv[2], inp;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
inp.val.t = t1; inp.val.t = t1;
@ -1625,9 +1631,10 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
return 0L; return 0L;
return outv[0].val.t; return outv[0].val.t;
} }
#endif // ≈YAP_TEXT_H #endif // ≈YAP_TEXT_H
const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc); const char *Yap_TextTermToText(Term t, char *bufwrite_Text,
Term Yap_MkTextTerm(const char *s, encoding_t e, Term tguide); encoding_t e USES_REGS);
Term Yap_MkTextTerm(const char *s, encoding_t e, Term tguide);

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

@ -11,13 +11,13 @@ Moyle. All rights reserved.
*/ */
/** /**
* *
* @file swi.c * @file swi.c
* *
* @addtogroup swi-c-interface * @addtogroup swi-c-interface
* *
* @{ * @{
*/ */
#define PL_KERNEL 1 #define PL_KERNEL 1
#define _EXPORT_KERNEL 1 #define _EXPORT_KERNEL 1
@ -119,8 +119,8 @@ static void UserCPredicate(char *a, CPredicate def, unsigned long int arity,
//! @{ //! @{
/** @defgroup swi-ATOMS Atom Construction /** @defgroup swi-ATOMS Atom Construction
* @ingroup swi-c-interface * @ingroup swi-c-interface
* */ * */
static UInt cvtFlags(unsigned flags) { static UInt cvtFlags(unsigned flags) {
UInt inptype = 0; UInt inptype = 0;
@ -156,8 +156,8 @@ static UInt cvtFlags(unsigned flags) {
/* void PL_agc_hook(void) */ /* void PL_agc_hook(void) */
/** @brief Atom garbage collection hook /** @brief Atom garbage collection hook
* *
*/ */
X_API PL_agc_hook_t PL_agc_hook(PL_agc_hook_t entry) { X_API PL_agc_hook_t PL_agc_hook(PL_agc_hook_t entry) {
return (PL_agc_hook_t)YAP_AGCRegisterHook((YAP_agc_hook)entry); return (PL_agc_hook_t)YAP_AGCRegisterHook((YAP_agc_hook)entry);
} }
@ -227,9 +227,7 @@ X_API int PL_get_nchars(term_t l, size_t *lengthp, char **s, unsigned flags) {
pop_text_stack(lvl); pop_text_stack(lvl);
return false; return false;
} }
out.val.c = protected_pop_text_stack(lvl, out.val.c, out.val.c = export_block(-1, out.val.c PASS_REGS);
flags & (BUF_RING | BUF_DISCARDABLE),
strlen(out.val.c) + 1 PASS_REGS);
*s = out.val.c; *s = out.val.c;
return true; return true;
} }
@ -288,8 +286,8 @@ X_API int PL_unify_chars(term_t l, int flags, size_t length, const char *s) {
} }
/** @brief extract the text representation from atom /** @brief extract the text representation from atom
* *
*/ */
X_API char *PL_atom_chars(atom_t a) /* SAM check type */ X_API char *PL_atom_chars(atom_t a) /* SAM check type */
{ {
Atom at = SWIAtomToAtom(a); Atom at = SWIAtomToAtom(a);
@ -297,8 +295,8 @@ X_API char *PL_atom_chars(atom_t a) /* SAM check type */
} }
/** @brief extract the text representation from atom, including its length /** @brief extract the text representation from atom, including its length
* *
*/ */
X_API char *PL_atom_nchars(atom_t a, size_t *len) /* SAM check type */ X_API char *PL_atom_nchars(atom_t a, size_t *len) /* SAM check type */
{ {
char *s = RepAtom(SWIAtomToAtom(a))->StrOfAE; char *s = RepAtom(SWIAtomToAtom(a))->StrOfAE;
@ -309,14 +307,14 @@ X_API char *PL_atom_nchars(atom_t a, size_t *len) /* SAM check type */
//! @} //! @}
/** @{ /** @{
* *
* @defgroup swi-term_references Term References * @defgroup swi-term_references Term References
* @ingroup swi-c-interface * @ingroup swi-c-interface
* */ * */
/** @brief create a clean term reference /** @brief create a clean term reference
* *
*/ */
X_API term_t PL_new_term_ref(void) { X_API term_t PL_new_term_ref(void) {
CACHE_REGS CACHE_REGS
term_t to = Yap_NewSlots(1); term_t to = Yap_NewSlots(1);
@ -324,17 +322,17 @@ X_API term_t PL_new_term_ref(void) {
} }
/** @brief duplicate a term reference /** @brief duplicate a term reference
* *
*/ */
X_API term_t PL_copy_term_ref(term_t from) { X_API term_t PL_copy_term_ref(term_t from) {
CACHE_REGS CACHE_REGS
return Yap_InitSlot(Yap_GetFromSlot(from)); return Yap_InitSlot(Yap_GetFromSlot(from));
} }
/** @brief create several new term references /** @brief create several new term references
* *
* @par n is the number of references * @par n is the number of references
*/ */
X_API term_t PL_new_term_refs(int n) { X_API term_t PL_new_term_refs(int n) {
CACHE_REGS CACHE_REGS
term_t to = Yap_NewSlots(n); term_t to = Yap_NewSlots(n);
@ -342,31 +340,31 @@ X_API term_t PL_new_term_refs(int n) {
} }
/** @brief dispose of all term references created since after /** @brief dispose of all term references created since after
* *
*/ */
X_API void PL_reset_term_refs(term_t after) { X_API void PL_reset_term_refs(term_t after) {
CACHE_REGS CACHE_REGS
LOCAL_CurSlot = after; LOCAL_CurSlot = after;
} }
/** @} /** @}
*/ */
//! @{ //! @{
/** @defgroup swi-term_manipulation Term Manipulation /** @defgroup swi-term_manipulation Term Manipulation
* @ingroup swi-c-interface * @ingroup swi-c-interface
* */ * */
/** /**
* @defgroup swi-get-operations Reading Terms * @defgroup swi-get-operations Reading Terms
* @ingroup swi-term_manipulation * @ingroup swi-term_manipulation
* */ * */
/** @brief *name is assigned the name and *arity the arity if term ts, or the /** @brief *name is assigned the name and *arity the arity if term ts, or the
* operaton fails. * operaton fails.
* *
*/ */
X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity) { X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -399,8 +397,8 @@ X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity) {
} }
/** @brief a is assigned the argument index from term ts /** @brief a is assigned the argument index from term ts
* *
*/ */
X_API int PL_get_arg(int index, term_t ts, term_t a) { X_API int PL_get_arg(int index, term_t ts, term_t a) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -429,8 +427,8 @@ X_API int PL_get_arg(int index, term_t ts, term_t a) {
} }
/** @brief *ap is assigned the name and *ip the arity from term ts /** @brief *ap is assigned the name and *ip the arity from term ts
* *
*/ */
X_API int PL_get_compound_name_arity(term_t ts, atom_t *ap, int *ip) { X_API int PL_get_compound_name_arity(term_t ts, atom_t *ap, int *ip) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -456,8 +454,8 @@ X_API int PL_get_compound_name_arity(term_t ts, atom_t *ap, int *ip) {
} }
/** @brief *a is assigned the atom in term ts, or the operation fails /** @brief *a is assigned the atom in term ts, or the operation fails
* *
*/ */
X_API int PL_get_atom(term_t ts, atom_t *a) { X_API int PL_get_atom(term_t ts, atom_t *a) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -468,8 +466,8 @@ X_API int PL_get_atom(term_t ts, atom_t *a) {
} }
/** @brief *i is assigned the int in term ts, or the operation fails /** @brief *i is assigned the int in term ts, or the operation fails
* *
*/ */
/* int PL_get_integer(term_t t, int *i) /* int PL_get_integer(term_t t, int *i)
YAP: long int YAP_IntOfTerm(Term) */ YAP: long int YAP_IntOfTerm(Term) */
X_API int PL_get_integer(term_t ts, int *i) { X_API int PL_get_integer(term_t ts, int *i) {
@ -483,8 +481,8 @@ X_API int PL_get_integer(term_t ts, int *i) {
/** @brief *i is assigned the boolean atom `true` or `false` in term ts, or the /** @brief *i is assigned the boolean atom `true` or `false` in term ts, or the
* operation fails * operation fails
* *
*/ */
X_API int PL_get_long(term_t ts, long *i) { X_API int PL_get_long(term_t ts, long *i) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -524,8 +522,8 @@ X_API int PL_get_bool(term_t ts, int *i) {
} }
/** @brief *a is assigned the int64 in term ts, or the operation fails /** @brief *a is assigned the int64 in term ts, or the operation fails
* *
*/ */
X_API int PL_get_int64(term_t ts, int64_t *i) { X_API int PL_get_int64(term_t ts, int64_t *i) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -575,8 +573,8 @@ X_API int PL_get_int64(term_t ts, int64_t *i) {
X_API int PL_get_int64_ex(term_t ts, int64_t *i) { return PL_get_int64(ts, i); } X_API int PL_get_int64_ex(term_t ts, int64_t *i) { return PL_get_int64(ts, i); }
/** @brief *a is assigned the intptr_t in term ts, or the operation fails /** @brief *a is assigned the intptr_t in term ts, or the operation fails
* *
*/ */
X_API int PL_get_intptr(term_t ts, intptr_t *a) { X_API int PL_get_intptr(term_t ts, intptr_t *a) {
CACHE_REGS CACHE_REGS
Term t = Yap_GetFromSlot(ts); Term t = Yap_GetFromSlot(ts);
@ -587,8 +585,8 @@ X_API int PL_get_intptr(term_t ts, intptr_t *a) {
} }
/** @brief *a is assigned the uintptr_t in term ts, or the operation fails /** @brief *a is assigned the uintptr_t in term ts, or the operation fails
* *
*/ */
X_API int PL_get_uintptr(term_t ts, uintptr_t *a) { X_API int PL_get_uintptr(term_t ts, uintptr_t *a) {
CACHE_REGS CACHE_REGS
Term t = Yap_GetFromSlot(ts); Term t = Yap_GetFromSlot(ts);
@ -599,8 +597,8 @@ X_API int PL_get_uintptr(term_t ts, uintptr_t *a) {
} }
#ifdef do_not_ld #ifdef do_not_ld
/** @brief a is assigned the argument index from term ts /** @brief a is assigned the argument index from term ts
* *
*/ */
X_API int _PL_get_arg(int index, term_t ts, term_t a) { X_API int _PL_get_arg(int index, term_t ts, term_t a) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -623,8 +621,8 @@ X_API int _PL_get_arg(int index, term_t ts, term_t a) {
/** @brief *a is assigned the string representation of the atom in term ts, or /** @brief *a is assigned the string representation of the atom in term ts, or
* the operation fails * the operation fails
* *
*/ */
X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */ X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */
{ {
CACHE_REGS CACHE_REGS
@ -645,8 +643,8 @@ X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */
/** @brief *a is assigned the string representation of the atom in term ts, and /** @brief *a is assigned the string representation of the atom in term ts, and
* *len its size, or the operation fails * *len its size, or the operation fails
* *
*/ */
X_API int PL_get_atom_nchars(term_t ts, size_t *len, X_API int PL_get_atom_nchars(term_t ts, size_t *len,
char **s) /* SAM check type */ char **s) /* SAM check type */
{ {
@ -656,10 +654,10 @@ X_API int PL_get_atom_nchars(term_t ts, size_t *len,
return 0; return 0;
} }
if (s) if (s)
*s = (char*)RepAtom(AtomOfTerm(t))->StrOfAE; *s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE;
if (len) { if (len) {
*len = strlen(*s); *len = strlen(*s);
} }
return 1; return 1;
} }
@ -693,8 +691,8 @@ X_API int PL_get_atom_nchars(term_t ts, size_t *len,
*/ */
/** @brief *f is assigned the functor of term ts, or the operation fails /** @brief *f is assigned the functor of term ts, or the operation fails
* *
*/ */
X_API int PL_get_functor(term_t ts, functor_t *f) { X_API int PL_get_functor(term_t ts, functor_t *f) {
CACHE_REGS CACHE_REGS
Term t = Yap_GetFromSlot(ts); Term t = Yap_GetFromSlot(ts);
@ -710,8 +708,8 @@ X_API int PL_get_functor(term_t ts, functor_t *f) {
/** @brief *f is assigned the floating point number of term ts, or the /** @brief *f is assigned the floating point number of term ts, or the
* operation fails * operation fails
* *
*/ */
X_API int PL_get_float(term_t ts, double *f) /* SAM type check*/ X_API int PL_get_float(term_t ts, double *f) /* SAM type check*/
{ {
CACHE_REGS CACHE_REGS
@ -740,8 +738,8 @@ X_API int PL_get_string_chars(term_t t, char **s, size_t *len) {
/** @brief *s is assigned the string representation of the string in term ts, /** @brief *s is assigned the string representation of the string in term ts,
* and *len its size, or the operation fails * and *len its size, or the operation fails
* *
*/ */
X_API int PL_get_string(term_t t, char **s, size_t *len) { X_API int PL_get_string(term_t t, char **s, size_t *len) {
CACHE_REGS CACHE_REGS
Term tt = Yap_GetFromSlot(t); Term tt = Yap_GetFromSlot(t);
@ -762,8 +760,8 @@ X_API int PL_get_string(term_t t, char **s, size_t *len) {
/** @brief h is assigned the head of the pair term ts, and tl its tail, or the /** @brief h is assigned the head of the pair term ts, and tl its tail, or the
* operation fails * operation fails
* *
*/ */
X_API int PL_get_list(term_t ts, term_t h, term_t tl) { X_API int PL_get_list(term_t ts, term_t h, term_t tl) {
CACHE_REGS CACHE_REGS
@ -777,8 +775,8 @@ X_API int PL_get_list(term_t ts, term_t h, term_t tl) {
} }
/** @brief h is assigned the head of the pair term ts, or the operation fails /** @brief h is assigned the head of the pair term ts, or the operation fails
* *
*/ */
X_API int PL_get_head(term_t ts, term_t h) { X_API int PL_get_head(term_t ts, term_t h) {
CACHE_REGS CACHE_REGS
YAP_Term t = Yap_GetFromSlot(ts); YAP_Term t = Yap_GetFromSlot(ts);
@ -790,8 +788,8 @@ X_API int PL_get_head(term_t ts, term_t h) {
} }
/** /**
* @} * @}
* */ * */
//! @{ //! @{
/** /**
@ -801,8 +799,8 @@ X_API int PL_get_head(term_t ts, term_t h) {
* */ * */
/*b* @brief t unifies with the true/false value in a. /*b* @brief t unifies with the true/false value in a.
* *
*/ */
X_API int PL_unify_bool(term_t t, int a) { X_API int PL_unify_bool(term_t t, int a) {
CACHE_REGS CACHE_REGS
Term iterm = (a ? MkAtomTerm(AtomTrue) : MkAtomTerm(AtomFalse)); Term iterm = (a ? MkAtomTerm(AtomTrue) : MkAtomTerm(AtomFalse));
@ -813,7 +811,7 @@ X_API int PL_unify_bool(term_t t, int a) {
/******************************* /*******************************
* GMP * * GMP *
*******************************/ *******************************/
X_API int PL_get_mpz(term_t t, mpz_t mpz) { X_API int PL_get_mpz(term_t t, mpz_t mpz) {
CACHE_REGS CACHE_REGS
@ -1554,7 +1552,7 @@ X_API int PL_unify_string_nchars(term_t t, size_t len, const char *chars) {
} }
/* int PL_unify_wchars(term_t ?t, int type, size_t len,, const pl_wchar_t *s) /* int PL_unify_wchars(term_t ?t, int type, size_t len,, const pl_wchar_t *s)
*/ */
X_API int PL_unify_wchars(term_t t, int type, size_t len, X_API int PL_unify_wchars(term_t t, int type, size_t len,
const pl_wchar_t *chars) { const pl_wchar_t *chars) {
CACHE_REGS CACHE_REGS
@ -1786,7 +1784,8 @@ int PL_unify_termv(term_t l, va_list ap) {
Term t = Yap_MkNewApplTerm(ff, arity); Term t = Yap_MkNewApplTerm(ff, arity);
if (nels) { if (nels) {
if (depth == MAX_DEPTH) { if (depth == MAX_DEPTH) {
fprintf(stderr, "ERROR: very deep term in PL_unify_term, change " fprintf(stderr,
"ERROR: very deep term in PL_unify_term, change "
"MAX_DEPTH from %d\n", "MAX_DEPTH from %d\n",
MAX_DEPTH); MAX_DEPTH);
return FALSE; return FALSE;
@ -2525,7 +2524,8 @@ X_API void PL_register_foreign_in_module(const char *module, const char *name,
#ifdef DEBUG #ifdef DEBUG
if (flags & (PL_FA_CREF)) { if (flags & (PL_FA_CREF)) {
fprintf(stderr, "PL_register_foreign_in_module called with non-implemented " fprintf(stderr,
"PL_register_foreign_in_module called with non-implemented "
"flag %x when creating predicate %s:%s/%d\n", "flag %x when creating predicate %s:%s/%d\n",
flags, module, name, arity); flags, module, name, arity);
} }
@ -3139,6 +3139,6 @@ char *PL_cwd(char *cwd, size_t cwdlen) {
} }
/** /**
* @} * @}
* @} * @}
*/ */

12
os/files.c
View File

@ -42,7 +42,7 @@ bool Yap_GetFileName(Term t, char *buf, size_t len, encoding_t enc) {
t = ArgOfTerm(2, t); t = ArgOfTerm(2, t);
len -= (szl + 1); len -= (szl + 1);
} }
return Yap_TextTermToText(t, buf, len, enc); return Yap_TextTermToText(t, buf, enc);
} }
static Int file_name_extension(USES_REGS1) { static Int file_name_extension(USES_REGS1) {
@ -78,8 +78,7 @@ static Int file_name_extension(USES_REGS1) {
Yap_unify(t2, t); Yap_unify(t2, t);
} else { } else {
f2 = ss + (strlen(ss) + 1); f2 = ss + (strlen(ss) + 1);
if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 1 - (f2 - f), if (!Yap_TextTermToText(t2, f2, ENC_ISO_UTF8))
ENC_ISO_UTF8))
return false; return false;
#if __APPLE__ || _WIN32 #if __APPLE__ || _WIN32
Yap_OverwriteUTF8BufferToLowCase(f2); Yap_OverwriteUTF8BufferToLowCase(f2);
@ -113,12 +112,11 @@ static Int file_name_extension(USES_REGS1) {
return true; return true;
} else { } else {
char *f2; char *f2;
if (!Yap_TextTermToText(t1, f, YAP_FILENAME_MAX - 2, ENC_ISO_UTF8)) { if (!Yap_TextTermToText(t1, f, ENC_ISO_UTF8)) {
return false; return false;
} }
f2 = f + strlen(f); f2 = f + strlen(f);
if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 2 - (f2 - f), if (!Yap_TextTermToText(t2, f2, ENC_ISO_UTF8)) {
ENC_ISO_UTF8)) {
return false; return false;
} }
if (f2[0] != '.') { if (f2[0] != '.') {
@ -460,7 +458,7 @@ static Int is_absolute_file_name(USES_REGS1) { /* file_base_name(Stream,N) */
Yap_Error(INSTANTIATION_ERROR, t, "file_base_name/2"); Yap_Error(INSTANTIATION_ERROR, t, "file_base_name/2");
return false; return false;
} }
const char *buf = Yap_TextTermToText(t, NULL, 0, LOCAL_encoding); const char *buf = Yap_TextTermToText(t, NULL, LOCAL_encoding);
if (buf) { if (buf) {
rc = Yap_IsAbsolutePath(buf); rc = Yap_IsAbsolutePath(buf);
} else { } else {

54
os/fmem.c
View File

@ -1,19 +1,19 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog * * YAP Prolog *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: mem.c * * File: mem.c *
* Last rev: 5/2/88 * * Last rev: 5/2/88 *
* mods: * * mods: *
* comments: Input/Output C implemented predicates * * comments: Input/Output C implemented predicates *
* * * *
*************************************************************************/ *************************************************************************/
#ifdef SCCS #ifdef SCCS
static char SccsId[] = "%W% %G%"; static char SccsId[] = "%W% %G%";
#endif #endif
@ -23,14 +23,12 @@ static char SccsId[] = "%W% %G%";
* *
*/ */
#include "sysbits.h"
#include "format.h" #include "format.h"
#include "sysbits.h"
#if HAVE_FMEMOPEN #if HAVE_FMEMOPEN
int format_synch(int sno, int sno0, format_info *fg) {
int format_synch(int sno, int sno0, format_info *fg) {
const char *s; const char *s;
int n; int n;
if (sno != sno0) { if (sno != sno0) {
@ -55,9 +53,9 @@ static char SccsId[] = "%W% %G%";
return sno; return sno;
} }
bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS) bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS)
// uses directly the buffer in the memory stream. // uses directly the buffer in the memory stream.
{ {
int nfillers, fill_space, lfill_space, nchars; int nfillers, fill_space, lfill_space, nchars;
int (*f_putc)(int, int); int (*f_putc)(int, int);
const char *buf; const char *buf;
@ -115,8 +113,8 @@ static char SccsId[] = "%W% %G%";
return true; return true;
} }
bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, encoding_t enc,
bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, encoding_t enc, size_t nchars) { size_t nchars) {
FILE *f; FILE *f;
// like any file stream. // like any file stream.
@ -139,8 +137,7 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, enc
sno = GetFreeStreamD(); sno = GetFreeStreamD();
if (sno < 0) if (sno < 0)
return (PlIOError(RESOURCE_ERROR_MAX_STREAMS, return (PlIOError(RESOURCE_ERROR_MAX_STREAMS, TermNil,
TermNil,
"new stream not available for open_mem_read_stream/1")); "new stream not available for open_mem_read_stream/1"));
st = GLOBAL_Stream + sno; st = GLOBAL_Stream + sno;
if (encp) if (encp)
@ -151,7 +148,7 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, enc
f = st->file = fmemopen((void *)buf, nchars, "r"); f = st->file = fmemopen((void *)buf, nchars, "r");
flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f;
Yap_initStream(sno, f, NULL, TermNil, encoding, flags, AtomRead, NULL); Yap_initStream(sno, f, NULL, TermNil, encoding, flags, AtomRead, NULL);
// like any file stream. // like any file stream.
Yap_DefaultStreamOps(st); Yap_DefaultStreamOps(st);
UNLOCK(st->streamlock); UNLOCK(st->streamlock);
return sno; return sno;
@ -165,7 +162,7 @@ open_mem_read_stream(USES_REGS1) /* $open_mem_read_stream(+List,-Stream) */
const char *buf; const char *buf;
ti = Deref(ARG1); ti = Deref(ARG1);
buf = Yap_TextTermToText(ti, NULL, 0, LOCAL_encoding); buf = Yap_TextTermToText(ti, NULL, LOCAL_encoding);
if (!buf) { if (!buf) {
return false; return false;
} }
@ -290,10 +287,9 @@ void Yap_MemOps(StreamDesc *st) {
st->stream_putc = FilePutc; st->stream_putc = FilePutc;
st->stream_getc = PlGetc; st->stream_getc = PlGetc;
} }
static int sssno; static int sssno;
bool Yap_CloseMemoryStream(int sno) { bool Yap_CloseMemoryStream(int sno) {
sssno++; sssno++;

4
os/format.h
View File

@ -1,8 +1,10 @@
#define FORMAT_MAX_SIZE 1024 #define FORMAT_MAX_SIZE 1024
#include <Yap.h>
typedef struct { typedef struct {
Int filler; intptr_t filler;
/* character to dump */ /* character to dump */
int phys; int phys;
/* position in buffer */ /* position in buffer */

4
os/iopreds.c
View File

@ -294,7 +294,7 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) {
s->status = flags; s->status = flags;
s->linepos = 0; s->linepos = 0;
s->linecount = 1; s->linecount = 1;
s->charcount = 0.; s->charcount = 0;
s->vfs = vfsp; s->vfs = vfsp;
s->encoding = ENC_ISO_UTF8; s->encoding = ENC_ISO_UTF8;
INIT_LOCK(s->streamlock); INIT_LOCK(s->streamlock);
@ -306,7 +306,7 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) {
} }
} else { } else {
unix_upd_stream_info(s); unix_upd_stream_info(s);
} }
/* Getting streams to prompt is a mess because we need for cooperation /* Getting streams to prompt is a mess because we need for cooperation
between readers and writers to the stream :-( between readers and writers to the stream :-(
*/ */

68
os/readterm.c
View File

@ -286,7 +286,7 @@ form:
+ symbols, including `(`, `)`, `,`, `;` + symbols, including `(`, `)`, `,`, `;`
*/ */
static Int scan_to_list(USES_ARGS1) { static Int scan_to_list(USES_REGS1) {
int inp_stream; int inp_stream;
Term tpos, tout; Term tpos, tout;
@ -1350,18 +1350,18 @@ static Int style_checker(USES_REGS1) {
return TRUE; return TRUE;
} }
Term Yap_BufferToTerm(const unsigned char *s, size_t len, Term opts) { Term Yap_BufferToTerm(const unsigned char *s, Term opts) {
Term rval; Term rval;
int sno; int sno;
encoding_t l = ENC_ISO_UTF8; encoding_t l = ENC_ISO_UTF8;
sno = Yap_open_buf_read_stream((char *)s, len, &l, MEM_BUF_USER); sno = Yap_open_buf_read_stream((char *)s, strlen((const char*)s), &l, MEM_BUF_USER);
rval = Yap_read_term(sno, opts, false); rval = Yap_read_term(sno, opts, false);
Yap_CloseStream(sno); Yap_CloseStream(sno);
return rval; return rval;
} }
X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len, X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len,
Term opts, int prio, Term opts, int prio,
Term bindings) { Term bindings) {
CACHE_REGS CACHE_REGS
@ -1374,10 +1374,10 @@ X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len,
if (prio != 1200) { if (prio != 1200) {
ctl = add_priority(bindings, ctl); ctl = add_priority(bindings, ctl);
} }
return Yap_BufferToTerm(s, len, ctl); return Yap_BufferToTerm(s, ctl);
} }
/** /**
* @pred read_term_from_atom( +Atom , -T , +Options ) * @pred read_term_from_atom( +Atom , -T , +Options )
* *
* read a term _T_ stored in constant _Atom_ according to _Options_ * read a term _T_ stored in constant _Atom_ according to _Options_
@ -1393,11 +1393,10 @@ X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len,
*supposed to *supposed to
* use YAP's internal encoding, so please avoid the encoding/1 option. * use YAP's internal encoding, so please avoid the encoding/1 option.
*/ */
static Int read_term_from_atom(USES_REGS1) { static Int read_term_from_atom(USES_REGS1) {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
Atom at; Atom at;
const unsigned char *s; const unsigned char *s;
size_t len;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "style_check/1"); Yap_Error(INSTANTIATION_ERROR, t1, "style_check/1");
@ -1408,14 +1407,13 @@ static Int read_term_from_atom(USES_REGS1) {
} else { } else {
at = AtomOfTerm(t1); at = AtomOfTerm(t1);
s = at->UStrOfAE; s = at->UStrOfAE;
len = strlen_utf8(s);
} }
Term ctl = add_output(ARG2, ARG3); Term ctl = add_output(ARG2, ARG3);
return Yap_BufferToTerm(s, len, ctl); return Yap_BufferToTerm(s, ctl);
} }
/** /**
* @pred read_term_from_atomic( +Atomic , - T , +Options ) * @pred read_term_from_atomic( +Atomic , - T , +Options )
* *
* read a term _T_ stored in text _Atomic_ according to _Options_ * read a term _T_ stored in text _Atomic_ according to _Options_
@ -1430,10 +1428,10 @@ static Int read_term_from_atom(USES_REGS1) {
*atom. *atom.
* Encoding is fixed in atoms and strings. * Encoding is fixed in atoms and strings.
*/ */
static Int read_term_from_atomic(USES_REGS1) { static Int read_term_from_atomic(USES_REGS1) {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
const unsigned char *s; const unsigned char *s;
size_t len;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_atomic/3"); Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_atomic/3");
return (FALSE); return (FALSE);
@ -1443,14 +1441,13 @@ static Int read_term_from_atomic(USES_REGS1) {
} else { } else {
Term t = Yap_AtomicToString(t1 PASS_REGS); Term t = Yap_AtomicToString(t1 PASS_REGS);
s = UStringOfTerm(t); s = UStringOfTerm(t);
len = strlen_utf8(s);
} }
Term ctl = add_output(ARG2, ARG3); Term ctl = add_output(ARG2, ARG3);
return Yap_BufferToTerm(s, len, ctl); return Yap_BufferToTerm(s, ctl);
} }
/** /**
* @pred read_term_from_string( +String , - T , + Options ) * @pred read_term_from_string( +String , - T , + Options )
* *
* read a term _T_ stored in constant _String_ according to _Options_ * read a term _T_ stored in constant _String_ according to _Options_
@ -1462,7 +1459,7 @@ static Int read_term_from_atomic(USES_REGS1) {
* @notes Idea from SWI-Prolog, in YAP only works with strings * @notes Idea from SWI-Prolog, in YAP only works with strings
* Check read_term_from_atomic/3 for the general version. * Check read_term_from_atomic/3 for the general version.
*/ */
static Int read_term_from_string(USES_REGS1) { static Int read_term_from_string(USES_REGS1) {
Term t1 = Deref(ARG1), rc; Term t1 = Deref(ARG1), rc;
const unsigned char *s; const unsigned char *s;
size_t len; size_t len;
@ -1484,11 +1481,10 @@ static Int read_term_from_string(USES_REGS1) {
if (!rc) if (!rc)
return false; return false;
return Yap_unify(rc, ARG2); return Yap_unify(rc, ARG2);
} }
static Int atomic_to_term(USES_REGS1) { static Int atomic_to_term(USES_REGS1) {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
size_t len;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE); return (FALSE);
@ -1498,15 +1494,13 @@ static Int atomic_to_term(USES_REGS1) {
} else { } else {
Term t = Yap_AtomicToString(t1 PASS_REGS); Term t = Yap_AtomicToString(t1 PASS_REGS);
const unsigned char *us = UStringOfTerm(t); const unsigned char *us = UStringOfTerm(t);
len = strlen_utf8(us); return Yap_BufferToTerm(us,
return Yap_BufferToTerm(us, len,
add_output(ARG2, add_names(ARG3, TermNil))); add_output(ARG2, add_names(ARG3, TermNil)));
} }
} }
static Int atom_to_term(USES_REGS1) { static Int atom_to_term(USES_REGS1) {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
size_t len;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE); return (FALSE);
@ -1516,15 +1510,14 @@ static Int atom_to_term(USES_REGS1) {
} else { } else {
Term t = Yap_AtomicToString(t1 PASS_REGS); Term t = Yap_AtomicToString(t1 PASS_REGS);
const unsigned char *us = UStringOfTerm(t); const unsigned char *us = UStringOfTerm(t);
len = strlen_utf8(us); return Yap_BufferToTerm(us,
return Yap_BufferToTerm(us, len,
add_output(ARG2, add_names(ARG3, TermNil))); add_output(ARG2, add_names(ARG3, TermNil)));
} }
} }
static Int string_to_term(USES_REGS1) { static Int string_to_term(USES_REGS1) {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
size_t len;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE); return (FALSE);
@ -1533,13 +1526,12 @@ static Int string_to_term(USES_REGS1) {
return (FALSE); return (FALSE);
} else { } else {
const unsigned char *us = UStringOfTerm(t1); const unsigned char *us = UStringOfTerm(t1);
len = strlen_utf8(us); return Yap_BufferToTerm(us,
return Yap_BufferToTerm(us, len,
add_output(ARG2, add_names(ARG3, TermNil))); add_output(ARG2, add_names(ARG3, TermNil)));
} }
} }
void Yap_InitReadTPreds(void) { void Yap_InitReadTPreds(void) {
Yap_InitCPred("read_term", 2, read_term2, SyncPredFlag); Yap_InitCPred("read_term", 2, read_term2, SyncPredFlag);
Yap_InitCPred("read_term", 3, read_term, SyncPredFlag); Yap_InitCPred("read_term", 3, read_term, SyncPredFlag);
@ -1560,4 +1552,4 @@ void Yap_InitReadTPreds(void) {
Yap_InitCPred("source_location", 2, source_location, SyncPredFlag); Yap_InitCPred("source_location", 2, source_location, SyncPredFlag);
Yap_InitCPred("$style_checker", 1, style_checker, Yap_InitCPred("$style_checker", 1, style_checker,
SyncPredFlag | HiddenPredFlag); SyncPredFlag | HiddenPredFlag);
} }

53
os/sysbits.c
View File

@ -1,19 +1,19 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog * * YAP Prolog *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: sysbits.c * * File: sysbits.c *
* Last rev: 4/03/88 * * Last rev: 4/03/88 *
* mods: * * mods: *
* comments: very much machine dependent routines * * comments: very much machine dependent routines *
* * * *
*************************************************************************/ *************************************************************************/
#ifdef SCCS #ifdef SCCS
static char SccsId[] = "%W% %G%"; static char SccsId[] = "%W% %G%";
#endif #endif
@ -487,8 +487,8 @@ const char *Yap_AbsoluteFile(const char *spec, char *rc0, bool ok) {
} }
static Term static Term
/* Expand the string for the program to run. */ /* Expand the string for the program to run. */
do_glob(const char *spec, bool glob_vs_wordexp) { do_glob(const char *spec, bool glob_vs_wordexp) {
CACHE_REGS CACHE_REGS
if (spec == NULL) { if (spec == NULL) {
return TermNil; return TermNil;
@ -847,7 +847,7 @@ static Int absolute_file_system_path(USES_REGS1) {
const char *fp; const char *fp;
bool rc; bool rc;
char s[MAXPATHLEN + 1]; char s[MAXPATHLEN + 1];
const char *text = Yap_TextTermToText(t, s, MAXPATHLEN, LOCAL_encoding); const char *text = Yap_TextTermToText(t, s, LOCAL_encoding);
if (text == NULL) { if (text == NULL) {
return false; return false;
@ -1359,7 +1359,7 @@ static Int p_expand_file_name(USES_REGS1) {
Yap_Error(INSTANTIATION_ERROR, t, "argument to true_file_name unbound"); Yap_Error(INSTANTIATION_ERROR, t, "argument to true_file_name unbound");
return FALSE; return FALSE;
} }
text = Yap_TextTermToText(t, NULL, 0, LOCAL_encoding); text = Yap_TextTermToText(t, NULL, LOCAL_encoding);
if (!text) if (!text)
return false; return false;
if (!(text2 = PlExpandVars(text, NULL, NULL))) if (!(text2 = PlExpandVars(text, NULL, NULL)))
@ -1925,7 +1925,7 @@ static HKEY reg_open_key(const wchar_t *which, int create) {
#define MAXREGSTRLEN 1024 #define MAXREGSTRLEN 1024
static wchar_t *WideStringFromAtom(Atom KeyAt USES_REGS) { static wchar_t *WideStringFromAtom(Atom KeyAt USES_REGS) {
return Yap_AtomToWide( KeyAt ); return Yap_AtomToWide(KeyAt);
} }
static Int p_win_registry_get_value(USES_REGS1) { static Int p_win_registry_get_value(USES_REGS1) {
@ -1959,7 +1959,7 @@ static Int p_win_registry_get_value(USES_REGS1) {
} }
if (!IsAtomTerm(Name)) { if (!IsAtomTerm(Name)) {
Yap_Error(TYPE_ERROR_ATOM, Key, "argument to win_registry_get_value"); Yap_Error(TYPE_ERROR_ATOM, Key, "argument to win_registry_get_value");
pop_text_stack(l); pop_text_stack(l);
return FALSE; return FALSE;
} }
NameAt = AtomOfTerm(Name); NameAt = AtomOfTerm(Name);
@ -1967,7 +1967,7 @@ pop_text_stack(l);
k = WideStringFromAtom(KeyAt PASS_REGS); k = WideStringFromAtom(KeyAt PASS_REGS);
if (!(key = reg_open_key(k, FALSE))) { if (!(key = reg_open_key(k, FALSE))) {
Yap_Error(EXISTENCE_ERROR_KEY, Key, "argument to win_registry_get_value"); Yap_Error(EXISTENCE_ERROR_KEY, Key, "argument to win_registry_get_value");
pop_text_stack(l); pop_text_stack(l);
return FALSE; return FALSE;
} }
name = WideStringFromAtom(NameAt PASS_REGS); name = WideStringFromAtom(NameAt PASS_REGS);
@ -1979,11 +1979,10 @@ pop_text_stack(l);
((wchar_t *)data)[len] = '\0'; ((wchar_t *)data)[len] = '\0';
Atom at = Yap_NWCharsToAtom((wchar_t *)data, len PASS_REGS); Atom at = Yap_NWCharsToAtom((wchar_t *)data, len PASS_REGS);
pop_text_stack(l); pop_text_stack(l);
return Yap_unify(MkAtomTerm(at),ARG3); return Yap_unify(MkAtomTerm(at), ARG3);
case REG_DWORD: case REG_DWORD: {
{
DWORD *d = (DWORD *)data; DWORD *d = (DWORD *)data;
pop_text_stack(l); pop_text_stack(l);
return Yap_unify(MkIntegerTerm((Int)d[0]), ARG3); return Yap_unify(MkIntegerTerm((Int)d[0]), ARG3);
} }
default: default:
@ -1991,7 +1990,7 @@ pop_text_stack(l);
return FALSE; return FALSE;
} }
} }
pop_text_stack(l); pop_text_stack(l);
return FALSE; return FALSE;
} }

41
os/writeterm.c
View File

@ -1,19 +1,19 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog * * YAP Prolog *
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: iopreds.c * * File: iopreds.c *
* Last rev: 5/2/88 * * Last rev: 5/2/88 *
* mods: * * mods: *
* comments: Input/Output C implemented predicates * * comments: Input/Output C implemented predicates *
* * * *
*************************************************************************/ *************************************************************************/
#ifdef SCCS #ifdef SCCS
static char SccsId[] = "%W% %G%"; static char SccsId[] = "%W% %G%";
#endif #endif
@ -25,10 +25,10 @@ static char SccsId[] = "%W% %G%";
*/ */
#include "Yap.h" #include "Yap.h"
#include "YapEval.h"
#include "YapHeap.h" #include "YapHeap.h"
#include "YapText.h" #include "YapText.h"
#include "Yatom.h" #include "Yatom.h"
#include "YapEval.h"
#include "yapio.h" #include "yapio.h"
#include <stdlib.h> #include <stdlib.h>
#if HAVE_STDARG_H #if HAVE_STDARG_H
@ -678,8 +678,7 @@ static Int term_to_string(USES_REGS1) {
Term t2 = Deref(ARG2), rc = false, t1 = Deref(ARG1); Term t2 = Deref(ARG2), rc = false, t1 = Deref(ARG1);
const char *s; const char *s;
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
size_t length; s = Yap_TermToString(ARG1,LOCAL_encoding,
s = Yap_TermToString(ARG1, &length, LOCAL_encoding,
Quote_illegal_f | Handle_vars_f); Quote_illegal_f | Handle_vars_f);
if (!s || !MkStringTerm(s)) { if (!s || !MkStringTerm(s)) {
Yap_Error(RESOURCE_ERROR_HEAP, t1, Yap_Error(RESOURCE_ERROR_HEAP, t1,
@ -700,8 +699,7 @@ static Int term_to_atom(USES_REGS1) {
Term t2 = Deref(ARG2), ctl, rc = false; Term t2 = Deref(ARG2), ctl, rc = false;
Atom at; Atom at;
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
size_t length; const char *s = Yap_TermToString(Deref(ARG1), LOCAL_encoding,
const char *s = Yap_TermToString(Deref(ARG1), &length, LOCAL_encoding,
Quote_illegal_f | Handle_vars_f); Quote_illegal_f | Handle_vars_f);
if (!s || !(at = Yap_UTF8ToAtom((const unsigned char *)s))) { if (!s || !(at = Yap_UTF8ToAtom((const unsigned char *)s))) {
Yap_Error(RESOURCE_ERROR_HEAP, t2, Yap_Error(RESOURCE_ERROR_HEAP, t2,
@ -716,8 +714,7 @@ static Int term_to_atom(USES_REGS1) {
at = AtomOfTerm(t2); at = AtomOfTerm(t2);
} }
ctl = TermNil; ctl = TermNil;
return (rc = Yap_BufferToTerm(RepAtom(at)->UStrOfAE, return ((rc = Yap_BufferToTerm(RepAtom(at)->UStrOfAE, ctl))) &&
strlen(RepAtom(at)->StrOfAE), ctl)) &&
Yap_unify(rc, ARG1); Yap_unify(rc, ARG1);
} }

38
os/yapio.h
View File

@ -1,19 +1,18 @@
/************************************************************************* /*************************************************************************
* * * *
* YAP Prolog %W% %G% * YAP Prolog %W% %G%
* * * *
* Yap Prolog was developed at NCCUP - Universidade do Porto * * Yap Prolog was developed at NCCUP - Universidade do Porto *
* * * *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 *
* * * *
************************************************************************** **************************************************************************
* * * *
* File: yapio.h * * File: yapio.h * Last
* Last rev: 22/1/03 * *rev: 22/1/03 * mods:
* mods: * ** comments: Input/Output information *
* comments: Input/Output information * * *
* * *************************************************************************/
*************************************************************************/
#ifndef YAPIO_H #ifndef YAPIO_H
@ -78,8 +77,7 @@ extern int Yap_PlFGetchar(void);
extern int Yap_GetCharForSIGINT(void); extern int Yap_GetCharForSIGINT(void);
extern Int Yap_StreamToFileNo(Term); extern Int Yap_StreamToFileNo(Term);
extern int Yap_OpenStream(FILE *, char *, Term, int); extern int Yap_OpenStream(FILE *, char *, Term, int);
extern char *Yap_TermToString(Term t, size_t *length, encoding_t encoding, extern char *Yap_TermToString(Term t, encoding_t encoding, int flags);
int flags);
extern char *Yap_HandleToString(yhandle_t l, size_t sz, size_t *length, extern char *Yap_HandleToString(yhandle_t l, size_t sz, size_t *length,
encoding_t *encoding, int flags); encoding_t *encoding, int flags);
extern int Yap_GetFreeStreamD(void); extern int Yap_GetFreeStreamD(void);
@ -110,10 +108,10 @@ extern Term Yap_StringToNumberTerm(const char *s, encoding_t *encp,
extern int Yap_FormatFloat(Float f, char **s, size_t sz); extern int Yap_FormatFloat(Float f, char **s, size_t sz);
extern int Yap_open_buf_read_stream(const char *buf, size_t nchars, extern int Yap_open_buf_read_stream(const char *buf, size_t nchars,
encoding_t *encp, memBufSource src); encoding_t *encp, memBufSource src);
extern bool Yap_set_stream_to_buf(struct stream_desc *st, const char *buf, encoding_t enc, extern bool Yap_set_stream_to_buf(struct stream_desc *st, const char *buf,
size_t nchars); encoding_t enc, size_t nchars);
extern int Yap_open_buf_write_stream(encoding_t enc, memBufSource src); extern int Yap_open_buf_write_stream(encoding_t enc, memBufSource src);
extern Term Yap_BufferToTerm(const unsigned char *s, size_t sz, Term opts); extern Term Yap_BufferToTerm(const unsigned char *s, Term opts);
extern X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, extern X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s,
size_t sz, Term opts, size_t sz, Term opts,
int prio, Term bindings); int prio, Term bindings);

8
packages/python/swig/setup.py
View File

File diff suppressed because one or more lines are too long

18
packages/python/yap_kernel/setup.py.in
View File

@ -97,25 +97,29 @@ if any(a.startswith(('bdist', 'build', 'install')) for a in sys.argv):
argv = make_yap_kernel_cmd(executable='python') argv = make_yap_kernel_cmd(executable='python')
dest = os.path.join(here, 'resources') dest = os.path.join(here, 'resources')
if os.path.exists(dest): try:
shutil.rmtree(dest) shutil.rmtree(dest)
os.makedirs( dest )
shutil.copy2('${CMAKE_SOURCE_DIR}/docs/icons/yap_32x32x32.png',dest)
shutil.copy2('${CMAKE_SOURCE_DIR}/docs/icons/yap_64x64x32.png',dest)
write_kernel_spec(dest, overrides={'argv': argv}) write_kernel_spec(dest, overrides={'argv': argv})
shutil.copy('${CMAKE_CURRENT_SOURCE_DIR}/kernel.js',dest) except:
shutil.copy('${CMAKE_SOURCE_DIR}/misc/editors/prolog.js',dest) pass
shutil.copy('${CMAKE_SOURCE_DIR}/docs/icons/yap_32x32x32.png',os.path.join(dest,'logo-32x32.png')) # shutil.copy('${CMAKE_CURRENT_SOURCE_DIR}/kernel.js',dest)
shutil.copy('${CMAKE_SOURCE_DIR}/docs/icons/yap_64x64x32.png',os.path.join(dest,'logo-64x64.png')) # shutil.copy('${CMAKE_SOURCE_DIR}/misc/editors/prolog.js',dest)
setup_args['data_files'] = [ setup_args['data_files'] = [
(pjoin('share', 'jupyter', 'kernels', KERNEL_NAME), glob(pjoin(dest, '*'))), (pjoin('share', 'jupyter', 'kernels', KERNEL_NAME), glob(pjoin(dest, '*'))),
] ]
mode_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'components', 'codemirror', 'mode', 'prolog') mode_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'components', 'codemirror', 'mode', 'prolog')
custom_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'custom') custom_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'custom')
try: try:
shutil.copy( pjoin( custom_loc, "custom.js") , pjoin( custom_loc, "custom.js.orig"))
shutil.copy( "${CMAKE_CURRENT_SOURCE_DIR}/custom.js" , pjoin( custom_loc, "custom.js"))
if not os.path.exists(mode_loc):
os.makedirs(mode_loc) os.makedirs(mode_loc)
shutil.copy( "${CMAKE_SOURCE_DIR}/misc/editors/prolog.js" , mode_loc) shutil.copy( "${CMAKE_SOURCE_DIR}/misc/editors/prolog.js" , mode_loc)
except: except:
pass pass
shutil.copy( pjoin( custom_loc, "custom.js") , pjoin( custom_loc, "custom.js.orig"))
shutil.copy( "${CMAKE_CURRENT_SOURCE_DIR}/custom.js" , pjoin( custom_loc, "custom.js"))
extras_require = setuptools_args['extras_require'] = { extras_require = setuptools_args['extras_require'] = {
'test:python_version=="2.7"': ['mock'], 'test:python_version=="2.7"': ['mock'],