1164 lines
34 KiB
C
Executable File
1164 lines
34 KiB
C
Executable File
/*************************************************************************
|
|
* *
|
|
* Yap Prolog *
|
|
* *
|
|
* Yap Prolog Was Developed At Nccup - Universidade Do Porto *
|
|
* *
|
|
* Copyright L.Damas, V.S.Costa And Universidade Do Porto 1985-1997 *
|
|
* *
|
|
**************************************************************************
|
|
* *
|
|
* File: Yap.C * Last
|
|
*Rev:
|
|
* Mods:
|
|
** Comments: Yap's Main File: parse arguments *
|
|
* *
|
|
*************************************************************************/
|
|
/* static char SccsId[] = "X 4.3.3"; */
|
|
|
|
#include "Yap.h"
|
|
#include "YapHeap.h"
|
|
#include "YapInterface.h"
|
|
#include "YapStreams.h"
|
|
#include "config.h"
|
|
|
|
#if HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
#if HAVE_STDINT_H
|
|
|
|
#include <stdint.h>
|
|
|
|
#endif
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */
|
|
#ifdef HAVE_UNISTD_H
|
|
#undef HAVE_UNISTD_H
|
|
#endif
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
|
|
#if HAVE_STRING_H
|
|
|
|
#include <string.h>
|
|
|
|
#endif
|
|
#if HAVE_ERRNO_H
|
|
|
|
#include <errno.h>
|
|
|
|
#endif
|
|
#if HAVE_DIRECT_H
|
|
#include <direct.h>
|
|
#endif
|
|
|
|
#if HAVE_LIBGEN_H
|
|
#include <libgen.h>
|
|
|
|
#endif
|
|
|
|
const char *Yap_BINDIR, *Yap_ROOTDIR, *Yap_SHAREDIR, *Yap_LIBDIR, *Yap_DLLDIR,
|
|
*Yap_PLDIR, *Yap_BOOTPLDIR, *Yap_BOOTSTRAPPLDIR, *Yap_COMMONSDIR,
|
|
*Yap_STARTUP, *Yap_BOOTFILE;
|
|
|
|
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", "/", "/usr",
|
|
"/opt", "$HOME", "$PWD", NULL};
|
|
|
|
const char *bindirs[] = {"[bin]", "(root)bin", NULL};
|
|
|
|
const char *libdirs[] = {
|
|
#if __ANDROID__
|
|
"/assets/lib",
|
|
#endif
|
|
"[lib]", "(root)lib", NULL};
|
|
|
|
const char *sharedirs[] = {
|
|
#if __ANDROID__
|
|
"/assets/share",
|
|
#endif
|
|
"[share]", "(root)share", NULL};
|
|
|
|
const char *dlldirs[] = {"$YAPLIBDIR", "(lib)Yap", "$PWD", NULL};
|
|
|
|
const char *ssdirs[] = {"$PWD", "$YAPLIBDIR", "(lib)Yap", NULL};
|
|
|
|
const char *pldirs[] = {"$YAPSHAREDIR", "?library", "(share)Yap", "$PWD", NULL};
|
|
|
|
const char *bootpldirs[] = {"(pl)pl", "$PWD", NULL};
|
|
|
|
const char *bootstrappldirs[] = {YAP_PL_SRCDIR, NULL};
|
|
|
|
const char *commonsdirs[] = {"(share)PrologCommons", "$PWD", 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;
|
|
}
|
|
out[0] = '\0';
|
|
if (inp[0] == '(') {
|
|
if (strstr(inp + 1, "root") == inp + 1 && Yap_ROOTDIR &&
|
|
Yap_ROOTDIR[0] != '\0') {
|
|
strcpy(out, Yap_ROOTDIR);
|
|
strcat(out, "/");
|
|
strcat(out, inp + strlen("(root)"));
|
|
} else if (strstr(inp + 1, "bin") == inp + 1 && Yap_BINDIR &&
|
|
Yap_BINDIR[0] != '\0') {
|
|
strcpy(out, Yap_BINDIR);
|
|
strcat(out, "/");
|
|
strcat(out, inp + strlen("(bin)"));
|
|
} else if (strstr(inp + 1, "lib") == inp + 1 && Yap_LIBDIR &&
|
|
Yap_LIBDIR[0] != '\0') {
|
|
strcpy(out, Yap_LIBDIR);
|
|
strcat(out, "/");
|
|
strcat(out, inp + strlen("(lib)"));
|
|
} else if (strstr(inp + 1, "share") == inp + 1 && Yap_SHAREDIR &&
|
|
Yap_SHAREDIR[0] != '\0') {
|
|
strcpy(out, Yap_SHAREDIR);
|
|
strcat(out, "/");
|
|
strcat(out, inp + strlen("(share)"));
|
|
} else if (strstr(inp + 1, "pl") == inp + 1 && Yap_PLDIR &&
|
|
Yap_PLDIR[0] != '\0') {
|
|
strcpy(out, Yap_PLDIR);
|
|
strcat(out, "/");
|
|
strcat(out, inp + strlen("(pl)"));
|
|
} else if (strstr(inp + 1, "execdir") == inp + 1) {
|
|
char *buf = Malloc(YAP_FILENAME_MAX + 1);
|
|
const char *ex = Yap_AbsoluteFile(Yap_FindExecutable(), buf, false);
|
|
if (ex != NULL) {
|
|
strcpy(out, dirname((char *)ex));
|
|
strcat(out, "/");
|
|
strcat(out, inp + strlen("(execdir)"));
|
|
}
|
|
}
|
|
} 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);
|
|
}
|
|
} else if (inp[0] == '$') {
|
|
char *e;
|
|
if ((e = getenv(inp + 1)) != NULL) {
|
|
strcpy(out, e);
|
|
}
|
|
} else if (inp[0] == '?') {
|
|
#if _WINDOWS_
|
|
char *e;
|
|
if ((e = Yap_RegistryGetString(inp + 1)) != NULL) {
|
|
strcpy(out, e);
|
|
}
|
|
#endif
|
|
} else if (inp[0] == '~') {
|
|
char *e;
|
|
if ((e = getenv("HOME")) != NULL) {
|
|
if (inp[1] == '\0') {
|
|
strcpy(out, e);
|
|
} else if (inp[1] == '/') {
|
|
strcpy(out, e);
|
|
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);
|
|
#endif
|
|
} else if (strstr(inp + 1, "lib") == inp + 1) {
|
|
#ifdef YAP_LIBDIR
|
|
strcpy(o, YAP_LIBDIR);
|
|
#endif
|
|
} else if (strstr(inp + 1, "share") == inp + 1) {
|
|
#ifdef YAP_SHAREDIR
|
|
strcpy(o, YAP_SHAREDIR);
|
|
#endif
|
|
} else if (strstr(inp + 1, "dll") == inp + 1) {
|
|
#ifdef YAP_DLLDIR
|
|
strcpy(o, YAP_DLLDIR);
|
|
#endif
|
|
} else if (strstr(inp + 1, "pl") == inp + 1) {
|
|
#ifdef YAP_PLDIR
|
|
strcpy(o, YAP_PLDIR);
|
|
#endif
|
|
} else if (strstr(inp + 1, "commons") == inp + 1) {
|
|
#ifdef YAP_COMMONSDIR
|
|
strcpy(o, YAP_COMMONSDIR);
|
|
#endif
|
|
}
|
|
} else {
|
|
strcpy(out, inp);
|
|
}
|
|
if (out[0]) {
|
|
return out;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*
|
|
* It treats the following variables as :
|
|
* ROOTDIR, SHAREDIR, LIBDIR, EXECUTABLE
|
|
*
|
|
* @return
|
|
*/
|
|
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 *full;
|
|
if (names) {
|
|
full = Malloc(YAP_FILENAME_MAX + 1);
|
|
}
|
|
int i = 0;
|
|
while ((inp = paths[i++]) != NULL) {
|
|
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));
|
|
}
|
|
} 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")) {
|
|
int lvl = push_text_stack();
|
|
const char *path = getenv("PATH");
|
|
char *o = &path[0L], *no, *p;
|
|
char *buf = Malloc(YAP_FILENAME_MAX + 1);
|
|
o = Malloc(strlen(path) + 1);
|
|
strcpy(o, path);
|
|
if ((p = strstr(o, "anaconda"))) {
|
|
char *q = p + strlen("anaconda"), *r = strstr(q, "/bin");
|
|
if (r - q > 0 && r - q < 10 && (r[4] == ':' || r[4] == '\0')) {
|
|
r[0] = '\0';
|
|
q = strrchr(o, ':');
|
|
if (q)
|
|
o = q + 1;
|
|
} else
|
|
o = NULL;
|
|
}
|
|
Yap_ROOTDIR = pop_output_text_stack(lvl, o);
|
|
}
|
|
if (!Yap_ROOTDIR)
|
|
#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);
|
|
if (Yap_ROOTDIR)
|
|
setAtomicGlobalPrologFlag(HOME_FLAG,
|
|
MkAtomTerm(Yap_LookupAtom(Yap_ROOTDIR)));
|
|
if (Yap_PLDIR)
|
|
setAtomicGlobalPrologFlag(PROLOG_LIBRARY_DIRECTORY_FLAG,
|
|
MkAtomTerm(Yap_LookupAtom(Yap_PLDIR)));
|
|
if (Yap_DLLDIR)
|
|
setAtomicGlobalPrologFlag(PROLOG_FOREIGN_DIRECTORY_FLAG,
|
|
MkAtomTerm(Yap_LookupAtom(Yap_DLLDIR)));
|
|
}
|
|
|
|
static void print_usage(void) {
|
|
fprintf(stderr, "\n[ Valid switches for command line arguments: ]\n");
|
|
fprintf(stderr, " -? Shows this screen\n");
|
|
fprintf(stderr, " -b Boot file \n");
|
|
fprintf(stderr, " -dump-runtime-variables\n");
|
|
fprintf(stderr, " -f initialization file or \"none\"\n");
|
|
fprintf(stderr, " -g Run Goal Before Top-Level \n");
|
|
fprintf(stderr, " -z Run Goal Before Top-Level \n");
|
|
fprintf(stderr, " -q start with informational messages off\n");
|
|
fprintf(stderr, " -l load Prolog file\n");
|
|
fprintf(stderr, " -L run Prolog file and exit\n");
|
|
fprintf(stderr, " -p extra path for file-search-path\n");
|
|
fprintf(stderr, " -hSize Heap area in Kbytes (default: %d, minimum: %d)\n",
|
|
DefHeapSpace, MinHeapSpace);
|
|
fprintf(stderr,
|
|
" -sSize Stack area in Kbytes (default: %d, minimum: %d)\n",
|
|
DefStackSpace, MinStackSpace);
|
|
fprintf(stderr,
|
|
" -tSize Trail area in Kbytes (default: %d, minimum: %d)\n",
|
|
DefTrailSpace, MinTrailSpace);
|
|
fprintf(stderr, " -GSize Max Area for Global Stack\n");
|
|
fprintf(stderr,
|
|
" -LSize Max Area for Local Stack (number must follow L)\n");
|
|
fprintf(stderr, " -TSize Max Area for Trail (number must follow T)\n");
|
|
fprintf(stderr, " -nosignals disable signal handling from Prolog\n");
|
|
fprintf(stderr, "\n[Execution Modes]\n");
|
|
fprintf(stderr, " -J0 Interpreted mode (default)\n");
|
|
fprintf(stderr, " -J1 Mixed mode only for user predicates\n");
|
|
fprintf(stderr, " -J2 Mixed mode for all predicates\n");
|
|
fprintf(stderr, " -J3 Compile all user predicates\n");
|
|
fprintf(stderr, " -J4 Compile all predicates\n");
|
|
|
|
#ifdef TABLING
|
|
fprintf(stderr,
|
|
" -ts Maximum table space area in Mbytes (default: unlimited)\n");
|
|
#endif /* TABLING */
|
|
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA) || \
|
|
defined(YAPOR_THREADS)
|
|
fprintf(stderr, " -w Number of workers (default: %d)\n",
|
|
DEFAULT_NUMBERWORKERS);
|
|
fprintf(stderr,
|
|
" -sl Loop scheduler executions before look for hiden "
|
|
"shared work (default: %d)\n",
|
|
DEFAULT_SCHEDULERLOOP);
|
|
fprintf(stderr, " -d Value of delayed release of load (default: %d)\n",
|
|
DEFAULT_DELAYEDRELEASELOAD);
|
|
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA || YAPOR_THREADS */
|
|
/* nf: Preprocessor */
|
|
/* fprintf(stderr," -DVar=Name Persistent definition\n"); */
|
|
fprintf(stderr, "\n");
|
|
}
|
|
|
|
static int myisblank(int c) {
|
|
switch (c) {
|
|
case ' ':
|
|
case '\t':
|
|
case '\n':
|
|
case '\r':
|
|
return TRUE;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static char *add_end_dot(char arg[]) {
|
|
int sz = strlen(arg), i;
|
|
i = sz;
|
|
while (i && myisblank(arg[--i]))
|
|
;
|
|
if (i && arg[i] != ',') {
|
|
char *p = (char *)malloc(sz + 2);
|
|
if (!p)
|
|
return NULL;
|
|
strncpy(p, arg, sz);
|
|
p[sz] = '.';
|
|
p[sz + 1] = '\0';
|
|
return p;
|
|
}
|
|
return arg;
|
|
}
|
|
|
|
static int dump_runtime_variables(void) {
|
|
fprintf(stdout, "CC=\"%s\"\n", C_CC);
|
|
fprintf(stdout, "YAP_ROOTDIR=\"%s\"\n", YAP_ROOTDIR);
|
|
fprintf(stdout, "YAP_LIBS=\"%s\"\n", C_LIBS);
|
|
fprintf(stdout, "YAP_SHLIB_SUFFIX=\"%s\"\n", SO_EXT);
|
|
fprintf(stdout, "YAP_VERSION=%s\n", YAP_NUMERIC_VERSION);
|
|
exit(0);
|
|
return 1;
|
|
}
|
|
|
|
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__
|
|
iap->boot_file_type = YAP_BOOT_PL;
|
|
iap->SavedState = NULL;
|
|
iap->assetManager = NULL;
|
|
#else
|
|
iap->boot_file_type = YAP_QLY;
|
|
iap->SavedState = saved_state;
|
|
#endif
|
|
iap->Argc = argc;
|
|
iap->Argv = argv;
|
|
return YAP_QLY;
|
|
}
|
|
|
|
/**
|
|
* @short Paese command line
|
|
* @param argc number of arguments
|
|
* @param argv arguments
|
|
* @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[],
|
|
YAP_init_args *iap) {
|
|
char *p;
|
|
size_t *ssize;
|
|
|
|
Yap_InitDefaults(iap, NULL, argc, argv);
|
|
while (--argc > 0) {
|
|
p = *++argv;
|
|
if (*p == '-')
|
|
switch (*++p) {
|
|
case 'b':
|
|
iap->boot_file_type = YAP_PL;
|
|
if (p[1])
|
|
iap->YapPrologBootFile = p + 1;
|
|
else if (argv[1] && *argv[1] != '-') {
|
|
iap->YapPrologBootFile = *++argv;
|
|
argc--;
|
|
} else {
|
|
iap->YapPrologBootFile = "boot.yap";
|
|
}
|
|
break;
|
|
case 'B':
|
|
iap->boot_file_type = YAP_BOOT_PL;
|
|
if (p[1])
|
|
iap->YapPrologBootFile = p + 1;
|
|
else if (argv[1] && *argv[1] != '-') {
|
|
iap->YapPrologBootFile = *++argv;
|
|
argc--;
|
|
} else {
|
|
iap->YapPrologBootFile = NULL;
|
|
}
|
|
iap->bootstrapping = true;
|
|
break;
|
|
case '?':
|
|
print_usage();
|
|
exit(EXIT_SUCCESS);
|
|
case 'q':
|
|
iap->QuietMode = TRUE;
|
|
break;
|
|
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA) || \
|
|
defined(YAPOR_THREADS)
|
|
case 'w':
|
|
ssize = &(iap->NumberWorkers);
|
|
goto GetSize;
|
|
case 'd':
|
|
if (!strcmp("dump-runtime-variables", p))
|
|
return dump_runtime_variables();
|
|
ssize = &(iap->DelayedReleaseLoad);
|
|
goto GetSize;
|
|
#else
|
|
case 'd':
|
|
if (!strcmp("dump-runtime-variables", p))
|
|
return dump_runtime_variables();
|
|
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA || YAPOR_THREADS */
|
|
case 'F':
|
|
/* just ignore for now */
|
|
argc--;
|
|
argv++;
|
|
break;
|
|
case 'f':
|
|
iap->FastBoot = TRUE;
|
|
if (argc > 1 && argv[1][0] != '-') {
|
|
argc--;
|
|
argv++;
|
|
if (strcmp(*argv, "none")) {
|
|
iap->YapPrologRCFile = *argv;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
// execution mode
|
|
case 'J':
|
|
switch (p[1]) {
|
|
case '0':
|
|
iap->ExecutionMode = YAPC_INTERPRETED;
|
|
break;
|
|
case '1':
|
|
iap->ExecutionMode = YAPC_MIXED_MODE_USER;
|
|
break;
|
|
case '2':
|
|
iap->ExecutionMode = YAPC_MIXED_MODE_ALL;
|
|
break;
|
|
case '3':
|
|
iap->ExecutionMode = YAPC_COMPILE_USER;
|
|
break;
|
|
case '4':
|
|
iap->ExecutionMode = YAPC_COMPILE_ALL;
|
|
break;
|
|
default:
|
|
fprintf(stderr, "[ YAP unrecoverable error: unknown switch -%c%c ]\n",
|
|
*p, p[1]);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
p++;
|
|
break;
|
|
case 'G':
|
|
ssize = &(iap->MaxGlobalSize);
|
|
goto GetSize;
|
|
break;
|
|
case 's':
|
|
case 'S':
|
|
ssize = &(iap->StackSize);
|
|
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA) || \
|
|
defined(YAPOR_THREADS)
|
|
if (p[1] == 'l') {
|
|
p++;
|
|
ssize = &(iap->SchedulerLoop);
|
|
}
|
|
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA || YAPOR_THREADS */
|
|
goto GetSize;
|
|
case 'a':
|
|
case 'A':
|
|
ssize = &(iap->AttsSize);
|
|
goto GetSize;
|
|
case 'T':
|
|
ssize = &(iap->MaxTrailSize);
|
|
goto get_trail_size;
|
|
case 't':
|
|
ssize = &(iap->TrailSize);
|
|
#ifdef TABLING
|
|
if (p[1] == 's') {
|
|
p++;
|
|
ssize = &(iap->MaxTableSpaceSize);
|
|
}
|
|
#endif /* TABLING */
|
|
get_trail_size:
|
|
if (*++p == '\0') {
|
|
if (argc > 1)
|
|
--argc, p = *++argv;
|
|
else {
|
|
fprintf(stderr,
|
|
"[ YAP unrecoverable error: missing size in flag %s ]",
|
|
argv[0]);
|
|
print_usage();
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
{
|
|
unsigned long int i = 0, ch;
|
|
while ((ch = *p++) >= '0' && ch <= '9')
|
|
i = i * 10 + ch - '0';
|
|
switch (ch) {
|
|
case 'M':
|
|
case 'm':
|
|
i *= 1024;
|
|
ch = *p++;
|
|
break;
|
|
case 'g':
|
|
i *= 1024 * 1024;
|
|
ch = *p++;
|
|
break;
|
|
case 'k':
|
|
case 'K':
|
|
ch = *p++;
|
|
break;
|
|
}
|
|
if (ch) {
|
|
iap->YapPrologTopLevelGoal = add_end_dot(*argv);
|
|
} else {
|
|
*ssize = i;
|
|
}
|
|
}
|
|
break;
|
|
case 'h':
|
|
case 'H':
|
|
ssize = &(iap->HeapSize);
|
|
GetSize:
|
|
if (*++p == '\0') {
|
|
if (argc > 1)
|
|
--argc, p = *++argv;
|
|
else {
|
|
fprintf(stderr,
|
|
"[ YAP unrecoverable error: missing size in flag %s ]",
|
|
argv[0]);
|
|
print_usage();
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
{
|
|
unsigned long int i = 0, ch;
|
|
while ((ch = *p++) >= '0' && ch <= '9')
|
|
i = i * 10 + ch - '0';
|
|
switch (ch) {
|
|
case 'M':
|
|
case 'm':
|
|
i *= 1024;
|
|
ch = *p++;
|
|
break;
|
|
case 'g':
|
|
case 'G':
|
|
i *= 1024 * 1024;
|
|
ch = *p++;
|
|
break;
|
|
case 'k':
|
|
case 'K':
|
|
ch = *p++;
|
|
break;
|
|
}
|
|
if (ch) {
|
|
fprintf(
|
|
stderr,
|
|
"[ YAP unrecoverable error: illegal size specification %s ]",
|
|
argv[-1]);
|
|
Yap_exit(1);
|
|
}
|
|
*ssize = i;
|
|
}
|
|
break;
|
|
#ifdef DEBUG
|
|
case 'P':
|
|
if (p[1] != '\0') {
|
|
while (p[1] != '\0') {
|
|
int ch = p[1];
|
|
if (ch >= 'A' && ch <= 'Z')
|
|
ch += ('a' - 'A');
|
|
if (ch >= 'a' && ch <= 'z')
|
|
GLOBAL_Option[ch - 96] = 1;
|
|
p++;
|
|
}
|
|
} else {
|
|
YAP_SetOutputMessage();
|
|
}
|
|
break;
|
|
#endif
|
|
case 'L':
|
|
if (p[1] && p[1] >= '0' &&
|
|
p[1] <= '9') /* hack to emulate SWI's L local option */
|
|
{
|
|
ssize = &(iap->MaxStackSize);
|
|
goto GetSize;
|
|
}
|
|
iap->QuietMode = TRUE;
|
|
iap->HaltAfterConsult = TRUE;
|
|
case 'l':
|
|
p++;
|
|
if (!*++argv) {
|
|
fprintf(stderr,
|
|
"%% YAP unrecoverable error: missing load file name\n");
|
|
exit(1);
|
|
} else if (!strcmp("--", *argv)) {
|
|
/* shell script, the next entry should be the file itself */
|
|
iap->YapPrologRCFile = argv[1];
|
|
argc = 1;
|
|
break;
|
|
} else {
|
|
iap->YapPrologRCFile = *argv;
|
|
argc--;
|
|
}
|
|
if (*p) {
|
|
/* we have something, usually, of the form:
|
|
-L --
|
|
FileName
|
|
ExtraArgs
|
|
*/
|
|
/* being called from a script */
|
|
while (*p && (*p == ' ' || *p == '\t'))
|
|
p++;
|
|
if (p[0] == '-' && p[1] == '-') {
|
|
/* ignore what is next */
|
|
argc = 1;
|
|
}
|
|
}
|
|
break;
|
|
/* run goal before top-level */
|
|
case 'g':
|
|
if ((*argv)[0] == '\0')
|
|
iap->YapPrologGoal = *argv;
|
|
else {
|
|
argc--;
|
|
if (argc == 0) {
|
|
fprintf(stderr, " [ YAP unrecoverable error: missing "
|
|
"initialization goal for option 'g' ]\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
argv++;
|
|
iap->YapPrologGoal = *argv;
|
|
}
|
|
break;
|
|
/* run goal as top-level */
|
|
case 'z':
|
|
if ((*argv)[0] == '\0')
|
|
iap->YapPrologTopLevelGoal = *argv;
|
|
else {
|
|
argc--;
|
|
if (argc == 0) {
|
|
fprintf(stderr, " [ YAP unrecoverable error: missing goal for "
|
|
"option 'z' ]\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
argv++;
|
|
iap->YapPrologTopLevelGoal = add_end_dot(*argv);
|
|
}
|
|
break;
|
|
case 'n':
|
|
if (!strcmp("nosignals", p)) {
|
|
iap->PrologCannotHandleInterrupts = true;
|
|
break;
|
|
}
|
|
break;
|
|
case '-':
|
|
if (!strcmp("-nosignals", p)) {
|
|
iap->PrologCannotHandleInterrupts = true;
|
|
break;
|
|
} else if (!strncmp("-home=", p, strlen("-home="))) {
|
|
GLOBAL_Home = p + strlen("-home=");
|
|
} else if (!strncmp("-cwd=", p, strlen("-cwd="))) {
|
|
if (!Yap_ChDir(p + strlen("-cwd="))) {
|
|
fprintf(stderr, " [ YAP unrecoverable error in setting cwd: %s ]\n",
|
|
strerror(errno));
|
|
}
|
|
} else if (!strncmp("-stack=", p, strlen("-stack="))) {
|
|
ssize = &(iap->StackSize);
|
|
p += strlen("-stack=");
|
|
goto GetSize;
|
|
} else if (!strncmp("-trail=", p, strlen("-trail="))) {
|
|
ssize = &(iap->TrailSize);
|
|
p += strlen("-trail=");
|
|
goto GetSize;
|
|
} else if (!strncmp("-heap=", p, strlen("-heap="))) {
|
|
ssize = &(iap->HeapSize);
|
|
p += strlen("-heap=");
|
|
goto GetSize;
|
|
} else if (!strncmp("-goal=", p, strlen("-goal="))) {
|
|
iap->YapPrologGoal = p + strlen("-goal=");
|
|
} else if (!strncmp("-top-level=", p, strlen("-top-level="))) {
|
|
iap->YapPrologTopLevelGoal = p + strlen("-top-level=");
|
|
} else if (!strncmp("-table=", p, strlen("-table="))) {
|
|
ssize = &(iap->MaxTableSpaceSize);
|
|
p += strlen("-table=");
|
|
goto GetSize;
|
|
} else if (!strncmp("-", p, strlen("-="))) {
|
|
ssize = &(iap->MaxTableSpaceSize);
|
|
p += strlen("-table=");
|
|
/* skip remaining arguments */
|
|
argc = 1;
|
|
}
|
|
break;
|
|
case 'p':
|
|
if ((*argv)[0] == '\0')
|
|
iap->YapPrologAddPath = *argv;
|
|
else {
|
|
argc--;
|
|
if (argc == 0) {
|
|
fprintf(stderr, " [ YAP unrecoverable error: missing paths for "
|
|
"option 'p' ]\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
argv++;
|
|
iap->YapPrologAddPath = *argv;
|
|
}
|
|
break;
|
|
/* nf: Begin preprocessor code */
|
|
case 'D': {
|
|
char *var, *value;
|
|
++p;
|
|
var = p;
|
|
if (var == NULL || *var == '\0')
|
|
break;
|
|
while (*p != '=' && *p != '\0')
|
|
++p;
|
|
if (*p == '\0')
|
|
break;
|
|
*p = '\0';
|
|
++p;
|
|
value = p;
|
|
if (*value == '\0')
|
|
break;
|
|
if (iap->def_c == YAP_MAX_YPP_DEFS)
|
|
break;
|
|
iap->def_var[iap->def_c] = var;
|
|
iap->def_value[iap->def_c] = value;
|
|
++(iap->def_c);
|
|
break;
|
|
}
|
|
/* End preprocessor code */
|
|
default: {
|
|
fprintf(stderr, "[ YAP unrecoverable error: unknown switch -%c ]\n",
|
|
*p);
|
|
print_usage();
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
else {
|
|
iap->SavedState = p;
|
|
}
|
|
}
|
|
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;
|
|
}
|