Merge ssh://ssh.dcc.fc.up.pt:31064/home/vsc/yap
This commit is contained in:
Vitor Santos Costa
commit
069fcc875c
32
C/adtdefs.c
32
C/adtdefs.c
@ -147,6 +147,32 @@ static inline Atom SearchAtom(const unsigned char *p, Atom a) {
|
||||
return (NIL);
|
||||
}
|
||||
|
||||
Atom
|
||||
Yap_AtomInUse(const char *atom) { /* lookup atom in atom table */
|
||||
uint64_t hash;
|
||||
const unsigned char *p;
|
||||
Atom a, na = NIL;
|
||||
AtomEntry *ae;
|
||||
size_t sz = AtomHashTableSize;
|
||||
|
||||
/* compute hash */
|
||||
p =( const unsigned char *) atom;
|
||||
|
||||
hash = HashFunction(p);
|
||||
hash = hash % sz;
|
||||
/* we'll start by holding a read lock in order to avoid contention */
|
||||
READ_LOCK(HashChain[hash].AERWLock);
|
||||
a = HashChain[hash].Entry;
|
||||
/* search atom in chain */
|
||||
na = SearchAtom(p, a);
|
||||
ae = RepAtom(na);
|
||||
if (na != NIL ) {
|
||||
READ_UNLOCK(HashChain[hash].AERWLock);
|
||||
return (na);
|
||||
}
|
||||
READ_UNLOCK(HashChain[hash].AERWLock);
|
||||
return NIL;
|
||||
}
|
||||
|
||||
static Atom
|
||||
LookupAtom(const unsigned char *atom) { /* lookup atom in atom table */
|
||||
@ -221,7 +247,7 @@ Atom Yap_LookupAtomWithLength(const char *atom,
|
||||
ptr = Yap_AllocCodeSpace(len0 + 1);
|
||||
if (!ptr)
|
||||
return NIL;
|
||||
memcpy(ptr, atom, len0);
|
||||
memmove(ptr, atom, len0);
|
||||
ptr[len0] = '\0';
|
||||
at = LookupAtom(ptr);
|
||||
Yap_FreeCodeSpace(ptr);
|
||||
@ -1010,7 +1036,7 @@ Atom Yap_LookupAtomWithLength(const char *atom,
|
||||
if (IsApplTerm(t0)) {
|
||||
Yap_FreeCodeSpace((char *)RepAppl(t0));
|
||||
}
|
||||
memcpy((void *)pt, (void *)ap, sz);
|
||||
memmove((void *)pt, (void *)ap, sz);
|
||||
p->ValueOfVE = AbsAppl(pt);
|
||||
#endif
|
||||
} else if (IsStringTerm(v)) {
|
||||
@ -1025,7 +1051,7 @@ Atom Yap_LookupAtomWithLength(const char *atom,
|
||||
if (IsApplTerm(t0)) {
|
||||
Yap_FreeCodeSpace((char *)RepAppl(t0));
|
||||
}
|
||||
memcpy((void *)pt, (void *)ap, sz);
|
||||
memmove((void *)pt, (void *)ap, sz);
|
||||
p->ValueOfVE = AbsAppl(pt);
|
||||
} else {
|
||||
if (IsApplTerm(t0)) {
|
||||
|
||||
@ -216,7 +216,7 @@ Atom Yap_LookupAtomWithLength(const char *atom,
|
||||
ptr = Yap_AllocCodeSpace(len0 + 1);
|
||||
if (!ptr)
|
||||
return NIL;
|
||||
memcpy(ptr, atom, len0);
|
||||
memmove(ptr, atom, len0);
|
||||
ptr[len0] = '\0';
|
||||
at = LookupAtom(ptr);
|
||||
Yap_FreeCodeSpace(ptr);
|
||||
@ -1004,7 +1004,7 @@ void Yap_PutValue(Atom a, Term v) {
|
||||
if (IsApplTerm(t0)) {
|
||||
Yap_FreeCodeSpace((char *)RepAppl(t0));
|
||||
}
|
||||
memcpy((void *)pt, (void *)ap, sz);
|
||||
memmove((void *)pt, (void *)ap, sz);
|
||||
p->ValueOfVE = AbsAppl(pt);
|
||||
#endif
|
||||
} else if (IsStringTerm(v)) {
|
||||
@ -1019,7 +1019,7 @@ void Yap_PutValue(Atom a, Term v) {
|
||||
if (IsApplTerm(t0)) {
|
||||
Yap_FreeCodeSpace((char *)RepAppl(t0));
|
||||
}
|
||||
memcpy((void *)pt, (void *)ap, sz);
|
||||
memmove((void *)pt, (void *)ap, sz);
|
||||
p->ValueOfVE = AbsAppl(pt);
|
||||
} else {
|
||||
if (IsApplTerm(t0)) {
|
||||
|
||||
@ -1329,7 +1329,7 @@ XX realloc(MALLOC_T ptr, size_t size) {
|
||||
MALLOC_T new = malloc(size);
|
||||
|
||||
if (ptr)
|
||||
memcpy(new, ptr, size);
|
||||
memmove(new, ptr, size);
|
||||
free(ptr);
|
||||
return (new);
|
||||
}
|
||||
|
||||
33
C/atomic.c
33
C/atomic.c
@ -588,13 +588,25 @@ restart_aux:
|
||||
}
|
||||
}
|
||||
|
||||
/** @pred atom_codes(?A, ?L) is iso
|
||||
|
||||
|
||||
The predicate holds when at least one of the arguments is
|
||||
ground (otherwise, YAP will generate an error event. _A_ must be unifiable
|
||||
with an atom, and the argument _L_ with the list of the character codes for
|
||||
string _A_.
|
||||
|
||||
|
||||
*/
|
||||
static Int atom_codes(USES_REGS1) {
|
||||
Term t1;
|
||||
t1 = Deref(ARG1);
|
||||
LOCAL_MAX_SIZE = 1024;
|
||||
int l = push_text_stack();
|
||||
|
||||
restart_aux:
|
||||
t1 = Deref(ARG1);
|
||||
if (IsAtomTerm(t1)) {
|
||||
Term tf = Yap_AtomToListOfCodes(t1 PASS_REGS);
|
||||
Term tf = Yap_AtomSWIToListOfCodes(t1 PASS_REGS);
|
||||
if (tf) {
|
||||
pop_text_stack(l);
|
||||
return Yap_unify(ARG2, tf);
|
||||
@ -602,17 +614,16 @@ restart_aux:
|
||||
} else if (IsVarTerm(t1)) {
|
||||
/* ARG1 unbound */
|
||||
Term t = Deref(ARG2);
|
||||
Atom af = Yap_ListToAtom(t PASS_REGS);
|
||||
Atom af = Yap_ListOfCodesToAtom(t PASS_REGS);
|
||||
if (af) {
|
||||
pop_text_stack(l);
|
||||
return Yap_unify(ARG1, MkAtomTerm(af));
|
||||
}
|
||||
} else if (IsVarTerm(t1)) {
|
||||
LOCAL_Error_TYPE = TYPE_ERROR_ATOM;
|
||||
}
|
||||
/* error handling */
|
||||
} else {
|
||||
Yap_ThrowError(TYPE_ERROR_ATOM, t1, NULL);
|
||||
}
|
||||
if (LOCAL_Error_TYPE && Yap_HandleError("atom_codes/2")) {
|
||||
t1 = Deref(ARG1);
|
||||
goto restart_aux;
|
||||
}
|
||||
{
|
||||
@ -1455,9 +1466,7 @@ error:
|
||||
if (LOCAL_Error_TYPE && Yap_HandleError("atom_concat/3")) {
|
||||
goto restart_aux;
|
||||
}
|
||||
{
|
||||
return FALSE;
|
||||
}
|
||||
{ return FALSE; }
|
||||
}
|
||||
|
||||
static Int atomics_to_string2(USES_REGS1) {
|
||||
@ -2070,7 +2079,7 @@ static Int atom_split(USES_REGS1) {
|
||||
}
|
||||
size_t b_mid = skip_utf8(s0, u_mid) - s0;
|
||||
s1 = s10 = Malloc(b_mid + 1);
|
||||
memcpy(s1, s, b_mid);
|
||||
memmove(s1, s, b_mid);
|
||||
s1[b_mid] = '\0';
|
||||
to1 = MkAtomTerm(Yap_ULookupAtom(s10));
|
||||
to2 = MkAtomTerm(Yap_ULookupAtom(s0 + b_mid));
|
||||
@ -2756,6 +2765,8 @@ void Yap_InitAtomPreds(void) {
|
||||
Yap_InitCPred("downcase_atom", 2, downcase_text_to_atom, 0);
|
||||
Yap_InitCPred("upcase_text_to_atom", 2, upcase_text_to_atom, 0);
|
||||
Yap_InitCPred("upcase_atom", 2, upcase_text_to_atom, 0);
|
||||
Yap_InitCPred("text_to_string", 2, downcase_text_to_string, 0);
|
||||
Yap_InitCPred("text_to_atom", 2, downcase_text_to_string, 0);
|
||||
Yap_InitCPred("downcase_text_to_string", 2, downcase_text_to_string, 0);
|
||||
Yap_InitCPred("upcase_text_to_string", 2, upcase_text_to_string, 0);
|
||||
Yap_InitCPred("downcase_text_to_codes", 2, downcase_text_to_codes, 0);
|
||||
|
||||
@ -48,7 +48,7 @@ char *Yap_blob_to_string(AtomEntry *ref, const char *s0, size_t sz) {
|
||||
size_t sz0 = strlcpy(s, (char *)RepAtom(AtomSWIStream)->StrOfAE, sz);
|
||||
#else
|
||||
size_t sz0;
|
||||
char *f = (char *)memcpy(s, (char *)RepAtom(AtomSWIStream)->StrOfAE, sz);
|
||||
char *f = (char *)memmove(s, (char *)RepAtom(AtomSWIStream)->StrOfAE, sz);
|
||||
f[0] = '\0';
|
||||
sz0 = f - s;
|
||||
#endif
|
||||
@ -156,7 +156,7 @@ AtomEntry *Yap_lookupBlob(void *blob, size_t len, void *type0, int *new) {
|
||||
ae->PropsOfAE = AbsBlobProp(b);
|
||||
ae->NextOfAE = AbsAtom(Blobs);
|
||||
ae->rep.blob->length = len;
|
||||
memcpy(ae->rep.blob->data, blob, len);
|
||||
memmove(ae->rep.blob->data, blob, len);
|
||||
Blobs = ae;
|
||||
if (NOfBlobs > NOfBlobsMax) {
|
||||
Yap_signal(YAP_CDOVF_SIGNAL);
|
||||
|
||||
@ -297,6 +297,16 @@ X_API Term YAP_MkStringTerm(const char *n) {
|
||||
return I;
|
||||
}
|
||||
|
||||
X_API Term YAP_MkCharPTerm( char *n) {
|
||||
CACHE_REGS
|
||||
Term I;
|
||||
BACKUP_H();
|
||||
|
||||
I = MkStringTerm(n);
|
||||
RECOVER_H();
|
||||
return I;
|
||||
}
|
||||
|
||||
X_API Term YAP_MkUnsignedStringTerm(const unsigned char *n) {
|
||||
CACHE_REGS
|
||||
Term I;
|
||||
@ -1898,7 +1908,7 @@ X_API YAP_opaque_tag_t YAP_NewOpaqueType(struct YAP_opaque_handler_struct *f) {
|
||||
return -1;
|
||||
}
|
||||
i = GLOBAL_OpaqueHandlersCount++;
|
||||
memcpy(GLOBAL_OpaqueHandlers + i, f, sizeof(YAP_opaque_handler_t));
|
||||
memmove(GLOBAL_OpaqueHandlers + i, f, sizeof(YAP_opaque_handler_t));
|
||||
return i;
|
||||
}
|
||||
|
||||
@ -2129,20 +2139,16 @@ X_API int YAP_InitConsult(int mode, const char *fname, char **full, int *osnop)
|
||||
char *d = Malloc(strlen(fl)+1);
|
||||
strcpy(d,fl);
|
||||
bool consulted = (mode == YAP_CONSULT_MODE);
|
||||
sno = Yap_OpenStream(MkStringTerm(fl), "r", MkAtomTerm(Yap_LookupAtom(fl)), LOCAL_encoding);
|
||||
Term tat = MkAtomTerm(Yap_LookupAtom(d));
|
||||
sno = Yap_OpenStream(tat, "r", MkAtomTerm(Yap_LookupAtom(fname)), LOCAL_encoding);
|
||||
if (sno < 0 ||
|
||||
!Yap_ChDir(dirname((char *)d))) {
|
||||
pop_text_stack(lvl);
|
||||
*full = NULL;
|
||||
return -1;
|
||||
}
|
||||
LOCAL_PrologMode = UserMode;
|
||||
} LOCAL_PrologMode = UserMode;
|
||||
|
||||
Yap_init_consult(consulted, fl);
|
||||
GLOBAL_Stream[sno].name = Yap_LookupAtom(fl);
|
||||
GLOBAL_Stream[sno].user_name = MkAtomTerm(Yap_LookupAtom(fname));
|
||||
GLOBAL_Stream[sno].encoding = LOCAL_encoding;
|
||||
*full = pop_output_text_stack(lvl, fl);
|
||||
Yap_init_consult(consulted, pop_output_text_stack__(lvl,fl));
|
||||
RECOVER_MACHINE_REGS();
|
||||
UNLOCK(GLOBAL_Stream[sno].streamlock);
|
||||
return sno;
|
||||
@ -2176,7 +2182,8 @@ X_API void YAP_EndConsult(int sno, int *osnop, const char *full) {
|
||||
if (osnop >= 0)
|
||||
Yap_AddAlias(AtomLoopStream, *osnop);
|
||||
Yap_end_consult();
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid ", " closing %s(%d), %d", full, *osnop, sno);
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid ", " closing %s:%s(%d), %d",
|
||||
CurrentModule == 0? "prolog": RepAtom(AtomOfTerm(CurrentModule))->StrOfAE, full, *osnop, sno);
|
||||
// LOCAL_CurSlot);
|
||||
pop_text_stack(lvl);
|
||||
RECOVER_MACHINE_REGS();
|
||||
@ -2264,8 +2271,8 @@ X_API int YAP_WriteDynamicBuffer(YAP_Term t, char *buf, size_t sze,
|
||||
char *b;
|
||||
|
||||
BACKUP_MACHINE_REGS();
|
||||
b = Yap_TermToBuffer(t, enc, flags);
|
||||
strncpy(buf, b, sze);
|
||||
b = Yap_TermToBuffer(t, flags);
|
||||
strncpy(buf, b, sze-1);
|
||||
buf[sze] = 0;
|
||||
RECOVER_MACHINE_REGS();
|
||||
return true;
|
||||
@ -2364,7 +2371,7 @@ X_API void YAP_FlushAllStreams(void) {
|
||||
X_API void YAP_Throw(Term t) {
|
||||
BACKUP_MACHINE_REGS();
|
||||
LOCAL_ActiveError->errorNo = THROW_EVENT;
|
||||
LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, LOCAL_encoding, 0);
|
||||
LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, 0);
|
||||
Yap_JumpToEnv();
|
||||
RECOVER_MACHINE_REGS();
|
||||
}
|
||||
@ -2374,7 +2381,7 @@ X_API void YAP_AsyncThrow(Term t) {
|
||||
BACKUP_MACHINE_REGS();
|
||||
LOCAL_PrologMode |= AsyncIntMode;
|
||||
LOCAL_ActiveError->errorNo = THROW_EVENT;
|
||||
LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, LOCAL_encoding, 0);
|
||||
LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(t, 0);
|
||||
Yap_JumpToEnv();
|
||||
LOCAL_PrologMode &= ~AsyncIntMode;
|
||||
RECOVER_MACHINE_REGS();
|
||||
@ -3104,7 +3111,7 @@ X_API Int YAP_AtomToInt(YAP_Atom At) {
|
||||
"No more room for translations");
|
||||
return -1;
|
||||
}
|
||||
memcpy(nt, ot, sizeof(atom_t) * MaxAtomTranslations);
|
||||
memmove(nt, ot, sizeof(atom_t) * MaxAtomTranslations);
|
||||
TR_Atoms = nt;
|
||||
free(ot);
|
||||
MaxAtomTranslations *= 2;
|
||||
@ -3132,7 +3139,7 @@ X_API Int YAP_FunctorToInt(YAP_Functor f) {
|
||||
"No more room for translations");
|
||||
return -1;
|
||||
}
|
||||
memcpy(nt, ot, sizeof(functor_t) * MaxFunctorTranslations);
|
||||
memmove(nt, ot, sizeof(functor_t) * MaxFunctorTranslations);
|
||||
TR_Functors = nt;
|
||||
free(ot);
|
||||
MaxFunctorTranslations *= 2;
|
||||
|
||||
11
C/cdmgr.c
11
C/cdmgr.c
@ -301,7 +301,7 @@ void Yap_BuildMegaClause(PredEntry *ap) {
|
||||
mcl->ClLine = cl->usc.ClLine;
|
||||
ptr = mcl->ClCode;
|
||||
while (TRUE) {
|
||||
memcpy((void *)ptr, (void *)cl->ClCode, sz);
|
||||
memmove((void *)ptr, (void *)cl->ClCode, sz);
|
||||
if (has_blobs) {
|
||||
LOCAL_ClDiff = (char *)(ptr) - (char *)cl->ClCode;
|
||||
restore_opcodes(ptr, NULL PASS_REGS);
|
||||
@ -380,7 +380,7 @@ static void split_megaclause(PredEntry *ap) {
|
||||
new->ClSize = mcl->ClItemSize;
|
||||
new->usc.ClLine = Yap_source_line_no();
|
||||
new->ClNext = NULL;
|
||||
memcpy((void *)new->ClCode, (void *)ptr, mcl->ClItemSize);
|
||||
memmove((void *)new->ClCode, (void *)ptr, mcl->ClItemSize);
|
||||
if (prev) {
|
||||
prev->ClNext = new;
|
||||
} else {
|
||||
@ -1386,7 +1386,7 @@ static void expand_consult(void) {
|
||||
}
|
||||
new_cs = new_cl + InitialConsultCapacity;
|
||||
/* start copying */
|
||||
memcpy((void *)new_cs, (void *)LOCAL_ConsultLow,
|
||||
memmove((void *)new_cs, (void *)LOCAL_ConsultLow,
|
||||
OldConsultCapacity * sizeof(consult_obj));
|
||||
/* copying done, release old space */
|
||||
Yap_FreeCodeSpace((char *)LOCAL_ConsultLow);
|
||||
@ -1768,6 +1768,7 @@ bool Yap_addclause(Term t, yamop *cp, Term tmode, Term mod, Term *t4ref)
|
||||
disc[2] = Yap_Module_Name(p);
|
||||
sc[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDiscontiguous, 3), 3, disc);
|
||||
sc[1] = MkIntegerTerm(Yap_source_line_no());
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "source %s ", RepAtom(LOCAL_SourceFileName)->StrOfAE);
|
||||
sc[2] = MkAtomTerm(LOCAL_SourceFileName);
|
||||
sc[3] = t;
|
||||
t = Yap_MkApplTerm(Yap_MkFunctor(AtomStyleCheck, 4), 4, sc);
|
||||
@ -2064,7 +2065,7 @@ Atom Yap_ConsultingFile(USES_REGS1) {
|
||||
if (LOCAL_consult_level == 0) {
|
||||
return (AtomUser);
|
||||
} else {
|
||||
return (Yap_ULookupAtom(LOCAL_ConsultBase[2].f_name));
|
||||
return LOCAL_ConsultBase[2].f_name;
|
||||
}
|
||||
}
|
||||
|
||||
@ -2078,7 +2079,7 @@ void Yap_init_consult(int mode, const char *filenam) {
|
||||
expand_consult();
|
||||
}
|
||||
LOCAL_ConsultSp--;
|
||||
LOCAL_ConsultSp->f_name = (const unsigned char *)filenam;
|
||||
LOCAL_ConsultSp->f_name = Yap_LookupAtom(filenam);
|
||||
LOCAL_ConsultSp--;
|
||||
LOCAL_ConsultSp->mode = mode;
|
||||
LOCAL_ConsultSp--;
|
||||
|
||||
@ -719,7 +719,7 @@ restart:
|
||||
dest = Yap_emit_extra_size(blob_op, sz / CellSize, sz, &cglobs->cint);
|
||||
|
||||
/* copy the bignum */
|
||||
memcpy(dest, src, sz);
|
||||
memmove(dest, src, sz);
|
||||
/* note that we don't need to copy size info, unless we wanted
|
||||
to garbage collect clauses ;-) */
|
||||
cglobs->cint.icpc = cglobs->cint.cpc;
|
||||
@ -758,7 +758,7 @@ restart:
|
||||
dest = Yap_emit_extra_size(blob_op, sz / CellSize, sz, &cglobs->cint);
|
||||
|
||||
/* copy the bignum */
|
||||
memcpy(dest, src, sz);
|
||||
memmove(dest, src, sz);
|
||||
/* note that we don't need to copy size info, unless we wanted
|
||||
to garbage collect clauses ;-) */
|
||||
cglobs->cint.icpc = cglobs->cint.cpc;
|
||||
|
||||
@ -642,7 +642,7 @@ static CELL *copy_double(CELL *st, CELL *pt) {
|
||||
static CELL *copy_string(CELL *st, CELL *pt) {
|
||||
UInt sz = pt[1] + 3;
|
||||
/* first thing, store a link to the list before we move on */
|
||||
memcpy(st, pt, sizeof(CELL) * sz);
|
||||
memmove(st, pt, sizeof(CELL) * sz);
|
||||
/* now reserve space */
|
||||
return st + sz;
|
||||
}
|
||||
@ -656,7 +656,7 @@ static CELL *copy_big_int(CELL *st, CELL *pt) {
|
||||
st[0] = (CELL)FunctorBigInt;
|
||||
st[1] = pt[1];
|
||||
/* then the actual number */
|
||||
memcpy((void *)(st + 2), (void *)(pt + 2), sz);
|
||||
memmove((void *)(st + 2), (void *)(pt + 2), sz);
|
||||
st = st + 2 + sz / CellSize;
|
||||
/* then the tail for gc */
|
||||
st[0] = EndSpecials;
|
||||
@ -968,7 +968,7 @@ loop:
|
||||
if (HR + sz >= ASP) {
|
||||
goto error2;
|
||||
}
|
||||
memcpy((void *)HR, (void *)(to_visit_base), sz * sizeof(CELL *));
|
||||
memmove((void *)HR, (void *)(to_visit_base), sz * sizeof(CELL *));
|
||||
to_visit_base = (CELL **)HR;
|
||||
to_visit = to_visit_base + sz;
|
||||
}
|
||||
@ -1684,7 +1684,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
|
||||
nar = ppt->Contents + Unsigned(NOfCells);
|
||||
}
|
||||
woar = (link_entry *)nar;
|
||||
memcpy((void *)woar, (const void *)dbg->LinkAr,
|
||||
memmove((void *)woar, (const void *)dbg->LinkAr,
|
||||
(size_t)(NOfLinks * sizeof(link_entry)));
|
||||
woar += NOfLinks;
|
||||
#ifdef ALIGN_LONGS
|
||||
|
||||
@ -1978,7 +1978,7 @@ Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
|
||||
assert(ncopies >= 3);
|
||||
|
||||
if (ncopies > 9)
|
||||
memcpy(d, s, copysize);
|
||||
memmove(d, s, copysize);
|
||||
|
||||
else {
|
||||
*(d+0) = *(s+0);
|
||||
@ -2077,7 +2077,7 @@ Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
|
||||
/* Must alloc, copy, free. */
|
||||
newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
|
||||
if (newmem != 0) {
|
||||
memcpy(newmem, oldmem, oldsize - 2*SIZE_SZ);
|
||||
memmove(newmem, oldmem, oldsize - 2*SIZE_SZ);
|
||||
fREe(oldmem);
|
||||
}
|
||||
}
|
||||
|
||||
67
C/errors.c
67
C/errors.c
@ -49,7 +49,7 @@
|
||||
const char *s = IsAtomTerm(t) ? RepAtom(AtomOfTerm(t))->StrOfAE \
|
||||
: IsStringTerm(t) ? StringOfTerm(t) : NULL; \
|
||||
if (s) { \
|
||||
char *tmp = malloc(strlen(s) + 1); \
|
||||
char *tmp = calloc(1,strlen(s) + 1); \
|
||||
strcpy(tmp, s); \
|
||||
i->k = tmp; \
|
||||
} \
|
||||
@ -90,21 +90,23 @@ static bool setErr(const char *q, yap_error_descriptor_t *i, Term t) {
|
||||
return i->k ? TermTrue : TermFalse; \
|
||||
}
|
||||
|
||||
#define query_key_i(k, ks, q, i) \
|
||||
if (strcmp(ks, q) == 0) { \
|
||||
#define query_key_i(k, ks, q, i) if (strcmp(ks, q) == 0) { \
|
||||
return MkIntegerTerm(i->k); \
|
||||
}
|
||||
|
||||
#define query_key_s(k, ks, q, i) \
|
||||
if (strcmp(ks, q) == 0 && i->k) { \
|
||||
return MkAtomTerm(Yap_LookupAtom(i->k)); } else {return TermNil;}
|
||||
|
||||
#define query_key_t(k, ks, q, i) \
|
||||
if (strcmp(ks, q) == 0) { \
|
||||
return (i->k && i->k[0] ? MkStringTerm(i->k) : TermNil); \
|
||||
}
|
||||
Term t; if((t = Yap_BufferToTerm(i->k, TermNil) ) == 0 ) return TermNil; return t; }
|
||||
|
||||
static Term queryErr(const char *q, yap_error_descriptor_t *i) {
|
||||
query_key_i(errorNo, "errorNo", q, i);
|
||||
query_key_i(errorClass, "errorClass", q, i);
|
||||
query_key_s(errorAsText, "errorAsText", q, i);
|
||||
query_key_s(errorGoal, "errorGoal", q, i);
|
||||
query_key_t(errorGoal, "errorGoal", q, i);
|
||||
query_key_s(classAsText, "classAsText", q, i);
|
||||
query_key_i(errorLine, "errorLine", q, i);
|
||||
query_key_s(errorFunction, "errorFunction", q, i);
|
||||
@ -123,7 +125,7 @@ static Term queryErr(const char *q, yap_error_descriptor_t *i) {
|
||||
query_key_s(prologParserText, "prologParserText", q, i);
|
||||
query_key_s(prologParserFile, "prologParserFile", q, i);
|
||||
query_key_b(prologConsulting, "prologConsulting", q, i);
|
||||
query_key_s(culprit, "culprit", q, i);
|
||||
query_key_t(culprit, "culprit", q, i);
|
||||
query_key_s(errorMsg, "errorMsg", q, i);
|
||||
query_key_i(errorMsgLen, "errorMsgLen", q, i);
|
||||
return TermNil;
|
||||
@ -148,10 +150,10 @@ static void printErr(yap_error_descriptor_t *i) {
|
||||
return;
|
||||
}
|
||||
print_key_i("errorNo", i->errorNo);
|
||||
print_key_i("errorClass", i->errorClass);
|
||||
print_key_s("errorAsText", i->errorAsText);
|
||||
print_key_i("errorClass", (i->errorClass = Yap_errorClass(i->errorNo)));
|
||||
print_key_s("errorAsText", (i->errorAsText=Yap_errorName(i->errorNo) ) );
|
||||
print_key_s("errorGoal", i->errorGoal);
|
||||
print_key_s("classAsText", i->classAsText);
|
||||
print_key_s("classAsText", (i->classAsText=Yap_errorClassName(i->errorClass)));
|
||||
print_key_i("errorLine", i->errorLine);
|
||||
print_key_s("errorFunction", i->errorFunction);
|
||||
print_key_s("errorFile", i->errorFile);
|
||||
@ -322,7 +324,7 @@ bool Yap_PrintWarning(Term twarning) {
|
||||
PredEntry *pred = RepPredProp(PredPropByFunc(
|
||||
FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2;
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid ", " warning(%s)",
|
||||
Yap_TermToBuffer(twarning, ENC_ISO_UTF8,Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f));
|
||||
Yap_TermToBuffer(twarning, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f));
|
||||
Term cmod = (CurrentModule == PROLOG_MODULE ? TermProlog : CurrentModule);
|
||||
bool rc;
|
||||
Term ts[2], err;
|
||||
@ -330,7 +332,7 @@ bool Yap_PrintWarning(Term twarning) {
|
||||
if (LOCAL_PrologMode & InErrorMode && LOCAL_ActiveError &&
|
||||
(err = LOCAL_ActiveError->errorNo)) {
|
||||
fprintf(stderr, "%% Warning %s while processing error: %s %s\n",
|
||||
Yap_TermToBuffer(twarning, ENC_ISO_UTF8,
|
||||
Yap_TermToBuffer(twarning,
|
||||
Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f),
|
||||
Yap_errorClassName(Yap_errorClass(err)), Yap_errorName(err));
|
||||
return false;
|
||||
@ -581,23 +583,17 @@ bool Yap_pushErrorContext(bool pass, yap_error_descriptor_t *new_error) {
|
||||
/* if (Yap_HasException()) */
|
||||
/* memset(LOCAL_ActiveError, 0, sizeof(*LOCAL_ActiveError)); */
|
||||
/* LOCAL_ActiveError->top_error = bf; */
|
||||
|
||||
/* } */
|
||||
yap_error_descriptor_t *Yap_popErrorContext(bool mdnew, bool pass) {
|
||||
yap_error_descriptor_t *e = LOCAL_ActiveError;
|
||||
yap_error_descriptor_t *e = LOCAL_ActiveError, *ep = LOCAL_ActiveError->top_error;
|
||||
// last block
|
||||
LOCAL_ActiveError = e->top_error;
|
||||
if (e->errorNo) {
|
||||
if (!LOCAL_ActiveError->errorNo && pass) {
|
||||
memcpy(LOCAL_ActiveError, e, sizeof(*LOCAL_ActiveError));
|
||||
} else {
|
||||
return e;
|
||||
LOCAL_ActiveError = ep;
|
||||
if (e->errorNo && !ep->errorNo && pass) {
|
||||
yap_error_descriptor_t *epp = ep->top_error;
|
||||
memmove(ep, e, sizeof(*e));
|
||||
ep->top_error = epp;
|
||||
}
|
||||
} else {
|
||||
if (e->errorNo)
|
||||
return e;
|
||||
}
|
||||
return NULL;
|
||||
return LOCAL_ActiveError;
|
||||
}
|
||||
/**
|
||||
* Throw an error directly to the error handler
|
||||
@ -652,7 +648,7 @@ bool Yap_MkErrorRecord(yap_error_descriptor_t *r, const char *file,
|
||||
r->culprit = NULL;
|
||||
} else {
|
||||
r->culprit = Yap_TermToBuffer(
|
||||
where, ENC_ISO_UTF8, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f);
|
||||
where, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f);
|
||||
}
|
||||
if (LOCAL_consult_level > 0) {
|
||||
r->prologParserFile = Yap_ConsultingFile(PASS_REGS1)->StrOfAE;
|
||||
@ -941,6 +937,7 @@ typedef struct c_error_info {
|
||||
;
|
||||
|
||||
#include <YapErrors.h>
|
||||
#include <iopreds.h>
|
||||
|
||||
yap_error_class_number Yap_errorClass(yap_error_number e) {
|
||||
return c_error_list[e].class;
|
||||
@ -956,8 +953,8 @@ yap_error_descriptor_t *Yap_GetException(yap_error_descriptor_t *i) {
|
||||
CACHE_REGS
|
||||
if (i->errorNo != YAP_NO_ERROR) {
|
||||
yap_error_descriptor_t *t = LOCAL_ActiveError,
|
||||
*nt = malloc(sizeof(yap_error_descriptor_t));
|
||||
memcpy(nt, t, sizeof(yap_error_descriptor_t));
|
||||
*nt = calloc(1,sizeof(yap_error_descriptor_t));
|
||||
memmove(nt, t, sizeof(yap_error_descriptor_t));
|
||||
return nt;
|
||||
}
|
||||
return 0;
|
||||
@ -989,8 +986,11 @@ static Int reset_exception(USES_REGS1) { return Yap_ResetException(worker_id); }
|
||||
Term MkErrorTerm(yap_error_descriptor_t *t) {
|
||||
if (t->errorClass == EVENT)
|
||||
return t->errorRawTerm;
|
||||
Term tc = t->culprit ? Yap_BufferToTerm(t->culprit, TermNil) : TermNil;
|
||||
if (tc == 0)
|
||||
tc = MkAtomTerm(Yap_LookupAtom(t->culprit));
|
||||
return mkerrort(t->errorNo,
|
||||
t->culprit ? Yap_BufferToTerm(t->culprit, TermNil) : TermNil,
|
||||
tc,
|
||||
err2list(t));
|
||||
}
|
||||
|
||||
@ -1002,8 +1002,13 @@ static Int read_exception(USES_REGS1) {
|
||||
}
|
||||
|
||||
static Int print_exception(USES_REGS1) {
|
||||
yap_error_descriptor_t *t = AddressOfTerm(Deref(ARG1));
|
||||
Term t1 = Deref(ARG1);
|
||||
if (IsAddressTerm(t1)) {
|
||||
yap_error_descriptor_t *t = AddressOfTerm(t1);
|
||||
printErr(t);
|
||||
} else {
|
||||
return Yap_WriteTerm(LOCAL_c_error_stream,t1,TermNil PASS_REGS);
|
||||
}
|
||||
// Yap_DebugPlWriteln(rc);
|
||||
return true;
|
||||
}
|
||||
@ -1144,7 +1149,7 @@ yap_error_descriptor_t *Yap_UserError(Term t, yap_error_descriptor_t *i) {
|
||||
n = t2;
|
||||
}
|
||||
i->errorGoal = Yap_TermToBuffer(
|
||||
n, ENC_ISO_UTF8, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f);
|
||||
n, Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f);
|
||||
}
|
||||
Yap_prolog_add_culprit(i PASS_REGS);
|
||||
return i;
|
||||
|
||||
3
C/exec.c
3
C/exec.c
@ -2116,7 +2116,8 @@ static Int jump_env(USES_REGS1) {
|
||||
}
|
||||
// Yap_DebugPlWriteln(t);
|
||||
// char *buf = Yap_TermToBuffer(t, ENC_ISO_UTF8,
|
||||
// Quote_illegal_f | Ignore_ops_f | Unfold_cyclics_f);
|
||||
// Quote_illegal_f | Ignore_ops_f |
|
||||
// Unfold_cyclics_f);
|
||||
// __android_log_print(ANDROID_LOG_INFO, "YAPDroid ", " throw(%s)", buf);
|
||||
LOCAL_ActiveError = Yap_UserError(t0, LOCAL_ActiveError);
|
||||
bool out = JumpToEnv(PASS_REGS1);
|
||||
|
||||
@ -253,7 +253,7 @@ IntervalUDIRefitIndex(struct index_t **ip, UInt b[] USES_REGS)
|
||||
qsort(s0+1, (size_t)*s0, sizeof(BITS32), compar);
|
||||
it->links[offset0] = s0-sorted0;
|
||||
if (it->udi_free_args) {
|
||||
memcpy(sorted, s0+1, sizeof(BITS32)*(*s0));
|
||||
memmove(sorted, s0+1, sizeof(BITS32)*(*s0));
|
||||
qsort(sorted, (size_t)*s0, sizeof(BITS32), compar2);
|
||||
sorted += *s0;
|
||||
}
|
||||
|
||||
73
C/flags.c
73
C/flags.c
@ -80,22 +80,29 @@ static void newFlag(Term fl, Term val);
|
||||
static Int current_prolog_flag(USES_REGS1);
|
||||
static Int set_prolog_flag(USES_REGS1);
|
||||
|
||||
#include "Yatom.h"
|
||||
#include "YapEval.h"
|
||||
#include "Yatom.h"
|
||||
#include "yapio.h"
|
||||
|
||||
#define YAP_FLAG(ID, NAME, WRITABLE, DEF, INIT, HELPER) { NAME, WRITABLE, DEF, INIT, HELPER }
|
||||
#define YAP_FLAG(ID, NAME, WRITABLE, DEF, INIT, HELPER) \
|
||||
{ NAME, WRITABLE, DEF, INIT, HELPER }
|
||||
|
||||
#define START_LOCAL_FLAGS static flag_info local_flags_setup[] = {
|
||||
#define END_LOCAL_FLAGS LZERO_FLAG};
|
||||
#define END_LOCAL_FLAGS \
|
||||
LZERO_FLAG \
|
||||
} \
|
||||
;
|
||||
|
||||
#define START_GLOBAL_FLAGS static flag_info global_flags_setup[] = {
|
||||
#define END_GLOBAL_FLAGS GZERO_FLAG};
|
||||
|
||||
|
||||
#define GZERO_FLAG { NULL, false, NULL, NULL, NULL }
|
||||
#define LZERO_FLAG { NULL, false, NULL, NULL, NULL }
|
||||
#define END_GLOBAL_FLAGS \
|
||||
GZERO_FLAG \
|
||||
} \
|
||||
;
|
||||
|
||||
#define GZERO_FLAG \
|
||||
{ NULL, false, NULL, NULL, NULL }
|
||||
#define LZERO_FLAG \
|
||||
{ NULL, false, NULL, NULL, NULL }
|
||||
|
||||
#include "YapGFlagInfo.h"
|
||||
|
||||
@ -111,8 +118,7 @@ static Term indexer(Term inp) {
|
||||
"set_prolog_flag index in {off,single,compact,multi,on,max}");
|
||||
return TermZERO;
|
||||
}
|
||||
Yap_Error(TYPE_ERROR_ATOM, inp,
|
||||
"set_prolog_flag in {dec10,error,fail,quiet}");
|
||||
Yap_Error(TYPE_ERROR_ATOM, inp, "set_prolog_flag index to an atom");
|
||||
return TermZERO;
|
||||
}
|
||||
|
||||
@ -133,13 +139,15 @@ static bool dqf1(ModEntry *new, Term t2 USES_REGS) {
|
||||
return true;
|
||||
}
|
||||
/* bad argument, but still an atom */
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted "
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2,
|
||||
"bad option %s for backquoted "
|
||||
"string flag, use one string, "
|
||||
"atom, codes or chars",
|
||||
RepAtom(AtomOfTerm(t2))->StrOfAE);
|
||||
return false;
|
||||
} else {
|
||||
Yap_Error(TYPE_ERROR_ATOM, t2, "set_prolog_flag(double_quotes, %s), should "
|
||||
Yap_Error(TYPE_ERROR_ATOM, t2,
|
||||
"set_prolog_flag(double_quotes, %s), should "
|
||||
"be {string,atom,codes,chars}",
|
||||
RepAtom(AtomOfTerm(t2))->StrOfAE);
|
||||
return false;
|
||||
@ -168,7 +176,8 @@ static bool bqf1(ModEntry *new, Term t2 USES_REGS) {
|
||||
new->flags |= BCKQ_CHARS;
|
||||
return true;
|
||||
}
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted "
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2,
|
||||
"bad option %s for backquoted "
|
||||
"string flag, use one string, "
|
||||
"atom, codes or chars",
|
||||
RepAtom(AtomOfTerm(t2))->StrOfAE);
|
||||
@ -186,7 +195,6 @@ static bool bqs(Term t2) {
|
||||
return bqf1(new, t2 PASS_REGS);
|
||||
}
|
||||
|
||||
|
||||
static bool sqf1(ModEntry *new, Term t2 USES_REGS) {
|
||||
new->flags &= ~(SNGQ_CHARS | SNGQ_CODES | SNGQ_ATOM | SNGQ_STRING);
|
||||
if (IsAtomTerm(t2)) {
|
||||
@ -203,7 +211,8 @@ static bool sqf1(ModEntry *new, Term t2 USES_REGS) {
|
||||
new->flags |= SNGQ_CHARS;
|
||||
return true;
|
||||
}
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2, "bad option %s for backquoted "
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, t2,
|
||||
"bad option %s for backquoted "
|
||||
"string flag, use one string, "
|
||||
"atom, codes or chars",
|
||||
RepAtom(AtomOfTerm(t2))->StrOfAE);
|
||||
@ -215,7 +224,6 @@ static bool sqf1(ModEntry *new, Term t2 USES_REGS) {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static bool sqf(Term t2) {
|
||||
CACHE_REGS
|
||||
ModEntry *new = Yap_GetModuleEntry(CurrentModule);
|
||||
@ -239,7 +247,8 @@ static Term isaccess(Term inp) {
|
||||
static Term stream(Term inp) {
|
||||
if (IsVarTerm(inp))
|
||||
return inp;
|
||||
if (Yap_CheckStream(inp, Input_Stream_f | Output_Stream_f | Append_Stream_f |
|
||||
if (Yap_CheckStream(inp,
|
||||
Input_Stream_f | Output_Stream_f | Append_Stream_f |
|
||||
Socket_Stream_f,
|
||||
"yap_flag/3") >= 0)
|
||||
return inp;
|
||||
@ -468,7 +477,7 @@ static bool typein(Term inp) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool list_atom( Term inp ) {
|
||||
x static bool list_atom( Term inp ) {
|
||||
if (IsVarTerm(inp)) {
|
||||
Yap_Error(INSTANTIATION_ERROR, inp, "set_prolog_flag in \"...\"");
|
||||
return false;
|
||||
@ -782,7 +791,6 @@ static bool setYapFlagInModule(Term tflag, Term t2, Term mod) {
|
||||
return bqf1(me, t2 PASS_REGS);
|
||||
} else if (fv->FlagOfVE == SINGLE_QUOTES_FLAG) {
|
||||
return sqf1(me, t2 PASS_REGS);
|
||||
|
||||
}
|
||||
// bad key?
|
||||
return false;
|
||||
@ -850,8 +858,7 @@ static Int cont_yap_flag(USES_REGS1) {
|
||||
Term modt = CurrentModule;
|
||||
tflag = Yap_StripModule(tflag, &modt);
|
||||
while (i != gmax && i != UNKNOWN_FLAG && i != CHARACTER_ESCAPES_FLAG &&
|
||||
i != BACK_QUOTES_FLAG &&
|
||||
i != SINGLE_QUOTES_FLAG &&
|
||||
i != BACK_QUOTES_FLAG && i != SINGLE_QUOTES_FLAG &&
|
||||
i != DOUBLE_QUOTES_FLAG)
|
||||
i++;
|
||||
if (i == gmax)
|
||||
@ -1056,14 +1063,16 @@ void Yap_setModuleFlags(ModEntry *new, ModEntry *cme) {
|
||||
|
||||
Atom at = new->AtomOfME;
|
||||
if (at == AtomProlog || CurrentModule == PROLOG_MODULE) {
|
||||
new->flags =
|
||||
M_SYSTEM | UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM;
|
||||
new->flags = M_SYSTEM | UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES |
|
||||
BCKQ_STRING | SNGQ_ATOM;
|
||||
if (at == AtomUser)
|
||||
new->flags = UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM;
|
||||
new->flags =
|
||||
UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING | SNGQ_ATOM;
|
||||
} else if (cme && cme->flags && cme != new) {
|
||||
new->flags = cme->flags;
|
||||
} else {
|
||||
new->flags = (UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING |SNGQ_ATOM);
|
||||
new->flags =
|
||||
(UNKNOWN_ERROR | M_CHARESCAPE | DBLQ_CODES | BCKQ_STRING | SNGQ_ATOM);
|
||||
}
|
||||
// printf("cme=%s new=%s flags=%x\n",cme,at->StrOfAE,new->flags);
|
||||
}
|
||||
@ -1392,7 +1401,8 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
|
||||
}
|
||||
CACHE_REGS
|
||||
const char *us = (const char *)s;
|
||||
t0 = Yap_BufferToTermWithPrioBindings(us, TermNil, 0L, strlen(s) + 1, GLOBAL_MaxPriority);
|
||||
t0 = Yap_BufferToTermWithPrioBindings(us, TermNil, 0L, strlen(s) + 1,
|
||||
GLOBAL_MaxPriority);
|
||||
if (!t0)
|
||||
return false;
|
||||
if (IsAtomTerm(t0) || IsIntTerm(t0)) {
|
||||
@ -1439,7 +1449,8 @@ do_prolog_flag_property(Term tflag,
|
||||
xarg *args;
|
||||
prolog_flag_property_choices_t i;
|
||||
bool rc = true;
|
||||
args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
|
||||
args =
|
||||
Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
|
||||
PROLOG_FLAG_PROPERTY_END, DOMAIN_ERROR_PROLOG_FLAG);
|
||||
if (args == NULL) {
|
||||
Yap_Error(LOCAL_Error_TYPE, opts, NULL);
|
||||
@ -1527,8 +1538,7 @@ static Int cont_prolog_flag_property(USES_REGS1) { /* current_prolog_flag */
|
||||
lab = MkAtomTerm(Yap_LookupAtom(local_flags_setup[i - gmax].name));
|
||||
} else {
|
||||
if (i == UNKNOWN_FLAG || i == CHARACTER_ESCAPES_FLAG ||
|
||||
i == SINGLE_QUOTES_FLAG ||
|
||||
i == DOUBLE_QUOTES_FLAG ||
|
||||
i == SINGLE_QUOTES_FLAG || i == DOUBLE_QUOTES_FLAG ||
|
||||
i == BACK_QUOTES_FLAG) {
|
||||
Term labs[2];
|
||||
labs[0] = MkVarTerm();
|
||||
@ -1607,7 +1617,8 @@ static Int do_create_prolog_flag(USES_REGS1) {
|
||||
prolog_flag_property_choices_t i;
|
||||
Term tflag = Deref(ARG1), tval = Deref(ARG2), opts = Deref(ARG3);
|
||||
|
||||
args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
|
||||
args =
|
||||
Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
|
||||
PROLOG_FLAG_PROPERTY_END, DOMAIN_ERROR_PROLOG_FLAG);
|
||||
if (args == NULL) {
|
||||
Yap_Error(LOCAL_Error_TYPE, opts, NULL);
|
||||
@ -1722,7 +1733,7 @@ void Yap_InitFlags(bool bootstrap) {
|
||||
*/
|
||||
Yap_InitCPredBack("prolog_flag", 3, 1, current_prolog_flag, cont_yap_flag,
|
||||
0);
|
||||
Yap_InitCPredBack("yap_flag", 3, 1, prolog_flag, cont_yap_flag, 0);
|
||||
Yap_InitCPredBack("yap_flag", 3, 1, yap_flag, cont_yap_flag, 0);
|
||||
Yap_InitCPredBack("prolog_flag", 2, 1, current_prolog_flag2,
|
||||
cont_current_prolog_flag, 0);
|
||||
Yap_InitCPredBack("current_prolog_flag", 2, 1, current_prolog_flag2,
|
||||
|
||||
@ -56,7 +56,7 @@
|
||||
CPredicate f = PREG->y_u.Osbpp.p->cs.f_code;
|
||||
PREG = NEXTOP(PREG, Osbpp);
|
||||
saveregs();
|
||||
d0 = (f)(PASS_REGS1);
|
||||
d0 = f(PASS_REGS1);
|
||||
setregs();
|
||||
#ifdef SHADOW_S
|
||||
SREG = Yap_REGS.S_;
|
||||
|
||||
@ -475,7 +475,7 @@ loop:
|
||||
goto overflow;
|
||||
}
|
||||
*ptf++ = AbsAppl(HR);
|
||||
memcpy(HR, ap2, sizeof(CELL) * (3 + ap2[1]));
|
||||
memmove(HR, ap2, sizeof(CELL) * (3 + ap2[1]));
|
||||
HR += ap2[1] + 3;
|
||||
break;
|
||||
default: {
|
||||
@ -756,7 +756,7 @@ restart:
|
||||
res = -1;
|
||||
goto error_handler;
|
||||
}
|
||||
memcpy(HR, ap, sizeof(CELL) * (3 + ap[1]));
|
||||
memmove(HR, ap, sizeof(CELL) * (3 + ap[1]));
|
||||
HR += ap[1] + 3;
|
||||
break;
|
||||
default: {
|
||||
|
||||
6
C/grow.c
6
C/grow.c
@ -205,13 +205,13 @@ CopyLocalAndTrail( USES_REGS1 )
|
||||
static void
|
||||
IncrementalCopyStacksFromWorker( USES_REGS1 )
|
||||
{
|
||||
memcpy((void *) PtoGloAdjust((CELL *)LOCAL_start_global_copy),
|
||||
memmove((void *) PtoGloAdjust((CELL *)LOCAL_start_global_copy),
|
||||
(void *) (LOCAL_start_global_copy),
|
||||
(size_t) (LOCAL_end_global_copy - LOCAL_start_global_copy));
|
||||
memcpy((void *) PtoLocAdjust((CELL *)LOCAL_start_local_copy),
|
||||
memmove((void *) PtoLocAdjust((CELL *)LOCAL_start_local_copy),
|
||||
(void *) LOCAL_start_local_copy,
|
||||
(size_t) (LOCAL_end_local_copy - LOCAL_start_local_copy));
|
||||
memcpy((void *) PtoTRAdjust((tr_fr_ptr)LOCAL_start_trail_copy),
|
||||
memmove((void *) PtoTRAdjust((tr_fr_ptr)LOCAL_start_trail_copy),
|
||||
(void *) (LOCAL_start_trail_copy),
|
||||
(size_t) (LOCAL_end_trail_copy - LOCAL_start_trail_copy));
|
||||
}
|
||||
|
||||
@ -825,7 +825,7 @@ static inline int smaller_or_eq(Term t1, Term t2) {
|
||||
}
|
||||
|
||||
static inline void clcpy(ClauseDef *d, ClauseDef *s) {
|
||||
memcpy((void *)d, (void *)s, sizeof(ClauseDef));
|
||||
memmove((void *)d, (void *)s, sizeof(ClauseDef));
|
||||
}
|
||||
|
||||
static void insort(ClauseDef base[], CELL *p, CELL *q, int my_p) {
|
||||
@ -2670,7 +2670,7 @@ static ClauseDef *copy_clauses(ClauseDef *max0, ClauseDef *min0, CELL *top,
|
||||
save_machine_regs();
|
||||
siglongjmp(cint->CompilerBotch, 4);
|
||||
}
|
||||
memcpy((void *)top, (void *)min0, sz);
|
||||
memmove((void *)top, (void *)min0, sz);
|
||||
return (ClauseDef *)top;
|
||||
}
|
||||
|
||||
|
||||
4
C/init.c
4
C/init.c
@ -301,7 +301,7 @@ bool Yap_dup_op(OpEntry *op, ModEntry *she) {
|
||||
OpEntry *info = (OpEntry *)Yap_AllocAtomSpace(sizeof(OpEntry));
|
||||
if (!info)
|
||||
return false;
|
||||
memcpy(info, op, sizeof(OpEntry));
|
||||
memmove(info, op, sizeof(OpEntry));
|
||||
info->NextForME = she->OpForME;
|
||||
she->OpForME = info;
|
||||
info->OpModule = MkAtomTerm(she->AtomOfME);
|
||||
@ -1162,7 +1162,7 @@ void Yap_init_yapor_workers(void) {
|
||||
worker_id = proc;
|
||||
Yap_remap_yapor_memory();
|
||||
LOCAL = REMOTE(worker_id);
|
||||
memcpy(REMOTE(worker_id), REMOTE(0), sizeof(struct worker_local));
|
||||
memmove(REMOTE(worker_id), REMOTE(0), sizeof(struct worker_local));
|
||||
InitWorker(worker_id);
|
||||
break;
|
||||
} else
|
||||
|
||||
@ -447,7 +447,7 @@ static void Yap_setCurrentSourceLocation(struct stream_desc *s) {
|
||||
if (s->status & Pipe_Stream_f)
|
||||
LOCAL_SourceFileName = AtomPipe;
|
||||
else if (s->status & InMemory_Stream_f)
|
||||
LOCAL_SourceFileName = AtomCharsio;
|
||||
LOCAL_SourceFileName = s->name;
|
||||
else
|
||||
LOCAL_SourceFileName = s->name;
|
||||
LOCAL_SourceFileLineno = s->linecount;
|
||||
|
||||
@ -1808,7 +1808,7 @@ void Yap_dump_stack(void) {
|
||||
yap_error_class_number classno = Yap_errorClass(errnbr);
|
||||
|
||||
fprintf(stderr, "%% Error STATUS: %s/%s\n\n", Yap_errorName(errnbr),
|
||||
Yap_errorName(classno));
|
||||
Yap_errorClassName(classno));
|
||||
|
||||
fprintf(stderr, "%% Execution mode\n");
|
||||
if (LOCAL_PrologMode & BootMode)
|
||||
|
||||
169
C/text.c
169
C/text.c
@ -199,7 +199,7 @@ const void *MallocExportAsRO(const void *pt USES_REGS) {
|
||||
return NULL;
|
||||
size_t sz = o->sz;
|
||||
release_block(o);
|
||||
memcpy((void *)o, pt, sz);
|
||||
memmove((void *)o, pt, sz);
|
||||
return realloc((void *)o, sz);
|
||||
}
|
||||
|
||||
@ -215,10 +215,7 @@ void *Yap_InitTextAllocator(void) {
|
||||
return new;
|
||||
}
|
||||
|
||||
static size_t MaxTmp(USES_REGS1) {
|
||||
|
||||
return 1025;
|
||||
}
|
||||
static size_t MaxTmp(USES_REGS1) { return 1025; }
|
||||
|
||||
static Term Globalize(Term v USES_REGS) {
|
||||
if (!IsVarTerm(v = Deref(v))) {
|
||||
@ -231,7 +228,8 @@ static Term Globalize(Term v USES_REGS) {
|
||||
return v;
|
||||
}
|
||||
|
||||
static void *codes2buf(Term t0, void *b0, bool *get_codes USES_REGS) {
|
||||
static void *codes2buf(Term t0, void *b0, bool get_codes,
|
||||
bool fixed USES_REGS) {
|
||||
unsigned char *st0, *st, ar[16];
|
||||
Term t = t0;
|
||||
size_t length = 0;
|
||||
@ -241,11 +239,19 @@ static void *codes2buf(Term t0, void *b0, bool *get_codes USES_REGS) {
|
||||
st0[0] = 0;
|
||||
return st0;
|
||||
}
|
||||
if (!IsPairTerm(t))
|
||||
if (!IsPairTerm(t)) {
|
||||
Yap_ThrowError(TYPE_ERROR_LIST, t, "scanning list of codes");
|
||||
return NULL;
|
||||
}
|
||||
bool codes = IsIntegerTerm(HeadOfTerm(t));
|
||||
if (get_codes)
|
||||
*get_codes = codes;
|
||||
if (get_codes != codes && fixed) {
|
||||
if (codes) {
|
||||
Yap_ThrowError(TYPE_ERROR_INTEGER, HeadOfTerm(t),
|
||||
"scanning list of codes");
|
||||
} else {
|
||||
Yap_ThrowError(TYPE_ERROR_ATOM, HeadOfTerm(t), "scanning list of atoms");
|
||||
}
|
||||
}
|
||||
if (codes) {
|
||||
while (IsPairTerm(t)) {
|
||||
Term hd = HeadOfTerm(t);
|
||||
@ -259,7 +265,8 @@ static void *codes2buf(Term t0, void *b0, bool *get_codes USES_REGS) {
|
||||
}
|
||||
Int code = IntegerOfTerm(hd);
|
||||
if (code < 0) {
|
||||
Yap_ThrowError(TYPE_ERROR_CHARACTER_CODE, hd, "scanning list of codes");
|
||||
Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER_CODE, hd,
|
||||
"scanning list of character codes, found %d", code);
|
||||
return NULL;
|
||||
}
|
||||
length += put_utf8(ar, code);
|
||||
@ -368,26 +375,21 @@ static void *slice(size_t min, size_t max, const unsigned char *buf USES_REGS);
|
||||
|
||||
static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t,
|
||||
seq_tv_t *inp USES_REGS) {
|
||||
bool codes;
|
||||
unsigned char *nbuf = codes2buf(t, buf, &codes PASS_REGS);
|
||||
if (!codes)
|
||||
return NULL;
|
||||
bool codes = true, fixed = true;
|
||||
unsigned char *nbuf = codes2buf(t, buf, codes, fixed PASS_REGS);
|
||||
return nbuf;
|
||||
}
|
||||
|
||||
static unsigned char *Yap_ListOfAtomsToBuffer(unsigned char *buf, Term t,
|
||||
seq_tv_t *inp USES_REGS) {
|
||||
bool codes;
|
||||
unsigned char *nbuf = codes2buf(t, buf, &codes PASS_REGS);
|
||||
if (codes)
|
||||
return NULL;
|
||||
bool codes = false;
|
||||
unsigned char *nbuf = codes2buf(t, buf, codes, true PASS_REGS);
|
||||
return nbuf;
|
||||
}
|
||||
|
||||
static unsigned char *Yap_ListToBuffer(unsigned char *buf, Term t,
|
||||
seq_tv_t *inp USES_REGS) {
|
||||
unsigned char *nbuf = codes2buf(t, buf, NULL PASS_REGS);
|
||||
return nbuf;
|
||||
return codes2buf(t, buf, NULL, false PASS_REGS);
|
||||
}
|
||||
|
||||
#if USE_GEN_TYPE_ERROR
|
||||
@ -418,8 +420,10 @@ static yap_error_number gen_type_error(int flags) {
|
||||
// static int cnt;
|
||||
|
||||
unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) {
|
||||
|
||||
#define POPRET(x) return pop_output_text_stack(lvl, x)
|
||||
int lvl = push_text_stack();
|
||||
char *out = NULL;
|
||||
yap_error_number err0 = LOCAL_Error_TYPE;
|
||||
/* we know what the term is */
|
||||
if (!(inp->type & (YAP_STRING_CHARS | YAP_STRING_WCHARS))) {
|
||||
if (!(inp->type & YAP_STRING_TERM)) {
|
||||
@ -431,128 +435,131 @@ unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) {
|
||||
LOCAL_Error_TYPE = TYPE_ERROR_STRING;
|
||||
} 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;
|
||||
LOCAL_ActiveError->errorRawTerm = inp->val.t;
|
||||
} 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;
|
||||
}
|
||||
}
|
||||
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
|
||||
if (inp->val.uc != NULL) {
|
||||
LOCAL_ActiveError->errorRawTerm = MkUStringTerm(inp->val.uc);
|
||||
|
||||
}
|
||||
Yap_ThrowError(LOCAL_Error_TYPE, LOCAL_ActiveError->errorRawTerm, "Converting to text from term ");
|
||||
return NULL;
|
||||
if (err0 != LOCAL_Error_TYPE) {
|
||||
Yap_ThrowError(LOCAL_Error_TYPE, inp->val.t, "while reading text in");
|
||||
}
|
||||
}
|
||||
|
||||
if (IsAtomTerm(inp->val.t) && inp->type & YAP_STRING_ATOM) {
|
||||
// this is a term, extract to a buffer, and representation is wide
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
Atom at = AtomOfTerm(inp->val.t);
|
||||
if (RepAtom(at)->UStrOfAE[0] == 0) {
|
||||
unsigned char *o = Malloc(4);
|
||||
memset(o, 0, 4);
|
||||
return pop_output_text_stack(lvl, o);
|
||||
out = Malloc(4);
|
||||
memset(out, 0, 4);
|
||||
POPRET( out );
|
||||
}
|
||||
if (inp->type & YAP_STRING_WITH_BUFFER) {
|
||||
pop_text_stack(lvl);
|
||||
return at->UStrOfAE;
|
||||
}
|
||||
{
|
||||
size_t sz = strlen(at->StrOfAE);
|
||||
void *o = Malloc(sz + 1);
|
||||
strcpy(o, at->StrOfAE);
|
||||
return pop_output_text_stack(lvl, o);
|
||||
out = Malloc(sz + 1);
|
||||
strcpy(out, at->StrOfAE);
|
||||
POPRET( out );
|
||||
}
|
||||
}
|
||||
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
|
||||
// this is a term, extract to a buffer, and representation is wide
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
const char *s = StringOfTerm(inp->val.t);
|
||||
if (s[0] == 0) {
|
||||
char *o = Malloc(4);
|
||||
memset(o, 0, 4);
|
||||
return pop_output_text_stack(lvl, o);
|
||||
out = Malloc(4);
|
||||
memset(out, 0, 4);
|
||||
POPRET( out );
|
||||
}
|
||||
if (inp->type & YAP_STRING_WITH_BUFFER)
|
||||
if (inp->type & YAP_STRING_WITH_BUFFER) {
|
||||
pop_text_stack(lvl);
|
||||
return (unsigned char *)UStringOfTerm(inp->val.t);
|
||||
}
|
||||
{
|
||||
inp->type |= YAP_STRING_IN_TMP;
|
||||
size_t sz = strlen(s);
|
||||
char *o = Malloc(sz + 1);
|
||||
strcpy(o, s);
|
||||
return pop_output_text_stack(lvl, o);
|
||||
out = Malloc(sz + 1);
|
||||
strcpy(out, s);
|
||||
POPRET( out );
|
||||
}
|
||||
} else if (IsPairOrNilTerm(inp->val.t)) {
|
||||
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
|
||||
(YAP_STRING_CODES | YAP_STRING_ATOMS)) &&
|
||||
IsPairOrNilTerm(inp->val.t)) {
|
||||
(YAP_STRING_CODES | YAP_STRING_ATOMS))) {
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
return pop_output_text_stack(
|
||||
lvl, Yap_ListToBuffer(NULL, inp->val.t, inp PASS_REGS));
|
||||
out = (char *)Yap_ListToBuffer(NULL, inp->val.t, inp PASS_REGS);
|
||||
POPRET( out );
|
||||
// this is a term, extract to a sfer, and representation is wide
|
||||
}
|
||||
if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) {
|
||||
if (inp->type & YAP_STRING_CODES) {
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
return pop_output_text_stack(
|
||||
lvl, Yap_ListOfCodesToBuffer(NULL, inp->val.t, inp PASS_REGS));
|
||||
out = (char *)Yap_ListOfCodesToBuffer(NULL, inp->val.t, inp PASS_REGS);
|
||||
// this is a term, extract to a sfer, and representation is wide
|
||||
POPRET( out );
|
||||
}
|
||||
if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) {
|
||||
if (inp->type & YAP_STRING_ATOMS) {
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
return pop_output_text_stack(
|
||||
lvl, Yap_ListOfAtomsToBuffer(NULL, inp->val.t, inp PASS_REGS));
|
||||
out = (char *)Yap_ListOfAtomsToBuffer(NULL, inp->val.t, inp PASS_REGS);
|
||||
// this is a term, extract to a buffer, and representation is wide
|
||||
POPRET( out );
|
||||
}
|
||||
}
|
||||
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
|
||||
// ASCII, so both LATIN1 and UTF-8
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
char *s;
|
||||
s = Malloc(2 * MaxTmp(PASS_REGS1));
|
||||
if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
|
||||
out = Malloc(2 * MaxTmp(PASS_REGS1));
|
||||
if (snprintf(out, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
|
||||
IntegerOfTerm(inp->val.t)) < 0) {
|
||||
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
|
||||
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), out, char);
|
||||
}
|
||||
return pop_output_text_stack(lvl, s);
|
||||
POPRET( out );
|
||||
}
|
||||
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
|
||||
char *s;
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, 1024)) {
|
||||
out = Malloc(2 * MaxTmp(PASS_REGS1));
|
||||
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &out, 1024)) {
|
||||
pop_text_stack(lvl);
|
||||
return NULL;
|
||||
}
|
||||
return pop_output_text_stack(lvl, s);
|
||||
POPRET(out);
|
||||
}
|
||||
#if USE_GMP
|
||||
if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) {
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
char *s;
|
||||
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);
|
||||
out = Malloc(MaxTmp());
|
||||
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), out, MaxTmp() - 1,
|
||||
10)) {
|
||||
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), out, char);
|
||||
}
|
||||
return inp->val.uc = pop_output_text_stack(lvl, s);
|
||||
POPRET(out);
|
||||
}
|
||||
#endif
|
||||
if (inp->type & YAP_STRING_TERM) {
|
||||
// Yap_DebugPlWriteln(inp->val.t);
|
||||
char *s = (char *)Yap_TermToBuffer(inp->val.t, ENC_ISO_UTF8, 0);
|
||||
return inp->val.uc = pop_output_text_stack(lvl, s);
|
||||
pop_text_stack(lvl);
|
||||
return Yap_TermToBuffer(inp->val.t, 0);
|
||||
}
|
||||
|
||||
if (inp->type & YAP_STRING_CHARS) {
|
||||
if (inp->enc == ENC_ISO_ASCII) {
|
||||
pop_text_stack(lvl);
|
||||
return inp->val.uc;
|
||||
}
|
||||
|
||||
if (inp->enc == ENC_ISO_LATIN1) {
|
||||
return latin2utf8(inp);
|
||||
} else if (inp->enc == ENC_ISO_ASCII) {
|
||||
return inp->val.uc;
|
||||
} else { // if (inp->enc == ENC_ISO_UTF8) {
|
||||
return inp->val.uc;
|
||||
}
|
||||
POPRET( (char*)latin2utf8(inp));
|
||||
}
|
||||
|
||||
if (inp->enc == ENC_ISO_UTF8) {
|
||||
pop_text_stack(lvl);
|
||||
return inp->val.c;
|
||||
}
|
||||
}
|
||||
if (inp->type & YAP_STRING_WCHARS) {
|
||||
// printf("%S\n",inp->val.w);
|
||||
return wchar2utf8(inp);
|
||||
POPRET( (char *)wchar2utf8(inp) );
|
||||
}
|
||||
pop_text_stack(lvl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -681,16 +688,16 @@ static Term write_codes(void *s0, seq_tv_t *out 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) {
|
||||
if (s[0] == '\0') {
|
||||
return Yap_LookupAtom("");
|
||||
}
|
||||
size_t leng = strlen(s0);
|
||||
if (strlen_utf8(s0) <= leng) {
|
||||
return Yap_LookupAtom(s0);
|
||||
} else {
|
||||
size_t n = get_utf8(s, -1, &ch);
|
||||
unsigned char *buf = Malloc(n + 1);
|
||||
memcpy(buf, s0, n + 1);
|
||||
memmove(buf, s0, n + 1);
|
||||
return Yap_ULookupAtom(buf);
|
||||
}
|
||||
}
|
||||
@ -921,7 +928,7 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
|
||||
const unsigned char *ptr = skip_utf8(buf, out->max);
|
||||
size_t diff = (ptr - buf);
|
||||
char *nbuf = Malloc(diff + 1);
|
||||
memcpy(nbuf, buf, diff);
|
||||
memmove(nbuf, buf, diff);
|
||||
nbuf[diff] = '\0';
|
||||
leng = diff;
|
||||
}
|
||||
|
||||
@ -85,7 +85,7 @@ void *protected_pop_text_stack(int i, void *protected, bool tmp,
|
||||
out = LOCAL_FileNameBuf;
|
||||
else
|
||||
out = p;
|
||||
memcpy(out, protected, sz);
|
||||
memmove(out, protected, sz);
|
||||
} else {
|
||||
free(p);
|
||||
}
|
||||
@ -661,7 +661,7 @@ static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
|
||||
return Yap_LookupAtom(s0);
|
||||
} else {
|
||||
unsigned char *buf = Malloc(leng + 1);
|
||||
memcpy(buf, s0, leng);
|
||||
memmove(buf, s0, leng);
|
||||
buf[leng] = \0;
|
||||
return Yap_ULookupAtom(buf);
|
||||
}
|
||||
@ -872,7 +872,7 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
|
||||
size_t max_s = skip_utf8( buf, out-> max )-buf;
|
||||
if (max_s < leng_s) {
|
||||
char *nbuf = Malloc(max_s + 1);
|
||||
memcpy(nbuf, buf, max_s);
|
||||
memmove(nbuf, buf, max_s);
|
||||
nbuf[max_s] = '\0';
|
||||
leng_s = out->max;
|
||||
}
|
||||
|
||||
@ -87,7 +87,7 @@ static char *send_tracer_message(char *start, char *name, arity_t arity,
|
||||
continue;
|
||||
}
|
||||
}
|
||||
const char *sn = Yap_TermToBuffer(args[i], LOCAL_encoding,
|
||||
const char *sn = Yap_TermToBuffer(args[i],
|
||||
Quote_illegal_f | Handle_vars_f);
|
||||
size_t sz;
|
||||
if (sn == NULL) {
|
||||
|
||||
@ -182,7 +182,7 @@ copy_complex_term(CELL *pt0, CELL *pt0_end, int share, int newattvs, CELL *ptf,
|
||||
if (HR+sz > ASP - 2048) {
|
||||
goto overflow;
|
||||
}
|
||||
memcpy((void *)HR, (void *)ap2, sz*sizeof(CELL));
|
||||
memmove((void *)HR, (void *)ap2, sz*sizeof(CELL));
|
||||
HR += sz;
|
||||
} else {
|
||||
*ptf++ = d0; /* you can just copy other extensions. */
|
||||
@ -845,7 +845,7 @@ export_term_to_buffer(Term inpt, char *buf, char *bptr, CELL *t0 , CELL *tf, siz
|
||||
if (buf + len < (char *)((CELL *)td + (tf-t0))) {
|
||||
return FALSE;
|
||||
}
|
||||
memcpy((void *)td, (void *)t0, (tf-t0)* sizeof(CELL));
|
||||
memmove((void *)td, (void *)t0, (tf-t0)* sizeof(CELL));
|
||||
bf[0] = (td-buf);
|
||||
bf[1] = (tf-t0);
|
||||
bf[2] = inpt;
|
||||
@ -945,7 +945,7 @@ export_complex_term(Term tf, CELL *pt0, CELL *pt0_end, char * buf, size_t len0,
|
||||
if (HR+sz > ASP - 2048) {
|
||||
goto overflow;
|
||||
}
|
||||
memcpy((void *)HR, (void *)ap2, sz*sizeof(CELL));
|
||||
memmove((void *)HR, (void *)ap2, sz*sizeof(CELL));
|
||||
HR += sz;
|
||||
continue;
|
||||
}
|
||||
@ -1263,7 +1263,7 @@ Yap_ImportTerm(char * buf) {
|
||||
return 0L;
|
||||
}
|
||||
}
|
||||
memcpy(HR, buf+bc[0], sizeof(CELL)*sz);
|
||||
memmove(HR, buf+bc[0], sizeof(CELL)*sz);
|
||||
if (IsApplTerm(tinp)) {
|
||||
tret = AbsAppl(HR);
|
||||
import_compound(HR, (char *)HR, buf, HR);
|
||||
@ -3476,7 +3476,7 @@ hash_complex_term(register CELL *pt0,
|
||||
*st++ = LongIntOfTerm(d0);
|
||||
break;
|
||||
case (CELL)FunctorString:
|
||||
memcpy(st, RepAppl(d0), (3+RepAppl(d0)[1])*sizeof(CELL));
|
||||
memmove(st, RepAppl(d0), (3+RepAppl(d0)[1])*sizeof(CELL));
|
||||
st += 3+RepAppl(d0)[1];
|
||||
break;
|
||||
#ifdef USE_GMP
|
||||
@ -3491,7 +3491,7 @@ hash_complex_term(register CELL *pt0,
|
||||
goto global_overflow;
|
||||
}
|
||||
/* then the actual number */
|
||||
memcpy((void *)(st+1), (void *)(pt+1), sz);
|
||||
memmove((void *)(st+1), (void *)(pt+1), sz);
|
||||
st = st+sz/CellSize;
|
||||
}
|
||||
break;
|
||||
|
||||
29
C/write.c
29
C/write.c
@ -384,9 +384,7 @@ int Yap_FormatFloat(Float f, char **s, size_t sz) {
|
||||
wglb.lw = separator;
|
||||
wglb.stream = GLOBAL_Stream + sno;
|
||||
wrputf(f, &wglb);
|
||||
so = Yap_MemExportStreamPtr(sno);
|
||||
*s = BaseMalloc(strlen(so) + 1);
|
||||
strcpy(*s, so);
|
||||
*s = Yap_MemExportStreamPtr(sno);
|
||||
Yap_CloseStream(sno);
|
||||
return true;
|
||||
}
|
||||
@ -1255,28 +1253,3 @@ void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags,
|
||||
pop_text_stack(lvl);
|
||||
}
|
||||
|
||||
char *Yap_TermToBuffer(Term t, encoding_t enc, int flags) {
|
||||
CACHE_REGS
|
||||
int sno = Yap_open_buf_write_stream(enc, flags);
|
||||
const char *sf;
|
||||
|
||||
if (sno < 0)
|
||||
return NULL;
|
||||
if (t == 0)
|
||||
return NULL;
|
||||
else
|
||||
t = Deref(t);
|
||||
if (enc)
|
||||
GLOBAL_Stream[sno].encoding = enc;
|
||||
else
|
||||
GLOBAL_Stream[sno].encoding = LOCAL_encoding;
|
||||
GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
|
||||
Yap_plwrite(t, GLOBAL_Stream + sno, 0, flags, GLOBAL_MaxPriority);
|
||||
|
||||
sf = Yap_MemExportStreamPtr(sno);
|
||||
size_t len = strlen(sf);
|
||||
char *new = malloc(len + 1);
|
||||
strcpy(new, sf);
|
||||
Yap_CloseStream(sno);
|
||||
return new;
|
||||
}
|
||||
|
||||
@ -161,8 +161,7 @@ static bool consult(const char *b_file USES_REGS) {
|
||||
|
||||
/* consult in C */
|
||||
int lvl = push_text_stack();
|
||||
char *full = Malloc(YAP_FILENAME_MAX + 1);
|
||||
full[0] = '\0';
|
||||
char *full;
|
||||
/* the consult mode does not matter here, really */
|
||||
if ((osno = Yap_CheckAlias(AtomLoopStream)) < 0) {
|
||||
osno = 0;
|
||||
@ -204,15 +203,19 @@ static bool consult(const char *b_file USES_REGS) {
|
||||
} else {
|
||||
YAP_CompileClause(t);
|
||||
}
|
||||
} while (true);
|
||||
yap_error_descriptor_t *errd;
|
||||
if ((errd =
|
||||
Yap_GetException(LOCAL_ActiveError))) {
|
||||
fprintf(stderr, "%s:%ld:0: Error %s %s Found\n", errd->errorFile, (long int) errd->errorLine, errd->classAsText,
|
||||
errd->errorAsText);
|
||||
}
|
||||
} while (true);
|
||||
BACKUP_MACHINE_REGS();
|
||||
YAP_EndConsult(c_stream, &osno, full);
|
||||
if (!Yap_AddAlias(AtomLoopStream, osno)) {
|
||||
pop_text_stack(lvl);
|
||||
return false;
|
||||
}
|
||||
pop_text_stack(lvl);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -554,7 +554,7 @@ IF (WITH_PYTHON)
|
||||
ENDIF (WITH_PYTHON)
|
||||
|
||||
option(WITH_R
|
||||
"Allow YAP->R" ON)
|
||||
"Use R Interface" ON)
|
||||
|
||||
IF (WITH_R)
|
||||
include_directories(packages/real )
|
||||
|
||||
28
CXX/yapi.cpp
28
CXX/yapi.cpp
@ -19,7 +19,7 @@ extern "C" {
|
||||
#include "YapInterface.h"
|
||||
#include "iopreds.h"
|
||||
|
||||
X_API char *Yap_TermToBuffer(Term t, encoding_t encodingp, int flags);
|
||||
X_API char *Yap_TermToBuffer(Term t, int flags);
|
||||
|
||||
X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity);
|
||||
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t,
|
||||
@ -30,12 +30,9 @@ X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
|
||||
#if YAP_PYTHON
|
||||
X_API bool do_init_python(void);
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
static void YAPCatchError()
|
||||
{
|
||||
static void YAPCatchError() {
|
||||
if (LOCAL_CommittedError != nullptr &&
|
||||
LOCAL_CommittedError->errorNo != YAP_NO_ERROR) {
|
||||
// Yap_PopTermFromDB(info->errorTerm);
|
||||
@ -189,14 +186,8 @@ YAPStringTerm::YAPStringTerm(char *s) { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.c = s;
|
||||
inp.type = YAP_STRING_CHARS;
|
||||
out.type = YAP_STRING_STRING;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
mk(out.val.t);
|
||||
else
|
||||
t = 0L;
|
||||
Term ts = MkStringTerm(s);
|
||||
mk(ts);
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
@ -528,7 +519,6 @@ bool YAPEngine::mgoal(Term t, Term tmod, bool release) {
|
||||
#if YAP_PYTHON
|
||||
// PyThreadState *_save;
|
||||
|
||||
|
||||
//std::cerr << "mgoal " << YAPTerm(t).text() << "\n";
|
||||
// _save = PyEval_SaveThread();
|
||||
#endif
|
||||
@ -563,6 +553,8 @@ bool YAPEngine::mgoal(Term t, Term tmod, bool release) {
|
||||
//__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
|
||||
|
||||
result = (bool)YAP_EnterGoal(ap, nullptr, &q);
|
||||
//std::cerr << "mgoal " << YAPTerm(t).text() << "\n";
|
||||
|
||||
YAP_LeaveGoal(result && !release, &q);
|
||||
// PyEval_RestoreThread(_save);
|
||||
RECOVER_MACHINE_REGS();
|
||||
@ -672,7 +664,6 @@ goal = YAPApplTerm(f, nts);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
|
||||
BACKUP_MACHINE_REGS();
|
||||
try {
|
||||
@ -688,7 +679,6 @@ YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
|
||||
}
|
||||
names = TermNil;
|
||||
} catch (...) {
|
||||
|
||||
}
|
||||
RECOVER_MACHINE_REGS();
|
||||
}
|
||||
@ -708,6 +698,7 @@ bool YAPQuery::next() {
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
|
||||
|
||||
if (q_state == 0) {
|
||||
// Yap_do_low_level_trace = 1;
|
||||
result = (bool)YAP_EnterGoal(ap, nullptr, &q_h);
|
||||
} else {
|
||||
LOCAL_AllowRestart = q_open;
|
||||
@ -726,8 +717,7 @@ if (!result) {
|
||||
}
|
||||
|
||||
PredEntry *YAPQuery::rewriteUndefQuery() {
|
||||
ARG1 = goal = Yap_SaveTerm(Yap_MkApplTerm(FunctorCall
|
||||
, 1, &goal));
|
||||
ARG1 = goal = Yap_SaveTerm(Yap_MkApplTerm(FunctorCall, 1, &goal));
|
||||
return ap = PredCall;
|
||||
}
|
||||
|
||||
@ -914,7 +904,7 @@ PredEntry *YAPPredicate::getPred(Term &t, CELL *&out) {
|
||||
} else {
|
||||
ap = RepPredProp(PredPropByFunc(f, m));
|
||||
if (out)
|
||||
memcpy( out, RepAppl(t) + 1, ap->ArityOfPE*sizeof(CELL) );
|
||||
memmove(out, RepAppl(t) + 1, ap->ArityOfPE * sizeof(CELL));
|
||||
else
|
||||
out = RepAppl(t) + 1;
|
||||
}
|
||||
|
||||
@ -106,6 +106,7 @@ X_API extern void YAP_UserBackCutCPredicate(const char *name,
|
||||
|
||||
X_API extern YAP_Term YAP_ReadBuffer(const char *s, YAP_Term *tp);
|
||||
|
||||
extern YAP_Term YAP_MkcharPTerm(char *s);
|
||||
|
||||
|
||||
}
|
||||
|
||||
@ -178,6 +178,7 @@ public:
|
||||
// const std::string *s = new std::string("startup.yss");
|
||||
Embedded = true;
|
||||
install = false;
|
||||
|
||||
Yap_InitDefaults(this, nullptr, 0, nullptr);
|
||||
#if YAP_PYTHON
|
||||
Embedded = true;
|
||||
|
||||
27
CXX/yapt.hh
27
CXX/yapt.hh
@ -27,6 +27,13 @@
|
||||
|
||||
class YAPError;
|
||||
|
||||
extern "C" {
|
||||
|
||||
X_API extern Term YAP_MkCharPTerm( char *n);
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Generic Prolog Term
|
||||
*/
|
||||
@ -110,7 +117,7 @@ public:
|
||||
/// numbervars ( int start, bool process=false )
|
||||
intptr_t numberVars(intptr_t start, bool skip_singletons = false);
|
||||
inline Term term() {
|
||||
return gt();
|
||||
return Deref(gt());
|
||||
} /// from YAPTerm to Term (internal YAP representation)
|
||||
YAPTerm arg(int i) {
|
||||
BACKUP_MACHINE_REGS();
|
||||
@ -216,19 +223,15 @@ public:
|
||||
/// return a string with a textual representation of the term
|
||||
virtual const char *text() {
|
||||
CACHE_REGS
|
||||
encoding_t enc = LOCAL_encoding;
|
||||
char *os;
|
||||
|
||||
BACKUP_MACHINE_REGS();
|
||||
if (!(os = Yap_TermToBuffer(Yap_GetFromSlot(t), enc, Handle_vars_f))) {
|
||||
if (!(os = Yap_TermToBuffer(Yap_GetFromSlot(t), Handle_vars_f))) {
|
||||
RECOVER_MACHINE_REGS();
|
||||
return 0;
|
||||
}
|
||||
RECOVER_MACHINE_REGS();
|
||||
size_t length = strlen(os);
|
||||
char *sm = (char *)malloc(length + 1);
|
||||
strcpy(sm, os);
|
||||
return sm;
|
||||
return os;
|
||||
};
|
||||
|
||||
/// return a handle to the term
|
||||
@ -314,12 +317,18 @@ public:
|
||||
tf = ArgOfTerm(i, t0);
|
||||
RECOVER_MACHINE_REGS();
|
||||
return tf;
|
||||
};
|
||||
void putArg(int i, Term targ) {
|
||||
//BACKUP_MACHINE_REGS();
|
||||
Term t0 = gt();
|
||||
RepAppl(t0)[i] = Deref(targ);
|
||||
//RECOVER_MACHINE_REGS();
|
||||
};
|
||||
void putArg(int i, YAPTerm t) {
|
||||
BACKUP_MACHINE_REGS();
|
||||
//BACKUP_MACHINE_REGS();
|
||||
Term t0 = gt();
|
||||
RepAppl(t0)[i] = t.term();
|
||||
RECOVER_MACHINE_REGS();
|
||||
//RECOVER_MACHINE_REGS();
|
||||
};
|
||||
virtual bool isVar() { return false; } /// type check for unbound
|
||||
virtual bool isAtom() { return false; } /// type check for atom
|
||||
|
||||
27
H/TermExt.h
27
H/TermExt.h
@ -288,6 +288,8 @@ INLINE_ONLY bool IsLongIntTerm(Term t) {
|
||||
|
||||
/* extern Functor FunctorString; */
|
||||
|
||||
|
||||
|
||||
#define MkStringTerm(i) __MkStringTerm((i)PASS_REGS)
|
||||
|
||||
INLINE_ONLY Term __MkStringTerm(const char *s USES_REGS);
|
||||
@ -336,6 +338,31 @@ __MkUStringTerm(const unsigned char *s USES_REGS) {
|
||||
return t;
|
||||
}
|
||||
|
||||
#define MkCharPTerm(i) __MkCharPTerm((i)PASS_REGS)
|
||||
|
||||
INLINE_ONLY Term __MkCharPTerm(char *s USES_REGS);
|
||||
|
||||
INLINE_ONLY Term __MkCharPTerm(char *s USES_REGS) {
|
||||
Term t = AbsAppl(HR);
|
||||
size_t sz;
|
||||
if (s[0] == '\0') {
|
||||
sz = sizeof(CELL);
|
||||
HR[0] = (CELL)FunctorString;
|
||||
HR[1] = (CELL)sz;
|
||||
HR[2] = 0;
|
||||
} else {
|
||||
sz = ALIGN_BY_TYPE(strlen((char *)s) + 1, CELL);
|
||||
HR[0] = (CELL)FunctorString;
|
||||
HR[1] = (CELL)sz;
|
||||
strcpy((char *)(HR + 2), (const char *)s);
|
||||
}
|
||||
HR[2 + sz] = EndSpecials;
|
||||
HR += 3 + sz;
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
|
||||
INLINE_ONLY const unsigned char *UStringOfTerm(Term t);
|
||||
|
||||
INLINE_ONLY const unsigned char *UStringOfTerm(Term t) {
|
||||
|
||||
@ -144,12 +144,12 @@ static Term synerr(Term inp) {
|
||||
return inp;
|
||||
|
||||
if (IsAtomTerm(inp)) {
|
||||
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, inp,
|
||||
Yap_ThrowError(DOMAIN_ERROR_OUT_OF_RANGE, inp,
|
||||
"set_prolog_flag in {dec10,error,fail,quiet}");
|
||||
return TermZERO;
|
||||
}
|
||||
Yap_Error(TYPE_ERROR_ATOM, inp,
|
||||
"set_prolog_flag in {dec10,error,fail,quiet}");
|
||||
Yap_ThrowError(TYPE_ERROR_ATOM, inp,
|
||||
"syntax_error flag must be atom");
|
||||
return TermZERO;
|
||||
}
|
||||
|
||||
|
||||
@ -56,29 +56,26 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
~~~
|
||||
*/
|
||||
|
||||
|
||||
|
||||
YAP_FLAG(ANSWER_FORMAT_FLAG, "answer_format", true, isatom, "~p", NULL),
|
||||
/**< how to present answers, default is `~p`. */
|
||||
#if __ANDROID__
|
||||
YAP_FLAG(ANDROID_FLAG, "android", false, booleanFlag, "true", NULL), /**<
|
||||
read-only boolean, a machine running an Google's Android version of the Linux Operating System */
|
||||
read-only boolean, a machine running an Google's Android version of the
|
||||
Linux Operating System */
|
||||
#endif
|
||||
|
||||
|
||||
#if __APPLE__
|
||||
YAP_FLAG(APPLE_FLAG, "apple", false, booleanFlag, "true", NULL), /**<
|
||||
read-only boolean, a machine running an Apple Operating System */
|
||||
#endif
|
||||
YAP_FLAG(ARCH_FLAG, "arch", false, isatom, YAP_ARCH, NULL), /**<
|
||||
read-only atom, it describes the ISA used in this version of YAP.
|
||||
Available from YAP_AEH.
|
||||
Available from YAP_ARCH.
|
||||
*/
|
||||
|
||||
YAP_FLAG(ARGV_FLAG, "argv", false, argv, "@boot", NULL),
|
||||
YAP_FLAG(ARITHMETIC_EXCEPTIONS_FLAG, "arithmetic_exceptions", true,
|
||||
booleanFlag, "true", NULL),
|
||||
/**< `arithmetic_exceptions`
|
||||
/**<
|
||||
|
||||
Read-write flag telling whether arithmetic exceptions generate
|
||||
Prolog exceptions. If enabled:
|
||||
@ -98,8 +95,8 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
It is `true` by default, but it is disabled by packages like CLP(BN) and
|
||||
ProbLog.
|
||||
*/
|
||||
YAP_FLAG(BACK_QUOTES_FLAG, "back_quotes", true, isatom, "true", NULL),
|
||||
/**>
|
||||
YAP_FLAG(BACK_QUOTES_FLAG, "back_quotes", true, isatom, "true", bqs),
|
||||
/**<
|
||||
If _Value_ is unbound, tell whether a back quoted list of characters
|
||||
token is converted to a list of atoms, `chars`, to a list of integers,
|
||||
`codes`, or to a single atom, `atom`. If _Value_ is bound, set to
|
||||
@ -132,12 +129,14 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
Writable flag telling whether a character escapes are enabled,
|
||||
`true`, or disabled, `false`. The default value for this flag is
|
||||
`true`. */
|
||||
YAP_FLAG(COLON_SETS_CALLING_CONTEXT_FLAG, "colon_sets_calling_context", true, booleanFlag, "true", NULL),
|
||||
YAP_FLAG(COLON_SETS_CALLING_CONTEXT_FLAG, "colon_sets_calling_context",
|
||||
true, booleanFlag, "true", NULL),
|
||||
/**< `compiled_at `
|
||||
|
||||
Read-only flag that gives the time when the main YAP binary was compiled. It
|
||||
is obtained staight from the __TIME__ macro, as defined in the C99.
|
||||
*/ YAP_FLAG(COMPILED_AT_FLAG, "compiled_at", false, isatom, YAP_COMPILED_AT,
|
||||
Read-only flag that gives the time when the main YAP binary was compiled.
|
||||
It is obtained staight from the __TIME__ macro, as defined in the C99.
|
||||
*/
|
||||
YAP_FLAG(COMPILED_AT_FLAG, "compiled_at", false, isatom, YAP_COMPILED_AT,
|
||||
NULL),
|
||||
YAP_FLAG(DEBUG_FLAG, "debug", true, booleanFlag, "false", NULL),
|
||||
/**<
|
||||
@ -159,6 +158,15 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
NULL),
|
||||
YAP_FLAG(DEBUGGER_SHOW_CONTEXT_FLAG, "debugger_show_context", true,
|
||||
booleanFlag, "false", NULL),
|
||||
YAP_FLAG(DEFAULT_PARENT_MODULE_FLAG, "default_parent_module", true, isatom,
|
||||
"user", NULL),
|
||||
/**<
|
||||
* A module to be inherited by all other modules. Default is user that
|
||||
* reexports prolog.
|
||||
*
|
||||
* Set it to `prolog` for SICStus Prolog like resolution, to `user` for
|
||||
* SWI-like.
|
||||
*/
|
||||
YAP_FLAG(DIALECT_FLAG, "dialect", false, ro, "yap", NULL),
|
||||
/**<
|
||||
|
||||
@ -180,7 +188,7 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
booleanFlag, "false", NULL),
|
||||
/**<
|
||||
If `off` (default) consider the character `$` a control character, if
|
||||
`on` consider `$` a lower case character.
|
||||
vxu `on` consider `$` a lower case character.
|
||||
*/
|
||||
YAP_FLAG(DOUBLE_QUOTES_FLAG, "double_quotes", true, isatom, "codes", dqs),
|
||||
/**< iso
|
||||
@ -291,6 +299,8 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
value `toward_zero` for the current version of YAP.
|
||||
*/
|
||||
YAP_FLAG(ISO_FLAG, "iso", true, booleanFlag, "false", NULL),
|
||||
YAP_FLAG(JUPYTER_FLAG, "jupyter", false, booleanFlag, "true", NULL), /**<
|
||||
read-only boolean, a machine running Jupyter */
|
||||
YAP_FLAG(LANGUAGE_FLAG, "language", true, isatom, "yap", NULL),
|
||||
/**< `language `
|
||||
|
||||
@ -348,9 +358,8 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
program. This is for compatibility with old software that
|
||||
might expect module-independent operators.
|
||||
*/
|
||||
YAP_FLAG(MODULE_INDEPENDENT_OPERATORS_FLAG,
|
||||
"module_independent_operators", true, booleanFlag,
|
||||
"false", NULL),
|
||||
YAP_FLAG(MODULE_INDEPENDENT_OPERATORS_FLAG, "module_independent_operators",
|
||||
true, booleanFlag, "false", NULL),
|
||||
|
||||
YAP_FLAG(OPTIMISE_FLAG, "optimise", true, booleanFlag, "false", NULL),
|
||||
YAP_FLAG(OS_ARGV_FLAG, "os_argv", false, os_argv, "@boot", NULL),
|
||||
@ -383,6 +392,15 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
|
||||
enable the use of the readline library for console interactions, true by
|
||||
default if readline was found. */
|
||||
YAP_FLAG(REDEFINE_WARNINGS_FLAG, "redefine_warnings", true, booleanFlag,
|
||||
"true", NULL), /**<
|
||||
|
||||
If _Value_ is unbound, tell whether warnings for procedures defined
|
||||
in several different files are `on` or
|
||||
`off`. If _Value_ is bound to `on` enable these warnings,
|
||||
and if it is bound to `off` disable them. The default for YAP is
|
||||
`off`, unless we are in `sicstus` or `iso` mode.
|
||||
*/
|
||||
YAP_FLAG(REPORT_ERROR_FLAG, "report_error", true, booleanFlag, "true",
|
||||
NULL),
|
||||
YAP_FLAG(RESOURCE_DATABASE_FLAG, "resource_database", false, isatom,
|
||||
@ -418,6 +436,15 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
/**< `single_quoted text is usuallly interpreted as atoms. This flagTerm
|
||||
allows other inerpretations such as strings_contains_strings */
|
||||
|
||||
YAP_FLAG(SINGLE_VAR_WARNINGS_FLAG, "single_var_warnings", true, booleanFlag,
|
||||
"true", NULL), /**<
|
||||
If `true` (default `true`) YAP checks for singleton
|
||||
variables when loading files. A singleton variable is a
|
||||
variable that appears ony once in a clause. The name
|
||||
must start with a capital letter, variables whose name
|
||||
starts with underscore are never considered singleton.
|
||||
|
||||
*/
|
||||
YAP_FLAG(SIGNALS_FLAG, "signals", true, booleanFlag, "true", NULL),
|
||||
/**< `signals`
|
||||
|
||||
@ -476,10 +503,7 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
*/
|
||||
YAP_FLAG(THREADS_FLAG, "threads", false, ro, "MAX_THREADS", NULL),
|
||||
YAP_FLAG(TIMEZONE_FLAG, "timezone", false, ro, "18000", NULL),
|
||||
YAP_FLAG(TOPLEVEL_PRINT_ANON_FLAG, "toplevel_print_anon", true, booleanFlag,
|
||||
"true", NULL),
|
||||
YAP_FLAG(TOPLEVEL_HOOK_FLAG, "toplevel_hook", true,
|
||||
booleanFlag, "true",
|
||||
YAP_FLAG(TOPLEVEL_HOOK_FLAG, "toplevel_hook", true, booleanFlag, "true",
|
||||
NULL),
|
||||
/**< `toplevel_hook `
|
||||
|
||||
@ -489,6 +513,8 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
backtracked into.
|
||||
|
||||
*/
|
||||
YAP_FLAG(TOPLEVEL_PRINT_ANON_FLAG, "toplevel_print_anon", true, booleanFlag,
|
||||
"true", NULL),
|
||||
YAP_FLAG(TOPLEVEL_PRINT_OPTIONS_FLAG, "toplevel_print_options", true,
|
||||
list_option, "[quoted(true),numbervars(true),portrayed(true)]",
|
||||
NULL),
|
||||
@ -521,9 +547,9 @@ opportunity. Initial value is 10,000. May be changed. A value of 0
|
||||
are `silent`, `warning` and `error`. The first two create the flag
|
||||
on-the-fly, with `warning` printing a message. The value `error` is
|
||||
consistent with ISO: it raises an existence error and does not create the
|
||||
flag. See also `create_prolog_flag/3`. The default is`error`, and developers
|
||||
are encouraged to use `create_prolog_flag/3` to create flags for their
|
||||
library.
|
||||
flag. See also `create_prolog_flag/3`. The default is`error`, and
|
||||
developers are encouraged to use `create_prolog_flag/3` to create flags for
|
||||
their library.
|
||||
*/
|
||||
YAP_FLAG(UNKNOWN_FLAG, "unknown", true, isatom, "error", Yap_unknown),
|
||||
/**< `unknown is iso`
|
||||
|
||||
@ -10,10 +10,8 @@
|
||||
* *
|
||||
**************************************************************************
|
||||
* *
|
||||
* File: YapLFlagInfo.h *
|
||||
* Last rev: *
|
||||
* mods: *
|
||||
* comments: local flag enumeration. *
|
||||
* File: YapLFlagInfo.h * Last rev:
|
||||
** mods: * comments: local flag enumeration. *
|
||||
* *
|
||||
*************************************************************************/
|
||||
|
||||
@ -34,48 +32,47 @@ START_LOCAL_FLAGS
|
||||
YAP_FLAG(AUTOLOAD_FLAG, "autoload", true, booleanFlag, "false", NULL),
|
||||
/** + `read-only flag, that tells if Prolog is in an inner top-level */
|
||||
YAP_FLAG(BREAK_LEVEL_FLAG, "break_level", true, nat, "0", NULL),
|
||||
YAP_FLAG( CALL_COUNTING_FLAG, "call_counting", true, booleanFlag, "true" , NULL ), /** + `call_counting`
|
||||
YAP_FLAG(CALL_COUNTING_FLAG, "call_counting", true, booleanFlag, "true",
|
||||
NULL), /** + `call_counting`
|
||||
|
||||
Predicates compiled with this flag set maintain a counter on the numbers of proceduree calls and of retries. These counters are decreasing counters, and they can be used as timers. Three counters are available:
|
||||
Predicates compiled with this flag set maintain a counter
|
||||
on the numbers of proceduree calls and of retries. These counters
|
||||
are decreasing counters, and they can be used as timers. Three
|
||||
counters are available:
|
||||
|
||||
calls: number of predicate calls since execution started or since system was reset;
|
||||
retries: number of retries for predicates called since execution started or since counters were reset;
|
||||
calls_and_retries: count both on predicate calls and retries.
|
||||
These counters can be used to find out how many calls a certain goal takes to execute. They can also be force the computatiom yp
|
||||
stopping.
|
||||
calls: number of predicate calls since execution started or
|
||||
since system was reset; retries: number of retries for predicates
|
||||
called since execution started or since counters were reset;
|
||||
calls_and_retries: count both on predicate calls and
|
||||
retries. These counters can be used to find out how many calls a
|
||||
certain goal takes to execute. They can also be force the
|
||||
computatiom yp stopping.
|
||||
|
||||
If `on` `fileerrors` is `on`, if `off` (default)
|
||||
`fileerrors` is disabled.
|
||||
*/
|
||||
YAP_FLAG(ENCODING_FLAG, "encoding", true, isatom, "utf-8", getenc),
|
||||
YAP_FLAG( FILEERRORS_FLAG, "fileerrors", true, booleanFlag, "true" , NULL ), /** + `fileerrors`
|
||||
YAP_FLAG(FILEERRORS_FLAG, "fileerrors", true, booleanFlag, "true",
|
||||
NULL), /** + `fileerrors`
|
||||
|
||||
If `on` `fileerrors` is `on`, if `off` (default)
|
||||
`fileerrors` is disabled.
|
||||
*/
|
||||
YAP_FLAG( LANGUAGE_MODE_FLAG, "language_mode", true, isatom, "yap" , NULL ), /** + `language_mode`
|
||||
YAP_FLAG(LANGUAGE_MODE_FLAG, "language_mode", true, isatom, "yap",
|
||||
NULL), /** + `language_mode`
|
||||
|
||||
wweter native mode or trying to emulate a different Prolog.
|
||||
*/
|
||||
YAP_FLAG( REDEFINE_WARNINGS_FLAG, "redefine_warnings", true, booleanFlag, "true" , NULL ), /** + `redefine_warnings `
|
||||
|
||||
If _Value_ is unbound, tell whether warnings for procedures defined
|
||||
in several different files are `on` or
|
||||
`off`. If _Value_ is bound to `on` enable these warnings,
|
||||
and if it is bound to `off` disable them. The default for YAP is
|
||||
`off`, unless we are in `sicstus` or `iso` mode.
|
||||
*/
|
||||
YAP_FLAG( SINGLE_VAR_WARNINGS_FLAG, "single_var_warnings", true, booleanFlag, "true" , NULL ), /** + `single_var_warnings`
|
||||
If `true` (default `true`) YAP checks for singleton variables when loading files. A singleton variable is a variable that appears ony once in a clause. The name must start with a capital letter, variables whose name starts with underscore are never considered singleton.
|
||||
|
||||
*/
|
||||
YAP_FLAG( STACK_DUMP_ON_ERROR_FLAG, "stack_dump_on_error", true, booleanFlag, "false" , NULL ), /** + `stack_dump_on_error `
|
||||
YAP_FLAG(STACK_DUMP_ON_ERROR_FLAG, "stack_dump_on_error", true, booleanFlag,
|
||||
"true", NULL), /** + `stack_dump_on_error `
|
||||
|
||||
If `true` show a stack dump when YAP finds an error. The default is
|
||||
`off`.
|
||||
*/
|
||||
YAP_FLAG( STREAM_TYPE_CHECK_FLAG, "stream_type_check", true, isatom, "loose" , NULL ),
|
||||
YAP_FLAG( SYNTAX_ERRORS_FLAG, "syntax_errors", true, synerr, "error" , NULL ), /** + `syntax_errors`
|
||||
YAP_FLAG(STREAM_TYPE_CHECK_FLAG, "stream_type_check", true, isatom, "loose",
|
||||
NULL),
|
||||
YAP_FLAG(SYNTAX_ERRORS_FLAG, "syntax_errors", true, synerr, "error",
|
||||
NULL), /** + `syntax_errors`
|
||||
|
||||
Control action to be taken after syntax errors while executing read/1,
|
||||
`read/2`, or `read_term/3`:
|
||||
@ -88,14 +85,16 @@ Report the syntax error and generate an error (default).
|
||||
+ `quiet`
|
||||
Just fail
|
||||
*/
|
||||
YAP_FLAG( TYPEIN_MODULE_FLAG, "typein_module", true, isatom, "user" , typein ), /** + `typein_module `
|
||||
YAP_FLAG(TYPEIN_MODULE_FLAG, "typein_module", true, isatom, "user",
|
||||
typein), /** + `typein_module `
|
||||
|
||||
If bound, set the current working or type-in module to the argument,
|
||||
which must be an atom. If unbound, unify the argument with the current
|
||||
working module.
|
||||
|
||||
*/
|
||||
YAP_FLAG( USER_ERROR_FLAG, "user_error", true, stream, "user_error" , set_error_stream ), /** + `user_error1`
|
||||
YAP_FLAG(USER_ERROR_FLAG, "user_error", true, stream, "user_error",
|
||||
set_error_stream), /** + `user_error1`
|
||||
|
||||
If the second argument is bound to a stream, set user_error to
|
||||
this stream. If the second argument is unbound, unify the argument with
|
||||
@ -126,8 +125,10 @@ prompts from the system were redirected to the stream
|
||||
automatically redirects the user_error alias to the original
|
||||
`stderr`.
|
||||
*/
|
||||
YAP_FLAG( USER_INPUT_FLAG, "user_input", true, stream, "user_input" , set_input_stream ),
|
||||
YAP_FLAG( USER_OUTPUT_FLAG, "user_output", true, stream, "user_output" , set_output_stream ),
|
||||
YAP_FLAG(USER_INPUT_FLAG, "user_input", true, stream, "user_input",
|
||||
set_input_stream),
|
||||
YAP_FLAG(USER_OUTPUT_FLAG, "user_output", true, stream, "user_output",
|
||||
set_output_stream),
|
||||
|
||||
END_LOCAL_FLAGS
|
||||
|
||||
|
||||
16
H/YapText.h
16
H/YapText.h
@ -543,6 +543,22 @@ static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) {
|
||||
return out.val.t;
|
||||
}
|
||||
|
||||
static inline Term Yap_AtomSWIToListOfCodes(Term t0 USES_REGS) {
|
||||
seq_tv_t inp, out;
|
||||
|
||||
inp.val.t = t0;
|
||||
inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT |
|
||||
YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES |YAP_STRING_ATOMS_CODES |YAP_STRING_ATOMS_CODES |
|
||||
YAP_STRING_TERM;
|
||||
out.val.uc = NULL;
|
||||
out.type = YAP_STRING_CODES;
|
||||
|
||||
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
return 0L;
|
||||
return out.val.t;
|
||||
}
|
||||
|
||||
|
||||
static inline Term Yap_AtomToNumber(Term t0 USES_REGS) {
|
||||
seq_tv_t inp, out;
|
||||
inp.val.t = t0;
|
||||
|
||||
@ -35,6 +35,7 @@ extern int Yap_HasOp(Atom);
|
||||
extern struct operator_entry *
|
||||
Yap_GetOpPropForAModuleHavingALock(struct AtomEntryStruct *, Term);
|
||||
extern Atom Yap_LookupAtom(const char *);
|
||||
extern Atom Yap_AtomInUse(const char *atom);
|
||||
extern Atom Yap_ULookupAtom(const unsigned char *);
|
||||
extern Atom Yap_LookupAtomWithLength(const char *, size_t);
|
||||
extern Atom Yap_FullLookupAtom(const char *);
|
||||
@ -309,7 +310,6 @@ extern void Yap_DebugPlWriteln(Term t);
|
||||
extern void Yap_DebugErrorPutc(int n);
|
||||
extern void Yap_DebugErrorPuts(const char *s);
|
||||
extern void Yap_DebugWriteIndicator(struct pred_entry *ap);
|
||||
extern void Yap_PlWriteToStream(Term, int, int);
|
||||
extern void Yap_CloseReadline(void);
|
||||
/* depth_lim.c */
|
||||
extern bool Yap_InitReadline(Term t);
|
||||
|
||||
@ -1298,7 +1298,7 @@ INLINE_ONLY bool IsFlagProperty(PropFlags flags) {
|
||||
/* Proto types */
|
||||
|
||||
|
||||
extern char *Yap_TermToBuffer(Term t, encoding_t encoding, int flags);
|
||||
extern char *Yap_TermToBuffer(Term t, int flags);
|
||||
|
||||
extern Term Yap_BufferToTerm(const char *s, Term opts);
|
||||
|
||||
|
||||
@ -181,14 +181,14 @@ INLINE_ONLY void init_absmi_regs(REGSTORE *absmi_regs);
|
||||
|
||||
INLINE_ONLY void init_absmi_regs(REGSTORE *absmi_regs) {
|
||||
CACHE_REGS
|
||||
memcpy(absmi_regs, Yap_regp, sizeof(REGSTORE));
|
||||
memmove(absmi_regs, Yap_regp, sizeof(REGSTORE));
|
||||
}
|
||||
|
||||
INLINE_ONLY void restore_absmi_regs(REGSTORE *old_regs);
|
||||
|
||||
INLINE_ONLY void restore_absmi_regs(REGSTORE *old_regs) {
|
||||
CACHE_REGS
|
||||
memcpy(old_regs, Yap_regp, sizeof(REGSTORE));
|
||||
memmove(old_regs, Yap_regp, sizeof(REGSTORE));
|
||||
#ifdef THREADS
|
||||
pthread_setspecific(Yap_yaamregs_key, (void *)old_regs);
|
||||
LOCAL_ThreadHandle.current_yaam_regs = old_regs;
|
||||
|
||||
@ -95,7 +95,7 @@ typedef enum{
|
||||
t_createLowerExpectIntrinsicPass, //Removes llvm.expect intrinsics and creates "block_weights" metadata
|
||||
t_createLowerInvokePass, //Converts invoke and unwind instructions to use sjlj exception handling mechanisms
|
||||
t_createLowerSwitchPass, //Converts SwitchInst instructions into a sequence of chained binary branch instructions
|
||||
t_createMemCpyOptPass, //Performs optimizations related to eliminating memcpy calls and/or combining multiple stores into memset's
|
||||
t_createMemCpyOptPass, //Performs optimizations related to eliminating memmove calls and/or combining multiple stores into memset's
|
||||
t_createMergeFunctionsPass, //Discovers identical functions and collapses them
|
||||
t_createObjCARCAPElimPass, //ObjC ARC autorelease pool elimination
|
||||
t_createObjCARCContractPass, //Late ObjC ARC cleanups
|
||||
|
||||
@ -24,7 +24,7 @@
|
||||
/* consulting files */
|
||||
|
||||
typedef union CONSULT_OBJ {
|
||||
const unsigned char *f_name;
|
||||
Atom f_name;
|
||||
int mode;
|
||||
Prop p;
|
||||
UInt c;
|
||||
|
||||
@ -95,7 +95,7 @@ typedef struct {
|
||||
#define utarray_push_back(a,p) do { \
|
||||
utarray_reserve(a,1); \
|
||||
if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,(a)->i++), p); } \
|
||||
else { memcpy(_utarray_eltptr(a,(a)->i++), p, (a)->icd.sz); }; \
|
||||
else { memmove(_utarray_eltptr(a,(a)->i++), p, (a)->icd.sz); }; \
|
||||
} while(0)
|
||||
|
||||
#define utarray_pop_back(a) do { \
|
||||
@ -123,7 +123,7 @@ typedef struct {
|
||||
((a)->i - (j))*((a)->icd.sz)); \
|
||||
} \
|
||||
if ((a)->icd.copy) { (a)->icd.copy( _utarray_eltptr(a,j), p); } \
|
||||
else { memcpy(_utarray_eltptr(a,j), p, (a)->icd.sz); }; \
|
||||
else { memmove(_utarray_eltptr(a,j), p, (a)->icd.sz); }; \
|
||||
(a)->i++; \
|
||||
} while(0)
|
||||
|
||||
@ -142,7 +142,7 @@ typedef struct {
|
||||
(a)->icd.copy(_utarray_eltptr(a,j+_ut_i), _utarray_eltptr(w,_ut_i)); \
|
||||
} \
|
||||
} else { \
|
||||
memcpy(_utarray_eltptr(a,j), _utarray_eltptr(w,0), \
|
||||
memmove(_utarray_eltptr(a,j), _utarray_eltptr(w,0), \
|
||||
utarray_len(w)*((a)->icd.sz)); \
|
||||
} \
|
||||
(a)->i += utarray_len(w); \
|
||||
|
||||
@ -95,7 +95,7 @@ typedef enum{
|
||||
t_createLowerExpectIntrinsicPass, //Removes llvm.expect intrinsics and creates "block_weights" metadata
|
||||
t_createLowerInvokePass, //Converts invoke and unwind instructions to use sjlj exception handling mechanisms
|
||||
t_createLowerSwitchPass, //Converts SwitchInst instructions into a sequence of chained binary branch instructions
|
||||
t_createMemCpyOptPass, //Performs optimizations related to eliminating memcpy calls and/or combining multiple stores into memset's
|
||||
t_createMemCpyOptPass, //Performs optimizations related to eliminating memmove calls and/or combining multiple stores into memset's
|
||||
t_createMergeFunctionsPass, //Discovers identical functions and collapses them
|
||||
t_createObjCARCAPElimPass, //ObjC ARC autorelease pool elimination
|
||||
t_createObjCARCContractPass, //Late ObjC ARC cleanups
|
||||
|
||||
@ -66,29 +66,29 @@ static void share_private_nodes(int worker_q);
|
||||
#endif
|
||||
|
||||
#define P_COPY_GLOBAL_TO(Q) \
|
||||
memcpy((void *) (worker_offset(Q) + REMOTE_start_global_copy(Q)), \
|
||||
memmove((void *) (worker_offset(Q) + REMOTE_start_global_copy(Q)), \
|
||||
(void *) REMOTE_start_global_copy(Q), \
|
||||
(size_t) (REMOTE_end_global_copy(Q) - REMOTE_start_global_copy(Q)))
|
||||
#define Q_COPY_GLOBAL_FROM(P) \
|
||||
memcpy((void *) LOCAL_start_global_copy, \
|
||||
memmove((void *) LOCAL_start_global_copy, \
|
||||
(void *) (worker_offset(P) + LOCAL_start_global_copy), \
|
||||
(size_t) (LOCAL_end_global_copy - LOCAL_start_global_copy))
|
||||
|
||||
#define P_COPY_LOCAL_TO(Q) \
|
||||
memcpy((void *) (worker_offset(Q) + REMOTE_start_local_copy(Q)), \
|
||||
memmove((void *) (worker_offset(Q) + REMOTE_start_local_copy(Q)), \
|
||||
(void *) REMOTE_start_local_copy(Q), \
|
||||
(size_t) (REMOTE_end_local_copy(Q) - REMOTE_start_local_copy(Q)))
|
||||
#define Q_COPY_LOCAL_FROM(P) \
|
||||
memcpy((void *) LOCAL_start_local_copy, \
|
||||
memmove((void *) LOCAL_start_local_copy, \
|
||||
(void *) (worker_offset(P) + LOCAL_start_local_copy), \
|
||||
(size_t) (LOCAL_end_local_copy - LOCAL_start_local_copy))
|
||||
|
||||
#define P_COPY_TRAIL_TO(Q) \
|
||||
memcpy((void *) (worker_offset(Q) + REMOTE_start_trail_copy(Q)), \
|
||||
memmove((void *) (worker_offset(Q) + REMOTE_start_trail_copy(Q)), \
|
||||
(void *) REMOTE_start_trail_copy(Q), \
|
||||
(size_t) (REMOTE_end_trail_copy(Q) - REMOTE_start_trail_copy(Q)))
|
||||
#define Q_COPY_TRAIL_FROM(P) \
|
||||
memcpy((void *) LOCAL_start_trail_copy, \
|
||||
memmove((void *) LOCAL_start_trail_copy, \
|
||||
(void *) (worker_offset(P) + LOCAL_start_trail_copy), \
|
||||
(size_t) (LOCAL_end_trail_copy - LOCAL_start_trail_copy))
|
||||
|
||||
|
||||
@ -409,13 +409,13 @@ void resume_suspension_frame(susp_fr_ptr resume_fr, or_fr_ptr top_or_fr) {
|
||||
sg_fr_ptr sg_frame;
|
||||
|
||||
/* copy suspended stacks */
|
||||
memcpy(SuspFr_global_reg(resume_fr),
|
||||
memmove(SuspFr_global_reg(resume_fr),
|
||||
SuspFr_global_start(resume_fr),
|
||||
SuspFr_global_size(resume_fr));
|
||||
memcpy(SuspFr_local_reg(resume_fr),
|
||||
memmove(SuspFr_local_reg(resume_fr),
|
||||
SuspFr_local_start(resume_fr),
|
||||
SuspFr_local_size(resume_fr));
|
||||
memcpy(SuspFr_trail_reg(resume_fr),
|
||||
memmove(SuspFr_trail_reg(resume_fr),
|
||||
SuspFr_trail_start(resume_fr),
|
||||
SuspFr_trail_size(resume_fr));
|
||||
|
||||
|
||||
@ -574,9 +574,9 @@ typedef enum {
|
||||
SuspFr_global_size(SUSP_FR) = H_SIZE; \
|
||||
SuspFr_local_size(SUSP_FR) = B_SIZE; \
|
||||
SuspFr_trail_size(SUSP_FR) = TR_SIZE; \
|
||||
memcpy(SuspFr_global_start(SUSP_FR), SuspFr_global_reg(SUSP_FR), H_SIZE); \
|
||||
memcpy(SuspFr_local_start(SUSP_FR), SuspFr_local_reg(SUSP_FR), B_SIZE); \
|
||||
memcpy(SuspFr_trail_start(SUSP_FR), SuspFr_trail_reg(SUSP_FR), TR_SIZE)
|
||||
memmove(SuspFr_global_start(SUSP_FR), SuspFr_global_reg(SUSP_FR), H_SIZE); \
|
||||
memmove(SuspFr_local_start(SUSP_FR), SuspFr_local_reg(SUSP_FR), B_SIZE); \
|
||||
memmove(SuspFr_trail_start(SUSP_FR), SuspFr_trail_reg(SUSP_FR), TR_SIZE)
|
||||
|
||||
#define new_subgoal_trie_node(NODE, ENTRY, CHILD, PARENT, NEXT) \
|
||||
ALLOC_SUBGOAL_TRIE_NODE(NODE); \
|
||||
|
||||
@ -665,12 +665,12 @@ static void traverse_subgoal_trie(sg_node_ptr current_node, char *str,
|
||||
bucket = Hash_buckets(hash);
|
||||
last_bucket = bucket + Hash_num_buckets(hash);
|
||||
current_arity = (int *)malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
do {
|
||||
if (*bucket) {
|
||||
traverse_subgoal_trie(*bucket, str, str_index, arity, mode,
|
||||
TRAVERSE_POSITION_FIRST PASS_REGS);
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
#ifdef TRIE_COMPACT_PAIRS
|
||||
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
|
||||
str[str_index - 1] = ',';
|
||||
@ -687,7 +687,7 @@ static void traverse_subgoal_trie(sg_node_ptr current_node, char *str,
|
||||
/* save current state if first sibling node */
|
||||
if (position == TRAVERSE_POSITION_FIRST) {
|
||||
current_arity = (int *)malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
current_str_index = str_index;
|
||||
current_mode = mode;
|
||||
}
|
||||
@ -737,7 +737,7 @@ static void traverse_subgoal_trie(sg_node_ptr current_node, char *str,
|
||||
mode = current_mode;
|
||||
current_node = TrNode_next(current_node);
|
||||
while (current_node) {
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
#ifdef TRIE_COMPACT_PAIRS
|
||||
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
|
||||
str[str_index - 1] = ',';
|
||||
@ -768,12 +768,12 @@ static void traverse_answer_trie(ans_node_ptr current_node, char *str,
|
||||
bucket = Hash_buckets(hash);
|
||||
last_bucket = bucket + Hash_num_buckets(hash);
|
||||
current_arity = (int *)malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
do {
|
||||
if (*bucket) {
|
||||
traverse_answer_trie(*bucket, str, str_index, arity, var_index, mode,
|
||||
TRAVERSE_POSITION_FIRST PASS_REGS);
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
#ifdef TRIE_COMPACT_PAIRS
|
||||
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
|
||||
str[str_index - 1] = ',';
|
||||
@ -790,7 +790,7 @@ static void traverse_answer_trie(ans_node_ptr current_node, char *str,
|
||||
/* save current state if first sibling node */
|
||||
if (position == TRAVERSE_POSITION_FIRST) {
|
||||
current_arity = (int *)malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
current_str_index = str_index;
|
||||
current_var_index = var_index;
|
||||
current_mode = mode;
|
||||
@ -832,7 +832,7 @@ static void traverse_answer_trie(ans_node_ptr current_node, char *str,
|
||||
mode = current_mode;
|
||||
current_node = TrNode_next(current_node);
|
||||
while (current_node) {
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
#ifdef TRIE_COMPACT_PAIRS
|
||||
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
|
||||
str[str_index - 1] = ',';
|
||||
@ -863,12 +863,12 @@ static void traverse_global_trie(gt_node_ptr current_node, char *str,
|
||||
bucket = Hash_buckets(hash);
|
||||
last_bucket = bucket + Hash_num_buckets(hash);
|
||||
current_arity = (int *)malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
do {
|
||||
if (*bucket) {
|
||||
traverse_global_trie(*bucket, str, str_index, arity, mode,
|
||||
TRAVERSE_POSITION_FIRST PASS_REGS);
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
#ifdef TRIE_COMPACT_PAIRS
|
||||
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
|
||||
str[str_index - 1] = ',';
|
||||
@ -885,7 +885,7 @@ static void traverse_global_trie(gt_node_ptr current_node, char *str,
|
||||
/* save current state if first sibling node */
|
||||
if (position == TRAVERSE_POSITION_FIRST) {
|
||||
current_arity = (int *)malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
current_str_index = str_index;
|
||||
current_mode = mode;
|
||||
}
|
||||
@ -913,7 +913,7 @@ static void traverse_global_trie(gt_node_ptr current_node, char *str,
|
||||
mode = current_mode;
|
||||
current_node = TrNode_next(current_node);
|
||||
while (current_node) {
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
#ifdef TRIE_COMPACT_PAIRS
|
||||
if (arity[arity[0]] == -2 && str[str_index - 1] != '[')
|
||||
str[str_index - 1] = ',';
|
||||
@ -1200,7 +1200,7 @@ sg_fr_ptr subgoal_search(yamop *preg, CELL **Yaddr) {
|
||||
#ifdef MODE_DIRECTED_TABLING
|
||||
if (subs_pos) {
|
||||
ALLOC_BLOCK(mode_directed, subs_pos * sizeof(int), int);
|
||||
memcpy((void *)mode_directed, (void *)aux_mode_directed,
|
||||
memmove((void *)mode_directed, (void *)aux_mode_directed,
|
||||
subs_pos * sizeof(int));
|
||||
} else
|
||||
mode_directed = NULL;
|
||||
|
||||
@ -77,7 +77,7 @@
|
||||
#define copy_aux_stack() \
|
||||
{ arity_t size = 3 + heap_arity + subs_arity + vars_arity; \
|
||||
TOP_STACK -= size; \
|
||||
memcpy(TOP_STACK, aux_stack, size * sizeof(CELL *)); \
|
||||
memmove(TOP_STACK, aux_stack, size * sizeof(CELL *)); \
|
||||
aux_stack = TOP_STACK; \
|
||||
}/* macros 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' **
|
||||
** do not include 'set_cut' because trie instructions are cut safe */
|
||||
|
||||
@ -77,7 +77,7 @@
|
||||
#define copy_aux_stack() \
|
||||
{ int size = 3 + heap_arity + subs_arity + vars_arity; \
|
||||
TOP_STACK -= size; \
|
||||
memcpy(TOP_STACK, aux_stack, size * sizeof(CELL *)); \
|
||||
memmove(TOP_STACK, aux_stack, size * sizeof(CELL *)); \
|
||||
aux_stack = TOP_STACK; \
|
||||
}/* macros 'store_trie_node', 'restore_trie_node' and 'pop_trie_node' **
|
||||
** do not include 'set_cut' because trie instructions are cut safe */
|
||||
|
||||
@ -496,7 +496,7 @@
|
||||
/* Define to 1 if you have the `mbsnrtowcs' function. */
|
||||
#undef HAVE_MBSNRTOWCS
|
||||
|
||||
/* Define to 1 if you have the `memcpy' function. */
|
||||
/* Define to 1 if you have the `memmove' function. */
|
||||
#undef HAVE_MEMCPY
|
||||
|
||||
/* Define to 1 if you have the `memmove' function. */
|
||||
|
||||
@ -1767,7 +1767,7 @@ AC_CHECK_FUNCS(localeconv localtime lstat mallinfo)
|
||||
AC_CHECK_FUNCS(mbscoll)
|
||||
AC_CHECK_FUNCS(mbscasecoll)
|
||||
AC_CHECK_FUNCS(mbsnrtowcs)
|
||||
AC_CHECK_FUNCS(memcpy memmove mkstemp mktemp)
|
||||
AC_CHECK_FUNCS(memmove memmove mkstemp mktemp)
|
||||
AC_CHECK_FUNCS(nanosleep mktime opendir)
|
||||
AC_CHECK_FUNCS(putenv rand random drand48)
|
||||
AC_CHECK_FUNCS(readlink realpath regexec)
|
||||
|
||||
@ -291,7 +291,7 @@ check_symbol_exists(mallinfo " malloc.h" HAVE_MALLINFO)
|
||||
check_function_exists(mbscoll HAVE_MBSCOLL)
|
||||
check_function_exists(mbscasecoll HAVE_MBSCASECOLL)
|
||||
check_function_exists(mbsnrtowcs HAVE_MBSNRTOWCS)
|
||||
check_function_exists(memcpy HAVE_MEMCPY)
|
||||
check_function_exists(memmove HAVE_MEMCPY)
|
||||
check_function_exists(memmove HAVE_MEMMOVE)
|
||||
check_function_exists(mkstemp HAVE_MKSTEMP)
|
||||
check_function_exists(mktemp HAVE_MKTEMP)
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
#
|
||||
# FindLibR.cmake
|
||||
#
|
||||
# Copyright (C) 2009-11 by RStudio, Inc.
|
||||
# Copyright (C) 2009-18 by RStudio, Inc.
|
||||
#
|
||||
# This program is licensed to you under the terms of version 3 of the
|
||||
# GNU Affero General Public License. This program is distributed WITHOUT
|
||||
@ -21,11 +21,24 @@
|
||||
if(APPLE)
|
||||
|
||||
find_library(LIBR_LIBRARIES R)
|
||||
if(LIBR_LIBRARIES)
|
||||
|
||||
if(LIBR_LIBRARIES MATCHES ".*\\.framework")
|
||||
set(LIBR_HOME "${LIBR_LIBRARIES}/Resources" CACHE PATH "R home directory")
|
||||
set(LIBR_INCLUDE_DIRS "${LIBR_HOME}/include" CACHE PATH "R include directory")
|
||||
set(LIBR_DOC_DIR "${LIBR_HOME}/doc" CACHE PATH "R doc directory")
|
||||
set(LIBR_EXECUTABLE "${LIBR_HOME}/R" CACHE PATH "R executable")
|
||||
else()
|
||||
get_filename_component(_LIBR_LIBRARIES "${LIBR_LIBRARIES}" REALPATH)
|
||||
get_filename_component(_LIBR_LIBRARIES_DIR "${_LIBR_LIBRARIES}" PATH)
|
||||
set(LIBR_EXECUTABLE "${_LIBR_LIBRARIES_DIR}/../bin/R")
|
||||
execute_process(
|
||||
COMMAND ${LIBR_EXECUTABLE} "--slave" "--vanilla" "-e" "cat(R.home())"
|
||||
OUTPUT_VARIABLE LIBR_HOME
|
||||
)
|
||||
set(LIBR_HOME ${LIBR_HOME} CACHE PATH "R home directory")
|
||||
set(LIBR_INCLUDE_DIRS "${LIBR_HOME}/include" CACHE PATH "R include directory")
|
||||
set(LIBR_DOC_DIR "${LIBR_HOME}/doc" CACHE PATH "R doc directory")
|
||||
set(LIBR_LIB_DIR "${LIBR_HOME}/lib" CACHE PATH "R lib directory")
|
||||
endif()
|
||||
|
||||
# detection for UNIX & Win32
|
||||
@ -103,12 +116,15 @@ else()
|
||||
set(LIBR_INCLUDE_DIRS "${LIBR_HOME}/include" CACHE PATH "R include directory")
|
||||
set(LIBR_DOC_DIR "${LIBR_HOME}/doc" CACHE PATH "R doc directory")
|
||||
|
||||
# set library hint path based on whether we are doing a special session 64 build
|
||||
if(LIBR_FIND_WINDOWS_64BIT)
|
||||
# set library hint path for 64-bit build
|
||||
set(LIBR_ARCH "x64")
|
||||
set(LIBRARY_ARCH_HINT_PATH "${LIBR_HOME}/bin/x64")
|
||||
else()
|
||||
set(LIBRARY_ARCH_HINT_PATH "${LIBR_HOME}/bin/i386")
|
||||
endif()
|
||||
|
||||
# call dll2lib.R to ensure export files are generated
|
||||
execute_process(
|
||||
COMMAND "${LIBR_HOME}/bin/${LIBR_ARCH}/Rscript.exe" "dll2lib.R"
|
||||
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/tools"
|
||||
RESULT_VARIABLE LIBR_DLL2LIB_RESULT)
|
||||
|
||||
endif()
|
||||
|
||||
@ -173,6 +189,7 @@ find_package_handle_standard_args(LibR DEFAULT_MSG
|
||||
|
||||
if(LIBR_FOUND)
|
||||
message(STATUS "Found R: ${LIBR_HOME}")
|
||||
get_filename_component(LIBR_BIN_DIR "${LIBR_EXECUTABLE}" PATH CACHE)
|
||||
endif()
|
||||
|
||||
# mark low-level variables from FIND_* calls as advanced
|
||||
|
||||
@ -897,7 +897,7 @@ function. */
|
||||
#cmakedefine HAVE_MBSNRTOWCS ${HAVE_MBSNRTOWCS}
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the `memcpy' function. */
|
||||
/* Define to 1 if you have the `memmove' function. */
|
||||
#ifndef HAVE_MEMCPY
|
||||
#cmakedefine HAVE_MEMCPY ${HAVE_MEMCPY}
|
||||
#endif
|
||||
|
||||
@ -356,7 +356,7 @@ Srlc_write(void *handle, char *buffer, size_t size)
|
||||
{ char buf[sizeof(TCHAR)]; /* Pad to TCHAR */
|
||||
size_t i = sizeof(TCHAR) - (size-n);
|
||||
|
||||
memcpy(buf, buffer+n, i);
|
||||
memmove(buf, buffer+n, i);
|
||||
for(; i<sizeof(TCHAR); i++)
|
||||
buf[i] = '?';
|
||||
rlc_write(c, (TCHAR*)buffer, 1);
|
||||
|
||||
@ -203,6 +203,8 @@ typedef struct yap_boot_params {
|
||||
const char *INPUT_STARTUP;
|
||||
//> bootstrapping mode: YAP is not properly installed
|
||||
bool install;
|
||||
//> jupyter mode: YAP is in space
|
||||
bool jupyter;
|
||||
//> generats a saved space at this path
|
||||
const char *OUTPUT_STARTUP;
|
||||
//> if NON-0, minimal size for Heap or Code Area
|
||||
|
||||
@ -21,7 +21,7 @@ ECLASS(INSTANTIATION_ERROR_CLASS, "instantiation_error", 0)
|
||||
/// bad access, I/O
|
||||
ECLASS(PERMISSION_ERROR, "permission_error", 3)
|
||||
/// something that could not be represented into a type
|
||||
ECLASS(REPRESENTATION_ERROR, "representation_error", 1)
|
||||
ECLASS(REPRESENTATION_ERROR, "representation_error", 0)
|
||||
/// not enough ....
|
||||
ECLASS(RESOURCE_ERROR, "resource_error", 2)
|
||||
/// bad text
|
||||
|
||||
@ -26,7 +26,7 @@
|
||||
*/
|
||||
|
||||
|
||||
:- module(charsio, [
|
||||
:- module(system(charsio), [
|
||||
format_to_chars/3,
|
||||
format_to_chars/4,
|
||||
write_to_chars/3,
|
||||
|
||||
@ -70,7 +70,6 @@ Moyle. All rights reserved.
|
||||
|
||||
static atom_t ATOM_nil;
|
||||
|
||||
extern int PL_unify_termv(term_t l, va_list args);
|
||||
|
||||
extern X_API Atom YAP_AtomFromSWIAtom(atom_t at);
|
||||
extern X_API atom_t YAP_SWIAtomFromAtom(Atom at);
|
||||
@ -818,6 +817,14 @@ X_API int PL_unify_bool(term_t t, int a) {
|
||||
return Yap_unify(Yap_GetFromSlot(t), iterm);
|
||||
}
|
||||
|
||||
X_API int PL_put_bool(term_t t, int a) {
|
||||
CACHE_REGS
|
||||
CELL *pt = Yap_AddressFromHandle( t );
|
||||
Term iterm = (a ? MkAtomTerm(AtomTrue) : MkAtomTerm(AtomFalse));
|
||||
*pt = iterm;
|
||||
return true;
|
||||
}
|
||||
|
||||
#if USE_GMP
|
||||
|
||||
/*******************************
|
||||
@ -1273,7 +1280,7 @@ YAP: NO EQUIVALENT */
|
||||
X_API int PL_raise_exception(term_t exception) {
|
||||
CACHE_REGS
|
||||
LOCAL_Error_TYPE = THROW_EVENT;
|
||||
LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(Yap_GetFromHandle(exception), LOCAL_encoding, TermNil);
|
||||
LOCAL_ActiveError->errorGoal = Yap_TermToBuffer(Yap_GetFromHandle(exception), 0);
|
||||
//Yap_PutException(Yap_GetFromSlot(exception));
|
||||
Yap_RaiseException();
|
||||
return 0;
|
||||
@ -1321,7 +1328,7 @@ X_API int PL_unify_atom_chars(term_t t, const char *s) {
|
||||
Atom at;
|
||||
while ((at = Yap_CharsToAtom(s, ENC_ISO_LATIN1 PASS_REGS)) == 0L) {
|
||||
if (LOCAL_Error_TYPE && !Yap_SWIHandleError("PL_unify_atom_nchars"))
|
||||
return FALSE;
|
||||
return true;
|
||||
}
|
||||
Yap_AtomIncreaseHold(at);
|
||||
return Yap_unify(Yap_GetFromSlot(t), MkAtomTerm(at));
|
||||
|
||||
@ -593,7 +593,7 @@ Bfree
|
||||
}
|
||||
}
|
||||
|
||||
#define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \
|
||||
#define Bcopy(x,y) memmove((char *)&x->sign, (char *)&y->sign, \
|
||||
y->wds*sizeof(Long) + 2*sizeof(int))
|
||||
|
||||
static Bigint *
|
||||
|
||||
@ -42,7 +42,7 @@ growBuffer(Buffer b, size_t minfree)
|
||||
{ if ( !(new = malloc(sz)) )
|
||||
return FALSE;
|
||||
|
||||
memcpy(new, b->static_buffer, osz);
|
||||
memmove(new, b->static_buffer, osz);
|
||||
} else
|
||||
{ if ( !(new = realloc(b->base, sz)) )
|
||||
return FALSE;
|
||||
|
||||
@ -2381,7 +2381,7 @@ re_buffer(IOSTREAM *s, const char *from, size_t len)
|
||||
{ s->bufp = s->limitp = s->buffer;
|
||||
}
|
||||
|
||||
memcpy(s->bufp, from, len);
|
||||
memmove(s->bufp, from, len);
|
||||
s->bufp += len;
|
||||
}
|
||||
|
||||
@ -5846,7 +5846,7 @@ struct PL_local_data *Yap_InitThreadIO(int wid)
|
||||
return p;
|
||||
}
|
||||
#if THREADS
|
||||
memcpy(p, Yap_local[0]->PL_local_data_p_, sizeof(struct PL_local_data));
|
||||
memmove(p, Yap_local[0]->PL_local_data_p_, sizeof(struct PL_local_data));
|
||||
#endif
|
||||
return p;
|
||||
}
|
||||
|
||||
@ -1426,7 +1426,7 @@ localizeDecimalPoint(PL_locale *locale, Buffer b)
|
||||
|
||||
if ( strncmp(e, ddp, ddplen) == 0 )
|
||||
{ if ( dplen == ddplen )
|
||||
{ memcpy(e, dp, dplen);
|
||||
{ memmove(e, dp, dplen);
|
||||
} else
|
||||
{ char *ob = baseBuffer(b, char);
|
||||
if ( dplen > ddplen && !growBuffer(b, dplen-ddplen) )
|
||||
@ -1434,7 +1434,7 @@ localizeDecimalPoint(PL_locale *locale, Buffer b)
|
||||
e += baseBuffer(b, char) - ob;
|
||||
|
||||
memmove(&e[dplen-ddplen], e, strlen(e)+1);
|
||||
memcpy(e, dp, dplen);
|
||||
memmove(e, dp, dplen);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1477,7 +1477,7 @@ groupDigits(PL_locale *locale, Buffer b)
|
||||
{ *o-- = *e--;
|
||||
if ( --gsize == 0 && e>=s )
|
||||
{ o -= thslen-1;
|
||||
memcpy(o, ths, thslen);
|
||||
memmove(o, ths, thslen);
|
||||
o--;
|
||||
if ( grouping[1] == 0 )
|
||||
gsize = grouping[0];
|
||||
|
||||
@ -429,7 +429,7 @@ win_exec(size_t len, const wchar_t *cmd, UINT show)
|
||||
|
||||
/* ensure 0-terminated */
|
||||
wcmd = PL_malloc((len+1)*sizeof(wchar_t));
|
||||
memcpy(wcmd, cmd, len*sizeof(wchar_t));
|
||||
memmove(wcmd, cmd, len*sizeof(wchar_t));
|
||||
wcmd[len] = 0;
|
||||
|
||||
rval = CreateProcessW(NULL, /* app */
|
||||
|
||||
@ -953,7 +953,7 @@ getenv3(const char *name, char *buf, size_t len)
|
||||
|
||||
if ( s )
|
||||
{ if ( (l=strlen(s)) < len )
|
||||
memcpy(buf, s, l+1);
|
||||
memmove(buf, s, l+1);
|
||||
else if ( len > 0 )
|
||||
buf[0] = EOS; /* empty string if not fit */
|
||||
|
||||
|
||||
@ -253,7 +253,7 @@ static void growToBuffer(int c, ReadData _PL_rd) {
|
||||
if (rb.base == rb.fast) /* intptr_t clause: jump to use malloc() */
|
||||
{
|
||||
rb.base = PL_malloc(FASTBUFFERSIZE * 2);
|
||||
memcpy(rb.base, rb.fast, FASTBUFFERSIZE);
|
||||
memmove(rb.base, rb.fast, FASTBUFFERSIZE);
|
||||
} else
|
||||
rb.base = PL_realloc(rb.base, rb.size * 2);
|
||||
|
||||
|
||||
@ -491,7 +491,7 @@ Sread_readline(void *handle, char *buf, size_t size)
|
||||
{ PL_warning("Input line too long"); /* must be tested! */
|
||||
l = size-1;
|
||||
}
|
||||
memcpy(buf, line, l);
|
||||
memmove(buf, line, l);
|
||||
buf[l++] = '\n';
|
||||
rval = l;
|
||||
|
||||
|
||||
@ -239,7 +239,7 @@ S__setbuf(IOSTREAM *s, char *buffer, size_t size)
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(newbuf, s->bufp, copy);
|
||||
memmove(newbuf, s->bufp, copy);
|
||||
S__removebuf(s);
|
||||
s->unbuffer = newunbuf;
|
||||
s->bufp = s->buffer = newbuf;
|
||||
@ -1173,7 +1173,7 @@ Speekcode(IOSTREAM *s)
|
||||
|
||||
if ( s->bufp + UNDO_SIZE > s->limitp && !(s->flags&SIO_USERBUF) )
|
||||
{ safe = s->limitp - s->bufp;
|
||||
memcpy(s->buffer-safe, s->bufp, safe);
|
||||
memmove(s->buffer-safe, s->bufp, safe);
|
||||
}
|
||||
|
||||
start = s->bufp;
|
||||
@ -1262,11 +1262,11 @@ Sfread(void *data, size_t size, size_t elms, IOSTREAM *s)
|
||||
{ size_t avail = s->limitp - s->bufp;
|
||||
|
||||
if ( chars <= avail )
|
||||
{ memcpy(buf, s->bufp, chars);
|
||||
{ memmove(buf, s->bufp, chars);
|
||||
s->bufp += chars;
|
||||
return elms;
|
||||
} else
|
||||
{ memcpy(buf, s->bufp, avail);
|
||||
{ memmove(buf, s->bufp, avail);
|
||||
chars -= avail;
|
||||
buf += avail;
|
||||
s->bufp += avail;
|
||||
@ -1325,7 +1325,7 @@ Sread_pending(IOSTREAM *s, char *buf, size_t limit, int flags)
|
||||
n = s->limitp - s->bufp;
|
||||
if ( n > limit )
|
||||
n = limit;
|
||||
memcpy(&buf[done], s->bufp, n);
|
||||
memmove(&buf[done], s->bufp, n);
|
||||
s->bufp += n;
|
||||
|
||||
return done+n;
|
||||
@ -3439,7 +3439,7 @@ Swrite_memfile(void *handle, char *buf, size_t size)
|
||||
}
|
||||
if ( !mf->malloced )
|
||||
{ if ( mf->buffer )
|
||||
memcpy(nb, mf->buffer, mf->allocated);
|
||||
memmove(nb, mf->buffer, mf->allocated);
|
||||
mf->malloced = TRUE;
|
||||
}
|
||||
} else
|
||||
@ -3453,7 +3453,7 @@ Swrite_memfile(void *handle, char *buf, size_t size)
|
||||
*mf->bufferp = mf->buffer = nb;
|
||||
}
|
||||
|
||||
memcpy(&mf->buffer[mf->here], buf, size);
|
||||
memmove(&mf->buffer[mf->here], buf, size);
|
||||
mf->here += size;
|
||||
|
||||
if ( mf->here > mf->size )
|
||||
@ -3478,7 +3478,7 @@ Sread_memfile(void *handle, char *buf, size_t size)
|
||||
size = mf->size - mf->here;
|
||||
}
|
||||
|
||||
memcpy(buf, &mf->buffer[mf->here], size);
|
||||
memmove(buf, &mf->buffer[mf->here], size);
|
||||
mf->here += size;
|
||||
|
||||
return size;
|
||||
|
||||
@ -69,7 +69,7 @@ PL_save_text(PL_chars_t *text, int flags)
|
||||
{ size_t bl = bufsize_text(text, text->length+1);
|
||||
void *new = PL_malloc(bl);
|
||||
|
||||
memcpy(new, text->text.t, bl);
|
||||
memmove(new, text->text.t, bl);
|
||||
text->text.t = new;
|
||||
text->storage = PL_CHARS_MALLOC;
|
||||
} else if ( text->storage == PL_CHARS_LOCAL )
|
||||
@ -104,7 +104,7 @@ PL_from_stack_text(PL_chars_t *text)
|
||||
{ size_t bl = bufsize_text(text, text->length+1);
|
||||
|
||||
if ( bl < sizeof(text->buf) )
|
||||
{ memcpy(text->buf, text->text.t, bl);
|
||||
{ memmove(text->buf, text->text.t, bl);
|
||||
text->text.t = text->buf;
|
||||
text->storage = PL_CHARS_LOCAL;
|
||||
} else
|
||||
@ -135,7 +135,7 @@ ui64toa(uint64_t val, char *out)
|
||||
} while ( val );
|
||||
|
||||
nbDigs = ptrOrg - ptr;
|
||||
memcpy(out, ptr, nbDigs);
|
||||
memmove(out, ptr, nbDigs);
|
||||
out += nbDigs;
|
||||
*out = '\0';
|
||||
|
||||
@ -610,7 +610,7 @@ PL_promote_text(PL_chars_t *text)
|
||||
unsigned char *e = &buf[text->length];
|
||||
pl_wchar_t *t = (pl_wchar_t*)text->buf;
|
||||
|
||||
memcpy(buf, text->buf, text->length*sizeof(char));
|
||||
memmove(buf, text->buf, text->length*sizeof(char));
|
||||
while(f<e)
|
||||
{ *t++ = *f++;
|
||||
}
|
||||
@ -663,7 +663,7 @@ PL_demote_text(PL_chars_t *text)
|
||||
pl_wchar_t *e = &buf[text->length];
|
||||
char *t = text->buf;
|
||||
|
||||
memcpy(buf, text->buf, text->length*sizeof(pl_wchar_t));
|
||||
memmove(buf, text->buf, text->length*sizeof(pl_wchar_t));
|
||||
while(f<e)
|
||||
{ if ( *f > 0xff )
|
||||
return FALSE;
|
||||
@ -1021,7 +1021,7 @@ PL_canonise_text(PL_chars_t *text)
|
||||
text->encoding = ENC_WCHAR;
|
||||
if ( len+1 < sizeof(text->buf)/sizeof(wchar_t) )
|
||||
{ if ( text->text.t == text->buf )
|
||||
{ memcpy(b2, text->buf, sizeof(text->buf));
|
||||
{ memmove(b2, text->buf, sizeof(text->buf));
|
||||
from = b2;
|
||||
}
|
||||
text->text.w = (wchar_t*)text->buf;
|
||||
@ -1239,7 +1239,7 @@ PL_concat_text(int n, PL_chars_t **text, PL_chars_t *result)
|
||||
}
|
||||
|
||||
for(to=result->text.t, i=0; i<n; i++)
|
||||
{ memcpy(to, text[i]->text.t, text[i]->length);
|
||||
{ memmove(to, text[i]->text.t, text[i]->length);
|
||||
to += text[i]->length;
|
||||
}
|
||||
*to = EOS;
|
||||
@ -1257,7 +1257,7 @@ PL_concat_text(int n, PL_chars_t **text, PL_chars_t *result)
|
||||
|
||||
for(to=result->text.w, i=0; i<n; i++)
|
||||
{ if ( text[i]->encoding == ENC_WCHAR )
|
||||
{ memcpy(to, text[i]->text.w, text[i]->length*sizeof(pl_wchar_t));
|
||||
{ memmove(to, text[i]->text.w, text[i]->length*sizeof(pl_wchar_t));
|
||||
to += text[i]->length;
|
||||
} else
|
||||
{ const unsigned char *f = (const unsigned char *)text[i]->text.t;
|
||||
|
||||
@ -137,7 +137,7 @@ format_float(double f, char *buf)
|
||||
{ *o++ = s[0];
|
||||
*o++ = '.';
|
||||
if ( end-s > 1 )
|
||||
{ memcpy(o, s+1, end-s-1);
|
||||
{ memmove(o, s+1, end-s-1);
|
||||
o += end-s-1;
|
||||
} else
|
||||
*o++ = '0';
|
||||
@ -149,14 +149,14 @@ format_float(double f, char *buf)
|
||||
*o++ = '.';
|
||||
for(i=0; i < -decpt; i++)
|
||||
*o++ = '0';
|
||||
memcpy(o, s, end-s);
|
||||
memmove(o, s, end-s);
|
||||
o[end-s] = 0;
|
||||
}
|
||||
} else if ( end-s > decpt ) /* decimal dot inside */
|
||||
{ memcpy(o, s, decpt);
|
||||
{ memmove(o, s, decpt);
|
||||
o += decpt;
|
||||
*o++ = '.';
|
||||
memcpy(o, s+decpt, end-s-decpt);
|
||||
memmove(o, s+decpt, end-s-decpt);
|
||||
o[end-s-decpt] = 0;
|
||||
} else /* decimal dot after */
|
||||
{ int i;
|
||||
@ -167,13 +167,13 @@ format_float(double f, char *buf)
|
||||
*o++ = '.';
|
||||
if ( end-s > 1 )
|
||||
{ trailing += (int)(end-s)-1;
|
||||
memcpy(o, s+1, end-s-1);
|
||||
memmove(o, s+1, end-s-1);
|
||||
o += end-s-1;
|
||||
} else
|
||||
*o++ = '0';
|
||||
sprintf(o, "e+%d", trailing);
|
||||
} else /* within precision trail with .0 */
|
||||
{ memcpy(o, s, end-s);
|
||||
{ memmove(o, s, end-s);
|
||||
o += end-s;
|
||||
|
||||
for(i=(int)(end-s); i<decpt; i++)
|
||||
|
||||
@ -57,6 +57,7 @@
|
||||
with the `use_module(library(lists))` command.
|
||||
*/
|
||||
|
||||
:- include(pl/bootlists).
|
||||
|
||||
/** @pred list_concat(+ _Lists_,? _List_)
|
||||
|
||||
|
||||
@ -159,7 +159,7 @@ new_int_matrix(int ndims, int dims[], long int data[])
|
||||
}
|
||||
bdata = matrix_long_data(mat,ndims);
|
||||
if (data)
|
||||
memcpy((void *)bdata,(void *)data,sizeof(double)*nelems);
|
||||
memmove((void *)bdata,(void *)data,sizeof(double)*nelems);
|
||||
return blob;
|
||||
}
|
||||
|
||||
@ -193,7 +193,7 @@ new_float_matrix(int ndims, int dims[], double data[])
|
||||
}
|
||||
bdata = matrix_double_data(mat,ndims);
|
||||
if (data)
|
||||
memcpy((void *)bdata,(void *)data,sizeof(double)*nelems);
|
||||
memmove((void *)bdata,(void *)data,sizeof(double)*nelems);
|
||||
return blob;
|
||||
}
|
||||
|
||||
|
||||
@ -88,7 +88,7 @@ expand_buffer( int space )
|
||||
Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "out of memory" );
|
||||
Yap_exit( EXIT_FAILURE );
|
||||
}
|
||||
memcpy( tmp, buf, bufsize );
|
||||
memmove( tmp, buf, bufsize );
|
||||
free( buf );
|
||||
buf = tmp;
|
||||
#else /* use realloc */
|
||||
|
||||
@ -1539,7 +1539,7 @@ sopno finish; /* to this less one */
|
||||
return (ret);
|
||||
enlarge(p, p->ssize + len); /* this many unexpected additions */
|
||||
assert(p->ssize >= p->slen + len);
|
||||
(void)memcpy((char *)(p->strip + p->slen), (char *)(p->strip + start),
|
||||
(void)memmove((char *)(p->strip + p->slen), (char *)(p->strip + start),
|
||||
(size_t)len * sizeof(sop));
|
||||
p->slen += len;
|
||||
return (ret);
|
||||
|
||||
@ -130,7 +130,7 @@ static int nope = 0; /* for use in asserts; shuts lint up */
|
||||
#define SET0(v, n) ((v)[n] = 0)
|
||||
#define SET1(v, n) ((v)[n] = 1)
|
||||
#define ISSET(v, n) ((v)[n])
|
||||
#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
|
||||
#define ASSIGN(d, s) memmove(d, s, m->g->nstates)
|
||||
#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
|
||||
#define STATEVARS \
|
||||
long vn; \
|
||||
|
||||
@ -153,8 +153,8 @@ RL_Tree *copy_rl(RL_Tree *tree) {
|
||||
free(new);
|
||||
return NULL;
|
||||
}
|
||||
memcpy(new, tree, sizeof(RL_Tree));
|
||||
memcpy(buf_ptr, &tree->root[0], tree->size * NODE_SIZE);
|
||||
memmove(new, tree, sizeof(RL_Tree));
|
||||
memmove(buf_ptr, &tree->root[0], tree->size * NODE_SIZE);
|
||||
new->root = buf_ptr;
|
||||
new->mem_alloc = tree->size *NODE_SIZE;
|
||||
return new;
|
||||
|
||||
@ -167,7 +167,7 @@ md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
|
||||
X = (const md5_word_t *)data;
|
||||
} else {
|
||||
/* not aligned */
|
||||
memcpy(xbuf, data, 64);
|
||||
memmove(xbuf, data, 64);
|
||||
X = xbuf;
|
||||
}
|
||||
}
|
||||
@ -353,7 +353,7 @@ md5_append(md5_state_t *pms, const md5_byte_t *data, unsigned int nbytes)
|
||||
if (offset) {
|
||||
unsigned int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
|
||||
|
||||
memcpy(pms->buf + offset, p, copy);
|
||||
memmove(pms->buf + offset, p, copy);
|
||||
if (offset + copy < 64)
|
||||
return;
|
||||
p += copy;
|
||||
@ -367,7 +367,7 @@ md5_append(md5_state_t *pms, const md5_byte_t *data, unsigned int nbytes)
|
||||
|
||||
/* Process a final partial block. */
|
||||
if (left)
|
||||
memcpy(pms->buf, p, left);
|
||||
memmove(pms->buf, p, left);
|
||||
}
|
||||
|
||||
void
|
||||
|
||||
@ -114,7 +114,7 @@ typedef struct itrie_data {
|
||||
YAP_Int i, new_num_buckets = DEPTH + BASE_TR_DATA_BUCKETS; \
|
||||
bucket = TrEntry_buckets(TR_ENTRY); \
|
||||
new_itrie_buckets(TR_ENTRY, new_num_buckets); \
|
||||
memcpy(TrEntry_buckets(TR_ENTRY), bucket, \
|
||||
memmove(TrEntry_buckets(TR_ENTRY), bucket, \
|
||||
TrEntry_num_buckets(TR_ENTRY) * SIZEOF_TR_DATA_BUCKET); \
|
||||
free_itrie_buckets(bucket, TrEntry_num_buckets(TR_ENTRY)); \
|
||||
bucket = TrEntry_buckets(TR_ENTRY); \
|
||||
|
||||
@ -1468,12 +1468,12 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
|
||||
hash = (TrHash) node;
|
||||
first_bucket = TrHash_buckets(hash);
|
||||
bucket = first_bucket + TrHash_num_buckets(hash);
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
do {
|
||||
if (*--bucket) {
|
||||
node = *bucket;
|
||||
traverse_and_print(node, arity, str, str_index, mode);
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) {
|
||||
/* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */
|
||||
if (str_index > 0 && str[str_index - 1] != '[')
|
||||
@ -1490,9 +1490,9 @@ void traverse_and_print(TrNode node, int *arity, char *str, int str_index, int m
|
||||
|
||||
if (TrNode_next(node)) {
|
||||
int *current_arity = (int *) malloc(sizeof(int) * (arity[0] + 1));
|
||||
memcpy(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
memmove(current_arity, arity, sizeof(int) * (arity[0] + 1));
|
||||
traverse_and_print(TrNode_next(node), arity, str, str_index, mode);
|
||||
memcpy(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
memmove(arity, current_arity, sizeof(int) * (current_arity[0] + 1));
|
||||
if (mode != TRIE_PRINT_FLOAT2 && arity[arity[0]] < 0) {
|
||||
/* restore possible PairEndEmptyTag/PairEndTermTag/CommaEndTag side-effect */
|
||||
if (str_index > 0 && str[str_index - 1] != '[')
|
||||
|
||||
@ -221,7 +221,7 @@ typedef struct trie_hash {
|
||||
{ YAP_Term *aux_stack; \
|
||||
YAP_Int aux_size = CURRENT_AUXILIARY_TERM_STACK_SIZE * sizeof(YAP_Term); \
|
||||
new_struct(aux_stack, YAP_Term, aux_size * 2); \
|
||||
memcpy(aux_stack, AUXILIARY_TERM_STACK, aux_size); \
|
||||
memmove(aux_stack, AUXILIARY_TERM_STACK, aux_size); \
|
||||
free_struct(AUXILIARY_TERM_STACK); \
|
||||
AUXILIARY_TERM_STACK = aux_stack; \
|
||||
CURRENT_AUXILIARY_TERM_STACK_SIZE *= 2; \
|
||||
|
||||
31
os/alias.c
31
os/alias.c
@ -209,7 +209,7 @@ ExtendAliasArray(void)
|
||||
UInt new_size = GLOBAL_SzOfFileAliases+ALIASES_BLOCK_SIZE;
|
||||
|
||||
new = (AliasDesc)Yap_AllocCodeSpace(sizeof(AliasDesc *)*new_size);
|
||||
memcpy((void *)new, (void *)GLOBAL_FileAliases, sizeof(AliasDesc *)*GLOBAL_SzOfFileAliases);
|
||||
memmove((void *)new, (void *)GLOBAL_FileAliases, sizeof(AliasDesc *)*GLOBAL_SzOfFileAliases);
|
||||
Yap_FreeCodeSpace((ADDR) GLOBAL_FileAliases);
|
||||
GLOBAL_FileAliases = new;
|
||||
GLOBAL_SzOfFileAliases = new_size;
|
||||
@ -221,16 +221,16 @@ Yap_SetAlias (Atom arg, int sno)
|
||||
CACHE_REGS
|
||||
AliasDesc aliasp = GLOBAL_FileAliases, aliasp_max = GLOBAL_FileAliases+GLOBAL_NOfFileAliases;
|
||||
|
||||
while (aliasp < aliasp_max) {
|
||||
// replace alias
|
||||
if (aliasp->name == arg) {
|
||||
aliasp->alias_stream = sno;
|
||||
if (arg == AtomUserIn)
|
||||
LOCAL_c_input_stream = sno;
|
||||
if (arg == AtomUserOut)
|
||||
LOCAL_c_output_stream = sno;
|
||||
if (arg == AtomUserErr)
|
||||
LOCAL_c_error_stream = sno;
|
||||
while (aliasp < aliasp_max) {
|
||||
// replace alias
|
||||
if (aliasp->name == arg) {
|
||||
aliasp->alias_stream = sno;
|
||||
return;
|
||||
}
|
||||
aliasp++;
|
||||
@ -317,16 +317,16 @@ ExistsAliasForStream (int sno, Atom al)
|
||||
while (aliasp < aliasp_max) {
|
||||
if (aliasp->alias_stream == sno && aliasp->name == al) {
|
||||
if (al == AtomUserIn) {
|
||||
LOCAL_c_input_stream = StdInStream;
|
||||
aliasp->alias_stream = StdInStream;
|
||||
}
|
||||
LOCAL_c_input_stream = sno;
|
||||
aliasp->alias_stream = sno;
|
||||
} else
|
||||
if (al == AtomUserOut) {
|
||||
LOCAL_c_output_stream = StdOutStream;
|
||||
aliasp->alias_stream = StdOutStream;
|
||||
LOCAL_c_output_stream = sno;
|
||||
aliasp->alias_stream = sno;
|
||||
}
|
||||
if (al == AtomUserErr) {
|
||||
LOCAL_c_error_stream = StdErrStream;
|
||||
aliasp->alias_stream = StdErrStream;
|
||||
LOCAL_c_error_stream = sno;
|
||||
aliasp->alias_stream = sno;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@ -387,6 +387,12 @@ Yap_AddAlias (Atom arg, int sno)
|
||||
|
||||
AliasDesc aliasp = GLOBAL_FileAliases, aliasp_max = GLOBAL_FileAliases+GLOBAL_NOfFileAliases;
|
||||
|
||||
if (arg == AtomUserIn)
|
||||
LOCAL_c_input_stream = sno;
|
||||
else if (arg == AtomUserOut)
|
||||
LOCAL_c_output_stream = sno;
|
||||
else if (arg == AtomUserErr)
|
||||
LOCAL_c_error_stream = sno;
|
||||
while (aliasp < aliasp_max) {
|
||||
if (aliasp->name == arg) {
|
||||
aliasp->alias_stream = sno;
|
||||
@ -394,6 +400,7 @@ Yap_AddAlias (Atom arg, int sno)
|
||||
}
|
||||
aliasp++;
|
||||
}
|
||||
|
||||
/* we have not found an alias neither a hole */
|
||||
if (aliasp == GLOBAL_FileAliases+GLOBAL_SzOfFileAliases)
|
||||
ExtendAliasArray();
|
||||
|
||||
10
os/assets.c
10
os/assets.c
@ -98,7 +98,7 @@ open_asset(VFS_t *me, const char *fname, const char *io_mode, int sno) {
|
||||
if ((buf = AAsset_getBuffer(am))) {
|
||||
// copy to memory
|
||||
char *bf = malloc(sz);
|
||||
memcpy(bf, buf, sz);
|
||||
memmove(bf, buf, sz);
|
||||
bool rc = Yap_set_stream_to_buf(st, bf, sz);
|
||||
if (rc) AAsset_close(am);
|
||||
st->vfs = NULL;
|
||||
@ -162,10 +162,10 @@ static bool stat_a(VFS_t *me, const char *fname, vfs_stat *out) {
|
||||
out->st_dev = bf.st_dev;
|
||||
out->st_uid = bf.st_uid;
|
||||
out->st_gid = bf.st_gid;
|
||||
memcpy(&out->st_atimespec, (const void *) &bf.st_atim, sizeof(struct timespec));
|
||||
memcpy(&out->st_mtimespec, (const void *) &bf.st_mtim, sizeof(struct timespec));
|
||||
memcpy(&out->st_ctimespec, (const void *) &bf.st_ctim, sizeof(struct timespec));
|
||||
memcpy(&out->st_birthtimespec, (const void *) &bf.st_ctim,
|
||||
memmove(&out->st_atimespec, (const void *) &bf.st_atim, sizeof(struct timespec));
|
||||
memmove(&out->st_mtimespec, (const void *) &bf.st_mtim, sizeof(struct timespec));
|
||||
memmove(&out->st_ctimespec, (const void *) &bf.st_ctim, sizeof(struct timespec));
|
||||
memmove(&out->st_birthtimespec, (const void *) &bf.st_ctim,
|
||||
sizeof(struct timespec));
|
||||
}
|
||||
AAsset *a = AAssetManager_open(Yap_assetManager(), fname, AASSET_MODE_UNKNOWN);
|
||||
|
||||
@ -990,16 +990,11 @@ leaving the current stream position unaltered.
|
||||
*/
|
||||
static Int peek_code(USES_REGS1) { /* at_end_of_stream */
|
||||
/* the next character is a EOF */
|
||||
int sno = Yap_CheckTextStream(ARG1, Input_Stream_f, "peek/2");
|
||||
int sno = Yap_CheckTextStream(ARG1, Input_Stream_f, "peek_code/2");
|
||||
Int ch;
|
||||
|
||||
if (sno < 0)
|
||||
return FALSE;
|
||||
if (GLOBAL_Stream[sno].status & Binary_Stream_f) {
|
||||
UNLOCK(GLOBAL_Stream[sno].streamlock);
|
||||
Yap_Error(PERMISSION_ERROR_INPUT_TEXT_STREAM, ARG1, "peek_code/2");
|
||||
return FALSE;
|
||||
}
|
||||
if ((ch = Yap_peek(sno)) < 0) {
|
||||
#ifdef PEEK_EOF
|
||||
UNLOCK(GLOBAL_Stream[sno].streamlock);
|
||||
|
||||
@ -82,8 +82,8 @@ Term Yap_StringToNumberTerm(const char *s, encoding_t *encp, bool error_on) {
|
||||
CACHE_REGS
|
||||
int sno;
|
||||
int i = push_text_stack();
|
||||
|
||||
sno = Yap_open_buf_read_stream(s, strlen(s), encp, MEM_BUF_USER);
|
||||
Atom nat = Yap_LookupAtom(Yap_StrPrefix(s, 16));
|
||||
sno = Yap_open_buf_read_stream(s, strlen(s), encp, MEM_BUF_USER, nat, MkAtomTerm(Yap_LookupAtom("eval")));
|
||||
if (sno < 0)
|
||||
return FALSE;
|
||||
if (encp)
|
||||
|
||||
@ -98,7 +98,7 @@ static Int file_name_extension(USES_REGS1) {
|
||||
ext = "";
|
||||
}
|
||||
base = Malloc(lenb_b + 1);
|
||||
memcpy(base, f, lenb_b);
|
||||
memmove(base, f, lenb_b);
|
||||
base[lenb_b] = '\0';
|
||||
if (IsVarTerm(t1 = Deref(ARG1))) {
|
||||
// should always succeed
|
||||
|
||||
70
os/fmem.c
70
os/fmem.c
@ -131,8 +131,18 @@ bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf,
|
||||
return true;
|
||||
}
|
||||
|
||||
int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp,
|
||||
memBufSource src) {
|
||||
|
||||
char *Yap_StrPrefix( const char *buf, size_t n) {
|
||||
char *b = (char*)malloc(n);
|
||||
strncpy(b, buf, n - 1);
|
||||
if (strlen(buf) > n - 1)
|
||||
b[15] = '\0';
|
||||
return b;
|
||||
}
|
||||
|
||||
int Yap_open_buf_read_stream(const char *buf, size_t nchars,
|
||||
encoding_t *encp, memBufSource src, Atom fname,
|
||||
Term uname) {
|
||||
CACHE_REGS
|
||||
int sno;
|
||||
StreamDesc *st;
|
||||
@ -153,7 +163,7 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp,
|
||||
f = st->file = fmemopen((void *)buf, nchars, "r");
|
||||
st->vfs = NULL;
|
||||
flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f;
|
||||
Yap_initStream(sno, f, "memStream", "r", TermNone, encoding, flags, NULL);
|
||||
Yap_initStream(sno, f, RepAtom(fname)->StrOfAE, "r", uname, encoding, flags, NULL);
|
||||
// like any file stream.
|
||||
Yap_DefaultStreamOps(st);
|
||||
UNLOCK(st->streamlock);
|
||||
@ -176,7 +186,7 @@ open_mem_read_stream(USES_REGS1) /* $open_mem_read_stream(+List,-Stream) */
|
||||
}
|
||||
buf = pop_output_text_stack(l, buf);
|
||||
sno = Yap_open_buf_read_stream(buf, strlen(buf) + 1, &LOCAL_encoding,
|
||||
MEM_BUF_MALLOC);
|
||||
MEM_BUF_MALLOC, Yap_LookupAtom(Yap_StrPrefix((char *)buf,16)), TermNone);
|
||||
t = Yap_MkStream(sno);
|
||||
return Yap_unify(ARG2, t);
|
||||
}
|
||||
@ -193,7 +203,9 @@ int Yap_open_buf_write_stream(encoding_t enc, memBufSource src) {
|
||||
return -1;
|
||||
|
||||
st = GLOBAL_Stream + sno;
|
||||
st->status = Output_Stream_f | InMemory_Stream_f | FreeOnClose_Stream_f;
|
||||
st->status = Output_Stream_f | InMemory_Stream_f;
|
||||
if (st->nbuf)
|
||||
st->status |= FreeOnClose_Stream_f;
|
||||
st->linepos = 0;
|
||||
st->charcount = 0;
|
||||
st->linecount = 1;
|
||||
@ -202,15 +214,15 @@ int Yap_open_buf_write_stream(encoding_t enc, memBufSource src) {
|
||||
st->buf.on = true;
|
||||
st->nbuf = NULL;
|
||||
st->nsize = 0;
|
||||
st->status |= Seekable_Stream_f;
|
||||
#if HAVE_OPEN_MEMSTREAM
|
||||
st->file = open_memstream(&st->nbuf, &st->nsize);
|
||||
// setbuf(st->file, NULL);
|
||||
st->status |= Seekable_Stream_f;
|
||||
#else
|
||||
st->file = fmemopen((void *)st->nbuf, st->nsize, "w");
|
||||
if (!st->nbuf) {
|
||||
return -1;
|
||||
}
|
||||
#else
|
||||
st->file = fmemopen((void *)st->nbuf, st->nsize, "w+");
|
||||
#endif
|
||||
Yap_DefaultStreamOps(st);
|
||||
UNLOCK(st->streamlock);
|
||||
@ -247,35 +259,41 @@ open_mem_write_stream(USES_REGS1) /* $open_mem_write_stream(-Stream) */
|
||||
* by other writes..
|
||||
*/
|
||||
char *Yap_MemExportStreamPtr(int sno) {
|
||||
char *s;
|
||||
if (fflush(GLOBAL_Stream[sno].file) == 0) {
|
||||
s = GLOBAL_Stream[sno].nbuf;
|
||||
// s[fseek(GLOBAL_Stream[sno].file, 0, SEEK_END)] = '\0';
|
||||
return s;
|
||||
}
|
||||
|
||||
if (fflush(GLOBAL_Stream[sno].file) < 0) {
|
||||
return NULL;
|
||||
}
|
||||
size_t len = fseek(GLOBAL_Stream[sno].file, 0, SEEK_END);
|
||||
char *buf = malloc(len+1);
|
||||
#if HAVE_OPEN_MEMSTREAM
|
||||
char *s = GLOBAL_Stream[sno].nbuf;
|
||||
memcpy(buf, s, len);
|
||||
// s[fseek(GLOBAL_Stream[sno].file, 0, SEEK_END)] = '\0';
|
||||
#else
|
||||
fread(buf, sz, 1, GLOBAL_Stream[sno].file);
|
||||
#endif
|
||||
buf[len] = '\0';
|
||||
return buf;
|
||||
}
|
||||
|
||||
static Int peek_mem_write_stream(
|
||||
USES_REGS1) { /* '$peek_mem_write_stream'(+GLOBAL_Stream,?S0,?S) */
|
||||
Int sno =
|
||||
Yap_CheckStream(ARG1, (Output_Stream_f | InMemory_Stream_f), "close/2");
|
||||
Int i;
|
||||
Term tf = ARG2;
|
||||
CELL *HI;
|
||||
const char *ptr;
|
||||
char *ptr;
|
||||
int ch;
|
||||
|
||||
if (sno < 0)
|
||||
return (FALSE);
|
||||
char *p = ptr = Yap_MemExportStreamPtr(sno);
|
||||
restart:
|
||||
HI = HR;
|
||||
if (fflush(GLOBAL_Stream[sno].file) == 0) {
|
||||
i = fseek(GLOBAL_Stream[sno].file, 0, SEEK_END);
|
||||
ptr = GLOBAL_Stream[sno].nbuf;
|
||||
}
|
||||
while (i > 0) {
|
||||
--i;
|
||||
tf = MkPairTerm(MkIntTerm(ptr[i]), tf);
|
||||
while ((ch = *p++)) {
|
||||
HR[0] = MkIntTerm(ch);
|
||||
HR[1] = AbsPair(HR+2);
|
||||
HR += 2;
|
||||
if (HR + 1024 >= ASP) {
|
||||
UNLOCK(GLOBAL_Stream[sno].streamlock);
|
||||
HR = HI;
|
||||
@ -284,14 +302,14 @@ restart:
|
||||
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
|
||||
return (FALSE);
|
||||
}
|
||||
i = GLOBAL_Stream[sno].u.mem_string.pos;
|
||||
tf = ARG2;
|
||||
LOCK(GLOBAL_Stream[sno].streamlock);
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
HR[-1] = tf;
|
||||
UNLOCK(GLOBAL_Stream[sno].streamlock);
|
||||
return (Yap_unify(ARG3, tf));
|
||||
free(ptr);
|
||||
return (Yap_unify(ARG3, AbsPair(HI)));
|
||||
}
|
||||
|
||||
void Yap_MemOps(StreamDesc *st) {
|
||||
|
||||
@ -96,7 +96,7 @@ fmemread(void *cookie, char *buf, int n)
|
||||
return 0;
|
||||
if (n >= c->eof - c->pos)
|
||||
n = c->eof - c->pos;
|
||||
memcpy (buf, c->buf + c->pos, n);
|
||||
memmove (buf, c->buf + c->pos, n);
|
||||
c->pos += n;
|
||||
return n;
|
||||
}
|
||||
@ -144,7 +144,7 @@ fmemwrite(void *cookie, const char *buf, int n)
|
||||
}
|
||||
c->pos += n;
|
||||
if (n - adjust)
|
||||
memcpy (c->buf + c->pos - n, buf, n - adjust);
|
||||
memmove (c->buf + c->pos - n, buf, n - adjust);
|
||||
else
|
||||
{
|
||||
return EOF;
|
||||
|
||||
@ -45,7 +45,7 @@ static int readfn(void *handler, char *buf, int size) {
|
||||
if (size > available) {
|
||||
size = available;
|
||||
}
|
||||
memcpy(buf, mem->buffer + mem->pos, sizeof(char) * size);
|
||||
memmove(buf, mem->buffer + mem->pos, sizeof(char) * size);
|
||||
mem->pos += size;
|
||||
|
||||
return size;
|
||||
@ -58,7 +58,7 @@ static int writefn(void *handler, const char *buf, int size) {
|
||||
if (size > available) {
|
||||
size = available;
|
||||
}
|
||||
memcpy(mem->buffer + mem->pos, buf, sizeof(char) * size);
|
||||
memmove(mem->buffer + mem->pos, buf, sizeof(char) * size);
|
||||
mem->pos += size;
|
||||
|
||||
return size;
|
||||
|
||||
24
os/iopreds.c
24
os/iopreds.c
@ -1129,9 +1129,13 @@ static void check_bom(int sno, StreamDesc *st) {
|
||||
bool Yap_initStream(int sno, FILE *fd, const char *name, const char *io_mode,
|
||||
Term file_name, encoding_t encoding, stream_flags_t flags,
|
||||
void *vfs) {
|
||||
// fprintf(stderr,"+ %s --> %d\n", name, sno);
|
||||
StreamDesc *st = &GLOBAL_Stream[sno];
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "init %s %s stream <%d>",io_mode,name,
|
||||
sno);
|
||||
__android_log_print(
|
||||
ANDROID_LOG_INFO, "YAPDroid", "init %s %s:%s stream <%d>", io_mode,
|
||||
CurrentModule == 0 ? "prolog"
|
||||
: RepAtom(AtomOfTerm(CurrentModule))->StrOfAE,
|
||||
name, sno);
|
||||
if (io_mode == NULL)
|
||||
Yap_Error(PERMISSION_ERROR_NEW_ALIAS_FOR_STREAM, MkIntegerTerm(sno),
|
||||
"File opened with NULL Permissions");
|
||||
@ -1229,14 +1233,11 @@ typedef enum open_enum_choices { OPEN_DEFS() } open_choices_t;
|
||||
static const param_t open_defs[] = {OPEN_DEFS()};
|
||||
#undef PAR
|
||||
|
||||
|
||||
static bool fill_stream(int sno, StreamDesc *st, Term tin, const char *io_mode, Term user_name,
|
||||
encoding_t enc)
|
||||
{
|
||||
static bool fill_stream(int sno, StreamDesc *st, Term tin, const char *io_mode,
|
||||
Term user_name, encoding_t enc) {
|
||||
struct vfs *vfsp = NULL;
|
||||
const char *fname;
|
||||
|
||||
|
||||
if (IsAtomTerm(tin))
|
||||
fname = RepAtom(AtomOfTerm(tin))->StrOfAE;
|
||||
else if (IsStringTerm(tin))
|
||||
@ -1287,8 +1288,10 @@ static bool fill_stream(int sno, StreamDesc *st, Term tin, const char *io_mode,
|
||||
return false;
|
||||
}
|
||||
buf = pop_output_text_stack(i, buf);
|
||||
Atom nat = Yap_LookupAtom(Yap_StrPrefix(buf, 32));
|
||||
sno = Yap_open_buf_read_stream(buf, strlen(buf) + 1, &LOCAL_encoding,
|
||||
MEM_BUF_MALLOC);
|
||||
MEM_BUF_MALLOC, nat,
|
||||
MkAtomTerm(NameOfFunctor(f)));
|
||||
return Yap_OpenBufWriteStream(PASS_REGS1);
|
||||
}
|
||||
} else if (!strcmp(RepAtom(NameOfFunctor(f))->StrOfAE, "popen")) {
|
||||
@ -1361,8 +1364,8 @@ static Int do_open(Term file_name, Term t2, Term tlist USES_REGS) {
|
||||
open_mode = AtomOfTerm(t2);
|
||||
}
|
||||
/* get options */
|
||||
xarg *args = Yap_ArgListToVector(tlist, open_defs, OPEN_END,
|
||||
DOMAIN_ERROR_OPEN_OPTION);
|
||||
xarg *args =
|
||||
Yap_ArgListToVector(tlist, open_defs, OPEN_END, DOMAIN_ERROR_OPEN_OPTION);
|
||||
if (args == NULL) {
|
||||
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
|
||||
Yap_Error(LOCAL_Error_TYPE, tlist, "option handling in open/3");
|
||||
@ -1667,7 +1670,6 @@ int Yap_OpenStream(Term tin, const char *io_mode, Term user_name,
|
||||
st = GLOBAL_Stream + sno;
|
||||
// fname = Yap_VF(fname);
|
||||
|
||||
|
||||
if (fill_stream(sno, st, tin, io_mode, user_name, enc))
|
||||
return sno;
|
||||
return -1;
|
||||
|
||||
@ -124,7 +124,6 @@ extern bool Yap_PrintWarning(Term twarning);
|
||||
extern void Yap_plwrite(Term, struct stream_desc *, int, int, int);
|
||||
extern void Yap_WriteAtom(struct stream_desc *s, Atom atom);
|
||||
extern bool Yap_WriteTerm(int output_stream, Term t, Term opts USES_REGS);
|
||||
|
||||
extern Term Yap_scan_num(struct stream_desc *, bool);
|
||||
|
||||
extern void Yap_DefaultStreamOps(StreamDesc *st);
|
||||
|
||||
@ -85,7 +85,7 @@ mem_write (void *c, const char *buf, int n)
|
||||
intermediate bytges are NUL. */
|
||||
if (cookie->eof < cookie->pos)
|
||||
memset (cbuf + cookie->eof, '\0', cookie->pos - cookie->eof);
|
||||
memcpy (cbuf + cookie->pos, buf, n);
|
||||
memmove (cbuf + cookie->pos, buf, n);
|
||||
cookie->pos += n;
|
||||
/* If the user has previously written beyond the current position,
|
||||
remember what the trailing NUL is overwriting. Otherwise,
|
||||
|
||||
@ -837,6 +837,8 @@ static parser_state_t initParser(Term opts, FEnv *fe, REnv *re, int inp_stream,
|
||||
LOCAL_ErrorMessage = NULL;
|
||||
fe->old_TR = TR;
|
||||
LOCAL_Error_TYPE = YAP_NO_ERROR;
|
||||
__android_log_print(ANDROID_LOG_INFO, "YAPDroid ", " open %s, %d",
|
||||
CurrentModule == 0? "prolog": RepAtom(AtomOfTerm(CurrentModule))->StrOfAE, inp_stream);
|
||||
LOCAL_SourceFileName = GLOBAL_Stream[inp_stream].name;
|
||||
LOCAL_eot_before_eof = false;
|
||||
fe->tpos = StreamPosition(inp_stream);
|
||||
@ -1008,7 +1010,6 @@ Term Yap_read_term(int sno, Term opts, bool clause) {
|
||||
#endif
|
||||
|
||||
yap_error_descriptor_t *new = malloc(sizeof *new);
|
||||
|
||||
bool err = Yap_pushErrorContext(true, new);
|
||||
int lvl = push_text_stack();
|
||||
parser_state_t state = YAP_START_PARSING;
|
||||
@ -1051,9 +1052,6 @@ Term Yap_read_term(int sno, Term opts, bool clause) {
|
||||
#endif /* EMACS */
|
||||
pop_text_stack(lvl);
|
||||
Yap_popErrorContext(err, true);
|
||||
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
|
||||
Yap_Error(LOCAL_Error_TYPE, Yap_MkStream(sno), LOCAL_ErrorMessage);
|
||||
}
|
||||
return fe.t;
|
||||
}
|
||||
}
|
||||
@ -1398,8 +1396,8 @@ Term Yap_BufferToTerm(const char *s, Term opts) {
|
||||
Term rval;
|
||||
int sno;
|
||||
encoding_t l = ENC_ISO_UTF8;
|
||||
sno = Yap_open_buf_read_stream((char *)s, strlen((const char *)s)+1, &l,
|
||||
MEM_BUF_USER);
|
||||
sno = Yap_open_buf_read_stream((char *)s, strlen(s)+1, &l,
|
||||
MEM_BUF_USER, Yap_LookupAtom(Yap_StrPrefix(s,16)), TermNone );
|
||||
|
||||
GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
|
||||
rval = Yap_read_term(sno, opts, false);
|
||||
@ -1412,7 +1410,7 @@ Term Yap_UBufferToTerm(const unsigned char *s, Term opts) {
|
||||
int sno;
|
||||
encoding_t l = ENC_ISO_UTF8;
|
||||
sno = Yap_open_buf_read_stream((char *)s, strlen((const char *)s), &l,
|
||||
MEM_BUF_USER);
|
||||
MEM_BUF_USER, Yap_LookupAtom(Yap_StrPrefix((char *)s,16)), TermNone);
|
||||
GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
|
||||
rval = Yap_read_term(sno, opts, false);
|
||||
Yap_CloseStream(sno);
|
||||
@ -1521,6 +1519,7 @@ static Int read_term_from_string(USES_REGS1) {
|
||||
Term t1 = Deref(ARG1), rc;
|
||||
const unsigned char *s;
|
||||
size_t len;
|
||||
BACKUP_H()
|
||||
if (IsVarTerm(t1)) {
|
||||
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
|
||||
return (FALSE);
|
||||
@ -1533,10 +1532,11 @@ static Int read_term_from_string(USES_REGS1) {
|
||||
}
|
||||
char *ss = (char *)s;
|
||||
encoding_t enc = ENC_ISO_UTF8;
|
||||
int sno = Yap_open_buf_read_stream(ss, len, &enc, MEM_BUF_USER);
|
||||
int sno = Yap_open_buf_read_stream(ss, len, &enc, MEM_BUF_USER, Yap_LookupAtom(Yap_StrPrefix(ss,16)), TermString);
|
||||
GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
|
||||
rc = Yap_read_term(sno, Deref(ARG3), 3);
|
||||
Yap_CloseStream(sno);
|
||||
RECOVER_H();
|
||||
if (!rc)
|
||||
return false;
|
||||
return Yap_unify(rc, ARG2);
|
||||
|
||||
14
os/streams.c
14
os/streams.c
@ -683,7 +683,7 @@ static xarg *generate_property(int sno, Term t2,
|
||||
}
|
||||
|
||||
static Int cont_stream_property(USES_REGS1) { /* current_stream */
|
||||
bool det;
|
||||
bool det = false;
|
||||
xarg *args;
|
||||
int i = IntOfTerm(EXTRA_CBACK_ARG(2, 1));
|
||||
stream_property_choices_t p = STREAM_PROPERTY_END;
|
||||
@ -705,7 +705,7 @@ static Int cont_stream_property(USES_REGS1) { /* current_stream */
|
||||
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
|
||||
if (LOCAL_Error_TYPE == DOMAIN_ERROR_GENERIC_ARGUMENT)
|
||||
LOCAL_Error_TYPE = DOMAIN_ERROR_STREAM_PROPERTY_OPTION;
|
||||
Yap_Error(LOCAL_Error_TYPE, t2, NULL);
|
||||
Yap_ThrowError(LOCAL_Error_TYPE, t2, NULL);
|
||||
return false;
|
||||
}
|
||||
cut_fail();
|
||||
@ -714,16 +714,17 @@ static Int cont_stream_property(USES_REGS1) { /* current_stream */
|
||||
if (IsAtomTerm(args[STREAM_PROPERTY_ALIAS].tvalue)) {
|
||||
// one solution only
|
||||
i = Yap_CheckAlias(AtomOfTerm(args[STREAM_PROPERTY_ALIAS].tvalue));
|
||||
free(args) UNLOCK(GLOBAL_Stream[i].streamlock);
|
||||
UNLOCK(GLOBAL_Stream[i].streamlock);
|
||||
if (i < 0 || !Yap_unify(ARG1, Yap_MkStream(i))) {
|
||||
free(args);
|
||||
cut_fail();
|
||||
}
|
||||
cut_succeed();
|
||||
det = true;
|
||||
}
|
||||
LOCK(GLOBAL_Stream[i].streamlock);
|
||||
rc = do_stream_property(i, args PASS_REGS);
|
||||
UNLOCK(GLOBAL_Stream[i].streamlock);
|
||||
if (IsVarTerm(t1)) {
|
||||
if (!det && IsVarTerm(t1)) {
|
||||
if (rc)
|
||||
rc = Yap_unify(ARG1, Yap_MkStream(i));
|
||||
if (p == STREAM_PROPERTY_END) {
|
||||
@ -743,7 +744,7 @@ static Int cont_stream_property(USES_REGS1) { /* current_stream */
|
||||
}
|
||||
} else {
|
||||
// done
|
||||
det = (p == STREAM_PROPERTY_END);
|
||||
det = det || (p == STREAM_PROPERTY_END);
|
||||
}
|
||||
free(args);
|
||||
if (rc) {
|
||||
@ -998,6 +999,7 @@ static void CloseStream(int sno) {
|
||||
// __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "close stream <%d>",
|
||||
// sno);
|
||||
VFS_t *me;
|
||||
//fprintf( stderr, "- %d\n",sno);
|
||||
if ((me = GLOBAL_Stream[sno].vfs) != NULL &&
|
||||
GLOBAL_Stream[sno].file == NULL) {
|
||||
if (me->close) {
|
||||
|
||||
@ -93,7 +93,7 @@ static Term readFromBuffer(const char *s, Term opts) {
|
||||
int sno;
|
||||
encoding_t enc = ENC_ISO_UTF8;
|
||||
sno = Yap_open_buf_read_stream((char *)s, strlen_utf8((unsigned char *)s),
|
||||
&enc, MEM_BUF_USER);
|
||||
&enc, MEM_BUF_USER, Yap_LookupAtom(Yap_StrPrefix((char *)s,16)), TermNone);
|
||||
|
||||
rval = Yap_read_term(sno, opts, 3);
|
||||
Yap_CloseStream(sno);
|
||||
@ -672,7 +672,7 @@ static Int term_to_string(USES_REGS1) {
|
||||
Term t2 = Deref(ARG2), rc = false, t1 = Deref(ARG1);
|
||||
const char *s;
|
||||
if (IsVarTerm(t2)) {
|
||||
s = Yap_TermToBuffer(ARG1, LOCAL_encoding, Quote_illegal_f | Handle_vars_f);
|
||||
s = Yap_TermToBuffer(t1, Quote_illegal_f | Handle_vars_f);
|
||||
if (!s || !MkStringTerm(s)) {
|
||||
Yap_Error(RESOURCE_ERROR_HEAP, t1,
|
||||
"Could not get memory from the operating system");
|
||||
@ -692,7 +692,7 @@ static Int term_to_atom(USES_REGS1) {
|
||||
Term t2 = Deref(ARG2), ctl, rc = false;
|
||||
Atom at;
|
||||
if (IsVarTerm(t2)) {
|
||||
const char *s = Yap_TermToBuffer(Deref(ARG1), LOCAL_encoding,
|
||||
const char *s = Yap_TermToBuffer(Deref(ARG1),
|
||||
Quote_illegal_f | Handle_vars_f);
|
||||
if (!s || !(at = Yap_UTF8ToAtom((const unsigned char *)s))) {
|
||||
Yap_Error(RESOURCE_ERROR_HEAP, t2,
|
||||
@ -711,6 +711,25 @@ static Int term_to_atom(USES_REGS1) {
|
||||
Yap_unify(rc, ARG1);
|
||||
}
|
||||
|
||||
char *Yap_TermToBuffer(Term t, int flags) {
|
||||
CACHE_REGS
|
||||
int sno = Yap_open_buf_write_stream(LOCAL_encoding,flags);
|
||||
|
||||
if (sno < 0)
|
||||
return NULL;
|
||||
if (t == 0)
|
||||
return NULL;
|
||||
else
|
||||
t = Deref(t);
|
||||
GLOBAL_Stream[sno].encoding = LOCAL_encoding;
|
||||
GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
|
||||
Yap_plwrite(t, GLOBAL_Stream + sno, 0, flags, GLOBAL_MaxPriority);
|
||||
|
||||
char *new = Yap_MemExportStreamPtr(sno);
|
||||
Yap_CloseStream(sno);
|
||||
return new;
|
||||
}
|
||||
|
||||
void Yap_InitWriteTPreds(void) {
|
||||
Yap_InitCPred("write_term", 2, write_term2, SyncPredFlag);
|
||||
Yap_InitCPred("write_term", 3, write_term3, SyncPredFlag);
|
||||
|
||||
@ -89,7 +89,7 @@ extern int Yap_GetCharForSIGINT(void);
|
||||
extern Int Yap_StreamToFileNo(Term);
|
||||
extern int Yap_OpenStream(Term tin, const char* io_mode, Term user_name, encoding_t enc);
|
||||
extern int Yap_FileStream(FILE*, char *, Term, int, VFS_t *);
|
||||
extern char *Yap_TermToBuffer(Term t, encoding_t encoding, int flags);
|
||||
extern char *Yap_TermToBuffer(Term t, int flags);
|
||||
extern char *Yap_HandleToString(yhandle_t l, size_t sz, size_t *length,
|
||||
encoding_t *encoding, int flags);
|
||||
extern int Yap_GetFreeStreamD(void);
|
||||
@ -114,11 +114,14 @@ typedef enum mem_buf_source {
|
||||
|
||||
extern char *Yap_MemStreamBuf(int sno);
|
||||
|
||||
extern char *Yap_StrPrefix( const char *buf, size_t n) ;
|
||||
|
||||
extern Term Yap_StringToNumberTerm(const char *s, encoding_t *encp,
|
||||
bool error_on);
|
||||
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);
|
||||
encoding_t *encp, memBufSource src, Atom name,
|
||||
Term uname);
|
||||
extern int Yap_open_buf_write_stream(encoding_t enc, memBufSource src);
|
||||
extern Term Yap_BufferToTerm(const char *s, Term opts);
|
||||
extern X_API Term Yap_BufferToTermWithPrioBindings(const char *s, Term opts, Term bindings, size_t sz,
|
||||
|
||||
@ -202,7 +202,7 @@ void Yap_init_socks(char *host, long interface_port) {
|
||||
soadr.sin_port = htons((short)interface_port);
|
||||
|
||||
if (he != NULL) {
|
||||
memcpy((char *)&adr, (char *)he->h_addr_list[0], (size_t)he->h_length);
|
||||
memmove((char *)&adr, (char *)he->h_addr_list[0], (size_t)he->h_length);
|
||||
} else {
|
||||
adr.s_addr = inet_addr(host);
|
||||
}
|
||||
@ -635,7 +635,7 @@ static Int p_socket_bind(USES_REGS1) {
|
||||
#endif
|
||||
return (FALSE);
|
||||
}
|
||||
memcpy((void *)&saddr.sin_addr, (void *)he->h_addr_list[0], he->h_length);
|
||||
memmove((void *)&saddr.sin_addr, (void *)he->h_addr_list[0], he->h_length);
|
||||
}
|
||||
if (IsVarTerm(tport)) {
|
||||
port = 0;
|
||||
@ -774,7 +774,7 @@ static Int p_socket_connect(USES_REGS1) {
|
||||
#endif
|
||||
return (FALSE);
|
||||
}
|
||||
memcpy((void *)&saddr.sin_addr, (void *)he->h_addr_list[0], he->h_length);
|
||||
memmove((void *)&saddr.sin_addr, (void *)he->h_addr_list[0], he->h_length);
|
||||
}
|
||||
if (IsVarTerm(tport)) {
|
||||
Yap_Error(INSTANTIATION_ERROR, tport, "socket_connect/3");
|
||||
@ -1239,7 +1239,7 @@ static Int p_hostname_address(USES_REGS1) {
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
memcpy((char *)&adr, (char *)he->h_addr_list[0], (size_t)he->h_length);
|
||||
memmove((char *)&adr, (char *)he->h_addr_list[0], (size_t)he->h_length);
|
||||
out = MkAtomTerm(Yap_LookupAtom(inet_ntoa(adr)));
|
||||
return (Yap_unify(out, ARG2));
|
||||
}
|
||||
|
||||
@ -80,7 +80,7 @@ int bpredscpu(int *dop1, int rows, int *bin, int3 numpreds, int **ret)
|
||||
ptr = fres;
|
||||
for(x = 0; x < NUM_T; x++)
|
||||
{
|
||||
memcpy(ptr, vec[x].data(), ini[x] * sizeof(int));
|
||||
memmove(ptr, vec[x].data(), ini[x] * sizeof(int));
|
||||
ptr += ini[x];
|
||||
}
|
||||
*ret = fres;
|
||||
|
||||
@ -376,12 +376,12 @@ load_rule( void ) {
|
||||
pred->is_fact = FALSE;
|
||||
x = (strlen(strname) + 1) * sizeof(char);
|
||||
pred->predname = (char *)malloc(x);
|
||||
memcpy(pred->predname, strname, x);
|
||||
memmove(pred->predname, strname, x);
|
||||
nvec = (int32_t *)malloc(sizeof(int32_t)*(ptr-vec));
|
||||
memcpy(nvec, vec, sizeof(int32_t)*(ptr-vec));
|
||||
memmove(nvec, vec, sizeof(int32_t)*(ptr-vec));
|
||||
pred->address_host_table = nvec;
|
||||
pred->negatives = (int32_t *)malloc(sizeof(int32_t) * cont);
|
||||
memcpy(pred->negatives, neg, sizeof(int32_t) * cont);
|
||||
memmove(pred->negatives, neg, sizeof(int32_t) * cont);
|
||||
Cuda_NewRule( pred );
|
||||
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm((YAP_Int)pred));
|
||||
}
|
||||
|
||||
@ -180,7 +180,7 @@ void postgresRead(PGconn **ret, vector<gpunode> *L, int *inpquery, char *names,
|
||||
{
|
||||
numt = (strlen(tok) + 1) * sizeof(char);
|
||||
qrs[x] = (char *)malloc(numt);
|
||||
memcpy(qrs[x], tok, numt);
|
||||
memmove(qrs[x], tok, numt);
|
||||
}
|
||||
x += 2;
|
||||
}
|
||||
@ -264,7 +264,7 @@ void postgresRead(PGconn **ret, vector<gpunode> *L, int *inpquery, char *names,
|
||||
L->at(z).address_host_table = mat;
|
||||
numc = (strlen(tok) + 1) * sizeof(char);
|
||||
L->at(z).predname = (char *)malloc(numc);
|
||||
memcpy(L->at(z).predname, tok, numc);
|
||||
memmove(L->at(z).predname, tok, numc);
|
||||
PQclear(pgr);
|
||||
tok = strtok(NULL, " ");
|
||||
z++;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user