diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

generate known atoms and functors automatically

Browse Source
This commit is contained in:
Vítor Santos Costa 2008-12-23 01:53:52 +00:00
parent 8efcdf7eaa
commit a8ac9bfb43
34 changed files with 2180 additions and 1003 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
C/absmi.c
View File

@ -2696,7 +2696,7 @@ Yap_absmi(int inp)
goto do_commit_b_y; goto do_commit_b_y;
} }
if (!(ActiveSignals & YAP_CREEP_SIGNAL)) { 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]; XREGS[0] = YREG[PREG->u.yp.y];
PREG = NEXTOP(PREG,yp); PREG = NEXTOP(PREG,yp);
goto creep_either; goto creep_either;
@ -2712,7 +2712,7 @@ Yap_absmi(int inp)
goto do_commit_b_x; goto do_commit_b_x;
} }
if (!(ActiveSignals & YAP_CREEP_SIGNAL)) { 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 USE_THREADED_CODE
if (PREG->opc == (OPCODE)OpAddress[_fcall]) if (PREG->opc == (OPCODE)OpAddress[_fcall])
#else #else
@ -2756,7 +2756,7 @@ Yap_absmi(int inp)
goto either_notest; goto either_notest;
} }
/* find something to fool S */ /* 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) { if (ActiveSignals & YAP_CDOVF_SIGNAL) {
ASP = (CELL *) (((char *) YREG) + PREG->u.Osbpp.s); ASP = (CELL *) (((char *) YREG) + PREG->u.Osbpp.s);
if (ASP > (CELL *)PROTECT_FROZEN_B(B)) if (ASP > (CELL *)PROTECT_FROZEN_B(B))
@ -12632,7 +12632,7 @@ Yap_absmi(int inp)
Op(p_dif, l); Op(p_dif, l);
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
BEGD(d1); BEGD(d1);
@ -12754,7 +12754,7 @@ Yap_absmi(int inp)
Op(p_eq, l); Op(p_eq, l);
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
BEGD(d1); BEGD(d1);
@ -12911,7 +12911,7 @@ Yap_absmi(int inp)
H[0] = XREG(PREG->u.xxx.x1); H[0] = XREG(PREG->u.xxx.x1);
H[1] = XREG(PREG->u.xxx.x2); H[1] = XREG(PREG->u.xxx.x2);
RESET_VARIABLE(H+2); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -13012,7 +13012,7 @@ Yap_absmi(int inp)
H[0] = t; H[0] = t;
H[1] = XREG(PREG->u.xxn.xi); H[1] = XREG(PREG->u.xxn.xi);
RESET_VARIABLE(H+2); 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; H = Ho;
} }
#endif /* LOW_LEVEL_TRACE */ #endif /* LOW_LEVEL_TRACE */
@ -13091,7 +13091,7 @@ Yap_absmi(int inp)
H[0] = XREG(PREG->u.yxx.x1); H[0] = XREG(PREG->u.yxx.x1);
H[1] = XREG(PREG->u.yxx.x2); H[1] = XREG(PREG->u.yxx.x2);
RESET_VARIABLE(H+2); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -13206,7 +13206,7 @@ Yap_absmi(int inp)
H[0] = t; H[0] = t;
H[1] = XREG(PREG->u.yxn.xi); H[1] = XREG(PREG->u.yxn.xi);
RESET_VARIABLE(H+2); 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; H = Ho;
} }
#endif /* LOW_LEVEL_TRACE */ #endif /* LOW_LEVEL_TRACE */
@ -13301,7 +13301,7 @@ Yap_absmi(int inp)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H[1] = XREG(PREG->u.xxx.x1); H[1] = XREG(PREG->u.xxx.x1);
H[2] = XREG(PREG->u.xxx.x2); 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 */ #endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */ /* We have to build the structure */
@ -13423,7 +13423,7 @@ Yap_absmi(int inp)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H[1] = PREG->u.xxn.c; H[1] = PREG->u.xxn.c;
H[2] = XREG(PREG->u.xxn.xi); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -13531,7 +13531,7 @@ Yap_absmi(int inp)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H[1] = XREG(PREG->u.xxn.xi); H[1] = XREG(PREG->u.xxn.xi);
H[2] = ti; 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; H = hi;
} }
#endif /* LOW_LEVEL_TRACE */ #endif /* LOW_LEVEL_TRACE */
@ -13627,7 +13627,7 @@ Yap_absmi(int inp)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H[1] = XREG(PREG->u.yxx.x1); H[1] = XREG(PREG->u.yxx.x1);
H[2] = XREG(PREG->u.yxx.x2); 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 */ #endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */ /* We have to build the structure */
@ -13767,7 +13767,7 @@ Yap_absmi(int inp)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H[1] = PREG->u.yxn.c; H[1] = PREG->u.yxn.c;
H[2] = XREG(PREG->u.yxn.xi); 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 */ #endif /* LOW_LEVEL_TRACE */
/* We have to build the structure */ /* We have to build the structure */
@ -13897,7 +13897,7 @@ Yap_absmi(int inp)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H[1] = XREG(PREG->u.yxn.xi); H[1] = XREG(PREG->u.yxn.xi);
H[2] = ti; 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; H = hi;
} }
#endif /* LOW_LEVEL_TRACE */ #endif /* LOW_LEVEL_TRACE */
@ -14018,7 +14018,7 @@ Yap_absmi(int inp)
H[0] = XREG(PREG->u.xxx.x); H[0] = XREG(PREG->u.xxx.x);
RESET_VARIABLE(H+1); RESET_VARIABLE(H+1);
RESET_VARIABLE(H+2); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -14066,7 +14066,7 @@ Yap_absmi(int inp)
H[0] = XREG(PREG->u.xxy.x); H[0] = XREG(PREG->u.xxy.x);
RESET_VARIABLE(H+1); RESET_VARIABLE(H+1);
RESET_VARIABLE(H+2); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -14117,7 +14117,7 @@ Yap_absmi(int inp)
H[0] = XREG(PREG->u.yxx.x2); H[0] = XREG(PREG->u.yxx.x2);
RESET_VARIABLE(H+1); RESET_VARIABLE(H+1);
RESET_VARIABLE(H+2); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -14168,7 +14168,7 @@ Yap_absmi(int inp)
H[0] = XREG(PREG->u.yyx.x); H[0] = XREG(PREG->u.yyx.x);
RESET_VARIABLE(H+1); RESET_VARIABLE(H+1);
RESET_VARIABLE(H+2); 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 */ #endif /* LOW_LEVEL_TRACE */
BEGD(d0); BEGD(d0);
@ -14219,7 +14219,7 @@ Yap_absmi(int inp)
Op(p_functor, e); Op(p_functor, e);
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (Yap_do_low_level_trace) 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 */ #endif /* LOW_LEVEL_TRACE */
restart_functor: restart_functor:
BEGD(d0); BEGD(d0);

2
C/amasm.c
View File

@ -4024,7 +4024,7 @@ Yap_InitComma(void)
code_p->u.Osbpp.bmap = NULL; code_p->u.Osbpp.bmap = NULL;
GONEXT(Osbpp); GONEXT(Osbpp);
if (PRED_GOAL_EXPANSION_ON) { 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->opc = emit_op(_call_cpred);
code_p->u.Osbpp.s = emit_count(-Signed(RealEnvSize)); code_p->u.Osbpp.s = emit_count(-Signed(RealEnvSize));
code_p->u.Osbpp.p = code_p->u.Osbpp.p =

2
C/arith1.c
View File

@ -806,7 +806,7 @@ p_unary_is(void)
/* error */ /* error */
ti[0] = t; ti[0] = t;
ti[1] = MkIntTerm(1); 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, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression", "functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,1); RepAtom(name)->StrOfAE,1);

2
C/arith2.c
View File

@ -1084,7 +1084,7 @@ p_binary_is(void)
/* error */ /* error */
ti[0] = t; ti[0] = t;
ti[1] = MkIntTerm(1); 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, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression", "functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,2); RepAtom(name)->StrOfAE,2);

18
C/arrays.c
View File

