This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/H/tatoms.h

1507 lines
67 KiB
C
Raw Normal View History

2015-10-20 07:52:33 +01:00
2015-08-07 22:57:53 +01:00
/* 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_
2015-08-18 20:50:27 +01:00
#define Term3Dots MkAtomTerm( Yap_heap_regs->Atom3Dots_ )
Atom AtomAbol_;
#define AtomAbol Yap_heap_regs->AtomAbol_
2015-08-18 20:50:27 +01:00
#define TermAbol MkAtomTerm( Yap_heap_regs->AtomAbol_ )
Atom AtomAccess_;
#define AtomAccess Yap_heap_regs->AtomAccess_
2015-08-18 20:50:27 +01:00
#define TermAccess MkAtomTerm( Yap_heap_regs->AtomAccess_ )
Atom AtomAfInet_;
#define AtomAfInet Yap_heap_regs->AtomAfInet_
2015-08-18 20:50:27 +01:00
#define TermAfInet MkAtomTerm( Yap_heap_regs->AtomAfInet_ )
Atom AtomAfLocal_;
#define AtomAfLocal Yap_heap_regs->AtomAfLocal_
2015-08-18 20:50:27 +01:00
#define TermAfLocal MkAtomTerm( Yap_heap_regs->AtomAfLocal_ )
Atom AtomAfUnix_;
#define AtomAfUnix Yap_heap_regs->AtomAfUnix_
2015-08-18 20:50:27 +01:00
#define TermAfUnix MkAtomTerm( Yap_heap_regs->AtomAfUnix_ )
Atom AtomAlarm_;
#define AtomAlarm Yap_heap_regs->AtomAlarm_
2015-08-18 20:50:27 +01:00
#define TermAlarm MkAtomTerm( Yap_heap_regs->AtomAlarm_ )
Atom AtomAlias_;
#define AtomAlias Yap_heap_regs->AtomAlias_
2015-08-18 20:50:27 +01:00
#define TermAlias MkAtomTerm( Yap_heap_regs->AtomAlias_ )
2015-09-21 23:05:36 +01:00
Atom AtomAll_;
#define AtomAll Yap_heap_regs->AtomAll_
#define TermAll MkAtomTerm( Yap_heap_regs->AtomAll_ )
Atom AtomAltNot_;
#define AtomAltNot Yap_heap_regs->AtomAltNot_
2015-08-18 20:50:27 +01:00
#define TermAltNot MkAtomTerm( Yap_heap_regs->AtomAltNot_ )
2013-04-29 17:58:05 +01:00
Atom AtomAny_;
#define AtomAny Yap_heap_regs->AtomAny_
2015-08-18 20:50:27 +01:00
#define TermAny MkAtomTerm( Yap_heap_regs->AtomAny_ )
Atom AtomAppend_;
#define AtomAppend Yap_heap_regs->AtomAppend_
2015-08-18 20:50:27 +01:00
#define TermAppend MkAtomTerm( Yap_heap_regs->AtomAppend_ )
Atom AtomArg_;
#define AtomArg Yap_heap_regs->AtomArg_
2015-08-18 20:50:27 +01:00
#define TermArg MkAtomTerm( Yap_heap_regs->AtomArg_ )
Atom AtomArray_;
#define AtomArray Yap_heap_regs->AtomArray_
2015-08-18 20:50:27 +01:00
#define TermArray MkAtomTerm( Yap_heap_regs->AtomArray_ )
Atom AtomArrayAccess_;
#define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_
2015-08-18 20:50:27 +01:00
#define TermArrayAccess MkAtomTerm( Yap_heap_regs->AtomArrayAccess_ )
Atom AtomArrayOverflow_;
#define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_
2015-08-18 20:50:27 +01:00
#define TermArrayOverflow MkAtomTerm( Yap_heap_regs->AtomArrayOverflow_ )
Atom AtomArrayType_;
#define AtomArrayType Yap_heap_regs->AtomArrayType_
2015-08-18 20:50:27 +01:00
#define TermArrayType MkAtomTerm( Yap_heap_regs->AtomArrayType_ )
Atom AtomArrow_;
#define AtomArrow Yap_heap_regs->AtomArrow_
2015-08-18 20:50:27 +01:00
#define TermArrow MkAtomTerm( Yap_heap_regs->AtomArrow_ )
2016-01-03 02:06:09 +00:00
Atom AtomAttributedModule_;
#define AtomAttributedModule Yap_heap_regs->AtomAttributedModule_
#define TermAttributedModule MkAtomTerm( Yap_heap_regs->AtomAttributedModule_ )
Atom AtomDoubleArrow_;
#define AtomDoubleArrow Yap_heap_regs->AtomDoubleArrow_
2015-08-18 20:50:27 +01:00
#define TermDoubleArrow MkAtomTerm( Yap_heap_regs->AtomDoubleArrow_ )
Atom AtomAssert_;
#define AtomAssert Yap_heap_regs->AtomAssert_
2015-08-18 20:50:27 +01:00
#define TermAssert MkAtomTerm( Yap_heap_regs->AtomAssert_ )
2013-07-07 22:15:25 +01:00
Atom AtomEmptyBrackets_;
#define AtomEmptyBrackets Yap_heap_regs->AtomEmptyBrackets_
2015-08-18 20:50:27 +01:00
#define TermEmptyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyBrackets_ )
2013-07-07 22:15:25 +01:00
Atom AtomEmptySquareBrackets_;
#define AtomEmptySquareBrackets Yap_heap_regs->AtomEmptySquareBrackets_
2015-08-18 20:50:27 +01:00
#define TermEmptySquareBrackets MkAtomTerm( Yap_heap_regs->AtomEmptySquareBrackets_ )
2013-07-07 22:15:25 +01:00
Atom AtomEmptyCurlyBrackets_;
#define AtomEmptyCurlyBrackets Yap_heap_regs->AtomEmptyCurlyBrackets_
2015-08-18 20:50:27 +01:00
#define TermEmptyCurlyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyCurlyBrackets_ )
Atom AtomAsserta_;
#define AtomAsserta Yap_heap_regs->AtomAsserta_
#define TermAsserta MkAtomTerm( Yap_heap_regs->AtomAsserta_ )
Atom AtomAssertaStatic_;
#define AtomAssertaStatic Yap_heap_regs->AtomAssertaStatic_
#define TermAssertaStatic MkAtomTerm( Yap_heap_regs->AtomAssertaStatic_ )
Atom AtomAssertz_;
#define AtomAssertz Yap_heap_regs->AtomAssertz_
#define TermAssertz MkAtomTerm( Yap_heap_regs->AtomAssertz_ )
Atom AtomAssertzStatic_;
#define AtomAssertzStatic Yap_heap_regs->AtomAssertzStatic_
#define TermAssertzStatic MkAtomTerm( Yap_heap_regs->AtomAssertzStatic_ )
Atom AtomAt_;
#define AtomAt Yap_heap_regs->AtomAt_
2015-08-18 20:50:27 +01:00
#define TermAt MkAtomTerm( Yap_heap_regs->AtomAt_ )
Atom AtomAtom_;
#define AtomAtom Yap_heap_regs->AtomAtom_
2015-08-18 20:50:27 +01:00
#define TermAtom MkAtomTerm( Yap_heap_regs->AtomAtom_ )
Atom AtomAtomic_;
#define AtomAtomic Yap_heap_regs->AtomAtomic_
2015-08-18 20:50:27 +01:00
#define TermAtomic MkAtomTerm( Yap_heap_regs->AtomAtomic_ )
Atom AtomAtt_;
#define AtomAtt Yap_heap_regs->AtomAtt_
2015-08-18 20:50:27 +01:00
#define TermAtt MkAtomTerm( Yap_heap_regs->AtomAtt_ )
Atom AtomAtt1_;
#define AtomAtt1 Yap_heap_regs->AtomAtt1_
2015-08-18 20:50:27 +01:00
#define TermAtt1 MkAtomTerm( Yap_heap_regs->AtomAtt1_ )
Atom AtomAttDo_;
#define AtomAttDo Yap_heap_regs->AtomAttDo_
2015-08-18 20:50:27 +01:00
#define TermAttDo MkAtomTerm( Yap_heap_regs->AtomAttDo_ )
Atom AtomAttributes_;
#define AtomAttributes Yap_heap_regs->AtomAttributes_
2015-08-18 20:50:27 +01:00
#define TermAttributes MkAtomTerm( Yap_heap_regs->AtomAttributes_ )
Atom AtomB_;
#define AtomB Yap_heap_regs->AtomB_
2015-08-18 20:50:27 +01:00
#define TermB MkAtomTerm( Yap_heap_regs->AtomB_ )
Atom AtomBatched_;
#define AtomBatched Yap_heap_regs->AtomBatched_
2015-08-18 20:50:27 +01:00
#define TermBatched MkAtomTerm( Yap_heap_regs->AtomBatched_ )
Atom AtomBetween_;
#define AtomBetween Yap_heap_regs->AtomBetween_
2015-08-18 20:50:27 +01:00
#define TermBetween MkAtomTerm( Yap_heap_regs->AtomBetween_ )
Atom AtomBinary_;
#define AtomBinary Yap_heap_regs->AtomBinary_
2015-08-18 20:50:27 +01:00
#define TermBinary MkAtomTerm( Yap_heap_regs->AtomBinary_ )
Atom AtomBigNum_;
#define AtomBigNum Yap_heap_regs->AtomBigNum_
2015-08-18 20:50:27 +01:00
#define TermBigNum MkAtomTerm( Yap_heap_regs->AtomBigNum_ )
Atom AtomBinaryStream_;
#define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_
2015-08-18 20:50:27 +01:00
#define TermBinaryStream MkAtomTerm( Yap_heap_regs->AtomBinaryStream_ )
Atom AtomBoolean_;
#define AtomBoolean Yap_heap_regs->AtomBoolean_
2015-08-18 20:50:27 +01:00
#define TermBoolean MkAtomTerm( Yap_heap_regs->AtomBoolean_ )
Atom AtomBraces_;
#define AtomBraces Yap_heap_regs->AtomBraces_
2015-08-18 20:50:27 +01:00
#define TermBraces MkAtomTerm( Yap_heap_regs->AtomBraces_ )
Atom AtomBreak_;
#define AtomBreak Yap_heap_regs->AtomBreak_
2015-08-18 20:50:27 +01:00
#define TermBreak MkAtomTerm( Yap_heap_regs->AtomBreak_ )
Atom AtomByte_;
#define AtomByte Yap_heap_regs->AtomByte_
2015-08-18 20:50:27 +01:00
#define TermByte MkAtomTerm( Yap_heap_regs->AtomByte_ )
Atom AtomCArith_;
#define AtomCArith Yap_heap_regs->AtomCArith_
2015-08-18 20:50:27 +01:00
#define TermCArith MkAtomTerm( Yap_heap_regs->AtomCArith_ )
Atom AtomCall_;
#define AtomCall Yap_heap_regs->AtomCall_
2015-08-18 20:50:27 +01:00
#define TermCall MkAtomTerm( Yap_heap_regs->AtomCall_ )
Atom AtomCallAndRetryCounter_;
#define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_
2015-08-18 20:50:27 +01:00
#define TermCallAndRetryCounter MkAtomTerm( Yap_heap_regs->AtomCallAndRetryCounter_ )
Atom AtomCallCounter_;
#define AtomCallCounter Yap_heap_regs->AtomCallCounter_
2015-08-18 20:50:27 +01:00
#define TermCallCounter MkAtomTerm( Yap_heap_regs->AtomCallCounter_ )
Atom AtomCallable_;
#define AtomCallable Yap_heap_regs->AtomCallable_
2015-08-18 20:50:27 +01:00
#define TermCallable MkAtomTerm( Yap_heap_regs->AtomCallable_ )
Atom AtomCatch_;
#define AtomCatch Yap_heap_regs->AtomCatch_
2015-08-18 20:50:27 +01:00
#define TermCatch MkAtomTerm( Yap_heap_regs->AtomCatch_ )
Atom AtomChangeModule_;
#define AtomChangeModule Yap_heap_regs->AtomChangeModule_
2015-08-18 20:50:27 +01:00
#define TermChangeModule MkAtomTerm( Yap_heap_regs->AtomChangeModule_ )
Atom AtomChar_;
#define AtomChar Yap_heap_regs->AtomChar_
2015-08-18 20:50:27 +01:00
#define TermChar MkAtomTerm( Yap_heap_regs->AtomChar_ )
Atom AtomCharsio_;
#define AtomCharsio Yap_heap_regs->AtomCharsio_
2015-08-18 20:50:27 +01:00
#define TermCharsio MkAtomTerm( Yap_heap_regs->AtomCharsio_ )
Atom AtomCharacter_;
#define AtomCharacter Yap_heap_regs->AtomCharacter_
2015-08-18 20:50:27 +01:00
#define TermCharacter MkAtomTerm( Yap_heap_regs->AtomCharacter_ )
Atom AtomCharacterCode_;
#define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_
2015-08-18 20:50:27 +01:00
#define TermCharacterCode MkAtomTerm( Yap_heap_regs->AtomCharacterCode_ )
Atom AtomChars_;
#define AtomChars Yap_heap_regs->AtomChars_
2015-08-18 20:50:27 +01:00
#define TermChars MkAtomTerm( Yap_heap_regs->AtomChars_ )
Atom AtomCharset_;
#define AtomCharset Yap_heap_regs->AtomCharset_
2015-08-18 20:50:27 +01:00
#define TermCharset MkAtomTerm( Yap_heap_regs->AtomCharset_ )
2015-10-20 07:52:33 +01:00
Atom AtomChType_;
#define AtomChType Yap_heap_regs->AtomChType_
#define TermChType MkAtomTerm( Yap_heap_regs->AtomChType_ )
2009-06-06 00:45:41 +01:00
Atom AtomCleanCall_;
#define AtomCleanCall Yap_heap_regs->AtomCleanCall_
2015-08-18 20:50:27 +01:00
#define TermCleanCall MkAtomTerm( Yap_heap_regs->AtomCleanCall_ )
Atom AtomColomn_;
#define AtomColomn Yap_heap_regs->AtomColomn_
2015-08-18 20:50:27 +01:00
#define TermColomn MkAtomTerm( Yap_heap_regs->AtomColomn_ )
Atom AtomCodeSpace_;
#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_
2015-08-18 20:50:27 +01:00
#define TermCodeSpace MkAtomTerm( Yap_heap_regs->AtomCodeSpace_ )
2010-07-19 14:48:42 +01:00
Atom AtomCodes_;
#define AtomCodes Yap_heap_regs->AtomCodes_
2015-08-18 20:50:27 +01:00
#define TermCodes MkAtomTerm( Yap_heap_regs->AtomCodes_ )
2013-12-19 16:56:55 +00:00
Atom AtomCoInductive_;
#define AtomCoInductive Yap_heap_regs->AtomCoInductive_
2015-08-18 20:50:27 +01:00
#define TermCoInductive MkAtomTerm( Yap_heap_regs->AtomCoInductive_ )
Atom AtomComma_;
#define AtomComma Yap_heap_regs->AtomComma_
2015-08-18 20:50:27 +01:00
#define TermComma MkAtomTerm( Yap_heap_regs->AtomComma_ )
2013-12-08 22:56:48 +00:00
Atom AtomCommentHook_;
#define AtomCommentHook Yap_heap_regs->AtomCommentHook_
2015-08-18 20:50:27 +01:00
#define TermCommentHook MkAtomTerm( Yap_heap_regs->AtomCommentHook_ )
Atom AtomCompact_;
#define AtomCompact Yap_heap_regs->AtomCompact_
2015-08-18 20:50:27 +01:00
#define TermCompact MkAtomTerm( Yap_heap_regs->AtomCompact_ )
Atom AtomCompound_;
#define AtomCompound Yap_heap_regs->AtomCompound_
2015-08-18 20:50:27 +01:00
#define TermCompound MkAtomTerm( Yap_heap_regs->AtomCompound_ )
Atom AtomConsistencyError_;
#define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_
2015-08-18 20:50:27 +01:00
#define TermConsistencyError MkAtomTerm( Yap_heap_regs->AtomConsistencyError_ )
Atom AtomConsult_;
#define AtomConsult Yap_heap_regs->AtomConsult_
#define TermConsult MkAtomTerm( Yap_heap_regs->AtomConsult_ )
Atom AtomConsultOnBoot_;
#define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_
2015-08-18 20:50:27 +01:00
#define TermConsultOnBoot MkAtomTerm( Yap_heap_regs->AtomConsultOnBoot_ )
Atom AtomContext_;
#define AtomContext Yap_heap_regs->AtomContext_
2015-08-18 20:50:27 +01:00
#define TermContext MkAtomTerm( Yap_heap_regs->AtomContext_ )
Atom AtomCputime_;
#define AtomCputime Yap_heap_regs->AtomCputime_
2015-08-18 20:50:27 +01:00
#define TermCputime MkAtomTerm( Yap_heap_regs->AtomCputime_ )
Atom AtomCreate_;
#define AtomCreate Yap_heap_regs->AtomCreate_
2015-08-18 20:50:27 +01:00
#define TermCreate MkAtomTerm( Yap_heap_regs->AtomCreate_ )
Atom AtomCreep_;
#define AtomCreep Yap_heap_regs->AtomCreep_
2015-08-18 20:50:27 +01:00
#define TermCreep MkAtomTerm( Yap_heap_regs->AtomCreep_ )
Atom AtomCryptAtoms_;
#define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_
2015-08-18 20:50:27 +01:00
#define TermCryptAtoms MkAtomTerm( Yap_heap_regs->AtomCryptAtoms_ )
Atom AtomCsult_;
#define AtomCsult Yap_heap_regs->AtomCsult_
2015-08-18 20:50:27 +01:00
#define TermCsult MkAtomTerm( Yap_heap_regs->AtomCsult_ )
Atom AtomCurrentModule_;
#define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_
2015-08-18 20:50:27 +01:00
#define TermCurrentModule MkAtomTerm( Yap_heap_regs->AtomCurrentModule_ )
Atom AtomCut_;
#define AtomCut Yap_heap_regs->AtomCut_
2015-08-18 20:50:27 +01:00
#define TermCut MkAtomTerm( Yap_heap_regs->AtomCut_ )
Atom AtomCutBy_;
#define AtomCutBy Yap_heap_regs->AtomCutBy_
2015-08-18 20:50:27 +01:00
#define TermCutBy MkAtomTerm( Yap_heap_regs->AtomCutBy_ )
Atom AtomDAbort_;
#define AtomDAbort Yap_heap_regs->AtomDAbort_
2015-08-18 20:50:27 +01:00
#define TermDAbort MkAtomTerm( Yap_heap_regs->AtomDAbort_ )
2011-04-30 01:16:40 +01:00
Atom AtomDBLoad_;
#define AtomDBLoad Yap_heap_regs->AtomDBLoad_
2015-08-18 20:50:27 +01:00
#define TermDBLoad MkAtomTerm( Yap_heap_regs->AtomDBLoad_ )
Atom AtomDBREF_;
#define AtomDBREF Yap_heap_regs->AtomDBREF_
2015-08-18 20:50:27 +01:00
#define TermDBREF MkAtomTerm( Yap_heap_regs->AtomDBREF_ )
Atom AtomDBReference_;
#define AtomDBReference Yap_heap_regs->AtomDBReference_
2015-08-18 20:50:27 +01:00
#define TermDBReference MkAtomTerm( Yap_heap_regs->AtomDBReference_ )
Atom AtomDBTerm_;
#define AtomDBTerm Yap_heap_regs->AtomDBTerm_
2015-08-18 20:50:27 +01:00
#define TermDBTerm MkAtomTerm( Yap_heap_regs->AtomDBTerm_ )
Atom AtomDBref_;
#define AtomDBref Yap_heap_regs->AtomDBref_
2015-08-18 20:50:27 +01:00
#define TermDBref MkAtomTerm( Yap_heap_regs->AtomDBref_ )
Atom AtomDInteger_;
#define AtomDInteger Yap_heap_regs->AtomDInteger_
2015-08-18 20:50:27 +01:00
#define TermDInteger MkAtomTerm( Yap_heap_regs->AtomDInteger_ )
2015-07-23 01:19:35 +01:00
Atom AtomDebugMeta_;
#define AtomDebugMeta Yap_heap_regs->AtomDebugMeta_
2015-08-18 20:50:27 +01:00
#define TermDebugMeta MkAtomTerm( Yap_heap_regs->AtomDebugMeta_ )
Atom AtomDebuggerInput_;
#define AtomDebuggerInput Yap_heap_regs->AtomDebuggerInput_
2015-08-18 20:50:27 +01:00
#define TermDebuggerInput MkAtomTerm( Yap_heap_regs->AtomDebuggerInput_ )
Atom AtomDec10_;
#define AtomDec10 Yap_heap_regs->AtomDec10_
2015-08-18 20:50:27 +01:00
#define TermDec10 MkAtomTerm( Yap_heap_regs->AtomDec10_ )
Atom AtomDefault_;
#define AtomDefault Yap_heap_regs->AtomDefault_
2015-08-18 20:50:27 +01:00
#define TermDefault MkAtomTerm( Yap_heap_regs->AtomDefault_ )
Atom AtomDevNull_;
#define AtomDevNull Yap_heap_regs->AtomDevNull_
2015-08-18 20:50:27 +01:00
#define TermDevNull MkAtomTerm( Yap_heap_regs->AtomDevNull_ )
Atom AtomDiff_;
#define AtomDiff Yap_heap_regs->AtomDiff_
2015-08-18 20:50:27 +01:00
#define TermDiff MkAtomTerm( Yap_heap_regs->AtomDiff_ )
2015-09-21 23:05:36 +01:00
Atom AtomDirectory_;
#define AtomDirectory Yap_heap_regs->AtomDirectory_
#define TermDirectory MkAtomTerm( Yap_heap_regs->AtomDirectory_ )
Atom AtomDiscontiguous_;
#define AtomDiscontiguous Yap_heap_regs->AtomDiscontiguous_
2015-08-18 20:50:27 +01:00
#define TermDiscontiguous MkAtomTerm( Yap_heap_regs->AtomDiscontiguous_ )
Atom AtomDiscontiguousWarnings_;
#define AtomDiscontiguousWarnings Yap_heap_regs->AtomDiscontiguousWarnings_
2015-08-18 20:50:27 +01:00
#define TermDiscontiguousWarnings MkAtomTerm( Yap_heap_regs->AtomDiscontiguousWarnings_ )
Atom AtomDollar_;
#define AtomDollar Yap_heap_regs->AtomDollar_
2015-08-18 20:50:27 +01:00
#define TermDollar MkAtomTerm( Yap_heap_regs->AtomDollar_ )
Atom AtomDoLogUpdClause_;
#define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_
2015-08-18 20:50:27 +01:00
#define TermDoLogUpdClause MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause_ )
Atom AtomDoLogUpdClause0_;
#define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_
2015-08-18 20:50:27 +01:00
#define TermDoLogUpdClause0 MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause0_ )
Atom AtomDoLogUpdClauseErase_;
#define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_
2015-08-18 20:50:27 +01:00
#define TermDoLogUpdClauseErase MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClauseErase_ )
Atom AtomDollarU_;
#define AtomDollarU Yap_heap_regs->AtomDollarU_
2015-08-18 20:50:27 +01:00
#define TermDollarU MkAtomTerm( Yap_heap_regs->AtomDollarU_ )
Atom AtomDollarUndef_;
#define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_
2015-08-18 20:50:27 +01:00
#define TermDollarUndef MkAtomTerm( Yap_heap_regs->AtomDollarUndef_ )
Atom AtomDomainError_;
#define AtomDomainError Yap_heap_regs->AtomDomainError_
2015-08-18 20:50:27 +01:00
#define TermDomainError MkAtomTerm( Yap_heap_regs->AtomDomainError_ )
Atom AtomDoStaticClause_;
#define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_
2015-08-18 20:50:27 +01:00
#define TermDoStaticClause MkAtomTerm( Yap_heap_regs->AtomDoStaticClause_ )
Atom AtomDots_;
#define AtomDots Yap_heap_regs->AtomDots_
2015-08-18 20:50:27 +01:00
#define TermDots MkAtomTerm( Yap_heap_regs->AtomDots_ )
Atom AtomDOUBLE_;
#define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_
2015-08-18 20:50:27 +01:00
#define TermDOUBLE MkAtomTerm( Yap_heap_regs->AtomDOUBLE_ )
2016-01-03 15:44:33 +00:00
Atom AtomDoubleSlash_;
#define AtomDoubleSlash Yap_heap_regs->AtomDoubleSlash_
#define TermDoubleSlash MkAtomTerm( Yap_heap_regs->AtomDoubleSlash_ )
Atom AtomE_;
#define AtomE Yap_heap_regs->AtomE_
2015-08-18 20:50:27 +01:00
#define TermE MkAtomTerm( Yap_heap_regs->AtomE_ )
Atom AtomEOFBeforeEOT_;
#define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_
2015-08-18 20:50:27 +01:00
#define TermEOFBeforeEOT MkAtomTerm( Yap_heap_regs->AtomEOFBeforeEOT_ )
Atom AtomEQ_;
#define AtomEQ Yap_heap_regs->AtomEQ_
2015-08-18 20:50:27 +01:00
#define TermEQ MkAtomTerm( Yap_heap_regs->AtomEQ_ )
Atom AtomEmptyAtom_;
#define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_
2015-08-18 20:50:27 +01:00
#define TermEmptyAtom MkAtomTerm( Yap_heap_regs->AtomEmptyAtom_ )
Atom AtomEncoding_;
#define AtomEncoding Yap_heap_regs->AtomEncoding_
2015-08-18 20:50:27 +01:00
#define TermEncoding MkAtomTerm( Yap_heap_regs->AtomEncoding_ )
Atom AtomEndOfStream_;
#define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_
2015-08-18 20:50:27 +01:00
#define TermEndOfStream MkAtomTerm( Yap_heap_regs->AtomEndOfStream_ )
Atom AtomEof_;
#define AtomEof Yap_heap_regs->AtomEof_
2015-08-18 20:50:27 +01:00
#define TermEof MkAtomTerm( Yap_heap_regs->AtomEof_ )
Atom AtomEOfCode_;
#define AtomEOfCode Yap_heap_regs->AtomEOfCode_
2015-08-18 20:50:27 +01:00
#define TermEOfCode MkAtomTerm( Yap_heap_regs->AtomEOfCode_ )
Atom AtomEq_;
#define AtomEq Yap_heap_regs->AtomEq_
2015-08-18 20:50:27 +01:00
#define TermEq MkAtomTerm( Yap_heap_regs->AtomEq_ )
Atom AtomError_;
#define AtomError Yap_heap_regs->AtomError_
2015-08-18 20:50:27 +01:00
#define TermError MkAtomTerm( Yap_heap_regs->AtomError_ )
Atom AtomException_;
#define AtomException Yap_heap_regs->AtomException_
2015-08-18 20:50:27 +01:00
#define TermException MkAtomTerm( Yap_heap_regs->AtomException_ )
2015-09-21 23:05:36 +01:00
Atom AtomExtensions_;
#define AtomExtensions Yap_heap_regs->AtomExtensions_
#define TermExtensions MkAtomTerm( Yap_heap_regs->AtomExtensions_ )
Atom AtomEvaluable_;
#define AtomEvaluable Yap_heap_regs->AtomEvaluable_
2015-08-18 20:50:27 +01:00
#define TermEvaluable MkAtomTerm( Yap_heap_regs->AtomEvaluable_ )
Atom AtomEvaluationError_;
#define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_
2015-08-18 20:50:27 +01:00
#define TermEvaluationError MkAtomTerm( Yap_heap_regs->AtomEvaluationError_ )
2015-09-21 23:05:36 +01:00
Atom AtomExecutable_;
#define AtomExecutable Yap_heap_regs->AtomExecutable_
#define TermExecutable MkAtomTerm( Yap_heap_regs->AtomExecutable_ )
2010-08-03 21:04:16 +01:00
Atom AtomExecute_;
#define AtomExecute Yap_heap_regs->AtomExecute_
2015-08-18 20:50:27 +01:00
#define TermExecute MkAtomTerm( Yap_heap_regs->AtomExecute_ )
Atom AtomExecAnswers_;
#define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_
2015-08-18 20:50:27 +01:00
#define TermExecAnswers MkAtomTerm( Yap_heap_regs->AtomExecAnswers_ )
Atom AtomExecuteInMod_;
#define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_
2015-08-18 20:50:27 +01:00
#define TermExecuteInMod MkAtomTerm( Yap_heap_regs->AtomExecuteInMod_ )
Atom AtomExecuteWithin_;
#define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_
2015-08-18 20:50:27 +01:00
#define TermExecuteWithin MkAtomTerm( Yap_heap_regs->AtomExecuteWithin_ )
Atom AtomExecuteWoMod_;
#define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_
2015-08-18 20:50:27 +01:00
#define TermExecuteWoMod MkAtomTerm( Yap_heap_regs->AtomExecuteWoMod_ )
2010-08-03 21:04:16 +01:00
Atom AtomExist_;
#define AtomExist Yap_heap_regs->AtomExist_
2015-08-18 20:50:27 +01:00
#define TermExist MkAtomTerm( Yap_heap_regs->AtomExist_ )
Atom AtomExistenceError_;
#define AtomExistenceError Yap_heap_regs->AtomExistenceError_
2015-08-18 20:50:27 +01:00
#define TermExistenceError MkAtomTerm( Yap_heap_regs->AtomExistenceError_ )
2013-01-11 16:45:14 +00:00
Atom AtomExoClause_;
#define AtomExoClause Yap_heap_regs->AtomExoClause_
2015-08-18 20:50:27 +01:00
#define TermExoClause MkAtomTerm( Yap_heap_regs->AtomExoClause_ )
Atom AtomExpectedNumber_;
#define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_
2015-08-18 20:50:27 +01:00
#define TermExpectedNumber MkAtomTerm( Yap_heap_regs->AtomExpectedNumber_ )
2015-09-21 23:05:36 +01:00
Atom AtomExpand_;
#define AtomExpand Yap_heap_regs->AtomExpand_
#define TermExpand MkAtomTerm( Yap_heap_regs->AtomExpand_ )
Atom AtomExtendFileSearchPath_;
#define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_
2015-08-18 20:50:27 +01:00
#define TermExtendFileSearchPath MkAtomTerm( Yap_heap_regs->AtomExtendFileSearchPath_ )
2015-09-21 23:05:36 +01:00
Atom AtomExtendsions_;
#define AtomExtendsions Yap_heap_regs->AtomExtendsions_
#define TermExtendsions MkAtomTerm( Yap_heap_regs->AtomExtendsions_ )
Atom AtomFB_;
#define AtomFB Yap_heap_regs->AtomFB_
2015-08-18 20:50:27 +01:00
#define TermFB MkAtomTerm( Yap_heap_regs->AtomFB_ )
Atom AtomFail_;
#define AtomFail Yap_heap_regs->AtomFail_
2015-08-18 20:50:27 +01:00
#define TermFail MkAtomTerm( Yap_heap_regs->AtomFail_ )
Atom AtomFalse_;
#define AtomFalse Yap_heap_regs->AtomFalse_
2015-08-18 20:50:27 +01:00
#define TermFalse MkAtomTerm( Yap_heap_regs->AtomFalse_ )
Atom AtomFast_;
#define AtomFast Yap_heap_regs->AtomFast_
2015-08-18 20:50:27 +01:00
#define TermFast MkAtomTerm( Yap_heap_regs->AtomFast_ )
Atom AtomFastFail_;
#define AtomFastFail Yap_heap_regs->AtomFastFail_
#define TermFastFail MkAtomTerm( Yap_heap_regs->AtomFastFail_ )
2015-09-21 23:05:36 +01:00
Atom AtomFileErrors_;
#define AtomFileErrors Yap_heap_regs->AtomFileErrors_
#define TermFileErrors MkAtomTerm( Yap_heap_regs->AtomFileErrors_ )
Atom AtomFileerrors_;
#define AtomFileerrors Yap_heap_regs->AtomFileerrors_
2015-08-18 20:50:27 +01:00
#define TermFileerrors MkAtomTerm( Yap_heap_regs->AtomFileerrors_ )
2015-09-21 23:05:36 +01:00
Atom AtomFileType_;
#define AtomFileType Yap_heap_regs->AtomFileType_
#define TermFileType MkAtomTerm( Yap_heap_regs->AtomFileType_ )
Atom AtomFirst_;
#define AtomFirst Yap_heap_regs->AtomFirst_
#define TermFirst MkAtomTerm( Yap_heap_regs->AtomFirst_ )
Atom AtomFloat_;
#define AtomFloat Yap_heap_regs->AtomFloat_
2015-08-18 20:50:27 +01:00
#define TermFloat MkAtomTerm( Yap_heap_regs->AtomFloat_ )
Atom AtomFloatFormat_;
#define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_
2015-08-18 20:50:27 +01:00
#define TermFloatFormat MkAtomTerm( Yap_heap_regs->AtomFloatFormat_ )
Atom AtomFloatOverflow_;
#define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_
2015-08-18 20:50:27 +01:00
#define TermFloatOverflow MkAtomTerm( Yap_heap_regs->AtomFloatOverflow_ )
Atom AtomFloatUnderflow_;
#define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_
2015-08-18 20:50:27 +01:00
#define TermFloatUnderflow MkAtomTerm( Yap_heap_regs->AtomFloatUnderflow_ )
Atom AtomFormat_;
#define AtomFormat Yap_heap_regs->AtomFormat_
2015-08-18 20:50:27 +01:00
#define TermFormat MkAtomTerm( Yap_heap_regs->AtomFormat_ )
Atom AtomFormatAt_;
#define AtomFormatAt Yap_heap_regs->AtomFormatAt_
2015-08-18 20:50:27 +01:00
#define TermFormatAt MkAtomTerm( Yap_heap_regs->AtomFormatAt_ )
Atom AtomFull_;
#define AtomFull Yap_heap_regs->AtomFull_
2015-08-18 20:50:27 +01:00
#define TermFull MkAtomTerm( Yap_heap_regs->AtomFull_ )
Atom AtomFunctor_;
#define AtomFunctor Yap_heap_regs->AtomFunctor_
2015-08-18 20:50:27 +01:00
#define TermFunctor MkAtomTerm( Yap_heap_regs->AtomFunctor_ )
Atom AtomGT_;
#define AtomGT Yap_heap_regs->AtomGT_
2015-08-18 20:50:27 +01:00
#define TermGT MkAtomTerm( Yap_heap_regs->AtomGT_ )
Atom AtomGVar_;
#define AtomGVar Yap_heap_regs->AtomGVar_
2015-08-18 20:50:27 +01:00
#define TermGVar MkAtomTerm( Yap_heap_regs->AtomGVar_ )
Atom AtomGc_;
#define AtomGc Yap_heap_regs->AtomGc_
2015-08-18 20:50:27 +01:00
#define TermGc MkAtomTerm( Yap_heap_regs->AtomGc_ )
Atom AtomGcMargin_;
#define AtomGcMargin Yap_heap_regs->AtomGcMargin_
2015-08-18 20:50:27 +01:00
#define TermGcMargin MkAtomTerm( Yap_heap_regs->AtomGcMargin_ )
Atom AtomGcTrace_;
#define AtomGcTrace Yap_heap_regs->AtomGcTrace_
2015-08-18 20:50:27 +01:00
#define TermGcTrace MkAtomTerm( Yap_heap_regs->AtomGcTrace_ )
Atom AtomGcVerbose_;
#define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_
2015-08-18 20:50:27 +01:00
#define TermGcVerbose MkAtomTerm( Yap_heap_regs->AtomGcVerbose_ )
Atom AtomGcVeryVerbose_;
#define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_
2015-08-18 20:50:27 +01:00
#define TermGcVeryVerbose MkAtomTerm( Yap_heap_regs->AtomGcVeryVerbose_ )
Atom AtomGeneratePredInfo_;
#define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_
2015-08-18 20:50:27 +01:00
#define TermGeneratePredInfo MkAtomTerm( Yap_heap_regs->AtomGeneratePredInfo_ )
Atom AtomGetwork_;
#define AtomGetwork Yap_heap_regs->AtomGetwork_
2015-08-18 20:50:27 +01:00
#define TermGetwork MkAtomTerm( Yap_heap_regs->AtomGetwork_ )
Atom AtomGetworkSeq_;
#define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_
2015-08-18 20:50:27 +01:00
#define TermGetworkSeq MkAtomTerm( Yap_heap_regs->AtomGetworkSeq_ )
Atom AtomGlob_;
#define AtomGlob Yap_heap_regs->AtomGlob_
#define TermGlob MkAtomTerm( Yap_heap_regs->AtomGlob_ )
Atom AtomGlobal_;
#define AtomGlobal Yap_heap_regs->AtomGlobal_
2015-08-18 20:50:27 +01:00
#define TermGlobal MkAtomTerm( Yap_heap_regs->AtomGlobal_ )
Atom AtomGlobalSp_;
#define AtomGlobalSp Yap_heap_regs->AtomGlobalSp_
2015-08-18 20:50:27 +01:00
#define TermGlobalSp MkAtomTerm( Yap_heap_regs->AtomGlobalSp_ )
Atom AtomGlobalTrie_;
#define AtomGlobalTrie Yap_heap_regs->AtomGlobalTrie_
2015-08-18 20:50:27 +01:00
#define TermGlobalTrie MkAtomTerm( Yap_heap_regs->AtomGlobalTrie_ )
Atom AtomGoalExpansion_;
#define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_
2015-08-18 20:50:27 +01:00
#define TermGoalExpansion MkAtomTerm( Yap_heap_regs->AtomGoalExpansion_ )
Atom AtomHat_;
#define AtomHat Yap_heap_regs->AtomHat_
2015-08-18 20:50:27 +01:00
#define TermHat MkAtomTerm( Yap_heap_regs->AtomHat_ )
Atom AtomHERE_;
#define AtomHERE Yap_heap_regs->AtomHERE_
2015-08-18 20:50:27 +01:00
#define TermHERE MkAtomTerm( Yap_heap_regs->AtomHERE_ )
Atom AtomHandleThrow_;
#define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_
2015-08-18 20:50:27 +01:00
#define TermHandleThrow MkAtomTerm( Yap_heap_regs->AtomHandleThrow_ )
Atom AtomHeap_;
#define AtomHeap Yap_heap_regs->AtomHeap_
2015-08-18 20:50:27 +01:00
#define TermHeap MkAtomTerm( Yap_heap_regs->AtomHeap_ )
Atom AtomHeapUsed_;
#define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_
2015-08-18 20:50:27 +01:00
#define TermHeapUsed MkAtomTerm( Yap_heap_regs->AtomHeapUsed_ )
Atom AtomHugeInt_;
#define AtomHugeInt Yap_heap_regs->AtomHugeInt_
2015-08-18 20:50:27 +01:00
#define TermHugeInt MkAtomTerm( Yap_heap_regs->AtomHugeInt_ )
Atom AtomIDB_;
#define AtomIDB Yap_heap_regs->AtomIDB_
2015-08-18 20:50:27 +01:00
#define TermIDB MkAtomTerm( Yap_heap_regs->AtomIDB_ )
Atom AtomIOMode_;
#define AtomIOMode Yap_heap_regs->AtomIOMode_
2015-08-18 20:50:27 +01:00
#define TermIOMode MkAtomTerm( Yap_heap_regs->AtomIOMode_ )
Atom AtomId_;
#define AtomId Yap_heap_regs->AtomId_
2015-08-18 20:50:27 +01:00
#define TermId MkAtomTerm( Yap_heap_regs->AtomId_ )
Atom AtomIgnore_;
#define AtomIgnore Yap_heap_regs->AtomIgnore_
2015-08-18 20:50:27 +01:00
#define TermIgnore MkAtomTerm( Yap_heap_regs->AtomIgnore_ )
Atom AtomInf_;
#define AtomInf Yap_heap_regs->AtomInf_
2015-08-18 20:50:27 +01:00
#define TermInf MkAtomTerm( Yap_heap_regs->AtomInf_ )
2013-04-30 00:22:53 +01:00
Atom AtomInfinity_;
#define AtomInfinity Yap_heap_regs->AtomInfinity_
2015-08-18 20:50:27 +01:00
#define TermInfinity MkAtomTerm( Yap_heap_regs->AtomInfinity_ )
Atom AtomInitGoal_;
#define AtomInitGoal Yap_heap_regs->AtomInitGoal_
2015-08-18 20:50:27 +01:00
#define TermInitGoal MkAtomTerm( Yap_heap_regs->AtomInitGoal_ )
Atom AtomInitProlog_;
#define AtomInitProlog Yap_heap_regs->AtomInitProlog_
2015-08-18 20:50:27 +01:00
#define TermInitProlog MkAtomTerm( Yap_heap_regs->AtomInitProlog_ )
2009-06-13 22:05:45 +01:00
Atom AtomInStackExpansion_;
#define AtomInStackExpansion Yap_heap_regs->AtomInStackExpansion_
2015-08-18 20:50:27 +01:00
#define TermInStackExpansion MkAtomTerm( Yap_heap_regs->AtomInStackExpansion_ )
Atom AtomInput_;
#define AtomInput Yap_heap_regs->AtomInput_
2015-08-18 20:50:27 +01:00
#define TermInput MkAtomTerm( Yap_heap_regs->AtomInput_ )
Atom AtomInstantiationError_;
#define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_
2015-08-18 20:50:27 +01:00
#define TermInstantiationError MkAtomTerm( Yap_heap_regs->AtomInstantiationError_ )
Atom AtomInt_;
#define AtomInt Yap_heap_regs->AtomInt_
2015-08-18 20:50:27 +01:00
#define TermInt MkAtomTerm( Yap_heap_regs->AtomInt_ )
Atom AtomIntOverflow_;
#define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_
2015-08-18 20:50:27 +01:00
#define TermIntOverflow MkAtomTerm( Yap_heap_regs->AtomIntOverflow_ )
Atom AtomInteger_;
#define AtomInteger Yap_heap_regs->AtomInteger_
2015-08-18 20:50:27 +01:00
#define TermInteger MkAtomTerm( Yap_heap_regs->AtomInteger_ )
Atom AtomInternalCompilerError_;
#define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_
2015-08-18 20:50:27 +01:00
#define TermInternalCompilerError MkAtomTerm( Yap_heap_regs->AtomInternalCompilerError_ )
Atom AtomIs_;
#define AtomIs Yap_heap_regs->AtomIs_
2015-08-18 20:50:27 +01:00
#define TermIs MkAtomTerm( Yap_heap_regs->AtomIs_ )
Atom AtomKey_;
#define AtomKey Yap_heap_regs->AtomKey_
2015-08-18 20:50:27 +01:00
#define TermKey MkAtomTerm( Yap_heap_regs->AtomKey_ )
Atom AtomLDLibraryPath_;
#define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_
2015-08-18 20:50:27 +01:00
#define TermLDLibraryPath MkAtomTerm( Yap_heap_regs->AtomLDLibraryPath_ )
Atom AtomLONGINT_;
#define AtomLONGINT Yap_heap_regs->AtomLONGINT_
2015-08-18 20:50:27 +01:00
#define TermLONGINT MkAtomTerm( Yap_heap_regs->AtomLONGINT_ )
Atom AtomLOOP_;
#define AtomLOOP Yap_heap_regs->AtomLOOP_
2015-08-18 20:50:27 +01:00
#define TermLOOP MkAtomTerm( Yap_heap_regs->AtomLOOP_ )
Atom AtomLoopStream_;
#define AtomLoopStream Yap_heap_regs->AtomLoopStream_
2015-08-18 20:50:27 +01:00
#define TermLoopStream MkAtomTerm( Yap_heap_regs->AtomLoopStream_ )
Atom AtomLT_;
#define AtomLT Yap_heap_regs->AtomLT_
2015-08-18 20:50:27 +01:00
#define TermLT MkAtomTerm( Yap_heap_regs->AtomLT_ )
Atom AtomLastExecuteWithin_;
#define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_
2015-08-18 20:50:27 +01:00
#define TermLastExecuteWithin MkAtomTerm( Yap_heap_regs->AtomLastExecuteWithin_ )
Atom AtomLeash_;
#define AtomLeash Yap_heap_regs->AtomLeash_
2015-08-18 20:50:27 +01:00
#define TermLeash MkAtomTerm( Yap_heap_regs->AtomLeash_ )
2013-06-26 04:53:23 +01:00
Atom AtomLeast_;
#define AtomLeast Yap_heap_regs->AtomLeast_
2015-08-18 20:50:27 +01:00
#define TermLeast MkAtomTerm( Yap_heap_regs->AtomLeast_ )
Atom AtomLength_;
#define AtomLength Yap_heap_regs->AtomLength_
2015-08-18 20:50:27 +01:00
#define TermLength MkAtomTerm( Yap_heap_regs->AtomLength_ )
Atom AtomList_;
#define AtomList Yap_heap_regs->AtomList_
2015-08-18 20:50:27 +01:00
#define TermList MkAtomTerm( Yap_heap_regs->AtomList_ )
Atom AtomLine_;
#define AtomLine Yap_heap_regs->AtomLine_
2015-08-18 20:50:27 +01:00
#define TermLine MkAtomTerm( Yap_heap_regs->AtomLine_ )
Atom AtomLive_;
#define AtomLive Yap_heap_regs->AtomLive_
2015-08-18 20:50:27 +01:00
#define TermLive MkAtomTerm( Yap_heap_regs->AtomLive_ )
Atom AtomLoadAnswers_;
#define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_
2015-08-18 20:50:27 +01:00
#define TermLoadAnswers MkAtomTerm( Yap_heap_regs->AtomLoadAnswers_ )
Atom AtomLocal_;
#define AtomLocal Yap_heap_regs->AtomLocal_
2015-08-18 20:50:27 +01:00
#define TermLocal MkAtomTerm( Yap_heap_regs->AtomLocal_ )
Atom AtomLocalSp_;
#define AtomLocalSp Yap_heap_regs->AtomLocalSp_
2015-08-18 20:50:27 +01:00
#define TermLocalSp MkAtomTerm( Yap_heap_regs->AtomLocalSp_ )
Atom AtomLocalTrie_;
#define AtomLocalTrie Yap_heap_regs->AtomLocalTrie_
2015-08-18 20:50:27 +01:00
#define TermLocalTrie MkAtomTerm( Yap_heap_regs->AtomLocalTrie_ )
2013-04-17 02:04:53 +01:00
Atom AtomMax_;
#define AtomMax Yap_heap_regs->AtomMax_
2015-08-18 20:50:27 +01:00
#define TermMax MkAtomTerm( Yap_heap_regs->AtomMax_ )
2013-06-26 04:53:23 +01:00
Atom AtomMaximum_;
#define AtomMaximum Yap_heap_regs->AtomMaximum_
2015-08-18 20:50:27 +01:00
#define TermMaximum MkAtomTerm( Yap_heap_regs->AtomMaximum_ )
Atom AtomMaxArity_;
#define AtomMaxArity Yap_heap_regs->AtomMaxArity_
2015-08-18 20:50:27 +01:00
#define TermMaxArity MkAtomTerm( Yap_heap_regs->AtomMaxArity_ )
Atom AtomMaxFiles_;
#define AtomMaxFiles Yap_heap_regs->AtomMaxFiles_
2015-08-18 20:50:27 +01:00
#define TermMaxFiles MkAtomTerm( Yap_heap_regs->AtomMaxFiles_ )
Atom AtomMegaClause_;
#define AtomMegaClause Yap_heap_regs->AtomMegaClause_
2015-08-18 20:50:27 +01:00
#define TermMegaClause MkAtomTerm( Yap_heap_regs->AtomMegaClause_ )
Atom AtomMetaCall_;
#define AtomMetaCall Yap_heap_regs->AtomMetaCall_
2015-08-18 20:50:27 +01:00
#define TermMetaCall MkAtomTerm( Yap_heap_regs->AtomMetaCall_ )
Atom AtomMfClause_;
#define AtomMfClause Yap_heap_regs->AtomMfClause_
2015-08-18 20:50:27 +01:00
#define TermMfClause MkAtomTerm( Yap_heap_regs->AtomMfClause_ )
2013-04-17 02:04:53 +01:00
Atom AtomMin_;
#define AtomMin Yap_heap_regs->AtomMin_
2015-08-18 20:50:27 +01:00
#define TermMin MkAtomTerm( Yap_heap_regs->AtomMin_ )
2013-06-26 04:53:23 +01:00
Atom AtomMinimum_;
#define AtomMinimum Yap_heap_regs->AtomMinimum_
2015-08-18 20:50:27 +01:00
#define TermMinimum MkAtomTerm( Yap_heap_regs->AtomMinimum_ )
Atom AtomMinus_;
#define AtomMinus Yap_heap_regs->AtomMinus_
2015-08-18 20:50:27 +01:00
#define TermMinus MkAtomTerm( Yap_heap_regs->AtomMinus_ )
Atom AtomModify_;
#define AtomModify Yap_heap_regs->AtomModify_
2015-08-18 20:50:27 +01:00
#define TermModify MkAtomTerm( Yap_heap_regs->AtomModify_ )
Atom AtomModule_;
#define AtomModule Yap_heap_regs->AtomModule_
2015-08-18 20:50:27 +01:00
#define TermModule MkAtomTerm( Yap_heap_regs->AtomModule_ )
2013-06-26 04:53:23 +01:00
Atom AtomMost_;
#define AtomMost Yap_heap_regs->AtomMost_
2015-08-18 20:50:27 +01:00
#define TermMost MkAtomTerm( Yap_heap_regs->AtomMost_ )
Atom AtomMulti_;
#define AtomMulti Yap_heap_regs->AtomMulti_
2015-08-18 20:50:27 +01:00
#define TermMulti MkAtomTerm( Yap_heap_regs->AtomMulti_ )
Atom AtomMultiFile_;
#define AtomMultiFile Yap_heap_regs->AtomMultiFile_
2015-08-18 20:50:27 +01:00
#define TermMultiFile MkAtomTerm( Yap_heap_regs->AtomMultiFile_ )
Atom AtomMultiple_;
#define AtomMultiple Yap_heap_regs->AtomMultiple_
2015-08-18 20:50:27 +01:00
#define TermMultiple MkAtomTerm( Yap_heap_regs->AtomMultiple_ )
Atom AtomMutable_;
#define AtomMutable Yap_heap_regs->AtomMutable_
2015-08-18 20:50:27 +01:00
#define TermMutable MkAtomTerm( Yap_heap_regs->AtomMutable_ )
Atom AtomMutableVariable_;
#define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_
2015-08-18 20:50:27 +01:00
#define TermMutableVariable MkAtomTerm( Yap_heap_regs->AtomMutableVariable_ )
2014-11-27 10:02:04 +00:00
Atom AtomMutex_;
#define AtomMutex Yap_heap_regs->AtomMutex_
2015-08-18 20:50:27 +01:00
#define TermMutex MkAtomTerm( Yap_heap_regs->AtomMutex_ )
Atom AtomMyddasDB_;
#define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_
2015-08-18 20:50:27 +01:00
#define TermMyddasDB MkAtomTerm( Yap_heap_regs->AtomMyddasDB_ )
Atom AtomMyddasGoal_;
#define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_
2015-08-18 20:50:27 +01:00
#define TermMyddasGoal MkAtomTerm( Yap_heap_regs->AtomMyddasGoal_ )
Atom AtomMyddasHost_;
#define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_
2015-08-18 20:50:27 +01:00
#define TermMyddasHost MkAtomTerm( Yap_heap_regs->AtomMyddasHost_ )
Atom AtomMyddasPass_;
#define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_
2015-08-18 20:50:27 +01:00
#define TermMyddasPass MkAtomTerm( Yap_heap_regs->AtomMyddasPass_ )
Atom AtomMyddasUser_;
#define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_
2015-08-18 20:50:27 +01:00
#define TermMyddasUser MkAtomTerm( Yap_heap_regs->AtomMyddasUser_ )
Atom AtomMyddasVersionName_;
#define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_
2015-08-18 20:50:27 +01:00
#define TermMyddasVersionName MkAtomTerm( Yap_heap_regs->AtomMyddasVersionName_ )
Atom AtomNan_;
#define AtomNan Yap_heap_regs->AtomNan_
2015-08-18 20:50:27 +01:00
#define TermNan MkAtomTerm( Yap_heap_regs->AtomNan_ )
Atom AtomNb_;
#define AtomNb Yap_heap_regs->AtomNb_
2015-08-18 20:50:27 +01:00
#define TermNb MkAtomTerm( Yap_heap_regs->AtomNb_ )
Atom AtomNbTerm_;
#define AtomNbTerm Yap_heap_regs->AtomNbTerm_
2015-08-18 20:50:27 +01:00
#define TermNbTerm MkAtomTerm( Yap_heap_regs->AtomNbTerm_ )
Atom AtomNew_;
#define AtomNew Yap_heap_regs->AtomNew_
2015-08-18 20:50:27 +01:00
#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_
2015-08-18 20:50:27 +01:00
#define TermNoEffect MkAtomTerm( Yap_heap_regs->AtomNoEffect_ )
Atom AtomNoMemory_;
#define AtomNoMemory Yap_heap_regs->AtomNoMemory_
2015-08-18 20:50:27 +01:00
#define TermNoMemory MkAtomTerm( Yap_heap_regs->AtomNoMemory_ )
2010-08-03 21:04:16 +01:00
Atom AtomNone_;
#define AtomNone Yap_heap_regs->AtomNone_
2015-08-18 20:50:27 +01:00
#define TermNone MkAtomTerm( Yap_heap_regs->AtomNone_ )
Atom AtomNonEmptyList_;
#define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_
2015-08-18 20:50:27 +01:00
#define TermNonEmptyList MkAtomTerm( Yap_heap_regs->AtomNonEmptyList_ )
Atom AtomNot_;
#define AtomNot Yap_heap_regs->AtomNot_
2015-08-18 20:50:27 +01:00
#define TermNot MkAtomTerm( Yap_heap_regs->AtomNot_ )
Atom AtomNotImplemented_;
#define AtomNotImplemented Yap_heap_regs->AtomNotImplemented_
2015-08-18 20:50:27 +01:00
#define TermNotImplemented MkAtomTerm( Yap_heap_regs->AtomNotImplemented_ )
Atom AtomNotLessThanZero_;
#define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_
2015-08-18 20:50:27 +01:00
#define TermNotLessThanZero MkAtomTerm( Yap_heap_regs->AtomNotLessThanZero_ )
Atom AtomNotNewline_;
#define AtomNotNewline Yap_heap_regs->AtomNotNewline_
2015-08-18 20:50:27 +01:00
#define TermNotNewline MkAtomTerm( Yap_heap_regs->AtomNotNewline_ )
Atom AtomNotZero_;
#define AtomNotZero Yap_heap_regs->AtomNotZero_
2015-08-18 20:50:27 +01:00
#define TermNotZero MkAtomTerm( Yap_heap_regs->AtomNotZero_ )
Atom AtomNumber_;
#define AtomNumber Yap_heap_regs->AtomNumber_
2015-08-18 20:50:27 +01:00
#define TermNumber MkAtomTerm( Yap_heap_regs->AtomNumber_ )
Atom AtomOff_;
#define AtomOff Yap_heap_regs->AtomOff_
2015-08-18 20:50:27 +01:00
#define TermOff MkAtomTerm( Yap_heap_regs->AtomOff_ )
Atom AtomOffline_;
#define AtomOffline Yap_heap_regs->AtomOffline_
2015-08-18 20:50:27 +01:00
#define TermOffline MkAtomTerm( Yap_heap_regs->AtomOffline_ )
Atom AtomOn_;
#define AtomOn Yap_heap_regs->AtomOn_
2015-08-18 20:50:27 +01:00
#define TermOn MkAtomTerm( Yap_heap_regs->AtomOn_ )
Atom AtomOnline_;
#define AtomOnline Yap_heap_regs->AtomOnline_
2015-08-18 20:50:27 +01:00
#define TermOnline MkAtomTerm( Yap_heap_regs->AtomOnline_ )
Atom AtomOpen_;
#define AtomOpen Yap_heap_regs->AtomOpen_
2015-08-18 20:50:27 +01:00
#define TermOpen MkAtomTerm( Yap_heap_regs->AtomOpen_ )
Atom AtomOperatingSystemError_;
#define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_
2015-08-18 20:50:27 +01:00
#define TermOperatingSystemError MkAtomTerm( Yap_heap_regs->AtomOperatingSystemError_ )
Atom AtomOperatingSystemSupport_;
#define AtomOperatingSystemSupport Yap_heap_regs->AtomOperatingSystemSupport_
2015-08-18 20:50:27 +01:00
#define TermOperatingSystemSupport MkAtomTerm( Yap_heap_regs->AtomOperatingSystemSupport_ )
Atom AtomOperator_;
#define AtomOperator Yap_heap_regs->AtomOperator_
2015-08-18 20:50:27 +01:00
#define TermOperator MkAtomTerm( Yap_heap_regs->AtomOperator_ )
Atom AtomOperatorPriority_;
#define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_
2015-08-18 20:50:27 +01:00
#define TermOperatorPriority MkAtomTerm( Yap_heap_regs->AtomOperatorPriority_ )
Atom AtomOperatorSpecifier_;
#define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_
2015-08-18 20:50:27 +01:00
#define TermOperatorSpecifier MkAtomTerm( Yap_heap_regs->AtomOperatorSpecifier_ )
2015-09-21 23:05:36 +01:00
Atom AtomOpt_;
#define AtomOpt Yap_heap_regs->AtomOpt_
#define TermOpt MkAtomTerm( Yap_heap_regs->AtomOpt_ )
Atom AtomOtherwise_;
#define AtomOtherwise Yap_heap_regs->AtomOtherwise_
2015-08-18 20:50:27 +01:00
#define TermOtherwise MkAtomTerm( Yap_heap_regs->AtomOtherwise_ )
Atom AtomOutOfAttvarsError_;
#define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_
2015-08-18 20:50:27 +01:00
#define TermOutOfAttvarsError MkAtomTerm( Yap_heap_regs->AtomOutOfAttvarsError_ )
Atom AtomOutOfAuxspaceError_;
#define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_
2015-08-18 20:50:27 +01:00
#define TermOutOfAuxspaceError MkAtomTerm( Yap_heap_regs->AtomOutOfAuxspaceError_ )
Atom AtomOutOfHeapError_;
#define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_
2015-08-18 20:50:27 +01:00
#define TermOutOfHeapError MkAtomTerm( Yap_heap_regs->AtomOutOfHeapError_ )
Atom AtomOutOfRange_;
#define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_
2015-08-18 20:50:27 +01:00
#define TermOutOfRange MkAtomTerm( Yap_heap_regs->AtomOutOfRange_ )
Atom AtomOutOfStackError_;
#define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_
2015-08-18 20:50:27 +01:00
#define TermOutOfStackError MkAtomTerm( Yap_heap_regs->AtomOutOfStackError_ )
Atom AtomOutOfTrailError_;
#define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_
2015-08-18 20:50:27 +01:00
#define TermOutOfTrailError MkAtomTerm( Yap_heap_regs->AtomOutOfTrailError_ )
Atom AtomOutput_;
#define AtomOutput Yap_heap_regs->AtomOutput_
2015-08-18 20:50:27 +01:00
#define TermOutput MkAtomTerm( Yap_heap_regs->AtomOutput_ )
Atom AtomParameter_;
#define AtomParameter Yap_heap_regs->AtomParameter_
2015-08-18 20:50:27 +01:00
#define TermParameter MkAtomTerm( Yap_heap_regs->AtomParameter_ )
Atom AtomPrologCommonsDir_;
#define AtomPrologCommonsDir Yap_heap_regs->AtomPrologCommonsDir_
2015-08-18 20:50:27 +01:00
#define TermPrologCommonsDir MkAtomTerm( Yap_heap_regs->AtomPrologCommonsDir_ )
Atom AtomPast_;
#define AtomPast Yap_heap_regs->AtomPast_
2015-08-18 20:50:27 +01:00
#define TermPast MkAtomTerm( Yap_heap_regs->AtomPast_ )
Atom AtomPastEndOfStream_;
#define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_
2015-08-18 20:50:27 +01:00
#define TermPastEndOfStream MkAtomTerm( Yap_heap_regs->AtomPastEndOfStream_ )
Atom AtomPermissionError_;
#define AtomPermissionError Yap_heap_regs->AtomPermissionError_
2015-08-18 20:50:27 +01:00
#define TermPermissionError MkAtomTerm( Yap_heap_regs->AtomPermissionError_ )
Atom AtomPi_;
#define AtomPi Yap_heap_regs->AtomPi_
2015-08-18 20:50:27 +01:00
#define TermPi MkAtomTerm( Yap_heap_regs->AtomPi_ )
Atom AtomPipe_;
#define AtomPipe Yap_heap_regs->AtomPipe_
2015-08-18 20:50:27 +01:00
#define TermPipe MkAtomTerm( Yap_heap_regs->AtomPipe_ )
Atom AtomPlus_;
#define AtomPlus Yap_heap_regs->AtomPlus_
2015-08-18 20:50:27 +01:00
#define TermPlus MkAtomTerm( Yap_heap_regs->AtomPlus_ )
Atom AtomPointer_;
#define AtomPointer Yap_heap_regs->AtomPointer_
2015-08-18 20:50:27 +01:00
#define TermPointer MkAtomTerm( Yap_heap_regs->AtomPointer_ )
Atom AtomPortray_;
#define AtomPortray Yap_heap_regs->AtomPortray_
2015-08-18 20:50:27 +01:00
#define TermPortray MkAtomTerm( Yap_heap_regs->AtomPortray_ )
Atom AtomPredicateIndicator_;
#define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_
2015-08-18 20:50:27 +01:00
#define TermPredicateIndicator MkAtomTerm( Yap_heap_regs->AtomPredicateIndicator_ )
Atom AtomPrimitive_;
#define AtomPrimitive Yap_heap_regs->AtomPrimitive_
2015-08-18 20:50:27 +01:00
#define TermPrimitive MkAtomTerm( Yap_heap_regs->AtomPrimitive_ )
2013-11-21 00:22:03 +00:00
Atom AtomPrintMessage_;
#define AtomPrintMessage Yap_heap_regs->AtomPrintMessage_
2015-08-18 20:50:27 +01:00
#define TermPrintMessage MkAtomTerm( Yap_heap_regs->AtomPrintMessage_ )
Atom AtomPrivateProcedure_;
#define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_
2015-08-18 20:50:27 +01:00
#define TermPrivateProcedure MkAtomTerm( Yap_heap_regs->AtomPrivateProcedure_ )
Atom AtomProcedure_;
#define AtomProcedure Yap_heap_regs->AtomProcedure_
2015-08-18 20:50:27 +01:00
#define TermProcedure MkAtomTerm( Yap_heap_regs->AtomProcedure_ )
Atom AtomProfile_;
#define AtomProfile Yap_heap_regs->AtomProfile_
2015-08-18 20:50:27 +01:00
#define TermProfile MkAtomTerm( Yap_heap_regs->AtomProfile_ )
Atom AtomProlog_;
#define AtomProlog Yap_heap_regs->AtomProlog_
2015-08-18 20:50:27 +01:00
#define TermProlog MkAtomTerm( Yap_heap_regs->AtomProlog_ )
2015-09-21 23:05:36 +01:00
Atom AtomQly_;
#define AtomQly Yap_heap_regs->AtomQly_
#define TermQly MkAtomTerm( Yap_heap_regs->AtomQly_ )
Atom AtomQuery_;
#define AtomQuery Yap_heap_regs->AtomQuery_
2015-08-18 20:50:27 +01:00
#define TermQuery MkAtomTerm( Yap_heap_regs->AtomQuery_ )
Atom AtomQueue_;
#define AtomQueue Yap_heap_regs->AtomQueue_
2015-08-18 20:50:27 +01:00
#define TermQueue MkAtomTerm( Yap_heap_regs->AtomQueue_ )
Atom AtomQuiet_;
#define AtomQuiet Yap_heap_regs->AtomQuiet_
2015-08-18 20:50:27 +01:00
#define TermQuiet MkAtomTerm( Yap_heap_regs->AtomQuiet_ )
Atom AtomRadix_;
#define AtomRadix Yap_heap_regs->AtomRadix_
2015-08-18 20:50:27 +01:00
#define TermRadix MkAtomTerm( Yap_heap_regs->AtomRadix_ )
Atom AtomRandom_;
#define AtomRandom Yap_heap_regs->AtomRandom_
2015-08-18 20:50:27 +01:00
#define TermRandom MkAtomTerm( Yap_heap_regs->AtomRandom_ )
2012-10-23 14:55:44 +01:00
Atom AtomRange_;
#define AtomRange Yap_heap_regs->AtomRange_
2015-08-18 20:50:27 +01:00
#define TermRange MkAtomTerm( Yap_heap_regs->AtomRange_ )
Atom AtomRDiv_;
#define AtomRDiv Yap_heap_regs->AtomRDiv_
2015-08-18 20:50:27 +01:00
#define TermRDiv MkAtomTerm( Yap_heap_regs->AtomRDiv_ )
Atom AtomRead_;
#define AtomRead Yap_heap_regs->AtomRead_
2015-08-18 20:50:27 +01:00
#define TermRead MkAtomTerm( Yap_heap_regs->AtomRead_ )
Atom AtomReadOnly_;
#define AtomReadOnly Yap_heap_regs->AtomReadOnly_
2015-08-18 20:50:27 +01:00
#define TermReadOnly MkAtomTerm( Yap_heap_regs->AtomReadOnly_ )
Atom AtomReadWrite_;
#define AtomReadWrite Yap_heap_regs->AtomReadWrite_
2015-08-18 20:50:27 +01:00
#define TermReadWrite MkAtomTerm( Yap_heap_regs->AtomReadWrite_ )
Atom AtomReadutil_;
#define AtomReadutil Yap_heap_regs->AtomReadutil_
2015-08-18 20:50:27 +01:00
#define TermReadutil MkAtomTerm( Yap_heap_regs->AtomReadutil_ )
Atom AtomReconsult_;
#define AtomReconsult Yap_heap_regs->AtomReconsult_
#define TermReconsult MkAtomTerm( Yap_heap_regs->AtomReconsult_ )
Atom AtomRecordedP_;
#define AtomRecordedP Yap_heap_regs->AtomRecordedP_
2015-08-18 20:50:27 +01:00
#define TermRecordedP MkAtomTerm( Yap_heap_regs->AtomRecordedP_ )
Atom AtomRecordedWithKey_;
#define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_
2015-08-18 20:50:27 +01:00
#define TermRecordedWithKey MkAtomTerm( Yap_heap_regs->AtomRecordedWithKey_ )
Atom AtomRedefineWarnings_;
#define AtomRedefineWarnings Yap_heap_regs->AtomRedefineWarnings_
2015-08-18 20:50:27 +01:00
#define TermRedefineWarnings MkAtomTerm( Yap_heap_regs->AtomRedefineWarnings_ )
2009-06-06 00:45:41 +01:00
Atom AtomRedoFreeze_;
#define AtomRedoFreeze Yap_heap_regs->AtomRedoFreeze_
2015-08-18 20:50:27 +01:00
#define TermRedoFreeze MkAtomTerm( Yap_heap_regs->AtomRedoFreeze_ )
Atom AtomRefoundVar_;
#define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_
2015-08-18 20:50:27 +01:00
#define TermRefoundVar MkAtomTerm( Yap_heap_regs->AtomRefoundVar_ )
2015-09-21 23:05:36 +01:00
Atom AtomRelativeTo_;
#define AtomRelativeTo Yap_heap_regs->AtomRelativeTo_
#define TermRelativeTo MkAtomTerm( Yap_heap_regs->AtomRelativeTo_ )
Atom AtomRepeat_;
#define AtomRepeat Yap_heap_regs->AtomRepeat_
2015-08-18 20:50:27 +01:00
#define TermRepeat MkAtomTerm( Yap_heap_regs->AtomRepeat_ )
Atom AtomRepeatSpace_;
#define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_
2015-08-18 20:50:27 +01:00
#define TermRepeatSpace MkAtomTerm( Yap_heap_regs->AtomRepeatSpace_ )
Atom AtomReposition_;
#define AtomReposition Yap_heap_regs->AtomReposition_
2015-08-18 20:50:27 +01:00
#define TermReposition MkAtomTerm( Yap_heap_regs->AtomReposition_ )
Atom AtomRepresentationError_;
#define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_
2015-08-18 20:50:27 +01:00
#define TermRepresentationError MkAtomTerm( Yap_heap_regs->AtomRepresentationError_ )
Atom AtomReset_;
#define AtomReset Yap_heap_regs->AtomReset_
2015-08-18 20:50:27 +01:00
#define TermReset MkAtomTerm( Yap_heap_regs->AtomReset_ )
Atom AtomResize_;
#define AtomResize Yap_heap_regs->AtomResize_
2015-08-18 20:50:27 +01:00
#define TermResize MkAtomTerm( Yap_heap_regs->AtomResize_ )
Atom AtomResourceError_;
#define AtomResourceError Yap_heap_regs->AtomResourceError_
2015-08-18 20:50:27 +01:00
#define TermResourceError MkAtomTerm( Yap_heap_regs->AtomResourceError_ )
Atom AtomRestoreRegs_;
#define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_
2015-08-18 20:50:27 +01:00
#define TermRestoreRegs MkAtomTerm( Yap_heap_regs->AtomRestoreRegs_ )
Atom AtomRetryCounter_;
#define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_
2015-08-18 20:50:27 +01:00
#define TermRetryCounter MkAtomTerm( Yap_heap_regs->AtomRetryCounter_ )
Atom AtomRTree_;
#define AtomRTree Yap_heap_regs->AtomRTree_
2015-08-18 20:50:27 +01:00
#define TermRTree MkAtomTerm( Yap_heap_regs->AtomRTree_ )
Atom AtomSafe_;
#define AtomSafe Yap_heap_regs->AtomSafe_
2015-08-18 20:50:27 +01:00
#define TermSafe MkAtomTerm( Yap_heap_regs->AtomSafe_ )
Atom AtomSafeCallCleanup_;
#define AtomSafeCallCleanup Yap_heap_regs->AtomSafeCallCleanup_
2015-08-18 20:50:27 +01:00
#define TermSafeCallCleanup MkAtomTerm( Yap_heap_regs->AtomSafeCallCleanup_ )
Atom AtomSame_;
#define AtomSame Yap_heap_regs->AtomSame_
2015-08-18 20:50:27 +01:00
#define TermSame MkAtomTerm( Yap_heap_regs->AtomSame_ )
Atom AtomSemic_;
#define AtomSemic Yap_heap_regs->AtomSemic_
2015-08-18 20:50:27 +01:00
#define TermSemic MkAtomTerm( Yap_heap_regs->AtomSemic_ )
Atom AtomShiftCountOverflow_;
#define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_
2015-08-18 20:50:27 +01:00
#define TermShiftCountOverflow MkAtomTerm( Yap_heap_regs->AtomShiftCountOverflow_ )
Atom AtomSigAlarm_;
#define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_
2015-08-18 20:50:27 +01:00
#define TermSigAlarm MkAtomTerm( Yap_heap_regs->AtomSigAlarm_ )
Atom AtomSigBreak_;
#define AtomSigBreak Yap_heap_regs->AtomSigBreak_
2015-08-18 20:50:27 +01:00
#define TermSigBreak MkAtomTerm( Yap_heap_regs->AtomSigBreak_ )
Atom AtomSigCreep_;
#define AtomSigCreep Yap_heap_regs->AtomSigCreep_
2015-08-18 20:50:27 +01:00
#define TermSigCreep MkAtomTerm( Yap_heap_regs->AtomSigCreep_ )
Atom AtomSigDebug_;
#define AtomSigDebug Yap_heap_regs->AtomSigDebug_
2015-08-18 20:50:27 +01:00
#define TermSigDebug MkAtomTerm( Yap_heap_regs->AtomSigDebug_ )
Atom AtomSigDelayCreep_;
#define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_
2015-08-18 20:50:27 +01:00
#define TermSigDelayCreep MkAtomTerm( Yap_heap_regs->AtomSigDelayCreep_ )
Atom AtomSigFPE_;
#define AtomSigFPE Yap_heap_regs->AtomSigFPE_
2015-08-18 20:50:27 +01:00
#define TermSigFPE MkAtomTerm( Yap_heap_regs->AtomSigFPE_ )
Atom AtomSigHup_;
#define AtomSigHup Yap_heap_regs->AtomSigHup_
2015-08-18 20:50:27 +01:00
#define TermSigHup MkAtomTerm( Yap_heap_regs->AtomSigHup_ )
Atom AtomSigInt_;
#define AtomSigInt Yap_heap_regs->AtomSigInt_
2015-08-18 20:50:27 +01:00
#define TermSigInt MkAtomTerm( Yap_heap_regs->AtomSigInt_ )
Atom AtomSigIti_;
#define AtomSigIti Yap_heap_regs->AtomSigIti_
2015-08-18 20:50:27 +01:00
#define TermSigIti MkAtomTerm( Yap_heap_regs->AtomSigIti_ )
Atom AtomSigPending_;
#define AtomSigPending Yap_heap_regs->AtomSigPending_
2015-08-18 20:50:27 +01:00
#define TermSigPending MkAtomTerm( Yap_heap_regs->AtomSigPending_ )
Atom AtomSigPipe_;
#define AtomSigPipe Yap_heap_regs->AtomSigPipe_
2015-08-18 20:50:27 +01:00
#define TermSigPipe MkAtomTerm( Yap_heap_regs->AtomSigPipe_ )
Atom AtomSigStackDump_;
#define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_
2015-08-18 20:50:27 +01:00
#define TermSigStackDump MkAtomTerm( Yap_heap_regs->AtomSigStackDump_ )
Atom AtomSigStatistics_;
#define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_
2015-08-18 20:50:27 +01:00
#define TermSigStatistics MkAtomTerm( Yap_heap_regs->AtomSigStatistics_ )
Atom AtomSigTrace_;
#define AtomSigTrace Yap_heap_regs->AtomSigTrace_
2015-08-18 20:50:27 +01:00
#define TermSigTrace MkAtomTerm( Yap_heap_regs->AtomSigTrace_ )
Atom AtomSigUsr1_;
#define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_
2015-08-18 20:50:27 +01:00
#define TermSigUsr1 MkAtomTerm( Yap_heap_regs->AtomSigUsr1_ )
Atom AtomSigUsr2_;
#define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_
2015-08-18 20:50:27 +01:00
#define TermSigUsr2 MkAtomTerm( Yap_heap_regs->AtomSigUsr2_ )
Atom AtomSigVTAlarm_;
#define AtomSigVTAlarm Yap_heap_regs->AtomSigVTAlarm_
2015-08-18 20:50:27 +01:00
#define TermSigVTAlarm MkAtomTerm( Yap_heap_regs->AtomSigVTAlarm_ )
Atom AtomSigWakeUp_;
#define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_
2015-08-18 20:50:27 +01:00
#define TermSigWakeUp MkAtomTerm( Yap_heap_regs->AtomSigWakeUp_ )
Atom AtomSilent_;
#define AtomSilent Yap_heap_regs->AtomSilent_
2015-08-18 20:50:27 +01:00
#define TermSilent MkAtomTerm( Yap_heap_regs->AtomSilent_ )
Atom AtomSingle_;
#define AtomSingle Yap_heap_regs->AtomSingle_
2015-08-18 20:50:27 +01:00
#define TermSingle MkAtomTerm( Yap_heap_regs->AtomSingle_ )
Atom AtomSingleVarWarnings_;
#define AtomSingleVarWarnings Yap_heap_regs->AtomSingleVarWarnings_
2015-08-18 20:50:27 +01:00
#define TermSingleVarWarnings MkAtomTerm( Yap_heap_regs->AtomSingleVarWarnings_ )
Atom AtomSingleton_;
#define AtomSingleton Yap_heap_regs->AtomSingleton_
2015-08-18 20:50:27 +01:00
#define TermSingleton MkAtomTerm( Yap_heap_regs->AtomSingleton_ )
Atom AtomSlash_;
#define AtomSlash Yap_heap_regs->AtomSlash_
2015-08-18 20:50:27 +01:00
#define TermSlash MkAtomTerm( Yap_heap_regs->AtomSlash_ )
Atom AtomSocket_;
#define AtomSocket Yap_heap_regs->AtomSocket_
2015-08-18 20:50:27 +01:00
#define TermSocket MkAtomTerm( Yap_heap_regs->AtomSocket_ )
2015-09-21 23:05:36 +01:00
Atom AtomSolutions_;
#define AtomSolutions Yap_heap_regs->AtomSolutions_
#define TermSolutions MkAtomTerm( Yap_heap_regs->AtomSolutions_ )
Atom AtomSource_;
#define AtomSource Yap_heap_regs->AtomSource_
2015-08-18 20:50:27 +01:00
#define TermSource MkAtomTerm( Yap_heap_regs->AtomSource_ )
Atom AtomSourceSink_;
#define AtomSourceSink Yap_heap_regs->AtomSourceSink_
2015-08-18 20:50:27 +01:00
#define TermSourceSink MkAtomTerm( Yap_heap_regs->AtomSourceSink_ )
Atom AtomSpy_;
#define AtomSpy Yap_heap_regs->AtomSpy_
2015-08-18 20:50:27 +01:00
#define TermSpy MkAtomTerm( Yap_heap_regs->AtomSpy_ )
Atom AtomStack_;
#define AtomStack Yap_heap_regs->AtomStack_
2015-08-18 20:50:27 +01:00
#define TermStack MkAtomTerm( Yap_heap_regs->AtomStack_ )
Atom AtomStackFree_;
#define AtomStackFree Yap_heap_regs->AtomStackFree_
2015-08-18 20:50:27 +01:00
#define TermStackFree MkAtomTerm( Yap_heap_regs->AtomStackFree_ )
Atom AtomStartupSavedState_;
#define AtomStartupSavedState Yap_heap_regs->AtomStartupSavedState_
2015-08-18 20:50:27 +01:00
#define TermStartupSavedState MkAtomTerm( Yap_heap_regs->AtomStartupSavedState_ )
Atom AtomStaticClause_;
#define AtomStaticClause Yap_heap_regs->AtomStaticClause_
2015-08-18 20:50:27 +01:00
#define TermStaticClause MkAtomTerm( Yap_heap_regs->AtomStaticClause_ )
Atom AtomStaticProcedure_;
#define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_
2015-08-18 20:50:27 +01:00
#define TermStaticProcedure MkAtomTerm( Yap_heap_regs->AtomStaticProcedure_ )
Atom AtomStream_;
#define AtomStream Yap_heap_regs->AtomStream_
2015-08-18 20:50:27 +01:00
#define TermStream MkAtomTerm( Yap_heap_regs->AtomStream_ )
2012-02-27 08:53:18 +00:00
Atom AtomSWIStream_;
#define AtomSWIStream Yap_heap_regs->AtomSWIStream_
2015-08-18 20:50:27 +01:00
#define TermSWIStream MkAtomTerm( Yap_heap_regs->AtomSWIStream_ )
2010-02-26 10:59:43 +00:00
Atom AtomVStream_;
#define AtomVStream Yap_heap_regs->AtomVStream_
2015-08-18 20:50:27 +01:00
#define TermVStream MkAtomTerm( Yap_heap_regs->AtomVStream_ )
Atom AtomStreams_;
#define AtomStreams Yap_heap_regs->AtomStreams_
2015-08-18 20:50:27 +01:00
#define TermStreams MkAtomTerm( Yap_heap_regs->AtomStreams_ )
Atom AtomStreamOrAlias_;
#define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_
2015-08-18 20:50:27 +01:00
#define TermStreamOrAlias MkAtomTerm( Yap_heap_regs->AtomStreamOrAlias_ )
Atom AtomStreamPos_;
#define AtomStreamPos Yap_heap_regs->AtomStreamPos_
2015-08-18 20:50:27 +01:00
#define TermStreamPos MkAtomTerm( Yap_heap_regs->AtomStreamPos_ )
Atom AtomStreamPosition_;
#define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_
2015-08-18 20:50:27 +01:00
#define TermStreamPosition MkAtomTerm( Yap_heap_regs->AtomStreamPosition_ )
Atom AtomString_;
#define AtomString Yap_heap_regs->AtomString_
2015-08-18 20:50:27 +01:00
#define TermString MkAtomTerm( Yap_heap_regs->AtomString_ )
2015-09-21 23:05:36 +01:00
Atom AtomStyleCheck_;
#define AtomStyleCheck Yap_heap_regs->AtomStyleCheck_
#define TermStyleCheck MkAtomTerm( Yap_heap_regs->AtomStyleCheck_ )
Atom AtomSTRING_;
#define AtomSTRING Yap_heap_regs->AtomSTRING_
2015-08-18 20:50:27 +01:00
#define TermSTRING MkAtomTerm( Yap_heap_regs->AtomSTRING_ )
Atom AtomSwi_;
#define AtomSwi Yap_heap_regs->AtomSwi_
2015-08-18 20:50:27 +01:00
#define TermSwi MkAtomTerm( Yap_heap_regs->AtomSwi_ )
Atom AtomSymbolChar_;
#define AtomSymbolChar Yap_heap_regs->AtomSymbolChar_
2015-08-18 20:50:27 +01:00
#define TermSymbolChar MkAtomTerm( Yap_heap_regs->AtomSymbolChar_ )
Atom AtomSyntaxError_;
#define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_
2015-08-18 20:50:27 +01:00
#define TermSyntaxError MkAtomTerm( Yap_heap_regs->AtomSyntaxError_ )
2015-07-06 12:01:55 +01:00
Atom AtomSyntaxErrors_;
#define AtomSyntaxErrors Yap_heap_regs->AtomSyntaxErrors_
2015-08-18 20:50:27 +01:00
#define TermSyntaxErrors MkAtomTerm( Yap_heap_regs->AtomSyntaxErrors_ )
Atom AtomSyntaxErrorHandler_;
#define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_
2015-08-18 20:50:27 +01:00
#define TermSyntaxErrorHandler MkAtomTerm( Yap_heap_regs->AtomSyntaxErrorHandler_ )
Atom AtomSystem_;
#define AtomSystem Yap_heap_regs->AtomSystem_
2015-08-18 20:50:27 +01:00
#define TermSystem MkAtomTerm( Yap_heap_regs->AtomSystem_ )
Atom AtomSystemError_;
#define AtomSystemError Yap_heap_regs->AtomSystemError_
2015-08-18 20:50:27 +01:00
#define TermSystemError MkAtomTerm( Yap_heap_regs->AtomSystemError_ )
Atom AtomSystemLibraryDir_;
#define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_
2015-08-18 20:50:27 +01:00
#define TermSystemLibraryDir MkAtomTerm( Yap_heap_regs->AtomSystemLibraryDir_ )
Atom AtomTerm_;
#define AtomTerm Yap_heap_regs->AtomTerm_
2015-08-18 20:50:27 +01:00
#define TermTerm MkAtomTerm( Yap_heap_regs->AtomTerm_ )
Atom AtomTerms_;
#define AtomTerms Yap_heap_regs->AtomTerms_
2015-08-18 20:50:27 +01:00
#define TermTerms MkAtomTerm( Yap_heap_regs->AtomTerms_ )
Atom AtomTermExpansion_;
#define AtomTermExpansion Yap_heap_regs->AtomTermExpansion_
2015-08-18 20:50:27 +01:00
#define TermTermExpansion MkAtomTerm( Yap_heap_regs->AtomTermExpansion_ )
2013-12-08 19:12:24 +00:00
Atom AtomText_;
#define AtomText Yap_heap_regs->AtomText_
2015-08-18 20:50:27 +01:00
#define TermText MkAtomTerm( Yap_heap_regs->AtomText_ )
Atom AtomTextStream_;
#define AtomTextStream Yap_heap_regs->AtomTextStream_
2015-08-18 20:50:27 +01:00
#define TermTextStream MkAtomTerm( Yap_heap_regs->AtomTextStream_ )
Atom AtomThread_;
#define AtomThread Yap_heap_regs->AtomThread_
2015-08-18 20:50:27 +01:00
#define TermThread MkAtomTerm( Yap_heap_regs->AtomThread_ )
Atom AtomThreads_;
#define AtomThreads Yap_heap_regs->AtomThreads_
2015-08-18 20:50:27 +01:00
#define TermThreads MkAtomTerm( Yap_heap_regs->AtomThreads_ )
Atom AtomThrow_;
#define AtomThrow Yap_heap_regs->AtomThrow_
2015-08-18 20:50:27 +01:00
#define TermThrow MkAtomTerm( Yap_heap_regs->AtomThrow_ )
Atom AtomTimeOutSpec_;
#define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_
2015-08-18 20:50:27 +01:00
#define TermTimeOutSpec MkAtomTerm( Yap_heap_regs->AtomTimeOutSpec_ )
Atom AtomTimeoutError_;
#define AtomTimeoutError Yap_heap_regs->AtomTimeoutError_
2015-08-18 20:50:27 +01:00
#define TermTimeoutError MkAtomTerm( Yap_heap_regs->AtomTimeoutError_ )
Atom AtomTopLevelGoal_;
#define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_
2015-08-18 20:50:27 +01:00
#define TermTopLevelGoal MkAtomTerm( Yap_heap_regs->AtomTopLevelGoal_ )
Atom AtomTopThreadGoal_;
#define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_
2015-08-18 20:50:27 +01:00
#define TermTopThreadGoal MkAtomTerm( Yap_heap_regs->AtomTopThreadGoal_ )
2015-07-23 01:19:35 +01:00
Atom AtomTraceMetaCall_;
#define AtomTraceMetaCall Yap_heap_regs->AtomTraceMetaCall_
2015-08-18 20:50:27 +01:00
#define TermTraceMetaCall MkAtomTerm( Yap_heap_regs->AtomTraceMetaCall_ )
Atom AtomTrail_;
#define AtomTrail Yap_heap_regs->AtomTrail_
2015-08-18 20:50:27 +01:00
#define TermTrail MkAtomTerm( Yap_heap_regs->AtomTrail_ )
Atom AtomTrue_;
#define AtomTrue Yap_heap_regs->AtomTrue_
2015-08-18 20:50:27 +01:00
#define TermTrue MkAtomTerm( Yap_heap_regs->AtomTrue_ )
Atom AtomTty_;
#define AtomTty Yap_heap_regs->AtomTty_
2015-08-18 20:50:27 +01:00
#define TermTty MkAtomTerm( Yap_heap_regs->AtomTty_ )
Atom AtomTtys_;
#define AtomTtys Yap_heap_regs->AtomTtys_
2015-08-18 20:50:27 +01:00
#define TermTtys MkAtomTerm( Yap_heap_regs->AtomTtys_ )
2015-09-21 23:05:36 +01:00
Atom AtomTxt_;
#define AtomTxt Yap_heap_regs->AtomTxt_
#define TermTxt MkAtomTerm( Yap_heap_regs->AtomTxt_ )
Atom AtomTypeError_;
#define AtomTypeError Yap_heap_regs->AtomTypeError_
2015-08-18 20:50:27 +01:00
#define TermTypeError MkAtomTerm( Yap_heap_regs->AtomTypeError_ )
Atom AtomUndefined_;
#define AtomUndefined Yap_heap_regs->AtomUndefined_
2015-08-18 20:50:27 +01:00
#define TermUndefined MkAtomTerm( Yap_heap_regs->AtomUndefined_ )
Atom AtomUndefp_;
#define AtomUndefp Yap_heap_regs->AtomUndefp_
2015-08-18 20:50:27 +01:00
#define TermUndefp MkAtomTerm( Yap_heap_regs->AtomUndefp_ )
Atom AtomUnderflow_;
#define AtomUnderflow Yap_heap_regs->AtomUnderflow_
2015-08-18 20:50:27 +01:00
#define TermUnderflow MkAtomTerm( Yap_heap_regs->AtomUnderflow_ )
Atom AtomUnificationStack_;
#define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_
2015-08-18 20:50:27 +01:00
#define TermUnificationStack MkAtomTerm( Yap_heap_regs->AtomUnificationStack_ )
2013-04-29 17:58:05 +01:00
Atom AtomUnique_;
#define AtomUnique Yap_heap_regs->AtomUnique_
2015-08-18 20:50:27 +01:00
#define TermUnique MkAtomTerm( Yap_heap_regs->AtomUnique_ )
Atom AtomUnsignedByte_;
#define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_
2015-08-18 20:50:27 +01:00
#define TermUnsignedByte MkAtomTerm( Yap_heap_regs->AtomUnsignedByte_ )
Atom AtomUnsignedChar_;
#define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_
2015-08-18 20:50:27 +01:00
#define TermUnsignedChar MkAtomTerm( Yap_heap_regs->AtomUnsignedChar_ )
Atom AtomUser_;
#define AtomUser Yap_heap_regs->AtomUser_
2015-08-18 20:50:27 +01:00
#define TermUser MkAtomTerm( Yap_heap_regs->AtomUser_ )
Atom AtomUserErr_;
#define AtomUserErr Yap_heap_regs->AtomUserErr_
2015-08-18 20:50:27 +01:00
#define TermUserErr MkAtomTerm( Yap_heap_regs->AtomUserErr_ )
Atom AtomUserIn_;
#define AtomUserIn Yap_heap_regs->AtomUserIn_
2015-08-18 20:50:27 +01:00
#define TermUserIn MkAtomTerm( Yap_heap_regs->AtomUserIn_ )
Atom AtomUserOut_;
#define AtomUserOut Yap_heap_regs->AtomUserOut_
2015-08-18 20:50:27 +01:00
#define TermUserOut MkAtomTerm( Yap_heap_regs->AtomUserOut_ )
Atom AtomDollarVar_;
#define AtomDollarVar Yap_heap_regs->AtomDollarVar_
#define TermDollarVar MkAtomTerm( Yap_heap_regs->AtomDollarVar_ )
Atom AtomVBar_;
#define AtomVBar Yap_heap_regs->AtomVBar_
2015-08-18 20:50:27 +01:00
#define TermVBar MkAtomTerm( Yap_heap_regs->AtomVBar_ )
Atom AtomVarBranches_;
#define AtomVarBranches Yap_heap_regs->AtomVarBranches_
2015-08-18 20:50:27 +01:00
#define TermVarBranches MkAtomTerm( Yap_heap_regs->AtomVarBranches_ )
Atom AtomVariableNames_;
#define AtomVariableNames Yap_heap_regs->AtomVariableNames_
2015-08-18 20:50:27 +01:00
#define TermVariableNames MkAtomTerm( Yap_heap_regs->AtomVariableNames_ )
2012-03-15 22:19:48 +00:00
Atom AtomHiddenVar_;
#define AtomHiddenVar Yap_heap_regs->AtomHiddenVar_
2015-08-18 20:50:27 +01:00
#define TermHiddenVar MkAtomTerm( Yap_heap_regs->AtomHiddenVar_ )
Atom AtomVariable_;
#define AtomVariable Yap_heap_regs->AtomVariable_
2015-08-18 20:50:27 +01:00
#define TermVariable MkAtomTerm( Yap_heap_regs->AtomVariable_ )
2016-01-06 12:38:28 +00:00
Atom AtomVerbose_;
#define AtomVerbose Yap_heap_regs->AtomVerbose_
#define TermVerbose MkAtomTerm( Yap_heap_regs->AtomVerbose_ )
2015-09-21 23:05:36 +01:00
Atom AtomVerboseFileSearch_;
#define AtomVerboseFileSearch Yap_heap_regs->AtomVerboseFileSearch_
#define TermVerboseFileSearch MkAtomTerm( Yap_heap_regs->AtomVerboseFileSearch_ )
Atom AtomVersionNumber_;
#define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_
2015-08-18 20:50:27 +01:00
#define TermVersionNumber MkAtomTerm( Yap_heap_regs->AtomVersionNumber_ )
2016-01-06 12:38:28 +00:00
Atom AtomVeryVerbose_;
#define AtomVeryVerbose Yap_heap_regs->AtomVeryVerbose_
#define TermVeryVerbose MkAtomTerm( Yap_heap_regs->AtomVeryVerbose_ )
Atom AtomWakeUpGoal_;
#define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_
2015-08-18 20:50:27 +01:00
#define TermWakeUpGoal MkAtomTerm( Yap_heap_regs->AtomWakeUpGoal_ )
Atom AtomWarning_;
#define AtomWarning Yap_heap_regs->AtomWarning_
2015-08-18 20:50:27 +01:00
#define TermWarning MkAtomTerm( Yap_heap_regs->AtomWarning_ )
Atom AtomWhen_;
#define AtomWhen Yap_heap_regs->AtomWhen_
2015-08-18 20:50:27 +01:00
#define TermWhen MkAtomTerm( Yap_heap_regs->AtomWhen_ )
Atom AtomWrite_;
#define AtomWrite Yap_heap_regs->AtomWrite_
2015-08-18 20:50:27 +01:00
#define TermWrite MkAtomTerm( Yap_heap_regs->AtomWrite_ )
Atom AtomXml_;
#define AtomXml Yap_heap_regs->AtomXml_
2015-08-18 20:50:27 +01:00
#define TermXml MkAtomTerm( Yap_heap_regs->AtomXml_ )
Atom AtomYapHacks_;
#define AtomYapHacks Yap_heap_regs->AtomYapHacks_
2015-08-18 20:50:27 +01:00
#define TermYapHacks MkAtomTerm( Yap_heap_regs->AtomYapHacks_ )
Atom AtomZeroDivisor_;
#define AtomZeroDivisor Yap_heap_regs->AtomZeroDivisor_
2015-08-18 20:50:27 +01:00
#define TermZeroDivisor MkAtomTerm( Yap_heap_regs->AtomZeroDivisor_ )
Functor FunctorAfInet_;
#define FunctorAfInet Yap_heap_regs->FunctorAfInet_
Functor FunctorAfLocal_;
#define FunctorAfLocal Yap_heap_regs->FunctorAfLocal_
Functor FunctorAfUnix_;
#define FunctorAfUnix Yap_heap_regs->FunctorAfUnix_
Functor FunctorAltNot_;
#define FunctorAltNot Yap_heap_regs->FunctorAltNot_
Functor FunctorArg_;
#define FunctorArg Yap_heap_regs->FunctorArg_
Functor FunctorArrayEntry_;
#define FunctorArrayEntry Yap_heap_regs->FunctorArrayEntry_
Functor FunctorArrow_;
#define FunctorArrow Yap_heap_regs->FunctorArrow_
Functor FunctorDoubleArrow_;
#define FunctorDoubleArrow Yap_heap_regs->FunctorDoubleArrow_
Functor FunctorAssert1_;
#define FunctorAssert1 Yap_heap_regs->FunctorAssert1_
Functor FunctorAssert_;
#define FunctorAssert Yap_heap_regs->FunctorAssert_
Functor FunctorAtFoundOne_;
#define FunctorAtFoundOne Yap_heap_regs->FunctorAtFoundOne_
Functor FunctorAtom_;
#define FunctorAtom Yap_heap_regs->FunctorAtom_
Functor FunctorAtt1_;
#define FunctorAtt1 Yap_heap_regs->FunctorAtt1_
Functor FunctorAttGoal_;
#define FunctorAttGoal Yap_heap_regs->FunctorAttGoal_
Functor FunctorBraces_;
#define FunctorBraces Yap_heap_regs->FunctorBraces_
Functor FunctorCall_;
#define FunctorCall Yap_heap_regs->FunctorCall_
2008-12-23 02:20:22 +00:00
Functor FunctorCatch_;
#define FunctorCatch Yap_heap_regs->FunctorCatch_
Functor FunctorChangeModule_;
#define FunctorChangeModule Yap_heap_regs->FunctorChangeModule_
Functor FunctorChars_;
#define FunctorChars Yap_heap_regs->FunctorChars_
Functor FunctorChars1_;
#define FunctorChars1 Yap_heap_regs->FunctorChars1_
2009-06-06 00:45:41 +01:00
Functor FunctorCleanCall_;
#define FunctorCleanCall Yap_heap_regs->FunctorCleanCall_
Functor FunctorClist_;
#define FunctorClist Yap_heap_regs->FunctorClist_
2010-07-19 14:48:42 +01:00
Functor FunctorCodes_;
#define FunctorCodes Yap_heap_regs->FunctorCodes_
Functor FunctorCodes1_;
#define FunctorCodes1 Yap_heap_regs->FunctorCodes1_
Functor FunctorComma_;
#define FunctorComma Yap_heap_regs->FunctorComma_
2013-12-08 22:56:48 +00:00
Functor FunctorCommentHook_;
#define FunctorCommentHook Yap_heap_regs->FunctorCommentHook_
Functor FunctorContext2_;
#define FunctorContext2 Yap_heap_regs->FunctorContext2_
2008-12-23 02:20:22 +00:00
Functor FunctorConsistencyError_;
#define FunctorConsistencyError Yap_heap_regs->FunctorConsistencyError_
Functor FunctorCreep_;
#define FunctorCreep Yap_heap_regs->FunctorCreep_
Functor FunctorCsult_;
#define FunctorCsult Yap_heap_regs->FunctorCsult_
Functor FunctorCurrentModule_;
#define FunctorCurrentModule Yap_heap_regs->FunctorCurrentModule_
Functor FunctorCutBy_;
#define FunctorCutBy Yap_heap_regs->FunctorCutBy_
2011-03-11 19:49:32 +00:00
Functor FunctorDBREF_;
#define FunctorDBREF Yap_heap_regs->FunctorDBREF_
Functor FunctorDiff_;
#define FunctorDiff Yap_heap_regs->FunctorDiff_
2008-12-23 02:20:22 +00:00
Functor FunctorDoLogUpdClause_;
#define FunctorDoLogUpdClause Yap_heap_regs->FunctorDoLogUpdClause_
Functor FunctorDoLogUpdClause0_;
#define FunctorDoLogUpdClause0 Yap_heap_regs->FunctorDoLogUpdClause0_
Functor FunctorDoLogUpdClauseErase_;
#define FunctorDoLogUpdClauseErase Yap_heap_regs->FunctorDoLogUpdClauseErase_
Functor FunctorDoStaticClause_;
#define FunctorDoStaticClause Yap_heap_regs->FunctorDoStaticClause_
Functor FunctorDollarVar_;
#define FunctorDollarVar Yap_heap_regs->FunctorDollarVar_
2008-12-23 02:20:22 +00:00
Functor FunctorDomainError_;
#define FunctorDomainError Yap_heap_regs->FunctorDomainError_
Functor FunctorDot_;
#define FunctorDot Yap_heap_regs->FunctorDot_
Functor FunctorDot10_;
#define FunctorDot10 Yap_heap_regs->FunctorDot10_
Functor FunctorDot11_;
#define FunctorDot11 Yap_heap_regs->FunctorDot11_
Functor FunctorDot12_;
#define FunctorDot12 Yap_heap_regs->FunctorDot12_
Functor FunctorDot2_;
#define FunctorDot2 Yap_heap_regs->FunctorDot2_
Functor FunctorDot3_;
#define FunctorDot3 Yap_heap_regs->FunctorDot3_
Functor FunctorDot4_;
#define FunctorDot4 Yap_heap_regs->FunctorDot4_
Functor FunctorDot5_;
#define FunctorDot5 Yap_heap_regs->FunctorDot5_
Functor FunctorDot6_;
#define FunctorDot6 Yap_heap_regs->FunctorDot6_
Functor FunctorDot7_;
#define FunctorDot7 Yap_heap_regs->FunctorDot7_
Functor FunctorDot8_;
#define FunctorDot8 Yap_heap_regs->FunctorDot8_
Functor FunctorDot9_;
#define FunctorDot9 Yap_heap_regs->FunctorDot9_
2016-01-03 15:40:49 +00:00
Functor FunctorDoubleSlash_;
#define FunctorDoubleSlash Yap_heap_regs->FunctorDoubleSlash_
2013-09-13 11:44:26 +01:00
Functor FunctorEmptySquareBrackets_;
#define FunctorEmptySquareBrackets Yap_heap_regs->FunctorEmptySquareBrackets_
Functor FunctorEmptyCurlyBrackets_;
#define FunctorEmptyCurlyBrackets Yap_heap_regs->FunctorEmptyCurlyBrackets_
Functor FunctorEq_;
#define FunctorEq Yap_heap_regs->FunctorEq_
Functor FunctorError_;
#define FunctorError Yap_heap_regs->FunctorError_
2008-12-23 02:20:22 +00:00
Functor FunctorEvaluationError_;
#define FunctorEvaluationError Yap_heap_regs->FunctorEvaluationError_
Functor FunctorExecute2InMod_;
#define FunctorExecute2InMod Yap_heap_regs->FunctorExecute2InMod_
Functor FunctorExecuteInMod_;
#define FunctorExecuteInMod Yap_heap_regs->FunctorExecuteInMod_
Functor FunctorExecuteWithin_;
#define FunctorExecuteWithin Yap_heap_regs->FunctorExecuteWithin_
2008-12-23 02:20:22 +00:00
Functor FunctorExistenceError_;
#define FunctorExistenceError Yap_heap_regs->FunctorExistenceError_
2013-01-11 16:45:14 +00:00
Functor FunctorExoClause_;
#define FunctorExoClause Yap_heap_regs->FunctorExoClause_
Functor FunctorFunctor_;
#define FunctorFunctor Yap_heap_regs->FunctorFunctor_
Functor FunctorGAtom_;
#define FunctorGAtom Yap_heap_regs->FunctorGAtom_
Functor FunctorGAtomic_;
#define FunctorGAtomic Yap_heap_regs->FunctorGAtomic_
Functor FunctorGCompound_;
#define FunctorGCompound Yap_heap_regs->FunctorGCompound_
Functor FunctorGFloat_;
#define FunctorGFloat Yap_heap_regs->FunctorGFloat_
Functor FunctorGFormatAt_;
#define FunctorGFormatAt Yap_heap_regs->FunctorGFormatAt_
Functor FunctorGInteger_;
#define FunctorGInteger Yap_heap_regs->FunctorGInteger_
Functor FunctorGNumber_;
#define FunctorGNumber Yap_heap_regs->FunctorGNumber_
Functor FunctorGPrimitive_;
#define FunctorGPrimitive Yap_heap_regs->FunctorGPrimitive_
Functor FunctorGVar_;
#define FunctorGVar Yap_heap_regs->FunctorGVar_
Functor FunctorGeneratePredInfo_;
#define FunctorGeneratePredInfo Yap_heap_regs->FunctorGeneratePredInfo_
Functor FunctorGoalExpansion2_;
#define FunctorGoalExpansion2 Yap_heap_regs->FunctorGoalExpansion2_
2008-12-23 02:20:22 +00:00
Functor FunctorGoalExpansion_;
#define FunctorGoalExpansion Yap_heap_regs->FunctorGoalExpansion_
Functor FunctorHandleThrow_;
#define FunctorHandleThrow Yap_heap_regs->FunctorHandleThrow_
Functor FunctorHat_;
#define FunctorHat Yap_heap_regs->FunctorHat_
Functor FunctorId_;
#define FunctorId Yap_heap_regs->FunctorId_
Functor FunctorIs_;
#define FunctorIs Yap_heap_regs->FunctorIs_
Functor FunctorLastExecuteWithin_;
#define FunctorLastExecuteWithin Yap_heap_regs->FunctorLastExecuteWithin_
Functor FunctorList_;
#define FunctorList Yap_heap_regs->FunctorList_
Functor FunctorLOOP_;
#define FunctorLOOP Yap_heap_regs->FunctorLOOP_
Functor FunctorMegaClause_;
#define FunctorMegaClause Yap_heap_regs->FunctorMegaClause_
2008-12-23 02:20:22 +00:00
Functor FunctorMetaCall_;
#define FunctorMetaCall Yap_heap_regs->FunctorMetaCall_
Functor FunctorMinus_;
#define FunctorMinus Yap_heap_regs->FunctorMinus_
Functor FunctorModule_;
#define FunctorModule Yap_heap_regs->FunctorModule_
Functor FunctorMultiFileClause_;
#define FunctorMultiFileClause Yap_heap_regs->FunctorMultiFileClause_
Functor FunctorMutable_;
#define FunctorMutable Yap_heap_regs->FunctorMutable_
2014-11-27 10:02:04 +00:00
Functor FunctorMutex_;
#define FunctorMutex Yap_heap_regs->FunctorMutex_
Functor FunctorNotImplemented_;
#define FunctorNotImplemented Yap_heap_regs->FunctorNotImplemented_
Functor FunctorNBQueue_;
#define FunctorNBQueue Yap_heap_regs->FunctorNBQueue_
Functor FunctorNot_;
#define FunctorNot Yap_heap_regs->FunctorNot_
Functor FunctorOr_;
#define FunctorOr Yap_heap_regs->FunctorOr_
2008-12-23 02:20:22 +00:00
Functor FunctorPermissionError_;
#define FunctorPermissionError Yap_heap_regs->FunctorPermissionError_
2011-04-04 13:20:35 +01:00
Functor FunctorPlus_;
#define FunctorPlus Yap_heap_regs->FunctorPlus_
Functor FunctorPortray_;
#define FunctorPortray Yap_heap_regs->FunctorPortray_
2013-11-21 00:22:03 +00:00
Functor FunctorPrintMessage_;
#define FunctorPrintMessage Yap_heap_regs->FunctorPrintMessage_
2016-01-03 02:06:09 +00:00
Functor FunctorProcedure_;
#define FunctorProcedure Yap_heap_regs->FunctorProcedure_
2009-06-06 00:45:41 +01:00
Functor FunctorPrologConstraint_;
#define FunctorPrologConstraint Yap_heap_regs->FunctorPrologConstraint_
Functor FunctorQuery_;
#define FunctorQuery Yap_heap_regs->FunctorQuery_
2008-12-23 02:20:22 +00:00
Functor FunctorRecordedWithKey_;
#define FunctorRecordedWithKey Yap_heap_regs->FunctorRecordedWithKey_
Functor FunctorRDiv_;
#define FunctorRDiv Yap_heap_regs->FunctorRDiv_
2009-06-06 00:45:41 +01:00
Functor FunctorRedoFreeze_;
#define FunctorRedoFreeze Yap_heap_regs->FunctorRedoFreeze_
2008-12-23 02:20:22 +00:00
Functor FunctorRepresentationError_;
#define FunctorRepresentationError Yap_heap_regs->FunctorRepresentationError_
Functor FunctorResourceError_;
#define FunctorResourceError Yap_heap_regs->FunctorResourceError_
Functor FunctorRestoreRegs_;
#define FunctorRestoreRegs Yap_heap_regs->FunctorRestoreRegs_
Functor FunctorRestoreRegs1_;
#define FunctorRestoreRegs1 Yap_heap_regs->FunctorRestoreRegs1_
Functor FunctorSafe_;
#define FunctorSafe Yap_heap_regs->FunctorSafe_
Functor FunctorSafeCallCleanup_;
#define FunctorSafeCallCleanup Yap_heap_regs->FunctorSafeCallCleanup_
Functor FunctorSame_;
#define FunctorSame Yap_heap_regs->FunctorSame_
Functor FunctorSlash_;
#define FunctorSlash Yap_heap_regs->FunctorSlash_
Functor FunctorStaticClause_;
#define FunctorStaticClause Yap_heap_regs->FunctorStaticClause_
Functor FunctorStream_;
#define FunctorStream Yap_heap_regs->FunctorStream_
Functor FunctorStreamEOS_;
#define FunctorStreamEOS Yap_heap_regs->FunctorStreamEOS_
Functor FunctorStreamPos_;
#define FunctorStreamPos Yap_heap_regs->FunctorStreamPos_
Functor FunctorString1_;
#define FunctorString1 Yap_heap_regs->FunctorString1_
2015-09-21 23:05:36 +01:00
Functor FunctorStyleCheck_;
#define FunctorStyleCheck Yap_heap_regs->FunctorStyleCheck_
Functor FunctorSyntaxError_;
#define FunctorSyntaxError Yap_heap_regs->FunctorSyntaxError_
2010-02-26 13:30:16 +00:00
Functor FunctorShortSyntaxError_;
#define FunctorShortSyntaxError Yap_heap_regs->FunctorShortSyntaxError_
Functor FunctorTermExpansion_;
#define FunctorTermExpansion Yap_heap_regs->FunctorTermExpansion_
Functor FunctorThreadRun_;
#define FunctorThreadRun Yap_heap_regs->FunctorThreadRun_
Functor FunctorThrow_;
#define FunctorThrow Yap_heap_regs->FunctorThrow_
Functor FunctorTimeoutError_;
#define FunctorTimeoutError Yap_heap_regs->FunctorTimeoutError_
2015-07-23 01:19:35 +01:00
Functor FunctorTraceMetaCall_;
#define FunctorTraceMetaCall Yap_heap_regs->FunctorTraceMetaCall_
2008-12-23 02:20:22 +00:00
Functor FunctorTypeError_;
#define FunctorTypeError Yap_heap_regs->FunctorTypeError_
Functor FunctorUMinus_;
#define FunctorUMinus Yap_heap_regs->FunctorUMinus_
Functor FunctorUPlus_;
#define FunctorUPlus Yap_heap_regs->FunctorUPlus_
Functor FunctorVBar_;
#define FunctorVBar Yap_heap_regs->FunctorVBar_
2012-03-15 22:19:48 +00:00
Functor FunctorHiddenVar_;
#define FunctorHiddenVar Yap_heap_regs->FunctorHiddenVar_