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

Fixes, mostly to the biting o

Browse Source
This commit is contained in:
Vitor Santos Costa 2017-12-10 01:22:45 +00:00
parent 645b2c7d93
commit 3061844c95
22 changed files with 3137 additions and 3546 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

724
C/c_interface.c
View File

File diff suppressed because it is too large Load Diff

25
C/load_dl.c
View File

@ -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
View File

@ -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
View File

@ -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);

8
C/stdpreds.c
View File

@ -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
View File

@ -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
View File

@ -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;
}

7
CMakeLists.txt
View File

@ -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
View File

@ -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 */

2
H/YapGFlagInfo.h
View File

@ -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
View File

@ -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
View File

@ -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);

16
config.h.cmake
View File

@ -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

8
os/iopreds.c
View File

@ -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) {

1
os/iopreds.h
View File

@ -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
View File

@ -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) {

6
pl/CMakeLists.txt
View File

@ -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
)

3
pl/arith.yap
View File

@ -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

1
pl/init.yap
View File

@ -118,6 +118,7 @@ otherwise.
:- compile_expressions.
:- bootstrap('bootutils.yap').
:- bootstrap('bootlists.yap').
:- bootstrap('consult.yap').

2
pl/load_foreign.yap
View File

@ -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.
*/

3
pl/meta.yap
View File

@ -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,