2015-10-20 07:52:33 +01:00
|
|
|
|
2015-08-07 16:57:53 -05:00
|
|
|
/* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms"
|
2016-03-16 23:56:24 +00:00
|
|
|
{lease do not update, update misc/ATOMS instead */
|
2010-04-18 21:48:20 +01:00
|
|
|
|
2008-12-23 01:53:52 +00:00
|
|
|
Atom3Dots = Yap_LookupAtom("...");
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-04-26 15:33:16 +01:00
|
|
|
AtomColon = Yap_LookupAtom(":"); TermColon = MkAtomTerm(AtomColon);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-04-26 15:33:16 +01:00
|
|
|
AtomCurly = Yap_LookupAtom("{}"); TermCurly = MkAtomTerm(AtomCurly);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-05-15 08:08:42 +01:00
|
|
|
AtomExists = Yap_LookupAtom("exists"); TermExists = MkAtomTerm(AtomExists);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-04-26 15:33:16 +01:00
|
|
|
AtomI = Yap_LookupAtom("i"); TermI = MkAtomTerm(AtomI);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-04-26 15:33:16 +01:00
|
|
|
AtomJ = Yap_LookupAtom("j"); TermJ = MkAtomTerm(AtomJ);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-04-26 15:33:16 +01:00
|
|
|
AtomObj = Yap_LookupAtom("o__bj__"); TermObj = MkAtomTerm(AtomObj);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-03-29 02:02:43 +01:00
|
|
|
AtomRetry = Yap_LookupAtom("retry"); TermRetry = MkAtomTerm(AtomRetry);
|
2016-03-16 23:56:24 +00:00
|
|
|
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("<stream>"); 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);
|
2016-05-15 08:08:42 +01:00
|
|
|
AtomT = Yap_LookupAtom("t"); TermT = MkAtomTerm(AtomT);
|
2016-03-16 23:56:24 +00:00
|
|
|
AtomTerm = Yap_LookupAtom("term"); TermTerm = MkAtomTerm(AtomTerm);
|
|
|
|
|
AtomTermExpansion = Yap_LookupAtom("term_expansion"); TermTermExpansion = MkAtomTerm(AtomTermExpansion);
|
2016-04-26 15:33:16 +01:00
|
|
|
AtomTerms = Yap_LookupAtom("terms"); TermTerms = MkAtomTerm(AtomTerms);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2009-05-17 09:42:56 -07:00
|
|
|
AtomTrail = Yap_LookupAtom("trail");
|
2016-03-16 23:56:24 +00:00
|
|
|
AtomTrue = Yap_LookupAtom("true"); TermTrue = MkAtomTerm(AtomTrue);
|
|
|
|
|
AtomTty = Yap_LookupAtom("tty"); TermTty = MkAtomTerm(AtomTty);
|
|
|
|
|
AtomTtys = Yap_LookupAtom("ttys"); TermTtys = MkAtomTerm(AtomTtys);
|
2016-05-15 08:08:42 +01:00
|
|
|
AtomTuple = Yap_LookupAtom("tuple"); TermTuple = MkAtomTerm(AtomTuple);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-06-03 16:53:43 +01:00
|
|
|
AtomUndefp0 = Yap_FullLookupAtom("$undefp0"); TermUndefp0 = MkAtomTerm(AtomUndefp0);
|
2016-03-16 23:56:24 +00:00
|
|
|
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);
|
2016-07-31 10:23:19 -05:00
|
|
|
AtomWriteTerm = Yap_LookupAtom("write_term"); TermWriteTerm = MkAtomTerm(AtomWriteTerm);
|
2016-03-16 23:56:24 +00:00
|
|
|
AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml);
|
|
|
|
|
AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks);
|
|
|
|
|
AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor);
|
2008-12-23 01:53:52 +00:00
|
|
|
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);
|
2014-04-24 08:26:31 +01:00
|
|
|
FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2);
|
|
|
|
|
FunctorAssert1 = Yap_MkFunctor(AtomAssert,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorAssert = Yap_MkFunctor(AtomAssert,2);
|
|
|
|
|
FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2);
|
|
|
|
|
FunctorAtom = Yap_MkFunctor(AtomAtom,1);
|
2008-12-24 09:04:44 +00:00
|
|
|
FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2);
|
|
|
|
|
FunctorBraces = Yap_MkFunctor(AtomBraces,1);
|
|
|
|
|
FunctorCall = Yap_MkFunctor(AtomCall,1);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorCatch = Yap_MkFunctor(AtomCatch,3);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1);
|
2015-06-19 00:56:24 +01:00
|
|
|
FunctorChars = Yap_MkFunctor(AtomChars,2);
|
|
|
|
|
FunctorChars1 = Yap_MkFunctor(AtomChars,1);
|
2009-06-05 18:45:41 -05:00
|
|
|
FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorClist = Yap_MkFunctor(AtomWhen,4);
|
2010-07-19 14:48:42 +01:00
|
|
|
FunctorCodes = Yap_MkFunctor(AtomCodes,2);
|
2015-06-19 00:56:24 +01:00
|
|
|
FunctorCodes1 = Yap_MkFunctor(AtomCodes,1);
|
2016-04-26 15:33:16 +01:00
|
|
|
FunctorColon = Yap_MkFunctor(AtomColon,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorComma = Yap_MkFunctor(AtomComma,2);
|
2013-12-08 22:56:48 +00:00
|
|
|
FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3);
|
2009-05-30 12:52:23 -05:00
|
|
|
FunctorContext2 = Yap_MkFunctor(AtomContext,2);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorCreep = Yap_MkFunctor(AtomCreep,1);
|
2014-06-11 19:36:50 +01:00
|
|
|
FunctorCsult = Yap_MkFunctor(AtomCsult,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1);
|
|
|
|
|
FunctorCutBy = Yap_MkFunctor(AtomCutBy,1);
|
2011-03-11 19:49:32 +00:00
|
|
|
FunctorDBREF = Yap_MkFunctor(AtomDBREF,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorDiff = Yap_MkFunctor(AtomDiff,2);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6);
|
|
|
|
|
FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6);
|
|
|
|
|
FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6);
|
|
|
|
|
FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5);
|
2016-04-26 15:33:16 +01:00
|
|
|
FunctorDollar = Yap_MkFunctor(AtomDollar,1);
|
2015-12-15 08:48:53 +00:00
|
|
|
FunctorDollarVar = Yap_MkFunctor(AtomDollarVar,1);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorDomainError = Yap_MkFunctor(AtomDomainError,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorDot = Yap_MkFunctor(AtomDot,2);
|
2008-12-24 09:04:44 +00:00
|
|
|
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);
|
2016-01-03 15:40:49 +00:00
|
|
|
FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2);
|
2013-09-13 11:44:26 +01:00
|
|
|
FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2);
|
|
|
|
|
FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorEq = Yap_MkFunctor(AtomEq,2);
|
|
|
|
|
FunctorError = Yap_MkFunctor(AtomError,2);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);
|
2016-03-16 23:56:24 +00:00
|
|
|
FunctorException = Yap_MkFunctor(AtomException,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2);
|
|
|
|
|
FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2);
|
|
|
|
|
FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2);
|
2013-01-11 16:45:14 +00:00
|
|
|
FunctorExoClause = Yap_MkFunctor(AtomExoClause,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
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);
|
2009-10-21 00:07:31 +01:00
|
|
|
FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
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);
|
2012-11-07 13:49:54 +00:00
|
|
|
FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3);
|
|
|
|
|
FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3);
|
2013-01-14 22:46:06 +00:00
|
|
|
FunctorHat = Yap_MkFunctor(AtomHat,2);
|
2016-04-26 15:33:16 +01:00
|
|
|
FunctorI = Yap_MkFunctor(AtomI,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorId = Yap_MkFunctor(AtomId,1);
|
2009-02-09 21:56:40 +00:00
|
|
|
FunctorIs = Yap_MkFunctor(AtomIs,2);
|
2016-04-26 15:33:16 +01:00
|
|
|
FunctorJ = Yap_MkFunctor(AtomJ,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1);
|
|
|
|
|
FunctorList = Yap_MkFunctor(AtomDot,2);
|
2010-11-01 20:11:28 +00:00
|
|
|
FunctorLOOP = Yap_MkFunctor(AtomLOOP,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4);
|
2008-12-24 09:04:44 +00:00
|
|
|
FunctorMinus = Yap_MkFunctor(AtomMinus,2);
|
2016-04-26 15:33:16 +01:00
|
|
|
FunctorModule = Yap_MkFunctor(AtomColon,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5);
|
|
|
|
|
FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL)));
|
2014-11-27 10:02:04 +00:00
|
|
|
FunctorMutex = Yap_MkFunctor(AtomMutex,2);
|
2009-05-30 12:52:23 -05:00
|
|
|
FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2);
|
2010-03-12 22:40:17 +00:00
|
|
|
FunctorNBQueue = Yap_MkFunctor(AtomQueue,4);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorNot = Yap_MkFunctor(AtomNot,1);
|
2016-04-26 15:33:16 +01:00
|
|
|
FunctorObj = Yap_MkFunctor(AtomObj,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorOr = Yap_MkFunctor(AtomSemic,2);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3);
|
2011-04-04 13:20:35 +01:00
|
|
|
FunctorPlus = Yap_MkFunctor(AtomPlus,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorPortray = Yap_MkFunctor(AtomPortray,1);
|
2013-11-21 00:22:03 +00:00
|
|
|
FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2);
|
2016-01-03 02:06:09 +00:00
|
|
|
FunctorProcedure = Yap_MkFunctor(AtomProcedure,5);
|
2009-06-05 18:45:41 -05:00
|
|
|
FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2);
|
2016-03-29 02:02:43 +01:00
|
|
|
FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,4);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorQuery = Yap_MkFunctor(AtomQuery,1);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6);
|
2010-05-28 09:53:56 +01:00
|
|
|
FunctorRDiv = Yap_MkFunctor(AtomRDiv,2);
|
2009-06-05 18:45:41 -05:00
|
|
|
FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1);
|
|
|
|
|
FunctorResourceError = Yap_MkFunctor(AtomResourceError,1);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2);
|
|
|
|
|
FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1);
|
2009-03-10 16:24:26 +00:00
|
|
|
FunctorSafe = Yap_MkFunctor(AtomSafe,1);
|
2009-11-27 11:21:24 +00:00
|
|
|
FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorSame = Yap_MkFunctor(AtomSame,2);
|
|
|
|
|
FunctorSlash = Yap_MkFunctor(AtomSlash,2);
|
2013-11-07 23:51:22 +00:00
|
|
|
FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorStream = Yap_MkFunctor(AtomStream,1);
|
|
|
|
|
FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1);
|
2011-02-14 23:39:27 -08:00
|
|
|
FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4);
|
2015-06-19 00:56:24 +01:00
|
|
|
FunctorString1 = Yap_MkFunctor(AtomString,1);
|
2015-09-21 17:05:36 -05:00
|
|
|
FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4);
|
2015-08-18 14:36:10 -05:00
|
|
|
FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4);
|
2010-02-26 13:30:16 +00:00
|
|
|
FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1);
|
2012-12-07 08:08:32 +00:00
|
|
|
FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2);
|
|
|
|
|
FunctorThrow = Yap_MkFunctor(AtomThrow,1);
|
2009-05-30 12:52:23 -05:00
|
|
|
FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2);
|
2015-07-22 19:19:35 -05:00
|
|
|
FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3);
|
2008-12-23 02:20:22 +00:00
|
|
|
FunctorTypeError = Yap_MkFunctor(AtomTypeError,2);
|
2008-12-23 01:53:52 +00:00
|
|
|
FunctorUMinus = Yap_MkFunctor(AtomMinus,1);
|
|
|
|
|
FunctorUPlus = Yap_MkFunctor(AtomPlus,1);
|
|
|
|
|
FunctorVBar = Yap_MkFunctor(AtomVBar,2);
|
2016-07-31 10:23:19 -05:00
|
|
|
FunctorWriteTerm = Yap_MkFunctor(AtomWriteTerm,2);
|
2012-03-15 22:19:48 +00:00
|
|
|
FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1);
|
