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

Memory management and UTF-8 for all fixes

This commit is contained in:
Vitor Santos Costa 2016-11-04 11:36:48 -05:00
parent 02e0e50915
commit 46a9d52d2d
26 changed files with 526 additions and 483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
C/adtdefs.c
View File

@ -57,10 +57,15 @@ GetFunctorProp(AtomEntry *ae,
arity_t arity) { /* look property list of atom a for kind */
FunctorEntry *pp;
pp = RepFunctorProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && (pp = RepFunctorProp(pp->NextOfPE)))
;
return (AbsFunctorProp(pp));
PropEntry *p = RepFunctorProp(ae->PropsOfAE);
while (p != NIL) {
if (p->KindOfPE == FunctorProperty &&
RepFunctorProp(p)->ArityOfFE == arity) {
return p;
}
p = p->NextOfPE;
}
return NIL;
}
/* vsc: We must guarantee that IsVarTerm(functor) returns true! */
@ -155,7 +160,6 @@ LookupAtom(const unsigned char *atom) { /* lookup atom in atom table */
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;
@ -199,6 +203,7 @@ LookupAtom(const unsigned char *atom) { /* lookup atom in atom table */
if (NOfAtoms > 2 * AtomHashTableSize) {
Yap_signal(YAP_CDOVF_SIGNAL);
}
return na;
}

10
C/alloc.c
View File

@ -77,7 +77,7 @@ void *my_malloc(size_t sz) {
p = malloc(sz);
// Yap_DebugPuts(stderr,"gof\n");
if (Yap_do_low_level_trace||1)
if (Yap_do_low_level_trace)
fprintf(stderr, "+ %p : %lu\n", p, sz);
if (sz > 500 && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "+ %d %p", write_malloc,
@ -89,8 +89,8 @@ void *my_realloc(void *ptr, size_t sz) {
void *p;
p = realloc(ptr, sz);
if (Yap_do_low_level_trace||1)
fprintf(stderr, "+ %p -> %p : %lu\n", ptr, p, sz);
if (Yap_do_low_level_trace)
// fprintf(stderr, "+ %p -> %p : %lu\n", ptr, p, sz);
// Yap_DebugPuts(stderr,"gof\n");
if (sz > 500 && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "* %d %p", write_malloc,
@ -100,7 +100,7 @@ void *my_realloc(void *ptr, size_t sz) {
void my_free(void *p) {
// printf("f %p\n",p);
if (Yap_do_low_level_trace||1)
if (Yap_do_low_level_trace)
fprintf(stderr, "+ %p\n", p);
if (write_malloc && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "- %d %p", write_malloc,
@ -671,7 +671,7 @@ static char *AllocHeap(size_t size) {
LOCK(FreeBlocksLock);
if ((b = GetBlock(size))) {
if (b->b_size >= size + 24 + 1) {
n = (BlockHeader *)(((YAP_SEG_SIZE *)b) + size + 1);
n = (BlockHeader *)(((YAP_SEG_SIZE *)b) + size + 1)v;
n->b_size = b->b_size - size - 1;
b->b_size = size;
AddToFreeList(n);

611
C/atomic.c
View File

File diff suppressed because it is too large Load Diff

33
C/cmppreds.c
View File

@ -63,6 +63,8 @@ static char SccsId[] = "%W% %G%";
#endif
#include <wchar.h>
#include "YapError.h"
static Int compare(Term, Term);
static Int p_compare(USES_REGS1);
static Int p_acomp(USES_REGS1);
@ -378,9 +380,11 @@ inline static Int compare(Term t1, Term t2) /* compare terms t1 and t2 */
return 1;
else {
int out;
if (!(out = 2 - ArityOfFunctor(f)))
out = strcmp(".", (char *)RepAtom(NameOfFunctor(f))->StrOfAE);
return (out);
if (f != FunctorDot)
return strcmp(".", RepAtom(NameOfFunctor(f))->StrOfAE);
else {
return compare_complex(RepPair(t1) - 1, RepPair(t1) + 1, RepAppl(t2) );
}
}
}
if (IsPairTerm(t2)) {
@ -590,14 +594,12 @@ inline static Int flt_cmp(Float dif) {
return dif = 0.0;
}
static inline Int a_cmp(Term t1, Term t2 USES_REGS) {
static Int a_cmp(Term t1, Term t2 USES_REGS) {
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "=:=/2");
return FALSE;
Yap_ThrowError( INSTANTIATION_ERROR, t1, "while doing arithmetic comparison" );
}
if (IsVarTerm(t2)) {
Yap_Error(INSTANTIATION_ERROR, t2, "=:=/2");
return FALSE;
Yap_ThrowError( INSTANTIATION_ERROR, t1, "while doing arithmetic comparison" );
}
if (IsFloatTerm(t1) && IsFloatTerm(t2)) {
return flt_cmp(FloatOfTerm(t1) - FloatOfTerm(t2));
@ -620,8 +622,7 @@ static inline Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_ErrorMessage = "trying to evaluate nan";
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, "trying to evaluate nan" );
}
#endif
return flt_cmp(i1 - f2);
@ -636,8 +637,7 @@ static inline Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f1 = FloatOfTerm(t1);
#if HAVE_ISNAN
if (isnan(f1)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_ErrorMessage = "trying to evaluate nan";
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t1, "trying to evaluate nan" );
}
#endif
t2 = Yap_Eval(t2);
@ -653,9 +653,8 @@ static inline Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_ErrorMessage = "trying to evaluate nan";
}
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, "trying to evaluate nan" );
}
#endif
return flt_cmp(f1 - f2);
#ifdef USE_GMP
@ -676,8 +675,7 @@ static inline Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_ErrorMessage = "trying to evaluate nan";
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, "trying to evaluate nan" );
}
#endif
return Yap_gmp_cmp_big_float(t1, f2);
@ -744,7 +742,6 @@ static Int a_eq(Term t1, Term t2) {
}
}
out = a_cmp(t1, t2 PASS_REGS);
Yap_Error(LOCAL_Error_TYPE, t1, LOCAL_ErrorMessage);
return out == 0;
}

16
C/compiler.c
View File

@ -1080,10 +1080,8 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
} else {
char s[32];
LOCAL_Error_TYPE = TYPE_ERROR_NUMBER;
Yap_bip_name(Op, s);
sprintf(LOCAL_ErrorMessage, "compiling %s/2 with output bound", s);
Yap_ThrowError( TYPE_ERROR_NUMBER, t2, "compiling %s/2 with output bound", s);
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1094,9 +1092,8 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
if (IsNewVar(t2)) {
char s[32];
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
Yap_bip_name(Op, s);
sprintf(LOCAL_ErrorMessage, "compiling %s/3", s);
Yap_ThrowError(INSTANTIATION_ERROR , t2, "compiling %s/3", s);
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1107,10 +1104,7 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
if (!IsIntegerTerm(t2)) {
char s[32];
LOCAL_Error_TYPE = TYPE_ERROR_INTEGER;
Yap_bip_name(Op, s);
sprintf(LOCAL_ErrorMessage, "compiling functor/3");
Yap_ThrowError( TYPE_ERROR_INTEGER, t2, "compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1118,9 +1112,7 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
if (i2 < 0) {
char s[32];
LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO;
Yap_bip_name(Op, s);
sprintf(LOCAL_ErrorMessage, "compiling functor/3");
Yap_ThrowError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO , t2, "compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}

21
C/errors.c
View File

@ -310,6 +310,27 @@ yap_error_descriptor_t *Yap_popErrorContext(void) {
return new_error;
}
void Yap_ThrowError__(const char *file, const char *function, int lineno,
yap_error_number type, Term where, ...) {
va_list ap;
char tmpbuf[MAXPATHLEN];
va_start(ap, where);
char *format = va_arg(ap, char *);
if (format != NULL) {
#if HAVE_VSNPRINTF
(void)vsnprintf(tmpbuf, MAXPATHLEN - 1, format, ap);
#else
(void)vsprintf(tnpbuf, format, ap);
#endif
// fprintf(stderr, "warning: ");
Yap_Error__(file, function, lineno, type, where, tmpbuf);
} else {
Yap_Error__(file, function, lineno, type, where);
}
siglongjmp(LOCAL_RestartEnv, 2);
}
/**
* @brief Yap_Error
* This function handles errors in the C code. Check errors.yap for the

1
C/exec.c
View File

@ -2229,6 +2229,7 @@ bool Yap_ResetException(int wid) {
Yap_PopTermFromDB(REMOTE_ActiveError(wid)->errorTerm);
}
REMOTE_ActiveError(wid)->errorTerm = NULL;
REMOTE_ActiveError(wid)->errorTerm = NULL;
return true;
}

2
C/grow.c
View File

@ -749,9 +749,7 @@ AdjustScannerStacks(TokEntry **tksp, VarEntry **vep USES_REGS)
break;
case Var_tok:
case String_tok:
case WString_tok:
case BQString_tok:
case WBQString_tok:
if (IsOldTrail(tks->TokInfo))
tks->TokInfo = TrailAdjust(tks->TokInfo);
break;

100
C/parser.c
View File

@ -173,12 +173,15 @@ const char *Yap_tokRep(void *tokptr, encoding_t enc);
static void syntax_msg(const char *msg, ...) {
CACHE_REGS
va_list ap;
if (LOCAL_toktide == LOCAL_tokptr) {
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE + 1);
if (!LOCAL_ErrorMessage ||
(LOCAL_Error_TYPE == SYNTAX_ERROR &&
LOCAL_ActiveError->prologParserLine < LOCAL_tokptr->TokPos)) {
if (!LOCAL_ErrorMessage) {
LOCAL_ErrorMessage = malloc(1024 + 1);
}
LOCAL_ActiveError->prologParserLine = LOCAL_tokptr->TokPos;
va_start(ap, msg);
vsnprintf(LOCAL_ErrorMessage, YAP_FILENAME_MAX, msg, ap);
LOCAL_Error_TYPE = SYNTAX_ERROR;
vsnprintf(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE, msg, ap);
va_end(ap);
}
}
@ -224,22 +227,18 @@ static void syntax_msg(const char *msg, ...) {
#define FAIL siglongjmp(FailBuff->JmpBuff, 1)
VarEntry *
Yap_LookupVar(const char *var) /* lookup variable in variables table
* */
VarEntry *Yap_LookupVar(const char *var) /* lookup variable in variables table
* */
{
CACHE_REGS
VarEntry *p;
int32_t ch;
const unsigned char *v1 = var;
Atom vat = Yap_LookupAtom(var);
#if DEBUG
if (GLOBAL_Option[4])
fprintf(stderr, "[LookupVar %s]", var);
#endif
v1 = v1 + get_utf8(v1, 1, &ch);
if (ch != '_' || v1[0] != '\0') {
if (var[0] != '_' || var[1] != '\0') {
VarEntry **op = &LOCAL_VarTable;
UInt hv;
@ -249,7 +248,7 @@ Yap_LookupVar(const char *var) /* lookup variable in variables table
CELL hpv = p->hv;
if (hv == hpv) {
Int scmp;
if ((scmp = strcmp(var, p->VarRep)) == 0) {
if ((scmp = strcmp(var, RepAtom(p->VarRep)->StrOfAE)) == 0) {
p->refs++;
return (p);
} else if (scmp < 0) {
@ -267,22 +266,21 @@ Yap_LookupVar(const char *var) /* lookup variable in variables table
p = p->VarRight;
}
}
p = (VarEntry *)Yap_AllocScannerMemory(strlen(var) + 1+ sizeof(VarEntry));
p = (VarEntry *)Yap_AllocScannerMemory(sizeof(VarEntry));
*op = p;
p->VarLeft = p->VarRight = NULL;
p->hv = hv;
p->refs = 1L;
strcpy(p->VarRep, var);
p->VarRep = vat;
} else {
/* anon var */
p = (VarEntry *)Yap_AllocScannerMemory(sizeof(VarEntry) + 3);
p = (VarEntry *)Yap_AllocScannerMemory(sizeof(VarEntry));
p->VarLeft = LOCAL_AnonVarTable;
LOCAL_AnonVarTable = p;
p->VarRight = NULL;
p->refs = 0L;
p->hv = 1L;
p->VarRep[0] = '_';
p->VarRep[1] = '\0';
p->VarRep = vat;
}
p->VarAdr = TermNil;
return (p);
@ -290,11 +288,11 @@ Yap_LookupVar(const char *var) /* lookup variable in variables table
static Term VarNames(VarEntry *p, Term l USES_REGS) {
if (p != NULL) {
if (strcmp(p->VarRep, "_") != 0) {
if (strcmp(RepAtom(p->VarRep)->StrOfAE, "_") != 0) {
Term t[2];
Term o;
t[0] = MkAtomTerm(Yap_LookupAtom(p->VarRep));
t[0] = MkAtomTerm(p->VarRep);
if (!IsVarTerm(p->VarAdr))
p->VarAdr = MkVarTerm();
t[1] = p->VarAdr;
@ -321,11 +319,11 @@ Term Yap_VarNames(VarEntry *p, Term l) {
static Term Singletons(VarEntry *p, Term l USES_REGS) {
if (p != NULL) {
if (p->VarRep[0] != '_' && p->refs == 1) {
if (RepAtom(p->VarRep)->StrOfAE[0] != '_' && p->refs == 1) {
Term t[2];
Term o;
t[0] = MkAtomTerm(Yap_LookupAtom(p->VarRep));
t[0] = MkAtomTerm(p->VarRep);
t[1] = p->VarAdr;
o = Yap_MkApplTerm(FunctorEq, 2, t);
o = MkPairTerm(o,
@ -404,10 +402,10 @@ static int IsInfixOp(Atom op, int *pptr, int *lpptr, int *rpptr,
OpEntry *opp = Yap_GetOpProp(op, INFIX_OP, cmod PASS_REGS);
if (!opp)
return FALSE;
return false;
if (opp->OpModule && opp->OpModule != cmod) {
READ_UNLOCK(opp->OpRWLock);
return FALSE;
return false;
}
if ((p = opp->Infix) != 0) {
READ_UNLOCK(opp->OpRWLock);
@ -614,7 +612,8 @@ static Term ParseArgs(Atom a, Term close, JMPBUFF *FailBuff, Term arg1,
}
static Term MakeAccessor(Term t, Functor f USES_REGS) {
UInt arity = ArityOfFunctor(FunctorOfTerm(t)), i;
UInt arity = ArityOfFunctor(FunctorOfTerm(t));
int i;
Term tf[2], tl = TermNil;
tf[1] = ArgOfTerm(1, t);
@ -791,7 +790,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
case '{':
NextToken;
if (LOCAL_tokptr->Tok == Ponctuation_tok &&
(int)LOCAL_tokptr->TokInfo == TermEndSquareBracket) {
(int)LOCAL_tokptr->TokInfo == TermEndCurlyBracket) {
t = MkAtomTerm(AtomBraces);
NextToken;
break;
@ -803,7 +802,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
syntax_msg("line %d: Stack Overflow", LOCAL_tokptr->TokPos);
FAIL;
}
checkfor(TermEndSquareBracket, FailBuff, enc PASS_REGS);
checkfor(TermEndCurlyBracket, FailBuff, enc PASS_REGS);
break;
default:
syntax_msg("line %d: unexpected ponctuation signal %s",
@ -905,15 +904,16 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
/* main loop to parse infix and posfix operators starts here */
while (true) {
Atom name;
if (LOCAL_tokptr->Tok == Ord(Name_tok) &&
Yap_HasOp(AtomOfTerm(LOCAL_tokptr->TokInfo))) {
Atom save_opinfo = opinfo = AtomOfTerm(LOCAL_tokptr->TokInfo);
Yap_HasOp((name = AtomOfTerm(LOCAL_tokptr->TokInfo)))) {
Atom save_opinfo = opinfo = name;
if (IsInfixOp(save_opinfo, &opprio, &oplprio, &oprprio, cmod PASS_REGS) &&
opprio <= prio && oplprio >= curprio) {
/* try parsing as infix operator */
Volatile int oldprio = curprio;
TRY3(
func = Yap_MkFunctor(AtomOfTerm(LOCAL_tokptr->TokInfo), 2);
func = Yap_MkFunctor(save_opinfo, 2);
if (func == NULL) {
syntax_msg("line %d: Heap Overflow", LOCAL_tokptr->TokPos);
FAIL;
@ -954,7 +954,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
break;
}
if (LOCAL_tokptr->Tok == Ord(Ponctuation_tok)) {
if (LOCAL_tokptr->TokInfo == TermDot && prio >= 1000 && curprio <= 999) {
if (LOCAL_tokptr->TokInfo == TermComma && prio >= 1000 && curprio <= 999) {
Volatile Term args[2];
NextToken;
args[0] = t;
@ -1001,17 +1001,17 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
curprio = opprio;
continue;
} else if (LOCAL_tokptr->TokInfo == TermBeginCurlyBracket &&
IsPosfixOp(AtomEmptyCurlyBrackets, &opprio, &oplprio,
IsPosfixOp(AtomBraces, &opprio, &oplprio,
cmod PASS_REGS) &&
opprio <= prio && oplprio >= curprio) {
t = ParseArgs(AtomEmptyCurlyBrackets, TermEndCurlyBracket, FailBuff, t,
t = ParseArgs(AtomBraces, TermEndCurlyBracket, FailBuff, t,
enc, cmod PASS_REGS);
t = MakeAccessor(t, FunctorEmptyCurlyBrackets PASS_REGS);
t = MakeAccessor(t, FunctorBraces PASS_REGS);
curprio = opprio;
continue;
}
}
if (LOCAL_tokptr->Tok <= Ord(WString_tok)) {
if (LOCAL_tokptr->Tok <= Ord(String_tok)) {
syntax_msg("line %d: expected operator, got \'%s\'", LOCAL_tokptr->TokPos,
Yap_tokRep(LOCAL_tokptr, enc));
FAIL;
@ -1026,6 +1026,7 @@ Term Yap_Parse(UInt prio, encoding_t enc, Term cmod) {
Volatile Term t;
JMPBUFF FailBuff;
yhandle_t sls = Yap_StartSlots();
LOCAL_toktide = LOCAL_tokptr;
if (!sigsetjmp(FailBuff.JmpBuff, 0)) {
@ -1042,22 +1043,19 @@ Term Yap_Parse(UInt prio, encoding_t enc, Term cmod) {
}
#endif
Yap_CloseSlots(sls);
if (LOCAL_tokptr != NULL && LOCAL_tokptr->Tok != Ord(eot_tok)) {
LOCAL_Error_TYPE = SYNTAX_ERROR;
LOCAL_ErrorMessage = "term does not end on . ";
t = 0;
}
if (t != 0 && LOCAL_Error_TYPE == SYNTAX_ERROR) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
LOCAL_ErrorMessage = NULL;
}
// if (LOCAL_tokptr->Tok != Ord(eot_tok))
// return (0L);
return t;
}
Yap_CloseSlots(sls);
return (0);
if (LOCAL_tokptr != NULL && LOCAL_tokptr->Tok != Ord(eot_tok)) {
LOCAL_Error_TYPE = SYNTAX_ERROR;
LOCAL_ErrorMessage = "term does not end on . ";
t = 0;
}
if (t != 0 && LOCAL_Error_TYPE == SYNTAX_ERROR) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
LOCAL_ErrorMessage = NULL;
}
// if (LOCAL_tokptr->Tok != Ord(eot_tok))
// return (0L);
return t;
}
//! @}

17
C/scanner.c
View File

@ -1202,7 +1202,8 @@ Term Yap_scan_num(StreamDesc *inp) {
ef->TokNext = NULL;
LOCAL_tokptr = tokptr;
LOCAL_toktide = e;
LOCAL_ErrorMessage = Yap_syntax_error(e, inp - GLOBAL_Stream);
Yap_JumpToEnv(
Yap_syntax_error(e, inp - GLOBAL_Stream) );
LOCAL_Error_TYPE = SYNTAX_ERROR;
}
}
@ -1237,21 +1238,18 @@ const char *Yap_tokRep(void *tokptre, encoding_t encoding) {
case Ponctuation_tok:
case String_tok:
case BQString_tok:
case WString_tok:
case WBQString_tok: {
return Yap_TermToString(info, &length, encoding, flags);
}
case Var_tok: {
case Var_tok:
{
VarEntry *varinfo = (VarEntry *)info;
varinfo->VarAdr = TermNil;
return varinfo->VarRep;
return RepAtom(varinfo->VarRep)->StrOfAE;
}
case Error_tok:
return "<ERR>";
case eot_tok:
return "<EOT>";
case QuasiQuotes_tok:
case WQuasiQuotes_tok:
return "<QQ>";
}
}
@ -1445,7 +1443,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
}
t->Tok = Ord(kind = Var_tok);
}
} break;
case NU: {
@ -1923,7 +1921,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
qq->end.byteno = fseek(inp_stream->file, 0, 0);
} else {
qq->end.byteno = inp_stream->charcount - 1;
}
}
qq->end.lineno = inp_stream->linecount;
qq->end.linepos = inp_stream->linepos - 1;
qq->end.charno = inp_stream->charcount - 1;
@ -1977,7 +1975,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
return (l);
}
int vsc_count;
void Yap_clean_tokenizer(TokEntry *tokstart, VarEntry *vartable,
VarEntry *anonvartable) {

54
C/text.c
View File

@ -52,19 +52,16 @@ typedef struct TextBuffer_manager {
} text_buffer_t;
int push_text_stack(USES_REGS1) {
printf("push %d\n", LOCAL_TextBuffer->lvl);
return LOCAL_TextBuffer->lvl++;
}
int pop_text_stack(int i) {
printf("pop %d\n", i);
int lvl = LOCAL_TextBuffer->lvl;
while (lvl > i) {
struct mblock *p = LOCAL_TextBuffer->first[lvl];
while (p) {
struct mblock *np = p->next;
free(p);
printf("----------> %p free\n", p);
p = np;
}
LOCAL_TextBuffer->first[lvl] = NULL;
@ -95,7 +92,6 @@ void *Malloc(size_t sz USES_REGS) {
o->next = NULL;
o->sz = sz;
o->lvl = lvl;
printf("%p malloc %d\n", o, sz);
return o + 1;
}
@ -115,7 +111,6 @@ void *Realloc(void *pt, size_t sz USES_REGS) {
if (LOCAL_TextBuffer->last[lvl] == old) {
LOCAL_TextBuffer->last[lvl] = o;
}
printf("%p realloc %ld\n", o, sz);
return o + 1;
}
@ -136,7 +131,6 @@ void Free(void *pt USES_REGS) {
LOCAL_TextBuffer->last[lvl] = o->prev;
}
free(o);
printf("%p free\n", o);
}
void *Yap_InitTextAllocator(void) {
@ -392,7 +386,7 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
Atom at = AtomOfTerm(inp->val.t);
inp->val.uc = at->UStrOfAE;
return at->UStrOfAE;
}
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
// this is a term, extract to a buffer, and representation is wide
@ -636,7 +630,7 @@ static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
unsigned char *s = s0;
int32_t ch;
if (strlen_utf8(s0) <= leng) {
if (!leng || strlen_utf8(s0) <= leng) {
return Yap_LookupAtom(s0);
} else {
size_t n = get_utf8(s, 1, &ch);
@ -729,15 +723,17 @@ static Term write_number(unsigned char *s, seq_tv_t *out, int size USES_REGS) {
static Term string_to_term(void *s, seq_tv_t *out, size_t leng USES_REGS) {
Term o;
int i = push_text_stack();
o = out->val.t =
Yap_StringToTerm(s, strlen(s) + 1, &out->enc, GLOBAL_MaxPriority, NULL);
pop_text_stack(i);
return o;
}
bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
/* we know what the term is */
if (out->type == 0) {
return true;
}
if (out->type & YAP_STRING_TERM) {
if ((out->val.t = string_to_term(inp, out, leng PASS_REGS)) != 0L)
return out->val.t != 0;
@ -753,7 +749,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
return false;
}
if (out->type & (YAP_STRING_ATOM)) {
if (write_atom(inp, out, leng PASS_REGS) != NIL) {
if ((out->val.a = write_atom(inp, out, leng PASS_REGS)) != NIL) {
Atom at = out->val.a;
if (at && (out->type & YAP_STRING_OUTPUT_TERM))
out->val.t = MkAtomTerm(at);
@ -797,7 +793,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
out->val.t = write_number(inp, out, leng PASS_REGS);
// Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0;
default: {}
default: { return true ; }
}
return false;
}
@ -833,7 +829,6 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
bool rc;
size_t leng;
int l = push_text_stack(PASS_REGS1);
/*
f//printfmark(stderr, "[ %d ", n++) ;
if (inp->type & (YAP_STRING_TERM|YAP_STRING_ATOM|YAP_STRING_ATOMS_CODES
@ -858,26 +853,22 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
}
if (!buf) {
pop_text_stack( l);
return 0L;
}
if (out->type & (YAP_STRING_UPCASE | YAP_STRING_DOWNCASE)) {
if (out->type & YAP_STRING_UPCASE) {
if (!upcase(buf, out)) {
pop_text_stack( l);
return false;
}
}
if (out->type & YAP_STRING_DOWNCASE) {
if (!downcase(buf, out)) {
pop_text_stack( l);
return false;
}
}
}
rc = write_Text(buf, out, leng PASS_REGS);
pop_text_stack(l);
/* fprintf(stderr, " -> ");
if (!rc) fprintf(stderr, "NULL");
else if (out->type &
@ -919,9 +910,7 @@ static unsigned char *concat(int n, unsigned char *sv[] USES_REGS) {
buf = Malloc(room + 1);
buf0 = (unsigned char *)buf;
for (i = 0; i < n; i++) {
char *s = (char *)sv[i];
buf = strcpy(buf, s);
buf += strlen(s);
buf = stpcpy(buf, sv[i]);
}
return buf0;
}
@ -945,12 +934,11 @@ static void *slice(size_t min, size_t max, unsigned char *buf USES_REGS) {
bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
unsigned char **bufv;
unsigned char *buf;
size_t leng;
int i;
int l = push_text_stack(PASS_REGS1);
size_t leng;
bufv = Malloc(tot * sizeof(unsigned char *));
if (!bufv) {
pop_text_stack( l);
return NULL;
}
for (i = 0; i < tot; i++) {
@ -958,14 +946,12 @@ bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
unsigned char *nbuf = Yap_readText(inp + i, &leng PASS_REGS);
if (!nbuf) {
pop_text_stack( l);
return NULL;
}
bufv[i] = nbuf;
}
buf = concat(tot, bufv PASS_REGS);
bool rc = write_Text(buf, out, leng PASS_REGS);
pop_text_stack(l);
bool rc = write_Text(buf, out, 0 PASS_REGS);
return rc;
}
@ -973,14 +959,11 @@ bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
seq_tv_t outv[] USES_REGS) {
unsigned char *buf;
int lvl = push_text_stack(PASS_REGS1);
size_t l;
inp->type |= YAP_STRING_IN_TMP;
buf = Yap_readText(inp, &l PASS_REGS);
if (!buf) {
pop_text_stack( l);
return false;
}
if (!cuts) {
@ -991,11 +974,9 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
if (outv[0].val.t) {
buf0 = Yap_readText(outv, &l0 PASS_REGS);
if (!buf0) {
pop_text_stack( l);
return false;
}
if (cmp_Text(buf, buf0, l0) != 0) {
pop_text_stack( l);
return false;
}
l1 = l - l0;
@ -1003,26 +984,21 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
buf1 = slice(l0, l, buf PASS_REGS);
bool rc = write_Text(buf1, outv + 1, l1 PASS_REGS);
if (!rc) {
pop_text_stack( l);
return false;
}
pop_text_stack(lvl);
return rc;
} else /* if (outv[1].val.t) */ {
buf1 = Yap_readText(outv + 1, &l1 PASS_REGS);
if (!buf1) {
pop_text_stack( l);
return false;
}
l0 = l - l1;
if (cmp_Text(skip_utf8((const unsigned char *)buf, l0), buf1, l1) !=
0) {
pop_text_stack( l);
return false;
}
buf0 = slice(0, l0, buf PASS_REGS);
bool rc = write_Text(buf0, outv, l0 PASS_REGS);
pop_text_stack((rc ? 0 : lvl));
return rc;
}
}
@ -1033,14 +1009,14 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
next = 0;
else
next = cuts[i - 1];
if (cuts[i] == 0)
break;
void *bufi = slice(next, cuts[i], buf PASS_REGS);
if (!write_Text(bufi, outv + i, cuts[i] - next PASS_REGS)) {
pop_text_stack( l);
return false;
}
}
pop_text_stack(l);
return true;
}

6
C/write.c
View File

@ -1012,7 +1012,7 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
}
} else if (!wglb->Ignore_ops &&
(Arity == 1 ||
((atom == AtomEmptyBrackets || atom == AtomEmptyCurlyBrackets ||
((atom == AtomEmptyBrackets || atom == AtomCurly ||
atom == AtomEmptySquareBrackets) &&
Yap_IsListTerm(ArgOfTerm(1, t)))) &&
Yap_IsPosfixOp(atom, &op, &lp)) {
@ -1047,7 +1047,7 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
wrputc('(', wglb->stream);
} else if (atom == AtomEmptySquareBrackets) {
wrputc('[', wglb->stream);
} else if (atom == AtomEmptyCurlyBrackets) {
} else if (atom == AtomCurly) {
wrputc('{', wglb->stream);
}
lastw = separator;
@ -1056,7 +1056,7 @@ static void writeTerm(Term t, int p, int depth, int rinfixarg,
wrputc(')', wglb->stream);
} else if (atom == AtomEmptySquareBrackets) {
wrputc(']', wglb->stream);
} else if (atom == AtomEmptyCurlyBrackets) {
} else if (atom == AtomCurly) {
wrputc('}', wglb->stream);
}
lastw = separator;

8
CXX/yapa.hh
View File

@ -23,8 +23,6 @@ enum PropTag {
MUTEX_TAG = MutexProperty, // 0xFFF6,
/// A typed array, may be in-db or in-stack deped
ARRAY_TAG = ArrayProperty, // 0xFFF7,
/// atom does not fit ISO-LATIN-1
WIDE_TAG = WideAtomProperty, // 0xFFF8,
/// module
MODULE_TAG = ModProperty, // 0xFFFA,
/// the original SICStus blackboard
@ -59,14 +57,12 @@ class YAPAtom {
/// construct new YAPAtom from Atom
YAPAtom( Atom at ) { a = at; }
public:
/// construct new YAPAtom from string
/// construct new YAPAtom from UTF-8 string
YAPAtom( const char * s) { a = Yap_LookupAtom( s ); }
/// construct new YAPAtom from wide string
YAPAtom( const wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); }
//YAPAtom( const wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); }
/// construct new YAPAtom from max-length string
YAPAtom( const char * s, size_t len) { a = Yap_LookupAtomWithLength( s, len ); }
/// construct new YAPAtom from max-length wide string
YAPAtom( const wchar_t * s, size_t len) { a = Yap_LookupMaybeWideAtomWithLength( s, len ); }
/// get name of atom
const char *getName(void);
/// get name of (other way)

2
H/ATOMS
View File

@ -37,7 +37,6 @@ A BeginCurlyBracket N "{"
A EndCurlyBracket N "}"
A EmptyBrackets N "()"
A EmptySquareBrackets N "[]"
A EmptyCurlyBrackets N "{}"
A Asserta N "asserta"
A AssertaStatic N "asserta_static"
A Assertz N "assertz"
@ -498,7 +497,6 @@ F Dot8 Dot 8
F Dot9 Dot 9
F DoubleSlash DoubleSlash 2
F EmptySquareBrackets EmptySquareBrackets 2
F EmptyCurlyBrackets EmptyCurlyBrackets 2
F Eq Eq 2
F Error Error 2
F EvaluationError EvaluationError 1

5
H/ScannerTypes.h
View File

@ -3,13 +3,10 @@ typedef enum TokenKinds {
Number_tok,
Var_tok,
String_tok,
WString_tok,
BQString_tok,
WBQString_tok,
Ponctuation_tok,
Error_tok,
QuasiQuotes_tok,
WQuasiQuotes_tok,
eot_tok
} tkinds;
@ -29,5 +26,5 @@ typedef struct VARSTRUCT {
CELL hv;
UInt refs;
struct VARSTRUCT *VarLeft, *VarRight;
char VarRep[1];
Atom VarRep;
} VarEntry;

2
H/YapGFlagInfo.h
View File

@ -524,7 +524,7 @@ and _Patch_ is the patch number.
*/
YAP_FLAG(VERSION_DATA_FLAG, "version_data", false, ro, YAP_TVERSION,
NULL), /**<
`version ` Read-only flag that returns an a compound term with the
`version ` Read-only flag that returns a compound term with the
current version of YAP. The term will have the name `yap` and arity 4, the first
argument will be the
major version, the second the minor version, the third the patch number, and the

2
H/YapText.h
View File

@ -190,7 +190,7 @@ inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) {
return rc;
else if (b > 0) {
pt += l;
rc += l;
rc ++;
} else {
pt++;
}

2
H/generated/iatoms.h
View File

@ -32,7 +32,6 @@
AtomEndCurlyBracket = Yap_LookupAtom("}"); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket);
AtomEmptyBrackets = Yap_LookupAtom("()"); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets);
AtomEmptySquareBrackets = Yap_LookupAtom("[]"); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets);
AtomEmptyCurlyBrackets = Yap_LookupAtom("{}"); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets);
AtomAsserta = Yap_LookupAtom("asserta"); TermAsserta = MkAtomTerm(AtomAsserta);
AtomAssertaStatic = Yap_LookupAtom("asserta_static"); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic);
AtomAssertz = Yap_LookupAtom("assertz"); TermAssertz = MkAtomTerm(AtomAssertz);
@ -493,7 +492,6 @@
FunctorDot9 = Yap_MkFunctor(AtomDot,9);
FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2);
FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2);
FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2);
FunctorEq = Yap_MkFunctor(AtomEq,2);
FunctorError = Yap_MkFunctor(AtomError,2);
FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);

2
H/generated/ratoms.h
View File

@ -32,7 +32,6 @@
AtomEndCurlyBracket = AtomAdjust(AtomEndCurlyBracket); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket);
AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets);
AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets);
AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets);
AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta);
AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic);
AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz);
@ -493,7 +492,6 @@
FunctorDot9 = FuncAdjust(FunctorDot9);
FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash);
FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets);
FunctorEmptyCurlyBrackets = FuncAdjust(FunctorEmptyCurlyBrackets);
FunctorEq = FuncAdjust(FunctorEq);
FunctorError = FuncAdjust(FunctorError);
FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);

3
H/generated/tatoms.h
View File

@ -32,7 +32,6 @@ EXTERNAL Atom AtomBeginCurlyBracket; EXTERNAL Term TermBeginCurlyBracket;
EXTERNAL Atom AtomEndCurlyBracket; EXTERNAL Term TermEndCurlyBracket;
EXTERNAL Atom AtomEmptyBrackets; EXTERNAL Term TermEmptyBrackets;
EXTERNAL Atom AtomEmptySquareBrackets; EXTERNAL Term TermEmptySquareBrackets;
EXTERNAL Atom AtomEmptyCurlyBrackets; EXTERNAL Term TermEmptyCurlyBrackets;
EXTERNAL Atom AtomAsserta; EXTERNAL Term TermAsserta;
EXTERNAL Atom AtomAssertaStatic; EXTERNAL Term TermAssertaStatic;
EXTERNAL Atom AtomAssertz; EXTERNAL Term TermAssertz;
@ -549,8 +548,6 @@ EXTERNAL Functor FunctorDoubleSlash;
EXTERNAL Functor FunctorEmptySquareBrackets;
EXTERNAL Functor FunctorEmptyCurlyBrackets;
EXTERNAL Functor FunctorEq;
EXTERNAL Functor FunctorError;

9
include/YapError.h
View File

@ -41,11 +41,18 @@
struct yami *Yap_Error__(const char *file, const char *function, int lineno,
yap_error_number err, YAP_Term wheret, ...);
void Yap_ThrowError__(const char *file, const char *function, int lineno,
yap_error_number err, YAP_Term wheret, ...);
#define Yap_NilError(id, ...) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, TermNil, __VA_ARGS__)
#define Yap_Error(id, inp, ...) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__)
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__)
#define Yap_ThrowError(id, inp, ...) \
Yap_ThrowError__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__)
#ifdef YAP_TERM_H
/**

2
os/iopreds.c
View File

@ -1869,7 +1869,7 @@ void Yap_InitIOPreds(void) {
Yap_InitReadTPreds();
Yap_InitFormat();
Yap_InitRandomPreds();
#if USE_READLINE
#if USE_READLINE
Yap_InitReadlinePreds();
#endif
Yap_InitSockets();

2
os/iopreds.h
View File

@ -151,7 +151,7 @@ bool Yap_DoPrompt(StreamDesc *s);
Int Yap_peek(int sno);
int Yap_MemPeekc(int sno);
char *Yap_syntax_error(TokEntry *tokptr, int sno);
Term Yap_syntax_error(TokEntry *tokptr, int sno);
int console_post_process_read_char(int, StreamDesc *);
int console_post_process_eof(StreamDesc *);

75
os/readterm.c
View File

@ -95,7 +95,7 @@ static char SccsId[] = "%W% %G%";
#define SYSTEM_STAT stat
#endif
static char *syntax_error(TokEntry *errtok, int sno, Term cmod);
static Term syntax_error(TokEntry *errtok, int sno, Term cmod);
static void clean_vars(VarEntry *p) {
if (p == NULL)
@ -215,7 +215,7 @@ static const param_t read_defs[] = {READ_DEFS()};
* Implicit arguments:
* +
*/
static char *syntax_error(TokEntry *errtok, int sno, Term cmod) {
static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
CACHE_REGS
Term info;
Term startline, errline, endline;
@ -270,42 +270,21 @@ static char *syntax_error(TokEntry *errtok, int sno, Term cmod) {
t0[0] = MkAtomTerm(Yap_LookupAtom("<QQ>"));
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, t0);
} break;
case WQuasiQuotes_tok: {
Term t0[2];
t0[0] = MkAtomTerm(Yap_LookupAtom("<WideQQ>"));
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, t0);
} break;
case Number_tok:
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomNumber, 1), 1, &(tok->TokInfo));
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomNumber, 1), 1, &info);
break;
case Var_tok: {
Term t[2];
VarEntry *varinfo = (VarEntry *)info;
t[0] = MkIntTerm(0);
t[1] = Yap_CharsToString(varinfo->VarRep, ENC_ISO_LATIN1 PASS_REGS);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomGVar, 2), 2, t);
} break;
case String_tok: {
Term t0 = Yap_CharsToTDQ((char *)info, cmod, ENC_ISO_LATIN1 PASS_REGS);
if (!t0) {
return 0;
}
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
} break;
case WString_tok: {
Term t0 = Yap_WCharsToTDQ((wchar_t *)info, cmod PASS_REGS);
if (!t0)
return 0;
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &info);
} break;
case BQString_tok: {
Term t0 = Yap_CharsToTBQ((char *)info, cmod, ENC_ISO_LATIN1 PASS_REGS);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
} break;
case WBQString_tok: {
Term t0 = Yap_WCharsToTBQ((wchar_t *)info, cmod PASS_REGS);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &info);
} break;
case Error_tok: {
ts[0] = MkAtomTerm(AtomError);
@ -361,10 +340,10 @@ static char *syntax_error(TokEntry *errtok, int sno, Term cmod) {
Yap_DebugPlWriteln(terr);
}
#endif
return NULL;
return terr;
}
char *Yap_syntax_error(TokEntry *errtok, int sno) {
Term Yap_syntax_error(TokEntry *errtok, int sno) {
return syntax_error(errtok, sno, CurrentModule);
}
@ -798,21 +777,28 @@ static parser_state_t scan(REnv *re, FEnv *fe, int inp_stream) {
LOCAL_tokptr = LOCAL_toktide =
Yap_tokenizer(GLOBAL_Stream + inp_stream, false, &fe->tpos);
if (LOCAL_ErrorMessage)
return YAP_SCANNING_ERROR;
if (LOCAL_tokptr->Tok != Ord(eot_tok)) {
// next step
return YAP_PARSING;
#if DEBUG
if (GLOBAL_Option[2]) {
TokEntry *t = LOCAL_tokptr;
int n = 0;
while (t) {
fprintf(stderr, "[Token %d %s %d]", Ord(t->Tok),
Yap_tokRep(t, ENC_ISO_UTF8), n++);
t = t->TokNext;
}
}
if (LOCAL_tokptr->Tok == eot_tok && LOCAL_tokptr->TokInfo == TermNl) {
size_t len = strlen("Empty clause");
char *out = malloc(len + 1);
strncpy(out, "Empty clause", len);
LOCAL_ErrorMessage = out;
LOCAL_Error_TYPE = SYNTAX_ERROR;
return YAP_PARSING_ERROR;
}
return scanEOF(fe, inp_stream);
#endif
if (LOCAL_ErrorMessage)
return YAP_SCANNING_ERROR;
if (LOCAL_tokptr->Tok != Ord(eot_tok)) {
// next step
return YAP_PARSING;
}
if (LOCAL_tokptr->Tok == eot_tok && LOCAL_tokptr->TokInfo == TermNl) {
LOCAL_Error_TYPE = SYNTAX_ERROR;
return YAP_PARSING_ERROR;
}
return scanEOF(fe, inp_stream);
}
static parser_state_t scanError(REnv *re, FEnv *fe, int inp_stream) {
@ -1282,13 +1268,15 @@ X_API Term Yap_StringToTerm(const char *s, size_t len, encoding_t *encp,
CACHE_REGS
Term bvar = MkVarTerm(), ctl;
yhandle_t sl;
int lvl = push_text_stack();
if (len == 0) {
Term rval = TermEof;
if (rval && bindings) {
*bindings = TermNil;
}
return rval;
pop_text_stack(lvl);
return rval;
}
if (bindings) {
ctl = Yap_MkApplTerm(Yap_MkFunctor(AtomVariableNames, 1), 1, &bvar);
@ -1307,6 +1295,7 @@ X_API Term Yap_StringToTerm(const char *s, size_t len, encoding_t *encp,
if (rval && bindings) {
*bindings = Yap_PopHandle(sl);
}
pop_text_stack(lvl);
return rval;
}

8
pl/boot.yap
View File

@ -174,7 +174,7 @@ list, since backtracking could not "pass through" the cut.
system_module(_Mod, _SysExps, _Decls).
% new_system_module(Mod).
use_system_module(_init, _SysExps).
use_system_module(Module, _SysExps).
private(_).
@ -251,6 +251,7 @@ private(_).
:- use_system_module( '$_strict_iso', ['$check_iso_strict_clause'/1,
'$iso_check_goal'/2]).
'$early_print_message'(Level, Msg) :-
'$pred_exists'(print_message(_,_), prolog), !,
print_message( Level, Msg).
@ -658,7 +659,7 @@ number of steps.
'$execute_command'(G, VL, Pos, Option, Source) :-
'$continue_with_command'(Option, VL, Pos, G, Source).
'$continue_with_command'(Where,V,'$stream_position'(C,_P,A1,A2,A3),'$source_location'(_F,L):G,Source) :-
!,
'$continue_with_command'(Where,V,'$stream_position'(C,L,A1,A2,A3),G,Source).
@ -1648,6 +1649,3 @@ log_event( String, Args ) :-
/**
@}
*/

1
pl/grammar.yap
View File

@ -109,7 +109,6 @@ prolog:'$translate_rule'(Rule, (NH :- B) ) :-
),
t_tidy(B1, B).
t_head(V, _, _, _, _, G0) :- var(V), !,
'$do_error'(instantiation_error,G0).
t_head((H,List), NH, NGs, S, S1, G0) :- !,