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

- add debugging code to memory allocation 

= atom to number: cleanup function name as this is more than just supporting SWI
- SrcMask only applies to rules.
- add auxiliary type/error function
- fix typos
- fix enumeration mode in current_flag
- get rid of TrueName routines, use AbsoluteFileName instead.
- detail synatx error source
This commit is contained in:
V'itor Santos Costa 2016-02-11 06:00:56 -08:00
parent f440981b41
commit 74b2b5561d
13 changed files with 121 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
C/alloc.c
View File

@ -60,11 +60,31 @@ static char SccsId[] = "%W% %G%";
/************************************************************************/ /************************************************************************/
/* Yap workspace management */ /* Yap workspace management */
#define MASK 0x968e00
#if USE_SYSTEM_MALLOC #if USE_SYSTEM_MALLOC
#if 0
inline static void * my_malloc(size_t sz)
{
void *p;
p = malloc(sz);
// Yap_DebugPuts(stderr,"gof\n");
return p;
}
inline static void my_free(void *p)
{
printf("f %p\n",p);
free(p);
if (((CELL)p & 0xffffff00) == MASK) jmp_deb(1);
// Yap_DebugPuts(stderr,"gof\n");
}
#else
#define my_malloc(sz) malloc(sz) #define my_malloc(sz) malloc(sz)
#define my_free(ptr) free(ptr)
#endif
#define my_realloc(ptr, sz, osz, safe) realloc(ptr, sz) #define my_realloc(ptr, sz, osz, safe) realloc(ptr, sz)
#define my_realloc0(ptr, sz) realloc(ptr, sz) #define my_realloc0(ptr, sz) realloc(ptr, sz)
#define my_free(ptr) free(ptr)
#else #else
#define my_malloc(sz) Yap_dlmalloc(sz) #define my_malloc(sz) Yap_dlmalloc(sz)
#define my_realloc0(ptr, sz) Yap_dlrealloc(ptr, sz) #define my_realloc0(ptr, sz) Yap_dlrealloc(ptr, sz)

42
C/c_interface.c
View File

