23#include "inline-only.h"
31 return (
Atom)(Addr(p) - AtomBase);
37 return (
AtomEntry *) (AtomBase + Unsigned (a);
54#if USE_OFFSETS_IN_PROPS
59 return (
Prop)(Addr(p) - AtomBase);
65 return (
PropEntry *)(AtomBase + Unsigned(p));
82#if USE_OFFSETS_IN_PROPS
93 return (
Prop)(Addr(p) - AtomBase);
112INLINE_ONLY arity_t ArityOfFunctor(
Functor);
114INLINE_ONLY arity_t ArityOfFunctor(
Functor Fun) {
124INLINE_ONLY PropFlags IsFunctorProperty(
int);
126INLINE_ONLY PropFlags IsFunctorProperty(
int flags) {
127 return (PropFlags)((flags == FunctorProperty));
154#if defined(YAPOR) || defined(THREADS)
157 unsigned int owner_id;
166#if USE_OFFSETS_IN_PROPS
177 return (
Prop)(Addr(p) - AtomBase);
196#define GlobalProperty ((PropFlags)0xfffd)
198INLINE_ONLY PropFlags IsGlobalProperty(
int);
200INLINE_ONLY PropFlags IsGlobalProperty(
int flags) {
201 return (PropFlags)((flags == GlobalProperty));
216#if defined(YAPOR) || defined(THREADS)
223#if USE_OFFSETS_IN_PROPS
228 return (
ModEntry *)(AtomBase + Unsigned(p));
234 return (
Prop)(Addr(p) - AtomBase);
249#define ModToTerm(m) (m == PROLOG_MODULE ? TermProlog : m)
253#define ModProperty ((PropFlags)0xfffa)
255INLINE_ONLY
bool IsModProperty(
int);
257INLINE_ONLY
bool IsModProperty(
int flags) {
258 return flags == ModProperty;
264#define M_SYSTEM (0x0001)
265#define M_CHARESCAPE (0x0002)
266#define DBLQ_CHARS (0x0004)
267#define DBLQ_ATOM (0x0008)
268#define DBLQ_STRING (0x0010)
269#define DBLQ_CODES (0x0020)
270#define DBLQ_MASK (DBLQ_CHARS | DBLQ_ATOM | DBLQ_STRING | DBLQ_CODES)
271#define BCKQ_CHARS (0x0040)
272#define BCKQ_ATOM (0x0080)
273#define BCKQ_STRING (0x0100)
274#define BCKQ_CODES (0x0200)
275#define BCKQ_MASK (BCKQ_CHARS | BCKQ_ATOM | BCKQ_STRING | BCKQ_CODES)
276#define UNKNOWN_FAIL (0x0400)
277#define UNKNOWN_WARNING (0x0800)
278#define UNKNOWN_ERROR (0x1000)
279#define UNKNOWN_FAST_FAIL (0x2000)
280#define UNKNOWN_ABORT (0x4000)
281#define UNKNOWN_HALT (0x8000)
282#define UNKNOWN_MASK \
283 (UNKNOWN_ERROR | UNKNOWN_WARNING | UNKNOWN_FAIL | UNKNOWN_FAST_FAIL | \
284 UNKNOWN_ABORT | UNKNOWN_HALT)
285#define SNGQ_CHARS (0x10000)
286#define SNGQ_ATOM (0x20000)
287#define SNGQ_STRING (0x40000)
288#define SNGQ_CODES (0x80000)
289#define SNGQ_MASK (BCKQ_CHARS | BCKQ_ATOM | BCKQ_STRING | BCKQ_CODES)
298#if defined(YAPOR) || defined(THREADS)
305 BITS16 Prefix, Infix, Posfix;
307#if USE_OFFSETS_IN_PROPS
312 return (
OpEntry *)(AtomBase + Unsigned(p));
318 return (
Prop)(Addr(p) - AtomBase);
332#define OpProperty ((PropFlags)0xffff)
334INLINE_ONLY
bool IsOpProperty(PropFlags);
336INLINE_ONLY
bool IsOpProperty(PropFlags flags) {
337 return flags == OpProperty;
340typedef enum { INFIX_OP = 0, POSFIX_OP = 1, PREFIX_OP = 2 } op_type;
342OpEntry *Yap_GetOpProp(
Atom, op_type, Term CACHE_TYPE);
344int Yap_IsPrefixOp(
Atom,
int *,
int *);
346int Yap_IsInfixOp(
Atom,
int *,
int *,
int *);
347int Yap_IsPosfixOp(
Atom,
int *,
int *);
351#define MaskPrio 0x0fff
352#define DcrlpFlag 0x1000
353#define DcrrpFlag 0x2000
355typedef union arith_ret *eval_ret;
361 unsigned int ArityOfEE;
367#if USE_OFFSETS_IN_PROPS
372 return (
ExpEntry *)(AtomBase + Unsigned(p));
378 return (
Prop)(Addr(p) - AtomBase);
394#define ExpProperty 0xffe0
398INLINE_ONLY PropFlags IsExpProperty(
int);
400INLINE_ONLY PropFlags IsExpProperty(
int flags) {
401 return (PropFlags)((flags == ExpProperty));
408#if defined(YAPOR) || defined(THREADS)
413#if USE_OFFSETS_IN_PROPS
418 return (
ValEntry *)(AtomBase + Unsigned(p));
424 return (
Prop)(Addr(p) - AtomBase);
440#define ValProperty ((PropFlags)0xfffc)
453typedef uint64_t pred_flags_t;
454#define ProxyPredFlag \
455 ((pred_flags_t)0x4000000000)
456#define UndefPredFlag \
457 ((pred_flags_t)0x4000000000)
458#define ProfiledPredFlag ((pred_flags_t)0x2000000000)
459#define DiscontiguousPredFlag \
460 ((pred_flags_t)0x1000000000)
462#define SysExportPredFlag \
463 ((pred_flags_t)0x800000000)
464#define NoTracePredFlag \
465 ((pred_flags_t)0x400000000)
466#define NoSpyPredFlag ((pred_flags_t)0x200000000)
467#define QuasiQuotationPredFlag \
468 ((pred_flags_t)0x100000000)
469#define MegaClausePredFlag \
470 ((pred_flags_t)0x80000000)
471#define ThreadLocalPredFlag ((pred_flags_t)0x40000000)
472#define MultiFileFlag ((pred_flags_t)0x20000000)
473#define UserCPredFlag ((pred_flags_t)0x10000000)
474#define LogUpdatePredFlag \
475 ((pred_flags_t)0x08000000)
476#define InUsePredFlag ((pred_flags_t)0x04000000)
477#define CountPredFlag ((pred_flags_t)0x02000000)
478#define HiddenPredFlag ((pred_flags_t)0x01000000)
479#define CArgsPredFlag ((pred_flags_t)0x00800000)
480#define SourcePredFlag \
481 ((pred_flags_t)0x00400000)
482#define MetaPredFlag \
483 ((pred_flags_t)0x00200000)
484#define SyncPredFlag \
485 ((pred_flags_t)0x00100000)
486#define NumberDBPredFlag ((pred_flags_t)0x00080000)
487#define AtomDBPredFlag ((pred_flags_t)0x00040000)
490#define TestPredFlag ((pred_flags_t)0x00010000)
491#define AsmPredFlag ((pred_flags_t)0x00008000)
492#define StandardPredFlag ((pred_flags_t)0x00004000)
493#define DynamicPredFlag ((pred_flags_t)0x00002000)
494#define CPredFlag ((pred_flags_t)0x00001000)
495#define SafePredFlag ((pred_flags_t)0x00000800)
496#define CompiledPredFlag ((pred_flags_t)0x00000400)
497#define IndexedPredFlag ((pred_flags_t)0x00000200)
498#define SpiedPredFlag ((pred_flags_t)0x00000100)
499#define BinaryPredFlag ((pred_flags_t)0x00000080)
500#define TabledPredFlag ((pred_flags_t)0x00000040)
501#define SequentialPredFlag \
502 ((pred_flags_t)0x00000020)
503#define BackCPredFlag ((pred_flags_t)0x00000008)
504#define ModuleTransparentPredFlag ((pred_flags_t)0x00000004)
505#define SWIEnvPredFlag ((pred_flags_t)0x00000002)
506#define UDIPredFlag ((pred_flags_t)0x00000001)
508#define SystemPredFlags \
509 (AsmPredFlag | StandardPredFlag | CPredFlag | BinaryPredFlag | BackCPredFlag)
510#define ForeignPredFlags \
511 (AsmPredFlag | SWIEnvPredFlag | CPredFlag | BinaryPredFlag | UDIPredFlag | \
512 CArgsPredFlag | UserCPredFlag | SafePredFlag | BackCPredFlag)
513#define LivePredFlags \
514 (LogUpdatePredFlag | MultiFileFlag | TabledPredFlag | ForeignPredFlags)
516#define StatePredFlags \
517 (InUsePredFlag | CountPredFlag | SpiedPredFlag | IndexedPredFlag)
518#define is_system(pe) (pe->PredFlags & SystemPredFlags)
519#define is_dynamic(pe) (pe->PredFlags & DynamicPredFlag)
520#define is_foreign(pe) (pe->PredFlags & ForeignPredFlags)
521#define is_static(pe) (pe->PredFlags & CompiledPredFlag)
522#define is_logupd(pe) (pe->PredFlags & LogUpdatePredFlag)
523#define is_live(pe) (pe->PredFlags & LivePredFlags)
525#define is_tabled(pe) (pe->PredFlags & TabledPredFlag)
531 UInt NOfHeadSuccesses;
534#if defined(YAPOR) || defined(THREADS)
539typedef enum { LUCALL_EXEC, LUCALL_ASSERT, LUCALL_RETRACT } timestamp_type;
541#define TIMESTAMP_EOT ((UInt)(~0L))
542#define TIMESTAMP_RESET (TIMESTAMP_EOT - 1024)
547 struct yami *CodeOfPred;
549 pred_flags_t PredFlags;
553 struct yami *TrueCodeOfPred;
554 struct yami *FirstClause;
555 struct yami *LastClause;
567#if defined(YAPOR) || defined(THREADS)
574 struct Predicates *beamTable;
576 struct yami *MetaEntryOfPred;
578 UInt TimeStampOfPred;
579 timestamp_type LastCallOfPred;
586#define PEProp ((PropFlags)(0x0000))
588#if USE_OFFSETS_IN_PROPS
593 return (
PredEntry *)(AtomBase + Unsigned(p));
599 return (
Prop)(Addr(p) - AtomBase);
617INLINE_ONLY PropFlags IsPredProperty(
int);
619INLINE_ONLY PropFlags IsPredProperty(
int flags) {
620 return (PropFlags)((flags == PEProp));
624extern Term IDB_MODULE;
627 if (pe->ModuleOfPred == IDB_MODULE) {
629 }
else if (pe->ArityOfPE == 0) {
630 return (
Atom)pe->FunctorOfPred;
633 return NameOfFunctor(f);
637extern const char *IndicatorOfPred(
PredEntry *pe);
639extern PredEntry *Yap_get_pred(Term t, Term tmod,
const char *pname);
641 extern PredEntry *Yap_new_pred(Term t, Term tmod,
bool lu,
const char *pname);
649 FuncSwitchMask = 0x800000,
650 HasDBTMask = 0x400000,
653 SwitchRootMask = 0x80000,
654 SwitchTableMask = 0x40000,
655 HasBlobsMask = 0x20000,
656 ProfFoundMask = 0x10000,
657 DynamicMask = 0x8000,
662 LogUpdRuleMask = 0x0400,
672void Yap_InitCPred(
const char *name, arity_t arity, CPredicate f,
674void Yap_InitAsmPred(
const char *name, arity_t arity,
int code, CPredicate asmc,
676void Yap_InitCmpPred(
const char *name, arity_t arity, CmpPredicate cmp,
678void Yap_InitCPredBack(
const char *name, arity_t arity, arity_t extra,
679 CPredicate call, CPredicate retry, pred_flags_t flags);
680void Yap_InitCPredBackCut(
const char *name, arity_t arity, arity_t extra,
681 CPredicate call, CPredicate retry, CPredicate cut,
683void Yap_InitCPredBack_(
const char *name, arity_t arity, arity_t extra,
684 CPredicate call, CPredicate retry, CPredicate cut,
700 Term Contents[MIN_ARRAY];
703INLINE_ONLY
DBTerm *TermToDBTerm(Term);
705INLINE_ONLY
DBTerm *TermToDBTerm(Term X) {
707 return (
DBTerm *)((
unsigned char *)RepPair(X) - (CELL) &
708 (((
DBTerm *)NULL)->Contents));
710 return (
DBTerm *)((
unsigned char *)RepAppl(X) - (CELL) &
711 (((
DBTerm *)NULL)->Contents));
720#if defined(YAPOR) || defined(THREADS)
739#define DBStructFlagsToDBStruct(X) \
740 ((DBRef)((unsigned char *)(X) - (CELL) & (((DBRef)NULL)->Flags)))
743#define INIT_DBREF_COUNT(X) (X)->ref_count = 0
744#define INC_DBREF_COUNT(X) (X)->ref_count++
745#define DEC_DBREF_COUNT(X) (X)->ref_count--
746#define DBREF_IN_USE(X) ((X)->ref_count != 0)
748#define INIT_DBREF_COUNT(X)
749#define INC_DBREF_COUNT(X)
750#define DEC_DBREF_COUNT(X)
751#define DBREF_IN_USE(X) ((X)->Flags & InUseMask)
758INLINE_ONLY
int IsDBRefTerm(Term);
760INLINE_ONLY
int IsDBRefTerm(Term t) {
761 return (
int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorDBRef);
764INLINE_ONLY Term MkDBRefTerm(
DBRef);
766INLINE_ONLY Term MkDBRefTerm(
DBRef p) {
767 return (Term)((AbsAppl(((CELL *)(p)))));
770INLINE_ONLY
DBRef DBRefOfTerm(Term t);
772INLINE_ONLY
DBRef DBRefOfTerm(Term t) {
776INLINE_ONLY
int IsRefTerm(Term);
778INLINE_ONLY
int IsRefTerm(Term t) {
779 return (
int)(IsApplTerm(t) && FunctorOfTerm(t) == FunctorDBRef);
782INLINE_ONLY CODEADDR RefOfTerm(Term t);
784INLINE_ONLY CODEADDR RefOfTerm(Term t) {
785 return (CODEADDR)(DBRefOfTerm(t));
791 unsigned int ArityOfDB;
793#if defined(YAPOR) || defined(THREADS)
802#define DBProperty ((PropFlags)0x8000)
807 unsigned int ArityOfDB;
809#if defined(YAPOR) || defined(THREADS)
821#define CodeDBProperty (DBProperty | CodeDBBit)
823INLINE_ONLY PropFlags IsDBProperty(
int);
825INLINE_ONLY PropFlags IsDBProperty(
int flags) {
826 return (PropFlags)((flags & ~CodeDBBit) == DBProperty);
829#if USE_OFFSETS_IN_PROPS
834 return (
DBProp)(AtomBase + Unsigned(p));
840 return (
Prop)(Addr(p) - AtomBase);
871#if defined(YAPOR) || defined(THREADS)
878#if USE_OFFSETS_IN_PROPS
889 return (
Prop)(Addr(p) - AtomBase);
908#define BBProperty ((PropFlags)0xfffb)
910INLINE_ONLY PropFlags IsBBProperty(
int);
912INLINE_ONLY PropFlags IsBBProperty(
int flags) {
913 return (PropFlags)((flags == BBProperty));
923#if USE_OFFSETS_IN_PROPS
928 return (
HoldEntry *)(AtomBase + Unsigned(p));
934 return (
Prop)(Addr(p) - AtomBase);
951#define HoldProperty 0xfff6
961#if USE_OFFSETS_IN_PROPS
972 return (
Prop)(Addr(p) - AtomBase);
990#define TranslationProperty 0xfff4
992bool Yap_PutAtomTranslation(
Atom a, arity_t arity, Int i);
1000 READ_LOCK(ae->ARWLock);
1001 p = RepTranslationProp(p0 = ae->PropsOfAE);
1002 while (p0 && (p->KindOfPE != TranslationProperty || p->arity != arity))
1003 p = RepTranslationProp(p0 = p->NextOfPE);
1004 READ_UNLOCK(ae->ARWLock);
1011INLINE_ONLY
bool IsTranslationProperty(PropFlags);
1013INLINE_ONLY
bool IsTranslationProperty(PropFlags flags) {
1014 return flags == TranslationProperty;
1026#if USE_OFFSETS_IN_PROPS
1031 return (
MutexEntry *)(AtomBase + Unsigned(p));
1037 return (
Prop)(Addr(p) - AtomBase);
1053#define MutexProperty 0xfff5
1055bool Yap_PutAtomMutex(
Atom a,
void *ptr);
1058static inline void *Yap_GetMutexFromProp(
Atom at) {
1063 READ_LOCK(ae->ARWLock);
1064 p = RepMutexProp(p0 = ae->PropsOfAE);
1065 while (p0 && p->KindOfPE != MutexProperty)
1066 p = RepMutexProp(p0 = p->NextOfPE);
1067 READ_UNLOCK(ae->ARWLock);
1073INLINE_ONLY
bool IsMutexProperty(PropFlags);
1075INLINE_ONLY
bool IsMutexProperty(PropFlags flags) {
1076 return (PropFlags)((flags == MutexProperty));
1084#if USE_OFFSETS_IN_PROPS
1089 return (
ArrayEntry *)(AtomBase + Unsigned(p));
1095 return (
Prop)(Addr(p) - AtomBase);
1107 return (
Prop)(Addr(p) - AtomBase);
1135#define ArrayProperty ((PropFlags)0xfff7)
1137INLINE_ONLY
bool ArrayIsDynamic(
ArrayEntry *);
1139INLINE_ONLY
bool ArrayIsDynamic(
ArrayEntry *are) {
1140 return ((are)->TypeOfAE & DYNAMIC_ARRAY) != 0;
1143INLINE_ONLY
bool IsArrayProperty(PropFlags);
1145INLINE_ONLY
bool IsArrayProperty(PropFlags flags) {
1146 return flags == ArrayProperty;
1156#if USE_OFFSETS_IN_PROPS
1164INLINE_ONLY
AtomEntry *AbsBlobProp(BlobPropEntry *p);
1167 return (
Prop)(Addr(p) - AtomBase);
1186#define BlobProperty ((PropFlags)0xfffe)
1188INLINE_ONLY
bool IsBlobProperty(PropFlags);
1190INLINE_ONLY
bool IsBlobProperty(PropFlags flags) {
1191 return flags == BlobProperty;
1194INLINE_ONLY
bool IsBlob(
Atom);
1196INLINE_ONLY
bool IsBlob(
Atom at) {
1197 return RepAtom(at)->PropsOfAE != NIL &&
1198 IsBlobProperty(RepBlobProp(RepAtom(at)->PropsOfAE)->KindOfPE);
1201INLINE_ONLY
bool IsValProperty(PropFlags);
1203INLINE_ONLY
bool IsValProperty(PropFlags flags) {
1204 return flags == ValProperty;
1209typedef Term (*flag_func)(Term);
1210typedef bool (*flag_helper_func)(Term);
1215#if defined(YAPOR) || defined(THREADS)
1219 bool global, atomic, rw;
1221 flag_helper_func helper;
1223#if USE_OFFSETS_IN_PROPS
1228 return (
FlagEntry *)(AtomBase + Unsigned(p));
1234 return (
Prop)(Addr(p) - AtomBase);
1250#define FlagProperty ((PropFlags)0xfff9)
1252INLINE_ONLY
bool IsFlagProperty(PropFlags);
1254INLINE_ONLY
bool IsFlagProperty(PropFlags flags) {
1255 return flags == FlagProperty;
1265void Yap_ErDBE(
DBRef);
1266DBTerm *Yap_StoreTermInDB(Term,
int);
1267DBTerm *Yap_StoreTermInDBPlusExtraSpace(Term, UInt, UInt *);
1268Term Yap_FetchTermFromDB(
void *);
1269Term Yap_FetchClauseTermFromDB(
void *);
1270Term Yap_PopTermFromDB(
void *);
1271void Yap_ReleaseTermFromDB(
void *);
1280#define PROLOG_MODULE 0
1284#define PredHashInitialSize ((UInt)1039)
1285#define PredHashIncrement ((UInt)7919)
1294INLINE_ONLY UInt PRED_HASH(
FunctorEntry *fe, Term cur_mod,
1296 return (((CELL)fe + cur_mod) >> 2) % size;
1302INLINE_ONLY
Prop PredPropByAtomAndMod(
Atom, Term);
1305INLINE_ONLY
Prop PredPropByFunc(
Functor fe, Term cur_mod);
1306INLINE_ONLY
Prop PredPropByAtom(
Atom at, Term cur_mod);
1313Yap_GetThreadPred(
struct pred_entry *CACHE_TYPE);
1316Yap_GetThreadPred(
struct pred_entry *ap USES_REGS) {
1317 Functor f = ap->FunctorOfPred;
1318 Term mod = ap->ModuleOfPred;
1319 Prop p0 = AbsPredProp(LOCAL_ThreadHandle.local_preds);
1323 if (ap->FunctorOfPred == f && ap->ModuleOfPred == mod)
1327 return RepPredProp(Yap_NewThreadPred(ap PASS_REGS));
1335 if (!(p = RepPredProp(fe->PropsOfFE))) {
1338 if ((p->ModuleOfPred == cur_mod || !(p->ModuleOfPred))) {
1341 if (p->PredFlags & ThreadLocalPredFlag) {
1342 return AbsPredProp(Yap_GetThreadPred(p INIT_REGS));
1345 return AbsPredProp(p);
1348 UInt hash = PRED_HASH(fe, cur_mod, PredHashTableSize);
1349 READ_LOCK(PredHashRWLock);
1353 if (p->FunctorOfPred == fe && p->ModuleOfPred == cur_mod) {
1356 if (p->PredFlags & ThreadLocalPredFlag) {
1357 READ_UNLOCK(PredHashRWLock);
1358 return AbsPredProp(Yap_GetThreadPred(p INIT_REGS));
1361 READ_UNLOCK(PredHashRWLock);
1362 return AbsPredProp(p);
1364 p = p->NextPredOfHash;
1366 READ_UNLOCK(PredHashRWLock);
1371INLINE_ONLY
Prop PredPropByFunc(
Functor fe, Term cur_mod)
1376 FUNC_WRITE_LOCK(fe);
1377 p0 = GetPredPropByFuncHavingLock(fe, cur_mod);
1379 FUNC_WRITE_UNLOCK(fe);
1382 return Yap_NewPredPropByFunctor(fe, cur_mod);
1386GetPredPropByFuncAndModHavingLock(
FunctorEntry *fe, Term cur_mod) {
1389 if (!(p = RepPredProp(fe->PropsOfFE))) {
1392 if (p->ModuleOfPred == cur_mod || p->ModuleOfPred == 0) {
1395 if (p->PredFlags & ThreadLocalPredFlag) {
1396 return AbsPredProp(Yap_GetThreadPred(p INIT_REGS));
1399 return AbsPredProp(p);
1402 UInt hash = PRED_HASH(fe, cur_mod, PredHashTableSize);
1403 READ_LOCK(PredHashRWLock);
1407 if (p->FunctorOfPred == fe && p->ModuleOfPred == cur_mod) {
1410 if (p->PredFlags & ThreadLocalPredFlag) {
1411 READ_UNLOCK(PredHashRWLock);
1412 return AbsPredProp(Yap_GetThreadPred(p INIT_REGS));
1415 READ_UNLOCK(PredHashRWLock);
1416 return AbsPredProp(p);
1418 p = p->NextPredOfHash;
1420 READ_UNLOCK(PredHashRWLock);
1425INLINE_ONLY
Prop PredPropByFuncAndMod(
Functor fe, Term cur_mod)
1430 FUNC_WRITE_LOCK(fe);
1431 p0 = GetPredPropByFuncAndModHavingLock(fe, cur_mod);
1433 FUNC_WRITE_UNLOCK(fe);
1436 return Yap_NewPredPropByFunctor(fe, cur_mod);
1439INLINE_ONLY
Prop PredPropByAtom(
Atom at, Term cur_mod)
1445 WRITE_LOCK(ae->ARWLock);
1449 if (pe->KindOfPE == PEProp &&
1450 (pe->ModuleOfPred == cur_mod || !pe->ModuleOfPred)) {
1453 if (pe->PredFlags & ThreadLocalPredFlag) {
1454 WRITE_UNLOCK(ae->ARWLock);
1455 return AbsPredProp(Yap_GetThreadPred(pe INIT_REGS));
1458 WRITE_UNLOCK(ae->ARWLock);
1463 return Yap_NewPredPropByAtom(ae, cur_mod);
1466INLINE_ONLY
Prop PredPropByAtomAndMod(
Atom at, Term cur_mod)
1472 WRITE_LOCK(ae->ARWLock);
1476 if (pe->KindOfPE == PEProp &&
1477 (pe->ModuleOfPred == cur_mod || pe->ModuleOfPred == 0)) {
1480 if (pe->PredFlags & ThreadLocalPredFlag) {
1481 WRITE_UNLOCK(ae->ARWLock);
1482 return AbsPredProp(Yap_GetThreadPred(pe INIT_REGS));
1485 WRITE_UNLOCK(ae->ARWLock);
1490 return Yap_NewPredPropByAtom(ae, cur_mod);
1494#define PELOCK(I, Z) \
1496 LOCK((Z)->PELock); \
1497 (Z)->StatisticsForPred->NOfEntries = (I); \
1498 (Z)->StatisticsForPred->NOfHeadSuccesses = pthread_self(); \
1500#define UNLOCKPE(I, Z) \
1501 ((Z)->StatisticsForPred->NOfRetries = (I), UNLOCK((Z)->PELock))
1502#elif YAPOR || THREADS
1503#define PELOCK(I, Z) (LOCK((Z)->PELock))
1504#define UNLOCKPE(I, Z) (UNLOCK((Z)->PELock))
1507#define UNLOCKPE(I, Z)
1515 p->NextOfPE = ae->PropsOfAE;
1516 ae->PropsOfAE = AbsProp(p);
1521INLINE_ONLY
const char *AtomName(
Atom at);
1531INLINE_ONLY
const char *AtomName(
Atom at) {
1532 return RepAtom(at)->rep.uStrOfAE;
1535INLINE_ONLY
const char *AtomTermName(Term t);
1548INLINE_ONLY
const char *AtomTermName(Term t) {
1549 return RepAtom(AtomOfTerm(t))->rep.uStrOfAE;
1554extern bool Yap_HasException(
void);
1557INLINE_ONLY
bool Yap_HasException(
void) {
1558 return LOCAL_ActiveError->errorNo != 0L;
bool Yap_ResetException(yap_error_descriptor_t *i)
clean up (notice that the code ensures ActiveError exists on exit
yap_error_descriptor_t * Yap_PeekException(void)
is an error active?
bool Yap_RaiseException()
let's go
bool Yap_RestartException(yap_error_descriptor_t *i)
clean up (notice that the code ensures ActiveError exists on exit
yap_error_descriptor_t * Yap_GetException(void)
clone Active Error
Module property: low-level data used to manage modes.
struct mod_entry * NextME
Module local flags (from SWI compat)
Atom AtomOfME
index in operator table
struct operator_entry * OpForME
index in module table
Atom OwnerFile
module's name
struct pred_entry * PredForME
kind of property
PropFlags KindOfPE
chain of atom properties
unsigned int flags
module's owner file
all we need to know about an error/throw