@ -1020,23 +1020,23 @@ p_static_array_properties(void)
return(FALSE); return(FALSE);
switch(tp) { switch(tp) {
case array_of_ints: case array_of_ints:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("int")))); return(Yap_unify(ARG3,MkAtomTerm(AtomInt)));
case array_of_dbrefs: case array_of_dbrefs:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("dbref")))); return(Yap_unify(ARG3,MkAtomTerm(AtomDBref)));
case array_of_doubles: case array_of_doubles:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("float")))); return(Yap_unify(ARG3,MkAtomTerm(AtomFloat)));
case array_of_ptrs: case array_of_ptrs:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("ptr")))); return(Yap_unify(ARG3,MkAtomTerm(AtomPtr)));
case array_of_chars: case array_of_chars:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("char")))); return(Yap_unify(ARG3,MkAtomTerm(AtomChar)));
case array_of_uchars: case array_of_uchars:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("unsigned char")))); return(Yap_unify(ARG3,MkAtomTerm(AtomUnsignedChar)));
case array_of_terms: case array_of_terms:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("term")))); return(Yap_unify(ARG3,MkAtomTerm(AtomTerm)));
case array_of_nb_terms: case array_of_nb_terms:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("nb_term")))); return(Yap_unify(ARG3,MkAtomTerm(AtomNbTerm)));
case array_of_atoms: case array_of_atoms:
return(Yap_unify(ARG3,MkAtomTerm(Yap_LookupAtom("atom")))); return(Yap_unify(ARG3,MkAtomTerm(AtomAtom)));
} }
} }
} }

2
C/attvar.c
View File

@ -837,7 +837,7 @@ static Int
p_swi_all_atts(void) { p_swi_all_atts(void) {
/* receive a variable in ARG1 */ /* receive a variable in ARG1 */
Term inp = Deref(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 this is unbound, ok */
if (IsVarTerm(inp)) { if (IsVarTerm(inp)) {

18
C/c_interface.c
View File

@ -2045,7 +2045,7 @@ YAP_Init(YAP_init_args *yap_init)
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
if (yap_init->YapPrologRCFile) { 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 This must be done again after restore, as yap_flags
has been overwritten .... has been overwritten ....
@ -2054,27 +2054,27 @@ YAP_Init(YAP_init_args *yap_init)
} }
#ifdef MYDDAS_MYSQL #ifdef MYDDAS_MYSQL
if (yap_init->myddas) { if (yap_init->myddas) {
Yap_PutValue(Yap_FullLookupAtom("$myddas_goal"),MkIntegerTerm(yap_init->myddas)); Yap_PutValue(AtomMyddasGoal,MkIntegerTerm(yap_init->myddas));
/* Mandatory Fields */ /* Mandatory Fields */
Yap_PutValue(Yap_FullLookupAtom("$myddas_user"),MkAtomTerm(Yap_LookupAtom(yap_init->myddas_user))); Yap_PutValue(AtomMyddasUser,MkAtomTerm(Yap_LookupAtom(yap_init->myddas_user)));
Yap_PutValue(Yap_FullLookupAtom("$myddas_db"),MkAtomTerm(Yap_LookupAtom(yap_init->myddas_db))); Yap_PutValue(AtomMyddasDB,MkAtomTerm(Yap_LookupAtom(yap_init->myddas_db)));
/* Non-Mandatory Fields */ /* Non-Mandatory Fields */
if (yap_init->myddas_pass != NULL) 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) 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 #endif
if (yap_init->YapPrologTopLevelGoal) { 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) { 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) { 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) { if (yap_init->QuietMode) {
yap_flags[QUIET_MODE_FLAG] = TRUE; yap_flags[QUIET_MODE_FLAG] = TRUE;

20
C/cdmgr.c
View File

@ -588,7 +588,7 @@ PredForChoicePt(yamop *p_code) {
case _or_else: case _or_else:
if (p_code == p_code->u.Osblp.l) { if (p_code == p_code->u.Osblp.l) {
/* repeat */ /* repeat */
Atom at = Yap_LookupAtom("repeat "); Atom at = AtomRepeatSpace;
return RepPredProp(PredPropByAtom(at, PROLOG_MODULE)); return RepPredProp(PredPropByAtom(at, PROLOG_MODULE));
} else { } else {
return p_code->u.Osblp.p0; 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[0] = MkAtomTerm(AbsAtom(ap));
ti[1] = MkIntegerTerm(Arity); 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_ErrorMessage = Yap_ErrorSay;
Yap_Error_Term = t; Yap_Error_Term = t;
Yap_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE; Yap_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE;
@ -2544,7 +2544,7 @@ static Atom
YapConsultingFile (void) YapConsultingFile (void)
{ {
if (consult_level == 0) { if (consult_level == 0) {
return(Yap_LookupAtom("user")); return(AtomUser);
} else { } else {
return(Yap_LookupAtom(ConsultBase[2].filename)); return(Yap_LookupAtom(ConsultBase[2].filename));
} }
@ -2694,7 +2694,7 @@ p_setspy(void)
CELL fg; CELL fg;
Term t, mod; Term t, mod;
at = Yap_FullLookupAtom("$spy"); at = AtomSpy;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0));
SpyCode = pred; SpyCode = pred;
t = Deref(ARG1); t = Deref(ARG1);
@ -3487,7 +3487,7 @@ clause_was_found(PredEntry *pp, Atom *pat, UInt *parity) {
if (pp->ModuleOfPred == IDB_MODULE) { if (pp->ModuleOfPred == IDB_MODULE) {
if (pp->PredFlags & NumberDBPredFlag) { if (pp->PredFlags & NumberDBPredFlag) {
*parity = 0; *parity = 0;
*pat = Yap_LookupAtom("integer"); *pat = AtomInteger;
} else if (pp->PredFlags & AtomDBPredFlag) { } else if (pp->PredFlags & AtomDBPredFlag) {
*parity = 0; *parity = 0;
*pat = (Atom)pp->FunctorOfPred; *pat = (Atom)pp->FunctorOfPred;
@ -4539,8 +4539,8 @@ p_is_profiled(void)
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Term ta; Term ta;
if (PROFILING) ta = MkAtomTerm(Yap_LookupAtom("on")); if (PROFILING) ta = MkAtomTerm(AtomOn);
else ta = MkAtomTerm(Yap_LookupAtom("off")); else ta = MkAtomTerm(AtomOff);
BIND((CELL *)t,ta,bind_is_profiled); BIND((CELL *)t,ta,bind_is_profiled);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(CellPtr(t), ta); DO_TRAIL(CellPtr(t), ta);
@ -4642,8 +4642,8 @@ p_is_call_counted(void)
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Term ta; Term ta;
if (CALL_COUNTING) ta = MkAtomTerm(Yap_LookupAtom("on")); if (CALL_COUNTING) ta = MkAtomTerm(AtomOn);
else ta = MkAtomTerm(Yap_LookupAtom("off")); else ta = MkAtomTerm(AtomOff);
BIND((CELL *)t,ta,bind_is_call_counted); BIND((CELL *)t,ta,bind_is_call_counted);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(CellPtr(t), ta); DO_TRAIL(CellPtr(t), ta);
@ -6184,7 +6184,7 @@ p_choicepoint_info(void)
break; break;
case _Nstop: case _Nstop:
{ {
Atom at = Yap_FullLookupAtom("$live"); Atom at = AtomLive;
t = MkAtomTerm(at); t = MkAtomTerm(at);
pe = RepPredProp(PredPropByAtom(at, CurrentModule)); pe = RepPredProp(PredPropByAtom(at, CurrentModule));
} }

12
C/computils.c
View File

@ -349,11 +349,11 @@ write_functor(Functor f)
{ {
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
if (f == FunctorDBRef) { if (f == FunctorDBRef) {
Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("DBRef"))); Yap_DebugPlWrite(MkAtomTerm(AtomDBREF));
} else if (f == FunctorLongInt) { } else if (f == FunctorLongInt) {
Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("LongInt"))); Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT));
} else if (f == FunctorDouble) { } else if (f == FunctorDouble) {
Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("Double"))); Yap_DebugPlWrite(MkAtomTerm(AtomDOUBLE));
} }
} else { } else {
Yap_DebugPlWrite(MkAtomTerm(NameOfFunctor (f))); Yap_DebugPlWrite(MkAtomTerm(NameOfFunctor (f)));
@ -499,11 +499,11 @@ ShowOp (char *f, struct PSEUDO *cpc)
Functor fun = (Functor)*cptr++; Functor fun = (Functor)*cptr++;
if (IsExtensionFunctor(fun)) { if (IsExtensionFunctor(fun)) {
if (fun == FunctorDBRef) { if (fun == FunctorDBRef) {
Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("DBRef"))); Yap_DebugPlWrite(MkAtomTerm(AtomDBREF));
} else if (fun == FunctorLongInt) { } else if (fun == FunctorLongInt) {
Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("LongInt"))); Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT));
} else if (fun == FunctorDouble) { } else if (fun == FunctorDouble) {
Yap_DebugPlWrite(MkAtomTerm(Yap_LookupAtom("Double"))); Yap_DebugPlWrite(MkAtomTerm(AtomDOUBLE));
} }
} else { } else {
Yap_DebugPlWrite (MkAtomTerm(NameOfFunctor(fun))); Yap_DebugPlWrite (MkAtomTerm(NameOfFunctor(fun)));

2
C/corout.c
View File

@ -605,7 +605,7 @@ Yap_InitCoroutPreds(void)
Atom at; Atom at;
PredEntry *pred; PredEntry *pred;
at = Yap_FullLookupAtom("$wake_up_goal"); at = AtomWakeUpGoal;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 2),0)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 2),0));
WakeUpCode = pred; WakeUpCode = pred;
#endif #endif

