diff --git a/H/generated/dhstruct.h b/H/generated/dhstruct.h index 000f2d460..39c872ca4 100644 --- a/H/generated/dhstruct.h +++ b/H/generated/dhstruct.h @@ -87,6 +87,7 @@ #ifdef EUROTRA #define TermDollarU Yap_heap_regs->TermDollarU_ #endif +#define TermAnswer Yap_heap_regs->TermAnswer_ #define USER_MODULE Yap_heap_regs->USER_MODULE_ #define IDB_MODULE Yap_heap_regs->IDB_MODULE_ @@ -135,24 +136,25 @@ #ifdef COROUTINING #define WakeUpCode Yap_heap_regs->WakeUpCode_ #endif -#define PredGoalExpansion Yap_heap_regs->PredGoalExpansion_ -#define PredMetaCall Yap_heap_regs->PredMetaCall_ -#define PredTraceMetaCall Yap_heap_regs->PredTraceMetaCall_ #define PredDollarCatch Yap_heap_regs->PredDollarCatch_ -#define PredRecordedWithKey Yap_heap_regs->PredRecordedWithKey_ -#define PredLogUpdClause Yap_heap_regs->PredLogUpdClause_ -#define PredLogUpdClauseErase Yap_heap_regs->PredLogUpdClauseErase_ -#define PredLogUpdClause0 Yap_heap_regs->PredLogUpdClause0_ -#define PredStaticClause Yap_heap_regs->PredStaticClause_ -#define PredThrow Yap_heap_regs->PredThrow_ -#define PredHandleThrow Yap_heap_regs->PredHandleThrow_ -#define PredIs Yap_heap_regs->PredIs_ -#define PredSafeCallCleanup Yap_heap_regs->PredSafeCallCleanup_ -#define PredRestoreRegs Yap_heap_regs->PredRestoreRegs_ -#define PredCommentHook Yap_heap_regs->PredCommentHook_ #ifdef YAPOR #define PredGetwork Yap_heap_regs->PredGetwork_ #endif /* YAPOR */ +#define PredGoalExpansion Yap_heap_regs->PredGoalExpansion_ +#define PredHandleThrow Yap_heap_regs->PredHandleThrow_ +#define PredIs Yap_heap_regs->PredIs_ +#define PredLogUpdClause Yap_heap_regs->PredLogUpdClause_ +#define PredLogUpdClauseErase Yap_heap_regs->PredLogUpdClauseErase_ +#define PredLogUpdClause0 Yap_heap_regs->PredLogUpdClause0_ +#define PredMetaCall Yap_heap_regs->PredMetaCall_ +#define PredProtectStack Yap_heap_regs->PredProtectStack_ +#define PredRecordedWithKey Yap_heap_regs->PredRecordedWithKey_ +#define PredRestoreRegs Yap_heap_regs->PredRestoreRegs_ +#define PredSafeCallCleanup Yap_heap_regs->PredSafeCallCleanup_ +#define PredStaticClause Yap_heap_regs->PredStaticClause_ +#define PredThrow Yap_heap_regs->PredThrow_ +#define PredTraceMetaCall Yap_heap_regs->PredTraceMetaCall_ +#define PredCommentHook Yap_heap_regs->PredCommentHook_ #define PredProcedure Yap_heap_regs->PredProcedure_ #ifdef LOW_LEVEL_TRACER diff --git a/H/generated/h0struct.h b/H/generated/h0struct.h index 4429cbacf..6a13db133 100644 --- a/H/generated/h0struct.h +++ b/H/generated/h0struct.h @@ -135,24 +135,25 @@ EXTERNAL struct pred_entry *PredTrue; #ifdef COROUTINING EXTERNAL struct pred_entry *WakeUpCode; #endif -EXTERNAL struct pred_entry *PredGoalExpansion; -EXTERNAL struct pred_entry *PredMetaCall; -EXTERNAL struct pred_entry *PredTraceMetaCall; EXTERNAL struct pred_entry *PredDollarCatch; -EXTERNAL struct pred_entry *PredRecordedWithKey; -EXTERNAL struct pred_entry *PredLogUpdClause; -EXTERNAL struct pred_entry *PredLogUpdClauseErase; -EXTERNAL struct pred_entry *PredLogUpdClause0; -EXTERNAL struct pred_entry *PredStaticClause; -EXTERNAL struct pred_entry *PredThrow; -EXTERNAL struct pred_entry *PredHandleThrow; -EXTERNAL struct pred_entry *PredIs; -EXTERNAL struct pred_entry *PredSafeCallCleanup; -EXTERNAL struct pred_entry *PredRestoreRegs; -EXTERNAL struct pred_entry *PredCommentHook; #ifdef YAPOR EXTERNAL struct pred_entry *PredGetwork; #endif /* YAPOR */ +EXTERNAL struct pred_entry *PredGoalExpansion; +EXTERNAL struct pred_entry *PredHandleThrow; +EXTERNAL struct pred_entry *PredIs; +EXTERNAL struct pred_entry *PredLogUpdClause; +EXTERNAL struct pred_entry *PredLogUpdClauseErase; +EXTERNAL struct pred_entry *PredLogUpdClause0; +EXTERNAL struct pred_entry *PredMetaCall; +EXTERNAL struct pred_entry *PredProtectStack; +EXTERNAL struct pred_entry *PredRecordedWithKey; +EXTERNAL struct pred_entry *PredRestoreRegs; +EXTERNAL struct pred_entry *PredSafeCallCleanup; +EXTERNAL struct pred_entry *PredStaticClause; +EXTERNAL struct pred_entry *PredThrow; +EXTERNAL struct pred_entry *PredTraceMetaCall; +EXTERNAL struct pred_entry *PredCommentHook; EXTERNAL struct pred_entry *PredProcedure; /* low-level tracer */ #ifdef LOW_LEVEL_TRACER diff --git a/H/generated/hstruct.h b/H/generated/hstruct.h index 7db335e2a..40c139d8b 100755 --- a/H/generated/hstruct.h +++ b/H/generated/hstruct.h @@ -87,6 +87,7 @@ #ifdef EUROTRA Term TermDollarU_; #endif + Term TermAnswer_; //modules Term USER_MODULE_; Term IDB_MODULE_; @@ -135,24 +136,25 @@ #ifdef COROUTINING struct pred_entry *WakeUpCode_; #endif - struct pred_entry *PredGoalExpansion_; - struct pred_entry *PredMetaCall_; - struct pred_entry *PredTraceMetaCall_; struct pred_entry *PredDollarCatch_; - struct pred_entry *PredRecordedWithKey_; - struct pred_entry *PredLogUpdClause_; - struct pred_entry *PredLogUpdClauseErase_; - struct pred_entry *PredLogUpdClause0_; - struct pred_entry *PredStaticClause_; - struct pred_entry *PredThrow_; - struct pred_entry *PredHandleThrow_; - struct pred_entry *PredIs_; - struct pred_entry *PredSafeCallCleanup_; - struct pred_entry *PredRestoreRegs_; - struct pred_entry *PredCommentHook_; #ifdef YAPOR struct pred_entry *PredGetwork_; #endif /* YAPOR */ + struct pred_entry *PredGoalExpansion_; + struct pred_entry *PredHandleThrow_; + struct pred_entry *PredIs_; + struct pred_entry *PredLogUpdClause_; + struct pred_entry *PredLogUpdClauseErase_; + struct pred_entry *PredLogUpdClause0_; + struct pred_entry *PredMetaCall_; + struct pred_entry *PredProtectStack_; + struct pred_entry *PredRecordedWithKey_; + struct pred_entry *PredRestoreRegs_; + struct pred_entry *PredSafeCallCleanup_; + struct pred_entry *PredStaticClause_; + struct pred_entry *PredThrow_; + struct pred_entry *PredTraceMetaCall_; + struct pred_entry *PredCommentHook_; struct pred_entry *PredProcedure_; /* low-level tracer */ #ifdef LOW_LEVEL_TRACER diff --git a/H/generated/iatoms.h b/H/generated/iatoms.h index 447e7a007..7e829cfc5 100644 --- a/H/generated/iatoms.h +++ b/H/generated/iatoms.h @@ -1,421 +1,424 @@ /* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms" - please do not update, update misc/ATOMS instead */ + {lease do not update, update misc/ATOMS instead */ Atom3Dots = Yap_LookupAtom("..."); - AtomAbol = Yap_FullLookupAtom("$abol"); - AtomAccess = Yap_LookupAtom("access"); - AtomAfInet = Yap_LookupAtom("AF_INET"); - AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); - AtomAfUnix = Yap_LookupAtom("AF_UNIX"); - AtomAlarm = Yap_FullLookupAtom("$alarm"); - AtomAlias = Yap_LookupAtom("alias"); - AtomAll = Yap_LookupAtom("all"); - AtomAltNot = Yap_LookupAtom("not"); - AtomAny = Yap_LookupAtom("any"); - AtomAppend = Yap_LookupAtom("append"); - AtomArg = Yap_LookupAtom("arg"); - AtomArray = Yap_FullLookupAtom("$array"); - AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); - AtomArrayOverflow = Yap_LookupAtom("array_overflow"); - AtomArrayType = Yap_LookupAtom("array_type"); - AtomArrow = Yap_LookupAtom("->"); - AtomAttributedModule = Yap_LookupAtom("attributes_module"); - AtomDoubleArrow = Yap_LookupAtom("-->"); - AtomAssert = Yap_LookupAtom(":-"); - AtomEmptyBrackets = Yap_LookupAtom("()"); - AtomEmptySquareBrackets = Yap_LookupAtom("[]"); - AtomEmptyCurlyBrackets = Yap_LookupAtom("{}"); - AtomAsserta = Yap_LookupAtom("asserta"); - AtomAssertaStatic = Yap_LookupAtom("asserta_static"); - AtomAssertz = Yap_LookupAtom("assertz"); - AtomAssertzStatic = Yap_LookupAtom("assertz_static"); - AtomAt = Yap_LookupAtom("at"); - AtomAtom = Yap_LookupAtom("atom"); - AtomAtomic = Yap_LookupAtom("atomic"); - AtomAtt = Yap_FullLookupAtom("$att"); - AtomAtt1 = Yap_LookupAtom("att"); - AtomAttDo = Yap_FullLookupAtom("$att_do"); - AtomAttributes = Yap_LookupAtom("attributes"); - AtomB = Yap_FullLookupAtom("$last_choice_pt"); - AtomBatched = Yap_LookupAtom("batched"); - AtomBetween = Yap_LookupAtom("between"); - AtomBinary = Yap_LookupAtom("binary"); - AtomBigNum = Yap_LookupAtom("big_num"); - AtomBinaryStream = Yap_LookupAtom("binary_stream"); - AtomBoolean = Yap_LookupAtom("boolean"); - AtomBraces = Yap_LookupAtom("{}"); - AtomBreak = Yap_FullLookupAtom("$break"); - AtomByte = Yap_LookupAtom("byte"); - AtomCArith = Yap_FullLookupAtom("$c_arith"); - AtomCall = Yap_LookupAtom("call"); - AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); - AtomCallCounter = Yap_LookupAtom("call_counter"); - AtomCallable = Yap_LookupAtom("callable"); - AtomCatch = Yap_FullLookupAtom("$catch"); - AtomChangeModule = Yap_FullLookupAtom("$change_module"); - AtomChar = Yap_LookupAtom("char"); - AtomCharsio = Yap_LookupAtom("charsio"); - AtomCharacter = Yap_LookupAtom("character"); - AtomCharacterCode = Yap_LookupAtom("character_code"); - AtomChars = Yap_LookupAtom("chars"); - AtomCharset = Yap_LookupAtom("charset"); - AtomChType = Yap_FullLookupAtom("$char_type"); - AtomCleanCall = Yap_FullLookupAtom("$clean_call"); - AtomColomn = Yap_LookupAtom(":"); - AtomCodeSpace = Yap_LookupAtom("code_space"); - AtomCodes = Yap_LookupAtom("codes"); - AtomCoInductive = Yap_LookupAtom("coinductive"); - AtomComma = Yap_LookupAtom(","); - AtomCommentHook = Yap_LookupAtom("comment_hook"); - AtomCompact = Yap_LookupAtom("compact"); - AtomCompound = Yap_LookupAtom("compound"); - AtomConsistencyError = Yap_LookupAtom("consistency_error"); - AtomConsult = Yap_LookupAtom("consult"); - AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); - AtomContext = Yap_LookupAtom("context"); - AtomCputime = Yap_LookupAtom("cputime"); - AtomCreate = Yap_LookupAtom("create"); - AtomCreep = Yap_FullLookupAtom("$creep"); - AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); - AtomCsult = Yap_FullLookupAtom("$csult"); - AtomCurrentModule = Yap_FullLookupAtom("$current_module"); - AtomCut = Yap_LookupAtom("!"); - AtomCutBy = Yap_FullLookupAtom("$cut_by"); - AtomDAbort = Yap_FullLookupAtom("$abort"); - AtomDBLoad = Yap_FullLookupAtom("$db_load"); - AtomDBREF = Yap_LookupAtom("DBRef"); - AtomDBReference = Yap_LookupAtom("db_reference"); - AtomDBTerm = Yap_LookupAtom("db_term"); - AtomDBref = Yap_FullLookupAtom("$dbref"); - AtomDInteger = Yap_FullLookupAtom("$integer"); - AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); - AtomDebuggerInput = Yap_LookupAtom("debugger_input"); - AtomDec10 = Yap_LookupAtom("dec10"); - AtomDefault = Yap_LookupAtom("default"); - AtomDevNull = Yap_LookupAtom("/dev/null"); - AtomDiff = Yap_LookupAtom("\\="); - AtomDirectory = Yap_LookupAtom("disrectorys"); - AtomDiscontiguous = Yap_LookupAtom("discontiguous"); - AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); - AtomDollar = Yap_FullLookupAtom("$"); - AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); - AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); - AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); - AtomDollarU = Yap_FullLookupAtom("$u"); - AtomDollarUndef = Yap_FullLookupAtom("$undef"); - AtomDomainError = Yap_LookupAtom("domain_error"); - AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); - AtomDots = Yap_LookupAtom("dots"); - AtomDOUBLE = Yap_FullLookupAtom("Double"); - AtomDoubleSlash = Yap_FullLookupAtom("//"); - AtomE = Yap_LookupAtom("e"); - AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); - AtomEQ = Yap_LookupAtom("="); - AtomEmptyAtom = Yap_LookupAtom(""); - AtomEncoding = Yap_LookupAtom("encoding"); - AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); - AtomEof = Yap_LookupAtom("end_of_file"); - AtomEOfCode = Yap_LookupAtom("eof_code"); - AtomEq = Yap_LookupAtom("="); - AtomError = Yap_LookupAtom("error"); - AtomException = Yap_LookupAtom("exception"); - AtomExtensions = Yap_LookupAtom("extensions"); - AtomEvaluable = Yap_LookupAtom("evaluable"); - AtomEvaluationError = Yap_LookupAtom("evaluation_error"); - AtomExecutable = Yap_LookupAtom("executable"); - AtomExecute = Yap_LookupAtom("execute"); - AtomExecAnswers = Yap_LookupAtom("exec_answers"); - AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); - AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); - AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); - AtomExist = Yap_LookupAtom("exist"); - AtomExistenceError = Yap_LookupAtom("existence_error"); - AtomExoClause = Yap_FullLookupAtom("$exo_clause"); - AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); - AtomExpand = Yap_LookupAtom("expand"); - AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); - AtomExtendsions = Yap_LookupAtom("extensionh"); - AtomFB = Yap_LookupAtom("fb"); - AtomFail = Yap_LookupAtom("fail"); - AtomFalse = Yap_LookupAtom("false"); - AtomFast = Yap_FullLookupAtom("$fast"); - AtomFastFail = Yap_LookupAtom("fast_fail"); - AtomFileErrors = Yap_LookupAtom("file_errors"); - AtomFileerrors = Yap_LookupAtom("fileerrors"); - AtomFileType = Yap_LookupAtom("file_type"); - AtomFirst = Yap_LookupAtom("first"); - AtomFloat = Yap_LookupAtom("float"); - AtomFloatFormat = Yap_LookupAtom("\%.15g"); - AtomFloatOverflow = Yap_LookupAtom("float_overflow"); - AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); - AtomFormat = Yap_LookupAtom("format"); - AtomFormatAt = Yap_FullLookupAtom("$format@"); - AtomFull = Yap_LookupAtom("full"); - AtomFunctor = Yap_LookupAtom("functor"); - AtomGT = Yap_LookupAtom(">"); - AtomGVar = Yap_LookupAtom("var"); - AtomGc = Yap_FullLookupAtom("$gc"); - AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); - AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); - AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); - AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); - AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); - AtomGetwork = Yap_FullLookupAtom("$getwork"); - AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); - AtomGlob = Yap_LookupAtom("glob"); - AtomGlobal = Yap_LookupAtom("global"); - AtomGlobalSp = Yap_LookupAtom("global_sp"); - AtomGlobalTrie = Yap_LookupAtom("global_trie"); - AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); - AtomHat = Yap_LookupAtom("^"); - AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); - AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); - AtomHeap = Yap_LookupAtom("heap"); - AtomHeapUsed = Yap_LookupAtom("heapused"); - AtomHugeInt = Yap_LookupAtom("huge_int"); - AtomIDB = Yap_LookupAtom("idb"); - AtomIOMode = Yap_LookupAtom("io_mode"); - AtomId = Yap_LookupAtom("id"); - AtomIgnore = Yap_LookupAtom("ignore"); - AtomInf = Yap_LookupAtom("inf"); - AtomInfinity = Yap_LookupAtom("infinity"); - AtomInitGoal = Yap_FullLookupAtom("$init_goal"); - AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); - AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); - AtomInput = Yap_LookupAtom("input"); - AtomInstantiationError = Yap_LookupAtom("instantiation_error"); - AtomInt = Yap_LookupAtom("int"); - AtomIntOverflow = Yap_LookupAtom("int_overflow"); - AtomInteger = Yap_LookupAtom("integer"); - AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); - AtomIs = Yap_LookupAtom("is"); - AtomKey = Yap_LookupAtom("key"); - AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); - AtomLONGINT = Yap_LookupAtom("LongInt"); - AtomLOOP = Yap_LookupAtom("_LOOP_"); - AtomLoopStream = Yap_LookupAtom("loop_stream"); - AtomLT = Yap_LookupAtom("<"); - AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); - AtomLeash = Yap_FullLookupAtom("$leash"); - AtomLeast = Yap_LookupAtom("least"); - AtomLength = Yap_FullLookupAtom("length"); - AtomList = Yap_LookupAtom("list"); - AtomLine = Yap_LookupAtom("line"); - AtomLive = Yap_FullLookupAtom("$live"); - AtomLoadAnswers = Yap_LookupAtom("load_answers"); - AtomLocal = Yap_LookupAtom("local"); - AtomLocalSp = Yap_LookupAtom("local_sp"); - AtomLocalTrie = Yap_LookupAtom("local_trie"); - AtomMax = Yap_LookupAtom("max"); - AtomMaximum = Yap_LookupAtom("maximum"); - AtomMaxArity = Yap_LookupAtom("max_arity"); - AtomMaxFiles = Yap_LookupAtom("max_files"); - AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); - AtomMetaCall = Yap_FullLookupAtom("$call"); - AtomMfClause = Yap_FullLookupAtom("$mf_clause"); - AtomMin = Yap_LookupAtom("min"); - AtomMinimum = Yap_LookupAtom("minimum"); - AtomMinus = Yap_LookupAtom("-"); - AtomModify = Yap_LookupAtom("modify"); - AtomModule = Yap_LookupAtom("module"); - AtomMost = Yap_LookupAtom("most"); - AtomMulti = Yap_LookupAtom("multi"); - AtomMultiFile = Yap_FullLookupAtom("$mf"); - AtomMultiple = Yap_FullLookupAtom("multiple"); - AtomMutable = Yap_LookupAtom("mutable"); - AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); - AtomMutex = Yap_LookupAtom("mutex"); - AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); - AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); - AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); - AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); - AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); - AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); - AtomNan = Yap_LookupAtom("nan"); - AtomNb = Yap_LookupAtom("nb"); - AtomNbTerm = Yap_LookupAtom("nb_term"); - AtomNew = Yap_LookupAtom("new"); - AtomNewLine = Yap_LookupAtom("nl"); - AtomNl = Yap_LookupAtom("nl"); - AtomNoEffect = Yap_LookupAtom("no_effect"); - AtomNoMemory = Yap_LookupAtom("no_memory"); - AtomNone = Yap_LookupAtom("none"); - AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); - AtomNot = Yap_LookupAtom("\\+"); - AtomNotImplemented = Yap_LookupAtom("not_implemented"); - AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); - AtomNotNewline = Yap_LookupAtom("not_newline"); - AtomNotZero = Yap_LookupAtom("not_zero"); - AtomNumber = Yap_LookupAtom("number"); - AtomOff = Yap_LookupAtom("off"); - AtomOffline = Yap_LookupAtom("offline"); - AtomOn = Yap_LookupAtom("on"); - AtomOnline = Yap_LookupAtom("online"); - AtomOpen = Yap_LookupAtom("open"); - AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); - AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); - AtomOperator = Yap_LookupAtom("operator"); - AtomOperatorPriority = Yap_LookupAtom("operator_priority"); - AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); - AtomOpt = Yap_LookupAtom("opt"); - AtomOtherwise = Yap_LookupAtom("otherwise"); - AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); - AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); - AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); - AtomOutOfRange = Yap_LookupAtom("out_of_range"); - AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); - AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); - AtomOutput = Yap_LookupAtom("output"); - AtomParameter = Yap_LookupAtom("parameter"); - AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); - AtomPast = Yap_LookupAtom("past"); - AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); - AtomPermissionError = Yap_LookupAtom("permission_error"); - AtomPi = Yap_LookupAtom("pi"); - AtomPipe = Yap_LookupAtom("pipe"); - AtomPlus = Yap_LookupAtom("+"); - AtomPointer = Yap_LookupAtom("pointer"); - AtomPortray = Yap_FullLookupAtom("portray"); - AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); - AtomPrimitive = Yap_LookupAtom("primitive"); - AtomPrintMessage = Yap_LookupAtom("print_message"); - AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); - AtomProcedure = Yap_LookupAtom("procedure"); - AtomProfile = Yap_FullLookupAtom("$profile"); - AtomProlog = Yap_LookupAtom("prolog"); - AtomQly = Yap_LookupAtom("qly"); - AtomQuery = Yap_LookupAtom("?-"); - AtomQueue = Yap_LookupAtom("queue"); - AtomQuiet = Yap_LookupAtom("quiet"); - AtomRadix = Yap_LookupAtom("radix"); - AtomRandom = Yap_LookupAtom("random"); - AtomRange = Yap_LookupAtom("range"); - AtomRDiv = Yap_LookupAtom("rdiv"); - AtomRead = Yap_LookupAtom("read"); - AtomReadOnly = Yap_LookupAtom("read_only"); - AtomReadWrite = Yap_LookupAtom("read_write"); - AtomReadutil = Yap_LookupAtom("readutil"); - AtomReconsult = Yap_LookupAtom("reconsult"); - AtomRecordedP = Yap_FullLookupAtom("$recordep"); - AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); - AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); - AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); - AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); - AtomRelativeTo = Yap_FullLookupAtom("relative_to"); - AtomRepeat = Yap_LookupAtom("repeat"); - AtomRepeatSpace = Yap_LookupAtom("repeat "); - AtomReposition = Yap_LookupAtom("reposition"); - AtomRepresentationError = Yap_LookupAtom("representation_error"); - AtomReset = Yap_LookupAtom("reset"); - AtomResize = Yap_LookupAtom("resize"); - AtomResourceError = Yap_LookupAtom("resource_error"); - AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); - AtomRetryCounter = Yap_LookupAtom("retry_counter"); - AtomRTree = Yap_LookupAtom("rtree"); - AtomSafe = Yap_FullLookupAtom("$safe"); - AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); - AtomSame = Yap_LookupAtom("=="); - AtomSemic = Yap_LookupAtom(";"); - AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); - AtomSigAlarm = Yap_LookupAtom("sig_alarm"); - AtomSigBreak = Yap_LookupAtom("sig_break"); - AtomSigCreep = Yap_LookupAtom("sig_creep"); - AtomSigDebug = Yap_LookupAtom("sig_debug"); - AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); - AtomSigFPE = Yap_LookupAtom("sig_fpe"); - AtomSigHup = Yap_LookupAtom("sig_hup"); - AtomSigInt = Yap_LookupAtom("sig_int"); - AtomSigIti = Yap_LookupAtom("sig_iti"); - AtomSigPending = Yap_FullLookupAtom("$sig_pending"); - AtomSigPipe = Yap_LookupAtom("sig_pipe"); - AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); - AtomSigStatistics = Yap_LookupAtom("sig_statistics"); - AtomSigTrace = Yap_LookupAtom("sig_trace"); - AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); - AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); - AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); - AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); - AtomSilent = Yap_LookupAtom("Silent"); - AtomSingle = Yap_LookupAtom("single"); - AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); - AtomSingleton = Yap_LookupAtom("singleton"); - AtomSlash = Yap_LookupAtom("/"); - AtomSocket = Yap_LookupAtom("socket"); - AtomSolutions = Yap_LookupAtom("solutions"); - AtomSource = Yap_LookupAtom("source"); - AtomSourceSink = Yap_LookupAtom("source_sink"); - AtomSpy = Yap_FullLookupAtom("$spy"); - AtomStack = Yap_LookupAtom("stack"); - AtomStackFree = Yap_LookupAtom("stackfree"); - AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); - AtomStaticClause = Yap_FullLookupAtom("$static_clause"); - AtomStaticProcedure = Yap_LookupAtom("static_procedure"); - AtomStream = Yap_FullLookupAtom("$stream"); - AtomSWIStream = Yap_FullLookupAtom(""); - AtomVStream = Yap_LookupAtom("stream"); - AtomStreams = Yap_LookupAtom("streams"); - AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); - AtomStreamPos = Yap_FullLookupAtom("$stream_position"); - AtomStreamPosition = Yap_LookupAtom("stream_position"); - AtomString = Yap_LookupAtom("string"); - AtomStyleCheck = Yap_LookupAtom("style_check"); - AtomSTRING = Yap_FullLookupAtom("String"); - AtomSwi = Yap_LookupAtom("swi"); - AtomSymbolChar = Yap_LookupAtom("symbol_char"); - AtomSyntaxError = Yap_LookupAtom("syntax_error"); - AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); - AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); - AtomSystem = Yap_LookupAtom("system"); - AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); - AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); - AtomTerm = Yap_LookupAtom("term"); - AtomTerms = Yap_LookupAtom("terms"); - AtomTermExpansion = Yap_LookupAtom("term_expansion"); - AtomText = Yap_LookupAtom("text"); - AtomTextStream = Yap_LookupAtom("text_stream"); - AtomThread = Yap_LookupAtom("thread"); - AtomThreads = Yap_LookupAtom("threads"); - AtomThrow = Yap_LookupAtom("throw"); - AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); - AtomTimeoutError = Yap_LookupAtom("timeout_error"); - AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); - AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); - AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); + AtomAbol = Yap_FullLookupAtom("$abol"); TermAbol = MkAtomTerm(AtomAbol); + AtomAccess = Yap_LookupAtom("access"); TermAccess = MkAtomTerm(AtomAccess); + AtomAfInet = Yap_LookupAtom("AF_INET"); TermAfInet = MkAtomTerm(AtomAfInet); + AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); TermAfLocal = MkAtomTerm(AtomAfLocal); + AtomAfUnix = Yap_LookupAtom("AF_UNIX"); TermAfUnix = MkAtomTerm(AtomAfUnix); + AtomAlarm = Yap_FullLookupAtom("$alarm"); TermAlarm = MkAtomTerm(AtomAlarm); + AtomAlias = Yap_LookupAtom("alias"); TermAlias = MkAtomTerm(AtomAlias); + AtomAll = Yap_LookupAtom("all"); TermAll = MkAtomTerm(AtomAll); + AtomAltNot = Yap_LookupAtom("not"); TermAltNot = MkAtomTerm(AtomAltNot); + AtomAnswer = Yap_LookupAtom("answer"); TermAnswer = MkAtomTerm(AtomAnswer); + AtomAny = Yap_LookupAtom("any"); TermAny = MkAtomTerm(AtomAny); + AtomAppend = Yap_LookupAtom("append"); TermAppend = MkAtomTerm(AtomAppend); + AtomArg = Yap_LookupAtom("arg"); TermArg = MkAtomTerm(AtomArg); + AtomArray = Yap_FullLookupAtom("$array"); TermArray = MkAtomTerm(AtomArray); + AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); TermArrayAccess = MkAtomTerm(AtomArrayAccess); + AtomArrayOverflow = Yap_LookupAtom("array_overflow"); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); + AtomArrayType = Yap_LookupAtom("array_type"); TermArrayType = MkAtomTerm(AtomArrayType); + AtomArrow = Yap_LookupAtom("->"); TermArrow = MkAtomTerm(AtomArrow); + AtomAttributedModule = Yap_LookupAtom("attributes_module"); TermAttributedModule = MkAtomTerm(AtomAttributedModule); + AtomDoubleArrow = Yap_LookupAtom("-->"); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); + AtomAssert = Yap_LookupAtom(":-"); TermAssert = MkAtomTerm(AtomAssert); + AtomEmptyBrackets = Yap_LookupAtom("()"); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); + AtomEmptySquareBrackets = Yap_LookupAtom("[]"); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); + AtomEmptyCurlyBrackets = Yap_LookupAtom("{}"); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets); + AtomAsserta = Yap_LookupAtom("asserta"); TermAsserta = MkAtomTerm(AtomAsserta); + AtomAssertaStatic = Yap_LookupAtom("asserta_static"); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); + AtomAssertz = Yap_LookupAtom("assertz"); TermAssertz = MkAtomTerm(AtomAssertz); + AtomAssertzStatic = Yap_LookupAtom("assertz_static"); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); + AtomAt = Yap_LookupAtom("at"); TermAt = MkAtomTerm(AtomAt); + AtomAtom = Yap_LookupAtom("atom"); TermAtom = MkAtomTerm(AtomAtom); + AtomAtomic = Yap_LookupAtom("atomic"); TermAtomic = MkAtomTerm(AtomAtomic); + AtomAtt = Yap_FullLookupAtom("$att"); TermAtt = MkAtomTerm(AtomAtt); + AtomAtt1 = Yap_LookupAtom("att"); TermAtt1 = MkAtomTerm(AtomAtt1); + AtomAttDo = Yap_FullLookupAtom("$att_do"); TermAttDo = MkAtomTerm(AtomAttDo); + AtomAttributes = Yap_LookupAtom("attributes"); TermAttributes = MkAtomTerm(AtomAttributes); + AtomB = Yap_FullLookupAtom("$last_choice_pt"); TermB = MkAtomTerm(AtomB); + AtomBatched = Yap_LookupAtom("batched"); TermBatched = MkAtomTerm(AtomBatched); + AtomBetween = Yap_LookupAtom("between"); TermBetween = MkAtomTerm(AtomBetween); + AtomBinary = Yap_LookupAtom("binary"); TermBinary = MkAtomTerm(AtomBinary); + AtomBigNum = Yap_LookupAtom("big_num"); TermBigNum = MkAtomTerm(AtomBigNum); + AtomBinaryStream = Yap_LookupAtom("binary_stream"); TermBinaryStream = MkAtomTerm(AtomBinaryStream); + AtomBoolean = Yap_LookupAtom("boolean"); TermBoolean = MkAtomTerm(AtomBoolean); + AtomBraces = Yap_LookupAtom("{}"); TermBraces = MkAtomTerm(AtomBraces); + AtomBreak = Yap_FullLookupAtom("$break"); TermBreak = MkAtomTerm(AtomBreak); + AtomByte = Yap_LookupAtom("byte"); TermByte = MkAtomTerm(AtomByte); + AtomCArith = Yap_FullLookupAtom("$c_arith"); TermCArith = MkAtomTerm(AtomCArith); + AtomCall = Yap_LookupAtom("call"); TermCall = MkAtomTerm(AtomCall); + AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); + AtomCallCounter = Yap_LookupAtom("call_counter"); TermCallCounter = MkAtomTerm(AtomCallCounter); + AtomCallable = Yap_LookupAtom("callable"); TermCallable = MkAtomTerm(AtomCallable); + AtomCatch = Yap_FullLookupAtom("$catch"); TermCatch = MkAtomTerm(AtomCatch); + AtomChangeModule = Yap_FullLookupAtom("$change_module"); TermChangeModule = MkAtomTerm(AtomChangeModule); + AtomChar = Yap_LookupAtom("char"); TermChar = MkAtomTerm(AtomChar); + AtomCharsio = Yap_LookupAtom("charsio"); TermCharsio = MkAtomTerm(AtomCharsio); + AtomCharacter = Yap_LookupAtom("character"); TermCharacter = MkAtomTerm(AtomCharacter); + AtomCharacterCode = Yap_LookupAtom("character_code"); TermCharacterCode = MkAtomTerm(AtomCharacterCode); + AtomChars = Yap_LookupAtom("chars"); TermChars = MkAtomTerm(AtomChars); + AtomCharset = Yap_LookupAtom("charset"); TermCharset = MkAtomTerm(AtomCharset); + AtomChType = Yap_FullLookupAtom("$char_type"); TermChType = MkAtomTerm(AtomChType); + AtomCleanCall = Yap_FullLookupAtom("$clean_call"); TermCleanCall = MkAtomTerm(AtomCleanCall); + AtomColomn = Yap_LookupAtom(":"); TermColomn = MkAtomTerm(AtomColomn); + AtomCodeSpace = Yap_LookupAtom("code_space"); TermCodeSpace = MkAtomTerm(AtomCodeSpace); + AtomCodes = Yap_LookupAtom("codes"); TermCodes = MkAtomTerm(AtomCodes); + AtomCoInductive = Yap_LookupAtom("coinductive"); TermCoInductive = MkAtomTerm(AtomCoInductive); + AtomComma = Yap_LookupAtom(","); TermComma = MkAtomTerm(AtomComma); + AtomCommentHook = Yap_LookupAtom("comment_hook"); TermCommentHook = MkAtomTerm(AtomCommentHook); + AtomCompact = Yap_LookupAtom("compact"); TermCompact = MkAtomTerm(AtomCompact); + AtomCompound = Yap_LookupAtom("compound"); TermCompound = MkAtomTerm(AtomCompound); + AtomConsistencyError = Yap_LookupAtom("consistency_error"); TermConsistencyError = MkAtomTerm(AtomConsistencyError); + AtomConsult = Yap_LookupAtom("consult"); TermConsult = MkAtomTerm(AtomConsult); + AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); + AtomContext = Yap_LookupAtom("context"); TermContext = MkAtomTerm(AtomContext); + AtomCputime = Yap_LookupAtom("cputime"); TermCputime = MkAtomTerm(AtomCputime); + AtomCreate = Yap_LookupAtom("create"); TermCreate = MkAtomTerm(AtomCreate); + AtomCreep = Yap_FullLookupAtom("$creep"); TermCreep = MkAtomTerm(AtomCreep); + AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); + AtomCsult = Yap_FullLookupAtom("$csult"); TermCsult = MkAtomTerm(AtomCsult); + AtomCurrentModule = Yap_FullLookupAtom("$current_module"); TermCurrentModule = MkAtomTerm(AtomCurrentModule); + AtomCut = Yap_LookupAtom("!"); TermCut = MkAtomTerm(AtomCut); + AtomCutBy = Yap_FullLookupAtom("$cut_by"); TermCutBy = MkAtomTerm(AtomCutBy); + AtomDAbort = Yap_FullLookupAtom("$abort"); TermDAbort = MkAtomTerm(AtomDAbort); + AtomDBLoad = Yap_FullLookupAtom("$db_load"); TermDBLoad = MkAtomTerm(AtomDBLoad); + AtomDBREF = Yap_LookupAtom("DBRef"); TermDBREF = MkAtomTerm(AtomDBREF); + AtomDBReference = Yap_LookupAtom("db_reference"); TermDBReference = MkAtomTerm(AtomDBReference); + AtomDBTerm = Yap_LookupAtom("db_term"); TermDBTerm = MkAtomTerm(AtomDBTerm); + AtomDBref = Yap_FullLookupAtom("$dbref"); TermDBref = MkAtomTerm(AtomDBref); + AtomDInteger = Yap_FullLookupAtom("$integer"); TermDInteger = MkAtomTerm(AtomDInteger); + AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); TermDebugMeta = MkAtomTerm(AtomDebugMeta); + AtomDebuggerInput = Yap_LookupAtom("debugger_input"); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); + AtomDec10 = Yap_LookupAtom("dec10"); TermDec10 = MkAtomTerm(AtomDec10); + AtomDefault = Yap_LookupAtom("default"); TermDefault = MkAtomTerm(AtomDefault); + AtomDevNull = Yap_LookupAtom("/dev/null"); TermDevNull = MkAtomTerm(AtomDevNull); + AtomDiff = Yap_LookupAtom("\\="); TermDiff = MkAtomTerm(AtomDiff); + AtomDirectory = Yap_LookupAtom("disrectorys"); TermDirectory = MkAtomTerm(AtomDirectory); + AtomDiscontiguous = Yap_LookupAtom("discontiguous"); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); + AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); + AtomDollar = Yap_FullLookupAtom("$"); TermDollar = MkAtomTerm(AtomDollar); + AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); + AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); + AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); + AtomDollarU = Yap_FullLookupAtom("$u"); TermDollarU = MkAtomTerm(AtomDollarU); + AtomDollarUndef = Yap_FullLookupAtom("$undef"); TermDollarUndef = MkAtomTerm(AtomDollarUndef); + AtomDomainError = Yap_LookupAtom("domain_error"); TermDomainError = MkAtomTerm(AtomDomainError); + AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); + AtomDots = Yap_LookupAtom("dots"); TermDots = MkAtomTerm(AtomDots); + AtomDOUBLE = Yap_FullLookupAtom("Double"); TermDOUBLE = MkAtomTerm(AtomDOUBLE); + AtomDoubleSlash = Yap_FullLookupAtom("//"); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); + AtomE = Yap_LookupAtom("e"); TermE = MkAtomTerm(AtomE); + AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); + AtomEQ = Yap_LookupAtom("="); TermEQ = MkAtomTerm(AtomEQ); + AtomEmptyAtom = Yap_LookupAtom(""); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); + AtomEncoding = Yap_LookupAtom("encoding"); TermEncoding = MkAtomTerm(AtomEncoding); + AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); TermEndOfStream = MkAtomTerm(AtomEndOfStream); + AtomEof = Yap_LookupAtom("end_of_file"); TermEof = MkAtomTerm(AtomEof); + AtomEOfCode = Yap_LookupAtom("eof_code"); TermEOfCode = MkAtomTerm(AtomEOfCode); + AtomEq = Yap_LookupAtom("="); TermEq = MkAtomTerm(AtomEq); + AtomError = Yap_LookupAtom("error"); TermError = MkAtomTerm(AtomError); + AtomException = Yap_LookupAtom("exception"); TermException = MkAtomTerm(AtomException); + AtomExtensions = Yap_LookupAtom("extensions"); TermExtensions = MkAtomTerm(AtomExtensions); + AtomEvaluable = Yap_LookupAtom("evaluable"); TermEvaluable = MkAtomTerm(AtomEvaluable); + AtomEvaluationError = Yap_LookupAtom("evaluation_error"); TermEvaluationError = MkAtomTerm(AtomEvaluationError); + AtomExecutable = Yap_LookupAtom("executable"); TermExecutable = MkAtomTerm(AtomExecutable); + AtomExecute = Yap_LookupAtom("execute"); TermExecute = MkAtomTerm(AtomExecute); + AtomExecAnswers = Yap_LookupAtom("exec_answers"); TermExecAnswers = MkAtomTerm(AtomExecAnswers); + AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); + AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); + AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); + AtomExist = Yap_LookupAtom("exist"); TermExist = MkAtomTerm(AtomExist); + AtomExit = Yap_LookupAtom("exit"); TermExit = MkAtomTerm(AtomExit); + AtomExistenceError = Yap_LookupAtom("existence_error"); TermExistenceError = MkAtomTerm(AtomExistenceError); + AtomExoClause = Yap_FullLookupAtom("$exo_clause"); TermExoClause = MkAtomTerm(AtomExoClause); + AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); + AtomExpand = Yap_LookupAtom("expand"); TermExpand = MkAtomTerm(AtomExpand); + AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); + AtomExtendsions = Yap_LookupAtom("extensionh"); TermExtendsions = MkAtomTerm(AtomExtendsions); + AtomFB = Yap_LookupAtom("fb"); TermFB = MkAtomTerm(AtomFB); + AtomFail = Yap_LookupAtom("fail"); TermFail = MkAtomTerm(AtomFail); + AtomFalse = Yap_LookupAtom("false"); TermFalse = MkAtomTerm(AtomFalse); + AtomFast = Yap_FullLookupAtom("$fast"); TermFast = MkAtomTerm(AtomFast); + AtomFastFail = Yap_LookupAtom("fast_fail"); TermFastFail = MkAtomTerm(AtomFastFail); + AtomFileErrors = Yap_LookupAtom("file_errors"); TermFileErrors = MkAtomTerm(AtomFileErrors); + AtomFileerrors = Yap_LookupAtom("fileerrors"); TermFileerrors = MkAtomTerm(AtomFileerrors); + AtomFileType = Yap_LookupAtom("file_type"); TermFileType = MkAtomTerm(AtomFileType); + AtomFirst = Yap_LookupAtom("first"); TermFirst = MkAtomTerm(AtomFirst); + AtomFloat = Yap_LookupAtom("float"); TermFloat = MkAtomTerm(AtomFloat); + AtomFloatFormat = Yap_LookupAtom("\%.15g"); TermFloatFormat = MkAtomTerm(AtomFloatFormat); + AtomFloatOverflow = Yap_LookupAtom("float_overflow"); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); + AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); + AtomFormat = Yap_LookupAtom("format"); TermFormat = MkAtomTerm(AtomFormat); + AtomFormatAt = Yap_FullLookupAtom("$format@"); TermFormatAt = MkAtomTerm(AtomFormatAt); + AtomFull = Yap_LookupAtom("full"); TermFull = MkAtomTerm(AtomFull); + AtomFunctor = Yap_LookupAtom("functor"); TermFunctor = MkAtomTerm(AtomFunctor); + AtomGT = Yap_LookupAtom(">"); TermGT = MkAtomTerm(AtomGT); + AtomGVar = Yap_LookupAtom("var"); TermGVar = MkAtomTerm(AtomGVar); + AtomGc = Yap_FullLookupAtom("$gc"); TermGc = MkAtomTerm(AtomGc); + AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); TermGcMargin = MkAtomTerm(AtomGcMargin); + AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); TermGcTrace = MkAtomTerm(AtomGcTrace); + AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); TermGcVerbose = MkAtomTerm(AtomGcVerbose); + AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); + AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); + AtomGetwork = Yap_FullLookupAtom("$getwork"); TermGetwork = MkAtomTerm(AtomGetwork); + AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); + AtomGlob = Yap_LookupAtom("glob"); TermGlob = MkAtomTerm(AtomGlob); + AtomGlobal = Yap_LookupAtom("global"); TermGlobal = MkAtomTerm(AtomGlobal); + AtomGlobalSp = Yap_LookupAtom("global_sp"); TermGlobalSp = MkAtomTerm(AtomGlobalSp); + AtomGlobalTrie = Yap_LookupAtom("global_trie"); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); + AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); + AtomHat = Yap_LookupAtom("^"); TermHat = MkAtomTerm(AtomHat); + AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); TermHERE = MkAtomTerm(AtomHERE); + AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); TermHandleThrow = MkAtomTerm(AtomHandleThrow); + AtomHeap = Yap_LookupAtom("heap"); TermHeap = MkAtomTerm(AtomHeap); + AtomHeapUsed = Yap_LookupAtom("heapused"); TermHeapUsed = MkAtomTerm(AtomHeapUsed); + AtomHugeInt = Yap_LookupAtom("huge_int"); TermHugeInt = MkAtomTerm(AtomHugeInt); + AtomIDB = Yap_LookupAtom("idb"); TermIDB = MkAtomTerm(AtomIDB); + AtomIOMode = Yap_LookupAtom("io_mode"); TermIOMode = MkAtomTerm(AtomIOMode); + AtomId = Yap_LookupAtom("id"); TermId = MkAtomTerm(AtomId); + AtomIgnore = Yap_LookupAtom("ignore"); TermIgnore = MkAtomTerm(AtomIgnore); + AtomInf = Yap_LookupAtom("inf"); TermInf = MkAtomTerm(AtomInf); + AtomInfinity = Yap_LookupAtom("infinity"); TermInfinity = MkAtomTerm(AtomInfinity); + AtomInitGoal = Yap_FullLookupAtom("$init_goal"); TermInitGoal = MkAtomTerm(AtomInitGoal); + AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); TermInitProlog = MkAtomTerm(AtomInitProlog); + AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); + AtomInput = Yap_LookupAtom("input"); TermInput = MkAtomTerm(AtomInput); + AtomInstantiationError = Yap_LookupAtom("instantiation_error"); TermInstantiationError = MkAtomTerm(AtomInstantiationError); + AtomInt = Yap_LookupAtom("int"); TermInt = MkAtomTerm(AtomInt); + AtomIntOverflow = Yap_LookupAtom("int_overflow"); TermIntOverflow = MkAtomTerm(AtomIntOverflow); + AtomInteger = Yap_LookupAtom("integer"); TermInteger = MkAtomTerm(AtomInteger); + AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); + AtomIs = Yap_LookupAtom("is"); TermIs = MkAtomTerm(AtomIs); + AtomKey = Yap_LookupAtom("key"); TermKey = MkAtomTerm(AtomKey); + AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); + AtomLONGINT = Yap_LookupAtom("LongInt"); TermLONGINT = MkAtomTerm(AtomLONGINT); + AtomLOOP = Yap_LookupAtom("_LOOP_"); TermLOOP = MkAtomTerm(AtomLOOP); + AtomLoopStream = Yap_LookupAtom("loop_stream"); TermLoopStream = MkAtomTerm(AtomLoopStream); + AtomLT = Yap_LookupAtom("<"); TermLT = MkAtomTerm(AtomLT); + AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); + AtomLeash = Yap_FullLookupAtom("$leash"); TermLeash = MkAtomTerm(AtomLeash); + AtomLeast = Yap_LookupAtom("least"); TermLeast = MkAtomTerm(AtomLeast); + AtomLength = Yap_FullLookupAtom("length"); TermLength = MkAtomTerm(AtomLength); + AtomList = Yap_LookupAtom("list"); TermList = MkAtomTerm(AtomList); + AtomLine = Yap_LookupAtom("line"); TermLine = MkAtomTerm(AtomLine); + AtomLive = Yap_FullLookupAtom("$live"); TermLive = MkAtomTerm(AtomLive); + AtomLoadAnswers = Yap_LookupAtom("load_answers"); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); + AtomLocal = Yap_LookupAtom("local"); TermLocal = MkAtomTerm(AtomLocal); + AtomLocalSp = Yap_LookupAtom("local_sp"); TermLocalSp = MkAtomTerm(AtomLocalSp); + AtomLocalTrie = Yap_LookupAtom("local_trie"); TermLocalTrie = MkAtomTerm(AtomLocalTrie); + AtomMax = Yap_LookupAtom("max"); TermMax = MkAtomTerm(AtomMax); + AtomMaximum = Yap_LookupAtom("maximum"); TermMaximum = MkAtomTerm(AtomMaximum); + AtomMaxArity = Yap_LookupAtom("max_arity"); TermMaxArity = MkAtomTerm(AtomMaxArity); + AtomMaxFiles = Yap_LookupAtom("max_files"); TermMaxFiles = MkAtomTerm(AtomMaxFiles); + AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); TermMegaClause = MkAtomTerm(AtomMegaClause); + AtomMetaCall = Yap_FullLookupAtom("$call"); TermMetaCall = MkAtomTerm(AtomMetaCall); + AtomMfClause = Yap_FullLookupAtom("$mf_clause"); TermMfClause = MkAtomTerm(AtomMfClause); + AtomMin = Yap_LookupAtom("min"); TermMin = MkAtomTerm(AtomMin); + AtomMinimum = Yap_LookupAtom("minimum"); TermMinimum = MkAtomTerm(AtomMinimum); + AtomMinus = Yap_LookupAtom("-"); TermMinus = MkAtomTerm(AtomMinus); + AtomModify = Yap_LookupAtom("modify"); TermModify = MkAtomTerm(AtomModify); + AtomModule = Yap_LookupAtom("module"); TermModule = MkAtomTerm(AtomModule); + AtomMost = Yap_LookupAtom("most"); TermMost = MkAtomTerm(AtomMost); + AtomMulti = Yap_LookupAtom("multi"); TermMulti = MkAtomTerm(AtomMulti); + AtomMultiFile = Yap_FullLookupAtom("$mf"); TermMultiFile = MkAtomTerm(AtomMultiFile); + AtomMultiple = Yap_FullLookupAtom("multiple"); TermMultiple = MkAtomTerm(AtomMultiple); + AtomMutable = Yap_LookupAtom("mutable"); TermMutable = MkAtomTerm(AtomMutable); + AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); TermMutableVariable = MkAtomTerm(AtomMutableVariable); + AtomMutex = Yap_LookupAtom("mutex"); TermMutex = MkAtomTerm(AtomMutex); + AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); TermMyddasDB = MkAtomTerm(AtomMyddasDB); + AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); + AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); TermMyddasHost = MkAtomTerm(AtomMyddasHost); + AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); TermMyddasPass = MkAtomTerm(AtomMyddasPass); + AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); TermMyddasUser = MkAtomTerm(AtomMyddasUser); + AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); + AtomNan = Yap_LookupAtom("nan"); TermNan = MkAtomTerm(AtomNan); + AtomNb = Yap_LookupAtom("nb"); TermNb = MkAtomTerm(AtomNb); + AtomNbTerm = Yap_LookupAtom("nb_term"); TermNbTerm = MkAtomTerm(AtomNbTerm); + AtomNew = Yap_LookupAtom("new"); TermNew = MkAtomTerm(AtomNew); + AtomNewLine = Yap_LookupAtom("nl"); TermNewLine = MkAtomTerm(AtomNewLine); + AtomNl = Yap_LookupAtom("nl"); TermNl = MkAtomTerm(AtomNl); + AtomNoEffect = Yap_LookupAtom("no_effect"); TermNoEffect = MkAtomTerm(AtomNoEffect); + AtomNoMemory = Yap_LookupAtom("no_memory"); TermNoMemory = MkAtomTerm(AtomNoMemory); + AtomNone = Yap_LookupAtom("none"); TermNone = MkAtomTerm(AtomNone); + AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); + AtomNot = Yap_LookupAtom("\\+"); TermNot = MkAtomTerm(AtomNot); + AtomNotImplemented = Yap_LookupAtom("not_implemented"); TermNotImplemented = MkAtomTerm(AtomNotImplemented); + AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); + AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline); + AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero); + AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber); + AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff); + AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline); + AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn); + AtomOnline = Yap_LookupAtom("online"); TermOnline = MkAtomTerm(AtomOnline); + AtomOpen = Yap_LookupAtom("open"); TermOpen = MkAtomTerm(AtomOpen); + AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); + AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); + AtomOperator = Yap_LookupAtom("operator"); TermOperator = MkAtomTerm(AtomOperator); + AtomOperatorPriority = Yap_LookupAtom("operator_priority"); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); + AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); + AtomOpt = Yap_LookupAtom("opt"); TermOpt = MkAtomTerm(AtomOpt); + AtomOtherwise = Yap_LookupAtom("otherwise"); TermOtherwise = MkAtomTerm(AtomOtherwise); + AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); + AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); + AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); + AtomOutOfRange = Yap_LookupAtom("out_of_range"); TermOutOfRange = MkAtomTerm(AtomOutOfRange); + AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); + AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); + AtomOutput = Yap_LookupAtom("output"); TermOutput = MkAtomTerm(AtomOutput); + AtomParameter = Yap_LookupAtom("parameter"); TermParameter = MkAtomTerm(AtomParameter); + AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); + AtomPast = Yap_LookupAtom("past"); TermPast = MkAtomTerm(AtomPast); + AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); + AtomPermissionError = Yap_LookupAtom("permission_error"); TermPermissionError = MkAtomTerm(AtomPermissionError); + AtomPi = Yap_LookupAtom("pi"); TermPi = MkAtomTerm(AtomPi); + AtomPipe = Yap_LookupAtom("pipe"); TermPipe = MkAtomTerm(AtomPipe); + AtomPlus = Yap_LookupAtom("+"); TermPlus = MkAtomTerm(AtomPlus); + AtomPointer = Yap_LookupAtom("pointer"); TermPointer = MkAtomTerm(AtomPointer); + AtomPortray = Yap_FullLookupAtom("portray"); TermPortray = MkAtomTerm(AtomPortray); + AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); + AtomPrimitive = Yap_LookupAtom("primitive"); TermPrimitive = MkAtomTerm(AtomPrimitive); + AtomPrintMessage = Yap_LookupAtom("print_message"); TermPrintMessage = MkAtomTerm(AtomPrintMessage); + AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); + AtomProcedure = Yap_LookupAtom("procedure"); TermProcedure = MkAtomTerm(AtomProcedure); + AtomProfile = Yap_FullLookupAtom("$profile"); TermProfile = MkAtomTerm(AtomProfile); + AtomProlog = Yap_LookupAtom("prolog"); TermProlog = MkAtomTerm(AtomProlog); + AtomProtectStack = Yap_FullLookupAtom("$protect_stack"); TermProtectStack = MkAtomTerm(AtomProtectStack); + AtomQly = Yap_LookupAtom("qly"); TermQly = MkAtomTerm(AtomQly); + AtomQuery = Yap_LookupAtom("?-"); TermQuery = MkAtomTerm(AtomQuery); + AtomQueue = Yap_LookupAtom("queue"); TermQueue = MkAtomTerm(AtomQueue); + AtomQuiet = Yap_LookupAtom("quiet"); TermQuiet = MkAtomTerm(AtomQuiet); + AtomRadix = Yap_LookupAtom("radix"); TermRadix = MkAtomTerm(AtomRadix); + AtomRandom = Yap_LookupAtom("random"); TermRandom = MkAtomTerm(AtomRandom); + AtomRange = Yap_LookupAtom("range"); TermRange = MkAtomTerm(AtomRange); + AtomRDiv = Yap_LookupAtom("rdiv"); TermRDiv = MkAtomTerm(AtomRDiv); + AtomRead = Yap_LookupAtom("read"); TermRead = MkAtomTerm(AtomRead); + AtomReadOnly = Yap_LookupAtom("read_only"); TermReadOnly = MkAtomTerm(AtomReadOnly); + AtomReadWrite = Yap_LookupAtom("read_write"); TermReadWrite = MkAtomTerm(AtomReadWrite); + AtomReadutil = Yap_LookupAtom("readutil"); TermReadutil = MkAtomTerm(AtomReadutil); + AtomReconsult = Yap_LookupAtom("reconsult"); TermReconsult = MkAtomTerm(AtomReconsult); + AtomRecordedP = Yap_FullLookupAtom("$recordep"); TermRecordedP = MkAtomTerm(AtomRecordedP); + AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); + AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); + AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); + AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); TermRefoundVar = MkAtomTerm(AtomRefoundVar); + AtomRelativeTo = Yap_FullLookupAtom("relative_to"); TermRelativeTo = MkAtomTerm(AtomRelativeTo); + AtomRepeat = Yap_LookupAtom("repeat"); TermRepeat = MkAtomTerm(AtomRepeat); + AtomRepeatSpace = Yap_LookupAtom("repeat "); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); + AtomReposition = Yap_LookupAtom("reposition"); TermReposition = MkAtomTerm(AtomReposition); + AtomRepresentationError = Yap_LookupAtom("representation_error"); TermRepresentationError = MkAtomTerm(AtomRepresentationError); + AtomReset = Yap_LookupAtom("reset"); TermReset = MkAtomTerm(AtomReset); + AtomResize = Yap_LookupAtom("resize"); TermResize = MkAtomTerm(AtomResize); + AtomResourceError = Yap_LookupAtom("resource_error"); TermResourceError = MkAtomTerm(AtomResourceError); + AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); + AtomRetryCounter = Yap_LookupAtom("retry_counter"); TermRetryCounter = MkAtomTerm(AtomRetryCounter); + AtomRTree = Yap_LookupAtom("rtree"); TermRTree = MkAtomTerm(AtomRTree); + AtomSafe = Yap_FullLookupAtom("$safe"); TermSafe = MkAtomTerm(AtomSafe); + AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); + AtomSame = Yap_LookupAtom("=="); TermSame = MkAtomTerm(AtomSame); + AtomSemic = Yap_LookupAtom(";"); TermSemic = MkAtomTerm(AtomSemic); + AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); + AtomSigAlarm = Yap_LookupAtom("sig_alarm"); TermSigAlarm = MkAtomTerm(AtomSigAlarm); + AtomSigBreak = Yap_LookupAtom("sig_break"); TermSigBreak = MkAtomTerm(AtomSigBreak); + AtomSigCreep = Yap_LookupAtom("sig_creep"); TermSigCreep = MkAtomTerm(AtomSigCreep); + AtomSigDebug = Yap_LookupAtom("sig_debug"); TermSigDebug = MkAtomTerm(AtomSigDebug); + AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); + AtomSigFPE = Yap_LookupAtom("sig_fpe"); TermSigFPE = MkAtomTerm(AtomSigFPE); + AtomSigHup = Yap_LookupAtom("sig_hup"); TermSigHup = MkAtomTerm(AtomSigHup); + AtomSigInt = Yap_LookupAtom("sig_int"); TermSigInt = MkAtomTerm(AtomSigInt); + AtomSigIti = Yap_LookupAtom("sig_iti"); TermSigIti = MkAtomTerm(AtomSigIti); + AtomSigPending = Yap_FullLookupAtom("$sig_pending"); TermSigPending = MkAtomTerm(AtomSigPending); + AtomSigPipe = Yap_LookupAtom("sig_pipe"); TermSigPipe = MkAtomTerm(AtomSigPipe); + AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); TermSigStackDump = MkAtomTerm(AtomSigStackDump); + AtomSigStatistics = Yap_LookupAtom("sig_statistics"); TermSigStatistics = MkAtomTerm(AtomSigStatistics); + AtomSigTrace = Yap_LookupAtom("sig_trace"); TermSigTrace = MkAtomTerm(AtomSigTrace); + AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); + AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); + AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); + AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); + AtomSilent = Yap_LookupAtom("Silent"); TermSilent = MkAtomTerm(AtomSilent); + AtomSingle = Yap_LookupAtom("single"); TermSingle = MkAtomTerm(AtomSingle); + AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); + AtomSingleton = Yap_LookupAtom("singleton"); TermSingleton = MkAtomTerm(AtomSingleton); + AtomSlash = Yap_LookupAtom("/"); TermSlash = MkAtomTerm(AtomSlash); + AtomSocket = Yap_LookupAtom("socket"); TermSocket = MkAtomTerm(AtomSocket); + AtomSolutions = Yap_LookupAtom("solutions"); TermSolutions = MkAtomTerm(AtomSolutions); + AtomSource = Yap_LookupAtom("source"); TermSource = MkAtomTerm(AtomSource); + AtomSourceSink = Yap_LookupAtom("source_sink"); TermSourceSink = MkAtomTerm(AtomSourceSink); + AtomSpy = Yap_FullLookupAtom("$spy"); TermSpy = MkAtomTerm(AtomSpy); + AtomStack = Yap_LookupAtom("stack"); TermStack = MkAtomTerm(AtomStack); + AtomStackFree = Yap_LookupAtom("stackfree"); TermStackFree = MkAtomTerm(AtomStackFree); + AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); + AtomStaticClause = Yap_FullLookupAtom("$static_clause"); TermStaticClause = MkAtomTerm(AtomStaticClause); + AtomStaticProcedure = Yap_LookupAtom("static_procedure"); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); + AtomStream = Yap_FullLookupAtom("$stream"); TermStream = MkAtomTerm(AtomStream); + AtomSWIStream = Yap_FullLookupAtom(""); TermSWIStream = MkAtomTerm(AtomSWIStream); + AtomVStream = Yap_LookupAtom("stream"); TermVStream = MkAtomTerm(AtomVStream); + AtomStreams = Yap_LookupAtom("streams"); TermStreams = MkAtomTerm(AtomStreams); + AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); + AtomStreamPos = Yap_FullLookupAtom("$stream_position"); TermStreamPos = MkAtomTerm(AtomStreamPos); + AtomStreamPosition = Yap_LookupAtom("stream_position"); TermStreamPosition = MkAtomTerm(AtomStreamPosition); + AtomString = Yap_LookupAtom("string"); TermString = MkAtomTerm(AtomString); + AtomStyleCheck = Yap_LookupAtom("style_check"); TermStyleCheck = MkAtomTerm(AtomStyleCheck); + AtomSTRING = Yap_FullLookupAtom("String"); TermSTRING = MkAtomTerm(AtomSTRING); + AtomSwi = Yap_LookupAtom("swi"); TermSwi = MkAtomTerm(AtomSwi); + AtomSymbolChar = Yap_LookupAtom("symbol_char"); TermSymbolChar = MkAtomTerm(AtomSymbolChar); + AtomSyntaxError = Yap_LookupAtom("syntax_error"); TermSyntaxError = MkAtomTerm(AtomSyntaxError); + AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); + AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); + AtomSystem = Yap_LookupAtom("system"); TermSystem = MkAtomTerm(AtomSystem); + AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); TermSystemError = MkAtomTerm(AtomSystemError); + AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); + AtomTerm = Yap_LookupAtom("term"); TermTerm = MkAtomTerm(AtomTerm); + AtomTerms = Yap_LookupAtom("terms"); TermTerms = MkAtomTerm(AtomTerms); + AtomTermExpansion = Yap_LookupAtom("term_expansion"); TermTermExpansion = MkAtomTerm(AtomTermExpansion); + AtomText = Yap_LookupAtom("text"); TermText = MkAtomTerm(AtomText); + AtomTextStream = Yap_LookupAtom("text_stream"); TermTextStream = MkAtomTerm(AtomTextStream); + AtomThread = Yap_LookupAtom("thread"); TermThread = MkAtomTerm(AtomThread); + AtomThreads = Yap_LookupAtom("threads"); TermThreads = MkAtomTerm(AtomThreads); + AtomThrow = Yap_LookupAtom("throw"); TermThrow = MkAtomTerm(AtomThrow); + AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); + AtomTimeoutError = Yap_LookupAtom("timeout_error"); TermTimeoutError = MkAtomTerm(AtomTimeoutError); + AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); + AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); + AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); AtomTrail = Yap_LookupAtom("trail"); - AtomTrue = Yap_LookupAtom("true"); - AtomTty = Yap_LookupAtom("tty"); - AtomTtys = Yap_LookupAtom("ttys"); - AtomTxt = Yap_LookupAtom("txt"); - AtomTypeError = Yap_LookupAtom("type_error"); - AtomUndefined = Yap_LookupAtom("undefined"); - AtomUndefp = Yap_FullLookupAtom("$undefp"); - AtomUnderflow = Yap_LookupAtom("underflow"); - AtomUnificationStack = Yap_LookupAtom("unification_stack"); - AtomUnique = Yap_LookupAtom("unique"); - AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); - AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); - AtomUser = Yap_LookupAtom("user"); - AtomUserErr = Yap_LookupAtom("user_error"); - AtomUserIn = Yap_LookupAtom("user_input"); - AtomUserOut = Yap_LookupAtom("user_output"); - AtomDollarVar = Yap_LookupAtom("$VAR"); - AtomVBar = Yap_LookupAtom("|"); - AtomVarBranches = Yap_LookupAtom("var_branches"); - AtomVariableNames = Yap_LookupAtom("variable_names"); - AtomHiddenVar = Yap_FullLookupAtom("$V"); - AtomVariable = Yap_LookupAtom("variable"); - AtomVerbose = Yap_LookupAtom("verbose"); - AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); - AtomVersionNumber = Yap_FullLookupAtom("$version_name"); - AtomVeryVerbose = Yap_LookupAtom("very_verbose"); - AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); - AtomWarning = Yap_LookupAtom("warning"); - AtomWhen = Yap_FullLookupAtom("$when"); - AtomWrite = Yap_LookupAtom("write"); - AtomXml = Yap_LookupAtom("xml"); - AtomYapHacks = Yap_LookupAtom("yap_hacks"); - AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); + AtomTrue = Yap_LookupAtom("true"); TermTrue = MkAtomTerm(AtomTrue); + AtomTty = Yap_LookupAtom("tty"); TermTty = MkAtomTerm(AtomTty); + AtomTtys = Yap_LookupAtom("ttys"); TermTtys = MkAtomTerm(AtomTtys); + AtomTxt = Yap_LookupAtom("txt"); TermTxt = MkAtomTerm(AtomTxt); + AtomTypeError = Yap_LookupAtom("type_error"); TermTypeError = MkAtomTerm(AtomTypeError); + AtomUndefined = Yap_LookupAtom("undefined"); TermUndefined = MkAtomTerm(AtomUndefined); + AtomUndefp = Yap_FullLookupAtom("$undefp"); TermUndefp = MkAtomTerm(AtomUndefp); + AtomUnderflow = Yap_LookupAtom("underflow"); TermUnderflow = MkAtomTerm(AtomUnderflow); + AtomUnificationStack = Yap_LookupAtom("unification_stack"); TermUnificationStack = MkAtomTerm(AtomUnificationStack); + AtomUnique = Yap_LookupAtom("unique"); TermUnique = MkAtomTerm(AtomUnique); + AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); + AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); + AtomUser = Yap_LookupAtom("user"); TermUser = MkAtomTerm(AtomUser); + AtomUserErr = Yap_LookupAtom("user_error"); TermUserErr = MkAtomTerm(AtomUserErr); + AtomUserIn = Yap_LookupAtom("user_input"); TermUserIn = MkAtomTerm(AtomUserIn); + AtomUserOut = Yap_LookupAtom("user_output"); TermUserOut = MkAtomTerm(AtomUserOut); + AtomDollarVar = Yap_LookupAtom("$VAR"); TermDollarVar = MkAtomTerm(AtomDollarVar); + AtomVBar = Yap_LookupAtom("|"); TermVBar = MkAtomTerm(AtomVBar); + AtomVarBranches = Yap_LookupAtom("var_branches"); TermVarBranches = MkAtomTerm(AtomVarBranches); + AtomVariableNames = Yap_LookupAtom("variable_names"); TermVariableNames = MkAtomTerm(AtomVariableNames); + AtomHiddenVar = Yap_FullLookupAtom("$V"); TermHiddenVar = MkAtomTerm(AtomHiddenVar); + AtomVariable = Yap_LookupAtom("variable"); TermVariable = MkAtomTerm(AtomVariable); + AtomVerbose = Yap_LookupAtom("verbose"); TermVerbose = MkAtomTerm(AtomVerbose); + AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); + AtomVersionNumber = Yap_FullLookupAtom("$version_name"); TermVersionNumber = MkAtomTerm(AtomVersionNumber); + AtomVeryVerbose = Yap_LookupAtom("very_verbose"); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); + AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); + AtomWarning = Yap_LookupAtom("warning"); TermWarning = MkAtomTerm(AtomWarning); + AtomWhen = Yap_FullLookupAtom("$when"); TermWhen = MkAtomTerm(AtomWhen); + AtomWrite = Yap_LookupAtom("write"); TermWrite = MkAtomTerm(AtomWrite); + AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml); + AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks); + AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); FunctorAfInet = Yap_MkFunctor(AtomAfInet,2); FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1); FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1); @@ -474,6 +477,7 @@ FunctorEq = Yap_MkFunctor(AtomEq,2); FunctorError = Yap_MkFunctor(AtomError,2); FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1); + FunctorException = Yap_MkFunctor(AtomException,1); FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2); FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2); FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1); @@ -516,6 +520,7 @@ FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2); FunctorProcedure = Yap_MkFunctor(AtomProcedure,5); FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2); + FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,1); FunctorQuery = Yap_MkFunctor(AtomQuery,1); FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6); FunctorRDiv = Yap_MkFunctor(AtomRDiv,2); diff --git a/H/generated/ihstruct.h b/H/generated/ihstruct.h index 0a8df7e8a..33e55ac29 100644 --- a/H/generated/ihstruct.h +++ b/H/generated/ihstruct.h @@ -87,6 +87,7 @@ #ifdef EUROTRA TermDollarU = MkAtomTerm(AtomDollarU); #endif + TermAnswer = MkAtomTerm(AtomAnswer); USER_MODULE = MkAtomTerm(AtomUser); IDB_MODULE = MkAtomTerm(AtomIDB); @@ -135,24 +136,25 @@ #ifdef COROUTINING WakeUpCode = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomWakeUpGoal,2),PROLOG_MODULE)); #endif - PredGoalExpansion = RepPredProp(PredPropByFunc(FunctorGoalExpansion,USER_MODULE)); - PredMetaCall = RepPredProp(PredPropByFunc(FunctorMetaCall,PROLOG_MODULE)); - PredTraceMetaCall = RepPredProp(PredPropByFunc(FunctorTraceMetaCall,PROLOG_MODULE)); PredDollarCatch = RepPredProp(PredPropByFunc(FunctorCatch,PROLOG_MODULE)); - PredRecordedWithKey = RepPredProp(PredPropByFunc(FunctorRecordedWithKey,PROLOG_MODULE)); - PredLogUpdClause = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE)); - PredLogUpdClauseErase = RepPredProp(PredPropByFunc(FunctorDoLogUpdClauseErase,PROLOG_MODULE)); - PredLogUpdClause0 = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE)); - PredStaticClause = RepPredProp(PredPropByFunc(FunctorDoStaticClause,PROLOG_MODULE)); - PredThrow = RepPredProp(PredPropByFunc(FunctorThrow,PROLOG_MODULE)); - PredHandleThrow = RepPredProp(PredPropByFunc(FunctorHandleThrow,PROLOG_MODULE)); - PredIs = RepPredProp(PredPropByFunc(FunctorIs,PROLOG_MODULE)); - PredSafeCallCleanup = RepPredProp(PredPropByFunc(FunctorSafeCallCleanup,PROLOG_MODULE)); - PredRestoreRegs = RepPredProp(PredPropByFunc(FunctorRestoreRegs,PROLOG_MODULE)); - PredCommentHook = RepPredProp(PredPropByFunc(FunctorCommentHook,PROLOG_MODULE)); #ifdef YAPOR PredGetwork = RepPredProp(PredPropByAtom(AtomGetwork,PROLOG_MODULE)); #endif /* YAPOR */ + PredGoalExpansion = RepPredProp(PredPropByFunc(FunctorGoalExpansion,USER_MODULE)); + PredHandleThrow = RepPredProp(PredPropByFunc(FunctorHandleThrow,PROLOG_MODULE)); + PredIs = RepPredProp(PredPropByFunc(FunctorIs,PROLOG_MODULE)); + PredLogUpdClause = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE)); + PredLogUpdClauseErase = RepPredProp(PredPropByFunc(FunctorDoLogUpdClauseErase,PROLOG_MODULE)); + PredLogUpdClause0 = RepPredProp(PredPropByFunc(FunctorDoLogUpdClause,PROLOG_MODULE)); + PredMetaCall = RepPredProp(PredPropByFunc(FunctorMetaCall,PROLOG_MODULE)); + PredProtectStack = RepPredProp(PredPropByFunc(FunctorProtectStack,PROLOG_MODULE)); + PredRecordedWithKey = RepPredProp(PredPropByFunc(FunctorRecordedWithKey,PROLOG_MODULE)); + PredRestoreRegs = RepPredProp(PredPropByFunc(FunctorRestoreRegs,PROLOG_MODULE)); + PredSafeCallCleanup = RepPredProp(PredPropByFunc(FunctorSafeCallCleanup,PROLOG_MODULE)); + PredStaticClause = RepPredProp(PredPropByFunc(FunctorDoStaticClause,PROLOG_MODULE)); + PredThrow = RepPredProp(PredPropByFunc(FunctorThrow,PROLOG_MODULE)); + PredTraceMetaCall = RepPredProp(PredPropByFunc(FunctorTraceMetaCall,PROLOG_MODULE)); + PredCommentHook = RepPredProp(PredPropByFunc(FunctorCommentHook,PROLOG_MODULE)); PredProcedure = Yap_MkLogPred(RepPredProp(PredPropByFunc(FunctorProcedure,PROLOG_MODULE))); #ifdef LOW_LEVEL_TRACER diff --git a/H/generated/ilocals.h b/H/generated/ilocals.h index 0c23637ca..c7528a8f2 100755 --- a/H/generated/ilocals.h +++ b/H/generated/ilocals.h @@ -275,5 +275,5 @@ static void InitWorker(int wid) { REMOTE_Including(wid) = TermNil; REMOTE_MAX_SIZE(wid) = 1024L; - REMOTE_LastWTime(wid) = NULL; + REMOTE_LastWTime(wid) = 0; } diff --git a/H/generated/ratoms.h b/H/generated/ratoms.h index e86e7371b..5312a554d 100644 --- a/H/generated/ratoms.h +++ b/H/generated/ratoms.h @@ -1,421 +1,424 @@ /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" - please do not update, update misc/ATOMS instead */ + {lease do not update, update misc/ATOMS instead */ Atom3Dots = AtomAdjust(Atom3Dots); - AtomAbol = AtomAdjust(AtomAbol); - AtomAccess = AtomAdjust(AtomAccess); - AtomAfInet = AtomAdjust(AtomAfInet); - AtomAfLocal = AtomAdjust(AtomAfLocal); - AtomAfUnix = AtomAdjust(AtomAfUnix); - AtomAlarm = AtomAdjust(AtomAlarm); - AtomAlias = AtomAdjust(AtomAlias); - AtomAll = AtomAdjust(AtomAll); - AtomAltNot = AtomAdjust(AtomAltNot); - AtomAny = AtomAdjust(AtomAny); - AtomAppend = AtomAdjust(AtomAppend); - AtomArg = AtomAdjust(AtomArg); - AtomArray = AtomAdjust(AtomArray); - AtomArrayAccess = AtomAdjust(AtomArrayAccess); - AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); - AtomArrayType = AtomAdjust(AtomArrayType); - AtomArrow = AtomAdjust(AtomArrow); - AtomAttributedModule = AtomAdjust(AtomAttributedModule); - AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); - AtomAssert = AtomAdjust(AtomAssert); - AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); - AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); - AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets); - AtomAsserta = AtomAdjust(AtomAsserta); - AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); - AtomAssertz = AtomAdjust(AtomAssertz); - AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); - AtomAt = AtomAdjust(AtomAt); - AtomAtom = AtomAdjust(AtomAtom); - AtomAtomic = AtomAdjust(AtomAtomic); - AtomAtt = AtomAdjust(AtomAtt); - AtomAtt1 = AtomAdjust(AtomAtt1); - AtomAttDo = AtomAdjust(AtomAttDo); - AtomAttributes = AtomAdjust(AtomAttributes); - AtomB = AtomAdjust(AtomB); - AtomBatched = AtomAdjust(AtomBatched); - AtomBetween = AtomAdjust(AtomBetween); - AtomBinary = AtomAdjust(AtomBinary); - AtomBigNum = AtomAdjust(AtomBigNum); - AtomBinaryStream = AtomAdjust(AtomBinaryStream); - AtomBoolean = AtomAdjust(AtomBoolean); - AtomBraces = AtomAdjust(AtomBraces); - AtomBreak = AtomAdjust(AtomBreak); - AtomByte = AtomAdjust(AtomByte); - AtomCArith = AtomAdjust(AtomCArith); - AtomCall = AtomAdjust(AtomCall); - AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); - AtomCallCounter = AtomAdjust(AtomCallCounter); - AtomCallable = AtomAdjust(AtomCallable); - AtomCatch = AtomAdjust(AtomCatch); - AtomChangeModule = AtomAdjust(AtomChangeModule); - AtomChar = AtomAdjust(AtomChar); - AtomCharsio = AtomAdjust(AtomCharsio); - AtomCharacter = AtomAdjust(AtomCharacter); - AtomCharacterCode = AtomAdjust(AtomCharacterCode); - AtomChars = AtomAdjust(AtomChars); - AtomCharset = AtomAdjust(AtomCharset); - AtomChType = AtomAdjust(AtomChType); - AtomCleanCall = AtomAdjust(AtomCleanCall); - AtomColomn = AtomAdjust(AtomColomn); - AtomCodeSpace = AtomAdjust(AtomCodeSpace); - AtomCodes = AtomAdjust(AtomCodes); - AtomCoInductive = AtomAdjust(AtomCoInductive); - AtomComma = AtomAdjust(AtomComma); - AtomCommentHook = AtomAdjust(AtomCommentHook); - AtomCompact = AtomAdjust(AtomCompact); - AtomCompound = AtomAdjust(AtomCompound); - AtomConsistencyError = AtomAdjust(AtomConsistencyError); - AtomConsult = AtomAdjust(AtomConsult); - AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); - AtomContext = AtomAdjust(AtomContext); - AtomCputime = AtomAdjust(AtomCputime); - AtomCreate = AtomAdjust(AtomCreate); - AtomCreep = AtomAdjust(AtomCreep); - AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); - AtomCsult = AtomAdjust(AtomCsult); - AtomCurrentModule = AtomAdjust(AtomCurrentModule); - AtomCut = AtomAdjust(AtomCut); - AtomCutBy = AtomAdjust(AtomCutBy); - AtomDAbort = AtomAdjust(AtomDAbort); - AtomDBLoad = AtomAdjust(AtomDBLoad); - AtomDBREF = AtomAdjust(AtomDBREF); - AtomDBReference = AtomAdjust(AtomDBReference); - AtomDBTerm = AtomAdjust(AtomDBTerm); - AtomDBref = AtomAdjust(AtomDBref); - AtomDInteger = AtomAdjust(AtomDInteger); - AtomDebugMeta = AtomAdjust(AtomDebugMeta); - AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); - AtomDec10 = AtomAdjust(AtomDec10); - AtomDefault = AtomAdjust(AtomDefault); - AtomDevNull = AtomAdjust(AtomDevNull); - AtomDiff = AtomAdjust(AtomDiff); - AtomDirectory = AtomAdjust(AtomDirectory); - AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); - AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); - AtomDollar = AtomAdjust(AtomDollar); - AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); - AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); - AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); - AtomDollarU = AtomAdjust(AtomDollarU); - AtomDollarUndef = AtomAdjust(AtomDollarUndef); - AtomDomainError = AtomAdjust(AtomDomainError); - AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); - AtomDots = AtomAdjust(AtomDots); - AtomDOUBLE = AtomAdjust(AtomDOUBLE); - AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); - AtomE = AtomAdjust(AtomE); - AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); - AtomEQ = AtomAdjust(AtomEQ); - AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); - AtomEncoding = AtomAdjust(AtomEncoding); - AtomEndOfStream = AtomAdjust(AtomEndOfStream); - AtomEof = AtomAdjust(AtomEof); - AtomEOfCode = AtomAdjust(AtomEOfCode); - AtomEq = AtomAdjust(AtomEq); - AtomError = AtomAdjust(AtomError); - AtomException = AtomAdjust(AtomException); - AtomExtensions = AtomAdjust(AtomExtensions); - AtomEvaluable = AtomAdjust(AtomEvaluable); - AtomEvaluationError = AtomAdjust(AtomEvaluationError); - AtomExecutable = AtomAdjust(AtomExecutable); - AtomExecute = AtomAdjust(AtomExecute); - AtomExecAnswers = AtomAdjust(AtomExecAnswers); - AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); - AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); - AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); - AtomExist = AtomAdjust(AtomExist); - AtomExistenceError = AtomAdjust(AtomExistenceError); - AtomExoClause = AtomAdjust(AtomExoClause); - AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); - AtomExpand = AtomAdjust(AtomExpand); - AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); - AtomExtendsions = AtomAdjust(AtomExtendsions); - AtomFB = AtomAdjust(AtomFB); - AtomFail = AtomAdjust(AtomFail); - AtomFalse = AtomAdjust(AtomFalse); - AtomFast = AtomAdjust(AtomFast); - AtomFastFail = AtomAdjust(AtomFastFail); - AtomFileErrors = AtomAdjust(AtomFileErrors); - AtomFileerrors = AtomAdjust(AtomFileerrors); - AtomFileType = AtomAdjust(AtomFileType); - AtomFirst = AtomAdjust(AtomFirst); - AtomFloat = AtomAdjust(AtomFloat); - AtomFloatFormat = AtomAdjust(AtomFloatFormat); - AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); - AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); - AtomFormat = AtomAdjust(AtomFormat); - AtomFormatAt = AtomAdjust(AtomFormatAt); - AtomFull = AtomAdjust(AtomFull); - AtomFunctor = AtomAdjust(AtomFunctor); - AtomGT = AtomAdjust(AtomGT); - AtomGVar = AtomAdjust(AtomGVar); - AtomGc = AtomAdjust(AtomGc); - AtomGcMargin = AtomAdjust(AtomGcMargin); - AtomGcTrace = AtomAdjust(AtomGcTrace); - AtomGcVerbose = AtomAdjust(AtomGcVerbose); - AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); - AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); - AtomGetwork = AtomAdjust(AtomGetwork); - AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); - AtomGlob = AtomAdjust(AtomGlob); - AtomGlobal = AtomAdjust(AtomGlobal); - AtomGlobalSp = AtomAdjust(AtomGlobalSp); - AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); - AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); - AtomHat = AtomAdjust(AtomHat); - AtomHERE = AtomAdjust(AtomHERE); - AtomHandleThrow = AtomAdjust(AtomHandleThrow); - AtomHeap = AtomAdjust(AtomHeap); - AtomHeapUsed = AtomAdjust(AtomHeapUsed); - AtomHugeInt = AtomAdjust(AtomHugeInt); - AtomIDB = AtomAdjust(AtomIDB); - AtomIOMode = AtomAdjust(AtomIOMode); - AtomId = AtomAdjust(AtomId); - AtomIgnore = AtomAdjust(AtomIgnore); - AtomInf = AtomAdjust(AtomInf); - AtomInfinity = AtomAdjust(AtomInfinity); - AtomInitGoal = AtomAdjust(AtomInitGoal); - AtomInitProlog = AtomAdjust(AtomInitProlog); - AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); - AtomInput = AtomAdjust(AtomInput); - AtomInstantiationError = AtomAdjust(AtomInstantiationError); - AtomInt = AtomAdjust(AtomInt); - AtomIntOverflow = AtomAdjust(AtomIntOverflow); - AtomInteger = AtomAdjust(AtomInteger); - AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); - AtomIs = AtomAdjust(AtomIs); - AtomKey = AtomAdjust(AtomKey); - AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); - AtomLONGINT = AtomAdjust(AtomLONGINT); - AtomLOOP = AtomAdjust(AtomLOOP); - AtomLoopStream = AtomAdjust(AtomLoopStream); - AtomLT = AtomAdjust(AtomLT); - AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); - AtomLeash = AtomAdjust(AtomLeash); - AtomLeast = AtomAdjust(AtomLeast); - AtomLength = AtomAdjust(AtomLength); - AtomList = AtomAdjust(AtomList); - AtomLine = AtomAdjust(AtomLine); - AtomLive = AtomAdjust(AtomLive); - AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); - AtomLocal = AtomAdjust(AtomLocal); - AtomLocalSp = AtomAdjust(AtomLocalSp); - AtomLocalTrie = AtomAdjust(AtomLocalTrie); - AtomMax = AtomAdjust(AtomMax); - AtomMaximum = AtomAdjust(AtomMaximum); - AtomMaxArity = AtomAdjust(AtomMaxArity); - AtomMaxFiles = AtomAdjust(AtomMaxFiles); - AtomMegaClause = AtomAdjust(AtomMegaClause); - AtomMetaCall = AtomAdjust(AtomMetaCall); - AtomMfClause = AtomAdjust(AtomMfClause); - AtomMin = AtomAdjust(AtomMin); - AtomMinimum = AtomAdjust(AtomMinimum); - AtomMinus = AtomAdjust(AtomMinus); - AtomModify = AtomAdjust(AtomModify); - AtomModule = AtomAdjust(AtomModule); - AtomMost = AtomAdjust(AtomMost); - AtomMulti = AtomAdjust(AtomMulti); - AtomMultiFile = AtomAdjust(AtomMultiFile); - AtomMultiple = AtomAdjust(AtomMultiple); - AtomMutable = AtomAdjust(AtomMutable); - AtomMutableVariable = AtomAdjust(AtomMutableVariable); - AtomMutex = AtomAdjust(AtomMutex); - AtomMyddasDB = AtomAdjust(AtomMyddasDB); - AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); - AtomMyddasHost = AtomAdjust(AtomMyddasHost); - AtomMyddasPass = AtomAdjust(AtomMyddasPass); - AtomMyddasUser = AtomAdjust(AtomMyddasUser); - AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); - AtomNan = AtomAdjust(AtomNan); - AtomNb = AtomAdjust(AtomNb); - AtomNbTerm = AtomAdjust(AtomNbTerm); - AtomNew = AtomAdjust(AtomNew); - AtomNewLine = AtomAdjust(AtomNewLine); - AtomNl = AtomAdjust(AtomNl); - AtomNoEffect = AtomAdjust(AtomNoEffect); - AtomNoMemory = AtomAdjust(AtomNoMemory); - AtomNone = AtomAdjust(AtomNone); - AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); - AtomNot = AtomAdjust(AtomNot); - AtomNotImplemented = AtomAdjust(AtomNotImplemented); - AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); - AtomNotNewline = AtomAdjust(AtomNotNewline); - AtomNotZero = AtomAdjust(AtomNotZero); - AtomNumber = AtomAdjust(AtomNumber); - AtomOff = AtomAdjust(AtomOff); - AtomOffline = AtomAdjust(AtomOffline); - AtomOn = AtomAdjust(AtomOn); - AtomOnline = AtomAdjust(AtomOnline); - AtomOpen = AtomAdjust(AtomOpen); - AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); - AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); - AtomOperator = AtomAdjust(AtomOperator); - AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); - AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); - AtomOpt = AtomAdjust(AtomOpt); - AtomOtherwise = AtomAdjust(AtomOtherwise); - AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); - AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); - AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); - AtomOutOfRange = AtomAdjust(AtomOutOfRange); - AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); - AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); - AtomOutput = AtomAdjust(AtomOutput); - AtomParameter = AtomAdjust(AtomParameter); - AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); - AtomPast = AtomAdjust(AtomPast); - AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); - AtomPermissionError = AtomAdjust(AtomPermissionError); - AtomPi = AtomAdjust(AtomPi); - AtomPipe = AtomAdjust(AtomPipe); - AtomPlus = AtomAdjust(AtomPlus); - AtomPointer = AtomAdjust(AtomPointer); - AtomPortray = AtomAdjust(AtomPortray); - AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); - AtomPrimitive = AtomAdjust(AtomPrimitive); - AtomPrintMessage = AtomAdjust(AtomPrintMessage); - AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); - AtomProcedure = AtomAdjust(AtomProcedure); - AtomProfile = AtomAdjust(AtomProfile); - AtomProlog = AtomAdjust(AtomProlog); - AtomQly = AtomAdjust(AtomQly); - AtomQuery = AtomAdjust(AtomQuery); - AtomQueue = AtomAdjust(AtomQueue); - AtomQuiet = AtomAdjust(AtomQuiet); - AtomRadix = AtomAdjust(AtomRadix); - AtomRandom = AtomAdjust(AtomRandom); - AtomRange = AtomAdjust(AtomRange); - AtomRDiv = AtomAdjust(AtomRDiv); - AtomRead = AtomAdjust(AtomRead); - AtomReadOnly = AtomAdjust(AtomReadOnly); - AtomReadWrite = AtomAdjust(AtomReadWrite); - AtomReadutil = AtomAdjust(AtomReadutil); - AtomReconsult = AtomAdjust(AtomReconsult); - AtomRecordedP = AtomAdjust(AtomRecordedP); - AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); - AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); - AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); - AtomRefoundVar = AtomAdjust(AtomRefoundVar); - AtomRelativeTo = AtomAdjust(AtomRelativeTo); - AtomRepeat = AtomAdjust(AtomRepeat); - AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); - AtomReposition = AtomAdjust(AtomReposition); - AtomRepresentationError = AtomAdjust(AtomRepresentationError); - AtomReset = AtomAdjust(AtomReset); - AtomResize = AtomAdjust(AtomResize); - AtomResourceError = AtomAdjust(AtomResourceError); - AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); - AtomRetryCounter = AtomAdjust(AtomRetryCounter); - AtomRTree = AtomAdjust(AtomRTree); - AtomSafe = AtomAdjust(AtomSafe); - AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); - AtomSame = AtomAdjust(AtomSame); - AtomSemic = AtomAdjust(AtomSemic); - AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); - AtomSigAlarm = AtomAdjust(AtomSigAlarm); - AtomSigBreak = AtomAdjust(AtomSigBreak); - AtomSigCreep = AtomAdjust(AtomSigCreep); - AtomSigDebug = AtomAdjust(AtomSigDebug); - AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); - AtomSigFPE = AtomAdjust(AtomSigFPE); - AtomSigHup = AtomAdjust(AtomSigHup); - AtomSigInt = AtomAdjust(AtomSigInt); - AtomSigIti = AtomAdjust(AtomSigIti); - AtomSigPending = AtomAdjust(AtomSigPending); - AtomSigPipe = AtomAdjust(AtomSigPipe); - AtomSigStackDump = AtomAdjust(AtomSigStackDump); - AtomSigStatistics = AtomAdjust(AtomSigStatistics); - AtomSigTrace = AtomAdjust(AtomSigTrace); - AtomSigUsr1 = AtomAdjust(AtomSigUsr1); - AtomSigUsr2 = AtomAdjust(AtomSigUsr2); - AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); - AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); - AtomSilent = AtomAdjust(AtomSilent); - AtomSingle = AtomAdjust(AtomSingle); - AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); - AtomSingleton = AtomAdjust(AtomSingleton); - AtomSlash = AtomAdjust(AtomSlash); - AtomSocket = AtomAdjust(AtomSocket); - AtomSolutions = AtomAdjust(AtomSolutions); - AtomSource = AtomAdjust(AtomSource); - AtomSourceSink = AtomAdjust(AtomSourceSink); - AtomSpy = AtomAdjust(AtomSpy); - AtomStack = AtomAdjust(AtomStack); - AtomStackFree = AtomAdjust(AtomStackFree); - AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); - AtomStaticClause = AtomAdjust(AtomStaticClause); - AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); - AtomStream = AtomAdjust(AtomStream); - AtomSWIStream = AtomAdjust(AtomSWIStream); - AtomVStream = AtomAdjust(AtomVStream); - AtomStreams = AtomAdjust(AtomStreams); - AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); - AtomStreamPos = AtomAdjust(AtomStreamPos); - AtomStreamPosition = AtomAdjust(AtomStreamPosition); - AtomString = AtomAdjust(AtomString); - AtomStyleCheck = AtomAdjust(AtomStyleCheck); - AtomSTRING = AtomAdjust(AtomSTRING); - AtomSwi = AtomAdjust(AtomSwi); - AtomSymbolChar = AtomAdjust(AtomSymbolChar); - AtomSyntaxError = AtomAdjust(AtomSyntaxError); - AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); - AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); - AtomSystem = AtomAdjust(AtomSystem); - AtomSystemError = AtomAdjust(AtomSystemError); - AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); - AtomTerm = AtomAdjust(AtomTerm); - AtomTerms = AtomAdjust(AtomTerms); - AtomTermExpansion = AtomAdjust(AtomTermExpansion); - AtomText = AtomAdjust(AtomText); - AtomTextStream = AtomAdjust(AtomTextStream); - AtomThread = AtomAdjust(AtomThread); - AtomThreads = AtomAdjust(AtomThreads); - AtomThrow = AtomAdjust(AtomThrow); - AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); - AtomTimeoutError = AtomAdjust(AtomTimeoutError); - AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); - AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); - AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); + AtomAbol = AtomAdjust(AtomAbol); TermAbol = MkAtomTerm(AtomAbol); + AtomAccess = AtomAdjust(AtomAccess); TermAccess = MkAtomTerm(AtomAccess); + AtomAfInet = AtomAdjust(AtomAfInet); TermAfInet = MkAtomTerm(AtomAfInet); + AtomAfLocal = AtomAdjust(AtomAfLocal); TermAfLocal = MkAtomTerm(AtomAfLocal); + AtomAfUnix = AtomAdjust(AtomAfUnix); TermAfUnix = MkAtomTerm(AtomAfUnix); + AtomAlarm = AtomAdjust(AtomAlarm); TermAlarm = MkAtomTerm(AtomAlarm); + AtomAlias = AtomAdjust(AtomAlias); TermAlias = MkAtomTerm(AtomAlias); + AtomAll = AtomAdjust(AtomAll); TermAll = MkAtomTerm(AtomAll); + AtomAltNot = AtomAdjust(AtomAltNot); TermAltNot = MkAtomTerm(AtomAltNot); + AtomAnswer = AtomAdjust(AtomAnswer); TermAnswer = MkAtomTerm(AtomAnswer); + AtomAny = AtomAdjust(AtomAny); TermAny = MkAtomTerm(AtomAny); + AtomAppend = AtomAdjust(AtomAppend); TermAppend = MkAtomTerm(AtomAppend); + AtomArg = AtomAdjust(AtomArg); TermArg = MkAtomTerm(AtomArg); + AtomArray = AtomAdjust(AtomArray); TermArray = MkAtomTerm(AtomArray); + AtomArrayAccess = AtomAdjust(AtomArrayAccess); TermArrayAccess = MkAtomTerm(AtomArrayAccess); + AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); + AtomArrayType = AtomAdjust(AtomArrayType); TermArrayType = MkAtomTerm(AtomArrayType); + AtomArrow = AtomAdjust(AtomArrow); TermArrow = MkAtomTerm(AtomArrow); + AtomAttributedModule = AtomAdjust(AtomAttributedModule); TermAttributedModule = MkAtomTerm(AtomAttributedModule); + AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); + AtomAssert = AtomAdjust(AtomAssert); TermAssert = MkAtomTerm(AtomAssert); + AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); + AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); + AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets); + AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta); + AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); + AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz); + AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); + AtomAt = AtomAdjust(AtomAt); TermAt = MkAtomTerm(AtomAt); + AtomAtom = AtomAdjust(AtomAtom); TermAtom = MkAtomTerm(AtomAtom); + AtomAtomic = AtomAdjust(AtomAtomic); TermAtomic = MkAtomTerm(AtomAtomic); + AtomAtt = AtomAdjust(AtomAtt); TermAtt = MkAtomTerm(AtomAtt); + AtomAtt1 = AtomAdjust(AtomAtt1); TermAtt1 = MkAtomTerm(AtomAtt1); + AtomAttDo = AtomAdjust(AtomAttDo); TermAttDo = MkAtomTerm(AtomAttDo); + AtomAttributes = AtomAdjust(AtomAttributes); TermAttributes = MkAtomTerm(AtomAttributes); + AtomB = AtomAdjust(AtomB); TermB = MkAtomTerm(AtomB); + AtomBatched = AtomAdjust(AtomBatched); TermBatched = MkAtomTerm(AtomBatched); + AtomBetween = AtomAdjust(AtomBetween); TermBetween = MkAtomTerm(AtomBetween); + AtomBinary = AtomAdjust(AtomBinary); TermBinary = MkAtomTerm(AtomBinary); + AtomBigNum = AtomAdjust(AtomBigNum); TermBigNum = MkAtomTerm(AtomBigNum); + AtomBinaryStream = AtomAdjust(AtomBinaryStream); TermBinaryStream = MkAtomTerm(AtomBinaryStream); + AtomBoolean = AtomAdjust(AtomBoolean); TermBoolean = MkAtomTerm(AtomBoolean); + AtomBraces = AtomAdjust(AtomBraces); TermBraces = MkAtomTerm(AtomBraces); + AtomBreak = AtomAdjust(AtomBreak); TermBreak = MkAtomTerm(AtomBreak); + AtomByte = AtomAdjust(AtomByte); TermByte = MkAtomTerm(AtomByte); + AtomCArith = AtomAdjust(AtomCArith); TermCArith = MkAtomTerm(AtomCArith); + AtomCall = AtomAdjust(AtomCall); TermCall = MkAtomTerm(AtomCall); + AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); + AtomCallCounter = AtomAdjust(AtomCallCounter); TermCallCounter = MkAtomTerm(AtomCallCounter); + AtomCallable = AtomAdjust(AtomCallable); TermCallable = MkAtomTerm(AtomCallable); + AtomCatch = AtomAdjust(AtomCatch); TermCatch = MkAtomTerm(AtomCatch); + AtomChangeModule = AtomAdjust(AtomChangeModule); TermChangeModule = MkAtomTerm(AtomChangeModule); + AtomChar = AtomAdjust(AtomChar); TermChar = MkAtomTerm(AtomChar); + AtomCharsio = AtomAdjust(AtomCharsio); TermCharsio = MkAtomTerm(AtomCharsio); + AtomCharacter = AtomAdjust(AtomCharacter); TermCharacter = MkAtomTerm(AtomCharacter); + AtomCharacterCode = AtomAdjust(AtomCharacterCode); TermCharacterCode = MkAtomTerm(AtomCharacterCode); + AtomChars = AtomAdjust(AtomChars); TermChars = MkAtomTerm(AtomChars); + AtomCharset = AtomAdjust(AtomCharset); TermCharset = MkAtomTerm(AtomCharset); + AtomChType = AtomAdjust(AtomChType); TermChType = MkAtomTerm(AtomChType); + AtomCleanCall = AtomAdjust(AtomCleanCall); TermCleanCall = MkAtomTerm(AtomCleanCall); + AtomColomn = AtomAdjust(AtomColomn); TermColomn = MkAtomTerm(AtomColomn); + AtomCodeSpace = AtomAdjust(AtomCodeSpace); TermCodeSpace = MkAtomTerm(AtomCodeSpace); + AtomCodes = AtomAdjust(AtomCodes); TermCodes = MkAtomTerm(AtomCodes); + AtomCoInductive = AtomAdjust(AtomCoInductive); TermCoInductive = MkAtomTerm(AtomCoInductive); + AtomComma = AtomAdjust(AtomComma); TermComma = MkAtomTerm(AtomComma); + AtomCommentHook = AtomAdjust(AtomCommentHook); TermCommentHook = MkAtomTerm(AtomCommentHook); + AtomCompact = AtomAdjust(AtomCompact); TermCompact = MkAtomTerm(AtomCompact); + AtomCompound = AtomAdjust(AtomCompound); TermCompound = MkAtomTerm(AtomCompound); + AtomConsistencyError = AtomAdjust(AtomConsistencyError); TermConsistencyError = MkAtomTerm(AtomConsistencyError); + AtomConsult = AtomAdjust(AtomConsult); TermConsult = MkAtomTerm(AtomConsult); + AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); + AtomContext = AtomAdjust(AtomContext); TermContext = MkAtomTerm(AtomContext); + AtomCputime = AtomAdjust(AtomCputime); TermCputime = MkAtomTerm(AtomCputime); + AtomCreate = AtomAdjust(AtomCreate); TermCreate = MkAtomTerm(AtomCreate); + AtomCreep = AtomAdjust(AtomCreep); TermCreep = MkAtomTerm(AtomCreep); + AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); + AtomCsult = AtomAdjust(AtomCsult); TermCsult = MkAtomTerm(AtomCsult); + AtomCurrentModule = AtomAdjust(AtomCurrentModule); TermCurrentModule = MkAtomTerm(AtomCurrentModule); + AtomCut = AtomAdjust(AtomCut); TermCut = MkAtomTerm(AtomCut); + AtomCutBy = AtomAdjust(AtomCutBy); TermCutBy = MkAtomTerm(AtomCutBy); + AtomDAbort = AtomAdjust(AtomDAbort); TermDAbort = MkAtomTerm(AtomDAbort); + AtomDBLoad = AtomAdjust(AtomDBLoad); TermDBLoad = MkAtomTerm(AtomDBLoad); + AtomDBREF = AtomAdjust(AtomDBREF); TermDBREF = MkAtomTerm(AtomDBREF); + AtomDBReference = AtomAdjust(AtomDBReference); TermDBReference = MkAtomTerm(AtomDBReference); + AtomDBTerm = AtomAdjust(AtomDBTerm); TermDBTerm = MkAtomTerm(AtomDBTerm); + AtomDBref = AtomAdjust(AtomDBref); TermDBref = MkAtomTerm(AtomDBref); + AtomDInteger = AtomAdjust(AtomDInteger); TermDInteger = MkAtomTerm(AtomDInteger); + AtomDebugMeta = AtomAdjust(AtomDebugMeta); TermDebugMeta = MkAtomTerm(AtomDebugMeta); + AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); + AtomDec10 = AtomAdjust(AtomDec10); TermDec10 = MkAtomTerm(AtomDec10); + AtomDefault = AtomAdjust(AtomDefault); TermDefault = MkAtomTerm(AtomDefault); + AtomDevNull = AtomAdjust(AtomDevNull); TermDevNull = MkAtomTerm(AtomDevNull); + AtomDiff = AtomAdjust(AtomDiff); TermDiff = MkAtomTerm(AtomDiff); + AtomDirectory = AtomAdjust(AtomDirectory); TermDirectory = MkAtomTerm(AtomDirectory); + AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); + AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); + AtomDollar = AtomAdjust(AtomDollar); TermDollar = MkAtomTerm(AtomDollar); + AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); + AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); + AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); + AtomDollarU = AtomAdjust(AtomDollarU); TermDollarU = MkAtomTerm(AtomDollarU); + AtomDollarUndef = AtomAdjust(AtomDollarUndef); TermDollarUndef = MkAtomTerm(AtomDollarUndef); + AtomDomainError = AtomAdjust(AtomDomainError); TermDomainError = MkAtomTerm(AtomDomainError); + AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); + AtomDots = AtomAdjust(AtomDots); TermDots = MkAtomTerm(AtomDots); + AtomDOUBLE = AtomAdjust(AtomDOUBLE); TermDOUBLE = MkAtomTerm(AtomDOUBLE); + AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); + AtomE = AtomAdjust(AtomE); TermE = MkAtomTerm(AtomE); + AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); + AtomEQ = AtomAdjust(AtomEQ); TermEQ = MkAtomTerm(AtomEQ); + AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); + AtomEncoding = AtomAdjust(AtomEncoding); TermEncoding = MkAtomTerm(AtomEncoding); + AtomEndOfStream = AtomAdjust(AtomEndOfStream); TermEndOfStream = MkAtomTerm(AtomEndOfStream); + AtomEof = AtomAdjust(AtomEof); TermEof = MkAtomTerm(AtomEof); + AtomEOfCode = AtomAdjust(AtomEOfCode); TermEOfCode = MkAtomTerm(AtomEOfCode); + AtomEq = AtomAdjust(AtomEq); TermEq = MkAtomTerm(AtomEq); + AtomError = AtomAdjust(AtomError); TermError = MkAtomTerm(AtomError); + AtomException = AtomAdjust(AtomException); TermException = MkAtomTerm(AtomException); + AtomExtensions = AtomAdjust(AtomExtensions); TermExtensions = MkAtomTerm(AtomExtensions); + AtomEvaluable = AtomAdjust(AtomEvaluable); TermEvaluable = MkAtomTerm(AtomEvaluable); + AtomEvaluationError = AtomAdjust(AtomEvaluationError); TermEvaluationError = MkAtomTerm(AtomEvaluationError); + AtomExecutable = AtomAdjust(AtomExecutable); TermExecutable = MkAtomTerm(AtomExecutable); + AtomExecute = AtomAdjust(AtomExecute); TermExecute = MkAtomTerm(AtomExecute); + AtomExecAnswers = AtomAdjust(AtomExecAnswers); TermExecAnswers = MkAtomTerm(AtomExecAnswers); + AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); + AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); + AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); + AtomExist = AtomAdjust(AtomExist); TermExist = MkAtomTerm(AtomExist); + AtomExit = AtomAdjust(AtomExit); TermExit = MkAtomTerm(AtomExit); + AtomExistenceError = AtomAdjust(AtomExistenceError); TermExistenceError = MkAtomTerm(AtomExistenceError); + AtomExoClause = AtomAdjust(AtomExoClause); TermExoClause = MkAtomTerm(AtomExoClause); + AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); + AtomExpand = AtomAdjust(AtomExpand); TermExpand = MkAtomTerm(AtomExpand); + AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); + AtomExtendsions = AtomAdjust(AtomExtendsions); TermExtendsions = MkAtomTerm(AtomExtendsions); + AtomFB = AtomAdjust(AtomFB); TermFB = MkAtomTerm(AtomFB); + AtomFail = AtomAdjust(AtomFail); TermFail = MkAtomTerm(AtomFail); + AtomFalse = AtomAdjust(AtomFalse); TermFalse = MkAtomTerm(AtomFalse); + AtomFast = AtomAdjust(AtomFast); TermFast = MkAtomTerm(AtomFast); + AtomFastFail = AtomAdjust(AtomFastFail); TermFastFail = MkAtomTerm(AtomFastFail); + AtomFileErrors = AtomAdjust(AtomFileErrors); TermFileErrors = MkAtomTerm(AtomFileErrors); + AtomFileerrors = AtomAdjust(AtomFileerrors); TermFileerrors = MkAtomTerm(AtomFileerrors); + AtomFileType = AtomAdjust(AtomFileType); TermFileType = MkAtomTerm(AtomFileType); + AtomFirst = AtomAdjust(AtomFirst); TermFirst = MkAtomTerm(AtomFirst); + AtomFloat = AtomAdjust(AtomFloat); TermFloat = MkAtomTerm(AtomFloat); + AtomFloatFormat = AtomAdjust(AtomFloatFormat); TermFloatFormat = MkAtomTerm(AtomFloatFormat); + AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); + AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); + AtomFormat = AtomAdjust(AtomFormat); TermFormat = MkAtomTerm(AtomFormat); + AtomFormatAt = AtomAdjust(AtomFormatAt); TermFormatAt = MkAtomTerm(AtomFormatAt); + AtomFull = AtomAdjust(AtomFull); TermFull = MkAtomTerm(AtomFull); + AtomFunctor = AtomAdjust(AtomFunctor); TermFunctor = MkAtomTerm(AtomFunctor); + AtomGT = AtomAdjust(AtomGT); TermGT = MkAtomTerm(AtomGT); + AtomGVar = AtomAdjust(AtomGVar); TermGVar = MkAtomTerm(AtomGVar); + AtomGc = AtomAdjust(AtomGc); TermGc = MkAtomTerm(AtomGc); + AtomGcMargin = AtomAdjust(AtomGcMargin); TermGcMargin = MkAtomTerm(AtomGcMargin); + AtomGcTrace = AtomAdjust(AtomGcTrace); TermGcTrace = MkAtomTerm(AtomGcTrace); + AtomGcVerbose = AtomAdjust(AtomGcVerbose); TermGcVerbose = MkAtomTerm(AtomGcVerbose); + AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); + AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); + AtomGetwork = AtomAdjust(AtomGetwork); TermGetwork = MkAtomTerm(AtomGetwork); + AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); + AtomGlob = AtomAdjust(AtomGlob); TermGlob = MkAtomTerm(AtomGlob); + AtomGlobal = AtomAdjust(AtomGlobal); TermGlobal = MkAtomTerm(AtomGlobal); + AtomGlobalSp = AtomAdjust(AtomGlobalSp); TermGlobalSp = MkAtomTerm(AtomGlobalSp); + AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); + AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); + AtomHat = AtomAdjust(AtomHat); TermHat = MkAtomTerm(AtomHat); + AtomHERE = AtomAdjust(AtomHERE); TermHERE = MkAtomTerm(AtomHERE); + AtomHandleThrow = AtomAdjust(AtomHandleThrow); TermHandleThrow = MkAtomTerm(AtomHandleThrow); + AtomHeap = AtomAdjust(AtomHeap); TermHeap = MkAtomTerm(AtomHeap); + AtomHeapUsed = AtomAdjust(AtomHeapUsed); TermHeapUsed = MkAtomTerm(AtomHeapUsed); + AtomHugeInt = AtomAdjust(AtomHugeInt); TermHugeInt = MkAtomTerm(AtomHugeInt); + AtomIDB = AtomAdjust(AtomIDB); TermIDB = MkAtomTerm(AtomIDB); + AtomIOMode = AtomAdjust(AtomIOMode); TermIOMode = MkAtomTerm(AtomIOMode); + AtomId = AtomAdjust(AtomId); TermId = MkAtomTerm(AtomId); + AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore); + AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf); + AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity); + AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal); + AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog); + AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); + AtomInput = AtomAdjust(AtomInput); TermInput = MkAtomTerm(AtomInput); + AtomInstantiationError = AtomAdjust(AtomInstantiationError); TermInstantiationError = MkAtomTerm(AtomInstantiationError); + AtomInt = AtomAdjust(AtomInt); TermInt = MkAtomTerm(AtomInt); + AtomIntOverflow = AtomAdjust(AtomIntOverflow); TermIntOverflow = MkAtomTerm(AtomIntOverflow); + AtomInteger = AtomAdjust(AtomInteger); TermInteger = MkAtomTerm(AtomInteger); + AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); + AtomIs = AtomAdjust(AtomIs); TermIs = MkAtomTerm(AtomIs); + AtomKey = AtomAdjust(AtomKey); TermKey = MkAtomTerm(AtomKey); + AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); + AtomLONGINT = AtomAdjust(AtomLONGINT); TermLONGINT = MkAtomTerm(AtomLONGINT); + AtomLOOP = AtomAdjust(AtomLOOP); TermLOOP = MkAtomTerm(AtomLOOP); + AtomLoopStream = AtomAdjust(AtomLoopStream); TermLoopStream = MkAtomTerm(AtomLoopStream); + AtomLT = AtomAdjust(AtomLT); TermLT = MkAtomTerm(AtomLT); + AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); + AtomLeash = AtomAdjust(AtomLeash); TermLeash = MkAtomTerm(AtomLeash); + AtomLeast = AtomAdjust(AtomLeast); TermLeast = MkAtomTerm(AtomLeast); + AtomLength = AtomAdjust(AtomLength); TermLength = MkAtomTerm(AtomLength); + AtomList = AtomAdjust(AtomList); TermList = MkAtomTerm(AtomList); + AtomLine = AtomAdjust(AtomLine); TermLine = MkAtomTerm(AtomLine); + AtomLive = AtomAdjust(AtomLive); TermLive = MkAtomTerm(AtomLive); + AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); + AtomLocal = AtomAdjust(AtomLocal); TermLocal = MkAtomTerm(AtomLocal); + AtomLocalSp = AtomAdjust(AtomLocalSp); TermLocalSp = MkAtomTerm(AtomLocalSp); + AtomLocalTrie = AtomAdjust(AtomLocalTrie); TermLocalTrie = MkAtomTerm(AtomLocalTrie); + AtomMax = AtomAdjust(AtomMax); TermMax = MkAtomTerm(AtomMax); + AtomMaximum = AtomAdjust(AtomMaximum); TermMaximum = MkAtomTerm(AtomMaximum); + AtomMaxArity = AtomAdjust(AtomMaxArity); TermMaxArity = MkAtomTerm(AtomMaxArity); + AtomMaxFiles = AtomAdjust(AtomMaxFiles); TermMaxFiles = MkAtomTerm(AtomMaxFiles); + AtomMegaClause = AtomAdjust(AtomMegaClause); TermMegaClause = MkAtomTerm(AtomMegaClause); + AtomMetaCall = AtomAdjust(AtomMetaCall); TermMetaCall = MkAtomTerm(AtomMetaCall); + AtomMfClause = AtomAdjust(AtomMfClause); TermMfClause = MkAtomTerm(AtomMfClause); + AtomMin = AtomAdjust(AtomMin); TermMin = MkAtomTerm(AtomMin); + AtomMinimum = AtomAdjust(AtomMinimum); TermMinimum = MkAtomTerm(AtomMinimum); + AtomMinus = AtomAdjust(AtomMinus); TermMinus = MkAtomTerm(AtomMinus); + AtomModify = AtomAdjust(AtomModify); TermModify = MkAtomTerm(AtomModify); + AtomModule = AtomAdjust(AtomModule); TermModule = MkAtomTerm(AtomModule); + AtomMost = AtomAdjust(AtomMost); TermMost = MkAtomTerm(AtomMost); + AtomMulti = AtomAdjust(AtomMulti); TermMulti = MkAtomTerm(AtomMulti); + AtomMultiFile = AtomAdjust(AtomMultiFile); TermMultiFile = MkAtomTerm(AtomMultiFile); + AtomMultiple = AtomAdjust(AtomMultiple); TermMultiple = MkAtomTerm(AtomMultiple); + AtomMutable = AtomAdjust(AtomMutable); TermMutable = MkAtomTerm(AtomMutable); + AtomMutableVariable = AtomAdjust(AtomMutableVariable); TermMutableVariable = MkAtomTerm(AtomMutableVariable); + AtomMutex = AtomAdjust(AtomMutex); TermMutex = MkAtomTerm(AtomMutex); + AtomMyddasDB = AtomAdjust(AtomMyddasDB); TermMyddasDB = MkAtomTerm(AtomMyddasDB); + AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); + AtomMyddasHost = AtomAdjust(AtomMyddasHost); TermMyddasHost = MkAtomTerm(AtomMyddasHost); + AtomMyddasPass = AtomAdjust(AtomMyddasPass); TermMyddasPass = MkAtomTerm(AtomMyddasPass); + AtomMyddasUser = AtomAdjust(AtomMyddasUser); TermMyddasUser = MkAtomTerm(AtomMyddasUser); + AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); + AtomNan = AtomAdjust(AtomNan); TermNan = MkAtomTerm(AtomNan); + AtomNb = AtomAdjust(AtomNb); TermNb = MkAtomTerm(AtomNb); + AtomNbTerm = AtomAdjust(AtomNbTerm); TermNbTerm = MkAtomTerm(AtomNbTerm); + AtomNew = AtomAdjust(AtomNew); TermNew = MkAtomTerm(AtomNew); + AtomNewLine = AtomAdjust(AtomNewLine); TermNewLine = MkAtomTerm(AtomNewLine); + AtomNl = AtomAdjust(AtomNl); TermNl = MkAtomTerm(AtomNl); + AtomNoEffect = AtomAdjust(AtomNoEffect); TermNoEffect = MkAtomTerm(AtomNoEffect); + AtomNoMemory = AtomAdjust(AtomNoMemory); TermNoMemory = MkAtomTerm(AtomNoMemory); + AtomNone = AtomAdjust(AtomNone); TermNone = MkAtomTerm(AtomNone); + AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); + AtomNot = AtomAdjust(AtomNot); TermNot = MkAtomTerm(AtomNot); + AtomNotImplemented = AtomAdjust(AtomNotImplemented); TermNotImplemented = MkAtomTerm(AtomNotImplemented); + AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); + AtomNotNewline = AtomAdjust(AtomNotNewline); TermNotNewline = MkAtomTerm(AtomNotNewline); + AtomNotZero = AtomAdjust(AtomNotZero); TermNotZero = MkAtomTerm(AtomNotZero); + AtomNumber = AtomAdjust(AtomNumber); TermNumber = MkAtomTerm(AtomNumber); + AtomOff = AtomAdjust(AtomOff); TermOff = MkAtomTerm(AtomOff); + AtomOffline = AtomAdjust(AtomOffline); TermOffline = MkAtomTerm(AtomOffline); + AtomOn = AtomAdjust(AtomOn); TermOn = MkAtomTerm(AtomOn); + AtomOnline = AtomAdjust(AtomOnline); TermOnline = MkAtomTerm(AtomOnline); + AtomOpen = AtomAdjust(AtomOpen); TermOpen = MkAtomTerm(AtomOpen); + AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); + AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); + AtomOperator = AtomAdjust(AtomOperator); TermOperator = MkAtomTerm(AtomOperator); + AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); + AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); + AtomOpt = AtomAdjust(AtomOpt); TermOpt = MkAtomTerm(AtomOpt); + AtomOtherwise = AtomAdjust(AtomOtherwise); TermOtherwise = MkAtomTerm(AtomOtherwise); + AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); + AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); + AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); + AtomOutOfRange = AtomAdjust(AtomOutOfRange); TermOutOfRange = MkAtomTerm(AtomOutOfRange); + AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); + AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); + AtomOutput = AtomAdjust(AtomOutput); TermOutput = MkAtomTerm(AtomOutput); + AtomParameter = AtomAdjust(AtomParameter); TermParameter = MkAtomTerm(AtomParameter); + AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); + AtomPast = AtomAdjust(AtomPast); TermPast = MkAtomTerm(AtomPast); + AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); + AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError); + AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi); + AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe); + AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus); + AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer); + AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray); + AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); + AtomPrimitive = AtomAdjust(AtomPrimitive); TermPrimitive = MkAtomTerm(AtomPrimitive); + AtomPrintMessage = AtomAdjust(AtomPrintMessage); TermPrintMessage = MkAtomTerm(AtomPrintMessage); + AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); + AtomProcedure = AtomAdjust(AtomProcedure); TermProcedure = MkAtomTerm(AtomProcedure); + AtomProfile = AtomAdjust(AtomProfile); TermProfile = MkAtomTerm(AtomProfile); + AtomProlog = AtomAdjust(AtomProlog); TermProlog = MkAtomTerm(AtomProlog); + AtomProtectStack = AtomAdjust(AtomProtectStack); TermProtectStack = MkAtomTerm(AtomProtectStack); + AtomQly = AtomAdjust(AtomQly); TermQly = MkAtomTerm(AtomQly); + AtomQuery = AtomAdjust(AtomQuery); TermQuery = MkAtomTerm(AtomQuery); + AtomQueue = AtomAdjust(AtomQueue); TermQueue = MkAtomTerm(AtomQueue); + AtomQuiet = AtomAdjust(AtomQuiet); TermQuiet = MkAtomTerm(AtomQuiet); + AtomRadix = AtomAdjust(AtomRadix); TermRadix = MkAtomTerm(AtomRadix); + AtomRandom = AtomAdjust(AtomRandom); TermRandom = MkAtomTerm(AtomRandom); + AtomRange = AtomAdjust(AtomRange); TermRange = MkAtomTerm(AtomRange); + AtomRDiv = AtomAdjust(AtomRDiv); TermRDiv = MkAtomTerm(AtomRDiv); + AtomRead = AtomAdjust(AtomRead); TermRead = MkAtomTerm(AtomRead); + AtomReadOnly = AtomAdjust(AtomReadOnly); TermReadOnly = MkAtomTerm(AtomReadOnly); + AtomReadWrite = AtomAdjust(AtomReadWrite); TermReadWrite = MkAtomTerm(AtomReadWrite); + AtomReadutil = AtomAdjust(AtomReadutil); TermReadutil = MkAtomTerm(AtomReadutil); + AtomReconsult = AtomAdjust(AtomReconsult); TermReconsult = MkAtomTerm(AtomReconsult); + AtomRecordedP = AtomAdjust(AtomRecordedP); TermRecordedP = MkAtomTerm(AtomRecordedP); + AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); + AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); + AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); + AtomRefoundVar = AtomAdjust(AtomRefoundVar); TermRefoundVar = MkAtomTerm(AtomRefoundVar); + AtomRelativeTo = AtomAdjust(AtomRelativeTo); TermRelativeTo = MkAtomTerm(AtomRelativeTo); + AtomRepeat = AtomAdjust(AtomRepeat); TermRepeat = MkAtomTerm(AtomRepeat); + AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); + AtomReposition = AtomAdjust(AtomReposition); TermReposition = MkAtomTerm(AtomReposition); + AtomRepresentationError = AtomAdjust(AtomRepresentationError); TermRepresentationError = MkAtomTerm(AtomRepresentationError); + AtomReset = AtomAdjust(AtomReset); TermReset = MkAtomTerm(AtomReset); + AtomResize = AtomAdjust(AtomResize); TermResize = MkAtomTerm(AtomResize); + AtomResourceError = AtomAdjust(AtomResourceError); TermResourceError = MkAtomTerm(AtomResourceError); + AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); + AtomRetryCounter = AtomAdjust(AtomRetryCounter); TermRetryCounter = MkAtomTerm(AtomRetryCounter); + AtomRTree = AtomAdjust(AtomRTree); TermRTree = MkAtomTerm(AtomRTree); + AtomSafe = AtomAdjust(AtomSafe); TermSafe = MkAtomTerm(AtomSafe); + AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); + AtomSame = AtomAdjust(AtomSame); TermSame = MkAtomTerm(AtomSame); + AtomSemic = AtomAdjust(AtomSemic); TermSemic = MkAtomTerm(AtomSemic); + AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); + AtomSigAlarm = AtomAdjust(AtomSigAlarm); TermSigAlarm = MkAtomTerm(AtomSigAlarm); + AtomSigBreak = AtomAdjust(AtomSigBreak); TermSigBreak = MkAtomTerm(AtomSigBreak); + AtomSigCreep = AtomAdjust(AtomSigCreep); TermSigCreep = MkAtomTerm(AtomSigCreep); + AtomSigDebug = AtomAdjust(AtomSigDebug); TermSigDebug = MkAtomTerm(AtomSigDebug); + AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); + AtomSigFPE = AtomAdjust(AtomSigFPE); TermSigFPE = MkAtomTerm(AtomSigFPE); + AtomSigHup = AtomAdjust(AtomSigHup); TermSigHup = MkAtomTerm(AtomSigHup); + AtomSigInt = AtomAdjust(AtomSigInt); TermSigInt = MkAtomTerm(AtomSigInt); + AtomSigIti = AtomAdjust(AtomSigIti); TermSigIti = MkAtomTerm(AtomSigIti); + AtomSigPending = AtomAdjust(AtomSigPending); TermSigPending = MkAtomTerm(AtomSigPending); + AtomSigPipe = AtomAdjust(AtomSigPipe); TermSigPipe = MkAtomTerm(AtomSigPipe); + AtomSigStackDump = AtomAdjust(AtomSigStackDump); TermSigStackDump = MkAtomTerm(AtomSigStackDump); + AtomSigStatistics = AtomAdjust(AtomSigStatistics); TermSigStatistics = MkAtomTerm(AtomSigStatistics); + AtomSigTrace = AtomAdjust(AtomSigTrace); TermSigTrace = MkAtomTerm(AtomSigTrace); + AtomSigUsr1 = AtomAdjust(AtomSigUsr1); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); + AtomSigUsr2 = AtomAdjust(AtomSigUsr2); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); + AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); + AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); + AtomSilent = AtomAdjust(AtomSilent); TermSilent = MkAtomTerm(AtomSilent); + AtomSingle = AtomAdjust(AtomSingle); TermSingle = MkAtomTerm(AtomSingle); + AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); + AtomSingleton = AtomAdjust(AtomSingleton); TermSingleton = MkAtomTerm(AtomSingleton); + AtomSlash = AtomAdjust(AtomSlash); TermSlash = MkAtomTerm(AtomSlash); + AtomSocket = AtomAdjust(AtomSocket); TermSocket = MkAtomTerm(AtomSocket); + AtomSolutions = AtomAdjust(AtomSolutions); TermSolutions = MkAtomTerm(AtomSolutions); + AtomSource = AtomAdjust(AtomSource); TermSource = MkAtomTerm(AtomSource); + AtomSourceSink = AtomAdjust(AtomSourceSink); TermSourceSink = MkAtomTerm(AtomSourceSink); + AtomSpy = AtomAdjust(AtomSpy); TermSpy = MkAtomTerm(AtomSpy); + AtomStack = AtomAdjust(AtomStack); TermStack = MkAtomTerm(AtomStack); + AtomStackFree = AtomAdjust(AtomStackFree); TermStackFree = MkAtomTerm(AtomStackFree); + AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); + AtomStaticClause = AtomAdjust(AtomStaticClause); TermStaticClause = MkAtomTerm(AtomStaticClause); + AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); + AtomStream = AtomAdjust(AtomStream); TermStream = MkAtomTerm(AtomStream); + AtomSWIStream = AtomAdjust(AtomSWIStream); TermSWIStream = MkAtomTerm(AtomSWIStream); + AtomVStream = AtomAdjust(AtomVStream); TermVStream = MkAtomTerm(AtomVStream); + AtomStreams = AtomAdjust(AtomStreams); TermStreams = MkAtomTerm(AtomStreams); + AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); + AtomStreamPos = AtomAdjust(AtomStreamPos); TermStreamPos = MkAtomTerm(AtomStreamPos); + AtomStreamPosition = AtomAdjust(AtomStreamPosition); TermStreamPosition = MkAtomTerm(AtomStreamPosition); + AtomString = AtomAdjust(AtomString); TermString = MkAtomTerm(AtomString); + AtomStyleCheck = AtomAdjust(AtomStyleCheck); TermStyleCheck = MkAtomTerm(AtomStyleCheck); + AtomSTRING = AtomAdjust(AtomSTRING); TermSTRING = MkAtomTerm(AtomSTRING); + AtomSwi = AtomAdjust(AtomSwi); TermSwi = MkAtomTerm(AtomSwi); + AtomSymbolChar = AtomAdjust(AtomSymbolChar); TermSymbolChar = MkAtomTerm(AtomSymbolChar); + AtomSyntaxError = AtomAdjust(AtomSyntaxError); TermSyntaxError = MkAtomTerm(AtomSyntaxError); + AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); + AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); + AtomSystem = AtomAdjust(AtomSystem); TermSystem = MkAtomTerm(AtomSystem); + AtomSystemError = AtomAdjust(AtomSystemError); TermSystemError = MkAtomTerm(AtomSystemError); + AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); + AtomTerm = AtomAdjust(AtomTerm); TermTerm = MkAtomTerm(AtomTerm); + AtomTerms = AtomAdjust(AtomTerms); TermTerms = MkAtomTerm(AtomTerms); + AtomTermExpansion = AtomAdjust(AtomTermExpansion); TermTermExpansion = MkAtomTerm(AtomTermExpansion); + AtomText = AtomAdjust(AtomText); TermText = MkAtomTerm(AtomText); + AtomTextStream = AtomAdjust(AtomTextStream); TermTextStream = MkAtomTerm(AtomTextStream); + AtomThread = AtomAdjust(AtomThread); TermThread = MkAtomTerm(AtomThread); + AtomThreads = AtomAdjust(AtomThreads); TermThreads = MkAtomTerm(AtomThreads); + AtomThrow = AtomAdjust(AtomThrow); TermThrow = MkAtomTerm(AtomThrow); + AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); + AtomTimeoutError = AtomAdjust(AtomTimeoutError); TermTimeoutError = MkAtomTerm(AtomTimeoutError); + AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); + AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); + AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); AtomTrail = AtomAdjust(AtomTrail); - AtomTrue = AtomAdjust(AtomTrue); - AtomTty = AtomAdjust(AtomTty); - AtomTtys = AtomAdjust(AtomTtys); - AtomTxt = AtomAdjust(AtomTxt); - AtomTypeError = AtomAdjust(AtomTypeError); - AtomUndefined = AtomAdjust(AtomUndefined); - AtomUndefp = AtomAdjust(AtomUndefp); - AtomUnderflow = AtomAdjust(AtomUnderflow); - AtomUnificationStack = AtomAdjust(AtomUnificationStack); - AtomUnique = AtomAdjust(AtomUnique); - AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); - AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); - AtomUser = AtomAdjust(AtomUser); - AtomUserErr = AtomAdjust(AtomUserErr); - AtomUserIn = AtomAdjust(AtomUserIn); - AtomUserOut = AtomAdjust(AtomUserOut); - AtomDollarVar = AtomAdjust(AtomDollarVar); - AtomVBar = AtomAdjust(AtomVBar); - AtomVarBranches = AtomAdjust(AtomVarBranches); - AtomVariableNames = AtomAdjust(AtomVariableNames); - AtomHiddenVar = AtomAdjust(AtomHiddenVar); - AtomVariable = AtomAdjust(AtomVariable); - AtomVerbose = AtomAdjust(AtomVerbose); - AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); - AtomVersionNumber = AtomAdjust(AtomVersionNumber); - AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); - AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); - AtomWarning = AtomAdjust(AtomWarning); - AtomWhen = AtomAdjust(AtomWhen); - AtomWrite = AtomAdjust(AtomWrite); - AtomXml = AtomAdjust(AtomXml); - AtomYapHacks = AtomAdjust(AtomYapHacks); - AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); + AtomTrue = AtomAdjust(AtomTrue); TermTrue = MkAtomTerm(AtomTrue); + AtomTty = AtomAdjust(AtomTty); TermTty = MkAtomTerm(AtomTty); + AtomTtys = AtomAdjust(AtomTtys); TermTtys = MkAtomTerm(AtomTtys); + AtomTxt = AtomAdjust(AtomTxt); TermTxt = MkAtomTerm(AtomTxt); + AtomTypeError = AtomAdjust(AtomTypeError); TermTypeError = MkAtomTerm(AtomTypeError); + AtomUndefined = AtomAdjust(AtomUndefined); TermUndefined = MkAtomTerm(AtomUndefined); + AtomUndefp = AtomAdjust(AtomUndefp); TermUndefp = MkAtomTerm(AtomUndefp); + AtomUnderflow = AtomAdjust(AtomUnderflow); TermUnderflow = MkAtomTerm(AtomUnderflow); + AtomUnificationStack = AtomAdjust(AtomUnificationStack); TermUnificationStack = MkAtomTerm(AtomUnificationStack); + AtomUnique = AtomAdjust(AtomUnique); TermUnique = MkAtomTerm(AtomUnique); + AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); + AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); + AtomUser = AtomAdjust(AtomUser); TermUser = MkAtomTerm(AtomUser); + AtomUserErr = AtomAdjust(AtomUserErr); TermUserErr = MkAtomTerm(AtomUserErr); + AtomUserIn = AtomAdjust(AtomUserIn); TermUserIn = MkAtomTerm(AtomUserIn); + AtomUserOut = AtomAdjust(AtomUserOut); TermUserOut = MkAtomTerm(AtomUserOut); + AtomDollarVar = AtomAdjust(AtomDollarVar); TermDollarVar = MkAtomTerm(AtomDollarVar); + AtomVBar = AtomAdjust(AtomVBar); TermVBar = MkAtomTerm(AtomVBar); + AtomVarBranches = AtomAdjust(AtomVarBranches); TermVarBranches = MkAtomTerm(AtomVarBranches); + AtomVariableNames = AtomAdjust(AtomVariableNames); TermVariableNames = MkAtomTerm(AtomVariableNames); + AtomHiddenVar = AtomAdjust(AtomHiddenVar); TermHiddenVar = MkAtomTerm(AtomHiddenVar); + AtomVariable = AtomAdjust(AtomVariable); TermVariable = MkAtomTerm(AtomVariable); + AtomVerbose = AtomAdjust(AtomVerbose); TermVerbose = MkAtomTerm(AtomVerbose); + AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); + AtomVersionNumber = AtomAdjust(AtomVersionNumber); TermVersionNumber = MkAtomTerm(AtomVersionNumber); + AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); + AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); + AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning); + AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen); + AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite); + AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml); + AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks); + AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); FunctorAfInet = FuncAdjust(FunctorAfInet); FunctorAfLocal = FuncAdjust(FunctorAfLocal); FunctorAfUnix = FuncAdjust(FunctorAfUnix); @@ -474,6 +477,7 @@ FunctorEq = FuncAdjust(FunctorEq); FunctorError = FuncAdjust(FunctorError); FunctorEvaluationError = FuncAdjust(FunctorEvaluationError); + FunctorException = FuncAdjust(FunctorException); FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod); FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod); FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin); @@ -516,6 +520,7 @@ FunctorPrintMessage = FuncAdjust(FunctorPrintMessage); FunctorProcedure = FuncAdjust(FunctorProcedure); FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint); + FunctorProtectStack = FuncAdjust(FunctorProtectStack); FunctorQuery = FuncAdjust(FunctorQuery); FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey); FunctorRDiv = FuncAdjust(FunctorRDiv); diff --git a/H/generated/rhstruct.h b/H/generated/rhstruct.h index cd2f6b479..2efa87471 100644 --- a/H/generated/rhstruct.h +++ b/H/generated/rhstruct.h @@ -87,6 +87,7 @@ #ifdef EUROTRA TermDollarU = AtomTermAdjust(TermDollarU); #endif + TermAnswer = AtomTermAdjust(TermAnswer); USER_MODULE = AtomTermAdjust(USER_MODULE); IDB_MODULE = AtomTermAdjust(IDB_MODULE); @@ -135,24 +136,25 @@ #ifdef COROUTINING WakeUpCode = PtoPredAdjust(WakeUpCode); #endif - PredGoalExpansion = PtoPredAdjust(PredGoalExpansion); - PredMetaCall = PtoPredAdjust(PredMetaCall); - PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall); PredDollarCatch = PtoPredAdjust(PredDollarCatch); - PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey); - PredLogUpdClause = PtoPredAdjust(PredLogUpdClause); - PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase); - PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0); - PredStaticClause = PtoPredAdjust(PredStaticClause); - PredThrow = PtoPredAdjust(PredThrow); - PredHandleThrow = PtoPredAdjust(PredHandleThrow); - PredIs = PtoPredAdjust(PredIs); - PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup); - PredRestoreRegs = PtoPredAdjust(PredRestoreRegs); - PredCommentHook = PtoPredAdjust(PredCommentHook); #ifdef YAPOR PredGetwork = PtoPredAdjust(PredGetwork); #endif /* YAPOR */ + PredGoalExpansion = PtoPredAdjust(PredGoalExpansion); + PredHandleThrow = PtoPredAdjust(PredHandleThrow); + PredIs = PtoPredAdjust(PredIs); + PredLogUpdClause = PtoPredAdjust(PredLogUpdClause); + PredLogUpdClauseErase = PtoPredAdjust(PredLogUpdClauseErase); + PredLogUpdClause0 = PtoPredAdjust(PredLogUpdClause0); + PredMetaCall = PtoPredAdjust(PredMetaCall); + PredProtectStack = PtoPredAdjust(PredProtectStack); + PredRecordedWithKey = PtoPredAdjust(PredRecordedWithKey); + PredRestoreRegs = PtoPredAdjust(PredRestoreRegs); + PredSafeCallCleanup = PtoPredAdjust(PredSafeCallCleanup); + PredStaticClause = PtoPredAdjust(PredStaticClause); + PredThrow = PtoPredAdjust(PredThrow); + PredTraceMetaCall = PtoPredAdjust(PredTraceMetaCall); + PredCommentHook = PtoPredAdjust(PredCommentHook); PredProcedure = PtoPredAdjust(PredProcedure); #ifdef LOW_LEVEL_TRACER diff --git a/H/generated/tatoms.h b/H/generated/tatoms.h index a4f8ef031..a78e7f28b 100644 --- a/H/generated/tatoms.h +++ b/H/generated/tatoms.h @@ -1,1506 +1,685 @@ /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" - please do not update, update misc/ATOMS instead */ + {lease do not update, update misc/ATOMS instead */ + +Atom Atom3Dots; +Atom AtomAbol; Term TermAbol; +Atom AtomAccess; Term TermAccess; +Atom AtomAfInet; Term TermAfInet; +Atom AtomAfLocal; Term TermAfLocal; +Atom AtomAfUnix; Term TermAfUnix; +Atom AtomAlarm; Term TermAlarm; +Atom AtomAlias; Term TermAlias; +Atom AtomAll; Term TermAll; +Atom AtomAltNot; Term TermAltNot; +Atom AtomAnswer; Term TermAnswer; +Atom AtomAny; Term TermAny; +Atom AtomAppend; Term TermAppend; +Atom AtomArg; Term TermArg; +Atom AtomArray; Term TermArray; +Atom AtomArrayAccess; Term TermArrayAccess; +Atom AtomArrayOverflow; Term TermArrayOverflow; +Atom AtomArrayType; Term TermArrayType; +Atom AtomArrow; Term TermArrow; +Atom AtomAttributedModule; Term TermAttributedModule; +Atom AtomDoubleArrow; Term TermDoubleArrow; +Atom AtomAssert; Term TermAssert; +Atom AtomEmptyBrackets; Term TermEmptyBrackets; +Atom AtomEmptySquareBrackets; Term TermEmptySquareBrackets; +Atom AtomEmptyCurlyBrackets; Term TermEmptyCurlyBrackets; +Atom AtomAsserta; Term TermAsserta; +Atom AtomAssertaStatic; Term TermAssertaStatic; +Atom AtomAssertz; Term TermAssertz; +Atom AtomAssertzStatic; Term TermAssertzStatic; +Atom AtomAt; Term TermAt; +Atom AtomAtom; Term TermAtom; +Atom AtomAtomic; Term TermAtomic; +Atom AtomAtt; Term TermAtt; +Atom AtomAtt1; Term TermAtt1; +Atom AtomAttDo; Term TermAttDo; +Atom AtomAttributes; Term TermAttributes; +Atom AtomB; Term TermB; +Atom AtomBatched; Term TermBatched; +Atom AtomBetween; Term TermBetween; +Atom AtomBinary; Term TermBinary; +Atom AtomBigNum; Term TermBigNum; +Atom AtomBinaryStream; Term TermBinaryStream; +Atom AtomBoolean; Term TermBoolean; +Atom AtomBraces; Term TermBraces; +Atom AtomBreak; Term TermBreak; +Atom AtomByte; Term TermByte; +Atom AtomCArith; Term TermCArith; +Atom AtomCall; Term TermCall; +Atom AtomCallAndRetryCounter; Term TermCallAndRetryCounter; +Atom AtomCallCounter; Term TermCallCounter; +Atom AtomCallable; Term TermCallable; +Atom AtomCatch; Term TermCatch; +Atom AtomChangeModule; Term TermChangeModule; +Atom AtomChar; Term TermChar; +Atom AtomCharsio; Term TermCharsio; +Atom AtomCharacter; Term TermCharacter; +Atom AtomCharacterCode; Term TermCharacterCode; +Atom AtomChars; Term TermChars; +Atom AtomCharset; Term TermCharset; +Atom AtomChType; Term TermChType; +Atom AtomCleanCall; Term TermCleanCall; +Atom AtomColomn; Term TermColomn; +Atom AtomCodeSpace; Term TermCodeSpace; +Atom AtomCodes; Term TermCodes; +Atom AtomCoInductive; Term TermCoInductive; +Atom AtomComma; Term TermComma; +Atom AtomCommentHook; Term TermCommentHook; +Atom AtomCompact; Term TermCompact; +Atom AtomCompound; Term TermCompound; +Atom AtomConsistencyError; Term TermConsistencyError; +Atom AtomConsult; Term TermConsult; +Atom AtomConsultOnBoot; Term TermConsultOnBoot; +Atom AtomContext; Term TermContext; +Atom AtomCputime; Term TermCputime; +Atom AtomCreate; Term TermCreate; +Atom AtomCreep; Term TermCreep; +Atom AtomCryptAtoms; Term TermCryptAtoms; +Atom AtomCsult; Term TermCsult; +Atom AtomCurrentModule; Term TermCurrentModule; +Atom AtomCut; Term TermCut; +Atom AtomCutBy; Term TermCutBy; +Atom AtomDAbort; Term TermDAbort; +Atom AtomDBLoad; Term TermDBLoad; +Atom AtomDBREF; Term TermDBREF; +Atom AtomDBReference; Term TermDBReference; +Atom AtomDBTerm; Term TermDBTerm; +Atom AtomDBref; Term TermDBref; +Atom AtomDInteger; Term TermDInteger; +Atom AtomDebugMeta; Term TermDebugMeta; +Atom AtomDebuggerInput; Term TermDebuggerInput; +Atom AtomDec10; Term TermDec10; +Atom AtomDefault; Term TermDefault; +Atom AtomDevNull; Term TermDevNull; +Atom AtomDiff; Term TermDiff; +Atom AtomDirectory; Term TermDirectory; +Atom AtomDiscontiguous; Term TermDiscontiguous; +Atom AtomDiscontiguousWarnings; Term TermDiscontiguousWarnings; +Atom AtomDollar; Term TermDollar; +Atom AtomDoLogUpdClause; Term TermDoLogUpdClause; +Atom AtomDoLogUpdClause0; Term TermDoLogUpdClause0; +Atom AtomDoLogUpdClauseErase; Term TermDoLogUpdClauseErase; +Atom AtomDollarU; Term TermDollarU; +Atom AtomDollarUndef; Term TermDollarUndef; +Atom AtomDomainError; Term TermDomainError; +Atom AtomDoStaticClause; Term TermDoStaticClause; +Atom AtomDots; Term TermDots; +Atom AtomDOUBLE; Term TermDOUBLE; +Atom AtomDoubleSlash; Term TermDoubleSlash; +Atom AtomE; Term TermE; +Atom AtomEOFBeforeEOT; Term TermEOFBeforeEOT; +Atom AtomEQ; Term TermEQ; +Atom AtomEmptyAtom; Term TermEmptyAtom; +Atom AtomEncoding; Term TermEncoding; +Atom AtomEndOfStream; Term TermEndOfStream; +Atom AtomEof; Term TermEof; +Atom AtomEOfCode; Term TermEOfCode; +Atom AtomEq; Term TermEq; +Atom AtomError; Term TermError; +Atom AtomException; Term TermException; +Atom AtomExtensions; Term TermExtensions; +Atom AtomEvaluable; Term TermEvaluable; +Atom AtomEvaluationError; Term TermEvaluationError; +Atom AtomExecutable; Term TermExecutable; +Atom AtomExecute; Term TermExecute; +Atom AtomExecAnswers; Term TermExecAnswers; +Atom AtomExecuteInMod; Term TermExecuteInMod; +Atom AtomExecuteWithin; Term TermExecuteWithin; +Atom AtomExecuteWoMod; Term TermExecuteWoMod; +Atom AtomExist; Term TermExist; +Atom AtomExit; Term TermExit; +Atom AtomExistenceError; Term TermExistenceError; +Atom AtomExoClause; Term TermExoClause; +Atom AtomExpectedNumber; Term TermExpectedNumber; +Atom AtomExpand; Term TermExpand; +Atom AtomExtendFileSearchPath; Term TermExtendFileSearchPath; +Atom AtomExtendsions; Term TermExtendsions; +Atom AtomFB; Term TermFB; +Atom AtomFail; Term TermFail; +Atom AtomFalse; Term TermFalse; +Atom AtomFast; Term TermFast; +Atom AtomFastFail; Term TermFastFail; +Atom AtomFileErrors; Term TermFileErrors; +Atom AtomFileerrors; Term TermFileerrors; +Atom AtomFileType; Term TermFileType; +Atom AtomFirst; Term TermFirst; +Atom AtomFloat; Term TermFloat; +Atom AtomFloatFormat; Term TermFloatFormat; +Atom AtomFloatOverflow; Term TermFloatOverflow; +Atom AtomFloatUnderflow; Term TermFloatUnderflow; +Atom AtomFormat; Term TermFormat; +Atom AtomFormatAt; Term TermFormatAt; +Atom AtomFull; Term TermFull; +Atom AtomFunctor; Term TermFunctor; +Atom AtomGT; Term TermGT; +Atom AtomGVar; Term TermGVar; +Atom AtomGc; Term TermGc; +Atom AtomGcMargin; Term TermGcMargin; +Atom AtomGcTrace; Term TermGcTrace; +Atom AtomGcVerbose; Term TermGcVerbose; +Atom AtomGcVeryVerbose; Term TermGcVeryVerbose; +Atom AtomGeneratePredInfo; Term TermGeneratePredInfo; +Atom AtomGetwork; Term TermGetwork; +Atom AtomGetworkSeq; Term TermGetworkSeq; +Atom AtomGlob; Term TermGlob; +Atom AtomGlobal; Term TermGlobal; +Atom AtomGlobalSp; Term TermGlobalSp; +Atom AtomGlobalTrie; Term TermGlobalTrie; +Atom AtomGoalExpansion; Term TermGoalExpansion; +Atom AtomHat; Term TermHat; +Atom AtomHERE; Term TermHERE; +Atom AtomHandleThrow; Term TermHandleThrow; +Atom AtomHeap; Term TermHeap; +Atom AtomHeapUsed; Term TermHeapUsed; +Atom AtomHugeInt; Term TermHugeInt; +Atom AtomIDB; Term TermIDB; +Atom AtomIOMode; Term TermIOMode; +Atom AtomId; Term TermId; +Atom AtomIgnore; Term TermIgnore; +Atom AtomInf; Term TermInf; +Atom AtomInfinity; Term TermInfinity; +Atom AtomInitGoal; Term TermInitGoal; +Atom AtomInitProlog; Term TermInitProlog; +Atom AtomInStackExpansion; Term TermInStackExpansion; +Atom AtomInput; Term TermInput; +Atom AtomInstantiationError; Term TermInstantiationError; +Atom AtomInt; Term TermInt; +Atom AtomIntOverflow; Term TermIntOverflow; +Atom AtomInteger; Term TermInteger; +Atom AtomInternalCompilerError; Term TermInternalCompilerError; +Atom AtomIs; Term TermIs; +Atom AtomKey; Term TermKey; +Atom AtomLDLibraryPath; Term TermLDLibraryPath; +Atom AtomLONGINT; Term TermLONGINT; +Atom AtomLOOP; Term TermLOOP; +Atom AtomLoopStream; Term TermLoopStream; +Atom AtomLT; Term TermLT; +Atom AtomLastExecuteWithin; Term TermLastExecuteWithin; +Atom AtomLeash; Term TermLeash; +Atom AtomLeast; Term TermLeast; +Atom AtomLength; Term TermLength; +Atom AtomList; Term TermList; +Atom AtomLine; Term TermLine; +Atom AtomLive; Term TermLive; +Atom AtomLoadAnswers; Term TermLoadAnswers; +Atom AtomLocal; Term TermLocal; +Atom AtomLocalSp; Term TermLocalSp; +Atom AtomLocalTrie; Term TermLocalTrie; +Atom AtomMax; Term TermMax; +Atom AtomMaximum; Term TermMaximum; +Atom AtomMaxArity; Term TermMaxArity; +Atom AtomMaxFiles; Term TermMaxFiles; +Atom AtomMegaClause; Term TermMegaClause; +Atom AtomMetaCall; Term TermMetaCall; +Atom AtomMfClause; Term TermMfClause; +Atom AtomMin; Term TermMin; +Atom AtomMinimum; Term TermMinimum; +Atom AtomMinus; Term TermMinus; +Atom AtomModify; Term TermModify; +Atom AtomModule; Term TermModule; +Atom AtomMost; Term TermMost; +Atom AtomMulti; Term TermMulti; +Atom AtomMultiFile; Term TermMultiFile; +Atom AtomMultiple; Term TermMultiple; +Atom AtomMutable; Term TermMutable; +Atom AtomMutableVariable; Term TermMutableVariable; +Atom AtomMutex; Term TermMutex; +Atom AtomMyddasDB; Term TermMyddasDB; +Atom AtomMyddasGoal; Term TermMyddasGoal; +Atom AtomMyddasHost; Term TermMyddasHost; +Atom AtomMyddasPass; Term TermMyddasPass; +Atom AtomMyddasUser; Term TermMyddasUser; +Atom AtomMyddasVersionName; Term TermMyddasVersionName; +Atom AtomNan; Term TermNan; +Atom AtomNb; Term TermNb; +Atom AtomNbTerm; Term TermNbTerm; +Atom AtomNew; Term TermNew; +Atom AtomNewLine; Term TermNewLine; +Atom AtomNl; Term TermNl; +Atom AtomNoEffect; Term TermNoEffect; +Atom AtomNoMemory; Term TermNoMemory; +Atom AtomNone; Term TermNone; +Atom AtomNonEmptyList; Term TermNonEmptyList; +Atom AtomNot; Term TermNot; +Atom AtomNotImplemented; Term TermNotImplemented; +Atom AtomNotLessThanZero; Term TermNotLessThanZero; +Atom AtomNotNewline; Term TermNotNewline; +Atom AtomNotZero; Term TermNotZero; +Atom AtomNumber; Term TermNumber; +Atom AtomOff; Term TermOff; +Atom AtomOffline; Term TermOffline; +Atom AtomOn; Term TermOn; +Atom AtomOnline; Term TermOnline; +Atom AtomOpen; Term TermOpen; +Atom AtomOperatingSystemError; Term TermOperatingSystemError; +Atom AtomOperatingSystemSupport; Term TermOperatingSystemSupport; +Atom AtomOperator; Term TermOperator; +Atom AtomOperatorPriority; Term TermOperatorPriority; +Atom AtomOperatorSpecifier; Term TermOperatorSpecifier; +Atom AtomOpt; Term TermOpt; +Atom AtomOtherwise; Term TermOtherwise; +Atom AtomOutOfAttvarsError; Term TermOutOfAttvarsError; +Atom AtomOutOfAuxspaceError; Term TermOutOfAuxspaceError; +Atom AtomOutOfHeapError; Term TermOutOfHeapError; +Atom AtomOutOfRange; Term TermOutOfRange; +Atom AtomOutOfStackError; Term TermOutOfStackError; +Atom AtomOutOfTrailError; Term TermOutOfTrailError; +Atom AtomOutput; Term TermOutput; +Atom AtomParameter; Term TermParameter; +Atom AtomPrologCommonsDir; Term TermPrologCommonsDir; +Atom AtomPast; Term TermPast; +Atom AtomPastEndOfStream; Term TermPastEndOfStream; +Atom AtomPermissionError; Term TermPermissionError; +Atom AtomPi; Term TermPi; +Atom AtomPipe; Term TermPipe; +Atom AtomPlus; Term TermPlus; +Atom AtomPointer; Term TermPointer; +Atom AtomPortray; Term TermPortray; +Atom AtomPredicateIndicator; Term TermPredicateIndicator; +Atom AtomPrimitive; Term TermPrimitive; +Atom AtomPrintMessage; Term TermPrintMessage; +Atom AtomPrivateProcedure; Term TermPrivateProcedure; +Atom AtomProcedure; Term TermProcedure; +Atom AtomProfile; Term TermProfile; +Atom AtomProlog; Term TermProlog; +Atom AtomProtectStack; Term TermProtectStack; +Atom AtomQly; Term TermQly; +Atom AtomQuery; Term TermQuery; +Atom AtomQueue; Term TermQueue; +Atom AtomQuiet; Term TermQuiet; +Atom AtomRadix; Term TermRadix; +Atom AtomRandom; Term TermRandom; +Atom AtomRange; Term TermRange; +Atom AtomRDiv; Term TermRDiv; +Atom AtomRead; Term TermRead; +Atom AtomReadOnly; Term TermReadOnly; +Atom AtomReadWrite; Term TermReadWrite; +Atom AtomReadutil; Term TermReadutil; +Atom AtomReconsult; Term TermReconsult; +Atom AtomRecordedP; Term TermRecordedP; +Atom AtomRecordedWithKey; Term TermRecordedWithKey; +Atom AtomRedefineWarnings; Term TermRedefineWarnings; +Atom AtomRedoFreeze; Term TermRedoFreeze; +Atom AtomRefoundVar; Term TermRefoundVar; +Atom AtomRelativeTo; Term TermRelativeTo; +Atom AtomRepeat; Term TermRepeat; +Atom AtomRepeatSpace; Term TermRepeatSpace; +Atom AtomReposition; Term TermReposition; +Atom AtomRepresentationError; Term TermRepresentationError; +Atom AtomReset; Term TermReset; +Atom AtomResize; Term TermResize; +Atom AtomResourceError; Term TermResourceError; +Atom AtomRestoreRegs; Term TermRestoreRegs; +Atom AtomRetryCounter; Term TermRetryCounter; +Atom AtomRTree; Term TermRTree; +Atom AtomSafe; Term TermSafe; +Atom AtomSafeCallCleanup; Term TermSafeCallCleanup; +Atom AtomSame; Term TermSame; +Atom AtomSemic; Term TermSemic; +Atom AtomShiftCountOverflow; Term TermShiftCountOverflow; +Atom AtomSigAlarm; Term TermSigAlarm; +Atom AtomSigBreak; Term TermSigBreak; +Atom AtomSigCreep; Term TermSigCreep; +Atom AtomSigDebug; Term TermSigDebug; +Atom AtomSigDelayCreep; Term TermSigDelayCreep; +Atom AtomSigFPE; Term TermSigFPE; +Atom AtomSigHup; Term TermSigHup; +Atom AtomSigInt; Term TermSigInt; +Atom AtomSigIti; Term TermSigIti; +Atom AtomSigPending; Term TermSigPending; +Atom AtomSigPipe; Term TermSigPipe; +Atom AtomSigStackDump; Term TermSigStackDump; +Atom AtomSigStatistics; Term TermSigStatistics; +Atom AtomSigTrace; Term TermSigTrace; +Atom AtomSigUsr1; Term TermSigUsr1; +Atom AtomSigUsr2; Term TermSigUsr2; +Atom AtomSigVTAlarm; Term TermSigVTAlarm; +Atom AtomSigWakeUp; Term TermSigWakeUp; +Atom AtomSilent; Term TermSilent; +Atom AtomSingle; Term TermSingle; +Atom AtomSingleVarWarnings; Term TermSingleVarWarnings; +Atom AtomSingleton; Term TermSingleton; +Atom AtomSlash; Term TermSlash; +Atom AtomSocket; Term TermSocket; +Atom AtomSolutions; Term TermSolutions; +Atom AtomSource; Term TermSource; +Atom AtomSourceSink; Term TermSourceSink; +Atom AtomSpy; Term TermSpy; +Atom AtomStack; Term TermStack; +Atom AtomStackFree; Term TermStackFree; +Atom AtomStartupSavedState; Term TermStartupSavedState; +Atom AtomStaticClause; Term TermStaticClause; +Atom AtomStaticProcedure; Term TermStaticProcedure; +Atom AtomStream; Term TermStream; +Atom AtomSWIStream; Term TermSWIStream; +Atom AtomVStream; Term TermVStream; +Atom AtomStreams; Term TermStreams; +Atom AtomStreamOrAlias; Term TermStreamOrAlias; +Atom AtomStreamPos; Term TermStreamPos; +Atom AtomStreamPosition; Term TermStreamPosition; +Atom AtomString; Term TermString; +Atom AtomStyleCheck; Term TermStyleCheck; +Atom AtomSTRING; Term TermSTRING; +Atom AtomSwi; Term TermSwi; +Atom AtomSymbolChar; Term TermSymbolChar; +Atom AtomSyntaxError; Term TermSyntaxError; +Atom AtomSyntaxErrors; Term TermSyntaxErrors; +Atom AtomSyntaxErrorHandler; Term TermSyntaxErrorHandler; +Atom AtomSystem; Term TermSystem; +Atom AtomSystemError; Term TermSystemError; +Atom AtomSystemLibraryDir; Term TermSystemLibraryDir; +Atom AtomTerm; Term TermTerm; +Atom AtomTerms; Term TermTerms; +Atom AtomTermExpansion; Term TermTermExpansion; +Atom AtomText; Term TermText; +Atom AtomTextStream; Term TermTextStream; +Atom AtomThread; Term TermThread; +Atom AtomThreads; Term TermThreads; +Atom AtomThrow; Term TermThrow; +Atom AtomTimeOutSpec; Term TermTimeOutSpec; +Atom AtomTimeoutError; Term TermTimeoutError; +Atom AtomTopLevelGoal; Term TermTopLevelGoal; +Atom AtomTopThreadGoal; Term TermTopThreadGoal; +Atom AtomTraceMetaCall; Term TermTraceMetaCall; +Atom AtomTrail; +Atom AtomTrue; Term TermTrue; +Atom AtomTty; Term TermTty; +Atom AtomTtys; Term TermTtys; +Atom AtomTxt; Term TermTxt; +Atom AtomTypeError; Term TermTypeError; +Atom AtomUndefined; Term TermUndefined; +Atom AtomUndefp; Term TermUndefp; +Atom AtomUnderflow; Term TermUnderflow; +Atom AtomUnificationStack; Term TermUnificationStack; +Atom AtomUnique; Term TermUnique; +Atom AtomUnsignedByte; Term TermUnsignedByte; +Atom AtomUnsignedChar; Term TermUnsignedChar; +Atom AtomUser; Term TermUser; +Atom AtomUserErr; Term TermUserErr; +Atom AtomUserIn; Term TermUserIn; +Atom AtomUserOut; Term TermUserOut; +Atom AtomDollarVar; Term TermDollarVar; +Atom AtomVBar; Term TermVBar; +Atom AtomVarBranches; Term TermVarBranches; +Atom AtomVariableNames; Term TermVariableNames; +Atom AtomHiddenVar; Term TermHiddenVar; +Atom AtomVariable; Term TermVariable; +Atom AtomVerbose; Term TermVerbose; +Atom AtomVerboseFileSearch; Term TermVerboseFileSearch; +Atom AtomVersionNumber; Term TermVersionNumber; +Atom AtomVeryVerbose; Term TermVeryVerbose; +Atom AtomWakeUpGoal; Term TermWakeUpGoal; +Atom AtomWarning; Term TermWarning; +Atom AtomWhen; Term TermWhen; +Atom AtomWrite; Term TermWrite; +Atom AtomXml; Term TermXml; +Atom AtomYapHacks; Term TermYapHacks; +Atom AtomZeroDivisor; Term TermZeroDivisor; + Functor FunctorAfInet; + + Functor FunctorAfLocal; + + Functor FunctorAfUnix; + + Functor FunctorAltNot; + + Functor FunctorArg; + + Functor FunctorArrayEntry; + + Functor FunctorArrow; + + Functor FunctorDoubleArrow; + + Functor FunctorAssert1; + + Functor FunctorAssert; + + Functor FunctorAtFoundOne; + + Functor FunctorAtom; + + Functor FunctorAtt1; + + Functor FunctorAttGoal; + + Functor FunctorBraces; + + Functor FunctorCall; + + Functor FunctorCatch; + + Functor FunctorChangeModule; + + Functor FunctorChars; + + Functor FunctorChars1; + + Functor FunctorCleanCall; + + Functor FunctorClist; + + Functor FunctorCodes; + + Functor FunctorCodes1; + + Functor FunctorComma; + + Functor FunctorCommentHook; + + Functor FunctorContext2; + + Functor FunctorConsistencyError; + + Functor FunctorCreep; + + Functor FunctorCsult; + + Functor FunctorCurrentModule; + + Functor FunctorCutBy; + + Functor FunctorDBREF; + + Functor FunctorDiff; + + Functor FunctorDoLogUpdClause; + + Functor FunctorDoLogUpdClause0; + + Functor FunctorDoLogUpdClauseErase; + + Functor FunctorDoStaticClause; + + Functor FunctorDollarVar; + + Functor FunctorDomainError; + + Functor FunctorDot; + + Functor FunctorDot10; + + Functor FunctorDot11; + + Functor FunctorDot12; + + Functor FunctorDot2; + + Functor FunctorDot3; + + Functor FunctorDot4; + + Functor FunctorDot5; + + Functor FunctorDot6; + + Functor FunctorDot7; + + Functor FunctorDot8; + + Functor FunctorDot9; + + Functor FunctorDoubleSlash; + + Functor FunctorEmptySquareBrackets; + + Functor FunctorEmptyCurlyBrackets; + + Functor FunctorEq; + + Functor FunctorError; + + Functor FunctorEvaluationError; + + Functor FunctorException; + + Functor FunctorExecute2InMod; + + Functor FunctorExecuteInMod; + + Functor FunctorExecuteWithin; + + Functor FunctorExistenceError; + + Functor FunctorExoClause; + + Functor FunctorFunctor; + + Functor FunctorGAtom; + + Functor FunctorGAtomic; + + Functor FunctorGCompound; + + Functor FunctorGFloat; + + Functor FunctorGFormatAt; + + Functor FunctorGInteger; + + Functor FunctorGNumber; + + Functor FunctorGPrimitive; + + Functor FunctorGVar; + + Functor FunctorGeneratePredInfo; + + Functor FunctorGoalExpansion2; + + Functor FunctorGoalExpansion; + + Functor FunctorHandleThrow; + + Functor FunctorHat; + + Functor FunctorId; + + Functor FunctorIs; + + Functor FunctorLastExecuteWithin; + + Functor FunctorList; + + Functor FunctorLOOP; + + Functor FunctorMegaClause; + + Functor FunctorMetaCall; + + Functor FunctorMinus; + + Functor FunctorModule; + + Functor FunctorMultiFileClause; + + Functor FunctorMutable; + + Functor FunctorMutex; + + Functor FunctorNotImplemented; + + Functor FunctorNBQueue; + + Functor FunctorNot; + + Functor FunctorOr; + + Functor FunctorPermissionError; + + Functor FunctorPlus; + + Functor FunctorPortray; + + Functor FunctorPrintMessage; + + Functor FunctorProcedure; + + Functor FunctorPrologConstraint; + + Functor FunctorProtectStack; + + Functor FunctorQuery; + + Functor FunctorRecordedWithKey; + + Functor FunctorRDiv; + + Functor FunctorRedoFreeze; + + Functor FunctorRepresentationError; + + Functor FunctorResourceError; + + Functor FunctorRestoreRegs; + + Functor FunctorRestoreRegs1; + + Functor FunctorSafe; + + Functor FunctorSafeCallCleanup; + + Functor FunctorSame; + + Functor FunctorSlash; + + Functor FunctorStaticClause; + + Functor FunctorStream; + + Functor FunctorStreamEOS; + + Functor FunctorStreamPos; + + Functor FunctorString1; + + Functor FunctorStyleCheck; + + Functor FunctorSyntaxError; + + Functor FunctorShortSyntaxError; + + Functor FunctorTermExpansion; + + Functor FunctorThreadRun; + + Functor FunctorThrow; + + Functor FunctorTimeoutError; + + Functor FunctorTraceMetaCall; + + Functor FunctorTypeError; + + Functor FunctorUMinus; + + Functor FunctorUPlus; + + Functor FunctorVBar; + + Functor FunctorHiddenVar; - Atom Atom3Dots_; -#define Atom3Dots Yap_heap_regs->Atom3Dots_ -#define Term3Dots MkAtomTerm( Yap_heap_regs->Atom3Dots_ ) - Atom AtomAbol_; -#define AtomAbol Yap_heap_regs->AtomAbol_ -#define TermAbol MkAtomTerm( Yap_heap_regs->AtomAbol_ ) - Atom AtomAccess_; -#define AtomAccess Yap_heap_regs->AtomAccess_ -#define TermAccess MkAtomTerm( Yap_heap_regs->AtomAccess_ ) - Atom AtomAfInet_; -#define AtomAfInet Yap_heap_regs->AtomAfInet_ -#define TermAfInet MkAtomTerm( Yap_heap_regs->AtomAfInet_ ) - Atom AtomAfLocal_; -#define AtomAfLocal Yap_heap_regs->AtomAfLocal_ -#define TermAfLocal MkAtomTerm( Yap_heap_regs->AtomAfLocal_ ) - Atom AtomAfUnix_; -#define AtomAfUnix Yap_heap_regs->AtomAfUnix_ -#define TermAfUnix MkAtomTerm( Yap_heap_regs->AtomAfUnix_ ) - Atom AtomAlarm_; -#define AtomAlarm Yap_heap_regs->AtomAlarm_ -#define TermAlarm MkAtomTerm( Yap_heap_regs->AtomAlarm_ ) - Atom AtomAlias_; -#define AtomAlias Yap_heap_regs->AtomAlias_ -#define TermAlias MkAtomTerm( Yap_heap_regs->AtomAlias_ ) - Atom AtomAll_; -#define AtomAll Yap_heap_regs->AtomAll_ -#define TermAll MkAtomTerm( Yap_heap_regs->AtomAll_ ) - Atom AtomAltNot_; -#define AtomAltNot Yap_heap_regs->AtomAltNot_ -#define TermAltNot MkAtomTerm( Yap_heap_regs->AtomAltNot_ ) - Atom AtomAny_; -#define AtomAny Yap_heap_regs->AtomAny_ -#define TermAny MkAtomTerm( Yap_heap_regs->AtomAny_ ) - Atom AtomAppend_; -#define AtomAppend Yap_heap_regs->AtomAppend_ -#define TermAppend MkAtomTerm( Yap_heap_regs->AtomAppend_ ) - Atom AtomArg_; -#define AtomArg Yap_heap_regs->AtomArg_ -#define TermArg MkAtomTerm( Yap_heap_regs->AtomArg_ ) - Atom AtomArray_; -#define AtomArray Yap_heap_regs->AtomArray_ -#define TermArray MkAtomTerm( Yap_heap_regs->AtomArray_ ) - Atom AtomArrayAccess_; -#define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_ -#define TermArrayAccess MkAtomTerm( Yap_heap_regs->AtomArrayAccess_ ) - Atom AtomArrayOverflow_; -#define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_ -#define TermArrayOverflow MkAtomTerm( Yap_heap_regs->AtomArrayOverflow_ ) - Atom AtomArrayType_; -#define AtomArrayType Yap_heap_regs->AtomArrayType_ -#define TermArrayType MkAtomTerm( Yap_heap_regs->AtomArrayType_ ) - Atom AtomArrow_; -#define AtomArrow Yap_heap_regs->AtomArrow_ -#define TermArrow MkAtomTerm( Yap_heap_regs->AtomArrow_ ) - Atom AtomAttributedModule_; -#define AtomAttributedModule Yap_heap_regs->AtomAttributedModule_ -#define TermAttributedModule MkAtomTerm( Yap_heap_regs->AtomAttributedModule_ ) - Atom AtomDoubleArrow_; -#define AtomDoubleArrow Yap_heap_regs->AtomDoubleArrow_ -#define TermDoubleArrow MkAtomTerm( Yap_heap_regs->AtomDoubleArrow_ ) - Atom AtomAssert_; -#define AtomAssert Yap_heap_regs->AtomAssert_ -#define TermAssert MkAtomTerm( Yap_heap_regs->AtomAssert_ ) - Atom AtomEmptyBrackets_; -#define AtomEmptyBrackets Yap_heap_regs->AtomEmptyBrackets_ -#define TermEmptyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyBrackets_ ) - Atom AtomEmptySquareBrackets_; -#define AtomEmptySquareBrackets Yap_heap_regs->AtomEmptySquareBrackets_ -#define TermEmptySquareBrackets MkAtomTerm( Yap_heap_regs->AtomEmptySquareBrackets_ ) - Atom AtomEmptyCurlyBrackets_; -#define AtomEmptyCurlyBrackets Yap_heap_regs->AtomEmptyCurlyBrackets_ -#define TermEmptyCurlyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyCurlyBrackets_ ) - Atom 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_ -#define TermAt MkAtomTerm( Yap_heap_regs->AtomAt_ ) - Atom AtomAtom_; -#define AtomAtom Yap_heap_regs->AtomAtom_ -#define TermAtom MkAtomTerm( Yap_heap_regs->AtomAtom_ ) - Atom AtomAtomic_; -#define AtomAtomic Yap_heap_regs->AtomAtomic_ -#define TermAtomic MkAtomTerm( Yap_heap_regs->AtomAtomic_ ) - Atom AtomAtt_; -#define AtomAtt Yap_heap_regs->AtomAtt_ -#define TermAtt MkAtomTerm( Yap_heap_regs->AtomAtt_ ) - Atom AtomAtt1_; -#define AtomAtt1 Yap_heap_regs->AtomAtt1_ -#define TermAtt1 MkAtomTerm( Yap_heap_regs->AtomAtt1_ ) - Atom AtomAttDo_; -#define AtomAttDo Yap_heap_regs->AtomAttDo_ -#define TermAttDo MkAtomTerm( Yap_heap_regs->AtomAttDo_ ) - Atom AtomAttributes_; -#define AtomAttributes Yap_heap_regs->AtomAttributes_ -#define TermAttributes MkAtomTerm( Yap_heap_regs->AtomAttributes_ ) - Atom AtomB_; -#define AtomB Yap_heap_regs->AtomB_ -#define TermB MkAtomTerm( Yap_heap_regs->AtomB_ ) - Atom AtomBatched_; -#define AtomBatched Yap_heap_regs->AtomBatched_ -#define TermBatched MkAtomTerm( Yap_heap_regs->AtomBatched_ ) - Atom AtomBetween_; -#define AtomBetween Yap_heap_regs->AtomBetween_ -#define TermBetween MkAtomTerm( Yap_heap_regs->AtomBetween_ ) - Atom AtomBinary_; -#define AtomBinary Yap_heap_regs->AtomBinary_ -#define TermBinary MkAtomTerm( Yap_heap_regs->AtomBinary_ ) - Atom AtomBigNum_; -#define AtomBigNum Yap_heap_regs->AtomBigNum_ -#define TermBigNum MkAtomTerm( Yap_heap_regs->AtomBigNum_ ) - Atom AtomBinaryStream_; -#define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_ -#define TermBinaryStream MkAtomTerm( Yap_heap_regs->AtomBinaryStream_ ) - Atom AtomBoolean_; -#define AtomBoolean Yap_heap_regs->AtomBoolean_ -#define TermBoolean MkAtomTerm( Yap_heap_regs->AtomBoolean_ ) - Atom AtomBraces_; -#define AtomBraces Yap_heap_regs->AtomBraces_ -#define TermBraces MkAtomTerm( Yap_heap_regs->AtomBraces_ ) - Atom AtomBreak_; -#define AtomBreak Yap_heap_regs->AtomBreak_ -#define TermBreak MkAtomTerm( Yap_heap_regs->AtomBreak_ ) - Atom AtomByte_; -#define AtomByte Yap_heap_regs->AtomByte_ -#define TermByte MkAtomTerm( Yap_heap_regs->AtomByte_ ) - Atom AtomCArith_; -#define AtomCArith Yap_heap_regs->AtomCArith_ -#define TermCArith MkAtomTerm( Yap_heap_regs->AtomCArith_ ) - Atom AtomCall_; -#define AtomCall Yap_heap_regs->AtomCall_ -#define TermCall MkAtomTerm( Yap_heap_regs->AtomCall_ ) - Atom AtomCallAndRetryCounter_; -#define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_ -#define TermCallAndRetryCounter MkAtomTerm( Yap_heap_regs->AtomCallAndRetryCounter_ ) - Atom AtomCallCounter_; -#define AtomCallCounter Yap_heap_regs->AtomCallCounter_ -#define TermCallCounter MkAtomTerm( Yap_heap_regs->AtomCallCounter_ ) - Atom AtomCallable_; -#define AtomCallable Yap_heap_regs->AtomCallable_ -#define TermCallable MkAtomTerm( Yap_heap_regs->AtomCallable_ ) - Atom AtomCatch_; -#define AtomCatch Yap_heap_regs->AtomCatch_ -#define TermCatch MkAtomTerm( Yap_heap_regs->AtomCatch_ ) - Atom AtomChangeModule_; -#define AtomChangeModule Yap_heap_regs->AtomChangeModule_ -#define TermChangeModule MkAtomTerm( Yap_heap_regs->AtomChangeModule_ ) - Atom AtomChar_; -#define AtomChar Yap_heap_regs->AtomChar_ -#define TermChar MkAtomTerm( Yap_heap_regs->AtomChar_ ) - Atom AtomCharsio_; -#define AtomCharsio Yap_heap_regs->AtomCharsio_ -#define TermCharsio MkAtomTerm( Yap_heap_regs->AtomCharsio_ ) - Atom AtomCharacter_; -#define AtomCharacter Yap_heap_regs->AtomCharacter_ -#define TermCharacter MkAtomTerm( Yap_heap_regs->AtomCharacter_ ) - Atom AtomCharacterCode_; -#define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_ -#define TermCharacterCode MkAtomTerm( Yap_heap_regs->AtomCharacterCode_ ) - Atom AtomChars_; -#define AtomChars Yap_heap_regs->AtomChars_ -#define TermChars MkAtomTerm( Yap_heap_regs->AtomChars_ ) - Atom AtomCharset_; -#define AtomCharset Yap_heap_regs->AtomCharset_ -#define TermCharset MkAtomTerm( Yap_heap_regs->AtomCharset_ ) - Atom AtomChType_; -#define AtomChType Yap_heap_regs->AtomChType_ -#define TermChType MkAtomTerm( Yap_heap_regs->AtomChType_ ) - Atom AtomCleanCall_; -#define AtomCleanCall Yap_heap_regs->AtomCleanCall_ -#define TermCleanCall MkAtomTerm( Yap_heap_regs->AtomCleanCall_ ) - Atom AtomColomn_; -#define AtomColomn Yap_heap_regs->AtomColomn_ -#define TermColomn MkAtomTerm( Yap_heap_regs->AtomColomn_ ) - Atom AtomCodeSpace_; -#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_ -#define TermCodeSpace MkAtomTerm( Yap_heap_regs->AtomCodeSpace_ ) - Atom AtomCodes_; -#define AtomCodes Yap_heap_regs->AtomCodes_ -#define TermCodes MkAtomTerm( Yap_heap_regs->AtomCodes_ ) - Atom AtomCoInductive_; -#define AtomCoInductive Yap_heap_regs->AtomCoInductive_ -#define TermCoInductive MkAtomTerm( Yap_heap_regs->AtomCoInductive_ ) - Atom AtomComma_; -#define AtomComma Yap_heap_regs->AtomComma_ -#define TermComma MkAtomTerm( Yap_heap_regs->AtomComma_ ) - Atom AtomCommentHook_; -#define AtomCommentHook Yap_heap_regs->AtomCommentHook_ -#define TermCommentHook MkAtomTerm( Yap_heap_regs->AtomCommentHook_ ) - Atom AtomCompact_; -#define AtomCompact Yap_heap_regs->AtomCompact_ -#define TermCompact MkAtomTerm( Yap_heap_regs->AtomCompact_ ) - Atom AtomCompound_; -#define AtomCompound Yap_heap_regs->AtomCompound_ -#define TermCompound MkAtomTerm( Yap_heap_regs->AtomCompound_ ) - Atom AtomConsistencyError_; -#define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_ -#define TermConsistencyError MkAtomTerm( Yap_heap_regs->AtomConsistencyError_ ) - Atom AtomConsult_; -#define AtomConsult Yap_heap_regs->AtomConsult_ -#define TermConsult MkAtomTerm( Yap_heap_regs->AtomConsult_ ) - Atom AtomConsultOnBoot_; -#define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_ -#define TermConsultOnBoot MkAtomTerm( Yap_heap_regs->AtomConsultOnBoot_ ) - Atom AtomContext_; -#define AtomContext Yap_heap_regs->AtomContext_ -#define TermContext MkAtomTerm( Yap_heap_regs->AtomContext_ ) - Atom AtomCputime_; -#define AtomCputime Yap_heap_regs->AtomCputime_ -#define TermCputime MkAtomTerm( Yap_heap_regs->AtomCputime_ ) - Atom AtomCreate_; -#define AtomCreate Yap_heap_regs->AtomCreate_ -#define TermCreate MkAtomTerm( Yap_heap_regs->AtomCreate_ ) - Atom AtomCreep_; -#define AtomCreep Yap_heap_regs->AtomCreep_ -#define TermCreep MkAtomTerm( Yap_heap_regs->AtomCreep_ ) - Atom AtomCryptAtoms_; -#define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_ -#define TermCryptAtoms MkAtomTerm( Yap_heap_regs->AtomCryptAtoms_ ) - Atom AtomCsult_; -#define AtomCsult Yap_heap_regs->AtomCsult_ -#define TermCsult MkAtomTerm( Yap_heap_regs->AtomCsult_ ) - Atom AtomCurrentModule_; -#define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_ -#define TermCurrentModule MkAtomTerm( Yap_heap_regs->AtomCurrentModule_ ) - Atom AtomCut_; -#define AtomCut Yap_heap_regs->AtomCut_ -#define TermCut MkAtomTerm( Yap_heap_regs->AtomCut_ ) - Atom AtomCutBy_; -#define AtomCutBy Yap_heap_regs->AtomCutBy_ -#define TermCutBy MkAtomTerm( Yap_heap_regs->AtomCutBy_ ) - Atom AtomDAbort_; -#define AtomDAbort Yap_heap_regs->AtomDAbort_ -#define TermDAbort MkAtomTerm( Yap_heap_regs->AtomDAbort_ ) - Atom AtomDBLoad_; -#define AtomDBLoad Yap_heap_regs->AtomDBLoad_ -#define TermDBLoad MkAtomTerm( Yap_heap_regs->AtomDBLoad_ ) - Atom AtomDBREF_; -#define AtomDBREF Yap_heap_regs->AtomDBREF_ -#define TermDBREF MkAtomTerm( Yap_heap_regs->AtomDBREF_ ) - Atom AtomDBReference_; -#define AtomDBReference Yap_heap_regs->AtomDBReference_ -#define TermDBReference MkAtomTerm( Yap_heap_regs->AtomDBReference_ ) - Atom AtomDBTerm_; -#define AtomDBTerm Yap_heap_regs->AtomDBTerm_ -#define TermDBTerm MkAtomTerm( Yap_heap_regs->AtomDBTerm_ ) - Atom AtomDBref_; -#define AtomDBref Yap_heap_regs->AtomDBref_ -#define TermDBref MkAtomTerm( Yap_heap_regs->AtomDBref_ ) - Atom AtomDInteger_; -#define AtomDInteger Yap_heap_regs->AtomDInteger_ -#define TermDInteger MkAtomTerm( Yap_heap_regs->AtomDInteger_ ) - Atom AtomDebugMeta_; -#define AtomDebugMeta Yap_heap_regs->AtomDebugMeta_ -#define TermDebugMeta MkAtomTerm( Yap_heap_regs->AtomDebugMeta_ ) - Atom AtomDebuggerInput_; -#define AtomDebuggerInput Yap_heap_regs->AtomDebuggerInput_ -#define TermDebuggerInput MkAtomTerm( Yap_heap_regs->AtomDebuggerInput_ ) - Atom AtomDec10_; -#define AtomDec10 Yap_heap_regs->AtomDec10_ -#define TermDec10 MkAtomTerm( Yap_heap_regs->AtomDec10_ ) - Atom AtomDefault_; -#define AtomDefault Yap_heap_regs->AtomDefault_ -#define TermDefault MkAtomTerm( Yap_heap_regs->AtomDefault_ ) - Atom AtomDevNull_; -#define AtomDevNull Yap_heap_regs->AtomDevNull_ -#define TermDevNull MkAtomTerm( Yap_heap_regs->AtomDevNull_ ) - Atom AtomDiff_; -#define AtomDiff Yap_heap_regs->AtomDiff_ -#define TermDiff MkAtomTerm( Yap_heap_regs->AtomDiff_ ) - Atom AtomDirectory_; -#define AtomDirectory Yap_heap_regs->AtomDirectory_ -#define TermDirectory MkAtomTerm( Yap_heap_regs->AtomDirectory_ ) - Atom AtomDiscontiguous_; -#define AtomDiscontiguous Yap_heap_regs->AtomDiscontiguous_ -#define TermDiscontiguous MkAtomTerm( Yap_heap_regs->AtomDiscontiguous_ ) - Atom AtomDiscontiguousWarnings_; -#define AtomDiscontiguousWarnings Yap_heap_regs->AtomDiscontiguousWarnings_ -#define TermDiscontiguousWarnings MkAtomTerm( Yap_heap_regs->AtomDiscontiguousWarnings_ ) - Atom AtomDollar_; -#define AtomDollar Yap_heap_regs->AtomDollar_ -#define TermDollar MkAtomTerm( Yap_heap_regs->AtomDollar_ ) - Atom AtomDoLogUpdClause_; -#define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_ -#define TermDoLogUpdClause MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause_ ) - Atom AtomDoLogUpdClause0_; -#define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_ -#define TermDoLogUpdClause0 MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause0_ ) - Atom AtomDoLogUpdClauseErase_; -#define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_ -#define TermDoLogUpdClauseErase MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClauseErase_ ) - Atom AtomDollarU_; -#define AtomDollarU Yap_heap_regs->AtomDollarU_ -#define TermDollarU MkAtomTerm( Yap_heap_regs->AtomDollarU_ ) - Atom AtomDollarUndef_; -#define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_ -#define TermDollarUndef MkAtomTerm( Yap_heap_regs->AtomDollarUndef_ ) - Atom AtomDomainError_; -#define AtomDomainError Yap_heap_regs->AtomDomainError_ -#define TermDomainError MkAtomTerm( Yap_heap_regs->AtomDomainError_ ) - Atom AtomDoStaticClause_; -#define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_ -#define TermDoStaticClause MkAtomTerm( Yap_heap_regs->AtomDoStaticClause_ ) - Atom AtomDots_; -#define AtomDots Yap_heap_regs->AtomDots_ -#define TermDots MkAtomTerm( Yap_heap_regs->AtomDots_ ) - Atom AtomDOUBLE_; -#define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_ -#define TermDOUBLE MkAtomTerm( Yap_heap_regs->AtomDOUBLE_ ) - Atom AtomDoubleSlash_; -#define AtomDoubleSlash Yap_heap_regs->AtomDoubleSlash_ -#define TermDoubleSlash MkAtomTerm( Yap_heap_regs->AtomDoubleSlash_ ) - Atom AtomE_; -#define AtomE Yap_heap_regs->AtomE_ -#define TermE MkAtomTerm( Yap_heap_regs->AtomE_ ) - Atom AtomEOFBeforeEOT_; -#define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_ -#define TermEOFBeforeEOT MkAtomTerm( Yap_heap_regs->AtomEOFBeforeEOT_ ) - Atom AtomEQ_; -#define AtomEQ Yap_heap_regs->AtomEQ_ -#define TermEQ MkAtomTerm( Yap_heap_regs->AtomEQ_ ) - Atom AtomEmptyAtom_; -#define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_ -#define TermEmptyAtom MkAtomTerm( Yap_heap_regs->AtomEmptyAtom_ ) - Atom AtomEncoding_; -#define AtomEncoding Yap_heap_regs->AtomEncoding_ -#define TermEncoding MkAtomTerm( Yap_heap_regs->AtomEncoding_ ) - Atom AtomEndOfStream_; -#define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_ -#define TermEndOfStream MkAtomTerm( Yap_heap_regs->AtomEndOfStream_ ) - Atom AtomEof_; -#define AtomEof Yap_heap_regs->AtomEof_ -#define TermEof MkAtomTerm( Yap_heap_regs->AtomEof_ ) - Atom AtomEOfCode_; -#define AtomEOfCode Yap_heap_regs->AtomEOfCode_ -#define TermEOfCode MkAtomTerm( Yap_heap_regs->AtomEOfCode_ ) - Atom AtomEq_; -#define AtomEq Yap_heap_regs->AtomEq_ -#define TermEq MkAtomTerm( Yap_heap_regs->AtomEq_ ) - Atom AtomError_; -#define AtomError Yap_heap_regs->AtomError_ -#define TermError MkAtomTerm( Yap_heap_regs->AtomError_ ) - Atom AtomException_; -#define AtomException Yap_heap_regs->AtomException_ -#define TermException MkAtomTerm( Yap_heap_regs->AtomException_ ) - Atom AtomExtensions_; -#define AtomExtensions Yap_heap_regs->AtomExtensions_ -#define TermExtensions MkAtomTerm( Yap_heap_regs->AtomExtensions_ ) - Atom AtomEvaluable_; -#define AtomEvaluable Yap_heap_regs->AtomEvaluable_ -#define TermEvaluable MkAtomTerm( Yap_heap_regs->AtomEvaluable_ ) - Atom AtomEvaluationError_; -#define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_ -#define TermEvaluationError MkAtomTerm( Yap_heap_regs->AtomEvaluationError_ ) - Atom AtomExecutable_; -#define AtomExecutable Yap_heap_regs->AtomExecutable_ -#define TermExecutable MkAtomTerm( Yap_heap_regs->AtomExecutable_ ) - Atom AtomExecute_; -#define AtomExecute Yap_heap_regs->AtomExecute_ -#define TermExecute MkAtomTerm( Yap_heap_regs->AtomExecute_ ) - Atom AtomExecAnswers_; -#define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_ -#define TermExecAnswers MkAtomTerm( Yap_heap_regs->AtomExecAnswers_ ) - Atom AtomExecuteInMod_; -#define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_ -#define TermExecuteInMod MkAtomTerm( Yap_heap_regs->AtomExecuteInMod_ ) - Atom AtomExecuteWithin_; -#define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_ -#define TermExecuteWithin MkAtomTerm( Yap_heap_regs->AtomExecuteWithin_ ) - Atom AtomExecuteWoMod_; -#define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_ -#define TermExecuteWoMod MkAtomTerm( Yap_heap_regs->AtomExecuteWoMod_ ) - Atom AtomExist_; -#define AtomExist Yap_heap_regs->AtomExist_ -#define TermExist MkAtomTerm( Yap_heap_regs->AtomExist_ ) - Atom AtomExistenceError_; -#define AtomExistenceError Yap_heap_regs->AtomExistenceError_ -#define TermExistenceError MkAtomTerm( Yap_heap_regs->AtomExistenceError_ ) - Atom AtomExoClause_; -#define AtomExoClause Yap_heap_regs->AtomExoClause_ -#define TermExoClause MkAtomTerm( Yap_heap_regs->AtomExoClause_ ) - Atom AtomExpectedNumber_; -#define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_ -#define TermExpectedNumber MkAtomTerm( Yap_heap_regs->AtomExpectedNumber_ ) - Atom AtomExpand_; -#define AtomExpand Yap_heap_regs->AtomExpand_ -#define TermExpand MkAtomTerm( Yap_heap_regs->AtomExpand_ ) - Atom AtomExtendFileSearchPath_; -#define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_ -#define TermExtendFileSearchPath MkAtomTerm( Yap_heap_regs->AtomExtendFileSearchPath_ ) - Atom AtomExtendsions_; -#define AtomExtendsions Yap_heap_regs->AtomExtendsions_ -#define TermExtendsions MkAtomTerm( Yap_heap_regs->AtomExtendsions_ ) - Atom AtomFB_; -#define AtomFB Yap_heap_regs->AtomFB_ -#define TermFB MkAtomTerm( Yap_heap_regs->AtomFB_ ) - Atom AtomFail_; -#define AtomFail Yap_heap_regs->AtomFail_ -#define TermFail MkAtomTerm( Yap_heap_regs->AtomFail_ ) - Atom AtomFalse_; -#define AtomFalse Yap_heap_regs->AtomFalse_ -#define TermFalse MkAtomTerm( Yap_heap_regs->AtomFalse_ ) - Atom AtomFast_; -#define AtomFast Yap_heap_regs->AtomFast_ -#define TermFast MkAtomTerm( Yap_heap_regs->AtomFast_ ) - Atom AtomFastFail_; -#define AtomFastFail Yap_heap_regs->AtomFastFail_ -#define TermFastFail MkAtomTerm( Yap_heap_regs->AtomFastFail_ ) - Atom AtomFileErrors_; -#define AtomFileErrors Yap_heap_regs->AtomFileErrors_ -#define TermFileErrors MkAtomTerm( Yap_heap_regs->AtomFileErrors_ ) - Atom AtomFileerrors_; -#define AtomFileerrors Yap_heap_regs->AtomFileerrors_ -#define TermFileerrors MkAtomTerm( Yap_heap_regs->AtomFileerrors_ ) - 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_ -#define TermFloat MkAtomTerm( Yap_heap_regs->AtomFloat_ ) - Atom AtomFloatFormat_; -#define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_ -#define TermFloatFormat MkAtomTerm( Yap_heap_regs->AtomFloatFormat_ ) - Atom AtomFloatOverflow_; -#define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_ -#define TermFloatOverflow MkAtomTerm( Yap_heap_regs->AtomFloatOverflow_ ) - Atom AtomFloatUnderflow_; -#define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_ -#define TermFloatUnderflow MkAtomTerm( Yap_heap_regs->AtomFloatUnderflow_ ) - Atom AtomFormat_; -#define AtomFormat Yap_heap_regs->AtomFormat_ -#define TermFormat MkAtomTerm( Yap_heap_regs->AtomFormat_ ) - Atom AtomFormatAt_; -#define AtomFormatAt Yap_heap_regs->AtomFormatAt_ -#define TermFormatAt MkAtomTerm( Yap_heap_regs->AtomFormatAt_ ) - Atom AtomFull_; -#define AtomFull Yap_heap_regs->AtomFull_ -#define TermFull MkAtomTerm( Yap_heap_regs->AtomFull_ ) - Atom AtomFunctor_; -#define AtomFunctor Yap_heap_regs->AtomFunctor_ -#define TermFunctor MkAtomTerm( Yap_heap_regs->AtomFunctor_ ) - Atom AtomGT_; -#define AtomGT Yap_heap_regs->AtomGT_ -#define TermGT MkAtomTerm( Yap_heap_regs->AtomGT_ ) - Atom AtomGVar_; -#define AtomGVar Yap_heap_regs->AtomGVar_ -#define TermGVar MkAtomTerm( Yap_heap_regs->AtomGVar_ ) - Atom AtomGc_; -#define AtomGc Yap_heap_regs->AtomGc_ -#define TermGc MkAtomTerm( Yap_heap_regs->AtomGc_ ) - Atom AtomGcMargin_; -#define AtomGcMargin Yap_heap_regs->AtomGcMargin_ -#define TermGcMargin MkAtomTerm( Yap_heap_regs->AtomGcMargin_ ) - Atom AtomGcTrace_; -#define AtomGcTrace Yap_heap_regs->AtomGcTrace_ -#define TermGcTrace MkAtomTerm( Yap_heap_regs->AtomGcTrace_ ) - Atom AtomGcVerbose_; -#define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_ -#define TermGcVerbose MkAtomTerm( Yap_heap_regs->AtomGcVerbose_ ) - Atom AtomGcVeryVerbose_; -#define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_ -#define TermGcVeryVerbose MkAtomTerm( Yap_heap_regs->AtomGcVeryVerbose_ ) - Atom AtomGeneratePredInfo_; -#define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_ -#define TermGeneratePredInfo MkAtomTerm( Yap_heap_regs->AtomGeneratePredInfo_ ) - Atom AtomGetwork_; -#define AtomGetwork Yap_heap_regs->AtomGetwork_ -#define TermGetwork MkAtomTerm( Yap_heap_regs->AtomGetwork_ ) - Atom AtomGetworkSeq_; -#define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_ -#define TermGetworkSeq MkAtomTerm( Yap_heap_regs->AtomGetworkSeq_ ) - Atom AtomGlob_; -#define AtomGlob Yap_heap_regs->AtomGlob_ -#define TermGlob MkAtomTerm( Yap_heap_regs->AtomGlob_ ) - Atom AtomGlobal_; -#define AtomGlobal Yap_heap_regs->AtomGlobal_ -#define TermGlobal MkAtomTerm( Yap_heap_regs->AtomGlobal_ ) - Atom AtomGlobalSp_; -#define AtomGlobalSp Yap_heap_regs->AtomGlobalSp_ -#define TermGlobalSp MkAtomTerm( Yap_heap_regs->AtomGlobalSp_ ) - Atom AtomGlobalTrie_; -#define AtomGlobalTrie Yap_heap_regs->AtomGlobalTrie_ -#define TermGlobalTrie MkAtomTerm( Yap_heap_regs->AtomGlobalTrie_ ) - Atom AtomGoalExpansion_; -#define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_ -#define TermGoalExpansion MkAtomTerm( Yap_heap_regs->AtomGoalExpansion_ ) - Atom AtomHat_; -#define AtomHat Yap_heap_regs->AtomHat_ -#define TermHat MkAtomTerm( Yap_heap_regs->AtomHat_ ) - Atom AtomHERE_; -#define AtomHERE Yap_heap_regs->AtomHERE_ -#define TermHERE MkAtomTerm( Yap_heap_regs->AtomHERE_ ) - Atom AtomHandleThrow_; -#define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_ -#define TermHandleThrow MkAtomTerm( Yap_heap_regs->AtomHandleThrow_ ) - Atom AtomHeap_; -#define AtomHeap Yap_heap_regs->AtomHeap_ -#define TermHeap MkAtomTerm( Yap_heap_regs->AtomHeap_ ) - Atom AtomHeapUsed_; -#define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_ -#define TermHeapUsed MkAtomTerm( Yap_heap_regs->AtomHeapUsed_ ) - Atom AtomHugeInt_; -#define AtomHugeInt Yap_heap_regs->AtomHugeInt_ -#define TermHugeInt MkAtomTerm( Yap_heap_regs->AtomHugeInt_ ) - Atom AtomIDB_; -#define AtomIDB Yap_heap_regs->AtomIDB_ -#define TermIDB MkAtomTerm( Yap_heap_regs->AtomIDB_ ) - Atom AtomIOMode_; -#define AtomIOMode Yap_heap_regs->AtomIOMode_ -#define TermIOMode MkAtomTerm( Yap_heap_regs->AtomIOMode_ ) - Atom AtomId_; -#define AtomId Yap_heap_regs->AtomId_ -#define TermId MkAtomTerm( Yap_heap_regs->AtomId_ ) - Atom AtomIgnore_; -#define AtomIgnore Yap_heap_regs->AtomIgnore_ -#define TermIgnore MkAtomTerm( Yap_heap_regs->AtomIgnore_ ) - Atom AtomInf_; -#define AtomInf Yap_heap_regs->AtomInf_ -#define TermInf MkAtomTerm( Yap_heap_regs->AtomInf_ ) - Atom AtomInfinity_; -#define AtomInfinity Yap_heap_regs->AtomInfinity_ -#define TermInfinity MkAtomTerm( Yap_heap_regs->AtomInfinity_ ) - Atom AtomInitGoal_; -#define AtomInitGoal Yap_heap_regs->AtomInitGoal_ -#define TermInitGoal MkAtomTerm( Yap_heap_regs->AtomInitGoal_ ) - Atom AtomInitProlog_; -#define AtomInitProlog Yap_heap_regs->AtomInitProlog_ -#define TermInitProlog MkAtomTerm( Yap_heap_regs->AtomInitProlog_ ) - Atom AtomInStackExpansion_; -#define AtomInStackExpansion Yap_heap_regs->AtomInStackExpansion_ -#define TermInStackExpansion MkAtomTerm( Yap_heap_regs->AtomInStackExpansion_ ) - Atom AtomInput_; -#define AtomInput Yap_heap_regs->AtomInput_ -#define TermInput MkAtomTerm( Yap_heap_regs->AtomInput_ ) - Atom AtomInstantiationError_; -#define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_ -#define TermInstantiationError MkAtomTerm( Yap_heap_regs->AtomInstantiationError_ ) - Atom AtomInt_; -#define AtomInt Yap_heap_regs->AtomInt_ -#define TermInt MkAtomTerm( Yap_heap_regs->AtomInt_ ) - Atom AtomIntOverflow_; -#define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_ -#define TermIntOverflow MkAtomTerm( Yap_heap_regs->AtomIntOverflow_ ) - Atom AtomInteger_; -#define AtomInteger Yap_heap_regs->AtomInteger_ -#define TermInteger MkAtomTerm( Yap_heap_regs->AtomInteger_ ) - Atom AtomInternalCompilerError_; -#define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_ -#define TermInternalCompilerError MkAtomTerm( Yap_heap_regs->AtomInternalCompilerError_ ) - Atom AtomIs_; -#define AtomIs Yap_heap_regs->AtomIs_ -#define TermIs MkAtomTerm( Yap_heap_regs->AtomIs_ ) - Atom AtomKey_; -#define AtomKey Yap_heap_regs->AtomKey_ -#define TermKey MkAtomTerm( Yap_heap_regs->AtomKey_ ) - Atom AtomLDLibraryPath_; -#define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_ -#define TermLDLibraryPath MkAtomTerm( Yap_heap_regs->AtomLDLibraryPath_ ) - Atom AtomLONGINT_; -#define AtomLONGINT Yap_heap_regs->AtomLONGINT_ -#define TermLONGINT MkAtomTerm( Yap_heap_regs->AtomLONGINT_ ) - Atom AtomLOOP_; -#define AtomLOOP Yap_heap_regs->AtomLOOP_ -#define TermLOOP MkAtomTerm( Yap_heap_regs->AtomLOOP_ ) - Atom AtomLoopStream_; -#define AtomLoopStream Yap_heap_regs->AtomLoopStream_ -#define TermLoopStream MkAtomTerm( Yap_heap_regs->AtomLoopStream_ ) - Atom AtomLT_; -#define AtomLT Yap_heap_regs->AtomLT_ -#define TermLT MkAtomTerm( Yap_heap_regs->AtomLT_ ) - Atom AtomLastExecuteWithin_; -#define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_ -#define TermLastExecuteWithin MkAtomTerm( Yap_heap_regs->AtomLastExecuteWithin_ ) - Atom AtomLeash_; -#define AtomLeash Yap_heap_regs->AtomLeash_ -#define TermLeash MkAtomTerm( Yap_heap_regs->AtomLeash_ ) - Atom AtomLeast_; -#define AtomLeast Yap_heap_regs->AtomLeast_ -#define TermLeast MkAtomTerm( Yap_heap_regs->AtomLeast_ ) - Atom AtomLength_; -#define AtomLength Yap_heap_regs->AtomLength_ -#define TermLength MkAtomTerm( Yap_heap_regs->AtomLength_ ) - Atom AtomList_; -#define AtomList Yap_heap_regs->AtomList_ -#define TermList MkAtomTerm( Yap_heap_regs->AtomList_ ) - Atom AtomLine_; -#define AtomLine Yap_heap_regs->AtomLine_ -#define TermLine MkAtomTerm( Yap_heap_regs->AtomLine_ ) - Atom AtomLive_; -#define AtomLive Yap_heap_regs->AtomLive_ -#define TermLive MkAtomTerm( Yap_heap_regs->AtomLive_ ) - Atom AtomLoadAnswers_; -#define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_ -#define TermLoadAnswers MkAtomTerm( Yap_heap_regs->AtomLoadAnswers_ ) - Atom AtomLocal_; -#define AtomLocal Yap_heap_regs->AtomLocal_ -#define TermLocal MkAtomTerm( Yap_heap_regs->AtomLocal_ ) - Atom AtomLocalSp_; -#define AtomLocalSp Yap_heap_regs->AtomLocalSp_ -#define TermLocalSp MkAtomTerm( Yap_heap_regs->AtomLocalSp_ ) - Atom AtomLocalTrie_; -#define AtomLocalTrie Yap_heap_regs->AtomLocalTrie_ -#define TermLocalTrie MkAtomTerm( Yap_heap_regs->AtomLocalTrie_ ) - Atom AtomMax_; -#define AtomMax Yap_heap_regs->AtomMax_ -#define TermMax MkAtomTerm( Yap_heap_regs->AtomMax_ ) - Atom AtomMaximum_; -#define AtomMaximum Yap_heap_regs->AtomMaximum_ -#define TermMaximum MkAtomTerm( Yap_heap_regs->AtomMaximum_ ) - Atom AtomMaxArity_; -#define AtomMaxArity Yap_heap_regs->AtomMaxArity_ -#define TermMaxArity MkAtomTerm( Yap_heap_regs->AtomMaxArity_ ) - Atom AtomMaxFiles_; -#define AtomMaxFiles Yap_heap_regs->AtomMaxFiles_ -#define TermMaxFiles MkAtomTerm( Yap_heap_regs->AtomMaxFiles_ ) - Atom AtomMegaClause_; -#define AtomMegaClause Yap_heap_regs->AtomMegaClause_ -#define TermMegaClause MkAtomTerm( Yap_heap_regs->AtomMegaClause_ ) - Atom AtomMetaCall_; -#define AtomMetaCall Yap_heap_regs->AtomMetaCall_ -#define TermMetaCall MkAtomTerm( Yap_heap_regs->AtomMetaCall_ ) - Atom AtomMfClause_; -#define AtomMfClause Yap_heap_regs->AtomMfClause_ -#define TermMfClause MkAtomTerm( Yap_heap_regs->AtomMfClause_ ) - Atom AtomMin_; -#define AtomMin Yap_heap_regs->AtomMin_ -#define TermMin MkAtomTerm( Yap_heap_regs->AtomMin_ ) - Atom AtomMinimum_; -#define AtomMinimum Yap_heap_regs->AtomMinimum_ -#define TermMinimum MkAtomTerm( Yap_heap_regs->AtomMinimum_ ) - Atom AtomMinus_; -#define AtomMinus Yap_heap_regs->AtomMinus_ -#define TermMinus MkAtomTerm( Yap_heap_regs->AtomMinus_ ) - Atom AtomModify_; -#define AtomModify Yap_heap_regs->AtomModify_ -#define TermModify MkAtomTerm( Yap_heap_regs->AtomModify_ ) - Atom AtomModule_; -#define AtomModule Yap_heap_regs->AtomModule_ -#define TermModule MkAtomTerm( Yap_heap_regs->AtomModule_ ) - Atom AtomMost_; -#define AtomMost Yap_heap_regs->AtomMost_ -#define TermMost MkAtomTerm( Yap_heap_regs->AtomMost_ ) - Atom AtomMulti_; -#define AtomMulti Yap_heap_regs->AtomMulti_ -#define TermMulti MkAtomTerm( Yap_heap_regs->AtomMulti_ ) - Atom AtomMultiFile_; -#define AtomMultiFile Yap_heap_regs->AtomMultiFile_ -#define TermMultiFile MkAtomTerm( Yap_heap_regs->AtomMultiFile_ ) - Atom AtomMultiple_; -#define AtomMultiple Yap_heap_regs->AtomMultiple_ -#define TermMultiple MkAtomTerm( Yap_heap_regs->AtomMultiple_ ) - Atom AtomMutable_; -#define AtomMutable Yap_heap_regs->AtomMutable_ -#define TermMutable MkAtomTerm( Yap_heap_regs->AtomMutable_ ) - Atom AtomMutableVariable_; -#define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_ -#define TermMutableVariable MkAtomTerm( Yap_heap_regs->AtomMutableVariable_ ) - Atom AtomMutex_; -#define AtomMutex Yap_heap_regs->AtomMutex_ -#define TermMutex MkAtomTerm( Yap_heap_regs->AtomMutex_ ) - Atom AtomMyddasDB_; -#define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_ -#define TermMyddasDB MkAtomTerm( Yap_heap_regs->AtomMyddasDB_ ) - Atom AtomMyddasGoal_; -#define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_ -#define TermMyddasGoal MkAtomTerm( Yap_heap_regs->AtomMyddasGoal_ ) - Atom AtomMyddasHost_; -#define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_ -#define TermMyddasHost MkAtomTerm( Yap_heap_regs->AtomMyddasHost_ ) - Atom AtomMyddasPass_; -#define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_ -#define TermMyddasPass MkAtomTerm( Yap_heap_regs->AtomMyddasPass_ ) - Atom AtomMyddasUser_; -#define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_ -#define TermMyddasUser MkAtomTerm( Yap_heap_regs->AtomMyddasUser_ ) - Atom AtomMyddasVersionName_; -#define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_ -#define TermMyddasVersionName MkAtomTerm( Yap_heap_regs->AtomMyddasVersionName_ ) - Atom AtomNan_; -#define AtomNan Yap_heap_regs->AtomNan_ -#define TermNan MkAtomTerm( Yap_heap_regs->AtomNan_ ) - Atom AtomNb_; -#define AtomNb Yap_heap_regs->AtomNb_ -#define TermNb MkAtomTerm( Yap_heap_regs->AtomNb_ ) - Atom AtomNbTerm_; -#define AtomNbTerm Yap_heap_regs->AtomNbTerm_ -#define TermNbTerm MkAtomTerm( Yap_heap_regs->AtomNbTerm_ ) - Atom AtomNew_; -#define AtomNew Yap_heap_regs->AtomNew_ -#define TermNew MkAtomTerm( Yap_heap_regs->AtomNew_ ) - Atom AtomNewLine_; -#define AtomNewLine Yap_heap_regs->AtomNewLine_ -#define TermNewLine MkAtomTerm( Yap_heap_regs->AtomNewLine_ ) - Atom AtomNl_; -#define AtomNl Yap_heap_regs->AtomNl_ -#define TermNl MkAtomTerm( Yap_heap_regs->AtomNl_ ) - Atom AtomNoEffect_; -#define AtomNoEffect Yap_heap_regs->AtomNoEffect_ -#define TermNoEffect MkAtomTerm( Yap_heap_regs->AtomNoEffect_ ) - Atom AtomNoMemory_; -#define AtomNoMemory Yap_heap_regs->AtomNoMemory_ -#define TermNoMemory MkAtomTerm( Yap_heap_regs->AtomNoMemory_ ) - Atom AtomNone_; -#define AtomNone Yap_heap_regs->AtomNone_ -#define TermNone MkAtomTerm( Yap_heap_regs->AtomNone_ ) - Atom AtomNonEmptyList_; -#define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_ -#define TermNonEmptyList MkAtomTerm( Yap_heap_regs->AtomNonEmptyList_ ) - Atom AtomNot_; -#define AtomNot Yap_heap_regs->AtomNot_ -#define TermNot MkAtomTerm( Yap_heap_regs->AtomNot_ ) - Atom AtomNotImplemented_; -#define AtomNotImplemented Yap_heap_regs->AtomNotImplemented_ -#define TermNotImplemented MkAtomTerm( Yap_heap_regs->AtomNotImplemented_ ) - Atom AtomNotLessThanZero_; -#define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_ -#define TermNotLessThanZero MkAtomTerm( Yap_heap_regs->AtomNotLessThanZero_ ) - Atom AtomNotNewline_; -#define AtomNotNewline Yap_heap_regs->AtomNotNewline_ -#define TermNotNewline MkAtomTerm( Yap_heap_regs->AtomNotNewline_ ) - Atom AtomNotZero_; -#define AtomNotZero Yap_heap_regs->AtomNotZero_ -#define TermNotZero MkAtomTerm( Yap_heap_regs->AtomNotZero_ ) - Atom AtomNumber_; -#define AtomNumber Yap_heap_regs->AtomNumber_ -#define TermNumber MkAtomTerm( Yap_heap_regs->AtomNumber_ ) - Atom AtomOff_; -#define AtomOff Yap_heap_regs->AtomOff_ -#define TermOff MkAtomTerm( Yap_heap_regs->AtomOff_ ) - Atom AtomOffline_; -#define AtomOffline Yap_heap_regs->AtomOffline_ -#define TermOffline MkAtomTerm( Yap_heap_regs->AtomOffline_ ) - Atom AtomOn_; -#define AtomOn Yap_heap_regs->AtomOn_ -#define TermOn MkAtomTerm( Yap_heap_regs->AtomOn_ ) - Atom AtomOnline_; -#define AtomOnline Yap_heap_regs->AtomOnline_ -#define TermOnline MkAtomTerm( Yap_heap_regs->AtomOnline_ ) - Atom AtomOpen_; -#define AtomOpen Yap_heap_regs->AtomOpen_ -#define TermOpen MkAtomTerm( Yap_heap_regs->AtomOpen_ ) - Atom AtomOperatingSystemError_; -#define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_ -#define TermOperatingSystemError MkAtomTerm( Yap_heap_regs->AtomOperatingSystemError_ ) - Atom AtomOperatingSystemSupport_; -#define AtomOperatingSystemSupport Yap_heap_regs->AtomOperatingSystemSupport_ -#define TermOperatingSystemSupport MkAtomTerm( Yap_heap_regs->AtomOperatingSystemSupport_ ) - Atom AtomOperator_; -#define AtomOperator Yap_heap_regs->AtomOperator_ -#define TermOperator MkAtomTerm( Yap_heap_regs->AtomOperator_ ) - Atom AtomOperatorPriority_; -#define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_ -#define TermOperatorPriority MkAtomTerm( Yap_heap_regs->AtomOperatorPriority_ ) - Atom AtomOperatorSpecifier_; -#define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_ -#define TermOperatorSpecifier MkAtomTerm( Yap_heap_regs->AtomOperatorSpecifier_ ) - Atom AtomOpt_; -#define AtomOpt Yap_heap_regs->AtomOpt_ -#define TermOpt MkAtomTerm( Yap_heap_regs->AtomOpt_ ) - Atom AtomOtherwise_; -#define AtomOtherwise Yap_heap_regs->AtomOtherwise_ -#define TermOtherwise MkAtomTerm( Yap_heap_regs->AtomOtherwise_ ) - Atom AtomOutOfAttvarsError_; -#define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_ -#define TermOutOfAttvarsError MkAtomTerm( Yap_heap_regs->AtomOutOfAttvarsError_ ) - Atom AtomOutOfAuxspaceError_; -#define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_ -#define TermOutOfAuxspaceError MkAtomTerm( Yap_heap_regs->AtomOutOfAuxspaceError_ ) - Atom AtomOutOfHeapError_; -#define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_ -#define TermOutOfHeapError MkAtomTerm( Yap_heap_regs->AtomOutOfHeapError_ ) - Atom AtomOutOfRange_; -#define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_ -#define TermOutOfRange MkAtomTerm( Yap_heap_regs->AtomOutOfRange_ ) - Atom AtomOutOfStackError_; -#define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_ -#define TermOutOfStackError MkAtomTerm( Yap_heap_regs->AtomOutOfStackError_ ) - Atom AtomOutOfTrailError_; -#define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_ -#define TermOutOfTrailError MkAtomTerm( Yap_heap_regs->AtomOutOfTrailError_ ) - Atom AtomOutput_; -#define AtomOutput Yap_heap_regs->AtomOutput_ -#define TermOutput MkAtomTerm( Yap_heap_regs->AtomOutput_ ) - Atom AtomParameter_; -#define AtomParameter Yap_heap_regs->AtomParameter_ -#define TermParameter MkAtomTerm( Yap_heap_regs->AtomParameter_ ) - Atom AtomPrologCommonsDir_; -#define AtomPrologCommonsDir Yap_heap_regs->AtomPrologCommonsDir_ -#define TermPrologCommonsDir MkAtomTerm( Yap_heap_regs->AtomPrologCommonsDir_ ) - Atom AtomPast_; -#define AtomPast Yap_heap_regs->AtomPast_ -#define TermPast MkAtomTerm( Yap_heap_regs->AtomPast_ ) - Atom AtomPastEndOfStream_; -#define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_ -#define TermPastEndOfStream MkAtomTerm( Yap_heap_regs->AtomPastEndOfStream_ ) - Atom AtomPermissionError_; -#define AtomPermissionError Yap_heap_regs->AtomPermissionError_ -#define TermPermissionError MkAtomTerm( Yap_heap_regs->AtomPermissionError_ ) - Atom AtomPi_; -#define AtomPi Yap_heap_regs->AtomPi_ -#define TermPi MkAtomTerm( Yap_heap_regs->AtomPi_ ) - Atom AtomPipe_; -#define AtomPipe Yap_heap_regs->AtomPipe_ -#define TermPipe MkAtomTerm( Yap_heap_regs->AtomPipe_ ) - Atom AtomPlus_; -#define AtomPlus Yap_heap_regs->AtomPlus_ -#define TermPlus MkAtomTerm( Yap_heap_regs->AtomPlus_ ) - Atom AtomPointer_; -#define AtomPointer Yap_heap_regs->AtomPointer_ -#define TermPointer MkAtomTerm( Yap_heap_regs->AtomPointer_ ) - Atom AtomPortray_; -#define AtomPortray Yap_heap_regs->AtomPortray_ -#define TermPortray MkAtomTerm( Yap_heap_regs->AtomPortray_ ) - Atom AtomPredicateIndicator_; -#define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_ -#define TermPredicateIndicator MkAtomTerm( Yap_heap_regs->AtomPredicateIndicator_ ) - Atom AtomPrimitive_; -#define AtomPrimitive Yap_heap_regs->AtomPrimitive_ -#define TermPrimitive MkAtomTerm( Yap_heap_regs->AtomPrimitive_ ) - Atom AtomPrintMessage_; -#define AtomPrintMessage Yap_heap_regs->AtomPrintMessage_ -#define TermPrintMessage MkAtomTerm( Yap_heap_regs->AtomPrintMessage_ ) - Atom AtomPrivateProcedure_; -#define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_ -#define TermPrivateProcedure MkAtomTerm( Yap_heap_regs->AtomPrivateProcedure_ ) - Atom AtomProcedure_; -#define AtomProcedure Yap_heap_regs->AtomProcedure_ -#define TermProcedure MkAtomTerm( Yap_heap_regs->AtomProcedure_ ) - Atom AtomProfile_; -#define AtomProfile Yap_heap_regs->AtomProfile_ -#define TermProfile MkAtomTerm( Yap_heap_regs->AtomProfile_ ) - Atom AtomProlog_; -#define AtomProlog Yap_heap_regs->AtomProlog_ -#define TermProlog MkAtomTerm( Yap_heap_regs->AtomProlog_ ) - Atom AtomQly_; -#define AtomQly Yap_heap_regs->AtomQly_ -#define TermQly MkAtomTerm( Yap_heap_regs->AtomQly_ ) - Atom AtomQuery_; -#define AtomQuery Yap_heap_regs->AtomQuery_ -#define TermQuery MkAtomTerm( Yap_heap_regs->AtomQuery_ ) - Atom AtomQueue_; -#define AtomQueue Yap_heap_regs->AtomQueue_ -#define TermQueue MkAtomTerm( Yap_heap_regs->AtomQueue_ ) - Atom AtomQuiet_; -#define AtomQuiet Yap_heap_regs->AtomQuiet_ -#define TermQuiet MkAtomTerm( Yap_heap_regs->AtomQuiet_ ) - Atom AtomRadix_; -#define AtomRadix Yap_heap_regs->AtomRadix_ -#define TermRadix MkAtomTerm( Yap_heap_regs->AtomRadix_ ) - Atom AtomRandom_; -#define AtomRandom Yap_heap_regs->AtomRandom_ -#define TermRandom MkAtomTerm( Yap_heap_regs->AtomRandom_ ) - Atom AtomRange_; -#define AtomRange Yap_heap_regs->AtomRange_ -#define TermRange MkAtomTerm( Yap_heap_regs->AtomRange_ ) - Atom AtomRDiv_; -#define AtomRDiv Yap_heap_regs->AtomRDiv_ -#define TermRDiv MkAtomTerm( Yap_heap_regs->AtomRDiv_ ) - Atom AtomRead_; -#define AtomRead Yap_heap_regs->AtomRead_ -#define TermRead MkAtomTerm( Yap_heap_regs->AtomRead_ ) - Atom AtomReadOnly_; -#define AtomReadOnly Yap_heap_regs->AtomReadOnly_ -#define TermReadOnly MkAtomTerm( Yap_heap_regs->AtomReadOnly_ ) - Atom AtomReadWrite_; -#define AtomReadWrite Yap_heap_regs->AtomReadWrite_ -#define TermReadWrite MkAtomTerm( Yap_heap_regs->AtomReadWrite_ ) - Atom AtomReadutil_; -#define AtomReadutil Yap_heap_regs->AtomReadutil_ -#define TermReadutil MkAtomTerm( Yap_heap_regs->AtomReadutil_ ) - Atom AtomReconsult_; -#define AtomReconsult Yap_heap_regs->AtomReconsult_ -#define TermReconsult MkAtomTerm( Yap_heap_regs->AtomReconsult_ ) - Atom AtomRecordedP_; -#define AtomRecordedP Yap_heap_regs->AtomRecordedP_ -#define TermRecordedP MkAtomTerm( Yap_heap_regs->AtomRecordedP_ ) - Atom AtomRecordedWithKey_; -#define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_ -#define TermRecordedWithKey MkAtomTerm( Yap_heap_regs->AtomRecordedWithKey_ ) - Atom AtomRedefineWarnings_; -#define AtomRedefineWarnings Yap_heap_regs->AtomRedefineWarnings_ -#define TermRedefineWarnings MkAtomTerm( Yap_heap_regs->AtomRedefineWarnings_ ) - Atom AtomRedoFreeze_; -#define AtomRedoFreeze Yap_heap_regs->AtomRedoFreeze_ -#define TermRedoFreeze MkAtomTerm( Yap_heap_regs->AtomRedoFreeze_ ) - Atom AtomRefoundVar_; -#define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_ -#define TermRefoundVar MkAtomTerm( Yap_heap_regs->AtomRefoundVar_ ) - Atom AtomRelativeTo_; -#define AtomRelativeTo Yap_heap_regs->AtomRelativeTo_ -#define TermRelativeTo MkAtomTerm( Yap_heap_regs->AtomRelativeTo_ ) - Atom AtomRepeat_; -#define AtomRepeat Yap_heap_regs->AtomRepeat_ -#define TermRepeat MkAtomTerm( Yap_heap_regs->AtomRepeat_ ) - Atom AtomRepeatSpace_; -#define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_ -#define TermRepeatSpace MkAtomTerm( Yap_heap_regs->AtomRepeatSpace_ ) - Atom AtomReposition_; -#define AtomReposition Yap_heap_regs->AtomReposition_ -#define TermReposition MkAtomTerm( Yap_heap_regs->AtomReposition_ ) - Atom AtomRepresentationError_; -#define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_ -#define TermRepresentationError MkAtomTerm( Yap_heap_regs->AtomRepresentationError_ ) - Atom AtomReset_; -#define AtomReset Yap_heap_regs->AtomReset_ -#define TermReset MkAtomTerm( Yap_heap_regs->AtomReset_ ) - Atom AtomResize_; -#define AtomResize Yap_heap_regs->AtomResize_ -#define TermResize MkAtomTerm( Yap_heap_regs->AtomResize_ ) - Atom AtomResourceError_; -#define AtomResourceError Yap_heap_regs->AtomResourceError_ -#define TermResourceError MkAtomTerm( Yap_heap_regs->AtomResourceError_ ) - Atom AtomRestoreRegs_; -#define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_ -#define TermRestoreRegs MkAtomTerm( Yap_heap_regs->AtomRestoreRegs_ ) - Atom AtomRetryCounter_; -#define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_ -#define TermRetryCounter MkAtomTerm( Yap_heap_regs->AtomRetryCounter_ ) - Atom AtomRTree_; -#define AtomRTree Yap_heap_regs->AtomRTree_ -#define TermRTree MkAtomTerm( Yap_heap_regs->AtomRTree_ ) - Atom AtomSafe_; -#define AtomSafe Yap_heap_regs->AtomSafe_ -#define TermSafe MkAtomTerm( Yap_heap_regs->AtomSafe_ ) - Atom AtomSafeCallCleanup_; -#define AtomSafeCallCleanup Yap_heap_regs->AtomSafeCallCleanup_ -#define TermSafeCallCleanup MkAtomTerm( Yap_heap_regs->AtomSafeCallCleanup_ ) - Atom AtomSame_; -#define AtomSame Yap_heap_regs->AtomSame_ -#define TermSame MkAtomTerm( Yap_heap_regs->AtomSame_ ) - Atom AtomSemic_; -#define AtomSemic Yap_heap_regs->AtomSemic_ -#define TermSemic MkAtomTerm( Yap_heap_regs->AtomSemic_ ) - Atom AtomShiftCountOverflow_; -#define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_ -#define TermShiftCountOverflow MkAtomTerm( Yap_heap_regs->AtomShiftCountOverflow_ ) - Atom AtomSigAlarm_; -#define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_ -#define TermSigAlarm MkAtomTerm( Yap_heap_regs->AtomSigAlarm_ ) - Atom AtomSigBreak_; -#define AtomSigBreak Yap_heap_regs->AtomSigBreak_ -#define TermSigBreak MkAtomTerm( Yap_heap_regs->AtomSigBreak_ ) - Atom AtomSigCreep_; -#define AtomSigCreep Yap_heap_regs->AtomSigCreep_ -#define TermSigCreep MkAtomTerm( Yap_heap_regs->AtomSigCreep_ ) - Atom AtomSigDebug_; -#define AtomSigDebug Yap_heap_regs->AtomSigDebug_ -#define TermSigDebug MkAtomTerm( Yap_heap_regs->AtomSigDebug_ ) - Atom AtomSigDelayCreep_; -#define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_ -#define TermSigDelayCreep MkAtomTerm( Yap_heap_regs->AtomSigDelayCreep_ ) - Atom AtomSigFPE_; -#define AtomSigFPE Yap_heap_regs->AtomSigFPE_ -#define TermSigFPE MkAtomTerm( Yap_heap_regs->AtomSigFPE_ ) - Atom AtomSigHup_; -#define AtomSigHup Yap_heap_regs->AtomSigHup_ -#define TermSigHup MkAtomTerm( Yap_heap_regs->AtomSigHup_ ) - Atom AtomSigInt_; -#define AtomSigInt Yap_heap_regs->AtomSigInt_ -#define TermSigInt MkAtomTerm( Yap_heap_regs->AtomSigInt_ ) - Atom AtomSigIti_; -#define AtomSigIti Yap_heap_regs->AtomSigIti_ -#define TermSigIti MkAtomTerm( Yap_heap_regs->AtomSigIti_ ) - Atom AtomSigPending_; -#define AtomSigPending Yap_heap_regs->AtomSigPending_ -#define TermSigPending MkAtomTerm( Yap_heap_regs->AtomSigPending_ ) - Atom AtomSigPipe_; -#define AtomSigPipe Yap_heap_regs->AtomSigPipe_ -#define TermSigPipe MkAtomTerm( Yap_heap_regs->AtomSigPipe_ ) - Atom AtomSigStackDump_; -#define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_ -#define TermSigStackDump MkAtomTerm( Yap_heap_regs->AtomSigStackDump_ ) - Atom AtomSigStatistics_; -#define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_ -#define TermSigStatistics MkAtomTerm( Yap_heap_regs->AtomSigStatistics_ ) - Atom AtomSigTrace_; -#define AtomSigTrace Yap_heap_regs->AtomSigTrace_ -#define TermSigTrace MkAtomTerm( Yap_heap_regs->AtomSigTrace_ ) - Atom AtomSigUsr1_; -#define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_ -#define TermSigUsr1 MkAtomTerm( Yap_heap_regs->AtomSigUsr1_ ) - Atom AtomSigUsr2_; -#define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_ -#define TermSigUsr2 MkAtomTerm( Yap_heap_regs->AtomSigUsr2_ ) - Atom AtomSigVTAlarm_; -#define AtomSigVTAlarm Yap_heap_regs->AtomSigVTAlarm_ -#define TermSigVTAlarm MkAtomTerm( Yap_heap_regs->AtomSigVTAlarm_ ) - Atom AtomSigWakeUp_; -#define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_ -#define TermSigWakeUp MkAtomTerm( Yap_heap_regs->AtomSigWakeUp_ ) - Atom AtomSilent_; -#define AtomSilent Yap_heap_regs->AtomSilent_ -#define TermSilent MkAtomTerm( Yap_heap_regs->AtomSilent_ ) - Atom AtomSingle_; -#define AtomSingle Yap_heap_regs->AtomSingle_ -#define TermSingle MkAtomTerm( Yap_heap_regs->AtomSingle_ ) - Atom AtomSingleVarWarnings_; -#define AtomSingleVarWarnings Yap_heap_regs->AtomSingleVarWarnings_ -#define TermSingleVarWarnings MkAtomTerm( Yap_heap_regs->AtomSingleVarWarnings_ ) - Atom AtomSingleton_; -#define AtomSingleton Yap_heap_regs->AtomSingleton_ -#define TermSingleton MkAtomTerm( Yap_heap_regs->AtomSingleton_ ) - Atom AtomSlash_; -#define AtomSlash Yap_heap_regs->AtomSlash_ -#define TermSlash MkAtomTerm( Yap_heap_regs->AtomSlash_ ) - Atom AtomSocket_; -#define AtomSocket Yap_heap_regs->AtomSocket_ -#define TermSocket MkAtomTerm( Yap_heap_regs->AtomSocket_ ) - Atom AtomSolutions_; -#define AtomSolutions Yap_heap_regs->AtomSolutions_ -#define TermSolutions MkAtomTerm( Yap_heap_regs->AtomSolutions_ ) - Atom AtomSource_; -#define AtomSource Yap_heap_regs->AtomSource_ -#define TermSource MkAtomTerm( Yap_heap_regs->AtomSource_ ) - Atom AtomSourceSink_; -#define AtomSourceSink Yap_heap_regs->AtomSourceSink_ -#define TermSourceSink MkAtomTerm( Yap_heap_regs->AtomSourceSink_ ) - Atom AtomSpy_; -#define AtomSpy Yap_heap_regs->AtomSpy_ -#define TermSpy MkAtomTerm( Yap_heap_regs->AtomSpy_ ) - Atom AtomStack_; -#define AtomStack Yap_heap_regs->AtomStack_ -#define TermStack MkAtomTerm( Yap_heap_regs->AtomStack_ ) - Atom AtomStackFree_; -#define AtomStackFree Yap_heap_regs->AtomStackFree_ -#define TermStackFree MkAtomTerm( Yap_heap_regs->AtomStackFree_ ) - Atom AtomStartupSavedState_; -#define AtomStartupSavedState Yap_heap_regs->AtomStartupSavedState_ -#define TermStartupSavedState MkAtomTerm( Yap_heap_regs->AtomStartupSavedState_ ) - Atom AtomStaticClause_; -#define AtomStaticClause Yap_heap_regs->AtomStaticClause_ -#define TermStaticClause MkAtomTerm( Yap_heap_regs->AtomStaticClause_ ) - Atom AtomStaticProcedure_; -#define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_ -#define TermStaticProcedure MkAtomTerm( Yap_heap_regs->AtomStaticProcedure_ ) - Atom AtomStream_; -#define AtomStream Yap_heap_regs->AtomStream_ -#define TermStream MkAtomTerm( Yap_heap_regs->AtomStream_ ) - Atom AtomSWIStream_; -#define AtomSWIStream Yap_heap_regs->AtomSWIStream_ -#define TermSWIStream MkAtomTerm( Yap_heap_regs->AtomSWIStream_ ) - Atom AtomVStream_; -#define AtomVStream Yap_heap_regs->AtomVStream_ -#define TermVStream MkAtomTerm( Yap_heap_regs->AtomVStream_ ) - Atom AtomStreams_; -#define AtomStreams Yap_heap_regs->AtomStreams_ -#define TermStreams MkAtomTerm( Yap_heap_regs->AtomStreams_ ) - Atom AtomStreamOrAlias_; -#define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_ -#define TermStreamOrAlias MkAtomTerm( Yap_heap_regs->AtomStreamOrAlias_ ) - Atom AtomStreamPos_; -#define AtomStreamPos Yap_heap_regs->AtomStreamPos_ -#define TermStreamPos MkAtomTerm( Yap_heap_regs->AtomStreamPos_ ) - Atom AtomStreamPosition_; -#define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_ -#define TermStreamPosition MkAtomTerm( Yap_heap_regs->AtomStreamPosition_ ) - Atom AtomString_; -#define AtomString Yap_heap_regs->AtomString_ -#define TermString MkAtomTerm( Yap_heap_regs->AtomString_ ) - Atom AtomStyleCheck_; -#define AtomStyleCheck Yap_heap_regs->AtomStyleCheck_ -#define TermStyleCheck MkAtomTerm( Yap_heap_regs->AtomStyleCheck_ ) - Atom AtomSTRING_; -#define AtomSTRING Yap_heap_regs->AtomSTRING_ -#define TermSTRING MkAtomTerm( Yap_heap_regs->AtomSTRING_ ) - Atom AtomSwi_; -#define AtomSwi Yap_heap_regs->AtomSwi_ -#define TermSwi MkAtomTerm( Yap_heap_regs->AtomSwi_ ) - Atom AtomSymbolChar_; -#define AtomSymbolChar Yap_heap_regs->AtomSymbolChar_ -#define TermSymbolChar MkAtomTerm( Yap_heap_regs->AtomSymbolChar_ ) - Atom AtomSyntaxError_; -#define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_ -#define TermSyntaxError MkAtomTerm( Yap_heap_regs->AtomSyntaxError_ ) - Atom AtomSyntaxErrors_; -#define AtomSyntaxErrors Yap_heap_regs->AtomSyntaxErrors_ -#define TermSyntaxErrors MkAtomTerm( Yap_heap_regs->AtomSyntaxErrors_ ) - Atom AtomSyntaxErrorHandler_; -#define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_ -#define TermSyntaxErrorHandler MkAtomTerm( Yap_heap_regs->AtomSyntaxErrorHandler_ ) - Atom AtomSystem_; -#define AtomSystem Yap_heap_regs->AtomSystem_ -#define TermSystem MkAtomTerm( Yap_heap_regs->AtomSystem_ ) - Atom AtomSystemError_; -#define AtomSystemError Yap_heap_regs->AtomSystemError_ -#define TermSystemError MkAtomTerm( Yap_heap_regs->AtomSystemError_ ) - Atom AtomSystemLibraryDir_; -#define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_ -#define TermSystemLibraryDir MkAtomTerm( Yap_heap_regs->AtomSystemLibraryDir_ ) - Atom AtomTerm_; -#define AtomTerm Yap_heap_regs->AtomTerm_ -#define TermTerm MkAtomTerm( Yap_heap_regs->AtomTerm_ ) - Atom AtomTerms_; -#define AtomTerms Yap_heap_regs->AtomTerms_ -#define TermTerms MkAtomTerm( Yap_heap_regs->AtomTerms_ ) - Atom AtomTermExpansion_; -#define AtomTermExpansion Yap_heap_regs->AtomTermExpansion_ -#define TermTermExpansion MkAtomTerm( Yap_heap_regs->AtomTermExpansion_ ) - Atom AtomText_; -#define AtomText Yap_heap_regs->AtomText_ -#define TermText MkAtomTerm( Yap_heap_regs->AtomText_ ) - Atom AtomTextStream_; -#define AtomTextStream Yap_heap_regs->AtomTextStream_ -#define TermTextStream MkAtomTerm( Yap_heap_regs->AtomTextStream_ ) - Atom AtomThread_; -#define AtomThread Yap_heap_regs->AtomThread_ -#define TermThread MkAtomTerm( Yap_heap_regs->AtomThread_ ) - Atom AtomThreads_; -#define AtomThreads Yap_heap_regs->AtomThreads_ -#define TermThreads MkAtomTerm( Yap_heap_regs->AtomThreads_ ) - Atom AtomThrow_; -#define AtomThrow Yap_heap_regs->AtomThrow_ -#define TermThrow MkAtomTerm( Yap_heap_regs->AtomThrow_ ) - Atom AtomTimeOutSpec_; -#define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_ -#define TermTimeOutSpec MkAtomTerm( Yap_heap_regs->AtomTimeOutSpec_ ) - Atom AtomTimeoutError_; -#define AtomTimeoutError Yap_heap_regs->AtomTimeoutError_ -#define TermTimeoutError MkAtomTerm( Yap_heap_regs->AtomTimeoutError_ ) - Atom AtomTopLevelGoal_; -#define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_ -#define TermTopLevelGoal MkAtomTerm( Yap_heap_regs->AtomTopLevelGoal_ ) - Atom AtomTopThreadGoal_; -#define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_ -#define TermTopThreadGoal MkAtomTerm( Yap_heap_regs->AtomTopThreadGoal_ ) - Atom AtomTraceMetaCall_; -#define AtomTraceMetaCall Yap_heap_regs->AtomTraceMetaCall_ -#define TermTraceMetaCall MkAtomTerm( Yap_heap_regs->AtomTraceMetaCall_ ) - Atom AtomTrail_; -#define AtomTrail Yap_heap_regs->AtomTrail_ -#define TermTrail MkAtomTerm( Yap_heap_regs->AtomTrail_ ) - Atom AtomTrue_; -#define AtomTrue Yap_heap_regs->AtomTrue_ -#define TermTrue MkAtomTerm( Yap_heap_regs->AtomTrue_ ) - Atom AtomTty_; -#define AtomTty Yap_heap_regs->AtomTty_ -#define TermTty MkAtomTerm( Yap_heap_regs->AtomTty_ ) - Atom AtomTtys_; -#define AtomTtys Yap_heap_regs->AtomTtys_ -#define TermTtys MkAtomTerm( Yap_heap_regs->AtomTtys_ ) - Atom AtomTxt_; -#define AtomTxt Yap_heap_regs->AtomTxt_ -#define TermTxt MkAtomTerm( Yap_heap_regs->AtomTxt_ ) - Atom AtomTypeError_; -#define AtomTypeError Yap_heap_regs->AtomTypeError_ -#define TermTypeError MkAtomTerm( Yap_heap_regs->AtomTypeError_ ) - Atom AtomUndefined_; -#define AtomUndefined Yap_heap_regs->AtomUndefined_ -#define TermUndefined MkAtomTerm( Yap_heap_regs->AtomUndefined_ ) - Atom AtomUndefp_; -#define AtomUndefp Yap_heap_regs->AtomUndefp_ -#define TermUndefp MkAtomTerm( Yap_heap_regs->AtomUndefp_ ) - Atom AtomUnderflow_; -#define AtomUnderflow Yap_heap_regs->AtomUnderflow_ -#define TermUnderflow MkAtomTerm( Yap_heap_regs->AtomUnderflow_ ) - Atom AtomUnificationStack_; -#define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_ -#define TermUnificationStack MkAtomTerm( Yap_heap_regs->AtomUnificationStack_ ) - Atom AtomUnique_; -#define AtomUnique Yap_heap_regs->AtomUnique_ -#define TermUnique MkAtomTerm( Yap_heap_regs->AtomUnique_ ) - Atom AtomUnsignedByte_; -#define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_ -#define TermUnsignedByte MkAtomTerm( Yap_heap_regs->AtomUnsignedByte_ ) - Atom AtomUnsignedChar_; -#define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_ -#define TermUnsignedChar MkAtomTerm( Yap_heap_regs->AtomUnsignedChar_ ) - Atom AtomUser_; -#define AtomUser Yap_heap_regs->AtomUser_ -#define TermUser MkAtomTerm( Yap_heap_regs->AtomUser_ ) - Atom AtomUserErr_; -#define AtomUserErr Yap_heap_regs->AtomUserErr_ -#define TermUserErr MkAtomTerm( Yap_heap_regs->AtomUserErr_ ) - Atom AtomUserIn_; -#define AtomUserIn Yap_heap_regs->AtomUserIn_ -#define TermUserIn MkAtomTerm( Yap_heap_regs->AtomUserIn_ ) - Atom AtomUserOut_; -#define AtomUserOut Yap_heap_regs->AtomUserOut_ -#define TermUserOut MkAtomTerm( Yap_heap_regs->AtomUserOut_ ) - Atom AtomDollarVar_; -#define AtomDollarVar Yap_heap_regs->AtomDollarVar_ -#define TermDollarVar MkAtomTerm( Yap_heap_regs->AtomDollarVar_ ) - Atom AtomVBar_; -#define AtomVBar Yap_heap_regs->AtomVBar_ -#define TermVBar MkAtomTerm( Yap_heap_regs->AtomVBar_ ) - Atom AtomVarBranches_; -#define AtomVarBranches Yap_heap_regs->AtomVarBranches_ -#define TermVarBranches MkAtomTerm( Yap_heap_regs->AtomVarBranches_ ) - Atom AtomVariableNames_; -#define AtomVariableNames Yap_heap_regs->AtomVariableNames_ -#define TermVariableNames MkAtomTerm( Yap_heap_regs->AtomVariableNames_ ) - Atom AtomHiddenVar_; -#define AtomHiddenVar Yap_heap_regs->AtomHiddenVar_ -#define TermHiddenVar MkAtomTerm( Yap_heap_regs->AtomHiddenVar_ ) - Atom AtomVariable_; -#define AtomVariable Yap_heap_regs->AtomVariable_ -#define TermVariable MkAtomTerm( Yap_heap_regs->AtomVariable_ ) - Atom AtomVerbose_; -#define AtomVerbose Yap_heap_regs->AtomVerbose_ -#define TermVerbose MkAtomTerm( Yap_heap_regs->AtomVerbose_ ) - Atom AtomVerboseFileSearch_; -#define AtomVerboseFileSearch Yap_heap_regs->AtomVerboseFileSearch_ -#define TermVerboseFileSearch MkAtomTerm( Yap_heap_regs->AtomVerboseFileSearch_ ) - Atom AtomVersionNumber_; -#define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_ -#define TermVersionNumber MkAtomTerm( Yap_heap_regs->AtomVersionNumber_ ) - Atom AtomVeryVerbose_; -#define AtomVeryVerbose Yap_heap_regs->AtomVeryVerbose_ -#define TermVeryVerbose MkAtomTerm( Yap_heap_regs->AtomVeryVerbose_ ) - Atom AtomWakeUpGoal_; -#define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_ -#define TermWakeUpGoal MkAtomTerm( Yap_heap_regs->AtomWakeUpGoal_ ) - Atom AtomWarning_; -#define AtomWarning Yap_heap_regs->AtomWarning_ -#define TermWarning MkAtomTerm( Yap_heap_regs->AtomWarning_ ) - Atom AtomWhen_; -#define AtomWhen Yap_heap_regs->AtomWhen_ -#define TermWhen MkAtomTerm( Yap_heap_regs->AtomWhen_ ) - Atom AtomWrite_; -#define AtomWrite Yap_heap_regs->AtomWrite_ -#define TermWrite MkAtomTerm( Yap_heap_regs->AtomWrite_ ) - Atom AtomXml_; -#define AtomXml Yap_heap_regs->AtomXml_ -#define TermXml MkAtomTerm( Yap_heap_regs->AtomXml_ ) - Atom AtomYapHacks_; -#define AtomYapHacks Yap_heap_regs->AtomYapHacks_ -#define TermYapHacks MkAtomTerm( Yap_heap_regs->AtomYapHacks_ ) - Atom AtomZeroDivisor_; -#define AtomZeroDivisor Yap_heap_regs->AtomZeroDivisor_ -#define TermZeroDivisor MkAtomTerm( Yap_heap_regs->AtomZeroDivisor_ ) - Functor FunctorAfInet_; -#define FunctorAfInet Yap_heap_regs->FunctorAfInet_ - Functor FunctorAfLocal_; -#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_ - 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_ - Functor FunctorCleanCall_; -#define FunctorCleanCall Yap_heap_regs->FunctorCleanCall_ - Functor FunctorClist_; -#define FunctorClist Yap_heap_regs->FunctorClist_ - Functor FunctorCodes_; -#define FunctorCodes Yap_heap_regs->FunctorCodes_ - Functor FunctorCodes1_; -#define FunctorCodes1 Yap_heap_regs->FunctorCodes1_ - Functor FunctorComma_; -#define FunctorComma Yap_heap_regs->FunctorComma_ - Functor FunctorCommentHook_; -#define FunctorCommentHook Yap_heap_regs->FunctorCommentHook_ - Functor FunctorContext2_; -#define FunctorContext2 Yap_heap_regs->FunctorContext2_ - 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_ - Functor FunctorDBREF_; -#define FunctorDBREF Yap_heap_regs->FunctorDBREF_ - Functor FunctorDiff_; -#define FunctorDiff Yap_heap_regs->FunctorDiff_ - 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_ - 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_ - Functor FunctorDoubleSlash_; -#define FunctorDoubleSlash Yap_heap_regs->FunctorDoubleSlash_ - 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_ - 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_ - Functor FunctorExistenceError_; -#define FunctorExistenceError Yap_heap_regs->FunctorExistenceError_ - 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_ - 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_ - 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_ - 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_ - Functor FunctorPermissionError_; -#define FunctorPermissionError Yap_heap_regs->FunctorPermissionError_ - Functor FunctorPlus_; -#define FunctorPlus Yap_heap_regs->FunctorPlus_ - Functor FunctorPortray_; -#define FunctorPortray Yap_heap_regs->FunctorPortray_ - Functor FunctorPrintMessage_; -#define FunctorPrintMessage Yap_heap_regs->FunctorPrintMessage_ - Functor FunctorProcedure_; -#define FunctorProcedure Yap_heap_regs->FunctorProcedure_ - Functor FunctorPrologConstraint_; -#define FunctorPrologConstraint Yap_heap_regs->FunctorPrologConstraint_ - Functor FunctorQuery_; -#define FunctorQuery Yap_heap_regs->FunctorQuery_ - Functor FunctorRecordedWithKey_; -#define FunctorRecordedWithKey Yap_heap_regs->FunctorRecordedWithKey_ - Functor FunctorRDiv_; -#define FunctorRDiv Yap_heap_regs->FunctorRDiv_ - Functor FunctorRedoFreeze_; -#define FunctorRedoFreeze Yap_heap_regs->FunctorRedoFreeze_ - 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_ - Functor FunctorStyleCheck_; -#define FunctorStyleCheck Yap_heap_regs->FunctorStyleCheck_ - Functor FunctorSyntaxError_; -#define FunctorSyntaxError Yap_heap_regs->FunctorSyntaxError_ - 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_ - Functor FunctorTraceMetaCall_; -#define FunctorTraceMetaCall Yap_heap_regs->FunctorTraceMetaCall_ - 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_ - Functor FunctorHiddenVar_; -#define FunctorHiddenVar Yap_heap_regs->FunctorHiddenVar_ diff --git a/H/iatoms.h b/H/iatoms.h deleted file mode 100644 index 447e7a007..000000000 --- a/H/iatoms.h +++ /dev/null @@ -1,548 +0,0 @@ - - /* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms" - please do not update, update misc/ATOMS instead */ - - Atom3Dots = Yap_LookupAtom("..."); - AtomAbol = Yap_FullLookupAtom("$abol"); - AtomAccess = Yap_LookupAtom("access"); - AtomAfInet = Yap_LookupAtom("AF_INET"); - AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); - AtomAfUnix = Yap_LookupAtom("AF_UNIX"); - AtomAlarm = Yap_FullLookupAtom("$alarm"); - AtomAlias = Yap_LookupAtom("alias"); - AtomAll = Yap_LookupAtom("all"); - AtomAltNot = Yap_LookupAtom("not"); - AtomAny = Yap_LookupAtom("any"); - AtomAppend = Yap_LookupAtom("append"); - AtomArg = Yap_LookupAtom("arg"); - AtomArray = Yap_FullLookupAtom("$array"); - AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); - AtomArrayOverflow = Yap_LookupAtom("array_overflow"); - AtomArrayType = Yap_LookupAtom("array_type"); - AtomArrow = Yap_LookupAtom("->"); - AtomAttributedModule = Yap_LookupAtom("attributes_module"); - AtomDoubleArrow = Yap_LookupAtom("-->"); - AtomAssert = Yap_LookupAtom(":-"); - AtomEmptyBrackets = Yap_LookupAtom("()"); - AtomEmptySquareBrackets = Yap_LookupAtom("[]"); - AtomEmptyCurlyBrackets = Yap_LookupAtom("{}"); - AtomAsserta = Yap_LookupAtom("asserta"); - AtomAssertaStatic = Yap_LookupAtom("asserta_static"); - AtomAssertz = Yap_LookupAtom("assertz"); - AtomAssertzStatic = Yap_LookupAtom("assertz_static"); - AtomAt = Yap_LookupAtom("at"); - AtomAtom = Yap_LookupAtom("atom"); - AtomAtomic = Yap_LookupAtom("atomic"); - AtomAtt = Yap_FullLookupAtom("$att"); - AtomAtt1 = Yap_LookupAtom("att"); - AtomAttDo = Yap_FullLookupAtom("$att_do"); - AtomAttributes = Yap_LookupAtom("attributes"); - AtomB = Yap_FullLookupAtom("$last_choice_pt"); - AtomBatched = Yap_LookupAtom("batched"); - AtomBetween = Yap_LookupAtom("between"); - AtomBinary = Yap_LookupAtom("binary"); - AtomBigNum = Yap_LookupAtom("big_num"); - AtomBinaryStream = Yap_LookupAtom("binary_stream"); - AtomBoolean = Yap_LookupAtom("boolean"); - AtomBraces = Yap_LookupAtom("{}"); - AtomBreak = Yap_FullLookupAtom("$break"); - AtomByte = Yap_LookupAtom("byte"); - AtomCArith = Yap_FullLookupAtom("$c_arith"); - AtomCall = Yap_LookupAtom("call"); - AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); - AtomCallCounter = Yap_LookupAtom("call_counter"); - AtomCallable = Yap_LookupAtom("callable"); - AtomCatch = Yap_FullLookupAtom("$catch"); - AtomChangeModule = Yap_FullLookupAtom("$change_module"); - AtomChar = Yap_LookupAtom("char"); - AtomCharsio = Yap_LookupAtom("charsio"); - AtomCharacter = Yap_LookupAtom("character"); - AtomCharacterCode = Yap_LookupAtom("character_code"); - AtomChars = Yap_LookupAtom("chars"); - AtomCharset = Yap_LookupAtom("charset"); - AtomChType = Yap_FullLookupAtom("$char_type"); - AtomCleanCall = Yap_FullLookupAtom("$clean_call"); - AtomColomn = Yap_LookupAtom(":"); - AtomCodeSpace = Yap_LookupAtom("code_space"); - AtomCodes = Yap_LookupAtom("codes"); - AtomCoInductive = Yap_LookupAtom("coinductive"); - AtomComma = Yap_LookupAtom(","); - AtomCommentHook = Yap_LookupAtom("comment_hook"); - AtomCompact = Yap_LookupAtom("compact"); - AtomCompound = Yap_LookupAtom("compound"); - AtomConsistencyError = Yap_LookupAtom("consistency_error"); - AtomConsult = Yap_LookupAtom("consult"); - AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); - AtomContext = Yap_LookupAtom("context"); - AtomCputime = Yap_LookupAtom("cputime"); - AtomCreate = Yap_LookupAtom("create"); - AtomCreep = Yap_FullLookupAtom("$creep"); - AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); - AtomCsult = Yap_FullLookupAtom("$csult"); - AtomCurrentModule = Yap_FullLookupAtom("$current_module"); - AtomCut = Yap_LookupAtom("!"); - AtomCutBy = Yap_FullLookupAtom("$cut_by"); - AtomDAbort = Yap_FullLookupAtom("$abort"); - AtomDBLoad = Yap_FullLookupAtom("$db_load"); - AtomDBREF = Yap_LookupAtom("DBRef"); - AtomDBReference = Yap_LookupAtom("db_reference"); - AtomDBTerm = Yap_LookupAtom("db_term"); - AtomDBref = Yap_FullLookupAtom("$dbref"); - AtomDInteger = Yap_FullLookupAtom("$integer"); - AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); - AtomDebuggerInput = Yap_LookupAtom("debugger_input"); - AtomDec10 = Yap_LookupAtom("dec10"); - AtomDefault = Yap_LookupAtom("default"); - AtomDevNull = Yap_LookupAtom("/dev/null"); - AtomDiff = Yap_LookupAtom("\\="); - AtomDirectory = Yap_LookupAtom("disrectorys"); - AtomDiscontiguous = Yap_LookupAtom("discontiguous"); - AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); - AtomDollar = Yap_FullLookupAtom("$"); - AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); - AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); - AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); - AtomDollarU = Yap_FullLookupAtom("$u"); - AtomDollarUndef = Yap_FullLookupAtom("$undef"); - AtomDomainError = Yap_LookupAtom("domain_error"); - AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); - AtomDots = Yap_LookupAtom("dots"); - AtomDOUBLE = Yap_FullLookupAtom("Double"); - AtomDoubleSlash = Yap_FullLookupAtom("//"); - AtomE = Yap_LookupAtom("e"); - AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); - AtomEQ = Yap_LookupAtom("="); - AtomEmptyAtom = Yap_LookupAtom(""); - AtomEncoding = Yap_LookupAtom("encoding"); - AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); - AtomEof = Yap_LookupAtom("end_of_file"); - AtomEOfCode = Yap_LookupAtom("eof_code"); - AtomEq = Yap_LookupAtom("="); - AtomError = Yap_LookupAtom("error"); - AtomException = Yap_LookupAtom("exception"); - AtomExtensions = Yap_LookupAtom("extensions"); - AtomEvaluable = Yap_LookupAtom("evaluable"); - AtomEvaluationError = Yap_LookupAtom("evaluation_error"); - AtomExecutable = Yap_LookupAtom("executable"); - AtomExecute = Yap_LookupAtom("execute"); - AtomExecAnswers = Yap_LookupAtom("exec_answers"); - AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); - AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); - AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); - AtomExist = Yap_LookupAtom("exist"); - AtomExistenceError = Yap_LookupAtom("existence_error"); - AtomExoClause = Yap_FullLookupAtom("$exo_clause"); - AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); - AtomExpand = Yap_LookupAtom("expand"); - AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); - AtomExtendsions = Yap_LookupAtom("extensionh"); - AtomFB = Yap_LookupAtom("fb"); - AtomFail = Yap_LookupAtom("fail"); - AtomFalse = Yap_LookupAtom("false"); - AtomFast = Yap_FullLookupAtom("$fast"); - AtomFastFail = Yap_LookupAtom("fast_fail"); - AtomFileErrors = Yap_LookupAtom("file_errors"); - AtomFileerrors = Yap_LookupAtom("fileerrors"); - AtomFileType = Yap_LookupAtom("file_type"); - AtomFirst = Yap_LookupAtom("first"); - AtomFloat = Yap_LookupAtom("float"); - AtomFloatFormat = Yap_LookupAtom("\%.15g"); - AtomFloatOverflow = Yap_LookupAtom("float_overflow"); - AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); - AtomFormat = Yap_LookupAtom("format"); - AtomFormatAt = Yap_FullLookupAtom("$format@"); - AtomFull = Yap_LookupAtom("full"); - AtomFunctor = Yap_LookupAtom("functor"); - AtomGT = Yap_LookupAtom(">"); - AtomGVar = Yap_LookupAtom("var"); - AtomGc = Yap_FullLookupAtom("$gc"); - AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); - AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); - AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); - AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); - AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); - AtomGetwork = Yap_FullLookupAtom("$getwork"); - AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); - AtomGlob = Yap_LookupAtom("glob"); - AtomGlobal = Yap_LookupAtom("global"); - AtomGlobalSp = Yap_LookupAtom("global_sp"); - AtomGlobalTrie = Yap_LookupAtom("global_trie"); - AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); - AtomHat = Yap_LookupAtom("^"); - AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); - AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); - AtomHeap = Yap_LookupAtom("heap"); - AtomHeapUsed = Yap_LookupAtom("heapused"); - AtomHugeInt = Yap_LookupAtom("huge_int"); - AtomIDB = Yap_LookupAtom("idb"); - AtomIOMode = Yap_LookupAtom("io_mode"); - AtomId = Yap_LookupAtom("id"); - AtomIgnore = Yap_LookupAtom("ignore"); - AtomInf = Yap_LookupAtom("inf"); - AtomInfinity = Yap_LookupAtom("infinity"); - AtomInitGoal = Yap_FullLookupAtom("$init_goal"); - AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); - AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); - AtomInput = Yap_LookupAtom("input"); - AtomInstantiationError = Yap_LookupAtom("instantiation_error"); - AtomInt = Yap_LookupAtom("int"); - AtomIntOverflow = Yap_LookupAtom("int_overflow"); - AtomInteger = Yap_LookupAtom("integer"); - AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); - AtomIs = Yap_LookupAtom("is"); - AtomKey = Yap_LookupAtom("key"); - AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); - AtomLONGINT = Yap_LookupAtom("LongInt"); - AtomLOOP = Yap_LookupAtom("_LOOP_"); - AtomLoopStream = Yap_LookupAtom("loop_stream"); - AtomLT = Yap_LookupAtom("<"); - AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); - AtomLeash = Yap_FullLookupAtom("$leash"); - AtomLeast = Yap_LookupAtom("least"); - AtomLength = Yap_FullLookupAtom("length"); - AtomList = Yap_LookupAtom("list"); - AtomLine = Yap_LookupAtom("line"); - AtomLive = Yap_FullLookupAtom("$live"); - AtomLoadAnswers = Yap_LookupAtom("load_answers"); - AtomLocal = Yap_LookupAtom("local"); - AtomLocalSp = Yap_LookupAtom("local_sp"); - AtomLocalTrie = Yap_LookupAtom("local_trie"); - AtomMax = Yap_LookupAtom("max"); - AtomMaximum = Yap_LookupAtom("maximum"); - AtomMaxArity = Yap_LookupAtom("max_arity"); - AtomMaxFiles = Yap_LookupAtom("max_files"); - AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); - AtomMetaCall = Yap_FullLookupAtom("$call"); - AtomMfClause = Yap_FullLookupAtom("$mf_clause"); - AtomMin = Yap_LookupAtom("min"); - AtomMinimum = Yap_LookupAtom("minimum"); - AtomMinus = Yap_LookupAtom("-"); - AtomModify = Yap_LookupAtom("modify"); - AtomModule = Yap_LookupAtom("module"); - AtomMost = Yap_LookupAtom("most"); - AtomMulti = Yap_LookupAtom("multi"); - AtomMultiFile = Yap_FullLookupAtom("$mf"); - AtomMultiple = Yap_FullLookupAtom("multiple"); - AtomMutable = Yap_LookupAtom("mutable"); - AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); - AtomMutex = Yap_LookupAtom("mutex"); - AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); - AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); - AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); - AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); - AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); - AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); - AtomNan = Yap_LookupAtom("nan"); - AtomNb = Yap_LookupAtom("nb"); - AtomNbTerm = Yap_LookupAtom("nb_term"); - AtomNew = Yap_LookupAtom("new"); - AtomNewLine = Yap_LookupAtom("nl"); - AtomNl = Yap_LookupAtom("nl"); - AtomNoEffect = Yap_LookupAtom("no_effect"); - AtomNoMemory = Yap_LookupAtom("no_memory"); - AtomNone = Yap_LookupAtom("none"); - AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); - AtomNot = Yap_LookupAtom("\\+"); - AtomNotImplemented = Yap_LookupAtom("not_implemented"); - AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); - AtomNotNewline = Yap_LookupAtom("not_newline"); - AtomNotZero = Yap_LookupAtom("not_zero"); - AtomNumber = Yap_LookupAtom("number"); - AtomOff = Yap_LookupAtom("off"); - AtomOffline = Yap_LookupAtom("offline"); - AtomOn = Yap_LookupAtom("on"); - AtomOnline = Yap_LookupAtom("online"); - AtomOpen = Yap_LookupAtom("open"); - AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); - AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); - AtomOperator = Yap_LookupAtom("operator"); - AtomOperatorPriority = Yap_LookupAtom("operator_priority"); - AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); - AtomOpt = Yap_LookupAtom("opt"); - AtomOtherwise = Yap_LookupAtom("otherwise"); - AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); - AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); - AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); - AtomOutOfRange = Yap_LookupAtom("out_of_range"); - AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); - AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); - AtomOutput = Yap_LookupAtom("output"); - AtomParameter = Yap_LookupAtom("parameter"); - AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); - AtomPast = Yap_LookupAtom("past"); - AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); - AtomPermissionError = Yap_LookupAtom("permission_error"); - AtomPi = Yap_LookupAtom("pi"); - AtomPipe = Yap_LookupAtom("pipe"); - AtomPlus = Yap_LookupAtom("+"); - AtomPointer = Yap_LookupAtom("pointer"); - AtomPortray = Yap_FullLookupAtom("portray"); - AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); - AtomPrimitive = Yap_LookupAtom("primitive"); - AtomPrintMessage = Yap_LookupAtom("print_message"); - AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); - AtomProcedure = Yap_LookupAtom("procedure"); - AtomProfile = Yap_FullLookupAtom("$profile"); - AtomProlog = Yap_LookupAtom("prolog"); - AtomQly = Yap_LookupAtom("qly"); - AtomQuery = Yap_LookupAtom("?-"); - AtomQueue = Yap_LookupAtom("queue"); - AtomQuiet = Yap_LookupAtom("quiet"); - AtomRadix = Yap_LookupAtom("radix"); - AtomRandom = Yap_LookupAtom("random"); - AtomRange = Yap_LookupAtom("range"); - AtomRDiv = Yap_LookupAtom("rdiv"); - AtomRead = Yap_LookupAtom("read"); - AtomReadOnly = Yap_LookupAtom("read_only"); - AtomReadWrite = Yap_LookupAtom("read_write"); - AtomReadutil = Yap_LookupAtom("readutil"); - AtomReconsult = Yap_LookupAtom("reconsult"); - AtomRecordedP = Yap_FullLookupAtom("$recordep"); - AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); - AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); - AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); - AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); - AtomRelativeTo = Yap_FullLookupAtom("relative_to"); - AtomRepeat = Yap_LookupAtom("repeat"); - AtomRepeatSpace = Yap_LookupAtom("repeat "); - AtomReposition = Yap_LookupAtom("reposition"); - AtomRepresentationError = Yap_LookupAtom("representation_error"); - AtomReset = Yap_LookupAtom("reset"); - AtomResize = Yap_LookupAtom("resize"); - AtomResourceError = Yap_LookupAtom("resource_error"); - AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); - AtomRetryCounter = Yap_LookupAtom("retry_counter"); - AtomRTree = Yap_LookupAtom("rtree"); - AtomSafe = Yap_FullLookupAtom("$safe"); - AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); - AtomSame = Yap_LookupAtom("=="); - AtomSemic = Yap_LookupAtom(";"); - AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); - AtomSigAlarm = Yap_LookupAtom("sig_alarm"); - AtomSigBreak = Yap_LookupAtom("sig_break"); - AtomSigCreep = Yap_LookupAtom("sig_creep"); - AtomSigDebug = Yap_LookupAtom("sig_debug"); - AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); - AtomSigFPE = Yap_LookupAtom("sig_fpe"); - AtomSigHup = Yap_LookupAtom("sig_hup"); - AtomSigInt = Yap_LookupAtom("sig_int"); - AtomSigIti = Yap_LookupAtom("sig_iti"); - AtomSigPending = Yap_FullLookupAtom("$sig_pending"); - AtomSigPipe = Yap_LookupAtom("sig_pipe"); - AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); - AtomSigStatistics = Yap_LookupAtom("sig_statistics"); - AtomSigTrace = Yap_LookupAtom("sig_trace"); - AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); - AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); - AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); - AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); - AtomSilent = Yap_LookupAtom("Silent"); - AtomSingle = Yap_LookupAtom("single"); - AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); - AtomSingleton = Yap_LookupAtom("singleton"); - AtomSlash = Yap_LookupAtom("/"); - AtomSocket = Yap_LookupAtom("socket"); - AtomSolutions = Yap_LookupAtom("solutions"); - AtomSource = Yap_LookupAtom("source"); - AtomSourceSink = Yap_LookupAtom("source_sink"); - AtomSpy = Yap_FullLookupAtom("$spy"); - AtomStack = Yap_LookupAtom("stack"); - AtomStackFree = Yap_LookupAtom("stackfree"); - AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); - AtomStaticClause = Yap_FullLookupAtom("$static_clause"); - AtomStaticProcedure = Yap_LookupAtom("static_procedure"); - AtomStream = Yap_FullLookupAtom("$stream"); - AtomSWIStream = Yap_FullLookupAtom(""); - AtomVStream = Yap_LookupAtom("stream"); - AtomStreams = Yap_LookupAtom("streams"); - AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); - AtomStreamPos = Yap_FullLookupAtom("$stream_position"); - AtomStreamPosition = Yap_LookupAtom("stream_position"); - AtomString = Yap_LookupAtom("string"); - AtomStyleCheck = Yap_LookupAtom("style_check"); - AtomSTRING = Yap_FullLookupAtom("String"); - AtomSwi = Yap_LookupAtom("swi"); - AtomSymbolChar = Yap_LookupAtom("symbol_char"); - AtomSyntaxError = Yap_LookupAtom("syntax_error"); - AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); - AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); - AtomSystem = Yap_LookupAtom("system"); - AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); - AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); - AtomTerm = Yap_LookupAtom("term"); - AtomTerms = Yap_LookupAtom("terms"); - AtomTermExpansion = Yap_LookupAtom("term_expansion"); - AtomText = Yap_LookupAtom("text"); - AtomTextStream = Yap_LookupAtom("text_stream"); - AtomThread = Yap_LookupAtom("thread"); - AtomThreads = Yap_LookupAtom("threads"); - AtomThrow = Yap_LookupAtom("throw"); - AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); - AtomTimeoutError = Yap_LookupAtom("timeout_error"); - AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); - AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); - AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); - AtomTrail = Yap_LookupAtom("trail"); - AtomTrue = Yap_LookupAtom("true"); - AtomTty = Yap_LookupAtom("tty"); - AtomTtys = Yap_LookupAtom("ttys"); - AtomTxt = Yap_LookupAtom("txt"); - AtomTypeError = Yap_LookupAtom("type_error"); - AtomUndefined = Yap_LookupAtom("undefined"); - AtomUndefp = Yap_FullLookupAtom("$undefp"); - AtomUnderflow = Yap_LookupAtom("underflow"); - AtomUnificationStack = Yap_LookupAtom("unification_stack"); - AtomUnique = Yap_LookupAtom("unique"); - AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); - AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); - AtomUser = Yap_LookupAtom("user"); - AtomUserErr = Yap_LookupAtom("user_error"); - AtomUserIn = Yap_LookupAtom("user_input"); - AtomUserOut = Yap_LookupAtom("user_output"); - AtomDollarVar = Yap_LookupAtom("$VAR"); - AtomVBar = Yap_LookupAtom("|"); - AtomVarBranches = Yap_LookupAtom("var_branches"); - AtomVariableNames = Yap_LookupAtom("variable_names"); - AtomHiddenVar = Yap_FullLookupAtom("$V"); - AtomVariable = Yap_LookupAtom("variable"); - AtomVerbose = Yap_LookupAtom("verbose"); - AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); - AtomVersionNumber = Yap_FullLookupAtom("$version_name"); - AtomVeryVerbose = Yap_LookupAtom("very_verbose"); - AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); - AtomWarning = Yap_LookupAtom("warning"); - AtomWhen = Yap_FullLookupAtom("$when"); - AtomWrite = Yap_LookupAtom("write"); - AtomXml = Yap_LookupAtom("xml"); - AtomYapHacks = Yap_LookupAtom("yap_hacks"); - AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); - FunctorAfInet = Yap_MkFunctor(AtomAfInet,2); - FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1); - FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1); - FunctorAltNot = Yap_MkFunctor(AtomAltNot,1); - FunctorArg = Yap_MkFunctor(AtomArg,3); - FunctorArrayEntry = Yap_MkFunctor(AtomArrayAccess,3); - FunctorArrow = Yap_MkFunctor(AtomArrow,2); - FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2); - FunctorAssert1 = Yap_MkFunctor(AtomAssert,1); - FunctorAssert = Yap_MkFunctor(AtomAssert,2); - FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2); - FunctorAtom = Yap_MkFunctor(AtomAtom,1); - FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3); - FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2); - FunctorBraces = Yap_MkFunctor(AtomBraces,1); - FunctorCall = Yap_MkFunctor(AtomCall,1); - FunctorCatch = Yap_MkFunctor(AtomCatch,3); - FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1); - FunctorChars = Yap_MkFunctor(AtomChars,2); - FunctorChars1 = Yap_MkFunctor(AtomChars,1); - FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2); - FunctorClist = Yap_MkFunctor(AtomWhen,4); - FunctorCodes = Yap_MkFunctor(AtomCodes,2); - FunctorCodes1 = Yap_MkFunctor(AtomCodes,1); - FunctorComma = Yap_MkFunctor(AtomComma,2); - FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3); - FunctorContext2 = Yap_MkFunctor(AtomContext,2); - FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1); - FunctorCreep = Yap_MkFunctor(AtomCreep,1); - FunctorCsult = Yap_MkFunctor(AtomCsult,2); - FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1); - FunctorCutBy = Yap_MkFunctor(AtomCutBy,1); - FunctorDBREF = Yap_MkFunctor(AtomDBREF,1); - FunctorDiff = Yap_MkFunctor(AtomDiff,2); - FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6); - FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6); - FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6); - FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5); - FunctorDollarVar = Yap_MkFunctor(AtomDollarVar,1); - FunctorDomainError = Yap_MkFunctor(AtomDomainError,2); - FunctorDot = Yap_MkFunctor(AtomDot,2); - FunctorDot10 = Yap_MkFunctor(AtomDot,10); - FunctorDot11 = Yap_MkFunctor(AtomDot,11); - FunctorDot12 = Yap_MkFunctor(AtomDot,12); - FunctorDot2 = Yap_MkFunctor(AtomDot,2); - FunctorDot3 = Yap_MkFunctor(AtomDot,3); - FunctorDot4 = Yap_MkFunctor(AtomDot,4); - FunctorDot5 = Yap_MkFunctor(AtomDot,5); - FunctorDot6 = Yap_MkFunctor(AtomDot,6); - FunctorDot7 = Yap_MkFunctor(AtomDot,7); - FunctorDot8 = Yap_MkFunctor(AtomDot,8); - FunctorDot9 = Yap_MkFunctor(AtomDot,9); - FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2); - FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2); - FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2); - FunctorEq = Yap_MkFunctor(AtomEq,2); - FunctorError = Yap_MkFunctor(AtomError,2); - FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1); - FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2); - FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2); - FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1); - FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2); - FunctorExoClause = Yap_MkFunctor(AtomExoClause,2); - FunctorFunctor = Yap_MkFunctor(AtomFunctor,3); - FunctorGAtom = Yap_MkFunctor(AtomAtom,1); - FunctorGAtomic = Yap_MkFunctor(AtomAtomic,1); - FunctorGCompound = Yap_MkFunctor(AtomCompound,1); - FunctorGFloat = Yap_MkFunctor(AtomFloat,1); - FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2); - FunctorGInteger = Yap_MkFunctor(AtomInteger,1); - FunctorGNumber = Yap_MkFunctor(AtomNumber,1); - FunctorGPrimitive = Yap_MkFunctor(AtomPrimitive,1); - FunctorGVar = Yap_MkFunctor(AtomGVar,1); - FunctorGeneratePredInfo = Yap_MkFunctor(AtomGeneratePredInfo,4); - FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2); - FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3); - FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3); - FunctorHat = Yap_MkFunctor(AtomHat,2); - FunctorId = Yap_MkFunctor(AtomId,1); - FunctorIs = Yap_MkFunctor(AtomIs,2); - FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1); - FunctorList = Yap_MkFunctor(AtomDot,2); - FunctorLOOP = Yap_MkFunctor(AtomLOOP,1); - FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2); - FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4); - FunctorMinus = Yap_MkFunctor(AtomMinus,2); - FunctorModule = Yap_MkFunctor(AtomColomn,2); - FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5); - FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL))); - FunctorMutex = Yap_MkFunctor(AtomMutex,2); - FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2); - FunctorNBQueue = Yap_MkFunctor(AtomQueue,4); - FunctorNot = Yap_MkFunctor(AtomNot,1); - FunctorOr = Yap_MkFunctor(AtomSemic,2); - FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3); - FunctorPlus = Yap_MkFunctor(AtomPlus,2); - FunctorPortray = Yap_MkFunctor(AtomPortray,1); - FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2); - FunctorProcedure = Yap_MkFunctor(AtomProcedure,5); - FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2); - FunctorQuery = Yap_MkFunctor(AtomQuery,1); - FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6); - FunctorRDiv = Yap_MkFunctor(AtomRDiv,2); - FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3); - FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1); - FunctorResourceError = Yap_MkFunctor(AtomResourceError,1); - FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2); - FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1); - FunctorSafe = Yap_MkFunctor(AtomSafe,1); - FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4); - FunctorSame = Yap_MkFunctor(AtomSame,2); - FunctorSlash = Yap_MkFunctor(AtomSlash,2); - FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2); - FunctorStream = Yap_MkFunctor(AtomStream,1); - FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1); - FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4); - FunctorString1 = Yap_MkFunctor(AtomString,1); - FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4); - FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4); - FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1); - FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2); - FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2); - FunctorThrow = Yap_MkFunctor(AtomThrow,1); - FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2); - FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3); - FunctorTypeError = Yap_MkFunctor(AtomTypeError,2); - FunctorUMinus = Yap_MkFunctor(AtomMinus,1); - FunctorUPlus = Yap_MkFunctor(AtomPlus,1); - FunctorVBar = Yap_MkFunctor(AtomVBar,2); - FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1); diff --git a/H/ratoms.h b/H/ratoms.h deleted file mode 100644 index e86e7371b..000000000 --- a/H/ratoms.h +++ /dev/null @@ -1,548 +0,0 @@ - - /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" - please do not update, update misc/ATOMS instead */ - - Atom3Dots = AtomAdjust(Atom3Dots); - AtomAbol = AtomAdjust(AtomAbol); - AtomAccess = AtomAdjust(AtomAccess); - AtomAfInet = AtomAdjust(AtomAfInet); - AtomAfLocal = AtomAdjust(AtomAfLocal); - AtomAfUnix = AtomAdjust(AtomAfUnix); - AtomAlarm = AtomAdjust(AtomAlarm); - AtomAlias = AtomAdjust(AtomAlias); - AtomAll = AtomAdjust(AtomAll); - AtomAltNot = AtomAdjust(AtomAltNot); - AtomAny = AtomAdjust(AtomAny); - AtomAppend = AtomAdjust(AtomAppend); - AtomArg = AtomAdjust(AtomArg); - AtomArray = AtomAdjust(AtomArray); - AtomArrayAccess = AtomAdjust(AtomArrayAccess); - AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); - AtomArrayType = AtomAdjust(AtomArrayType); - AtomArrow = AtomAdjust(AtomArrow); - AtomAttributedModule = AtomAdjust(AtomAttributedModule); - AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); - AtomAssert = AtomAdjust(AtomAssert); - AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); - AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); - AtomEmptyCurlyBrackets = AtomAdjust(AtomEmptyCurlyBrackets); - AtomAsserta = AtomAdjust(AtomAsserta); - AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); - AtomAssertz = AtomAdjust(AtomAssertz); - AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); - AtomAt = AtomAdjust(AtomAt); - AtomAtom = AtomAdjust(AtomAtom); - AtomAtomic = AtomAdjust(AtomAtomic); - AtomAtt = AtomAdjust(AtomAtt); - AtomAtt1 = AtomAdjust(AtomAtt1); - AtomAttDo = AtomAdjust(AtomAttDo); - AtomAttributes = AtomAdjust(AtomAttributes); - AtomB = AtomAdjust(AtomB); - AtomBatched = AtomAdjust(AtomBatched); - AtomBetween = AtomAdjust(AtomBetween); - AtomBinary = AtomAdjust(AtomBinary); - AtomBigNum = AtomAdjust(AtomBigNum); - AtomBinaryStream = AtomAdjust(AtomBinaryStream); - AtomBoolean = AtomAdjust(AtomBoolean); - AtomBraces = AtomAdjust(AtomBraces); - AtomBreak = AtomAdjust(AtomBreak); - AtomByte = AtomAdjust(AtomByte); - AtomCArith = AtomAdjust(AtomCArith); - AtomCall = AtomAdjust(AtomCall); - AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); - AtomCallCounter = AtomAdjust(AtomCallCounter); - AtomCallable = AtomAdjust(AtomCallable); - AtomCatch = AtomAdjust(AtomCatch); - AtomChangeModule = AtomAdjust(AtomChangeModule); - AtomChar = AtomAdjust(AtomChar); - AtomCharsio = AtomAdjust(AtomCharsio); - AtomCharacter = AtomAdjust(AtomCharacter); - AtomCharacterCode = AtomAdjust(AtomCharacterCode); - AtomChars = AtomAdjust(AtomChars); - AtomCharset = AtomAdjust(AtomCharset); - AtomChType = AtomAdjust(AtomChType); - AtomCleanCall = AtomAdjust(AtomCleanCall); - AtomColomn = AtomAdjust(AtomColomn); - AtomCodeSpace = AtomAdjust(AtomCodeSpace); - AtomCodes = AtomAdjust(AtomCodes); - AtomCoInductive = AtomAdjust(AtomCoInductive); - AtomComma = AtomAdjust(AtomComma); - AtomCommentHook = AtomAdjust(AtomCommentHook); - AtomCompact = AtomAdjust(AtomCompact); - AtomCompound = AtomAdjust(AtomCompound); - AtomConsistencyError = AtomAdjust(AtomConsistencyError); - AtomConsult = AtomAdjust(AtomConsult); - AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); - AtomContext = AtomAdjust(AtomContext); - AtomCputime = AtomAdjust(AtomCputime); - AtomCreate = AtomAdjust(AtomCreate); - AtomCreep = AtomAdjust(AtomCreep); - AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); - AtomCsult = AtomAdjust(AtomCsult); - AtomCurrentModule = AtomAdjust(AtomCurrentModule); - AtomCut = AtomAdjust(AtomCut); - AtomCutBy = AtomAdjust(AtomCutBy); - AtomDAbort = AtomAdjust(AtomDAbort); - AtomDBLoad = AtomAdjust(AtomDBLoad); - AtomDBREF = AtomAdjust(AtomDBREF); - AtomDBReference = AtomAdjust(AtomDBReference); - AtomDBTerm = AtomAdjust(AtomDBTerm); - AtomDBref = AtomAdjust(AtomDBref); - AtomDInteger = AtomAdjust(AtomDInteger); - AtomDebugMeta = AtomAdjust(AtomDebugMeta); - AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); - AtomDec10 = AtomAdjust(AtomDec10); - AtomDefault = AtomAdjust(AtomDefault); - AtomDevNull = AtomAdjust(AtomDevNull); - AtomDiff = AtomAdjust(AtomDiff); - AtomDirectory = AtomAdjust(AtomDirectory); - AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); - AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); - AtomDollar = AtomAdjust(AtomDollar); - AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); - AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); - AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); - AtomDollarU = AtomAdjust(AtomDollarU); - AtomDollarUndef = AtomAdjust(AtomDollarUndef); - AtomDomainError = AtomAdjust(AtomDomainError); - AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); - AtomDots = AtomAdjust(AtomDots); - AtomDOUBLE = AtomAdjust(AtomDOUBLE); - AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); - AtomE = AtomAdjust(AtomE); - AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); - AtomEQ = AtomAdjust(AtomEQ); - AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); - AtomEncoding = AtomAdjust(AtomEncoding); - AtomEndOfStream = AtomAdjust(AtomEndOfStream); - AtomEof = AtomAdjust(AtomEof); - AtomEOfCode = AtomAdjust(AtomEOfCode); - AtomEq = AtomAdjust(AtomEq); - AtomError = AtomAdjust(AtomError); - AtomException = AtomAdjust(AtomException); - AtomExtensions = AtomAdjust(AtomExtensions); - AtomEvaluable = AtomAdjust(AtomEvaluable); - AtomEvaluationError = AtomAdjust(AtomEvaluationError); - AtomExecutable = AtomAdjust(AtomExecutable); - AtomExecute = AtomAdjust(AtomExecute); - AtomExecAnswers = AtomAdjust(AtomExecAnswers); - AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); - AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); - AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); - AtomExist = AtomAdjust(AtomExist); - AtomExistenceError = AtomAdjust(AtomExistenceError); - AtomExoClause = AtomAdjust(AtomExoClause); - AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); - AtomExpand = AtomAdjust(AtomExpand); - AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); - AtomExtendsions = AtomAdjust(AtomExtendsions); - AtomFB = AtomAdjust(AtomFB); - AtomFail = AtomAdjust(AtomFail); - AtomFalse = AtomAdjust(AtomFalse); - AtomFast = AtomAdjust(AtomFast); - AtomFastFail = AtomAdjust(AtomFastFail); - AtomFileErrors = AtomAdjust(AtomFileErrors); - AtomFileerrors = AtomAdjust(AtomFileerrors); - AtomFileType = AtomAdjust(AtomFileType); - AtomFirst = AtomAdjust(AtomFirst); - AtomFloat = AtomAdjust(AtomFloat); - AtomFloatFormat = AtomAdjust(AtomFloatFormat); - AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); - AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); - AtomFormat = AtomAdjust(AtomFormat); - AtomFormatAt = AtomAdjust(AtomFormatAt); - AtomFull = AtomAdjust(AtomFull); - AtomFunctor = AtomAdjust(AtomFunctor); - AtomGT = AtomAdjust(AtomGT); - AtomGVar = AtomAdjust(AtomGVar); - AtomGc = AtomAdjust(AtomGc); - AtomGcMargin = AtomAdjust(AtomGcMargin); - AtomGcTrace = AtomAdjust(AtomGcTrace); - AtomGcVerbose = AtomAdjust(AtomGcVerbose); - AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); - AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); - AtomGetwork = AtomAdjust(AtomGetwork); - AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); - AtomGlob = AtomAdjust(AtomGlob); - AtomGlobal = AtomAdjust(AtomGlobal); - AtomGlobalSp = AtomAdjust(AtomGlobalSp); - AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); - AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); - AtomHat = AtomAdjust(AtomHat); - AtomHERE = AtomAdjust(AtomHERE); - AtomHandleThrow = AtomAdjust(AtomHandleThrow); - AtomHeap = AtomAdjust(AtomHeap); - AtomHeapUsed = AtomAdjust(AtomHeapUsed); - AtomHugeInt = AtomAdjust(AtomHugeInt); - AtomIDB = AtomAdjust(AtomIDB); - AtomIOMode = AtomAdjust(AtomIOMode); - AtomId = AtomAdjust(AtomId); - AtomIgnore = AtomAdjust(AtomIgnore); - AtomInf = AtomAdjust(AtomInf); - AtomInfinity = AtomAdjust(AtomInfinity); - AtomInitGoal = AtomAdjust(AtomInitGoal); - AtomInitProlog = AtomAdjust(AtomInitProlog); - AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); - AtomInput = AtomAdjust(AtomInput); - AtomInstantiationError = AtomAdjust(AtomInstantiationError); - AtomInt = AtomAdjust(AtomInt); - AtomIntOverflow = AtomAdjust(AtomIntOverflow); - AtomInteger = AtomAdjust(AtomInteger); - AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); - AtomIs = AtomAdjust(AtomIs); - AtomKey = AtomAdjust(AtomKey); - AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); - AtomLONGINT = AtomAdjust(AtomLONGINT); - AtomLOOP = AtomAdjust(AtomLOOP); - AtomLoopStream = AtomAdjust(AtomLoopStream); - AtomLT = AtomAdjust(AtomLT); - AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); - AtomLeash = AtomAdjust(AtomLeash); - AtomLeast = AtomAdjust(AtomLeast); - AtomLength = AtomAdjust(AtomLength); - AtomList = AtomAdjust(AtomList); - AtomLine = AtomAdjust(AtomLine); - AtomLive = AtomAdjust(AtomLive); - AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); - AtomLocal = AtomAdjust(AtomLocal); - AtomLocalSp = AtomAdjust(AtomLocalSp); - AtomLocalTrie = AtomAdjust(AtomLocalTrie); - AtomMax = AtomAdjust(AtomMax); - AtomMaximum = AtomAdjust(AtomMaximum); - AtomMaxArity = AtomAdjust(AtomMaxArity); - AtomMaxFiles = AtomAdjust(AtomMaxFiles); - AtomMegaClause = AtomAdjust(AtomMegaClause); - AtomMetaCall = AtomAdjust(AtomMetaCall); - AtomMfClause = AtomAdjust(AtomMfClause); - AtomMin = AtomAdjust(AtomMin); - AtomMinimum = AtomAdjust(AtomMinimum); - AtomMinus = AtomAdjust(AtomMinus); - AtomModify = AtomAdjust(AtomModify); - AtomModule = AtomAdjust(AtomModule); - AtomMost = AtomAdjust(AtomMost); - AtomMulti = AtomAdjust(AtomMulti); - AtomMultiFile = AtomAdjust(AtomMultiFile); - AtomMultiple = AtomAdjust(AtomMultiple); - AtomMutable = AtomAdjust(AtomMutable); - AtomMutableVariable = AtomAdjust(AtomMutableVariable); - AtomMutex = AtomAdjust(AtomMutex); - AtomMyddasDB = AtomAdjust(AtomMyddasDB); - AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); - AtomMyddasHost = AtomAdjust(AtomMyddasHost); - AtomMyddasPass = AtomAdjust(AtomMyddasPass); - AtomMyddasUser = AtomAdjust(AtomMyddasUser); - AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); - AtomNan = AtomAdjust(AtomNan); - AtomNb = AtomAdjust(AtomNb); - AtomNbTerm = AtomAdjust(AtomNbTerm); - AtomNew = AtomAdjust(AtomNew); - AtomNewLine = AtomAdjust(AtomNewLine); - AtomNl = AtomAdjust(AtomNl); - AtomNoEffect = AtomAdjust(AtomNoEffect); - AtomNoMemory = AtomAdjust(AtomNoMemory); - AtomNone = AtomAdjust(AtomNone); - AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); - AtomNot = AtomAdjust(AtomNot); - AtomNotImplemented = AtomAdjust(AtomNotImplemented); - AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); - AtomNotNewline = AtomAdjust(AtomNotNewline); - AtomNotZero = AtomAdjust(AtomNotZero); - AtomNumber = AtomAdjust(AtomNumber); - AtomOff = AtomAdjust(AtomOff); - AtomOffline = AtomAdjust(AtomOffline); - AtomOn = AtomAdjust(AtomOn); - AtomOnline = AtomAdjust(AtomOnline); - AtomOpen = AtomAdjust(AtomOpen); - AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); - AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); - AtomOperator = AtomAdjust(AtomOperator); - AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); - AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); - AtomOpt = AtomAdjust(AtomOpt); - AtomOtherwise = AtomAdjust(AtomOtherwise); - AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); - AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); - AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); - AtomOutOfRange = AtomAdjust(AtomOutOfRange); - AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); - AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); - AtomOutput = AtomAdjust(AtomOutput); - AtomParameter = AtomAdjust(AtomParameter); - AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); - AtomPast = AtomAdjust(AtomPast); - AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); - AtomPermissionError = AtomAdjust(AtomPermissionError); - AtomPi = AtomAdjust(AtomPi); - AtomPipe = AtomAdjust(AtomPipe); - AtomPlus = AtomAdjust(AtomPlus); - AtomPointer = AtomAdjust(AtomPointer); - AtomPortray = AtomAdjust(AtomPortray); - AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); - AtomPrimitive = AtomAdjust(AtomPrimitive); - AtomPrintMessage = AtomAdjust(AtomPrintMessage); - AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); - AtomProcedure = AtomAdjust(AtomProcedure); - AtomProfile = AtomAdjust(AtomProfile); - AtomProlog = AtomAdjust(AtomProlog); - AtomQly = AtomAdjust(AtomQly); - AtomQuery = AtomAdjust(AtomQuery); - AtomQueue = AtomAdjust(AtomQueue); - AtomQuiet = AtomAdjust(AtomQuiet); - AtomRadix = AtomAdjust(AtomRadix); - AtomRandom = AtomAdjust(AtomRandom); - AtomRange = AtomAdjust(AtomRange); - AtomRDiv = AtomAdjust(AtomRDiv); - AtomRead = AtomAdjust(AtomRead); - AtomReadOnly = AtomAdjust(AtomReadOnly); - AtomReadWrite = AtomAdjust(AtomReadWrite); - AtomReadutil = AtomAdjust(AtomReadutil); - AtomReconsult = AtomAdjust(AtomReconsult); - AtomRecordedP = AtomAdjust(AtomRecordedP); - AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); - AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); - AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); - AtomRefoundVar = AtomAdjust(AtomRefoundVar); - AtomRelativeTo = AtomAdjust(AtomRelativeTo); - AtomRepeat = AtomAdjust(AtomRepeat); - AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); - AtomReposition = AtomAdjust(AtomReposition); - AtomRepresentationError = AtomAdjust(AtomRepresentationError); - AtomReset = AtomAdjust(AtomReset); - AtomResize = AtomAdjust(AtomResize); - AtomResourceError = AtomAdjust(AtomResourceError); - AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); - AtomRetryCounter = AtomAdjust(AtomRetryCounter); - AtomRTree = AtomAdjust(AtomRTree); - AtomSafe = AtomAdjust(AtomSafe); - AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); - AtomSame = AtomAdjust(AtomSame); - AtomSemic = AtomAdjust(AtomSemic); - AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); - AtomSigAlarm = AtomAdjust(AtomSigAlarm); - AtomSigBreak = AtomAdjust(AtomSigBreak); - AtomSigCreep = AtomAdjust(AtomSigCreep); - AtomSigDebug = AtomAdjust(AtomSigDebug); - AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); - AtomSigFPE = AtomAdjust(AtomSigFPE); - AtomSigHup = AtomAdjust(AtomSigHup); - AtomSigInt = AtomAdjust(AtomSigInt); - AtomSigIti = AtomAdjust(AtomSigIti); - AtomSigPending = AtomAdjust(AtomSigPending); - AtomSigPipe = AtomAdjust(AtomSigPipe); - AtomSigStackDump = AtomAdjust(AtomSigStackDump); - AtomSigStatistics = AtomAdjust(AtomSigStatistics); - AtomSigTrace = AtomAdjust(AtomSigTrace); - AtomSigUsr1 = AtomAdjust(AtomSigUsr1); - AtomSigUsr2 = AtomAdjust(AtomSigUsr2); - AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); - AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); - AtomSilent = AtomAdjust(AtomSilent); - AtomSingle = AtomAdjust(AtomSingle); - AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); - AtomSingleton = AtomAdjust(AtomSingleton); - AtomSlash = AtomAdjust(AtomSlash); - AtomSocket = AtomAdjust(AtomSocket); - AtomSolutions = AtomAdjust(AtomSolutions); - AtomSource = AtomAdjust(AtomSource); - AtomSourceSink = AtomAdjust(AtomSourceSink); - AtomSpy = AtomAdjust(AtomSpy); - AtomStack = AtomAdjust(AtomStack); - AtomStackFree = AtomAdjust(AtomStackFree); - AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); - AtomStaticClause = AtomAdjust(AtomStaticClause); - AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); - AtomStream = AtomAdjust(AtomStream); - AtomSWIStream = AtomAdjust(AtomSWIStream); - AtomVStream = AtomAdjust(AtomVStream); - AtomStreams = AtomAdjust(AtomStreams); - AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); - AtomStreamPos = AtomAdjust(AtomStreamPos); - AtomStreamPosition = AtomAdjust(AtomStreamPosition); - AtomString = AtomAdjust(AtomString); - AtomStyleCheck = AtomAdjust(AtomStyleCheck); - AtomSTRING = AtomAdjust(AtomSTRING); - AtomSwi = AtomAdjust(AtomSwi); - AtomSymbolChar = AtomAdjust(AtomSymbolChar); - AtomSyntaxError = AtomAdjust(AtomSyntaxError); - AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); - AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); - AtomSystem = AtomAdjust(AtomSystem); - AtomSystemError = AtomAdjust(AtomSystemError); - AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); - AtomTerm = AtomAdjust(AtomTerm); - AtomTerms = AtomAdjust(AtomTerms); - AtomTermExpansion = AtomAdjust(AtomTermExpansion); - AtomText = AtomAdjust(AtomText); - AtomTextStream = AtomAdjust(AtomTextStream); - AtomThread = AtomAdjust(AtomThread); - AtomThreads = AtomAdjust(AtomThreads); - AtomThrow = AtomAdjust(AtomThrow); - AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); - AtomTimeoutError = AtomAdjust(AtomTimeoutError); - AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); - AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); - AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); - AtomTrail = AtomAdjust(AtomTrail); - AtomTrue = AtomAdjust(AtomTrue); - AtomTty = AtomAdjust(AtomTty); - AtomTtys = AtomAdjust(AtomTtys); - AtomTxt = AtomAdjust(AtomTxt); - AtomTypeError = AtomAdjust(AtomTypeError); - AtomUndefined = AtomAdjust(AtomUndefined); - AtomUndefp = AtomAdjust(AtomUndefp); - AtomUnderflow = AtomAdjust(AtomUnderflow); - AtomUnificationStack = AtomAdjust(AtomUnificationStack); - AtomUnique = AtomAdjust(AtomUnique); - AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); - AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); - AtomUser = AtomAdjust(AtomUser); - AtomUserErr = AtomAdjust(AtomUserErr); - AtomUserIn = AtomAdjust(AtomUserIn); - AtomUserOut = AtomAdjust(AtomUserOut); - AtomDollarVar = AtomAdjust(AtomDollarVar); - AtomVBar = AtomAdjust(AtomVBar); - AtomVarBranches = AtomAdjust(AtomVarBranches); - AtomVariableNames = AtomAdjust(AtomVariableNames); - AtomHiddenVar = AtomAdjust(AtomHiddenVar); - AtomVariable = AtomAdjust(AtomVariable); - AtomVerbose = AtomAdjust(AtomVerbose); - AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); - AtomVersionNumber = AtomAdjust(AtomVersionNumber); - AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); - AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); - AtomWarning = AtomAdjust(AtomWarning); - AtomWhen = AtomAdjust(AtomWhen); - AtomWrite = AtomAdjust(AtomWrite); - AtomXml = AtomAdjust(AtomXml); - AtomYapHacks = AtomAdjust(AtomYapHacks); - AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); - FunctorAfInet = FuncAdjust(FunctorAfInet); - FunctorAfLocal = FuncAdjust(FunctorAfLocal); - FunctorAfUnix = FuncAdjust(FunctorAfUnix); - FunctorAltNot = FuncAdjust(FunctorAltNot); - FunctorArg = FuncAdjust(FunctorArg); - FunctorArrayEntry = FuncAdjust(FunctorArrayEntry); - FunctorArrow = FuncAdjust(FunctorArrow); - FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); - FunctorAssert1 = FuncAdjust(FunctorAssert1); - FunctorAssert = FuncAdjust(FunctorAssert); - FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne); - FunctorAtom = FuncAdjust(FunctorAtom); - FunctorAtt1 = FuncAdjust(FunctorAtt1); - FunctorAttGoal = FuncAdjust(FunctorAttGoal); - FunctorBraces = FuncAdjust(FunctorBraces); - FunctorCall = FuncAdjust(FunctorCall); - FunctorCatch = FuncAdjust(FunctorCatch); - FunctorChangeModule = FuncAdjust(FunctorChangeModule); - FunctorChars = FuncAdjust(FunctorChars); - FunctorChars1 = FuncAdjust(FunctorChars1); - FunctorCleanCall = FuncAdjust(FunctorCleanCall); - FunctorClist = FuncAdjust(FunctorClist); - FunctorCodes = FuncAdjust(FunctorCodes); - FunctorCodes1 = FuncAdjust(FunctorCodes1); - FunctorComma = FuncAdjust(FunctorComma); - FunctorCommentHook = FuncAdjust(FunctorCommentHook); - FunctorContext2 = FuncAdjust(FunctorContext2); - FunctorConsistencyError = FuncAdjust(FunctorConsistencyError); - FunctorCreep = FuncAdjust(FunctorCreep); - FunctorCsult = FuncAdjust(FunctorCsult); - FunctorCurrentModule = FuncAdjust(FunctorCurrentModule); - FunctorCutBy = FuncAdjust(FunctorCutBy); - FunctorDBREF = FuncAdjust(FunctorDBREF); - FunctorDiff = FuncAdjust(FunctorDiff); - FunctorDoLogUpdClause = FuncAdjust(FunctorDoLogUpdClause); - FunctorDoLogUpdClause0 = FuncAdjust(FunctorDoLogUpdClause0); - FunctorDoLogUpdClauseErase = FuncAdjust(FunctorDoLogUpdClauseErase); - FunctorDoStaticClause = FuncAdjust(FunctorDoStaticClause); - FunctorDollarVar = FuncAdjust(FunctorDollarVar); - FunctorDomainError = FuncAdjust(FunctorDomainError); - FunctorDot = FuncAdjust(FunctorDot); - FunctorDot10 = FuncAdjust(FunctorDot10); - FunctorDot11 = FuncAdjust(FunctorDot11); - FunctorDot12 = FuncAdjust(FunctorDot12); - FunctorDot2 = FuncAdjust(FunctorDot2); - FunctorDot3 = FuncAdjust(FunctorDot3); - FunctorDot4 = FuncAdjust(FunctorDot4); - FunctorDot5 = FuncAdjust(FunctorDot5); - FunctorDot6 = FuncAdjust(FunctorDot6); - FunctorDot7 = FuncAdjust(FunctorDot7); - FunctorDot8 = FuncAdjust(FunctorDot8); - FunctorDot9 = FuncAdjust(FunctorDot9); - FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash); - FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets); - FunctorEmptyCurlyBrackets = FuncAdjust(FunctorEmptyCurlyBrackets); - FunctorEq = FuncAdjust(FunctorEq); - FunctorError = FuncAdjust(FunctorError); - FunctorEvaluationError = FuncAdjust(FunctorEvaluationError); - FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod); - FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod); - FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin); - FunctorExistenceError = FuncAdjust(FunctorExistenceError); - FunctorExoClause = FuncAdjust(FunctorExoClause); - FunctorFunctor = FuncAdjust(FunctorFunctor); - FunctorGAtom = FuncAdjust(FunctorGAtom); - FunctorGAtomic = FuncAdjust(FunctorGAtomic); - FunctorGCompound = FuncAdjust(FunctorGCompound); - FunctorGFloat = FuncAdjust(FunctorGFloat); - FunctorGFormatAt = FuncAdjust(FunctorGFormatAt); - FunctorGInteger = FuncAdjust(FunctorGInteger); - FunctorGNumber = FuncAdjust(FunctorGNumber); - FunctorGPrimitive = FuncAdjust(FunctorGPrimitive); - FunctorGVar = FuncAdjust(FunctorGVar); - FunctorGeneratePredInfo = FuncAdjust(FunctorGeneratePredInfo); - FunctorGoalExpansion2 = FuncAdjust(FunctorGoalExpansion2); - FunctorGoalExpansion = FuncAdjust(FunctorGoalExpansion); - FunctorHandleThrow = FuncAdjust(FunctorHandleThrow); - FunctorHat = FuncAdjust(FunctorHat); - FunctorId = FuncAdjust(FunctorId); - FunctorIs = FuncAdjust(FunctorIs); - FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin); - FunctorList = FuncAdjust(FunctorList); - FunctorLOOP = FuncAdjust(FunctorLOOP); - FunctorMegaClause = FuncAdjust(FunctorMegaClause); - FunctorMetaCall = FuncAdjust(FunctorMetaCall); - FunctorMinus = FuncAdjust(FunctorMinus); - FunctorModule = FuncAdjust(FunctorModule); - FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause); - FunctorMutable = FuncAdjust(FunctorMutable); - FunctorMutex = FuncAdjust(FunctorMutex); - FunctorNotImplemented = FuncAdjust(FunctorNotImplemented); - FunctorNBQueue = FuncAdjust(FunctorNBQueue); - FunctorNot = FuncAdjust(FunctorNot); - FunctorOr = FuncAdjust(FunctorOr); - FunctorPermissionError = FuncAdjust(FunctorPermissionError); - FunctorPlus = FuncAdjust(FunctorPlus); - FunctorPortray = FuncAdjust(FunctorPortray); - FunctorPrintMessage = FuncAdjust(FunctorPrintMessage); - FunctorProcedure = FuncAdjust(FunctorProcedure); - FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint); - FunctorQuery = FuncAdjust(FunctorQuery); - FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey); - FunctorRDiv = FuncAdjust(FunctorRDiv); - FunctorRedoFreeze = FuncAdjust(FunctorRedoFreeze); - FunctorRepresentationError = FuncAdjust(FunctorRepresentationError); - FunctorResourceError = FuncAdjust(FunctorResourceError); - FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs); - FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1); - FunctorSafe = FuncAdjust(FunctorSafe); - FunctorSafeCallCleanup = FuncAdjust(FunctorSafeCallCleanup); - FunctorSame = FuncAdjust(FunctorSame); - FunctorSlash = FuncAdjust(FunctorSlash); - FunctorStaticClause = FuncAdjust(FunctorStaticClause); - FunctorStream = FuncAdjust(FunctorStream); - FunctorStreamEOS = FuncAdjust(FunctorStreamEOS); - FunctorStreamPos = FuncAdjust(FunctorStreamPos); - FunctorString1 = FuncAdjust(FunctorString1); - FunctorStyleCheck = FuncAdjust(FunctorStyleCheck); - FunctorSyntaxError = FuncAdjust(FunctorSyntaxError); - FunctorShortSyntaxError = FuncAdjust(FunctorShortSyntaxError); - FunctorTermExpansion = FuncAdjust(FunctorTermExpansion); - FunctorThreadRun = FuncAdjust(FunctorThreadRun); - FunctorThrow = FuncAdjust(FunctorThrow); - FunctorTimeoutError = FuncAdjust(FunctorTimeoutError); - FunctorTraceMetaCall = FuncAdjust(FunctorTraceMetaCall); - FunctorTypeError = FuncAdjust(FunctorTypeError); - FunctorUMinus = FuncAdjust(FunctorUMinus); - FunctorUPlus = FuncAdjust(FunctorUPlus); - FunctorVBar = FuncAdjust(FunctorVBar); - FunctorHiddenVar = FuncAdjust(FunctorHiddenVar); diff --git a/H/tatoms.h b/H/tatoms.h deleted file mode 100644 index a4f8ef031..000000000 --- a/H/tatoms.h +++ /dev/null @@ -1,1506 +0,0 @@ - - /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" - please do not update, update misc/ATOMS instead */ - - Atom Atom3Dots_; -#define Atom3Dots Yap_heap_regs->Atom3Dots_ -#define Term3Dots MkAtomTerm( Yap_heap_regs->Atom3Dots_ ) - Atom AtomAbol_; -#define AtomAbol Yap_heap_regs->AtomAbol_ -#define TermAbol MkAtomTerm( Yap_heap_regs->AtomAbol_ ) - Atom AtomAccess_; -#define AtomAccess Yap_heap_regs->AtomAccess_ -#define TermAccess MkAtomTerm( Yap_heap_regs->AtomAccess_ ) - Atom AtomAfInet_; -#define AtomAfInet Yap_heap_regs->AtomAfInet_ -#define TermAfInet MkAtomTerm( Yap_heap_regs->AtomAfInet_ ) - Atom AtomAfLocal_; -#define AtomAfLocal Yap_heap_regs->AtomAfLocal_ -#define TermAfLocal MkAtomTerm( Yap_heap_regs->AtomAfLocal_ ) - Atom AtomAfUnix_; -#define AtomAfUnix Yap_heap_regs->AtomAfUnix_ -#define TermAfUnix MkAtomTerm( Yap_heap_regs->AtomAfUnix_ ) - Atom AtomAlarm_; -#define AtomAlarm Yap_heap_regs->AtomAlarm_ -#define TermAlarm MkAtomTerm( Yap_heap_regs->AtomAlarm_ ) - Atom AtomAlias_; -#define AtomAlias Yap_heap_regs->AtomAlias_ -#define TermAlias MkAtomTerm( Yap_heap_regs->AtomAlias_ ) - Atom AtomAll_; -#define AtomAll Yap_heap_regs->AtomAll_ -#define TermAll MkAtomTerm( Yap_heap_regs->AtomAll_ ) - Atom AtomAltNot_; -#define AtomAltNot Yap_heap_regs->AtomAltNot_ -#define TermAltNot MkAtomTerm( Yap_heap_regs->AtomAltNot_ ) - Atom AtomAny_; -#define AtomAny Yap_heap_regs->AtomAny_ -#define TermAny MkAtomTerm( Yap_heap_regs->AtomAny_ ) - Atom AtomAppend_; -#define AtomAppend Yap_heap_regs->AtomAppend_ -#define TermAppend MkAtomTerm( Yap_heap_regs->AtomAppend_ ) - Atom AtomArg_; -#define AtomArg Yap_heap_regs->AtomArg_ -#define TermArg MkAtomTerm( Yap_heap_regs->AtomArg_ ) - Atom AtomArray_; -#define AtomArray Yap_heap_regs->AtomArray_ -#define TermArray MkAtomTerm( Yap_heap_regs->AtomArray_ ) - Atom AtomArrayAccess_; -#define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_ -#define TermArrayAccess MkAtomTerm( Yap_heap_regs->AtomArrayAccess_ ) - Atom AtomArrayOverflow_; -#define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_ -#define TermArrayOverflow MkAtomTerm( Yap_heap_regs->AtomArrayOverflow_ ) - Atom AtomArrayType_; -#define AtomArrayType Yap_heap_regs->AtomArrayType_ -#define TermArrayType MkAtomTerm( Yap_heap_regs->AtomArrayType_ ) - Atom AtomArrow_; -#define AtomArrow Yap_heap_regs->AtomArrow_ -#define TermArrow MkAtomTerm( Yap_heap_regs->AtomArrow_ ) - Atom AtomAttributedModule_; -#define AtomAttributedModule Yap_heap_regs->AtomAttributedModule_ -#define TermAttributedModule MkAtomTerm( Yap_heap_regs->AtomAttributedModule_ ) - Atom AtomDoubleArrow_; -#define AtomDoubleArrow Yap_heap_regs->AtomDoubleArrow_ -#define TermDoubleArrow MkAtomTerm( Yap_heap_regs->AtomDoubleArrow_ ) - Atom AtomAssert_; -#define AtomAssert Yap_heap_regs->AtomAssert_ -#define TermAssert MkAtomTerm( Yap_heap_regs->AtomAssert_ ) - Atom AtomEmptyBrackets_; -#define AtomEmptyBrackets Yap_heap_regs->AtomEmptyBrackets_ -#define TermEmptyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyBrackets_ ) - Atom AtomEmptySquareBrackets_; -#define AtomEmptySquareBrackets Yap_heap_regs->AtomEmptySquareBrackets_ -#define TermEmptySquareBrackets MkAtomTerm( Yap_heap_regs->AtomEmptySquareBrackets_ ) - Atom AtomEmptyCurlyBrackets_; -#define AtomEmptyCurlyBrackets Yap_heap_regs->AtomEmptyCurlyBrackets_ -#define TermEmptyCurlyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyCurlyBrackets_ ) - Atom 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_ -#define TermAt MkAtomTerm( Yap_heap_regs->AtomAt_ ) - Atom AtomAtom_; -#define AtomAtom Yap_heap_regs->AtomAtom_ -#define TermAtom MkAtomTerm( Yap_heap_regs->AtomAtom_ ) - Atom AtomAtomic_; -#define AtomAtomic Yap_heap_regs->AtomAtomic_ -#define TermAtomic MkAtomTerm( Yap_heap_regs->AtomAtomic_ ) - Atom AtomAtt_; -#define AtomAtt Yap_heap_regs->AtomAtt_ -#define TermAtt MkAtomTerm( Yap_heap_regs->AtomAtt_ ) - Atom AtomAtt1_; -#define AtomAtt1 Yap_heap_regs->AtomAtt1_ -#define TermAtt1 MkAtomTerm( Yap_heap_regs->AtomAtt1_ ) - Atom AtomAttDo_; -#define AtomAttDo Yap_heap_regs->AtomAttDo_ -#define TermAttDo MkAtomTerm( Yap_heap_regs->AtomAttDo_ ) - Atom AtomAttributes_; -#define AtomAttributes Yap_heap_regs->AtomAttributes_ -#define TermAttributes MkAtomTerm( Yap_heap_regs->AtomAttributes_ ) - Atom AtomB_; -#define AtomB Yap_heap_regs->AtomB_ -#define TermB MkAtomTerm( Yap_heap_regs->AtomB_ ) - Atom AtomBatched_; -#define AtomBatched Yap_heap_regs->AtomBatched_ -#define TermBatched MkAtomTerm( Yap_heap_regs->AtomBatched_ ) - Atom AtomBetween_; -#define AtomBetween Yap_heap_regs->AtomBetween_ -#define TermBetween MkAtomTerm( Yap_heap_regs->AtomBetween_ ) - Atom AtomBinary_; -#define AtomBinary Yap_heap_regs->AtomBinary_ -#define TermBinary MkAtomTerm( Yap_heap_regs->AtomBinary_ ) - Atom AtomBigNum_; -#define AtomBigNum Yap_heap_regs->AtomBigNum_ -#define TermBigNum MkAtomTerm( Yap_heap_regs->AtomBigNum_ ) - Atom AtomBinaryStream_; -#define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_ -#define TermBinaryStream MkAtomTerm( Yap_heap_regs->AtomBinaryStream_ ) - Atom AtomBoolean_; -#define AtomBoolean Yap_heap_regs->AtomBoolean_ -#define TermBoolean MkAtomTerm( Yap_heap_regs->AtomBoolean_ ) - Atom AtomBraces_; -#define AtomBraces Yap_heap_regs->AtomBraces_ -#define TermBraces MkAtomTerm( Yap_heap_regs->AtomBraces_ ) - Atom AtomBreak_; -#define AtomBreak Yap_heap_regs->AtomBreak_ -#define TermBreak MkAtomTerm( Yap_heap_regs->AtomBreak_ ) - Atom AtomByte_; -#define AtomByte Yap_heap_regs->AtomByte_ -#define TermByte MkAtomTerm( Yap_heap_regs->AtomByte_ ) - Atom AtomCArith_; -#define AtomCArith Yap_heap_regs->AtomCArith_ -#define TermCArith MkAtomTerm( Yap_heap_regs->AtomCArith_ ) - Atom AtomCall_; -#define AtomCall Yap_heap_regs->AtomCall_ -#define TermCall MkAtomTerm( Yap_heap_regs->AtomCall_ ) - Atom AtomCallAndRetryCounter_; -#define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_ -#define TermCallAndRetryCounter MkAtomTerm( Yap_heap_regs->AtomCallAndRetryCounter_ ) - Atom AtomCallCounter_; -#define AtomCallCounter Yap_heap_regs->AtomCallCounter_ -#define TermCallCounter MkAtomTerm( Yap_heap_regs->AtomCallCounter_ ) - Atom AtomCallable_; -#define AtomCallable Yap_heap_regs->AtomCallable_ -#define TermCallable MkAtomTerm( Yap_heap_regs->AtomCallable_ ) - Atom AtomCatch_; -#define AtomCatch Yap_heap_regs->AtomCatch_ -#define TermCatch MkAtomTerm( Yap_heap_regs->AtomCatch_ ) - Atom AtomChangeModule_; -#define AtomChangeModule Yap_heap_regs->AtomChangeModule_ -#define TermChangeModule MkAtomTerm( Yap_heap_regs->AtomChangeModule_ ) - Atom AtomChar_; -#define AtomChar Yap_heap_regs->AtomChar_ -#define TermChar MkAtomTerm( Yap_heap_regs->AtomChar_ ) - Atom AtomCharsio_; -#define AtomCharsio Yap_heap_regs->AtomCharsio_ -#define TermCharsio MkAtomTerm( Yap_heap_regs->AtomCharsio_ ) - Atom AtomCharacter_; -#define AtomCharacter Yap_heap_regs->AtomCharacter_ -#define TermCharacter MkAtomTerm( Yap_heap_regs->AtomCharacter_ ) - Atom AtomCharacterCode_; -#define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_ -#define TermCharacterCode MkAtomTerm( Yap_heap_regs->AtomCharacterCode_ ) - Atom AtomChars_; -#define AtomChars Yap_heap_regs->AtomChars_ -#define TermChars MkAtomTerm( Yap_heap_regs->AtomChars_ ) - Atom AtomCharset_; -#define AtomCharset Yap_heap_regs->AtomCharset_ -#define TermCharset MkAtomTerm( Yap_heap_regs->AtomCharset_ ) - Atom AtomChType_; -#define AtomChType Yap_heap_regs->AtomChType_ -#define TermChType MkAtomTerm( Yap_heap_regs->AtomChType_ ) - Atom AtomCleanCall_; -#define AtomCleanCall Yap_heap_regs->AtomCleanCall_ -#define TermCleanCall MkAtomTerm( Yap_heap_regs->AtomCleanCall_ ) - Atom AtomColomn_; -#define AtomColomn Yap_heap_regs->AtomColomn_ -#define TermColomn MkAtomTerm( Yap_heap_regs->AtomColomn_ ) - Atom AtomCodeSpace_; -#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_ -#define TermCodeSpace MkAtomTerm( Yap_heap_regs->AtomCodeSpace_ ) - Atom AtomCodes_; -#define AtomCodes Yap_heap_regs->AtomCodes_ -#define TermCodes MkAtomTerm( Yap_heap_regs->AtomCodes_ ) - Atom AtomCoInductive_; -#define AtomCoInductive Yap_heap_regs->AtomCoInductive_ -#define TermCoInductive MkAtomTerm( Yap_heap_regs->AtomCoInductive_ ) - Atom AtomComma_; -#define AtomComma Yap_heap_regs->AtomComma_ -#define TermComma MkAtomTerm( Yap_heap_regs->AtomComma_ ) - Atom AtomCommentHook_; -#define AtomCommentHook Yap_heap_regs->AtomCommentHook_ -#define TermCommentHook MkAtomTerm( Yap_heap_regs->AtomCommentHook_ ) - Atom AtomCompact_; -#define AtomCompact Yap_heap_regs->AtomCompact_ -#define TermCompact MkAtomTerm( Yap_heap_regs->AtomCompact_ ) - Atom AtomCompound_; -#define AtomCompound Yap_heap_regs->AtomCompound_ -#define TermCompound MkAtomTerm( Yap_heap_regs->AtomCompound_ ) - Atom AtomConsistencyError_; -#define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_ -#define TermConsistencyError MkAtomTerm( Yap_heap_regs->AtomConsistencyError_ ) - Atom AtomConsult_; -#define AtomConsult Yap_heap_regs->AtomConsult_ -#define TermConsult MkAtomTerm( Yap_heap_regs->AtomConsult_ ) - Atom AtomConsultOnBoot_; -#define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_ -#define TermConsultOnBoot MkAtomTerm( Yap_heap_regs->AtomConsultOnBoot_ ) - Atom AtomContext_; -#define AtomContext Yap_heap_regs->AtomContext_ -#define TermContext MkAtomTerm( Yap_heap_regs->AtomContext_ ) - Atom AtomCputime_; -#define AtomCputime Yap_heap_regs->AtomCputime_ -#define TermCputime MkAtomTerm( Yap_heap_regs->AtomCputime_ ) - Atom AtomCreate_; -#define AtomCreate Yap_heap_regs->AtomCreate_ -#define TermCreate MkAtomTerm( Yap_heap_regs->AtomCreate_ ) - Atom AtomCreep_; -#define AtomCreep Yap_heap_regs->AtomCreep_ -#define TermCreep MkAtomTerm( Yap_heap_regs->AtomCreep_ ) - Atom AtomCryptAtoms_; -#define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_ -#define TermCryptAtoms MkAtomTerm( Yap_heap_regs->AtomCryptAtoms_ ) - Atom AtomCsult_; -#define AtomCsult Yap_heap_regs->AtomCsult_ -#define TermCsult MkAtomTerm( Yap_heap_regs->AtomCsult_ ) - Atom AtomCurrentModule_; -#define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_ -#define TermCurrentModule MkAtomTerm( Yap_heap_regs->AtomCurrentModule_ ) - Atom AtomCut_; -#define AtomCut Yap_heap_regs->AtomCut_ -#define TermCut MkAtomTerm( Yap_heap_regs->AtomCut_ ) - Atom AtomCutBy_; -#define AtomCutBy Yap_heap_regs->AtomCutBy_ -#define TermCutBy MkAtomTerm( Yap_heap_regs->AtomCutBy_ ) - Atom AtomDAbort_; -#define AtomDAbort Yap_heap_regs->AtomDAbort_ -#define TermDAbort MkAtomTerm( Yap_heap_regs->AtomDAbort_ ) - Atom AtomDBLoad_; -#define AtomDBLoad Yap_heap_regs->AtomDBLoad_ -#define TermDBLoad MkAtomTerm( Yap_heap_regs->AtomDBLoad_ ) - Atom AtomDBREF_; -#define AtomDBREF Yap_heap_regs->AtomDBREF_ -#define TermDBREF MkAtomTerm( Yap_heap_regs->AtomDBREF_ ) - Atom AtomDBReference_; -#define AtomDBReference Yap_heap_regs->AtomDBReference_ -#define TermDBReference MkAtomTerm( Yap_heap_regs->AtomDBReference_ ) - Atom AtomDBTerm_; -#define AtomDBTerm Yap_heap_regs->AtomDBTerm_ -#define TermDBTerm MkAtomTerm( Yap_heap_regs->AtomDBTerm_ ) - Atom AtomDBref_; -#define AtomDBref Yap_heap_regs->AtomDBref_ -#define TermDBref MkAtomTerm( Yap_heap_regs->AtomDBref_ ) - Atom AtomDInteger_; -#define AtomDInteger Yap_heap_regs->AtomDInteger_ -#define TermDInteger MkAtomTerm( Yap_heap_regs->AtomDInteger_ ) - Atom AtomDebugMeta_; -#define AtomDebugMeta Yap_heap_regs->AtomDebugMeta_ -#define TermDebugMeta MkAtomTerm( Yap_heap_regs->AtomDebugMeta_ ) - Atom AtomDebuggerInput_; -#define AtomDebuggerInput Yap_heap_regs->AtomDebuggerInput_ -#define TermDebuggerInput MkAtomTerm( Yap_heap_regs->AtomDebuggerInput_ ) - Atom AtomDec10_; -#define AtomDec10 Yap_heap_regs->AtomDec10_ -#define TermDec10 MkAtomTerm( Yap_heap_regs->AtomDec10_ ) - Atom AtomDefault_; -#define AtomDefault Yap_heap_regs->AtomDefault_ -#define TermDefault MkAtomTerm( Yap_heap_regs->AtomDefault_ ) - Atom AtomDevNull_; -#define AtomDevNull Yap_heap_regs->AtomDevNull_ -#define TermDevNull MkAtomTerm( Yap_heap_regs->AtomDevNull_ ) - Atom AtomDiff_; -#define AtomDiff Yap_heap_regs->AtomDiff_ -#define TermDiff MkAtomTerm( Yap_heap_regs->AtomDiff_ ) - Atom AtomDirectory_; -#define AtomDirectory Yap_heap_regs->AtomDirectory_ -#define TermDirectory MkAtomTerm( Yap_heap_regs->AtomDirectory_ ) - Atom AtomDiscontiguous_; -#define AtomDiscontiguous Yap_heap_regs->AtomDiscontiguous_ -#define TermDiscontiguous MkAtomTerm( Yap_heap_regs->AtomDiscontiguous_ ) - Atom AtomDiscontiguousWarnings_; -#define AtomDiscontiguousWarnings Yap_heap_regs->AtomDiscontiguousWarnings_ -#define TermDiscontiguousWarnings MkAtomTerm( Yap_heap_regs->AtomDiscontiguousWarnings_ ) - Atom AtomDollar_; -#define AtomDollar Yap_heap_regs->AtomDollar_ -#define TermDollar MkAtomTerm( Yap_heap_regs->AtomDollar_ ) - Atom AtomDoLogUpdClause_; -#define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_ -#define TermDoLogUpdClause MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause_ ) - Atom AtomDoLogUpdClause0_; -#define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_ -#define TermDoLogUpdClause0 MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause0_ ) - Atom AtomDoLogUpdClauseErase_; -#define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_ -#define TermDoLogUpdClauseErase MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClauseErase_ ) - Atom AtomDollarU_; -#define AtomDollarU Yap_heap_regs->AtomDollarU_ -#define TermDollarU MkAtomTerm( Yap_heap_regs->AtomDollarU_ ) - Atom AtomDollarUndef_; -#define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_ -#define TermDollarUndef MkAtomTerm( Yap_heap_regs->AtomDollarUndef_ ) - Atom AtomDomainError_; -#define AtomDomainError Yap_heap_regs->AtomDomainError_ -#define TermDomainError MkAtomTerm( Yap_heap_regs->AtomDomainError_ ) - Atom AtomDoStaticClause_; -#define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_ -#define TermDoStaticClause MkAtomTerm( Yap_heap_regs->AtomDoStaticClause_ ) - Atom AtomDots_; -#define AtomDots Yap_heap_regs->AtomDots_ -#define TermDots MkAtomTerm( Yap_heap_regs->AtomDots_ ) - Atom AtomDOUBLE_; -#define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_ -#define TermDOUBLE MkAtomTerm( Yap_heap_regs->AtomDOUBLE_ ) - Atom AtomDoubleSlash_; -#define AtomDoubleSlash Yap_heap_regs->AtomDoubleSlash_ -#define TermDoubleSlash MkAtomTerm( Yap_heap_regs->AtomDoubleSlash_ ) - Atom AtomE_; -#define AtomE Yap_heap_regs->AtomE_ -#define TermE MkAtomTerm( Yap_heap_regs->AtomE_ ) - Atom AtomEOFBeforeEOT_; -#define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_ -#define TermEOFBeforeEOT MkAtomTerm( Yap_heap_regs->AtomEOFBeforeEOT_ ) - Atom AtomEQ_; -#define AtomEQ Yap_heap_regs->AtomEQ_ -#define TermEQ MkAtomTerm( Yap_heap_regs->AtomEQ_ ) - Atom AtomEmptyAtom_; -#define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_ -#define TermEmptyAtom MkAtomTerm( Yap_heap_regs->AtomEmptyAtom_ ) - Atom AtomEncoding_; -#define AtomEncoding Yap_heap_regs->AtomEncoding_ -#define TermEncoding MkAtomTerm( Yap_heap_regs->AtomEncoding_ ) - Atom AtomEndOfStream_; -#define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_ -#define TermEndOfStream MkAtomTerm( Yap_heap_regs->AtomEndOfStream_ ) - Atom AtomEof_; -#define AtomEof Yap_heap_regs->AtomEof_ -#define TermEof MkAtomTerm( Yap_heap_regs->AtomEof_ ) - Atom AtomEOfCode_; -#define AtomEOfCode Yap_heap_regs->AtomEOfCode_ -#define TermEOfCode MkAtomTerm( Yap_heap_regs->AtomEOfCode_ ) - Atom AtomEq_; -#define AtomEq Yap_heap_regs->AtomEq_ -#define TermEq MkAtomTerm( Yap_heap_regs->AtomEq_ ) - Atom AtomError_; -#define AtomError Yap_heap_regs->AtomError_ -#define TermError MkAtomTerm( Yap_heap_regs->AtomError_ ) - Atom AtomException_; -#define AtomException Yap_heap_regs->AtomException_ -#define TermException MkAtomTerm( Yap_heap_regs->AtomException_ ) - Atom AtomExtensions_; -#define AtomExtensions Yap_heap_regs->AtomExtensions_ -#define TermExtensions MkAtomTerm( Yap_heap_regs->AtomExtensions_ ) - Atom AtomEvaluable_; -#define AtomEvaluable Yap_heap_regs->AtomEvaluable_ -#define TermEvaluable MkAtomTerm( Yap_heap_regs->AtomEvaluable_ ) - Atom AtomEvaluationError_; -#define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_ -#define TermEvaluationError MkAtomTerm( Yap_heap_regs->AtomEvaluationError_ ) - Atom AtomExecutable_; -#define AtomExecutable Yap_heap_regs->AtomExecutable_ -#define TermExecutable MkAtomTerm( Yap_heap_regs->AtomExecutable_ ) - Atom AtomExecute_; -#define AtomExecute Yap_heap_regs->AtomExecute_ -#define TermExecute MkAtomTerm( Yap_heap_regs->AtomExecute_ ) - Atom AtomExecAnswers_; -#define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_ -#define TermExecAnswers MkAtomTerm( Yap_heap_regs->AtomExecAnswers_ ) - Atom AtomExecuteInMod_; -#define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_ -#define TermExecuteInMod MkAtomTerm( Yap_heap_regs->AtomExecuteInMod_ ) - Atom AtomExecuteWithin_; -#define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_ -#define TermExecuteWithin MkAtomTerm( Yap_heap_regs->AtomExecuteWithin_ ) - Atom AtomExecuteWoMod_; -#define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_ -#define TermExecuteWoMod MkAtomTerm( Yap_heap_regs->AtomExecuteWoMod_ ) - Atom AtomExist_; -#define AtomExist Yap_heap_regs->AtomExist_ -#define TermExist MkAtomTerm( Yap_heap_regs->AtomExist_ ) - Atom AtomExistenceError_; -#define AtomExistenceError Yap_heap_regs->AtomExistenceError_ -#define TermExistenceError MkAtomTerm( Yap_heap_regs->AtomExistenceError_ ) - Atom AtomExoClause_; -#define AtomExoClause Yap_heap_regs->AtomExoClause_ -#define TermExoClause MkAtomTerm( Yap_heap_regs->AtomExoClause_ ) - Atom AtomExpectedNumber_; -#define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_ -#define TermExpectedNumber MkAtomTerm( Yap_heap_regs->AtomExpectedNumber_ ) - Atom AtomExpand_; -#define AtomExpand Yap_heap_regs->AtomExpand_ -#define TermExpand MkAtomTerm( Yap_heap_regs->AtomExpand_ ) - Atom AtomExtendFileSearchPath_; -#define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_ -#define TermExtendFileSearchPath MkAtomTerm( Yap_heap_regs->AtomExtendFileSearchPath_ ) - Atom AtomExtendsions_; -#define AtomExtendsions Yap_heap_regs->AtomExtendsions_ -#define TermExtendsions MkAtomTerm( Yap_heap_regs->AtomExtendsions_ ) - Atom AtomFB_; -#define AtomFB Yap_heap_regs->AtomFB_ -#define TermFB MkAtomTerm( Yap_heap_regs->AtomFB_ ) - Atom AtomFail_; -#define AtomFail Yap_heap_regs->AtomFail_ -#define TermFail MkAtomTerm( Yap_heap_regs->AtomFail_ ) - Atom AtomFalse_; -#define AtomFalse Yap_heap_regs->AtomFalse_ -#define TermFalse MkAtomTerm( Yap_heap_regs->AtomFalse_ ) - Atom AtomFast_; -#define AtomFast Yap_heap_regs->AtomFast_ -#define TermFast MkAtomTerm( Yap_heap_regs->AtomFast_ ) - Atom AtomFastFail_; -#define AtomFastFail Yap_heap_regs->AtomFastFail_ -#define TermFastFail MkAtomTerm( Yap_heap_regs->AtomFastFail_ ) - Atom AtomFileErrors_; -#define AtomFileErrors Yap_heap_regs->AtomFileErrors_ -#define TermFileErrors MkAtomTerm( Yap_heap_regs->AtomFileErrors_ ) - Atom AtomFileerrors_; -#define AtomFileerrors Yap_heap_regs->AtomFileerrors_ -#define TermFileerrors MkAtomTerm( Yap_heap_regs->AtomFileerrors_ ) - 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_ -#define TermFloat MkAtomTerm( Yap_heap_regs->AtomFloat_ ) - Atom AtomFloatFormat_; -#define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_ -#define TermFloatFormat MkAtomTerm( Yap_heap_regs->AtomFloatFormat_ ) - Atom AtomFloatOverflow_; -#define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_ -#define TermFloatOverflow MkAtomTerm( Yap_heap_regs->AtomFloatOverflow_ ) - Atom AtomFloatUnderflow_; -#define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_ -#define TermFloatUnderflow MkAtomTerm( Yap_heap_regs->AtomFloatUnderflow_ ) - Atom AtomFormat_; -#define AtomFormat Yap_heap_regs->AtomFormat_ -#define TermFormat MkAtomTerm( Yap_heap_regs->AtomFormat_ ) - Atom AtomFormatAt_; -#define AtomFormatAt Yap_heap_regs->AtomFormatAt_ -#define TermFormatAt MkAtomTerm( Yap_heap_regs->AtomFormatAt_ ) - Atom AtomFull_; -#define AtomFull Yap_heap_regs->AtomFull_ -#define TermFull MkAtomTerm( Yap_heap_regs->AtomFull_ ) - Atom AtomFunctor_; -#define AtomFunctor Yap_heap_regs->AtomFunctor_ -#define TermFunctor MkAtomTerm( Yap_heap_regs->AtomFunctor_ ) - Atom AtomGT_; -#define AtomGT Yap_heap_regs->AtomGT_ -#define TermGT MkAtomTerm( Yap_heap_regs->AtomGT_ ) - Atom AtomGVar_; -#define AtomGVar Yap_heap_regs->AtomGVar_ -#define TermGVar MkAtomTerm( Yap_heap_regs->AtomGVar_ ) - Atom AtomGc_; -#define AtomGc Yap_heap_regs->AtomGc_ -#define TermGc MkAtomTerm( Yap_heap_regs->AtomGc_ ) - Atom AtomGcMargin_; -#define AtomGcMargin Yap_heap_regs->AtomGcMargin_ -#define TermGcMargin MkAtomTerm( Yap_heap_regs->AtomGcMargin_ ) - Atom AtomGcTrace_; -#define AtomGcTrace Yap_heap_regs->AtomGcTrace_ -#define TermGcTrace MkAtomTerm( Yap_heap_regs->AtomGcTrace_ ) - Atom AtomGcVerbose_; -#define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_ -#define TermGcVerbose MkAtomTerm( Yap_heap_regs->AtomGcVerbose_ ) - Atom AtomGcVeryVerbose_; -#define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_ -#define TermGcVeryVerbose MkAtomTerm( Yap_heap_regs->AtomGcVeryVerbose_ ) - Atom AtomGeneratePredInfo_; -#define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_ -#define TermGeneratePredInfo MkAtomTerm( Yap_heap_regs->AtomGeneratePredInfo_ ) - Atom AtomGetwork_; -#define AtomGetwork Yap_heap_regs->AtomGetwork_ -#define TermGetwork MkAtomTerm( Yap_heap_regs->AtomGetwork_ ) - Atom AtomGetworkSeq_; -#define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_ -#define TermGetworkSeq MkAtomTerm( Yap_heap_regs->AtomGetworkSeq_ ) - Atom AtomGlob_; -#define AtomGlob Yap_heap_regs->AtomGlob_ -#define TermGlob MkAtomTerm( Yap_heap_regs->AtomGlob_ ) - Atom AtomGlobal_; -#define AtomGlobal Yap_heap_regs->AtomGlobal_ -#define TermGlobal MkAtomTerm( Yap_heap_regs->AtomGlobal_ ) - Atom AtomGlobalSp_; -#define AtomGlobalSp Yap_heap_regs->AtomGlobalSp_ -#define TermGlobalSp MkAtomTerm( Yap_heap_regs->AtomGlobalSp_ ) - Atom AtomGlobalTrie_; -#define AtomGlobalTrie Yap_heap_regs->AtomGlobalTrie_ -#define TermGlobalTrie MkAtomTerm( Yap_heap_regs->AtomGlobalTrie_ ) - Atom AtomGoalExpansion_; -#define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_ -#define TermGoalExpansion MkAtomTerm( Yap_heap_regs->AtomGoalExpansion_ ) - Atom AtomHat_; -#define AtomHat Yap_heap_regs->AtomHat_ -#define TermHat MkAtomTerm( Yap_heap_regs->AtomHat_ ) - Atom AtomHERE_; -#define AtomHERE Yap_heap_regs->AtomHERE_ -#define TermHERE MkAtomTerm( Yap_heap_regs->AtomHERE_ ) - Atom AtomHandleThrow_; -#define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_ -#define TermHandleThrow MkAtomTerm( Yap_heap_regs->AtomHandleThrow_ ) - Atom AtomHeap_; -#define AtomHeap Yap_heap_regs->AtomHeap_ -#define TermHeap MkAtomTerm( Yap_heap_regs->AtomHeap_ ) - Atom AtomHeapUsed_; -#define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_ -#define TermHeapUsed MkAtomTerm( Yap_heap_regs->AtomHeapUsed_ ) - Atom AtomHugeInt_; -#define AtomHugeInt Yap_heap_regs->AtomHugeInt_ -#define TermHugeInt MkAtomTerm( Yap_heap_regs->AtomHugeInt_ ) - Atom AtomIDB_; -#define AtomIDB Yap_heap_regs->AtomIDB_ -#define TermIDB MkAtomTerm( Yap_heap_regs->AtomIDB_ ) - Atom AtomIOMode_; -#define AtomIOMode Yap_heap_regs->AtomIOMode_ -#define TermIOMode MkAtomTerm( Yap_heap_regs->AtomIOMode_ ) - Atom AtomId_; -#define AtomId Yap_heap_regs->AtomId_ -#define TermId MkAtomTerm( Yap_heap_regs->AtomId_ ) - Atom AtomIgnore_; -#define AtomIgnore Yap_heap_regs->AtomIgnore_ -#define TermIgnore MkAtomTerm( Yap_heap_regs->AtomIgnore_ ) - Atom AtomInf_; -#define AtomInf Yap_heap_regs->AtomInf_ -#define TermInf MkAtomTerm( Yap_heap_regs->AtomInf_ ) - Atom AtomInfinity_; -#define AtomInfinity Yap_heap_regs->AtomInfinity_ -#define TermInfinity MkAtomTerm( Yap_heap_regs->AtomInfinity_ ) - Atom AtomInitGoal_; -#define AtomInitGoal Yap_heap_regs->AtomInitGoal_ -#define TermInitGoal MkAtomTerm( Yap_heap_regs->AtomInitGoal_ ) - Atom AtomInitProlog_; -#define AtomInitProlog Yap_heap_regs->AtomInitProlog_ -#define TermInitProlog MkAtomTerm( Yap_heap_regs->AtomInitProlog_ ) - Atom AtomInStackExpansion_; -#define AtomInStackExpansion Yap_heap_regs->AtomInStackExpansion_ -#define TermInStackExpansion MkAtomTerm( Yap_heap_regs->AtomInStackExpansion_ ) - Atom AtomInput_; -#define AtomInput Yap_heap_regs->AtomInput_ -#define TermInput MkAtomTerm( Yap_heap_regs->AtomInput_ ) - Atom AtomInstantiationError_; -#define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_ -#define TermInstantiationError MkAtomTerm( Yap_heap_regs->AtomInstantiationError_ ) - Atom AtomInt_; -#define AtomInt Yap_heap_regs->AtomInt_ -#define TermInt MkAtomTerm( Yap_heap_regs->AtomInt_ ) - Atom AtomIntOverflow_; -#define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_ -#define TermIntOverflow MkAtomTerm( Yap_heap_regs->AtomIntOverflow_ ) - Atom AtomInteger_; -#define AtomInteger Yap_heap_regs->AtomInteger_ -#define TermInteger MkAtomTerm( Yap_heap_regs->AtomInteger_ ) - Atom AtomInternalCompilerError_; -#define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_ -#define TermInternalCompilerError MkAtomTerm( Yap_heap_regs->AtomInternalCompilerError_ ) - Atom AtomIs_; -#define AtomIs Yap_heap_regs->AtomIs_ -#define TermIs MkAtomTerm( Yap_heap_regs->AtomIs_ ) - Atom AtomKey_; -#define AtomKey Yap_heap_regs->AtomKey_ -#define TermKey MkAtomTerm( Yap_heap_regs->AtomKey_ ) - Atom AtomLDLibraryPath_; -#define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_ -#define TermLDLibraryPath MkAtomTerm( Yap_heap_regs->AtomLDLibraryPath_ ) - Atom AtomLONGINT_; -#define AtomLONGINT Yap_heap_regs->AtomLONGINT_ -#define TermLONGINT MkAtomTerm( Yap_heap_regs->AtomLONGINT_ ) - Atom AtomLOOP_; -#define AtomLOOP Yap_heap_regs->AtomLOOP_ -#define TermLOOP MkAtomTerm( Yap_heap_regs->AtomLOOP_ ) - Atom AtomLoopStream_; -#define AtomLoopStream Yap_heap_regs->AtomLoopStream_ -#define TermLoopStream MkAtomTerm( Yap_heap_regs->AtomLoopStream_ ) - Atom AtomLT_; -#define AtomLT Yap_heap_regs->AtomLT_ -#define TermLT MkAtomTerm( Yap_heap_regs->AtomLT_ ) - Atom AtomLastExecuteWithin_; -#define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_ -#define TermLastExecuteWithin MkAtomTerm( Yap_heap_regs->AtomLastExecuteWithin_ ) - Atom AtomLeash_; -#define AtomLeash Yap_heap_regs->AtomLeash_ -#define TermLeash MkAtomTerm( Yap_heap_regs->AtomLeash_ ) - Atom AtomLeast_; -#define AtomLeast Yap_heap_regs->AtomLeast_ -#define TermLeast MkAtomTerm( Yap_heap_regs->AtomLeast_ ) - Atom AtomLength_; -#define AtomLength Yap_heap_regs->AtomLength_ -#define TermLength MkAtomTerm( Yap_heap_regs->AtomLength_ ) - Atom AtomList_; -#define AtomList Yap_heap_regs->AtomList_ -#define TermList MkAtomTerm( Yap_heap_regs->AtomList_ ) - Atom AtomLine_; -#define AtomLine Yap_heap_regs->AtomLine_ -#define TermLine MkAtomTerm( Yap_heap_regs->AtomLine_ ) - Atom AtomLive_; -#define AtomLive Yap_heap_regs->AtomLive_ -#define TermLive MkAtomTerm( Yap_heap_regs->AtomLive_ ) - Atom AtomLoadAnswers_; -#define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_ -#define TermLoadAnswers MkAtomTerm( Yap_heap_regs->AtomLoadAnswers_ ) - Atom AtomLocal_; -#define AtomLocal Yap_heap_regs->AtomLocal_ -#define TermLocal MkAtomTerm( Yap_heap_regs->AtomLocal_ ) - Atom AtomLocalSp_; -#define AtomLocalSp Yap_heap_regs->AtomLocalSp_ -#define TermLocalSp MkAtomTerm( Yap_heap_regs->AtomLocalSp_ ) - Atom AtomLocalTrie_; -#define AtomLocalTrie Yap_heap_regs->AtomLocalTrie_ -#define TermLocalTrie MkAtomTerm( Yap_heap_regs->AtomLocalTrie_ ) - Atom AtomMax_; -#define AtomMax Yap_heap_regs->AtomMax_ -#define TermMax MkAtomTerm( Yap_heap_regs->AtomMax_ ) - Atom AtomMaximum_; -#define AtomMaximum Yap_heap_regs->AtomMaximum_ -#define TermMaximum MkAtomTerm( Yap_heap_regs->AtomMaximum_ ) - Atom AtomMaxArity_; -#define AtomMaxArity Yap_heap_regs->AtomMaxArity_ -#define TermMaxArity MkAtomTerm( Yap_heap_regs->AtomMaxArity_ ) - Atom AtomMaxFiles_; -#define AtomMaxFiles Yap_heap_regs->AtomMaxFiles_ -#define TermMaxFiles MkAtomTerm( Yap_heap_regs->AtomMaxFiles_ ) - Atom AtomMegaClause_; -#define AtomMegaClause Yap_heap_regs->AtomMegaClause_ -#define TermMegaClause MkAtomTerm( Yap_heap_regs->AtomMegaClause_ ) - Atom AtomMetaCall_; -#define AtomMetaCall Yap_heap_regs->AtomMetaCall_ -#define TermMetaCall MkAtomTerm( Yap_heap_regs->AtomMetaCall_ ) - Atom AtomMfClause_; -#define AtomMfClause Yap_heap_regs->AtomMfClause_ -#define TermMfClause MkAtomTerm( Yap_heap_regs->AtomMfClause_ ) - Atom AtomMin_; -#define AtomMin Yap_heap_regs->AtomMin_ -#define TermMin MkAtomTerm( Yap_heap_regs->AtomMin_ ) - Atom AtomMinimum_; -#define AtomMinimum Yap_heap_regs->AtomMinimum_ -#define TermMinimum MkAtomTerm( Yap_heap_regs->AtomMinimum_ ) - Atom AtomMinus_; -#define AtomMinus Yap_heap_regs->AtomMinus_ -#define TermMinus MkAtomTerm( Yap_heap_regs->AtomMinus_ ) - Atom AtomModify_; -#define AtomModify Yap_heap_regs->AtomModify_ -#define TermModify MkAtomTerm( Yap_heap_regs->AtomModify_ ) - Atom AtomModule_; -#define AtomModule Yap_heap_regs->AtomModule_ -#define TermModule MkAtomTerm( Yap_heap_regs->AtomModule_ ) - Atom AtomMost_; -#define AtomMost Yap_heap_regs->AtomMost_ -#define TermMost MkAtomTerm( Yap_heap_regs->AtomMost_ ) - Atom AtomMulti_; -#define AtomMulti Yap_heap_regs->AtomMulti_ -#define TermMulti MkAtomTerm( Yap_heap_regs->AtomMulti_ ) - Atom AtomMultiFile_; -#define AtomMultiFile Yap_heap_regs->AtomMultiFile_ -#define TermMultiFile MkAtomTerm( Yap_heap_regs->AtomMultiFile_ ) - Atom AtomMultiple_; -#define AtomMultiple Yap_heap_regs->AtomMultiple_ -#define TermMultiple MkAtomTerm( Yap_heap_regs->AtomMultiple_ ) - Atom AtomMutable_; -#define AtomMutable Yap_heap_regs->AtomMutable_ -#define TermMutable MkAtomTerm( Yap_heap_regs->AtomMutable_ ) - Atom AtomMutableVariable_; -#define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_ -#define TermMutableVariable MkAtomTerm( Yap_heap_regs->AtomMutableVariable_ ) - Atom AtomMutex_; -#define AtomMutex Yap_heap_regs->AtomMutex_ -#define TermMutex MkAtomTerm( Yap_heap_regs->AtomMutex_ ) - Atom AtomMyddasDB_; -#define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_ -#define TermMyddasDB MkAtomTerm( Yap_heap_regs->AtomMyddasDB_ ) - Atom AtomMyddasGoal_; -#define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_ -#define TermMyddasGoal MkAtomTerm( Yap_heap_regs->AtomMyddasGoal_ ) - Atom AtomMyddasHost_; -#define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_ -#define TermMyddasHost MkAtomTerm( Yap_heap_regs->AtomMyddasHost_ ) - Atom AtomMyddasPass_; -#define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_ -#define TermMyddasPass MkAtomTerm( Yap_heap_regs->AtomMyddasPass_ ) - Atom AtomMyddasUser_; -#define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_ -#define TermMyddasUser MkAtomTerm( Yap_heap_regs->AtomMyddasUser_ ) - Atom AtomMyddasVersionName_; -#define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_ -#define TermMyddasVersionName MkAtomTerm( Yap_heap_regs->AtomMyddasVersionName_ ) - Atom AtomNan_; -#define AtomNan Yap_heap_regs->AtomNan_ -#define TermNan MkAtomTerm( Yap_heap_regs->AtomNan_ ) - Atom AtomNb_; -#define AtomNb Yap_heap_regs->AtomNb_ -#define TermNb MkAtomTerm( Yap_heap_regs->AtomNb_ ) - Atom AtomNbTerm_; -#define AtomNbTerm Yap_heap_regs->AtomNbTerm_ -#define TermNbTerm MkAtomTerm( Yap_heap_regs->AtomNbTerm_ ) - Atom AtomNew_; -#define AtomNew Yap_heap_regs->AtomNew_ -#define TermNew MkAtomTerm( Yap_heap_regs->AtomNew_ ) - Atom AtomNewLine_; -#define AtomNewLine Yap_heap_regs->AtomNewLine_ -#define TermNewLine MkAtomTerm( Yap_heap_regs->AtomNewLine_ ) - Atom AtomNl_; -#define AtomNl Yap_heap_regs->AtomNl_ -#define TermNl MkAtomTerm( Yap_heap_regs->AtomNl_ ) - Atom AtomNoEffect_; -#define AtomNoEffect Yap_heap_regs->AtomNoEffect_ -#define TermNoEffect MkAtomTerm( Yap_heap_regs->AtomNoEffect_ ) - Atom AtomNoMemory_; -#define AtomNoMemory Yap_heap_regs->AtomNoMemory_ -#define TermNoMemory MkAtomTerm( Yap_heap_regs->AtomNoMemory_ ) - Atom AtomNone_; -#define AtomNone Yap_heap_regs->AtomNone_ -#define TermNone MkAtomTerm( Yap_heap_regs->AtomNone_ ) - Atom AtomNonEmptyList_; -#define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_ -#define TermNonEmptyList MkAtomTerm( Yap_heap_regs->AtomNonEmptyList_ ) - Atom AtomNot_; -#define AtomNot Yap_heap_regs->AtomNot_ -#define TermNot MkAtomTerm( Yap_heap_regs->AtomNot_ ) - Atom AtomNotImplemented_; -#define AtomNotImplemented Yap_heap_regs->AtomNotImplemented_ -#define TermNotImplemented MkAtomTerm( Yap_heap_regs->AtomNotImplemented_ ) - Atom AtomNotLessThanZero_; -#define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_ -#define TermNotLessThanZero MkAtomTerm( Yap_heap_regs->AtomNotLessThanZero_ ) - Atom AtomNotNewline_; -#define AtomNotNewline Yap_heap_regs->AtomNotNewline_ -#define TermNotNewline MkAtomTerm( Yap_heap_regs->AtomNotNewline_ ) - Atom AtomNotZero_; -#define AtomNotZero Yap_heap_regs->AtomNotZero_ -#define TermNotZero MkAtomTerm( Yap_heap_regs->AtomNotZero_ ) - Atom AtomNumber_; -#define AtomNumber Yap_heap_regs->AtomNumber_ -#define TermNumber MkAtomTerm( Yap_heap_regs->AtomNumber_ ) - Atom AtomOff_; -#define AtomOff Yap_heap_regs->AtomOff_ -#define TermOff MkAtomTerm( Yap_heap_regs->AtomOff_ ) - Atom AtomOffline_; -#define AtomOffline Yap_heap_regs->AtomOffline_ -#define TermOffline MkAtomTerm( Yap_heap_regs->AtomOffline_ ) - Atom AtomOn_; -#define AtomOn Yap_heap_regs->AtomOn_ -#define TermOn MkAtomTerm( Yap_heap_regs->AtomOn_ ) - Atom AtomOnline_; -#define AtomOnline Yap_heap_regs->AtomOnline_ -#define TermOnline MkAtomTerm( Yap_heap_regs->AtomOnline_ ) - Atom AtomOpen_; -#define AtomOpen Yap_heap_regs->AtomOpen_ -#define TermOpen MkAtomTerm( Yap_heap_regs->AtomOpen_ ) - Atom AtomOperatingSystemError_; -#define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_ -#define TermOperatingSystemError MkAtomTerm( Yap_heap_regs->AtomOperatingSystemError_ ) - Atom AtomOperatingSystemSupport_; -#define AtomOperatingSystemSupport Yap_heap_regs->AtomOperatingSystemSupport_ -#define TermOperatingSystemSupport MkAtomTerm( Yap_heap_regs->AtomOperatingSystemSupport_ ) - Atom AtomOperator_; -#define AtomOperator Yap_heap_regs->AtomOperator_ -#define TermOperator MkAtomTerm( Yap_heap_regs->AtomOperator_ ) - Atom AtomOperatorPriority_; -#define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_ -#define TermOperatorPriority MkAtomTerm( Yap_heap_regs->AtomOperatorPriority_ ) - Atom AtomOperatorSpecifier_; -#define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_ -#define TermOperatorSpecifier MkAtomTerm( Yap_heap_regs->AtomOperatorSpecifier_ ) - Atom AtomOpt_; -#define AtomOpt Yap_heap_regs->AtomOpt_ -#define TermOpt MkAtomTerm( Yap_heap_regs->AtomOpt_ ) - Atom AtomOtherwise_; -#define AtomOtherwise Yap_heap_regs->AtomOtherwise_ -#define TermOtherwise MkAtomTerm( Yap_heap_regs->AtomOtherwise_ ) - Atom AtomOutOfAttvarsError_; -#define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_ -#define TermOutOfAttvarsError MkAtomTerm( Yap_heap_regs->AtomOutOfAttvarsError_ ) - Atom AtomOutOfAuxspaceError_; -#define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_ -#define TermOutOfAuxspaceError MkAtomTerm( Yap_heap_regs->AtomOutOfAuxspaceError_ ) - Atom AtomOutOfHeapError_; -#define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_ -#define TermOutOfHeapError MkAtomTerm( Yap_heap_regs->AtomOutOfHeapError_ ) - Atom AtomOutOfRange_; -#define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_ -#define TermOutOfRange MkAtomTerm( Yap_heap_regs->AtomOutOfRange_ ) - Atom AtomOutOfStackError_; -#define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_ -#define TermOutOfStackError MkAtomTerm( Yap_heap_regs->AtomOutOfStackError_ ) - Atom AtomOutOfTrailError_; -#define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_ -#define TermOutOfTrailError MkAtomTerm( Yap_heap_regs->AtomOutOfTrailError_ ) - Atom AtomOutput_; -#define AtomOutput Yap_heap_regs->AtomOutput_ -#define TermOutput MkAtomTerm( Yap_heap_regs->AtomOutput_ ) - Atom AtomParameter_; -#define AtomParameter Yap_heap_regs->AtomParameter_ -#define TermParameter MkAtomTerm( Yap_heap_regs->AtomParameter_ ) - Atom AtomPrologCommonsDir_; -#define AtomPrologCommonsDir Yap_heap_regs->AtomPrologCommonsDir_ -#define TermPrologCommonsDir MkAtomTerm( Yap_heap_regs->AtomPrologCommonsDir_ ) - Atom AtomPast_; -#define AtomPast Yap_heap_regs->AtomPast_ -#define TermPast MkAtomTerm( Yap_heap_regs->AtomPast_ ) - Atom AtomPastEndOfStream_; -#define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_ -#define TermPastEndOfStream MkAtomTerm( Yap_heap_regs->AtomPastEndOfStream_ ) - Atom AtomPermissionError_; -#define AtomPermissionError Yap_heap_regs->AtomPermissionError_ -#define TermPermissionError MkAtomTerm( Yap_heap_regs->AtomPermissionError_ ) - Atom AtomPi_; -#define AtomPi Yap_heap_regs->AtomPi_ -#define TermPi MkAtomTerm( Yap_heap_regs->AtomPi_ ) - Atom AtomPipe_; -#define AtomPipe Yap_heap_regs->AtomPipe_ -#define TermPipe MkAtomTerm( Yap_heap_regs->AtomPipe_ ) - Atom AtomPlus_; -#define AtomPlus Yap_heap_regs->AtomPlus_ -#define TermPlus MkAtomTerm( Yap_heap_regs->AtomPlus_ ) - Atom AtomPointer_; -#define AtomPointer Yap_heap_regs->AtomPointer_ -#define TermPointer MkAtomTerm( Yap_heap_regs->AtomPointer_ ) - Atom AtomPortray_; -#define AtomPortray Yap_heap_regs->AtomPortray_ -#define TermPortray MkAtomTerm( Yap_heap_regs->AtomPortray_ ) - Atom AtomPredicateIndicator_; -#define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_ -#define TermPredicateIndicator MkAtomTerm( Yap_heap_regs->AtomPredicateIndicator_ ) - Atom AtomPrimitive_; -#define AtomPrimitive Yap_heap_regs->AtomPrimitive_ -#define TermPrimitive MkAtomTerm( Yap_heap_regs->AtomPrimitive_ ) - Atom AtomPrintMessage_; -#define AtomPrintMessage Yap_heap_regs->AtomPrintMessage_ -#define TermPrintMessage MkAtomTerm( Yap_heap_regs->AtomPrintMessage_ ) - Atom AtomPrivateProcedure_; -#define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_ -#define TermPrivateProcedure MkAtomTerm( Yap_heap_regs->AtomPrivateProcedure_ ) - Atom AtomProcedure_; -#define AtomProcedure Yap_heap_regs->AtomProcedure_ -#define TermProcedure MkAtomTerm( Yap_heap_regs->AtomProcedure_ ) - Atom AtomProfile_; -#define AtomProfile Yap_heap_regs->AtomProfile_ -#define TermProfile MkAtomTerm( Yap_heap_regs->AtomProfile_ ) - Atom AtomProlog_; -#define AtomProlog Yap_heap_regs->AtomProlog_ -#define TermProlog MkAtomTerm( Yap_heap_regs->AtomProlog_ ) - Atom AtomQly_; -#define AtomQly Yap_heap_regs->AtomQly_ -#define TermQly MkAtomTerm( Yap_heap_regs->AtomQly_ ) - Atom AtomQuery_; -#define AtomQuery Yap_heap_regs->AtomQuery_ -#define TermQuery MkAtomTerm( Yap_heap_regs->AtomQuery_ ) - Atom AtomQueue_; -#define AtomQueue Yap_heap_regs->AtomQueue_ -#define TermQueue MkAtomTerm( Yap_heap_regs->AtomQueue_ ) - Atom AtomQuiet_; -#define AtomQuiet Yap_heap_regs->AtomQuiet_ -#define TermQuiet MkAtomTerm( Yap_heap_regs->AtomQuiet_ ) - Atom AtomRadix_; -#define AtomRadix Yap_heap_regs->AtomRadix_ -#define TermRadix MkAtomTerm( Yap_heap_regs->AtomRadix_ ) - Atom AtomRandom_; -#define AtomRandom Yap_heap_regs->AtomRandom_ -#define TermRandom MkAtomTerm( Yap_heap_regs->AtomRandom_ ) - Atom AtomRange_; -#define AtomRange Yap_heap_regs->AtomRange_ -#define TermRange MkAtomTerm( Yap_heap_regs->AtomRange_ ) - Atom AtomRDiv_; -#define AtomRDiv Yap_heap_regs->AtomRDiv_ -#define TermRDiv MkAtomTerm( Yap_heap_regs->AtomRDiv_ ) - Atom AtomRead_; -#define AtomRead Yap_heap_regs->AtomRead_ -#define TermRead MkAtomTerm( Yap_heap_regs->AtomRead_ ) - Atom AtomReadOnly_; -#define AtomReadOnly Yap_heap_regs->AtomReadOnly_ -#define TermReadOnly MkAtomTerm( Yap_heap_regs->AtomReadOnly_ ) - Atom AtomReadWrite_; -#define AtomReadWrite Yap_heap_regs->AtomReadWrite_ -#define TermReadWrite MkAtomTerm( Yap_heap_regs->AtomReadWrite_ ) - Atom AtomReadutil_; -#define AtomReadutil Yap_heap_regs->AtomReadutil_ -#define TermReadutil MkAtomTerm( Yap_heap_regs->AtomReadutil_ ) - Atom AtomReconsult_; -#define AtomReconsult Yap_heap_regs->AtomReconsult_ -#define TermReconsult MkAtomTerm( Yap_heap_regs->AtomReconsult_ ) - Atom AtomRecordedP_; -#define AtomRecordedP Yap_heap_regs->AtomRecordedP_ -#define TermRecordedP MkAtomTerm( Yap_heap_regs->AtomRecordedP_ ) - Atom AtomRecordedWithKey_; -#define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_ -#define TermRecordedWithKey MkAtomTerm( Yap_heap_regs->AtomRecordedWithKey_ ) - Atom AtomRedefineWarnings_; -#define AtomRedefineWarnings Yap_heap_regs->AtomRedefineWarnings_ -#define TermRedefineWarnings MkAtomTerm( Yap_heap_regs->AtomRedefineWarnings_ ) - Atom AtomRedoFreeze_; -#define AtomRedoFreeze Yap_heap_regs->AtomRedoFreeze_ -#define TermRedoFreeze MkAtomTerm( Yap_heap_regs->AtomRedoFreeze_ ) - Atom AtomRefoundVar_; -#define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_ -#define TermRefoundVar MkAtomTerm( Yap_heap_regs->AtomRefoundVar_ ) - Atom AtomRelativeTo_; -#define AtomRelativeTo Yap_heap_regs->AtomRelativeTo_ -#define TermRelativeTo MkAtomTerm( Yap_heap_regs->AtomRelativeTo_ ) - Atom AtomRepeat_; -#define AtomRepeat Yap_heap_regs->AtomRepeat_ -#define TermRepeat MkAtomTerm( Yap_heap_regs->AtomRepeat_ ) - Atom AtomRepeatSpace_; -#define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_ -#define TermRepeatSpace MkAtomTerm( Yap_heap_regs->AtomRepeatSpace_ ) - Atom AtomReposition_; -#define AtomReposition Yap_heap_regs->AtomReposition_ -#define TermReposition MkAtomTerm( Yap_heap_regs->AtomReposition_ ) - Atom AtomRepresentationError_; -#define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_ -#define TermRepresentationError MkAtomTerm( Yap_heap_regs->AtomRepresentationError_ ) - Atom AtomReset_; -#define AtomReset Yap_heap_regs->AtomReset_ -#define TermReset MkAtomTerm( Yap_heap_regs->AtomReset_ ) - Atom AtomResize_; -#define AtomResize Yap_heap_regs->AtomResize_ -#define TermResize MkAtomTerm( Yap_heap_regs->AtomResize_ ) - Atom AtomResourceError_; -#define AtomResourceError Yap_heap_regs->AtomResourceError_ -#define TermResourceError MkAtomTerm( Yap_heap_regs->AtomResourceError_ ) - Atom AtomRestoreRegs_; -#define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_ -#define TermRestoreRegs MkAtomTerm( Yap_heap_regs->AtomRestoreRegs_ ) - Atom AtomRetryCounter_; -#define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_ -#define TermRetryCounter MkAtomTerm( Yap_heap_regs->AtomRetryCounter_ ) - Atom AtomRTree_; -#define AtomRTree Yap_heap_regs->AtomRTree_ -#define TermRTree MkAtomTerm( Yap_heap_regs->AtomRTree_ ) - Atom AtomSafe_; -#define AtomSafe Yap_heap_regs->AtomSafe_ -#define TermSafe MkAtomTerm( Yap_heap_regs->AtomSafe_ ) - Atom AtomSafeCallCleanup_; -#define AtomSafeCallCleanup Yap_heap_regs->AtomSafeCallCleanup_ -#define TermSafeCallCleanup MkAtomTerm( Yap_heap_regs->AtomSafeCallCleanup_ ) - Atom AtomSame_; -#define AtomSame Yap_heap_regs->AtomSame_ -#define TermSame MkAtomTerm( Yap_heap_regs->AtomSame_ ) - Atom AtomSemic_; -#define AtomSemic Yap_heap_regs->AtomSemic_ -#define TermSemic MkAtomTerm( Yap_heap_regs->AtomSemic_ ) - Atom AtomShiftCountOverflow_; -#define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_ -#define TermShiftCountOverflow MkAtomTerm( Yap_heap_regs->AtomShiftCountOverflow_ ) - Atom AtomSigAlarm_; -#define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_ -#define TermSigAlarm MkAtomTerm( Yap_heap_regs->AtomSigAlarm_ ) - Atom AtomSigBreak_; -#define AtomSigBreak Yap_heap_regs->AtomSigBreak_ -#define TermSigBreak MkAtomTerm( Yap_heap_regs->AtomSigBreak_ ) - Atom AtomSigCreep_; -#define AtomSigCreep Yap_heap_regs->AtomSigCreep_ -#define TermSigCreep MkAtomTerm( Yap_heap_regs->AtomSigCreep_ ) - Atom AtomSigDebug_; -#define AtomSigDebug Yap_heap_regs->AtomSigDebug_ -#define TermSigDebug MkAtomTerm( Yap_heap_regs->AtomSigDebug_ ) - Atom AtomSigDelayCreep_; -#define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_ -#define TermSigDelayCreep MkAtomTerm( Yap_heap_regs->AtomSigDelayCreep_ ) - Atom AtomSigFPE_; -#define AtomSigFPE Yap_heap_regs->AtomSigFPE_ -#define TermSigFPE MkAtomTerm( Yap_heap_regs->AtomSigFPE_ ) - Atom AtomSigHup_; -#define AtomSigHup Yap_heap_regs->AtomSigHup_ -#define TermSigHup MkAtomTerm( Yap_heap_regs->AtomSigHup_ ) - Atom AtomSigInt_; -#define AtomSigInt Yap_heap_regs->AtomSigInt_ -#define TermSigInt MkAtomTerm( Yap_heap_regs->AtomSigInt_ ) - Atom AtomSigIti_; -#define AtomSigIti Yap_heap_regs->AtomSigIti_ -#define TermSigIti MkAtomTerm( Yap_heap_regs->AtomSigIti_ ) - Atom AtomSigPending_; -#define AtomSigPending Yap_heap_regs->AtomSigPending_ -#define TermSigPending MkAtomTerm( Yap_heap_regs->AtomSigPending_ ) - Atom AtomSigPipe_; -#define AtomSigPipe Yap_heap_regs->AtomSigPipe_ -#define TermSigPipe MkAtomTerm( Yap_heap_regs->AtomSigPipe_ ) - Atom AtomSigStackDump_; -#define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_ -#define TermSigStackDump MkAtomTerm( Yap_heap_regs->AtomSigStackDump_ ) - Atom AtomSigStatistics_; -#define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_ -#define TermSigStatistics MkAtomTerm( Yap_heap_regs->AtomSigStatistics_ ) - Atom AtomSigTrace_; -#define AtomSigTrace Yap_heap_regs->AtomSigTrace_ -#define TermSigTrace MkAtomTerm( Yap_heap_regs->AtomSigTrace_ ) - Atom AtomSigUsr1_; -#define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_ -#define TermSigUsr1 MkAtomTerm( Yap_heap_regs->AtomSigUsr1_ ) - Atom AtomSigUsr2_; -#define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_ -#define TermSigUsr2 MkAtomTerm( Yap_heap_regs->AtomSigUsr2_ ) - Atom AtomSigVTAlarm_; -#define AtomSigVTAlarm Yap_heap_regs->AtomSigVTAlarm_ -#define TermSigVTAlarm MkAtomTerm( Yap_heap_regs->AtomSigVTAlarm_ ) - Atom AtomSigWakeUp_; -#define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_ -#define TermSigWakeUp MkAtomTerm( Yap_heap_regs->AtomSigWakeUp_ ) - Atom AtomSilent_; -#define AtomSilent Yap_heap_regs->AtomSilent_ -#define TermSilent MkAtomTerm( Yap_heap_regs->AtomSilent_ ) - Atom AtomSingle_; -#define AtomSingle Yap_heap_regs->AtomSingle_ -#define TermSingle MkAtomTerm( Yap_heap_regs->AtomSingle_ ) - Atom AtomSingleVarWarnings_; -#define AtomSingleVarWarnings Yap_heap_regs->AtomSingleVarWarnings_ -#define TermSingleVarWarnings MkAtomTerm( Yap_heap_regs->AtomSingleVarWarnings_ ) - Atom AtomSingleton_; -#define AtomSingleton Yap_heap_regs->AtomSingleton_ -#define TermSingleton MkAtomTerm( Yap_heap_regs->AtomSingleton_ ) - Atom AtomSlash_; -#define AtomSlash Yap_heap_regs->AtomSlash_ -#define TermSlash MkAtomTerm( Yap_heap_regs->AtomSlash_ ) - Atom AtomSocket_; -#define AtomSocket Yap_heap_regs->AtomSocket_ -#define TermSocket MkAtomTerm( Yap_heap_regs->AtomSocket_ ) - Atom AtomSolutions_; -#define AtomSolutions Yap_heap_regs->AtomSolutions_ -#define TermSolutions MkAtomTerm( Yap_heap_regs->AtomSolutions_ ) - Atom AtomSource_; -#define AtomSource Yap_heap_regs->AtomSource_ -#define TermSource MkAtomTerm( Yap_heap_regs->AtomSource_ ) - Atom AtomSourceSink_; -#define AtomSourceSink Yap_heap_regs->AtomSourceSink_ -#define TermSourceSink MkAtomTerm( Yap_heap_regs->AtomSourceSink_ ) - Atom AtomSpy_; -#define AtomSpy Yap_heap_regs->AtomSpy_ -#define TermSpy MkAtomTerm( Yap_heap_regs->AtomSpy_ ) - Atom AtomStack_; -#define AtomStack Yap_heap_regs->AtomStack_ -#define TermStack MkAtomTerm( Yap_heap_regs->AtomStack_ ) - Atom AtomStackFree_; -#define AtomStackFree Yap_heap_regs->AtomStackFree_ -#define TermStackFree MkAtomTerm( Yap_heap_regs->AtomStackFree_ ) - Atom AtomStartupSavedState_; -#define AtomStartupSavedState Yap_heap_regs->AtomStartupSavedState_ -#define TermStartupSavedState MkAtomTerm( Yap_heap_regs->AtomStartupSavedState_ ) - Atom AtomStaticClause_; -#define AtomStaticClause Yap_heap_regs->AtomStaticClause_ -#define TermStaticClause MkAtomTerm( Yap_heap_regs->AtomStaticClause_ ) - Atom AtomStaticProcedure_; -#define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_ -#define TermStaticProcedure MkAtomTerm( Yap_heap_regs->AtomStaticProcedure_ ) - Atom AtomStream_; -#define AtomStream Yap_heap_regs->AtomStream_ -#define TermStream MkAtomTerm( Yap_heap_regs->AtomStream_ ) - Atom AtomSWIStream_; -#define AtomSWIStream Yap_heap_regs->AtomSWIStream_ -#define TermSWIStream MkAtomTerm( Yap_heap_regs->AtomSWIStream_ ) - Atom AtomVStream_; -#define AtomVStream Yap_heap_regs->AtomVStream_ -#define TermVStream MkAtomTerm( Yap_heap_regs->AtomVStream_ ) - Atom AtomStreams_; -#define AtomStreams Yap_heap_regs->AtomStreams_ -#define TermStreams MkAtomTerm( Yap_heap_regs->AtomStreams_ ) - Atom AtomStreamOrAlias_; -#define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_ -#define TermStreamOrAlias MkAtomTerm( Yap_heap_regs->AtomStreamOrAlias_ ) - Atom AtomStreamPos_; -#define AtomStreamPos Yap_heap_regs->AtomStreamPos_ -#define TermStreamPos MkAtomTerm( Yap_heap_regs->AtomStreamPos_ ) - Atom AtomStreamPosition_; -#define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_ -#define TermStreamPosition MkAtomTerm( Yap_heap_regs->AtomStreamPosition_ ) - Atom AtomString_; -#define AtomString Yap_heap_regs->AtomString_ -#define TermString MkAtomTerm( Yap_heap_regs->AtomString_ ) - Atom AtomStyleCheck_; -#define AtomStyleCheck Yap_heap_regs->AtomStyleCheck_ -#define TermStyleCheck MkAtomTerm( Yap_heap_regs->AtomStyleCheck_ ) - Atom AtomSTRING_; -#define AtomSTRING Yap_heap_regs->AtomSTRING_ -#define TermSTRING MkAtomTerm( Yap_heap_regs->AtomSTRING_ ) - Atom AtomSwi_; -#define AtomSwi Yap_heap_regs->AtomSwi_ -#define TermSwi MkAtomTerm( Yap_heap_regs->AtomSwi_ ) - Atom AtomSymbolChar_; -#define AtomSymbolChar Yap_heap_regs->AtomSymbolChar_ -#define TermSymbolChar MkAtomTerm( Yap_heap_regs->AtomSymbolChar_ ) - Atom AtomSyntaxError_; -#define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_ -#define TermSyntaxError MkAtomTerm( Yap_heap_regs->AtomSyntaxError_ ) - Atom AtomSyntaxErrors_; -#define AtomSyntaxErrors Yap_heap_regs->AtomSyntaxErrors_ -#define TermSyntaxErrors MkAtomTerm( Yap_heap_regs->AtomSyntaxErrors_ ) - Atom AtomSyntaxErrorHandler_; -#define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_ -#define TermSyntaxErrorHandler MkAtomTerm( Yap_heap_regs->AtomSyntaxErrorHandler_ ) - Atom AtomSystem_; -#define AtomSystem Yap_heap_regs->AtomSystem_ -#define TermSystem MkAtomTerm( Yap_heap_regs->AtomSystem_ ) - Atom AtomSystemError_; -#define AtomSystemError Yap_heap_regs->AtomSystemError_ -#define TermSystemError MkAtomTerm( Yap_heap_regs->AtomSystemError_ ) - Atom AtomSystemLibraryDir_; -#define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_ -#define TermSystemLibraryDir MkAtomTerm( Yap_heap_regs->AtomSystemLibraryDir_ ) - Atom AtomTerm_; -#define AtomTerm Yap_heap_regs->AtomTerm_ -#define TermTerm MkAtomTerm( Yap_heap_regs->AtomTerm_ ) - Atom AtomTerms_; -#define AtomTerms Yap_heap_regs->AtomTerms_ -#define TermTerms MkAtomTerm( Yap_heap_regs->AtomTerms_ ) - Atom AtomTermExpansion_; -#define AtomTermExpansion Yap_heap_regs->AtomTermExpansion_ -#define TermTermExpansion MkAtomTerm( Yap_heap_regs->AtomTermExpansion_ ) - Atom AtomText_; -#define AtomText Yap_heap_regs->AtomText_ -#define TermText MkAtomTerm( Yap_heap_regs->AtomText_ ) - Atom AtomTextStream_; -#define AtomTextStream Yap_heap_regs->AtomTextStream_ -#define TermTextStream MkAtomTerm( Yap_heap_regs->AtomTextStream_ ) - Atom AtomThread_; -#define AtomThread Yap_heap_regs->AtomThread_ -#define TermThread MkAtomTerm( Yap_heap_regs->AtomThread_ ) - Atom AtomThreads_; -#define AtomThreads Yap_heap_regs->AtomThreads_ -#define TermThreads MkAtomTerm( Yap_heap_regs->AtomThreads_ ) - Atom AtomThrow_; -#define AtomThrow Yap_heap_regs->AtomThrow_ -#define TermThrow MkAtomTerm( Yap_heap_regs->AtomThrow_ ) - Atom AtomTimeOutSpec_; -#define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_ -#define TermTimeOutSpec MkAtomTerm( Yap_heap_regs->AtomTimeOutSpec_ ) - Atom AtomTimeoutError_; -#define AtomTimeoutError Yap_heap_regs->AtomTimeoutError_ -#define TermTimeoutError MkAtomTerm( Yap_heap_regs->AtomTimeoutError_ ) - Atom AtomTopLevelGoal_; -#define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_ -#define TermTopLevelGoal MkAtomTerm( Yap_heap_regs->AtomTopLevelGoal_ ) - Atom AtomTopThreadGoal_; -#define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_ -#define TermTopThreadGoal MkAtomTerm( Yap_heap_regs->AtomTopThreadGoal_ ) - Atom AtomTraceMetaCall_; -#define AtomTraceMetaCall Yap_heap_regs->AtomTraceMetaCall_ -#define TermTraceMetaCall MkAtomTerm( Yap_heap_regs->AtomTraceMetaCall_ ) - Atom AtomTrail_; -#define AtomTrail Yap_heap_regs->AtomTrail_ -#define TermTrail MkAtomTerm( Yap_heap_regs->AtomTrail_ ) - Atom AtomTrue_; -#define AtomTrue Yap_heap_regs->AtomTrue_ -#define TermTrue MkAtomTerm( Yap_heap_regs->AtomTrue_ ) - Atom AtomTty_; -#define AtomTty Yap_heap_regs->AtomTty_ -#define TermTty MkAtomTerm( Yap_heap_regs->AtomTty_ ) - Atom AtomTtys_; -#define AtomTtys Yap_heap_regs->AtomTtys_ -#define TermTtys MkAtomTerm( Yap_heap_regs->AtomTtys_ ) - Atom AtomTxt_; -#define AtomTxt Yap_heap_regs->AtomTxt_ -#define TermTxt MkAtomTerm( Yap_heap_regs->AtomTxt_ ) - Atom AtomTypeError_; -#define AtomTypeError Yap_heap_regs->AtomTypeError_ -#define TermTypeError MkAtomTerm( Yap_heap_regs->AtomTypeError_ ) - Atom AtomUndefined_; -#define AtomUndefined Yap_heap_regs->AtomUndefined_ -#define TermUndefined MkAtomTerm( Yap_heap_regs->AtomUndefined_ ) - Atom AtomUndefp_; -#define AtomUndefp Yap_heap_regs->AtomUndefp_ -#define TermUndefp MkAtomTerm( Yap_heap_regs->AtomUndefp_ ) - Atom AtomUnderflow_; -#define AtomUnderflow Yap_heap_regs->AtomUnderflow_ -#define TermUnderflow MkAtomTerm( Yap_heap_regs->AtomUnderflow_ ) - Atom AtomUnificationStack_; -#define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_ -#define TermUnificationStack MkAtomTerm( Yap_heap_regs->AtomUnificationStack_ ) - Atom AtomUnique_; -#define AtomUnique Yap_heap_regs->AtomUnique_ -#define TermUnique MkAtomTerm( Yap_heap_regs->AtomUnique_ ) - Atom AtomUnsignedByte_; -#define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_ -#define TermUnsignedByte MkAtomTerm( Yap_heap_regs->AtomUnsignedByte_ ) - Atom AtomUnsignedChar_; -#define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_ -#define TermUnsignedChar MkAtomTerm( Yap_heap_regs->AtomUnsignedChar_ ) - Atom AtomUser_; -#define AtomUser Yap_heap_regs->AtomUser_ -#define TermUser MkAtomTerm( Yap_heap_regs->AtomUser_ ) - Atom AtomUserErr_; -#define AtomUserErr Yap_heap_regs->AtomUserErr_ -#define TermUserErr MkAtomTerm( Yap_heap_regs->AtomUserErr_ ) - Atom AtomUserIn_; -#define AtomUserIn Yap_heap_regs->AtomUserIn_ -#define TermUserIn MkAtomTerm( Yap_heap_regs->AtomUserIn_ ) - Atom AtomUserOut_; -#define AtomUserOut Yap_heap_regs->AtomUserOut_ -#define TermUserOut MkAtomTerm( Yap_heap_regs->AtomUserOut_ ) - Atom AtomDollarVar_; -#define AtomDollarVar Yap_heap_regs->AtomDollarVar_ -#define TermDollarVar MkAtomTerm( Yap_heap_regs->AtomDollarVar_ ) - Atom AtomVBar_; -#define AtomVBar Yap_heap_regs->AtomVBar_ -#define TermVBar MkAtomTerm( Yap_heap_regs->AtomVBar_ ) - Atom AtomVarBranches_; -#define AtomVarBranches Yap_heap_regs->AtomVarBranches_ -#define TermVarBranches MkAtomTerm( Yap_heap_regs->AtomVarBranches_ ) - Atom AtomVariableNames_; -#define AtomVariableNames Yap_heap_regs->AtomVariableNames_ -#define TermVariableNames MkAtomTerm( Yap_heap_regs->AtomVariableNames_ ) - Atom AtomHiddenVar_; -#define AtomHiddenVar Yap_heap_regs->AtomHiddenVar_ -#define TermHiddenVar MkAtomTerm( Yap_heap_regs->AtomHiddenVar_ ) - Atom AtomVariable_; -#define AtomVariable Yap_heap_regs->AtomVariable_ -#define TermVariable MkAtomTerm( Yap_heap_regs->AtomVariable_ ) - Atom AtomVerbose_; -#define AtomVerbose Yap_heap_regs->AtomVerbose_ -#define TermVerbose MkAtomTerm( Yap_heap_regs->AtomVerbose_ ) - Atom AtomVerboseFileSearch_; -#define AtomVerboseFileSearch Yap_heap_regs->AtomVerboseFileSearch_ -#define TermVerboseFileSearch MkAtomTerm( Yap_heap_regs->AtomVerboseFileSearch_ ) - Atom AtomVersionNumber_; -#define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_ -#define TermVersionNumber MkAtomTerm( Yap_heap_regs->AtomVersionNumber_ ) - Atom AtomVeryVerbose_; -#define AtomVeryVerbose Yap_heap_regs->AtomVeryVerbose_ -#define TermVeryVerbose MkAtomTerm( Yap_heap_regs->AtomVeryVerbose_ ) - Atom AtomWakeUpGoal_; -#define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_ -#define TermWakeUpGoal MkAtomTerm( Yap_heap_regs->AtomWakeUpGoal_ ) - Atom AtomWarning_; -#define AtomWarning Yap_heap_regs->AtomWarning_ -#define TermWarning MkAtomTerm( Yap_heap_regs->AtomWarning_ ) - Atom AtomWhen_; -#define AtomWhen Yap_heap_regs->AtomWhen_ -#define TermWhen MkAtomTerm( Yap_heap_regs->AtomWhen_ ) - Atom AtomWrite_; -#define AtomWrite Yap_heap_regs->AtomWrite_ -#define TermWrite MkAtomTerm( Yap_heap_regs->AtomWrite_ ) - Atom AtomXml_; -#define AtomXml Yap_heap_regs->AtomXml_ -#define TermXml MkAtomTerm( Yap_heap_regs->AtomXml_ ) - Atom AtomYapHacks_; -#define AtomYapHacks Yap_heap_regs->AtomYapHacks_ -#define TermYapHacks MkAtomTerm( Yap_heap_regs->AtomYapHacks_ ) - Atom AtomZeroDivisor_; -#define AtomZeroDivisor Yap_heap_regs->AtomZeroDivisor_ -#define TermZeroDivisor MkAtomTerm( Yap_heap_regs->AtomZeroDivisor_ ) - Functor FunctorAfInet_; -#define FunctorAfInet Yap_heap_regs->FunctorAfInet_ - Functor FunctorAfLocal_; -#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_ - 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_ - Functor FunctorCleanCall_; -#define FunctorCleanCall Yap_heap_regs->FunctorCleanCall_ - Functor FunctorClist_; -#define FunctorClist Yap_heap_regs->FunctorClist_ - Functor FunctorCodes_; -#define FunctorCodes Yap_heap_regs->FunctorCodes_ - Functor FunctorCodes1_; -#define FunctorCodes1 Yap_heap_regs->FunctorCodes1_ - Functor FunctorComma_; -#define FunctorComma Yap_heap_regs->FunctorComma_ - Functor FunctorCommentHook_; -#define FunctorCommentHook Yap_heap_regs->FunctorCommentHook_ - Functor FunctorContext2_; -#define FunctorContext2 Yap_heap_regs->FunctorContext2_ - 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_ - Functor FunctorDBREF_; -#define FunctorDBREF Yap_heap_regs->FunctorDBREF_ - Functor FunctorDiff_; -#define FunctorDiff Yap_heap_regs->FunctorDiff_ - 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_ - 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_ - Functor FunctorDoubleSlash_; -#define FunctorDoubleSlash Yap_heap_regs->FunctorDoubleSlash_ - 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_ - 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_ - Functor FunctorExistenceError_; -#define FunctorExistenceError Yap_heap_regs->FunctorExistenceError_ - 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_ - 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_ - 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_ - 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_ - Functor FunctorPermissionError_; -#define FunctorPermissionError Yap_heap_regs->FunctorPermissionError_ - Functor FunctorPlus_; -#define FunctorPlus Yap_heap_regs->FunctorPlus_ - Functor FunctorPortray_; -#define FunctorPortray Yap_heap_regs->FunctorPortray_ - Functor FunctorPrintMessage_; -#define FunctorPrintMessage Yap_heap_regs->FunctorPrintMessage_ - Functor FunctorProcedure_; -#define FunctorProcedure Yap_heap_regs->FunctorProcedure_ - Functor FunctorPrologConstraint_; -#define FunctorPrologConstraint Yap_heap_regs->FunctorPrologConstraint_ - Functor FunctorQuery_; -#define FunctorQuery Yap_heap_regs->FunctorQuery_ - Functor FunctorRecordedWithKey_; -#define FunctorRecordedWithKey Yap_heap_regs->FunctorRecordedWithKey_ - Functor FunctorRDiv_; -#define FunctorRDiv Yap_heap_regs->FunctorRDiv_ - Functor FunctorRedoFreeze_; -#define FunctorRedoFreeze Yap_heap_regs->FunctorRedoFreeze_ - 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_ - Functor FunctorStyleCheck_; -#define FunctorStyleCheck Yap_heap_regs->FunctorStyleCheck_ - Functor FunctorSyntaxError_; -#define FunctorSyntaxError Yap_heap_regs->FunctorSyntaxError_ - 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_ - Functor FunctorTraceMetaCall_; -#define FunctorTraceMetaCall Yap_heap_regs->FunctorTraceMetaCall_ - 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_ - Functor FunctorHiddenVar_; -#define FunctorHiddenVar Yap_heap_regs->FunctorHiddenVar_