@ -58,6 +58,9 @@
#include <malloc.h> #include <malloc.h>
#endif #endif
typedef void *atom_t;
typedef void *functor_t;
typedef enum { typedef enum {
FRG_FIRST_CALL = 0, /* Initial call */ FRG_FIRST_CALL = 0, /* Initial call */
FRG_CUTTED = 1, /* Context was cutted */ FRG_CUTTED = 1, /* Context was cutted */
@ -2094,10 +2097,14 @@ X_API int YAP_InitConsult(int mode, const char *filename, int *osnop) {
} }
bool consulted = (mode == YAP_CONSULT_MODE); bool consulted = (mode == YAP_CONSULT_MODE);
Yap_init_consult(consulted, filename); Yap_init_consult(consulted, filename);
f = fopen(Yap_AbsoluteFile(filename, LOCAL_FileNameBuf, FILENAME_MAX - 1), const char *full = Yap_AbsoluteFile(filename, true);
"r"); if (!full)
return -1;
f = fopen( full, "r");
if (!f) if (!f)
return -1; return -1;
else
free( (char *)full );
sno = Yap_OpenStream(f, NULL, TermNil, Input_Stream_f); sno = Yap_OpenStream(f, NULL, TermNil, Input_Stream_f);
*osnop = Yap_CheckAlias(AtomLoopStream); *osnop = Yap_CheckAlias(AtomLoopStream);
if (!Yap_AddAlias(AtomLoopStream, sno)) { if (!Yap_AddAlias(AtomLoopStream, sno)) {
@ -3380,30 +3387,35 @@ X_API int YAP_RequiresExtraStack(size_t sz) {
return TRUE; return TRUE;
} }
atom_t *TR_Atoms;
functor_t *TR_Functors;
size_t AtomTranslations, MaxAtomTranslations;
size_t FunctorTranslations, MaxFunctorTranslations;
X_API Int YAP_AtomToInt(Atom At) { X_API Int YAP_AtomToInt(Atom At) {
TranslationEntry *te = Yap_GetTranslationProp(At, 0); TranslationEntry *te = Yap_GetTranslationProp(At, 0);
if (te != NIL) if (te != NIL)
return te->Translation; return te->Translation;
SWI_Atoms[AtomTranslations] = At; TR_Atoms[AtomTranslations] = At;
Yap_PutAtomTranslation(At, 0, AtomTranslations); Yap_PutAtomTranslation(At, 0, AtomTranslations);
AtomTranslations++; AtomTranslations++;
if (AtomTranslations == MaxAtomTranslations) { if (AtomTranslations == MaxAtomTranslations) {
Atom *nt = (Atom *)malloc(sizeof(Atom) * 2 * MaxAtomTranslations), atom_t *ot = TR_Atoms;
*ot = SWI_Atoms; atom_t *nt = (atom_t *)malloc(sizeof(atom_t) * 2 * MaxAtomTranslations);
if (nt == NULL) { if (nt == NULL) {
Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At), Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At),
"No more room for translations"); "No more room for translations");
return -1; return -1;
} }
memcpy(nt, ot, sizeof(Atom) * MaxAtomTranslations); memcpy(nt, ot, sizeof(atom_t) * MaxAtomTranslations);
SWI_Atoms = nt; TR_Atoms = nt;
free(ot); free(ot);
MaxAtomTranslations *= 2; MaxAtomTranslations *= 2;
} }
return AtomTranslations - 1; return AtomTranslations - 1;
} }
X_API Atom YAP_IntToAtom(Int i) { return SWI_Atoms[i]; } X_API Atom YAP_IntToAtom(Int i) { return TR_Atoms[i]; }
X_API Int YAP_FunctorToInt(Functor f) { X_API Int YAP_FunctorToInt(Functor f) {
Atom At = NameOfFunctor(f); Atom At = NameOfFunctor(f);
@ -3411,27 +3423,27 @@ X_API Int YAP_FunctorToInt(Functor f) {
TranslationEntry *te = Yap_GetTranslationProp(At, arity); TranslationEntry *te = Yap_GetTranslationProp(At, arity);
if (te != NIL) if (te != NIL)
return te->Translation; return te->Translation;
SWI_Functors[FunctorTranslations] = f; TR_Functors[FunctorTranslations] = f;
Yap_PutAtomTranslation(At, arity, FunctorTranslations); Yap_PutAtomTranslation(At, arity, FunctorTranslations);
FunctorTranslations++; FunctorTranslations++;
if (FunctorTranslations == MaxFunctorTranslations) { if (FunctorTranslations == MaxFunctorTranslations) {
Functor *nt = functor_t *nt =
(Functor *)malloc(sizeof(Functor) * 2 * MaxFunctorTranslations), (functor_t *)malloc(sizeof(functor_t) * 2 * MaxFunctorTranslations),
*ot = SWI_Functors; *ot = TR_Functors;
if (nt == NULL) { if (nt == NULL) {
Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At), Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At),
"No more room for translations"); "No more room for translations");
return -1; return -1;
} }
memcpy(nt, ot, sizeof(Functor) * MaxFunctorTranslations); memcpy(nt, ot, sizeof(functor_t) * MaxFunctorTranslations);
SWI_Functors = nt; TR_Functors = nt;
free(ot); free(ot);
MaxFunctorTranslations *= 2; MaxFunctorTranslations *= 2;
} }
return FunctorTranslations - 1; return FunctorTranslations - 1;
} }
X_API Functor YAP_IntToFunctor(Int i) { return SWI_Functors[i]; } X_API Functor YAP_IntToFunctor(Int i) { return TR_Functors[i]; }
#endif // C_INTERFACE_C #endif // C_INTERFACE_C

4
C/cdmgr.c
View File