4
C/dbase.c
View File

@ -2639,7 +2639,7 @@ new_lu_int_key(Int key)
return NULL; return NULL;
} }
} }
ae = Yap_FullLookupAtom("$integer"); ae = AtomDInteger;
WRITE_LOCK(ae->ARWLock); WRITE_LOCK(ae->ARWLock);
p0 = Yap_NewPredPropByAtom(ae,IDB_MODULE); p0 = Yap_NewPredPropByAtom(ae,IDB_MODULE);
p = RepPredProp(p0); 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); 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); RETRY_C_RECORDED_K_CODE = NEXTOP(PredRecordedWithKey->cs.p_code.FirstClause,OtapFs);
Yap_InitCPredBack("$recordedp", 3, 3, in_rdedp, co_rdedp, SyncPredFlag|HiddenPredFlag); 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, Yap_InitCPredBack("$current_immediate_key", 2, 4, init_current_key, cont_current_key,
SyncPredFlag|HiddenPredFlag); SyncPredFlag|HiddenPredFlag);
} }

498
C/errors.c
View File

File diff suppressed because it is too large Load Diff

4
C/eval.c
View File

@ -47,7 +47,7 @@ Eval(Term t)
ti[0] = t; ti[0] = t;
ti[1] = MkIntegerTerm(0); ti[1] = MkIntegerTerm(0);
/* error */ /* 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, Yap_Error(TYPE_ERROR_EVALUABLE, terror,
"atom %s for arithmetic expression", "atom %s for arithmetic expression",
RepAtom(name)->StrOfAE); RepAtom(name)->StrOfAE);
@ -79,7 +79,7 @@ Eval(Term t)
/* error */ /* error */
ti[0] = t; ti[0] = t;
ti[1] = MkIntegerTerm(n); 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, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression", "functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,n); RepAtom(name)->StrOfAE,n);

10
C/globals.c
View File

@ -1564,7 +1564,7 @@ p_nb_queue_close(void)
out = out =
Yap_unify(ARG3, qp[QUEUE_TAIL]) && Yap_unify(ARG3, qp[QUEUE_TAIL]) &&
Yap_unify(ARG2, qp[QUEUE_HEAD]); 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); qp[0] = MkIntegerTerm(0);
return out; return out;
} }
@ -1757,7 +1757,7 @@ p_nb_heap(void)
hsize = IntegerOfTerm(tsize); 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)) { if (!Yap_gcl((2*hsize+HEAP_START+1)*sizeof(CELL), 2, ENV, P)) {
Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return FALSE; return FALSE;
@ -1809,7 +1809,7 @@ p_nb_heap_close(void)
if (qp[HEAP_DELAY_ARENA] != MkIntTerm(0)) if (qp[HEAP_DELAY_ARENA] != MkIntTerm(0))
RecoverDelayArena(qp[HEAP_DELAY_ARENA]); RecoverDelayArena(qp[HEAP_DELAY_ARENA]);
#endif #endif
qp[-1] = (CELL)Yap_MkFunctor(Yap_LookupAtom("heap"),1); qp[-1] = (CELL)Yap_MkFunctor(AtomHeap,1);
qp[0] = MkIntegerTerm(0); qp[0] = MkIntegerTerm(0);
return TRUE; return TRUE;
} }
@ -1901,7 +1901,7 @@ p_nb_heap_add_to_heap(void)
hmsize += extra_size; hmsize += extra_size;
if (!qd) if (!qd)
return FALSE; 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)); top = qd+(HEAP_START+2*(hmsize-extra_size));
while (extra_size) { while (extra_size) {
RESET_VARIABLE(top); RESET_VARIABLE(top);
@ -2055,7 +2055,7 @@ p_nb_beam(void)
} }
hsize = IntegerOfTerm(tsize); 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)) { if (!Yap_gcl((5*hsize+HEAP_START+1)*sizeof(CELL), 2, ENV, P)) {
Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return FALSE; return FALSE;

8
C/gprof.c
View File

@ -1214,9 +1214,9 @@ static Int profinit1(void)
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
if (Yap_OffLineProfiler) if (Yap_OffLineProfiler)
Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("offline"))); Yap_unify(ARG1,MkAtomTerm(AtomOffline));
else else
Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("online"))); Yap_unify(ARG1,MkAtomTerm(AtomOnline));
} else if (IsAtomTerm(t)) { } else if (IsAtomTerm(t)) {
char *name = RepAtom(AtomOfTerm(t))->StrOfAE; char *name = RepAtom(AtomOfTerm(t))->StrOfAE;
if (!strcmp(name,"offline")) if (!strcmp(name,"offline"))
@ -1238,9 +1238,9 @@ static Int profinit1(void)
static Int proftype(void) static Int proftype(void)
{ {
if (Yap_OffLineProfiler) if (Yap_OffLineProfiler)
return Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("offline"))); return Yap_unify(ARG1,MkAtomTerm(AtomOffline));
else else
return Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("online"))); return Yap_unify(ARG1,MkAtomTerm(AtomOnline));
} }
static Int start_profilers(int msec) static Int start_profilers(int msec)

236
C/init.c
View File

