Fixes, mostly to the biting o
This commit is contained in:
Vitor Santos Costa
parent
645b2c7d93
commit
3061844c95
724
C/c_interface.c
724
C/c_interface.c
File diff suppressed because it is too large
Load Diff
25
C/load_dl.c
25
C/load_dl.c
|
|
@ -167,18 +167,10 @@ static Int LoadForeign(StringList
|
|||
|
||||
while (libs) {
|
||||
const char *file = AtomName(libs->name);
|
||||
if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true,
|
||||
true)) {
|
||||
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
|
||||
/* use LD_LIBRARY_PATH */
|
||||
strncpy(LOCAL_ErrorMessage, (char *)AtomName(libs->name),
|
||||
YAP_FILENAME_MAX);
|
||||
}
|
||||
|
||||
#ifdef __osf__
|
||||
if ((libs->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY)) == NULL)
|
||||
#else
|
||||
if ((libs->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY | RTLD_GLOBAL)) ==
|
||||
if ((libs->handle = dlopen(file, RTLD_LAZY | RTLD_GLOBAL)) ==
|
||||
NULL)
|
||||
#endif
|
||||
{
|
||||
|
|
@ -195,20 +187,9 @@ static Int LoadForeign(StringList
|
|||
/* load libraries first so that their symbols are available to
|
||||
other routines */
|
||||
const char *file = AtomName(ofiles->name);
|
||||
if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true,
|
||||
true)) {
|
||||
if (LOCAL_ErrorMessage == NULL) {
|
||||
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
|
||||
strcpy(LOCAL_ErrorMessage,
|
||||
"%% Trying to open non-existing file in LoadForeign");
|
||||
}
|
||||
}
|
||||
#ifdef __osf__
|
||||
if ((ofiles->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY)) == NULL)
|
||||
#else
|
||||
if ((ofiles->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY | RTLD_GLOBAL)) ==
|
||||
|
||||
if ((ofiles->handle = dlopen(file, RTLD_LAZY | RTLD_GLOBAL)) ==
|
||||
NULL)
|
||||
#endif
|
||||
{
|
||||
if (LOCAL_ErrorMessage == NULL) {
|
||||
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
|
||||
|
|
|
|||
4
C/qlyr.c
4
C/qlyr.c
|
|
@ -1097,10 +1097,10 @@ static Int qload_program(USES_REGS1) {
|
|||
return true;
|
||||
}
|
||||
|
||||
YAP_file_type_t Yap_Restore(const char *s, const char *lib_dir) {
|
||||
YAP_file_type_t Yap_Restore(const char *s) {
|
||||
CACHE_REGS
|
||||
|
||||
FILE *stream = Yap_OpenRestore(s, lib_dir);
|
||||
FILE *stream = Yap_OpenRestore(s);
|
||||
if (!stream)
|
||||
return -1;
|
||||
GLOBAL_RestoreFile = s;
|
||||
|
|
|
|||
48
C/save.c
48
C/save.c
|
|
@ -87,7 +87,7 @@ void initIO(void);
|
|||
|
||||
static int myread(FILE *, char *, Int);
|
||||
static Int mywrite(FILE *, char *, Int);
|
||||
static FILE *open_file(char *, int);
|
||||
static FILE *open_file(const char *, int);
|
||||
static int close_file(void);
|
||||
static Int putout(CELL);
|
||||
static Int putcellptr(CELL *);
|
||||
|
|
@ -123,7 +123,7 @@ static void restore_heap(void);
|
|||
static void ShowAtoms(void);
|
||||
static void ShowEntries(PropEntry *);
|
||||
#endif
|
||||
static int OpenRestore(const char *, const char *, CELL *, CELL *, CELL *,
|
||||
static int OpenRestore(const char *, CELL *, CELL *, CELL *,
|
||||
CELL *, FILE **);
|
||||
static void CloseRestore(void);
|
||||
#ifndef _WIN32
|
||||
|
|
@ -233,7 +233,7 @@ static Int OldHeapUsed;
|
|||
static CELL which_save;
|
||||
|
||||
/* Open a file to read or to write */
|
||||
static FILE *open_file(char *my_file, int flag) {
|
||||
static FILE *open_file(const char *my_file, int flag) {
|
||||
FILE *splfild;
|
||||
char flags[6];
|
||||
int i = 0;
|
||||
|
|
@ -1307,10 +1307,11 @@ static void ShowAtoms() {
|
|||
|
||||
#include <stdio.h>
|
||||
|
||||
static int commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail,
|
||||
static int commit_to_saved_state(const char *s, CELL *Astate, CELL *ATrail,
|
||||
CELL *AStack, CELL *AHeap) {
|
||||
CACHE_REGS
|
||||
int mode;
|
||||
char tmp[YAP_FILENAME_MAX+1];
|
||||
|
||||
if ((mode = check_header(Astate, ATrail, AStack, AHeap PASS_REGS)) ==
|
||||
FAIL_RESTORE)
|
||||
|
|
@ -1318,9 +1319,8 @@ static int commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail,
|
|||
LOCAL_PrologMode = BootMode;
|
||||
if (Yap_HeapBase) {
|
||||
if (falseGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG) && !silentMode()) {
|
||||
Yap_findFile(s, NULL, NULL, LOCAL_FileNameBuf2, true, YAP_QLY, true,
|
||||
true);
|
||||
fprintf(stderr, "%% Restoring file %s\n", LOCAL_FileNameBuf2);
|
||||
Yap_AbsoluteFile(s, tmp, true);
|
||||
fprintf(stderr, "%% Restoring file %s\n", tmp);
|
||||
}
|
||||
Yap_CloseStreams(TRUE);
|
||||
}
|
||||
|
|
@ -1333,7 +1333,7 @@ static int commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail,
|
|||
return mode;
|
||||
}
|
||||
|
||||
static int try_open(char *inpf, CELL *Astate, CELL *ATrail, CELL *AStack,
|
||||
static int try_open(const char *inpf, CELL *Astate, CELL *ATrail, CELL *AStack,
|
||||
CELL *AHeap, FILE **streamp) {
|
||||
int mode;
|
||||
|
||||
|
|
@ -1355,18 +1355,13 @@ static int try_open(char *inpf, CELL *Astate, CELL *ATrail, CELL *AStack,
|
|||
return mode;
|
||||
}
|
||||
|
||||
static int OpenRestore(const char *inpf, const char *YapLibDir, CELL *Astate,
|
||||
static int OpenRestore(const char *fname, CELL *Astate,
|
||||
CELL *ATrail, CELL *AStack, CELL *AHeap,
|
||||
FILE **streamp) {
|
||||
CACHE_REGS
|
||||
|
||||
int mode;
|
||||
char fname[YAP_FILENAME_MAX + 1];
|
||||
|
||||
if (!Yap_findFile(inpf, YAP_STARTUP, YapLibDir, fname, true, YAP_QLY,
|
||||
true, true))
|
||||
return FAIL_RESTORE;
|
||||
if (fname[0] && (mode = try_open(fname, Astate, ATrail, AStack, AHeap,
|
||||
if (fname && fname[0] && (mode = try_open(fname, Astate, ATrail, AStack, AHeap,
|
||||
streamp)) != FAIL_RESTORE) {
|
||||
setAtomicGlobalPrologFlag(RESOURCE_DATABASE_FLAG,
|
||||
MkAtomTerm(Yap_LookupAtom(fname)));
|
||||
|
|
@ -1378,22 +1373,19 @@ static int OpenRestore(const char *inpf, const char *YapLibDir, CELL *Astate,
|
|||
do_SYSTEM_ERROR_INTERNAL(PERMISSION_ERROR_OPEN_SOURCE_SINK,
|
||||
"incorrect saved state ");
|
||||
} else {
|
||||
strncpy(LOCAL_FileNameBuf, inpf, YAP_FILENAME_MAX - 1);
|
||||
strncpy(LOCAL_FileNameBuf, fname, YAP_FILENAME_MAX - 1);
|
||||
do_SYSTEM_ERROR_INTERNAL(PERMISSION_ERROR_OPEN_SOURCE_SINK,
|
||||
"could not open saved state");
|
||||
}
|
||||
return FAIL_RESTORE;
|
||||
}
|
||||
|
||||
FILE *Yap_OpenRestore(const char *inpf, const char *YapLibDir) {
|
||||
FILE *Yap_OpenRestore(const char *inpf) {
|
||||
FILE *stream = NULL;
|
||||
|
||||
if (!inpf)
|
||||
inpf = "startup.yss";
|
||||
if (!YapLibDir) {
|
||||
YapLibDir = YAP_LIBDIR;
|
||||
}
|
||||
OpenRestore(inpf, YapLibDir, NULL, NULL, NULL, NULL, &stream);
|
||||
OpenRestore(inpf, NULL, NULL, NULL, NULL, &stream);
|
||||
return stream;
|
||||
}
|
||||
|
||||
|
|
@ -1467,14 +1459,14 @@ static void RestoreHeap(OPCODE old_ops[] USES_REGS) {
|
|||
* This function is called to know about the parameters of the last saved
|
||||
* state
|
||||
*/
|
||||
int Yap_SavedInfo(const char *FileName, const char *YapLibDir, CELL *ATrail,
|
||||
int Yap_SavedInfo(const char *FileName, CELL *ATrail,
|
||||
CELL *AStack, CELL *AHeap) {
|
||||
return DO_ONLY_CODE;
|
||||
|
||||
CELL MyTrail, MyStack, MyHeap, MyState;
|
||||
int mode;
|
||||
|
||||
mode = OpenRestore(FileName, YapLibDir, &MyState, &MyTrail, &MyStack, &MyHeap,
|
||||
mode = OpenRestore(FileName, &MyState, &MyTrail, &MyStack, &MyHeap,
|
||||
NULL);
|
||||
if (mode == FAIL_RESTORE) {
|
||||
return -1;
|
||||
|
|
@ -1554,13 +1546,13 @@ static void FreeRecords(void) {
|
|||
* This function is called when wanting only to restore the heap and
|
||||
* associated registers
|
||||
*/
|
||||
static int Restore(char *s, char *lib_dir USES_REGS) {
|
||||
static int Restore(char *s_dir USES_REGS) {
|
||||
int restore_mode;
|
||||
|
||||
OPCODE old_ops[_std_top + 1];
|
||||
CELL MyTrail, MyStack, MyHeap, MyState;
|
||||
|
||||
if ((restore_mode = OpenRestore(s, lib_dir, &MyState, &MyTrail, &MyStack,
|
||||
if ((restore_mode = OpenRestore(s_dir, &MyState, &MyTrail, &MyStack,
|
||||
&MyHeap, NULL)) == FAIL_RESTORE)
|
||||
return (FALSE);
|
||||
Yap_ShutdownLoadForeign();
|
||||
|
|
@ -1612,9 +1604,9 @@ static int Restore(char *s, char *lib_dir USES_REGS) {
|
|||
return restore_mode;
|
||||
}
|
||||
|
||||
int Yap_SavedStateRestore(char *s, char *lib_dir) {
|
||||
int Yap_SavedStateRestore(char *s) {
|
||||
CACHE_REGS
|
||||
return Restore(s, lib_dir PASS_REGS);
|
||||
return Restore(s PASS_REGS);
|
||||
}
|
||||
|
||||
static Int p_restore(USES_REGS1) {
|
||||
|
|
@ -1640,7 +1632,7 @@ static Int p_restore(USES_REGS1) {
|
|||
Yap_Error(TYPE_ERROR_LIST, t1, "restore/1");
|
||||
return (FALSE);
|
||||
}
|
||||
if ((mode = Restore(s, NULL PASS_REGS)) == DO_ONLY_CODE) {
|
||||
if ((mode = Restore(s PASS_REGS)) == DO_ONLY_CODE) {
|
||||
Yap_RestartYap(3);
|
||||
}
|
||||
return (mode != FAIL_RESTORE);
|
||||
|
|
|
|||
|
|
@ -1349,13 +1349,13 @@ static Int p_statistics_lu_db_size(USES_REGS1) {
|
|||
}
|
||||
|
||||
static Int p_executable(USES_REGS1) {
|
||||
char tmp[YAP_FILENAME_MAX+1];
|
||||
if (GLOBAL_argv && GLOBAL_argv[0])
|
||||
Yap_findFile(GLOBAL_argv[0], NULL, NULL, LOCAL_FileNameBuf, true, YAP_EXE,
|
||||
true, true);
|
||||
Yap_AbsoluteFile(GLOBAL_argv[0], tmp, true);
|
||||
else
|
||||
strncpy(LOCAL_FileNameBuf, Yap_FindExecutable(), YAP_FILENAME_MAX - 1);
|
||||
strncpy(tmp, Yap_FindExecutable(), YAP_FILENAME_MAX);
|
||||
|
||||
return Yap_unify(MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)), ARG1);
|
||||
return Yap_unify(MkAtomTerm(Yap_LookupAtom(tmp)), ARG1);
|
||||
}
|
||||
|
||||
static Int p_system_mode(USES_REGS1) {
|
||||
|
|
|
|||
2
C/text.c
2
C/text.c
|
|
@ -31,7 +31,7 @@ inline static size_t min_size(size_t i, size_t j) { return (i < j ? i : j); }
|
|||
#define wcsnlen(S, N) min_size(N, wcslen(S))
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_STPCPY
|
||||
#if !defined(HAVE_STPCPY) && !defined(__APPLE__)
|
||||
inline static void* __stpcpy(void * i, const void * j) { return strcpy(i,j)+strlen(j);}
|
||||
#define stpcpy __stpcpy
|
||||
#endif
|
||||
|
|
|
|||
678
C/yap-args.c
678
C/yap-args.c
|
|
@ -9,7 +9,8 @@
|
|||
**************************************************************************
|
||||
* *
|
||||
* File: Yap.C * Last
|
||||
*Rev: * Mods:
|
||||
*Rev:
|
||||
* Mods:
|
||||
** Comments: Yap's Main File: parse arguments *
|
||||
* *
|
||||
*************************************************************************/
|
||||
|
|
@ -18,6 +19,7 @@
|
|||
#include "Yap.h"
|
||||
#include "YapHeap.h"
|
||||
#include "YapInterface.h"
|
||||
#include "YapStreams.h"
|
||||
#include "config.h"
|
||||
|
||||
#if HAVE_UNISTD_H
|
||||
|
|
@ -61,111 +63,329 @@
|
|||
|
||||
#endif
|
||||
|
||||
const char *Yap_BINDIR, *Yap_ROOTDIR, *Yap_SHAREDIR, *Yap_LIBDIR, *Yap_DLLDIR, *Yap_PLDIR;
|
||||
const char *Yap_BINDIR, *Yap_ROOTDIR, *Yap_SHAREDIR, *Yap_LIBDIR, *Yap_DLLDIR,
|
||||
*Yap_PLDIR, *Yap_BOOTPLDIR, *Yap_BOOTSTRAPPLDIR, *Yap_COMMONSDIR,
|
||||
*Yap_STARTUP, *Yap_BOOTFILE;
|
||||
|
||||
const char *rootdirs[] = {
|
||||
YAP_ROOTDIR,
|
||||
"(EXECUTABLE)..",
|
||||
"/usr/local",
|
||||
"~",
|
||||
NULL
|
||||
};
|
||||
|
||||
static int yap_lineno = 0;
|
||||
|
||||
/* do initial boot by consulting the file boot.yap */
|
||||
static void do_bootfile(const char *b_file USES_REGS) {
|
||||
Term t;
|
||||
int boot_stream, osno;
|
||||
Functor functor_query = Yap_MkFunctor(Yap_LookupAtom("?-"), 1);
|
||||
Functor functor_command1 = Yap_MkFunctor(Yap_LookupAtom(":-"), 1);
|
||||
|
||||
/* consult boot.pl */
|
||||
char *full = malloc(YAP_FILENAME_MAX + 1);
|
||||
full[0] = '\0';
|
||||
/* the consult mode does not matter here, really */
|
||||
boot_stream = YAP_InitConsult(YAP_BOOT_MODE, b_file, full, &osno);
|
||||
if (boot_stream < 0) {
|
||||
fprintf(stderr, "[ FATAL ERROR: could not open boot_stream %s ]\n",
|
||||
b_file);
|
||||
exit(1);
|
||||
}
|
||||
free(full);
|
||||
setAtomicGlobalPrologFlag(
|
||||
RESOURCE_DATABASE_FLAG,
|
||||
MkAtomTerm(GLOBAL_Stream[boot_stream].name));
|
||||
do {
|
||||
CACHE_REGS
|
||||
YAP_Reset(YAP_FULL_RESET);
|
||||
Yap_StartSlots();
|
||||
t = YAP_ReadClauseFromStream(boot_stream);
|
||||
|
||||
// Yap_DebugPlWriteln(t);
|
||||
if (t == 0) {
|
||||
fprintf(stderr,
|
||||
"[ SYNTAX ERROR: while parsing boot_stream %s at line %d ]\n",
|
||||
b_file, yap_lineno);
|
||||
} else if (YAP_IsVarTerm(t) || t == TermNil) {
|
||||
fprintf(stderr, "[ line %d: term cannot be compiled ]", yap_lineno);
|
||||
} else if (YAP_IsPairTerm(t)) {
|
||||
fprintf(stderr, "[ SYSTEM ERROR: consult not allowed in boot file ]\n");
|
||||
fprintf(stderr, "error found at line %d and pos %d", yap_lineno,
|
||||
fseek(GLOBAL_Stream[boot_stream].file, 0L, SEEK_CUR));
|
||||
} else if (IsApplTerm(t) && (FunctorOfTerm(t) == functor_query ||
|
||||
FunctorOfTerm(t) == functor_command1)) {
|
||||
YAP_RunGoalOnce(ArgOfTerm(1, t));
|
||||
} else {
|
||||
Term ts[2];
|
||||
char *ErrorMessage;
|
||||
Functor fun = Yap_MkFunctor(Yap_LookupAtom("$prepare_clause"), 2);
|
||||
PredEntry *pe = RepPredProp(PredPropByFunc(fun, PROLOG_MODULE));
|
||||
|
||||
if (pe->OpcodeOfPred != UNDEF_OPCODE && pe->OpcodeOfPred != FAIL_OPCODE) {
|
||||
ts[0] = t;
|
||||
RESET_VARIABLE(ts + 1);
|
||||
if (YAP_RunGoal(Yap_MkApplTerm(fun, 2, ts)))
|
||||
t = ts[1];
|
||||
}
|
||||
ErrorMessage = YAP_CompileClause(t);
|
||||
if (ErrorMessage) {
|
||||
fprintf(stderr, "%s", ErrorMessage);
|
||||
}
|
||||
}
|
||||
} while (t != TermEof);
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
YAP_EndConsult(boot_stream, &osno);
|
||||
#if DEBUG
|
||||
if (Yap_output_msg)
|
||||
fprintf(stderr, "Boot loaded\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
/** @brief A simple language for detecting where YAP stuff cn be found
|
||||
*
|
||||
* @long The options are
|
||||
* `[V]` use a configuration variable YAP_XXXDIR, prefixed by "DESTDIR"
|
||||
* `(V)PATH` compute V and add /PATH,
|
||||
* `$V` search the envurinment
|
||||
* `?V` search the WINDOWS registry
|
||||
* ~` search HOME
|
||||
* `@` query user option.
|
||||
*
|
||||
*/
|
||||
const char *rootdirs[] = {"[root]", "(execdir)..", "/usr/local", "~", NULL};
|
||||
|
||||
const char *bindirs[] = {"[bin]", "(root)bin", NULL};
|
||||
|
||||
const char *libdirs[] = {
|
||||
"$YAPLIBDIR",
|
||||
"[lib]",
|
||||
#if __ANDROID__
|
||||
"/assets/lib",
|
||||
#endif
|
||||
YAP_LIBDIR,
|
||||
"(root)lib",
|
||||
NULL
|
||||
};
|
||||
"[lib]", "(root)lib", NULL};
|
||||
|
||||
const char *sharedirs[] = {
|
||||
"$YAPSHAREDIR",
|
||||
"[share]",
|
||||
#if __ANDROID__
|
||||
"/assets/share",
|
||||
#endif
|
||||
YAP_SHAREDIR,
|
||||
"(root)share",
|
||||
NULL
|
||||
};
|
||||
"[share]", "(root)share", NULL};
|
||||
|
||||
const char *dlldirs[] = {
|
||||
"(lib)Yap",
|
||||
NULL
|
||||
};
|
||||
const char *dlldirs[] = {"$YAPLIBDIR", "(lib)Yap", ".", NULL};
|
||||
|
||||
const char *pldirs[] = {
|
||||
"(share)Yap",
|
||||
NULL
|
||||
};
|
||||
const char *ssdirs[] = {".", "$YAPLIBDIR", "(lib)Yap", NULL};
|
||||
|
||||
const char *pldirs[] = {"$YAPSHAREDIR", "?library", "(share)Yap", ".", NULL};
|
||||
|
||||
const char *bootpldirs[] = {"(pl)pl", ".", NULL};
|
||||
|
||||
const char *bootstrappldirs[] = {YAP_PL_SRCDIR, NULL};
|
||||
|
||||
const char *commonsdirs[] = {"(share)PrologCommons", ".", NULL};
|
||||
|
||||
const char *ssnames[] = {"@SavedState", YAP_STARTUP, "startup.yss", NULL};
|
||||
|
||||
const char *plnames[] = {"@YapPrologBootFile", YAP_BOOTFILE, "boot.yap", NULL};
|
||||
|
||||
/**
|
||||
* Search
|
||||
*/
|
||||
char *location(YAP_init_args *iap, const char *inp, char *out) {
|
||||
if (inp == NULL || inp[0] == '\0') {
|
||||
return NULL;
|
||||
} else if (inp[0] == '(') {
|
||||
if (strstr(inp + 1, "root") == inp + 1) {
|
||||
if (!Yap_ROOTDIR || Yap_ROOTDIR[0] == '\0') {
|
||||
return NULL;
|
||||
}
|
||||
strcpy(out, Yap_ROOTDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp + strlen("(root)"));
|
||||
} else if (strstr(inp + 1, "bin") == inp + 1) {
|
||||
if (!Yap_BINDIR || Yap_BINDIR[0] == '\0') {
|
||||
return NULL;
|
||||
}
|
||||
strcpy(out, Yap_BINDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp + strlen("(bin)"));
|
||||
} else if (strstr(inp + 1, "lib") == inp + 1) {
|
||||
if (!Yap_LIBDIR || Yap_LIBDIR[0] == '\0') {
|
||||
return NULL;
|
||||
}
|
||||
strcpy(out, Yap_LIBDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp + strlen("(lib)"));
|
||||
} else if (strstr(inp + 1, "share") == inp + 1) {
|
||||
if (!Yap_SHAREDIR || Yap_SHAREDIR[0] == '\0') {
|
||||
return NULL;
|
||||
}
|
||||
strcpy(out, Yap_SHAREDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp + strlen("(share)"));
|
||||
} else if (strstr(inp + 1, "pl") == inp + 1) {
|
||||
if (!Yap_PLDIR || Yap_PLDIR[0] == '\0') {
|
||||
return NULL;
|
||||
}
|
||||
strcpy(out, Yap_PLDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp + strlen("(pl)"));
|
||||
}else if (strstr(inp + 1, "execdir") == inp + 1) {
|
||||
const char *ex = Yap_FindExecutable();
|
||||
if (ex == NULL)
|
||||
return NULL;
|
||||
strcpy(out, dirname(ex));
|
||||
strcat(out, "/");
|
||||
strcat(out, inp + strlen("(execdir)"));
|
||||
} else
|
||||
return NULL;
|
||||
} else if (inp[0] == '@') {
|
||||
|
||||
if (strstr(inp + 1, "YapPrologBootFile") == inp + 1) {
|
||||
const char *tmp;
|
||||
tmp = iap->YapPrologBootFile;
|
||||
if (tmp && tmp[0])
|
||||
strcpy(out, tmp);
|
||||
} else if (strstr(inp + 1, "SavedState") == inp + 1) {
|
||||
const char *tmp = iap->SavedState;
|
||||
if (tmp && tmp[0])
|
||||
strcpy(out, tmp);
|
||||
}
|
||||
return NULL;
|
||||
} else if (inp[0] == '$') {
|
||||
char *e;
|
||||
if ((e = getenv(inp + 1)) != NULL) {
|
||||
strcpy(out, e);
|
||||
}
|
||||
return NULL;
|
||||
} else if (inp[0] == '?') {
|
||||
#if _WINDOWS_
|
||||
char *e;
|
||||
if ((e = Yap_RegistryGetString(inp + 1)) != NULL) {
|
||||
strcpy(out, e);
|
||||
} else
|
||||
#endif
|
||||
return NULL;
|
||||
} else if (inp[0] == '~') {
|
||||
char *e;
|
||||
if ((e = getenv("HOME")) != NULL) {
|
||||
strcpy(out, e);
|
||||
}
|
||||
if (inp[1] != '\0')
|
||||
strcat(out, inp + 1);
|
||||
} else if (inp[0] == '[') {
|
||||
char *o = out;
|
||||
const char *e;
|
||||
if ((e = getenv("DESTDIR"))) {
|
||||
strcpy(out, e);
|
||||
o += strlen(e);
|
||||
}
|
||||
if (strstr(inp + 1, "root") == inp + 1) {
|
||||
#ifdef YAP_ROOTDIR
|
||||
strcpy(o, YAP_ROOTDIR);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
} else if (strstr(inp + 1, "lib") == inp + 1) {
|
||||
#ifdef YAP_LIBDIR
|
||||
strcpy(o, YAP_LIBDIR);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
} else if (strstr(inp + 1, "share") == inp + 1) {
|
||||
#ifdef YAP_SHAREDIR
|
||||
strcpy(o, YAP_SHAREDIR);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
} else if (strstr(inp + 1, "dll") == inp + 1) {
|
||||
#ifdef YAP_DLLDIR
|
||||
strcpy(o, YAP_DLLDIR);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
} else if (strstr(inp + 1, "pl") == inp + 1) {
|
||||
#ifdef YAP_PLDIR
|
||||
strcpy(o, YAP_PLDIR);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
} else if (strstr(inp + 1, "commons") == inp + 1) {
|
||||
#ifdef YAP_COMMONSDIR
|
||||
strcpy(o, YAP_COMMONSDIR);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
strcpy(out, inp);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief find default paths for main YAP variables
|
||||
*
|
||||
* This function is called once at boot time to set the main paths; it searches a list of paths to instantiate a number of variables.
|
||||
* Paths must be directories.
|
||||
* This function is called once at boot time to set the main paths; it searches
|
||||
* a list of paths to instantiate a number of variables. Paths must be
|
||||
* directories.
|
||||
*
|
||||
* It treats the following variables as :
|
||||
* ROOTDIR, SHAREDIR, LIBDIR, EXECUTABLE
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
static const char *find_directory(const char *paths[]) {
|
||||
int i = 0;
|
||||
static const char *find_directory(YAP_init_args *iap, const char *paths[],
|
||||
const char *names[]) {
|
||||
int lvl = push_text_stack();
|
||||
char *out = Malloc(YAP_FILENAME_MAX + 1);
|
||||
const char *inp;
|
||||
char *out = malloc(YAP_FILENAME_MAX + 1);
|
||||
out[0] = '\0';
|
||||
char *full;
|
||||
if (names) {
|
||||
full = Malloc(YAP_FILENAME_MAX + 1);
|
||||
}
|
||||
int i = 0;
|
||||
while ((inp = paths[i++]) != NULL) {
|
||||
if (inp[0] == '(') {
|
||||
if (strstr(inp + 1, "root") == inp + 1) {
|
||||
strcpy(out, Yap_ROOTDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp+(strlen("(root)")+1));
|
||||
} else if (strstr(inp + 1, "lib") == inp + 1) {
|
||||
strcpy(out, Yap_LIBDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp+(strlen("(lib)")+1));
|
||||
} else if (strstr(inp + 1, "share") == inp + 1) {
|
||||
strcpy(out, Yap_LIBDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp+(strlen("(share)")+1));
|
||||
} else if (strstr(inp + 1, "executable") == inp + 1) {
|
||||
strcpy(out, Yap_LIBDIR);
|
||||
strcat(out, "/");
|
||||
strcat(out, inp+(strlen("(executable)")+1));
|
||||
}
|
||||
} else if (inp[0] == '$') {
|
||||
char *e;
|
||||
if ((e = getenv(inp + 1)) != NULL) {
|
||||
strcpy(out, e);
|
||||
return out;
|
||||
}
|
||||
} else if (inp[0] == '[') {
|
||||
if (Yap_ROOTDIR && Yap_ROOTDIR[0] && strstr(inp + 1, "root") == inp + 1) {
|
||||
strcpy(out, Yap_ROOTDIR);
|
||||
} else if (Yap_LIBDIR && Yap_LIBDIR[0] && strstr(inp + 1, "lib") == inp + 1) {
|
||||
strcpy(out, Yap_LIBDIR);
|
||||
} else if (Yap_SHAREDIR && Yap_SHAREDIR[0] && strstr(inp + 1, "share") == inp + 1) {
|
||||
strcpy(out, Yap_SHAREDIR);
|
||||
}
|
||||
} else {
|
||||
char *e;
|
||||
if ((e = getenv(inp + 1)) != NULL) {
|
||||
strcpy(out, e);
|
||||
} else {
|
||||
out[0] = '\0';
|
||||
char *o = location(iap, inp, out), *no;
|
||||
if (o && o[0] && Yap_isDirectory(o)) {
|
||||
if (names) {
|
||||
size_t s = strlen(o);
|
||||
o[s++] = '/';
|
||||
const char *p;
|
||||
int j = 0;
|
||||
while ((p = names[j++])) {
|
||||
char *io = o + s;
|
||||
if ((no = location(iap, p, io)) && io[0] != '\0' && Yap_Exists(o))
|
||||
return pop_output_text_stack(lvl, realpath(o, full));
|
||||
}
|
||||
strcat(out, inp);
|
||||
}
|
||||
if (out[0]) {
|
||||
return out;
|
||||
} else
|
||||
return pop_output_text_stack(lvl, o);
|
||||
}
|
||||
}
|
||||
pop_text_stack(lvl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void Yap_set_locations(YAP_init_args *iap) {
|
||||
#if CONDA_BUILD
|
||||
if (!getenv("DESTDIR")) {
|
||||
char buf[YAP_FILENAME_MAX + 1];
|
||||
const char *o = Yap_FindExecutable();
|
||||
if (!o)
|
||||
return;
|
||||
strcpy(buf, dirname(dirname(o)));
|
||||
putenv("DESTDIR", buf)k
|
||||
}
|
||||
#endif
|
||||
Yap_ROOTDIR = find_directory(iap, rootdirs, NULL);
|
||||
Yap_LIBDIR = find_directory(iap, libdirs, NULL);
|
||||
Yap_BINDIR = find_directory(iap, bindirs, NULL);
|
||||
Yap_SHAREDIR = find_directory(iap, sharedirs, NULL);
|
||||
Yap_DLLDIR = find_directory(iap, dlldirs, NULL);
|
||||
Yap_PLDIR = find_directory(iap, pldirs, NULL);
|
||||
Yap_COMMONSDIR = find_directory(iap, commonsdirs, NULL);
|
||||
Yap_STARTUP = find_directory(iap, ssdirs, ssnames);
|
||||
if (iap->bootstrapping)
|
||||
Yap_BOOTFILE = find_directory(iap, bootstrappldirs, plnames);
|
||||
else
|
||||
Yap_BOOTFILE = find_directory(iap, bootpldirs, plnames);
|
||||
setAtomicGlobalPrologFlag( HOME_FLAG, MkAtomTerm(Yap_LookupAtom(Yap_ROOTDIR)));
|
||||
setAtomicGlobalPrologFlag( PROLOG_LIBRARY_DIRECTORY_FLAG,MkAtomTerm(Yap_LookupAtom(Yap_PLDIR)));
|
||||
setAtomicGlobalPrologFlag( PROLOG_FOREIGN_DIRECTORY_FLAG, MkAtomTerm(Yap_LookupAtom(Yap_DLLDIR)));
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -236,9 +456,10 @@ static int myisblank(int c) {
|
|||
static char *add_end_dot(char arg[]) {
|
||||
int sz = strlen(arg), i;
|
||||
i = sz;
|
||||
while (i && myisblank(arg[--i]));
|
||||
while (i && myisblank(arg[--i]))
|
||||
;
|
||||
if (i && arg[i] != ',') {
|
||||
char *p = (char *) malloc(sz + 2);
|
||||
char *p = (char *)malloc(sz + 2);
|
||||
if (!p)
|
||||
return NULL;
|
||||
strncpy(p, arg, sz);
|
||||
|
|
@ -261,6 +482,9 @@ static int dump_runtime_variables(void) {
|
|||
|
||||
X_API YAP_file_type_t Yap_InitDefaults(void *x, char *saved_state, int argc,
|
||||
char *argv[]) {
|
||||
|
||||
if (!LOCAL_TextBuffer)
|
||||
LOCAL_TextBuffer = Yap_InitTextAllocator();
|
||||
YAP_init_args *iap = x;
|
||||
memset(iap, 0, sizeof(YAP_init_args));
|
||||
#if __ANDROID__
|
||||
|
|
@ -273,11 +497,6 @@ X_API YAP_file_type_t Yap_InitDefaults(void *x, char *saved_state, int argc,
|
|||
#endif
|
||||
iap->Argc = argc;
|
||||
iap->Argv = argv;
|
||||
Yap_ROOTDIR = find_directory(rootdirs);
|
||||
Yap_LIBDIR = find_directory(libdirs);
|
||||
Yap_SHAREDIR = find_directory(sharedirs);
|
||||
Yap_DLLDIR = find_directory(dlldirs);
|
||||
Yap_PLDIR = find_directory(pldirs);
|
||||
return YAP_QLY;
|
||||
}
|
||||
|
||||
|
|
@ -288,34 +507,10 @@ X_API YAP_file_type_t Yap_InitDefaults(void *x, char *saved_state, int argc,
|
|||
* @param iap options, see YAP_init_args
|
||||
* @return boot from saved state or restore; error
|
||||
*/
|
||||
X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[],
|
||||
X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[],
|
||||
YAP_init_args *iap) {
|
||||
char *p;
|
||||
size_t *ssize;
|
||||
#ifndef YAP_ROOTDIR
|
||||
{
|
||||
char *b0 = Yap_FindExecutable(), *b1, *b2;
|
||||
char b[YAP_FILENAME_MAX + 1];
|
||||
|
||||
strncpy(b, b0, YAP_FILENAME_MAX);
|
||||
b1 = dirname(b);
|
||||
YAP_BINDIR = malloc(strlen(b1) + 1);
|
||||
strcpy(YAP_BINDIR, b1);
|
||||
b2 = dirname(b1);
|
||||
YAP_ROOTDIR = malloc(strlen(b2) + 1);
|
||||
strcpy(YAP_ROOTDIR, b2);
|
||||
strncpy(b, YAP_ROOTDIR, YAP_FILENAME_MAX);
|
||||
strncat(b, "/share", YAP_FILENAME_MAX);
|
||||
YAP_SHAREDIR = malloc(strlen(b) + 1);
|
||||
strcpy(YAP_SHAREDIR, b);
|
||||
strncpy(b, YAP_ROOTDIR, YAP_FILENAME_MAX);
|
||||
strncat(b, "/lib", YAP_FILENAME_MAX);
|
||||
YAP_LIBDIR = malloc(strlen(b) + 1);
|
||||
strcpy(YAP_LIBDIR, b);
|
||||
strncpy(b, YAP_ROOTDIR, YAP_FILENAME_MAX);
|
||||
strncat(b, "/lib/Yap", YAP_FILENAME_MAX);
|
||||
};
|
||||
#endif
|
||||
|
||||
Yap_InitDefaults(iap, NULL, argc, argv);
|
||||
while (--argc > 0) {
|
||||
|
|
@ -701,4 +896,271 @@ X_API YAP_file_type_t Yap_InitDefaults(void *x, char *saved_state, int argc,
|
|||
}
|
||||
}
|
||||
return iap->boot_file_type;
|
||||
}
|
||||
|
||||
/**
|
||||
YAP_DelayInit()
|
||||
|
||||
ensures initialization is done after engine creation.
|
||||
It receives a pointer to function and a string describing
|
||||
the module.
|
||||
*/
|
||||
|
||||
X_API bool YAP_initialized = false;
|
||||
static int n_mdelays = 0;
|
||||
static YAP_delaymodule_t *m_delays;
|
||||
|
||||
X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) {
|
||||
if (m_delays) {
|
||||
m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t));
|
||||
} else {
|
||||
m_delays = malloc(sizeof(YAP_delaymodule_t));
|
||||
}
|
||||
m_delays[n_mdelays].f = f;
|
||||
m_delays[n_mdelays].s = s;
|
||||
n_mdelays++;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Yap_LateInit(const char s[]) {
|
||||
int i;
|
||||
for (i = 0; i < n_mdelays; i++) {
|
||||
if (!strcmp(m_delays[i].s, s)) {
|
||||
m_delays[i].f();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static void start_modules(void) {
|
||||
Term cm = CurrentModule;
|
||||
size_t i;
|
||||
for (i = 0; i < n_mdelays; i++) {
|
||||
CurrentModule = MkAtomTerm(YAP_LookupAtom(m_delays[i].s));
|
||||
m_delays[i].f();
|
||||
}
|
||||
CurrentModule = cm;
|
||||
}
|
||||
|
||||
/// whether Yap is under control of some other system
|
||||
bool Yap_embedded = true;
|
||||
|
||||
struct ssz_t {
|
||||
size_t Heap, Stack, Trail;
|
||||
};
|
||||
|
||||
static void init_hw(YAP_init_args *yap_init, struct ssz_t *spt) {
|
||||
Yap_page_size = Yap_InitPageSize(); /* init memory page size, required by
|
||||
later functions */
|
||||
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA)
|
||||
Yap_init_yapor_global_local_memory();
|
||||
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA */
|
||||
if (!yap_init->Embedded) {
|
||||
GLOBAL_PrologShouldHandleInterrupts =
|
||||
!yap_init->PrologCannotHandleInterrupts;
|
||||
Yap_InitSysbits(0); /* init signal handling and time, required by later
|
||||
functions */
|
||||
GLOBAL_argv = yap_init->Argv;
|
||||
GLOBAL_argc = yap_init->Argc;
|
||||
}
|
||||
|
||||
#if __ANDROID__
|
||||
|
||||
// if (yap_init->assetManager)
|
||||
Yap_InitAssetManager();
|
||||
|
||||
#endif
|
||||
|
||||
if (yap_init->TrailSize == 0) {
|
||||
if (spt->Trail == 0)
|
||||
spt->Trail = DefTrailSpace;
|
||||
} else {
|
||||
spt->Trail = yap_init->TrailSize;
|
||||
}
|
||||
// Atts = yap_init->AttsSize;
|
||||
if (yap_init->StackSize == 0) {
|
||||
spt->Stack = DefStackSpace;
|
||||
} else {
|
||||
spt->Stack = yap_init->StackSize;
|
||||
}
|
||||
#ifndef USE_SYSTEM_MALLOC
|
||||
if (yap_init->HeapSize == 0) {
|
||||
if (spt->Heap == 0)
|
||||
spt->Heap = DefHeapSpace;
|
||||
} else {
|
||||
spt->Heap = yap_init->HeapSize;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static void init_globals(YAP_init_args *yap_init) {
|
||||
GLOBAL_FAST_BOOT_FLAG = yap_init->FastBoot;
|
||||
#if defined(YAPOR) || defined(TABLING)
|
||||
|
||||
Yap_init_root_frames();
|
||||
|
||||
#endif /* YAPOR || TABLING */
|
||||
#ifdef YAPOR
|
||||
Yap_init_yapor_workers();
|
||||
#if YAPOR_THREADS
|
||||
if (Yap_thread_self() != 0) {
|
||||
#else
|
||||
if (worker_id != 0) {
|
||||
#endif
|
||||
#if defined(YAPOR_COPY) || defined(YAPOR_SBA)
|
||||
/*
|
||||
In the SBA we cannot just happily inherit registers
|
||||
from the other workers
|
||||
*/
|
||||
Yap_InitYaamRegs(worker_id);
|
||||
#endif /* YAPOR_COPY || YAPOR_SBA */
|
||||
#ifndef YAPOR_THREADS
|
||||
Yap_InitPreAllocCodeSpace(0);
|
||||
#endif /* YAPOR_THREADS */
|
||||
/* slaves, waiting for work */
|
||||
CurrentModule = USER_MODULE;
|
||||
P = GETWORK_FIRST_TIME;
|
||||
Yap_exec_absmi(FALSE, YAP_EXEC_ABSMI);
|
||||
Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil,
|
||||
"abstract machine unexpected exit (YAP_Init)");
|
||||
}
|
||||
#endif /* YAPOR */
|
||||
RECOVER_MACHINE_REGS();
|
||||
/* make sure we do this after restore */
|
||||
if (yap_init->MaxStackSize) {
|
||||
GLOBAL_AllowLocalExpansion = FALSE;
|
||||
} else {
|
||||
GLOBAL_AllowLocalExpansion = TRUE;
|
||||
}
|
||||
if (yap_init->MaxGlobalSize) {
|
||||
GLOBAL_AllowGlobalExpansion = FALSE;
|
||||
} else {
|
||||
GLOBAL_AllowGlobalExpansion = TRUE;
|
||||
}
|
||||
if (yap_init->MaxTrailSize) {
|
||||
GLOBAL_AllowTrailExpansion = FALSE;
|
||||
} else {
|
||||
GLOBAL_AllowTrailExpansion = TRUE;
|
||||
}
|
||||
if (yap_init->YapPrologRCFile) {
|
||||
Yap_PutValue(AtomConsultOnBoot,
|
||||
MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile)));
|
||||
/*
|
||||
This must be done again after restore, as yap_flags
|
||||
has been overwritten ....
|
||||
*/
|
||||
setBooleanGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG,
|
||||
yap_init->HaltAfterConsult);
|
||||
}
|
||||
if (yap_init->YapPrologTopLevelGoal) {
|
||||
Yap_PutValue(AtomTopLevelGoal,
|
||||
MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologTopLevelGoal)));
|
||||
}
|
||||
if (yap_init->YapPrologGoal) {
|
||||
Yap_PutValue(AtomInitGoal,
|
||||
MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologGoal)));
|
||||
}
|
||||
if (yap_init->YapPrologAddPath) {
|
||||
Yap_PutValue(AtomExtendFileSearchPath,
|
||||
MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologAddPath)));
|
||||
}
|
||||
|
||||
if (yap_init->QuietMode) {
|
||||
setVerbosity(TermSilent);
|
||||
}
|
||||
}
|
||||
|
||||
static YAP_file_type_t end_init(YAP_init_args *yap_init, YAP_file_type_t rc) {
|
||||
init_globals(yap_init);
|
||||
LOCAL_PrologMode &= ~BootMode;
|
||||
|
||||
start_modules();
|
||||
|
||||
YAP_initialized = true;
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* this routine is supposed to be called from an external program
|
||||
that wants to control Yap */
|
||||
|
||||
X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
|
||||
YAP_file_type_t restore_result = yap_init->boot_file_type;
|
||||
bool do_bootstrap = (restore_result & YAP_CONSULT_MODE);
|
||||
struct ssz_t minfo;
|
||||
|
||||
if (YAP_initialized)
|
||||
return YAP_FOUND_BOOT_ERROR;
|
||||
if (!LOCAL_TextBuffer)
|
||||
LOCAL_TextBuffer = Yap_InitTextAllocator();
|
||||
|
||||
/* ignore repeated calls to YAP_Init */
|
||||
Yap_embedded = yap_init->Embedded;
|
||||
|
||||
minfo.Trail = 0, minfo.Stack = 0, minfo.Trail = 0;
|
||||
init_hw(yap_init, &minfo);
|
||||
Yap_InitWorkspace(yap_init, minfo.Heap, minfo.Stack, minfo.Trail, 0,
|
||||
yap_init->MaxTableSpaceSize, yap_init->NumberWorkers,
|
||||
yap_init->SchedulerLoop, yap_init->DelayedReleaseLoad);
|
||||
//
|
||||
|
||||
CACHE_REGS
|
||||
if (Yap_embedded)
|
||||
if (yap_init->QuietMode) {
|
||||
setVerbosity(TermSilent);
|
||||
}
|
||||
if (yap_init->YapPrologRCFile != NULL) {
|
||||
/*
|
||||
This must be done before restore, otherwise
|
||||
restore will print out messages ....
|
||||
*/
|
||||
setBooleanGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG,
|
||||
yap_init->HaltAfterConsult);
|
||||
}
|
||||
/* tell the system who should cope with interrupts */
|
||||
Yap_ExecutionMode = yap_init->ExecutionMode;
|
||||
Yap_set_locations(yap_init);
|
||||
if (!do_bootstrap && Yap_STARTUP && yap_init->boot_file_type != YAP_BOOT_PL &&
|
||||
Yap_SavedInfo(Yap_STARTUP, &minfo.Trail, &minfo.Stack, &minfo.Heap) &&
|
||||
Yap_Restore(Yap_STARTUP)) {
|
||||
setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, true);
|
||||
CurrentModule = LOCAL_SourceModule = USER_MODULE;
|
||||
return end_init(yap_init, YAP_QLY);
|
||||
} else {
|
||||
do_bootfile(Yap_BOOTFILE PASS_REGS);
|
||||
setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, false);
|
||||
return end_init(yap_init, YAP_BOOT_PL);
|
||||
}
|
||||
}
|
||||
|
||||
#if (DefTrailSpace < MinTrailSpace)
|
||||
#undef DefTrailSpace
|
||||
#define DefTrailSpace MinTrailSpace
|
||||
#endif
|
||||
|
||||
#if (DefStackSpace < MinStackSpace)
|
||||
#undef DefStackSpace
|
||||
#define DefStackSpace MinStackSpace
|
||||
#endif
|
||||
|
||||
#if (DefHeapSpace < MinHeapSpace)
|
||||
#undef DefHeapSpace
|
||||
#define DefHeapSpace MinHeapSpace
|
||||
#endif
|
||||
|
||||
#define DEFAULT_NUMBERWORKERS 1
|
||||
#define DEFAULT_SCHEDULERLOOP 10
|
||||
#define DEFAULT_DELAYEDRELEASELOAD 3
|
||||
|
||||
X_API YAP_file_type_t YAP_FastInit(char *saved_state, int argc, char *argv[]) {
|
||||
YAP_init_args init_args;
|
||||
YAP_file_type_t out;
|
||||
|
||||
if ((out = Yap_InitDefaults(&init_args, saved_state, argc, argv)) !=
|
||||
YAP_FOUND_BOOT_ERROR)
|
||||
out = YAP_Init(&init_args);
|
||||
if (out == YAP_FOUND_BOOT_ERROR) {
|
||||
Yap_Error(init_args.ErrorNo, TermNil, init_args.ErrorCause);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@ cmake_policy(VERSION 3.4)
|
|||
|
||||
set( CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/cmake")
|
||||
|
||||
set(ANACONDA $ENV{CONDA_BUILD} CACHE BOOL "Anaconda Environment")
|
||||
message(STATUS "ANACONDA found: ${ANACONDA}")
|
||||
set(ANACONDA $ENV{CONDA_BUILD} CACHE BOOL "Anaconda Environment")
|
||||
message(STATUS "ANACONDA found: ${ANACONDA}")
|
||||
|
||||
include(CheckIncludeFiles)
|
||||
include(CheckLibraryExists)
|
||||
|
|
@ -222,6 +222,7 @@ if (ANACONDA)
|
|||
#set( CMAKE_INSTALL_FULL_PREFIX $ENV{PREFIX} )
|
||||
set( PYTHON_LIBRARY $ENV{PREFIX}/lib/libpython$ENV{PY_VER}m$ENV{SHLIB_EXT})
|
||||
set( PYTHON_INCLUDE_DIR $ENV{PREFIX}/include/python$ENV{PY_VER}m)
|
||||
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS CONDA_BUILD=1)
|
||||
set(YAP_IS_MOVABLE 1)
|
||||
endif()
|
||||
|
||||
|
|
@ -814,7 +815,7 @@ endif(NOT ANDROID)
|
|||
|
||||
#
|
||||
|
||||
install(FILES ${INCLUDE_HEADERS} ${CONFIGURATION_HEADERS} DESTINATION ${YAP_INCLUDEDIR} )
|
||||
install(FILES ${INCLUDE_HEADERS} ${CONFIGURATION_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/Yap )
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
3
H/Yap.h
3
H/Yap.h
|
|
@ -151,7 +151,8 @@ typedef void *(*fptr_t)(void);
|
|||
main exports in YapInterface.h
|
||||
*************************************************************************************************/
|
||||
|
||||
extern const char *Yap_BINDIR, *Yap_ROOTDIR, *Yap_SHAREDIR, *Yap_LIBDIR, *Yap_DLLDIR, *Yap_PLDIR;
|
||||
extern const char *Yap_BINDIR, *Yap_ROOTDIR, *Yap_SHAREDIR, *Yap_LIBDIR, *Yap_DLLDIR, *Yap_PLDIR, *Yap_COMMONSDIR, *Yap_STARTUP, *Yap_BOOTFILE;
|
||||
|
||||
|
||||
/* Basic exports */
|
||||
|
||||
|
|
|
|||
|
|
@ -236,7 +236,7 @@ process, namely, on choice-points.
|
|||
YAP_FLAG(GMP_VERSION_FLAG, "gmp_version", false, isatom, "4.8.12", NULL),
|
||||
YAP_FLAG(HALT_AFTER_CONSULT_FLAG, "halt_after_consult", false, booleanFlag,
|
||||
"false", NULL),
|
||||
/* YAP_FLAG(HOME_FLAG, "home", false, isatom, rootdir, NULL),*/ /**< home `
|
||||
YAP_FLAG(HOME_FLAG, "home", false, isatom, rootdir, NULL), /**< home `
|
||||
|
||||
the root of the YAP installation, by default `/usr/local` in Unix or
|
||||
`c:\Yap` in Windows system. Can only be set at configure time
|
||||
|
|
|
|||
169
H/YapTerm.h
169
H/YapTerm.h
|
|
@ -1,169 +0,0 @@
|
|||
/*************************************************************************
|
||||
* *
|
||||
* YAP Prolog %W% %G% *
|
||||
* Yap Prolog was developed at NCCUP - Universidade do Porto *
|
||||
* *
|
||||
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
|
||||
* *
|
||||
**************************************************************************
|
||||
* *
|
||||
* File: Yap.h *
|
||||
* mods: *
|
||||
* comments: abstract type definitions for YAP *
|
||||
* version: $Id: Yap.h,v 1.38 2008-06-18 10:02:27 vsc Exp $ *
|
||||
*************************************************************************/
|
||||
|
||||
#ifndef YAP_H
|
||||
#include "YapTermConfig.h"
|
||||
#include "config.h"
|
||||
|
||||
#endif
|
||||
|
||||
#if HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
#if HAVE_INTTYPES_H
|
||||
#include <inttypes.h>
|
||||
#endif
|
||||
|
||||
/* truth-values */
|
||||
/* stdbool defines the booleam type, bool,
|
||||
and the constants false and true */
|
||||
#if HAVE_STDBOOL_H
|
||||
#include <stdbool.h>
|
||||
#else
|
||||
#ifndef true
|
||||
typedef int _Bool;
|
||||
#define bool _Bool;
|
||||
|
||||
#define false 0
|
||||
#define true 1
|
||||
#endif
|
||||
#endif /* HAVE_STDBOOL_H */
|
||||
|
||||
|
||||
#define ALIGN_BY_TYPE(X, TYPE) \
|
||||
(((CELL)(X) + (sizeof(TYPE) - 1)) & ~(sizeof(TYPE) - 1))
|
||||
|
||||
#ifndef EXTERN
|
||||
#ifdef MSC_VER
|
||||
#define EXTERN
|
||||
#else
|
||||
#define EXTERN extern
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* defines integer types Int and UInt (unsigned) with the same size as a ptr
|
||||
** and integer types Short and UShort with half the size of a ptr */
|
||||
|
||||
#if defined(PRIdPTR)
|
||||
|
||||
typedef intptr_t YAP_Int;
|
||||
typedef uintptr_t YAP_UInt;
|
||||
|
||||
#elif defined(_WIN64)
|
||||
|
||||
|
||||
typedef int64_t YAP_Int;
|
||||
typedef uint64_t YAP_UInt;
|
||||
|
||||
#elif defined(_WIN32)
|
||||
|
||||
typedef int32_t YAP_Int;
|
||||
typedef uint32_t YAP_UInt;
|
||||
|
||||
#elif SIZEOF_LONG_INT == SIZEOF_INT_P
|
||||
|
||||
typedef long int YAP_Int;
|
||||
typedef unsigned long int YAP_UInt;
|
||||
|
||||
#elif SIZEOF_INT == SIZEOF_INT_P
|
||||
|
||||
typedef int YAP_Int;
|
||||
typedef unsigned int YAP_UInt;
|
||||
|
||||
#else
|
||||
#error Yap require integer types of the same size as a pointer
|
||||
#endif
|
||||
|
||||
/* */ typedef short int YAP_Short;
|
||||
/* */ typedef unsigned short int YAP_UShort;
|
||||
|
||||
typedef YAP_UInt YAP_CELL;
|
||||
typedef YAP_UInt YAP_Term;
|
||||
|
||||
/* Type definitions */
|
||||
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE true
|
||||
#endif
|
||||
#ifndef FALSE
|
||||
#endif
|
||||
|
||||
typedef bool YAP_Bool;
|
||||
#define FALSE false
|
||||
|
||||
typedef YAP_Int YAP_handle_t;
|
||||
|
||||
|
||||
typedef double YAP_Float;
|
||||
|
||||
typedef void *YAP_Atom;
|
||||
|
||||
typedef void *YAP_Functor;
|
||||
|
||||
#ifdef YAP_H
|
||||
|
||||
typedef YAP_Int Int;
|
||||
typedef YAP_UInt UInt;
|
||||
typedef YAP_Short Short;
|
||||
typedef YAP_UShort UShort;
|
||||
|
||||
typedef uint16_t BITS16;
|
||||
typedef int16_t SBITS16;
|
||||
typedef uint32_t BITS32;
|
||||
|
||||
typedef YAP_CELL CELL;
|
||||
|
||||
typedef YAP_Term Term;
|
||||
|
||||
#define WordSize sizeof(BITS16)
|
||||
#define CellSize sizeof(CELL)
|
||||
#define SmallSize sizeof(SMALLUNSGN)
|
||||
|
||||
typedef YAP_Int Int;
|
||||
typedef YAP_Float Float;
|
||||
typedef YAP_handle_t yhandle_t;
|
||||
|
||||
#endif
|
||||
|
||||
#include "YapError.h"
|
||||
|
||||
#include "../os/encoding.h"
|
||||
|
||||
typedef encoding_t YAP_encoding_t;
|
||||
|
||||
#include "YapFormat.h"
|
||||
|
||||
/*************************************************************************************************
|
||||
type casting macros
|
||||
*************************************************************************************************/
|
||||
|
||||
#if SIZEOF_INT < SIZEOF_INT_P
|
||||
#define SHORT_INTS 1
|
||||
#else
|
||||
#define SHORT_INTS 0
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
typedef long long int YAP_LONG_LONG;
|
||||
typedef unsigned long long int YAP_ULONG_LONG;
|
||||
#else
|
||||
typedef long int YAP_LONG_LONG;
|
||||
typedef unsigned long int YAP_ULONG_LONG;
|
||||
#endif
|
||||
|
||||
#define Unsigned(V) ((CELL)(V))
|
||||
#define Signed(V) ((Int)(V))
|
||||
|
||||
14
H/Yapproto.h
14
H/Yapproto.h
|
|
@ -354,16 +354,16 @@ extern void Yap_InitReadUtil(void);
|
|||
|
||||
/* qly.c */
|
||||
extern void Yap_InitQLY(void);
|
||||
extern YAP_file_type_t Yap_Restore(const char *, const char *);
|
||||
extern YAP_file_type_t Yap_Restore(const char *);
|
||||
extern void Yap_InitQLYR(void);
|
||||
|
||||
/* range.c */
|
||||
extern void Yap_InitRange(void);
|
||||
|
||||
/* save.c */
|
||||
extern int Yap_SavedInfo(const char *, const char *, CELL *, CELL *, CELL *);
|
||||
extern int Yap_SavedStateRestore(char *, char *);
|
||||
extern FILE *Yap_OpenRestore(const char *, const char *);
|
||||
extern int Yap_SavedInfo(const char *, CELL *, CELL *, CELL *);
|
||||
extern int Yap_SavedStateRestore(char *);
|
||||
extern FILE *Yap_OpenRestore(const char *);
|
||||
extern void Yap_InitSavePreds(void);
|
||||
|
||||
/* scanner.c */
|
||||
|
|
@ -432,10 +432,10 @@ extern void Yap_WinError(char *);
|
|||
extern const char *Yap_AbsoluteFile(const char *spec, char *obuf, bool ok);
|
||||
extern const char *Yap_AbsoluteFileInBuffer(const char *spec, char *outp, size_t sz,
|
||||
bool ok);
|
||||
extern const char *Yap_findFile(const char *isource, const char *idef,
|
||||
const char *root, char *result, bool access,
|
||||
YAP_file_type_t ftype, bool expand_root, bool in_lib);
|
||||
extern bool Yap_ChDir(const char *path);
|
||||
bool Yap_isDirectory(const char *FileName);
|
||||
extern bool Yap_Exists(const char *f);
|
||||
|
||||
|
||||
/* threads.c */
|
||||
extern void Yap_InitThreadPreds(void);
|
||||
|
|
|
|||
|
|
@ -1971,7 +1971,6 @@ significant byte first (like Motorola and SPARC, unlike Intel). */
|
|||
|
||||
|
||||
|
||||
#ifndef YAP_IS_MOVABLE
|
||||
/* name of YAP instaii */
|
||||
#ifndef YAP_ROOTDIR
|
||||
#define YAP_ROOTDIR "${YAP_ROOTDIR}"
|
||||
|
|
@ -2001,13 +2000,14 @@ significant byte first (like Motorola and SPARC, unlike Intel). */
|
|||
#define YAP_SHAREDIR "${YAP_ROOTDIR}/share"
|
||||
#endif
|
||||
|
||||
#else
|
||||
extern char
|
||||
*YAP_BINDIR,
|
||||
*YAP_ROOTDIR,
|
||||
*YAP_SHAREDIR,
|
||||
*YAP_LIBDIR,
|
||||
*YAP_YAPLIB;
|
||||
/* name of YAP PL library */
|
||||
#ifndef YAP_PLDIR
|
||||
#define YAP_PLDIR "${YAP_SHAREDIR}/Yap"
|
||||
#endif
|
||||
|
||||
/* name of Commons library */
|
||||
#ifndef YAP_COMMONSDIR
|
||||
#define YAP COMMONSDIR "${YAP_SHAREDIR}/PrologCommmons"
|
||||
#endif
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1370,7 +1370,7 @@ writable.
|
|||
|
||||
*/
|
||||
|
||||
static Int open3(USES_REGS1) {
|
||||
static Int open3(USES_RfEGS1) {
|
||||
/* '$open'(+File,+Mode,?Stream,-ReturnCode) */
|
||||
return do_open(Deref(ARG1), Deref(ARG2), TermNil PASS_REGS);
|
||||
}
|
||||
|
|
@ -1465,11 +1465,11 @@ static Int p_file_expansion(USES_REGS1) { /* '$file_expansion'(+File,-Name) */
|
|||
PlIOError(INSTANTIATION_ERROR, file_name, "absolute_file_name/3");
|
||||
return (FALSE);
|
||||
}
|
||||
if (!Yap_findFile(RepAtom(AtomOfTerm(file_name))->StrOfAE, NULL, NULL,
|
||||
LOCAL_FileNameBuf, true, YAP_ANY_FILE, true, false))
|
||||
char tmp[YAP_FILENAME_MAX+1];
|
||||
if (!Yap_AbsoluteFile(RepAtom(AtomOfTerm(file_name))->StrOfAE,tmp, false))
|
||||
return (PlIOError(EXISTENCE_ERROR_SOURCE_SINK, file_name,
|
||||
"absolute_file_name/3"));
|
||||
return (Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf))));
|
||||
return (Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(tmp))));
|
||||
}
|
||||
|
||||
static Int p_open_null_stream(USES_REGS1) {
|
||||
|
|
|
|||
|
|
@ -273,7 +273,6 @@ extern FILE *Yap_stderr;
|
|||
|
||||
char *Yap_MemExportStreamPtr(int sno);
|
||||
|
||||
extern bool Yap_Exists(const char *f);
|
||||
|
||||
static inline void freeBuffer(const void *ptr) {
|
||||
CACHE_REGS
|
||||
|
|
|
|||
293
os/sysbits.c
293
os/sysbits.c
|
|
@ -34,7 +34,6 @@ static void FileError(yap_error_number type, Term where, const char *format,
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
static Int p_sh(USES_REGS1);
|
||||
static Int p_shell(USES_REGS1);
|
||||
static Int p_system(USES_REGS1);
|
||||
|
|
@ -67,11 +66,11 @@ void Yap_WinError(char *yap_error) {
|
|||
|
||||
/// is_directory: verifies whether an expanded file name
|
||||
/// points at a readable directory
|
||||
static bool is_directory(const char *FileName) {
|
||||
bool Yap_isDirectory(const char *FileName) {
|
||||
|
||||
VFS_t *vfs;
|
||||
if ((vfs = vfs_owner(FileName))) {
|
||||
return vfs->isdir(vfs,FileName);
|
||||
return vfs->isdir(vfs, FileName);
|
||||
}
|
||||
#ifdef _WIN32
|
||||
DWORD dwAtts = GetFileAttributes(FileName);
|
||||
|
|
@ -97,7 +96,7 @@ bool Yap_Exists(const char *f) {
|
|||
VFS_t *vfs;
|
||||
f = Yap_VFAlloc(f);
|
||||
if ((vfs = vfs_owner(f))) {
|
||||
return vfs->exists(vfs,f);
|
||||
return vfs->exists(vfs, f);
|
||||
}
|
||||
#if _WIN32
|
||||
if (_access(f, 0) == 0)
|
||||
|
|
@ -345,7 +344,7 @@ static char *PrologPath(const char *Y, char *X) { return (char *)Y; }
|
|||
|
||||
char virtual_cwd[YAP_FILENAME_MAX + 1];
|
||||
|
||||
bool Yap_ChDir(const char *path) {
|
||||
bool Yap_ChDir(const char *path) {
|
||||
bool rc = false;
|
||||
char qp[FILENAME_MAX + 1];
|
||||
const char *qpath = Yap_AbsoluteFile(path, qp, true);
|
||||
|
|
@ -369,10 +368,9 @@ char virtual_cwd[YAP_FILENAME_MAX + 1];
|
|||
return rc;
|
||||
}
|
||||
|
||||
|
||||
static const char *myrealpath(const char *path, char *out) {
|
||||
int lvl = push_text_stack();
|
||||
#if _WIN32
|
||||
#if _WIN32
|
||||
DWORD retval = 0;
|
||||
|
||||
// notice that the file does not need to exist
|
||||
|
|
@ -393,8 +391,8 @@ static const char *myrealpath(const char *path, char *out) {
|
|||
}
|
||||
// rc = NULL;
|
||||
if (errno == ENOENT || errno == EACCES) {
|
||||
char *base= Malloc(YAP_FILENAME_MAX + 1);
|
||||
strncpy(base, path, YAP_FILENAME_MAX );
|
||||
char *base = Malloc(YAP_FILENAME_MAX + 1);
|
||||
strncpy(base, path, YAP_FILENAME_MAX);
|
||||
rc = realpath(dirname(base), out);
|
||||
|
||||
if (rc) {
|
||||
|
|
@ -959,95 +957,10 @@ static bool initSysPath(Term tlib, Term tcommons, bool dir_done,
|
|||
int len;
|
||||
char *dir;
|
||||
|
||||
#if __WINDOWS__
|
||||
{
|
||||
if ((dir = Yap_RegistryGetString("library")) && is_directory(dir)) {
|
||||
dir_done = true;
|
||||
if (!Yap_unify(tlib, MkAtomTerm(Yap_LookupAtom(dir))))
|
||||
return false;
|
||||
}
|
||||
if ((dir = Yap_RegistryGetString("prolog_commons")) && is_directory(dir)) {
|
||||
if (!Yap_unify(tcommons, MkAtomTerm(Yap_LookupAtom(dir))))
|
||||
return false;
|
||||
commons_done = true;
|
||||
}
|
||||
}
|
||||
if (dir_done && commons_done)
|
||||
return true;
|
||||
#endif
|
||||
|
||||
if (!Yap_unify(tlib, MkAtomTerm(Yap_LookupAtom(Yap_PLDIR))))
|
||||
return false;
|
||||
if (!commons_done) {
|
||||
LOCAL_FileNameBuf[len] = '\0';
|
||||
strncat(LOCAL_FileNameBuf, "PrologCommons", YAP_FILENAME_MAX);
|
||||
if (is_directory(LOCAL_FileNameBuf)) {
|
||||
if (!Yap_unify(tcommons, MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf))))
|
||||
return FALSE;
|
||||
}
|
||||
commons_done = true;
|
||||
}
|
||||
if (dir_done && commons_done)
|
||||
return TRUE;
|
||||
|
||||
#if __WINDOWS__
|
||||
{
|
||||
size_t buflen;
|
||||
char *pt;
|
||||
/* couldn't find it where it was supposed to be,
|
||||
let's try using the executable */
|
||||
if (!GetModuleFileName(NULL, LOCAL_FileNameBuf, YAP_FILENAME_MAX)) {
|
||||
Yap_WinError("could not find executable name");
|
||||
/* do nothing */
|
||||
return FALSE;
|
||||
}
|
||||
buflen = strlen(LOCAL_FileNameBuf);
|
||||
pt = LOCAL_FileNameBuf + buflen;
|
||||
while (*--pt != '\\') {
|
||||
/* skip executable */
|
||||
if (pt == LOCAL_FileNameBuf) {
|
||||
FileError(SYSTEM_ERROR_OPERATING_SYSTEM, TermNil,
|
||||
"could not find executable name");
|
||||
/* do nothing */
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
while (*--pt != '\\') {
|
||||
/* skip parent directory "bin\\" */
|
||||
if (pt == LOCAL_FileNameBuf) {
|
||||
FileError(SYSTEM_ERROR_OPERATING_SYSTEM, TermNil,
|
||||
"could not find executable name");
|
||||
/* do nothing */
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
/* now, this is a possible location for the ROOT_DIR, let's look for a share
|
||||
* directory here */
|
||||
pt[1] = '\0';
|
||||
/* grosse */
|
||||
strncat(LOCAL_FileNameBuf, "lib\\Yap", YAP_FILENAME_MAX);
|
||||
libdir = Yap_AllocCodeSpace(strlen(LOCAL_FileNameBuf) + 1);
|
||||
strncpy(libdir, LOCAL_FileNameBuf, strlen(LOCAL_FileNameBuf) + 1);
|
||||
pt[1] = '\0';
|
||||
strncat(LOCAL_FileNameBuf, "share", YAP_FILENAME_MAX);
|
||||
}
|
||||
strncat(LOCAL_FileNameBuf, "\\", YAP_FILENAME_MAX);
|
||||
len = strlen(LOCAL_FileNameBuf);
|
||||
strncat(LOCAL_FileNameBuf, "Yap", YAP_FILENAME_MAX);
|
||||
if (!dir_done && is_directory(LOCAL_FileNameBuf)) {
|
||||
if (!Yap_unify(tlib, MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf))))
|
||||
return FALSE;
|
||||
dir_done = true;
|
||||
}
|
||||
LOCAL_FileNameBuf[len] = '\0';
|
||||
strncat(LOCAL_FileNameBuf, "PrologCommons", YAP_FILENAME_MAX);
|
||||
if (!commons_done && is_directory(LOCAL_FileNameBuf)) {
|
||||
if (!Yap_unify(tcommons, MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf))))
|
||||
return FALSE;
|
||||
commons_done = true;
|
||||
}
|
||||
#endif
|
||||
return dir_done && commons_done;
|
||||
return Yap_unify(tcommons, MkAtomTerm(Yap_LookupAtom(Yap_COMMONSDIR)));
|
||||
}
|
||||
|
||||
static Int libraries_directories(USES_REGS1) {
|
||||
|
|
@ -1134,9 +1047,9 @@ int Yap_volume_header(char *file) { return volume_header(file); }
|
|||
const char *Yap_getcwd(char *cwd, size_t cwdlen) {
|
||||
if (virtual_cwd[0]) {
|
||||
if (!cwd) {
|
||||
cwd = malloc(cwdlen+1);
|
||||
cwd = malloc(cwdlen + 1);
|
||||
}
|
||||
strcpy( cwd, virtual_cwd);
|
||||
strcpy(cwd, virtual_cwd);
|
||||
return cwd;
|
||||
}
|
||||
#if _WIN32 || defined(__MINGW32__)
|
||||
|
|
@ -1171,184 +1084,6 @@ static Int working_directory(USES_REGS1) {
|
|||
return Yap_ChDir(RepAtom(AtomOfTerm(t2))->StrOfAE);
|
||||
}
|
||||
|
||||
/** Yap_findFile(): tries to locate a file, no expansion should be performed/
|
||||
*
|
||||
*
|
||||
* @param isource the proper file
|
||||
* @param idef the default name fothe file, ie, startup.yss
|
||||
* @param root the prefix
|
||||
* @param result the output
|
||||
* @param access verify whether the file has access permission
|
||||
* @param ftype saved state, object, saved file, prolog file
|
||||
* @param expand_root expand $ ~, etc
|
||||
* @param in_lib library file
|
||||
*
|
||||
* @return
|
||||
*/
|
||||
const char *Yap_findFile(const char *isource, const char *idef,
|
||||
const char *iroot, char *result, bool access,
|
||||
YAP_file_type_t ftype, bool expand_root, bool in_lib) {
|
||||
|
||||
char *save_buffer = NULL;
|
||||
char *root, *source;
|
||||
int rc = FAIL_RESTORE;
|
||||
int try = 0;
|
||||
bool abspath = false;
|
||||
|
||||
int lvl = push_text_stack();
|
||||
root = Malloc(YAP_FILENAME_MAX+1);
|
||||
source= Malloc(YAP_FILENAME_MAX+1);
|
||||
if (iroot && iroot[0])
|
||||
strcpy(root, iroot);
|
||||
else
|
||||
root[0] = 0;
|
||||
if (isource && isource[0])
|
||||
strcpy(source, isource);
|
||||
else
|
||||
source[0] = 0;
|
||||
//__android_log_print(ANDROID_LOG_ERROR, "YAPDroid " __FUNCTION__,
|
||||
// "try=%d %s %s", try, isource, iroot) ; }
|
||||
while (rc == FAIL_RESTORE) {
|
||||
// means we failed this iteration
|
||||
bool done = false;
|
||||
// { CACHE_REGS
|
||||
switch (try ++) {
|
||||
case 0: // path or file name is given;
|
||||
if (!source[0] && idef && idef[0]) {
|
||||
strcpy(source, idef);
|
||||
}
|
||||
if (source[0]) {
|
||||
abspath = Yap_IsAbsolutePath(source, expand_root);
|
||||
}
|
||||
if (!abspath && !root[0] && ftype == YAP_BOOT_PL) {
|
||||
strcpy(root, YAP_PL_SRCDIR);
|
||||
}
|
||||
break;
|
||||
case 1: // library directory is given in command line
|
||||
if (in_lib && ftype == YAP_SAVED_STATE) {
|
||||
if (iroot && iroot[0])
|
||||
strcpy(root, iroot);
|
||||
else
|
||||
root[0] = 0;
|
||||
if (isource && isource[0])
|
||||
strcpy(source, isource);
|
||||
else if (idef && idef[0])
|
||||
strcpy(source, idef);
|
||||
else
|
||||
source[0] = 0;
|
||||
} else {
|
||||
done = true;
|
||||
}
|
||||
break;
|
||||
case 3: // use compilation variable YAPLIBDIR
|
||||
if (in_lib) {
|
||||
if (isource && isource[0])
|
||||
strcpy(source, isource);
|
||||
else if (idef && idef[0])
|
||||
strcpy(source, idef);
|
||||
else
|
||||
source[0] = 0;
|
||||
if (ftype == YAP_PL) {
|
||||
strcpy(root,YAP_SHAREDIR);
|
||||
} else if (ftype == YAP_BOOT_PL) {
|
||||
strcpy(root, YAP_SHAREDIR);
|
||||
strcat(root,"/pl");
|
||||
} else {
|
||||
strcpy(root,YAP_LIBDIR);
|
||||
}
|
||||
} else
|
||||
done = true;
|
||||
break;
|
||||
|
||||
case 4: // WIN stuff: registry
|
||||
#if __WINDOWS
|
||||
if (in_lib) {
|
||||
const char *key = (ftype == YAP_PL || ftype == YAP_QLY ? "library" : "startup");
|
||||
strcpy( source, Yap_RegistryGetString(source) );
|
||||
root[0] = 0;
|
||||
} else
|
||||
#endif
|
||||
done = true;
|
||||
break;
|
||||
|
||||
case 5: // search from the binary
|
||||
#ifndef __ANDROID__
|
||||
{
|
||||
done = true;
|
||||
} break;
|
||||
#endif
|
||||
{
|
||||
const char *pt = Yap_FindExecutable();
|
||||
|
||||
if (pt) {
|
||||
if (ftype == YAP_BOOT_PL) {
|
||||
#if __ANDROID__
|
||||
strcpy(root, "../../../files/Yap/pl");
|
||||
#else
|
||||
root = "../../share/Yap/pl";
|
||||
#endif
|
||||
} else {
|
||||
strcpy(root, (ftype == YAP_SAVED_STATE || ftype == YAP_OBJ
|
||||
? "../../lib/Yap"
|
||||
: "../../share/Yap"));
|
||||
}
|
||||
if (strcmp(root, iroot) == 0) {
|
||||
done = true;
|
||||
continue;
|
||||
}
|
||||
if (!save_buffer) {
|
||||
save_buffer = Malloc(YAP_FILENAME_MAX + 1);
|
||||
|
||||
save_buffer[0] = 0;
|
||||
}
|
||||
if (Yap_findFile(source, NULL, root, save_buffer, access, ftype,
|
||||
expand_root, in_lib))
|
||||
strcpy(root, save_buffer);
|
||||
else
|
||||
done = true;
|
||||
} else {
|
||||
done = true;
|
||||
}
|
||||
if (isource && isource[0])
|
||||
strcpy(source, isource);
|
||||
else if (idef && idef[0])
|
||||
strcpy(source, idef);
|
||||
else
|
||||
source[0] = 0;
|
||||
}
|
||||
break;
|
||||
case 6: // default, try current directory
|
||||
if (!isource && ftype == YAP_SAVED_STATE)
|
||||
strcpy(source, idef);
|
||||
root[0] = 0;
|
||||
break;
|
||||
default:
|
||||
pop_text_stack(lvl);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (done)
|
||||
continue;
|
||||
// { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR, __FUNCTION__,
|
||||
// "root= %s %s ", root, source) ; }
|
||||
const char *work = PlExpandVars(source, root, result);
|
||||
|
||||
|
||||
// expand names in case you have
|
||||
// to add a prefix
|
||||
if (!access || Yap_Exists(work)) {
|
||||
work = pop_output_text_stack(lvl,work);
|
||||
return work; // done
|
||||
} else if (abspath) {
|
||||
pop_text_stack(lvl);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
pop_text_stack(lvl);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static Int true_file_name(USES_REGS1) {
|
||||
Term t = Deref(ARG1);
|
||||
const char *s;
|
||||
|
|
@ -1414,10 +1149,10 @@ static Int true_file_name3(USES_REGS1) {
|
|||
}
|
||||
root = RepAtom(AtomOfTerm(t2))->StrOfAE;
|
||||
}
|
||||
if (!Yap_findFile(RepAtom(AtomOfTerm(t))->StrOfAE, NULL, root,
|
||||
LOCAL_FileNameBuf, false, YAP_PL, false, false))
|
||||
char tmp[YAP_FILENAME_MAX + 1];
|
||||
if (!Yap_AbsoluteFile(RepAtom(AtomOfTerm(t))->StrOfAE, tmp, true))
|
||||
return FALSE;
|
||||
return Yap_unify(ARG3, MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)));
|
||||
return Yap_unify(ARG3, MkAtomTerm(Yap_LookupAtom(tmp)));
|
||||
}
|
||||
|
||||
/* Executes $SHELL under Prolog */
|
||||
|
|
@ -1864,7 +1599,7 @@ static Int p_win32(USES_REGS1) {
|
|||
}
|
||||
|
||||
static Int p_ld_path(USES_REGS1) {
|
||||
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom(YAP_DLLDIR)));
|
||||
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom(Yap_DLLDIR)));
|
||||
}
|
||||
|
||||
static Int p_address_bits(USES_REGS1) {
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ set(PL_BOOT_SOURCES
|
|||
attributes.yap
|
||||
boot.yap
|
||||
bootlists.yap
|
||||
bootutils.yap
|
||||
callcount.yap
|
||||
checker.yap
|
||||
consult.yap
|
||||
|
|
@ -84,6 +85,9 @@ install(FILES ${CMAKE_TOP_BINARY_DIR}/${YAP_STARTUP}
|
|||
endif()
|
||||
|
||||
|
||||
install(FILES ${PL_SOURCES}
|
||||
install(FILES ${PL_BOOT_SOURCES}
|
||||
DESTINATION ${libpl}/pl
|
||||
)
|
||||
install(FILES ../library/ypp.yap
|
||||
DESTINATION ${libpl}/library
|
||||
)
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@
|
|||
:- system_module( '$_arith', [compile_expressions/0,
|
||||
expand_exprs/2,
|
||||
plus/3,
|
||||
succ/2], ['$c_built_in'/3]).
|
||||
succ/2], ['$c_built_in'/4]).
|
||||
|
||||
:- private( [do_c_built_in/3,
|
||||
do_c_built_metacall/3,
|
||||
|
|
@ -86,7 +86,6 @@ expand_exprs(Old,New) :-
|
|||
After a call to this predicate, arithmetical expressions will be compiled.
|
||||
(see example below). This is the default behavior.
|
||||
*/
|
||||
|
||||
compile_expressions :- set_value('$c_arith',true).
|
||||
|
||||
/** @pred do_not_compile_expressions
|
||||
|
|
|
|||
|
|
@ -118,6 +118,7 @@ otherwise.
|
|||
|
||||
:- compile_expressions.
|
||||
|
||||
|
||||
:- bootstrap('bootutils.yap').
|
||||
:- bootstrap('bootlists.yap').
|
||||
:- bootstrap('consult.yap').
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ variable:
|
|||
+ YAPLIBDIR
|
||||
|
||||
if defined, or in the default library.
|
||||
|
||||
available as
|
||||
YAP supports the SWI-Prolog interface to loading foreign code, the shlib package.
|
||||
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -30,6 +30,9 @@ meta_predicate declaration
|
|||
|
||||
% directive now meta_predicate Ps :- $meta_predicate(Ps).
|
||||
|
||||
:- use_system_module( '$_arith', ['$c_built_in'/4]).
|
||||
|
||||
|
||||
:- dynamic prolog:'$meta_predicate'/4.
|
||||
|
||||
:- multifile prolog:'$meta_predicate'/4,
|
||||
|
|
|
|||
Reference in New Issue