27#define C_INTERFACE_C 1
28#define _EXPORT_KERNEL 1
41#if _MSC_VER || defined(__MINGW32__)
49#include "YapSignals.h"
58#include "tab.macros.h"
79typedef void *functor_t;
90 struct PL_local_data *engine;
93X_API
bool python_in_python;
95X_API
int YAP_Reset(yap_reset_t mode,
bool reset_global);
98#define strncpy(X, Y, Z) strcpy(X, Y)
101#define strncat(X, Y, Z) strcat(X, Y)
104#if defined(_WIN32) && !defined(X_API)
105#define X_API __declspec(dllexport)
108#define SOURCEBOOTPath NULL
110#define BOOT_FROM_SAVED_STATE true
146 Yap_RebootHandles(worker_id);
153 Yap_RebootHandles(worker_id);
211static arity_t current_arity(
void) {
213 if (P && PREVOP(P, Osbpp)->opc == Yap_opcode(_call_usercpred)) {
214 return PREVOP(P, Osbpp)->y_u.Osbpp.p->ArityOfPE;
220static int doexpand(UInt sz) {
224 Yap_track_cpred( 0, P, 0, &info);
225 if (!Yap_gc(&info)) {
231X_API YAP_Term YAP_A(
int i) {
233 return (Deref(XREGS[i]));
236X_API YAP_Term YAP_SetA(
int i, YAP_Term t) {
238 return (Deref(XREGS[i]));
241X_API YAP_Bool YAP_IsIntTerm(YAP_Term t) {
return IsIntegerTerm(t); }
243X_API YAP_Bool YAP_IsNumberTerm(YAP_Term t) {
244 return IsIntegerTerm(t) || IsIntTerm(t) || IsFloatTerm(t) || IsBigIntTerm(t);
247X_API YAP_Bool YAP_IsLongIntTerm(YAP_Term t) {
return IsLongIntTerm(t); }
249X_API YAP_Bool YAP_IsBigNumTerm(YAP_Term t) {
253 if (!IsBigIntTerm(t))
256 return pt[1] == BIG_INT;
260X_API YAP_Bool YAP_IsRationalTerm(YAP_Term t) {
264 if (!IsBigIntTerm(t))
267 return pt[1] == BIG_RATIONAL;
270X_API YAP_Bool YAP_IsStringTerm(YAP_Term t) {
return (IsStringTerm(t)); }
272X_API YAP_Bool YAP_IsVarTerm(YAP_Term t) {
return (IsVarTerm(t)); }
274X_API YAP_Bool YAP_IsNonVarTerm(YAP_Term t) {
return (IsNonVarTerm(t)); }
276X_API YAP_Bool YAP_IsFloatTerm(Term t) {
return (IsFloatTerm(t)); }
278X_API YAP_Bool YAP_IsDbRefTerm(Term t) {
return (IsDBRefTerm(t)); }
280X_API YAP_Bool YAP_IsAtomTerm(Term t) {
return (IsAtomTerm(t)); }
282X_API YAP_Bool YAP_IsPairTerm(Term t) {
return (IsPairTerm(t)); }
284X_API YAP_Bool YAP_IsApplTerm(Term t) {
285 return IsApplTerm(t) && !IsExtensionFunctor(FunctorOfTerm(t));
288X_API YAP_Bool YAP_IsCompoundTerm(Term t) {
289 return (IsApplTerm(t) && !IsExtensionFunctor(FunctorOfTerm(t))) ||
293X_API Term YAP_MkIntTerm(Int n) {
298 I = MkIntegerTerm(n);
303X_API Term YAP_MkStringTerm(
const char *n) {
313X_API Term YAP_MkCharPTerm(
char *n) {
323X_API Term YAP_MkUnsignedStringTerm(
const unsigned char *n) {
328 I = MkUStringTerm(n);
333X_API
const char *YAP_StringOfTerm(Term t) {
return StringOfTerm(t); }
335X_API
const unsigned char *YAP_UnsignedStringOfTerm(Term t) {
336 return UStringOfTerm(t);
339X_API Int YAP_IntOfTerm(Term t) {
343 return LongIntOfTerm(t);
347X_API Term YAP_MkBigNumTerm(
void *big) {
350 I = Yap_MkBigIntTerm(big);
355X_API YAP_Bool YAP_BigNumOfTerm(Term t,
void *b) {
359 if (!IsBigIntTerm(t))
361 mpz_set(bz, Yap_BigIntOfTerm(t));
366X_API Term YAP_MkRationalTerm(
void *big) {
369 I = Yap_MkBigRatTerm((
MP_RAT *)big);
375X_API YAP_Bool YAP_RationalOfTerm(Term t,
void *b) {
379 if (!IsBigIntTerm(t))
381 mpq_set(br, Yap_BigRatOfTerm(t));
386X_API Term YAP_MkBlobTerm(
unsigned int sz) {
390 while (HR + (sz + 4) > ASP - 1024) {
391 if (!doexpand((sz + 4) *
sizeof(CELL))) {
392 Yap_Error(RESOURCE_ERROR_STACK, TermNil,
393 "YAP failed to grow the stack while constructing a blob: %s",
399 HR[0] = (CELL)FunctorBlob;
403 HR[-1] = CloseExtension((I));
409X_API
void *YAP_BlobOfTerm(Term t) {
416 return (RepAppl(t) + 3);
419X_API Term YAP_MkFloatTerm(
double n) {
430X_API YAP_Float YAP_FloatOfTerm(YAP_Term t) {
return (FloatOfTerm(t)); }
432X_API Term YAP_MkAtomTerm(YAP_Atom n) {
439X_API YAP_Atom YAP_AtomOfTerm(Term t) {
return (AtomOfTerm(t)); }
441X_API
bool YAP_IsWideAtom(YAP_Atom a) {
442 const unsigned char *s = RepAtom(a)->UStrOfAE;
445 size_t n = get_utf8(s, 1, &v);
452X_API
const char *YAP_AtomName(YAP_Atom a) {
459X_API
const wchar_t *YAP_WideAtomName(YAP_Atom a) {
461 const unsigned char *s = RepAtom(a)->UStrOfAE;
462 size_t n = strlen_utf8(s);
463 wchar_t *dest =
Malloc((n + 1) *
sizeof(
wchar_t)), *o = dest;
465 size_t n = get_utf8(s, 1, &v);
474X_API YAP_Atom YAP_LookupAtom(
const char *c) {
479 a = Yap_LookupAtom(c);
480 if (a == NIL || Yap_get_signal(YAP_CDOVF_SIGNAL)) {
481 if (!Yap_locked_growheap(FALSE, 0, NULL)) {
482 Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"YAP failed to grow heap: %s",
492X_API YAP_Atom YAP_LookupWideAtom(
const wchar_t *c) {
497 a = Yap_NWCharsToAtom(c, -1 USES_REGS);
498 if (a == NIL || Yap_get_signal(YAP_CDOVF_SIGNAL)) {
499 if (!Yap_locked_growheap(FALSE, 0, NULL)) {
500 Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"YAP failed to grow heap: %s",
510X_API YAP_Atom YAP_FullLookupAtom(
const char *c) {
515 at = Yap_FullLookupAtom(c);
516 if (at == NIL || Yap_get_signal(YAP_CDOVF_SIGNAL)) {
517 if (!Yap_locked_growheap(FALSE, 0, NULL)) {
518 Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"YAP failed to grow heap: %s",
528X_API
size_t YAP_AtomNameLength(YAP_Atom at) {
530 return RepAtom(at)->rep.blob->length;
532 unsigned char *c = RepAtom(at)->UStrOfAE;
534 return strlen_utf8(c);
537X_API Term YAP_MkVarTerm(
void) {
548X_API Term YAP_MkPairTerm(Term t1, Term t2) {
553 while (HR > ASP - 1024) {
554 Int sl1 = Yap_InitSlot(t1);
555 Int sl2 = Yap_InitSlot(t2);
559 Yap_track_cpred( 0, P, 0, &info);
560 if (!Yap_gc(&info)) {
563 t1 = Yap_GetFromSlot(sl1);
564 t2 = Yap_GetFromSlot(sl2);
565 Yap_RecoverSlots(2, sl2);
567 t = MkPairTerm(t1, t2);
572X_API Term YAP_MkListFromTerms(Term *ta, Int sz) {
579 while (HR + sz * 2 > ASP - 1024) {
580 Int sl1 = Yap_InitSlot((CELL)ta);
586 ta = (CELL *)Yap_GetFromSlot(sl1);
587 Yap_RecoverSlots(1, sl1);
599 h[1] = AbsPair(h + 2);
608X_API Term YAP_MkNewPairTerm() {
616 t = Yap_MkNewPairTerm();
622X_API Term YAP_HeadOfTerm(Term t) {
return (HeadOfTerm(t)); }
624X_API Term YAP_TailOfTerm(Term t) {
return (TailOfTerm(t)); }
626X_API Int YAP_SkipList(Term *l, Term **tailp) {
627 return Yap_SkipList(l, tailp);
632 do_derefa(v, l, derefa_unk, derefa_nonvar);
635 if (IsPairTerm(*l)) {
636 intptr_t power = 1, lam = 0;
646 do_derefa(v, l, derefa2_unk, derefa2_nonvar);
647 }
while (*l != *s && IsPairTerm(*l));
654X_API Term YAP_MkApplTerm(YAP_Functor f, UInt arity, Term args[]) {
659 if (HR + arity > ASP - 1024)
662 t = Yap_MkApplTerm(f, arity, args);
667X_API Term YAP_MkNewApplTerm(YAP_Functor f, UInt arity) {
672 if (HR + arity > ASP - 1024)
675 t = Yap_MkNewApplTerm(f, arity);
681X_API YAP_Functor YAP_FunctorOfTerm(Term t) {
return (FunctorOfTerm(t)); }
683X_API Term YAP_ArgOfTerm(UInt n, Term t) {
return (ArgOfTerm(n, t)); }
685X_API Term *YAP_ArgsOfTerm(Term t) {
687 return RepAppl(t) + 1;
688 else if (IsPairTerm(t))
693X_API YAP_Functor YAP_MkFunctor(YAP_Atom a, UInt n) {
694 return (Yap_MkFunctor(a, n));
697X_API YAP_Atom YAP_NameOfFunctor(YAP_Functor f) {
return (NameOfFunctor(f)); }
699X_API UInt YAP_ArityOfFunctor(YAP_Functor f) {
return (ArityOfFunctor(f)); }
703X_API
void *YAP_ExtraSpaceCut(
void) {
709 ptr = (
void *)(((CELL *)(Yap_REGS.CUT_C_TOP)) -
710 (((
yamop *)Yap_REGS.CUT_C_TOP->try_userc_cut_yamop)
711 ->y_u.OtapFs.extra));
718X_API
void *YAP_ExtraSpace(
void) {
725 ptr = (
void *)((CELL *)(B + 1) + P->y_u.OtapFs.s);
733X_API
void YAP_cut_up(
void) {
737 while (POP_CHOICE_POINT(B->cp_b)) {
743 if (ENV > B->cp_env) {
752 if (POP_CHOICE_POINT(B->cp_b)) {
755 CUT_prune_to(cut_pt);
761 if (POP_CHOICE_POINT(B->cp_b)) {
771X_API
bool YAP_Unify(Term t1, Term t2) {
773 BACKUP_MACHINE_REGS();
775 out = Yap_unify(t1, t2);
777 RECOVER_MACHINE_REGS();
781X_API
int YAP_Unifiable(Term t1, Term t2) {
783 BACKUP_MACHINE_REGS();
785 out = Yap_Unifiable(t1, t2);
787 RECOVER_MACHINE_REGS();
792X_API
int YAP_ExactlyEqual(Term t1, Term t2) {
794 BACKUP_MACHINE_REGS();
796 out = Yap_eq(t1, t2);
798 RECOVER_MACHINE_REGS();
803X_API
int YAP_Variant(Term t1, Term t2) {
805 BACKUP_MACHINE_REGS();
807 out = Yap_Variant(Deref(t1), Deref(t2));
809 RECOVER_MACHINE_REGS();
814X_API Int YAP_TermHash(Term t, Int sz, Int depth,
int variant) {
817 BACKUP_MACHINE_REGS();
819 out = Yap_TermHash(t, sz, depth, variant);
821 RECOVER_MACHINE_REGS();
827 return Yap_CurrentSlot();
830X_API Int YAP_NewSlots(
int n) {
832 return Yap_NewSlots(n);
837 return Yap_InitSlot(t);
842 return Yap_RecoverSlots(n, top_slot);
847 return Yap_GetFromSlot(slot);
852 return Yap_AddressFromSlot(slot);
857 Term *b = Yap_AddressFromSlot(slot);
862 }
else if (a == (CELL)b) {
873 Yap_PutInSlot(slot, t);
876typedef Int (*CPredicate0)(void);
878typedef Int (*CPredicate1)(yhandle_t);
880typedef Int (*CPredicate2)(yhandle_t, yhandle_t);
882typedef Int (*CPredicate3)(yhandle_t, yhandle_t, yhandle_t);
884typedef Int (*CPredicate4)(yhandle_t, yhandle_t, yhandle_t, yhandle_t);
886typedef Int (*CPredicate5)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
889typedef Int (*CPredicate6)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
890 yhandle_t, yhandle_t);
892typedef Int (*CPredicate7)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
893 yhandle_t, yhandle_t, yhandle_t);
895typedef Int (*CPredicate8)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
896 yhandle_t, yhandle_t, yhandle_t, yhandle_t);
898typedef Int (*CPredicate9)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
899 yhandle_t, yhandle_t, yhandle_t, yhandle_t,
902typedef Int (*CPredicate10)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
903 yhandle_t, yhandle_t, yhandle_t, yhandle_t,
904 yhandle_t, yhandle_t);
906typedef Int (*CPredicateV)(yhandle_t, yhandle_t,
struct foreign_context *);
908static Int execute_cargs(
PredEntry *pe, CPredicate exec_code USES_REGS) {
911 switch (pe->ArityOfPE) {
913 CPredicate0 code0 = (CPredicate0)exec_code;
917 CPredicate1 code1 = (CPredicate1)exec_code;
918 a1 = Yap_InitSlots(1, &ARG1);
922 CPredicate2 code2 = (CPredicate2)exec_code;
923 a1 = Yap_InitSlots(2, &ARG1);
924 rc = code2(a1, a1 + 1);
927 CPredicate3 code3 = (CPredicate3)exec_code;
928 a1 = Yap_InitSlots(3, &ARG1);
929 rc = code3(a1, a1 + 1, a1 + 2);
932 CPredicate4 code4 = (CPredicate4)exec_code;
933 a1 = Yap_InitSlots(4, &ARG1);
934 rc = code4(a1, a1 + 1, a1 + 2, a1 + 3);
937 CPredicate5 code5 = (CPredicate5)exec_code;
938 a1 = Yap_InitSlots(5, &ARG1);
939 rc = code5(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4);
943 CPredicate6 code6 = (CPredicate6)exec_code;
944 a1 = Yap_InitSlots(6, &ARG1);
945 rc = code6(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5);
948 CPredicate7 code7 = (CPredicate7)exec_code;
949 a1 = Yap_InitSlots(7, &ARG1);
950 rc = code7(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6);
953 CPredicate8 code8 = (CPredicate8)exec_code;
954 a1 = Yap_InitSlots(8, &ARG1);
955 rc = code8(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, a1 + 7);
958 CPredicate9 code9 = (CPredicate9)exec_code;
959 a1 = Yap_InitSlots(9, &ARG1);
960 rc = code9(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, a1 + 7,
964 CPredicate10 code10 = (CPredicate10)exec_code;
965 a1 = Yap_InitSlots(10, &ARG1);
966 rc = code10(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, a1 + 7,
970 YAP_Error(SYSTEM_ERROR_INTERNAL, TermNil,
971 "YAP only supports SWI C-call with arity =< 10");
974 Yap_RecoverSlots(pe->ArityOfPE, a1);
982typedef uintptr_t (*CBPredicate2)(yhandle_t, yhandle_t,
985typedef uintptr_t (*CBPredicate3)(yhandle_t, yhandle_t, yhandle_t,
988typedef uintptr_t (*CBPredicate4)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
991typedef uintptr_t (*CBPredicate5)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
994typedef uintptr_t (*CBPredicate6)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
995 yhandle_t, yhandle_t,
998typedef uintptr_t (*CBPredicate7)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
999 yhandle_t, yhandle_t, yhandle_t,
1002typedef uintptr_t (*CBPredicate8)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
1003 yhandle_t, yhandle_t, yhandle_t, yhandle_t,
1006typedef uintptr_t (*CBPredicate9)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
1007 yhandle_t, yhandle_t, yhandle_t, yhandle_t,
1010typedef uintptr_t (*CBPredicate10)(yhandle_t, yhandle_t, yhandle_t, yhandle_t,
1011 yhandle_t, yhandle_t, yhandle_t, yhandle_t,
1012 yhandle_t, yhandle_t,
1015static uintptr_t execute_cargs_back(
PredEntry *pe, CPredicate exec_code,
1017 switch (pe->ArityOfPE) {
1019 CBPredicate0 code0 = (CBPredicate0)exec_code;
1023 CBPredicate1 code1 = (CBPredicate1)exec_code;
1024 yhandle_t a1 = Yap_InitSlots(1, &B->cp_a1);
1025 return code1(a1, ctx);
1028 CBPredicate2 code2 = (CBPredicate2)exec_code;
1029 yhandle_t a1 = Yap_InitSlots(2, &B->cp_a1);
1030 return code2(a1, a1 + 1, ctx);
1033 CBPredicate3 code3 = (CBPredicate3)exec_code;
1034 yhandle_t a1 = Yap_InitSlots(3, &B->cp_a1);
1035 return code3(a1, a1 + 1, a1 + 2, ctx);
1038 CBPredicate4 code4 = (CBPredicate4)exec_code;
1039 yhandle_t a1 = Yap_InitSlots(4, &B->cp_a1);
1040 return code4(a1, a1 + 1, a1 + 2, a1 + 3, ctx);
1043 CBPredicate5 code5 = (CBPredicate5)exec_code;
1044 yhandle_t a1 = Yap_InitSlots(5, &B->cp_a1);
1045 return code5(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, ctx);
1048 CBPredicate6 code6 = (CBPredicate6)exec_code;
1049 yhandle_t a1 = Yap_InitSlots(6, &B->cp_a1);
1050 return code6(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, ctx);
1053 CBPredicate7 code7 = (CBPredicate7)exec_code;
1054 yhandle_t a1 = Yap_InitSlots(7, &B->cp_a1);
1055 return code7(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, ctx);
1058 CBPredicate8 code8 = (CBPredicate8)exec_code;
1059 yhandle_t a1 = Yap_InitSlots(8, &B->cp_a1);
1060 return code8(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, a1 + 7,
1064 CBPredicate9 code9 = (CBPredicate9)exec_code;
1065 yhandle_t a1 = Yap_InitSlots(9, &B->cp_a1);
1066 return code9(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, a1 + 7,
1070 CBPredicate10 code10 = (CBPredicate10)exec_code;
1071 yhandle_t a1 = Yap_InitSlots(10, &B->cp_a1);
1072 return code10(a1, a1 + 1, a1 + 2, a1 + 3, a1 + 4, a1 + 5, a1 + 6, a1 + 7,
1073 a1 + 8, a1 + 9, ctx);
1076 YAP_Error(SYSTEM_ERROR_INTERNAL, TermNil,
1077 "YAP only supports SWI C-call with arity =< 10");
1082static uintptr_t complete_fail(
choiceptr ptr,
int has_cp USES_REGS) {
1085 while (B && B->cp_b && B->cp_b <= ptr) {
1089 return do_cut(FALSE);
1093static uintptr_t complete_exit(
choiceptr ptr,
int has_cp,
1094 int cut_all USES_REGS) {
1096 while (B && (!ptr || B < ptr)) {
1097 if (cut_all || B->cp_ap == EXITCODE) {
1100 }
else if (B->cp_ap->opc == RETRY_USERC_OPCODE && B->cp_b == ptr) {
1102 return do_cut(TRUE);
1106 if (!ptr || B < ptr) {
1109 while (
new &&
new < ptr) {
1110 if (new->cp_ap == EXITCODE)
1111 new->cp_ap = FAILCODE;
1113 else if (new->cp_ap->opc == RETRY_USERC_OPCODE && new->cp_b == ptr) {
1115 new->cp_ap = FAILCODE;
1123 return do_cut(TRUE);
1125 ptr->cp_ap = FAILCODE;
1131X_API Int YAP_Execute(
PredEntry *pe, CPredicate exec_code) {
1132 BACKUP_MACHINE_REGS();
1135 Int OASP = LCL0 - (CELL *)B;
1140 int lvl = push_text_stack();
1141 yhandle_t hdl = Yap_CurrentHandle();
1142 if (pe->PredFlags & SWIEnvPredFlag) {
1143 CPredicateV codev = (CPredicateV)exec_code;
1147 yhandle_t s0 = Yap_InitSlots(pe->ArityOfPE, &ARG1);
1149 ret = codev(s0, 0, &ctx);
1150 }
else if (pe->PredFlags & CArgsPredFlag) {
1152 ret = execute_cargs(pe, exec_code PASS_REGS);
1155 ret = (exec_code)(PASS_REGS1);
1160 complete_exit(((
choiceptr)(LCL0 - OASP)), FALSE, FALSE PASS_REGS);
1162 complete_fail(((
choiceptr)(LCL0 - OASP)), FALSE PASS_REGS);
1164 Yap_RecoverHandles(0, hdl);
1165 pop_text_stack( lvl );
1167 RECOVER_MACHINE_REGS();
1174#define FRG_REDO_MASK 0x00000003L
1175#define FRG_REDO_BITS 2
1176#define REDO_INT 0x02
1177#define REDO_PTR 0x03
1179X_API Int YAP_ExecuteFirst(
PredEntry *pe, CPredicate exec_code) {
1181 CELL ocp = LCL0 - (CELL *)B;
1183 Int CurSlot = Yap_StartSlots();
1185 (SWIEnvPredFlag | CArgsPredFlag | ModuleTransparentPredFlag)) {
1187 CPredicateV codev = (CPredicateV)exec_code;
1192 ctx->control = FRG_FIRST_CALL;
1194 ctx->context = (uintptr_t)NULL;
1195 if (pe->PredFlags & CArgsPredFlag) {
1196 val = execute_cargs_back(pe, exec_code, ctx PASS_REGS);
1198 val = codev(Yap_InitSlots(pe->ArityOfPE, &ARG1), 0, ctx);
1200 Yap_CloseSlots(CurSlot);
1206 return complete_fail(((
choiceptr)(LCL0 - ocp)), TRUE PASS_REGS);
1207 }
else if (val == 1) {
1208 return complete_exit(((
choiceptr)(LCL0 - ocp)), TRUE, FALSE PASS_REGS);
1210 if ((val & REDO_PTR) == REDO_PTR)
1211 ctx->context = (uintptr_t)(val & ~REDO_PTR);
1213 ctx->context = (uintptr_t)((val & ~REDO_PTR) >> FRG_REDO_BITS);
1215 return complete_exit(((
choiceptr)(LCL0 - ocp)), FALSE, FALSE PASS_REGS);
1218 Int ret = (exec_code)(PASS_REGS1);
1219 Yap_CloseSlots(CurSlot);
1227X_API Int YAP_ExecuteOnCut(
PredEntry *pe, CPredicate exec_code,
1230 Int oB = LCL0 - (CELL *)B;
1233 yhandle_t CurSlot = Yap_StartSlots();
1236 oB = LCL0 - (CELL *)B;
1240 if (pe->PredFlags & (SWIEnvPredFlag | CArgsPredFlag)) {
1242 CPredicateV codev = (CPredicateV)exec_code;
1245 CELL *args = B->cp_args;
1248 ctx->control = FRG_CUTTED;
1250 if (pe->PredFlags & CArgsPredFlag) {
1251 val = execute_cargs_back(pe, exec_code, ctx PASS_REGS);
1253 val = codev(Yap_InitSlots(pe->ArityOfPE, args), 0, ctx);
1256 Int oYENV = LCL0 - YENV;
1257 yamop *oP = P, *oCP = CP;
1260 val = exec_code(PASS_REGS1);
1261 YENV = LCL0 - oYENV;
1265 Yap_CloseSlots(CurSlot);
1275X_API Int YAP_ExecuteNext(
PredEntry *pe, CPredicate exec_code) {
1279 UInt ocp = LCL0 - (CELL *)B;
1280 if (pe->PredFlags & (SWIEnvPredFlag | CArgsPredFlag)) {
1282 CPredicateV codev = (CPredicateV)exec_code;
1287 ctx->control = FRG_REDO;
1288 if (pe->PredFlags & CArgsPredFlag) {
1289 val = execute_cargs_back(pe, exec_code, ctx PASS_REGS);
1291 val = codev(Yap_InitSlots(pe->ArityOfPE, &ARG1), 0, ctx);
1300 return complete_fail(((
choiceptr)(LCL0 - ocp)), TRUE PASS_REGS);
1302 }
else if (val == 1) {
1303 return complete_exit(((
choiceptr)(LCL0 - ocp)), TRUE, FALSE PASS_REGS);
1305 if ((val & REDO_PTR) == REDO_PTR)
1306 ctx->context = (uintptr_t)(val & ~REDO_PTR);
1308 ctx->context = (uintptr_t)((val & ~REDO_PTR) >> FRG_REDO_BITS);
1311 return complete_exit(((
choiceptr)(LCL0 - ocp)), FALSE, FALSE PASS_REGS);
1313 Int ret = (exec_code)(PASS_REGS1);
1321X_API
void *YAP_ReallocSpaceFromYap(
void *ptr,
size_t size) {
1324 BACKUP_MACHINE_REGS();
1325 while ((new_ptr = Yap_ReallocCodeSpace(ptr, size)) == NULL) {
1326 if (!Yap_growheap(FALSE, size, NULL)) {
1327 Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
1331 RECOVER_MACHINE_REGS();
1335X_API
void *YAP_AllocSpaceFromYap(
size_t size) {
1338 BACKUP_MACHINE_REGS();
1340 while ((ptr = Yap_AllocCodeSpace(size)) == NULL) {
1341 if (!Yap_growheap(FALSE, size, NULL)) {
1342 Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
1346 RECOVER_MACHINE_REGS();
1350X_API
void YAP_FreeSpaceFromYap(
void *ptr) { Yap_FreeCodeSpace(ptr); }
1364 BACKUP_MACHINE_REGS();
1366 int l = push_text_stack();
1368 inp.type = YAP_STRING_ATOMS_CODES | YAP_STRING_STRING | YAP_STRING_ATOM |
1369 YAP_STRING_TRUNC | YAP_STRING_MALLOC;
1371 out.type = YAP_STRING_CHARS;
1373 out.enc = ENC_ISO_UTF8;
1374 if (!Yap_CVT_Text(&inp, &out PASS_REGS)) {
1376 RECOVER_MACHINE_REGS();
1379 RECOVER_MACHINE_REGS();
1380 if (buf == out.val.c) {
1383 return pop_output_text_stack(l, out.val.c);
1389X_API Term YAP_BufferToString(
const char *s) {
1396 inp.type = YAP_STRING_CHARS;
1397 out.type = YAP_STRING_CODES;
1398 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1407X_API Term YAP_NBufferToString(
const char *s,
size_t len) {
1414 inp.type = YAP_STRING_CHARS;
1415 out.type = YAP_STRING_CODES | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
1417 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1426X_API Term YAP_WideBufferToString(
const wchar_t *s) {
1433 inp.type = YAP_STRING_WCHARS;
1434 out.type = YAP_STRING_CODES;
1435 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1444X_API Term YAP_NWideBufferToString(
const wchar_t *s,
size_t len) {
1451 inp.type = YAP_STRING_WCHARS;
1452 out.type = YAP_STRING_CODES | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
1454 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1463X_API Term YAP_ReadBuffer(
const char *s, Term *tp) {
1468 LOCAL_ErrorMessage = NULL;
1469 while (!(t = Yap_BufferToTerm(s, TermNil))) {
1470 if (LOCAL_Error_TYPE) {
1471 if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {
1472 if (!Yap_dogc( PASS_REGS1)) {
1473 *tp = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage));
1474 Yap_ThrowError(RESOURCE_ERROR_STACK, MkStringTerm(s),NULL);
1478 }
else if (LOCAL_Error_TYPE == RESOURCE_ERROR_HEAP) {
1479 if (!Yap_growheap(FALSE, 0, NULL)) {
1480 *tp = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage));
1481 Yap_ThrowError(RESOURCE_ERROR_HEAP, MkStringTerm(s),NULL);
1485 }
else if (LOCAL_Error_TYPE == RESOURCE_ERROR_TRAIL) {
1486 if (!Yap_growtrail(0, FALSE)) {
1487 *tp = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage));
1488 Yap_ThrowError(RESOURCE_ERROR_HEAP, MkStringTerm(s),NULL);
1493 if (LOCAL_Error_TYPE == YAP_NO_ERROR) {
1494 Yap_ThrowError(LOCAL_Error_TYPE , MkStringTerm(s), NULL);
1498 LOCAL_ErrorMessage = NULL;
1511X_API YAP_Term YAP_BufferToAtomList(
const char *s) {
1518 inp.type = YAP_STRING_CHARS;
1519 out.type = YAP_STRING_ATOMS;
1520 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1529X_API Term YAP_NBufferToAtomList(
const char *s,
size_t len) {
1536 inp.type = YAP_STRING_CHARS;
1537 out.type = YAP_STRING_ATOMS | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
1539 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1548X_API Term YAP_WideBufferToAtomList(
const wchar_t *s) {
1555 inp.type = YAP_STRING_WCHARS;
1556 out.type = YAP_STRING_ATOMS;
1557 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1566X_API Term YAP_NWideBufferToAtomList(
const wchar_t *s,
size_t len) {
1573 inp.type = YAP_STRING_WCHARS;
1574 out.type = YAP_STRING_ATOMS | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
1576 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1585X_API Term YAP_NWideBufferToAtomDiffList(
const wchar_t *s, Term t0,
1593 inp.type = YAP_STRING_WCHARS;
1595 YAP_STRING_ATOMS | YAP_STRING_NCHARS | YAP_STRING_TRUNC | YAP_STRING_DIFF;
1598 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1607X_API Term YAP_BufferToDiffList(
const char *s, Term t0) {
1614 inp.type = YAP_STRING_CHARS;
1615 out.type = YAP_STRING_CODES | YAP_STRING_DIFF;
1617 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1626X_API Term YAP_NBufferToDiffList(
const char *s, Term t0,
size_t len) {
1633 inp.type = YAP_STRING_CHARS;
1635 YAP_STRING_CODES | YAP_STRING_NCHARS | YAP_STRING_TRUNC | YAP_STRING_DIFF;
1638 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1647X_API Term YAP_WideBufferToDiffList(
const wchar_t *s, Term t0) {
1654 inp.type = YAP_STRING_WCHARS;
1655 out.type = YAP_STRING_CODES | YAP_STRING_DIFF;
1657 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1666X_API Term YAP_NWideBufferToDiffList(
const wchar_t *s, Term t0,
size_t len) {
1673 inp.type = YAP_STRING_WCHARS;
1675 YAP_STRING_CODES | YAP_STRING_NCHARS | YAP_STRING_TRUNC | YAP_STRING_DIFF;
1678 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1686X_API
void YAP_Error__(
const char *file,
const char *
function,
int lineno,
int myerrno, Term t,
const char *buf, ...) {
1687#define YAP_BUF_SIZE 512
1689 char tmpbuf[YAP_BUF_SIZE];
1692 myerrno = SYSTEM_ERROR_INTERNAL;
1698 (void)vsnprintf(tmpbuf, YAP_BUF_SIZE, buf, ap);
1700 (void)vsprintf(tmpbuf, buf, ap);
1709X_API YAP_PredEntryPtr YAP_FunctorToPred(YAP_Functor func) {
1711 return RepPredProp(PredPropByFunc(func, CurrentModule));
1714X_API YAP_PredEntryPtr YAP_AtomToPred(YAP_Atom at) {
1716 return RepPredProp(PredPropByAtom(at, CurrentModule));
1719X_API YAP_PredEntryPtr YAP_FunctorToPredInModule(YAP_Functor func, Term mod) {
1720 return RepPredProp(PredPropByFunc(func, mod));
1723X_API YAP_PredEntryPtr YAP_AtomToPredInModule(YAP_Atom at, Term mod) {
1724 return RepPredProp(PredPropByAtom(at, mod));
1737X_API
bool YAP_EnterGoal(YAP_PredEntryPtr ape, CELL *ptr,
YAP_dogoalinfo *dgi) {
1745 BACKUP_MACHINE_REGS();
1746 dgi->lvl = push_text_stack();
1747 LOCAL_ActiveError->errorNo = YAP_NO_ERROR;
1748 LOCAL_PrologMode = UserMode;
1751 dgi->b0 = LCL0 - (CELL *)B;
1752 dgi->env0 = LCL0 - ENV;
1755 Yap_PrepGoal(pe->ArityOfPE,
nullptr, B PASS_REGS);
1760 dgi->b_entry = LCL0 - (CELL *)B;
1762 dgi->tr = (CELL *)TR - LCL0;
1765 out = Yap_exec_absmi(
true,
false);
1769 dgi->b_exit = LCL0 - (CELL *)B;
1771 dgi->EndSlot = LOCAL_CurSlot;
1777 pop_text_stack(dgi->lvl);
1778 RECOVER_MACHINE_REGS();
1787 BACKUP_MACHINE_REGS();
1788 dgi->lvl = push_text_stack();
1790 myB0 = (
choiceptr)(LCL0 - dgi->b_entry);
1794 if (B->cp_ap == TRUSTFAILCODE)
1796 else if (B->cp_ap == FAILCODE)
1799 if (B->cp_ap == NOCODE)
1809 LOCAL_CurSlot = dgi->EndSlot;
1810 out = Yap_exec_absmi(
true,
true );
1812 dgi->EndSlot = LOCAL_CurSlot;
1813 dgi->b_exit = LCL0 - (CELL *)B;
1815 printf(
"F %ld\n", dgi->CurSlot);
1819 pop_text_stack(dgi->lvl);
1820 RECOVER_MACHINE_REGS();
1831 BACKUP_MACHINE_REGS();
1833 dgi->lvl = push_text_stack();
1842 }
else if (LOCAL_PrologMode & AsyncIntMode) {
1843 Yap_signal(YAP_FAIL_SIGNAL);
1847 DEPTH = B->cp_depth;
1851 YENV = ENV = LCL0-dgi->env0;
1854 pop_text_stack(dgi->lvl);
1855 RECOVER_MACHINE_REGS();
1862X_API Int YAP_RunGoal(Term t) {
1865 yhandle_t cslot = LOCAL_CurSlot;
1866 BACKUP_MACHINE_REGS();
1868int lvl = push_text_stack();
1870 LOCAL_AllowRestart = FALSE;
1871 LOCAL_PrologMode = UserMode;
1872 out = Yap_RunTopGoal(t,
true);
1873 LOCAL_PrologMode = UserCCallMode;
1876 RECOVER_MACHINE_REGS();
1877 LOCAL_CurSlot = cslot;
1878 pop_text_stack(lvl);
1882X_API Term YAP_AllocExternalDataInStack(
size_t bytes) {
1884 Term t = Yap_AllocExternalDataInStack(EXTERNAL_BLOB, bytes, &pt);
1890X_API YAP_Bool YAP_IsExternalDataInStackTerm(Term t) {
1891 return IsExternalBlobTerm(t, EXTERNAL_BLOB);
1894X_API
void *YAP_ExternalDataInStackFromTerm(Term t) {
1895 return ExternalBlobFromTerm(t);
1900 if (!GLOBAL_OpaqueHandlersCount) {
1901 GLOBAL_OpaqueHandlers =
1903 if (!GLOBAL_OpaqueHandlers) {
1907 GLOBAL_OpaqueHandlersCount = USER_BLOB_START;
1908 }
else if (GLOBAL_OpaqueHandlersCount == USER_BLOB_END) {
1912 i = GLOBAL_OpaqueHandlersCount++;
1917X_API Term YAP_NewOpaqueObject(YAP_opaque_tag_t blob_tag,
size_t bytes) {
1919 Term t = Yap_AllocExternalDataInStack((CELL)blob_tag, bytes, &pt);
1922 if (blob_tag < USER_BLOB_START || blob_tag >= USER_BLOB_END) {
1923 Yap_Error(SYSTEM_ERROR_INTERNAL, AbsAppl(pt),
1924 "clean opaque: bad blob with tag " UInt_FORMAT, blob_tag);
1927 YAP_opaque_tag_t blob_info = blob_tag;
1928 if (GLOBAL_OpaqueHandlers[blob_info].cut_handler ||
1929 GLOBAL_OpaqueHandlers[blob_info].fail_handler) {
1932 TrailTerm(TR) = AbsPair(HR - 2);
1937X_API YAP_Bool YAP_IsOpaqueObjectTerm(Term t, YAP_opaque_tag_t tag) {
1938 return IsExternalBlobTerm(t, (CELL)tag);
1941X_API
void *YAP_OpaqueObjectFromTerm(Term t) {
return ExternalBlobFromTerm(t); }
1943X_API CELL *YAP_HeapStoreOpaqueTerm(Term t) {
1944 return Yap_HeapStoreOpaqueTerm(t);
1947X_API Int YAP_RunGoalOnce(Term t) {
1950 yamop *old_CP = CP, *old_P = P;
1951 Int oldPrologMode = LOCAL_PrologMode;
1954 BACKUP_MACHINE_REGS();
1955 int lvl = push_text_stack();
1956 CSlot = Yap_StartSlots();
1957 LOCAL_PrologMode = UserMode;
1959 LOCAL_AllowRestart =
true;
1960 out = Yap_RunTopGoal(t,
true);
1961 LOCAL_PrologMode = oldPrologMode;
1963 if (!(oldPrologMode & UserCCallMode)) {
1965 pop_text_stack( lvl);
1966 LOCAL_AllowRestart =
false;
1967 RECOVER_MACHINE_REGS();
1977 while (cut_pt->cp_ap != NOCODE) {
1979 if (POP_CHOICE_POINT(cut_pt->cp_b)) {
1983 cut_pt = cut_pt->cp_b;
1986 CUT_prune_to(cut_pt);
1994 Yap_CloseSlots(CSlot);
1997 ENV = (CELL *)ASP[E_E];
2000 DEPTH = ASP[E_DEPTH];
2006 pop_text_stack( lvl);
2007 LOCAL_AllowRestart =
false;
2008 RECOVER_MACHINE_REGS();
2011 LOCAL_AllowRestart =
false;
2012 RECOVER_MACHINE_REGS();
2013 pop_text_stack( lvl);
2017X_API
bool YAP_RestartGoal(
void) {
2019 BACKUP_MACHINE_REGS();
2021 if (LOCAL_AllowRestart) {
2022 P = (
yamop *)FAILCODE;
2023 LOCAL_PrologMode = UserMode;
2024 out = Yap_exec_absmi(TRUE, YAP_EXEC_ABSMI);
2025 LOCAL_PrologMode = UserCCallMode;
2029 LOCAL_AllowRestart = FALSE;
2034 RECOVER_MACHINE_REGS();
2038X_API
bool YAP_ShutdownGoal(
int backtrack) {
2040 BACKUP_MACHINE_REGS();
2042 if (LOCAL_AllowRestart) {
2046 while (cut_pt->cp_ap != NOCODE) {
2048 if (POP_CHOICE_POINT(cut_pt->cp_b)) {
2051 cut_pt = cut_pt->cp_b;
2054 CUT_prune_to(cut_pt);
2060 Yap_exec_absmi(TRUE, YAP_EXEC_ABSMI);
2066 ASP = cut_pt->cp_env;
2067 ENV = (CELL *)ASP[E_E];
2071 DEPTH = ASP[E_DEPTH];
2073 LOCAL_AllowRestart = FALSE;
2075 RECOVER_MACHINE_REGS();
2079X_API
bool YAP_ContinueGoal(
void) {
2082 BACKUP_MACHINE_REGS();
2084 LOCAL_PrologMode = UserMode;
2085 out = Yap_exec_absmi(TRUE, YAP_EXEC_ABSMI);
2086 LOCAL_PrologMode = UserCCallMode;
2088 RECOVER_MACHINE_REGS();
2099 if (POP_CHOICE_POINT(B->cp_b)) {
2112X_API
bool YAP_GoalHasException(Term *t) {
2114 BACKUP_MACHINE_REGS();
2115 return LOCAL_ActiveError->errorNo != YAP_NO_ERROR;
2118X_API
void YAP_ClearExceptions(
void) {
2124X_API
int YAP_InitConsult(
int mode,
const char *fname,
char *full,
2129 int lvl = push_text_stack();
2130 BACKUP_MACHINE_REGS();
2131 const char *fl = NULL;
2132 if (mode == YAP_BOOT_MODE) {
2133 mode = YAP_CONSULT_MODE;
2135 if (fname == NULL || fname[0] ==
'\0') {
2136 extern char * Yap_SOURCEBOOT;
2137 fl = Yap_SOURCEBOOT;
2140 __android_log_print(
2141 ANDROID_LOG_INFO,
"YAPDroid",
"failed ABSOLUTEFN %s ", fl);
2142 if (full) full[0] =
'\0';
2143 pop_text_stack(lvl);
2146 __android_log_print(
2147 ANDROID_LOG_INFO,
"YAPDroid",
"done init_ consult %s ",fl);
2148 char *d =
Malloc(strlen(fl) + 1);
2150 bool consulted = (mode == YAP_CONSULT_MODE);
2151 Term tat = MkAtomTerm(Yap_LookupAtom(d));
2152 sno = Yap_OpenStream(tat,
"r", MkAtomTerm(Yap_LookupAtom(fname)),
2154 __android_log_print(
2155 ANDROID_LOG_INFO,
"YAPDroid",
"OpenStream got %d ",sno);
2156 if (sno < 0 || !Yap_ChDir(dirname((
char *)d))) {
2157 if (full) full[0] =
'\0';
2158 pop_text_stack(lvl);
2161 LOCAL_PrologMode = UserMode;
2163 Yap_init_consult(consulted,full);
2164 RECOVER_MACHINE_REGS();
2165 UNLOCK(GLOBAL_Stream[sno].streamlock);
2166 pop_text_stack(lvl);
2174X_API FILE *YAP_TermToStream(Term t) {
2175 BACKUP_MACHINE_REGS();
2178 if (IsVarTerm(t) || !IsAtomTerm(t))
2180 if ((s = Yap_GetStreamHandle(t)->file)) {
2181 RECOVER_MACHINE_REGS();
2184 RECOVER_MACHINE_REGS();
2188X_API
void YAP_EndConsult(
int sno,
int *osnop,
const char *full) {
2189 BACKUP_MACHINE_REGS();
2190 Yap_CloseStream(sno);
2191 int lvl = push_text_stack();
2192 char *d =
Malloc(strlen(full) + 1);
2194 Yap_ChDir(dirname(d));
2196 __android_log_print(ANDROID_LOG_INFO,
"YAPDroid ",
" closing %s:%s(%d), %d",
2199 : RepAtom(AtomOfTerm(CurrentModule))->StrOfAE,
2202 pop_text_stack(lvl);
2203 RECOVER_MACHINE_REGS();
2208 int sno = Yap_FileStream(f, NULL, TermNil, Input_Stream_f, NULL);
2210 BACKUP_MACHINE_REGS();
2212 Yap_CloseStream( sno);
2213 RECOVER_MACHINE_REGS();
2220 BACKUP_MACHINE_REGS();
2223 if (sigsetjmp(signew, 0)) {
2224 Yap_syntax_error(LOCAL_toktide, sno,
"ReadFromStream");
2225 RECOVER_MACHINE_REGS();
2230 RECOVER_MACHINE_REGS();
2236 BACKUP_MACHINE_REGS();
2240 Yap_MkApplTerm(Yap_MkFunctor(AtomVariableNames, 1), 1, &vs),
2242 Yap_MkApplTerm(Yap_MkFunctor(AtomTermPosition, 1),
2246 RECOVER_MACHINE_REGS();
2250X_API
void YAP_Write(Term t, FILE *f,
int flags) {
2251 BACKUP_MACHINE_REGS();
2252 int sno = Yap_FileStream(f, NULL, TermNil, Output_Stream_f, NULL);
2254 Yap_plwrite(t, GLOBAL_Stream + sno, 0, HR, flags, NULL);
2255 Yap_CloseStream(sno);
2257 RECOVER_MACHINE_REGS();
2260X_API YAP_Term YAP_CopyTerm(Term t) {
2262 BACKUP_MACHINE_REGS();
2264 tn = Yap_CopyTerm(t);
2266 RECOVER_MACHINE_REGS();
2271X_API
char *YAP_WriteBuffer(Term t,
char *buf,
size_t sze,
int flags) {
2275 BACKUP_MACHINE_REGS();
2276 int l = push_text_stack();
2278 inp.type = YAP_STRING_TERM | YAP_STRING_DATUM;
2279 out.type = YAP_STRING_CHARS;
2282 out.enc = LOCAL_encoding;
2283 if (!Yap_CVT_Text(&inp, &out PASS_REGS)) {
2284 RECOVER_MACHINE_REGS();
2288 RECOVER_MACHINE_REGS();
2289 if (buf == out.val.c) {
2293 if ( strlen(out.val.c ) < sze) {
2294 strcpy( buf, out.val.c);
2300 return out.val.c = pop_output_text_stack(l,buf);
2306 encoding_t enc,
int flags) {
2309 BACKUP_MACHINE_REGS();
2310 b = Yap_TermToBuffer(t, flags);
2311 RECOVER_MACHINE_REGS();
2315X_API
bool YAP_CompileClause(Term t) {
2318 Term mod = CurrentModule;
2322 BACKUP_MACHINE_REGS();
2325 LOCAL_ErrorMessage = NULL;
2327 YAPEnterCriticalSection();
2328 codeaddr = Yap_cclause(t, 0, mod, t);
2329 ok = (codeaddr != NULL);
2332 if (!Yap_addclause(t, codeaddr, TermAssertz, mod, &tn)) {
2338 YAPLeaveCriticalSection();
2340 if (Yap_get_signal(YAP_CDOVF_SIGNAL)) {
2341 if (!Yap_locked_growheap(FALSE, 0, NULL)) {
2342 Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"YAP failed to grow heap: %s",
2343 LOCAL_ErrorMessage);
2347 RECOVER_MACHINE_REGS();
2354X_API
void YAP_PutValue(YAP_Atom at, Term t) { Yap_PutValue(at, t); }
2356X_API Term YAP_GetValue(YAP_Atom at) {
return (Yap_GetValue(at)); }
2358X_API
int YAP_CompareTerms(Term t1, Term t2) {
2359 return Yap_compare_terms(t1, t2);
2362X_API
int YAP_Reset(yap_reset_t mode,
bool reset_global) {
2364 BACKUP_MACHINE_REGS();
2365 res = Yap_Reset(mode, reset_global);
2366 RECOVER_MACHINE_REGS();
2370X_API
void YAP_Exit(
int retval) { Yap_exit(retval); }
2372X_API
int YAP_InitSocks(
const char *host,
long port) {
return 0; }
2374X_API
void YAP_SetOutputMessage(
void) {
2376 Yap_output_msg = TRUE;
2380X_API
int YAP_StreamToFileNo(Term t) {
return (Yap_StreamToFileNo(t)); }
2389X_API
void YAP_CloseAllOpenStreams(
void) {
2397X_API
void YAP_FlushAllStreams(
void) {
2405X_API
void YAP_Throw(Term t) {
2406 BACKUP_MACHINE_REGS();
2407 Yap_ThrowError(THROW_EVENT, t, NULL );
2408 RECOVER_MACHINE_REGS();
2411X_API
void YAP_AsyncThrow(Term t) {
2413 BACKUP_MACHINE_REGS();
2414 LOCAL_PrologMode |= AsyncIntMode;
2415 Yap_ThrowError(THROW_EVENT, t, NULL );
2416 LOCAL_PrologMode &= ~AsyncIntMode;
2417 RECOVER_MACHINE_REGS();
2420X_API
void YAP_Halt(
int i) { Yap_exit(i); }
2422X_API CELL *YAP_TopOfLocalStack(
void) {
2427X_API
void *YAP_Predicate(YAP_Atom a, UInt arity, Term
m) {
2429 return ((
void *)RepPredProp(PredPropByAtom(a,
m)));
2431 Functor f = Yap_MkFunctor(a, arity);
2432 return ((
void *)RepPredProp(PredPropByFunc(f,
m)));
2436X_API
void YAP_PredicateInfo(
void *p, YAP_Atom *a, UInt *arity, Term *
m) {
2438 if (pd->ArityOfPE) {
2439 *arity = pd->ArityOfPE;
2440 *a = NameOfFunctor(pd->FunctorOfPred);
2443 *a = (
Atom)(pd->FunctorOfPred);
2445 if (pd->ModuleOfPred)
2446 *
m = pd->ModuleOfPred;
2451X_API
void YAP_UserCPredicate(
const char *name, YAP_UserCPred def,
2453 Yap_InitCPred(name, arity, (CPredicate)def, UserCPredFlag);
2456X_API
void YAP_UserBackCPredicate_(
const char *name, YAP_UserCPred init,
2457 YAP_UserCPred
cont, YAP_Arity arity,
2459 Yap_InitCPredBackCut(name, arity, extra, (CPredicate)init, (CPredicate)
cont,
2460 NULL, UserCPredFlag);
2463X_API
void YAP_UserBackCutCPredicate(
const char *name, YAP_UserCPred init,
2464 YAP_UserCPred
cont, YAP_UserCPred cut,
2465 YAP_Arity arity, YAP_Arity extra) {
2466 Yap_InitCPredBackCut(name, arity, extra, (CPredicate)init, (CPredicate)
cont,
2467 (CPredicate)cut, UserCPredFlag);
2470X_API
void YAP_UserBackCPredicate(
const char *name, YAP_UserCPred init,
2471 YAP_UserCPred
cont, arity_t arity,
2473 Yap_InitCPredBackCut(name, arity, extra, (CPredicate)init, (CPredicate)
cont,
2474 NULL, UserCPredFlag);
2477X_API
void YAP_UserCPredicateWithArgs(
const char *a, YAP_UserCPred f,
2478 arity_t arity, Term mod) {
2480 Term cm = CurrentModule;
2481 CurrentModule = mod;
2482 Yap_InitCPred(a, arity, (CPredicate)f, UserCPredFlag | CArgsPredFlag);
2486X_API Term YAP_CurrentModule(
void) {
2488 return (CurrentModule);
2491X_API Term YAP_SetCurrentModule(Term
new) {
2493 Term omod = CurrentModule;
2494 LOCAL_SourceModule = CurrentModule =
new;
2498X_API Term YAP_CreateModule(YAP_Atom at) {
2500 WRITE_LOCK(RepAtom(at)->ARWLock);
2501 t = Yap_Module(MkAtomTerm(at));
2502 WRITE_UNLOCK(RepAtom(at)->ARWLock);
2506X_API Term YAP_StripModule(Term t, Term *modp) {
2507 return Yap_StripModule(t, modp);
2510X_API
int YAP_ThreadSelf(
void) {
2512 return Yap_thread_self();
2520 return Yap_thread_create_engine(attr);
2526X_API
int YAP_ThreadAttachEngine(
int wid) {
2528 return Yap_thread_attach_engine(wid);
2534X_API
int YAP_ThreadDetachEngine(
int wid) {
2536 return Yap_thread_detach_engine(wid);
2542X_API
int YAP_ThreadDestroyEngine(
int wid) {
2544 return Yap_thread_destroy_engine(wid);
2550X_API Term YAP_TermNil(
void) {
return TermNil; }
2552X_API
int YAP_IsTermNil(Term t) {
return t == TermNil; }
2554X_API
int YAP_AtomGetHold(YAP_Atom at) {
return Yap_AtomIncreaseHold(at); }
2556X_API
int YAP_AtomReleaseHold(YAP_Atom at) {
return Yap_AtomDecreaseHold(at); }
2558X_API YAP_agc_hook YAP_AGCRegisterHook(YAP_agc_hook hook) {
2559 YAP_agc_hook old = (YAP_agc_hook)GLOBAL_AGCHook;
2560 GLOBAL_AGCHook = (Agc_hook)hook;
2564X_API
int YAP_HaltRegisterHook(HaltHookFunc hook,
void *closure) {
2565 return Yap_HaltRegisterHook(hook, closure);
2568X_API
char *YAP_cwd(
void) {
2570 char *buf = Yap_AllocCodeSpace(FILENAME_MAX + 1);
2572 if (!Yap_getcwd(buf, FILENAME_MAX))
2575 buf = Yap_ReallocCodeSpace(buf, len + 1);
2579X_API Term YAP_FloatsToList(
double *dblp,
size_t sz) {
2587 while (ASP - 1024 < HR + sz * (2 + 2 + SIZEOF_DOUBLE / SIZEOF_INT_P)) {
2588 if ((CELL *)dblp > H0 && (CELL *)dblp < HR) {
2590 LOCAL_OpenArray = (CELL *)dblp;
2592 if (!Yap_dogc( PASS_REGS1)) {
2596 dblp = (
double *)LOCAL_OpenArray;
2597 LOCAL_OpenArray = NULL;
2603 oldH[0] = MkFloatTerm(*dblp++);
2604 oldH[1] = AbsPair(HR);
2612X_API Int YAP_ListToFloats(Term t,
double *dblp,
size_t sz) {
2625 if (IsFloatTerm(hd)) {
2626 dblp[i++] = FloatOfTerm(hd);
2628 extern double Yap_gmp_to_float(Term hd);
2631 dblp[i++] = IntOfTerm(hd);
2632 else if (IsLongIntTerm(hd))
2633 dblp[i++] = LongIntOfTerm(hd);
2634 else if (IsBigIntTerm(hd))
2635 dblp[i++] = Yap_gmp_to_float(hd);
2645X_API Term YAP_IntsToList(Int *dblp,
size_t sz) {
2653 while (ASP - 1024 < HR + sz * 3) {
2654 if ((CELL *)dblp > H0 && (CELL *)dblp < HR) {
2656 LOCAL_OpenArray = (CELL *)dblp;
2658 if (!Yap_dogc(PASS_REGS1)) {
2662 dblp = (Int *)LOCAL_OpenArray;
2663 LOCAL_OpenArray = NULL;
2669 oldH[0] = MkIntegerTerm(*dblp++);
2670 oldH[1] = AbsPair(HR);
2678X_API Int YAP_ListToInts(Term t, Int *dblp,
size_t sz) {
2693 dblp[i++] = IntOfTerm(hd);
2700X_API Term YAP_OpenList(
int n) {
2705 while (HR + 2 * n > ASP - 1024) {
2706 if (!Yap_dogc( PASS_REGS1)) {
2718X_API Term YAP_ExtendList(Term t0, Term inp) {
2720 CELL *ptr = RepPair(t0);
2724 ptr[1] = AbsPair(ptr + 2);
2725 t = AbsPair(ptr + 2);
2731X_API
int YAP_CloseList(Term t0, Term tail) {
2732 CELL *ptr = RepPair(t0);
2734 RESET_VARIABLE(ptr - 1);
2735 if (!Yap_unify((Term)(ptr - 1), tail))
2740X_API
int YAP_IsAttVar(Term t) {
2745 return IsAttVar(VarOfTerm(t));
2748X_API Term YAP_AttsOfVar(Term t) {
2755 if (!IsAttVar(VarOfTerm(t)))
2757 attv = RepAttVar(VarOfTerm(t));
2761X_API
int YAP_FileNoFromStream(Term t) {
2766 return Yap_StreamToFileNo(t);
2769X_API
void *YAP_FileDescriptorFromStream(Term t) {
2774 return Yap_FileDescriptorFromStream(t);
2777X_API
void *YAP_Record(Term t) {
2781 dbterm = Yap_StoreTermInDB(Deref(t), 0);
2785 while (dbt == NULL) {
2786 if (!Yap_growheap(FALSE,
sizeof(
struct record_list), NULL)) {
2788 Yap_FreeCodeSpace((
void *)dbterm);
2789 Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"using YAP_Record");
2794 Yap_Records->prev_rec = dbt;
2796 dbt->next_rec = Yap_Records;
2797 dbt->prev_rec = NULL;
2798 dbt->dbrecord = dbterm;
2803X_API Term YAP_Recorded(
void *handle) {
2808 BACKUP_MACHINE_REGS();
2810 LOCAL_Error_TYPE = YAP_NO_ERROR;
2811 t = Yap_FetchTermFromDB(dbterm);
2812 if (LOCAL_Error_TYPE == YAP_NO_ERROR) {
2813 RECOVER_MACHINE_REGS();
2815 }
else if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
2816 LOCAL_Error_TYPE = YAP_NO_ERROR;
2817 if (!Yap_growglobal(NULL)) {
2818 Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil,
2819 LOCAL_ErrorMessage);
2820 RECOVER_MACHINE_REGS();
2824 LOCAL_Error_TYPE = YAP_NO_ERROR;
2825 if (!Yap_growstack(dbterm->NOfCells * CellSize)) {
2826 Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
2827 RECOVER_MACHINE_REGS();
2831 }
while (t == (CELL)0);
2832 RECOVER_MACHINE_REGS();
2836X_API
int YAP_Erase(
void *handle) {
2839 dbr->next_rec->prev_rec = dbr->prev_rec;
2841 dbr->prev_rec->next_rec = dbr->next_rec;
2842 else if (Yap_Records == dbr) {
2843 Yap_Records = dbr->next_rec;
2845 Yap_ReleaseTermFromDB(dbr->dbrecord);
2846 Yap_FreeCodeSpace(handle);
2852 return Yap_NewSlots(n);
2857 CELL *ptr0 = Yap_AddressFromSlot(slot), *ptr1 = &ARG1;
2863X_API
void YAP_signal(
int sig) { Yap_signal(sig); }
2865X_API
int YAP_SetYAPFlag(Term flag, Term val) {
return Yap_set_flag(flag, val); }
2868X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) {
2870 Term *t = (CELL *)Deref(Yap_GetFromSlot(s));
2877X_API Term YAP_ModuleUser(
void) {
return MkAtomTerm(AtomUser); }
2880X_API YAP_handle_t YAP_NumberOfClausesForPredicate(YAP_PredEntryPtr ape) {
2882 return pe->cs.p_code.NOfClauses;
2885X_API
int YAP_MaxOpPriority(YAP_Atom at, Term module) {
2888 WRITE_LOCK(ae->ARWLock);
2889 info = Yap_GetOpPropForAModuleHavingALock(ae, module);
2891 WRITE_UNLOCK(ae->ARWLock);
2894 int ret = info->Prefix;
2895 if (info->Infix > ret)
2897 if (info->Posfix > ret)
2899 WRITE_UNLOCK(ae->ARWLock);
2903X_API
int YAP_OpInfo(YAP_Atom at, Term module,
int opkind,
int *yap_type,
2909 WRITE_LOCK(ae->ARWLock);
2910 info = Yap_GetOpPropForAModuleHavingALock(ae, module);
2913 info = Yap_GetOpPropForAModuleHavingALock(ae, PROLOG_MODULE);
2915 WRITE_UNLOCK(ae->ARWLock);
2919 if (opkind == PREFIX_OP) {
2920 SMALLUNSGN p = info->Prefix;
2922 WRITE_UNLOCK(ae->ARWLock);
2925 if (p & DcrrpFlag) {
2927 *prio = (p ^ DcrrpFlag);
2932 }
else if (opkind == INFIX_OP) {
2933 SMALLUNSGN p = info->Infix;
2935 WRITE_UNLOCK(ae->ARWLock);
2938 if ((p & DcrrpFlag) && (p & DcrlpFlag)) {
2940 *prio = (p ^ (DcrrpFlag | DcrlpFlag));
2941 }
else if (p & DcrrpFlag) {
2943 *prio = (p ^ DcrrpFlag);
2944 }
else if (p & DcrlpFlag) {
2946 *prio = (p ^ DcrlpFlag);
2952 SMALLUNSGN p = info->Posfix;
2953 if (p & DcrlpFlag) {
2955 *prio = (p ^ DcrlpFlag);
2962 WRITE_UNLOCK(ae->ARWLock);
2966X_API
int YAP_Argv(
char ***argvp) {
2968 *argvp = GLOBAL_argv;
2973X_API YAP_tag_t YAP_TagOfTerm(Term t) {
2975 CELL *pt = VarOfTerm(t);
2976 if (IsUnboundVar(pt)) {
2980 return YAP_TAG_UNBOUND;
2985 return YAP_TAG_PAIR;
2986 if (IsAtomOrIntTerm(t)) {
2988 return YAP_TAG_ATOM;
2993 if (IsExtensionFunctor(f)) {
2994 if (f == FunctorDBRef) {
2995 return YAP_TAG_DBREF;
2997 if (f == FunctorLongInt) {
2998 return YAP_TAG_LONG_INT;
3000 if (f == FunctorBigInt) {
3001 big_blob_type bt = RepAppl(t)[1];
3004 return YAP_TAG_BIG_INT;
3006 return YAP_TAG_RATIONAL;
3008 return YAP_TAG_OPAQUE;
3010 return YAP_TAG_OPAQUE;
3013 return YAP_TAG_APPL;
3017X_API
void *YAP_PointerOfTerm(Term t) {
3019 Yap_ThrowError(INSTANTIATION_ERROR, t, NULL);
3021 }
else if (!IsIntegerTerm(t)) {
3022 Yap_ThrowError(TYPE_ERROR_INTEGER, t, NULL);
3025 return (
void *)IntegerOfTerm(t);
3029int YAP_BPROLOG_exception;
3030Term YAP_BPROLOG_curr_toam_status;
3042 utf8proc_uint8_t dst[8];
3045 if (IsPairTerm(t)) {
3046 while (t != TermNil) {
3049 Term hd = HeadOfTerm(t);
3050 if (IsAtomTerm(hd)) {
3051 Atom at = AtomOfTerm(hd);
3052 unsigned char *s = RepAtom(at)->UStrOfAE;
3054 get_utf8(s, 1, &ch);
3056 }
else if (IsIntegerTerm(hd)) {
3057 c = IntegerOfTerm(hd);
3062 sz += utf8proc_encode_char(c, dst);
3065 }
else if (IsAtomTerm(t)) {
3066 Atom at = AtomOfTerm(t);
3067 char *s = RepAtom(at)->StrOfAE;
3069 }
else if (IsStringTerm(t)) {
3070 sz = strlen(StringOfTerm(t));
3075X_API Int YAP_ListLength(Term t) {
3078 Int n = Yap_SkipList(&t, &aux);
3079 if (IsVarTerm(*aux))
3081 if (*aux == TermNil)
3086X_API Int YAP_NumberVars(Term t, Int nbv) {
3090X_API Term YAP_UnNumberVars(Term t) {
3092 return Yap_UnNumberTerm(t, NULL);
3095X_API
int YAP_IsNumberedVariable(Term t) {
3096 return IsApplTerm(t) && FunctorOfTerm(t) == FunctorDollarVar &&
3097 IsIntegerTerm(ArgOfTerm(1, t));
3100 X_API
size_t YAP_ExportTerm(Term inp,
char *buf,
size_t len) {
3103 return Yap_ExportTerm(inp, buf, len, current_arity());
3106X_API Term YAP_ImportTerm(
char *buf) {
3107 return Yap_ImportTerm(buf);
3110X_API
size_t YAP_SizeOfExportedTerm(
char *buf) {
3113 return Yap_SizeOfExportedTerm(buf);
3116X_API Term YAP_ImportTfunnumberm(
char *buf) {
return Yap_ImportTerm(buf); }
3118X_API
int YAP_RequiresExtraStack(
size_t sz) {
3123 if (HR <= ASP - sz) {
3127 while (HR > ASP - sz) {
3130 if (!Yap_dogc( PASS_REGS1)) {
3131 Yap_ThrowError(RESOURCE_ERROR_STACK, TermNil,
"needed %ld cells", sz);
3141functor_t *TR_Functors;
3142size_t AtomTranslations, MaxAtomTranslations;
3143size_t FunctorTranslations, MaxFunctorTranslations;
3145X_API Int YAP_AtomToInt(YAP_Atom At) {
3148 return te->Translation;
3149 TR_Atoms[AtomTranslations] = At;
3150 Yap_PutAtomTranslation(At, 0, AtomTranslations);
3152 if (AtomTranslations == MaxAtomTranslations) {
3153 atom_t *ot = TR_Atoms;
3154 atom_t *nt = (atom_t *)malloc(
sizeof(atom_t) * 2 * MaxAtomTranslations);
3156 Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At),
3157 "No more room for translations");
3160 memmove(nt, ot,
sizeof(atom_t) * MaxAtomTranslations);
3163 MaxAtomTranslations *= 2;
3165 return AtomTranslations - 1;
3168X_API YAP_Atom YAP_IntToAtom(Int i) {
return TR_Atoms[i]; }
3170X_API Int YAP_FunctorToInt(YAP_Functor f) {
3171 YAP_Atom At = NameOfFunctor(f);
3172 arity_t arity = ArityOfFunctor(f);
3175 return te->Translation;
3176 TR_Functors[FunctorTranslations] = f;
3177 Yap_PutAtomTranslation(At, arity, FunctorTranslations);
3178 FunctorTranslations++;
3179 if (FunctorTranslations == MaxFunctorTranslations) {
3180 functor_t *nt = (functor_t *)malloc(
sizeof(functor_t) * 2 *
3181 MaxFunctorTranslations),
3184 Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At),
3185 "No more room for translations");
3188 memmove(nt, ot,
sizeof(functor_t) * MaxFunctorTranslations);
3191 MaxFunctorTranslations *= 2;
3193 return FunctorTranslations - 1;
3196X_API
void *YAP_foreign_stream(
int sno) {
3197 return GLOBAL_Stream[sno].u.private_data;
3200X_API YAP_Functor YAP_IntToFunctor(Int i) {
return TR_Functors[i]; }
3202X_API YAP_PredEntryPtr YAP_TopGoal(
void) {
3203 Functor f = Yap_MkFunctor(Yap_LookupAtom(
"yap_query"), 3);
3204 Term tmod = MkAtomTerm(Yap_LookupAtom(
"yapi"));
3205 PredEntry *p = RepPredProp(Yap_GetPredPropByFunc(f, tmod));
3209void yap_init(
void) {}
const char * Yap_AbsoluteFile(const char *spec, bool ok)
generate absolute path, if ok first expand SICStus Prolog style
X_API YAP_Term YAP_ReadClauseFromStream(int s, YAP_Term varNames, YAP_Term)
read a Prolog clause from a Prolog opened stream $s$
bool Yap_ResetException(yap_error_descriptor_t *i)
clean up (notice that the code ensures ActiveError exists on exit
bool Yap_RaiseException()
let's go
void * Malloc(size_t sz USES_REGS)
allocate a temporary text block
void Yap_ThrowError__(const char *file, const char *function, int lineno, yap_error_number type, Term where, const char *msg,...)
Throw an error directly to the error handler.
int Yap_NumberVars(Term t, int numbv, bool handle_singles USES_REGS)
numbervariables in term t
X_API void * YAP_GetStreamFromId(int no)
given a stream descriptor or stream alias (see open/3 ), return YAP's internal handle
X_API Term YAP_ReadFromStream(int sno)
read a Prolog term from a Prolog opened stream $s$
X_API Term YAP_Read(FILE *f)
read a Prolog term from an operating system stream $s$
X_API YAP_handle_t YAP_ArgsToSlots(int HowMany)
copies the first new n YAAM registers to slots
X_API YAP_Term * YAP_AddressFromSlot(YAP_handle_t)
get the memory address of a slot
X_API size_t YAP_UTF8_TextLength(Term t)
Output the number of bytes needed to represent a string in UTF-8 Note that the terminating zero is no...
X_API void YAP_StartSlots(void)
initialize the slot data-structure: all existing slots will be discarded
X_API void YAP_PutInSlot(YAP_handle_t slot, YAP_Term t)
store term in a slot
X_API void YAP_EndSlots(void)
discard all existing slots: operates as
X_API YAP_Term * YAP_AddressOfTermInSlot(YAP_handle_t)
get the memory address of the term actually stored in a slot
X_API yhandle_t YAP_CurrentSlot(void)
report the current position of the slots, assuming that they occupy the top of the stack
X_API char * YAP_WriteDynamicBuffer(YAP_Term t, encoding_t enc, int flags)
write a a term to n user-provided buffer: make sure not tp overflow the buffer even if the text is mu...
X_API YAP_Term YAP_GetFromSlot(YAP_handle_t slot)
read from a slot
X_API void * YAP_RepStreamFromId(int sno)
Obtain a pointer to the YAP representation of a stream.
X_API int YAP_RecoverSlots(int, YAP_handle_t topSlot)
Succeeds if it recovers the space allocated for $n$ contiguous slots starting at topSlot.
X_API void YAP_SlotsToArgs(int HowMany, YAP_handle_t slot)
copies n slots such that sl is copied to the last abstract ,achine register
X_API char * YAP_StringToBuffer(Term t, char *buf, unsigned int bufsize)
copy a string to a buffer, the buffer must have been malloced
X_API yhandle_t YAP_InitSlot(YAP_Term t)
allocate n empty new slots
Term Yap_read_term(int sno, Term opts, bool clause)
generic routine to read terms from a stream
opaque variables can interact with the system
Attributed variales are controlled by the attvar_record.