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

android debugging plus clean-ups

Browse Source
This commit is contained in:
Vítor Santos Costa
2015-04-13 13:28:17 +01:00
parent d1a230eb56
commit ef586e264e
77 changed files with 2346 additions and 4054 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
C/absmi.c
View File

@@ -3,7 +3,7 @@
* Yap Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* \z *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************

395
C/cdmgr.c
View File

File diff suppressed because it is too large Load Diff

6
C/fli_absmi_insts.h
View File

@@ -14,13 +14,13 @@
char *s; Atom name;
if (PREG->y_u.Osbpp.p->ArityOfPE) {
Functor f = PREG->y_u.Osbpp.p->FunctorOfPred;
name = f->NameOfFE;
name = f->NameOfFE;
} else {
name = (Atom)(PREG->y_u.Osbpp.p->FunctorOfPred);
}
s = name->StrOfAE;
__android_log_print(ANDROID_LOG_INFO, "YAP", " %s ", s);
LOG( " %s ", s);
#endif
check_trail(TR);
if (!(PREG->y_u.Osbpp.p->PredFlags & (SafePredFlag|NoTracePredFlag|HiddenPredFlag))) {

16
C/iopreds.c
View File

@@ -574,7 +574,7 @@ Yap_read_term(term_t t0, IOSTREAM *inp_stream, struct read_data_t *rd)
Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable, LOCAL_Comments);
rd->varnames = 0;
rd->singles = 0;
return Yap_unify_constant( Yap_GetFromSlot( t0 PASS_REGS), MkAtomTerm (AtomEof));
return Yap_unify_constant( Yap_GetFromSlot( t0), MkAtomTerm (AtomEof));
}
}
repeat_cycle:
@@ -620,7 +620,7 @@ Yap_read_term(term_t t0, IOSTREAM *inp_stream, struct read_data_t *rd)
Yap_clean_tokenizer(tokstart, LOCAL_VarTable, LOCAL_AnonVarTable, LOCAL_Comments);
rd->has_exception = TRUE;
rd->exception = Yap_InitSlot(terror PASS_REGS);
rd->exception = Yap_InitSlot(terror);
CurrentModule = OCurrentModule;
return FALSE;
}
@@ -630,9 +630,9 @@ Yap_read_term(term_t t0, IOSTREAM *inp_stream, struct read_data_t *rd)
break;
}
}
if (!Yap_unify(t, Yap_GetFromSlot( t0 PASS_REGS)))
if (!Yap_unify(t, Yap_GetFromSlot( t0)))
return FALSE;
if (store_comments && !Yap_unify(LOCAL_Comments, Yap_GetFromSlot( rd->comments PASS_REGS)))
if (store_comments && !Yap_unify(LOCAL_Comments, Yap_GetFromSlot( rd->comments )))
return FALSE;
if (rd->varnames) {
Term v;
@@ -656,7 +656,7 @@ Yap_read_term(term_t t0, IOSTREAM *inp_stream, struct read_data_t *rd)
}
}
LOCAL_VarNames = v;
if (!Yap_unify(v, Yap_GetFromSlot( rd->varnames PASS_REGS ))) {
if (!Yap_unify(v, Yap_GetFromSlot( rd->varnames ))) {
CurrentModule = OCurrentModule;
return FALSE;
}
@@ -683,7 +683,7 @@ Yap_read_term(term_t t0, IOSTREAM *inp_stream, struct read_data_t *rd)
TR = old_TR;
}
}
if (!Yap_unify(v, Yap_GetFromSlot( rd->variables PASS_REGS ) )) {
if (!Yap_unify(v, Yap_GetFromSlot( rd->variables ) )) {
CurrentModule = OCurrentModule;
return FALSE;
}
@@ -711,11 +711,11 @@ Yap_read_term(term_t t0, IOSTREAM *inp_stream, struct read_data_t *rd)
}
if (rd->singles == 1) {
if (IsPairTerm(v))
rd->singles = Yap_InitSlot( v PASS_REGS);
rd->singles = Yap_InitSlot( v );
else
rd->singles = FALSE;
} else if (rd->singles) {
if (!Yap_unify( v, Yap_GetFromSlot( rd->singles PASS_REGS ))) {
if (!Yap_unify( v, Yap_GetFromSlot( rd->singles ))) {
CurrentModule = OCurrentModule;
return FALSE;
}

8
C/parser.c
View File

@@ -848,7 +848,7 @@ case Var_tok:
tn = Yap_MkNewApplTerm(SWIFunctorToFunctor(FUNCTOR_quasi_quotation4), 4);
tnp = RepAppl(tn) + 1;
tnp[0] = MkAtomTerm(at);
if (!get_quasi_quotation(Yap_InitSlot(ArgOfTerm(2, tn) PASS_REGS),
if (!get_quasi_quotation(Yap_InitSlot(ArgOfTerm(2, tn)),
&qq->text,
qq->text + strlen((const char *)qq->text), rd))
FAIL;
@@ -857,7 +857,7 @@ case Var_tok:
intptr_t qqend = qq->end.charno;
// set_range_position(positions, -1, qqend PASS_LD);
if (!PL_unify_term(Yap_InitSlot(ArgOfTerm(2, t) PASS_REGS), PL_FUNCTOR,
if (!PL_unify_term(Yap_InitSlot(ArgOfTerm(2, t) ), PL_FUNCTOR,
FUNCTOR_minus2, PL_INTPTR,
qq->mid.charno + 2, /* end of | token */
PL_INTPTR, qqend - 2)) /* end minus "|}" */
@@ -865,12 +865,12 @@ case Var_tok:
}
tnp[2] =
Yap_GetFromSlot(rd->varnames PASS_REGS); /* Arg 3: the var dictionary */
Yap_GetFromSlot(rd->varnames); /* Arg 3: the var dictionary */
/* Arg 4: the result */
t = ArgOfTerm(4, tn);
if (!(to = PL_new_term_ref()) ||
!PL_unify_list(rd->qq_tail, to, rd->qq_tail) ||
!PL_unify(to, Yap_InitSlot(tn PASS_REGS)))
!PL_unify(to, Yap_InitSlot(tn )))
FAIL;
}
NextToken;

107
C/pl-yap.c
View File

@@ -72,7 +72,7 @@ codeToAtom(int chrcode)
if ( !(pv=GD->atoms.for_code[page]) )
{ pv = PL_malloc(256*sizeof(atom_t));
memset(pv, 0, 256*sizeof(atom_t));
GD->atoms.for_code[page] = pv;
}
@@ -83,7 +83,7 @@ codeToAtom(int chrcode)
} else
{ a = uncachedCodeToAtom(chrcode);
}
return a;
}
@@ -142,9 +142,9 @@ callProlog(module_t module, term_t goal, int flags, term_t *ex )
fail;
}
proc = PL_pred(fd, module);
{ int arity = arityFunctor(fd);
term_t args = PL_new_term_refs(arity);
qid_t qid;
@@ -196,7 +196,7 @@ PL_qualify(term_t raw, term_t qualified)
if ( !(mname = PL_new_term_ref()) ||
!PL_strip_module(raw, &m, qualified) )
return FALSE;
/* modules are terms in YAP */
Yap_PutInSlot(mname, (Term)m PASS_REGS);
@@ -208,7 +208,7 @@ int
valueExpression(term_t t, Number r ARG_LD)
{
REGS_FROM_LD
YAP_Term t0 = Yap_Eval(Yap_GetFromSlot(t PASS_REGS) PASS_REGS);
YAP_Term t0 = Yap_Eval(Yap_GetFromSlot(t ) PASS_REGS);
if (YAP_IsIntTerm(t0)) {
r->type = V_INTEGER;
r->value.i = YAP_IntOfTerm(t0);
@@ -263,7 +263,7 @@ double_in_int64_range(double x)
int
toIntegerNumber(Number n, int flags)
{
{
switch(n->type)
{ case V_INTEGER:
succeed;
@@ -283,12 +283,12 @@ switch(n->type)
if ( (flags & TOINT_CONVERT_FLOAT) )
{ if ( double_in_int64_range(n->value.f) )
{ int64_t l = (int64_t)n->value.f;
if ( (flags & TOINT_TRUNCATE) ||
(double)l == n->value.f )
{ n->value.i = l;
n->type = V_INTEGER;
return TRUE;
}
return FALSE;
@@ -296,7 +296,7 @@ switch(n->type)
} else
{ mpz_init_set_d(n->value.mpz, n->value.f);
n->type = V_MPZ;
return TRUE;
#endif
}
@@ -305,7 +305,7 @@ switch(n->type)
}
assert(0);
fail;
}
}
int
@@ -313,15 +313,15 @@ _PL_unify_atomic(term_t t, PL_atomic_t a)
{
GET_LD
if (IsApplTerm(a) || IsAtomTerm(a))
return Yap_unify(Yap_GetFromSlot(t PASS_REGS), a);
return Yap_unify(Yap_GetFromSlot(t ), a);
return PL_unify_atom(t, a);
}
int
_PL_unify_string(term_t t, word w)
{
CACHE_REGS
return Yap_unify(Yap_GetFromSlot(t PASS_REGS), w);
CACHE_REGS
return Yap_unify(Yap_GetFromSlot(t ), w);
}
Atom lookupAtom(const char *s, size_t len)
@@ -395,7 +395,7 @@ typedef union
int
get_atom_ptr_text(Atom a, PL_chars_t *text)
{
{
if (IsWideAtom(a)) {
pl_wchar_t *name = (pl_wchar_t *)a->WStrOfAE;
text->text.w = name;
@@ -467,7 +467,7 @@ patch used localeconv() to find the decimal point, but this is both
complicated and not thread-safe.
Finally, with help of Richard we decided to replace the first character
that is not a digit nor [eE], as this must be the decimal point.
that is not a digit nor [eE], as this must be the decimal point.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#define isDigit(c) ((c) >= '0' && (c) <= '9')
@@ -582,7 +582,7 @@ int
priorityOperator(Module m, atom_t atom)
{
YAP_Term mod = (YAP_Term)m;
if (!m)
if (!m)
mod = YAP_CurrentModule();
return YAP_MaxOpPriority(YAP_AtomFromSWIAtom(atom), mod);
}
@@ -593,7 +593,7 @@ currentOperator(Module m, atom_t name, int kind, int *type, int *priority)
YAP_Term mod = (YAP_Term)m;
int opkind, yap_type;
if (!m)
if (!m)
mod = YAP_CurrentModule();
switch (kind) {
case OP_PREFIX:
@@ -630,7 +630,7 @@ currentOperator(Module m, atom_t name, int kind, int *type, int *priority)
break;
case 7:
*type = OP_FX;
break;
break;
default:
*type = OP_FY;
break;
@@ -861,9 +861,9 @@ Yap_TermToString(Term t, char *s, size_t sz, size_t *length, int *encoding, int
Int l;
Int myASP = LCL0-ASP;
yhandle_t CurSlot = Yap_StartSlots();
Yap_StartSlots( );
l = Yap_InitSlot(t PASS_REGS );
l = Yap_InitSlot(t );
{ IOENC encodings[3];
IOENC *enc;
@@ -874,7 +874,7 @@ Yap_TermToString(Term t, char *s, size_t sz, size_t *length, int *encoding, int
encodings[2] = ENC_UNKNOWN;
for(enc = encodings; *enc != ENC_UNKNOWN; enc++)
{
{
int64_t size;
IOSTREAM *fd;
@@ -891,10 +891,10 @@ Yap_TermToString(Term t, char *s, size_t sz, size_t *length, int *encoding, int
{ *encoding = *enc;
size = Stell64(fd);
if ( *enc == ENC_ISO_LATIN_1 )
{
{
*length = size-1;
} else
{
{
*length = (size/sizeof(pl_wchar_t))-1;
}
/* found, just check if using local space */
@@ -935,23 +935,16 @@ Yap_HandleToString(term_t l, size_t sz, size_t *length, int *encoding, int flags
size_t size = 4096, total = size;
IOSTREAM *fd;
total = size;
total = size+1;
buf = malloc(total);
#ifdef DEBUG
{CACHE_REGS
__android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "text %p \n", buf);}
#endif
buf[0]='\0';
while ( (fd = Sopenmem(&buf, &size, "w")) == NULL ||
(( fd->encoding = ENC_UTF8) && FALSE) ||
(PL_write_term(fd, l, 1200, flags) == 0) ||
Sputcode(EOS, fd) < 0 ||
Sflush(fd) < 0 ) /* failure */
{
#ifdef DEBUG
{CACHE_REGS
__android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "fd %p, %x buf=%s\n", fd, LOCAL_SlotBase[28], buf);}
#endif
Sclose(fd);
Sclose(fd);
if (!fd)
return NULL;
total += size;
@@ -960,11 +953,7 @@ Yap_HandleToString(term_t l, size_t sz, size_t *length, int *encoding, int flags
return NULL;
Sclose(fd);
}
#ifdef DEBUG
{CACHE_REGS
__android_log_print(ANDROID_LOG_ERROR, __FUNCTION__, "text done %s", buf);}
#endif
Sclose(fd);
Sclose(fd);
/* success */
return buf;
}
@@ -988,9 +977,9 @@ char *
PL_prompt_string(int fd)
{ if ( fd == 0 )
{ atom_t a = PrologPrompt(); /* TBD: deal with UTF-8 */
if ( a )
{
{
Atom at = YAP_AtomFromSWIAtom(a);
if (!IsWideAtom(at) && !IsBlob(at)) {
return RepAtom(at)->StrOfAE;
@@ -1082,7 +1071,7 @@ PL_dispatch(int fd, int wait)
X_API int _PL_get_arg__LD(int index, term_t ts, term_t a ARG_LD)
{
REGS_FROM_LD
YAP_Term t = Yap_GetFromSlot(ts PASS_REGS);
YAP_Term t = Yap_GetFromSlot(ts);
if ( !YAP_IsApplTerm(t) ) {
if (YAP_IsPairTerm(t)) {
if (index == 1){
@@ -1098,13 +1087,13 @@ X_API int _PL_get_arg__LD(int index, term_t ts, term_t a ARG_LD)
Yap_PutInSlot(a,ArgOfTerm(index, t) PASS_REGS);
return 1;
}
/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
YAP: YAP_Atom YAP_AtomOfTerm(Term) */
int PL_get_atom__LD(term_t ts, atom_t *a ARG_LD)
{
REGS_FROM_LD
YAP_Term t = Yap_GetFromSlot(ts PASS_REGS);
YAP_Term t = Yap_GetFromSlot(ts);
if ( !IsAtomTerm(t))
return 0;
*a = YAP_SWIAtomFromAtom(AtomOfTerm(t));
@@ -1121,61 +1110,61 @@ X_API int PL_put_atom__LD(term_t t, atom_t a ARG_LD)
int PL_put_term__LD(term_t d, term_t s ARG_LD)
{
REGS_FROM_LD
Yap_PutInSlot(d,Yap_GetFromSlot(s PASS_REGS) PASS_REGS);
Yap_PutInSlot(d,Yap_GetFromSlot(s) PASS_REGS);
return 1;
}
term_t PL_new_term_ref__LD(ARG1_LD)
{
REGS_FROM_LD
term_t to = Yap_NewSlots(1 PASS_REGS);
term_t to = Yap_NewSlots(1);
return to;
}
int PL_is_atom__LD(term_t ts ARG_LD)
{
REGS_FROM_LD
Term t = Yap_GetFromSlot(ts PASS_REGS);
Term t = Yap_GetFromSlot(ts);
return !IsVarTerm(t) && IsAtomTerm(t);
}
int PL_is_variable__LD(term_t ts ARG_LD)
{
REGS_FROM_LD
YAP_Term t = Yap_GetFromSlot(ts PASS_REGS);
YAP_Term t = Yap_GetFromSlot(ts);
return IsVarTerm(t);
}
X_API int PL_unify__LD(term_t t1, term_t t2 ARG_LD)
{
REGS_FROM_LD
return Yap_unify(Yap_GetFromSlot(t1 PASS_REGS),Yap_GetFromSlot(t2 PASS_REGS));
return Yap_unify(Yap_GetFromSlot(t1),Yap_GetFromSlot(t2));
}
int PL_unify_atom__LD(term_t t, atom_t at ARG_LD)
{
REGS_FROM_LD
YAP_Term cterm = MkAtomTerm(YAP_AtomFromSWIAtom(at));
return YAP_Unify(Yap_GetFromSlot(t PASS_REGS),cterm);
return YAP_Unify(Yap_GetFromSlot(t),cterm);
}
/* SWI: int PL_unify_integer(term_t ?t, long n)
YAP long int unify(YAP_Term* a, Term* b) */
int PL_unify_integer__LD(term_t t, intptr_t i ARG_LD)
{
{
REGS_FROM_LD
Term iterm = MkIntegerTerm(i);
return Yap_unify(Yap_GetFromSlot(t PASS_REGS),iterm);
return Yap_unify(Yap_GetFromSlot(t),iterm);
}
/* SWI: int PL_unify_integer(term_t ?t, long n)
YAP long int unify(YAP_Term* a, Term* b) */
X_API int PL_unify_int64__LD(term_t t, int64_t n ARG_LD)
{
{
REGS_FROM_LD
#if SIZEOF_INT_P==8
Term iterm = MkIntegerTerm(n);
return Yap_unify(Yap_GetFromSlot(t PASS_REGS),iterm);
return Yap_unify(Yap_GetFromSlot(t),iterm);
#elif USE_GMP
YAP_Term iterm;
char s[64];
@@ -1190,7 +1179,7 @@ X_API int PL_unify_int64__LD(term_t t, int64_t n ARG_LD)
#endif
mpz_init_set_str (&rop, s, 10);
iterm = YAP_MkBigNumTerm((void *)&rop);
return YAP_Unify(Yap_GetFromSlot(t PASS_REGS),iterm);
return YAP_Unify(Yap_GetFromSlot(t),iterm);
#else
if ((long)n == n)
return PL_unify_integer(t, n);
@@ -1238,12 +1227,12 @@ PL_w32thread_raise(DWORD id, int sig)
if ( sig < 0 || sig > MAXSIGNAL )
return FALSE; /* illegal signal */
PL_LOCK(L_PLFLAG);
PL_LOCK(L_PLFLAG);
for(i = 0; i <= thread_highest_id; i++)
{ PL_thread_info_t *info = GD->thread.threads[i];
if ( info && info->w32id == id && info->thread_data )
{
{
Sfprintf(GLOBAL_stderr, "post %d %d\n\n\n",i, sig);
Yap_external_signal(i, sig); //raiseSignal(info->thread_data, sig);
if ( info->w32id )
@@ -1254,7 +1243,7 @@ PL_w32thread_raise(DWORD id, int sig)
}
}
PL_UNLOCK(L_PLFLAG);
return FALSE; /* can't find thread */
}

75
C/qlyr.c
View File

@@ -77,14 +77,15 @@ Yap_AlwaysAllocCodeSpace(UInt size)
static void
QLYR_ERROR(qlfr_err_t my_err)
{
Yap_Error(SAVED_STATE_ERROR,TermNil,"error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]);
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]);
Yap_Error(SAVED_STATE_ERROR,TermNil,"error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]);
Yap_exit(1);
}
static Atom
LookupAtom(Atom oat)
{
CACHE_REGS
CACHE_REGS
CELL hash = (CELL)(oat) % LOCAL_ImportAtomHashTableSize;
import_atom_hash_entry_t *a;
@@ -95,6 +96,7 @@ LookupAtom(Atom oat)
}
a = a->next;
}
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %p in saved state ", oat);
QLYR_ERROR(UNKNOWN_ATOM);
return NIL;
}
@@ -459,12 +461,12 @@ TermToGlobalOrAtomAdjust(Term t)
#define CharP(X) ((char *)(X))
#define REINIT_LOCK(P)
#define REINIT_RWLOCK(P)
#define REINIT_LOCK(P)
#define REINIT_RWLOCK(P)
#define BlobTypeAdjust(P) (P)
#define NoAGCAtomAdjust(P) (P)
#define OrArgAdjust(P)
#define TabEntryAdjust(P)
#define OrArgAdjust(P)
#define TabEntryAdjust(P)
#define IntegerAdjust(D) (D)
#define AddrAdjust(P) (P)
#define MFileAdjust(P) (P)
@@ -480,8 +482,8 @@ CodeVarAdjust__ (Term var USES_REGS)
#define ConstantAdjust(P) (P)
#define ArityAdjust(P) (P)
#define DoubleInCodeAdjust(P)
#define IntegerInCodeAdjust(Pxb)
#define DoubleInCodeAdjust(P)
#define IntegerInCodeAdjust(Pxb)
static inline PredEntry *
PtoPredAdjust(PredEntry *p)
@@ -706,7 +708,7 @@ checkChars(IOSTREAM *stream, char s[])
{
int ch, c;
char *p = s;
while ((ch = *p++)) {
if ((c = read_byte(stream)) != ch ) {
return false;
@@ -773,7 +775,7 @@ ReadHash(IOSTREAM *stream)
Atom oat = (Atom)read_UInt(stream);
Atom at;
qlf_tag_t tg = read_tag(stream);
if (tg == QLY_ATOM_WIDE) {
wchar_t *rep = (wchar_t *)AllocTempSpace();
UInt len;
@@ -833,7 +835,7 @@ ReadHash(IOSTREAM *stream)
UInt arity = read_UInt(stream);
Atom omod = (Atom)read_UInt(stream);
Term mod;
if (omod) {
mod = MkAtomTerm(AtomAdjust(omod));
if (mod == TermProlog) mod = 0;
@@ -889,7 +891,7 @@ ReadHash(IOSTREAM *stream)
UInt nrefs = read_UInt(stream);
LogUpdClause *ncl = (LogUpdClause *)Yap_AlwaysAllocCodeSpace(sz);
if (!ncl) {
QLYR_ERROR(OUT_OF_CODE_SPACE);
QLYR_ERROR(OUT_OF_CODE_SPACE);
}
ncl->Id = FunctorDBRef;
ncl->ClRefCount = nrefs;
@@ -900,9 +902,9 @@ ReadHash(IOSTREAM *stream)
}
static void
read_clauses(IOSTREAM *stream, PredEntry *pp, UInt nclauses, UInt flags) {
read_clauses(IOSTREAM *stream, PredEntry *pp, UInt nclauses, pred_flags_t flags) {
CACHE_REGS
if (pp->PredFlags & LogUpdatePredFlag) {
if (flags & LogUpdatePredFlag) {
/* first, clean up whatever was there */
if (pp->cs.p_code.NOfClauses) {
LogUpdClause *cl;
@@ -934,7 +936,7 @@ read_clauses(IOSTREAM *stream, PredEntry *pp, UInt nclauses, UInt flags) {
RestoreLUClause(cl, pp PASS_REGS);
Yap_AssertzClause(pp, cl->ClCode);
}
} else if (pp->PredFlags & MegaClausePredFlag) {
} else if (flags & MegaClausePredFlag) {
CACHE_REGS
char *base = (void *)read_UInt(stream);
UInt mask = read_UInt(stream);
@@ -952,26 +954,26 @@ read_clauses(IOSTREAM *stream, PredEntry *pp, UInt nclauses, UInt flags) {
cl->ClCode;
pp->PredFlags |= MegaClausePredFlag;
/* enter index mode */
if (mask & ExoMask) {
struct index_t **icl = (struct index_t **)(cl->ClCode);
if (mask & ExoMask) {
struct index_t **icl = (struct index_t **)(cl->ClCode);
pp->OpcodeOfPred = Yap_opcode(_enter_exo);
icl[0] = NULL;
icl[1] = NULL;
} else {
pp->OpcodeOfPred = INDEX_OPCODE;
}
pp->CodeOfPred = pp->cs.p_code.TrueCodeOfPred = (yamop *)(&(pp->OpcodeOfPred));
pp->CodeOfPred = pp->cs.p_code.TrueCodeOfPred = (yamop *)(&(pp->OpcodeOfPred));
/* This must be set for restoremegaclause */
pp->cs.p_code.NOfClauses = nclauses;
RestoreMegaClause(cl PASS_REGS);
} else if (pp->PredFlags & DynamicPredFlag) {
} else if (flags & DynamicPredFlag) {
UInt i;
for (i = 0; i < nclauses; i++) {
char *base = (void *)read_UInt(stream);
UInt size = read_UInt(stream);
DynamicClause *cl = (DynamicClause *)Yap_AlwaysAllocCodeSpace(size);
LOCAL_HDiff = (char *)cl-base;
read_bytes(stream, cl, size);
INIT_LOCK(cl->ClLock);
@@ -983,9 +985,9 @@ read_clauses(IOSTREAM *stream, PredEntry *pp, UInt nclauses, UInt flags) {
UInt i;
if (pp->PredFlags & SYSTEM_PRED_FLAGS) {
if (flags & SYSTEM_PRED_FLAGS) {
if (nclauses) {
QLYR_ERROR(INCONSISTENT_CPRED);
QLYR_ERROR(INCONSISTENT_CPRED);
}
return;
}
@@ -1005,8 +1007,8 @@ read_clauses(IOSTREAM *stream, PredEntry *pp, UInt nclauses, UInt flags) {
static void
read_pred(IOSTREAM *stream, Term mod) {
UInt flags;
UInt nclauses, fl1;
pred_flags_t flags, fl1;
UInt nclauses;
PredEntry *ap;
ap = LookupPredEntry((PredEntry *)read_UInt(stream));
@@ -1015,17 +1017,24 @@ read_pred(IOSTREAM *stream, Term mod) {
if (ap->PredFlags & IndexedPredFlag) {
Yap_RemoveIndexation(ap);
}
/* if (ap->ArityOfPE && ap->ModuleOfPred != IDB_MODULE) */
#if 0
if (ap->ArityOfPE && ap->ModuleOfPred != IDB_MODULE)
__android_log_print(ANDROID_LOG_INFO, "YAP ", " %s/%ld %lx\n", NameOfFunctor(ap->FunctorOfPred)->StrOfAE, ap->ArityOfPE, flags);
/* printf(" %s/%ld %lx\n", NameOfFunctor(ap->FunctorOfPred)->StrOfAE, ap->ArityOfPE, flags); */
/* else if (ap->ModuleOfPred != IDB_MODULE) */
else if (ap->ModuleOfPred != IDB_MODULE)
__android_log_print(ANDROID_LOG_INFO, "YAP "," %s/%ld %lx\n", ((Atom)(ap->FunctorOfPred))->StrOfAE, ap->ArityOfPE, flags);
/* printf(" %s/%ld %lx\n", ((Atom)(ap->FunctorOfPred))->StrOfAE, ap->ArityOfPE, flags); */
fl1 = flags & ((UInt)STATIC_PRED_FLAGS|(UInt)EXTRA_PRED_FLAGS);
else
__android_log_print(ANDROID_LOG_INFO, "YAP "," number\n");
#endif
fl1 = flags & ((pred_flags_t)STATIC_PRED_FLAGS|(UInt)EXTRA_PRED_FLAGS);
ap->PredFlags &= ~((UInt)STATIC_PRED_FLAGS|(UInt)EXTRA_PRED_FLAGS);
ap->PredFlags |= fl1;
if (flags & NumberDBPredFlag) {
ap->src.IndxId = read_UInt(stream);
} else {
ap->src.OwnerFile = (Atom)read_UInt(stream);
if (ap->src.OwnerFile) {
ap->src.OwnerFile = AtomAdjust(ap->src.OwnerFile);
}
@@ -1035,8 +1044,10 @@ read_pred(IOSTREAM *stream, Term mod) {
if (flags & MultiFileFlag && ap->ModuleOfPred == PROLOG_MODULE) {
ap->ModuleOfPred = TermProlog;
}
read_clauses(stream, ap, nclauses, flags);
if (flags & HiddenPredFlag) {
if (nclauses)
read_clauses(stream, ap, nclauses, flags);
if (flags & HiddenPredFlag) {
Yap_HidePred(ap);
}
}
@@ -1134,11 +1145,11 @@ p_read_program( USES_REGS1 )
return TRUE;
}
int
int
Yap_Restore(char *s, char *lib_dir)
{
IOSTREAM *stream = Yap_OpenRestore(s, lib_dir);
if (!stream)
if (!stream)
return -1;
GLOBAL_RestoreFile = s;
if (get_header( stream ) == NIL)
@@ -1146,6 +1157,7 @@ Yap_Restore(char *s, char *lib_dir)
read_module(stream);
Sclose( stream );
GLOBAL_RestoreFile = NULL;
CurrentModule = USER_MODULE;
return DO_ONLY_CODE;
}
@@ -1160,4 +1172,3 @@ void Yap_InitQLYR(void)
restore_codes();
}
}

13
C/save.c
View File

@@ -249,19 +249,6 @@ open_file(char *my_file, int flag)
char flags[6];
int i=0;
#if __ANDROID__
if (strstr(my_file, "/assets/") == my_file) {
if (flag == O_RDONLY) {
my_file += strlen("/assets/");
AAsset* asset = AAssetManager_open(GLOBAL_assetManager, my_file, AASSET_MODE_UNKNOWN);
if (!asset)
return NULL;
AAsset_close( asset );
return NULL; // usually the file will be compressed, so there is no point in actually trying to open it.
}
return NULL;
}
#endif
if (flag & O_RDONLY) {
flags[i++] = 'r';
}

138
C/stdpreds.c Normal file → Executable file
View File

@@ -877,61 +877,69 @@ static Int
return TRUE;
}
static PropEntry *
fetchPredFromListOfProps (PropEntry *p)
{
while (p) {
if (p->KindOfPE == PEProp) {
// found our baby..
return p;
} else if (p->KindOfPE == FunctorProperty) {
// go to list of properties in functor..
PropEntry *q;
FunctorEntry *f = RepFunctorProp(p);
if ((q = fetchPredFromListOfProps( f->PropsOfFE ))) {
return q;
}
}
p = p->NextOfPE;
}
return NIL;
}
static PropEntry *
nextPredForAtom (PropEntry *p)
{
PredEntry *pe;
if (p == NIL)
return NIL;
pe = RepPredProp(p);
if (pe->ArityOfPE == 0) {
// if atom prop, search atom list
return fetchPredFromListOfProps(p->NextOfPE);
} else {
FunctorEntry *f = pe->FunctorOfPred;
// first search remainder of functor list
if ((p = fetchPredFromListOfProps(p->NextOfPE))) {
return p;
}
// if that fails, follow the functor
return fetchPredFromListOfProps( f->NextOfPE );
}
}
static Int cont_current_predicate(USES_REGS1) {
PredEntry *pp = NULL;
PropEntry *n;
UInt Arity;
Term name;
Term t1 = Deref(ARG1), t2 = Deref(ARG2), t3;
bool is_det = false, rc;
bool rc;
Functor f;
if (IsNonVarTerm(t1)) {
// current_pred(A, M, P)
PropEntry *p = AddressOfTerm(EXTRA_CBACK_ARG(4, 1));
PropEntry *q = AddressOfTerm(EXTRA_CBACK_ARG(4, 2));
// restart inner loop
for (; q; q = q->NextOfPE) {
if (q->KindOfPE == PEProp) {
pp = RepPredProp(q);
q = q->NextOfPE;
if (q == NIL)
p = p->NextOfPE;
if (!p)
is_det = true;
// we are done with this loop.
break;
}
}
if (!pp && p) {
// try using outer loop
for (; p; p = p->NextOfPE) {
if (p->KindOfPE == PEProp) {
q = NULL;
pp = RepPredProp(p);
p = p->NextOfPE;
if (!p)
is_det = true;
break;
} else if (p->KindOfPE == FunctorProperty) {
// looping on p/n
for (q = RepFunctorProp(p)->PropsOfFE; q; q = q->NextOfPE) {
if (q->KindOfPE == PEProp) {
pp = RepPredProp(q);
q = q->NextOfPE;
if (!q && !p->NextOfPE)
is_det = true;
break;
}
}
break;
}
}
}
if (pp == NULL) // nothing more
cut_fail();
if (!is_det) {
EXTRA_CBACK_ARG(4, 1) = MkAddressTerm(p);
EXTRA_CBACK_ARG(4, 2) = MkAddressTerm(q);
pp = RepPredProp(p);
n = nextPredForAtom (p);
if (n == NIL) {
YAP_cut_up();
} else {
EXTRA_CBACK_ARG(4, 1) = MkAddressTerm(n);
B->cp_h = HR;
}
} else if (IsNonVarTerm(t2)) {
// operating within the same module.
@@ -945,8 +953,8 @@ static Int cont_current_predicate(USES_REGS1) {
if (npp) {
EXTRA_CBACK_ARG(4, 1) = MkAddressTerm(npp);
B->cp_h = HR;
} else {
is_det = true;
} else {
YAP_cut_up();
}
} else {
pp = AddressOfTerm(EXTRA_CBACK_ARG(4, 1));
@@ -964,10 +972,12 @@ static Int cont_current_predicate(USES_REGS1) {
} // we found a new answer
if (!pp)
cut_fail();
else
else {
EXTRA_CBACK_ARG(4, 1) = MkAddressTerm(pp->NextPredOfModule);
B->cp_h = HR;
B->cp_h = HR;
}
}
if (pp->ModuleOfPred != IDB_MODULE) {
f = pp->FunctorOfPred;
Arity = pp->ArityOfPE;
@@ -996,15 +1006,11 @@ static Int cont_current_predicate(USES_REGS1) {
t3 = name;
}
rc = (!(pp->PredFlags & HiddenPredFlag)) &&
Yap_unify(ARG2, ModToTerm(pp->ModuleOfPred)) && Yap_unify(ARG1, name) &&
Yap_unify(ARG3, t3) && Yap_unify(ARG4, MkIntegerTerm(pp->PredFlags));
if (is_det) {
if (rc)
cut_succeed();
else
cut_fail();
}
return rc;
Yap_unify(ARG2, ModToTerm(pp->ModuleOfPred)) &&
Yap_unify(ARG1, name) &&
Yap_unify(ARG3, t3) &&
Yap_unify(ARG4, MkIntegerTerm(pp->PredFlags));
return rc;
}
static Int init_current_predicate(USES_REGS1) {
@@ -1015,6 +1021,9 @@ static Int init_current_predicate(USES_REGS1) {
PredEntry *pp = NULL;
ModEntry *m = NULL;
t1 = Yap_StripModule(t1, &t2);
t3 = Yap_StripModule(t3, &t2);
// check term
if (!IsVarTerm(t3)) {
t3 = Yap_StripModule(t3, &t2);
@@ -1076,15 +1085,10 @@ static Int init_current_predicate(USES_REGS1) {
Yap_Error(TYPE_ERROR_ATOM, t1, "current_predicate/2");
cut_fail();
} else {
PropEntry *p = RepAtom(AtomOfTerm(t1))->PropsOfAE, *q = NIL;
while (p && p->KindOfPE == FunctorProperty &&
(q = RepFunctorProp(p)->PropsOfFE) == NIL) {
p = p->NextOfPE;
}
PropEntry *p = fetchPredFromListOfProps(RepAtom(AtomOfTerm(t1))->PropsOfAE);
if (!p)
cut_fail();
EXTRA_CBACK_ARG(4, 1) = MkAddressTerm(p);
EXTRA_CBACK_ARG(4, 2) = MkAddressTerm(q);
B->cp_h = HR;
}
}
@@ -1130,7 +1134,7 @@ int Yap_IsOpMaxPrio(Atom at) {
CACHE_REGS
OpEntry *op = NextOp(RepOpProp((Prop)(RepAtom(at)->PropsOfAE)) PASS_REGS);
int max;
if (EndOfPAEntr(op))
return 0;
max = (op->Prefix & 0xfff);
@@ -1162,7 +1166,7 @@ static Int cont_current_op(USES_REGS1) {
READ_UNLOCK(op->OpRWLock);
if (next) {
EXTRA_CBACK_ARG(5, 1) = (CELL)MkIntegerTerm((CELL)next);
B->cp_h = HR;
B->cp_h = HR;
return TRUE;
} else {
cut_succeed();
@@ -1171,7 +1175,7 @@ static Int cont_current_op(USES_REGS1) {
READ_UNLOCK(op->OpRWLock);
if (next) {
EXTRA_CBACK_ARG(5, 1) = (CELL)MkIntegerTerm((CELL)next);
B->cp_h = HR;
B->cp_h = HR;
return FALSE;
} else {
cut_fail();
@@ -1187,7 +1191,7 @@ static Int init_current_op(USES_REGS1) { /* current_op(-Precedence,-Type,-Atom)
static Int cont_current_atom_op(USES_REGS1) {
OpEntry *op = (OpEntry *)IntegerOfTerm(EXTRA_CBACK_ARG(5, 1)), *next;
READ_LOCK(op->OpRWLock);
next = NextOp(RepOpProp(op->NextOfPE) PASS_REGS);
if (unify_op(op PASS_REGS)) {

467
C/sysbits.c
View File

@@ -107,13 +107,14 @@ static char SccsId[] = "%W% %G%";
#include <readline/readline.h>
#endif
/// File Error Handler
static void
Yap_FileError(yap_error_number type, Term where, const char *format,...)
{
GET_LD
if ( truePrologFlag(PLFLAG_FILEERRORS) ) {
if ( truePrologFlag(PLFLAG_FILEERRORS) ) {
va_list ap;
va_start (ap, format);
/* now build the error string */
Yap_Error(type, TermNil, format, ap);
@@ -123,6 +124,7 @@ Yap_FileError(yap_error_number type, Term where, const char *format,...)
}
static void InitTime(int);
static void InitWTime(void);
static Int p_sh( USES_REGS1 );
@@ -141,24 +143,6 @@ static int chdir(char *);
/* #define signal skel_signal */
#endif /* MACYAP */
#if DEBUG
void
LOG(const char *fmt, ...);
void
LOG(const char *fmt, ...)
{
FILE * fd;
va_list ap;
fd = fopen("c:\\cygwin\\Log.txt", "a");
va_start(ap, fmt);
vfprintf(fd, fmt, ap);
va_end(ap);
fclose( fd );
}
#endif
void exit(int);
@@ -180,12 +164,118 @@ Yap_WinError(char *yap_error)
#define is_valid_env_char(C) ( ((C) >= 'a' && (C) <= 'z') || ((C) >= 'A' && \
(C) <= 'Z') || (C) == '_' )
#if __ANDROID__
AAssetManager * Yap_assetManager;
void *
Yap_openAssetFile( const char *path ) {
AAssetDir *d;
LOG("openA %s %p", path, path);
const char * p = path+8;
AAsset* asset = AAssetManager_open(Yap_assetManager, p, AASSET_MODE_UNKNOWN);
return asset;
}
bool
Yap_isAsset( const char *path )
{
return path[0] == '/'&&
path[1] == 'a'&&
path[2] == 's'&&
path[3] == 's'&&
path[4] == 'e'&&
path[5] == 't'&&
path[6] == 's'&&
(path[7] == '/' || path[7] == '\0');
}
bool
Yap_AccessAsset( const char *name, int mode )
{
AAssetManager* mgr = Yap_assetManager;
const char *bufp=name+7;
if (bufp[0] == '/')
bufp++;
if ((mode & W_OK) == W_OK) {
return false;
}
// check if file is a directory.
AAssetDir *assetDir = AAssetManager_openDir(mgr, bufp);
if (assetDir) {
AAssetDir_close(assetDir);
return true;
}
return false;
}
bool
Yap_AssetIsFile( const char *name )
{
AAssetManager* mgr = Yap_assetManager;
const char *bufp=name+7;
if (bufp[0] == '/')
bufp++;
// check if file is a directory.
AAsset *asset = AAssetManager_open(mgr, bufp, AASSET_MODE_UNKNOWN);
if (!asset)
return false;
AAsset_close(asset);
return true;
}
bool
Yap_AssetIsDir( const char *name )
{
AAssetManager* mgr = Yap_assetManager;
const char *bufp=name+7;
if (bufp[0] == '/')
bufp++;
// check if file is a directory.
AAssetDir *assetDir = AAssetManager_openDir(mgr, bufp);
if (!assetDir) {
return false;
}
AAssetDir_close(assetDir);
AAsset *asset = AAssetManager_open(mgr, bufp, AASSET_MODE_UNKNOWN);
if (!asset)
return true;
AAsset_close(asset);
return false;
}
int64_t
Yap_AssetSize( const char *name )
{
AAssetManager* mgr = Yap_assetManager;
const char *bufp=name+7;
if (bufp[0] == '/')
bufp++;
AAsset *asset = AAssetManager_open(mgr, bufp, AASSET_MODE_UNKNOWN);
if (!asset)
return -1;
off64_t len = AAsset_getLength64(asset);
AAsset_close(asset);
return len;
}
#endif
/// is_directory: verifies whether an expanded file name
/// points at a readable directory
static bool
is_directory(const char *FileName)
{
#ifdef __ANDROID__
if (Yap_isAsset(FileName)) {
return Yap_AssetIsDir(FileName);
}
#endif
#ifdef __WINDOWS__
DWORD dwAtts = GetFileAttributes( FileName );
if (dwAtts == INVALID_FILE_ATTRIBUTES)
@@ -200,8 +290,8 @@ is_directory(const char *FileName)
}
return S_ISDIR(buf.st_mode);
#else
Yap_Error(SYSTEM_ERROR, TermNil,
"stat not available in this configuration");
Yap_Error(SYSTEM_ERROR, TermNil,
"stat not available in this configuration");
return false;
#endif
}
@@ -211,17 +301,22 @@ is_directory(const char *FileName)
static bool
has_access(const char *FileName, int mode)
{
#if HAS_ACCESS
#ifdef __ANDROID__
if (Yap_isAsset(FileName)) {
return Yap_AccessAsset(FileName, mode);
}
#endif
#if HAVE_ACCESS
if (access( FileName, mode ) == 0)
return true;
if (errno == EINVAL) {
Yap_Error(SYSTEM_ERROR, TermNil,
Yap_Error(SYSTEM_ERROR, TermNil,
"bad flags to access");
}
return false;
#else
Yap_Error(SYSTEM_ERROR, TermNil,
"access not available in this configuration");
Yap_Error(SYSTEM_ERROR, TermNil,
"access not available in this configuration");
return false;
#endif
}
@@ -269,25 +364,125 @@ IsAbsolutePath(const char *p)
#endif
}
#define isValidEnvChar(C) ( ((C) >= 'a' && (C) <= 'z') || ((C) >= 'A' && \
(C) <= 'Z') || (C) == '_' )
// this is necessary because
// support for ~expansion at the beginning
// systems like Android do not do this.
static char *
yapExpandVars (const char *source, char *result)
{
const char *src = source;
char *res = result;
if (strlen(source) >= YAP_FILENAME_MAX) {
Yap_Error(OPERATING_SYSTEM_ERROR, TermNil, "%s in true_file-name is larger than the buffer size (%d bytes)", source, strlen(source));
}
/* step 1: eating home information */
if (source[0] == '~') {
if (dir_separator(source[1]) || source[1] == '\0')
{
char *s;
src++;
#if defined(_WIN32)
s = getenv("HOMEDRIVE");
if (s != NULL)
strncpy (result, getenv ("HOMEDRIVE"), YAP_FILENAME_MAX);
s = getenv("HOMEPATH");
if (s != NULL)
strncpy (result, s, YAP_FILENAME_MAX);
#else
s = getenv ("HOME");
if (s != NULL)
strncpy (result, s, YAP_FILENAME_MAX);
#endif
} else {
#if HAVE_GETPWNAM
struct passwd *user_passwd;
src++;
while (!dir_separator((*res = *src)) && *res != '\0')
res++, src++;
res[0] = '\0';
if ((user_passwd = getpwnam (result)) == NULL) {
Yap_FileError(OPERATING_SYSTEM_ERROR, MkAtomTerm(Yap_LookupAtom(source)),"User %s does not exist in %s", result, source);
return NULL;
}
strncpy (result, user_passwd->pw_dir, YAP_FILENAME_MAX);
#else
Yap_FileError(OPERATING_SYSTEM_ERROR, MkAtomTerm(Yap_LookupAtom(source)),"User %s cannot be found in %s, missing getpwnam", result, source);
return NULL;
#endif
}
strncat (result, src, YAP_FILENAME_MAX);
return result;
}
#if !HAVE_WORDEXP
// do VARIABLE expansion
else if (source[0] == '$') {
/* follow SICStus expansion rules */
int ch;
char *s;
src = source+1;
if (src[0] == '{') {
src++;
while ((*res++ = (ch = *src++)) && isValidEnvChar (ch) && ch != '}') {
res++;
}
if (ch == '}') {
// {...}
// done
}
} else {
while ((*res++ = (ch = *src++)) && isValidEnvChar (ch) && ch != '}') {
res++;
}
src--;
}
res[0] = '\0';
if ((s = (char *) getenv (result))) {
strncpy (result, s, YAP_FILENAME_MAX);
} else {
result[0] = '\0';
}
strncat (result, src, YAP_FILENAME_MAX);
}
#endif
else {
strncpy (result, source, YAP_FILENAME_MAX);
}
return result;
}
char *
expandVars(const char *pattern, char *expanded, int maxlen)
{
char tmp[YAP_FILENAME_MAX+1];
if ((pattern = yapExpandVars(pattern, tmp)) == NULL) {
return NULL;
}
#if __WIN32 || __MINGW32__
DWORD retval=0;
// notice that the file does not need to exist1
if (ini == NULL) {
ini = malloc(strlen(w)+1);
}
retval = ExpandEnvironmentStrings(pattern,
expanded,
maxlen);
if (retval == 0)
if (retval == 0)
{
Yap_WinError("Generating a full path name for a file" );
return NULL;
}
return expanded;
#elif HAVE_WORDEXP
wordexp_t result;
return expanded;
#elif HAVE_WORDEXP
wordexp_t result;
/* Expand the string for the program to run. */
switch (wordexp (pattern, &result, 0))
{
@@ -297,6 +492,9 @@ wordexp_t result;
return NULL;
} else {
char *w = result.we_wordv[0];
if (expanded == NULL) {
expanded = malloc(strlen(w)+1);
}
strncpy( expanded, w, maxlen );
wordfree (&result);
return expanded;
@@ -309,8 +507,15 @@ wordexp_t result;
default: /* Some other error. */
return NULL;
}
#else
// just use basic
if (expanded == NULL) {
expanded = malloc(strlen(pattern)+1);
}
strcpy(expanded, pattern);
#endif
return NULL;
return expanded;
}
#if _WIN32 || defined(__MINGW32__)
@@ -378,15 +583,17 @@ PrologPath(const char *p, char *buf, size_t len)
char *
OsPath(const char *p, char *buf)
{ strcpy(buf, p);
{
if()z
trcpy(buf, p);
return buf;
}
#else
char *
OsPath(const char *X, char *Y) {
if (X!=Y && Y) strcpy(Y,X);
return Y;
//if (X!=Y && Y) strcpy(Y,X);
return (char *)X ;
}
#endif /* O_XOS */
@@ -398,10 +605,33 @@ OsPath(const char *X, char *Y) {
bool ChDir(const char *path) {
bool rc = false;
char *qpath = AbsoluteFile(path, NULL);
char *qpath = AbsoluteFile(path, NULL);
#ifdef __ANDROID__
if (GLOBAL_AssetsWD) {
free( GLOBAL_AssetsWD );
GLOBAL_AssetsWD = NULL;
}
if (Yap_isAsset(qpath) ) {
AAssetManager* mgr = Yap_assetManager;
const char *ptr = qpath+8;
AAssetDir* d;
if (ptr[0] == '/')
ptr++;
d = AAssetManager_openDir(mgr, ptr);
if (d) {
GLOBAL_AssetsWD = malloc( strlen(qpath) + 1 );
strcpy( GLOBAL_AssetsWD, qpath );
AAssetDir_close( d );
return true;
}
return false;
} else {
GLOBAL_AssetsWD = NULL;
}
#endif
#if _WIN32 || defined(__MINGW32__)
GET_LD
GET_LD
if ((rc = (SetCurrentDirectory(qpath) != 0)) == 0)
{
Yap_WinError("SetCurrentDirectory failed" );
@@ -415,7 +645,7 @@ bool ChDir(const char *path) {
#if _WIN32 || defined(__MINGW32__)
char *
BaseName(const char *X) {
char *qpath = unix2win(X, NULL, YAP_FILENAME_MAX);
char *qpath = unix2win(X, NULL, YAP_FILENAME_MAX);
char base[YAP_FILENAME_MAX], ext[YAP_FILENAME_MAX];
_splitpath(qpath, NULL, NULL, base, ext);
strcpy(qpath, base);
@@ -425,16 +655,16 @@ BaseName(const char *X) {
char *
DirName(const char *X) {
char dir[YAP_FILENAME_MAX];
char drive[YAP_FILENAME_MAX];
char dir[YAP_FILENAME_MAX];
char drive[YAP_FILENAME_MAX];
char *o = unix2win(X, NULL, YAP_FILENAME_MAX);
int err;
if (!o)
return NULL;
if (!o)
return NULL;
if (( err = _splitpath_s(o, drive, YAP_FILENAME_MAX-1, dir, YAP_FILENAME_MAX-1,NULL, 0, NULL, 0) ) != 0) {
Yap_FileError(OPERATING_SYSTEM_ERROR, TermNil, "could not perform _splitpath %s: %s", X, strerror(errno));
return NULL;
Yap_FileError(OPERATING_SYSTEM_ERROR, TermNil, "could not perform _splitpath %s: %s", X, strerror(errno));
return NULL;
}
strncpy(o, drive, YAP_FILENAME_MAX-1);
strncat(o, dir, YAP_FILENAME_MAX-1);
@@ -451,8 +681,8 @@ static char *myrealpath( const char *path, char *out)
YAP_FILENAME_MAX,
out,
NULL);
if (retval == 0)
if (retval == 0)
{
Yap_WinError("Generating a full path name for a file" );
return NULL;
@@ -462,25 +692,25 @@ static char *myrealpath( const char *path, char *out)
{
char *rc = realpath(path,out);
char *s0;
if (rc == NULL && (errno == ENOENT|| errno == EACCES)) {
char *s = basename((char *)path);
s0 = malloc(strlen(s)+1);
strcpy(s0, s);
if ((rc = myrealpath(dirname((char *)path), out))==NULL) {
Yap_FileError(OPERATING_SYSTEM_ERROR, TermNil, "could not find file %s: %s", path, strerror(errno));
return NULL;
Yap_FileError(OPERATING_SYSTEM_ERROR, TermNil, "could not find file %s: %s", path, strerror(errno));
return NULL;
}
if(rc[strlen(rc)-1] != '/' )
strcat(rc, "/");
strcat(rc, s0);
free(s0);
}
return rc;
return rc;
}
#else
return NULL;
#endif
#endif
}
char *
@@ -488,57 +718,44 @@ char *
{
GET_LD
char *rc;
char *qpath0;
#if _WIN32 || defined(__MINGW32__)
char *o = malloc(YAP_FILENAME_MAX+1);
if (!o)
return NULL;
// first pass, remove Unix style stuff
if (unix2win(spec, o, YAP_FILENAME_MAX) == NULL)
return NULL;
spec = (const char *)o;
#endif
#if HAVE_WORDEXP
char o[YAP_FILENAME_MAX+1];
#elif _WIN32 || defined(__MINGW32__)
char u[YAP_FILENAME_MAX+1];
// first pass, remove Unix style stuff
if (unix2win(spec, u, YAP_FILENAME_MAX) == NULL)
return NULL;
spec = (const char *)u;
#endif
if (tmp == NULL) {
tmp = malloc(YAP_FILENAME_MAX+1);
if (tmp == NULL) {
return NULL;
}
}
if ( truePrologFlag(PLFLAG_FILEVARS) )
if ( truePrologFlag(PLFLAG_FILEVARS) )
{
qpath0 = malloc(YAP_FILENAME_MAX+1);
#if HAVE_WORDEXP
qpath0=expandVars(spec,qpath0,YAP_FILENAME_MAX);
#if HAVE_WORDEXP
spec=expandVars(spec,o,YAP_FILENAME_MAX);
#endif
#if _WIN32 || defined(__MINGW32__)
free((char *)spec);
#endif
spec = qpath0;
}
#if HAVE_REALPATH
#if HAVE_REALPATH
rc = myrealpath(spec, tmp);
#endif
if (spec == qpath0
#if _WIN32 || defined(__MINGW32__)
|| true
#endif
)
free((char *)spec);
return rc;
}
char *canoniseFileName( char *path) {
#if HAVE_REALPATH && HAVE_BASENAME
#if _WIN32 || defined(__MINGW32__)
char *o = malloc(YAP_FILENAME_MAX+1);
if (!o)
return NULL;
// first pass, remove Unix style stuff
if (unix2win(path, o, YAP_FILENAME_MAX) == NULL)
return NULL;
path = o;
#endif
#if _WIN32 || defined(__MINGW32__)
char *o = malloc(YAP_FILENAME_MAX+1);
if (!o)
return NULL;
// first pass, remove Unix style stuff
if (unix2win(path, o, YAP_FILENAME_MAX) == NULL)
return NULL;
path = o;
#endif
char *rc, *tmp = malloc(PATH_MAX);
if (tmp == NULL) return NULL;
rc = myrealpath(path, tmp);
@@ -882,7 +1099,7 @@ void Yap_systime_interval(Int *now,Int *interval)
The problem is that mingw32 does not seem to have acces to div */
#ifndef do_div
#define do_div(n,base) ({ \
unsigned long __upper, __low, __high, __mod; \
unsigned long __upper, __low, __high, __mod; \
asm("":"=a" (__low), "=d" (__high):"A" (n)); \
__upper = __high; \
if (__high) { \
@@ -1492,8 +1709,8 @@ Yap_random (void)
#elif HAVE_RAND
return (((double) (rand ()) / RAND_MAX));
#else
Yap_Error(SYSTEM_ERROR, TermNil,
"random not available in this configuration");
Yap_Error(SYSTEM_ERROR, TermNil,
"random not available in this configuration");
return (0.0);
#endif
}
@@ -2035,7 +2252,7 @@ MSCHandleSignal(DWORD dwCtrlType) {
}
#endif
/* SIGINT can cause problems, if caught before full initialization */
static void
InitSignals (void)
@@ -2103,11 +2320,11 @@ Yap_volume_header(char *file)
char * PL_cwd(char *cwd, size_t cwdlen)
{
return Yap_getcwd( cwd, cwdlen );
return (char *)Yap_getcwd( (const char *)cwd, cwdlen );
}
char * Yap_getcwd(const char *cwd, size_t cwdlen)
{
const char * Yap_getcwd(const char *cwd, size_t cwdlen)
{
#if _WIN32 || defined(__MINGW32__)
if (GetCurrentDirectory(cwdlen, (char *)cwd) == 0)
{
@@ -2116,7 +2333,13 @@ Yap_volume_header(char *file)
}
return (char *)cwd;
#else
return getcwd(cwd, cwdlen);
#if __ANDROID__
if (GLOBAL_AssetsWD) {
return strncpy( (char *)cwd, (const char *)GLOBAL_AssetsWD, cwdlen);
}
#endif
return getcwd((char *)cwd, cwdlen);
#endif
}
@@ -2126,15 +2349,16 @@ Yap_volume_header(char *file)
{
char *work;
char ares1[YAP_FILENAME_MAX+1];
work = expandVars( source, ares1, YAP_FILENAME_MAX);
// expand names first
if (root && !IsAbsolutePath( source ) ) {
char ares2[YAP_FILENAME_MAX+1];
strncpy( ares2, root, YAP_FILENAME_MAX );
strncat( ares2, "/", YAP_FILENAME_MAX );
strncat( ares2, work, YAP_FILENAME_MAX );
return AbsoluteFile( ares2, result );
work = expandVars( source, ares1, YAP_FILENAME_MAX);
// expand names first
if (root && !IsAbsolutePath( source ) ) {
char ares2[YAP_FILENAME_MAX+1];
strncpy( ares2, root, YAP_FILENAME_MAX );
strncat( ares2, "/", YAP_FILENAME_MAX );
strncat( ares2, work, YAP_FILENAME_MAX );
return AbsoluteFile( ares2, result );
} else {
// expand path
return myrealpath( work, result);
@@ -2146,25 +2370,24 @@ Yap_volume_header(char *file)
TrueFileName (char *isource, char *root, char *result, int in_lib, int expand_root)
{
CACHE_REGS
char *work;
const char *source = isource;
// expand names in case you have
// to add a prefix
if (!expand_root)
root = NULL;
if (exists((work = expandWithPrefix( source, root, result ))))
return true; // done
if (exists((work = expandWithPrefix( source, root, result ))))
return true; // done
if (in_lib) {
if (Yap_LibDir != NULL) {
strncpy(LOCAL_FileNameBuf, Yap_LibDir, YAP_FILENAME_MAX);
if (Yap_LibDir != NULL) {
strncpy(LOCAL_FileNameBuf, Yap_LibDir, YAP_FILENAME_MAX);
}
#if HAVE_GETENV
{
char *yap_env = getenv("YAPLIBDIR");
if (yap_env &&
exists((work = expandWithPrefix( source, yap_env, result ))))
if (yap_env && exists((work = expandWithPrefix( source, yap_env, result ))))
return true; // done
}
#endif
@@ -2181,7 +2404,7 @@ TrueFileName (char *isource, char *root, char *result, int in_lib, int expand_ro
}
return false;
}
int
Yap_TrueFileName (char *source, char *result, int in_lib)
{
@@ -2287,14 +2510,14 @@ p_sh ( USES_REGS1 )
/** shell(+Command:text, -Status:integer) is det.
Run an external command and wait for its completion.
Run an external command and wait for its completion.
*/
static Int
p_shell ( USES_REGS1 )
{ /* '$shell'(+SystCommand) */
#if _MSC_VER || defined(__MINGW32__)
char *cmd;
term_t A1 = Yap_InitSlot(ARG1 PASS_REGS);
term_t A1 = Yap_InitSlot(ARG1);
if ( PL_get_chars(A1, &cmd, CVT_ALL|REP_FN|CVT_EXCEPTION) )
{ int rval = System(cmd);
@@ -2373,7 +2596,7 @@ p_system ( USES_REGS1 )
{ /* '$system'(+SystCommand) */
#if _MSC_VER || defined(__MINGW32__)
char *cmd;
term_t A1 = Yap_InitSlot(ARG1 PASS_REGS);
term_t A1 = Yap_InitSlot(ARG1);
if ( PL_get_chars(A1, &cmd, CVT_ALL|REP_FN|CVT_EXCEPTION) )
{ STARTUPINFO si;
PROCESS_INFORMATION pi;
@@ -2745,7 +2968,7 @@ p_virtual_alarm( USES_REGS1 )
Yap_Error(INSTANTIATION_ERROR, t, "alarm/2");
return(FALSE);
}
if (!IsIntegerTerm(t)) {
if (!IsIntegerTerm(t)) {
Yap_Error(TYPE_ERROR_INTEGER, t, "alarm/2");
return(FALSE);
}
@@ -2935,11 +3158,7 @@ p_yap_paths( USES_REGS1 ) {
strncat(destdir, "/" YAP_SHAREDIR, YAP_FILENAME_MAX );
out2 = MkAtomTerm(Yap_LookupAtom(destdir));
} else {
#if __ANDROID__
out2 = MkAtomTerm(Yap_LookupAtom("/assets/share/Yap"));
#else
out2 = MkAtomTerm(Yap_LookupAtom(YAP_SHAREDIR));
#endif
}
if (env_destdir) {
strncat(destdir, env_destdir, YAP_FILENAME_MAX );
@@ -2973,9 +3192,7 @@ p_log_event( USES_REGS1 ) {
#endif
if (IsWideAtom(at) || IsBlob(at))
return FALSE;
#if __ANDROID__
__android_log_print(ANDROID_LOG_INFO, "YAP", " %s ",RepAtom(at)->StrOfAE);
#endif
LOG( " %s ",RepAtom(at)->StrOfAE);
return TRUE;
}

73
C/text.c
View File

@@ -89,7 +89,7 @@ get_string_from_list( Term t, seq_tv_t *inp, char *s, int atoms USES_REGS)
int i = RepAtom(at)->WStrOfAE[0];
if (i <= 0) {
LOCAL_Error_TYPE = REPRESENTATION_ERROR_CHARACTER_CODE;
return NULL;
return NULL;
}
*s++ = i;
} else
@@ -105,7 +105,7 @@ get_string_from_list( Term t, seq_tv_t *inp, char *s, int atoms USES_REGS)
Int i = IntOfTerm(HeadOfTerm(t));
if (i <= 0 || i > 255) {
LOCAL_Error_TYPE = REPRESENTATION_ERROR_CHARACTER_CODE;
return NULL;
return NULL;
}
*s++ = i;
if (--max == 0) {
@@ -165,7 +165,7 @@ get_wide_from_list( Term t, seq_tv_t *inp, wchar_t *s, int atoms USES_REGS)
*s++ = code = IntOfTerm(HeadOfTerm(t));
if (code <= 0) {
LOCAL_Error_TYPE = REPRESENTATION_ERROR_CHARACTER_CODE;
return NULL;
return NULL;
}
if (--max == 0) {
*s++ = 0;
@@ -232,7 +232,7 @@ SkipListCodes(Term *l, Term **tailp, Int *atoms, int *wide)
return length;
}
}
l = RepPair(*l)+1;
l = RepPair(*l)+1;
do_derefa(v,l,derefa2_unk,derefa2_nonvar);
} while ( *l != *s && IsPairTerm(*l) );
}
@@ -370,7 +370,7 @@ Yap_ListToBuffer(void *buf, Term t, seq_tv_t *inp, int *widep, size_t *lenp USES
}
}
static yap_error_number
static yap_error_number
gen_type_error(int flags) {
if ((flags & (YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_ATOMS_CODES|YAP_STRING_BIG)) ==
(YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_ATOMS_CODES|YAP_STRING_BIG))
@@ -378,7 +378,7 @@ gen_type_error(int flags) {
if ((flags & (YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG)) ==
(YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG))
return TYPE_ERROR_ATOMIC;
if ((flags & (YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG)) ==
if ((flags & (YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG)) ==
(YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG))
return TYPE_ERROR_NUMBER;
if (flags & YAP_STRING_ATOM )
@@ -403,12 +403,12 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
if (IsVarTerm(inp->val.t)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = inp->val.t;
return 0L;
return 0L;
}
if (!IsStringTerm(inp->val.t)) {
LOCAL_Error_TYPE = TYPE_ERROR_STRING;
LOCAL_Error_Term = inp->val.t;
return 0L;
return 0L;
}
s = StringOfTerm( inp->val.t );
if ( s == NULL ) {
@@ -461,11 +461,11 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
if (IsVarTerm(inp->val.t)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = inp->val.t;
return 0L;
return 0L;
} else if (!IsAtomTerm(inp->val.t)) {
LOCAL_Error_TYPE = TYPE_ERROR_ATOM;
LOCAL_Error_Term = inp->val.t;
return NULL;
return NULL;
} else {
Atom at = AtomOfTerm(inp->val.t);
if (IsWideAtom(at)) {
@@ -527,7 +527,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
*lengp = wcslen(inp->val.w);
return (void *)inp->val.w;
case YAP_STRING_LITERAL:
{
{
yhandle_t CurSlot = Yap_StartSlots( );
if (buf) s = buf;
else s = Yap_PreAllocCodeSpace();
@@ -537,7 +537,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
CurSlot = Yap_StartSlots();
fd = Sopenmem(&s, &sz, "w");
fd->encoding = ENC_UTF8;
if ( ! PL_write_term(fd, Yap_InitSlot(inp->val.t PASS_REGS), 1200, 0) ||
if ( ! PL_write_term(fd, Yap_InitSlot(inp->val.t), 1200, 0) ||
Sputcode(EOS, fd) < 0 ||
Sflush(fd) < 0 ) {
AUX_ERROR( inp->val.t, LOCAL_MAX_SIZE, s, char);
@@ -563,7 +563,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
} else {
LOCAL_Error_TYPE = gen_type_error( inp->type );
LOCAL_Error_Term = t;
}
}
} else if (IsPairTerm(t) ) {
if (inp->type & (YAP_STRING_CODES|YAP_STRING_ATOMS)) {
inp->type &= (YAP_STRING_CODES|YAP_STRING_ATOMS);
@@ -584,7 +584,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
} else {
LOCAL_Error_TYPE = gen_type_error( inp->type );
LOCAL_Error_Term = t;
}
}
} else if (IsIntegerTerm(t)) {
if (inp->type & (YAP_STRING_INT)) {
inp->type &= (YAP_STRING_INT);
@@ -593,7 +593,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
} else {
LOCAL_Error_TYPE = gen_type_error( inp->type );
LOCAL_Error_Term = t;
}
}
} else if (IsFloatTerm(t)) {
if (inp->type & (YAP_STRING_FLOAT)) {
inp->type &= (YAP_STRING_FLOAT);
@@ -602,7 +602,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
} else {
LOCAL_Error_TYPE = gen_type_error( inp->type );
LOCAL_Error_Term = t;
}
}
#if USE_GMP
} else if (IsBigIntTerm(t)) {
if (inp->type & (YAP_STRING_BIG)) {
@@ -612,7 +612,7 @@ read_Text( void *buf, seq_tv_t *inp, encoding_t *enc, int *minimal, size_t *leng
} else {
LOCAL_Error_TYPE = gen_type_error( inp->type );
LOCAL_Error_Term = t;
}
}
#endif
} else {
if (!Yap_IsGroundTerm(t)) {
@@ -652,7 +652,7 @@ write_strings( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng
max++;
buf = utf8_put_char(buf, '\0');
}
close_tstring( buf PASS_REGS );
out->val.t = t;
}
@@ -730,7 +730,7 @@ write_atoms( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng U
int chr;
CELL *cl;
cp = utf8_get_char(cp, &chr);
if (chr == '\0') break;
if (chr == '\0') break;
w[0] = chr;
cl = HR;
HR += 2;
@@ -787,7 +787,7 @@ write_atoms( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng U
} else {
if (sz == 0) t = TermNil;
else HR[-1] = TermNil;
}
}
out->val.t = t;
return (t);
}
@@ -864,7 +864,7 @@ write_codes( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng U
} else {
if (sz == 0) t = TermNil;
else HR[-1] = TermNil;
}
}
out->val.t = t;
return (t);
}
@@ -877,7 +877,7 @@ write_atom( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng US
if (out->type & (YAP_STRING_NCHARS|YAP_STRING_TRUNC)) {
if (out->type & YAP_STRING_TRUNC && out->max < max) max = out->max;
}
switch (enc) {
case YAP_UTF8:
{ char *s = s0, *lim = s + strnlen(s, max);
@@ -921,7 +921,7 @@ static ssize_t
write_length( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng USES_REGS)
{
size_t max = -1;
if (out->type & (YAP_STRING_NCHARS|YAP_STRING_TRUNC)) {
if (out->type & YAP_STRING_NCHARS && out->sz != (size_t)-1) return out->sz;
if (out->type & YAP_STRING_TRUNC) max = out->max;
@@ -955,7 +955,7 @@ write_number( void *s0, seq_tv_t *out, encoding_t enc, int minimal, int size USE
char *s = s0;
Term t = 0L;
if ( (st=Sopenmem( &s, NULL, "r")) != NULL )
{
{
if (enc == YAP_UTF8)
st->encoding = ENC_UTF8;
else if (enc == YAP_WCHAR)
@@ -1005,7 +1005,7 @@ write_term( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng US
size_t len = out->sz;
Term t = 0L;
if ( (st=Sopenmem( s0, &len, "r")) )
{
{
if (enc == YAP_UTF8)
st->encoding = ENC_UTF8;
else if (enc == YAP_WCHAR)
@@ -1030,7 +1030,7 @@ write_Text( void *inp, seq_tv_t *out, encoding_t enc, int minimal, size_t leng U
case YAP_STRING_ATOMS:
out->val.t =
write_atoms( inp, out, enc, minimal, leng PASS_REGS);
return out->val.t != 0;
return out->val.t != 0;
case YAP_STRING_CODES:
out->val.t =
write_codes( inp, out, enc, minimal, leng PASS_REGS);
@@ -1042,13 +1042,13 @@ write_Text( void *inp, seq_tv_t *out, encoding_t enc, int minimal, size_t leng U
case YAP_STRING_ATOM:
out->val.a =
write_atom( inp, out, enc, minimal, leng PASS_REGS);
return out->val.a != NULL;
return out->val.a != NULL;
case YAP_STRING_INT:
case YAP_STRING_FLOAT:
case YAP_STRING_BIG:
out->val.t =
write_number( inp, out, enc, minimal, leng PASS_REGS);
return out->val.t != 0;
return out->val.t != 0;
case YAP_STRING_CHARS:
out->val.c = inp;
return 1;
@@ -1163,14 +1163,14 @@ cmp_Text( void *s1, void *s2, int l, encoding_t enc1, encoding_t enc2 )
char *w2 = s2;
for (i = 0; i < l; i++) { chr2 = *w2++; w1 = utf8_get_char(w1, &chr1); if (chr1-chr2) return chr1-chr2; }
}
return 0;
return 0;
case YAP_UTF8:
{
int chr1, chr2;
char *w2 = s2;
for (i = 0; i < l; i++) { w2 = utf8_get_char(w2, &chr2); w1 = utf8_get_char(w1, &chr1); if (chr1-chr2) return chr1-chr2; }
}
return 0;
return 0;
case YAP_WCHAR:
{
int chr1, chr2;
@@ -1179,7 +1179,7 @@ cmp_Text( void *s1, void *s2, int l, encoding_t enc1, encoding_t enc2 )
}
return 0;
}
}
}
case YAP_WCHAR:
{
wchar_t *w1 = (wchar_t *)s1;
@@ -1330,7 +1330,7 @@ slice( size_t min, size_t max, void *buf, seq_tv_t *out, encoding_t enc USES_REG
} else if (enc == YAP_CHAR) {
/* atom */
char *nbuf = (char *)HR;
if (max>min) {
Term t = TermNil;
char *ptr = (char *)buf + min;
@@ -1377,7 +1377,7 @@ Yap_Concat_Text( int n, seq_tv_t inp[], seq_tv_t *out USES_REGS)
buf = NULL;
for (i = 0 ; i < n ; i++) {
void *nbuf = read_Text( buf, inp+i, encv+i, &minimal, &leng PASS_REGS );
if (!nbuf)
return 0L;
bufv[i] = nbuf;
@@ -1391,8 +1391,8 @@ Yap_Concat_Text( int n, seq_tv_t inp[], seq_tv_t *out USES_REGS)
return buf;
}
//
// out must be an atom or a string
//
// out must be an atom or a string
void *
Yap_Splice_Text( int n, size_t cuts[], seq_tv_t *inp, encoding_t encv[], seq_tv_t outv[] USES_REGS)
{
@@ -1442,7 +1442,7 @@ Yap_Splice_Text( int n, size_t cuts[], seq_tv_t *inp, encoding_t encv[], seq_tv
return NULL;
l1 = write_length( buf1, outv+1, enc1, minimal1, leng1 PASS_REGS);
if (l < l1) return NULL;
l0 = l-l1;
l0 = l-l1;
if (cmp_Text( advance_Text(buf, l0, enc), buf1, l1, enc, enc1) != 0)
return NULL;
buf0 = slice(0, l0, buf, outv, enc PASS_REGS);
@@ -1463,4 +1463,3 @@ Yap_Splice_Text( int n, size_t cuts[], seq_tv_t *inp, encoding_t encv[], seq_tv
}
return (void *)outv;;
}

14
C/tracer.c
View File

@@ -144,6 +144,20 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
Int arity;
/* extern int gc_calls; */
vsc_count++;
#if __ANDROID__
PredEntry *ap = pred;
if (pred && port == enter_pred) {
UInt flags = ap->PredFlags;
if (ap->ArityOfPE && ap->ModuleOfPred != IDB_MODULE)
__android_log_print(ANDROID_LOG_INFO, "YAP ", " %s/%ld %lx\n", NameOfFunctor(ap->FunctorOfPred)->StrOfAE, ap->ArityOfPE, flags);
/* printf(" %s/%ld %lx\n", NameOfFunctor(ap->FunctorOfPred)->StrOfAE, ap->ArityOfPE, flags); */
else if (ap->ModuleOfPred != IDB_MODULE)
__android_log_print(ANDROID_LOG_INFO, "YAP "," %s/%ld %lx\n", ((Atom)(ap->FunctorOfPred))->StrOfAE, ap->ArityOfPE, flags);
/* printf(" %s/%ld %lx\n", ((Atom)(ap->FunctorOfPred))->StrOfAE, ap->ArityOfPE, flags); */
__android_log_print(ANDROID_LOG_INFO, "YAP "," %x ", ap->src.OwnerFile);
}
return;
#endif
// if (!worker_id) return;
LOCK(Yap_heap_regs->low_level_trace_lock);

6
C/write.c
View File

@@ -694,8 +694,8 @@ static Term from_pointer(CELL *ptr0, struct rewind_term *rwt,
if (wglb->Keep_terms) {
struct rewind_term *x = rwt->parent;
rwt->u_sd.s.old = Yap_InitSlot(t PASS_REGS);
rwt->u_sd.s.ptr = Yap_InitSlot((CELL)ptr0 PASS_REGS);
rwt->u_sd.s.old = Yap_InitSlot(t);
rwt->u_sd.s.ptr = Yap_InitSlot((CELL)ptr0);
if (!IsAtomicTerm(t) && !IsVarTerm(t)) {
while (x) {
@@ -785,7 +785,7 @@ static Term check_infinite_loop(Term t, struct rewind_term *x,
CACHE_REGS
if (wglb->Keep_terms) {
while (x) {
if (Yap_GetFromSlot(x->u_sd.s.old PASS_REGS) == t)
if (Yap_GetFromSlot(x->u_sd.s.old) == t)
return TermFoundVar;
x = x->parent;
}

5
C/yap-args.c
View File

@@ -167,11 +167,7 @@ int
YAP_parse_yap_arguments(int argc, char *argv[], YAP_init_args *iap)
{
char *p;
#ifdef USE_SYSTEM_MALLOC
int BootMode = YAP_FULL_BOOT_FROM_PROLOG;
#else
int BootMode = YAP_BOOT_FROM_SAVED_CODE;
#endif
unsigned long int *ssize;
iap->SavedState = NULL;
@@ -554,5 +550,6 @@ YAP_parse_yap_arguments(int argc, char *argv[], YAP_init_args *iap)
}
GD->cmdline.appl_argc = argc;
GD->cmdline.appl_argv = argv;
//___androidlog_print(ANDROID_LOG_INFO, "YAP ", "boot mode %d", BootMode);
return BootMode;
}