From 4ccb8cf210a6fff5cdaccd6889520474c24b176e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Tue, 18 Aug 2015 14:50:27 -0500 Subject: [PATCH] more atom as terms stuff --- .gitignore | 4 + H/ihstruct.h | 48 +------ H/ratoms.h | 5 +- H/rhstruct.h | 48 +------ H/tatoms.h | 393 ++++++++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 401 insertions(+), 97 deletions(-) diff --git a/.gitignore b/.gitignore index 24d6d8c7b..611da148b 100644 --- a/.gitignore +++ b/.gitignore @@ -76,3 +76,7 @@ packages/bdd/CMakeFiles/CMakeDirectoryInformation.cmake C/new_iop.c *.pdf + +*.log + +*.orig diff --git a/H/ihstruct.h b/H/ihstruct.h index 6bbbfd1f9..c63ebabb7 100644 --- a/H/ihstruct.h +++ b/H/ihstruct.h @@ -1,6 +1,6 @@  - /* This file, ihstruct.h , was generated automatically by "yap -L misc/buildheap" - please do not update, update misc/HEAPFIELDS instead */ + /* This file, ihstruct.h, was generated automatically by "yap -L misc/buildheap" + please do not update, update misc/HEAPFIELDS instead */ @@ -86,50 +86,6 @@ #ifdef EUROTRA TermDollarU = MkAtomTerm(AtomDollarU); #endif - TermAppend = MkAtomTerm(AtomAppend); - TermAtom = MkAtomTerm(AtomAtom); - TermBinary = MkAtomTerm(AtomBinary); - TermBoolean = MkAtomTerm(AtomBoolean); - TermChars = MkAtomTerm(AtomChars); - TermCodes = MkAtomTerm(AtomCodes); - TermCompact = MkAtomTerm(AtomCompact); - TermDec10 = MkAtomTerm(AtomDec10); - TermDots = MkAtomTerm(AtomDots); - TermEof = MkAtomTerm(AtomEof); - TermEOfCode = MkAtomTerm(AtomEOfCode); - TermError = MkAtomTerm(AtomError); - TermException = MkAtomTerm(AtomException); - TermFail = MkAtomTerm(AtomFail); - TermFalse = MkAtomTerm(AtomFalse); - TermFloat = MkAtomTerm(AtomFloat); - TermGlobal = MkAtomTerm(AtomGlobal); - TermIgnore = MkAtomTerm(AtomIgnore); - TermInteger = MkAtomTerm(AtomInteger); - TermMax = MkAtomTerm(AtomMax); - TermModule = MkAtomTerm(AtomModule); - TermMulti = MkAtomTerm(AtomMulti); - TermOff = MkAtomTerm(AtomOff); - TermOn = MkAtomTerm(AtomOn); - TermPortray = MkAtomTerm(AtomPortray); - TermProlog = MkAtomTerm(AtomProlog); - TermQuiet = MkAtomTerm(AtomQuiet); - TermRead = MkAtomTerm(AtomRead); - TermReadOnly = MkAtomTerm(AtomReadOnly); - TermReadWrite = MkAtomTerm(AtomReadWrite); - TermReFoundVar = MkAtomTerm(AtomRefoundVar); - TermReset = MkAtomTerm(AtomReset); - TermSilent = MkAtomTerm(AtomSilent); - TermSingle = MkAtomTerm(AtomSingle); - TermSource = MkAtomTerm(AtomSource); - TermString = MkAtomTerm(AtomString); - TermSymbolChar = MkAtomTerm(AtomSymbolChar); - TermTerm = MkAtomTerm(AtomTerm); - TermText = MkAtomTerm(AtomText); - TermThread = MkAtomTerm(AtomThread); - TermTrue = MkAtomTerm(AtomTrue); - TermWarning = MkAtomTerm(AtomWarning); - TermWrite = MkAtomTerm(AtomWrite); - TermXml = MkAtomTerm(AtomXml); USER_MODULE = MkAtomTerm(AtomUser); IDB_MODULE = MkAtomTerm(AtomIDB); diff --git a/H/ratoms.h b/H/ratoms.h index 8e28bc9ff..b3950570f 100644 --- a/H/ratoms.h +++ b/H/ratoms.h @@ -1,4 +1,4 @@ - + /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" please do not update, update misc/ATOMS instead */ @@ -217,6 +217,8 @@ AtomNb = AtomAdjust(AtomNb); AtomNbTerm = AtomAdjust(AtomNbTerm); AtomNew = AtomAdjust(AtomNew); + AtomNewLine = AtomAdjust(AtomNewLine); + AtomNl = AtomAdjust(AtomNl); AtomNoEffect = AtomAdjust(AtomNoEffect); AtomNoMemory = AtomAdjust(AtomNoMemory); AtomNone = AtomAdjust(AtomNone); @@ -262,7 +264,6 @@ AtomProcedure = AtomAdjust(AtomProcedure); AtomProfile = AtomAdjust(AtomProfile); AtomProlog = AtomAdjust(AtomProlog); - AtomPtr = AtomAdjust(AtomPtr); AtomQuery = AtomAdjust(AtomQuery); AtomQueue = AtomAdjust(AtomQueue); AtomQuiet = AtomAdjust(AtomQuiet); diff --git a/H/rhstruct.h b/H/rhstruct.h index e3475b96a..3e145155c 100644 --- a/H/rhstruct.h +++ b/H/rhstruct.h @@ -1,6 +1,6 @@  - /* This file, rhstruct.h , was generated automatically by "yap -L misc/buildheap" - please do not update, update misc/HEAPFIELDS instead */ + /* This file, rhstruct.h, was generated automatically by "yap -L misc/buildheap" + please do not update, update misc/HEAPFIELDS instead */ @@ -86,50 +86,6 @@ #ifdef EUROTRA TermDollarU = AtomTermAdjust(TermDollarU); #endif - TermAppend = AtomTermAdjust(TermAppend); - TermAtom = AtomTermAdjust(TermAtom); - TermBinary = AtomTermAdjust(TermBinary); - TermBoolean = AtomTermAdjust(TermBoolean); - TermChars = AtomTermAdjust(TermChars); - TermCodes = AtomTermAdjust(TermCodes); - TermCompact = AtomTermAdjust(TermCompact); - TermDec10 = AtomTermAdjust(TermDec10); - TermDots = AtomTermAdjust(TermDots); - TermEof = AtomTermAdjust(TermEof); - TermEOfCode = AtomTermAdjust(TermEOfCode); - TermError = AtomTermAdjust(TermError); - TermException = AtomTermAdjust(TermException); - TermFail = AtomTermAdjust(TermFail); - TermFalse = AtomTermAdjust(TermFalse); - TermFloat = AtomTermAdjust(TermFloat); - TermGlobal = AtomTermAdjust(TermGlobal); - TermIgnore = AtomTermAdjust(TermIgnore); - TermInteger = AtomTermAdjust(TermInteger); - TermMax = AtomTermAdjust(TermMax); - TermModule = AtomTermAdjust(TermModule); - TermMulti = AtomTermAdjust(TermMulti); - TermOff = AtomTermAdjust(TermOff); - TermOn = AtomTermAdjust(TermOn); - TermPortray = AtomTermAdjust(TermPortray); - TermProlog = AtomTermAdjust(TermProlog); - TermQuiet = AtomTermAdjust(TermQuiet); - TermRead = AtomTermAdjust(TermRead); - TermReadOnly = AtomTermAdjust(TermReadOnly); - TermReadWrite = AtomTermAdjust(TermReadWrite); - TermReFoundVar = AtomTermAdjust(TermReFoundVar); - TermReset = AtomTermAdjust(TermReset); - TermSilent = AtomTermAdjust(TermSilent); - TermSingle = AtomTermAdjust(TermSingle); - TermSource = AtomTermAdjust(TermSource); - TermString = AtomTermAdjust(TermString); - TermSymbolChar = AtomTermAdjust(TermSymbolChar); - TermTerm = AtomTermAdjust(TermTerm); - TermText = AtomTermAdjust(TermText); - TermThread = AtomTermAdjust(TermThread); - TermTrue = AtomTermAdjust(TermTrue); - TermWarning = AtomTermAdjust(TermWarning); - TermWrite = AtomTermAdjust(TermWrite); - TermXml = AtomTermAdjust(TermXml); USER_MODULE = AtomTermAdjust(USER_MODULE); IDB_MODULE = AtomTermAdjust(IDB_MODULE); diff --git a/H/tatoms.h b/H/tatoms.h index ee5858f48..efee32272 100644 --- a/H/tatoms.h +++ b/H/tatoms.h @@ -1,775 +1,1162 @@ - + /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" please do not update, update misc/ATOMS instead */ Atom Atom3Dots_; #define Atom3Dots Yap_heap_regs->Atom3Dots_ +#define Term3Dots MkAtomTerm( Yap_heap_regs->Atom3Dots_ ) Atom AtomAbol_; #define AtomAbol Yap_heap_regs->AtomAbol_ +#define TermAbol MkAtomTerm( Yap_heap_regs->AtomAbol_ ) Atom AtomAccess_; #define AtomAccess Yap_heap_regs->AtomAccess_ +#define TermAccess MkAtomTerm( Yap_heap_regs->AtomAccess_ ) Atom AtomAfInet_; #define AtomAfInet Yap_heap_regs->AtomAfInet_ +#define TermAfInet MkAtomTerm( Yap_heap_regs->AtomAfInet_ ) Atom AtomAfLocal_; #define AtomAfLocal Yap_heap_regs->AtomAfLocal_ +#define TermAfLocal MkAtomTerm( Yap_heap_regs->AtomAfLocal_ ) Atom AtomAfUnix_; #define AtomAfUnix Yap_heap_regs->AtomAfUnix_ +#define TermAfUnix MkAtomTerm( Yap_heap_regs->AtomAfUnix_ ) Atom AtomAlarm_; #define AtomAlarm Yap_heap_regs->AtomAlarm_ +#define TermAlarm MkAtomTerm( Yap_heap_regs->AtomAlarm_ ) Atom AtomAlias_; #define AtomAlias Yap_heap_regs->AtomAlias_ +#define TermAlias MkAtomTerm( Yap_heap_regs->AtomAlias_ ) Atom AtomAltNot_; #define AtomAltNot Yap_heap_regs->AtomAltNot_ +#define TermAltNot MkAtomTerm( Yap_heap_regs->AtomAltNot_ ) Atom AtomAny_; #define AtomAny Yap_heap_regs->AtomAny_ +#define TermAny MkAtomTerm( Yap_heap_regs->AtomAny_ ) Atom AtomAppend_; #define AtomAppend Yap_heap_regs->AtomAppend_ +#define TermAppend MkAtomTerm( Yap_heap_regs->AtomAppend_ ) Atom AtomArg_; #define AtomArg Yap_heap_regs->AtomArg_ +#define TermArg MkAtomTerm( Yap_heap_regs->AtomArg_ ) Atom AtomArray_; #define AtomArray Yap_heap_regs->AtomArray_ +#define TermArray MkAtomTerm( Yap_heap_regs->AtomArray_ ) Atom AtomArrayAccess_; #define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_ +#define TermArrayAccess MkAtomTerm( Yap_heap_regs->AtomArrayAccess_ ) Atom AtomArrayOverflow_; #define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_ +#define TermArrayOverflow MkAtomTerm( Yap_heap_regs->AtomArrayOverflow_ ) Atom AtomArrayType_; #define AtomArrayType Yap_heap_regs->AtomArrayType_ +#define TermArrayType MkAtomTerm( Yap_heap_regs->AtomArrayType_ ) Atom AtomArrow_; #define AtomArrow Yap_heap_regs->AtomArrow_ +#define TermArrow MkAtomTerm( Yap_heap_regs->AtomArrow_ ) Atom AtomDoubleArrow_; #define AtomDoubleArrow Yap_heap_regs->AtomDoubleArrow_ +#define TermDoubleArrow MkAtomTerm( Yap_heap_regs->AtomDoubleArrow_ ) Atom AtomAssert_; #define AtomAssert Yap_heap_regs->AtomAssert_ +#define TermAssert MkAtomTerm( Yap_heap_regs->AtomAssert_ ) Atom AtomEmptyBrackets_; #define AtomEmptyBrackets Yap_heap_regs->AtomEmptyBrackets_ +#define TermEmptyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyBrackets_ ) Atom AtomEmptySquareBrackets_; #define AtomEmptySquareBrackets Yap_heap_regs->AtomEmptySquareBrackets_ +#define TermEmptySquareBrackets MkAtomTerm( Yap_heap_regs->AtomEmptySquareBrackets_ ) Atom AtomEmptyCurlyBrackets_; #define AtomEmptyCurlyBrackets Yap_heap_regs->AtomEmptyCurlyBrackets_ +#define TermEmptyCurlyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyCurlyBrackets_ ) Atom AtomAt_; #define AtomAt Yap_heap_regs->AtomAt_ +#define TermAt MkAtomTerm( Yap_heap_regs->AtomAt_ ) Atom AtomAtom_; #define AtomAtom Yap_heap_regs->AtomAtom_ +#define TermAtom MkAtomTerm( Yap_heap_regs->AtomAtom_ ) Atom AtomAtomic_; #define AtomAtomic Yap_heap_regs->AtomAtomic_ +#define TermAtomic MkAtomTerm( Yap_heap_regs->AtomAtomic_ ) Atom AtomAtt_; #define AtomAtt Yap_heap_regs->AtomAtt_ +#define TermAtt MkAtomTerm( Yap_heap_regs->AtomAtt_ ) Atom AtomAtt1_; #define AtomAtt1 Yap_heap_regs->AtomAtt1_ +#define TermAtt1 MkAtomTerm( Yap_heap_regs->AtomAtt1_ ) Atom AtomAttDo_; #define AtomAttDo Yap_heap_regs->AtomAttDo_ +#define TermAttDo MkAtomTerm( Yap_heap_regs->AtomAttDo_ ) Atom AtomAttributes_; #define AtomAttributes Yap_heap_regs->AtomAttributes_ +#define TermAttributes MkAtomTerm( Yap_heap_regs->AtomAttributes_ ) Atom AtomB_; #define AtomB Yap_heap_regs->AtomB_ +#define TermB MkAtomTerm( Yap_heap_regs->AtomB_ ) Atom AtomBatched_; #define AtomBatched Yap_heap_regs->AtomBatched_ +#define TermBatched MkAtomTerm( Yap_heap_regs->AtomBatched_ ) Atom AtomBetween_; #define AtomBetween Yap_heap_regs->AtomBetween_ +#define TermBetween MkAtomTerm( Yap_heap_regs->AtomBetween_ ) Atom AtomBinary_; #define AtomBinary Yap_heap_regs->AtomBinary_ +#define TermBinary MkAtomTerm( Yap_heap_regs->AtomBinary_ ) Atom AtomBigNum_; #define AtomBigNum Yap_heap_regs->AtomBigNum_ +#define TermBigNum MkAtomTerm( Yap_heap_regs->AtomBigNum_ ) Atom AtomBinaryStream_; #define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_ +#define TermBinaryStream MkAtomTerm( Yap_heap_regs->AtomBinaryStream_ ) Atom AtomBoolean_; #define AtomBoolean Yap_heap_regs->AtomBoolean_ +#define TermBoolean MkAtomTerm( Yap_heap_regs->AtomBoolean_ ) Atom AtomBraces_; #define AtomBraces Yap_heap_regs->AtomBraces_ +#define TermBraces MkAtomTerm( Yap_heap_regs->AtomBraces_ ) Atom AtomBreak_; #define AtomBreak Yap_heap_regs->AtomBreak_ +#define TermBreak MkAtomTerm( Yap_heap_regs->AtomBreak_ ) Atom AtomByte_; #define AtomByte Yap_heap_regs->AtomByte_ +#define TermByte MkAtomTerm( Yap_heap_regs->AtomByte_ ) Atom AtomCArith_; #define AtomCArith Yap_heap_regs->AtomCArith_ +#define TermCArith MkAtomTerm( Yap_heap_regs->AtomCArith_ ) Atom AtomCall_; #define AtomCall Yap_heap_regs->AtomCall_ +#define TermCall MkAtomTerm( Yap_heap_regs->AtomCall_ ) Atom AtomCallAndRetryCounter_; #define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_ +#define TermCallAndRetryCounter MkAtomTerm( Yap_heap_regs->AtomCallAndRetryCounter_ ) Atom AtomCallCounter_; #define AtomCallCounter Yap_heap_regs->AtomCallCounter_ +#define TermCallCounter MkAtomTerm( Yap_heap_regs->AtomCallCounter_ ) Atom AtomCallable_; #define AtomCallable Yap_heap_regs->AtomCallable_ +#define TermCallable MkAtomTerm( Yap_heap_regs->AtomCallable_ ) Atom AtomCatch_; #define AtomCatch Yap_heap_regs->AtomCatch_ +#define TermCatch MkAtomTerm( Yap_heap_regs->AtomCatch_ ) Atom AtomChangeModule_; #define AtomChangeModule Yap_heap_regs->AtomChangeModule_ +#define TermChangeModule MkAtomTerm( Yap_heap_regs->AtomChangeModule_ ) Atom AtomChar_; #define AtomChar Yap_heap_regs->AtomChar_ +#define TermChar MkAtomTerm( Yap_heap_regs->AtomChar_ ) Atom AtomCharsio_; #define AtomCharsio Yap_heap_regs->AtomCharsio_ +#define TermCharsio MkAtomTerm( Yap_heap_regs->AtomCharsio_ ) Atom AtomCharacter_; #define AtomCharacter Yap_heap_regs->AtomCharacter_ +#define TermCharacter MkAtomTerm( Yap_heap_regs->AtomCharacter_ ) Atom AtomCharacterCode_; #define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_ +#define TermCharacterCode MkAtomTerm( Yap_heap_regs->AtomCharacterCode_ ) Atom AtomChars_; #define AtomChars Yap_heap_regs->AtomChars_ +#define TermChars MkAtomTerm( Yap_heap_regs->AtomChars_ ) Atom AtomCharset_; #define AtomCharset Yap_heap_regs->AtomCharset_ +#define TermCharset MkAtomTerm( Yap_heap_regs->AtomCharset_ ) Atom AtomCleanCall_; #define AtomCleanCall Yap_heap_regs->AtomCleanCall_ +#define TermCleanCall MkAtomTerm( Yap_heap_regs->AtomCleanCall_ ) Atom AtomColomn_; #define AtomColomn Yap_heap_regs->AtomColomn_ +#define TermColomn MkAtomTerm( Yap_heap_regs->AtomColomn_ ) Atom AtomCodeSpace_; #define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_ +#define TermCodeSpace MkAtomTerm( Yap_heap_regs->AtomCodeSpace_ ) Atom AtomCodes_; #define AtomCodes Yap_heap_regs->AtomCodes_ +#define TermCodes MkAtomTerm( Yap_heap_regs->AtomCodes_ ) Atom AtomCoInductive_; #define AtomCoInductive Yap_heap_regs->AtomCoInductive_ +#define TermCoInductive MkAtomTerm( Yap_heap_regs->AtomCoInductive_ ) Atom AtomComma_; #define AtomComma Yap_heap_regs->AtomComma_ +#define TermComma MkAtomTerm( Yap_heap_regs->AtomComma_ ) Atom AtomCommentHook_; #define AtomCommentHook Yap_heap_regs->AtomCommentHook_ +#define TermCommentHook MkAtomTerm( Yap_heap_regs->AtomCommentHook_ ) Atom AtomCompact_; #define AtomCompact Yap_heap_regs->AtomCompact_ +#define TermCompact MkAtomTerm( Yap_heap_regs->AtomCompact_ ) Atom AtomCompound_; #define AtomCompound Yap_heap_regs->AtomCompound_ +#define TermCompound MkAtomTerm( Yap_heap_regs->AtomCompound_ ) Atom AtomConsistencyError_; #define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_ +#define TermConsistencyError MkAtomTerm( Yap_heap_regs->AtomConsistencyError_ ) Atom AtomConsultOnBoot_; #define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_ +#define TermConsultOnBoot MkAtomTerm( Yap_heap_regs->AtomConsultOnBoot_ ) Atom AtomContext_; #define AtomContext Yap_heap_regs->AtomContext_ +#define TermContext MkAtomTerm( Yap_heap_regs->AtomContext_ ) Atom AtomCputime_; #define AtomCputime Yap_heap_regs->AtomCputime_ +#define TermCputime MkAtomTerm( Yap_heap_regs->AtomCputime_ ) Atom AtomCreate_; #define AtomCreate Yap_heap_regs->AtomCreate_ +#define TermCreate MkAtomTerm( Yap_heap_regs->AtomCreate_ ) Atom AtomCreep_; #define AtomCreep Yap_heap_regs->AtomCreep_ +#define TermCreep MkAtomTerm( Yap_heap_regs->AtomCreep_ ) Atom AtomCryptAtoms_; #define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_ +#define TermCryptAtoms MkAtomTerm( Yap_heap_regs->AtomCryptAtoms_ ) Atom AtomCsult_; #define AtomCsult Yap_heap_regs->AtomCsult_ +#define TermCsult MkAtomTerm( Yap_heap_regs->AtomCsult_ ) Atom AtomCurrentModule_; #define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_ +#define TermCurrentModule MkAtomTerm( Yap_heap_regs->AtomCurrentModule_ ) Atom AtomCut_; #define AtomCut Yap_heap_regs->AtomCut_ +#define TermCut MkAtomTerm( Yap_heap_regs->AtomCut_ ) Atom AtomCutBy_; #define AtomCutBy Yap_heap_regs->AtomCutBy_ +#define TermCutBy MkAtomTerm( Yap_heap_regs->AtomCutBy_ ) Atom AtomDAbort_; #define AtomDAbort Yap_heap_regs->AtomDAbort_ +#define TermDAbort MkAtomTerm( Yap_heap_regs->AtomDAbort_ ) Atom AtomDBLoad_; #define AtomDBLoad Yap_heap_regs->AtomDBLoad_ +#define TermDBLoad MkAtomTerm( Yap_heap_regs->AtomDBLoad_ ) Atom AtomDBREF_; #define AtomDBREF Yap_heap_regs->AtomDBREF_ +#define TermDBREF MkAtomTerm( Yap_heap_regs->AtomDBREF_ ) Atom AtomDBReference_; #define AtomDBReference Yap_heap_regs->AtomDBReference_ +#define TermDBReference MkAtomTerm( Yap_heap_regs->AtomDBReference_ ) Atom AtomDBTerm_; #define AtomDBTerm Yap_heap_regs->AtomDBTerm_ +#define TermDBTerm MkAtomTerm( Yap_heap_regs->AtomDBTerm_ ) Atom AtomDBref_; #define AtomDBref Yap_heap_regs->AtomDBref_ +#define TermDBref MkAtomTerm( Yap_heap_regs->AtomDBref_ ) Atom AtomDInteger_; #define AtomDInteger Yap_heap_regs->AtomDInteger_ +#define TermDInteger MkAtomTerm( Yap_heap_regs->AtomDInteger_ ) Atom AtomDebugMeta_; #define AtomDebugMeta Yap_heap_regs->AtomDebugMeta_ +#define TermDebugMeta MkAtomTerm( Yap_heap_regs->AtomDebugMeta_ ) Atom AtomDebuggerInput_; #define AtomDebuggerInput Yap_heap_regs->AtomDebuggerInput_ +#define TermDebuggerInput MkAtomTerm( Yap_heap_regs->AtomDebuggerInput_ ) Atom AtomDec10_; #define AtomDec10 Yap_heap_regs->AtomDec10_ +#define TermDec10 MkAtomTerm( Yap_heap_regs->AtomDec10_ ) Atom AtomDefault_; #define AtomDefault Yap_heap_regs->AtomDefault_ +#define TermDefault MkAtomTerm( Yap_heap_regs->AtomDefault_ ) Atom AtomDevNull_; #define AtomDevNull Yap_heap_regs->AtomDevNull_ +#define TermDevNull MkAtomTerm( Yap_heap_regs->AtomDevNull_ ) Atom AtomDiff_; #define AtomDiff Yap_heap_regs->AtomDiff_ +#define TermDiff MkAtomTerm( Yap_heap_regs->AtomDiff_ ) Atom AtomDiscontiguous_; #define AtomDiscontiguous Yap_heap_regs->AtomDiscontiguous_ +#define TermDiscontiguous MkAtomTerm( Yap_heap_regs->AtomDiscontiguous_ ) Atom AtomDiscontiguousWarnings_; #define AtomDiscontiguousWarnings Yap_heap_regs->AtomDiscontiguousWarnings_ +#define TermDiscontiguousWarnings MkAtomTerm( Yap_heap_regs->AtomDiscontiguousWarnings_ ) Atom AtomDollar_; #define AtomDollar Yap_heap_regs->AtomDollar_ +#define TermDollar MkAtomTerm( Yap_heap_regs->AtomDollar_ ) Atom AtomDoLogUpdClause_; #define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_ +#define TermDoLogUpdClause MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause_ ) Atom AtomDoLogUpdClause0_; #define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_ +#define TermDoLogUpdClause0 MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause0_ ) Atom AtomDoLogUpdClauseErase_; #define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_ +#define TermDoLogUpdClauseErase MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClauseErase_ ) Atom AtomDollarU_; #define AtomDollarU Yap_heap_regs->AtomDollarU_ +#define TermDollarU MkAtomTerm( Yap_heap_regs->AtomDollarU_ ) Atom AtomDollarUndef_; #define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_ +#define TermDollarUndef MkAtomTerm( Yap_heap_regs->AtomDollarUndef_ ) Atom AtomDomainError_; #define AtomDomainError Yap_heap_regs->AtomDomainError_ +#define TermDomainError MkAtomTerm( Yap_heap_regs->AtomDomainError_ ) Atom AtomDoStaticClause_; #define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_ +#define TermDoStaticClause MkAtomTerm( Yap_heap_regs->AtomDoStaticClause_ ) Atom AtomDots_; #define AtomDots Yap_heap_regs->AtomDots_ +#define TermDots MkAtomTerm( Yap_heap_regs->AtomDots_ ) Atom AtomDOUBLE_; #define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_ +#define TermDOUBLE MkAtomTerm( Yap_heap_regs->AtomDOUBLE_ ) Atom AtomE_; #define AtomE Yap_heap_regs->AtomE_ +#define TermE MkAtomTerm( Yap_heap_regs->AtomE_ ) Atom AtomEOFBeforeEOT_; #define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_ +#define TermEOFBeforeEOT MkAtomTerm( Yap_heap_regs->AtomEOFBeforeEOT_ ) Atom AtomEQ_; #define AtomEQ Yap_heap_regs->AtomEQ_ +#define TermEQ MkAtomTerm( Yap_heap_regs->AtomEQ_ ) Atom AtomEmptyAtom_; #define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_ +#define TermEmptyAtom MkAtomTerm( Yap_heap_regs->AtomEmptyAtom_ ) Atom AtomEncoding_; #define AtomEncoding Yap_heap_regs->AtomEncoding_ +#define TermEncoding MkAtomTerm( Yap_heap_regs->AtomEncoding_ ) Atom AtomEndOfStream_; #define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_ +#define TermEndOfStream MkAtomTerm( Yap_heap_regs->AtomEndOfStream_ ) Atom AtomEof_; #define AtomEof Yap_heap_regs->AtomEof_ +#define TermEof MkAtomTerm( Yap_heap_regs->AtomEof_ ) Atom AtomEOfCode_; #define AtomEOfCode Yap_heap_regs->AtomEOfCode_ +#define TermEOfCode MkAtomTerm( Yap_heap_regs->AtomEOfCode_ ) Atom AtomEq_; #define AtomEq Yap_heap_regs->AtomEq_ +#define TermEq MkAtomTerm( Yap_heap_regs->AtomEq_ ) Atom AtomError_; #define AtomError Yap_heap_regs->AtomError_ +#define TermError MkAtomTerm( Yap_heap_regs->AtomError_ ) Atom AtomException_; #define AtomException Yap_heap_regs->AtomException_ +#define TermException MkAtomTerm( Yap_heap_regs->AtomException_ ) Atom AtomEvaluable_; #define AtomEvaluable Yap_heap_regs->AtomEvaluable_ +#define TermEvaluable MkAtomTerm( Yap_heap_regs->AtomEvaluable_ ) Atom AtomEvaluationError_; #define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_ +#define TermEvaluationError MkAtomTerm( Yap_heap_regs->AtomEvaluationError_ ) Atom AtomExecute_; #define AtomExecute Yap_heap_regs->AtomExecute_ +#define TermExecute MkAtomTerm( Yap_heap_regs->AtomExecute_ ) Atom AtomExecAnswers_; #define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_ +#define TermExecAnswers MkAtomTerm( Yap_heap_regs->AtomExecAnswers_ ) Atom AtomExecuteInMod_; #define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_ +#define TermExecuteInMod MkAtomTerm( Yap_heap_regs->AtomExecuteInMod_ ) Atom AtomExecuteWithin_; #define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_ +#define TermExecuteWithin MkAtomTerm( Yap_heap_regs->AtomExecuteWithin_ ) Atom AtomExecuteWoMod_; #define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_ +#define TermExecuteWoMod MkAtomTerm( Yap_heap_regs->AtomExecuteWoMod_ ) Atom AtomExist_; #define AtomExist Yap_heap_regs->AtomExist_ +#define TermExist MkAtomTerm( Yap_heap_regs->AtomExist_ ) Atom AtomExistenceError_; #define AtomExistenceError Yap_heap_regs->AtomExistenceError_ +#define TermExistenceError MkAtomTerm( Yap_heap_regs->AtomExistenceError_ ) Atom AtomExoClause_; #define AtomExoClause Yap_heap_regs->AtomExoClause_ +#define TermExoClause MkAtomTerm( Yap_heap_regs->AtomExoClause_ ) Atom AtomExpectedNumber_; #define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_ +#define TermExpectedNumber MkAtomTerm( Yap_heap_regs->AtomExpectedNumber_ ) Atom AtomExtendFileSearchPath_; #define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_ +#define TermExtendFileSearchPath MkAtomTerm( Yap_heap_regs->AtomExtendFileSearchPath_ ) Atom AtomFB_; #define AtomFB Yap_heap_regs->AtomFB_ +#define TermFB MkAtomTerm( Yap_heap_regs->AtomFB_ ) Atom AtomFail_; #define AtomFail Yap_heap_regs->AtomFail_ +#define TermFail MkAtomTerm( Yap_heap_regs->AtomFail_ ) Atom AtomFalse_; #define AtomFalse Yap_heap_regs->AtomFalse_ +#define TermFalse MkAtomTerm( Yap_heap_regs->AtomFalse_ ) Atom AtomFast_; #define AtomFast Yap_heap_regs->AtomFast_ +#define TermFast MkAtomTerm( Yap_heap_regs->AtomFast_ ) Atom AtomFileerrors_; #define AtomFileerrors Yap_heap_regs->AtomFileerrors_ +#define TermFileerrors MkAtomTerm( Yap_heap_regs->AtomFileerrors_ ) Atom AtomFloat_; #define AtomFloat Yap_heap_regs->AtomFloat_ +#define TermFloat MkAtomTerm( Yap_heap_regs->AtomFloat_ ) Atom AtomFloatFormat_; #define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_ +#define TermFloatFormat MkAtomTerm( Yap_heap_regs->AtomFloatFormat_ ) Atom AtomFloatOverflow_; #define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_ +#define TermFloatOverflow MkAtomTerm( Yap_heap_regs->AtomFloatOverflow_ ) Atom AtomFloatUnderflow_; #define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_ +#define TermFloatUnderflow MkAtomTerm( Yap_heap_regs->AtomFloatUnderflow_ ) Atom AtomFormat_; #define AtomFormat Yap_heap_regs->AtomFormat_ +#define TermFormat MkAtomTerm( Yap_heap_regs->AtomFormat_ ) Atom AtomFormatAt_; #define AtomFormatAt Yap_heap_regs->AtomFormatAt_ +#define TermFormatAt MkAtomTerm( Yap_heap_regs->AtomFormatAt_ ) Atom AtomFull_; #define AtomFull Yap_heap_regs->AtomFull_ +#define TermFull MkAtomTerm( Yap_heap_regs->AtomFull_ ) Atom AtomFunctor_; #define AtomFunctor Yap_heap_regs->AtomFunctor_ +#define TermFunctor MkAtomTerm( Yap_heap_regs->AtomFunctor_ ) Atom AtomGT_; #define AtomGT Yap_heap_regs->AtomGT_ +#define TermGT MkAtomTerm( Yap_heap_regs->AtomGT_ ) Atom AtomGVar_; #define AtomGVar Yap_heap_regs->AtomGVar_ +#define TermGVar MkAtomTerm( Yap_heap_regs->AtomGVar_ ) Atom AtomGc_; #define AtomGc Yap_heap_regs->AtomGc_ +#define TermGc MkAtomTerm( Yap_heap_regs->AtomGc_ ) Atom AtomGcMargin_; #define AtomGcMargin Yap_heap_regs->AtomGcMargin_ +#define TermGcMargin MkAtomTerm( Yap_heap_regs->AtomGcMargin_ ) Atom AtomGcTrace_; #define AtomGcTrace Yap_heap_regs->AtomGcTrace_ +#define TermGcTrace MkAtomTerm( Yap_heap_regs->AtomGcTrace_ ) Atom AtomGcVerbose_; #define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_ +#define TermGcVerbose MkAtomTerm( Yap_heap_regs->AtomGcVerbose_ ) Atom AtomGcVeryVerbose_; #define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_ +#define TermGcVeryVerbose MkAtomTerm( Yap_heap_regs->AtomGcVeryVerbose_ ) Atom AtomGeneratePredInfo_; #define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_ +#define TermGeneratePredInfo MkAtomTerm( Yap_heap_regs->AtomGeneratePredInfo_ ) Atom AtomGetwork_; #define AtomGetwork Yap_heap_regs->AtomGetwork_ +#define TermGetwork MkAtomTerm( Yap_heap_regs->AtomGetwork_ ) Atom AtomGetworkSeq_; #define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_ +#define TermGetworkSeq MkAtomTerm( Yap_heap_regs->AtomGetworkSeq_ ) Atom AtomGlobal_; #define AtomGlobal Yap_heap_regs->AtomGlobal_ +#define TermGlobal MkAtomTerm( Yap_heap_regs->AtomGlobal_ ) Atom AtomGlobalSp_; #define AtomGlobalSp Yap_heap_regs->AtomGlobalSp_ +#define TermGlobalSp MkAtomTerm( Yap_heap_regs->AtomGlobalSp_ ) Atom AtomGlobalTrie_; #define AtomGlobalTrie Yap_heap_regs->AtomGlobalTrie_ +#define TermGlobalTrie MkAtomTerm( Yap_heap_regs->AtomGlobalTrie_ ) Atom AtomGoalExpansion_; #define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_ +#define TermGoalExpansion MkAtomTerm( Yap_heap_regs->AtomGoalExpansion_ ) Atom AtomHat_; #define AtomHat Yap_heap_regs->AtomHat_ +#define TermHat MkAtomTerm( Yap_heap_regs->AtomHat_ ) Atom AtomHERE_; #define AtomHERE Yap_heap_regs->AtomHERE_ +#define TermHERE MkAtomTerm( Yap_heap_regs->AtomHERE_ ) Atom AtomHandleThrow_; #define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_ +#define TermHandleThrow MkAtomTerm( Yap_heap_regs->AtomHandleThrow_ ) Atom AtomHeap_; #define AtomHeap Yap_heap_regs->AtomHeap_ +#define TermHeap MkAtomTerm( Yap_heap_regs->AtomHeap_ ) Atom AtomHeapUsed_; #define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_ +#define TermHeapUsed MkAtomTerm( Yap_heap_regs->AtomHeapUsed_ ) Atom AtomHugeInt_; #define AtomHugeInt Yap_heap_regs->AtomHugeInt_ +#define TermHugeInt MkAtomTerm( Yap_heap_regs->AtomHugeInt_ ) Atom AtomIDB_; #define AtomIDB Yap_heap_regs->AtomIDB_ +#define TermIDB MkAtomTerm( Yap_heap_regs->AtomIDB_ ) Atom AtomIOMode_; #define AtomIOMode Yap_heap_regs->AtomIOMode_ +#define TermIOMode MkAtomTerm( Yap_heap_regs->AtomIOMode_ ) Atom AtomId_; #define AtomId Yap_heap_regs->AtomId_ +#define TermId MkAtomTerm( Yap_heap_regs->AtomId_ ) Atom AtomIgnore_; #define AtomIgnore Yap_heap_regs->AtomIgnore_ +#define TermIgnore MkAtomTerm( Yap_heap_regs->AtomIgnore_ ) Atom AtomInf_; #define AtomInf Yap_heap_regs->AtomInf_ +#define TermInf MkAtomTerm( Yap_heap_regs->AtomInf_ ) Atom AtomInfinity_; #define AtomInfinity Yap_heap_regs->AtomInfinity_ +#define TermInfinity MkAtomTerm( Yap_heap_regs->AtomInfinity_ ) Atom AtomInitGoal_; #define AtomInitGoal Yap_heap_regs->AtomInitGoal_ +#define TermInitGoal MkAtomTerm( Yap_heap_regs->AtomInitGoal_ ) Atom AtomInitProlog_; #define AtomInitProlog Yap_heap_regs->AtomInitProlog_ +#define TermInitProlog MkAtomTerm( Yap_heap_regs->AtomInitProlog_ ) Atom AtomInStackExpansion_; #define AtomInStackExpansion Yap_heap_regs->AtomInStackExpansion_ +#define TermInStackExpansion MkAtomTerm( Yap_heap_regs->AtomInStackExpansion_ ) Atom AtomInput_; #define AtomInput Yap_heap_regs->AtomInput_ +#define TermInput MkAtomTerm( Yap_heap_regs->AtomInput_ ) Atom AtomInstantiationError_; #define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_ +#define TermInstantiationError MkAtomTerm( Yap_heap_regs->AtomInstantiationError_ ) Atom AtomInt_; #define AtomInt Yap_heap_regs->AtomInt_ +#define TermInt MkAtomTerm( Yap_heap_regs->AtomInt_ ) Atom AtomIntOverflow_; #define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_ +#define TermIntOverflow MkAtomTerm( Yap_heap_regs->AtomIntOverflow_ ) Atom AtomInteger_; #define AtomInteger Yap_heap_regs->AtomInteger_ +#define TermInteger MkAtomTerm( Yap_heap_regs->AtomInteger_ ) Atom AtomInternalCompilerError_; #define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_ +#define TermInternalCompilerError MkAtomTerm( Yap_heap_regs->AtomInternalCompilerError_ ) Atom AtomIs_; #define AtomIs Yap_heap_regs->AtomIs_ +#define TermIs MkAtomTerm( Yap_heap_regs->AtomIs_ ) Atom AtomKey_; #define AtomKey Yap_heap_regs->AtomKey_ +#define TermKey MkAtomTerm( Yap_heap_regs->AtomKey_ ) Atom AtomLDLibraryPath_; #define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_ +#define TermLDLibraryPath MkAtomTerm( Yap_heap_regs->AtomLDLibraryPath_ ) Atom AtomLONGINT_; #define AtomLONGINT Yap_heap_regs->AtomLONGINT_ +#define TermLONGINT MkAtomTerm( Yap_heap_regs->AtomLONGINT_ ) Atom AtomLOOP_; #define AtomLOOP Yap_heap_regs->AtomLOOP_ +#define TermLOOP MkAtomTerm( Yap_heap_regs->AtomLOOP_ ) Atom AtomLoopStream_; #define AtomLoopStream Yap_heap_regs->AtomLoopStream_ +#define TermLoopStream MkAtomTerm( Yap_heap_regs->AtomLoopStream_ ) Atom AtomLT_; #define AtomLT Yap_heap_regs->AtomLT_ +#define TermLT MkAtomTerm( Yap_heap_regs->AtomLT_ ) Atom AtomLastExecuteWithin_; #define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_ +#define TermLastExecuteWithin MkAtomTerm( Yap_heap_regs->AtomLastExecuteWithin_ ) Atom AtomLeash_; #define AtomLeash Yap_heap_regs->AtomLeash_ +#define TermLeash MkAtomTerm( Yap_heap_regs->AtomLeash_ ) Atom AtomLeast_; #define AtomLeast Yap_heap_regs->AtomLeast_ +#define TermLeast MkAtomTerm( Yap_heap_regs->AtomLeast_ ) Atom AtomLength_; #define AtomLength Yap_heap_regs->AtomLength_ +#define TermLength MkAtomTerm( Yap_heap_regs->AtomLength_ ) Atom AtomList_; #define AtomList Yap_heap_regs->AtomList_ +#define TermList MkAtomTerm( Yap_heap_regs->AtomList_ ) Atom AtomLine_; #define AtomLine Yap_heap_regs->AtomLine_ +#define TermLine MkAtomTerm( Yap_heap_regs->AtomLine_ ) Atom AtomLive_; #define AtomLive Yap_heap_regs->AtomLive_ +#define TermLive MkAtomTerm( Yap_heap_regs->AtomLive_ ) Atom AtomLoadAnswers_; #define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_ +#define TermLoadAnswers MkAtomTerm( Yap_heap_regs->AtomLoadAnswers_ ) Atom AtomLocal_; #define AtomLocal Yap_heap_regs->AtomLocal_ +#define TermLocal MkAtomTerm( Yap_heap_regs->AtomLocal_ ) Atom AtomLocalSp_; #define AtomLocalSp Yap_heap_regs->AtomLocalSp_ +#define TermLocalSp MkAtomTerm( Yap_heap_regs->AtomLocalSp_ ) Atom AtomLocalTrie_; #define AtomLocalTrie Yap_heap_regs->AtomLocalTrie_ +#define TermLocalTrie MkAtomTerm( Yap_heap_regs->AtomLocalTrie_ ) Atom AtomMax_; #define AtomMax Yap_heap_regs->AtomMax_ +#define TermMax MkAtomTerm( Yap_heap_regs->AtomMax_ ) Atom AtomMaximum_; #define AtomMaximum Yap_heap_regs->AtomMaximum_ +#define TermMaximum MkAtomTerm( Yap_heap_regs->AtomMaximum_ ) Atom AtomMaxArity_; #define AtomMaxArity Yap_heap_regs->AtomMaxArity_ +#define TermMaxArity MkAtomTerm( Yap_heap_regs->AtomMaxArity_ ) Atom AtomMaxFiles_; #define AtomMaxFiles Yap_heap_regs->AtomMaxFiles_ +#define TermMaxFiles MkAtomTerm( Yap_heap_regs->AtomMaxFiles_ ) Atom AtomMegaClause_; #define AtomMegaClause Yap_heap_regs->AtomMegaClause_ +#define TermMegaClause MkAtomTerm( Yap_heap_regs->AtomMegaClause_ ) Atom AtomMetaCall_; #define AtomMetaCall Yap_heap_regs->AtomMetaCall_ +#define TermMetaCall MkAtomTerm( Yap_heap_regs->AtomMetaCall_ ) Atom AtomMfClause_; #define AtomMfClause Yap_heap_regs->AtomMfClause_ +#define TermMfClause MkAtomTerm( Yap_heap_regs->AtomMfClause_ ) Atom AtomMin_; #define AtomMin Yap_heap_regs->AtomMin_ +#define TermMin MkAtomTerm( Yap_heap_regs->AtomMin_ ) Atom AtomMinimum_; #define AtomMinimum Yap_heap_regs->AtomMinimum_ +#define TermMinimum MkAtomTerm( Yap_heap_regs->AtomMinimum_ ) Atom AtomMinus_; #define AtomMinus Yap_heap_regs->AtomMinus_ +#define TermMinus MkAtomTerm( Yap_heap_regs->AtomMinus_ ) Atom AtomModify_; #define AtomModify Yap_heap_regs->AtomModify_ +#define TermModify MkAtomTerm( Yap_heap_regs->AtomModify_ ) Atom AtomModule_; #define AtomModule Yap_heap_regs->AtomModule_ +#define TermModule MkAtomTerm( Yap_heap_regs->AtomModule_ ) Atom AtomMost_; #define AtomMost Yap_heap_regs->AtomMost_ +#define TermMost MkAtomTerm( Yap_heap_regs->AtomMost_ ) Atom AtomMulti_; #define AtomMulti Yap_heap_regs->AtomMulti_ +#define TermMulti MkAtomTerm( Yap_heap_regs->AtomMulti_ ) Atom AtomMultiFile_; #define AtomMultiFile Yap_heap_regs->AtomMultiFile_ +#define TermMultiFile MkAtomTerm( Yap_heap_regs->AtomMultiFile_ ) Atom AtomMultiple_; #define AtomMultiple Yap_heap_regs->AtomMultiple_ +#define TermMultiple MkAtomTerm( Yap_heap_regs->AtomMultiple_ ) Atom AtomMutable_; #define AtomMutable Yap_heap_regs->AtomMutable_ +#define TermMutable MkAtomTerm( Yap_heap_regs->AtomMutable_ ) Atom AtomMutableVariable_; #define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_ +#define TermMutableVariable MkAtomTerm( Yap_heap_regs->AtomMutableVariable_ ) Atom AtomMutex_; #define AtomMutex Yap_heap_regs->AtomMutex_ +#define TermMutex MkAtomTerm( Yap_heap_regs->AtomMutex_ ) Atom AtomMyddasDB_; #define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_ +#define TermMyddasDB MkAtomTerm( Yap_heap_regs->AtomMyddasDB_ ) Atom AtomMyddasGoal_; #define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_ +#define TermMyddasGoal MkAtomTerm( Yap_heap_regs->AtomMyddasGoal_ ) Atom AtomMyddasHost_; #define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_ +#define TermMyddasHost MkAtomTerm( Yap_heap_regs->AtomMyddasHost_ ) Atom AtomMyddasPass_; #define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_ +#define TermMyddasPass MkAtomTerm( Yap_heap_regs->AtomMyddasPass_ ) Atom AtomMyddasUser_; #define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_ +#define TermMyddasUser MkAtomTerm( Yap_heap_regs->AtomMyddasUser_ ) Atom AtomMyddasVersionName_; #define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_ +#define TermMyddasVersionName MkAtomTerm( Yap_heap_regs->AtomMyddasVersionName_ ) Atom AtomNan_; #define AtomNan Yap_heap_regs->AtomNan_ +#define TermNan MkAtomTerm( Yap_heap_regs->AtomNan_ ) Atom AtomNb_; #define AtomNb Yap_heap_regs->AtomNb_ +#define TermNb MkAtomTerm( Yap_heap_regs->AtomNb_ ) Atom AtomNbTerm_; #define AtomNbTerm Yap_heap_regs->AtomNbTerm_ +#define TermNbTerm MkAtomTerm( Yap_heap_regs->AtomNbTerm_ ) Atom AtomNew_; #define AtomNew Yap_heap_regs->AtomNew_ +#define TermNew MkAtomTerm( Yap_heap_regs->AtomNew_ ) + Atom AtomNewLine_; +#define AtomNewLine Yap_heap_regs->AtomNewLine_ +#define TermNewLine MkAtomTerm( Yap_heap_regs->AtomNewLine_ ) + Atom AtomNl_; +#define AtomNl Yap_heap_regs->AtomNl_ +#define TermNl MkAtomTerm( Yap_heap_regs->AtomNl_ ) Atom AtomNoEffect_; #define AtomNoEffect Yap_heap_regs->AtomNoEffect_ +#define TermNoEffect MkAtomTerm( Yap_heap_regs->AtomNoEffect_ ) Atom AtomNoMemory_; #define AtomNoMemory Yap_heap_regs->AtomNoMemory_ +#define TermNoMemory MkAtomTerm( Yap_heap_regs->AtomNoMemory_ ) Atom AtomNone_; #define AtomNone Yap_heap_regs->AtomNone_ +#define TermNone MkAtomTerm( Yap_heap_regs->AtomNone_ ) Atom AtomNonEmptyList_; #define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_ +#define TermNonEmptyList MkAtomTerm( Yap_heap_regs->AtomNonEmptyList_ ) Atom AtomNot_; #define AtomNot Yap_heap_regs->AtomNot_ +#define TermNot MkAtomTerm( Yap_heap_regs->AtomNot_ ) Atom AtomNotImplemented_; #define AtomNotImplemented Yap_heap_regs->AtomNotImplemented_ +#define TermNotImplemented MkAtomTerm( Yap_heap_regs->AtomNotImplemented_ ) Atom AtomNotLessThanZero_; #define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_ +#define TermNotLessThanZero MkAtomTerm( Yap_heap_regs->AtomNotLessThanZero_ ) Atom AtomNotNewline_; #define AtomNotNewline Yap_heap_regs->AtomNotNewline_ +#define TermNotNewline MkAtomTerm( Yap_heap_regs->AtomNotNewline_ ) Atom AtomNotZero_; #define AtomNotZero Yap_heap_regs->AtomNotZero_ +#define TermNotZero MkAtomTerm( Yap_heap_regs->AtomNotZero_ ) Atom AtomNumber_; #define AtomNumber Yap_heap_regs->AtomNumber_ +#define TermNumber MkAtomTerm( Yap_heap_regs->AtomNumber_ ) Atom AtomOff_; #define AtomOff Yap_heap_regs->AtomOff_ +#define TermOff MkAtomTerm( Yap_heap_regs->AtomOff_ ) Atom AtomOffline_; #define AtomOffline Yap_heap_regs->AtomOffline_ +#define TermOffline MkAtomTerm( Yap_heap_regs->AtomOffline_ ) Atom AtomOn_; #define AtomOn Yap_heap_regs->AtomOn_ +#define TermOn MkAtomTerm( Yap_heap_regs->AtomOn_ ) Atom AtomOnline_; #define AtomOnline Yap_heap_regs->AtomOnline_ +#define TermOnline MkAtomTerm( Yap_heap_regs->AtomOnline_ ) Atom AtomOpen_; #define AtomOpen Yap_heap_regs->AtomOpen_ +#define TermOpen MkAtomTerm( Yap_heap_regs->AtomOpen_ ) Atom AtomOperatingSystemError_; #define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_ +#define TermOperatingSystemError MkAtomTerm( Yap_heap_regs->AtomOperatingSystemError_ ) Atom AtomOperatingSystemSupport_; #define AtomOperatingSystemSupport Yap_heap_regs->AtomOperatingSystemSupport_ +#define TermOperatingSystemSupport MkAtomTerm( Yap_heap_regs->AtomOperatingSystemSupport_ ) Atom AtomOperator_; #define AtomOperator Yap_heap_regs->AtomOperator_ +#define TermOperator MkAtomTerm( Yap_heap_regs->AtomOperator_ ) Atom AtomOperatorPriority_; #define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_ +#define TermOperatorPriority MkAtomTerm( Yap_heap_regs->AtomOperatorPriority_ ) Atom AtomOperatorSpecifier_; #define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_ +#define TermOperatorSpecifier MkAtomTerm( Yap_heap_regs->AtomOperatorSpecifier_ ) Atom AtomOtherwise_; #define AtomOtherwise Yap_heap_regs->AtomOtherwise_ +#define TermOtherwise MkAtomTerm( Yap_heap_regs->AtomOtherwise_ ) Atom AtomOutOfAttvarsError_; #define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_ +#define TermOutOfAttvarsError MkAtomTerm( Yap_heap_regs->AtomOutOfAttvarsError_ ) Atom AtomOutOfAuxspaceError_; #define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_ +#define TermOutOfAuxspaceError MkAtomTerm( Yap_heap_regs->AtomOutOfAuxspaceError_ ) Atom AtomOutOfHeapError_; #define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_ +#define TermOutOfHeapError MkAtomTerm( Yap_heap_regs->AtomOutOfHeapError_ ) Atom AtomOutOfRange_; #define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_ +#define TermOutOfRange MkAtomTerm( Yap_heap_regs->AtomOutOfRange_ ) Atom AtomOutOfStackError_; #define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_ +#define TermOutOfStackError MkAtomTerm( Yap_heap_regs->AtomOutOfStackError_ ) Atom AtomOutOfTrailError_; #define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_ +#define TermOutOfTrailError MkAtomTerm( Yap_heap_regs->AtomOutOfTrailError_ ) Atom AtomOutput_; #define AtomOutput Yap_heap_regs->AtomOutput_ +#define TermOutput MkAtomTerm( Yap_heap_regs->AtomOutput_ ) Atom AtomParameter_; #define AtomParameter Yap_heap_regs->AtomParameter_ +#define TermParameter MkAtomTerm( Yap_heap_regs->AtomParameter_ ) Atom AtomPrologCommonsDir_; #define AtomPrologCommonsDir Yap_heap_regs->AtomPrologCommonsDir_ +#define TermPrologCommonsDir MkAtomTerm( Yap_heap_regs->AtomPrologCommonsDir_ ) Atom AtomPast_; #define AtomPast Yap_heap_regs->AtomPast_ +#define TermPast MkAtomTerm( Yap_heap_regs->AtomPast_ ) Atom AtomPastEndOfStream_; #define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_ +#define TermPastEndOfStream MkAtomTerm( Yap_heap_regs->AtomPastEndOfStream_ ) Atom AtomPermissionError_; #define AtomPermissionError Yap_heap_regs->AtomPermissionError_ +#define TermPermissionError MkAtomTerm( Yap_heap_regs->AtomPermissionError_ ) Atom AtomPi_; #define AtomPi Yap_heap_regs->AtomPi_ +#define TermPi MkAtomTerm( Yap_heap_regs->AtomPi_ ) Atom AtomPipe_; #define AtomPipe Yap_heap_regs->AtomPipe_ +#define TermPipe MkAtomTerm( Yap_heap_regs->AtomPipe_ ) Atom AtomPlus_; #define AtomPlus Yap_heap_regs->AtomPlus_ +#define TermPlus MkAtomTerm( Yap_heap_regs->AtomPlus_ ) Atom AtomPointer_; #define AtomPointer Yap_heap_regs->AtomPointer_ +#define TermPointer MkAtomTerm( Yap_heap_regs->AtomPointer_ ) Atom AtomPortray_; #define AtomPortray Yap_heap_regs->AtomPortray_ +#define TermPortray MkAtomTerm( Yap_heap_regs->AtomPortray_ ) Atom AtomPredicateIndicator_; #define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_ +#define TermPredicateIndicator MkAtomTerm( Yap_heap_regs->AtomPredicateIndicator_ ) Atom AtomPrimitive_; #define AtomPrimitive Yap_heap_regs->AtomPrimitive_ +#define TermPrimitive MkAtomTerm( Yap_heap_regs->AtomPrimitive_ ) Atom AtomPrintMessage_; #define AtomPrintMessage Yap_heap_regs->AtomPrintMessage_ +#define TermPrintMessage MkAtomTerm( Yap_heap_regs->AtomPrintMessage_ ) Atom AtomPrivateProcedure_; #define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_ +#define TermPrivateProcedure MkAtomTerm( Yap_heap_regs->AtomPrivateProcedure_ ) Atom AtomProcedure_; #define AtomProcedure Yap_heap_regs->AtomProcedure_ +#define TermProcedure MkAtomTerm( Yap_heap_regs->AtomProcedure_ ) Atom AtomProfile_; #define AtomProfile Yap_heap_regs->AtomProfile_ +#define TermProfile MkAtomTerm( Yap_heap_regs->AtomProfile_ ) Atom AtomProlog_; #define AtomProlog Yap_heap_regs->AtomProlog_ - Atom AtomPtr_; -#define AtomPtr Yap_heap_regs->AtomPtr_ +#define TermProlog MkAtomTerm( Yap_heap_regs->AtomProlog_ ) Atom AtomQuery_; #define AtomQuery Yap_heap_regs->AtomQuery_ +#define TermQuery MkAtomTerm( Yap_heap_regs->AtomQuery_ ) Atom AtomQueue_; #define AtomQueue Yap_heap_regs->AtomQueue_ +#define TermQueue MkAtomTerm( Yap_heap_regs->AtomQueue_ ) Atom AtomQuiet_; #define AtomQuiet Yap_heap_regs->AtomQuiet_ +#define TermQuiet MkAtomTerm( Yap_heap_regs->AtomQuiet_ ) Atom AtomRadix_; #define AtomRadix Yap_heap_regs->AtomRadix_ +#define TermRadix MkAtomTerm( Yap_heap_regs->AtomRadix_ ) Atom AtomRandom_; #define AtomRandom Yap_heap_regs->AtomRandom_ +#define TermRandom MkAtomTerm( Yap_heap_regs->AtomRandom_ ) Atom AtomRange_; #define AtomRange Yap_heap_regs->AtomRange_ +#define TermRange MkAtomTerm( Yap_heap_regs->AtomRange_ ) Atom AtomRDiv_; #define AtomRDiv Yap_heap_regs->AtomRDiv_ +#define TermRDiv MkAtomTerm( Yap_heap_regs->AtomRDiv_ ) Atom AtomRead_; #define AtomRead Yap_heap_regs->AtomRead_ +#define TermRead MkAtomTerm( Yap_heap_regs->AtomRead_ ) Atom AtomReadOnly_; #define AtomReadOnly Yap_heap_regs->AtomReadOnly_ +#define TermReadOnly MkAtomTerm( Yap_heap_regs->AtomReadOnly_ ) Atom AtomReadWrite_; #define AtomReadWrite Yap_heap_regs->AtomReadWrite_ +#define TermReadWrite MkAtomTerm( Yap_heap_regs->AtomReadWrite_ ) Atom AtomReadutil_; #define AtomReadutil Yap_heap_regs->AtomReadutil_ +#define TermReadutil MkAtomTerm( Yap_heap_regs->AtomReadutil_ ) Atom AtomRecordedP_; #define AtomRecordedP Yap_heap_regs->AtomRecordedP_ +#define TermRecordedP MkAtomTerm( Yap_heap_regs->AtomRecordedP_ ) Atom AtomRecordedWithKey_; #define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_ +#define TermRecordedWithKey MkAtomTerm( Yap_heap_regs->AtomRecordedWithKey_ ) Atom AtomRedefineWarnings_; #define AtomRedefineWarnings Yap_heap_regs->AtomRedefineWarnings_ +#define TermRedefineWarnings MkAtomTerm( Yap_heap_regs->AtomRedefineWarnings_ ) Atom AtomRedoFreeze_; #define AtomRedoFreeze Yap_heap_regs->AtomRedoFreeze_ +#define TermRedoFreeze MkAtomTerm( Yap_heap_regs->AtomRedoFreeze_ ) Atom AtomRefoundVar_; #define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_ +#define TermRefoundVar MkAtomTerm( Yap_heap_regs->AtomRefoundVar_ ) Atom AtomRepeat_; #define AtomRepeat Yap_heap_regs->AtomRepeat_ +#define TermRepeat MkAtomTerm( Yap_heap_regs->AtomRepeat_ ) Atom AtomRepeatSpace_; #define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_ +#define TermRepeatSpace MkAtomTerm( Yap_heap_regs->AtomRepeatSpace_ ) Atom AtomReposition_; #define AtomReposition Yap_heap_regs->AtomReposition_ +#define TermReposition MkAtomTerm( Yap_heap_regs->AtomReposition_ ) Atom AtomRepresentationError_; #define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_ +#define TermRepresentationError MkAtomTerm( Yap_heap_regs->AtomRepresentationError_ ) Atom AtomReset_; #define AtomReset Yap_heap_regs->AtomReset_ +#define TermReset MkAtomTerm( Yap_heap_regs->AtomReset_ ) Atom AtomResize_; #define AtomResize Yap_heap_regs->AtomResize_ +#define TermResize MkAtomTerm( Yap_heap_regs->AtomResize_ ) Atom AtomResourceError_; #define AtomResourceError Yap_heap_regs->AtomResourceError_ +#define TermResourceError MkAtomTerm( Yap_heap_regs->AtomResourceError_ ) Atom AtomRestoreRegs_; #define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_ +#define TermRestoreRegs MkAtomTerm( Yap_heap_regs->AtomRestoreRegs_ ) Atom AtomRetryCounter_; #define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_ +#define TermRetryCounter MkAtomTerm( Yap_heap_regs->AtomRetryCounter_ ) Atom AtomRTree_; #define AtomRTree Yap_heap_regs->AtomRTree_ +#define TermRTree MkAtomTerm( Yap_heap_regs->AtomRTree_ ) Atom AtomSafe_; #define AtomSafe Yap_heap_regs->AtomSafe_ +#define TermSafe MkAtomTerm( Yap_heap_regs->AtomSafe_ ) Atom AtomSafeCallCleanup_; #define AtomSafeCallCleanup Yap_heap_regs->AtomSafeCallCleanup_ +#define TermSafeCallCleanup MkAtomTerm( Yap_heap_regs->AtomSafeCallCleanup_ ) Atom AtomSame_; #define AtomSame Yap_heap_regs->AtomSame_ +#define TermSame MkAtomTerm( Yap_heap_regs->AtomSame_ ) Atom AtomSemic_; #define AtomSemic Yap_heap_regs->AtomSemic_ +#define TermSemic MkAtomTerm( Yap_heap_regs->AtomSemic_ ) Atom AtomShiftCountOverflow_; #define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_ +#define TermShiftCountOverflow MkAtomTerm( Yap_heap_regs->AtomShiftCountOverflow_ ) Atom AtomSigAlarm_; #define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_ +#define TermSigAlarm MkAtomTerm( Yap_heap_regs->AtomSigAlarm_ ) Atom AtomSigBreak_; #define AtomSigBreak Yap_heap_regs->AtomSigBreak_ +#define TermSigBreak MkAtomTerm( Yap_heap_regs->AtomSigBreak_ ) Atom AtomSigCreep_; #define AtomSigCreep Yap_heap_regs->AtomSigCreep_ +#define TermSigCreep MkAtomTerm( Yap_heap_regs->AtomSigCreep_ ) Atom AtomSigDebug_; #define AtomSigDebug Yap_heap_regs->AtomSigDebug_ +#define TermSigDebug MkAtomTerm( Yap_heap_regs->AtomSigDebug_ ) Atom AtomSigDelayCreep_; #define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_ +#define TermSigDelayCreep MkAtomTerm( Yap_heap_regs->AtomSigDelayCreep_ ) Atom AtomSigFPE_; #define AtomSigFPE Yap_heap_regs->AtomSigFPE_ +#define TermSigFPE MkAtomTerm( Yap_heap_regs->AtomSigFPE_ ) Atom AtomSigHup_; #define AtomSigHup Yap_heap_regs->AtomSigHup_ +#define TermSigHup MkAtomTerm( Yap_heap_regs->AtomSigHup_ ) Atom AtomSigInt_; #define AtomSigInt Yap_heap_regs->AtomSigInt_ +#define TermSigInt MkAtomTerm( Yap_heap_regs->AtomSigInt_ ) Atom AtomSigIti_; #define AtomSigIti Yap_heap_regs->AtomSigIti_ +#define TermSigIti MkAtomTerm( Yap_heap_regs->AtomSigIti_ ) Atom AtomSigPending_; #define AtomSigPending Yap_heap_regs->AtomSigPending_ +#define TermSigPending MkAtomTerm( Yap_heap_regs->AtomSigPending_ ) Atom AtomSigPipe_; #define AtomSigPipe Yap_heap_regs->AtomSigPipe_ +#define TermSigPipe MkAtomTerm( Yap_heap_regs->AtomSigPipe_ ) Atom AtomSigStackDump_; #define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_ +#define TermSigStackDump MkAtomTerm( Yap_heap_regs->AtomSigStackDump_ ) Atom AtomSigStatistics_; #define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_ +#define TermSigStatistics MkAtomTerm( Yap_heap_regs->AtomSigStatistics_ ) Atom AtomSigTrace_; #define AtomSigTrace Yap_heap_regs->AtomSigTrace_ +#define TermSigTrace MkAtomTerm( Yap_heap_regs->AtomSigTrace_ ) Atom AtomSigUsr1_; #define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_ +#define TermSigUsr1 MkAtomTerm( Yap_heap_regs->AtomSigUsr1_ ) Atom AtomSigUsr2_; #define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_ +#define TermSigUsr2 MkAtomTerm( Yap_heap_regs->AtomSigUsr2_ ) Atom AtomSigVTAlarm_; #define AtomSigVTAlarm Yap_heap_regs->AtomSigVTAlarm_ +#define TermSigVTAlarm MkAtomTerm( Yap_heap_regs->AtomSigVTAlarm_ ) Atom AtomSigWakeUp_; #define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_ +#define TermSigWakeUp MkAtomTerm( Yap_heap_regs->AtomSigWakeUp_ ) Atom AtomSilent_; #define AtomSilent Yap_heap_regs->AtomSilent_ +#define TermSilent MkAtomTerm( Yap_heap_regs->AtomSilent_ ) Atom AtomSingle_; #define AtomSingle Yap_heap_regs->AtomSingle_ +#define TermSingle MkAtomTerm( Yap_heap_regs->AtomSingle_ ) Atom AtomSingleVarWarnings_; #define AtomSingleVarWarnings Yap_heap_regs->AtomSingleVarWarnings_ +#define TermSingleVarWarnings MkAtomTerm( Yap_heap_regs->AtomSingleVarWarnings_ ) Atom AtomSingleton_; #define AtomSingleton Yap_heap_regs->AtomSingleton_ +#define TermSingleton MkAtomTerm( Yap_heap_regs->AtomSingleton_ ) Atom AtomSlash_; #define AtomSlash Yap_heap_regs->AtomSlash_ +#define TermSlash MkAtomTerm( Yap_heap_regs->AtomSlash_ ) Atom AtomSocket_; #define AtomSocket Yap_heap_regs->AtomSocket_ +#define TermSocket MkAtomTerm( Yap_heap_regs->AtomSocket_ ) Atom AtomSource_; #define AtomSource Yap_heap_regs->AtomSource_ +#define TermSource MkAtomTerm( Yap_heap_regs->AtomSource_ ) Atom AtomSourceSink_; #define AtomSourceSink Yap_heap_regs->AtomSourceSink_ +#define TermSourceSink MkAtomTerm( Yap_heap_regs->AtomSourceSink_ ) Atom AtomSpy_; #define AtomSpy Yap_heap_regs->AtomSpy_ +#define TermSpy MkAtomTerm( Yap_heap_regs->AtomSpy_ ) Atom AtomStack_; #define AtomStack Yap_heap_regs->AtomStack_ +#define TermStack MkAtomTerm( Yap_heap_regs->AtomStack_ ) Atom AtomStackFree_; #define AtomStackFree Yap_heap_regs->AtomStackFree_ +#define TermStackFree MkAtomTerm( Yap_heap_regs->AtomStackFree_ ) Atom AtomStartupSavedState_; #define AtomStartupSavedState Yap_heap_regs->AtomStartupSavedState_ +#define TermStartupSavedState MkAtomTerm( Yap_heap_regs->AtomStartupSavedState_ ) Atom AtomStaticClause_; #define AtomStaticClause Yap_heap_regs->AtomStaticClause_ +#define TermStaticClause MkAtomTerm( Yap_heap_regs->AtomStaticClause_ ) Atom AtomStaticProcedure_; #define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_ +#define TermStaticProcedure MkAtomTerm( Yap_heap_regs->AtomStaticProcedure_ ) Atom AtomStream_; #define AtomStream Yap_heap_regs->AtomStream_ +#define TermStream MkAtomTerm( Yap_heap_regs->AtomStream_ ) Atom AtomSWIStream_; #define AtomSWIStream Yap_heap_regs->AtomSWIStream_ +#define TermSWIStream MkAtomTerm( Yap_heap_regs->AtomSWIStream_ ) Atom AtomVStream_; #define AtomVStream Yap_heap_regs->AtomVStream_ +#define TermVStream MkAtomTerm( Yap_heap_regs->AtomVStream_ ) Atom AtomStreams_; #define AtomStreams Yap_heap_regs->AtomStreams_ +#define TermStreams MkAtomTerm( Yap_heap_regs->AtomStreams_ ) Atom AtomStreamOrAlias_; #define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_ +#define TermStreamOrAlias MkAtomTerm( Yap_heap_regs->AtomStreamOrAlias_ ) Atom AtomStreamPos_; #define AtomStreamPos Yap_heap_regs->AtomStreamPos_ +#define TermStreamPos MkAtomTerm( Yap_heap_regs->AtomStreamPos_ ) Atom AtomStreamPosition_; #define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_ +#define TermStreamPosition MkAtomTerm( Yap_heap_regs->AtomStreamPosition_ ) Atom AtomString_; #define AtomString Yap_heap_regs->AtomString_ +#define TermString MkAtomTerm( Yap_heap_regs->AtomString_ ) Atom AtomSTRING_; #define AtomSTRING Yap_heap_regs->AtomSTRING_ +#define TermSTRING MkAtomTerm( Yap_heap_regs->AtomSTRING_ ) Atom AtomSwi_; #define AtomSwi Yap_heap_regs->AtomSwi_ +#define TermSwi MkAtomTerm( Yap_heap_regs->AtomSwi_ ) Atom AtomSymbolChar_; #define AtomSymbolChar Yap_heap_regs->AtomSymbolChar_ +#define TermSymbolChar MkAtomTerm( Yap_heap_regs->AtomSymbolChar_ ) Atom AtomSyntaxError_; #define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_ +#define TermSyntaxError MkAtomTerm( Yap_heap_regs->AtomSyntaxError_ ) Atom AtomSyntaxErrors_; #define AtomSyntaxErrors Yap_heap_regs->AtomSyntaxErrors_ +#define TermSyntaxErrors MkAtomTerm( Yap_heap_regs->AtomSyntaxErrors_ ) Atom AtomSyntaxErrorHandler_; #define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_ +#define TermSyntaxErrorHandler MkAtomTerm( Yap_heap_regs->AtomSyntaxErrorHandler_ ) Atom AtomSystem_; #define AtomSystem Yap_heap_regs->AtomSystem_ +#define TermSystem MkAtomTerm( Yap_heap_regs->AtomSystem_ ) Atom AtomSystemError_; #define AtomSystemError Yap_heap_regs->AtomSystemError_ +#define TermSystemError MkAtomTerm( Yap_heap_regs->AtomSystemError_ ) Atom AtomSystemLibraryDir_; #define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_ +#define TermSystemLibraryDir MkAtomTerm( Yap_heap_regs->AtomSystemLibraryDir_ ) Atom AtomTerm_; #define AtomTerm Yap_heap_regs->AtomTerm_ +#define TermTerm MkAtomTerm( Yap_heap_regs->AtomTerm_ ) Atom AtomTerms_; #define AtomTerms Yap_heap_regs->AtomTerms_ +#define TermTerms MkAtomTerm( Yap_heap_regs->AtomTerms_ ) Atom AtomTermExpansion_; #define AtomTermExpansion Yap_heap_regs->AtomTermExpansion_ +#define TermTermExpansion MkAtomTerm( Yap_heap_regs->AtomTermExpansion_ ) Atom AtomText_; #define AtomText Yap_heap_regs->AtomText_ +#define TermText MkAtomTerm( Yap_heap_regs->AtomText_ ) Atom AtomTextStream_; #define AtomTextStream Yap_heap_regs->AtomTextStream_ +#define TermTextStream MkAtomTerm( Yap_heap_regs->AtomTextStream_ ) Atom AtomThread_; #define AtomThread Yap_heap_regs->AtomThread_ +#define TermThread MkAtomTerm( Yap_heap_regs->AtomThread_ ) Atom AtomThreads_; #define AtomThreads Yap_heap_regs->AtomThreads_ +#define TermThreads MkAtomTerm( Yap_heap_regs->AtomThreads_ ) Atom AtomThrow_; #define AtomThrow Yap_heap_regs->AtomThrow_ +#define TermThrow MkAtomTerm( Yap_heap_regs->AtomThrow_ ) Atom AtomTimeOutSpec_; #define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_ +#define TermTimeOutSpec MkAtomTerm( Yap_heap_regs->AtomTimeOutSpec_ ) Atom AtomTimeoutError_; #define AtomTimeoutError Yap_heap_regs->AtomTimeoutError_ +#define TermTimeoutError MkAtomTerm( Yap_heap_regs->AtomTimeoutError_ ) Atom AtomTopLevelGoal_; #define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_ +#define TermTopLevelGoal MkAtomTerm( Yap_heap_regs->AtomTopLevelGoal_ ) Atom AtomTopThreadGoal_; #define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_ +#define TermTopThreadGoal MkAtomTerm( Yap_heap_regs->AtomTopThreadGoal_ ) Atom AtomTraceMetaCall_; #define AtomTraceMetaCall Yap_heap_regs->AtomTraceMetaCall_ +#define TermTraceMetaCall MkAtomTerm( Yap_heap_regs->AtomTraceMetaCall_ ) Atom AtomTrail_; #define AtomTrail Yap_heap_regs->AtomTrail_ +#define TermTrail MkAtomTerm( Yap_heap_regs->AtomTrail_ ) Atom AtomTrue_; #define AtomTrue Yap_heap_regs->AtomTrue_ +#define TermTrue MkAtomTerm( Yap_heap_regs->AtomTrue_ ) Atom AtomTty_; #define AtomTty Yap_heap_regs->AtomTty_ +#define TermTty MkAtomTerm( Yap_heap_regs->AtomTty_ ) Atom AtomTtys_; #define AtomTtys Yap_heap_regs->AtomTtys_ +#define TermTtys MkAtomTerm( Yap_heap_regs->AtomTtys_ ) Atom AtomTypeError_; #define AtomTypeError Yap_heap_regs->AtomTypeError_ +#define TermTypeError MkAtomTerm( Yap_heap_regs->AtomTypeError_ ) Atom AtomUndefined_; #define AtomUndefined Yap_heap_regs->AtomUndefined_ +#define TermUndefined MkAtomTerm( Yap_heap_regs->AtomUndefined_ ) Atom AtomUndefp_; #define AtomUndefp Yap_heap_regs->AtomUndefp_ +#define TermUndefp MkAtomTerm( Yap_heap_regs->AtomUndefp_ ) Atom AtomUnderflow_; #define AtomUnderflow Yap_heap_regs->AtomUnderflow_ +#define TermUnderflow MkAtomTerm( Yap_heap_regs->AtomUnderflow_ ) Atom AtomUnificationStack_; #define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_ +#define TermUnificationStack MkAtomTerm( Yap_heap_regs->AtomUnificationStack_ ) Atom AtomUnique_; #define AtomUnique Yap_heap_regs->AtomUnique_ +#define TermUnique MkAtomTerm( Yap_heap_regs->AtomUnique_ ) Atom AtomUnsignedByte_; #define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_ +#define TermUnsignedByte MkAtomTerm( Yap_heap_regs->AtomUnsignedByte_ ) Atom AtomUnsignedChar_; #define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_ +#define TermUnsignedChar MkAtomTerm( Yap_heap_regs->AtomUnsignedChar_ ) Atom AtomUser_; #define AtomUser Yap_heap_regs->AtomUser_ +#define TermUser MkAtomTerm( Yap_heap_regs->AtomUser_ ) Atom AtomUserErr_; #define AtomUserErr Yap_heap_regs->AtomUserErr_ +#define TermUserErr MkAtomTerm( Yap_heap_regs->AtomUserErr_ ) Atom AtomUserIn_; #define AtomUserIn Yap_heap_regs->AtomUserIn_ +#define TermUserIn MkAtomTerm( Yap_heap_regs->AtomUserIn_ ) Atom AtomUserOut_; #define AtomUserOut Yap_heap_regs->AtomUserOut_ +#define TermUserOut MkAtomTerm( Yap_heap_regs->AtomUserOut_ ) Atom AtomVBar_; #define AtomVBar Yap_heap_regs->AtomVBar_ +#define TermVBar MkAtomTerm( Yap_heap_regs->AtomVBar_ ) Atom AtomVar_; #define AtomVar Yap_heap_regs->AtomVar_ +#define TermVar MkAtomTerm( Yap_heap_regs->AtomVar_ ) Atom AtomVarBranches_; #define AtomVarBranches Yap_heap_regs->AtomVarBranches_ +#define TermVarBranches MkAtomTerm( Yap_heap_regs->AtomVarBranches_ ) Atom AtomVariableNames_; #define AtomVariableNames Yap_heap_regs->AtomVariableNames_ +#define TermVariableNames MkAtomTerm( Yap_heap_regs->AtomVariableNames_ ) Atom AtomHiddenVar_; #define AtomHiddenVar Yap_heap_regs->AtomHiddenVar_ +#define TermHiddenVar MkAtomTerm( Yap_heap_regs->AtomHiddenVar_ ) Atom AtomVariable_; #define AtomVariable Yap_heap_regs->AtomVariable_ +#define TermVariable MkAtomTerm( Yap_heap_regs->AtomVariable_ ) Atom AtomVersionNumber_; #define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_ +#define TermVersionNumber MkAtomTerm( Yap_heap_regs->AtomVersionNumber_ ) Atom AtomWakeUpGoal_; #define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_ +#define TermWakeUpGoal MkAtomTerm( Yap_heap_regs->AtomWakeUpGoal_ ) Atom AtomWarning_; #define AtomWarning Yap_heap_regs->AtomWarning_ +#define TermWarning MkAtomTerm( Yap_heap_regs->AtomWarning_ ) Atom AtomWhen_; #define AtomWhen Yap_heap_regs->AtomWhen_ +#define TermWhen MkAtomTerm( Yap_heap_regs->AtomWhen_ ) Atom AtomWrite_; #define AtomWrite Yap_heap_regs->AtomWrite_ +#define TermWrite MkAtomTerm( Yap_heap_regs->AtomWrite_ ) Atom AtomXml_; #define AtomXml Yap_heap_regs->AtomXml_ +#define TermXml MkAtomTerm( Yap_heap_regs->AtomXml_ ) Atom AtomYapHacks_; #define AtomYapHacks Yap_heap_regs->AtomYapHacks_ +#define TermYapHacks MkAtomTerm( Yap_heap_regs->AtomYapHacks_ ) Atom AtomZeroDivisor_; #define AtomZeroDivisor Yap_heap_regs->AtomZeroDivisor_ +#define TermZeroDivisor MkAtomTerm( Yap_heap_regs->AtomZeroDivisor_ ) Functor FunctorAfInet_; #define FunctorAfInet Yap_heap_regs->FunctorAfInet_ Functor FunctorAfLocal_;