diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
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.
6c98e37e18
yap-6.3/H/tatoms.h

855 lines
32 KiB
C
Raw Normal View History

make clear that some files are generated automatically.
2010-04-18 21:48:20 +01:00
/* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms"
please do not update, update misc/ATOMS instead */
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom Atom3Dots_;
#define Atom3Dots Yap_heap_regs->Atom3Dots_
Atom AtomAbol_;
#define AtomAbol Yap_heap_regs->AtomAbol_
Atom AtomAccess_;
#define AtomAccess Yap_heap_regs->AtomAccess_
Atom AtomAfInet_;
#define AtomAfInet Yap_heap_regs->AtomAfInet_
Atom AtomAfLocal_;
#define AtomAfLocal Yap_heap_regs->AtomAfLocal_
Atom AtomAfUnix_;
#define AtomAfUnix Yap_heap_regs->AtomAfUnix_
Atom AtomAlarm_;
#define AtomAlarm Yap_heap_regs->AtomAlarm_
Atom AtomAlias_;
#define AtomAlias Yap_heap_regs->AtomAlias_
Atom AtomAltNot_;
#define AtomAltNot Yap_heap_regs->AtomAltNot_
Atom AtomAppend_;
#define AtomAppend Yap_heap_regs->AtomAppend_
Atom AtomArg_;
#define AtomArg Yap_heap_regs->AtomArg_
Atom AtomArray_;
#define AtomArray Yap_heap_regs->AtomArray_
Atom AtomArrayAccess_;
#define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_
Atom AtomArrayOverflow_;
#define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_
Atom AtomArrayType_;
#define AtomArrayType Yap_heap_regs->AtomArrayType_
Atom AtomArrow_;
#define AtomArrow Yap_heap_regs->AtomArrow_
Atom AtomAssert_;
#define AtomAssert Yap_heap_regs->AtomAssert_
Atom AtomAt_;
#define AtomAt Yap_heap_regs->AtomAt_
Atom AtomAtom_;
#define AtomAtom Yap_heap_regs->AtomAtom_
Atom AtomAtomic_;
#define AtomAtomic Yap_heap_regs->AtomAtomic_
Atom AtomAtt_;
#define AtomAtt Yap_heap_regs->AtomAtt_
Atom AtomAtt1_;
#define AtomAtt1 Yap_heap_regs->AtomAtt1_
Atom AtomAttDo_;
#define AtomAttDo Yap_heap_regs->AtomAttDo_
Atom AtomAttributes_;
#define AtomAttributes Yap_heap_regs->AtomAttributes_
Atom AtomB_;
#define AtomB Yap_heap_regs->AtomB_
Atom AtomBatched_;
#define AtomBatched Yap_heap_regs->AtomBatched_
Atom AtomBetween_;
#define AtomBetween Yap_heap_regs->AtomBetween_
support 2^2 is 4 and not 4.0: complicated if we have to deal with bignums.
2009-04-25 01:03:00 +01:00
Atom AtomHugeInt_;
#define AtomHugeInt Yap_heap_regs->AtomHugeInt_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomBinaryStream_;
#define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_
Atom AtomBraces_;
#define AtomBraces Yap_heap_regs->AtomBraces_
Atom AtomBreak_;
#define AtomBreak Yap_heap_regs->AtomBreak_
Atom AtomByte_;
#define AtomByte Yap_heap_regs->AtomByte_
Atom AtomCArith_;
#define AtomCArith Yap_heap_regs->AtomCArith_
Atom AtomCall_;
#define AtomCall Yap_heap_regs->AtomCall_
Atom AtomCallAndRetryCounter_;
#define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_
Atom AtomCallCounter_;
#define AtomCallCounter Yap_heap_regs->AtomCallCounter_
Atom AtomCallable_;
#define AtomCallable Yap_heap_regs->AtomCallable_
Atom AtomCatch_;
#define AtomCatch Yap_heap_regs->AtomCatch_
Atom AtomChangeModule_;
#define AtomChangeModule Yap_heap_regs->AtomChangeModule_
Atom AtomChar_;
#define AtomChar Yap_heap_regs->AtomChar_
support resource errors for out of memory conditions. improve stack dump message.
2009-05-17 17:42:56 +01:00
Atom AtomCharsio_;
#define AtomCharsio Yap_heap_regs->AtomCharsio_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomCharacter_;
#define AtomCharacter Yap_heap_regs->AtomCharacter_
Atom AtomCharacterCode_;
#define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_
tightenn conditions on JumpExec
2009-06-06 00:45:41 +01:00
Atom AtomCleanCall_;
#define AtomCleanCall Yap_heap_regs->AtomCleanCall_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomColomn_;
#define AtomColomn Yap_heap_regs->AtomColomn_
support resource errors for out of memory conditions. improve stack dump message.
2009-05-17 17:42:56 +01:00
Atom AtomCodeSpace_;
#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_
codes/2 functor (used by format).
2010-07-19 14:48:42 +01:00
Atom AtomCodes_;
#define AtomCodes Yap_heap_regs->AtomCodes_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomComma_;
#define AtomComma Yap_heap_regs->AtomComma_
Atom AtomCompound_;
#define AtomCompound Yap_heap_regs->AtomCompound_
Atom AtomConsistencyError_;
#define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_
Atom AtomConsultOnBoot_;
#define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Atom AtomContext_;
#define AtomContext Yap_heap_regs->AtomContext_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomCputime_;
#define AtomCputime Yap_heap_regs->AtomCputime_
Atom AtomCreate_;
#define AtomCreate Yap_heap_regs->AtomCreate_
Atom AtomCreep_;
#define AtomCreep Yap_heap_regs->AtomCreep_
Atom AtomCryptAtoms_;
#define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_
Atom AtomCsult_;
#define AtomCsult Yap_heap_regs->AtomCsult_
Atom AtomCurrentModule_;
#define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_
Atom AtomCut_;
#define AtomCut Yap_heap_regs->AtomCut_
Atom AtomCutBy_;
#define AtomCutBy Yap_heap_regs->AtomCutBy_
Atom AtomDAbort_;
#define AtomDAbort Yap_heap_regs->AtomDAbort_
dbload
2011-04-30 01:16:40 +01:00
Atom AtomDBLoad_;
#define AtomDBLoad Yap_heap_regs->AtomDBLoad_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomDBREF_;
#define AtomDBREF Yap_heap_regs->AtomDBREF_
Atom AtomDBReference_;
#define AtomDBReference Yap_heap_regs->AtomDBReference_
Atom AtomDBTerm_;
#define AtomDBTerm Yap_heap_regs->AtomDBTerm_
Atom AtomDBref_;
#define AtomDBref Yap_heap_regs->AtomDBref_
Atom AtomDInteger_;
#define AtomDInteger Yap_heap_regs->AtomDInteger_
Atom AtomDOUBLE_;
#define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_
Atom AtomDec10_;
#define AtomDec10 Yap_heap_regs->AtomDec10_
Atom AtomDefault_;
#define AtomDefault Yap_heap_regs->AtomDefault_
Atom AtomDevNull_;
#define AtomDevNull Yap_heap_regs->AtomDevNull_
Atom AtomDiff_;
#define AtomDiff Yap_heap_regs->AtomDiff_
Atom AtomDoLogUpdClause_;
#define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_
Atom AtomDoLogUpdClause0_;
#define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_
Atom AtomDoLogUpdClauseErase_;
#define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_
Atom AtomDoStaticClause_;
#define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_
Atom AtomDollarU_;
#define AtomDollarU Yap_heap_regs->AtomDollarU_
Atom AtomDollarUndef_;
#define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_
Atom AtomDomainError_;
#define AtomDomainError Yap_heap_regs->AtomDomainError_
Atom AtomE_;
#define AtomE Yap_heap_regs->AtomE_
Atom AtomEOFBeforeEOT_;
#define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_
Atom AtomEQ_;
#define AtomEQ Yap_heap_regs->AtomEQ_
Atom AtomEmptyAtom_;
#define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_
patches to provide initial support UTF32 encodings(from Paulo Moura)
2010-10-27 14:49:27 +01:00
Atom AtomEncoding_;
#define AtomEncoding Yap_heap_regs->AtomEncoding_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomEndOfStream_;
#define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_
Atom AtomEof_;
#define AtomEof Yap_heap_regs->AtomEof_
Atom AtomEq_;
#define AtomEq Yap_heap_regs->AtomEq_
Atom AtomError_;
#define AtomError Yap_heap_regs->AtomError_
Atom AtomEvaluable_;
#define AtomEvaluable Yap_heap_regs->AtomEvaluable_
Atom AtomEvaluationError_;
#define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_
implement access_file/2 in C
2010-08-03 21:04:16 +01:00
Atom AtomExecute_;
#define AtomExecute Yap_heap_regs->AtomExecute_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomExecAnswers_;
#define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_
Atom AtomExecuteInMod_;
#define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_
Atom AtomExecuteWithin_;
#define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_
Atom AtomExecuteWoMod_;
#define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_
implement access_file/2 in C
2010-08-03 21:04:16 +01:00
Atom AtomExist_;
#define AtomExist Yap_heap_regs->AtomExist_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomExistenceError_;
#define AtomExistenceError Yap_heap_regs->AtomExistenceError_
Atom AtomExpectedNumber_;
#define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_
Atom AtomExtendFileSearchPath_;
#define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_
Atom AtomFB_;
#define AtomFB Yap_heap_regs->AtomFB_
Atom AtomFail_;
#define AtomFail Yap_heap_regs->AtomFail_
Atom AtomFalse_;
#define AtomFalse Yap_heap_regs->AtomFalse_
Atom AtomFast_;
#define AtomFast Yap_heap_regs->AtomFast_
Atom AtomFileerrors_;
#define AtomFileerrors Yap_heap_regs->AtomFileerrors_
Atom AtomFloat_;
#define AtomFloat Yap_heap_regs->AtomFloat_
Atom AtomFloatFormat_;
#define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_
Atom AtomFloatOverflow_;
#define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_
Atom AtomFloatUnderflow_;
#define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_
Atom AtomFormat_;
#define AtomFormat Yap_heap_regs->AtomFormat_
Atom AtomFormatAt_;
#define AtomFormatAt Yap_heap_regs->AtomFormatAt_
Atom AtomFunctor_;
#define AtomFunctor Yap_heap_regs->AtomFunctor_
Atom AtomGT_;
#define AtomGT Yap_heap_regs->AtomGT_
Atom AtomGVar_;
#define AtomGVar Yap_heap_regs->AtomGVar_
Atom AtomGc_;
#define AtomGc Yap_heap_regs->AtomGc_
Atom AtomGcMargin_;
#define AtomGcMargin Yap_heap_regs->AtomGcMargin_
Atom AtomGcTrace_;
#define AtomGcTrace Yap_heap_regs->AtomGcTrace_
Atom AtomGcVerbose_;
#define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_
Atom AtomGcVeryVerbose_;
#define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_
Atom AtomGeneratePredInfo_;
#define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_
Atom AtomGetwork_;
#define AtomGetwork Yap_heap_regs->AtomGetwork_
Atom AtomGetworkSeq_;
#define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_
adding two new modes to the yap_flag/2 and tabling_mode/2 built-in predicates: 'local_trie' mode and 'global_trie' mode.
2010-04-16 02:08:06 +01:00
Atom AtomGlobalSp_;
#define AtomGlobalSp Yap_heap_regs->AtomGlobalSp_
Atom AtomGlobalTrie_;
#define AtomGlobalTrie Yap_heap_regs->AtomGlobalTrie_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomGoalExpansion_;
#define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_
Atom AtomHERE_;
#define AtomHERE Yap_heap_regs->AtomHERE_
Atom AtomHandleThrow_;
#define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_
Atom AtomHeap_;
#define AtomHeap Yap_heap_regs->AtomHeap_
Atom AtomHeapUsed_;
#define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_
Atom AtomIDB_;
#define AtomIDB Yap_heap_regs->AtomIDB_
Atom AtomIOMode_;
#define AtomIOMode Yap_heap_regs->AtomIOMode_
Atom AtomId_;
#define AtomId Yap_heap_regs->AtomId_
Atom AtomInf_;
#define AtomInf Yap_heap_regs->AtomInf_
Atom AtomInitGoal_;
#define AtomInitGoal Yap_heap_regs->AtomInitGoal_
include AtomInStackExpansion
2009-06-13 22:05:45 +01:00
Atom AtomInStackExpansion_;
#define AtomInStackExpansion Yap_heap_regs->AtomInStackExpansion_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomInput_;
#define AtomInput Yap_heap_regs->AtomInput_
Atom AtomInstantiationError_;
#define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_
Atom AtomInt_;
#define AtomInt Yap_heap_regs->AtomInt_
Atom AtomIntOverflow_;
#define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_
Atom AtomInteger_;
#define AtomInteger Yap_heap_regs->AtomInteger_
Atom AtomInternalCompilerError_;
#define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_
rename BinaryTestPredFlag to BinaryPredFlag get rid of small annoying arithmetic bugs
2009-02-09 21:56:40 +00:00
Atom AtomIs_;
#define AtomIs Yap_heap_regs->AtomIs_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomKey_;
#define AtomKey Yap_heap_regs->AtomKey_
Atom AtomLDLibraryPath_;
#define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_
Atom AtomLONGINT_;
#define AtomLONGINT Yap_heap_regs->AtomLONGINT_
routines to copy rational terms to tree and vice-versa.
2010-11-01 20:11:28 +00:00
Atom AtomLOOP_;
#define AtomLOOP Yap_heap_regs->AtomLOOP_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomLT_;
#define AtomLT Yap_heap_regs->AtomLT_
Atom AtomLastExecuteWithin_;
#define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_
Atom AtomLeash_;
#define AtomLeash Yap_heap_regs->AtomLeash_
support for X^[A,B] and X^length in arithmetic expressions.
2011-10-27 11:36:48 +01:00
Atom AtomLength_;
#define AtomLength Yap_heap_regs->AtomLength_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomList_;
#define AtomList Yap_heap_regs->AtomList_
Atom AtomLive_;
#define AtomLive Yap_heap_regs->AtomLive_
Atom AtomLoadAnswers_;
#define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_
Atom AtomLocal_;
#define AtomLocal Yap_heap_regs->AtomLocal_
adding two new modes to the yap_flag/2 and tabling_mode/2 built-in predicates: 'local_trie' mode and 'global_trie' mode.
2010-04-16 02:08:06 +01:00
Atom AtomLocalSp_;
#define AtomLocalSp Yap_heap_regs->AtomLocalSp_
Atom AtomLocalTrie_;
#define AtomLocalTrie Yap_heap_regs->AtomLocalTrie_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomMaxArity_;
#define AtomMaxArity Yap_heap_regs->AtomMaxArity_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Atom AtomMaxFiles_;
#define AtomMaxFiles Yap_heap_regs->AtomMaxFiles_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomMegaClause_;
#define AtomMegaClause Yap_heap_regs->AtomMegaClause_
Atom AtomMetaCall_;
#define AtomMetaCall Yap_heap_regs->AtomMetaCall_
Atom AtomMfClause_;
#define AtomMfClause Yap_heap_regs->AtomMfClause_
Atom AtomMinus_;
#define AtomMinus Yap_heap_regs->AtomMinus_
Atom AtomModify_;
#define AtomModify Yap_heap_regs->AtomModify_
Atom AtomMultiFile_;
#define AtomMultiFile Yap_heap_regs->AtomMultiFile_
Atom AtomMutable_;
#define AtomMutable Yap_heap_regs->AtomMutable_
Atom AtomMutableVariable_;
#define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_
Atom AtomMyddasDB_;
#define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_
Atom AtomMyddasGoal_;
#define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_
Atom AtomMyddasHost_;
#define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_
Atom AtomMyddasPass_;
#define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_
Atom AtomMyddasUser_;
#define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_
Atom AtomMyddasVersionName_;
#define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_
Atom AtomNan_;
#define AtomNan Yap_heap_regs->AtomNan_
Atom AtomNb_;
#define AtomNb Yap_heap_regs->AtomNb_
Atom AtomNbTerm_;
#define AtomNbTerm Yap_heap_regs->AtomNbTerm_
Atom AtomNew_;
#define AtomNew Yap_heap_regs->AtomNew_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Atom AtomNoMemory_;
#define AtomNoMemory Yap_heap_regs->AtomNoMemory_
implement access_file/2 in C
2010-08-03 21:04:16 +01:00
Atom AtomNone_;
#define AtomNone Yap_heap_regs->AtomNone_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomNonEmptyList_;
#define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_
Atom AtomNot_;
#define AtomNot Yap_heap_regs->AtomNot_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Atom AtomNotImplemented_;
#define AtomNotImplemented Yap_heap_regs->AtomNotImplemented_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomNotLessThanZero_;
#define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_
Atom AtomNotNewline_;
#define AtomNotNewline Yap_heap_regs->AtomNotNewline_
Atom AtomNotZero_;
#define AtomNotZero Yap_heap_regs->AtomNotZero_
Atom AtomNumber_;
#define AtomNumber Yap_heap_regs->AtomNumber_
Atom AtomOff_;
#define AtomOff Yap_heap_regs->AtomOff_
Atom AtomOffline_;
#define AtomOffline Yap_heap_regs->AtomOffline_
Atom AtomOn_;
#define AtomOn Yap_heap_regs->AtomOn_
Atom AtomOnline_;
#define AtomOnline Yap_heap_regs->AtomOnline_
Atom AtomOpen_;
#define AtomOpen Yap_heap_regs->AtomOpen_
Atom AtomOperatingSystemError_;
#define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_
inform about new module for system library
2010-04-22 12:11:15 +01:00
Atom AtomOperatingSystemSupport_;
#define AtomOperatingSystemSupport Yap_heap_regs->AtomOperatingSystemSupport_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomOperator_;
#define AtomOperator Yap_heap_regs->AtomOperator_
Atom AtomOperatorPriority_;
#define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_
Atom AtomOperatorSpecifier_;
#define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_
Atom AtomOtherwise_;
#define AtomOtherwise Yap_heap_regs->AtomOtherwise_
Atom AtomOutOfAttvarsError_;
#define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_
Atom AtomOutOfAuxspaceError_;
#define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_
Atom AtomOutOfHeapError_;
#define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_
Atom AtomOutOfRange_;
#define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_
Atom AtomOutOfStackError_;
#define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_
Atom AtomOutOfTrailError_;
#define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_
Atom AtomOutput_;
#define AtomOutput Yap_heap_regs->AtomOutput_
OSX portability updates start of support for commons prolog initiative
2009-02-16 12:25:03 +00:00
Atom AtomPrologCommonsDir_;
#define AtomPrologCommonsDir Yap_heap_regs->AtomPrologCommonsDir_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomPastEndOfStream_;
#define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_
Atom AtomPermissionError_;
#define AtomPermissionError Yap_heap_regs->AtomPermissionError_
Atom AtomPi_;
#define AtomPi Yap_heap_regs->AtomPi_
Atom AtomPipe_;
#define AtomPipe Yap_heap_regs->AtomPipe_
Atom AtomPlus_;
#define AtomPlus Yap_heap_regs->AtomPlus_
Atom AtomPointer_;
#define AtomPointer Yap_heap_regs->AtomPointer_
Atom AtomPortray_;
#define AtomPortray Yap_heap_regs->AtomPortray_
Atom AtomPredicateIndicator_;
#define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_
Atom AtomPrimitive_;
#define AtomPrimitive Yap_heap_regs->AtomPrimitive_
Atom AtomPrivateProcedure_;
#define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Atom AtomProcedure_;
#define AtomProcedure Yap_heap_regs->AtomProcedure_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomProfile_;
#define AtomProfile Yap_heap_regs->AtomProfile_
Atom AtomProlog_;
#define AtomProlog Yap_heap_regs->AtomProlog_
Atom AtomPtr_;
#define AtomPtr Yap_heap_regs->AtomPtr_
Atom AtomQuery_;
#define AtomQuery Yap_heap_regs->AtomQuery_
Atom AtomQueue_;
#define AtomQueue Yap_heap_regs->AtomQueue_
Atom AtomQuiet_;
#define AtomQuiet Yap_heap_regs->AtomQuiet_
Atom AtomRadix_;
#define AtomRadix Yap_heap_regs->AtomRadix_
Atom AtomRandom_;
#define AtomRandom Yap_heap_regs->AtomRandom_
Atom AtomRead_;
#define AtomRead Yap_heap_regs->AtomRead_
Atom AtomReadutil_;
#define AtomReadutil Yap_heap_regs->AtomReadutil_
Atom AtomRecordedP_;
#define AtomRecordedP Yap_heap_regs->AtomRecordedP_
Atom AtomRecordedWithKey_;
#define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_
tightenn conditions on JumpExec
2009-06-06 00:45:41 +01:00
Atom AtomRedoFreeze_;
#define AtomRedoFreeze Yap_heap_regs->AtomRedoFreeze_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomRefoundVar_;
#define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_
Atom AtomRepeat_;
#define AtomRepeat Yap_heap_regs->AtomRepeat_
Atom AtomRepeatSpace_;
#define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_
Atom AtomReposition_;
#define AtomReposition Yap_heap_regs->AtomReposition_
Atom AtomRepresentationError_;
#define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_
support for rational numbers make floor and friends return an integer (make it closer to SICStus).
2010-05-28 09:53:56 +01:00
Atom AtomRDiv_;
#define AtomRDiv Yap_heap_regs->AtomRDiv_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomResize_;
#define AtomResize Yap_heap_regs->AtomResize_
Atom AtomResourceError_;
#define AtomResourceError Yap_heap_regs->AtomResourceError_
Atom AtomRestoreRegs_;
#define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_
Atom AtomRetryCounter_;
#define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_
support for user defined indexing: step 1 basic routines.
2009-02-12 16:39:20 +00:00
Atom AtomRTree_;
#define AtomRTree Yap_heap_regs->AtomRTree_
improve code for disjunctions by trying to avoid permanent variables.
2009-03-10 16:24:26 +00:00
Atom AtomSafe_;
#define AtomSafe Yap_heap_regs->AtomSafe_
change throw mechanism to fit better with cleanup mechanism: - balls are now stored off line and recovered by Prolog code when everything is safe. - if a ball exists, throw uses the *existing* one (be careful not to have one laying around). - Jump routine cleans up every cp except ones for setup_call handling, backtracking simply calls setup handlers.
2009-11-27 11:21:24 +00:00
Atom AtomSafeCallCleanup_;
#define AtomSafeCallCleanup Yap_heap_regs->AtomSafeCallCleanup_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomSame_;
#define AtomSame Yap_heap_regs->AtomSame_
Atom AtomSemic_;
#define AtomSemic Yap_heap_regs->AtomSemic_
Atom AtomShiftCountOverflow_;
#define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_
Atom AtomSigAlarm_;
#define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_
Atom AtomSigBreak_;
#define AtomSigBreak Yap_heap_regs->AtomSigBreak_
Atom AtomSigCreep_;
#define AtomSigCreep Yap_heap_regs->AtomSigCreep_
Atom AtomSigDebug_;
#define AtomSigDebug Yap_heap_regs->AtomSigDebug_
Atom AtomSigDelayCreep_;
#define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_
Atom AtomSigHup_;
#define AtomSigHup Yap_heap_regs->AtomSigHup_
Atom AtomSigInt_;
#define AtomSigInt Yap_heap_regs->AtomSigInt_
Atom AtomSigIti_;
#define AtomSigIti Yap_heap_regs->AtomSigIti_
Atom AtomSigPending_;
#define AtomSigPending Yap_heap_regs->AtomSigPending_
Atom AtomSigPipe_;
#define AtomSigPipe Yap_heap_regs->AtomSigPipe_
Atom AtomSigStackDump_;
#define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_
Atom AtomSigStatistics_;
#define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_
Atom AtomSigTrace_;
#define AtomSigTrace Yap_heap_regs->AtomSigTrace_
Atom AtomSigUsr1_;
#define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_
Atom AtomSigUsr2_;
#define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_
separate standard alarm from virtual alarm. timeout uses virtual alarm #112
2009-06-03 16:09:14 +01:00
Atom AtomSigVTAlarm_;
#define AtomSigVTAlarm Yap_heap_regs->AtomSigVTAlarm_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomSigWakeUp_;
#define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_
Atom AtomSlash_;
#define AtomSlash Yap_heap_regs->AtomSlash_
Atom AtomSocket_;
#define AtomSocket Yap_heap_regs->AtomSocket_
Atom AtomSourceSink_;
#define AtomSourceSink Yap_heap_regs->AtomSourceSink_
Atom AtomSpy_;
#define AtomSpy Yap_heap_regs->AtomSpy_
fix gmp support to give out of resource error if the bignum is too big.
2009-04-25 17:01:33 +01:00
Atom AtomStack_;
#define AtomStack Yap_heap_regs->AtomStack_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomStackFree_;
#define AtomStackFree Yap_heap_regs->AtomStackFree_
make sure we rebuild saved state stuff even if we do not actually enter top-level. fix bug with some definitions being reset at load time.
2010-12-07 15:06:53 +00:00
Atom AtomStartupSavedState_;
#define AtomStartupSavedState Yap_heap_regs->AtomStartupSavedState_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomStaticClause_;
#define AtomStaticClause Yap_heap_regs->AtomStaticClause_
Atom AtomStaticProcedure_;
#define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_
Atom AtomStream_;
#define AtomStream Yap_heap_regs->AtomStream_
more ATOM changes.
2010-02-26 10:59:43 +00:00
Atom AtomVStream_;
#define AtomVStream Yap_heap_regs->AtomVStream_
fix lack of streams message (Ulrich Neumerkel #60)
2009-05-23 01:55:18 +01:00
Atom AtomStreams_;
#define AtomStreams Yap_heap_regs->AtomStreams_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomStreamOrAlias_;
#define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_
Atom AtomStreamPos_;
#define AtomStreamPos Yap_heap_regs->AtomStreamPos_
Atom AtomStreamPosition_;
#define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_
Atom AtomString_;
#define AtomString Yap_heap_regs->AtomString_
Atom AtomSwi_;
#define AtomSwi Yap_heap_regs->AtomSwi_
Atom AtomSyntaxError_;
#define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_
Atom AtomSyntaxErrorHandler_;
#define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_
Atom AtomSystem_;
#define AtomSystem Yap_heap_regs->AtomSystem_
Atom AtomSystemError_;
#define AtomSystemError Yap_heap_regs->AtomSystemError_
Atom AtomSystemLibraryDir_;
#define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_
Atom AtomTerm_;
#define AtomTerm Yap_heap_regs->AtomTerm_
Atom AtomTerms_;
#define AtomTerms Yap_heap_regs->AtomTerms_
Atom AtomTextStream_;
#define AtomTextStream Yap_heap_regs->AtomTextStream_
Atom AtomThreads_;
#define AtomThreads Yap_heap_regs->AtomThreads_
Atom AtomThrow_;
#define AtomThrow Yap_heap_regs->AtomThrow_
Atom AtomTimeOutSpec_;
#define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Atom AtomTimeoutError_;
#define AtomTimeoutError Yap_heap_regs->AtomTimeoutError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomTopLevelGoal_;
#define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_
Atom AtomTopThreadGoal_;
#define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_
support resource errors for out of memory conditions. improve stack dump message.
2009-05-17 17:42:56 +01:00
Atom AtomTrail_;
#define AtomTrail Yap_heap_regs->AtomTrail_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomTrue_;
#define AtomTrue Yap_heap_regs->AtomTrue_
Atom AtomTty_;
#define AtomTty Yap_heap_regs->AtomTty_
Atom AtomTtys_;
#define AtomTtys Yap_heap_regs->AtomTtys_
Atom AtomTypeError_;
#define AtomTypeError Yap_heap_regs->AtomTypeError_
Atom AtomUndefined_;
#define AtomUndefined Yap_heap_regs->AtomUndefined_
Atom AtomUndefp_;
#define AtomUndefp Yap_heap_regs->AtomUndefp_
Atom AtomUnderflow_;
#define AtomUnderflow Yap_heap_regs->AtomUnderflow_
support resource errors for out of memory conditions. improve stack dump message.
2009-05-17 17:42:56 +01:00
Atom AtomUnificationStack_;
#define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Atom AtomUnsignedByte_;
#define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_
Atom AtomUnsignedChar_;
#define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_
Atom AtomUser_;
#define AtomUser Yap_heap_regs->AtomUser_
Atom AtomUserErr_;
#define AtomUserErr Yap_heap_regs->AtomUserErr_
Atom AtomUserIn_;
#define AtomUserIn Yap_heap_regs->AtomUserIn_
Atom AtomUserOut_;
#define AtomUserOut Yap_heap_regs->AtomUserOut_
Atom AtomVBar_;
#define AtomVBar Yap_heap_regs->AtomVBar_
Atom AtomVar_;
#define AtomVar Yap_heap_regs->AtomVar_
Atom AtomVariable_;
#define AtomVariable Yap_heap_regs->AtomVariable_
Atom AtomVersionNumber_;
#define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_
Atom AtomWakeUpGoal_;
#define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_
Atom AtomWhen_;
#define AtomWhen Yap_heap_regs->AtomWhen_
Atom AtomWrite_;
#define AtomWrite Yap_heap_regs->AtomWrite_
Atom AtomYapHacks_;
#define AtomYapHacks Yap_heap_regs->AtomYapHacks_
Atom AtomZeroDivisor_;
#define AtomZeroDivisor 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 FunctorAssert_;
#define FunctorAssert Yap_heap_regs->FunctorAssert_
Functor FunctorAtFoundOne_;
#define FunctorAtFoundOne Yap_heap_regs->FunctorAtFoundOne_
Functor FunctorAtom_;
#define FunctorAtom Yap_heap_regs->FunctorAtom_
moe changes to support atomic generation of atoms support automatic generation of code walker (to find P's predicate and clause)
2008-12-24 09:04:44 +00:00
Functor FunctorAtt1_;
#define FunctorAtt1 Yap_heap_regs->FunctorAtt1_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorAttGoal_;
#define FunctorAttGoal Yap_heap_regs->FunctorAttGoal_
Functor FunctorBraces_;
#define FunctorBraces Yap_heap_regs->FunctorBraces_
Functor FunctorCall_;
#define FunctorCall Yap_heap_regs->FunctorCall_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorCatch_;
#define FunctorCatch Yap_heap_regs->FunctorCatch_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorChangeModule_;
#define FunctorChangeModule Yap_heap_regs->FunctorChangeModule_
tightenn conditions on JumpExec
2009-06-06 00:45:41 +01:00
Functor FunctorCleanCall_;
#define FunctorCleanCall Yap_heap_regs->FunctorCleanCall_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorClist_;
#define FunctorClist Yap_heap_regs->FunctorClist_
codes/2 functor (used by format).
2010-07-19 14:48:42 +01:00
Functor FunctorCodes_;
#define FunctorCodes Yap_heap_regs->FunctorCodes_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorComma_;
#define FunctorComma Yap_heap_regs->FunctorComma_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Functor FunctorContext2_;
#define FunctorContext2 Yap_heap_regs->FunctorContext2_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorConsistencyError_;
#define FunctorConsistencyError Yap_heap_regs->FunctorConsistencyError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
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_
fix to thread support.
2011-03-11 19:49:32 +00:00
Functor FunctorDBREF_;
#define FunctorDBREF Yap_heap_regs->FunctorDBREF_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorDiff_;
#define FunctorDiff Yap_heap_regs->FunctorDiff_
cleanup unnecessary MkFunctor
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 FunctorDomainError_;
#define FunctorDomainError Yap_heap_regs->FunctorDomainError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorDot_;
#define FunctorDot Yap_heap_regs->FunctorDot_
moe changes to support atomic generation of atoms support automatic generation of code walker (to find P's predicate and clause)
2008-12-24 09:04:44 +00:00
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_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorEq_;
#define FunctorEq Yap_heap_regs->FunctorEq_
Functor FunctorError_;
#define FunctorError Yap_heap_regs->FunctorError_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorEvaluationError_;
#define FunctorEvaluationError Yap_heap_regs->FunctorEvaluationError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorExecute2InMod_;
#define FunctorExecute2InMod Yap_heap_regs->FunctorExecute2InMod_
Functor FunctorExecuteInMod_;
#define FunctorExecuteInMod Yap_heap_regs->FunctorExecuteInMod_
Functor FunctorExecuteWithin_;
#define FunctorExecuteWithin Yap_heap_regs->FunctorExecuteWithin_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorExistenceError_;
#define FunctorExistenceError Yap_heap_regs->FunctorExistenceError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
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_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorGoalExpansion_;
#define FunctorGoalExpansion Yap_heap_regs->FunctorGoalExpansion_
Functor FunctorHandleThrow_;
#define FunctorHandleThrow Yap_heap_regs->FunctorHandleThrow_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorId_;
#define FunctorId Yap_heap_regs->FunctorId_
rename BinaryTestPredFlag to BinaryPredFlag get rid of small annoying arithmetic bugs
2009-02-09 21:56:40 +00:00
Functor FunctorIs_;
#define FunctorIs Yap_heap_regs->FunctorIs_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorLastExecuteWithin_;
#define FunctorLastExecuteWithin Yap_heap_regs->FunctorLastExecuteWithin_
Functor FunctorList_;
#define FunctorList Yap_heap_regs->FunctorList_
routines to copy rational terms to tree and vice-versa.
2010-11-01 20:11:28 +00:00
Functor FunctorLOOP_;
#define FunctorLOOP Yap_heap_regs->FunctorLOOP_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorMegaClause_;
#define FunctorMegaClause Yap_heap_regs->FunctorMegaClause_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorMetaCall_;
#define FunctorMetaCall Yap_heap_regs->FunctorMetaCall_
moe changes to support atomic generation of atoms support automatic generation of code walker (to find P's predicate and clause)
2008-12-24 09:04:44 +00:00
Functor FunctorMinus_;
#define FunctorMinus Yap_heap_regs->FunctorMinus_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorModule_;
#define FunctorModule Yap_heap_regs->FunctorModule_
Functor FunctorMultiFileClause_;
#define FunctorMultiFileClause Yap_heap_regs->FunctorMultiFileClause_
Functor FunctorMutable_;
#define FunctorMutable Yap_heap_regs->FunctorMutable_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Functor FunctorNotImplemented_;
#define FunctorNotImplemented Yap_heap_regs->FunctorNotImplemented_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorNBQueue_;
#define FunctorNBQueue Yap_heap_regs->FunctorNBQueue_
Functor FunctorNot_;
#define FunctorNot Yap_heap_regs->FunctorNot_
Functor FunctorOr_;
#define FunctorOr Yap_heap_regs->FunctorOr_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorPermissionError_;
#define FunctorPermissionError Yap_heap_regs->FunctorPermissionError_
includ e6.2 changes for globals.
2011-04-04 13:20:35 +01:00
Functor FunctorPlus_;
#define FunctorPlus Yap_heap_regs->FunctorPlus_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorPortray_;
#define FunctorPortray Yap_heap_regs->FunctorPortray_
tightenn conditions on JumpExec
2009-06-06 00:45:41 +01:00
Functor FunctorPrologConstraint_;
#define FunctorPrologConstraint Yap_heap_regs->FunctorPrologConstraint_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorQuery_;
#define FunctorQuery Yap_heap_regs->FunctorQuery_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorRecordedWithKey_;
#define FunctorRecordedWithKey Yap_heap_regs->FunctorRecordedWithKey_
support for rational numbers make floor and friends return an integer (make it closer to SICStus).
2010-05-28 09:53:56 +01:00
Functor FunctorRDiv_;
#define FunctorRDiv Yap_heap_regs->FunctorRDiv_
tightenn conditions on JumpExec
2009-06-06 00:45:41 +01:00
Functor FunctorRedoFreeze_;
#define FunctorRedoFreeze Yap_heap_regs->FunctorRedoFreeze_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorRepresentationError_;
#define FunctorRepresentationError Yap_heap_regs->FunctorRepresentationError_
Functor FunctorResourceError_;
#define FunctorResourceError Yap_heap_regs->FunctorResourceError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorRestoreRegs_;
#define FunctorRestoreRegs Yap_heap_regs->FunctorRestoreRegs_
Functor FunctorRestoreRegs1_;
#define FunctorRestoreRegs1 Yap_heap_regs->FunctorRestoreRegs1_
improve code for disjunctions by trying to avoid permanent variables.
2009-03-10 16:24:26 +00:00
Functor FunctorSafe_;
#define FunctorSafe Yap_heap_regs->FunctorSafe_
change throw mechanism to fit better with cleanup mechanism: - balls are now stored off line and recovered by Prolog code when everything is safe. - if a ball exists, throw uses the *existing* one (be careful not to have one laying around). - Jump routine cleans up every cp except ones for setup_call handling, backtracking simply calls setup handlers.
2009-11-27 11:21:24 +00:00
Functor FunctorSafeCallCleanup_;
#define FunctorSafeCallCleanup Yap_heap_regs->FunctorSafeCallCleanup_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
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_
moe changes to support atomic generation of atoms support automatic generation of code walker (to find P's predicate and clause)
2008-12-24 09:04:44 +00:00
Functor FunctorSyntaxError_;
#define FunctorSyntaxError Yap_heap_regs->FunctorSyntaxError_
fix missing commit for syntax_erro
2010-02-26 13:30:16 +00:00
Functor FunctorShortSyntaxError_;
#define FunctorShortSyntaxError Yap_heap_regs->FunctorShortSyntaxError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorThreadRun_;
#define FunctorThreadRun Yap_heap_regs->FunctorThreadRun_
Functor FunctorThrow_;
#define FunctorThrow Yap_heap_regs->FunctorThrow_
first pass at a decent implementation of PL_error (#95) - basically copy SWI code.
2009-05-30 18:52:23 +01:00
Functor FunctorTimeoutError_;
#define FunctorTimeoutError Yap_heap_regs->FunctorTimeoutError_
cleanup unnecessary MkFunctor
2008-12-23 02:20:22 +00:00
Functor FunctorTypeError_;
#define FunctorTypeError Yap_heap_regs->FunctorTypeError_
generate known atoms and functors automatically
2008-12-23 01:53:52 +00:00
Functor FunctorUMinus_;
#define FunctorUMinus Yap_heap_regs->FunctorUMinus_
Functor FunctorUPlus_;
#define FunctorUPlus Yap_heap_regs->FunctorUPlus_
Functor FunctorVBar_;
#define FunctorVBar Yap_heap_regs->FunctorVBar_
Functor FunctorVar_;
#define FunctorVar Yap_heap_regs->FunctorVar_
Reference in New Issue Copy Permalink