@ -475,7 +475,7 @@ InitDebug(void)
} }
#endif #endif
/* Set at full leash */ /* Set at full leash */
At = Yap_FullLookupAtom("$leash"); At = AtomLeash;
Yap_PutValue(At, MkIntTerm(15)); Yap_PutValue(At, MkIntTerm(15));
} }
@ -963,37 +963,19 @@ InitFlags(void)
static void static void
InitCodes(void) InitCodes(void)
{ {
Atom #include "iatoms.h"
AtomAltNot, Yap_heap_regs->term_prolog = MkAtomTerm(AtomProlog);
#ifdef COROUTINING Yap_heap_regs->user_module = MkAtomTerm(AtomUser);
AtomArrayAccess, Yap_heap_regs->idb_module = MkAtomTerm(AtomIDB);
#endif Yap_heap_regs->attributes_module = MkAtomTerm(AtomAttributes);
AtomArrow, Yap_heap_regs->charsio_module = MkAtomTerm(AtomCharsio);
AtomBraces, Yap_heap_regs->terms_module = MkAtomTerm(AtomTerms);
AtomEq, Yap_heap_regs->system_module = MkAtomTerm(AtomSystem);
AtomGVar, Yap_heap_regs->readutil_module = MkAtomTerm(AtomReadutil);
AtomNot, Yap_heap_regs->hacks_module = MkAtomTerm(AtomYapHacks);
AtomQuery, Yap_heap_regs->globals_module = MkAtomTerm(AtomNb);
AtomSemic, Yap_heap_regs->arg_module = MkAtomTerm(AtomArg);
AtomCreep, Yap_heap_regs->swi_module = MkAtomTerm(AtomSwi);
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"));
Yap_InitModules(); Yap_InitModules();
#ifdef BEAM #ifdef BEAM
Yap_heap_regs->beam_retry_code.opc = Yap_opcode(_retry_eam); Yap_heap_regs->beam_retry_code.opc = Yap_opcode(_retry_eam);
@ -1161,13 +1143,13 @@ InitCodes(void)
Atom at; Atom at;
PredEntry *pred; PredEntry *pred;
at = Yap_FullLookupAtom("$creep"); at = AtomCreep;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),PROLOG_MODULE)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),PROLOG_MODULE));
Yap_heap_regs->creep_code = pred; Yap_heap_regs->creep_code = pred;
at = Yap_FullLookupAtom("$undefp"); at = AtomUndefp;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),PROLOG_MODULE)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),PROLOG_MODULE));
Yap_heap_regs->undef_code = pred; Yap_heap_regs->undef_code = pred;
at = Yap_FullLookupAtom("$spy"); at = AtomSpy;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0));
Yap_heap_regs->spy_code = pred; Yap_heap_regs->spy_code = pred;
Yap_heap_regs->env_for_trustfail_code.p = 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!!!! don't initialise this here, this is initialised by Yap_InitModules!!!!
Yap_heap_regs->no_of_modules = 1; 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 EUROTRA
#ifdef SFUNC Yap_heap_regs->term_dollar_u = MkAtomTerm(AtomDollarU);
Yap_heap_regs->atom_dollar_undef = MkAtomTerm(Yap_FullLookupAtom("$undef"));
#endif #endif
#endif Yap_heap_regs->term_refound_var = MkAtomTerm(AtomRefoundVar);
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->n_of_file_aliases = 0; Yap_heap_regs->n_of_file_aliases = 0;
Yap_heap_regs->file_aliases = NULL; Yap_heap_regs->file_aliases = NULL;
Yap_heap_regs->foreign_code_loaded = NULL; Yap_heap_regs->foreign_code_loaded = NULL;
@ -1384,28 +1220,28 @@ InitCodes(void)
/* predicates can only be defined after this point */ /* predicates can only be defined after this point */
Yap_heap_regs->env_for_yes_code.p = Yap_heap_regs->env_for_yes_code.p =
Yap_heap_regs->env_for_yes_code.p0 = Yap_heap_regs->env_for_yes_code.p0 =
RepPredProp(PredPropByAtom(Yap_heap_regs->atom_true,0)); RepPredProp(PredPropByAtom(AtomTrue,0));
Yap_heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_heap_regs->atom_meta_call,4),PROLOG_MODULE)); Yap_heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomMetaCall,4),PROLOG_MODULE));
Yap_heap_regs->pred_dollar_catch = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_FullLookupAtom("$catch"),3),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(Yap_FullLookupAtom("$recorded_with_key"),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(Yap_FullLookupAtom("$do_log_upd_clause"),6),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(Yap_FullLookupAtom("$do_log_upd_clause_erase"),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(Yap_FullLookupAtom("$do_log_upd_clause0"),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(Yap_FullLookupAtom("$do_static_clause"),5),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_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_handle_throw = RepPredProp(PredPropByFunc(Yap_MkFunctor(AtomHandleThrow,3),PROLOG_MODULE));
Yap_heap_regs->pred_goal_expansion = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom("goal_expansion"),3),USER_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.p =
Yap_heap_regs->env_for_trustfail_code.p0 = 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 */ /* 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; modp->PredFlags |= MetaPredFlag;
} }
#ifdef YAPOR #ifdef YAPOR
Yap_heap_regs->getwork_code.u.Otapl.p = RepPredProp(PredPropByAtom(Yap_FullLookupAtom("$getwork"), 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(Yap_FullLookupAtom("$getwork_seq"), PROLOG_MODULE)); Yap_heap_regs->getwork_seq_code.u.Otapl.p = RepPredProp(PredPropByAtom(AtomGetworkSeq, PROLOG_MODULE));
#endif /* YAPOR */ #endif /* YAPOR */
Yap_heap_regs->db_erased_marker = Yap_heap_regs->db_erased_marker =
(DBRef)Yap_AllocCodeSpace(sizeof(DBStruct)); (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->ClFlags = ErasedMask|LogUpdMask;
Yap_heap_regs->logdb_erased_marker->ClSource = NULL; Yap_heap_regs->logdb_erased_marker->ClSource = NULL;
Yap_heap_regs->logdb_erased_marker->ClRefCount = 0; 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->ClExt = NULL;
Yap_heap_regs->logdb_erased_marker->ClPrev = NULL; Yap_heap_regs->logdb_erased_marker->ClPrev = NULL;
Yap_heap_regs->logdb_erased_marker->ClNext = NULL; Yap_heap_regs->logdb_erased_marker->ClNext = NULL;
@ -1442,10 +1278,10 @@ InitCodes(void)
static void static void
InitVersion(void) InitVersion(void)
{ {
Yap_PutValue(Yap_FullLookupAtom("$version_name"), Yap_PutValue(AtomVersionNumber,
MkAtomTerm(Yap_LookupAtom(YAP_VERSION))); MkAtomTerm(Yap_LookupAtom(YAP_VERSION)));
#if defined MYDDAS_MYSQL || defined MYDDAS_ODBC #if defined MYDDAS_MYSQL || defined MYDDAS_ODBC
Yap_PutValue(Yap_FullLookupAtom("$myddas_version_name"), Yap_PutValue(AtomMyddasVersionName,
MkAtomTerm(Yap_LookupAtom(MYDDAS_VERSION))); MkAtomTerm(Yap_LookupAtom(MYDDAS_VERSION)));
#endif #endif
} }

98
C/iopreds.c
View File

@ -308,7 +308,7 @@ unix_upd_stream_info (StreamDesc * s)
/* isatty does not seem to work with simplescar. I'll assume the first /* isatty does not seem to work with simplescar. I'll assume the first
three streams will probably be ttys (pipes are not thatg different) */ three streams will probably be ttys (pipes are not thatg different) */
if (s-Stream < 3) { 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; s->status |= Tty_Stream_f|Reset_Eof_Stream_f|Promptable_Stream_f;
} }
#else #else
@ -319,11 +319,11 @@ unix_upd_stream_info (StreamDesc * s)
#if HAVE_TTYNAME #if HAVE_TTYNAME
char *ttys = ttyname(filedes); char *ttys = ttyname(filedes);
if (ttys == NULL) if (ttys == NULL)
s->u.file.name = Yap_LookupAtom("tty"); s->u.file.name = AtomTty;
else else
s->u.file.name = Yap_LookupAtom(ttys); s->u.file.name = AtomTtys;
#else #else
s->u.file.name = Yap_LookupAtom("tty"); s->u.file.name = AtomTty;
#endif #endif
s->status |= Tty_Stream_f|Reset_Eof_Stream_f|Promptable_Stream_f; s->status |= Tty_Stream_f|Reset_Eof_Stream_f|Promptable_Stream_f;
return; return;
@ -453,13 +453,13 @@ InitStdStream (int sno, SMALLUNSGN flags, YP_File file)
InitFileIO(s); InitFileIO(s);
switch(sno) { switch(sno) {
case 0: case 0:
s->u.file.name=Yap_LookupAtom("user_input"); s->u.file.name=AtomUserIn;
break; break;
case 1: case 1:
s->u.file.name=Yap_LookupAtom("user_output"); s->u.file.name=AtomUserOut;
break; break;
default: default:
s->u.file.name=Yap_LookupAtom("user_error"); s->u.file.name=AtomUserErr;
break; break;
} }
s->u.file.user_name = MkAtomTerm (s->u.file.name); s->u.file.user_name = MkAtomTerm (s->u.file.name);
@ -496,11 +496,11 @@ InitStdStreams (void)
Yap_c_output_stream = StdOutStream; Yap_c_output_stream = StdOutStream;
Yap_c_error_stream = StdErrStream; Yap_c_error_stream = StdErrStream;
/* init standard aliases */ /* init standard aliases */
FileAliases[0].name = AtomUsrIn; FileAliases[0].name = AtomUserIn;
FileAliases[0].alias_stream = 0; FileAliases[0].alias_stream = 0;
FileAliases[1].name = AtomUsrOut; FileAliases[1].name = AtomUserOut;
FileAliases[1].alias_stream = 1; FileAliases[1].alias_stream = 1;
FileAliases[2].name = AtomUsrErr; FileAliases[2].name = AtomUserErr;
FileAliases[2].alias_stream = 2; FileAliases[2].alias_stream = 2;
NOfFileAliases = 3; NOfFileAliases = 3;
SzOfFileAliases = ALIASES_BLOCK_SIZE; SzOfFileAliases = ALIASES_BLOCK_SIZE;
@ -534,7 +534,7 @@ Yap_InitPlIO (void)
static Int static Int
PlIOError (yap_error_number type, Term culprit, char *who) 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); Yap_Error(type, culprit, who);
/* and fail */ /* and fail */
return FALSE; return FALSE;
@ -2263,7 +2263,7 @@ p_open (void)
} }
open_mode = AtomOfTerm (t2); open_mode = AtomOfTerm (t2);
if (open_mode == AtomRead || open_mode == AtomCsult) { 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)); return(Yap_unify(MkStream(FileAliases[0].alias_stream), ARG3));
} }
strncpy(io_mode,"rb", 8); strncpy(io_mode,"rb", 8);
@ -2371,7 +2371,7 @@ p_open (void)
st->stream_gets = PlGetsFunc(); st->stream_gets = PlGetsFunc();
} }
ta[1] = MkAtomTerm(AtomTrue); 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"); Yap_Error(PERMISSION_ERROR_OPEN_SOURCE_SINK,t,"open/4");
return FALSE; return FALSE;
} }
@ -2568,7 +2568,7 @@ p_open_null_stream (void)
st->stream_gets = PlGetsFunc(); st->stream_gets = PlGetsFunc();
st->stream_wgetc = get_wchar; st->stream_wgetc = get_wchar;
st->stream_wgetc_for_read = 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); t = MkStream (sno);
return (Yap_unify (ARG1, t)); return (Yap_unify (ARG1, t));
} }
@ -3046,9 +3046,9 @@ CheckStream (Term arg, int kind, char *msg)
"ambiguous use of 'user' as a stream"); "ambiguous use of 'user' as a stream");
return (-1); return (-1);
} }
sname = AtomUsrIn; sname = AtomUserIn;
} else { } else {
sname = AtomUsrOut; sname = AtomUserOut;
} }
} }
if ((sno = CheckAlias(sname)) == -1) { if ((sno = CheckAlias(sname)) == -1) {
@ -3130,13 +3130,13 @@ StreamName(int i)
if (i < 3) return(MkAtomTerm(AtomUser)); if (i < 3) return(MkAtomTerm(AtomUser));
#if USE_SOCKET #if USE_SOCKET
if (Stream[i].status & Socket_Stream_f) if (Stream[i].status & Socket_Stream_f)
return(MkAtomTerm(Yap_LookupAtom("socket"))); return(MkAtomTerm(AtomSocket));
else else
#endif #endif
if (Stream[i].status & Pipe_Stream_f) if (Stream[i].status & Pipe_Stream_f)
return(MkAtomTerm(Yap_LookupAtom("pipe"))); return(MkAtomTerm(AtomPipe));
if (Stream[i].status & InMemory_Stream_f) if (Stream[i].status & InMemory_Stream_f)
return(MkAtomTerm(Yap_LookupAtom("charsio"))); return(MkAtomTerm(AtomCharsio));
else { else {
if (yap_flags[LANGUAGE_MODE_FLAG] == ISO_CHARACTER_ESCAPES) { if (yap_flags[LANGUAGE_MODE_FLAG] == ISO_CHARACTER_ESCAPES) {
return(Stream[i].u.file.user_name); return(Stream[i].u.file.user_name);
@ -3667,11 +3667,11 @@ syntax_error (TokEntry * tokptr, int sno)
{ {
Term t0[1]; Term t0[1];
t0[0] = MkAtomTerm((Atom)info); 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; break;
case Number_tok: 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; break;
case Var_tok: case Var_tok:
{ {
@ -3685,19 +3685,19 @@ syntax_error (TokEntry * tokptr, int sno)
} else { } else {
t[2] = varinfo->VarAdr; 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; break;
case String_tok: case String_tok:
{ {
Term t0 = Yap_StringToList((char *)info); 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; break;
case WString_tok: case WString_tok:
{ {
Term t0 = Yap_WideStringToList((wchar_t *)info); 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; break;
case Error_tok: case Error_tok:
@ -3722,26 +3722,26 @@ syntax_error (TokEntry * tokptr, int sno)
} else if (tokptr->Tok != Ord (Error_tok)) { } else if (tokptr->Tok != Ord (Error_tok)) {
ts[1] = MkIntegerTerm(tokptr->TokPos); ts[1] = MkIntegerTerm(tokptr->TokPos);
*error = *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; error = RepPair(*error)+1;
count++; count++;
} }
tokptr = tokptr->TokNext; 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]; Term t[3];
t[0] = MkIntegerTerm(start); t[0] = MkIntegerTerm(start);
t[1] = MkIntegerTerm(err); t[1] = MkIntegerTerm(err);
t[2] = MkIntegerTerm(end); 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[4] = MkIntegerTerm(out);
tf[5] = MkIntegerTerm(err); tf[5] = MkIntegerTerm(err);
tf[6] = StreamName(sno); 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 Int
@ -3794,16 +3794,16 @@ p_get_read_error_handler(void)
switch (ParserErrorStyle) { switch (ParserErrorStyle) {
case FAIL_ON_PARSER_ERROR: case FAIL_ON_PARSER_ERROR:
t = MkAtomTerm(Yap_LookupAtom("fail")); t = MkAtomTerm(AtomFail);
break; break;
case EXCEPTION_ON_PARSER_ERROR: case EXCEPTION_ON_PARSER_ERROR:
t = MkAtomTerm(Yap_LookupAtom("error")); t = MkAtomTerm(AtomError);
break; break;
case QUIET_ON_PARSER_ERROR: case QUIET_ON_PARSER_ERROR:
t = MkAtomTerm(Yap_LookupAtom("quiet")); t = MkAtomTerm(AtomQuiet);
break; break;
case CONTINUE_ON_PARSER_ERROR: case CONTINUE_ON_PARSER_ERROR:
t = MkAtomTerm(Yap_LookupAtom("dec10")); t = MkAtomTerm(AtomDec10);
break; break;
default: default:
Yap_Error(SYSTEM_ERROR,TermNil,"corrupted syntax_error handler"); Yap_Error(SYSTEM_ERROR,TermNil,"corrupted syntax_error handler");
@ -3991,7 +3991,7 @@ static Int
t[1] = MkAtomTerm(Yap_LookupAtom(Yap_ErrorMessage)); t[1] = MkAtomTerm(Yap_LookupAtom(Yap_ErrorMessage));
Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable); Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable);
return(Yap_unify(tpos,ARG5) && 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 { } else {
@ -4064,13 +4064,13 @@ p_user_file_name (void)
return (FALSE); return (FALSE);
#if USE_SOCKET #if USE_SOCKET
if (Stream[sno].status & Socket_Stream_f) if (Stream[sno].status & Socket_Stream_f)
tout = MkAtomTerm(Yap_LookupAtom("socket")); tout = MkAtomTerm(AtomSocket);
else else
#endif #endif
if (Stream[sno].status & Pipe_Stream_f) if (Stream[sno].status & Pipe_Stream_f)
tout = MkAtomTerm(Yap_LookupAtom("pipe")); tout = MkAtomTerm(AtomPipe);
else if (Stream[sno].status & InMemory_Stream_f) else if (Stream[sno].status & InMemory_Stream_f)
tout = MkAtomTerm(Yap_LookupAtom("charsio")); tout = MkAtomTerm(AtomCharsio);
else else
tout = Stream[sno].u.file.user_name; tout = Stream[sno].u.file.user_name;
UNLOCK(Stream[sno].streamlock); UNLOCK(Stream[sno].streamlock);
@ -4086,13 +4086,13 @@ p_file_name (void)
return (FALSE); return (FALSE);
#if USE_SOCKET #if USE_SOCKET
if (Stream[sno].status & Socket_Stream_f) if (Stream[sno].status & Socket_Stream_f)
tout = MkAtomTerm(Yap_LookupAtom("socket")); tout = MkAtomTerm(AtomSocket);
else else
#endif #endif
if (Stream[sno].status & Pipe_Stream_f) if (Stream[sno].status & Pipe_Stream_f)
tout = MkAtomTerm(Yap_LookupAtom("pipe")); tout = MkAtomTerm(AtomPipe);
else if (Stream[sno].status & InMemory_Stream_f) else if (Stream[sno].status & InMemory_Stream_f)
tout = MkAtomTerm(Yap_LookupAtom("charsio")); tout = MkAtomTerm(AtomCharsio);
else else
tout = MkAtomTerm(Stream[sno].u.file.name); tout = MkAtomTerm(Stream[sno].u.file.name);
UNLOCK(Stream[sno].streamlock); UNLOCK(Stream[sno].streamlock);
@ -4115,14 +4115,14 @@ p_cur_line_no (void)
Atom my_stream; Atom my_stream;
#if USE_SOCKET #if USE_SOCKET
if (Stream[sno].status & Socket_Stream_f) if (Stream[sno].status & Socket_Stream_f)
my_stream = Yap_LookupAtom("socket"); my_stream = AtomSocket;
else else
#endif #endif
if (Stream[sno].status & Pipe_Stream_f) if (Stream[sno].status & Pipe_Stream_f)
my_stream = Yap_LookupAtom("pipe"); my_stream = AtomPipe;
else else
if (Stream[sno].status & InMemory_Stream_f) if (Stream[sno].status & InMemory_Stream_f)
my_stream = Yap_LookupAtom("charsio"); my_stream = AtomCharsio;
else else
my_stream = Stream[sno].u.file.name; my_stream = Stream[sno].u.file.name;
for (i = 0; i < MaxStreams; i++) for (i = 0; i < MaxStreams; i++)
@ -4315,7 +4315,7 @@ p_set_stream_position (void)
UNLOCK(Stream[sno].streamlock); UNLOCK(Stream[sno].streamlock);
Yap_Error(INSTANTIATION_ERROR, tp, "set_stream_position/2"); Yap_Error(INSTANTIATION_ERROR, tp, "set_stream_position/2");
return (FALSE); return (FALSE);
} else if (tp != MkAtomTerm(Yap_LookupAtom("at"))) { } else if (tp != MkAtomTerm(AtomAt)) {
UNLOCK(Stream[sno].streamlock); UNLOCK(Stream[sno].streamlock);
Yap_Error(DOMAIN_ERROR_STREAM_POSITION, tin, "set_stream_position/2"); Yap_Error(DOMAIN_ERROR_STREAM_POSITION, tin, "set_stream_position/2");
return (FALSE); return (FALSE);
@ -5340,7 +5340,7 @@ format(volatile Term otail, volatile Term oargs, int sno)
Term ta[2]; Term ta[2];
ta[0] = otail; ta[0] = otail;
ta[1] = oargs; 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) { if (Stream[sno].status & InMemory_Stream_f) {
Stream[sno].u.mem_string.error_handler = old_handler; Stream[sno].u.mem_string.error_handler = old_handler;
@ -5530,7 +5530,7 @@ p_stream_select(void)
return(FALSE); return(FALSE);
} }
if (IsAtomTerm(t2)) { if (IsAtomTerm(t2)) {
if (t2 == MkAtomTerm(Yap_LookupAtom("off"))) { if (t2 == MkAtomTerm(AtomOff)) {
/* wait indefinitely */ /* wait indefinitely */
ptime = NULL; ptime = NULL;
} else { } else {
@ -5951,8 +5951,8 @@ p_float_format(void)
{ {
Term in = Deref(ARG1); Term in = Deref(ARG1);
if (IsVarTerm(in)) if (IsVarTerm(in))
return Yap_unify(ARG1, MkAtomTerm(FloatFormat)); return Yap_unify(ARG1, MkAtomTerm(AtomFloatFormat));
FloatFormat = AtomOfTerm(in); AtomFloatFormat = AtomOfTerm(in);
return TRUE; return TRUE;
} }
@ -6025,7 +6025,7 @@ Yap_StringToTerm(char *s,Term *tp)
tokstart = Yap_tokptr = Yap_toktide = Yap_tokenizer(sno, &tpos); tokstart = Yap_tokptr = Yap_toktide = Yap_tokenizer(sno, &tpos);
if (tokstart == NIL && tokstart->Tok == Ord (eot_tok)) { if (tokstart == NIL && tokstart->Tok == Ord (eot_tok)) {
if (tp) { 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); Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable);
/* cannot actually use CloseStream, because we didn't allocate the buffer */ /* cannot actually use CloseStream, because we didn't allocate the buffer */

2
C/modules.c
View File

@ -313,7 +313,7 @@ Yap_InitModulesC(void)
void void
Yap_InitModules(void) Yap_InitModules(void)
{ {
LookupModule(MkAtomTerm(Yap_LookupAtom("prolog"))); LookupModule(MkAtomTerm(AtomProlog));
LookupModule(USER_MODULE); LookupModule(USER_MODULE);
LookupModule(IDB_MODULE); LookupModule(IDB_MODULE);
LookupModule(ATTRIBUTES_MODULE); LookupModule(ATTRIBUTES_MODULE);

4
C/parser.c
View File

@ -352,7 +352,7 @@ ParseArgs(Atom a, JMPBUFF *FailBuff)
else else
t = Yap_MkApplTerm(Yap_MkFunctor(a, nargs), nargs, p); t = Yap_MkApplTerm(Yap_MkFunctor(a, nargs), nargs, p);
#else #else
if (a == AtomDBRef && nargs == 2) if (a == AtomDBref && nargs == 2)
t = MkDBRefTerm((DBRef)IntegerOfTerm(p[0])); t = MkDBRefTerm((DBRef)IntegerOfTerm(p[0]));
else else
t = Yap_MkApplTerm(func, nargs, p); t = Yap_MkApplTerm(func, nargs, p);
@ -674,7 +674,7 @@ ParseTerm(int prio, JMPBUFF *FailBuff)
NextToken; NextToken;
args[0] = t; args[0] = t;
args[1] = ParseTerm(1000, FailBuff); 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 */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
Yap_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";

2
C/scanner.c
View File

@ -962,7 +962,7 @@ Yap_tokenizer(int inp_stream, Term *tposp)
t->Tok = Name_tok; t->Tok = Name_tok;
if (ch == '(') if (ch == '(')
solo_flag = FALSE; solo_flag = FALSE;
t->TokInfo = Unsigned(Yap_LookupAtom("e")); t->TokInfo = Unsigned(AtomE);
t->TokPos = GetCurInpPos(inp_stream); t->TokPos = GetCurInpPos(inp_stream);
e2 = (TokEntry *) AllocScannerMemory(sizeof(TokEntry)); e2 = (TokEntry *) AllocScannerMemory(sizeof(TokEntry));
if (e2 == NULL) { if (e2 == NULL) {

26
C/stdpreds.c
View File

@ -365,7 +365,7 @@ Int cont_eam(void) {
Int use_eam(void) { Int use_eam(void) {
if (EAM) EAM=0; if (EAM) EAM=0;
else { Yap_PutValue(Yap_FullLookupAtom("$c_arith"),0); EAM=1; } else { Yap_PutValue(AtomCArith,0); EAM=1; }
return(TRUE); return(TRUE);
} }
@ -495,7 +495,7 @@ p_creep(void)
Atom at; Atom at;
PredEntry *pred; PredEntry *pred;
at = Yap_FullLookupAtom("$creep"); at = AtomCreep;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0));
CreepCode = pred; CreepCode = pred;
do_signal(YAP_CREEP_SIGNAL); do_signal(YAP_CREEP_SIGNAL);
@ -508,7 +508,7 @@ p_signal_creep(void)
Atom at; Atom at;
PredEntry *pred; PredEntry *pred;
at = Yap_FullLookupAtom("$creep"); at = AtomCreep;
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1),0));
CreepCode = pred; CreepCode = pred;
LOCK(SignalLock); LOCK(SignalLock);
@ -971,7 +971,7 @@ p_name(void)
String + 1024 > (char *)AuxSp) String + 1024 > (char *)AuxSp)
goto expand_auxsp; goto expand_auxsp;
if (!IsVarTerm(t) && t == MkAtomTerm(AtomNil)) { 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)) { while (!IsVarTerm(t) && IsPairTerm(t)) {
Term Head; Term Head;
@ -1112,7 +1112,7 @@ p_atom_chars(void)
return(FALSE); return(FALSE);
} }
if (t == TermNil) { if (t == TermNil) {
return (Yap_unify_constant(t1, MkAtomTerm(Yap_LookupAtom("")))); return (Yap_unify_constant(t1, MkAtomTerm(AtomEmptyAtom)));
} }
if (!IsPairTerm(t)) { if (!IsPairTerm(t)) {
Yap_Error(TYPE_ERROR_LIST, t, "atom_chars/2"); Yap_Error(TYPE_ERROR_LIST, t, "atom_chars/2");
@ -1660,7 +1660,7 @@ p_atom_codes(void)
return(FALSE); return(FALSE);
} }
if (t == TermNil) { if (t == TermNil) {
return (Yap_unify_constant(t1, MkAtomTerm(Yap_LookupAtom("")))); return (Yap_unify_constant(t1, MkAtomTerm(AtomEmptyAtom)));
} }
if (!IsPairTerm(t)) { if (!IsPairTerm(t)) {
Yap_Error(TYPE_ERROR_LIST, t, "atom_codes/2"); Yap_Error(TYPE_ERROR_LIST, t, "atom_codes/2");
@ -1886,10 +1886,10 @@ gen_syntax_error(Atom InpAtom, char *s)
ti[1] = ARG2; ti[1] = ARG2;
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom(s),2),2,ti); ts[0] = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom(s),2),2,ti);
ts[1] = ts[4] = ts[5] = MkIntTerm(0); ts[1] = ts[4] = ts[5] = MkIntTerm(0);
ts[2] = MkAtomTerm(Yap_LookupAtom("expected number syntax")); ts[2] = MkAtomTerm(AtomExpectedNumber);
ts[3] = TermNil; ts[3] = TermNil;
ts[6] = MkAtomTerm(InpAtom); 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 static Int
@ -3493,17 +3493,17 @@ p_access_yap_flags(void)
int n = 0; int n = 0;
if (IsMode_CompletedOn(yap_flags[flag])) { if (IsMode_CompletedOn(yap_flags[flag])) {
if (IsMode_LoadAnswers(yap_flags[flag])) if (IsMode_LoadAnswers(yap_flags[flag]))
tout = MkAtomTerm(Yap_LookupAtom("load_answers")); tout = MkAtomTerm(AtomLoadAnswers);
else else
tout = MkAtomTerm(Yap_LookupAtom("exec_answers")); tout = MkAtomTerm(AtomExecAnswers);
n++; n++;
} }
if (IsMode_SchedulingOn(yap_flags[flag])) { if (IsMode_SchedulingOn(yap_flags[flag])) {
Term taux = tout; Term taux = tout;
if (IsMode_Local(yap_flags[flag])) if (IsMode_Local(yap_flags[flag]))
tout = MkAtomTerm(Yap_LookupAtom("local")); tout = MkAtomTerm(Yap_AtomLocalA);
else else
tout = MkAtomTerm(Yap_LookupAtom("batched")); tout = MkAtomTerm(AtomBatched);
if (n) { if (n) {
taux = MkPairTerm(taux, MkAtomTerm(AtomNil)); taux = MkPairTerm(taux, MkAtomTerm(AtomNil));
tout = MkPairTerm(tout, taux); tout = MkPairTerm(tout, taux);
@ -3511,7 +3511,7 @@ p_access_yap_flags(void)
n++; n++;
} }
if (n == 0) if (n == 0)
tout = MkAtomTerm(Yap_LookupAtom("default")); tout = MkAtomTerm(AtomDefault);
} else } else
#endif /* TABLING */ #endif /* TABLING */
tout = MkIntegerTerm(yap_flags[flag]); tout = MkIntegerTerm(yap_flags[flag]);

38
C/sysbits.c
View File

@ -190,7 +190,7 @@ Yap_InitSysPath(void) {
{ {
char *dir; char *dir;
if ((dir = Yap_RegistryGetString("library"))) { if ((dir = Yap_RegistryGetString("library"))) {
Yap_PutValue(Yap_LookupAtom("system_library_directory"), Yap_PutValue(AtomSystemLibraryDir,
MkAtomTerm(Yap_LookupAtom(dir))); MkAtomTerm(Yap_LookupAtom(dir)));
return; return;
} }
@ -244,7 +244,7 @@ Yap_InitSysPath(void) {
strncat(Yap_FileNameBuf,"/", YAP_FILENAME_MAX); strncat(Yap_FileNameBuf,"/", YAP_FILENAME_MAX);
#endif #endif
strncat(Yap_FileNameBuf, "Yap", YAP_FILENAME_MAX); strncat(Yap_FileNameBuf, "Yap", YAP_FILENAME_MAX);
Yap_PutValue(Yap_LookupAtom("system_library_directory"), Yap_PutValue(AtomSystemLibraryDir,
MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf))); MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf)));
} }
@ -2085,7 +2085,7 @@ p_file_directory_name (void)
chp = Yap_FileNameBuf+strlen(Yap_FileNameBuf); chp = Yap_FileNameBuf+strlen(Yap_FileNameBuf);
while (!dir_separator(*--chp) && chp != Yap_FileNameBuf); while (!dir_separator(*--chp) && chp != Yap_FileNameBuf);
if (chp == Yap_FileNameBuf) { if (chp == Yap_FileNameBuf) {
return Yap_unify(MkAtomTerm(Yap_LookupAtom(".")),ARG2); return Yap_unify(MkAtomTerm(AtomDot),ARG2);
} }
*chp = '\0'; *chp = '\0';
return Yap_unify(MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf)),ARG2); return Yap_unify(MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf)),ARG2);
@ -2532,7 +2532,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_wake_up"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigWakeUp));
} }
if (ActiveSignals & YAP_ITI_SIGNAL) { if (ActiveSignals & YAP_ITI_SIGNAL) {
ActiveSignals &= ~YAP_ITI_SIGNAL; ActiveSignals &= ~YAP_ITI_SIGNAL;
@ -2540,7 +2540,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_iti"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigIti));
} }
if (ActiveSignals & YAP_INT_SIGNAL) { if (ActiveSignals & YAP_INT_SIGNAL) {
ActiveSignals &= ~YAP_INT_SIGNAL; ActiveSignals &= ~YAP_INT_SIGNAL;
@ -2548,7 +2548,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_int"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigInt));
} }
if (ActiveSignals & YAP_USR2_SIGNAL) { if (ActiveSignals & YAP_USR2_SIGNAL) {
ActiveSignals &= ~YAP_USR2_SIGNAL; ActiveSignals &= ~YAP_USR2_SIGNAL;
@ -2556,7 +2556,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_usr2"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigUsr2));
} }
if (ActiveSignals & YAP_USR1_SIGNAL) { if (ActiveSignals & YAP_USR1_SIGNAL) {
ActiveSignals &= ~YAP_USR1_SIGNAL; ActiveSignals &= ~YAP_USR1_SIGNAL;
@ -2564,7 +2564,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_usr1"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigUsr1));
} }
if (ActiveSignals & YAP_PIPE_SIGNAL) { if (ActiveSignals & YAP_PIPE_SIGNAL) {
ActiveSignals &= ~YAP_PIPE_SIGNAL; ActiveSignals &= ~YAP_PIPE_SIGNAL;
@ -2572,7 +2572,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_pipe"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigPipe));
} }
if (ActiveSignals & YAP_HUP_SIGNAL) { if (ActiveSignals & YAP_HUP_SIGNAL) {
ActiveSignals &= ~YAP_HUP_SIGNAL; ActiveSignals &= ~YAP_HUP_SIGNAL;
@ -2580,12 +2580,12 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_hup"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigHup));
} }
if (ActiveSignals & YAP_ALARM_SIGNAL) { if (ActiveSignals & YAP_ALARM_SIGNAL) {
ActiveSignals &= ~YAP_ALARM_SIGNAL; ActiveSignals &= ~YAP_ALARM_SIGNAL;
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_alarm"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigAlarm));
} }
if (ActiveSignals & YAP_DELAY_CREEP_SIGNAL) { if (ActiveSignals & YAP_DELAY_CREEP_SIGNAL) {
ActiveSignals &= ~(YAP_CREEP_SIGNAL|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)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_delay_creep"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigDelayCreep));
} }
if (ActiveSignals & YAP_CREEP_SIGNAL) { if (ActiveSignals & YAP_CREEP_SIGNAL) {
ActiveSignals &= ~YAP_CREEP_SIGNAL; ActiveSignals &= ~YAP_CREEP_SIGNAL;
@ -2601,7 +2601,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_creep"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigCreep));
} }
if (ActiveSignals & YAP_TRACE_SIGNAL) { if (ActiveSignals & YAP_TRACE_SIGNAL) {
ActiveSignals &= ~YAP_TRACE_SIGNAL; ActiveSignals &= ~YAP_TRACE_SIGNAL;
@ -2609,7 +2609,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_trace"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigTrace));
} }
if (ActiveSignals & YAP_DEBUG_SIGNAL) { if (ActiveSignals & YAP_DEBUG_SIGNAL) {
ActiveSignals &= ~YAP_DEBUG_SIGNAL; ActiveSignals &= ~YAP_DEBUG_SIGNAL;
@ -2617,7 +2617,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_debug"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigDebug));
} }
if (ActiveSignals & YAP_BREAK_SIGNAL) { if (ActiveSignals & YAP_BREAK_SIGNAL) {
ActiveSignals &= ~YAP_BREAK_SIGNAL; ActiveSignals &= ~YAP_BREAK_SIGNAL;
@ -2625,7 +2625,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_break"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigBreak));
} }
if (ActiveSignals & YAP_STACK_DUMP_SIGNAL) { if (ActiveSignals & YAP_STACK_DUMP_SIGNAL) {
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)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_stack_dump"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigStackDump));
} }
if (ActiveSignals & YAP_STATISTICS_SIGNAL) { if (ActiveSignals & YAP_STATISTICS_SIGNAL) {
ActiveSignals &= ~YAP_STATISTICS_SIGNAL; ActiveSignals &= ~YAP_STATISTICS_SIGNAL;
@ -2641,7 +2641,7 @@ p_first_signal(void)
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
#endif #endif
UNLOCK(SignalLock); UNLOCK(SignalLock);
return Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom("sig_statistics"))); return Yap_unify(ARG1, MkAtomTerm(AtomSigStatistics));
} }
#ifdef THREADS #ifdef THREADS
pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock)); pthread_mutex_unlock(&(ThreadHandle[worker_id].tlock));
@ -2734,7 +2734,7 @@ p_win32(void)
static Int static Int
p_ld_path(void) p_ld_path(void)
{ {
return Yap_unify(ARG1,MkAtomTerm(Yap_LookupAtom("LD_LIBRARY_PATH"))); return Yap_unify(ARG1,MkAtomTerm(AtomLDLibraryPath));
} }