@ -3647,7 +3647,7 @@ static Int fetch_next_static_clause(PredEntry *pe, yamop *i_code, Term th,
don't do this!! I might have stored a choice-point and changed ASP don't do this!! I might have stored a choice-point and changed ASP
Yap_RecoverSlots(3); Yap_RecoverSlots(3);
*/ */
if (cl == NULL || !(cl->ClFlags & SrcMask)) { if (cl == NULL || !(pe->PredFlags & SourcePredFlag)) {
UNLOCKPE(45, pe); UNLOCKPE(45, pe);
return false; return false;
} }
@ -3703,7 +3703,7 @@ static Int fetch_next_static_clause(PredEntry *pe, yamop *i_code, Term th,
P = cl->ClCode; P = cl->ClCode;
} }
UNLOCKPE(45, pe); UNLOCKPE(45, pe);
return TRUE; return true;
} else { } else {
Term t; Term t;

20
C/errors.c
View File

@ -133,7 +133,7 @@ bool Yap_PrintWarning(Term twarning) {
CACHE_REGS CACHE_REGS
PredEntry *pred = RepPredProp(PredPropByFunc( PredEntry *pred = RepPredProp(PredPropByFunc(
FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2; FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2;
Term cmod = CurrentModule; Term cmod = ( CurrentModule == PROLOG_MODULE ? TermProlog : CurrentModule );
bool rc; bool rc;
Term ts[2]; Term ts[2];
@ -157,6 +157,8 @@ bool Yap_PrintWarning(Term twarning) {
} }
ts[1] = twarning; ts[1] = twarning;
ts[0] = MkAtomTerm(AtomWarning); ts[0] = MkAtomTerm(AtomWarning);
HB = B->cp_h = HR;
B->cp_tr = TR;
rc = Yap_execute_pred(pred, ts, true PASS_REGS); rc = Yap_execute_pred(pred, ts, true PASS_REGS);
LOCAL_within_print_message = false; LOCAL_within_print_message = false;
LOCAL_DoingUndefp = false; LOCAL_DoingUndefp = false;
@ -613,7 +615,7 @@ static Int
is_boolean( USES_REGS1 ) is_boolean( USES_REGS1 )
{ {
Term t = Deref(ARG1); Term t = Deref(ARG1);
//Term Context = Deref(ARG2); //Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);;
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t, NULL); Yap_Error(INSTANTIATION_ERROR, t, NULL);
return false; return false;
@ -621,6 +623,19 @@ is_boolean( USES_REGS1 )
return t == TermTrue || t == TermFalse; return t == TermTrue || t == TermFalse;
} }
static Int
is_atom( USES_REGS1 )
{
Term t = Deref(ARG1);
//Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);;
if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t, NULL);
return false;
}
return IsAtomTerm( t );
}
static Int static Int
is_callable( USES_REGS1 ) is_callable( USES_REGS1 )
@ -699,6 +714,7 @@ Yap_InitErrorPreds( void )
CurrentModule = ERROR_MODULE; CurrentModule = ERROR_MODULE;
Yap_InitCPred("is_boolean", 2, is_boolean, TestPredFlag); Yap_InitCPred("is_boolean", 2, is_boolean, TestPredFlag);
Yap_InitCPred("is_callable", 2, is_callable, TestPredFlag); Yap_InitCPred("is_callable", 2, is_callable, TestPredFlag);
Yap_InitCPred("is_atom", 2, is_atom, TestPredFlag);
Yap_InitCPred("is_predicate_indicator", 2, is_predicate_indicator, TestPredFlag); Yap_InitCPred("is_predicate_indicator", 2, is_predicate_indicator, TestPredFlag);
CurrentModule = cm; CurrentModule = cm;
} }

2
C/exec.c
View File

@ -1037,7 +1037,7 @@ static Int exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
LOCAL_PrologMode = UserMode; LOCAL_PrologMode = UserMode;
} break; } break;
case 3: { /* saved state */ case 3: { /* saved state */
return FALSE; return false;
} }
default: default:
/* do nothing */ /* do nothing */

22
C/flags.c
View File

