diff --git a/H/ATOMS b/H/ATOMS index 9092f684c..c5c3da9a2 100644 --- a/H/ATOMS +++ b/H/ATOMS @@ -430,6 +430,7 @@ A WakeUpGoal F "$wake_up_goal" A Warning N "warning" A When F "$when" A Write N "write" +A WriteTerm N "write_term" A Xml N "xml" A YapHacks N "yap_hacks" A ZeroDivisor N "zero_divisor" @@ -569,4 +570,5 @@ F TypeError TypeError 2 F UMinus Minus 1 F UPlus Plus 1 F VBar VBar 2 +F WriteTerm WriteTerm 2 F HiddenVar HiddenVar 1 diff --git a/H/Atoms.h b/H/Atoms.h index b20265568..988e68f4a 100644 --- a/H/Atoms.h +++ b/H/Atoms.h @@ -20,7 +20,7 @@ #ifndef EXTERN #ifndef ADTDEFS_C -#define EXTERN static +#define EXTERN static #else #define EXTERN #endif @@ -28,7 +28,7 @@ #include -typedef struct atom_blob { +typedef struct atom_blob { size_t length; char data[MIN_ARRAY]; } atom_blob_t; @@ -38,66 +38,59 @@ typedef struct atom_blob { /* Atoms are assumed to be uniquely represented by an OFFSET and to have associated with them a struct of type AtomEntry The two functions - RepAtom : Atom -> *AtomEntry - AbsAtom : *AtomEntry -> Atom + RepAtom : Atom -> *AtomEntry + AbsAtom : *AtomEntry -> Atom are used to encapsulate the implementation of atoms */ typedef struct AtomEntryStruct *Atom; typedef struct PropEntryStruct *Prop; - /* I can only define the structure after I define the actual atoms */ /* atom structure */ -typedef struct AtomEntryStruct -{ - Atom NextOfAE; /* used to build hash chains */ - Prop PropsOfAE; /* property list for this atom */ +typedef struct AtomEntryStruct { + Atom NextOfAE; /* used to build hash chains */ + Prop PropsOfAE; /* property list for this atom */ #if defined(YAPOR) || defined(THREADS) rwlock_t ARWLock; #endif union { - unsigned char uUStrOfAE[MIN_ARRAY]; /* representation of atom as a string */ - char uStrOfAE[MIN_ARRAY]; /* representation of atom as a string */ - wchar_t uWStrOfAE[MIN_ARRAY]; /* representation of atom as a string */ + unsigned char uUStrOfAE[MIN_ARRAY]; /* representation of atom as a string */ + char uStrOfAE[MIN_ARRAY]; /* representation of atom as a string */ + wchar_t uWStrOfAE[MIN_ARRAY]; /* representation of atom as a string */ struct atom_blob blob[MIN_ARRAY]; } rep; -} -AtomEntry; +} AtomEntry; // compatible with C and C++; -typedef struct ExtraAtomEntryStruct -{ - Atom NextOfAE; /* used to build hash chains */ - Prop PropsOfAE; /* property list for this atom */ +typedef struct ExtraAtomEntryStruct { + Atom NextOfAE; /* used to build hash chains */ + Prop PropsOfAE; /* property list for this atom */ #if defined(YAPOR) || defined(THREADS) rwlock_t ARWLock; #endif union { - unsigned char uUStrOfAE[4]; /* representation of atom as a string */ - char uStrOfAE[4]; /* representation of atom as a string */ - wchar_t uWStrOfAE[2]; /* representation of atom as a string */ + unsigned char uUStrOfAE[4]; /* representation of atom as a string */ + char uStrOfAE[4]; /* representation of atom as a string */ + wchar_t uWStrOfAE[2]; /* representation of atom as a string */ struct atom_blob blob[2]; } rep; -} - ExtraAtomEntry; +} ExtraAtomEntry; #define UStrOfAE rep.uUStrOfAE #define StrOfAE rep.uStrOfAE #define WStrOfAE rep.uWStrOfAE - /* Props and Atoms are stored in chains, ending with a NIL */ #ifdef USE_OFFSETS -# define EndOfPAEntr(P) ( Addr(P) == AtomBase) +#define EndOfPAEntr(P) (Addr(P) == AtomBase) #else -# define EndOfPAEntr(P) ( Addr(P) == NIL ) +#define EndOfPAEntr(P) (Addr(P) == NIL) #endif - /* ********************** Properties **********************************/ #if defined(USE_OFFSETS) @@ -109,34 +102,32 @@ typedef struct ExtraAtomEntryStruct typedef SFLAGS PropFlags; /* basic property entry structure */ -typedef struct PropEntryStruct -{ - Prop NextOfPE; /* used to chain properties */ - PropFlags KindOfPE; /* kind of property */ +typedef struct PropEntryStruct { + Prop NextOfPE; /* used to chain properties */ + PropFlags KindOfPE; /* kind of property */ } PropEntry; /* ************************* Functors **********************************/ - /* Functor data type - abstype Functor = atom # int - with MkFunctor(a,n) = ... - and NameOfFunctor(f) = ... - and ArityOfFunctor(f) = ... */ +/* Functor data type + abstype Functor = atom # int + with MkFunctor(a,n) = ... + and NameOfFunctor(f) = ... + and ArityOfFunctor(f) = ... */ -#define MaxArity 255 +#define MaxArity 255 -typedef CELL arity_t; +typedef size_t arity_t; - #define FunctorProperty ((PropFlags)(0xbb00)) +#define FunctorProperty ((PropFlags)(0xbb00)) /* functor property */ -typedef struct FunctorEntryStruct -{ - Prop NextOfPE; /* used to chain properties */ - PropFlags KindOfPE; /* kind of property */ - arity_t ArityOfFE; /* arity of functor */ - Atom NameOfFE; /* back pointer to owner atom */ - Prop PropsOfFE; /* pointer to list of properties for this functor */ +typedef struct FunctorEntryStruct { + Prop NextOfPE; /* used to chain properties */ + PropFlags KindOfPE; /* kind of property */ + arity_t ArityOfFE; /* arity of functor */ + Atom NameOfFE; /* back pointer to owner atom */ + Prop PropsOfFE; /* pointer to list of properties for this functor */ #if defined(YAPOR) || defined(THREADS) rwlock_t FRWLock; #endif @@ -144,5 +135,4 @@ typedef struct FunctorEntryStruct typedef FunctorEntry *Functor; - #endif /* ATOMS_H */ diff --git a/H/generated/iatoms.h b/H/generated/iatoms.h index a5c8a450d..e92b86e85 100644 --- a/H/generated/iatoms.h +++ b/H/generated/iatoms.h @@ -425,6 +425,7 @@ AtomWarning = Yap_LookupAtom("warning"); TermWarning = MkAtomTerm(AtomWarning); AtomWhen = Yap_FullLookupAtom("$when"); TermWhen = MkAtomTerm(AtomWhen); AtomWrite = Yap_LookupAtom("write"); TermWrite = MkAtomTerm(AtomWrite); + AtomWriteTerm = Yap_LookupAtom("write_term"); TermWriteTerm = MkAtomTerm(AtomWriteTerm); AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml); AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks); AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); @@ -564,4 +565,5 @@ FunctorUMinus = Yap_MkFunctor(AtomMinus,1); FunctorUPlus = Yap_MkFunctor(AtomPlus,1); FunctorVBar = Yap_MkFunctor(AtomVBar,2); + FunctorWriteTerm = Yap_MkFunctor(AtomWriteTerm,2); FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1); diff --git a/H/generated/ratoms.h b/H/generated/ratoms.h index c836cb449..563df5b3f 100644 --- a/H/generated/ratoms.h +++ b/H/generated/ratoms.h @@ -425,6 +425,7 @@ AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning); AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen); AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite); + AtomWriteTerm = AtomAdjust(AtomWriteTerm); TermWriteTerm = MkAtomTerm(AtomWriteTerm); AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml); AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks); AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); @@ -564,4 +565,5 @@ FunctorUMinus = FuncAdjust(FunctorUMinus); FunctorUPlus = FuncAdjust(FunctorUPlus); FunctorVBar = FuncAdjust(FunctorVBar); + FunctorWriteTerm = FuncAdjust(FunctorWriteTerm); FunctorHiddenVar = FuncAdjust(FunctorHiddenVar); diff --git a/H/generated/tatoms.h b/H/generated/tatoms.h index d49d7555d..eb4cc27bc 100644 --- a/H/generated/tatoms.h +++ b/H/generated/tatoms.h @@ -2,703 +2,706 @@ /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" {lease do not update, update misc/ATOMS instead */ -Atom Atom3Dots; -Atom AtomAbol; Term TermAbol; -Atom AtomAccess; Term TermAccess; -Atom AtomAfInet; Term TermAfInet; -Atom AtomAfLocal; Term TermAfLocal; -Atom AtomAfUnix; Term TermAfUnix; -Atom AtomAlarm; Term TermAlarm; -Atom AtomAlias; Term TermAlias; -Atom AtomAll; Term TermAll; -Atom AtomAltNot; Term TermAltNot; -Atom AtomAnswer; Term TermAnswer; -Atom AtomAny; Term TermAny; -Atom AtomAppend; Term TermAppend; -Atom AtomArg; Term TermArg; -Atom AtomArray; Term TermArray; -Atom AtomArrayAccess; Term TermArrayAccess; -Atom AtomArrayOverflow; Term TermArrayOverflow; -Atom AtomArrayType; Term TermArrayType; -Atom AtomArrow; Term TermArrow; -Atom AtomAttributedModule; Term TermAttributedModule; -Atom AtomDoubleArrow; Term TermDoubleArrow; -Atom AtomAssert; Term TermAssert; -Atom AtomEmptyBrackets; Term TermEmptyBrackets; -Atom AtomEmptySquareBrackets; Term TermEmptySquareBrackets; -Atom AtomEmptyCurlyBrackets; Term TermEmptyCurlyBrackets; -Atom AtomAsserta; Term TermAsserta; -Atom AtomAssertaStatic; Term TermAssertaStatic; -Atom AtomAssertz; Term TermAssertz; -Atom AtomAssertzStatic; Term TermAssertzStatic; -Atom AtomAt; Term TermAt; -Atom AtomAtom; Term TermAtom; -Atom AtomAtomic; Term TermAtomic; -Atom AtomAtt; Term TermAtt; -Atom AtomAtt1; Term TermAtt1; -Atom AtomAttDo; Term TermAttDo; -Atom AtomAttributes; Term TermAttributes; -Atom AtomB; Term TermB; -Atom AtomBatched; Term TermBatched; -Atom AtomBetween; Term TermBetween; -Atom AtomBinary; Term TermBinary; -Atom AtomBigNum; Term TermBigNum; -Atom AtomBinaryStream; Term TermBinaryStream; -Atom AtomBoolean; Term TermBoolean; -Atom AtomBraces; Term TermBraces; -Atom AtomBreak; Term TermBreak; -Atom AtomByte; Term TermByte; -Atom AtomCArith; Term TermCArith; -Atom AtomCall; Term TermCall; -Atom AtomCallAndRetryCounter; Term TermCallAndRetryCounter; -Atom AtomCallCounter; Term TermCallCounter; -Atom AtomCallable; Term TermCallable; -Atom AtomCatch; Term TermCatch; -Atom AtomChangeModule; Term TermChangeModule; -Atom AtomChar; Term TermChar; -Atom AtomCharsio; Term TermCharsio; -Atom AtomCharacter; Term TermCharacter; -Atom AtomCharacterCode; Term TermCharacterCode; -Atom AtomChars; Term TermChars; -Atom AtomCharset; Term TermCharset; -Atom AtomChType; Term TermChType; -Atom AtomCleanCall; Term TermCleanCall; -Atom AtomColon; Term TermColon; -Atom AtomCodeSpace; Term TermCodeSpace; -Atom AtomCodes; Term TermCodes; -Atom AtomCoInductive; Term TermCoInductive; -Atom AtomComma; Term TermComma; -Atom AtomCommentHook; Term TermCommentHook; -Atom AtomCompact; Term TermCompact; -Atom AtomCompound; Term TermCompound; -Atom AtomConsistencyError; Term TermConsistencyError; -Atom AtomConsult; Term TermConsult; -Atom AtomConsultOnBoot; Term TermConsultOnBoot; -Atom AtomContext; Term TermContext; -Atom AtomCputime; Term TermCputime; -Atom AtomCreate; Term TermCreate; -Atom AtomCreep; Term TermCreep; -Atom AtomCryptAtoms; Term TermCryptAtoms; -Atom AtomCurly; Term TermCurly; -Atom AtomCsult; Term TermCsult; -Atom AtomCurrentModule; Term TermCurrentModule; -Atom AtomCut; Term TermCut; -Atom AtomCutBy; Term TermCutBy; -Atom AtomDAbort; Term TermDAbort; -Atom AtomDBLoad; Term TermDBLoad; -Atom AtomDBREF; Term TermDBREF; -Atom AtomDBReference; Term TermDBReference; -Atom AtomDBTerm; Term TermDBTerm; -Atom AtomDBref; Term TermDBref; -Atom AtomDInteger; Term TermDInteger; -Atom AtomDebugMeta; Term TermDebugMeta; -Atom AtomDebuggerInput; Term TermDebuggerInput; -Atom AtomDec10; Term TermDec10; -Atom AtomDefault; Term TermDefault; -Atom AtomDevNull; Term TermDevNull; -Atom AtomDiff; Term TermDiff; -Atom AtomDirectory; Term TermDirectory; -Atom AtomDiscontiguous; Term TermDiscontiguous; -Atom AtomDiscontiguousWarnings; Term TermDiscontiguousWarnings; -Atom AtomDollar; Term TermDollar; -Atom AtomDoLogUpdClause; Term TermDoLogUpdClause; -Atom AtomDoLogUpdClause0; Term TermDoLogUpdClause0; -Atom AtomDoLogUpdClauseErase; Term TermDoLogUpdClauseErase; -Atom AtomDollarU; Term TermDollarU; -Atom AtomDollarUndef; Term TermDollarUndef; -Atom AtomDomainError; Term TermDomainError; -Atom AtomDoStaticClause; Term TermDoStaticClause; -Atom AtomDots; Term TermDots; -Atom AtomDOUBLE; Term TermDOUBLE; -Atom AtomDoubleSlash; Term TermDoubleSlash; -Atom AtomE; Term TermE; -Atom AtomEOFBeforeEOT; Term TermEOFBeforeEOT; -Atom AtomEQ; Term TermEQ; -Atom AtomEmptyAtom; Term TermEmptyAtom; -Atom AtomEncoding; Term TermEncoding; -Atom AtomEndOfStream; Term TermEndOfStream; -Atom AtomEof; Term TermEof; -Atom AtomEOfCode; Term TermEOfCode; -Atom AtomEq; Term TermEq; -Atom AtomError; Term TermError; -Atom AtomException; Term TermException; -Atom AtomExtensions; Term TermExtensions; -Atom AtomEvaluable; Term TermEvaluable; -Atom AtomEvaluationError; Term TermEvaluationError; -Atom AtomExecutable; Term TermExecutable; -Atom AtomExecute; Term TermExecute; -Atom AtomExecAnswers; Term TermExecAnswers; -Atom AtomExecuteInMod; Term TermExecuteInMod; -Atom AtomExecuteWithin; Term TermExecuteWithin; -Atom AtomExecuteWoMod; Term TermExecuteWoMod; -Atom AtomExist; Term TermExist; -Atom AtomExists; Term TermExists; -Atom AtomExit; Term TermExit; -Atom AtomExistenceError; Term TermExistenceError; -Atom AtomExoClause; Term TermExoClause; -Atom AtomExpectedNumber; Term TermExpectedNumber; -Atom AtomExpand; Term TermExpand; -Atom AtomExtendFileSearchPath; Term TermExtendFileSearchPath; -Atom AtomExtendsions; Term TermExtendsions; -Atom AtomFB; Term TermFB; -Atom AtomFail; Term TermFail; -Atom AtomFalse; Term TermFalse; -Atom AtomFast; Term TermFast; -Atom AtomFastFail; Term TermFastFail; -Atom AtomFileErrors; Term TermFileErrors; -Atom AtomFileerrors; Term TermFileerrors; -Atom AtomFileType; Term TermFileType; -Atom AtomFirst; Term TermFirst; -Atom AtomFloat; Term TermFloat; -Atom AtomFloatFormat; Term TermFloatFormat; -Atom AtomFloatOverflow; Term TermFloatOverflow; -Atom AtomFloatUnderflow; Term TermFloatUnderflow; -Atom AtomFormat; Term TermFormat; -Atom AtomFormatAt; Term TermFormatAt; -Atom AtomFull; Term TermFull; -Atom AtomFunctor; Term TermFunctor; -Atom AtomGT; Term TermGT; -Atom AtomGVar; Term TermGVar; -Atom AtomGc; Term TermGc; -Atom AtomGcMargin; Term TermGcMargin; -Atom AtomGcTrace; Term TermGcTrace; -Atom AtomGcVerbose; Term TermGcVerbose; -Atom AtomGcVeryVerbose; Term TermGcVeryVerbose; -Atom AtomGeneratePredInfo; Term TermGeneratePredInfo; -Atom AtomGetwork; Term TermGetwork; -Atom AtomGetworkSeq; Term TermGetworkSeq; -Atom AtomGlob; Term TermGlob; -Atom AtomGlobal; Term TermGlobal; -Atom AtomGlobalSp; Term TermGlobalSp; -Atom AtomGlobalTrie; Term TermGlobalTrie; -Atom AtomGoalExpansion; Term TermGoalExpansion; -Atom AtomHat; Term TermHat; -Atom AtomHERE; Term TermHERE; -Atom AtomHandleThrow; Term TermHandleThrow; -Atom AtomHeap; Term TermHeap; -Atom AtomHeapUsed; Term TermHeapUsed; -Atom AtomHugeInt; Term TermHugeInt; -Atom AtomIDB; Term TermIDB; -Atom AtomIOMode; Term TermIOMode; -Atom AtomI; Term TermI; -Atom AtomId; Term TermId; -Atom AtomIgnore; Term TermIgnore; -Atom AtomInf; Term TermInf; -Atom AtomInfinity; Term TermInfinity; -Atom AtomInitGoal; Term TermInitGoal; -Atom AtomInitProlog; Term TermInitProlog; -Atom AtomInStackExpansion; Term TermInStackExpansion; -Atom AtomInput; Term TermInput; -Atom AtomInstantiationError; Term TermInstantiationError; -Atom AtomInt; Term TermInt; -Atom AtomIntOverflow; Term TermIntOverflow; -Atom AtomInteger; Term TermInteger; -Atom AtomInternalCompilerError; Term TermInternalCompilerError; -Atom AtomIs; Term TermIs; -Atom AtomJ; Term TermJ; -Atom AtomKey; Term TermKey; -Atom AtomLDLibraryPath; Term TermLDLibraryPath; -Atom AtomLONGINT; Term TermLONGINT; -Atom AtomLOOP; Term TermLOOP; -Atom AtomLoopStream; Term TermLoopStream; -Atom AtomLT; Term TermLT; -Atom AtomLastExecuteWithin; Term TermLastExecuteWithin; -Atom AtomLeash; Term TermLeash; -Atom AtomLeast; Term TermLeast; -Atom AtomLength; Term TermLength; -Atom AtomList; Term TermList; -Atom AtomLine; Term TermLine; -Atom AtomLive; Term TermLive; -Atom AtomLoadAnswers; Term TermLoadAnswers; -Atom AtomLocal; Term TermLocal; -Atom AtomLocalSp; Term TermLocalSp; -Atom AtomLocalTrie; Term TermLocalTrie; -Atom AtomMax; Term TermMax; -Atom AtomMaximum; Term TermMaximum; -Atom AtomMaxArity; Term TermMaxArity; -Atom AtomMaxFiles; Term TermMaxFiles; -Atom AtomMegaClause; Term TermMegaClause; -Atom AtomMetaCall; Term TermMetaCall; -Atom AtomMfClause; Term TermMfClause; -Atom AtomMin; Term TermMin; -Atom AtomMinimum; Term TermMinimum; -Atom AtomMinus; Term TermMinus; -Atom AtomModify; Term TermModify; -Atom AtomModule; Term TermModule; -Atom AtomMost; Term TermMost; -Atom AtomMulti; Term TermMulti; -Atom AtomMultiFile; Term TermMultiFile; -Atom AtomMultiple; Term TermMultiple; -Atom AtomMutable; Term TermMutable; -Atom AtomMutableVariable; Term TermMutableVariable; -Atom AtomMutex; Term TermMutex; -Atom AtomMyddasDB; Term TermMyddasDB; -Atom AtomMyddasGoal; Term TermMyddasGoal; -Atom AtomMyddasHost; Term TermMyddasHost; -Atom AtomMyddasPass; Term TermMyddasPass; -Atom AtomMyddasUser; Term TermMyddasUser; -Atom AtomMyddasVersionName; Term TermMyddasVersionName; -Atom AtomNan; Term TermNan; -Atom AtomNb; Term TermNb; -Atom AtomNbTerm; Term TermNbTerm; -Atom AtomNew; Term TermNew; -Atom AtomNewLine; Term TermNewLine; -Atom AtomNl; Term TermNl; -Atom AtomNoEffect; Term TermNoEffect; -Atom AtomNoMemory; Term TermNoMemory; -Atom AtomNone; Term TermNone; -Atom AtomNonEmptyList; Term TermNonEmptyList; -Atom AtomNot; Term TermNot; -Atom AtomNotImplemented; Term TermNotImplemented; -Atom AtomNotLessThanZero; Term TermNotLessThanZero; -Atom AtomNotNewline; Term TermNotNewline; -Atom AtomNotZero; Term TermNotZero; -Atom AtomNumber; Term TermNumber; -Atom AtomObj; Term TermObj; -Atom AtomOff; Term TermOff; -Atom AtomOffline; Term TermOffline; -Atom AtomOn; Term TermOn; -Atom AtomOnline; Term TermOnline; -Atom AtomOpen; Term TermOpen; -Atom AtomOperatingSystemError; Term TermOperatingSystemError; -Atom AtomOperatingSystemSupport; Term TermOperatingSystemSupport; -Atom AtomOperator; Term TermOperator; -Atom AtomOperatorPriority; Term TermOperatorPriority; -Atom AtomOperatorSpecifier; Term TermOperatorSpecifier; -Atom AtomOpt; Term TermOpt; -Atom AtomOtherwise; Term TermOtherwise; -Atom AtomOutOfAttvarsError; Term TermOutOfAttvarsError; -Atom AtomOutOfAuxspaceError; Term TermOutOfAuxspaceError; -Atom AtomOutOfHeapError; Term TermOutOfHeapError; -Atom AtomOutOfRange; Term TermOutOfRange; -Atom AtomOutOfStackError; Term TermOutOfStackError; -Atom AtomOutOfTrailError; Term TermOutOfTrailError; -Atom AtomOutput; Term TermOutput; -Atom AtomParameter; Term TermParameter; -Atom AtomPrologCommonsDir; Term TermPrologCommonsDir; -Atom AtomPast; Term TermPast; -Atom AtomPastEndOfStream; Term TermPastEndOfStream; -Atom AtomPermissionError; Term TermPermissionError; -Atom AtomPi; Term TermPi; -Atom AtomPipe; Term TermPipe; -Atom AtomPlus; Term TermPlus; -Atom AtomPointer; Term TermPointer; -Atom AtomPortray; Term TermPortray; -Atom AtomPredicateIndicator; Term TermPredicateIndicator; -Atom AtomPrimitive; Term TermPrimitive; -Atom AtomPrintMessage; Term TermPrintMessage; -Atom AtomPrivateProcedure; Term TermPrivateProcedure; -Atom AtomProcedure; Term TermProcedure; -Atom AtomProfile; Term TermProfile; -Atom AtomProlog; Term TermProlog; -Atom AtomProtectStack; Term TermProtectStack; -Atom AtomQly; Term TermQly; -Atom AtomQuery; Term TermQuery; -Atom AtomQueue; Term TermQueue; -Atom AtomQuiet; Term TermQuiet; -Atom AtomRadix; Term TermRadix; -Atom AtomRandom; Term TermRandom; -Atom AtomRange; Term TermRange; -Atom AtomRDiv; Term TermRDiv; -Atom AtomRead; Term TermRead; -Atom AtomReadOnly; Term TermReadOnly; -Atom AtomReadWrite; Term TermReadWrite; -Atom AtomReadutil; Term TermReadutil; -Atom AtomReconsult; Term TermReconsult; -Atom AtomRecordedP; Term TermRecordedP; -Atom AtomRecordedWithKey; Term TermRecordedWithKey; -Atom AtomRedefineWarnings; Term TermRedefineWarnings; -Atom AtomRedoFreeze; Term TermRedoFreeze; -Atom AtomRefoundVar; Term TermRefoundVar; -Atom AtomRelativeTo; Term TermRelativeTo; -Atom AtomRepeat; Term TermRepeat; -Atom AtomRepeatSpace; Term TermRepeatSpace; -Atom AtomReposition; Term TermReposition; -Atom AtomRepresentationError; Term TermRepresentationError; -Atom AtomReset; Term TermReset; -Atom AtomResize; Term TermResize; -Atom AtomResourceError; Term TermResourceError; -Atom AtomRestoreRegs; Term TermRestoreRegs; -Atom AtomRetry; Term TermRetry; -Atom AtomRetryCounter; Term TermRetryCounter; -Atom AtomRTree; Term TermRTree; -Atom AtomSafe; Term TermSafe; -Atom AtomSafeCallCleanup; Term TermSafeCallCleanup; -Atom AtomSame; Term TermSame; -Atom AtomSemic; Term TermSemic; -Atom AtomShiftCountOverflow; Term TermShiftCountOverflow; -Atom AtomSigAlarm; Term TermSigAlarm; -Atom AtomSigBreak; Term TermSigBreak; -Atom AtomSigCreep; Term TermSigCreep; -Atom AtomSigDebug; Term TermSigDebug; -Atom AtomSigDelayCreep; Term TermSigDelayCreep; -Atom AtomSigFPE; Term TermSigFPE; -Atom AtomSigHup; Term TermSigHup; -Atom AtomSigInt; Term TermSigInt; -Atom AtomSigIti; Term TermSigIti; -Atom AtomSigPending; Term TermSigPending; -Atom AtomSigPipe; Term TermSigPipe; -Atom AtomSigStackDump; Term TermSigStackDump; -Atom AtomSigStatistics; Term TermSigStatistics; -Atom AtomSigTrace; Term TermSigTrace; -Atom AtomSigUsr1; Term TermSigUsr1; -Atom AtomSigUsr2; Term TermSigUsr2; -Atom AtomSigVTAlarm; Term TermSigVTAlarm; -Atom AtomSigWakeUp; Term TermSigWakeUp; -Atom AtomSilent; Term TermSilent; -Atom AtomSingle; Term TermSingle; -Atom AtomSingleVarWarnings; Term TermSingleVarWarnings; -Atom AtomSingleton; Term TermSingleton; -Atom AtomSlash; Term TermSlash; -Atom AtomSocket; Term TermSocket; -Atom AtomSolutions; Term TermSolutions; -Atom AtomSource; Term TermSource; -Atom AtomSourceSink; Term TermSourceSink; -Atom AtomSpy; Term TermSpy; -Atom AtomStack; Term TermStack; -Atom AtomStackFree; Term TermStackFree; -Atom AtomStartupSavedState; Term TermStartupSavedState; -Atom AtomStaticClause; Term TermStaticClause; -Atom AtomStaticProcedure; Term TermStaticProcedure; -Atom AtomStream; Term TermStream; -Atom AtomSWIStream; Term TermSWIStream; -Atom AtomVStream; Term TermVStream; -Atom AtomStreams; Term TermStreams; -Atom AtomStreamOrAlias; Term TermStreamOrAlias; -Atom AtomStreamPos; Term TermStreamPos; -Atom AtomStreamPosition; Term TermStreamPosition; -Atom AtomString; Term TermString; -Atom AtomStyleCheck; Term TermStyleCheck; -Atom AtomSTRING; Term TermSTRING; -Atom AtomSwi; Term TermSwi; -Atom AtomSymbolChar; Term TermSymbolChar; -Atom AtomSyntaxError; Term TermSyntaxError; -Atom AtomSyntaxErrors; Term TermSyntaxErrors; -Atom AtomSyntaxErrorHandler; Term TermSyntaxErrorHandler; -Atom AtomSystem; Term TermSystem; -Atom AtomSystemError; Term TermSystemError; -Atom AtomSystemLibraryDir; Term TermSystemLibraryDir; -Atom AtomT; Term TermT; -Atom AtomTerm; Term TermTerm; -Atom AtomTermExpansion; Term TermTermExpansion; -Atom AtomTerms; Term TermTerms; -Atom AtomText; Term TermText; -Atom AtomTextStream; Term TermTextStream; -Atom AtomThread; Term TermThread; -Atom AtomThreads; Term TermThreads; -Atom AtomThrow; Term TermThrow; -Atom AtomTimeOutSpec; Term TermTimeOutSpec; -Atom AtomTimeoutError; Term TermTimeoutError; -Atom AtomTopLevelGoal; Term TermTopLevelGoal; -Atom AtomTopThreadGoal; Term TermTopThreadGoal; -Atom AtomTraceMetaCall; Term TermTraceMetaCall; -Atom AtomTrail; -Atom AtomTrue; Term TermTrue; -Atom AtomTty; Term TermTty; -Atom AtomTtys; Term TermTtys; -Atom AtomTuple; Term TermTuple; -Atom AtomTxt; Term TermTxt; -Atom AtomTypeError; Term TermTypeError; -Atom AtomUndefined; Term TermUndefined; -Atom AtomUndefp; Term TermUndefp; -Atom AtomUndefp0; Term TermUndefp0; -Atom AtomUnderflow; Term TermUnderflow; -Atom AtomUnificationStack; Term TermUnificationStack; -Atom AtomUnique; Term TermUnique; -Atom AtomUnsignedByte; Term TermUnsignedByte; -Atom AtomUnsignedChar; Term TermUnsignedChar; -Atom AtomUser; Term TermUser; -Atom AtomUserErr; Term TermUserErr; -Atom AtomUserIn; Term TermUserIn; -Atom AtomUserOut; Term TermUserOut; -Atom AtomDollarVar; Term TermDollarVar; -Atom AtomVBar; Term TermVBar; -Atom AtomVarBranches; Term TermVarBranches; -Atom AtomVariableNames; Term TermVariableNames; -Atom AtomHiddenVar; Term TermHiddenVar; -Atom AtomVariable; Term TermVariable; -Atom AtomVerbose; Term TermVerbose; -Atom AtomVerboseFileSearch; Term TermVerboseFileSearch; -Atom AtomVersionNumber; Term TermVersionNumber; -Atom AtomVeryVerbose; Term TermVeryVerbose; -Atom AtomWakeUpGoal; Term TermWakeUpGoal; -Atom AtomWarning; Term TermWarning; -Atom AtomWhen; Term TermWhen; -Atom AtomWrite; Term TermWrite; -Atom AtomXml; Term TermXml; -Atom AtomYapHacks; Term TermYapHacks; -Atom AtomZeroDivisor; Term TermZeroDivisor; - Functor FunctorAfInet; +EXTERNAL Atom Atom3Dots; +EXTERNAL Atom AtomAbol; EXTERNAL Term TermAbol; +EXTERNAL Atom AtomAccess; EXTERNAL Term TermAccess; +EXTERNAL Atom AtomAfInet; EXTERNAL Term TermAfInet; +EXTERNAL Atom AtomAfLocal; EXTERNAL Term TermAfLocal; +EXTERNAL Atom AtomAfUnix; EXTERNAL Term TermAfUnix; +EXTERNAL Atom AtomAlarm; EXTERNAL Term TermAlarm; +EXTERNAL Atom AtomAlias; EXTERNAL Term TermAlias; +EXTERNAL Atom AtomAll; EXTERNAL Term TermAll; +EXTERNAL Atom AtomAltNot; EXTERNAL Term TermAltNot; +EXTERNAL Atom AtomAnswer; EXTERNAL Term TermAnswer; +EXTERNAL Atom AtomAny; EXTERNAL Term TermAny; +EXTERNAL Atom AtomAppend; EXTERNAL Term TermAppend; +EXTERNAL Atom AtomArg; EXTERNAL Term TermArg; +EXTERNAL Atom AtomArray; EXTERNAL Term TermArray; +EXTERNAL Atom AtomArrayAccess; EXTERNAL Term TermArrayAccess; +EXTERNAL Atom AtomArrayOverflow; EXTERNAL Term TermArrayOverflow; +EXTERNAL Atom AtomArrayType; EXTERNAL Term TermArrayType; +EXTERNAL Atom AtomArrow; EXTERNAL Term TermArrow; +EXTERNAL Atom AtomAttributedModule; EXTERNAL Term TermAttributedModule; +EXTERNAL Atom AtomDoubleArrow; EXTERNAL Term TermDoubleArrow; +EXTERNAL Atom AtomAssert; EXTERNAL Term TermAssert; +EXTERNAL Atom AtomEmptyBrackets; EXTERNAL Term TermEmptyBrackets; +EXTERNAL Atom AtomEmptySquareBrackets; EXTERNAL Term TermEmptySquareBrackets; +EXTERNAL Atom AtomEmptyCurlyBrackets; EXTERNAL Term TermEmptyCurlyBrackets; +EXTERNAL Atom AtomAsserta; EXTERNAL Term TermAsserta; +EXTERNAL Atom AtomAssertaStatic; EXTERNAL Term TermAssertaStatic; +EXTERNAL Atom AtomAssertz; EXTERNAL Term TermAssertz; +EXTERNAL Atom AtomAssertzStatic; EXTERNAL Term TermAssertzStatic; +EXTERNAL Atom AtomAt; EXTERNAL Term TermAt; +EXTERNAL Atom AtomAtom; EXTERNAL Term TermAtom; +EXTERNAL Atom AtomAtomic; EXTERNAL Term TermAtomic; +EXTERNAL Atom AtomAtt; EXTERNAL Term TermAtt; +EXTERNAL Atom AtomAtt1; EXTERNAL Term TermAtt1; +EXTERNAL Atom AtomAttDo; EXTERNAL Term TermAttDo; +EXTERNAL Atom AtomAttributes; EXTERNAL Term TermAttributes; +EXTERNAL Atom AtomB; EXTERNAL Term TermB; +EXTERNAL Atom AtomBatched; EXTERNAL Term TermBatched; +EXTERNAL Atom AtomBetween; EXTERNAL Term TermBetween; +EXTERNAL Atom AtomBinary; EXTERNAL Term TermBinary; +EXTERNAL Atom AtomBigNum; EXTERNAL Term TermBigNum; +EXTERNAL Atom AtomBinaryStream; EXTERNAL Term TermBinaryStream; +EXTERNAL Atom AtomBoolean; EXTERNAL Term TermBoolean; +EXTERNAL Atom AtomBraces; EXTERNAL Term TermBraces; +EXTERNAL Atom AtomBreak; EXTERNAL Term TermBreak; +EXTERNAL Atom AtomByte; EXTERNAL Term TermByte; +EXTERNAL Atom AtomCArith; EXTERNAL Term TermCArith; +EXTERNAL Atom AtomCall; EXTERNAL Term TermCall; +EXTERNAL Atom AtomCallAndRetryCounter; EXTERNAL Term TermCallAndRetryCounter; +EXTERNAL Atom AtomCallCounter; EXTERNAL Term TermCallCounter; +EXTERNAL Atom AtomCallable; EXTERNAL Term TermCallable; +EXTERNAL Atom AtomCatch; EXTERNAL Term TermCatch; +EXTERNAL Atom AtomChangeModule; EXTERNAL Term TermChangeModule; +EXTERNAL Atom AtomChar; EXTERNAL Term TermChar; +EXTERNAL Atom AtomCharsio; EXTERNAL Term TermCharsio; +EXTERNAL Atom AtomCharacter; EXTERNAL Term TermCharacter; +EXTERNAL Atom AtomCharacterCode; EXTERNAL Term TermCharacterCode; +EXTERNAL Atom AtomChars; EXTERNAL Term TermChars; +EXTERNAL Atom AtomCharset; EXTERNAL Term TermCharset; +EXTERNAL Atom AtomChType; EXTERNAL Term TermChType; +EXTERNAL Atom AtomCleanCall; EXTERNAL Term TermCleanCall; +EXTERNAL Atom AtomColon; EXTERNAL Term TermColon; +EXTERNAL Atom AtomCodeSpace; EXTERNAL Term TermCodeSpace; +EXTERNAL Atom AtomCodes; EXTERNAL Term TermCodes; +EXTERNAL Atom AtomCoInductive; EXTERNAL Term TermCoInductive; +EXTERNAL Atom AtomComma; EXTERNAL Term TermComma; +EXTERNAL Atom AtomCommentHook; EXTERNAL Term TermCommentHook; +EXTERNAL Atom AtomCompact; EXTERNAL Term TermCompact; +EXTERNAL Atom AtomCompound; EXTERNAL Term TermCompound; +EXTERNAL Atom AtomConsistencyError; EXTERNAL Term TermConsistencyError; +EXTERNAL Atom AtomConsult; EXTERNAL Term TermConsult; +EXTERNAL Atom AtomConsultOnBoot; EXTERNAL Term TermConsultOnBoot; +EXTERNAL Atom AtomContext; EXTERNAL Term TermContext; +EXTERNAL Atom AtomCputime; EXTERNAL Term TermCputime; +EXTERNAL Atom AtomCreate; EXTERNAL Term TermCreate; +EXTERNAL Atom AtomCreep; EXTERNAL Term TermCreep; +EXTERNAL Atom AtomCryptAtoms; EXTERNAL Term TermCryptAtoms; +EXTERNAL Atom AtomCurly; EXTERNAL Term TermCurly; +EXTERNAL Atom AtomCsult; EXTERNAL Term TermCsult; +EXTERNAL Atom AtomCurrentModule; EXTERNAL Term TermCurrentModule; +EXTERNAL Atom AtomCut; EXTERNAL Term TermCut; +EXTERNAL Atom AtomCutBy; EXTERNAL Term TermCutBy; +EXTERNAL Atom AtomDAbort; EXTERNAL Term TermDAbort; +EXTERNAL Atom AtomDBLoad; EXTERNAL Term TermDBLoad; +EXTERNAL Atom AtomDBREF; EXTERNAL Term TermDBREF; +EXTERNAL Atom AtomDBReference; EXTERNAL Term TermDBReference; +EXTERNAL Atom AtomDBTerm; EXTERNAL Term TermDBTerm; +EXTERNAL Atom AtomDBref; EXTERNAL Term TermDBref; +EXTERNAL Atom AtomDInteger; EXTERNAL Term TermDInteger; +EXTERNAL Atom AtomDebugMeta; EXTERNAL Term TermDebugMeta; +EXTERNAL Atom AtomDebuggerInput; EXTERNAL Term TermDebuggerInput; +EXTERNAL Atom AtomDec10; EXTERNAL Term TermDec10; +EXTERNAL Atom AtomDefault; EXTERNAL Term TermDefault; +EXTERNAL Atom AtomDevNull; EXTERNAL Term TermDevNull; +EXTERNAL Atom AtomDiff; EXTERNAL Term TermDiff; +EXTERNAL Atom AtomDirectory; EXTERNAL Term TermDirectory; +EXTERNAL Atom AtomDiscontiguous; EXTERNAL Term TermDiscontiguous; +EXTERNAL Atom AtomDiscontiguousWarnings; EXTERNAL Term TermDiscontiguousWarnings; +EXTERNAL Atom AtomDollar; EXTERNAL Term TermDollar; +EXTERNAL Atom AtomDoLogUpdClause; EXTERNAL Term TermDoLogUpdClause; +EXTERNAL Atom AtomDoLogUpdClause0; EXTERNAL Term TermDoLogUpdClause0; +EXTERNAL Atom AtomDoLogUpdClauseErase; EXTERNAL Term TermDoLogUpdClauseErase; +EXTERNAL Atom AtomDollarU; EXTERNAL Term TermDollarU; +EXTERNAL Atom AtomDollarUndef; EXTERNAL Term TermDollarUndef; +EXTERNAL Atom AtomDomainError; EXTERNAL Term TermDomainError; +EXTERNAL Atom AtomDoStaticClause; EXTERNAL Term TermDoStaticClause; +EXTERNAL Atom AtomDots; EXTERNAL Term TermDots; +EXTERNAL Atom AtomDOUBLE; EXTERNAL Term TermDOUBLE; +EXTERNAL Atom AtomDoubleSlash; EXTERNAL Term TermDoubleSlash; +EXTERNAL Atom AtomE; EXTERNAL Term TermE; +EXTERNAL Atom AtomEOFBeforeEOT; EXTERNAL Term TermEOFBeforeEOT; +EXTERNAL Atom AtomEQ; EXTERNAL Term TermEQ; +EXTERNAL Atom AtomEmptyAtom; EXTERNAL Term TermEmptyAtom; +EXTERNAL Atom AtomEncoding; EXTERNAL Term TermEncoding; +EXTERNAL Atom AtomEndOfStream; EXTERNAL Term TermEndOfStream; +EXTERNAL Atom AtomEof; EXTERNAL Term TermEof; +EXTERNAL Atom AtomEOfCode; EXTERNAL Term TermEOfCode; +EXTERNAL Atom AtomEq; EXTERNAL Term TermEq; +EXTERNAL Atom AtomError; EXTERNAL Term TermError; +EXTERNAL Atom AtomException; EXTERNAL Term TermException; +EXTERNAL Atom AtomExtensions; EXTERNAL Term TermExtensions; +EXTERNAL Atom AtomEvaluable; EXTERNAL Term TermEvaluable; +EXTERNAL Atom AtomEvaluationError; EXTERNAL Term TermEvaluationError; +EXTERNAL Atom AtomExecutable; EXTERNAL Term TermExecutable; +EXTERNAL Atom AtomExecute; EXTERNAL Term TermExecute; +EXTERNAL Atom AtomExecAnswers; EXTERNAL Term TermExecAnswers; +EXTERNAL Atom AtomExecuteInMod; EXTERNAL Term TermExecuteInMod; +EXTERNAL Atom AtomExecuteWithin; EXTERNAL Term TermExecuteWithin; +EXTERNAL Atom AtomExecuteWoMod; EXTERNAL Term TermExecuteWoMod; +EXTERNAL Atom AtomExist; EXTERNAL Term TermExist; +EXTERNAL Atom AtomExists; EXTERNAL Term TermExists; +EXTERNAL Atom AtomExit; EXTERNAL Term TermExit; +EXTERNAL Atom AtomExistenceError; EXTERNAL Term TermExistenceError; +EXTERNAL Atom AtomExoClause; EXTERNAL Term TermExoClause; +EXTERNAL Atom AtomExpectedNumber; EXTERNAL Term TermExpectedNumber; +EXTERNAL Atom AtomExpand; EXTERNAL Term TermExpand; +EXTERNAL Atom AtomExtendFileSearchPath; EXTERNAL Term TermExtendFileSearchPath; +EXTERNAL Atom AtomExtendsions; EXTERNAL Term TermExtendsions; +EXTERNAL Atom AtomFB; EXTERNAL Term TermFB; +EXTERNAL Atom AtomFail; EXTERNAL Term TermFail; +EXTERNAL Atom AtomFalse; EXTERNAL Term TermFalse; +EXTERNAL Atom AtomFast; EXTERNAL Term TermFast; +EXTERNAL Atom AtomFastFail; EXTERNAL Term TermFastFail; +EXTERNAL Atom AtomFileErrors; EXTERNAL Term TermFileErrors; +EXTERNAL Atom AtomFileerrors; EXTERNAL Term TermFileerrors; +EXTERNAL Atom AtomFileType; EXTERNAL Term TermFileType; +EXTERNAL Atom AtomFirst; EXTERNAL Term TermFirst; +EXTERNAL Atom AtomFloat; EXTERNAL Term TermFloat; +EXTERNAL Atom AtomFloatFormat; EXTERNAL Term TermFloatFormat; +EXTERNAL Atom AtomFloatOverflow; EXTERNAL Term TermFloatOverflow; +EXTERNAL Atom AtomFloatUnderflow; EXTERNAL Term TermFloatUnderflow; +EXTERNAL Atom AtomFormat; EXTERNAL Term TermFormat; +EXTERNAL Atom AtomFormatAt; EXTERNAL Term TermFormatAt; +EXTERNAL Atom AtomFull; EXTERNAL Term TermFull; +EXTERNAL Atom AtomFunctor; EXTERNAL Term TermFunctor; +EXTERNAL Atom AtomGT; EXTERNAL Term TermGT; +EXTERNAL Atom AtomGVar; EXTERNAL Term TermGVar; +EXTERNAL Atom AtomGc; EXTERNAL Term TermGc; +EXTERNAL Atom AtomGcMargin; EXTERNAL Term TermGcMargin; +EXTERNAL Atom AtomGcTrace; EXTERNAL Term TermGcTrace; +EXTERNAL Atom AtomGcVerbose; EXTERNAL Term TermGcVerbose; +EXTERNAL Atom AtomGcVeryVerbose; EXTERNAL Term TermGcVeryVerbose; +EXTERNAL Atom AtomGeneratePredInfo; EXTERNAL Term TermGeneratePredInfo; +EXTERNAL Atom AtomGetwork; EXTERNAL Term TermGetwork; +EXTERNAL Atom AtomGetworkSeq; EXTERNAL Term TermGetworkSeq; +EXTERNAL Atom AtomGlob; EXTERNAL Term TermGlob; +EXTERNAL Atom AtomGlobal; EXTERNAL Term TermGlobal; +EXTERNAL Atom AtomGlobalSp; EXTERNAL Term TermGlobalSp; +EXTERNAL Atom AtomGlobalTrie; EXTERNAL Term TermGlobalTrie; +EXTERNAL Atom AtomGoalExpansion; EXTERNAL Term TermGoalExpansion; +EXTERNAL Atom AtomHat; EXTERNAL Term TermHat; +EXTERNAL Atom AtomHERE; EXTERNAL Term TermHERE; +EXTERNAL Atom AtomHandleThrow; EXTERNAL Term TermHandleThrow; +EXTERNAL Atom AtomHeap; EXTERNAL Term TermHeap; +EXTERNAL Atom AtomHeapUsed; EXTERNAL Term TermHeapUsed; +EXTERNAL Atom AtomHugeInt; EXTERNAL Term TermHugeInt; +EXTERNAL Atom AtomIDB; EXTERNAL Term TermIDB; +EXTERNAL Atom AtomIOMode; EXTERNAL Term TermIOMode; +EXTERNAL Atom AtomI; EXTERNAL Term TermI; +EXTERNAL Atom AtomId; EXTERNAL Term TermId; +EXTERNAL Atom AtomIgnore; EXTERNAL Term TermIgnore; +EXTERNAL Atom AtomInf; EXTERNAL Term TermInf; +EXTERNAL Atom AtomInfinity; EXTERNAL Term TermInfinity; +EXTERNAL Atom AtomInitGoal; EXTERNAL Term TermInitGoal; +EXTERNAL Atom AtomInitProlog; EXTERNAL Term TermInitProlog; +EXTERNAL Atom AtomInStackExpansion; EXTERNAL Term TermInStackExpansion; +EXTERNAL Atom AtomInput; EXTERNAL Term TermInput; +EXTERNAL Atom AtomInstantiationError; EXTERNAL Term TermInstantiationError; +EXTERNAL Atom AtomInt; EXTERNAL Term TermInt; +EXTERNAL Atom AtomIntOverflow; EXTERNAL Term TermIntOverflow; +EXTERNAL Atom AtomInteger; EXTERNAL Term TermInteger; +EXTERNAL Atom AtomInternalCompilerError; EXTERNAL Term TermInternalCompilerError; +EXTERNAL Atom AtomIs; EXTERNAL Term TermIs; +EXTERNAL Atom AtomJ; EXTERNAL Term TermJ; +EXTERNAL Atom AtomKey; EXTERNAL Term TermKey; +EXTERNAL Atom AtomLDLibraryPath; EXTERNAL Term TermLDLibraryPath; +EXTERNAL Atom AtomLONGINT; EXTERNAL Term TermLONGINT; +EXTERNAL Atom AtomLOOP; EXTERNAL Term TermLOOP; +EXTERNAL Atom AtomLoopStream; EXTERNAL Term TermLoopStream; +EXTERNAL Atom AtomLT; EXTERNAL Term TermLT; +EXTERNAL Atom AtomLastExecuteWithin; EXTERNAL Term TermLastExecuteWithin; +EXTERNAL Atom AtomLeash; EXTERNAL Term TermLeash; +EXTERNAL Atom AtomLeast; EXTERNAL Term TermLeast; +EXTERNAL Atom AtomLength; EXTERNAL Term TermLength; +EXTERNAL Atom AtomList; EXTERNAL Term TermList; +EXTERNAL Atom AtomLine; EXTERNAL Term TermLine; +EXTERNAL Atom AtomLive; EXTERNAL Term TermLive; +EXTERNAL Atom AtomLoadAnswers; EXTERNAL Term TermLoadAnswers; +EXTERNAL Atom AtomLocal; EXTERNAL Term TermLocal; +EXTERNAL Atom AtomLocalSp; EXTERNAL Term TermLocalSp; +EXTERNAL Atom AtomLocalTrie; EXTERNAL Term TermLocalTrie; +EXTERNAL Atom AtomMax; EXTERNAL Term TermMax; +EXTERNAL Atom AtomMaximum; EXTERNAL Term TermMaximum; +EXTERNAL Atom AtomMaxArity; EXTERNAL Term TermMaxArity; +EXTERNAL Atom AtomMaxFiles; EXTERNAL Term TermMaxFiles; +EXTERNAL Atom AtomMegaClause; EXTERNAL Term TermMegaClause; +EXTERNAL Atom AtomMetaCall; EXTERNAL Term TermMetaCall; +EXTERNAL Atom AtomMfClause; EXTERNAL Term TermMfClause; +EXTERNAL Atom AtomMin; EXTERNAL Term TermMin; +EXTERNAL Atom AtomMinimum; EXTERNAL Term TermMinimum; +EXTERNAL Atom AtomMinus; EXTERNAL Term TermMinus; +EXTERNAL Atom AtomModify; EXTERNAL Term TermModify; +EXTERNAL Atom AtomModule; EXTERNAL Term TermModule; +EXTERNAL Atom AtomMost; EXTERNAL Term TermMost; +EXTERNAL Atom AtomMulti; EXTERNAL Term TermMulti; +EXTERNAL Atom AtomMultiFile; EXTERNAL Term TermMultiFile; +EXTERNAL Atom AtomMultiple; EXTERNAL Term TermMultiple; +EXTERNAL Atom AtomMutable; EXTERNAL Term TermMutable; +EXTERNAL Atom AtomMutableVariable; EXTERNAL Term TermMutableVariable; +EXTERNAL Atom AtomMutex; EXTERNAL Term TermMutex; +EXTERNAL Atom AtomMyddasDB; EXTERNAL Term TermMyddasDB; +EXTERNAL Atom AtomMyddasGoal; EXTERNAL Term TermMyddasGoal; +EXTERNAL Atom AtomMyddasHost; EXTERNAL Term TermMyddasHost; +EXTERNAL Atom AtomMyddasPass; EXTERNAL Term TermMyddasPass; +EXTERNAL Atom AtomMyddasUser; EXTERNAL Term TermMyddasUser; +EXTERNAL Atom AtomMyddasVersionName; EXTERNAL Term TermMyddasVersionName; +EXTERNAL Atom AtomNan; EXTERNAL Term TermNan; +EXTERNAL Atom AtomNb; EXTERNAL Term TermNb; +EXTERNAL Atom AtomNbTerm; EXTERNAL Term TermNbTerm; +EXTERNAL Atom AtomNew; EXTERNAL Term TermNew; +EXTERNAL Atom AtomNewLine; EXTERNAL Term TermNewLine; +EXTERNAL Atom AtomNl; EXTERNAL Term TermNl; +EXTERNAL Atom AtomNoEffect; EXTERNAL Term TermNoEffect; +EXTERNAL Atom AtomNoMemory; EXTERNAL Term TermNoMemory; +EXTERNAL Atom AtomNone; EXTERNAL Term TermNone; +EXTERNAL Atom AtomNonEmptyList; EXTERNAL Term TermNonEmptyList; +EXTERNAL Atom AtomNot; EXTERNAL Term TermNot; +EXTERNAL Atom AtomNotImplemented; EXTERNAL Term TermNotImplemented; +EXTERNAL Atom AtomNotLessThanZero; EXTERNAL Term TermNotLessThanZero; +EXTERNAL Atom AtomNotNewline; EXTERNAL Term TermNotNewline; +EXTERNAL Atom AtomNotZero; EXTERNAL Term TermNotZero; +EXTERNAL Atom AtomNumber; EXTERNAL Term TermNumber; +EXTERNAL Atom AtomObj; EXTERNAL Term TermObj; +EXTERNAL Atom AtomOff; EXTERNAL Term TermOff; +EXTERNAL Atom AtomOffline; EXTERNAL Term TermOffline; +EXTERNAL Atom AtomOn; EXTERNAL Term TermOn; +EXTERNAL Atom AtomOnline; EXTERNAL Term TermOnline; +EXTERNAL Atom AtomOpen; EXTERNAL Term TermOpen; +EXTERNAL Atom AtomOperatingSystemError; EXTERNAL Term TermOperatingSystemError; +EXTERNAL Atom AtomOperatingSystemSupport; EXTERNAL Term TermOperatingSystemSupport; +EXTERNAL Atom AtomOperator; EXTERNAL Term TermOperator; +EXTERNAL Atom AtomOperatorPriority; EXTERNAL Term TermOperatorPriority; +EXTERNAL Atom AtomOperatorSpecifier; EXTERNAL Term TermOperatorSpecifier; +EXTERNAL Atom AtomOpt; EXTERNAL Term TermOpt; +EXTERNAL Atom AtomOtherwise; EXTERNAL Term TermOtherwise; +EXTERNAL Atom AtomOutOfAttvarsError; EXTERNAL Term TermOutOfAttvarsError; +EXTERNAL Atom AtomOutOfAuxspaceError; EXTERNAL Term TermOutOfAuxspaceError; +EXTERNAL Atom AtomOutOfHeapError; EXTERNAL Term TermOutOfHeapError; +EXTERNAL Atom AtomOutOfRange; EXTERNAL Term TermOutOfRange; +EXTERNAL Atom AtomOutOfStackError; EXTERNAL Term TermOutOfStackError; +EXTERNAL Atom AtomOutOfTrailError; EXTERNAL Term TermOutOfTrailError; +EXTERNAL Atom AtomOutput; EXTERNAL Term TermOutput; +EXTERNAL Atom AtomParameter; EXTERNAL Term TermParameter; +EXTERNAL Atom AtomPrologCommonsDir; EXTERNAL Term TermPrologCommonsDir; +EXTERNAL Atom AtomPast; EXTERNAL Term TermPast; +EXTERNAL Atom AtomPastEndOfStream; EXTERNAL Term TermPastEndOfStream; +EXTERNAL Atom AtomPermissionError; EXTERNAL Term TermPermissionError; +EXTERNAL Atom AtomPi; EXTERNAL Term TermPi; +EXTERNAL Atom AtomPipe; EXTERNAL Term TermPipe; +EXTERNAL Atom AtomPlus; EXTERNAL Term TermPlus; +EXTERNAL Atom AtomPointer; EXTERNAL Term TermPointer; +EXTERNAL Atom AtomPortray; EXTERNAL Term TermPortray; +EXTERNAL Atom AtomPredicateIndicator; EXTERNAL Term TermPredicateIndicator; +EXTERNAL Atom AtomPrimitive; EXTERNAL Term TermPrimitive; +EXTERNAL Atom AtomPrintMessage; EXTERNAL Term TermPrintMessage; +EXTERNAL Atom AtomPrivateProcedure; EXTERNAL Term TermPrivateProcedure; +EXTERNAL Atom AtomProcedure; EXTERNAL Term TermProcedure; +EXTERNAL Atom AtomProfile; EXTERNAL Term TermProfile; +EXTERNAL Atom AtomProlog; EXTERNAL Term TermProlog; +EXTERNAL Atom AtomProtectStack; EXTERNAL Term TermProtectStack; +EXTERNAL Atom AtomQly; EXTERNAL Term TermQly; +EXTERNAL Atom AtomQuery; EXTERNAL Term TermQuery; +EXTERNAL Atom AtomQueue; EXTERNAL Term TermQueue; +EXTERNAL Atom AtomQuiet; EXTERNAL Term TermQuiet; +EXTERNAL Atom AtomRadix; EXTERNAL Term TermRadix; +EXTERNAL Atom AtomRandom; EXTERNAL Term TermRandom; +EXTERNAL Atom AtomRange; EXTERNAL Term TermRange; +EXTERNAL Atom AtomRDiv; EXTERNAL Term TermRDiv; +EXTERNAL Atom AtomRead; EXTERNAL Term TermRead; +EXTERNAL Atom AtomReadOnly; EXTERNAL Term TermReadOnly; +EXTERNAL Atom AtomReadWrite; EXTERNAL Term TermReadWrite; +EXTERNAL Atom AtomReadutil; EXTERNAL Term TermReadutil; +EXTERNAL Atom AtomReconsult; EXTERNAL Term TermReconsult; +EXTERNAL Atom AtomRecordedP; EXTERNAL Term TermRecordedP; +EXTERNAL Atom AtomRecordedWithKey; EXTERNAL Term TermRecordedWithKey; +EXTERNAL Atom AtomRedefineWarnings; EXTERNAL Term TermRedefineWarnings; +EXTERNAL Atom AtomRedoFreeze; EXTERNAL Term TermRedoFreeze; +EXTERNAL Atom AtomRefoundVar; EXTERNAL Term TermRefoundVar; +EXTERNAL Atom AtomRelativeTo; EXTERNAL Term TermRelativeTo; +EXTERNAL Atom AtomRepeat; EXTERNAL Term TermRepeat; +EXTERNAL Atom AtomRepeatSpace; EXTERNAL Term TermRepeatSpace; +EXTERNAL Atom AtomReposition; EXTERNAL Term TermReposition; +EXTERNAL Atom AtomRepresentationError; EXTERNAL Term TermRepresentationError; +EXTERNAL Atom AtomReset; EXTERNAL Term TermReset; +EXTERNAL Atom AtomResize; EXTERNAL Term TermResize; +EXTERNAL Atom AtomResourceError; EXTERNAL Term TermResourceError; +EXTERNAL Atom AtomRestoreRegs; EXTERNAL Term TermRestoreRegs; +EXTERNAL Atom AtomRetry; EXTERNAL Term TermRetry; +EXTERNAL Atom AtomRetryCounter; EXTERNAL Term TermRetryCounter; +EXTERNAL Atom AtomRTree; EXTERNAL Term TermRTree; +EXTERNAL Atom AtomSafe; EXTERNAL Term TermSafe; +EXTERNAL Atom AtomSafeCallCleanup; EXTERNAL Term TermSafeCallCleanup; +EXTERNAL Atom AtomSame; EXTERNAL Term TermSame; +EXTERNAL Atom AtomSemic; EXTERNAL Term TermSemic; +EXTERNAL Atom AtomShiftCountOverflow; EXTERNAL Term TermShiftCountOverflow; +EXTERNAL Atom AtomSigAlarm; EXTERNAL Term TermSigAlarm; +EXTERNAL Atom AtomSigBreak; EXTERNAL Term TermSigBreak; +EXTERNAL Atom AtomSigCreep; EXTERNAL Term TermSigCreep; +EXTERNAL Atom AtomSigDebug; EXTERNAL Term TermSigDebug; +EXTERNAL Atom AtomSigDelayCreep; EXTERNAL Term TermSigDelayCreep; +EXTERNAL Atom AtomSigFPE; EXTERNAL Term TermSigFPE; +EXTERNAL Atom AtomSigHup; EXTERNAL Term TermSigHup; +EXTERNAL Atom AtomSigInt; EXTERNAL Term TermSigInt; +EXTERNAL Atom AtomSigIti; EXTERNAL Term TermSigIti; +EXTERNAL Atom AtomSigPending; EXTERNAL Term TermSigPending; +EXTERNAL Atom AtomSigPipe; EXTERNAL Term TermSigPipe; +EXTERNAL Atom AtomSigStackDump; EXTERNAL Term TermSigStackDump; +EXTERNAL Atom AtomSigStatistics; EXTERNAL Term TermSigStatistics; +EXTERNAL Atom AtomSigTrace; EXTERNAL Term TermSigTrace; +EXTERNAL Atom AtomSigUsr1; EXTERNAL Term TermSigUsr1; +EXTERNAL Atom AtomSigUsr2; EXTERNAL Term TermSigUsr2; +EXTERNAL Atom AtomSigVTAlarm; EXTERNAL Term TermSigVTAlarm; +EXTERNAL Atom AtomSigWakeUp; EXTERNAL Term TermSigWakeUp; +EXTERNAL Atom AtomSilent; EXTERNAL Term TermSilent; +EXTERNAL Atom AtomSingle; EXTERNAL Term TermSingle; +EXTERNAL Atom AtomSingleVarWarnings; EXTERNAL Term TermSingleVarWarnings; +EXTERNAL Atom AtomSingleton; EXTERNAL Term TermSingleton; +EXTERNAL Atom AtomSlash; EXTERNAL Term TermSlash; +EXTERNAL Atom AtomSocket; EXTERNAL Term TermSocket; +EXTERNAL Atom AtomSolutions; EXTERNAL Term TermSolutions; +EXTERNAL Atom AtomSource; EXTERNAL Term TermSource; +EXTERNAL Atom AtomSourceSink; EXTERNAL Term TermSourceSink; +EXTERNAL Atom AtomSpy; EXTERNAL Term TermSpy; +EXTERNAL Atom AtomStack; EXTERNAL Term TermStack; +EXTERNAL Atom AtomStackFree; EXTERNAL Term TermStackFree; +EXTERNAL Atom AtomStartupSavedState; EXTERNAL Term TermStartupSavedState; +EXTERNAL Atom AtomStaticClause; EXTERNAL Term TermStaticClause; +EXTERNAL Atom AtomStaticProcedure; EXTERNAL Term TermStaticProcedure; +EXTERNAL Atom AtomStream; EXTERNAL Term TermStream; +EXTERNAL Atom AtomSWIStream; EXTERNAL Term TermSWIStream; +EXTERNAL Atom AtomVStream; EXTERNAL Term TermVStream; +EXTERNAL Atom AtomStreams; EXTERNAL Term TermStreams; +EXTERNAL Atom AtomStreamOrAlias; EXTERNAL Term TermStreamOrAlias; +EXTERNAL Atom AtomStreamPos; EXTERNAL Term TermStreamPos; +EXTERNAL Atom AtomStreamPosition; EXTERNAL Term TermStreamPosition; +EXTERNAL Atom AtomString; EXTERNAL Term TermString; +EXTERNAL Atom AtomStyleCheck; EXTERNAL Term TermStyleCheck; +EXTERNAL Atom AtomSTRING; EXTERNAL Term TermSTRING; +EXTERNAL Atom AtomSwi; EXTERNAL Term TermSwi; +EXTERNAL Atom AtomSymbolChar; EXTERNAL Term TermSymbolChar; +EXTERNAL Atom AtomSyntaxError; EXTERNAL Term TermSyntaxError; +EXTERNAL Atom AtomSyntaxErrors; EXTERNAL Term TermSyntaxErrors; +EXTERNAL Atom AtomSyntaxErrorHandler; EXTERNAL Term TermSyntaxErrorHandler; +EXTERNAL Atom AtomSystem; EXTERNAL Term TermSystem; +EXTERNAL Atom AtomSystemError; EXTERNAL Term TermSystemError; +EXTERNAL Atom AtomSystemLibraryDir; EXTERNAL Term TermSystemLibraryDir; +EXTERNAL Atom AtomT; EXTERNAL Term TermT; +EXTERNAL Atom AtomTerm; EXTERNAL Term TermTerm; +EXTERNAL Atom AtomTermExpansion; EXTERNAL Term TermTermExpansion; +EXTERNAL Atom AtomTerms; EXTERNAL Term TermTerms; +EXTERNAL Atom AtomText; EXTERNAL Term TermText; +EXTERNAL Atom AtomTextStream; EXTERNAL Term TermTextStream; +EXTERNAL Atom AtomThread; EXTERNAL Term TermThread; +EXTERNAL Atom AtomThreads; EXTERNAL Term TermThreads; +EXTERNAL Atom AtomThrow; EXTERNAL Term TermThrow; +EXTERNAL Atom AtomTimeOutSpec; EXTERNAL Term TermTimeOutSpec; +EXTERNAL Atom AtomTimeoutError; EXTERNAL Term TermTimeoutError; +EXTERNAL Atom AtomTopLevelGoal; EXTERNAL Term TermTopLevelGoal; +EXTERNAL Atom AtomTopThreadGoal; EXTERNAL Term TermTopThreadGoal; +EXTERNAL Atom AtomTraceMetaCall; EXTERNAL Term TermTraceMetaCall; +EXTERNAL Atom AtomTrail; +EXTERNAL Atom AtomTrue; EXTERNAL Term TermTrue; +EXTERNAL Atom AtomTty; EXTERNAL Term TermTty; +EXTERNAL Atom AtomTtys; EXTERNAL Term TermTtys; +EXTERNAL Atom AtomTuple; EXTERNAL Term TermTuple; +EXTERNAL Atom AtomTxt; EXTERNAL Term TermTxt; +EXTERNAL Atom AtomTypeError; EXTERNAL Term TermTypeError; +EXTERNAL Atom AtomUndefined; EXTERNAL Term TermUndefined; +EXTERNAL Atom AtomUndefp; EXTERNAL Term TermUndefp; +EXTERNAL Atom AtomUndefp0; EXTERNAL Term TermUndefp0; +EXTERNAL Atom AtomUnderflow; EXTERNAL Term TermUnderflow; +EXTERNAL Atom AtomUnificationStack; EXTERNAL Term TermUnificationStack; +EXTERNAL Atom AtomUnique; EXTERNAL Term TermUnique; +EXTERNAL Atom AtomUnsignedByte; EXTERNAL Term TermUnsignedByte; +EXTERNAL Atom AtomUnsignedChar; EXTERNAL Term TermUnsignedChar; +EXTERNAL Atom AtomUser; EXTERNAL Term TermUser; +EXTERNAL Atom AtomUserErr; EXTERNAL Term TermUserErr; +EXTERNAL Atom AtomUserIn; EXTERNAL Term TermUserIn; +EXTERNAL Atom AtomUserOut; EXTERNAL Term TermUserOut; +EXTERNAL Atom AtomDollarVar; EXTERNAL Term TermDollarVar; +EXTERNAL Atom AtomVBar; EXTERNAL Term TermVBar; +EXTERNAL Atom AtomVarBranches; EXTERNAL Term TermVarBranches; +EXTERNAL Atom AtomVariableNames; EXTERNAL Term TermVariableNames; +EXTERNAL Atom AtomHiddenVar; EXTERNAL Term TermHiddenVar; +EXTERNAL Atom AtomVariable; EXTERNAL Term TermVariable; +EXTERNAL Atom AtomVerbose; EXTERNAL Term TermVerbose; +EXTERNAL Atom AtomVerboseFileSearch; EXTERNAL Term TermVerboseFileSearch; +EXTERNAL Atom AtomVersionNumber; EXTERNAL Term TermVersionNumber; +EXTERNAL Atom AtomVeryVerbose; EXTERNAL Term TermVeryVerbose; +EXTERNAL Atom AtomWakeUpGoal; EXTERNAL Term TermWakeUpGoal; +EXTERNAL Atom AtomWarning; EXTERNAL Term TermWarning; +EXTERNAL Atom AtomWhen; EXTERNAL Term TermWhen; +EXTERNAL Atom AtomWrite; EXTERNAL Term TermWrite; +EXTERNAL Atom AtomWriteTerm; EXTERNAL Term TermWriteTerm; +EXTERNAL Atom AtomXml; EXTERNAL Term TermXml; +EXTERNAL Atom AtomYapHacks; EXTERNAL Term TermYapHacks; +EXTERNAL Atom AtomZeroDivisor; EXTERNAL Term TermZeroDivisor; +EXTERNAL Functor FunctorAfInet; - Functor FunctorAfLocal; +EXTERNAL Functor FunctorAfLocal; - Functor FunctorAfUnix; +EXTERNAL Functor FunctorAfUnix; - Functor FunctorAltNot; +EXTERNAL Functor FunctorAltNot; - Functor FunctorArg; +EXTERNAL Functor FunctorArg; - Functor FunctorArrayEntry; +EXTERNAL Functor FunctorArrayEntry; - Functor FunctorArrow; +EXTERNAL Functor FunctorArrow; - Functor FunctorDoubleArrow; +EXTERNAL Functor FunctorDoubleArrow; - Functor FunctorAssert1; +EXTERNAL Functor FunctorAssert1; - Functor FunctorAssert; +EXTERNAL Functor FunctorAssert; - Functor FunctorAtFoundOne; +EXTERNAL Functor FunctorAtFoundOne; - Functor FunctorAtom; +EXTERNAL Functor FunctorAtom; - Functor FunctorAtt1; +EXTERNAL Functor FunctorAtt1; - Functor FunctorAttGoal; +EXTERNAL Functor FunctorAttGoal; - Functor FunctorBraces; +EXTERNAL Functor FunctorBraces; - Functor FunctorCall; +EXTERNAL Functor FunctorCall; - Functor FunctorCatch; +EXTERNAL Functor FunctorCatch; - Functor FunctorChangeModule; +EXTERNAL Functor FunctorChangeModule; - Functor FunctorChars; +EXTERNAL Functor FunctorChars; - Functor FunctorChars1; +EXTERNAL Functor FunctorChars1; - Functor FunctorCleanCall; +EXTERNAL Functor FunctorCleanCall; - Functor FunctorClist; +EXTERNAL Functor FunctorClist; - Functor FunctorCodes; +EXTERNAL Functor FunctorCodes; - Functor FunctorCodes1; +EXTERNAL Functor FunctorCodes1; - Functor FunctorColon; +EXTERNAL Functor FunctorColon; - Functor FunctorComma; +EXTERNAL Functor FunctorComma; - Functor FunctorCommentHook; +EXTERNAL Functor FunctorCommentHook; - Functor FunctorContext2; +EXTERNAL Functor FunctorContext2; - Functor FunctorConsistencyError; +EXTERNAL Functor FunctorConsistencyError; - Functor FunctorCreep; +EXTERNAL Functor FunctorCreep; - Functor FunctorCsult; +EXTERNAL Functor FunctorCsult; - Functor FunctorCurrentModule; +EXTERNAL Functor FunctorCurrentModule; - Functor FunctorCutBy; +EXTERNAL Functor FunctorCutBy; - Functor FunctorDBREF; +EXTERNAL Functor FunctorDBREF; - Functor FunctorDiff; +EXTERNAL Functor FunctorDiff; - Functor FunctorDoLogUpdClause; +EXTERNAL Functor FunctorDoLogUpdClause; - Functor FunctorDoLogUpdClause0; +EXTERNAL Functor FunctorDoLogUpdClause0; - Functor FunctorDoLogUpdClauseErase; +EXTERNAL Functor FunctorDoLogUpdClauseErase; - Functor FunctorDoStaticClause; +EXTERNAL Functor FunctorDoStaticClause; - Functor FunctorDollar; +EXTERNAL Functor FunctorDollar; - Functor FunctorDollarVar; +EXTERNAL Functor FunctorDollarVar; - Functor FunctorDomainError; +EXTERNAL Functor FunctorDomainError; - Functor FunctorDot; +EXTERNAL Functor FunctorDot; - Functor FunctorDot10; +EXTERNAL Functor FunctorDot10; - Functor FunctorDot11; +EXTERNAL Functor FunctorDot11; - Functor FunctorDot12; +EXTERNAL Functor FunctorDot12; - Functor FunctorDot2; +EXTERNAL Functor FunctorDot2; - Functor FunctorDot3; +EXTERNAL Functor FunctorDot3; - Functor FunctorDot4; +EXTERNAL Functor FunctorDot4; - Functor FunctorDot5; +EXTERNAL Functor FunctorDot5; - Functor FunctorDot6; +EXTERNAL Functor FunctorDot6; - Functor FunctorDot7; +EXTERNAL Functor FunctorDot7; - Functor FunctorDot8; +EXTERNAL Functor FunctorDot8; - Functor FunctorDot9; +EXTERNAL Functor FunctorDot9; - Functor FunctorDoubleSlash; +EXTERNAL Functor FunctorDoubleSlash; - Functor FunctorEmptySquareBrackets; +EXTERNAL Functor FunctorEmptySquareBrackets; - Functor FunctorEmptyCurlyBrackets; +EXTERNAL Functor FunctorEmptyCurlyBrackets; - Functor FunctorEq; +EXTERNAL Functor FunctorEq; - Functor FunctorError; +EXTERNAL Functor FunctorError; - Functor FunctorEvaluationError; +EXTERNAL Functor FunctorEvaluationError; - Functor FunctorException; +EXTERNAL Functor FunctorException; - Functor FunctorExecute2InMod; +EXTERNAL Functor FunctorExecute2InMod; - Functor FunctorExecuteInMod; +EXTERNAL Functor FunctorExecuteInMod; - Functor FunctorExecuteWithin; +EXTERNAL Functor FunctorExecuteWithin; - Functor FunctorExistenceError; +EXTERNAL Functor FunctorExistenceError; - Functor FunctorExoClause; +EXTERNAL Functor FunctorExoClause; - Functor FunctorFunctor; +EXTERNAL Functor FunctorFunctor; - Functor FunctorGAtom; +EXTERNAL Functor FunctorGAtom; - Functor FunctorGAtomic; +EXTERNAL Functor FunctorGAtomic; - Functor FunctorGCompound; +EXTERNAL Functor FunctorGCompound; - Functor FunctorGFloat; +EXTERNAL Functor FunctorGFloat; - Functor FunctorGFormatAt; +EXTERNAL Functor FunctorGFormatAt; - Functor FunctorGInteger; +EXTERNAL Functor FunctorGInteger; - Functor FunctorGNumber; +EXTERNAL Functor FunctorGNumber; - Functor FunctorGPrimitive; +EXTERNAL Functor FunctorGPrimitive; - Functor FunctorGVar; +EXTERNAL Functor FunctorGVar; - Functor FunctorGeneratePredInfo; +EXTERNAL Functor FunctorGeneratePredInfo; - Functor FunctorGoalExpansion2; +EXTERNAL Functor FunctorGoalExpansion2; - Functor FunctorGoalExpansion; +EXTERNAL Functor FunctorGoalExpansion; - Functor FunctorHandleThrow; +EXTERNAL Functor FunctorHandleThrow; - Functor FunctorHat; +EXTERNAL Functor FunctorHat; - Functor FunctorI; +EXTERNAL Functor FunctorI; - Functor FunctorId; +EXTERNAL Functor FunctorId; - Functor FunctorIs; +EXTERNAL Functor FunctorIs; - Functor FunctorJ; +EXTERNAL Functor FunctorJ; - Functor FunctorLastExecuteWithin; +EXTERNAL Functor FunctorLastExecuteWithin; - Functor FunctorList; +EXTERNAL Functor FunctorList; - Functor FunctorLOOP; +EXTERNAL Functor FunctorLOOP; - Functor FunctorMegaClause; +EXTERNAL Functor FunctorMegaClause; - Functor FunctorMetaCall; +EXTERNAL Functor FunctorMetaCall; - Functor FunctorMinus; +EXTERNAL Functor FunctorMinus; - Functor FunctorModule; +EXTERNAL Functor FunctorModule; - Functor FunctorMultiFileClause; +EXTERNAL Functor FunctorMultiFileClause; - Functor FunctorMutable; +EXTERNAL Functor FunctorMutable; - Functor FunctorMutex; +EXTERNAL Functor FunctorMutex; - Functor FunctorNotImplemented; +EXTERNAL Functor FunctorNotImplemented; - Functor FunctorNBQueue; +EXTERNAL Functor FunctorNBQueue; - Functor FunctorNot; +EXTERNAL Functor FunctorNot; - Functor FunctorObj; +EXTERNAL Functor FunctorObj; - Functor FunctorOr; +EXTERNAL Functor FunctorOr; - Functor FunctorPermissionError; +EXTERNAL Functor FunctorPermissionError; - Functor FunctorPlus; +EXTERNAL Functor FunctorPlus; - Functor FunctorPortray; +EXTERNAL Functor FunctorPortray; - Functor FunctorPrintMessage; +EXTERNAL Functor FunctorPrintMessage; - Functor FunctorProcedure; +EXTERNAL Functor FunctorProcedure; - Functor FunctorPrologConstraint; +EXTERNAL Functor FunctorPrologConstraint; - Functor FunctorProtectStack; +EXTERNAL Functor FunctorProtectStack; - Functor FunctorQuery; +EXTERNAL Functor FunctorQuery; - Functor FunctorRecordedWithKey; +EXTERNAL Functor FunctorRecordedWithKey; - Functor FunctorRDiv; +EXTERNAL Functor FunctorRDiv; - Functor FunctorRedoFreeze; +EXTERNAL Functor FunctorRedoFreeze; - Functor FunctorRepresentationError; +EXTERNAL Functor FunctorRepresentationError; - Functor FunctorResourceError; +EXTERNAL Functor FunctorResourceError; - Functor FunctorRestoreRegs; +EXTERNAL Functor FunctorRestoreRegs; - Functor FunctorRestoreRegs1; +EXTERNAL Functor FunctorRestoreRegs1; - Functor FunctorSafe; +EXTERNAL Functor FunctorSafe; - Functor FunctorSafeCallCleanup; +EXTERNAL Functor FunctorSafeCallCleanup; - Functor FunctorSame; +EXTERNAL Functor FunctorSame; - Functor FunctorSlash; +EXTERNAL Functor FunctorSlash; - Functor FunctorStaticClause; +EXTERNAL Functor FunctorStaticClause; - Functor FunctorStream; +EXTERNAL Functor FunctorStream; - Functor FunctorStreamEOS; +EXTERNAL Functor FunctorStreamEOS; - Functor FunctorStreamPos; +EXTERNAL Functor FunctorStreamPos; - Functor FunctorString1; +EXTERNAL Functor FunctorString1; - Functor FunctorStyleCheck; +EXTERNAL Functor FunctorStyleCheck; - Functor FunctorSyntaxError; +EXTERNAL Functor FunctorSyntaxError; - Functor FunctorShortSyntaxError; +EXTERNAL Functor FunctorShortSyntaxError; - Functor FunctorTermExpansion; +EXTERNAL Functor FunctorTermExpansion; - Functor FunctorThreadRun; +EXTERNAL Functor FunctorThreadRun; - Functor FunctorThrow; +EXTERNAL Functor FunctorThrow; - Functor FunctorTimeoutError; +EXTERNAL Functor FunctorTimeoutError; - Functor FunctorTraceMetaCall; +EXTERNAL Functor FunctorTraceMetaCall; - Functor FunctorTypeError; +EXTERNAL Functor FunctorTypeError; - Functor FunctorUMinus; +EXTERNAL Functor FunctorUMinus; - Functor FunctorUPlus; +EXTERNAL Functor FunctorUPlus; - Functor FunctorVBar; +EXTERNAL Functor FunctorVBar; - Functor FunctorHiddenVar; +EXTERNAL Functor FunctorWriteTerm; + +EXTERNAL Functor FunctorHiddenVar;