7
C/userpreds.c
View File

@ -592,14 +592,11 @@ static int
p_grab_tokens() p_grab_tokens()
{ {
Term *p = ASP - 20, *p0, t; Term *p = ASP - 20, *p0, t;
Atom IdAtom, VarAtom;
Functor IdFunctor, VarFunctor; Functor IdFunctor, VarFunctor;
char ch, IdChars[256], *chp; char ch, IdChars[256], *chp;
IdAtom = Yap_LookupAtom("id"); IdFunctor = FunctorId;
IdFunctor = Yap_MkFunctor(IdAtom, 1); VarFunctor = FunctorVar;
VarAtom = Yap_LookupAtom("var");
VarFunctor = Yap_MkFunctor(VarAtom, 1);
p0 = p; p0 = p;
ch = Yap_PlGetchar(); ch = Yap_PlGetchar();
while (1) { while (1) {

4
C/utilpreds.c
View File

@ -2301,8 +2301,8 @@ camacho_dum(void)
/* build output list */ /* build output list */
t1 = MkAtomTerm(Yap_LookupAtom("[]")); t1 = TermNil;
t2 = MkPairTerm(MkIntegerTerm(max), t1); t2 = MkPairTerm(MkIntegerTerm(max), t1);
return(Yap_unify(t2, ARG1)); return(Yap_unify(t2, ARG1));
} }

10
C/write.c
View File

@ -124,7 +124,7 @@ wrputf(Float f, wrf writewch) /* writes a float */
} }
lastw = alphanum; lastw = alphanum;
// sprintf(s, "%.15g", f); // sprintf(s, "%.15g", f);
sprintf(s, RepAtom(FloatFormat)->StrOfAE, f); sprintf(s, RepAtom(AtomFloatFormat)->StrOfAE, f);
while (*pt == ' ') while (*pt == ' ')
pt++; pt++;
if (*pt == 'i' || *pt == 'n') /* inf or nan */ { 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]; char s[256];
putAtom(AtomDBRef, Quote_illegal, writewch); putAtom(AtomDBref, Quote_illegal, writewch);
#if SHORT_INTS #if SHORT_INTS
sprintf(s, "(0x%p,0)", ref); sprintf(s, "(0x%p,0)", ref);
#elif __linux__ #elif __linux__
@ -296,7 +296,7 @@ putAtom(Atom atom, int Quote_illegal, wrf writewch) /* writes an atom */
/* #define CRYPT_FOR_STEVE 1*/ /* #define CRYPT_FOR_STEVE 1*/
#ifdef CRYPT_FOR_STEVE #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]; char s[16];
sprintf(s,"x%x", (CELL)s); sprintf(s,"x%x", (CELL)s);
wrputs(s, writewch); 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) { if (wglb->MaxDepth != 0 && depth > wglb->MaxDepth) {
putAtom(Yap_LookupAtom("..."), wglb->Quote_illegal, wglb->writewch); putAtom(Atom3Dots, wglb->Quote_illegal, wglb->writewch);
return; return;
} }
if (EX != 0) if (EX != 0)
@ -481,7 +481,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg, struct write_globs *wglb)
long sl= 0; long sl= 0;
if (wglb->MaxList && eldepth > wglb->MaxList) { if (wglb->MaxList && eldepth > wglb->MaxList) {
putAtom(Yap_LookupAtom("..."), wglb->Quote_illegal, wglb->writewch); putAtom(Atom3Dots, wglb->Quote_illegal, wglb->writewch);
wrputc(']', wglb->writewch); wrputc(']', wglb->writewch);
lastw = separator; lastw = separator;
return; return;

257
H/Heap.h
View File

@ -370,137 +370,7 @@ typedef struct various_codes {
struct static_mega_clause *dead_mega_clauses; struct static_mega_clause *dead_mega_clauses;
struct static_index *dead_static_indices; struct static_index *dead_static_indices;
struct dbterm_list *dbterms_list; struct dbterm_list *dbterms_list;
Atom #include "tatoms.h"
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;
Term Term
#ifdef EUROTRA #ifdef EUROTRA
term_dollar_u, term_dollar_u,
@ -692,132 +562,7 @@ extern struct various_codes *Yap_heap_regs;
#define CharConversionTable2 Yap_heap_regs->char_conversion_table2 #define CharConversionTable2 Yap_heap_regs->char_conversion_table2
#define CurrentModules Yap_heap_regs->current_modules #define CurrentModules Yap_heap_regs->current_modules
#define OpList Yap_heap_regs->op_list #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 #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 TermDollarU Yap_heap_regs->term_dollar_u
#define TermProlog Yap_heap_regs->term_prolog #define TermProlog Yap_heap_regs->term_prolog
#define TermReFoundVar Yap_heap_regs->term_refound_var #define TermReFoundVar Yap_heap_regs->term_refound_var

2
H/Yap.h
View File

@ -1114,7 +1114,7 @@ TailOfTermCell (Term t)
/*************** variables concerned with atoms table *******************/ /*************** variables concerned with atoms table *******************/
#define MaxHash 1001 #define MaxHash 3333
#define MaxWideHash (MaxHash/10+1) #define MaxWideHash (MaxHash/10+1)
#define FAIL_RESTORE 0 #define FAIL_RESTORE 0

341
H/iatoms.h Normal file
View File

@ -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);

344
H/ratoms.h Normal file
View File

@ -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);

125
H/rheap.h
View File

@ -817,130 +817,7 @@ restore_codes(void)
icl = icl->SiblingIndex; icl = icl->SiblingIndex;
} }
} }
Yap_heap_regs->atom_abol = AtomAdjust(Yap_heap_regs->atom_abol); #include "ratoms.h"
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);
#ifdef EUROTRA #ifdef EUROTRA
Yap_heap_regs->term_dollar_u = AtomTermAdjust(Yap_heap_regs->term_dollar_u); Yap_heap_regs->term_dollar_u = AtomTermAdjust(Yap_heap_regs->term_dollar_u);
#endif #endif

