From 65ff3ed471bfc6a6ce5d306febb140600827ba5f Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Mon, 20 Feb 2017 15:28:46 +0000 Subject: [PATCH] Smaller updates: constant use of longjmp conflict with python headers win32 support dll support --- #.gitignore# | 203 ++ #GitSHA1.c.in# | 2 + .ctags | 6 + .gitignore | 2 +- BEAM/eamamasm.c | 48 +- BEAM/eamindex.c | 46 +- C/amasm.c | 2 +- C/c_interface.c | 80 +- C/cdmgr.c | 2 +- C/errors.c | 4 +- C/exec.c | 168 +- C/flags.c | 13 +- C/globals.c | 2 +- C/heapgc.c | 13 +- C/load_dll.c | 21 +- C/load_foreign.c | 10 +- C/parser.c | 6 +- C/signals.c | 2 +- C/stdpreds.c | 26 +- C/write.c | 2 +- CMakeLists.txt | 70 +- H/LOCALS | 10 +- H/TermExt.h | 2 + H/Yap.h | 39 +- H/YapCompile.h | 2 +- H/{eval.h => YapEval.h} | 6 +- H/YapHeap.h | 2 +- H/YapTags.h | 66 +- H/YapTerm.h | 27 +- H/YapText.h | 17 + H/Yapproto.h | 7 +- H/absmi.h | 4 +- H/blobs.h | 2 +- H/generated/dlocals.h | 2 + H/generated/hlocals.h | 7 +- H/generated/iatoms.h | 1168 ++++---- H/generated/ilocals.h | 3 +- H/generated/ratoms.h | 1168 ++++---- H/generated/rlocals.h | 1 + H/generated/tatoms.h | 1889 ++++++++----- H/tracer.h | 6 +- JIT/HPP/jit_predicates.hpp | 2 +- OPTYap/CMakeLists.txt | 5 +- OPTYap/opt.preds.c | 2 +- OPTYap/tab.tries.c | 2 +- Packages.cmake | 3 +- autoconf/Makefile.in | 4 +- cmake/Config.cmake | 30 +- cmake/Model.cmake | 1 + Prelims.cmake => cmake/Prelims.cmake | 3 +- cmake/Sources.cmake | 4 +- cmake/python.cmake | 83 +- config.h.cmake | 25 + configure | 17 +- gtags.conf | 46 + include/SWI-Prolog.h | 389 ++- include/VFS.h | 8 +- include/YapError.h | 6 +- include/YapFormat.h | 61 + include/YapInterface.h | 58 +- include/YapStreams.h | 2 + libYap.cmake | 1 - library/dialect/swi/fli/CMakeLists.txt | 2 + library/dialect/swi/fli/swi.c | 31 +- library/dialect/swi/os/pl-prologflag.c | 2 +- library/lammpi/CMakeLists.txt | 1 + library/lammpi/yap_mpi.c | 4 +- library/matlab/CMakeLists.txt | 2 +- library/matrix/CMakeLists.txt | 3 +- library/matrix/matrix.c | 4 +- library/random/yap_random.c | 4 +- library/regex/CMakeLists.txt | 11 +- library/regex/regexec.c | 4 +- library/rltree/range_list.c | 945 ++++--- library/system/CMakeLists.txt | 5 +- library/system/sys.c | 4 +- library/tries/CMakeLists.txt | 10 +- library/tries/core_dbtries.c | 12 +- library/tries/tries.c | 28 +- misc/buildatoms | 8 +- misc/mktags | 13 + os/CMakeLists.txt | 4 +- os/readterm.c | 38 +- os/time.c | 129 +- os/write.c | 2 +- packages/CMakeLists.txt | 62 + packages/Makefile.in | 84 + packages/README | 12 + packages/bdd/CMakeLists.txt | 3 +- packages/bdd/bdd.yap | 91 +- packages/bdd/trie_sp.yap | 35 +- packages/clp_examples/3jugs.yap | 129 + packages/clp_examples/photo.yap | 85 + packages/clp_examples/queens.yap | 49 + packages/clp_examples/send_more_money.yap | 44 + packages/clp_examples/send_most_money.yap | 47 + packages/clp_examples/sudoku.yap | 84 + packages/clp_examples/test.yap | Bin 0 -> 2807 bytes packages/clpfd.yap | 1318 +++++++++ packages/cplint/CMakeLists.txt | 6 +- packages/cuda/CMakeLists.txt | 2 +- packages/examples/photo.yap | 80 + packages/examples/queens.yap | 67 + packages/examples/send_more_money.yap | 41 + packages/examples/send_most_money.yap | 45 + packages/gecode/CMakeLists.txt | 3 +- packages/jpl/src/c/CMakeLists.txt | 3 +- packages/jpl/src/c/jpl.c | 19 +- packages/myddas/CMakeLists.txt | 4 + packages/myddas/mysql/CMakeLists.txt | 5 +- packages/myddas/odbc/CMakeLists.txt | 3 +- packages/myddas/postgres/CMakeLists.txt | 3 +- packages/myddas/postgres/myddas_postgres.c | 2 +- packages/myddas/sqlite3/CMakeLists.txt | 1 + packages/myddas/sqlite3/myddas_sqlite3.c | 2 +- packages/pyswip/pyswip/core.py | 2 +- packages/python/CMakeLists.txt | 42 +- packages/raptor/CMakeLists.txt | 6 +- packages/raptor/raptor_yap.c | 6 +- packages/raptor/xml2_yap.c | 4 +- packages/real/CMakeLists.txt | 34 +- packages/real/real.c | 2857 +++++++++----------- packages/real/real.pl | 3 +- packages/swig/CMakeLists.txt | 12 +- packages/swig/java/CMakeLists.txt | 8 +- packages/swig/python/CMakeLists.txt | 147 +- packages/swig/python/setup.py.cmake | 14 +- packages/swig/yap.i | 619 +++-- pl/absf.yap | 6 +- pl/load_foreign.yap | 7 +- pl/pathconf.yap | 9 +- 131 files changed, 8125 insertions(+), 5154 deletions(-) create mode 100644 #.gitignore# create mode 100644 #GitSHA1.c.in# rename H/{eval.h => YapEval.h} (99%) rename Prelims.cmake => cmake/Prelims.cmake (99%) create mode 100644 gtags.conf create mode 100644 include/YapFormat.h create mode 100644 misc/mktags create mode 100644 packages/CMakeLists.txt create mode 100644 packages/Makefile.in create mode 100644 packages/README create mode 100644 packages/clp_examples/3jugs.yap create mode 100644 packages/clp_examples/photo.yap create mode 100644 packages/clp_examples/queens.yap create mode 100644 packages/clp_examples/send_more_money.yap create mode 100644 packages/clp_examples/send_most_money.yap create mode 100644 packages/clp_examples/sudoku.yap create mode 100644 packages/clp_examples/test.yap create mode 100644 packages/clpfd.yap create mode 100644 packages/examples/photo.yap create mode 100644 packages/examples/queens.yap create mode 100644 packages/examples/send_more_money.yap create mode 100644 packages/examples/send_most_money.yap diff --git a/#.gitignore# b/#.gitignore# new file mode 100644 index 000000000..814c15609 --- /dev/null +++ b/#.gitignore# @@ -0,0 +1,203 @@ +*~ +*.itf +*.po +*.qlf +*.xwam +*.wam +*.ma +*.s +*.o +*.so +*.dylib +*.dll +docs/yap.info* +.build +tags +TGSautom4te.cache +cscope.* +GPATH +m32 +GRTAGS +GTAGS +tmtags* +.autotools +.Rhistory +.zedstate +config.h +Yap.h +YapConfig.h +YapTermConfig.h +.graffiti +.#*# +*/#*# +*bak +*rej +*.db +groups +*.ede +.??* +*ggtags* +.atom-build.josn +.autotools +.cproject +.dir-locals.el +.DS_store +.kateproject +.project +.pydevproject +.Rhistory +.zedstate +.graffiti +.kateproject +autom4te.cache +*rej +#* +#*# +config.h +*.html +packages/gecode/dev +JIT/HPP/bkp +cmake_install.cmake +cmake_clean.cmake +*.build +C/myabsmi.c +*.ctags# +*.hs +CMakeFiles +*.make +C/new_iop.c +*.pdf +*.log +*.orig +JIT/HPP/#JIT_In# +*.text +yap +*startup.yss +*cmake_files +C/pl-yap.c +GitSHA1.c +.vscode +CMakeLists.txt.* +FindPackageLog.txt +GitSHA1.c +clang +cmake-build-debug +os/YapIOConfig.h +CodeBlocks + +os/readterm.c.cpp + +os/readterm.c.cpp + +packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot + +packages/ProbLog/#problog_lbdd.yap# + +packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot + +packages/ProbLog/problog_examples/output/out.dat + +packages/ProbLog/problog_examples/outputvalues.pl + +packages/ProbLog/problogbdd + +packages/raptor/raptor_config.h + +packages/real/rconfig.h + +packages/ProbLog/problog/#completion.yap# + +packages/ProbLog/problog_examples/output +packages/ProbLog/problog_examples/queries +packages/swig/java/*.java +packages/swig/java/*.class +packages/swig/java/*.jar +packages/swig/java/*wrap* +*jnilib +*.jar +*LOG +packages/cplint/approx/simplecuddLPADs/LPADBDD + +packages/swi-minisat2/˜:ilp +packages/swig/android/app +packages/cplint/L + +packages/CLPBN/horus/hcli +tmp +Eclipse +packages/bdd/simplecudd/problogbdd +trace +packages/bdd/cudd_config.h +Makefile +build +Debug +debug +Release +Build +xcode +Threads +droid +mxe +mxe32 +msys2 +caret +codelite +configure +Qt +cmake/cmake-android +sublime +yap-6.3.workspace +yap-6.3.geany +YAP.project +CBlocks +yPQ +*.tmp +YAP.sublime* +yap32 +Eclipse +codeblocks +yap-6.3.tags +android +yap.prj + +yap.VITORs-MBP.vsc.pui +vc +packages/myddas/pl/myddas_odbc.yap + +packages/myddas/pl/myddas_postgres.yap + +packages/myddas/pl/myddas_sqlite3.ypp + +packages/myddas/pl/#myddas_postgres.ypp# + +packages/myddas/hh + +packages/myddas/DaysInHospital_Y3.csv + +packages/myddas/agile.csv + +*.pyc + +*.cmake# + +*.tex + +*.c# + +packages/swig/yap_wrap.cxx + +packages/swig/yap_wrap.h + +packages/swig/yap_wrap.cpp + +packages/swig/yap.py + +*.ipynb +yap +packages/python/yap_kernel/x/__init__.py +x +packages/python/yap_kernel/x/__main__.py + +*.gch +mxe +build diff --git a/#GitSHA1.c.in# b/#GitSHA1.c.in# new file mode 100644 index 000000000..17c3143ef --- /dev/null +++ b/#GitSHA1.c.in# @@ -0,0 +1,2 @@ +eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee#define GIT_SHA1 "@GIT_SHA1@" +const char g_GIT_SHA1[] = GIT_SHA1; diff --git a/.ctags b/.ctags index 2fc149c54..2f53b2a9a 100644 --- a/.ctags +++ b/.ctags @@ -6,6 +6,7 @@ --regex-Prolog=/^([a-z][A-Za-z0-9_]*:)?\'(.*)\'\(.*\)\.[ \t]*.*/\2/p,predicate,predicate definition/ --regex-Prolog=/^:-[ \t]+(discontiguous|dynamic|multifile|table|thread_local)[ \t]+([a-z][_a-zA-Z0-9]*:)?([a-z0-9_][_a-zA-Z0-9]*)/\1/p,predicate,predicate metadata/ --regex-Prolog=/^[ \t]*Yap_InitCPred[ \t]*\"(\$?[A-Za-z0-9_]*)\"([ \t]*).*/\1/p,predicate,predicate definition/ +--langmap=C:+.(h.cmake).(h.config) --exclude=\._* --exclude=*\.bak --exclude=\.svn @@ -22,3 +23,8 @@ --exclude=\#.* --exclude=(.)\#* --exclude=*.dylib +--exclude=docs +--exclude=build +--exclude=cmake-build-debug +--exclude=clang + diff --git a/.gitignore b/.gitignore index 104696a90..42f6b30ff 100644 --- a/.gitignore +++ b/.gitignore @@ -84,7 +84,7 @@ clang cmake-build-debug os/YapIOConfig.h CodeBlocks - +x os/readterm.c.cpp os/readterm.c.cpp diff --git a/BEAM/eamamasm.c b/BEAM/eamamasm.c index 9773e091e..3671a3d19 100644 --- a/BEAM/eamamasm.c +++ b/BEAM/eamamasm.c @@ -12,8 +12,8 @@ #ifdef BEAM #include "Yap.h" -#include "compile.h" -#include "clause.h" +#include "YapCompile.h" +#include "clause.h" #include "eam.h" #include "eamamasm.h" #include @@ -85,7 +85,7 @@ int X_Var(Ventry *ve) int var; if (ve->KindOfVE == PermVar || ve->KindOfVE == VoidVar ) { - printf("Erro no tipo de variavel X ->eamamas.c \n"); + printf("Erro no tipo de variavel X ->eamamas.c \n"); exit(1); } var = ((ve->NoOfVE) & MaskVarAdrs); @@ -99,7 +99,7 @@ int Y_Var(Ventry *ve) { int var; if (ve->KindOfVE != PermVar) { - printf("Erro no tipo de variavel Y ->eamamas.c \n"); + printf("Erro no tipo de variavel Y ->eamamas.c \n"); exit(1); } var = ((ve->NoOfVE) & MaskVarAdrs); @@ -119,7 +119,7 @@ void eam_pass(CInstr *ppc) { int alloc_found=0; int body=0; - + while (ppc) { switch ((int) ppc->op) { @@ -184,7 +184,7 @@ void eam_pass(CInstr *ppc) } else { emit_inst(_unify_val_Y_op); emit_par(Y_Var((Ventry *) ppc->new4)); - + } } else { emit_inst(_unify_void_op); } break; @@ -268,7 +268,7 @@ void eam_pass(CInstr *ppc) case put_atom_op: emit_inst(_put_atom_op); emit_par(ppc->new1); - emit_par(ppc->new4); + emit_par(ppc->new4); break; case put_list_op: emit_inst(_put_list_op); @@ -349,7 +349,7 @@ void eam_pass(CInstr *ppc) case cut_op: emit_inst(_cut_op); - break; + break; case commit_op: emit_inst(_commit_op); break; @@ -402,7 +402,7 @@ void eam_pass(CInstr *ppc) } emit_par(ppc->new4); break; - + case direct_safe_call_op: if (ppc->new1==1) { emit_inst(_direct_safe_call_unary_op); @@ -434,8 +434,8 @@ void eam_pass(CInstr *ppc) if (a==NULL) a=Yap_LookupAtom("\n"); emit_inst(_put_atom_op); emit_par(1); - emit_par((Cell) MkAtomTerm(a)); - } + emit_par((Cell) MkAtomTerm(a)); + } emit_inst(_write_call); break; case is_op: @@ -468,50 +468,50 @@ void eam_pass(CInstr *ppc) case remove_box_op: case remove_last_box_op: break; - + case jump_op: emit_inst(_jump_op); emit_upar((Cell) Code_Start+ (Cell) labels[ppc->new4]); break; case label_op: - if (pass==0) labels[ppc->new4] = get_addr(); + if (pass==0) labels[ppc->new4] = get_addr(); break; case run_op: /* se ficar vazio, retirar no eam_am.c o +5 das linhas pc=clause->code+5 no only_1_clause e no call */ emit_inst(_try_me_op); emit_par(0); - emit_par(0); emit_par(0); - emit_par(0); + emit_par(0); + emit_par(0); break; case only_1_clause_op: emit_inst(_only_1_clause_op); emit_par(ppc->new4); emit_par(((struct Clauses *)ppc->new4)->predi->arity); - emit_par(((struct Clauses *)ppc->new4)->nr_vars); + emit_par(((struct Clauses *)ppc->new4)->nr_vars); emit_par(0); /* Nr da alternativa */ break; case try_me_op: emit_inst(_try_me_op); - emit_par(ppc->new4); + emit_par(ppc->new4); emit_par(((struct Clauses *)ppc->new4)->predi->arity); - emit_par(((struct Clauses *)ppc->new4)->nr_vars); + emit_par(((struct Clauses *)ppc->new4)->nr_vars); emit_par(0); /* Nr da alternativa */ break; case retry_me_op: emit_inst(_retry_me_op); emit_par(ppc->new4); emit_par(((struct Clauses *)ppc->new4)->predi->arity); - emit_par(((struct Clauses *)ppc->new4)->nr_vars); + emit_par(((struct Clauses *)ppc->new4)->nr_vars); emit_par(ppc->new1); break; case trust_me_op: emit_inst(_trust_me_op); emit_par(ppc->new4); emit_par(((struct Clauses *)ppc->new4)->predi->arity); - emit_par(((struct Clauses *)ppc->new4)->nr_vars); + emit_par(((struct Clauses *)ppc->new4)->nr_vars); emit_par(ppc->new1); break; @@ -529,11 +529,11 @@ void eam_pass(CInstr *ppc) } body=1; break; - + case prepare_tries: emit_inst(_prepare_tries); - emit_par(ppc->new1); - emit_par(ppc->new4); + emit_par(ppc->new1); + emit_par(ppc->new4); break; case exit_op: @@ -559,7 +559,7 @@ void eam_pass(CInstr *ppc) printf("[ please note that beam still does not support a lot of builtins ]\n"); } emit_inst(_fail_op); - + } ppc = ppc->nextInst; } diff --git a/BEAM/eamindex.c b/BEAM/eamindex.c index 59d6ce964..f9aa20db8 100644 --- a/BEAM/eamindex.c +++ b/BEAM/eamindex.c @@ -12,8 +12,8 @@ #ifdef BEAM #include "Yap.h" -#include "compile.h" -#include "clause.h" +#include "YapCompile.h" +#include "clause.h" #include "eam.h" #include #include @@ -40,13 +40,13 @@ int exists_on_table(Cell a,struct HASH_TABLE **table, int i) struct HASH_TABLE *t; t=table[i]; - + while(t) { if (t->value==a) return(1); - + t=t->next; } - + return(0); } @@ -61,20 +61,20 @@ Cell *gera_codigo_try(struct Predicates *predi) /* gerar os try's para o predic emit_new(prepare_tries,predi->nr_alt,predi->arity); if (predi->nr_alt==1) { - emit_new(only_1_clause_op,0,(unsigned long) c); - } else if (predi->nr_alt>1) { + emit_new(only_1_clause_op,0,(unsigned long) c); + } else if (predi->nr_alt>1) { while(c!=NULL) { - if (nr+1==predi->nr_alt) emit_new(trust_me_op,nr,(unsigned long) c); + if (nr+1==predi->nr_alt) emit_new(trust_me_op,nr,(unsigned long) c); else if (nr==0) emit_new(try_me_op,predi->nr_alt,(unsigned long) c); else emit_new(retry_me_op,nr,(unsigned long) c); c=c->next; nr++; } - } else { + } else { emit_new(fail_op,0,0); } - + return(eam_assemble(StartCode)); } @@ -91,7 +91,7 @@ Cell *gera_codigo_try_list(struct Predicates *predi) /* gerar os try's para o p c=predi->first; emit_new(prepare_tries,nr_preds,predi->arity); - if (nr_preds>=1) { + if (nr_preds>=1) { while(c!=NULL) { if (c->predi==predi && (c->idx==Lista || c->idx==Variavel)) { if (nr_preds==1) { @@ -108,20 +108,20 @@ Cell *gera_codigo_try_list(struct Predicates *predi) /* gerar os try's para o p } else { emit_new(fail_op,0,0); } - + return(eam_assemble(StartCode)); } -struct HASH_TABLE **gera_codigo_try_atom(struct Predicates *predi) +struct HASH_TABLE **gera_codigo_try_atom(struct Predicates *predi) { int j,nr_preds,nr_atoms; struct HASH_TABLE **table; struct HASH_TABLE *t; struct Clauses *cla; - nr_atoms=predi->idx_atom; + nr_atoms=predi->idx_atom; nr_preds=nr_atoms+predi->idx_var; table=malloc(sizeof(struct HASH_TABLE *)*(nr_atoms+1)); for (j=0;j<=nr_atoms;j++) table[j]=NULL; @@ -132,7 +132,7 @@ struct Clauses *cla; Cell a; unsigned int index; int nr; - + a=cla->val; if (a && nr_atoms) { index=index_of_hash_table_atom(a,nr_atoms); @@ -187,18 +187,18 @@ struct HASH_TABLE **table; struct HASH_TABLE *t; struct Clauses *cla; - nr_appls=predi->idx_functor; + nr_appls=predi->idx_functor; nr_preds=nr_appls+predi->idx_var; table=malloc(sizeof(struct HASH_TABLE *)*(nr_appls+1)); for (j=0;j<=nr_appls;j++) table[j]=NULL; - + cla=predi->first; while(cla) { if (cla->idx==Estrutura) { Cell a; long int index; int nr; - + a=cla->val; if (a && nr_appls) { index=index_of_hash_table_appl(a,nr_appls); @@ -257,7 +257,7 @@ Cell *gera_codigo_try_only_vars(struct Predicates *predi) /* gerar os try's de V c=predi->first; emit_new(prepare_tries,nr_preds,predi->arity); - if (nr_preds>=1) { + if (nr_preds>=1) { while(c!=NULL) { if (c->predi==predi && c->idx==Variavel) { if (nr_preds==1) { @@ -274,7 +274,7 @@ Cell *gera_codigo_try_only_vars(struct Predicates *predi) /* gerar os try's de V } else { emit_new(fail_op,0,0); } - + return(eam_assemble(StartCode)); } @@ -292,7 +292,7 @@ void do_eam_indexing(struct Predicates *p) p->idx=1; } - if((Print_Code & 4) && (Print_Code & 8)) { + if((Print_Code & 4) && (Print_Code & 8)) { printf("General Case :\n"); eam_showcode(p->code); } @@ -309,10 +309,10 @@ void ver_predicados(struct Predicates *p) c=p->first; while(c!=NULL) { - printf("Clausula %d do tipo %d (%d locals %d args) (val=0x%X)\n",++i,c->idx,c->nr_vars,c->predi->arity, (unsigned )c->val); + printf("Clausula %d do tipo %d (%d locals %d args) (val=0x%X)\n",++i,c->idx,c->nr_vars,c->predi->arity, (unsigned )c->val); c=c->next; } - + } diff --git a/C/amasm.c b/C/amasm.c index de132f952..ca67e65af 100755 --- a/C/amasm.c +++ b/C/amasm.c @@ -188,7 +188,7 @@ static char SccsId[] = "@(#)amasm.c 1.3 3/15/90"; #include "Yap.h" #include "clause.h" -#include "compile.h" +#include "YapCompile.h" #include "yapio.h" #ifdef BEAM diff --git a/C/c_interface.c b/C/c_interface.c index 1fedec402..d35554ee0 100755 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -127,8 +127,7 @@ X_API yhandle_t YAP_CurrentSlot(void); /// @brief allocate n empty new slots /// -/// Return a handle to the system's default slot. -X_API yhandle_t YAP_NewSlots(int NumberOfSlots); +/// Return a handle to the system's default slo t. iX_API yhandle_t YAP_NewSlots(int NumberOfSlots); /// @brief allocate n empty new slots /// @@ -246,6 +245,8 @@ X_API YAP_Bool YAP_IsRationalTerm(YAP_Term t) { #endif } +X_API YAP_Bool YAP_IsStringTerm(YAP_Term t) { return (IsStringTerm(t)); } + X_API YAP_Bool YAP_IsVarTerm(YAP_Term t) { return (IsVarTerm(t)); } X_API YAP_Bool YAP_IsNonVarTerm(YAP_Term t) { return (IsNonVarTerm(t)); } @@ -277,6 +278,32 @@ X_API Term YAP_MkIntTerm(Int n) { return I; } +X_API Term YAP_MkStringTerm(const char *n) { + CACHE_REGS + Term I; + BACKUP_H(); + + I = MkStringTerm(n); + RECOVER_H(); + return I; +} + +X_API Term YAP_MkUnsignedStringTerm(const unsigned char *n) { + CACHE_REGS + Term I; + BACKUP_H(); + + I = MkUStringTerm(n); + RECOVER_H(); + return I; +} + +X_API const char *YAP_StringOfTerm(Term t) { return StringOfTerm(t); } + +X_API const unsigned char *YAP_UnsignedStringOfTerm(Term t) { + return UStringOfTerm(t); +} + X_API Int YAP_IntOfTerm(Term t) { if (!IsApplTerm(t)) return IntOfTerm(t); @@ -1380,8 +1407,8 @@ X_API Term YAP_ReadBuffer(const char *s, Term *tp) { tv = 0; LOCAL_ErrorMessage = NULL; const unsigned char *us = (const unsigned char *)s; - while (!(t = Yap_BufferToTermWithPrioBindings( - us, strlen(s) + 1, TermNil, GLOBAL_MaxPriority, tv))) { + while (!(t = Yap_BufferToTermWithPrioBindings(us, strlen(s) + 1, TermNil, + GLOBAL_MaxPriority, tv))) { if (LOCAL_ErrorMessage) { if (!strcmp(LOCAL_ErrorMessage, "Stack Overflow")) { if (!Yap_dogc(0, NULL PASS_REGS)) { @@ -1638,7 +1665,6 @@ X_API PredEntry *YAP_AtomToPredInModule(Atom at, Term mod) { static int run_emulator(USES_REGS1) { int out; - LOCAL_PrologMode &= ~(UserCCallMode | CCallMode); out = Yap_absmi(0); LOCAL_PrologMode |= UserCCallMode; return out; @@ -1661,7 +1687,7 @@ X_API bool YAP_EnterGoal(PredEntry *pe, CELL *ptr, YAP_dogoalinfo *dgi) { // slot=%d", pe, pe->CodeOfPred->opc, FAILCODE, Deref(ARG1), Deref(ARG2), // LOCAL_CurSlot); dgi->b = LCL0 - (CELL *)B; - out = run_emulator(PASS_REGS1); + out = Yap_exec_absmi(true, false); RECOVER_MACHINE_REGS(); if (out) { dgi->EndSlot = LOCAL_CurSlot; @@ -2122,16 +2148,20 @@ X_API YAP_Term YAP_CopyTerm(Term t) { X_API char *YAP_WriteBuffer(Term t, char *buf, size_t sze, int flags) { CACHE_REGS - size_t length; + seq_tv_t inp, out; + size_t length = sze; char *b; BACKUP_MACHINE_REGS(); - if ((b = Yap_TermToString(t, &length, LOCAL_encoding, flags)) != buf) { - RECOVER_MACHINE_REGS(); - return b; - } + inp.val.t = t; + inp.type = YAP_STRING_TERM; + out.type = YAP_STRING_CHARS; + out.val.c = buf; + out.enc = LOCAL_encoding; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return NULL; RECOVER_MACHINE_REGS(); - return buf; + return out.val.c; } /// write a a term to n user-provided buffer: make sure not tp @@ -2253,13 +2283,11 @@ static void do_bootfile(const char *bootfilename USES_REGS) { the module. */ -static bool initialized = false; +X_API bool YAP_initialized = false; static int n_mdelays = 0; static YAP_delaymodule_t *m_delays; X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) { - if (initialized) - return false; if (m_delays) { m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t)); } else { @@ -2271,6 +2299,17 @@ X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) { return true; } +bool Yap_LateInit(const char s[]) { + int i; + for (i = 0; i < n_mdelays; i++) { + if (!strcmp(m_delays[i].s, s)) { + m_delays[i].f(); + return true; + } + } + return false; +} + static void start_modules(void) { Term cm = CurrentModule; size_t i; @@ -2296,9 +2335,8 @@ YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { const char *yroot; /* ignore repeated calls to YAP_Init */ - if (initialized) + if (YAP_initialized) return YAP_FOUND_BOOT_ERROR; - initialized = true; Yap_embedded = yap_init->Embedded; Yap_page_size = Yap_InitPageSize(); /* init memory page size, required by @@ -2306,9 +2344,10 @@ YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { #if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA) Yap_init_yapor_global_local_memory(); #endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA */ - GLOBAL_PrologShouldHandleInterrupts = yap_init->PrologShouldHandleInterrupts && - !yap_init->Embedded; - Yap_InitSysbits(0); /* init signal handling and time, required by later + // GLOBAL_PrologShouldHandleInterrupts = + // yap_init->PrologShouldHandleInterrupts && + if (!yap_init->Embedded) + Yap_InitSysbits(0); /* init signal handling and time, required by later functions */ GLOBAL_argv = yap_init->Argv; GLOBAL_argc = yap_init->Argc; @@ -2492,6 +2531,7 @@ YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, false); } start_modules(); + YAP_initialized = true; return rc; } diff --git a/C/cdmgr.c b/C/cdmgr.c index 65acb4b91..237347c24 100644 --- a/C/cdmgr.c +++ b/C/cdmgr.c @@ -20,7 +20,7 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98"; #include "Yap.h" #include "clause.h" -#include "eval.h" +#include "YapEval.h" #include "tracer.h" #include "yapio.h" #ifdef YAPOR diff --git a/C/errors.c b/C/errors.c index c1b52d23f..ba62468c5 100755 --- a/C/errors.c +++ b/C/errors.c @@ -207,7 +207,7 @@ void Yap_RestartYap(int flag) { #if PUSH_REGS restore_absmi_regs(&Yap_standard_regs); #endif - siglongjmp(LOCAL_RestartEnv, 1); + siglongjmp(*LOCAL_RestartEnv, 1); } static void error_exit_yap(int value) { @@ -328,7 +328,7 @@ void Yap_ThrowError__(const char *file, const char *function, int lineno, } else { Yap_Error__(file, function, lineno, type, where); } - siglongjmp(LOCAL_RestartEnv, 4); + siglongjmp(*LOCAL_RestartEnv, 4); } /** diff --git a/C/exec.c b/C/exec.c index 9b099872a..98e4dc532 100755 --- a/C/exec.c +++ b/C/exec.c @@ -48,7 +48,7 @@ static choiceptr cp_from_integer(Term cpt USES_REGS) { */ Term Yap_cp_as_integer(choiceptr cp) { CACHE_REGS - return cp_as_integer(cp PASS_REGS); + return cp_as_integer(cp PASS_REGS); } /** @@ -128,7 +128,7 @@ inline static bool CallMetaCall(Term t, Term mod USES_REGS) { */ Term Yap_ExecuteCallMetaCall(Term mod) { CACHE_REGS - Term ts[4]; + Term ts[4]; ts[0] = ARG1; ts[1] = cp_as_integer(B PASS_REGS); /* p_current_choice_point */ ts[2] = ARG1; @@ -141,8 +141,8 @@ Term Yap_ExecuteCallMetaCall(Term mod) { Term Yap_PredicateIndicator(Term t, Term mod) { CACHE_REGS - // generate predicate indicator in this case - Term ti[2]; + // generate predicate indicator in this case + Term ti[2]; t = Yap_YapStripModule(t, &mod); if (IsApplTerm(t) && !IsExtensionFunctor(FunctorOfTerm(t))) { ti[0] = MkAtomTerm(NameOfFunctor(FunctorOfTerm(t))); @@ -210,12 +210,12 @@ static Int save_env_b(USES_REGS1) { } /** Look for a predicate with same functor as t, - create a new one of it cannot find it. - */ + create a new one of it cannot find it. +*/ static PredEntry *new_pred(Term t, Term tmod, char *pname) { Term t0 = t; -restart: + restart: if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t0, pname); return NULL; @@ -273,7 +273,7 @@ inline static bool do_execute(Term t, Term mod USES_REGS) { Term t0 = t; t = Yap_YapStripModule(t, &mod); /* first do predicate expansion, even before you process signals. - This way you don't get to spy goal_expansion(). */ + This way you don't get to spy goal_expansion(). */ if (Yap_has_a_signal() && !LOCAL_InterruptsDisabled && !(LOCAL_PrologMode & (AbortMode | InterruptMode | SystemMode))) { return EnterCreepMode(t, mod PASS_REGS); @@ -393,7 +393,7 @@ inline static bool do_execute_n(Term t, Term mod, unsigned int n USES_REGS) { int j = -n; Term t0 = t; -restart_exec: + restart_exec: if (IsVarTerm(t)) { return CallError(INSTANTIATION_ERROR, t0, mod PASS_REGS); } else if (IsAtomTerm(t)) { @@ -432,8 +432,8 @@ restart_exec: } if (Yap_has_a_signal() && !LOCAL_InterruptsDisabled) { return EnterCreepMode( - copy_execn_to_heap(f, pt, n, arity, CurrentModule PASS_REGS), - mod PASS_REGS); + copy_execn_to_heap(f, pt, n, arity, CurrentModule PASS_REGS), + mod PASS_REGS); } if (arity > MaxTemps) { return CallError(TYPE_ERROR_CALLABLE, t, mod PASS_REGS); @@ -650,7 +650,7 @@ static Int execute_clause(USES_REGS1) { /* '$execute_clause'(Goal) */ yamop *code; Term clt = Deref(ARG3); -restart_exec: + restart_exec: if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, ARG3, "call/1"); return FALSE; @@ -746,7 +746,7 @@ static void prune_inner_computation(choiceptr parent) { cut_pt = B; while (cut_pt < parent) { /* make sure we - e C-choicepoints */ + e C-choicepoints */ if (POP_CHOICE_POINT(cut_pt->cp_b)) { POP_EXECUTE(); } @@ -791,7 +791,7 @@ static void complete_inner_computation(choiceptr old_B) { static inline Term *GetTermAddress(CELL a) { Term *b = NULL; -restart: + restart: if (!IsVarTerm(a)) { return (b); } else if (a == (CELL)b) { @@ -845,8 +845,8 @@ static bool exit_set_call(execution_port exec_result, choiceptr B0, yamop *oCP, Term rc; switch (exec_result) { - // we failed - // Exception: we'll pass it through + // we failed + // Exception: we'll pass it through case CALLED_FROM_EXCEPTION: // internal exception { @@ -905,8 +905,8 @@ static bool exit_set_call(execution_port exec_result, choiceptr B0, yamop *oCP, choiceptr saved_b = B; CELL *pt = ASP; CUT_C_PUSH( - NEXTOP(NEXTOP(PredProtectStack->cs.p_code.FirstClause, OtapFs), OtapFs), - pt); // this is where things get complicated, we need to + NEXTOP(NEXTOP(PredProtectStack->cs.p_code.FirstClause, OtapFs), OtapFs), + pt); // this is where things get complicated, we need to // protect the stack and be able to backtrack pt -= 4; pt[3] = t4; @@ -955,7 +955,7 @@ static Int protect_stack_from_cut(USES_REGS1) { * @param USES_REGS1 [env for threaded execution] * @return c [next answer] - */ +*/ static Int protect_stack_from_retry(USES_REGS1) { // called after backtracking.. // @@ -1091,9 +1091,9 @@ static Int setup_call_catcher_cleanup(USES_REGS1) { static bool complete_ge(bool out, Term omod, yhandle_t sl, bool creeping) { CACHE_REGS - if (creeping) { - Yap_signal(YAP_CREEP_SIGNAL); - } + if (creeping) { + Yap_signal(YAP_CREEP_SIGNAL); + } CurrentModule = omod; Yap_CloseSlots(sl); if (out) { @@ -1123,7 +1123,7 @@ static Int _user_expand_goal(USES_REGS1) { ARG1 = Yap_MkApplTerm(FunctorModule, 2, mg_args); ARG2 = Yap_GetFromSlot(h2); if ((pe = RepPredProp( - Yap_GetPredPropByFunc(FunctorGoalExpansion2, SYSTEM_MODULE))) && + Yap_GetPredPropByFunc(FunctorGoalExpansion2, SYSTEM_MODULE))) && pe->OpcodeOfPred != FAIL_OPCODE && pe->OpcodeOfPred != UNDEF_OPCODE && Yap_execute_pred(pe, NULL, false PASS_REGS)) { return complete_ge(true, omod, sl, creeping); @@ -1133,7 +1133,7 @@ static Int _user_expand_goal(USES_REGS1) { ARG3 = Yap_GetFromSlot(h2); /* user:goal_expansion(A,CurMod,B) */ if ((pe = RepPredProp( - Yap_GetPredPropByFunc(FunctorGoalExpansion, USER_MODULE))) && + Yap_GetPredPropByFunc(FunctorGoalExpansion, USER_MODULE))) && pe->OpcodeOfPred != FAIL_OPCODE && pe->OpcodeOfPred != UNDEF_OPCODE && Yap_execute_pred(pe, NULL PASS_REGS, false)) { return complete_ge(true, omod, sl, creeping); @@ -1145,7 +1145,7 @@ static Int _user_expand_goal(USES_REGS1) { /* user:goal_expansion(A,B) */ if (cmod != USER_MODULE && /* we have tried this before */ (pe = RepPredProp( - Yap_GetPredPropByFunc(FunctorGoalExpansion2, USER_MODULE))) && + Yap_GetPredPropByFunc(FunctorGoalExpansion2, USER_MODULE))) && pe->OpcodeOfPred != FAIL_OPCODE && pe->OpcodeOfPred != UNDEF_OPCODE && Yap_execute_pred(pe, NULL PASS_REGS, false)) { return complete_ge(true, omod, sl, creeping); @@ -1165,7 +1165,7 @@ static Int do_term_expansion(USES_REGS1) { ARG1 = g; if ((pe = RepPredProp( - Yap_GetPredPropByFunc(FunctorTermExpansion, USER_MODULE))) && + Yap_GetPredPropByFunc(FunctorTermExpansion, USER_MODULE))) && pe->OpcodeOfPred != FAIL_OPCODE && pe->OpcodeOfPred != UNDEF_OPCODE && Yap_execute_pred(pe, NULL, false PASS_REGS)) { return complete_ge(true, omod, sl, creeping); @@ -1184,7 +1184,7 @@ static Int do_term_expansion(USES_REGS1) { ARG1 = Yap_MkApplTerm(FunctorModule, 2, mg_args); ARG2 = Yap_GetFromSlot(h2); if ((pe = RepPredProp( - Yap_GetPredPropByFunc(FunctorTermExpansion, SYSTEM_MODULE))) && + Yap_GetPredPropByFunc(FunctorTermExpansion, SYSTEM_MODULE))) && pe->OpcodeOfPred != FAIL_OPCODE && pe->OpcodeOfPred != UNDEF_OPCODE && Yap_execute_pred(pe, NULL, false PASS_REGS)) { return complete_ge(true, omod, sl, creeping); @@ -1202,7 +1202,7 @@ static Int execute0(USES_REGS1) { /* '$execute0'(Goal,Mod) */ return EnterCreepMode(t, mod PASS_REGS); } t = Yap_YapStripModule(t, &mod); -restart_exec: + restart_exec: if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, ARG3, "call/1"); return false; @@ -1421,7 +1421,10 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) { int lval, out; Int OldBorder = LOCAL_CBorder; LOCAL_CBorder = LCL0 - (CELL *)B; - if (top && (lval = sigsetjmp(LOCAL_RestartEnv, 1)) != 0) { + sigjmp_buf signew, *sighold = LOCAL_RestartEnv; + LOCAL_RestartEnv = &signew; + + if (top && (lval = sigsetjmp(signew, 1)) != 0) { switch (lval) { case 1: { /* restart */ /* otherwise, SetDBForThrow will fail entering critical mode */ @@ -1449,25 +1452,27 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) { /* reset the registers so that we don't have trash in abstract * machine */ Yap_set_fpu_exceptions( - getAtomicGlobalPrologFlag(ARITHMETIC_EXCEPTIONS_FLAG)); + getAtomicGlobalPrologFlag(ARITHMETIC_EXCEPTIONS_FLAG)); P = (yamop *)FAILCODE; LOCAL_PrologMode = UserMode; } break; case 3: { /* saved state */ LOCAL_CBorder = OldBorder; + LOCAL_RestartEnv = sighold; return false; } case 4: { /* abort */ /* can be called from anywgerre, must reset registers, */ + LOCAL_RestartEnv = sighold; Yap_JumpToEnv(TermDAbort); P = (yamop *)FAILCODE; LOCAL_PrologMode = UserMode; } break; default: - /* do nothing */ - LOCAL_PrologMode = UserMode; + /* do nothing */ + LOCAL_PrologMode = UserMode; } } else { LOCAL_PrologMode = UserMode; @@ -1480,6 +1485,7 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) { if (!Yap_has_a_signal()) CalculateStackGap(PASS_REGS1); LOCAL_CBorder = OldBorder; + LOCAL_RestartEnv = sighold; return out; } @@ -1530,13 +1536,13 @@ void Yap_PrepGoal(arity_t arity, CELL *pt, choiceptr saved_b USES_REGS) { static bool do_goal(yamop *CodeAdr, int arity, CELL *pt, bool top USES_REGS) { choiceptr saved_b = B; bool out; - + Yap_PrepGoal(arity, pt, saved_b PASS_REGS); CACHE_A1(); P = (yamop *)CodeAdr; // S = CellPtr(RepPredProp( // PredPropByFunc(Yap_MkFunctor(AtomCall, 1), 0))); /* A1 mishaps */ - + out = exec_absmi(top, YAP_EXEC_ABSMI PASS_REGS); if (top) Yap_flush(); @@ -1550,7 +1556,7 @@ static bool do_goal(yamop *CodeAdr, int arity, CELL *pt, bool top USES_REGS) { bool Yap_exec_absmi(bool top, yap_reset_t has_reset) { CACHE_REGS - return exec_absmi(top, has_reset PASS_REGS); + return exec_absmi(top, has_reset PASS_REGS); } /** @@ -1560,7 +1566,7 @@ bool Yap_exec_absmi(bool top, yap_reset_t has_reset) { */ void Yap_fail_all(choiceptr bb USES_REGS) { yamop *saved_p, *saved_cp; - + saved_p = P; saved_cp = CP; /* prune away choicepoints */ @@ -1579,7 +1585,7 @@ void Yap_fail_all(choiceptr bb USES_REGS) { DEPTH = B->cp_depth; #endif /* DEPTH_LIMIT */ YENV = ENV = B->cp_env; -/* recover local stack */ + /* recover local stack */ #ifdef DEPTH_LIMIT DEPTH = ENV[E_DEPTH]; #endif @@ -1606,16 +1612,16 @@ bool Yap_execute_pred(PredEntry *ppe, CELL *pt, bool pass_ex USES_REGS) { yamop *saved_p, *saved_cp; yamop *CodeAdr; bool out; - + saved_p = P; saved_cp = CP; LOCAL_PrologMode |= TopGoalMode; - + PELOCK(81, ppe); CodeAdr = ppe->CodeOfPred; UNLOCK(ppe->PELock); out = do_goal(CodeAdr, ppe->ArityOfPE, pt, false PASS_REGS); - + if (out) { choiceptr cut_B; /* we succeeded, let's prune */ @@ -1691,21 +1697,21 @@ bool Yap_execute_pred(PredEntry *ppe, CELL *pt, bool pass_ex USES_REGS) { bool Yap_execute_goal(Term t, int nargs, Term mod, bool pass_ex) { CACHE_REGS - Prop pe; + Prop pe; PredEntry *ppe; CELL *pt; /* preserve the current restart environment */ /* visualc*/ /* just keep the difference because of possible garbage collections */ - + if (IsAtomTerm(t)) { Atom a = AtomOfTerm(t); pt = NULL; pe = PredPropByAtom(a, mod); } else if (IsApplTerm(t)) { Functor f = FunctorOfTerm(t); - + if (IsBlobFunctor(f)) { Yap_Error(TYPE_ERROR_CALLABLE, t, "call/1"); return false; @@ -1728,7 +1734,7 @@ bool Yap_execute_goal(Term t, int nargs, Term mod, bool pass_ex) { void Yap_trust_last(void) { CACHE_REGS - ASP = B->cp_env; + ASP = B->cp_env; CP = B->cp_cp; HR = B->cp_h; #ifdef DEPTH_LIMIT @@ -1746,7 +1752,7 @@ void Yap_trust_last(void) { Term Yap_RunTopGoal(Term t, bool handle_errors) { CACHE_REGS - yamop *CodeAdr; + yamop *CodeAdr; Prop pe; PredEntry *ppe; CELL *pt; @@ -1754,7 +1760,7 @@ Term Yap_RunTopGoal(Term t, bool handle_errors) { Term tmod = CurrentModule; Term goal_out = 0; LOCAL_PrologMode |= TopGoalMode; - + t = Yap_YapStripModule(t, &tmod); if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, "call/1"); @@ -1767,7 +1773,7 @@ Term Yap_RunTopGoal(Term t, bool handle_errors) { arity = 0; } else if (IsApplTerm(t)) { Functor f = FunctorOfTerm(t); - + if (IsBlobFunctor(f)) { Yap_Error(TYPE_ERROR_CALLABLE, t, "call/1"); LOCAL_PrologMode &= ~TopGoalMode; @@ -1799,7 +1805,7 @@ Term Yap_RunTopGoal(Term t, bool handle_errors) { ts[0] = tmod; ts[1] = t; Functor f = Yap_MkFunctor(Yap_LookupAtom("call"), 1); - + pt = &t; t = Yap_MkApplTerm(FunctorModule, 2, ts); pe = Yap_GetPredPropByFunc(f, tmod); @@ -1809,7 +1815,7 @@ Term Yap_RunTopGoal(Term t, bool handle_errors) { PELOCK(82, ppe); CodeAdr = ppe->CodeOfPred; UNLOCK(ppe->PELock); - + #if !USE_SYSTEM_MALLOC if (LOCAL_TrailTop - HeapTop < 2048) { Yap_Error(RESOURCE_ERROR_TRAIL, TermNil, @@ -1825,7 +1831,7 @@ static void do_restore_regs(Term t, int restore_all USES_REGS) { Int i; Int max = ArityOfFunctor(FunctorOfTerm(t)) - 4; CELL *ptr = RepAppl(t) + 5; - + P = (yamop *)IntegerOfTerm(ptr[-4]); CP = (yamop *)IntegerOfTerm(ptr[-3]); ENV = (CELL *)(LCL0 - IntegerOfTerm(ptr[-2])); @@ -1855,11 +1861,11 @@ static Int restore_regs(USES_REGS1) { * a * call */ static Int restore_regs2(USES_REGS1) { - + Term t = Deref(ARG1), d0; choiceptr pt0; Int d; - + if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, "support for coroutining"); return (FALSE); @@ -1969,7 +1975,7 @@ static Int cut_up_to_next_disjunction(USES_REGS1) { bool Yap_Reset(yap_reset_t mode) { CACHE_REGS - int res = TRUE; + int res = TRUE; Yap_ResetException(worker_id); /* first, backtrack to the root */ @@ -2018,14 +2024,17 @@ static Int JumpToEnv() { /* find the first choicepoint that may be a catch */ // DBTerm *dbt = Yap_RefToException(); while (handler && Yap_PredForChoicePt(handler, NULL) != PredDollarCatch) { + //printf("--handler=%p, max=%p\n", handler, LCL0-LOCAL_CBorder); while (POP_CHOICE_POINT(handler)) { POP_FAIL_EXECUTE(handler); } + if (handler == (choiceptr)(LCL0-LOCAL_CBorder)) { + break; + } /* we are already doing a catch */ /* make sure we prune C-choicepoints */ - if (handler->cp_ap == NOCODE && - (handler >= (choiceptr)(LCL0 - LOCAL_CBorder) || - handler->cp_b == NULL)) { + if ((handler->cp_ap == NOCODE && handler->cp_b == NULL) || + (handler->cp_b >= (choiceptr)(LCL0 - LOCAL_CBorder))) { break; } handler = handler->cp_b; @@ -2065,7 +2074,7 @@ static Int JumpToEnv() { bool Yap_JumpToEnv(Term t) { CACHE_REGS - LOCAL_BallTerm = Yap_StoreTermInDB(t, 0); + LOCAL_BallTerm = Yap_StoreTermInDB(t, 0); if (!LOCAL_BallTerm) return false; if (LOCAL_PrologMode & TopGoalMode) @@ -2080,20 +2089,20 @@ static Int jump_env(USES_REGS1) { Yap_Error(INSTANTIATION_ERROR, t, "throw ball must be bound"); return false; } else if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorError) { - Term t2, te; - + Term t2; + Yap_find_prolog_culprit(PASS_REGS1); // LOCAL_Error_TYPE = ERROR_EVENT; t = ArgOfTerm(1, t); if (IsApplTerm(t) && IsAtomTerm((t2 = ArgOfTerm(1, t)))) { - LOCAL_ActiveError.errorAsText = AtomOfTerm(t2); - LOCAL_ActiveError.classAsText = NameOfFunctor(FunctorOfTerm(t)); + LOCAL_ActiveError->errorAsText = AtomOfTerm(t2); + LOCAL_ActiveError->classAsText = NameOfFunctor(FunctorOfTerm(t)); } else if (IsAtomTerm(t)) { - LOCAL_ActiveError.errorAsText = AtomOfTerm(t); - LOCAL_ActiveError.classAsText = NULL; + LOCAL_ActiveError->errorAsText = AtomOfTerm(t); + LOCAL_ActiveError->classAsText = NULL; } } else { - //LOCAL_Error_TYPE = THROW_EVENT; + // LOCAL_Error_TYPE = THROW_EVENT; } LOCAL_ActiveError->prologPredName = NULL; Yap_PutException(t); @@ -2115,27 +2124,27 @@ static Int generate_pred_info(USES_REGS1) { void Yap_InitYaamRegs(int myworker_id) { Term h0var; -// getchar(); + // getchar(); #if PUSH_REGS -/* Guarantee that after a longjmp we go back to the original abstract - machine registers */ + /* Guarantee that after a longjmp we go back to the original abstract + machine registers */ #ifdef THREADS if (myworker_id) { REGSTORE *rs = REMOTE_ThreadHandle(myworker_id).default_yaam_regs; pthread_setspecific(Yap_yaamregs_key, (const void *)rs); REMOTE_ThreadHandle(myworker_id).current_yaam_regs = rs; } -/* may be run by worker_id on behalf on myworker_id */ + /* may be run by worker_id on behalf on myworker_id */ #else Yap_regp = &Yap_standard_regs; #endif #endif /* PUSH_REGS */ CACHE_REGS - Yap_ResetException(worker_id); + Yap_ResetException(worker_id); Yap_PutValue(AtomBreak, MkIntTerm(0)); TR = (tr_fr_ptr)REMOTE_TrailBase(myworker_id); HR = H0 = ((CELL *)REMOTE_GlobalBase(myworker_id)) + - 1; // +1: hack to ensure the gc does not try to mark mistakenly + 1; // +1: hack to ensure the gc does not try to mark mistakenly LCL0 = ASP = (CELL *)REMOTE_LocalBase(myworker_id); CurrentTrailTop = (tr_fr_ptr)(REMOTE_TrailTop(myworker_id) - MinTrailGap); /* notice that an initial choice-point and environment @@ -2159,12 +2168,12 @@ void Yap_InitYaamRegs(int myworker_id) { #ifdef YAPOR_SBA BSEG = #endif /* YAPOR_SBA */ - BBREG = B_FZ = (choiceptr)REMOTE_LocalBase(myworker_id); + BBREG = B_FZ = (choiceptr)REMOTE_LocalBase(myworker_id); TR = TR_FZ = (tr_fr_ptr)REMOTE_TrailBase(myworker_id); #endif /* FROZEN_STACKS */ CalculateStackGap(PASS_REGS1); -/* the first real choice-point will also have AP=FAIL */ -/* always have an empty slots for people to use */ + /* the first real choice-point will also have AP=FAIL */ + /* always have an empty slots for people to use */ #if defined(YAPOR) || defined(THREADS) LOCAL = REMOTE(myworker_id); worker_id = myworker_id; @@ -2179,7 +2188,7 @@ void Yap_InitYaamRegs(int myworker_id) { REMOTE_GcGeneration(myworker_id) = Yap_NewTimedVar(h0var); REMOTE_GcCurrentPhase(myworker_id) = 0L; REMOTE_GcPhase(myworker_id) = - Yap_NewTimedVar(MkIntTerm(REMOTE_GcCurrentPhase(myworker_id))); + Yap_NewTimedVar(MkIntTerm(REMOTE_GcCurrentPhase(myworker_id))); #if defined(YAPOR) || defined(THREADS) PP = NULL; PREG_ADDR = NULL; @@ -2192,7 +2201,7 @@ void Yap_InitYaamRegs(int myworker_id) { #ifdef YAPOR_SBA BSEG = #endif /* YAPOR_SBA */ - BBREG = B_FZ = (choiceptr)REMOTE_LocalBase(myworker_id); + BBREG = B_FZ = (choiceptr)REMOTE_LocalBase(myworker_id); TR = TR_FZ = (tr_fr_ptr)REMOTE_TrailBase(myworker_id); #endif /* FROZEN_STACKS */ CalculateStackGap(PASS_REGS1); @@ -2205,7 +2214,7 @@ void Yap_InitYaamRegs(int myworker_id) { Term Yap_GetException(void) { CACHE_REGS - Term t = 0; + Term t = 0; if (LOCAL_BallTerm) { t = Yap_PopTermFromDB(LOCAL_BallTerm); @@ -2224,8 +2233,8 @@ bool Yap_RaiseException(void) { bool Yap_PutException(Term t) { CACHE_REGS - if ((LOCAL_BallTerm = Yap_StoreTermInDB(t, 0)) != NULL) - return true; + if ((LOCAL_BallTerm = Yap_StoreTermInDB(t, 0)) != NULL) + return true; return false; } @@ -2235,7 +2244,6 @@ bool Yap_ResetException(int wid) { Yap_PopTermFromDB(REMOTE_ActiveError(wid)->errorTerm); } REMOTE_ActiveError(wid)->errorTerm = NULL; - REMOTE_ActiveError(wid)->errorTerm = NULL; return true; } @@ -2274,7 +2282,7 @@ int Yap_dogc(int extra_args, Term *tp USES_REGS) { void Yap_InitExecFs(void) { CACHE_REGS - Term cm = CurrentModule; + Term cm = CurrentModule; Yap_InitComma(); Yap_InitCPred("$execute", 1, execute, 0); Yap_InitCPred("$execute", 2, execute2, 0); diff --git a/C/flags.c b/C/flags.c index 0e62684ee..411026375 100644 --- a/C/flags.c +++ b/C/flags.c @@ -666,12 +666,19 @@ static bool setYapFlagInModule(Term tflag, Term t2, Term mod) { flag_term *tarr = GLOBAL_Flags; if (!(fv->type(t2))) return false; + if (fv->helper && !(fv->helper(t2))) return false; Term tout = tarr[fv->FlagOfVE].at; - if (IsVarTerm(tout)) - Yap_PopTermFromDB(tarr[fv->FlagOfVE].DBT); - if (IsAtomOrIntTerm(t2)) + if (IsVarTerm(tout)) { + Term t; + while ((t = Yap_PopTermFromDB(tarr[fv->FlagOfVE].DBT)) == 0) { + if (!Yap_gc(2, ENV, gc_P(P, CP))) { + Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); + return false; + } + } + } else if (IsAtomOrIntTerm(t2)) tarr[fv->FlagOfVE].at = t2; else { tarr[fv->FlagOfVE].DBT = Yap_StoreTermInDB(t2, 2); diff --git a/C/globals.c b/C/globals.c index 9897a3221..2826fa41c 100644 --- a/C/globals.c +++ b/C/globals.c @@ -115,7 +115,7 @@ threads that are created after the registration. #include "YapHeap.h" #include "yapio.h" #include "iopreds.h" -#include "eval.h" +#include "YapEval.h" #include "attvar.h" #include diff --git a/C/heapgc.c b/C/heapgc.c index 8cec0ac7f..68415abbe 100644 --- a/C/heapgc.c +++ b/C/heapgc.c @@ -134,7 +134,7 @@ gc_growtrail(int committed, tr_fr_ptr begsTR, cont *old_cont_top0 USES_REGS) #endif /* could not find more trail */ save_machine_regs(); - siglongjmp(LOCAL_gc_restore, 2); + siglongjmp(*LOCAL_gc_restore, 2); } } @@ -397,7 +397,7 @@ check_pr_trail( tr_fr_ptr rc USES_REGS) if (!Yap_locked_growtrail(0, TRUE) || TRUE) { /* could not find more trail */ save_machine_regs(); - siglongjmp(LOCAL_gc_restore, 2); + siglongjmp(*LOCAL_gc_restore, 2); } rc = TR-n; } @@ -525,7 +525,7 @@ pop_registers(Int num_regs, yamop *nextop USES_REGS) /* error: we don't have enough room */ /* could not find more trail */ save_machine_regs(); - siglongjmp(LOCAL_gc_restore, 4); + siglongjmp(*LOCAL_gc_restore, 4); } } } @@ -1450,7 +1450,7 @@ mark_variable(CELL_PTR current USES_REGS) /* error: we don't have enough room */ /* could not find more trail */ save_machine_regs(); - siglongjmp(LOCAL_gc_restore, 3); + siglongjmp(*LOCAL_gc_restore, 3); } else if (n > 0) { CELL *ptr = LOCAL_extra_gc_cells; @@ -3934,6 +3934,9 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS) UInt gc_phase; UInt alloc_sz; int jmp_res; + sigjmp_buf jmp; + + LOCAL_gc_restore = &jmp; heap_cells = HR-H0; gc_verbose = is_gc_verbose(); @@ -3989,7 +3992,7 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS) } #endif time_start = Yap_cputime(); - jmp_res = sigsetjmp(LOCAL_gc_restore, 0); + jmp_res = sigsetjmp(jmp, 0); if (jmp_res == 2) { UInt sz; diff --git a/C/load_dll.c b/C/load_dll.c index ea881df06..e0889edc5 100755 --- a/C/load_dll.c +++ b/C/load_dll.c @@ -42,15 +42,15 @@ Yap_FindExecutable(void) void * Yap_LoadForeignFile(char *file, int flags) { - void *ptr= (void *)LoadLibrary(file); + char *buf = malloc(1024); + printf("file=%s\n" , file ); + void *ptr= (void *)LoadLibrary(file); if (!ptr) { - CACHE_REGS - LOCAL_ErrorMessage = NULL; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorMessage, 256, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 1023, NULL); - } + } return ptr; } @@ -83,17 +83,18 @@ LoadForeign(StringList ofiles, StringList libs, HINSTANCE handle; const char *file = AtomName(ofiles->name); - if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) && + if (Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) && (handle=LoadLibrary(LOCAL_FileNameBuf)) != 0) { LOCAL_ErrorMessage = NULL; if (*init_proc == NULL) *init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name); } else { - FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, GetLastError(), - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorMessage, 256, - NULL); + char *buf = malloc(1024); + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 1023, + NULL); //fprintf(stderr,"WinError: %s\n", LOCAL_ErrorSay); } ofiles = ofiles->next; diff --git a/C/load_foreign.c b/C/load_foreign.c index a1dd5fea7..aeb2c9351 100644 --- a/C/load_foreign.c +++ b/C/load_foreign.c @@ -46,7 +46,7 @@ p_load_foreign( USES_REGS1 ) YapInitProc InitProc = NULL; Term t, t1; StringList new; - Int returncode = FALSE; + bool returncode = FALSE; yhandle_t CurSlot = Yap_StartSlots(); // Yap_DebugPlWrite(ARG1); printf("%s\n", " \n"); @@ -80,13 +80,17 @@ p_load_foreign( USES_REGS1 ) /* get the initialization function name */ t1 = Deref(ARG3); InitProcName = (char *)RepAtom(AtomOfTerm(t1))->StrOfAE; - + + // verify if it was waiting for initialization + if (Yap_LateInit( InitProcName ) ){ + returncode = true; + } else /* call the OS specific function for dynamic loading */ if(Yap_LoadForeign(ofiles,libs,InitProcName,&InitProc)==LOAD_SUCCEEDED) { Yap_StartSlots( ); (*InitProc)(); Yap_CloseSlots(CurSlot); - returncode = TRUE; + returncode = true; } /* I should recover space if load foreign fails */ diff --git a/C/parser.c b/C/parser.c index fde6b32e2..6296a4ced 100755 --- a/C/parser.c +++ b/C/parser.c @@ -302,7 +302,7 @@ static Term VarNames(VarEntry *p, Term l USES_REGS) { VarNames(p->VarLeft, l PASS_REGS) PASS_REGS)); if (HR > ASP - 4096) { save_machine_regs(); - siglongjmp(LOCAL_IOBotch, 1); + longjmp(*LOCAL_IOBotch, 1); } return (o); } else { @@ -332,7 +332,7 @@ static Term Singletons(VarEntry *p, Term l USES_REGS) { Singletons(p->VarLeft, l PASS_REGS) PASS_REGS)); if (HR > ASP - 4096) { save_machine_regs(); - siglongjmp(LOCAL_IOBotch, 1); + longjmp(*LOCAL_IOBotch, 1); } return (o); } else { @@ -357,7 +357,7 @@ static Term Variables(VarEntry *p, Term l USES_REGS) { Variables(p->VarRight, Variables(p->VarLeft, l PASS_REGS) PASS_REGS)); if (HR > ASP - 4096) { save_machine_regs(); - siglongjmp(LOCAL_IOBotch, 1); + siglongjmp(*LOCAL_IOBotch, 1); } return (o); } else { diff --git a/C/signals.c b/C/signals.c index b2684b519..5d87ce6dc 100755 --- a/C/signals.c +++ b/C/signals.c @@ -67,7 +67,7 @@ static yap_signals InteractSIGINT(int ch) { #if PUSH_REGS // restore_absmi_regs(&Yap_standard_regs); #endif - siglongjmp(LOCAL_RestartEnv, 4); + siglongjmp(&LOCAL_RestartEnv, 4); return YAP_ABORT_SIGNAL; case 'b': /* continue */ diff --git a/C/stdpreds.c b/C/stdpreds.c index d019f7821..f9a0b7cdd 100755 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -58,6 +58,9 @@ static char SccsId[] = "%W% %G%"; #include #include +extern int init_tries(void); + + static Int p_setval(USES_REGS1); static Int p_value(USES_REGS1); static Int p_values(USES_REGS1); @@ -74,7 +77,7 @@ static Int p_halt(USES_REGS1); #endif static Int current_predicate(USES_REGS1); static Int cont_current_predicate(USES_REGS1); -static OpEntry *NextOp(OpEntry *CACHE_TYPE); +static OpEntry *NextOp(Prop CACHE_TYPE); static Int init_current_op(USES_REGS1); static Int cont_current_op(USES_REGS1); static Int init_current_atom_op(USES_REGS1); @@ -943,22 +946,24 @@ static Int current_predicate(USES_REGS1) { return cont_current_predicate(PASS_REGS1); } -static OpEntry *NextOp(OpEntry *pp USES_REGS) { +static OpEntry *NextOp(Prop pp USES_REGS) { + while (!EndOfPAEntr(pp) && pp->KindOfPE != OpProperty && - (pp->OpModule != PROLOG_MODULE || pp->OpModule != CurrentModule)) - pp = RepOpProp(pp->NextOfPE); - return (pp); + (RepOpProp(pp)->OpModule != PROLOG_MODULE + || RepOpProp(pp)->OpModule != CurrentModule) ) + pp = pp->NextOfPE; + return RepOpProp(pp); } int Yap_IsOp(Atom at) { CACHE_REGS - OpEntry *op = NextOp(RepOpProp((Prop)(RepAtom(at)->PropsOfAE)) PASS_REGS); + OpEntry *op = NextOp(RepAtom(at)->PropsOfAE PASS_REGS); return (!EndOfPAEntr(op)); } int Yap_IsOpMaxPrio(Atom at) { CACHE_REGS - OpEntry *op = NextOp(RepOpProp((Prop)(RepAtom(at)->PropsOfAE)) PASS_REGS); + OpEntry *op = NextOp(RepAtom(at)->PropsOfAE PASS_REGS); int max; if (EndOfPAEntr(op)) @@ -1020,7 +1025,7 @@ static Int cont_current_atom_op(USES_REGS1) { OpEntry *op = (OpEntry *)IntegerOfTerm(EXTRA_CBACK_ARG(5, 1)), *next; READ_LOCK(op->OpRWLock); - next = NextOp(RepOpProp(op->NextOfPE) PASS_REGS); + next = NextOp(op->NextOfPE PASS_REGS); if (unify_op(op PASS_REGS)) { READ_UNLOCK(op->OpRWLock); if (next) { @@ -1053,7 +1058,7 @@ static Int init_current_atom_op( cut_fail(); } ae = RepAtom(AtomOfTerm(t)); - if (EndOfPAEntr((ope = NextOp(RepOpProp(ae->PropsOfAE) PASS_REGS)))) { + if (EndOfPAEntr((ope = NextOp(ae->PropsOfAE PASS_REGS)))) { cut_fail(); } EXTRA_CBACK_ARG(5, 1) = (CELL)MkIntegerTerm((Int)ope); @@ -1074,7 +1079,7 @@ static Int cut_fail(); } ae = RepAtom(AtomOfTerm(t)); - if (EndOfPAEntr((ope = NextOp(RepOpProp(ae->PropsOfAE) PASS_REGS)))) { + if (EndOfPAEntr((ope = NextOp(ae->PropsOfAE PASS_REGS)))) { cut_fail(); } EXTRA_CBACK_ARG(5, 1) = (CELL)MkIntegerTerm((Int)ope); @@ -1629,7 +1634,6 @@ void Yap_InitCPreds(void) { #if SUPPORT_CONDOR init_sys(); init_random(); - // init_tries(); init_regexp(); #endif } diff --git a/C/write.c b/C/write.c index 91064bdd7..d79302817 100644 --- a/C/write.c +++ b/C/write.c @@ -570,7 +570,7 @@ static void write_string(const unsigned char *s, if (chr == '\0') break; - if (delta == 0) {chr = *ptr++; } + if (delta == 0) {chr = *ptr++; } write_quoted(chr, qt, stream); } while (TRUE); wrputc(qt, stream); diff --git a/CMakeLists.txt b/CMakeLists.txt index 0887f25b7..aef88b428 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,7 +1,7 @@ # value of 3.4.0 or lower. -# Sets the minimum version of CMake required to build the native -# library. You should either keep the default value or only pass a +# Sets the version of CMake required to build the native +# library. You should either keep the default value or pass a # value of 3.4.0 or lower. project( YAP ) @@ -33,13 +33,13 @@ include(FindPackageHandleStandardArgs) include (GNUInstallDirs) # Creates and names a library, sets it as either STATIC -# or SHARED, and provides the relative paths to its source code. -# You can define multiple libraries, and CMake builds it for you. +# or SHARED, and provides the relative paths to its source code.z +# You can define libraries, and CMake builds it for you. # Gradle automatically packages shared libraries with your APK. #cross-compilation support # Search packages for host system instead of packages for target system -# in case of cross compilation these macro should be defined by toolchain file +# in case of cross compilation define these macro by toolchain file if(NOT COMMAND find_host_package) macro(find_host_package) find_package(${ARGN}) @@ -53,6 +53,7 @@ endif() option(BUILD_SHARED_LIBS "Build shared library" ON) set (CMAKE_POSITION_INDEPENDENT_CODE TRUE) +set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE) include(Prelims NO_POLICY_SCOPE) @@ -69,6 +70,8 @@ if (ANDROID) ) endif (ANDROID) + set_property( SOURCE ${LIBYAP_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1) + add_definitions(-DUSE_MYDDAS=1 -DMYDDAS_SQLITE3=1) if (MYSQL_FOUND) @@ -82,6 +85,9 @@ if (ODBC_FOUND) if (MYSQL_POSTGRES) add_definitions(= -DMYDDAS_POSTGRES=1) endif() + if (MYSQL_POSTGRES) + set(SWIG_SOURCES packages/swig/python/yap_PYTHONwrapper.cxx ) + endif() if (ANDROID) @@ -93,34 +99,17 @@ if (MYSQL_POSTGRES) ADD_SUBDIRECTORY(CXX) -set (SWIG_FILES ${CMAKE_SOURCE_DIR}/../generated/jni/yap_wrap.cpp ) - -else () - set(YLIBS - $ - $ - $ - $ - $ - $ - $ - ) - - -endif () +else() + List (APPEND YLIBS $ ) + List (APPEND YLIBS $ ) + List (APPEND YLIBS $ ) + List (APPEND YLIBS $ ) + List (APPEND YLIBS $ ) + List (APPEND YLIBS $ ) if (WIN32) - list (APPEND YLIBS $) -endif() - - -add_component (core - ${ENGINE_SOURCES} - ${SWIG_FILES} - ${C_INTERFACE_SOURCES} - ${STATIC_SOURCES} - ${ALL_SOURCES} - ) + List (APPEND YLIBS $ ) + endif() add_library( # Sets the name of the library. @@ -128,18 +117,26 @@ add_library( # Sets the name of the library. # Sets the library as a shared library. SHARED + + ${ENGINE_SOURCES} + ${C_INTERFACE_SOURCES} + //${STATIC_SOURCES} + # cmake object libraries ${YLIBS} - ${WINDLLS} ) +if (WIN32) + target_link_libraries(libYap ${WINDLLS}) +endif (WIN32) + include(libYap NO_POLICY_SCOPE) +endif() if (USE_READLINE) target_link_libraries(libYap ${READLINE_LIBRARIES}) endif (USE_READLINE) - if (ANDROID) add_dependencies(libYap plmyddas ) @@ -148,9 +145,8 @@ if (ANDROID) endif () set_target_properties(libYap - PROPERTIES OUTPUT_NAME Yap - ) - + PROPERTIES OUTPUT_NAME Yap + ) MY_include(Packages NO_POLICY_SCOPE) - include(Config NO_POLICY_SCOPE) +include(Config NO_POLICY_SCOPE) diff --git a/H/LOCALS b/H/LOCALS index 26ad866d9..31dac822d 100755 --- a/H/LOCALS +++ b/H/LOCALS @@ -145,7 +145,7 @@ ADDR db_vec0 =NULL struct RB_red_blk_node* db_root =NULL struct RB_red_blk_node* db_nil =NULL -sigjmp_buf gc_restore void +sigjmp_buf* gc_restore void CELL* extra_gc_cells void CELL* extra_gc_cells_base void CELL* extra_gc_cells_top void @@ -160,8 +160,8 @@ struct mem_blk* CMemFirstBlock =NULL UInt CMemFirstBlockSz =0L // Variable used by the compiler to store number of permanent vars in a clause -int nperm =0L - +int nperm =0 +int jMP =0 // Thread Local Area for Labels Int* LabelFirstArray =NULL UInt LabelFirstArraySz =0L @@ -198,7 +198,7 @@ ADDR TrailTop void yap_error_descriptor_t* ActiveError =calloc(sizeof(yap_error_descriptor_t),1) /// pointer to an exception term, from throw -jmp_buf IOBotch void +jmp_buf* IOBotch void TokEntry* tokptr void TokEntry* toktide void VarEntry* VarTable void @@ -209,7 +209,7 @@ CELL* CommentsNextChar void wchar_t* CommentsBuff void size_t CommentsBuffPos void size_t CommentsBuffLim void -sigjmp_buf RestartEnv void +sigjmp_buf* RestartEnv void char FileNameBuf[YAP_FILENAME_MAX+1] void char FileNameBuf2[YAP_FILENAME_MAX+1] void diff --git a/H/TermExt.h b/H/TermExt.h index e2169ddb1..e8658cc2c 100755 --- a/H/TermExt.h +++ b/H/TermExt.h @@ -302,6 +302,8 @@ INLINE_ONLY inline EXTERN Term __MkStringTerm(const char *s USES_REGS) { return t; } +#define MkUStringTerm(i) __MkUStringTerm((i)PASS_REGS) + INLINE_ONLY inline EXTERN Term __MkUStringTerm(const unsigned char *s USES_REGS); diff --git a/H/Yap.h b/H/Yap.h index 07bd31a3d..40ebc7927 100755 --- a/H/Yap.h +++ b/H/Yap.h @@ -129,37 +129,6 @@ #endif #endif /* defined(HAVE_NULLPTR) */ -/* Microsoft's Visual C++ Compiler */ -#ifdef _MSC_VER /* adjust a config.h from mingw32 to work with vc++ */ -#ifdef HAVE_GCC -#undef HAVE_GCC -#endif /* HAVE_GCC */ -#ifdef USE_THREADED_CODE -#undef USE_THREADED_CODE -#endif /* USE_THREADED_CODE */ -#define inline __inline -#define YAP_VERSION "YAP-6.3.4" -#define BIN_DIR "c:\\Yap\\bin" -#define LIB_DIR "c:\\Yap\\lib\\Yap" -#define SHARE_DIR "c:\\Yap\\share\\Yap" -#ifdef HOST_ALIAS -#undef HOST_ALIAS -#endif /* HOST_ALIAS */ -#define HOST_ALIAS "i386-pc-win32" -#ifdef HAVE_IEEEFP_H -#undef HAVE_IEEEFP_H -#endif /* HAVE_IEEEFP_H */ -#ifdef HAVE_UNISTD_H -#undef HAVE_UNISTD_H -#endif /* HAVE_UNISTD_H */ -#ifdef HAVE_SYS_TIME_H -#undef HAVE_SYS_TIME_H -#endif /* HAVE_SYS_TIME_H */ -#endif /* _MSC_VER */ - -#if HAVE_TIME_H -#include -#endif #ifdef __MINGW32__ #ifndef _WIN32 @@ -727,10 +696,10 @@ typedef struct thandle { struct timeval *start_of_times_sysp; struct timeval *last_time_sysp; #elif _WIN32 - struct _FILETIME *start_of_timesp; - struct _FILETIME *last_timep; - struct _FILETIME *start_of_times_sysp; - struct _FILETIME *last_time_sysp; + win64_time_t *start_of_timesp; + win64_time_t *last_timep; + win64_time_t *start_of_times_sysp; + win64_time_t *last_time_sysp; #endif } yap_thandle; #endif /* THREADS */ diff --git a/H/YapCompile.h b/H/YapCompile.h index e08067bf2..520ef48f7 100644 --- a/H/YapCompile.h +++ b/H/YapCompile.h @@ -8,7 +8,7 @@ * * ************************************************************************** * * -* File: compile.h * +* File: YapCompile.h * * Last rev: * * mods: * * comments: compiler data structures and routines * diff --git a/H/eval.h b/H/YapEval.h similarity index 99% rename from H/eval.h rename to H/YapEval.h index 5b1117a59..0299ec7f5 100644 --- a/H/eval.h +++ b/H/YapEval.h @@ -1,6 +1,6 @@ /************************************************************************* * * -* YAP Prolog @(#)eval.h 1.2 +* YAP Prolog @(#)YapEval.h 1.2 * * * Yap Prolog was developed at NCCUP - Universidade do Porto * * * @@ -8,7 +8,7 @@ * * ************************************************************************** * * -* File: eval.h * +* File: YapEval.h * * Last rev: * * mods: * * comments: arithmetical functions info * @@ -17,7 +17,7 @@ /** -@file eval.h +@file YapEval.h @defgroup arithmetic Arithmetic in YAP diff --git a/H/YapHeap.h b/H/YapHeap.h index c86532ac5..233c5ebc8 100755 --- a/H/YapHeap.h +++ b/H/YapHeap.h @@ -154,7 +154,7 @@ typedef struct thandle { /******************* this is the data base: everything here should be possible to restore ********************/ -#if __INIT_C__ +#if __INIT_C__ || defined(MSC_VER) #define EXTERNAL #else #define EXTERNAL extern diff --git a/H/YapTags.h b/H/YapTags.h index 4ae7f2e06..2eb5e7b2d 100644 --- a/H/YapTags.h +++ b/H/YapTags.h @@ -166,13 +166,15 @@ INLINE_ONLY inline EXTERN Term *VarOfTerm(Term t) { return (Term *)(t); } INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1); -INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1) { +INLINE_ONLY +inline EXTERN Term MkVarTerm__(USES_REGS1) { return (Term)((*HR = 0, HR++)); } INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *); -INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) == +INLINE_ONLY +inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) == 0); } #else @@ -181,13 +183,15 @@ INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) == INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1); -INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1) { +INLINE_ONLY +inline EXTERN Term MkVarTerm__(USES_REGS1) { return (Term)((*HR = (CELL)HR, HR++)); } INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *); -INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { +INLINE_ONLY + inline EXTERN bool IsUnboundVar(Term *t) { return *(t) == (Term)(t); } @@ -195,13 +199,15 @@ INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { INLINE_ONLY inline EXTERN CELL *PtrOfTerm(Term); -INLINE_ONLY inline EXTERN CELL *PtrOfTerm(Term t) { +INLINE_ONLY + inline EXTERN CELL *PtrOfTerm(Term t) { return (CELL *)(*(CELL *)(t)); } INLINE_ONLY inline EXTERN Functor FunctorOfTerm(Term); -INLINE_ONLY inline EXTERN Functor FunctorOfTerm(Term t) { +INLINE_ONLY + inline EXTERN Functor FunctorOfTerm(Term t) { return (Functor)(*RepAppl(t)); } @@ -209,13 +215,15 @@ INLINE_ONLY inline EXTERN Functor FunctorOfTerm(Term t) { INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom); -INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom a) { +INLINE_ONLY + inline EXTERN Term MkAtomTerm(Atom a) { return (Term)(AtomTag | (CELL)(a)); } INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t); -INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) { +INLINE_ONLY + inline EXTERN Atom AtomOfTerm(Term t) { return (Atom)((~AtomTag & (CELL)(t))); } @@ -223,13 +231,15 @@ INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) { INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom); -INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom at) { +INLINE_ONLY + inline EXTERN Term MkAtomTerm(Atom at) { return (Term)(TAGGEDA((CELL)AtomTag, (CELL)(at))); } INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t); -INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) { +INLINE_ONLY + inline EXTERN Atom AtomOfTerm(Term t) { return (Atom)(NonTagPart(t)); } @@ -237,13 +247,15 @@ INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) { INLINE_ONLY inline EXTERN bool IsAtomTerm(Term); -INLINE_ONLY inline EXTERN bool IsAtomTerm(Term t) { +INLINE_ONLY + inline EXTERN bool IsAtomTerm(Term t) { return CHKTAG((t), AtomTag); } INLINE_ONLY inline EXTERN Term MkIntTerm(Int); -INLINE_ONLY inline EXTERN Term MkIntTerm(Int n) { +INLINE_ONLY + inline EXTERN Term MkIntTerm(Int n) { return (Term)(TAGGED(NumberTag, (n))); } @@ -254,19 +266,22 @@ INLINE_ONLY inline EXTERN Term MkIntTerm(Int n) { INLINE_ONLY inline EXTERN Term MkIntConstant(Int); -INLINE_ONLY inline EXTERN Term MkIntConstant(Int n) { +INLINE_ONLY + inline EXTERN Term MkIntConstant(Int n) { return (Term)(NONTAGGED(NumberTag, (n))); } INLINE_ONLY inline EXTERN bool IsIntTerm(Term); -INLINE_ONLY inline EXTERN bool IsIntTerm(Term t) { +INLINE_ONLY + inline EXTERN bool IsIntTerm(Term t) { return CHKTAG((t), NumberTag); } INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS); -INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS) { +INLINE_ONLY + EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS) { CELL *p = HR; HR[0] = head; @@ -308,20 +323,23 @@ INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS) { INLINE_ONLY inline EXTERN Term __MkIntegerTerm(Int USES_REGS); -INLINE_ONLY inline EXTERN Term __MkIntegerTerm(Int n USES_REGS) { +INLINE_ONLY + inline EXTERN Term __MkIntegerTerm(Int n USES_REGS) { return (Term)(IntInBnd(n) ? MkIntTerm(n) : MkLongIntTerm(n)); } #endif INLINE_ONLY inline EXTERN bool IsIntegerTerm(Term); -INLINE_ONLY inline EXTERN bool IsIntegerTerm(Term t) { +INLINE_ONLY + inline EXTERN bool IsIntegerTerm(Term t) { return (int)(IsIntTerm(t) || IsLongIntTerm(t)); } INLINE_ONLY inline EXTERN Int IntegerOfTerm(Term); -INLINE_ONLY inline EXTERN Int IntegerOfTerm(Term t) { +INLINE_ONLY + inline EXTERN Int IntegerOfTerm(Term t) { return (Int)(IsIntTerm(t) ? IntOfTerm(t) : LongIntOfTerm(t)); } @@ -332,7 +350,8 @@ INLINE_ONLY inline EXTERN Int IntegerOfTerm(Term t) { INLINE_ONLY inline EXTERN Term __MkAddressTerm(void *USES_REGS); -INLINE_ONLY inline EXTERN Term __MkAddressTerm(void *n USES_REGS) { +INLINE_ONLY + inline EXTERN Term __MkAddressTerm(void *n USES_REGS) { return __MkIntegerTerm((Int)n PASS_REGS); } @@ -340,20 +359,23 @@ INLINE_ONLY inline EXTERN Term __MkAddressTerm(void *n USES_REGS) { INLINE_ONLY inline EXTERN bool IsAddressTerm(Term); -INLINE_ONLY inline EXTERN bool IsAddressTerm(Term t) { +INLINE_ONLY + inline EXTERN bool IsAddressTerm(Term t) { return (bool)IsIntegerTerm(t); } INLINE_ONLY inline EXTERN void *AddressOfTerm(Term); -INLINE_ONLY inline EXTERN void *AddressOfTerm(Term t) { +INLINE_ONLY + inline EXTERN void *AddressOfTerm(Term t) { return (void *)(IsIntTerm(t) ? IntOfTerm(t) : LongIntOfTerm(t)); } INLINE_ONLY inline EXTERN Int IsPairTermOrNil (Term); -INLINE_ONLY inline EXTERN Int +INLINE_ONLY + inline EXTERN Int IsPairOrNilTerm (Term t) { return IsPairTerm(t) || t == TermNil; diff --git a/H/YapTerm.h b/H/YapTerm.h index e10cd6f50..a7632a379 100644 --- a/H/YapTerm.h +++ b/H/YapTerm.h @@ -33,7 +33,7 @@ typedef void *Atom; (((CELL)(X) + (sizeof(TYPE) - 1)) & ~(sizeof(TYPE) - 1)) #ifndef EXTERN -#ifdef _MSC_VER +#ifdef MSC_VER #define EXTERN #else #define EXTERN extern @@ -44,51 +44,30 @@ typedef void *Atom; ** and integer types Short and UShort with half the size of a ptr */ #if defined(PRIdPTR) -#define Int_FORMAT "%" PRIdPTR -#define Int_ANYFORMAT "%" PRIuPTR -#define UInt_FORMAT "%" PRIuPTR -#define Int_F PRIdPTR -#define Int_ANYF PRIuPTR -#define UInt_F PRIuPTR typedef intptr_t Int; typedef uintptr_t UInt; #elif defined(_WIN64) + typedef int64_t Int; typedef uint64_t UInt; -#define Int_FORMAT "%I64d" -#define UInt_FORMAT "%I64u" -#define Int_F "I64d" -#define UInt_F "I64u" #elif defined(_WIN32) typedef int32_t Int; typedef uint32_t UInt; -#define Int_FORMAT "%I32d" -#define UInt_FORMAT "%I32u" -#define Int_F "I32d" -#define UInt_F "I32u" #elif SIZEOF_LONG_INT == SIZEOF_INT_P typedef long int Int; typedef unsigned long int UInt; -#define Int_FORMAT "%ld" -#define UInt_FORMAT "%uld" -#define Int_F "ld" -#define UInt_F "uld" #elif SIZEOF_INT == SIZEOF_INT_P typedef int Int; typedef unsigned int UInt; -#define Int_FORMAT "%l" -#define UInt_FORMAT "%ul" -#define Int_F "l" -#define UInt_F "ul" #else #error Yap require integer types of the same size as a pointer @@ -107,6 +86,8 @@ typedef uint32_t BITS32; #define CellSize sizeof(CELL) #define SmallSize sizeof(SMALLUNSGN) +#include "YapFormat.h" + /************************************************************************************************* type casting macros *************************************************************************************************/ diff --git a/H/YapText.h b/H/YapText.h index 267667df0..bc9dc9829 100644 --- a/H/YapText.h +++ b/H/YapText.h @@ -31,6 +31,23 @@ #include "../utf8proc/utf8proc.h" #include "Yap.h" +#define ReleaseAndReturn(r) \ + { \ + pop_text_stack(l); \ + return r; \ + } +#define release_cut_fail() \ + { \ + pop_text_stack(l); \ + cut_fail(); \ + } +#define release_cut_succeed() \ + { \ + pop_text_stack(l); \ + cut_succeed(); \ + } + + /// allocate a temporary text block /// extern void *Malloc(size_t sz USES_REGS); diff --git a/H/Yapproto.h b/H/Yapproto.h index 5759e71f1..85270a5ef 100755 --- a/H/Yapproto.h +++ b/H/Yapproto.h @@ -13,12 +13,6 @@ * version: $Id: Yapproto.h,v 1.90 2008-08-07 20:51:23 vsc Exp $ * *************************************************************************/ -#if defined(_WIN32) -#define X_API __declspec(dllexport) -#else -#define X_API -#endif - /* prototype file for Yap */ /* absmi.c */ @@ -309,6 +303,7 @@ extern struct vfs *Yap_InitAssetManager(void); /* load_foreign.c */ extern void Yap_InitLoadForeign(void); +extern bool Yap_LateInit(const char s[]); /* mavar.c */ extern void Yap_InitMaVarCPreds(void); diff --git a/H/absmi.h b/H/absmi.h index 9b7a79113..deb0c78b6 100755 --- a/H/absmi.h +++ b/H/absmi.h @@ -139,7 +139,7 @@ register struct yami *P1REG asm("bp"); /* can't use yamop before Yap.h */ #include "Yap.h" #include "clause.h" -#include "eval.h" +#include "YapEval.h" #ifdef HAVE_STRING_H #include #endif @@ -2327,6 +2327,8 @@ static inline void prune(choiceptr cp USES_REGS) { if (POP_CHOICE_POINT(B->cp_b)) { POP_EXECUTE(); } + if (B->cp_b == NULL) + break; B = B->cp_b; } if (POP_CHOICE_POINT(B->cp_b)) { diff --git a/H/blobs.h b/H/blobs.h index cae04601e..0e0f73803 100644 --- a/H/blobs.h +++ b/H/blobs.h @@ -11,7 +11,7 @@ #ifndef BLOBS_H #define BLOBS_H -#ifndef X_API +#if !defined(X_API) && !defined(SWIGYAP) #if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(PL_KERNEL) #define X_API __declspec(dllexport) #else diff --git a/H/generated/dlocals.h b/H/generated/dlocals.h index 2034b0403..0b3f4c025 100644 --- a/H/generated/dlocals.h +++ b/H/generated/dlocals.h @@ -250,6 +250,8 @@ #define LOCAL_nperm LOCAL->nperm_ #define REMOTE_nperm(wid) REMOTE(wid)->nperm_ +#define LOCAL_jMP LOCAL->jMP_ +#define REMOTE_jMP(wid) REMOTE(wid)->jMP_ #define LOCAL_LabelFirstArray LOCAL->LabelFirstArray_ #define REMOTE_LabelFirstArray(wid) REMOTE(wid)->LabelFirstArray_ diff --git a/H/generated/hlocals.h b/H/generated/hlocals.h index 46a00dad4..470a84605 100644 --- a/H/generated/hlocals.h +++ b/H/generated/hlocals.h @@ -126,7 +126,7 @@ typedef struct worker_local { ADDR db_vec0_; struct RB_red_blk_node* db_root_; struct RB_red_blk_node* db_nil_; - sigjmp_buf gc_restore_; + sigjmp_buf* gc_restore_; CELL* extra_gc_cells_; CELL* extra_gc_cells_base_; CELL* extra_gc_cells_top_; @@ -140,6 +140,7 @@ typedef struct worker_local { UInt CMemFirstBlockSz_; // Variable used by the compiler to store number of permanent vars in a clause int nperm_; + int jMP_; // Thread Local Area for Labels Int* LabelFirstArray_; UInt LabelFirstArraySz_; @@ -166,7 +167,7 @@ typedef struct worker_local { /* error handling info, designed to be easy to pass to the foreign world */ yap_error_descriptor_t* ActiveError_; /// pointer to an exception term, from throw - jmp_buf IOBotch_; + jmp_buf* IOBotch_; TokEntry* tokptr_; TokEntry* toktide_; VarEntry* VarTable_; @@ -177,7 +178,7 @@ typedef struct worker_local { wchar_t* CommentsBuff_; size_t CommentsBuffPos_; size_t CommentsBuffLim_; - sigjmp_buf RestartEnv_; + sigjmp_buf* RestartEnv_; char FileNameBuf_[YAP_FILENAME_MAX+1]; char FileNameBuf2_[YAP_FILENAME_MAX+1]; struct TextBuffer_manager* TextBuffer_; diff --git a/H/generated/iatoms.h b/H/generated/iatoms.h index 9e01498dd..180728605 100644 --- a/H/generated/iatoms.h +++ b/H/generated/iatoms.h @@ -1,584 +1,584 @@ - - /* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms" - {lease do not update, update misc/ATOMS instead */ - - Atom3Dots = Yap_LookupAtom("..."); - AtomAbol = Yap_FullLookupAtom("$abol"); TermAbol = MkAtomTerm(AtomAbol); - AtomAccess = Yap_LookupAtom("access"); TermAccess = MkAtomTerm(AtomAccess); - AtomAfInet = Yap_LookupAtom("AF_INET"); TermAfInet = MkAtomTerm(AtomAfInet); - AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); TermAfLocal = MkAtomTerm(AtomAfLocal); - AtomAfUnix = Yap_LookupAtom("AF_UNIX"); TermAfUnix = MkAtomTerm(AtomAfUnix); - AtomAlarm = Yap_FullLookupAtom("$alarm"); TermAlarm = MkAtomTerm(AtomAlarm); - AtomAlias = Yap_LookupAtom("alias"); TermAlias = MkAtomTerm(AtomAlias); - AtomAll = Yap_LookupAtom("all"); TermAll = MkAtomTerm(AtomAll); - AtomAltNot = Yap_LookupAtom("not"); TermAltNot = MkAtomTerm(AtomAltNot); - AtomAnswer = Yap_LookupAtom("answer"); TermAnswer = MkAtomTerm(AtomAnswer); - AtomAny = Yap_LookupAtom("any"); TermAny = MkAtomTerm(AtomAny); - AtomAppend = Yap_LookupAtom("append"); TermAppend = MkAtomTerm(AtomAppend); - AtomArg = Yap_LookupAtom("arg"); TermArg = MkAtomTerm(AtomArg); - AtomArray = Yap_FullLookupAtom("$array"); TermArray = MkAtomTerm(AtomArray); - AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); TermArrayAccess = MkAtomTerm(AtomArrayAccess); - AtomArrayOverflow = Yap_LookupAtom("array_overflow"); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); - AtomArrayType = Yap_LookupAtom("array_type"); TermArrayType = MkAtomTerm(AtomArrayType); - AtomArrow = Yap_LookupAtom("->"); TermArrow = MkAtomTerm(AtomArrow); - AtomAttributedModule = Yap_LookupAtom("attributes_module"); TermAttributedModule = MkAtomTerm(AtomAttributedModule); - AtomDoubleArrow = Yap_LookupAtom("-->"); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); - AtomAssert = Yap_LookupAtom(":-"); TermAssert = MkAtomTerm(AtomAssert); - AtomBeginBracket = Yap_LookupAtom("("); TermBeginBracket = MkAtomTerm(AtomBeginBracket); - AtomEndBracket = Yap_LookupAtom(")"); TermEndBracket = MkAtomTerm(AtomEndBracket); - AtomBeginSquareBracket = Yap_LookupAtom("["); TermBeginSquareBracket = MkAtomTerm(AtomBeginSquareBracket); - AtomEndSquareBracket = Yap_LookupAtom("]"); TermEndSquareBracket = MkAtomTerm(AtomEndSquareBracket); - AtomBeginCurlyBracket = Yap_LookupAtom("{"); TermBeginCurlyBracket = MkAtomTerm(AtomBeginCurlyBracket); - AtomEndCurlyBracket = Yap_LookupAtom("}"); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket); - AtomEmptyBrackets = Yap_LookupAtom("()"); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); - AtomEmptySquareBrackets = Yap_LookupAtom("[]"); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); - AtomAsserta = Yap_LookupAtom("asserta"); TermAsserta = MkAtomTerm(AtomAsserta); - AtomAssertaStatic = Yap_LookupAtom("asserta_static"); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); - AtomAssertz = Yap_LookupAtom("assertz"); TermAssertz = MkAtomTerm(AtomAssertz); - AtomAssertzStatic = Yap_LookupAtom("assertz_static"); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); - AtomAt = Yap_LookupAtom("at"); TermAt = MkAtomTerm(AtomAt); - AtomAtom = Yap_LookupAtom("atom"); TermAtom = MkAtomTerm(AtomAtom); - AtomAtomic = Yap_LookupAtom("atomic"); TermAtomic = MkAtomTerm(AtomAtomic); - AtomAtt = Yap_FullLookupAtom("$att"); TermAtt = MkAtomTerm(AtomAtt); - AtomAtt1 = Yap_LookupAtom("att"); TermAtt1 = MkAtomTerm(AtomAtt1); - AtomAttDo = Yap_FullLookupAtom("$att_do"); TermAttDo = MkAtomTerm(AtomAttDo); - AtomAttributes = Yap_LookupAtom("attributes"); TermAttributes = MkAtomTerm(AtomAttributes); - AtomB = Yap_FullLookupAtom("$last_choice_pt"); TermB = MkAtomTerm(AtomB); - AtomBatched = Yap_LookupAtom("batched"); TermBatched = MkAtomTerm(AtomBatched); - AtomBetween = Yap_LookupAtom("between"); TermBetween = MkAtomTerm(AtomBetween); - AtomBinary = Yap_LookupAtom("binary"); TermBinary = MkAtomTerm(AtomBinary); - AtomBigNum = Yap_LookupAtom("big_num"); TermBigNum = MkAtomTerm(AtomBigNum); - AtomBinaryStream = Yap_LookupAtom("binary_stream"); TermBinaryStream = MkAtomTerm(AtomBinaryStream); - AtomBoolean = Yap_LookupAtom("boolean"); TermBoolean = MkAtomTerm(AtomBoolean); - AtomBraces = Yap_LookupAtom("{}"); TermBraces = MkAtomTerm(AtomBraces); - AtomBreak = Yap_FullLookupAtom("$break"); TermBreak = MkAtomTerm(AtomBreak); - AtomByte = Yap_LookupAtom("byte"); TermByte = MkAtomTerm(AtomByte); - AtomCArith = Yap_FullLookupAtom("$c_arith"); TermCArith = MkAtomTerm(AtomCArith); - AtomCall = Yap_LookupAtom("call"); TermCall = MkAtomTerm(AtomCall); - AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); - AtomCallCounter = Yap_LookupAtom("call_counter"); TermCallCounter = MkAtomTerm(AtomCallCounter); - AtomCallable = Yap_LookupAtom("callable"); TermCallable = MkAtomTerm(AtomCallable); - AtomCatch = Yap_FullLookupAtom("$catch"); TermCatch = MkAtomTerm(AtomCatch); - AtomChangeModule = Yap_FullLookupAtom("$change_module"); TermChangeModule = MkAtomTerm(AtomChangeModule); - AtomChar = Yap_LookupAtom("char"); TermChar = MkAtomTerm(AtomChar); - AtomCharsio = Yap_LookupAtom("charsio"); TermCharsio = MkAtomTerm(AtomCharsio); - AtomCharacter = Yap_LookupAtom("character"); TermCharacter = MkAtomTerm(AtomCharacter); - AtomCharacterCode = Yap_LookupAtom("character_code"); TermCharacterCode = MkAtomTerm(AtomCharacterCode); - AtomChars = Yap_LookupAtom("chars"); TermChars = MkAtomTerm(AtomChars); - AtomCharset = Yap_LookupAtom("charset"); TermCharset = MkAtomTerm(AtomCharset); - AtomChType = Yap_FullLookupAtom("$char_type"); TermChType = MkAtomTerm(AtomChType); - AtomCleanCall = Yap_FullLookupAtom("$clean_call"); TermCleanCall = MkAtomTerm(AtomCleanCall); - AtomClose = Yap_LookupAtom("close"); TermClose = MkAtomTerm(AtomClose); - AtomColon = Yap_LookupAtom(":"); TermColon = MkAtomTerm(AtomColon); - AtomCodeSpace = Yap_LookupAtom("code_space"); TermCodeSpace = MkAtomTerm(AtomCodeSpace); - AtomCodes = Yap_LookupAtom("codes"); TermCodes = MkAtomTerm(AtomCodes); - AtomCoInductive = Yap_LookupAtom("coinductive"); TermCoInductive = MkAtomTerm(AtomCoInductive); - AtomComma = Yap_LookupAtom(","); TermComma = MkAtomTerm(AtomComma); - AtomCommentHook = Yap_LookupAtom("comment_hook"); TermCommentHook = MkAtomTerm(AtomCommentHook); - AtomCompact = Yap_LookupAtom("compact"); TermCompact = MkAtomTerm(AtomCompact); - AtomCompound = Yap_LookupAtom("compound"); TermCompound = MkAtomTerm(AtomCompound); - AtomConsistencyError = Yap_LookupAtom("consistency_error"); TermConsistencyError = MkAtomTerm(AtomConsistencyError); - AtomConsult = Yap_LookupAtom("consult"); TermConsult = MkAtomTerm(AtomConsult); - AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); - AtomContext = Yap_LookupAtom("context"); TermContext = MkAtomTerm(AtomContext); - AtomCputime = Yap_LookupAtom("cputime"); TermCputime = MkAtomTerm(AtomCputime); - AtomCreate = Yap_LookupAtom("create"); TermCreate = MkAtomTerm(AtomCreate); - AtomCreep = Yap_FullLookupAtom("$creep"); TermCreep = MkAtomTerm(AtomCreep); - AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); - AtomCurly = Yap_LookupAtom("{}"); TermCurly = MkAtomTerm(AtomCurly); - AtomCsult = Yap_FullLookupAtom("$csult"); TermCsult = MkAtomTerm(AtomCsult); - AtomCurrentModule = Yap_FullLookupAtom("$current_module"); TermCurrentModule = MkAtomTerm(AtomCurrentModule); - AtomCut = Yap_LookupAtom("!"); TermCut = MkAtomTerm(AtomCut); - AtomCutBy = Yap_FullLookupAtom("$cut_by"); TermCutBy = MkAtomTerm(AtomCutBy); - AtomDAbort = Yap_LookupAtom("abort"); TermDAbort = MkAtomTerm(AtomDAbort); - AtomDBLoad = Yap_FullLookupAtom("$db_load"); TermDBLoad = MkAtomTerm(AtomDBLoad); - AtomDBREF = Yap_LookupAtom("DBRef"); TermDBREF = MkAtomTerm(AtomDBREF); - AtomDBReference = Yap_LookupAtom("db_reference"); TermDBReference = MkAtomTerm(AtomDBReference); - AtomDBTerm = Yap_LookupAtom("db_term"); TermDBTerm = MkAtomTerm(AtomDBTerm); - AtomDBref = Yap_FullLookupAtom("$dbref"); TermDBref = MkAtomTerm(AtomDBref); - AtomDInteger = Yap_FullLookupAtom("$integer"); TermDInteger = MkAtomTerm(AtomDInteger); - AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); TermDebugMeta = MkAtomTerm(AtomDebugMeta); - AtomDebuggerInput = Yap_LookupAtom("debugger_input"); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); - AtomDec10 = Yap_LookupAtom("dec10"); TermDec10 = MkAtomTerm(AtomDec10); - AtomDefault = Yap_LookupAtom("default"); TermDefault = MkAtomTerm(AtomDefault); - AtomDevNull = Yap_LookupAtom("/dev/null"); TermDevNull = MkAtomTerm(AtomDevNull); - AtomDiff = Yap_LookupAtom("\\="); TermDiff = MkAtomTerm(AtomDiff); - AtomDirectory = Yap_LookupAtom("disrectorys"); TermDirectory = MkAtomTerm(AtomDirectory); - AtomDiscontiguous = Yap_LookupAtom("discontiguous"); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); - AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); - AtomDollar = Yap_FullLookupAtom("$"); TermDollar = MkAtomTerm(AtomDollar); - AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); - AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); - AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); - AtomDollarU = Yap_FullLookupAtom("$u"); TermDollarU = MkAtomTerm(AtomDollarU); - AtomDollarUndef = Yap_FullLookupAtom("$undef"); TermDollarUndef = MkAtomTerm(AtomDollarUndef); - AtomDomainError = Yap_LookupAtom("domain_error"); TermDomainError = MkAtomTerm(AtomDomainError); - AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); - AtomDots = Yap_LookupAtom("dots"); TermDots = MkAtomTerm(AtomDots); - AtomDOUBLE = Yap_FullLookupAtom("Double"); TermDOUBLE = MkAtomTerm(AtomDOUBLE); - AtomDoubleSlash = Yap_FullLookupAtom("//"); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); - AtomE = Yap_LookupAtom("e"); TermE = MkAtomTerm(AtomE); - AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); - AtomEQ = Yap_LookupAtom("="); TermEQ = MkAtomTerm(AtomEQ); - AtomEmptyAtom = Yap_LookupAtom(""); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); - AtomEncoding = Yap_LookupAtom("encoding"); TermEncoding = MkAtomTerm(AtomEncoding); - AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); TermEndOfStream = MkAtomTerm(AtomEndOfStream); - AtomEof = Yap_LookupAtom("end_of_file"); TermEof = MkAtomTerm(AtomEof); - AtomEOfCode = Yap_LookupAtom("eof_code"); TermEOfCode = MkAtomTerm(AtomEOfCode); - AtomEq = Yap_LookupAtom("="); TermEq = MkAtomTerm(AtomEq); - AtomError = Yap_LookupAtom("error"); TermError = MkAtomTerm(AtomError); - AtomException = Yap_LookupAtom("exception"); TermException = MkAtomTerm(AtomException); - AtomExtensions = Yap_LookupAtom("extensions"); TermExtensions = MkAtomTerm(AtomExtensions); - AtomEvaluable = Yap_LookupAtom("evaluable"); TermEvaluable = MkAtomTerm(AtomEvaluable); - AtomEvaluationError = Yap_LookupAtom("evaluation_error"); TermEvaluationError = MkAtomTerm(AtomEvaluationError); - AtomExecutable = Yap_LookupAtom("executable"); TermExecutable = MkAtomTerm(AtomExecutable); - AtomExecute = Yap_LookupAtom("execute"); TermExecute = MkAtomTerm(AtomExecute); - AtomExecAnswers = Yap_LookupAtom("exec_answers"); TermExecAnswers = MkAtomTerm(AtomExecAnswers); - AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); - AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); - AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); - AtomExist = Yap_LookupAtom("exist"); TermExist = MkAtomTerm(AtomExist); - AtomExists = Yap_LookupAtom("exists"); TermExists = MkAtomTerm(AtomExists); - AtomExit = Yap_LookupAtom("exit"); TermExit = MkAtomTerm(AtomExit); - AtomExistenceError = Yap_LookupAtom("existence_error"); TermExistenceError = MkAtomTerm(AtomExistenceError); - AtomExoClause = Yap_FullLookupAtom("$exo_clause"); TermExoClause = MkAtomTerm(AtomExoClause); - AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); - AtomExpand = Yap_LookupAtom("expand"); TermExpand = MkAtomTerm(AtomExpand); - AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); - AtomExtendsions = Yap_LookupAtom("extensionh"); TermExtendsions = MkAtomTerm(AtomExtendsions); - AtomFB = Yap_LookupAtom("fb"); TermFB = MkAtomTerm(AtomFB); - AtomFail = Yap_LookupAtom("fail"); TermFail = MkAtomTerm(AtomFail); - AtomFalse = Yap_LookupAtom("false"); TermFalse = MkAtomTerm(AtomFalse); - AtomFast = Yap_FullLookupAtom("$fast"); TermFast = MkAtomTerm(AtomFast); - AtomFastFail = Yap_LookupAtom("fast_fail"); TermFastFail = MkAtomTerm(AtomFastFail); - AtomFileErrors = Yap_LookupAtom("file_errors"); TermFileErrors = MkAtomTerm(AtomFileErrors); - AtomFileerrors = Yap_LookupAtom("fileerrors"); TermFileerrors = MkAtomTerm(AtomFileerrors); - AtomFileType = Yap_LookupAtom("file_type"); TermFileType = MkAtomTerm(AtomFileType); - AtomFirst = Yap_LookupAtom("first"); TermFirst = MkAtomTerm(AtomFirst); - AtomFloat = Yap_LookupAtom("float"); TermFloat = MkAtomTerm(AtomFloat); - AtomFloatFormat = Yap_LookupAtom("\%.15g"); TermFloatFormat = MkAtomTerm(AtomFloatFormat); - AtomFloatOverflow = Yap_LookupAtom("float_overflow"); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); - AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); - AtomFormat = Yap_LookupAtom("format"); TermFormat = MkAtomTerm(AtomFormat); - AtomFormatAt = Yap_FullLookupAtom("$format@"); TermFormatAt = MkAtomTerm(AtomFormatAt); - AtomFull = Yap_LookupAtom("full"); TermFull = MkAtomTerm(AtomFull); - AtomFunctor = Yap_LookupAtom("functor"); TermFunctor = MkAtomTerm(AtomFunctor); - AtomGT = Yap_LookupAtom(">"); TermGT = MkAtomTerm(AtomGT); - AtomGVar = Yap_LookupAtom("var"); TermGVar = MkAtomTerm(AtomGVar); - AtomGc = Yap_FullLookupAtom("$gc"); TermGc = MkAtomTerm(AtomGc); - AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); TermGcMargin = MkAtomTerm(AtomGcMargin); - AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); TermGcTrace = MkAtomTerm(AtomGcTrace); - AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); TermGcVerbose = MkAtomTerm(AtomGcVerbose); - AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); - AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); - AtomGetwork = Yap_FullLookupAtom("$getwork"); TermGetwork = MkAtomTerm(AtomGetwork); - AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); - AtomGlob = Yap_LookupAtom("glob"); TermGlob = MkAtomTerm(AtomGlob); - AtomGlobal = Yap_LookupAtom("global"); TermGlobal = MkAtomTerm(AtomGlobal); - AtomGlobalSp = Yap_LookupAtom("global_sp"); TermGlobalSp = MkAtomTerm(AtomGlobalSp); - AtomGlobalTrie = Yap_LookupAtom("global_trie"); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); - AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); - AtomHat = Yap_LookupAtom("^"); TermHat = MkAtomTerm(AtomHat); - AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); TermHERE = MkAtomTerm(AtomHERE); - AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); TermHandleThrow = MkAtomTerm(AtomHandleThrow); - AtomHeap = Yap_LookupAtom("heap"); TermHeap = MkAtomTerm(AtomHeap); - AtomHeapUsed = Yap_LookupAtom("heapused"); TermHeapUsed = MkAtomTerm(AtomHeapUsed); - AtomHugeInt = Yap_LookupAtom("huge_int"); TermHugeInt = MkAtomTerm(AtomHugeInt); - AtomIDB = Yap_LookupAtom("idb"); TermIDB = MkAtomTerm(AtomIDB); - AtomIOMode = Yap_LookupAtom("io_mode"); TermIOMode = MkAtomTerm(AtomIOMode); - AtomI = Yap_LookupAtom("i"); TermI = MkAtomTerm(AtomI); - AtomId = Yap_LookupAtom("id"); TermId = MkAtomTerm(AtomId); - AtomIgnore = Yap_LookupAtom("ignore"); TermIgnore = MkAtomTerm(AtomIgnore); - AtomInf = Yap_LookupAtom("inf"); TermInf = MkAtomTerm(AtomInf); - AtomInfinity = Yap_LookupAtom("infinity"); TermInfinity = MkAtomTerm(AtomInfinity); - AtomInfo = Yap_LookupAtom("info"); TermInfo = MkAtomTerm(AtomInfo); - AtomInitGoal = Yap_FullLookupAtom("$init_goal"); TermInitGoal = MkAtomTerm(AtomInitGoal); - AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); TermInitProlog = MkAtomTerm(AtomInitProlog); - AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); - AtomInput = Yap_LookupAtom("input"); TermInput = MkAtomTerm(AtomInput); - AtomInstantiationError = Yap_LookupAtom("instantiation_error"); TermInstantiationError = MkAtomTerm(AtomInstantiationError); - AtomInt = Yap_LookupAtom("int"); TermInt = MkAtomTerm(AtomInt); - AtomIntOverflow = Yap_LookupAtom("int_overflow"); TermIntOverflow = MkAtomTerm(AtomIntOverflow); - AtomInteger = Yap_LookupAtom("integer"); TermInteger = MkAtomTerm(AtomInteger); - AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); - AtomIs = Yap_LookupAtom("is"); TermIs = MkAtomTerm(AtomIs); - AtomJ = Yap_LookupAtom("j"); TermJ = MkAtomTerm(AtomJ); - Atoml = Yap_LookupAtom("l"); Terml = MkAtomTerm(Atoml); - AtomKey = Yap_LookupAtom("key"); TermKey = MkAtomTerm(AtomKey); - AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); - AtomLONGINT = Yap_LookupAtom("LongInt"); TermLONGINT = MkAtomTerm(AtomLONGINT); - AtomLOOP = Yap_LookupAtom("_LOOP_"); TermLOOP = MkAtomTerm(AtomLOOP); - AtomLoopStream = Yap_LookupAtom("loop_stream"); TermLoopStream = MkAtomTerm(AtomLoopStream); - AtomLT = Yap_LookupAtom("<"); TermLT = MkAtomTerm(AtomLT); - AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); - AtomLeash = Yap_FullLookupAtom("$leash"); TermLeash = MkAtomTerm(AtomLeash); - AtomLeast = Yap_LookupAtom("least"); TermLeast = MkAtomTerm(AtomLeast); - AtomLength = Yap_FullLookupAtom("length"); TermLength = MkAtomTerm(AtomLength); - AtomList = Yap_LookupAtom("list"); TermList = MkAtomTerm(AtomList); - AtomLine = Yap_LookupAtom("line"); TermLine = MkAtomTerm(AtomLine); - AtomLive = Yap_FullLookupAtom("$live"); TermLive = MkAtomTerm(AtomLive); - AtomLoadAnswers = Yap_LookupAtom("load_answers"); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); - AtomLocal = Yap_LookupAtom("local"); TermLocal = MkAtomTerm(AtomLocal); - AtomLocalSp = Yap_LookupAtom("local_sp"); TermLocalSp = MkAtomTerm(AtomLocalSp); - AtomLocalTrie = Yap_LookupAtom("local_trie"); TermLocalTrie = MkAtomTerm(AtomLocalTrie); - AtomMax = Yap_LookupAtom("max"); TermMax = MkAtomTerm(AtomMax); - AtomMaximum = Yap_LookupAtom("maximum"); TermMaximum = MkAtomTerm(AtomMaximum); - AtomMaxArity = Yap_LookupAtom("max_arity"); TermMaxArity = MkAtomTerm(AtomMaxArity); - AtomMaxFiles = Yap_LookupAtom("max_files"); TermMaxFiles = MkAtomTerm(AtomMaxFiles); - AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); TermMegaClause = MkAtomTerm(AtomMegaClause); - AtomMetaCall = Yap_FullLookupAtom("$call"); TermMetaCall = MkAtomTerm(AtomMetaCall); - AtomMfClause = Yap_FullLookupAtom("$mf_clause"); TermMfClause = MkAtomTerm(AtomMfClause); - AtomMin = Yap_LookupAtom("min"); TermMin = MkAtomTerm(AtomMin); - AtomMinimum = Yap_LookupAtom("minimum"); TermMinimum = MkAtomTerm(AtomMinimum); - AtomMinus = Yap_LookupAtom("-"); TermMinus = MkAtomTerm(AtomMinus); - AtomModify = Yap_LookupAtom("modify"); TermModify = MkAtomTerm(AtomModify); - AtomModule = Yap_LookupAtom("module"); TermModule = MkAtomTerm(AtomModule); - AtomMost = Yap_LookupAtom("most"); TermMost = MkAtomTerm(AtomMost); - AtomMulti = Yap_LookupAtom("multi"); TermMulti = MkAtomTerm(AtomMulti); - AtomMultiFile = Yap_FullLookupAtom("$mf"); TermMultiFile = MkAtomTerm(AtomMultiFile); - AtomMultiple = Yap_FullLookupAtom("multiple"); TermMultiple = MkAtomTerm(AtomMultiple); - AtomMutable = Yap_LookupAtom("mutable"); TermMutable = MkAtomTerm(AtomMutable); - AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); TermMutableVariable = MkAtomTerm(AtomMutableVariable); - AtomMutex = Yap_LookupAtom("mutex"); TermMutex = MkAtomTerm(AtomMutex); - AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); TermMyddasDB = MkAtomTerm(AtomMyddasDB); - AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); - AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); TermMyddasHost = MkAtomTerm(AtomMyddasHost); - AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); TermMyddasPass = MkAtomTerm(AtomMyddasPass); - AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); TermMyddasUser = MkAtomTerm(AtomMyddasUser); - AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); - AtomNan = Yap_LookupAtom("nan"); TermNan = MkAtomTerm(AtomNan); - AtomNb = Yap_LookupAtom("nb"); TermNb = MkAtomTerm(AtomNb); - AtomNbTerm = Yap_LookupAtom("nb_term"); TermNbTerm = MkAtomTerm(AtomNbTerm); - AtomNew = Yap_LookupAtom("new"); TermNew = MkAtomTerm(AtomNew); - AtomNewLine = Yap_LookupAtom("nl"); TermNewLine = MkAtomTerm(AtomNewLine); - AtomNl = Yap_LookupAtom("nl"); TermNl = MkAtomTerm(AtomNl); - AtomNoEffect = Yap_LookupAtom("no_effect"); TermNoEffect = MkAtomTerm(AtomNoEffect); - AtomNoMemory = Yap_LookupAtom("no_memory"); TermNoMemory = MkAtomTerm(AtomNoMemory); - AtomNone = Yap_LookupAtom("none"); TermNone = MkAtomTerm(AtomNone); - AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); - AtomNot = Yap_LookupAtom("\\+"); TermNot = MkAtomTerm(AtomNot); - AtomNotImplemented = Yap_LookupAtom("not_implemented"); TermNotImplemented = MkAtomTerm(AtomNotImplemented); - AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); - AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline); - AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero); - AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber); - AtomObj = Yap_LookupAtom("o__bj__"); TermObj = MkAtomTerm(AtomObj); - AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff); - AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline); - AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn); - AtomOnline = Yap_LookupAtom("online"); TermOnline = MkAtomTerm(AtomOnline); - AtomOpen = Yap_LookupAtom("open"); TermOpen = MkAtomTerm(AtomOpen); - AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); - AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); - AtomOperator = Yap_LookupAtom("operator"); TermOperator = MkAtomTerm(AtomOperator); - AtomOperatorPriority = Yap_LookupAtom("operator_priority"); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); - AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); - AtomOpt = Yap_LookupAtom("opt"); TermOpt = MkAtomTerm(AtomOpt); - AtomOtherwise = Yap_LookupAtom("otherwise"); TermOtherwise = MkAtomTerm(AtomOtherwise); - AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); - AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); - AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); - AtomOutOfRange = Yap_LookupAtom("out_of_range"); TermOutOfRange = MkAtomTerm(AtomOutOfRange); - AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); - AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); - AtomOutput = Yap_LookupAtom("output"); TermOutput = MkAtomTerm(AtomOutput); - AtomParameter = Yap_LookupAtom("parameter"); TermParameter = MkAtomTerm(AtomParameter); - AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); - AtomPast = Yap_LookupAtom("past"); TermPast = MkAtomTerm(AtomPast); - AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); - AtomPermissionError = Yap_LookupAtom("permission_error"); TermPermissionError = MkAtomTerm(AtomPermissionError); - AtomPi = Yap_LookupAtom("pi"); TermPi = MkAtomTerm(AtomPi); - AtomPipe = Yap_LookupAtom("pipe"); TermPipe = MkAtomTerm(AtomPipe); - AtomPriority = Yap_LookupAtom("priority"); TermPriority = MkAtomTerm(AtomPriority); - AtomPlus = Yap_LookupAtom("+"); TermPlus = MkAtomTerm(AtomPlus); - AtomPointer = Yap_LookupAtom("pointer"); TermPointer = MkAtomTerm(AtomPointer); - AtomPortray = Yap_FullLookupAtom("portray"); TermPortray = MkAtomTerm(AtomPortray); - AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); - AtomPrimitive = Yap_LookupAtom("primitive"); TermPrimitive = MkAtomTerm(AtomPrimitive); - AtomPrintMessage = Yap_LookupAtom("print_message"); TermPrintMessage = MkAtomTerm(AtomPrintMessage); - AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); - AtomProcedure = Yap_LookupAtom("procedure"); TermProcedure = MkAtomTerm(AtomProcedure); - AtomProfile = Yap_FullLookupAtom("$profile"); TermProfile = MkAtomTerm(AtomProfile); - AtomProlog = Yap_LookupAtom("prolog"); TermProlog = MkAtomTerm(AtomProlog); - AtomProtectStack = Yap_FullLookupAtom("$protect_stack"); TermProtectStack = MkAtomTerm(AtomProtectStack); - AtomQly = Yap_LookupAtom("qly"); TermQly = MkAtomTerm(AtomQly); - AtomQuery = Yap_LookupAtom("?-"); TermQuery = MkAtomTerm(AtomQuery); - AtomQueue = Yap_LookupAtom("queue"); TermQueue = MkAtomTerm(AtomQueue); - AtomQuiet = Yap_LookupAtom("quiet"); TermQuiet = MkAtomTerm(AtomQuiet); - AtomRadix = Yap_LookupAtom("radix"); TermRadix = MkAtomTerm(AtomRadix); - AtomRandom = Yap_LookupAtom("random"); TermRandom = MkAtomTerm(AtomRandom); - AtomRange = Yap_LookupAtom("range"); TermRange = MkAtomTerm(AtomRange); - AtomRDiv = Yap_LookupAtom("rdiv"); TermRDiv = MkAtomTerm(AtomRDiv); - AtomRead = Yap_LookupAtom("read"); TermRead = MkAtomTerm(AtomRead); - AtomReadOnly = Yap_LookupAtom("read_only"); TermReadOnly = MkAtomTerm(AtomReadOnly); - AtomReadWrite = Yap_LookupAtom("read_write"); TermReadWrite = MkAtomTerm(AtomReadWrite); - AtomReadutil = Yap_LookupAtom("readutil"); TermReadutil = MkAtomTerm(AtomReadutil); - AtomReconsult = Yap_LookupAtom("reconsult"); TermReconsult = MkAtomTerm(AtomReconsult); - AtomRecordedP = Yap_FullLookupAtom("$recordep"); TermRecordedP = MkAtomTerm(AtomRecordedP); - AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); - AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); - AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); - AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); TermRefoundVar = MkAtomTerm(AtomRefoundVar); - AtomRelativeTo = Yap_FullLookupAtom("relative_to"); TermRelativeTo = MkAtomTerm(AtomRelativeTo); - AtomRepeat = Yap_LookupAtom("repeat"); TermRepeat = MkAtomTerm(AtomRepeat); - AtomRepeatSpace = Yap_LookupAtom("repeat "); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); - AtomReposition = Yap_LookupAtom("reposition"); TermReposition = MkAtomTerm(AtomReposition); - AtomRepresentationError = Yap_LookupAtom("representation_error"); TermRepresentationError = MkAtomTerm(AtomRepresentationError); - AtomReset = Yap_LookupAtom("reset"); TermReset = MkAtomTerm(AtomReset); - AtomResize = Yap_LookupAtom("resize"); TermResize = MkAtomTerm(AtomResize); - AtomResourceError = Yap_LookupAtom("resource_error"); TermResourceError = MkAtomTerm(AtomResourceError); - AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); - AtomRetry = Yap_LookupAtom("retry"); TermRetry = MkAtomTerm(AtomRetry); - AtomRetryCounter = Yap_LookupAtom("retry_counter"); TermRetryCounter = MkAtomTerm(AtomRetryCounter); - AtomRTree = Yap_LookupAtom("rtree"); TermRTree = MkAtomTerm(AtomRTree); - AtomSafe = Yap_FullLookupAtom("$safe"); TermSafe = MkAtomTerm(AtomSafe); - AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); - AtomSame = Yap_LookupAtom("=="); TermSame = MkAtomTerm(AtomSame); - AtomSemic = Yap_LookupAtom(";"); TermSemic = MkAtomTerm(AtomSemic); - AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); - AtomSigAlarm = Yap_LookupAtom("sig_alarm"); TermSigAlarm = MkAtomTerm(AtomSigAlarm); - AtomSigBreak = Yap_LookupAtom("sig_break"); TermSigBreak = MkAtomTerm(AtomSigBreak); - AtomSigCreep = Yap_LookupAtom("sig_creep"); TermSigCreep = MkAtomTerm(AtomSigCreep); - AtomSigDebug = Yap_LookupAtom("sig_debug"); TermSigDebug = MkAtomTerm(AtomSigDebug); - AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); - AtomSigFPE = Yap_LookupAtom("sig_fpe"); TermSigFPE = MkAtomTerm(AtomSigFPE); - AtomSigHup = Yap_LookupAtom("sig_hup"); TermSigHup = MkAtomTerm(AtomSigHup); - AtomSigInt = Yap_LookupAtom("sig_int"); TermSigInt = MkAtomTerm(AtomSigInt); - AtomSigIti = Yap_LookupAtom("sig_iti"); TermSigIti = MkAtomTerm(AtomSigIti); - AtomSigPending = Yap_FullLookupAtom("$sig_pending"); TermSigPending = MkAtomTerm(AtomSigPending); - AtomSigPipe = Yap_LookupAtom("sig_pipe"); TermSigPipe = MkAtomTerm(AtomSigPipe); - AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); TermSigStackDump = MkAtomTerm(AtomSigStackDump); - AtomSigStatistics = Yap_LookupAtom("sig_statistics"); TermSigStatistics = MkAtomTerm(AtomSigStatistics); - AtomSigTrace = Yap_LookupAtom("sig_trace"); TermSigTrace = MkAtomTerm(AtomSigTrace); - AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); - AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); - AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); - AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); - AtomSilent = Yap_LookupAtom("Silent"); TermSilent = MkAtomTerm(AtomSilent); - AtomSingle = Yap_LookupAtom("single"); TermSingle = MkAtomTerm(AtomSingle); - AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); - AtomSingleton = Yap_LookupAtom("singleton"); TermSingleton = MkAtomTerm(AtomSingleton); - AtomSlash = Yap_LookupAtom("/"); TermSlash = MkAtomTerm(AtomSlash); - AtomSocket = Yap_LookupAtom("socket"); TermSocket = MkAtomTerm(AtomSocket); - AtomSolutions = Yap_LookupAtom("solutions"); TermSolutions = MkAtomTerm(AtomSolutions); - AtomSource = Yap_LookupAtom("source"); TermSource = MkAtomTerm(AtomSource); - AtomSourceSink = Yap_LookupAtom("source_sink"); TermSourceSink = MkAtomTerm(AtomSourceSink); - AtomSpy = Yap_FullLookupAtom("$spy"); TermSpy = MkAtomTerm(AtomSpy); - AtomStack = Yap_LookupAtom("stack"); TermStack = MkAtomTerm(AtomStack); - AtomStackFree = Yap_LookupAtom("stackfree"); TermStackFree = MkAtomTerm(AtomStackFree); - AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); - AtomStaticClause = Yap_FullLookupAtom("$static_clause"); TermStaticClause = MkAtomTerm(AtomStaticClause); - AtomStaticProcedure = Yap_LookupAtom("static_procedure"); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); - AtomStream = Yap_FullLookupAtom("$stream"); TermStream = MkAtomTerm(AtomStream); - AtomSWIStream = Yap_FullLookupAtom(""); TermSWIStream = MkAtomTerm(AtomSWIStream); - AtomVStream = Yap_LookupAtom("stream"); TermVStream = MkAtomTerm(AtomVStream); - AtomStreams = Yap_LookupAtom("streams"); TermStreams = MkAtomTerm(AtomStreams); - AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); - AtomStreamPos = Yap_FullLookupAtom("$stream_position"); TermStreamPos = MkAtomTerm(AtomStreamPos); - AtomStreamPosition = Yap_LookupAtom("stream_position"); TermStreamPosition = MkAtomTerm(AtomStreamPosition); - AtomString = Yap_LookupAtom("string"); TermString = MkAtomTerm(AtomString); - AtomStyleCheck = Yap_LookupAtom("style_check"); TermStyleCheck = MkAtomTerm(AtomStyleCheck); - AtomSTRING = Yap_FullLookupAtom("String"); TermSTRING = MkAtomTerm(AtomSTRING); - AtomSwi = Yap_LookupAtom("swi"); TermSwi = MkAtomTerm(AtomSwi); - AtomSymbolChar = Yap_LookupAtom("symbol_char"); TermSymbolChar = MkAtomTerm(AtomSymbolChar); - AtomSyntaxError = Yap_LookupAtom("syntax_error"); TermSyntaxError = MkAtomTerm(AtomSyntaxError); - AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); - AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); - AtomSystem = Yap_LookupAtom("system"); TermSystem = MkAtomTerm(AtomSystem); - AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); TermSystemError = MkAtomTerm(AtomSystemError); - AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); - AtomT = Yap_LookupAtom("t"); TermT = MkAtomTerm(AtomT); - AtomTerm = Yap_LookupAtom("term"); TermTerm = MkAtomTerm(AtomTerm); - AtomTermExpansion = Yap_LookupAtom("term_expansion"); TermTermExpansion = MkAtomTerm(AtomTermExpansion); - AtomTerms = Yap_LookupAtom("terms"); TermTerms = MkAtomTerm(AtomTerms); - AtomText = Yap_LookupAtom("text"); TermText = MkAtomTerm(AtomText); - AtomTextStream = Yap_LookupAtom("text_stream"); TermTextStream = MkAtomTerm(AtomTextStream); - AtomThread = Yap_LookupAtom("thread"); TermThread = MkAtomTerm(AtomThread); - AtomThreads = Yap_LookupAtom("threads"); TermThreads = MkAtomTerm(AtomThreads); - AtomThrow = Yap_LookupAtom("throw"); TermThrow = MkAtomTerm(AtomThrow); - AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); - AtomTimeoutError = Yap_LookupAtom("timeout_error"); TermTimeoutError = MkAtomTerm(AtomTimeoutError); - AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); - AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); - AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); - AtomTrail = Yap_LookupAtom("trail"); - AtomTrue = Yap_LookupAtom("true"); TermTrue = MkAtomTerm(AtomTrue); - AtomTty = Yap_LookupAtom("tty"); TermTty = MkAtomTerm(AtomTty); - AtomTtys = Yap_LookupAtom("ttys"); TermTtys = MkAtomTerm(AtomTtys); - AtomTuple = Yap_LookupAtom("tuple"); TermTuple = MkAtomTerm(AtomTuple); - AtomTxt = Yap_LookupAtom("txt"); TermTxt = MkAtomTerm(AtomTxt); - AtomTypeError = Yap_LookupAtom("type_error"); TermTypeError = MkAtomTerm(AtomTypeError); - AtomUndefined = Yap_LookupAtom("undefined"); TermUndefined = MkAtomTerm(AtomUndefined); - AtomUndefp = Yap_FullLookupAtom("$undefp"); TermUndefp = MkAtomTerm(AtomUndefp); - AtomUndefp0 = Yap_FullLookupAtom("$undefp0"); TermUndefp0 = MkAtomTerm(AtomUndefp0); - AtomUnderflow = Yap_LookupAtom("underflow"); TermUnderflow = MkAtomTerm(AtomUnderflow); - AtomUnificationStack = Yap_LookupAtom("unification_stack"); TermUnificationStack = MkAtomTerm(AtomUnificationStack); - AtomUnique = Yap_LookupAtom("unique"); TermUnique = MkAtomTerm(AtomUnique); - AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); - AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); - AtomUser = Yap_LookupAtom("user"); TermUser = MkAtomTerm(AtomUser); - AtomUserErr = Yap_LookupAtom("user_error"); TermUserErr = MkAtomTerm(AtomUserErr); - AtomUserIn = Yap_LookupAtom("user_input"); TermUserIn = MkAtomTerm(AtomUserIn); - AtomUserOut = Yap_LookupAtom("user_output"); TermUserOut = MkAtomTerm(AtomUserOut); - AtomDollarVar = Yap_LookupAtom("$VAR"); TermDollarVar = MkAtomTerm(AtomDollarVar); - AtomVBar = Yap_LookupAtom("|"); TermVBar = MkAtomTerm(AtomVBar); - AtomVarBranches = Yap_LookupAtom("var_branches"); TermVarBranches = MkAtomTerm(AtomVarBranches); - AtomVariableNames = Yap_LookupAtom("variable_names"); TermVariableNames = MkAtomTerm(AtomVariableNames); - AtomHiddenVar = Yap_FullLookupAtom("$V"); TermHiddenVar = MkAtomTerm(AtomHiddenVar); - AtomVariable = Yap_LookupAtom("variable"); TermVariable = MkAtomTerm(AtomVariable); - AtomVerbose = Yap_LookupAtom("verbose"); TermVerbose = MkAtomTerm(AtomVerbose); - AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); - AtomVersionNumber = Yap_FullLookupAtom("$version_name"); TermVersionNumber = MkAtomTerm(AtomVersionNumber); - AtomVeryVerbose = Yap_LookupAtom("very_verbose"); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); - AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); - AtomWarning = Yap_LookupAtom("warning"); TermWarning = MkAtomTerm(AtomWarning); - AtomWhen = Yap_FullLookupAtom("$when"); TermWhen = MkAtomTerm(AtomWhen); - AtomWrite = Yap_LookupAtom("write"); TermWrite = MkAtomTerm(AtomWrite); - AtomWriteTerm = Yap_LookupAtom("write_term"); TermWriteTerm = MkAtomTerm(AtomWriteTerm); - AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml); - AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks); - AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); - FunctorAfInet = Yap_MkFunctor(AtomAfInet,2); - FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1); - FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1); - FunctorAltNot = Yap_MkFunctor(AtomAltNot,1); - FunctorArg = Yap_MkFunctor(AtomArg,3); - FunctorArrayEntry = Yap_MkFunctor(AtomArrayAccess,3); - FunctorArrow = Yap_MkFunctor(AtomArrow,2); - FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2); - FunctorAssert1 = Yap_MkFunctor(AtomAssert,1); - FunctorAssert = Yap_MkFunctor(AtomAssert,2); - FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2); - FunctorAtom = Yap_MkFunctor(AtomAtom,1); - FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3); - FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2); - FunctorBraces = Yap_MkFunctor(AtomBraces,1); - FunctorCall = Yap_MkFunctor(AtomCall,1); - FunctorCatch = Yap_MkFunctor(AtomCatch,3); - FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1); - FunctorChars = Yap_MkFunctor(AtomChars,2); - FunctorChars1 = Yap_MkFunctor(AtomChars,1); - FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2); - FunctorClist = Yap_MkFunctor(AtomWhen,4); - FunctorCodes = Yap_MkFunctor(AtomCodes,2); - FunctorCodes1 = Yap_MkFunctor(AtomCodes,1); - FunctorColon = Yap_MkFunctor(AtomColon,2); - FunctorComma = Yap_MkFunctor(AtomComma,2); - FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3); - FunctorContext2 = Yap_MkFunctor(AtomContext,2); - FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1); - FunctorCreep = Yap_MkFunctor(AtomCreep,1); - FunctorCsult = Yap_MkFunctor(AtomCsult,2); - FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1); - FunctorCutBy = Yap_MkFunctor(AtomCutBy,1); - FunctorDBREF = Yap_MkFunctor(AtomDBREF,1); - FunctorDiff = Yap_MkFunctor(AtomDiff,2); - FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6); - FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6); - FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6); - FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5); - FunctorDollar = Yap_MkFunctor(AtomDollar,1); - FunctorDollarVar = Yap_MkFunctor(AtomDollarVar,1); - FunctorDomainError = Yap_MkFunctor(AtomDomainError,2); - FunctorDot = Yap_MkFunctor(AtomDot,2); - FunctorDot10 = Yap_MkFunctor(AtomDot,10); - FunctorDot11 = Yap_MkFunctor(AtomDot,11); - FunctorDot12 = Yap_MkFunctor(AtomDot,12); - FunctorDot2 = Yap_MkFunctor(AtomDot,2); - FunctorDot3 = Yap_MkFunctor(AtomDot,3); - FunctorDot4 = Yap_MkFunctor(AtomDot,4); - FunctorDot5 = Yap_MkFunctor(AtomDot,5); - FunctorDot6 = Yap_MkFunctor(AtomDot,6); - FunctorDot7 = Yap_MkFunctor(AtomDot,7); - FunctorDot8 = Yap_MkFunctor(AtomDot,8); - FunctorDot9 = Yap_MkFunctor(AtomDot,9); - FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2); - FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2); - FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2); - FunctorEq = Yap_MkFunctor(AtomEq,2); - FunctorError = Yap_MkFunctor(AtomError,2); - FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1); - FunctorException = Yap_MkFunctor(AtomException,1); - FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2); - FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2); - FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1); - FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2); - FunctorExoClause = Yap_MkFunctor(AtomExoClause,2); - FunctorFunctor = Yap_MkFunctor(AtomFunctor,3); - FunctorGAtom = Yap_MkFunctor(AtomAtom,1); - FunctorGAtomic = Yap_MkFunctor(AtomAtomic,1); - FunctorGCompound = Yap_MkFunctor(AtomCompound,1); - FunctorGFloat = Yap_MkFunctor(AtomFloat,1); - FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2); - FunctorGInteger = Yap_MkFunctor(AtomInteger,1); - FunctorGNumber = Yap_MkFunctor(AtomNumber,1); - FunctorGPrimitive = Yap_MkFunctor(AtomPrimitive,1); - FunctorGVar = Yap_MkFunctor(AtomGVar,1); - FunctorGeneratePredInfo = Yap_MkFunctor(AtomGeneratePredInfo,4); - FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2); - FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3); - FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3); - FunctorHat = Yap_MkFunctor(AtomHat,2); - FunctorI = Yap_MkFunctor(AtomI,2); - FunctorId = Yap_MkFunctor(AtomId,1); - FunctorInfo1 = Yap_MkFunctor(AtomInfo,1); - FunctorInfo2 = Yap_MkFunctor(AtomInfo,2); - FunctorInfo3 = Yap_MkFunctor(AtomInfo,3); - FunctorInfo4 = Yap_MkFunctor(AtomInfo,4); - FunctorIs = Yap_MkFunctor(AtomIs,2); - FunctorJ = Yap_MkFunctor(AtomJ,2); - FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1); - FunctorList = Yap_MkFunctor(AtomDot,2); - FunctorLOOP = Yap_MkFunctor(AtomLOOP,1); - FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2); - FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4); - FunctorMinus = Yap_MkFunctor(AtomMinus,2); - FunctorModule = Yap_MkFunctor(AtomColon,2); - FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5); - FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL))); - FunctorMutex = Yap_MkFunctor(AtomMutex,2); - FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2); - FunctorNBQueue = Yap_MkFunctor(AtomQueue,4); - FunctorNot = Yap_MkFunctor(AtomNot,1); - FunctorObj = Yap_MkFunctor(AtomObj,1); - FunctorOr = Yap_MkFunctor(AtomSemic,2); - FunctorOutput = Yap_MkFunctor(AtomOutput,1); - FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3); - FunctorPlus = Yap_MkFunctor(AtomPlus,2); - FunctorPortray = Yap_MkFunctor(AtomPortray,1); - FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2); - FunctorProcedure = Yap_MkFunctor(AtomProcedure,5); - FunctorPriority = Yap_MkFunctor(AtomPriority,1); - FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2); - FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,4); - FunctorQuery = Yap_MkFunctor(AtomQuery,1); - FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6); - FunctorRDiv = Yap_MkFunctor(AtomRDiv,2); - FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3); - FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1); - FunctorResourceError = Yap_MkFunctor(AtomResourceError,1); - FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2); - FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1); - FunctorSafe = Yap_MkFunctor(AtomSafe,1); - FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4); - FunctorSame = Yap_MkFunctor(AtomSame,2); - FunctorSlash = Yap_MkFunctor(AtomSlash,2); - FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2); - FunctorStream = Yap_MkFunctor(AtomStream,1); - FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1); - FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4); - FunctorString1 = Yap_MkFunctor(AtomString,1); - FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4); - FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4); - FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1); - FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2); - FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2); - FunctorThrow = Yap_MkFunctor(AtomThrow,1); - FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2); - FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3); - FunctorTypeError = Yap_MkFunctor(AtomTypeError,2); - FunctorUMinus = Yap_MkFunctor(AtomMinus,1); - FunctorUPlus = Yap_MkFunctor(AtomPlus,1); - FunctorVBar = Yap_MkFunctor(AtomVBar,2); - FunctorWriteTerm = Yap_MkFunctor(AtomWriteTerm,2); - FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1); + + /* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms" + {lease do not update, update misc/ATOMS instead */ + + Atom3Dots = Yap_LookupAtom("..."); + AtomAbol = Yap_FullLookupAtom("$abol"); TermAbol = MkAtomTerm(AtomAbol); + AtomAccess = Yap_LookupAtom("access"); TermAccess = MkAtomTerm(AtomAccess); + AtomAfInet = Yap_LookupAtom("AF_INET"); TermAfInet = MkAtomTerm(AtomAfInet); + AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); TermAfLocal = MkAtomTerm(AtomAfLocal); + AtomAfUnix = Yap_LookupAtom("AF_UNIX"); TermAfUnix = MkAtomTerm(AtomAfUnix); + AtomAlarm = Yap_FullLookupAtom("$alarm"); TermAlarm = MkAtomTerm(AtomAlarm); + AtomAlias = Yap_LookupAtom("alias"); TermAlias = MkAtomTerm(AtomAlias); + AtomAll = Yap_LookupAtom("all"); TermAll = MkAtomTerm(AtomAll); + AtomAltNot = Yap_LookupAtom("not"); TermAltNot = MkAtomTerm(AtomAltNot); + AtomAnswer = Yap_LookupAtom("answer"); TermAnswer = MkAtomTerm(AtomAnswer); + AtomAny = Yap_LookupAtom("any"); TermAny = MkAtomTerm(AtomAny); + AtomAppend = Yap_LookupAtom("append"); TermAppend = MkAtomTerm(AtomAppend); + AtomArg = Yap_LookupAtom("arg"); TermArg = MkAtomTerm(AtomArg); + AtomArray = Yap_FullLookupAtom("$array"); TermArray = MkAtomTerm(AtomArray); + AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); TermArrayAccess = MkAtomTerm(AtomArrayAccess); + AtomArrayOverflow = Yap_LookupAtom("array_overflow"); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); + AtomArrayType = Yap_LookupAtom("array_type"); TermArrayType = MkAtomTerm(AtomArrayType); + AtomArrow = Yap_LookupAtom("->"); TermArrow = MkAtomTerm(AtomArrow); + AtomAttributedModule = Yap_LookupAtom("attributes_module"); TermAttributedModule = MkAtomTerm(AtomAttributedModule); + AtomDoubleArrow = Yap_LookupAtom("-->"); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); + AtomAssert = Yap_LookupAtom(":-"); TermAssert = MkAtomTerm(AtomAssert); + AtomBeginBracket = Yap_LookupAtom("("); TermBeginBracket = MkAtomTerm(AtomBeginBracket); + AtomEndBracket = Yap_LookupAtom(")"); TermEndBracket = MkAtomTerm(AtomEndBracket); + AtomBeginSquareBracket = Yap_LookupAtom("["); TermBeginSquareBracket = MkAtomTerm(AtomBeginSquareBracket); + AtomEndSquareBracket = Yap_LookupAtom("]"); TermEndSquareBracket = MkAtomTerm(AtomEndSquareBracket); + AtomBeginCurlyBracket = Yap_LookupAtom("{"); TermBeginCurlyBracket = MkAtomTerm(AtomBeginCurlyBracket); + AtomEndCurlyBracket = Yap_LookupAtom("}"); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket); + AtomEmptyBrackets = Yap_LookupAtom("()"); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); + AtomEmptySquareBrackets = Yap_LookupAtom("[]"); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); + AtomAsserta = Yap_LookupAtom("asserta"); TermAsserta = MkAtomTerm(AtomAsserta); + AtomAssertaStatic = Yap_LookupAtom("asserta_static"); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); + AtomAssertz = Yap_LookupAtom("assertz"); TermAssertz = MkAtomTerm(AtomAssertz); + AtomAssertzStatic = Yap_LookupAtom("assertz_static"); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); + AtomAt = Yap_LookupAtom("at"); TermAt = MkAtomTerm(AtomAt); + AtomAtom = Yap_LookupAtom("atom"); TermAtom = MkAtomTerm(AtomAtom); + AtomAtomic = Yap_LookupAtom("atomic"); TermAtomic = MkAtomTerm(AtomAtomic); + AtomAtt = Yap_FullLookupAtom("$att"); TermAtt = MkAtomTerm(AtomAtt); + AtomAtt1 = Yap_LookupAtom("att"); TermAtt1 = MkAtomTerm(AtomAtt1); + AtomAttDo = Yap_FullLookupAtom("$att_do"); TermAttDo = MkAtomTerm(AtomAttDo); + AtomAttributes = Yap_LookupAtom("attributes"); TermAttributes = MkAtomTerm(AtomAttributes); + AtomB = Yap_FullLookupAtom("$last_choice_pt"); TermB = MkAtomTerm(AtomB); + AtomBatched = Yap_LookupAtom("batched"); TermBatched = MkAtomTerm(AtomBatched); + AtomBetween = Yap_LookupAtom("between"); TermBetween = MkAtomTerm(AtomBetween); + AtomBinary = Yap_LookupAtom("binary"); TermBinary = MkAtomTerm(AtomBinary); + AtomBigNum = Yap_LookupAtom("big_num"); TermBigNum = MkAtomTerm(AtomBigNum); + AtomBinaryStream = Yap_LookupAtom("binary_stream"); TermBinaryStream = MkAtomTerm(AtomBinaryStream); + AtomBoolean = Yap_LookupAtom("boolean"); TermBoolean = MkAtomTerm(AtomBoolean); + AtomBraces = Yap_LookupAtom("{}"); TermBraces = MkAtomTerm(AtomBraces); + AtomBreak = Yap_FullLookupAtom("$break"); TermBreak = MkAtomTerm(AtomBreak); + AtomByte = Yap_LookupAtom("byte"); TermByte = MkAtomTerm(AtomByte); + AtomCArith = Yap_FullLookupAtom("$c_arith"); TermCArith = MkAtomTerm(AtomCArith); + AtomCall = Yap_LookupAtom("call"); TermCall = MkAtomTerm(AtomCall); + AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); + AtomCallCounter = Yap_LookupAtom("call_counter"); TermCallCounter = MkAtomTerm(AtomCallCounter); + AtomCallable = Yap_LookupAtom("callable"); TermCallable = MkAtomTerm(AtomCallable); + AtomCatch = Yap_FullLookupAtom("$catch"); TermCatch = MkAtomTerm(AtomCatch); + AtomChangeModule = Yap_FullLookupAtom("$change_module"); TermChangeModule = MkAtomTerm(AtomChangeModule); + AtomChar = Yap_LookupAtom("char"); TermChar = MkAtomTerm(AtomChar); + AtomCharsio = Yap_LookupAtom("charsio"); TermCharsio = MkAtomTerm(AtomCharsio); + AtomCharacter = Yap_LookupAtom("character"); TermCharacter = MkAtomTerm(AtomCharacter); + AtomCharacterCode = Yap_LookupAtom("character_code"); TermCharacterCode = MkAtomTerm(AtomCharacterCode); + AtomChars = Yap_LookupAtom("chars"); TermChars = MkAtomTerm(AtomChars); + AtomCharset = Yap_LookupAtom("charset"); TermCharset = MkAtomTerm(AtomCharset); + AtomChType = Yap_FullLookupAtom("$char_type"); TermChType = MkAtomTerm(AtomChType); + AtomCleanCall = Yap_FullLookupAtom("$clean_call"); TermCleanCall = MkAtomTerm(AtomCleanCall); + AtomClose = Yap_LookupAtom("close"); TermClose = MkAtomTerm(AtomClose); + AtomColon = Yap_LookupAtom(":"); TermColon = MkAtomTerm(AtomColon); + AtomCodeSpace = Yap_LookupAtom("code_space"); TermCodeSpace = MkAtomTerm(AtomCodeSpace); + AtomCodes = Yap_LookupAtom("codes"); TermCodes = MkAtomTerm(AtomCodes); + AtomCoInductive = Yap_LookupAtom("coinductive"); TermCoInductive = MkAtomTerm(AtomCoInductive); + AtomComma = Yap_LookupAtom(","); TermComma = MkAtomTerm(AtomComma); + AtomCommentHook = Yap_LookupAtom("comment_hook"); TermCommentHook = MkAtomTerm(AtomCommentHook); + AtomCompact = Yap_LookupAtom("compact"); TermCompact = MkAtomTerm(AtomCompact); + AtomCompound = Yap_LookupAtom("compound"); TermCompound = MkAtomTerm(AtomCompound); + AtomConsistencyError = Yap_LookupAtom("consistency_error"); TermConsistencyError = MkAtomTerm(AtomConsistencyError); + AtomConsult = Yap_LookupAtom("consult"); TermConsult = MkAtomTerm(AtomConsult); + AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); + AtomContext = Yap_LookupAtom("context"); TermContext = MkAtomTerm(AtomContext); + AtomCputime = Yap_LookupAtom("cputime"); TermCputime = MkAtomTerm(AtomCputime); + AtomCreate = Yap_LookupAtom("create"); TermCreate = MkAtomTerm(AtomCreate); + AtomCreep = Yap_FullLookupAtom("$creep"); TermCreep = MkAtomTerm(AtomCreep); + AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); + AtomCurly = Yap_LookupAtom("{}"); TermCurly = MkAtomTerm(AtomCurly); + AtomCsult = Yap_FullLookupAtom("$csult"); TermCsult = MkAtomTerm(AtomCsult); + AtomCurrentModule = Yap_FullLookupAtom("$current_module"); TermCurrentModule = MkAtomTerm(AtomCurrentModule); + AtomCut = Yap_LookupAtom("!"); TermCut = MkAtomTerm(AtomCut); + AtomCutBy = Yap_FullLookupAtom("$cut_by"); TermCutBy = MkAtomTerm(AtomCutBy); + AtomDAbort = Yap_LookupAtom("abort"); TermDAbort = MkAtomTerm(AtomDAbort); + AtomDBLoad = Yap_FullLookupAtom("$db_load"); TermDBLoad = MkAtomTerm(AtomDBLoad); + AtomDBREF = Yap_LookupAtom("DBRef"); TermDBREF = MkAtomTerm(AtomDBREF); + AtomDBReference = Yap_LookupAtom("db_reference"); TermDBReference = MkAtomTerm(AtomDBReference); + AtomDBTerm = Yap_LookupAtom("db_term"); TermDBTerm = MkAtomTerm(AtomDBTerm); + AtomDBref = Yap_FullLookupAtom("$dbref"); TermDBref = MkAtomTerm(AtomDBref); + AtomDInteger = Yap_FullLookupAtom("$integer"); TermDInteger = MkAtomTerm(AtomDInteger); + AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); TermDebugMeta = MkAtomTerm(AtomDebugMeta); + AtomDebuggerInput = Yap_LookupAtom("debugger_input"); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); + AtomDec10 = Yap_LookupAtom("dec10"); TermDec10 = MkAtomTerm(AtomDec10); + AtomDefault = Yap_LookupAtom("default"); TermDefault = MkAtomTerm(AtomDefault); + AtomDevNull = Yap_LookupAtom("/dev/null"); TermDevNull = MkAtomTerm(AtomDevNull); + AtomDiff = Yap_LookupAtom("\\="); TermDiff = MkAtomTerm(AtomDiff); + AtomDirectory = Yap_LookupAtom("disrectorys"); TermDirectory = MkAtomTerm(AtomDirectory); + AtomDiscontiguous = Yap_LookupAtom("discontiguous"); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); + AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); + AtomDollar = Yap_FullLookupAtom("$"); TermDollar = MkAtomTerm(AtomDollar); + AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); + AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); + AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); + AtomDollarU = Yap_FullLookupAtom("$u"); TermDollarU = MkAtomTerm(AtomDollarU); + AtomDollarUndef = Yap_FullLookupAtom("$undef"); TermDollarUndef = MkAtomTerm(AtomDollarUndef); + AtomDomainError = Yap_LookupAtom("domain_error"); TermDomainError = MkAtomTerm(AtomDomainError); + AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); + AtomDots = Yap_LookupAtom("dots"); TermDots = MkAtomTerm(AtomDots); + AtomDOUBLE = Yap_FullLookupAtom("Double"); TermDOUBLE = MkAtomTerm(AtomDOUBLE); + AtomDoubleSlash = Yap_FullLookupAtom("//"); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); + AtomE = Yap_LookupAtom("e"); TermE = MkAtomTerm(AtomE); + AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); + AtomEQ = Yap_LookupAtom("="); TermEQ = MkAtomTerm(AtomEQ); + AtomEmptyAtom = Yap_LookupAtom(""); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); + AtomEncoding = Yap_LookupAtom("encoding"); TermEncoding = MkAtomTerm(AtomEncoding); + AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); TermEndOfStream = MkAtomTerm(AtomEndOfStream); + AtomEof = Yap_LookupAtom("end_of_file"); TermEof = MkAtomTerm(AtomEof); + AtomEOfCode = Yap_LookupAtom("eof_code"); TermEOfCode = MkAtomTerm(AtomEOfCode); + AtomEq = Yap_LookupAtom("="); TermEq = MkAtomTerm(AtomEq); + AtomError = Yap_LookupAtom("error"); TermError = MkAtomTerm(AtomError); + AtomException = Yap_LookupAtom("exception"); TermException = MkAtomTerm(AtomException); + AtomExtensions = Yap_LookupAtom("extensions"); TermExtensions = MkAtomTerm(AtomExtensions); + AtomEvaluable = Yap_LookupAtom("evaluable"); TermEvaluable = MkAtomTerm(AtomEvaluable); + AtomEvaluationError = Yap_LookupAtom("evaluation_error"); TermEvaluationError = MkAtomTerm(AtomEvaluationError); + AtomExecutable = Yap_LookupAtom("executable"); TermExecutable = MkAtomTerm(AtomExecutable); + AtomExecute = Yap_LookupAtom("execute"); TermExecute = MkAtomTerm(AtomExecute); + AtomExecAnswers = Yap_LookupAtom("exec_answers"); TermExecAnswers = MkAtomTerm(AtomExecAnswers); + AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); + AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); + AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); + AtomExist = Yap_LookupAtom("exist"); TermExist = MkAtomTerm(AtomExist); + AtomExists = Yap_LookupAtom("exists"); TermExists = MkAtomTerm(AtomExists); + AtomExit = Yap_LookupAtom("exit"); TermExit = MkAtomTerm(AtomExit); + AtomExistenceError = Yap_LookupAtom("existence_error"); TermExistenceError = MkAtomTerm(AtomExistenceError); + AtomExoClause = Yap_FullLookupAtom("$exo_clause"); TermExoClause = MkAtomTerm(AtomExoClause); + AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); + AtomExpand = Yap_LookupAtom("expand"); TermExpand = MkAtomTerm(AtomExpand); + AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); + AtomExtendsions = Yap_LookupAtom("extensionh"); TermExtendsions = MkAtomTerm(AtomExtendsions); + AtomFB = Yap_LookupAtom("fb"); TermFB = MkAtomTerm(AtomFB); + AtomFail = Yap_LookupAtom("fail"); TermFail = MkAtomTerm(AtomFail); + AtomFalse = Yap_LookupAtom("false"); TermFalse = MkAtomTerm(AtomFalse); + AtomFast = Yap_FullLookupAtom("$fast"); TermFast = MkAtomTerm(AtomFast); + AtomFastFail = Yap_LookupAtom("fast_fail"); TermFastFail = MkAtomTerm(AtomFastFail); + AtomFileErrors = Yap_LookupAtom("file_errors"); TermFileErrors = MkAtomTerm(AtomFileErrors); + AtomFileerrors = Yap_LookupAtom("fileerrors"); TermFileerrors = MkAtomTerm(AtomFileerrors); + AtomFileType = Yap_LookupAtom("file_type"); TermFileType = MkAtomTerm(AtomFileType); + AtomFirst = Yap_LookupAtom("first"); TermFirst = MkAtomTerm(AtomFirst); + AtomFloat = Yap_LookupAtom("float"); TermFloat = MkAtomTerm(AtomFloat); + AtomFloatFormat = Yap_LookupAtom("\%.15g"); TermFloatFormat = MkAtomTerm(AtomFloatFormat); + AtomFloatOverflow = Yap_LookupAtom("float_overflow"); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); + AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); + AtomFormat = Yap_LookupAtom("format"); TermFormat = MkAtomTerm(AtomFormat); + AtomFormatAt = Yap_FullLookupAtom("$format@"); TermFormatAt = MkAtomTerm(AtomFormatAt); + AtomFull = Yap_LookupAtom("full"); TermFull = MkAtomTerm(AtomFull); + AtomFunctor = Yap_LookupAtom("functor"); TermFunctor = MkAtomTerm(AtomFunctor); + AtomGT = Yap_LookupAtom(">"); TermGT = MkAtomTerm(AtomGT); + AtomGVar = Yap_LookupAtom("var"); TermGVar = MkAtomTerm(AtomGVar); + AtomGc = Yap_FullLookupAtom("$gc"); TermGc = MkAtomTerm(AtomGc); + AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); TermGcMargin = MkAtomTerm(AtomGcMargin); + AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); TermGcTrace = MkAtomTerm(AtomGcTrace); + AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); TermGcVerbose = MkAtomTerm(AtomGcVerbose); + AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); + AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); + AtomGetwork = Yap_FullLookupAtom("$getwork"); TermGetwork = MkAtomTerm(AtomGetwork); + AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); + AtomGlob = Yap_LookupAtom("glob"); TermGlob = MkAtomTerm(AtomGlob); + AtomGlobal = Yap_LookupAtom("global"); TermGlobal = MkAtomTerm(AtomGlobal); + AtomGlobalSp = Yap_LookupAtom("global_sp"); TermGlobalSp = MkAtomTerm(AtomGlobalSp); + AtomGlobalTrie = Yap_LookupAtom("global_trie"); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); + AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); + AtomHat = Yap_LookupAtom("^"); TermHat = MkAtomTerm(AtomHat); + AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); TermHERE = MkAtomTerm(AtomHERE); + AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); TermHandleThrow = MkAtomTerm(AtomHandleThrow); + AtomHeap = Yap_LookupAtom("heap"); TermHeap = MkAtomTerm(AtomHeap); + AtomHeapUsed = Yap_LookupAtom("heapused"); TermHeapUsed = MkAtomTerm(AtomHeapUsed); + AtomHugeInt = Yap_LookupAtom("huge_int"); TermHugeInt = MkAtomTerm(AtomHugeInt); + AtomIDB = Yap_LookupAtom("idb"); TermIDB = MkAtomTerm(AtomIDB); + AtomIOMode = Yap_LookupAtom("io_mode"); TermIOMode = MkAtomTerm(AtomIOMode); + AtomI = Yap_LookupAtom("i"); TermI = MkAtomTerm(AtomI); + AtomId = Yap_LookupAtom("id"); TermId = MkAtomTerm(AtomId); + AtomIgnore = Yap_LookupAtom("ignore"); TermIgnore = MkAtomTerm(AtomIgnore); + AtomInf = Yap_LookupAtom("inf"); TermInf = MkAtomTerm(AtomInf); + AtomInfinity = Yap_LookupAtom("infinity"); TermInfinity = MkAtomTerm(AtomInfinity); + AtomInfo = Yap_LookupAtom("info"); TermInfo = MkAtomTerm(AtomInfo); + AtomInitGoal = Yap_FullLookupAtom("$init_goal"); TermInitGoal = MkAtomTerm(AtomInitGoal); + AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); TermInitProlog = MkAtomTerm(AtomInitProlog); + AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); + AtomInput = Yap_LookupAtom("input"); TermInput = MkAtomTerm(AtomInput); + AtomInstantiationError = Yap_LookupAtom("instantiation_error"); TermInstantiationError = MkAtomTerm(AtomInstantiationError); + AtomInt = Yap_LookupAtom("int"); TermInt = MkAtomTerm(AtomInt); + AtomIntOverflow = Yap_LookupAtom("int_overflow"); TermIntOverflow = MkAtomTerm(AtomIntOverflow); + AtomInteger = Yap_LookupAtom("integer"); TermInteger = MkAtomTerm(AtomInteger); + AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); + AtomIs = Yap_LookupAtom("is"); TermIs = MkAtomTerm(AtomIs); + AtomJ = Yap_LookupAtom("j"); TermJ = MkAtomTerm(AtomJ); + Atoml = Yap_LookupAtom("l"); Terml = MkAtomTerm(Atoml); + AtomKey = Yap_LookupAtom("key"); TermKey = MkAtomTerm(AtomKey); + AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); + AtomLONGINT = Yap_LookupAtom("LongInt"); TermLONGINT = MkAtomTerm(AtomLONGINT); + AtomLOOP = Yap_LookupAtom("_LOOP_"); TermLOOP = MkAtomTerm(AtomLOOP); + AtomLoopStream = Yap_LookupAtom("loop_stream"); TermLoopStream = MkAtomTerm(AtomLoopStream); + AtomLT = Yap_LookupAtom("<"); TermLT = MkAtomTerm(AtomLT); + AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); + AtomLeash = Yap_FullLookupAtom("$leash"); TermLeash = MkAtomTerm(AtomLeash); + AtomLeast = Yap_LookupAtom("least"); TermLeast = MkAtomTerm(AtomLeast); + AtomLength = Yap_FullLookupAtom("length"); TermLength = MkAtomTerm(AtomLength); + AtomList = Yap_LookupAtom("list"); TermList = MkAtomTerm(AtomList); + AtomLine = Yap_LookupAtom("line"); TermLine = MkAtomTerm(AtomLine); + AtomLive = Yap_FullLookupAtom("$live"); TermLive = MkAtomTerm(AtomLive); + AtomLoadAnswers = Yap_LookupAtom("load_answers"); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); + AtomLocal = Yap_LookupAtom("local"); TermLocal = MkAtomTerm(AtomLocal); + AtomLocalSp = Yap_LookupAtom("local_sp"); TermLocalSp = MkAtomTerm(AtomLocalSp); + AtomLocalTrie = Yap_LookupAtom("local_trie"); TermLocalTrie = MkAtomTerm(AtomLocalTrie); + AtomMax = Yap_LookupAtom("max"); TermMax = MkAtomTerm(AtomMax); + AtomMaximum = Yap_LookupAtom("maximum"); TermMaximum = MkAtomTerm(AtomMaximum); + AtomMaxArity = Yap_LookupAtom("max_arity"); TermMaxArity = MkAtomTerm(AtomMaxArity); + AtomMaxFiles = Yap_LookupAtom("max_files"); TermMaxFiles = MkAtomTerm(AtomMaxFiles); + AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); TermMegaClause = MkAtomTerm(AtomMegaClause); + AtomMetaCall = Yap_FullLookupAtom("$call"); TermMetaCall = MkAtomTerm(AtomMetaCall); + AtomMfClause = Yap_FullLookupAtom("$mf_clause"); TermMfClause = MkAtomTerm(AtomMfClause); + AtomMin = Yap_LookupAtom("min"); TermMin = MkAtomTerm(AtomMin); + AtomMinimum = Yap_LookupAtom("minimum"); TermMinimum = MkAtomTerm(AtomMinimum); + AtomMinus = Yap_LookupAtom("-"); TermMinus = MkAtomTerm(AtomMinus); + AtomModify = Yap_LookupAtom("modify"); TermModify = MkAtomTerm(AtomModify); + AtomModule = Yap_LookupAtom("module"); TermModule = MkAtomTerm(AtomModule); + AtomMost = Yap_LookupAtom("most"); TermMost = MkAtomTerm(AtomMost); + AtomMulti = Yap_LookupAtom("multi"); TermMulti = MkAtomTerm(AtomMulti); + AtomMultiFile = Yap_FullLookupAtom("$mf"); TermMultiFile = MkAtomTerm(AtomMultiFile); + AtomMultiple = Yap_FullLookupAtom("multiple"); TermMultiple = MkAtomTerm(AtomMultiple); + AtomMutable = Yap_LookupAtom("mutable"); TermMutable = MkAtomTerm(AtomMutable); + AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); TermMutableVariable = MkAtomTerm(AtomMutableVariable); + AtomMutex = Yap_LookupAtom("mutex"); TermMutex = MkAtomTerm(AtomMutex); + AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); TermMyddasDB = MkAtomTerm(AtomMyddasDB); + AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); + AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); TermMyddasHost = MkAtomTerm(AtomMyddasHost); + AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); TermMyddasPass = MkAtomTerm(AtomMyddasPass); + AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); TermMyddasUser = MkAtomTerm(AtomMyddasUser); + AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); + AtomNan = Yap_LookupAtom("nan"); TermNan = MkAtomTerm(AtomNan); + AtomNb = Yap_LookupAtom("nb"); TermNb = MkAtomTerm(AtomNb); + AtomNbTerm = Yap_LookupAtom("nb_term"); TermNbTerm = MkAtomTerm(AtomNbTerm); + AtomNew = Yap_LookupAtom("new"); TermNew = MkAtomTerm(AtomNew); + AtomNewLine = Yap_LookupAtom("nl"); TermNewLine = MkAtomTerm(AtomNewLine); + AtomNl = Yap_LookupAtom("nl"); TermNl = MkAtomTerm(AtomNl); + AtomNoEffect = Yap_LookupAtom("no_effect"); TermNoEffect = MkAtomTerm(AtomNoEffect); + AtomNoMemory = Yap_LookupAtom("no_memory"); TermNoMemory = MkAtomTerm(AtomNoMemory); + AtomNone = Yap_LookupAtom("none"); TermNone = MkAtomTerm(AtomNone); + AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); + AtomNot = Yap_LookupAtom("\\+"); TermNot = MkAtomTerm(AtomNot); + AtomNotImplemented = Yap_LookupAtom("not_implemented"); TermNotImplemented = MkAtomTerm(AtomNotImplemented); + AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); + AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline); + AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero); + AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber); + AtomObj = Yap_LookupAtom("o__bj__"); TermObj = MkAtomTerm(AtomObj); + AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff); + AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline); + AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn); + AtomOnline = Yap_LookupAtom("online"); TermOnline = MkAtomTerm(AtomOnline); + AtomOpen = Yap_LookupAtom("open"); TermOpen = MkAtomTerm(AtomOpen); + AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); + AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); + AtomOperator = Yap_LookupAtom("operator"); TermOperator = MkAtomTerm(AtomOperator); + AtomOperatorPriority = Yap_LookupAtom("operator_priority"); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); + AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); + AtomOpt = Yap_LookupAtom("opt"); TermOpt = MkAtomTerm(AtomOpt); + AtomOtherwise = Yap_LookupAtom("otherwise"); TermOtherwise = MkAtomTerm(AtomOtherwise); + AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); + AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); + AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); + AtomOutOfRange = Yap_LookupAtom("out_of_range"); TermOutOfRange = MkAtomTerm(AtomOutOfRange); + AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); + AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); + AtomOutput = Yap_LookupAtom("output"); TermOutput = MkAtomTerm(AtomOutput); + AtomParameter = Yap_LookupAtom("parameter"); TermParameter = MkAtomTerm(AtomParameter); + AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); + AtomPast = Yap_LookupAtom("past"); TermPast = MkAtomTerm(AtomPast); + AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); + AtomPermissionError = Yap_LookupAtom("permission_error"); TermPermissionError = MkAtomTerm(AtomPermissionError); + AtomPi = Yap_LookupAtom("pi"); TermPi = MkAtomTerm(AtomPi); + AtomPipe = Yap_LookupAtom("pipe"); TermPipe = MkAtomTerm(AtomPipe); + AtomPriority = Yap_LookupAtom("priority"); TermPriority = MkAtomTerm(AtomPriority); + AtomPlus = Yap_LookupAtom("+"); TermPlus = MkAtomTerm(AtomPlus); + AtomPointer = Yap_LookupAtom("pointer"); TermPointer = MkAtomTerm(AtomPointer); + AtomPortray = Yap_FullLookupAtom("portray"); TermPortray = MkAtomTerm(AtomPortray); + AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); + AtomPrimitive = Yap_LookupAtom("primitive"); TermPrimitive = MkAtomTerm(AtomPrimitive); + AtomPrintMessage = Yap_LookupAtom("print_message"); TermPrintMessage = MkAtomTerm(AtomPrintMessage); + AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); + AtomProcedure = Yap_LookupAtom("procedure"); TermProcedure = MkAtomTerm(AtomProcedure); + AtomProfile = Yap_FullLookupAtom("$profile"); TermProfile = MkAtomTerm(AtomProfile); + AtomProlog = Yap_LookupAtom("prolog"); TermProlog = MkAtomTerm(AtomProlog); + AtomProtectStack = Yap_FullLookupAtom("$protect_stack"); TermProtectStack = MkAtomTerm(AtomProtectStack); + AtomQly = Yap_LookupAtom("qly"); TermQly = MkAtomTerm(AtomQly); + AtomQuery = Yap_LookupAtom("?-"); TermQuery = MkAtomTerm(AtomQuery); + AtomQueue = Yap_LookupAtom("queue"); TermQueue = MkAtomTerm(AtomQueue); + AtomQuiet = Yap_LookupAtom("quiet"); TermQuiet = MkAtomTerm(AtomQuiet); + AtomRadix = Yap_LookupAtom("radix"); TermRadix = MkAtomTerm(AtomRadix); + AtomRandom = Yap_LookupAtom("random"); TermRandom = MkAtomTerm(AtomRandom); + AtomRange = Yap_LookupAtom("range"); TermRange = MkAtomTerm(AtomRange); + AtomRDiv = Yap_LookupAtom("rdiv"); TermRDiv = MkAtomTerm(AtomRDiv); + AtomRead = Yap_LookupAtom("read"); TermRead = MkAtomTerm(AtomRead); + AtomReadOnly = Yap_LookupAtom("read_only"); TermReadOnly = MkAtomTerm(AtomReadOnly); + AtomReadWrite = Yap_LookupAtom("read_write"); TermReadWrite = MkAtomTerm(AtomReadWrite); + AtomReadutil = Yap_LookupAtom("readutil"); TermReadutil = MkAtomTerm(AtomReadutil); + AtomReconsult = Yap_LookupAtom("reconsult"); TermReconsult = MkAtomTerm(AtomReconsult); + AtomRecordedP = Yap_FullLookupAtom("$recordep"); TermRecordedP = MkAtomTerm(AtomRecordedP); + AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); + AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); + AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); + AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); TermRefoundVar = MkAtomTerm(AtomRefoundVar); + AtomRelativeTo = Yap_FullLookupAtom("relative_to"); TermRelativeTo = MkAtomTerm(AtomRelativeTo); + AtomRepeat = Yap_LookupAtom("repeat"); TermRepeat = MkAtomTerm(AtomRepeat); + AtomRepeatSpace = Yap_LookupAtom("repeat "); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); + AtomReposition = Yap_LookupAtom("reposition"); TermReposition = MkAtomTerm(AtomReposition); + AtomRepresentationError = Yap_LookupAtom("representation_error"); TermRepresentationError = MkAtomTerm(AtomRepresentationError); + AtomReset = Yap_LookupAtom("reset"); TermReset = MkAtomTerm(AtomReset); + AtomResize = Yap_LookupAtom("resize"); TermResize = MkAtomTerm(AtomResize); + AtomResourceError = Yap_LookupAtom("resource_error"); TermResourceError = MkAtomTerm(AtomResourceError); + AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); + AtomRetry = Yap_LookupAtom("retry"); TermRetry = MkAtomTerm(AtomRetry); + AtomRetryCounter = Yap_LookupAtom("retry_counter"); TermRetryCounter = MkAtomTerm(AtomRetryCounter); + AtomRTree = Yap_LookupAtom("rtree"); TermRTree = MkAtomTerm(AtomRTree); + AtomSafe = Yap_FullLookupAtom("$safe"); TermSafe = MkAtomTerm(AtomSafe); + AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); + AtomSame = Yap_LookupAtom("=="); TermSame = MkAtomTerm(AtomSame); + AtomSemic = Yap_LookupAtom(";"); TermSemic = MkAtomTerm(AtomSemic); + AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); + AtomSigAlarm = Yap_LookupAtom("sig_alarm"); TermSigAlarm = MkAtomTerm(AtomSigAlarm); + AtomSigBreak = Yap_LookupAtom("sig_break"); TermSigBreak = MkAtomTerm(AtomSigBreak); + AtomSigCreep = Yap_LookupAtom("sig_creep"); TermSigCreep = MkAtomTerm(AtomSigCreep); + AtomSigDebug = Yap_LookupAtom("sig_debug"); TermSigDebug = MkAtomTerm(AtomSigDebug); + AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); + AtomSigFPE = Yap_LookupAtom("sig_fpe"); TermSigFPE = MkAtomTerm(AtomSigFPE); + AtomSigHup = Yap_LookupAtom("sig_hup"); TermSigHup = MkAtomTerm(AtomSigHup); + AtomSigInt = Yap_LookupAtom("sig_int"); TermSigInt = MkAtomTerm(AtomSigInt); + AtomSigIti = Yap_LookupAtom("sig_iti"); TermSigIti = MkAtomTerm(AtomSigIti); + AtomSigPending = Yap_FullLookupAtom("$sig_pending"); TermSigPending = MkAtomTerm(AtomSigPending); + AtomSigPipe = Yap_LookupAtom("sig_pipe"); TermSigPipe = MkAtomTerm(AtomSigPipe); + AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); TermSigStackDump = MkAtomTerm(AtomSigStackDump); + AtomSigStatistics = Yap_LookupAtom("sig_statistics"); TermSigStatistics = MkAtomTerm(AtomSigStatistics); + AtomSigTrace = Yap_LookupAtom("sig_trace"); TermSigTrace = MkAtomTerm(AtomSigTrace); + AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); + AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); + AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); + AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); + AtomSilent = Yap_LookupAtom("Silent"); TermSilent = MkAtomTerm(AtomSilent); + AtomSingle = Yap_LookupAtom("single"); TermSingle = MkAtomTerm(AtomSingle); + AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); + AtomSingleton = Yap_LookupAtom("singleton"); TermSingleton = MkAtomTerm(AtomSingleton); + AtomSlash = Yap_LookupAtom("/"); TermSlash = MkAtomTerm(AtomSlash); + AtomSocket = Yap_LookupAtom("socket"); TermSocket = MkAtomTerm(AtomSocket); + AtomSolutions = Yap_LookupAtom("solutions"); TermSolutions = MkAtomTerm(AtomSolutions); + AtomSource = Yap_LookupAtom("source"); TermSource = MkAtomTerm(AtomSource); + AtomSourceSink = Yap_LookupAtom("source_sink"); TermSourceSink = MkAtomTerm(AtomSourceSink); + AtomSpy = Yap_FullLookupAtom("$spy"); TermSpy = MkAtomTerm(AtomSpy); + AtomStack = Yap_LookupAtom("stack"); TermStack = MkAtomTerm(AtomStack); + AtomStackFree = Yap_LookupAtom("stackfree"); TermStackFree = MkAtomTerm(AtomStackFree); + AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); + AtomStaticClause = Yap_FullLookupAtom("$static_clause"); TermStaticClause = MkAtomTerm(AtomStaticClause); + AtomStaticProcedure = Yap_LookupAtom("static_procedure"); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); + AtomStream = Yap_FullLookupAtom("$stream"); TermStream = MkAtomTerm(AtomStream); + AtomSWIStream = Yap_FullLookupAtom(""); TermSWIStream = MkAtomTerm(AtomSWIStream); + AtomVStream = Yap_LookupAtom("stream"); TermVStream = MkAtomTerm(AtomVStream); + AtomStreams = Yap_LookupAtom("streams"); TermStreams = MkAtomTerm(AtomStreams); + AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); + AtomStreamPos = Yap_FullLookupAtom("$stream_position"); TermStreamPos = MkAtomTerm(AtomStreamPos); + AtomStreamPosition = Yap_LookupAtom("stream_position"); TermStreamPosition = MkAtomTerm(AtomStreamPosition); + AtomString = Yap_LookupAtom("string"); TermString = MkAtomTerm(AtomString); + AtomStyleCheck = Yap_LookupAtom("style_check"); TermStyleCheck = MkAtomTerm(AtomStyleCheck); + AtomSTRING = Yap_FullLookupAtom("String"); TermSTRING = MkAtomTerm(AtomSTRING); + AtomSwi = Yap_LookupAtom("swi"); TermSwi = MkAtomTerm(AtomSwi); + AtomSymbolChar = Yap_LookupAtom("symbol_char"); TermSymbolChar = MkAtomTerm(AtomSymbolChar); + AtomSyntaxError = Yap_LookupAtom("syntax_error"); TermSyntaxError = MkAtomTerm(AtomSyntaxError); + AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); + AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); + AtomSystem = Yap_LookupAtom("system"); TermSystem = MkAtomTerm(AtomSystem); + AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); TermSystemError = MkAtomTerm(AtomSystemError); + AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); + AtomT = Yap_LookupAtom("t"); TermT = MkAtomTerm(AtomT); + AtomTerm = Yap_LookupAtom("term"); TermTerm = MkAtomTerm(AtomTerm); + AtomTermExpansion = Yap_LookupAtom("term_expansion"); TermTermExpansion = MkAtomTerm(AtomTermExpansion); + AtomTerms = Yap_LookupAtom("terms"); TermTerms = MkAtomTerm(AtomTerms); + AtomText = Yap_LookupAtom("text"); TermText = MkAtomTerm(AtomText); + AtomTextStream = Yap_LookupAtom("text_stream"); TermTextStream = MkAtomTerm(AtomTextStream); + AtomThread = Yap_LookupAtom("thread"); TermThread = MkAtomTerm(AtomThread); + AtomThreads = Yap_LookupAtom("threads"); TermThreads = MkAtomTerm(AtomThreads); + AtomThrow = Yap_LookupAtom("throw"); TermThrow = MkAtomTerm(AtomThrow); + AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); + AtomTimeoutError = Yap_LookupAtom("timeout_error"); TermTimeoutError = MkAtomTerm(AtomTimeoutError); + AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); + AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); + AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); + AtomTrail = Yap_LookupAtom("trail"); + AtomTrue = Yap_LookupAtom("true"); TermTrue = MkAtomTerm(AtomTrue); + AtomTty = Yap_LookupAtom("tty"); TermTty = MkAtomTerm(AtomTty); + AtomTtys = Yap_LookupAtom("ttys"); TermTtys = MkAtomTerm(AtomTtys); + AtomTuple = Yap_LookupAtom("tuple"); TermTuple = MkAtomTerm(AtomTuple); + AtomTxt = Yap_LookupAtom("txt"); TermTxt = MkAtomTerm(AtomTxt); + AtomTypeError = Yap_LookupAtom("type_error"); TermTypeError = MkAtomTerm(AtomTypeError); + AtomUndefined = Yap_LookupAtom("undefined"); TermUndefined = MkAtomTerm(AtomUndefined); + AtomUndefp = Yap_FullLookupAtom("$undefp"); TermUndefp = MkAtomTerm(AtomUndefp); + AtomUndefp0 = Yap_FullLookupAtom("$undefp0"); TermUndefp0 = MkAtomTerm(AtomUndefp0); + AtomUnderflow = Yap_LookupAtom("underflow"); TermUnderflow = MkAtomTerm(AtomUnderflow); + AtomUnificationStack = Yap_LookupAtom("unification_stack"); TermUnificationStack = MkAtomTerm(AtomUnificationStack); + AtomUnique = Yap_LookupAtom("unique"); TermUnique = MkAtomTerm(AtomUnique); + AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); + AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); + AtomUser = Yap_LookupAtom("user"); TermUser = MkAtomTerm(AtomUser); + AtomUserErr = Yap_LookupAtom("user_error"); TermUserErr = MkAtomTerm(AtomUserErr); + AtomUserIn = Yap_LookupAtom("user_input"); TermUserIn = MkAtomTerm(AtomUserIn); + AtomUserOut = Yap_LookupAtom("user_output"); TermUserOut = MkAtomTerm(AtomUserOut); + AtomDollarVar = Yap_LookupAtom("$VAR"); TermDollarVar = MkAtomTerm(AtomDollarVar); + AtomVBar = Yap_LookupAtom("|"); TermVBar = MkAtomTerm(AtomVBar); + AtomVarBranches = Yap_LookupAtom("var_branches"); TermVarBranches = MkAtomTerm(AtomVarBranches); + AtomVariableNames = Yap_LookupAtom("variable_names"); TermVariableNames = MkAtomTerm(AtomVariableNames); + AtomHiddenVar = Yap_FullLookupAtom("$V"); TermHiddenVar = MkAtomTerm(AtomHiddenVar); + AtomVariable = Yap_LookupAtom("variable"); TermVariable = MkAtomTerm(AtomVariable); + AtomVerbose = Yap_LookupAtom("verbose"); TermVerbose = MkAtomTerm(AtomVerbose); + AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); + AtomVersionNumber = Yap_FullLookupAtom("$version_name"); TermVersionNumber = MkAtomTerm(AtomVersionNumber); + AtomVeryVerbose = Yap_LookupAtom("very_verbose"); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); + AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); + AtomWarning = Yap_LookupAtom("warning"); TermWarning = MkAtomTerm(AtomWarning); + AtomWhen = Yap_FullLookupAtom("$when"); TermWhen = MkAtomTerm(AtomWhen); + AtomWrite = Yap_LookupAtom("write"); TermWrite = MkAtomTerm(AtomWrite); + AtomWriteTerm = Yap_LookupAtom("write_term"); TermWriteTerm = MkAtomTerm(AtomWriteTerm); + AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml); + AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks); + AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); + FunctorAfInet = Yap_MkFunctor(AtomAfInet,2); + FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1); + FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1); + FunctorAltNot = Yap_MkFunctor(AtomAltNot,1); + FunctorArg = Yap_MkFunctor(AtomArg,3); + FunctorArrayEntry = Yap_MkFunctor(AtomArrayAccess,3); + FunctorArrow = Yap_MkFunctor(AtomArrow,2); + FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2); + FunctorAssert1 = Yap_MkFunctor(AtomAssert,1); + FunctorAssert = Yap_MkFunctor(AtomAssert,2); + FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2); + FunctorAtom = Yap_MkFunctor(AtomAtom,1); + FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3); + FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2); + FunctorBraces = Yap_MkFunctor(AtomBraces,1); + FunctorCall = Yap_MkFunctor(AtomCall,1); + FunctorCatch = Yap_MkFunctor(AtomCatch,3); + FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1); + FunctorChars = Yap_MkFunctor(AtomChars,2); + FunctorChars1 = Yap_MkFunctor(AtomChars,1); + FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2); + FunctorClist = Yap_MkFunctor(AtomWhen,4); + FunctorCodes = Yap_MkFunctor(AtomCodes,2); + FunctorCodes1 = Yap_MkFunctor(AtomCodes,1); + FunctorColon = Yap_MkFunctor(AtomColon,2); + FunctorComma = Yap_MkFunctor(AtomComma,2); + FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3); + FunctorContext2 = Yap_MkFunctor(AtomContext,2); + FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1); + FunctorCreep = Yap_MkFunctor(AtomCreep,1); + FunctorCsult = Yap_MkFunctor(AtomCsult,2); + FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1); + FunctorCutBy = Yap_MkFunctor(AtomCutBy,1); + FunctorDBREF = Yap_MkFunctor(AtomDBREF,1); + FunctorDiff = Yap_MkFunctor(AtomDiff,2); + FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6); + FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6); + FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6); + FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5); + FunctorDollar = Yap_MkFunctor(AtomDollar,1); + FunctorDollarVar = Yap_MkFunctor(AtomDollarVar,1); + FunctorDomainError = Yap_MkFunctor(AtomDomainError,2); + FunctorDot = Yap_MkFunctor(AtomDot,2); + FunctorDot10 = Yap_MkFunctor(AtomDot,10); + FunctorDot11 = Yap_MkFunctor(AtomDot,11); + FunctorDot12 = Yap_MkFunctor(AtomDot,12); + FunctorDot2 = Yap_MkFunctor(AtomDot,2); + FunctorDot3 = Yap_MkFunctor(AtomDot,3); + FunctorDot4 = Yap_MkFunctor(AtomDot,4); + FunctorDot5 = Yap_MkFunctor(AtomDot,5); + FunctorDot6 = Yap_MkFunctor(AtomDot,6); + FunctorDot7 = Yap_MkFunctor(AtomDot,7); + FunctorDot8 = Yap_MkFunctor(AtomDot,8); + FunctorDot9 = Yap_MkFunctor(AtomDot,9); + FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2); + FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2); + FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2); + FunctorEq = Yap_MkFunctor(AtomEq,2); + FunctorError = Yap_MkFunctor(AtomError,2); + FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1); + FunctorException = Yap_MkFunctor(AtomException,1); + FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2); + FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2); + FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1); + FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2); + FunctorExoClause = Yap_MkFunctor(AtomExoClause,2); + FunctorFunctor = Yap_MkFunctor(AtomFunctor,3); + FunctorGAtom = Yap_MkFunctor(AtomAtom,1); + FunctorGAtomic = Yap_MkFunctor(AtomAtomic,1); + FunctorGCompound = Yap_MkFunctor(AtomCompound,1); + FunctorGFloat = Yap_MkFunctor(AtomFloat,1); + FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2); + FunctorGInteger = Yap_MkFunctor(AtomInteger,1); + FunctorGNumber = Yap_MkFunctor(AtomNumber,1); + FunctorGPrimitive = Yap_MkFunctor(AtomPrimitive,1); + FunctorGVar = Yap_MkFunctor(AtomGVar,1); + FunctorGeneratePredInfo = Yap_MkFunctor(AtomGeneratePredInfo,4); + FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2); + FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3); + FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3); + FunctorHat = Yap_MkFunctor(AtomHat,2); + FunctorI = Yap_MkFunctor(AtomI,2); + FunctorId = Yap_MkFunctor(AtomId,1); + FunctorInfo1 = Yap_MkFunctor(AtomInfo,1); + FunctorInfo2 = Yap_MkFunctor(AtomInfo,2); + FunctorInfo3 = Yap_MkFunctor(AtomInfo,3); + FunctorInfo4 = Yap_MkFunctor(AtomInfo,4); + FunctorIs = Yap_MkFunctor(AtomIs,2); + FunctorJ = Yap_MkFunctor(AtomJ,2); + FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1); + FunctorList = Yap_MkFunctor(AtomDot,2); + FunctorLOOP = Yap_MkFunctor(AtomLOOP,1); + FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2); + FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4); + FunctorMinus = Yap_MkFunctor(AtomMinus,2); + FunctorModule = Yap_MkFunctor(AtomColon,2); + FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5); + FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL))); + FunctorMutex = Yap_MkFunctor(AtomMutex,2); + FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2); + FunctorNBQueue = Yap_MkFunctor(AtomQueue,4); + FunctorNot = Yap_MkFunctor(AtomNot,1); + FunctorObj = Yap_MkFunctor(AtomObj,1); + FunctorOr = Yap_MkFunctor(AtomSemic,2); + FunctorOutput = Yap_MkFunctor(AtomOutput,1); + FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3); + FunctorPlus = Yap_MkFunctor(AtomPlus,2); + FunctorPortray = Yap_MkFunctor(AtomPortray,1); + FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2); + FunctorProcedure = Yap_MkFunctor(AtomProcedure,5); + FunctorPriority = Yap_MkFunctor(AtomPriority,1); + FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2); + FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,4); + FunctorQuery = Yap_MkFunctor(AtomQuery,1); + FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6); + FunctorRDiv = Yap_MkFunctor(AtomRDiv,2); + FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3); + FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1); + FunctorResourceError = Yap_MkFunctor(AtomResourceError,1); + FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2); + FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1); + FunctorSafe = Yap_MkFunctor(AtomSafe,1); + FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4); + FunctorSame = Yap_MkFunctor(AtomSame,2); + FunctorSlash = Yap_MkFunctor(AtomSlash,2); + FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2); + FunctorStream = Yap_MkFunctor(AtomStream,1); + FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1); + FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4); + FunctorString1 = Yap_MkFunctor(AtomString,1); + FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4); + FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4); + FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1); + FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2); + FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2); + FunctorThrow = Yap_MkFunctor(AtomThrow,1); + FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2); + FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3); + FunctorTypeError = Yap_MkFunctor(AtomTypeError,2); + FunctorUMinus = Yap_MkFunctor(AtomMinus,1); + FunctorUPlus = Yap_MkFunctor(AtomPlus,1); + FunctorVBar = Yap_MkFunctor(AtomVBar,2); + FunctorWriteTerm = Yap_MkFunctor(AtomWriteTerm,2); + FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1); diff --git a/H/generated/ilocals.h b/H/generated/ilocals.h index 2ada8ba04..7da9a5e1c 100755 --- a/H/generated/ilocals.h +++ b/H/generated/ilocals.h @@ -139,7 +139,8 @@ static void InitWorker(int wid) { REMOTE_CMemFirstBlock(wid) = NULL; REMOTE_CMemFirstBlockSz(wid) = 0L; - REMOTE_nperm(wid) = 0L; + REMOTE_nperm(wid) = 0; + REMOTE_jMP(wid) = 0; REMOTE_LabelFirstArray(wid) = NULL; REMOTE_LabelFirstArraySz(wid) = 0L; diff --git a/H/generated/ratoms.h b/H/generated/ratoms.h index 1f485c034..1deb1e028 100644 --- a/H/generated/ratoms.h +++ b/H/generated/ratoms.h @@ -1,584 +1,584 @@ - - /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" - {lease do not update, update misc/ATOMS instead */ - - Atom3Dots = AtomAdjust(Atom3Dots); - AtomAbol = AtomAdjust(AtomAbol); TermAbol = MkAtomTerm(AtomAbol); - AtomAccess = AtomAdjust(AtomAccess); TermAccess = MkAtomTerm(AtomAccess); - AtomAfInet = AtomAdjust(AtomAfInet); TermAfInet = MkAtomTerm(AtomAfInet); - AtomAfLocal = AtomAdjust(AtomAfLocal); TermAfLocal = MkAtomTerm(AtomAfLocal); - AtomAfUnix = AtomAdjust(AtomAfUnix); TermAfUnix = MkAtomTerm(AtomAfUnix); - AtomAlarm = AtomAdjust(AtomAlarm); TermAlarm = MkAtomTerm(AtomAlarm); - AtomAlias = AtomAdjust(AtomAlias); TermAlias = MkAtomTerm(AtomAlias); - AtomAll = AtomAdjust(AtomAll); TermAll = MkAtomTerm(AtomAll); - AtomAltNot = AtomAdjust(AtomAltNot); TermAltNot = MkAtomTerm(AtomAltNot); - AtomAnswer = AtomAdjust(AtomAnswer); TermAnswer = MkAtomTerm(AtomAnswer); - AtomAny = AtomAdjust(AtomAny); TermAny = MkAtomTerm(AtomAny); - AtomAppend = AtomAdjust(AtomAppend); TermAppend = MkAtomTerm(AtomAppend); - AtomArg = AtomAdjust(AtomArg); TermArg = MkAtomTerm(AtomArg); - AtomArray = AtomAdjust(AtomArray); TermArray = MkAtomTerm(AtomArray); - AtomArrayAccess = AtomAdjust(AtomArrayAccess); TermArrayAccess = MkAtomTerm(AtomArrayAccess); - AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); - AtomArrayType = AtomAdjust(AtomArrayType); TermArrayType = MkAtomTerm(AtomArrayType); - AtomArrow = AtomAdjust(AtomArrow); TermArrow = MkAtomTerm(AtomArrow); - AtomAttributedModule = AtomAdjust(AtomAttributedModule); TermAttributedModule = MkAtomTerm(AtomAttributedModule); - AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); - AtomAssert = AtomAdjust(AtomAssert); TermAssert = MkAtomTerm(AtomAssert); - AtomBeginBracket = AtomAdjust(AtomBeginBracket); TermBeginBracket = MkAtomTerm(AtomBeginBracket); - AtomEndBracket = AtomAdjust(AtomEndBracket); TermEndBracket = MkAtomTerm(AtomEndBracket); - AtomBeginSquareBracket = AtomAdjust(AtomBeginSquareBracket); TermBeginSquareBracket = MkAtomTerm(AtomBeginSquareBracket); - AtomEndSquareBracket = AtomAdjust(AtomEndSquareBracket); TermEndSquareBracket = MkAtomTerm(AtomEndSquareBracket); - AtomBeginCurlyBracket = AtomAdjust(AtomBeginCurlyBracket); TermBeginCurlyBracket = MkAtomTerm(AtomBeginCurlyBracket); - AtomEndCurlyBracket = AtomAdjust(AtomEndCurlyBracket); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket); - AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); - AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); - AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta); - AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); - AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz); - AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); - AtomAt = AtomAdjust(AtomAt); TermAt = MkAtomTerm(AtomAt); - AtomAtom = AtomAdjust(AtomAtom); TermAtom = MkAtomTerm(AtomAtom); - AtomAtomic = AtomAdjust(AtomAtomic); TermAtomic = MkAtomTerm(AtomAtomic); - AtomAtt = AtomAdjust(AtomAtt); TermAtt = MkAtomTerm(AtomAtt); - AtomAtt1 = AtomAdjust(AtomAtt1); TermAtt1 = MkAtomTerm(AtomAtt1); - AtomAttDo = AtomAdjust(AtomAttDo); TermAttDo = MkAtomTerm(AtomAttDo); - AtomAttributes = AtomAdjust(AtomAttributes); TermAttributes = MkAtomTerm(AtomAttributes); - AtomB = AtomAdjust(AtomB); TermB = MkAtomTerm(AtomB); - AtomBatched = AtomAdjust(AtomBatched); TermBatched = MkAtomTerm(AtomBatched); - AtomBetween = AtomAdjust(AtomBetween); TermBetween = MkAtomTerm(AtomBetween); - AtomBinary = AtomAdjust(AtomBinary); TermBinary = MkAtomTerm(AtomBinary); - AtomBigNum = AtomAdjust(AtomBigNum); TermBigNum = MkAtomTerm(AtomBigNum); - AtomBinaryStream = AtomAdjust(AtomBinaryStream); TermBinaryStream = MkAtomTerm(AtomBinaryStream); - AtomBoolean = AtomAdjust(AtomBoolean); TermBoolean = MkAtomTerm(AtomBoolean); - AtomBraces = AtomAdjust(AtomBraces); TermBraces = MkAtomTerm(AtomBraces); - AtomBreak = AtomAdjust(AtomBreak); TermBreak = MkAtomTerm(AtomBreak); - AtomByte = AtomAdjust(AtomByte); TermByte = MkAtomTerm(AtomByte); - AtomCArith = AtomAdjust(AtomCArith); TermCArith = MkAtomTerm(AtomCArith); - AtomCall = AtomAdjust(AtomCall); TermCall = MkAtomTerm(AtomCall); - AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); - AtomCallCounter = AtomAdjust(AtomCallCounter); TermCallCounter = MkAtomTerm(AtomCallCounter); - AtomCallable = AtomAdjust(AtomCallable); TermCallable = MkAtomTerm(AtomCallable); - AtomCatch = AtomAdjust(AtomCatch); TermCatch = MkAtomTerm(AtomCatch); - AtomChangeModule = AtomAdjust(AtomChangeModule); TermChangeModule = MkAtomTerm(AtomChangeModule); - AtomChar = AtomAdjust(AtomChar); TermChar = MkAtomTerm(AtomChar); - AtomCharsio = AtomAdjust(AtomCharsio); TermCharsio = MkAtomTerm(AtomCharsio); - AtomCharacter = AtomAdjust(AtomCharacter); TermCharacter = MkAtomTerm(AtomCharacter); - AtomCharacterCode = AtomAdjust(AtomCharacterCode); TermCharacterCode = MkAtomTerm(AtomCharacterCode); - AtomChars = AtomAdjust(AtomChars); TermChars = MkAtomTerm(AtomChars); - AtomCharset = AtomAdjust(AtomCharset); TermCharset = MkAtomTerm(AtomCharset); - AtomChType = AtomAdjust(AtomChType); TermChType = MkAtomTerm(AtomChType); - AtomCleanCall = AtomAdjust(AtomCleanCall); TermCleanCall = MkAtomTerm(AtomCleanCall); - AtomClose = AtomAdjust(AtomClose); TermClose = MkAtomTerm(AtomClose); - AtomColon = AtomAdjust(AtomColon); TermColon = MkAtomTerm(AtomColon); - AtomCodeSpace = AtomAdjust(AtomCodeSpace); TermCodeSpace = MkAtomTerm(AtomCodeSpace); - AtomCodes = AtomAdjust(AtomCodes); TermCodes = MkAtomTerm(AtomCodes); - AtomCoInductive = AtomAdjust(AtomCoInductive); TermCoInductive = MkAtomTerm(AtomCoInductive); - AtomComma = AtomAdjust(AtomComma); TermComma = MkAtomTerm(AtomComma); - AtomCommentHook = AtomAdjust(AtomCommentHook); TermCommentHook = MkAtomTerm(AtomCommentHook); - AtomCompact = AtomAdjust(AtomCompact); TermCompact = MkAtomTerm(AtomCompact); - AtomCompound = AtomAdjust(AtomCompound); TermCompound = MkAtomTerm(AtomCompound); - AtomConsistencyError = AtomAdjust(AtomConsistencyError); TermConsistencyError = MkAtomTerm(AtomConsistencyError); - AtomConsult = AtomAdjust(AtomConsult); TermConsult = MkAtomTerm(AtomConsult); - AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); - AtomContext = AtomAdjust(AtomContext); TermContext = MkAtomTerm(AtomContext); - AtomCputime = AtomAdjust(AtomCputime); TermCputime = MkAtomTerm(AtomCputime); - AtomCreate = AtomAdjust(AtomCreate); TermCreate = MkAtomTerm(AtomCreate); - AtomCreep = AtomAdjust(AtomCreep); TermCreep = MkAtomTerm(AtomCreep); - AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); - AtomCurly = AtomAdjust(AtomCurly); TermCurly = MkAtomTerm(AtomCurly); - AtomCsult = AtomAdjust(AtomCsult); TermCsult = MkAtomTerm(AtomCsult); - AtomCurrentModule = AtomAdjust(AtomCurrentModule); TermCurrentModule = MkAtomTerm(AtomCurrentModule); - AtomCut = AtomAdjust(AtomCut); TermCut = MkAtomTerm(AtomCut); - AtomCutBy = AtomAdjust(AtomCutBy); TermCutBy = MkAtomTerm(AtomCutBy); - AtomDAbort = AtomAdjust(AtomDAbort); TermDAbort = MkAtomTerm(AtomDAbort); - AtomDBLoad = AtomAdjust(AtomDBLoad); TermDBLoad = MkAtomTerm(AtomDBLoad); - AtomDBREF = AtomAdjust(AtomDBREF); TermDBREF = MkAtomTerm(AtomDBREF); - AtomDBReference = AtomAdjust(AtomDBReference); TermDBReference = MkAtomTerm(AtomDBReference); - AtomDBTerm = AtomAdjust(AtomDBTerm); TermDBTerm = MkAtomTerm(AtomDBTerm); - AtomDBref = AtomAdjust(AtomDBref); TermDBref = MkAtomTerm(AtomDBref); - AtomDInteger = AtomAdjust(AtomDInteger); TermDInteger = MkAtomTerm(AtomDInteger); - AtomDebugMeta = AtomAdjust(AtomDebugMeta); TermDebugMeta = MkAtomTerm(AtomDebugMeta); - AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); - AtomDec10 = AtomAdjust(AtomDec10); TermDec10 = MkAtomTerm(AtomDec10); - AtomDefault = AtomAdjust(AtomDefault); TermDefault = MkAtomTerm(AtomDefault); - AtomDevNull = AtomAdjust(AtomDevNull); TermDevNull = MkAtomTerm(AtomDevNull); - AtomDiff = AtomAdjust(AtomDiff); TermDiff = MkAtomTerm(AtomDiff); - AtomDirectory = AtomAdjust(AtomDirectory); TermDirectory = MkAtomTerm(AtomDirectory); - AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); - AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); - AtomDollar = AtomAdjust(AtomDollar); TermDollar = MkAtomTerm(AtomDollar); - AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); - AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); - AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); - AtomDollarU = AtomAdjust(AtomDollarU); TermDollarU = MkAtomTerm(AtomDollarU); - AtomDollarUndef = AtomAdjust(AtomDollarUndef); TermDollarUndef = MkAtomTerm(AtomDollarUndef); - AtomDomainError = AtomAdjust(AtomDomainError); TermDomainError = MkAtomTerm(AtomDomainError); - AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); - AtomDots = AtomAdjust(AtomDots); TermDots = MkAtomTerm(AtomDots); - AtomDOUBLE = AtomAdjust(AtomDOUBLE); TermDOUBLE = MkAtomTerm(AtomDOUBLE); - AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); - AtomE = AtomAdjust(AtomE); TermE = MkAtomTerm(AtomE); - AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); - AtomEQ = AtomAdjust(AtomEQ); TermEQ = MkAtomTerm(AtomEQ); - AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); - AtomEncoding = AtomAdjust(AtomEncoding); TermEncoding = MkAtomTerm(AtomEncoding); - AtomEndOfStream = AtomAdjust(AtomEndOfStream); TermEndOfStream = MkAtomTerm(AtomEndOfStream); - AtomEof = AtomAdjust(AtomEof); TermEof = MkAtomTerm(AtomEof); - AtomEOfCode = AtomAdjust(AtomEOfCode); TermEOfCode = MkAtomTerm(AtomEOfCode); - AtomEq = AtomAdjust(AtomEq); TermEq = MkAtomTerm(AtomEq); - AtomError = AtomAdjust(AtomError); TermError = MkAtomTerm(AtomError); - AtomException = AtomAdjust(AtomException); TermException = MkAtomTerm(AtomException); - AtomExtensions = AtomAdjust(AtomExtensions); TermExtensions = MkAtomTerm(AtomExtensions); - AtomEvaluable = AtomAdjust(AtomEvaluable); TermEvaluable = MkAtomTerm(AtomEvaluable); - AtomEvaluationError = AtomAdjust(AtomEvaluationError); TermEvaluationError = MkAtomTerm(AtomEvaluationError); - AtomExecutable = AtomAdjust(AtomExecutable); TermExecutable = MkAtomTerm(AtomExecutable); - AtomExecute = AtomAdjust(AtomExecute); TermExecute = MkAtomTerm(AtomExecute); - AtomExecAnswers = AtomAdjust(AtomExecAnswers); TermExecAnswers = MkAtomTerm(AtomExecAnswers); - AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); - AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); - AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); - AtomExist = AtomAdjust(AtomExist); TermExist = MkAtomTerm(AtomExist); - AtomExists = AtomAdjust(AtomExists); TermExists = MkAtomTerm(AtomExists); - AtomExit = AtomAdjust(AtomExit); TermExit = MkAtomTerm(AtomExit); - AtomExistenceError = AtomAdjust(AtomExistenceError); TermExistenceError = MkAtomTerm(AtomExistenceError); - AtomExoClause = AtomAdjust(AtomExoClause); TermExoClause = MkAtomTerm(AtomExoClause); - AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); - AtomExpand = AtomAdjust(AtomExpand); TermExpand = MkAtomTerm(AtomExpand); - AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); - AtomExtendsions = AtomAdjust(AtomExtendsions); TermExtendsions = MkAtomTerm(AtomExtendsions); - AtomFB = AtomAdjust(AtomFB); TermFB = MkAtomTerm(AtomFB); - AtomFail = AtomAdjust(AtomFail); TermFail = MkAtomTerm(AtomFail); - AtomFalse = AtomAdjust(AtomFalse); TermFalse = MkAtomTerm(AtomFalse); - AtomFast = AtomAdjust(AtomFast); TermFast = MkAtomTerm(AtomFast); - AtomFastFail = AtomAdjust(AtomFastFail); TermFastFail = MkAtomTerm(AtomFastFail); - AtomFileErrors = AtomAdjust(AtomFileErrors); TermFileErrors = MkAtomTerm(AtomFileErrors); - AtomFileerrors = AtomAdjust(AtomFileerrors); TermFileerrors = MkAtomTerm(AtomFileerrors); - AtomFileType = AtomAdjust(AtomFileType); TermFileType = MkAtomTerm(AtomFileType); - AtomFirst = AtomAdjust(AtomFirst); TermFirst = MkAtomTerm(AtomFirst); - AtomFloat = AtomAdjust(AtomFloat); TermFloat = MkAtomTerm(AtomFloat); - AtomFloatFormat = AtomAdjust(AtomFloatFormat); TermFloatFormat = MkAtomTerm(AtomFloatFormat); - AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); - AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); - AtomFormat = AtomAdjust(AtomFormat); TermFormat = MkAtomTerm(AtomFormat); - AtomFormatAt = AtomAdjust(AtomFormatAt); TermFormatAt = MkAtomTerm(AtomFormatAt); - AtomFull = AtomAdjust(AtomFull); TermFull = MkAtomTerm(AtomFull); - AtomFunctor = AtomAdjust(AtomFunctor); TermFunctor = MkAtomTerm(AtomFunctor); - AtomGT = AtomAdjust(AtomGT); TermGT = MkAtomTerm(AtomGT); - AtomGVar = AtomAdjust(AtomGVar); TermGVar = MkAtomTerm(AtomGVar); - AtomGc = AtomAdjust(AtomGc); TermGc = MkAtomTerm(AtomGc); - AtomGcMargin = AtomAdjust(AtomGcMargin); TermGcMargin = MkAtomTerm(AtomGcMargin); - AtomGcTrace = AtomAdjust(AtomGcTrace); TermGcTrace = MkAtomTerm(AtomGcTrace); - AtomGcVerbose = AtomAdjust(AtomGcVerbose); TermGcVerbose = MkAtomTerm(AtomGcVerbose); - AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); - AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); - AtomGetwork = AtomAdjust(AtomGetwork); TermGetwork = MkAtomTerm(AtomGetwork); - AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); - AtomGlob = AtomAdjust(AtomGlob); TermGlob = MkAtomTerm(AtomGlob); - AtomGlobal = AtomAdjust(AtomGlobal); TermGlobal = MkAtomTerm(AtomGlobal); - AtomGlobalSp = AtomAdjust(AtomGlobalSp); TermGlobalSp = MkAtomTerm(AtomGlobalSp); - AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); - AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); - AtomHat = AtomAdjust(AtomHat); TermHat = MkAtomTerm(AtomHat); - AtomHERE = AtomAdjust(AtomHERE); TermHERE = MkAtomTerm(AtomHERE); - AtomHandleThrow = AtomAdjust(AtomHandleThrow); TermHandleThrow = MkAtomTerm(AtomHandleThrow); - AtomHeap = AtomAdjust(AtomHeap); TermHeap = MkAtomTerm(AtomHeap); - AtomHeapUsed = AtomAdjust(AtomHeapUsed); TermHeapUsed = MkAtomTerm(AtomHeapUsed); - AtomHugeInt = AtomAdjust(AtomHugeInt); TermHugeInt = MkAtomTerm(AtomHugeInt); - AtomIDB = AtomAdjust(AtomIDB); TermIDB = MkAtomTerm(AtomIDB); - AtomIOMode = AtomAdjust(AtomIOMode); TermIOMode = MkAtomTerm(AtomIOMode); - AtomI = AtomAdjust(AtomI); TermI = MkAtomTerm(AtomI); - AtomId = AtomAdjust(AtomId); TermId = MkAtomTerm(AtomId); - AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore); - AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf); - AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity); - AtomInfo = AtomAdjust(AtomInfo); TermInfo = MkAtomTerm(AtomInfo); - AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal); - AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog); - AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); - AtomInput = AtomAdjust(AtomInput); TermInput = MkAtomTerm(AtomInput); - AtomInstantiationError = AtomAdjust(AtomInstantiationError); TermInstantiationError = MkAtomTerm(AtomInstantiationError); - AtomInt = AtomAdjust(AtomInt); TermInt = MkAtomTerm(AtomInt); - AtomIntOverflow = AtomAdjust(AtomIntOverflow); TermIntOverflow = MkAtomTerm(AtomIntOverflow); - AtomInteger = AtomAdjust(AtomInteger); TermInteger = MkAtomTerm(AtomInteger); - AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); - AtomIs = AtomAdjust(AtomIs); TermIs = MkAtomTerm(AtomIs); - AtomJ = AtomAdjust(AtomJ); TermJ = MkAtomTerm(AtomJ); - Atoml = AtomAdjust(Atoml); Terml = MkAtomTerm(Atoml); - AtomKey = AtomAdjust(AtomKey); TermKey = MkAtomTerm(AtomKey); - AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); - AtomLONGINT = AtomAdjust(AtomLONGINT); TermLONGINT = MkAtomTerm(AtomLONGINT); - AtomLOOP = AtomAdjust(AtomLOOP); TermLOOP = MkAtomTerm(AtomLOOP); - AtomLoopStream = AtomAdjust(AtomLoopStream); TermLoopStream = MkAtomTerm(AtomLoopStream); - AtomLT = AtomAdjust(AtomLT); TermLT = MkAtomTerm(AtomLT); - AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); - AtomLeash = AtomAdjust(AtomLeash); TermLeash = MkAtomTerm(AtomLeash); - AtomLeast = AtomAdjust(AtomLeast); TermLeast = MkAtomTerm(AtomLeast); - AtomLength = AtomAdjust(AtomLength); TermLength = MkAtomTerm(AtomLength); - AtomList = AtomAdjust(AtomList); TermList = MkAtomTerm(AtomList); - AtomLine = AtomAdjust(AtomLine); TermLine = MkAtomTerm(AtomLine); - AtomLive = AtomAdjust(AtomLive); TermLive = MkAtomTerm(AtomLive); - AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); - AtomLocal = AtomAdjust(AtomLocal); TermLocal = MkAtomTerm(AtomLocal); - AtomLocalSp = AtomAdjust(AtomLocalSp); TermLocalSp = MkAtomTerm(AtomLocalSp); - AtomLocalTrie = AtomAdjust(AtomLocalTrie); TermLocalTrie = MkAtomTerm(AtomLocalTrie); - AtomMax = AtomAdjust(AtomMax); TermMax = MkAtomTerm(AtomMax); - AtomMaximum = AtomAdjust(AtomMaximum); TermMaximum = MkAtomTerm(AtomMaximum); - AtomMaxArity = AtomAdjust(AtomMaxArity); TermMaxArity = MkAtomTerm(AtomMaxArity); - AtomMaxFiles = AtomAdjust(AtomMaxFiles); TermMaxFiles = MkAtomTerm(AtomMaxFiles); - AtomMegaClause = AtomAdjust(AtomMegaClause); TermMegaClause = MkAtomTerm(AtomMegaClause); - AtomMetaCall = AtomAdjust(AtomMetaCall); TermMetaCall = MkAtomTerm(AtomMetaCall); - AtomMfClause = AtomAdjust(AtomMfClause); TermMfClause = MkAtomTerm(AtomMfClause); - AtomMin = AtomAdjust(AtomMin); TermMin = MkAtomTerm(AtomMin); - AtomMinimum = AtomAdjust(AtomMinimum); TermMinimum = MkAtomTerm(AtomMinimum); - AtomMinus = AtomAdjust(AtomMinus); TermMinus = MkAtomTerm(AtomMinus); - AtomModify = AtomAdjust(AtomModify); TermModify = MkAtomTerm(AtomModify); - AtomModule = AtomAdjust(AtomModule); TermModule = MkAtomTerm(AtomModule); - AtomMost = AtomAdjust(AtomMost); TermMost = MkAtomTerm(AtomMost); - AtomMulti = AtomAdjust(AtomMulti); TermMulti = MkAtomTerm(AtomMulti); - AtomMultiFile = AtomAdjust(AtomMultiFile); TermMultiFile = MkAtomTerm(AtomMultiFile); - AtomMultiple = AtomAdjust(AtomMultiple); TermMultiple = MkAtomTerm(AtomMultiple); - AtomMutable = AtomAdjust(AtomMutable); TermMutable = MkAtomTerm(AtomMutable); - AtomMutableVariable = AtomAdjust(AtomMutableVariable); TermMutableVariable = MkAtomTerm(AtomMutableVariable); - AtomMutex = AtomAdjust(AtomMutex); TermMutex = MkAtomTerm(AtomMutex); - AtomMyddasDB = AtomAdjust(AtomMyddasDB); TermMyddasDB = MkAtomTerm(AtomMyddasDB); - AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); - AtomMyddasHost = AtomAdjust(AtomMyddasHost); TermMyddasHost = MkAtomTerm(AtomMyddasHost); - AtomMyddasPass = AtomAdjust(AtomMyddasPass); TermMyddasPass = MkAtomTerm(AtomMyddasPass); - AtomMyddasUser = AtomAdjust(AtomMyddasUser); TermMyddasUser = MkAtomTerm(AtomMyddasUser); - AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); - AtomNan = AtomAdjust(AtomNan); TermNan = MkAtomTerm(AtomNan); - AtomNb = AtomAdjust(AtomNb); TermNb = MkAtomTerm(AtomNb); - AtomNbTerm = AtomAdjust(AtomNbTerm); TermNbTerm = MkAtomTerm(AtomNbTerm); - AtomNew = AtomAdjust(AtomNew); TermNew = MkAtomTerm(AtomNew); - AtomNewLine = AtomAdjust(AtomNewLine); TermNewLine = MkAtomTerm(AtomNewLine); - AtomNl = AtomAdjust(AtomNl); TermNl = MkAtomTerm(AtomNl); - AtomNoEffect = AtomAdjust(AtomNoEffect); TermNoEffect = MkAtomTerm(AtomNoEffect); - AtomNoMemory = AtomAdjust(AtomNoMemory); TermNoMemory = MkAtomTerm(AtomNoMemory); - AtomNone = AtomAdjust(AtomNone); TermNone = MkAtomTerm(AtomNone); - AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); - AtomNot = AtomAdjust(AtomNot); TermNot = MkAtomTerm(AtomNot); - AtomNotImplemented = AtomAdjust(AtomNotImplemented); TermNotImplemented = MkAtomTerm(AtomNotImplemented); - AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); - AtomNotNewline = AtomAdjust(AtomNotNewline); TermNotNewline = MkAtomTerm(AtomNotNewline); - AtomNotZero = AtomAdjust(AtomNotZero); TermNotZero = MkAtomTerm(AtomNotZero); - AtomNumber = AtomAdjust(AtomNumber); TermNumber = MkAtomTerm(AtomNumber); - AtomObj = AtomAdjust(AtomObj); TermObj = MkAtomTerm(AtomObj); - AtomOff = AtomAdjust(AtomOff); TermOff = MkAtomTerm(AtomOff); - AtomOffline = AtomAdjust(AtomOffline); TermOffline = MkAtomTerm(AtomOffline); - AtomOn = AtomAdjust(AtomOn); TermOn = MkAtomTerm(AtomOn); - AtomOnline = AtomAdjust(AtomOnline); TermOnline = MkAtomTerm(AtomOnline); - AtomOpen = AtomAdjust(AtomOpen); TermOpen = MkAtomTerm(AtomOpen); - AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); - AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); - AtomOperator = AtomAdjust(AtomOperator); TermOperator = MkAtomTerm(AtomOperator); - AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); - AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); - AtomOpt = AtomAdjust(AtomOpt); TermOpt = MkAtomTerm(AtomOpt); - AtomOtherwise = AtomAdjust(AtomOtherwise); TermOtherwise = MkAtomTerm(AtomOtherwise); - AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); - AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); - AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); - AtomOutOfRange = AtomAdjust(AtomOutOfRange); TermOutOfRange = MkAtomTerm(AtomOutOfRange); - AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); - AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); - AtomOutput = AtomAdjust(AtomOutput); TermOutput = MkAtomTerm(AtomOutput); - AtomParameter = AtomAdjust(AtomParameter); TermParameter = MkAtomTerm(AtomParameter); - AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); - AtomPast = AtomAdjust(AtomPast); TermPast = MkAtomTerm(AtomPast); - AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); - AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError); - AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi); - AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe); - AtomPriority = AtomAdjust(AtomPriority); TermPriority = MkAtomTerm(AtomPriority); - AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus); - AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer); - AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray); - AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); - AtomPrimitive = AtomAdjust(AtomPrimitive); TermPrimitive = MkAtomTerm(AtomPrimitive); - AtomPrintMessage = AtomAdjust(AtomPrintMessage); TermPrintMessage = MkAtomTerm(AtomPrintMessage); - AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); - AtomProcedure = AtomAdjust(AtomProcedure); TermProcedure = MkAtomTerm(AtomProcedure); - AtomProfile = AtomAdjust(AtomProfile); TermProfile = MkAtomTerm(AtomProfile); - AtomProlog = AtomAdjust(AtomProlog); TermProlog = MkAtomTerm(AtomProlog); - AtomProtectStack = AtomAdjust(AtomProtectStack); TermProtectStack = MkAtomTerm(AtomProtectStack); - AtomQly = AtomAdjust(AtomQly); TermQly = MkAtomTerm(AtomQly); - AtomQuery = AtomAdjust(AtomQuery); TermQuery = MkAtomTerm(AtomQuery); - AtomQueue = AtomAdjust(AtomQueue); TermQueue = MkAtomTerm(AtomQueue); - AtomQuiet = AtomAdjust(AtomQuiet); TermQuiet = MkAtomTerm(AtomQuiet); - AtomRadix = AtomAdjust(AtomRadix); TermRadix = MkAtomTerm(AtomRadix); - AtomRandom = AtomAdjust(AtomRandom); TermRandom = MkAtomTerm(AtomRandom); - AtomRange = AtomAdjust(AtomRange); TermRange = MkAtomTerm(AtomRange); - AtomRDiv = AtomAdjust(AtomRDiv); TermRDiv = MkAtomTerm(AtomRDiv); - AtomRead = AtomAdjust(AtomRead); TermRead = MkAtomTerm(AtomRead); - AtomReadOnly = AtomAdjust(AtomReadOnly); TermReadOnly = MkAtomTerm(AtomReadOnly); - AtomReadWrite = AtomAdjust(AtomReadWrite); TermReadWrite = MkAtomTerm(AtomReadWrite); - AtomReadutil = AtomAdjust(AtomReadutil); TermReadutil = MkAtomTerm(AtomReadutil); - AtomReconsult = AtomAdjust(AtomReconsult); TermReconsult = MkAtomTerm(AtomReconsult); - AtomRecordedP = AtomAdjust(AtomRecordedP); TermRecordedP = MkAtomTerm(AtomRecordedP); - AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); - AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); - AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); - AtomRefoundVar = AtomAdjust(AtomRefoundVar); TermRefoundVar = MkAtomTerm(AtomRefoundVar); - AtomRelativeTo = AtomAdjust(AtomRelativeTo); TermRelativeTo = MkAtomTerm(AtomRelativeTo); - AtomRepeat = AtomAdjust(AtomRepeat); TermRepeat = MkAtomTerm(AtomRepeat); - AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); - AtomReposition = AtomAdjust(AtomReposition); TermReposition = MkAtomTerm(AtomReposition); - AtomRepresentationError = AtomAdjust(AtomRepresentationError); TermRepresentationError = MkAtomTerm(AtomRepresentationError); - AtomReset = AtomAdjust(AtomReset); TermReset = MkAtomTerm(AtomReset); - AtomResize = AtomAdjust(AtomResize); TermResize = MkAtomTerm(AtomResize); - AtomResourceError = AtomAdjust(AtomResourceError); TermResourceError = MkAtomTerm(AtomResourceError); - AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); - AtomRetry = AtomAdjust(AtomRetry); TermRetry = MkAtomTerm(AtomRetry); - AtomRetryCounter = AtomAdjust(AtomRetryCounter); TermRetryCounter = MkAtomTerm(AtomRetryCounter); - AtomRTree = AtomAdjust(AtomRTree); TermRTree = MkAtomTerm(AtomRTree); - AtomSafe = AtomAdjust(AtomSafe); TermSafe = MkAtomTerm(AtomSafe); - AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); - AtomSame = AtomAdjust(AtomSame); TermSame = MkAtomTerm(AtomSame); - AtomSemic = AtomAdjust(AtomSemic); TermSemic = MkAtomTerm(AtomSemic); - AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); - AtomSigAlarm = AtomAdjust(AtomSigAlarm); TermSigAlarm = MkAtomTerm(AtomSigAlarm); - AtomSigBreak = AtomAdjust(AtomSigBreak); TermSigBreak = MkAtomTerm(AtomSigBreak); - AtomSigCreep = AtomAdjust(AtomSigCreep); TermSigCreep = MkAtomTerm(AtomSigCreep); - AtomSigDebug = AtomAdjust(AtomSigDebug); TermSigDebug = MkAtomTerm(AtomSigDebug); - AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); - AtomSigFPE = AtomAdjust(AtomSigFPE); TermSigFPE = MkAtomTerm(AtomSigFPE); - AtomSigHup = AtomAdjust(AtomSigHup); TermSigHup = MkAtomTerm(AtomSigHup); - AtomSigInt = AtomAdjust(AtomSigInt); TermSigInt = MkAtomTerm(AtomSigInt); - AtomSigIti = AtomAdjust(AtomSigIti); TermSigIti = MkAtomTerm(AtomSigIti); - AtomSigPending = AtomAdjust(AtomSigPending); TermSigPending = MkAtomTerm(AtomSigPending); - AtomSigPipe = AtomAdjust(AtomSigPipe); TermSigPipe = MkAtomTerm(AtomSigPipe); - AtomSigStackDump = AtomAdjust(AtomSigStackDump); TermSigStackDump = MkAtomTerm(AtomSigStackDump); - AtomSigStatistics = AtomAdjust(AtomSigStatistics); TermSigStatistics = MkAtomTerm(AtomSigStatistics); - AtomSigTrace = AtomAdjust(AtomSigTrace); TermSigTrace = MkAtomTerm(AtomSigTrace); - AtomSigUsr1 = AtomAdjust(AtomSigUsr1); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); - AtomSigUsr2 = AtomAdjust(AtomSigUsr2); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); - AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); - AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); - AtomSilent = AtomAdjust(AtomSilent); TermSilent = MkAtomTerm(AtomSilent); - AtomSingle = AtomAdjust(AtomSingle); TermSingle = MkAtomTerm(AtomSingle); - AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); - AtomSingleton = AtomAdjust(AtomSingleton); TermSingleton = MkAtomTerm(AtomSingleton); - AtomSlash = AtomAdjust(AtomSlash); TermSlash = MkAtomTerm(AtomSlash); - AtomSocket = AtomAdjust(AtomSocket); TermSocket = MkAtomTerm(AtomSocket); - AtomSolutions = AtomAdjust(AtomSolutions); TermSolutions = MkAtomTerm(AtomSolutions); - AtomSource = AtomAdjust(AtomSource); TermSource = MkAtomTerm(AtomSource); - AtomSourceSink = AtomAdjust(AtomSourceSink); TermSourceSink = MkAtomTerm(AtomSourceSink); - AtomSpy = AtomAdjust(AtomSpy); TermSpy = MkAtomTerm(AtomSpy); - AtomStack = AtomAdjust(AtomStack); TermStack = MkAtomTerm(AtomStack); - AtomStackFree = AtomAdjust(AtomStackFree); TermStackFree = MkAtomTerm(AtomStackFree); - AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); - AtomStaticClause = AtomAdjust(AtomStaticClause); TermStaticClause = MkAtomTerm(AtomStaticClause); - AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); - AtomStream = AtomAdjust(AtomStream); TermStream = MkAtomTerm(AtomStream); - AtomSWIStream = AtomAdjust(AtomSWIStream); TermSWIStream = MkAtomTerm(AtomSWIStream); - AtomVStream = AtomAdjust(AtomVStream); TermVStream = MkAtomTerm(AtomVStream); - AtomStreams = AtomAdjust(AtomStreams); TermStreams = MkAtomTerm(AtomStreams); - AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); - AtomStreamPos = AtomAdjust(AtomStreamPos); TermStreamPos = MkAtomTerm(AtomStreamPos); - AtomStreamPosition = AtomAdjust(AtomStreamPosition); TermStreamPosition = MkAtomTerm(AtomStreamPosition); - AtomString = AtomAdjust(AtomString); TermString = MkAtomTerm(AtomString); - AtomStyleCheck = AtomAdjust(AtomStyleCheck); TermStyleCheck = MkAtomTerm(AtomStyleCheck); - AtomSTRING = AtomAdjust(AtomSTRING); TermSTRING = MkAtomTerm(AtomSTRING); - AtomSwi = AtomAdjust(AtomSwi); TermSwi = MkAtomTerm(AtomSwi); - AtomSymbolChar = AtomAdjust(AtomSymbolChar); TermSymbolChar = MkAtomTerm(AtomSymbolChar); - AtomSyntaxError = AtomAdjust(AtomSyntaxError); TermSyntaxError = MkAtomTerm(AtomSyntaxError); - AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); - AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); - AtomSystem = AtomAdjust(AtomSystem); TermSystem = MkAtomTerm(AtomSystem); - AtomSystemError = AtomAdjust(AtomSystemError); TermSystemError = MkAtomTerm(AtomSystemError); - AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); - AtomT = AtomAdjust(AtomT); TermT = MkAtomTerm(AtomT); - AtomTerm = AtomAdjust(AtomTerm); TermTerm = MkAtomTerm(AtomTerm); - AtomTermExpansion = AtomAdjust(AtomTermExpansion); TermTermExpansion = MkAtomTerm(AtomTermExpansion); - AtomTerms = AtomAdjust(AtomTerms); TermTerms = MkAtomTerm(AtomTerms); - AtomText = AtomAdjust(AtomText); TermText = MkAtomTerm(AtomText); - AtomTextStream = AtomAdjust(AtomTextStream); TermTextStream = MkAtomTerm(AtomTextStream); - AtomThread = AtomAdjust(AtomThread); TermThread = MkAtomTerm(AtomThread); - AtomThreads = AtomAdjust(AtomThreads); TermThreads = MkAtomTerm(AtomThreads); - AtomThrow = AtomAdjust(AtomThrow); TermThrow = MkAtomTerm(AtomThrow); - AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); - AtomTimeoutError = AtomAdjust(AtomTimeoutError); TermTimeoutError = MkAtomTerm(AtomTimeoutError); - AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); - AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); - AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); - AtomTrail = AtomAdjust(AtomTrail); - AtomTrue = AtomAdjust(AtomTrue); TermTrue = MkAtomTerm(AtomTrue); - AtomTty = AtomAdjust(AtomTty); TermTty = MkAtomTerm(AtomTty); - AtomTtys = AtomAdjust(AtomTtys); TermTtys = MkAtomTerm(AtomTtys); - AtomTuple = AtomAdjust(AtomTuple); TermTuple = MkAtomTerm(AtomTuple); - AtomTxt = AtomAdjust(AtomTxt); TermTxt = MkAtomTerm(AtomTxt); - AtomTypeError = AtomAdjust(AtomTypeError); TermTypeError = MkAtomTerm(AtomTypeError); - AtomUndefined = AtomAdjust(AtomUndefined); TermUndefined = MkAtomTerm(AtomUndefined); - AtomUndefp = AtomAdjust(AtomUndefp); TermUndefp = MkAtomTerm(AtomUndefp); - AtomUndefp0 = AtomAdjust(AtomUndefp0); TermUndefp0 = MkAtomTerm(AtomUndefp0); - AtomUnderflow = AtomAdjust(AtomUnderflow); TermUnderflow = MkAtomTerm(AtomUnderflow); - AtomUnificationStack = AtomAdjust(AtomUnificationStack); TermUnificationStack = MkAtomTerm(AtomUnificationStack); - AtomUnique = AtomAdjust(AtomUnique); TermUnique = MkAtomTerm(AtomUnique); - AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); - AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); - AtomUser = AtomAdjust(AtomUser); TermUser = MkAtomTerm(AtomUser); - AtomUserErr = AtomAdjust(AtomUserErr); TermUserErr = MkAtomTerm(AtomUserErr); - AtomUserIn = AtomAdjust(AtomUserIn); TermUserIn = MkAtomTerm(AtomUserIn); - AtomUserOut = AtomAdjust(AtomUserOut); TermUserOut = MkAtomTerm(AtomUserOut); - AtomDollarVar = AtomAdjust(AtomDollarVar); TermDollarVar = MkAtomTerm(AtomDollarVar); - AtomVBar = AtomAdjust(AtomVBar); TermVBar = MkAtomTerm(AtomVBar); - AtomVarBranches = AtomAdjust(AtomVarBranches); TermVarBranches = MkAtomTerm(AtomVarBranches); - AtomVariableNames = AtomAdjust(AtomVariableNames); TermVariableNames = MkAtomTerm(AtomVariableNames); - AtomHiddenVar = AtomAdjust(AtomHiddenVar); TermHiddenVar = MkAtomTerm(AtomHiddenVar); - AtomVariable = AtomAdjust(AtomVariable); TermVariable = MkAtomTerm(AtomVariable); - AtomVerbose = AtomAdjust(AtomVerbose); TermVerbose = MkAtomTerm(AtomVerbose); - AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); - AtomVersionNumber = AtomAdjust(AtomVersionNumber); TermVersionNumber = MkAtomTerm(AtomVersionNumber); - AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); - AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); - AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning); - AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen); - AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite); - AtomWriteTerm = AtomAdjust(AtomWriteTerm); TermWriteTerm = MkAtomTerm(AtomWriteTerm); - AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml); - AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks); - AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); - FunctorAfInet = FuncAdjust(FunctorAfInet); - FunctorAfLocal = FuncAdjust(FunctorAfLocal); - FunctorAfUnix = FuncAdjust(FunctorAfUnix); - FunctorAltNot = FuncAdjust(FunctorAltNot); - FunctorArg = FuncAdjust(FunctorArg); - FunctorArrayEntry = FuncAdjust(FunctorArrayEntry); - FunctorArrow = FuncAdjust(FunctorArrow); - FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); - FunctorAssert1 = FuncAdjust(FunctorAssert1); - FunctorAssert = FuncAdjust(FunctorAssert); - FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne); - FunctorAtom = FuncAdjust(FunctorAtom); - FunctorAtt1 = FuncAdjust(FunctorAtt1); - FunctorAttGoal = FuncAdjust(FunctorAttGoal); - FunctorBraces = FuncAdjust(FunctorBraces); - FunctorCall = FuncAdjust(FunctorCall); - FunctorCatch = FuncAdjust(FunctorCatch); - FunctorChangeModule = FuncAdjust(FunctorChangeModule); - FunctorChars = FuncAdjust(FunctorChars); - FunctorChars1 = FuncAdjust(FunctorChars1); - FunctorCleanCall = FuncAdjust(FunctorCleanCall); - FunctorClist = FuncAdjust(FunctorClist); - FunctorCodes = FuncAdjust(FunctorCodes); - FunctorCodes1 = FuncAdjust(FunctorCodes1); - FunctorColon = FuncAdjust(FunctorColon); - FunctorComma = FuncAdjust(FunctorComma); - FunctorCommentHook = FuncAdjust(FunctorCommentHook); - FunctorContext2 = FuncAdjust(FunctorContext2); - FunctorConsistencyError = FuncAdjust(FunctorConsistencyError); - FunctorCreep = FuncAdjust(FunctorCreep); - FunctorCsult = FuncAdjust(FunctorCsult); - FunctorCurrentModule = FuncAdjust(FunctorCurrentModule); - FunctorCutBy = FuncAdjust(FunctorCutBy); - FunctorDBREF = FuncAdjust(FunctorDBREF); - FunctorDiff = FuncAdjust(FunctorDiff); - FunctorDoLogUpdClause = FuncAdjust(FunctorDoLogUpdClause); - FunctorDoLogUpdClause0 = FuncAdjust(FunctorDoLogUpdClause0); - FunctorDoLogUpdClauseErase = FuncAdjust(FunctorDoLogUpdClauseErase); - FunctorDoStaticClause = FuncAdjust(FunctorDoStaticClause); - FunctorDollar = FuncAdjust(FunctorDollar); - FunctorDollarVar = FuncAdjust(FunctorDollarVar); - FunctorDomainError = FuncAdjust(FunctorDomainError); - FunctorDot = FuncAdjust(FunctorDot); - FunctorDot10 = FuncAdjust(FunctorDot10); - FunctorDot11 = FuncAdjust(FunctorDot11); - FunctorDot12 = FuncAdjust(FunctorDot12); - FunctorDot2 = FuncAdjust(FunctorDot2); - FunctorDot3 = FuncAdjust(FunctorDot3); - FunctorDot4 = FuncAdjust(FunctorDot4); - FunctorDot5 = FuncAdjust(FunctorDot5); - FunctorDot6 = FuncAdjust(FunctorDot6); - FunctorDot7 = FuncAdjust(FunctorDot7); - FunctorDot8 = FuncAdjust(FunctorDot8); - FunctorDot9 = FuncAdjust(FunctorDot9); - FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); - FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash); - FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets); - FunctorEq = FuncAdjust(FunctorEq); - FunctorError = FuncAdjust(FunctorError); - FunctorEvaluationError = FuncAdjust(FunctorEvaluationError); - FunctorException = FuncAdjust(FunctorException); - FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod); - FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod); - FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin); - FunctorExistenceError = FuncAdjust(FunctorExistenceError); - FunctorExoClause = FuncAdjust(FunctorExoClause); - FunctorFunctor = FuncAdjust(FunctorFunctor); - FunctorGAtom = FuncAdjust(FunctorGAtom); - FunctorGAtomic = FuncAdjust(FunctorGAtomic); - FunctorGCompound = FuncAdjust(FunctorGCompound); - FunctorGFloat = FuncAdjust(FunctorGFloat); - FunctorGFormatAt = FuncAdjust(FunctorGFormatAt); - FunctorGInteger = FuncAdjust(FunctorGInteger); - FunctorGNumber = FuncAdjust(FunctorGNumber); - FunctorGPrimitive = FuncAdjust(FunctorGPrimitive); - FunctorGVar = FuncAdjust(FunctorGVar); - FunctorGeneratePredInfo = FuncAdjust(FunctorGeneratePredInfo); - FunctorGoalExpansion2 = FuncAdjust(FunctorGoalExpansion2); - FunctorGoalExpansion = FuncAdjust(FunctorGoalExpansion); - FunctorHandleThrow = FuncAdjust(FunctorHandleThrow); - FunctorHat = FuncAdjust(FunctorHat); - FunctorI = FuncAdjust(FunctorI); - FunctorId = FuncAdjust(FunctorId); - FunctorInfo1 = FuncAdjust(FunctorInfo1); - FunctorInfo2 = FuncAdjust(FunctorInfo2); - FunctorInfo3 = FuncAdjust(FunctorInfo3); - FunctorInfo4 = FuncAdjust(FunctorInfo4); - FunctorIs = FuncAdjust(FunctorIs); - FunctorJ = FuncAdjust(FunctorJ); - FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin); - FunctorList = FuncAdjust(FunctorList); - FunctorLOOP = FuncAdjust(FunctorLOOP); - FunctorMegaClause = FuncAdjust(FunctorMegaClause); - FunctorMetaCall = FuncAdjust(FunctorMetaCall); - FunctorMinus = FuncAdjust(FunctorMinus); - FunctorModule = FuncAdjust(FunctorModule); - FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause); - FunctorMutable = FuncAdjust(FunctorMutable); - FunctorMutex = FuncAdjust(FunctorMutex); - FunctorNotImplemented = FuncAdjust(FunctorNotImplemented); - FunctorNBQueue = FuncAdjust(FunctorNBQueue); - FunctorNot = FuncAdjust(FunctorNot); - FunctorObj = FuncAdjust(FunctorObj); - FunctorOr = FuncAdjust(FunctorOr); - FunctorOutput = FuncAdjust(FunctorOutput); - FunctorPermissionError = FuncAdjust(FunctorPermissionError); - FunctorPlus = FuncAdjust(FunctorPlus); - FunctorPortray = FuncAdjust(FunctorPortray); - FunctorPrintMessage = FuncAdjust(FunctorPrintMessage); - FunctorProcedure = FuncAdjust(FunctorProcedure); - FunctorPriority = FuncAdjust(FunctorPriority); - FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint); - FunctorProtectStack = FuncAdjust(FunctorProtectStack); - FunctorQuery = FuncAdjust(FunctorQuery); - FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey); - FunctorRDiv = FuncAdjust(FunctorRDiv); - FunctorRedoFreeze = FuncAdjust(FunctorRedoFreeze); - FunctorRepresentationError = FuncAdjust(FunctorRepresentationError); - FunctorResourceError = FuncAdjust(FunctorResourceError); - FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs); - FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1); - FunctorSafe = FuncAdjust(FunctorSafe); - FunctorSafeCallCleanup = FuncAdjust(FunctorSafeCallCleanup); - FunctorSame = FuncAdjust(FunctorSame); - FunctorSlash = FuncAdjust(FunctorSlash); - FunctorStaticClause = FuncAdjust(FunctorStaticClause); - FunctorStream = FuncAdjust(FunctorStream); - FunctorStreamEOS = FuncAdjust(FunctorStreamEOS); - FunctorStreamPos = FuncAdjust(FunctorStreamPos); - FunctorString1 = FuncAdjust(FunctorString1); - FunctorStyleCheck = FuncAdjust(FunctorStyleCheck); - FunctorSyntaxError = FuncAdjust(FunctorSyntaxError); - FunctorShortSyntaxError = FuncAdjust(FunctorShortSyntaxError); - FunctorTermExpansion = FuncAdjust(FunctorTermExpansion); - FunctorThreadRun = FuncAdjust(FunctorThreadRun); - FunctorThrow = FuncAdjust(FunctorThrow); - FunctorTimeoutError = FuncAdjust(FunctorTimeoutError); - FunctorTraceMetaCall = FuncAdjust(FunctorTraceMetaCall); - FunctorTypeError = FuncAdjust(FunctorTypeError); - FunctorUMinus = FuncAdjust(FunctorUMinus); - FunctorUPlus = FuncAdjust(FunctorUPlus); - FunctorVBar = FuncAdjust(FunctorVBar); - FunctorWriteTerm = FuncAdjust(FunctorWriteTerm); - FunctorHiddenVar = FuncAdjust(FunctorHiddenVar); + + /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" + {lease do not update, update misc/ATOMS instead */ + + Atom3Dots = AtomAdjust(Atom3Dots); + AtomAbol = AtomAdjust(AtomAbol); TermAbol = MkAtomTerm(AtomAbol); + AtomAccess = AtomAdjust(AtomAccess); TermAccess = MkAtomTerm(AtomAccess); + AtomAfInet = AtomAdjust(AtomAfInet); TermAfInet = MkAtomTerm(AtomAfInet); + AtomAfLocal = AtomAdjust(AtomAfLocal); TermAfLocal = MkAtomTerm(AtomAfLocal); + AtomAfUnix = AtomAdjust(AtomAfUnix); TermAfUnix = MkAtomTerm(AtomAfUnix); + AtomAlarm = AtomAdjust(AtomAlarm); TermAlarm = MkAtomTerm(AtomAlarm); + AtomAlias = AtomAdjust(AtomAlias); TermAlias = MkAtomTerm(AtomAlias); + AtomAll = AtomAdjust(AtomAll); TermAll = MkAtomTerm(AtomAll); + AtomAltNot = AtomAdjust(AtomAltNot); TermAltNot = MkAtomTerm(AtomAltNot); + AtomAnswer = AtomAdjust(AtomAnswer); TermAnswer = MkAtomTerm(AtomAnswer); + AtomAny = AtomAdjust(AtomAny); TermAny = MkAtomTerm(AtomAny); + AtomAppend = AtomAdjust(AtomAppend); TermAppend = MkAtomTerm(AtomAppend); + AtomArg = AtomAdjust(AtomArg); TermArg = MkAtomTerm(AtomArg); + AtomArray = AtomAdjust(AtomArray); TermArray = MkAtomTerm(AtomArray); + AtomArrayAccess = AtomAdjust(AtomArrayAccess); TermArrayAccess = MkAtomTerm(AtomArrayAccess); + AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); + AtomArrayType = AtomAdjust(AtomArrayType); TermArrayType = MkAtomTerm(AtomArrayType); + AtomArrow = AtomAdjust(AtomArrow); TermArrow = MkAtomTerm(AtomArrow); + AtomAttributedModule = AtomAdjust(AtomAttributedModule); TermAttributedModule = MkAtomTerm(AtomAttributedModule); + AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); + AtomAssert = AtomAdjust(AtomAssert); TermAssert = MkAtomTerm(AtomAssert); + AtomBeginBracket = AtomAdjust(AtomBeginBracket); TermBeginBracket = MkAtomTerm(AtomBeginBracket); + AtomEndBracket = AtomAdjust(AtomEndBracket); TermEndBracket = MkAtomTerm(AtomEndBracket); + AtomBeginSquareBracket = AtomAdjust(AtomBeginSquareBracket); TermBeginSquareBracket = MkAtomTerm(AtomBeginSquareBracket); + AtomEndSquareBracket = AtomAdjust(AtomEndSquareBracket); TermEndSquareBracket = MkAtomTerm(AtomEndSquareBracket); + AtomBeginCurlyBracket = AtomAdjust(AtomBeginCurlyBracket); TermBeginCurlyBracket = MkAtomTerm(AtomBeginCurlyBracket); + AtomEndCurlyBracket = AtomAdjust(AtomEndCurlyBracket); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket); + AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); + AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); + AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta); + AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); + AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz); + AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); + AtomAt = AtomAdjust(AtomAt); TermAt = MkAtomTerm(AtomAt); + AtomAtom = AtomAdjust(AtomAtom); TermAtom = MkAtomTerm(AtomAtom); + AtomAtomic = AtomAdjust(AtomAtomic); TermAtomic = MkAtomTerm(AtomAtomic); + AtomAtt = AtomAdjust(AtomAtt); TermAtt = MkAtomTerm(AtomAtt); + AtomAtt1 = AtomAdjust(AtomAtt1); TermAtt1 = MkAtomTerm(AtomAtt1); + AtomAttDo = AtomAdjust(AtomAttDo); TermAttDo = MkAtomTerm(AtomAttDo); + AtomAttributes = AtomAdjust(AtomAttributes); TermAttributes = MkAtomTerm(AtomAttributes); + AtomB = AtomAdjust(AtomB); TermB = MkAtomTerm(AtomB); + AtomBatched = AtomAdjust(AtomBatched); TermBatched = MkAtomTerm(AtomBatched); + AtomBetween = AtomAdjust(AtomBetween); TermBetween = MkAtomTerm(AtomBetween); + AtomBinary = AtomAdjust(AtomBinary); TermBinary = MkAtomTerm(AtomBinary); + AtomBigNum = AtomAdjust(AtomBigNum); TermBigNum = MkAtomTerm(AtomBigNum); + AtomBinaryStream = AtomAdjust(AtomBinaryStream); TermBinaryStream = MkAtomTerm(AtomBinaryStream); + AtomBoolean = AtomAdjust(AtomBoolean); TermBoolean = MkAtomTerm(AtomBoolean); + AtomBraces = AtomAdjust(AtomBraces); TermBraces = MkAtomTerm(AtomBraces); + AtomBreak = AtomAdjust(AtomBreak); TermBreak = MkAtomTerm(AtomBreak); + AtomByte = AtomAdjust(AtomByte); TermByte = MkAtomTerm(AtomByte); + AtomCArith = AtomAdjust(AtomCArith); TermCArith = MkAtomTerm(AtomCArith); + AtomCall = AtomAdjust(AtomCall); TermCall = MkAtomTerm(AtomCall); + AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); + AtomCallCounter = AtomAdjust(AtomCallCounter); TermCallCounter = MkAtomTerm(AtomCallCounter); + AtomCallable = AtomAdjust(AtomCallable); TermCallable = MkAtomTerm(AtomCallable); + AtomCatch = AtomAdjust(AtomCatch); TermCatch = MkAtomTerm(AtomCatch); + AtomChangeModule = AtomAdjust(AtomChangeModule); TermChangeModule = MkAtomTerm(AtomChangeModule); + AtomChar = AtomAdjust(AtomChar); TermChar = MkAtomTerm(AtomChar); + AtomCharsio = AtomAdjust(AtomCharsio); TermCharsio = MkAtomTerm(AtomCharsio); + AtomCharacter = AtomAdjust(AtomCharacter); TermCharacter = MkAtomTerm(AtomCharacter); + AtomCharacterCode = AtomAdjust(AtomCharacterCode); TermCharacterCode = MkAtomTerm(AtomCharacterCode); + AtomChars = AtomAdjust(AtomChars); TermChars = MkAtomTerm(AtomChars); + AtomCharset = AtomAdjust(AtomCharset); TermCharset = MkAtomTerm(AtomCharset); + AtomChType = AtomAdjust(AtomChType); TermChType = MkAtomTerm(AtomChType); + AtomCleanCall = AtomAdjust(AtomCleanCall); TermCleanCall = MkAtomTerm(AtomCleanCall); + AtomClose = AtomAdjust(AtomClose); TermClose = MkAtomTerm(AtomClose); + AtomColon = AtomAdjust(AtomColon); TermColon = MkAtomTerm(AtomColon); + AtomCodeSpace = AtomAdjust(AtomCodeSpace); TermCodeSpace = MkAtomTerm(AtomCodeSpace); + AtomCodes = AtomAdjust(AtomCodes); TermCodes = MkAtomTerm(AtomCodes); + AtomCoInductive = AtomAdjust(AtomCoInductive); TermCoInductive = MkAtomTerm(AtomCoInductive); + AtomComma = AtomAdjust(AtomComma); TermComma = MkAtomTerm(AtomComma); + AtomCommentHook = AtomAdjust(AtomCommentHook); TermCommentHook = MkAtomTerm(AtomCommentHook); + AtomCompact = AtomAdjust(AtomCompact); TermCompact = MkAtomTerm(AtomCompact); + AtomCompound = AtomAdjust(AtomCompound); TermCompound = MkAtomTerm(AtomCompound); + AtomConsistencyError = AtomAdjust(AtomConsistencyError); TermConsistencyError = MkAtomTerm(AtomConsistencyError); + AtomConsult = AtomAdjust(AtomConsult); TermConsult = MkAtomTerm(AtomConsult); + AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); + AtomContext = AtomAdjust(AtomContext); TermContext = MkAtomTerm(AtomContext); + AtomCputime = AtomAdjust(AtomCputime); TermCputime = MkAtomTerm(AtomCputime); + AtomCreate = AtomAdjust(AtomCreate); TermCreate = MkAtomTerm(AtomCreate); + AtomCreep = AtomAdjust(AtomCreep); TermCreep = MkAtomTerm(AtomCreep); + AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); + AtomCurly = AtomAdjust(AtomCurly); TermCurly = MkAtomTerm(AtomCurly); + AtomCsult = AtomAdjust(AtomCsult); TermCsult = MkAtomTerm(AtomCsult); + AtomCurrentModule = AtomAdjust(AtomCurrentModule); TermCurrentModule = MkAtomTerm(AtomCurrentModule); + AtomCut = AtomAdjust(AtomCut); TermCut = MkAtomTerm(AtomCut); + AtomCutBy = AtomAdjust(AtomCutBy); TermCutBy = MkAtomTerm(AtomCutBy); + AtomDAbort = AtomAdjust(AtomDAbort); TermDAbort = MkAtomTerm(AtomDAbort); + AtomDBLoad = AtomAdjust(AtomDBLoad); TermDBLoad = MkAtomTerm(AtomDBLoad); + AtomDBREF = AtomAdjust(AtomDBREF); TermDBREF = MkAtomTerm(AtomDBREF); + AtomDBReference = AtomAdjust(AtomDBReference); TermDBReference = MkAtomTerm(AtomDBReference); + AtomDBTerm = AtomAdjust(AtomDBTerm); TermDBTerm = MkAtomTerm(AtomDBTerm); + AtomDBref = AtomAdjust(AtomDBref); TermDBref = MkAtomTerm(AtomDBref); + AtomDInteger = AtomAdjust(AtomDInteger); TermDInteger = MkAtomTerm(AtomDInteger); + AtomDebugMeta = AtomAdjust(AtomDebugMeta); TermDebugMeta = MkAtomTerm(AtomDebugMeta); + AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); + AtomDec10 = AtomAdjust(AtomDec10); TermDec10 = MkAtomTerm(AtomDec10); + AtomDefault = AtomAdjust(AtomDefault); TermDefault = MkAtomTerm(AtomDefault); + AtomDevNull = AtomAdjust(AtomDevNull); TermDevNull = MkAtomTerm(AtomDevNull); + AtomDiff = AtomAdjust(AtomDiff); TermDiff = MkAtomTerm(AtomDiff); + AtomDirectory = AtomAdjust(AtomDirectory); TermDirectory = MkAtomTerm(AtomDirectory); + AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); + AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); + AtomDollar = AtomAdjust(AtomDollar); TermDollar = MkAtomTerm(AtomDollar); + AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); + AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); + AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); + AtomDollarU = AtomAdjust(AtomDollarU); TermDollarU = MkAtomTerm(AtomDollarU); + AtomDollarUndef = AtomAdjust(AtomDollarUndef); TermDollarUndef = MkAtomTerm(AtomDollarUndef); + AtomDomainError = AtomAdjust(AtomDomainError); TermDomainError = MkAtomTerm(AtomDomainError); + AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); + AtomDots = AtomAdjust(AtomDots); TermDots = MkAtomTerm(AtomDots); + AtomDOUBLE = AtomAdjust(AtomDOUBLE); TermDOUBLE = MkAtomTerm(AtomDOUBLE); + AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); + AtomE = AtomAdjust(AtomE); TermE = MkAtomTerm(AtomE); + AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); + AtomEQ = AtomAdjust(AtomEQ); TermEQ = MkAtomTerm(AtomEQ); + AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); + AtomEncoding = AtomAdjust(AtomEncoding); TermEncoding = MkAtomTerm(AtomEncoding); + AtomEndOfStream = AtomAdjust(AtomEndOfStream); TermEndOfStream = MkAtomTerm(AtomEndOfStream); + AtomEof = AtomAdjust(AtomEof); TermEof = MkAtomTerm(AtomEof); + AtomEOfCode = AtomAdjust(AtomEOfCode); TermEOfCode = MkAtomTerm(AtomEOfCode); + AtomEq = AtomAdjust(AtomEq); TermEq = MkAtomTerm(AtomEq); + AtomError = AtomAdjust(AtomError); TermError = MkAtomTerm(AtomError); + AtomException = AtomAdjust(AtomException); TermException = MkAtomTerm(AtomException); + AtomExtensions = AtomAdjust(AtomExtensions); TermExtensions = MkAtomTerm(AtomExtensions); + AtomEvaluable = AtomAdjust(AtomEvaluable); TermEvaluable = MkAtomTerm(AtomEvaluable); + AtomEvaluationError = AtomAdjust(AtomEvaluationError); TermEvaluationError = MkAtomTerm(AtomEvaluationError); + AtomExecutable = AtomAdjust(AtomExecutable); TermExecutable = MkAtomTerm(AtomExecutable); + AtomExecute = AtomAdjust(AtomExecute); TermExecute = MkAtomTerm(AtomExecute); + AtomExecAnswers = AtomAdjust(AtomExecAnswers); TermExecAnswers = MkAtomTerm(AtomExecAnswers); + AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); + AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); + AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); + AtomExist = AtomAdjust(AtomExist); TermExist = MkAtomTerm(AtomExist); + AtomExists = AtomAdjust(AtomExists); TermExists = MkAtomTerm(AtomExists); + AtomExit = AtomAdjust(AtomExit); TermExit = MkAtomTerm(AtomExit); + AtomExistenceError = AtomAdjust(AtomExistenceError); TermExistenceError = MkAtomTerm(AtomExistenceError); + AtomExoClause = AtomAdjust(AtomExoClause); TermExoClause = MkAtomTerm(AtomExoClause); + AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); + AtomExpand = AtomAdjust(AtomExpand); TermExpand = MkAtomTerm(AtomExpand); + AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); + AtomExtendsions = AtomAdjust(AtomExtendsions); TermExtendsions = MkAtomTerm(AtomExtendsions); + AtomFB = AtomAdjust(AtomFB); TermFB = MkAtomTerm(AtomFB); + AtomFail = AtomAdjust(AtomFail); TermFail = MkAtomTerm(AtomFail); + AtomFalse = AtomAdjust(AtomFalse); TermFalse = MkAtomTerm(AtomFalse); + AtomFast = AtomAdjust(AtomFast); TermFast = MkAtomTerm(AtomFast); + AtomFastFail = AtomAdjust(AtomFastFail); TermFastFail = MkAtomTerm(AtomFastFail); + AtomFileErrors = AtomAdjust(AtomFileErrors); TermFileErrors = MkAtomTerm(AtomFileErrors); + AtomFileerrors = AtomAdjust(AtomFileerrors); TermFileerrors = MkAtomTerm(AtomFileerrors); + AtomFileType = AtomAdjust(AtomFileType); TermFileType = MkAtomTerm(AtomFileType); + AtomFirst = AtomAdjust(AtomFirst); TermFirst = MkAtomTerm(AtomFirst); + AtomFloat = AtomAdjust(AtomFloat); TermFloat = MkAtomTerm(AtomFloat); + AtomFloatFormat = AtomAdjust(AtomFloatFormat); TermFloatFormat = MkAtomTerm(AtomFloatFormat); + AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); + AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); + AtomFormat = AtomAdjust(AtomFormat); TermFormat = MkAtomTerm(AtomFormat); + AtomFormatAt = AtomAdjust(AtomFormatAt); TermFormatAt = MkAtomTerm(AtomFormatAt); + AtomFull = AtomAdjust(AtomFull); TermFull = MkAtomTerm(AtomFull); + AtomFunctor = AtomAdjust(AtomFunctor); TermFunctor = MkAtomTerm(AtomFunctor); + AtomGT = AtomAdjust(AtomGT); TermGT = MkAtomTerm(AtomGT); + AtomGVar = AtomAdjust(AtomGVar); TermGVar = MkAtomTerm(AtomGVar); + AtomGc = AtomAdjust(AtomGc); TermGc = MkAtomTerm(AtomGc); + AtomGcMargin = AtomAdjust(AtomGcMargin); TermGcMargin = MkAtomTerm(AtomGcMargin); + AtomGcTrace = AtomAdjust(AtomGcTrace); TermGcTrace = MkAtomTerm(AtomGcTrace); + AtomGcVerbose = AtomAdjust(AtomGcVerbose); TermGcVerbose = MkAtomTerm(AtomGcVerbose); + AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); + AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); + AtomGetwork = AtomAdjust(AtomGetwork); TermGetwork = MkAtomTerm(AtomGetwork); + AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); + AtomGlob = AtomAdjust(AtomGlob); TermGlob = MkAtomTerm(AtomGlob); + AtomGlobal = AtomAdjust(AtomGlobal); TermGlobal = MkAtomTerm(AtomGlobal); + AtomGlobalSp = AtomAdjust(AtomGlobalSp); TermGlobalSp = MkAtomTerm(AtomGlobalSp); + AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); + AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); + AtomHat = AtomAdjust(AtomHat); TermHat = MkAtomTerm(AtomHat); + AtomHERE = AtomAdjust(AtomHERE); TermHERE = MkAtomTerm(AtomHERE); + AtomHandleThrow = AtomAdjust(AtomHandleThrow); TermHandleThrow = MkAtomTerm(AtomHandleThrow); + AtomHeap = AtomAdjust(AtomHeap); TermHeap = MkAtomTerm(AtomHeap); + AtomHeapUsed = AtomAdjust(AtomHeapUsed); TermHeapUsed = MkAtomTerm(AtomHeapUsed); + AtomHugeInt = AtomAdjust(AtomHugeInt); TermHugeInt = MkAtomTerm(AtomHugeInt); + AtomIDB = AtomAdjust(AtomIDB); TermIDB = MkAtomTerm(AtomIDB); + AtomIOMode = AtomAdjust(AtomIOMode); TermIOMode = MkAtomTerm(AtomIOMode); + AtomI = AtomAdjust(AtomI); TermI = MkAtomTerm(AtomI); + AtomId = AtomAdjust(AtomId); TermId = MkAtomTerm(AtomId); + AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore); + AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf); + AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity); + AtomInfo = AtomAdjust(AtomInfo); TermInfo = MkAtomTerm(AtomInfo); + AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal); + AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog); + AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); + AtomInput = AtomAdjust(AtomInput); TermInput = MkAtomTerm(AtomInput); + AtomInstantiationError = AtomAdjust(AtomInstantiationError); TermInstantiationError = MkAtomTerm(AtomInstantiationError); + AtomInt = AtomAdjust(AtomInt); TermInt = MkAtomTerm(AtomInt); + AtomIntOverflow = AtomAdjust(AtomIntOverflow); TermIntOverflow = MkAtomTerm(AtomIntOverflow); + AtomInteger = AtomAdjust(AtomInteger); TermInteger = MkAtomTerm(AtomInteger); + AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); + AtomIs = AtomAdjust(AtomIs); TermIs = MkAtomTerm(AtomIs); + AtomJ = AtomAdjust(AtomJ); TermJ = MkAtomTerm(AtomJ); + Atoml = AtomAdjust(Atoml); Terml = MkAtomTerm(Atoml); + AtomKey = AtomAdjust(AtomKey); TermKey = MkAtomTerm(AtomKey); + AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); + AtomLONGINT = AtomAdjust(AtomLONGINT); TermLONGINT = MkAtomTerm(AtomLONGINT); + AtomLOOP = AtomAdjust(AtomLOOP); TermLOOP = MkAtomTerm(AtomLOOP); + AtomLoopStream = AtomAdjust(AtomLoopStream); TermLoopStream = MkAtomTerm(AtomLoopStream); + AtomLT = AtomAdjust(AtomLT); TermLT = MkAtomTerm(AtomLT); + AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); + AtomLeash = AtomAdjust(AtomLeash); TermLeash = MkAtomTerm(AtomLeash); + AtomLeast = AtomAdjust(AtomLeast); TermLeast = MkAtomTerm(AtomLeast); + AtomLength = AtomAdjust(AtomLength); TermLength = MkAtomTerm(AtomLength); + AtomList = AtomAdjust(AtomList); TermList = MkAtomTerm(AtomList); + AtomLine = AtomAdjust(AtomLine); TermLine = MkAtomTerm(AtomLine); + AtomLive = AtomAdjust(AtomLive); TermLive = MkAtomTerm(AtomLive); + AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); + AtomLocal = AtomAdjust(AtomLocal); TermLocal = MkAtomTerm(AtomLocal); + AtomLocalSp = AtomAdjust(AtomLocalSp); TermLocalSp = MkAtomTerm(AtomLocalSp); + AtomLocalTrie = AtomAdjust(AtomLocalTrie); TermLocalTrie = MkAtomTerm(AtomLocalTrie); + AtomMax = AtomAdjust(AtomMax); TermMax = MkAtomTerm(AtomMax); + AtomMaximum = AtomAdjust(AtomMaximum); TermMaximum = MkAtomTerm(AtomMaximum); + AtomMaxArity = AtomAdjust(AtomMaxArity); TermMaxArity = MkAtomTerm(AtomMaxArity); + AtomMaxFiles = AtomAdjust(AtomMaxFiles); TermMaxFiles = MkAtomTerm(AtomMaxFiles); + AtomMegaClause = AtomAdjust(AtomMegaClause); TermMegaClause = MkAtomTerm(AtomMegaClause); + AtomMetaCall = AtomAdjust(AtomMetaCall); TermMetaCall = MkAtomTerm(AtomMetaCall); + AtomMfClause = AtomAdjust(AtomMfClause); TermMfClause = MkAtomTerm(AtomMfClause); + AtomMin = AtomAdjust(AtomMin); TermMin = MkAtomTerm(AtomMin); + AtomMinimum = AtomAdjust(AtomMinimum); TermMinimum = MkAtomTerm(AtomMinimum); + AtomMinus = AtomAdjust(AtomMinus); TermMinus = MkAtomTerm(AtomMinus); + AtomModify = AtomAdjust(AtomModify); TermModify = MkAtomTerm(AtomModify); + AtomModule = AtomAdjust(AtomModule); TermModule = MkAtomTerm(AtomModule); + AtomMost = AtomAdjust(AtomMost); TermMost = MkAtomTerm(AtomMost); + AtomMulti = AtomAdjust(AtomMulti); TermMulti = MkAtomTerm(AtomMulti); + AtomMultiFile = AtomAdjust(AtomMultiFile); TermMultiFile = MkAtomTerm(AtomMultiFile); + AtomMultiple = AtomAdjust(AtomMultiple); TermMultiple = MkAtomTerm(AtomMultiple); + AtomMutable = AtomAdjust(AtomMutable); TermMutable = MkAtomTerm(AtomMutable); + AtomMutableVariable = AtomAdjust(AtomMutableVariable); TermMutableVariable = MkAtomTerm(AtomMutableVariable); + AtomMutex = AtomAdjust(AtomMutex); TermMutex = MkAtomTerm(AtomMutex); + AtomMyddasDB = AtomAdjust(AtomMyddasDB); TermMyddasDB = MkAtomTerm(AtomMyddasDB); + AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); + AtomMyddasHost = AtomAdjust(AtomMyddasHost); TermMyddasHost = MkAtomTerm(AtomMyddasHost); + AtomMyddasPass = AtomAdjust(AtomMyddasPass); TermMyddasPass = MkAtomTerm(AtomMyddasPass); + AtomMyddasUser = AtomAdjust(AtomMyddasUser); TermMyddasUser = MkAtomTerm(AtomMyddasUser); + AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); + AtomNan = AtomAdjust(AtomNan); TermNan = MkAtomTerm(AtomNan); + AtomNb = AtomAdjust(AtomNb); TermNb = MkAtomTerm(AtomNb); + AtomNbTerm = AtomAdjust(AtomNbTerm); TermNbTerm = MkAtomTerm(AtomNbTerm); + AtomNew = AtomAdjust(AtomNew); TermNew = MkAtomTerm(AtomNew); + AtomNewLine = AtomAdjust(AtomNewLine); TermNewLine = MkAtomTerm(AtomNewLine); + AtomNl = AtomAdjust(AtomNl); TermNl = MkAtomTerm(AtomNl); + AtomNoEffect = AtomAdjust(AtomNoEffect); TermNoEffect = MkAtomTerm(AtomNoEffect); + AtomNoMemory = AtomAdjust(AtomNoMemory); TermNoMemory = MkAtomTerm(AtomNoMemory); + AtomNone = AtomAdjust(AtomNone); TermNone = MkAtomTerm(AtomNone); + AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); + AtomNot = AtomAdjust(AtomNot); TermNot = MkAtomTerm(AtomNot); + AtomNotImplemented = AtomAdjust(AtomNotImplemented); TermNotImplemented = MkAtomTerm(AtomNotImplemented); + AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); + AtomNotNewline = AtomAdjust(AtomNotNewline); TermNotNewline = MkAtomTerm(AtomNotNewline); + AtomNotZero = AtomAdjust(AtomNotZero); TermNotZero = MkAtomTerm(AtomNotZero); + AtomNumber = AtomAdjust(AtomNumber); TermNumber = MkAtomTerm(AtomNumber); + AtomObj = AtomAdjust(AtomObj); TermObj = MkAtomTerm(AtomObj); + AtomOff = AtomAdjust(AtomOff); TermOff = MkAtomTerm(AtomOff); + AtomOffline = AtomAdjust(AtomOffline); TermOffline = MkAtomTerm(AtomOffline); + AtomOn = AtomAdjust(AtomOn); TermOn = MkAtomTerm(AtomOn); + AtomOnline = AtomAdjust(AtomOnline); TermOnline = MkAtomTerm(AtomOnline); + AtomOpen = AtomAdjust(AtomOpen); TermOpen = MkAtomTerm(AtomOpen); + AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); + AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); + AtomOperator = AtomAdjust(AtomOperator); TermOperator = MkAtomTerm(AtomOperator); + AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); + AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); + AtomOpt = AtomAdjust(AtomOpt); TermOpt = MkAtomTerm(AtomOpt); + AtomOtherwise = AtomAdjust(AtomOtherwise); TermOtherwise = MkAtomTerm(AtomOtherwise); + AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); + AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); + AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); + AtomOutOfRange = AtomAdjust(AtomOutOfRange); TermOutOfRange = MkAtomTerm(AtomOutOfRange); + AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); + AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); + AtomOutput = AtomAdjust(AtomOutput); TermOutput = MkAtomTerm(AtomOutput); + AtomParameter = AtomAdjust(AtomParameter); TermParameter = MkAtomTerm(AtomParameter); + AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); + AtomPast = AtomAdjust(AtomPast); TermPast = MkAtomTerm(AtomPast); + AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); + AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError); + AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi); + AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe); + AtomPriority = AtomAdjust(AtomPriority); TermPriority = MkAtomTerm(AtomPriority); + AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus); + AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer); + AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray); + AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); + AtomPrimitive = AtomAdjust(AtomPrimitive); TermPrimitive = MkAtomTerm(AtomPrimitive); + AtomPrintMessage = AtomAdjust(AtomPrintMessage); TermPrintMessage = MkAtomTerm(AtomPrintMessage); + AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); + AtomProcedure = AtomAdjust(AtomProcedure); TermProcedure = MkAtomTerm(AtomProcedure); + AtomProfile = AtomAdjust(AtomProfile); TermProfile = MkAtomTerm(AtomProfile); + AtomProlog = AtomAdjust(AtomProlog); TermProlog = MkAtomTerm(AtomProlog); + AtomProtectStack = AtomAdjust(AtomProtectStack); TermProtectStack = MkAtomTerm(AtomProtectStack); + AtomQly = AtomAdjust(AtomQly); TermQly = MkAtomTerm(AtomQly); + AtomQuery = AtomAdjust(AtomQuery); TermQuery = MkAtomTerm(AtomQuery); + AtomQueue = AtomAdjust(AtomQueue); TermQueue = MkAtomTerm(AtomQueue); + AtomQuiet = AtomAdjust(AtomQuiet); TermQuiet = MkAtomTerm(AtomQuiet); + AtomRadix = AtomAdjust(AtomRadix); TermRadix = MkAtomTerm(AtomRadix); + AtomRandom = AtomAdjust(AtomRandom); TermRandom = MkAtomTerm(AtomRandom); + AtomRange = AtomAdjust(AtomRange); TermRange = MkAtomTerm(AtomRange); + AtomRDiv = AtomAdjust(AtomRDiv); TermRDiv = MkAtomTerm(AtomRDiv); + AtomRead = AtomAdjust(AtomRead); TermRead = MkAtomTerm(AtomRead); + AtomReadOnly = AtomAdjust(AtomReadOnly); TermReadOnly = MkAtomTerm(AtomReadOnly); + AtomReadWrite = AtomAdjust(AtomReadWrite); TermReadWrite = MkAtomTerm(AtomReadWrite); + AtomReadutil = AtomAdjust(AtomReadutil); TermReadutil = MkAtomTerm(AtomReadutil); + AtomReconsult = AtomAdjust(AtomReconsult); TermReconsult = MkAtomTerm(AtomReconsult); + AtomRecordedP = AtomAdjust(AtomRecordedP); TermRecordedP = MkAtomTerm(AtomRecordedP); + AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); + AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); + AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); + AtomRefoundVar = AtomAdjust(AtomRefoundVar); TermRefoundVar = MkAtomTerm(AtomRefoundVar); + AtomRelativeTo = AtomAdjust(AtomRelativeTo); TermRelativeTo = MkAtomTerm(AtomRelativeTo); + AtomRepeat = AtomAdjust(AtomRepeat); TermRepeat = MkAtomTerm(AtomRepeat); + AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); + AtomReposition = AtomAdjust(AtomReposition); TermReposition = MkAtomTerm(AtomReposition); + AtomRepresentationError = AtomAdjust(AtomRepresentationError); TermRepresentationError = MkAtomTerm(AtomRepresentationError); + AtomReset = AtomAdjust(AtomReset); TermReset = MkAtomTerm(AtomReset); + AtomResize = AtomAdjust(AtomResize); TermResize = MkAtomTerm(AtomResize); + AtomResourceError = AtomAdjust(AtomResourceError); TermResourceError = MkAtomTerm(AtomResourceError); + AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); + AtomRetry = AtomAdjust(AtomRetry); TermRetry = MkAtomTerm(AtomRetry); + AtomRetryCounter = AtomAdjust(AtomRetryCounter); TermRetryCounter = MkAtomTerm(AtomRetryCounter); + AtomRTree = AtomAdjust(AtomRTree); TermRTree = MkAtomTerm(AtomRTree); + AtomSafe = AtomAdjust(AtomSafe); TermSafe = MkAtomTerm(AtomSafe); + AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); + AtomSame = AtomAdjust(AtomSame); TermSame = MkAtomTerm(AtomSame); + AtomSemic = AtomAdjust(AtomSemic); TermSemic = MkAtomTerm(AtomSemic); + AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); + AtomSigAlarm = AtomAdjust(AtomSigAlarm); TermSigAlarm = MkAtomTerm(AtomSigAlarm); + AtomSigBreak = AtomAdjust(AtomSigBreak); TermSigBreak = MkAtomTerm(AtomSigBreak); + AtomSigCreep = AtomAdjust(AtomSigCreep); TermSigCreep = MkAtomTerm(AtomSigCreep); + AtomSigDebug = AtomAdjust(AtomSigDebug); TermSigDebug = MkAtomTerm(AtomSigDebug); + AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); + AtomSigFPE = AtomAdjust(AtomSigFPE); TermSigFPE = MkAtomTerm(AtomSigFPE); + AtomSigHup = AtomAdjust(AtomSigHup); TermSigHup = MkAtomTerm(AtomSigHup); + AtomSigInt = AtomAdjust(AtomSigInt); TermSigInt = MkAtomTerm(AtomSigInt); + AtomSigIti = AtomAdjust(AtomSigIti); TermSigIti = MkAtomTerm(AtomSigIti); + AtomSigPending = AtomAdjust(AtomSigPending); TermSigPending = MkAtomTerm(AtomSigPending); + AtomSigPipe = AtomAdjust(AtomSigPipe); TermSigPipe = MkAtomTerm(AtomSigPipe); + AtomSigStackDump = AtomAdjust(AtomSigStackDump); TermSigStackDump = MkAtomTerm(AtomSigStackDump); + AtomSigStatistics = AtomAdjust(AtomSigStatistics); TermSigStatistics = MkAtomTerm(AtomSigStatistics); + AtomSigTrace = AtomAdjust(AtomSigTrace); TermSigTrace = MkAtomTerm(AtomSigTrace); + AtomSigUsr1 = AtomAdjust(AtomSigUsr1); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); + AtomSigUsr2 = AtomAdjust(AtomSigUsr2); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); + AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); + AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); + AtomSilent = AtomAdjust(AtomSilent); TermSilent = MkAtomTerm(AtomSilent); + AtomSingle = AtomAdjust(AtomSingle); TermSingle = MkAtomTerm(AtomSingle); + AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); + AtomSingleton = AtomAdjust(AtomSingleton); TermSingleton = MkAtomTerm(AtomSingleton); + AtomSlash = AtomAdjust(AtomSlash); TermSlash = MkAtomTerm(AtomSlash); + AtomSocket = AtomAdjust(AtomSocket); TermSocket = MkAtomTerm(AtomSocket); + AtomSolutions = AtomAdjust(AtomSolutions); TermSolutions = MkAtomTerm(AtomSolutions); + AtomSource = AtomAdjust(AtomSource); TermSource = MkAtomTerm(AtomSource); + AtomSourceSink = AtomAdjust(AtomSourceSink); TermSourceSink = MkAtomTerm(AtomSourceSink); + AtomSpy = AtomAdjust(AtomSpy); TermSpy = MkAtomTerm(AtomSpy); + AtomStack = AtomAdjust(AtomStack); TermStack = MkAtomTerm(AtomStack); + AtomStackFree = AtomAdjust(AtomStackFree); TermStackFree = MkAtomTerm(AtomStackFree); + AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); + AtomStaticClause = AtomAdjust(AtomStaticClause); TermStaticClause = MkAtomTerm(AtomStaticClause); + AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); + AtomStream = AtomAdjust(AtomStream); TermStream = MkAtomTerm(AtomStream); + AtomSWIStream = AtomAdjust(AtomSWIStream); TermSWIStream = MkAtomTerm(AtomSWIStream); + AtomVStream = AtomAdjust(AtomVStream); TermVStream = MkAtomTerm(AtomVStream); + AtomStreams = AtomAdjust(AtomStreams); TermStreams = MkAtomTerm(AtomStreams); + AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); + AtomStreamPos = AtomAdjust(AtomStreamPos); TermStreamPos = MkAtomTerm(AtomStreamPos); + AtomStreamPosition = AtomAdjust(AtomStreamPosition); TermStreamPosition = MkAtomTerm(AtomStreamPosition); + AtomString = AtomAdjust(AtomString); TermString = MkAtomTerm(AtomString); + AtomStyleCheck = AtomAdjust(AtomStyleCheck); TermStyleCheck = MkAtomTerm(AtomStyleCheck); + AtomSTRING = AtomAdjust(AtomSTRING); TermSTRING = MkAtomTerm(AtomSTRING); + AtomSwi = AtomAdjust(AtomSwi); TermSwi = MkAtomTerm(AtomSwi); + AtomSymbolChar = AtomAdjust(AtomSymbolChar); TermSymbolChar = MkAtomTerm(AtomSymbolChar); + AtomSyntaxError = AtomAdjust(AtomSyntaxError); TermSyntaxError = MkAtomTerm(AtomSyntaxError); + AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); + AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); + AtomSystem = AtomAdjust(AtomSystem); TermSystem = MkAtomTerm(AtomSystem); + AtomSystemError = AtomAdjust(AtomSystemError); TermSystemError = MkAtomTerm(AtomSystemError); + AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); + AtomT = AtomAdjust(AtomT); TermT = MkAtomTerm(AtomT); + AtomTerm = AtomAdjust(AtomTerm); TermTerm = MkAtomTerm(AtomTerm); + AtomTermExpansion = AtomAdjust(AtomTermExpansion); TermTermExpansion = MkAtomTerm(AtomTermExpansion); + AtomTerms = AtomAdjust(AtomTerms); TermTerms = MkAtomTerm(AtomTerms); + AtomText = AtomAdjust(AtomText); TermText = MkAtomTerm(AtomText); + AtomTextStream = AtomAdjust(AtomTextStream); TermTextStream = MkAtomTerm(AtomTextStream); + AtomThread = AtomAdjust(AtomThread); TermThread = MkAtomTerm(AtomThread); + AtomThreads = AtomAdjust(AtomThreads); TermThreads = MkAtomTerm(AtomThreads); + AtomThrow = AtomAdjust(AtomThrow); TermThrow = MkAtomTerm(AtomThrow); + AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); + AtomTimeoutError = AtomAdjust(AtomTimeoutError); TermTimeoutError = MkAtomTerm(AtomTimeoutError); + AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); + AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); + AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); + AtomTrail = AtomAdjust(AtomTrail); + AtomTrue = AtomAdjust(AtomTrue); TermTrue = MkAtomTerm(AtomTrue); + AtomTty = AtomAdjust(AtomTty); TermTty = MkAtomTerm(AtomTty); + AtomTtys = AtomAdjust(AtomTtys); TermTtys = MkAtomTerm(AtomTtys); + AtomTuple = AtomAdjust(AtomTuple); TermTuple = MkAtomTerm(AtomTuple); + AtomTxt = AtomAdjust(AtomTxt); TermTxt = MkAtomTerm(AtomTxt); + AtomTypeError = AtomAdjust(AtomTypeError); TermTypeError = MkAtomTerm(AtomTypeError); + AtomUndefined = AtomAdjust(AtomUndefined); TermUndefined = MkAtomTerm(AtomUndefined); + AtomUndefp = AtomAdjust(AtomUndefp); TermUndefp = MkAtomTerm(AtomUndefp); + AtomUndefp0 = AtomAdjust(AtomUndefp0); TermUndefp0 = MkAtomTerm(AtomUndefp0); + AtomUnderflow = AtomAdjust(AtomUnderflow); TermUnderflow = MkAtomTerm(AtomUnderflow); + AtomUnificationStack = AtomAdjust(AtomUnificationStack); TermUnificationStack = MkAtomTerm(AtomUnificationStack); + AtomUnique = AtomAdjust(AtomUnique); TermUnique = MkAtomTerm(AtomUnique); + AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); + AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); + AtomUser = AtomAdjust(AtomUser); TermUser = MkAtomTerm(AtomUser); + AtomUserErr = AtomAdjust(AtomUserErr); TermUserErr = MkAtomTerm(AtomUserErr); + AtomUserIn = AtomAdjust(AtomUserIn); TermUserIn = MkAtomTerm(AtomUserIn); + AtomUserOut = AtomAdjust(AtomUserOut); TermUserOut = MkAtomTerm(AtomUserOut); + AtomDollarVar = AtomAdjust(AtomDollarVar); TermDollarVar = MkAtomTerm(AtomDollarVar); + AtomVBar = AtomAdjust(AtomVBar); TermVBar = MkAtomTerm(AtomVBar); + AtomVarBranches = AtomAdjust(AtomVarBranches); TermVarBranches = MkAtomTerm(AtomVarBranches); + AtomVariableNames = AtomAdjust(AtomVariableNames); TermVariableNames = MkAtomTerm(AtomVariableNames); + AtomHiddenVar = AtomAdjust(AtomHiddenVar); TermHiddenVar = MkAtomTerm(AtomHiddenVar); + AtomVariable = AtomAdjust(AtomVariable); TermVariable = MkAtomTerm(AtomVariable); + AtomVerbose = AtomAdjust(AtomVerbose); TermVerbose = MkAtomTerm(AtomVerbose); + AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); + AtomVersionNumber = AtomAdjust(AtomVersionNumber); TermVersionNumber = MkAtomTerm(AtomVersionNumber); + AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); + AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); + AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning); + AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen); + AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite); + AtomWriteTerm = AtomAdjust(AtomWriteTerm); TermWriteTerm = MkAtomTerm(AtomWriteTerm); + AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml); + AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks); + AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); + FunctorAfInet = FuncAdjust(FunctorAfInet); + FunctorAfLocal = FuncAdjust(FunctorAfLocal); + FunctorAfUnix = FuncAdjust(FunctorAfUnix); + FunctorAltNot = FuncAdjust(FunctorAltNot); + FunctorArg = FuncAdjust(FunctorArg); + FunctorArrayEntry = FuncAdjust(FunctorArrayEntry); + FunctorArrow = FuncAdjust(FunctorArrow); + FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); + FunctorAssert1 = FuncAdjust(FunctorAssert1); + FunctorAssert = FuncAdjust(FunctorAssert); + FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne); + FunctorAtom = FuncAdjust(FunctorAtom); + FunctorAtt1 = FuncAdjust(FunctorAtt1); + FunctorAttGoal = FuncAdjust(FunctorAttGoal); + FunctorBraces = FuncAdjust(FunctorBraces); + FunctorCall = FuncAdjust(FunctorCall); + FunctorCatch = FuncAdjust(FunctorCatch); + FunctorChangeModule = FuncAdjust(FunctorChangeModule); + FunctorChars = FuncAdjust(FunctorChars); + FunctorChars1 = FuncAdjust(FunctorChars1); + FunctorCleanCall = FuncAdjust(FunctorCleanCall); + FunctorClist = FuncAdjust(FunctorClist); + FunctorCodes = FuncAdjust(FunctorCodes); + FunctorCodes1 = FuncAdjust(FunctorCodes1); + FunctorColon = FuncAdjust(FunctorColon); + FunctorComma = FuncAdjust(FunctorComma); + FunctorCommentHook = FuncAdjust(FunctorCommentHook); + FunctorContext2 = FuncAdjust(FunctorContext2); + FunctorConsistencyError = FuncAdjust(FunctorConsistencyError); + FunctorCreep = FuncAdjust(FunctorCreep); + FunctorCsult = FuncAdjust(FunctorCsult); + FunctorCurrentModule = FuncAdjust(FunctorCurrentModule); + FunctorCutBy = FuncAdjust(FunctorCutBy); + FunctorDBREF = FuncAdjust(FunctorDBREF); + FunctorDiff = FuncAdjust(FunctorDiff); + FunctorDoLogUpdClause = FuncAdjust(FunctorDoLogUpdClause); + FunctorDoLogUpdClause0 = FuncAdjust(FunctorDoLogUpdClause0); + FunctorDoLogUpdClauseErase = FuncAdjust(FunctorDoLogUpdClauseErase); + FunctorDoStaticClause = FuncAdjust(FunctorDoStaticClause); + FunctorDollar = FuncAdjust(FunctorDollar); + FunctorDollarVar = FuncAdjust(FunctorDollarVar); + FunctorDomainError = FuncAdjust(FunctorDomainError); + FunctorDot = FuncAdjust(FunctorDot); + FunctorDot10 = FuncAdjust(FunctorDot10); + FunctorDot11 = FuncAdjust(FunctorDot11); + FunctorDot12 = FuncAdjust(FunctorDot12); + FunctorDot2 = FuncAdjust(FunctorDot2); + FunctorDot3 = FuncAdjust(FunctorDot3); + FunctorDot4 = FuncAdjust(FunctorDot4); + FunctorDot5 = FuncAdjust(FunctorDot5); + FunctorDot6 = FuncAdjust(FunctorDot6); + FunctorDot7 = FuncAdjust(FunctorDot7); + FunctorDot8 = FuncAdjust(FunctorDot8); + FunctorDot9 = FuncAdjust(FunctorDot9); + FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); + FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash); + FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets); + FunctorEq = FuncAdjust(FunctorEq); + FunctorError = FuncAdjust(FunctorError); + FunctorEvaluationError = FuncAdjust(FunctorEvaluationError); + FunctorException = FuncAdjust(FunctorException); + FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod); + FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod); + FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin); + FunctorExistenceError = FuncAdjust(FunctorExistenceError); + FunctorExoClause = FuncAdjust(FunctorExoClause); + FunctorFunctor = FuncAdjust(FunctorFunctor); + FunctorGAtom = FuncAdjust(FunctorGAtom); + FunctorGAtomic = FuncAdjust(FunctorGAtomic); + FunctorGCompound = FuncAdjust(FunctorGCompound); + FunctorGFloat = FuncAdjust(FunctorGFloat); + FunctorGFormatAt = FuncAdjust(FunctorGFormatAt); + FunctorGInteger = FuncAdjust(FunctorGInteger); + FunctorGNumber = FuncAdjust(FunctorGNumber); + FunctorGPrimitive = FuncAdjust(FunctorGPrimitive); + FunctorGVar = FuncAdjust(FunctorGVar); + FunctorGeneratePredInfo = FuncAdjust(FunctorGeneratePredInfo); + FunctorGoalExpansion2 = FuncAdjust(FunctorGoalExpansion2); + FunctorGoalExpansion = FuncAdjust(FunctorGoalExpansion); + FunctorHandleThrow = FuncAdjust(FunctorHandleThrow); + FunctorHat = FuncAdjust(FunctorHat); + FunctorI = FuncAdjust(FunctorI); + FunctorId = FuncAdjust(FunctorId); + FunctorInfo1 = FuncAdjust(FunctorInfo1); + FunctorInfo2 = FuncAdjust(FunctorInfo2); + FunctorInfo3 = FuncAdjust(FunctorInfo3); + FunctorInfo4 = FuncAdjust(FunctorInfo4); + FunctorIs = FuncAdjust(FunctorIs); + FunctorJ = FuncAdjust(FunctorJ); + FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin); + FunctorList = FuncAdjust(FunctorList); + FunctorLOOP = FuncAdjust(FunctorLOOP); + FunctorMegaClause = FuncAdjust(FunctorMegaClause); + FunctorMetaCall = FuncAdjust(FunctorMetaCall); + FunctorMinus = FuncAdjust(FunctorMinus); + FunctorModule = FuncAdjust(FunctorModule); + FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause); + FunctorMutable = FuncAdjust(FunctorMutable); + FunctorMutex = FuncAdjust(FunctorMutex); + FunctorNotImplemented = FuncAdjust(FunctorNotImplemented); + FunctorNBQueue = FuncAdjust(FunctorNBQueue); + FunctorNot = FuncAdjust(FunctorNot); + FunctorObj = FuncAdjust(FunctorObj); + FunctorOr = FuncAdjust(FunctorOr); + FunctorOutput = FuncAdjust(FunctorOutput); + FunctorPermissionError = FuncAdjust(FunctorPermissionError); + FunctorPlus = FuncAdjust(FunctorPlus); + FunctorPortray = FuncAdjust(FunctorPortray); + FunctorPrintMessage = FuncAdjust(FunctorPrintMessage); + FunctorProcedure = FuncAdjust(FunctorProcedure); + FunctorPriority = FuncAdjust(FunctorPriority); + FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint); + FunctorProtectStack = FuncAdjust(FunctorProtectStack); + FunctorQuery = FuncAdjust(FunctorQuery); + FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey); + FunctorRDiv = FuncAdjust(FunctorRDiv); + FunctorRedoFreeze = FuncAdjust(FunctorRedoFreeze); + FunctorRepresentationError = FuncAdjust(FunctorRepresentationError); + FunctorResourceError = FuncAdjust(FunctorResourceError); + FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs); + FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1); + FunctorSafe = FuncAdjust(FunctorSafe); + FunctorSafeCallCleanup = FuncAdjust(FunctorSafeCallCleanup); + FunctorSame = FuncAdjust(FunctorSame); + FunctorSlash = FuncAdjust(FunctorSlash); + FunctorStaticClause = FuncAdjust(FunctorStaticClause); + FunctorStream = FuncAdjust(FunctorStream); + FunctorStreamEOS = FuncAdjust(FunctorStreamEOS); + FunctorStreamPos = FuncAdjust(FunctorStreamPos); + FunctorString1 = FuncAdjust(FunctorString1); + FunctorStyleCheck = FuncAdjust(FunctorStyleCheck); + FunctorSyntaxError = FuncAdjust(FunctorSyntaxError); + FunctorShortSyntaxError = FuncAdjust(FunctorShortSyntaxError); + FunctorTermExpansion = FuncAdjust(FunctorTermExpansion); + FunctorThreadRun = FuncAdjust(FunctorThreadRun); + FunctorThrow = FuncAdjust(FunctorThrow); + FunctorTimeoutError = FuncAdjust(FunctorTimeoutError); + FunctorTraceMetaCall = FuncAdjust(FunctorTraceMetaCall); + FunctorTypeError = FuncAdjust(FunctorTypeError); + FunctorUMinus = FuncAdjust(FunctorUMinus); + FunctorUPlus = FuncAdjust(FunctorUPlus); + FunctorVBar = FuncAdjust(FunctorVBar); + FunctorWriteTerm = FuncAdjust(FunctorWriteTerm); + FunctorHiddenVar = FuncAdjust(FunctorHiddenVar); diff --git a/H/generated/rlocals.h b/H/generated/rlocals.h index 77f95bc68..cddc0d9f2 100644 --- a/H/generated/rlocals.h +++ b/H/generated/rlocals.h @@ -145,6 +145,7 @@ static void RestoreWorker(int wid USES_REGS) { + #ifdef THREADS #endif /* THREADS */ diff --git a/H/generated/tatoms.h b/H/generated/tatoms.h index 561d48c72..beee9ff0c 100644 --- a/H/generated/tatoms.h +++ b/H/generated/tatoms.h @@ -1,728 +1,1161 @@ - - /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" - {lease do not update, update misc/ATOMS instead */ - -EXTERNAL Atom Atom3Dots; -EXTERNAL Atom AtomAbol; EXTERNAL Term TermAbol; -EXTERNAL Atom AtomAccess; EXTERNAL Term TermAccess; -EXTERNAL Atom AtomAfInet; EXTERNAL Term TermAfInet; -EXTERNAL Atom AtomAfLocal; EXTERNAL Term TermAfLocal; -EXTERNAL Atom AtomAfUnix; EXTERNAL Term TermAfUnix; -EXTERNAL Atom AtomAlarm; EXTERNAL Term TermAlarm; -EXTERNAL Atom AtomAlias; EXTERNAL Term TermAlias; -EXTERNAL Atom AtomAll; EXTERNAL Term TermAll; -EXTERNAL Atom AtomAltNot; EXTERNAL Term TermAltNot; -EXTERNAL Atom AtomAnswer; EXTERNAL Term TermAnswer; -EXTERNAL Atom AtomAny; EXTERNAL Term TermAny; -EXTERNAL Atom AtomAppend; EXTERNAL Term TermAppend; -EXTERNAL Atom AtomArg; EXTERNAL Term TermArg; -EXTERNAL Atom AtomArray; EXTERNAL Term TermArray; -EXTERNAL Atom AtomArrayAccess; EXTERNAL Term TermArrayAccess; -EXTERNAL Atom AtomArrayOverflow; EXTERNAL Term TermArrayOverflow; -EXTERNAL Atom AtomArrayType; EXTERNAL Term TermArrayType; -EXTERNAL Atom AtomArrow; EXTERNAL Term TermArrow; -EXTERNAL Atom AtomAttributedModule; EXTERNAL Term TermAttributedModule; -EXTERNAL Atom AtomDoubleArrow; EXTERNAL Term TermDoubleArrow; -EXTERNAL Atom AtomAssert; EXTERNAL Term TermAssert; -EXTERNAL Atom AtomBeginBracket; EXTERNAL Term TermBeginBracket; -EXTERNAL Atom AtomEndBracket; EXTERNAL Term TermEndBracket; -EXTERNAL Atom AtomBeginSquareBracket; EXTERNAL Term TermBeginSquareBracket; -EXTERNAL Atom AtomEndSquareBracket; EXTERNAL Term TermEndSquareBracket; -EXTERNAL Atom AtomBeginCurlyBracket; EXTERNAL Term TermBeginCurlyBracket; -EXTERNAL Atom AtomEndCurlyBracket; EXTERNAL Term TermEndCurlyBracket; -EXTERNAL Atom AtomEmptyBrackets; EXTERNAL Term TermEmptyBrackets; -EXTERNAL Atom AtomEmptySquareBrackets; EXTERNAL Term TermEmptySquareBrackets; -EXTERNAL Atom AtomAsserta; EXTERNAL Term TermAsserta; -EXTERNAL Atom AtomAssertaStatic; EXTERNAL Term TermAssertaStatic; -EXTERNAL Atom AtomAssertz; EXTERNAL Term TermAssertz; -EXTERNAL Atom AtomAssertzStatic; EXTERNAL Term TermAssertzStatic; -EXTERNAL Atom AtomAt; EXTERNAL Term TermAt; -EXTERNAL Atom AtomAtom; EXTERNAL Term TermAtom; -EXTERNAL Atom AtomAtomic; EXTERNAL Term TermAtomic; -EXTERNAL Atom AtomAtt; EXTERNAL Term TermAtt; -EXTERNAL Atom AtomAtt1; EXTERNAL Term TermAtt1; -EXTERNAL Atom AtomAttDo; EXTERNAL Term TermAttDo; -EXTERNAL Atom AtomAttributes; EXTERNAL Term TermAttributes; -EXTERNAL Atom AtomB; EXTERNAL Term TermB; -EXTERNAL Atom AtomBatched; EXTERNAL Term TermBatched; -EXTERNAL Atom AtomBetween; EXTERNAL Term TermBetween; -EXTERNAL Atom AtomBinary; EXTERNAL Term TermBinary; -EXTERNAL Atom AtomBigNum; EXTERNAL Term TermBigNum; -EXTERNAL Atom AtomBinaryStream; EXTERNAL Term TermBinaryStream; -EXTERNAL Atom AtomBoolean; EXTERNAL Term TermBoolean; -EXTERNAL Atom AtomBraces; EXTERNAL Term TermBraces; -EXTERNAL Atom AtomBreak; EXTERNAL Term TermBreak; -EXTERNAL Atom AtomByte; EXTERNAL Term TermByte; -EXTERNAL Atom AtomCArith; EXTERNAL Term TermCArith; -EXTERNAL Atom AtomCall; EXTERNAL Term TermCall; -EXTERNAL Atom AtomCallAndRetryCounter; EXTERNAL Term TermCallAndRetryCounter; -EXTERNAL Atom AtomCallCounter; EXTERNAL Term TermCallCounter; -EXTERNAL Atom AtomCallable; EXTERNAL Term TermCallable; -EXTERNAL Atom AtomCatch; EXTERNAL Term TermCatch; -EXTERNAL Atom AtomChangeModule; EXTERNAL Term TermChangeModule; -EXTERNAL Atom AtomChar; EXTERNAL Term TermChar; -EXTERNAL Atom AtomCharsio; EXTERNAL Term TermCharsio; -EXTERNAL Atom AtomCharacter; EXTERNAL Term TermCharacter; -EXTERNAL Atom AtomCharacterCode; EXTERNAL Term TermCharacterCode; -EXTERNAL Atom AtomChars; EXTERNAL Term TermChars; -EXTERNAL Atom AtomCharset; EXTERNAL Term TermCharset; -EXTERNAL Atom AtomChType; EXTERNAL Term TermChType; -EXTERNAL Atom AtomCleanCall; EXTERNAL Term TermCleanCall; -EXTERNAL Atom AtomClose; EXTERNAL Term TermClose; -EXTERNAL Atom AtomColon; EXTERNAL Term TermColon; -EXTERNAL Atom AtomCodeSpace; EXTERNAL Term TermCodeSpace; -EXTERNAL Atom AtomCodes; EXTERNAL Term TermCodes; -EXTERNAL Atom AtomCoInductive; EXTERNAL Term TermCoInductive; -EXTERNAL Atom AtomComma; EXTERNAL Term TermComma; -EXTERNAL Atom AtomCommentHook; EXTERNAL Term TermCommentHook; -EXTERNAL Atom AtomCompact; EXTERNAL Term TermCompact; -EXTERNAL Atom AtomCompound; EXTERNAL Term TermCompound; -EXTERNAL Atom AtomConsistencyError; EXTERNAL Term TermConsistencyError; -EXTERNAL Atom AtomConsult; EXTERNAL Term TermConsult; -EXTERNAL Atom AtomConsultOnBoot; EXTERNAL Term TermConsultOnBoot; -EXTERNAL Atom AtomContext; EXTERNAL Term TermContext; -EXTERNAL Atom AtomCputime; EXTERNAL Term TermCputime; -EXTERNAL Atom AtomCreate; EXTERNAL Term TermCreate; -EXTERNAL Atom AtomCreep; EXTERNAL Term TermCreep; -EXTERNAL Atom AtomCryptAtoms; EXTERNAL Term TermCryptAtoms; -EXTERNAL Atom AtomCurly; EXTERNAL Term TermCurly; -EXTERNAL Atom AtomCsult; EXTERNAL Term TermCsult; -EXTERNAL Atom AtomCurrentModule; EXTERNAL Term TermCurrentModule; -EXTERNAL Atom AtomCut; EXTERNAL Term TermCut; -EXTERNAL Atom AtomCutBy; EXTERNAL Term TermCutBy; -EXTERNAL Atom AtomDAbort; EXTERNAL Term TermDAbort; -EXTERNAL Atom AtomDBLoad; EXTERNAL Term TermDBLoad; -EXTERNAL Atom AtomDBREF; EXTERNAL Term TermDBREF; -EXTERNAL Atom AtomDBReference; EXTERNAL Term TermDBReference; -EXTERNAL Atom AtomDBTerm; EXTERNAL Term TermDBTerm; -EXTERNAL Atom AtomDBref; EXTERNAL Term TermDBref; -EXTERNAL Atom AtomDInteger; EXTERNAL Term TermDInteger; -EXTERNAL Atom AtomDebugMeta; EXTERNAL Term TermDebugMeta; -EXTERNAL Atom AtomDebuggerInput; EXTERNAL Term TermDebuggerInput; -EXTERNAL Atom AtomDec10; EXTERNAL Term TermDec10; -EXTERNAL Atom AtomDefault; EXTERNAL Term TermDefault; -EXTERNAL Atom AtomDevNull; EXTERNAL Term TermDevNull; -EXTERNAL Atom AtomDiff; EXTERNAL Term TermDiff; -EXTERNAL Atom AtomDirectory; EXTERNAL Term TermDirectory; -EXTERNAL Atom AtomDiscontiguous; EXTERNAL Term TermDiscontiguous; -EXTERNAL Atom AtomDiscontiguousWarnings; EXTERNAL Term TermDiscontiguousWarnings; -EXTERNAL Atom AtomDollar; EXTERNAL Term TermDollar; -EXTERNAL Atom AtomDoLogUpdClause; EXTERNAL Term TermDoLogUpdClause; -EXTERNAL Atom AtomDoLogUpdClause0; EXTERNAL Term TermDoLogUpdClause0; -EXTERNAL Atom AtomDoLogUpdClauseErase; EXTERNAL Term TermDoLogUpdClauseErase; -EXTERNAL Atom AtomDollarU; EXTERNAL Term TermDollarU; -EXTERNAL Atom AtomDollarUndef; EXTERNAL Term TermDollarUndef; -EXTERNAL Atom AtomDomainError; EXTERNAL Term TermDomainError; -EXTERNAL Atom AtomDoStaticClause; EXTERNAL Term TermDoStaticClause; -EXTERNAL Atom AtomDots; EXTERNAL Term TermDots; -EXTERNAL Atom AtomDOUBLE; EXTERNAL Term TermDOUBLE; -EXTERNAL Atom AtomDoubleSlash; EXTERNAL Term TermDoubleSlash; -EXTERNAL Atom AtomE; EXTERNAL Term TermE; -EXTERNAL Atom AtomEOFBeforeEOT; EXTERNAL Term TermEOFBeforeEOT; -EXTERNAL Atom AtomEQ; EXTERNAL Term TermEQ; -EXTERNAL Atom AtomEmptyAtom; EXTERNAL Term TermEmptyAtom; -EXTERNAL Atom AtomEncoding; EXTERNAL Term TermEncoding; -EXTERNAL Atom AtomEndOfStream; EXTERNAL Term TermEndOfStream; -EXTERNAL Atom AtomEof; EXTERNAL Term TermEof; -EXTERNAL Atom AtomEOfCode; EXTERNAL Term TermEOfCode; -EXTERNAL Atom AtomEq; EXTERNAL Term TermEq; -EXTERNAL Atom AtomError; EXTERNAL Term TermError; -EXTERNAL Atom AtomException; EXTERNAL Term TermException; -EXTERNAL Atom AtomExtensions; EXTERNAL Term TermExtensions; -EXTERNAL Atom AtomEvaluable; EXTERNAL Term TermEvaluable; -EXTERNAL Atom AtomEvaluationError; EXTERNAL Term TermEvaluationError; -EXTERNAL Atom AtomExecutable; EXTERNAL Term TermExecutable; -EXTERNAL Atom AtomExecute; EXTERNAL Term TermExecute; -EXTERNAL Atom AtomExecAnswers; EXTERNAL Term TermExecAnswers; -EXTERNAL Atom AtomExecuteInMod; EXTERNAL Term TermExecuteInMod; -EXTERNAL Atom AtomExecuteWithin; EXTERNAL Term TermExecuteWithin; -EXTERNAL Atom AtomExecuteWoMod; EXTERNAL Term TermExecuteWoMod; -EXTERNAL Atom AtomExist; EXTERNAL Term TermExist; -EXTERNAL Atom AtomExists; EXTERNAL Term TermExists; -EXTERNAL Atom AtomExit; EXTERNAL Term TermExit; -EXTERNAL Atom AtomExistenceError; EXTERNAL Term TermExistenceError; -EXTERNAL Atom AtomExoClause; EXTERNAL Term TermExoClause; -EXTERNAL Atom AtomExpectedNumber; EXTERNAL Term TermExpectedNumber; -EXTERNAL Atom AtomExpand; EXTERNAL Term TermExpand; -EXTERNAL Atom AtomExtendFileSearchPath; EXTERNAL Term TermExtendFileSearchPath; -EXTERNAL Atom AtomExtendsions; EXTERNAL Term TermExtendsions; -EXTERNAL Atom AtomFB; EXTERNAL Term TermFB; -EXTERNAL Atom AtomFail; EXTERNAL Term TermFail; -EXTERNAL Atom AtomFalse; EXTERNAL Term TermFalse; -EXTERNAL Atom AtomFast; EXTERNAL Term TermFast; -EXTERNAL Atom AtomFastFail; EXTERNAL Term TermFastFail; -EXTERNAL Atom AtomFileErrors; EXTERNAL Term TermFileErrors; -EXTERNAL Atom AtomFileerrors; EXTERNAL Term TermFileerrors; -EXTERNAL Atom AtomFileType; EXTERNAL Term TermFileType; -EXTERNAL Atom AtomFirst; EXTERNAL Term TermFirst; -EXTERNAL Atom AtomFloat; EXTERNAL Term TermFloat; -EXTERNAL Atom AtomFloatFormat; EXTERNAL Term TermFloatFormat; -EXTERNAL Atom AtomFloatOverflow; EXTERNAL Term TermFloatOverflow; -EXTERNAL Atom AtomFloatUnderflow; EXTERNAL Term TermFloatUnderflow; -EXTERNAL Atom AtomFormat; EXTERNAL Term TermFormat; -EXTERNAL Atom AtomFormatAt; EXTERNAL Term TermFormatAt; -EXTERNAL Atom AtomFull; EXTERNAL Term TermFull; -EXTERNAL Atom AtomFunctor; EXTERNAL Term TermFunctor; -EXTERNAL Atom AtomGT; EXTERNAL Term TermGT; -EXTERNAL Atom AtomGVar; EXTERNAL Term TermGVar; -EXTERNAL Atom AtomGc; EXTERNAL Term TermGc; -EXTERNAL Atom AtomGcMargin; EXTERNAL Term TermGcMargin; -EXTERNAL Atom AtomGcTrace; EXTERNAL Term TermGcTrace; -EXTERNAL Atom AtomGcVerbose; EXTERNAL Term TermGcVerbose; -EXTERNAL Atom AtomGcVeryVerbose; EXTERNAL Term TermGcVeryVerbose; -EXTERNAL Atom AtomGeneratePredInfo; EXTERNAL Term TermGeneratePredInfo; -EXTERNAL Atom AtomGetwork; EXTERNAL Term TermGetwork; -EXTERNAL Atom AtomGetworkSeq; EXTERNAL Term TermGetworkSeq; -EXTERNAL Atom AtomGlob; EXTERNAL Term TermGlob; -EXTERNAL Atom AtomGlobal; EXTERNAL Term TermGlobal; -EXTERNAL Atom AtomGlobalSp; EXTERNAL Term TermGlobalSp; -EXTERNAL Atom AtomGlobalTrie; EXTERNAL Term TermGlobalTrie; -EXTERNAL Atom AtomGoalExpansion; EXTERNAL Term TermGoalExpansion; -EXTERNAL Atom AtomHat; EXTERNAL Term TermHat; -EXTERNAL Atom AtomHERE; EXTERNAL Term TermHERE; -EXTERNAL Atom AtomHandleThrow; EXTERNAL Term TermHandleThrow; -EXTERNAL Atom AtomHeap; EXTERNAL Term TermHeap; -EXTERNAL Atom AtomHeapUsed; EXTERNAL Term TermHeapUsed; -EXTERNAL Atom AtomHugeInt; EXTERNAL Term TermHugeInt; -EXTERNAL Atom AtomIDB; EXTERNAL Term TermIDB; -EXTERNAL Atom AtomIOMode; EXTERNAL Term TermIOMode; -EXTERNAL Atom AtomI; EXTERNAL Term TermI; -EXTERNAL Atom AtomId; EXTERNAL Term TermId; -EXTERNAL Atom AtomIgnore; EXTERNAL Term TermIgnore; -EXTERNAL Atom AtomInf; EXTERNAL Term TermInf; -EXTERNAL Atom AtomInfinity; EXTERNAL Term TermInfinity; -EXTERNAL Atom AtomInfo; EXTERNAL Term TermInfo; -EXTERNAL Atom AtomInitGoal; EXTERNAL Term TermInitGoal; -EXTERNAL Atom AtomInitProlog; EXTERNAL Term TermInitProlog; -EXTERNAL Atom AtomInStackExpansion; EXTERNAL Term TermInStackExpansion; -EXTERNAL Atom AtomInput; EXTERNAL Term TermInput; -EXTERNAL Atom AtomInstantiationError; EXTERNAL Term TermInstantiationError; -EXTERNAL Atom AtomInt; EXTERNAL Term TermInt; -EXTERNAL Atom AtomIntOverflow; EXTERNAL Term TermIntOverflow; -EXTERNAL Atom AtomInteger; EXTERNAL Term TermInteger; -EXTERNAL Atom AtomInternalCompilerError; EXTERNAL Term TermInternalCompilerError; -EXTERNAL Atom AtomIs; EXTERNAL Term TermIs; -EXTERNAL Atom AtomJ; EXTERNAL Term TermJ; -EXTERNAL Atom Atoml; EXTERNAL Term Terml; -EXTERNAL Atom AtomKey; EXTERNAL Term TermKey; -EXTERNAL Atom AtomLDLibraryPath; EXTERNAL Term TermLDLibraryPath; -EXTERNAL Atom AtomLONGINT; EXTERNAL Term TermLONGINT; -EXTERNAL Atom AtomLOOP; EXTERNAL Term TermLOOP; -EXTERNAL Atom AtomLoopStream; EXTERNAL Term TermLoopStream; -EXTERNAL Atom AtomLT; EXTERNAL Term TermLT; -EXTERNAL Atom AtomLastExecuteWithin; EXTERNAL Term TermLastExecuteWithin; -EXTERNAL Atom AtomLeash; EXTERNAL Term TermLeash; -EXTERNAL Atom AtomLeast; EXTERNAL Term TermLeast; -EXTERNAL Atom AtomLength; EXTERNAL Term TermLength; -EXTERNAL Atom AtomList; EXTERNAL Term TermList; -EXTERNAL Atom AtomLine; EXTERNAL Term TermLine; -EXTERNAL Atom AtomLive; EXTERNAL Term TermLive; -EXTERNAL Atom AtomLoadAnswers; EXTERNAL Term TermLoadAnswers; -EXTERNAL Atom AtomLocal; EXTERNAL Term TermLocal; -EXTERNAL Atom AtomLocalSp; EXTERNAL Term TermLocalSp; -EXTERNAL Atom AtomLocalTrie; EXTERNAL Term TermLocalTrie; -EXTERNAL Atom AtomMax; EXTERNAL Term TermMax; -EXTERNAL Atom AtomMaximum; EXTERNAL Term TermMaximum; -EXTERNAL Atom AtomMaxArity; EXTERNAL Term TermMaxArity; -EXTERNAL Atom AtomMaxFiles; EXTERNAL Term TermMaxFiles; -EXTERNAL Atom AtomMegaClause; EXTERNAL Term TermMegaClause; -EXTERNAL Atom AtomMetaCall; EXTERNAL Term TermMetaCall; -EXTERNAL Atom AtomMfClause; EXTERNAL Term TermMfClause; -EXTERNAL Atom AtomMin; EXTERNAL Term TermMin; -EXTERNAL Atom AtomMinimum; EXTERNAL Term TermMinimum; -EXTERNAL Atom AtomMinus; EXTERNAL Term TermMinus; -EXTERNAL Atom AtomModify; EXTERNAL Term TermModify; -EXTERNAL Atom AtomModule; EXTERNAL Term TermModule; -EXTERNAL Atom AtomMost; EXTERNAL Term TermMost; -EXTERNAL Atom AtomMulti; EXTERNAL Term TermMulti; -EXTERNAL Atom AtomMultiFile; EXTERNAL Term TermMultiFile; -EXTERNAL Atom AtomMultiple; EXTERNAL Term TermMultiple; -EXTERNAL Atom AtomMutable; EXTERNAL Term TermMutable; -EXTERNAL Atom AtomMutableVariable; EXTERNAL Term TermMutableVariable; -EXTERNAL Atom AtomMutex; EXTERNAL Term TermMutex; -EXTERNAL Atom AtomMyddasDB; EXTERNAL Term TermMyddasDB; -EXTERNAL Atom AtomMyddasGoal; EXTERNAL Term TermMyddasGoal; -EXTERNAL Atom AtomMyddasHost; EXTERNAL Term TermMyddasHost; -EXTERNAL Atom AtomMyddasPass; EXTERNAL Term TermMyddasPass; -EXTERNAL Atom AtomMyddasUser; EXTERNAL Term TermMyddasUser; -EXTERNAL Atom AtomMyddasVersionName; EXTERNAL Term TermMyddasVersionName; -EXTERNAL Atom AtomNan; EXTERNAL Term TermNan; -EXTERNAL Atom AtomNb; EXTERNAL Term TermNb; -EXTERNAL Atom AtomNbTerm; EXTERNAL Term TermNbTerm; -EXTERNAL Atom AtomNew; EXTERNAL Term TermNew; -EXTERNAL Atom AtomNewLine; EXTERNAL Term TermNewLine; -EXTERNAL Atom AtomNl; EXTERNAL Term TermNl; -EXTERNAL Atom AtomNoEffect; EXTERNAL Term TermNoEffect; -EXTERNAL Atom AtomNoMemory; EXTERNAL Term TermNoMemory; -EXTERNAL Atom AtomNone; EXTERNAL Term TermNone; -EXTERNAL Atom AtomNonEmptyList; EXTERNAL Term TermNonEmptyList; -EXTERNAL Atom AtomNot; EXTERNAL Term TermNot; -EXTERNAL Atom AtomNotImplemented; EXTERNAL Term TermNotImplemented; -EXTERNAL Atom AtomNotLessThanZero; EXTERNAL Term TermNotLessThanZero; -EXTERNAL Atom AtomNotNewline; EXTERNAL Term TermNotNewline; -EXTERNAL Atom AtomNotZero; EXTERNAL Term TermNotZero; -EXTERNAL Atom AtomNumber; EXTERNAL Term TermNumber; -EXTERNAL Atom AtomObj; EXTERNAL Term TermObj; -EXTERNAL Atom AtomOff; EXTERNAL Term TermOff; -EXTERNAL Atom AtomOffline; EXTERNAL Term TermOffline; -EXTERNAL Atom AtomOn; EXTERNAL Term TermOn; -EXTERNAL Atom AtomOnline; EXTERNAL Term TermOnline; -EXTERNAL Atom AtomOpen; EXTERNAL Term TermOpen; -EXTERNAL Atom AtomOperatingSystemError; EXTERNAL Term TermOperatingSystemError; -EXTERNAL Atom AtomOperatingSystemSupport; EXTERNAL Term TermOperatingSystemSupport; -EXTERNAL Atom AtomOperator; EXTERNAL Term TermOperator; -EXTERNAL Atom AtomOperatorPriority; EXTERNAL Term TermOperatorPriority; -EXTERNAL Atom AtomOperatorSpecifier; EXTERNAL Term TermOperatorSpecifier; -EXTERNAL Atom AtomOpt; EXTERNAL Term TermOpt; -EXTERNAL Atom AtomOtherwise; EXTERNAL Term TermOtherwise; -EXTERNAL Atom AtomOutOfAttvarsError; EXTERNAL Term TermOutOfAttvarsError; -EXTERNAL Atom AtomOutOfAuxspaceError; EXTERNAL Term TermOutOfAuxspaceError; -EXTERNAL Atom AtomOutOfHeapError; EXTERNAL Term TermOutOfHeapError; -EXTERNAL Atom AtomOutOfRange; EXTERNAL Term TermOutOfRange; -EXTERNAL Atom AtomOutOfStackError; EXTERNAL Term TermOutOfStackError; -EXTERNAL Atom AtomOutOfTrailError; EXTERNAL Term TermOutOfTrailError; -EXTERNAL Atom AtomOutput; EXTERNAL Term TermOutput; -EXTERNAL Atom AtomParameter; EXTERNAL Term TermParameter; -EXTERNAL Atom AtomPrologCommonsDir; EXTERNAL Term TermPrologCommonsDir; -EXTERNAL Atom AtomPast; EXTERNAL Term TermPast; -EXTERNAL Atom AtomPastEndOfStream; EXTERNAL Term TermPastEndOfStream; -EXTERNAL Atom AtomPermissionError; EXTERNAL Term TermPermissionError; -EXTERNAL Atom AtomPi; EXTERNAL Term TermPi; -EXTERNAL Atom AtomPipe; EXTERNAL Term TermPipe; -EXTERNAL Atom AtomPriority; EXTERNAL Term TermPriority; -EXTERNAL Atom AtomPlus; EXTERNAL Term TermPlus; -EXTERNAL Atom AtomPointer; EXTERNAL Term TermPointer; -EXTERNAL Atom AtomPortray; EXTERNAL Term TermPortray; -EXTERNAL Atom AtomPredicateIndicator; EXTERNAL Term TermPredicateIndicator; -EXTERNAL Atom AtomPrimitive; EXTERNAL Term TermPrimitive; -EXTERNAL Atom AtomPrintMessage; EXTERNAL Term TermPrintMessage; -EXTERNAL Atom AtomPrivateProcedure; EXTERNAL Term TermPrivateProcedure; -EXTERNAL Atom AtomProcedure; EXTERNAL Term TermProcedure; -EXTERNAL Atom AtomProfile; EXTERNAL Term TermProfile; -EXTERNAL Atom AtomProlog; EXTERNAL Term TermProlog; -EXTERNAL Atom AtomProtectStack; EXTERNAL Term TermProtectStack; -EXTERNAL Atom AtomQly; EXTERNAL Term TermQly; -EXTERNAL Atom AtomQuery; EXTERNAL Term TermQuery; -EXTERNAL Atom AtomQueue; EXTERNAL Term TermQueue; -EXTERNAL Atom AtomQuiet; EXTERNAL Term TermQuiet; -EXTERNAL Atom AtomRadix; EXTERNAL Term TermRadix; -EXTERNAL Atom AtomRandom; EXTERNAL Term TermRandom; -EXTERNAL Atom AtomRange; EXTERNAL Term TermRange; -EXTERNAL Atom AtomRDiv; EXTERNAL Term TermRDiv; -EXTERNAL Atom AtomRead; EXTERNAL Term TermRead; -EXTERNAL Atom AtomReadOnly; EXTERNAL Term TermReadOnly; -EXTERNAL Atom AtomReadWrite; EXTERNAL Term TermReadWrite; -EXTERNAL Atom AtomReadutil; EXTERNAL Term TermReadutil; -EXTERNAL Atom AtomReconsult; EXTERNAL Term TermReconsult; -EXTERNAL Atom AtomRecordedP; EXTERNAL Term TermRecordedP; -EXTERNAL Atom AtomRecordedWithKey; EXTERNAL Term TermRecordedWithKey; -EXTERNAL Atom AtomRedefineWarnings; EXTERNAL Term TermRedefineWarnings; -EXTERNAL Atom AtomRedoFreeze; EXTERNAL Term TermRedoFreeze; -EXTERNAL Atom AtomRefoundVar; EXTERNAL Term TermRefoundVar; -EXTERNAL Atom AtomRelativeTo; EXTERNAL Term TermRelativeTo; -EXTERNAL Atom AtomRepeat; EXTERNAL Term TermRepeat; -EXTERNAL Atom AtomRepeatSpace; EXTERNAL Term TermRepeatSpace; -EXTERNAL Atom AtomReposition; EXTERNAL Term TermReposition; -EXTERNAL Atom AtomRepresentationError; EXTERNAL Term TermRepresentationError; -EXTERNAL Atom AtomReset; EXTERNAL Term TermReset; -EXTERNAL Atom AtomResize; EXTERNAL Term TermResize; -EXTERNAL Atom AtomResourceError; EXTERNAL Term TermResourceError; -EXTERNAL Atom AtomRestoreRegs; EXTERNAL Term TermRestoreRegs; -EXTERNAL Atom AtomRetry; EXTERNAL Term TermRetry; -EXTERNAL Atom AtomRetryCounter; EXTERNAL Term TermRetryCounter; -EXTERNAL Atom AtomRTree; EXTERNAL Term TermRTree; -EXTERNAL Atom AtomSafe; EXTERNAL Term TermSafe; -EXTERNAL Atom AtomSafeCallCleanup; EXTERNAL Term TermSafeCallCleanup; -EXTERNAL Atom AtomSame; EXTERNAL Term TermSame; -EXTERNAL Atom AtomSemic; EXTERNAL Term TermSemic; -EXTERNAL Atom AtomShiftCountOverflow; EXTERNAL Term TermShiftCountOverflow; -EXTERNAL Atom AtomSigAlarm; EXTERNAL Term TermSigAlarm; -EXTERNAL Atom AtomSigBreak; EXTERNAL Term TermSigBreak; -EXTERNAL Atom AtomSigCreep; EXTERNAL Term TermSigCreep; -EXTERNAL Atom AtomSigDebug; EXTERNAL Term TermSigDebug; -EXTERNAL Atom AtomSigDelayCreep; EXTERNAL Term TermSigDelayCreep; -EXTERNAL Atom AtomSigFPE; EXTERNAL Term TermSigFPE; -EXTERNAL Atom AtomSigHup; EXTERNAL Term TermSigHup; -EXTERNAL Atom AtomSigInt; EXTERNAL Term TermSigInt; -EXTERNAL Atom AtomSigIti; EXTERNAL Term TermSigIti; -EXTERNAL Atom AtomSigPending; EXTERNAL Term TermSigPending; -EXTERNAL Atom AtomSigPipe; EXTERNAL Term TermSigPipe; -EXTERNAL Atom AtomSigStackDump; EXTERNAL Term TermSigStackDump; -EXTERNAL Atom AtomSigStatistics; EXTERNAL Term TermSigStatistics; -EXTERNAL Atom AtomSigTrace; EXTERNAL Term TermSigTrace; -EXTERNAL Atom AtomSigUsr1; EXTERNAL Term TermSigUsr1; -EXTERNAL Atom AtomSigUsr2; EXTERNAL Term TermSigUsr2; -EXTERNAL Atom AtomSigVTAlarm; EXTERNAL Term TermSigVTAlarm; -EXTERNAL Atom AtomSigWakeUp; EXTERNAL Term TermSigWakeUp; -EXTERNAL Atom AtomSilent; EXTERNAL Term TermSilent; -EXTERNAL Atom AtomSingle; EXTERNAL Term TermSingle; -EXTERNAL Atom AtomSingleVarWarnings; EXTERNAL Term TermSingleVarWarnings; -EXTERNAL Atom AtomSingleton; EXTERNAL Term TermSingleton; -EXTERNAL Atom AtomSlash; EXTERNAL Term TermSlash; -EXTERNAL Atom AtomSocket; EXTERNAL Term TermSocket; -EXTERNAL Atom AtomSolutions; EXTERNAL Term TermSolutions; -EXTERNAL Atom AtomSource; EXTERNAL Term TermSource; -EXTERNAL Atom AtomSourceSink; EXTERNAL Term TermSourceSink; -EXTERNAL Atom AtomSpy; EXTERNAL Term TermSpy; -EXTERNAL Atom AtomStack; EXTERNAL Term TermStack; -EXTERNAL Atom AtomStackFree; EXTERNAL Term TermStackFree; -EXTERNAL Atom AtomStartupSavedState; EXTERNAL Term TermStartupSavedState; -EXTERNAL Atom AtomStaticClause; EXTERNAL Term TermStaticClause; -EXTERNAL Atom AtomStaticProcedure; EXTERNAL Term TermStaticProcedure; -EXTERNAL Atom AtomStream; EXTERNAL Term TermStream; -EXTERNAL Atom AtomSWIStream; EXTERNAL Term TermSWIStream; -EXTERNAL Atom AtomVStream; EXTERNAL Term TermVStream; -EXTERNAL Atom AtomStreams; EXTERNAL Term TermStreams; -EXTERNAL Atom AtomStreamOrAlias; EXTERNAL Term TermStreamOrAlias; -EXTERNAL Atom AtomStreamPos; EXTERNAL Term TermStreamPos; -EXTERNAL Atom AtomStreamPosition; EXTERNAL Term TermStreamPosition; -EXTERNAL Atom AtomString; EXTERNAL Term TermString; -EXTERNAL Atom AtomStyleCheck; EXTERNAL Term TermStyleCheck; -EXTERNAL Atom AtomSTRING; EXTERNAL Term TermSTRING; -EXTERNAL Atom AtomSwi; EXTERNAL Term TermSwi; -EXTERNAL Atom AtomSymbolChar; EXTERNAL Term TermSymbolChar; -EXTERNAL Atom AtomSyntaxError; EXTERNAL Term TermSyntaxError; -EXTERNAL Atom AtomSyntaxErrors; EXTERNAL Term TermSyntaxErrors; -EXTERNAL Atom AtomSyntaxErrorHandler; EXTERNAL Term TermSyntaxErrorHandler; -EXTERNAL Atom AtomSystem; EXTERNAL Term TermSystem; -EXTERNAL Atom AtomSystemError; EXTERNAL Term TermSystemError; -EXTERNAL Atom AtomSystemLibraryDir; EXTERNAL Term TermSystemLibraryDir; -EXTERNAL Atom AtomT; EXTERNAL Term TermT; -EXTERNAL Atom AtomTerm; EXTERNAL Term TermTerm; -EXTERNAL Atom AtomTermExpansion; EXTERNAL Term TermTermExpansion; -EXTERNAL Atom AtomTerms; EXTERNAL Term TermTerms; -EXTERNAL Atom AtomText; EXTERNAL Term TermText; -EXTERNAL Atom AtomTextStream; EXTERNAL Term TermTextStream; -EXTERNAL Atom AtomThread; EXTERNAL Term TermThread; -EXTERNAL Atom AtomThreads; EXTERNAL Term TermThreads; -EXTERNAL Atom AtomThrow; EXTERNAL Term TermThrow; -EXTERNAL Atom AtomTimeOutSpec; EXTERNAL Term TermTimeOutSpec; -EXTERNAL Atom AtomTimeoutError; EXTERNAL Term TermTimeoutError; -EXTERNAL Atom AtomTopLevelGoal; EXTERNAL Term TermTopLevelGoal; -EXTERNAL Atom AtomTopThreadGoal; EXTERNAL Term TermTopThreadGoal; -EXTERNAL Atom AtomTraceMetaCall; EXTERNAL Term TermTraceMetaCall; -EXTERNAL Atom AtomTrail; -EXTERNAL Atom AtomTrue; EXTERNAL Term TermTrue; -EXTERNAL Atom AtomTty; EXTERNAL Term TermTty; -EXTERNAL Atom AtomTtys; EXTERNAL Term TermTtys; -EXTERNAL Atom AtomTuple; EXTERNAL Term TermTuple; -EXTERNAL Atom AtomTxt; EXTERNAL Term TermTxt; -EXTERNAL Atom AtomTypeError; EXTERNAL Term TermTypeError; -EXTERNAL Atom AtomUndefined; EXTERNAL Term TermUndefined; -EXTERNAL Atom AtomUndefp; EXTERNAL Term TermUndefp; -EXTERNAL Atom AtomUndefp0; EXTERNAL Term TermUndefp0; -EXTERNAL Atom AtomUnderflow; EXTERNAL Term TermUnderflow; -EXTERNAL Atom AtomUnificationStack; EXTERNAL Term TermUnificationStack; -EXTERNAL Atom AtomUnique; EXTERNAL Term TermUnique; -EXTERNAL Atom AtomUnsignedByte; EXTERNAL Term TermUnsignedByte; -EXTERNAL Atom AtomUnsignedChar; EXTERNAL Term TermUnsignedChar; -EXTERNAL Atom AtomUser; EXTERNAL Term TermUser; -EXTERNAL Atom AtomUserErr; EXTERNAL Term TermUserErr; -EXTERNAL Atom AtomUserIn; EXTERNAL Term TermUserIn; -EXTERNAL Atom AtomUserOut; EXTERNAL Term TermUserOut; -EXTERNAL Atom AtomDollarVar; EXTERNAL Term TermDollarVar; -EXTERNAL Atom AtomVBar; EXTERNAL Term TermVBar; -EXTERNAL Atom AtomVarBranches; EXTERNAL Term TermVarBranches; -EXTERNAL Atom AtomVariableNames; EXTERNAL Term TermVariableNames; -EXTERNAL Atom AtomHiddenVar; EXTERNAL Term TermHiddenVar; -EXTERNAL Atom AtomVariable; EXTERNAL Term TermVariable; -EXTERNAL Atom AtomVerbose; EXTERNAL Term TermVerbose; -EXTERNAL Atom AtomVerboseFileSearch; EXTERNAL Term TermVerboseFileSearch; -EXTERNAL Atom AtomVersionNumber; EXTERNAL Term TermVersionNumber; -EXTERNAL Atom AtomVeryVerbose; EXTERNAL Term TermVeryVerbose; -EXTERNAL Atom AtomWakeUpGoal; EXTERNAL Term TermWakeUpGoal; -EXTERNAL Atom AtomWarning; EXTERNAL Term TermWarning; -EXTERNAL Atom AtomWhen; EXTERNAL Term TermWhen; -EXTERNAL Atom AtomWrite; EXTERNAL Term TermWrite; -EXTERNAL Atom AtomWriteTerm; EXTERNAL Term TermWriteTerm; -EXTERNAL Atom AtomXml; EXTERNAL Term TermXml; -EXTERNAL Atom AtomYapHacks; EXTERNAL Term TermYapHacks; -EXTERNAL Atom AtomZeroDivisor; EXTERNAL Term TermZeroDivisor; -EXTERNAL Functor FunctorAfInet; - -EXTERNAL Functor FunctorAfLocal; - -EXTERNAL Functor FunctorAfUnix; - -EXTERNAL Functor FunctorAltNot; - -EXTERNAL Functor FunctorArg; - -EXTERNAL Functor FunctorArrayEntry; - -EXTERNAL Functor FunctorArrow; - -EXTERNAL Functor FunctorDoubleArrow; - -EXTERNAL Functor FunctorAssert1; - -EXTERNAL Functor FunctorAssert; - -EXTERNAL Functor FunctorAtFoundOne; - -EXTERNAL Functor FunctorAtom; - -EXTERNAL Functor FunctorAtt1; - -EXTERNAL Functor FunctorAttGoal; - -EXTERNAL Functor FunctorBraces; - -EXTERNAL Functor FunctorCall; - -EXTERNAL Functor FunctorCatch; - -EXTERNAL Functor FunctorChangeModule; - -EXTERNAL Functor FunctorChars; - -EXTERNAL Functor FunctorChars1; - -EXTERNAL Functor FunctorCleanCall; - -EXTERNAL Functor FunctorClist; - -EXTERNAL Functor FunctorCodes; - -EXTERNAL Functor FunctorCodes1; - -EXTERNAL Functor FunctorColon; - -EXTERNAL Functor FunctorComma; - -EXTERNAL Functor FunctorCommentHook; - -EXTERNAL Functor FunctorContext2; - -EXTERNAL Functor FunctorConsistencyError; - -EXTERNAL Functor FunctorCreep; - -EXTERNAL Functor FunctorCsult; - -EXTERNAL Functor FunctorCurrentModule; - -EXTERNAL Functor FunctorCutBy; - -EXTERNAL Functor FunctorDBREF; - -EXTERNAL Functor FunctorDiff; - -EXTERNAL Functor FunctorDoLogUpdClause; - -EXTERNAL Functor FunctorDoLogUpdClause0; - -EXTERNAL Functor FunctorDoLogUpdClauseErase; - -EXTERNAL Functor FunctorDoStaticClause; - -EXTERNAL Functor FunctorDollar; - -EXTERNAL Functor FunctorDollarVar; - -EXTERNAL Functor FunctorDomainError; - -EXTERNAL Functor FunctorDot; - -EXTERNAL Functor FunctorDot10; - -EXTERNAL Functor FunctorDot11; - -EXTERNAL Functor FunctorDot12; - -EXTERNAL Functor FunctorDot2; - -EXTERNAL Functor FunctorDot3; - -EXTERNAL Functor FunctorDot4; - -EXTERNAL Functor FunctorDot5; - -EXTERNAL Functor FunctorDot6; - -EXTERNAL Functor FunctorDot7; - -EXTERNAL Functor FunctorDot8; - -EXTERNAL Functor FunctorDot9; - -EXTERNAL Functor FunctorDoubleArrow; - -EXTERNAL Functor FunctorDoubleSlash; - -EXTERNAL Functor FunctorEmptySquareBrackets; - -EXTERNAL Functor FunctorEq; - -EXTERNAL Functor FunctorError; - -EXTERNAL Functor FunctorEvaluationError; - -EXTERNAL Functor FunctorException; - -EXTERNAL Functor FunctorExecute2InMod; - -EXTERNAL Functor FunctorExecuteInMod; - -EXTERNAL Functor FunctorExecuteWithin; - -EXTERNAL Functor FunctorExistenceError; - -EXTERNAL Functor FunctorExoClause; - -EXTERNAL Functor FunctorFunctor; - -EXTERNAL Functor FunctorGAtom; - -EXTERNAL Functor FunctorGAtomic; - -EXTERNAL Functor FunctorGCompound; - -EXTERNAL Functor FunctorGFloat; - -EXTERNAL Functor FunctorGFormatAt; - -EXTERNAL Functor FunctorGInteger; - -EXTERNAL Functor FunctorGNumber; - -EXTERNAL Functor FunctorGPrimitive; - -EXTERNAL Functor FunctorGVar; - -EXTERNAL Functor FunctorGeneratePredInfo; - -EXTERNAL Functor FunctorGoalExpansion2; - -EXTERNAL Functor FunctorGoalExpansion; - -EXTERNAL Functor FunctorHandleThrow; - -EXTERNAL Functor FunctorHat; - -EXTERNAL Functor FunctorI; - -EXTERNAL Functor FunctorId; - -EXTERNAL Functor FunctorInfo1; - -EXTERNAL Functor FunctorInfo2; - -EXTERNAL Functor FunctorInfo3; - -EXTERNAL Functor FunctorInfo4; - -EXTERNAL Functor FunctorIs; - -EXTERNAL Functor FunctorJ; - -EXTERNAL Functor FunctorLastExecuteWithin; - -EXTERNAL Functor FunctorList; - -EXTERNAL Functor FunctorLOOP; - -EXTERNAL Functor FunctorMegaClause; - -EXTERNAL Functor FunctorMetaCall; - -EXTERNAL Functor FunctorMinus; - -EXTERNAL Functor FunctorModule; - -EXTERNAL Functor FunctorMultiFileClause; - -EXTERNAL Functor FunctorMutable; - -EXTERNAL Functor FunctorMutex; - -EXTERNAL Functor FunctorNotImplemented; - -EXTERNAL Functor FunctorNBQueue; - -EXTERNAL Functor FunctorNot; - -EXTERNAL Functor FunctorObj; - -EXTERNAL Functor FunctorOr; - -EXTERNAL Functor FunctorOutput; - -EXTERNAL Functor FunctorPermissionError; - -EXTERNAL Functor FunctorPlus; - -EXTERNAL Functor FunctorPortray; - -EXTERNAL Functor FunctorPrintMessage; - -EXTERNAL Functor FunctorProcedure; - -EXTERNAL Functor FunctorPriority; - -EXTERNAL Functor FunctorPrologConstraint; - -EXTERNAL Functor FunctorProtectStack; - -EXTERNAL Functor FunctorQuery; - -EXTERNAL Functor FunctorRecordedWithKey; - -EXTERNAL Functor FunctorRDiv; - -EXTERNAL Functor FunctorRedoFreeze; - -EXTERNAL Functor FunctorRepresentationError; - -EXTERNAL Functor FunctorResourceError; - -EXTERNAL Functor FunctorRestoreRegs; - -EXTERNAL Functor FunctorRestoreRegs1; - -EXTERNAL Functor FunctorSafe; - -EXTERNAL Functor FunctorSafeCallCleanup; - -EXTERNAL Functor FunctorSame; - -EXTERNAL Functor FunctorSlash; - -EXTERNAL Functor FunctorStaticClause; - -EXTERNAL Functor FunctorStream; - -EXTERNAL Functor FunctorStreamEOS; - -EXTERNAL Functor FunctorStreamPos; - -EXTERNAL Functor FunctorString1; - -EXTERNAL Functor FunctorStyleCheck; - -EXTERNAL Functor FunctorSyntaxError; - -EXTERNAL Functor FunctorShortSyntaxError; - -EXTERNAL Functor FunctorTermExpansion; - -EXTERNAL Functor FunctorThreadRun; - -EXTERNAL Functor FunctorThrow; - -EXTERNAL Functor FunctorTimeoutError; - -EXTERNAL Functor FunctorTraceMetaCall; - -EXTERNAL Functor FunctorTypeError; - -EXTERNAL Functor FunctorUMinus; - -EXTERNAL Functor FunctorUPlus; - -EXTERNAL Functor FunctorVBar; - -EXTERNAL Functor FunctorWriteTerm; - -EXTERNAL Functor FunctorHiddenVar; - + +/* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms" + {lease do not update, update misc/ATOMS instead */ + +X_API EXTERNAL Atom Atom3Dots; +X_API EXTERNAL Atom AtomAbol; +X_API EXTERNAL Term TermAbol; +X_API EXTERNAL Atom AtomAccess; +X_API EXTERNAL Term TermAccess; +X_API EXTERNAL Atom AtomAfInet; +X_API EXTERNAL Term TermAfInet; +X_API EXTERNAL Atom AtomAfLocal; +X_API EXTERNAL Term TermAfLocal; +X_API EXTERNAL Atom AtomAfUnix; +X_API EXTERNAL Term TermAfUnix; +X_API EXTERNAL Atom AtomAlarm; +X_API EXTERNAL Term TermAlarm; +X_API EXTERNAL Atom AtomAlias; +X_API EXTERNAL Term TermAlias; +X_API EXTERNAL Atom AtomAll; +X_API EXTERNAL Term TermAll; +X_API EXTERNAL Atom AtomAltNot; +X_API EXTERNAL Term TermAltNot; +X_API EXTERNAL Atom AtomAnswer; +X_API EXTERNAL Term TermAnswer; +X_API EXTERNAL Atom AtomAny; +X_API EXTERNAL Term TermAny; +X_API EXTERNAL Atom AtomAppend; +X_API EXTERNAL Term TermAppend; +X_API EXTERNAL Atom AtomArg; +X_API EXTERNAL Term TermArg; +X_API EXTERNAL Atom AtomArray; +X_API EXTERNAL Term TermArray; +X_API EXTERNAL Atom AtomArrayAccess; +X_API EXTERNAL Term TermArrayAccess; +X_API EXTERNAL Atom AtomArrayOverflow; +X_API EXTERNAL Term TermArrayOverflow; +X_API EXTERNAL Atom AtomArrayType; +X_API EXTERNAL Term TermArrayType; +X_API EXTERNAL Atom AtomArrow; +X_API EXTERNAL Term TermArrow; +X_API EXTERNAL Atom AtomAttributedModule; +X_API EXTERNAL Term TermAttributedModule; +X_API EXTERNAL Atom AtomDoubleArrow; +X_API EXTERNAL Term TermDoubleArrow; +X_API EXTERNAL Atom AtomAssert; +X_API EXTERNAL Term TermAssert; +X_API EXTERNAL Atom AtomBeginBracket; +X_API EXTERNAL Term TermBeginBracket; +X_API EXTERNAL Atom AtomEndBracket; +X_API EXTERNAL Term TermEndBracket; +X_API EXTERNAL Atom AtomBeginSquareBracket; +X_API EXTERNAL Term TermBeginSquareBracket; +X_API EXTERNAL Atom AtomEndSquareBracket; +X_API EXTERNAL Term TermEndSquareBracket; +X_API EXTERNAL Atom AtomBeginCurlyBracket; +X_API EXTERNAL Term TermBeginCurlyBracket; +X_API EXTERNAL Atom AtomEndCurlyBracket; +X_API EXTERNAL Term TermEndCurlyBracket; +X_API EXTERNAL Atom AtomEmptyBrackets; +X_API EXTERNAL Term TermEmptyBrackets; +X_API EXTERNAL Atom AtomEmptySquareBrackets; +X_API EXTERNAL Term TermEmptySquareBrackets; +X_API EXTERNAL Atom AtomAsserta; +X_API EXTERNAL Term TermAsserta; +X_API EXTERNAL Atom AtomAssertaStatic; +X_API EXTERNAL Term TermAssertaStatic; +X_API EXTERNAL Atom AtomAssertz; +X_API EXTERNAL Term TermAssertz; +X_API EXTERNAL Atom AtomAssertzStatic; +X_API EXTERNAL Term TermAssertzStatic; +X_API EXTERNAL Atom AtomAt; +X_API EXTERNAL Term TermAt; +X_API EXTERNAL Atom AtomAtom; +X_API EXTERNAL Term TermAtom; +X_API EXTERNAL Atom AtomAtomic; +X_API EXTERNAL Term TermAtomic; +X_API EXTERNAL Atom AtomAtt; +X_API EXTERNAL Term TermAtt; +X_API EXTERNAL Atom AtomAtt1; +X_API EXTERNAL Term TermAtt1; +X_API EXTERNAL Atom AtomAttDo; +X_API EXTERNAL Term TermAttDo; +X_API EXTERNAL Atom AtomAttributes; +X_API EXTERNAL Term TermAttributes; +X_API EXTERNAL Atom AtomB; +X_API EXTERNAL Term TermB; +X_API EXTERNAL Atom AtomBatched; +X_API EXTERNAL Term TermBatched; +X_API EXTERNAL Atom AtomBetween; +X_API EXTERNAL Term TermBetween; +X_API EXTERNAL Atom AtomBinary; +X_API EXTERNAL Term TermBinary; +X_API EXTERNAL Atom AtomBigNum; +X_API EXTERNAL Term TermBigNum; +X_API EXTERNAL Atom AtomBinaryStream; +X_API EXTERNAL Term TermBinaryStream; +X_API EXTERNAL Atom AtomBoolean; +X_API EXTERNAL Term TermBoolean; +X_API EXTERNAL Atom AtomBraces; +X_API EXTERNAL Term TermBraces; +X_API EXTERNAL Atom AtomBreak; +X_API EXTERNAL Term TermBreak; +X_API EXTERNAL Atom AtomByte; +X_API EXTERNAL Term TermByte; +X_API EXTERNAL Atom AtomCArith; +X_API EXTERNAL Term TermCArith; +X_API EXTERNAL Atom AtomCall; +X_API EXTERNAL Term TermCall; +X_API EXTERNAL Atom AtomCallAndRetryCounter; +X_API EXTERNAL Term TermCallAndRetryCounter; +X_API EXTERNAL Atom AtomCallCounter; +X_API EXTERNAL Term TermCallCounter; +X_API EXTERNAL Atom AtomCallable; +X_API EXTERNAL Term TermCallable; +X_API EXTERNAL Atom AtomCatch; +X_API EXTERNAL Term TermCatch; +X_API EXTERNAL Atom AtomChangeModule; +X_API EXTERNAL Term TermChangeModule; +X_API EXTERNAL Atom AtomChar; +X_API EXTERNAL Term TermChar; +X_API EXTERNAL Atom AtomCharsio; +X_API EXTERNAL Term TermCharsio; +X_API EXTERNAL Atom AtomCharacter; +X_API EXTERNAL Term TermCharacter; +X_API EXTERNAL Atom AtomCharacterCode; +X_API EXTERNAL Term TermCharacterCode; +X_API EXTERNAL Atom AtomChars; +X_API EXTERNAL Term TermChars; +X_API EXTERNAL Atom AtomCharset; +X_API EXTERNAL Term TermCharset; +X_API EXTERNAL Atom AtomChType; +X_API EXTERNAL Term TermChType; +X_API EXTERNAL Atom AtomCleanCall; +X_API EXTERNAL Term TermCleanCall; +X_API EXTERNAL Atom AtomClose; +X_API EXTERNAL Term TermClose; +X_API EXTERNAL Atom AtomColon; +X_API EXTERNAL Term TermColon; +X_API EXTERNAL Atom AtomCodeSpace; +X_API EXTERNAL Term TermCodeSpace; +X_API EXTERNAL Atom AtomCodes; +X_API EXTERNAL Term TermCodes; +X_API EXTERNAL Atom AtomCoInductive; +X_API EXTERNAL Term TermCoInductive; +X_API EXTERNAL Atom AtomComma; +X_API EXTERNAL Term TermComma; +X_API EXTERNAL Atom AtomCommentHook; +X_API EXTERNAL Term TermCommentHook; +X_API EXTERNAL Atom AtomCompact; +X_API EXTERNAL Term TermCompact; +X_API EXTERNAL Atom AtomCompound; +X_API EXTERNAL Term TermCompound; +X_API EXTERNAL Atom AtomConsistencyError; +X_API EXTERNAL Term TermConsistencyError; +X_API EXTERNAL Atom AtomConsult; +X_API EXTERNAL Term TermConsult; +X_API EXTERNAL Atom AtomConsultOnBoot; +X_API EXTERNAL Term TermConsultOnBoot; +X_API EXTERNAL Atom AtomContext; +X_API EXTERNAL Term TermContext; +X_API EXTERNAL Atom AtomCputime; +X_API EXTERNAL Term TermCputime; +X_API EXTERNAL Atom AtomCreate; +X_API EXTERNAL Term TermCreate; +X_API EXTERNAL Atom AtomCreep; +X_API EXTERNAL Term TermCreep; +X_API EXTERNAL Atom AtomCryptAtoms; +X_API EXTERNAL Term TermCryptAtoms; +X_API EXTERNAL Atom AtomCurly; +X_API EXTERNAL Term TermCurly; +X_API EXTERNAL Atom AtomCsult; +X_API EXTERNAL Term TermCsult; +X_API EXTERNAL Atom AtomCurrentModule; +X_API EXTERNAL Term TermCurrentModule; +X_API EXTERNAL Atom AtomCut; +X_API EXTERNAL Term TermCut; +X_API EXTERNAL Atom AtomCutBy; +X_API EXTERNAL Term TermCutBy; +X_API EXTERNAL Atom AtomDAbort; +X_API EXTERNAL Term TermDAbort; +X_API EXTERNAL Atom AtomDBLoad; +X_API EXTERNAL Term TermDBLoad; +X_API EXTERNAL Atom AtomDBREF; +X_API EXTERNAL Term TermDBREF; +X_API EXTERNAL Atom AtomDBReference; +X_API EXTERNAL Term TermDBReference; +X_API EXTERNAL Atom AtomDBTerm; +X_API EXTERNAL Term TermDBTerm; +X_API EXTERNAL Atom AtomDBref; +X_API EXTERNAL Term TermDBref; +X_API EXTERNAL Atom AtomDInteger; +X_API EXTERNAL Term TermDInteger; +X_API EXTERNAL Atom AtomDebugMeta; +X_API EXTERNAL Term TermDebugMeta; +X_API EXTERNAL Atom AtomDebuggerInput; +X_API EXTERNAL Term TermDebuggerInput; +X_API EXTERNAL Atom AtomDec10; +X_API EXTERNAL Term TermDec10; +X_API EXTERNAL Atom AtomDefault; +X_API EXTERNAL Term TermDefault; +X_API EXTERNAL Atom AtomDevNull; +X_API EXTERNAL Term TermDevNull; +X_API EXTERNAL Atom AtomDiff; +X_API EXTERNAL Term TermDiff; +X_API EXTERNAL Atom AtomDirectory; +X_API EXTERNAL Term TermDirectory; +X_API EXTERNAL Atom AtomDiscontiguous; +X_API EXTERNAL Term TermDiscontiguous; +X_API EXTERNAL Atom AtomDiscontiguousWarnings; +X_API EXTERNAL Term TermDiscontiguousWarnings; +X_API EXTERNAL Atom AtomDollar; +X_API EXTERNAL Term TermDollar; +X_API EXTERNAL Atom AtomDoLogUpdClause; +X_API EXTERNAL Term TermDoLogUpdClause; +X_API EXTERNAL Atom AtomDoLogUpdClause0; +X_API EXTERNAL Term TermDoLogUpdClause0; +X_API EXTERNAL Atom AtomDoLogUpdClauseErase; +X_API EXTERNAL Term TermDoLogUpdClauseErase; +X_API EXTERNAL Atom AtomDollarU; +X_API EXTERNAL Term TermDollarU; +X_API EXTERNAL Atom AtomDollarUndef; +X_API EXTERNAL Term TermDollarUndef; +X_API EXTERNAL Atom AtomDomainError; +X_API EXTERNAL Term TermDomainError; +X_API EXTERNAL Atom AtomDoStaticClause; +X_API EXTERNAL Term TermDoStaticClause; +X_API EXTERNAL Atom AtomDots; +X_API EXTERNAL Term TermDots; +X_API EXTERNAL Atom AtomDOUBLE; +X_API EXTERNAL Term TermDOUBLE; +X_API EXTERNAL Atom AtomDoubleSlash; +X_API EXTERNAL Term TermDoubleSlash; +X_API EXTERNAL Atom AtomE; +X_API EXTERNAL Term TermE; +X_API EXTERNAL Atom AtomEOFBeforeEOT; +X_API EXTERNAL Term TermEOFBeforeEOT; +X_API EXTERNAL Atom AtomEQ; +X_API EXTERNAL Term TermEQ; +X_API EXTERNAL Atom AtomEmptyAtom; +X_API EXTERNAL Term TermEmptyAtom; +X_API EXTERNAL Atom AtomEncoding; +X_API EXTERNAL Term TermEncoding; +X_API EXTERNAL Atom AtomEndOfStream; +X_API EXTERNAL Term TermEndOfStream; +X_API EXTERNAL Atom AtomEof; +X_API EXTERNAL Term TermEof; +X_API EXTERNAL Atom AtomEOfCode; +X_API EXTERNAL Term TermEOfCode; +X_API EXTERNAL Atom AtomEq; +X_API EXTERNAL Term TermEq; +X_API EXTERNAL Atom AtomError; +X_API EXTERNAL Term TermError; +X_API EXTERNAL Atom AtomException; +X_API EXTERNAL Term TermException; +X_API EXTERNAL Atom AtomExtensions; +X_API EXTERNAL Term TermExtensions; +X_API EXTERNAL Atom AtomEvaluable; +X_API EXTERNAL Term TermEvaluable; +X_API EXTERNAL Atom AtomEvaluationError; +X_API EXTERNAL Term TermEvaluationError; +X_API EXTERNAL Atom AtomExecutable; +X_API EXTERNAL Term TermExecutable; +X_API EXTERNAL Atom AtomExecute; +X_API EXTERNAL Term TermExecute; +X_API EXTERNAL Atom AtomExecAnswers; +X_API EXTERNAL Term TermExecAnswers; +X_API EXTERNAL Atom AtomExecuteInMod; +X_API EXTERNAL Term TermExecuteInMod; +X_API EXTERNAL Atom AtomExecuteWithin; +X_API EXTERNAL Term TermExecuteWithin; +X_API EXTERNAL Atom AtomExecuteWoMod; +X_API EXTERNAL Term TermExecuteWoMod; +X_API EXTERNAL Atom AtomExist; +X_API EXTERNAL Term TermExist; +X_API EXTERNAL Atom AtomExists; +X_API EXTERNAL Term TermExists; +X_API EXTERNAL Atom AtomExit; +X_API EXTERNAL Term TermExit; +X_API EXTERNAL Atom AtomExistenceError; +X_API EXTERNAL Term TermExistenceError; +X_API EXTERNAL Atom AtomExoClause; +X_API EXTERNAL Term TermExoClause; +X_API EXTERNAL Atom AtomExpectedNumber; +X_API EXTERNAL Term TermExpectedNumber; +X_API EXTERNAL Atom AtomExpand; +X_API EXTERNAL Term TermExpand; +X_API EXTERNAL Atom AtomExtendFileSearchPath; +X_API EXTERNAL Term TermExtendFileSearchPath; +X_API EXTERNAL Atom AtomExtendsions; +X_API EXTERNAL Term TermExtendsions; +X_API EXTERNAL Atom AtomFB; +X_API EXTERNAL Term TermFB; +X_API EXTERNAL Atom AtomFail; +X_API EXTERNAL Term TermFail; +X_API EXTERNAL Atom AtomFalse; +X_API EXTERNAL Term TermFalse; +X_API EXTERNAL Atom AtomFast; +X_API EXTERNAL Term TermFast; +X_API EXTERNAL Atom AtomFastFail; +X_API EXTERNAL Term TermFastFail; +X_API EXTERNAL Atom AtomFileErrors; +X_API EXTERNAL Term TermFileErrors; +X_API EXTERNAL Atom AtomFileerrors; +X_API EXTERNAL Term TermFileerrors; +X_API EXTERNAL Atom AtomFileType; +X_API EXTERNAL Term TermFileType; +X_API EXTERNAL Atom AtomFirst; +X_API EXTERNAL Term TermFirst; +X_API EXTERNAL Atom AtomFloat; +X_API EXTERNAL Term TermFloat; +X_API EXTERNAL Atom AtomFloatFormat; +X_API EXTERNAL Term TermFloatFormat; +X_API EXTERNAL Atom AtomFloatOverflow; +X_API EXTERNAL Term TermFloatOverflow; +X_API EXTERNAL Atom AtomFloatUnderflow; +X_API EXTERNAL Term TermFloatUnderflow; +X_API EXTERNAL Atom AtomFormat; +X_API EXTERNAL Term TermFormat; +X_API EXTERNAL Atom AtomFormatAt; +X_API EXTERNAL Term TermFormatAt; +X_API EXTERNAL Atom AtomFull; +X_API EXTERNAL Term TermFull; +X_API EXTERNAL Atom AtomFunctor; +X_API EXTERNAL Term TermFunctor; +X_API EXTERNAL Atom AtomGT; +X_API EXTERNAL Term TermGT; +X_API EXTERNAL Atom AtomGVar; +X_API EXTERNAL Term TermGVar; +X_API EXTERNAL Atom AtomGc; +X_API EXTERNAL Term TermGc; +X_API EXTERNAL Atom AtomGcMargin; +X_API EXTERNAL Term TermGcMargin; +X_API EXTERNAL Atom AtomGcTrace; +X_API EXTERNAL Term TermGcTrace; +X_API EXTERNAL Atom AtomGcVerbose; +X_API EXTERNAL Term TermGcVerbose; +X_API EXTERNAL Atom AtomGcVeryVerbose; +X_API EXTERNAL Term TermGcVeryVerbose; +X_API EXTERNAL Atom AtomGeneratePredInfo; +X_API EXTERNAL Term TermGeneratePredInfo; +X_API EXTERNAL Atom AtomGetwork; +X_API EXTERNAL Term TermGetwork; +X_API EXTERNAL Atom AtomGetworkSeq; +X_API EXTERNAL Term TermGetworkSeq; +X_API EXTERNAL Atom AtomGlob; +X_API EXTERNAL Term TermGlob; +X_API EXTERNAL Atom AtomGlobal; +X_API EXTERNAL Term TermGlobal; +X_API EXTERNAL Atom AtomGlobalSp; +X_API EXTERNAL Term TermGlobalSp; +X_API EXTERNAL Atom AtomGlobalTrie; +X_API EXTERNAL Term TermGlobalTrie; +X_API EXTERNAL Atom AtomGoalExpansion; +X_API EXTERNAL Term TermGoalExpansion; +X_API EXTERNAL Atom AtomHat; +X_API EXTERNAL Term TermHat; +X_API EXTERNAL Atom AtomHERE; +X_API EXTERNAL Term TermHERE; +X_API EXTERNAL Atom AtomHandleThrow; +X_API EXTERNAL Term TermHandleThrow; +X_API EXTERNAL Atom AtomHeap; +X_API EXTERNAL Term TermHeap; +X_API EXTERNAL Atom AtomHeapUsed; +X_API EXTERNAL Term TermHeapUsed; +X_API EXTERNAL Atom AtomHugeInt; +X_API EXTERNAL Term TermHugeInt; +X_API EXTERNAL Atom AtomIDB; +X_API EXTERNAL Term TermIDB; +X_API EXTERNAL Atom AtomIOMode; +X_API EXTERNAL Term TermIOMode; +X_API EXTERNAL Atom AtomI; +X_API EXTERNAL Term TermI; +X_API EXTERNAL Atom AtomId; +X_API EXTERNAL Term TermId; +X_API EXTERNAL Atom AtomIgnore; +X_API EXTERNAL Term TermIgnore; +X_API EXTERNAL Atom AtomInf; +X_API EXTERNAL Term TermInf; +X_API EXTERNAL Atom AtomInfinity; +X_API EXTERNAL Term TermInfinity; +X_API EXTERNAL Atom AtomInfo; +X_API EXTERNAL Term TermInfo; +X_API EXTERNAL Atom AtomInitGoal; +X_API EXTERNAL Term TermInitGoal; +X_API EXTERNAL Atom AtomInitProlog; +X_API EXTERNAL Term TermInitProlog; +X_API EXTERNAL Atom AtomInStackExpansion; +X_API EXTERNAL Term TermInStackExpansion; +X_API EXTERNAL Atom AtomInput; +X_API EXTERNAL Term TermInput; +X_API EXTERNAL Atom AtomInstantiationError; +X_API EXTERNAL Term TermInstantiationError; +X_API EXTERNAL Atom AtomInt; +X_API EXTERNAL Term TermInt; +X_API EXTERNAL Atom AtomIntOverflow; +X_API EXTERNAL Term TermIntOverflow; +X_API EXTERNAL Atom AtomInteger; +X_API EXTERNAL Term TermInteger; +X_API EXTERNAL Atom AtomInternalCompilerError; +X_API EXTERNAL Term TermInternalCompilerError; +X_API EXTERNAL Atom AtomIs; +X_API EXTERNAL Term TermIs; +X_API EXTERNAL Atom AtomJ; +X_API EXTERNAL Term TermJ; +X_API EXTERNAL Atom Atoml; +X_API EXTERNAL Term Terml; +X_API EXTERNAL Atom AtomKey; +X_API EXTERNAL Term TermKey; +X_API EXTERNAL Atom AtomLDLibraryPath; +X_API EXTERNAL Term TermLDLibraryPath; +X_API EXTERNAL Atom AtomLONGINT; +X_API EXTERNAL Term TermLONGINT; +X_API EXTERNAL Atom AtomLOOP; +X_API EXTERNAL Term TermLOOP; +X_API EXTERNAL Atom AtomLoopStream; +X_API EXTERNAL Term TermLoopStream; +X_API EXTERNAL Atom AtomLT; +X_API EXTERNAL Term TermLT; +X_API EXTERNAL Atom AtomLastExecuteWithin; +X_API EXTERNAL Term TermLastExecuteWithin; +X_API EXTERNAL Atom AtomLeash; +X_API EXTERNAL Term TermLeash; +X_API EXTERNAL Atom AtomLeast; +X_API EXTERNAL Term TermLeast; +X_API EXTERNAL Atom AtomLength; +X_API EXTERNAL Term TermLength; +X_API EXTERNAL Atom AtomList; +X_API EXTERNAL Term TermList; +X_API EXTERNAL Atom AtomLine; +X_API EXTERNAL Term TermLine; +X_API EXTERNAL Atom AtomLive; +X_API EXTERNAL Term TermLive; +X_API EXTERNAL Atom AtomLoadAnswers; +X_API EXTERNAL Term TermLoadAnswers; +X_API EXTERNAL Atom AtomLocal; +X_API EXTERNAL Term TermLocal; +X_API EXTERNAL Atom AtomLocalSp; +X_API EXTERNAL Term TermLocalSp; +X_API EXTERNAL Atom AtomLocalTrie; +X_API EXTERNAL Term TermLocalTrie; +X_API EXTERNAL Atom AtomMax; +X_API EXTERNAL Term TermMax; +X_API EXTERNAL Atom AtomMaximum; +X_API EXTERNAL Term TermMaximum; +X_API EXTERNAL Atom AtomMaxArity; +X_API EXTERNAL Term TermMaxArity; +X_API EXTERNAL Atom AtomMaxFiles; +X_API EXTERNAL Term TermMaxFiles; +X_API EXTERNAL Atom AtomMegaClause; +X_API EXTERNAL Term TermMegaClause; +X_API EXTERNAL Atom AtomMetaCall; +X_API EXTERNAL Term TermMetaCall; +X_API EXTERNAL Atom AtomMfClause; +X_API EXTERNAL Term TermMfClause; +X_API EXTERNAL Atom AtomMin; +X_API EXTERNAL Term TermMin; +X_API EXTERNAL Atom AtomMinimum; +X_API EXTERNAL Term TermMinimum; +X_API EXTERNAL Atom AtomMinus; +X_API EXTERNAL Term TermMinus; +X_API EXTERNAL Atom AtomModify; +X_API EXTERNAL Term TermModify; +X_API EXTERNAL Atom AtomModule; +X_API EXTERNAL Term TermModule; +X_API EXTERNAL Atom AtomMost; +X_API EXTERNAL Term TermMost; +X_API EXTERNAL Atom AtomMulti; +X_API EXTERNAL Term TermMulti; +X_API EXTERNAL Atom AtomMultiFile; +X_API EXTERNAL Term TermMultiFile; +X_API EXTERNAL Atom AtomMultiple; +X_API EXTERNAL Term TermMultiple; +X_API EXTERNAL Atom AtomMutable; +X_API EXTERNAL Term TermMutable; +X_API EXTERNAL Atom AtomMutableVariable; +X_API EXTERNAL Term TermMutableVariable; +X_API EXTERNAL Atom AtomMutex; +X_API EXTERNAL Term TermMutex; +X_API EXTERNAL Atom AtomMyddasDB; +X_API EXTERNAL Term TermMyddasDB; +X_API EXTERNAL Atom AtomMyddasGoal; +X_API EXTERNAL Term TermMyddasGoal; +X_API EXTERNAL Atom AtomMyddasHost; +X_API EXTERNAL Term TermMyddasHost; +X_API EXTERNAL Atom AtomMyddasPass; +X_API EXTERNAL Term TermMyddasPass; +X_API EXTERNAL Atom AtomMyddasUser; +X_API EXTERNAL Term TermMyddasUser; +X_API EXTERNAL Atom AtomMyddasVersionName; +X_API EXTERNAL Term TermMyddasVersionName; +X_API EXTERNAL Atom AtomNan; +X_API EXTERNAL Term TermNan; +X_API EXTERNAL Atom AtomNb; +X_API EXTERNAL Term TermNb; +X_API EXTERNAL Atom AtomNbTerm; +X_API EXTERNAL Term TermNbTerm; +X_API EXTERNAL Atom AtomNew; +X_API EXTERNAL Term TermNew; +X_API EXTERNAL Atom AtomNewLine; +X_API EXTERNAL Term TermNewLine; +X_API EXTERNAL Atom AtomNl; +X_API EXTERNAL Term TermNl; +X_API EXTERNAL Atom AtomNoEffect; +X_API EXTERNAL Term TermNoEffect; +X_API EXTERNAL Atom AtomNoMemory; +X_API EXTERNAL Term TermNoMemory; +X_API EXTERNAL Atom AtomNone; +X_API EXTERNAL Term TermNone; +X_API EXTERNAL Atom AtomNonEmptyList; +X_API EXTERNAL Term TermNonEmptyList; +X_API EXTERNAL Atom AtomNot; +X_API EXTERNAL Term TermNot; +X_API EXTERNAL Atom AtomNotImplemented; +X_API EXTERNAL Term TermNotImplemented; +X_API EXTERNAL Atom AtomNotLessThanZero; +X_API EXTERNAL Term TermNotLessThanZero; +X_API EXTERNAL Atom AtomNotNewline; +X_API EXTERNAL Term TermNotNewline; +X_API EXTERNAL Atom AtomNotZero; +X_API EXTERNAL Term TermNotZero; +X_API EXTERNAL Atom AtomNumber; +X_API EXTERNAL Term TermNumber; +X_API EXTERNAL Atom AtomObj; +X_API EXTERNAL Term TermObj; +X_API EXTERNAL Atom AtomOff; +X_API EXTERNAL Term TermOff; +X_API EXTERNAL Atom AtomOffline; +X_API EXTERNAL Term TermOffline; +X_API EXTERNAL Atom AtomOn; +X_API EXTERNAL Term TermOn; +X_API EXTERNAL Atom AtomOnline; +X_API EXTERNAL Term TermOnline; +X_API EXTERNAL Atom AtomOpen; +X_API EXTERNAL Term TermOpen; +X_API EXTERNAL Atom AtomOperatingSystemError; +X_API EXTERNAL Term TermOperatingSystemError; +X_API EXTERNAL Atom AtomOperatingSystemSupport; +X_API EXTERNAL Term TermOperatingSystemSupport; +X_API EXTERNAL Atom AtomOperator; +X_API EXTERNAL Term TermOperator; +X_API EXTERNAL Atom AtomOperatorPriority; +X_API EXTERNAL Term TermOperatorPriority; +X_API EXTERNAL Atom AtomOperatorSpecifier; +X_API EXTERNAL Term TermOperatorSpecifier; +X_API EXTERNAL Atom AtomOpt; +X_API EXTERNAL Term TermOpt; +X_API EXTERNAL Atom AtomOtherwise; +X_API EXTERNAL Term TermOtherwise; +X_API EXTERNAL Atom AtomOutOfAttvarsError; +X_API EXTERNAL Term TermOutOfAttvarsError; +X_API EXTERNAL Atom AtomOutOfAuxspaceError; +X_API EXTERNAL Term TermOutOfAuxspaceError; +X_API EXTERNAL Atom AtomOutOfHeapError; +X_API EXTERNAL Term TermOutOfHeapError; +X_API EXTERNAL Atom AtomOutOfRange; +X_API EXTERNAL Term TermOutOfRange; +X_API EXTERNAL Atom AtomOutOfStackError; +X_API EXTERNAL Term TermOutOfStackError; +X_API EXTERNAL Atom AtomOutOfTrailError; +X_API EXTERNAL Term TermOutOfTrailError; +X_API EXTERNAL Atom AtomOutput; +X_API EXTERNAL Term TermOutput; +X_API EXTERNAL Atom AtomParameter; +X_API EXTERNAL Term TermParameter; +X_API EXTERNAL Atom AtomPrologCommonsDir; +X_API EXTERNAL Term TermPrologCommonsDir; +X_API EXTERNAL Atom AtomPast; +X_API EXTERNAL Term TermPast; +X_API EXTERNAL Atom AtomPastEndOfStream; +X_API EXTERNAL Term TermPastEndOfStream; +X_API EXTERNAL Atom AtomPermissionError; +X_API EXTERNAL Term TermPermissionError; +X_API EXTERNAL Atom AtomPi; +X_API EXTERNAL Term TermPi; +X_API EXTERNAL Atom AtomPipe; +X_API EXTERNAL Term TermPipe; +X_API EXTERNAL Atom AtomPriority; +X_API EXTERNAL Term TermPriority; +X_API EXTERNAL Atom AtomPlus; +X_API EXTERNAL Term TermPlus; +X_API EXTERNAL Atom AtomPointer; +X_API EXTERNAL Term TermPointer; +X_API EXTERNAL Atom AtomPortray; +X_API EXTERNAL Term TermPortray; +X_API EXTERNAL Atom AtomPredicateIndicator; +X_API EXTERNAL Term TermPredicateIndicator; +X_API EXTERNAL Atom AtomPrimitive; +X_API EXTERNAL Term TermPrimitive; +X_API EXTERNAL Atom AtomPrintMessage; +X_API EXTERNAL Term TermPrintMessage; +X_API EXTERNAL Atom AtomPrivateProcedure; +X_API EXTERNAL Term TermPrivateProcedure; +X_API EXTERNAL Atom AtomProcedure; +X_API EXTERNAL Term TermProcedure; +X_API EXTERNAL Atom AtomProfile; +X_API EXTERNAL Term TermProfile; +X_API EXTERNAL Atom AtomProlog; +X_API EXTERNAL Term TermProlog; +X_API EXTERNAL Atom AtomProtectStack; +X_API EXTERNAL Term TermProtectStack; +X_API EXTERNAL Atom AtomQly; +X_API EXTERNAL Term TermQly; +X_API EXTERNAL Atom AtomQuery; +X_API EXTERNAL Term TermQuery; +X_API EXTERNAL Atom AtomQueue; +X_API EXTERNAL Term TermQueue; +X_API EXTERNAL Atom AtomQuiet; +X_API EXTERNAL Term TermQuiet; +X_API EXTERNAL Atom AtomRadix; +X_API EXTERNAL Term TermRadix; +X_API EXTERNAL Atom AtomRandom; +X_API EXTERNAL Term TermRandom; +X_API EXTERNAL Atom AtomRange; +X_API EXTERNAL Term TermRange; +X_API EXTERNAL Atom AtomRDiv; +X_API EXTERNAL Term TermRDiv; +X_API EXTERNAL Atom AtomRead; +X_API EXTERNAL Term TermRead; +X_API EXTERNAL Atom AtomReadOnly; +X_API EXTERNAL Term TermReadOnly; +X_API EXTERNAL Atom AtomReadWrite; +X_API EXTERNAL Term TermReadWrite; +X_API EXTERNAL Atom AtomReadutil; +X_API EXTERNAL Term TermReadutil; +X_API EXTERNAL Atom AtomReconsult; +X_API EXTERNAL Term TermReconsult; +X_API EXTERNAL Atom AtomRecordedP; +X_API EXTERNAL Term TermRecordedP; +X_API EXTERNAL Atom AtomRecordedWithKey; +X_API EXTERNAL Term TermRecordedWithKey; +X_API EXTERNAL Atom AtomRedefineWarnings; +X_API EXTERNAL Term TermRedefineWarnings; +X_API EXTERNAL Atom AtomRedoFreeze; +X_API EXTERNAL Term TermRedoFreeze; +X_API EXTERNAL Atom AtomRefoundVar; +X_API EXTERNAL Term TermRefoundVar; +X_API EXTERNAL Atom AtomRelativeTo; +X_API EXTERNAL Term TermRelativeTo; +X_API EXTERNAL Atom AtomRepeat; +X_API EXTERNAL Term TermRepeat; +X_API EXTERNAL Atom AtomRepeatSpace; +X_API EXTERNAL Term TermRepeatSpace; +X_API EXTERNAL Atom AtomReposition; +X_API EXTERNAL Term TermReposition; +X_API EXTERNAL Atom AtomRepresentationError; +X_API EXTERNAL Term TermRepresentationError; +X_API EXTERNAL Atom AtomReset; +X_API EXTERNAL Term TermReset; +X_API EXTERNAL Atom AtomResize; +X_API EXTERNAL Term TermResize; +X_API EXTERNAL Atom AtomResourceError; +X_API EXTERNAL Term TermResourceError; +X_API EXTERNAL Atom AtomRestoreRegs; +X_API EXTERNAL Term TermRestoreRegs; +X_API EXTERNAL Atom AtomRetry; +X_API EXTERNAL Term TermRetry; +X_API EXTERNAL Atom AtomRetryCounter; +X_API EXTERNAL Term TermRetryCounter; +X_API EXTERNAL Atom AtomRTree; +X_API EXTERNAL Term TermRTree; +X_API EXTERNAL Atom AtomSafe; +X_API EXTERNAL Term TermSafe; +X_API EXTERNAL Atom AtomSafeCallCleanup; +X_API EXTERNAL Term TermSafeCallCleanup; +X_API EXTERNAL Atom AtomSame; +X_API EXTERNAL Term TermSame; +X_API EXTERNAL Atom AtomSemic; +X_API EXTERNAL Term TermSemic; +X_API EXTERNAL Atom AtomShiftCountOverflow; +X_API EXTERNAL Term TermShiftCountOverflow; +X_API EXTERNAL Atom AtomSigAlarm; +X_API EXTERNAL Term TermSigAlarm; +X_API EXTERNAL Atom AtomSigBreak; +X_API EXTERNAL Term TermSigBreak; +X_API EXTERNAL Atom AtomSigCreep; +X_API EXTERNAL Term TermSigCreep; +X_API EXTERNAL Atom AtomSigDebug; +X_API EXTERNAL Term TermSigDebug; +X_API EXTERNAL Atom AtomSigDelayCreep; +X_API EXTERNAL Term TermSigDelayCreep; +X_API EXTERNAL Atom AtomSigFPE; +X_API EXTERNAL Term TermSigFPE; +X_API EXTERNAL Atom AtomSigHup; +X_API EXTERNAL Term TermSigHup; +X_API EXTERNAL Atom AtomSigInt; +X_API EXTERNAL Term TermSigInt; +X_API EXTERNAL Atom AtomSigIti; +X_API EXTERNAL Term TermSigIti; +X_API EXTERNAL Atom AtomSigPending; +X_API EXTERNAL Term TermSigPending; +X_API EXTERNAL Atom AtomSigPipe; +X_API EXTERNAL Term TermSigPipe; +X_API EXTERNAL Atom AtomSigStackDump; +X_API EXTERNAL Term TermSigStackDump; +X_API EXTERNAL Atom AtomSigStatistics; +X_API EXTERNAL Term TermSigStatistics; +X_API EXTERNAL Atom AtomSigTrace; +X_API EXTERNAL Term TermSigTrace; +X_API EXTERNAL Atom AtomSigUsr1; +X_API EXTERNAL Term TermSigUsr1; +X_API EXTERNAL Atom AtomSigUsr2; +X_API EXTERNAL Term TermSigUsr2; +X_API EXTERNAL Atom AtomSigVTAlarm; +X_API EXTERNAL Term TermSigVTAlarm; +X_API EXTERNAL Atom AtomSigWakeUp; +X_API EXTERNAL Term TermSigWakeUp; +X_API EXTERNAL Atom AtomSilent; +X_API EXTERNAL Term TermSilent; +X_API EXTERNAL Atom AtomSingle; +X_API EXTERNAL Term TermSingle; +X_API EXTERNAL Atom AtomSingleVarWarnings; +X_API EXTERNAL Term TermSingleVarWarnings; +X_API EXTERNAL Atom AtomSingleton; +X_API EXTERNAL Term TermSingleton; +X_API EXTERNAL Atom AtomSlash; +X_API EXTERNAL Term TermSlash; +X_API EXTERNAL Atom AtomSocket; +X_API EXTERNAL Term TermSocket; +X_API EXTERNAL Atom AtomSolutions; +X_API EXTERNAL Term TermSolutions; +X_API EXTERNAL Atom AtomSource; +X_API EXTERNAL Term TermSource; +X_API EXTERNAL Atom AtomSourceSink; +X_API EXTERNAL Term TermSourceSink; +X_API EXTERNAL Atom AtomSpy; +X_API EXTERNAL Term TermSpy; +X_API EXTERNAL Atom AtomStack; +X_API EXTERNAL Term TermStack; +X_API EXTERNAL Atom AtomStackFree; +X_API EXTERNAL Term TermStackFree; +X_API EXTERNAL Atom AtomStartupSavedState; +X_API EXTERNAL Term TermStartupSavedState; +X_API EXTERNAL Atom AtomStaticClause; +X_API EXTERNAL Term TermStaticClause; +X_API EXTERNAL Atom AtomStaticProcedure; +X_API EXTERNAL Term TermStaticProcedure; +X_API EXTERNAL Atom AtomStream; +X_API EXTERNAL Term TermStream; +X_API EXTERNAL Atom AtomSWIStream; +X_API EXTERNAL Term TermSWIStream; +X_API EXTERNAL Atom AtomVStream; +X_API EXTERNAL Term TermVStream; +X_API EXTERNAL Atom AtomStreams; +X_API EXTERNAL Term TermStreams; +X_API EXTERNAL Atom AtomStreamOrAlias; +X_API EXTERNAL Term TermStreamOrAlias; +X_API EXTERNAL Atom AtomStreamPos; +X_API EXTERNAL Term TermStreamPos; +X_API EXTERNAL Atom AtomStreamPosition; +X_API EXTERNAL Term TermStreamPosition; +X_API EXTERNAL Atom AtomString; +X_API EXTERNAL Term TermString; +X_API EXTERNAL Atom AtomStyleCheck; +X_API EXTERNAL Term TermStyleCheck; +X_API EXTERNAL Atom AtomSTRING; +X_API EXTERNAL Term TermSTRING; +X_API EXTERNAL Atom AtomSwi; +X_API EXTERNAL Term TermSwi; +X_API EXTERNAL Atom AtomSymbolChar; +X_API EXTERNAL Term TermSymbolChar; +X_API EXTERNAL Atom AtomSyntaxError; +X_API EXTERNAL Term TermSyntaxError; +X_API EXTERNAL Atom AtomSyntaxErrors; +X_API EXTERNAL Term TermSyntaxErrors; +X_API EXTERNAL Atom AtomSyntaxErrorHandler; +X_API EXTERNAL Term TermSyntaxErrorHandler; +X_API EXTERNAL Atom AtomSystem; +X_API EXTERNAL Term TermSystem; +X_API EXTERNAL Atom AtomSystemError; +X_API EXTERNAL Term TermSystemError; +X_API EXTERNAL Atom AtomSystemLibraryDir; +X_API EXTERNAL Term TermSystemLibraryDir; +X_API EXTERNAL Atom AtomT; +X_API EXTERNAL Term TermT; +X_API EXTERNAL Atom AtomTerm; +X_API EXTERNAL Term TermTerm; +X_API EXTERNAL Atom AtomTermExpansion; +X_API EXTERNAL Term TermTermExpansion; +X_API EXTERNAL Atom AtomTerms; +X_API EXTERNAL Term TermTerms; +X_API EXTERNAL Atom AtomText; +X_API EXTERNAL Term TermText; +X_API EXTERNAL Atom AtomTextStream; +X_API EXTERNAL Term TermTextStream; +X_API EXTERNAL Atom AtomThread; +X_API EXTERNAL Term TermThread; +X_API EXTERNAL Atom AtomThreads; +X_API EXTERNAL Term TermThreads; +X_API EXTERNAL Atom AtomThrow; +X_API EXTERNAL Term TermThrow; +X_API EXTERNAL Atom AtomTimeOutSpec; +X_API EXTERNAL Term TermTimeOutSpec; +X_API EXTERNAL Atom AtomTimeoutError; +X_API EXTERNAL Term TermTimeoutError; +X_API EXTERNAL Atom AtomTopLevelGoal; +X_API EXTERNAL Term TermTopLevelGoal; +X_API EXTERNAL Atom AtomTopThreadGoal; +X_API EXTERNAL Term TermTopThreadGoal; +X_API EXTERNAL Atom AtomTraceMetaCall; +X_API EXTERNAL Term TermTraceMetaCall; +X_API EXTERNAL Atom AtomTrail; +X_API EXTERNAL Atom AtomTrue; +X_API EXTERNAL Term TermTrue; +X_API EXTERNAL Atom AtomTty; +X_API EXTERNAL Term TermTty; +X_API EXTERNAL Atom AtomTtys; +X_API EXTERNAL Term TermTtys; +X_API EXTERNAL Atom AtomTuple; +X_API EXTERNAL Term TermTuple; +X_API EXTERNAL Atom AtomTxt; +X_API EXTERNAL Term TermTxt; +X_API EXTERNAL Atom AtomTypeError; +X_API EXTERNAL Term TermTypeError; +X_API EXTERNAL Atom AtomUndefined; +X_API EXTERNAL Term TermUndefined; +X_API EXTERNAL Atom AtomUndefp; +X_API EXTERNAL Term TermUndefp; +X_API EXTERNAL Atom AtomUndefp0; +X_API EXTERNAL Term TermUndefp0; +X_API EXTERNAL Atom AtomUnderflow; +X_API EXTERNAL Term TermUnderflow; +X_API EXTERNAL Atom AtomUnificationStack; +X_API EXTERNAL Term TermUnificationStack; +X_API EXTERNAL Atom AtomUnique; +X_API EXTERNAL Term TermUnique; +X_API EXTERNAL Atom AtomUnsignedByte; +X_API EXTERNAL Term TermUnsignedByte; +X_API EXTERNAL Atom AtomUnsignedChar; +X_API EXTERNAL Term TermUnsignedChar; +X_API EXTERNAL Atom AtomUser; +X_API EXTERNAL Term TermUser; +X_API EXTERNAL Atom AtomUserErr; +X_API EXTERNAL Term TermUserErr; +X_API EXTERNAL Atom AtomUserIn; +X_API EXTERNAL Term TermUserIn; +X_API EXTERNAL Atom AtomUserOut; +X_API EXTERNAL Term TermUserOut; +X_API EXTERNAL Atom AtomDollarVar; +X_API EXTERNAL Term TermDollarVar; +X_API EXTERNAL Atom AtomVBar; +X_API EXTERNAL Term TermVBar; +X_API EXTERNAL Atom AtomVarBranches; +X_API EXTERNAL Term TermVarBranches; +X_API EXTERNAL Atom AtomVariableNames; +X_API EXTERNAL Term TermVariableNames; +X_API EXTERNAL Atom AtomHiddenVar; +X_API EXTERNAL Term TermHiddenVar; +X_API EXTERNAL Atom AtomVariable; +X_API EXTERNAL Term TermVariable; +X_API EXTERNAL Atom AtomVerbose; +X_API EXTERNAL Term TermVerbose; +X_API EXTERNAL Atom AtomVerboseFileSearch; +X_API EXTERNAL Term TermVerboseFileSearch; +X_API EXTERNAL Atom AtomVersionNumber; +X_API EXTERNAL Term TermVersionNumber; +X_API EXTERNAL Atom AtomVeryVerbose; +X_API EXTERNAL Term TermVeryVerbose; +X_API EXTERNAL Atom AtomWakeUpGoal; +X_API EXTERNAL Term TermWakeUpGoal; +X_API EXTERNAL Atom AtomWarning; +X_API EXTERNAL Term TermWarning; +X_API EXTERNAL Atom AtomWhen; +X_API EXTERNAL Term TermWhen; +X_API EXTERNAL Atom AtomWrite; +X_API EXTERNAL Term TermWrite; +X_API EXTERNAL Atom AtomWriteTerm; +X_API EXTERNAL Term TermWriteTerm; +X_API EXTERNAL Atom AtomXml; +X_API EXTERNAL Term TermXml; +X_API EXTERNAL Atom AtomYapHacks; +X_API EXTERNAL Term TermYapHacks; +X_API EXTERNAL Atom AtomZeroDivisor; +X_API EXTERNAL Term TermZeroDivisor; +X_API EXTERNAL Functor FunctorAfInet; + +X_API EXTERNAL Functor FunctorAfLocal; + +X_API EXTERNAL Functor FunctorAfUnix; + +X_API EXTERNAL Functor FunctorAltNot; + +X_API EXTERNAL Functor FunctorArg; + +X_API EXTERNAL Functor FunctorArrayEntry; + +X_API EXTERNAL Functor FunctorArrow; + +X_API EXTERNAL Functor FunctorDoubleArrow; + +X_API EXTERNAL Functor FunctorAssert1; + +X_API EXTERNAL Functor FunctorAssert; + +X_API EXTERNAL Functor FunctorAtFoundOne; + +X_API EXTERNAL Functor FunctorAtom; + +X_API EXTERNAL Functor FunctorAtt1; + +X_API EXTERNAL Functor FunctorAttGoal; + +X_API EXTERNAL Functor FunctorBraces; + +X_API EXTERNAL Functor FunctorCall; + +X_API EXTERNAL Functor FunctorCatch; + +X_API EXTERNAL Functor FunctorChangeModule; + +X_API EXTERNAL Functor FunctorChars; + +X_API EXTERNAL Functor FunctorChars1; + +X_API EXTERNAL Functor FunctorCleanCall; + +X_API EXTERNAL Functor FunctorClist; + +X_API EXTERNAL Functor FunctorCodes; + +X_API EXTERNAL Functor FunctorCodes1; + +X_API EXTERNAL Functor FunctorColon; + +X_API EXTERNAL Functor FunctorComma; + +X_API EXTERNAL Functor FunctorCommentHook; + +X_API EXTERNAL Functor FunctorContext2; + +X_API EXTERNAL Functor FunctorConsistencyError; + +X_API EXTERNAL Functor FunctorCreep; + +X_API EXTERNAL Functor FunctorCsult; + +X_API EXTERNAL Functor FunctorCurrentModule; + +X_API EXTERNAL Functor FunctorCutBy; + +X_API EXTERNAL Functor FunctorDBREF; + +X_API EXTERNAL Functor FunctorDiff; + +X_API EXTERNAL Functor FunctorDoLogUpdClause; + +X_API EXTERNAL Functor FunctorDoLogUpdClause0; + +X_API EXTERNAL Functor FunctorDoLogUpdClauseErase; + +X_API EXTERNAL Functor FunctorDoStaticClause; + +X_API EXTERNAL Functor FunctorDollar; + +X_API EXTERNAL Functor FunctorDollarVar; + +X_API EXTERNAL Functor FunctorDomainError; + +X_API EXTERNAL Functor FunctorDot; + +X_API EXTERNAL Functor FunctorDot10; + +X_API EXTERNAL Functor FunctorDot11; + +X_API EXTERNAL Functor FunctorDot12; + +X_API EXTERNAL Functor FunctorDot2; + +X_API EXTERNAL Functor FunctorDot3; + +X_API EXTERNAL Functor FunctorDot4; + +X_API EXTERNAL Functor FunctorDot5; + +X_API EXTERNAL Functor FunctorDot6; + +X_API EXTERNAL Functor FunctorDot7; + +X_API EXTERNAL Functor FunctorDot8; + +X_API EXTERNAL Functor FunctorDot9; + +X_API EXTERNAL Functor FunctorDoubleArrow; + +X_API EXTERNAL Functor FunctorDoubleSlash; + +X_API EXTERNAL Functor FunctorEmptySquareBrackets; + +X_API EXTERNAL Functor FunctorEq; + +X_API EXTERNAL Functor FunctorError; + +X_API EXTERNAL Functor FunctorEvaluationError; + +X_API EXTERNAL Functor FunctorException; + +X_API EXTERNAL Functor FunctorExecute2InMod; + +X_API EXTERNAL Functor FunctorExecuteInMod; + +X_API EXTERNAL Functor FunctorExecuteWithin; + +X_API EXTERNAL Functor FunctorExistenceError; + +X_API EXTERNAL Functor FunctorExoClause; + +X_API EXTERNAL Functor FunctorFunctor; + +X_API EXTERNAL Functor FunctorGAtom; + +X_API EXTERNAL Functor FunctorGAtomic; + +X_API EXTERNAL Functor FunctorGCompound; + +X_API EXTERNAL Functor FunctorGFloat; + +X_API EXTERNAL Functor FunctorGFormatAt; + +X_API EXTERNAL Functor FunctorGInteger; + +X_API EXTERNAL Functor FunctorGNumber; + +X_API EXTERNAL Functor FunctorGPrimitive; + +X_API EXTERNAL Functor FunctorGVar; + +X_API EXTERNAL Functor FunctorGeneratePredInfo; + +X_API EXTERNAL Functor FunctorGoalExpansion2; + +X_API EXTERNAL Functor FunctorGoalExpansion; + +X_API EXTERNAL Functor FunctorHandleThrow; + +X_API EXTERNAL Functor FunctorHat; + +X_API EXTERNAL Functor FunctorI; + +X_API EXTERNAL Functor FunctorId; + +X_API EXTERNAL Functor FunctorInfo1; + +X_API EXTERNAL Functor FunctorInfo2; + +X_API EXTERNAL Functor FunctorInfo3; + +X_API EXTERNAL Functor FunctorInfo4; + +X_API EXTERNAL Functor FunctorIs; + +X_API EXTERNAL Functor FunctorJ; + +X_API EXTERNAL Functor FunctorLastExecuteWithin; + +X_API EXTERNAL Functor FunctorList; + +X_API EXTERNAL Functor FunctorLOOP; + +X_API EXTERNAL Functor FunctorMegaClause; + +X_API EXTERNAL Functor FunctorMetaCall; + +X_API EXTERNAL Functor FunctorMinus; + +X_API EXTERNAL Functor FunctorModule; + +X_API EXTERNAL Functor FunctorMultiFileClause; + +X_API EXTERNAL Functor FunctorMutable; + +X_API EXTERNAL Functor FunctorMutex; + +X_API EXTERNAL Functor FunctorNotImplemented; + +X_API EXTERNAL Functor FunctorNBQueue; + +X_API EXTERNAL Functor FunctorNot; + +X_API EXTERNAL Functor FunctorObj; + +X_API EXTERNAL Functor FunctorOr; + +X_API EXTERNAL Functor FunctorOutput; + +X_API EXTERNAL Functor FunctorPermissionError; + +X_API EXTERNAL Functor FunctorPlus; + +X_API EXTERNAL Functor FunctorPortray; + +X_API EXTERNAL Functor FunctorPrintMessage; + +X_API EXTERNAL Functor FunctorProcedure; + +X_API EXTERNAL Functor FunctorPriority; + +X_API EXTERNAL Functor FunctorPrologConstraint; + +X_API EXTERNAL Functor FunctorProtectStack; + +X_API EXTERNAL Functor FunctorQuery; + +X_API EXTERNAL Functor FunctorRecordedWithKey; + +X_API EXTERNAL Functor FunctorRDiv; + +X_API EXTERNAL Functor FunctorRedoFreeze; + +X_API EXTERNAL Functor FunctorRepresentationError; + +X_API EXTERNAL Functor FunctorResourceError; + +X_API EXTERNAL Functor FunctorRestoreRegs; + +X_API EXTERNAL Functor FunctorRestoreRegs1; + +X_API EXTERNAL Functor FunctorSafe; + +X_API EXTERNAL Functor FunctorSafeCallCleanup; + +X_API EXTERNAL Functor FunctorSame; + +X_API EXTERNAL Functor FunctorSlash; + +X_API EXTERNAL Functor FunctorStaticClause; + +X_API EXTERNAL Functor FunctorStream; + +X_API EXTERNAL Functor FunctorStreamEOS; + +X_API EXTERNAL Functor FunctorStreamPos; + +X_API EXTERNAL Functor FunctorString1; + +X_API EXTERNAL Functor FunctorStyleCheck; + +X_API EXTERNAL Functor FunctorSyntaxError; + +X_API EXTERNAL Functor FunctorShortSyntaxError; + +X_API EXTERNAL Functor FunctorTermExpansion; + +X_API EXTERNAL Functor FunctorThreadRun; + +X_API EXTERNAL Functor FunctorThrow; + +X_API EXTERNAL Functor FunctorTimeoutError; + +X_API EXTERNAL Functor FunctorTraceMetaCall; + +X_API EXTERNAL Functor FunctorTypeError; + +X_API EXTERNAL Functor FunctorUMinus; + +X_API EXTERNAL Functor FunctorUPlus; + +X_API EXTERNAL Functor FunctorVBar; + +X_API EXTERNAL Functor FunctorWriteTerm; + +X_API EXTERNAL Functor FunctorHiddenVar; diff --git a/H/tracer.h b/H/tracer.h index 055a64437..f63dc7b13 100644 --- a/H/tracer.h +++ b/H/tracer.h @@ -38,8 +38,8 @@ typedef enum { #define low_level_trace(Port, pred, args) low_level_trace__(Port, pred, args) #endif -void low_level_trace__(yap_low_level_port, PredEntry *, CELL *); -void Yap_InitLowLevelTrace(void); -void toggle_low_level_trace(void); +extern bool low_level_trace__(yap_low_level_port, PredEntry *, CELL *); +extern void Yap_InitLowLevelTrace(void); +extern void toggle_low_level_trace(void); #endif diff --git a/JIT/HPP/jit_predicates.hpp b/JIT/HPP/jit_predicates.hpp index 1d6785faa..2289b9a05 100644 --- a/JIT/HPP/jit_predicates.hpp +++ b/JIT/HPP/jit_predicates.hpp @@ -1,7 +1,7 @@ #include "Yap.h" #include "amijit.h" #include "clause.h" -#include "eval.h" +#include "YapEval.h" #if HAVE_ERRNO_H #include #else diff --git a/OPTYap/CMakeLists.txt b/OPTYap/CMakeLists.txt index 5ff5aee35..c3cd06398 100644 --- a/OPTYap/CMakeLists.txt +++ b/OPTYap/CMakeLists.txt @@ -76,16 +76,17 @@ endif (WITH_YAPOR_SBA) if (WITH_YAPOR) - set_property(DIRECTORY .. APPEND PROPERTY COMPILE_DEFINITIONS YAPOR=1) + set_property(DIRECTORY .. APPEND PROPERTY COMPILE_DEFINITIONS YAPOR=1;YAP_KERNEL=1) endif () set (POSITION_INDEPENDENT_CODE TRUE) +SET_PROPERTY(DIRECTORY PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 ) add_component (libOPTYap ${OPTYap_SOURCES} ) -MY_set_target_properties(libOPTYap +My_set_target_properties(libOPTYap PROPERTIES # RPATH ${libdir} VERSION ${LIBYAPTAI_FULL_VERSION} # SOVERSION ${LIBYAPTAI_MAJOR_VERSION}.${LIBYAPTAI_MINOR_VERSION} diff --git a/OPTYap/opt.preds.c b/OPTYap/opt.preds.c index 77d4182e8..fa7a69445 100644 --- a/OPTYap/opt.preds.c +++ b/OPTYap/opt.preds.c @@ -170,7 +170,7 @@ struct page_statistics { #define INCREMENT_AUX_STATS(STATS, BYTES, PAGES) \ BYTES += PgEnt_bytes_in_use(STATS) #define SHOW_PAGE_STATS_MSG(STR_NAME) \ - " %s %10" Int_F "s bytes (%ld structs in use)\n", STR_NAME + " %s %10" Int_F "s bytes (%" Sizet_F " ; structs in use)\n", STR_NAME #define SHOW_PAGE_STATS_ARGS(STATS, STR_TYPE) \ PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE), PgEnt_strs_in_use(STATS) #endif /* USE_PAGES_MALLOC */ diff --git a/OPTYap/tab.tries.c b/OPTYap/tab.tries.c index cf05c885c..9f21e184d 100644 --- a/OPTYap/tab.tries.c +++ b/OPTYap/tab.tries.c @@ -19,7 +19,7 @@ #ifdef TABLING #include "Yatom.h" #include "YapHeap.h" -#include "eval.h" +#include "YapEval.h" #include "tab.macros.h" static inline sg_node_ptr diff --git a/Packages.cmake b/Packages.cmake index 92f84b166..76096a280 100644 --- a/Packages.cmake +++ b/Packages.cmake @@ -38,6 +38,8 @@ ENDIF(WITH_CPLINT) #must be last +add_subDIRECTORY (packages/python) + OPTION (WITH_SWIG " Enable SWIG interfaces to foreign languages" ON) IF (WITH_SWIG) add_subDIRECTORY (packages/swig) @@ -67,7 +69,6 @@ endif() add_subDIRECTORY (packages/real) -add_subDIRECTORY (packages/python) add_subDIRECTORY (packages/jpl) diff --git a/autoconf/Makefile.in b/autoconf/Makefile.in index 02630b031..54e6e5395 100755 --- a/autoconf/Makefile.in +++ b/autoconf/Makefile.in @@ -167,13 +167,13 @@ HEADERS = \ H/attvar.h \ H/blobs.h \ H/clause.h \ - H/compile.h \ + H/YapCöompile.h \ H/corout.h \ H/dlmalloc.h \ H/dglobals.h \ H/dlocals.h \ H/dhstruct.h \ - H/eval.h \ + H/YapEval.h \ H/heapgc.h \ H/hglobals.h \ H/hlocals.h \ diff --git a/cmake/Config.cmake b/cmake/Config.cmake index 4b5c288fb..52da0d98d 100644 --- a/cmake/Config.cmake +++ b/cmake/Config.cmake @@ -145,30 +145,30 @@ endif (HAVE_LIBDL) if (WIN32) check_library_exists(comdlg32 FindText "" HAVE_LIBCOMDLG32) - if (HAVE_LIBCOMDLG32) + #if (HAVE_LIBCOMDLG32) - set(EXTRALIBS ${EXTRALIBS} comdlg32) - endif (HAVE_LIBCOMDLG32) + set(WINDLLS ${WINDLLS} comdlg32) + #endif (HAVE_LIBCOMDLG32) check_library_exists(msvcrt strtok "" HAVE_LIBMSCRT) - if (HAVE_LIBMSCRT) - set(EXTRALIBS ${EXTRALIBS} mscrt) - endif (HAVE_LIBMSCRT) +#if (HAVE_LIBMSCRT) + set(WINDLLS ${WINDLLS} mscrt) + #endif (HAVE_LIBMSCRT) check_library_exists(shell32 main "" HAVE_LIBSHELL32) - if (HAVE_LIBSHELL32) - set(EXTRALIBS ${EXTRALIBS} shell32) - endif (HAVE_LIBSHELL32) + #if (HAVE_LIBSHELL32) + set(WINDLLS ${WINDLLS} shell32) + #endif (HAVE_LIBSHELL32) check_library_exists(wsock32 main "" HAVE_LIBWSOCK32) - if (HAVE_LIBWSOCK32) - set(EXTRALIBS ${EXTRALIBS} wsock32) - endif (HAVE_LIBWSOCK32) + #if (HAVE_LIBWSOCK32) + set(WINDLLS ${WINDLLS} wsock32) + #endif (HAVE_LIBWSOCK32) check_library_exists(ws2_32 main "" HAVE_LIBWS2_32) - if (HAVE_LIBWS2_32) - set(EXTRALIBS ${EXTRALIBS} ws2_32) - endif (HAVE_LIBWS2_32) + #if (HAVE_LIBWS2_32 OR TRUE) + set(WINDLLS ${WINDLLS} ws2_32) + #endif (HAVE_LIBWS2_32) endif () check_library_exists(judy Judy1Set "" HAVE_LIBJUDY) diff --git a/cmake/Model.cmake b/cmake/Model.cmake index 1ec8215ec..bb238bdfe 100644 --- a/cmake/Model.cmake +++ b/cmake/Model.cmake @@ -17,6 +17,7 @@ site_name( YAP_SITE ) if (WIN32) set (YAP_ARCH $ENV{PROCESSOR_ARCHITECTURE}) + set_property( DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "MS_WIN64=1" ) set(YAP_SYSTEM_OPTIONS "windows " ${YAP_SYSTEM_OPTIONS}) endif() if (UNIX) diff --git a/Prelims.cmake b/cmake/Prelims.cmake similarity index 99% rename from Prelims.cmake rename to cmake/Prelims.cmake index ccc7ca5ad..a7c4e5290 100644 --- a/Prelims.cmake +++ b/cmake/Prelims.cmake @@ -138,11 +138,11 @@ endif() set ( includedir "${prefix}/include") set ( exec_prefix "${prefix}") set ( libdir "${exec_prefix}/lib") -set ( dlls "${exec_prefix}/lib/Yap") set ( datadir "${datarootdir}") set ( mandir "${datarootdir}/man") set ( bindir "${exec_prefix}/bin") set ( docdir "${datarootdir}/doc/Yap") +set ( dlls "${exec_prefix}/lib/Yap") set(YAP_ROOTDIR ${prefix}) @@ -164,4 +164,3 @@ set(YAP_ROOTDIR "${prefix}") include (cudd NO-POLICY-SCOPE) include (python NO-POLICY-SCOPE) include (java NO-POLICY-SCOPE) - diff --git a/cmake/Sources.cmake b/cmake/Sources.cmake index 778867c94..715808c86 100644 --- a/cmake/Sources.cmake +++ b/cmake/Sources.cmake @@ -124,13 +124,13 @@ list(APPEND LIBYAP_SOURCES ${C_INTERFACE_SOURCES} ${ENGINE_SOURCES}) H/attvar.h H/blobs.h H/clause.h - H/compile.h + H/YapCompile.h H/corout.h H/dlmalloc.h H/generated/dglobals.h H/generated/dlocals.h H/generated/dhstruct.h - H/eval.h + H/YapEval.h H/heapgc.h H/generated/hglobals.h H/generated/hlocals.h diff --git a/cmake/python.cmake b/cmake/python.cmake index 288e2ca1e..c640cbbd1 100644 --- a/cmake/python.cmake +++ b/cmake/python.cmake @@ -1,40 +1,73 @@ option (WITH_PYTHON - "Allow Python->YAP and YAP->Python" ON) +"Allow Python->YAP and YAP->Python" ON) + +# PYTHONLIBS_FOUND - have the Python libs been found +# PYTHON_LIBRARIES - path to the python library +# PYTHON_INCLUDE_PATH - path to where Python.h is found (deprecated) +# PYTHON_INCLUDE_DIRS - path to where Python.h is found +# PYTHON_DEBUG_LIBRARIES - path to the debug library (deprecated) +# PYTHONLIBS_VERSION_STRING - version of the Python libs found (since CMake 2.8.8) +# +# IF (WITH_PYTHON) + set (Python_ADDITIONAL_VERSIONS 3.5 3.6 3.4 3.3) -#BREW install for Python3 + find_package(PythonInterp) + # find_package(PythonLibs) -if (APPLE) -foreach (i 3.6 3.5 3.4 3.3 3.2 3.1 3.0) - set (PYTHON_INCLUDE_DIRS /usr/local/Frameworks/Python.framework/Versions/${i}/Headers) - message("Trying Python ${i}") - if (EXISTS ${PYTHON_INCLUDE_DIRS}) - set (PYTHON_EXECUTABLE /usr/local/bin/python${i} CACHE FILEPATH "Path to a program" FORCE ) - set (PYTHON_INCLUDE_DIR /usr/local/Frameworks/Python.framework/Versions/${i}/include/python${i}m - CACHE PATH "Path to a file." FORCE ) - set (PYTHON_LIBRARY /usr/local/Frameworks/Python.framework/Versions/${i}/lib/libpython${i}.dylib - CACHE FILEPATH "Path to a library" FORCE ) - break() - endif() -endforeach() + execute_process ( COMMAND ${PYTHON_EXECUTABLE} -c "import sysconfig; print( sysconfig.get_path( 'include' ) )" +OUTPUT_VARIABLE _ABS_PYTHON_INCLUDE_PATH +OUTPUT_STRIP_TRAILING_WHITESPACE ) +get_filename_component ( ABS_PYTHON_INCLUDE_PATH ${_ABS_PYTHON_INCLUDE_PATH} ABSOLUTE ) + + set ( PYTHON_INCLUDE_DIR + ${ABS_PYTHON_INCLUDE_PATH} + CACHE "PATH" "Directory with Python.h " + ) + + set ( PYTHON_INCLUDE_DIRS + ${ABS_PYTHON_INCLUDE_PATH} + CACHE "PATH" "Python.h Dir (Deprecated)" + ) + + execute_process ( COMMAND ${PYTHON_EXECUTABLE} -c "import sysconfig; print( sysconfig.get_path( 'stdlib' ) )" + OUTPUT_VARIABLE _ABS_PYTHON_SYSLIB_PATH + OUTPUT_STRIP_TRAILING_WHITESPACE ) + + set( _ABS_PYTHON_SYSLIB_PATH + ${_ABS_PYTHON_SYSLIB_PATH}/../${CMAKE_SHARED_LIBRARY_PREFIX}python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}m${CMAKE_SHARED_LIBRARY_SUFFIX} ) + message("${_ABS_PYTHON_SYSLIB_PATH}") + get_filename_component ( ABS_PYTHON_SYSLIB_PATH ${_ABS_PYTHON_SYSLIB_PATH} ABSOLUTE ) + + + set ( PYTHON_LIBRARY + ${ABS_PYTHON_SYSLIB_PATH} + CACHE "FILEPATH" "Python Library" + ) + set ( PYTHON_LIBRARIES + ${PYTHON_LIBRARY} + CACHE "FILEPATH" "Python Library (Deprecated)" + ) + if ( (EXISTS PYTHON_LIBRARY) AND ( EXISTS ${PYTHON_INCLUDE_DIR}) ) + set ( PYTHONLIBS_FOUND ON) else() -set (Python_ADDITIONAL_VERSIONS 3.6 3.5 3.4 3.3 3.2 3.1 3.0 2.8 2.6 2.5) +find_package(PythonLibs) endif() -find_package(PythonInterp) -find_package(PythonLibs) + macro_log_feature (PYTHONLIBS_FOUND "Python" + "Use Python System" + "http://www.python.org" FALSE) - macro_log_feature (PYTHONLIBS_FOUND "Python" - "Use Python System" - "http://www.python.org" FALSE) -#include_directories( ${PYTHON_INCLUDE_DIRS} ) + include_directories( BEFORE ${PYTHON_INCLUDE_DIR} ) + + LIST( APPEND + CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_DIR} ${CMAKE_REQUIRED_INCLUDES} ) + + check_include_file(Python.h HAVE_PYTHON_H) -set( CMAKE_REQUIRED_INCLUDES ${PYTHON_INCLUDE_DIRS} ${CMAKE_REQUIRED_INCLUDES} ) -check_include_file(Python.h HAVE_PYTHON_H) endif(WITH_PYTHON) - diff --git a/config.h.cmake b/config.h.cmake index 02fab125e..23eb68f79 100644 --- a/config.h.cmake +++ b/config.h.cmake @@ -2036,5 +2036,30 @@ calls it, or to nothing if 'inline' is not supported under any name. */ #define free(pt) my_free(pt) #endif +#ifdef _WIN32 +#ifndef __WINDOWS__ +#define __WINDOWS__ 1 +#endif +#endif + + +/** + * X_API macro + * + * @brief Linux exports all symbols by default, but WIN32 does + * not. cmake can enable exports, using CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS + * + * @param _WIN32 + * + * @return + */ +#if _WIN32 && !defined(YAP_KERNEL) +#define X_API __declspec(dllimport) +#else +#define X_API +#endif +#define O_API + + #endif diff --git a/configure b/configure index d93ba3d4d..9ef3492c9 100755 --- a/configure +++ b/configure @@ -28,13 +28,14 @@ BUILD_TYPE="Debug" PREFIX=/usr/local LIBDIR= CMAKE_ARGS= +GENERATOR="" if [ -e "${TOP_SRCDIR}/.configure-custom.sh" ]; then . "${TOP_SRCDIR}/.configure-custom.sh" fi quote() { - echo "$1" | sed -e "s|'|'\\\\''|g; 1s/^/'/; \$s/\$/'/" + echo "$*" | sed -e "s|'|'\\\\''|g; 1s/^/'/; \$s/\$/'/" } extract_var_string() { @@ -163,6 +164,8 @@ print_help() { --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/PROJECT_NAME] + + --generato=Generator Specify the tool used to send callss EOF first=y @@ -288,6 +291,13 @@ while [ $# != 0 ]; do "--docdir") CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_INSTALL_DOCDIR=$(quote "$2")"; shift;; + "--generator="*) + GENERATOR="$CMAKE_ARGS -G $(1#*=)";; + + "-G"|"--generator") + GENERATOR="$CMAKE_ARGS -G$(quote "$2")"; + shift;; + "CC="*) CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_C_COMPILER=$(quote "${1#*=}")";; "CXX="*) @@ -295,7 +305,7 @@ while [ $# != 0 ]; do "CFLAGS="*) CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_C_FLAGS=$(quote "${1#*=}")";; "CXXFLAGS="*) - CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_CXX_FLAGS=$(quote "${1#*=}")";; + CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_CXX_FLAGS=$(quote "${1#*=}")";; "LDFLAGS="*) LDFLAGS="$LDFLAGS ${1#*=}";; @@ -362,4 +372,5 @@ if [ "x${LDFLAGS}" != "x" ]; then fi CMAKE_CMD="${CMAKE} ${TOP_SRCDIR}" -${CMAKE_CMD} ${TOP_SRCDIR} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=${PREFIX} -DCMAKE_INSTALL_LIBDIR=${LIBDIR} ${CMAKE_ARGS} + +${CMAKE_CMD} "${GENERATOR}" ${TOP_SRCDIR} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=${PREFIX} -DCMAKE_INSTALL_LIBDIR=${LIBDIR} ${CMAKE_ARGS} diff --git a/gtags.conf b/gtags.conf new file mode 100644 index 000000000..f9966d04b --- /dev/null +++ b/gtags.conf @@ -0,0 +1,46 @@ +# +# Copyright (c) 1998, 1999, 2000, 2001, 2002, 2003, 2010, 2011, 2013, +# 2015, 2016 +# Tama Communications Corporation +# +# This file is part of GNU GLOBAL. +# +# This file is free software; as a special exception the author gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# +# * +# Configuration file for GNU GLOBAL source code tag system. +# +# Basically, GLOBAL doesn't need this file ('gtags.conf'), because it has +# default values in itsself. If you have the file as '/etc/gtags.conf' or +# "$HOME/.globalrc" in your system then GLOBAL overwrite the default values +# with the values in the file. +# +# The format is similar to termcap(5). You can specify a target with +# GTAGSLABEL environment variable. Default target is 'default'. +# +# If you want to have a common record for yourself, it is recommended to +# use the following method: +# + +common: + :skip=Debug/,Release/,Threads/,mxe/,xcode/,codeblocks/,Qt/,xcode/,android/,compile_commands.json,xml/,YAPDroid/app/build/,YAPDroid/lib/build/:HTML/,HTML.pub/,tags,TAGS,ID,y.tab.c,y.tab.h,gtags.files,cscope.files,cscope.out,cscope.po.out,cscope.in.out,SCCS/,RCS/,CVS/,CVSROOT/,{arch}/,autom4te.cache/,*.orig,*.rej,*.bak,*~,#*#,*.swp,*.tmp,*_flymake.*,*_flymake: + + +# +# A common map for both Exuberant Ctags and Universal Ctags. +# Don't include definitions of ctagscom and ctagslib in this entry. +# +default:\ + yap:native:user: + +yap:\ + :tc=common:\ + :langmap=Prolog\:.pl.yap.ypp.P.prolog:\ + :gtags_parser=Prolog\:$ctagslib: + diff --git a/include/SWI-Prolog.h b/include/SWI-Prolog.h index 43c7352c2..69735c8e1 100755 --- a/include/SWI-Prolog.h +++ b/include/SWI-Prolog.h @@ -18,7 +18,7 @@ extern "C" { #endif //=== includes =============================================================== -#ifdef _YAP_NOT_INSTALLED_ +#ifdef YAP_KERNEL #include "config.h" #ifdef __cplusplus @@ -26,9 +26,13 @@ extern "C" { #endif -#if USE_GMP && !defined(__cplusplus) +#if USE_GMP +#if defined(__cplusplus) +#include +#else #include #endif +#endif #ifdef __cplusplus extern "C" { @@ -36,12 +40,14 @@ extern "C" { #include "YapInterface.h" #else -#include -#if USE_GMP -#include -#endif +#if _YAP_NOT_INSTALLED_ +#include +#include +#else +#include #include #endif +#endif #include #include #include @@ -85,35 +91,9 @@ See SWI-Prolog.h, containing the same code for an explanation on this stuff. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ -#ifndef _PL_EXPORT_DONE -#define _PL_EXPORT_DONE - -#if (defined(__WINDOWS__) || defined(__CYGWIN__) || defined(__MINGW32__)) && !defined(__LCC__) -#define HAVE_DECLSPEC -#endif - -#ifdef HAVE_DECLSPEC -# ifdef _YAP_NOT_INSTALLED_ -#define PL_EXPORT(type) __declspec(dllexport) type -#define PL_EXPORT_DATA(type) __declspec(dllexport) type -#define install_t void -# else -# ifdef __BORLANDC__ -#define PL_EXPORT(type) type _stdcall -#define PL_EXPORT_DATA(type) extern type -# else -#define PL_EXPORT(type) extern type -#define PL_EXPORT_DATA(type) __declspec(dllimport) type -# endif -#define install_t __declspec(dllexport) void -# endif -#else /*HAVE_DECLSPEC*/ -#define PL_EXPORT(type) extern type -#define PL_EXPORT_DATA(type) extern type -#define install_t void -#endif /*HAVE_DECLSPEC*/ -#endif /*_PL_EXPORT_DONE*/ - +#define PL_EXPORT(type) extern X_API type +#define PL_EXPORT_DATA(type) extern X_API type +#define install_t O_API void /******************************* * GCC ATTRIBUTES * @@ -403,102 +383,101 @@ PL_EXPORT(int) PL_chars_to_term(const char *chars, #define PL_fail return FALSE /* fail */ #define PL_succeed return TRUE /* success */ -extern X_API PL_agc_hook_t PL_agc_hook(PL_agc_hook_t); -extern X_API char* PL_atom_chars(atom_t); -extern X_API char* PL_atom_nchars(atom_t, size_t *); -extern X_API term_t PL_copy_term_ref(term_t); -extern X_API term_t PL_new_term_ref(void); -extern X_API term_t PL_new_term_refs(int); -extern X_API void PL_reset_term_refs(term_t); + PL_EXPORT( PL_agc_hook_t ) PL_agc_hook(PL_agc_hook_t); + PL_EXPORT( char* ) PL_atom_chars(atom_t); + PL_EXPORT( char* ) PL_atom_nchars(atom_t, size_t *); + PL_EXPORT( term_t ) PL_copy_term_ref(term_t); + PL_EXPORT( term_t ) PL_new_term_ref(void); + PL_EXPORT( term_t ) PL_new_term_refs(int); + PL_EXPORT( void ) PL_reset_term_refs(term_t); /* begin PL_get_* functions =============================*/ -extern X_API int PL_get_arg(int, term_t, term_t); -extern X_API int _PL_get_arg(int, term_t, term_t); -extern X_API int PL_get_atom(term_t, atom_t *); -extern X_API int PL_get_atom_chars(term_t, char **); -extern X_API int PL_get_atom_nchars(term_t, size_t *, char **); -extern X_API int PL_get_bool(term_t, int *); -extern X_API int PL_get_chars(term_t, char **, unsigned); -extern X_API int PL_get_nchars(term_t, size_t *, char **, unsigned); -extern X_API int PL_get_wchars(term_t, size_t *, wchar_t **, unsigned); -extern X_API int PL_get_functor(term_t, functor_t *); -extern X_API int PL_get_compound_name_arity(term_t t, atom_t *ap, int *ip); -extern X_API int PL_get_float(term_t, double *); -extern X_API int PL_get_head(term_t, term_t); -extern X_API int PL_get_int64(term_t, int64_t *); -extern X_API int PL_get_integer(term_t, int *); -extern X_API int PL_get_list(term_t, term_t, term_t); -extern X_API int PL_get_long(term_t, long *); -extern X_API int PL_get_list_chars(term_t, char **, unsigned); -extern X_API int PL_get_list_nchars(term_t, size_t *, char **, unsigned); -extern X_API int PL_get_module(term_t, module_t *); -extern X_API module_t PL_context(void); -extern X_API int PL_strip_module(term_t, module_t *, term_t); -extern X_API atom_t PL_module_name(module_t); -extern X_API module_t PL_new_module(atom_t); -extern X_API int PL_get_name_arity(term_t, atom_t *, int *); -extern X_API int PL_get_nil(term_t); -extern X_API int PL_get_pointer(term_t, void **); -extern X_API int PL_get_intptr(term_t, intptr_t *); -extern X_API int PL_get_uintptr(term_t, uintptr_t *); -extern X_API int PL_get_tail(term_t, term_t); + PL_EXPORT( int ) PL_get_arg(int, term_t, term_t); + PL_EXPORT( int ) PL_get_atom(term_t, atom_t *); + PL_EXPORT( int ) PL_get_atom_chars(term_t, char **); + PL_EXPORT( int ) PL_get_atom_nchars(term_t, size_t *, char **); + PL_EXPORT( int ) PL_get_bool(term_t, int *); + PL_EXPORT( int ) PL_get_chars(term_t, char **, unsigned); + PL_EXPORT( int ) PL_get_nchars(term_t, size_t *, char **, unsigned); + PL_EXPORT( int ) PL_get_wchars(term_t, size_t *, wchar_t **, unsigned); + PL_EXPORT( int ) PL_get_functor(term_t, functor_t *); + PL_EXPORT( int ) PL_get_compound_name_arity(term_t t, atom_t *ap, int *ip); + PL_EXPORT( int ) PL_get_float(term_t, double *); + PL_EXPORT( int ) PL_get_head(term_t, term_t); + PL_EXPORT( int ) PL_get_int64(term_t, int64_t *); + PL_EXPORT( int ) PL_get_integer(term_t, int *); + PL_EXPORT( int ) PL_get_list(term_t, term_t, term_t); + PL_EXPORT( int ) PL_get_long(term_t, long *); + PL_EXPORT( int ) PL_get_list_chars(term_t, char **, unsigned); + PL_EXPORT( int ) PL_get_list_nchars(term_t, size_t *, char **, unsigned); + PL_EXPORT( int ) PL_get_module(term_t, module_t *); + PL_EXPORT( module_t ) PL_context(void); + PL_EXPORT( int ) PL_strip_module(term_t, module_t *, term_t); + PL_EXPORT( atom_t ) PL_module_name(module_t); + PL_EXPORT( module_t ) PL_new_module(atom_t); + PL_EXPORT( int ) PL_get_name_arity(term_t, atom_t *, int *); + PL_EXPORT( int ) PL_get_nil(term_t); + PL_EXPORT( int ) PL_get_pointer(term_t, void **); + PL_EXPORT( int ) PL_get_intptr(term_t, intptr_t *); + PL_EXPORT( int ) PL_get_uintptr(term_t, uintptr_t *); + PL_EXPORT( int ) PL_get_tail(term_t, term_t); /* end PL_get_* functions =============================*/ /* begin PL_new_* functions =============================*/ -extern X_API atom_t PL_new_atom(const char *); -extern X_API atom_t PL_new_atom_nchars(size_t, const char *); -extern X_API atom_t PL_new_atom_wchars(size_t, const pl_wchar_t *); -extern X_API char *PL_atom_nchars(atom_t, size_t *); -extern X_API pl_wchar_t *PL_atom_wchars(atom_t, size_t *); -extern X_API functor_t PL_new_functor(atom_t, int); -extern X_API atom_t PL_functor_name(functor_t); -extern X_API int PL_functor_arity(functor_t); + PL_EXPORT( atom_t ) PL_new_atom(const char *); + PL_EXPORT( atom_t ) PL_new_atom_nchars(size_t, const char *); + PL_EXPORT( atom_t ) PL_new_atom_wchars(size_t, const pl_wchar_t *); + PL_EXPORT( char *) PL_atom_nchars(atom_t, size_t *); + PL_EXPORT( pl_wchar_t *) PL_atom_wchars(atom_t, size_t *); + PL_EXPORT( functor_t ) PL_new_functor(atom_t, int); + PL_EXPORT( atom_t ) PL_functor_name(functor_t); + PL_EXPORT( int ) PL_functor_arity(functor_t); /* end PL_new_* functions =============================*/ /* begin PL_put_* functions =============================*/ -extern X_API int PL_cons_functor(term_t, functor_t,...); -extern X_API int PL_cons_functor_v(term_t, functor_t,term_t); -extern X_API int PL_cons_list(term_t, term_t, term_t); -extern X_API int PL_put_atom(term_t, atom_t); -extern X_API int PL_put_atom_chars(term_t, const char *); -extern X_API int PL_put_atom_nchars(term_t, size_t ,const char *); -extern X_API int PL_put_boolean(term_t, uintptr_t); -extern X_API int PL_put_float(term_t, double); -extern X_API int PL_put_functor(term_t, functor_t t); -extern X_API int PL_put_int64(term_t, int64_t); -extern X_API int PL_put_integer(term_t, long); -extern X_API int PL_put_list(term_t); -extern X_API int PL_put_list_chars(term_t, const char *); -extern X_API void PL_put_nil(term_t); -extern X_API int PL_put_pointer(term_t, void *); -extern X_API int PL_put_string_chars(term_t, const char *); -extern X_API int PL_put_string_nchars(term_t, size_t, const char *); -extern X_API int PL_put_term(term_t, term_t); -extern X_API int PL_put_variable(term_t); -extern X_API int PL_put_intptr(term_t t, intptr_t n); -extern X_API int PL_put_uintptr(term_t t, uintptr_t n); -extern X_API int PL_compare(term_t, term_t); + PL_EXPORT( int ) PL_cons_functor(term_t, functor_t,...); + PL_EXPORT( int ) PL_cons_functor_v(term_t, functor_t,term_t); + PL_EXPORT( int ) PL_cons_list(term_t, term_t, term_t); + PL_EXPORT( int ) PL_put_atom(term_t, atom_t); + PL_EXPORT( int ) PL_put_atom_chars(term_t, const char *); + PL_EXPORT( int ) PL_put_atom_nchars(term_t, size_t ,const char *); + PL_EXPORT( int ) PL_put_boolean(term_t, uintptr_t); + PL_EXPORT( int ) PL_put_float(term_t, double); + PL_EXPORT( int ) PL_put_functor(term_t, functor_t t); + PL_EXPORT( int ) PL_put_int64(term_t, int64_t); + PL_EXPORT( int ) PL_put_integer(term_t, long); + PL_EXPORT( int ) PL_put_list(term_t); + PL_EXPORT( int ) PL_put_list_chars(term_t, const char *); + PL_EXPORT( void ) PL_put_nil(term_t); + PL_EXPORT( int ) PL_put_pointer(term_t, void *); + PL_EXPORT( int ) PL_put_string_chars(term_t, const char *); + PL_EXPORT( int ) PL_put_string_nchars(term_t, size_t, const char *); + PL_EXPORT( int ) PL_put_term(term_t, term_t); + PL_EXPORT( int ) PL_put_variable(term_t); + PL_EXPORT( int ) PL_put_intptr(term_t t, intptr_t n); + PL_EXPORT( int ) PL_put_uintptr(term_t t, uintptr_t n); + PL_EXPORT( int ) PL_compare(term_t, term_t); /* end PL_put_* functions =============================*/ /* begin PL_unify_* functions =============================*/ -extern X_API int PL_unify(term_t, term_t); -extern X_API int PL_unify_atom(term_t, atom_t); -extern X_API int PL_unify_arg(int, term_t, term_t); -extern X_API int PL_unify_atom_chars(term_t, const char *); -extern X_API int PL_unify_atom_nchars(term_t, size_t len, const char *); -extern X_API int PL_unify_float(term_t, double); -extern X_API int PL_unify_functor(term_t, functor_t); -extern X_API int PL_unify_int64(term_t, int64_t); -extern X_API int PL_unify_intptr(term_t, intptr_t); -extern X_API int PL_unify_uintptr(term_t, uintptr_t); -extern X_API int PL_unify_integer(term_t, long); -extern X_API int PL_unify_list(term_t, term_t, term_t); -extern X_API int PL_unify_list_chars(term_t, const char *); -extern X_API int PL_unify_list_ncodes(term_t, size_t, const char *); -extern X_API int PL_unify_nil(term_t); -extern X_API int PL_unify_pointer(term_t, void *); -extern X_API int PL_unify_bool(term_t, int); -extern X_API int PL_unify_string_chars(term_t, const char *); -extern X_API int PL_unify_string_nchars(term_t, size_t, const char *); -extern X_API int PL_unify_term(term_t,...); -extern X_API int PL_unify_chars(term_t, int, size_t, const char *); -extern X_API int PL_unify_chars_diff(term_t, term_t, int, size_t, const char *); + PL_EXPORT( int ) PL_unify(term_t, term_t); + PL_EXPORT( int ) PL_unify_atom(term_t, atom_t); + PL_EXPORT( int ) PL_unify_arg(int, term_t, term_t); + PL_EXPORT( int ) PL_unify_atom_chars(term_t, const char *); + PL_EXPORT( int ) PL_unify_atom_nchars(term_t, size_t len, const char *); + PL_EXPORT( int ) PL_unify_float(term_t, double); + PL_EXPORT( int ) PL_unify_functor(term_t, functor_t); + PL_EXPORT( int ) PL_unify_int64(term_t, int64_t); + PL_EXPORT( int ) PL_unify_intptr(term_t, intptr_t); + PL_EXPORT( int ) PL_unify_uintptr(term_t, uintptr_t); + PL_EXPORT( int ) PL_unify_integer(term_t, long); + PL_EXPORT( int ) PL_unify_list(term_t, term_t, term_t); + PL_EXPORT( int ) PL_unify_list_chars(term_t, const char *); + PL_EXPORT( int ) PL_unify_list_ncodes(term_t, size_t, const char *); + PL_EXPORT( int ) PL_unify_nil(term_t); + PL_EXPORT( int ) PL_unify_pointer(term_t, void *); + PL_EXPORT( int ) PL_unify_bool(term_t, int); + PL_EXPORT( int ) PL_unify_string_chars(term_t, const char *); + PL_EXPORT( int ) PL_unify_string_nchars(term_t, size_t, const char *); + PL_EXPORT( int ) PL_unify_term(term_t,...); + PL_EXPORT( int ) PL_unify_chars(term_t, int, size_t, const char *); + PL_EXPORT( int ) PL_unify_chars_diff(term_t, term_t, int, size_t, const char *); /******************************* * LISTS * *******************************/ @@ -506,92 +485,92 @@ extern X_API int PL_unify_chars_diff(term_t, term_t, int, size_t, const char *) PL_EXPORT(int) PL_skip_list(term_t list, term_t tail, size_t *len); -extern X_API int PL_unify_wchars(term_t, int, size_t, const pl_wchar_t *); -extern X_API int PL_unify_wchars_diff(term_t, term_t, int, size_t, const pl_wchar_t *); -extern X_API int PL_chars_to_term(const char *,term_t); + PL_EXPORT( int ) PL_unify_wchars(term_t, int, size_t, const pl_wchar_t *); + PL_EXPORT( int ) PL_unify_wchars_diff(term_t, term_t, int, size_t, const pl_wchar_t *); + PL_EXPORT( int ) PL_chars_to_term(const char *,term_t); /* begin PL_is_* functions =============================*/ -extern X_API int PL_is_atom(term_t); -extern X_API int PL_is_atomic(term_t); -extern X_API int PL_is_compound(term_t); -extern X_API int PL_is_float(term_t); -extern X_API int PL_is_functor(term_t, functor_t); -extern X_API int PL_is_ground(term_t); -extern X_API int PL_is_callable(term_t); -extern X_API int PL_is_integer(term_t); -extern X_API int PL_is_pair(term_t); -extern X_API int PL_is_list(term_t); -extern X_API int PL_is_pair(term_t); -extern X_API int PL_is_number(term_t); -extern X_API int PL_is_string(term_t); -extern X_API int PL_is_variable(term_t); -extern X_API int PL_term_type(term_t); -extern X_API int PL_is_inf(term_t); -extern X_API int PL_is_acyclic(term_t t); + PL_EXPORT( int ) PL_is_atom(term_t); + PL_EXPORT( int ) PL_is_atomic(term_t); + PL_EXPORT( int ) PL_is_compound(term_t); + PL_EXPORT( int ) PL_is_float(term_t); + PL_EXPORT( int ) PL_is_functor(term_t, functor_t); + PL_EXPORT( int ) PL_is_ground(term_t); + PL_EXPORT( int ) PL_is_callable(term_t); + PL_EXPORT( int ) PL_is_integer(term_t); + PL_EXPORT( int ) PL_is_pair(term_t); + PL_EXPORT( int ) PL_is_list(term_t); + PL_EXPORT( int ) PL_is_pair(term_t); + PL_EXPORT( int ) PL_is_number(term_t); + PL_EXPORT( int ) PL_is_string(term_t); + PL_EXPORT( int ) PL_is_variable(term_t); + PL_EXPORT( int ) PL_term_type(term_t); + PL_EXPORT( int ) PL_is_inf(term_t); + PL_EXPORT( int ) PL_is_acyclic(term_t t); /* end PL_is_* functions =============================*/ -extern X_API void PL_halt(int); -extern X_API int PL_initialise(int, char **); -extern X_API int PL_is_initialised(int *, char ***); -extern X_API void PL_close_foreign_frame(fid_t); -extern X_API void PL_discard_foreign_frame(fid_t); -extern X_API void PL_rewind_foreign_frame(fid_t); -extern X_API fid_t PL_open_foreign_frame(void); -extern X_API int PL_raise_exception(term_t); -extern X_API int PL_throw(term_t); -extern X_API void PL_clear_exception(void); -extern X_API void PL_register_atom(atom_t); -extern X_API void PL_unregister_atom(atom_t); -extern X_API predicate_t PL_pred(functor_t, module_t); -extern X_API predicate_t PL_predicate(const char *, int, const char *); + PL_EXPORT( void ) PL_halt(int); + PL_EXPORT( int ) PL_initialise(int, char **); + PL_EXPORT( int ) PL_is_initialised(int *, char ***); + PL_EXPORT( void ) PL_close_foreign_frame(fid_t); + PL_EXPORT( void ) PL_discard_foreign_frame(fid_t); + PL_EXPORT( void ) PL_rewind_foreign_frame(fid_t); + PL_EXPORT( fid_t ) PL_open_foreign_frame(void); + PL_EXPORT( int ) PL_raise_exception(term_t); + PL_EXPORT( int ) PL_throw(term_t); + PL_EXPORT( void ) PL_clear_exception(void); + PL_EXPORT( void ) PL_register_atom(atom_t); + PL_EXPORT( void ) PL_unregister_atom(atom_t); + PL_EXPORT( predicate_t ) PL_pred(functor_t, module_t); + PL_EXPORT( predicate_t ) PL_predicate(const char *, int, const char *); #define GP_NAMEARITY 0x100 /* or'ed mask */ -extern X_API int PL_unify_predicate(term_t head, predicate_t pred, int how); -extern X_API void PL_predicate_info(predicate_t, atom_t *, int *, module_t *); -extern X_API qid_t PL_open_query(module_t, int, predicate_t, term_t); -extern X_API int PL_next_solution(qid_t); -extern X_API void PL_cut_query(qid_t); -extern X_API void PL_close_query(qid_t); -extern X_API int PL_toplevel(void); -extern X_API term_t PL_exception(qid_t); -extern X_API term_t PL_exception(qid_t); -extern X_API int PL_call_predicate(module_t, int, predicate_t, term_t); -extern X_API int PL_call(term_t, module_t); -extern X_API void PL_register_foreign(const char *, int, pl_function_t, int); -extern X_API void PL_register_foreign_in_module(const char *, const char *, int, pl_function_t, int); -extern X_API void PL_register_extensions(const PL_extension *); -extern X_API void PL_register_extensions_in_module(const char *module, const PL_extension *); -extern X_API void PL_load_extensions(const PL_extension *); -extern X_API int PL_handle_signals(void); -extern X_API int PL_thread_self(void); -extern X_API int PL_unify_thread_id(term_t, int); -extern X_API int PL_thread_attach_engine(const PL_thread_attr_t *); -extern X_API int PL_thread_destroy_engine(void); -extern X_API int PL_thread_at_exit(void (*)(void *), void *, int); -extern X_API int PL_thread_raise(int tid, int sig); -extern X_API PL_engine_t PL_create_engine(const PL_thread_attr_t *); -extern X_API int PL_destroy_engine(PL_engine_t); -extern X_API int PL_set_engine(PL_engine_t,PL_engine_t *); -extern X_API int PL_get_string(term_t, char **, size_t *); -extern X_API int PL_get_string_chars(term_t, char **, size_t *); -extern X_API record_t PL_record(term_t); -extern X_API int PL_recorded(record_t, term_t); -extern X_API record_t PL_duplicate_record(record_t); -extern X_API void PL_erase(record_t); + PL_EXPORT( int ) PL_unify_predicate(term_t head, predicate_t pred, int how); + PL_EXPORT( void ) PL_predicate_info(predicate_t, atom_t *, int *, module_t *); + PL_EXPORT( qid_t ) PL_open_query(module_t, int, predicate_t, term_t); + PL_EXPORT( int ) PL_next_solution(qid_t); + PL_EXPORT( void ) PL_cut_query(qid_t); + PL_EXPORT( void ) PL_close_query(qid_t); + PL_EXPORT( int ) PL_toplevel(void); + PL_EXPORT( term_t ) PL_exception(qid_t); + PL_EXPORT( term_t ) PL_exception(qid_t); + PL_EXPORT( int ) PL_call_predicate(module_t, int, predicate_t, term_t); + PL_EXPORT( int ) PL_call(term_t, module_t); + PL_EXPORT( void ) PL_register_foreign(const char *, int, pl_function_t, int); + PL_EXPORT( void ) PL_register_foreign_in_module(const char *, const char *, int, pl_function_t, int); + PL_EXPORT( void ) PL_register_extensions(const PL_extension *); + PL_EXPORT( void ) PL_register_extensions_in_module(const char *module, const PL_extension *); + PL_EXPORT( void ) PL_load_extensions(const PL_extension *); + PL_EXPORT( int ) PL_handle_signals(void); + PL_EXPORT( int ) PL_thread_self(void); + PL_EXPORT( int ) PL_unify_thread_id(term_t, int); + PL_EXPORT( int ) PL_thread_attach_engine(const PL_thread_attr_t *); + PL_EXPORT( int ) PL_thread_destroy_engine(void); + PL_EXPORT( int ) PL_thread_at_exit(void (*)(void *), void *, int); + PL_EXPORT( int ) PL_thread_raise(int tid, int sig); + PL_EXPORT( PL_engine_t ) PL_create_engine(const PL_thread_attr_t *); + PL_EXPORT( int ) PL_destroy_engine(PL_engine_t); + PL_EXPORT( int ) PL_set_engine(PL_engine_t,PL_engine_t *); + PL_EXPORT( int ) PL_get_string(term_t, char **, size_t *); + PL_EXPORT( int ) PL_get_string_chars(term_t, char **, size_t *); + PL_EXPORT( record_t ) PL_record(term_t); + PL_EXPORT( int ) PL_recorded(record_t, term_t); + PL_EXPORT( record_t ) PL_duplicate_record(record_t); + PL_EXPORT( void ) PL_erase(record_t); /* only partial implementation, does not guarantee export between different architectures and versions of YAP */ -extern X_API char *PL_record_external(term_t, size_t *); -extern X_API int PL_recorded_external(const char *, term_t); -extern X_API int PL_erase_external(char *); -extern X_API int PL_action(int,...); -extern X_API void PL_on_halt(int (*)(int, void *), void *); -extern X_API void *PL_malloc(size_t); -extern X_API void *PL_malloc_uncollectable(size_t s); -extern X_API void *PL_realloc(void*,size_t); -extern X_API void PL_free(void *); -extern X_API int PL_eval_expression_to_int64_ex(term_t t, int64_t *val); -extern X_API void PL_cleanup_fork(void); -extern X_API int PL_get_signum_ex(term_t sig, int *n); + PL_EXPORT( char *) PL_record_external(term_t, size_t *); + PL_EXPORT( int ) PL_recorded_external(const char *, term_t); + PL_EXPORT( int ) PL_erase_external(char *); + PL_EXPORT( int ) PL_action(int,...); + PL_EXPORT( void ) PL_on_halt(int (*)(int, void *), void *); + PL_EXPORT( void *) PL_malloc(size_t); + PL_EXPORT( void *) PL_malloc_uncollectable(size_t s); + PL_EXPORT( void *) PL_realloc(void*,size_t); + PL_EXPORT( void ) PL_free(void *); + PL_EXPORT( int ) PL_eval_expression_to_int64_ex(term_t t, int64_t *val); + PL_EXPORT( void ) PL_cleanup_fork(void); + PL_EXPORT( int ) PL_get_signum_ex(term_t sig, int *n); -extern X_API size_t PL_utf8_strlen(const char *s, size_t len); + PL_EXPORT( size_t ) PL_utf8_strlen(const char *s, size_t len); -extern X_API int PL_unify_list_codes(term_t l, const char *chars); + PL_EXPORT( int ) PL_unify_list_codes(term_t l, const char *chas); @@ -607,8 +586,6 @@ extern X_API void PL_fatal_error(const char *msg); extern X_API int Sprintf(const char * fm,...); extern X_API int Sdprintf(const char *,...); -extern X_API char *PL_prompt_string(int fd); - /******************************* * FILENAME SUPPORT * *******************************/ diff --git a/include/VFS.h b/include/VFS.h index 4ffa601e6..65876b6db 100644 --- a/include/VFS.h +++ b/include/VFS.h @@ -23,8 +23,12 @@ #ifdef _WIN32 #include -typedef uintptr_t uid_t; -typedef uintptr_t gid_t; +#ifndef uid_t +#define uid_t int +#endif +#ifndef gid_t +#define gid_t int +#endif #endif typedef struct { diff --git a/include/YapError.h b/include/YapError.h index a9ea6810f..315efd58a 100644 --- a/include/YapError.h +++ b/include/YapError.h @@ -42,7 +42,11 @@ struct yami *Yap_Error__(const char *file, const char *function, int lineno, yap_error_number err, YAP_Term wheret, ...); void Yap_ThrowError__(const char *file, const char *function, int lineno, - yap_error_number err, YAP_Term wheret, ...) __attribute__ ((noreturn)); + yap_error_number err, YAP_Term wheret, ...) + #ifndef MSC_VER + __attribute__ ((noreturn)) + #endif + ; #define Yap_NilError(id, ...) \ diff --git a/include/YapFormat.h b/include/YapFormat.h new file mode 100644 index 000000000..2d7adc1c5 --- /dev/null +++ b/include/YapFormat.h @@ -0,0 +1,61 @@ + +#ifndef YAP_FORMAT + +#if defined(_WIN64) + +typedef int64_t Int; +typedef uint64_t UInt; +#define Int_FORMAT "%I64d" +#define UInt_FORMAT "%I64u" +#define Int_F "I64d" +#define UInt_F "I64u" +#define UXInt_F "I64xu" +#define Sizet_F "Id" + +#elif defined(_WIN32) + +typedef int32_t Int; +typedef uint32_t UInt; +#define Int_FORMAT "%I32d" +#define UInt_FORMAT "%I32u" +#define Int_F "I32d" +#define UInt_F "I32u" +#define UInt_FORMAT "%I32u" +#define UXInt_FORMAT "%I32xu" +#define Sizet_F "Id" + +#elif defined(PRIdPTR) +#define Int_FORMAT "%" PRIdPTR +#define Int_ANYFORMAT "%" PRIuPTR +#define UInt_FORMAT "%" PRIuPTR +#define Int_F PRIdPTR +#define Int_ANYF PRIuPTR +#define UInt_F PRIuPTR +#define UXInt_F PRIxPTR +#define Sizet_F "zd" + +#elif SIZEOF_LONG_INT == SIZEOF_INT_P + +typedef long int Int; +typedef unsigned long int UInt; +#define Int_FORMAT "%ld" +#define UInt_FORMAT "%uld" +#define Int_F "ld" +#define UInt_F "uld" +#define UXInt_F "ulxd" +#define Sizet_F "uld" + +#elif SIZEOF_INT == SIZEOF_INT_P + +typedef int Int; +typedef unsigned int UInt; +#define Int_FORMAT "%l" +#define UInt_FORMAT "%ul" +#define Int_F "l" +#define UInt_F "ul" +#define UXInt_F "uld" +#define Sizet_F "ux" + +#endif + +#endif diff --git a/include/YapInterface.h b/include/YapInterface.h index fa3afec9f..0552dafb5 100755 --- a/include/YapInterface.h +++ b/include/YapInterface.h @@ -72,50 +72,9 @@ __BEGIN_DECLS * * @return */ -#if defined(_WIN32) -#if YAP_H -#define X_API __declspec(dllexport) -#else -#define X_API __declspec(dllimport) -#endif -#else -#define X_API -#endif -#ifndef Int_FORMAT +#include "YapFormat.h" -#ifdef PRIdPTR -#define Int_FORMAT "%" PRIdPTR -#elif _WIN64 -#define Int_FORMAT "%I64d" -#elif _WIN32 -#define Int_FORMAT "%I32d" -#else -#define Int_FORMAT "%ld" -#endif - -#ifdef PRIiPTR -#define Int_ANYFORMAT "%" PRIiPTR -#elif _WIN64 -#define Int_ANYFORMAT "%I64i" -#elif _WIN32 -#define Int_ANYFORMAT "%I32i" -#else -#define Int_ANYFORMAT "%li" -#endif - -#ifdef PRIuPTR -#define UInt_FORMAT "%" PRIuPTR -#elif _WIN64 -#define UInt_FORMAT "%I64ud" -#elif _WIN32 -#define UInt_FORMAT "%I32ud" -#else -#define UInt_FORMAT "%lu" -#endif - -/* portable form of formatted output for Prolog terms */ -#endif /* Primitive Functions */ @@ -173,6 +132,9 @@ extern X_API YAP_Bool YAP_IsDbRefTerm(YAP_Term); /* YAP_Bool IsAtomTerm(YAP_Term) */ extern X_API YAP_Bool YAP_IsAtomTerm(YAP_Term); +/* YAP_Bool IsAtomTerm(YAP_Term) */ +extern X_API YAP_Bool YAP_IsStringTerm(YAP_Term); + /* YAP_Bool IsPairTerm(YAP_Term) */ extern X_API YAP_Bool YAP_IsPairTerm(YAP_Term); @@ -185,12 +147,24 @@ extern X_API YAP_Bool YAP_IsCompoundTerm(YAP_Term); /* Term MkIntTerm(YAP_Int) */ extern X_API YAP_Term YAP_MkIntTerm(YAP_Int); +/* Term MkIntTerm(YAP_Int) */ +extern X_API YAP_Term YAP_MkStringTerm(const char *); + +/* Term MkIntTerm(YAP_Int) */ +extern X_API YAP_Term YAP_MkUnsignedStringTerm(const unsigned char *); + /* Term MkBigNumTerm(void *) */ extern X_API YAP_Term YAP_MkBigNumTerm(void *); /* Term MkRationalTerm(void *) */ extern X_API YAP_Term YAP_MkRationalTerm(void *); +/* YAP_Int IntOfTerm(Term) */ +extern X_API const unsigned char *YAP_UnsignedStringOfTerm(YAP_Term); + +/* YAP_Int StribgOfTerm(Term) */ +extern X_API const char *YAP_StringOfTerm(YAP_Term); + /* YAP_Int IntOfTerm(Term) */ extern X_API YAP_Int YAP_IntOfTerm(YAP_Term); diff --git a/include/YapStreams.h b/include/YapStreams.h index e9b8f10d9..280e34a8f 100644 --- a/include/YapStreams.h +++ b/include/YapStreams.h @@ -36,7 +36,9 @@ static char SccsId[] = "%W% %G%"; #define ALIASES_BLOCK_SIZE 8 #if _WIN32 +#ifndef USE_SOCKET #define USE_SOCKET 1 +#endif #define HAVE_SOCKET 1 #endif diff --git a/libYap.cmake b/libYap.cmake index 5cdddcc92..5f48bfdde 100644 --- a/libYap.cmake +++ b/libYap.cmake @@ -17,7 +17,6 @@ string(TIMESTAMP YAP_TIMESTAMP) string( SUBSTRING ${CMAKE_SHARED_LIBRARY_SUFFIX} 1 -1 SO_EXT ) - set_property(DIRECTORY PROPERTY CXX_STANDARD 11) # rpath stuff, hopefully it works diff --git a/library/dialect/swi/fli/CMakeLists.txt b/library/dialect/swi/fli/CMakeLists.txt index ecabf2a64..68fa93c26 100644 --- a/library/dialect/swi/fli/CMakeLists.txt +++ b/library/dialect/swi/fli/CMakeLists.txt @@ -13,6 +13,8 @@ MY_set_target_properties(libswi POSITION_INDEPENDENT_CODE ON ) +SET_PROPERTY(DIRECTORY PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 ) + include_directories (../../../H ../.../../include ../os ${CMAKE_BINARY_DIR} ${GMP_INCLUDE_DIR}) set (YAP_SWILIB $ ) diff --git a/library/dialect/swi/fli/swi.c b/library/dialect/swi/fli/swi.c index 4fc90f20a..e3ee3712d 100755 --- a/library/dialect/swi/fli/swi.c +++ b/library/dialect/swi/fli/swi.c @@ -29,8 +29,8 @@ Moyle. All rights reserved. #include #include +#include #include -#include #include "swi.h" #include @@ -216,6 +216,7 @@ X_API int PL_get_nchars(term_t l, size_t *lengthp, char **s, unsigned flags) { if (flags & BUF_MALLOC) { out.type |= YAP_STRING_MALLOC; + out.val.c = NULL; } if (lengthp) { out.type |= YAP_STRING_NCHARS; @@ -245,6 +246,7 @@ int PL_get_wchars(term_t l, size_t *lengthp, wchar_t **s, unsigned flags) { out.type = YAP_STRING_WCHARS; if (flags & BUF_MALLOC) { out.type |= YAP_STRING_MALLOC; + out.val.c = NULL; } if (lengthp) { out.type |= YAP_STRING_NCHARS; @@ -278,9 +280,7 @@ X_API int PL_unify_chars(term_t l, int flags, size_t length, const char *s) { } else if (flags & PL_CHAR_LIST) { out.type = YAP_STRING_ATOMS; } - if (length != (size_t)-1) { out.max = length; - } if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return Yap_unify(Yap_GetFromSlot(l), out.val.t); @@ -345,8 +345,7 @@ X_API term_t PL_new_term_refs(int n) { */ X_API void PL_reset_term_refs(term_t after) { CACHE_REGS - term_t new = Yap_NewSlots(1); - Yap_RecoverSlots(after - new, new); + LOCAL_CurSlot = after; } /** @} @@ -629,9 +628,17 @@ X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */ { CACHE_REGS Term t = Yap_GetFromSlot(ts); - if (!IsAtomTerm(t)) + char *src; + if (!IsAtomTerm(t)) { return 0; - *a = RepAtom(AtomOfTerm(t))->StrOfAE; + } + src = (char *)RepAtom(AtomOfTerm(t))->StrOfAE; + if (!a) + return 0; + if (*a && *a != src) + strcpy(*a, src); + else + *a = src; return 1; } @@ -644,10 +651,14 @@ X_API int PL_get_atom_nchars(term_t ts, size_t *len, { CACHE_REGS Term t = Yap_GetFromSlot(ts); - if (!IsAtomTerm(t)) + if (!IsAtomTerm(t)) { return 0; - *s = RepAtom(AtomOfTerm(t))->StrOfAE; + } + if (s) + *s = (char*)RepAtom(AtomOfTerm(t))->StrOfAE; + if (len) { *len = strlen(*s); +} return 1; } @@ -800,7 +811,7 @@ X_API int PL_unify_bool(term_t t, int a) { #if USE_GMP /******************************* -* GMP * + * GMP * *******************************/ X_API int PL_get_mpz(term_t t, mpz_t mpz) { diff --git a/library/dialect/swi/os/pl-prologflag.c b/library/dialect/swi/os/pl-prologflag.c index 571cdb6c8..521b1b7c8 100755 --- a/library/dialect/swi/os/pl-prologflag.c +++ b/library/dialect/swi/os/pl-prologflag.c @@ -29,7 +29,7 @@ #ifdef __YAP_PROLOG__ #include "Yatom.h" #include "pl-ctype.h" -#include "eval.h" +#include "YapEval.h" #else #include "os/pl-ctype.h" #endif diff --git a/library/lammpi/CMakeLists.txt b/library/lammpi/CMakeLists.txt index dcd647bc7..243500100 100644 --- a/library/lammpi/CMakeLists.txt +++ b/library/lammpi/CMakeLists.txt @@ -82,6 +82,7 @@ if (MPI_C_FOUND) install(TARGETS yap_mpi LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/library/lammpi/yap_mpi.c b/library/lammpi/yap_mpi.c index 66c34f999..856af9d3c 100644 --- a/library/lammpi/yap_mpi.c +++ b/library/lammpi/yap_mpi.c @@ -78,7 +78,7 @@ extern int GLOBAL_argc; static hashtable requests=NULL; static hashtable broadcasts=NULL; -void init_mpi(void); +X_API void init_mpi(void); /******************************************************************** * Time accounting @@ -1003,7 +1003,7 @@ mpi_default_buffer_size(void) /******************************************************************** * Init *******************************************************************/ -void +X_API void init_mpi(void) { requests=new_hashtable(HASHSIZE); diff --git a/library/matlab/CMakeLists.txt b/library/matlab/CMakeLists.txt index 69bfcbfb4..3ae50b9ab 100644 --- a/library/matlab/CMakeLists.txt +++ b/library/matlab/CMakeLists.txt @@ -17,7 +17,7 @@ if (MATLAB_FOUND) target_link_libraries(matlab libYap $(MATLAB_LIBRARIES) ) install(TARGETS matlab - LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) endif (MATLAB_FOUND) diff --git a/library/matrix/CMakeLists.txt b/library/matrix/CMakeLists.txt index d567f9055..b8a62a5c2 100644 --- a/library/matrix/CMakeLists.txt +++ b/library/matrix/CMakeLists.txt @@ -6,7 +6,8 @@ target_link_libraries(matrix libYap) set_target_properties (matrix PROPERTIES PREFIX "") install(TARGETS matrix - LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} ) diff --git a/library/matrix/matrix.c b/library/matrix/matrix.c index f0ea4e5c5..f664aedc5 100644 --- a/library/matrix/matrix.c +++ b/library/matrix/matrix.c @@ -3244,9 +3244,9 @@ is_matrix(void) return TRUE; } -void init_matrix( void ); +X_API void init_matrix( void ); -void +X_API void init_matrix(void) { AtomC = YAP_LookupAtom("c"); diff --git a/library/random/yap_random.c b/library/random/yap_random.c index 6e7b7ab9b..21bee0a60 100644 --- a/library/random/yap_random.c +++ b/library/random/yap_random.c @@ -22,7 +22,7 @@ #include #endif -void init_random( void ); +X_API void init_random( void ); static short a1 = 27314, b1 = 9213, c1 = 17773; @@ -59,7 +59,7 @@ p_getrand(void) YAP_Unify(YAP_ARG3,YAP_MkIntTerm(c1))); } -void +X_API void init_random(void) { YAP_UserCPredicate("random", p_random, 1); diff --git a/library/regex/CMakeLists.txt b/library/regex/CMakeLists.txt index c67f897bf..148323350 100644 --- a/library/regex/CMakeLists.txt +++ b/library/regex/CMakeLists.txt @@ -1,17 +1,23 @@ - set ( REGEX_SOURCES +set ( REGEX_INCLUDES cclass.h cname.h collate.h utils.h yapregex.h engine.c + ) + +set ( REGEX_SOURCES regcomp.c regerror.c regexec.c regfree.c ) + INCLUDE_DIRECTORIES(BEFORE +. +) add_library (regexp SHARED regexp.c ${REGEX_SOURCES}) target_link_libraries(regexp libYap) @@ -19,6 +25,7 @@ target_link_libraries(regexp libYap) set_target_properties (regexp PROPERTIES PREFIX "") install(TARGETS regexp - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/library/regex/regexec.c b/library/regex/regexec.c index 53518d236..c4499d2ce 100644 --- a/library/regex/regexec.c +++ b/library/regex/regexec.c @@ -52,7 +52,7 @@ static char sccsid[] = "@(#)regexec.c 8.3 (Berkeley) 3/20/94"; #ifndef HAVE_REGEXEC -#include "c_interface.h" +#include "YapInterface.h" #if HAVE_SYS_TYPES_H #include #endif @@ -68,8 +68,8 @@ static char sccsid[] = "@(#)regexec.c 8.3 (Berkeley) 3/20/94"; #include #endif -#include "regex2.h" #include "utils.h" +#include "regex2.h" #include "yapregex.h" #if used diff --git a/library/rltree/range_list.c b/library/rltree/range_list.c index 9b4050ac0..97cf056b9 100644 --- a/library/rltree/range_list.c +++ b/library/rltree/range_list.c @@ -1,11 +1,12 @@ /******************************************************************************************* -Copyright (C) 2004,2005,2006,2007,2008 (Nuno A. Fonseca) +Copyright (C) 2004,2005,2006,2007,2008 (Nuno A. Fonseca) + -This program is free software; you can redistribute it and/or -modify it under the terms of the GNU General Public License -as published by the Free Software Foundation; either -version 2 of the License, or (at your option) any later +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -21,110 +22,103 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Last rev: $Id: range_list.c,v 1.1 2008-03-26 23:05:22 nunofonseca Exp $ **************************************************************************/ +#include "range_list.h" #include #include #include -#include "range_list.h" /*****************************************************************************/ +void set_num_bit(unsigned int number, char *storage, STATUS status); +BOOLEAN is_num_bit(unsigned int number, char *storage, STATUS status); +static void set_quadrant(RL_Node *node, short quadrant, QUADRANT_STATUS status); +static QUADRANT_STATUS quadrant_status(RL_Node *node, short quadrant); -void set_num_bit(unsigned int number,char* storage,STATUS status); -BOOLEAN is_num_bit(unsigned int number,char *storage,STATUS status); +static void quadrant_interval(RL_Tree *tree, short quadrant, NUM interval, + NUM *quad_interval); +static NUM get_quadrant_node(RL_Tree *tree, NUM node, short quadrant, + NUM interval); +static unsigned int tree_size(RL_Tree *tree, NUM node, NUM); -static void set_quadrant(RL_Node* node,short quadrant,QUADRANT_STATUS status); -static QUADRANT_STATUS quadrant_status(RL_Node* node,short quadrant); +int get_location(RL_Tree *tree, NUM node, short quadrant, NUM interval); -static void quadrant_interval(RL_Tree *tree,short quadrant,NUM interval,NUM *quad_interval); -static NUM get_quadrant_node(RL_Tree* tree,NUM node,short quadrant,NUM interval); -static unsigned int tree_size(RL_Tree *tree,NUM node,NUM); +long set_in(NUM number, NUM node, NUM node_num, NUM interval, NUM max, + RL_Tree *tree, STATUS status); +long compact_node(RL_Tree *, NUM node, NUM next_node, NUM node_interval, + NUM next_node_interval, NUM next_node_num, short quadrant, + NUM max); -int get_location(RL_Tree* tree,NUM node,short quadrant,NUM interval); - -long set_in(NUM number,NUM node, NUM node_num, NUM interval,NUM max,RL_Tree* tree,STATUS status); -long compact_node(RL_Tree*,NUM node,NUM next_node,NUM node_interval,NUM next_node_interval,NUM next_node_num,short quadrant,NUM max); - -BOOLEAN in_tree(NUM number,RL_Tree *tree,NUM node,NUM node_num,NUM interval); +BOOLEAN in_tree(NUM number, RL_Tree *tree, NUM node, NUM node_num, + NUM interval); void display_tree(RL_Tree *tree); -void idisplay_tree(RL_Tree *tree,NUM node,NUM node_num,NUM interval,NUM max); -static void display_leaf(RL_Tree* tree,NUM node,NUM node_num,NUM max); +void idisplay_tree(RL_Tree *tree, NUM node, NUM node_num, NUM interval, + NUM max); +static void display_leaf(RL_Tree *tree, NUM node, NUM node_num, NUM max); -NUM new_node(RL_Tree* tree,NUM node_father,short quadrant,NUM node_num,NUM quad_min,NUM quad_max,STATUS); -static void root_intervals(RL_Tree* tree); +NUM new_node(RL_Tree *tree, NUM node_father, short quadrant, NUM node_num, + NUM quad_min, NUM quad_max, STATUS); +static void root_intervals(RL_Tree *tree); -NUM next_min(RL_Tree *tree,NUM node,NUM node_num,NUM interval,NUM max,NUM min); -NUM tree_minus(RL_Tree *r1,RL_Tree *r2,NUM node1,NUM node2,NUM node_num,NUM interval,NUM max); +NUM next_min(RL_Tree *tree, NUM node, NUM node_num, NUM interval, NUM max, + NUM min); +NUM tree_minus(RL_Tree *r1, RL_Tree *r2, NUM node1, NUM node2, NUM node_num, + NUM interval, NUM max); -RL_Tree* minus_rl(RL_Tree* range1,RL_Tree* range2); -void shift_right(RL_Tree *tree,const NUM idx,const long nnodes); -void shift_left(RL_Tree *tree,const NUM idx, const long nnodes); -void intersect_leafs(char *storage1,char *storage2); +RL_Tree *minus_rl(RL_Tree *range1, RL_Tree *range2); +void shift_right(RL_Tree *tree, const NUM idx, const long nnodes); +void shift_left(RL_Tree *tree, const NUM idx, const long nnodes); +void intersect_leafs(char *storage1, char *storage2); -//static void print_nodes(RL_Tree* tree); +// static void print_nodes(RL_Tree* tree); // -RL_Buffer* buffer=NULL; -unsigned int active_bits[16]={ - 1, - 3, - 7, - 15, - 31, - 63, - 127, - 255, - 511, - 1023, - 2047, - 4095, - 8191, - 16383, - 32767, - 65535 -}; - +RL_Buffer *buffer = NULL; +unsigned int active_bits[16] = {1, 3, 7, 15, 31, 63, + 127, 255, 511, 1023, 2047, 4095, + 8191, 16383, 32767, 65535}; /*****************************************************************************/ /* * * */ -RL_Tree* new_rl(NUM max_size) { +RL_Tree *new_rl(NUM max_size) { RL_Tree *new; RL_Node *buf_ptr; short q; - NUM qi,tmp; - - if ( max_size <2 ) - max_size=2; + NUM qi, tmp; - new=(RL_Tree*)malloc(sizeof(RL_Tree)); - if(new==NULL) + if (max_size < 2) + max_size = 2; + + new = (RL_Tree *)malloc(sizeof(RL_Tree)); + if (new == NULL) return NULL; - new->range_max=max_size; + new->range_max = max_size; root_intervals(new); // alloc a block for the nodes - new->root=(RL_Node*)calloc(1,NODE_SIZE); - new->size=1; - new->mem_alloc=NODE_SIZE; // memory allocated + new->root = (RL_Node *)calloc(1, NODE_SIZE); + new->size = 1; + new->mem_alloc = NODE_SIZE; // memory allocated // reset buffer - buf_ptr=new->root;//tree_buffer(); - ALL_OUT(&buf_ptr[0]); // Initialize all numbers as being out of the range/interval - buf_ptr[0].i_node.num_subnodes=1; - new->root=buf_ptr;// pointer to the buffer + buf_ptr = new->root; // tree_buffer(); + ALL_OUT( + &buf_ptr[0]); // Initialize all numbers as being out of the range/interval + buf_ptr[0].i_node.num_subnodes = 1; + new->root = buf_ptr; // pointer to the buffer - buf_ptr->i_node.num_subnodes=1; - quadrant_interval(new,1,max_size,&qi); - tmp=qi+1; - for(q=2;q<=BRANCH_FACTOR;++q) { - if ( max_size < qi*(q-1)+1 ) // 16 32 48 64 - 32 - set_quadrant(new->root,q,R_IGNORE); - tmp+=qi; // max_size=16 16+1 + buf_ptr->i_node.num_subnodes = 1; + quadrant_interval(new, 1, max_size, &qi); + tmp = qi + 1; + for (q = 2; q <= BRANCH_FACTOR; ++q) { + if (max_size < qi * (q - 1) + 1) // 16 32 48 64 - 32 + set_quadrant(new->root, q, R_IGNORE); + tmp += qi; // max_size=16 16+1 } return new; @@ -133,54 +127,56 @@ RL_Tree* new_rl(NUM max_size) { * * */ -RL_Tree* copy_rl(RL_Tree *tree) { +RL_Tree *copy_rl(RL_Tree *tree) { RL_Tree *new; RL_Node *buf_ptr; - new=(RL_Tree*)malloc(sizeof(RL_Tree)); - buf_ptr=(RL_Node*)calloc(tree->size,NODE_SIZE); - if( new==NULL ) { + new = (RL_Tree *)malloc(sizeof(RL_Tree)); + buf_ptr = (RL_Node *)calloc(tree->size, NODE_SIZE); + if (new == NULL) { printf("new==NULL"); - free(buf_ptr); + free(buf_ptr); return NULL; } - if( buf_ptr==NULL ) { - printf("buf_ptr==NULL---%lu",tree->size); - free(new); + if (buf_ptr == NULL) { + printf("buf_ptr==NULL---%lu", tree->size); + free(new); return NULL; } - memcpy(new,tree,sizeof(RL_Tree)); - memcpy(buf_ptr,&tree->root[0],tree->size*NODE_SIZE); - new->root=buf_ptr; - new->mem_alloc=tree->size*NODE_SIZE; + memcpy(new, tree, sizeof(RL_Tree)); + memcpy(buf_ptr, &tree->root[0], tree->size * NODE_SIZE); + new->root = buf_ptr; + new->mem_alloc = tree->size *NODE_SIZE; return new; } /* * * */ -void free_rl(RL_Tree* range) { - +void free_rl(RL_Tree *range) { + // free nodes block - if(range->mem_alloc!=0) + if (range->mem_alloc != 0) free(range->root); // free(range); } /* - + */ -RL_Tree* set_in_rl(RL_Tree* tree,NUM number,STATUS status) { +RL_Tree *set_in_rl(RL_Tree *tree, NUM number, STATUS status) { /* */ - if ( number >0 && number <=tree->range_max) - set_in(number,ROOT(tree),1,ROOT_INTERVAL(tree),tree->range_max,tree,status); + if (number > 0 && number <= tree->range_max) + set_in(number, ROOT(tree), 1, ROOT_INTERVAL(tree), tree->range_max, tree, + status); #ifdef DEBUG - printf("Setting: %lu size=%lu\n",number,tree->size); + printf("Setting: %lu size=%lu\n", number, tree->size); #endif /*if (status==IN && !in_rl(tree,number)) { - fprintf(stderr,"Error adding %lu to tree: size=%lu max=%lu\n",number,tree->size,tree->range_max); + fprintf(stderr,"Error adding %lu to tree: size=%lu + max=%lu\n",number,tree->size,tree->range_max); display_tree(tree); exit(1); }*/ @@ -189,38 +185,38 @@ RL_Tree* set_in_rl(RL_Tree* tree,NUM number,STATUS status) { /* * Mark all examples in range IN/OUT */ -void rl_all(RL_Tree* tree,STATUS status) { +void rl_all(RL_Tree *tree, STATUS status) { int i; - for(i=1;i<=BRANCH_FACTOR;++i) - if (quadrant_status(NODE(tree,ROOT(tree)),i)!=R_IGNORE) { - if(status==IN) - set_quadrant(NODE(tree,ROOT(tree)),i,R_TOTALLY_IN_INTERVAL); + for (i = 1; i <= BRANCH_FACTOR; ++i) + if (quadrant_status(NODE(tree, ROOT(tree)), i) != R_IGNORE) { + if (status == IN) + set_quadrant(NODE(tree, ROOT(tree)), i, R_TOTALLY_IN_INTERVAL); else - set_quadrant(NODE(tree,ROOT(tree)),i,R_NOT_IN_INTERVAL); + set_quadrant(NODE(tree, ROOT(tree)), i, R_NOT_IN_INTERVAL); } - tree->size=1; + tree->size = 1; } /* * * */ -BOOLEAN in_rl(RL_Tree* tree,NUM number) { - if ( number <1 && number >tree->range_max) +BOOLEAN in_rl(RL_Tree *tree, NUM number) { + if (number < 1 && number > tree->range_max) return FALSE; - return in_tree(number,tree,ROOT(tree),1,ROOT_INTERVAL(tree)); + return in_tree(number, tree, ROOT(tree), 1, ROOT_INTERVAL(tree)); } /* * * */ -BOOLEAN freeze_rl(RL_Tree* range) { - +BOOLEAN freeze_rl(RL_Tree *range) { + // reduce memory usage if possible - NUM s=range->size*NODE_SIZE; - if ( s < range->mem_alloc) { - range->root=(RL_Node*)realloc(range->root,s); - range->mem_alloc=s; + NUM s = range->size * NODE_SIZE; + if (s < range->mem_alloc) { + range->root = (RL_Node *)realloc(range->root, s); + range->mem_alloc = s; } return TRUE; } @@ -228,158 +224,175 @@ BOOLEAN freeze_rl(RL_Tree* range) { * Returns range1 without the numbers in range2 * Constraint:range1->max==range2->max */ -RL_Tree* minus_rl(RL_Tree* range1,RL_Tree* range2) { - if (range1->range_max!=range1->range_max) +RL_Tree *minus_rl(RL_Tree *range1, RL_Tree *range2) { + if (range1->range_max != range2->range_max) return NULL; //!!!!tree_minus(range1,range2,ROOT(range1),ROOT(range2),1,ROOT_INTERVAL(range1),range1->range_max); return range1; } /* - * Returns next number in tree bigger than min + * Returns next number in tree bigger than min */ -NUM rl_next_in_bigger(RL_Tree *tree,NUM min) { - if ( tree==NULL ) { - fprintf(stdout,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!%lu\n",min); +NUM rl_next_in_bigger(RL_Tree *tree, NUM min) { + if (tree == NULL) { + fprintf(stdout, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!%lu\n", min); } - return next_min(tree,ROOT(tree),1,ROOT_INTERVAL(tree),tree->range_max,min+1); + return next_min(tree, ROOT(tree), 1, ROOT_INTERVAL(tree), tree->range_max, + min + 1); } -/* ****************************************************************************** +/* ****************************************************************************** Private Functions - ****************************************************************************** */ + ****************************************************************************** + */ /* static void print_nodes(RL_Tree* tree) { RL_Node* nodes=tree->root; int j; - - for(j=0;jsize;++j) + + for(j=0;jsize;++j) printf("[%d]=%lu\n",j,(unsigned long int)nodes[j].leaf); - + } */ // treeXquadrantXinterval->quadrant_minXquadrant_max -static void quadrant_interval(RL_Tree *tree,short quadrant,NUM interval,NUM *quad_interval) { - - if ( IS_ROOT(tree,interval) ) { - *quad_interval=tree->root_i; +static void quadrant_interval(RL_Tree *tree, short quadrant, NUM interval, + NUM *quad_interval) { + + if (IS_ROOT(tree, interval)) { + *quad_interval = tree->root_i; } else { - *quad_interval=NEXT_INTERVAL(interval); + *quad_interval = NEXT_INTERVAL(interval); } } // numberXtreeXinterval->quadrantXquadrant_minXquadrant_max -static void number_quadrant(NUM number,RL_Tree *tree,NUM node_interval,NUM node_num,short *quadrant,NUM *quad_min,NUM *quad_max) { - NUM tmp=node_num-1,quad_interval; +static void number_quadrant(NUM number, RL_Tree *tree, NUM node_interval, + NUM node_num, short *quadrant, NUM *quad_min, + NUM *quad_max) { + NUM tmp = node_num - 1, quad_interval; int i; - quadrant_interval(tree,1,node_interval,&quad_interval); - i=(number-node_num)/quad_interval+1; - tmp=node_num-1+quad_interval*i; - *quad_max=tmp; - *quadrant=i; - *quad_min=tmp-quad_interval+1; - //printf("number=%lu node num=%lu quad_interval=%lu-------> quadrant=%d quad_max=%lu\n",number,node_num,quad_interval,i,tmp); + quadrant_interval(tree, 1, node_interval, &quad_interval); + i = (number - node_num) / quad_interval + 1; + tmp = node_num - 1 + quad_interval * i; + *quad_max = tmp; + *quadrant = i; + *quad_min = tmp - quad_interval + 1; + // printf("number=%lu node num=%lu quad_interval=%lu-------> quadrant=%d + // quad_max=%lu\n",number,node_num,quad_interval,i,tmp); } /* * returns the index to the quadrant "quadrant" node */ -static NUM get_quadrant_node(RL_Tree* tree,NUM node,short quadrant,NUM interval) { - int d=get_location(tree,node,quadrant,interval); - return node+d; +static NUM get_quadrant_node(RL_Tree *tree, NUM node, short quadrant, + NUM interval) { + int d = get_location(tree, node, quadrant, interval); + return node + d; } -/* src s +/* src s * src= 1 2 3 4 5 6 _ _ * offset= 2 * nbytes=6 - * >>>src= 1 2 1 2 3 4 5 6 + * >>>src= 1 2 1 2 3 4 5 6 * src s */ -void shift_right(RL_Tree *tree,const NUM idx,const long nnodes){ - long n=idx+nnodes; - RL_Node *s=tree->root; +void shift_right(RL_Tree *tree, const NUM idx, const long nnodes) { + long n = idx + nnodes; + RL_Node *s = tree->root; - if (nnodes<=0) return; - //print_nodes(tree); - while(n>=idx) { - s[n+1].leaf=s[n].leaf; + if (nnodes <= 0) + return; + // print_nodes(tree); + while (n >= idx) { + s[n + 1].leaf = s[n].leaf; --n; } - //print_nodes(tree); - //printf(">>----------------\n"); + // print_nodes(tree); + // printf(">>----------------\n"); } -void shift_left(RL_Tree *tree,const NUM idx, const long nnodes){ - long n=idx; - RL_Node *s=tree->root; +void shift_left(RL_Tree *tree, const NUM idx, const long nnodes) { + long n = idx; + RL_Node *s = tree->root; - //printf("sfit left: idx=%u nnodes=%u max=%u\n",idx,nnodes,tree->size); - if ( nnodes<=0 ) // last element + // printf("sfit left: idx=%u nnodes=%u max=%u\n",idx,nnodes,tree->size); + if (nnodes <= 0) // last element return; - + // print_nodes(tree); - while(nroot; - NUM new_interval=+NEXT_INTERVAL(father_interval); +NUM new_node(RL_Tree *tree, NUM node_father, short quadrant, + NUM father_interval, NUM quad_min, NUM quad_max, STATUS status) { + // RL_Node *new,*root_node=tree->root; + NUM new_interval = +NEXT_INTERVAL(father_interval); NUM times; NUM new; - RL_Node* ptr; - new=get_quadrant_node(tree,node_father,quadrant,father_interval); - - if ( tree->mem_alloc!=0 ) { + RL_Node *ptr; + new = get_quadrant_node(tree, node_father, quadrant, father_interval); + + if (tree->mem_alloc != 0) { // increase array size and shift elements right - if ( REALLOC_MEM(tree) ) { - //printf("new node:resizing memory: current %lu -> new %lu [%lu]\n",tree->mem_alloc,MEM_SIZE(tree),tree->size); - ptr=(RL_Node*)realloc(tree->root,MEM_SIZE(tree)); - if ( ptr==NULL ) { - fprintf(stderr,"Fatal error:range_list: Unable to allocate memory"); - exit(1); + if (REALLOC_MEM(tree)) { + // printf("new node:resizing memory: current %lu -> new %lu + // [%lu]\n",tree->mem_alloc,MEM_SIZE(tree),tree->size); + ptr = (RL_Node *)realloc(tree->root, MEM_SIZE(tree)); + if (ptr == NULL) { + fprintf(stderr, "Fatal error:range_list: Unable to allocate memory"); + exit(1); } - tree->root=ptr; - tree->mem_alloc=MEM_SIZE(tree); + tree->root = ptr; + tree->mem_alloc = MEM_SIZE(tree); } // SHIFT elements at the right and including the current node one position - times=tree->size-1-new; - shift_right(tree,new,times); - // SHIFT_NODES((void*)new,times*NODE_SIZE); + times = tree->size - 1 - new; + shift_right(tree, new, times); + // SHIFT_NODES((void*)new,times*NODE_SIZE); } // update father reference - set_quadrant(NODE(tree,node_father),quadrant,R_PARCIALLY_IN_INTERVAL); + set_quadrant(NODE(tree, node_father), quadrant, R_PARCIALLY_IN_INTERVAL); // initialize node - if ( status==IN) { - ALL_OUT(NODE(tree,new)); // clear all bits - if ( !IS_LEAF(new_interval) ) { + if (status == IN) { + ALL_OUT(NODE(tree, new)); // clear all bits + if (!IS_LEAF(new_interval)) { short q; - RL_Node* node_ptr=NODE(tree,new); - node_ptr->i_node.num_subnodes=1; - for(q=2;q<=BRANCH_FACTOR;++q) - if ( MIN(quad_max,tree->range_max) < quad_min+NEXT_INTERVAL(new_interval)*(q-1) ) //QUADRANT_MAX_VALUE( - set_quadrant(NODE(tree,new),q,R_IGNORE); + RL_Node *node_ptr = NODE(tree, new); + node_ptr->i_node.num_subnodes = 1; + for (q = 2; q <= BRANCH_FACTOR; ++q) + if (MIN(quad_max, tree->range_max) < + quad_min + + NEXT_INTERVAL(new_interval) * (q - 1)) // QUADRANT_MAX_VALUE( + set_quadrant(NODE(tree, new), q, R_IGNORE); } } else { // status ==out - //SET_LEAF_IN(tree->range_max,NODE(tree,new),quad_min); - tree->root[new].leaf=ON_BITS(MIN(16,tree->range_max-quad_min+1)); - if ( !IS_LEAF(new_interval) ) { + // SET_LEAF_IN(tree->range_max,NODE(tree,new),quad_min); + tree->root[new].leaf = ON_BITS(MIN(16, tree->range_max - quad_min + 1)); + if (!IS_LEAF(new_interval)) { short q; - RL_Node* node_ptr=NODE(tree,new); - node_ptr->i_node.num_subnodes=1; - node_ptr->i_node.quadrant_1=node_ptr->i_node.quadrant_2=node_ptr->i_node.quadrant_3=node_ptr->i_node.quadrant_4=R_TOTALLY_IN_INTERVAL; - for(q=2;q<=BRANCH_FACTOR;++q) - if ( MIN(quad_max,tree->range_max) < quad_min+NEXT_INTERVAL(new_interval)*(q-1) ) //QUADRANT_MAX_VALUE( - set_quadrant(NODE(tree,new),q,R_IGNORE); + RL_Node *node_ptr = NODE(tree, new); + node_ptr->i_node.num_subnodes = 1; + node_ptr->i_node.quadrant_1 = node_ptr->i_node.quadrant_2 = + node_ptr->i_node.quadrant_3 = node_ptr->i_node.quadrant_4 = + R_TOTALLY_IN_INTERVAL; + for (q = 2; q <= BRANCH_FACTOR; ++q) + if (MIN(quad_max, tree->range_max) < + quad_min + + NEXT_INTERVAL(new_interval) * (q - 1)) // QUADRANT_MAX_VALUE( + set_quadrant(NODE(tree, new), q, R_IGNORE); } } // update tree size @@ -391,37 +404,38 @@ NUM new_node(RL_Tree* tree,NUM node_father,short quadrant,NUM father_interval,NU * returns the offset * */ -int get_location(RL_Tree* tree,NUM node,short quadrant,NUM node_interval) { - int i,c=1,tmp; +int get_location(RL_Tree *tree, NUM node, short quadrant, NUM node_interval) { + int i, c = 1, tmp; NUM next_node; NUM next_interval; - if (quadrant==1 || IS_LEAF(node_interval)) return 1; + if (quadrant == 1 || IS_LEAF(node_interval)) + return 1; // - if ( LAST_LEVEL_INODE(node_interval) ) { + if (LAST_LEVEL_INODE(node_interval)) { // 1 node = current - for(i=1;isize,compacted; - NUM interval=node_interval; - NUM quad_min,quad_max; + long ret_val = tree->size, compacted; + NUM interval = node_interval; + NUM quad_min, quad_max; short quadrant; NUM size; /* */ - if ( IS_LEAF(interval) ) { + if (IS_LEAF(interval)) { // current node is a leaf - set_num_bit(number-node_num,(char*)NODE(tree,node),status); + set_num_bit(number - node_num, (char *)NODE(tree, node), status); return 0; } // - number_quadrant(number,tree,node_interval,node_num,&quadrant,&quad_min,&quad_max); - interval=quad_max-quad_min+1; + number_quadrant(number, tree, node_interval, node_num, &quadrant, &quad_min, + &quad_max); + interval = quad_max - quad_min + 1; // select next node - switch(status) { + switch (status) { case IN: - // move pointer to next node - if ( quadrant_status(NODE(tree,node),quadrant)==R_NOT_IN_INTERVAL ) { + // move pointer to next node + if (quadrant_status(NODE(tree, node), quadrant) == R_NOT_IN_INTERVAL) { // new node - //display_tree(tree); - next_node=new_node(tree,node,quadrant,node_interval,quad_min,quad_max,status); - }else if ( quadrant_status(NODE(tree,node),quadrant)==R_TOTALLY_IN_INTERVAL ) + // display_tree(tree); + next_node = new_node(tree, node, quadrant, node_interval, quad_min, + quad_max, status); + } else if (quadrant_status(NODE(tree, node), quadrant) == + R_TOTALLY_IN_INTERVAL) return 0; else - next_node=get_quadrant_node(tree,node,quadrant,node_interval); + next_node = get_quadrant_node(tree, node, quadrant, node_interval); break; case OUT: - if ( quadrant_status(NODE(tree,node),quadrant)==R_TOTALLY_IN_INTERVAL ) { + if (quadrant_status(NODE(tree, node), quadrant) == R_TOTALLY_IN_INTERVAL) { // new node - next_node=new_node(tree,node,quadrant,node_interval,quad_min,quad_max,status); - } else if ( quadrant_status(NODE(tree,node),quadrant)==R_NOT_IN_INTERVAL ) + next_node = new_node(tree, node, quadrant, node_interval, quad_min, + quad_max, status); + } else if (quadrant_status(NODE(tree, node), quadrant) == R_NOT_IN_INTERVAL) return 0; else - next_node=get_quadrant_node(tree,node,quadrant,node_interval); + next_node = get_quadrant_node(tree, node, quadrant, node_interval); break; default: - printf("set_in: invalid number status %d\n",status); + printf("set_in: invalid number status %d\n", status); exit(1); } // insert in tree - set_in(number,next_node,quad_min,interval,quad_max,tree,status); - ret_val=tree->size-ret_val; // number of nodes added/removed + set_in(number, next_node, quad_min, interval, quad_max, tree, status); + ret_val = tree->size - ret_val; // number of nodes added/removed // compact tree: only if we didn't create new nodes - //compacted=compact_node(tree,node,next_node,node_interval,interval,quad_min,quadrant,MIN(quad_max,tree->range_max)); - compacted=0; - if ( compacted==-1 ) { - //NUM times=tree->size-1-next_node; // -1 because array position 0 - shift_left(tree,next_node,1); + // compacted=compact_node(tree,node,next_node,node_interval,interval,quad_min,quadrant,MIN(quad_max,tree->range_max)); + compacted = 0; + if (compacted == -1) { + // NUM times=tree->size-1-next_node; // -1 because array position 0 + shift_left(tree, next_node, 1); // update tree size - tree->size+=compacted; - ret_val+=compacted; - //ret_val=0;//compacted; + tree->size += compacted; + ret_val += compacted; + // ret_val=0;//compacted; } // update subnodes number - if ( tree->root[node].i_node.num_subnodes ==255 ) - size=tree_size(tree,node,interval); + if (tree->root[node].i_node.num_subnodes == 255) + size = tree_size(tree, node, interval); else - size=ret_val+tree->root[node].i_node.num_subnodes; // new subnodes value + size = ret_val + tree->root[node].i_node.num_subnodes; // new subnodes value - if ( size > 254 ) - tree->root[node].i_node.num_subnodes=255; + if (size > 254) + tree->root[node].i_node.num_subnodes = 255; else - tree->root[node].i_node.num_subnodes=size; - + tree->root[node].i_node.num_subnodes = size; + // if (size <0 ) exit(1); return ret_val; } /* - * Check if can change quadrant color of node. If it changes, the node is deleted and all nodes at right in the array are shifted one position. + * Check if can change quadrant color of node. If it changes, the node is + * deleted and all nodes at right in the array are shifted one position. * */ -long compact_node(RL_Tree *tree,NUM node,NUM next_node,NUM node_interval,NUM next_node_interval,NUM next_node_num,short quadrant,NUM max){ +long compact_node(RL_Tree *tree, NUM node, NUM next_node, NUM node_interval, + NUM next_node_interval, NUM next_node_num, short quadrant, + NUM max) { unsigned int j; - RL_Node* node_ptr=NODE(tree,next_node); // next node pointer - + RL_Node *node_ptr = NODE(tree, next_node); // next node pointer + // Try to compact a leaf - if ( IS_LEAF(next_node_interval) ) { + if (IS_LEAF(next_node_interval)) { #ifdef DEBUG - fprintf(stderr,"compact_node: interval node\n"); + fprintf(stderr, "compact_node: interval node\n"); #endif // ALL IN - if ( LEAF_ALL_IN(node_ptr->leaf) ) { - set_quadrant(NODE(tree,node),quadrant,R_TOTALLY_IN_INTERVAL); + if (LEAF_ALL_IN(node_ptr->leaf)) { + set_quadrant(NODE(tree, node), quadrant, R_TOTALLY_IN_INTERVAL); return -1; } // ALL IN: part II // The last node does not need to be all in - if ( max-next_node_num+1 <= LEAF_SIZE ) { - j=ON_BITS(max-next_node_num+1); //153,154,155,156,157,.,.,.,[158 -> valor do max=200 devia ser 158 - if ( node_ptr->leaf==j ) { - set_quadrant(NODE(tree,node),quadrant,R_TOTALLY_IN_INTERVAL); - return -1; + if (max - next_node_num + 1 <= LEAF_SIZE) { + j = ON_BITS(max - next_node_num + 1); // 153,154,155,156,157,.,.,.,[158 + // -> valor do max=200 devia ser 158 + if (node_ptr->leaf == j) { + set_quadrant(NODE(tree, node), quadrant, R_TOTALLY_IN_INTERVAL); + return -1; } } // ALL OUT - if ( LEAF_ALL_OUT(node_ptr->leaf) ) { - set_quadrant(NODE(tree,node),quadrant,R_NOT_IN_INTERVAL); + if (LEAF_ALL_OUT(node_ptr->leaf)) { + set_quadrant(NODE(tree, node), quadrant, R_NOT_IN_INTERVAL); #ifdef DEBUG printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>compacted leaf1\n"); #endif @@ -540,27 +564,29 @@ long compact_node(RL_Tree *tree,NUM node,NUM next_node,NUM node_interval,NUM nex } } else { #ifdef DEBUG - fprintf(stderr,"compact_node:range node\n"); + fprintf(stderr, "compact_node:range node\n"); #endif // INODE - range list node - if ( node_ptr->i_node.num_subnodes>1 ) // unable to compact + if (node_ptr->i_node.num_subnodes > 1) // unable to compact return 0; // ALL IN - for(j=1;j<=BRANCH_FACTOR;++j) - if ( quadrant_status(NODE(tree,next_node),j)!=R_IGNORE && quadrant_status(NODE(tree,next_node),j)!=R_TOTALLY_IN_INTERVAL ) - break; + for (j = 1; j <= BRANCH_FACTOR; ++j) + if (quadrant_status(NODE(tree, next_node), j) != R_IGNORE && + quadrant_status(NODE(tree, next_node), j) != R_TOTALLY_IN_INTERVAL) + break; - if (j>BRANCH_FACTOR) { - set_quadrant(NODE(tree,node),quadrant,R_TOTALLY_IN_INTERVAL); + if (j > BRANCH_FACTOR) { + set_quadrant(NODE(tree, node), quadrant, R_TOTALLY_IN_INTERVAL); return -1; } // ALL OUT - for(j=1;j<=BRANCH_FACTOR;++j) - if ( quadrant_status(NODE(tree,next_node),j)!=R_IGNORE && quadrant_status(NODE(tree,next_node),j)!=R_NOT_IN_INTERVAL ) - break; + for (j = 1; j <= BRANCH_FACTOR; ++j) + if (quadrant_status(NODE(tree, next_node), j) != R_IGNORE && + quadrant_status(NODE(tree, next_node), j) != R_NOT_IN_INTERVAL) + break; - if (j>BRANCH_FACTOR) { - set_quadrant(NODE(tree,node),quadrant,R_NOT_IN_INTERVAL); + if (j > BRANCH_FACTOR) { + set_quadrant(NODE(tree, node), quadrant, R_NOT_IN_INTERVAL); return -1; } } @@ -570,86 +596,89 @@ long compact_node(RL_Tree *tree,NUM node,NUM next_node,NUM node_interval,NUM nex /* * interval: interval associated to the node */ -static unsigned int tree_size(RL_Tree *tree,NUM node,NUM interval) { - unsigned int c=1,tmp; - int i=1; +static unsigned int tree_size(RL_Tree *tree, NUM node, NUM interval) { + unsigned int c = 1, tmp; + int i = 1; short status; NUM next_interval; NUM next_node; - RL_Node* node_ptr=NODE(tree,node); + RL_Node *node_ptr = NODE(tree, node); - if ( IS_LEAF(interval)) return 1; + if (IS_LEAF(interval)) + return 1; - if ( node_ptr->i_node.num_subnodes==255) { + if (node_ptr->i_node.num_subnodes == 255) { // compute the size of all subtrees - next_interval=NEXT_INTERVAL(interval); - for(i=1;i<=BRANCH_FACTOR;++i) { - status=quadrant_status(NODE(tree,node),i); - switch(status) { + next_interval = NEXT_INTERVAL(interval); + for (i = 1; i <= BRANCH_FACTOR; ++i) { + status = quadrant_status(NODE(tree, node), i); + switch (status) { case R_PARCIALLY_IN_INTERVAL: - next_node=node+c; // - tmp=tree_size(tree,next_node,next_interval); - c+=tmp; - // default: + next_node = node + c; // + tmp = tree_size(tree, next_node, next_interval); + c += tmp; + // default: } } - } - else c=node_ptr->i_node.num_subnodes; + } else + c = node_ptr->i_node.num_subnodes; return c; } /* * number >=1 && number <=16 */ -void set_num_bit(unsigned int number,char *storage,STATUS status) { - if ( number >= 8 ) { +void set_num_bit(unsigned int number, char *storage, STATUS status) { + if (number >= 8) { storage++; - number=number-8; // =-8 - } - if ( status==IN ) - BITMAP_insert(*storage,number); + number = number - 8; // =-8 + } + if (status == IN) + BITMAP_insert(*storage, number); else - BITMAP_delete(*storage,number); + BITMAP_delete(*storage, number); } /* */ -BOOLEAN is_num_bit(unsigned int number,char *storage,STATUS status) { - if ( number >= 8 ) { +BOOLEAN is_num_bit(unsigned int number, char *storage, STATUS status) { + if (number >= 8) { storage++; - number=number-8; // =-8 - } - if ( status==IN ) - return BITMAP_member(*storage,number); + number = number - 8; // =-8 + } + if (status == IN) + return BITMAP_member(*storage, number); else - return !BITMAP_member(*storage,number); + return !BITMAP_member(*storage, number); } /* * */ -static void set_quadrant(RL_Node *node,short quadrant,QUADRANT_STATUS status){ +static void set_quadrant(RL_Node *node, short quadrant, + QUADRANT_STATUS status) { - switch(quadrant){ + switch (quadrant) { case 1: - node->i_node.quadrant_1=status; + node->i_node.quadrant_1 = status; break; case 2: - node->i_node.quadrant_2=status; + node->i_node.quadrant_2 = status; break; case 3: - node->i_node.quadrant_3=status; + node->i_node.quadrant_3 = status; break; case 4: - node->i_node.quadrant_4=status; + node->i_node.quadrant_4 = status; break; default: - fprintf(stderr,"ERROR: set_quadrant: invalid quadrant %d(%d)\n",quadrant,status); + fprintf(stderr, "ERROR: set_quadrant: invalid quadrant %d(%d)\n", quadrant, + status); } } /* * */ -static QUADRANT_STATUS quadrant_status(RL_Node *node,short quadrant){ +static QUADRANT_STATUS quadrant_status(RL_Node *node, short quadrant) { - switch(quadrant){ + switch (quadrant) { case 1: return node->i_node.quadrant_1; case 2: @@ -659,7 +688,7 @@ static QUADRANT_STATUS quadrant_status(RL_Node *node,short quadrant){ case 4: return node->i_node.quadrant_4; default: - fprintf(stderr,"ERROR: quadrant_status: invalid quadrant(%d)\n",quadrant); + fprintf(stderr, "ERROR: quadrant_status: invalid quadrant(%d)\n", quadrant); } return 0; } @@ -667,10 +696,11 @@ static QUADRANT_STATUS quadrant_status(RL_Node *node,short quadrant){ * * */ -static BOOLEAN in_leaf(NUM number,RL_Tree *tree,NUM node,NUM node_num,NUM max) { +static BOOLEAN in_leaf(NUM number, RL_Tree *tree, NUM node, NUM node_num, + NUM max) { - if(is_num_bit(number-node_num,(char*)NODE(tree,node),IN)) - return TRUE; + if (is_num_bit(number - node_num, (char *)NODE(tree, node), IN)) + return TRUE; return FALSE; } @@ -678,47 +708,50 @@ static BOOLEAN in_leaf(NUM number,RL_Tree *tree,NUM node,NUM node_num,NUM max) { * * */ -BOOLEAN in_tree(NUM number,RL_Tree *tree,NUM node,NUM node_num,NUM node_interval) { +BOOLEAN in_tree(NUM number, RL_Tree *tree, NUM node, NUM node_num, + NUM node_interval) { NUM next_node; short quadrant; - NUM interval=node_interval; - NUM max=MIN(node_num+interval,tree->range_max); - NUM quad_min,quad_max; + NUM interval = node_interval; + NUM max = MIN(node_num + interval, tree->range_max); + NUM quad_min, quad_max; /* */ - if ( IS_LEAF(interval)) + if (IS_LEAF(interval)) // current node is a leaf - return in_leaf(number,tree,node,node_num,max); - - number_quadrant(number,tree,node_interval,node_num,&quadrant,&quad_min,&quad_max); - interval=quad_max-quad_min+1; - node_num=quad_min; - - if ( quadrant_status(NODE(tree,node),quadrant)==R_PARCIALLY_IN_INTERVAL ) { - next_node=get_quadrant_node(tree,node,quadrant,node_interval); - return in_tree(number,tree,next_node,node_num,interval); - } - if ( quadrant_status(NODE(tree,node),quadrant)==R_TOTALLY_IN_INTERVAL ) + return in_leaf(number, tree, node, node_num, max); + + number_quadrant(number, tree, node_interval, node_num, &quadrant, &quad_min, + &quad_max); + interval = quad_max - quad_min + 1; + node_num = quad_min; + + if (quadrant_status(NODE(tree, node), quadrant) == R_PARCIALLY_IN_INTERVAL) { + next_node = get_quadrant_node(tree, node, quadrant, node_interval); + return in_tree(number, tree, next_node, node_num, interval); + } + if (quadrant_status(NODE(tree, node), quadrant) == R_TOTALLY_IN_INTERVAL) return TRUE; - + return FALSE; } - -/* ************************************************************************************************* */ -/* I/O */ -/* ************************************************************************************************* */ +/* ************************************************************************************************* + */ +/* I/O */ +/* ************************************************************************************************* + */ /* * */ -static void display_leaf(RL_Tree *tree,NUM node,NUM node_num,NUM max) { +static void display_leaf(RL_Tree *tree, NUM node, NUM node_num, NUM max) { int i; printf("|"); - //for(i=0;iroot; + NUM qi, tmp = 0; + next_node = 0; // tree->root; - printf("Size:%lu -[1,%lu]\n",tree->size,tree->range_max); - qi=ROOT_INTERVAL(tree)/BRANCH_FACTOR; - //quadrant_interval(tree,1,tree->range_max,&qi); - for(i=1;i<=BRANCH_FACTOR;++i) { - tmp+=qi; + printf("Size:%lu -[1,%lu]\n", tree->size, tree->range_max); + qi = ROOT_INTERVAL(tree) / BRANCH_FACTOR; + // quadrant_interval(tree,1,tree->range_max,&qi); + for (i = 1; i <= BRANCH_FACTOR; ++i) { + tmp += qi; // - init=tmp-qi+1; - max=tmp; - status=quadrant_status(NODE(tree,0),i); - switch(status) { + init = tmp - qi + 1; + max = tmp; + status = quadrant_status(NODE(tree, 0), i); + switch (status) { case R_PARCIALLY_IN_INTERVAL: - next_node=get_quadrant_node(tree,ROOT(tree),i,qi*BRANCH_FACTOR); - idisplay_tree(tree,next_node,init,qi,max); + next_node = get_quadrant_node(tree, ROOT(tree), i, qi * BRANCH_FACTOR); + idisplay_tree(tree, next_node, init, qi, max); break; case R_TOTALLY_IN_INTERVAL: - printf(",[%lu-%lu]",init,MIN(max,tree->range_max)); + printf(",[%lu-%lu]", init, MIN(max, tree->range_max)); break; - case R_IGNORE: + case R_IGNORE: break; - default: + default: /* not in */ - printf(",]%lu-%lu[",init,MIN(max,tree->range_max)); + printf(",]%lu-%lu[", init, MIN(max, tree->range_max)); } } printf("\n"); @@ -767,7 +800,8 @@ void display_tree(RL_Tree *tree) { * * */ -void idisplay_tree(RL_Tree *tree,NUM node,NUM node_num,NUM interval,NUM max) { +void idisplay_tree(RL_Tree *tree, NUM node, NUM node_num, NUM interval, + NUM max) { NUM next_node; short quadrant; NUM interval2; @@ -775,47 +809,51 @@ void idisplay_tree(RL_Tree *tree,NUM node,NUM node_num,NUM interval,NUM max) { NUM quadrant_max; short status; - if ( IS_LEAF(interval) ) - return display_leaf(tree,node,node_num,MIN(max,tree->range_max)); - - interval2=NEXT_INTERVAL(interval); + if (IS_LEAF(interval)) + return display_leaf(tree, node, node_num, MIN(max, tree->range_max)); + + interval2 = NEXT_INTERVAL(interval); // - for(quadrant=1;quadrant<=BRANCH_FACTOR;++quadrant){ - node_num2=node_num+(quadrant-1)*interval2; - quadrant_max=QUADRANT_MAX_VALUE(node_num,quadrant,interval2,max); - status=quadrant_status(NODE(tree,node),quadrant); - switch(status) { + for (quadrant = 1; quadrant <= BRANCH_FACTOR; ++quadrant) { + node_num2 = node_num + (quadrant - 1) * interval2; + quadrant_max = QUADRANT_MAX_VALUE(node_num, quadrant, interval2, max); + status = quadrant_status(NODE(tree, node), quadrant); + switch (status) { case R_PARCIALLY_IN_INTERVAL: - next_node=get_quadrant_node(tree,node,quadrant,interval); - if ( IS_LEAF(interval2) ) - display_leaf(tree,next_node,node_num2,MIN(quadrant_max,tree->range_max)); - else - idisplay_tree(tree,next_node,node_num2,interval2,quadrant_max); + next_node = get_quadrant_node(tree, node, quadrant, interval); + if (IS_LEAF(interval2)) + display_leaf(tree, next_node, node_num2, + MIN(quadrant_max, tree->range_max)); + else + idisplay_tree(tree, next_node, node_num2, interval2, quadrant_max); break; case R_TOTALLY_IN_INTERVAL: - printf(",[%lu-%lu]",node_num2,MIN(node_num2+interval2-1,max)); + printf(",[%lu-%lu]", node_num2, MIN(node_num2 + interval2 - 1, max)); break; case R_IGNORE: break; default: - printf(",]%lu-%lu[",node_num2,MIN(tree->range_max,node_num2+interval2-1)); + printf(",]%lu-%lu[", node_num2, + MIN(tree->range_max, node_num2 + interval2 - 1)); } } } - -/* *************************************************************************************************** */ -static NUM next_in_leaf(RL_Tree *tree,NUM node,NUM node_num,NUM max,NUM min) { +/* *************************************************************************************************** + */ +static NUM next_in_leaf(RL_Tree *tree, NUM node, NUM node_num, NUM max, + NUM min) { NUM number; - number=node_num; - if ( numbernumber=%lu\n",node_num,max,min,number); - for (;number<=max;++number) - if(is_num_bit(number-node_num,(char*)NODE(tree,node),IN)) { - //fprintf(stdout,"next_in_leaf:[%lu,%lu]:min=%lu>>>>number=%lu\n",node_num,max,min,number); + number = node_num; + if (number < min) + number = min; + // fprintf(stderr,"next_in_leaf:[%lu,%lu]:min=%lu-->number=%lu\n",node_num,max,min,number); + for (; number <= max; ++number) + if (is_num_bit(number - node_num, (char *)NODE(tree, node), IN)) { + // fprintf(stdout,"next_in_leaf:[%lu,%lu]:min=%lu>>>>number=%lu\n",node_num,max,min,number); return number; } - //fprintf(stderr,"!next_in_leaf:[%lu,%lu]:min=%lu-->number=%lu\n",node_num,max,min,number); + // fprintf(stderr,"!next_in_leaf:[%lu,%lu]:min=%lu-->number=%lu\n",node_num,max,min,number); return 0; } @@ -823,68 +861,74 @@ static NUM next_in_leaf(RL_Tree *tree,NUM node,NUM node_num,NUM max,NUM min) { * Find next element bigger than min * */ -NUM next_min(RL_Tree *tree,NUM node,NUM node_num,NUM interval,NUM max,NUM min) { +NUM next_min(RL_Tree *tree, NUM node, NUM node_num, NUM interval, NUM max, + NUM min) { NUM next_node; short quadrant; NUM interval2; NUM node_num2; NUM quadrant_max; short status; - - if ( min > tree->range_max ) return 0; - if ( IS_LEAF(interval) ) - return next_in_leaf(tree,node,node_num,MIN(max,tree->range_max),min); - - interval2=NEXT_INTERVAL(interval); + + if (min > tree->range_max) + return 0; + if (IS_LEAF(interval)) + return next_in_leaf(tree, node, node_num, MIN(max, tree->range_max), min); + + interval2 = NEXT_INTERVAL(interval); // - for(quadrant=1;quadrant<=BRANCH_FACTOR;++quadrant){ + for (quadrant = 1; quadrant <= BRANCH_FACTOR; ++quadrant) { NUM found; - node_num2=node_num+(quadrant-1)*interval2; - quadrant_max=QUADRANT_MAX_VALUE(node_num,quadrant,interval2,max); + node_num2 = node_num + (quadrant - 1) * interval2; + quadrant_max = QUADRANT_MAX_VALUE(node_num, quadrant, interval2, max); //------------------------------------------ - status=quadrant_status(NODE(tree,node),quadrant); - switch(status) { + status = quadrant_status(NODE(tree, node), quadrant); + switch (status) { case R_PARCIALLY_IN_INTERVAL: - next_node=get_quadrant_node(tree,node,quadrant,interval); - found=next_min(tree,next_node,node_num2,interval2,quadrant_max,min); - if ( found>0) return found; + next_node = get_quadrant_node(tree, node, quadrant, interval); + found = + next_min(tree, next_node, node_num2, interval2, quadrant_max, min); + if (found > 0) + return found; break; case R_TOTALLY_IN_INTERVAL: - if (min<=quadrant_max && min>=node_num2) - return min; - if ( min < node_num2 ) return node_num2; + if (min <= quadrant_max && min >= node_num2) + return min; + if (min < node_num2) + return node_num2; } - } return 0; } /* *******************************************************************************************************/ /* - * + * */ -void intersect_leafs(char *storage1,char *storage2) { - - BITMAP_difference(*storage1,*storage1,*storage2); - storage1++; storage2++; - BITMAP_difference(*storage1,*storage1,*storage2); +void intersect_leafs(char *storage1, char *storage2) { + + BITMAP_difference(*storage1, *storage1, *storage2); + storage1++; + storage2++; + BITMAP_difference(*storage1, *storage1, *storage2); } /* * Removes the elements in tree1 that are in tree2 * */ -/*NUM tree_minus(RL_Tree *tree1,RL_Tree *tree2,NUM node1,NUM node2,NUM node_num,NUM interval,NUM max) { +/*NUM tree_minus(RL_Tree *tree1,RL_Tree *tree2,NUM node1,NUM node2,NUM +node_num,NUM interval,NUM max) { NUM next_node1,next_node2; short quadrant; NUM interval2; NUM node_num2; NUM quadrant_max; short status1,status2; - - + + if ( IS_LEAF(interval) ) // return intersect_leafs((char*)NODE(tree1,node1),(char*)NODE(tree2,node2)); - + interval2=NEXT_INTERVAL(interval); // for(quadrant=1;quadrant<=BRANCH_FACTOR;++quadrant){ @@ -895,18 +939,22 @@ void intersect_leafs(char *storage1,char *storage2) { status2=quadrant_status(NODE(tree2,node2),quadrant); if (status2==R_IGNORE || status2==R_NOT_IN_INTERVAL) { // do nothing - } else if ( status2==R_TOTALLY_IN_INTERVAL && (status1==R_IGNORE || status1==R_NOT_IN_INTERVAL )) { + } else if ( status2==R_TOTALLY_IN_INTERVAL && (status1==R_IGNORE || +status1==R_NOT_IN_INTERVAL )) { // do nothing - } else if ( status2==R_TOTALLY_IN_INTERVAL && status1==R_TOTALLY_IN_INTERVAL ) { + } else if ( status2==R_TOTALLY_IN_INTERVAL && status1==R_TOTALLY_IN_INTERVAL +) { // delete entire quadrant subtree in tree1 - } else if ( status2==R_PARTIALLY_IN_INTERVAL && status1==R_PARTIALLY_IN_INTERVAL){ + } else if ( status2==R_PARTIALLY_IN_INTERVAL && +status1==R_PARTIALLY_IN_INTERVAL){ // call same function next_node1=get_quadrant_node(tree1,node1,quadrant,interval); next_node2=get_quadrant_node(tree1,node2,quadrant,interval); tree_minus(tree1,tree2,next_node1,next_node2,node_num2,interval2,quadrant_max); - } else if ( status2==R_PARTIALLY_IN_INTERVAL && status1==R_TOTALLY_IN_INTERVAL) { + } else if ( status2==R_PARTIALLY_IN_INTERVAL && +status1==R_TOTALLY_IN_INTERVAL) { // foreach element of tree2, remove it in tree1 - + } else { // this should never happen!!!! } @@ -918,40 +966,43 @@ void intersect_leafs(char *storage1,char *storage2) { break; case R_TOTALLY_IN_INTERVAL: if (min<=quadrant_max && min>=node_num2) - return min; + return min; if ( min < node_num2 ) return node_num2; } - + } return 0; }*/ -/* *************************************************************************************************** */ +/* *************************************************************************************************** + */ // root level -static NUM norm_tree_size(NUM interval){ +static NUM norm_tree_size(NUM interval) { NUM tmp; - NUM j=BRANCH_FACTOR;; + NUM j = BRANCH_FACTOR; + ; - if ( interval<= LEAF_SIZE*BRANCH_FACTOR) return LEAF_SIZE; - while(1) { - tmp=LEAF_SIZE*j; - if ( tmp * BRANCH_FACTOR >= interval )break; - j*=BRANCH_FACTOR;; + if (interval <= LEAF_SIZE * BRANCH_FACTOR) + return LEAF_SIZE; + while (1) { + tmp = LEAF_SIZE * j; + if (tmp * BRANCH_FACTOR >= interval) + break; + j *= BRANCH_FACTOR; + ; } return tmp; } // -static void root_intervals(RL_Tree* tree) { - NUM first_i; +static void root_intervals(RL_Tree *tree) { + NUM first_i; - first_i=norm_tree_size(tree->range_max); - //k=tree->range_max/first_i+1; // number of large intervals - - tree->root_i=first_i; + first_i = norm_tree_size(tree->range_max); + // k=tree->range_max/first_i+1; // number of large intervals - if ( tree->root_i*BRANCH_FACTOR < tree->range_max ) { - tree->root_i=tree->root_i*BRANCH_FACTOR; - //printf("%lu---->>%lu\n",tree->range_max,tree->root_i); + tree->root_i = first_i; + + if (tree->root_i * BRANCH_FACTOR < tree->range_max) { + tree->root_i = tree->root_i * BRANCH_FACTOR; + // printf("%lu---->>%lu\n",tree->range_max,tree->root_i); } } - - diff --git a/library/system/CMakeLists.txt b/library/system/CMakeLists.txt index 917cc3ac9..5eb2182cf 100644 --- a/library/system/CMakeLists.txt +++ b/library/system/CMakeLists.txt @@ -41,7 +41,8 @@ set_target_properties (sys PROPERTIES PREFIX "") endif() MY_install(TARGETS sys - LIBRARY DESTINATION ${dlls} - ARCHIVE DESTINATION ${dlls} ) + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} + ARCHIVE DESTINATION ${dlls} ) configure_file ("sys_config.h.cmake" "sys_config.h" ) diff --git a/library/system/sys.c b/library/system/sys.c index 3804861ac..3ed5c8279 100644 --- a/library/system/sys.c +++ b/library/system/sys.c @@ -85,7 +85,7 @@ #include #endif -void init_sys(void); +X_API void init_sys(void); #if defined(__MINGW32__) || _MSC_VER static YAP_Term WinError(void) { @@ -1034,7 +1034,7 @@ static YAP_Bool error_message(void) { return YAP_Unify(YAP_ARG2, YAP_ARG1); #endif } -void init_sys(void) { +X_API void init_sys(void) { #if HAVE_MKTIME tzset(); #endif diff --git a/library/tries/CMakeLists.txt b/library/tries/CMakeLists.txt index 6066da28a..62dec0f91 100644 --- a/library/tries/CMakeLists.txt +++ b/library/tries/CMakeLists.txt @@ -1,3 +1,4 @@ +set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE) set ( TRIES_SOURCES core_tries.c @@ -12,7 +13,8 @@ target_link_libraries(tries libYap) set_target_properties (tries PROPERTIES PREFIX "") install(TARGETS tries - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls}) @@ -22,6 +24,9 @@ set ( ITRIES_SOURCES itries.c ) +if (ANDROID OR WIN32) + add_component ( otries ${TRIES_SOURCES} ) +endif() add_library (itries SHARED ${ITRIES_SOURCES}) target_link_libraries(itries libYap) @@ -29,6 +34,7 @@ target_link_libraries(itries libYap) set_target_properties (itries PROPERTIES PREFIX "") install(TARGETS itries - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/library/tries/core_dbtries.c b/library/tries/core_dbtries.c index 07ae1d6b0..2aed07731 100644 --- a/library/tries/core_dbtries.c +++ b/library/tries/core_dbtries.c @@ -843,7 +843,7 @@ int traverse_get_counter(TrNode node) { YAP_Term generate_label(YAP_Int Index) { char label[20]; - sprintf(label,"L%ld", Index); + sprintf(label,"L%" Int_F, Index); return YAP_MkAtomTerm(YAP_LookupAtom(label)); } @@ -1004,7 +1004,7 @@ YAP_Int core_db_trie_get_optimization_level_count(YAP_Int opt_level) { void displaynode(TrNode node) { if (node != NULL) { if (IS_HASH_NODE(node)) - printf("HASH n%i, b%i, p%li\n", TrHash_num_nodes((TrHash) node), TrHash_num_buckets((TrHash) node), (long) node); + printf("HASH n%i, b%i, p%p\n", TrHash_num_nodes((TrHash) node), TrHash_num_buckets((TrHash) node), node); else if (TrNode_entry(node) == PairInitTag) printf("PairInitTag\n"); else if (TrNode_entry(node) == PairEndTag) @@ -1012,7 +1012,7 @@ void displaynode(TrNode node) { else if (IS_FUNCTOR_NODE(node)) printf("functor(%s)\n", YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)( ~ApplTag & TrNode_entry(node))))); else if (YAP_IsIntTerm(TrNode_entry(node))) - printf("int(%ld)\n", YAP_IntOfTerm(TrNode_entry(node))); + printf("int(%"Int_F")\n", YAP_IntOfTerm(TrNode_entry(node))); else if (YAP_IsAtomTerm(TrNode_entry(node))) printf("atom(%s)\n", YAP_AtomName(YAP_AtomOfTerm(TrNode_entry(node)))); else @@ -1040,7 +1040,7 @@ void displayterm(YAP_Term term) { else if (YAP_IsApplTerm(term)) printf("functor(%s)\n", YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)( ~ApplTag & term)))); else if (YAP_IsIntTerm(term)) - printf("int(%ld)\n", YAP_IntOfTerm(term)); + printf("int(%"Int_F")\n", YAP_IntOfTerm(term)); else if (YAP_IsAtomTerm(term)) printf("atom(%s)\n", YAP_AtomName(YAP_AtomOfTerm(term))); else @@ -1070,7 +1070,7 @@ void display_trie_inner(TrNode node) { void trie_display_node(TrNode node) { if (node != NULL) { if (IS_HASH_NODE(node)) - printf("HASH(n%i, b%i, p%li), ", TrHash_num_nodes((TrHash) node), TrHash_num_buckets((TrHash) node), (long) node); + printf("HASH(n%i, b%i, p%p), ", TrHash_num_nodes((TrHash) node), TrHash_num_buckets((TrHash) node), node); else if (TrNode_entry(node) == PairInitTag) printf("PairInitTag, "); else if (TrNode_entry(node) == PairEndTag) @@ -1078,7 +1078,7 @@ void trie_display_node(TrNode node) { else if (IS_FUNCTOR_NODE(node)) printf("functor(%s), ", YAP_AtomName(YAP_NameOfFunctor((YAP_Functor)( ~ApplTag & TrNode_entry(node))))); else if (YAP_IsIntTerm(TrNode_entry(node))) - printf("int(%ld), ", YAP_IntOfTerm(TrNode_entry(node))); + printf("int(%" Int_F"), ", YAP_IntOfTerm(TrNode_entry(node))); else if (YAP_IsAtomTerm(TrNode_entry(node))) printf("atom(%s), ", YAP_AtomName(YAP_AtomOfTerm(TrNode_entry(node)))); else diff --git a/library/tries/tries.c b/library/tries/tries.c index aaf8cc1d0..f0f28e2e3 100644 --- a/library/tries/tries.c +++ b/library/tries/tries.c @@ -31,7 +31,7 @@ typedef struct { /* Procedures */ /* -------------------------- */ -void init_tries(void); +O_API void init_tries(void); static YAP_Bool p_trie_open(void); static YAP_Bool p_trie_close(void); static YAP_Bool p_trie_close_all(void); @@ -87,7 +87,7 @@ static YAP_Bool p_print_trie(void); /* Module Init Procedure */ /* -------------------------- */ -void init_tries(void) { +O_API void init_tries(void) { trie_init_module(); YAP_UserCPredicate("trie_open", p_trie_open, 1); @@ -955,3 +955,27 @@ static YAP_Bool p_trie_db_opt_min_prefix(void) { return FALSE; } #undef min_prefix + + +#ifdef _WIN32 + +#include + +int WINAPI win_tries(HANDLE, DWORD, LPVOID); + +int WINAPI win_tries(HANDLE hinst, DWORD reason, LPVOID reserved) +{ + switch (reason) + { + case DLL_PROCESS_ATTACH: + break; + case DLL_PROCESS_DETACH: + break; + case DLL_THREAD_ATTACH: + break; + case DLL_THREAD_DETACH: + break; + } + return 1; +} +#endif diff --git a/misc/buildatoms b/misc/buildatoms index 3c1062248..1e6a3063e 100644 --- a/misc/buildatoms +++ b/misc/buildatoms @@ -12,7 +12,7 @@ :- yap_flag(write_strings,on). main :- - warning(Warning), + warning(Warning), file_filter_with_init('H/ATOMS','H/generated/tatoms.h',gen_fields, Warning, ['tatoms.h']), file_filter_with_init('H/ATOMS','H/generated/iatoms.h',gen_decl, Warning, ['iatoms.h']), file_filter_with_init('H/ATOMS','H/generated/ratoms.h',gen_rcov, Warning, ['ratoms.h']). @@ -23,13 +23,13 @@ gen_fields(Inp,Out) :- split_unquoted(Inp," ",["A",Atom,_,_]), !, ( Atom = [C|_], code_type(C, alpha), Atom \= "Trail" -> - append(["EXTERNAL Atom Atom",Atom,"; EXTERNAL Term Term",Atom,";"], Out) + append(["X_API EXTERNAL Atom Atom",Atom,"; X_API EXTERNAL Term Term",Atom,";"], Out) ; - append(["EXTERNAL Atom Atom",Atom,";"], Out) + append(["X_API EXTERNAL Atom Atom",Atom,";"], Out) ). gen_fields(Inp,Out) :- split_unquoted(Inp," ",["F",Name,_,_]), !, - append(["EXTERNAL Functor Functor",Name,";\n"],Out). + append(["X_API EXTERNAL Functor Functor",Name,";\n"],Out). gen_rcov(Inp,Out) :- split_unquoted(Inp," ",["A",Atom,_,_]), !, diff --git a/misc/mktags b/misc/mktags new file mode 100644 index 000000000..339c2a1c5 --- /dev/null +++ b/misc/mktags @@ -0,0 +1,13 @@ + +# etags + +/bin/rm -f TAGS +find . -name '*.c' | xargs etags -a -Q +find . -name '*.h' | xargs etags -a -Q +find . -name '*.pl' | xargs etags -a -Q -lprolog +find . -name '*.yap' | xargs etags -a -Q -lprolog +find . -name '*.cxx' | xargs etags -a -Q +find . -name '*.hh' | xargs etags -a -Q +find . -name '*.py' | xargs etags -a -Q + + diff --git a/os/CMakeLists.txt b/os/CMakeLists.txt index 6915be592..3730c7c81 100644 --- a/os/CMakeLists.txt +++ b/os/CMakeLists.txt @@ -38,7 +38,9 @@ set (YAPOS_HEADERS include_directories (../H ../include ../OPTYap . ${GMP_INCLUDE_DIR} ${PROJECT_BINARY_DIR}) - set (POSITION_INDEPENDENT_CODE TRUE) +SET_PROPERTY(DIRECTORY PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 ) + +set (POSITION_INDEPENDENT_CODE TRUE) add_component (libYAPOs ${YAPOS_SOURCES} diff --git a/os/readterm.c b/os/readterm.c index 5a4205080..a10eeaab6 100644 --- a/os/readterm.c +++ b/os/readterm.c @@ -30,7 +30,7 @@ static char SccsId[] = "%W% %G%"; #include "YapHeap.h" #include "YapText.h" #include "Yatom.h" -#include "eval.h" +#include "YapEval.h" #include "yapio.h" #include #if HAVE_STDARG_H @@ -500,33 +500,40 @@ static void reset_regs(TokEntry *tokstart, FEnv *fe) { static Term get_variables(FEnv *fe, TokEntry *tokstart) { CACHE_REGS Term v; + jmp_buf j; + LOCAL_IOBotch = &j; if (fe->vp) { while (true) { fe->old_H = HR; - if (setjmp(LOCAL_IOBotch) == 0) { + if (setjmp(j) == 0) { if ((v = Yap_Variables(LOCAL_VarTable, TermNil))) { fe->old_H = HR; - return v; + LOCAL_IOBotch = NULL; + return v; } } else { reset_regs(tokstart, fe); } } } + LOCAL_IOBotch = NULL; return 0; } static Term get_varnames(FEnv *fe, TokEntry *tokstart) { CACHE_REGS Term v; + jmp_buf j; + LOCAL_IOBotch = &j; if (fe->np) { while (true) { fe->old_H = HR; - if (setjmp(LOCAL_IOBotch) == 0) { + if (setjmp(j) == 0) { if ((v = Yap_VarNames(LOCAL_VarTable, TermNil))) { fe->old_H = HR; + LOCAL_IOBotch = NULL; return v; } } else { @@ -534,24 +541,30 @@ static Term get_varnames(FEnv *fe, TokEntry *tokstart) { } } } + LOCAL_IOBotch = NULL; return 0; } static Term get_singletons(FEnv *fe, TokEntry *tokstart) { CACHE_REGS Term v; + jmp_buf j; + LOCAL_IOBotch = &j; if (fe->sp) { while (TRUE) { fe->old_H = HR; - if (setjmp(LOCAL_IOBotch) == 0) { - if ((v = Yap_Singletons(LOCAL_VarTable, TermNil))) - return v; + if (setjmp(j) == 0) { + if ((v = Yap_Singletons(LOCAL_VarTable, TermNil))) { + LOCAL_IOBotch = NULL; + return v; + } } else { reset_regs(tokstart, fe); } } } + LOCAL_IOBotch = NULL; return 0; } @@ -580,19 +593,24 @@ static void warn_singletons(FEnv *fe, TokEntry *tokstart) { static Term get_stream_position(FEnv *fe, TokEntry *tokstart) { CACHE_REGS Term v; + jmp_buf j; + LOCAL_IOBotch = &j; if (fe->tp) { while (true) { fe->old_H = HR; - if (setjmp(LOCAL_IOBotch) == 0) { - if ((v = CurrentPositionToTerm())) + if (setjmp(j) == 0) { + if ((v = CurrentPositionToTerm())) { + LOCAL_IOBotch = NULL; return v; + } } else { reset_regs(tokstart, fe); } } } - return 0; + LOCAL_IOBotch = NULL; + return 0; } static bool complete_processing(FEnv *fe, TokEntry *tokstart) { diff --git a/os/time.c b/os/time.c index 3927ea9d4..81a892caf 100644 --- a/os/time.c +++ b/os/time.c @@ -142,18 +142,23 @@ void Yap_systime_interval(Int *now, Int *interval) { #include -static FILETIME StartOfTimes, last_time; +typedef union { + FILETIME f; + __int64 t; +} win64_time_t; -static FILETIME StartOfTimes_sys, last_time_sys; +static win64_time_t StartOfTimes, last_time; + +static win64_time_t StartOfTimes_sys, last_time_sys; static clock_t TimesStartOfTimes, Times_last_time; /* store user time in this variable */ void Yap_InitTime(int wid) { HANDLE hProcess = GetCurrentProcess(); - FILETIME CreationTime, ExitTime, KernelTime, UserTime; - if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, - &UserTime)) { + win64_time_t CreationTime, ExitTime, KernelTime, UserTime; + if (!GetProcessTimes(hProcess, &CreationTime.f, &ExitTime.f, &KernelTime.f, + &UserTime.f)) { /* WIN98 */ clock_t t; t = clock(); @@ -161,125 +166,89 @@ void Yap_InitTime(int wid) { } else { #if THREADS REMOTE_ThreadHandle(wid).start_of_timesp = - (struct _FILETIME *)malloc(sizeof(FILETIME)); + (struct _win64_time_t *)malloc(sizeof(win64_time_t)); REMOTE_ThreadHandle(wid).last_timep = - (struct _FILETIME *)malloc(sizeof(FILETIME)); + (struct _win64_time_t *)malloc(sizeof(win64_time_t)); REMOTE_ThreadHandle(wid).start_of_times_sysp = - (struct _FILETIME *)malloc(sizeof(FILETIME)); + (struct _win64_time_t *)malloc(sizeof(win64_time_t)); REMOTE_ThreadHandle(wid).last_time_sysp = - (struct _FILETIME *)malloc(sizeof(FILETIME)); - (*REMOTE_ThreadHandle(wid).last_timep).dwLowDateTime = + (struct _win64_time_t *)malloc(sizeof(win64_time_t)); + (*REMOTE_ThreadHandle(wid).last_timep).f.dwLowDateTime = UserTime.dwLowDateTime; (*REMOTE_ThreadHandle(wid).last_timep).dwHighDateTime = UserTime.dwHighDateTime; - (*REMOTE_ThreadHandle(wid).start_of_timesp).dwLowDateTime = + (*REMOTE_ThreadHandle(wid).start_of_timesp).f.dwLowDateTime = UserTime.dwLowDateTime; - (*REMOTE_ThreadHandle(wid).start_of_timesp).dwHighDateTime = + (*REMOTE_ThreadHandle(wid).start_of_timesp).f.dwHighDateTime = UserTime.dwHighDateTime; - (*REMOTE_ThreadHandle(wid).last_time_sysp).dwLowDateTime = + (*REMOTE_ThreadHandle(wid).last_time_sysp).f.dwLowDateTime = KernelTime.dwLowDateTime; - (*REMOTE_ThreadHandle(wid).last_time_sysp).dwHighDateTime = + (*REMOTE_ThreadHandle(wid).last_time_sysp).f.dwHighDateTime = KernelTime.dwHighDateTime; - (*REMOTE_ThreadHandle(wid).start_of_times_sysp).dwLowDateTime = + (*REMOTE_ThreadHandle(wid).start_of_times_sysp).f.dwLowDateTime = KernelTime.dwLowDateTime; - (*REMOTE_ThreadHandle(wid).start_of_times_sysp).dwHighDateTime = + (*REMOTE_ThreadHandle(wid).start_of_times_sysp).f.dwHighDateTime = KernelTime.dwHighDateTime; #else - last_time.dwLowDateTime = UserTime.dwLowDateTime; - last_time.dwHighDateTime = UserTime.dwHighDateTime; - StartOfTimes.dwLowDateTime = UserTime.dwLowDateTime; - StartOfTimes.dwHighDateTime = UserTime.dwHighDateTime; - last_time_sys.dwLowDateTime = KernelTime.dwLowDateTime; - last_time_sys.dwHighDateTime = KernelTime.dwHighDateTime; - StartOfTimes_sys.dwLowDateTime = KernelTime.dwLowDateTime; - StartOfTimes_sys.dwHighDateTime = KernelTime.dwHighDateTime; + last_time.f.dwLowDateTime = UserTime.f.dwLowDateTime; + last_time.f.dwHighDateTime = UserTime.f.dwHighDateTime; + StartOfTimes.f.dwLowDateTime = UserTime.f.dwLowDateTime; + StartOfTimes.f.dwHighDateTime = UserTime.f.dwHighDateTime; + last_time_sys.f.dwLowDateTime = KernelTime.f.dwLowDateTime; + last_time_sys.f.dwHighDateTime = KernelTime.f.dwHighDateTime; + StartOfTimes_sys.f.dwLowDateTime = KernelTime.f.dwLowDateTime; + StartOfTimes_sys.f.dwHighDateTime = KernelTime.f.dwHighDateTime; #endif } } -#ifdef __GNUC__ -static unsigned long long int sub_utime(FILETIME t1, FILETIME t2) { - ULARGE_INTEGER u[2]; - memcpy((void *)u, (void *)&t1, sizeof(FILETIME)); - memcpy((void *)(u + 1), (void *)&t2, sizeof(FILETIME)); - return u[0].QuadPart - u[1].QuadPart; -} -#endif - UInt Yap_cputime(void) { HANDLE hProcess = GetCurrentProcess(); - FILETIME CreationTime, ExitTime, KernelTime, UserTime; - if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, - &UserTime)) { + win64_time_t CreationTime, ExitTime, KernelTime, UserTime; + if (!GetProcessTimes(hProcess, &CreationTime.f, & ExitTime.f, &KernelTime.f, + &UserTime.f)) { clock_t t; t = clock(); return (((t - TimesStartOfTimes) * 1000) / CLOCKS_PER_SEC); } else { -#ifdef __GNUC__ - unsigned long long int t = sub_utime(UserTime, StartOfTimes); - do_div(t, 10000); - return ((Int)t); -#endif -#ifdef _MSC_VER - __int64 t = *(__int64 *)&UserTime - *(__int64 *)&StartOfTimes; + __int64 t = UserTime.t - StartOfTimes.t; return ((Int)(t / 10000)); -#endif } } void Yap_cputime_interval(Int *now, Int *interval) { HANDLE hProcess = GetCurrentProcess(); - FILETIME CreationTime, ExitTime, KernelTime, UserTime; - if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, - &UserTime)) { + win64_time_t CreationTime, ExitTime, KernelTime, UserTime; + if (!GetProcessTimes(hProcess, &CreationTime.f, & ExitTime.f, &KernelTime.f, + &UserTime.f)) { clock_t t; t = clock(); *now = ((t - TimesStartOfTimes) * 1000) / CLOCKS_PER_SEC; *interval = (t - Times_last_time) * 1000 / CLOCKS_PER_SEC; Times_last_time = t; } else { -#ifdef __GNUC__ - unsigned long long int t1 = sub_utime(UserTime, StartOfTimes); - unsigned long long int t2 = sub_utime(UserTime, last_time); - do_div(t1, 10000); - *now = (Int)t1; - do_div(t2, 10000); - *interval = (Int)t2; -#endif -#ifdef _MSC_VER - __int64 t1 = *(__int64 *)&UserTime - *(__int64 *)&StartOfTimes; - __int64 t2 = *(__int64 *)&UserTime - *(__int64 *)&last_time; + __int64 t1 = UserTime.t - StartOfTimes.t; + __int64 t2 = UserTime.t - last_time.t; *now = (Int)(t1 / 10000); *interval = (Int)(t2 / 10000); -#endif - last_time.dwLowDateTime = UserTime.dwLowDateTime; - last_time.dwHighDateTime = UserTime.dwHighDateTime; + last_time.f.dwLowDateTime = UserTime.f.dwLowDateTime; + last_time.f.dwHighDateTime = UserTime.f.dwHighDateTime; } } void Yap_systime_interval(Int *now, Int *interval) { HANDLE hProcess = GetCurrentProcess(); - FILETIME CreationTime, ExitTime, KernelTime, UserTime; - if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, - &UserTime)) { + win64_time_t CreationTime, ExitTime, KernelTime, UserTime; + if (!GetProcessTimes(hProcess, &CreationTime.f, &ExitTime.f, &KernelTime.f, + &UserTime.f)) { *now = *interval = 0; /* not available */ } else { -#ifdef __GNUC__ - unsigned long long int t1 = sub_utime(KernelTime, StartOfTimes_sys); - unsigned long long int t2 = sub_utime(KernelTime, last_time_sys); - do_div(t1, 10000); - *now = (Int)t1; - do_div(t2, 10000); - *interval = (Int)t2; -#endif -#ifdef _MSC_VER - __int64 t1 = *(__int64 *)&KernelTime - *(__int64 *)&StartOfTimes_sys; - __int64 t2 = *(__int64 *)&KernelTime - *(__int64 *)&last_time_sys; + __int64 t1 = KernelTime.t - StartOfTimes_sys.t; + __int64 t2 = KernelTime.t - last_time_sys.t; *now = (Int)(t1 / 10000); *interval = (Int)(t2 / 10000); -#endif - last_time_sys.dwLowDateTime = KernelTime.dwLowDateTime; - last_time_sys.dwHighDateTime = KernelTime.dwHighDateTime; + last_time_sys.f.dwLowDateTime = KernelTime.f.dwLowDateTime; + last_time_sys.f.dwHighDateTime = KernelTime.f.dwHighDateTime; } } @@ -376,9 +345,9 @@ static void InitTime(int wid) { struct timeval tp; gettimeofday(&tp, NULL); - (*REMOTE_ThreadHandle(wid).last_timep).tv_sec = + (*REMOTE_ThreadHandle(wid).last_timep).f.tv_sec = (*REMOTE_ThreadHandle.start_of_timesp(wid)).tv_sec = tp.tv_sec; - (*REMOTE_ThreadHandle(wid).last_timep).tv_usec = + (*REMOTE_ThreadHandle(wid).last_timep).f.tv_usec = (*REMOTE_ThreadHandle.start_of_timesp(wid)).tv_usec = tp.tv_usec; } diff --git a/os/write.c b/os/write.c index e510ef0b0..18234b736 100644 --- a/os/write.c +++ b/os/write.c @@ -28,7 +28,7 @@ static char SccsId[] = "%W% %G%"; #include "Yatom.h" #include "YapHeap.h" #include "yapio.h" -#include "eval.h" +#include "YapEval.h" #include "YapText.h" #include #if HAVE_STDARG_H diff --git a/packages/CMakeLists.txt b/packages/CMakeLists.txt new file mode 100644 index 000000000..a35a1a0f5 --- /dev/null +++ b/packages/CMakeLists.txt @@ -0,0 +1,62 @@ + +#TODO: change macro_log_feature to check both WITH_{$name} and ${name}_FOUND +#TODO: improve FindGecode.cmake to be similar to other Find*.cmake +#CHECK: GECODE + +macro_optional_find_package (Gecode ON) +macro_log_feature (GECODE_FOUND "libgecode" + "Use Generic Constraint Development Environment (GECODE) library" + "http://www.gecode.org" FALSE) + +if (GECODE_FOUND) + #DEFINES: + # GECODE_INCLUDE_DIR + # GECODE_VERSION + # GECODE_LIBRARIES + + #set (EXTRALIBS gecode) + + string(SUBSTRING ${GECODE_VERSION} 0 1 GECODE_MAJOR ) + + set (GECODE_SOURCES gecode${GECODE_MAJOR}_yap.cc + gecode${GECODE_MAJOR}-common.icc + ${GECODE_VERSION}/gecode_yap_cc_impl_auto_generated.icc + ${GECODE_VERSION}/gecode_yap_cc_init_auto_generated.icc + ${GECODE_VERSION}/gecode_yap_cc_forward_auto_generated.icc + disjunctor.icc + disjunctor.hh ) + + add_custom_target (gecodeyap ALL DEPENDS gecode${GECODE_MAJOR}_yap_hand_written.yap ${GECODE_VERSION}/gecode_yap_auto_generated.yap gecode_yap + ) # WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) + + # create a startup.yss on the top directory. + add_custom_command (TARGET gecodeyap + COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/gecode${GECODE_MAJOR}_yap_hand_written.yap ${CMAKE_CURRENT_SOURCE_DIR}/${GECODE_VERSION}/gecode_yap_auto_generated.yap > gecode.yap + VERBATIM + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + ) + + add_library (gecode_yap SHARED ${GECODE_SOURCES}) + + target_link_libraries(gecode_yap libYap ${GECODE_LIBRARIES}) + + set_target_properties (gecode_yap PROPERTIES PREFIX "") + + include_directories (${GECODE_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/${GECODE_VERSION}) + + install(TARGETS gecode_yap + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} + ARCHIVE DESTINATION ${dlls} + ) + + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/gecode.yap + DESTINATION ${libpl} + ) + + install(FILES clpfd.yap + DESTINATION ${libpl}/gecode + ) + +endif (GECODE_FOUND) + diff --git a/packages/Makefile.in b/packages/Makefile.in new file mode 100644 index 000000000..1381dcf32 --- /dev/null +++ b/packages/Makefile.in @@ -0,0 +1,84 @@ +# +# default base directory for YAP installation +# (EROOT for architecture-dependent files) +# +prefix = @prefix@ +exec_prefix = @exec_prefix@ +ROOTDIR = $(prefix) +EROOTDIR = @exec_prefix@ +abs_top_builddir = @abs_top_builddir@ +# +# where the binary should be +# +BINDIR = $(EROOTDIR)/bin +# +# where YAP should look for libraries +# +LIBDIR=@libdir@ +YAPLIBDIR=@libdir@/Yap +# +# where YAP should look for architecture-independent Prolog libraries +# +SHAREDIR=$(ROOTDIR)/share +# +# +CXX=@CXX@ +CXXFLAGS= @SHLIB_CXXFLAGS@ $(YAP_EXTRAS) $(DEFS) -I. -I$(srcdir) -I../.. -I$(srcdir)/../../include -I$(srcdir)/../../os -I @GECODE_INCLUDES@ +# +# +# You shouldn't need to change what follows. +# +INSTALL=@INSTALL@ +INSTALL_DATA=@INSTALL_DATA@ +INSTALL_PROGRAM=@INSTALL_PROGRAM@ +SHELL=/bin/sh +RANLIB=@RANLIB@ +srcdir=@srcdir@ +SO=@SO@ +#4.1VPATH=@srcdir@:@srcdir@/OPTYap +CWD=$(PWD) +# + +OBJS=gecode_yap.o +SOBJS=gecode_yap.@SO@ + +GECODE_VERSION = @GECODE_VERSION@ +DISJUNCTOR = -DDISJUNCTOR +GECODE_LIBS = @GECODE_EXTRALIBS@ +GECODE_MAJOR = @GECODE_MAJOR@ +all: $(SOBJS) gecode.yap + +gecode_yap.o: \ + $(srcdir)/gecode$(GECODE_MAJOR)_yap.cc \ + $(srcdir)/gecode$(GECODE_MAJOR)-common.icc \ + $(srcdir)/$(GECODE_VERSION)/gecode_yap_cc_impl_auto_generated.icc \ + $(srcdir)/$(GECODE_VERSION)/gecode_yap_cc_init_auto_generated.icc \ + $(srcdir)/$(GECODE_VERSION)/gecode_yap_cc_forward_auto_generated.icc \ + $(srcdir)/disjunctor.icc \ + $(srcdir)/disjunctor.hh + $(CXX) -c -I$(srcdir)/$(GECODE_VERSION) $(CXXFLAGS) $(DISJUNCTOR) -o $@ $< + +@DO_SECOND_LD@gecode_yap.@SO@: gecode_yap.o +@DO_SECOND_LD@ @SHLIB_CXX_LD@ -o gecode_yap.@SO@ gecode_yap.o $(LDFLAGS) $(GECODE_LIBS) @EXTRA_LIBS_FOR_DLLS@ + +gecode.yap: $(srcdir)/gecode$(GECODE_MAJOR)_yap_hand_written.yap $(srcdir)/$(GECODE_VERSION)/gecode_yap_auto_generated.yap + cat $^ > $@ + +.PHONY: all clean install + +clean: + -rm -f *.o $(SOBJS) *~ gecode.yap + +distclean: + -rm -f $(SOBJS) Makefile + +install: all install-examples + mkdir -p $(DESTDIR)$(YAPLIBDIR) + mkdir -p $(DESTDIR)$(SHAREDIR)/Yap + mkdir -p $(DESTDIR)$(SHAREDIR)/Yap/gecode + $(INSTALL_PROGRAM) $(SOBJS) $(DESTDIR)$(YAPLIBDIR) + $(INSTALL) gecode.yap $(DESTDIR)$(SHAREDIR)/Yap + $(INSTALL) $(srcdir)/clpfd.yap $(DESTDIR)$(SHAREDIR)/Yap/gecode + +install-examples: + diff --git a/packages/README b/packages/README new file mode 100644 index 000000000..c3bca8c57 --- /dev/null +++ b/packages/README @@ -0,0 +1,12 @@ +Development of gecode/yap takes place in: + + git@github.com:denys-duchier/yap-6.3.git + +which tracks the official yap repository and is also regularly pulled into it. +see: + https://github.com/denys-duchier/yap-6.3 + +Enquiries/bug reports can be made either on the yap mailing list or to the +author denys.duchier /AT/ univ-orleans.fr. + +What litle documentation there is can be found in file DOC.txt. diff --git a/packages/bdd/CMakeLists.txt b/packages/bdd/CMakeLists.txt index 36cc5ac02..81b0073f2 100644 --- a/packages/bdd/CMakeLists.txt +++ b/packages/bdd/CMakeLists.txt @@ -51,7 +51,8 @@ IF (CUDD_FOUND) set(YAP_SYSTEM_OPTIONS "cudd " ${YAP_SYSTEM_OPTIONS} PARENT_SCOPE) install(TARGETS cudd - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/bdd/bdd.yap b/packages/bdd/bdd.yap index faaed0f85..03abff01a 100644 --- a/packages/bdd/bdd.yap +++ b/packages/bdd/bdd.yap @@ -6,7 +6,7 @@ This library provides an interface to the BDD package CUDD. It requires CUDD compiled as a dynamic library. In Linux this is available out of box in Fedora, but can easily be ported to other Linux distributions. CUDD is available in the ports OSX package, and in -cygwin. To use it, call +cygwin. To use it, call ~~~~~ :-use_module(library(bdd))`. @@ -15,7 +15,7 @@ cygwin. To use it, call The following predicates construct a BDD: \toc - + */ :- module(bdd, [ @@ -24,12 +24,12 @@ The following predicates construct a BDD: bdd_from_list/3, mtbdd_new/2, mtbdd_new/3, - bdd_eval/2, - mtbdd_eval/2, + bdd_eval/2, + mtbdd_eval/2, bdd_tree/2, bdd_size/2, - bdd_print/2, - bdd_print/3, + bdd_print/2, + bdd_print/3, bdd_to_probability_sum_product/2, bdd_to_probability_sum_product/3, bdd_reorder/2, @@ -50,7 +50,7 @@ tell_warning :- :- catch(load_foreign_files([cudd], [], init_cudd),_,fail) -> true ; tell_warning. /** -@pred bdd_new(? _Exp_, - _BddHandle_) +@pred bdd_new(? _Exp_, - _BddHandle_) create a new BDD from the logical expression _Exp_. The expression may include: @@ -93,7 +93,7 @@ bdd_new(T, Bdd) :- bdd_new(T, Vars, Bdd). /** -@pred bdd_new(? _Exp_, +_Vars_, - _BddHandle_) +@pred bdd_new(? _Exp_, +_Vars_, - _BddHandle_) Same as bdd_new/2, but receives a term of the form `vs(V1,....,Vn)`. This allows incremental construction of BDDs. @@ -104,11 +104,21 @@ bdd_new(T, Vars, cudd(M,X,VS,TrueVars)) :- VS =.. [vs|TrueVars], findall(Manager-Cudd, set_bdd(T, VS, Manager, Cudd), [M-X]). -/** @pred bdd_from_list(? _List_, ?_Vars_, - _BddHandle_) + + set_bdd(T, VS, Manager, Cudd) :- + numbervars(VS,0,_), + ( ground(T) + -> + term_to_cudd(T,Manager,Cudd) + ; + writeln(throw(error(instantiation_error,T))) + ). + +/** @pred bdd_from_list(? _List_, ?_Vars_, - _BddHandle_) Convert a _List_ of logical expressions of the form above, that includes the set of free variables _Vars_, into a BDD accessible -through _BddHandle_. +through _BddHandle_. */ % create a new BDD from a list. bdd_from_list(List, Vars, cudd(M,X,VS,TrueVars)) :- @@ -116,15 +126,6 @@ bdd_from_list(List, Vars, cudd(M,X,VS,TrueVars)) :- VS =.. [vs|TrueVars], findall(Manager-Cudd, set_bdd_from_list(List, VS, Manager, Cudd), [M-X]). -set_bdd(T, VS, Manager, Cudd) :- - numbervars(VS,0,_), - ( ground(T) - -> - term_to_cudd(T,Manager,Cudd) - ; - writeln(throw(error(instantiation_error,T))) - ). - set_bdd_from_list(T0, VS, Manager, Cudd) :- numbervars(VS,0,_), generate_releases(T0, Manager, T), @@ -133,7 +134,7 @@ set_bdd_from_list(T0, VS, Manager, Cudd) :- list_to_cudd(T,Manager,_Cudd0,Cudd). generate_releases(T0, Manager, T) :- - rb_empty(RB0), + rb_empty(RB0), reverse(T0, [H|R]), add_releases(R, RB0, [H], Manager, T). @@ -190,7 +191,7 @@ list_to_cudd([(V=Tree)|T], Manager, _Cudd0, CuddF) :- V = cudd(Cudd), list_to_cudd(T, Manager, Cudd, CuddF). -/** @pred mtbdd_new(? _Exp_, - _BddHandle_) +/** @pred mtbdd_new(? _Exp_, - _BddHandle_) create a new algebraic decision diagram (ADD) from the logical expression _Exp_. The expression may include: @@ -207,7 +208,7 @@ sum subtraction + or( _X_, _Y_), _X_ \/ _Y_ logical or - + */ mtbdd_new(T, Mtbdd) :- term_variables(T, Vars), @@ -218,15 +219,15 @@ mtbdd_new(T, Vars, add(M,X,VS,Vars)) :- functor(VS,vs,Sz), findall(Manager-Cudd, (numbervars(VS,0,_),term_to_add(T,Sz,Manager,Cudd)), [M-X]). -/** @pred bdd_eval(+ _BDDHandle_, _Val_) +/** @pred bdd_eval(+ _BDDHandle_, _Val_) Unify _Val_ with the value of the logical expression compiled in _BDDHandle_ given an assignment to its variables. ~~~~~ -bdd_new(X+(Y+X)*(-Z), BDD), -[X,Y,Z] = [0,0,0], -bdd_eval(BDD, V), +bdd_new(X+(Y+X)*(-Z), BDD), +[X,Y,Z] = [0,0,0], +bdd_eval(BDD, V), writeln(V). ~~~~~ would write 0 in the standard output stream. @@ -249,7 +250,7 @@ computing the disjunction of the two cases and binding the output variable. The top node gives the full expression value. Notice that `(1- _X_)` implements negation. - + */ bdd_eval(cudd(M, X, Vars, _), Val) :- cudd_eval(M, X, Vars, Val). @@ -260,15 +261,15 @@ mtbdd_eval(add(M,X, Vars, _), Val) :- add_eval(M, X, Vars, Val). % get the BDD as a Prolog list from the CUDD C object -/** @pred bdd_tree(+ _BDDHandle_, _Term_) +/** @pred bdd_tree(+ _BDDHandle_, _Term_) Convert the BDD or ADD represented by _BDDHandle_ to a Prolog term of the form `bdd( _Dir_, _Nodes_, _Vars_)` or `mtbdd( _Nodes_, _Vars_)`, respectively. The arguments are: -+ ++ _Dir_ direction of the BDD, usually 1 -+ - _Nodes_ list of nodes in the BDD or ADD. ++ + _Nodes_ list of nodes in the BDD or ADD. In a BDD nodes may be pp (both terminals are positive) or pn (right-hand-side is negative), and have four arguments: a logical @@ -277,7 +278,7 @@ variable corresponding to the node, a logical variable, a 0 or a 1 with the value of the left-hand side, and a logical variable, a 0 or a 1 with the right-hand side. -+ ++ _Vars_ are the free variables in the original BDD, or the parameters of the BDD/ADD. As an example, the BDD for the expression `X+(Y+X)\*(-Z)` becomes: @@ -286,19 +287,19 @@ As an example, the BDD for the expression `X+(Y+X)\*(-Z)` becomes: bdd(1,[pn(N2,X,1,N1),pp(N1,Y,N0,1),pn(N0,Z,1,1)],vs(X,Y,Z)) ~~~~~ - + */ bdd_tree(cudd(M, X, Vars, _Vs), bdd(Dir, List, Vars)) :- cudd_to_term(M, X, Vars, Dir, List). bdd_tree(add(M, X, Vars, _), mtbdd(Tree, Vars)) :- add_to_term(M, X, Vars, Tree). -/** @pred bdd_to_probability_sum_product(+ _BDDHandle_, - _Prob_) +/** @pred bdd_to_probability_sum_product(+ _BDDHandle_, - _Prob_) Each node in a BDD is given a probability _Pi_. The total probability of a corresponding sum-product network is _Prob_. - + */ bdd_to_probability_sum_product(cudd(M,X,_,Probs), Prob) :- cudd_to_probability_sum_product(M, X, Probs, Prob). @@ -323,13 +324,13 @@ eval_prob(pp(P,X,L,R), _, P) :- eval_prob(pn(P,X,L,R), _, P) :- P is X * L + (1-X) * (1-R). ~~~~~ - + */ bdd_to_probability_sum_product(cudd(M,X,_,_Probs), Probs, Prob) :- cudd_to_probability_sum_product(M, X, Probs, Prob). -/** @pred bdd_close( _BDDHandle_) +/** @pred bdd_close( _BDDHandle_) close the BDD and release any resources it holds. @@ -339,7 +340,7 @@ bdd_close(cudd(M,_,_Vars, _)) :- bdd_close(add(M,_,_Vars, _)) :- cudd_die(M). -/** @pred bdd_close( _BDDHandle_) +/** @pred bdd_close( _BDDHandle_) close the BDD and release any resources it holds. @@ -347,22 +348,22 @@ bdd_close(add(M,_,_Vars, _)) :- bdd_reorder(cudd(M,Top,_Vars, _), How) :- cudd_reorder(M, Top,How). -/** @pred bdd_size(+ _BDDHandle_, - _Size_) +/** @pred bdd_size(+ _BDDHandle_, - _Size_) Unify _Size_ with the number of nodes in _BDDHandle_. - + */ bdd_size(cudd(M,Top,_Vars, _), Sz) :- cudd_size(M,Top,Sz). bdd_size(add(M,Top,_Vars, _), Sz) :- cudd_size(M,Top,Sz). -/** @pred bdd_print(+ _BDDHandle_, + _File_) +/** @pred bdd_print(+ _BDDHandle_, + _File_) Output bdd _BDDHandle_ as a dot file to _File_. - + */ bdd_print(cudd(M,Top,_Vars, _), File) :- absolute_file_name(File, AFile, []), @@ -374,11 +375,11 @@ bdd_print(add(M,Top,_Vars, _), File) :- bdd_print(cudd(M,Top, Vars, _), File, Names) :- Vars =.. [_|LVars], %trace, - maplist( fetch_name(Names), LVars, Ss), + maplist( fetch_name(Names), LVars, Ss), absolute_file_name(File, AFile, []), cudd_print(M, Top, AFile, Ss). bdd_print(add(M,Top, Vars, _), File, Names) :- - Vars =.. [_|LVars], + Vars =.. [_|LVars], maplist( fetch_name(Names), LVars, Ss), absolute_file_name(File, AFile, []), cudd_print(M, Top, AFile, Ss). @@ -398,7 +399,7 @@ bdd_to_sp(bdd(Dir, Tree, _Vars, IVars), Binds, Prob) :- sp(Dir, Tree, Vars, Vars, P) :- run_sp(Tree), - fetch(Tree, Dir, P). + fetch(Tree, Dir, P). run_sp([]). run_sp(pp(P,X,L,R).Tree) :- diff --git a/packages/bdd/trie_sp.yap b/packages/bdd/trie_sp.yap index 650763cf4..d12b1f39b 100644 --- a/packages/bdd/trie_sp.yap +++ b/packages/bdd/trie_sp.yap @@ -33,9 +33,10 @@ extract_vars((_-V).MapList, V.Vs) :- extract_vars(MapList, Vs). complex_to_andor(empty, Map, Map, 0). -complex_to_andor([endlist], Map, Map, 0) :- !. complex_to_andor([list(Els)], Map0, MapF, Tree) :- !, - complex_to_andor(Els, Map0, MapF, Tree). +complex_to_andor(Els, Map0, MapF, Tree). +complex_to_andor([endlist|_], Map, Map, 1) :- !. + El1 == endlist, !. complex_to_andor([El1,El2|Els], Map0, MapF, or(T1,T2)) :- !, complex_to_and(El1, Map0, MapI, T1), complex_to_andor([El2|Els], MapI, MapF, T2). @@ -44,8 +45,8 @@ complex_to_andor([Els], Map0, MapF, V) :- complex_to_and(int(A1,[endlist]), Map0, MapF, V) :- !, check(Map0, A1, V, MapF). +complex_to_and(atom(true,[endlist]), Map0, MapF, 1) :- !. complex_to_and(atom(A1,[endlist]), Map0, MapF, V) :- !, - check(Map0, A1, V, MapF). complex_to_and(functor(not,1,[int(A1,[endlist])]), Map0, MapF, not(V)) :- !, check(Map0, A1, V, MapF). complex_to_and(functor(not,1,[atom(A1,[endlist])]), Map0, MapF, not(V)) :- !, @@ -63,7 +64,7 @@ complex_to_and(functor(not,1,[atom(A1,Els)]), Map0, MapF, and(not(V),T2)) :- !, check(Map0, A1, V, MapI), complex_to_andor(Els, MapI, MapF, T2). % HASH TABLE, it can be an OR or an AND. -complex_to_and(functor(not,1,[int(A1,Els)|More]), Map0, MapF, or(NOTV1,O2)) :- +complex_to_and(functor(not,1,[int(A1,Els)|More]), Map0, MapF, or(NOTV1,O2)) :- check(Map0, A1, V, MapI), (Els == [endlist] -> @@ -74,8 +75,9 @@ complex_to_and(functor(not,1,[int(A1,Els)|More]), Map0, MapF, or(NOTV1,O2)) :- NOTV1 = and(not(V), T2) ), complex_to_and(functor(not,1,More), MapI2, MapF, O2). -complex_to_and(functor(not,1,[atom(A1,Els)|More]), Map0, MapF, or(NOTV1,O2)) :- +complex_to_and(functor(not,1,[atom(A1,Els)|More]), Map0, MapF, or(NOTV1,O2)) :- check(Map0, A1, V, MapI), + check(Map0, A1, V, MapF). (Els == [endlist] -> NOTV1 = not(V), @@ -86,17 +88,18 @@ complex_to_and(functor(not,1,[atom(A1,Els)|More]), Map0, MapF, or(NOTV1,O2)) :- ), complex_to_and(functor(not,1,More), MapI2, MapF, O2). -tabled_complex_to_andor(T, Map, Map, Tab, Tab, V) :- +tabled_complex_to_andor(empty, Map, Map, Tab, Tab, 0). +tabled_complex_to_andor(T, Map, Map, Tab, Tab, V) :- rb_lookup(T, V, Tab), !, increment_ref_count(V). -tabled_complex_to_andor(IN, Map0, MapF, Tab0, TabF, OUT) :- - IN = [El1,El2|Els], !, - OUT = or(0,_,T1,T2), - rb_insert(Tab0, IN, OUT, Tab1), - tabled_complex_to_and(El1, Map0, MapI, Tab1, TabI, T1), - tabled_complex_to_andor(El2.Els, MapI, MapF, TabI, TabF, T2). +tabled_complex_to_andor(IN, Map, Map, Tab, Tab, 1) :- + IN = !. tabled_complex_to_andor([Els], Map0, MapF, Tab0, TabF, V) :- tabled_complex_to_and(Els, Map0, MapF, Tab0, TabF, V). + rb_insert(Tab0, IN, OUT, Tab1), +tabled_complex_to_andor([El1,Dl2], Map0, MapF, Tab0, TabF, or(T1,T2)) :- + tabled_complex_to_and(El1, Map0, MapI, Tab1, TabI, T1), + tabled_complex_to_andor(El2.Els, MapI, MapF, TabI, TabF, T2). tabled_complex_to_and(int(A1,[endlist]), Map0, MapF, Tab, Tab, V) :- !, check(Map0, A1, V, MapF). @@ -106,16 +109,16 @@ tabled_complex_to_and(functor(not,1,[int(A1,[endlist])]), Map0, MapF, Tab, Tab, check(Map0, A1, V, MapF). tabled_complex_to_and(functor(not,1,[atom(A1,[endlist])]), Map0, MapF, Tab, Tab, not(V)) :- !, check(Map0, A1, V, MapF). -tabled_complex_to_and(T, Map, Map, Tab, Tab, V) :- +tabled_complex_to_and(T, Map, Map, Tab, Tab, V) :- rb_lookup(T, V, Tab), !, increment_ref_count(V). -tabled_complex_to_and(IN, Map0, MapF, Tab0, TabF, OUT) :- +tabled_complex_to_and(IN, Map0, MapF, Tab0, TabF, OUT) :- IN = int(A1,Els), !, check(Map0, A1, V, MapI), rb_insert(Tab0, IN, OUT, TabI), OUT = and(0, _, V, T2), tabled_complex_to_andor(Els, MapI, MapF, TabI, TabF, T2). -tabled_complex_to_and(IN, Map0, MapF, Tab0, TabF, OUT) :- +tabled_complex_to_and(IN, Map0, MapF, Tab0, TabF, OUT) :- IN = atom(A1,Els), !, check(Map0, A1, V, MapI), rb_insert(Tab0, IN, OUT, TabI), @@ -141,5 +144,3 @@ increment_ref_count(V) :- arg(1,V,I0), I is I0+1, setarg(1,V,I). - - diff --git a/packages/clp_examples/3jugs.yap b/packages/clp_examples/3jugs.yap new file mode 100644 index 000000000..f5749f530 --- /dev/null +++ b/packages/clp_examples/3jugs.yap @@ -0,0 +1,129 @@ +% Example with matrices,based on: +% +% Three jugs problem in Minzinc modelled as a shortest path problem. +% +% Problem from Taha "Introduction to Operations Research", page 245 +% +% Model created by Hakan Kjellerstrand, hakank@bonetmail.com +% See also my MiniZinc page: http://www.hakank.org/minizinc + +% +% VSC: had to transpose the matrix, and change the constraints.... +% + +:- style_check( all ). + +:- use_module(library(gecode/clpfd)). +:- use_module(library(maplist)). +:- use_module(library(lists)). + +main :- + problem(Z, X, InFlow, OutFlow, N), + out(Z, X, InFlow, OutFlow, N), + fail. +main. + +problem(Z, X, InFlow, OutFlow, N) :- + N = 15, + Start = 1, + End = 15, + M = 999, + d( M, DD ), + D <== array[1..N,1..N] of DD, % distance + RHS <== array[1..N] of _, % requirements (right hand statement) + X <== array[1..N, 1..N] of 0..1, % the resulting matrix, 1 if connected, 0 else + OutFlow <== array[1..N] of 0..1, + InFlow <== array[1..N] of 0..1, + +% objective to minimize + Z in 0..M, + Z #= sum( [I in 1..N, J in 1..N] where D[I,J] + RHS[I] <== 1 ; + I == End -> + RHS[I] <== -1 ; + RHS[I] <== 0 ) + ), + + + % must be larger than 0?? + foreach( [I in 1..N, J in 1..N], + ( D[J,I] = M -> + X[J,I] #= 0 ; + true ) + ), + % outflow constraint + foreach(I in 1..N, + OutFlow[I] #= sum(J in 1..N where D[J,I]. +%%============================================================================= + +:- use_module(library(gecode/clpfd)). +:- use_module(library(maplist)). + +main :- ex(Ex, People, Names, _Preferences), + photo(Ex, People, Amount ), + format( 'Example ~a: ~w~n', [Ex, Amount]), + maplist(join, People, Names, PeopleNames), + keysort( PeopleNames, SortedPeopleNames), + maplist(join, _People, SortedNames, SortedPeopleNames), + maplist(output, SortedNames ), + fail. +main. + +join( Key, El, Key-El ). + +output( Name ) :- format(' ~a~n', [Name]). + +% 5 people want to have a photograph together, but they have preferences. +photo(Ex, People, Amount) :- + ex(Ex, People, _, Preferences), + length(People, Len), + Len0 is Len-1, + People ins 0..Len0, + all_distinct(People), + % Bools are the satisfied constraints + maplist(preference_satisfied, Preferences, Bools), + length(Preferences, PLen), + Amount in 0..PLen, + sum( Bools ) #= Amount, + % add all satisfied constraints + maximize(Amount), + labeling([], People). + +%reification, use with care +preference_satisfied(X-Y, B) :- + abs(X - Y) #= 1 #<==> B. + +ex(s,[Alice,Bob,Carl,Deb,Evan], + ['Alice','Bob','Carl','Deb','Evan'], + [Alice-Carl, + Carl-Deb, + Deb-Alice, + Evan-Alice, + Bob-Evan, + Carl-Evan, + Deb-Evan, + Evan-Bob]). + +ex(l,[Betty,Chris,Donald,Fred,Gary,Mary,Paul,Peter,Susan], + ['Betty','Chris','Donald','Fred','Gary','Mary','Paul','Peter','Susan'], + [Betty-Donald, + Betty-Gary, + Betty-Peter, + Chris-Gary, + Chris-Susan, + Donald-Fred, + Donald-Gary, + Fred-Betty, + Fred-Gary, + Gary-Mary, + Gary-Betty, + Mary-Betty, + Mary-Susan, + Paul-Donald, + Paul-Peter, + Peter-Susan, + Peter-Paul]). diff --git a/packages/clp_examples/queens.yap b/packages/clp_examples/queens.yap new file mode 100644 index 000000000..bfc9b9839 --- /dev/null +++ b/packages/clp_examples/queens.yap @@ -0,0 +1,49 @@ + +:- use_module(library(gecode/clpfd)). +:- use_module(library(maplist)). + +main :- + between(1,10,N), + I is N*100, + statistics( runtime, _ ), + once( queens(I, _Queens) ), + statistics( runtime, [DT|_] ), +% findall(Queens, queens(I, Queens), Solutions ), +% length( Solutions, N), + format('~d took ~w msec to find first solution.~n', [I, DT]), + fail. +main. + +queens(N, Queens) :- + length(Queens, N), + Queens ins 1..N, + all_distinct(Queens), + foldl(inc, Queens, Inc, 0, _), % [0, 1, 2, .... ] + foldl(dec, Queens, Dec, 0, _), % [0, -1, -2, ... ] + all_distinct(Inc,Queens), + all_distinct(Dec,Queens), + labeling([], Queens). + +inc(_, I0, I0, I) :- + I is I0+1. + +dec(_, I0, I0, I) :- + I is I0-1. + +lqueens(N, Queens) :- + length(Queens, N), + Queens ins 1..N, + all_distinct(Queens), + lconstrain( Queens, 0 ), + labeling([], Queens). + +lconstrain([], _). +lconstrain( [Q|Queens], I0) :- + I is I0+1, + foldl(constrain(Q, I0), Queens, I, _), + lconstrain( Queens, I). + +constrain(Q, I, R, J, J1) :- + J1 is J+1, + Q + I #\= R + J, + Q - I #\= R - J. diff --git a/packages/clp_examples/send_more_money.yap b/packages/clp_examples/send_more_money.yap new file mode 100644 index 000000000..6f9c467fa --- /dev/null +++ b/packages/clp_examples/send_more_money.yap @@ -0,0 +1,44 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011, 2013 by Denys Duchier, Vitor Santos Costa +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +:- use_module(library(gecode/clpfd)). + +main :- + statistics( runtime, _ ), + once( send_more_money(Letters) ), + statistics( runtime, [DT|_] ), +% findall(Queens, queens(I, Queens), Solutions ), +% length( Solutions, N), + format('took ~w msec to find first solution, ~w.~n', [I, DT, Letters]), + fail. +main. + +% S E N D +% + M O R E +% --------- +% M O N E Y +send_more_money(Letters) :- + [S,E,N,D,M,O,R,Y] = Letters, + Letters ins 0..9, + M #\= 0, + S #\= 0, + all_distinct(Letters), + 1000*S + 100*E + 10*N + D + + 1000*M + 100*O + 10*R + E #= + 10000*M + 1000*O + 100*N + 10*E + Y, + labeling([], Letters). diff --git a/packages/clp_examples/send_most_money.yap b/packages/clp_examples/send_most_money.yap new file mode 100644 index 000000000..e31a7c16e --- /dev/null +++ b/packages/clp_examples/send_most_money.yap @@ -0,0 +1,47 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011, 2013 by Denys Duchier, Vitor Santos Costa +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +:- use_module(library(gecode/clpfd)). + + +main :- + statistics( runtime, _ ), + once( send_most_money(Letters, Money) ), + statistics( runtime, [DT|_] ), +% findall(Queens, queens(I, Queens), Solutions ), +% length( Solutions, N), + format('took ~w msec to find first solution, ~w.~n', [DT, Letters:Money]), + fail. +main. + +% S E N D +% + M O S T +% --------- +% M O N E Y +send_most_money(Letters, Money) :- + [S,E,N,D,M,O,T,Y] = Letters, + Letters ins 0..9, + Money in 0..99999, + M #\= 0, + S #\= 0, + all_distinct(Letters), + 1000*S + 100*E + 10*N + D + + 1000*M + 100*O + 10*S + T #= Money, + 10000*M + 1000*O + 100*N + 10*E + Y #= Money, + maximize(Money), + labeling([], Letters). diff --git a/packages/clp_examples/sudoku.yap b/packages/clp_examples/sudoku.yap new file mode 100644 index 000000000..08a8230ac --- /dev/null +++ b/packages/clp_examples/sudoku.yap @@ -0,0 +1,84 @@ + + +:- style_check(all). + +:- use_module(library(gecode/clpfd)). +:- use_module(library(maplist)). + +main :- + ex(Ex, _), + sudoku(Ex, _My), + fail. +main. + +sudoku( Ex, Els ) :- + problem(Ex, Els), + output(Els). + +% +% gecode constraints +% +problem(Ex, Els) :- + length(Els, 81), + Els ins 1..9, + M <== matrix( Els, [dim=[9,9]] ), + % select rows + foreach( I in 0..8 , all_different(M[I,_]) ), + % select cols + foreach( J in 0..8, all_different(M[_,J]) ), + % select squares + foreach( [I,J] ins 0..2 , + all_different(M[I*3+(0..2),J*3+(0..2)]) ), + ex(Ex, Els), +% maplist( bound, Els, Exs), + labeling( [], Els ). + + +% The gecode interface doesn't support wake-ups on binding constained variables, this is the closest. +% +bound(El, X) :- + ( nonvar(X) -> El #= X ; true ). + +% +% output using matrix library +% +output(Els) :- + M <== matrix( Els, [dim=[9,9]] ), + foreach( I in 0..2 , output(M, I) ), + output_line. + +output(M, I) :- + output_line, + foreach( J in 0..2 , output_row(M, J+I*3) ). + +output_row( M, Row ) :- + L <== M[Row,_], + format('| ~d ~d ~d | ~d ~d ~d | ~d ~d ~d |~n', L). + +output_line :- + format(' ~|~`-t~24+~n', []). + +ex( 1, [ + _,6,_,1,_,4,_,5,_, + _,_,8,3,_,5,6,_,_, + 2,_,_,_,_,_,_,_,1, + 8,_,_,4,_,7,_,_,6, + _,_,6,_,_,_,3,_,_, + 7,_,_,9,_,1,_,_,4, + 5,_,_,_,_,_,_,_,2, + _,_,7,2,_,6,9,_,_, + _,4,_,5,_,8,_,7,_ + ] ). + + +ex(2, [ + _,_,1,_,8,_,6,_,4, + _,3,7,6,_,_,_,_,_, + 5,_,_,_,_,_,_,_,_, + _,_,_,_,_,5,_,_,_, + _,_,6,_,1,_,8,_,_, + _,_,_,4,_,_,_,_,_, + _,_,_,_,_,_,_,_,3, + _,_,_,_,_,7,5,2,_, + 8,_,2,_,9,_,7,_,_ + ] ). diff --git a/packages/clp_examples/test.yap b/packages/clp_examples/test.yap new file mode 100644 index 0000000000000000000000000000000000000000..7a9862416a2773ef270f5e1c8bbab3f883a3787d GIT binary patch literal 2807 zcmc&$VNau45Z$l#S4^^BZu72{+g7U^Yts73P2T56i-cf%t7It{z+K&6zh|ZtN|ma~ zOE$&=m*LKtbA~x|z8zCuyu>zGJlMq#MPVFMx7X=l{VBJ>I$b`+R>jd>7G^K%-Y(Lm zJz2z$t7R8qZ%3`e$2iIh4(JpPeLLdlq4rK<3w{@#NnNdqvT$B zz9!H01z*2P-fvG1m`73y$Gpz&(g_WvoVF~3D$Aff%Yd^;nt_^Z(oAR!q;9wc8RyMOqv02(HT(*J{O~iN=8SIe z8r_;0QlqQOR$@3hIKVRc$dTwgLOT1H2zr3)|g-vom z5945wCV7#e0SeVxgQjb)V!!5Vsjaa(MQF2P*U;BXa`E^KXSaBnn7%z8_E)CD%&1~! z)XvPPWM=eH*_NwN6muY2p+vQ=<`bjQScMYZ_~dwV#;?2Mzo+7Ph4s80>p8H>D|-I6 zj5_#_g=;8@wRhB%f<9MGE$EhwN=sSzUuC?gsJT%8Zg{*LkBLoSb6wAT6kks4i&EAL zuqn^GXzwt~!WR!CtdAjpU!T$yp{IFNG$)sMiR(d9U)m36eWup+`qff@yHrQ zYq@~~3wA`VccZ_{ORx@~qjmJ#syW};VQRH1x%$GcykpCUe7Q2_%9&%E+!qhZ)il`j zO6gjxF~;a+GwF^zwHKQMW^Cl60pAr8B%Sq6#;ayV)UWX$n*%Ovwl*w5@8Vg+AwEP^nrUwe@16KO!$DZR Nj3W4!EKfeh-XE5Rzw-b9 literal 0 HcmV?d00001 diff --git a/packages/clpfd.yap b/packages/clpfd.yap new file mode 100644 index 000000000..1d14385c7 --- /dev/null +++ b/packages/clpfd.yap @@ -0,0 +1,1318 @@ +/** +@defgroup Gecode_and_ClPbBFDbC Programming Finite Domain Constraints in YAP/Gecode +@ingroup Gecode +@{ + +The gecode/clp(fd) interface is designed to use the GECODE functionality +in a more CLP like style. It requires + +~~~~~{.prolog} +:- use_module(library(gecode/clpfd)). +~~~~~ +Several example programs are available with the distribution. + +Integer variables are declared as: + ++ _V_ in _A_.. _B_ +declares an integer variable _V_ with range _A_ to _B_. ++ _Vs_ ins _A_.. _B_ +declares a set of integer variabless _Vs_ with range _A_ to _B_. ++ boolvar( _V_) +declares a boolean variable. ++ boolvars( _Vs_) +declares a set of boolean variable. + + +Constraints supported are: + +*/ + + +:- module(gecode_clpfd, [ + op(100, yf, []), + op(760, yfx, #<==>), + op(750, xfy, #==>), + op(750, yfx, #<==), + op(740, yfx, #\/), + op(730, yfx, #\), + op(720, yfx, #/\), + op(710, fy, #\), + op(705, xfx, where), + op(700, xfx, #>), + op(700, xfx, #<), + op(700, xfx, #>=), + op(700, xfx, #=<), + op(700, xfx, #=), + op(700, xfx, #\=), + op(700, xf, #>), + op(700, xf, #<), + op(700, xf, #>=), + op(700, xf, #=<), + op(700, xf, #=), + op(700, xf, #\=), + op(500, yfx, '<=>'), + op(500, yfx, '=>'), + op(450, xfx, ..), % should bind more tightly than \/ + (#>)/2, + (#<)/2, + (#>=)/2, + (#=<)/2, + (#=)/2, + (#\=)/2, + (#>)/1, + (#<)/1, + (#>=)/1, + (#=<)/1, + (#=)/1, + (#\=)/1, + (#<==>)/2, + (#==>)/2, + (#<==)/2, + (#\)/1, + (#\/)/2, + (#/\)/2, + in/2 , + ins/2, + boolvar/1, + boolvars/1, + all_different/1, + all_distinct/1, + all_distinct/2, + maximize/1, + minimize/1, + sum/3, + lex_chain/1, + minimum/2, + min/2, + maximum/2, + max/2, + scalar_product/4, + element/2, + extensional_constraint/2, + in_relation/2, + clause/4, + dfa/4, + in_dfa/2, + in_dfa/4, /* + tuples_in/2, */ + labeling/2 /*, + label/1, + indomain/1, + serialized/2, + global_cardinality/2, + global_cardinality/3, + circuit/1, + element/3, + automaton/3, + automaton/8, + transpose/2, + zcompare/3, + chain/2, + fd_var/1, + fd_inf/2, + fd_sup/2, + fd_size/2, + fd_dom/2 */ + ]). + +/** @pred _X_ #< _B_ is det +reified implication + +As an example. consider finding out the people who wanted to sit +next to a friend and that are are actually sitting together: + +~~~~~{.prolog} +preference_satisfied(X-Y, B) :- + abs(X - Y) #= 1 #<==> B. +~~~~~ +Note that not all constraints may be reifiable. + + +*/ +/** @pred _X_ #< _Y_ is semidet +smaller or equal + +Arguments to this constraint may be an arithmetic expression with +, +-, \\*, integer division /, min, max, sum, +count, and +abs. Boolean variables support conjunction (/\), disjunction (\/), +implication (=>), equivalence (<=>), and xor. The sum constraint allows a two argument version using the +`where` conditional, in Zinc style. + +The send more money equation may be written as: + +~~~~~{.prolog} + 1000*S + 100*E + 10*N + D + + 1000*M + 100*O + 10*R + E #= +10000*M + 1000*O + 100*N + 10*E + Y, +~~~~~ + +This example uses `where` to select from +column _I_ the elements that have value under _M_: + +~~~~~{.prolog} +OutFlow[I] #= sum(J in 1..N where D[J,I]count constraint counts the number of elements that match a +certain constant or variable (integer sets are not available). + + +*/ +/** @pred _X_ #<==> _B_ is det +reified equivalence + +*/ +/** @pred _X_ #= _Y_ is semidet +equality + +*/ +/** @pred _X_ #=< _Y_ is semidet +smaller + +*/ +/** @pred _X_ #==> _B_ is det +Reified implication + +*/ +/** @pred _X_ #> _Y_ is semidet +larger + +*/ +/** @pred _X_ #>= _Y_ is semidet +larger or equal + +*/ +/** @pred _X_ #\= _Y_ is semidet +disequality + +*/ +/** @pred labeling( _Opts_, _Xs_) +performs labeling, several variable and value selection options are +available. The defaults are `min` and `min_step`. + +Variable selection options are as follows: + ++ leftmost +choose the first variable ++ min +choose one of the variables with smallest minimum value ++ max +choose one of the variables with greatest maximum value ++ ff +choose one of the most constrained variables, that is, with the smallest +domain. + + +Given that we selected a variable, the values chosen for branching may +be: + ++ min_step +smallest value ++ max_step +largest value ++ bisect +median ++ enum +all value starting from the minimum. + + + +*/ +/** @pred scalar_product(+ _Cs_, + _Vs_, + _Rel_, ? _V_ ) + +The product of constant _Cs_ by _Vs_ must be in relation + _Rel_ with _V_ . + + +*/ + +:- use_module(library(gecode)). +:- use_module(library(maplist)). + +:- reexport(library(matrix), [(<==)/2, op(800, xfx, '<=='), + op(700, xfx, in), + op(700, xfx, ins), + op(450, xfx, ..), % should bind more tightly than \/ + op(710, xfx, of), + foreach/2, foreach/4, of/2]). + +% build array of constraints +% +matrix:array_extension(_.._ , gecode_clpfd:build). + +build( I..J, _, Size, L) :- + length( L, Size ), + L ins I..J. + +matrix:rhs_opaque(X) :- constraint(X). + +constraint( (_ #> _) ). +constraint( (_ #< _) ). +constraint( (_ #>= _) ). +constraint( (_ #=< _) ). +constraint( (_ #= _) ). +constraint( (_ #\= _) ). +constraint( (_ #\ _) ). +constraint( (_ #<==> _) ). +constraint( (_ #==> _) ). +constraint( (_ #<== _) ). +constraint( (_ #\/ _) ). +constraint( (_ #/\ _) ). +constraint( in(_, _) ). %2, +constraint( ins(_, _) ). %2, +constraint( all_different(_) ). %1, +constraint( all_distinct(_) ). %1, +constraint( all_distinct(_,_) ). %1, +constraint( sum(_, _, _) ). %3, +constraint( scalar_product(_, _, _, _) ). %4, +constraint( min(_, _) ). %2, +constraint( minimum(_, _) ). %2, +constraint( max(_, _) ). %2, +constraint( maximum(_, _) ). %2, +constraint( in_relation(_, _) ). %2, +constraint( in_dfa(_, _) ). %2, +constraint( in_dfa(_, _, _, _) ). %2, +constraint( tuples_in(_, _) ). %2, +constraint( labeling(_, _) ). %2, +constraint( label(_) ). %1, +constraint( indomain(_) ). %1, +constraint( lex_chain(_) ). %1, +constraint( serialized(_, _) ). %2, +constraint( global_cardinality(_, _) ). %2, +constraint( global_cardinality(_, _, _) ). %3, +constraint( circuit(_) ). %1, +constraint( element(_, _, _) ). %3, +constraint( automaton(_, _, _) ). %3, +constraint( automaton(_, _, _, _, _, _, _, _) ). %8, +constraint( transpose(_, _) ). %2, +constraint( zcompare(_, _, _) ). %3, +constraint( chain(_, _) ). %2, +constraint( element(_, _) ). %2, +constraint( fd_var(_) ). %1, +constraint( fd_inf(_, _) ). %2, +constraint( fd_sup(_, _) ). %2, +constraint( fd_size(_, _) ). %2, +constraint( fd_dom(_, _) ). %2 +constraint( clause(_, _, _, _) ). %2 + + +process_constraints((B0,B1), (NB0, NB1), Env) :- + process_constraints(B0, NB0, Env), + process_constraints(B1, NB1, Env). +process_constraints(B, B, env(_Space)) :- + constraint(B), !. +process_constraints(B, B, _Env). +% process_constraint(B, NB, Space). + +( A #= B) :- + get_home(Env), + check(A, NA), + check(B, NB), + post( rel(NA, (#=), NB), Env, _). +( A #\= B) :- + get_home(Env), + check(A, NA), + check(B, NB), + post( rel(NA, (#\=), NB), Env, _). +( A #< B) :- + get_home(Env), + check(A, NA), + check(B, NB), + post( rel(NA, (#<), NB), Env, _). +( A #> B) :- + get_home(Env), + check(A, NA), + check(B, NB), + post( rel(NA, (#>), NB), Env, _). +( A #=< B) :- + get_home(Env), + check(A, NA), + check(B, NB), + post( rel(NA, (#=<), NB), Env, _). +( A #>= B) :- + get_home(Env), + check(A, NA), + check(B, NB), + post( rel(NA, (#>=), NB), Env, _). +( A #= ) :- + get_home(Env), + check(A, NA), + post( rel(NA, (#=)), Env, _). +/** @pred _X_ #= is det +all elements of _X_ must take the same value + +*/ +( A #\= ) :- + get_home(Env), + check(A, NA), + post( rel(NA, (#\=)), Env, _). +/** @pred _X_ #< is det +elements of _X_ must be decreasing or equal + + +*/ +( A #< ) :- + get_home(Env), + check(A, NA), + post( rel(NA, (#<)), Env, _). +/** @pred _X_ #> is det +elements of _X_ must be increasing + +*/ +( A #> ) :- + get_home(Env), + check(A, NA), + post( rel(NA, (#>)), Env, _). +/** @pred _X_ #=< is det +elements of _X_ must be decreasing + +*/ +( A #=< ) :- + get_home(Env), + check(A, NA), + post( rel(NA, (#=<) ), Env, _). +/** @pred _X_ #>= is det +elements of _X_ must be increasinga or equal + +*/ +( A #>= ) :- + get_home(Env), + check(A, NA), + post( rel(NA, (#>=)), Env, _). +sum( L, Op, V) :- + get_home( Env ), + check(L, NL), + check(V, NV), + post( rel(sum(NL), Op, NV), Env, _). +( ( A #<==> VBool )) :- + get_home(Space-Map), + check(A, NA), + check(VBool, NVBool), + Bool := boolvar(Space), + m( NVBool, Bool, 0, 1, Map), + Space += reify(Bool, 'RM_EQV', R), + post(NA, Space-Map, R). +( A #==> VBool) :- + get_home(Space-Map), + check(A, NA), + check(VBool, NVBool), + Bool := boolvar(Space), + m( NVBool, Bool, 0, 1, Map), + Space += reify(Bool, 'RM_IMP', R), + post(NA, Space-Map, R). +( A #<== VBool) :- + get_home(Space-Map), + check(A, NA), + check(VBool, NVBool), + Bool := boolvar(Space), + m( NVBool, Bool, 0, 1, Map), + Space += reify(Bool, 'RM_PMI', R), + post(NA, Space-Map, R). +'#\\'(A) :- + get_home(Space-Map), + check(A, NA), + B := boolvar(Space), + Space += reify(B, 'RM_EQV', R), + Space += rel(B, 'BOT_EQV', 0), + post(NA, Space-Map, R). +( A1 #\/ A2 ) :- + get_home(Space-Map), + check(A1, NA1), + check(A2, NA2), + B1 := boolvar(Space), + B2 := boolvar(Space), + Space += reify(B1, 'RM_EQV', R1), + Space += reify(B2, 'RM_EQV', R2), + post(NA1, Space-Map, R1), + post(NA2, Space-Map, R2), + Space += rel(B1, B2, 'BOT_OR', 1). +( A1 #/\ A2 ) :- + get_home(Space-Map), + check(A1, NA1), + check(A2, NA2), + B1 := boolvar(Space), + B2 := boolvar(Space), + Space += reify(B1, 'RM_EQV', R1), + Space += reify(B2, 'RM_EQV', R2), + post(NA1, Space-Map, R1), + post(NA2, Space-Map, R2), + Space += rel(B1, B2, 'BOT_AND', 1). +( X in A..B) :- + get_home(Space-Map), + check(A, NA), + check(B, NB), + m(X, NX, NA, NB, Map), + NX := intvar(Space, NA, NB). +( Xs ins A..B) :- + get_home(Space-Map), + check(A, NA), + check(B, NB), + maplist(lm(NA, NB, Map), Xs, NXs), + length(Xs, N), + NXs := intvars(Space, N, NA, NB). +boolvar( X ) :- + get_home(Space-Map), + m(X, NX, 0, 1, Map), + NX := boolvar( Space ). +boolvars( Xs ) :- + get_home(Space-Map), + maplist(lm(0, 1, Map), Xs, NXs), + length(Xs, N), + NXs := boolvars( Space, N ). + +/** @pred all_different( _Vs_ ) + Verifies whether all elements of a list are different. +*/ +all_different( Xs ) :- + get_home(Env), + check(Xs, NXs), + post( all_different( NXs ), Env, _ ). + +all_distinct( Xs ) :- + get_home(Env), + check(Xs, NXs), + post( all_distinct( NXs ), Env, _ ). +all_distinct( Cs, Xs ) :- + get_home(Env), + check(Xs, NXs), + post( all_distinct( Cs, NXs ), Env, _ ). +scalar_product( Cs, Vs, Rels, X ) :- + get_home(Env), + check(Vs, NVs), + post( scalar_product( Cs, NVs, Rels, X ), Env, _ ). +lex_chain( Cs ) :- + get_home(Env), + check(Cs, NCs), + post( rel( NCs, '#=<' ), Env, _ ). +minimum( V, Xs ) :- + get_home(Env), + check(Xs, NXs), + check(V, NV), + post( rel( min(NXs), (#=), NV ), Env, _ ). +min( Xs, V ) :- + get_home(Env), + check(Xs, NXs), + check(V, NV), + post( rel( min(NXs), (#=), NV ), Env, _ ). +maximum( V, Xs ) :- + get_home(Env), + check(Xs, NXs), + check(V, NV), + post( rel( max(NXs), (#=), NV ), Env, _ ). +max( Xs, V ) :- + get_home(Env), + check(Xs, NXs), + check(V, NV), + post( rel( max(NXs), (#=), NV ), Env, _ ). +element( V, Xs ) :- + get_home(Env), + check(Xs, NXs), + check(V, NV), + post( element( NV, NXs ), Env, _ ). +in_relation( Xs, Rel ) :- + get_home(Env), + check(Xs, NXs), + post(in_tupleset(NXs, Rel), Env, _ ). +in_dfa( Xs, Rel ) :- + get_home(Env), + check(Xs, NXs), + post(in_dfa(NXs, Rel), Env, _ ). +in_dfa( Xs, S0, Ts, Fs ) :- + get_home(Env), + check(Xs, NXs), + post(in_dfa(NXs, S0, Ts, Fs), Env, _ ). +clause( and, Ps, Ns, V ) :- + get_home(Env), + check(Ps, NPs), + check(Ns, NNs), + check(V, NV), + post(clause( 'BOT_AND', NPs, NNs, NV), Env, _ ). +clause( or, Ps, Ns, V ) :- + get_home(Env), + check(Ps, NPs), + check(Ns, NNs), + check(V, NV), + post(clause( 'BOT_OR', NPs, NNs, NV), Env, _ ). + +labeling(Opts, Xs) :- + get_home(Space-Map), + foldl2( processs_lab_opt, Opts, 'INT_VAR_SIZE_MIN', BranchVar, 'INT_VAL_MIN', BranchVal), + term_variables(Xs, Vs), + check( Vs, X1s ), + ( X1s == [] -> true ; + maplist(ll(Map), X1s, NXs), + Space += branch(NXs, BranchVar, BranchVal) ). + +processs_lab_opt(leftmost, _, 'INT_VAR_NONE', BranchVal, BranchVal). +processs_lab_opt(min, _, 'INT_VAR_SIZE_MIN', BranchVal, BranchVal). +processs_lab_opt(max, _, 'INT_VAR_SIZE_MAX', BranchVal, BranchVal). +processs_lab_opt(ff, _, 'INT_VAR_DEGREE_MIN', BranchVal, BranchVal). +processs_lab_opt(min_step, BranchVar, BranchVar, _, 'INT_VAL_MIN'). +processs_lab_opt(max_step, BranchVar, BranchVar, _, 'INT_VAL_MIN'). +processs_lab_opt(bisect, BranchVar, BranchVar, _, 'INT_VAL_MED'). +processs_lab_opt(enum, BranchVar, BranchVar, _, 'INT_VALUES_MIN'). + + +maximize(V) :- + get_home(Space-Map), + l(V, I, Map), + Space += maximize(I). + +minimize(V) :- + get_home(Space-Map), + l(V, I, Map), + Space += minimize(I). + +extensional_constraint( Tuples, TupleSet) :- + TupleSet := tupleset( Tuples ). + +dfa( S0, Transitions, Finals, DFA) :- + DFA := dfa( S0, Transitions, Finals ). + + +check(V, NV) :- + ( var(V) -> V = NV ; + number(V) -> V = NV ; + is_list(V) -> maplist(check, V, NV) ; + V = sum(_,_) -> V = NV ; + V = '[]'(Indx, Mat) -> NV <== '[]'(Indx, Mat) ; + V = '$matrix'(_, _, _, _, C) -> C =.. [_|L], maplist(check, L, NV) ; + V = A+B -> check(A,NA), check(B, NB), NV = NB+NA ; + V = A-B -> check(A,NA), check(B, NB), NV = NB-NA ; + arith(V, _) -> V =.. [C|L], maplist(check, L, NL), NV =.. [C|NL] ; + constraint(V) -> V =.. [C|L], maplist(check, L, NL), NV =.. [C|NL] ). + +post( ( A #= B), Env, Reify) :- + post( rel( A, (#=), B), Env, Reify). +post( ( A #\= B), Env, Reify) :- + post( rel( A, (#\=), B), Env, Reify). +post( ( A #> B), Env, Reify) :- + post( rel( A, (#>), B), Env, Reify). +post( ( A #< B), Env, Reify) :- + post( rel( A, (#<), B), Env, Reify). +post( ( A #>= B), Env, Reify) :- + post( rel( A, (#>=), B), Env, Reify). +post( ( A #=< B), Env, Reify) :- + post( rel( A, (#=<), B), Env, Reify). +% [X,Y,Z] #< +post( rel( A, Op), Space-Map, Reify):- + ( var( A ) -> l(A, IA, Map) ; checklist( var, A ) -> maplist(ll(Map), A, IA ) ), + gecode_arith_op( Op, GOP ), + (var(Reify) -> Space += rel(IA, GOP) ; + Space += rel(IA, GOP, Reify) ). + +% X #< Y +% X #< 2 +post( rel( A, Op, B), Space-Map, Reify):- + var(A), + ( var(B) -> l(B, IB, Map) ; integer(B) -> IB = B ), !, + l(A, IA, Map), + gecode_arith_op( Op, GOP ), + (var(Reify) -> Space += rel(IA, GOP, IB) ; + Space += rel(IA, GOP, IB, Reify) ). + +% 2 #\= B -> reverse +post( rel( A, Op, B), Space-Map, Reify) :- + ( var(A) ; integer(A) ), !, + reverse_arith_op( Op, ROp ), + post( rel( B, ROp, A), Space-Map, Reify). + +% A is never unbound + +% [A,B,C,D] #< 3 +post( rel( A, Op, B ), Space-Map, Reify):- + checklist( var, A ), !, + maplist(ll(Map), A, IL ), + ( var(B) -> l(B, IB, Map) ; integer(B) -> IB = B ; equality(B, NB, Space-Map), l(NB, IB, Map) ), !, + gecode_arith_op( Op, GOP ), + (var(Reify) -> Space += rel(IL, GOP) ; + Space += rel(IL, GOP, IB) ). + +% sum([A,B,C]) #= X +post( rel( sum(L), Op, Out), Space-Map, Reify):- !, + checklist( var, L ), !, + maplist(ll(Map), L, IL ), + ( var(Out) -> l(Out, IOut, Map) ; integer(Out) -> IOut = Out ; equality(Out, NOut, Space-Map), l(NOut, IOut, Map) ), + gecode_arith_op( Op, GOP ), + (var(Reify) -> + Space += linear(IL, GOP, IOut); + Space += linear(IL, GOP, IOut, Reify) + ). + +% count([A,B,C], 3) #= X +post( rel( count(X, Y), Op, Out), Space-Map, Reify):- !, + ( checklist( var, X ) -> maplist(ll(Map), X, IX ) ), + ( var(Y) -> l(Y, IY, Map) ; integer(Y) -> IY = Y ; equality(Y, NY, Space-Map), l(NY, IY, Map) ), + ( var(Out) -> l(Out, IOut, Map) ; integer(Out) -> IOut = Out ; equality(Out, NOut, Space-Map), l(NOut, IOut, Map) ), !, + gecode_arith_op( Op, GOP ), + (var(Reify) -> + Space += count(IX, IY, GOP, IOut); + Space += count(IX, IY, GOP, IOut, Reify) + ). + + +% sum([I in 0..N-1, M[I]]) #= X +post( rel( sum(Foreach, Cond), Op, Out), Space-Map, Reify):- !, + ( var(Out) -> l(Out, IOut, Map) ; integer(Out) -> IOut = Out ; equality(Out, NOut, Space-Map), l(NOut, IOut, Map) ), + cond2list( Foreach, Cond, Cs, L), + maplist(ll(Map), [Out|L], [IOut|IL] ), + gecode_arith_op( Op, GOP ), + (L = [] -> true ; + var(Reify) -> + Space += linear(Cs, IL, GOP, IOut); + Space += linear(Cs, IL, GOP, IOut, Reify) + ). + +post( rel(A1+A2, Op, B), Space-Map, Reify):- + ( nonvar(B) ; B = _ + _ ; B = _-_), !, + linearize(A1+A2, 1, As, Bs, CAs, CBs, 0, A0, Space-Map), + linearize(B, -1, Bs, [], CBs, [], A0, B0, Space-Map), + gecode_arith_op( Op, GOP ), + (var(Reify) -> + ( checklist(is_one, CAs) -> + Space += linear(As, GOP, B0); + Space += linear(CAs, As, GOP, B0) + ) + ; + ( checklist(is_one, CAs) -> + Space += linear(As, GOP, B0, Reify); + Space += linear(CAs, As, GOP, B0, Reify) + ) + ). + +post( rel(A1-A2, Op, B), Space-Map, Reify):- + ( nonvar(B) ; B = _ + _ ; B = _-_), !, + linearize(A1-A2, 1, As, Bs, CAs, CBs, 0, A0, Space-Map), + linearize(B, -1, Bs, [], CBs, [], A0, B0, Space-Map), + gecode_arith_op( Op, GOP ), + (var(Reify) -> + ( checklist(is_one, CAs) -> + Space += linear(As, GOP, B0); + Space += linear(CAs, As, GOP, B0) + ) + ; + ( checklist(is_one, CAs) -> + Space += linear(As, GOP, B0, Reify); + Space += linear(CAs, As, GOP, B0, Reify) + ) + ). + +post( rel(A, Op, B), Space-Map, Reify):- + arith(A, Name), + A =.. [_Op,A1], + is_list(A1), !, + ( _Op = min -> true ; _Op = max ), + maplist(equality_l( Space-Map), A1, NA1), + maplist(in_c_l( Space-Map), NA1, VA1), + equality(B, B1, Space-Map), + out_c(Name, VA1, B1, Op, Space-Map, Reify). + +post( rel(A, Op, B), Space-Map, Reify):- + arith(A, Name), + A =.. [_Op,A1], !, + equality(A1, NA1, Space-Map), + in_c(NA1, VA1, Space-Map), !, + equality(B, B1, Space-Map), + out_c(Name, VA1, B1, Op, Space-Map, Reify). + +post( rel(A, Op, B), Space-Map, Reify):- + arith(A, Name), + A =.. [_Op,A1,A2], !, + equality(A1, NA1, Space-Map), + in_c(NA1, VA1, Space-Map), + equality(A2, NA2, Space-Map), + in_c(NA2, VA2, Space-Map), + equality(B, B1, Space-Map), + out_c(Name, VA1, VA2, B1, Op, Space-Map, Reify). + +post( scalar_product(Cs, L, Op, Out), Space-Map, Reify):- + var(Out), !, + maplist(ll(Map), [Out|L], [IOut|IL] ), + gecode_arith_op( Op, GOP ), + (var(Reify) -> + Space += linear(Cs, IL, GOP, IOut); + Space += linear(Cs, IL, GOP, IOut, Reify) + ). +post( scalar_product(Cs, L, Op, Out), Space-Map, Reify):- + integer(Out), !, + maplist(ll(Map), L, IL ), + gecode_arith_op( Op, GOP ), + (var(Reify) -> + Space += linear(Cs, IL, GOP, Out); + Space += linear(Cs, IL, GOP, Out, Reify) + ). +post( all_different( Xs ), Space-Map, Reify) :- + maplist(ll(Map), Xs, NXs), + (var(Reify) -> + Space += distinct(NXs) + ; + throw(error(domain(not_reifiable),all_different( Xs ))) + ). +post( all_distinct( Xs ), Space-Map, Reify) :- + maplist(ll(Map), Xs, NXs), + (var(Reify) -> + Space += distinct(NXs) + ; + throw(error(domain(not_reifiable),all_distinct( Xs ))) + ). +post( all_distinct( Cs , Xs ), Space-Map, Reify) :- + maplist(ll(Map), Xs, NXs), + (var(Reify) -> + Space += distinct(Cs,NXs) + ; + throw(error(domain(not_reifiable),all_distinct( Cs , Xs ))) + ). +post(in_tupleset(Xs, Tuples), Space-Map, Reify) :- + is_list( Tuples ), !, + TS := tupleset( Tuples ), + maplist(ll(Map), Xs, IXs), + (var(Reify) -> + Space += extensional(IXs, TS) + ; + throw(error(domain(not_reifiable),in_relation(Xs, Tuples))) + ). +post(in_tupleset(Xs, TS), Space-Map, Reify) :- + maplist(ll(Map), Xs, IXs), + (var(Reify) -> + Space += extensional(IXs, TS) + ; + throw(error(domain(not_reifiable),in_relation(Xs, TS))) + ). +post(in_dfa(Xs, S0, Trs, Fs), Space-Map, Reify) :- + TS := dfa( S0, Trs, Fs ), + maplist(ll(Map), Xs, IXs), + (var(Reify) -> + Space += extensional(IXs, TS) + ; + throw(error(domain(not_reifiable),in_dfa(Xs, S0, Trs, Fs))) + ). +post(in_dfa(Xs, TS), Space-Map, Reify) :- + maplist(ll(Map), Xs, IXs), + (var(Reify) -> + Space += extensional(IXs, TS) + ; + throw(error(domain(not_reifiable),in_dfa(Xs, TS))) + ). + +post(element(V, Xs), Space-Map, Reify) :- + l(V, IV, Map), + maplist(ll(Map), Xs, IXs), + (var(Reify) -> + Space += element(IV, IXs) + ; + Space += element(IV, IXs, Reify) + ). + +post(clause( Type, Ps, Ns, V), Space-Map, Reify) :- + (integer(V) -> V = IV ; l(V, IV, Map) ), + maplist(ll(Map), Ps, IPs), + maplist(ll(Map), Ns, INs), + (var(Reify) -> + Space += clause(Type, IPs, INs, IV) + ; + Space += clause(Type, IPs, INs, IV, Reify) + ). + +gecode_arith_op( (#=) , 'IRT_EQ' ). +gecode_arith_op( (#\=) , 'IRT_NQ' ). +gecode_arith_op( (#>) , 'IRT_GR' ). +gecode_arith_op( (#>=) , 'IRT_GQ' ). +gecode_arith_op( (#<) , 'IRT_LE' ). +gecode_arith_op( (#=<) , 'IRT_LQ' ). + +reverse_arith_op( (#=) , (#=) ). +reverse_arith_op( (#\=) , (#\=) ). +reverse_arith_op( (#>) , (#<) ). +reverse_arith_op( (#>=) , (#=<) ). +reverse_arith_op( (#<) , (#>) ). +reverse_arith_op( (#=<) , (#>=) ). + +linearize(V, C, [A|As], As, [C|CAs], CAs, I, I, _-Map) :- + var(V), !, + l(V, A, Map). +linearize(A+B, C, As, Bs, CAs, CBs, I, IF, Env) :- + linearize(A, C, As, A1s, CAs, CA1s, I, I1, Env), + linearize(B, C, A1s, Bs, CA1s, CBs, I1, IF, Env). +linearize(A-B, C, As, Bs, CAs, CBs, I, IF, Env) :- + NC is -C, + linearize(A, C, As, A1s, CAs, CA1s, I, I1, Env), + linearize(B, NC, A1s, Bs, CA1s, CBs, I1, IF, Env). +linearize(A, C, As, As, CAs, CAs, I, IF, _) :- + integer(A), !, + IF is I-C*A. +linearize(A, C, As, As, CAs, CAs, I, IF, _) :- + ground(A), + catch( (B is eval(A)), _, fail ), !, + IF is I-C*B. +linearize(C1*B, C, As, Bs, CAs, CBs, I, IF, Env) :- + integer(C1), !, + NC is C*C1, + linearize(B, NC, As, Bs, CAs, CBs, I, IF, Env). +linearize(B*C1, C, As, Bs, CAs, CBs, I, IF, Env) :- + integer(C1), !, + NC is C*C1, + linearize(B, NC, As, Bs, CAs, CBs, I, IF, Env). +linearize(AC, C, [A|Bs], Bs, [C|CBs], CBs, I, I, Env) :- + arith(AC, _), + equality(AC, V, Env), + Env = _-Map, + l(V, A, Map). + +arith('/\\'(_,_), (/\)). +arith('\\/'(_,_), (\/)). +arith('=>'(_,_), (=>)). +arith('<=>'(_,_), (<=>)). +arith(xor(_,_), xor). +arith(abs(_), abs). +arith(min(_), min). +arith(max(_), max). +arith(min(_,_), min). +arith(max(_,_), max). +arith((_ * _), times). +arith((_ / _), div). +arith(sum(_), sum). +arith(sum(_,_), sum). +arith(count(_,_), count). + +% replace abs(min(A,B)-max(A,B)) by +% min(A,B,A1), max(A,B,A2), linear([1,-1],[A1,B1],=,A3), abs(A3,AN) +equality(V, V, _Env) :- + var( V ), !. +equality(V, V, _Env) :- + integer( V ), !. +equality(abs(V), NV, Env) :- + equality(V, VA, Env), + new_arith(abs, VA, NV, Env). +equality(min(V), NV, Env) :- + maplist( equality_l(Env), V, VA ), + new_arith(min, VA, NV, Env). +equality(max(V), NV, Env) :- + maplist( equality_l(Env), V, VA ), + new_arith(max, VA, NV, Env). +equality(V1+V2, NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( plus, V1A, V2A, NV, Env). +equality(V1-V2, NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( minus, V1A, V2A, NV, Env). +equality(V1*V2, NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( times, V1A, V2A, NV, Env). +equality(V1/V2, NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( div, V1A, V2A, NV, Env). +equality(V1 mod V2, NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (mod), V1A, V2A, NV, Env). +equality(max( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (max), V1A, V2A, NV, Env). +equality(min( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (min), V1A, V2A, NV, Env). +equality(sum( V ), NV, Env) :- + maplist( equality_l(Env), V, VA ), + new_arith(sum, VA, NV, Env). +equality(sum( C, G ), NV, Env) :- + new_arith(sum, C, G, NV, Env). +equality('/\\'( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (/\), V1A, V2A, NV, Env). +equality('\\/'( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (\/), V1A, V2A, NV, Env). +equality('<=>'( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (<=>), V1A, V2A, NV, Env). +equality('=>'( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (=>), V1A, V2A, NV, Env). +equality('xor'( V1 , V2), NV, Env) :- + equality(V1, V1A, Env), + equality(V2, V2A, Env), + new_arith( (xor), V1A, V2A, NV, Env). + +equality_l(Env, V0, V) :- + equality(V0, V, Env). + +% abs(X) #= 3 +out_c(Name, A1, B, Op, Space-Map, Reify) :- + integer(B), !, + new_arith( Name, A1, NB, Space-Map), + gecode_arith_op( Op, BOP ), + l(NB, IB, Map), + ( var(Reify) -> + Space += rel(IB, BOP, B) + ; + Space += rel(IB, BOP, B, Reify) + ). +% abs(X) #= Cin[..] +out_c(Name, A1, B, (#=), Space-Map, Reify) :- + var(Reify), + l(B, IB, Map), !, + l(A1, IA1, Map), + G =.. [Name, IA1, IB], + Space += G. +% abs(X) #= NEW +out_c(Name, A1, B, (#=), Space-Map, Reify) :- + var(Reify), !, + new_arith( Name, A1, B, Space-Map). +% abs(X) #> NEW +out_c(Name, A1, B, Op, Space-Map, Reify) :- + l(B, IB0, Map), !, + new_arith( Name, A1, NB, Space-Map), + l(NB, IB, Map), + gecode_arith_op( Op, BOP ), + ( + nonvar(Reify) -> + Space += rel(IB, BOP, IB0) + ; + Space += rel(IB, BOP, IB0, Reify) + ). + +% X*Y #= 3 +out_c(Name, A1, A2, B, Op, Space-Map, Reify) :- + integer(B), !, + new_arith( Name, A1, A2, NB, Space-Map), + l(NB, IB, Map), + gecode_arith_op( Op, BOP ), + ( var(Reify) -> + Space += rel(IB, BOP, B) + ; + Space += rel(IB, BOP, B, Reify) + ). +% X*Y #= Cin[..] +out_c(Name, A1, A2, B, (#=), Space-Map, Reify) :- + var(Reify), + l(B, IB, Map), !, + l(A1, IA1, Map), + l(A2, IA2, Map), + G =.. [Name, IA1, IA2, IB], + Space += G. +% abs(X) #= NEW, cannot be reified +out_c(Name, A1, A2, B, (#=), Space-Map, Reify) :- + var(Reify), !, + new_arith( Name, A1, A2, B, Space-Map). +% min(X,Y) #= Cin[..] <=> +out_c(Name, A1, A2, B, Op, Space-Map, Reify) :- + l(B, IB0, Map), !, + new_arith( Name, A1, A2, NB, Space-Map), + l(NB, IB, Map), + gecode_arith_op( Op, BOP ), + ( var(Reify) -> + Space += rel(IB, BOP, IB0) + ; + Space += rel(IB, BOP, IB0, Reify) + ). + +new_arith( abs, V, NV, Space-Map) :- + l(V, X, Min0, Max0, Map), + ( Min0 < 0 -> + ( Max0 < 0 -> Min is -Max0, Max is -Min0 ; + Min = 0 , Max is max( -Min0, Max0 ) ) + ; + Min = Min0, Max = Max0 + ), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += abs(X, NX). + +new_arith( min, V, NV, Space-Map) :- + V = [V1|RV], + l(V1, _X1, Min0, Max0, Map), + foldl2( min_l(Map), RV, Max0, Max, Min0, Min), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + maplist(ll(Map), V, X), + Space += min(X, NX). + +new_arith( max, V, NV, Space-Map) :- + V = [V1|RV], + l(V1, _X1, Min0, Max0, Map), + foldl2( max_l(Map), RV, Max0, Max, Min0, Min), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + maplist(ll(Map), V, X), + Space += min(X, NX). + +new_arith( sum, V, NV, Space-Map) :- + foldl2( sum_l(Map), V, 0, Max, 0, Min), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + maplist(ll(Map), V, X), + Space += linear(X, 'IRT_EQ', NX). + +new_arith( minus, V1, V2, NV, Space-Map) :- + l(V1, X1, Min1, Max1, Map), + l(V2, X2, Min2, Max2, Map), + Min is Min1-Max2, + Max is Max1-Min2, + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += linear([1,-1], [X1,X2], 'IRT_EQ', NX). + +new_arith( plus, V1, V2, NV, Space-Map) :- + l(V1, X1, Min1, Max1, Map), + l(V2, X2, Min2, Max2, Map), + Min is Min1+Min2, + Max is Max1+Max2, + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += linear([1,1], [X1,X2], 'IRT_EQ', NX). + +new_arith( min, V1, V2, NV, Space-Map) :- + l(V1, X1, Min1, Max1, Map), + l(V2, X2, Min2, Max2, Map), + Min is min(Min1,Min2), + Max is min(Max1,Max2), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += min(X1, X2, NX). + +new_arith( max, V1, V2, NV, Space-Map) :- + l(V1, X1, Min1, Max1, Map), + l(V2, X2, Min2, Max2, Map), + Min is max(Min1,Min2), + Max is max(Max1,Max2), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += max(X1, X2, NX). + +new_arith( times, V1, V2, NV, Space-Map) :- + l(V1, X1, Min1, Max1, Map), + l(V2, X2, Min2, Max2, Map), + min_times(Min1,Min2,Max1,Max2,Min), + max_times(Min1,Min2,Max1,Max2,Max), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += times(X1, X2, NX). + +new_arith( (div), V1, V2, NV, Space-Map) :- + l(V1, X1, Min1, Max1, Map), + l(V2, X2, Min2, Max2, Map), + min_div(Min1,Min2,Max1,Max2,Min), + max_div(Min1,Min2,Max1,Max2,Max), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += div(X1, X2, NX). + +new_arith( (mod), V1, V2, NV, Space-Map) :- + l(V1, X1, _Min1, Max1, Map), + l(V2, X2, _Min2, Max2, Map), + Min is 0, + Max is min(abs(Max1), Max2-1), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + Space += mod(X1, X2, NX). + +new_arith( sum, Foreach, Cond, NV, Space-Map) :- + cond2list( Foreach, Cond, Cs, V), + foldl2( sum_l(Map), V, 0, Max, 0, Min), + NX := intvar(Space, Min, Max), + m(NV, NX, Min, Max, Map), + maplist(ll(Map), V, X), + Space += linear(Cs, X, 'IRT_EQ', NX). + +new_arith( (/\), V1, V2, NV, Space-Map) :- + l(V1, X1, Map), + l(V2, X2, Map), + NX := boolvar(Space), + m(NV, NX, 0, 1, Map), + Space += rel(X1, 'BOT_AND', X2, NX). + +new_arith( (\/), V1, V2, NV, Space-Map) :- + l(V1, X1, Map), + l(V2, X2, Map), + NX := boolvar(Space), + m(NV, NX, 0, 1, Map), + Space += rel(X1, 'BOT_OR', X2, NX). + +new_arith( (=>), V1, V2, NV, Space-Map) :- + l(V1, X1, Map), + l(V2, X2, Map), + NX := boolvar(Space), + m(NV, NX, 0, 1, Map), + Space += rel(X1, 'BOT_IMP', X2, NX). + + +new_arith( (<=>), V1, V2, NV, Space-Map) :- + l(V1, X1, Map), + l(V2, X2, Map), + NX := boolvar(Space), + m(NV, NX, 0, 1, Map), + Space += rel(X1, 'BOT_EQV', X2, NX). + +new_arith( xor, V1, V2, NV, Space-Map) :- + l(V1, X1, Map), + l(V2, X2, Map), + NX := boolvar(Space), + m(NV, NX, 0, 1, Map), + Space += rel(X1, 'BOT_XOR', X2, NX). + + + +min_times(Min1,Min2,Max1,Max2,Min) :- + Min is min(Min1*Min2, min(Min1*Max2, min(Max1*Min2, Max1*Max2))). + +max_times(Min1,Min2,Max1,Max2,Max) :- + Max is max(Min1*Min2, max(Min1*Max2, max(Max1*Min2, Max1*Max2))). + +min_div(Min1,Min20,Max1,Max20,Min) :- + ( Min20 == 0 -> Min2 = 1 ; Min2 = Min20), + ( Max20 == 0 -> Max2 = -1; Max2 = Max20), + Min is min(Min1 div Min2, min(Min1 div Max2, min(Max1 div Min2, Max1 div Max2))). + +max_div(Min1,Min20,Max1,Max20,Max) :- + ( Min20 == 0 -> Min2 = 1 ; Min2 = Min20), + ( Max20 == 0 -> Max2 = -1; Max2 = Max20), + Max is max(Min1 div Min2, max(Min1 div Max2, max(Max1 div Min2, Max1 div Max2))). + +min_l(Map, V, Min0, Min, Max0, Max) :- + l(V, _, Min1, Max1, Map), + Min is min(Min0, Min1), + Max is min(Max0, Max1). + +max_l(Map, V, Min0, Min, Max0, Max) :- + l(V, _, Min1, Max1, Map), + Min is max(Min0, Min1), + Max is max(Max0, Max1). + +sum_l(Map, V, Min0, Min, Max0, Max) :- + l(V, _, Min1, Max1, Map), + Min is Min0 + Min1, + Max is Max0 + Max1. + + +in_c(A, A, _y) :- + var(A), !. +in_c(C, A, Space-Map) :- + integer(C), + Min is C-1, + NX := intvar(Space, Min, C), + m(A, NX, Min, C, Map), + Space += rel(NX, 'IRT_EQ', C). + +in_c_l(Env, V, IV) :- + in_c(V, IV, Env). + +user:term_expansion( ( H :- B), (H :- (gecode_clpfd:init_gecode(Space, Me), NB, gecode_clpfd:close_gecode(Space, Vs, Me)) ) ) :- + process_constraints(B, NB, Env), + term_variables(H, Vs), + nonvar( Env ), !, + Env = env( Space ). + +init_gecode(Space, old) :- + nb_current(gecode_space, Space), nonvar(Space), !. +init_gecode(Space-Map, new) :- + Space := space, + b_setval(gecode_done, false), + b_setval(gecode_space, Space-Map). + +close_gecode(_Space, _Vs, old) :- !. +close_gecode(Space-Map, Vs0, new) :- + term_variables(Vs0, Vs), + selectlist(intvar(Map), Vs, CVs), + maplist(ll(Map), CVs, IVs), + SolSpace := search(Space), + b_setval(gecode_done, true), + CVs := val(SolSpace,IVs). + +intvar(Map, V) :- + l(V, _IV, Map). + +get_home(Home) :- + b_getval(gecode_space, Home). + +cond2list((List where Goal), El, Cs, Vs) :- !, + foreach( List, add_el(Goal, El), ([])-([]), Cs-Vs ). +cond2list(List, El, Cs, Vs) :- !, + foreach( List, add_el(true, El), ([])-([]), Cs-Vs ). + +add_el(G0, El, Cs-Vs, [C|Cs]-[V|Vs]) :- + call(G0), !, + E <== El, + ( var(E) -> C = 1, E = V ; E = C*V, integer(C), var(V) -> true ; E = V*C, integer(C), var(V) ). +add_el(_G0, _El, Cs-Vs, Cs-Vs). + +% An attributed variable with attribute value Domain has been +% assigned the value Y + +attr_unify_hook(_, _) :- + b_getval(gecode_done, true), !. +attr_unify_hook(v(IV1,_,_), Y) :- + ( get_attr(Y, gecode_clpfd, v(IV2,_,_)) + -> + nb_getval(gecode_space, Space-_), + ( IV1 == IV2 -> true ; + Space += rel(IV1, 'IRT_EQ', IV2) ) + ; var(Y) + -> true + ; integer(Y) -> + nb_getval(gecode_space, Space-_), + Space += rel(IV1, 'IRT_EQ', Y) + ). + +% Translate attributes from this module to residual goals + +attribute_goals(X) --> + { get_attr(X, gecode_clpfd, v(_,A,B)) }, + [X in A..B]. + +m(X, Y, A, B, _Map) :- + put_attr(X, gecode_clpfd, v(Y, A, B)). +/* +m(NV, OV, NA, NB, Vs) :- + var(Vs), !, + Vs = [v(NV,OV,NA,NB)|_]. +m(NV, OV, NA, NB, [_|Vs]) :- + m(NV, OV, NA, NB, Vs). +*/ + +lm(A, B, Map, X, Y) :- + m(X, Y, A, B, Map). + +l(V, IV, _) :- + get_attr(V, gecode_clpfd, v(IV, _, _)). +/* +l(_NV, _OV, Vs) :- + var(Vs), !, + fail. +l(NV, OV, [v(V, OV, _A, _B)|_Vs]) :- + V == NV, !. +l(NV, OV, [_|Vs]) :- + l(NV, OV, Vs). +*/ + +ll(Map, X, Y) :- + l(X, Y, Map). + +l(V, IV, A, B, _) :- + get_attr(V, gecode_clpfd, v(IV, A, B)). + +/* +l(_NV, _OV, _, _, Vs) :- + var(Vs), !, + fail. +l(NV, OV, A, B, [v(V, OV, A, B)|_Vs]) :- + V == NV, !. +l(NV, OV, A, B, [_|Vs]) :- + l(NV, OV, A, B, Vs). +*/ + +is_one(1). + +/** +@} +*/ diff --git a/packages/cplint/CMakeLists.txt b/packages/cplint/CMakeLists.txt index 83b8353a6..a28e64f24 100644 --- a/packages/cplint/CMakeLists.txt +++ b/packages/cplint/CMakeLists.txt @@ -147,7 +147,8 @@ IF (CUDD_FOUND) ) install(TARGETS bddem - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) @@ -169,7 +170,8 @@ IF (CUDD_FOUND) add_subDIRECTORY ( approx/simplecuddLPADs ) install(TARGETS cplint - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/cuda/CMakeLists.txt b/packages/cuda/CMakeLists.txt index 8326d84b5..816f1e2b8 100644 --- a/packages/cuda/CMakeLists.txt +++ b/packages/cuda/CMakeLists.txt @@ -106,7 +106,7 @@ endif( THRUST_INCLUDE_DIR ) ) install(TARGETS libcuda - LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/examples/photo.yap b/packages/examples/photo.yap new file mode 100644 index 000000000..da33819b9 --- /dev/null +++ b/packages/examples/photo.yap @@ -0,0 +1,80 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011 by Denys Duchier +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +:- use_module(library(gecode)). +:- use_module(library(maplist)). + +% 5 people want to have a photograph together, but they have preferences. +photo(Ex, Solution,Amount) :- + db(Ex, People, Preferences), + Space := space, + length(People, Len), + Len0 is Len-1, + People := intvars(Space,Len,0,Len0), + Space += distinct(People), + % Bools are the satisfied constraints + maplist(preferences(Space, Len), Preferences, Bools), + length(Preferences, PLen), + Sum := intvar(Space,0,PLen), + Space += linear(Bools,'IRT_EQ',Sum), + % add all satisfied constraints + Space += maximize(Sum), + Space += branch(People,'INT_VAR_SIZE_MIN','INT_VAL_MIN'), + SolSpace := search(Space), + Solution := val(SolSpace,People), + Amount := val(SolSpace,Sum). + +%reification, use with care +preferences(Space, Len, X-Y, B) :- + NLen is -Len, + I0 := intvar(Space, NLen, Len), + I := intvar(Space, 0, Len), + B := boolvar(Space), + Space += reify(B, 'RM_EQV', R), + Space += linear([1,-1],[X,Y],'IRT_EQ', I0), + Space += abs(I0, I), + Space += rel(I, 'IRT_EQ', 1, R). + + +db(s,[Alice,Bob,Carl,Deb,Evan], [Alice-Carl, + Carl-Deb, + Deb-Alice, + Evan-Alice, + Bob-Evan, + Carl-Evan, + Deb-Evan, + Evan-Bob]). + +db(l,[Betty,Chris,Donald,Fred,Gary,Mary,Paul,Peter,Susan], + [Betty-Donald, + Betty-Gary, + Betty-Peter, + Chris-Gary, + Chris-Susan, + Donald-Fred, + Donald-Gary, + Fred-Betty, + Fred-Gary, + Gary-Mary, + Gary-Betty, + Mary-Betty, + Mary-Susan, + Paul-Donald, + Paul-Peter, + Peter-Susan, + Peter-Paul]). diff --git a/packages/examples/queens.yap b/packages/examples/queens.yap new file mode 100644 index 000000000..3167babbf --- /dev/null +++ b/packages/examples/queens.yap @@ -0,0 +1,67 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011 by Denys Duchier +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +:- use_module(library(gecode)). +:- use_module(library(maplist)). + +% use alldiff constraints +queens(N, Solution) :- + Space := space, + length(Queens, N), + Queens := intvars(Space,N,1,N), + Space += distinct(Queens), + foldl(inc, Queens, Inc, 0, _), + foldl(dec, Queens, Dec, 0, _), + Space += distinct(Inc,Queens), + Space += distinct(Dec,Queens), + Space += branch(Queens, 'INT_VAR_SIZE_MIN', 'INT_VAL_MIN'), + SolSpace := search(Space), + Solution := val(SolSpace,Queens). + +inc(_, I0, I0, I) :- + I is I0+1. + +dec(_, I0, I0, I) :- + I is I0-1. + +% +% Using gecode linear constraints for diagonals. +% +lqueens(N, Solution) :- + Space := space, + length(Queens, N), + Queens := intvars(Space,N,1,N), + Space += distinct(Queens), + lconstrain( Queens, Space, 0), + Space += branch(Queens, 'INT_VAR_SIZE_MIN', 'INT_VAL_MIN'), + SolSpace := search(Space), + Solution := val(SolSpace,Queens). + +lconstrain([], _, _). +lconstrain( [Q|Queens], Space, I0) :- + I is I0+1, + foldl(constrain(Q, I0, Space), Queens, I, _), + lconstrain( Queens, Space, I). + +constrain(Q, I, Space, R, J, J1) :- + % Q+I != R+J, Q-I != R-J <=> Q-R != J-I, Q-R != I-J, + J1 is J+1, + Sum is I-J, + Diff is J-I, + Space += linear([1,-1], [Q,R], 'IRT_NQ', Diff), + Space += linear([1,-1], [Q,R], 'IRT_NQ', Sum). \ No newline at end of file diff --git a/packages/examples/send_more_money.yap b/packages/examples/send_more_money.yap new file mode 100644 index 000000000..cf4d298be --- /dev/null +++ b/packages/examples/send_more_money.yap @@ -0,0 +1,41 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011 by Denys Duchier +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +:- use_module(library(gecode)). + +% S E N D +% + M O R E +% --------- +% M O N E Y +send_more_money(Solution) :- + Space := space, + Letters := intvars(Space,8,0,9), + [S,E,N,D,M,O,R,Y] = Letters, + Space += rel(M,'IRT_NQ',0), + Space += rel(S,'IRT_NQ',0), + Space += distinct(Letters), + C = [1000, 100, 10, 1, + 1000, 100, 10, 1, + -10000, -1000, -100, -10, -1], + X = [S,E,N,D, + M,O,R,E, + M,O,N,E,Y], + Space += linear(C, X, 'IRT_EQ', 0), + Space += branch(Letters, 'INT_VAR_SIZE_MIN', 'INT_VAL_MIN'), + SolSpace := search(Space), + Solution := val(SolSpace,Letters). diff --git a/packages/examples/send_most_money.yap b/packages/examples/send_most_money.yap new file mode 100644 index 000000000..ad37eec96 --- /dev/null +++ b/packages/examples/send_most_money.yap @@ -0,0 +1,45 @@ +%% -*- prolog -*- +%%============================================================================= +%% Copyright (C) 2011 by Denys Duchier +%% +%% This program is free software: you can redistribute it and/or modify it +%% under the terms of the GNU Lesser General Public License as published by the +%% Free Software Foundation, either version 3 of the License, or (at your +%% option) any later version. +%% +%% This program is distributed in the hope that it will be useful, but WITHOUT +%% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +%% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for +%% more details. +%% +%% You should have received a copy of the GNU Lesser General Public License +%% along with this program. If not, see . +%%============================================================================= + +:- use_module(library(gecode)). + +% S E N D +% + M O S T +% --------- +% M O N E Y +send_most_money(Solution,Amount) :- + Space := space, + Letters := intvars(Space,8,0,9), + [S,E,N,D,M,O,T,Y] = Letters, + Space += rel(M,'IRT_NQ',0), + Space += rel(S,'IRT_NQ',0), + Space += distinct(Letters), + C = [1000, 100, 10, 1, + 1000, 100, 10, 1, + -10000, -1000, -100, -10, -1], + X = [S,E,N,D, + M,O,S,T, + M,O,N,E,Y], + Space += linear(C, X, 'IRT_EQ', 0), + Money := intvar(Space,0,99999), + Space += linear([10000,1000,100,10,1],[M,O,N,E,Y],'IRT_EQ',Money), + Space += maximize(Money), + Space += branch(Letters,'INT_VAR_SIZE_MIN','INT_VAL_MIN'), + SolSpace := search(Space), + Solution := val(SolSpace,Letters), + Amount := val(SolSpace,Money). diff --git a/packages/gecode/CMakeLists.txt b/packages/gecode/CMakeLists.txt index c6edf765e..a35a1a0f5 100644 --- a/packages/gecode/CMakeLists.txt +++ b/packages/gecode/CMakeLists.txt @@ -45,7 +45,8 @@ if (GECODE_FOUND) include_directories (${GECODE_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/${GECODE_VERSION}) install(TARGETS gecode_yap - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/jpl/src/c/CMakeLists.txt b/packages/jpl/src/c/CMakeLists.txt index 3cdaa7e35..826dc9171 100644 --- a/packages/jpl/src/c/CMakeLists.txt +++ b/packages/jpl/src/c/CMakeLists.txt @@ -11,7 +11,8 @@ include_directories (${JAVA_INCLUDE_DIRS} ${JNI_INCLUDE_DIRS} ) # set(YAP_SYSTEM_OPTIONS "jpl " ${YAP_SYSTEM_OPTIONS} PARENT_SCOPE) install(TARGETS jplYap - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/jpl/src/c/jpl.c b/packages/jpl/src/c/jpl.c index 64c1832a6..2a1bbc939 100755 --- a/packages/jpl/src/c/jpl.c +++ b/packages/jpl/src/c/jpl.c @@ -770,15 +770,8 @@ jni_tag_to_iref( } -#if SIZEOF_LONG == SIZEOF_VOIDP -#define IREF_FMT "J#%020lu" -#define IREF_INTTYPE unsigned long -#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP -#define IREF_FMT "J#%020llu" -#define IREF_INTTYPE unsigned long long -#else -#error "Cannot determine format for irefs" -#endif +#define IREF_FMT "J#%020%" UXInt_F +#define IREF_INTTYPE uintptr_t static bool jni_iref_to_tag( @@ -4556,7 +4549,7 @@ JNIEXPORT jobject JNICALL term_t term; jobject term_t; /* return value */ - JPL_DEBUG(1, Sdprintf( ">exception(jqid=%lu)\n", (long)jqid)); + JPL_DEBUG(1, Sdprintf( ">exception(jqid=%p)\n", jqid)); return ( jpl_ensure_pvm_init(env) && ( JPL_DEBUG(1, Sdprintf( " ok: jpl_ensure_pvm_init(env)\n")), TRUE ) /* && jqid != NULL // redundant */ @@ -4570,7 +4563,7 @@ JNIEXPORT jobject JNICALL && setTermTValue(env,term_t,term) && ( JPL_DEBUG(1, Sdprintf( " ok: setTermTValue(env,term_t,term)\n")), TRUE ) ? ( - JPL_DEBUG(1, Sdprintf(" =%lu\n",(long)term_t)), + JPL_DEBUG(1, Sdprintf(" =%p\n",term_t)), term_t ) : NULL /* oughta diagnose failure? */ @@ -4878,7 +4871,7 @@ JNIEXPORT jobject JNICALL jobject rval; term_t trefs; - JPL_DEBUG(1, Sdprintf( ">new_term_refs(env=%lu,jProlog=%lu,jn=%lu)...\n", (long)env, (long)jProlog, (long)jn)); + JPL_DEBUG(1, Sdprintf( ">new_term_refs(env=%p,jProlog=%p,jn=%p)...\n", env, jProlog, (long)jn)); return ( jpl_ensure_pvm_init(env) && jn >= 0 /* I hope PL_new_term_refs(0) is defined [ISSUE] */ @@ -5265,7 +5258,7 @@ JNIEXPORT void JNICALL { atom_t atom; - JPL_DEBUG(1, Sdprintf( "unregister_atom(env=%lu,jProlog=%lu,jatom=%lu)...\n", (long)env, (long)jProlog, (long)jatom)); + JPL_DEBUG(1, Sdprintf( "unregister_atom(env=%p,jProlog=%p,jatom=%p)...\n", env, jProlog, jatom)); if ( jpl_ensure_pvm_init(env) && getAtomTValue(env,jatom,&atom) /* checks that jatom isn't null */ diff --git a/packages/myddas/CMakeLists.txt b/packages/myddas/CMakeLists.txt index cff032477..686710a39 100644 --- a/packages/myddas/CMakeLists.txt +++ b/packages/myddas/CMakeLists.txt @@ -48,6 +48,10 @@ add_component(myddas ${MYDDAS_HEADERS} ) +SET_PROPERTY(SOURCE ${MYDDAS_SOURCES} + ${MYDDAS_UTIL_SOURCES} + ${MYDDAS_HEADERS} PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 ) + MY_add_dependencies(myddas plmyddas) add_subdirectory(pl) diff --git a/packages/myddas/mysql/CMakeLists.txt b/packages/myddas/mysql/CMakeLists.txt index 37035695c..224fca758 100644 --- a/packages/myddas/mysql/CMakeLists.txt +++ b/packages/myddas/mysql/CMakeLists.txt @@ -29,8 +29,9 @@ add_library(Yapmysql SHARED ${MYSQL_SOURCES}) target_link_libraries(Yapmysql ${MYSQL_LIBRARIES} libYap) install(TARGETS Yapmysql - LIBRARY DESTINATION ${dlls} - ARCHIVE DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} + ARCHIVE DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} ) endif() include_directories(${MYSQL_INCLUDE_DIR} ..) diff --git a/packages/myddas/odbc/CMakeLists.txt b/packages/myddas/odbc/CMakeLists.txt index a43ec138b..78be97d4a 100644 --- a/packages/myddas/odbc/CMakeLists.txt +++ b/packages/myddas/odbc/CMakeLists.txt @@ -33,7 +33,8 @@ set_target_properties (Yapodbc PROPERTIES install(TARGETS Yapodbc - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/myddas/postgres/CMakeLists.txt b/packages/myddas/postgres/CMakeLists.txt index 298d0c380..c86285032 100644 --- a/packages/myddas/postgres/CMakeLists.txt +++ b/packages/myddas/postgres/CMakeLists.txt @@ -32,7 +32,8 @@ set_property(GLOBAL APPEND PROPERTY COMPILE_DEFINITIONS -DMYDDAS_POSTGRES=1) install(TARGETS Yappostgres - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) endif (PostgreSQL_FOUND) diff --git a/packages/myddas/postgres/myddas_postgres.c b/packages/myddas/postgres/myddas_postgres.c index bb091cab5..dc4c60dec 100644 --- a/packages/myddas/postgres/myddas_postgres.c +++ b/packages/myddas/postgres/myddas_postgres.c @@ -109,7 +109,7 @@ #include "Yatom.h" #include "YapText.h" #include "cut_c.h" -#include "eval.h" +#include "YapEval.h" #include "myddas.h" #ifdef MYDDAS_STATS #include "myddas_structs.h" diff --git a/packages/myddas/sqlite3/CMakeLists.txt b/packages/myddas/sqlite3/CMakeLists.txt index d0a632dc4..23c7d46c0 100644 --- a/packages/myddas/sqlite3/CMakeLists.txt +++ b/packages/myddas/sqlite3/CMakeLists.txt @@ -23,6 +23,7 @@ add_definitions(-DSQLITE_ENABLE_RTREE=1 ) add_definitions(-DSQLITE_ENABLE_FTS5=1 ) +SET_PROPERTY(DIRECTORY PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 ) if (ANDROID) diff --git a/packages/myddas/sqlite3/myddas_sqlite3.c b/packages/myddas/sqlite3/myddas_sqlite3.c index 1db67f3c5..d91e72ffc 100644 --- a/packages/myddas/sqlite3/myddas_sqlite3.c +++ b/packages/myddas/sqlite3/myddas_sqlite3.c @@ -25,7 +25,7 @@ #include "Yatom.h" #include "YapText.h" #include "cut_c.h" -#include "eval.h" +#include "YapEval.h" #include "myddas.h" #ifdef MYDDAS_STATS #include "myddas_structs.h" diff --git a/packages/pyswip/pyswip/core.py b/packages/pyswip/pyswip/core.py index 04960e208..854f4a89b 100644 --- a/packages/pyswip/pyswip/core.py +++ b/packages/pyswip/pyswip/core.py @@ -396,7 +396,7 @@ PL_get_atom_ex = _lib.PL_get_atom_ex PL_get_atom_ex.argtypes = [term_t, POINTER(atom_t)] #PL_EXPORT(int) PL_get_atom_chars(term_t t, char **a); -PL_get_atom_chars = _lib.PL_get_atom_chars +PL_get_atom_chars = _lib. PL_get_atom_chars.argtypes = [term_t, POINTER(c_char_p)] PL_get_atom_nchars = _lib.PL_get_atom_nchars diff --git a/packages/python/CMakeLists.txt b/packages/python/CMakeLists.txt index 961946973..893a2dee2 100644 --- a/packages/python/CMakeLists.txt +++ b/packages/python/CMakeLists.txt @@ -1,32 +1,27 @@ -#CHECK: PythonLibs +#CHECK: PythonLibs, changed to work in WIN32 if (PYTHONLIBS_FOUND) -include(FindPythonModule) +include(FindPythonModule) +set (PYTHON_SOURCES + python.c pl2py.c pybips.c py2pl.c pl2pl.c pypreds.c) - include("${CMAKE_SOURCE_DIR}/packages/python/Sources.cmake") +set (PYTHON_HEADERS + python.h) + +set (CMAKE_POSITION_INDEPENDENT_CODE TRUE) add_library (YAPPython SHARED ${PYTHON_SOURCES}) + target_link_libraries(YAPPython libYap ${PYTHON_LIBRARIES} + ${WINDLLS} +${GMP_LIBRARIES}) - target_link_libraries(YAPPython libYap ${PYTHON_LIBRARIES}) - set(SETUP_PY "${CMAKE_CURRENT_BINARY_DIR}/setup.py") +set_property( SOURCE ${PYTHON_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1) -add_custom_target ( YAPex ALL - COMMAND ${PYTHON_EXECUTABLE} setup.py build -f - DEPENDS yapex.py ) - -# set_target_properties (YAPPython PROPERTIES PREFIX "") - - include_directories (${PYTHON_INCLUDE_DIRS}) - - install(TARGETS YAPPython - LIBRARY DESTINATION ${dlls} - ARCHIVE DESTINATION ${dlls} - ) install(FILES python.pl DESTINATION ${libpl} @@ -34,8 +29,10 @@ add_custom_target ( YAPex ALL configure_file ("setup.py.cmake" "setup.py" ) -install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SETUP_PY} install -f - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})") + set(SETUP_PY "${CMAKE_CURRENT_BINARY_DIR}/setup.py") + +#set_target_properties (YAPPython PROPERTIES PREFIX "") + find_python_module( jupyter ) @@ -43,6 +40,11 @@ if (PY_JUPYTER) add_subdirectory(yap_kernel) -endif() +ENDIF() + +install(TARGETS YAPPython + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} + ARCHIVE DESTINATION ${dlls} ) endif (PYTHONLIBS_FOUND) diff --git a/packages/raptor/CMakeLists.txt b/packages/raptor/CMakeLists.txt index 94b7c8574..d628b2237 100644 --- a/packages/raptor/CMakeLists.txt +++ b/packages/raptor/CMakeLists.txt @@ -57,7 +57,8 @@ else (WIN32) endif() install(TARGETS libxml2 - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${libdir} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) endif(WIN32) @@ -113,7 +114,8 @@ IF (RAPTOR_FOUND) set_target_properties (raptor PROPERTIES PREFIX "") install(TARGETS raptor - LIBRARY DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} ) diff --git a/packages/raptor/raptor_yap.c b/packages/raptor/raptor_yap.c index 5460d219f..4ec2d11c3 100644 --- a/packages/raptor/raptor_yap.c +++ b/packages/raptor/raptor_yap.c @@ -28,7 +28,7 @@ #include "raptor2.h" #endif -void raptor_yap_init(void); +X_API void raptor_yap_init(void); raptor_world *world; @@ -58,7 +58,7 @@ static YAP_Atom term_load(const raptor_term *term) { case RAPTOR_TERM_TYPE_UNKNOWN: default: - raptor_log_error_formatted(term->world, RAPTOR_LOG_LEVEL_ERROR, NULL, + raptor_log_error_formatted(term->world, RAPTOR_LOG_LEVEL_ERROR, NULL, "Triple has unsupported term type %d", term->type); break; @@ -159,7 +159,7 @@ static inline void raptor_yap_halt(int exit, void *world) { raptor_free_world((raptor_world *)world); } -void raptor_yap_init(void) { +X_API void raptor_yap_init(void) { world = raptor_new_world(); YAP_HaltRegisterHook(raptor_yap_halt, (void *)world); diff --git a/packages/raptor/xml2_yap.c b/packages/raptor/xml2_yap.c index 5cd22be7f..a7da8e4d3 100644 --- a/packages/raptor/xml2_yap.c +++ b/packages/raptor/xml2_yap.c @@ -28,7 +28,7 @@ #include #include -void libxml2_yap_init (void); +X_API void libxml2_yap_init (void); struct exo_aux { YAP_Functor functor; @@ -159,7 +159,7 @@ load_xml ( void ) extern Int YAP_UserCPredicate(const char *, Int f(void), int arity); -void libxml2_yap_init (void) +X_API void libxml2_yap_init (void) { YAP_UserCPredicate("load_xml", load_xml, 2); YAP_UserCPredicate("load_xml2", load_xml, 2); diff --git a/packages/real/CMakeLists.txt b/packages/real/CMakeLists.txt index 658cf6b5d..f4dbb36ca 100644 --- a/packages/real/CMakeLists.txt +++ b/packages/real/CMakeLists.txt @@ -1,13 +1,20 @@ # PROJECT ( YAP_REAL C ) -macro_optional_find_package (R ON) + +# LIBR_FOUND +# LIBR_HOME +# LIBR_INCLUDE_DIRS +# LIBR_DOC_DIR +# LIBR_LIBRARIES +# +macro_optional_find_package (LibR ON) macro_log_feature (R_FOUND "R" "Use R Environment" "http://www.r.org" FALSE) -if (R_FOUND) +if (LIBR_FOUND) set (REAL_SOURCES real.c @@ -16,37 +23,26 @@ if (R_FOUND) include_directories ( ${CMAKE_CURRENT_BINARY_DIR} - ${R_INCLUDE_DIR} + ${LIBR_INCLUDE_DIRS} ) set (CMAKE_REQUIRED_INCLUDES ${CMAKE_CURRENT_BINARY_DIR} - ${R_INCLUDE_DIR} + ${LIBR_INCLUDE_DIRS} ) - -# The module defines the following variables: -# R_FOUND - System has R -# R_EXECUTABLE - The R interpreter -# R_INCLUDE_DIR - the R include directory -# R_LIBRARIES - The libraries needed to use R -# R_VERSION_STRING - R version - add_library (real SHARED ${REAL_SOURCES}) - target_link_libraries (real ${R_LIBRARIES} ${CMAKE_DL_LIBS} libYap) + target_link_libraries (real ${LIBR_LIBRARIES} ${CMAKE_DL_LIBS} libYap) - set_target_properties (real PROPERTIES PREFIX "") - - check_include_files( R.h HAVE_R_H ) - check_include_files ( "R.h;Rembedded.h" HAVE_R_EMBEDDED_H ) check_include_files( "Rembedded.h;Rinterface.h" HAVE_R_INTERFACE_H ) configure_file ("rconfig.h.cmake" "rconfig.h" ) install(TARGETS real - LIBRARY DESTINATION ${dlls} + RUNTIME DESTINATION ${dlls} ARCHIVE DESTINATION ${dlls} + LIBRARY DESTINATION ${dlls} ) install(FILES real.pl @@ -54,4 +50,4 @@ include_directories ( ) -endif (R_FOUND) +endif (LIBR_FOUND) diff --git a/packages/real/real.c b/packages/real/real.c index a661250af..f0521cbb2 100644 --- a/packages/real/real.c +++ b/packages/real/real.c @@ -12,29 +12,46 @@ #include #define R_SIGNAL_HANDLERS 1 #endif -#include #include +#include #include #include bool R_isNull(SEXP sexp); -#if DEBUG_MEMORY -#define PROTECT_AND_COUNT(EXP) { extern int R_PPStackTop; PROTECT(EXP); nprotect++; printf("%s:%d +%d=%d\n",__FUNCTION__, __LINE__,nprotect ,R_PPStackTop ); } -#define Ureturn { extern int R_PPStackTop; printf("%s:%d -%d=%d\n", __FUNCTION__,__LINE__,nprotect,R_PPStackTop-nprotect); } unprotect(nprotect); return +#if DEBUG_MEMORY +#define PROTECT_AND_COUNT(EXP) \ + { \ + extern int R_PPStackTop; \ + PROTECT(EXP); \ + nprotect++; \ + printf("%s:%d +%d=%d\n", __FUNCTION__, __LINE__, nprotect, R_PPStackTop); \ + } +#define Ureturn \ + { \ + extern int R_PPStackTop; \ + printf("%s:%d -%d=%d\n", __FUNCTION__, __LINE__, nprotect, \ + R_PPStackTop - nprotect); \ + } \ + unprotect(nprotect); \ + return #else -#define PROTECT_AND_COUNT(EXP) { PROTECT(EXP); nprotect++; } -#define Ureturn unprotect(nprotect); return +#define PROTECT_AND_COUNT(EXP) \ + { \ + PROTECT(EXP); \ + nprotect++; \ + } +#define Ureturn \ + unprotect(nprotect); \ + return #endif // #define PL_free(v) -static inline SEXP -protected_tryEval( SEXP expr, SEXP env, int *errp) -{ +static inline SEXP protected_tryEval(SEXP expr, SEXP env, int *errp) { SEXP o; - o = R_tryEval( expr, env, errp); - return o ? o : expr; + o = R_tryEval(expr, env, errp); + return o ? o : expr; } static atom_t ATOM_break; @@ -71,90 +88,78 @@ static functor_t FUNCTOR_tilde1; static functor_t FUNCTOR_tilde2; static functor_t FUNCTOR_while2; +X_API install_t install_real(void); -install_t install_real(void); - -static SEXP term_to_sexp(term_t t, bool eval); +static SEXP term_to_sexp(term_t t, bool eval); static int sexp_to_pl(term_t t, SEXP s); -#define PL_R_BOOL (1) /* const char * */ -#define PL_R_CHARS (2) /* const char * */ -#define PL_R_INTEGER (3) /* int */ -#define PL_R_FLOAT (4) /* double */ -#define PL_R_COMPLEX (5) /* x + yi * */ -#define PL_R_SYMBOL (6) /* A * */ -#define PL_R_CALL (7) /* A(F) * */ -#define PL_R_LISTEL (8) /* X$listEl * */ -#define PL_R_SLOT (9) /* X@slot * */ -#define PL_R_NAME (10) /* name = X, just within a list * */ -#define PL_R_PLUS (11) /* +X * */ -#define PL_R_PSYMBOL (12) /* -X * */ -#define PL_R_ATBOOL (13) /* @X * */ -#define PL_R_VARIABLE (14) /* _ */ -#define PL_R_SUBSET (15) /* [] */ -#define PL_R_DOT (16) /* . */ -#define PL_R_DEFUN (17) /* function(_,_,_) -> ... */ -#define PL_R_QUOTE (18) /* quote(_) */ -#define PL_R_INNER (19) /* %i% */ -#define PL_R_OUTER (20) /* %o% */ -#define PL_R_FORMULA (21) /* At ~ Exp */ -#define PL_R_IF (22) /* if(Cond, Then) */ -#define PL_R_IF_ELSE (23) /* if(Cond, Then, Else) */ -#define PL_R_FOR (26) /* for(I in Cond, Expr) */ -#define PL_R_WHILE (27) /* while(Cond, Expr) */ -#define PL_R_REPEAT (28) /* repeat(Expr) */ -#define PL_R_NEXT (29) /* next */ -#define PL_R_BREAK (30) /* break */ -#define PL_R_IN (31) /* break */ -#define PL_R_RFORMULA (32) /* ~ Exp */ -#define PL_R_EQUAL (33) /* ~ Exp */ -#define PL_R_VECTOR (256) /* [.....] * */ +#define PL_R_BOOL (1) /* const char * */ +#define PL_R_CHARS (2) /* const char * */ +#define PL_R_INTEGER (3) /* int */ +#define PL_R_FLOAT (4) /* double */ +#define PL_R_COMPLEX (5) /* x + yi * */ +#define PL_R_SYMBOL (6) /* A * */ +#define PL_R_CALL (7) /* A(F) * */ +#define PL_R_LISTEL (8) /* X$listEl * */ +#define PL_R_SLOT (9) /* X@slot * */ +#define PL_R_NAME (10) /* name = X, just within a list * */ +#define PL_R_PLUS (11) /* +X * */ +#define PL_R_PSYMBOL (12) /* -X * */ +#define PL_R_ATBOOL (13) /* @X * */ +#define PL_R_VARIABLE (14) /* _ */ +#define PL_R_SUBSET (15) /* [] */ +#define PL_R_DOT (16) /* . */ +#define PL_R_DEFUN (17) /* function(_,_,_) -> ... */ +#define PL_R_QUOTE (18) /* quote(_) */ +#define PL_R_INNER (19) /* %i% */ +#define PL_R_OUTER (20) /* %o% */ +#define PL_R_FORMULA (21) /* At ~ Exp */ +#define PL_R_IF (22) /* if(Cond, Then) */ +#define PL_R_IF_ELSE (23) /* if(Cond, Then, Else) */ +#define PL_R_FOR (26) /* for(I in Cond, Expr) */ +#define PL_R_WHILE (27) /* while(Cond, Expr) */ +#define PL_R_REPEAT (28) /* repeat(Expr) */ +#define PL_R_NEXT (29) /* next */ +#define PL_R_BREAK (30) /* break */ +#define PL_R_IN (31) /* break */ +#define PL_R_RFORMULA (32) /* ~ Exp */ +#define PL_R_EQUAL (33) /* ~ Exp */ +#define PL_R_VECTOR (256) /* [.....] * */ -#define REAL_Error(s, t) REAL_Error__(__LINE__,__FUNCTION__,s,t) +#define REAL_Error(s, t) REAL_Error__(__LINE__, __FUNCTION__, s, t) -static bool -REAL_Error__(int line, const char *function, const char *s, term_t t) -{ - term_t except = PL_new_term_ref(); +static bool REAL_Error__(int line, const char *function, const char *s, + term_t t) { + term_t except = PL_new_term_ref(); - PL_unify_term(except, - PL_FUNCTOR_CHARS, "real_error", 2, - PL_CHARS, s, - PL_TERM, t, - PL_CHARS, function, - PL_INT, line); + PL_unify_term(except, PL_FUNCTOR_CHARS, "real_error", 2, PL_CHARS, s, PL_TERM, + t, PL_CHARS, function, PL_INT, line); - return PL_raise_exception(except); + return PL_raise_exception(except); } #define _PL_get_arg PL_get_arg -#define Sdprintf(S,A1) fprintf(stderr,S,A1) +#define Sdprintf(S, A1) fprintf(stderr, S, A1) -static size_t -pos_dims(size_t R_index[], size_t ndims, size_t dims[]) -{ +static size_t pos_dims(size_t R_index[], size_t ndims, size_t dims[]) { int i, index = 0; - for (i = ndims-1; i>=0; i--) { - index = index*dims[i] + R_index[i]-1; + for (i = ndims - 1; i >= 0; i--) { + index = index * dims[i] + R_index[i] - 1; } return index; } -static void -inc_dims(size_t R_index[], size_t ndims, size_t dims[]) -{ +static void inc_dims(size_t R_index[], size_t ndims, size_t dims[]) { int i; - for (i = ndims-1; i>=0; i--) { + for (i = ndims - 1; i >= 0; i--) { if (++R_index[i] <= dims[i]) return; R_index[i] = 1; } } -static size_t -sexp_rank(SEXP sexp) -{ +static size_t sexp_rank(SEXP sexp) { /* Return the number of dimensions for the buffer * (e.g., a vector will return 1, a matrix 2, ...) */ @@ -165,51 +170,44 @@ sexp_rank(SEXP sexp) return GET_LENGTH(dim); } - /* Copied, with slight mods from rpy2 */ -static int -sexp_shape(SEXP sexp, size_t nd, size_t *shape) -{ +static int sexp_shape(SEXP sexp, size_t nd, size_t *shape) { /* Set 'shape', containing the size of each dimension (see sexp_rank). */ int i; SEXP dim = getAttrib(sexp, R_DimSymbol); if (dim == R_NilValue) shape[0] = LENGTH(sexp); - else for (i = 0; i < nd; i++) { + else + for (i = 0; i < nd; i++) { shape[i] = INTEGER(dim)[i]; } return TRUE; } - /* get the list element named str, or return NULL */ -static SEXP -getListElement(SEXP list, const char *str) -{ +static SEXP getListElement(SEXP list, const char *str) { SEXP elmt = R_NilValue, names; int i; if (list == R_NilValue) - return R_NilValue; + return R_NilValue; names = getAttrib(list, R_NamesSymbol); for (i = 0; i < length(list); i++) - if(strcmp(CHAR(STRING_ELT(names, i)), str) == 0) { + if (strcmp(CHAR(STRING_ELT(names, i)), str) == 0) { elmt = VECTOR_ELT(list, i); break; } - return elmt; + return elmt; } -static int -setListElement(term_t t, SEXP s_str, SEXP sexp) -{ +static int setListElement(term_t t, SEXP s_str, SEXP sexp) { int i, hadError, nprotect = 0; size_t shape; SEXP names, name_R, call_R, p, list; const char *str; - if (TYPEOF(s_str) == SYMSXP){ - s_str = PRINTNAME( s_str ); + if (TYPEOF(s_str) == SYMSXP) { + s_str = PRINTNAME(s_str); } if (TYPEOF(s_str) == STRSXP) { if (sexp_rank(s_str) > 1) { @@ -219,282 +217,256 @@ setListElement(term_t t, SEXP s_str, SEXP sexp) if (shape != 1) { Ureturn FALSE; } - str = CHAR(CHARACTER_DATA(s_str)[0]); - } else { + str = CHAR(CHARACTER_DATA(s_str)[0]); + } else { + Ureturn FALSE; + } + PROTECT_AND_COUNT(list = term_to_sexp(t, TRUE)); + if (list == R_NilValue) { Ureturn FALSE; } - PROTECT_AND_COUNT( list = term_to_sexp( t, TRUE ) ); - if (list == R_NilValue) - { Ureturn FALSE; } names = getAttrib(list, R_NamesSymbol); for (i = 0; i < length(list); i++) { - if(strcmp(CHAR(STRING_ELT(names, i)), str) == 0) { + if (strcmp(CHAR(STRING_ELT(names, i)), str) == 0) { SET_ELEMENT(list, i, sexp); Ureturn TRUE; } } // new attribute, // we need to work with the identifier - PROTECT_AND_COUNT( list = term_to_sexp( t, FALSE ) ); + PROTECT_AND_COUNT(list = term_to_sexp(t, FALSE)); PROTECT_AND_COUNT(name_R = allocVector(STRSXP, 1)); - SET_STRING_ELT( name_R, 0, mkCharCE(str, CE_UTF8)); + SET_STRING_ELT(name_R, 0, mkCharCE(str, CE_UTF8)); PROTECT_AND_COUNT(call_R = lang3(R_DollarSymbol, list, name_R)); p = lang3(install("<-"), call_R, sexp); - (void) protected_tryEval(p, R_GlobalEnv, &hadError); + (void)protected_tryEval(p, R_GlobalEnv, &hadError); Ureturn TRUE; } -static int -complex_term( term_t head, double *valxP, double* valyP) -{ +static int complex_term(term_t head, double *valxP, double *valyP) { term_t val1 = PL_new_term_ref(); atom_t name; int arity; - if ( - PL_is_functor(head, FUNCTOR_plus2) && - PL_get_arg(2, head, val1) && - ( ( PL_is_functor(val1, FUNCTOR_i1) && - PL_get_arg(1, val1, val1) && - PL_get_float( val1, valyP) ) - || - ( PL_get_name_arity(val1, & name, & arity) && - name == ATOM_i && arity == 0 && - (*valyP = 1, TRUE) - ) - ) && - PL_get_arg(1, head, head) && - PL_get_float( head, valxP) - ) + if (PL_is_functor(head, FUNCTOR_plus2) && PL_get_arg(2, head, val1) && + ((PL_is_functor(val1, FUNCTOR_i1) && PL_get_arg(1, val1, val1) && + PL_get_float(val1, valyP)) || + (PL_get_name_arity(val1, &name, &arity) && name == ATOM_i && + arity == 0 && (*valyP = 1, TRUE))) && + PL_get_arg(1, head, head) && PL_get_float(head, valxP)) return TRUE; - if ( - PL_is_functor(head, FUNCTOR_minus2) && - PL_get_arg(2, head, val1) && - ( ( PL_is_functor(val1, FUNCTOR_i1) && - PL_get_arg(1, val1, val1) && - PL_get_float( val1, valyP) && - ( *valyP = -*valyP, TRUE ) - ) - || - ( - PL_get_name_arity(val1, & name, & arity) && - name == ATOM_i && arity == 0 && - (*valyP = -1, TRUE) - ) - ) && - PL_get_arg(1, head, head) && - PL_get_float( head, valxP) - ) + if (PL_is_functor(head, FUNCTOR_minus2) && PL_get_arg(2, head, val1) && + ((PL_is_functor(val1, FUNCTOR_i1) && PL_get_arg(1, val1, val1) && + PL_get_float(val1, valyP) && (*valyP = -*valyP, TRUE)) || + (PL_get_name_arity(val1, &name, &arity) && name == ATOM_i && + arity == 0 && (*valyP = -1, TRUE))) && + PL_get_arg(1, head, head) && PL_get_float(head, valxP)) return 1; return 0; } -static int -REAL_term_type( term_t t , int context) -{ int objtype=PL_term_type(t), rc; - term_t tmp = PL_copy_term_ref( t ); +static int REAL_term_type(term_t t, int context) { + int objtype = PL_term_type(t), rc; + term_t tmp = PL_copy_term_ref(t); functor_t f; - switch(objtype) - { - case PL_VARIABLE: - return PL_R_VARIABLE; - case PL_INTEGER: - return PL_R_INTEGER; - case PL_FLOAT: - return PL_R_FLOAT; - case PL_STRING: - return PL_R_CHARS; - case PL_ATOM: + switch (objtype) { + case PL_VARIABLE: + return PL_R_VARIABLE; + case PL_INTEGER: + return PL_R_INTEGER; + case PL_FLOAT: + return PL_R_FLOAT; + case PL_STRING: + return PL_R_CHARS; + case PL_ATOM: #ifdef PL_NIL - case PL_NIL: + case PL_NIL: #endif - { int got_v = 0; - int bool_vP = 0; - atom_t tmp_atom; + { + int got_v = 0; + int bool_vP = 0; + atom_t tmp_atom; - if ( (got_v = PL_get_bool(t,&bool_vP)) ) - return PL_R_BOOL; + if ((got_v = PL_get_bool(t, &bool_vP))) + return PL_R_BOOL; - if ( !PL_get_atom(t,&tmp_atom) ) - REAL_Error("type atom",t); + if (!PL_get_atom(t, &tmp_atom)) + REAL_Error("type atom", t); - if (tmp_atom==ATOM_true || tmp_atom==ATOM_false ) - return PL_R_BOOL; - if (tmp_atom==ATOM_break) - return PL_R_BREAK; - if (tmp_atom==ATOM_next) - return PL_R_NEXT; - else if (context & PL_R_VECTOR) - return PL_R_CHARS; - else - return PL_R_SYMBOL; - } - break; - case PL_TERM: + if (tmp_atom == ATOM_true || tmp_atom == ATOM_false) + return PL_R_BOOL; + if (tmp_atom == ATOM_break) + return PL_R_BREAK; + if (tmp_atom == ATOM_next) + return PL_R_NEXT; + else if (context & PL_R_VECTOR) + return PL_R_CHARS; + else + return PL_R_SYMBOL; + } break; + case PL_TERM: #ifdef PL_LIST_PAIR - case PL_LIST_PAIR: + case PL_LIST_PAIR: #endif - { - term_t tail = PL_new_term_ref(); - size_t len; - atom_t a; - int arity; + { + term_t tail = PL_new_term_ref(); + size_t len; + atom_t a; + int arity; - - if (PL_LIST == PL_skip_list(t, tail, &len)) { - if (!PL_get_list(t, tmp, t) ) { - return FALSE; - } - int rc = PL_R_VECTOR|REAL_term_type( tmp , context|PL_R_VECTOR); - return rc; - } else if (len > 0) { - // must be a dot term - return PL_R_DOT; - } - if (!PL_get_functor(t, &f)) - return FALSE; - if ( (context & PL_R_VECTOR) && f == FUNCTOR_equal2 ) { - return PL_R_NAME|PL_R_VECTOR; - } - if ( !(context & PL_R_VECTOR) && f == FUNCTOR_dollar2 ) { - if (! PL_get_arg(2, t, tmp)) - return FALSE; - return PL_R_LISTEL; - } - if ( !(context & PL_R_VECTOR) && f == FUNCTOR_at2 ) { - if (! PL_get_arg(2, t, tmp)) - return FALSE; - return PL_R_SLOT; - } - if ( !(context & PL_R_VECTOR) && f == FUNCTOR_square_brackets2 ) { - return PL_R_SUBSET; - } - { - double x, y; - if (complex_term( t, &x, &y)) - return PL_R_COMPLEX; - } - if ( f == FUNCTOR_tilde2 ) { - return PL_R_FORMULA; - } - if ( f == FUNCTOR_tilde1 ) { - return PL_R_RFORMULA; - } - if ( f == FUNCTOR_plus1 ) { - if (! PL_get_arg(1, t, tmp)) - return FALSE; - rc = REAL_term_type( tmp , context ); - if (rc == PL_R_CHARS || rc == PL_R_SYMBOL) - return PL_R_PLUS; - return PL_R_CALL; - } - if ( f == FUNCTOR_dot1 ) { - if (! PL_get_arg(1, t, tmp)) - return FALSE; - rc = REAL_term_type( tmp , context ); - if (rc == PL_R_DOT || rc == PL_R_SYMBOL) - return PL_R_DOT; - } - if ( f == FUNCTOR_brackets1 ) { - if (! PL_get_arg(1, t, tmp)) - return FALSE; - return PL_R_CALL; - } - if ( f == FUNCTOR_equal2 ) { - return PL_R_EQUAL; - } - if ( f == FUNCTOR_minus1 || - f == FUNCTOR_dollar1 ) { - if (! PL_get_arg(1, t, tmp)) - return FALSE; - rc = REAL_term_type( tmp , context ); - if (rc == PL_R_CHARS || rc == PL_R_SYMBOL) - return PL_R_PSYMBOL; - return PL_R_CALL; - } - if ( f == FUNCTOR_quote1 ) - return PL_R_QUOTE; - - if ( f == FUNCTOR_if2 && PL_get_arg(1, t, tmp) && PL_get_name_arity(tmp, &a, &arity) && a == ATOM_function ) - return PL_R_DEFUN; - - if ( f == FUNCTOR_iff2 ) - return PL_R_IF; - - if ( f == FUNCTOR_in2 ) - return PL_R_IN; - - if ( f == FUNCTOR_iff3 ) - return PL_R_IF_ELSE; - - if ( f == FUNCTOR_while2 ) - return PL_R_WHILE; - - if ( f == FUNCTOR_repeat1 ) - return PL_R_REPEAT; - - if ( f == FUNCTOR_boolop1 ) - { - - if ( !PL_get_arg(1, t, tmp) ) - return REAL_Error("argument access", t); - - if ( ! PL_get_atom(tmp,&a) ) - return REAL_Error("type atom", t); - - if ( a == ATOM_true || a == ATOM_false ) - return PL_R_BOOL; - } - return PL_R_CALL; - } - break; - default: - return FALSE; + if (PL_LIST == PL_skip_list(t, tail, &len)) { + if (!PL_get_list(t, tmp, t)) { + return FALSE; + } + int rc = PL_R_VECTOR | REAL_term_type(tmp, context | PL_R_VECTOR); + return rc; + } else if (len > 0) { + // must be a dot term + return PL_R_DOT; } + if (!PL_get_functor(t, &f)) + return FALSE; + if ((context & PL_R_VECTOR) && f == FUNCTOR_equal2) { + return PL_R_NAME | PL_R_VECTOR; + } + if (!(context & PL_R_VECTOR) && f == FUNCTOR_dollar2) { + if (!PL_get_arg(2, t, tmp)) + return FALSE; + return PL_R_LISTEL; + } + if (!(context & PL_R_VECTOR) && f == FUNCTOR_at2) { + if (!PL_get_arg(2, t, tmp)) + return FALSE; + return PL_R_SLOT; + } + if (!(context & PL_R_VECTOR) && f == FUNCTOR_square_brackets2) { + return PL_R_SUBSET; + } + { + double x, y; + if (complex_term(t, &x, &y)) + return PL_R_COMPLEX; + } + if (f == FUNCTOR_tilde2) { + return PL_R_FORMULA; + } + if (f == FUNCTOR_tilde1) { + return PL_R_RFORMULA; + } + if (f == FUNCTOR_plus1) { + if (!PL_get_arg(1, t, tmp)) + return FALSE; + rc = REAL_term_type(tmp, context); + if (rc == PL_R_CHARS || rc == PL_R_SYMBOL) + return PL_R_PLUS; + return PL_R_CALL; + } + if (f == FUNCTOR_dot1) { + if (!PL_get_arg(1, t, tmp)) + return FALSE; + rc = REAL_term_type(tmp, context); + if (rc == PL_R_DOT || rc == PL_R_SYMBOL) + return PL_R_DOT; + } + if (f == FUNCTOR_brackets1) { + if (!PL_get_arg(1, t, tmp)) + return FALSE; + return PL_R_CALL; + } + if (f == FUNCTOR_equal2) { + return PL_R_EQUAL; + } + if (f == FUNCTOR_minus1 || f == FUNCTOR_dollar1) { + if (!PL_get_arg(1, t, tmp)) + return FALSE; + rc = REAL_term_type(tmp, context); + if (rc == PL_R_CHARS || rc == PL_R_SYMBOL) + return PL_R_PSYMBOL; + return PL_R_CALL; + } + if (f == FUNCTOR_quote1) + return PL_R_QUOTE; + + if (f == FUNCTOR_if2 && PL_get_arg(1, t, tmp) && + PL_get_name_arity(tmp, &a, &arity) && a == ATOM_function) + return PL_R_DEFUN; + + if (f == FUNCTOR_iff2) + return PL_R_IF; + + if (f == FUNCTOR_in2) + return PL_R_IN; + + if (f == FUNCTOR_iff3) + return PL_R_IF_ELSE; + + if (f == FUNCTOR_while2) + return PL_R_WHILE; + + if (f == FUNCTOR_repeat1) + return PL_R_REPEAT; + + if (f == FUNCTOR_boolop1) { + + if (!PL_get_arg(1, t, tmp)) + return REAL_Error("argument access", t); + + if (!PL_get_atom(tmp, &a)) + return REAL_Error("type atom", t); + + if (a == ATOM_true || a == ATOM_false) + return PL_R_BOOL; + } + return PL_R_CALL; + } break; + default: + return FALSE; + } } -static int -merge_dots( term_t t ) -{ char so[1025], *ns = so; - int loop=TRUE, first = TRUE, arity; +static int merge_dots(term_t t) { + char so[1025], *ns = so; + int loop = TRUE, first = TRUE, arity; term_t tmp = PL_new_term_ref(); atom_t name; so[0] = '\0'; while (loop) { - if ( PL_get_list(t, tmp, t) ) loop = TRUE; - else if ( (PL_is_functor(t, FUNCTOR_dot1) && PL_get_arg(1, t, tmp)) || (tmp = t, TRUE)) loop = FALSE; + if (PL_get_list(t, tmp, t)) + loop = TRUE; + else if ((PL_is_functor(t, FUNCTOR_dot1) && PL_get_arg(1, t, tmp)) || + (tmp = t, TRUE)) + loop = FALSE; if (!first || !loop) { - strncat( so, ".", 1024); + strncat(so, ".", 1024); } if (first) { first = FALSE; } - if ( PL_get_chars(tmp, &ns, CVT_ATOM|CVT_STRING|BUF_DISCARDABLE|REP_UTF8) ) { + if (PL_get_chars(tmp, &ns, + CVT_ATOM | CVT_STRING | BUF_DISCARDABLE | REP_UTF8)) { ns += strlen(ns); if (!loop) { - atom_t at = PL_new_atom( so ); - return PL_put_atom(t, at); + atom_t at = PL_new_atom(so); + return PL_put_atom(t, at); } - } else if ( !loop && - PL_is_functor(t, FUNCTOR_brackets1) && - PL_get_arg(1, t, tmp) && - PL_get_chars(tmp, &ns, CVT_ATOM|CVT_STRING|BUF_DISCARDABLE|REP_UTF8) ) { - strncat( so, ns, 1024-strlen(so)-1); - return - PL_put_atom_chars(tmp, so) && - PL_cons_functor(t, FUNCTOR_brackets1, tmp); - } else if ( !loop && - PL_get_name_arity( tmp, &name, & arity ) && - (ns = PL_atom_chars( name ) ) ) { - strncat( so, ns, 1024-strlen(so)-1); + } else if (!loop && PL_is_functor(t, FUNCTOR_brackets1) && + PL_get_arg(1, t, tmp) && + PL_get_chars(tmp, &ns, CVT_ATOM | CVT_STRING | BUF_DISCARDABLE | + REP_UTF8)) { + strncat(so, ns, 1024 - strlen(so) - 1); + return PL_put_atom_chars(tmp, so) && + PL_cons_functor(t, FUNCTOR_brackets1, tmp); + } else if (!loop && PL_get_name_arity(tmp, &name, &arity) && + (ns = PL_atom_chars(name))) { + strncat(so, ns, 1024 - strlen(so) - 1); term_t a = PL_new_term_refs(arity); int i; for (i = 0; i < arity; i++) - if (!PL_get_arg(i+1, tmp, a+i)) - return FALSE; + if (!PL_get_arg(i + 1, tmp, a + i)) + return FALSE; return PL_cons_functor_v(t, PL_new_functor(PL_new_atom(so), arity), a); } else return FALSE; @@ -503,288 +475,243 @@ merge_dots( term_t t ) } // put t in ans[index]; and stores elements of type objtype -static int -term_to_S_el( term_t t, int objtype, size_t index, SEXP ans) -{ +static int term_to_S_el(term_t t, int objtype, size_t index, SEXP ans) { switch (objtype) { - case PL_R_CHARS: - case PL_R_PLUS: - { - char *s; + case PL_R_CHARS: + case PL_R_PLUS: { + char *s; - if ( PL_get_chars(t, &s, CVT_ATOM|CVT_STRING|CVT_LIST|BUF_DISCARDABLE|REP_UTF8) ) - { - CHARACTER_DATA(ans)[index] = mkCharCE(s, CE_UTF8); - return TRUE; - } - else - { - if (PL_get_arg( 1, t , t ) && - PL_get_chars(t, &s, CVT_ATOM|CVT_STRING|CVT_LIST|BUF_DISCARDABLE|REP_UTF8) ) - { - CHARACTER_DATA(ans)[index] = mkCharCE(s, CE_UTF8); - return TRUE; - } - } + if (PL_get_chars(t, &s, CVT_ATOM | CVT_STRING | CVT_LIST | BUF_DISCARDABLE | + REP_UTF8)) { + CHARACTER_DATA(ans)[index] = mkCharCE(s, CE_UTF8); + return TRUE; + } else { + if (PL_get_arg(1, t, t) && + PL_get_chars(t, &s, CVT_ATOM | CVT_STRING | CVT_LIST | + BUF_DISCARDABLE | REP_UTF8)) { + CHARACTER_DATA(ans)[index] = mkCharCE(s, CE_UTF8); + return TRUE; } + } + } + return FALSE; + + case PL_R_INTEGER: { + int64_t val; + + if (PL_get_int64(t, &val)) { + INTEGER_DATA(ans)[index] = val; + } else { + return FALSE; + } + } break; + case PL_R_FLOAT: { + double val; + int64_t ival; + + if (PL_get_float(t, &val)) { + NUMERIC_DATA(ans)[index] = val; + return TRUE; + } else if (PL_get_int64(t, &ival)) { + NUMERIC_DATA(ans)[index] = ival; + return TRUE; + } else return FALSE; - case PL_R_INTEGER: - { int64_t val; + } break; + case PL_R_ATBOOL: + case PL_R_BOOL: { + int val; - if ( PL_get_int64(t, &val) ) - { - INTEGER_DATA(ans)[index] = val; - } - else { - return FALSE; - } + if (PL_get_bool(t, &val)) { + LOGICAL_DATA(ans)[index] = val; + return TRUE; + } else { + if (PL_get_arg(1, t, t) && PL_get_bool(t, &val)) { + LOGICAL_DATA(ans)[index] = val; + return TRUE; } - break; - case PL_R_FLOAT: - { double val; - int64_t ival; - - if ( PL_get_float(t, &val) ) - { - NUMERIC_DATA(ans)[index] = val; - return TRUE; - } - else if ( PL_get_int64(t, &ival) ) - { - NUMERIC_DATA(ans)[index] = ival; - return TRUE; - } - else - return FALSE; - - } - break; - case PL_R_ATBOOL: - case PL_R_BOOL: - { - int val; - - if ( PL_get_bool(t, &val) ) - { - LOGICAL_DATA(ans)[index] = val; - return TRUE; - } - else { - if (PL_get_arg( 1, t , t ) && - PL_get_bool(t, &val) ) - { - LOGICAL_DATA(ans)[index] = val; - return TRUE; - } - return FALSE; - } - } - break; - - case PL_R_COMPLEX: - { - double valx, valy, val; - int64_t ival; - - if ( complex_term( t , & valx, & valy) ) - { - COMPLEX_DATA(ans)[index].r = valx; - COMPLEX_DATA(ans)[index].i = valy; - return TRUE; - } else if ( PL_get_float(t, &val) ) - { - COMPLEX_DATA(ans)[index].r = val; - COMPLEX_DATA(ans)[index].i = 0.0; - return TRUE; - } else if ( PL_get_int64(t, &ival) ) - { - COMPLEX_DATA(ans)[index].r = ival; - COMPLEX_DATA(ans)[index].i = 0.0; - return TRUE; - } else - { /* FIXME: Destroy ans */ - return FALSE; /* type error */ - } + return FALSE; } + } break; - break; + case PL_R_COMPLEX: { + double valx, valy, val; + int64_t ival; - default: - assert(0); + if (complex_term(t, &valx, &valy)) { + COMPLEX_DATA(ans)[index].r = valx; + COMPLEX_DATA(ans)[index].i = valy; + return TRUE; + } else if (PL_get_float(t, &val)) { + COMPLEX_DATA(ans)[index].r = val; + COMPLEX_DATA(ans)[index].i = 0.0; + return TRUE; + } else if (PL_get_int64(t, &ival)) { + COMPLEX_DATA(ans)[index].r = ival; + COMPLEX_DATA(ans)[index].i = 0.0; + return TRUE; + } else { /* FIXME: Destroy ans */ + return FALSE; /* type error */ + } + } + + break; + + default: + assert(0); } return TRUE; } // put t in ans[index]; and stores elements of type objtype -static int -sexp_to_S_el( SEXP sin, size_t index, SEXP ans) -{ +static int sexp_to_S_el(SEXP sin, size_t index, SEXP ans) { switch (TYPEOF(ans)) { - case STRSXP: - { - if (TYPEOF(sin) != STRSXP) - return FALSE; - CHARACTER_DATA(ans)[index] = CHARACTER_DATA(sin)[0]; - } - break; - case INTSXP: - { - if (TYPEOF(sin) != INTSXP) - return FALSE; - INTEGER_DATA(ans)[index] = INTEGER_DATA(sin)[0]; - } - break; + case STRSXP: { + if (TYPEOF(sin) != STRSXP) + return FALSE; + CHARACTER_DATA(ans)[index] = CHARACTER_DATA(sin)[0]; + } break; + case INTSXP: { + if (TYPEOF(sin) != INTSXP) + return FALSE; + INTEGER_DATA(ans)[index] = INTEGER_DATA(sin)[0]; + } break; - case REALSXP: - { - if (TYPEOF(sin) == INTSXP) - NUMERIC_DATA(ans)[index] = INTEGER_DATA(sin)[0]; - else if (TYPEOF(sin) == REALSXP) - NUMERIC_DATA(ans)[index] = NUMERIC_DATA(sin)[0]; - else - return FALSE; - } - break; + case REALSXP: { + if (TYPEOF(sin) == INTSXP) + NUMERIC_DATA(ans)[index] = INTEGER_DATA(sin)[0]; + else if (TYPEOF(sin) == REALSXP) + NUMERIC_DATA(ans)[index] = NUMERIC_DATA(sin)[0]; + else + return FALSE; + } break; - case LGLSXP: - { - if (TYPEOF(sin) == LGLSXP) - LOGICAL_DATA(ans)[index] = LOGICAL_DATA(sin)[0]; - else - return FALSE; - break; - } + case LGLSXP: { + if (TYPEOF(sin) == LGLSXP) + LOGICAL_DATA(ans)[index] = LOGICAL_DATA(sin)[0]; + else + return FALSE; + break; + } + case CPLXSXP: { + if (TYPEOF(sin) == CPLXSXP) { + COMPLEX_DATA(ans)[index] = COMPLEX_DATA(sin)[0]; + } else if (TYPEOF(sin) == INTSXP) { + COMPLEX_DATA(ans)[index].r = INTEGER_DATA(sin)[0]; + COMPLEX_DATA(ans)[index].i = 0; + } else if (TYPEOF(sin) == REALSXP) { + COMPLEX_DATA(ans)[index].r = NUMERIC_DATA(sin)[0]; + COMPLEX_DATA(ans)[index].i = 0; + } else + return FALSE; + } break; + case VECSXP: { + SEXPTYPE type = TYPEOF(sin); + switch (type) { case CPLXSXP: - { - if (TYPEOF(sin) == CPLXSXP) { - COMPLEX_DATA(ans)[index] = COMPLEX_DATA(sin)[0]; - } else if (TYPEOF(sin) == INTSXP) { - COMPLEX_DATA(ans)[index].r = INTEGER_DATA(sin)[0]; - COMPLEX_DATA(ans)[index].i = 0; - } else if (TYPEOF(sin) == REALSXP) { - COMPLEX_DATA(ans)[index].r = NUMERIC_DATA(sin)[0]; - COMPLEX_DATA(ans)[index].i = 0; - } else - return FALSE; - } + case INTSXP: + case REALSXP: + VECTOR_DATA(ans)[index] = Rf_coerceVector(sin, type); break; - - case VECSXP: - { - SEXPTYPE type = TYPEOF(sin); - switch (type) { - case CPLXSXP: - case INTSXP: - case REALSXP: - VECTOR_DATA(ans)[index] = Rf_coerceVector(sin, type); - break; - case VECSXP: - VECTOR_DATA(ans)[index] = VECTOR_DATA(sin)[0]; - break; - default: - return FALSE; - } - } + case VECSXP: + VECTOR_DATA(ans)[index] = VECTOR_DATA(sin)[0]; break; - default: - assert(0); + return FALSE; + } + } break; + + default: + assert(0); } return 1; } -static int -set_listEl_to_sexp( term_t t, SEXP sexp) -{ term_t tslot = PL_new_term_ref(); +static int set_listEl_to_sexp(term_t t, SEXP sexp) { + term_t tslot = PL_new_term_ref(); SEXP s; int nprotect = 0; - if (!PL_get_arg( 2, t, tslot) ) + if (!PL_get_arg(2, t, tslot)) return FALSE; - if ( PL_is_pair( tslot ) || - PL_is_functor( tslot , FUNCTOR_dot1 ) ) { - if (!merge_dots( tslot )) + if (PL_is_pair(tslot) || PL_is_functor(tslot, FUNCTOR_dot1)) { + if (!merge_dots(tslot)) return FALSE; } - s = term_to_sexp(tslot, FALSE) ; - if (!PL_get_arg( 1, t, t) ) + s = term_to_sexp(tslot, FALSE); + if (!PL_get_arg(1, t, t)) Ureturn FALSE; // we now have s with the slot, and tmp_R with the object. Let us roll.. - return setListElement( t, s , sexp); + return setListElement(t, s, sexp); } - -static SEXP -list_to_sexp( term_t t, int objtype) -{ term_t tail = PL_new_term_ref(), tmp = PL_copy_term_ref( t ); +static SEXP list_to_sexp(term_t t, int objtype) { + term_t tail = PL_new_term_ref(), tmp = PL_copy_term_ref(t); size_t dims[256]; term_t stack[256]; size_t R_index[256]; - size_t ndims = 0, len, spos=0; + size_t ndims = 0, len, spos = 0; int nprotect = 0, i, sobjtype; SEXP ans; // cheking the depth of the list - tmp = PL_copy_term_ref( tmp ); + tmp = PL_copy_term_ref(tmp); while (PL_is_pair(tmp)) { size_t len; if (PL_LIST != PL_skip_list(tmp, tail, &len)) { Ureturn R_NilValue; } - if (! PL_get_list(tmp, tmp, tail)) { + if (!PL_get_list(tmp, tmp, tail)) { Ureturn R_NilValue; } dims[ndims] = len; ndims++; } - for (i=0, len=1; i < ndims; i++) { + for (i = 0, len = 1; i < ndims; i++) { len *= dims[i]; } - if ((objtype &~ PL_R_VECTOR) == PL_R_NAME) { + if ((objtype & ~PL_R_VECTOR) == PL_R_NAME) { SEXP names; int nprotect = 0; - PROTECT_AND_COUNT(ans=NEW_LIST(len)); + PROTECT_AND_COUNT(ans = NEW_LIST(len)); PROTECT_AND_COUNT(names = allocVector(STRSXP, len)); - for(i=0; PL_get_list(t, tmp, t); i++) - { - if ( PL_is_functor(tmp, FUNCTOR_equal2) ) - { char *nm = NULL; - SEXP sexp; + for (i = 0; PL_get_list(t, tmp, t); i++) { + if (PL_is_functor(tmp, FUNCTOR_equal2)) { + char *nm = NULL; + SEXP sexp; - if ( PL_get_arg(1, tmp, tail) && - PL_get_arg(2, tmp, tmp) && - ( PL_is_pair( tail ) || - PL_is_functor( tail , FUNCTOR_dot1 ) ) && - merge_dots( tail ) && - PL_get_chars(tail, &nm, CVT_ATOM|CVT_STRING|BUF_MALLOC|REP_UTF8)) { - sexp = term_to_sexp(tmp, FALSE) ; - SET_STRING_ELT(names, i, mkCharCE(nm, CE_UTF8)); - SET_ELEMENT(ans, i, sexp); - PL_free(nm); - } else if ( (PL_is_atom(tail) || PL_is_string(tail)) && - PL_get_chars(tail, &nm, CVT_ATOM|CVT_STRING|BUF_MALLOC|REP_UTF8) ) - { - sexp = term_to_sexp(tmp, FALSE); - SET_STRING_ELT(names, i, mkCharCE(nm, CE_UTF8)); - SET_ELEMENT(ans, i, sexp); - PL_free(nm); - /* also check cases like java.parameters */ - } else - { /* FIXME: Destroy ans and names */ - if (nm) PL_free(nm); - Ureturn ans; - } - } else - { /* */ - REAL_Error("type list", tmp); - Ureturn ans; - } + if (PL_get_arg(1, tmp, tail) && PL_get_arg(2, tmp, tmp) && + (PL_is_pair(tail) || PL_is_functor(tail, FUNCTOR_dot1)) && + merge_dots(tail) && + PL_get_chars(tail, &nm, + CVT_ATOM | CVT_STRING | BUF_MALLOC | REP_UTF8)) { + sexp = term_to_sexp(tmp, FALSE); + SET_STRING_ELT(names, i, mkCharCE(nm, CE_UTF8)); + SET_ELEMENT(ans, i, sexp); + PL_free(nm); + } else if ((PL_is_atom(tail) || PL_is_string(tail)) && + PL_get_chars(tail, &nm, CVT_ATOM | CVT_STRING | BUF_MALLOC | + REP_UTF8)) { + sexp = term_to_sexp(tmp, FALSE); + SET_STRING_ELT(names, i, mkCharCE(nm, CE_UTF8)); + SET_ELEMENT(ans, i, sexp); + PL_free(nm); + /* also check cases like java.parameters */ + } else { /* FIXME: Destroy ans and names */ + if (nm) + PL_free(nm); + Ureturn ans; + } + } else { /* */ + REAL_Error("type list", tmp); + Ureturn ans; + } } SET_NAMES(ans, names); @@ -792,58 +719,56 @@ list_to_sexp( term_t t, int objtype) } else { sobjtype = objtype & ~PL_R_VECTOR; } - switch(sobjtype) - { - case PL_R_INTEGER: - PROTECT_AND_COUNT(ans=NEW_INTEGER(len)); - break; - case PL_R_FLOAT: - PROTECT_AND_COUNT(ans=NEW_NUMERIC(len)); - break; - case PL_R_CHARS: - case PL_R_PLUS: - PROTECT_AND_COUNT(ans=NEW_CHARACTER(len)); - break; - case PL_R_COMPLEX: - PROTECT_AND_COUNT(ans=NEW_COMPLEX(len)); - break; - case PL_R_ATBOOL: - case PL_R_BOOL: - PROTECT_AND_COUNT(ans=NEW_LOGICAL(len)); - break; - default: - assert(0); - } - + switch (sobjtype) { + case PL_R_INTEGER: + PROTECT_AND_COUNT(ans = NEW_INTEGER(len)); + break; + case PL_R_FLOAT: + PROTECT_AND_COUNT(ans = NEW_NUMERIC(len)); + break; + case PL_R_CHARS: + case PL_R_PLUS: + PROTECT_AND_COUNT(ans = NEW_CHARACTER(len)); + break; + case PL_R_COMPLEX: + PROTECT_AND_COUNT(ans = NEW_COMPLEX(len)); + break; + case PL_R_ATBOOL: + case PL_R_BOOL: + PROTECT_AND_COUNT(ans = NEW_LOGICAL(len)); + break; + default: + assert(0); + } // take care of dims SEXP sdims = NEW_INTEGER(ndims); - for ( i = 0 ; i < ndims; i++ ) { + for (i = 0; i < ndims; i++) { INTEGER_DATA(sdims)[i] = dims[i]; R_index[i] = 1; // use R notation } setAttrib(ans, R_DimSymbol, sdims); - stack[0] = PL_copy_term_ref( t ); + stack[0] = PL_copy_term_ref(t); term_t l = stack[0]; - for (i = 1; i <= ndims ; i++) + for (i = 1; i <= ndims; i++) stack[i] = PL_new_term_ref(); - while( TRUE ) { - if (PL_is_pair( l ) ) { - PL_get_list( l, stack[spos + 1], l); + while (TRUE) { + if (PL_is_pair(l)) { + PL_get_list(l, stack[spos + 1], l); l = stack[spos + 1]; spos++; } else if (PL_is_list(l)) { if (spos == 0) - break; + break; l = stack[spos - 1]; spos--; } else { - if ( !term_to_S_el( l, objtype & ~PL_R_VECTOR, pos_dims(R_index, ndims, dims), ans) ) { - if ((objtype & PL_R_INTEGER) && - PL_is_float( l ) ) { - Ureturn list_to_sexp( t, PL_R_FLOAT|PL_R_VECTOR ); - } + if (!term_to_S_el(l, objtype & ~PL_R_VECTOR, + pos_dims(R_index, ndims, dims), ans)) { + if ((objtype & PL_R_INTEGER) && PL_is_float(l)) { + Ureturn list_to_sexp(t, PL_R_FLOAT | PL_R_VECTOR); + } Ureturn R_NilValue; } inc_dims(R_index, ndims, dims); @@ -854,182 +779,164 @@ list_to_sexp( term_t t, int objtype) Ureturn ans; } -static int -slot_to_sexp( term_t t, SEXP *ansP) -{ term_t tslot = PL_new_term_ref(); +static int slot_to_sexp(term_t t, SEXP *ansP) { + term_t tslot = PL_new_term_ref(); char *s; SEXP tmp_R, name_R; - int nprotect=0; + int nprotect = 0; - if (!PL_get_arg( 2, t, tslot) ) + if (!PL_get_arg(2, t, tslot)) return FALSE; - if ( PL_is_pair( tslot ) || - PL_is_functor( tslot , FUNCTOR_dot1 ) ) { - if (!merge_dots( tslot )) + if (PL_is_pair(tslot) || PL_is_functor(tslot, FUNCTOR_dot1)) { + if (!merge_dots(tslot)) return FALSE; } - if ( !PL_get_chars(tslot, &s, - CVT_ATOM|BUF_MALLOC|REP_UTF8) ) - { - return FALSE; - } - if (!PL_get_arg( 1, t, t) ) + if (!PL_get_chars(tslot, &s, CVT_ATOM | BUF_MALLOC | REP_UTF8)) { + return FALSE; + } + if (!PL_get_arg(1, t, t)) return FALSE; - PROTECT_AND_COUNT(tmp_R = term_to_sexp( t, TRUE ) ); + PROTECT_AND_COUNT(tmp_R = term_to_sexp(t, TRUE)); // we now have s with the slot, and tmp_R with the object. Let us roll.. PROTECT_AND_COUNT(name_R = install(s)); - if (! R_has_slot(tmp_R, name_R)) { - return FALSE; + if (!R_has_slot(tmp_R, name_R)) { + return FALSE; } - *ansP = GET_SLOT( tmp_R, name_R ); - if (! *ansP) + *ansP = GET_SLOT(tmp_R, name_R); + if (!*ansP) return FALSE; return TRUE; } -static int -set_slot_to_sexp( term_t t, SEXP sexp) -{ term_t tslot = PL_new_term_ref(); +static int set_slot_to_sexp(term_t t, SEXP sexp) { + term_t tslot = PL_new_term_ref(); char *s; SEXP tmp_R, name_R; - int nprotect=0; + int nprotect = 0; - if (!PL_get_arg( 2, t, tslot) ) + if (!PL_get_arg(2, t, tslot)) return FALSE; - if ( PL_is_pair( tslot ) || - PL_is_functor( tslot , FUNCTOR_dot1 ) ) { - if (!merge_dots( tslot )) + if (PL_is_pair(tslot) || PL_is_functor(tslot, FUNCTOR_dot1)) { + if (!merge_dots(tslot)) return FALSE; } - if ( !PL_get_chars(tslot, &s, - CVT_ATOM|BUF_MALLOC|REP_UTF8) ) - { - return FALSE; - } - if (!PL_get_arg( 1, t, t) ) + if (!PL_get_chars(tslot, &s, CVT_ATOM | BUF_MALLOC | REP_UTF8)) { + return FALSE; + } + if (!PL_get_arg(1, t, t)) return FALSE; - PROTECT_AND_COUNT( tmp_R = term_to_sexp( t, TRUE )); + PROTECT_AND_COUNT(tmp_R = term_to_sexp(t, TRUE)); // we now have s with the slot, and tmp_R with the object. Let us roll.. - PROTECT_AND_COUNT( name_R = install(s) ); + PROTECT_AND_COUNT(name_R = install(s)); // if (! R_has_slot(tmp_R, name_R)) { // return FALSE; //} - SET_SLOT( tmp_R, name_R, sexp ); + SET_SLOT(tmp_R, name_R, sexp); Ureturn TRUE; } -static int -listEl_to_sexp( term_t t, SEXP *ansP) -{ term_t tslot = PL_new_term_ref(); +static int listEl_to_sexp(term_t t, SEXP *ansP) { + term_t tslot = PL_new_term_ref(); char *s; SEXP tmp_R; - int nprotect=0; + int nprotect = 0; - if (!PL_get_arg( 2, t, tslot) ) + if (!PL_get_arg(2, t, tslot)) return FALSE; - if ( PL_is_pair( tslot ) || - PL_is_functor( tslot , FUNCTOR_dot1 ) ) { - if (!merge_dots( tslot )) + if (PL_is_pair(tslot) || PL_is_functor(tslot, FUNCTOR_dot1)) { + if (!merge_dots(tslot)) return FALSE; } - if ( !PL_get_chars(tslot, &s, - CVT_ATOM|BUF_MALLOC|REP_UTF8) ) - { - return FALSE; - } - if (!PL_get_arg( 1, t, t) ) + if (!PL_get_chars(tslot, &s, CVT_ATOM | BUF_MALLOC | REP_UTF8)) { + return FALSE; + } + if (!PL_get_arg(1, t, t)) return FALSE; - PROTECT_AND_COUNT( tmp_R = term_to_sexp( t, TRUE ) ); + PROTECT_AND_COUNT(tmp_R = term_to_sexp(t, TRUE)); // we now have s with the slot, and tmp_R with the object. Let us roll.. - *ansP = getListElement(tmp_R, s); + *ansP = getListElement(tmp_R, s); if (*ansP == R_NilValue) Ureturn FALSE; Ureturn TRUE; } -static SEXP -pl_to_func( term_t t, bool eval) -{ +static SEXP pl_to_func(term_t t, bool eval) { atom_t name; int arity; - term_t a1 = PL_new_term_ref(), a; + term_t a1 = PL_new_term_ref(), a; int i, ierror; SEXP c_R, call_R, res_R; char *sf; int nprotect = 0; - if (!PL_get_name_arity(t, & name, & arity)) - { - Ureturn FALSE; - } - if ( !( sf = PL_atom_chars(name) ) ) - { - Ureturn FALSE; - } + if (!PL_get_name_arity(t, &name, &arity)) { + Ureturn FALSE; + } + if (!(sf = PL_atom_chars(name))) { + Ureturn FALSE; + } if (!strcmp(sf, "()")) { - if ( !PL_get_arg(1, t, a1) || - !PL_get_chars(a1, &sf, - CVT_ATOM|BUF_MALLOC|REP_UTF8) ) - { - Ureturn FALSE; - } + if (!PL_get_arg(1, t, a1) || + !PL_get_chars(a1, &sf, CVT_ATOM | BUF_MALLOC | REP_UTF8)) { + Ureturn FALSE; + } arity = 0; } - + // first evaluate arguments left to right - a = PL_new_term_ref(), a1 = PL_new_term_ref(); - PROTECT_AND_COUNT( call_R = allocList(arity+1) ); - c_R = call_R ; + a = PL_new_term_ref(), a1 = PL_new_term_ref(); + PROTECT_AND_COUNT(call_R = allocList(arity + 1)); + c_R = call_R; c_R = CDR(c_R); - for (i=0; i< arity;i ++) { - if ( !PL_get_arg( i+ 1, t, a) ) { + for (i = 0; i < arity; i++) { + if (!PL_get_arg(i + 1, t, a)) { REAL_Error("argument access", t); { Ureturn R_NilValue; } } - if ( PL_is_functor(a, FUNCTOR_equal2) ) { + if (PL_is_functor(a, FUNCTOR_equal2)) { char *s = NULL; - if (!PL_get_arg(1, a, a1)) - { Ureturn FALSE; } - if ( PL_is_pair( a1 ) || - PL_is_functor( a1 , FUNCTOR_dot1 ) ) { - if (!merge_dots( a1 )) { + if (!PL_get_arg(1, a, a1)) { + Ureturn FALSE; + } + if (PL_is_pair(a1) || PL_is_functor(a1, FUNCTOR_dot1)) { + if (!merge_dots(a1)) { Ureturn FALSE; } } - if ( !PL_get_chars(a1, &s, - CVT_ATOM|CVT_STRING|BUF_MALLOC|REP_UTF8) ) - { - Ureturn FALSE; - } - if (!PL_get_arg(2, a, a)) - { Ureturn FALSE; } - - SETCAR(c_R, term_to_sexp( a, FALSE ) ); - SET_TAG(c_R, install(s) ); - PL_free( s ); - } else { - SETCAR(c_R, term_to_sexp( a, FALSE ) ); + if (!PL_get_chars(a1, &s, + CVT_ATOM | CVT_STRING | BUF_MALLOC | REP_UTF8)) { + Ureturn FALSE; + } + if (!PL_get_arg(2, a, a)) { + Ureturn FALSE; + } + + SETCAR(c_R, term_to_sexp(a, FALSE)); + SET_TAG(c_R, install(s)); + PL_free(s); + } else { + SETCAR(c_R, term_to_sexp(a, FALSE)); } - c_R = CDR(c_R); + c_R = CDR(c_R); } - + // now we can evaluate the function if (arity == 1) { - SEXP mu; - PROTECT_AND_COUNT( mu = getAttrib(CADR(call_R), install(sf)) ); - if(!(mu == R_UnboundValue || mu == R_NilValue ) ) { - // PL_free( sf ); + SEXP mu; + PROTECT_AND_COUNT(mu = getAttrib(CADR(call_R), install(sf))); + if (!(mu == R_UnboundValue || mu == R_NilValue)) { + // PL_free( sf ); { Ureturn mu; } - } + } } c_R = call_R; // PROTECT_AND_COUNT( fn_R = myFindFun(install(sf), R_GlobalEnv) ); @@ -1037,17 +944,16 @@ pl_to_func( term_t t, bool eval) SETCAR(c_R, install(sf)); // PL_free( sf ); if (eval) { - PROTECT_AND_COUNT( res_R = protected_tryEval(call_R, R_GlobalEnv, &ierror) ); - if (res_R == NULL) res_R = call_R; + PROTECT_AND_COUNT(res_R = protected_tryEval(call_R, R_GlobalEnv, &ierror)); + if (res_R == NULL) + res_R = call_R; { Ureturn res_R; } } Ureturn call_R; } -static int -pl_to_body( term_t t, SEXP *ansP) -{ - term_t tmp = PL_copy_term_ref(t), tail = PL_copy_term_ref(t); +static int pl_to_body(term_t t, SEXP *ansP) { + term_t tmp = PL_copy_term_ref(t), tail = PL_copy_term_ref(t); size_t i, len; SEXP body_R; int nprotect = 0; @@ -1057,86 +963,84 @@ pl_to_body( term_t t, SEXP *ansP) PROTECT_AND_COUNT(ans = stmp = allocList(len)); for (i = 0; i < len; i++) { - if (!PL_get_list( t, tmp, t )) - { Ureturn FALSE; } - PROTECT_AND_COUNT( body_R = term_to_sexp( t, FALSE ) ); - SETCAR(stmp , body_R ); - stmp = CDR( stmp ); + if (!PL_get_list(t, tmp, t)) { + Ureturn FALSE; + } + PROTECT_AND_COUNT(body_R = term_to_sexp(t, FALSE)); + SETCAR(stmp, body_R); + stmp = CDR(stmp); } *ansP = ans; } else { - PROTECT_AND_COUNT( *ansP = term_to_sexp( t, FALSE ) ); - if (Rf_isNull(*ansP)) - { Ureturn FALSE; } + PROTECT_AND_COUNT(*ansP = term_to_sexp(t, FALSE)); + if (Rf_isNull(*ansP)) { + Ureturn FALSE; + } } Ureturn TRUE; } - -static int -pl_to_defun( term_t t, SEXP *ansP) -{ +static int pl_to_defun(term_t t, SEXP *ansP) { atom_t name; int arity; - term_t a = PL_new_term_ref(), body = PL_new_term_ref(); + term_t a = PL_new_term_ref(), body = PL_new_term_ref(); int i; SEXP clo_R, c_R, call_R, body_R; int nprotect = 0; - if (!PL_get_arg(1, t, a)) - { - Ureturn FALSE; - } - if (!PL_get_name_arity(a, &name, &arity)) - { - Ureturn FALSE; - } - if (!PL_get_arg(2, t, body)) - { - Ureturn FALSE; - } + if (!PL_get_arg(1, t, a)) { + Ureturn FALSE; + } + if (!PL_get_name_arity(a, &name, &arity)) { + Ureturn FALSE; + } + if (!PL_get_arg(2, t, body)) { + Ureturn FALSE; + } - PROTECT_AND_COUNT( clo_R = allocSExp(CLOSXP) ); - if (!clo_R) - { Ureturn FALSE; } + PROTECT_AND_COUNT(clo_R = allocSExp(CLOSXP)); + if (!clo_R) { + Ureturn FALSE; + } PROTECT_AND_COUNT(c_R = call_R = allocList(arity)); SET_TYPEOF(c_R, LANGSXP); for (i = 0; i < arity; i++) { SEXP tmp_R; - if ( !PL_get_arg( i+1, a, t) ) - { Ureturn REAL_Error("argument access", t); } - PROTECT_AND_COUNT( tmp_R = term_to_sexp( t, FALSE ) ); - if (Rf_isNull(tmp_R)) - { Ureturn FALSE; } + if (!PL_get_arg(i + 1, a, t)) { + Ureturn REAL_Error("argument access", t); + } + PROTECT_AND_COUNT(tmp_R = term_to_sexp(t, FALSE)); + if (Rf_isNull(tmp_R)) { + Ureturn FALSE; + } SETCAR(c_R, tmp_R); SET_TAG(c_R, CreateTag(tmp_R)); c_R = CDR(c_R); } SET_FORMALS(clo_R, call_R); SET_CLOENV(clo_R, R_GlobalEnv); - if (!pl_to_body( body, &body_R )) - { Ureturn FALSE; } + if (!pl_to_body(body, &body_R)) { + Ureturn FALSE; + } SET_BODY(clo_R, body_R); *ansP = clo_R; Ureturn TRUE; } -static int -old_list_to_sexp( term_t t, SEXP c_R, int n, bool eval ) -{ +static int old_list_to_sexp(term_t t, SEXP c_R, int n, bool eval) { int i; term_t a = PL_new_term_ref(); SEXP head_R; int nprotect = 0; for (i = 0; i < n; i++) { - if (PL_get_list( t, a, t )) { - if (PL_is_variable( a )) { - SETCAR(c_R, R_MissingArg); + if (PL_get_list(t, a, t)) { + if (PL_is_variable(a)) { + SETCAR(c_R, R_MissingArg); } else { - PROTECT_AND_COUNT( head_R = term_to_sexp( a, eval) ); - SETCAR(c_R, head_R); + PROTECT_AND_COUNT(head_R = term_to_sexp(a, eval)); + SETCAR(c_R, head_R); } c_R = CDR(c_R); } else { @@ -1146,9 +1050,7 @@ old_list_to_sexp( term_t t, SEXP c_R, int n, bool eval ) Ureturn TRUE; } -static SEXP -subset_to_sexp( term_t t, bool eval) -{ +static SEXP subset_to_sexp(term_t t, bool eval) { term_t a = PL_new_term_ref(), b = PL_new_term_ref(); SEXP lhs_R, call_R, res_R, sin, c_R; int nprotect = 0; @@ -1156,42 +1058,46 @@ subset_to_sexp( term_t t, bool eval) size_t len; // get lh side - if ( !PL_get_arg( 2, t, a) ) - { REAL_Error("argument access", t); - Ureturn R_NilValue; - } - PROTECT_AND_COUNT( lhs_R = term_to_sexp( a, eval ) ); - if (Rf_isNull(lhs_R)) - { Ureturn R_NilValue; } + if (!PL_get_arg(2, t, a)) { + REAL_Error("argument access", t); + Ureturn R_NilValue; + } + PROTECT_AND_COUNT(lhs_R = term_to_sexp(a, eval)); + if (Rf_isNull(lhs_R)) { + Ureturn R_NilValue; + } // get index - if ( !PL_get_arg( 1, t, a) ) - { REAL_Error("argument access", t); - Ureturn R_NilValue; - } - if ( PL_get_list( a, t, b) && PL_is_pair(t) && PL_get_nil(b) ) { /* [[ operator */ + if (!PL_get_arg(1, t, a)) { + REAL_Error("argument access", t); + Ureturn R_NilValue; + } + if (PL_get_list(a, t, b) && PL_is_pair(t) && + PL_get_nil(b)) { /* [[ operator */ sin = R_Bracket2Symbol; a = t; } else { sin = R_BracketSymbol; // [ operator } - if ( PL_skip_list( a, b, &len ) != PL_LIST) - { Ureturn R_NilValue; } - PROTECT_AND_COUNT(call_R = allocList(len+2)); + if (PL_skip_list(a, b, &len) != PL_LIST) { + Ureturn R_NilValue; + } + PROTECT_AND_COUNT(call_R = allocList(len + 2)); c_R = call_R; SETCAR(c_R, sin); SET_TYPEOF(c_R, LANGSXP); c_R = CDR(c_R); SETCAR(c_R, lhs_R); c_R = CDR(c_R); - if (! old_list_to_sexp( a, c_R, len, FALSE ) ) { + if (!old_list_to_sexp(a, c_R, len, FALSE)) { Ureturn R_NilValue; } SEXP ans; if (eval) { - PROTECT_AND_COUNT( res_R = protected_tryEval(call_R, R_GlobalEnv, &ierror) ); - - if (ierror) - { Ureturn call_R; } + PROTECT_AND_COUNT(res_R = protected_tryEval(call_R, R_GlobalEnv, &ierror)); + + if (ierror) { + Ureturn call_R; + } ans = res_R; } else { ans = call_R; @@ -1199,107 +1105,98 @@ subset_to_sexp( term_t t, bool eval) Ureturn ans; } -static int -set_subset_eval( SEXP symbol, term_t a, SEXP lhs_R, SEXP sexp) -{ +static int set_subset_eval(SEXP symbol, term_t a, SEXP lhs_R, SEXP sexp) { int hadError; SEXP p, call_R, index_R, c_R, sin; term_t f, b; int nprotect = 0; size_t len; - f = PL_new_term_ref( ); - b = PL_new_term_ref( ); - if ( PL_get_list( a, b, f) && PL_is_pair(b) && PL_get_nil(f) ) { /* [[ operator ]] */ + f = PL_new_term_ref(); + b = PL_new_term_ref(); + if (PL_get_list(a, b, f) && PL_is_pair(b) && + PL_get_nil(f)) { /* [[ operator ]] */ sin = R_Bracket2Symbol; a = b; } else { sin = R_BracketSymbol; // [ operator } - if ( PL_skip_list( a, b, &len ) != PL_LIST) - { Ureturn FALSE; } - PROTECT_AND_COUNT(c_R = index_R = allocList(len+1)); + if (PL_skip_list(a, b, &len) != PL_LIST) { + Ureturn FALSE; + } + PROTECT_AND_COUNT(c_R = index_R = allocList(len + 1)); SETCAR(c_R, sin); SET_TYPEOF(c_R, LANGSXP); c_R = CDR(c_R); - if (! old_list_to_sexp( a, c_R, len, TRUE ) ) { + if (!old_list_to_sexp(a, c_R, len, TRUE)) { { Ureturn 0; } } - PROTECT_AND_COUNT(call_R = LCONS(symbol, CONS(lhs_R,index_R))); + PROTECT_AND_COUNT(call_R = LCONS(symbol, CONS(lhs_R, index_R))); SET_TYPEOF(call_R, LANGSXP); - PROTECT_AND_COUNT( p = lang3(install("<-"), call_R, sexp) ); - (void) protected_tryEval(p, R_GlobalEnv, &hadError); + PROTECT_AND_COUNT(p = lang3(install("<-"), call_R, sexp)); + (void)protected_tryEval(p, R_GlobalEnv, &hadError); { Ureturn hadError; } } -static int -set_subset_to_sexp( term_t t, SEXP sexp) -{ +static int set_subset_to_sexp(term_t t, SEXP sexp) { term_t a = PL_new_term_ref(); SEXP lhs_R; int i = 0; size_t dims[256], indexi[256], ndims, index; - int nprotect=0; + int nprotect = 0; - - if ( !PL_get_arg( 1, t, a) ) + if (!PL_get_arg(1, t, a)) return REAL_Error("argument access", t); - if ( !PL_get_arg( 2, t, t) ) - return REAL_Error ("argument access", t); + if (!PL_get_arg(2, t, t)) + return REAL_Error("argument access", t); term_t t0 = PL_copy_term_ref(t); term_t a0 = PL_copy_term_ref(a); while (PL_get_list(a, t, a)) { int64_t j; - if (! PL_get_int64(t, &j) ) { - PROTECT_AND_COUNT( lhs_R = term_to_sexp( t0, FALSE ) ); - return set_subset_eval( R_BracketSymbol, a0, lhs_R, sexp); + if (!PL_get_int64(t, &j)) { + PROTECT_AND_COUNT(lhs_R = term_to_sexp(t0, FALSE)); + return set_subset_eval(R_BracketSymbol, a0, lhs_R, sexp); } indexi[i] = j; i++; } - PROTECT_AND_COUNT( lhs_R = term_to_sexp( t0, TRUE ) ); + PROTECT_AND_COUNT(lhs_R = term_to_sexp(t0, TRUE)); ndims = sexp_rank(lhs_R); sexp_shape(lhs_R, ndims, dims); if (i != ndims) Ureturn FALSE; index = pos_dims(indexi, ndims, dims); - Ureturn sexp_to_S_el( sexp, index, lhs_R); + Ureturn sexp_to_S_el(sexp, index, lhs_R); } - - -static int -pl_to_unary(const char *s, term_t t, SEXP *ansP) -{ - int nprotect=0; - if (!PL_get_arg( 1, t , t )) { +static int pl_to_unary(const char *s, term_t t, SEXP *ansP) { + int nprotect = 0; + if (!PL_get_arg(1, t, t)) { Ureturn FALSE; } - PROTECT_AND_COUNT( *ansP = term_to_sexp(t, FALSE) ); - PROTECT_AND_COUNT( *ansP = lang2( install(s), *ansP) ); + PROTECT_AND_COUNT(*ansP = term_to_sexp(t, FALSE)); + PROTECT_AND_COUNT(*ansP = lang2(install(s), *ansP)); Ureturn TRUE; } -static int -pl_to_binary(const char *s, term_t t, term_t tmp, SEXP *ansP) -{ - int nprotect=0; +static int pl_to_binary(const char *s, term_t t, term_t tmp, SEXP *ansP) { + int nprotect = 0; SEXP sexp; - if (!PL_get_arg( 2, t , tmp )) { + if (!PL_get_arg(2, t, tmp)) { return FALSE; } - if (!PL_get_arg( 1, t , t )) { + if (!PL_get_arg(1, t, t)) { return FALSE; } - PROTECT_AND_COUNT( *ansP = term_to_sexp(t, FALSE) ); - PROTECT_AND_COUNT( sexp = term_to_sexp(tmp, FALSE) ); - PROTECT_AND_COUNT( *ansP = lang3( install(s), *ansP, sexp) ); + PROTECT_AND_COUNT(*ansP = term_to_sexp(t, FALSE)); + PROTECT_AND_COUNT(sexp = term_to_sexp(tmp, FALSE)); + PROTECT_AND_COUNT(*ansP = lang3(install(s), *ansP, sexp)); Ureturn TRUE; } @@ -1313,309 +1210,265 @@ pl_to_binary(const char *s, term_t t, term_t tmp, SEXP *ansP) * * @return whether it succeeds or fails. */ -static SEXP - ( term_to_sexp( term_t t, bool eval) ) -{ +static SEXP(term_to_sexp(term_t t, bool eval)) { int nprotect = 0; SEXP ans = R_NilValue; int objtype; - term_t tmp = PL_copy_term_ref( t ); + term_t tmp = PL_copy_term_ref(t); int rc; - objtype = REAL_term_type(tmp, 0); if (objtype & PL_R_VECTOR) { - PROTECT_AND_COUNT(ans = list_to_sexp( t, objtype ) ); - rc = ( ans != R_NilValue ) ; + PROTECT_AND_COUNT(ans = list_to_sexp(t, objtype)); + rc = (ans != R_NilValue); } else - switch(objtype) - { - /// free variable is translated to an argument that can take - /// any value, eg: - /// `[_,2]` corresponds to `[,2]` in R selectors - /// `X ~ _` corresponds tp `X ~ .` in R formulas + switch (objtype) { + /// free variable is translated to an argument that can take + /// any value, eg: + /// `[_,2]` corresponds to `[,2]` in R selectors + /// `X ~ _` corresponds tp `X ~ .` in R formulas case PL_R_VARIABLE: ans = R_MissingArg; rc = true; break; - /// +'Atom' or "string" to R 'string' or CHARACTER object - /// - /// real suggest using "..." notation for strings, - /// but `string` will work as well. - /// - /// @deprecated +atom is an hack, and should be avoided + /// +'Atom' or "string" to R 'string' or CHARACTER object + /// + /// real suggest using "..." notation for strings, + /// but `string` will work as well. + /// + /// @deprecated +atom is an hack, and should be avoided case PL_R_PLUS: case PL_R_CHARS: PROTECT_AND_COUNT(ans = NEW_CHARACTER(1)); - rc = term_to_S_el( t, PL_R_CHARS, 0, ans); + rc = term_to_S_el(t, PL_R_CHARS, 0, ans); break; - /// Prolog -atom or -"symbol" matches to R symbol - /// - /// @deprecated not needed any longer + /// Prolog -atom or -"symbol" matches to R symbol + /// + /// @deprecated not needed any longer case PL_R_PSYMBOL: - rc = PL_get_arg( 1, t , t ); + rc = PL_get_arg(1, t, t); - /// Prolog atom matches to R symbol - /// - /// atoms can be evaluated - case PL_R_SYMBOL: - { char *s = NULL; + /// Prolog atom matches to R symbol + /// + /// atoms can be evaluated + case PL_R_SYMBOL: { + char *s = NULL; - if ((rc = PL_get_chars(t, &s, CVT_ATOM|CVT_STRING|BUF_DISCARDABLE|REP_UTF8)) ) - { - if (eval) { - PROTECT_AND_COUNT( ans = findVar(Rf_install(s), R_GlobalEnv) ); - } else { - PROTECT_AND_COUNT(ans = Rf_install(s) ); //NEW_CHARACTER(1)); - // if ( ! term_to_S_el( t, PL_R_CHARS, 0, ans) ) - //Ureturn 0; - } - if (ans == R_UnboundValue) { - rc = false; - } - } + if ((rc = PL_get_chars(t, &s, CVT_ATOM | CVT_STRING | BUF_DISCARDABLE | + REP_UTF8))) { + if (eval) { + PROTECT_AND_COUNT(ans = findVar(Rf_install(s), R_GlobalEnv)); + } else { + PROTECT_AND_COUNT(ans = Rf_install(s)); // NEW_CHARACTER(1)); + // if ( ! term_to_S_el( t, PL_R_CHARS, 0, ans) ) + // Ureturn 0; + } + if (ans == R_UnboundValue) { + rc = false; + } } - break; + } break; - /// YAP supports . as an infix operator, so a.b can be converted into R's 'a.b' - /// + /// YAP supports . as an infix operator, so a.b can be converted into R's + /// 'a.b' + /// case PL_R_DOT: rc = merge_dots(t); - PROTECT_AND_COUNT( ans = term_to_sexp( t, eval ) ); + PROTECT_AND_COUNT(ans = term_to_sexp(t, eval)); break; - /// integer basic type + /// integer basic type case PL_R_INTEGER: PROTECT_AND_COUNT(ans = NEW_INTEGER(1)); - rc = term_to_S_el( t, PL_R_INTEGER, 0, ans); + rc = term_to_S_el(t, PL_R_INTEGER, 0, ans); break; - /// float basic type + /// float basic type case PL_R_FLOAT: PROTECT_AND_COUNT(ans = NEW_NUMERIC(1)); - rc = term_to_S_el( t, PL_R_FLOAT, 0, ans); + rc = term_to_S_el(t, PL_R_FLOAT, 0, ans); break; - /// boolean in real is true or 'TRUE', false or 'FALSE' + /// boolean in real is true or 'TRUE', false or 'FALSE' case PL_R_BOOL: PROTECT_AND_COUNT(ans = NEW_LOGICAL(1)); - rc = term_to_S_el( t, PL_R_BOOL, 0, ans); + rc = term_to_S_el(t, PL_R_BOOL, 0, ans); break; - /// X$E access a named attribute from a list (ie. an attribute) - case PL_R_LISTEL: - { - rc = listEl_to_sexp( t, &ans); - } - break; - /// O@S access a slot from an object - case PL_R_SLOT: - { - rc = slot_to_sexp( t, &ans); - } - break; + /// X$E access a named attribute from a list (ie. an attribute) + case PL_R_LISTEL: { + rc = listEl_to_sexp(t, &ans); + } break; + /// O@S access a slot from an object + case PL_R_SLOT: { + rc = slot_to_sexp(t, &ans); + } break; - /// [...] selects a subset from a vector - case PL_R_SUBSET: - { - ans = subset_to_sexp( t, eval); - rc = (ans != R_NilValue && ans != R_UnboundValue); - } - break; + /// [...] selects a subset from a vector + case PL_R_SUBSET: { + ans = subset_to_sexp(t, eval); + rc = (ans != R_NilValue && ans != R_UnboundValue); + } break; - /// = applied in code definition, - /// - /// currently never evaluated - case PL_R_EQUAL: - { - tmp = PL_new_term_ref(); - rc = pl_to_binary( "=", t, tmp, &ans ); - } - break; + /// = applied in code definition, + /// + /// currently never evaluated + case PL_R_EQUAL: { + tmp = PL_new_term_ref(); + rc = pl_to_binary("=", t, tmp, &ans); + } break; - /// function call or closure - case PL_R_CALL: - { - PROTECT_AND_COUNT( ans = pl_to_func( t, eval) ); - if(ans && !Rf_isNull(ans)) { - rc = true; + /// function call or closure + case PL_R_CALL: { + PROTECT_AND_COUNT(ans = pl_to_func(t, eval)); + if (ans && !Rf_isNull(ans)) { + rc = true; } else { rc = false; } + } + + break; + + /// fuction definition (yes, you can write R code as a Prolog term) + case PL_R_DEFUN: { + rc = pl_to_defun(t, &ans); + } break; + + /// (X -> Y) + + case PL_R_IF: { + term_t tcond = PL_new_term_ref(); + SEXP cond, expr; + + if ((rc = PL_get_arg(1, t, tcond))) { + PROTECT_AND_COUNT(cond = term_to_sexp(tcond, FALSE)); } - - break; + if (rc && PL_get_arg(2, t, t) && pl_to_body(t, &expr)) { + PROTECT_AND_COUNT(ans = LCONS(cond, expr)); + } + } break; - /// fuction definition (yes, you can write R code as a Prolog term) - case PL_R_DEFUN: - { - rc = pl_to_defun( t, &ans ); - } - break; + /// if(Then, Else) - /// (X -> Y) - - case PL_R_IF: - { - term_t tcond = PL_new_term_ref(); - SEXP cond, expr; - - if ( (rc = - PL_get_arg( 1, t, tcond )) ) { - PROTECT_AND_COUNT( cond = term_to_sexp( tcond, FALSE ) ); - } - if (rc && - PL_get_arg( 2, t, t ) && - pl_to_body( t, &expr ) ) { - PROTECT_AND_COUNT(ans = LCONS( cond, expr )); - } + case PL_R_IF_ELSE: { + term_t tcond = PL_new_term_ref(); + SEXP cond, sthen, selse; + if ((rc = PL_get_arg(1, t, tcond))) { + PROTECT_AND_COUNT(cond = term_to_sexp(tcond, FALSE)); + if (PL_get_arg(2, t, tcond) && pl_to_body(tcond, &sthen) && + PL_get_arg(3, t, t) && pl_to_body(t, &selse)) { + PROTECT_AND_COUNT(ans = lang4(install("if"), cond, sthen, selse)); + } } break; - /// if(Then, Else) + /// in(Cond, Expr) + case PL_R_IN: { + term_t tcond = PL_new_term_ref(); + SEXP cond, expr; - case PL_R_IF_ELSE: - { - term_t tcond = PL_new_term_ref(); - SEXP cond, sthen, selse; - if ( (rc = - PL_get_arg( 1, t, tcond )) ) { - PROTECT_AND_COUNT( cond = term_to_sexp( tcond, FALSE ) ); - if ( PL_get_arg( 2, t, tcond ) && - pl_to_body( tcond, &sthen ) && - PL_get_arg( 3, t, t ) && - pl_to_body( t, &selse ) - ) { - PROTECT_AND_COUNT(ans = lang4(install("if"), cond, sthen, selse)); + if ((rc = PL_get_arg(1, t, tcond))) { - } + PROTECT_AND_COUNT(cond = term_to_sexp(tcond, FALSE)); + if ((rc = PL_get_arg(2, t, t))) { + PROTECT_AND_COUNT(expr = term_to_sexp(t, FALSE)); + PROTECT_AND_COUNT(ans = lang3(install("in"), cond, expr)); + } } break; - /// in(Cond, Expr) - case PL_R_IN: - { - term_t tcond = PL_new_term_ref(); - SEXP cond, expr; - - if (( rc = - PL_get_arg( 1, t, tcond ) )) { - - PROTECT_AND_COUNT( cond = term_to_sexp( tcond, FALSE ) ); - if (( rc = PL_get_arg( 2, t, t ))) { - PROTECT_AND_COUNT( expr = term_to_sexp( t, FALSE ) ); - PROTECT_AND_COUNT(ans = lang3(install("in"), cond, expr)); - } - } - break; - - /// while(Cond, Expr) - case PL_R_WHILE: - { - term_t tcond = PL_new_term_ref(); - SEXP cond, expr; - PROTECT_AND_COUNT( cond = term_to_sexp( tcond, FALSE ) ); - if (( rc = PL_get_arg( 2, t, t ))) { - PROTECT_AND_COUNT( expr = term_to_sexp( t, FALSE ) ); - PROTECT_AND_COUNT(ans = lang3(install("while"), cond, expr)); - } - } - } + /// while(Cond, Expr) + case PL_R_WHILE: { + term_t tcond = PL_new_term_ref(); + SEXP cond, expr; + PROTECT_AND_COUNT(cond = term_to_sexp(tcond, FALSE)); + if ((rc = PL_get_arg(2, t, t))) { + PROTECT_AND_COUNT(expr = term_to_sexp(t, FALSE)); + PROTECT_AND_COUNT(ans = lang3(install("while"), cond, expr)); } - break; + } + } + } break; - /// reepeat( Expr) - case PL_R_REPEAT: - { - SEXP expr; + /// reepeat( Expr) + case PL_R_REPEAT: { + SEXP expr; - if ( (rc = PL_get_arg( 1, t, t ) && - pl_to_body( t, &expr ) ) ) { - PROTECT_AND_COUNT(ans = lang2(install("repeat"), expr)); - } + if ((rc = PL_get_arg(1, t, t) && pl_to_body(t, &expr))) { + PROTECT_AND_COUNT(ans = lang2(install("repeat"), expr)); } - break; + } break; - /// break - case PL_R_BREAK: - { - PROTECT_AND_COUNT(ans = lang1(install("break"))); - } + /// break + case PL_R_BREAK: { + PROTECT_AND_COUNT(ans = lang1(install("break"))); + } rc = true; break; - /// next - case PL_R_NEXT: - { - PROTECT_AND_COUNT(ans = lang1(install("next"))); - } + /// next + case PL_R_NEXT: { + PROTECT_AND_COUNT(ans = lang1(install("next"))); + } rc = true; break; - - // binary formula X ~ _ - case PL_R_FORMULA: - { - if ((rc = PL_get_arg( 2, t , tmp ))) { - if (PL_is_variable( tmp )) { - if (( rc = - PL_get_arg( 1, t , t ) )) { - PROTECT_AND_COUNT(ans = lang3( install("~"), *&ans, install(".")) ); - } - } else { - rc = pl_to_binary( "~", t, tmp, &ans ); - } - } + // binary formula X ~ _ + case PL_R_FORMULA: { + if ((rc = PL_get_arg(2, t, tmp))) { + if (PL_is_variable(tmp)) { + if ((rc = PL_get_arg(1, t, t))) { + PROTECT_AND_COUNT(ans = lang3(install("~"), *&ans, install("."))); + } + } else { + rc = pl_to_binary("~", t, tmp, &ans); + } } - break; + } break; - // unary formula ~ _ + // unary formula ~ _ case PL_R_RFORMULA: - if ((rc = PL_get_arg( 1, t , tmp ))) { - if (PL_is_variable( tmp )) { - PROTECT_AND_COUNT( ans = term_to_sexp(t, FALSE) ); - PROTECT_AND_COUNT(ans = lang2( install("~"), install(".")) ); - } + if ((rc = PL_get_arg(1, t, tmp))) { + if (PL_is_variable(tmp)) { + PROTECT_AND_COUNT(ans = term_to_sexp(t, FALSE)); + PROTECT_AND_COUNT(ans = lang2(install("~"), install("."))); + } } else { - rc = pl_to_unary( "~", tmp, &ans ); + rc = pl_to_unary("~", tmp, &ans); } break; - case PL_R_QUOTE: - { - rc = PL_get_arg(1, t, t); - PROTECT_AND_COUNT( ans = term_to_sexp(t, TRUE) ); - } - break; + case PL_R_QUOTE: { + rc = PL_get_arg(1, t, t); + PROTECT_AND_COUNT(ans = term_to_sexp(t, TRUE)); + } break; - case PL_R_OUTER: - rc = pl_to_binary( "%o%", t, tmp, &ans ); - break; - - case PL_R_INNER: - { - rc = pl_to_binary( "%i%", t, tmp, &ans ); - } + case PL_R_OUTER: + rc = pl_to_binary("%o%", t, tmp, &ans); break; + case PL_R_INNER: { + rc = pl_to_binary("%i%", t, tmp, &ans); + } break; + default: assert(0); rc = false; } - PL_reset_term_refs( tmp ); + PL_reset_term_refs(tmp); Ureturn ans; } // // Prolog to SEXP // -static int -bind_sexp(term_t t, SEXP sexp) -{ int nprotect = 0; +static int bind_sexp(term_t t, SEXP sexp) { + int nprotect = 0; int objtype; objtype = REAL_term_type(t, 0); @@ -1624,159 +1477,146 @@ bind_sexp(term_t t, SEXP sexp) return FALSE; } - switch(objtype) - { - case PL_R_VARIABLE: - break; - case PL_R_BOOL: - { - int b; - size_t n; - return sexp_rank(sexp) == 1 && - sexp_shape(sexp, 0, &n) && - n == 1 && - TYPEOF(sexp) == LGLSXP && - PL_get_bool(t,&b) && - b == LOGICAL(sexp)[0]; - } - - case PL_R_FLOAT: - { - double dbl; - size_t n; - return sexp_rank(sexp) == 1 && - sexp_shape(sexp, 0, &n) && - n == 1 && - TYPEOF(sexp) == REALSXP && - PL_get_float(t, &dbl) && - dbl == REAL(sexp)[0]; - } - - case PL_R_INTEGER: - { - size_t n; - int64_t i; - return sexp_rank(sexp) == 1 && - sexp_shape(sexp, 0, &n) && - n == 1 && - TYPEOF(sexp) == INTSXP && - PL_get_int64(t, &i) && - i == INTEGER(sexp)[0]; - } - - case PL_R_COMPLEX: - case PL_R_PLUS: - case PL_R_CHARS: + switch (objtype) { + case PL_R_VARIABLE: + break; + case PL_R_BOOL: { + int b; + size_t n; + return sexp_rank(sexp) == 1 && sexp_shape(sexp, 0, &n) && n == 1 && + TYPEOF(sexp) == LGLSXP && PL_get_bool(t, &b) && + b == LOGICAL(sexp)[0]; + } + + case PL_R_FLOAT: { + double dbl; + size_t n; + return sexp_rank(sexp) == 1 && sexp_shape(sexp, 0, &n) && n == 1 && + TYPEOF(sexp) == REALSXP && PL_get_float(t, &dbl) && + dbl == REAL(sexp)[0]; + } + + case PL_R_INTEGER: { + size_t n; + int64_t i; + return sexp_rank(sexp) == 1 && sexp_shape(sexp, 0, &n) && n == 1 && + TYPEOF(sexp) == INTSXP && PL_get_int64(t, &i) && + i == INTEGER(sexp)[0]; + } + + case PL_R_COMPLEX: + case PL_R_PLUS: + case PL_R_CHARS: + return FALSE; + case PL_R_CALL: { + // look only for attributes + int arity; + atom_t name; + SEXP tmp_R; + const char *s; + if (!PL_get_name_arity(t, &name, &arity) || arity != 1) { return FALSE; - case PL_R_CALL: - { - // look only for attributes - int arity; - atom_t name; - SEXP tmp_R; - const char *s; - if ( !PL_get_name_arity(t, &name, &arity) || - arity != 1) { - return FALSE; - } - if ( !( s = PL_atom_chars(name) ) ) - { - return FALSE; - } - if ( !PL_get_arg(1, t, t)) { - return FALSE; - } - PROTECT_AND_COUNT( tmp_R = term_to_sexp(t, TRUE) ); - if (Rf_isNull(tmp_R)) - { Ureturn FALSE; } - // these two are tricky... - if (sexp_rank(tmp_R) == 1) { - if (!strcmp(s,"rownames")) { - SEXP dimnames, ans; - PROTECT_AND_COUNT(dimnames = allocVector(VECSXP, 1)); - if (!Rf_isNull(sexp)) { - size_t i, n = Rf_length(sexp); - PROTECT_AND_COUNT(ans = allocVector(STRSXP, n)); - for (i=0; i Prolog * *******************************/ - - -static int -sexp_to_pl(term_t t, SEXP s) -{ int rank = sexp_rank(s); +static int sexp_to_pl(term_t t, SEXP s) { + int rank = sexp_rank(s); size_t shape[256]; - if ( rank > 2 ) + if (rank > 2) return REAL_Error("multi-dimensional arrays unsupported", t); sexp_shape(s, rank, shape); - switch (rank) - { case 1: - { int i; + switch (rank) { + case 1: { + int i; - switch (TYPEOF(s)) - { case NILSXP: - PL_put_nil(t); - return TRUE; - case SYMSXP: - /* FIXME: take it as as an atom */ - s = PRINTNAME( s ); - if (TYPEOF(s) == STRSXP) { - size_t shape; + switch (TYPEOF(s)) { + case NILSXP: + PL_put_nil(t); + return TRUE; + case SYMSXP: + /* FIXME: take it as as an atom */ + s = PRINTNAME(s); + if (TYPEOF(s) == STRSXP) { + size_t shape; - if (sexp_rank(s) > 1) - return FALSE; - sexp_shape(s, 1, &shape); - if (shape != 1) - return FALSE; - return - PL_unify_chars(t, PL_ATOM|REP_UTF8, -1, CHAR(CHARACTER_DATA(s)[0]) ); - } - return FALSE; - case REALSXP: - { term_t head = PL_new_term_ref(); - term_t tail = PL_new_term_ref(); - - PL_put_nil(tail); - for (i = shape[0]-1; i>=0; i--) - { if ( !PL_put_float(head, NUMERIC_DATA(s)[i]) || - !PL_cons_list(tail, head, tail) ) - return FALSE; - } - PL_put_term(t, tail); - break; - } - case INTSXP: - { term_t head = PL_new_term_ref(); - term_t tail = PL_new_term_ref(); - - PL_put_nil(tail); - for (i = shape[0]-1; i>=0; i--) - { if ( !PL_put_int64(head, INTEGER_DATA(s)[i]) || - !PL_cons_list(tail, head, tail) ) - return FALSE; - } - PL_put_term(t, tail); - break; - } - case LGLSXP: - { term_t head = PL_new_term_ref(); - term_t tail = PL_new_term_ref(); - - PL_put_nil(tail); - for (i = shape[0]-1; i>=0; i--) - { if ( !PL_put_variable(head) || /* TBD: All PL_put_bool() */ - !PL_unify_bool(head, LOGICAL_DATA(s)[i]) || - !PL_cons_list(tail, head, tail) ) - return FALSE; - } - PL_put_term(t, tail); - break; - } - case CPLXSXP: - { term_t headr = PL_new_term_ref(); - term_t headi = PL_new_term_ref(); - term_t tail = PL_new_term_ref(); - - PL_put_nil(tail); - for (i = shape[0]-1; i>=0; i--) { - if ( COMPLEX_DATA(s)[i].i >= 0) { - if ( !PL_put_float(headr, COMPLEX_DATA(s)[i].r) || - !PL_put_float(headi, COMPLEX_DATA(s)[i].i) || - !PL_cons_functor(headi, FUNCTOR_i1, headi) || - !PL_cons_functor(headr, FUNCTOR_plus2, headr, headi) || - !PL_cons_list(tail, headr, tail) ) - return FALSE; - } else if ( !PL_put_float(headr, COMPLEX_DATA(s)[i].r) || - !PL_put_float(headi, -COMPLEX_DATA(s)[i].i) || - !PL_cons_functor(headi, FUNCTOR_i1, headi) || - !PL_cons_functor(headr, FUNCTOR_minus2, headr, headi) || - !PL_cons_list(tail, headr, tail) ) - return FALSE; - } - PL_put_term(t, tail); - break; - } - case VECSXP: - { SEXP names = GET_NAMES(s); - term_t av = PL_new_term_refs(2); - term_t head = PL_new_term_ref(); - term_t tail = PL_new_term_ref(); - - PL_put_nil(tail); - for (i = LENGTH(s)-1; i>=0; i--) - { SEXP elem = VECTOR_ELT(s,i) ; - - if (names == R_NilValue || - STRING_ELT(names,i) == R_NilValue) { - // PL_unify(av+0,av+1); - if (!sexp_to_pl(av, elem) || - // !PL_cons_functor_v(head, FUNCTOR_equal2, av) || - !PL_cons_list(tail, av, tail) ) - return FALSE; - } - else if ( !PL_put_atom_chars(av+0, CHAR(STRING_ELT(names,i))) || - !sexp_to_pl(av+1, elem) || - !PL_cons_functor_v(head, FUNCTOR_equal2, av) || - !PL_cons_list(tail, head, tail) ) - return FALSE; - } - PL_put_term(t, tail); - break; - } - case STRSXP: - { term_t tail = PL_new_term_ref(); - - PL_put_nil(tail); - for (i = shape[0]-1; i>=0; i--) - { const char *chars = CHAR(CHARACTER_DATA(s)[i]); - term_t head = PL_new_term_ref(); - // use string to communicate with outside world - if ( !PL_unify_chars(head, PL_STRING|REP_UTF8, -1, chars) || - !PL_cons_list(tail, head, tail) ) - return FALSE; - } - PL_put_term(t, tail); - break; - } - default: - { char buf[256]; - snprintf(buf, 255,"Unsupported r-type, with id: %d \n", TYPEOF(s) ); - return REAL_Error(buf, t); - } - } - if ( shape[0] == 1 ) - { if ( !PL_get_arg(1, t, t) ) /* Just return the head */ - REAL_Error ("argument access", t); - } - break; - } - case 2: - { SEXP adims = getAttrib(s, R_DimSymbol); - int nrows = INTEGER(adims)[0]; - int ncols = INTEGER(adims)[1]; - term_t tail = PL_new_term_ref(); - term_t nest_tail = PL_new_term_ref(); - term_t nest_head = PL_new_term_ref(); - int i,j,c; - - PL_put_nil(tail); - - for (i = (nrows-1); i > -1 ; i--) - { PL_put_nil(nest_tail); - for (j=(ncols-1); j > -1 ; j--) - { c = (j*nrows)+i; - // { size_t index = col_i*len + row_i; - - switch (TYPEOF(s)) - { case REALSXP: - if ( !PL_put_float(nest_head, NUMERIC_DATA(s)[c]) ) - return FALSE; - break; - case INTSXP: - if ( !PL_put_int64(nest_head, INTEGER_DATA(s)[c]) ) - return FALSE; - break; - case STRSXP: - nest_head = PL_new_term_ref(); - if ( !PL_unify_chars(nest_head, PL_STRING|REP_UTF8, -1, CHAR(CHARACTER_DATA(s)[c])) ) - return FALSE; - break; - case LGLSXP: - if ( !PL_put_variable(nest_head) || - !PL_unify_bool(nest_head, LOGICAL_DATA(s)[c]) ) - return FALSE; - break; - } - if ( !PL_cons_list(nest_tail, nest_head, nest_tail) ) - return FALSE; - } - if ( !PL_cons_list(tail, nest_tail, tail) ) - return FALSE; - } - - PL_put_term(t, tail); - break; + if (sexp_rank(s) > 1) + return FALSE; + sexp_shape(s, 1, &shape); + if (shape != 1) + return FALSE; + return PL_unify_chars(t, PL_ATOM | REP_UTF8, -1, + CHAR(CHARACTER_DATA(s)[0])); } - default: - assert(0); + return FALSE; + case REALSXP: { + term_t head = PL_new_term_ref(); + term_t tail = PL_new_term_ref(); + + PL_put_nil(tail); + for (i = shape[0] - 1; i >= 0; i--) { + if (!PL_put_float(head, NUMERIC_DATA(s)[i]) || + !PL_cons_list(tail, head, tail)) + return FALSE; + } + PL_put_term(t, tail); + break; } + case INTSXP: { + term_t head = PL_new_term_ref(); + term_t tail = PL_new_term_ref(); + + PL_put_nil(tail); + for (i = shape[0] - 1; i >= 0; i--) { + if (!PL_put_int64(head, INTEGER_DATA(s)[i]) || + !PL_cons_list(tail, head, tail)) + return FALSE; + } + PL_put_term(t, tail); + break; + } + case LGLSXP: { + term_t head = PL_new_term_ref(); + term_t tail = PL_new_term_ref(); + + PL_put_nil(tail); + for (i = shape[0] - 1; i >= 0; i--) { + if (!PL_put_variable(head) || /* TBD: All PL_put_bool() */ + !PL_unify_bool(head, LOGICAL_DATA(s)[i]) || + !PL_cons_list(tail, head, tail)) + return FALSE; + } + PL_put_term(t, tail); + break; + } + case CPLXSXP: { + term_t headr = PL_new_term_ref(); + term_t headi = PL_new_term_ref(); + term_t tail = PL_new_term_ref(); + + PL_put_nil(tail); + for (i = shape[0] - 1; i >= 0; i--) { + if (COMPLEX_DATA(s)[i].i >= 0) { + if (!PL_put_float(headr, COMPLEX_DATA(s)[i].r) || + !PL_put_float(headi, COMPLEX_DATA(s)[i].i) || + !PL_cons_functor(headi, FUNCTOR_i1, headi) || + !PL_cons_functor(headr, FUNCTOR_plus2, headr, headi) || + !PL_cons_list(tail, headr, tail)) + return FALSE; + } else if (!PL_put_float(headr, COMPLEX_DATA(s)[i].r) || + !PL_put_float(headi, -COMPLEX_DATA(s)[i].i) || + !PL_cons_functor(headi, FUNCTOR_i1, headi) || + !PL_cons_functor(headr, FUNCTOR_minus2, headr, headi) || + !PL_cons_list(tail, headr, tail)) + return FALSE; + } + PL_put_term(t, tail); + break; + } + case VECSXP: { + SEXP names = GET_NAMES(s); + term_t av = PL_new_term_refs(2); + term_t head = PL_new_term_ref(); + term_t tail = PL_new_term_ref(); + + PL_put_nil(tail); + for (i = LENGTH(s) - 1; i >= 0; i--) { + SEXP elem = VECTOR_ELT(s, i); + + if (names == R_NilValue || STRING_ELT(names, i) == R_NilValue) { + // PL_unify(av+0,av+1); + if (!sexp_to_pl(av, elem) || + // !PL_cons_functor_v(head, FUNCTOR_equal2, av) || + !PL_cons_list(tail, av, tail)) + return FALSE; + } else if (!PL_put_atom_chars(av + 0, CHAR(STRING_ELT(names, i))) || + !sexp_to_pl(av + 1, elem) || + !PL_cons_functor_v(head, FUNCTOR_equal2, av) || + !PL_cons_list(tail, head, tail)) + return FALSE; + } + PL_put_term(t, tail); + break; + } + case STRSXP: { + term_t tail = PL_new_term_ref(); + + PL_put_nil(tail); + for (i = shape[0] - 1; i >= 0; i--) { + const char *chars = CHAR(CHARACTER_DATA(s)[i]); + term_t head = PL_new_term_ref(); + // use string to communicate with outside world + if (!PL_unify_chars(head, PL_STRING | REP_UTF8, -1, chars) || + !PL_cons_list(tail, head, tail)) + return FALSE; + } + PL_put_term(t, tail); + break; + } + default: { + char buf[256]; + snprintf(buf, 255, "Unsupported r-type, with id: %d \n", TYPEOF(s)); + return REAL_Error(buf, t); + } + } + if (shape[0] == 1) { + if (!PL_get_arg(1, t, t)) /* Just return the head */ + REAL_Error("argument access", t); + } + break; + } + case 2: { + SEXP adims = getAttrib(s, R_DimSymbol); + int nrows = INTEGER(adims)[0]; + int ncols = INTEGER(adims)[1]; + term_t tail = PL_new_term_ref(); + term_t nest_tail = PL_new_term_ref(); + term_t nest_head = PL_new_term_ref(); + int i, j, c; + + PL_put_nil(tail); + + for (i = (nrows - 1); i > -1; i--) { + PL_put_nil(nest_tail); + for (j = (ncols - 1); j > -1; j--) { + c = (j * nrows) + i; + // { size_t index = col_i*len + row_i; + + switch (TYPEOF(s)) { + case REALSXP: + if (!PL_put_float(nest_head, NUMERIC_DATA(s)[c])) + return FALSE; + break; + case INTSXP: + if (!PL_put_int64(nest_head, INTEGER_DATA(s)[c])) + return FALSE; + break; + case STRSXP: + nest_head = PL_new_term_ref(); + if (!PL_unify_chars(nest_head, PL_STRING | REP_UTF8, -1, + CHAR(CHARACTER_DATA(s)[c]))) + return FALSE; + break; + case LGLSXP: + if (!PL_put_variable(nest_head) || + !PL_unify_bool(nest_head, LOGICAL_DATA(s)[c])) + return FALSE; + break; + } + if (!PL_cons_list(nest_tail, nest_head, nest_tail)) + return FALSE; + } + if (!PL_cons_list(tail, nest_tail, tail)) + return FALSE; + } + + PL_put_term(t, tail); + break; + } + default: + assert(0); + } return TRUE; } @@ -2028,24 +1863,22 @@ sexp_to_pl(term_t t, SEXP s) * START/END * *******************************/ -static foreign_t -init_R(void) -{ int argc = 2; - char * argv[] = {"R" , "--slave","--vanilla"}; +static foreign_t init_R(void) { + int argc = 2; + char *argv[] = {"R", "--slave", "--vanilla"}; - // Rf_endEmbeddedR(0); +// Rf_endEmbeddedR(0); #if R_SIGNAL_HANDLERS - R_SignalHandlers=0; + R_SignalHandlers = 0; #endif Rf_initEmbeddedR(argc, argv); R_CStackLimit = -1; return TRUE; } -static foreign_t -stop_R(void) -{ Rf_endEmbeddedR(0); +static foreign_t stop_R(void) { + Rf_endEmbeddedR(0); R_dot_Last(); R_RunExitFinalizers(); R_gc(); @@ -2053,73 +1886,72 @@ stop_R(void) return TRUE; } - /******************************* * EXECUTE COMMAND * *******************************/ -static SEXP -process_expression(const char * expression) -{ SEXP e, tmp, val; +static SEXP process_expression(const char *expression) { + SEXP e, tmp, val; int hadError; ParseStatus status; - int nprotect=0; + int nprotect = 0; // PROTECT_AND_COUNT(tmp = mkString(expression)); - PROTECT_AND_COUNT( tmp = ScalarString(mkCharCE(expression, CE_UTF8)) ); - PROTECT_AND_COUNT( e = R_ParseVector(tmp, 1, &status, R_NilValue) ); - if (status != PARSE_OK) - { - Sdprintf("Error: %d, in parsing R expression.\n", status ); - /* do not continue with protected_tryEval() */ - /* PL_unify_term(except, PL_FUNCTOR_CHARS, "r_expression_syntax_error", 2, PL_CHARS, expression, PL_R_INTEGER, status ); */ - /*FIXME: return the expression too (as atom) */ - /* PL_FUNCTOR_CHARS, "r_expression_syntax_error", 2, PL_CHARS, "atom", PL_TERM, to; */ - /* return PL_raise_exception(except); */ - Ureturn NULL; - } + PROTECT_AND_COUNT(tmp = ScalarString(mkCharCE(expression, CE_UTF8))); + PROTECT_AND_COUNT(e = R_ParseVector(tmp, 1, &status, R_NilValue)); + if (status != PARSE_OK) { + Sdprintf("Error: %d, in parsing R expression.\n", status); + /* do not continue with protected_tryEval() */ + /* PL_unify_term(except, PL_FUNCTOR_CHARS, "r_expression_syntax_error", 2, + * PL_CHARS, expression, PL_R_INTEGER, status ); */ + /*FIXME: return the expression too (as atom) */ + /* PL_FUNCTOR_CHARS, "r_expression_syntax_error", 2, PL_CHARS, "atom", + * PL_TERM, to; */ + /* return PL_raise_exception(except); */ + Ureturn NULL; + } /* FIXME: Check status (nicos: it seems to be always 1 though? */ - PROTECT_AND_COUNT(val = protected_tryEval(VECTOR_ELT(e, 0), R_GlobalEnv, &hadError)); - if ( !hadError ) - { Ureturn val; } + PROTECT_AND_COUNT( + val = protected_tryEval(VECTOR_ELT(e, 0), R_GlobalEnv, &hadError)); + if (!hadError) { + Ureturn val; + } { Ureturn NULL; } } -static foreign_t -send_R_command(term_t cmd) -{ char *s = NULL; +static foreign_t send_R_command(term_t cmd) { + char *s = NULL; term_t except = PL_new_term_ref(); - if ( PL_get_chars(cmd, &s, CVT_ALL|REP_UTF8|BUF_MALLOC) ) - { if ( process_expression(s) ) { - PL_free(s); - return TRUE; - } + if (PL_get_chars(cmd, &s, CVT_ALL | REP_UTF8 | BUF_MALLOC)) { + if (process_expression(s)) { PL_free(s); - if( PL_unify_term(except, PL_FUNCTOR_CHARS, "real_error", 1, PL_CHARS, "correspondence") ) - return PL_raise_exception(except) ; - return FALSE; + return TRUE; } - Sdprintf("Error in PL_get_chars for %s\n", s); /* FIXME: Exception */ + PL_free(s); + if (PL_unify_term(except, PL_FUNCTOR_CHARS, "real_error", 1, PL_CHARS, + "correspondence")) + return PL_raise_exception(except); + return FALSE; + } + Sdprintf("Error in PL_get_chars for %s\n", s); /* FIXME: Exception */ return FALSE; } // fast copy of a Prolog vector to R -static foreign_t -send_c_vector(term_t tvec, term_t tout) -{ char *s; +static foreign_t send_c_vector(term_t tvec, term_t tout) { + char *s = NULL; int arity, i; atom_t name; term_t targ = PL_new_term_ref(); - SEXP rho = R_GlobalEnv, ans; + SEXP rho = R_GlobalEnv, ans; int nprotect = 0; - if ( !PL_get_name_arity(tvec, &name, &arity) || - arity <= 0) { + if (!PL_get_name_arity(tvec, &name, &arity) || arity <= 0) { return FALSE; } - if ( !PL_get_atom_chars(tout, &s) ) { + if (!PL_get_atom_chars(tout, &s)) { return FALSE; } _PL_get_arg(1, tvec, targ); @@ -2127,12 +1959,12 @@ send_c_vector(term_t tvec, term_t tout) int ints = TRUE; for (i = 0; i < arity; i++) { - _PL_get_arg(i+1, tvec, targ); + _PL_get_arg(i + 1, tvec, targ); if (!PL_is_integer(targ)) { - ints = FALSE; - if (!PL_is_float(targ)) { - Ureturn FALSE; - } + ints = FALSE; + if (!PL_is_float(targ)) { + Ureturn FALSE; + } } } if (ints) { @@ -2140,47 +1972,49 @@ send_c_vector(term_t tvec, term_t tout) PROTECT_AND_COUNT(ans = allocVector(INTSXP, arity)); if (!ans) - return FALSE; + return FALSE; vec = INTEGER(ans); for (i = 0; i < arity; i++) { - int64_t j; - _PL_get_arg(i+1, tvec, targ); - if (!PL_get_int64(targ, &j)) { - Ureturn FALSE; - } - vec[i] = j; + int64_t j; + _PL_get_arg(i + 1, tvec, targ); + if (!PL_get_int64(targ, &j)) { + Ureturn FALSE; + } + vec[i] = j; } } else { double *vec; PROTECT_AND_COUNT(ans = allocVector(REALSXP, arity)); - if (!ans) - { Ureturn FALSE; } + if (!ans) { + Ureturn FALSE; + } vec = REAL(ans); for (i = 0; i < arity; i++) { - _PL_get_arg(i+1, tvec, targ); - if (!PL_get_float(targ, vec+i)) { - int64_t j; - if (!PL_get_int64(targ, &j)) - { Ureturn FALSE; } - vec[i] = j; - } + _PL_get_arg(i + 1, tvec, targ); + if (!PL_get_float(targ, vec + i)) { + int64_t j; + if (!PL_get_int64(targ, &j)) { + Ureturn FALSE; + } + vec[i] = j; + } } } } else if (PL_is_atom(targ) || PL_is_string(targ)) { PROTECT_AND_COUNT(ans = allocVector(STRSXP, arity)); - if (!ans) - { Ureturn FALSE; } + if (!ans) { + Ureturn FALSE; + } for (i = 0; i < arity; i++) { char *str = NULL; - _PL_get_arg(i+1, tvec, targ); - if ( PL_get_chars(targ, &str, CVT_ALL|BUF_DISCARDABLE|REP_UTF8) ) - { - SET_STRING_ELT(ans, i, mkCharCE(str, CE_UTF8) ); - } else { - Ureturn FALSE; + _PL_get_arg(i + 1, tvec, targ); + if (PL_get_chars(targ, &str, CVT_ALL | BUF_DISCARDABLE | REP_UTF8)) { + SET_STRING_ELT(ans, i, mkCharCE(str, CE_UTF8)); + } else { + Ureturn FALSE; } } } else { @@ -2190,146 +2024,133 @@ send_c_vector(term_t tvec, term_t tout) Ureturn TRUE; } +static foreign_t rexpr_to_pl_term(term_t in, term_t out) { + char *s; -static foreign_t -rexpr_to_pl_term(term_t in, term_t out) -{ char *s; + if (PL_get_chars(in, &s, CVT_ALL | BUF_MALLOC | REP_UTF8)) { + SEXP sexp; - if ( PL_get_chars(in, &s, CVT_ALL|BUF_MALLOC|REP_UTF8) ) - { SEXP sexp; + if ((sexp = process_expression(s))) { + term_t tmp = PL_new_term_ref(); - if ( (sexp=process_expression(s)) ) - { term_t tmp = PL_new_term_ref(); + PL_free(s); + if (sexp_to_pl(tmp, sexp)) + return PL_unify(out, tmp); - PL_free(s); - if ( sexp_to_pl(tmp, sexp) ) - return PL_unify(out, tmp); - - return FALSE; - } else - { /* FIXME: Throw exception */ - PL_free(s); - } + return FALSE; + } else { /* FIXME: Throw exception */ + PL_free(s); } + } return FALSE; } - -static foreign_t -robj_to_pl_term(term_t name, term_t out) -{ char *plname; +static foreign_t robj_to_pl_term(term_t name, term_t out) { + char *plname; int nprotect = 0; - - if ( PL_get_chars(name, &plname, CVT_ALL|BUF_DISCARDABLE|REP_UTF8) ) - { SEXP s; - term_t tmp = PL_new_term_ref(); - int rc; - PROTECT_AND_COUNT( s= findVar(install(plname), R_GlobalEnv) ); - if (s == R_UnboundValue || - TYPEOF(s)==SYMSXP) - { Ureturn REAL_Error("r_variable", name); } + if (PL_get_chars(name, &plname, CVT_ALL | BUF_DISCARDABLE | REP_UTF8)) { + SEXP s; + term_t tmp = PL_new_term_ref(); + int rc; - rc = sexp_to_pl(tmp, s); - - if ( rc ) { - Ureturn PL_unify(out, tmp); - } + PROTECT_AND_COUNT(s = findVar(install(plname), R_GlobalEnv)); + if (s == R_UnboundValue || TYPEOF(s) == SYMSXP) { + Ureturn REAL_Error("r_variable", name); } + rc = sexp_to_pl(tmp, s); + + if (rc) { + Ureturn PL_unify(out, tmp); + } + } + { Ureturn FALSE; } } -static foreign_t -set_R_variable(term_t rvar, term_t value) -{ char *vname = NULL; +static foreign_t set_R_variable(term_t rvar, term_t value) { + char *vname = NULL; SEXP sexp; int nprotect = 0; bool rc = false; - if ( PL_get_chars(rvar, &vname, CVT_ALL|BUF_MALLOC|REP_UTF8) ) - { - PROTECT_AND_COUNT( sexp = (term_to_sexp(value , TRUE) ) ); - if (!Rf_isNull(sexp)) - defineVar(Rf_install(vname) , sexp, R_GlobalEnv) ; - rc = true; - } + if (PL_get_chars(rvar, &vname, CVT_ALL | BUF_MALLOC | REP_UTF8)) { + PROTECT_AND_COUNT(sexp = (term_to_sexp(value, TRUE))); + if (!Rf_isNull(sexp)) + defineVar(Rf_install(vname), sexp, R_GlobalEnv); + rc = true; + } if (vname) PL_free(vname); - Ureturn rc; + Ureturn rc; } -static foreign_t -execute_R_1(term_t value ) -{ SEXP sexp; +static foreign_t execute_R_1(term_t value) { + SEXP sexp; foreign_t rc = FALSE; int nprotect = 0; int hadError; - + PROTECT_AND_COUNT(R_GlobalEnv); - PROTECT_AND_COUNT( sexp = term_to_sexp(value, TRUE) ); + PROTECT_AND_COUNT(sexp = term_to_sexp(value, TRUE)); rc = !Rf_isNull(sexp); - if (rc) { - PROTECT_AND_COUNT( sexp = protected_tryEval(sexp, R_GlobalEnv, &hadError) ); - if (hadError) - { + if (rc) { + PROTECT_AND_COUNT(sexp = protected_tryEval(sexp, R_GlobalEnv, &hadError)); + if (hadError) { Ureturn false; - } } + } Ureturn rc; } -static foreign_t -execute_R(term_t rvar, term_t value) -{ SEXP sexp; +static foreign_t execute_R(term_t rvar, term_t value) { + SEXP sexp; foreign_t rc = FALSE; term_t t1 = PL_new_term_ref(); int nprotect = 0; - PROTECT_AND_COUNT( sexp = term_to_sexp(value, true) ); - //PROTECT_AND_COUNT( sexp = protected_tryEval(sexp, R_GlobalEnv, &hadError) ); - if (sexp == R_UnboundValue || Rf_isNull(sexp)) - { - PL_reset_term_refs( t1 ); - Ureturn false; - } else { - int hadError = false; - sexp = protected_tryEval(sexp, R_GlobalEnv, &hadError); - if (hadError) - { - PL_reset_term_refs( t1 ); - Ureturn false; - } - } - if ( PL_is_ground( rvar ) ) { - rc = bind_sexp( rvar, sexp ); + PROTECT_AND_COUNT(sexp = term_to_sexp(value, true)); + // PROTECT_AND_COUNT( sexp = protected_tryEval(sexp, R_GlobalEnv, &hadError) + // ); + if (sexp == R_UnboundValue || Rf_isNull(sexp)) { + PL_reset_term_refs(t1); + Ureturn false; } else { - if (!sexp_to_pl( t1, sexp ) ) + int hadError = false; + sexp = protected_tryEval(sexp, R_GlobalEnv, &hadError); + if (hadError) { + PL_reset_term_refs(t1); + Ureturn false; + } + } + if (PL_is_ground(rvar)) { + rc = bind_sexp(rvar, sexp); + } else { + if (!sexp_to_pl(t1, sexp)) rc = FALSE; else - rc = PL_unify( rvar, t1 ); + rc = PL_unify(rvar, t1); } - PL_reset_term_refs( t1 ); + PL_reset_term_refs(t1); Ureturn rc; } -static foreign_t -is_R_variable(term_t t) -{ - SEXP name,o; +static foreign_t is_R_variable(term_t t) { + SEXP name, o; char *s; int nprotect = 0; /* is this variable defined in R?. */ - if ( PL_get_chars(t, &s, CVT_ATOM|CVT_STRING|BUF_DISCARDABLE|REP_UTF8) ) - { PROTECT_AND_COUNT(name = NEW_CHARACTER(1)); - CHARACTER_DATA(name)[0] = mkCharCE(s, CE_UTF8); - } - else { - Ureturn FALSE; + if (PL_get_chars(t, &s, CVT_ATOM | CVT_STRING | BUF_DISCARDABLE | REP_UTF8)) { + PROTECT_AND_COUNT(name = NEW_CHARACTER(1)); + CHARACTER_DATA(name)[0] = mkCharCE(s, CE_UTF8); + } else { + Ureturn FALSE; } - PROTECT_AND_COUNT(o = findVar(install(CHAR(STRING_ELT(name, 0))), R_GlobalEnv)); + PROTECT_AND_COUNT( + o = findVar(install(CHAR(STRING_ELT(name, 0))), R_GlobalEnv)); Ureturn o != R_UnboundValue; } @@ -2337,16 +2158,15 @@ is_R_variable(term_t t) #define ATOM_dot PL_new_atom(".") #endif -install_t -install_real(void) -{ /* FUNCTOR_dot2 = PL_new_functor(PL_new_atom("."), 2); */ +X_API install_t +install_real(void) { /* FUNCTOR_dot2 = PL_new_functor(PL_new_atom("."), 2); */ ATOM_break = PL_new_atom("break"); ATOM_false = PL_new_atom("false"); ATOM_function = PL_new_atom("function"); - ATOM_i = PL_new_atom("i"); + ATOM_i = PL_new_atom("i"); ATOM_next = PL_new_atom("next"); - ATOM_true = PL_new_atom("true"); + ATOM_true = PL_new_atom("true"); FUNCTOR_at2 = PL_new_functor(PL_new_atom("@"), 2); FUNCTOR_boolop1 = PL_new_functor(PL_new_atom("@"), 1); @@ -2375,17 +2195,16 @@ install_real(void) FUNCTOR_tilde2 = PL_new_functor(PL_new_atom("~"), 2); FUNCTOR_while2 = PL_new_functor(PL_new_atom("while"), 2); - PL_register_foreign("init_R", 0, init_R, 0); - PL_register_foreign("stop_R", 0, stop_R, 0); - PL_register_foreign("send_R_command", 1, send_R_command, 0); - PL_register_foreign("send_c_vector", 2, send_c_vector, 0); + PL_register_foreign("init_R", 0, init_R, 0); + PL_register_foreign("stop_R", 0, stop_R, 0); + PL_register_foreign("send_R_command", 1, send_R_command, 0); + PL_register_foreign("send_c_vector", 2, send_c_vector, 0); PL_register_foreign("rexpr_to_pl_term", 2, rexpr_to_pl_term, 0); - PL_register_foreign("robj_to_pl_term", 2, robj_to_pl_term, 0); - PL_register_foreign("set_R_variable", 2, set_R_variable, 0); - PL_register_foreign("execute_R", 2, execute_R, 0); - PL_register_foreign("execute_R", 1, execute_R_1, 0); - PL_register_foreign("is_R_variable", 1, is_R_variable, 0); + PL_register_foreign("robj_to_pl_term", 2, robj_to_pl_term, 0); + PL_register_foreign("set_R_variable", 2, set_R_variable, 0); + PL_register_foreign("execute_R", 2, execute_R, 0); + PL_register_foreign("execute_R", 1, execute_R_1, 0); + PL_register_foreign("is_R_variable", 1, is_R_variable, 0); } #endif /* R_H */ - diff --git a/packages/real/real.pl b/packages/real/real.pl index 972b8777f..0286fea92 100755 --- a/packages/real/real.pl +++ b/packages/real/real.pl @@ -212,8 +212,7 @@ start_r :- !, swipl_wins_warn, init_r_env, - use_foreign_library(foreign(real)), - init_R, + load_foreign_files([libreal], [], init_R), set_prolog_flag(double_quotes, string ), set_prolog_flag( real, started ). start_r. diff --git a/packages/swig/CMakeLists.txt b/packages/swig/CMakeLists.txt index 046bdc550..b451e3a98 100644 --- a/packages/swig/CMakeLists.txt +++ b/packages/swig/CMakeLists.txt @@ -1,4 +1,4 @@ -#CHECK: SWIG + option (WITH_SWiG "Allow Python->YAP and Java->YAP" ON) @@ -6,13 +6,13 @@ IF (WITH_SWiG) find_host_package (SWIG) macro_log_feature (SWIG_FOUND "Swig" - "Use SWIG Documentation System " + "Use SWIG Interface Generator " "http://www.swig.org" ON) if (SWIG_FOUND) # # SWIG_FOUND - set to true if SWIG is found - # SWIG_DIR - t he directory where swig is installed + # SWIG_DIR - the directory where swig is installed # SWIG_EXECUTABLE - the path to the swig executable # SWIG_VERSION - the version number of the swig executable # @@ -25,10 +25,12 @@ if (ANDROID) add_subdirectory(android) else(ANDROID) add_subdirectory(python) -# add_subdirectory(java) +#add_subdirectory(java) endif(ANDROID) + set_property( DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS SWIGYAP=1) + + endif (SWIG_FOUND) ENDIF (WITH_SWiG) - diff --git a/packages/swig/java/CMakeLists.txt b/packages/swig/java/CMakeLists.txt index d45651cfc..f642d839a 100644 --- a/packages/swig/java/CMakeLists.txt +++ b/packages/swig/java/CMakeLists.txt @@ -36,14 +36,12 @@ if (JNI_FOUND) SWIG_ADD_MODULE(Native java ${SWIG_SOURCES} ) - add_dependencies(Native Yap++ ) - - SWIG_LINK_LIBRARIES (Native Yap++ ) - set(CMAKE_JNI_TARGET 1) + set(CMAKE_JNI_TARGET 1 + ) ADD_JAR( NativeJar - SOURCES "${CMAKE_SOURCES_DIR}/docs/icons/yap_16x16x32.png" + SOURCES "../../../docs/icons/yap_16x16x32.png" DEPENDS Native PROPERTIES OUTPUT_NAME Native ) diff --git a/packages/swig/python/CMakeLists.txt b/packages/swig/python/CMakeLists.txt index b1823e213..8f25949c3 100644 --- a/packages/swig/python/CMakeLists.txt +++ b/packages/swig/python/CMakeLists.txt @@ -1,102 +1,83 @@ -# This is a CMake example for Python + # This is a CMake example for Python -INCLUDE(${SWIG_USE_FILE}) + INCLUDE( NewUseSWIG ) - GET_PROPERTY(OBJECTS TARGET core PROPERTY SOURCES) -GET_PROPERTY(OBJECTS TARGET libYAPOs PROPERTY SOURCES) -GET_PROPERTY(OBJECTS TARGET libOPTYap PROPERTY SOURCES) -# list( APPEND OBJECTS GET_PROPERTY(sourcefiles TARGET myddas PROPERTY SOURCES)) -# list( APPEND OBJECTS GET_PROPERTY(sourcefiles TARGET Yapsqlite3 PROPERTY SOURCES)) -# list( APPEND OBJECTS GET_PROPERTY(sourcefiles TARGET libswi PROPERTY SOURCES)) -# list( APPEND OBJECTS GET_PROPERTY(sourcefiles TARGET myddas PROPERTY SOURCES)) -# list( APPEND OBJECTS GET_PROPERTY(sourcefiles TARGET utf8proc PROPERTY SOURCES)) -# list( APPEND OBJECTS GET_PROPERTY(sourcefiles TARGET Yap++ PROPERTY SOURCES)) + if (PYTHONLIBS_FOUND) -if (PYTHONLIBS_FOUND) + include(FindPythonModule) - include(FindPythonModule) + INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH}) - INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH}) - - INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/CXX) - - SET(CMAKE_SWIG_FLAGS "-py3") - - SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES CPLUSPLUS ON) - SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_FLAGS "-includeall") - SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_FLAGS "-py3") - SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTY SWIG_MODULE_NAME yap ) - SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTY OUTPUT_NAME yap ) - - #configure_file ("setup.py.cmake" "setup.py" ) - #configure_file ("../yap.i" "yap.i" ) + INCLUDE_DIRECTORIES( "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/CXX" ) - SET( CMAKE_SWIG_OUTDIR "${CMAKE_CURRENT_BINARY_DIR}/yap" ) + SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES CPLUSPLUS ON) + SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_FLAGS "-O;-py3") + SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_MODULE_NAME yap ) + SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES OUTPUT_NAME yap ) + configure_file ("setup.py.cmake" ${CMAKE_CURRENT_BINARY_DIR}/setup.py ) + # configure_file ("../yap.i" "yap.i" ) - SWIG_ADD_MODULE(Py2YAP python ../yap.i ) - SWIG_LINK_LIBRARIES(Py2YAP ${PYTHON_LIBRARIES} Yap++ YAPPython libYap) - set_target_properties ( ${SWIG_MODULE_Py2YAP_REAL_NAME} PROPERTIES -NO_SONAME ON OUTPUT_NAME _yap LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/yap" ) - + SWIG_ADD_LIBRARY(Py2YAP LANGUAGE python SHARED SOURCES ../yap.i ) + if (WIN32) + SWIG_LINK_LIBRARIES(Py2YAP YAPPython libYap ${PYTHON_LIBRARIES} ) + else() + SWIG_LINK_LIBRARIES( Py2YAP libYap YAP++ YAPPython ${PYTHON_LIBRARIES} ) + endif() + set_target_properties ( ${SWIG_MODULE_Py2YAP_REAL_NAME} + PROPERTIES + NO_SONAME ON + OUTPUT_NAME _yap + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" ) + # inform we are compiling YAP + # s used in MSYS execute_process ( COMMAND ${PYTHON_EXECUTABLE} -c "import sysconfig; print( sysconfig.get_path( 'platlib' ) )" - OUTPUT_VARIABLE _ABS_PYTHON_MODULE_PATH - OUTPUT_STRIP_TRAILING_WHITESPACE ) + OUTPUT_VARIABLE _ABS_PYTHON_MODULE_PATH + OUTPUT_STRIP_TRAILING_WHITESPACE ) get_filename_component ( ABS_PYTHON_MODULE_PATH ${_ABS_PYTHON_MODULE_PATH} ABSOLUTE ) - file ( RELATIVE_PATH _REL_PYTHON_MOULE_PATH ${CMAKE_INSTALL_PREFIX} ${_ABS_PYTHON_MODULE_PATH} ) + file ( RELATIVE_PATH _REL_PYTHON_MODULE_PATH ${CMAKE_INSTALL_PREFIX} ${_ABS_PYTHON_MODULE_PATH} ) - set ( PYTHON_MODULE_PATH - ${_ABS_PYTHON_MODULE_PATH} - ) - - # set(SETUP_PY "${CMAKE_CURRENT_BINARY_DIR}/setup.py") - - # add_custom_target ( py2yap ALL - # COMMAND ${PYTHON_EXECUTABLE} setup.py bdist - # DEPENDS ../yap.i YAPPython ) + set ( PYTHON_MODULE_PATH + ${ABS_PYTHON_MODULE_PATH} + ) - # install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SETUP_PY} install - # WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})") - - INSTALL ( FILES ${CMAKE_CURRENT_BINARY_DIR}/yap/_yap.so DESTINATION ${PYTHON_MODULE_PATH} ) - INSTALL ( FILES ${CMAKE_CURRENT_BINARY_DIR}/yap/yap.py DESTINATION ${PYTHON_MODULE_PATH} ) - - - if ( DOCUMENTATION AND DOXYGEN_FOUND ) - - set(CMAKE_SWIG_FLAGS -DDOXYGEN=${DOXYGEN_FOUND}) - - # Run doxygen to only generate the xml - add_custom_command ( OUTPUT ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/doc - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/Doxyfile.xml - WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - DEPENDS ${c_headers};${c_sources};${cpp_sources};${cpp_headers} - ) - - # generate .i from doxygen .xml - add_custom_command ( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i - COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doxy2swig.py -n - ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml - ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i - DEPENDS ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml - ) - add_custom_target ( doc_i DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i ) - add_dependencies( ${SWIG_MODULE_ftdi1_REAL_NAME} doc_i ) - - endif () + INSTALL ( FILES ${CMAKE_CURRENT_BINARY_DIR}/yap.py DESTINATION ${PYTHON_MODULE_PATH} ) + INSTALL ( FILES ${CMAKE_SOURCE_DIR}/packages/python/yapex.py DESTINATION ${PYTHON_MODULE_PATH} ) - install(TARGETS ${SWIG_MODULE_Py2YAP_REAL_NAME} - LIBRARY DESTINATION ${dlls} - ARCHIVE DESTINATION ${dlls} - ) + INSTALL ( TARGETS ${SWIG_MODULE_Py2YAP_REAL_NAME} + RUNTIME DESTINATION ${PYTHON_MODULE_PATH} + ARCHIVE DESTINATION ${PYTHON_MODULE_PATH} + LIBRARY DESTINATION ${PYTHON_MODULE_PATH} + ) - # add_subdirectory ( examples ) -else () - message(STATUS "Not building python bindings") -endif(PYTHONLIBS_FOUND) + + + if ( DOCUMENTATION AND DOXYGEN_FOUND ) + + set(CMAKE_SWIG_FLAGS -DDOXYGEN=${DOXYGEN_FOUND}) + + # Run doxygen to only generate the xml + add_custom_command ( OUTPUT ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/doc + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/Doxyfile.xml + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS ${c_headers};${c_sources};${cpp_sources};${cpp_headers} + ) + + # generate .i from doxygen .xml + add_custom_command ( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i + COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doxy2swig.py -n + ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml + ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i + DEPENDS ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml + ) + add_custom_target ( doc_i DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i ) + add_dependencies( ${SWIG_MODULE_ftdi1_REAL_NAME} doc_i ) + + ENDIF() + ENDIF() diff --git a/packages/swig/python/setup.py.cmake b/packages/swig/python/setup.py.cmake index 403407188..ecc279e8e 100644 --- a/packages/swig/python/setup.py.cmake +++ b/packages/swig/python/setup.py.cmake @@ -8,9 +8,7 @@ if platform.system() == 'Darwin': else: my_extra_link_args = [] -python_sources = ['yap.i'] # ,'../../CXX/yapi.cpp'] + ${PYTHON_SOURCES} - -set objects = split('${OBJECTS}',';') +python_sources = ['${CMAKE_CURRENT_SOURCE_DIR}/../yap.i'] setup( name = "yap", @@ -20,12 +18,12 @@ ext_modules=[Extension('_yap', python_sources, ('MINOR_VERSION', '0'), ('_YAP_NOT_INSTALLED_', '1'), ('YAP_PYTHON', '1')], - runtime_library_dirs=['${dlls}'], + runtime_library_dirs=[,'$(bindir)'], swig_opts=['-modern','-outcurrentdir', '-c++', '-py3','-I${CMAKE_SOURCE_DIR}/CXX'], - library_dirs=['../../.o.', + library_dirs=["${dlls}","${bindir}", '.'], extra_link_args=my_extra_link_args, - libraries=['Yap++','Yap','YAPPython'], + libraries=['Yap','{GMP_LIBRARIES}'], include_dirs=['../../..', '${GMP_INCLUDE_DIRS}', '${CMAKE_SOURCE_DIR}/H', @@ -35,6 +33,6 @@ ext_modules=[Extension('_yap', python_sources, '${CMAKE_SOURCE_DIR}/include', '${CMAKE_SOURCE_DIR}/CXX', '.'] )], -py_modules = ['yap'] +py_modules = ['yap', '${CMAKE_SOURCE_DIR}/packages/python/yapex'] ) -\ + diff --git a/packages/swig/yap.i b/packages/swig/yap.i index 7c8198108..774dc26d4 100644 --- a/packages/swig/yap.i +++ b/packages/swig/yap.i @@ -1,298 +1,371 @@ +#ifdef SWIGPYTHON +%{ +#include + %} +#endif + /* example.i */ %module(directors = "1") yap - - -// Language independent exception handler + // Language independent exception handler %include exception.i %include stdint.i +%ignore *::operator[]; + +class YAPPredicate; +class YAPEngine; + +#define arity_t uintptr_t + + %{ -/* Put header files here or function declarations like below */ - -#define YAP_CPP_INTERFACE 1 #include "yapi.hh" - extern "C" { +#ifdef SWIGPYTHON + + extern "C" { + + extern X_API YAP_Term pythonToYAP(PyObject *pVal); + extern X_API PyObject * yap_to_python(YAP_Term t, bool eval); + X_API extern bool init_python(void); + extern X_API PyObject *py_Main; + extern X_API PyObject *py_Builtin; + extern X_API PyObject *py_Yapex; + } + + extern inline PyObject *AtomToPy(const char *s) { + if (strcmp(s, "true") == 0) + return Py_True; + if (strcmp(s, "false") == 0) + return Py_False; + if (strcmp(s, "none") == 0) + return Py_None; + if (strcmp(s, "[]") == 0) + return PyList_New(0); + else if (strcmp(s, "{}") == 0) + return PyDict_New(); + /* return __main__,s */ + else if (PyObject_HasAttrString(py_Main, s)) { + return PyObject_GetAttrString(py_Main, s); + } + // no way to translate + return NULL; + } +#endif + %} + +#ifdef SWIGPYTHON +%typemap(typecheck) Term* { + $1 = PySequence_Check($input); + } + +// Map a Python sequence into any sized C double array +%typemap(in) Term* { + int i; + if (!PySequence_Check($input)) { + PyErr_SetString(PyExc_TypeError,"Expecting a sequence"); + $1 = nullptr; + } else { + int sz = PyObject_Length($input); + std::vector v(sz); + for (i =0; i < sz; i++) { + PyObject *o = PySequence_GetItem($input,i); + v[i] = Term(pythonToYAP(o)); + //Py_DECREF(o); + } + $1 = &v[0]; + } + } + +%typemap(typecheck) YPTerm { + $1 = true; + } + +%typemap(in) Term { $1 = pythonToYAP($input); } + + +%typemap(out) YAP_Term { return $result = yap_to_python($1, false);} + +%typemap(out) Term { return $result = yap_to_python($1, false);} + + +%extend(out) Term{Term & __getitem__(size_t i){Term t0 = $self; + + if (IsApplTerm(t0)) { + Functor f = FunctorOfTerm(t0); + if (!IsExtensionFunctor(f)) + return (ArgOfTerm(i + 1, t0); + } else if (IsPairTerm(t0)) { + if (i == 0) + return HeadOfTerm(t0); + else if (i == 1) + return TailOfTerm(t0); + } + } + } + + + + // Language independent exception handler + + %exception next { + try { + $action + } catch (YAPError &e) { + yap_error_number en = e.getID(); + PyObject *pyerr = PyExc_RuntimeError; + + LOCAL_Error_TYPE = YAP_NO_ERROR; + switch (e.getErrorClass()) { + case YAPC_NO_ERROR: + break; + /// bad domain, "first argument often is the predicate. + case DOMAIN_ERROR: { + switch (en) { + case DOMAIN_ERROR_OUT_OF_RANGE: + case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: + pyerr = PyExc_IndexError; + break; + case DOMAIN_ERROR_CLOSE_OPTION: + case DOMAIN_ERROR_ENCODING: + case DOMAIN_ERROR_PROLOG_FLAG: + case DOMAIN_ERROR_ABSOLUTE_FILE_NAME_OPTION: + case DOMAIN_ERROR_READ_OPTION: + case DOMAIN_ERROR_SET_STREAM_OPTION: + pyerr = PyExc_KeyError; + break; + case DOMAIN_ERROR_FILE_ERRORS: + case DOMAIN_ERROR_FILE_TYPE: + case DOMAIN_ERROR_IO_MODE: + case DOMAIN_ERROR_SOURCE_SINK: + case DOMAIN_ERROR_STREAM_POSITION: + pyerr = PyExc_IOError; + break; + default: + pyerr = PyExc_ValueError; + } + } break; + /// bad arithmetic + case EVALUATION_ERROR: { + switch (en) { + case EVALUATION_ERROR_FLOAT_OVERFLOW: + case EVALUATION_ERROR_INT_OVERFLOW: + pyerr = PyExc_OverflowError; + break; + case EVALUATION_ERROR_FLOAT_UNDERFLOW: + case EVALUATION_ERROR_UNDERFLOW: + case EVALUATION_ERROR_ZERO_DIVISOR: + pyerr = PyExc_ArithmeticError; + break; + default: + pyerr = PyExc_RuntimeError; + } + } break; + /// missing object (I/O mostly) + case EXISTENCE_ERROR: + pyerr = PyExc_NotImplementedError; + break; + /// should be bound + case INSTANTIATION_ERROR_CLASS: + pyerr = PyExc_RuntimeError; + break; + /// bad access, I/O + case PERMISSION_ERROR: { + switch (en) { + case PERMISSION_ERROR_INPUT_BINARY_STREAM: + case PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM: + case PERMISSION_ERROR_INPUT_STREAM: + case PERMISSION_ERROR_INPUT_TEXT_STREAM: + case PERMISSION_ERROR_OPEN_SOURCE_SINK: + case PERMISSION_ERROR_OUTPUT_BINARY_STREAM: + case PERMISSION_ERROR_REPOSITION_STREAM: + case PERMISSION_ERROR_OUTPUT_STREAM: + case PERMISSION_ERROR_OUTPUT_TEXT_STREAM: + pyerr = PyExc_OverflowError; + break; + default: + pyerr = PyExc_RuntimeError; + } + } break; + /// something that could not be represented into a type + case REPRESENTATION_ERROR: + pyerr = PyExc_RuntimeError; + break; + /// not enough .... + case RESOURCE_ERROR: + pyerr = PyExc_RuntimeError; + break; + /// bad text + case SYNTAX_ERROR_CLASS: + pyerr = PyExc_SyntaxError; + break; + /// OS or internal + case SYSTEM_ERROR_CLASS: + pyerr = PyExc_RuntimeError; + break; + /// bad typing + case TYPE_ERROR: + pyerr = PyExc_TypeError; + break; + /// should be unbound + case UNINSTANTIATION_ERROR_CLASS: + pyerr = PyExc_RuntimeError; + break; + /// escape hatch + default: + break; + } + PyErr_SetString(pyerr, e.text().c_str()); + } + } + +#else + + // Language independent exception handler + %include exception.i + + %exception { + try { + $action + } catch (YAPError e) { + yap_error_number en = e.getID(); + LOCAL_Error_TYPE = YAP_NO_ERROR; + switch (e.getErrorClass()) { + case YAPC_NO_ERROR: + break; + /// bad domain, "first argument often is the predicate. + case DOMAIN_ERROR: { + switch (en) { + case DOMAIN_ERROR_OUT_OF_RANGE: + case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: + SWIG_exception(SWIG_IndexError, e.text()); + break; + case DOMAIN_ERROR_CLOSE_OPTION: + case DOMAIN_ERROR_ENCODING: + case DOMAIN_ERROR_PROLOG_FLAG: + case DOMAIN_ERROR_ABSOLUTE_FILE_NAME_OPTION: + case DOMAIN_ERROR_READ_OPTION: + case DOMAIN_ERROR_SET_STREAM_OPTION: + SWIG_exception(SWIG_AttributeError, e.text()); + break; + case DOMAIN_ERROR_FILE_ERRORS: + case DOMAIN_ERROR_FILE_TYPE: + case DOMAIN_ERROR_IO_MODE: + case DOMAIN_ERROR_SOURCE_SINK: + case DOMAIN_ERROR_STREAM_POSITION: + SWIG_exception(SWIG_IOError, e.text()); + break; + default: + SWIG_exception(SWIG_ValueError, e.text()); + } + } break; + /// bad arithmetic + case EVALUATION_ERROR: { + switch (en) { + case EVALUATION_ERROR_FLOAT_OVERFLOW: + case EVALUATION_ERROR_FLOAT_UNDERFLOW: + case EVALUATION_ERROR_INT_OVERFLOW: + case EVALUATION_ERROR_UNDERFLOW: + SWIG_exception(SWIG_OverflowError, e.text()); + break; + case EVALUATION_ERROR_ZERO_DIVISOR: + SWIG_exception(SWIG_DivisionByZero, e.text()); + break; + default: + SWIG_exception(SWIG_RuntimeError, e.text()); + } + } break; + /// missing object (I/O mostly) + case EXISTENCE_ERROR: + SWIG_exception(SWIG_RuntimeError, e.text()); + break; + /// should be bound + case INSTANTIATION_ERROR_CLASS: + SWIG_exception(SWIG_RuntimeError, e.text()); + break; + /// bad access, I/O + case PERMISSION_ERROR: { + switch (en) { + case PERMISSION_ERROR_INPUT_BINARY_STREAM: + case PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM: + case PERMISSION_ERROR_INPUT_STREAM: + case PERMISSION_ERROR_INPUT_TEXT_STREAM: + case PERMISSION_ERROR_OPEN_SOURCE_SINK: + case PERMISSION_ERROR_OUTPUT_BINARY_STREAM: + case PERMISSION_ERROR_REPOSITION_STREAM: + case PERMISSION_ERROR_OUTPUT_STREAM: + case PERMISSION_ERROR_OUTPUT_TEXT_STREAM: + SWIG_exception(SWIG_OverflowError, e.text()); + break; + default: + SWIG_exception(SWIG_RuntimeError, e.text()); + } + } break; + /// something that could not be represented into a type + case REPRESENTATION_ERROR: + SWIG_exception(SWIG_RuntimeError, e.text()); + break; + /// not enough .... + case RESOURCE_ERROR: + SWIG_exception(SWIG_RuntimeError, e.text()); + break; + /// bad text + case SYNTAX_ERROR_CLASS: + SWIG_exception(SWIG_SyntaxError, e.text()); + break; + /// OS or internal + case SYSTEM_ERROR_CLASS: + SWIG_exception(SWIG_RuntimeError, e.text()); + break; + /// bad typing + case TYPE_ERROR: + SWIG_exception(SWIG_TypeError, e.text()); + break; + /// should be unbound + case UNINSTANTIATION_ERROR_CLASS: + SWIG_exception(SWIG_RuntimeError, e.text()); + break; + /// escape hatch + default: + break; + } + } + } + +#endif + + %{ + /* Put header files here or function declarations like below */ + + + extern "C" { #if THREADS #define Yap_regp regcache #endif - // we cannot consult YapInterface.h, that conflicts with what we - // declare, though - // it shouldn't - } - -%} - -#ifdef SWIGPYTHON - -//include python/python.i - - - -%inline %{ - YAPTerm T(PyObject *input ) { return *new YAPTerm( pythonToYAP(input) ); } - %} - -%typemap(in) YAPTerm { $1 = *new YAPTerm( pythonToYAP($input) ); } - - -%typemap(in) Term { $1 = pythonToYAP($input); } - - -%typemap(out) YAPTerm { return $result = yap_to_python($1.term(), false);} -%typemap(out) Term { return $result = yap_to_python($1, false);} - - -// Language independent exception handler - -%exception next { - try { - $action - } catch (YAPError &e) { - yap_error_number en = e.getID(); - PyObject *pyerr = PyExc_RuntimeError; - - LOCAL_Error_TYPE = YAP_NO_ERROR; - switch (e.getErrorClass()) { - case YAPC_NO_ERROR: - break; - /// bad domain, "first argument often is the predicate. - case DOMAIN_ERROR: { - switch (en) { - case DOMAIN_ERROR_OUT_OF_RANGE: - case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: - pyerr = PyExc_IndexError; - break; - case DOMAIN_ERROR_CLOSE_OPTION: - case DOMAIN_ERROR_ENCODING: - case DOMAIN_ERROR_PROLOG_FLAG: - case DOMAIN_ERROR_ABSOLUTE_FILE_NAME_OPTION: - case DOMAIN_ERROR_READ_OPTION: - case DOMAIN_ERROR_SET_STREAM_OPTION: - pyerr = PyExc_KeyError; - break; - case DOMAIN_ERROR_FILE_ERRORS: - case DOMAIN_ERROR_FILE_TYPE: - case DOMAIN_ERROR_IO_MODE: - case DOMAIN_ERROR_SOURCE_SINK: - case DOMAIN_ERROR_STREAM_POSITION: - pyerr = PyExc_IOError; - break; - default: - pyerr = PyExc_ValueError; - } - } break; - /// bad arithmetic - case EVALUATION_ERROR: { - switch (en) { - case EVALUATION_ERROR_FLOAT_OVERFLOW: - case EVALUATION_ERROR_INT_OVERFLOW: - pyerr = PyExc_OverflowError; - break; - case EVALUATION_ERROR_FLOAT_UNDERFLOW: - case EVALUATION_ERROR_UNDERFLOW: - case EVALUATION_ERROR_ZERO_DIVISOR: - pyerr = PyExc_ArithmeticError; - break; - default: - pyerr = PyExc_RuntimeError; - } - } break; - /// missing object (I/O mostly) - case EXISTENCE_ERROR: - pyerr = PyExc_NotImplementedError; - break; - /// should be bound - case INSTANTIATION_ERROR_CLASS: - pyerr = PyExc_RuntimeError; - break; - /// bad access, I/O - case PERMISSION_ERROR: { - switch (en) { - case PERMISSION_ERROR_INPUT_BINARY_STREAM: - case PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM: - case PERMISSION_ERROR_INPUT_STREAM: - case PERMISSION_ERROR_INPUT_TEXT_STREAM: - case PERMISSION_ERROR_OPEN_SOURCE_SINK: - case PERMISSION_ERROR_OUTPUT_BINARY_STREAM: - case PERMISSION_ERROR_REPOSITION_STREAM: - case PERMISSION_ERROR_OUTPUT_STREAM: - case PERMISSION_ERROR_OUTPUT_TEXT_STREAM: - pyerr = PyExc_OverflowError; - break; - default: - pyerr = PyExc_RuntimeError; - } - } break; - /// something that could not be represented into a type - case REPRESENTATION_ERROR: - pyerr = PyExc_RuntimeError; - break; - /// not enough .... - case RESOURCE_ERROR: - pyerr = PyExc_RuntimeError; - break; - /// bad text - case SYNTAX_ERROR_CLASS: - pyerr = PyExc_SyntaxError; - break; - /// OS or internal - case SYSTEM_ERROR_CLASS: - pyerr = PyExc_RuntimeError; - break; - /// bad typing - case TYPE_ERROR: - pyerr = PyExc_TypeError; - break; - /// should be unbound - case UNINSTANTIATION_ERROR_CLASS: - pyerr = PyExc_RuntimeError; - break; - /// escape hatch - default: - break; + // we cannot consult YapInterface.h, that conflicts with what we + // declare, though + // it shouldn't } - PyErr_SetString(pyerr, e.text()); - } -} -#else + %} -// Language independent exception handler -%include exception.i + /* turn on director wrapping Callback */ + %feature("director") YAPCallback; - %exception { - try { - $action - } catch (YAPError e) { -yap_error_number en = e.getID(); -LOCAL_Error_TYPE = YAP_NO_ERROR; - switch (e.getErrorClass()) { - case YAPC_NO_ERROR: - break; - /// bad domain, "first argument often is the predicate. - case DOMAIN_ERROR: { - switch (en) { - case DOMAIN_ERROR_OUT_OF_RANGE: - case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: - SWIG_exception(SWIG_IndexError, e.text()); - break; - case DOMAIN_ERROR_CLOSE_OPTION: - case DOMAIN_ERROR_ENCODING: - case DOMAIN_ERROR_PROLOG_FLAG: - case DOMAIN_ERROR_ABSOLUTE_FILE_NAME_OPTION: - case DOMAIN_ERROR_READ_OPTION: - case DOMAIN_ERROR_SET_STREAM_OPTION: - SWIG_exception(SWIG_AttributeError, e.text()); - break; - case DOMAIN_ERROR_FILE_ERRORS: - case DOMAIN_ERROR_FILE_TYPE: - case DOMAIN_ERROR_IO_MODE: - case DOMAIN_ERROR_SOURCE_SINK: - case DOMAIN_ERROR_STREAM_POSITION: - SWIG_exception(SWIG_IOError, e.text()); - break; - default: - SWIG_exception(SWIG_ValueError, e.text()); - } - } break; - /// bad arithmetic - case EVALUATION_ERROR: { - switch (en) { - case EVALUATION_ERROR_FLOAT_OVERFLOW: - case EVALUATION_ERROR_FLOAT_UNDERFLOW: - case EVALUATION_ERROR_INT_OVERFLOW: - case EVALUATION_ERROR_UNDERFLOW: - SWIG_exception(SWIG_OverflowError, e.text()); - break; - case EVALUATION_ERROR_ZERO_DIVISOR: - SWIG_exception(SWIG_DivisionByZero, e.text()); - break; - default: - SWIG_exception(SWIG_RuntimeError, e.text()); - } - } break; - /// missing object (I/O mostly) - case EXISTENCE_ERROR: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// should be bound - case INSTANTIATION_ERROR_CLASS: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// bad access, I/O - case PERMISSION_ERROR: { - switch (en) { - case PERMISSION_ERROR_INPUT_BINARY_STREAM: - case PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM: - case PERMISSION_ERROR_INPUT_STREAM: - case PERMISSION_ERROR_INPUT_TEXT_STREAM: - case PERMISSION_ERROR_OPEN_SOURCE_SINK: - case PERMISSION_ERROR_OUTPUT_BINARY_STREAM: - case PERMISSION_ERROR_REPOSITION_STREAM: - case PERMISSION_ERROR_OUTPUT_STREAM: - case PERMISSION_ERROR_OUTPUT_TEXT_STREAM: - SWIG_exception(SWIG_OverflowError, e.text()); - break; - default: - SWIG_exception(SWIG_RuntimeError, e.text()); - } - } break; - /// something that could not be represented into a type - case REPRESENTATION_ERROR: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// not enough .... - case RESOURCE_ERROR: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// bad text - case SYNTAX_ERROR_CLASS: - SWIG_exception(SWIG_SyntaxError, e.text()); - break; - /// OS or internal - case SYSTEM_ERROR_CLASS: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// bad typing - case TYPE_ERROR: - SWIG_exception(SWIG_TypeError, e.text()); - break; - /// should be unbound - case UNINSTANTIATION_ERROR_CLASS: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// escape hatch - default: - break; - } - } -} + %include "yapa.hh" -#endif + %include "yapie.hh" - /* turn on director wrapping Callback */ -%feature("director") YAPCallback; + %include "yapt.hh" -// %include "yapi.hh" + %include "yapdb.hh" -%include "yapa.hh" + %include "yapq.hh" - %include "yapie.hh" - - %include "yapt.hh" - - %include "yapdb.hh" - - %include "yapq.hh" - -%init %{ -#ifdef SWIGPYTHON - init_python(); -#endif -%} + %init %{ + %} diff --git a/pl/absf.yap b/pl/absf.yap index 741ea3fac..52dbdac4c 100755 --- a/pl/absf.yap +++ b/pl/absf.yap @@ -419,15 +419,17 @@ absolute_file_name(File0,File) :- user:library_directory( Dir ). % '$split_by_sep'(0, 0, Dirs, Dir). '$system_library_directories'(foreign, Dir) :- - foreign_directory( Dir ). + foreign_directory( Dir ). % compatibility with old versions -% search the current directory first. +% +% search the current directory first. '$system_library_directories'(commons, Dir) :- commons_directory( Dir ). % enumerate all paths separated by a path_separator. '$paths'(Cs, C) :- + atom(Cs), ( current_prolog_flag(windows, true) -> Sep = ';' ; Sep = ':' ), sub_atom(Cs, N0, 1, N, Sep), diff --git a/pl/load_foreign.yap b/pl/load_foreign.yap index f5e4fd99d..6b06fb811 100644 --- a/pl/load_foreign.yap +++ b/pl/load_foreign.yap @@ -57,12 +57,13 @@ YAP supports the SWI-Prolog interface to loading foreign code, the shlib package load_foreign_files(Objs,Libs,Entry) :- source_module(M), '$check_objs_for_load_foreign_files'(Objs,NewObjs,load_foreign_files(Objs,Libs,Entry)), - '$check_libs_for_load_foreign_files'(Libs,NewLibs,load_foreign_files(Objs,Libs,Entry)), - '$check_entry_for_load_foreign_files'(Entry,load_foreign_files(Objs,Libs,Entry)), +'$check_libs_for_load_foreign_files'(Libs,NewLibs,load_foreign_files(Objs,Libs,Entry)), +'$check_entry_for_load_foreign_files'(Entry,load_foreign_files(Objs,Libs,Entry)), ( recordzifnot( '$foreign', M:'$foreign'(Objs,Libs,Entry), _) -> - '$load_foreign_files'(NewObjs,NewLibs,Entry), + +'$load_foreign_files'(NewObjs,NewLibs,Entry), ( prolog_load_context(file, F) -> diff --git a/pl/pathconf.yap b/pl/pathconf.yap index 42b903341..64b62fbf0 100644 --- a/pl/pathconf.yap +++ b/pl/pathconf.yap @@ -87,12 +87,10 @@ foreign_directory( Path ):- A \== yap. prolog_file_type(A, executable) :- current_prolog_flag(shared_object_extension, A). -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - + prolog_file_type(pyd, executable). +~~~~~~~~~~~~~~~~~~~~~ */ -:- multifile prolog_file_type/2. - :- dynamic prolog_file_type/2. prolog_file_type(yap, prolog). @@ -106,7 +104,8 @@ prolog_file_type(A, prolog) :- prolog_file_type(qly, qly). prolog_file_type(A, executable) :- current_prolog_flag(shared_object_extension, A). - + prolog_file_type(pyd, executable). + /** @pred file_search_path(+Name:atom, -Directory:atom) is nondet