yap-6.3/C/yap-args.c

/*************************************************************************
 *									 *
 *	 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;
          printf("%s -> %s\n", inp, o);
          if ((no = location(iap, p, io)) && io[0] != '\0' && Yap_Exists(o))
            return pop_output_text_stack(lvl, realpath(o, full));
        }
      } else {
        printf("-> %s\n", o);
        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;
}