2017-02-20 15:28:46 +00:00
|
|
|
|
|
|
|
|
/* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms"
|
|
|
|
|
{lease do not update, update misc/ATOMS instead */
|
|
|
|
|
|
|
|
|
|
Atom3Dots = AtomAdjust(Atom3Dots);
|
|
|
|
|
AtomAbol = AtomAdjust(AtomAbol); TermAbol = MkAtomTerm(AtomAbol);
|
|
|
|
|
AtomAccess = AtomAdjust(AtomAccess); TermAccess = MkAtomTerm(AtomAccess);
|
|
|
|
|
AtomAfInet = AtomAdjust(AtomAfInet); TermAfInet = MkAtomTerm(AtomAfInet);
|
|
|
|
|
AtomAfLocal = AtomAdjust(AtomAfLocal); TermAfLocal = MkAtomTerm(AtomAfLocal);
|
|
|
|
|
AtomAfUnix = AtomAdjust(AtomAfUnix); TermAfUnix = MkAtomTerm(AtomAfUnix);
|
|
|
|
|
AtomAlarm = AtomAdjust(AtomAlarm); TermAlarm = MkAtomTerm(AtomAlarm);
|
|
|
|
|
AtomAlias = AtomAdjust(AtomAlias); TermAlias = MkAtomTerm(AtomAlias);
|
|
|
|
|
AtomAll = AtomAdjust(AtomAll); TermAll = MkAtomTerm(AtomAll);
|
|
|
|
|
AtomAltNot = AtomAdjust(AtomAltNot); TermAltNot = MkAtomTerm(AtomAltNot);
|
|
|
|
|
AtomAnswer = AtomAdjust(AtomAnswer); TermAnswer = MkAtomTerm(AtomAnswer);
|
|
|
|
|
AtomAny = AtomAdjust(AtomAny); TermAny = MkAtomTerm(AtomAny);
|
|
|
|
|
AtomAppend = AtomAdjust(AtomAppend); TermAppend = MkAtomTerm(AtomAppend);
|
|
|
|
|
AtomArg = AtomAdjust(AtomArg); TermArg = MkAtomTerm(AtomArg);
|
|
|
|
|
AtomArray = AtomAdjust(AtomArray); TermArray = MkAtomTerm(AtomArray);
|
|
|
|
|
AtomArrayAccess = AtomAdjust(AtomArrayAccess); TermArrayAccess = MkAtomTerm(AtomArrayAccess);
|
|
|
|
|
AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow);
|
|
|
|
|
AtomArrayType = AtomAdjust(AtomArrayType); TermArrayType = MkAtomTerm(AtomArrayType);
|
|
|
|
|
AtomArrow = AtomAdjust(AtomArrow); TermArrow = MkAtomTerm(AtomArrow);
|
|
|
|
|
AtomAttributedModule = AtomAdjust(AtomAttributedModule); TermAttributedModule = MkAtomTerm(AtomAttributedModule);
|
|
|
|
|
AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow);
|
|
|
|
|
AtomAssert = AtomAdjust(AtomAssert); TermAssert = MkAtomTerm(AtomAssert);
|
|
|
|
|
AtomBeginBracket = AtomAdjust(AtomBeginBracket); TermBeginBracket = MkAtomTerm(AtomBeginBracket);
|
|
|
|
|
AtomEndBracket = AtomAdjust(AtomEndBracket); TermEndBracket = MkAtomTerm(AtomEndBracket);
|
|
|
|
|
AtomBeginSquareBracket = AtomAdjust(AtomBeginSquareBracket); TermBeginSquareBracket = MkAtomTerm(AtomBeginSquareBracket);
|
|
|
|
|
AtomEndSquareBracket = AtomAdjust(AtomEndSquareBracket); TermEndSquareBracket = MkAtomTerm(AtomEndSquareBracket);
|
|
|
|
|
AtomBeginCurlyBracket = AtomAdjust(AtomBeginCurlyBracket); TermBeginCurlyBracket = MkAtomTerm(AtomBeginCurlyBracket);
|
|
|
|
|
AtomEndCurlyBracket = AtomAdjust(AtomEndCurlyBracket); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket);
|
|
|
|
|
AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets);
|
|
|
|
|
AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets);
|
|
|
|
|
AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta);
|
|
|
|
|
AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic);
|
|
|
|
|
AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz);
|
|
|
|
|
AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic);
|
|
|
|
|
AtomAt = AtomAdjust(AtomAt); TermAt = MkAtomTerm(AtomAt);
|
|
|
|
|
AtomAtom = AtomAdjust(AtomAtom); TermAtom = MkAtomTerm(AtomAtom);
|
|
|
|
|
AtomAtomic = AtomAdjust(AtomAtomic); TermAtomic = MkAtomTerm(AtomAtomic);
|
|
|
|
|
AtomAtt = AtomAdjust(AtomAtt); TermAtt = MkAtomTerm(AtomAtt);
|
|
|
|
|
AtomAtt1 = AtomAdjust(AtomAtt1); TermAtt1 = MkAtomTerm(AtomAtt1);
|
|
|
|
|
AtomAttDo = AtomAdjust(AtomAttDo); TermAttDo = MkAtomTerm(AtomAttDo);
|
|
|
|
|
AtomAttributes = AtomAdjust(AtomAttributes); TermAttributes = MkAtomTerm(AtomAttributes);
|
|
|
|
|
AtomB = AtomAdjust(AtomB); TermB = MkAtomTerm(AtomB);
|
|
|
|
|
AtomBatched = AtomAdjust(AtomBatched); TermBatched = MkAtomTerm(AtomBatched);
|
|
|
|
|
AtomBetween = AtomAdjust(AtomBetween); TermBetween = MkAtomTerm(AtomBetween);
|
|
|
|
|
AtomBinary = AtomAdjust(AtomBinary); TermBinary = MkAtomTerm(AtomBinary);
|
|
|
|
|
AtomBigNum = AtomAdjust(AtomBigNum); TermBigNum = MkAtomTerm(AtomBigNum);
|
|
|
|
|
AtomBinaryStream = AtomAdjust(AtomBinaryStream); TermBinaryStream = MkAtomTerm(AtomBinaryStream);
|
|
|
|
|
AtomBoolean = AtomAdjust(AtomBoolean); TermBoolean = MkAtomTerm(AtomBoolean);
|
|
|
|
|
AtomBraces = AtomAdjust(AtomBraces); TermBraces = MkAtomTerm(AtomBraces);
|
|
|
|
|
AtomBreak = AtomAdjust(AtomBreak); TermBreak = MkAtomTerm(AtomBreak);
|
|
|
|
|
AtomByte = AtomAdjust(AtomByte); TermByte = MkAtomTerm(AtomByte);
|
|
|
|
|
AtomCArith = AtomAdjust(AtomCArith); TermCArith = MkAtomTerm(AtomCArith);
|
|
|
|
|
AtomCall = AtomAdjust(AtomCall); TermCall = MkAtomTerm(AtomCall);
|
|
|
|
|
AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter);
|
|
|
|
|
AtomCallCounter = AtomAdjust(AtomCallCounter); TermCallCounter = MkAtomTerm(AtomCallCounter);
|
|
|
|
|
AtomCallable = AtomAdjust(AtomCallable); TermCallable = MkAtomTerm(AtomCallable);
|
|
|
|
|
AtomCatch = AtomAdjust(AtomCatch); TermCatch = MkAtomTerm(AtomCatch);
|
|
|
|
|
AtomChangeModule = AtomAdjust(AtomChangeModule); TermChangeModule = MkAtomTerm(AtomChangeModule);
|
|
|
|
|
AtomChar = AtomAdjust(AtomChar); TermChar = MkAtomTerm(AtomChar);
|
|
|
|
|
AtomCharsio = AtomAdjust(AtomCharsio); TermCharsio = MkAtomTerm(AtomCharsio);
|
|
|
|
|
AtomCharacter = AtomAdjust(AtomCharacter); TermCharacter = MkAtomTerm(AtomCharacter);
|
|
|
|
|
AtomCharacterCode = AtomAdjust(AtomCharacterCode); TermCharacterCode = MkAtomTerm(AtomCharacterCode);
|
|
|
|
|
AtomChars = AtomAdjust(AtomChars); TermChars = MkAtomTerm(AtomChars);
|
|
|
|
|
AtomCharset = AtomAdjust(AtomCharset); TermCharset = MkAtomTerm(AtomCharset);
|
|
|
|
|
AtomChType = AtomAdjust(AtomChType); TermChType = MkAtomTerm(AtomChType);
|
|
|
|
|
AtomCleanCall = AtomAdjust(AtomCleanCall); TermCleanCall = MkAtomTerm(AtomCleanCall);
|
|
|
|
|
AtomClose = AtomAdjust(AtomClose); TermClose = MkAtomTerm(AtomClose);
|
|
|
|
|
AtomColon = AtomAdjust(AtomColon); TermColon = MkAtomTerm(AtomColon);
|
|
|
|
|
AtomCodeSpace = AtomAdjust(AtomCodeSpace); TermCodeSpace = MkAtomTerm(AtomCodeSpace);
|
|
|
|
|
AtomCodes = AtomAdjust(AtomCodes); TermCodes = MkAtomTerm(AtomCodes);
|
|
|
|
|
AtomCoInductive = AtomAdjust(AtomCoInductive); TermCoInductive = MkAtomTerm(AtomCoInductive);
|
|
|
|
|
AtomComma = AtomAdjust(AtomComma); TermComma = MkAtomTerm(AtomComma);
|
|
|
|
|
AtomCommentHook = AtomAdjust(AtomCommentHook); TermCommentHook = MkAtomTerm(AtomCommentHook);
|
|
|
|
|
AtomCompact = AtomAdjust(AtomCompact); TermCompact = MkAtomTerm(AtomCompact);
|
|
|
|
|
AtomCompound = AtomAdjust(AtomCompound); TermCompound = MkAtomTerm(AtomCompound);
|
|
|
|
|
AtomConsistencyError = AtomAdjust(AtomConsistencyError); TermConsistencyError = MkAtomTerm(AtomConsistencyError);
|
|
|
|
|
AtomConsult = AtomAdjust(AtomConsult); TermConsult = MkAtomTerm(AtomConsult);
|
|
|
|
|
AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot);
|
|
|
|
|
AtomContext = AtomAdjust(AtomContext); TermContext = MkAtomTerm(AtomContext);
|
|
|
|
|
AtomCputime = AtomAdjust(AtomCputime); TermCputime = MkAtomTerm(AtomCputime);
|
|
|
|
|
AtomCreate = AtomAdjust(AtomCreate); TermCreate = MkAtomTerm(AtomCreate);
|
|
|
|
|
AtomCreep = AtomAdjust(AtomCreep); TermCreep = MkAtomTerm(AtomCreep);
|
|
|
|
|
AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms);
|
|
|
|
|
AtomCurly = AtomAdjust(AtomCurly); TermCurly = MkAtomTerm(AtomCurly);
|
|
|
|
|
AtomCsult = AtomAdjust(AtomCsult); TermCsult = MkAtomTerm(AtomCsult);
|
|
|
|
|
AtomCurrentModule = AtomAdjust(AtomCurrentModule); TermCurrentModule = MkAtomTerm(AtomCurrentModule);
|
|
|
|
|
AtomCut = AtomAdjust(AtomCut); TermCut = MkAtomTerm(AtomCut);
|
|
|
|
|
AtomCutBy = AtomAdjust(AtomCutBy); TermCutBy = MkAtomTerm(AtomCutBy);
|
|
|
|
|
AtomDAbort = AtomAdjust(AtomDAbort); TermDAbort = MkAtomTerm(AtomDAbort);
|
|
|
|
|
AtomDBLoad = AtomAdjust(AtomDBLoad); TermDBLoad = MkAtomTerm(AtomDBLoad);
|
|
|
|
|
AtomDBREF = AtomAdjust(AtomDBREF); TermDBREF = MkAtomTerm(AtomDBREF);
|
|
|
|
|
AtomDBReference = AtomAdjust(AtomDBReference); TermDBReference = MkAtomTerm(AtomDBReference);
|
|
|
|
|
AtomDBTerm = AtomAdjust(AtomDBTerm); TermDBTerm = MkAtomTerm(AtomDBTerm);
|
|
|
|
|
AtomDBref = AtomAdjust(AtomDBref); TermDBref = MkAtomTerm(AtomDBref);
|
|
|
|
|
AtomDInteger = AtomAdjust(AtomDInteger); TermDInteger = MkAtomTerm(AtomDInteger);
|
|
|
|
|
AtomDebugMeta = AtomAdjust(AtomDebugMeta); TermDebugMeta = MkAtomTerm(AtomDebugMeta);
|
|
|
|
|
AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput);
|
|
|
|
|
AtomDec10 = AtomAdjust(AtomDec10); TermDec10 = MkAtomTerm(AtomDec10);
|
|
|
|
|
AtomDefault = AtomAdjust(AtomDefault); TermDefault = MkAtomTerm(AtomDefault);
|
|
|
|
|
AtomDevNull = AtomAdjust(AtomDevNull); TermDevNull = MkAtomTerm(AtomDevNull);
|
|
|
|
|
AtomDiff = AtomAdjust(AtomDiff); TermDiff = MkAtomTerm(AtomDiff);
|
|
|
|
|
AtomDirectory = AtomAdjust(AtomDirectory); TermDirectory = MkAtomTerm(AtomDirectory);
|
|
|
|
|
AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous);
|
|
|
|
|
AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings);
|
|
|
|
|
AtomDollar = AtomAdjust(AtomDollar); TermDollar = MkAtomTerm(AtomDollar);
|
|
|
|
|
AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause);
|
|
|
|
|
AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0);
|
|
|
|
|
AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase);
|
|
|
|
|
AtomDollarU = AtomAdjust(AtomDollarU); TermDollarU = MkAtomTerm(AtomDollarU);
|
|
|
|
|
AtomDollarUndef = AtomAdjust(AtomDollarUndef); TermDollarUndef = MkAtomTerm(AtomDollarUndef);
|
|
|
|
|
AtomDomainError = AtomAdjust(AtomDomainError); TermDomainError = MkAtomTerm(AtomDomainError);
|
|
|
|
|
AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause);
|
|
|
|
|
AtomDots = AtomAdjust(AtomDots); TermDots = MkAtomTerm(AtomDots);
|
|
|
|
|
AtomDOUBLE = AtomAdjust(AtomDOUBLE); TermDOUBLE = MkAtomTerm(AtomDOUBLE);
|
|
|
|
|
AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash);
|
|
|
|
|
AtomE = AtomAdjust(AtomE); TermE = MkAtomTerm(AtomE);
|
|
|
|
|
AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT);
|
|
|
|
|
AtomEQ = AtomAdjust(AtomEQ); TermEQ = MkAtomTerm(AtomEQ);
|
|
|
|
|
AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom);
|
|
|
|
|
AtomEncoding = AtomAdjust(AtomEncoding); TermEncoding = MkAtomTerm(AtomEncoding);
|
|
|
|
|
AtomEndOfStream = AtomAdjust(AtomEndOfStream); TermEndOfStream = MkAtomTerm(AtomEndOfStream);
|
|
|
|
|
AtomEof = AtomAdjust(AtomEof); TermEof = MkAtomTerm(AtomEof);
|
|
|
|
|
AtomEOfCode = AtomAdjust(AtomEOfCode); TermEOfCode = MkAtomTerm(AtomEOfCode);
|
|
|
|
|
AtomEq = AtomAdjust(AtomEq); TermEq = MkAtomTerm(AtomEq);
|
|
|
|
|
AtomError = AtomAdjust(AtomError); TermError = MkAtomTerm(AtomError);
|
|
|
|
|
AtomException = AtomAdjust(AtomException); TermException = MkAtomTerm(AtomException);
|
|
|
|
|
AtomExtensions = AtomAdjust(AtomExtensions); TermExtensions = MkAtomTerm(AtomExtensions);
|
|
|
|
|
AtomEvaluable = AtomAdjust(AtomEvaluable); TermEvaluable = MkAtomTerm(AtomEvaluable);
|
|
|
|
|
AtomEvaluationError = AtomAdjust(AtomEvaluationError); TermEvaluationError = MkAtomTerm(AtomEvaluationError);
|
|
|
|
|
AtomExecutable = AtomAdjust(AtomExecutable); TermExecutable = MkAtomTerm(AtomExecutable);
|
|
|
|
|
AtomExecute = AtomAdjust(AtomExecute); TermExecute = MkAtomTerm(AtomExecute);
|
|
|
|
|
AtomExecAnswers = AtomAdjust(AtomExecAnswers); TermExecAnswers = MkAtomTerm(AtomExecAnswers);
|
|
|
|
|
AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod);
|
|
|
|
|
AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin);
|
|
|
|
|
AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod);
|
|
|
|
|
AtomExist = AtomAdjust(AtomExist); TermExist = MkAtomTerm(AtomExist);
|
|
|
|
|
AtomExists = AtomAdjust(AtomExists); TermExists = MkAtomTerm(AtomExists);
|
|
|
|
|
AtomExit = AtomAdjust(AtomExit); TermExit = MkAtomTerm(AtomExit);
|
|
|
|
|
AtomExistenceError = AtomAdjust(AtomExistenceError); TermExistenceError = MkAtomTerm(AtomExistenceError);
|
|
|
|
|
AtomExoClause = AtomAdjust(AtomExoClause); TermExoClause = MkAtomTerm(AtomExoClause);
|
|
|
|
|
AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber);
|
|
|
|
|
AtomExpand = AtomAdjust(AtomExpand); TermExpand = MkAtomTerm(AtomExpand);
|
|
|
|
|
AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath);
|
|
|
|
|
AtomExtendsions = AtomAdjust(AtomExtendsions); TermExtendsions = MkAtomTerm(AtomExtendsions);
|
|
|
|
|
AtomFB = AtomAdjust(AtomFB); TermFB = MkAtomTerm(AtomFB);
|
|
|
|
|
AtomFail = AtomAdjust(AtomFail); TermFail = MkAtomTerm(AtomFail);
|
|
|
|
|
AtomFalse = AtomAdjust(AtomFalse); TermFalse = MkAtomTerm(AtomFalse);
|
|
|
|
|
AtomFast = AtomAdjust(AtomFast); TermFast = MkAtomTerm(AtomFast);
|
|
|
|
|
AtomFastFail = AtomAdjust(AtomFastFail); TermFastFail = MkAtomTerm(AtomFastFail);
|
|
|
|
|
AtomFileErrors = AtomAdjust(AtomFileErrors); TermFileErrors = MkAtomTerm(AtomFileErrors);
|
|
|
|
|
AtomFileerrors = AtomAdjust(AtomFileerrors); TermFileerrors = MkAtomTerm(AtomFileerrors);
|
|
|
|
|
AtomFileType = AtomAdjust(AtomFileType); TermFileType = MkAtomTerm(AtomFileType);
|
|
|
|
|
AtomFirst = AtomAdjust(AtomFirst); TermFirst = MkAtomTerm(AtomFirst);
|
|
|
|
|
AtomFloat = AtomAdjust(AtomFloat); TermFloat = MkAtomTerm(AtomFloat);
|
|
|
|
|
AtomFloatFormat = AtomAdjust(AtomFloatFormat); TermFloatFormat = MkAtomTerm(AtomFloatFormat);
|
|
|
|
|
AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow);
|
|
|
|
|
AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow);
|
|
|
|
|
AtomFormat = AtomAdjust(AtomFormat); TermFormat = MkAtomTerm(AtomFormat);
|
|
|
|
|
AtomFormatAt = AtomAdjust(AtomFormatAt); TermFormatAt = MkAtomTerm(AtomFormatAt);
|
|
|
|
|
AtomFull = AtomAdjust(AtomFull); TermFull = MkAtomTerm(AtomFull);
|
|
|
|
|
AtomFunctor = AtomAdjust(AtomFunctor); TermFunctor = MkAtomTerm(AtomFunctor);
|
|
|
|
|
AtomGT = AtomAdjust(AtomGT); TermGT = MkAtomTerm(AtomGT);
|
|
|
|
|
AtomGVar = AtomAdjust(AtomGVar); TermGVar = MkAtomTerm(AtomGVar);
|
|
|
|
|
AtomGc = AtomAdjust(AtomGc); TermGc = MkAtomTerm(AtomGc);
|
|
|
|
|
AtomGcMargin = AtomAdjust(AtomGcMargin); TermGcMargin = MkAtomTerm(AtomGcMargin);
|
|
|
|
|
AtomGcTrace = AtomAdjust(AtomGcTrace); TermGcTrace = MkAtomTerm(AtomGcTrace);
|
|
|
|
|
AtomGcVerbose = AtomAdjust(AtomGcVerbose); TermGcVerbose = MkAtomTerm(AtomGcVerbose);
|
|
|
|
|
AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose);
|
|
|
|
|
AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo);
|
|
|
|
|
AtomGetwork = AtomAdjust(AtomGetwork); TermGetwork = MkAtomTerm(AtomGetwork);
|
|
|
|
|
AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq);
|
|
|
|
|
AtomGlob = AtomAdjust(AtomGlob); TermGlob = MkAtomTerm(AtomGlob);
|
|
|
|
|
AtomGlobal = AtomAdjust(AtomGlobal); TermGlobal = MkAtomTerm(AtomGlobal);
|
|
|
|
|
AtomGlobalSp = AtomAdjust(AtomGlobalSp); TermGlobalSp = MkAtomTerm(AtomGlobalSp);
|
|
|
|
|
AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie);
|
|
|
|
|
AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion);
|
|
|
|
|
AtomHat = AtomAdjust(AtomHat); TermHat = MkAtomTerm(AtomHat);
|
|
|
|
|
AtomHERE = AtomAdjust(AtomHERE); TermHERE = MkAtomTerm(AtomHERE);
|
|
|
|
|
AtomHandleThrow = AtomAdjust(AtomHandleThrow); TermHandleThrow = MkAtomTerm(AtomHandleThrow);
|
|
|
|
|
AtomHeap = AtomAdjust(AtomHeap); TermHeap = MkAtomTerm(AtomHeap);
|
|
|
|
|
AtomHeapUsed = AtomAdjust(AtomHeapUsed); TermHeapUsed = MkAtomTerm(AtomHeapUsed);
|
|
|
|
|
AtomHugeInt = AtomAdjust(AtomHugeInt); TermHugeInt = MkAtomTerm(AtomHugeInt);
|
|
|
|
|
AtomIDB = AtomAdjust(AtomIDB); TermIDB = MkAtomTerm(AtomIDB);
|
|
|
|
|
AtomIOMode = AtomAdjust(AtomIOMode); TermIOMode = MkAtomTerm(AtomIOMode);
|
|
|
|
|
AtomI = AtomAdjust(AtomI); TermI = MkAtomTerm(AtomI);
|
|
|
|
|
AtomId = AtomAdjust(AtomId); TermId = MkAtomTerm(AtomId);
|
|
|
|
|
AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore);
|
|
|
|
|
AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf);
|
|
|
|
|
AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity);
|
|
|
|
|
AtomInfo = AtomAdjust(AtomInfo); TermInfo = MkAtomTerm(AtomInfo);
|
|
|
|
|
AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal);
|
|
|
|
|
AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog);
|
|
|
|
|
AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion);
|
|
|
|
|
AtomInput = AtomAdjust(AtomInput); TermInput = MkAtomTerm(AtomInput);
|
|
|
|
|
AtomInstantiationError = AtomAdjust(AtomInstantiationError); TermInstantiationError = MkAtomTerm(AtomInstantiationError);
|
|
|
|
|
AtomInt = AtomAdjust(AtomInt); TermInt = MkAtomTerm(AtomInt);
|
|
|
|
|
AtomIntOverflow = AtomAdjust(AtomIntOverflow); TermIntOverflow = MkAtomTerm(AtomIntOverflow);
|
|
|
|
|
AtomInteger = AtomAdjust(AtomInteger); TermInteger = MkAtomTerm(AtomInteger);
|
|
|
|
|
AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError);
|
|
|
|
|
AtomIs = AtomAdjust(AtomIs); TermIs = MkAtomTerm(AtomIs);
|
|
|
|
|
AtomJ = AtomAdjust(AtomJ); TermJ = MkAtomTerm(AtomJ);
|
|
|
|
|
Atoml = AtomAdjust(Atoml); Terml = MkAtomTerm(Atoml);
|
|
|
|
|
AtomKey = AtomAdjust(AtomKey); TermKey = MkAtomTerm(AtomKey);
|
|
|
|
|
AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath);
|
|
|
|
|
AtomLONGINT = AtomAdjust(AtomLONGINT); TermLONGINT = MkAtomTerm(AtomLONGINT);
|
|
|
|
|
AtomLOOP = AtomAdjust(AtomLOOP); TermLOOP = MkAtomTerm(AtomLOOP);
|
|
|
|
|
AtomLoopStream = AtomAdjust(AtomLoopStream); TermLoopStream = MkAtomTerm(AtomLoopStream);
|
|
|
|
|
AtomLT = AtomAdjust(AtomLT); TermLT = MkAtomTerm(AtomLT);
|
|
|
|
|
AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin);
|
|
|
|
|
AtomLeash = AtomAdjust(AtomLeash); TermLeash = MkAtomTerm(AtomLeash);
|
|
|
|
|
AtomLeast = AtomAdjust(AtomLeast); TermLeast = MkAtomTerm(AtomLeast);
|
|
|
|
|
AtomLength = AtomAdjust(AtomLength); TermLength = MkAtomTerm(AtomLength);
|
|
|
|
|
AtomList = AtomAdjust(AtomList); TermList = MkAtomTerm(AtomList);
|
|
|
|
|
AtomLine = AtomAdjust(AtomLine); TermLine = MkAtomTerm(AtomLine);
|
|
|
|
|
AtomLive = AtomAdjust(AtomLive); TermLive = MkAtomTerm(AtomLive);
|
|
|
|
|
AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers);
|
|
|
|
|
AtomLocal = AtomAdjust(AtomLocal); TermLocal = MkAtomTerm(AtomLocal);
|
|
|
|
|
AtomLocalSp = AtomAdjust(AtomLocalSp); TermLocalSp = MkAtomTerm(AtomLocalSp);
|
|
|
|
|
AtomLocalTrie = AtomAdjust(AtomLocalTrie); TermLocalTrie = MkAtomTerm(AtomLocalTrie);
|
|
|
|
|
AtomMax = AtomAdjust(AtomMax); TermMax = MkAtomTerm(AtomMax);
|
|
|
|
|
AtomMaximum = AtomAdjust(AtomMaximum); TermMaximum = MkAtomTerm(AtomMaximum);
|
|
|
|
|
AtomMaxArity = AtomAdjust(AtomMaxArity); TermMaxArity = MkAtomTerm(AtomMaxArity);
|
|
|
|
|
AtomMaxFiles = AtomAdjust(AtomMaxFiles); TermMaxFiles = MkAtomTerm(AtomMaxFiles);
|
|
|
|
|
AtomMegaClause = AtomAdjust(AtomMegaClause); TermMegaClause = MkAtomTerm(AtomMegaClause);
|
|
|
|
|
AtomMetaCall = AtomAdjust(AtomMetaCall); TermMetaCall = MkAtomTerm(AtomMetaCall);
|
|
|
|
|
AtomMfClause = AtomAdjust(AtomMfClause); TermMfClause = MkAtomTerm(AtomMfClause);
|
|
|
|
|
AtomMin = AtomAdjust(AtomMin); TermMin = MkAtomTerm(AtomMin);
|
|
|
|
|
AtomMinimum = AtomAdjust(AtomMinimum); TermMinimum = MkAtomTerm(AtomMinimum);
|
|
|
|
|
AtomMinus = AtomAdjust(AtomMinus); TermMinus = MkAtomTerm(AtomMinus);
|
|
|
|
|
AtomModify = AtomAdjust(AtomModify); TermModify = MkAtomTerm(AtomModify);
|
|
|
|
|
AtomModule = AtomAdjust(AtomModule); TermModule = MkAtomTerm(AtomModule);
|
|
|
|
|
AtomMost = AtomAdjust(AtomMost); TermMost = MkAtomTerm(AtomMost);
|
|
|
|
|
AtomMulti = AtomAdjust(AtomMulti); TermMulti = MkAtomTerm(AtomMulti);
|
|
|
|
|
AtomMultiFile = AtomAdjust(AtomMultiFile); TermMultiFile = MkAtomTerm(AtomMultiFile);
|
|
|
|
|
AtomMultiple = AtomAdjust(AtomMultiple); TermMultiple = MkAtomTerm(AtomMultiple);
|
|
|
|
|
AtomMutable = AtomAdjust(AtomMutable); TermMutable = MkAtomTerm(AtomMutable);
|
|
|
|
|
AtomMutableVariable = AtomAdjust(AtomMutableVariable); TermMutableVariable = MkAtomTerm(AtomMutableVariable);
|
|
|
|
|
AtomMutex = AtomAdjust(AtomMutex); TermMutex = MkAtomTerm(AtomMutex);
|
|
|
|
|
AtomMyddasDB = AtomAdjust(AtomMyddasDB); TermMyddasDB = MkAtomTerm(AtomMyddasDB);
|
|
|
|
|
AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal);
|
|
|
|
|
AtomMyddasHost = AtomAdjust(AtomMyddasHost); TermMyddasHost = MkAtomTerm(AtomMyddasHost);
|
|
|
|
|
AtomMyddasPass = AtomAdjust(AtomMyddasPass); TermMyddasPass = MkAtomTerm(AtomMyddasPass);
|
|
|
|
|
AtomMyddasUser = AtomAdjust(AtomMyddasUser); TermMyddasUser = MkAtomTerm(AtomMyddasUser);
|
|
|
|
|
AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName);
|
|
|
|
|
AtomNan = AtomAdjust(AtomNan); TermNan = MkAtomTerm(AtomNan);
|
|
|
|
|
AtomNb = AtomAdjust(AtomNb); TermNb = MkAtomTerm(AtomNb);
|
|
|
|
|
AtomNbTerm = AtomAdjust(AtomNbTerm); TermNbTerm = MkAtomTerm(AtomNbTerm);
|
|
|
|
|
AtomNew = AtomAdjust(AtomNew); TermNew = MkAtomTerm(AtomNew);
|
|
|
|
|
AtomNewLine = AtomAdjust(AtomNewLine); TermNewLine = MkAtomTerm(AtomNewLine);
|
|
|
|
|
AtomNl = AtomAdjust(AtomNl); TermNl = MkAtomTerm(AtomNl);
|
|
|
|
|
AtomNoEffect = AtomAdjust(AtomNoEffect); TermNoEffect = MkAtomTerm(AtomNoEffect);
|
|
|
|
|
AtomNoMemory = AtomAdjust(AtomNoMemory); TermNoMemory = MkAtomTerm(AtomNoMemory);
|
|
|
|
|
AtomNone = AtomAdjust(AtomNone); TermNone = MkAtomTerm(AtomNone);
|
|
|
|
|
AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList);
|
|
|
|
|
AtomNot = AtomAdjust(AtomNot); TermNot = MkAtomTerm(AtomNot);
|
|
|
|
|
AtomNotImplemented = AtomAdjust(AtomNotImplemented); TermNotImplemented = MkAtomTerm(AtomNotImplemented);
|
|
|
|
|
AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero);
|
|
|
|
|
AtomNotNewline = AtomAdjust(AtomNotNewline); TermNotNewline = MkAtomTerm(AtomNotNewline);
|
|
|
|
|
AtomNotZero = AtomAdjust(AtomNotZero); TermNotZero = MkAtomTerm(AtomNotZero);
|
|
|
|
|
AtomNumber = AtomAdjust(AtomNumber); TermNumber = MkAtomTerm(AtomNumber);
|
|
|
|
|
AtomObj = AtomAdjust(AtomObj); TermObj = MkAtomTerm(AtomObj);
|
|
|
|
|
AtomOff = AtomAdjust(AtomOff); TermOff = MkAtomTerm(AtomOff);
|
|
|
|
|
AtomOffline = AtomAdjust(AtomOffline); TermOffline = MkAtomTerm(AtomOffline);
|
|
|
|
|
AtomOn = AtomAdjust(AtomOn); TermOn = MkAtomTerm(AtomOn);
|
|
|
|
|
AtomOnline = AtomAdjust(AtomOnline); TermOnline = MkAtomTerm(AtomOnline);
|
|
|
|
|
AtomOpen = AtomAdjust(AtomOpen); TermOpen = MkAtomTerm(AtomOpen);
|
|
|
|
|
AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError);
|
|
|
|
|
AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport);
|
|
|
|
|
AtomOperator = AtomAdjust(AtomOperator); TermOperator = MkAtomTerm(AtomOperator);
|
|
|
|
|
AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority);
|
|
|
|
|
AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier);
|
|
|
|
|
AtomOpt = AtomAdjust(AtomOpt); TermOpt = MkAtomTerm(AtomOpt);
|
|
|
|
|
AtomOtherwise = AtomAdjust(AtomOtherwise); TermOtherwise = MkAtomTerm(AtomOtherwise);
|
|
|
|
|
AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError);
|
|
|
|
|
AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError);
|
|
|
|
|
AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError);
|
|
|
|
|
AtomOutOfRange = AtomAdjust(AtomOutOfRange); TermOutOfRange = MkAtomTerm(AtomOutOfRange);
|
|
|
|
|
AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError);
|
|
|
|
|
AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError);
|
|
|
|
|
AtomOutput = AtomAdjust(AtomOutput); TermOutput = MkAtomTerm(AtomOutput);
|
|
|
|
|
AtomParameter = AtomAdjust(AtomParameter); TermParameter = MkAtomTerm(AtomParameter);
|
|
|
|
|
AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir);
|
|
|
|
|
AtomPast = AtomAdjust(AtomPast); TermPast = MkAtomTerm(AtomPast);
|
|
|
|
|
AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream);
|
|
|
|
|
AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError);
|
|
|
|
|
AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi);
|
|
|
|
|
AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe);
|
|
|
|
|
AtomPriority = AtomAdjust(AtomPriority); TermPriority = MkAtomTerm(AtomPriority);
|
|
|
|
|
AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus);
|
|
|
|
|
AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer);
|
|
|
|
|
AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray);
|
|
|
|
|
AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator);
|
|
|
|
|
AtomPrimitive = AtomAdjust(AtomPrimitive); TermPrimitive = MkAtomTerm(AtomPrimitive);
|
|
|
|
|
AtomPrintMessage = AtomAdjust(AtomPrintMessage); TermPrintMessage = MkAtomTerm(AtomPrintMessage);
|
|
|
|
|
AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure);
|
|
|
|
|
AtomProcedure = AtomAdjust(AtomProcedure); TermProcedure = MkAtomTerm(AtomProcedure);
|
|
|
|
|
AtomProfile = AtomAdjust(AtomProfile); TermProfile = MkAtomTerm(AtomProfile);
|
|
|
|
|
AtomProlog = AtomAdjust(AtomProlog); TermProlog = MkAtomTerm(AtomProlog);
|
|
|
|
|
AtomProtectStack = AtomAdjust(AtomProtectStack); TermProtectStack = MkAtomTerm(AtomProtectStack);
|
|
|
|
|
AtomQly = AtomAdjust(AtomQly); TermQly = MkAtomTerm(AtomQly);
|
|
|
|
|
AtomQuery = AtomAdjust(AtomQuery); TermQuery = MkAtomTerm(AtomQuery);
|
|
|
|
|
AtomQueue = AtomAdjust(AtomQueue); TermQueue = MkAtomTerm(AtomQueue);
|
|
|
|
|
AtomQuiet = AtomAdjust(AtomQuiet); TermQuiet = MkAtomTerm(AtomQuiet);
|
|
|
|
|
AtomRadix = AtomAdjust(AtomRadix); TermRadix = MkAtomTerm(AtomRadix);
|
|
|
|
|
AtomRandom = AtomAdjust(AtomRandom); TermRandom = MkAtomTerm(AtomRandom);
|
|
|
|
|
AtomRange = AtomAdjust(AtomRange); TermRange = MkAtomTerm(AtomRange);
|
|
|
|
|
AtomRDiv = AtomAdjust(AtomRDiv); TermRDiv = MkAtomTerm(AtomRDiv);
|
|
|
|
|
AtomRead = AtomAdjust(AtomRead); TermRead = MkAtomTerm(AtomRead);
|
|
|
|
|
AtomReadOnly = AtomAdjust(AtomReadOnly); TermReadOnly = MkAtomTerm(AtomReadOnly);
|
|
|
|
|
AtomReadWrite = AtomAdjust(AtomReadWrite); TermReadWrite = MkAtomTerm(AtomReadWrite);
|
|
|
|
|
AtomReadutil = AtomAdjust(AtomReadutil); TermReadutil = MkAtomTerm(AtomReadutil);
|
|
|
|
|
AtomReconsult = AtomAdjust(AtomReconsult); TermReconsult = MkAtomTerm(AtomReconsult);
|
|
|
|
|
AtomRecordedP = AtomAdjust(AtomRecordedP); TermRecordedP = MkAtomTerm(AtomRecordedP);
|
|
|
|
|
AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey);
|
|
|
|
|
AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings);
|
|
|
|
|
AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze);
|
|
|
|
|
AtomRefoundVar = AtomAdjust(AtomRefoundVar); TermRefoundVar = MkAtomTerm(AtomRefoundVar);
|
|
|
|
|
AtomRelativeTo = AtomAdjust(AtomRelativeTo); TermRelativeTo = MkAtomTerm(AtomRelativeTo);
|
|
|
|
|
AtomRepeat = AtomAdjust(AtomRepeat); TermRepeat = MkAtomTerm(AtomRepeat);
|
|
|
|
|
AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace);
|
|
|
|
|
AtomReposition = AtomAdjust(AtomReposition); TermReposition = MkAtomTerm(AtomReposition);
|
|
|
|
|
AtomRepresentationError = AtomAdjust(AtomRepresentationError); TermRepresentationError = MkAtomTerm(AtomRepresentationError);
|
|
|
|
|
AtomReset = AtomAdjust(AtomReset); TermReset = MkAtomTerm(AtomReset);
|
|
|
|
|
AtomResize = AtomAdjust(AtomResize); TermResize = MkAtomTerm(AtomResize);
|
|
|
|
|
AtomResourceError = AtomAdjust(AtomResourceError); TermResourceError = MkAtomTerm(AtomResourceError);
|
|
|
|
|
AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs);
|
|
|
|
|
AtomRetry = AtomAdjust(AtomRetry); TermRetry = MkAtomTerm(AtomRetry);
|
|
|
|
|
AtomRetryCounter = AtomAdjust(AtomRetryCounter); TermRetryCounter = MkAtomTerm(AtomRetryCounter);
|
|
|
|
|
AtomRTree = AtomAdjust(AtomRTree); TermRTree = MkAtomTerm(AtomRTree);
|
|
|
|
|
AtomSafe = AtomAdjust(AtomSafe); TermSafe = MkAtomTerm(AtomSafe);
|
|
|
|
|
AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup);
|
|
|
|
|
AtomSame = AtomAdjust(AtomSame); TermSame = MkAtomTerm(AtomSame);
|
|
|
|
|
AtomSemic = AtomAdjust(AtomSemic); TermSemic = MkAtomTerm(AtomSemic);
|
|
|
|
|
AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow);
|
|
|
|
|
AtomSigAlarm = AtomAdjust(AtomSigAlarm); TermSigAlarm = MkAtomTerm(AtomSigAlarm);
|
|
|
|
|
AtomSigBreak = AtomAdjust(AtomSigBreak); TermSigBreak = MkAtomTerm(AtomSigBreak);
|
|
|
|
|
AtomSigCreep = AtomAdjust(AtomSigCreep); TermSigCreep = MkAtomTerm(AtomSigCreep);
|
|
|
|
|
AtomSigDebug = AtomAdjust(AtomSigDebug); TermSigDebug = MkAtomTerm(AtomSigDebug);
|
|
|
|
|
AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep);
|
|
|
|
|
AtomSigFPE = AtomAdjust(AtomSigFPE); TermSigFPE = MkAtomTerm(AtomSigFPE);
|
|
|
|
|
AtomSigHup = AtomAdjust(AtomSigHup); TermSigHup = MkAtomTerm(AtomSigHup);
|
|
|
|
|
AtomSigInt = AtomAdjust(AtomSigInt); TermSigInt = MkAtomTerm(AtomSigInt);
|
|
|
|
|
AtomSigIti = AtomAdjust(AtomSigIti); TermSigIti = MkAtomTerm(AtomSigIti);
|
|
|
|
|
AtomSigPending = AtomAdjust(AtomSigPending); TermSigPending = MkAtomTerm(AtomSigPending);
|
|
|
|
|
AtomSigPipe = AtomAdjust(AtomSigPipe); TermSigPipe = MkAtomTerm(AtomSigPipe);
|
|
|
|
|
AtomSigStackDump = AtomAdjust(AtomSigStackDump); TermSigStackDump = MkAtomTerm(AtomSigStackDump);
|
|
|
|
|
AtomSigStatistics = AtomAdjust(AtomSigStatistics); TermSigStatistics = MkAtomTerm(AtomSigStatistics);
|
|
|
|
|
AtomSigTrace = AtomAdjust(AtomSigTrace); TermSigTrace = MkAtomTerm(AtomSigTrace);
|
|
|
|
|
AtomSigUsr1 = AtomAdjust(AtomSigUsr1); TermSigUsr1 = MkAtomTerm(AtomSigUsr1);
|
|
|
|
|
AtomSigUsr2 = AtomAdjust(AtomSigUsr2); TermSigUsr2 = MkAtomTerm(AtomSigUsr2);
|
|
|
|
|
AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm);
|
|
|
|
|
AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp);
|
|
|
|
|
AtomSilent = AtomAdjust(AtomSilent); TermSilent = MkAtomTerm(AtomSilent);
|
|
|
|
|
AtomSingle = AtomAdjust(AtomSingle); TermSingle = MkAtomTerm(AtomSingle);
|
|
|
|
|
AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings);
|
|
|
|
|
AtomSingleton = AtomAdjust(AtomSingleton); TermSingleton = MkAtomTerm(AtomSingleton);
|
|
|
|
|
AtomSlash = AtomAdjust(AtomSlash); TermSlash = MkAtomTerm(AtomSlash);
|
|
|
|
|
AtomSocket = AtomAdjust(AtomSocket); TermSocket = MkAtomTerm(AtomSocket);
|
|
|
|
|
AtomSolutions = AtomAdjust(AtomSolutions); TermSolutions = MkAtomTerm(AtomSolutions);
|
|
|
|
|
AtomSource = AtomAdjust(AtomSource); TermSource = MkAtomTerm(AtomSource);
|
|
|
|
|
AtomSourceSink = AtomAdjust(AtomSourceSink); TermSourceSink = MkAtomTerm(AtomSourceSink);
|
|
|
|
|
AtomSpy = AtomAdjust(AtomSpy); TermSpy = MkAtomTerm(AtomSpy);
|
|
|
|
|
AtomStack = AtomAdjust(AtomStack); TermStack = MkAtomTerm(AtomStack);
|
|
|
|
|
AtomStackFree = AtomAdjust(AtomStackFree); TermStackFree = MkAtomTerm(AtomStackFree);
|
|
|
|
|
AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState);
|
|
|
|
|
AtomStaticClause = AtomAdjust(AtomStaticClause); TermStaticClause = MkAtomTerm(AtomStaticClause);
|
|
|
|
|
AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure);
|
|
|
|
|
AtomStream = AtomAdjust(AtomStream); TermStream = MkAtomTerm(AtomStream);
|
|
|
|
|
AtomSWIStream = AtomAdjust(AtomSWIStream); TermSWIStream = MkAtomTerm(AtomSWIStream);
|
|
|
|
|
AtomVStream = AtomAdjust(AtomVStream); TermVStream = MkAtomTerm(AtomVStream);
|
|
|
|
|
AtomStreams = AtomAdjust(AtomStreams); TermStreams = MkAtomTerm(AtomStreams);
|
|
|
|
|
AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias);
|
|
|
|
|
AtomStreamPos = AtomAdjust(AtomStreamPos); TermStreamPos = MkAtomTerm(AtomStreamPos);
|
|
|
|
|
AtomStreamPosition = AtomAdjust(AtomStreamPosition); TermStreamPosition = MkAtomTerm(AtomStreamPosition);
|
|
|
|
|
AtomString = AtomAdjust(AtomString); TermString = MkAtomTerm(AtomString);
|
|
|
|
|
AtomStyleCheck = AtomAdjust(AtomStyleCheck); TermStyleCheck = MkAtomTerm(AtomStyleCheck);
|
|
|
|
|
AtomSTRING = AtomAdjust(AtomSTRING); TermSTRING = MkAtomTerm(AtomSTRING);
|
|
|
|
|
AtomSwi = AtomAdjust(AtomSwi); TermSwi = MkAtomTerm(AtomSwi);
|
|
|
|
|
AtomSymbolChar = AtomAdjust(AtomSymbolChar); TermSymbolChar = MkAtomTerm(AtomSymbolChar);
|
|
|
|
|
AtomSyntaxError = AtomAdjust(AtomSyntaxError); TermSyntaxError = MkAtomTerm(AtomSyntaxError);
|
|
|
|
|
AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors);
|
|
|
|
|
AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler);
|
|
|
|
|
AtomSystem = AtomAdjust(AtomSystem); TermSystem = MkAtomTerm(AtomSystem);
|
|
|
|
|
AtomSystemError = AtomAdjust(AtomSystemError); TermSystemError = MkAtomTerm(AtomSystemError);
|
|
|
|
|
AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir);
|
|
|
|
|
AtomT = AtomAdjust(AtomT); TermT = MkAtomTerm(AtomT);
|
|
|
|
|
AtomTerm = AtomAdjust(AtomTerm); TermTerm = MkAtomTerm(AtomTerm);
|
|
|
|
|
AtomTermExpansion = AtomAdjust(AtomTermExpansion); TermTermExpansion = MkAtomTerm(AtomTermExpansion);
|
|
|
|
|
AtomTerms = AtomAdjust(AtomTerms); TermTerms = MkAtomTerm(AtomTerms);
|
|
|
|
|
AtomText = AtomAdjust(AtomText); TermText = MkAtomTerm(AtomText);
|
|
|
|
|
AtomTextStream = AtomAdjust(AtomTextStream); TermTextStream = MkAtomTerm(AtomTextStream);
|
|
|
|
|
AtomThread = AtomAdjust(AtomThread); TermThread = MkAtomTerm(AtomThread);
|
|
|
|
|
AtomThreads = AtomAdjust(AtomThreads); TermThreads = MkAtomTerm(AtomThreads);
|
|
|
|
|
AtomThrow = AtomAdjust(AtomThrow); TermThrow = MkAtomTerm(AtomThrow);
|
|
|
|
|
AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec);
|
|
|
|
|
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);
|
|
|
|
|
AtomTrue = AtomAdjust(AtomTrue); TermTrue = MkAtomTerm(AtomTrue);
|
|
|
|
|
AtomTty = AtomAdjust(AtomTty); TermTty = MkAtomTerm(AtomTty);
|
|
|
|
|
AtomTtys = AtomAdjust(AtomTtys); TermTtys = MkAtomTerm(AtomTtys);
|
|
|
|
|
AtomTuple = AtomAdjust(AtomTuple); TermTuple = MkAtomTerm(AtomTuple);
|
|
|
|
|
AtomTxt = AtomAdjust(AtomTxt); TermTxt = MkAtomTerm(AtomTxt);
|
|
|
|
|
AtomTypeError = AtomAdjust(AtomTypeError); TermTypeError = MkAtomTerm(AtomTypeError);
|
|
|
|
|
AtomUndefined = AtomAdjust(AtomUndefined); TermUndefined = MkAtomTerm(AtomUndefined);
|
|
|
|
|
AtomUndefp = AtomAdjust(AtomUndefp); TermUndefp = MkAtomTerm(AtomUndefp);
|
|
|
|
|
AtomUndefp0 = AtomAdjust(AtomUndefp0); TermUndefp0 = MkAtomTerm(AtomUndefp0);
|
|
|
|
|
AtomUnderflow = AtomAdjust(AtomUnderflow); TermUnderflow = MkAtomTerm(AtomUnderflow);
|
|
|
|
|
AtomUnificationStack = AtomAdjust(AtomUnificationStack); TermUnificationStack = MkAtomTerm(AtomUnificationStack);
|
|
|
|
|
AtomUnique = AtomAdjust(AtomUnique); TermUnique = MkAtomTerm(AtomUnique);
|
|
|
|
|
AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte);
|
|
|
|
|
AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar);
|
|
|
|
|
AtomUser = AtomAdjust(AtomUser); TermUser = MkAtomTerm(AtomUser);
|
|
|
|
|
AtomUserErr = AtomAdjust(AtomUserErr); TermUserErr = MkAtomTerm(AtomUserErr);
|
|
|
|
|
AtomUserIn = AtomAdjust(AtomUserIn); TermUserIn = MkAtomTerm(AtomUserIn);
|
|
|
|
|
AtomUserOut = AtomAdjust(AtomUserOut); TermUserOut = MkAtomTerm(AtomUserOut);
|
|
|
|
|
AtomDollarVar = AtomAdjust(AtomDollarVar); TermDollarVar = MkAtomTerm(AtomDollarVar);
|
|
|
|
|
AtomVBar = AtomAdjust(AtomVBar); TermVBar = MkAtomTerm(AtomVBar);
|
|
|
|
|
AtomVarBranches = AtomAdjust(AtomVarBranches); TermVarBranches = MkAtomTerm(AtomVarBranches);
|
|
|
|
|
AtomVariableNames = AtomAdjust(AtomVariableNames); TermVariableNames = MkAtomTerm(AtomVariableNames);
|
|
|
|
|
AtomHiddenVar = AtomAdjust(AtomHiddenVar); TermHiddenVar = MkAtomTerm(AtomHiddenVar);
|
|
|
|
|
AtomVariable = AtomAdjust(AtomVariable); TermVariable = MkAtomTerm(AtomVariable);
|
|
|
|
|
AtomVerbose = AtomAdjust(AtomVerbose); TermVerbose = MkAtomTerm(AtomVerbose);
|
|
|
|
|
AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch);
|
|
|
|
|
AtomVersionNumber = AtomAdjust(AtomVersionNumber); TermVersionNumber = MkAtomTerm(AtomVersionNumber);
|
|
|
|
|
AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose);
|
|
|
|
|
AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal);
|
|
|
|
|
AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning);
|
|
|
|
|
AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen);
|
|
|
|
|
AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite);
|
|
|
|
|
AtomWriteTerm = AtomAdjust(AtomWriteTerm); TermWriteTerm = MkAtomTerm(AtomWriteTerm);
|
|
|
|
|
AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml);
|
|
|
|
|
AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks);
|
|
|
|
|
AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor);
|
|
|
|
|
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);
|
|
|
|
|
FunctorColon = FuncAdjust(FunctorColon);
|
|
|
|
|
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);
|
|
|
|
|
FunctorDollar = FuncAdjust(FunctorDollar);
|
|
|
|
|
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);
|
|
|
|
|
FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow);
|
|
|
|
|
FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash);
|
|
|
|
|
FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets);
|
|
|
|
|
FunctorEq = FuncAdjust(FunctorEq);
|
|
|
|
|
FunctorError = FuncAdjust(FunctorError);
|
|
|
|
|
FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);
|
|
|
|
|
FunctorException = FuncAdjust(FunctorException);
|
|
|
|
|
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);
|
|
|
|
|
FunctorI = FuncAdjust(FunctorI);
|
|
|
|
|
FunctorId = FuncAdjust(FunctorId);
|
|
|
|
|
FunctorInfo1 = FuncAdjust(FunctorInfo1);
|
|
|
|
|
FunctorInfo2 = FuncAdjust(FunctorInfo2);
|
|
|
|
|
FunctorInfo3 = FuncAdjust(FunctorInfo3);
|
|
|
|
|
FunctorInfo4 = FuncAdjust(FunctorInfo4);
|
|
|
|
|
FunctorIs = FuncAdjust(FunctorIs);
|
|
|
|
|
FunctorJ = FuncAdjust(FunctorJ);
|
|
|
|
|
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);
|
|
|
|
|
FunctorObj = FuncAdjust(FunctorObj);
|
|
|
|
|
FunctorOr = FuncAdjust(FunctorOr);
|
|
|
|
|
FunctorOutput = FuncAdjust(FunctorOutput);
|
|
|
|
|
FunctorPermissionError = FuncAdjust(FunctorPermissionError);
|
|
|
|
|
FunctorPlus = FuncAdjust(FunctorPlus);
|
|
|
|
|
FunctorPortray = FuncAdjust(FunctorPortray);
|
|
|
|
|
FunctorPrintMessage = FuncAdjust(FunctorPrintMessage);
|
|
|
|
|
FunctorProcedure = FuncAdjust(FunctorProcedure);
|
|
|
|
|
FunctorPriority = FuncAdjust(FunctorPriority);
|
|
|
|
|
FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint);
|
|
|
|
|
FunctorProtectStack = FuncAdjust(FunctorProtectStack);
|
|
|
|
|
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);
|
|
|
|
|
FunctorWriteTerm = FuncAdjust(FunctorWriteTerm);
|
|
|
|
|
FunctorHiddenVar = FuncAdjust(FunctorHiddenVar);
|