@ -104,7 +104,7 @@ static bool dqf1(ModEntry *new, Term t2 USES_REGS) {
/* bad argument, but still an atom */ /* 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, " "string flag, use one string, "
"arom, codes or chars", "atom, codes or chars",
RepAtom(AtomOfTerm(t2))->StrOfAE); RepAtom(AtomOfTerm(t2))->StrOfAE);
return false; return false;
} else { } else {
@ -139,7 +139,7 @@ static bool bqf1(ModEntry *new, Term t2 USES_REGS) {
} }
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, " "string flag, use one string, "
"arom, codes or chars", "atom, codes or chars",
RepAtom(AtomOfTerm(t2))->StrOfAE); RepAtom(AtomOfTerm(t2))->StrOfAE);
return false; return false;
} else { } else {
@ -589,9 +589,10 @@ static void initFlag(flag_info *f, int fnum, bool global) {
static bool executable(Term inp) { static bool executable(Term inp) {
CACHE_REGS CACHE_REGS
if (GLOBAL_argv && GLOBAL_argv[0]) if (GLOBAL_argv && GLOBAL_argv[0]) {
Yap_TrueFileName(GLOBAL_argv[0], LOCAL_FileNameBuf, FALSE); if (!Yap_AbsoluteFileInBuffer(GLOBAL_argv[0], LOCAL_FileNameBuf, YAP_FILENAME_MAX - 1,true))
else return false;
} else
strncpy(LOCAL_FileNameBuf, Yap_FindExecutable(), YAP_FILENAME_MAX - 1); strncpy(LOCAL_FileNameBuf, Yap_FindExecutable(), YAP_FILENAME_MAX - 1);
return Yap_unify(MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)), inp); return Yap_unify(MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)), inp);
@ -880,8 +881,7 @@ static Int cont_current_prolog_flag(USES_REGS1) {
} }
EXTRA_CBACK_ARG(2, 1) = MkIntTerm(++i); EXTRA_CBACK_ARG(2, 1) = MkIntTerm(++i);
flag = getYapFlag(f); flag = getYapFlag(f);
if (!Yap_unify(f, ARG2)) return Yap_unify(flag, ARG2);
return false;
} }
cut_fail(); cut_fail();
} }
@ -1294,7 +1294,8 @@ do_prolog_flag_property(Term tflag,
args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs, args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
PROLOG_FLAG_PROPERTY_END); PROLOG_FLAG_PROPERTY_END);
if (args == NULL) { if (args == NULL) {
return FALSE; Yap_Error( LOCAL_Error_TYPE, LOCAL_Error_Term, NULL );
return false;
} }
if (!IsAtomTerm(tflag)) { if (!IsAtomTerm(tflag)) {
if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) { if (IsApplTerm(tflag) && FunctorOfTerm(tflag) == FunctorModule) {
@ -1454,8 +1455,9 @@ static Int do_create_prolog_flag(USES_REGS1) {
args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs, args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
PROLOG_FLAG_PROPERTY_END); PROLOG_FLAG_PROPERTY_END);
if (args == NULL) { if (args == NULL) {
return FALSE; Yap_Error( LOCAL_Error_TYPE, LOCAL_Error_Term, NULL );
return false;
} }
fv = GetFlagProp(AtomOfTerm(tflag)); fv = GetFlagProp(AtomOfTerm(tflag));
if (fv) { if (fv) {

7
C/init.c
View File

@ -1028,13 +1028,6 @@ static void InitLogDBErasedMarker(void) {
INIT_CLREF_COUNT(LogDBErasedMarker); INIT_CLREF_COUNT(LogDBErasedMarker);
} }
static void InitSWIAtoms(void) {
MaxAtomTranslations = N_SWI_ATOMS;
MaxFunctorTranslations = N_SWI_FUNCTORS;
SWI_Atoms = (Atom *)malloc(sizeof(Atom) * MaxAtomTranslations);
SWI_Functors = (Functor *)malloc(sizeof(Functor) * 2 * N_SWI_ATOMS);
}
static void InitEmptyWakeups(void) {} static void InitEmptyWakeups(void) {}
static void InitAtoms(void) { static void InitAtoms(void) {

2
C/load_aix.c
View File

@ -69,7 +69,7 @@ LoadForeign(StringList ofiles, StringList libs,
strcpy(LOCAL_ErrorSay," Load Failed: in AIX you must load a single object file"); strcpy(LOCAL_ErrorSay," Load Failed: in AIX you must load a single object file");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if (!Yap_TrueFileName(AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE)) { if (!Yap_AbsoluteFileInBuffer(AtomName(ofiles->name), LOCAL_FileNameBuf, YAP_FILENAME_MAX, true)) {
strcpy(LOCAL_ErrorSay, " Trying to open unexisting file in LoadForeign "); strcpy(LOCAL_ErrorSay, " Trying to open unexisting file in LoadForeign ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }

9
C/load_aout.c
View File

@ -67,7 +67,8 @@ Yap_FindExecutable(void)
if (*GLOBAL_argv[0] == '/') { if (*GLOBAL_argv[0] == '/') {
if (oktox(GLOBAL_argv[0])) { if (oktox(GLOBAL_argv[0])) {
strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]); strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE); Yap_AbsoluteFileInBuffer(LOCAL_FileNameBuf, true);
strncpy( GLOBAL_Executable, LOCAL_FileNameBuf, YAP_MAXPATHLEN);
return; return;
} }
} }
@ -87,12 +88,12 @@ Yap_FindExecutable(void)
cp++; cp++;
if (!oktox(LOCAL_FileNameBuf)) if (!oktox(LOCAL_FileNameBuf))
continue; continue;
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE); Yap_AbsoluteFileInBuffer(Yap_AbsoluteFileInBuffer(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
return; return;
} }
/* one last try for dual systems */ /* one last try for dual systems */
strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]); strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE); Yap_AbsoluteFileInBuffer(Yap_AbsoluteFileInBuffer(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
if (oktox(GLOBAL_Executable)) if (oktox(GLOBAL_Executable))
return GLOBAL_Executable; return GLOBAL_Executable;
else else

59
C/parser.c
View File

@ -175,10 +175,11 @@ static void syntax_msg(const char *msg, ...) {
va_list ap; va_list ap;
if (LOCAL_toktide == LOCAL_tokptr) { if (LOCAL_toktide == LOCAL_tokptr) {
char out[YAP_FILENAME_MAX];
va_start(ap, msg); va_start(ap, msg);
vsnprintf(LOCAL_FileNameBuf2, YAP_FILENAME_MAX - 1, msg, ap); vsnprintf(out, YAP_FILENAME_MAX - 1, msg, ap);
LOCAL_ErrorMessage = LOCAL_FileNameBuf2; LOCAL_Error_Term = MkStringTerm( out );
LOCAL_Error_TYPE = SYNTAX_ERROR; LOCAL_Error_TYPE = SYNTAX_ERROR;
va_end(ap); va_end(ap);
} }
} }
@ -463,7 +464,7 @@ inline static void checkfor(wchar_t c, JMPBUFF *FailBuff USES_REGS) {
LOCAL_tokptr->TokInfo != (Term)c) { LOCAL_tokptr->TokInfo != (Term)c) {
char s[1024]; char s[1024];
strncpy(s, Yap_tokRep(LOCAL_tokptr), 1023); strncpy(s, Yap_tokRep(LOCAL_tokptr), 1023);
syntax_msg("expected to find \'%c\', found %s", c, s); syntax_msg("line %d: expected to find \'%c\', found %s", LOCAL_tokptr->TokPos, c, s);
FAIL; FAIL;
} }
NextToken; NextToken;
@ -543,12 +544,12 @@ static Term ParseArgs(Atom a, wchar_t close, JMPBUFF *FailBuff,
func = Yap_MkFunctor(a, 1); func = Yap_MkFunctor(a, 1);
if (func == NULL) { if (func == NULL) {
syntax_msg("Heap Overflow"); syntax_msg("line %d: Heap Overflow",LOCAL_tokptr->TokPos );
FAIL; FAIL;
} }
t = Yap_MkApplTerm(func, nargs, p); t = Yap_MkApplTerm(func, nargs, p);
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos );
return TermNil; return TermNil;
} }
NextToken; NextToken;
@ -558,7 +559,7 @@ static Term ParseArgs(Atom a, wchar_t close, JMPBUFF *FailBuff,
while (1) { while (1) {
Term *tp = (Term *)ParserAuxSp; Term *tp = (Term *)ParserAuxSp;
if (ParserAuxSp + 1 > LOCAL_TrailTop) { if (ParserAuxSp + 1 > LOCAL_TrailTop) {
syntax_msg("Trail Overflow"); syntax_msg("line %d: Trail Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
*tp++ = Unsigned(ParseTerm(999, FailBuff PASS_REGS)); *tp++ = Unsigned(ParseTerm(999, FailBuff PASS_REGS));
@ -576,12 +577,12 @@ static Term ParseArgs(Atom a, wchar_t close, JMPBUFF *FailBuff,
* order * order
*/ */
if (HR > ASP - (nargs + 1)) { if (HR > ASP - (nargs + 1)) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
func = Yap_MkFunctor(a, nargs); func = Yap_MkFunctor(a, nargs);
if (func == NULL) { if (func == NULL) {
syntax_msg("Heap Overflow"); syntax_msg("line %d: Heap Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
#ifdef SFUNC #ifdef SFUNC
@ -596,7 +597,7 @@ static Term ParseArgs(Atom a, wchar_t close, JMPBUFF *FailBuff,
t = Yap_MkApplTerm(func, nargs, p); t = Yap_MkApplTerm(func, nargs, p);
#endif #endif
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
return TermNil; return TermNil;
} }
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
@ -631,7 +632,7 @@ loop:
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
to_store[1] = TermNil; to_store[1] = TermNil;
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow" ,LOCAL_tokptr->TokPos);
FAIL; FAIL;
} else { } else {
to_store[1] = AbsPair(HR); to_store[1] = AbsPair(HR);
@ -645,7 +646,7 @@ loop:
to_store[1] = MkAtomTerm(AtomNil); to_store[1] = MkAtomTerm(AtomNil);
} }
} else { } else {
syntax_msg("looking for symbol ',','|' got symbol '%s'", syntax_msg("line %d: looking for symbol ',','|' got symbol '%s'",LOCAL_tokptr->TokPos,
Yap_tokRep(LOCAL_tokptr)); Yap_tokRep(LOCAL_tokptr));
FAIL; FAIL;
} }
@ -717,14 +718,14 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
TRY( TRY(
/* build appl on the heap */ /* build appl on the heap */
func = Yap_MkFunctor((Atom)t, 1); if (func == NULL) { func = Yap_MkFunctor((Atom)t, 1); if (func == NULL) {
syntax_msg("Heap Overflow"); syntax_msg("line %d: Heap Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
t = ParseTerm(oprprio, FailBuff PASS_REGS); t = ParseTerm(oprprio, FailBuff PASS_REGS);
t = Yap_MkApplTerm(func, 1, &t); t = Yap_MkApplTerm(func, 1, &t);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} curprio = opprio; } curprio = opprio;
, break;) , break;)
@ -750,7 +751,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
LOCAL_Error_TYPE = YAP_NO_ERROR; LOCAL_Error_TYPE = YAP_NO_ERROR;
t = Yap_CharsToTDQ(p, CurrentModule, LOCAL_encoding PASS_REGS); t = Yap_CharsToTDQ(p, CurrentModule, LOCAL_encoding PASS_REGS);
if (!t) { if (!t) {
syntax_msg("could not convert \"%s\"", (char *)LOCAL_tokptr->TokInfo); syntax_msg("line %d: could not convert \"%s\"",LOCAL_tokptr->TokPos, (char *)LOCAL_tokptr->TokInfo);
FAIL; FAIL;
} }
LOCAL_Error_TYPE = oerr; LOCAL_Error_TYPE = oerr;
@ -765,7 +766,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
LOCAL_Error_TYPE = YAP_NO_ERROR; LOCAL_Error_TYPE = YAP_NO_ERROR;
t = Yap_WCharsToTDQ(p, CurrentModule PASS_REGS); t = Yap_WCharsToTDQ(p, CurrentModule PASS_REGS);
if (!t) { if (!t) {
syntax_msg("could not convert \'%S\'", (wchar_t *)LOCAL_tokptr->TokInfo); syntax_msg("line %d: could not convert \'%S\'",LOCAL_tokptr->TokPos, (wchar_t *)LOCAL_tokptr->TokInfo);
FAIL; FAIL;
} }
LOCAL_Error_TYPE = oerr; LOCAL_Error_TYPE = oerr;
@ -781,7 +782,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
t = Yap_CharsToTBQ(p, CurrentModule, LOCAL_encoding PASS_REGS); t = Yap_CharsToTBQ(p, CurrentModule, LOCAL_encoding PASS_REGS);
if (!t) { if (!t) {
syntax_msg("could not convert \'%s\"", (char *)LOCAL_tokptr->TokInfo); syntax_msg("line %d: could not convert \'%s\"",LOCAL_tokptr->TokPos, (char *)LOCAL_tokptr->TokInfo);
FAIL; FAIL;
} }
LOCAL_Error_TYPE = oerr; LOCAL_Error_TYPE = oerr;
@ -796,7 +797,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
yap_error_number oerr = LOCAL_Error_TYPE; yap_error_number oerr = LOCAL_Error_TYPE;
LOCAL_Error_TYPE = YAP_NO_ERROR; LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!t) { if (!t) {
syntax_msg("could not convert \"%S\"", (wchar_t *)LOCAL_tokptr->TokInfo); syntax_msg("line %d: could not convert \"%S\"",LOCAL_tokptr->TokPos, (wchar_t *)LOCAL_tokptr->TokInfo);
FAIL; FAIL;
} }
LOCAL_Error_TYPE = oerr; LOCAL_Error_TYPE = oerr;
@ -812,7 +813,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
break; break;
case Error_tok: case Error_tok:
syntax_msg("found ill-formed \"%s\"", Yap_tokRep(LOCAL_tokptr)); syntax_msg("line %d: found ill-formed \"%s\"",LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr));
FAIL; FAIL;
case Ponctuation_tok: case Ponctuation_tok:
@ -847,13 +848,13 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
t = Yap_MkApplTerm(FunctorBraces, 1, &t); t = Yap_MkApplTerm(FunctorBraces, 1, &t);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
checkfor('}', FailBuff PASS_REGS); checkfor('}', FailBuff PASS_REGS);
break; break;
default: default:
syntax_msg("unexpected ponctuation signal %s", Yap_tokRep(LOCAL_tokptr)); syntax_msg("line %d: unexpected ponctuation signal %s",LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr));
FAIL; FAIL;
} }
break; break;
@ -944,7 +945,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
NextToken; NextToken;
break; break;
default: default:
syntax_msg("expected operator, got \'%s\'", Yap_tokRep(LOCAL_tokptr)); syntax_msg("line %d: expected operator, got \'%s\'",LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr));
FAIL; FAIL;
} }
@ -960,7 +961,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
TRY3( TRY3(
func = Yap_MkFunctor((Atom)LOCAL_tokptr->TokInfo, 2); func = Yap_MkFunctor((Atom)LOCAL_tokptr->TokInfo, 2);
if (func == NULL) { if (func == NULL) {
syntax_msg("Heap Overflow"); syntax_msg("line %d: Heap Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} NextToken; } NextToken;
{ {
@ -970,7 +971,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
t = Yap_MkApplTerm(func, 2, args); t = Yap_MkApplTerm(func, 2, args);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
}, },
@ -983,13 +984,13 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
/* parse as posfix operator */ /* parse as posfix operator */
Functor func = Yap_MkFunctor((Atom)LOCAL_tokptr->TokInfo, 1); Functor func = Yap_MkFunctor((Atom)LOCAL_tokptr->TokInfo, 1);
if (func == NULL) { if (func == NULL) {
syntax_msg("Heap Overflow"); syntax_msg("line %d: Heap Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
t = Yap_MkApplTerm(func, 1, &t); t = Yap_MkApplTerm(func, 1, &t);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
curprio = opprio; curprio = opprio;
@ -1008,7 +1009,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
t = Yap_MkApplTerm(FunctorComma, 2, args); t = Yap_MkApplTerm(FunctorComma, 2, args);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
curprio = 1000; curprio = 1000;
@ -1023,7 +1024,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
t = Yap_MkApplTerm(FunctorVBar, 2, args); t = Yap_MkApplTerm(FunctorVBar, 2, args);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (HR > ASP - 4096) { if (HR > ASP - 4096) {
syntax_msg("Stack Overflow"); syntax_msg("line %d: Stack Overflow",LOCAL_tokptr->TokPos);
FAIL; FAIL;
} }
curprio = opprio; curprio = opprio;
@ -1053,7 +1054,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff USES_REGS) {
} }
} }
if (LOCAL_tokptr->Tok <= Ord(WString_tok)) { if (LOCAL_tokptr->Tok <= Ord(WString_tok)) {
syntax_msg("expected operator, got \'%s\'", Yap_tokRep(LOCAL_tokptr)); syntax_msg("line %d: expected operator, got \'%s\'",LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr));
FAIL; FAIL;
} }
break; break;

4
C/save.c
View File

@ -1400,7 +1400,7 @@ commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail, CELL *AStack, CELL *A
LOCAL_PrologMode = BootMode; LOCAL_PrologMode = BootMode;
if (Yap_HeapBase) { if (Yap_HeapBase) {
if (falseGlobalPrologFlag( HALT_AFTER_CONSULT_FLAG ) && !silentMode( )) { if (falseGlobalPrologFlag( HALT_AFTER_CONSULT_FLAG ) && !silentMode( )) {
Yap_TrueFileName(s,LOCAL_FileNameBuf2, YAP_FILENAME_MAX); Yap_AbsoluteFileInBuffer(s,LOCAL_FileNameBuf2, YAP_FILENAME_MAX, true);
fprintf(stderr, "%% Restoring file %s\n", LOCAL_FileNameBuf2); fprintf(stderr, "%% Restoring file %s\n", LOCAL_FileNameBuf2);
} }
Yap_CloseStreams(TRUE); Yap_CloseStreams(TRUE);
@ -1442,7 +1442,7 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
int mode; int mode;
char fname[PATH_MAX+1]; char fname[PATH_MAX+1];
if (!Yap_trueFileName( inpf, YAP_STARTUP, YapLibDir, fname, true, YAP_SAVED_STATE, true, true)) if (!Yap_AbsoluteFileInBuffer( inpf, fname, PATH_MAX, true))
return false; return false;
if (fname[0] && if (fname[0] &&
(mode = try_open(fname,Astate,ATrail,AStack,AHeap,streamp)) != FAIL_RESTORE) { (mode = try_open(fname,Astate,ATrail,AStack,AHeap,streamp)) != FAIL_RESTORE) {

1
C/scanner.c
View File

@ -1247,6 +1247,7 @@ const char *Yap_tokRep(TokEntry *tokptr) {
return buf; return buf;
case Var_tok: { case Var_tok: {
VarEntry *varinfo = (VarEntry *)info; VarEntry *varinfo = (VarEntry *)info;
varinfo->VarAdr = TermNil;
return varinfo->VarRep; return varinfo->VarRep;
} }
case String_tok: case String_tok:

2
C/text.c
View File

@ -650,7 +650,7 @@ write_atom( void *s0, seq_tv_t *out, encoding_t enc, int minimal, size_t leng US
switch (enc) { switch (enc) {
case ENC_ISO_UTF8: case ENC_ISO_UTF8:
{ unsigned char *s = s0, *lim = s + strnlen(s0, max); { unsigned char *s = s0, *lim = s + strnlen(s0, max);
wchar_t *buf = malloc(sizeof(wchar_t)*((lim+1)-s)), *ptr = buf; wchar_t *buf = malloc(sizeof(wchar_t)*((lim+2)-s)), *ptr = buf;
Atom at; Atom at;
while (*s && s < lim) { while (*s && s < lim) {