try to make initialisation process more robust
try to make name more robust (in case Lookup new atom fails) git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@1254 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
This commit is contained in:
vsc
parent
14f9382666
commit
f11ab09a60
@ -10,8 +10,12 @@
|
||||
* File: c_interface.c *
|
||||
* comments: c_interface primitives definition *
|
||||
* *
|
||||
* Last rev: $Date: 2005-03-01 22:25:08 $,$Author: vsc $ *
|
||||
* Last rev: $Date: 2005-03-02 18:35:44 $,$Author: vsc $ *
|
||||
* $Log: not supported by cvs2svn $
|
||||
* Revision 1.61 2005/03/01 22:25:08 vsc
|
||||
* fix pruning bug
|
||||
* make DL_MALLOC less enthusiastic about walking through buckets.
|
||||
*
|
||||
* Revision 1.60 2005/02/08 18:04:47 vsc
|
||||
* library_directory may not be deterministic (usually it isn't).
|
||||
*
|
||||
@ -95,6 +99,9 @@
|
||||
#include "Yap.h"
|
||||
#include "clause.h"
|
||||
#include "yapio.h"
|
||||
#if HAVE_STDARG_H
|
||||
#include <stdarg.h>
|
||||
#endif
|
||||
#if _MSC_VER || defined(__MINGW32__)
|
||||
#include <windows.h>
|
||||
#endif
|
||||
@ -165,7 +172,7 @@ X_API int STD_PROTO(YAP_StringToBuffer, (Term, char *, unsigned int));
|
||||
X_API Term STD_PROTO(YAP_ReadBuffer, (char *,Term *));
|
||||
X_API Term STD_PROTO(YAP_BufferToString, (char *));
|
||||
X_API Term STD_PROTO(YAP_BufferToAtomList, (char *));
|
||||
X_API void STD_PROTO(YAP_Error,(char *));
|
||||
X_API void STD_PROTO(YAP_Error,(int, Term, char *, ...));
|
||||
X_API Term STD_PROTO(YAP_RunGoal,(Term));
|
||||
X_API int STD_PROTO(YAP_RestartGoal,(void));
|
||||
X_API int STD_PROTO(YAP_GoalHasException,(Term *));
|
||||
@ -835,9 +842,28 @@ YAP_BufferToAtomList(char *s)
|
||||
|
||||
|
||||
X_API void
|
||||
YAP_Error(char *buf)
|
||||
YAP_Error(int myerrno, Term t, char *buf,...)
|
||||
{
|
||||
Yap_Error(SYSTEM_ERROR,TermNil,buf);
|
||||
#define YAP_BUF_SIZE 512
|
||||
va_list ap;
|
||||
char tmpbuf[YAP_BUF_SIZE];
|
||||
|
||||
if (!myerrno)
|
||||
myerrno = SYSTEM_ERROR;
|
||||
if (t == 0L)
|
||||
t = TermNil;
|
||||
if (buf != NULL) {
|
||||
va_start (ap, buf);
|
||||
#if HAVE_VSNPRINTF
|
||||
(void) vsnprintf(tmpbuf, YAP_BUF_SIZE, buf, ap);
|
||||
#else
|
||||
(void) vsprintf(tmpbuf, buf, ap);
|
||||
#endif
|
||||
va_end (ap);
|
||||
} else {
|
||||
tmpbuf[0] = '\0';
|
||||
}
|
||||
Yap_Error(myerrno,t,tmpbuf);
|
||||
}
|
||||
|
||||
static void myputc (int ch)
|
||||
@ -1046,7 +1072,9 @@ YAP_Init(YAP_init_args *yap_init)
|
||||
if (yap_init->SavedState != NULL ||
|
||||
yap_init->YapPrologBootFile == NULL) {
|
||||
if (Yap_SavedInfo (yap_init->SavedState, yap_init->YapLibDir, &Trail, &Stack, &Heap) != 1) {
|
||||
return(YAP_BOOT_FROM_SAVED_ERROR);
|
||||
yap_init->ErrorNo = Yap_Error_TYPE;
|
||||
yap_init->ErrorCause = Yap_ErrorMessage;
|
||||
return YAP_BOOT_FROM_SAVED_ERROR;
|
||||
}
|
||||
}
|
||||
if (yap_init->TrailSize == 0) {
|
||||
@ -1095,6 +1123,11 @@ YAP_Init(YAP_init_args *yap_init)
|
||||
if (yap_init->SavedState != NULL ||
|
||||
yap_init->YapPrologBootFile == NULL) {
|
||||
restore_result = Yap_Restore(yap_init->SavedState, yap_init->YapLibDir);
|
||||
if (restore_result == FAIL_RESTORE) {
|
||||
yap_init->ErrorNo = Yap_Error_TYPE;
|
||||
yap_init->ErrorCause = Yap_ErrorMessage;
|
||||
return YAP_BOOT_FROM_SAVED_ERROR;
|
||||
}
|
||||
} else {
|
||||
restore_result = FAIL_RESTORE;
|
||||
}
|
||||
@ -1134,21 +1167,25 @@ YAP_Init(YAP_init_args *yap_init)
|
||||
}
|
||||
if (yap_init->SavedState != NULL ||
|
||||
yap_init->YapPrologBootFile == NULL) {
|
||||
if (restore_result == FAIL_RESTORE)
|
||||
return(YAP_BOOT_FROM_SAVED_ERROR);
|
||||
if (restore_result == FAIL_RESTORE) {
|
||||
yap_init->ErrorNo = Yap_Error_TYPE;
|
||||
yap_init->ErrorCause = Yap_ErrorMessage;
|
||||
return YAP_BOOT_FROM_SAVED_ERROR;
|
||||
}
|
||||
if (restore_result == DO_ONLY_CODE) {
|
||||
return(YAP_BOOT_FROM_SAVED_CODE);
|
||||
return YAP_BOOT_FROM_SAVED_CODE;
|
||||
} else {
|
||||
return(YAP_BOOT_FROM_SAVED_STACKS);
|
||||
return YAP_BOOT_FROM_SAVED_STACKS;
|
||||
}
|
||||
}
|
||||
return(YAP_BOOT_FROM_PROLOG);
|
||||
return YAP_BOOT_FROM_PROLOG;
|
||||
}
|
||||
|
||||
X_API Int
|
||||
YAP_FastInit(char saved_state[])
|
||||
{
|
||||
YAP_init_args init_args;
|
||||
Int out;
|
||||
|
||||
init_args.SavedState = saved_state;
|
||||
init_args.HeapSize = 0;
|
||||
@ -1166,8 +1203,13 @@ YAP_FastInit(char saved_state[])
|
||||
init_args.PrologShouldHandleInterrupts = FALSE;
|
||||
init_args.Argc = 0;
|
||||
init_args.Argv = NULL;
|
||||
|
||||
return(YAP_Init(&init_args));
|
||||
init_args.ErrorNo = 0;
|
||||
init_args.ErrorCause = NULL;
|
||||
out = YAP_Init(&init_args);
|
||||
if (out == YAP_BOOT_FROM_SAVED_ERROR) {
|
||||
Yap_Error(init_args.ErrorNo,TermNil,init_args.ErrorCause);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
X_API void
|
||||
|
||||
19
C/errors.c
19
C/errors.c
@ -372,7 +372,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
|
||||
int psize = YAP_BUF_SIZE;
|
||||
|
||||
#if DEBUG
|
||||
/* fprintf(stderr,"***** Processing Error %d (%x,%x) %s***\n", type, ActiveSignals,Yap_PrologMode,format);*/
|
||||
if (Yap_heap_regs && !(Yap_PrologMode & BootMode))
|
||||
fprintf(stderr,"***** Processing Error %d (%x,%x) %s***\n", type, ActiveSignals,Yap_PrologMode,format);
|
||||
else
|
||||
fprintf(stderr,"***** Processing Error %d (%x) %s***\n", type,Yap_PrologMode,format);
|
||||
#endif
|
||||
if (type == INTERRUPT_ERROR) {
|
||||
fprintf(stderr,"%% YAP exiting: cannot handle signal %d\n",
|
||||
@ -419,9 +422,9 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
|
||||
tmpbuf[0] = '\0';
|
||||
}
|
||||
if (Yap_PrologMode == UserCCallMode) {
|
||||
fprintf(stderr,"%% OOOPS in USER C-CODE: %s.\n",tmpbuf);
|
||||
fprintf(stderr,"%% YAP OOOPS in USER C-CODE: %s.\n",tmpbuf);
|
||||
} else {
|
||||
fprintf(stderr,"%% OOOPS: %s.\n",tmpbuf);
|
||||
fprintf(stderr,"%% YAP OOOPS: %s.\n",tmpbuf);
|
||||
}
|
||||
error_exit_yap (1);
|
||||
}
|
||||
@ -461,7 +464,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
|
||||
va_end (ap);
|
||||
if (Yap_PrologMode & BootMode) {
|
||||
/* crash in flames! */
|
||||
fprintf(stderr,"%% Fatal Error: %s exiting....\n",tmpbuf);
|
||||
fprintf(stderr,"%% YAP Fatal Error: %s exiting....\n",tmpbuf);
|
||||
error_exit_yap (1);
|
||||
}
|
||||
#ifdef DEBUGX
|
||||
@ -472,8 +475,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...)
|
||||
{
|
||||
fprintf(stderr,"%% Internal YAP Error: %s exiting....\n",tmpbuf);
|
||||
serious = TRUE;
|
||||
detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, tmpbuf, YAP_BUF_SIZE);
|
||||
fprintf(stderr,"%% Bug found while executing %s\n",tmpbuf);
|
||||
if (Yap_PrologMode & BootMode) {
|
||||
fprintf(stderr,"%% YAP crashed while booting %s\n",tmpbuf);
|
||||
} else {
|
||||
detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, tmpbuf, YAP_BUF_SIZE);
|
||||
fprintf(stderr,"%% Bug found while executing %s\n",tmpbuf);
|
||||
}
|
||||
error_exit_yap (1);
|
||||
}
|
||||
case FATAL_ERROR:
|
||||
|
||||
5
C/exec.c
5
C/exec.c
@ -1450,11 +1450,14 @@ JumpToEnv(Term t) {
|
||||
#ifdef TABLING
|
||||
abolish_incomplete_subgoals(B);
|
||||
#endif /* TABLING */
|
||||
return(FALSE);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
Int
|
||||
Yap_JumpToEnv(Term t) {
|
||||
if (Yap_PrologMode & BootMode) {
|
||||
return FALSE;
|
||||
}
|
||||
return JumpToEnv(t);
|
||||
}
|
||||
|
||||
|
||||
338
C/save.c
338
C/save.c
@ -81,7 +81,7 @@ static char end_msg[256] ="*** End of YAP saved state *****";
|
||||
|
||||
#endif
|
||||
|
||||
STATIC_PROTO(void myread, (int, char *, Int));
|
||||
STATIC_PROTO(int myread, (int, char *, Int));
|
||||
STATIC_PROTO(void mywrite, (int, char *, Int));
|
||||
STATIC_PROTO(int open_file, (char *, int));
|
||||
STATIC_PROTO(void close_file, (void));
|
||||
@ -99,13 +99,13 @@ STATIC_PROTO(Int do_save, (int));
|
||||
STATIC_PROTO(Int p_save, (void));
|
||||
STATIC_PROTO(Int p_save_program, (void));
|
||||
STATIC_PROTO(int check_header, (CELL *, CELL *, CELL *, CELL *));
|
||||
STATIC_PROTO(void get_heap_info, (void));
|
||||
STATIC_PROTO(void get_regs, (int));
|
||||
STATIC_PROTO(void get_insts, (OPCODE []));
|
||||
STATIC_PROTO(void get_hash, (void));
|
||||
STATIC_PROTO(void CopyCode, (void));
|
||||
STATIC_PROTO(void CopyStacks, (void));
|
||||
STATIC_PROTO(void get_coded, (int, OPCODE []));
|
||||
STATIC_PROTO(int get_heap_info, (void));
|
||||
STATIC_PROTO(int get_regs, (int));
|
||||
STATIC_PROTO(int get_insts, (OPCODE []));
|
||||
STATIC_PROTO(int get_hash, (void));
|
||||
STATIC_PROTO(int CopyCode, (void));
|
||||
STATIC_PROTO(int CopyStacks, (void));
|
||||
STATIC_PROTO(int get_coded, (int, OPCODE []));
|
||||
STATIC_PROTO(void restore_codes, (void));
|
||||
STATIC_PROTO(Term AdjustDBTerm, (Term, Term *));
|
||||
STATIC_PROTO(void RestoreDB, (DBEntry *));
|
||||
@ -152,23 +152,45 @@ LightBug(s)
|
||||
|
||||
#endif /* LIGHT */
|
||||
|
||||
static int
|
||||
do_system_error(yap_error_number etype, const char *msg)
|
||||
{
|
||||
#if HAVE_SNPRINTF
|
||||
#if HAVE_STRERROR
|
||||
snprintf(Yap_ErrorSay,MAX_ERROR_MSG_SIZE,"%s (%s when reading %s)", msg, strerror(errno), Yap_FileNameBuf);
|
||||
#else
|
||||
snprintf(Yap_ErrorSay,MAX_ERROR_MSG_SIZE,"%s, (system error %d when reading %s)",msg,errno,Yap_FileNameBuf);
|
||||
#endif
|
||||
#else
|
||||
#if HAVE_STRERROR
|
||||
sprintf(Yap_ErrorSay,"%s, (%s when reading %s)",msg,strerror(errno),Yap_FileNameBuf);
|
||||
#else
|
||||
sprintf(Yap_ErrorSay,"%s, (system error %d when reading %s)",msg,errno,Yap_FileNameBuf);
|
||||
#endif
|
||||
#endif
|
||||
Yap_ErrorMessage = Yap_ErrorSay;
|
||||
Yap_Error_TYPE = etype;
|
||||
return -1;
|
||||
}
|
||||
|
||||
#if SHORT_INTS
|
||||
|
||||
#ifdef M_WILLIAMS
|
||||
#include <fcntl.h>
|
||||
#endif
|
||||
|
||||
static void
|
||||
static int
|
||||
myread(int fd, char *buff, Int len)
|
||||
{
|
||||
while (len > 16000) {
|
||||
int nchars = read(fd, buff, 16000);
|
||||
if (nchars <= 0)
|
||||
Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
|
||||
len -= 16000;
|
||||
buff += 16000;
|
||||
while (len > 0) {
|
||||
int nchars = read(fd, buff, len);
|
||||
if (nchars < 0) {
|
||||
return do_system_error(PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM, "bad read on saved state", );
|
||||
}
|
||||
len -= nchars;
|
||||
buff += nchars;
|
||||
}
|
||||
read(fd, buff, (unsigned) len);
|
||||
return len;
|
||||
}
|
||||
|
||||
static void
|
||||
@ -185,17 +207,18 @@ mywrite(int fd, char *buff, Int len)
|
||||
#else /* SHORT_INTS */
|
||||
|
||||
inline static
|
||||
void myread(int fd, char *buffer, Int len) {
|
||||
int myread(int fd, char *buffer, Int len) {
|
||||
int nread;
|
||||
|
||||
while (len > 0) {
|
||||
nread = read(fd, buffer, (int)len);
|
||||
if (nread < 1) {
|
||||
Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
|
||||
return do_system_error(PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM,"bad read on saved state");
|
||||
}
|
||||
buffer += nread;
|
||||
len -= nread;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
inline static
|
||||
@ -204,8 +227,9 @@ void mywrite(int fd, char *buff, Int len) {
|
||||
|
||||
while (len > 0) {
|
||||
nwritten = (Int)write(fd, buff, (int)len);
|
||||
if (nwritten == -1) {
|
||||
Yap_Error(SYSTEM_ERROR,TermNil,"write error while saving");
|
||||
if (nwritten < 0) {
|
||||
Yap_ErrorMessage = "bad write on saved state";
|
||||
Yap_Error(SYSTEM_ERROR,TermNil,Yap_ErrorMessage);
|
||||
}
|
||||
buff += nwritten;
|
||||
len -= nwritten;
|
||||
@ -263,12 +287,12 @@ open_file(char *my_file, int flag)
|
||||
#endif /* M_WILLIAMS */
|
||||
{
|
||||
splfild = 0; /* We do not have an open file */
|
||||
return(-1);
|
||||
return -1;
|
||||
}
|
||||
#ifdef undf0
|
||||
fprintf(errout, "Opened file %s\n", my_file);
|
||||
#endif
|
||||
return(splfild);
|
||||
return splfild;
|
||||
}
|
||||
|
||||
static void
|
||||
@ -311,12 +335,12 @@ get_header_cell(void)
|
||||
int count = 0, n;
|
||||
while (count < sizeof(CELL)) {
|
||||
if ((n = read(splfild, &l, sizeof(CELL)-count)) < 0) {
|
||||
Yap_ErrorMessage = "corrupt saved state (too short)";
|
||||
return(0L);
|
||||
do_system_error(PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM,"failed to read saved state header");
|
||||
return 0L;
|
||||
}
|
||||
count += n;
|
||||
}
|
||||
return(l);
|
||||
return l;
|
||||
}
|
||||
|
||||
/* gets a pointer to cell from a file */
|
||||
@ -524,7 +548,7 @@ do_save(int mode) {
|
||||
Term t1 = Deref(ARG1);
|
||||
if (!Yap_GetName(Yap_FileNameBuf, YAP_FILENAME_MAX, t1)) {
|
||||
Yap_Error(TYPE_ERROR_LIST,t1,"save/1");
|
||||
return(FALSE);
|
||||
return FALSE;
|
||||
}
|
||||
Yap_CloseStreams(TRUE);
|
||||
if ((splfild = open_file(Yap_FileNameBuf, O_WRONLY | O_CREAT)) < 0) {
|
||||
@ -576,7 +600,7 @@ static Int
|
||||
p_save_program(void)
|
||||
{
|
||||
which_save = 0;
|
||||
return(do_save(DO_ONLY_CODE));
|
||||
return do_save(DO_ONLY_CODE);
|
||||
}
|
||||
|
||||
/* Now, to restore the saved code */
|
||||
@ -593,8 +617,8 @@ check_header(CELL *info, CELL *ATrail, CELL *AStack, CELL *AHeap)
|
||||
/* skip the first line */
|
||||
do {
|
||||
if (read(splfild, pp, 1) < 0) {
|
||||
Yap_ErrorMessage = "corrupt saved state (failed to read first line)";
|
||||
return(FAIL_RESTORE);
|
||||
do_system_error(PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM,"failed to scan first line from saved state");
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
} while (pp[0] != 1);
|
||||
/* now check the version */
|
||||
@ -603,97 +627,126 @@ check_header(CELL *info, CELL *ATrail, CELL *AStack, CELL *AHeap)
|
||||
int count = 0, n, to_read = Unsigned(strlen(msg) + 1);
|
||||
while (count < to_read) {
|
||||
if ((n = read(splfild, pp, to_read-count)) < 0) {
|
||||
Yap_ErrorMessage = "corrupt saved state (header too short)";
|
||||
return(FAIL_RESTORE);
|
||||
do_system_error(PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM,"failed to scan version info from saved state");
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
count += n;
|
||||
}
|
||||
}
|
||||
if (pp[0] != 'Y' && pp[1] != 'A' && pp[0] != 'P') {
|
||||
Yap_ErrorMessage = "corrupt saved state (should say YAP)";
|
||||
return(FAIL_RESTORE);
|
||||
Yap_ErrorMessage = Yap_ErrorSay;
|
||||
strncpy(Yap_ErrorMessage, "saved state ", MAX_ERROR_MSG_SIZE);
|
||||
strncat(Yap_ErrorMessage, Yap_FileNameBuf, MAX_ERROR_MSG_SIZE);
|
||||
strncat(Yap_ErrorMessage, " failed to match `YAP\'", MAX_ERROR_MSG_SIZE);
|
||||
Yap_Error_TYPE = CONSISTENCY_ERROR;
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
if (strcmp(pp, msg) != 0) {
|
||||
Yap_ErrorMessage = "corrupt saved state (different version of YAP)";
|
||||
return(FAIL_RESTORE);
|
||||
Yap_ErrorMessage = Yap_ErrorSay;
|
||||
strncpy(Yap_ErrorMessage, "saved state ", MAX_ERROR_MSG_SIZE);
|
||||
strncat(Yap_ErrorMessage, Yap_FileNameBuf, MAX_ERROR_MSG_SIZE);
|
||||
strncat(Yap_ErrorMessage, " failed to match version ID", MAX_ERROR_MSG_SIZE);
|
||||
Yap_Error_TYPE = CONSISTENCY_ERROR;
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
/* check info on header */
|
||||
/* ignore info on saved state */
|
||||
*info = get_header_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
/* check the restore mode */
|
||||
mode = get_header_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
if (mode != DO_EVERYTHING && mode != DO_ONLY_CODE) {
|
||||
Yap_ErrorMessage = "corrupt saved state (bad type)";
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
/* ignore info on stacks size */
|
||||
*AHeap = get_header_cell();
|
||||
if (Yap_ErrorMessage) {
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
*AStack = get_header_cell();
|
||||
if (Yap_ErrorMessage) {
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
*ATrail = get_header_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
if (Yap_ErrorMessage) {
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
/* now, check whether we got enough enough space to load the
|
||||
saved space */
|
||||
hp_size = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
while (Yap_HeapBase != NULL &&
|
||||
hp_size > Unsigned(HeapLim) - Unsigned(Yap_HeapBase)) {
|
||||
if(!Yap_growheap(FALSE, hp_size, NULL)) {
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
}
|
||||
if (mode == DO_EVERYTHING) {
|
||||
lc_size = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
gb_size=get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
if (Yap_HeapBase != NULL && lc_size+gb_size > Unsigned(Yap_LocalBase) - Unsigned(Yap_GlobalBase)) {
|
||||
Yap_ErrorMessage = "not enough stack space for restore";
|
||||
return(FAIL_RESTORE);
|
||||
if (Yap_ErrorMessage != NULL)
|
||||
Yap_ErrorMessage = "could not allocate enough stack space";
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
if (Yap_HeapBase != NULL && (tr_size = get_cell()) > Unsigned(Yap_TrailTop) - Unsigned(Yap_TrailBase)) {
|
||||
Yap_ErrorMessage = "not enough trail space for restore";
|
||||
return(FAIL_RESTORE);
|
||||
if (Yap_ErrorMessage != NULL)
|
||||
Yap_ErrorMessage = "could not allocate enough trail space";
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
} else {
|
||||
/* skip cell size */
|
||||
get_header_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
get_header_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
get_header_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
return(mode);
|
||||
}
|
||||
|
||||
/* Gets the state of the heap, and evaluates the related variables */
|
||||
static void
|
||||
static int
|
||||
get_heap_info(void)
|
||||
{
|
||||
OldHeapBase = (ADDR) get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
OldHeapTop = (ADDR) get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
OldHeapUsed = (Int) get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
FreeBlocks = (BlockHeader *) get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
AuxSp = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
AuxTop = (ADDR)get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
HDiff = Unsigned(Yap_HeapBase) - Unsigned(OldHeapBase);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Gets the register array */
|
||||
/* Saves the old bases for the work areas */
|
||||
/* and evaluates the difference from the old areas to the new ones */
|
||||
static void
|
||||
static int
|
||||
get_regs(int flag)
|
||||
{
|
||||
CELL *NewGlobalBase = (CELL *)Yap_GlobalBase;
|
||||
@ -702,46 +755,95 @@ get_regs(int flag)
|
||||
|
||||
/* Get regs */
|
||||
compile_arrays = (int)get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (flag == DO_EVERYTHING) {
|
||||
CP = (yamop *)get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
ENV = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
ASP = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
/* N = get_cell(); */
|
||||
H0 = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
LCL0 = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
H = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
HB = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
B = (choiceptr)get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
TR = (tr_fr_ptr)get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
YENV = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
S = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
P = (yamop *)get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
CreepFlag = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
#ifdef COROUTINING
|
||||
DelayedVars = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
CurrentModule = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (flag == DO_EVERYTHING) {
|
||||
#ifdef COROUTINING
|
||||
WokenGoals = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
#endif
|
||||
#ifdef DEPTH_LIMIT
|
||||
DEPTH = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
/* Get the old bases */
|
||||
OldXREGS = get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
which_save = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
XDiff = (CELL)XREGS - (CELL)OldXREGS;
|
||||
get_heap_info();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (get_heap_info() < 0)
|
||||
return -1;
|
||||
if (flag == DO_EVERYTHING) {
|
||||
ARG1 = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (which_save == 2) {
|
||||
ARG2 = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
}
|
||||
/* get old trail base */
|
||||
OldTrailBase = (ADDR)get_cellptr();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
/* Save the old register where we can easily access them */
|
||||
OldASP = ASP;
|
||||
OldLCL0 = LCL0;
|
||||
@ -754,54 +856,71 @@ get_regs(int flag)
|
||||
Yap_GlobalBase = (ADDR)NewGlobalBase;
|
||||
LCL0 = NewLCL0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Get the old opcodes and place them in a hash table */
|
||||
static void
|
||||
static int
|
||||
get_insts(OPCODE old_ops[])
|
||||
{
|
||||
myread(splfild, (char *)old_ops, sizeof(OPCODE)*(_std_top+1));
|
||||
return myread(splfild, (char *)old_ops, sizeof(OPCODE)*(_std_top+1));
|
||||
}
|
||||
|
||||
/* Get the old atoms hash table */
|
||||
static void
|
||||
static int
|
||||
get_hash(void)
|
||||
{
|
||||
myread(splfild, Yap_chtype , NUMBER_OF_CHARS);
|
||||
return myread(splfild, Yap_chtype , NUMBER_OF_CHARS);
|
||||
}
|
||||
|
||||
/* Copy all of the old code to the new Heap */
|
||||
static void
|
||||
static int
|
||||
CopyCode(void)
|
||||
{
|
||||
#if defined(YAPOR) || defined(TABLING)
|
||||
/* skip the local and global data structures */
|
||||
CELL j = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (j != Unsigned(&GLOBAL) - Unsigned(Yap_HeapBase)) {
|
||||
Yap_Error(FATAL_ERROR,TermNil,"bad saved state (code space size does not match)");
|
||||
Yap_ErrorMessage = "code space size does not match saved state";
|
||||
return -1;
|
||||
}
|
||||
myread(splfild, (char *) Yap_HeapBase, j);
|
||||
if (myread(splfild, (char *) Yap_HeapBase, j) < 0)
|
||||
return -1;
|
||||
#ifdef USE_HEAP
|
||||
j = get_cell();
|
||||
myread(splfild, (char *) &HashChain, j);
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (myread(splfild, (char *) &HashChain, j) < 0)
|
||||
return -1;
|
||||
#else
|
||||
j = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (j != Unsigned(BaseAllocArea) - Unsigned(&HashChain)) {
|
||||
Yap_Error(FATAL_ERROR,TermNil,"bad saved state (Base to Hash does not match)");
|
||||
Yap_ErrorMessage = "Base to Hash does not match saved state";
|
||||
return -1;
|
||||
}
|
||||
myread(splfild, (char *) &HashChain, j);
|
||||
if (myread(splfild, (char *) &HashChain, j) < 0)
|
||||
return -1;
|
||||
j = get_cell();
|
||||
myread(splfild, (char *) TopAllocBlockArea, j);
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
if (myread(splfild, (char *) TopAllocBlockArea, j) < 0)
|
||||
return -1;
|
||||
#endif
|
||||
#else
|
||||
myread(splfild, (char *) Yap_HeapBase,
|
||||
(Unsigned(OldHeapTop) - Unsigned(OldHeapBase)));
|
||||
if (myread(splfild, (char *) Yap_HeapBase,
|
||||
(Unsigned(OldHeapTop) - Unsigned(OldHeapBase))) < 0)
|
||||
return -1;
|
||||
#endif /* YAPOR || TABLING */
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Copy the local and global stack and also the trail to their new home */
|
||||
/* In REGS we still have nonadjusted values !! */
|
||||
static void
|
||||
static int
|
||||
CopyStacks(void)
|
||||
{
|
||||
Int j;
|
||||
@ -809,16 +928,20 @@ CopyStacks(void)
|
||||
|
||||
j = Unsigned(OldLCL0) - Unsigned(ASP);
|
||||
NewASP = (char *) (Unsigned(ASP) + (Unsigned(LCL0) - Unsigned(OldLCL0)));
|
||||
myread(splfild, (char *) NewASP, j);
|
||||
if (myread(splfild, (char *) NewASP, j) < 0)
|
||||
return -1;
|
||||
j = Unsigned(H) - Unsigned(OldGlobalBase);
|
||||
myread(splfild, (char *) Yap_GlobalBase, j);
|
||||
if (myread(splfild, (char *) Yap_GlobalBase, j) < 0)
|
||||
return -1;
|
||||
j = Unsigned(TR) - Unsigned(OldTrailBase);
|
||||
myread(splfild, Yap_TrailBase, j);
|
||||
if (myread(splfild, Yap_TrailBase, j))
|
||||
return -1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Copy the local and global stack and also the trail to their new home */
|
||||
/* In REGS we still have nonadjusted values !! */
|
||||
static void
|
||||
static int
|
||||
CopyTrailEntries(void)
|
||||
{
|
||||
CELL entry, *Entries;
|
||||
@ -826,31 +949,44 @@ CopyTrailEntries(void)
|
||||
Entries = (CELL *)Yap_TrailBase;
|
||||
do {
|
||||
*Entries++ = entry = get_cell();
|
||||
if (Yap_ErrorMessage)
|
||||
return -1;
|
||||
} while ((CODEADDR)entry != NULL);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* get things which are saved in the file */
|
||||
static void
|
||||
static int
|
||||
get_coded(int flag, OPCODE old_ops[])
|
||||
{
|
||||
char my_end_msg[256];
|
||||
|
||||
get_regs(flag);
|
||||
get_insts(old_ops);
|
||||
get_hash();
|
||||
CopyCode();
|
||||
if (get_regs(flag) < 0)
|
||||
return -1;
|
||||
if (get_insts(old_ops) < 0)
|
||||
return -1;
|
||||
if (get_hash() < 0)
|
||||
return -1;
|
||||
if (CopyCode() < 0)
|
||||
return -1;
|
||||
switch (flag) {
|
||||
case DO_EVERYTHING:
|
||||
CopyStacks();
|
||||
if (CopyStacks() < 0)
|
||||
return -1;
|
||||
break;
|
||||
case DO_ONLY_CODE:
|
||||
CopyTrailEntries();
|
||||
if (CopyTrailEntries() < 0)
|
||||
return -1;
|
||||
break;
|
||||
}
|
||||
/* Check CRC */
|
||||
myread(splfild, my_end_msg, 256);
|
||||
if (strcmp(end_msg,my_end_msg) != 0)
|
||||
Yap_Error(FATAL_ERROR,TermNil,"corrupt saved state (bad trailing CRC)");
|
||||
if (myread(splfild, my_end_msg, 256) < 0)
|
||||
return -1;
|
||||
if (strcmp(end_msg,my_end_msg) != 0) {
|
||||
Yap_ErrorMessage = "bad trailing CRC in saved state";
|
||||
return -1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* restore some heap registers */
|
||||
@ -1278,10 +1414,22 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
|
||||
Yap_ErrorMessage = NULL;
|
||||
if (inpf == NULL)
|
||||
inpf = StartUpFile;
|
||||
#if __simplescalar__
|
||||
/* does not implement getcwd */
|
||||
strncpy(Yap_FileNameBuf,yap_pwd,YAP_FILENAME_MAX);
|
||||
#elif HAVE_GETCWD
|
||||
if (getcwd (Yap_FileNameBuf, YAP_FILENAME_MAX) == NULL)
|
||||
Yap_FileNameBuf[0] = '\0';
|
||||
#else
|
||||
if (getwd (Yap_FileNameBuf) == NULL)
|
||||
Yap_FileNameBuf[0] = '\0';
|
||||
#endif
|
||||
strncat(Yap_FileNameBuf, "/", YAP_FILENAME_MAX);
|
||||
strncat(Yap_FileNameBuf, inpf, YAP_FILENAME_MAX);
|
||||
if (inpf != NULL && (splfild = open_file(inpf, O_RDONLY)) > 0) {
|
||||
if ((mode = commit_to_saved_state(inpf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) {
|
||||
Yap_ErrorMessage = NULL;
|
||||
return(mode);
|
||||
return mode;
|
||||
}
|
||||
}
|
||||
if (!Yap_dir_separator(inpf[0]) && !Yap_volume_header(inpf)) {
|
||||
@ -1294,7 +1442,7 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
|
||||
if ((splfild = open_file(Yap_FileNameBuf, O_RDONLY)) > 0) {
|
||||
if ((mode = commit_to_saved_state(Yap_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) {
|
||||
Yap_ErrorMessage = NULL;
|
||||
return(mode);
|
||||
return mode;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1306,7 +1454,7 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
|
||||
if ((splfild = open_file(Yap_FileNameBuf, O_RDONLY)) > 0) {
|
||||
if ((mode = commit_to_saved_state(Yap_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) {
|
||||
Yap_ErrorMessage = NULL;
|
||||
return(mode);
|
||||
return mode;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1324,12 +1472,10 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
|
||||
}
|
||||
/* could not open file */
|
||||
if (Yap_ErrorMessage == NULL) {
|
||||
Yap_Error(SYSTEM_ERROR,TermNil,"could not open %s,",inpf);
|
||||
} else {
|
||||
Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
|
||||
strncpy(Yap_FileNameBuf, inpf, YAP_FILENAME_MAX);
|
||||
do_system_error(PERMISSION_ERROR_OPEN_SOURCE_SINK,"could not open saved state");
|
||||
}
|
||||
Yap_ErrorMessage = NULL;
|
||||
return(FAIL_RESTORE);
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
|
||||
static void
|
||||
@ -1403,11 +1549,10 @@ Yap_SavedInfo(char *FileName, char *YapLibDir, CELL *ATrail, CELL *AStack, CELL
|
||||
int mode;
|
||||
|
||||
mode = OpenRestore(FileName, YapLibDir, &MyState, &MyTrail, &MyStack, &MyHeap);
|
||||
close_file();
|
||||
if (mode == FAIL_RESTORE) {
|
||||
Yap_ErrorMessage = NULL;
|
||||
return(0);
|
||||
return -1;
|
||||
}
|
||||
close_file();
|
||||
if (! *AHeap)
|
||||
*AHeap = MyHeap / 1024;
|
||||
if (mode != DO_ONLY_CODE && *AStack)
|
||||
@ -1481,7 +1626,8 @@ Restore(char *s, char *lib_dir)
|
||||
return(FALSE);
|
||||
Yap_ShutdownLoadForeign();
|
||||
in_limbo = TRUE;
|
||||
get_coded(restore_mode, old_ops);
|
||||
if (get_coded(restore_mode, old_ops) < 0)
|
||||
return FAIL_RESTORE;
|
||||
restore_regs(restore_mode);
|
||||
in_limbo = FALSE;
|
||||
/*#endif*/
|
||||
@ -1518,7 +1664,7 @@ Restore(char *s, char *lib_dir)
|
||||
if (which_save == 2) {
|
||||
Yap_unify(ARG2, MkIntTerm(0));
|
||||
}
|
||||
return(restore_mode);
|
||||
return restore_mode;
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
15
C/stdpreds.c
15
C/stdpreds.c
@ -11,8 +11,12 @@
|
||||
* File: stdpreds.c *
|
||||
* comments: General-purpose C implemented system predicates *
|
||||
* *
|
||||
* Last rev: $Date: 2005-03-01 22:25:09 $,$Author: vsc $ *
|
||||
* Last rev: $Date: 2005-03-02 18:35:46 $,$Author: vsc $ *
|
||||
* $Log: not supported by cvs2svn $
|
||||
* Revision 1.83 2005/03/01 22:25:09 vsc
|
||||
* fix pruning bug
|
||||
* make DL_MALLOC less enthusiastic about walking through buckets.
|
||||
*
|
||||
* Revision 1.82 2005/02/21 16:50:04 vsc
|
||||
* amd64 fixes
|
||||
* library fixes
|
||||
@ -1063,7 +1067,14 @@ p_name(void)
|
||||
}
|
||||
if (IsAtomTerm(t) && AtomOfTerm(t) == AtomNil) {
|
||||
if ((NewT = get_num(String)) == TermNil) {
|
||||
NewT = MkAtomTerm(Yap_LookupAtom(String));
|
||||
Atom at;
|
||||
while ((at = Yap_LookupAtom(String)) == NIL) {
|
||||
if (!Yap_growheap(FALSE, 0, NULL)) {
|
||||
Yap_Error(OUT_OF_HEAP_ERROR, TermNil, Yap_ErrorMessage);
|
||||
return(FALSE);
|
||||
}
|
||||
}
|
||||
NewT = MkAtomTerm(at);
|
||||
}
|
||||
return Yap_unify_constant(ARG1, NewT);
|
||||
} else {
|
||||
|
||||
@ -287,14 +287,14 @@ parse_yap_arguments(int argc, char *argv[], YAP_init_args *iap)
|
||||
host = *++argv;
|
||||
argc--;
|
||||
if (host == NULL || host[0] == '-')
|
||||
YAP_Error("sockets must receive host to connect to");
|
||||
YAP_Error(0,0L,"sockets must receive host to connect to");
|
||||
p1 = *++argv;
|
||||
argc--;
|
||||
if (p1 == NULL || p1[0] == '-')
|
||||
YAP_Error("sockets must receive port to connect to");
|
||||
YAP_Error(0,0L,"sockets must receive port to connect to");
|
||||
port = strtol(p1, &ptr, 10);
|
||||
if (ptr == NULL || ptr[0] != '\0')
|
||||
YAP_Error("port argument to socket must be a number");
|
||||
YAP_Error(0,0L,"port argument to socket must be a number");
|
||||
YAP_InitSocks(host,port);
|
||||
}
|
||||
break;
|
||||
@ -446,6 +446,8 @@ init_standard_system(int argc, char *argv[], YAP_init_args *iap)
|
||||
iap->PrologShouldHandleInterrupts = TRUE;
|
||||
iap->Argc = argc;
|
||||
iap->Argv = argv;
|
||||
iap->ErrorNo = 0;
|
||||
iap->ErrorCause = NULL;
|
||||
|
||||
BootMode = parse_yap_arguments(argc,argv,iap);
|
||||
|
||||
@ -466,10 +468,14 @@ init_standard_system(int argc, char *argv[], YAP_init_args *iap)
|
||||
/* init memory */
|
||||
if (BootMode == YAP_BOOT_FROM_PROLOG ||
|
||||
BootMode == YAP_FULL_BOOT_FROM_PROLOG) {
|
||||
YAP_Init(iap);
|
||||
BootMode = YAP_Init(iap);
|
||||
} else {
|
||||
BootMode = YAP_Init(iap);
|
||||
}
|
||||
if (iap->ErrorNo) {
|
||||
/* boot failed */
|
||||
YAP_Error(iap->ErrorNo,0L,iap->ErrorCause);
|
||||
}
|
||||
return(BootMode);
|
||||
}
|
||||
|
||||
@ -552,7 +558,7 @@ main (int argc, char **argv)
|
||||
YAP_init_args init_args;
|
||||
|
||||
BootMode = init_standard_system(argc, argv, &init_args);
|
||||
if (BootMode == YAP_BOOT_FROM_SAVED_ERROR) {
|
||||
if (BootMode == YAP_BOOT_ERROR) {
|
||||
fprintf(stderr,"[ FATAL ERROR: could not find saved state ]\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
26
docs/yap.tex
26
docs/yap.tex
@ -14029,7 +14029,7 @@ program contains two facts for the procedure @t{b}:
|
||||
|
||||
int
|
||||
main(int argc, char *argv[]) @{
|
||||
if (YAP_FastInit("saved_state") == YAP_BOOT_FROM_SAVED_ERROR)
|
||||
if (YAP_FastInit("saved_state") == YAP_BOOT_ERROR)
|
||||
exit(1);
|
||||
if (YAP_RunGoal(YAP_MkAtomTerm(YAP_LookupAtom("do")))) @{
|
||||
printf("Success\n");
|
||||
@ -14091,14 +14091,19 @@ Initialize a copy of YAP from @var{SavedState}. The copy is
|
||||
monolithic and currently must be loaded at the same address where it was
|
||||
saved. @code{YAP_FastInit} is a simpler version of @code{YAP_Init}.
|
||||
|
||||
@item YAP_Init(@code{char *} @var{SavedState}, @code{int}
|
||||
@var{HeapSize}, @code{int} @var{StackSize}, @code{int}
|
||||
@var{TrailSize}, @code{int} @var{NumberofWorkers}, @code{int}
|
||||
@item YAP_Init(@var{InitInfo})
|
||||
@findex YAP_Init/1
|
||||
Initialize YAP. The arguments are in a @code{C}
|
||||
structure of type @code{YAP_init_args}.
|
||||
|
||||
The fields of @var{InitInfo} are @code{char *} @var{SavedState},
|
||||
@code{int} @var{HeapSize}, @code{int} @var{StackSize}, @code{int}
|
||||
@var{TrailSize}, @code{int} @var{NumberofWorkers}, @code{int}
|
||||
@var{SchedulerLoop}, @code{int} @var{DelayedReleaseLoad}, @code{int}
|
||||
@var{argc}, @code{char **} @var{argv})
|
||||
@findex YAP_Init/9
|
||||
Initialize YAP. In the future the arguments as a single @code{C}
|
||||
structure.
|
||||
@var{argc}, @code{char **} @var{argv}, @code{int} @var{ErrorNo}, and
|
||||
@code{char *} @var{ErrorCause}. The function returns an integer, which
|
||||
indicates the current status. If the result is @code{YAP_BOOT_ERROR}
|
||||
booting failed.
|
||||
|
||||
If @var{SavedState} is not NULL, try to open and restore the file
|
||||
@var{SavedState}. Initially YAP will search in the current directory. If
|
||||
@ -14120,6 +14125,11 @@ The argument count @var{argc} and string of arguments @var{argv}
|
||||
arguments are to be passed to user programs as the arguments used to
|
||||
call YAP.
|
||||
|
||||
If booting failed you may consult @code{ErrorNo} and @code{ErrorCause}
|
||||
for the cause of the error, or call
|
||||
@code{YAP_Error(ErrorNo,0L,ErrorCause)} to do default processing.
|
||||
|
||||
|
||||
@item @code{void} YAP_PutValue(@code{Atom} @var{at}, @code{Term} @var{value})
|
||||
@findex YAP_PutValue/2
|
||||
Associate the term @var{value} with the atom @var{at}. The term
|
||||
|
||||
@ -24,6 +24,10 @@
|
||||
|
||||
#include "yap_structs.h"
|
||||
|
||||
#if HAVE_STDARG_H
|
||||
#include <stdarg.h>
|
||||
#endif
|
||||
|
||||
#ifndef _yap_c_interface_h
|
||||
|
||||
#define _yap_c_interface_h 1
|
||||
@ -220,8 +224,8 @@ extern X_API YAP_Bool PROTO(YAP_GoalHasException,(YAP_Term *));
|
||||
/* int YAP_Reset(void) */
|
||||
extern X_API void PROTO(YAP_Reset,(void));
|
||||
|
||||
/* void YAP_Error(char *) */
|
||||
extern X_API void PROTO(YAP_Error,(char *));
|
||||
/* void YAP_Error(int, YAP_Term, char *,...) */
|
||||
extern X_API void PROTO(YAP_Error,(int, YAP_Term, char *, ...));
|
||||
|
||||
/* YAP_Term YAP_Read(int (*)(void)) */
|
||||
extern X_API YAP_Term PROTO(YAP_Read,(int (*)(void)));
|
||||
|
||||
@ -53,7 +53,7 @@ typedef struct AtomEntry *YAP_Atom;
|
||||
#define YAP_BOOT_FROM_SAVED_CODE 1
|
||||
#define YAP_BOOT_FROM_SAVED_STACKS 2
|
||||
#define YAP_FULL_BOOT_FROM_PROLOG 4
|
||||
#define YAP_BOOT_FROM_SAVED_ERROR -1
|
||||
#define YAP_BOOT_ERROR -1
|
||||
|
||||
#define YAP_WRITE_QUOTED 0
|
||||
#define YAP_WRITE_HANDLE_VARS 1
|
||||
@ -98,6 +98,10 @@ typedef struct {
|
||||
int Argc;
|
||||
/* array of arguments as seen by Prolog */
|
||||
char **Argv;
|
||||
/* errornumber */
|
||||
int ErrorNo;
|
||||
/* errorstring */
|
||||
char *ErrorCause;
|
||||
} YAP_init_args;
|
||||
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
* File: Yap.h.m4 *
|
||||
* mods: *
|
||||
* comments: main header file for YAP *
|
||||
* version: $Id: Yap.h.m4,v 1.79 2005-02-08 18:38:02 vsc Exp $ *
|
||||
* version: $Id: Yap.h.m4,v 1.80 2005-03-02 18:35:49 vsc Exp $ *
|
||||
*************************************************************************/
|
||||
|
||||
#include "config.h"
|
||||
@ -706,11 +706,11 @@ and RefOfTerm(t) : Term -> DBRef = ...
|
||||
|
||||
extern ADDR Yap_HeapBase;
|
||||
|
||||
#define MAX_ERROR_MSG_SIZE 256
|
||||
|
||||
/* This is ok for Linux, should be ok for everyone */
|
||||
#define YAP_FILENAME_MAX 1024
|
||||
|
||||
#define MAX_ERROR_MSG_SIZE YAP_FILENAME_MAX
|
||||
|
||||
#ifdef THREADS
|
||||
typedef struct thread_globs {
|
||||
ADDR local_base;
|
||||
|
||||
Reference in New Issue
Block a user