text: #ifndef PL_YAP_H
  #define PL_YAP_H
  
  #ifdef __YAP_PROLOG__
  
  #include "Yatom.h"
  
  /* depends on tag schema, but 4 should always do */
  #define LMASK_BITS	4		/* total # mask bits */
  
  #if HAVE_CTYPE_H
  #include <ctype.h>
  #endif
  
  #if HAVE_SYS_STAT_H
  #include <sys/stat.h>
  #endif
  
  #define SIZE_VOIDP SIZEOF_INT_P
  
  
  #if SIZEOF_LONG_INT==4
  #define INT64_FORMAT "%lld"
  #else
  #define INT64_FORMAT "%ld"
  #endif
  #define INTBITSIZE (sizeof(int)*8)
  
  typedef module_t	        Module;
  typedef Term		(*Func)(term_t);	/* foreign functions */
  
  extern const char *Yap_GetCurrentPredName(void);
  extern Int     Yap_GetCurrentPredArity(void);
  extern term_t Yap_fetch_module_for_format(term_t args, Term *modp);
  extern IOENC Yap_DefaultEncoding(void);
  extern void Yap_SetDefaultEncoding(IOENC);
  extern void Yap_setCurrentSourceLocation( void *rd );
  extern void   *Yap_GetStreamHandle(Atom at);
  
  extern atom_t codeToAtom(int chrcode);
  
  #define valTermRef(t)    ((Word)Yap_AddressFromSlot(t PASS_REGS))
  
  #include "pl-codelist.h"
  
  //move this to SWI
  
  #define GP_CREATE	2		/* create (in this module) */
  
  #ifndef HAVE_MBSCOLL
  COMMON(int) mbscoll(const char *s1, const char *s2);
  #endif
  
  
  #ifndef HAVE_MBSCASECOLL
  COMMON(int) mbscasecoll(const char *s1, const char *s2);
  #endif
  
  COMMON(atom_t) 		TemporaryFile(const char *id, int *fdp);
  COMMON(char *) 		Getenv(const char *, char *buf, size_t buflen);
  
  /*** memory allocation stuff: SWI wraps around malloc  */
  
  #define stopItimer()
  
  COMMON(word) 		pl_print(term_t term);
  COMMON(word) 		pl_write(term_t term);
  COMMON(word) 		pl_write_canonical(term_t term);
  COMMON(word) 		pl_write_term(term_t term, term_t options);
  COMMON(word) 		pl_writeq(term_t term);
  
  static inline int
  get_procedure(term_t descr, predicate_t *proc, term_t he, int f) {
    CACHE_REGS
    Term t = Yap_GetFromSlot(descr PASS_REGS);
  
    if (IsVarTerm(t)) return FALSE;
    if (IsAtomTerm(t)) 
      *proc = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t),CurrentModule));
    else if (IsApplTerm(t)) {
      Functor f = FunctorOfTerm(t);
      if (IsExtensionFunctor(f)) {
        return FALSE;
      } 
      *proc = RepPredProp(Yap_GetPredPropByFunc(f, CurrentModule));
    }
    return TRUE;
  }
  
  COMMON(intptr_t) 	lengthList(term_t list, int errors);
  COMMON(int)		promoteToFloatNumber(Number n);
  COMMON(char *) 		PrologPath(const char *ospath, char *plpath, size_t len);
  COMMON(char *) 		ExpandOneFile(const char *spec, char *file);
  COMMON(char *) 		AbsoluteFile(const char *spec, char *path);
  COMMON(char *) 		BaseName(const char *f);
  COMMON(bool) 		ChDir(const char *path);
  COMMON(char *) 		OsPath(const char *plpath, char *ospath);
  COMMON(bool) 		ChDir(const char *path);
  COMMON(int) 		DeleteTemporaryFile(atom_t name);
  COMMON(int) 		IsAbsolutePath(const char *spec);
  
  COMMON(bool) 		sysError(const char *fm, ...);
  
  COMMON(int)		setDoubleQuotes(atom_t a, unsigned int *flagp);
  
  COMMON(int)		getAccessLevelMask(atom_t a, access_level_t *val);
  
  /* TBD */
  
  extern word globalString(size_t size, char *s);
  extern word globalWString(size_t size, wchar_t *s);
  
  #define allocHeap(n)		allocHeap__LD(n PASS_LD)
  
  #define valHandle(r) valHandle__LD(r PASS_LD)
  
  Int                   YAP_PLArityOfSWIFunctor(functor_t f);
  struct PL_blob_t*     YAP_find_blob_type(Atom at);
  
  void PL_license(const char *license, const char *module);
  
  
  #define arityFunctor(f) YAP_PLArityOfSWIFunctor(f)
  
  #define stringAtom(w)	(YAP_AtomFromSWIAtom(w)->StrOfAE)
  #define isInteger(A) (!IsVarTerm(A) && ( IsIntegerTerm((A)) || YAP_IsBigNumTerm((A)) ))
  #define isString(A) (!IsVarTerm(A) && IsStringTerm(A) )
  #define isAtom(A) (!IsVarTerm(A) && IsAtomTerm((A)) )
  #define isList(A) (!IsVarTerm(A) && IsPairTerm((A)) )
  #define isNil(A) ((A) == TermNil)
  #define isReal(A) (!IsVarTerm(A) && IsFloatTerm((A)) )
  #define isFloat(A) (!IsVarTerm(A) && IsFloatTerm((A)) )
  #define isVar(A) IsVarTerm((A))
  #define valReal(w) FloatOfTerm((w))
  #define valFloat(w) FloatOfTerm((w))
  #define atomValue(atom) AtomOfTerm(atom)
  #define atomFromTerm(term) YAP_SWIAtomFromAtom(AtomOfTerm(term))
  
  inline static char *
  atomName(Atom atom)
  {
    if (IsWideAtom(atom)) 
      return (char *)(atom->WStrOfAE);
    return atom->StrOfAE;
  }
  
  #define nameOfAtom(atom) nameOfAtom(atom)
  
  #define atomBlobType(at) YAP_find_blob_type(at)
  #define argTermP(w,i) ((Word)((YAP_ArgsOfTerm(w)+(i))))
  #define deRef(t) while (IsVarTerm(*(t)) && !IsUnboundVar(t)) { t = (CELL *)(*(t)); }
  #define canBind(t) FALSE  // VSC: to implement
  #define _PL_predicate(A,B,C,D) PL_predicate(A,B,C)
  #define predicateHasClauses(pe) ((pe)->cs.p_code.NOfClauses != 0)
  #define lookupModule(A) Yap_GetModuleEntry(MkAtomTerm(YAP_AtomFromSWIAtom(A)))
  
  Procedure resolveProcedure(functor_t f, Module module);
  
  #define charEscapeWriteOption(A) FALSE  // VSC: to implement
  #define wordToTermRef(A) Yap_InitSlot(*(A) PASS_REGS)
  #define isTaggedInt(A) IsIntegerTerm(A)
  #define valInt(A) IntegerOfTerm(A)
  
  #define MODULE_user Yap_GetModuleEntry(MkAtomTerm(Yap_LookupAtom("user")))
  #define MODULE_system Yap_GetModuleEntry(MkAtomTerm(Yap_LookupAtom("system")))
  #define MODULE_parse Yap_GetModuleEntry(LOCAL_SourceModule)
  
  extern term_t Yap_CvtTerm(term_t ts);
  
  #define clearNumber(n)
  
  wchar_t *nameOfWideAtom(atom_t atom);
  int isWideAtom(atom_t atom);
  
  inline static int
  charCode(Term w)
  { if ( IsAtomTerm(w) )
      { 
        Atom a = atomValue(w);
  
        if (IsWideAtom(a)) {
  	if (wcslen(a->WStrOfAE) == 1)
  	  return a->WStrOfAE[0];
  	return -1;
        }
        if (strlen(a->StrOfAE) == 1)
  	return ((unsigned char *)(a->StrOfAE))[0];
        return -1;
      }
    return -1;
  }
  
  #define PL_get_atom(t, a)	PL_get_atom__LD(t, a PASS_LD)
  #define PL_get_atom_ex(t, a)	PL_get_atom_ex__LD(t, a PASS_LD)
  #define PL_get_text(l, t, f)	PL_get_text__LD(l, t, f PASS_LD)
  #define PL_is_atom(t)		PL_is_atom__LD(t PASS_LD)
  #define PL_is_variable(t)	PL_is_variable__LD(t PASS_LD)
  #define PL_new_term_ref()	PL_new_term_ref__LD(PASS_LD1)
  #define PL_put_atom(t, a)	PL_put_atom__LD(t, a PASS_LD)
  #define PL_put_term(t1, t2)	PL_put_term__LD(t1, t2 PASS_LD)
  #define PL_unify_atom(t, a)	PL_unify_atom__LD(t, a PASS_LD)
  #define PL_unify_integer(t, i)	PL_unify_integer__LD(t, i PASS_LD)
  
  #define _PL_get_arg(i, t, a) _PL_get_arg__LD(i, t, a PASS_LD);
  
  #endif /* __YAP_PROLOG__ */
  
  unsigned int getUnknownModule(module_t m);
  
  #if IN_PL_OS_C
  static int
  stripostfix(const char *s, const char *e)
  { size_t ls = strlen(s);
    size_t le = strlen(e);
  
    if ( ls >= le )
      return strcasecmp(&s[ls-le], e) == 0;
  
    return FALSE;
  } 
  #endif
  
  #if HAVE_SIGPROCMASK
  #if HAVE_SIGNAL_H
  #include <signal.h>
  #endif
  
  static inline void
  unblockSignal(int sig)
  { sigset_t set;
  
    sigemptyset(&set);
    sigaddset(&set, sig);
  
    sigprocmask(SIG_UNBLOCK, &set, NULL);
    //  DEBUG(1, Sdprintf("Unblocked signal %d\n", sig));
  }
  #else
  static inline void
  unblockSignal(int sig)
  {
  }
  #endif
  
  #define suspendTrace(x)
  
  atom_t ATOM_;
  
  #if THREADS
  intptr_t system_thread_id(PL_thread_info_t *info);
  #endif
  
  #endif /* PL_YAP_H */
  