diff --git a/C/absmi.c b/C/absmi.c index 047d1d677..78d431c7c 100644 --- a/C/absmi.c +++ b/C/absmi.c @@ -2696,7 +2696,7 @@ Yap_absmi(int inp) goto do_commit_b_y; } if (!(ActiveSignals & YAP_CREEP_SIGNAL)) { - SREG = (CELL *)RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(AtomRestoreRegs,2),0)); + SREG = (CELL *)RepPredProp(Yap_GetPredPropByFunc(FunctorRestoreRegs,0)); XREGS[0] = YREG[PREG->u.yp.y]; PREG = NEXTOP(PREG,yp); goto creep_either; @@ -2712,7 +2712,7 @@ Yap_absmi(int inp) goto do_commit_b_x; } if (!(ActiveSignals & YAP_CREEP_SIGNAL)) { - SREG = (CELL *)RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(AtomRestoreRegs,2),0)); + SREG = (CELL *)RepPredProp(Yap_GetPredPropByFunc(FunctorRestoreRegs,0)); #if USE_THREADED_CODE if (PREG->opc == (OPCODE)OpAddress[_fcall]) #else @@ -2756,7 +2756,7 @@ Yap_absmi(int inp) goto either_notest; } /* find something to fool S */ - SREG = (CELL *)RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(AtomRestoreRegs,1),0)); + SREG = (CELL *)RepPredProp(Yap_GetPredPropByFunc(FunctorRestoreRegs1,0)); if (ActiveSignals & YAP_CDOVF_SIGNAL) { ASP = (CELL *) (((char *) YREG) + PREG->u.Osbpp.s); if (ASP > (CELL *)PROTECT_FROZEN_B(B)) @@ -12632,7 +12632,7 @@ Yap_absmi(int inp) Op(p_dif, l); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("\\="),2),0)),XREGS+1); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorDiff,0)),XREGS+1); #endif /* LOW_LEVEL_TRACE */ BEGD(d0); BEGD(d1); @@ -12754,7 +12754,7 @@ Yap_absmi(int inp) Op(p_eq, l); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("=="),2),0)),XREGS+1); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorSame,0)),XREGS+1); #endif /* LOW_LEVEL_TRACE */ BEGD(d0); BEGD(d1); @@ -12911,7 +12911,7 @@ Yap_absmi(int inp) H[0] = XREG(PREG->u.xxx.x1); H[1] = XREG(PREG->u.xxx.x2); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("arg"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -13012,7 +13012,7 @@ Yap_absmi(int inp) H[0] = t; H[1] = XREG(PREG->u.xxn.xi); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("arg"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); H = Ho; } #endif /* LOW_LEVEL_TRACE */ @@ -13091,7 +13091,7 @@ Yap_absmi(int inp) H[0] = XREG(PREG->u.yxx.x1); H[1] = XREG(PREG->u.yxx.x2); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("arg"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -13206,7 +13206,7 @@ Yap_absmi(int inp) H[0] = t; H[1] = XREG(PREG->u.yxn.xi); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("arg"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorArg,0)),H); H = Ho; } #endif /* LOW_LEVEL_TRACE */ @@ -13301,7 +13301,7 @@ Yap_absmi(int inp) RESET_VARIABLE(H); H[1] = XREG(PREG->u.xxx.x1); H[2] = XREG(PREG->u.xxx.x2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ /* We have to build the structure */ @@ -13423,7 +13423,7 @@ Yap_absmi(int inp) RESET_VARIABLE(H); H[1] = PREG->u.xxn.c; H[2] = XREG(PREG->u.xxn.xi); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -13531,7 +13531,7 @@ Yap_absmi(int inp) RESET_VARIABLE(H); H[1] = XREG(PREG->u.xxn.xi); H[2] = ti; - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); H = hi; } #endif /* LOW_LEVEL_TRACE */ @@ -13627,7 +13627,7 @@ Yap_absmi(int inp) RESET_VARIABLE(H); H[1] = XREG(PREG->u.yxx.x1); H[2] = XREG(PREG->u.yxx.x2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ /* We have to build the structure */ @@ -13767,7 +13767,7 @@ Yap_absmi(int inp) RESET_VARIABLE(H); H[1] = PREG->u.yxn.c; H[2] = XREG(PREG->u.yxn.xi); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ /* We have to build the structure */ @@ -13897,7 +13897,7 @@ Yap_absmi(int inp) RESET_VARIABLE(H); H[1] = XREG(PREG->u.yxn.xi); H[2] = ti; - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); H = hi; } #endif /* LOW_LEVEL_TRACE */ @@ -14018,7 +14018,7 @@ Yap_absmi(int inp) H[0] = XREG(PREG->u.xxx.x); RESET_VARIABLE(H+1); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -14066,7 +14066,7 @@ Yap_absmi(int inp) H[0] = XREG(PREG->u.xxy.x); RESET_VARIABLE(H+1); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -14117,7 +14117,7 @@ Yap_absmi(int inp) H[0] = XREG(PREG->u.yxx.x2); RESET_VARIABLE(H+1); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -14168,7 +14168,7 @@ Yap_absmi(int inp) H[0] = XREG(PREG->u.yyx.x); RESET_VARIABLE(H+1); RESET_VARIABLE(H+2); - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),H); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),H); } #endif /* LOW_LEVEL_TRACE */ BEGD(d0); @@ -14219,7 +14219,7 @@ Yap_absmi(int inp) Op(p_functor, e); #ifdef LOW_LEVEL_TRACER if (Yap_do_low_level_trace) - low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("functor"),3),0)),XREGS+1); + low_level_trace(enter_pred,RepPredProp(Yap_GetPredPropByFunc(FunctorFunctor,0)),XREGS+1); #endif /* LOW_LEVEL_TRACE */ restart_functor: BEGD(d0); diff --git a/C/amasm.c b/C/amasm.c index 235838bb8..801d8ef36 100644 --- a/C/amasm.c +++ b/C/amasm.c @@ -4024,7 +4024,7 @@ Yap_InitComma(void) code_p->u.Osbpp.bmap = NULL; GONEXT(Osbpp); if (PRED_GOAL_EXPANSION_ON) { - Functor fp = Yap_MkFunctor(Yap_FullLookupAtom("$generate_pred_info"),4); + Functor fp = FunctorGeneratePredInfo; code_p->opc = emit_op(_call_cpred); code_p->u.Osbpp.s = emit_count(-Signed(RealEnvSize)); code_p->u.Osbpp.p = diff --git a/C/arith1.c b/C/arith1.c index 1b343565c..571541585 100644 --- a/C/arith1.c +++ b/C/arith1.c @@ -806,7 +806,7 @@ p_unary_is(void) /* error */ ti[0] = t; ti[1] = MkIntTerm(1); - t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti); + t = Yap_MkApplTerm(FunctorSlash, 2, ti); Yap_Error(TYPE_ERROR_EVALUABLE, t, "functor %s/%d for arithmetic expression", RepAtom(name)->StrOfAE,1); diff --git a/C/arith2.c b/C/arith2.c index bc21f6ac2..bcafae4ed 100644 --- a/C/arith2.c +++ b/C/arith2.c @@ -1084,7 +1084,7 @@ p_binary_is(void) /* error */ ti[0] = t; ti[1] = MkIntTerm(1); - t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti); + t = Yap_MkApplTerm(FunctorSlash, 2, ti); Yap_Error(TYPE_ERROR_EVALUABLE, t, "functor %s/%d for arithmetic expression", RepAtom(name)->StrOfAE,2); diff --git a/C/arrays.c b/C/arrays.c index 4f3b4b46e..02601c504 100644 --- a/C/arrays.c +++ b/C/arrays.c @@ -1020,23 +1020,23 @@ p_static_array_properties(void) return(FALSE); switch(tp) { case array_of_ints: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("int")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomInt))); case array_of_dbrefs: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("dbref")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomDBref))); case array_of_doubles: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("float")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomFloat))); case array_of_ptrs: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("ptr")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomPtr))); case array_of_chars: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("char")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomChar))); case array_of_uchars: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("unsigned char")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomUnsignedChar))); case array_of_terms: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("term")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomTerm))); case array_of_nb_terms: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("nb_term")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomNbTerm))); case array_of_atoms: - return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("atom")))); + return(Yap_unify(ARG3,MkAtomTerm(AtomAtom))); } } } diff --git a/C/attvar.c b/C/attvar.c index 404ef031c..dfadc8023 100644 --- a/C/attvar.c +++ b/C/attvar.c @@ -837,7 +837,7 @@ static Int p_swi_all_atts(void) { /* receive a variable in ARG1 */ Term inp = Deref(ARG1); - Functor attf = Yap_MkFunctor(Yap_LookupAtom("att"),3); + Functor attf = Yap_MkFunctor(AtomAtt1,3); /* if this is unbound, ok */ if (IsVarTerm(inp)) { diff --git a/C/c_interface.c b/C/c_interface.c index df72ae3fc..514e5e98f 100644 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -2045,7 +2045,7 @@ YAP_Init(YAP_init_args *yap_init) RECOVER_MACHINE_REGS(); } if (yap_init->YapPrologRCFile) { - Yap_PutValue(Yap_FullLookupAtom("$consult_on_boot"), MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile))); + Yap_PutValue(AtomConsultOnBoot, MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile))); /* This must be done again after restore, as yap_flags has been overwritten .... @@ -2054,27 +2054,27 @@ YAP_Init(YAP_init_args *yap_init) } #ifdef MYDDAS_MYSQL if (yap_init->myddas) { - Yap_PutValue(Yap_FullLookupAtom("$myddas_goal"),MkIntegerTerm(yap_init->myddas)); + Yap_PutValue(AtomMyddasGoal,MkIntegerTerm(yap_init->myddas)); /* Mandatory Fields */ - Yap_PutValue(Yap_FullLookupAtom("$myddas_user"),MkAtomTerm(Yap_LookupAtom(yap_init->myddas_user))); - Yap_PutValue(Yap_FullLookupAtom("$myddas_db"),MkAtomTerm(Yap_LookupAtom(yap_init->myddas_db))); + Yap_PutValue(AtomMyddasUser,MkAtomTerm(Yap_LookupAtom(yap_init->myddas_user))); + Yap_PutValue(AtomMyddasDB,MkAtomTerm(Yap_LookupAtom(yap_init->myddas_db))); /* Non-Mandatory Fields */ if (yap_init->myddas_pass != NULL) - Yap_PutValue(Yap_FullLookupAtom("$myddas_pass"),MkAtomTerm(Yap_LookupAtom(yap_init->myddas_pass))); + Yap_PutValue(AtomMyddasPass,MkAtomTerm(Yap_LookupAtom(yap_init->myddas_pass))); if (yap_init->myddas_host != NULL) - Yap_PutValue(Yap_FullLookupAtom("$myddas_host"),MkAtomTerm(Yap_LookupAtom(yap_init->myddas_host))); + Yap_PutValue(AtomMyddasHost,MkAtomTerm(Yap_LookupAtom(yap_init->myddas_host))); } #endif if (yap_init->YapPrologTopLevelGoal) { - Yap_PutValue(Yap_FullLookupAtom("$top_level_goal"), MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologTopLevelGoal))); + Yap_PutValue(AtomTopLevelGoal, MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologTopLevelGoal))); } if (yap_init->YapPrologGoal) { - Yap_PutValue(Yap_FullLookupAtom("$init_goal"), MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologGoal))); + Yap_PutValue(AtomInitGoal, MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologGoal))); } if (yap_init->YapPrologAddPath) { - Yap_PutValue(Yap_FullLookupAtom("$extend_file_search_path"), MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologAddPath))); + Yap_PutValue(AtomExtendFileSearchPath, MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologAddPath))); } if (yap_init->QuietMode) { yap_flags[QUIET_MODE_FLAG] = TRUE; diff --git a/C/cdmgr.c b/C/cdmgr.c index a92f36f3f..fab09520a 100644 --- a/C/cdmgr.c +++ b/C/cdmgr.c @@ -588,7 +588,7 @@ PredForChoicePt(yamop *p_code) { case _or_else: if (p_code == p_code->u.Osblp.l) { /* repeat */ - Atom at = Yap_LookupAtom("repeat "); + Atom at = AtomRepeatSpace; return RepPredProp(PredPropByAtom(at, PROLOG_MODULE)); } else { return p_code->u.Osblp.p0; @@ -1949,7 +1949,7 @@ addcl_permission_error(AtomEntry *ap, Int Arity, int in_use) ti[0] = MkAtomTerm(AbsAtom(ap)); ti[1] = MkIntegerTerm(Arity); - t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti); + t = Yap_MkApplTerm(FunctorSlash, 2, ti); Yap_ErrorMessage = Yap_ErrorSay; Yap_Error_Term = t; Yap_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE; @@ -2544,7 +2544,7 @@ static Atom YapConsultingFile (void) { if (consult_level == 0) { - return(Yap_LookupAtom("user")); + return(AtomUser); } else { return(Yap_LookupAtom(ConsultBase[2].filename)); } @@ -2694,7 +2694,7 @@ p_setspy(void) CELL fg; Term t, mod; - at = Yap_FullLookupAtom("$spy"); + at = AtomSpy; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); SpyCode = pred; t = Deref(ARG1); @@ -3487,7 +3487,7 @@ clause_was_found(PredEntry *pp, Atom *pat, UInt *parity) { if (pp->ModuleOfPred == IDB_MODULE) { if (pp->PredFlags & NumberDBPredFlag) { *parity = 0; - *pat = Yap_LookupAtom("integer"); + *pat = AtomInteger; } else if (pp->PredFlags & AtomDBPredFlag) { *parity = 0; *pat = (Atom)pp->FunctorOfPred; @@ -4539,8 +4539,8 @@ p_is_profiled(void) if (IsVarTerm(t)) { Term ta; - if (PROFILING) ta = MkAtomTerm(Yap_LookupAtom("on")); - else ta = MkAtomTerm(Yap_LookupAtom("off")); + if (PROFILING) ta = MkAtomTerm(AtomOn); + else ta = MkAtomTerm(AtomOff); BIND((CELL *)t,ta,bind_is_profiled); #ifdef COROUTINING DO_TRAIL(CellPtr(t), ta); @@ -4642,8 +4642,8 @@ p_is_call_counted(void) if (IsVarTerm(t)) { Term ta; - if (CALL_COUNTING) ta = MkAtomTerm(Yap_LookupAtom("on")); - else ta = MkAtomTerm(Yap_LookupAtom("off")); + if (CALL_COUNTING) ta = MkAtomTerm(AtomOn); + else ta = MkAtomTerm(AtomOff); BIND((CELL *)t,ta,bind_is_call_counted); #ifdef COROUTINING DO_TRAIL(CellPtr(t), ta); @@ -6184,7 +6184,7 @@ p_choicepoint_info(void) break; case _Nstop: { - Atom at = Yap_FullLookupAtom("$live"); + Atom at = AtomLive; t = MkAtomTerm(at); pe = RepPredProp(PredPropByAtom(at, CurrentModule)); } diff --git a/C/computils.c b/C/computils.c index 61dc28579..108c46a4a 100644 --- a/C/computils.c +++ b/C/computils.c @@ -349,11 +349,11 @@ write_functor(Functor f) { if (IsExtensionFunctor(f)) { if (f == FunctorDBRef) { - Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("DBRef"))); + Yap_DebugPlWrite(MkAtomTerm(AtomDBREF)); } else if (f == FunctorLongInt) { - Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("LongInt"))); + Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT)); } else if (f == FunctorDouble) { - Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("Double"))); + Yap_DebugPlWrite(MkAtomTerm(AtomDOUBLE)); } } else { Yap_DebugPlWrite(MkAtomTerm(NameOfFunctor (f))); @@ -499,11 +499,11 @@ ShowOp (char *f, struct PSEUDO *cpc) Functor fun = (Functor)*cptr++; if (IsExtensionFunctor(fun)) { if (fun == FunctorDBRef) { - Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("DBRef"))); + Yap_DebugPlWrite(MkAtomTerm(AtomDBREF)); } else if (fun == FunctorLongInt) { - Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("LongInt"))); + Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT)); } else if (fun == FunctorDouble) { - Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("Double"))); + Yap_DebugPlWrite(MkAtomTerm(AtomDOUBLE)); } } else { Yap_DebugPlWrite (MkAtomTerm(NameOfFunctor(fun))); diff --git a/C/corout.c b/C/corout.c index 6f02ee060..fd8d200d7 100644 --- a/C/corout.c +++ b/C/corout.c @@ -605,7 +605,7 @@ Yap_InitCoroutPreds(void) Atom at; PredEntry *pred; - at = Yap_FullLookupAtom("$wake_up_goal"); + at = AtomWakeUpGoal; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 2),0)); WakeUpCode = pred; #endif diff --git a/C/dbase.c b/C/dbase.c index 53ca78fc8..611b778e5 100644 --- a/C/dbase.c +++ b/C/dbase.c @@ -2639,7 +2639,7 @@ new_lu_int_key(Int key) return NULL; } } - ae = Yap_FullLookupAtom("$integer"); + ae = AtomDInteger; WRITE_LOCK(ae->ARWLock); p0 = Yap_NewPredPropByAtom(ae,IDB_MODULE); p = RepPredProp(p0); @@ -5459,7 +5459,7 @@ Yap_InitBackDB(void) Yap_InitCPredBack("$recorded_with_key", 3, 3, in_rded_with_key, co_rded, SyncPredFlag|HiddenPredFlag); RETRY_C_RECORDED_K_CODE = NEXTOP(PredRecordedWithKey->cs.p_code.FirstClause,OtapFs); Yap_InitCPredBack("$recordedp", 3, 3, in_rdedp, co_rdedp, SyncPredFlag|HiddenPredFlag); - RETRY_C_RECORDEDP_CODE = NEXTOP(RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("$recordedp"), 3),0))->cs.p_code.FirstClause,OtapFs); + RETRY_C_RECORDEDP_CODE = NEXTOP(RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomRecordedP, 3),0))->cs.p_code.FirstClause,OtapFs); Yap_InitCPredBack("$current_immediate_key", 2, 4, init_current_key, cont_current_key, SyncPredFlag|HiddenPredFlag); } diff --git a/C/errors.c b/C/errors.c index 2869aedd2..948e1efc6 100644 --- a/C/errors.c +++ b/C/errors.c @@ -512,20 +512,20 @@ Yap_Error(yap_error_number type, Term where, char *format,...) case CALL_COUNTER_UNDERFLOW: /* Do a long jump */ PredEntriesCounter--; - Yap_JumpToEnv(MkAtomTerm(Yap_LookupAtom("call_counter"))); + Yap_JumpToEnv(MkAtomTerm(AtomCallCounter)); P = (yamop *)FAILCODE; Yap_PrologMode &= ~InErrorMode; return(P); case PRED_ENTRY_COUNTER_UNDERFLOW: /* Do a long jump */ - Yap_JumpToEnv(MkAtomTerm(Yap_LookupAtom("call_and_retry_counter"))); + Yap_JumpToEnv(MkAtomTerm(AtomCallAndRetryCounter)); P = (yamop *)FAILCODE; Yap_PrologMode &= ~InErrorMode; return(P); case RETRY_COUNTER_UNDERFLOW: /* Do a long jump */ PredEntriesCounter--; - Yap_JumpToEnv(MkAtomTerm(Yap_LookupAtom("retry_counter"))); + Yap_JumpToEnv(MkAtomTerm(AtomRetryCounter)); P = (yamop *)FAILCODE; Yap_PrologMode &= ~InErrorMode; return(P); @@ -536,10 +536,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) i = strlen(tmpbuf); ti[0] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("consistency_error"),1), 1, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomConsistencyError, 1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -549,12 +549,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("array_overflow")); + ti[0] = MkAtomTerm(AtomArrayOverflow); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -564,12 +564,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("array_type")); + ti[0] = MkAtomTerm(AtomArrayType); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -579,12 +579,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("io_mode")); + ti[0] = MkAtomTerm(AtomIOMode); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -594,12 +594,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("mutable")); + ti[0] = MkAtomTerm(AtomMutable); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -609,12 +609,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("non_empty_list")); + ti[0] = MkAtomTerm(AtomNonEmptyList); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -624,12 +624,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("not_less_than_zero")); + ti[0] = MkAtomTerm(AtomNotLessThanZero); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -639,12 +639,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("not_newline")); + ti[0] = MkAtomTerm(AtomNotNewline); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -654,12 +654,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("not_zero")); + ti[0] = MkAtomTerm(AtomNotZero); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -669,12 +669,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("out_of_range")); + ti[0] = MkAtomTerm(AtomOutOfRange); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -684,12 +684,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("operator_priority")); + ti[0] = MkAtomTerm(AtomOperatorPriority); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -699,12 +699,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("operator_specifier")); + ti[0] = MkAtomTerm(AtomOperatorSpecifier); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -714,12 +714,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("radix")); + ti[0] = MkAtomTerm(AtomRadix); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -729,12 +729,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("shift_count_overflow")); + ti[0] = MkAtomTerm(AtomShiftCountOverflow); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -744,12 +744,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("source_sink")); + ti[0] = MkAtomTerm(AtomSourceSink); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -759,12 +759,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("stream")); + ti[0] = MkAtomTerm(AtomStream); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -774,12 +774,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("stream_or_alias")); + ti[0] = MkAtomTerm(AtomStreamOrAlias); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -789,12 +789,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("stream_position")); + ti[0] = MkAtomTerm(AtomStreamPosition); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -804,12 +804,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("syntax_error_handler")); + ti[0] = MkAtomTerm(AtomSyntaxErrorHandler); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -819,12 +819,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("time_out_spec")); + ti[0] = MkAtomTerm(AtomTimeOutSpec); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("domain_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDomainError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -834,12 +834,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("source_sink")); + ti[0] = MkAtomTerm(AtomSourceSink); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("existence_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomExistenceError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -849,12 +849,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("array")); + ti[0] = MkAtomTerm(AtomArray); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("existence_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomExistenceError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -864,12 +864,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("key")); + ti[0] = MkAtomTerm(AtomKey); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("existence_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomExistenceError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -879,12 +879,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("stream")); + ti[0] = MkAtomTerm(AtomStream); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("existence_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomExistenceError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -894,11 +894,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("float_overflow")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("evaluation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomFloatOverflow); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomEvaluationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -908,11 +908,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("int_overflow")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("evaluation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomIntOverflow); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomEvaluationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -922,11 +922,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("undefined")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("evaluation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomUndefined); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomEvaluationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -936,11 +936,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("float_underflow")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("evaluation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomFloatUnderflow); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomEvaluationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -950,11 +950,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("underflow")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("evaluation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomUnderflow); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomEvaluationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -964,11 +964,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("zero_divisor")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("evaluation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomZeroDivisor); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomEvaluationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -977,10 +977,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) int i; i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("instantiation_error")); + nt[0] = MkAtomTerm(AtomInstantiationError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -989,10 +989,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) int i; i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("operating_system_error")); + nt[0] = MkAtomTerm(AtomOperatingSystemError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1002,10 +1002,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("out_of_heap_error")); + nt[0] = MkAtomTerm(AtomOutOfHeapError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1015,10 +1015,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("out_of_stack_error")); + nt[0] = MkAtomTerm(AtomOutOfStackError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1028,10 +1028,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("out_of_attvars_error")); + nt[0] = MkAtomTerm(AtomOutOfAttvarsError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1041,10 +1041,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("out_of_auxspace_error")); + nt[0] = MkAtomTerm(AtomOutOfAuxspaceError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1054,10 +1054,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) dump_stack(); i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("out_of_trail_error")); + nt[0] = MkAtomTerm(AtomOutOfTrailError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1067,13 +1067,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("access")); - ti[1] = MkAtomTerm(Yap_LookupAtom("private_procedure")); + ti[0] = MkAtomTerm(AtomAccess); + ti[1] = MkAtomTerm(AtomPrivateProcedure); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1083,13 +1083,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("create")); - ti[1] = MkAtomTerm(Yap_LookupAtom("array")); + ti[0] = MkAtomTerm(AtomCreate); + ti[1] = MkAtomTerm(AtomArray); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1099,13 +1099,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("create")); - ti[1] = MkAtomTerm(Yap_LookupAtom("operator")); + ti[0] = MkAtomTerm(AtomCreate); + ti[1] = MkAtomTerm(AtomOperator); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1115,13 +1115,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("input")); - ti[1] = MkAtomTerm(Yap_LookupAtom("binary_stream")); + ti[0] = MkAtomTerm(AtomInput); + ti[1] = MkAtomTerm(AtomBinaryStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1131,13 +1131,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("input")); - ti[1] = MkAtomTerm(Yap_LookupAtom("past_end_of_stream")); + ti[0] = MkAtomTerm(AtomInput); + ti[1] = MkAtomTerm(AtomPastEndOfStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1147,13 +1147,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("input")); - ti[1] = MkAtomTerm(Yap_LookupAtom("stream")); + ti[0] = MkAtomTerm(AtomInput); + ti[1] = MkAtomTerm(AtomStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1163,13 +1163,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("input")); - ti[1] = MkAtomTerm(Yap_LookupAtom("text_stream")); + ti[0] = MkAtomTerm(AtomInput); + ti[1] = MkAtomTerm(AtomTextStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1179,13 +1179,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("modify")); - ti[1] = MkAtomTerm(Yap_LookupAtom("static_procedure")); + ti[0] = MkAtomTerm(AtomModify); + ti[1] = MkAtomTerm(AtomStaticProcedure); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1195,13 +1195,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("new")); - ti[1] = MkAtomTerm(Yap_LookupAtom("alias")); + ti[0] = MkAtomTerm(AtomNew); + ti[1] = MkAtomTerm(AtomAlias); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1211,13 +1211,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("open")); - ti[1] = MkAtomTerm(Yap_LookupAtom("source_sink")); + ti[0] = MkAtomTerm(AtomOpen); + ti[1] = MkAtomTerm(AtomSourceSink); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1227,13 +1227,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("output")); - ti[1] = MkAtomTerm(Yap_LookupAtom("binary_stream")); + ti[0] = MkAtomTerm(AtomOutput); + ti[1] = MkAtomTerm(AtomBinaryStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1243,13 +1243,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("output")); - ti[1] = MkAtomTerm(Yap_LookupAtom("stream")); + ti[0] = MkAtomTerm(AtomOutput); + ti[1] = MkAtomTerm(AtomStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1259,13 +1259,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("output")); - ti[1] = MkAtomTerm(Yap_LookupAtom("text_stream")); + ti[0] = MkAtomTerm(AtomOutput); + ti[1] = MkAtomTerm(AtomTextStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1275,13 +1275,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("reposition")); - ti[1] = MkAtomTerm(Yap_LookupAtom("stream")); + ti[0] = MkAtomTerm(AtomReposition); + ti[1] = MkAtomTerm(AtomStream); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1291,13 +1291,13 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[3]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("resize")); - ti[1] = MkAtomTerm(Yap_LookupAtom("array")); + ti[0] = MkAtomTerm(AtomResize); + ti[1] = MkAtomTerm(AtomArray); ti[2] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("permission_error"),3), 3, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomPermissionError,3), 3, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1307,11 +1307,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("character")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("representation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomCharacter); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomRepresentationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1321,11 +1321,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("character_code")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("representation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomCharacterCode); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomRepresentationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1335,11 +1335,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("max_arity")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("representation_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomMaxArity); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomRepresentationError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1349,11 +1349,11 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[1]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("threads")); - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("resource_error"),1), 1, ti); + ti[0] = MkAtomTerm(AtomThreads); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomResourceError,1), 1, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1365,7 +1365,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...) nt[0] = where; tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1374,10 +1374,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) int i; i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("system_error")); + nt[0] = MkAtomTerm(AtomSystemError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1386,10 +1386,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) int i; i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("internal_compiler_error")); + nt[0] = MkAtomTerm(AtomInternalCompilerError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1399,12 +1399,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("array")); + ti[0] = MkAtomTerm(AtomArray); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1414,12 +1414,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("atom")); + ti[0] = MkAtomTerm(AtomAtom); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1429,12 +1429,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("atomic")); + ti[0] = MkAtomTerm(AtomAtomic); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1444,12 +1444,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("byte")); + ti[0] = MkAtomTerm(AtomByte); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1459,12 +1459,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("callable")); + ti[0] = MkAtomTerm(AtomCallable); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1474,12 +1474,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("char")); + ti[0] = MkAtomTerm(AtomChar); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1489,12 +1489,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("character")); + ti[0] = MkAtomTerm(AtomCharacter); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1504,12 +1504,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("compound")); + ti[0] = MkAtomTerm(AtomCompound); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1519,12 +1519,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("db_reference")); + ti[0] = MkAtomTerm(AtomDBReference); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1534,12 +1534,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("db_term")); + ti[0] = MkAtomTerm(AtomDBTerm); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1549,12 +1549,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("evaluable")); + ti[0] = MkAtomTerm(AtomEvaluable); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1564,12 +1564,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("float")); + ti[0] = MkAtomTerm(AtomFloat); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1579,12 +1579,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("integer")); + ti[0] = MkAtomTerm(AtomInteger); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1594,12 +1594,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("key")); + ti[0] = MkAtomTerm(AtomKey); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1609,12 +1609,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("list")); + ti[0] = MkAtomTerm(AtomList); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1624,12 +1624,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("number")); + ti[0] = MkAtomTerm(AtomNumber); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1639,12 +1639,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("predicate_indicator")); + ti[0] = MkAtomTerm(AtomPredicateIndicator); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1654,12 +1654,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("pointer")); + ti[0] = MkAtomTerm(AtomPointer); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1669,12 +1669,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("unsigned_byte")); + ti[0] = MkAtomTerm(AtomUnsignedByte); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1684,12 +1684,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("unsigned_char")); + ti[0] = MkAtomTerm(AtomUnsignedChar); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1699,12 +1699,12 @@ Yap_Error(yap_error_number type, Term where, char *format,...) Term ti[2]; i = strlen(tmpbuf); - ti[0] = MkAtomTerm(Yap_LookupAtom("variable")); + ti[0] = MkAtomTerm(AtomVariable); ti[1] = where; - nt[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("type_error"),2), 2, ti); + nt[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomTypeError,2), 2, ti); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } break; @@ -1713,10 +1713,10 @@ Yap_Error(yap_error_number type, Term where, char *format,...) int i; i = strlen(tmpbuf); - nt[0] = MkAtomTerm(Yap_LookupAtom("system_error")); + nt[0] = MkAtomTerm(AtomSystemError); tp = tmpbuf+i; psize -= i; - fun = Yap_MkFunctor(Yap_LookupAtom("error"),2); + fun = FunctorError; serious = TRUE; } } @@ -1742,7 +1742,7 @@ Yap_Error(yap_error_number type, Term where, char *format,...) ActiveSignals = 0; CreepFlag = CalculateStackGap(); if (type == PURE_ABORT) - Yap_JumpToEnv(MkAtomTerm(Yap_LookupAtom("$abort"))); + Yap_JumpToEnv(MkAtomTerm(AtomDAbort)); else Yap_JumpToEnv(Yap_MkApplTerm(fun, 2, nt)); P = (yamop *)FAILCODE; diff --git a/C/eval.c b/C/eval.c index ef17826da..ef789634a 100644 --- a/C/eval.c +++ b/C/eval.c @@ -47,7 +47,7 @@ Eval(Term t) ti[0] = t; ti[1] = MkIntegerTerm(0); /* error */ - terror = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti); + terror = Yap_MkApplTerm(Yap_MkFunctor(AtomSlash,2), 2, ti); Yap_Error(TYPE_ERROR_EVALUABLE, terror, "atom %s for arithmetic expression", RepAtom(name)->StrOfAE); @@ -79,7 +79,7 @@ Eval(Term t) /* error */ ti[0] = t; ti[1] = MkIntegerTerm(n); - t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti); + t = Yap_MkApplTerm(FunctorSlash, 2, ti); Yap_Error(TYPE_ERROR_EVALUABLE, t, "functor %s/%d for arithmetic expression", RepAtom(name)->StrOfAE,n); diff --git a/C/globals.c b/C/globals.c index 4f639e00a..ce5c7abab 100644 --- a/C/globals.c +++ b/C/globals.c @@ -1564,7 +1564,7 @@ p_nb_queue_close(void) out = Yap_unify(ARG3, qp[QUEUE_TAIL]) && Yap_unify(ARG2, qp[QUEUE_HEAD]); - qp[-1] = (CELL)Yap_MkFunctor(Yap_LookupAtom("heap"),1); + qp[-1] = (CELL)Yap_MkFunctor(AtomHeap,1); qp[0] = MkIntegerTerm(0); return out; } @@ -1757,7 +1757,7 @@ p_nb_heap(void) hsize = IntegerOfTerm(tsize); } - while ((heap = MkZeroApplTerm(Yap_MkFunctor(Yap_LookupAtom("heap"),2*hsize+HEAP_START+1),2*hsize+HEAP_START+1)) == TermNil) { + while ((heap = MkZeroApplTerm(Yap_MkFunctor(AtomHeap,2*hsize+HEAP_START+1),2*hsize+HEAP_START+1)) == TermNil) { if (!Yap_gcl((2*hsize+HEAP_START+1)*sizeof(CELL), 2, ENV, P)) { Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage); return FALSE; @@ -1809,7 +1809,7 @@ p_nb_heap_close(void) if (qp[HEAP_DELAY_ARENA] != MkIntTerm(0)) RecoverDelayArena(qp[HEAP_DELAY_ARENA]); #endif - qp[-1] = (CELL)Yap_MkFunctor(Yap_LookupAtom("heap"),1); + qp[-1] = (CELL)Yap_MkFunctor(AtomHeap,1); qp[0] = MkIntegerTerm(0); return TRUE; } @@ -1901,7 +1901,7 @@ p_nb_heap_add_to_heap(void) hmsize += extra_size; if (!qd) return FALSE; - qd[-1] = (CELL)Yap_MkFunctor(Yap_LookupAtom("heap"),2*hmsize+HEAP_START)+1; + qd[-1] = (CELL)Yap_MkFunctor(AtomHeap,2*hmsize+HEAP_START)+1; top = qd+(HEAP_START+2*(hmsize-extra_size)); while (extra_size) { RESET_VARIABLE(top); @@ -2055,7 +2055,7 @@ p_nb_beam(void) } hsize = IntegerOfTerm(tsize); } - while ((beam = MkZeroApplTerm(Yap_MkFunctor(Yap_LookupAtom("heap"),5*hsize+HEAP_START+1),5*hsize+HEAP_START+1)) == TermNil) { + while ((beam = MkZeroApplTerm(Yap_MkFunctor(AtomHeap,5*hsize+HEAP_START+1),5*hsize+HEAP_START+1)) == TermNil) { if (!Yap_gcl((5*hsize+HEAP_START+1)*sizeof(CELL), 2, ENV, P)) { Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage); return FALSE; diff --git a/C/gprof.c b/C/gprof.c index f014c8add..489a976cd 100644 --- a/C/gprof.c +++ b/C/gprof.c @@ -1214,9 +1214,9 @@ static Int profinit1(void) if (IsVarTerm(t)) { if (Yap_OffLineProfiler) - Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("offline"))); + Yap_unify(ARG1,MkAtomTerm(AtomOffline)); else - Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("online"))); + Yap_unify(ARG1,MkAtomTerm(AtomOnline)); } else if (IsAtomTerm(t)) { char *name = RepAtom(AtomOfTerm(t))->StrOfAE; if (!strcmp(name,"offline")) @@ -1238,9 +1238,9 @@ static Int profinit1(void) static Int proftype(void) { if (Yap_OffLineProfiler) - return Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("offline"))); + return Yap_unify(ARG1,MkAtomTerm(AtomOffline)); else - return Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("online"))); + return Yap_unify(ARG1,MkAtomTerm(AtomOnline)); } static Int start_profilers(int msec) diff --git a/C/init.c b/C/init.c index a168b50c9..ef2256710 100644 --- a/C/init.c +++ b/C/init.c @@ -475,7 +475,7 @@ InitDebug(void) } #endif /* Set at full leash */ - At = Yap_FullLookupAtom("$leash"); + At = AtomLeash; Yap_PutValue(At, MkIntTerm(15)); } @@ -963,37 +963,19 @@ InitFlags(void) static void InitCodes(void) { - Atom - AtomAltNot, -#ifdef COROUTINING - AtomArrayAccess, -#endif - AtomArrow, - AtomBraces, - AtomEq, - AtomGVar, - AtomNot, - AtomQuery, - AtomSemic, - AtomCreep, - AtomStream, - AtomStreamPos, - AtomVar; - Functor - FunctorThrow; - - Yap_heap_regs->term_prolog = MkAtomTerm(Yap_LookupAtom("prolog")); - Yap_heap_regs->user_module = MkAtomTerm(Yap_LookupAtom("user")); - Yap_heap_regs->idb_module = MkAtomTerm(Yap_LookupAtom("idb")); - Yap_heap_regs->attributes_module = MkAtomTerm(Yap_LookupAtom("attributes")); - Yap_heap_regs->charsio_module = MkAtomTerm(Yap_LookupAtom("charsio")); - Yap_heap_regs->terms_module = MkAtomTerm(Yap_LookupAtom("terms")); - Yap_heap_regs->system_module = MkAtomTerm(Yap_LookupAtom("system")); - Yap_heap_regs->readutil_module = MkAtomTerm(Yap_LookupAtom("readutil")); - Yap_heap_regs->hacks_module = MkAtomTerm(Yap_LookupAtom("yap_hacks")); - Yap_heap_regs->globals_module = MkAtomTerm(Yap_LookupAtom("nb")); - Yap_heap_regs->arg_module = MkAtomTerm(Yap_LookupAtom("arg")); - Yap_heap_regs->swi_module = MkAtomTerm(Yap_LookupAtom("swi")); +#include "iatoms.h" + Yap_heap_regs->term_prolog = MkAtomTerm(AtomProlog); + Yap_heap_regs->user_module = MkAtomTerm(AtomUser); + Yap_heap_regs->idb_module = MkAtomTerm(AtomIDB); + Yap_heap_regs->attributes_module = MkAtomTerm(AtomAttributes); + Yap_heap_regs->charsio_module = MkAtomTerm(AtomCharsio); + Yap_heap_regs->terms_module = MkAtomTerm(AtomTerms); + Yap_heap_regs->system_module = MkAtomTerm(AtomSystem); + Yap_heap_regs->readutil_module = MkAtomTerm(AtomReadutil); + Yap_heap_regs->hacks_module = MkAtomTerm(AtomYapHacks); + Yap_heap_regs->globals_module = MkAtomTerm(AtomNb); + Yap_heap_regs->arg_module = MkAtomTerm(AtomArg); + Yap_heap_regs->swi_module = MkAtomTerm(AtomSwi); Yap_InitModules(); #ifdef BEAM Yap_heap_regs->beam_retry_code.opc = Yap_opcode(_retry_eam); @@ -1161,13 +1143,13 @@ InitCodes(void) Atom at; PredEntry *pred; - at = Yap_FullLookupAtom("$creep"); + at = AtomCreep; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),PROLOG_MODULE)); Yap_heap_regs->creep_code = pred; - at = Yap_FullLookupAtom("$undefp"); + at = AtomUndefp; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),PROLOG_MODULE)); Yap_heap_regs->undef_code = pred; - at = Yap_FullLookupAtom("$spy"); + at = AtomSpy; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); Yap_heap_regs->spy_code = pred; Yap_heap_regs->env_for_trustfail_code.p = @@ -1212,156 +1194,10 @@ InitCodes(void) don't initialise this here, this is initialised by Yap_InitModules!!!! Yap_heap_regs->no_of_modules = 1; */ - Yap_heap_regs->atom_abol = Yap_FullLookupAtom("$abol"); - AtomAltNot = Yap_LookupAtom("not"); - Yap_heap_regs->atom_append = Yap_LookupAtom ("append"); - Yap_heap_regs->atom_array = Yap_FullLookupAtom("$array"); -#ifdef COROUTINING - AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); -#endif - AtomArrow = Yap_LookupAtom("->"); - Yap_heap_regs->atom_assert = Yap_LookupAtom(":-"); - Yap_heap_regs->atom_alarm = Yap_FullLookupAtom("$alarm"); -#if HAVE_SIGACTION - Yap_heap_regs->atom_sig_pending = Yap_FullLookupAtom("$sig_pending"); -#endif - AtomBraces = Yap_LookupAtom("{}"); -#ifdef COROUTINING - Yap_heap_regs->atom_att = Yap_FullLookupAtom("$att"); -#endif - Yap_heap_regs->atom_b = Yap_FullLookupAtom("$last_choice_pt"); - Yap_heap_regs->atom_break = Yap_FullLookupAtom("$break"); - Yap_heap_regs->atom_call = Yap_LookupAtom("call"); - Yap_heap_regs->atom_catch = Yap_FullLookupAtom("$catch"); - Yap_heap_regs->atom_comma = Yap_LookupAtom(","); - Yap_heap_regs->atom_cpu_time = Yap_LookupAtom("cputime"); - Yap_heap_regs->atom_csult = Yap_FullLookupAtom("$csult"); - Yap_heap_regs->atom_cut = Yap_LookupAtom("!"); - Yap_heap_regs->atom_cut_by = Yap_FullLookupAtom("$cut_by"); #ifdef EUROTRA -#ifdef SFUNC - Yap_heap_regs->atom_dollar_undef = MkAtomTerm(Yap_FullLookupAtom("$undef")); + Yap_heap_regs->term_dollar_u = MkAtomTerm(AtomDollarU); #endif -#endif - Yap_heap_regs->atom_dbref = Yap_FullLookupAtom ("$dbref"); - Yap_heap_regs->atom_e = Yap_LookupAtom("e"); - Yap_heap_regs->atom_e_q = Yap_LookupAtom("="); - Yap_heap_regs->atom_eof = Yap_LookupAtom ("end_of_file"); - AtomEq = Yap_LookupAtom("="); -#ifdef EUROTRA - Yap_heap_regs->atom_f_b = Yap_LookupAtom("fb"); -#endif - Yap_heap_regs->atom_fail = Yap_LookupAtom("fail"); - Yap_heap_regs->atom_false = Yap_LookupAtom("false"); - Yap_heap_regs->atom_fast = Yap_FullLookupAtom("$fast"); - Yap_heap_regs->atom_g_t = Yap_LookupAtom(">"); - Yap_heap_regs->atom_gc = Yap_FullLookupAtom("$gc"); - Yap_heap_regs->atom_gc_margin = Yap_FullLookupAtom("$gc_margin"); - Yap_heap_regs->atom_gc_trace = Yap_FullLookupAtom("$gc_trace"); - Yap_heap_regs->atom_gc_verbose = Yap_FullLookupAtom("$gc_verbose"); - Yap_heap_regs->atom_gc_very_verbose = Yap_FullLookupAtom("$gc_very_verbose"); - AtomGVar = Yap_LookupAtom("var"); - Yap_heap_regs->atom_global = Yap_LookupAtom("global_sp"); - Yap_heap_regs->atom_heap_used = Yap_LookupAtom("heapused"); - Yap_heap_regs->atom_inf = Yap_LookupAtom("inf"); - Yap_heap_regs->atom_l_t = Yap_LookupAtom("<"); - Yap_heap_regs->atom_local = Yap_LookupAtom("local_sp"); - Yap_heap_regs->atom_meta_call = Yap_FullLookupAtom("$call"); - Yap_heap_regs->atom_minus = Yap_LookupAtom("-"); - Yap_heap_regs->atom_multi_file = Yap_FullLookupAtom("$mf"); - Yap_heap_regs->atom_nan = Yap_LookupAtom("nan"); - AtomNot = Yap_LookupAtom("\\+"); - Yap_heap_regs->atom_otherwise = Yap_LookupAtom("otherwise"); - Yap_heap_regs->atom_pi = Yap_LookupAtom("pi"); - Yap_heap_regs->atom_plus = Yap_LookupAtom("+"); - Yap_heap_regs->atom_portray = Yap_FullLookupAtom("$portray"); - Yap_heap_regs->atom_profile = Yap_FullLookupAtom("$profile"); - AtomQuery = Yap_LookupAtom("?-"); - Yap_heap_regs->atom_random = Yap_LookupAtom("random"); - Yap_heap_regs->atom_read = Yap_LookupAtom("read"); - Yap_heap_regs->atom_repeat = Yap_LookupAtom("repeat"); - Yap_heap_regs->atom_restore_regs = Yap_FullLookupAtom("$restore_regs"); - AtomSemic = Yap_LookupAtom(";"); - Yap_heap_regs->atom_stack_free = Yap_LookupAtom("stackfree"); - AtomStream = Yap_FullLookupAtom("$stream"); - AtomStreamPos = Yap_FullLookupAtom("$stream_position"); - Yap_heap_regs->atom_true = Yap_LookupAtom("true"); - AtomCreep = Yap_LookupAtom("$creep"); - Yap_heap_regs->atom_user = Yap_LookupAtom ("user"); - Yap_heap_regs->atom_usr_err = Yap_LookupAtom ("user_error"); - Yap_heap_regs->atom_usr_in = Yap_LookupAtom ("user_input"); - Yap_heap_regs->atom_usr_out = Yap_LookupAtom ("user_output"); - AtomVar = Yap_FullLookupAtom("$VAR"); - Yap_heap_regs->atom_version_number = Yap_FullLookupAtom("$version_name"); - Yap_heap_regs->atom_write = Yap_LookupAtom ("write"); - Yap_heap_regs->float_format = Yap_LookupAtom ("\%.15g"); -#ifdef USE_SOCKET - Yap_heap_regs->functor_af_inet = Yap_MkFunctor(Yap_LookupAtom("AF_INET"),2); - Yap_heap_regs->functor_af_local = Yap_MkFunctor(Yap_LookupAtom("AF_LOCAL"),1); - Yap_heap_regs->functor_af_unix = Yap_MkFunctor(Yap_LookupAtom("AF_UNIX"),1); -#endif - Yap_heap_regs->functor_alt_not = Yap_MkFunctor(AtomAltNot, 1); -#ifdef COROUTINING - Yap_heap_regs->functor_array_entry = Yap_MkFunctor(AtomArrayAccess, 3); -#endif - Yap_heap_regs->functor_arrow = Yap_MkFunctor(AtomArrow, 2); - Yap_heap_regs->functor_assert = Yap_MkFunctor(AtomAssert, 2); - Yap_heap_regs->functor_at_found_one = Yap_MkFunctor(AtomFoundVar, 2); - Yap_heap_regs->functor_atom = Yap_MkFunctor(Yap_LookupAtom("atom"), 1); -#ifdef COROUTINING - Yap_heap_regs->functor_att_goal = Yap_MkFunctor(Yap_FullLookupAtom("$att_do"),2); -#endif - Yap_heap_regs->functor_braces = Yap_MkFunctor(AtomBraces, 1); - Yap_heap_regs->functor_call = Yap_MkFunctor(AtomCall, 1); - Yap_heap_regs->functor_cut_by = Yap_MkFunctor(AtomCutBy, 1); - Yap_heap_regs->functor_clist = Yap_MkFunctor(Yap_FullLookupAtom("$when"), 4); - Yap_heap_regs->functor_comma = Yap_MkFunctor(AtomComma, 2); - Yap_heap_regs->functor_csult = Yap_MkFunctor(AtomCsult, 1); - Yap_heap_regs->functor_dot = Yap_MkFunctor(AtomDot, 2); - Yap_heap_regs->functor_eq = Yap_MkFunctor(AtomEq, 2); - Yap_heap_regs->functor_execute_in_mod = Yap_MkFunctor(Yap_FullLookupAtom("$execute_in_mod"), 2); - Yap_heap_regs->functor_execute2_in_mod = Yap_MkFunctor(Yap_FullLookupAtom("$execute_wo_mod"), 2); - Yap_heap_regs->functor_execute_within = Yap_MkFunctor(Yap_FullLookupAtom("$execute_within"), 1); - Yap_heap_regs->functor_g_atom = Yap_MkFunctor(Yap_LookupAtom("atom"), 1); - Yap_heap_regs->functor_g_atomic = Yap_MkFunctor(Yap_LookupAtom("atomic"), 1); - Yap_heap_regs->functor_g_compound = Yap_MkFunctor(Yap_LookupAtom("compound"), 1); - Yap_heap_regs->functor_g_float = Yap_MkFunctor(Yap_LookupAtom("float"), 1); - Yap_heap_regs->functor_g_format_at = Yap_MkFunctor(Yap_LookupAtom("$format@"), 2); - Yap_heap_regs->functor_g_integer = Yap_MkFunctor(Yap_LookupAtom("integer"), 1); - Yap_heap_regs->functor_g_number = Yap_MkFunctor(Yap_LookupAtom("number"), 1); - Yap_heap_regs->functor_g_primitive = Yap_MkFunctor(Yap_LookupAtom("primitive"), 1); - Yap_heap_regs->functor_g_var = Yap_MkFunctor(AtomGVar, 1); - Yap_heap_regs->functor_last_execute_within = Yap_MkFunctor(Yap_FullLookupAtom("$last_execute_within"), 1); - Yap_heap_regs->functor_list = Yap_MkFunctor(Yap_LookupAtom("."), 2); - Yap_heap_regs->functor_mega_clause = Yap_MkFunctor (Yap_FullLookupAtom("$mega_clause"), 2); - Yap_heap_regs->functor_module = Yap_MkFunctor(Yap_LookupAtom(":"), 2); - Yap_heap_regs->functor_multi_file_clause = Yap_MkFunctor(Yap_FullLookupAtom("$mf_clause"), 5); -#ifdef MULTI_ASSIGNMENT_VARIABLES - Yap_heap_regs->functor_mutable = Yap_MkFunctor(Yap_FullLookupAtom("$mutable_variable"), - sizeof(timed_var)/sizeof(CELL)); -#endif - Yap_heap_regs->functor_nb_queue = Yap_MkFunctor(Yap_LookupAtom("queue"), 5); - Yap_heap_regs->functor_not = Yap_MkFunctor(AtomNot, 1); - Yap_heap_regs->functor_or = Yap_MkFunctor(AtomSemic, 2); - Yap_heap_regs->functor_portray = Yap_MkFunctor(AtomPortray, 1); - Yap_heap_regs->functor_query = Yap_MkFunctor(AtomQuery, 1); - Yap_heap_regs->functor_creep = Yap_MkFunctor(AtomCreep, 1); - Yap_heap_regs->functor_static_clause = Yap_MkFunctor (Yap_FullLookupAtom("$static_clause"), 1); - Yap_heap_regs->functor_stream = Yap_MkFunctor (AtomStream, 1); - Yap_heap_regs->functor_stream_pos = Yap_MkFunctor (AtomStreamPos, 5); - Yap_heap_regs->functor_stream_eOS = Yap_MkFunctor (Yap_LookupAtom("end_of_stream"), 1); - Yap_heap_regs->functor_thread_run = Yap_MkFunctor (Yap_FullLookupAtom("$top_thread_goal"), 2); - Yap_heap_regs->functor_change_module = Yap_MkFunctor (Yap_FullLookupAtom("$change_module"), 1); - Yap_heap_regs->functor_current_module = Yap_MkFunctor (Yap_FullLookupAtom("$current_module"), 1); - FunctorThrow = Yap_MkFunctor( Yap_FullLookupAtom("throw"), 1); - Yap_heap_regs->functor_u_minus = Yap_MkFunctor (Yap_heap_regs->atom_minus, 1); - Yap_heap_regs->functor_u_plus = Yap_MkFunctor (Yap_heap_regs->atom_plus, 1); - Yap_heap_regs->functor_v_bar = Yap_MkFunctor(Yap_LookupAtom("|"), 2); - Yap_heap_regs->functor_var = Yap_MkFunctor(AtomVar, 1); -#ifdef EUROTRA - Yap_heap_regs->term_dollar_u = MkAtomTerm(Yap_FullLookupAtom("$u")); -#endif - Yap_heap_regs->term_refound_var = MkAtomTerm(Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN")); + Yap_heap_regs->term_refound_var = MkAtomTerm(AtomRefoundVar); Yap_heap_regs->n_of_file_aliases = 0; Yap_heap_regs->file_aliases = NULL; Yap_heap_regs->foreign_code_loaded = NULL; @@ -1384,28 +1220,28 @@ InitCodes(void) /* predicates can only be defined after this point */ Yap_heap_regs->env_for_yes_code.p = Yap_heap_regs->env_for_yes_code.p0 = - RepPredProp(PredPropByAtom(Yap_heap_regs->atom_true,0)); - Yap_heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_heap_regs->atom_meta_call,4),PROLOG_MODULE)); - Yap_heap_regs->pred_dollar_catch = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$catch"),3),PROLOG_MODULE)); - Yap_heap_regs->pred_recorded_with_key = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$recorded_with_key"),3),PROLOG_MODULE)); - Yap_heap_regs->pred_log_upd_clause = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$do_log_upd_clause"),6),PROLOG_MODULE)); - Yap_heap_regs->pred_log_upd_clause_erase = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$do_log_upd_clause_erase"),6),PROLOG_MODULE)); - Yap_heap_regs->pred_log_upd_clause0 = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$do_log_upd_clause0"),6),PROLOG_MODULE)); - Yap_heap_regs->pred_static_clause = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$do_static_clause"),5),PROLOG_MODULE)); + RepPredProp(PredPropByAtom(AtomTrue,0)); + Yap_heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomMetaCall,4),PROLOG_MODULE)); + Yap_heap_regs->pred_dollar_catch = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomCatch,3),PROLOG_MODULE)); + Yap_heap_regs->pred_recorded_with_key = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomRecordedWithKey,3),PROLOG_MODULE)); + Yap_heap_regs->pred_log_upd_clause = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomDoLogUpdClause,6),PROLOG_MODULE)); + Yap_heap_regs->pred_log_upd_clause_erase = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomDoLogUpdClauseErase,6),PROLOG_MODULE)); + Yap_heap_regs->pred_log_upd_clause0 = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomDoLogUpdClause0,6),PROLOG_MODULE)); + Yap_heap_regs->pred_static_clause = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomDoStaticClause,5),PROLOG_MODULE)); Yap_heap_regs->pred_throw = RepPredProp(PredPropByFunc(FunctorThrow,PROLOG_MODULE)); - Yap_heap_regs->pred_handle_throw = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$handle_throw"),3),PROLOG_MODULE)); - Yap_heap_regs->pred_goal_expansion = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("goal_expansion"),3),USER_MODULE)); + Yap_heap_regs->pred_handle_throw = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomHandleThrow,3),PROLOG_MODULE)); + Yap_heap_regs->pred_goal_expansion = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomGoalExpansion,3),USER_MODULE)); Yap_heap_regs->env_for_trustfail_code.p = Yap_heap_regs->env_for_trustfail_code.p0 = - RepPredProp(PredPropByAtom(Yap_heap_regs->atom_false,PROLOG_MODULE)); + RepPredProp(PredPropByAtom(AtomFalse,PROLOG_MODULE)); { /* make sure we know about the module predicate */ - PredEntry *modp = RepPredProp(PredPropByFunc(Yap_heap_regs->functor_module,PROLOG_MODULE)); + PredEntry *modp = RepPredProp(PredPropByFunc(FunctorModule,PROLOG_MODULE)); modp->PredFlags |= MetaPredFlag; } #ifdef YAPOR - Yap_heap_regs->getwork_code.u.Otapl.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork"), PROLOG_MODULE)); - Yap_heap_regs->getwork_seq_code.u.Otapl.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork_seq"), PROLOG_MODULE)); + Yap_heap_regs->getwork_code.u.Otapl.p = RepPredProp(PredPropByAtom(AtomGetwork, PROLOG_MODULE)); + Yap_heap_regs->getwork_seq_code.u.Otapl.p = RepPredProp(PredPropByAtom(AtomGetworkSeq, PROLOG_MODULE)); #endif /* YAPOR */ Yap_heap_regs->db_erased_marker = (DBRef)Yap_AllocCodeSpace(sizeof(DBStruct)); @@ -1424,7 +1260,7 @@ InitCodes(void) Yap_heap_regs->logdb_erased_marker->ClFlags = ErasedMask|LogUpdMask; Yap_heap_regs->logdb_erased_marker->ClSource = NULL; Yap_heap_regs->logdb_erased_marker->ClRefCount = 0; - Yap_heap_regs->logdb_erased_marker->ClPred = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$do_log_upd_clause"),5),PROLOG_MODULE)); + Yap_heap_regs->logdb_erased_marker->ClPred = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomDoLogUpdClause,5),PROLOG_MODULE)); Yap_heap_regs->logdb_erased_marker->ClExt = NULL; Yap_heap_regs->logdb_erased_marker->ClPrev = NULL; Yap_heap_regs->logdb_erased_marker->ClNext = NULL; @@ -1442,10 +1278,10 @@ InitCodes(void) static void InitVersion(void) { - Yap_PutValue(Yap_FullLookupAtom("$version_name"), + Yap_PutValue(AtomVersionNumber, MkAtomTerm(Yap_LookupAtom(YAP_VERSION))); #if defined MYDDAS_MYSQL || defined MYDDAS_ODBC - Yap_PutValue(Yap_FullLookupAtom("$myddas_version_name"), + Yap_PutValue(AtomMyddasVersionName, MkAtomTerm(Yap_LookupAtom(MYDDAS_VERSION))); #endif } diff --git a/C/iopreds.c b/C/iopreds.c index 13a9863b4..ae3ea024c 100644 --- a/C/iopreds.c +++ b/C/iopreds.c @@ -308,7 +308,7 @@ unix_upd_stream_info (StreamDesc * s) /* isatty does not seem to work with simplescar. I'll assume the first three streams will probably be ttys (pipes are not thatg different) */ if (s-Stream < 3) { - s->u.file.name = Yap_LookupAtom("tty"); + s->u.file.name = AtomTty; s->status |= Tty_Stream_f|Reset_Eof_Stream_f|Promptable_Stream_f; } #else @@ -319,11 +319,11 @@ unix_upd_stream_info (StreamDesc * s) #if HAVE_TTYNAME char *ttys = ttyname(filedes); if (ttys == NULL) - s->u.file.name = Yap_LookupAtom("tty"); + s->u.file.name = AtomTty; else - s->u.file.name = Yap_LookupAtom(ttys); + s->u.file.name = AtomTtys; #else - s->u.file.name = Yap_LookupAtom("tty"); + s->u.file.name = AtomTty; #endif s->status |= Tty_Stream_f|Reset_Eof_Stream_f|Promptable_Stream_f; return; @@ -453,13 +453,13 @@ InitStdStream (int sno, SMALLUNSGN flags, YP_File file) InitFileIO(s); switch(sno) { case 0: - s->u.file.name=Yap_LookupAtom("user_input"); + s->u.file.name=AtomUserIn; break; case 1: - s->u.file.name=Yap_LookupAtom("user_output"); + s->u.file.name=AtomUserOut; break; default: - s->u.file.name=Yap_LookupAtom("user_error"); + s->u.file.name=AtomUserErr; break; } s->u.file.user_name = MkAtomTerm (s->u.file.name); @@ -496,11 +496,11 @@ InitStdStreams (void) Yap_c_output_stream = StdOutStream; Yap_c_error_stream = StdErrStream; /* init standard aliases */ - FileAliases[0].name = AtomUsrIn; + FileAliases[0].name = AtomUserIn; FileAliases[0].alias_stream = 0; - FileAliases[1].name = AtomUsrOut; + FileAliases[1].name = AtomUserOut; FileAliases[1].alias_stream = 1; - FileAliases[2].name = AtomUsrErr; + FileAliases[2].name = AtomUserErr; FileAliases[2].alias_stream = 2; NOfFileAliases = 3; SzOfFileAliases = ALIASES_BLOCK_SIZE; @@ -534,7 +534,7 @@ Yap_InitPlIO (void) static Int PlIOError (yap_error_number type, Term culprit, char *who) { - if (Yap_GetValue(Yap_LookupAtom("fileerrors")) == MkIntTerm(1)) { + if (Yap_GetValue(AtomFileerrors) == MkIntTerm(1)) { Yap_Error(type, culprit, who); /* and fail */ return FALSE; @@ -2263,7 +2263,7 @@ p_open (void) } open_mode = AtomOfTerm (t2); if (open_mode == AtomRead || open_mode == AtomCsult) { - if (open_mode == AtomCsult && AtomOfTerm(file_name) == AtomUsrIn) { + if (open_mode == AtomCsult && AtomOfTerm(file_name) == AtomUserIn) { return(Yap_unify(MkStream(FileAliases[0].alias_stream), ARG3)); } strncpy(io_mode,"rb", 8); @@ -2371,7 +2371,7 @@ p_open (void) st->stream_gets = PlGetsFunc(); } ta[1] = MkAtomTerm(AtomTrue); - t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("reposition"),1),1,ta); + t = Yap_MkApplTerm(Yap_MkFunctor(AtomReposition,1),1,ta); Yap_Error(PERMISSION_ERROR_OPEN_SOURCE_SINK,t,"open/4"); return FALSE; } @@ -2568,7 +2568,7 @@ p_open_null_stream (void) st->stream_gets = PlGetsFunc(); st->stream_wgetc = get_wchar; st->stream_wgetc_for_read = get_wchar; - st->u.file.user_name = MkAtomTerm (st->u.file.name = Yap_LookupAtom ("/dev/null")); + st->u.file.user_name = MkAtomTerm (st->u.file.name = AtomDevNull); t = MkStream (sno); return (Yap_unify (ARG1, t)); } @@ -3046,9 +3046,9 @@ CheckStream (Term arg, int kind, char *msg) "ambiguous use of 'user' as a stream"); return (-1); } - sname = AtomUsrIn; + sname = AtomUserIn; } else { - sname = AtomUsrOut; + sname = AtomUserOut; } } if ((sno = CheckAlias(sname)) == -1) { @@ -3130,13 +3130,13 @@ StreamName(int i) if (i < 3) return(MkAtomTerm(AtomUser)); #if USE_SOCKET if (Stream[i].status & Socket_Stream_f) - return(MkAtomTerm(Yap_LookupAtom("socket"))); + return(MkAtomTerm(AtomSocket)); else #endif if (Stream[i].status & Pipe_Stream_f) - return(MkAtomTerm(Yap_LookupAtom("pipe"))); + return(MkAtomTerm(AtomPipe)); if (Stream[i].status & InMemory_Stream_f) - return(MkAtomTerm(Yap_LookupAtom("charsio"))); + return(MkAtomTerm(AtomCharsio)); else { if (yap_flags[LANGUAGE_MODE_FLAG] == ISO_CHARACTER_ESCAPES) { return(Stream[i].u.file.user_name); @@ -3667,11 +3667,11 @@ syntax_error (TokEntry * tokptr, int sno) { Term t0[1]; t0[0] = MkAtomTerm((Atom)info); - ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("atom"),1),1,t0); + ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom,1),1,t0); } break; case Number_tok: - ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("number"),1),1,&(tokptr->TokInfo)); + ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomNumber,1),1,&(tokptr->TokInfo)); break; case Var_tok: { @@ -3685,19 +3685,19 @@ syntax_error (TokEntry * tokptr, int sno) } else { t[2] = varinfo->VarAdr; } - ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("var"),3),3,t); + ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomGVar,3),3,t); } break; case String_tok: { Term t0 = Yap_StringToList((char *)info); - ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("string"),1),1,&t0); + ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString,1),1,&t0); } break; case WString_tok: { Term t0 = Yap_WideStringToList((wchar_t *)info); - ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("string"),1),1,&t0); + ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString,1),1,&t0); } break; case Error_tok: @@ -3722,26 +3722,26 @@ syntax_error (TokEntry * tokptr, int sno) } else if (tokptr->Tok != Ord (Error_tok)) { ts[1] = MkIntegerTerm(tokptr->TokPos); *error = - MkPairTerm(Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("-"),2),2,ts),TermNil); + MkPairTerm(Yap_MkApplTerm(Yap_MkFunctor(AtomMinus,2),2,ts),TermNil); error = RepPair(*error)+1; count++; } tokptr = tokptr->TokNext; } - tf[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("read"),1),1,&ARG2); + tf[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomRead,1),1,&ARG2); { Term t[3]; t[0] = MkIntegerTerm(start); t[1] = MkIntegerTerm(err); t[2] = MkIntegerTerm(end); - tf[1] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("between"),3),3,t); + tf[1] = Yap_MkApplTerm(Yap_MkFunctor(AtomBetween,3),3,t); } - tf[2] = MkAtomTerm(Yap_LookupAtom("\n<==== HERE ====>\n")); + tf[2] = MkAtomTerm(AtomHERE); tf[4] = MkIntegerTerm(out); tf[5] = MkIntegerTerm(err); tf[6] = StreamName(sno); - return(Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("syntax_error"),7),7,tf)); + return(Yap_MkApplTerm(Yap_MkFunctor(AtomSyntaxError,7),7,tf)); } Int @@ -3794,16 +3794,16 @@ p_get_read_error_handler(void) switch (ParserErrorStyle) { case FAIL_ON_PARSER_ERROR: - t = MkAtomTerm(Yap_LookupAtom("fail")); + t = MkAtomTerm(AtomFail); break; case EXCEPTION_ON_PARSER_ERROR: - t = MkAtomTerm(Yap_LookupAtom("error")); + t = MkAtomTerm(AtomError); break; case QUIET_ON_PARSER_ERROR: - t = MkAtomTerm(Yap_LookupAtom("quiet")); + t = MkAtomTerm(AtomQuiet); break; case CONTINUE_ON_PARSER_ERROR: - t = MkAtomTerm(Yap_LookupAtom("dec10")); + t = MkAtomTerm(AtomDec10); break; default: Yap_Error(SYSTEM_ERROR,TermNil,"corrupted syntax_error handler"); @@ -3991,7 +3991,7 @@ static Int t[1] = MkAtomTerm(Yap_LookupAtom(Yap_ErrorMessage)); Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable); return(Yap_unify(tpos,ARG5) && - Yap_unify(ARG6,Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("error"),2),2,t))); + Yap_unify(ARG6,Yap_MkApplTerm(Yap_MkFunctor(AtomError,2),2,t))); } } } else { @@ -4064,13 +4064,13 @@ p_user_file_name (void) return (FALSE); #if USE_SOCKET if (Stream[sno].status & Socket_Stream_f) - tout = MkAtomTerm(Yap_LookupAtom("socket")); + tout = MkAtomTerm(AtomSocket); else #endif if (Stream[sno].status & Pipe_Stream_f) - tout = MkAtomTerm(Yap_LookupAtom("pipe")); + tout = MkAtomTerm(AtomPipe); else if (Stream[sno].status & InMemory_Stream_f) - tout = MkAtomTerm(Yap_LookupAtom("charsio")); + tout = MkAtomTerm(AtomCharsio); else tout = Stream[sno].u.file.user_name; UNLOCK(Stream[sno].streamlock); @@ -4086,13 +4086,13 @@ p_file_name (void) return (FALSE); #if USE_SOCKET if (Stream[sno].status & Socket_Stream_f) - tout = MkAtomTerm(Yap_LookupAtom("socket")); + tout = MkAtomTerm(AtomSocket); else #endif if (Stream[sno].status & Pipe_Stream_f) - tout = MkAtomTerm(Yap_LookupAtom("pipe")); + tout = MkAtomTerm(AtomPipe); else if (Stream[sno].status & InMemory_Stream_f) - tout = MkAtomTerm(Yap_LookupAtom("charsio")); + tout = MkAtomTerm(AtomCharsio); else tout = MkAtomTerm(Stream[sno].u.file.name); UNLOCK(Stream[sno].streamlock); @@ -4115,14 +4115,14 @@ p_cur_line_no (void) Atom my_stream; #if USE_SOCKET if (Stream[sno].status & Socket_Stream_f) - my_stream = Yap_LookupAtom("socket"); + my_stream = AtomSocket; else #endif if (Stream[sno].status & Pipe_Stream_f) - my_stream = Yap_LookupAtom("pipe"); + my_stream = AtomPipe; else if (Stream[sno].status & InMemory_Stream_f) - my_stream = Yap_LookupAtom("charsio"); + my_stream = AtomCharsio; else my_stream = Stream[sno].u.file.name; for (i = 0; i < MaxStreams; i++) @@ -4315,7 +4315,7 @@ p_set_stream_position (void) UNLOCK(Stream[sno].streamlock); Yap_Error(INSTANTIATION_ERROR, tp, "set_stream_position/2"); return (FALSE); - } else if (tp != MkAtomTerm(Yap_LookupAtom("at"))) { + } else if (tp != MkAtomTerm(AtomAt)) { UNLOCK(Stream[sno].streamlock); Yap_Error(DOMAIN_ERROR_STREAM_POSITION, tin, "set_stream_position/2"); return (FALSE); @@ -5340,7 +5340,7 @@ format(volatile Term otail, volatile Term oargs, int sno) Term ta[2]; ta[0] = otail; ta[1] = oargs; - Yap_Error(Yap_Error_TYPE, Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("format"),2),2,ta), "format/2"); + Yap_Error(Yap_Error_TYPE, Yap_MkApplTerm(Yap_MkFunctor(AtomFormat,2),2,ta), "format/2"); } if (Stream[sno].status & InMemory_Stream_f) { Stream[sno].u.mem_string.error_handler = old_handler; @@ -5530,7 +5530,7 @@ p_stream_select(void) return(FALSE); } if (IsAtomTerm(t2)) { - if (t2 == MkAtomTerm(Yap_LookupAtom("off"))) { + if (t2 == MkAtomTerm(AtomOff)) { /* wait indefinitely */ ptime = NULL; } else { @@ -5951,8 +5951,8 @@ p_float_format(void) { Term in = Deref(ARG1); if (IsVarTerm(in)) - return Yap_unify(ARG1, MkAtomTerm(FloatFormat)); - FloatFormat = AtomOfTerm(in); + return Yap_unify(ARG1, MkAtomTerm(AtomFloatFormat)); + AtomFloatFormat = AtomOfTerm(in); return TRUE; } @@ -6025,7 +6025,7 @@ Yap_StringToTerm(char *s,Term *tp) tokstart = Yap_tokptr = Yap_toktide = Yap_tokenizer(sno, &tpos); if (tokstart == NIL && tokstart->Tok == Ord (eot_tok)) { if (tp) { - *tp = MkAtomTerm(Yap_LookupAtom("end of file found before end of term")); + *tp = MkAtomTerm(AtomEOFBeforeEOT); } Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable); /* cannot actually use CloseStream, because we didn't allocate the buffer */ diff --git a/C/modules.c b/C/modules.c index 47c90e038..24215bba2 100644 --- a/C/modules.c +++ b/C/modules.c @@ -313,7 +313,7 @@ Yap_InitModulesC(void) void Yap_InitModules(void) { - LookupModule(MkAtomTerm(Yap_LookupAtom("prolog"))); + LookupModule(MkAtomTerm(AtomProlog)); LookupModule(USER_MODULE); LookupModule(IDB_MODULE); LookupModule(ATTRIBUTES_MODULE); diff --git a/C/parser.c b/C/parser.c index 3a7d18659..d568d30b2 100644 --- a/C/parser.c +++ b/C/parser.c @@ -352,7 +352,7 @@ ParseArgs(Atom a, JMPBUFF *FailBuff) else t = Yap_MkApplTerm(Yap_MkFunctor(a, nargs), nargs, p); #else - if (a == AtomDBRef && nargs == 2) + if (a == AtomDBref && nargs == 2) t = MkDBRefTerm((DBRef)IntegerOfTerm(p[0])); else t = Yap_MkApplTerm(func, nargs, p); @@ -674,7 +674,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff) NextToken; args[0] = t; args[1] = ParseTerm(1000, FailBuff); - t = Yap_MkApplTerm(Yap_MkFunctor(AtomComma, 2), 2, args); + t = Yap_MkApplTerm(FunctorComma, 2, args); /* check for possible overflow against local stack */ if (H > ASP-4096) { Yap_ErrorMessage = "Stack Overflow"; diff --git a/C/scanner.c b/C/scanner.c index a63f6d9ea..2082f6633 100644 --- a/C/scanner.c +++ b/C/scanner.c @@ -962,7 +962,7 @@ Yap_tokenizer(int inp_stream, Term *tposp) t->Tok = Name_tok; if (ch == '(') solo_flag = FALSE; - t->TokInfo = Unsigned(Yap_LookupAtom("e")); + t->TokInfo = Unsigned(AtomE); t->TokPos = GetCurInpPos(inp_stream); e2 = (TokEntry *) AllocScannerMemory(sizeof(TokEntry)); if (e2 == NULL) { diff --git a/C/stdpreds.c b/C/stdpreds.c index 936e183f5..ef2debfcb 100644 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -365,7 +365,7 @@ Int cont_eam(void) { Int use_eam(void) { if (EAM) EAM=0; - else { Yap_PutValue(Yap_FullLookupAtom("$c_arith"),0); EAM=1; } + else { Yap_PutValue(AtomCArith,0); EAM=1; } return(TRUE); } @@ -495,7 +495,7 @@ p_creep(void) Atom at; PredEntry *pred; - at = Yap_FullLookupAtom("$creep"); + at = AtomCreep; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); CreepCode = pred; do_signal(YAP_CREEP_SIGNAL); @@ -508,7 +508,7 @@ p_signal_creep(void) Atom at; PredEntry *pred; - at = Yap_FullLookupAtom("$creep"); + at = AtomCreep; pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); CreepCode = pred; LOCK(SignalLock); @@ -971,7 +971,7 @@ p_name(void) String + 1024 > (char *)AuxSp) goto expand_auxsp; if (!IsVarTerm(t) && t == MkAtomTerm(AtomNil)) { - return Yap_unify_constant(ARG1, MkAtomTerm(Yap_LookupAtom(""))); + return Yap_unify_constant(ARG1, MkAtomTerm(AtomEmptyAtom)); } while (!IsVarTerm(t) && IsPairTerm(t)) { Term Head; @@ -1112,7 +1112,7 @@ p_atom_chars(void) return(FALSE); } if (t == TermNil) { - return (Yap_unify_constant(t1, MkAtomTerm(Yap_LookupAtom("")))); + return (Yap_unify_constant(t1, MkAtomTerm(AtomEmptyAtom))); } if (!IsPairTerm(t)) { Yap_Error(TYPE_ERROR_LIST, t, "atom_chars/2"); @@ -1660,7 +1660,7 @@ p_atom_codes(void) return(FALSE); } if (t == TermNil) { - return (Yap_unify_constant(t1, MkAtomTerm(Yap_LookupAtom("")))); + return (Yap_unify_constant(t1, MkAtomTerm(AtomEmptyAtom))); } if (!IsPairTerm(t)) { Yap_Error(TYPE_ERROR_LIST, t, "atom_codes/2"); @@ -1886,10 +1886,10 @@ gen_syntax_error(Atom InpAtom, char *s) ti[1] = ARG2; ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom(s),2),2,ti); ts[1] = ts[4] = ts[5] = MkIntTerm(0); - ts[2] = MkAtomTerm(Yap_LookupAtom("expected number syntax")); + ts[2] = MkAtomTerm(AtomExpectedNumber); ts[3] = TermNil; ts[6] = MkAtomTerm(InpAtom); - return(Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("syntax_error"),7),7,ts)); + return(Yap_MkApplTerm(Yap_MkFunctor(AtomSyntaxError,7),7,ts)); } static Int @@ -3493,17 +3493,17 @@ p_access_yap_flags(void) int n = 0; if (IsMode_CompletedOn(yap_flags[flag])) { if (IsMode_LoadAnswers(yap_flags[flag])) - tout = MkAtomTerm(Yap_LookupAtom("load_answers")); + tout = MkAtomTerm(AtomLoadAnswers); else - tout = MkAtomTerm(Yap_LookupAtom("exec_answers")); + tout = MkAtomTerm(AtomExecAnswers); n++; } if (IsMode_SchedulingOn(yap_flags[flag])) { Term taux = tout; if (IsMode_Local(yap_flags[flag])) - tout = MkAtomTerm(Yap_LookupAtom("local")); + tout = MkAtomTerm(Yap_AtomLocalA); else - tout = MkAtomTerm(Yap_LookupAtom("batched")); + tout = MkAtomTerm(AtomBatched); if (n) { taux = MkPairTerm(taux, MkAtomTerm(AtomNil)); tout = MkPairTerm(tout, taux); @@ -3511,7 +3511,7 @@ p_access_yap_flags(void) n++; } if (n == 0) - tout = MkAtomTerm(Yap_LookupAtom("default")); + tout = MkAtomTerm(AtomDefault); } else #endif /* TABLING */ tout = MkIntegerTerm(yap_flags[flag]); diff --git a/C/sysbits.c b/C/sysbits.c index 23de1c0d0..ad5a915be 100644 --- a/C/sysbits.c +++ b/C/sysbits.c @@ -190,7 +190,7 @@ Yap_InitSysPath(void) { { char *dir; if ((dir = Yap_RegistryGetString("library"))) { - Yap_PutValue(Yap_LookupAtom("system_library_directory"), + Yap_PutValue(AtomSystemLibraryDir, MkAtomTerm(Yap_LookupAtom(dir))); return; } @@ -244,7 +244,7 @@ Yap_InitSysPath(void) { strncat(Yap_FileNameBuf,"/", YAP_FILENAME_MAX); #endif strncat(Yap_FileNameBuf, "Yap", YAP_FILENAME_MAX); - Yap_PutValue(Yap_LookupAtom("system_library_directory"), + Yap_PutValue(AtomSystemLibraryDir, MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf))); } @@ -2085,7 +2085,7 @@ p_file_directory_name (void) chp = Yap_FileNameBuf+strlen(Yap_FileNameBuf); while (!dir_separator(*--chp) && chp != Yap_FileNameBuf); if (chp == Yap_FileNameBuf) { - return Yap_unify(MkAtomTerm(Yap_LookupAtom(".")),ARG2); + return Yap_unify(MkAtomTerm(AtomDot),ARG2); } *chp = '\0'; return Yap_unify(MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf)),ARG2); @@ -2532,7 +2532,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_wake_up"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigWakeUp)); } if (ActiveSignals & YAP_ITI_SIGNAL) { ActiveSignals &= ~YAP_ITI_SIGNAL; @@ -2540,7 +2540,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_iti"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigIti)); } if (ActiveSignals & YAP_INT_SIGNAL) { ActiveSignals &= ~YAP_INT_SIGNAL; @@ -2548,7 +2548,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_int"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigInt)); } if (ActiveSignals & YAP_USR2_SIGNAL) { ActiveSignals &= ~YAP_USR2_SIGNAL; @@ -2556,7 +2556,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_usr2"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigUsr2)); } if (ActiveSignals & YAP_USR1_SIGNAL) { ActiveSignals &= ~YAP_USR1_SIGNAL; @@ -2564,7 +2564,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_usr1"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigUsr1)); } if (ActiveSignals & YAP_PIPE_SIGNAL) { ActiveSignals &= ~YAP_PIPE_SIGNAL; @@ -2572,7 +2572,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_pipe"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigPipe)); } if (ActiveSignals & YAP_HUP_SIGNAL) { ActiveSignals &= ~YAP_HUP_SIGNAL; @@ -2580,12 +2580,12 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_hup"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigHup)); } if (ActiveSignals & YAP_ALARM_SIGNAL) { ActiveSignals &= ~YAP_ALARM_SIGNAL; UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_alarm"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigAlarm)); } if (ActiveSignals & YAP_DELAY_CREEP_SIGNAL) { ActiveSignals &= ~(YAP_CREEP_SIGNAL|YAP_DELAY_CREEP_SIGNAL); @@ -2593,7 +2593,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_delay_creep"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigDelayCreep)); } if (ActiveSignals & YAP_CREEP_SIGNAL) { ActiveSignals &= ~YAP_CREEP_SIGNAL; @@ -2601,7 +2601,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_creep"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigCreep)); } if (ActiveSignals & YAP_TRACE_SIGNAL) { ActiveSignals &= ~YAP_TRACE_SIGNAL; @@ -2609,7 +2609,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_trace"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigTrace)); } if (ActiveSignals & YAP_DEBUG_SIGNAL) { ActiveSignals &= ~YAP_DEBUG_SIGNAL; @@ -2617,7 +2617,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_debug"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigDebug)); } if (ActiveSignals & YAP_BREAK_SIGNAL) { ActiveSignals &= ~YAP_BREAK_SIGNAL; @@ -2625,7 +2625,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_break"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigBreak)); } if (ActiveSignals & YAP_STACK_DUMP_SIGNAL) { ActiveSignals &= ~YAP_STACK_DUMP_SIGNAL; @@ -2633,7 +2633,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_stack_dump"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigStackDump)); } if (ActiveSignals & YAP_STATISTICS_SIGNAL) { ActiveSignals &= ~YAP_STATISTICS_SIGNAL; @@ -2641,7 +2641,7 @@ p_first_signal(void) pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); #endif UNLOCK(SignalLock); - return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_statistics"))); + return Yap_unify(ARG1, MkAtomTerm(AtomSigStatistics)); } #ifdef THREADS pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); @@ -2734,7 +2734,7 @@ p_win32(void) static Int p_ld_path(void) { - return Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("LD_LIBRARY_PATH"))); + return Yap_unify(ARG1,MkAtomTerm(AtomLDLibraryPath)); } diff --git a/C/userpreds.c b/C/userpreds.c index d607281b4..0ec1cbead 100644 --- a/C/userpreds.c +++ b/C/userpreds.c @@ -592,14 +592,11 @@ static int p_grab_tokens() { Term *p = ASP - 20, *p0, t; - Atom IdAtom, VarAtom; Functor IdFunctor, VarFunctor; char ch, IdChars[256], *chp; - IdAtom = Yap_LookupAtom("id"); - IdFunctor = Yap_MkFunctor(IdAtom, 1); - VarAtom = Yap_LookupAtom("var"); - VarFunctor = Yap_MkFunctor(VarAtom, 1); + IdFunctor = FunctorId; + VarFunctor = FunctorVar; p0 = p; ch = Yap_PlGetchar(); while (1) { diff --git a/C/utilpreds.c b/C/utilpreds.c index 2b2d5bd35..20576865a 100644 --- a/C/utilpreds.c +++ b/C/utilpreds.c @@ -2301,8 +2301,8 @@ camacho_dum(void) /* build output list */ - t1 = MkAtomTerm(Yap_LookupAtom("[]")); - t2 = MkPairTerm(MkIntegerTerm(max), t1); + t1 = TermNil; + t2 = MkPairTerm(MkIntegerTerm(max), t1); return(Yap_unify(t2, ARG1)); } diff --git a/C/write.c b/C/write.c index dd422bdf4..af84bc22a 100644 --- a/C/write.c +++ b/C/write.c @@ -124,7 +124,7 @@ wrputf(Float f, wrf writewch) /* writes a float */ } lastw = alphanum; // sprintf(s, "%.15g", f); - sprintf(s, RepAtom(FloatFormat)->StrOfAE, f); + sprintf(s, RepAtom(AtomFloatFormat)->StrOfAE, f); while (*pt == ' ') pt++; if (*pt == 'i' || *pt == 'n') /* inf or nan */ { @@ -150,7 +150,7 @@ wrputref(CODEADDR ref, int Quote_illegal, wrf writewch) /* writes a data base { char s[256]; - putAtom(AtomDBRef, Quote_illegal, writewch); + putAtom(AtomDBref, Quote_illegal, writewch); #if SHORT_INTS sprintf(s, "(0x%p,0)", ref); #elif __linux__ @@ -296,7 +296,7 @@ putAtom(Atom atom, int Quote_illegal, wrf writewch) /* writes an atom */ /* #define CRYPT_FOR_STEVE 1*/ #ifdef CRYPT_FOR_STEVE - if (Yap_GetValue(Yap_LookupAtom("crypt_atoms")) != TermNil && Yap_GetAProp(atom, OpProperty) == NIL) { + if (Yap_GetValue(AtomCryptAtoms) != TermNil && Yap_GetAProp(atom, OpProperty) == NIL) { char s[16]; sprintf(s,"x%x", (CELL)s); wrputs(s, writewch); @@ -439,7 +439,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg, struct write_globs *wglb) { if (wglb->MaxDepth != 0 && depth > wglb->MaxDepth) { - putAtom(Yap_LookupAtom("..."), wglb->Quote_illegal, wglb->writewch); + putAtom(Atom3Dots, wglb->Quote_illegal, wglb->writewch); return; } if (EX != 0) @@ -481,7 +481,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg, struct write_globs *wglb) long sl= 0; if (wglb->MaxList && eldepth > wglb->MaxList) { - putAtom(Yap_LookupAtom("..."), wglb->Quote_illegal, wglb->writewch); + putAtom(Atom3Dots, wglb->Quote_illegal, wglb->writewch); wrputc(']', wglb->writewch); lastw = separator; return; diff --git a/H/Heap.h b/H/Heap.h index b8fe722e8..99e4c9cbb 100644 --- a/H/Heap.h +++ b/H/Heap.h @@ -370,137 +370,7 @@ typedef struct various_codes { struct static_mega_clause *dead_mega_clauses; struct static_index *dead_static_indices; struct dbterm_list *dbterms_list; - Atom - atom_abol, - atom_alarm, - atom_append, - atom_array, - atom_assert, - atom_att, - atom_b, - atom_break, - atom_call, - atom_catch, - atom_comma, - atom_cpu_time, - atom_csult, - atom_cut, - atom_cut_by, -#ifdef EUROTRA -#ifdef SFUNC - atom_dollar_undef, -#endif -#endif - atom_dbref, - atom_e, - atom_e_q, - atom_eof, -#ifdef EUROTRA - atom_f_b, -#endif - atom_fail, - atom_false, - atom_fast, - atom_g_t, - atom_gc, - atom_gc_margin, - atom_gc_trace, - atom_gc_verbose, - atom_gc_very_verbose, - atom_global, - atom_heap_used, - atom_inf, - atom_l_t, - atom_local, - atom_meta_call, - atom_minus, - atom_multi_file, - atom_nan, - atom_otherwise, - atom_pi, - atom_plus, - atom_portray, - atom_profile, - atom_random, - atom_read, - atom_repeat, - atom_restore_regs, -#if HAVE_SIGACTION - atom_sig_pending, -#endif - atom_stack_free, - atom_true, - atom_unwritable, - atom_user, - atom_usr_in, - atom_usr_out, - atom_usr_err, - atom_version_number, - atom_write; - Atom answer_format, - float_format; - Functor -#ifdef USE_SOCKET - functor_af_inet, - functor_af_local, - functor_af_unix, -#endif - functor_alt_not, -#ifdef COROUTINING - functor_array_entry, -#endif - functor_arrow, - functor_assert, - functor_at_found_one, - functor_atom, -#ifdef COROUTINING - functor_att_goal, /* goal that activates attributed variables */ -#endif - functor_braces, - functor_call, - functor_clist, - functor_comma, - functor_creep, - functor_csult, - functor_cut_by, - functor_dot, - functor_eq, - functor_execute_in_mod, - functor_execute2_in_mod, - functor_execute_within, - functor_g_atom, - functor_g_atomic, - functor_g_compound, - functor_g_format_at, - functor_g_integer, - functor_g_float, - functor_g_number, - functor_g_primitive, - functor_g_var, - functor_last_execute_within, - functor_list, - functor_mega_clause, - functor_module, - functor_multi_file_clause, -#ifdef MULTI_ASSIGNMENT_VARIABLES - functor_mutable, -#endif - functor_nb_queue, - functor_not, - functor_or, - functor_portray, - functor_query, - functor_static_clause, - functor_stream, - functor_stream_pos, - functor_stream_eOS, - functor_thread_run, - functor_change_module, - functor_current_module, - functor_u_minus, - functor_u_plus, - functor_v_bar, - functor_var; +#include "tatoms.h" Term #ifdef EUROTRA term_dollar_u, @@ -692,132 +562,7 @@ extern struct various_codes *Yap_heap_regs; #define CharConversionTable2 Yap_heap_regs->char_conversion_table2 #define CurrentModules Yap_heap_regs->current_modules #define OpList Yap_heap_regs->op_list -#define AtomAbol Yap_heap_regs->atom_abol -#define AtomAlarm Yap_heap_regs->atom_alarm -#define AtomAppend Yap_heap_regs->atom_append -#define AtomArray Yap_heap_regs->atom_array -#define AtomAssert Yap_heap_regs->atom_assert -#define AtomAtt Yap_heap_regs->atom_att -#define AtomB Yap_heap_regs->atom_b -#define AtomBreak Yap_heap_regs->atom_break -#define AtomCall Yap_heap_regs->atom_call -#define AtomCatch Yap_heap_regs->atom_catch -#define AtomComma Yap_heap_regs->atom_comma -#define AtomCpuTime Yap_heap_regs->atom_cpu_time -#define AtomCsult Yap_heap_regs->atom_csult -#define AtomCut Yap_heap_regs->atom_cut -#define AtomCutBy Yap_heap_regs->atom_cut_by -#if defined(EUROTRA) && defined(SFUNC) -#define AtomDollarUndef Yap_heap_regs->atom_dollar_undef -#endif -#define AtomDBRef Yap_heap_regs->atom_dbref -#define AtomE Yap_heap_regs->atom_e -#define AtomEQ Yap_heap_regs->atom_e_q -#define AtomEof Yap_heap_regs->atom_eof -#ifdef EUROTRA -#define AtomFB Yap_heap_regs->atom_f_b -#endif -#define AtomFail Yap_heap_regs->atom_fail -#define AtomFalse Yap_heap_regs->atom_false -#define AtomFast Yap_heap_regs->atom_fast -#define AtomGT Yap_heap_regs->atom_g_t -#define AtomGc Yap_heap_regs->atom_gc -#define AtomGcMargin Yap_heap_regs->atom_gc_margin -#define AtomGcTrace Yap_heap_regs->atom_gc_trace -#define AtomGcVerbose Yap_heap_regs->atom_gc_verbose -#define AtomGcVeryVerbose Yap_heap_regs->atom_gc_very_verbose -#define AtomGlobal Yap_heap_regs->atom_global -#define AtomHeapUsed Yap_heap_regs->atom_heap_used -#define AtomInf Yap_heap_regs->atom_inf -#define AtomLocal Yap_heap_regs->atom_local -#define AtomLT Yap_heap_regs->atom_l_t -#define AtomMetaCall Yap_heap_regs->atom_meta_call -#define AtomMinus Yap_heap_regs->atom_minus -#define AtomMultiFile Yap_heap_regs->atom_multi_file -#define AtomNan Yap_heap_regs->atom_nan -#define AtomOtherwise Yap_heap_regs->atom_otherwise -#define AtomPi Yap_heap_regs->atom_pi -#define AtomPlus Yap_heap_regs->atom_plus -#define AtomPortray Yap_heap_regs->atom_portray -#define AtomProfile Yap_heap_regs->atom_profile -#define AtomRandom Yap_heap_regs->atom_random -#define AtomRead Yap_heap_regs->atom_read -#define AtomRepeat Yap_heap_regs->atom_repeat -#define AtomRestoreRegs Yap_heap_regs->atom_restore_regs -#if HAVE_SIGACTION -#define AtomSigPending Yap_heap_regs->atom_sig_pending -#endif -#define AtomStackFree Yap_heap_regs->atom_stack_free -#define AtomTrue Yap_heap_regs->atom_true -#define AtomUser Yap_heap_regs->atom_user -#define AtomUsrErr Yap_heap_regs->atom_usr_err -#define AtomUsrIn Yap_heap_regs->atom_usr_in -#define AtomUsrOut Yap_heap_regs->atom_usr_out -#define AtomVersionNumber Yap_heap_regs->atom_version_number -#define AtomWrite Yap_heap_regs->atom_write #define FloatFormat Yap_heap_regs->float_format -#ifdef USE_SOCKET -#define FunctorAfInet Yap_heap_regs->functor_af_inet -#define FunctorAfLocal Yap_heap_regs->functor_af_local -#define FunctorAfUnix Yap_heap_regs->functor_af_unix -#endif -#define FunctorAltNot Yap_heap_regs->functor_alt_not -#ifdef COROUTINING -#define FunctorArrayEntry Yap_heap_regs->functor_array_entry -#endif -#define FunctorArrow Yap_heap_regs->functor_arrow -#define FunctorAssert Yap_heap_regs->functor_assert -#define FunctorAtFoundOne Yap_heap_regs->functor_at_found_one -#define FunctorAtom Yap_heap_regs->functor_atom -#ifdef COROUTINING -#define FunctorAttGoal Yap_heap_regs->functor_att_goal -#endif -#define FunctorBraces Yap_heap_regs->functor_braces -#define FunctorCall Yap_heap_regs->functor_call -#define FunctorClist Yap_heap_regs->functor_clist -#define FunctorComma Yap_heap_regs->functor_comma -#define FunctorCreep Yap_heap_regs->functor_creep -#define FunctorCsult Yap_heap_regs->functor_csult -#define FunctorCutBy Yap_heap_regs->functor_cut_by -#define FunctorDot Yap_heap_regs->functor_dot -#define FunctorEq Yap_heap_regs->functor_eq -#define FunctorExecuteInMod Yap_heap_regs->functor_execute_in_mod -#define FunctorExecute2InMod Yap_heap_regs->functor_execute2_in_mod -#define FunctorExecuteWithin Yap_heap_regs->functor_execute_within -#define FunctorGAtom Yap_heap_regs->functor_g_atom -#define FunctorGAtomic Yap_heap_regs->functor_g_atomic -#define FunctorGCompound Yap_heap_regs->functor_g_compound -#define FunctorGFloat Yap_heap_regs->functor_g_float -#define FunctorGInteger Yap_heap_regs->functor_g_integer -#define FunctorGFormatAt Yap_heap_regs->functor_g_format_at -#define FunctorGNumber Yap_heap_regs->functor_g_number -#define FunctorGPrimitive Yap_heap_regs->functor_g_primitive -#define FunctorGVar Yap_heap_regs->functor_g_var -#define FunctorLastExecuteWithin Yap_heap_regs->functor_last_execute_within -#define FunctorList Yap_heap_regs->functor_list -#define FunctorMegaClause Yap_heap_regs->functor_mega_clause -#define FunctorModule Yap_heap_regs->functor_module -#define FunctorMultiFileClause Yap_heap_regs->functor_multi_file_clause -#ifdef MULTI_ASSIGNMENT_VARIABLES -#define FunctorMutable Yap_heap_regs->functor_mutable -#endif -#define FunctorNBQueue Yap_heap_regs->functor_nb_queue -#define FunctorNot Yap_heap_regs->functor_not -#define FunctorOr Yap_heap_regs->functor_or -#define FunctorPortray Yap_heap_regs->functor_portray -#define FunctorQuery Yap_heap_regs->functor_query -#define FunctorStaticClause Yap_heap_regs->functor_static_clause -#define FunctorStream Yap_heap_regs->functor_stream -#define FunctorStreamPos Yap_heap_regs->functor_stream_pos -#define FunctorStreamEOS Yap_heap_regs->functor_stream_eOS -#define FunctorThreadRun Yap_heap_regs->functor_thread_run -#define FunctorChangeModule Yap_heap_regs->functor_change_module -#define FunctorCurrentModule Yap_heap_regs->functor_current_module -#define FunctorModSwitch Yap_heap_regs->functor_mod_switch -#define FunctorUMinus Yap_heap_regs->functor_u_minus -#define FunctorUPlus Yap_heap_regs->functor_u_plus -#define FunctorVBar Yap_heap_regs->functor_v_bar -#define FunctorVar Yap_heap_regs->functor_var #define TermDollarU Yap_heap_regs->term_dollar_u #define TermProlog Yap_heap_regs->term_prolog #define TermReFoundVar Yap_heap_regs->term_refound_var diff --git a/H/Yap.h b/H/Yap.h index 921928f84..2116618da 100644 --- a/H/Yap.h +++ b/H/Yap.h @@ -1114,7 +1114,7 @@ TailOfTermCell (Term t) /*************** variables concerned with atoms table *******************/ -#define MaxHash 1001 +#define MaxHash 3333 #define MaxWideHash (MaxHash/10+1) #define FAIL_RESTORE 0 diff --git a/H/iatoms.h b/H/iatoms.h new file mode 100644 index 000000000..0909f3d0d --- /dev/null +++ b/H/iatoms.h @@ -0,0 +1,341 @@ + 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"); + AtomAltNot = Yap_LookupAtom("not"); + AtomAppend = Yap_LookupAtom("append"); + AtomArg = Yap_LookupAtom("arg"); + AtomArray = Yap_LookupAtom("array"); + AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); + AtomArrayOverflow = Yap_LookupAtom("array_overflow"); + AtomArrayType = Yap_LookupAtom("array_type"); + AtomArrow = Yap_LookupAtom("->"); + AtomAssert = Yap_LookupAtom(":-"); + 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"); + AtomBinaryStream = Yap_LookupAtom("binary_stream"); + 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"); + AtomCharacter = Yap_LookupAtom("character"); + AtomCharacterCode = Yap_LookupAtom("character_code"); + AtomCharsio = Yap_LookupAtom("charsio"); + AtomColomn = Yap_LookupAtom(":"); + AtomComma = Yap_LookupAtom(","); + AtomCompound = Yap_LookupAtom("compound"); + AtomConsistencyError = Yap_LookupAtom("consistency_error"); + AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); + 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"); + AtomDBReference = Yap_LookupAtom("db_reference"); + AtomDBTerm = Yap_LookupAtom("db_term"); + AtomDBref = Yap_FullLookupAtom("$dbref"); + AtomDInteger = Yap_FullLookupAtom("$integer"); + AtomDec10 = Yap_LookupAtom("dec10"); + AtomDefault = Yap_LookupAtom("default"); + AtomDevNull = Yap_LookupAtom("/dev/null"); + AtomDiff = Yap_LookupAtom("\\="); + AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); + AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); + AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); + AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); + AtomDollarU = Yap_LookupAtom("$u"); + AtomDollarUndef = Yap_FullLookupAtom("$undef"); + AtomDomainError = Yap_LookupAtom("domain_error"); + AtomE = Yap_LookupAtom("e"); + AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); + AtomEQ = Yap_LookupAtom("="); + AtomEmptyAtom = Yap_LookupAtom(""); + AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); + AtomEof = Yap_LookupAtom("end_of_file"); + AtomEq = Yap_LookupAtom("="); + AtomError = Yap_LookupAtom("error"); + AtomEvaluable = Yap_LookupAtom("evaluable"); + AtomEvaluationError = Yap_LookupAtom("evaluation_error"); + AtomExecAnswers = Yap_LookupAtom("exec_answers"); + AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); + AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); + AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); + AtomExistenceError = Yap_LookupAtom("existence_error"); + AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); + AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); + AtomFB = Yap_LookupAtom("fb"); + AtomFail = Yap_LookupAtom("fail"); + AtomFalse = Yap_LookupAtom("false"); + AtomFast = Yap_FullLookupAtom("$fast"); + AtomFileerrors = Yap_LookupAtom("fileerrors"); + 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@"); + 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"); + AtomGlobal = Yap_LookupAtom("global_sp"); + AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); + AtomHERE = Yap_LookupAtom("\n<====HERE====>\n"); + AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); + AtomHeap = Yap_LookupAtom("heap"); + AtomHeapUsed = Yap_LookupAtom("heapused"); + AtomIDB = Yap_LookupAtom("idb"); + AtomIOMode = Yap_LookupAtom("io_mode"); + AtomId = Yap_LookupAtom("id"); + AtomInf = Yap_LookupAtom("inf"); + AtomInitGoal = Yap_FullLookupAtom("$init_goal"); + 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"); + AtomKey = Yap_LookupAtom("key"); + AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); + AtomLT = Yap_LookupAtom("<"); + AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); + AtomLeash = Yap_FullLookupAtom("$leash"); + AtomList = Yap_LookupAtom("list"); + AtomLive = Yap_FullLookupAtom("$live"); + AtomLoadAnswers = Yap_LookupAtom("load_answers"); + AtomLocal = Yap_LookupAtom("local_sp"); + AtomLocalA = Yap_LookupAtom("local"); + AtomMaxArity = Yap_LookupAtom("max_arity"); + AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); + AtomMetaCall = Yap_FullLookupAtom("$call"); + AtomMfClause = Yap_FullLookupAtom("$mf_clause"); + AtomMinus = Yap_LookupAtom("-"); + AtomModify = Yap_LookupAtom("modify"); + AtomMultiFile = Yap_FullLookupAtom("$multi_file"); + AtomMutable = Yap_LookupAtom("mutable"); + AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); + 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"); + AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); + AtomNot = Yap_LookupAtom("\\+"); + 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"); + AtomOperator = Yap_LookupAtom("operator"); + AtomOperatorPriority = Yap_LookupAtom("operator_priority"); + AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); + 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"); + 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"); + AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); + AtomProfile = Yap_FullLookupAtom("$profile"); + AtomProlog = Yap_LookupAtom("prolog"); + AtomPtr = Yap_LookupAtom("ptr"); + AtomQuery = Yap_LookupAtom("?-"); + AtomQueue = Yap_LookupAtom("queue"); + AtomQuiet = Yap_LookupAtom("quiet"); + AtomRadix = Yap_LookupAtom("radix"); + AtomRandom = Yap_LookupAtom("random"); + AtomRead = Yap_LookupAtom("read"); + AtomReadutil = Yap_LookupAtom("readutil"); + AtomRecordedP = Yap_FullLookupAtom("$recordep"); + AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); + AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); + AtomRepeat = Yap_LookupAtom("repeat"); + AtomRepeatSpace = Yap_LookupAtom("repeat"); + AtomReposition = Yap_LookupAtom("reposition"); + AtomRepresentationError = Yap_LookupAtom("representation_error"); + AtomResize = Yap_LookupAtom("resize"); + AtomResourceError = Yap_LookupAtom("resource_error"); + AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); + AtomRetryCounter = Yap_LookupAtom("retry_counter"); + 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"); + 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_statistic"); + AtomSigTrace = Yap_LookupAtom("sig_trace"); + AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); + AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); + AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); + AtomSlash = Yap_LookupAtom("/"); + AtomSocket = Yap_LookupAtom("socket"); + AtomSourceSink = Yap_LookupAtom("source_sink"); + AtomSpy = Yap_FullLookupAtom("$spy"); + AtomStackFree = Yap_LookupAtom("stackfree"); + AtomStaticClause = Yap_FullLookupAtom("$static_clause"); + AtomStaticProcedure = Yap_LookupAtom("static_procedure"); + AtomStream = Yap_FullLookupAtom("$stream"); + AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); + AtomStreamPos = Yap_FullLookupAtom("$stream_position"); + AtomStreamPosition = Yap_LookupAtom("stream_position"); + AtomString = Yap_LookupAtom("string"); + AtomSwi = Yap_LookupAtom("swi"); + AtomSyntaxError = Yap_LookupAtom("syntax_error"); + AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); + AtomSystem = Yap_LookupAtom("system"); + AtomSystemError = Yap_LookupAtom("system_error"); + AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); + AtomTerm = Yap_LookupAtom("term"); + AtomTerms = Yap_LookupAtom("terms"); + AtomTextStream = Yap_LookupAtom("text_stream"); + AtomThreads = Yap_LookupAtom("threads"); + AtomThrow = Yap_LookupAtom("throw"); + AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); + AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); + AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); + AtomTrue = Yap_LookupAtom("true"); + AtomTty = Yap_LookupAtom("tty"); + AtomTtys = Yap_LookupAtom("ttys"); + AtomTypeError = Yap_LookupAtom("type_error"); + AtomUndefined = Yap_LookupAtom("undefined"); + AtomUndefp = Yap_FullLookupAtom("$undefp"); + AtomUnderflow = Yap_LookupAtom("underflow"); + 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"); + AtomVBar = Yap_LookupAtom("|"); + AtomVar = Yap_FullLookupAtom("$VAR"); + AtomVariable = Yap_LookupAtom("variable"); + AtomVersionNumber = Yap_FullLookupAtom("$version_name"); + AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); + AtomWhen = Yap_FullLookupAtom("$when"); + AtomWrite = Yap_LookupAtom("write"); + 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); + FunctorAssert = Yap_MkFunctor(AtomAssert,2); + FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2); + FunctorAtom = Yap_MkFunctor(AtomAtom,1); + FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2); + FunctorBraces = Yap_MkFunctor(AtomBraces,1); + FunctorCall = Yap_MkFunctor(AtomCall,1); + FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1); + FunctorClist = Yap_MkFunctor(AtomWhen,4); + FunctorComma = Yap_MkFunctor(AtomComma,2); + FunctorCreep = Yap_MkFunctor(AtomCreep,1); + FunctorCsult = Yap_MkFunctor(AtomCsult,1); + FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1); + FunctorCutBy = Yap_MkFunctor(AtomCutBy,1); + FunctorDiff = Yap_MkFunctor(AtomDiff,2); + FunctorDot = Yap_MkFunctor(AtomDot,2); + FunctorEq = Yap_MkFunctor(AtomEq,2); + FunctorError = Yap_MkFunctor(AtomError,2); + FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2); + FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2); + FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1); + 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,1); + 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); + FunctorId = Yap_MkFunctor(AtomId,1); + FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1); + FunctorList = Yap_MkFunctor(AtomDot,2); + FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2); + FunctorModule = Yap_MkFunctor(AtomColomn,2); + FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5); + FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL))); + FunctorNBQueue = Yap_MkFunctor(AtomQueue,5); + FunctorNot = Yap_MkFunctor(AtomNot,1); + FunctorOr = Yap_MkFunctor(AtomSemic,2); + FunctorPortray = Yap_MkFunctor(AtomPortray,1); + FunctorQuery = Yap_MkFunctor(AtomQuery,1); + FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2); + FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1); + FunctorSame = Yap_MkFunctor(AtomSame,2); + FunctorSlash = Yap_MkFunctor(AtomSlash,2); + FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,1); + FunctorStream = Yap_MkFunctor(AtomStream,1); + FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1); + FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,5); + FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2); + FunctorThrow = Yap_MkFunctor(AtomThrow,1); + FunctorUMinus = Yap_MkFunctor(AtomMinus,1); + FunctorUPlus = Yap_MkFunctor(AtomPlus,1); + FunctorVBar = Yap_MkFunctor(AtomVBar,2); + FunctorVar = Yap_MkFunctor(AtomVar,1); diff --git a/H/ratoms.h b/H/ratoms.h new file mode 100644 index 000000000..01a96efa3 --- /dev/null +++ b/H/ratoms.h @@ -0,0 +1,344 @@ + Atom3Dots = AtomAdjust(Atom3Dots); + AtomAbol = AtomAdjust(AtomAbol); + AtomAccess = AtomAdjust(AtomAccess); + AtomAfInet = AtomAdjust(AtomAfInet); + AtomAfLocal = AtomAdjust(AtomAfLocal); + AtomAfUnix = AtomAdjust(AtomAfUnix); + AtomAlarm = AtomAdjust(AtomAlarm); + AtomAlias = AtomAdjust(AtomAlias); + AtomAltNot = AtomAdjust(AtomAltNot); + AtomAppend = AtomAdjust(AtomAppend); + AtomArg = AtomAdjust(AtomArg); + AtomArray = AtomAdjust(AtomArray); + AtomArrayAccess = AtomAdjust(AtomArrayAccess); + AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); + AtomArrayType = AtomAdjust(AtomArrayType); + AtomArrow = AtomAdjust(AtomArrow); + AtomAssert = AtomAdjust(AtomAssert); + 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); + AtomBinaryStream = AtomAdjust(AtomBinaryStream); + 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); + AtomCharacter = AtomAdjust(AtomCharacter); + AtomCharacterCode = AtomAdjust(AtomCharacterCode); + AtomCharsio = AtomAdjust(AtomCharsio); + AtomColomn = AtomAdjust(AtomColomn); + AtomComma = AtomAdjust(AtomComma); + AtomCompound = AtomAdjust(AtomCompound); + AtomConsistencyError = AtomAdjust(AtomConsistencyError); + AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); + 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); + AtomDBREF = AtomAdjust(AtomDBREF); + AtomDBReference = AtomAdjust(AtomDBReference); + AtomDBTerm = AtomAdjust(AtomDBTerm); + AtomDBref = AtomAdjust(AtomDBref); + AtomDInteger = AtomAdjust(AtomDInteger); + AtomDOUBLE = AtomAdjust(AtomDOUBLE); + AtomDec10 = AtomAdjust(AtomDec10); + AtomDefault = AtomAdjust(AtomDefault); + AtomDevNull = AtomAdjust(AtomDevNull); + AtomDiff = AtomAdjust(AtomDiff); + AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); + AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); + AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); + AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); + AtomDollarU = AtomAdjust(AtomDollarU); + AtomDollarUndef = AtomAdjust(AtomDollarUndef); + AtomDomainError = AtomAdjust(AtomDomainError); + AtomE = AtomAdjust(AtomE); + AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); + AtomEQ = AtomAdjust(AtomEQ); + AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); + AtomEndOfStream = AtomAdjust(AtomEndOfStream); + AtomEof = AtomAdjust(AtomEof); + AtomEq = AtomAdjust(AtomEq); + AtomError = AtomAdjust(AtomError); + AtomEvaluable = AtomAdjust(AtomEvaluable); + AtomEvaluationError = AtomAdjust(AtomEvaluationError); + AtomExecAnswers = AtomAdjust(AtomExecAnswers); + AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); + AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); + AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); + AtomExistenceError = AtomAdjust(AtomExistenceError); + AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); + AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); + AtomFB = AtomAdjust(AtomFB); + AtomFail = AtomAdjust(AtomFail); + AtomFalse = AtomAdjust(AtomFalse); + AtomFast = AtomAdjust(AtomFast); + AtomFileerrors = AtomAdjust(AtomFileerrors); + AtomFloat = AtomAdjust(AtomFloat); + AtomFloatFormat = AtomAdjust(AtomFloatFormat); + AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); + AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); + AtomFormat = AtomAdjust(AtomFormat); + AtomFormatAt = AtomAdjust(AtomFormatAt); + 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); + AtomGlobal = AtomAdjust(AtomGlobal); + AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); + AtomHERE = AtomAdjust(AtomHERE); + AtomHandleThrow = AtomAdjust(AtomHandleThrow); + AtomHeap = AtomAdjust(AtomHeap); + AtomHeapUsed = AtomAdjust(AtomHeapUsed); + AtomIDB = AtomAdjust(AtomIDB); + AtomIOMode = AtomAdjust(AtomIOMode); + AtomId = AtomAdjust(AtomId); + AtomInf = AtomAdjust(AtomInf); + AtomInitGoal = AtomAdjust(AtomInitGoal); + AtomInput = AtomAdjust(AtomInput); + AtomInstantiationError = AtomAdjust(AtomInstantiationError); + AtomInt = AtomAdjust(AtomInt); + AtomIntOverflow = AtomAdjust(AtomIntOverflow); + AtomInteger = AtomAdjust(AtomInteger); + AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); + AtomKey = AtomAdjust(AtomKey); + AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); + AtomLONGINT = AtomAdjust(AtomLONGINT); + AtomLT = AtomAdjust(AtomLT); + AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); + AtomLeash = AtomAdjust(AtomLeash); + AtomList = AtomAdjust(AtomList); + AtomLive = AtomAdjust(AtomLive); + AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); + AtomLocal = AtomAdjust(AtomLocal); + AtomLocalA = AtomAdjust(AtomLocalA); + AtomMaxArity = AtomAdjust(AtomMaxArity); + AtomMegaClause = AtomAdjust(AtomMegaClause); + AtomMetaCall = AtomAdjust(AtomMetaCall); + AtomMfClause = AtomAdjust(AtomMfClause); + AtomMinus = AtomAdjust(AtomMinus); + AtomModify = AtomAdjust(AtomModify); + AtomMultiFile = AtomAdjust(AtomMultiFile); + AtomMutable = AtomAdjust(AtomMutable); + AtomMutableVariable = AtomAdjust(AtomMutableVariable); + 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); + AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); + AtomNot = AtomAdjust(AtomNot); + 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); + AtomOperator = AtomAdjust(AtomOperator); + AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); + AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); + AtomOtherwise = AtomAdjust(AtomOtherwise); + AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); + AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); + AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); + AtomOutOfRange = AtomAdjust(AtomOutOfRange); + AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); + AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); + AtomOutput = AtomAdjust(AtomOutput); + 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); + AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); + AtomProfile = AtomAdjust(AtomProfile); + AtomProlog = AtomAdjust(AtomProlog); + AtomPtr = AtomAdjust(AtomPtr); + AtomQuery = AtomAdjust(AtomQuery); + AtomQueue = AtomAdjust(AtomQueue); + AtomQuiet = AtomAdjust(AtomQuiet); + AtomRadix = AtomAdjust(AtomRadix); + AtomRandom = AtomAdjust(AtomRandom); + AtomRead = AtomAdjust(AtomRead); + AtomReadutil = AtomAdjust(AtomReadutil); + AtomRecordedP = AtomAdjust(AtomRecordedP); + AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); + AtomRefoundVar = AtomAdjust(AtomRefoundVar); + AtomRepeat = AtomAdjust(AtomRepeat); + AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); + AtomReposition = AtomAdjust(AtomReposition); + AtomRepresentationError = AtomAdjust(AtomRepresentationError); + AtomResize = AtomAdjust(AtomResize); + AtomResourceError = AtomAdjust(AtomResourceError); + AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); + AtomRetryCounter = AtomAdjust(AtomRetryCounter); + AtomSame = AtomAdjust(AtomSame); + AtomSemic = AtomAdjust(AtomSemic); + AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); + AtomSigAlarm = AtomAdjust(AtomSigAlarm); + AtomSigBreak = AtomAdjust(AtomSigBreak); + AtomSigCreep = AtomAdjust(AtomSigCreep); + AtomSigDebug = AtomAdjust(AtomSigDebug); + AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); + 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); + AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); + AtomSlash = AtomAdjust(AtomSlash); + AtomSocket = AtomAdjust(AtomSocket); + AtomSourceSink = AtomAdjust(AtomSourceSink); + AtomSpy = AtomAdjust(AtomSpy); + AtomStackFree = AtomAdjust(AtomStackFree); + AtomStaticClause = AtomAdjust(AtomStaticClause); + AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); + AtomStream = AtomAdjust(AtomStream); + AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); + AtomStreamPos = AtomAdjust(AtomStreamPos); + AtomStreamPosition = AtomAdjust(AtomStreamPosition); + AtomString = AtomAdjust(AtomString); + AtomSwi = AtomAdjust(AtomSwi); + AtomSyntaxError = AtomAdjust(AtomSyntaxError); + AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); + AtomSystem = AtomAdjust(AtomSystem); + AtomSystemError = AtomAdjust(AtomSystemError); + AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); + AtomTerm = AtomAdjust(AtomTerm); + AtomTerms = AtomAdjust(AtomTerms); + AtomTextStream = AtomAdjust(AtomTextStream); + AtomThreads = AtomAdjust(AtomThreads); + AtomThrow = AtomAdjust(AtomThrow); + AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); + AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); + AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); + AtomTrue = AtomAdjust(AtomTrue); + AtomTty = AtomAdjust(AtomTty); + AtomTtys = AtomAdjust(AtomTtys); + AtomTypeError = AtomAdjust(AtomTypeError); + AtomUndefined = AtomAdjust(AtomUndefined); + AtomUndefp = AtomAdjust(AtomUndefp); + AtomUnderflow = AtomAdjust(AtomUnderflow); + AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); + AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); + AtomUser = AtomAdjust(AtomUser); + AtomUserErr = AtomAdjust(AtomUserErr); + AtomUserIn = AtomAdjust(AtomUserIn); + AtomUserOut = AtomAdjust(AtomUserOut); + AtomVBar = AtomAdjust(AtomVBar); + AtomVar = AtomAdjust(AtomVar); + AtomVariable = AtomAdjust(AtomVariable); + AtomVersionNumber = AtomAdjust(AtomVersionNumber); + AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); + AtomWhen = AtomAdjust(AtomWhen); + AtomWrite = AtomAdjust(AtomWrite); + 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); + FunctorAssert = FuncAdjust(FunctorAssert); + FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne); + FunctorAtom = FuncAdjust(FunctorAtom); + FunctorAttGoal = FuncAdjust(FunctorAttGoal); + FunctorBraces = FuncAdjust(FunctorBraces); + FunctorCall = FuncAdjust(FunctorCall); + FunctorChangeModule = FuncAdjust(FunctorChangeModule); + FunctorClist = FuncAdjust(FunctorClist); + FunctorComma = FuncAdjust(FunctorComma); + FunctorCreep = FuncAdjust(FunctorCreep); + FunctorCsult = FuncAdjust(FunctorCsult); + FunctorCurrentModule = FuncAdjust(FunctorCurrentModule); + FunctorCutBy = FuncAdjust(FunctorCutBy); + FunctorDiff = FuncAdjust(FunctorDiff); + FunctorDot = FuncAdjust(FunctorDot); + FunctorEq = FuncAdjust(FunctorEq); + FunctorError = FuncAdjust(FunctorError); + FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod); + FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod); + FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin); + 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); + FunctorId = FuncAdjust(FunctorId); + FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin); + FunctorList = FuncAdjust(FunctorList); + FunctorMegaClause = FuncAdjust(FunctorMegaClause); + FunctorModule = FuncAdjust(FunctorModule); + FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause); + FunctorMutable = FuncAdjust(FunctorMutable); + FunctorNBQueue = FuncAdjust(FunctorNBQueue); + FunctorNot = FuncAdjust(FunctorNot); + FunctorOr = FuncAdjust(FunctorOr); + FunctorPortray = FuncAdjust(FunctorPortray); + FunctorQuery = FuncAdjust(FunctorQuery); + FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs); + FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1); + FunctorSame = FuncAdjust(FunctorSame); + FunctorSlash = FuncAdjust(FunctorSlash); + FunctorStaticClause = FuncAdjust(FunctorStaticClause); + FunctorStream = FuncAdjust(FunctorStream); + FunctorStreamEOS = FuncAdjust(FunctorStreamEOS); + FunctorStreamPos = FuncAdjust(FunctorStreamPos); + FunctorThreadRun = FuncAdjust(FunctorThreadRun); + FunctorThrow = FuncAdjust(FunctorThrow); + FunctorUMinus = FuncAdjust(FunctorUMinus); + FunctorUPlus = FuncAdjust(FunctorUPlus); + FunctorVBar = FuncAdjust(FunctorVBar); + FunctorVar = FuncAdjust(FunctorVar); diff --git a/H/rheap.h b/H/rheap.h index b339b757c..86d4a6193 100644 --- a/H/rheap.h +++ b/H/rheap.h @@ -817,130 +817,7 @@ restore_codes(void) icl = icl->SiblingIndex; } } - Yap_heap_regs->atom_abol = AtomAdjust(Yap_heap_regs->atom_abol); - Yap_heap_regs->atom_append = AtomAdjust(Yap_heap_regs->atom_append); - Yap_heap_regs->atom_array = AtomAdjust(Yap_heap_regs->atom_array); - Yap_heap_regs->atom_assert = AtomAdjust(Yap_heap_regs->atom_assert); - Yap_heap_regs->atom_alarm = AtomAdjust(Yap_heap_regs->atom_alarm); -#ifdef COROUTINING - Yap_heap_regs->atom_att = AtomAdjust(Yap_heap_regs->atom_att); -#endif - Yap_heap_regs->atom_b = AtomAdjust(Yap_heap_regs->atom_b); - Yap_heap_regs->atom_break = AtomAdjust(Yap_heap_regs->atom_break); - Yap_heap_regs->atom_call = AtomAdjust(Yap_heap_regs->atom_call); - Yap_heap_regs->atom_catch = AtomAdjust(Yap_heap_regs->atom_catch); - Yap_heap_regs->atom_comma = AtomAdjust(Yap_heap_regs->atom_comma); - Yap_heap_regs->atom_cpu_time = AtomAdjust(Yap_heap_regs->atom_cpu_time); - Yap_heap_regs->atom_csult = AtomAdjust(Yap_heap_regs->atom_csult); - Yap_heap_regs->atom_cut = AtomAdjust(Yap_heap_regs->atom_cut); - Yap_heap_regs->atom_cut_by = AtomAdjust(Yap_heap_regs->atom_cut_by); -#ifdef EUROTRA -#ifdef SFUNC - Yap_heap_regs->atom_dollar_undef = AtomAdjust(Yap_heap_regs->atom_dollar_undef); -#endif -#endif - Yap_heap_regs->atom_dbref = AtomAdjust(Yap_heap_regs->atom_dbref); - Yap_heap_regs->atom_e = AtomAdjust(Yap_heap_regs->atom_e); - Yap_heap_regs->atom_e_q = AtomAdjust(Yap_heap_regs->atom_e_q); - Yap_heap_regs->atom_eof = AtomAdjust(Yap_heap_regs->atom_eof); -#ifdef EUROTRA - Yap_heap_regs->atom_f_b = AtomAdjust(Yap_heap_regs->atom_f_b); -#endif - Yap_heap_regs->atom_fail = AtomAdjust(Yap_heap_regs->atom_fail); - Yap_heap_regs->atom_false = AtomAdjust(Yap_heap_regs->atom_false); - Yap_heap_regs->atom_fast = AtomAdjust(Yap_heap_regs->atom_fast); - Yap_heap_regs->atom_g_t = AtomAdjust(Yap_heap_regs->atom_g_t); - Yap_heap_regs->atom_gc = AtomAdjust(Yap_heap_regs->atom_gc); - Yap_heap_regs->atom_gc_margin = AtomAdjust(Yap_heap_regs->atom_gc_margin); - Yap_heap_regs->atom_gc_trace = AtomAdjust(Yap_heap_regs->atom_gc_trace); - Yap_heap_regs->atom_gc_verbose = AtomAdjust(Yap_heap_regs->atom_gc_verbose); - Yap_heap_regs->atom_gc_very_verbose = AtomAdjust(Yap_heap_regs->atom_gc_very_verbose); - Yap_heap_regs->atom_global = AtomAdjust(Yap_heap_regs->atom_global); - Yap_heap_regs->atom_heap_used = AtomAdjust(Yap_heap_regs->atom_heap_used); - Yap_heap_regs->atom_inf = AtomAdjust(Yap_heap_regs->atom_inf); - Yap_heap_regs->atom_l_t = AtomAdjust(Yap_heap_regs->atom_l_t); - Yap_heap_regs->atom_local = AtomAdjust(Yap_heap_regs->atom_local); - Yap_heap_regs->atom_meta_call = AtomAdjust(Yap_heap_regs->atom_meta_call); - Yap_heap_regs->atom_minus = AtomAdjust(Yap_heap_regs->atom_minus); - Yap_heap_regs->atom_multi_file = AtomAdjust(Yap_heap_regs->atom_multi_file); - Yap_heap_regs->atom_nan = AtomAdjust(Yap_heap_regs->atom_nan); - Yap_heap_regs->atom_otherwise = AtomAdjust(Yap_heap_regs->atom_otherwise); - Yap_heap_regs->atom_pi = AtomAdjust(Yap_heap_regs->atom_pi); - Yap_heap_regs->atom_plus = AtomAdjust(Yap_heap_regs->atom_plus); - Yap_heap_regs->atom_portray = AtomAdjust(Yap_heap_regs->atom_portray); - Yap_heap_regs->atom_profile = AtomAdjust(Yap_heap_regs->atom_profile); - Yap_heap_regs->atom_random = AtomAdjust(Yap_heap_regs->atom_random); - Yap_heap_regs->atom_read = AtomAdjust(Yap_heap_regs->atom_read); - Yap_heap_regs->atom_repeat = AtomAdjust(Yap_heap_regs->atom_repeat); - Yap_heap_regs->atom_restore_regs = AtomAdjust(Yap_heap_regs->atom_restore_regs); -#if HAVE_SIGACTION - Yap_heap_regs->atom_sig_pending = AtomAdjust(Yap_heap_regs->atom_sig_pending); -#endif - Yap_heap_regs->atom_stack_free = AtomAdjust(Yap_heap_regs->atom_stack_free); - Yap_heap_regs->atom_true = AtomAdjust(Yap_heap_regs->atom_true); - Yap_heap_regs->atom_user = AtomAdjust(Yap_heap_regs->atom_user); - Yap_heap_regs->atom_usr_err = AtomAdjust(Yap_heap_regs->atom_usr_err); - Yap_heap_regs->atom_usr_in = AtomAdjust(Yap_heap_regs->atom_usr_in); - Yap_heap_regs->atom_usr_out = AtomAdjust(Yap_heap_regs->atom_usr_out); - Yap_heap_regs->atom_version_number = AtomAdjust(Yap_heap_regs->atom_version_number); - Yap_heap_regs->atom_write = AtomAdjust(Yap_heap_regs->atom_write); - Yap_heap_regs->float_format = AtomAdjust(Yap_heap_regs->float_format); -#ifdef USE_SOCKET - Yap_heap_regs->functor_af_inet = FuncAdjust(Yap_heap_regs->functor_af_inet); - Yap_heap_regs->functor_af_local = FuncAdjust(Yap_heap_regs->functor_af_local); - Yap_heap_regs->functor_af_unix = FuncAdjust(Yap_heap_regs->functor_af_unix); -#endif - Yap_heap_regs->functor_alt_not = FuncAdjust(Yap_heap_regs->functor_alt_not); - Yap_heap_regs->functor_arrow = FuncAdjust(Yap_heap_regs->functor_arrow); - Yap_heap_regs->functor_assert = FuncAdjust(Yap_heap_regs->functor_assert); - Yap_heap_regs->functor_at_found_one = FuncAdjust(Yap_heap_regs->functor_at_found_one); - Yap_heap_regs->functor_atom = FuncAdjust(Yap_heap_regs->functor_atom); -#ifdef COROUTINING - Yap_heap_regs->functor_att_goal = FuncAdjust(Yap_heap_regs->functor_att_goal); -#endif - Yap_heap_regs->functor_braces = FuncAdjust(Yap_heap_regs->functor_braces); - Yap_heap_regs->functor_call = FuncAdjust(Yap_heap_regs->functor_call); - Yap_heap_regs->functor_cut_by = FuncAdjust(Yap_heap_regs->functor_cut_by); - Yap_heap_regs->functor_comma = FuncAdjust(Yap_heap_regs->functor_comma); - Yap_heap_regs->functor_creep = FuncAdjust(Yap_heap_regs->functor_creep); - Yap_heap_regs->functor_csult = FuncAdjust(Yap_heap_regs->functor_csult); - Yap_heap_regs->functor_dot = FuncAdjust(Yap_heap_regs->functor_dot); - Yap_heap_regs->functor_eq = FuncAdjust(Yap_heap_regs->functor_eq); - Yap_heap_regs->functor_execute_in_mod = FuncAdjust(Yap_heap_regs->functor_execute_in_mod); - Yap_heap_regs->functor_execute2_in_mod = FuncAdjust(Yap_heap_regs->functor_execute2_in_mod); - Yap_heap_regs->functor_execute_within = FuncAdjust(Yap_heap_regs->functor_execute_within); - Yap_heap_regs->functor_g_atom = FuncAdjust(Yap_heap_regs->functor_g_atom); - Yap_heap_regs->functor_g_atomic = FuncAdjust(Yap_heap_regs->functor_g_atomic); - Yap_heap_regs->functor_g_compound = FuncAdjust(Yap_heap_regs->functor_g_compound); - Yap_heap_regs->functor_g_float = FuncAdjust(Yap_heap_regs->functor_g_float); - Yap_heap_regs->functor_g_format_at = FuncAdjust(Yap_heap_regs->functor_g_format_at); - Yap_heap_regs->functor_g_integer = FuncAdjust(Yap_heap_regs->functor_g_integer); - Yap_heap_regs->functor_g_number = FuncAdjust(Yap_heap_regs->functor_g_number); - Yap_heap_regs->functor_g_primitive = FuncAdjust(Yap_heap_regs->functor_g_primitive); - Yap_heap_regs->functor_g_var = FuncAdjust(Yap_heap_regs->functor_g_var); - Yap_heap_regs->functor_last_execute_within = FuncAdjust(Yap_heap_regs->functor_last_execute_within); - Yap_heap_regs->functor_list = FuncAdjust(Yap_heap_regs->functor_list); - Yap_heap_regs->functor_mega_clause = FuncAdjust(Yap_heap_regs->functor_mega_clause); - Yap_heap_regs->functor_module = FuncAdjust(Yap_heap_regs->functor_module); - Yap_heap_regs->functor_multi_file_clause = FuncAdjust(Yap_heap_regs->functor_multi_file_clause); -#ifdef MULTI_ASSIGNMENT_VARIABLES - Yap_heap_regs->functor_mutable = FuncAdjust(Yap_heap_regs->functor_mutable); -#endif - Yap_heap_regs->functor_nb_queue = FuncAdjust(Yap_heap_regs->functor_nb_queue); - Yap_heap_regs->functor_not = FuncAdjust(Yap_heap_regs->functor_not); - Yap_heap_regs->functor_or = FuncAdjust(Yap_heap_regs->functor_or); - Yap_heap_regs->functor_portray = FuncAdjust(Yap_heap_regs->functor_portray); - Yap_heap_regs->functor_query = FuncAdjust(Yap_heap_regs->functor_query); - Yap_heap_regs->functor_static_clause = FuncAdjust(Yap_heap_regs->functor_static_clause); - Yap_heap_regs->functor_stream = FuncAdjust(Yap_heap_regs->functor_stream); - Yap_heap_regs->functor_stream_pos = FuncAdjust(Yap_heap_regs->functor_stream_pos); - Yap_heap_regs->functor_stream_eOS = FuncAdjust(Yap_heap_regs->functor_stream_eOS); - Yap_heap_regs->functor_change_module = FuncAdjust(Yap_heap_regs->functor_change_module); - Yap_heap_regs->functor_current_module = FuncAdjust(Yap_heap_regs->functor_current_module); - Yap_heap_regs->functor_u_minus = FuncAdjust(Yap_heap_regs->functor_u_minus); - Yap_heap_regs->functor_u_plus = FuncAdjust(Yap_heap_regs->functor_u_plus); - Yap_heap_regs->functor_v_bar = FuncAdjust(Yap_heap_regs->functor_v_bar); - Yap_heap_regs->functor_var = FuncAdjust(Yap_heap_regs->functor_var); +#include "ratoms.h" #ifdef EUROTRA Yap_heap_regs->term_dollar_u = AtomTermAdjust(Yap_heap_regs->term_dollar_u); #endif diff --git a/H/tatoms.h b/H/tatoms.h new file mode 100644 index 000000000..05d995d48 --- /dev/null +++ b/H/tatoms.h @@ -0,0 +1,688 @@ + Atom Atom3Dots_; +#define Atom3Dots Yap_heap_regs->Atom3Dots_ + Atom AtomAbol_; +#define AtomAbol Yap_heap_regs->AtomAbol_ + Atom AtomAccess_; +#define AtomAccess Yap_heap_regs->AtomAccess_ + Atom AtomAfInet_; +#define AtomAfInet Yap_heap_regs->AtomAfInet_ + Atom AtomAfLocal_; +#define AtomAfLocal Yap_heap_regs->AtomAfLocal_ + Atom AtomAfUnix_; +#define AtomAfUnix Yap_heap_regs->AtomAfUnix_ + Atom AtomAlarm_; +#define AtomAlarm Yap_heap_regs->AtomAlarm_ + Atom AtomAlias_; +#define AtomAlias Yap_heap_regs->AtomAlias_ + Atom AtomAltNot_; +#define AtomAltNot Yap_heap_regs->AtomAltNot_ + Atom AtomAppend_; +#define AtomAppend Yap_heap_regs->AtomAppend_ + Atom AtomArg_; +#define AtomArg Yap_heap_regs->AtomArg_ + Atom AtomArray_; +#define AtomArray Yap_heap_regs->AtomArray_ + Atom AtomArrayAccess_; +#define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_ + Atom AtomArrayOverflow_; +#define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_ + Atom AtomArrayType_; +#define AtomArrayType Yap_heap_regs->AtomArrayType_ + Atom AtomArrow_; +#define AtomArrow Yap_heap_regs->AtomArrow_ + Atom AtomAssert_; +#define AtomAssert Yap_heap_regs->AtomAssert_ + Atom AtomAt_; +#define AtomAt Yap_heap_regs->AtomAt_ + Atom AtomAtom_; +#define AtomAtom Yap_heap_regs->AtomAtom_ + Atom AtomAtomic_; +#define AtomAtomic Yap_heap_regs->AtomAtomic_ + Atom AtomAtt_; +#define AtomAtt Yap_heap_regs->AtomAtt_ + Atom AtomAtt1_; +#define AtomAtt1 Yap_heap_regs->AtomAtt1_ + Atom AtomAttDo_; +#define AtomAttDo Yap_heap_regs->AtomAttDo_ + Atom AtomAttributes_; +#define AtomAttributes Yap_heap_regs->AtomAttributes_ + Atom AtomB_; +#define AtomB Yap_heap_regs->AtomB_ + Atom AtomBatched_; +#define AtomBatched Yap_heap_regs->AtomBatched_ + Atom AtomBetween_; +#define AtomBetween Yap_heap_regs->AtomBetween_ + Atom AtomBinaryStream_; +#define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_ + Atom AtomBraces_; +#define AtomBraces Yap_heap_regs->AtomBraces_ + Atom AtomBreak_; +#define AtomBreak Yap_heap_regs->AtomBreak_ + Atom AtomByte_; +#define AtomByte Yap_heap_regs->AtomByte_ + Atom AtomCArith_; +#define AtomCArith Yap_heap_regs->AtomCArith_ + Atom AtomCall_; +#define AtomCall Yap_heap_regs->AtomCall_ + Atom AtomCallAndRetryCounter_; +#define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_ + Atom AtomCallCounter_; +#define AtomCallCounter Yap_heap_regs->AtomCallCounter_ + Atom AtomCallable_; +#define AtomCallable Yap_heap_regs->AtomCallable_ + Atom AtomCatch_; +#define AtomCatch Yap_heap_regs->AtomCatch_ + Atom AtomChangeModule_; +#define AtomChangeModule Yap_heap_regs->AtomChangeModule_ + Atom AtomChar_; +#define AtomChar Yap_heap_regs->AtomChar_ + Atom AtomCharacter_; +#define AtomCharacter Yap_heap_regs->AtomCharacter_ + Atom AtomCharacterCode_; +#define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_ + Atom AtomCharsio_; +#define AtomCharsio Yap_heap_regs->AtomCharsio_ + Atom AtomColomn_; +#define AtomColomn Yap_heap_regs->AtomColomn_ + Atom AtomComma_; +#define AtomComma Yap_heap_regs->AtomComma_ + Atom AtomCompound_; +#define AtomCompound Yap_heap_regs->AtomCompound_ + Atom AtomConsistencyError_; +#define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_ + Atom AtomConsultOnBoot_; +#define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_ + Atom AtomCputime_; +#define AtomCputime Yap_heap_regs->AtomCputime_ + Atom AtomCreate_; +#define AtomCreate Yap_heap_regs->AtomCreate_ + Atom AtomCreep_; +#define AtomCreep Yap_heap_regs->AtomCreep_ + Atom AtomCryptAtoms_; +#define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_ + Atom AtomCsult_; +#define AtomCsult Yap_heap_regs->AtomCsult_ + Atom AtomCurrentModule_; +#define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_ + Atom AtomCut_; +#define AtomCut Yap_heap_regs->AtomCut_ + Atom AtomCutBy_; +#define AtomCutBy Yap_heap_regs->AtomCutBy_ + Atom AtomDAbort_; +#define AtomDAbort Yap_heap_regs->AtomDAbort_ + Atom AtomDBREF_; +#define AtomDBREF Yap_heap_regs->AtomDBREF_ + Atom AtomDBReference_; +#define AtomDBReference Yap_heap_regs->AtomDBReference_ + Atom AtomDBTerm_; +#define AtomDBTerm Yap_heap_regs->AtomDBTerm_ + Atom AtomDBref_; +#define AtomDBref Yap_heap_regs->AtomDBref_ + Atom AtomDInteger_; +#define AtomDInteger Yap_heap_regs->AtomDInteger_ + Atom AtomDOUBLE_; +#define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_ + Atom AtomDec10_; +#define AtomDec10 Yap_heap_regs->AtomDec10_ + Atom AtomDefault_; +#define AtomDefault Yap_heap_regs->AtomDefault_ + Atom AtomDevNull_; +#define AtomDevNull Yap_heap_regs->AtomDevNull_ + Atom AtomDiff_; +#define AtomDiff Yap_heap_regs->AtomDiff_ + Atom AtomDoLogUpdClause_; +#define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_ + Atom AtomDoLogUpdClause0_; +#define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_ + Atom AtomDoLogUpdClauseErase_; +#define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_ + Atom AtomDoStaticClause_; +#define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_ + Atom AtomDollarU_; +#define AtomDollarU Yap_heap_regs->AtomDollarU_ + Atom AtomDollarUndef_; +#define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_ + Atom AtomDomainError_; +#define AtomDomainError Yap_heap_regs->AtomDomainError_ + Atom AtomE_; +#define AtomE Yap_heap_regs->AtomE_ + Atom AtomEOFBeforeEOT_; +#define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_ + Atom AtomEQ_; +#define AtomEQ Yap_heap_regs->AtomEQ_ + Atom AtomEmptyAtom_; +#define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_ + Atom AtomEndOfStream_; +#define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_ + Atom AtomEof_; +#define AtomEof Yap_heap_regs->AtomEof_ + Atom AtomEq_; +#define AtomEq Yap_heap_regs->AtomEq_ + Atom AtomError_; +#define AtomError Yap_heap_regs->AtomError_ + Atom AtomEvaluable_; +#define AtomEvaluable Yap_heap_regs->AtomEvaluable_ + Atom AtomEvaluationError_; +#define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_ + Atom AtomExecAnswers_; +#define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_ + Atom AtomExecuteInMod_; +#define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_ + Atom AtomExecuteWithin_; +#define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_ + Atom AtomExecuteWoMod_; +#define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_ + Atom AtomExistenceError_; +#define AtomExistenceError Yap_heap_regs->AtomExistenceError_ + Atom AtomExpectedNumber_; +#define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_ + Atom AtomExtendFileSearchPath_; +#define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_ + Atom AtomFB_; +#define AtomFB Yap_heap_regs->AtomFB_ + Atom AtomFail_; +#define AtomFail Yap_heap_regs->AtomFail_ + Atom AtomFalse_; +#define AtomFalse Yap_heap_regs->AtomFalse_ + Atom AtomFast_; +#define AtomFast Yap_heap_regs->AtomFast_ + Atom AtomFileerrors_; +#define AtomFileerrors Yap_heap_regs->AtomFileerrors_ + Atom AtomFloat_; +#define AtomFloat Yap_heap_regs->AtomFloat_ + Atom AtomFloatFormat_; +#define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_ + Atom AtomFloatOverflow_; +#define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_ + Atom AtomFloatUnderflow_; +#define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_ + Atom AtomFormat_; +#define AtomFormat Yap_heap_regs->AtomFormat_ + Atom AtomFormatAt_; +#define AtomFormatAt Yap_heap_regs->AtomFormatAt_ + Atom AtomFunctor_; +#define AtomFunctor Yap_heap_regs->AtomFunctor_ + Atom AtomGT_; +#define AtomGT Yap_heap_regs->AtomGT_ + Atom AtomGVar_; +#define AtomGVar Yap_heap_regs->AtomGVar_ + Atom AtomGc_; +#define AtomGc Yap_heap_regs->AtomGc_ + Atom AtomGcMargin_; +#define AtomGcMargin Yap_heap_regs->AtomGcMargin_ + Atom AtomGcTrace_; +#define AtomGcTrace Yap_heap_regs->AtomGcTrace_ + Atom AtomGcVerbose_; +#define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_ + Atom AtomGcVeryVerbose_; +#define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_ + Atom AtomGeneratePredInfo_; +#define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_ + Atom AtomGetwork_; +#define AtomGetwork Yap_heap_regs->AtomGetwork_ + Atom AtomGetworkSeq_; +#define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_ + Atom AtomGlobal_; +#define AtomGlobal Yap_heap_regs->AtomGlobal_ + Atom AtomGoalExpansion_; +#define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_ + Atom AtomHERE_; +#define AtomHERE Yap_heap_regs->AtomHERE_ + Atom AtomHandleThrow_; +#define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_ + Atom AtomHeap_; +#define AtomHeap Yap_heap_regs->AtomHeap_ + Atom AtomHeapUsed_; +#define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_ + Atom AtomIDB_; +#define AtomIDB Yap_heap_regs->AtomIDB_ + Atom AtomIOMode_; +#define AtomIOMode Yap_heap_regs->AtomIOMode_ + Atom AtomId_; +#define AtomId Yap_heap_regs->AtomId_ + Atom AtomInf_; +#define AtomInf Yap_heap_regs->AtomInf_ + Atom AtomInitGoal_; +#define AtomInitGoal Yap_heap_regs->AtomInitGoal_ + Atom AtomInput_; +#define AtomInput Yap_heap_regs->AtomInput_ + Atom AtomInstantiationError_; +#define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_ + Atom AtomInt_; +#define AtomInt Yap_heap_regs->AtomInt_ + Atom AtomIntOverflow_; +#define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_ + Atom AtomInteger_; +#define AtomInteger Yap_heap_regs->AtomInteger_ + Atom AtomInternalCompilerError_; +#define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_ + Atom AtomKey_; +#define AtomKey Yap_heap_regs->AtomKey_ + Atom AtomLDLibraryPath_; +#define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_ + Atom AtomLONGINT_; +#define AtomLONGINT Yap_heap_regs->AtomLONGINT_ + Atom AtomLT_; +#define AtomLT Yap_heap_regs->AtomLT_ + Atom AtomLastExecuteWithin_; +#define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_ + Atom AtomLeash_; +#define AtomLeash Yap_heap_regs->AtomLeash_ + Atom AtomList_; +#define AtomList Yap_heap_regs->AtomList_ + Atom AtomLive_; +#define AtomLive Yap_heap_regs->AtomLive_ + Atom AtomLoadAnswers_; +#define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_ + Atom AtomLocal_; +#define AtomLocal Yap_heap_regs->AtomLocal_ + Atom AtomLocalA_; +#define AtomLocalA Yap_heap_regs->AtomLocalA_ + Atom AtomMaxArity_; +#define AtomMaxArity Yap_heap_regs->AtomMaxArity_ + Atom AtomMegaClause_; +#define AtomMegaClause Yap_heap_regs->AtomMegaClause_ + Atom AtomMetaCall_; +#define AtomMetaCall Yap_heap_regs->AtomMetaCall_ + Atom AtomMfClause_; +#define AtomMfClause Yap_heap_regs->AtomMfClause_ + Atom AtomMinus_; +#define AtomMinus Yap_heap_regs->AtomMinus_ + Atom AtomModify_; +#define AtomModify Yap_heap_regs->AtomModify_ + Atom AtomMultiFile_; +#define AtomMultiFile Yap_heap_regs->AtomMultiFile_ + Atom AtomMutable_; +#define AtomMutable Yap_heap_regs->AtomMutable_ + Atom AtomMutableVariable_; +#define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_ + Atom AtomMyddasDB_; +#define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_ + Atom AtomMyddasGoal_; +#define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_ + Atom AtomMyddasHost_; +#define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_ + Atom AtomMyddasPass_; +#define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_ + Atom AtomMyddasUser_; +#define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_ + Atom AtomMyddasVersionName_; +#define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_ + Atom AtomNan_; +#define AtomNan Yap_heap_regs->AtomNan_ + Atom AtomNb_; +#define AtomNb Yap_heap_regs->AtomNb_ + Atom AtomNbTerm_; +#define AtomNbTerm Yap_heap_regs->AtomNbTerm_ + Atom AtomNew_; +#define AtomNew Yap_heap_regs->AtomNew_ + Atom AtomNonEmptyList_; +#define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_ + Atom AtomNot_; +#define AtomNot Yap_heap_regs->AtomNot_ + Atom AtomNotLessThanZero_; +#define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_ + Atom AtomNotNewline_; +#define AtomNotNewline Yap_heap_regs->AtomNotNewline_ + Atom AtomNotZero_; +#define AtomNotZero Yap_heap_regs->AtomNotZero_ + Atom AtomNumber_; +#define AtomNumber Yap_heap_regs->AtomNumber_ + Atom AtomOff_; +#define AtomOff Yap_heap_regs->AtomOff_ + Atom AtomOffline_; +#define AtomOffline Yap_heap_regs->AtomOffline_ + Atom AtomOn_; +#define AtomOn Yap_heap_regs->AtomOn_ + Atom AtomOnline_; +#define AtomOnline Yap_heap_regs->AtomOnline_ + Atom AtomOpen_; +#define AtomOpen Yap_heap_regs->AtomOpen_ + Atom AtomOperatingSystemError_; +#define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_ + Atom AtomOperator_; +#define AtomOperator Yap_heap_regs->AtomOperator_ + Atom AtomOperatorPriority_; +#define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_ + Atom AtomOperatorSpecifier_; +#define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_ + Atom AtomOtherwise_; +#define AtomOtherwise Yap_heap_regs->AtomOtherwise_ + Atom AtomOutOfAttvarsError_; +#define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_ + Atom AtomOutOfAuxspaceError_; +#define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_ + Atom AtomOutOfHeapError_; +#define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_ + Atom AtomOutOfRange_; +#define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_ + Atom AtomOutOfStackError_; +#define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_ + Atom AtomOutOfTrailError_; +#define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_ + Atom AtomOutput_; +#define AtomOutput Yap_heap_regs->AtomOutput_ + Atom AtomPastEndOfStream_; +#define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_ + Atom AtomPermissionError_; +#define AtomPermissionError Yap_heap_regs->AtomPermissionError_ + Atom AtomPi_; +#define AtomPi Yap_heap_regs->AtomPi_ + Atom AtomPipe_; +#define AtomPipe Yap_heap_regs->AtomPipe_ + Atom AtomPlus_; +#define AtomPlus Yap_heap_regs->AtomPlus_ + Atom AtomPointer_; +#define AtomPointer Yap_heap_regs->AtomPointer_ + Atom AtomPortray_; +#define AtomPortray Yap_heap_regs->AtomPortray_ + Atom AtomPredicateIndicator_; +#define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_ + Atom AtomPrimitive_; +#define AtomPrimitive Yap_heap_regs->AtomPrimitive_ + Atom AtomPrivateProcedure_; +#define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_ + Atom AtomProfile_; +#define AtomProfile Yap_heap_regs->AtomProfile_ + Atom AtomProlog_; +#define AtomProlog Yap_heap_regs->AtomProlog_ + Atom AtomPtr_; +#define AtomPtr Yap_heap_regs->AtomPtr_ + Atom AtomQuery_; +#define AtomQuery Yap_heap_regs->AtomQuery_ + Atom AtomQueue_; +#define AtomQueue Yap_heap_regs->AtomQueue_ + Atom AtomQuiet_; +#define AtomQuiet Yap_heap_regs->AtomQuiet_ + Atom AtomRadix_; +#define AtomRadix Yap_heap_regs->AtomRadix_ + Atom AtomRandom_; +#define AtomRandom Yap_heap_regs->AtomRandom_ + Atom AtomRead_; +#define AtomRead Yap_heap_regs->AtomRead_ + Atom AtomReadutil_; +#define AtomReadutil Yap_heap_regs->AtomReadutil_ + Atom AtomRecordedP_; +#define AtomRecordedP Yap_heap_regs->AtomRecordedP_ + Atom AtomRecordedWithKey_; +#define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_ + Atom AtomRefoundVar_; +#define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_ + Atom AtomRepeat_; +#define AtomRepeat Yap_heap_regs->AtomRepeat_ + Atom AtomRepeatSpace_; +#define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_ + Atom AtomReposition_; +#define AtomReposition Yap_heap_regs->AtomReposition_ + Atom AtomRepresentationError_; +#define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_ + Atom AtomResize_; +#define AtomResize Yap_heap_regs->AtomResize_ + Atom AtomResourceError_; +#define AtomResourceError Yap_heap_regs->AtomResourceError_ + Atom AtomRestoreRegs_; +#define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_ + Atom AtomRetryCounter_; +#define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_ + Atom AtomSame_; +#define AtomSame Yap_heap_regs->AtomSame_ + Atom AtomSemic_; +#define AtomSemic Yap_heap_regs->AtomSemic_ + Atom AtomShiftCountOverflow_; +#define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_ + Atom AtomSigAlarm_; +#define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_ + Atom AtomSigBreak_; +#define AtomSigBreak Yap_heap_regs->AtomSigBreak_ + Atom AtomSigCreep_; +#define AtomSigCreep Yap_heap_regs->AtomSigCreep_ + Atom AtomSigDebug_; +#define AtomSigDebug Yap_heap_regs->AtomSigDebug_ + Atom AtomSigDelayCreep_; +#define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_ + Atom AtomSigHup_; +#define AtomSigHup Yap_heap_regs->AtomSigHup_ + Atom AtomSigInt_; +#define AtomSigInt Yap_heap_regs->AtomSigInt_ + Atom AtomSigIti_; +#define AtomSigIti Yap_heap_regs->AtomSigIti_ + Atom AtomSigPending_; +#define AtomSigPending Yap_heap_regs->AtomSigPending_ + Atom AtomSigPipe_; +#define AtomSigPipe Yap_heap_regs->AtomSigPipe_ + Atom AtomSigStackDump_; +#define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_ + Atom AtomSigStatistics_; +#define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_ + Atom AtomSigTrace_; +#define AtomSigTrace Yap_heap_regs->AtomSigTrace_ + Atom AtomSigUsr1_; +#define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_ + Atom AtomSigUsr2_; +#define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_ + Atom AtomSigWakeUp_; +#define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_ + Atom AtomSlash_; +#define AtomSlash Yap_heap_regs->AtomSlash_ + Atom AtomSocket_; +#define AtomSocket Yap_heap_regs->AtomSocket_ + Atom AtomSourceSink_; +#define AtomSourceSink Yap_heap_regs->AtomSourceSink_ + Atom AtomSpy_; +#define AtomSpy Yap_heap_regs->AtomSpy_ + Atom AtomStackFree_; +#define AtomStackFree Yap_heap_regs->AtomStackFree_ + Atom AtomStaticClause_; +#define AtomStaticClause Yap_heap_regs->AtomStaticClause_ + Atom AtomStaticProcedure_; +#define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_ + Atom AtomStream_; +#define AtomStream Yap_heap_regs->AtomStream_ + Atom AtomStreamOrAlias_; +#define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_ + Atom AtomStreamPos_; +#define AtomStreamPos Yap_heap_regs->AtomStreamPos_ + Atom AtomStreamPosition_; +#define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_ + Atom AtomString_; +#define AtomString Yap_heap_regs->AtomString_ + Atom AtomSwi_; +#define AtomSwi Yap_heap_regs->AtomSwi_ + Atom AtomSyntaxError_; +#define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_ + Atom AtomSyntaxErrorHandler_; +#define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_ + Atom AtomSystem_; +#define AtomSystem Yap_heap_regs->AtomSystem_ + Atom AtomSystemError_; +#define AtomSystemError Yap_heap_regs->AtomSystemError_ + Atom AtomSystemLibraryDir_; +#define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_ + Atom AtomTerm_; +#define AtomTerm Yap_heap_regs->AtomTerm_ + Atom AtomTerms_; +#define AtomTerms Yap_heap_regs->AtomTerms_ + Atom AtomTextStream_; +#define AtomTextStream Yap_heap_regs->AtomTextStream_ + Atom AtomThreads_; +#define AtomThreads Yap_heap_regs->AtomThreads_ + Atom AtomThrow_; +#define AtomThrow Yap_heap_regs->AtomThrow_ + Atom AtomTimeOutSpec_; +#define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_ + Atom AtomTopLevelGoal_; +#define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_ + Atom AtomTopThreadGoal_; +#define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_ + Atom AtomTrue_; +#define AtomTrue Yap_heap_regs->AtomTrue_ + Atom AtomTty_; +#define AtomTty Yap_heap_regs->AtomTty_ + Atom AtomTtys_; +#define AtomTtys Yap_heap_regs->AtomTtys_ + Atom AtomTypeError_; +#define AtomTypeError Yap_heap_regs->AtomTypeError_ + Atom AtomUndefined_; +#define AtomUndefined Yap_heap_regs->AtomUndefined_ + Atom AtomUndefp_; +#define AtomUndefp Yap_heap_regs->AtomUndefp_ + Atom AtomUnderflow_; +#define AtomUnderflow Yap_heap_regs->AtomUnderflow_ + Atom AtomUnsignedByte_; +#define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_ + Atom AtomUnsignedChar_; +#define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_ + Atom AtomUser_; +#define AtomUser Yap_heap_regs->AtomUser_ + Atom AtomUserErr_; +#define AtomUserErr Yap_heap_regs->AtomUserErr_ + Atom AtomUserIn_; +#define AtomUserIn Yap_heap_regs->AtomUserIn_ + Atom AtomUserOut_; +#define AtomUserOut Yap_heap_regs->AtomUserOut_ + Atom AtomVBar_; +#define AtomVBar Yap_heap_regs->AtomVBar_ + Atom AtomVar_; +#define AtomVar Yap_heap_regs->AtomVar_ + Atom AtomVariable_; +#define AtomVariable Yap_heap_regs->AtomVariable_ + Atom AtomVersionNumber_; +#define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_ + Atom AtomWakeUpGoal_; +#define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_ + Atom AtomWhen_; +#define AtomWhen Yap_heap_regs->AtomWhen_ + Atom AtomWrite_; +#define AtomWrite Yap_heap_regs->AtomWrite_ + Atom AtomYapHacks_; +#define AtomYapHacks Yap_heap_regs->AtomYapHacks_ + Atom AtomZeroDivisor_; +#define AtomZeroDivisor Yap_heap_regs->AtomZeroDivisor_ + Functor FunctorAfInet_; +#define FunctorAfInet Yap_heap_regs->FunctorAfInet_ + Functor FunctorAfLocal_; +#define FunctorAfLocal Yap_heap_regs->FunctorAfLocal_ + Functor FunctorAfUnix_; +#define FunctorAfUnix Yap_heap_regs->FunctorAfUnix_ + Functor FunctorAltNot_; +#define FunctorAltNot Yap_heap_regs->FunctorAltNot_ + Functor FunctorArg_; +#define FunctorArg Yap_heap_regs->FunctorArg_ + Functor FunctorArrayEntry_; +#define FunctorArrayEntry Yap_heap_regs->FunctorArrayEntry_ + Functor FunctorArrow_; +#define FunctorArrow Yap_heap_regs->FunctorArrow_ + Functor FunctorAssert_; +#define FunctorAssert Yap_heap_regs->FunctorAssert_ + Functor FunctorAtFoundOne_; +#define FunctorAtFoundOne Yap_heap_regs->FunctorAtFoundOne_ + Functor FunctorAtom_; +#define FunctorAtom Yap_heap_regs->FunctorAtom_ + 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 FunctorChangeModule_; +#define FunctorChangeModule Yap_heap_regs->FunctorChangeModule_ + Functor FunctorClist_; +#define FunctorClist Yap_heap_regs->FunctorClist_ + Functor FunctorComma_; +#define FunctorComma Yap_heap_regs->FunctorComma_ + 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 FunctorDiff_; +#define FunctorDiff Yap_heap_regs->FunctorDiff_ + Functor FunctorDot_; +#define FunctorDot Yap_heap_regs->FunctorDot_ + Functor FunctorEq_; +#define FunctorEq Yap_heap_regs->FunctorEq_ + Functor FunctorError_; +#define FunctorError Yap_heap_regs->FunctorError_ + 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 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 FunctorId_; +#define FunctorId Yap_heap_regs->FunctorId_ + Functor FunctorLastExecuteWithin_; +#define FunctorLastExecuteWithin Yap_heap_regs->FunctorLastExecuteWithin_ + Functor FunctorList_; +#define FunctorList Yap_heap_regs->FunctorList_ + Functor FunctorMegaClause_; +#define FunctorMegaClause Yap_heap_regs->FunctorMegaClause_ + 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 FunctorNBQueue_; +#define FunctorNBQueue Yap_heap_regs->FunctorNBQueue_ + Functor FunctorNot_; +#define FunctorNot Yap_heap_regs->FunctorNot_ + Functor FunctorOr_; +#define FunctorOr Yap_heap_regs->FunctorOr_ + Functor FunctorPortray_; +#define FunctorPortray Yap_heap_regs->FunctorPortray_ + Functor FunctorQuery_; +#define FunctorQuery Yap_heap_regs->FunctorQuery_ + Functor FunctorRestoreRegs_; +#define FunctorRestoreRegs Yap_heap_regs->FunctorRestoreRegs_ + Functor FunctorRestoreRegs1_; +#define FunctorRestoreRegs1 Yap_heap_regs->FunctorRestoreRegs1_ + 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 FunctorThreadRun_; +#define FunctorThreadRun Yap_heap_regs->FunctorThreadRun_ + Functor FunctorThrow_; +#define FunctorThrow Yap_heap_regs->FunctorThrow_ + Functor FunctorUMinus_; +#define FunctorUMinus Yap_heap_regs->FunctorUMinus_ + Functor FunctorUPlus_; +#define FunctorUPlus Yap_heap_regs->FunctorUPlus_ + Functor FunctorVBar_; +#define FunctorVBar Yap_heap_regs->FunctorVBar_ + Functor FunctorVar_; +#define FunctorVar Yap_heap_regs->FunctorVar_ diff --git a/LGPL/PLStream/buildatoms b/LGPL/PLStream/buildatoms index ec3de1e96..3b1014046 100644 --- a/LGPL/PLStream/buildatoms +++ b/LGPL/PLStream/buildatoms @@ -11,7 +11,7 @@ :- yap_flag(write_strings,on). main :- - file_filter('ATOMS','atoms.h',gen_decl). + file_filter('ATOMS','../H/atoms.h',gen_decl). gen_decl(Inp,Out) :- split(Inp," ",["A",Atom,String]), !, @@ -30,6 +30,3 @@ counter(I) :- I1 is I+1, nb_setval(count,I1). - - - diff --git a/Makefile.in b/Makefile.in index 59a257b0f..ffcf92367 100644 --- a/Makefile.in +++ b/Makefile.in @@ -131,6 +131,7 @@ HEADERS = \ $(srcdir)/OPTYap/alpha_locks_funcs.h \ $(srcdir)/OPTYap/pthread_locks.h \ $(srcdir)/H/cut_c.h \ + $(srcdir)/H/iatoms.h $(srcdir)/H/ratoms.h $(srcdir)/H/tatoms.h \ $(srcdir)/MYDDAS/myddas.h $(srcdir)/MYDDAS/myddas_structs.h \ $(srcdir)/MYDDAS/myddas_statistics.h \ $(srcdir)/MYDDAS/myddas_statistics_structs.h \ diff --git a/misc/ATOMS b/misc/ATOMS new file mode 100644 index 000000000..dab7e0845 --- /dev/null +++ b/misc/ATOMS @@ -0,0 +1,351 @@ +// +// Atoms are of the form A Name Normal,FullLookup,String +// Notice that no spaces are allowed +// +// This is supported by YAP directly +// A Dot N "." +// +A 3Dots N "..." +A Abol F "$abol" +A Access N "access" +A AfInet N "AF_INET" +A AfLocal N "AF_LOCAL" +A AfUnix N "AF_UNIX" +A Alarm F "$alarm" +A Alias N "alias" +A AltNot N "not" +A Append N "append" +A Arg N "arg" +A Array N "array" +A ArrayAccess F "$array_arg" +A ArrayOverflow N "array_overflow" +A ArrayType N "array_type" +A Arrow N "->" +A Assert N ":-" +A At N "at" +A Atom N "atom" +A Atomic N "atomic" +A Att F "$att" +A Att1 N "att" +A AttDo F "$att_do" +A Attributes N "attributes" +A B F "$last_choice_pt" +A Batched N "batched" +A Between N "between" +A BinaryStream N "binary_stream" +A Braces N "{}" +A Break F "$break" +A Byte N "byte" +A CArith F "$c_arith" +A Call N "call" +A CallAndRetryCounter N "call_and_retry_counter" +A CallCounter N "call_counter" +A Callable N "callable" +A Catch F "$catch" +A ChangeModule F "$change_module" +A Char N "char" +A Character N "character" +A CharacterCode N "character_code" +A Charsio N "charsio" +A Colomn N ":" +A Comma N "," +A Compound N "compound" +A ConsistencyError N "consistency_error" +A ConsultOnBoot F "$consult_on_boot" +A Cputime N "cputime" +A Create N "create" +A Creep F "$creep" +A CryptAtoms N "crypt_atoms" +A Csult F "$csult" +A CurrentModule F "$current_module" +A Cut N "!" +A CutBy F "$cut_by" +A DAbort F "$abort" +A DBREF A "DBRef" +A DBReference N "db_reference" +A DBTerm N "db_term" +A DBref F "$dbref" +A DInteger F "$integer" +A DOUBLE A "Double" +A Dec10 N "dec10" +A Default N "default" +A DevNull N "/dev/null" +A Diff N "\\=" +A DoLogUpdClause F "$do_log_upd_clause" +A DoLogUpdClause0 F "$do_log_upd_clause0" +A DoLogUpdClauseErase F "$do_log_upd_clause_erase" +A DoStaticClause F "$do_static_clause" +A DollarU N "$u" +A DollarUndef F "$undef" +A DomainError N "domain_error" +A E N "e" +A EOFBeforeEOT N "end_of_file_found_before_end_of_term" +A EQ N "=" +A EmptyAtom N "" +A EndOfStream N "$end_of_stream" +A Eof N "end_of_file" +A Eq N "=" +A Error N "error" +A Evaluable N "evaluable" +A EvaluationError N "evaluation_error" +A ExecAnswers N "exec_answers" +A ExecuteInMod F "$execute_in_mod" +A ExecuteWithin F "$execute_within" +A ExecuteWoMod F "$execute_wo_mod" +A ExistenceError N "existence_error" +A ExpectedNumber N "expected_number_syntax" +A ExtendFileSearchPath F "$extend_file_search_path" +A FB N "fb" +A Fail N "fail" +A False N "false" +A Fast F "$fast" +A Fileerrors N "fileerrors" +A Float N "float" +A FloatFormat N "\%.15g" +A FloatOverflow N "float_overflow" +A FloatUnderflow N "float_underflow" +A Format N "format" +A FormatAt F "$format@" +A Functor N "functor" +A GT N ">" +A GVar N "var" +A Gc F "$gc" +A GcMargin F "$gc_margin" +A GcTrace F "$gc_trace" +A GcVerbose F "$gc_verbose" +A GcVeryVerbose F "$gc_very_verbose" +A GeneratePredInfo F "$generate_pred_info" +A Getwork F "$getwork" +A GetworkSeq F "$getwork_seq" +A Global N "global_sp" +A GoalExpansion N "goal_expansion" +A HERE N "\n<====HERE====>\n" +A HandleThrow F "$handle_throw" +A Heap N "heap" +A HeapUsed N "heapused" +A IDB N "idb" +A IOMode N "io_mode" +A Id N "id" +A Inf N "inf" +A InitGoal F "$init_goal" +A Input N "input" +A InstantiationError N "instantiation_error" +A Int N "int" +A IntOverflow N "int_overflow" +A Integer N "integer" +A InternalCompilerError N "internal_compiler_error" +A Key N "key" +A LDLibraryPath N "LD_LIBRARY_PATH" +A LONGINT A "LongInt" +A LT N "<" +A LastExecuteWithin F "$last_execute_within" +A Leash F "$leash" +A List N "list" +A Live F "$live" +A LoadAnswers N "load_answers" +A Local N "local_sp" +A LocalA N "local" +A MaxArity N "max_arity" +A MegaClause F "$mega_clause" +A MetaCall F "$call" +A MfClause F "$mf_clause" +A Minus N "-" +A Modify N "modify" +A MultiFile F "$multi_file" +A Mutable N "mutable" +A MutableVariable F "$mutable_variable" +A MyddasDB F "$myddas_db" +A MyddasGoal F "$myddas_goal" +A MyddasHost F "$myddas_host" +A MyddasPass F "$myddas_pass" +A MyddasUser F "$myddas_user" +A MyddasVersionName F "$myddas_version_name" +A Nan N "nan" +A Nb N "nb" +A NbTerm N "nb_term" +A New N "new" +A NonEmptyList N "non_empty_list" +A Not N "\\+" +A NotLessThanZero N "not_less_than_zero" +A NotNewline N "not_newline" +A NotZero N "not_zero" +A Number N "number" +A Off N "off" +A Offline N "offline" +A On N "on" +A Online N "online" +A Open N "open" +A OperatingSystemError N "operating_system_error" +A Operator N "operator" +A OperatorPriority N "operator_priority" +A OperatorSpecifier N "operator_specifier" +A Otherwise N "otherwise" +A OutOfAttvarsError N "out_of_attvars_error" +A OutOfAuxspaceError N "out_of_auxspace_error" +A OutOfHeapError N "out_of_heap_error" +A OutOfRange N "out_of_range" +A OutOfStackError N "out_of_stack_error" +A OutOfTrailError N "out_of_trail_error" +A Output N "output" +A PastEndOfStream N "past_end_of_stream" +A PermissionError N "permission_error" +A Pi N "pi" +A Pipe N "pipe" +A Plus N "+" +A Pointer N "pointer" +A Portray F "$portray" +A PredicateIndicator N "predicate_indicator" +A Primitive N "primitive" +A PrivateProcedure N "private_procedure" +A Profile F "$profile" +A Prolog N "prolog" +A Ptr N "ptr" +A Query N "?-" +A Queue N "queue" +A Quiet N "quiet" +A Radix N "radix" +A Random N "random" +A Read N "read" +A Readutil N "readutil" +A RecordedP F "$recordep" +A RecordedWithKey F "$recorded_with_key" +A RefoundVar F "$I_FOUND_THE_VARIABLE_AGAIN" +A Repeat N "repeat" +A RepeatSpace N "repeat" +A Reposition N "reposition" +A RepresentationError N "representation_error" +A Resize N "resize" +A ResourceError N "resource_error" +A RestoreRegs F "$restore_regs" +A RetryCounter N "retry_counter" +A Same N "==" +A Semic N ";" +A ShiftCountOverflow N "shift_count_overflow" +A SigAlarm N "sig_alarm" +A SigBreak N "sig_break" +A SigCreep N "sig_creep" +A SigDebug N "sig_debug" +A SigDelayCreep N "sig_delay_creep" +A SigHup N "sig_hup" +A SigInt N "sig_int" +A SigIti N "sig_iti" +A SigPending F "$sig_pending" +A SigPipe N "sig_pipe" +A SigStackDump N "sig_stack_dump" +A SigStatistics N "sig_statistic" +A SigTrace N "sig_trace" +A SigUsr1 N "sig_usr1" +A SigUsr2 N "sig_usr2" +A SigWakeUp N "sig_wake_up" +A Slash N "/" +A Socket N "socket" +A SourceSink N "source_sink" +A Spy F "$spy" +A StackFree N "stackfree" +A StaticClause F "$static_clause" +A StaticProcedure N "static_procedure" +A Stream F "$stream" +A StreamOrAlias N "stream_or_alias" +A StreamPos F "$stream_position" +A StreamPosition N "stream_position" +A String N "string" +A Swi N "swi" +A SyntaxError N "syntax_error" +A SyntaxErrorHandler N "syntax_error_handler" +A System N "system" +A SystemError N "system_error" +A SystemLibraryDir N "system_library_directory" +A Term N "term" +A Terms N "terms" +A TextStream N "text_stream" +A Threads N "threads" +A Throw N "throw" +A TimeOutSpec N "time_out_spec" +A TopLevelGoal F "$top_level_goal" +A TopThreadGoal F "$top_thread_goal" +A True N "true" +A Tty N "tty" +A Ttys N "ttys" +A TypeError N "type_error" +A Undefined N "undefined" +A Undefp F "$undefp" +A Underflow N "underflow" +A UnsignedByte N "unsigned_byte" +A UnsignedChar N "unsigned_char" +A User N "user" +A UserErr N "user_error" +A UserIn N "user_input" +A UserOut N "user_output" +A VBar N "|" +A Var F "$VAR" +A Variable N "variable" +A VersionNumber F "$version_name" +A WakeUpGoal F "$wake_up_goal" +A When F "$when" +A Write N "write" +A YapHacks N "yap_hacks" +A ZeroDivisor N "zero_divisor" +F AfInet AfInet 2 +F AfLocal AfLocal 1 +F AfUnix AfUnix 1 +F AltNot AltNot 1 +F Arg Arg 3 +F ArrayEntry ArrayAccess 3 +F Arrow Arrow 2 +F Assert Assert 2 +F AtFoundOne FoundVar 2 +F Atom Atom 1 +F AttGoal AttDo 2 +F Braces Braces 1 +F Call Call 1 +F ChangeModule ChangeModule 1 +F Clist When 4 +F Comma Comma 2 +F Creep Creep 1 +F Csult Csult 1 +F CurrentModule CurrentModule 1 +F CutBy CutBy 1 +F Diff Diff 2 +F Dot Dot 2 +F Eq Eq 2 +F Error Error 2 +F Execute2InMod ExecuteWoMod 2 +F ExecuteInMod ExecuteInMod 2 +F ExecuteWithin ExecuteWithin 1 +F Functor Functor 3 +F GAtom Atom 1 +F GAtomic Atomic 1 +F GCompound Compound 1 +F GFloat Float 1 +F GFormatAt FormatAt 1 +F GInteger Integer 1 +F GNumber Number 1 +F GPrimitive Primitive 1 +F GVar GVar 1 +F GeneratePredInfo GeneratePredInfo 4 +F Id Id 1 +F LastExecuteWithin LastExecuteWithin 1 +F List Dot 2 +F MegaClause MegaClause 2 +F Module Colomn 2 +F MultiFileClause MfClause 5 +F Mutable MutableVariable (sizeof(timed_var)/sizeof(CELL)) +F NBQueue Queue 5 +F Not Not 1 +F Or Semic 2 +F Portray Portray 1 +F Query Query 1 +F RestoreRegs RestoreRegs 2 +F RestoreRegs1 RestoreRegs 1 +F Same Same 2 +F Slash Slash 2 +F StaticClause StaticClause 1 +F Stream Stream 1 +F StreamEOS EndOfStream 1 +F StreamPos StreamPos 5 +F ThreadRun TopThreadGoal 2 +F Throw Throw 1 +F UMinus Minus 1 +F UPlus Plus 1 +F VBar VBar 2 +F Var Var 1