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

15
C/atomic.c
View File

@ -268,12 +268,11 @@ static Int char_code(USES_REGS1) {
Atom at = AtomOfTerm(t0);
Term tf;
unsigned char *c = RepAtom(at)->UStrOfAE;
int32_t v;
c += get_utf8(c, 1, &v);
if (c[0] != '\0') {
Yap_Error(TYPE_ERROR_CHARACTER, t0, "char_code/2");
return FALSE;
}
int32_t v = IntegerOfTerm(ARG1);
get_utf8(c, -1, &v);
if (!v)
return false;
tf = MkIntTerm(v);
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);
LOCAL_MAX_SIZE = 1024;
int l = push_text_stack();
restart_aux:
restart_aux:
if (Yap_IsGroundTerm(t1)) {
if (!IsVarTerm(t2) && !IsPairTerm(t2) && t2 != TermNil) {
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;
BACKUP_MACHINE_REGS();
b = Yap_TermToString(t, lengthp, enc, flags);
if (*lengthp >= sze)
*lengthp = sze;
b = Yap_TermToString(t, enc, flags);
strncpy(buf, b, sze);
buf[sze] = 0;
RECOVER_MACHINE_REGS();
return true;
}
@ -2341,9 +2340,9 @@ static void do_bootfile(const char *bootfilename USES_REGS) {
if (Yap_output_msg)
fprintf(stderr, "Boot loaded\n");
#endif
}
}
/**
/**
YAP_DelayInit()
ensures initialization is done after engine creation.
@ -2351,11 +2350,11 @@ static void do_bootfile(const char *bootfilename USES_REGS) {
the module.
*/
X_API bool YAP_initialized = false;
static int n_mdelays = 0;
static YAP_delaymodule_t *m_delays;
X_API bool YAP_initialized = false;
static int n_mdelays = 0;
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) {
m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t));
} else {
@ -2365,9 +2364,9 @@ X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) {
m_delays[n_mdelays].s = s;
n_mdelays++;
return true;
}
}
bool Yap_LateInit(const char s[]) {
bool Yap_LateInit(const char s[]) {
int i;
for (i = 0; i < n_mdelays; i++) {
if (!strcmp(m_delays[i].s, s)) {
@ -2376,9 +2375,9 @@ bool Yap_LateInit(const char s[]) {
}
}
return false;
}
}
static void start_modules(void) {
static void start_modules(void) {
Term cm = CurrentModule;
size_t i;
for (i = 0; i < n_mdelays; i++) {
@ -2386,15 +2385,15 @@ static void start_modules(void) {
m_delays[i].f();
}
CurrentModule = cm;
}
}
/// whether Yap is under control of some other system
bool Yap_embedded = true;
/// whether Yap is under control of some other system
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 */
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;
bool do_bootstrap = (restore_result & YAP_CONSULT_MODE);
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();
YAP_initialized = true;
return rc;
}
}
#if (DefTrailSpace < MinTrailSpace)
#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_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_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);
}
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);
}
}
X_API int YAP_Reset(yap_reset_t mode) {
X_API int YAP_Reset(yap_reset_t mode) {
int res = TRUE;
BACKUP_MACHINE_REGS();
res = Yap_Reset(mode);
RECOVER_MACHINE_REGS();
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
Yap_output_msg = TRUE;
#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();
Yap_CloseStreams(FALSE);
RECOVER_H();
}
}
X_API void YAP_FlushAllStreams(void) {
X_API void YAP_FlushAllStreams(void) {
BACKUP_H();
// VSC?? Yap_FlushStreams();
RECOVER_H();
}
}
X_API void YAP_Throw(Term t) {
X_API void YAP_Throw(Term t) {
BACKUP_MACHINE_REGS();
Yap_JumpToEnv(t);
RECOVER_MACHINE_REGS();
}
}
X_API void YAP_AsyncThrow(Term t) {
X_API void YAP_AsyncThrow(Term t) {
CACHE_REGS
BACKUP_MACHINE_REGS();
LOCAL_PrologMode |= AsyncIntMode;
Yap_JumpToEnv(t);
LOCAL_PrologMode &= ~AsyncIntMode;
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
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) {
return ((void *) RepPredProp(PredPropByAtom(a, m)));
} else {
Functor f = Yap_MkFunctor(a, arity);
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;
if (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;
else
*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);
}
}
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,
arity_t extra) {
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,
arity_t arity, arity_t extra) {
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,
arity_t extra) {
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) {
CACHE_REGS
PredEntry *pe;
@ -2771,91 +2770,91 @@ X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f,
}
pe->PredFlags |= CArgsPredFlag;
CurrentModule = cm;
}
}
X_API Term YAP_CurrentModule(void) {
X_API Term YAP_CurrentModule(void) {
CACHE_REGS
return (CurrentModule);
}
}
X_API Term YAP_SetCurrentModule(Term new) {
X_API Term YAP_SetCurrentModule(Term new) {
CACHE_REGS
Term omod = CurrentModule;
LOCAL_SourceModule = CurrentModule = new;
return omod;
}
}
X_API Term YAP_CreateModule(Atom at) {
X_API Term YAP_CreateModule(Atom at) {
Term t;
WRITE_LOCK(RepAtom(at)->ARWLock);
t = Yap_Module(MkAtomTerm(at));
WRITE_UNLOCK(RepAtom(at)->ARWLock);
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);
}
}
X_API int YAP_ThreadSelf(void) {
X_API int YAP_ThreadSelf(void) {
#if THREADS
return Yap_thread_self();
#else
return -2;
#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
return Yap_thread_create_engine(attr);
#else
return -1;
#endif
}
}
X_API int YAP_ThreadAttachEngine(int wid) {
X_API int YAP_ThreadAttachEngine(int wid) {
#if THREADS
return Yap_thread_attach_engine(wid);
#else
return FALSE;
#endif
}
}
X_API int YAP_ThreadDetachEngine(int wid) {
X_API int YAP_ThreadDetachEngine(int wid) {
#if THREADS
return Yap_thread_detach_engine(wid);
#else
return FALSE;
#endif
}
}
X_API int YAP_ThreadDestroyEngine(int wid) {
X_API int YAP_ThreadDestroyEngine(int wid) {
#if THREADS
return Yap_thread_destroy_engine(wid);
#else
return FALSE;
#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;
GLOBAL_AGCHook = hook;
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);
}
}
X_API char *YAP_cwd(void) {
X_API char *YAP_cwd(void) {
CACHE_REGS
char *buf = NULL;
int len;
@ -2867,9 +2866,9 @@ X_API char *YAP_cwd(void) {
return NULL;
strncpy(buf, LOCAL_FileNameBuf, len);
return buf;
}
}
X_API Term YAP_FloatsToList(double *dblp, size_t sz) {
X_API Term YAP_FloatsToList(double *dblp, size_t sz) {
CACHE_REGS
Term t;
CELL *oldH;
@ -2900,9 +2899,9 @@ X_API Term YAP_FloatsToList(double *dblp, size_t sz) {
oldH[1] = TermNil;
RECOVER_H();
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;
t = Deref(t);
@ -2935,9 +2934,9 @@ X_API Int YAP_ListToFloats(Term t, double *dblp, size_t sz) {
return sz;
t = TailOfTerm(t);
} while (TRUE);
}
}
X_API Term YAP_IntsToList(Int *dblp, size_t sz) {
X_API Term YAP_IntsToList(Int *dblp, size_t sz) {
CACHE_REGS
Term t;
CELL *oldH;
@ -2968,9 +2967,9 @@ X_API Term YAP_IntsToList(Int *dblp, size_t sz) {
oldH[1] = TermNil;
RECOVER_H();
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;
t = Deref(t);
@ -2990,9 +2989,9 @@ X_API Int YAP_ListToInts(Term t, Int *dblp, size_t sz) {
return sz;
t = TailOfTerm(t);
} while (TRUE);
}
}
X_API Term YAP_OpenList(int n) {
X_API Term YAP_OpenList(int n) {
CACHE_REGS
Term t;
BACKUP_H();
@ -3008,9 +3007,9 @@ X_API Term YAP_OpenList(int n) {
RECOVER_H();
return t;
}
}
X_API Term YAP_ExtendList(Term t0, Term inp) {
X_API Term YAP_ExtendList(Term t0, Term inp) {
Term t;
CELL *ptr = RepPair(t0);
BACKUP_H();
@ -3021,26 +3020,26 @@ X_API Term YAP_ExtendList(Term t0, Term inp) {
RECOVER_H();
return t;
}
}
X_API int YAP_CloseList(Term t0, Term tail) {
X_API int YAP_CloseList(Term t0, Term tail) {
CELL *ptr = RepPair(t0);
RESET_VARIABLE(ptr - 1);
if (!Yap_unify((Term) (ptr - 1), tail))
return FALSE;
return TRUE;
}
}
X_API int YAP_IsAttVar(Term t) {
X_API int YAP_IsAttVar(Term t) {
CACHE_REGS
t = Deref(t);
if (!IsVarTerm(t))
return FALSE;
return IsAttVar(VarOfTerm(t));
}
}
X_API Term YAP_AttsOfVar(Term t) {
X_API Term YAP_AttsOfVar(Term t) {
CACHE_REGS
attvar_record *attv;
@ -3051,25 +3050,25 @@ X_API Term YAP_AttsOfVar(Term t) {
return TermNil;
attv = RepAttVar(VarOfTerm(t));
return attv->Atts;
}
}
X_API int YAP_FileNoFromStream(Term t) {
X_API int YAP_FileNoFromStream(Term t) {
t = Deref(t);
if (IsVarTerm(t))
return -1;
return Yap_StreamToFileNo(t);
}
}
X_API void *YAP_FileDescriptorFromStream(Term t) {
X_API void *YAP_FileDescriptorFromStream(Term t) {
t = Deref(t);
if (IsVarTerm(t))
return NULL;
return Yap_FileDescriptorFromStream(t);
}
}
X_API void *YAP_Record(Term t) {
X_API void *YAP_Record(Term t) {
DBTerm *dbterm;
DBRecordList *dbt;
@ -3093,9 +3092,9 @@ X_API void *YAP_Record(Term t) {
dbt->dbrecord = dbterm;
Yap_Records = dbt;
return dbt;
}
}
X_API Term YAP_Recorded(void *handle) {
X_API Term YAP_Recorded(void *handle) {
CACHE_REGS
Term t;
DBTerm *dbterm = ((DBRecordList *) handle)->dbrecord;
@ -3126,9 +3125,9 @@ X_API Term YAP_Recorded(void *handle) {
} while (t == (CELL) 0);
RECOVER_MACHINE_REGS();
return t;
}
}
X_API int YAP_Erase(void *handle) {
X_API int YAP_Erase(void *handle) {
DBRecordList *dbr = (DBRecordList *) handle;
if (dbr->next_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_FreeCodeSpace(handle);
return 1;
}
}
X_API yhandle_t YAP_ArgsToSlots(int n) {
X_API yhandle_t YAP_ArgsToSlots(int n) {
CACHE_REGS
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
CELL *ptr0 = Yap_AddressFromSlot(slot), *ptr1 = &ARG1;
while (n--) {
*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) */
X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) {
/* yhandle_t YAP_VarSlotToNumber(yhandle_t) */
X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) {
CACHE_REGS
Term *t = (CELL *) Deref(Yap_GetFromSlot(s));
if (t < HR)
return t - H0;
return t - LCL0;
}
}
/* Term YAP_ModuleUser() */
X_API Term YAP_ModuleUser(void) { return MkAtomTerm(AtomUser); }
/* Term YAP_ModuleUser() */
X_API Term YAP_ModuleUser(void) { return MkAtomTerm(AtomUser); }
/* int YAP_PredicateHasClauses() */
X_API yhandle_t YAP_NumberOfClausesForPredicate(PredEntry *pe) {
/* int YAP_PredicateHasClauses() */
X_API yhandle_t YAP_NumberOfClausesForPredicate(PredEntry *pe) {
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);
OpEntry *info;
WRITE_LOCK(ae->ARWLock);
@ -3192,9 +3191,9 @@ X_API int YAP_MaxOpPriority(Atom at, Term module) {
ret = info->Posfix;
WRITE_UNLOCK(ae->ARWLock);
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);
OpEntry *info;
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;
WRITE_UNLOCK(ae->ARWLock);
return 1;
}
}
X_API int YAP_Argv(char ***argvp) {
X_API int YAP_Argv(char ***argvp) {
if (argvp) {
*argvp = GLOBAL_argv;
}
return GLOBAL_argc;
}
}
X_API YAP_tag_t YAP_TagOfTerm(Term t) {
X_API YAP_tag_t YAP_TagOfTerm(Term t) {
if (IsVarTerm(t)) {
CELL *pt = VarOfTerm(t);
if (IsUnboundVar(pt)) {
@ -3304,12 +3303,12 @@ X_API YAP_tag_t YAP_TagOfTerm(Term t) {
}
return YAP_TAG_APPL;
}
}
}
int YAP_BPROLOG_exception;
Term YAP_BPROLOG_curr_toam_status;
int YAP_BPROLOG_exception;
Term YAP_BPROLOG_curr_toam_status;
/**
/**
* Output the number of bytes needed to represent a string in UTF-8
* Note that the terminating zero is not included. No error checking
* 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.
*/
X_API size_t YAP_UTF8_TextLength(Term t) {
X_API size_t YAP_UTF8_TextLength(Term t) {
utf8proc_uint8_t dst[8];
size_t sz = 0;
@ -3350,9 +3349,9 @@ X_API size_t YAP_UTF8_TextLength(Term t) {
sz = strlen(StringOfTerm(t));
}
return sz;
}
}
X_API Int YAP_ListLength(Term t) {
X_API Int YAP_ListLength(Term t) {
Term *aux;
Int n = Yap_SkipList(&t, &aux);
@ -3361,35 +3360,35 @@ X_API Int YAP_ListLength(Term t) {
if (*aux == TermNil)
return n;
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 */
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 &&
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)
return 0;
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)
return 0;
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
if (sz < 16 * 1024)
@ -3408,14 +3407,14 @@ X_API int YAP_RequiresExtraStack(size_t sz) {
}
RECOVER_H();
return TRUE;
}
}
atom_t *TR_Atoms;
functor_t *TR_Functors;
size_t AtomTranslations, MaxAtomTranslations;
size_t FunctorTranslations, MaxFunctorTranslations;
atom_t *TR_Atoms;
functor_t *TR_Functors;
size_t AtomTranslations, MaxAtomTranslations;
size_t FunctorTranslations, MaxFunctorTranslations;
X_API Int YAP_AtomToInt(Atom At) {
X_API Int YAP_AtomToInt(Atom At) {
TranslationEntry *te = Yap_GetTranslationProp(At, 0);
if (te != NIL)
return te->Translation;
@ -3436,11 +3435,11 @@ X_API Int YAP_AtomToInt(Atom At) {
MaxAtomTranslations *= 2;
}
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);
arity_t arity = ArityOfFunctor(f);
TranslationEntry *te = Yap_GetTranslationProp(At, arity);
@ -3464,25 +3463,25 @@ X_API Int YAP_FunctorToInt(Functor f) {
MaxFunctorTranslations *= 2;
}
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);
Term tmod = MkAtomTerm(Yap_LookupAtom("yapi"));
PredEntry *p = RepPredProp(Yap_GetPredPropByFunc(f, tmod));
return p;
}
}
void yap_init(void) {}
void yap_init(void) {}
#endif // C_INTERFACE_C
/**
/**
@}
*/
*/

19
C/modules.c
View File

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

36
C/scanner.c
View File

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

432
C/text.c
View File

@ -1,19 +1,19 @@
/*************************************************************************
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985-- *
* *
**************************************************************************
* *
* File: strings.c *
* comments: General-conversion of character sequences. *
* *
* Last rev: $Date: 2008-07-24 16:02:00 $,$Author: vsc $ *
* *
*************************************************************************/
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985-- *
* *
**************************************************************************
* *
* File: strings.c *
* comments: General-conversion of character sequences. *
* *
* Last rev: $Date: 2008-07-24 16:02:00 $,$Author: vsc $ *
* *
*************************************************************************/
#include "Yap.h"
#include "YapEval.h"
@ -51,10 +51,7 @@ typedef struct TextBuffer_manager {
int lvl;
} text_buffer_t;
int push_text_stack(USES_REGS1) {
return LOCAL_TextBuffer->lvl++;
}
int push_text_stack(USES_REGS1) { return LOCAL_TextBuffer->lvl++; }
int pop_text_stack(int i) {
int lvl = LOCAL_TextBuffer->lvl;
@ -73,43 +70,9 @@ int pop_text_stack(int i) {
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 *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;
void insert_block(struct mblock *o) {
int lvl = o->lvl;
o->prev = LOCAL_TextBuffer->last[lvl];
if (o->prev) {
o->prev->next = o;
@ -120,8 +83,36 @@ void *Malloc(size_t sz USES_REGS) {
LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = o;
}
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->lvl = lvl;
o->prev = o->next = 0;
insert_block(o);
return o + 1;
}
@ -141,26 +132,28 @@ void *Realloc(void *pt, size_t sz USES_REGS) {
if (LOCAL_TextBuffer->last[lvl] == old) {
LOCAL_TextBuffer->last[lvl] = o;
}
o->sz = sz;
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) {
struct mblock *o = pt;
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;
}
release_block(o);
free(o);
}
@ -171,8 +164,8 @@ void *Yap_InitTextAllocator(void) {
static size_t MaxTmp(USES_REGS1) {
return ((char *) LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) -
(char *) LOCAL_TextBuffer->ptr;
return ((char *)LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) -
(char *)LOCAL_TextBuffer->ptr;
}
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;
} else {
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)) {
ch = IntegerOfTerm(hd);
@ -262,7 +255,6 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
l = RepPair(*l) + 1;
do_derefa(v, l, derefa2_unk, derefa2_nonvar);
}
}
if (IsVarTerm(*l)) {
@ -279,13 +271,12 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
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;
size_t sz = *lengp = strlen(inp->val.c);
size_t sz = strlen(inp->val.c);
sz *= 2;
int ch;
unsigned char *buf = Malloc(sz + 1), *pt = buf;
*lengp = strlen(inp->val.c);
if (!buf)
return NULL;
while ((ch = *b0++)) {
@ -298,9 +289,8 @@ static unsigned char *latin2utf8(seq_tv_t *inp, size_t *lengp) {
return buf;
}
static unsigned char *wchar2utf8(seq_tv_t *inp, size_t *lengp) {
*lengp = wcslen(inp->val.w);
size_t sz = *lengp * 4;
static unsigned char *wchar2utf8(seq_tv_t *inp) {
size_t sz = wcslen(inp->val.w) * 4;
wchar_t *b0 = inp->val.w;
unsigned char *buf = Malloc(sz + 1), *pt = buf;
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 unsigned char *to_buffer(unsigned char *buf, Term t, seq_tv_t *inp,
bool *widep, Int *atoms,
size_t *lenp USES_REGS) {
bool *widep, Int *atoms USES_REGS) {
CELL *r = NULL;
Int n;
if (!buf) {
inp->max = *lenp;
}
unsigned char *bufc = buf;
if (bufc == NULL) {
bufc = malloc(1024);
}
n = SkipListCodes(&bufc, &t, &r, atoms, widep, inp PASS_REGS);
if (n < 0) {
LOCAL_Error_TYPE = -n;
return NULL;
}
*lenp = n;
return bufc;
}
static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t,
seq_tv_t *inp, bool *widep,
size_t *lenp USES_REGS) {
seq_tv_t *inp,
bool *widep USES_REGS) {
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,
seq_tv_t *inp, bool *widep,
size_t *lenp USES_REGS) {
seq_tv_t *inp,
bool *widep USES_REGS) {
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,
seq_tv_t *inp, bool *widep,
size_t *lenp USES_REGS) {
seq_tv_t *inp, bool *widep USES_REGS) {
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
@ -381,7 +368,7 @@ static yap_error_number gen_type_error(int flags) {
// 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;
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) &&
inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) {
LOCAL_Error_TYPE = TYPE_ERROR_LIST;
} else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t)
&& !IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) {
} else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
!IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) {
LOCAL_Error_TYPE = TYPE_ERROR_TEXT;
}
}
@ -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
// Yap_DebugPlWriteln(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)
return at->UStrOfAE;
size_t sz = strlen(at->StrOfAE);
inp->type |= YAP_STRING_IN_TMP;
char *o = Malloc(sz + 1);
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) {
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(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)
return (unsigned char *) UStringOfTerm(inp->val.t);
return (unsigned char *)UStringOfTerm(inp->val.t);
inp->type |= YAP_STRING_IN_TMP;
size_t sz = strlen(s);
char *o = Malloc(sz + 1);
o = export_block(0, o);
strcpy(o, s);
return (unsigned char *) o;
return (unsigned char *)o;
}
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS)) &&
IsPairOrNilTerm(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
}
if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(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
}
if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(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
}
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
// ASCII, so both LATIN1 and UTF-8
// Yap_DebugPlWriteln(inp->val.t);
char *s;
s = Malloc(0);
s = Malloc(2 * MaxTmp(PASS_REGS1));
if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
IntegerOfTerm(inp->val.t)) < 0) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
}
if (lengp)
*lengp = strlen(s);
return (unsigned char *) s;
return (unsigned char *)s;
}
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
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)) {
return NULL;
}
if (lengp)
*lengp = strlen(s);
return (unsigned char *) s;
return (unsigned char *)s;
}
#if USE_GMP
if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
char *s;
s = Malloc(0);
s = Malloc(MaxTmp());
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) {
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
}
if (lengp)
*lengp = strlen(s);
return inp->val.uc = (unsigned char *) s;
return inp->val.uc = (unsigned char *)s;
}
#endif
if (inp->type & YAP_STRING_TERM) {
// Yap_DebugPlWriteln(inp->val.t);
char *s = (char *) Yap_TermToString(inp->val.t, lengp, ENC_ISO_UTF8, 0);
return inp->val.uc = (unsigned char *) s;
char *s = (char *)Yap_TermToString(inp->val.t, ENC_ISO_UTF8, 0);
return inp->val.uc = (unsigned char *)s;
}
if (inp->type & YAP_STRING_CHARS) {
if (inp->enc == ENC_ISO_LATIN1) {
return latin2utf8(inp, lengp);
return latin2utf8(inp);
} else if (inp->enc == ENC_ISO_ASCII) {
if (lengp)
*lengp = strlen(inp->val.c);
return inp->val.uc;
} else { //if (inp->enc == ENC_ISO_UTF8) {
if (lengp)
*lengp = strlen(inp->val.c);
} else { // if (inp->enc == ENC_ISO_UTF8) {
return inp->val.uc;
}
}
if (inp->type & YAP_STRING_WCHARS) {
// printf("%S\n",inp->val.w);
return wchar2utf8(inp, lengp);
return wchar2utf8(inp);
}
return NULL;
}
static Term write_strings(unsigned char *s0, seq_tv_t *out,
size_t leng USES_REGS) {
size_t min = 0, max = leng;
static Term write_strings(unsigned char *s0, seq_tv_t *out USES_REGS) {
size_t min = 0, max = strlen((char *)s0);
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
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);
LOCAL_TERM_ERROR(t, 2 * max);
unsigned char *buf = buf_from_tstring(HR);
strcpy((char *) buf, s);
strcpy((char *)buf, s);
if (max + 1 < min) {
LOCAL_TERM_ERROR(t, 2 * min);
memset(buf + min, '\0', max);
@ -547,12 +521,13 @@ static Term write_strings(unsigned char *s0, seq_tv_t *out,
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);
char *s1 = (char *)s0;
size_t sz = 0;
size_t max = leng;
if (leng == 0) {
out->val.t = t;
size_t max = strlen(s1);
if (s1[0] == '\0') {
out->val.t = TermNil;
return TermNil;
}
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;
}
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 w[10];
int wp = 0;
@ -598,23 +573,23 @@ static Term write_atoms(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
return (t);
}
static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
Term t = AbsPair(HR);
size_t sz = 0;
size_t max = leng;
if (leng == 0) {
out->val.t = t;
return TermNil;
static Term write_codes(void *s0, seq_tv_t *out USES_REGS) {
Term t;
size_t sz = strlen(s0);
if (sz == 0) {
if (out->type & YAP_STRING_DIFF) {
out->val.t = Globalize(out->dif PASS_REGS);
} else {
out->val.t = TermNil;
}
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
if (out->type & YAP_STRING_TRUNC && out->max < max)
max = out->max;
return out->val.t;
}
unsigned char *s = s0, *lim = s + strlen((char *) s);
unsigned char *s = s0, *lim = s + sz;
unsigned char *cp = s;
t = AbsPair(HR);
LOCAL_TERM_ERROR(t, 2 * (lim - s));
t = AbsPair(HR);
while (*cp) {
utf8proc_int32_t chr;
CELL *cl;
@ -625,28 +600,20 @@ static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
HR += 2;
cl[0] = MkIntegerTerm(chr);
cl[1] = AbsPair(HR);
sz++;
if (sz == max)
break;
}
if (out->type & YAP_STRING_DIFF) {
if (sz == 0)
t = out->dif;
else
if (sz == 0) {
HR[-1] = Globalize(out->dif PASS_REGS);
} else {
if (sz == 0)
t = TermNil;
else
HR[-1] = TermNil;
}
out->val.t = 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;
int32_t ch;
size_t leng = strlen(s0);
if (leng == 0) {
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;
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
out->val.uc = malloc(room_end < 16 ? 16 : room_end);
}
if (out->val.uc != s0) {
strcpy(out->val.c, (char *) s0);
strcpy(out->val.c, (char *)s0);
}
} 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 *cp = s;
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;
} 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;
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;
}
static size_t write_length(const unsigned char *s0, seq_tv_t *out,
size_t leng USES_REGS) {
return leng;
static size_t write_length(const unsigned char *s0, seq_tv_t *out USES_REGS) {
return strlen_utf8(s0);
}
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) {
Term t;
yap_error_number erro = LOCAL_Error_TYPE;
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);
LOCAL_Error_TYPE = erro;
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;
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;
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 */
if (out->type == 0) {
return true;
}
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;
}
if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) {
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);
return true;
@ -775,7 +742,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
return false;
}
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;
if (at && (out->type & YAP_STRING_OUTPUT_TERM))
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) {
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);
return ((Int) room > 0);
return ((Int)room > 0);
}
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);
return ((Int) room > 0);
return ((Int)room > 0);
}
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);
return out->val.t != 0;
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);
return out->val.t != 0;
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);
return out->val.t != 0;
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);
return out->val.l != (size_t) (-1);
return out->val.l != (size_t)(-1);
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);
return out->val.a != NULL;
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);
return out->val.t != 0;
default: {
return true;
}
default: { return true; }
}
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) {
unsigned char *buf;
bool rc;
size_t leng;
/*
f//printfmark(stderr, "[ %d ", n++) ;
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);
*/
// cnt++;
buf = Yap_readText(inp, &leng PASS_REGS);
int l = push_text_stack();
buf = Yap_readText(inp PASS_REGS);
if (!buf) {
pop_text_stack(l);
return 0L;
}
size_t leng = strlen_utf8(buf);
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
if (out->max < leng) {
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;
}
// 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) {
if (!upcase(buf, out)) {
pop_text_stack(l);
return false;
}
}
if (out->type & YAP_STRING_DOWNCASE) {
if (!downcase(buf, out)) {
pop_text_stack(l);
return false;
}
}
}
rc = write_Text(buf, out, leng PASS_REGS);
rc = write_Text(buf, out PASS_REGS);
/* fprintf(stderr, " -> ");
if (!rc) fprintf(stderr, "NULL");
else if (out->type &
@ -910,10 +878,10 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
else
fprintf(stderr, "%s", out->val.c);
fprintf(stderr, "\n]\n"); */
pop_text_stack(l);
return rc;
}
static unsigned char *concat(int n, void *sv[] USES_REGS) {
void *buf;
unsigned char *buf0;
@ -921,16 +889,21 @@ static unsigned char *concat(int n, void *sv[] USES_REGS) {
int 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);
buf0 = buf;
for (i = 0; i < n; i++) {
char *s = sv[i];
if (!s[0])
continue;
#if _WIN32 || defined(__ANDROID__)
strcpy(buf, sv[i]);
strcpy(buf, s);
buf = (char *)buf + strlen(buf);
#else
buf = stpcpy(buf, sv[i]);
buf = stpcpy(buf, s);
#endif
}
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) {
void **bufv;
unsigned char *buf;
int i;
size_t leng;
int i, j;
bufv = Malloc(tot * sizeof(unsigned char *));
if (!bufv) {
return NULL;
}
for (i = 0; i < tot; i++) {
inp[i].type |= YAP_STRING_WITH_BUFFER;
unsigned char *nbuf = Yap_readText(inp + i, &leng PASS_REGS);
for (i = 0, j = 0; i < tot; i++) {
inp[j].type |= YAP_STRING_WITH_BUFFER;
unsigned char *nbuf = Yap_readText(inp + i PASS_REGS);
if (!nbuf) {
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);
bool rc = write_Text(buf, out, strlen_utf8(buf) PASS_REGS);
}
bool rc = write_Text(buf, out PASS_REGS);
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;
inp->type |= YAP_STRING_IN_TMP;
buf = Yap_readText(inp, &b_l PASS_REGS);
buf = Yap_readText(inp PASS_REGS);
if (!buf) {
return false;
}
b_l = strlen((char *)buf);
u_l = strlen_utf8(buf);
if (!cuts) {
if (n == 2) {
@ -996,37 +977,40 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
unsigned char *buf0, *buf1;
if (outv[0].val.t) {
buf0 = Yap_readText(outv, &b_l0 PASS_REGS);
buf0 = Yap_readText(outv PASS_REGS);
if (!buf0) {
return false;
}
b_l0 = strlen((const char *)buf0);
if (bcmp(buf, buf0, b_l0) != 0) {
return false;
}
u_l0 = strlen_utf8(buf0);
u_l1 = u_l - u_l0;
b_l1 = b_l - b_l0;
buf1 = slice(u_l0, u_l, buf PASS_REGS);
b_l1 = strlen((const char *) buf1);
bool rc = write_Text(buf1, outv + 1, b_l1 PASS_REGS);
b_l1 = strlen((const char *)buf1);
bool rc = write_Text(buf1, outv + 1 PASS_REGS);
if (!rc) {
return false;
}
return rc;
} else /* if (outv[1].val.t) */ {
buf1 = Yap_readText(outv + 1, &b_l1 PASS_REGS);
buf1 = Yap_readText(outv + 1 PASS_REGS);
if (!buf1) {
return false;
}
b_l1 = strlen((char *)buf1);
u_l1 = strlen_utf8(buf1);
b_l0 = b_l - b_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) {
return false;
}
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;
}
}
@ -1040,7 +1024,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
if (i > 0 && cuts[i] == 0)
break;
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;
}
}
@ -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
called.
*/
const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) {
CACHE_REGS
const char *Yap_TextTermToText(Term t, char *buf, encoding_t enc USES_REGS) {
seq_tv_t inp, out;
inp.val.t = t;
if (IsAtomTerm(t) && t != TermNil) {
@ -1127,11 +1110,10 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
if (ap->ModuleOfPred == IDB_MODULE) {
if (ap->PredFlags & NumberDBPredFlag) {
Int key = ap->src.IndxId;
snprintf(s, smax - s, "%"
PRIdPTR, key);
snprintf(s, smax - s, "%" PRIdPTR, key);
return LOCAL_FileNameBuf;
} else if (ap->PredFlags & AtomDBPredFlag) {
at = (Atom) (ap->FunctorOfPred);
at = (Atom)(ap->FunctorOfPred);
if (!Yap_AtomToUTF8Text(at, s))
return NULL;
} else {
@ -1144,15 +1126,14 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
if (arity) {
at = NameOfFunctor(ap->FunctorOfPred);
} else {
at = (Atom) (ap->FunctorOfPred);
at = (Atom)(ap->FunctorOfPred);
}
}
if (!Yap_AtomToUTF8Text(at, s)) {
return NULL;
}
s += strlen(s);
snprintf(s, smax - s, "/%"
PRIdPTR, arity);
snprintf(s, smax - s, "/%" PRIdPTR, arity);
return s0;
}
@ -1165,8 +1146,7 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
*
≈ * @return the term
*/
Term Yap_MkTextTerm(const char *s, encoding_t enc, Term tguide) {
CACHE_REGS
Term Yap_MkTextTerm(const char *s, encoding_t enc, Term tguide USES_REGS) {
if (IsAtomTerm(tguide))
return MkAtomTerm(Yap_LookupAtom(s));
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;
}
}
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);
size_t sz;
if (sn == NULL) {

4
C/utilpreds.c
View File

@ -4585,6 +4585,9 @@ renumbervar(Term t, Int id USES_REGS)
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)
{
@ -4604,6 +4607,7 @@ static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end
deref_head(d0, vars_in_term_unk);
vars_in_term_nvar:
{
vsc++;
if (IsPairTerm(d0)) {
if (to_visit + 1024 >= (CELL **)AuxSp) {
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;
wrputf(f, &wglb);
so = Yap_MemExportStreamPtr(sno);
*s = Malloc( strlen(so) )+1;
*s = Malloc( strlen(so)+1 );
strcpy(*s, so );
Yap_CloseStream(sno);
return true;
@ -410,10 +410,10 @@ static void wrputref(CODEADDR ref, int Quote_illegal,
#endif
wrputs(s, stream);
lastw = alphanum;
}
}
/* writes a blob (default) */
static int wrputblob(AtomEntry *ref, int Quote_illegal,
/* writes a blob (default) */
static int wrputblob(AtomEntry *ref, int Quote_illegal,
struct write_globs *wglb) {
wrf stream = wglb->stream;
int rc;
@ -424,10 +424,10 @@ static int wrputblob(AtomEntry *ref, int Quote_illegal,
}
lastw = alphanum;
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;
if (ch == '\0')
@ -461,11 +461,11 @@ static int legalAtom(unsigned char *s) /* Is this a legal atom ? */
if (Yap_chtype[ch] > NU)
return false;
return true;
}
}
static wtype
AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
{
static wtype
AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
{
int ch;
if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0')
return (separator);
@ -474,9 +474,9 @@ AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */
return alphanum;
}
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
if (!(Yap_GetModuleEntry(CurrentModule)->flags & M_CHARESCAPE)) {
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 */
{
{
StreamDesc *stream = wglb->stream;
utf8proc_int32_t chr, qt;
unsigned char *ptr = (unsigned char *)s;
@ -575,10 +575,10 @@ static void write_string(const unsigned char *s,
write_quoted(chr, qt, stream);
} while (true);
wrputc(qt, stream);
}
}
/* writes an atom */
static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
/* writes an atom */
static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
unsigned char *s;
wtype atom_or_symbol;
wrf stream = wglb->stream;
@ -615,17 +615,17 @@ static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) {
} else {
wrputs((char *)s, stream);
}
}
}
void Yap_WriteAtom(StreamDesc *s, Atom atom) {
void Yap_WriteAtom(StreamDesc *s, Atom atom) {
struct write_globs wglb;
wglb.stream = s;
wglb.Quote_illegal = FALSE;
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))
return FALSE;
do {
@ -647,12 +647,12 @@ static int IsCodesTerm(Term string) /* checks whether this is a string */
return (FALSE);
} while (string != TermNil);
return (TRUE);
}
}
/* writes a string */
static void putString(Term string, struct write_globs *wglb)
/* writes a string */
static void putString(Term string, struct write_globs *wglb)
{
{
wrf stream = wglb->stream;
wrputc('"', stream);
while (string != TermNil) {
@ -662,12 +662,12 @@ static void putString(Term string, struct write_globs *wglb)
}
wrputc('"', stream);
lastw = alphanum;
}
}
/* writes a string */
static void putUnquotedString(Term string, struct write_globs *wglb)
/* writes a string */
static void putUnquotedString(Term string, struct write_globs *wglb)
{
{
wrf stream = wglb->stream;
while (string != TermNil) {
int ch = IntOfTerm(HeadOfTerm(string));
@ -675,9 +675,9 @@ static void putUnquotedString(Term string, struct write_globs *wglb)
string = TailOfTerm(string);
}
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) {
CACHE_REGS
Term t;
@ -713,9 +713,9 @@ static Term from_pointer(CELL *ptr0, struct rewind_term *rwt,
}
}
return t;
}
}
static CELL *restore_from_write(struct rewind_term *rwt,
static CELL *restore_from_write(struct rewind_term *rwt,
struct write_globs *wglb) {
CACHE_REGS
CELL *ptr;
@ -729,10 +729,10 @@ static CELL *restore_from_write(struct rewind_term *rwt,
}
rwt->u_sd.s.ptr = 0;
return ptr;
}
}
/* writes an unbound variable */
static void write_var(CELL *t, struct write_globs *wglb,
/* writes an unbound variable */
static void write_var(CELL *t, struct write_globs *wglb,
struct rewind_term *rwt) {
CACHE_REGS
if (lastw == alphanum) {
@ -773,9 +773,9 @@ static void write_var(CELL *t, struct write_globs *wglb,
} else {
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) {
CACHE_REGS
if (wglb->Keep_terms) {
@ -792,9 +792,9 @@ static Term check_infinite_loop(Term t, struct rewind_term *x,
}
}
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) {
Term ti;
struct rewind_term nrwt;
@ -867,14 +867,14 @@ static void write_list(Term t, int direction, int depth,
wglb, &nrwt);
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)
/* term to write */
/* context priority */
/* term to write */
/* context priority */
{
{
CACHE_REGS
struct rewind_term nrwt;
nrwt.parent = rwt;
@ -1203,14 +1203,14 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
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)
/* term to be written */
/* consumer */
/* write options */
{
/* term to be written */
/* consumer */
/* write options */
{
CACHE_REGS
struct write_globs wglb;
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);
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
int sno = Yap_open_buf_write_stream(enc, flags);
const char *sf;
@ -1278,4 +1278,4 @@ char *Yap_TermToString(Term t, size_t *lengthp, encoding_t enc, int flags) {
if (e)
LOCAL_BallTerm = e;
return new;
}
}

12
CXX/yapi.cpp
View File

@ -12,18 +12,18 @@ extern "C" {
#include "YapInterface.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);
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_UserCPredicate(const char *, YAP_UserCPred, arity_t arity);
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t,
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);
#if YAP_PYTHON
#if YAP_PYTHON
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
virtual const char *text() {
CACHE_REGS
size_t length = 0;
encoding_t enc = LOCAL_encoding;
char *os;
BACKUP_MACHINE_REGS();
if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc,
if (!(os = Yap_TermToString(Yap_GetFromSlot(t), enc,
Handle_vars_f))) {
RECOVER_MACHINE_REGS();
return 0;
}
RECOVER_MACHINE_REGS();
length = strlen(os) + 1;
size_t length = strlen(os);
char *sm = (char *)malloc(length + 1);
strcpy(sm, os);
return sm;

381
H/YapText.h
View File

@ -1,19 +1,19 @@
/*************************************************************************
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: YapMirror.c *
* Last rev: 5/2/88 *
* mods: *
* comments: Term conversion C implemented support *
* *
*************************************************************************/
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: YapMirror.c *
* Last rev: 5/2/88 *
* mods: *
* comments: Term conversion C implemented support *
* *
*************************************************************************/
#ifndef YAP_TEXT_H
#define YAP_TEXT_H
@ -47,7 +47,6 @@
cut_succeed(); \
}
/// allocate a temporary text block
///
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 pop_text_stack(int lvl USES_REGS);
extern void *protected_pop_text_stack(int lvl, void *safe, bool tmp,
size_t sz USES_REGS);
extern void *export_block(int lvl, void *exp USES_REGS);
#ifndef Yap_Min
#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_ssize_t rc = utf8proc_iterate(ptr, n, valp);
if (rc < 0) {
if (rc == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("get_utf8 found bad UTF-8 char %s, skipping...", ptr);
else Yap_Warning("UTF-8 error %d, skipping...", *ptr);
if (rc == UTF8PROC_ERROR_INVALIDUTF8)
Yap_Warning("get_utf8 found bad UTF-8 char %s, skipping...", ptr);
else
Yap_Warning("UTF-8 error %d, skipping...", *ptr);
rc = 1;
}
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,
utf8proc_int32_t val) {
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;
}
@ -213,8 +214,11 @@ inline static const utf8proc_uint8_t *skip_utf8(const utf8proc_uint8_t *pt,
if (b == 0)
return pt;
if (l < 0) {
if (l == UTF8PROC_ERROR_INVALIDUTF8) 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);
if (l == UTF8PROC_ERROR_INVALIDUTF8)
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;
}
pt += l;
@ -237,8 +241,10 @@ inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) {
pt += l;
rc++;
} else {
if (l == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("found bad UTF-8 char %d, skipping %s...", *pt, pt);
else Yap_Warning("UTF-8 error %d, skipping...", l);
if (l == UTF8PROC_ERROR_INVALIDUTF8)
Yap_Warning("found bad UTF-8 char %d, skipping %s...", *pt, pt);
else
Yap_Warning("UTF-8 error %d, skipping...", l);
pt++;
}
}
@ -451,9 +457,8 @@ static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
// the routines
extern unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp USES_REGS);
extern bool write_Text(unsigned char *inp, seq_tv_t *out,
size_t leng USES_REGS);
extern unsigned char *Yap_readText(seq_tv_t *inp USES_REGS);
extern bool write_Text(unsigned char *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_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 |
YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
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))
return 0L;
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);
}
static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) {
static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) {
if (!IsAtomTerm(t0)) {
return -TYPE_ERROR_ATOM;
}
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;
inp.val.t = t0;
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))
return 0L;
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;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
inp.val.a = at;
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))
return NIL;
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;
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))
return 0L;
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;
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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) {
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))
return 0L;
return out.val.t;
}
}
static inline Term Yap_UTF8ToDiffListOfCodes(const char *s,
static inline Term Yap_UTF8ToDiffListOfCodes(const char *s,
Term tail USES_REGS) {
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))
return 0L;
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) {
seq_tv_t inp, out;
@ -858,9 +863,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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;
inp.val.t = t0;
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))
return (Atom)NULL;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return (Atom)NULL;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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;
inp.val.t = t0;
inp.type =
@ -1191,9 +1196,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L;
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;
inp.val.t = t0;
inp.type =
@ -1202,9 +1207,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L;
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;
inp.val.t = t0;
inp.type =
@ -1213,9 +1218,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L;
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;
inp.val.t = t0;
inp.type =
@ -1224,9 +1229,9 @@ static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L;
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;
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))
return 0L;
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) {
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))
return 0L;
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) {
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))
return 0L;
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;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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)) {
return -TYPE_ERROR_STRING;
}
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
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))
return 0L;
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;
inp.val.t = t0;
inp.type = YAP_STRING_STRING;
out.type =
YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
out.val.uc = NULL;
out.enc = ENC_ISO_UTF8;
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
while (*s) {
// 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);
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;
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))
return 0L;
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);
}
}
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;
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))
return 0L;
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;
inp.val.w0 = s;
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))
return 0L;
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;
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))
return 0L;
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;
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))
return 0L;
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;
inp.val.w0 = s;
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))
return 0L;
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;
inpv[0].val.t = t1;
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))
return (Atom)NULL;
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;
inpv[0].val.t = t1;
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))
return (Atom)NULL;
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;
inpv[0].val.t = t1;
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))
return 0L;
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) {
seq_tv_t outv[2], inp;
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[1] = outv[1].val.a;
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;
inp.type = YAP_STRING_ATOM;
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))
return (Atom)NULL;
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;
inp.type = YAP_STRING_ATOM;
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))
return (Atom)NULL;
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) {
seq_tv_t outv[2], inp;
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[1] = outv[1].val.t;
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;
inp.type = YAP_STRING_STRING;
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))
return 0L;
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;
inp.type = YAP_STRING_STRING;
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))
return 0L;
return outv[0].val.t;
}
}
#endif // ≈YAP_TEXT_H
const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc);
Term Yap_MkTextTerm(const char *s, encoding_t e, Term tguide);
const char *Yap_TextTermToText(Term t, char *bufwrite_Text,
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
*
* @addtogroup swi-c-interface
*
* @{
*/
*
* @file swi.c
*
* @addtogroup swi-c-interface
*
* @{
*/
#define PL_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
* @ingroup swi-c-interface
* */
* @ingroup swi-c-interface
* */
static UInt cvtFlags(unsigned flags) {
UInt inptype = 0;
@ -156,8 +156,8 @@ static UInt cvtFlags(unsigned flags) {
/* void PL_agc_hook(void) */
/** @brief Atom garbage collection hook
*
*/
*
*/
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);
}
@ -227,9 +227,7 @@ X_API int PL_get_nchars(term_t l, size_t *lengthp, char **s, unsigned flags) {
pop_text_stack(lvl);
return false;
}
out.val.c = protected_pop_text_stack(lvl, out.val.c,
flags & (BUF_RING | BUF_DISCARDABLE),
strlen(out.val.c) + 1 PASS_REGS);
out.val.c = export_block(-1, out.val.c PASS_REGS);
*s = out.val.c;
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
*
*/
*
*/
X_API char *PL_atom_chars(atom_t a) /* SAM check type */
{
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
*
*/
*
*/
X_API char *PL_atom_nchars(atom_t a, size_t *len) /* SAM check type */
{
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
* @ingroup swi-c-interface
* */
*
* @defgroup swi-term_references Term References
* @ingroup swi-c-interface
* */
/** @brief create a clean term reference
*
*/
*
*/
X_API term_t PL_new_term_ref(void) {
CACHE_REGS
term_t to = Yap_NewSlots(1);
@ -324,17 +322,17 @@ X_API term_t PL_new_term_ref(void) {
}
/** @brief duplicate a term reference
*
*/
*
*/
X_API term_t PL_copy_term_ref(term_t from) {
CACHE_REGS
return Yap_InitSlot(Yap_GetFromSlot(from));
}
/** @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) {
CACHE_REGS
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
*
*/
*
*/
X_API void PL_reset_term_refs(term_t after) {
CACHE_REGS
LOCAL_CurSlot = after;
}
/** @}
*/
*/
//! @{
/** @defgroup swi-term_manipulation Term Manipulation
* @ingroup swi-c-interface
* */
* @ingroup swi-c-interface
* */
/**
* @defgroup swi-get-operations Reading Terms
* @ingroup swi-term_manipulation
* */
* @defgroup swi-get-operations Reading Terms
* @ingroup swi-term_manipulation
* */
/** @brief *name is assigned the name and *arity the arity if term ts, or the
* operaton fails.
*
*/
*
*/
X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity) {
CACHE_REGS
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
*
*/
*
*/
X_API int PL_get_arg(int index, term_t ts, term_t a) {
CACHE_REGS
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
*
*/
*
*/
X_API int PL_get_compound_name_arity(term_t ts, atom_t *ap, int *ip) {
CACHE_REGS
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
*
*/
*
*/
X_API int PL_get_atom(term_t ts, atom_t *a) {
CACHE_REGS
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
*
*/
*
*/
/* int PL_get_integer(term_t t, int *i)
YAP: long int YAP_IntOfTerm(Term) */
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
* operation fails
*
*/
*
*/
X_API int PL_get_long(term_t ts, long *i) {
CACHE_REGS
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
*
*/
*
*/
X_API int PL_get_int64(term_t ts, int64_t *i) {
CACHE_REGS
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); }
/** @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) {
CACHE_REGS
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
*
*/
*
*/
X_API int PL_get_uintptr(term_t ts, uintptr_t *a) {
CACHE_REGS
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
/** @brief a is assigned the argument index from term ts
*
*/
*
*/
X_API int _PL_get_arg(int index, term_t ts, term_t a) {
CACHE_REGS
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
* the operation fails
*
*/
*
*/
X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */
{
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
* *len its size, or the operation fails
*
*/
*
*/
X_API int PL_get_atom_nchars(term_t ts, size_t *len,
char **s) /* SAM check type */
{
@ -656,10 +654,10 @@ X_API int PL_get_atom_nchars(term_t ts, size_t *len,
return 0;
}
if (s)
*s = (char*)RepAtom(AtomOfTerm(t))->StrOfAE;
*s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE;
if (len) {
*len = strlen(*s);
}
}
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
*
*/
*
*/
X_API int PL_get_functor(term_t ts, functor_t *f) {
CACHE_REGS
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
* operation fails
*
*/
*
*/
X_API int PL_get_float(term_t ts, double *f) /* SAM type check*/
{
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,
* and *len its size, or the operation fails
*
*/
*
*/
X_API int PL_get_string(term_t t, char **s, size_t *len) {
CACHE_REGS
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
* operation fails
*
*/
*
*/
X_API int PL_get_list(term_t ts, term_t h, term_t tl) {
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
*
*/
*
*/
X_API int PL_get_head(term_t ts, term_t h) {
CACHE_REGS
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.
*
*/
*
*/
X_API int PL_unify_bool(term_t t, int a) {
CACHE_REGS
Term iterm = (a ? MkAtomTerm(AtomTrue) : MkAtomTerm(AtomFalse));
@ -813,7 +811,7 @@ X_API int PL_unify_bool(term_t t, int a) {
/*******************************
* GMP *
*******************************/
*******************************/
X_API int PL_get_mpz(term_t t, mpz_t mpz) {
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)
*/
*/
X_API int PL_unify_wchars(term_t t, int type, size_t len,
const pl_wchar_t *chars) {
CACHE_REGS
@ -1786,7 +1784,8 @@ int PL_unify_termv(term_t l, va_list ap) {
Term t = Yap_MkNewApplTerm(ff, arity);
if (nels) {
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);
return FALSE;
@ -2525,7 +2524,8 @@ X_API void PL_register_foreign_in_module(const char *module, const char *name,
#ifdef DEBUG
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",
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);
len -= (szl + 1);
}
return Yap_TextTermToText(t, buf, len, enc);
return Yap_TextTermToText(t, buf, enc);
}
static Int file_name_extension(USES_REGS1) {
@ -78,8 +78,7 @@ static Int file_name_extension(USES_REGS1) {
Yap_unify(t2, t);
} else {
f2 = ss + (strlen(ss) + 1);
if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 1 - (f2 - f),
ENC_ISO_UTF8))
if (!Yap_TextTermToText(t2, f2, ENC_ISO_UTF8))
return false;
#if __APPLE__ || _WIN32
Yap_OverwriteUTF8BufferToLowCase(f2);
@ -113,12 +112,11 @@ static Int file_name_extension(USES_REGS1) {
return true;
} else {
char *f2;
if (!Yap_TextTermToText(t1, f, YAP_FILENAME_MAX - 2, ENC_ISO_UTF8)) {
if (!Yap_TextTermToText(t1, f, ENC_ISO_UTF8)) {
return false;
}
f2 = f + strlen(f);
if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 2 - (f2 - f),
ENC_ISO_UTF8)) {
if (!Yap_TextTermToText(t2, f2, ENC_ISO_UTF8)) {
return false;
}
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");
return false;
}
const char *buf = Yap_TextTermToText(t, NULL, 0, LOCAL_encoding);
const char *buf = Yap_TextTermToText(t, NULL, LOCAL_encoding);
if (buf) {
rc = Yap_IsAbsolutePath(buf);
} else {

54
os/fmem.c
View File

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

4
os/format.h
View File

@ -1,8 +1,10 @@
#define FORMAT_MAX_SIZE 1024
#include <Yap.h>
typedef struct {
Int filler;
intptr_t filler;
/* character to dump */
int phys;
/* 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->linepos = 0;
s->linecount = 1;
s->charcount = 0.;
s->charcount = 0;
s->vfs = vfsp;
s->encoding = ENC_ISO_UTF8;
INIT_LOCK(s->streamlock);
@ -306,7 +306,7 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) {
}
} else {
unix_upd_stream_info(s);
}
}
/* Getting streams to prompt is a mess because we need for cooperation
between readers and writers to the stream :-(
*/

68
os/readterm.c
View File

@ -286,7 +286,7 @@ form:
+ symbols, including `(`, `)`, `,`, `;`
*/
static Int scan_to_list(USES_ARGS1) {
static Int scan_to_list(USES_REGS1) {
int inp_stream;
Term tpos, tout;
@ -1350,18 +1350,18 @@ static Int style_checker(USES_REGS1) {
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;
int sno;
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);
Yap_CloseStream(sno);
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 bindings) {
CACHE_REGS
@ -1374,10 +1374,10 @@ X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len,
if (prio != 1200) {
ctl = add_priority(bindings, ctl);
}
return Yap_BufferToTerm(s, len, ctl);
}
return Yap_BufferToTerm(s, ctl);
}
/**
/**
* @pred read_term_from_atom( +Atom , -T , +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
* 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);
Atom at;
const unsigned char *s;
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "style_check/1");
@ -1408,14 +1407,13 @@ static Int read_term_from_atom(USES_REGS1) {
} else {
at = AtomOfTerm(t1);
s = at->UStrOfAE;
len = strlen_utf8(s);
}
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 )
*
* read a term _T_ stored in text _Atomic_ according to _Options_
@ -1430,10 +1428,10 @@ static Int read_term_from_atom(USES_REGS1) {
*atom.
* 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);
const unsigned char *s;
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_atomic/3");
return (FALSE);
@ -1443,14 +1441,13 @@ static Int read_term_from_atomic(USES_REGS1) {
} else {
Term t = Yap_AtomicToString(t1 PASS_REGS);
s = UStringOfTerm(t);
len = strlen_utf8(s);
}
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 )
*
* 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
* 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;
const unsigned char *s;
size_t len;
@ -1484,11 +1481,10 @@ static Int read_term_from_string(USES_REGS1) {
if (!rc)
return false;
return Yap_unify(rc, ARG2);
}
}
static Int atomic_to_term(USES_REGS1) {
static Int atomic_to_term(USES_REGS1) {
Term t1 = Deref(ARG1);
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE);
@ -1498,15 +1494,13 @@ static Int atomic_to_term(USES_REGS1) {
} else {
Term t = Yap_AtomicToString(t1 PASS_REGS);
const unsigned char *us = UStringOfTerm(t);
len = strlen_utf8(us);
return Yap_BufferToTerm(us, len,
return Yap_BufferToTerm(us,
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);
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE);
@ -1516,15 +1510,14 @@ static Int atom_to_term(USES_REGS1) {
} else {
Term t = Yap_AtomicToString(t1 PASS_REGS);
const unsigned char *us = UStringOfTerm(t);
len = strlen_utf8(us);
return Yap_BufferToTerm(us, len,
return Yap_BufferToTerm(us,
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);
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE);
@ -1533,13 +1526,12 @@ static Int string_to_term(USES_REGS1) {
return (FALSE);
} else {
const unsigned char *us = UStringOfTerm(t1);
len = strlen_utf8(us);
return Yap_BufferToTerm(us, len,
return Yap_BufferToTerm(us,
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", 3, read_term, SyncPredFlag);
@ -1560,4 +1552,4 @@ void Yap_InitReadTPreds(void) {
Yap_InitCPred("source_location", 2, source_location, SyncPredFlag);
Yap_InitCPred("$style_checker", 1, style_checker,
SyncPredFlag | HiddenPredFlag);
}
}

53
os/sysbits.c
View File

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

41
os/writeterm.c
View File

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

38
os/yapio.h
View File

@ -1,19 +1,18 @@
/*************************************************************************
* *
* YAP Prolog %W% %G%
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 *
* *
**************************************************************************
* *
* File: yapio.h *
* Last rev: 22/1/03 *
* mods: *
* comments: Input/Output information *
* *
*************************************************************************/
* *
* YAP Prolog %W% %G%
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 *
* *
**************************************************************************
* *
* File: yapio.h * Last
*rev: 22/1/03 * mods:
** comments: Input/Output information *
* *
*************************************************************************/
#ifndef YAPIO_H
@ -78,8 +77,7 @@ extern int Yap_PlFGetchar(void);
extern int Yap_GetCharForSIGINT(void);
extern Int Yap_StreamToFileNo(Term);
extern int Yap_OpenStream(FILE *, char *, Term, int);
extern char *Yap_TermToString(Term t, size_t *length, encoding_t encoding,
int flags);
extern char *Yap_TermToString(Term t, encoding_t encoding, int flags);
extern char *Yap_HandleToString(yhandle_t l, size_t sz, size_t *length,
encoding_t *encoding, int flags);
extern int Yap_GetFreeStreamD(void);
@ -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_open_buf_read_stream(const char *buf, size_t nchars,
encoding_t *encp, memBufSource src);
extern bool Yap_set_stream_to_buf(struct stream_desc *st, const char *buf, encoding_t enc,
size_t nchars);
extern bool Yap_set_stream_to_buf(struct stream_desc *st, const char *buf,
encoding_t enc, size_t nchars);
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,
size_t sz, Term opts,
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')
dest = os.path.join(here, 'resources')
if os.path.exists(dest):
try:
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})
shutil.copy('${CMAKE_CURRENT_SOURCE_DIR}/kernel.js',dest)
shutil.copy('${CMAKE_SOURCE_DIR}/misc/editors/prolog.js',dest)
shutil.copy('${CMAKE_SOURCE_DIR}/docs/icons/yap_32x32x32.png',os.path.join(dest,'logo-32x32.png'))
shutil.copy('${CMAKE_SOURCE_DIR}/docs/icons/yap_64x64x32.png',os.path.join(dest,'logo-64x64.png'))
except:
pass
# shutil.copy('${CMAKE_CURRENT_SOURCE_DIR}/kernel.js',dest)
# shutil.copy('${CMAKE_SOURCE_DIR}/misc/editors/prolog.js',dest)
setup_args['data_files'] = [
(pjoin('share', 'jupyter', 'kernels', KERNEL_NAME), glob(pjoin(dest, '*'))),
]
mode_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'components', 'codemirror', 'mode', 'prolog')
custom_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'custom')
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)
shutil.copy( "${CMAKE_SOURCE_DIR}/misc/editors/prolog.js" , mode_loc)
except:
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'] = {
'test:python_version=="2.7"': ['mock'],