688
H/tatoms.h Normal file
View File

@ -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_

5
LGPL/PLStream/buildatoms
View File

@ -11,7 +11,7 @@
:- yap_flag(write_strings,on). :- yap_flag(write_strings,on).
main :- main :-
file_filter('ATOMS','atoms.h',gen_decl). file_filter('ATOMS','../H/atoms.h',gen_decl).
gen_decl(Inp,Out) :- gen_decl(Inp,Out) :-
split(Inp," ",["A",Atom,String]), !, split(Inp," ",["A",Atom,String]), !,
@ -30,6 +30,3 @@ counter(I) :-
I1 is I+1, I1 is I+1,
nb_setval(count,I1). nb_setval(count,I1).

1
Makefile.in
View File

@ -131,6 +131,7 @@ HEADERS = \
$(srcdir)/OPTYap/alpha_locks_funcs.h \ $(srcdir)/OPTYap/alpha_locks_funcs.h \
$(srcdir)/OPTYap/pthread_locks.h \ $(srcdir)/OPTYap/pthread_locks.h \
$(srcdir)/H/cut_c.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.h $(srcdir)/MYDDAS/myddas_structs.h \
$(srcdir)/MYDDAS/myddas_statistics.h \ $(srcdir)/MYDDAS/myddas_statistics.h \
$(srcdir)/MYDDAS/myddas_statistics_structs.h \ $(srcdir)/MYDDAS/myddas_statistics_structs.h \

351
misc/ATOMS Normal file
View File

@ -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