more atoms plus cleanups
This commit is contained in:
Vítor Santos Costa
parent
9d1fa8a907
commit
88b179b603
@ -87,6 +87,7 @@
|
|||||||
#ifdef EUROTRA
|
#ifdef EUROTRA
|
||||||
#define TermDollarU Yap_heap_regs->TermDollarU_
|
#define TermDollarU Yap_heap_regs->TermDollarU_
|
||||||
#endif
|
#endif
|
||||||
|
#define TermAnswer Yap_heap_regs->TermAnswer_
|
||||||
|
|
||||||
#define USER_MODULE Yap_heap_regs->USER_MODULE_
|
#define USER_MODULE Yap_heap_regs->USER_MODULE_
|
||||||
#define IDB_MODULE Yap_heap_regs->IDB_MODULE_
|
#define IDB_MODULE Yap_heap_regs->IDB_MODULE_
|
||||||
@ -135,24 +136,25 @@
|
|||||||
#ifdef COROUTINING
|
#ifdef COROUTINING
|
||||||
#define WakeUpCode Yap_heap_regs->WakeUpCode_
|
#define WakeUpCode Yap_heap_regs->WakeUpCode_
|
||||||
#endif
|
#endif
|
||||||
#define PredGoalExpansion Yap_heap_regs->PredGoalExpansion_
|
|
||||||
#define PredMetaCall Yap_heap_regs->PredMetaCall_
|
|
||||||
#define PredTraceMetaCall Yap_heap_regs->PredTraceMetaCall_
|
|
||||||
#define PredDollarCatch Yap_heap_regs->PredDollarCatch_
|
#define PredDollarCatch Yap_heap_regs->PredDollarCatch_
|
||||||
#define PredRecordedWithKey Yap_heap_regs->PredRecordedWithKey_
|
|
||||||
#define PredLogUpdClause Yap_heap_regs->PredLogUpdClause_
|
|
||||||
#define PredLogUpdClauseErase Yap_heap_regs->PredLogUpdClauseErase_
|
|
||||||
#define PredLogUpdClause0 Yap_heap_regs->PredLogUpdClause0_
|
|
||||||
#define PredStaticClause Yap_heap_regs->PredStaticClause_
|
|
||||||
#define PredThrow Yap_heap_regs->PredThrow_
|
|
||||||
#define PredHandleThrow Yap_heap_regs->PredHandleThrow_
|
|
||||||
#define PredIs Yap_heap_regs->PredIs_
|
|
||||||
#define PredSafeCallCleanup Yap_heap_regs->PredSafeCallCleanup_
|
|
||||||
#define PredRestoreRegs Yap_heap_regs->PredRestoreRegs_
|
|
||||||
#define PredCommentHook Yap_heap_regs->PredCommentHook_
|
|
||||||
#ifdef YAPOR
|
#ifdef YAPOR
|
||||||
#define PredGetwork Yap_heap_regs->PredGetwork_
|
#define PredGetwork Yap_heap_regs->PredGetwork_
|
||||||
#endif /* YAPOR */
|
#endif /* YAPOR */
|
||||||
|
#define PredGoalExpansion Yap_heap_regs->PredGoalExpansion_
|
||||||
|
#define PredHandleThrow Yap_heap_regs->PredHandleThrow_
|
||||||
|
#define PredIs Yap_heap_regs->PredIs_
|
||||||
|
#define PredLogUpdClause Yap_heap_regs->PredLogUpdClause_
|
||||||
|
#define PredLogUpdClauseErase Yap_heap_regs->PredLogUpdClauseErase_
|
||||||
|
#define PredLogUpdClause0 Yap_heap_regs->PredLogUpdClause0_
|
||||||
|
#define PredMetaCall Yap_heap_regs->PredMetaCall_
|
||||||
|
#define PredProtectStack Yap_heap_regs->PredProtectStack_
|
||||||
|
#define PredRecordedWithKey Yap_heap_regs->PredRecordedWithKey_
|
||||||
|
#define PredRestoreRegs Yap_heap_regs->PredRestoreRegs_
|
||||||
|
#define PredSafeCallCleanup Yap_heap_regs->PredSafeCallCleanup_
|
||||||
|
#define PredStaticClause Yap_heap_regs->PredStaticClause_
|
||||||
|
#define PredThrow Yap_heap_regs->PredThrow_
|
||||||
|
#define PredTraceMetaCall Yap_heap_regs->PredTraceMetaCall_
|
||||||
|
#define PredCommentHook Yap_heap_regs->PredCommentHook_
|
||||||
#define PredProcedure Yap_heap_regs->PredProcedure_
|
#define PredProcedure Yap_heap_regs->PredProcedure_
|
||||||
|
|
||||||
#ifdef LOW_LEVEL_TRACER
|
#ifdef LOW_LEVEL_TRACER
|
||||||
|
|||||||
@ -135,24 +135,25 @@ EXTERNAL struct pred_entry *PredTrue;
|
|||||||
#ifdef COROUTINING
|
#ifdef COROUTINING
|
||||||
EXTERNAL struct pred_entry *WakeUpCode;
|
EXTERNAL struct pred_entry *WakeUpCode;
|
||||||
#endif
|
#endif
|
||||||
EXTERNAL struct pred_entry *PredGoalExpansion;
|
|
||||||
EXTERNAL struct pred_entry *PredMetaCall;
|
|
||||||
EXTERNAL struct pred_entry *PredTraceMetaCall;
|
|
||||||
EXTERNAL struct pred_entry *PredDollarCatch;
|
EXTERNAL struct pred_entry *PredDollarCatch;
|
||||||
EXTERNAL struct pred_entry *PredRecordedWithKey;
|
|
||||||
EXTERNAL struct pred_entry *PredLogUpdClause;
|
|
||||||
EXTERNAL struct pred_entry *PredLogUpdClauseErase;
|
|
||||||
EXTERNAL struct pred_entry *PredLogUpdClause0;
|
|
||||||
EXTERNAL struct pred_entry *PredStaticClause;
|
|
||||||
EXTERNAL struct pred_entry *PredThrow;
|
|
||||||
EXTERNAL struct pred_entry *PredHandleThrow;
|
|
||||||
EXTERNAL struct pred_entry *PredIs;
|
|
||||||
EXTERNAL struct pred_entry *PredSafeCallCleanup;
|
|
||||||
EXTERNAL struct pred_entry *PredRestoreRegs;
|
|
||||||
EXTERNAL struct pred_entry *PredCommentHook;
|
|
||||||
#ifdef YAPOR
|
#ifdef YAPOR
|
||||||
EXTERNAL struct pred_entry *PredGetwork;
|
EXTERNAL struct pred_entry *PredGetwork;
|
||||||
#endif /* YAPOR */
|
#endif /* YAPOR */
|
||||||
|
EXTERNAL struct pred_entry *PredGoalExpansion;
|
||||||
|
EXTERNAL struct pred_entry *PredHandleThrow;
|
||||||
|
EXTERNAL struct pred_entry *PredIs;
|
||||||
|
EXTERNAL struct pred_entry *PredLogUpdClause;
|
||||||
|
EXTERNAL struct pred_entry *PredLogUpdClauseErase;
|
||||||
|
EXTERNAL struct pred_entry *PredLogUpdClause0;
|
||||||
|
EXTERNAL struct pred_entry *PredMetaCall;
|
||||||
|
EXTERNAL struct pred_entry *PredProtectStack;
|
||||||
|
EXTERNAL struct pred_entry *PredRecordedWithKey;
|
||||||
|
EXTERNAL struct pred_entry *PredRestoreRegs;
|
||||||
|
EXTERNAL struct pred_entry *PredSafeCallCleanup;
|
||||||
|
EXTERNAL struct pred_entry *PredStaticClause;
|
||||||
|
EXTERNAL struct pred_entry *PredThrow;
|
||||||
|
EXTERNAL struct pred_entry *PredTraceMetaCall;
|
||||||
|
EXTERNAL struct pred_entry *PredCommentHook;
|
||||||
EXTERNAL struct pred_entry *PredProcedure;
|
EXTERNAL struct pred_entry *PredProcedure;
|
||||||
/* low-level tracer */
|
/* low-level tracer */
|
||||||
#ifdef LOW_LEVEL_TRACER
|
#ifdef LOW_LEVEL_TRACER
|
||||||
|
|||||||
@ -87,6 +87,7 @@
|
|||||||
#ifdef EUROTRA
|
#ifdef EUROTRA
|
||||||
Term TermDollarU_;
|
Term TermDollarU_;
|
||||||
#endif
|
#endif
|
||||||
|
Term TermAnswer_;
|
||||||
//modules
|
//modules
|
||||||
Term USER_MODULE_;
|
Term USER_MODULE_;
|
||||||
Term IDB_MODULE_;
|
Term IDB_MODULE_;
|
||||||
@ -135,24 +136,25 @@
|
|||||||
#ifdef COROUTINING
|
#ifdef COROUTINING
|
||||||
struct pred_entry *WakeUpCode_;
|
struct pred_entry *WakeUpCode_;
|
||||||
#endif
|
#endif
|
||||||
struct pred_entry *PredGoalExpansion_;
|
|
||||||
struct pred_entry *PredMetaCall_;
|
|
||||||
struct pred_entry *PredTraceMetaCall_;
|
|
||||||
struct pred_entry *PredDollarCatch_;
|
struct pred_entry *PredDollarCatch_;
|
||||||
struct pred_entry *PredRecordedWithKey_;
|
|
||||||
struct pred_entry *PredLogUpdClause_;
|
|
||||||
struct pred_entry *PredLogUpdClauseErase_;
|
|
||||||
struct pred_entry *PredLogUpdClause0_;
|
|
||||||
struct pred_entry *PredStaticClause_;
|
|
||||||
struct pred_entry *PredThrow_;
|
|
||||||
struct pred_entry *PredHandleThrow_;
|
|
||||||
struct pred_entry *PredIs_;
|
|
||||||
struct pred_entry *PredSafeCallCleanup_;
|
|
||||||
struct pred_entry *PredRestoreRegs_;
|
|
||||||
struct pred_entry *PredCommentHook_;
|
|
||||||
#ifdef YAPOR
|
#ifdef YAPOR
|
||||||
struct pred_entry *PredGetwork_;
|
struct pred_entry *PredGetwork_;
|
||||||
#endif /* YAPOR */
|
#endif /* YAPOR */
|
||||||
|
struct pred_entry *PredGoalExpansion_;
|
||||||
|
struct pred_entry *PredHandleThrow_;
|
||||||
|
struct pred_entry *PredIs_;
|
||||||
|
struct pred_entry *PredLogUpdClause_;
|
||||||
|
struct pred_entry *PredLogUpdClauseErase_;
|
||||||
|
struct pred_entry *PredLogUpdClause0_;
|
||||||
|
struct pred_entry *PredMetaCall_;
|
||||||
|
struct pred_entry *PredProtectStack_;
|
||||||
|
struct pred_entry *PredRecordedWithKey_;
|
||||||
|
struct pred_entry *PredRestoreRegs_;
|
||||||
|
struct pred_entry *PredSafeCallCleanup_;
|
||||||
|
struct pred_entry *PredStaticClause_;
|
||||||
|
struct pred_entry *PredThrow_;
|
||||||
|
struct pred_entry *PredTraceMetaCall_;
|
||||||
|
struct pred_entry *PredCommentHook_;
|
||||||
struct pred_entry *PredProcedure_;
|
struct pred_entry *PredProcedure_;
|
||||||
/* low-level tracer */
|
/* low-level tracer */
|
||||||
#ifdef LOW_LEVEL_TRACER
|
#ifdef LOW_LEVEL_TRACER
|
||||||
|
|||||||
@ -1,421 +1,424 @@
|
|||||||
|
|
||||||
/* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms"
|
/* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms"
|
||||||
please do not update, update misc/ATOMS instead */
|
{lease do not update, update misc/ATOMS instead */
|
||||||
|
|
||||||
Atom3Dots = Yap_LookupAtom("...");
|
Atom3Dots = Yap_LookupAtom("...");
|
||||||
AtomAbol = Yap_FullLookupAtom("$abol");
|
AtomAbol = Yap_FullLookupAtom("$abol"); TermAbol = MkAtomTerm(AtomAbol);
|
||||||
AtomAccess = Yap_LookupAtom("access");
|
AtomAccess = Yap_LookupAtom("access"); TermAccess = MkAtomTerm(AtomAccess);
|
||||||
AtomAfInet = Yap_LookupAtom("AF_INET");
|
AtomAfInet = Yap_LookupAtom("AF_INET"); TermAfInet = MkAtomTerm(AtomAfInet);
|
||||||
AtomAfLocal = Yap_LookupAtom("AF_LOCAL");
|
AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); TermAfLocal = MkAtomTerm(AtomAfLocal);
|
||||||
AtomAfUnix = Yap_LookupAtom("AF_UNIX");
|
AtomAfUnix = Yap_LookupAtom("AF_UNIX"); TermAfUnix = MkAtomTerm(AtomAfUnix);
|
||||||
AtomAlarm = Yap_FullLookupAtom("$alarm");
|
AtomAlarm = Yap_FullLookupAtom("$alarm"); TermAlarm = MkAtomTerm(AtomAlarm);
|
||||||
AtomAlias = Yap_LookupAtom("alias");
|
AtomAlias = Yap_LookupAtom("alias"); TermAlias = MkAtomTerm(AtomAlias);
|
||||||
AtomAll = Yap_LookupAtom("all");
|
AtomAll = Yap_LookupAtom("all"); TermAll = MkAtomTerm(AtomAll);
|
||||||
AtomAltNot = Yap_LookupAtom("not");
|
AtomAltNot = Yap_LookupAtom("not"); TermAltNot = MkAtomTerm(AtomAltNot);
|
||||||
AtomAny = Yap_LookupAtom("any");
|
AtomAnswer = Yap_LookupAtom("answer"); TermAnswer = MkAtomTerm(AtomAnswer);
|
||||||
AtomAppend = Yap_LookupAtom("append");
|
AtomAny = Yap_LookupAtom("any"); TermAny = MkAtomTerm(AtomAny);
|
||||||
AtomArg = Yap_LookupAtom("arg");
|
AtomAppend = Yap_LookupAtom("append"); TermAppend = MkAtomTerm(AtomAppend);
|
||||||
AtomArray = Yap_FullLookupAtom("$array");
|
AtomArg = Yap_LookupAtom("arg"); TermArg = MkAtomTerm(AtomArg);
|
||||||
AtomArrayAccess = Yap_FullLookupAtom("$array_arg");
|
AtomArray = Yap_FullLookupAtom("$array"); TermArray = MkAtomTerm(AtomArray);
|
||||||
AtomArrayOverflow = Yap_LookupAtom("array_overflow");
|
AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); TermArrayAccess = MkAtomTerm(AtomArrayAccess);
|
||||||
AtomArrayType = Yap_LookupAtom("array_type");
|
AtomArrayOverflow = Yap_LookupAtom("array_overflow"); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow);
|
||||||
AtomArrow = Yap_LookupAtom("->");
|
AtomArrayType = Yap_LookupAtom("array_type"); TermArrayType = MkAtomTerm(AtomArrayType);
|
||||||
AtomAttributedModule = Yap_LookupAtom("attributes_module");
|
AtomArrow = Yap_LookupAtom("->"); TermArrow = MkAtomTerm(AtomArrow);
|
||||||
AtomDoubleArrow = Yap_LookupAtom("-->");
|
AtomAttributedModule = Yap_LookupAtom("attributes_module"); TermAttributedModule = MkAtomTerm(AtomAttributedModule);
|
||||||
AtomAssert = Yap_LookupAtom(":-");
|
AtomDoubleArrow = Yap_LookupAtom("-->"); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow);
|
||||||
AtomEmptyBrackets = Yap_LookupAtom("()");
|
AtomAssert = Yap_LookupAtom(":-"); TermAssert = MkAtomTerm(AtomAssert);
|
||||||
AtomEmptySquareBrackets = Yap_LookupAtom("[]");
|
AtomEmptyBrackets = Yap_LookupAtom("()"); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets);
|
||||||
AtomEmptyCurlyBrackets = Yap_LookupAtom("{}");
|
AtomEmptySquareBrackets = Yap_LookupAtom("[]"); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets);
|
||||||
AtomAsserta = Yap_LookupAtom("asserta");
|
AtomEmptyCurlyBrackets = Yap_LookupAtom("{}"); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets);
|
||||||
AtomAssertaStatic = Yap_LookupAtom("asserta_static");
|
AtomAsserta = Yap_LookupAtom("asserta"); TermAsserta = MkAtomTerm(AtomAsserta);
|
||||||
AtomAssertz = Yap_LookupAtom("assertz");
|
AtomAssertaStatic = Yap_LookupAtom("asserta_static"); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic);
|
||||||
AtomAssertzStatic = Yap_LookupAtom("assertz_static");
|
AtomAssertz = Yap_LookupAtom("assertz"); TermAssertz = MkAtomTerm(AtomAssertz);
|
||||||
AtomAt = Yap_LookupAtom("at");
|
AtomAssertzStatic = Yap_LookupAtom("assertz_static"); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic);
|
||||||
AtomAtom = Yap_LookupAtom("atom");
|
AtomAt = Yap_LookupAtom("at"); TermAt = MkAtomTerm(AtomAt);
|
||||||
AtomAtomic = Yap_LookupAtom("atomic");
|
AtomAtom = Yap_LookupAtom("atom"); TermAtom = MkAtomTerm(AtomAtom);
|
||||||
AtomAtt = Yap_FullLookupAtom("$att");
|
AtomAtomic = Yap_LookupAtom("atomic"); TermAtomic = MkAtomTerm(AtomAtomic);
|
||||||
AtomAtt1 = Yap_LookupAtom("att");
|
AtomAtt = Yap_FullLookupAtom("$att"); TermAtt = MkAtomTerm(AtomAtt);
|
||||||
AtomAttDo = Yap_FullLookupAtom("$att_do");
|
AtomAtt1 = Yap_LookupAtom("att"); TermAtt1 = MkAtomTerm(AtomAtt1);
|
||||||
AtomAttributes = Yap_LookupAtom("attributes");
|
AtomAttDo = Yap_FullLookupAtom("$att_do"); TermAttDo = MkAtomTerm(AtomAttDo);
|
||||||
AtomB = Yap_FullLookupAtom("$last_choice_pt");
|
AtomAttributes = Yap_LookupAtom("attributes"); TermAttributes = MkAtomTerm(AtomAttributes);
|
||||||
AtomBatched = Yap_LookupAtom("batched");
|
AtomB = Yap_FullLookupAtom("$last_choice_pt"); TermB = MkAtomTerm(AtomB);
|
||||||
AtomBetween = Yap_LookupAtom("between");
|
AtomBatched = Yap_LookupAtom("batched"); TermBatched = MkAtomTerm(AtomBatched);
|
||||||
AtomBinary = Yap_LookupAtom("binary");
|
AtomBetween = Yap_LookupAtom("between"); TermBetween = MkAtomTerm(AtomBetween);
|
||||||
AtomBigNum = Yap_LookupAtom("big_num");
|
AtomBinary = Yap_LookupAtom("binary"); TermBinary = MkAtomTerm(AtomBinary);
|
||||||
AtomBinaryStream = Yap_LookupAtom("binary_stream");
|
AtomBigNum = Yap_LookupAtom("big_num"); TermBigNum = MkAtomTerm(AtomBigNum);
|
||||||
AtomBoolean = Yap_LookupAtom("boolean");
|
AtomBinaryStream = Yap_LookupAtom("binary_stream"); TermBinaryStream = MkAtomTerm(AtomBinaryStream);
|
||||||
AtomBraces = Yap_LookupAtom("{}");
|
AtomBoolean = Yap_LookupAtom("boolean"); TermBoolean = MkAtomTerm(AtomBoolean);
|
||||||
AtomBreak = Yap_FullLookupAtom("$break");
|
AtomBraces = Yap_LookupAtom("{}"); TermBraces = MkAtomTerm(AtomBraces);
|
||||||
AtomByte = Yap_LookupAtom("byte");
|
AtomBreak = Yap_FullLookupAtom("$break"); TermBreak = MkAtomTerm(AtomBreak);
|
||||||
AtomCArith = Yap_FullLookupAtom("$c_arith");
|
AtomByte = Yap_LookupAtom("byte"); TermByte = MkAtomTerm(AtomByte);
|
||||||
AtomCall = Yap_LookupAtom("call");
|
AtomCArith = Yap_FullLookupAtom("$c_arith"); TermCArith = MkAtomTerm(AtomCArith);
|
||||||
AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter");
|
AtomCall = Yap_LookupAtom("call"); TermCall = MkAtomTerm(AtomCall);
|
||||||
AtomCallCounter = Yap_LookupAtom("call_counter");
|
AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter);
|
||||||
AtomCallable = Yap_LookupAtom("callable");
|
AtomCallCounter = Yap_LookupAtom("call_counter"); TermCallCounter = MkAtomTerm(AtomCallCounter);
|
||||||
AtomCatch = Yap_FullLookupAtom("$catch");
|
AtomCallable = Yap_LookupAtom("callable"); TermCallable = MkAtomTerm(AtomCallable);
|
||||||
AtomChangeModule = Yap_FullLookupAtom("$change_module");
|
AtomCatch = Yap_FullLookupAtom("$catch"); TermCatch = MkAtomTerm(AtomCatch);
|
||||||
AtomChar = Yap_LookupAtom("char");
|
AtomChangeModule = Yap_FullLookupAtom("$change_module"); TermChangeModule = MkAtomTerm(AtomChangeModule);
|
||||||
AtomCharsio = Yap_LookupAtom("charsio");
|
AtomChar = Yap_LookupAtom("char"); TermChar = MkAtomTerm(AtomChar);
|
||||||
AtomCharacter = Yap_LookupAtom("character");
|
AtomCharsio = Yap_LookupAtom("charsio"); TermCharsio = MkAtomTerm(AtomCharsio);
|
||||||
AtomCharacterCode = Yap_LookupAtom("character_code");
|
AtomCharacter = Yap_LookupAtom("character"); TermCharacter = MkAtomTerm(AtomCharacter);
|
||||||
AtomChars = Yap_LookupAtom("chars");
|
AtomCharacterCode = Yap_LookupAtom("character_code"); TermCharacterCode = MkAtomTerm(AtomCharacterCode);
|
||||||
AtomCharset = Yap_LookupAtom("charset");
|
AtomChars = Yap_LookupAtom("chars"); TermChars = MkAtomTerm(AtomChars);
|
||||||
AtomChType = Yap_FullLookupAtom("$char_type");
|
AtomCharset = Yap_LookupAtom("charset"); TermCharset = MkAtomTerm(AtomCharset);
|
||||||
AtomCleanCall = Yap_FullLookupAtom("$clean_call");
|
AtomChType = Yap_FullLookupAtom("$char_type"); TermChType = MkAtomTerm(AtomChType);
|
||||||
AtomColomn = Yap_LookupAtom(":");
|
AtomCleanCall = Yap_FullLookupAtom("$clean_call"); TermCleanCall = MkAtomTerm(AtomCleanCall);
|
||||||
AtomCodeSpace = Yap_LookupAtom("code_space");
|
AtomColomn = Yap_LookupAtom(":"); TermColomn = MkAtomTerm(AtomColomn);
|
||||||
AtomCodes = Yap_LookupAtom("codes");
|
AtomCodeSpace = Yap_LookupAtom("code_space"); TermCodeSpace = MkAtomTerm(AtomCodeSpace);
|
||||||
AtomCoInductive = Yap_LookupAtom("coinductive");
|
AtomCodes = Yap_LookupAtom("codes"); TermCodes = MkAtomTerm(AtomCodes);
|
||||||
AtomComma = Yap_LookupAtom(",");
|
AtomCoInductive = Yap_LookupAtom("coinductive"); TermCoInductive = MkAtomTerm(AtomCoInductive);
|
||||||
AtomCommentHook = Yap_LookupAtom("comment_hook");
|
AtomComma = Yap_LookupAtom(","); TermComma = MkAtomTerm(AtomComma);
|
||||||
AtomCompact = Yap_LookupAtom("compact");
|
AtomCommentHook = Yap_LookupAtom("comment_hook"); TermCommentHook = MkAtomTerm(AtomCommentHook);
|
||||||
AtomCompound = Yap_LookupAtom("compound");
|
AtomCompact = Yap_LookupAtom("compact"); TermCompact = MkAtomTerm(AtomCompact);
|
||||||
AtomConsistencyError = Yap_LookupAtom("consistency_error");
|
AtomCompound = Yap_LookupAtom("compound"); TermCompound = MkAtomTerm(AtomCompound);
|
||||||
AtomConsult = Yap_LookupAtom("consult");
|
AtomConsistencyError = Yap_LookupAtom("consistency_error"); TermConsistencyError = MkAtomTerm(AtomConsistencyError);
|
||||||
AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot");
|
AtomConsult = Yap_LookupAtom("consult"); TermConsult = MkAtomTerm(AtomConsult);
|
||||||
AtomContext = Yap_LookupAtom("context");
|
AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot);
|
||||||
AtomCputime = Yap_LookupAtom("cputime");
|
AtomContext = Yap_LookupAtom("context"); TermContext = MkAtomTerm(AtomContext);
|
||||||
AtomCreate = Yap_LookupAtom("create");
|
AtomCputime = Yap_LookupAtom("cputime"); TermCputime = MkAtomTerm(AtomCputime);
|
||||||
AtomCreep = Yap_FullLookupAtom("$creep");
|
AtomCreate = Yap_LookupAtom("create"); TermCreate = MkAtomTerm(AtomCreate);
|
||||||
AtomCryptAtoms = Yap_LookupAtom("crypt_atoms");
|
AtomCreep = Yap_FullLookupAtom("$creep"); TermCreep = MkAtomTerm(AtomCreep);
|
||||||
AtomCsult = Yap_FullLookupAtom("$csult");
|
AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms);
|
||||||
AtomCurrentModule = Yap_FullLookupAtom("$current_module");
|
AtomCsult = Yap_FullLookupAtom("$csult"); TermCsult = MkAtomTerm(AtomCsult);
|
||||||
AtomCut = Yap_LookupAtom("!");
|
AtomCurrentModule = Yap_FullLookupAtom("$current_module"); TermCurrentModule = MkAtomTerm(AtomCurrentModule);
|
||||||
AtomCutBy = Yap_FullLookupAtom("$cut_by");
|
AtomCut = Yap_LookupAtom("!"); TermCut = MkAtomTerm(AtomCut);
|
||||||
AtomDAbort = Yap_FullLookupAtom("$abort");
|
AtomCutBy = Yap_FullLookupAtom("$cut_by"); TermCutBy = MkAtomTerm(AtomCutBy);
|
||||||
AtomDBLoad = Yap_FullLookupAtom("$db_load");
|
AtomDAbort = Yap_FullLookupAtom("$abort"); TermDAbort = MkAtomTerm(AtomDAbort);
|
||||||
AtomDBREF = Yap_LookupAtom("DBRef");
|
AtomDBLoad = Yap_FullLookupAtom("$db_load"); TermDBLoad = MkAtomTerm(AtomDBLoad);
|
||||||
AtomDBReference = Yap_LookupAtom("db_reference");
|
AtomDBREF = Yap_LookupAtom("DBRef"); TermDBREF = MkAtomTerm(AtomDBREF);
|
||||||
AtomDBTerm = Yap_LookupAtom("db_term");
|
AtomDBReference = Yap_LookupAtom("db_reference"); TermDBReference = MkAtomTerm(AtomDBReference);
|
||||||
AtomDBref = Yap_FullLookupAtom("$dbref");
|
AtomDBTerm = Yap_LookupAtom("db_term"); TermDBTerm = MkAtomTerm(AtomDBTerm);
|
||||||
AtomDInteger = Yap_FullLookupAtom("$integer");
|
AtomDBref = Yap_FullLookupAtom("$dbref"); TermDBref = MkAtomTerm(AtomDBref);
|
||||||
AtomDebugMeta = Yap_FullLookupAtom("$debug_meta");
|
AtomDInteger = Yap_FullLookupAtom("$integer"); TermDInteger = MkAtomTerm(AtomDInteger);
|
||||||
AtomDebuggerInput = Yap_LookupAtom("debugger_input");
|
AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); TermDebugMeta = MkAtomTerm(AtomDebugMeta);
|
||||||
AtomDec10 = Yap_LookupAtom("dec10");
|
AtomDebuggerInput = Yap_LookupAtom("debugger_input"); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput);
|
||||||
AtomDefault = Yap_LookupAtom("default");
|
AtomDec10 = Yap_LookupAtom("dec10"); TermDec10 = MkAtomTerm(AtomDec10);
|
||||||
AtomDevNull = Yap_LookupAtom("/dev/null");
|
AtomDefault = Yap_LookupAtom("default"); TermDefault = MkAtomTerm(AtomDefault);
|
||||||
AtomDiff = Yap_LookupAtom("\\=");
|
AtomDevNull = Yap_LookupAtom("/dev/null"); TermDevNull = MkAtomTerm(AtomDevNull);
|
||||||
AtomDirectory = Yap_LookupAtom("disrectorys");
|
AtomDiff = Yap_LookupAtom("\\="); TermDiff = MkAtomTerm(AtomDiff);
|
||||||
AtomDiscontiguous = Yap_LookupAtom("discontiguous");
|
AtomDirectory = Yap_LookupAtom("disrectorys"); TermDirectory = MkAtomTerm(AtomDirectory);
|
||||||
AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings");
|
AtomDiscontiguous = Yap_LookupAtom("discontiguous"); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous);
|
||||||
AtomDollar = Yap_FullLookupAtom("$");
|
AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings);
|
||||||
AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause");
|
AtomDollar = Yap_FullLookupAtom("$"); TermDollar = MkAtomTerm(AtomDollar);
|
||||||
AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0");
|
AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause);
|
||||||
AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase");
|
AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0);
|
||||||
AtomDollarU = Yap_FullLookupAtom("$u");
|
AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase);
|
||||||
AtomDollarUndef = Yap_FullLookupAtom("$undef");
|
AtomDollarU = Yap_FullLookupAtom("$u"); TermDollarU = MkAtomTerm(AtomDollarU);
|
||||||
AtomDomainError = Yap_LookupAtom("domain_error");
|
AtomDollarUndef = Yap_FullLookupAtom("$undef"); TermDollarUndef = MkAtomTerm(AtomDollarUndef);
|
||||||
AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause");
|
AtomDomainError = Yap_LookupAtom("domain_error"); TermDomainError = MkAtomTerm(AtomDomainError);
|
||||||
AtomDots = Yap_LookupAtom("dots");
|
AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause);
|
||||||
AtomDOUBLE = Yap_FullLookupAtom("Double");
|
AtomDots = Yap_LookupAtom("dots"); TermDots = MkAtomTerm(AtomDots);
|
||||||
AtomDoubleSlash = Yap_FullLookupAtom("//");
|
AtomDOUBLE = Yap_FullLookupAtom("Double"); TermDOUBLE = MkAtomTerm(AtomDOUBLE);
|
||||||
AtomE = Yap_LookupAtom("e");
|
AtomDoubleSlash = Yap_FullLookupAtom("//"); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash);
|
||||||
AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term");
|
AtomE = Yap_LookupAtom("e"); TermE = MkAtomTerm(AtomE);
|
||||||
AtomEQ = Yap_LookupAtom("=");
|
AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT);
|
||||||
AtomEmptyAtom = Yap_LookupAtom("");
|
AtomEQ = Yap_LookupAtom("="); TermEQ = MkAtomTerm(AtomEQ);
|
||||||
AtomEncoding = Yap_LookupAtom("encoding");
|
AtomEmptyAtom = Yap_LookupAtom(""); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom);
|
||||||
AtomEndOfStream = Yap_LookupAtom("$end_of_stream");
|
AtomEncoding = Yap_LookupAtom("encoding"); TermEncoding = MkAtomTerm(AtomEncoding);
|
||||||
AtomEof = Yap_LookupAtom("end_of_file");
|
AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); TermEndOfStream = MkAtomTerm(AtomEndOfStream);
|
||||||
AtomEOfCode = Yap_LookupAtom("eof_code");
|
AtomEof = Yap_LookupAtom("end_of_file"); TermEof = MkAtomTerm(AtomEof);
|
||||||
AtomEq = Yap_LookupAtom("=");
|
AtomEOfCode = Yap_LookupAtom("eof_code"); TermEOfCode = MkAtomTerm(AtomEOfCode);
|
||||||
AtomError = Yap_LookupAtom("error");
|
AtomEq = Yap_LookupAtom("="); TermEq = MkAtomTerm(AtomEq);
|
||||||
AtomException = Yap_LookupAtom("exception");
|
AtomError = Yap_LookupAtom("error"); TermError = MkAtomTerm(AtomError);
|
||||||
AtomExtensions = Yap_LookupAtom("extensions");
|
AtomException = Yap_LookupAtom("exception"); TermException = MkAtomTerm(AtomException);
|
||||||
AtomEvaluable = Yap_LookupAtom("evaluable");
|
AtomExtensions = Yap_LookupAtom("extensions"); TermExtensions = MkAtomTerm(AtomExtensions);
|
||||||
AtomEvaluationError = Yap_LookupAtom("evaluation_error");
|
AtomEvaluable = Yap_LookupAtom("evaluable"); TermEvaluable = MkAtomTerm(AtomEvaluable);
|
||||||
AtomExecutable = Yap_LookupAtom("executable");
|
AtomEvaluationError = Yap_LookupAtom("evaluation_error"); TermEvaluationError = MkAtomTerm(AtomEvaluationError);
|
||||||
AtomExecute = Yap_LookupAtom("execute");
|
AtomExecutable = Yap_LookupAtom("executable"); TermExecutable = MkAtomTerm(AtomExecutable);
|
||||||
AtomExecAnswers = Yap_LookupAtom("exec_answers");
|
AtomExecute = Yap_LookupAtom("execute"); TermExecute = MkAtomTerm(AtomExecute);
|
||||||
AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod");
|
AtomExecAnswers = Yap_LookupAtom("exec_answers"); TermExecAnswers = MkAtomTerm(AtomExecAnswers);
|
||||||
AtomExecuteWithin = Yap_FullLookupAtom("$execute_within");
|
AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod);
|
||||||
AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod");
|
AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin);
|
||||||
AtomExist = Yap_LookupAtom("exist");
|
AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod);
|
||||||
AtomExistenceError = Yap_LookupAtom("existence_error");
|
AtomExist = Yap_LookupAtom("exist"); TermExist = MkAtomTerm(AtomExist);
|
||||||
AtomExoClause = Yap_FullLookupAtom("$exo_clause");
|
AtomExit = Yap_LookupAtom("exit"); TermExit = MkAtomTerm(AtomExit);
|
||||||
AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax");
|
AtomExistenceError = Yap_LookupAtom("existence_error"); TermExistenceError = MkAtomTerm(AtomExistenceError);
|
||||||
AtomExpand = Yap_LookupAtom("expand");
|
AtomExoClause = Yap_FullLookupAtom("$exo_clause"); TermExoClause = MkAtomTerm(AtomExoClause);
|
||||||
AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path");
|
AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber);
|
||||||
AtomExtendsions = Yap_LookupAtom("extensionh");
|
AtomExpand = Yap_LookupAtom("expand"); TermExpand = MkAtomTerm(AtomExpand);
|
||||||
AtomFB = Yap_LookupAtom("fb");
|
AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath);
|
||||||
AtomFail = Yap_LookupAtom("fail");
|
AtomExtendsions = Yap_LookupAtom("extensionh"); TermExtendsions = MkAtomTerm(AtomExtendsions);
|
||||||
AtomFalse = Yap_LookupAtom("false");
|
AtomFB = Yap_LookupAtom("fb"); TermFB = MkAtomTerm(AtomFB);
|
||||||
AtomFast = Yap_FullLookupAtom("$fast");
|
AtomFail = Yap_LookupAtom("fail"); TermFail = MkAtomTerm(AtomFail);
|
||||||
AtomFastFail = Yap_LookupAtom("fast_fail");
|
AtomFalse = Yap_LookupAtom("false"); TermFalse = MkAtomTerm(AtomFalse);
|
||||||
AtomFileErrors = Yap_LookupAtom("file_errors");
|
AtomFast = Yap_FullLookupAtom("$fast"); TermFast = MkAtomTerm(AtomFast);
|
||||||
AtomFileerrors = Yap_LookupAtom("fileerrors");
|
AtomFastFail = Yap_LookupAtom("fast_fail"); TermFastFail = MkAtomTerm(AtomFastFail);
|
||||||
AtomFileType = Yap_LookupAtom("file_type");
|
AtomFileErrors = Yap_LookupAtom("file_errors"); TermFileErrors = MkAtomTerm(AtomFileErrors);
|
||||||
AtomFirst = Yap_LookupAtom("first");
|
AtomFileerrors = Yap_LookupAtom("fileerrors"); TermFileerrors = MkAtomTerm(AtomFileerrors);
|
||||||
AtomFloat = Yap_LookupAtom("float");
|
AtomFileType = Yap_LookupAtom("file_type"); TermFileType = MkAtomTerm(AtomFileType);
|
||||||
AtomFloatFormat = Yap_LookupAtom("\%.15g");
|
AtomFirst = Yap_LookupAtom("first"); TermFirst = MkAtomTerm(AtomFirst);
|
||||||
AtomFloatOverflow = Yap_LookupAtom("float_overflow");
|
AtomFloat = Yap_LookupAtom("float"); TermFloat = MkAtomTerm(AtomFloat);
|
||||||
AtomFloatUnderflow = Yap_LookupAtom("float_underflow");
|
AtomFloatFormat = Yap_LookupAtom("\%.15g"); TermFloatFormat = MkAtomTerm(AtomFloatFormat);
|
||||||
AtomFormat = Yap_LookupAtom("format");
|
AtomFloatOverflow = Yap_LookupAtom("float_overflow"); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow);
|
||||||
AtomFormatAt = Yap_FullLookupAtom("$format@");
|
AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow);
|
||||||
AtomFull = Yap_LookupAtom("full");
|
AtomFormat = Yap_LookupAtom("format"); TermFormat = MkAtomTerm(AtomFormat);
|
||||||
AtomFunctor = Yap_LookupAtom("functor");
|
AtomFormatAt = Yap_FullLookupAtom("$format@"); TermFormatAt = MkAtomTerm(AtomFormatAt);
|
||||||
AtomGT = Yap_LookupAtom(">");
|
AtomFull = Yap_LookupAtom("full"); TermFull = MkAtomTerm(AtomFull);
|
||||||
AtomGVar = Yap_LookupAtom("var");
|
AtomFunctor = Yap_LookupAtom("functor"); TermFunctor = MkAtomTerm(AtomFunctor);
|
||||||
AtomGc = Yap_FullLookupAtom("$gc");
|
AtomGT = Yap_LookupAtom(">"); TermGT = MkAtomTerm(AtomGT);
|
||||||
AtomGcMargin = Yap_FullLookupAtom("$gc_margin");
|
AtomGVar = Yap_LookupAtom("var"); TermGVar = MkAtomTerm(AtomGVar);
|
||||||
AtomGcTrace = Yap_FullLookupAtom("$gc_trace");
|
AtomGc = Yap_FullLookupAtom("$gc"); TermGc = MkAtomTerm(AtomGc);
|
||||||
AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose");
|
AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); TermGcMargin = MkAtomTerm(AtomGcMargin);
|
||||||
AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose");
|
AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); TermGcTrace = MkAtomTerm(AtomGcTrace);
|
||||||
AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info");
|
AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); TermGcVerbose = MkAtomTerm(AtomGcVerbose);
|
||||||
AtomGetwork = Yap_FullLookupAtom("$getwork");
|
AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose);
|
||||||
AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq");
|
AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo);
|
||||||
AtomGlob = Yap_LookupAtom("glob");
|
AtomGetwork = Yap_FullLookupAtom("$getwork"); TermGetwork = MkAtomTerm(AtomGetwork);
|
||||||
AtomGlobal = Yap_LookupAtom("global");
|
AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq);
|
||||||
AtomGlobalSp = Yap_LookupAtom("global_sp");
|
AtomGlob = Yap_LookupAtom("glob"); TermGlob = MkAtomTerm(AtomGlob);
|
||||||
AtomGlobalTrie = Yap_LookupAtom("global_trie");
|
AtomGlobal = Yap_LookupAtom("global"); TermGlobal = MkAtomTerm(AtomGlobal);
|
||||||
AtomGoalExpansion = Yap_LookupAtom("goal_expansion");
|
AtomGlobalSp = Yap_LookupAtom("global_sp"); TermGlobalSp = MkAtomTerm(AtomGlobalSp);
|
||||||
AtomHat = Yap_LookupAtom("^");
|
AtomGlobalTrie = Yap_LookupAtom("global_trie"); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie);
|
||||||
AtomHERE = Yap_LookupAtom("\n <====HERE====> \n");
|
AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion);
|
||||||
AtomHandleThrow = Yap_FullLookupAtom("$handle_throw");
|
AtomHat = Yap_LookupAtom("^"); TermHat = MkAtomTerm(AtomHat);
|
||||||
AtomHeap = Yap_LookupAtom("heap");
|
AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); TermHERE = MkAtomTerm(AtomHERE);
|
||||||
AtomHeapUsed = Yap_LookupAtom("heapused");
|
AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); TermHandleThrow = MkAtomTerm(AtomHandleThrow);
|
||||||
AtomHugeInt = Yap_LookupAtom("huge_int");
|
AtomHeap = Yap_LookupAtom("heap"); TermHeap = MkAtomTerm(AtomHeap);
|
||||||
AtomIDB = Yap_LookupAtom("idb");
|
AtomHeapUsed = Yap_LookupAtom("heapused"); TermHeapUsed = MkAtomTerm(AtomHeapUsed);
|
||||||
AtomIOMode = Yap_LookupAtom("io_mode");
|
AtomHugeInt = Yap_LookupAtom("huge_int"); TermHugeInt = MkAtomTerm(AtomHugeInt);
|
||||||
AtomId = Yap_LookupAtom("id");
|
AtomIDB = Yap_LookupAtom("idb"); TermIDB = MkAtomTerm(AtomIDB);
|
||||||
AtomIgnore = Yap_LookupAtom("ignore");
|
AtomIOMode = Yap_LookupAtom("io_mode"); TermIOMode = MkAtomTerm(AtomIOMode);
|
||||||
AtomInf = Yap_LookupAtom("inf");
|
AtomId = Yap_LookupAtom("id"); TermId = MkAtomTerm(AtomId);
|
||||||
AtomInfinity = Yap_LookupAtom("infinity");
|
AtomIgnore = Yap_LookupAtom("ignore"); TermIgnore = MkAtomTerm(AtomIgnore);
|
||||||
AtomInitGoal = Yap_FullLookupAtom("$init_goal");
|
AtomInf = Yap_LookupAtom("inf"); TermInf = MkAtomTerm(AtomInf);
|
||||||
AtomInitProlog = Yap_FullLookupAtom("$init_prolog");
|
AtomInfinity = Yap_LookupAtom("infinity"); TermInfinity = MkAtomTerm(AtomInfinity);
|
||||||
AtomInStackExpansion = Yap_LookupAtom("in stack expansion");
|
AtomInitGoal = Yap_FullLookupAtom("$init_goal"); TermInitGoal = MkAtomTerm(AtomInitGoal);
|
||||||
AtomInput = Yap_LookupAtom("input");
|
AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); TermInitProlog = MkAtomTerm(AtomInitProlog);
|
||||||
AtomInstantiationError = Yap_LookupAtom("instantiation_error");
|
AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion);
|
||||||
AtomInt = Yap_LookupAtom("int");
|
AtomInput = Yap_LookupAtom("input"); TermInput = MkAtomTerm(AtomInput);
|
||||||
AtomIntOverflow = Yap_LookupAtom("int_overflow");
|
AtomInstantiationError = Yap_LookupAtom("instantiation_error"); TermInstantiationError = MkAtomTerm(AtomInstantiationError);
|
||||||
AtomInteger = Yap_LookupAtom("integer");
|
AtomInt = Yap_LookupAtom("int"); TermInt = MkAtomTerm(AtomInt);
|
||||||
AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error");
|
AtomIntOverflow = Yap_LookupAtom("int_overflow"); TermIntOverflow = MkAtomTerm(AtomIntOverflow);
|
||||||
AtomIs = Yap_LookupAtom("is");
|
AtomInteger = Yap_LookupAtom("integer"); TermInteger = MkAtomTerm(AtomInteger);
|
||||||
AtomKey = Yap_LookupAtom("key");
|
AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError);
|
||||||
AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH");
|
AtomIs = Yap_LookupAtom("is"); TermIs = MkAtomTerm(AtomIs);
|
||||||
AtomLONGINT = Yap_LookupAtom("LongInt");
|
AtomKey = Yap_LookupAtom("key"); TermKey = MkAtomTerm(AtomKey);
|
||||||
AtomLOOP = Yap_LookupAtom("_LOOP_");
|
AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath);
|
||||||
AtomLoopStream = Yap_LookupAtom("loop_stream");
|
AtomLONGINT = Yap_LookupAtom("LongInt"); TermLONGINT = MkAtomTerm(AtomLONGINT);
|
||||||
AtomLT = Yap_LookupAtom("<");
|
AtomLOOP = Yap_LookupAtom("_LOOP_"); TermLOOP = MkAtomTerm(AtomLOOP);
|
||||||
AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within");
|
AtomLoopStream = Yap_LookupAtom("loop_stream"); TermLoopStream = MkAtomTerm(AtomLoopStream);
|
||||||
AtomLeash = Yap_FullLookupAtom("$leash");
|
AtomLT = Yap_LookupAtom("<"); TermLT = MkAtomTerm(AtomLT);
|
||||||
AtomLeast = Yap_LookupAtom("least");
|
AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin);
|
||||||
AtomLength = Yap_FullLookupAtom("length");
|
AtomLeash = Yap_FullLookupAtom("$leash"); TermLeash = MkAtomTerm(AtomLeash);
|
||||||
AtomList = Yap_LookupAtom("list");
|
AtomLeast = Yap_LookupAtom("least"); TermLeast = MkAtomTerm(AtomLeast);
|
||||||
AtomLine = Yap_LookupAtom("line");
|
AtomLength = Yap_FullLookupAtom("length"); TermLength = MkAtomTerm(AtomLength);
|
||||||
AtomLive = Yap_FullLookupAtom("$live");
|
AtomList = Yap_LookupAtom("list"); TermList = MkAtomTerm(AtomList);
|
||||||
AtomLoadAnswers = Yap_LookupAtom("load_answers");
|
AtomLine = Yap_LookupAtom("line"); TermLine = MkAtomTerm(AtomLine);
|
||||||
AtomLocal = Yap_LookupAtom("local");
|
AtomLive = Yap_FullLookupAtom("$live"); TermLive = MkAtomTerm(AtomLive);
|
||||||
AtomLocalSp = Yap_LookupAtom("local_sp");
|
AtomLoadAnswers = Yap_LookupAtom("load_answers"); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers);
|
||||||
AtomLocalTrie = Yap_LookupAtom("local_trie");
|
AtomLocal = Yap_LookupAtom("local"); TermLocal = MkAtomTerm(AtomLocal);
|
||||||
AtomMax = Yap_LookupAtom("max");
|
AtomLocalSp = Yap_LookupAtom("local_sp"); TermLocalSp = MkAtomTerm(AtomLocalSp);
|
||||||
AtomMaximum = Yap_LookupAtom("maximum");
|
AtomLocalTrie = Yap_LookupAtom("local_trie"); TermLocalTrie = MkAtomTerm(AtomLocalTrie);
|
||||||
AtomMaxArity = Yap_LookupAtom("max_arity");
|
AtomMax = Yap_LookupAtom("max"); TermMax = MkAtomTerm(AtomMax);
|
||||||
AtomMaxFiles = Yap_LookupAtom("max_files");
|
AtomMaximum = Yap_LookupAtom("maximum"); TermMaximum = MkAtomTerm(AtomMaximum);
|
||||||
AtomMegaClause = Yap_FullLookupAtom("$mega_clause");
|
AtomMaxArity = Yap_LookupAtom("max_arity"); TermMaxArity = MkAtomTerm(AtomMaxArity);
|
||||||
AtomMetaCall = Yap_FullLookupAtom("$call");
|
AtomMaxFiles = Yap_LookupAtom("max_files"); TermMaxFiles = MkAtomTerm(AtomMaxFiles);
|
||||||
AtomMfClause = Yap_FullLookupAtom("$mf_clause");
|
AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); TermMegaClause = MkAtomTerm(AtomMegaClause);
|
||||||
AtomMin = Yap_LookupAtom("min");
|
AtomMetaCall = Yap_FullLookupAtom("$call"); TermMetaCall = MkAtomTerm(AtomMetaCall);
|
||||||
AtomMinimum = Yap_LookupAtom("minimum");
|
AtomMfClause = Yap_FullLookupAtom("$mf_clause"); TermMfClause = MkAtomTerm(AtomMfClause);
|
||||||
AtomMinus = Yap_LookupAtom("-");
|
AtomMin = Yap_LookupAtom("min"); TermMin = MkAtomTerm(AtomMin);
|
||||||
AtomModify = Yap_LookupAtom("modify");
|
AtomMinimum = Yap_LookupAtom("minimum"); TermMinimum = MkAtomTerm(AtomMinimum);
|
||||||
AtomModule = Yap_LookupAtom("module");
|
AtomMinus = Yap_LookupAtom("-"); TermMinus = MkAtomTerm(AtomMinus);
|
||||||
AtomMost = Yap_LookupAtom("most");
|
AtomModify = Yap_LookupAtom("modify"); TermModify = MkAtomTerm(AtomModify);
|
||||||
AtomMulti = Yap_LookupAtom("multi");
|
AtomModule = Yap_LookupAtom("module"); TermModule = MkAtomTerm(AtomModule);
|
||||||
AtomMultiFile = Yap_FullLookupAtom("$mf");
|
AtomMost = Yap_LookupAtom("most"); TermMost = MkAtomTerm(AtomMost);
|
||||||
AtomMultiple = Yap_FullLookupAtom("multiple");
|
AtomMulti = Yap_LookupAtom("multi"); TermMulti = MkAtomTerm(AtomMulti);
|
||||||
AtomMutable = Yap_LookupAtom("mutable");
|
AtomMultiFile = Yap_FullLookupAtom("$mf"); TermMultiFile = MkAtomTerm(AtomMultiFile);
|
||||||
AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable");
|
AtomMultiple = Yap_FullLookupAtom("multiple"); TermMultiple = MkAtomTerm(AtomMultiple);
|
||||||
AtomMutex = Yap_LookupAtom("mutex");
|
AtomMutable = Yap_LookupAtom("mutable"); TermMutable = MkAtomTerm(AtomMutable);
|
||||||
AtomMyddasDB = Yap_FullLookupAtom("$myddas_db");
|
AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); TermMutableVariable = MkAtomTerm(AtomMutableVariable);
|
||||||
AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal");
|
AtomMutex = Yap_LookupAtom("mutex"); TermMutex = MkAtomTerm(AtomMutex);
|
||||||
AtomMyddasHost = Yap_FullLookupAtom("$myddas_host");
|
AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); TermMyddasDB = MkAtomTerm(AtomMyddasDB);
|
||||||
AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass");
|
AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal);
|
||||||
AtomMyddasUser = Yap_FullLookupAtom("$myddas_user");
|
AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); TermMyddasHost = MkAtomTerm(AtomMyddasHost);
|
||||||
AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name");
|
AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); TermMyddasPass = MkAtomTerm(AtomMyddasPass);
|
||||||
AtomNan = Yap_LookupAtom("nan");
|
AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); TermMyddasUser = MkAtomTerm(AtomMyddasUser);
|
||||||
AtomNb = Yap_LookupAtom("nb");
|
AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName);
|
||||||
AtomNbTerm = Yap_LookupAtom("nb_term");
|
AtomNan = Yap_LookupAtom("nan"); TermNan = MkAtomTerm(AtomNan);
|
||||||
AtomNew = Yap_LookupAtom("new");
|
AtomNb = Yap_LookupAtom("nb"); TermNb = MkAtomTerm(AtomNb);
|
||||||
AtomNewLine = Yap_LookupAtom("nl");
|
AtomNbTerm = Yap_LookupAtom("nb_term"); TermNbTerm = MkAtomTerm(AtomNbTerm);
|
||||||
AtomNl = Yap_LookupAtom("nl");
|
AtomNew = Yap_LookupAtom("new"); TermNew = MkAtomTerm(AtomNew);
|
||||||
AtomNoEffect = Yap_LookupAtom("no_effect");
|
AtomNewLine = Yap_LookupAtom("nl"); TermNewLine = MkAtomTerm(AtomNewLine);
|
||||||
AtomNoMemory = Yap_LookupAtom("no_memory");
|
AtomNl = Yap_LookupAtom("nl"); TermNl = MkAtomTerm(AtomNl);
|
||||||
AtomNone = Yap_LookupAtom("none");
|
AtomNoEffect = Yap_LookupAtom("no_effect"); TermNoEffect = MkAtomTerm(AtomNoEffect);
|
||||||
AtomNonEmptyList = Yap_LookupAtom("non_empty_list");
|
AtomNoMemory = Yap_LookupAtom("no_memory"); TermNoMemory = MkAtomTerm(AtomNoMemory);
|
||||||
AtomNot = Yap_LookupAtom("\\+");
|
AtomNone = Yap_LookupAtom("none"); TermNone = MkAtomTerm(AtomNone);
|
||||||
AtomNotImplemented = Yap_LookupAtom("not_implemented");
|
AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList);
|
||||||
AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero");
|
AtomNot = Yap_LookupAtom("\\+"); TermNot = MkAtomTerm(AtomNot);
|
||||||
AtomNotNewline = Yap_LookupAtom("not_newline");
|
AtomNotImplemented = Yap_LookupAtom("not_implemented"); TermNotImplemented = MkAtomTerm(AtomNotImplemented);
|
||||||
AtomNotZero = Yap_LookupAtom("not_zero");
|
AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero);
|
||||||
AtomNumber = Yap_LookupAtom("number");
|
AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline);
|
||||||
AtomOff = Yap_LookupAtom("off");
|
AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero);
|
||||||
AtomOffline = Yap_LookupAtom("offline");
|
AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber);
|
||||||
AtomOn = Yap_LookupAtom("on");
|
AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff);
|
||||||
AtomOnline = Yap_LookupAtom("online");
|
AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline);
|
||||||
AtomOpen = Yap_LookupAtom("open");
|
AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn);
|
||||||
AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL");
|
AtomOnline = Yap_LookupAtom("online"); TermOnline = MkAtomTerm(AtomOnline);
|
||||||
AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support");
|
AtomOpen = Yap_LookupAtom("open"); TermOpen = MkAtomTerm(AtomOpen);
|
||||||
AtomOperator = Yap_LookupAtom("operator");
|
AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError);
|
||||||
AtomOperatorPriority = Yap_LookupAtom("operator_priority");
|
AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport);
|
||||||
AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier");
|
AtomOperator = Yap_LookupAtom("operator"); TermOperator = MkAtomTerm(AtomOperator);
|
||||||
AtomOpt = Yap_LookupAtom("opt");
|
AtomOperatorPriority = Yap_LookupAtom("operator_priority"); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority);
|
||||||
AtomOtherwise = Yap_LookupAtom("otherwise");
|
AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier);
|
||||||
AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error");
|
AtomOpt = Yap_LookupAtom("opt"); TermOpt = MkAtomTerm(AtomOpt);
|
||||||
AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error");
|
AtomOtherwise = Yap_LookupAtom("otherwise"); TermOtherwise = MkAtomTerm(AtomOtherwise);
|
||||||
AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error");
|
AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError);
|
||||||
AtomOutOfRange = Yap_LookupAtom("out_of_range");
|
AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError);
|
||||||
AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error");
|
AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError);
|
||||||
AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error");
|
AtomOutOfRange = Yap_LookupAtom("out_of_range"); TermOutOfRange = MkAtomTerm(AtomOutOfRange);
|
||||||
AtomOutput = Yap_LookupAtom("output");
|
AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError);
|
||||||
AtomParameter = Yap_LookupAtom("parameter");
|
AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError);
|
||||||
AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory");
|
AtomOutput = Yap_LookupAtom("output"); TermOutput = MkAtomTerm(AtomOutput);
|
||||||
AtomPast = Yap_LookupAtom("past");
|
AtomParameter = Yap_LookupAtom("parameter"); TermParameter = MkAtomTerm(AtomParameter);
|
||||||
AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream");
|
AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir);
|
||||||
AtomPermissionError = Yap_LookupAtom("permission_error");
|
AtomPast = Yap_LookupAtom("past"); TermPast = MkAtomTerm(AtomPast);
|
||||||
AtomPi = Yap_LookupAtom("pi");
|
AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream);
|
||||||
AtomPipe = Yap_LookupAtom("pipe");
|
AtomPermissionError = Yap_LookupAtom("permission_error"); TermPermissionError = MkAtomTerm(AtomPermissionError);
|
||||||
AtomPlus = Yap_LookupAtom("+");
|
AtomPi = Yap_LookupAtom("pi"); TermPi = MkAtomTerm(AtomPi);
|
||||||
AtomPointer = Yap_LookupAtom("pointer");
|
AtomPipe = Yap_LookupAtom("pipe"); TermPipe = MkAtomTerm(AtomPipe);
|
||||||
AtomPortray = Yap_FullLookupAtom("portray");
|
AtomPlus = Yap_LookupAtom("+"); TermPlus = MkAtomTerm(AtomPlus);
|
||||||
AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator");
|
AtomPointer = Yap_LookupAtom("pointer"); TermPointer = MkAtomTerm(AtomPointer);
|
||||||
AtomPrimitive = Yap_LookupAtom("primitive");
|
AtomPortray = Yap_FullLookupAtom("portray"); TermPortray = MkAtomTerm(AtomPortray);
|
||||||
AtomPrintMessage = Yap_LookupAtom("print_message");
|
AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator);
|
||||||
AtomPrivateProcedure = Yap_LookupAtom("private_procedure");
|
AtomPrimitive = Yap_LookupAtom("primitive"); TermPrimitive = MkAtomTerm(AtomPrimitive);
|
||||||
AtomProcedure = Yap_LookupAtom("procedure");
|
AtomPrintMessage = Yap_LookupAtom("print_message"); TermPrintMessage = MkAtomTerm(AtomPrintMessage);
|
||||||
AtomProfile = Yap_FullLookupAtom("$profile");
|
AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure);
|
||||||
AtomProlog = Yap_LookupAtom("prolog");
|
AtomProcedure = Yap_LookupAtom("procedure"); TermProcedure = MkAtomTerm(AtomProcedure);
|
||||||
AtomQly = Yap_LookupAtom("qly");
|
AtomProfile = Yap_FullLookupAtom("$profile"); TermProfile = MkAtomTerm(AtomProfile);
|
||||||
AtomQuery = Yap_LookupAtom("?-");
|
AtomProlog = Yap_LookupAtom("prolog"); TermProlog = MkAtomTerm(AtomProlog);
|
||||||
AtomQueue = Yap_LookupAtom("queue");
|
AtomProtectStack = Yap_FullLookupAtom("$protect_stack"); TermProtectStack = MkAtomTerm(AtomProtectStack);
|
||||||
AtomQuiet = Yap_LookupAtom("quiet");
|
AtomQly = Yap_LookupAtom("qly"); TermQly = MkAtomTerm(AtomQly);
|
||||||
AtomRadix = Yap_LookupAtom("radix");
|
AtomQuery = Yap_LookupAtom("?-"); TermQuery = MkAtomTerm(AtomQuery);
|
||||||
AtomRandom = Yap_LookupAtom("random");
|
AtomQueue = Yap_LookupAtom("queue"); TermQueue = MkAtomTerm(AtomQueue);
|
||||||
AtomRange = Yap_LookupAtom("range");
|
AtomQuiet = Yap_LookupAtom("quiet"); TermQuiet = MkAtomTerm(AtomQuiet);
|
||||||
AtomRDiv = Yap_LookupAtom("rdiv");
|
AtomRadix = Yap_LookupAtom("radix"); TermRadix = MkAtomTerm(AtomRadix);
|
||||||
AtomRead = Yap_LookupAtom("read");
|
AtomRandom = Yap_LookupAtom("random"); TermRandom = MkAtomTerm(AtomRandom);
|
||||||
AtomReadOnly = Yap_LookupAtom("read_only");
|
AtomRange = Yap_LookupAtom("range"); TermRange = MkAtomTerm(AtomRange);
|
||||||
AtomReadWrite = Yap_LookupAtom("read_write");
|
AtomRDiv = Yap_LookupAtom("rdiv"); TermRDiv = MkAtomTerm(AtomRDiv);
|
||||||
AtomReadutil = Yap_LookupAtom("readutil");
|
AtomRead = Yap_LookupAtom("read"); TermRead = MkAtomTerm(AtomRead);
|
||||||
AtomReconsult = Yap_LookupAtom("reconsult");
|
AtomReadOnly = Yap_LookupAtom("read_only"); TermReadOnly = MkAtomTerm(AtomReadOnly);
|
||||||
AtomRecordedP = Yap_FullLookupAtom("$recordep");
|
AtomReadWrite = Yap_LookupAtom("read_write"); TermReadWrite = MkAtomTerm(AtomReadWrite);
|
||||||
AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key");
|
AtomReadutil = Yap_LookupAtom("readutil"); TermReadutil = MkAtomTerm(AtomReadutil);
|
||||||
AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings");
|
AtomReconsult = Yap_LookupAtom("reconsult"); TermReconsult = MkAtomTerm(AtomReconsult);
|
||||||
AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze");
|
AtomRecordedP = Yap_FullLookupAtom("$recordep"); TermRecordedP = MkAtomTerm(AtomRecordedP);
|
||||||
AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN");
|
AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey);
|
||||||
AtomRelativeTo = Yap_FullLookupAtom("relative_to");
|
AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings);
|
||||||
AtomRepeat = Yap_LookupAtom("repeat");
|
AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze);
|
||||||
AtomRepeatSpace = Yap_LookupAtom("repeat ");
|
AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); TermRefoundVar = MkAtomTerm(AtomRefoundVar);
|
||||||
AtomReposition = Yap_LookupAtom("reposition");
|
AtomRelativeTo = Yap_FullLookupAtom("relative_to"); TermRelativeTo = MkAtomTerm(AtomRelativeTo);
|
||||||
AtomRepresentationError = Yap_LookupAtom("representation_error");
|
AtomRepeat = Yap_LookupAtom("repeat"); TermRepeat = MkAtomTerm(AtomRepeat);
|
||||||
AtomReset = Yap_LookupAtom("reset");
|
AtomRepeatSpace = Yap_LookupAtom("repeat "); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace);
|
||||||
AtomResize = Yap_LookupAtom("resize");
|
AtomReposition = Yap_LookupAtom("reposition"); TermReposition = MkAtomTerm(AtomReposition);
|
||||||
AtomResourceError = Yap_LookupAtom("resource_error");
|
AtomRepresentationError = Yap_LookupAtom("representation_error"); TermRepresentationError = MkAtomTerm(AtomRepresentationError);
|
||||||
AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs");
|
AtomReset = Yap_LookupAtom("reset"); TermReset = MkAtomTerm(AtomReset);
|
||||||
AtomRetryCounter = Yap_LookupAtom("retry_counter");
|
AtomResize = Yap_LookupAtom("resize"); TermResize = MkAtomTerm(AtomResize);
|
||||||
AtomRTree = Yap_LookupAtom("rtree");
|
AtomResourceError = Yap_LookupAtom("resource_error"); TermResourceError = MkAtomTerm(AtomResourceError);
|
||||||
AtomSafe = Yap_FullLookupAtom("$safe");
|
AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs);
|
||||||
AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup");
|
AtomRetryCounter = Yap_LookupAtom("retry_counter"); TermRetryCounter = MkAtomTerm(AtomRetryCounter);
|
||||||
AtomSame = Yap_LookupAtom("==");
|
AtomRTree = Yap_LookupAtom("rtree"); TermRTree = MkAtomTerm(AtomRTree);
|
||||||
AtomSemic = Yap_LookupAtom(";");
|
AtomSafe = Yap_FullLookupAtom("$safe"); TermSafe = MkAtomTerm(AtomSafe);
|
||||||
AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow");
|
AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup);
|
||||||
AtomSigAlarm = Yap_LookupAtom("sig_alarm");
|
AtomSame = Yap_LookupAtom("=="); TermSame = MkAtomTerm(AtomSame);
|
||||||
AtomSigBreak = Yap_LookupAtom("sig_break");
|
AtomSemic = Yap_LookupAtom(";"); TermSemic = MkAtomTerm(AtomSemic);
|
||||||
AtomSigCreep = Yap_LookupAtom("sig_creep");
|
AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow);
|
||||||
AtomSigDebug = Yap_LookupAtom("sig_debug");
|
AtomSigAlarm = Yap_LookupAtom("sig_alarm"); TermSigAlarm = MkAtomTerm(AtomSigAlarm);
|
||||||
AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep");
|
AtomSigBreak = Yap_LookupAtom("sig_break"); TermSigBreak = MkAtomTerm(AtomSigBreak);
|
||||||
AtomSigFPE = Yap_LookupAtom("sig_fpe");
|
AtomSigCreep = Yap_LookupAtom("sig_creep"); TermSigCreep = MkAtomTerm(AtomSigCreep);
|
||||||
AtomSigHup = Yap_LookupAtom("sig_hup");
|
AtomSigDebug = Yap_LookupAtom("sig_debug"); TermSigDebug = MkAtomTerm(AtomSigDebug);
|
||||||
AtomSigInt = Yap_LookupAtom("sig_int");
|
AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep);
|
||||||
AtomSigIti = Yap_LookupAtom("sig_iti");
|
AtomSigFPE = Yap_LookupAtom("sig_fpe"); TermSigFPE = MkAtomTerm(AtomSigFPE);
|
||||||
AtomSigPending = Yap_FullLookupAtom("$sig_pending");
|
AtomSigHup = Yap_LookupAtom("sig_hup"); TermSigHup = MkAtomTerm(AtomSigHup);
|
||||||
AtomSigPipe = Yap_LookupAtom("sig_pipe");
|
AtomSigInt = Yap_LookupAtom("sig_int"); TermSigInt = MkAtomTerm(AtomSigInt);
|
||||||
AtomSigStackDump = Yap_LookupAtom("sig_stack_dump");
|
AtomSigIti = Yap_LookupAtom("sig_iti"); TermSigIti = MkAtomTerm(AtomSigIti);
|
||||||
AtomSigStatistics = Yap_LookupAtom("sig_statistics");
|
AtomSigPending = Yap_FullLookupAtom("$sig_pending"); TermSigPending = MkAtomTerm(AtomSigPending);
|
||||||
AtomSigTrace = Yap_LookupAtom("sig_trace");
|
AtomSigPipe = Yap_LookupAtom("sig_pipe"); TermSigPipe = MkAtomTerm(AtomSigPipe);
|
||||||
AtomSigUsr1 = Yap_LookupAtom("sig_usr1");
|
AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); TermSigStackDump = MkAtomTerm(AtomSigStackDump);
|
||||||
AtomSigUsr2 = Yap_LookupAtom("sig_usr2");
|
AtomSigStatistics = Yap_LookupAtom("sig_statistics"); TermSigStatistics = MkAtomTerm(AtomSigStatistics);
|
||||||
AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm");
|
AtomSigTrace = Yap_LookupAtom("sig_trace"); TermSigTrace = MkAtomTerm(AtomSigTrace);
|
||||||
AtomSigWakeUp = Yap_LookupAtom("sig_wake_up");
|
AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); TermSigUsr1 = MkAtomTerm(AtomSigUsr1);
|
||||||
AtomSilent = Yap_LookupAtom("Silent");
|
AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); TermSigUsr2 = MkAtomTerm(AtomSigUsr2);
|
||||||
AtomSingle = Yap_LookupAtom("single");
|
AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm);
|
||||||
AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings");
|
AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp);
|
||||||
AtomSingleton = Yap_LookupAtom("singleton");
|
AtomSilent = Yap_LookupAtom("Silent"); TermSilent = MkAtomTerm(AtomSilent);
|
||||||
AtomSlash = Yap_LookupAtom("/");
|
AtomSingle = Yap_LookupAtom("single"); TermSingle = MkAtomTerm(AtomSingle);
|
||||||
AtomSocket = Yap_LookupAtom("socket");
|
AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings);
|
||||||
AtomSolutions = Yap_LookupAtom("solutions");
|
AtomSingleton = Yap_LookupAtom("singleton"); TermSingleton = MkAtomTerm(AtomSingleton);
|
||||||
AtomSource = Yap_LookupAtom("source");
|
AtomSlash = Yap_LookupAtom("/"); TermSlash = MkAtomTerm(AtomSlash);
|
||||||
AtomSourceSink = Yap_LookupAtom("source_sink");
|
AtomSocket = Yap_LookupAtom("socket"); TermSocket = MkAtomTerm(AtomSocket);
|
||||||
AtomSpy = Yap_FullLookupAtom("$spy");
|
AtomSolutions = Yap_LookupAtom("solutions"); TermSolutions = MkAtomTerm(AtomSolutions);
|
||||||
AtomStack = Yap_LookupAtom("stack");
|
AtomSource = Yap_LookupAtom("source"); TermSource = MkAtomTerm(AtomSource);
|
||||||
AtomStackFree = Yap_LookupAtom("stackfree");
|
AtomSourceSink = Yap_LookupAtom("source_sink"); TermSourceSink = MkAtomTerm(AtomSourceSink);
|
||||||
AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state");
|
AtomSpy = Yap_FullLookupAtom("$spy"); TermSpy = MkAtomTerm(AtomSpy);
|
||||||
AtomStaticClause = Yap_FullLookupAtom("$static_clause");
|
AtomStack = Yap_LookupAtom("stack"); TermStack = MkAtomTerm(AtomStack);
|
||||||
AtomStaticProcedure = Yap_LookupAtom("static_procedure");
|
AtomStackFree = Yap_LookupAtom("stackfree"); TermStackFree = MkAtomTerm(AtomStackFree);
|
||||||
AtomStream = Yap_FullLookupAtom("$stream");
|
AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState);
|
||||||
AtomSWIStream = Yap_FullLookupAtom("<stream>");
|
AtomStaticClause = Yap_FullLookupAtom("$static_clause"); TermStaticClause = MkAtomTerm(AtomStaticClause);
|
||||||
AtomVStream = Yap_LookupAtom("stream");
|
AtomStaticProcedure = Yap_LookupAtom("static_procedure"); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure);
|
||||||
AtomStreams = Yap_LookupAtom("streams");
|
AtomStream = Yap_FullLookupAtom("$stream"); TermStream = MkAtomTerm(AtomStream);
|
||||||
AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias");
|
AtomSWIStream = Yap_FullLookupAtom("<stream>"); TermSWIStream = MkAtomTerm(AtomSWIStream);
|
||||||
AtomStreamPos = Yap_FullLookupAtom("$stream_position");
|
AtomVStream = Yap_LookupAtom("stream"); TermVStream = MkAtomTerm(AtomVStream);
|
||||||
AtomStreamPosition = Yap_LookupAtom("stream_position");
|
AtomStreams = Yap_LookupAtom("streams"); TermStreams = MkAtomTerm(AtomStreams);
|
||||||
AtomString = Yap_LookupAtom("string");
|
AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias);
|
||||||
AtomStyleCheck = Yap_LookupAtom("style_check");
|
AtomStreamPos = Yap_FullLookupAtom("$stream_position"); TermStreamPos = MkAtomTerm(AtomStreamPos);
|
||||||
AtomSTRING = Yap_FullLookupAtom("String");
|
AtomStreamPosition = Yap_LookupAtom("stream_position"); TermStreamPosition = MkAtomTerm(AtomStreamPosition);
|
||||||
AtomSwi = Yap_LookupAtom("swi");
|
AtomString = Yap_LookupAtom("string"); TermString = MkAtomTerm(AtomString);
|
||||||
AtomSymbolChar = Yap_LookupAtom("symbol_char");
|
AtomStyleCheck = Yap_LookupAtom("style_check"); TermStyleCheck = MkAtomTerm(AtomStyleCheck);
|
||||||
AtomSyntaxError = Yap_LookupAtom("syntax_error");
|
AtomSTRING = Yap_FullLookupAtom("String"); TermSTRING = MkAtomTerm(AtomSTRING);
|
||||||
AtomSyntaxErrors = Yap_LookupAtom("syntax_errors");
|
AtomSwi = Yap_LookupAtom("swi"); TermSwi = MkAtomTerm(AtomSwi);
|
||||||
AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler");
|
AtomSymbolChar = Yap_LookupAtom("symbol_char"); TermSymbolChar = MkAtomTerm(AtomSymbolChar);
|
||||||
AtomSystem = Yap_LookupAtom("system");
|
AtomSyntaxError = Yap_LookupAtom("syntax_error"); TermSyntaxError = MkAtomTerm(AtomSyntaxError);
|
||||||
AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL");
|
AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors);
|
||||||
AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory");
|
AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler);
|
||||||
AtomTerm = Yap_LookupAtom("term");
|
AtomSystem = Yap_LookupAtom("system"); TermSystem = MkAtomTerm(AtomSystem);
|
||||||
AtomTerms = Yap_LookupAtom("terms");
|
AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); TermSystemError = MkAtomTerm(AtomSystemError);
|
||||||
AtomTermExpansion = Yap_LookupAtom("term_expansion");
|
AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir);
|
||||||
AtomText = Yap_LookupAtom("text");
|
AtomTerm = Yap_LookupAtom("term"); TermTerm = MkAtomTerm(AtomTerm);
|
||||||
AtomTextStream = Yap_LookupAtom("text_stream");
|
AtomTerms = Yap_LookupAtom("terms"); TermTerms = MkAtomTerm(AtomTerms);
|
||||||
AtomThread = Yap_LookupAtom("thread");
|
AtomTermExpansion = Yap_LookupAtom("term_expansion"); TermTermExpansion = MkAtomTerm(AtomTermExpansion);
|
||||||
AtomThreads = Yap_LookupAtom("threads");
|
AtomText = Yap_LookupAtom("text"); TermText = MkAtomTerm(AtomText);
|
||||||
AtomThrow = Yap_LookupAtom("throw");
|
AtomTextStream = Yap_LookupAtom("text_stream"); TermTextStream = MkAtomTerm(AtomTextStream);
|
||||||
AtomTimeOutSpec = Yap_LookupAtom("time_out_spec");
|
AtomThread = Yap_LookupAtom("thread"); TermThread = MkAtomTerm(AtomThread);
|
||||||
AtomTimeoutError = Yap_LookupAtom("timeout_error");
|
AtomThreads = Yap_LookupAtom("threads"); TermThreads = MkAtomTerm(AtomThreads);
|
||||||
AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal");
|
AtomThrow = Yap_LookupAtom("throw"); TermThrow = MkAtomTerm(AtomThrow);
|
||||||
AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal");
|
AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec);
|
||||||
AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call");
|
AtomTimeoutError = Yap_LookupAtom("timeout_error"); TermTimeoutError = MkAtomTerm(AtomTimeoutError);
|
||||||
|
AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal);
|
||||||
|
AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal);
|
||||||
|
AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall);
|
||||||
AtomTrail = Yap_LookupAtom("trail");
|
AtomTrail = Yap_LookupAtom("trail");
|
||||||
AtomTrue = Yap_LookupAtom("true");
|
AtomTrue = Yap_LookupAtom("true"); TermTrue = MkAtomTerm(AtomTrue);
|
||||||
AtomTty = Yap_LookupAtom("tty");
|
AtomTty = Yap_LookupAtom("tty"); TermTty = MkAtomTerm(AtomTty);
|
||||||
AtomTtys = Yap_LookupAtom("ttys");
|
AtomTtys = Yap_LookupAtom("ttys"); TermTtys = MkAtomTerm(AtomTtys);
|
||||||
AtomTxt = Yap_LookupAtom("txt");
|
AtomTxt = Yap_LookupAtom("txt"); TermTxt = MkAtomTerm(AtomTxt);
|
||||||
AtomTypeError = Yap_LookupAtom("type_error");
|
AtomTypeError = Yap_LookupAtom("type_error"); TermTypeError = MkAtomTerm(AtomTypeError);
|
||||||
AtomUndefined = Yap_LookupAtom("undefined");
|
AtomUndefined = Yap_LookupAtom("undefined"); TermUndefined = MkAtomTerm(AtomUndefined);
|
||||||
AtomUndefp = Yap_FullLookupAtom("$undefp");
|
AtomUndefp = Yap_FullLookupAtom("$undefp"); TermUndefp = MkAtomTerm(AtomUndefp);
|
||||||
AtomUnderflow = Yap_LookupAtom("underflow");
|
AtomUnderflow = Yap_LookupAtom("underflow"); TermUnderflow = MkAtomTerm(AtomUnderflow);
|
||||||
AtomUnificationStack = Yap_LookupAtom("unification_stack");
|
AtomUnificationStack = Yap_LookupAtom("unification_stack"); TermUnificationStack = MkAtomTerm(AtomUnificationStack);
|
||||||
AtomUnique = Yap_LookupAtom("unique");
|
AtomUnique = Yap_LookupAtom("unique"); TermUnique = MkAtomTerm(AtomUnique);
|
||||||
AtomUnsignedByte = Yap_LookupAtom("unsigned_byte");
|
AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte);
|
||||||
AtomUnsignedChar = Yap_LookupAtom("unsigned_char");
|
AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar);
|
||||||
AtomUser = Yap_LookupAtom("user");
|
AtomUser = Yap_LookupAtom("user"); TermUser = MkAtomTerm(AtomUser);
|
||||||
AtomUserErr = Yap_LookupAtom("user_error");
|
AtomUserErr = Yap_LookupAtom("user_error"); TermUserErr = MkAtomTerm(AtomUserErr);
|
||||||
AtomUserIn = Yap_LookupAtom("user_input");
|
AtomUserIn = Yap_LookupAtom("user_input"); TermUserIn = MkAtomTerm(AtomUserIn);
|
||||||
AtomUserOut = Yap_LookupAtom("user_output");
|
AtomUserOut = Yap_LookupAtom("user_output"); TermUserOut = MkAtomTerm(AtomUserOut);
|
||||||
AtomDollarVar = Yap_LookupAtom("$VAR");
|
AtomDollarVar = Yap_LookupAtom("$VAR"); TermDollarVar = MkAtomTerm(AtomDollarVar);
|
||||||
AtomVBar = Yap_LookupAtom("|");
|
AtomVBar = Yap_LookupAtom("|"); TermVBar = MkAtomTerm(AtomVBar);
|
||||||
AtomVarBranches = Yap_LookupAtom("var_branches");
|
AtomVarBranches = Yap_LookupAtom("var_branches"); TermVarBranches = MkAtomTerm(AtomVarBranches);
|
||||||
AtomVariableNames = Yap_LookupAtom("variable_names");
|
AtomVariableNames = Yap_LookupAtom("variable_names"); TermVariableNames = MkAtomTerm(AtomVariableNames);
|
||||||
AtomHiddenVar = Yap_FullLookupAtom("$V");
|
AtomHiddenVar = Yap_FullLookupAtom("$V"); TermHiddenVar = MkAtomTerm(AtomHiddenVar);
|
||||||
AtomVariable = Yap_LookupAtom("variable");
|
AtomVariable = Yap_LookupAtom("variable"); TermVariable = MkAtomTerm(AtomVariable);
|
||||||
AtomVerbose = Yap_LookupAtom("verbose");
|
AtomVerbose = Yap_LookupAtom("verbose"); TermVerbose = MkAtomTerm(AtomVerbose);
|
||||||
AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search");
|
AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch);
|
||||||
AtomVersionNumber = Yap_FullLookupAtom("$version_name");
|
AtomVersionNumber = Yap_FullLookupAtom("$version_name"); TermVersionNumber = MkAtomTerm(AtomVersionNumber);
|
||||||
AtomVeryVerbose = Yap_LookupAtom("very_verbose");
|
AtomVeryVerbose = Yap_LookupAtom("very_verbose"); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose);
|
||||||
AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal");
|
AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal);
|
||||||
AtomWarning = Yap_LookupAtom("warning");
|
AtomWarning = Yap_LookupAtom("warning"); TermWarning = MkAtomTerm(AtomWarning);
|
||||||
AtomWhen = Yap_FullLookupAtom("$when");
|
AtomWhen = Yap_FullLookupAtom("$when"); TermWhen = MkAtomTerm(AtomWhen);
|
||||||
AtomWrite = Yap_LookupAtom("write");
|
AtomWrite = Yap_LookupAtom("write"); TermWrite = MkAtomTerm(AtomWrite);
|
||||||
AtomXml = Yap_LookupAtom("xml");
|
AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml);
|
||||||
AtomYapHacks = Yap_LookupAtom("yap_hacks");
|
AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks);
|
||||||
AtomZeroDivisor = Yap_LookupAtom("zero_divisor");
|
AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor);
|
||||||
FunctorAfInet = Yap_MkFunctor(AtomAfInet,2);
|
FunctorAfInet = Yap_MkFunctor(AtomAfInet,2);
|
||||||
FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1);
|
FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1);
|
||||||
FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1);
|
FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1);
|
||||||
@ -474,6 +477,7 @@
|
|||||||
FunctorEq = Yap_MkFunctor(AtomEq,2);
|
FunctorEq = Yap_MkFunctor(AtomEq,2);
|
||||||
FunctorError = Yap_MkFunctor(AtomError,2);
|
FunctorError = Yap_MkFunctor(AtomError,2);
|
||||||
FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);
|
FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);
|
||||||
|
FunctorException = Yap_MkFunctor(AtomException,1);
|
||||||
FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2);
|
FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2);
|
||||||
FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2);
|
FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2);
|
||||||
FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1);
|
FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1);
|
||||||
@ -516,6 +520,7 @@
|
|||||||
FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2);
|
FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2);
|
||||||
FunctorProcedure = Yap_MkFunctor(AtomProcedure,5);
|
FunctorProcedure = Yap_MkFunctor(AtomProcedure,5);
|
||||||
FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2);
|
FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2);
|
||||||
|
FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,1);
|
||||||
FunctorQuery = Yap_MkFunctor(AtomQuery,1);
|
FunctorQuery = Yap_MkFunctor(AtomQuery,1);
|
||||||
FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6);
|
FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6);
|
||||||
FunctorRDiv = Yap_MkFunctor(AtomRDiv,2);
|
FunctorRDiv = Yap_MkFunctor(AtomRDiv,2);
|
||||||
|
|||||||
@ -87,6 +87,7 @@
|
|||||||
#ifdef EUROTRA
|
#ifdef EUROTRA
|
||||||
TermDollarU = MkAtomTerm(AtomDollarU);
|
TermDollarU = MkAtomTerm(AtomDollarU);
|
||||||
#endif
|
#endif
|
||||||
|
TermAnswer = MkAtomTerm(AtomAnswer);
|
||||||
|
|
||||||
USER_MODULE = MkAtomTerm(AtomUser);
|
USER_MODULE = MkAtomTerm(AtomUser);
|
||||||
IDB_MODULE = MkAtomTerm(AtomIDB);
|
IDB_MODULE = MkAtomTerm(AtomIDB);
|
||||||
@ -135,24 +136,25 @@
|
|||||||
#ifdef COROUTINING
|
#ifdef COROUTINING
|
||||||
WakeUpCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomWakeUpGoal,2),PROLOG_MODULE));
|
WakeUpCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomWakeUpGoal,2),PROLOG_MODULE));
|
||||||
#endif
|
#endif
|
||||||
PredGoalExpansion = RepPredProp(PredPropByFunc(FunctorGoalExpansion,USER_MODULE));
|
|
||||||
PredMetaCall = RepPredProp(PredPropByFunc(FunctorMetaCall,PROLOG_MODULE));
|
|
||||||
PredTraceMetaCall = RepPredProp(PredPropByFunc(FunctorTraceMetaCall,PROLOG_MODULE));
|
|
||||||
PredDollarCatch = RepPredProp(PredPropByFunc(FunctorCatch,PROLOG_MODULE));
|
PredDollarCatch = RepPredProp(PredPropByFunc(FunctorCatch,PROLOG_MODULE));
|
||||||
PredRecordedWithKey = RepPredProp(PredPropByFunc(FunctorRecordedWithKey,PROLOG_MODULE));
|
|
||||||
PredLogUpdClause = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE));
|
|
||||||
PredLogUpdClauseErase = RepPredProp(PredPropByFunc(FunctorDoLogUpdClauseErase,PROLOG_MODULE));
|
|
||||||
PredLogUpdClause0 = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE));
|
|
||||||
PredStaticClause = RepPredProp(PredPropByFunc(FunctorDoStaticClause,PROLOG_MODULE));
|
|
||||||
PredThrow = RepPredProp(PredPropByFunc(FunctorThrow,PROLOG_MODULE));
|
|
||||||
PredHandleThrow = RepPredProp(PredPropByFunc(FunctorHandleThrow,PROLOG_MODULE));
|
|
||||||
PredIs = RepPredProp(PredPropByFunc(FunctorIs,PROLOG_MODULE));
|
|
||||||
PredSafeCallCleanup = RepPredProp(PredPropByFunc(FunctorSafeCallCleanup,PROLOG_MODULE));
|
|
||||||
PredRestoreRegs = RepPredProp(PredPropByFunc(FunctorRestoreRegs,PROLOG_MODULE));
|
|
||||||
PredCommentHook = RepPredProp(PredPropByFunc(FunctorCommentHook,PROLOG_MODULE));
|
|
||||||
#ifdef YAPOR
|
#ifdef YAPOR
|
||||||
PredGetwork = RepPredProp(PredPropByAtom(AtomGetwork,PROLOG_MODULE));
|
PredGetwork = RepPredProp(PredPropByAtom(AtomGetwork,PROLOG_MODULE));
|
||||||
#endif /* YAPOR */
|
#endif /* YAPOR */
|
||||||
|
PredGoalExpansion = RepPredProp(PredPropByFunc(FunctorGoalExpansion,USER_MODULE));
|
||||||
|
PredHandleThrow = RepPredProp(PredPropByFunc(FunctorHandleThrow,PROLOG_MODULE));
|
||||||
|
PredIs = RepPredProp(PredPropByFunc(FunctorIs,PROLOG_MODULE));
|
||||||
|
PredLogUpdClause = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE));
|
||||||
|
PredLogUpdClauseErase = RepPredProp(PredPropByFunc(FunctorDoLogUpdClauseErase,PROLOG_MODULE));
|
||||||
|
PredLogUpdClause0 = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE));
|
||||||
|
PredMetaCall = RepPredProp(PredPropByFunc(FunctorMetaCall,PROLOG_MODULE));
|
||||||
|
PredProtectStack = RepPredProp(PredPropByFunc(FunctorProtectStack,PROLOG_MODULE));
|
||||||
|
PredRecordedWithKey = RepPredProp(PredPropByFunc(FunctorRecordedWithKey,PROLOG_MODULE));
|
||||||
|
PredRestoreRegs = RepPredProp(PredPropByFunc(FunctorRestoreRegs,PROLOG_MODULE));
|
||||||
|
PredSafeCallCleanup = RepPredProp(PredPropByFunc(FunctorSafeCallCleanup,PROLOG_MODULE));
|
||||||
|
PredStaticClause = RepPredProp(PredPropByFunc(FunctorDoStaticClause,PROLOG_MODULE));
|
||||||
|
PredThrow = RepPredProp(PredPropByFunc(FunctorThrow,PROLOG_MODULE));
|
||||||
|
PredTraceMetaCall = RepPredProp(PredPropByFunc(FunctorTraceMetaCall,PROLOG_MODULE));
|
||||||
|
PredCommentHook = RepPredProp(PredPropByFunc(FunctorCommentHook,PROLOG_MODULE));
|
||||||
PredProcedure = Yap_MkLogPred(RepPredProp(PredPropByFunc(FunctorProcedure,PROLOG_MODULE)));
|
PredProcedure = Yap_MkLogPred(RepPredProp(PredPropByFunc(FunctorProcedure,PROLOG_MODULE)));
|
||||||
|
|
||||||
#ifdef LOW_LEVEL_TRACER
|
#ifdef LOW_LEVEL_TRACER
|
||||||
|
|||||||
@ -275,5 +275,5 @@ static void InitWorker(int wid) {
|
|||||||
REMOTE_Including(wid) = TermNil;
|
REMOTE_Including(wid) = TermNil;
|
||||||
REMOTE_MAX_SIZE(wid) = 1024L;
|
REMOTE_MAX_SIZE(wid) = 1024L;
|
||||||
|
|
||||||
REMOTE_LastWTime(wid) = NULL;
|
REMOTE_LastWTime(wid) = 0;
|
||||||
}
|
}
|
||||||
|
|||||||
@ -1,421 +1,424 @@
|
|||||||
|
|
||||||
/* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms"
|
/* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms"
|
||||||
please do not update, update misc/ATOMS instead */
|
{lease do not update, update misc/ATOMS instead */
|
||||||
|
|
||||||
Atom3Dots = AtomAdjust(Atom3Dots);
|
Atom3Dots = AtomAdjust(Atom3Dots);
|
||||||
AtomAbol = AtomAdjust(AtomAbol);
|
AtomAbol = AtomAdjust(AtomAbol); TermAbol = MkAtomTerm(AtomAbol);
|
||||||
AtomAccess = AtomAdjust(AtomAccess);
|
AtomAccess = AtomAdjust(AtomAccess); TermAccess = MkAtomTerm(AtomAccess);
|
||||||
AtomAfInet = AtomAdjust(AtomAfInet);
|
AtomAfInet = AtomAdjust(AtomAfInet); TermAfInet = MkAtomTerm(AtomAfInet);
|
||||||
AtomAfLocal = AtomAdjust(AtomAfLocal);
|
AtomAfLocal = AtomAdjust(AtomAfLocal); TermAfLocal = MkAtomTerm(AtomAfLocal);
|
||||||
AtomAfUnix = AtomAdjust(AtomAfUnix);
|
AtomAfUnix = AtomAdjust(AtomAfUnix); TermAfUnix = MkAtomTerm(AtomAfUnix);
|
||||||
AtomAlarm = AtomAdjust(AtomAlarm);
|
AtomAlarm = AtomAdjust(AtomAlarm); TermAlarm = MkAtomTerm(AtomAlarm);
|
||||||
AtomAlias = AtomAdjust(AtomAlias);
|
AtomAlias = AtomAdjust(AtomAlias); TermAlias = MkAtomTerm(AtomAlias);
|
||||||
AtomAll = AtomAdjust(AtomAll);
|
AtomAll = AtomAdjust(AtomAll); TermAll = MkAtomTerm(AtomAll);
|
||||||
AtomAltNot = AtomAdjust(AtomAltNot);
|
AtomAltNot = AtomAdjust(AtomAltNot); TermAltNot = MkAtomTerm(AtomAltNot);
|
||||||
AtomAny = AtomAdjust(AtomAny);
|
AtomAnswer = AtomAdjust(AtomAnswer); TermAnswer = MkAtomTerm(AtomAnswer);
|
||||||
AtomAppend = AtomAdjust(AtomAppend);
|
AtomAny = AtomAdjust(AtomAny); TermAny = MkAtomTerm(AtomAny);
|
||||||
AtomArg = AtomAdjust(AtomArg);
|
AtomAppend = AtomAdjust(AtomAppend); TermAppend = MkAtomTerm(AtomAppend);
|
||||||
AtomArray = AtomAdjust(AtomArray);
|
AtomArg = AtomAdjust(AtomArg); TermArg = MkAtomTerm(AtomArg);
|
||||||
AtomArrayAccess = AtomAdjust(AtomArrayAccess);
|
AtomArray = AtomAdjust(AtomArray); TermArray = MkAtomTerm(AtomArray);
|
||||||
AtomArrayOverflow = AtomAdjust(AtomArrayOverflow);
|
AtomArrayAccess = AtomAdjust(AtomArrayAccess); TermArrayAccess = MkAtomTerm(AtomArrayAccess);
|
||||||
AtomArrayType = AtomAdjust(AtomArrayType);
|
AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow);
|
||||||
AtomArrow = AtomAdjust(AtomArrow);
|
AtomArrayType = AtomAdjust(AtomArrayType); TermArrayType = MkAtomTerm(AtomArrayType);
|
||||||
AtomAttributedModule = AtomAdjust(AtomAttributedModule);
|
AtomArrow = AtomAdjust(AtomArrow); TermArrow = MkAtomTerm(AtomArrow);
|
||||||
AtomDoubleArrow = AtomAdjust(AtomDoubleArrow);
|
AtomAttributedModule = AtomAdjust(AtomAttributedModule); TermAttributedModule = MkAtomTerm(AtomAttributedModule);
|
||||||
AtomAssert = AtomAdjust(AtomAssert);
|
AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow);
|
||||||
AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets);
|
AtomAssert = AtomAdjust(AtomAssert); TermAssert = MkAtomTerm(AtomAssert);
|
||||||
AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets);
|
AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets);
|
||||||
AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets);
|
AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets);
|
||||||
AtomAsserta = AtomAdjust(AtomAsserta);
|
AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets);
|
||||||
AtomAssertaStatic = AtomAdjust(AtomAssertaStatic);
|
AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta);
|
||||||
AtomAssertz = AtomAdjust(AtomAssertz);
|
AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic);
|
||||||
AtomAssertzStatic = AtomAdjust(AtomAssertzStatic);
|
AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz);
|
||||||
AtomAt = AtomAdjust(AtomAt);
|
AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic);
|
||||||
AtomAtom = AtomAdjust(AtomAtom);
|
AtomAt = AtomAdjust(AtomAt); TermAt = MkAtomTerm(AtomAt);
|
||||||
AtomAtomic = AtomAdjust(AtomAtomic);
|
AtomAtom = AtomAdjust(AtomAtom); TermAtom = MkAtomTerm(AtomAtom);
|
||||||
AtomAtt = AtomAdjust(AtomAtt);
|
AtomAtomic = AtomAdjust(AtomAtomic); TermAtomic = MkAtomTerm(AtomAtomic);
|
||||||
AtomAtt1 = AtomAdjust(AtomAtt1);
|
AtomAtt = AtomAdjust(AtomAtt); TermAtt = MkAtomTerm(AtomAtt);
|
||||||
AtomAttDo = AtomAdjust(AtomAttDo);
|
AtomAtt1 = AtomAdjust(AtomAtt1); TermAtt1 = MkAtomTerm(AtomAtt1);
|
||||||
AtomAttributes = AtomAdjust(AtomAttributes);
|
AtomAttDo = AtomAdjust(AtomAttDo); TermAttDo = MkAtomTerm(AtomAttDo);
|
||||||
AtomB = AtomAdjust(AtomB);
|
AtomAttributes = AtomAdjust(AtomAttributes); TermAttributes = MkAtomTerm(AtomAttributes);
|
||||||
AtomBatched = AtomAdjust(AtomBatched);
|
AtomB = AtomAdjust(AtomB); TermB = MkAtomTerm(AtomB);
|
||||||
AtomBetween = AtomAdjust(AtomBetween);
|
AtomBatched = AtomAdjust(AtomBatched); TermBatched = MkAtomTerm(AtomBatched);
|
||||||
AtomBinary = AtomAdjust(AtomBinary);
|
AtomBetween = AtomAdjust(AtomBetween); TermBetween = MkAtomTerm(AtomBetween);
|
||||||
AtomBigNum = AtomAdjust(AtomBigNum);
|
AtomBinary = AtomAdjust(AtomBinary); TermBinary = MkAtomTerm(AtomBinary);
|
||||||
AtomBinaryStream = AtomAdjust(AtomBinaryStream);
|
AtomBigNum = AtomAdjust(AtomBigNum); TermBigNum = MkAtomTerm(AtomBigNum);
|
||||||
AtomBoolean = AtomAdjust(AtomBoolean);
|
AtomBinaryStream = AtomAdjust(AtomBinaryStream); TermBinaryStream = MkAtomTerm(AtomBinaryStream);
|
||||||
AtomBraces = AtomAdjust(AtomBraces);
|
AtomBoolean = AtomAdjust(AtomBoolean); TermBoolean = MkAtomTerm(AtomBoolean);
|
||||||
AtomBreak = AtomAdjust(AtomBreak);
|
AtomBraces = AtomAdjust(AtomBraces); TermBraces = MkAtomTerm(AtomBraces);
|
||||||
AtomByte = AtomAdjust(AtomByte);
|
AtomBreak = AtomAdjust(AtomBreak); TermBreak = MkAtomTerm(AtomBreak);
|
||||||
AtomCArith = AtomAdjust(AtomCArith);
|
AtomByte = AtomAdjust(AtomByte); TermByte = MkAtomTerm(AtomByte);
|
||||||
AtomCall = AtomAdjust(AtomCall);
|
AtomCArith = AtomAdjust(AtomCArith); TermCArith = MkAtomTerm(AtomCArith);
|
||||||
AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter);
|
AtomCall = AtomAdjust(AtomCall); TermCall = MkAtomTerm(AtomCall);
|
||||||
AtomCallCounter = AtomAdjust(AtomCallCounter);
|
AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter);
|
||||||
AtomCallable = AtomAdjust(AtomCallable);
|
AtomCallCounter = AtomAdjust(AtomCallCounter); TermCallCounter = MkAtomTerm(AtomCallCounter);
|
||||||
AtomCatch = AtomAdjust(AtomCatch);
|
AtomCallable = AtomAdjust(AtomCallable); TermCallable = MkAtomTerm(AtomCallable);
|
||||||
AtomChangeModule = AtomAdjust(AtomChangeModule);
|
AtomCatch = AtomAdjust(AtomCatch); TermCatch = MkAtomTerm(AtomCatch);
|
||||||
AtomChar = AtomAdjust(AtomChar);
|
AtomChangeModule = AtomAdjust(AtomChangeModule); TermChangeModule = MkAtomTerm(AtomChangeModule);
|
||||||
AtomCharsio = AtomAdjust(AtomCharsio);
|
AtomChar = AtomAdjust(AtomChar); TermChar = MkAtomTerm(AtomChar);
|
||||||
AtomCharacter = AtomAdjust(AtomCharacter);
|
AtomCharsio = AtomAdjust(AtomCharsio); TermCharsio = MkAtomTerm(AtomCharsio);
|
||||||
AtomCharacterCode = AtomAdjust(AtomCharacterCode);
|
AtomCharacter = AtomAdjust(AtomCharacter); TermCharacter = MkAtomTerm(AtomCharacter);
|
||||||
AtomChars = AtomAdjust(AtomChars);
|
AtomCharacterCode = AtomAdjust(AtomCharacterCode); TermCharacterCode = MkAtomTerm(AtomCharacterCode);
|
||||||
AtomCharset = AtomAdjust(AtomCharset);
|
AtomChars = AtomAdjust(AtomChars); TermChars = MkAtomTerm(AtomChars);
|
||||||
AtomChType = AtomAdjust(AtomChType);
|
AtomCharset = AtomAdjust(AtomCharset); TermCharset = MkAtomTerm(AtomCharset);
|
||||||
AtomCleanCall = AtomAdjust(AtomCleanCall);
|
AtomChType = AtomAdjust(AtomChType); TermChType = MkAtomTerm(AtomChType);
|
||||||
AtomColomn = AtomAdjust(AtomColomn);
|
AtomCleanCall = AtomAdjust(AtomCleanCall); TermCleanCall = MkAtomTerm(AtomCleanCall);
|
||||||
AtomCodeSpace = AtomAdjust(AtomCodeSpace);
|
AtomColomn = AtomAdjust(AtomColomn); TermColomn = MkAtomTerm(AtomColomn);
|
||||||
AtomCodes = AtomAdjust(AtomCodes);
|
AtomCodeSpace = AtomAdjust(AtomCodeSpace); TermCodeSpace = MkAtomTerm(AtomCodeSpace);
|
||||||
AtomCoInductive = AtomAdjust(AtomCoInductive);
|
AtomCodes = AtomAdjust(AtomCodes); TermCodes = MkAtomTerm(AtomCodes);
|
||||||
AtomComma = AtomAdjust(AtomComma);
|
AtomCoInductive = AtomAdjust(AtomCoInductive); TermCoInductive = MkAtomTerm(AtomCoInductive);
|
||||||
AtomCommentHook = AtomAdjust(AtomCommentHook);
|
AtomComma = AtomAdjust(AtomComma); TermComma = MkAtomTerm(AtomComma);
|
||||||
AtomCompact = AtomAdjust(AtomCompact);
|
AtomCommentHook = AtomAdjust(AtomCommentHook); TermCommentHook = MkAtomTerm(AtomCommentHook);
|
||||||
AtomCompound = AtomAdjust(AtomCompound);
|
AtomCompact = AtomAdjust(AtomCompact); TermCompact = MkAtomTerm(AtomCompact);
|
||||||
AtomConsistencyError = AtomAdjust(AtomConsistencyError);
|
AtomCompound = AtomAdjust(AtomCompound); TermCompound = MkAtomTerm(AtomCompound);
|
||||||
AtomConsult = AtomAdjust(AtomConsult);
|
AtomConsistencyError = AtomAdjust(AtomConsistencyError); TermConsistencyError = MkAtomTerm(AtomConsistencyError);
|
||||||
AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot);
|
AtomConsult = AtomAdjust(AtomConsult); TermConsult = MkAtomTerm(AtomConsult);
|
||||||
AtomContext = AtomAdjust(AtomContext);
|
AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot);
|
||||||
AtomCputime = AtomAdjust(AtomCputime);
|
AtomContext = AtomAdjust(AtomContext); TermContext = MkAtomTerm(AtomContext);
|
||||||
AtomCreate = AtomAdjust(AtomCreate);
|
AtomCputime = AtomAdjust(AtomCputime); TermCputime = MkAtomTerm(AtomCputime);
|
||||||
AtomCreep = AtomAdjust(AtomCreep);
|
AtomCreate = AtomAdjust(AtomCreate); TermCreate = MkAtomTerm(AtomCreate);
|
||||||
AtomCryptAtoms = AtomAdjust(AtomCryptAtoms);
|
AtomCreep = AtomAdjust(AtomCreep); TermCreep = MkAtomTerm(AtomCreep);
|
||||||
AtomCsult = AtomAdjust(AtomCsult);
|
AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms);
|
||||||
AtomCurrentModule = AtomAdjust(AtomCurrentModule);
|
AtomCsult = AtomAdjust(AtomCsult); TermCsult = MkAtomTerm(AtomCsult);
|
||||||
AtomCut = AtomAdjust(AtomCut);
|
AtomCurrentModule = AtomAdjust(AtomCurrentModule); TermCurrentModule = MkAtomTerm(AtomCurrentModule);
|
||||||
AtomCutBy = AtomAdjust(AtomCutBy);
|
AtomCut = AtomAdjust(AtomCut); TermCut = MkAtomTerm(AtomCut);
|
||||||
AtomDAbort = AtomAdjust(AtomDAbort);
|
AtomCutBy = AtomAdjust(AtomCutBy); TermCutBy = MkAtomTerm(AtomCutBy);
|
||||||
AtomDBLoad = AtomAdjust(AtomDBLoad);
|
AtomDAbort = AtomAdjust(AtomDAbort); TermDAbort = MkAtomTerm(AtomDAbort);
|
||||||
AtomDBREF = AtomAdjust(AtomDBREF);
|
AtomDBLoad = AtomAdjust(AtomDBLoad); TermDBLoad = MkAtomTerm(AtomDBLoad);
|
||||||
AtomDBReference = AtomAdjust(AtomDBReference);
|
AtomDBREF = AtomAdjust(AtomDBREF); TermDBREF = MkAtomTerm(AtomDBREF);
|
||||||
AtomDBTerm = AtomAdjust(AtomDBTerm);
|
AtomDBReference = AtomAdjust(AtomDBReference); TermDBReference = MkAtomTerm(AtomDBReference);
|
||||||
AtomDBref = AtomAdjust(AtomDBref);
|
AtomDBTerm = AtomAdjust(AtomDBTerm); TermDBTerm = MkAtomTerm(AtomDBTerm);
|
||||||
AtomDInteger = AtomAdjust(AtomDInteger);
|
AtomDBref = AtomAdjust(AtomDBref); TermDBref = MkAtomTerm(AtomDBref);
|
||||||
AtomDebugMeta = AtomAdjust(AtomDebugMeta);
|
AtomDInteger = AtomAdjust(AtomDInteger); TermDInteger = MkAtomTerm(AtomDInteger);
|
||||||
AtomDebuggerInput = AtomAdjust(AtomDebuggerInput);
|
AtomDebugMeta = AtomAdjust(AtomDebugMeta); TermDebugMeta = MkAtomTerm(AtomDebugMeta);
|
||||||
AtomDec10 = AtomAdjust(AtomDec10);
|
AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput);
|
||||||
AtomDefault = AtomAdjust(AtomDefault);
|
AtomDec10 = AtomAdjust(AtomDec10); TermDec10 = MkAtomTerm(AtomDec10);
|
||||||
AtomDevNull = AtomAdjust(AtomDevNull);
|
AtomDefault = AtomAdjust(AtomDefault); TermDefault = MkAtomTerm(AtomDefault);
|
||||||
AtomDiff = AtomAdjust(AtomDiff);
|
AtomDevNull = AtomAdjust(AtomDevNull); TermDevNull = MkAtomTerm(AtomDevNull);
|
||||||
AtomDirectory = AtomAdjust(AtomDirectory);
|
AtomDiff = AtomAdjust(AtomDiff); TermDiff = MkAtomTerm(AtomDiff);
|
||||||
AtomDiscontiguous = AtomAdjust(AtomDiscontiguous);
|
AtomDirectory = AtomAdjust(AtomDirectory); TermDirectory = MkAtomTerm(AtomDirectory);
|
||||||
AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings);
|
AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous);
|
||||||
AtomDollar = AtomAdjust(AtomDollar);
|
AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings);
|
||||||
AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause);
|
AtomDollar = AtomAdjust(AtomDollar); TermDollar = MkAtomTerm(AtomDollar);
|
||||||
AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0);
|
AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause);
|
||||||
AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase);
|
AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0);
|
||||||
AtomDollarU = AtomAdjust(AtomDollarU);
|
AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase);
|
||||||
AtomDollarUndef = AtomAdjust(AtomDollarUndef);
|
AtomDollarU = AtomAdjust(AtomDollarU); TermDollarU = MkAtomTerm(AtomDollarU);
|
||||||
AtomDomainError = AtomAdjust(AtomDomainError);
|
AtomDollarUndef = AtomAdjust(AtomDollarUndef); TermDollarUndef = MkAtomTerm(AtomDollarUndef);
|
||||||
AtomDoStaticClause = AtomAdjust(AtomDoStaticClause);
|
AtomDomainError = AtomAdjust(AtomDomainError); TermDomainError = MkAtomTerm(AtomDomainError);
|
||||||
AtomDots = AtomAdjust(AtomDots);
|
AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause);
|
||||||
AtomDOUBLE = AtomAdjust(AtomDOUBLE);
|
AtomDots = AtomAdjust(AtomDots); TermDots = MkAtomTerm(AtomDots);
|
||||||
AtomDoubleSlash = AtomAdjust(AtomDoubleSlash);
|
AtomDOUBLE = AtomAdjust(AtomDOUBLE); TermDOUBLE = MkAtomTerm(AtomDOUBLE);
|
||||||
AtomE = AtomAdjust(AtomE);
|
AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash);
|
||||||
AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT);
|
AtomE = AtomAdjust(AtomE); TermE = MkAtomTerm(AtomE);
|
||||||
AtomEQ = AtomAdjust(AtomEQ);
|
AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT);
|
||||||
AtomEmptyAtom = AtomAdjust(AtomEmptyAtom);
|
AtomEQ = AtomAdjust(AtomEQ); TermEQ = MkAtomTerm(AtomEQ);
|
||||||
AtomEncoding = AtomAdjust(AtomEncoding);
|
AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom);
|
||||||
AtomEndOfStream = AtomAdjust(AtomEndOfStream);
|
AtomEncoding = AtomAdjust(AtomEncoding); TermEncoding = MkAtomTerm(AtomEncoding);
|
||||||
AtomEof = AtomAdjust(AtomEof);
|
AtomEndOfStream = AtomAdjust(AtomEndOfStream); TermEndOfStream = MkAtomTerm(AtomEndOfStream);
|
||||||
AtomEOfCode = AtomAdjust(AtomEOfCode);
|
AtomEof = AtomAdjust(AtomEof); TermEof = MkAtomTerm(AtomEof);
|
||||||
AtomEq = AtomAdjust(AtomEq);
|
AtomEOfCode = AtomAdjust(AtomEOfCode); TermEOfCode = MkAtomTerm(AtomEOfCode);
|
||||||
AtomError = AtomAdjust(AtomError);
|
AtomEq = AtomAdjust(AtomEq); TermEq = MkAtomTerm(AtomEq);
|
||||||
AtomException = AtomAdjust(AtomException);
|
AtomError = AtomAdjust(AtomError); TermError = MkAtomTerm(AtomError);
|
||||||
AtomExtensions = AtomAdjust(AtomExtensions);
|
AtomException = AtomAdjust(AtomException); TermException = MkAtomTerm(AtomException);
|
||||||
AtomEvaluable = AtomAdjust(AtomEvaluable);
|
AtomExtensions = AtomAdjust(AtomExtensions); TermExtensions = MkAtomTerm(AtomExtensions);
|
||||||
AtomEvaluationError = AtomAdjust(AtomEvaluationError);
|
AtomEvaluable = AtomAdjust(AtomEvaluable); TermEvaluable = MkAtomTerm(AtomEvaluable);
|
||||||
AtomExecutable = AtomAdjust(AtomExecutable);
|
AtomEvaluationError = AtomAdjust(AtomEvaluationError); TermEvaluationError = MkAtomTerm(AtomEvaluationError);
|
||||||
AtomExecute = AtomAdjust(AtomExecute);
|
AtomExecutable = AtomAdjust(AtomExecutable); TermExecutable = MkAtomTerm(AtomExecutable);
|
||||||
AtomExecAnswers = AtomAdjust(AtomExecAnswers);
|
AtomExecute = AtomAdjust(AtomExecute); TermExecute = MkAtomTerm(AtomExecute);
|
||||||
AtomExecuteInMod = AtomAdjust(AtomExecuteInMod);
|
AtomExecAnswers = AtomAdjust(AtomExecAnswers); TermExecAnswers = MkAtomTerm(AtomExecAnswers);
|
||||||
AtomExecuteWithin = AtomAdjust(AtomExecuteWithin);
|
AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod);
|
||||||
AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod);
|
AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin);
|
||||||
AtomExist = AtomAdjust(AtomExist);
|
AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod);
|
||||||
AtomExistenceError = AtomAdjust(AtomExistenceError);
|
AtomExist = AtomAdjust(AtomExist); TermExist = MkAtomTerm(AtomExist);
|
||||||
AtomExoClause = AtomAdjust(AtomExoClause);
|
AtomExit = AtomAdjust(AtomExit); TermExit = MkAtomTerm(AtomExit);
|
||||||
AtomExpectedNumber = AtomAdjust(AtomExpectedNumber);
|
AtomExistenceError = AtomAdjust(AtomExistenceError); TermExistenceError = MkAtomTerm(AtomExistenceError);
|
||||||
AtomExpand = AtomAdjust(AtomExpand);
|
AtomExoClause = AtomAdjust(AtomExoClause); TermExoClause = MkAtomTerm(AtomExoClause);
|
||||||
AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath);
|
AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber);
|
||||||
AtomExtendsions = AtomAdjust(AtomExtendsions);
|
AtomExpand = AtomAdjust(AtomExpand); TermExpand = MkAtomTerm(AtomExpand);
|
||||||
AtomFB = AtomAdjust(AtomFB);
|
AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath);
|
||||||
AtomFail = AtomAdjust(AtomFail);
|
AtomExtendsions = AtomAdjust(AtomExtendsions); TermExtendsions = MkAtomTerm(AtomExtendsions);
|
||||||
AtomFalse = AtomAdjust(AtomFalse);
|
AtomFB = AtomAdjust(AtomFB); TermFB = MkAtomTerm(AtomFB);
|
||||||
AtomFast = AtomAdjust(AtomFast);
|
AtomFail = AtomAdjust(AtomFail); TermFail = MkAtomTerm(AtomFail);
|
||||||
AtomFastFail = AtomAdjust(AtomFastFail);
|
AtomFalse = AtomAdjust(AtomFalse); TermFalse = MkAtomTerm(AtomFalse);
|
||||||
AtomFileErrors = AtomAdjust(AtomFileErrors);
|
AtomFast = AtomAdjust(AtomFast); TermFast = MkAtomTerm(AtomFast);
|
||||||
AtomFileerrors = AtomAdjust(AtomFileerrors);
|
AtomFastFail = AtomAdjust(AtomFastFail); TermFastFail = MkAtomTerm(AtomFastFail);
|
||||||
AtomFileType = AtomAdjust(AtomFileType);
|
AtomFileErrors = AtomAdjust(AtomFileErrors); TermFileErrors = MkAtomTerm(AtomFileErrors);
|
||||||
AtomFirst = AtomAdjust(AtomFirst);
|
AtomFileerrors = AtomAdjust(AtomFileerrors); TermFileerrors = MkAtomTerm(AtomFileerrors);
|
||||||
AtomFloat = AtomAdjust(AtomFloat);
|
AtomFileType = AtomAdjust(AtomFileType); TermFileType = MkAtomTerm(AtomFileType);
|
||||||
AtomFloatFormat = AtomAdjust(AtomFloatFormat);
|
AtomFirst = AtomAdjust(AtomFirst); TermFirst = MkAtomTerm(AtomFirst);
|
||||||
AtomFloatOverflow = AtomAdjust(AtomFloatOverflow);
|
AtomFloat = AtomAdjust(AtomFloat); TermFloat = MkAtomTerm(AtomFloat);
|
||||||
AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow);
|
AtomFloatFormat = AtomAdjust(AtomFloatFormat); TermFloatFormat = MkAtomTerm(AtomFloatFormat);
|
||||||
AtomFormat = AtomAdjust(AtomFormat);
|
AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow);
|
||||||
AtomFormatAt = AtomAdjust(AtomFormatAt);
|
AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow);
|
||||||
AtomFull = AtomAdjust(AtomFull);
|
AtomFormat = AtomAdjust(AtomFormat); TermFormat = MkAtomTerm(AtomFormat);
|
||||||
AtomFunctor = AtomAdjust(AtomFunctor);
|
AtomFormatAt = AtomAdjust(AtomFormatAt); TermFormatAt = MkAtomTerm(AtomFormatAt);
|
||||||
AtomGT = AtomAdjust(AtomGT);
|
AtomFull = AtomAdjust(AtomFull); TermFull = MkAtomTerm(AtomFull);
|
||||||
AtomGVar = AtomAdjust(AtomGVar);
|
AtomFunctor = AtomAdjust(AtomFunctor); TermFunctor = MkAtomTerm(AtomFunctor);
|
||||||
AtomGc = AtomAdjust(AtomGc);
|
AtomGT = AtomAdjust(AtomGT); TermGT = MkAtomTerm(AtomGT);
|
||||||
AtomGcMargin = AtomAdjust(AtomGcMargin);
|
AtomGVar = AtomAdjust(AtomGVar); TermGVar = MkAtomTerm(AtomGVar);
|
||||||
AtomGcTrace = AtomAdjust(AtomGcTrace);
|
AtomGc = AtomAdjust(AtomGc); TermGc = MkAtomTerm(AtomGc);
|
||||||
AtomGcVerbose = AtomAdjust(AtomGcVerbose);
|
AtomGcMargin = AtomAdjust(AtomGcMargin); TermGcMargin = MkAtomTerm(AtomGcMargin);
|
||||||
AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose);
|
AtomGcTrace = AtomAdjust(AtomGcTrace); TermGcTrace = MkAtomTerm(AtomGcTrace);
|
||||||
AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo);
|
AtomGcVerbose = AtomAdjust(AtomGcVerbose); TermGcVerbose = MkAtomTerm(AtomGcVerbose);
|
||||||
AtomGetwork = AtomAdjust(AtomGetwork);
|
AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose);
|
||||||
AtomGetworkSeq = AtomAdjust(AtomGetworkSeq);
|
AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo);
|
||||||
AtomGlob = AtomAdjust(AtomGlob);
|
AtomGetwork = AtomAdjust(AtomGetwork); TermGetwork = MkAtomTerm(AtomGetwork);
|
||||||
AtomGlobal = AtomAdjust(AtomGlobal);
|
AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq);
|
||||||
AtomGlobalSp = AtomAdjust(AtomGlobalSp);
|
AtomGlob = AtomAdjust(AtomGlob); TermGlob = MkAtomTerm(AtomGlob);
|
||||||
AtomGlobalTrie = AtomAdjust(AtomGlobalTrie);
|
AtomGlobal = AtomAdjust(AtomGlobal); TermGlobal = MkAtomTerm(AtomGlobal);
|
||||||
AtomGoalExpansion = AtomAdjust(AtomGoalExpansion);
|
AtomGlobalSp = AtomAdjust(AtomGlobalSp); TermGlobalSp = MkAtomTerm(AtomGlobalSp);
|
||||||
AtomHat = AtomAdjust(AtomHat);
|
AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie);
|
||||||
AtomHERE = AtomAdjust(AtomHERE);
|
AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion);
|
||||||
AtomHandleThrow = AtomAdjust(AtomHandleThrow);
|
AtomHat = AtomAdjust(AtomHat); TermHat = MkAtomTerm(AtomHat);
|
||||||
AtomHeap = AtomAdjust(AtomHeap);
|
AtomHERE = AtomAdjust(AtomHERE); TermHERE = MkAtomTerm(AtomHERE);
|
||||||
AtomHeapUsed = AtomAdjust(AtomHeapUsed);
|
AtomHandleThrow = AtomAdjust(AtomHandleThrow); TermHandleThrow = MkAtomTerm(AtomHandleThrow);
|
||||||
AtomHugeInt = AtomAdjust(AtomHugeInt);
|
AtomHeap = AtomAdjust(AtomHeap); TermHeap = MkAtomTerm(AtomHeap);
|
||||||
AtomIDB = AtomAdjust(AtomIDB);
|
AtomHeapUsed = AtomAdjust(AtomHeapUsed); TermHeapUsed = MkAtomTerm(AtomHeapUsed);
|
||||||
AtomIOMode = AtomAdjust(AtomIOMode);
|
AtomHugeInt = AtomAdjust(AtomHugeInt); TermHugeInt = MkAtomTerm(AtomHugeInt);
|
||||||
AtomId = AtomAdjust(AtomId);
|
AtomIDB = AtomAdjust(AtomIDB); TermIDB = MkAtomTerm(AtomIDB);
|
||||||
AtomIgnore = AtomAdjust(AtomIgnore);
|
AtomIOMode = AtomAdjust(AtomIOMode); TermIOMode = MkAtomTerm(AtomIOMode);
|
||||||
AtomInf = AtomAdjust(AtomInf);
|
AtomId = AtomAdjust(AtomId); TermId = MkAtomTerm(AtomId);
|
||||||
AtomInfinity = AtomAdjust(AtomInfinity);
|
AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore);
|
||||||
AtomInitGoal = AtomAdjust(AtomInitGoal);
|
AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf);
|
||||||
AtomInitProlog = AtomAdjust(AtomInitProlog);
|
AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity);
|
||||||
AtomInStackExpansion = AtomAdjust(AtomInStackExpansion);
|
AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal);
|
||||||
AtomInput = AtomAdjust(AtomInput);
|
AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog);
|
||||||
AtomInstantiationError = AtomAdjust(AtomInstantiationError);
|
AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion);
|
||||||
AtomInt = AtomAdjust(AtomInt);
|
AtomInput = AtomAdjust(AtomInput); TermInput = MkAtomTerm(AtomInput);
|
||||||
AtomIntOverflow = AtomAdjust(AtomIntOverflow);
|
AtomInstantiationError = AtomAdjust(AtomInstantiationError); TermInstantiationError = MkAtomTerm(AtomInstantiationError);
|
||||||
AtomInteger = AtomAdjust(AtomInteger);
|
AtomInt = AtomAdjust(AtomInt); TermInt = MkAtomTerm(AtomInt);
|
||||||
AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError);
|
AtomIntOverflow = AtomAdjust(AtomIntOverflow); TermIntOverflow = MkAtomTerm(AtomIntOverflow);
|
||||||
AtomIs = AtomAdjust(AtomIs);
|
AtomInteger = AtomAdjust(AtomInteger); TermInteger = MkAtomTerm(AtomInteger);
|
||||||
AtomKey = AtomAdjust(AtomKey);
|
AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError);
|
||||||
AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath);
|
AtomIs = AtomAdjust(AtomIs); TermIs = MkAtomTerm(AtomIs);
|
||||||
AtomLONGINT = AtomAdjust(AtomLONGINT);
|
AtomKey = AtomAdjust(AtomKey); TermKey = MkAtomTerm(AtomKey);
|
||||||
AtomLOOP = AtomAdjust(AtomLOOP);
|
AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath);
|
||||||
AtomLoopStream = AtomAdjust(AtomLoopStream);
|
AtomLONGINT = AtomAdjust(AtomLONGINT); TermLONGINT = MkAtomTerm(AtomLONGINT);
|
||||||
AtomLT = AtomAdjust(AtomLT);
|
AtomLOOP = AtomAdjust(AtomLOOP); TermLOOP = MkAtomTerm(AtomLOOP);
|
||||||
AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin);
|
AtomLoopStream = AtomAdjust(AtomLoopStream); TermLoopStream = MkAtomTerm(AtomLoopStream);
|
||||||
AtomLeash = AtomAdjust(AtomLeash);
|
AtomLT = AtomAdjust(AtomLT); TermLT = MkAtomTerm(AtomLT);
|
||||||
AtomLeast = AtomAdjust(AtomLeast);
|
AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin);
|
||||||
AtomLength = AtomAdjust(AtomLength);
|
AtomLeash = AtomAdjust(AtomLeash); TermLeash = MkAtomTerm(AtomLeash);
|
||||||
AtomList = AtomAdjust(AtomList);
|
AtomLeast = AtomAdjust(AtomLeast); TermLeast = MkAtomTerm(AtomLeast);
|
||||||
AtomLine = AtomAdjust(AtomLine);
|
AtomLength = AtomAdjust(AtomLength); TermLength = MkAtomTerm(AtomLength);
|
||||||
AtomLive = AtomAdjust(AtomLive);
|
AtomList = AtomAdjust(AtomList); TermList = MkAtomTerm(AtomList);
|
||||||
AtomLoadAnswers = AtomAdjust(AtomLoadAnswers);
|
AtomLine = AtomAdjust(AtomLine); TermLine = MkAtomTerm(AtomLine);
|
||||||
AtomLocal = AtomAdjust(AtomLocal);
|
AtomLive = AtomAdjust(AtomLive); TermLive = MkAtomTerm(AtomLive);
|
||||||
AtomLocalSp = AtomAdjust(AtomLocalSp);
|
AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers);
|
||||||
AtomLocalTrie = AtomAdjust(AtomLocalTrie);
|
AtomLocal = AtomAdjust(AtomLocal); TermLocal = MkAtomTerm(AtomLocal);
|
||||||
AtomMax = AtomAdjust(AtomMax);
|
AtomLocalSp = AtomAdjust(AtomLocalSp); TermLocalSp = MkAtomTerm(AtomLocalSp);
|
||||||
AtomMaximum = AtomAdjust(AtomMaximum);
|
AtomLocalTrie = AtomAdjust(AtomLocalTrie); TermLocalTrie = MkAtomTerm(AtomLocalTrie);
|
||||||
AtomMaxArity = AtomAdjust(AtomMaxArity);
|
AtomMax = AtomAdjust(AtomMax); TermMax = MkAtomTerm(AtomMax);
|
||||||
AtomMaxFiles = AtomAdjust(AtomMaxFiles);
|
AtomMaximum = AtomAdjust(AtomMaximum); TermMaximum = MkAtomTerm(AtomMaximum);
|
||||||
AtomMegaClause = AtomAdjust(AtomMegaClause);
|
AtomMaxArity = AtomAdjust(AtomMaxArity); TermMaxArity = MkAtomTerm(AtomMaxArity);
|
||||||
AtomMetaCall = AtomAdjust(AtomMetaCall);
|
AtomMaxFiles = AtomAdjust(AtomMaxFiles); TermMaxFiles = MkAtomTerm(AtomMaxFiles);
|
||||||
AtomMfClause = AtomAdjust(AtomMfClause);
|
AtomMegaClause = AtomAdjust(AtomMegaClause); TermMegaClause = MkAtomTerm(AtomMegaClause);
|
||||||
AtomMin = AtomAdjust(AtomMin);
|
AtomMetaCall = AtomAdjust(AtomMetaCall); TermMetaCall = MkAtomTerm(AtomMetaCall);
|
||||||
AtomMinimum = AtomAdjust(AtomMinimum);
|
AtomMfClause = AtomAdjust(AtomMfClause); TermMfClause = MkAtomTerm(AtomMfClause);
|
||||||
AtomMinus = AtomAdjust(AtomMinus);
|
AtomMin = AtomAdjust(AtomMin); TermMin = MkAtomTerm(AtomMin);
|
||||||
AtomModify = AtomAdjust(AtomModify);
|
AtomMinimum = AtomAdjust(AtomMinimum); TermMinimum = MkAtomTerm(AtomMinimum);
|
||||||
AtomModule = AtomAdjust(AtomModule);
|
AtomMinus = AtomAdjust(AtomMinus); TermMinus = MkAtomTerm(AtomMinus);
|
||||||
AtomMost = AtomAdjust(AtomMost);
|
AtomModify = AtomAdjust(AtomModify); TermModify = MkAtomTerm(AtomModify);
|
||||||
AtomMulti = AtomAdjust(AtomMulti);
|
AtomModule = AtomAdjust(AtomModule); TermModule = MkAtomTerm(AtomModule);
|
||||||
AtomMultiFile = AtomAdjust(AtomMultiFile);
|
AtomMost = AtomAdjust(AtomMost); TermMost = MkAtomTerm(AtomMost);
|
||||||
AtomMultiple = AtomAdjust(AtomMultiple);
|
AtomMulti = AtomAdjust(AtomMulti); TermMulti = MkAtomTerm(AtomMulti);
|
||||||
AtomMutable = AtomAdjust(AtomMutable);
|
AtomMultiFile = AtomAdjust(AtomMultiFile); TermMultiFile = MkAtomTerm(AtomMultiFile);
|
||||||
AtomMutableVariable = AtomAdjust(AtomMutableVariable);
|
AtomMultiple = AtomAdjust(AtomMultiple); TermMultiple = MkAtomTerm(AtomMultiple);
|
||||||
AtomMutex = AtomAdjust(AtomMutex);
|
AtomMutable = AtomAdjust(AtomMutable); TermMutable = MkAtomTerm(AtomMutable);
|
||||||
AtomMyddasDB = AtomAdjust(AtomMyddasDB);
|
AtomMutableVariable = AtomAdjust(AtomMutableVariable); TermMutableVariable = MkAtomTerm(AtomMutableVariable);
|
||||||
AtomMyddasGoal = AtomAdjust(AtomMyddasGoal);
|
AtomMutex = AtomAdjust(AtomMutex); TermMutex = MkAtomTerm(AtomMutex);
|
||||||
AtomMyddasHost = AtomAdjust(AtomMyddasHost);
|
AtomMyddasDB = AtomAdjust(AtomMyddasDB); TermMyddasDB = MkAtomTerm(AtomMyddasDB);
|
||||||
AtomMyddasPass = AtomAdjust(AtomMyddasPass);
|
AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal);
|
||||||
AtomMyddasUser = AtomAdjust(AtomMyddasUser);
|
AtomMyddasHost = AtomAdjust(AtomMyddasHost); TermMyddasHost = MkAtomTerm(AtomMyddasHost);
|
||||||
AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName);
|
AtomMyddasPass = AtomAdjust(AtomMyddasPass); TermMyddasPass = MkAtomTerm(AtomMyddasPass);
|
||||||
AtomNan = AtomAdjust(AtomNan);
|
AtomMyddasUser = AtomAdjust(AtomMyddasUser); TermMyddasUser = MkAtomTerm(AtomMyddasUser);
|
||||||
AtomNb = AtomAdjust(AtomNb);
|
AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName);
|
||||||
AtomNbTerm = AtomAdjust(AtomNbTerm);
|
AtomNan = AtomAdjust(AtomNan); TermNan = MkAtomTerm(AtomNan);
|
||||||
AtomNew = AtomAdjust(AtomNew);
|
AtomNb = AtomAdjust(AtomNb); TermNb = MkAtomTerm(AtomNb);
|
||||||
AtomNewLine = AtomAdjust(AtomNewLine);
|
AtomNbTerm = AtomAdjust(AtomNbTerm); TermNbTerm = MkAtomTerm(AtomNbTerm);
|
||||||
AtomNl = AtomAdjust(AtomNl);
|
AtomNew = AtomAdjust(AtomNew); TermNew = MkAtomTerm(AtomNew);
|
||||||
AtomNoEffect = AtomAdjust(AtomNoEffect);
|
AtomNewLine = AtomAdjust(AtomNewLine); TermNewLine = MkAtomTerm(AtomNewLine);
|
||||||
AtomNoMemory = AtomAdjust(AtomNoMemory);
|
AtomNl = AtomAdjust(AtomNl); TermNl = MkAtomTerm(AtomNl);
|
||||||
AtomNone = AtomAdjust(AtomNone);
|
AtomNoEffect = AtomAdjust(AtomNoEffect); TermNoEffect = MkAtomTerm(AtomNoEffect);
|
||||||
AtomNonEmptyList = AtomAdjust(AtomNonEmptyList);
|
AtomNoMemory = AtomAdjust(AtomNoMemory); TermNoMemory = MkAtomTerm(AtomNoMemory);
|
||||||
AtomNot = AtomAdjust(AtomNot);
|
AtomNone = AtomAdjust(AtomNone); TermNone = MkAtomTerm(AtomNone);
|
||||||
AtomNotImplemented = AtomAdjust(AtomNotImplemented);
|
AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList);
|
||||||
AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero);
|
AtomNot = AtomAdjust(AtomNot); TermNot = MkAtomTerm(AtomNot);
|
||||||
AtomNotNewline = AtomAdjust(AtomNotNewline);
|
AtomNotImplemented = AtomAdjust(AtomNotImplemented); TermNotImplemented = MkAtomTerm(AtomNotImplemented);
|
||||||
AtomNotZero = AtomAdjust(AtomNotZero);
|
AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero);
|
||||||
AtomNumber = AtomAdjust(AtomNumber);
|
AtomNotNewline = AtomAdjust(AtomNotNewline); TermNotNewline = MkAtomTerm(AtomNotNewline);
|
||||||
AtomOff = AtomAdjust(AtomOff);
|
AtomNotZero = AtomAdjust(AtomNotZero); TermNotZero = MkAtomTerm(AtomNotZero);
|
||||||
AtomOffline = AtomAdjust(AtomOffline);
|
AtomNumber = AtomAdjust(AtomNumber); TermNumber = MkAtomTerm(AtomNumber);
|
||||||
AtomOn = AtomAdjust(AtomOn);
|
AtomOff = AtomAdjust(AtomOff); TermOff = MkAtomTerm(AtomOff);
|
||||||
AtomOnline = AtomAdjust(AtomOnline);
|
AtomOffline = AtomAdjust(AtomOffline); TermOffline = MkAtomTerm(AtomOffline);
|
||||||
AtomOpen = AtomAdjust(AtomOpen);
|
AtomOn = AtomAdjust(AtomOn); TermOn = MkAtomTerm(AtomOn);
|
||||||
AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError);
|
AtomOnline = AtomAdjust(AtomOnline); TermOnline = MkAtomTerm(AtomOnline);
|
||||||
AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport);
|
AtomOpen = AtomAdjust(AtomOpen); TermOpen = MkAtomTerm(AtomOpen);
|
||||||
AtomOperator = AtomAdjust(AtomOperator);
|
AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError);
|
||||||
AtomOperatorPriority = AtomAdjust(AtomOperatorPriority);
|
AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport);
|
||||||
AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier);
|
AtomOperator = AtomAdjust(AtomOperator); TermOperator = MkAtomTerm(AtomOperator);
|
||||||
AtomOpt = AtomAdjust(AtomOpt);
|
AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority);
|
||||||
AtomOtherwise = AtomAdjust(AtomOtherwise);
|
AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier);
|
||||||
AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError);
|
AtomOpt = AtomAdjust(AtomOpt); TermOpt = MkAtomTerm(AtomOpt);
|
||||||
AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError);
|
AtomOtherwise = AtomAdjust(AtomOtherwise); TermOtherwise = MkAtomTerm(AtomOtherwise);
|
||||||
AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError);
|
AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError);
|
||||||
AtomOutOfRange = AtomAdjust(AtomOutOfRange);
|
AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError);
|
||||||
AtomOutOfStackError = AtomAdjust(AtomOutOfStackError);
|
AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError);
|
||||||
AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError);
|
AtomOutOfRange = AtomAdjust(AtomOutOfRange); TermOutOfRange = MkAtomTerm(AtomOutOfRange);
|
||||||
AtomOutput = AtomAdjust(AtomOutput);
|
AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError);
|
||||||
AtomParameter = AtomAdjust(AtomParameter);
|
AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError);
|
||||||
AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir);
|
AtomOutput = AtomAdjust(AtomOutput); TermOutput = MkAtomTerm(AtomOutput);
|
||||||
AtomPast = AtomAdjust(AtomPast);
|
AtomParameter = AtomAdjust(AtomParameter); TermParameter = MkAtomTerm(AtomParameter);
|
||||||
AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream);
|
AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir);
|
||||||
AtomPermissionError = AtomAdjust(AtomPermissionError);
|
AtomPast = AtomAdjust(AtomPast); TermPast = MkAtomTerm(AtomPast);
|
||||||
AtomPi = AtomAdjust(AtomPi);
|
AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream);
|
||||||
AtomPipe = AtomAdjust(AtomPipe);
|
AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError);
|
||||||
AtomPlus = AtomAdjust(AtomPlus);
|
AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi);
|
||||||
AtomPointer = AtomAdjust(AtomPointer);
|
AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe);
|
||||||
AtomPortray = AtomAdjust(AtomPortray);
|
AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus);
|
||||||
AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator);
|
AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer);
|
||||||
AtomPrimitive = AtomAdjust(AtomPrimitive);
|
AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray);
|
||||||
AtomPrintMessage = AtomAdjust(AtomPrintMessage);
|
AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator);
|
||||||
AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure);
|
AtomPrimitive = AtomAdjust(AtomPrimitive); TermPrimitive = MkAtomTerm(AtomPrimitive);
|
||||||
AtomProcedure = AtomAdjust(AtomProcedure);
|
AtomPrintMessage = AtomAdjust(AtomPrintMessage); TermPrintMessage = MkAtomTerm(AtomPrintMessage);
|
||||||
AtomProfile = AtomAdjust(AtomProfile);
|
AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure);
|
||||||
AtomProlog = AtomAdjust(AtomProlog);
|
AtomProcedure = AtomAdjust(AtomProcedure); TermProcedure = MkAtomTerm(AtomProcedure);
|
||||||
AtomQly = AtomAdjust(AtomQly);
|
AtomProfile = AtomAdjust(AtomProfile); TermProfile = MkAtomTerm(AtomProfile);
|
||||||
AtomQuery = AtomAdjust(AtomQuery);
|
AtomProlog = AtomAdjust(AtomProlog); TermProlog = MkAtomTerm(AtomProlog);
|
||||||
AtomQueue = AtomAdjust(AtomQueue);
|
AtomProtectStack = AtomAdjust(AtomProtectStack); TermProtectStack = MkAtomTerm(AtomProtectStack);
|
||||||
AtomQuiet = AtomAdjust(AtomQuiet);
|
AtomQly = AtomAdjust(AtomQly); TermQly = MkAtomTerm(AtomQly);
|
||||||
AtomRadix = AtomAdjust(AtomRadix);
|
AtomQuery = AtomAdjust(AtomQuery); TermQuery = MkAtomTerm(AtomQuery);
|
||||||
AtomRandom = AtomAdjust(AtomRandom);
|
AtomQueue = AtomAdjust(AtomQueue); TermQueue = MkAtomTerm(AtomQueue);
|
||||||
AtomRange = AtomAdjust(AtomRange);
|
AtomQuiet = AtomAdjust(AtomQuiet); TermQuiet = MkAtomTerm(AtomQuiet);
|
||||||
AtomRDiv = AtomAdjust(AtomRDiv);
|
AtomRadix = AtomAdjust(AtomRadix); TermRadix = MkAtomTerm(AtomRadix);
|
||||||
AtomRead = AtomAdjust(AtomRead);
|
AtomRandom = AtomAdjust(AtomRandom); TermRandom = MkAtomTerm(AtomRandom);
|
||||||
AtomReadOnly = AtomAdjust(AtomReadOnly);
|
AtomRange = AtomAdjust(AtomRange); TermRange = MkAtomTerm(AtomRange);
|
||||||
AtomReadWrite = AtomAdjust(AtomReadWrite);
|
AtomRDiv = AtomAdjust(AtomRDiv); TermRDiv = MkAtomTerm(AtomRDiv);
|
||||||
AtomReadutil = AtomAdjust(AtomReadutil);
|
AtomRead = AtomAdjust(AtomRead); TermRead = MkAtomTerm(AtomRead);
|
||||||
AtomReconsult = AtomAdjust(AtomReconsult);
|
AtomReadOnly = AtomAdjust(AtomReadOnly); TermReadOnly = MkAtomTerm(AtomReadOnly);
|
||||||
AtomRecordedP = AtomAdjust(AtomRecordedP);
|
AtomReadWrite = AtomAdjust(AtomReadWrite); TermReadWrite = MkAtomTerm(AtomReadWrite);
|
||||||
AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey);
|
AtomReadutil = AtomAdjust(AtomReadutil); TermReadutil = MkAtomTerm(AtomReadutil);
|
||||||
AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings);
|
AtomReconsult = AtomAdjust(AtomReconsult); TermReconsult = MkAtomTerm(AtomReconsult);
|
||||||
AtomRedoFreeze = AtomAdjust(AtomRedoFreeze);
|
AtomRecordedP = AtomAdjust(AtomRecordedP); TermRecordedP = MkAtomTerm(AtomRecordedP);
|
||||||
AtomRefoundVar = AtomAdjust(AtomRefoundVar);
|
AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey);
|
||||||
AtomRelativeTo = AtomAdjust(AtomRelativeTo);
|
AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings);
|
||||||
AtomRepeat = AtomAdjust(AtomRepeat);
|
AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze);
|
||||||
AtomRepeatSpace = AtomAdjust(AtomRepeatSpace);
|
AtomRefoundVar = AtomAdjust(AtomRefoundVar); TermRefoundVar = MkAtomTerm(AtomRefoundVar);
|
||||||
AtomReposition = AtomAdjust(AtomReposition);
|
AtomRelativeTo = AtomAdjust(AtomRelativeTo); TermRelativeTo = MkAtomTerm(AtomRelativeTo);
|
||||||
AtomRepresentationError = AtomAdjust(AtomRepresentationError);
|
AtomRepeat = AtomAdjust(AtomRepeat); TermRepeat = MkAtomTerm(AtomRepeat);
|
||||||
AtomReset = AtomAdjust(AtomReset);
|
AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace);
|
||||||
AtomResize = AtomAdjust(AtomResize);
|
AtomReposition = AtomAdjust(AtomReposition); TermReposition = MkAtomTerm(AtomReposition);
|
||||||
AtomResourceError = AtomAdjust(AtomResourceError);
|
AtomRepresentationError = AtomAdjust(AtomRepresentationError); TermRepresentationError = MkAtomTerm(AtomRepresentationError);
|
||||||
AtomRestoreRegs = AtomAdjust(AtomRestoreRegs);
|
AtomReset = AtomAdjust(AtomReset); TermReset = MkAtomTerm(AtomReset);
|
||||||
AtomRetryCounter = AtomAdjust(AtomRetryCounter);
|
AtomResize = AtomAdjust(AtomResize); TermResize = MkAtomTerm(AtomResize);
|
||||||
AtomRTree = AtomAdjust(AtomRTree);
|
AtomResourceError = AtomAdjust(AtomResourceError); TermResourceError = MkAtomTerm(AtomResourceError);
|
||||||
AtomSafe = AtomAdjust(AtomSafe);
|
AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs);
|
||||||
AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup);
|
AtomRetryCounter = AtomAdjust(AtomRetryCounter); TermRetryCounter = MkAtomTerm(AtomRetryCounter);
|
||||||
AtomSame = AtomAdjust(AtomSame);
|
AtomRTree = AtomAdjust(AtomRTree); TermRTree = MkAtomTerm(AtomRTree);
|
||||||
AtomSemic = AtomAdjust(AtomSemic);
|
AtomSafe = AtomAdjust(AtomSafe); TermSafe = MkAtomTerm(AtomSafe);
|
||||||
AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow);
|
AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup);
|
||||||
AtomSigAlarm = AtomAdjust(AtomSigAlarm);
|
AtomSame = AtomAdjust(AtomSame); TermSame = MkAtomTerm(AtomSame);
|
||||||
AtomSigBreak = AtomAdjust(AtomSigBreak);
|
AtomSemic = AtomAdjust(AtomSemic); TermSemic = MkAtomTerm(AtomSemic);
|
||||||
AtomSigCreep = AtomAdjust(AtomSigCreep);
|
AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow);
|
||||||
AtomSigDebug = AtomAdjust(AtomSigDebug);
|
AtomSigAlarm = AtomAdjust(AtomSigAlarm); TermSigAlarm = MkAtomTerm(AtomSigAlarm);
|
||||||
AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep);
|
AtomSigBreak = AtomAdjust(AtomSigBreak); TermSigBreak = MkAtomTerm(AtomSigBreak);
|
||||||
AtomSigFPE = AtomAdjust(AtomSigFPE);
|
AtomSigCreep = AtomAdjust(AtomSigCreep); TermSigCreep = MkAtomTerm(AtomSigCreep);
|
||||||
AtomSigHup = AtomAdjust(AtomSigHup);
|
AtomSigDebug = AtomAdjust(AtomSigDebug); TermSigDebug = MkAtomTerm(AtomSigDebug);
|
||||||
AtomSigInt = AtomAdjust(AtomSigInt);
|
AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep);
|
||||||
AtomSigIti = AtomAdjust(AtomSigIti);
|
AtomSigFPE = AtomAdjust(AtomSigFPE); TermSigFPE = MkAtomTerm(AtomSigFPE);
|
||||||
AtomSigPending = AtomAdjust(AtomSigPending);
|
AtomSigHup = AtomAdjust(AtomSigHup); TermSigHup = MkAtomTerm(AtomSigHup);
|
||||||
AtomSigPipe = AtomAdjust(AtomSigPipe);
|
AtomSigInt = AtomAdjust(AtomSigInt); TermSigInt = MkAtomTerm(AtomSigInt);
|
||||||
AtomSigStackDump = AtomAdjust(AtomSigStackDump);
|
AtomSigIti = AtomAdjust(AtomSigIti); TermSigIti = MkAtomTerm(AtomSigIti);
|
||||||
AtomSigStatistics = AtomAdjust(AtomSigStatistics);
|
AtomSigPending = AtomAdjust(AtomSigPending); TermSigPending = MkAtomTerm(AtomSigPending);
|
||||||
AtomSigTrace = AtomAdjust(AtomSigTrace);
|
AtomSigPipe = AtomAdjust(AtomSigPipe); TermSigPipe = MkAtomTerm(AtomSigPipe);
|
||||||
AtomSigUsr1 = AtomAdjust(AtomSigUsr1);
|
AtomSigStackDump = AtomAdjust(AtomSigStackDump); TermSigStackDump = MkAtomTerm(AtomSigStackDump);
|
||||||
AtomSigUsr2 = AtomAdjust(AtomSigUsr2);
|
AtomSigStatistics = AtomAdjust(AtomSigStatistics); TermSigStatistics = MkAtomTerm(AtomSigStatistics);
|
||||||
AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm);
|
AtomSigTrace = AtomAdjust(AtomSigTrace); TermSigTrace = MkAtomTerm(AtomSigTrace);
|
||||||
AtomSigWakeUp = AtomAdjust(AtomSigWakeUp);
|
AtomSigUsr1 = AtomAdjust(AtomSigUsr1); TermSigUsr1 = MkAtomTerm(AtomSigUsr1);
|
||||||
AtomSilent = AtomAdjust(AtomSilent);
|
AtomSigUsr2 = AtomAdjust(AtomSigUsr2); TermSigUsr2 = MkAtomTerm(AtomSigUsr2);
|
||||||
AtomSingle = AtomAdjust(AtomSingle);
|
AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm);
|
||||||
AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings);
|
AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp);
|
||||||
AtomSingleton = AtomAdjust(AtomSingleton);
|
AtomSilent = AtomAdjust(AtomSilent); TermSilent = MkAtomTerm(AtomSilent);
|
||||||
AtomSlash = AtomAdjust(AtomSlash);
|
AtomSingle = AtomAdjust(AtomSingle); TermSingle = MkAtomTerm(AtomSingle);
|
||||||
AtomSocket = AtomAdjust(AtomSocket);
|
AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings);
|
||||||
AtomSolutions = AtomAdjust(AtomSolutions);
|
AtomSingleton = AtomAdjust(AtomSingleton); TermSingleton = MkAtomTerm(AtomSingleton);
|
||||||
AtomSource = AtomAdjust(AtomSource);
|
AtomSlash = AtomAdjust(AtomSlash); TermSlash = MkAtomTerm(AtomSlash);
|
||||||
AtomSourceSink = AtomAdjust(AtomSourceSink);
|
AtomSocket = AtomAdjust(AtomSocket); TermSocket = MkAtomTerm(AtomSocket);
|
||||||
AtomSpy = AtomAdjust(AtomSpy);
|
AtomSolutions = AtomAdjust(AtomSolutions); TermSolutions = MkAtomTerm(AtomSolutions);
|
||||||
AtomStack = AtomAdjust(AtomStack);
|
AtomSource = AtomAdjust(AtomSource); TermSource = MkAtomTerm(AtomSource);
|
||||||
AtomStackFree = AtomAdjust(AtomStackFree);
|
AtomSourceSink = AtomAdjust(AtomSourceSink); TermSourceSink = MkAtomTerm(AtomSourceSink);
|
||||||
AtomStartupSavedState = AtomAdjust(AtomStartupSavedState);
|
AtomSpy = AtomAdjust(AtomSpy); TermSpy = MkAtomTerm(AtomSpy);
|
||||||
AtomStaticClause = AtomAdjust(AtomStaticClause);
|
AtomStack = AtomAdjust(AtomStack); TermStack = MkAtomTerm(AtomStack);
|
||||||
AtomStaticProcedure = AtomAdjust(AtomStaticProcedure);
|
AtomStackFree = AtomAdjust(AtomStackFree); TermStackFree = MkAtomTerm(AtomStackFree);
|
||||||
AtomStream = AtomAdjust(AtomStream);
|
AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState);
|
||||||
AtomSWIStream = AtomAdjust(AtomSWIStream);
|
AtomStaticClause = AtomAdjust(AtomStaticClause); TermStaticClause = MkAtomTerm(AtomStaticClause);
|
||||||
AtomVStream = AtomAdjust(AtomVStream);
|
AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure);
|
||||||
AtomStreams = AtomAdjust(AtomStreams);
|
AtomStream = AtomAdjust(AtomStream); TermStream = MkAtomTerm(AtomStream);
|
||||||
AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias);
|
AtomSWIStream = AtomAdjust(AtomSWIStream); TermSWIStream = MkAtomTerm(AtomSWIStream);
|
||||||
AtomStreamPos = AtomAdjust(AtomStreamPos);
|
AtomVStream = AtomAdjust(AtomVStream); TermVStream = MkAtomTerm(AtomVStream);
|
||||||
AtomStreamPosition = AtomAdjust(AtomStreamPosition);
|
AtomStreams = AtomAdjust(AtomStreams); TermStreams = MkAtomTerm(AtomStreams);
|
||||||
AtomString = AtomAdjust(AtomString);
|
AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias);
|
||||||
AtomStyleCheck = AtomAdjust(AtomStyleCheck);
|
AtomStreamPos = AtomAdjust(AtomStreamPos); TermStreamPos = MkAtomTerm(AtomStreamPos);
|
||||||
AtomSTRING = AtomAdjust(AtomSTRING);
|
AtomStreamPosition = AtomAdjust(AtomStreamPosition); TermStreamPosition = MkAtomTerm(AtomStreamPosition);
|
||||||
AtomSwi = AtomAdjust(AtomSwi);
|
AtomString = AtomAdjust(AtomString); TermString = MkAtomTerm(AtomString);
|
||||||
AtomSymbolChar = AtomAdjust(AtomSymbolChar);
|
AtomStyleCheck = AtomAdjust(AtomStyleCheck); TermStyleCheck = MkAtomTerm(AtomStyleCheck);
|
||||||
AtomSyntaxError = AtomAdjust(AtomSyntaxError);
|
AtomSTRING = AtomAdjust(AtomSTRING); TermSTRING = MkAtomTerm(AtomSTRING);
|
||||||
AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors);
|
AtomSwi = AtomAdjust(AtomSwi); TermSwi = MkAtomTerm(AtomSwi);
|
||||||
AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler);
|
AtomSymbolChar = AtomAdjust(AtomSymbolChar); TermSymbolChar = MkAtomTerm(AtomSymbolChar);
|
||||||
AtomSystem = AtomAdjust(AtomSystem);
|
AtomSyntaxError = AtomAdjust(AtomSyntaxError); TermSyntaxError = MkAtomTerm(AtomSyntaxError);
|
||||||
AtomSystemError = AtomAdjust(AtomSystemError);
|
AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors);
|
||||||
AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir);
|
AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler);
|
||||||
AtomTerm = AtomAdjust(AtomTerm);
|
AtomSystem = AtomAdjust(AtomSystem); TermSystem = MkAtomTerm(AtomSystem);
|
||||||
AtomTerms = AtomAdjust(AtomTerms);
|
AtomSystemError = AtomAdjust(AtomSystemError); TermSystemError = MkAtomTerm(AtomSystemError);
|
||||||
AtomTermExpansion = AtomAdjust(AtomTermExpansion);
|
AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir);
|
||||||
AtomText = AtomAdjust(AtomText);
|
AtomTerm = AtomAdjust(AtomTerm); TermTerm = MkAtomTerm(AtomTerm);
|
||||||
AtomTextStream = AtomAdjust(AtomTextStream);
|
AtomTerms = AtomAdjust(AtomTerms); TermTerms = MkAtomTerm(AtomTerms);
|
||||||
AtomThread = AtomAdjust(AtomThread);
|
AtomTermExpansion = AtomAdjust(AtomTermExpansion); TermTermExpansion = MkAtomTerm(AtomTermExpansion);
|
||||||
AtomThreads = AtomAdjust(AtomThreads);
|
AtomText = AtomAdjust(AtomText); TermText = MkAtomTerm(AtomText);
|
||||||
AtomThrow = AtomAdjust(AtomThrow);
|
AtomTextStream = AtomAdjust(AtomTextStream); TermTextStream = MkAtomTerm(AtomTextStream);
|
||||||
AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec);
|
AtomThread = AtomAdjust(AtomThread); TermThread = MkAtomTerm(AtomThread);
|
||||||
AtomTimeoutError = AtomAdjust(AtomTimeoutError);
|
AtomThreads = AtomAdjust(AtomThreads); TermThreads = MkAtomTerm(AtomThreads);
|
||||||
AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal);
|
AtomThrow = AtomAdjust(AtomThrow); TermThrow = MkAtomTerm(AtomThrow);
|
||||||
AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal);
|
AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec);
|
||||||
AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall);
|
AtomTimeoutError = AtomAdjust(AtomTimeoutError); TermTimeoutError = MkAtomTerm(AtomTimeoutError);
|
||||||
|
AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal);
|
||||||
|
AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal);
|
||||||
|
AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall);
|
||||||
AtomTrail = AtomAdjust(AtomTrail);
|
AtomTrail = AtomAdjust(AtomTrail);
|
||||||
AtomTrue = AtomAdjust(AtomTrue);
|
AtomTrue = AtomAdjust(AtomTrue); TermTrue = MkAtomTerm(AtomTrue);
|
||||||
AtomTty = AtomAdjust(AtomTty);
|
AtomTty = AtomAdjust(AtomTty); TermTty = MkAtomTerm(AtomTty);
|
||||||
AtomTtys = AtomAdjust(AtomTtys);
|
AtomTtys = AtomAdjust(AtomTtys); TermTtys = MkAtomTerm(AtomTtys);
|
||||||
AtomTxt = AtomAdjust(AtomTxt);
|
AtomTxt = AtomAdjust(AtomTxt); TermTxt = MkAtomTerm(AtomTxt);
|
||||||
AtomTypeError = AtomAdjust(AtomTypeError);
|
AtomTypeError = AtomAdjust(AtomTypeError); TermTypeError = MkAtomTerm(AtomTypeError);
|
||||||
AtomUndefined = AtomAdjust(AtomUndefined);
|
AtomUndefined = AtomAdjust(AtomUndefined); TermUndefined = MkAtomTerm(AtomUndefined);
|
||||||
AtomUndefp = AtomAdjust(AtomUndefp);
|
AtomUndefp = AtomAdjust(AtomUndefp); TermUndefp = MkAtomTerm(AtomUndefp);
|
||||||
AtomUnderflow = AtomAdjust(AtomUnderflow);
|
AtomUnderflow = AtomAdjust(AtomUnderflow); TermUnderflow = MkAtomTerm(AtomUnderflow);
|
||||||
AtomUnificationStack = AtomAdjust(AtomUnificationStack);
|
AtomUnificationStack = AtomAdjust(AtomUnificationStack); TermUnificationStack = MkAtomTerm(AtomUnificationStack);
|
||||||
AtomUnique = AtomAdjust(AtomUnique);
|
AtomUnique = AtomAdjust(AtomUnique); TermUnique = MkAtomTerm(AtomUnique);
|
||||||
AtomUnsignedByte = AtomAdjust(AtomUnsignedByte);
|
AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte);
|
||||||
AtomUnsignedChar = AtomAdjust(AtomUnsignedChar);
|
AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar);
|
||||||
AtomUser = AtomAdjust(AtomUser);
|
AtomUser = AtomAdjust(AtomUser); TermUser = MkAtomTerm(AtomUser);
|
||||||
AtomUserErr = AtomAdjust(AtomUserErr);
|
AtomUserErr = AtomAdjust(AtomUserErr); TermUserErr = MkAtomTerm(AtomUserErr);
|
||||||
AtomUserIn = AtomAdjust(AtomUserIn);
|
AtomUserIn = AtomAdjust(AtomUserIn); TermUserIn = MkAtomTerm(AtomUserIn);
|
||||||
AtomUserOut = AtomAdjust(AtomUserOut);
|
AtomUserOut = AtomAdjust(AtomUserOut); TermUserOut = MkAtomTerm(AtomUserOut);
|
||||||
AtomDollarVar = AtomAdjust(AtomDollarVar);
|
AtomDollarVar = AtomAdjust(AtomDollarVar); TermDollarVar = MkAtomTerm(AtomDollarVar);
|
||||||
AtomVBar = AtomAdjust(AtomVBar);
|
AtomVBar = AtomAdjust(AtomVBar); TermVBar = MkAtomTerm(AtomVBar);
|
||||||
AtomVarBranches = AtomAdjust(AtomVarBranches);
|
AtomVarBranches = AtomAdjust(AtomVarBranches); TermVarBranches = MkAtomTerm(AtomVarBranches);
|
||||||
AtomVariableNames = AtomAdjust(AtomVariableNames);
|
AtomVariableNames = AtomAdjust(AtomVariableNames); TermVariableNames = MkAtomTerm(AtomVariableNames);
|
||||||
AtomHiddenVar = AtomAdjust(AtomHiddenVar);
|
AtomHiddenVar = AtomAdjust(AtomHiddenVar); TermHiddenVar = MkAtomTerm(AtomHiddenVar);
|
||||||
AtomVariable = AtomAdjust(AtomVariable);
|
AtomVariable = AtomAdjust(AtomVariable); TermVariable = MkAtomTerm(AtomVariable);
|
||||||
AtomVerbose = AtomAdjust(AtomVerbose);
|
AtomVerbose = AtomAdjust(AtomVerbose); TermVerbose = MkAtomTerm(AtomVerbose);
|
||||||
AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch);
|
AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch);
|
||||||
AtomVersionNumber = AtomAdjust(AtomVersionNumber);
|
AtomVersionNumber = AtomAdjust(AtomVersionNumber); TermVersionNumber = MkAtomTerm(AtomVersionNumber);
|
||||||
AtomVeryVerbose = AtomAdjust(AtomVeryVerbose);
|
AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose);
|
||||||
AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal);
|
AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal);
|
||||||
AtomWarning = AtomAdjust(AtomWarning);
|
AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning);
|
||||||
AtomWhen = AtomAdjust(AtomWhen);
|
AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen);
|
||||||
AtomWrite = AtomAdjust(AtomWrite);
|
AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite);
|
||||||
AtomXml = AtomAdjust(AtomXml);
|
AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml);
|
||||||
AtomYapHacks = AtomAdjust(AtomYapHacks);
|
AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks);
|
||||||
AtomZeroDivisor = AtomAdjust(AtomZeroDivisor);
|
AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor);
|
||||||
FunctorAfInet = FuncAdjust(FunctorAfInet);
|
FunctorAfInet = FuncAdjust(FunctorAfInet);
|
||||||
FunctorAfLocal = FuncAdjust(FunctorAfLocal);
|
FunctorAfLocal = FuncAdjust(FunctorAfLocal);
|
||||||
FunctorAfUnix = FuncAdjust(FunctorAfUnix);
|
FunctorAfUnix = FuncAdjust(FunctorAfUnix);
|
||||||
@ -474,6 +477,7 @@
|
|||||||
FunctorEq = FuncAdjust(FunctorEq);
|
FunctorEq = FuncAdjust(FunctorEq);
|
||||||
FunctorError = FuncAdjust(FunctorError);
|
FunctorError = FuncAdjust(FunctorError);
|
||||||
FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);
|
FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);
|
||||||
|
FunctorException = FuncAdjust(FunctorException);
|
||||||
FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod);
|
FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod);
|
||||||
FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod);
|
FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod);
|
||||||
FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin);
|
FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin);
|
||||||
@ -516,6 +520,7 @@
|
|||||||
FunctorPrintMessage = FuncAdjust(FunctorPrintMessage);
|
FunctorPrintMessage = FuncAdjust(FunctorPrintMessage);
|
||||||
FunctorProcedure = FuncAdjust(FunctorProcedure);
|
FunctorProcedure = FuncAdjust(FunctorProcedure);
|
||||||
FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint);
|
FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint);
|
||||||
|
FunctorProtectStack = FuncAdjust(FunctorProtectStack);
|
||||||
FunctorQuery = FuncAdjust(FunctorQuery);
|
FunctorQuery = FuncAdjust(FunctorQuery);
|
||||||
FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey);
|
FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey);
|
||||||
FunctorRDiv = FuncAdjust(FunctorRDiv);
|
FunctorRDiv = FuncAdjust(FunctorRDiv);
|
||||||
|
|||||||
@ -87,6 +87,7 @@
|
|||||||
#ifdef EUROTRA
|
#ifdef EUROTRA
|
||||||
TermDollarU = AtomTermAdjust(TermDollarU);
|
TermDollarU = AtomTermAdjust(TermDollarU);
|
||||||
#endif
|
#endif
|
||||||
|
TermAnswer = AtomTermAdjust(TermAnswer);
|
||||||
|
|
||||||
USER_MODULE = AtomTermAdjust(USER_MODULE);
|
USER_MODULE = AtomTermAdjust(USER_MODULE);
|
||||||
IDB_MODULE = AtomTermAdjust(IDB_MODULE);
|
IDB_MODULE = AtomTermAdjust(IDB_MODULE);
|
||||||
@ -135,24 +136,25 @@
|
|||||||
#ifdef COROUTINING
|
#ifdef COROUTINING
|
||||||
WakeUpCode = PtoPredAdjust(WakeUpCode);
|
WakeUpCode = PtoPredAdjust(WakeUpCode);
|
||||||
#endif
|
#endif
|
||||||
PredGoalExpansion = PtoPredAdjust(PredGoalExpansion);
|
|
||||||
PredMetaCall = PtoPredAdjust(PredMetaCall);
|
|
||||||
PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall);
|
|
||||||
PredDollarCatch = PtoPredAdjust(PredDollarCatch);
|
PredDollarCatch = PtoPredAdjust(PredDollarCatch);
|
||||||
PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey);
|
|
||||||
PredLogUpdClause = PtoPredAdjust(PredLogUpdClause);
|
|
||||||
PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase);
|
|
||||||
PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0);
|
|
||||||
PredStaticClause = PtoPredAdjust(PredStaticClause);
|
|
||||||
PredThrow = PtoPredAdjust(PredThrow);
|
|
||||||
PredHandleThrow = PtoPredAdjust(PredHandleThrow);
|
|
||||||
PredIs = PtoPredAdjust(PredIs);
|
|
||||||
PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup);
|
|
||||||
PredRestoreRegs = PtoPredAdjust(PredRestoreRegs);
|
|
||||||
PredCommentHook = PtoPredAdjust(PredCommentHook);
|
|
||||||
#ifdef YAPOR
|
#ifdef YAPOR
|
||||||
PredGetwork = PtoPredAdjust(PredGetwork);
|
PredGetwork = PtoPredAdjust(PredGetwork);
|
||||||
#endif /* YAPOR */
|
#endif /* YAPOR */
|
||||||
|
PredGoalExpansion = PtoPredAdjust(PredGoalExpansion);
|
||||||
|
PredHandleThrow = PtoPredAdjust(PredHandleThrow);
|
||||||
|
PredIs = PtoPredAdjust(PredIs);
|
||||||
|
PredLogUpdClause = PtoPredAdjust(PredLogUpdClause);
|
||||||
|
PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase);
|
||||||
|
PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0);
|
||||||
|
PredMetaCall = PtoPredAdjust(PredMetaCall);
|
||||||
|
PredProtectStack = PtoPredAdjust(PredProtectStack);
|
||||||
|
PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey);
|
||||||
|
PredRestoreRegs = PtoPredAdjust(PredRestoreRegs);
|
||||||
|
PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup);
|
||||||
|
PredStaticClause = PtoPredAdjust(PredStaticClause);
|
||||||
|
PredThrow = PtoPredAdjust(PredThrow);
|
||||||
|
PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall);
|
||||||
|
PredCommentHook = PtoPredAdjust(PredCommentHook);
|
||||||
PredProcedure = PtoPredAdjust(PredProcedure);
|
PredProcedure = PtoPredAdjust(PredProcedure);
|
||||||
|
|
||||||
#ifdef LOW_LEVEL_TRACER
|
#ifdef LOW_LEVEL_TRACER
|
||||||
|
|||||||
2185
H/generated/tatoms.h
2185
H/generated/tatoms.h
File diff suppressed because it is too large
Load Diff
548
H/iatoms.h
548
H/iatoms.h
@ -1,548 +0,0 @@
|
|||||||
|
|
||||||
/* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms"
|
|
||||||
please do not update, update misc/ATOMS instead */
|
|
||||||
|
|
||||||
Atom3Dots = Yap_LookupAtom("...");
|
|
||||||
AtomAbol = Yap_FullLookupAtom("$abol");
|
|
||||||
AtomAccess = Yap_LookupAtom("access");
|
|
||||||
AtomAfInet = Yap_LookupAtom("AF_INET");
|
|
||||||
AtomAfLocal = Yap_LookupAtom("AF_LOCAL");
|
|
||||||
AtomAfUnix = Yap_LookupAtom("AF_UNIX");
|
|
||||||
AtomAlarm = Yap_FullLookupAtom("$alarm");
|
|
||||||
AtomAlias = Yap_LookupAtom("alias");
|
|
||||||
AtomAll = Yap_LookupAtom("all");
|
|
||||||
AtomAltNot = Yap_LookupAtom("not");
|
|
||||||
AtomAny = Yap_LookupAtom("any");
|
|
||||||
AtomAppend = Yap_LookupAtom("append");
|
|
||||||
AtomArg = Yap_LookupAtom("arg");
|
|
||||||
AtomArray = Yap_FullLookupAtom("$array");
|
|
||||||
AtomArrayAccess = Yap_FullLookupAtom("$array_arg");
|
|
||||||
AtomArrayOverflow = Yap_LookupAtom("array_overflow");
|
|
||||||
AtomArrayType = Yap_LookupAtom("array_type");
|
|
||||||
AtomArrow = Yap_LookupAtom("->");
|
|
||||||
AtomAttributedModule = Yap_LookupAtom("attributes_module");
|
|
||||||
AtomDoubleArrow = Yap_LookupAtom("-->");
|
|
||||||
AtomAssert = Yap_LookupAtom(":-");
|
|
||||||
AtomEmptyBrackets = Yap_LookupAtom("()");
|
|
||||||
AtomEmptySquareBrackets = Yap_LookupAtom("[]");
|
|
||||||
AtomEmptyCurlyBrackets = Yap_LookupAtom("{}");
|
|
||||||
AtomAsserta = Yap_LookupAtom("asserta");
|
|
||||||
AtomAssertaStatic = Yap_LookupAtom("asserta_static");
|
|
||||||
AtomAssertz = Yap_LookupAtom("assertz");
|
|
||||||
AtomAssertzStatic = Yap_LookupAtom("assertz_static");
|
|
||||||
AtomAt = Yap_LookupAtom("at");
|
|
||||||
AtomAtom = Yap_LookupAtom("atom");
|
|
||||||
AtomAtomic = Yap_LookupAtom("atomic");
|
|
||||||
AtomAtt = Yap_FullLookupAtom("$att");
|
|
||||||
AtomAtt1 = Yap_LookupAtom("att");
|
|
||||||
AtomAttDo = Yap_FullLookupAtom("$att_do");
|
|
||||||
AtomAttributes = Yap_LookupAtom("attributes");
|
|
||||||
AtomB = Yap_FullLookupAtom("$last_choice_pt");
|
|
||||||
AtomBatched = Yap_LookupAtom("batched");
|
|
||||||
AtomBetween = Yap_LookupAtom("between");
|
|
||||||
AtomBinary = Yap_LookupAtom("binary");
|
|
||||||
AtomBigNum = Yap_LookupAtom("big_num");
|
|
||||||
AtomBinaryStream = Yap_LookupAtom("binary_stream");
|
|
||||||
AtomBoolean = Yap_LookupAtom("boolean");
|
|
||||||
AtomBraces = Yap_LookupAtom("{}");
|
|
||||||
AtomBreak = Yap_FullLookupAtom("$break");
|
|
||||||
AtomByte = Yap_LookupAtom("byte");
|
|
||||||
AtomCArith = Yap_FullLookupAtom("$c_arith");
|
|
||||||
AtomCall = Yap_LookupAtom("call");
|
|
||||||
AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter");
|
|
||||||
AtomCallCounter = Yap_LookupAtom("call_counter");
|
|
||||||
AtomCallable = Yap_LookupAtom("callable");
|
|
||||||
AtomCatch = Yap_FullLookupAtom("$catch");
|
|
||||||
AtomChangeModule = Yap_FullLookupAtom("$change_module");
|
|
||||||
AtomChar = Yap_LookupAtom("char");
|
|
||||||
AtomCharsio = Yap_LookupAtom("charsio");
|
|
||||||
AtomCharacter = Yap_LookupAtom("character");
|
|
||||||
AtomCharacterCode = Yap_LookupAtom("character_code");
|
|
||||||
AtomChars = Yap_LookupAtom("chars");
|
|
||||||
AtomCharset = Yap_LookupAtom("charset");
|
|
||||||
AtomChType = Yap_FullLookupAtom("$char_type");
|
|
||||||
AtomCleanCall = Yap_FullLookupAtom("$clean_call");
|
|
||||||
AtomColomn = Yap_LookupAtom(":");
|
|
||||||
AtomCodeSpace = Yap_LookupAtom("code_space");
|
|
||||||
AtomCodes = Yap_LookupAtom("codes");
|
|
||||||
AtomCoInductive = Yap_LookupAtom("coinductive");
|
|
||||||
AtomComma = Yap_LookupAtom(",");
|
|
||||||
AtomCommentHook = Yap_LookupAtom("comment_hook");
|
|
||||||
AtomCompact = Yap_LookupAtom("compact");
|
|
||||||
AtomCompound = Yap_LookupAtom("compound");
|
|
||||||
AtomConsistencyError = Yap_LookupAtom("consistency_error");
|
|
||||||
AtomConsult = Yap_LookupAtom("consult");
|
|
||||||
AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot");
|
|
||||||
AtomContext = Yap_LookupAtom("context");
|
|
||||||
AtomCputime = Yap_LookupAtom("cputime");
|
|
||||||
AtomCreate = Yap_LookupAtom("create");
|
|
||||||
AtomCreep = Yap_FullLookupAtom("$creep");
|
|
||||||
AtomCryptAtoms = Yap_LookupAtom("crypt_atoms");
|
|
||||||
AtomCsult = Yap_FullLookupAtom("$csult");
|
|
||||||
AtomCurrentModule = Yap_FullLookupAtom("$current_module");
|
|
||||||
AtomCut = Yap_LookupAtom("!");
|
|
||||||
AtomCutBy = Yap_FullLookupAtom("$cut_by");
|
|
||||||
AtomDAbort = Yap_FullLookupAtom("$abort");
|
|
||||||
AtomDBLoad = Yap_FullLookupAtom("$db_load");
|
|
||||||
AtomDBREF = Yap_LookupAtom("DBRef");
|
|
||||||
AtomDBReference = Yap_LookupAtom("db_reference");
|
|
||||||
AtomDBTerm = Yap_LookupAtom("db_term");
|
|
||||||
AtomDBref = Yap_FullLookupAtom("$dbref");
|
|
||||||
AtomDInteger = Yap_FullLookupAtom("$integer");
|
|
||||||
AtomDebugMeta = Yap_FullLookupAtom("$debug_meta");
|
|
||||||
AtomDebuggerInput = Yap_LookupAtom("debugger_input");
|
|
||||||
AtomDec10 = Yap_LookupAtom("dec10");
|
|
||||||
AtomDefault = Yap_LookupAtom("default");
|
|
||||||
AtomDevNull = Yap_LookupAtom("/dev/null");
|
|
||||||
AtomDiff = Yap_LookupAtom("\\=");
|
|
||||||
AtomDirectory = Yap_LookupAtom("disrectorys");
|
|
||||||
AtomDiscontiguous = Yap_LookupAtom("discontiguous");
|
|
||||||
AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings");
|
|
||||||
AtomDollar = Yap_FullLookupAtom("$");
|
|
||||||
AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause");
|
|
||||||
AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0");
|
|
||||||
AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase");
|
|
||||||
AtomDollarU = Yap_FullLookupAtom("$u");
|
|
||||||
AtomDollarUndef = Yap_FullLookupAtom("$undef");
|
|
||||||
AtomDomainError = Yap_LookupAtom("domain_error");
|
|
||||||
AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause");
|
|
||||||
AtomDots = Yap_LookupAtom("dots");
|
|
||||||
AtomDOUBLE = Yap_FullLookupAtom("Double");
|
|
||||||
AtomDoubleSlash = Yap_FullLookupAtom("//");
|
|
||||||
AtomE = Yap_LookupAtom("e");
|
|
||||||
AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term");
|
|
||||||
AtomEQ = Yap_LookupAtom("=");
|
|
||||||
AtomEmptyAtom = Yap_LookupAtom("");
|
|
||||||
AtomEncoding = Yap_LookupAtom("encoding");
|
|
||||||
AtomEndOfStream = Yap_LookupAtom("$end_of_stream");
|
|
||||||
AtomEof = Yap_LookupAtom("end_of_file");
|
|
||||||
AtomEOfCode = Yap_LookupAtom("eof_code");
|
|
||||||
AtomEq = Yap_LookupAtom("=");
|
|
||||||
AtomError = Yap_LookupAtom("error");
|
|
||||||
AtomException = Yap_LookupAtom("exception");
|
|
||||||
AtomExtensions = Yap_LookupAtom("extensions");
|
|
||||||
AtomEvaluable = Yap_LookupAtom("evaluable");
|
|
||||||
AtomEvaluationError = Yap_LookupAtom("evaluation_error");
|
|
||||||
AtomExecutable = Yap_LookupAtom("executable");
|
|
||||||
AtomExecute = Yap_LookupAtom("execute");
|
|
||||||
AtomExecAnswers = Yap_LookupAtom("exec_answers");
|
|
||||||
AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod");
|
|
||||||
AtomExecuteWithin = Yap_FullLookupAtom("$execute_within");
|
|
||||||
AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod");
|
|
||||||
AtomExist = Yap_LookupAtom("exist");
|
|
||||||
AtomExistenceError = Yap_LookupAtom("existence_error");
|
|
||||||
AtomExoClause = Yap_FullLookupAtom("$exo_clause");
|
|
||||||
AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax");
|
|
||||||
AtomExpand = Yap_LookupAtom("expand");
|
|
||||||
AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path");
|
|
||||||
AtomExtendsions = Yap_LookupAtom("extensionh");
|
|
||||||
AtomFB = Yap_LookupAtom("fb");
|
|
||||||
AtomFail = Yap_LookupAtom("fail");
|
|
||||||
AtomFalse = Yap_LookupAtom("false");
|
|
||||||
AtomFast = Yap_FullLookupAtom("$fast");
|
|
||||||
AtomFastFail = Yap_LookupAtom("fast_fail");
|
|
||||||
AtomFileErrors = Yap_LookupAtom("file_errors");
|
|
||||||
AtomFileerrors = Yap_LookupAtom("fileerrors");
|
|
||||||
AtomFileType = Yap_LookupAtom("file_type");
|
|
||||||
AtomFirst = Yap_LookupAtom("first");
|
|
||||||
AtomFloat = Yap_LookupAtom("float");
|
|
||||||
AtomFloatFormat = Yap_LookupAtom("\%.15g");
|
|
||||||
AtomFloatOverflow = Yap_LookupAtom("float_overflow");
|
|
||||||
AtomFloatUnderflow = Yap_LookupAtom("float_underflow");
|
|
||||||
AtomFormat = Yap_LookupAtom("format");
|
|
||||||
AtomFormatAt = Yap_FullLookupAtom("$format@");
|
|
||||||
AtomFull = Yap_LookupAtom("full");
|
|
||||||
AtomFunctor = Yap_LookupAtom("functor");
|
|
||||||
AtomGT = Yap_LookupAtom(">");
|
|
||||||
AtomGVar = Yap_LookupAtom("var");
|
|
||||||
AtomGc = Yap_FullLookupAtom("$gc");
|
|
||||||
AtomGcMargin = Yap_FullLookupAtom("$gc_margin");
|
|
||||||
AtomGcTrace = Yap_FullLookupAtom("$gc_trace");
|
|
||||||
AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose");
|
|
||||||
AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose");
|
|
||||||
AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info");
|
|
||||||
AtomGetwork = Yap_FullLookupAtom("$getwork");
|
|
||||||
AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq");
|
|
||||||
AtomGlob = Yap_LookupAtom("glob");
|
|
||||||
AtomGlobal = Yap_LookupAtom("global");
|
|
||||||
AtomGlobalSp = Yap_LookupAtom("global_sp");
|
|
||||||
AtomGlobalTrie = Yap_LookupAtom("global_trie");
|
|
||||||
AtomGoalExpansion = Yap_LookupAtom("goal_expansion");
|
|
||||||
AtomHat = Yap_LookupAtom("^");
|
|
||||||
AtomHERE = Yap_LookupAtom("\n <====HERE====> \n");
|
|
||||||
AtomHandleThrow = Yap_FullLookupAtom("$handle_throw");
|
|
||||||
AtomHeap = Yap_LookupAtom("heap");
|
|
||||||
AtomHeapUsed = Yap_LookupAtom("heapused");
|
|
||||||
AtomHugeInt = Yap_LookupAtom("huge_int");
|
|
||||||
AtomIDB = Yap_LookupAtom("idb");
|
|
||||||
AtomIOMode = Yap_LookupAtom("io_mode");
|
|
||||||
AtomId = Yap_LookupAtom("id");
|
|
||||||
AtomIgnore = Yap_LookupAtom("ignore");
|
|
||||||
AtomInf = Yap_LookupAtom("inf");
|
|
||||||
AtomInfinity = Yap_LookupAtom("infinity");
|
|
||||||
AtomInitGoal = Yap_FullLookupAtom("$init_goal");
|
|
||||||
AtomInitProlog = Yap_FullLookupAtom("$init_prolog");
|
|
||||||
AtomInStackExpansion = Yap_LookupAtom("in stack expansion");
|
|
||||||
AtomInput = Yap_LookupAtom("input");
|
|
||||||
AtomInstantiationError = Yap_LookupAtom("instantiation_error");
|
|
||||||
AtomInt = Yap_LookupAtom("int");
|
|
||||||
AtomIntOverflow = Yap_LookupAtom("int_overflow");
|
|
||||||
AtomInteger = Yap_LookupAtom("integer");
|
|
||||||
AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error");
|
|
||||||
AtomIs = Yap_LookupAtom("is");
|
|
||||||
AtomKey = Yap_LookupAtom("key");
|
|
||||||
AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH");
|
|
||||||
AtomLONGINT = Yap_LookupAtom("LongInt");
|
|
||||||
AtomLOOP = Yap_LookupAtom("_LOOP_");
|
|
||||||
AtomLoopStream = Yap_LookupAtom("loop_stream");
|
|
||||||
AtomLT = Yap_LookupAtom("<");
|
|
||||||
AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within");
|
|
||||||
AtomLeash = Yap_FullLookupAtom("$leash");
|
|
||||||
AtomLeast = Yap_LookupAtom("least");
|
|
||||||
AtomLength = Yap_FullLookupAtom("length");
|
|
||||||
AtomList = Yap_LookupAtom("list");
|
|
||||||
AtomLine = Yap_LookupAtom("line");
|
|
||||||
AtomLive = Yap_FullLookupAtom("$live");
|
|
||||||
AtomLoadAnswers = Yap_LookupAtom("load_answers");
|
|
||||||
AtomLocal = Yap_LookupAtom("local");
|
|
||||||
AtomLocalSp = Yap_LookupAtom("local_sp");
|
|
||||||
AtomLocalTrie = Yap_LookupAtom("local_trie");
|
|
||||||
AtomMax = Yap_LookupAtom("max");
|
|
||||||
AtomMaximum = Yap_LookupAtom("maximum");
|
|
||||||
AtomMaxArity = Yap_LookupAtom("max_arity");
|
|
||||||
AtomMaxFiles = Yap_LookupAtom("max_files");
|
|
||||||
AtomMegaClause = Yap_FullLookupAtom("$mega_clause");
|
|
||||||
AtomMetaCall = Yap_FullLookupAtom("$call");
|
|
||||||
AtomMfClause = Yap_FullLookupAtom("$mf_clause");
|
|
||||||
AtomMin = Yap_LookupAtom("min");
|
|
||||||
AtomMinimum = Yap_LookupAtom("minimum");
|
|
||||||
AtomMinus = Yap_LookupAtom("-");
|
|
||||||
AtomModify = Yap_LookupAtom("modify");
|
|
||||||
AtomModule = Yap_LookupAtom("module");
|
|
||||||
AtomMost = Yap_LookupAtom("most");
|
|
||||||
AtomMulti = Yap_LookupAtom("multi");
|
|
||||||
AtomMultiFile = Yap_FullLookupAtom("$mf");
|
|
||||||
AtomMultiple = Yap_FullLookupAtom("multiple");
|
|
||||||
AtomMutable = Yap_LookupAtom("mutable");
|
|
||||||
AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable");
|
|
||||||
AtomMutex = Yap_LookupAtom("mutex");
|
|
||||||
AtomMyddasDB = Yap_FullLookupAtom("$myddas_db");
|
|
||||||
AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal");
|
|
||||||
AtomMyddasHost = Yap_FullLookupAtom("$myddas_host");
|
|
||||||
AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass");
|
|
||||||
AtomMyddasUser = Yap_FullLookupAtom("$myddas_user");
|
|
||||||
AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name");
|
|
||||||
AtomNan = Yap_LookupAtom("nan");
|
|
||||||
AtomNb = Yap_LookupAtom("nb");
|
|
||||||
AtomNbTerm = Yap_LookupAtom("nb_term");
|
|
||||||
AtomNew = Yap_LookupAtom("new");
|
|
||||||
AtomNewLine = Yap_LookupAtom("nl");
|
|
||||||
AtomNl = Yap_LookupAtom("nl");
|
|
||||||
AtomNoEffect = Yap_LookupAtom("no_effect");
|
|
||||||
AtomNoMemory = Yap_LookupAtom("no_memory");
|
|
||||||
AtomNone = Yap_LookupAtom("none");
|
|
||||||
AtomNonEmptyList = Yap_LookupAtom("non_empty_list");
|
|
||||||
AtomNot = Yap_LookupAtom("\\+");
|
|
||||||
AtomNotImplemented = Yap_LookupAtom("not_implemented");
|
|
||||||
AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero");
|
|
||||||
AtomNotNewline = Yap_LookupAtom("not_newline");
|
|
||||||
AtomNotZero = Yap_LookupAtom("not_zero");
|
|
||||||
AtomNumber = Yap_LookupAtom("number");
|
|
||||||
AtomOff = Yap_LookupAtom("off");
|
|
||||||
AtomOffline = Yap_LookupAtom("offline");
|
|
||||||
AtomOn = Yap_LookupAtom("on");
|
|
||||||
AtomOnline = Yap_LookupAtom("online");
|
|
||||||
AtomOpen = Yap_LookupAtom("open");
|
|
||||||
AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL");
|
|
||||||
AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support");
|
|
||||||
AtomOperator = Yap_LookupAtom("operator");
|
|
||||||
AtomOperatorPriority = Yap_LookupAtom("operator_priority");
|
|
||||||
AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier");
|
|
||||||
AtomOpt = Yap_LookupAtom("opt");
|
|
||||||
AtomOtherwise = Yap_LookupAtom("otherwise");
|
|
||||||
AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error");
|
|
||||||
AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error");
|
|
||||||
AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error");
|
|
||||||
AtomOutOfRange = Yap_LookupAtom("out_of_range");
|
|
||||||
AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error");
|
|
||||||
AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error");
|
|
||||||
AtomOutput = Yap_LookupAtom("output");
|
|
||||||
AtomParameter = Yap_LookupAtom("parameter");
|
|
||||||
AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory");
|
|
||||||
AtomPast = Yap_LookupAtom("past");
|
|
||||||
AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream");
|
|
||||||
AtomPermissionError = Yap_LookupAtom("permission_error");
|
|
||||||
AtomPi = Yap_LookupAtom("pi");
|
|
||||||
AtomPipe = Yap_LookupAtom("pipe");
|
|
||||||
AtomPlus = Yap_LookupAtom("+");
|
|
||||||
AtomPointer = Yap_LookupAtom("pointer");
|
|
||||||
AtomPortray = Yap_FullLookupAtom("portray");
|
|
||||||
AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator");
|
|
||||||
AtomPrimitive = Yap_LookupAtom("primitive");
|
|
||||||
AtomPrintMessage = Yap_LookupAtom("print_message");
|
|
||||||
AtomPrivateProcedure = Yap_LookupAtom("private_procedure");
|
|
||||||
AtomProcedure = Yap_LookupAtom("procedure");
|
|
||||||
AtomProfile = Yap_FullLookupAtom("$profile");
|
|
||||||
AtomProlog = Yap_LookupAtom("prolog");
|
|
||||||
AtomQly = Yap_LookupAtom("qly");
|
|
||||||
AtomQuery = Yap_LookupAtom("?-");
|
|
||||||
AtomQueue = Yap_LookupAtom("queue");
|
|
||||||
AtomQuiet = Yap_LookupAtom("quiet");
|
|
||||||
AtomRadix = Yap_LookupAtom("radix");
|
|
||||||
AtomRandom = Yap_LookupAtom("random");
|
|
||||||
AtomRange = Yap_LookupAtom("range");
|
|
||||||
AtomRDiv = Yap_LookupAtom("rdiv");
|
|
||||||
AtomRead = Yap_LookupAtom("read");
|
|
||||||
AtomReadOnly = Yap_LookupAtom("read_only");
|
|
||||||
AtomReadWrite = Yap_LookupAtom("read_write");
|
|
||||||
AtomReadutil = Yap_LookupAtom("readutil");
|
|
||||||
AtomReconsult = Yap_LookupAtom("reconsult");
|
|
||||||
AtomRecordedP = Yap_FullLookupAtom("$recordep");
|
|
||||||
AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key");
|
|
||||||
AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings");
|
|
||||||
AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze");
|
|
||||||
AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN");
|
|
||||||
AtomRelativeTo = Yap_FullLookupAtom("relative_to");
|
|
||||||
AtomRepeat = Yap_LookupAtom("repeat");
|
|
||||||
AtomRepeatSpace = Yap_LookupAtom("repeat ");
|
|
||||||
AtomReposition = Yap_LookupAtom("reposition");
|
|
||||||
AtomRepresentationError = Yap_LookupAtom("representation_error");
|
|
||||||
AtomReset = Yap_LookupAtom("reset");
|
|
||||||
AtomResize = Yap_LookupAtom("resize");
|
|
||||||
AtomResourceError = Yap_LookupAtom("resource_error");
|
|
||||||
AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs");
|
|
||||||
AtomRetryCounter = Yap_LookupAtom("retry_counter");
|
|
||||||
AtomRTree = Yap_LookupAtom("rtree");
|
|
||||||
AtomSafe = Yap_FullLookupAtom("$safe");
|
|
||||||
AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup");
|
|
||||||
AtomSame = Yap_LookupAtom("==");
|
|
||||||
AtomSemic = Yap_LookupAtom(";");
|
|
||||||
AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow");
|
|
||||||
AtomSigAlarm = Yap_LookupAtom("sig_alarm");
|
|
||||||
AtomSigBreak = Yap_LookupAtom("sig_break");
|
|
||||||
AtomSigCreep = Yap_LookupAtom("sig_creep");
|
|
||||||
AtomSigDebug = Yap_LookupAtom("sig_debug");
|
|
||||||
AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep");
|
|
||||||
AtomSigFPE = Yap_LookupAtom("sig_fpe");
|
|
||||||
AtomSigHup = Yap_LookupAtom("sig_hup");
|
|
||||||
AtomSigInt = Yap_LookupAtom("sig_int");
|
|
||||||
AtomSigIti = Yap_LookupAtom("sig_iti");
|
|
||||||
AtomSigPending = Yap_FullLookupAtom("$sig_pending");
|
|
||||||
AtomSigPipe = Yap_LookupAtom("sig_pipe");
|
|
||||||
AtomSigStackDump = Yap_LookupAtom("sig_stack_dump");
|
|
||||||
AtomSigStatistics = Yap_LookupAtom("sig_statistics");
|
|
||||||
AtomSigTrace = Yap_LookupAtom("sig_trace");
|
|
||||||
AtomSigUsr1 = Yap_LookupAtom("sig_usr1");
|
|
||||||
AtomSigUsr2 = Yap_LookupAtom("sig_usr2");
|
|
||||||
AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm");
|
|
||||||
AtomSigWakeUp = Yap_LookupAtom("sig_wake_up");
|
|
||||||
AtomSilent = Yap_LookupAtom("Silent");
|
|
||||||
AtomSingle = Yap_LookupAtom("single");
|
|
||||||
AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings");
|
|
||||||
AtomSingleton = Yap_LookupAtom("singleton");
|
|
||||||
AtomSlash = Yap_LookupAtom("/");
|
|
||||||
AtomSocket = Yap_LookupAtom("socket");
|
|
||||||
AtomSolutions = Yap_LookupAtom("solutions");
|
|
||||||
AtomSource = Yap_LookupAtom("source");
|
|
||||||
AtomSourceSink = Yap_LookupAtom("source_sink");
|
|
||||||
AtomSpy = Yap_FullLookupAtom("$spy");
|
|
||||||
AtomStack = Yap_LookupAtom("stack");
|
|
||||||
AtomStackFree = Yap_LookupAtom("stackfree");
|
|
||||||
AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state");
|
|
||||||
AtomStaticClause = Yap_FullLookupAtom("$static_clause");
|
|
||||||
AtomStaticProcedure = Yap_LookupAtom("static_procedure");
|
|
||||||
AtomStream = Yap_FullLookupAtom("$stream");
|
|
||||||
AtomSWIStream = Yap_FullLookupAtom("<stream>");
|
|
||||||
AtomVStream = Yap_LookupAtom("stream");
|
|
||||||
AtomStreams = Yap_LookupAtom("streams");
|
|
||||||
AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias");
|
|
||||||
AtomStreamPos = Yap_FullLookupAtom("$stream_position");
|
|
||||||
AtomStreamPosition = Yap_LookupAtom("stream_position");
|
|
||||||
AtomString = Yap_LookupAtom("string");
|
|
||||||
AtomStyleCheck = Yap_LookupAtom("style_check");
|
|
||||||
AtomSTRING = Yap_FullLookupAtom("String");
|
|
||||||
AtomSwi = Yap_LookupAtom("swi");
|
|
||||||
AtomSymbolChar = Yap_LookupAtom("symbol_char");
|
|
||||||
AtomSyntaxError = Yap_LookupAtom("syntax_error");
|
|
||||||
AtomSyntaxErrors = Yap_LookupAtom("syntax_errors");
|
|
||||||
AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler");
|
|
||||||
AtomSystem = Yap_LookupAtom("system");
|
|
||||||
AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL");
|
|
||||||
AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory");
|
|
||||||
AtomTerm = Yap_LookupAtom("term");
|
|
||||||
AtomTerms = Yap_LookupAtom("terms");
|
|
||||||
AtomTermExpansion = Yap_LookupAtom("term_expansion");
|
|
||||||
AtomText = Yap_LookupAtom("text");
|
|
||||||
AtomTextStream = Yap_LookupAtom("text_stream");
|
|
||||||
AtomThread = Yap_LookupAtom("thread");
|
|
||||||
AtomThreads = Yap_LookupAtom("threads");
|
|
||||||
AtomThrow = Yap_LookupAtom("throw");
|
|
||||||
AtomTimeOutSpec = Yap_LookupAtom("time_out_spec");
|
|
||||||
AtomTimeoutError = Yap_LookupAtom("timeout_error");
|
|
||||||
AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal");
|
|
||||||
AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal");
|
|
||||||
AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call");
|
|
||||||
AtomTrail = Yap_LookupAtom("trail");
|
|
||||||
AtomTrue = Yap_LookupAtom("true");
|
|
||||||
AtomTty = Yap_LookupAtom("tty");
|
|
||||||
AtomTtys = Yap_LookupAtom("ttys");
|
|
||||||
AtomTxt = Yap_LookupAtom("txt");
|
|
||||||
AtomTypeError = Yap_LookupAtom("type_error");
|
|
||||||
AtomUndefined = Yap_LookupAtom("undefined");
|
|
||||||
AtomUndefp = Yap_FullLookupAtom("$undefp");
|
|
||||||
AtomUnderflow = Yap_LookupAtom("underflow");
|
|
||||||
AtomUnificationStack = Yap_LookupAtom("unification_stack");
|
|
||||||
AtomUnique = Yap_LookupAtom("unique");
|
|
||||||
AtomUnsignedByte = Yap_LookupAtom("unsigned_byte");
|
|
||||||
AtomUnsignedChar = Yap_LookupAtom("unsigned_char");
|
|
||||||
AtomUser = Yap_LookupAtom("user");
|
|
||||||
AtomUserErr = Yap_LookupAtom("user_error");
|
|
||||||
AtomUserIn = Yap_LookupAtom("user_input");
|
|
||||||
AtomUserOut = Yap_LookupAtom("user_output");
|
|
||||||
AtomDollarVar = Yap_LookupAtom("$VAR");
|
|
||||||
AtomVBar = Yap_LookupAtom("|");
|
|
||||||
AtomVarBranches = Yap_LookupAtom("var_branches");
|
|
||||||
AtomVariableNames = Yap_LookupAtom("variable_names");
|
|
||||||
AtomHiddenVar = Yap_FullLookupAtom("$V");
|
|
||||||
AtomVariable = Yap_LookupAtom("variable");
|
|
||||||
AtomVerbose = Yap_LookupAtom("verbose");
|
|
||||||
AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search");
|
|
||||||
AtomVersionNumber = Yap_FullLookupAtom("$version_name");
|
|
||||||
AtomVeryVerbose = Yap_LookupAtom("very_verbose");
|
|
||||||
AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal");
|
|
||||||
AtomWarning = Yap_LookupAtom("warning");
|
|
||||||
AtomWhen = Yap_FullLookupAtom("$when");
|
|
||||||
AtomWrite = Yap_LookupAtom("write");
|
|
||||||
AtomXml = Yap_LookupAtom("xml");
|
|
||||||
AtomYapHacks = Yap_LookupAtom("yap_hacks");
|
|
||||||
AtomZeroDivisor = Yap_LookupAtom("zero_divisor");
|
|
||||||
FunctorAfInet = Yap_MkFunctor(AtomAfInet,2);
|
|
||||||
FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1);
|
|
||||||
FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1);
|
|
||||||
FunctorAltNot = Yap_MkFunctor(AtomAltNot,1);
|
|
||||||
FunctorArg = Yap_MkFunctor(AtomArg,3);
|
|
||||||
FunctorArrayEntry = Yap_MkFunctor(AtomArrayAccess,3);
|
|
||||||
FunctorArrow = Yap_MkFunctor(AtomArrow,2);
|
|
||||||
FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2);
|
|
||||||
FunctorAssert1 = Yap_MkFunctor(AtomAssert,1);
|
|
||||||
FunctorAssert = Yap_MkFunctor(AtomAssert,2);
|
|
||||||
FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2);
|
|
||||||
FunctorAtom = Yap_MkFunctor(AtomAtom,1);
|
|
||||||
FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3);
|
|
||||||
FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2);
|
|
||||||
FunctorBraces = Yap_MkFunctor(AtomBraces,1);
|
|
||||||
FunctorCall = Yap_MkFunctor(AtomCall,1);
|
|
||||||
FunctorCatch = Yap_MkFunctor(AtomCatch,3);
|
|
||||||
FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1);
|
|
||||||
FunctorChars = Yap_MkFunctor(AtomChars,2);
|
|
||||||
FunctorChars1 = Yap_MkFunctor(AtomChars,1);
|
|
||||||
FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2);
|
|
||||||
FunctorClist = Yap_MkFunctor(AtomWhen,4);
|
|
||||||
FunctorCodes = Yap_MkFunctor(AtomCodes,2);
|
|
||||||
FunctorCodes1 = Yap_MkFunctor(AtomCodes,1);
|
|
||||||
FunctorComma = Yap_MkFunctor(AtomComma,2);
|
|
||||||
FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3);
|
|
||||||
FunctorContext2 = Yap_MkFunctor(AtomContext,2);
|
|
||||||
FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1);
|
|
||||||
FunctorCreep = Yap_MkFunctor(AtomCreep,1);
|
|
||||||
FunctorCsult = Yap_MkFunctor(AtomCsult,2);
|
|
||||||
FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1);
|
|
||||||
FunctorCutBy = Yap_MkFunctor(AtomCutBy,1);
|
|
||||||
FunctorDBREF = Yap_MkFunctor(AtomDBREF,1);
|
|
||||||
FunctorDiff = Yap_MkFunctor(AtomDiff,2);
|
|
||||||
FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6);
|
|
||||||
FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6);
|
|
||||||
FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6);
|
|
||||||
FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5);
|
|
||||||
FunctorDollarVar = Yap_MkFunctor(AtomDollarVar,1);
|
|
||||||
FunctorDomainError = Yap_MkFunctor(AtomDomainError,2);
|
|
||||||
FunctorDot = Yap_MkFunctor(AtomDot,2);
|
|
||||||
FunctorDot10 = Yap_MkFunctor(AtomDot,10);
|
|
||||||
FunctorDot11 = Yap_MkFunctor(AtomDot,11);
|
|
||||||
FunctorDot12 = Yap_MkFunctor(AtomDot,12);
|
|
||||||
FunctorDot2 = Yap_MkFunctor(AtomDot,2);
|
|
||||||
FunctorDot3 = Yap_MkFunctor(AtomDot,3);
|
|
||||||
FunctorDot4 = Yap_MkFunctor(AtomDot,4);
|
|
||||||
FunctorDot5 = Yap_MkFunctor(AtomDot,5);
|
|
||||||
FunctorDot6 = Yap_MkFunctor(AtomDot,6);
|
|
||||||
FunctorDot7 = Yap_MkFunctor(AtomDot,7);
|
|
||||||
FunctorDot8 = Yap_MkFunctor(AtomDot,8);
|
|
||||||
FunctorDot9 = Yap_MkFunctor(AtomDot,9);
|
|
||||||
FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2);
|
|
||||||
FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2);
|
|
||||||
FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2);
|
|
||||||
FunctorEq = Yap_MkFunctor(AtomEq,2);
|
|
||||||
FunctorError = Yap_MkFunctor(AtomError,2);
|
|
||||||
FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);
|
|
||||||
FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2);
|
|
||||||
FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2);
|
|
||||||
FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1);
|
|
||||||
FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2);
|
|
||||||
FunctorExoClause = Yap_MkFunctor(AtomExoClause,2);
|
|
||||||
FunctorFunctor = Yap_MkFunctor(AtomFunctor,3);
|
|
||||||
FunctorGAtom = Yap_MkFunctor(AtomAtom,1);
|
|
||||||
FunctorGAtomic = Yap_MkFunctor(AtomAtomic,1);
|
|
||||||
FunctorGCompound = Yap_MkFunctor(AtomCompound,1);
|
|
||||||
FunctorGFloat = Yap_MkFunctor(AtomFloat,1);
|
|
||||||
FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2);
|
|
||||||
FunctorGInteger = Yap_MkFunctor(AtomInteger,1);
|
|
||||||
FunctorGNumber = Yap_MkFunctor(AtomNumber,1);
|
|
||||||
FunctorGPrimitive = Yap_MkFunctor(AtomPrimitive,1);
|
|
||||||
FunctorGVar = Yap_MkFunctor(AtomGVar,1);
|
|
||||||
FunctorGeneratePredInfo = Yap_MkFunctor(AtomGeneratePredInfo,4);
|
|
||||||
FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2);
|
|
||||||
FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3);
|
|
||||||
FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3);
|
|
||||||
FunctorHat = Yap_MkFunctor(AtomHat,2);
|
|
||||||
FunctorId = Yap_MkFunctor(AtomId,1);
|
|
||||||
FunctorIs = Yap_MkFunctor(AtomIs,2);
|
|
||||||
FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1);
|
|
||||||
FunctorList = Yap_MkFunctor(AtomDot,2);
|
|
||||||
FunctorLOOP = Yap_MkFunctor(AtomLOOP,1);
|
|
||||||
FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2);
|
|
||||||
FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4);
|
|
||||||
FunctorMinus = Yap_MkFunctor(AtomMinus,2);
|
|
||||||
FunctorModule = Yap_MkFunctor(AtomColomn,2);
|
|
||||||
FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5);
|
|
||||||
FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL)));
|
|
||||||
FunctorMutex = Yap_MkFunctor(AtomMutex,2);
|
|
||||||
FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2);
|
|
||||||
FunctorNBQueue = Yap_MkFunctor(AtomQueue,4);
|
|
||||||
FunctorNot = Yap_MkFunctor(AtomNot,1);
|
|
||||||
FunctorOr = Yap_MkFunctor(AtomSemic,2);
|
|
||||||
FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3);
|
|
||||||
FunctorPlus = Yap_MkFunctor(AtomPlus,2);
|
|
||||||
FunctorPortray = Yap_MkFunctor(AtomPortray,1);
|
|
||||||
FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2);
|
|
||||||
FunctorProcedure = Yap_MkFunctor(AtomProcedure,5);
|
|
||||||
FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2);
|
|
||||||
FunctorQuery = Yap_MkFunctor(AtomQuery,1);
|
|
||||||
FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6);
|
|
||||||
FunctorRDiv = Yap_MkFunctor(AtomRDiv,2);
|
|
||||||
FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3);
|
|
||||||
FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1);
|
|
||||||
FunctorResourceError = Yap_MkFunctor(AtomResourceError,1);
|
|
||||||
FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2);
|
|
||||||
FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1);
|
|
||||||
FunctorSafe = Yap_MkFunctor(AtomSafe,1);
|
|
||||||
FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4);
|
|
||||||
FunctorSame = Yap_MkFunctor(AtomSame,2);
|
|
||||||
FunctorSlash = Yap_MkFunctor(AtomSlash,2);
|
|
||||||
FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2);
|
|
||||||
FunctorStream = Yap_MkFunctor(AtomStream,1);
|
|
||||||
FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1);
|
|
||||||
FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4);
|
|
||||||
FunctorString1 = Yap_MkFunctor(AtomString,1);
|
|
||||||
FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4);
|
|
||||||
FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4);
|
|
||||||
FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1);
|
|
||||||
FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2);
|
|
||||||
FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2);
|
|
||||||
FunctorThrow = Yap_MkFunctor(AtomThrow,1);
|
|
||||||
FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2);
|
|
||||||
FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3);
|
|
||||||
FunctorTypeError = Yap_MkFunctor(AtomTypeError,2);
|
|
||||||
FunctorUMinus = Yap_MkFunctor(AtomMinus,1);
|
|
||||||
FunctorUPlus = Yap_MkFunctor(AtomPlus,1);
|
|
||||||
FunctorVBar = Yap_MkFunctor(AtomVBar,2);
|
|
||||||
FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1);
|
|
||||||
548
H/ratoms.h
548
H/ratoms.h
@ -1,548 +0,0 @@
|
|||||||
|
|
||||||
/* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms"
|
|
||||||
please do not update, update misc/ATOMS instead */
|
|
||||||
|
|
||||||
Atom3Dots = AtomAdjust(Atom3Dots);
|
|
||||||
AtomAbol = AtomAdjust(AtomAbol);
|
|
||||||
AtomAccess = AtomAdjust(AtomAccess);
|
|
||||||
AtomAfInet = AtomAdjust(AtomAfInet);
|
|
||||||
AtomAfLocal = AtomAdjust(AtomAfLocal);
|
|
||||||
AtomAfUnix = AtomAdjust(AtomAfUnix);
|
|
||||||
AtomAlarm = AtomAdjust(AtomAlarm);
|
|
||||||
AtomAlias = AtomAdjust(AtomAlias);
|
|
||||||
AtomAll = AtomAdjust(AtomAll);
|
|
||||||
AtomAltNot = AtomAdjust(AtomAltNot);
|
|
||||||
AtomAny = AtomAdjust(AtomAny);
|
|
||||||
AtomAppend = AtomAdjust(AtomAppend);
|
|
||||||
AtomArg = AtomAdjust(AtomArg);
|
|
||||||
AtomArray = AtomAdjust(AtomArray);
|
|
||||||
AtomArrayAccess = AtomAdjust(AtomArrayAccess);
|
|
||||||
AtomArrayOverflow = AtomAdjust(AtomArrayOverflow);
|
|
||||||
AtomArrayType = AtomAdjust(AtomArrayType);
|
|
||||||
AtomArrow = AtomAdjust(AtomArrow);
|
|
||||||
AtomAttributedModule = AtomAdjust(AtomAttributedModule);
|
|
||||||
AtomDoubleArrow = AtomAdjust(AtomDoubleArrow);
|
|
||||||
AtomAssert = AtomAdjust(AtomAssert);
|
|
||||||
AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets);
|
|
||||||
AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets);
|
|
||||||
AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets);
|
|
||||||
AtomAsserta = AtomAdjust(AtomAsserta);
|
|
||||||
AtomAssertaStatic = AtomAdjust(AtomAssertaStatic);
|
|
||||||
AtomAssertz = AtomAdjust(AtomAssertz);
|
|
||||||
AtomAssertzStatic = AtomAdjust(AtomAssertzStatic);
|
|
||||||
AtomAt = AtomAdjust(AtomAt);
|
|
||||||
AtomAtom = AtomAdjust(AtomAtom);
|
|
||||||
AtomAtomic = AtomAdjust(AtomAtomic);
|
|
||||||
AtomAtt = AtomAdjust(AtomAtt);
|
|
||||||
AtomAtt1 = AtomAdjust(AtomAtt1);
|
|
||||||
AtomAttDo = AtomAdjust(AtomAttDo);
|
|
||||||
AtomAttributes = AtomAdjust(AtomAttributes);
|
|
||||||
AtomB = AtomAdjust(AtomB);
|
|
||||||
AtomBatched = AtomAdjust(AtomBatched);
|
|
||||||
AtomBetween = AtomAdjust(AtomBetween);
|
|
||||||
AtomBinary = AtomAdjust(AtomBinary);
|
|
||||||
AtomBigNum = AtomAdjust(AtomBigNum);
|
|
||||||
AtomBinaryStream = AtomAdjust(AtomBinaryStream);
|
|
||||||
AtomBoolean = AtomAdjust(AtomBoolean);
|
|
||||||
AtomBraces = AtomAdjust(AtomBraces);
|
|
||||||
AtomBreak = AtomAdjust(AtomBreak);
|
|
||||||
AtomByte = AtomAdjust(AtomByte);
|
|
||||||
AtomCArith = AtomAdjust(AtomCArith);
|
|
||||||
AtomCall = AtomAdjust(AtomCall);
|
|
||||||
AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter);
|
|
||||||
AtomCallCounter = AtomAdjust(AtomCallCounter);
|
|
||||||
AtomCallable = AtomAdjust(AtomCallable);
|
|
||||||
AtomCatch = AtomAdjust(AtomCatch);
|
|
||||||
AtomChangeModule = AtomAdjust(AtomChangeModule);
|
|
||||||
AtomChar = AtomAdjust(AtomChar);
|
|
||||||
AtomCharsio = AtomAdjust(AtomCharsio);
|
|
||||||
AtomCharacter = AtomAdjust(AtomCharacter);
|
|
||||||
AtomCharacterCode = AtomAdjust(AtomCharacterCode);
|
|
||||||
AtomChars = AtomAdjust(AtomChars);
|
|
||||||
AtomCharset = AtomAdjust(AtomCharset);
|
|
||||||
AtomChType = AtomAdjust(AtomChType);
|
|
||||||
AtomCleanCall = AtomAdjust(AtomCleanCall);
|
|
||||||
AtomColomn = AtomAdjust(AtomColomn);
|
|
||||||
AtomCodeSpace = AtomAdjust(AtomCodeSpace);
|
|
||||||
AtomCodes = AtomAdjust(AtomCodes);
|
|
||||||
AtomCoInductive = AtomAdjust(AtomCoInductive);
|
|
||||||
AtomComma = AtomAdjust(AtomComma);
|
|
||||||
AtomCommentHook = AtomAdjust(AtomCommentHook);
|
|
||||||
AtomCompact = AtomAdjust(AtomCompact);
|
|
||||||
AtomCompound = AtomAdjust(AtomCompound);
|
|
||||||
AtomConsistencyError = AtomAdjust(AtomConsistencyError);
|
|
||||||
AtomConsult = AtomAdjust(AtomConsult);
|
|
||||||
AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot);
|
|
||||||
AtomContext = AtomAdjust(AtomContext);
|
|
||||||
AtomCputime = AtomAdjust(AtomCputime);
|
|
||||||
AtomCreate = AtomAdjust(AtomCreate);
|
|
||||||
AtomCreep = AtomAdjust(AtomCreep);
|
|
||||||
AtomCryptAtoms = AtomAdjust(AtomCryptAtoms);
|
|
||||||
AtomCsult = AtomAdjust(AtomCsult);
|
|
||||||
AtomCurrentModule = AtomAdjust(AtomCurrentModule);
|
|
||||||
AtomCut = AtomAdjust(AtomCut);
|
|
||||||
AtomCutBy = AtomAdjust(AtomCutBy);
|
|
||||||
AtomDAbort = AtomAdjust(AtomDAbort);
|
|
||||||
AtomDBLoad = AtomAdjust(AtomDBLoad);
|
|
||||||
AtomDBREF = AtomAdjust(AtomDBREF);
|
|
||||||
AtomDBReference = AtomAdjust(AtomDBReference);
|
|
||||||
AtomDBTerm = AtomAdjust(AtomDBTerm);
|
|
||||||
AtomDBref = AtomAdjust(AtomDBref);
|
|
||||||
AtomDInteger = AtomAdjust(AtomDInteger);
|
|
||||||
AtomDebugMeta = AtomAdjust(AtomDebugMeta);
|
|
||||||
AtomDebuggerInput = AtomAdjust(AtomDebuggerInput);
|
|
||||||
AtomDec10 = AtomAdjust(AtomDec10);
|
|
||||||
AtomDefault = AtomAdjust(AtomDefault);
|
|
||||||
AtomDevNull = AtomAdjust(AtomDevNull);
|
|
||||||
AtomDiff = AtomAdjust(AtomDiff);
|
|
||||||
AtomDirectory = AtomAdjust(AtomDirectory);
|
|
||||||
AtomDiscontiguous = AtomAdjust(AtomDiscontiguous);
|
|
||||||
AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings);
|
|
||||||
AtomDollar = AtomAdjust(AtomDollar);
|
|
||||||
AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause);
|
|
||||||
AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0);
|
|
||||||
AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase);
|
|
||||||
AtomDollarU = AtomAdjust(AtomDollarU);
|
|
||||||
AtomDollarUndef = AtomAdjust(AtomDollarUndef);
|
|
||||||
AtomDomainError = AtomAdjust(AtomDomainError);
|
|
||||||
AtomDoStaticClause = AtomAdjust(AtomDoStaticClause);
|
|
||||||
AtomDots = AtomAdjust(AtomDots);
|
|
||||||
AtomDOUBLE = AtomAdjust(AtomDOUBLE);
|
|
||||||
AtomDoubleSlash = AtomAdjust(AtomDoubleSlash);
|
|
||||||
AtomE = AtomAdjust(AtomE);
|
|
||||||
AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT);
|
|
||||||
AtomEQ = AtomAdjust(AtomEQ);
|
|
||||||
AtomEmptyAtom = AtomAdjust(AtomEmptyAtom);
|
|
||||||
AtomEncoding = AtomAdjust(AtomEncoding);
|
|
||||||
AtomEndOfStream = AtomAdjust(AtomEndOfStream);
|
|
||||||
AtomEof = AtomAdjust(AtomEof);
|
|
||||||
AtomEOfCode = AtomAdjust(AtomEOfCode);
|
|
||||||
AtomEq = AtomAdjust(AtomEq);
|
|
||||||
AtomError = AtomAdjust(AtomError);
|
|
||||||
AtomException = AtomAdjust(AtomException);
|
|
||||||
AtomExtensions = AtomAdjust(AtomExtensions);
|
|
||||||
AtomEvaluable = AtomAdjust(AtomEvaluable);
|
|
||||||
AtomEvaluationError = AtomAdjust(AtomEvaluationError);
|
|
||||||
AtomExecutable = AtomAdjust(AtomExecutable);
|
|
||||||
AtomExecute = AtomAdjust(AtomExecute);
|
|
||||||
AtomExecAnswers = AtomAdjust(AtomExecAnswers);
|
|
||||||
AtomExecuteInMod = AtomAdjust(AtomExecuteInMod);
|
|
||||||
AtomExecuteWithin = AtomAdjust(AtomExecuteWithin);
|
|
||||||
AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod);
|
|
||||||
AtomExist = AtomAdjust(AtomExist);
|
|
||||||
AtomExistenceError = AtomAdjust(AtomExistenceError);
|
|
||||||
AtomExoClause = AtomAdjust(AtomExoClause);
|
|
||||||
AtomExpectedNumber = AtomAdjust(AtomExpectedNumber);
|
|
||||||
AtomExpand = AtomAdjust(AtomExpand);
|
|
||||||
AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath);
|
|
||||||
AtomExtendsions = AtomAdjust(AtomExtendsions);
|
|
||||||
AtomFB = AtomAdjust(AtomFB);
|
|
||||||
AtomFail = AtomAdjust(AtomFail);
|
|
||||||
AtomFalse = AtomAdjust(AtomFalse);
|
|
||||||
AtomFast = AtomAdjust(AtomFast);
|
|
||||||
AtomFastFail = AtomAdjust(AtomFastFail);
|
|
||||||
AtomFileErrors = AtomAdjust(AtomFileErrors);
|
|
||||||
AtomFileerrors = AtomAdjust(AtomFileerrors);
|
|
||||||
AtomFileType = AtomAdjust(AtomFileType);
|
|
||||||
AtomFirst = AtomAdjust(AtomFirst);
|
|
||||||
AtomFloat = AtomAdjust(AtomFloat);
|
|
||||||
AtomFloatFormat = AtomAdjust(AtomFloatFormat);
|
|
||||||
AtomFloatOverflow = AtomAdjust(AtomFloatOverflow);
|
|
||||||
AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow);
|
|
||||||
AtomFormat = AtomAdjust(AtomFormat);
|
|
||||||
AtomFormatAt = AtomAdjust(AtomFormatAt);
|
|
||||||
AtomFull = AtomAdjust(AtomFull);
|
|
||||||
AtomFunctor = AtomAdjust(AtomFunctor);
|
|
||||||
AtomGT = AtomAdjust(AtomGT);
|
|
||||||
AtomGVar = AtomAdjust(AtomGVar);
|
|
||||||
AtomGc = AtomAdjust(AtomGc);
|
|
||||||
AtomGcMargin = AtomAdjust(AtomGcMargin);
|
|
||||||
AtomGcTrace = AtomAdjust(AtomGcTrace);
|
|
||||||
AtomGcVerbose = AtomAdjust(AtomGcVerbose);
|
|
||||||
AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose);
|
|
||||||
AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo);
|
|
||||||
AtomGetwork = AtomAdjust(AtomGetwork);
|
|
||||||
AtomGetworkSeq = AtomAdjust(AtomGetworkSeq);
|
|
||||||
AtomGlob = AtomAdjust(AtomGlob);
|
|
||||||
AtomGlobal = AtomAdjust(AtomGlobal);
|
|
||||||
AtomGlobalSp = AtomAdjust(AtomGlobalSp);
|
|
||||||
AtomGlobalTrie = AtomAdjust(AtomGlobalTrie);
|
|
||||||
AtomGoalExpansion = AtomAdjust(AtomGoalExpansion);
|
|
||||||
AtomHat = AtomAdjust(AtomHat);
|
|
||||||
AtomHERE = AtomAdjust(AtomHERE);
|
|
||||||
AtomHandleThrow = AtomAdjust(AtomHandleThrow);
|
|
||||||
AtomHeap = AtomAdjust(AtomHeap);
|
|
||||||
AtomHeapUsed = AtomAdjust(AtomHeapUsed);
|
|
||||||
AtomHugeInt = AtomAdjust(AtomHugeInt);
|
|
||||||
AtomIDB = AtomAdjust(AtomIDB);
|
|
||||||
AtomIOMode = AtomAdjust(AtomIOMode);
|
|
||||||
AtomId = AtomAdjust(AtomId);
|
|
||||||
AtomIgnore = AtomAdjust(AtomIgnore);
|
|
||||||
AtomInf = AtomAdjust(AtomInf);
|
|
||||||
AtomInfinity = AtomAdjust(AtomInfinity);
|
|
||||||
AtomInitGoal = AtomAdjust(AtomInitGoal);
|
|
||||||
AtomInitProlog = AtomAdjust(AtomInitProlog);
|
|
||||||
AtomInStackExpansion = AtomAdjust(AtomInStackExpansion);
|
|
||||||
AtomInput = AtomAdjust(AtomInput);
|
|
||||||
AtomInstantiationError = AtomAdjust(AtomInstantiationError);
|
|
||||||
AtomInt = AtomAdjust(AtomInt);
|
|
||||||
AtomIntOverflow = AtomAdjust(AtomIntOverflow);
|
|
||||||
AtomInteger = AtomAdjust(AtomInteger);
|
|
||||||
AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError);
|
|
||||||
AtomIs = AtomAdjust(AtomIs);
|
|
||||||
AtomKey = AtomAdjust(AtomKey);
|
|
||||||
AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath);
|
|
||||||
AtomLONGINT = AtomAdjust(AtomLONGINT);
|
|
||||||
AtomLOOP = AtomAdjust(AtomLOOP);
|
|
||||||
AtomLoopStream = AtomAdjust(AtomLoopStream);
|
|
||||||
AtomLT = AtomAdjust(AtomLT);
|
|
||||||
AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin);
|
|
||||||
AtomLeash = AtomAdjust(AtomLeash);
|
|
||||||
AtomLeast = AtomAdjust(AtomLeast);
|
|
||||||
AtomLength = AtomAdjust(AtomLength);
|
|
||||||
AtomList = AtomAdjust(AtomList);
|
|
||||||
AtomLine = AtomAdjust(AtomLine);
|
|
||||||
AtomLive = AtomAdjust(AtomLive);
|
|
||||||
AtomLoadAnswers = AtomAdjust(AtomLoadAnswers);
|
|
||||||
AtomLocal = AtomAdjust(AtomLocal);
|
|
||||||
AtomLocalSp = AtomAdjust(AtomLocalSp);
|
|
||||||
AtomLocalTrie = AtomAdjust(AtomLocalTrie);
|
|
||||||
AtomMax = AtomAdjust(AtomMax);
|
|
||||||
AtomMaximum = AtomAdjust(AtomMaximum);
|
|
||||||
AtomMaxArity = AtomAdjust(AtomMaxArity);
|
|
||||||
AtomMaxFiles = AtomAdjust(AtomMaxFiles);
|
|
||||||
AtomMegaClause = AtomAdjust(AtomMegaClause);
|
|
||||||
AtomMetaCall = AtomAdjust(AtomMetaCall);
|
|
||||||
AtomMfClause = AtomAdjust(AtomMfClause);
|
|
||||||
AtomMin = AtomAdjust(AtomMin);
|
|
||||||
AtomMinimum = AtomAdjust(AtomMinimum);
|
|
||||||
AtomMinus = AtomAdjust(AtomMinus);
|
|
||||||
AtomModify = AtomAdjust(AtomModify);
|
|
||||||
AtomModule = AtomAdjust(AtomModule);
|
|
||||||
AtomMost = AtomAdjust(AtomMost);
|
|
||||||
AtomMulti = AtomAdjust(AtomMulti);
|
|
||||||
AtomMultiFile = AtomAdjust(AtomMultiFile);
|
|
||||||
AtomMultiple = AtomAdjust(AtomMultiple);
|
|
||||||
AtomMutable = AtomAdjust(AtomMutable);
|
|
||||||
AtomMutableVariable = AtomAdjust(AtomMutableVariable);
|
|
||||||
AtomMutex = AtomAdjust(AtomMutex);
|
|
||||||
AtomMyddasDB = AtomAdjust(AtomMyddasDB);
|
|
||||||
AtomMyddasGoal = AtomAdjust(AtomMyddasGoal);
|
|
||||||
AtomMyddasHost = AtomAdjust(AtomMyddasHost);
|
|
||||||
AtomMyddasPass = AtomAdjust(AtomMyddasPass);
|
|
||||||
AtomMyddasUser = AtomAdjust(AtomMyddasUser);
|
|
||||||
AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName);
|
|
||||||
AtomNan = AtomAdjust(AtomNan);
|
|
||||||
AtomNb = AtomAdjust(AtomNb);
|
|
||||||
AtomNbTerm = AtomAdjust(AtomNbTerm);
|
|
||||||
AtomNew = AtomAdjust(AtomNew);
|
|
||||||
AtomNewLine = AtomAdjust(AtomNewLine);
|
|
||||||
AtomNl = AtomAdjust(AtomNl);
|
|
||||||
AtomNoEffect = AtomAdjust(AtomNoEffect);
|
|
||||||
AtomNoMemory = AtomAdjust(AtomNoMemory);
|
|
||||||
AtomNone = AtomAdjust(AtomNone);
|
|
||||||
AtomNonEmptyList = AtomAdjust(AtomNonEmptyList);
|
|
||||||
AtomNot = AtomAdjust(AtomNot);
|
|
||||||
AtomNotImplemented = AtomAdjust(AtomNotImplemented);
|
|
||||||
AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero);
|
|
||||||
AtomNotNewline = AtomAdjust(AtomNotNewline);
|
|
||||||
AtomNotZero = AtomAdjust(AtomNotZero);
|
|
||||||
AtomNumber = AtomAdjust(AtomNumber);
|
|
||||||
AtomOff = AtomAdjust(AtomOff);
|
|
||||||
AtomOffline = AtomAdjust(AtomOffline);
|
|
||||||
AtomOn = AtomAdjust(AtomOn);
|
|
||||||
AtomOnline = AtomAdjust(AtomOnline);
|
|
||||||
AtomOpen = AtomAdjust(AtomOpen);
|
|
||||||
AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError);
|
|
||||||
AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport);
|
|
||||||
AtomOperator = AtomAdjust(AtomOperator);
|
|
||||||
AtomOperatorPriority = AtomAdjust(AtomOperatorPriority);
|
|
||||||
AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier);
|
|
||||||
AtomOpt = AtomAdjust(AtomOpt);
|
|
||||||
AtomOtherwise = AtomAdjust(AtomOtherwise);
|
|
||||||
AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError);
|
|
||||||
AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError);
|
|
||||||
AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError);
|
|
||||||
AtomOutOfRange = AtomAdjust(AtomOutOfRange);
|
|
||||||
AtomOutOfStackError = AtomAdjust(AtomOutOfStackError);
|
|
||||||
AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError);
|
|
||||||
AtomOutput = AtomAdjust(AtomOutput);
|
|
||||||
AtomParameter = AtomAdjust(AtomParameter);
|
|
||||||
AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir);
|
|
||||||
AtomPast = AtomAdjust(AtomPast);
|
|
||||||
AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream);
|
|
||||||
AtomPermissionError = AtomAdjust(AtomPermissionError);
|
|
||||||
AtomPi = AtomAdjust(AtomPi);
|
|
||||||
AtomPipe = AtomAdjust(AtomPipe);
|
|
||||||
AtomPlus = AtomAdjust(AtomPlus);
|
|
||||||
AtomPointer = AtomAdjust(AtomPointer);
|
|
||||||
AtomPortray = AtomAdjust(AtomPortray);
|
|
||||||
AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator);
|
|
||||||
AtomPrimitive = AtomAdjust(AtomPrimitive);
|
|
||||||
AtomPrintMessage = AtomAdjust(AtomPrintMessage);
|
|
||||||
AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure);
|
|
||||||
AtomProcedure = AtomAdjust(AtomProcedure);
|
|
||||||
AtomProfile = AtomAdjust(AtomProfile);
|
|
||||||
AtomProlog = AtomAdjust(AtomProlog);
|
|
||||||
AtomQly = AtomAdjust(AtomQly);
|
|
||||||
AtomQuery = AtomAdjust(AtomQuery);
|
|
||||||
AtomQueue = AtomAdjust(AtomQueue);
|
|
||||||
AtomQuiet = AtomAdjust(AtomQuiet);
|
|
||||||
AtomRadix = AtomAdjust(AtomRadix);
|
|
||||||
AtomRandom = AtomAdjust(AtomRandom);
|
|
||||||
AtomRange = AtomAdjust(AtomRange);
|
|
||||||
AtomRDiv = AtomAdjust(AtomRDiv);
|
|
||||||
AtomRead = AtomAdjust(AtomRead);
|
|
||||||
AtomReadOnly = AtomAdjust(AtomReadOnly);
|
|
||||||
AtomReadWrite = AtomAdjust(AtomReadWrite);
|
|
||||||
AtomReadutil = AtomAdjust(AtomReadutil);
|
|
||||||
AtomReconsult = AtomAdjust(AtomReconsult);
|
|
||||||
AtomRecordedP = AtomAdjust(AtomRecordedP);
|
|
||||||
AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey);
|
|
||||||
AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings);
|
|
||||||
AtomRedoFreeze = AtomAdjust(AtomRedoFreeze);
|
|
||||||
AtomRefoundVar = AtomAdjust(AtomRefoundVar);
|
|
||||||
AtomRelativeTo = AtomAdjust(AtomRelativeTo);
|
|
||||||
AtomRepeat = AtomAdjust(AtomRepeat);
|
|
||||||
AtomRepeatSpace = AtomAdjust(AtomRepeatSpace);
|
|
||||||
AtomReposition = AtomAdjust(AtomReposition);
|
|
||||||
AtomRepresentationError = AtomAdjust(AtomRepresentationError);
|
|
||||||
AtomReset = AtomAdjust(AtomReset);
|
|
||||||
AtomResize = AtomAdjust(AtomResize);
|
|
||||||
AtomResourceError = AtomAdjust(AtomResourceError);
|
|
||||||
AtomRestoreRegs = AtomAdjust(AtomRestoreRegs);
|
|
||||||
AtomRetryCounter = AtomAdjust(AtomRetryCounter);
|
|
||||||
AtomRTree = AtomAdjust(AtomRTree);
|
|
||||||
AtomSafe = AtomAdjust(AtomSafe);
|
|
||||||
AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup);
|
|
||||||
AtomSame = AtomAdjust(AtomSame);
|
|
||||||
AtomSemic = AtomAdjust(AtomSemic);
|
|
||||||
AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow);
|
|
||||||
AtomSigAlarm = AtomAdjust(AtomSigAlarm);
|
|
||||||
AtomSigBreak = AtomAdjust(AtomSigBreak);
|
|
||||||
AtomSigCreep = AtomAdjust(AtomSigCreep);
|
|
||||||
AtomSigDebug = AtomAdjust(AtomSigDebug);
|
|
||||||
AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep);
|
|
||||||
AtomSigFPE = AtomAdjust(AtomSigFPE);
|
|
||||||
AtomSigHup = AtomAdjust(AtomSigHup);
|
|
||||||
AtomSigInt = AtomAdjust(AtomSigInt);
|
|
||||||
AtomSigIti = AtomAdjust(AtomSigIti);
|
|
||||||
AtomSigPending = AtomAdjust(AtomSigPending);
|
|
||||||
AtomSigPipe = AtomAdjust(AtomSigPipe);
|
|
||||||
AtomSigStackDump = AtomAdjust(AtomSigStackDump);
|
|
||||||
AtomSigStatistics = AtomAdjust(AtomSigStatistics);
|
|
||||||
AtomSigTrace = AtomAdjust(AtomSigTrace);
|
|
||||||
AtomSigUsr1 = AtomAdjust(AtomSigUsr1);
|
|
||||||
AtomSigUsr2 = AtomAdjust(AtomSigUsr2);
|
|
||||||
AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm);
|
|
||||||
AtomSigWakeUp = AtomAdjust(AtomSigWakeUp);
|
|
||||||
AtomSilent = AtomAdjust(AtomSilent);
|
|
||||||
AtomSingle = AtomAdjust(AtomSingle);
|
|
||||||
AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings);
|
|
||||||
AtomSingleton = AtomAdjust(AtomSingleton);
|
|
||||||
AtomSlash = AtomAdjust(AtomSlash);
|
|
||||||
AtomSocket = AtomAdjust(AtomSocket);
|
|
||||||
AtomSolutions = AtomAdjust(AtomSolutions);
|
|
||||||
AtomSource = AtomAdjust(AtomSource);
|
|
||||||
AtomSourceSink = AtomAdjust(AtomSourceSink);
|
|
||||||
AtomSpy = AtomAdjust(AtomSpy);
|
|
||||||
AtomStack = AtomAdjust(AtomStack);
|
|
||||||
AtomStackFree = AtomAdjust(AtomStackFree);
|
|
||||||
AtomStartupSavedState = AtomAdjust(AtomStartupSavedState);
|
|
||||||
AtomStaticClause = AtomAdjust(AtomStaticClause);
|
|
||||||
AtomStaticProcedure = AtomAdjust(AtomStaticProcedure);
|
|
||||||
AtomStream = AtomAdjust(AtomStream);
|
|
||||||
AtomSWIStream = AtomAdjust(AtomSWIStream);
|
|
||||||
AtomVStream = AtomAdjust(AtomVStream);
|
|
||||||
AtomStreams = AtomAdjust(AtomStreams);
|
|
||||||
AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias);
|
|
||||||
AtomStreamPos = AtomAdjust(AtomStreamPos);
|
|
||||||
AtomStreamPosition = AtomAdjust(AtomStreamPosition);
|
|
||||||
AtomString = AtomAdjust(AtomString);
|
|
||||||
AtomStyleCheck = AtomAdjust(AtomStyleCheck);
|
|
||||||
AtomSTRING = AtomAdjust(AtomSTRING);
|
|
||||||
AtomSwi = AtomAdjust(AtomSwi);
|
|
||||||
AtomSymbolChar = AtomAdjust(AtomSymbolChar);
|
|
||||||
AtomSyntaxError = AtomAdjust(AtomSyntaxError);
|
|
||||||
AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors);
|
|
||||||
AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler);
|
|
||||||
AtomSystem = AtomAdjust(AtomSystem);
|
|
||||||
AtomSystemError = AtomAdjust(AtomSystemError);
|
|
||||||
AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir);
|
|
||||||
AtomTerm = AtomAdjust(AtomTerm);
|
|
||||||
AtomTerms = AtomAdjust(AtomTerms);
|
|
||||||
AtomTermExpansion = AtomAdjust(AtomTermExpansion);
|
|
||||||
AtomText = AtomAdjust(AtomText);
|
|
||||||
AtomTextStream = AtomAdjust(AtomTextStream);
|
|
||||||
AtomThread = AtomAdjust(AtomThread);
|
|
||||||
AtomThreads = AtomAdjust(AtomThreads);
|
|
||||||
AtomThrow = AtomAdjust(AtomThrow);
|
|
||||||
AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec);
|
|
||||||
AtomTimeoutError = AtomAdjust(AtomTimeoutError);
|
|
||||||
AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal);
|
|
||||||
AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal);
|
|
||||||
AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall);
|
|
||||||
AtomTrail = AtomAdjust(AtomTrail);
|
|
||||||
AtomTrue = AtomAdjust(AtomTrue);
|
|
||||||
AtomTty = AtomAdjust(AtomTty);
|
|
||||||
AtomTtys = AtomAdjust(AtomTtys);
|
|
||||||
AtomTxt = AtomAdjust(AtomTxt);
|
|
||||||
AtomTypeError = AtomAdjust(AtomTypeError);
|
|
||||||
AtomUndefined = AtomAdjust(AtomUndefined);
|
|
||||||
AtomUndefp = AtomAdjust(AtomUndefp);
|
|
||||||
AtomUnderflow = AtomAdjust(AtomUnderflow);
|
|
||||||
AtomUnificationStack = AtomAdjust(AtomUnificationStack);
|
|
||||||
AtomUnique = AtomAdjust(AtomUnique);
|
|
||||||
AtomUnsignedByte = AtomAdjust(AtomUnsignedByte);
|
|
||||||
AtomUnsignedChar = AtomAdjust(AtomUnsignedChar);
|
|
||||||
AtomUser = AtomAdjust(AtomUser);
|
|
||||||
AtomUserErr = AtomAdjust(AtomUserErr);
|
|
||||||
AtomUserIn = AtomAdjust(AtomUserIn);
|
|
||||||
AtomUserOut = AtomAdjust(AtomUserOut);
|
|
||||||
AtomDollarVar = AtomAdjust(AtomDollarVar);
|
|
||||||
AtomVBar = AtomAdjust(AtomVBar);
|
|
||||||
AtomVarBranches = AtomAdjust(AtomVarBranches);
|
|
||||||
AtomVariableNames = AtomAdjust(AtomVariableNames);
|
|
||||||
AtomHiddenVar = AtomAdjust(AtomHiddenVar);
|
|
||||||
AtomVariable = AtomAdjust(AtomVariable);
|
|
||||||
AtomVerbose = AtomAdjust(AtomVerbose);
|
|
||||||
AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch);
|
|
||||||
AtomVersionNumber = AtomAdjust(AtomVersionNumber);
|
|
||||||
AtomVeryVerbose = AtomAdjust(AtomVeryVerbose);
|
|
||||||
AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal);
|
|
||||||
AtomWarning = AtomAdjust(AtomWarning);
|
|
||||||
AtomWhen = AtomAdjust(AtomWhen);
|
|
||||||
AtomWrite = AtomAdjust(AtomWrite);
|
|
||||||
AtomXml = AtomAdjust(AtomXml);
|
|
||||||
AtomYapHacks = AtomAdjust(AtomYapHacks);
|
|
||||||
AtomZeroDivisor = AtomAdjust(AtomZeroDivisor);
|
|
||||||
FunctorAfInet = FuncAdjust(FunctorAfInet);
|
|
||||||
FunctorAfLocal = FuncAdjust(FunctorAfLocal);
|
|
||||||
FunctorAfUnix = FuncAdjust(FunctorAfUnix);
|
|
||||||
FunctorAltNot = FuncAdjust(FunctorAltNot);
|
|
||||||
FunctorArg = FuncAdjust(FunctorArg);
|
|
||||||
FunctorArrayEntry = FuncAdjust(FunctorArrayEntry);
|
|
||||||
FunctorArrow = FuncAdjust(FunctorArrow);
|
|
||||||
FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow);
|
|
||||||
FunctorAssert1 = FuncAdjust(FunctorAssert1);
|
|
||||||
FunctorAssert = FuncAdjust(FunctorAssert);
|
|
||||||
FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne);
|
|
||||||
FunctorAtom = FuncAdjust(FunctorAtom);
|
|
||||||
FunctorAtt1 = FuncAdjust(FunctorAtt1);
|
|
||||||
FunctorAttGoal = FuncAdjust(FunctorAttGoal);
|
|
||||||
FunctorBraces = FuncAdjust(FunctorBraces);
|
|
||||||
FunctorCall = FuncAdjust(FunctorCall);
|
|
||||||
FunctorCatch = FuncAdjust(FunctorCatch);
|
|
||||||
FunctorChangeModule = FuncAdjust(FunctorChangeModule);
|
|
||||||
FunctorChars = FuncAdjust(FunctorChars);
|
|
||||||
FunctorChars1 = FuncAdjust(FunctorChars1);
|
|
||||||
FunctorCleanCall = FuncAdjust(FunctorCleanCall);
|
|
||||||
FunctorClist = FuncAdjust(FunctorClist);
|
|
||||||
FunctorCodes = FuncAdjust(FunctorCodes);
|
|
||||||
FunctorCodes1 = FuncAdjust(FunctorCodes1);
|
|
||||||
FunctorComma = FuncAdjust(FunctorComma);
|
|
||||||
FunctorCommentHook = FuncAdjust(FunctorCommentHook);
|
|
||||||
FunctorContext2 = FuncAdjust(FunctorContext2);
|
|
||||||
FunctorConsistencyError = FuncAdjust(FunctorConsistencyError);
|
|
||||||
FunctorCreep = FuncAdjust(FunctorCreep);
|
|
||||||
FunctorCsult = FuncAdjust(FunctorCsult);
|
|
||||||
FunctorCurrentModule = FuncAdjust(FunctorCurrentModule);
|
|
||||||
FunctorCutBy = FuncAdjust(FunctorCutBy);
|
|
||||||
FunctorDBREF = FuncAdjust(FunctorDBREF);
|
|
||||||
FunctorDiff = FuncAdjust(FunctorDiff);
|
|
||||||
FunctorDoLogUpdClause = FuncAdjust(FunctorDoLogUpdClause);
|
|
||||||
FunctorDoLogUpdClause0 = FuncAdjust(FunctorDoLogUpdClause0);
|
|
||||||
FunctorDoLogUpdClauseErase = FuncAdjust(FunctorDoLogUpdClauseErase);
|
|
||||||
FunctorDoStaticClause = FuncAdjust(FunctorDoStaticClause);
|
|
||||||
FunctorDollarVar = FuncAdjust(FunctorDollarVar);
|
|
||||||
FunctorDomainError = FuncAdjust(FunctorDomainError);
|
|
||||||
FunctorDot = FuncAdjust(FunctorDot);
|
|
||||||
FunctorDot10 = FuncAdjust(FunctorDot10);
|
|
||||||
FunctorDot11 = FuncAdjust(FunctorDot11);
|
|
||||||
FunctorDot12 = FuncAdjust(FunctorDot12);
|
|
||||||
FunctorDot2 = FuncAdjust(FunctorDot2);
|
|
||||||
FunctorDot3 = FuncAdjust(FunctorDot3);
|
|
||||||
FunctorDot4 = FuncAdjust(FunctorDot4);
|
|
||||||
FunctorDot5 = FuncAdjust(FunctorDot5);
|
|
||||||
FunctorDot6 = FuncAdjust(FunctorDot6);
|
|
||||||
FunctorDot7 = FuncAdjust(FunctorDot7);
|
|
||||||
FunctorDot8 = FuncAdjust(FunctorDot8);
|
|
||||||
FunctorDot9 = FuncAdjust(FunctorDot9);
|
|
||||||
FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash);
|
|
||||||
FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets);
|
|
||||||
FunctorEmptyCurlyBrackets = FuncAdjust(FunctorEmptyCurlyBrackets);
|
|
||||||
FunctorEq = FuncAdjust(FunctorEq);
|
|
||||||
FunctorError = FuncAdjust(FunctorError);
|
|
||||||
FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);
|
|
||||||
FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod);
|
|
||||||
FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod);
|
|
||||||
FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin);
|
|
||||||
FunctorExistenceError = FuncAdjust(FunctorExistenceError);
|
|
||||||
FunctorExoClause = FuncAdjust(FunctorExoClause);
|
|
||||||
FunctorFunctor = FuncAdjust(FunctorFunctor);
|
|
||||||
FunctorGAtom = FuncAdjust(FunctorGAtom);
|
|
||||||
FunctorGAtomic = FuncAdjust(FunctorGAtomic);
|
|
||||||
FunctorGCompound = FuncAdjust(FunctorGCompound);
|
|
||||||
FunctorGFloat = FuncAdjust(FunctorGFloat);
|
|
||||||
FunctorGFormatAt = FuncAdjust(FunctorGFormatAt);
|
|
||||||
FunctorGInteger = FuncAdjust(FunctorGInteger);
|
|
||||||
FunctorGNumber = FuncAdjust(FunctorGNumber);
|
|
||||||
FunctorGPrimitive = FuncAdjust(FunctorGPrimitive);
|
|
||||||
FunctorGVar = FuncAdjust(FunctorGVar);
|
|
||||||
FunctorGeneratePredInfo = FuncAdjust(FunctorGeneratePredInfo);
|
|
||||||
FunctorGoalExpansion2 = FuncAdjust(FunctorGoalExpansion2);
|
|
||||||
FunctorGoalExpansion = FuncAdjust(FunctorGoalExpansion);
|
|
||||||
FunctorHandleThrow = FuncAdjust(FunctorHandleThrow);
|
|
||||||
FunctorHat = FuncAdjust(FunctorHat);
|
|
||||||
FunctorId = FuncAdjust(FunctorId);
|
|
||||||
FunctorIs = FuncAdjust(FunctorIs);
|
|
||||||
FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin);
|
|
||||||
FunctorList = FuncAdjust(FunctorList);
|
|
||||||
FunctorLOOP = FuncAdjust(FunctorLOOP);
|
|
||||||
FunctorMegaClause = FuncAdjust(FunctorMegaClause);
|
|
||||||
FunctorMetaCall = FuncAdjust(FunctorMetaCall);
|
|
||||||
FunctorMinus = FuncAdjust(FunctorMinus);
|
|
||||||
FunctorModule = FuncAdjust(FunctorModule);
|
|
||||||
FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause);
|
|
||||||
FunctorMutable = FuncAdjust(FunctorMutable);
|
|
||||||
FunctorMutex = FuncAdjust(FunctorMutex);
|
|
||||||
FunctorNotImplemented = FuncAdjust(FunctorNotImplemented);
|
|
||||||
FunctorNBQueue = FuncAdjust(FunctorNBQueue);
|
|
||||||
FunctorNot = FuncAdjust(FunctorNot);
|
|
||||||
FunctorOr = FuncAdjust(FunctorOr);
|
|
||||||
FunctorPermissionError = FuncAdjust(FunctorPermissionError);
|
|
||||||
FunctorPlus = FuncAdjust(FunctorPlus);
|
|
||||||
FunctorPortray = FuncAdjust(FunctorPortray);
|
|
||||||
FunctorPrintMessage = FuncAdjust(FunctorPrintMessage);
|
|
||||||
FunctorProcedure = FuncAdjust(FunctorProcedure);
|
|
||||||
FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint);
|
|
||||||
FunctorQuery = FuncAdjust(FunctorQuery);
|
|
||||||
FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey);
|
|
||||||
FunctorRDiv = FuncAdjust(FunctorRDiv);
|
|
||||||
FunctorRedoFreeze = FuncAdjust(FunctorRedoFreeze);
|
|
||||||
FunctorRepresentationError = FuncAdjust(FunctorRepresentationError);
|
|
||||||
FunctorResourceError = FuncAdjust(FunctorResourceError);
|
|
||||||
FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs);
|
|
||||||
FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1);
|
|
||||||
FunctorSafe = FuncAdjust(FunctorSafe);
|
|
||||||
FunctorSafeCallCleanup = FuncAdjust(FunctorSafeCallCleanup);
|
|
||||||
FunctorSame = FuncAdjust(FunctorSame);
|
|
||||||
FunctorSlash = FuncAdjust(FunctorSlash);
|
|
||||||
FunctorStaticClause = FuncAdjust(FunctorStaticClause);
|
|
||||||
FunctorStream = FuncAdjust(FunctorStream);
|
|
||||||
FunctorStreamEOS = FuncAdjust(FunctorStreamEOS);
|
|
||||||
FunctorStreamPos = FuncAdjust(FunctorStreamPos);
|
|
||||||
FunctorString1 = FuncAdjust(FunctorString1);
|
|
||||||
FunctorStyleCheck = FuncAdjust(FunctorStyleCheck);
|
|
||||||
FunctorSyntaxError = FuncAdjust(FunctorSyntaxError);
|
|
||||||
FunctorShortSyntaxError = FuncAdjust(FunctorShortSyntaxError);
|
|
||||||
FunctorTermExpansion = FuncAdjust(FunctorTermExpansion);
|
|
||||||
FunctorThreadRun = FuncAdjust(FunctorThreadRun);
|
|
||||||
FunctorThrow = FuncAdjust(FunctorThrow);
|
|
||||||
FunctorTimeoutError = FuncAdjust(FunctorTimeoutError);
|
|
||||||
FunctorTraceMetaCall = FuncAdjust(FunctorTraceMetaCall);
|
|
||||||
FunctorTypeError = FuncAdjust(FunctorTypeError);
|
|
||||||
FunctorUMinus = FuncAdjust(FunctorUMinus);
|
|
||||||
FunctorUPlus = FuncAdjust(FunctorUPlus);
|
|
||||||
FunctorVBar = FuncAdjust(FunctorVBar);
|
|
||||||
FunctorHiddenVar = FuncAdjust(FunctorHiddenVar);
|
|
||||||
1506
H/tatoms.h
1506
H/tatoms.h
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user