This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/C/cdmgr.c

4767 lines
136 KiB
C
Raw Normal View History

/*************************************************************************
2016-01-03 01:26:09 +00:00
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: cdmgr.c *
* comments: Code manager *
* *
* Last rev: $Date: 2008-07-22 23:34:44 $,$Author: vsc $ 8
*************************************************************************/
#ifdef SCCS
2015-10-22 00:53:26 +01:00
static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
#endif
#include "Yap.h"
#include "clause.h"
#include "YapEval.h"
#include "tracer.h"
2016-03-29 01:55:12 +01:00
#include "yapio.h"
#ifdef YAPOR
#include "or.macros.h"
2015-10-22 00:53:26 +01:00
#endif /* YAPOR */
#ifdef TABLING
#include "tab.macros.h"
#endif /* TABLING */
#if HAVE_STRING_H
#include <string.h>
#endif
2016-03-29 01:55:12 +01:00
#include <assert.h>
2015-08-07 22:57:53 +01:00
#include <heapgc.h>
2015-09-29 23:08:10 +01:00
#include <iopreds.h>
2013-04-25 23:15:04 +01:00
static void retract_all(PredEntry *, int);
static void add_first_static(PredEntry *, yamop *, int);
static void add_first_dynamic(PredEntry *, yamop *, int);
static void asserta_stat_clause(PredEntry *, yamop *, int);
static void asserta_dynam_clause(PredEntry *, yamop *);
static void assertz_stat_clause(PredEntry *, yamop *, int);
static void assertz_dynam_clause(PredEntry *, yamop *);
2015-10-22 00:53:26 +01:00
static void expand_consult(void);
static int not_was_reconsulted(PredEntry *, Term, int);
static int RemoveIndexation(PredEntry *);
static Int p_number_of_clauses(USES_REGS1);
static Int p_compile(USES_REGS1);
static Int p_purge_clauses(USES_REGS1);
static Int p_setspy(USES_REGS1);
static Int p_rmspy(USES_REGS1);
static Int p_startconsult(USES_REGS1);
static Int p_showconslultlev(USES_REGS1);
static Int p_endconsult(USES_REGS1);
static Int p_undefined(USES_REGS1);
static Int p_new_multifile(USES_REGS1);
static Int p_is_multifile(USES_REGS1);
static Int p_optimizer_on(USES_REGS1);
static Int p_optimizer_off(USES_REGS1);
static Int p_is_dynamic(USES_REGS1);
static Int p_kill_dynamic(USES_REGS1);
static Int p_is_profiled(USES_REGS1);
static Int p_profile_info(USES_REGS1);
static Int p_profile_reset(USES_REGS1);
static Int p_is_call_counted(USES_REGS1);
static Int p_call_count_info(USES_REGS1);
static Int p_call_count_set(USES_REGS1);
static Int p_call_count_reset(USES_REGS1);
static void kill_first_log_iblock(LogUpdIndex *, LogUpdIndex *, PredEntry *);
#define PredArity(p) (p->ArityOfPE)
2015-10-22 00:53:26 +01:00
#define TRYCODE(G, F, N) ((N) < 5 ? (op_numbers)((int)F + (N)*3) : G)
2015-10-22 00:53:26 +01:00
static void InitConsultStack(void) {
CACHE_REGS
2015-10-22 00:53:26 +01:00
LOCAL_ConsultLow = (consult_obj *)Yap_AllocCodeSpace(sizeof(consult_obj) *
InitialConsultCapacity);
2011-05-04 10:11:41 +01:00
if (LOCAL_ConsultLow == NULL) {
2015-10-22 00:53:26 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "No Heap Space in InitCodes");
return;
}
2011-05-04 10:11:41 +01:00
LOCAL_ConsultCapacity = InitialConsultCapacity;
LOCAL_ConsultBase = LOCAL_ConsultSp =
2015-10-22 00:53:26 +01:00
LOCAL_ConsultLow + LOCAL_ConsultCapacity;
}
2015-10-22 00:53:26 +01:00
void Yap_ResetConsultStack(void) {
CACHE_REGS
2011-05-04 10:11:41 +01:00
Yap_FreeCodeSpace((char *)LOCAL_ConsultLow);
2015-10-22 00:53:26 +01:00
LOCAL_ConsultBase = LOCAL_ConsultSp = LOCAL_ConsultLow = NULL;
2011-05-04 10:11:41 +01:00
LOCAL_ConsultCapacity = InitialConsultCapacity;
}
/******************************************************************
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
ADDING AND REMOVE INFO TO A PROCEDURE
2015-04-13 13:28:17 +01:00
******************************************************************/
/*
* we have three kinds of predicates: dynamic DynamicPredFlag
* static CompiledPredFlag fast FastPredFlag all the
* database predicates are supported for dynamic predicates only abolish and
* assertz are supported for static predicates no database predicates are
2015-04-13 13:28:17 +01:00
* supportted for fast predicates
*/
2016-09-27 18:31:12 +01:00
PredEntry *Yap_get_pred(Term t, Term tmod, const char *pname) {
Term t0 = t;
2015-10-22 00:53:26 +01:00
restart:
if (IsVarTerm(t)) {
2015-01-18 01:32:13 +00:00
Yap_Error(INSTANTIATION_ERROR, t0, pname);
return NULL;
} else if (IsAtomTerm(t)) {
return RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t), tmod));
} else if (IsIntegerTerm(t) && tmod == IDB_MODULE) {
return Yap_FindLUIntKey(IntegerOfTerm(t));
2017-02-26 20:34:17 +00:00
} else if (IsPairTerm(t)) {
t = Yap_MkApplTerm(FunctorCsult, 1, &t);
goto restart;
} else if (IsApplTerm(t)) {
2015-10-22 00:53:26 +01:00
Functor fun = FunctorOfTerm(t);
if (IsExtensionFunctor(fun)) {
2015-01-18 01:32:13 +00:00
Yap_Error(TYPE_ERROR_CALLABLE, Yap_PredicateIndicator(t, tmod), pname);
2015-04-13 13:28:17 +01:00
return NULL;
}
if (fun == FunctorModule) {
Term tmod = ArgOfTerm(1, t);
2015-10-22 00:53:26 +01:00
if (IsVarTerm(tmod)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
return NULL;
}
2015-10-22 00:53:26 +01:00
if (!IsAtomTerm(tmod)) {
Yap_Error(TYPE_ERROR_ATOM, t0, pname);
return NULL;
}
t = ArgOfTerm(2, t);
goto restart;
}
return RepPredProp(Yap_GetPredPropByFunc(fun, tmod));
2016-08-02 17:34:58 +01:00
} else {
Yap_Error(TYPE_ERROR_CALLABLE, t0, pname);
}
return NULL;
}
/** Look for a predicate with same functor as t,
create a new one of it cannot find it.
*/
static PredEntry *new_pred(Term t, Term tmod, char *pname) {
Term t0 = t;
restart:
if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
return NULL;
} else if (IsAtomTerm(t)) {
return RepPredProp(PredPropByAtom(AtomOfTerm(t), tmod));
} else if (IsIntegerTerm(t) && tmod == IDB_MODULE) {
return Yap_FindLUIntKey(IntegerOfTerm(t));
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
if (IsExtensionFunctor(fun)) {
Yap_Error(TYPE_ERROR_CALLABLE, Yap_PredicateIndicator(t, tmod), pname);
return NULL;
}
if (fun == FunctorModule) {
Term tmod = ArgOfTerm(1, t);
if (IsVarTerm(tmod)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
return NULL;
}
if (!IsAtomTerm(tmod)) {
Yap_Error(TYPE_ERROR_ATOM, t0, pname);
return NULL;
}
t = ArgOfTerm(2, t);
goto restart;
}
return RepPredProp(PredPropByFunc(fun, tmod));
} else
return NULL;
}
/******************************************************************
2015-10-22 00:53:26 +01:00
Mega Clauses
2015-04-13 13:28:17 +01:00
******************************************************************/
2015-04-13 13:28:17 +01:00
#define OrArgAdjust(P)
#define TabEntryAdjust(P)
#define DoubleInCodeAdjust(D)
#define IntegerInCodeAdjust(D)
2015-10-22 00:53:26 +01:00
#define IntegerAdjust(D) (D)
#define PtoPredAdjust(X) (X)
#define PtoOpAdjust(X) (X)
#define PtoLUClauseAdjust(P) (P)
#define PtoLUIndexAdjust(P) (P)
#define XAdjust(X) (X)
#define YAdjust(X) (X)
#define AtomTermAdjust(X) (X)
#define CellPtoHeapAdjust(X) (X)
#define FuncAdjust(X) (X)
#define CodeAddrAdjust(X) (X)
#define CodeComposedTermAdjust(X) (X)
#define ConstantAdjust(X) (X)
#define ArityAdjust(X) (X)
#define OpcodeAdjust(X) (X)
#define ModuleAdjust(X) (X)
#define ExternalFunctionAdjust(X) (X)
2015-10-22 00:53:26 +01:00
#define AdjustSwitchTable(X, Y, Z)
#define DBGroundTermAdjust(X) (X)
#define rehash(A, B, C)
2015-10-22 00:53:26 +01:00
static Term BlobTermInCodeAdjust(Term t) {
CACHE_REGS
#if TAGS_FAST_OPS
2015-10-22 00:53:26 +01:00
return t - LOCAL_ClDiff;
#else
2015-10-22 00:53:26 +01:00
return t + LOCAL_ClDiff;
#endif
}
2015-10-22 00:53:26 +01:00
static Term ConstantTermAdjust(Term t) {
if (IsAtomTerm(t))
return AtomTermAdjust(t);
return t;
}
#include "rclause.h"
#ifdef DEBUG
2015-10-22 00:53:26 +01:00
static UInt total_megaclause, total_released, nof_megaclauses;
#endif
2015-10-22 00:53:26 +01:00
void Yap_BuildMegaClause(PredEntry *ap) {
CACHE_REGS
StaticClause *cl;
UInt sz;
MegaClause *mcl;
yamop *ptr;
size_t required;
UInt has_blobs = 0;
2015-10-22 00:53:26 +01:00
if (ap->PredFlags & (DynamicPredFlag | LogUpdatePredFlag | MegaClausePredFlag
#ifdef TABLING
2015-10-22 00:53:26 +01:00
| TabledPredFlag
#endif /* TABLING */
2015-10-22 00:53:26 +01:00
| UDIPredFlag) ||
ap->cs.p_code.FirstClause == NULL || ap->cs.p_code.NOfClauses < 16) {
return;
}
2015-10-22 00:53:26 +01:00
cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
sz = cl->ClSize;
while (TRUE) {
2015-10-22 00:53:26 +01:00
if (!(cl->ClFlags & FactMask))
return; /* no mega clause, sorry */
if (cl->ClSize != sz)
return; /* no mega clause, sorry */
if (cl->ClCode == ap->cs.p_code.LastClause)
break;
has_blobs |= (cl->ClFlags & HasBlobsMask);
cl = cl->ClNext;
}
/* ok, we got the chance for a mega clause */
if (has_blobs) {
sz -= sizeof(StaticClause);
} else {
2015-10-22 00:53:26 +01:00
sz -= (UInt)NEXTOP((yamop *)NULL, p) + sizeof(StaticClause);
}
2015-10-22 00:53:26 +01:00
required = sz * ap->cs.p_code.NOfClauses + sizeof(MegaClause) +
(UInt)NEXTOP((yamop *)NULL, l);
while (!(mcl = (MegaClause *)Yap_AllocCodeSpace(required))) {
if (!Yap_growheap(FALSE, required, NULL)) {
/* just fail, the system will keep on going */
return;
}
}
#ifdef DEBUG
total_megaclause += required;
2015-10-22 00:53:26 +01:00
cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
total_released += ap->cs.p_code.NOfClauses * cl->ClSize;
nof_megaclauses++;
#endif
Yap_ClauseSpace += required;
/* cool, it's our turn to do the conversion */
mcl->ClFlags = MegaMask | has_blobs;
mcl->ClSize = required;
mcl->ClPred = ap;
mcl->ClItemSize = sz;
mcl->ClNext = NULL;
2015-10-22 00:53:26 +01:00
cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
mcl->ClLine = cl->usc.ClLine;
ptr = mcl->ClCode;
while (TRUE) {
memcpy((void *)ptr, (void *)cl->ClCode, sz);
if (has_blobs) {
2015-10-22 00:53:26 +01:00
LOCAL_ClDiff = (char *)(ptr) - (char *)cl->ClCode;
restore_opcodes(ptr, NULL PASS_REGS);
}
ptr = (yamop *)((char *)ptr + sz);
if (cl->ClCode == ap->cs.p_code.LastClause)
break;
cl = cl->ClNext;
}
ptr->opc = Yap_opcode(_Ystop);
2015-10-22 00:53:26 +01:00
cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
/* recover the space spent on the original clauses */
while (TRUE) {
StaticClause *ncl, *curcl = cl;
ncl = cl->ClNext;
2012-03-09 11:46:34 +00:00
Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((ADDR)cl);
if (curcl->ClCode == ap->cs.p_code.LastClause)
break;
cl = ncl;
}
2015-10-22 00:53:26 +01:00
ap->cs.p_code.FirstClause = ap->cs.p_code.LastClause = mcl->ClCode;
2013-09-28 18:20:04 +01:00
ap->PredFlags |= MegaClausePredFlag;
2015-10-22 00:53:26 +01:00
Yap_inform_profiler_of_clause(mcl, (char *)mcl + required, ap, GPROF_MEGA);
}
2015-10-22 00:53:26 +01:00
static void split_megaclause(PredEntry *ap) {
StaticClause *start = NULL, *prev = NULL;
MegaClause *mcl;
yamop *ptr;
UInt ncls = ap->cs.p_code.NOfClauses, i;
2015-10-22 00:53:26 +01:00
mcl = ClauseCodeToMegaClause(ap->cs.p_code.FirstClause);
2013-01-14 09:48:05 +00:00
if (mcl->ClFlags & ExoMask) {
2015-10-22 00:53:26 +01:00
Yap_Error(PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, TermNil,
"while deleting clause from exo predicate %s/%d\n",
RepAtom(NameOfFunctor(ap->FunctorOfPred))->StrOfAE,
ap->ArityOfPE);
2013-01-14 09:48:05 +00:00
return;
}
RemoveIndexation(ap);
for (i = 0, ptr = mcl->ClCode; i < ncls; i++) {
2015-10-22 00:53:26 +01:00
StaticClause *new = (StaticClause *)Yap_AllocCodeSpace(
sizeof(StaticClause) + mcl->ClItemSize +
(UInt)NEXTOP((yamop *)NULL, p));
if (new == NULL) {
2015-10-22 00:53:26 +01:00
if (!Yap_growheap(FALSE,
(sizeof(StaticClause) + mcl->ClItemSize) * (ncls - i),
NULL)) {
while (start) {
StaticClause *cl = start;
start = cl->ClNext;
Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl);
}
if (ap->ArityOfPE) {
Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"while breaking up mega clause for %s/%d\n",
RepAtom(NameOfFunctor(ap->FunctorOfPred))->StrOfAE,
ap->ArityOfPE);
} else {
Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
"while breaking up mega clause for %s\n",
RepAtom((Atom)ap->FunctorOfPred)->StrOfAE);
}
return;
}
2010-12-31 05:37:25 +00:00
break;
}
2015-10-22 00:53:26 +01:00
Yap_ClauseSpace +=
sizeof(StaticClause) + mcl->ClItemSize + (UInt)NEXTOP((yamop *)NULL, p);
new->ClFlags = StaticMask | FactMask;
new->ClSize = mcl->ClItemSize;
new->usc.ClLine = Yap_source_line_no();
new->ClNext = NULL;
memcpy((void *)new->ClCode, (void *)ptr, mcl->ClItemSize);
if (prev) {
prev->ClNext = new;
} else {
start = new;
}
ptr = (yamop *)((char *)ptr + mcl->ClItemSize);
prev = new;
}
ap->PredFlags &= ~MegaClausePredFlag;
ap->cs.p_code.FirstClause = start->ClCode;
ap->cs.p_code.LastClause = prev->ClCode;
}
/******************************************************************
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
Indexation Info
2015-04-13 13:28:17 +01:00
******************************************************************/
2015-10-22 00:53:26 +01:00
#define ByteAdr(X) ((Int) & (X))
/* Index a prolog pred, given its predicate entry */
/* ap is already locked. */
2015-10-22 00:53:26 +01:00
static void IPred(PredEntry *ap, UInt NSlots, yamop *next_pc) {
yamop *BaseAddr;
#ifdef DEBUG
2011-03-07 16:34:20 +00:00
CACHE_REGS
if (GLOBAL_Option['i' - 'a' + 1]) {
Term tmod = ap->ModuleOfPred;
if (!tmod)
tmod = TermProlog;
2015-10-22 00:53:26 +01:00
Yap_DebugPutc(stderr, '\t');
Yap_DebugPlWrite(tmod);
2015-10-22 00:53:26 +01:00
Yap_DebugPutc(stderr, ':');
if (ap->ModuleOfPred == IDB_MODULE) {
Term t = Deref(ARG1);
if (IsAtomTerm(t)) {
2015-10-22 00:53:26 +01:00
Yap_DebugPlWrite(t);
} else if (IsIntegerTerm(t)) {
2015-10-22 00:53:26 +01:00
Yap_DebugPlWrite(t);
} else {
2015-10-22 00:53:26 +01:00
Functor f = FunctorOfTerm(t);
Atom At = NameOfFunctor(f);
Yap_DebugPlWrite(MkAtomTerm(At));
Yap_DebugPutc(stderr, '/');
Yap_DebugPlWrite(MkIntTerm(ArityOfFunctor(f)));
}
} else {
if (ap->ArityOfPE == 0) {
2015-10-22 00:53:26 +01:00
Atom At = (Atom)ap->FunctorOfPred;
Yap_DebugPlWrite(MkAtomTerm(At));
} else {
2015-10-22 00:53:26 +01:00
Functor f = ap->FunctorOfPred;
Atom At = NameOfFunctor(f);
Yap_DebugPlWrite(MkAtomTerm(At));
Yap_DebugPutc(stderr, '/');
Yap_DebugPlWrite(MkIntTerm(ArityOfFunctor(f)));
}
}
2015-10-22 00:53:26 +01:00
Yap_DebugPutc(stderr, '\n');
}
#endif
/* Do not try to index a dynamic predicate or one whithout args */
if (is_dynamic(ap)) {
2015-10-22 00:53:26 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil,
"trying to index a dynamic predicate");
return;
}
if ((BaseAddr = Yap_PredIsIndexable(ap, NSlots, next_pc)) != NULL) {
ap->cs.p_code.TrueCodeOfPred = BaseAddr;
ap->PredFlags |= IndexedPredFlag;
}
2015-10-22 00:53:26 +01:00
if (ap->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
if (ap->PredFlags & ProfiledPredFlag) {
2016-05-13 11:41:19 +01:00
Yap_initProfiler(ap);
}
ap->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
ap->CodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
#if defined(YAPOR) || defined(THREADS)
} else if (ap->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(ap->PredFlags & ThreadLocalPredFlag) &&
ap->ModuleOfPred != IDB_MODULE) {
ap->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
ap->CodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
#endif
} else {
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred;
ap->OpcodeOfPred = ap->CodeOfPred->opc;
}
#ifdef DEBUG
if (GLOBAL_Option['i' - 'a' + 1])
2015-10-22 00:53:26 +01:00
Yap_DebugPutc(stderr, '\n');
#endif
}
2015-10-22 00:53:26 +01:00
void Yap_IPred(PredEntry *p, UInt NSlots, yamop *next_pc) {
IPred(p, NSlots, next_pc);
}
2015-10-22 00:53:26 +01:00
#define GONEXT(TYPE) code_p = ((yamop *)(&(code_p->y_u.TYPE.next)))
2015-10-22 00:53:26 +01:00
static void RemoveMainIndex(PredEntry *ap) {
yamop *First = ap->cs.p_code.FirstClause;
2015-10-22 00:53:26 +01:00
int spied =
ap->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag);
ap->PredFlags &= ~IndexedPredFlag;
if (First == NULL) {
ap->cs.p_code.TrueCodeOfPred = FAILCODE;
} else {
ap->cs.p_code.TrueCodeOfPred = First;
}
if (First != NULL && spied) {
ap->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
ap->CodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
} else if (ap->cs.p_code.NOfClauses > 1
#ifdef TABLING
2015-10-22 00:53:26 +01:00
|| ap->PredFlags & TabledPredFlag
#endif /* TABLING */
2015-10-22 00:53:26 +01:00
) {
ap->OpcodeOfPred = INDEX_OPCODE;
2015-10-22 00:53:26 +01:00
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred =
(yamop *)(&(ap->OpcodeOfPred));
} else {
ap->OpcodeOfPred = ap->cs.p_code.TrueCodeOfPred->opc;
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred;
}
#if defined(YAPOR) || defined(THREADS)
if (ap->PredFlags & LogUpdatePredFlag &&
2011-03-15 09:08:09 +00:00
!(ap->PredFlags & ThreadLocalPredFlag) &&
ap->ModuleOfPred != IDB_MODULE) {
ap->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
ap->CodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
}
#endif
}
2015-10-22 00:53:26 +01:00
static void decrease_ref_counter(yamop *ptr, yamop *b, yamop *e, yamop *sc) {
if (ptr != FAILCODE && ptr != sc && (ptr < b || ptr > e)) {
LogUpdClause *cl = ClauseCodeToLogUpdClause(ptr);
cl->ClRefCount--;
2015-10-22 00:53:26 +01:00
if (cl->ClFlags & ErasedMask && !(cl->ClRefCount) &&
!(cl->ClFlags & InUseMask)) {
/* last ref to the clause */
Yap_ErLogUpdCl(cl);
}
}
}
2015-10-22 00:53:26 +01:00
static yamop *release_wcls(yamop *cop, OPCODE ecs) {
if (cop->opc == ecs) {
2014-05-30 01:06:09 +01:00
cop->y_u.sssllp.s3--;
if (!cop->y_u.sssllp.s3) {
2015-10-22 00:53:26 +01:00
UInt sz = (UInt)NEXTOP((yamop *)NULL, sssllp) +
cop->y_u.sssllp.s1 * sizeof(yamop *);
LOCK(ExpandClausesListLock);
#ifdef DEBUG
Yap_expand_clauses_sz -= sz;
Yap_ExpandClauses--;
#endif
2014-05-30 01:06:09 +01:00
if (cop->y_u.sssllp.p->PredFlags & LogUpdatePredFlag) {
2015-10-22 00:53:26 +01:00
Yap_LUIndexSpace_EXT -= sz;
} else {
2015-10-22 00:53:26 +01:00
Yap_IndexSpace_EXT -= sz;
}
if (ExpandClausesFirst == cop)
2015-10-22 00:53:26 +01:00
ExpandClausesFirst = cop->y_u.sssllp.snext;
if (ExpandClausesLast == cop) {
2015-10-22 00:53:26 +01:00
ExpandClausesLast = cop->y_u.sssllp.sprev;
}
2014-05-30 01:06:09 +01:00
if (cop->y_u.sssllp.sprev) {
2015-10-22 00:53:26 +01:00
cop->y_u.sssllp.sprev->y_u.sssllp.snext = cop->y_u.sssllp.snext;
}
2014-05-30 01:06:09 +01:00
if (cop->y_u.sssllp.snext) {
2015-10-22 00:53:26 +01:00
cop->y_u.sssllp.snext->y_u.sssllp.sprev = cop->y_u.sssllp.sprev;
}
UNLOCK(ExpandClausesListLock);
2012-03-09 11:46:34 +00:00
Yap_InformOfRemoval(cop);
Yap_FreeCodeSpace((char *)cop);
}
}
return FAILCODE;
}
2015-10-22 00:53:26 +01:00
static void cleanup_dangling_indices(yamop *ipc, yamop *beg, yamop *end,
yamop *suspend_code) {
OPCODE ecs = Yap_opcode(_expand_clauses);
while (ipc) {
op_numbers op = Yap_op_from_opcode(ipc->opc);
/* fprintf(stderr,"op: %d %p->%p\n", op, ipc, end);*/
2015-10-22 00:53:26 +01:00
switch (op) {
case _Ystop:
/* end of clause, for now */
return;
case _index_dbref:
case _index_blob:
case _index_long:
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, e);
break;
case _lock_lu:
case _unlock_lu:
/* locking should be done already */
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, e);
case _retry_profiled:
case _count_retry:
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, p);
break;
case _try_clause2:
case _try_clause3:
case _try_clause4:
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, l);
break;
case _retry2:
case _retry3:
case _retry4:
2014-05-30 01:06:09 +01:00
decrease_ref_counter(ipc->y_u.l.l, beg, end, suspend_code);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, l);
break;
case _retry:
case _trust:
2014-05-30 01:06:09 +01:00
decrease_ref_counter(ipc->y_u.Otapl.d, beg, end, suspend_code);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, Otapl);
break;
case _try_clause:
case _try_me:
case _retry_me:
case _profiled_trust_me:
case _trust_me:
case _count_trust_me:
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, Otapl);
break;
case _try_logical:
case _retry_logical:
case _count_retry_logical:
2015-10-22 00:53:26 +01:00
case _profiled_retry_logical: {
yamop *oipc = ipc;
decrease_ref_counter(ipc->y_u.OtaLl.d->ClCode, beg, end, suspend_code);
ipc = ipc->y_u.OtaLl.n;
Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL, OtaLl);
Yap_FreeCodeSpace((ADDR)oipc);
#ifdef DEBUG
2015-10-22 00:53:26 +01:00
Yap_DirtyCps--;
Yap_FreedCps++;
#endif
2015-10-22 00:53:26 +01:00
} break;
case _trust_logical:
case _count_trust_logical:
case _profiled_trust_logical:
#ifdef DEBUG
Yap_DirtyCps--;
Yap_FreedCps++;
#endif
2014-05-30 01:06:09 +01:00
decrease_ref_counter(ipc->y_u.OtILl.d->ClCode, beg, end, suspend_code);
2015-10-22 00:53:26 +01:00
Yap_LUIndexSpace_CP -= (UInt)NEXTOP((yamop *)NULL, OtILl);
Yap_FreeCodeSpace((ADDR)ipc);
return;
2015-10-22 00:53:26 +01:00
case _enter_lu_pred: {
yamop *oipc = ipc;
if (ipc->y_u.Illss.I->ClFlags & InUseMask || ipc->y_u.Illss.I->ClRefCount)
return;
#ifdef DEBUG
2015-10-22 00:53:26 +01:00
Yap_DirtyCps += ipc->y_u.Illss.s;
Yap_LiveCps -= ipc->y_u.Illss.s;
#endif
2015-10-22 00:53:26 +01:00
ipc = ipc->y_u.Illss.l1;
/* in case we visit again */
oipc->y_u.Illss.l1 = FAILCODE;
oipc->y_u.Illss.s = 0;
oipc->y_u.Illss.e = 0;
} break;
case _try_in:
case _jump:
case _jump_if_var:
2014-05-30 01:06:09 +01:00
ipc->y_u.l.l = release_wcls(ipc->y_u.l.l, ecs);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, l);
break;
2015-10-22 00:53:26 +01:00
/* instructions type xl */
case _jump_if_nonvar:
2014-05-30 01:06:09 +01:00
ipc->y_u.xll.l1 = release_wcls(ipc->y_u.xll.l1, ecs);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, xll);
break;
2015-10-22 00:53:26 +01:00
/* instructions type p */
case _user_switch:
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, lp);
break;
2015-10-22 00:53:26 +01:00
/* instructions type e */
case _switch_on_type:
2014-05-30 01:06:09 +01:00
ipc->y_u.llll.l1 = release_wcls(ipc->y_u.llll.l1, ecs);
ipc->y_u.llll.l2 = release_wcls(ipc->y_u.llll.l2, ecs);
ipc->y_u.llll.l3 = release_wcls(ipc->y_u.llll.l3, ecs);
ipc->y_u.llll.l4 = release_wcls(ipc->y_u.llll.l4, ecs);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, llll);
break;
case _switch_list_nl:
2014-05-30 01:06:09 +01:00
ipc->y_u.ollll.l1 = release_wcls(ipc->y_u.ollll.l1, ecs);
ipc->y_u.ollll.l2 = release_wcls(ipc->y_u.ollll.l2, ecs);
ipc->y_u.ollll.l3 = release_wcls(ipc->y_u.ollll.l3, ecs);
ipc->y_u.ollll.l4 = release_wcls(ipc->y_u.ollll.l4, ecs);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, ollll);
break;
case _switch_on_arg_type:
2014-05-30 01:06:09 +01:00
ipc->y_u.xllll.l1 = release_wcls(ipc->y_u.xllll.l1, ecs);
ipc->y_u.xllll.l2 = release_wcls(ipc->y_u.xllll.l2, ecs);
ipc->y_u.xllll.l3 = release_wcls(ipc->y_u.xllll.l3, ecs);
ipc->y_u.xllll.l4 = release_wcls(ipc->y_u.xllll.l4, ecs);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, xllll);
break;
case _switch_on_sub_arg_type:
2014-05-30 01:06:09 +01:00
ipc->y_u.sllll.l1 = release_wcls(ipc->y_u.sllll.l1, ecs);
ipc->y_u.sllll.l2 = release_wcls(ipc->y_u.sllll.l2, ecs);
ipc->y_u.sllll.l3 = release_wcls(ipc->y_u.sllll.l3, ecs);
ipc->y_u.sllll.l4 = release_wcls(ipc->y_u.sllll.l4, ecs);
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, sllll);
break;
case _if_not_then:
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, clll);
break;
case _switch_on_func:
case _if_func:
case _go_on_func:
case _switch_on_cons:
case _if_cons:
case _go_on_cons:
2015-10-22 00:53:26 +01:00
/* make sure we don't leave dangling references to memory that is going to
* be removed */
2014-05-30 01:06:09 +01:00
ipc->y_u.sssl.l = NULL;
2015-10-22 00:53:26 +01:00
ipc = NEXTOP(ipc, sssl);
break;
case _op_fail:
return;
default:
2015-10-22 00:53:26 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil,
"Bug in Indexing Code: opcode %d", op);
return;
}
#if defined(YAPOR) || defined(THREADS)
ipc = (yamop *)((CELL)ipc & ~1);
2015-04-13 13:28:17 +01:00
#endif
}
}
2015-10-22 00:53:26 +01:00
static void decrease_log_indices(LogUpdIndex *c, yamop *suspend_code) {
/* decrease all reference counters */
yamop *beg = c->ClCode, *end, *ipc;
2011-12-30 16:02:59 +00:00
if (c->ClFlags & SwitchTableMask) {
2015-10-22 00:53:26 +01:00
CELL *end = (CELL *)((char *)c + c->ClSize);
CELL *beg = (CELL *)(c->ClCode);
OPCODE ecs = Yap_opcode(_expand_clauses);
while (beg < end) {
2015-10-22 00:53:26 +01:00
yamop **x = (yamop **)(beg + 1);
beg += 2;
*x = release_wcls(*x, ecs);
}
return;
}
2015-10-22 00:53:26 +01:00
end = (yamop *)((CODEADDR)c + c->ClSize);
ipc = beg;
cleanup_dangling_indices(ipc, beg, end, suspend_code);
}
2015-10-22 00:53:26 +01:00
static void kill_static_child_indxs(StaticIndex *indx, int in_use) {
StaticIndex *cl = indx->ChildIndex;
while (cl != NULL) {
StaticIndex *next = cl->SiblingIndex;
kill_static_child_indxs(cl, in_use);
cl = next;
}
if (in_use) {
LOCK(DeadStaticIndicesLock);
indx->SiblingIndex = DeadStaticIndices;
indx->ChildIndex = NULL;
DeadStaticIndices = indx;
UNLOCK(DeadStaticIndicesLock);
} else {
2012-03-09 11:46:34 +00:00
Yap_InformOfRemoval(indx);
if (indx->ClFlags & SwitchTableMask)
Yap_IndexSpace_SW -= indx->ClSize;
else
Yap_IndexSpace_Tree -= indx->ClSize;
Yap_FreeCodeSpace((char *)indx);
}
}
2015-10-22 00:53:26 +01:00
static void kill_children(LogUpdIndex *c, PredEntry *ap) {
LogUpdIndex *ncl;
c->ClRefCount++;
ncl = c->ChildIndex;
/* kill children */
while (ncl) {
kill_first_log_iblock(ncl, c, ap);
ncl = c->ChildIndex;
}
c->ClRefCount--;
}
/* assumes c is already locked */
2015-10-22 00:53:26 +01:00
static void kill_off_lu_block(LogUpdIndex *c, LogUpdIndex *parent,
PredEntry *ap) {
/* first, make sure that I killed off all my children, some children may
remain in case I have tables as children */
if (parent != NULL) {
/* sat bye bye */
/* decrease refs */
parent->ClRefCount--;
2015-10-22 00:53:26 +01:00
if (parent->ClFlags & ErasedMask && !(parent->ClFlags & InUseMask) &&
parent->ClRefCount == 0) {
/* cool, I can erase the father too. */
if (parent->ClFlags & SwitchRootMask) {
2015-10-22 00:53:26 +01:00
kill_off_lu_block(parent, NULL, ap);
} else {
2015-10-22 00:53:26 +01:00
kill_off_lu_block(parent, parent->ParentIndex, ap);
}
}
}
decrease_log_indices(c, (yamop *)&(ap->cs.p_code.ExpandCode));
/* remove from list */
if (c->SiblingIndex)
c->SiblingIndex->PrevSiblingIndex = c->PrevSiblingIndex;
if (c->PrevSiblingIndex) {
c->PrevSiblingIndex->SiblingIndex = c->SiblingIndex;
} else {
DBErasedIList = c->SiblingIndex;
}
2012-03-09 11:46:34 +00:00
Yap_InformOfRemoval(c);
if (c->ClFlags & SwitchTableMask)
Yap_LUIndexSpace_SW -= c->ClSize;
else {
Yap_LUIndexSpace_Tree -= c->ClSize;
}
Yap_FreeCodeSpace((char *)c);
}
2015-10-22 00:53:26 +01:00
static void kill_first_log_iblock(LogUpdIndex *c, LogUpdIndex *parent,
PredEntry *ap) {
/* parent is always locked, now I lock myself */
if (parent != NULL) {
/* remove myself from parent */
if (c == parent->ChildIndex) {
parent->ChildIndex = c->SiblingIndex;
if (parent->ChildIndex) {
2015-10-22 00:53:26 +01:00
parent->ChildIndex->PrevSiblingIndex = NULL;
}
} else {
2015-10-22 00:53:26 +01:00
c->PrevSiblingIndex->SiblingIndex = c->SiblingIndex;
if (c->SiblingIndex) {
2015-10-22 00:53:26 +01:00
c->SiblingIndex->PrevSiblingIndex = c->PrevSiblingIndex;
}
}
} else {
/* I am top node */
if (ap->cs.p_code.TrueCodeOfPred == c->ClCode) {
RemoveMainIndex(ap);
}
}
decrease_log_indices(c, (yamop *)&(ap->cs.p_code.ExpandCode));
/* make sure that a child cannot remove us */
kill_children(c, ap);
/* check if we are still the main index */
/* always add to erased list */
c->SiblingIndex = DBErasedIList;
c->PrevSiblingIndex = NULL;
if (DBErasedIList)
DBErasedIList->PrevSiblingIndex = c;
DBErasedIList = c;
if (!((c->ClFlags & InUseMask) || c->ClRefCount)) {
kill_off_lu_block(c, parent, ap);
} else {
if (c->ClFlags & ErasedMask)
return;
c->ClFlags |= ErasedMask;
/* try to move up, so that we don't hold a switch table */
2015-10-22 00:53:26 +01:00
if (parent != NULL && parent->ClFlags & SwitchTableMask) {
2015-04-13 13:28:17 +01:00
c->ParentIndex = parent->ParentIndex;
parent->ParentIndex->ClRefCount++;
parent->ClRefCount--;
}
}
}
2015-10-22 00:53:26 +01:00
static void kill_top_static_iblock(StaticIndex *c, PredEntry *ap) {
2015-09-21 23:05:36 +01:00
kill_static_child_indxs(c, Yap_static_in_use(ap, TRUE));
RemoveMainIndex(ap);
}
2015-10-22 00:53:26 +01:00
void Yap_kill_iblock(ClauseUnion *blk, ClauseUnion *parent_blk, PredEntry *ap) {
if (ap->PredFlags & LogUpdatePredFlag) {
LogUpdIndex *c = (LogUpdIndex *)blk;
if (parent_blk != NULL) {
LogUpdIndex *cl = (LogUpdIndex *)parent_blk;
#if MULTIPLE_STACKS
/* protect against attempts at erasing */
cl->ClRefCount++;
#endif
kill_first_log_iblock(c, cl, ap);
#if MULTIPLE_STACKS
cl->ClRefCount--;
#endif
} else {
kill_first_log_iblock(c, NULL, ap);
}
} else {
StaticIndex *c = (StaticIndex *)blk;
if (parent_blk != NULL) {
StaticIndex *cl = parent_blk->si.ChildIndex;
if (cl == c) {
2015-10-22 00:53:26 +01:00
parent_blk->si.ChildIndex = c->SiblingIndex;
} else {
2015-10-22 00:53:26 +01:00
while (cl->SiblingIndex != c) {
cl = cl->SiblingIndex;
}
cl->SiblingIndex = c->SiblingIndex;
}
}
2015-09-21 23:05:36 +01:00
kill_static_child_indxs(c, Yap_static_in_use(ap, TRUE));
}
}
/*
This predicate is supposed to be called with a
lock on the current predicate
*/
2015-10-22 00:53:26 +01:00
void Yap_ErLogUpdIndex(LogUpdIndex *clau) {
if (clau->ClFlags & ErasedMask) {
if (!clau->ClRefCount) {
2015-10-22 00:53:26 +01:00
decrease_log_indices(clau,
(yamop *)&(clau->ClPred->cs.p_code.ExpandCode));
if (clau->ClFlags & SwitchRootMask) {
2015-10-22 00:53:26 +01:00
kill_off_lu_block(clau, NULL, clau->ClPred);
} else {
2015-10-22 00:53:26 +01:00
kill_off_lu_block(clau, clau->ParentIndex, clau->ClPred);
}
}
/* otherwise, nothing I can do, I have been erased already */
return;
}
if (clau->ClFlags & SwitchRootMask) {
kill_first_log_iblock(clau, NULL, clau->ClPred);
} else {
#if MULTIPLE_STACKS
/* protect against attempts at erasing */
clau->ClRefCount++;
#endif
kill_first_log_iblock(clau, clau->ParentIndex, clau->ClPred);
#if MULTIPLE_STACKS
/* protect against attempts at erasing */
clau->ClRefCount--;
#endif
}
}
/* Routine used when wanting to remove the indexation */
/* ap is known to already have been locked for WRITING */
2015-10-22 00:53:26 +01:00
static int RemoveIndexation(PredEntry *ap) {
if (ap->OpcodeOfPred == INDEX_OPCODE) {
return TRUE;
}
if (ap->PredFlags & LogUpdatePredFlag) {
2015-10-22 00:53:26 +01:00
kill_first_log_iblock(ClauseCodeToLogUpdIndex(ap->cs.p_code.TrueCodeOfPred),
NULL, ap);
} else {
StaticIndex *cl;
cl = ClauseCodeToStaticIndex(ap->cs.p_code.TrueCodeOfPred);
2015-04-13 13:28:17 +01:00
kill_top_static_iblock(cl, ap);
}
return TRUE;
}
2015-10-22 00:53:26 +01:00
int Yap_RemoveIndexation(PredEntry *ap) { return RemoveIndexation(ap); }
/******************************************************************
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
Adding clauses
2015-04-13 13:28:17 +01:00
******************************************************************/
2015-10-22 00:53:26 +01:00
#define assertz 0
#define consult 1
#define asserta 2
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void retract_all(PredEntry *p, int in_use) {
yamop *q;
q = p->cs.p_code.FirstClause;
if (q != NULL) {
2015-04-13 13:28:17 +01:00
if (p->PredFlags & LogUpdatePredFlag) {
LogUpdClause *cl = ClauseCodeToLogUpdClause(q);
do {
2015-10-22 00:53:26 +01:00
LogUpdClause *ncl = cl->ClNext;
Yap_ErLogUpdCl(cl);
cl = ncl;
} while (cl != NULL);
2015-04-13 13:28:17 +01:00
} else if (p->PredFlags & MegaClausePredFlag) {
MegaClause *cl = ClauseCodeToMegaClause(q);
if (in_use || cl->ClFlags & HasBlobsMask) {
2015-10-22 00:53:26 +01:00
LOCK(DeadMegaClausesLock);
cl->ClNext = DeadMegaClauses;
DeadMegaClauses = cl;
UNLOCK(DeadMegaClausesLock);
} else {
2015-10-22 00:53:26 +01:00
Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl);
}
/* make sure this is not a MegaClause */
p->PredFlags &= ~MegaClausePredFlag;
p->cs.p_code.NOfClauses = 0;
} else {
2015-10-22 00:53:26 +01:00
StaticClause *cl = ClauseCodeToStaticClause(q);
while (cl) {
2015-10-22 00:53:26 +01:00
StaticClause *ncl = cl->ClNext;
if (in_use || cl->ClFlags & HasBlobsMask) {
LOCK(DeadStaticClausesLock);
cl->ClNext = DeadStaticClauses;
DeadStaticClauses = cl;
UNLOCK(DeadStaticClausesLock);
} else {
Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl);
}
p->cs.p_code.NOfClauses--;
if (!ncl)
break;
cl = ncl;
}
}
}
p->cs.p_code.FirstClause = NULL;
p->cs.p_code.LastClause = NULL;
2015-10-22 00:53:26 +01:00
if (p->PredFlags & (DynamicPredFlag | LogUpdatePredFlag | MultiFileFlag)) {
p->OpcodeOfPred = FAIL_OPCODE;
} else {
p->OpcodeOfPred = UNDEF_OPCODE;
}
p->cs.p_code.TrueCodeOfPred = p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
2016-01-03 01:27:36 +00:00
if (trueGlobalPrologFlag(PROFILING_FLAG)) {
p->PredFlags |= ProfiledPredFlag;
if (!Yap_initProfiler(p)) {
2016-05-13 11:41:19 +01:00
return;
}
} else
p->PredFlags &= ~ProfiledPredFlag;
if (CALL_COUNTING) {
p->PredFlags |= CountPredFlag;
} else
p->PredFlags &= ~CountPredFlag;
Yap_PutValue(AtomAbol, MkAtomTerm(AtomTrue));
}
2016-01-03 01:27:36 +00:00
bool Yap_unknown(Term t) {
2015-12-15 09:18:36 +00:00
2016-01-03 01:27:36 +00:00
if (t == TermFastFail) {
UndefCode->OpcodeOfPred = FAIL_OPCODE;
return true;
} else if (t == TermError) {
UndefCode->OpcodeOfPred = UndefCode->CodeOfPred->opc;
return true;
} else if (t == TermFail) {
UndefCode->OpcodeOfPred = UndefCode->CodeOfPred->opc;
return true;
} else if (t == TermWarning) {
UndefCode->OpcodeOfPred = UndefCode->CodeOfPred->opc;
return true;
}
return false;
2015-12-15 09:18:36 +00:00
}
2016-01-03 01:27:36 +00:00
2015-10-22 00:53:26 +01:00
static int source_pred(PredEntry *p, yamop *q) {
if (p->PredFlags & (DynamicPredFlag | LogUpdatePredFlag))
2011-08-25 03:19:27 +01:00
return FALSE;
if (p->PredFlags & MultiFileFlag)
return TRUE;
2015-06-19 01:30:13 +01:00
if (trueGlobalPrologFlag(SOURCE_FLAG)) {
2011-08-25 03:19:27 +01:00
return TRUE;
}
return FALSE;
}
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void add_first_static(PredEntry *p, yamop *cp, int spy_flag) {
CACHE_REGS
yamop *pt = cp;
#ifdef TABLING
2016-01-03 01:27:36 +00:00
if (is_tabled(p)) {
p->OpcodeOfPred = INDEX_OPCODE;
p->cs.p_code.TrueCodeOfPred = p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#endif /* TABLING */
p->cs.p_code.TrueCodeOfPred = pt;
p->cs.p_code.FirstClause = p->cs.p_code.LastClause = cp;
p->OpcodeOfPred = pt->opc;
#if defined(YAPOR) || defined(THREADS)
if (p->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & ThreadLocalPredFlag) && p->ModuleOfPred != IDB_MODULE) {
p->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
} else
#endif
p->CodeOfPred = pt;
p->cs.p_code.NOfClauses = 1;
2016-01-03 01:27:36 +00:00
if (trueGlobalPrologFlag(PROFILING_FLAG)) {
p->PredFlags |= ProfiledPredFlag;
if (!Yap_initProfiler(p)) {
2016-05-13 11:41:19 +01:00
return;
}
spy_flag = TRUE;
} else {
p->PredFlags &= ~ProfiledPredFlag;
}
if (CALL_COUNTING) {
p->PredFlags |= CountPredFlag;
spy_flag = TRUE;
} else {
p->PredFlags &= ~CountPredFlag;
}
if (spy_flag) {
p->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
2011-08-25 03:19:27 +01:00
if (source_pred(p, cp)) {
p->PredFlags |= SourcePredFlag;
}
2015-10-22 00:53:26 +01:00
if (!(p->PredFlags & MultiFileFlag) && p->src.OwnerFile == AtomNil)
p->src.OwnerFile = Yap_ConsultingFile(PASS_REGS1);
}
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void add_first_dynamic(PredEntry *p, yamop *cp, int spy_flag) {
yamop *ncp = ((DynamicClause *)NULL)->ClCode;
DynamicClause *cl;
2016-01-03 01:27:36 +00:00
if (trueGlobalPrologFlag(PROFILING_FLAG)) {
p->PredFlags |= ProfiledPredFlag;
2016-05-13 11:41:19 +01:00
if (!Yap_initProfiler(p)) {
return;
}
2016-01-03 01:27:36 +00:00
spy_flag = true;
} else {
p->PredFlags &= ~ProfiledPredFlag;
}
if (CALL_COUNTING) {
p->PredFlags |= CountPredFlag;
2016-01-03 01:27:36 +00:00
spy_flag = true;
} else {
p->PredFlags &= ~CountPredFlag;
}
#ifdef YAPOR
p->PredFlags |= SequentialPredFlag;
#endif /* YAPOR */
2015-10-22 00:53:26 +01:00
/* allocate starter block, containing info needed to start execution,
* that is a try_mark to start the code and a fail to finish things up */
cl = (DynamicClause *)Yap_AllocCodeSpace(
(Int)NEXTOP(NEXTOP(NEXTOP(ncp, Otapl), e), l));
if (cl == NIL) {
2015-10-22 00:53:26 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "Heap crashed against Stacks");
return;
}
2015-10-22 00:53:26 +01:00
Yap_ClauseSpace += (Int)NEXTOP(NEXTOP(NEXTOP(ncp, Otapl), e), l);
/* skip the first entry, this contains the back link and will always be
empty for this entry */
2015-10-22 00:53:26 +01:00
ncp = (yamop *)(((CELL *)ncp) + 1);
/* next we have the flags. For this block mainly say whether we are
* being spied */
cl->ClFlags = DynamicMask;
ncp = cl->ClCode;
INIT_LOCK(cl->ClLock);
INIT_CLREF_COUNT(cl);
/* next, set the first instruction to execute in the dyamic
* predicate */
if (spy_flag)
p->OpcodeOfPred = ncp->opc = Yap_opcode(_spy_or_trymark);
else
p->OpcodeOfPred = ncp->opc = Yap_opcode(_try_and_mark);
2014-05-30 01:06:09 +01:00
ncp->y_u.Otapl.s = p->ArityOfPE;
ncp->y_u.Otapl.p = p;
ncp->y_u.Otapl.d = cp;
/* This is the point we enter the code */
p->cs.p_code.TrueCodeOfPred = p->CodeOfPred = ncp;
p->cs.p_code.NOfClauses = 1;
#if defined(YAPOR) || defined(THREADS)
if (p->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & ThreadLocalPredFlag) && p->ModuleOfPred != IDB_MODULE) {
p->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#endif
/* set the first clause to have a retry and mark which will
* backtrack to the previous block */
if (p->PredFlags & ProfiledPredFlag)
cp->opc = Yap_opcode(_profiled_retry_and_mark);
else if (p->PredFlags & CountPredFlag)
cp->opc = Yap_opcode(_count_retry_and_mark);
else
cp->opc = Yap_opcode(_retry_and_mark);
2014-05-30 01:06:09 +01:00
cp->y_u.Otapl.s = p->ArityOfPE;
cp->y_u.Otapl.p = p;
cp->y_u.Otapl.d = ncp;
/* also, keep a backpointer for the days you delete the clause */
ClauseCodeToDynamicClause(cp)->ClPrevious = ncp;
/* Don't forget to say who is the only clause for the predicate so
far */
p->cs.p_code.LastClause = p->cs.p_code.FirstClause = cp;
/* we're only missing what to do when we actually exit the procedure
*/
2015-10-22 00:53:26 +01:00
ncp = NEXTOP(ncp, Otapl);
/* and the last instruction to execute to exit the predicate, note
the retry is pointing to this pseudo clause */
ncp->opc = Yap_opcode(_trust_fail);
/* we're only missing what to do when we actually exit the procedure
*/
/* and close the code */
2015-10-22 00:53:26 +01:00
ncp = NEXTOP(ncp, e);
ncp->opc = Yap_opcode(_Ystop);
2014-05-30 01:06:09 +01:00
ncp->y_u.l.l = cl->ClCode;
2016-01-03 01:27:36 +00:00
// if (!(p->PredFlags & MultiFileFlag) && p->src.OwnerFile == AtomNil)
// p->src.OwnerFile = Yap_ConsultingFile(PASS_REGS1);
}
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void asserta_stat_clause(PredEntry *p, yamop *q, int spy_flag) {
StaticClause *cl = ClauseCodeToStaticClause(q);
p->cs.p_code.NOfClauses++;
if (is_logupd(p)) {
2015-10-22 00:53:26 +01:00
LogUpdClause *clp = ClauseCodeToLogUpdClause(p->cs.p_code.FirstClause),
*clq = ClauseCodeToLogUpdClause(q);
clq->ClPrev = NULL;
clq->ClNext = clp;
clp->ClPrev = clq;
p->cs.p_code.FirstClause = q;
2015-10-22 00:53:26 +01:00
if (p->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
p->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
} else if (!(p->PredFlags & IndexedPredFlag)) {
p->OpcodeOfPred = INDEX_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#if defined(YAPOR) || defined(THREADS)
2011-03-15 09:08:09 +00:00
if (p->ModuleOfPred != IDB_MODULE &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & ThreadLocalPredFlag)) {
p->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#endif
return;
}
cl->ClNext = ClauseCodeToStaticClause(p->cs.p_code.FirstClause);
p->cs.p_code.FirstClause = q;
p->cs.p_code.TrueCodeOfPred = q;
2015-10-22 00:53:26 +01:00
if (p->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
p->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
} else if (!(p->PredFlags & IndexedPredFlag)) {
p->OpcodeOfPred = INDEX_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
}
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void asserta_dynam_clause(PredEntry *p, yamop *cp) {
yamop *q;
DynamicClause *cl = ClauseCodeToDynamicClause(cp);
q = cp;
LOCK(ClauseCodeToDynamicClause(p->cs.p_code.FirstClause)->ClLock);
/* also, keep backpointers for the days we'll delete all the clause */
ClauseCodeToDynamicClause(p->cs.p_code.FirstClause)->ClPrevious = q;
cl->ClPrevious = (yamop *)(p->CodeOfPred);
cl->ClFlags |= DynamicMask;
UNLOCK(ClauseCodeToDynamicClause(p->cs.p_code.FirstClause)->ClLock);
2014-05-30 01:06:09 +01:00
q->y_u.Otapl.d = p->cs.p_code.FirstClause;
q->y_u.Otapl.s = p->ArityOfPE;
q->y_u.Otapl.p = p;
if (p->PredFlags & ProfiledPredFlag)
cp->opc = Yap_opcode(_profiled_retry_and_mark);
else if (p->PredFlags & CountPredFlag)
cp->opc = Yap_opcode(_count_retry_and_mark);
else
cp->opc = Yap_opcode(_retry_and_mark);
2014-05-30 01:06:09 +01:00
cp->y_u.Otapl.s = p->ArityOfPE;
cp->y_u.Otapl.p = p;
p->cs.p_code.FirstClause = cp;
q = p->CodeOfPred;
2014-05-30 01:06:09 +01:00
q->y_u.Otapl.d = cp;
q->y_u.Otapl.s = p->ArityOfPE;
q->y_u.Otapl.p = p;
}
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void assertz_stat_clause(PredEntry *p, yamop *cp, int spy_flag) {
yamop *pt;
p->cs.p_code.NOfClauses++;
pt = p->cs.p_code.LastClause;
if (is_logupd(p)) {
2015-10-22 00:53:26 +01:00
LogUpdClause *clp = ClauseCodeToLogUpdClause(cp),
*clq = ClauseCodeToLogUpdClause(pt);
clq->ClNext = clp;
clp->ClPrev = clq;
clp->ClNext = NULL;
p->cs.p_code.LastClause = cp;
if (!(p->PredFlags & IndexedPredFlag)) {
p->OpcodeOfPred = INDEX_OPCODE;
2015-10-22 00:53:26 +01:00
p->cs.p_code.TrueCodeOfPred = p->CodeOfPred =
(yamop *)(&(p->OpcodeOfPred));
}
#if defined(YAPOR) || defined(THREADS)
2011-03-15 09:08:09 +00:00
if (p->ModuleOfPred != IDB_MODULE &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & ThreadLocalPredFlag)) {
p->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#endif
2015-10-22 00:53:26 +01:00
if (p->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
p->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
return;
} else {
2015-10-22 00:53:26 +01:00
StaticClause *cl = ClauseCodeToStaticClause(pt);
cl->ClNext = ClauseCodeToStaticClause(cp);
}
if (p->cs.p_code.FirstClause == p->cs.p_code.LastClause) {
2015-10-22 00:53:26 +01:00
if (!(p->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag))) {
p->OpcodeOfPred = INDEX_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
}
p->cs.p_code.LastClause = cp;
}
/* p is already locked */
2015-10-22 00:53:26 +01:00
static void assertz_dynam_clause(PredEntry *p, yamop *cp) {
yamop *q;
DynamicClause *cl = ClauseCodeToDynamicClause(cp);
q = p->cs.p_code.LastClause;
LOCK(ClauseCodeToDynamicClause(q)->ClLock);
2014-05-30 01:06:09 +01:00
q->y_u.Otapl.d = cp;
p->cs.p_code.LastClause = cp;
/* also, keep backpointers for the days we'll delete all the clause */
cl->ClPrevious = q;
cl->ClFlags |= DynamicMask;
UNLOCK(ClauseCodeToDynamicClause(q)->ClLock);
q = (yamop *)cp;
if (p->PredFlags & ProfiledPredFlag)
q->opc = Yap_opcode(_profiled_retry_and_mark);
else if (p->PredFlags & CountPredFlag)
q->opc = Yap_opcode(_count_retry_and_mark);
else
q->opc = Yap_opcode(_retry_and_mark);
2014-05-30 01:06:09 +01:00
q->y_u.Otapl.d = p->CodeOfPred;
q->y_u.Otapl.s = p->ArityOfPE;
q->y_u.Otapl.p = p;
p->cs.p_code.NOfClauses++;
}
2015-10-22 00:53:26 +01:00
void Yap_AssertzClause(PredEntry *p, yamop *cp) {
2011-08-24 04:11:54 +01:00
if (p->PredFlags & DynamicPredFlag) {
if (p->cs.p_code.FirstClause == NULL) {
add_first_dynamic(p, cp, FALSE);
} else {
assertz_dynam_clause(p, cp);
}
} else {
if (p->cs.p_code.FirstClause == NULL) {
add_first_static(p, cp, FALSE);
} else {
assertz_stat_clause(p, cp, FALSE);
}
}
}
2015-10-22 00:53:26 +01:00
static void expand_consult(void) {
CACHE_REGS
consult_obj *new_cl, *new_cs;
2011-05-04 10:11:41 +01:00
UInt OldConsultCapacity = LOCAL_ConsultCapacity;
/* now double consult capacity */
2011-05-04 10:11:41 +01:00
LOCAL_ConsultCapacity += InitialConsultCapacity;
/* I assume it always works ;-) */
2015-10-22 00:53:26 +01:00
while ((new_cl = (consult_obj *)Yap_AllocCodeSpace(
sizeof(consult_obj) * LOCAL_ConsultCapacity)) == NULL) {
if (!Yap_growheap(FALSE, sizeof(consult_obj) * LOCAL_ConsultCapacity,
NULL)) {
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
return;
}
}
new_cs = new_cl + InitialConsultCapacity;
/* start copying */
2015-10-22 00:53:26 +01:00
memcpy((void *)new_cs, (void *)LOCAL_ConsultLow,
OldConsultCapacity * sizeof(consult_obj));
/* copying done, release old space */
2011-05-04 10:11:41 +01:00
Yap_FreeCodeSpace((char *)LOCAL_ConsultLow);
/* next, set up pointers correctly */
2015-10-22 00:53:26 +01:00
new_cs += (LOCAL_ConsultSp - LOCAL_ConsultLow);
2011-05-04 10:11:41 +01:00
/* put LOCAL_ConsultBase at same offset as before move */
LOCAL_ConsultBase = new_cl + ((LOCAL_ConsultBase - LOCAL_ConsultLow) +
InitialConsultCapacity);
/* new consult pointer */
LOCAL_ConsultSp =
new_cl + ((LOCAL_ConsultSp - LOCAL_ConsultLow) + InitialConsultCapacity);
/* new end of memory */
2011-05-04 10:11:41 +01:00
LOCAL_ConsultLow = new_cl;
}
2015-10-22 00:53:26 +01:00
static int not_was_reconsulted(PredEntry *p, Term t, int mode) {
CACHE_REGS
2015-10-22 00:53:26 +01:00
register consult_obj *fp;
Prop p0 = AbsProp((PropEntry *)p);
2011-05-04 10:11:41 +01:00
if (p == LOCAL_LastAssertedPred)
return FALSE;
2011-05-04 10:11:41 +01:00
if (!LOCAL_ConsultSp) {
InitConsultStack();
}
if (p->cs.p_code.NOfClauses) {
2011-05-04 10:11:41 +01:00
for (fp = LOCAL_ConsultSp; fp < LOCAL_ConsultBase; ++fp)
if (fp->p == p0)
2015-10-22 00:53:26 +01:00
break;
} else {
2011-05-04 10:11:41 +01:00
fp = LOCAL_ConsultBase;
}
if (fp != LOCAL_ConsultBase) {
2015-10-22 00:53:26 +01:00
LOCAL_LastAssertedPred = p;
return false; /* careful */
} else if (mode) { // consulting again a predicate in the original file.
2015-04-13 13:28:17 +01:00
if ((p->cs.p_code.NOfClauses &&
2015-10-22 00:53:26 +01:00
p->src.OwnerFile == Yap_ConsultingFile(PASS_REGS1) &&
p->src.OwnerFile != AtomNil && !(p->PredFlags & MultiFileFlag) &&
p->src.OwnerFile != AtomUserIn)) {
// if (p->ArityOfPE)
// printf("+ %s %s
//%d\n",NameOfFunctor(p->FunctorOfPred)->StrOfAE,p->src.OwnerFile->StrOfAE,
2016-01-03 01:27:36 +00:00
// p->cs.p_code.NOfClauses);
2015-10-22 00:53:26 +01:00
retract_all(p, Yap_static_in_use(p, TRUE));
}
// printf("- %s
//%s\n",NameOfFunctor(p->FunctorOfPred)->StrOfAE,p->src.OwnerFile->StrOfAE);
}
if (mode) {
if (LOCAL_ConsultSp <= LOCAL_ConsultLow + 6) {
expand_consult();
}
2011-05-04 10:11:41 +01:00
--LOCAL_ConsultSp;
LOCAL_ConsultSp->p = p0;
if (LOCAL_ConsultBase != LOCAL_ConsultLow + LOCAL_ConsultCapacity &&
LOCAL_ConsultBase[1].mode &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & MultiFileFlag)) /* we are in reconsult mode */ {
retract_all(p, Yap_static_in_use(p, TRUE));
}
2016-01-03 01:27:36 +00:00
// p->src.OwnerFile = Yap_ConsultingFile(PASS_REGS1);
}
LOCAL_LastAssertedPred = p;
2015-10-22 00:53:26 +01:00
return TRUE; /* careful */
}
2015-10-22 00:53:26 +01:00
static void addcl_permission_error(AtomEntry *ap, Int Arity, int in_use) {
CACHE_REGS
LOCAL_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE;
2016-11-08 07:37:36 +00:00
LOCAL_ErrorMessage = Malloc( 256 );
if (in_use) {
if (Arity == 0)
sprintf(LOCAL_ErrorMessage, "static predicate %s is in use", ap->StrOfAE);
else
sprintf(LOCAL_ErrorMessage,
2015-10-22 00:53:26 +01:00
"static predicate %s/" Int_FORMAT " is in use", ap->StrOfAE,
Arity);
} else {
if (Arity == 0)
sprintf(LOCAL_ErrorMessage, "system predicate %s", ap->StrOfAE);
else
2015-10-22 00:53:26 +01:00
sprintf(LOCAL_ErrorMessage, "system predicate %s/" Int_FORMAT,
ap->StrOfAE, Arity);
}
}
2015-10-22 00:53:26 +01:00
PredEntry *Yap_PredFromClause(Term t USES_REGS) {
Term cmod = LOCAL_SourceModule;
arity_t extra_arity = 0;
2015-10-22 00:53:26 +01:00
if (IsVarTerm(t))
return NULL;
while (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t);
if (f == FunctorModule) {
// module
2015-10-22 00:53:26 +01:00
cmod = ArgOfTerm(1, t);
if (!IsAtomTerm(cmod))
2015-10-22 00:53:26 +01:00
return NULL;
t = ArgOfTerm(2, t);
} else if (f == FunctorAssert) {
t = ArgOfTerm(1, t);
2015-10-22 00:53:26 +01:00
} else if (f == FunctorComma && extra_arity == 2) {
t = ArgOfTerm(1, t);
2015-10-22 00:53:26 +01:00
} else if (f == FunctorDoubleArrow) {
extra_arity = 2;
t = ArgOfTerm(1, t);
2015-10-22 00:53:26 +01:00
} else if (f == FunctorQuery || f == FunctorAssert1) {
// directives
return NULL;
} else {
if (extra_arity) {
2015-10-22 00:53:26 +01:00
f = Yap_MkFunctor(NameOfFunctor(f), ArityOfFunctor(f) + 2);
}
return RepPredProp(Yap_GetPredPropByFunc(f, cmod));
}
}
2015-10-22 00:53:26 +01:00
if (IsAtomTerm(t)) {
if (extra_arity) {
Functor f = Yap_MkFunctor(AtomOfTerm(t), 2);
return RepPredProp(Yap_GetPredPropByFunc(f, cmod));
}
2015-10-22 00:53:26 +01:00
return RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t), cmod));
}
// ints, lists
return NULL;
}
2016-01-03 01:27:36 +00:00
bool Yap_discontiguous(PredEntry *ap, Term mode USES_REGS) {
2015-10-22 00:53:26 +01:00
register consult_obj *fp;
2016-05-12 11:48:39 +01:00
if (ap->PredFlags & (DiscontiguousPredFlag | MultiFileFlag) ||
falseGlobalPrologFlag(DISCONTIGUOUS_WARNINGS_FLAG))
2016-01-03 01:27:36 +00:00
return false;
2016-05-12 11:48:39 +01:00
if ((mode != TermConsult && mode != TermReconsult))
return false;
if (!LOCAL_ConsultSp) {
return false;
}
if (ap == LOCAL_LastAssertedPred)
2016-05-16 09:35:29 +01:00
return false;
if (ap->cs.p_code.NOfClauses) {
2016-05-16 09:35:29 +01:00
Term repeat = AbsPair((CELL *)AbsPredProp(ap));
for (fp = LOCAL_ConsultSp; fp < LOCAL_ConsultBase; ++fp)
2016-05-16 09:35:29 +01:00
if (fp->p == AbsPredProp(ap)) {
// detect repeated warnings
if (LOCAL_ConsultSp == LOCAL_ConsultLow + 1) {
expand_consult();
}
--LOCAL_ConsultSp;
LOCAL_ConsultSp->r = repeat;
2015-10-22 00:53:26 +01:00
return true;
} else if (fp->r == repeat && ap->cs.p_code.NOfClauses > 4) {
return false;
2016-05-16 09:35:29 +01:00
}
}
return false;
}
2016-01-03 01:27:36 +00:00
static Int p_is_discontiguous(USES_REGS1) { /* '$is_multifile'(+S,+Mod) */
PredEntry *pe;
Int out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "discontiguous");
2016-01-03 01:27:36 +00:00
if (EndOfPAEntr(pe))
return FALSE;
PELOCK(27, pe);
out = (pe->PredFlags & DiscontiguousPredFlag);
UNLOCKPE(44, pe);
return (out);
}
static Int
p_new_discontiguous(USES_REGS1) { /* '$new_discontiguous'(+N,+Ar,+Mod) */
Atom at;
int arity;
PredEntry *pe;
Term t = Deref(ARG1);
Term mod = Deref(ARG3);
if (IsVarTerm(t))
2016-05-12 11:48:39 +01:00
return false;
2016-01-03 01:27:36 +00:00
if (IsAtomTerm(t))
at = AtomOfTerm(t);
else
2016-05-12 11:48:39 +01:00
return false;
2016-01-03 01:27:36 +00:00
t = Deref(ARG2);
if (IsVarTerm(t))
2016-05-12 11:48:39 +01:00
return false;
2016-01-03 01:27:36 +00:00
if (IsIntTerm(t))
arity = IntOfTerm(t);
else
2016-05-12 11:48:39 +01:00
return false;
2016-01-03 01:27:36 +00:00
if (arity == 0)
pe = RepPredProp(PredPropByAtom(at, mod));
else
pe = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, arity), mod));
PELOCK(26, pe);
pe->PredFlags |= DiscontiguousPredFlag;
/* mutifile-predicates are weird, they do not seat really on the default
* module */
if (pe->cs.p_code.NOfClauses == 0) {
pe->CodeOfPred = pe->cs.p_code.TrueCodeOfPred = FAILCODE;
pe->OpcodeOfPred = FAIL_OPCODE;
}
2016-01-03 01:27:36 +00:00
UNLOCKPE(43, pe);
return (TRUE);
}
bool Yap_multiple(PredEntry *ap, Term mode USES_REGS) {
2015-10-22 00:53:26 +01:00
register consult_obj *fp;
2015-10-22 00:53:26 +01:00
if ((ap->PredFlags & (MultiFileFlag | LogUpdatePredFlag | DynamicPredFlag)) ||
2016-01-03 01:27:36 +00:00
mode != TermReconsult)
2015-09-21 23:05:36 +01:00
return false;
if (LOCAL_consult_level == 0)
return false;
for (fp = LOCAL_ConsultSp; fp < LOCAL_ConsultBase; ++fp)
if (fp->p == AbsPredProp(ap)) {
return false;
}
2015-10-22 00:53:26 +01:00
return ap->cs.p_code.NOfClauses > 0 && ap->src.OwnerFile != AtomNil &&
Yap_ConsultingFile(PASS_REGS1) != ap->src.OwnerFile &&
LOCAL_Including != MkAtomTerm(ap->src.OwnerFile);
}
2015-10-22 00:53:26 +01:00
static int is_fact(Term t) {
Term a1;
if (IsAtomTerm(t))
return TRUE;
if (FunctorOfTerm(t) != FunctorAssert)
return TRUE;
a1 = ArgOfTerm(2, t);
if (a1 == MkAtomTerm(AtomTrue))
return TRUE;
return FALSE;
}
2015-10-22 00:53:26 +01:00
Int Yap_source_line_no(void) {
CACHE_REGS
2015-06-19 01:30:13 +01:00
return LOCAL_SourceFileLineno;
}
2015-10-22 00:53:26 +01:00
Atom Yap_source_file_name(void) {
CACHE_REGS
if (LOCAL_SourceFileName)
return LOCAL_SourceFileName;
return AtomNil;
2015-06-19 01:30:13 +01:00
}
2016-01-03 01:27:36 +00:00
/**
* @brief we cannot add clauses to the proceduree
2016-01-03 01:27:36 +00:00
*
* @param p predicate
*
* @return boolean
*/
2016-01-03 01:27:36 +00:00
bool Yap_constPred(PredEntry *p) {
pred_flags_t pflags;
pflags = p->PredFlags;
2017-05-19 09:56:37 +01:00
if (pflags &
((UserCPredFlag | CArgsPredFlag | NumberDBPredFlag | AtomDBPredFlag |
TestPredFlag | AsmPredFlag | CPredFlag | BinaryPredFlag)))
return true;
if (p->PredFlags &
(SysExportPredFlag | MultiFileFlag | DynamicPredFlag | LogUpdatePredFlag))
return false;
2016-01-03 01:27:36 +00:00
if (Yap_isSystemModule(p->ModuleOfPred)) {
if (p->cs.p_code.NOfClauses == 0) {
2016-01-03 01:27:36 +00:00
p->src.OwnerFile = Yap_source_file_name();
return false;
}
2016-01-03 01:27:36 +00:00
if (p->src.OwnerFile == Yap_source_file_name()) {
return false;
}
}
2017-05-19 09:56:37 +01:00
return false;
}
bool Yap_addclause(Term t, yamop *cp, Term tmode, Term mod, Term *t4ref)
/*
*
mode
0 assertz
1 consult
2 asserta
*/
{
CACHE_REGS
2015-10-22 00:53:26 +01:00
PredEntry *p;
int spy_flag = FALSE;
Atom at;
arity_t Arity;
pred_flags_t pflags;
Term tf;
int mode;
if (tmode == TermConsult) {
mode = consult;
} else if (tmode == TermReconsult) {
mode = consult;
} else if (tmode == TermAsserta) {
mode = asserta;
} else if (tmode == TermAssertz) {
mode = assertz;
} else if (tmode == TermAssertaStatic) {
mode = asserta;
} else if (tmode == TermAssertzStatic) {
mode = assertz;
2016-08-01 23:48:43 +01:00
} else {
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, tmode,
2016-08-02 01:14:51 +01:00
"compilation mode used to assert");
return false;
}
if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorAssert)
tf = ArgOfTerm(1, t);
else
tf = t;
tf = Yap_YapStripModule(tf, &mod);
2016-05-12 11:48:39 +01:00
if (IsAtomTerm(tf)) {
at = AtomOfTerm(tf);
p = RepPredProp(PredPropByAtom(at, mod));
Arity = 0;
} else {
Functor f = FunctorOfTerm(tf);
Arity = ArityOfFunctor(f);
at = NameOfFunctor(f);
p = RepPredProp(PredPropByFunc(f, mod));
}
2015-10-22 00:53:26 +01:00
PELOCK(20, p);
/* we are redefining a prolog module predicate */
if (Yap_constPred(p)) {
addcl_permission_error(RepAtom(at), Arity, FALSE);
2015-10-22 00:53:26 +01:00
UNLOCKPE(30, p);
2016-01-03 01:27:36 +00:00
return false;
}
2017-05-19 09:56:37 +01:00
Yap_PutValue(AtomAbol, TermNil);
pflags = p->PredFlags;
/* we are redefining a prolog module predicate */
if (pflags & MegaClausePredFlag) {
split_megaclause(p);
}
/* The only problem we have now is when we need to throw away
Indexing blocks
*/
if (pflags & IndexedPredFlag) {
Yap_AddClauseToIndex(p, cp, mode == asserta);
}
2015-10-22 00:53:26 +01:00
if (pflags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag))
2016-01-03 01:27:36 +00:00
spy_flag = true;
if (Yap_discontiguous(p, tmode PASS_REGS)) {
2015-09-21 23:05:36 +01:00
Term disc[3], sc[4];
if (p->ArityOfPE) {
disc[0] = MkAtomTerm(NameOfFunctor(p->FunctorOfPred));
} else {
disc[0] = MkAtomTerm((Atom)(p->FunctorOfPred));
2015-09-21 23:05:36 +01:00
}
disc[1] = MkIntTerm(p->ArityOfPE);
disc[2] = Yap_Module_Name(p);
sc[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomDiscontiguous, 3), 3, disc);
2015-10-22 00:53:26 +01:00
sc[1] = MkIntegerTerm(Yap_source_line_no());
sc[2] = MkAtomTerm(LOCAL_SourceFileName);
2015-09-21 23:05:36 +01:00
sc[3] = t;
t = Yap_MkApplTerm(Yap_MkFunctor(AtomStyleCheck, 4), 4, sc);
2016-01-03 01:27:36 +00:00
sc[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomStyleCheck, 1), 1, &t);
sc[1] = MkAtomTerm(AtomWarning);
Yap_PrintWarning(Yap_MkApplTerm(Yap_MkFunctor(AtomError, 2), 2, sc));
} else if (Yap_multiple(p, tmode PASS_REGS)) {
2016-01-03 01:27:36 +00:00
Term disc[4], sc[4];
2015-09-21 23:05:36 +01:00
if (p->ArityOfPE) {
disc[0] = MkAtomTerm(NameOfFunctor(p->FunctorOfPred));
} else {
disc[0] = MkAtomTerm((Atom)(p->FunctorOfPred));
2015-09-21 23:05:36 +01:00
}
disc[1] = MkIntTerm(p->ArityOfPE);
disc[2] = Yap_Module_Name(p);
disc[3] = MkAtomTerm(p->src.OwnerFile);
sc[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomMultiple, 4), 4, disc);
2015-10-22 00:53:26 +01:00
sc[1] = MkIntegerTerm(Yap_source_line_no());
sc[2] = MkAtomTerm(LOCAL_SourceFileName);
2015-09-21 23:05:36 +01:00
sc[3] = t;
t = Yap_MkApplTerm(Yap_MkFunctor(AtomStyleCheck, 4), 4, sc);
2016-01-03 01:27:36 +00:00
sc[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomStyleCheck, 1), 1, &t);
sc[1] = MkAtomTerm(AtomWarning);
Yap_PrintWarning(Yap_MkApplTerm(Yap_MkFunctor(AtomError, 2), 2, sc));
}
2015-04-13 13:28:17 +01:00
if (mode == consult)
2016-01-03 01:27:36 +00:00
not_was_reconsulted(p, t, true);
/* always check if we have a valid error first */
2015-10-22 00:53:26 +01:00
if (LOCAL_ErrorMessage &&
LOCAL_Error_TYPE == PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE) {
UNLOCKPE(31, p);
2016-01-03 01:27:36 +00:00
return false;
}
if (pflags & UDIPredFlag) {
Yap_new_udi_clause(p, cp, t);
}
if (!is_dynamic(p)) {
if (pflags & LogUpdatePredFlag) {
2015-10-22 00:53:26 +01:00
LogUpdClause *clp = ClauseCodeToLogUpdClause(cp);
clp->ClFlags |= LogUpdMask;
if (is_fact(t)) {
2015-10-22 00:53:26 +01:00
clp->ClFlags |= FactMask;
clp->lusl.ClLine = Yap_source_line_no();
}
} else {
2015-10-22 00:53:26 +01:00
StaticClause *clp = ClauseCodeToStaticClause(cp);
clp->ClFlags |= StaticMask;
if (is_fact(t) && !(p->PredFlags & TabledPredFlag)) {
2015-10-22 00:53:26 +01:00
clp->ClFlags |= FactMask;
clp->usc.ClLine = Yap_source_line_no();
}
}
if (compile_mode)
p->PredFlags = p->PredFlags | CompiledPredFlag;
else
p->PredFlags = p->PredFlags | CompiledPredFlag;
}
if (p->cs.p_code.FirstClause == NULL) {
if (!(pflags & DynamicPredFlag)) {
add_first_static(p, cp, spy_flag);
/* make sure we have a place to jump to */
if (p->OpcodeOfPred == UNDEF_OPCODE ||
2015-10-22 00:53:26 +01:00
p->OpcodeOfPred == FAIL_OPCODE) { /* log updates */
p->CodeOfPred = p->cs.p_code.TrueCodeOfPred;
p->OpcodeOfPred = ((yamop *)(p->CodeOfPred))->opc;
}
#if defined(YAPOR) || defined(THREADS)
if (p->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & ThreadLocalPredFlag) &&
p->ModuleOfPred != IDB_MODULE) {
p->OpcodeOfPred = LOCKPRED_OPCODE;
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#endif
} else {
add_first_dynamic(p, cp, spy_flag);
}
} else if (mode == asserta) {
if (pflags & DynamicPredFlag)
asserta_dynam_clause(p, cp);
else
asserta_stat_clause(p, cp, spy_flag);
} else if (pflags & DynamicPredFlag)
assertz_dynam_clause(p, cp);
else {
assertz_stat_clause(p, cp, spy_flag);
if (p->OpcodeOfPred != INDEX_OPCODE &&
2015-10-22 00:53:26 +01:00
p->OpcodeOfPred != Yap_opcode(_spy_pred)) {
p->CodeOfPred = p->cs.p_code.TrueCodeOfPred;
p->OpcodeOfPred = ((yamop *)(p->CodeOfPred))->opc;
}
#if defined(YAPOR) || defined(THREADS)
if (p->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(p->PredFlags & ThreadLocalPredFlag) &&
p->ModuleOfPred != IDB_MODULE) {
p->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
p->CodeOfPred = (yamop *)(&(p->OpcodeOfPred));
}
#endif
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(32, p);
if (pflags & LogUpdatePredFlag) {
LogUpdClause *cl = (LogUpdClause *)ClauseCodeToLogUpdClause(cp);
tf = MkDBRefTerm((DBRef)cl);
#if MULTIPLE_STACKS
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
INC_CLREF_COUNT(cl);
#else
if (!(cl->ClFlags & InUseMask)) {
cl->ClFlags |= InUseMask;
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
}
#endif
} else {
tf = Yap_MkStaticRefTerm(ClauseCodeToStaticClause(cp), p);
}
2016-08-01 23:48:43 +01:00
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "add %s/%ld %p",
RepAtom(at)->StrOfAE, Arity);
2016-01-03 01:27:36 +00:00
if (mod == PROLOG_MODULE)
mod = TermProlog;
if (pflags & MultiFileFlag) {
/* add Info on new clause for multifile predicates to the DB */
Term t[5], tn;
2015-10-22 00:53:26 +01:00
t[0] = MkAtomTerm(Yap_ConsultingFile(PASS_REGS1));
t[1] = MkAtomTerm(at);
t[2] = MkIntegerTerm(Arity);
t[3] = mod;
t[4] = tf;
2015-10-22 00:53:26 +01:00
tn = Yap_MkApplTerm(FunctorMultiFileClause, 5, t);
Yap_Recordz(AtomMultiFile, tn);
}
2016-05-12 11:48:39 +01:00
if (t4ref && *t4ref != TermNil) {
if (!Yap_unify(*t4ref, tf)) {
return false;
}
}
2016-01-03 01:27:36 +00:00
return true;
}
2015-10-22 00:53:26 +01:00
void Yap_EraseMegaClause(yamop *cl, PredEntry *ap) {
/* just make it fail */
cl->opc = Yap_opcode(_op_fail);
}
2015-10-22 00:53:26 +01:00
void Yap_EraseStaticClause(StaticClause *cl, PredEntry *ap, Term mod) {
/* ok, first I need to find out the parent predicate */
if (ap->PredFlags & MegaClausePredFlag) {
split_megaclause(ap);
}
if (ap->PredFlags & IndexedPredFlag)
RemoveIndexation(ap);
ap->cs.p_code.NOfClauses--;
if (ap->cs.p_code.FirstClause == cl->ClCode) {
/* got rid of first clause */
if (ap->cs.p_code.LastClause == cl->ClCode) {
/* got rid of all clauses */
ap->cs.p_code.LastClause = ap->cs.p_code.FirstClause = NULL;
ap->OpcodeOfPred = UNDEF_OPCODE;
2015-10-22 00:53:26 +01:00
ap->cs.p_code.TrueCodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
} else {
yamop *ncl = cl->ClNext->ClCode;
ap->cs.p_code.FirstClause = ncl;
2015-10-22 00:53:26 +01:00
ap->cs.p_code.TrueCodeOfPred = ncl;
ap->OpcodeOfPred = ncl->opc;
}
} else {
StaticClause *pcl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause),
2015-10-22 00:53:26 +01:00
*ocl = NULL;
while (pcl != cl) {
ocl = pcl;
pcl = pcl->ClNext;
}
if (ocl) {
ocl->ClNext = cl->ClNext;
}
2015-10-22 00:53:26 +01:00
if (cl->ClCode == ap->cs.p_code.LastClause) {
ap->cs.p_code.LastClause = ocl->ClCode;
}
}
if (ap->cs.p_code.NOfClauses == 1) {
2016-01-03 01:27:36 +00:00
assert(ap->cs.p_code.FirstClause);
2015-10-22 00:53:26 +01:00
ap->cs.p_code.TrueCodeOfPred = ap->cs.p_code.FirstClause;
ap->OpcodeOfPred = ap->cs.p_code.TrueCodeOfPred->opc;
}
2015-10-22 00:53:26 +01:00
if (cl->ClFlags & HasBlobsMask || Yap_static_in_use(ap, TRUE)) {
LOCK(DeadStaticClausesLock);
cl->ClNext = DeadStaticClauses;
DeadStaticClauses = cl;
UNLOCK(DeadStaticClausesLock);
} else {
2012-03-09 11:46:34 +00:00
Yap_InformOfRemoval(cl);
Yap_ClauseSpace -= cl->ClSize;
Yap_FreeCodeSpace((char *)cl);
}
if (ap->cs.p_code.NOfClauses == 0) {
2015-10-22 00:53:26 +01:00
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred;
} else if (ap->cs.p_code.NOfClauses > 1) {
ap->OpcodeOfPred = INDEX_OPCODE;
2015-10-22 00:53:26 +01:00
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred =
(yamop *)(&(ap->OpcodeOfPred));
} else if (ap->PredFlags &
(SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
ap->OpcodeOfPred = Yap_opcode(_spy_pred);
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred =
(yamop *)(&(ap->OpcodeOfPred));
} else {
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred;
}
#if defined(YAPOR) || defined(THREADS)
if (ap->PredFlags & LogUpdatePredFlag &&
2011-03-15 09:08:09 +00:00
!(ap->PredFlags & ThreadLocalPredFlag) &&
ap->ModuleOfPred != IDB_MODULE) {
ap->OpcodeOfPred = LOCKPRED_OPCODE;
2015-04-13 13:28:17 +01:00
ap->CodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
}
#endif
}
2015-10-22 00:53:26 +01:00
void Yap_add_logupd_clause(PredEntry *pe, LogUpdClause *cl, int mode) {
yamop *cp = cl->ClCode;
if (pe->PredFlags & IndexedPredFlag) {
Yap_AddClauseToIndex(pe, cp, mode == asserta);
}
if (pe->cs.p_code.FirstClause == NULL) {
add_first_static(pe, cp, FALSE);
/* make sure we have a place to jump to */
if (pe->OpcodeOfPred == UNDEF_OPCODE ||
2015-10-22 00:53:26 +01:00
pe->OpcodeOfPred == FAIL_OPCODE) { /* log updates */
#if defined(YAPOR) || defined(THREADS)
if (pe->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(pe->PredFlags & ThreadLocalPredFlag) &&
pe->ModuleOfPred != IDB_MODULE) {
pe->OpcodeOfPred = LOCKPRED_OPCODE;
pe->CodeOfPred = (yamop *)(&(pe->OpcodeOfPred));
} else {
#endif
2015-10-22 00:53:26 +01:00
pe->CodeOfPred = pe->cs.p_code.TrueCodeOfPred;
pe->OpcodeOfPred = ((yamop *)(pe->CodeOfPred))->opc;
2015-04-13 13:28:17 +01:00
#if defined(YAPOR) || defined(THREADS)
}
#endif
2015-10-22 00:53:26 +01:00
}
} else if (mode == asserta) {
asserta_stat_clause(pe, cp, FALSE);
} else {
assertz_stat_clause(pe, cp, FALSE);
}
}
2016-01-03 01:27:36 +00:00
static Int p_compile(USES_REGS1) { /* '$compile'(+C,+Flags,+C0,-Ref) */
2015-10-22 00:53:26 +01:00
Term t = Deref(ARG1);
Term t1 = Deref(ARG2);
Term mod = Deref(ARG4);
yamop *code_adr;
if (IsVarTerm(t1) || !IsAtomicTerm(t1))
return false;
if (IsVarTerm(mod) || !IsAtomTerm(mod))
return false;
/* separate assert in current file from reconsult
if (mode == assertz && LOCAL_consult_level && mod == CurrentModule)
2015-04-13 13:28:17 +01:00
mode = consult;
*/
2015-10-22 00:53:26 +01:00
code_adr = Yap_cclause(t, 5, mod,
Deref(ARG3)); /* vsc: give the number of arguments to
cclause() in case there is a overflow */
t = Deref(ARG1); /* just in case there was an heap overflow */
if (!LOCAL_ErrorMessage) {
2016-01-31 10:13:51 +00:00
YAPEnterCriticalSection();
Yap_addclause(t, code_adr, t1, mod, &ARG5);
2016-01-31 10:13:51 +00:00
YAPLeaveCriticalSection();
2015-04-13 13:28:17 +01:00
}
if (LOCAL_ErrorMessage) {
2016-10-20 04:44:59 +01:00
Yap_Error(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
YAPLeaveCriticalSection();
2016-01-03 01:27:36 +00:00
return false;
}
return true;
}
2015-10-22 00:53:26 +01:00
Atom Yap_ConsultingFile(USES_REGS1) {
2015-09-29 23:08:10 +01:00
int sno;
if ((sno = Yap_CheckAlias(AtomLoopStream)) >= 0) {
// if(sno ==0)
// return(AtomUserIn);
2015-10-22 00:53:26 +01:00
return StreamFullName(sno);
2015-09-29 23:08:10 +01:00
}
if (LOCAL_SourceFileName != NULL) {
return LOCAL_SourceFileName;
}
2011-05-04 10:11:41 +01:00
if (LOCAL_consult_level == 0) {
2015-10-22 00:53:26 +01:00
return (AtomUser);
} else {
2015-10-22 00:53:26 +01:00
return (Yap_ULookupAtom(LOCAL_ConsultBase[2].filename));
}
}
/* consult file *file*, *mode* may be one of either consult or reconsult */
2015-10-22 00:53:26 +01:00
static void init_consult(int mode, const unsigned char *file) {
CACHE_REGS
2011-05-04 10:11:41 +01:00
if (!LOCAL_ConsultSp) {
InitConsultStack();
}
if (LOCAL_ConsultSp >= LOCAL_ConsultLow + 6) {
expand_consult();
2016-05-14 11:27:53 +01:00
}
2011-05-04 10:11:41 +01:00
LOCAL_ConsultSp--;
LOCAL_ConsultSp->filename = file;
LOCAL_ConsultSp--;
LOCAL_ConsultSp->mode = mode;
LOCAL_ConsultSp--;
2015-10-22 00:53:26 +01:00
LOCAL_ConsultSp->c = (LOCAL_ConsultBase - LOCAL_ConsultSp);
2011-05-04 10:11:41 +01:00
LOCAL_ConsultBase = LOCAL_ConsultSp;
2011-03-30 15:32:59 +01:00
#if !defined(YAPOR) && !defined(YAPOR_SBA)
2015-10-22 00:53:26 +01:00
/* if (LOCAL_consult_level == 0)
do_toggle_static_predicates_in_use(TRUE); */
#endif
2011-05-04 10:11:41 +01:00
LOCAL_consult_level++;
LOCAL_LastAssertedPred = NULL;
}
2015-10-22 00:53:26 +01:00
void Yap_init_consult(int mode, const char *file) {
init_consult(mode, (const unsigned char *)file);
}
2015-10-22 00:53:26 +01:00
static Int p_startconsult(USES_REGS1) { /* '$start_consult'(+Mode) */
Term t;
char *smode = RepAtom(AtomOfTerm(Deref(ARG1)))->StrOfAE;
int mode;
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
mode = strcmp("consult", (char *)smode);
2015-09-21 23:05:36 +01:00
init_consult(mode, RepAtom(AtomOfTerm(Deref(ARG2)))->UStrOfAE);
2011-05-04 10:11:41 +01:00
t = MkIntTerm(LOCAL_consult_level);
return (Yap_unify_constant(ARG3, t));
}
2015-10-22 00:53:26 +01:00
static Int p_showconslultlev(USES_REGS1) {
Term t;
2011-05-04 10:11:41 +01:00
t = MkIntTerm(LOCAL_consult_level);
return (Yap_unify_constant(ARG1, t));
}
2015-10-22 00:53:26 +01:00
static void end_consult(USES_REGS1) {
2011-05-04 10:11:41 +01:00
LOCAL_ConsultSp = LOCAL_ConsultBase;
2015-10-22 00:53:26 +01:00
LOCAL_ConsultBase = LOCAL_ConsultSp + LOCAL_ConsultSp->c;
2011-05-04 10:11:41 +01:00
LOCAL_ConsultSp += 3;
LOCAL_consult_level--;
LOCAL_LastAssertedPred = NULL;
2011-03-30 15:32:59 +01:00
#if !defined(YAPOR) && !defined(YAPOR_SBA)
2015-10-22 00:53:26 +01:00
/* if (LOCAL_consult_level == 0)
do_toggle_static_predicates_in_use(FALSE);*/
#endif
}
2015-10-22 00:53:26 +01:00
void Yap_end_consult(void) {
CACHE_REGS
2015-10-22 00:53:26 +01:00
end_consult(PASS_REGS1);
}
2015-10-22 00:53:26 +01:00
static Int p_endconsult(USES_REGS1) { /* '$end_consult' */
end_consult(PASS_REGS1);
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static void purge_clauses(PredEntry *pred) {
2012-06-21 16:47:19 +01:00
if (pred->PredFlags & UDIPredFlag) {
Yap_udi_abolish(pred);
}
if (pred->cs.p_code.NOfClauses) {
if (pred->PredFlags & IndexedPredFlag)
RemoveIndexation(pred);
Yap_PutValue(AtomAbol, MkAtomTerm(AtomTrue));
2015-10-22 00:53:26 +01:00
retract_all(pred, Yap_static_in_use(pred, TRUE));
}
}
2015-10-22 00:53:26 +01:00
void Yap_Abolish(PredEntry *pred) {
purge_clauses(pred);
pred->src.OwnerFile = AtomNil;
}
2015-10-22 00:53:26 +01:00
static Int p_purge_clauses(USES_REGS1) { /* '$purge_clauses'(+Func) */
PredEntry *pred;
Term t = Deref(ARG1);
Term mod = Deref(ARG2);
MegaClause *before = DeadMegaClauses;
2015-04-13 13:28:17 +01:00
Yap_PutValue(AtomAbol, MkAtomTerm(AtomNil));
if (IsVarTerm(t))
return FALSE;
if (IsVarTerm(mod) || !IsAtomTerm(mod)) {
return FALSE;
}
if (IsAtomTerm(t)) {
Atom at = AtomOfTerm(t);
pred = RepPredProp(PredPropByAtom(at, mod));
} else if (IsApplTerm(t)) {
2015-10-22 00:53:26 +01:00
Functor fun = FunctorOfTerm(t);
pred = RepPredProp(PredPropByFunc(fun, mod));
} else
return (FALSE);
2015-10-22 00:53:26 +01:00
PELOCK(21, pred);
if (pred->PredFlags & StandardPredFlag) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(33, pred);
Yap_Error(PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, t, "assert/1");
return (FALSE);
}
purge_clauses(pred);
2015-10-22 00:53:26 +01:00
UNLOCKPE(34, pred);
2012-04-23 23:28:41 +01:00
/* try to use the garbage collector to recover the mega clause,
in case the objs pointing to it are dead themselves */
if (DeadMegaClauses != before) {
2015-10-22 00:53:26 +01:00
if (!Yap_gc(2, ENV, gc_P(P, CP))) {
2015-09-25 10:57:26 +01:00
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
2012-04-23 23:28:41 +01:00
return FALSE;
}
}
return TRUE;
}
2015-10-22 00:53:26 +01:00
static Int p_sys_export(USES_REGS1) { /* '$set_spy'(+Fun,+M) */
PredEntry *pred;
Term t, mod;
2014-04-06 17:06:19 +01:00
t = Deref(ARG1);
mod = Deref(ARG2);
if (IsVarTerm(mod) || !IsAtomTerm(mod))
return (FALSE);
if (IsVarTerm(t))
return (FALSE);
if (IsAtomTerm(t)) {
Atom at = AtomOfTerm(t);
pred = RepPredProp(Yap_PredPropByAtomNonThreadLocal(at, mod));
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
pred = RepPredProp(Yap_PredPropByFunctorNonThreadLocal(fun, mod));
} else {
return (FALSE);
}
2015-10-22 00:53:26 +01:00
PELOCK(100, pred);
2014-11-25 12:03:48 +00:00
pred->PredFlags |= SysExportPredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(100, pred);
2014-04-06 17:06:19 +01:00
return TRUE;
}
/******************************************************************
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
MANAGING SPY-POINTS
2015-04-13 13:28:17 +01:00
******************************************************************/
2015-10-22 00:53:26 +01:00
static Int p_is_no_trace(USES_REGS1) { /* '$undefined'(P,Mod) */
PredEntry *pe;
2013-12-11 01:05:51 +00:00
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "undefined/1");
2013-12-11 01:05:51 +00:00
if (EndOfPAEntr(pe))
return true;
2015-10-22 00:53:26 +01:00
PELOCK(36, pe);
2016-01-04 17:18:43 +00:00
if (pe->PredFlags & (NoTracePredFlag | HiddenPredFlag)) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(57, pe);
return true;
2013-12-11 01:05:51 +00:00
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(59, pe);
return false;
2013-12-11 01:05:51 +00:00
}
2015-10-22 00:53:26 +01:00
static Int p_set_no_trace(USES_REGS1) { /* '$set_no_trace'(+Fun,+M) */
PredEntry *pe;
2013-12-11 01:05:51 +00:00
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "undefined/1");
2013-12-11 01:05:51 +00:00
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(36, pe);
2014-11-25 12:03:48 +00:00
pe->PredFlags |= NoTracePredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(57, pe);
2013-12-11 01:05:51 +00:00
return TRUE;
}
2015-10-22 00:53:26 +01:00
int Yap_SetNoTrace(char *name, arity_t arity, Term tmod) {
PredEntry *pe;
2013-12-11 01:05:51 +00:00
if (arity == 0) {
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(MkAtomTerm(Yap_LookupAtom(name)), tmod, "no_trace");
2013-12-11 01:05:51 +00:00
} else {
2015-10-22 00:53:26 +01:00
pe = RepPredProp(
PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(name), arity), tmod));
2013-12-11 01:05:51 +00:00
}
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(36, pe);
2014-11-25 12:03:48 +00:00
pe->PredFlags |= NoTracePredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(57, pe);
2013-12-11 01:05:51 +00:00
return TRUE;
}
2015-10-22 00:53:26 +01:00
static Int p_setspy(USES_REGS1) { /* '$set_spy'(+Fun,+M) */
Atom at;
PredEntry *pred;
pred_flags_t fg;
Term t, mod;
at = AtomSpy;
2015-10-22 00:53:26 +01:00
pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1), 0));
SpyCode = pred;
t = Deref(ARG1);
mod = Deref(ARG2);
if (IsVarTerm(mod) || !IsAtomTerm(mod))
return (FALSE);
if (IsVarTerm(t))
return (FALSE);
if (IsAtomTerm(t)) {
Atom at = AtomOfTerm(t);
pred = RepPredProp(Yap_PredPropByAtomNonThreadLocal(at, mod));
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
pred = RepPredProp(Yap_PredPropByFunctorNonThreadLocal(fun, mod));
} else {
return (FALSE);
}
2015-10-22 00:53:26 +01:00
PELOCK(22, pred);
restart_spy:
if (pred->PredFlags & (CPredFlag | SafePredFlag)) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(35, pred);
return FALSE;
}
2015-10-22 00:53:26 +01:00
if (pred->OpcodeOfPred == UNDEF_OPCODE || pred->OpcodeOfPred == FAIL_OPCODE) {
UNLOCKPE(36, pred);
return FALSE;
}
if (pred->OpcodeOfPred == INDEX_OPCODE) {
int i = 0;
for (i = 0; i < pred->ArityOfPE; i++) {
2015-10-22 00:53:26 +01:00
XREGS[i + 1] = MkVarTerm();
}
IPred(pred, 0, CP);
goto restart_spy;
}
fg = pred->PredFlags;
if (fg & DynamicPredFlag) {
2015-10-22 00:53:26 +01:00
pred->OpcodeOfPred = ((yamop *)(pred->CodeOfPred))->opc =
Yap_opcode(_spy_or_trymark);
} else {
pred->OpcodeOfPred = Yap_opcode(_spy_pred);
2015-04-13 13:28:17 +01:00
pred->CodeOfPred = (yamop *)(&(pred->OpcodeOfPred));
}
pred->PredFlags |= SpiedPredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(37, pred);
return TRUE;
}
2015-10-22 00:53:26 +01:00
static Int p_rmspy(USES_REGS1) { /* '$rm_spy'(+T,+Mod) */
Atom at;
PredEntry *pred;
Term t;
Term mod;
t = Deref(ARG1);
mod = Deref(ARG2);
if (IsVarTerm(mod) || !IsAtomTerm(mod))
return (FALSE);
if (IsVarTerm(t))
return (FALSE);
if (IsAtomTerm(t)) {
at = AtomOfTerm(t);
pred = RepPredProp(Yap_PredPropByAtomNonThreadLocal(at, mod));
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
pred = RepPredProp(Yap_PredPropByFunctorNonThreadLocal(fun, mod));
} else
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(23, pred);
if (!(pred->PredFlags & SpiedPredFlag)) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(38, pred);
return FALSE;
}
#if THREADS
2013-02-15 16:30:53 +00:00
if (pred->PredFlags & ThreadLocalPredFlag) {
pred->OpcodeOfPred = Yap_opcode(_thread_local);
pred->PredFlags ^= SpiedPredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(39, pred);
return TRUE;
2015-04-13 13:28:17 +01:00
}
#endif
2015-10-22 00:53:26 +01:00
if (!(pred->PredFlags & (CountPredFlag | ProfiledPredFlag))) {
2009-06-22 17:12:56 +01:00
if (!(pred->PredFlags & DynamicPredFlag)) {
#if defined(YAPOR) || defined(THREADS)
2009-06-22 17:12:56 +01:00
if (pred->PredFlags & LogUpdatePredFlag &&
2015-10-22 00:53:26 +01:00
!(pred->PredFlags & ThreadLocalPredFlag) &&
pred->ModuleOfPred != IDB_MODULE) {
pred->OpcodeOfPred = LOCKPRED_OPCODE;
pred->CodeOfPred = (yamop *)(&(pred->OpcodeOfPred));
2009-06-22 17:12:56 +01:00
} else {
#endif
2015-10-22 00:53:26 +01:00
pred->CodeOfPred = pred->cs.p_code.TrueCodeOfPred;
pred->OpcodeOfPred = pred->CodeOfPred->opc;
#if defined(YAPOR) || defined(THREADS)
2009-06-22 17:12:56 +01:00
}
#endif
2009-06-22 17:12:56 +01:00
} else if (pred->OpcodeOfPred == Yap_opcode(_spy_or_trymark)) {
pred->OpcodeOfPred = Yap_opcode(_try_and_mark);
} else {
2015-10-22 00:53:26 +01:00
UNLOCKPE(39, pred);
2009-06-22 17:12:56 +01:00
return FALSE;
}
}
pred->PredFlags ^= SpiedPredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(40, pred);
return (TRUE);
}
/******************************************************************
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
INFO ABOUT PREDICATES
2015-04-13 13:28:17 +01:00
******************************************************************/
2015-04-13 13:28:17 +01:00
static Int
2015-10-22 00:53:26 +01:00
p_number_of_clauses(USES_REGS1) { /* '$number_of_clauses'(Predicate,M,N) */
Term t = Deref(ARG1);
Term mod = Deref(ARG2);
int ncl = 0;
2015-10-22 00:53:26 +01:00
Prop pe;
2015-10-22 00:53:26 +01:00
if (IsVarTerm(mod) || !IsAtomTerm(mod)) {
return (FALSE);
}
if (IsAtomTerm(t)) {
Atom a = AtomOfTerm(t);
pe = Yap_GetPredPropByAtom(a, mod);
} else if (IsApplTerm(t)) {
register Functor f = FunctorOfTerm(t);
pe = Yap_GetPredPropByFunc(f, mod);
} else {
return (FALSE);
}
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(24, RepPredProp(pe));
ncl = RepPredProp(pe)->cs.p_code.NOfClauses;
2015-10-22 00:53:26 +01:00
UNLOCKPE(41, RepPredProp(pe));
return (Yap_unify_constant(ARG3, MkIntegerTerm(ncl)));
}
2015-10-22 00:53:26 +01:00
static Int p_new_multifile(USES_REGS1) { /* '$new_multifile'(+N,+Ar,+Mod) */
Atom at;
arity_t arity;
PredEntry *pe;
Term t = Deref(ARG1);
Term mod = Deref(ARG3);
if (IsVarTerm(t))
return (FALSE);
if (IsAtomTerm(t))
at = AtomOfTerm(t);
else
return (FALSE);
t = Deref(ARG2);
if (IsVarTerm(t))
return (FALSE);
if (IsIntTerm(t))
arity = IntOfTerm(t);
else
return FALSE;
2015-04-13 13:28:17 +01:00
if (arity == 0)
pe = RepPredProp(PredPropByAtom(at, mod));
2015-04-13 13:28:17 +01:00
else
2015-10-22 00:53:26 +01:00
pe = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, arity), mod));
PELOCK(26, pe);
2016-01-03 01:27:36 +00:00
if (pe->PredFlags &
(UserCPredFlag | CArgsPredFlag | NumberDBPredFlag | AtomDBPredFlag |
TestPredFlag | AsmPredFlag | CPredFlag | BinaryPredFlag)) {
UNLOCKPE(26, pe);
addcl_permission_error(RepAtom(at), arity, FALSE);
return false;
}
if (pe->PredFlags & MultiFileFlag) {
UNLOCKPE(26, pe);
return true;
}
if (pe->cs.p_code.NOfClauses) {
UNLOCKPE(26, pe);
2016-01-03 01:27:36 +00:00
addcl_permission_error(RepAtom(at), arity, FALSE);
return false;
}
pe->PredFlags |= MultiFileFlag;
2015-10-22 00:53:26 +01:00
/* mutifile-predicates are weird, they do not seat really on the default
* module */
if (!(pe->PredFlags & (DynamicPredFlag | LogUpdatePredFlag))) {
/* static */
2015-10-22 00:53:26 +01:00
pe->PredFlags |= (SourcePredFlag | CompiledPredFlag);
}
2015-10-22 00:53:26 +01:00
pe->src.OwnerFile = Yap_ConsultingFile(PASS_REGS1);
if (pe->cs.p_code.NOfClauses == 0) {
pe->CodeOfPred = pe->cs.p_code.TrueCodeOfPred = FAILCODE;
pe->OpcodeOfPred = FAIL_OPCODE;
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(43, pe);
return true;
}
2015-10-22 00:53:26 +01:00
static Int p_is_multifile(USES_REGS1) { /* '$is_multifile'(+S,+Mod) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_multifile");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(27, pe);
out = (pe->PredFlags & MultiFileFlag);
2015-10-22 00:53:26 +01:00
UNLOCKPE(44, pe);
return (out);
}
2016-03-05 12:21:58 +00:00
static Int new_system_predicate(
2016-01-03 01:27:36 +00:00
USES_REGS1) { /* '$new_system_predicate'(+N,+Ar,+Mod) */
2015-10-22 00:53:26 +01:00
Atom at;
arity_t arity;
PredEntry *pe;
Term t = Deref(ARG1);
Term mod = Deref(ARG3);
if (IsVarTerm(t))
return (FALSE);
if (IsAtomTerm(t))
at = AtomOfTerm(t);
else
return (FALSE);
t = Deref(ARG2);
if (IsVarTerm(t))
return (FALSE);
if (IsIntTerm(t))
arity = IntOfTerm(t);
else
return FALSE;
2015-04-13 13:28:17 +01:00
if (arity == 0)
pe = RepPredProp(PredPropByAtom(at, mod));
2015-04-13 13:28:17 +01:00
else
2015-10-22 00:53:26 +01:00
pe = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, arity), mod));
PELOCK(26, pe);
2016-01-03 01:27:36 +00:00
if (pe->PredFlags & (LogUpdatePredFlag | DynamicPredFlag | MultiFileFlag)) {
UNLOCKPE(43, pe);
return false;
}
2016-03-05 12:21:58 +00:00
pe->PredFlags |= (StandardPredFlag);
2015-10-22 00:53:26 +01:00
UNLOCKPE(43, pe);
2016-03-05 12:21:58 +00:00
return (true);
}
2016-01-03 01:27:36 +00:00
static Int
p_is_system_predicate(USES_REGS1) { /* '$is_multifile'(+S,+Mod) */
2015-10-22 00:53:26 +01:00
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "system_predicate");
2016-03-05 12:21:58 +00:00
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(27, pe);
2016-01-03 01:27:36 +00:00
out = (pe->PredFlags & SystemPredFlags);
2015-10-22 00:53:26 +01:00
UNLOCKPE(44, pe);
return (out);
}
2015-10-22 00:53:26 +01:00
static Int p_is_thread_local(USES_REGS1) { /* '$is_dynamic'(+P) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_log_updatable");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(27, pe);
out = (pe->PredFlags & ThreadLocalPredFlag);
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
return (out);
}
2015-10-22 00:53:26 +01:00
static Int p_is_log_updatable(USES_REGS1) { /* '$is_dynamic'(+P) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_log_updatable");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(27, pe);
out = (pe->PredFlags & LogUpdatePredFlag);
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
return (out);
}
2015-10-22 00:53:26 +01:00
static Int p_is_source(USES_REGS1) { /* '$is_dynamic'(+P) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_source");
if (EndOfPAEntr(pe))
2016-01-03 01:27:36 +00:00
return false;
2015-10-22 00:53:26 +01:00
PELOCK(28, pe);
2016-01-03 01:27:36 +00:00
if (pe->PredFlags & SystemPredFlags) {
UNLOCKPE(46, pe);
return false;
}
out = (pe->PredFlags & (SourcePredFlag | LogUpdatePredFlag |
MegaClausePredFlag | DynamicPredFlag));
2015-10-22 00:53:26 +01:00
UNLOCKPE(46, pe);
2016-01-03 01:27:36 +00:00
return out;
}
2015-10-22 00:53:26 +01:00
static Int p_is_exo(USES_REGS1) { /* '$is_dynamic'(+P) */
PredEntry *pe;
bool out;
2013-01-11 16:45:14 +00:00
MegaClause *mcl;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_exo");
2013-01-11 16:45:14 +00:00
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(28, pe);
2013-01-11 16:45:14 +00:00
out = (pe->PredFlags & MegaClausePredFlag);
if (out) {
2015-10-22 00:53:26 +01:00
mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause);
2013-01-11 16:45:14 +00:00
out = mcl->ClFlags & ExoMask;
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(46, pe);
return (out);
2013-01-11 16:45:14 +00:00
}
static Int owner_file(USES_REGS1) { /* '$owner_file'(+P,M,F) */
2015-10-22 00:53:26 +01:00
PredEntry *pe;
Atom owner;
2010-02-28 22:24:51 +00:00
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_source");
2010-02-28 22:24:51 +00:00
if (EndOfPAEntr(pe))
return false;
2015-10-22 00:53:26 +01:00
PELOCK(29, pe);
2010-02-28 22:24:51 +00:00
if (pe->ModuleOfPred == IDB_MODULE) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(47, pe);
return false;
2010-02-28 22:24:51 +00:00
}
if (pe->PredFlags & MultiFileFlag) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(48, pe);
return false;
}
if (is_system(pe) || is_foreign(pe)) {
UNLOCKPE(48, pe);
return false;
2010-02-28 22:24:51 +00:00
}
2015-10-22 00:53:26 +01:00
owner = pe->src.OwnerFile;
UNLOCKPE(49, pe);
if (owner == AtomNil || owner == NULL)
return false;
2010-02-28 22:24:51 +00:00
return Yap_unify(ARG3, MkAtomTerm(owner));
}
2015-10-22 00:53:26 +01:00
static Int p_set_owner_file(USES_REGS1) { /* '$owner_file'(+P,M,F) */
PredEntry *pe;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_source");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(29, pe);
if (pe->ModuleOfPred == IDB_MODULE) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(47, pe);
return FALSE;
}
if (pe->PredFlags & MultiFileFlag) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(48, pe);
return FALSE;
}
pe->src.OwnerFile = AtomOfTerm(Deref(ARG3));
2015-10-22 00:53:26 +01:00
UNLOCKPE(49, pe);
return TRUE;
}
static Int p_mk_d(USES_REGS1) { /* '$make_dynamic'(+P) */
2015-10-22 00:53:26 +01:00
PredEntry *pe;
Atom at;
arity_t arity;
pe = new_pred(Deref(ARG1), Deref(ARG2), "dynamic");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(30, pe);
arity = pe->ArityOfPE;
if (arity == 0)
at = (Atom)pe->FunctorOfPred;
else
at = NameOfFunctor(pe->FunctorOfPred);
if (pe->PredFlags &
(UserCPredFlag | CArgsPredFlag | NumberDBPredFlag | AtomDBPredFlag |
TestPredFlag | AsmPredFlag | CPredFlag | BinaryPredFlag)) {
UNLOCKPE(30, pe);
addcl_permission_error(RepAtom(at), arity, FALSE);
return false;
}
if (pe->PredFlags & LogUpdatePredFlag) {
UNLOCKPE(26, pe);
return true;
}
if (pe->PredFlags & DynamicPredFlag) {
UNLOCKPE(26, pe);
return true;
}
if (pe->cs.p_code.NOfClauses != 0) {
UNLOCKPE(26, pe);
addcl_permission_error(RepAtom(at), arity, FALSE);
return false;
}
if (pe->OpcodeOfPred == UNDEF_OPCODE) {
pe->OpcodeOfPred = FAIL_OPCODE;
}
2015-10-22 00:53:26 +01:00
pe->src.OwnerFile = Yap_ConsultingFile(PASS_REGS1);
pe->PredFlags |= LogUpdatePredFlag;
2015-10-22 00:53:26 +01:00
UNLOCKPE(50, pe);
return true;
}
2015-10-22 00:53:26 +01:00
static Int p_is_dynamic(USES_REGS1) { /* '$is_dynamic'(+P) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_dynamic");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(31, pe);
out = (pe->PredFlags & (DynamicPredFlag | LogUpdatePredFlag));
UNLOCKPE(51, pe);
return (out);
}
2015-10-22 00:53:26 +01:00
static Int p_is_metapredicate(USES_REGS1) { /* '$is_metapredicate'(+P) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$is_meta");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(32, pe);
out = (pe->PredFlags & MetaPredFlag);
2015-10-22 00:53:26 +01:00
UNLOCKPE(52, pe);
return out;
}
2015-10-22 00:53:26 +01:00
static Int p_pred_exists(USES_REGS1) { /* '$pred_exists'(+P,+M) */
PredEntry *pe;
bool out;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "$exists");
if (EndOfPAEntr(pe))
2016-01-03 01:27:36 +00:00
return false;
2015-10-22 00:53:26 +01:00
PELOCK(34, pe);
if (pe->PredFlags & HiddenPredFlag) {
UNLOCKPE(54, pe);
2016-01-03 01:27:36 +00:00
return false;
}
out = (pe->OpcodeOfPred != UNDEF_OPCODE);
2015-10-22 00:53:26 +01:00
UNLOCKPE(55, pe);
return out;
}
2015-10-22 00:53:26 +01:00
static Int p_set_pred_module(USES_REGS1) { /* '$set_pred_module'(+P,+Mod)
*/
PredEntry *pe;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), CurrentModule, "set_pred_module/1");
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(35, pe);
pe->ModuleOfPred = Deref(ARG2);
2015-10-22 00:53:26 +01:00
UNLOCKPE(56, pe);
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_set_pred_owner(USES_REGS1) { /* '$set_pred_module'(+P,+File)
*/
PredEntry *pe;
Term a2 = Deref(ARG2);
2014-09-22 18:09:23 +01:00
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), CurrentModule, "set_pred_module/1");
2014-09-22 18:09:23 +01:00
if (EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(35, pe);
if (pe->PredFlags &
(UserCPredFlag | CArgsPredFlag | NumberDBPredFlag | AtomDBPredFlag |
TestPredFlag | AsmPredFlag | CPredFlag | BinaryPredFlag)) {
UNLOCKPE(56, pe);
2014-09-22 18:09:23 +01:00
return FALSE;
}
if (IsVarTerm(a2)) {
Yap_Error(INSTANTIATION_ERROR, a2, "load_files/2");
2015-10-22 00:53:26 +01:00
UNLOCKPE(56, pe);
2014-09-22 18:09:23 +01:00
return FALSE;
}
if (!IsAtomTerm(a2)) {
Yap_Error(TYPE_ERROR_ATOM, a2, "load_files/2");
2015-10-22 00:53:26 +01:00
UNLOCKPE(56, pe);
2014-09-22 18:09:23 +01:00
return FALSE;
}
pe->src.OwnerFile = AtomOfTerm(a2);
2015-10-22 00:53:26 +01:00
UNLOCKPE(56, pe);
return (TRUE);
2014-09-22 18:09:23 +01:00
}
/**
* Set handler for undefined predicates.
*/
static Int undefp_handler(USES_REGS1) { /* '$undefp_handler'(P,Mod) */
PredEntry *pe;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "undefined/1");
if (EndOfPAEntr(pe))
return false;
PELOCK(59, pe);
if (pe->OpcodeOfPred == UNDEF_OPCODE) {
UNLOCKPE(59, pe);
return false;
}
UndefCode = pe;
UNLOCKPE(59, pe);
return true;
}
2015-10-22 00:53:26 +01:00
static Int p_undefined(USES_REGS1) { /* '$undefined'(P,Mod) */
PredEntry *pe;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "undefined/1");
if (EndOfPAEntr(pe))
return TRUE;
2015-10-22 00:53:26 +01:00
PELOCK(36, pe);
if (pe->PredFlags & (CPredFlag | UserCPredFlag | TestPredFlag | AsmPredFlag |
DynamicPredFlag | LogUpdatePredFlag | TabledPredFlag)) {
UNLOCKPE(57, pe);
return FALSE;
}
if (pe->OpcodeOfPred == UNDEF_OPCODE) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(58, pe);
return TRUE;
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(59, pe);
return FALSE;
}
/*
* this predicate should only be called when all clauses for the dynamic
2015-04-13 13:28:17 +01:00
* predicate were remove, otherwise chaos will follow!!
*/
2015-10-22 00:53:26 +01:00
static Int p_kill_dynamic(USES_REGS1) { /* '$kill_dynamic'(P,M) */
PredEntry *pe;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "kill_dynamic/1");
if (EndOfPAEntr(pe))
return TRUE;
2015-10-22 00:53:26 +01:00
PELOCK(37, pe);
if (!(pe->PredFlags & (DynamicPredFlag | LogUpdatePredFlag))) {
UNLOCKPE(60, pe);
return FALSE;
}
if (pe->cs.p_code.LastClause != pe->cs.p_code.FirstClause) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(61, pe);
return (FALSE);
}
pe->cs.p_code.LastClause = pe->cs.p_code.FirstClause = NULL;
pe->OpcodeOfPred = UNDEF_OPCODE;
2015-10-22 00:53:26 +01:00
pe->cs.p_code.TrueCodeOfPred = pe->CodeOfPred =
(yamop *)(&(pe->OpcodeOfPred));
pe->PredFlags = 0;
2015-10-22 00:53:26 +01:00
UNLOCKPE(62, pe);
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_optimizer_on(USES_REGS1) { /* '$optimizer_on' */
optimizer_on = TRUE;
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_optimizer_off(USES_REGS1) { /* '$optimizer_off' */
optimizer_on = FALSE;
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_is_profiled(USES_REGS1) {
2015-09-21 23:05:36 +01:00
Term t = Deref(ARG1);
char *s;
2015-04-13 13:28:17 +01:00
2015-09-21 23:05:36 +01:00
if (IsVarTerm(t)) {
Term ta;
2016-01-03 01:27:36 +00:00
if (trueGlobalPrologFlag(PROFILING_FLAG))
2015-10-22 00:53:26 +01:00
ta = MkAtomTerm(AtomOn);
else
ta = MkAtomTerm(AtomOff);
YapBind((CELL *)t, ta);
return (TRUE);
} else if (!IsAtomTerm(t))
return (FALSE);
2015-09-21 23:05:36 +01:00
s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE;
2015-10-22 00:53:26 +01:00
if (strcmp(s, "on") == 0) {
2015-09-21 23:05:36 +01:00
Yap_InitComma();
2015-10-22 00:53:26 +01:00
return (TRUE);
} else if (strcmp(s, "off") == 0) {
2015-09-21 23:05:36 +01:00
PROFILING = FALSE;
Yap_InitComma();
2015-10-22 00:53:26 +01:00
return (TRUE);
}
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-10-22 00:53:26 +01:00
static Int p_profile_info(USES_REGS1) {
2015-09-21 23:05:36 +01:00
Term mod = Deref(ARG1);
Term tfun = Deref(ARG2);
Term out;
PredEntry *pe;
Term p[3];
2015-04-13 13:28:17 +01:00
2015-09-21 23:05:36 +01:00
if (IsVarTerm(mod) || !IsAtomTerm(mod))
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
if (IsVarTerm(tfun)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
} else if (IsApplTerm(tfun)) {
Functor f = FunctorOfTerm(tfun);
if (IsExtensionFunctor(f)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByFunc(f, mod));
} else if (IsAtomTerm(tfun)) {
pe = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(tfun), mod));
} else {
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
if (EndOfPAEntr(pe))
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
LOCK(pe->StatisticsForPred->lock);
if (!(pe->StatisticsForPred->NOfEntries)) {
UNLOCK(pe->StatisticsForPred->lock);
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
p[0] = Yap_MkULLIntTerm(pe->StatisticsForPred->NOfEntries);
p[1] = Yap_MkULLIntTerm(pe->StatisticsForPred->NOfHeadSuccesses);
p[2] = Yap_MkULLIntTerm(pe->StatisticsForPred->NOfRetries);
UNLOCK(pe->StatisticsForPred->lock);
2015-10-22 00:53:26 +01:00
out = Yap_MkApplTerm(Yap_MkFunctor(AtomProfile, 3), 3, p);
return (Yap_unify(ARG3, out));
}
2015-10-22 00:53:26 +01:00
static Int p_profile_reset(USES_REGS1) {
2015-09-21 23:05:36 +01:00
Term mod = Deref(ARG1);
Term tfun = Deref(ARG2);
PredEntry *pe;
2015-04-13 13:28:17 +01:00
2015-09-21 23:05:36 +01:00
if (IsVarTerm(mod) || !IsAtomTerm(mod))
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
if (IsVarTerm(tfun)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
} else if (IsApplTerm(tfun)) {
Functor f = FunctorOfTerm(tfun);
if (IsExtensionFunctor(f)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByFunc(f, mod));
} else if (IsAtomTerm(tfun)) {
pe = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(tfun), mod));
} else {
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
if (EndOfPAEntr(pe))
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
LOCK(pe->StatisticsForPred->lock);
pe->StatisticsForPred->NOfEntries = 0;
pe->StatisticsForPred->NOfHeadSuccesses = 0;
pe->StatisticsForPred->NOfRetries = 0;
UNLOCK(pe->StatisticsForPred->lock);
2015-10-22 00:53:26 +01:00
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_is_call_counted(USES_REGS1) {
2015-09-21 23:05:36 +01:00
Term t = Deref(ARG1);
char *s;
2015-09-21 23:05:36 +01:00
if (IsVarTerm(t)) {
Term ta;
2015-10-22 00:53:26 +01:00
if (CALL_COUNTING)
ta = MkAtomTerm(AtomOn);
else
ta = MkAtomTerm(AtomOff);
YapBind((CELL *)t, ta);
return (TRUE);
} else if (!IsAtomTerm(t))
return (FALSE);
2015-09-21 23:05:36 +01:00
s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE;
2015-10-22 00:53:26 +01:00
if (strcmp(s, "on") == 0) {
2015-09-21 23:05:36 +01:00
CALL_COUNTING = TRUE;
Yap_InitComma();
2015-10-22 00:53:26 +01:00
return (TRUE);
} else if (strcmp(s, "off") == 0) {
2015-09-21 23:05:36 +01:00
CALL_COUNTING = FALSE;
Yap_InitComma();
2015-10-22 00:53:26 +01:00
return (TRUE);
}
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-10-22 00:53:26 +01:00
static Int p_call_count_info(USES_REGS1) {
return (Yap_unify(MkIntegerTerm(LOCAL_ReductionsCounter), ARG1) &&
Yap_unify(MkIntegerTerm(LOCAL_PredEntriesCounter), ARG2) &&
Yap_unify(MkIntegerTerm(LOCAL_PredEntriesCounter), ARG3));
}
2015-10-22 00:53:26 +01:00
static Int p_call_count_reset(USES_REGS1) {
2015-09-21 23:05:36 +01:00
LOCAL_ReductionsCounter = 0;
LOCAL_ReductionsCounterOn = FALSE;
LOCAL_PredEntriesCounter = 0;
LOCAL_PredEntriesCounterOn = FALSE;
LOCAL_RetriesCounter = 0;
LOCAL_RetriesCounterOn = FALSE;
2015-10-22 00:53:26 +01:00
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_call_count_set(USES_REGS1) {
2015-09-21 23:05:36 +01:00
int do_calls = IntOfTerm(ARG2);
int do_retries = IntOfTerm(ARG4);
int do_entries = IntOfTerm(ARG6);
2015-09-21 23:05:36 +01:00
if (do_calls)
LOCAL_ReductionsCounter = IntegerOfTerm(Deref(ARG1));
LOCAL_ReductionsCounterOn = do_calls;
if (do_retries)
LOCAL_RetriesCounter = IntegerOfTerm(Deref(ARG3));
LOCAL_RetriesCounterOn = do_retries;
if (do_entries)
LOCAL_PredEntriesCounter = IntegerOfTerm(Deref(ARG5));
LOCAL_PredEntriesCounterOn = do_entries;
2015-10-22 00:53:26 +01:00
return (TRUE);
}
2015-10-22 00:53:26 +01:00
static Int p_clean_up_dead_clauses(USES_REGS1) {
2015-09-21 23:05:36 +01:00
while (DeadStaticClauses != NULL) {
char *pt = (char *)DeadStaticClauses;
Yap_ClauseSpace -= DeadStaticClauses->ClSize;
DeadStaticClauses = DeadStaticClauses->ClNext;
Yap_InformOfRemoval(pt);
Yap_FreeCodeSpace(pt);
}
2015-09-21 23:05:36 +01:00
while (DeadStaticIndices != NULL) {
char *pt = (char *)DeadStaticIndices;
if (DeadStaticIndices->ClFlags & SwitchTableMask)
Yap_IndexSpace_SW -= DeadStaticIndices->ClSize;
else
Yap_IndexSpace_Tree -= DeadStaticIndices->ClSize;
DeadStaticIndices = DeadStaticIndices->SiblingIndex;
Yap_InformOfRemoval(pt);
Yap_FreeCodeSpace(pt);
}
2015-09-21 23:05:36 +01:00
while (DeadMegaClauses != NULL) {
char *pt = (char *)DeadMegaClauses;
Yap_ClauseSpace -= DeadMegaClauses->ClSize;
DeadMegaClauses = DeadMegaClauses->ClNext;
Yap_InformOfRemoval(pt);
Yap_FreeCodeSpace(pt);
}
return TRUE;
}
2015-10-22 00:53:26 +01:00
void Yap_HidePred(PredEntry *pe) {
2016-01-08 03:18:36 +00:00
pe->PredFlags |= (HiddenPredFlag | NoSpyPredFlag | NoTracePredFlag);
}
2015-10-22 00:53:26 +01:00
static Int /* $system_predicate(P) */
p_stash_predicate(USES_REGS1) {
PredEntry *pe;
2015-09-21 23:05:36 +01:00
Term t1 = Deref(ARG1);
Term mod = Deref(ARG2);
2015-10-22 00:53:26 +01:00
restart_system_pred:
2015-09-21 23:05:36 +01:00
if (IsVarTerm(t1))
return (FALSE);
if (IsAtomTerm(t1)) {
Atom a = AtomOfTerm(t1);
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByAtom(a, mod));
} else if (IsApplTerm(t1)) {
2015-10-22 00:53:26 +01:00
Functor funt = FunctorOfTerm(t1);
2015-09-21 23:05:36 +01:00
if (IsExtensionFunctor(funt)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
if (funt == FunctorModule) {
Term nmod = ArgOfTerm(1, t1);
if (IsVarTerm(nmod)) {
2015-10-22 00:53:26 +01:00
Yap_Error(INSTANTIATION_ERROR, ARG1, "hide_predicate/1");
return (FALSE);
2015-09-21 23:05:36 +01:00
}
if (!IsAtomTerm(nmod)) {
2015-10-22 00:53:26 +01:00
Yap_Error(TYPE_ERROR_ATOM, ARG1, "hide_predicate/1");
return (FALSE);
2015-09-21 23:05:36 +01:00
}
t1 = ArgOfTerm(2, t1);
goto restart_system_pred;
}
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByFunc(funt, mod));
} else if (IsPairTerm(t1)) {
return TRUE;
} else
return FALSE;
2015-09-21 23:05:36 +01:00
if (EndOfPAEntr(pe))
return FALSE;
2015-09-21 23:05:36 +01:00
Yap_HidePred(pe);
return TRUE;
}
2015-10-22 00:53:26 +01:00
static Int /* $system_predicate(P) */
hide_predicate(USES_REGS1) {
2015-10-22 00:53:26 +01:00
PredEntry *pe;
2015-09-21 23:05:36 +01:00
Term t1 = Deref(ARG1);
Term mod = Deref(ARG2);
2015-10-22 00:53:26 +01:00
restart_system_pred:
2015-09-21 23:05:36 +01:00
if (IsVarTerm(t1))
return (FALSE);
if (IsAtomTerm(t1)) {
Atom a = AtomOfTerm(t1);
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByAtom(a, mod));
} else if (IsApplTerm(t1)) {
2015-10-22 00:53:26 +01:00
Functor funt = FunctorOfTerm(t1);
2015-09-21 23:05:36 +01:00
if (IsExtensionFunctor(funt)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
}
2015-09-21 23:05:36 +01:00
if (funt == FunctorModule) {
Term nmod = ArgOfTerm(1, t1);
if (IsVarTerm(nmod)) {
2015-10-22 00:53:26 +01:00
Yap_Error(INSTANTIATION_ERROR, ARG1, "hide_predicate/1");
return (FALSE);
2015-09-21 23:05:36 +01:00
}
if (!IsAtomTerm(nmod)) {
2015-10-22 00:53:26 +01:00
Yap_Error(TYPE_ERROR_ATOM, ARG1, "hide_predicate/1");
return (FALSE);
2015-09-21 23:05:36 +01:00
}
t1 = ArgOfTerm(2, t1);
goto restart_system_pred;
}
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByFunc(funt, mod));
} else if (IsPairTerm(t1)) {
return true;
2015-09-21 23:05:36 +01:00
} else
return false;
if (EndOfPAEntr(pe))
return false;
2016-01-08 03:18:36 +00:00
pe->PredFlags |= (HiddenPredFlag | NoSpyPredFlag | NoTracePredFlag);
return true;
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_hidden_predicate(USES_REGS1) {
PredEntry *pe;
2015-09-21 23:05:36 +01:00
Term t1 = Deref(ARG1);
Term mod = Deref(ARG2);
2015-10-22 00:53:26 +01:00
restart_system_pred:
2015-09-21 23:05:36 +01:00
if (IsVarTerm(t1))
return (FALSE);
if (IsAtomTerm(t1)) {
pe = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t1), mod));
} else if (IsApplTerm(t1)) {
2015-10-22 00:53:26 +01:00
Functor funt = FunctorOfTerm(t1);
2015-09-21 23:05:36 +01:00
if (IsExtensionFunctor(funt)) {
2015-10-22 00:53:26 +01:00
return (FALSE);
2015-09-21 23:05:36 +01:00
}
if (funt == FunctorModule) {
Term nmod = ArgOfTerm(1, t1);
if (IsVarTerm(nmod)) {
2015-10-22 00:53:26 +01:00
Yap_Error(INSTANTIATION_ERROR, ARG1, "hide_predicate/1");
return (FALSE);
}
2015-09-21 23:05:36 +01:00
if (!IsAtomTerm(nmod)) {
2015-10-22 00:53:26 +01:00
Yap_Error(TYPE_ERROR_ATOM, ARG1, "hide_predicate/1");
return (FALSE);
}
2015-09-21 23:05:36 +01:00
t1 = ArgOfTerm(2, t1);
goto restart_system_pred;
}
2015-09-21 23:05:36 +01:00
pe = RepPredProp(Yap_GetPredPropByFunc(funt, mod));
} else if (IsPairTerm(t1)) {
return (TRUE);
} else
return (FALSE);
if (EndOfPAEntr(pe))
2015-10-22 00:53:26 +01:00
return (FALSE);
return (pe->PredFlags & HiddenPredFlag);
}
2015-10-22 00:53:26 +01:00
static Int fetch_next_lu_clause(PredEntry *pe, yamop *i_code, Term th, Term tb,
Term tr, yamop *cp_ptr, int first_time) {
CACHE_REGS
2015-09-21 23:05:36 +01:00
LogUpdClause *cl;
Term rtn;
Term Terms[3];
Terms[0] = th;
Terms[1] = tb;
Terms[2] = tr;
2015-10-22 00:53:26 +01:00
cl = Yap_FollowIndexingCode(
pe, i_code, Terms, NEXTOP(PredLogUpdClause->CodeOfPred, Otapl), cp_ptr);
2015-09-21 23:05:36 +01:00
th = Terms[0];
tb = Terms[1];
tr = Terms[2];
2010-07-28 17:12:17 +01:00
if (cl == NULL) {
2015-09-21 23:05:36 +01:00
UNLOCK(pe->PELock);
return FALSE;
2010-07-28 17:12:17 +01:00
}
2015-09-21 23:05:36 +01:00
rtn = MkDBRefTerm((DBRef)cl);
#if MULTIPLE_STACKS
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
2015-09-21 23:05:36 +01:00
INC_CLREF_COUNT(cl);
#else
if (!(cl->ClFlags & InUseMask)) {
cl->ClFlags |= InUseMask;
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
2015-09-21 23:05:36 +01:00
}
#endif
if (cl->ClFlags & FactMask) {
2015-10-22 00:53:26 +01:00
if (!Yap_unify_constant(tb, MkAtomTerm(AtomTrue)) || !Yap_unify(tr, rtn)) {
2015-09-21 23:05:36 +01:00
UNLOCK(pe->PELock);
return FALSE;
2010-07-28 17:12:17 +01:00
}
if (pe->ArityOfPE) {
Functor f = FunctorOfTerm(th);
arity_t arity = ArityOfFunctor(f), i;
2015-10-22 00:53:26 +01:00
CELL *pt = RepAppl(th) + 1;
2015-10-22 00:53:26 +01:00
for (i = 0; i < arity; i++) {
XREGS[i + 1] = pt[i];
}
/* don't need no ENV */
2015-10-22 00:53:26 +01:00
if (first_time && P->opc != EXECUTE_CPRED_OP_CODE) {
CP = P;
ENV = YENV;
YENV = ASP;
YENV[E_CB] = (CELL)B;
}
2015-09-21 23:05:36 +01:00
P = cl->ClCode;
#if defined(YAPOR) || defined(THREADS)
if (pe->PredFlags & ThreadLocalPredFlag) {
2015-10-22 00:53:26 +01:00
/* we don't actually need to execute code */
UNLOCK(pe->PELock);
2015-09-21 23:05:36 +01:00
} else {
2015-10-22 00:53:26 +01:00
PP = pe;
2015-09-21 23:05:36 +01:00
}
#endif
} else {
/* we don't actually need to execute code */
UNLOCK(pe->PELock);
}
return TRUE;
2015-09-21 23:05:36 +01:00
} else {
Term t;
while ((t = Yap_FetchClauseTermFromDB(cl->lusl.ClSource)) == 0L) {
if (first_time) {
2015-10-22 00:53:26 +01:00
ARG5 = th;
ARG6 = tb;
ARG7 = tr;
if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_growglobal(NULL)) {
UNLOCK(pe->PELock);
Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil,
LOCAL_ErrorMessage);
return FALSE;
}
} else {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_gcl(LOCAL_Error_Size, 7, ENV, gc_P(P, CP))) {
UNLOCK(pe->PELock);
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
}
th = ARG5;
tb = ARG6;
tr = ARG7;
2015-09-21 23:05:36 +01:00
} else {
2015-10-22 00:53:26 +01:00
ARG6 = th;
ARG7 = tb;
ARG8 = tr;
if (!Yap_gcl(LOCAL_Error_Size, 8, ENV, gc_P(P, CP))) {
UNLOCK(pe->PELock);
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
th = ARG6;
tb = ARG7;
tr = ARG8;
2015-09-21 23:05:36 +01:00
}
}
UNLOCK(pe->PELock);
2015-10-22 00:53:26 +01:00
return (Yap_unify(th, ArgOfTerm(1, t)) && Yap_unify(tb, ArgOfTerm(2, t)) &&
Yap_unify(tr, rtn));
}
2015-09-21 23:05:36 +01:00
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_log_update_clause(USES_REGS1) {
PredEntry *pe;
2015-09-21 23:05:36 +01:00
Term t1 = Deref(ARG1);
Int ret;
yamop *new_cp;
if (P->opc == EXECUTE_CPRED_OP_CODE) {
new_cp = CP;
} else {
new_cp = P;
}
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(t1, Deref(ARG2), "clause/3");
2015-09-21 23:05:36 +01:00
if (pe == NULL || EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(41, pe);
2015-09-21 23:05:36 +01:00
ret = fetch_next_lu_clause(pe, pe->CodeOfPred, t1, ARG3, ARG4, new_cp, TRUE);
return ret;
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_continue_log_update_clause(USES_REGS1) {
2015-09-21 23:05:36 +01:00
PredEntry *pe = (PredEntry *)IntegerOfTerm(Deref(ARG1));
yamop *ipc = (yamop *)IntegerOfTerm(ARG2);
2015-10-22 00:53:26 +01:00
PELOCK(42, pe);
return fetch_next_lu_clause(pe, ipc, Deref(ARG3), ARG4, ARG5, B->cp_cp,
FALSE);
2015-09-21 23:05:36 +01:00
}
2015-10-22 00:53:26 +01:00
static Int fetch_next_lu_clause_erase(PredEntry *pe, yamop *i_code, Term th,
Term tb, Term tr, yamop *cp_ptr,
int first_time) {
2015-09-21 23:05:36 +01:00
CACHE_REGS
LogUpdClause *cl;
Term rtn;
Term Terms[3];
Terms[0] = th;
Terms[1] = tb;
Terms[2] = tr;
2015-10-22 00:53:26 +01:00
cl = Yap_FollowIndexingCode(pe, i_code, Terms,
NEXTOP(PredLogUpdClauseErase->CodeOfPred, Otapl),
cp_ptr);
2015-09-21 23:05:36 +01:00
th = Terms[0];
tb = Terms[1];
tr = Terms[2];
/* don't do this!! I might have stored a choice-point and changed ASP
Yap_RecoverSlots(3);
*/
if (cl == NULL) {
UNLOCK(pe->PELock);
return FALSE;
}
rtn = MkDBRefTerm((DBRef)cl);
#if MULTIPLE_STACKS
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
2015-09-21 23:05:36 +01:00
INC_CLREF_COUNT(cl);
#else
if (!(cl->ClFlags & InUseMask)) {
cl->ClFlags |= InUseMask;
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
2015-09-21 23:05:36 +01:00
}
#endif
if (cl->ClFlags & FactMask) {
2015-10-22 00:53:26 +01:00
if (!Yap_unify_constant(tb, MkAtomTerm(AtomTrue)) || !Yap_unify(tr, rtn)) {
2015-09-21 23:05:36 +01:00
UNLOCK(pe->PELock);
return FALSE;
2010-07-28 17:12:17 +01:00
}
if (pe->ArityOfPE) {
Functor f = FunctorOfTerm(th);
arity_t arity = ArityOfFunctor(f), i;
2015-10-22 00:53:26 +01:00
CELL *pt = RepAppl(th) + 1;
2015-10-22 00:53:26 +01:00
for (i = 0; i < arity; i++) {
XREGS[i + 1] = pt[i];
}
/* don't need no ENV */
2015-10-22 00:53:26 +01:00
if (first_time && P->opc != EXECUTE_CPRED_OP_CODE) {
CP = P;
ENV = YENV;
YENV = ASP;
YENV[E_CB] = (CELL)B;
}
P = cl->ClCode;
2015-09-21 23:05:36 +01:00
#if defined(YAPOR) || defined(THREADS)
if (pe->PredFlags & ThreadLocalPredFlag) {
2015-10-22 00:53:26 +01:00
/* we don't actually need to execute code */
UNLOCK(pe->PELock);
2015-09-21 23:05:36 +01:00
} else {
2015-10-22 00:53:26 +01:00
PP = pe;
2015-09-21 23:05:36 +01:00
}
#endif
} else {
/* we don't actually need to execute code */
UNLOCK(pe->PELock);
}
2015-09-21 23:05:36 +01:00
Yap_ErLogUpdCl(cl);
return TRUE;
} else {
Term t;
2015-09-21 23:05:36 +01:00
Int res;
2015-04-13 13:28:17 +01:00
2015-09-21 23:05:36 +01:00
while ((t = Yap_FetchClauseTermFromDB(cl->lusl.ClSource)) == 0L) {
if (first_time) {
2015-10-22 00:53:26 +01:00
ARG5 = th;
ARG6 = tb;
ARG7 = tr;
if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_locked_growglobal(NULL)) {
UNLOCK(pe->PELock);
Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil,
LOCAL_ErrorMessage);
return FALSE;
}
} else {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_locked_gcl(LOCAL_Error_Size, 7, ENV, gc_P(P, CP))) {
UNLOCK(pe->PELock);
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
}
th = ARG5;
tb = ARG6;
tr = ARG7;
} else {
2015-10-22 00:53:26 +01:00
ARG6 = th;
ARG7 = tb;
ARG8 = tr;
if (!Yap_gcl(LOCAL_Error_Size, 8, ENV, CP)) {
UNLOCK(pe->PELock);
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
th = ARG6;
tb = ARG7;
tr = ARG8;
}
}
2015-10-22 00:53:26 +01:00
res = Yap_unify(th, ArgOfTerm(1, t)) && Yap_unify(tb, ArgOfTerm(2, t)) &&
Yap_unify(tr, rtn);
2015-09-21 23:05:36 +01:00
if (res)
Yap_ErLogUpdCl(cl);
UNLOCK(pe->PELock);
return res;
}
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_log_update_clause_erase(USES_REGS1) {
PredEntry *pe;
Term t1 = Deref(ARG1);
2015-09-21 23:05:36 +01:00
Int ret;
yamop *new_cp;
2008-09-01 16:48:05 +01:00
if (P->opc == EXECUTE_CPRED_OP_CODE) {
new_cp = CP;
} else {
new_cp = P;
}
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(t1, Deref(ARG2), "clause/3");
if (pe == NULL || EndOfPAEntr(pe))
return FALSE;
2015-10-22 00:53:26 +01:00
PELOCK(43, pe);
ret = fetch_next_lu_clause_erase(pe, pe->CodeOfPred, t1, ARG3, ARG4, new_cp,
TRUE);
2015-09-21 23:05:36 +01:00
return ret;
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_continue_log_update_clause_erase(USES_REGS1) {
PredEntry *pe = (PredEntry *)IntegerOfTerm(Deref(ARG1));
yamop *ipc = (yamop *)IntegerOfTerm(ARG2);
2015-10-22 00:53:26 +01:00
PELOCK(44, pe);
return fetch_next_lu_clause_erase(pe, ipc, Deref(ARG3), ARG4, ARG5, B->cp_cp,
FALSE);
}
2015-10-22 00:53:26 +01:00
static void adjust_cl_timestamp(LogUpdClause *cl, UInt *arp, UInt *base) {
2015-09-21 23:05:36 +01:00
UInt clstamp = cl->ClTimeEnd;
if (cl->ClTimeEnd != TIMESTAMP_EOT) {
while (arp[0] > clstamp)
arp--;
if (arp[0] == clstamp) {
2015-10-22 00:53:26 +01:00
cl->ClTimeEnd = (arp - base);
} else {
2015-10-22 00:53:26 +01:00
cl->ClTimeEnd = (arp - base) + 1;
}
2015-04-13 13:28:17 +01:00
}
2015-09-21 23:05:36 +01:00
clstamp = cl->ClTimeStart;
while (arp[0] > clstamp)
arp--;
if (arp[0] == clstamp) {
2015-10-22 00:53:26 +01:00
cl->ClTimeStart = (arp - base);
2015-09-21 23:05:36 +01:00
} else {
2015-10-22 00:53:26 +01:00
cl->ClTimeStart = (arp - base) + 1;
}
2015-09-21 23:05:36 +01:00
clstamp = cl->ClTimeEnd;
}
2015-10-22 00:53:26 +01:00
static Term replace_integer(Term orig, UInt new) {
2015-09-21 23:05:36 +01:00
CELL *pt;
2015-10-22 00:53:26 +01:00
if (IntInBnd((Int) new))
2015-09-21 23:05:36 +01:00
return MkIntTerm(new);
/* should create an old integer */
if (!IsApplTerm(orig)) {
CACHE_REGS
2015-10-22 00:53:26 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, orig,
"%uld-->%uld where it should increase",
(unsigned long int)IntegerOfTerm(orig), (unsigned long int)new);
2015-09-21 23:05:36 +01:00
return MkIntegerTerm(new);
}
2015-09-21 23:05:36 +01:00
/* appl->appl */
/* replace integer in situ */
2015-10-22 00:53:26 +01:00
pt = RepAppl(orig) + 1;
2015-09-21 23:05:36 +01:00
*pt = new;
return orig;
}
2015-10-22 00:53:26 +01:00
static UInt tree_index_ssz(StaticIndex *x) {
UInt sz = x->ClSize;
x = x->ChildIndex;
while (x != NULL) {
2015-10-22 00:53:26 +01:00
sz += tree_index_ssz(x);
x = x->SiblingIndex;
}
return sz;
}
2015-10-22 00:53:26 +01:00
static UInt index_ssz(StaticIndex *x, PredEntry *pe) {
2013-01-23 09:58:02 +00:00
UInt sz = 0;
yamop *ep = ExpandClausesFirst;
if (pe->PredFlags & MegaClausePredFlag) {
MegaClause *mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause);
if (mcl->ClFlags & ExoMask) {
struct index_t *i = ((struct index_t **)(pe->cs.p_code.FirstClause))[0];
sz = 0;
while (i) {
2015-10-22 00:53:26 +01:00
sz = i->size + sz;
i = i->next;
2013-01-23 09:58:02 +00:00
}
return sz;
}
}
/* expand clause blocks */
while (ep) {
2014-05-30 01:06:09 +01:00
if (ep->y_u.sssllp.p == pe)
2015-10-22 00:53:26 +01:00
sz += (UInt)NEXTOP((yamop *)NULL, sssllp) +
ep->y_u.sssllp.s1 * sizeof(yamop *);
2014-05-30 01:06:09 +01:00
ep = ep->y_u.sssllp.snext;
2013-01-23 09:58:02 +00:00
}
/* main indexing tree */
sz += tree_index_ssz(x);
return sz;
}
2015-09-21 23:05:36 +01:00
#ifdef DEBUG
2015-10-22 00:53:26 +01:00
static Int p_predicate_lu_cps(USES_REGS1) {
2015-09-21 23:05:36 +01:00
return Yap_unify(ARG1, MkIntegerTerm(Yap_LiveCps)) &&
2015-10-22 00:53:26 +01:00
Yap_unify(ARG2, MkIntegerTerm(Yap_FreedCps)) &&
Yap_unify(ARG3, MkIntegerTerm(Yap_DirtyCps)) &&
Yap_unify(ARG4, MkIntegerTerm(Yap_NewCps));
2015-09-21 23:05:36 +01:00
}
#endif
2015-10-22 00:53:26 +01:00
static Int static_statistics(PredEntry *pe) {
CACHE_REGS
2013-01-23 09:58:02 +00:00
UInt sz = sizeof(PredEntry), cls = 0, isz = 0;
StaticClause *cl = ClauseCodeToStaticClause(pe->cs.p_code.FirstClause);
if (pe->cs.p_code.NOfClauses > 1 &&
pe->cs.p_code.TrueCodeOfPred != pe->cs.p_code.FirstClause) {
2013-01-23 09:58:02 +00:00
isz = index_ssz(ClauseCodeToStaticIndex(pe->cs.p_code.TrueCodeOfPred), pe);
}
if (pe->PredFlags & MegaClausePredFlag) {
MegaClause *mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause);
2015-10-22 00:53:26 +01:00
return Yap_unify(ARG3, MkIntegerTerm(mcl->ClSize / mcl->ClItemSize)) &&
Yap_unify(ARG4, MkIntegerTerm(mcl->ClSize)) &&
Yap_unify(ARG5, MkIntegerTerm(isz));
}
if (pe->cs.p_code.NOfClauses) {
do {
cls++;
sz += cl->ClSize;
if (cl->ClCode == pe->cs.p_code.LastClause)
2015-10-22 00:53:26 +01:00
break;
cl = cl->ClNext;
} while (TRUE);
}
return Yap_unify(ARG3, MkIntegerTerm(cls)) &&
2015-10-22 00:53:26 +01:00
Yap_unify(ARG4, MkIntegerTerm(sz)) &&
Yap_unify(ARG5, MkIntegerTerm(isz));
}
2015-10-22 00:53:26 +01:00
static Int p_static_pred_statistics(USES_REGS1) {
Int out;
2015-10-22 00:53:26 +01:00
PredEntry *pe;
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "predicate_statistics");
if (pe == NIL)
return (FALSE);
2015-10-22 00:53:26 +01:00
PELOCK(50, pe);
if (pe->PredFlags & (DynamicPredFlag | LogUpdatePredFlag | UserCPredFlag |
AsmPredFlag | CPredFlag | BinaryPredFlag)) {
/* should use '$recordedp' in this case */
UNLOCK(pe->PELock);
return FALSE;
}
out = static_statistics(pe);
UNLOCK(pe->PELock);
return out;
}
2015-10-22 00:53:26 +01:00
static Int p_predicate_erased_statistics(USES_REGS1) {
UInt sz = 0, cls = 0;
UInt isz = 0, icls = 0;
PredEntry *pe;
LogUpdClause *cl = DBErasedList;
LogUpdIndex *icl = DBErasedIList;
2015-10-22 00:53:26 +01:00
Term tpred = ArgOfTerm(2, Deref(ARG1));
Term tmod = ArgOfTerm(1, Deref(ARG1));
2016-10-20 04:44:59 +01:00
if (EndOfPAEntr(pe =
Yap_get_pred(tpred, tmod, "predicate_erased_statistics")))
return FALSE;
while (cl) {
if (cl->ClPred == pe) {
cls++;
sz += cl->ClSize;
}
cl = cl->ClNext;
}
while (icl) {
if (pe == icl->ClPred) {
icls++;
isz += icl->ClSize;
}
icl = icl->SiblingIndex;
}
2015-10-22 00:53:26 +01:00
return Yap_unify(ARG2, MkIntegerTerm(cls)) &&
Yap_unify(ARG3, MkIntegerTerm(sz)) &&
Yap_unify(ARG4, MkIntegerTerm(icls)) &&
Yap_unify(ARG5, MkIntegerTerm(isz));
}
2016-01-03 01:27:36 +00:00
void Yap_UpdateTimestamps(PredEntry *ap) {
2015-09-21 23:05:36 +01:00
CACHE_REGS
choiceptr bptr = B;
2015-10-22 00:53:26 +01:00
yamop *cl0 = NEXTOP(PredLogUpdClause0->CodeOfPred, Otapl);
yamop *cl = NEXTOP(PredLogUpdClause->CodeOfPred, Otapl);
yamop *cle = NEXTOP(PredLogUpdClauseErase->CodeOfPred, Otapl);
2015-09-21 23:05:36 +01:00
arity_t ar = ap->ArityOfPE;
UInt *arp, *top, *base;
LogUpdClause *lcl;
#if THREADS
2015-10-22 00:53:26 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "Timestamp overflow %p", ap);
2015-09-21 23:05:36 +01:00
return;
#endif
if (!ap->cs.p_code.NOfClauses)
return;
2015-10-22 00:53:26 +01:00
restart:
2015-09-21 23:05:36 +01:00
*--ASP = TIMESTAMP_EOT;
top = arp = (UInt *)ASP;
while (bptr) {
op_numbers opnum = Yap_op_from_opcode(bptr->cp_ap->opc);
switch (opnum) {
case _retry_logical:
case _count_retry_logical:
case _profiled_retry_logical:
case _trust_logical:
case _count_trust_logical:
case _profiled_trust_logical:
if (bptr->cp_ap->y_u.OtaLl.d->ClPred == ap) {
2015-10-22 00:53:26 +01:00
UInt ts = IntegerOfTerm(bptr->cp_args[ar]);
if (ts != arp[0]) {
if (arp - HR < 1024) {
goto overflow;
}
/* be thrifty, have this in case there is a hole */
if (ts != arp[0] - 1) {
UInt x = arp[0];
*--arp = x;
}
*--arp = ts;
}
2015-09-21 23:05:36 +01:00
}
bptr = bptr->cp_b;
break;
case _retry:
if ((bptr->cp_ap == cl0 || bptr->cp_ap == cl || bptr->cp_ap == cle) &&
2015-10-22 00:53:26 +01:00
((PredEntry *)IntegerOfTerm(bptr->cp_args[0]) == ap)) {
UInt ts = IntegerOfTerm(bptr->cp_args[5]);
if (ts != arp[0]) {
if (arp - HR < 1024) {
goto overflow;
}
if (ts != arp[0] - 1) {
UInt x = arp[0];
*--arp = x;
}
*--arp = ts;
}
2015-09-21 23:05:36 +01:00
}
bptr = bptr->cp_b;
break;
default:
bptr = bptr->cp_b;
continue;
}
}
if (*arp)
*--arp = 0L;
base = arp;
lcl = ClauseCodeToLogUpdClause(ap->cs.p_code.FirstClause);
while (lcl) {
2015-10-22 00:53:26 +01:00
adjust_cl_timestamp(lcl, top - 1, base);
2015-09-21 23:05:36 +01:00
lcl = lcl->ClNext;
}
lcl = DBErasedList;
while (lcl) {
if (lcl->ClPred == ap)
2015-10-22 00:53:26 +01:00
adjust_cl_timestamp(lcl, top - 1, base);
2015-09-21 23:05:36 +01:00
lcl = lcl->ClNext;
}
2015-10-22 00:53:26 +01:00
arp = top - 1;
2015-09-21 23:05:36 +01:00
bptr = B;
while (bptr) {
op_numbers opnum = Yap_op_from_opcode(bptr->cp_ap->opc);
switch (opnum) {
case _retry_logical:
case _count_retry_logical:
case _profiled_retry_logical:
case _trust_logical:
case _count_trust_logical:
case _profiled_trust_logical:
if (bptr->cp_ap->y_u.OtaLl.d->ClPred == ap) {
2015-10-22 00:53:26 +01:00
UInt ts = IntegerOfTerm(bptr->cp_args[ar]);
while (ts != arp[0])
arp--;
bptr->cp_args[ar] = replace_integer(bptr->cp_args[ar], arp - base);
2015-09-21 23:05:36 +01:00
}
bptr = bptr->cp_b;
break;
case _retry:
if ((bptr->cp_ap == cl0 || bptr->cp_ap == cl || bptr->cp_ap == cle) &&
2015-10-22 00:53:26 +01:00
((PredEntry *)IntegerOfTerm(bptr->cp_args[0]) == ap)) {
UInt ts = IntegerOfTerm(bptr->cp_args[5]);
while (ts != arp[0])
arp--;
bptr->cp_args[5] = replace_integer(bptr->cp_args[5], arp - base);
2015-09-21 23:05:36 +01:00
}
bptr = bptr->cp_b;
break;
default:
bptr = bptr->cp_b;
continue;
}
}
return;
2015-10-22 00:53:26 +01:00
overflow:
if (!Yap_growstack(64 * 1024)) {
2015-09-25 10:57:26 +01:00
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
2015-09-21 23:05:36 +01:00
return;
}
goto restart;
}
2015-10-22 00:53:26 +01:00
static Int fetch_next_static_clause(PredEntry *pe, yamop *i_code, Term th,
Term tb, Term tr, yamop *cp_ptr,
int first_time) {
2015-09-21 23:05:36 +01:00
CACHE_REGS
StaticClause *cl;
Term rtn;
Term Terms[3];
Terms[0] = th;
Terms[1] = tb;
Terms[2] = tr;
2015-10-22 00:53:26 +01:00
cl = (StaticClause *)Yap_FollowIndexingCode(
pe, i_code, Terms, NEXTOP(PredStaticClause->CodeOfPred, Otapl), cp_ptr);
2015-09-21 23:05:36 +01:00
th = Deref(Terms[0]);
tb = Deref(Terms[1]);
tr = Deref(Terms[2]);
2016-01-03 01:27:36 +00:00
/*
don't do this!! I might have stored a choice-point and changed ASP
2015-09-21 23:05:36 +01:00
Yap_RecoverSlots(3);
*/
if (cl == NULL) {
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
2016-01-03 01:27:36 +00:00
return false;
}
2015-09-21 23:05:36 +01:00
if (pe->PredFlags & MegaClausePredFlag) {
yamop *code = (yamop *)cl;
2015-10-22 00:53:26 +01:00
rtn = Yap_MkMegaRefTerm(pe, code);
if (!Yap_unify(tb, MkAtomTerm(AtomTrue)) || !Yap_unify(tr, rtn)) {
UNLOCKPE(45, pe);
return FALSE;
2015-09-21 23:05:36 +01:00
}
if (pe->ArityOfPE) {
Functor f = FunctorOfTerm(th);
arity_t arity = ArityOfFunctor(f), i;
2015-10-22 00:53:26 +01:00
CELL *pt = RepAppl(th) + 1;
2015-10-22 00:53:26 +01:00
for (i = 0; i < arity; i++) {
XREGS[i + 1] = pt[i];
2015-09-21 23:05:36 +01:00
}
/* don't need no ENV */
if (first_time && P->opc != EXECUTE_CPRED_OP_CODE) {
2015-10-22 00:53:26 +01:00
CP = P;
ENV = YENV;
YENV = ASP;
YENV[E_CB] = (CELL)B;
}
2015-09-21 23:05:36 +01:00
P = code;
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
2015-09-21 23:05:36 +01:00
return TRUE;
}
2015-09-21 23:05:36 +01:00
rtn = Yap_MkStaticRefTerm(cl, pe);
if (cl->ClFlags & FactMask) {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(tb, MkAtomTerm(AtomTrue)) || !Yap_unify(tr, rtn)) {
UNLOCKPE(45, pe);
2015-09-21 23:05:36 +01:00
return FALSE;
}
2015-09-21 23:05:36 +01:00
if (pe->ArityOfPE) {
Functor f = FunctorOfTerm(th);
arity_t arity = ArityOfFunctor(f), i;
2015-10-22 00:53:26 +01:00
CELL *pt = RepAppl(th) + 1;
2015-10-22 00:53:26 +01:00
for (i = 0; i < arity; i++) {
XREGS[i + 1] = pt[i];
2015-09-21 23:05:36 +01:00
}
/* don't need no ENV */
2015-10-22 00:53:26 +01:00
if (first_time && P->opc != EXECUTE_CPRED_OP_CODE) {
CP = P;
ENV = YENV;
YENV = ASP;
YENV[E_CB] = (CELL)B;
2015-09-21 23:05:36 +01:00
}
P = cl->ClCode;
}
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
return true;
} else {
2015-09-21 23:05:36 +01:00
Term t;
if (!(pe->PredFlags & SourcePredFlag)) {
/* no source */
rtn = Yap_MkStaticRefTerm(cl, pe);
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
2015-09-21 23:05:36 +01:00
return Yap_unify(tr, rtn);
}
while ((t = Yap_FetchClauseTermFromDB(cl->usc.ClSource)) == 0L) {
if (first_time) {
2015-10-22 00:53:26 +01:00
if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_growglobal(NULL)) {
Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil,
LOCAL_ErrorMessage);
UNLOCKPE(45, pe);
return FALSE;
}
} else {
LOCAL_Error_TYPE = YAP_NO_ERROR;
ARG5 = th;
ARG6 = tb;
ARG7 = tr;
if (!Yap_gc(7, ENV, gc_P(P, CP))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
UNLOCKPE(45, pe);
return FALSE;
}
th = ARG5;
tb = ARG6;
tr = ARG7;
}
2015-09-21 23:05:36 +01:00
} else {
2015-10-22 00:53:26 +01:00
LOCAL_Error_TYPE = YAP_NO_ERROR;
ARG6 = th;
ARG7 = tb;
ARG8 = tr;
if (!Yap_gcl(LOCAL_Error_Size, 8, ENV, CP)) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
UNLOCKPE(45, pe);
return FALSE;
}
th = ARG6;
tb = ARG7;
tr = ARG8;
2015-09-21 23:05:36 +01:00
}
}
rtn = Yap_MkStaticRefTerm(cl, pe);
2015-10-22 00:53:26 +01:00
UNLOCKPE(45, pe);
2015-09-21 23:05:36 +01:00
if (!IsApplTerm(t) || FunctorOfTerm(t) != FunctorAssert) {
2015-10-22 00:53:26 +01:00
return (Yap_unify(th, t) && Yap_unify(tb, MkAtomTerm(AtomTrue)) &&
Yap_unify(tr, rtn));
} else {
2015-10-22 00:53:26 +01:00
return (Yap_unify(th, ArgOfTerm(1, t)) &&
Yap_unify(tb, ArgOfTerm(2, t)) && Yap_unify(tr, rtn));
}
}
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_static_clause(USES_REGS1) {
PredEntry *pe;
2015-09-21 23:05:36 +01:00
Term t1 = Deref(ARG1);
2015-10-22 00:53:26 +01:00
yamop *new_cp;
2015-04-13 13:28:17 +01:00
2015-09-21 23:05:36 +01:00
if (P->opc == EXECUTE_CPRED_OP_CODE) {
new_cp = CP;
} else {
new_cp = P;
}
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(t1, Deref(ARG2), "clause/3");
2015-09-21 23:05:36 +01:00
if (pe == NULL || EndOfPAEntr(pe))
2016-01-03 01:27:36 +00:00
return false;
2015-10-22 00:53:26 +01:00
PELOCK(46, pe);
return fetch_next_static_clause(pe, pe->CodeOfPred, ARG1, ARG3, ARG4, new_cp,
2016-01-03 01:27:36 +00:00
true);
}
2015-10-22 00:53:26 +01:00
static Int /* $hidden_predicate(P) */
p_continue_static_clause(USES_REGS1) {
2015-09-21 23:05:36 +01:00
PredEntry *pe = (PredEntry *)IntegerOfTerm(Deref(ARG1));
yamop *ipc = (yamop *)IntegerOfTerm(ARG2);
2010-01-15 16:15:36 +00:00
2015-10-22 00:53:26 +01:00
PELOCK(48, pe);
return fetch_next_static_clause(pe, ipc, Deref(ARG3), ARG4, ARG5, B->cp_ap,
2016-01-03 01:27:36 +00:00
false);
}
2015-10-22 00:53:26 +01:00
static UInt compute_dbcl_size(arity_t arity) {
2011-04-30 01:16:40 +01:00
UInt sz;
2015-10-22 00:53:26 +01:00
switch (arity) {
2011-04-30 01:16:40 +01:00
case 2:
2015-10-22 00:53:26 +01:00
sz = (UInt)NEXTOP((yamop *)NULL, cc);
2011-04-30 01:16:40 +01:00
break;
case 3:
2015-10-22 00:53:26 +01:00
sz = (UInt)NEXTOP((yamop *)NULL, ccc);
2011-04-30 01:16:40 +01:00
break;
case 4:
2015-10-22 00:53:26 +01:00
sz = (UInt)NEXTOP((yamop *)NULL, cccc);
2011-04-30 01:16:40 +01:00
break;
case 5:
2015-10-22 00:53:26 +01:00
sz = (UInt)NEXTOP((yamop *)NULL, ccccc);
2011-04-30 01:16:40 +01:00
break;
case 6:
2015-10-22 00:53:26 +01:00
sz = (UInt)NEXTOP((yamop *)NULL, cccccc);
2011-04-30 01:16:40 +01:00
break;
default:
2015-10-22 00:53:26 +01:00
sz = arity * (UInt)NEXTOP((yamop *)NULL, xc);
2015-04-13 13:28:17 +01:00
break;
2011-04-30 01:16:40 +01:00
}
2015-10-22 00:53:26 +01:00
return (UInt)NEXTOP((yamop *)sz, p);
2011-04-30 01:16:40 +01:00
}
2015-10-22 00:53:26 +01:00
#define DerefAndCheck(t, V) \
t = Deref(V); \
if (IsVarTerm(t) || !(IsAtomOrIntTerm(t))) \
Yap_Error(TYPE_ERROR_ATOM, t0, "load_db");
2011-04-30 01:16:40 +01:00
2015-10-22 00:53:26 +01:00
static int store_dbcl_size(yamop *pc, arity_t arity, Term t0, PredEntry *pe) {
2011-04-30 01:16:40 +01:00
Term t;
2015-10-22 00:53:26 +01:00
CELL *tp = RepAppl(t0) + 1;
switch (arity) {
2011-04-30 01:16:40 +01:00
case 2:
pc->opc = Yap_opcode(_get_2atoms);
DerefAndCheck(t, tp[0]);
2014-05-30 01:06:09 +01:00
pc->y_u.cc.c1 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[1]);
2014-05-30 01:06:09 +01:00
pc->y_u.cc.c2 = t;
2015-10-22 00:53:26 +01:00
pc = NEXTOP(pc, cc);
2011-04-30 01:16:40 +01:00
break;
case 3:
pc->opc = Yap_opcode(_get_3atoms);
DerefAndCheck(t, tp[0]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccc.c1 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[1]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccc.c2 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[2]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccc.c3 = t;
2015-10-22 00:53:26 +01:00
pc = NEXTOP(pc, ccc);
2011-04-30 01:16:40 +01:00
break;
case 4:
pc->opc = Yap_opcode(_get_4atoms);
DerefAndCheck(t, tp[0]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccc.c1 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[1]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccc.c2 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[2]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccc.c3 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[3]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccc.c4 = t;
2015-10-22 00:53:26 +01:00
pc = NEXTOP(pc, cccc);
2011-04-30 01:16:40 +01:00
break;
case 5:
pc->opc = Yap_opcode(_get_5atoms);
DerefAndCheck(t, tp[0]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccccc.c1 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[1]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccccc.c2 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[2]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccccc.c3 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[3]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccccc.c4 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[4]);
2014-05-30 01:06:09 +01:00
pc->y_u.ccccc.c5 = t;
2015-10-22 00:53:26 +01:00
pc = NEXTOP(pc, ccccc);
2011-04-30 01:16:40 +01:00
break;
case 6:
pc->opc = Yap_opcode(_get_6atoms);
DerefAndCheck(t, tp[0]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccccc.c1 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[1]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccccc.c2 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[2]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccccc.c3 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[3]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccccc.c4 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[4]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccccc.c5 = t;
2011-04-30 01:16:40 +01:00
DerefAndCheck(t, tp[5]);
2014-05-30 01:06:09 +01:00
pc->y_u.cccccc.c6 = t;
2015-10-22 00:53:26 +01:00
pc = NEXTOP(pc, cccccc);
2011-04-30 01:16:40 +01:00
break;
2015-10-22 00:53:26 +01:00
default: {
arity_t i;
for (i = 0; i < arity; i++) {
pc->opc = Yap_opcode(_get_atom);
2011-04-30 01:16:40 +01:00
#if PRECOMPUTE_REGADDRESS
2015-10-22 00:53:26 +01:00
pc->y_u.xc.x = (CELL)(XREGS + (i + 1));
2011-04-30 01:16:40 +01:00
#else
2015-10-22 00:53:26 +01:00
pc->y_u.xc.x = i + 1;
2011-04-30 01:16:40 +01:00
#endif
2015-10-22 00:53:26 +01:00
DerefAndCheck(t, tp[0]);
pc->y_u.xc.c = t;
tp++;
pc = NEXTOP(pc, xc);
2011-04-30 01:16:40 +01:00
}
2015-10-22 00:53:26 +01:00
} break;
2011-04-30 01:16:40 +01:00
}
pc->opc = Yap_opcode(_procceed);
2014-05-30 01:06:09 +01:00
pc->y_u.p.p = pe;
2011-04-30 01:16:40 +01:00
return TRUE;
}
2015-04-13 13:28:17 +01:00
static Int
2015-10-22 00:53:26 +01:00
p_dbload_get_space(USES_REGS1) { /* '$number_of_clauses'(Predicate,M,N) */
Term t = Deref(ARG1);
Term mod = Deref(ARG2);
Term tn = Deref(ARG3);
arity_t arity;
Prop pe;
PredEntry *ap;
2011-04-30 01:16:40 +01:00
UInt sz;
MegaClause *mcl;
yamop *ptr;
UInt ncls;
UInt required;
2015-10-22 00:53:26 +01:00
if (IsVarTerm(mod) || !IsAtomTerm(mod)) {
return (FALSE);
2011-04-30 01:16:40 +01:00
}
if (IsAtomTerm(t)) {
Atom a = AtomOfTerm(t);
arity = 0;
pe = PredPropByAtom(a, mod);
} else if (IsApplTerm(t)) {
register Functor f = FunctorOfTerm(t);
arity = ArityOfFunctor(f);
pe = PredPropByFunc(f, mod);
} else {
return FALSE;
}
if (EndOfPAEntr(pe))
return FALSE;
ap = RepPredProp(pe);
2015-10-22 00:53:26 +01:00
if (ap->PredFlags & (DynamicPredFlag | LogUpdatePredFlag
2011-04-30 01:16:40 +01:00
#ifdef TABLING
2015-10-22 00:53:26 +01:00
| TabledPredFlag
2011-04-30 01:16:40 +01:00
#endif /* TABLING */
2015-10-22 00:53:26 +01:00
)) {
Yap_Error(PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, t,
"dbload_get_space/4");
2011-04-30 01:16:40 +01:00
return FALSE;
}
2015-10-22 00:53:26 +01:00
if (IsVarTerm(tn) || !IsIntegerTerm(tn)) {
2011-04-30 01:16:40 +01:00
return FALSE;
}
ncls = IntegerOfTerm(tn);
if (ncls <= 1) {
return FALSE;
}
2015-10-22 00:53:26 +01:00
sz = compute_dbcl_size(arity);
required = sz * ncls + sizeof(MegaClause) + (UInt)NEXTOP((yamop *)NULL, l);
2011-04-30 01:16:40 +01:00
#ifdef DEBUG
total_megaclause += required;
nof_megaclauses++;
#endif
while (!(mcl = (MegaClause *)Yap_AllocCodeSpace(required))) {
if (!Yap_growheap(FALSE, required, NULL)) {
/* just fail, the system will keep on going */
return FALSE;
}
}
Yap_ClauseSpace += required;
/* cool, it's our turn to do the conversion */
mcl->ClFlags = MegaMask;
2015-10-22 00:53:26 +01:00
mcl->ClSize = sz * ncls;
2011-04-30 01:16:40 +01:00
mcl->ClPred = ap;
mcl->ClItemSize = sz;
mcl->ClNext = NULL;
2015-10-22 00:53:26 +01:00
ap->cs.p_code.FirstClause = ap->cs.p_code.LastClause = mcl->ClCode;
2013-09-28 18:20:04 +01:00
ap->PredFlags |= (MegaClausePredFlag);
2011-04-30 01:16:40 +01:00
ap->cs.p_code.NOfClauses = ncls;
2015-10-22 00:53:26 +01:00
if (ap->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
2011-04-30 01:16:40 +01:00
ap->OpcodeOfPred = Yap_opcode(_spy_pred);
} else {
ap->OpcodeOfPred = INDEX_OPCODE;
}
2015-10-22 00:53:26 +01:00
ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred =
(yamop *)(&(ap->OpcodeOfPred));
ptr = (yamop *)((ADDR)mcl->ClCode + ncls * sz);
2011-04-30 01:16:40 +01:00
ptr->opc = Yap_opcode(_Ystop);
return Yap_unify(ARG4, MkIntegerTerm((Int)mcl));
}
2015-10-22 00:53:26 +01:00
static Int p_dbassert(USES_REGS1) { /* '$number_of_clauses'(Predicate,M,N) */
Term thandle = Deref(ARG2);
Term tn = Deref(ARG3);
PredEntry *pe;
MegaClause *mcl;
Int n;
2011-04-30 01:16:40 +01:00
2015-10-22 00:53:26 +01:00
if (IsVarTerm(thandle) || !IsIntegerTerm(thandle)) {
2011-04-30 01:16:40 +01:00
return FALSE;
}
mcl = (MegaClause *)IntegerOfTerm(thandle);
2015-10-22 00:53:26 +01:00
if (IsVarTerm(tn) || !IsIntegerTerm(tn)) {
2011-04-30 01:16:40 +01:00
return FALSE;
}
n = IntegerOfTerm(tn);
pe = mcl->ClPred;
2015-10-22 00:53:26 +01:00
return store_dbcl_size((yamop *)((ADDR)mcl->ClCode + n * (mcl->ClItemSize)),
pe->ArityOfPE, Deref(ARG1), pe);
2011-04-30 01:16:40 +01:00
}
#define CL_PROP_ERASED 0
2015-10-22 00:53:26 +01:00
#define CL_PROP_PRED 1
#define CL_PROP_FILE 2
#define CL_PROP_FACT 3
#define CL_PROP_LINE 4
#define CL_PROP_STREAM 5
/* instance(+Ref,?Term) */
2015-10-22 00:53:26 +01:00
static Int instance_property(USES_REGS1) {
Term t1 = Deref(ARG1);
DBRef dbr;
Int op = IntOfTerm(Deref(ARG2));
if (IsVarTerm(t1) || !IsDBRefTerm(t1)) {
if (IsApplTerm(t1)) {
if (FunctorOfTerm(t1) == FunctorStaticClause) {
2015-10-22 00:53:26 +01:00
StaticClause *cl = Yap_ClauseFromTerm(t1);
if (op == CL_PROP_ERASED) {
if (cl->ClFlags & ErasedMask) {
if (!Yap_unify(ARG3, MkAtomTerm(AtomTrue)))
return FALSE;
} else {
if (!Yap_unify(ARG3, MkAtomTerm(AtomFalse)))
return FALSE;
}
}
if (op == CL_PROP_PRED || op == CL_PROP_FILE || op == CL_PROP_STREAM) {
PredEntry *ap = (PredEntry *)IntegerOfTerm(ArgOfTerm(2, t1));
if (!ap) {
return FALSE;
}
if (op == CL_PROP_FILE) {
if (ap->src.OwnerFile)
return Yap_unify(ARG3, MkAtomTerm(ap->src.OwnerFile));
else
return FALSE;
} else {
Term t[2];
if (ap->ArityOfPE == 0) {
t[1] = MkAtomTerm((Atom)ap->FunctorOfPred);
} else {
Functor nf = ap->FunctorOfPred;
arity_t arity = ArityOfFunctor(nf);
Atom name = NameOfFunctor(nf);
t[0] = MkAtomTerm(name);
t[1] = MkIntegerTerm(arity);
t[1] = Yap_MkApplTerm(FunctorSlash, 2, t);
}
if (ap->ModuleOfPred == PROLOG_MODULE) {
t[0] = MkAtomTerm(AtomProlog);
} else {
t[0] = ap->ModuleOfPred;
}
return Yap_unify(ARG3, Yap_MkApplTerm(FunctorModule, 2, t));
}
}
if (op == CL_PROP_FACT) {
if (cl->ClFlags & FactMask) {
return Yap_unify(ARG3, MkAtomTerm(AtomTrue));
} else {
return Yap_unify(ARG3, MkAtomTerm(AtomFalse));
}
}
if (op == CL_PROP_LINE) {
if (cl->ClFlags & FactMask) {
return Yap_unify(ARG3, MkIntTerm(cl->usc.ClLine));
} else if (cl->ClFlags & SrcMask) {
return Yap_unify(ARG3, MkIntTerm(cl->usc.ClSource->ag.line_number));
} else
return Yap_unify(ARG3, MkIntTerm(0));
}
} else if (FunctorOfTerm(t1) == FunctorMegaClause) {
PredEntry *ap = (PredEntry *)IntegerOfTerm(ArgOfTerm(1, t1));
MegaClause *mcl = ClauseCodeToMegaClause(ap->cs.p_code.FirstClause);
if (op == CL_PROP_ERASED) {
return FALSE;
}
if (op == CL_PROP_PRED || op == CL_PROP_FILE || op == CL_PROP_STREAM) {
if (op == CL_PROP_FILE) {
if (ap->src.OwnerFile)
return Yap_unify(ARG3, MkAtomTerm(ap->src.OwnerFile));
else
return FALSE;
} else {
Functor nf = ap->FunctorOfPred;
arity_t arity = ArityOfFunctor(nf);
Atom name = NameOfFunctor(nf);
Term t[2];
t[0] = MkAtomTerm(name);
t[1] = MkIntegerTerm(arity);
t[1] = Yap_MkApplTerm(FunctorSlash, 2, t);
if (ap->ModuleOfPred == PROLOG_MODULE) {
t[0] = MkAtomTerm(AtomProlog);
} else {
t[0] = ap->ModuleOfPred;
}
return Yap_unify(ARG3, Yap_MkApplTerm(FunctorModule, 2, t));
}
}
if (op == CL_PROP_FACT) {
return Yap_unify(ARG3, MkAtomTerm(AtomTrue));
}
if (op == CL_PROP_LINE) {
return Yap_unify(ARG3, MkIntTerm(mcl->ClLine));
}
}
}
} else if ((dbr = DBRefOfTerm(t1))->Flags & LogUpdMask) {
LogUpdClause *cl = (LogUpdClause *)dbr;
if (op == CL_PROP_ERASED) {
if (cl->ClFlags & ErasedMask) {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG3, MkAtomTerm(AtomTrue)))
return FALSE;
} else {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG3, MkAtomTerm(AtomFalse)))
return FALSE;
}
}
if (op == CL_PROP_PRED || op == CL_PROP_FILE) {
PredEntry *ap = cl->ClPred;
Term t[2];
if (op == CL_PROP_FILE) {
2015-10-22 00:53:26 +01:00
if (ap->src.OwnerFile)
return Yap_unify(ARG3, MkAtomTerm(ap->src.OwnerFile));
else
return FALSE;
}
if (ap->ArityOfPE == 0) {
2015-10-22 00:53:26 +01:00
t[1] = MkAtomTerm((Atom)ap->FunctorOfPred);
} else {
2015-10-22 00:53:26 +01:00
Functor nf = ap->FunctorOfPred;
arity_t arity = ArityOfFunctor(nf);
Atom name = NameOfFunctor(nf);
2015-04-13 13:28:17 +01:00
2015-10-22 00:53:26 +01:00
t[0] = MkAtomTerm(name);
t[1] = MkIntegerTerm(arity);
t[1] = Yap_MkApplTerm(FunctorSlash, 2, t);
}
if (ap->ModuleOfPred == PROLOG_MODULE) {
2015-10-22 00:53:26 +01:00
t[0] = MkAtomTerm(AtomProlog);
} else {
2015-10-22 00:53:26 +01:00
t[0] = ap->ModuleOfPred;
}
2015-10-22 00:53:26 +01:00
return Yap_unify(ARG3, Yap_MkApplTerm(FunctorModule, 2, t));
}
if (op == CL_PROP_FACT) {
if (cl->ClFlags & FactMask) {
2015-10-22 00:53:26 +01:00
return Yap_unify(ARG3, MkAtomTerm(AtomTrue));
} else {
2015-10-22 00:53:26 +01:00
return Yap_unify(ARG3, MkAtomTerm(AtomFalse));
}
}
if (op == CL_PROP_LINE) {
if (cl->ClFlags & FactMask) {
2015-10-22 00:53:26 +01:00
return Yap_unify(ARG3, MkIntTerm(cl->lusl.ClLine));
} else if (cl->ClFlags & SrcMask) {
return Yap_unify(ARG3, MkIntTerm(cl->lusl.ClSource->ag.line_number));
} else
2015-09-21 23:05:36 +01:00
return Yap_unify(ARG3, MkIntTerm(0));
}
}
return FALSE;
}
2011-04-30 01:16:40 +01:00
2015-10-22 00:53:26 +01:00
static Int p_nth_instance(USES_REGS1) {
PredEntry *pe;
arity_t pred_arity;
Functor pred_f;
Term pred_module;
Term t4 = Deref(ARG4);
if (IsVarTerm(t4)) {
// we must know I or count;
2015-10-22 00:53:26 +01:00
Term TCount;
Int Count;
TCount = Deref(ARG3);
if (IsVarTerm(TCount)) {
return FALSE; // backtrack?
}
if (!IsIntegerTerm(TCount)) {
Yap_Error(TYPE_ERROR_INTEGER, TCount, "nth_instance/3");
return FALSE;
}
Count = IntegerOfTerm(TCount);
if (Count <= 0) {
2015-04-13 13:28:17 +01:00
if (Count)
2015-10-22 00:53:26 +01:00
Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, TCount, "nth_clause/3");
else
2015-10-22 00:53:26 +01:00
Yap_Error(DOMAIN_ERROR_NOT_ZERO, TCount, "nth_clause/3");
return FALSE;
}
2016-09-27 18:31:12 +01:00
pe = Yap_get_pred(Deref(ARG1), Deref(ARG2), "nth_clause/3");
if (pe) {
2015-10-22 00:53:26 +01:00
PELOCK(47, pe);
}
if (Deref(ARG2) == IDB_MODULE) {
2015-10-22 00:53:26 +01:00
return Yap_db_nth_recorded(pe, Count PASS_REGS);
} else {
Int CurSlot, sl4;
arity_t i;
void *cl0;
if (!pe)
2015-10-22 00:53:26 +01:00
return FALSE;
if (!(pe->PredFlags & (SourcePredFlag | LogUpdatePredFlag))) {
UNLOCK(pe->PELock);
return FALSE;
}
2015-10-22 00:53:26 +01:00
CurSlot = Yap_StartSlots();
/* I have pe and n */
2015-10-22 00:53:26 +01:00
sl4 = Yap_InitSlot(ARG4);
/* in case we have to index or to expand code */
for (i = 1; i <= pe->ArityOfPE; i++) {
2015-10-22 00:53:26 +01:00
XREGS[i] = MkVarTerm();
}
2015-10-22 00:53:26 +01:00
if (pe->OpcodeOfPred == INDEX_OPCODE) {
IPred(pe, 0, CP);
}
cl0 = Yap_NthClause(pe, Count);
2015-10-22 00:53:26 +01:00
ARG4 = Yap_GetFromSlot(sl4);
2015-04-13 13:28:17 +01:00
LOCAL_CurSlot = CurSlot;
if (cl0 == NULL) {
2015-10-22 00:53:26 +01:00
UNLOCK(pe->PELock);
return FALSE;
}
if (pe->PredFlags & LogUpdatePredFlag) {
2015-10-22 00:53:26 +01:00
LogUpdClause *cl = cl0;
2015-04-13 13:28:17 +01:00
#if MULTIPLE_STACKS
2015-10-22 00:53:26 +01:00
TRAIL_CLREF(cl); /* So that fail will erase it */
INC_CLREF_COUNT(cl);
#else
2015-10-22 00:53:26 +01:00
if (!(cl->ClFlags & InUseMask)) {
cl->ClFlags |= InUseMask;
TRAIL_CLREF(cl); /* So that fail will erase it */
}
#endif
2015-10-22 00:53:26 +01:00
UNLOCK(pe->PELock);
return Yap_unify(MkDBRefTerm((DBRef)cl), ARG4);
} else if (pe->PredFlags & MegaClausePredFlag) {
2015-10-22 00:53:26 +01:00
MegaClause *mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause);
if (mcl->ClFlags & ExoMask) {
UNLOCK(pe->PELock);
return Yap_unify(Yap_MkExoRefTerm(pe, Count - 1), ARG4);
}
/* fast access to nth element, all have same size */
UNLOCK(pe->PELock);
return Yap_unify(Yap_MkMegaRefTerm(pe, cl0), ARG4);
} else {
2015-10-22 00:53:26 +01:00
UNLOCK(pe->PELock);
return Yap_unify(Yap_MkStaticRefTerm(cl0, pe), ARG4);
}
}
}
/* t4 is bound, we have a reference */
if (IsDBRefTerm(t4)) {
DBRef ref = DBRefOfTerm(t4);
if (ref->Flags & LogUpdMask) {
LogUpdClause *cl = (LogUpdClause *)ref;
LogUpdClause *ocl;
UInt icl = 0;
pe = cl->ClPred;
2015-10-22 00:53:26 +01:00
PELOCK(66, pe);
if (cl->ClFlags & ErasedMask) {
2015-10-22 00:53:26 +01:00
UNLOCK(pe->PELock);
return FALSE;
}
ocl = ClauseCodeToLogUpdClause(pe->cs.p_code.FirstClause);
do {
2015-10-22 00:53:26 +01:00
icl++;
if (cl == ocl)
break;
ocl = ocl->ClNext;
} while (ocl != NULL);
UNLOCK(pe->PELock);
if (ocl == NULL) {
2015-10-22 00:53:26 +01:00
return FALSE;
}
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG3, MkIntegerTerm(icl))) {
return FALSE;
}
} else {
return Yap_unify_immediate_ref(ref PASS_REGS);
}
} else if (IsApplTerm(t4)) {
Functor f = FunctorOfTerm(t4);
2015-04-13 13:28:17 +01:00
if (f == FunctorStaticClause) {
StaticClause *cl = Yap_ClauseFromTerm(t4), *cl0;
pe = (PredEntry *)IntegerOfTerm(ArgOfTerm(2, t4));
Int i;
if (!pe) {
2015-10-22 00:53:26 +01:00
return FALSE;
}
2015-10-22 00:53:26 +01:00
if (!pe->cs.p_code.NOfClauses)
return FALSE;
cl0 = ClauseCodeToStaticClause(pe->cs.p_code.FirstClause);
2015-10-22 00:53:26 +01:00
// linear scan
for (i = 1; i < pe->cs.p_code.NOfClauses; i++) {
2015-10-22 00:53:26 +01:00
if (cl0 == cl) {
if (!Yap_unify(MkIntTerm(i), ARG3))
return FALSE;
break;
}
}
} else if (f == FunctorMegaClause) {
MegaClause *mcl;
yamop *cl = Yap_MegaClauseFromTerm(t4);
Int i;
pe = Yap_MegaClausePredicateFromTerm(t4);
mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause);
2015-10-22 00:53:26 +01:00
i = ((char *)cl - (char *)mcl->ClCode) / mcl->ClItemSize;
if (!Yap_unify(MkIntTerm(i), ARG3))
2015-10-22 00:53:26 +01:00
return FALSE;
} else if (f == FunctorExoClause) {
Int i;
pe = Yap_ExoClausePredicateFromTerm(t4);
i = Yap_ExoClauseFromTerm(t4);
2015-10-22 00:53:26 +01:00
if (!Yap_unify(MkIntTerm(i + 1), ARG3)) {
return FALSE;
}
} else {
Yap_Error(TYPE_ERROR_REFERENCE, t4, "nth_clause/3");
return FALSE;
}
} else {
Yap_Error(TYPE_ERROR_REFERENCE, t4, "nth_clause/3");
return FALSE;
}
pred_module = pe->ModuleOfPred;
if (pred_module != IDB_MODULE) {
pred_f = pe->FunctorOfPred;
pred_arity = pe->ArityOfPE;
} else {
if (pe->PredFlags & NumberDBPredFlag) {
pred_f = (Functor)MkIntegerTerm(pe->src.IndxId);
pred_arity = 0;
} else {
pred_f = pe->FunctorOfPred;
if (pe->PredFlags & AtomDBPredFlag) {
2015-10-22 00:53:26 +01:00
pred_arity = 0;
} else {
2015-10-22 00:53:26 +01:00
pred_arity = ArityOfFunctor(pred_f);
}
}
}
if (pred_arity) {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG1, Yap_MkNewApplTerm(pred_f, pred_arity)))
return FALSE;
} else {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG1, MkAtomTerm((Atom)pred_f)))
return FALSE;
}
if (pred_module == PROLOG_MODULE) {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG2, TermProlog))
return FALSE;
} else {
2015-10-22 00:53:26 +01:00
if (!Yap_unify(ARG2, pred_module))
return FALSE;
2015-04-13 13:28:17 +01:00
}
return TRUE;
}
2015-10-22 00:53:26 +01:00
static Int including(USES_REGS1) {
2015-09-21 23:05:36 +01:00
bool rc = Yap_unify(ARG1, LOCAL_Including);
if (!rc)
return FALSE;
LOCAL_Including = Deref(ARG2);
2015-10-22 00:53:26 +01:00
return true;
2015-09-21 23:05:36 +01:00
}
2015-10-22 00:53:26 +01:00
static Int predicate_flags(
USES_REGS1) { /* $predicate_flags(+Functor,+Mod,?OldFlags,?NewFlags) */
2015-06-19 01:30:13 +01:00
PredEntry *pe;
pred_flags_t newFl;
Term t1 = Deref(ARG1);
Term mod = Deref(ARG2);
if (IsVarTerm(mod) || !IsAtomTerm(mod)) {
2016-01-03 01:27:36 +00:00
return false;
2015-06-19 01:30:13 +01:00
}
if (IsVarTerm(t1))
return (FALSE);
if (IsAtomTerm(t1)) {
while ((pe = RepPredProp(PredPropByAtom(AtomOfTerm(t1), mod))) == NULL) {
if (!Yap_growheap(FALSE, 0, NULL)) {
2015-09-25 10:57:26 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, ARG1, "while generating new predicate");
2015-06-19 01:30:13 +01:00
return FALSE;
}
t1 = Deref(ARG1);
mod = Deref(ARG2);
}
} else if (IsApplTerm(t1)) {
Functor funt = FunctorOfTerm(t1);
while ((pe = RepPredProp(PredPropByFunc(funt, mod))) == NULL) {
if (!Yap_growheap(FALSE, 0, NULL)) {
2015-09-25 10:57:26 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, ARG1, "while generating new predicate");
2015-06-19 01:30:13 +01:00
return FALSE;
}
t1 = Deref(ARG1);
mod = Deref(ARG2);
}
} else
return (FALSE);
if (EndOfPAEntr(pe))
return (FALSE);
PELOCK(92, pe);
if (!Yap_unify_constant(ARG3, MkIntegerTerm(pe->PredFlags))) {
UNLOCK(pe->PELock);
return (FALSE);
}
ARG4 = Deref(ARG4);
if (IsVarTerm(ARG4)) {
UNLOCK(pe->PELock);
return (TRUE);
} else if (!IsIntegerTerm(ARG4)) {
Term te = Yap_Eval(ARG4);
if (IsIntegerTerm(te)) {
newFl = IntegerOfTerm(te);
} else {
UNLOCK(pe->PELock);
Yap_Error(TYPE_ERROR_INTEGER, ARG4, "flags");
return (FALSE);
}
} else
newFl = IntegerOfTerm(ARG4);
pe->PredFlags = newFl;
UNLOCK(pe->PELock);
return TRUE;
}
2016-01-03 01:27:36 +00:00
static bool pred_flag_clause(Functor f, Term mod, const char *name,
pred_flags_t val USES_REGS) {
Term tn;
Term s[2];
s[0] = MkAtomTerm(Yap_LookupAtom(name));
#if SIZEOF_INT_P == 8
s[1] = MkIntegerTerm(val);
#elif USE_GMP
{
2016-03-30 17:35:03 +01:00
char text[64];
2016-01-03 01:27:36 +00:00
MP_INT rop;
#ifdef _WIN32
2016-03-30 17:35:03 +01:00
snprintf(text, 64, "%I64d", (long long int)val);
2016-01-03 01:27:36 +00:00
#elif HAVE_SNPRINTF
2016-03-30 17:35:03 +01:00
snprintf(text, 64, "%lld", (long long int)val);
2016-01-03 01:27:36 +00:00
#else
2016-03-30 17:35:03 +01:00
sprintf(text, "%lld", (long long int)val);
2016-01-03 01:27:36 +00:00
#endif
2016-03-30 17:35:03 +01:00
mpz_init_set_str(&rop, text, 10);
s[1] = Yap_MkBigIntTerm((void *)&rop);
2016-01-03 01:27:36 +00:00
}
#endif
tn = Yap_MkApplTerm(f, 2, s);
yamop *code_adr =
Yap_cclause(tn, 2, mod, tn); /* vsc: give the number of arguments to
cclause() in case there is a overflow */
if (LOCAL_ErrorMessage) {
return false;
}
return Yap_addclause(tn, code_adr, TermAssertz, mod, NULL);
2016-01-03 01:27:36 +00:00
}
struct pred_entry *Yap_MkLogPred(struct pred_entry *pe) {
pe->PredFlags = LogUpdatePredFlag;
pe->OpcodeOfPred = FAIL_OPCODE;
pe->cs.p_code.TrueCodeOfPred = pe->CodeOfPred = FAILCODE;
return pe;
}
static Int init_pred_flag_vals(USES_REGS1) {
Functor f;
Term mod = Deref(ARG2), t = Deref(ARG1);
if (IsAtomTerm(t)) {
return false;
} else if (IsApplTerm(t)) {
f = FunctorOfTerm(t);
arity_t Arity = ArityOfFunctor(f);
if (Arity != 2)
return false;
} else {
return false;
}
pred_flag_clause(f, mod, "asm", AsmPredFlag PASS_REGS);
pred_flag_clause(f, mod, "atom_db", AtomDBPredFlag PASS_REGS);
pred_flag_clause(f, mod, "back_c", BackCPredFlag PASS_REGS);
pred_flag_clause(f, mod, "c", CPredFlag PASS_REGS);
pred_flag_clause(f, mod, "c_args", CArgsPredFlag PASS_REGS);
pred_flag_clause(f, mod, "compiled", CompiledPredFlag PASS_REGS);
pred_flag_clause(f, mod, "count", CountPredFlag PASS_REGS);
pred_flag_clause(f, mod, "discontiguous", DiscontiguousPredFlag PASS_REGS);
pred_flag_clause(f, mod, "immediate_update", DynamicPredFlag PASS_REGS);
pred_flag_clause(f, mod, "hidden", HiddenPredFlag PASS_REGS);
pred_flag_clause(f, mod, "in_use", InUsePredFlag PASS_REGS);
pred_flag_clause(f, mod, "indexed", IndexedPredFlag PASS_REGS);
pred_flag_clause(f, mod, "log_update", LogUpdatePredFlag PASS_REGS);
pred_flag_clause(f, mod, "mega_clause", MegaClausePredFlag PASS_REGS);
pred_flag_clause(f, mod, "meta", MetaPredFlag PASS_REGS);
pred_flag_clause(f, mod, "module_transparent",
ModuleTransparentPredFlag PASS_REGS);
pred_flag_clause(f, mod, "multi", MultiFileFlag PASS_REGS);
pred_flag_clause(f, mod, "no_spy", NoSpyPredFlag PASS_REGS);
pred_flag_clause(f, mod, "no_trace", NoTracePredFlag PASS_REGS);
pred_flag_clause(f, mod, "number_db", NumberDBPredFlag PASS_REGS);
pred_flag_clause(f, mod, "profiled", ProfiledPredFlag PASS_REGS);
pred_flag_clause(f, mod, "quasi_quotation", QuasiQuotationPredFlag PASS_REGS);
pred_flag_clause(f, mod, "safe", SafePredFlag PASS_REGS);
pred_flag_clause(f, mod, "sequential", SequentialPredFlag PASS_REGS);
pred_flag_clause(f, mod, "source", SourcePredFlag PASS_REGS);
pred_flag_clause(f, mod, "spied", SpiedPredFlag PASS_REGS);
pred_flag_clause(f, mod, "standard", StandardPredFlag PASS_REGS);
pred_flag_clause(f, mod, "swi_env", SWIEnvPredFlag PASS_REGS);
pred_flag_clause(f, mod, "sync", SyncPredFlag PASS_REGS);
pred_flag_clause(f, mod, "sys_export", SysExportPredFlag PASS_REGS);
pred_flag_clause(f, mod, "tabled", TabledPredFlag PASS_REGS);
pred_flag_clause(f, mod, "test", TestPredFlag PASS_REGS);
pred_flag_clause(f, mod, "thread_local", ThreadLocalPredFlag PASS_REGS);
pred_flag_clause(f, mod, "udi", UDIPredFlag PASS_REGS);
pred_flag_clause(f, mod, "user_c", UserCPredFlag PASS_REGS);
pred_flag_clause(f, mod, "system", SystemPredFlags PASS_REGS);
pred_flag_clause(f, mod, "foreign", ForeignPredFlags PASS_REGS);
return true;
}
2015-10-22 00:53:26 +01:00
void Yap_InitCdMgr(void) {
CACHE_REGS
Term cm = CurrentModule;
2016-01-03 01:27:36 +00:00
Yap_InitCPred("$init_pred_flag_vals", 2, init_pred_flag_vals, SyncPredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$start_consult", 3, p_startconsult,
SafePredFlag | SyncPredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$show_consult_level", 1, p_showconslultlev, SafePredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$end_consult", 0, p_endconsult, SafePredFlag | SyncPredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$set_spy", 2, p_setspy, SyncPredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$rm_spy", 2, p_rmspy, SafePredFlag | SyncPredFlag);
/* gc() may happen during compilation, hence these predicates are
2015-10-22 00:53:26 +01:00
now unsafe */
2015-06-19 01:30:13 +01:00
Yap_InitCPred("$predicate_flags", 4, predicate_flags, SyncPredFlag);
Yap_InitCPred("$compile", 5, p_compile, SyncPredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$purge_clauses", 2, p_purge_clauses,
SafePredFlag | SyncPredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$is_dynamic", 2, p_is_dynamic, TestPredFlag | SafePredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$is_metapredicate", 2, p_is_metapredicate,
TestPredFlag | SafePredFlag);
Yap_InitCPred("$is_log_updatable", 2, p_is_log_updatable,
TestPredFlag | SafePredFlag);
Yap_InitCPred("$is_thread_local", 2, p_is_thread_local,
TestPredFlag | SafePredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$is_source", 2, p_is_source, TestPredFlag | SafePredFlag);
2013-01-11 16:45:14 +00:00
Yap_InitCPred("$is_exo", 2, p_is_exo, TestPredFlag | SafePredFlag);
Yap_InitCPred("$owner_file", 3, owner_file, SafePredFlag);
Yap_InitCPred("$set_owner_file", 3, p_set_owner_file, SafePredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$mk_d", 2, p_mk_d, SafePredFlag);
2014-04-06 17:06:19 +01:00
Yap_InitCPred("$sys_export", 2, p_sys_export, TestPredFlag | SafePredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$pred_exists", 2, p_pred_exists, TestPredFlag | SafePredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$number_of_clauses", 3, p_number_of_clauses,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$undefined", 2, p_undefined, SafePredFlag | TestPredFlag);
Yap_InitCPred("$undefp_handler", 2, undefp_handler,
SafePredFlag | TestPredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$optimizer_on", 0, p_optimizer_on,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$clean_up_dead_clauses", 0, p_clean_up_dead_clauses,
SyncPredFlag);
Yap_InitCPred("$optimizer_off", 0, p_optimizer_off,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$kill_dynamic", 2, p_kill_dynamic,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$new_multifile", 3, p_new_multifile,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$is_multifile", 2, p_is_multifile,
TestPredFlag | SafePredFlag);
2016-03-05 12:21:58 +00:00
Yap_InitCPred("$new_system_predicate", 3, new_system_predicate,
2016-01-03 01:27:36 +00:00
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$is_system_predicate", 2, p_is_system_predicate,
TestPredFlag | SafePredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$new_discontiguous", 3, p_new_discontiguous,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$is_discontiguous", 2, p_is_discontiguous,
TestPredFlag | SafePredFlag);
2013-12-11 01:05:51 +00:00
Yap_InitCPred("$is_no_trace", 2, p_is_no_trace, TestPredFlag | SafePredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$set_no_trace", 2, p_set_no_trace,
TestPredFlag | SafePredFlag);
Yap_InitCPred("$is_profiled", 1, p_is_profiled, SafePredFlag | SyncPredFlag);
Yap_InitCPred("$profile_info", 3, p_profile_info,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$profile_reset", 2, p_profile_reset,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$is_call_counted", 1, p_is_call_counted,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$call_count_info", 3, p_call_count_info,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$call_count_set", 6, p_call_count_set,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$call_count_reset", 0, p_call_count_reset,
SafePredFlag | SyncPredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$set_pred_module", 2, p_set_pred_module, SafePredFlag);
2014-09-22 18:09:23 +01:00
Yap_InitCPred("$set_pred_owner", 2, p_set_pred_owner, SafePredFlag);
Yap_InitCPred("$hide_predicate", 2, hide_predicate, SafePredFlag);
Yap_InitCPred("$stash_predicate", 2, p_stash_predicate, SafePredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$hidden_predicate", 2, p_hidden_predicate, SafePredFlag);
Yap_InitCPred("$log_update_clause", 4, p_log_update_clause, SyncPredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$continue_log_update_clause", 5, p_continue_log_update_clause,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$log_update_clause_erase", 4, p_log_update_clause_erase,
SyncPredFlag);
Yap_InitCPred("$continue_log_update_clause_erase", 5,
p_continue_log_update_clause_erase,
SafePredFlag | SyncPredFlag);
2012-10-19 18:10:48 +01:00
Yap_InitCPred("$static_clause", 4, p_static_clause, SyncPredFlag);
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$continue_static_clause", 5, p_continue_static_clause,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$static_pred_statistics", 5, p_static_pred_statistics,
SyncPredFlag);
Yap_InitCPred("instance_property", 3, instance_property,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$fetch_nth_clause", 4, p_nth_instance, SyncPredFlag);
2011-04-30 01:16:40 +01:00
CurrentModule = DBLOAD_MODULE;
Yap_InitCPred("dbload_get_space", 4, p_dbload_get_space, 0L);
Yap_InitCPred("dbassert", 3, p_dbassert, 0L);
CurrentModule = cm;
2015-10-22 00:53:26 +01:00
Yap_InitCPred("$predicate_erased_statistics", 5,
p_predicate_erased_statistics, SyncPredFlag);
Yap_InitCPred("$including", 2, including, SyncPredFlag | HiddenPredFlag);
2015-09-21 23:05:36 +01:00
#ifdef DEBUG
2015-09-21 23:05:36 +01:00
Yap_InitCPred("$predicate_lu_cps", 4, p_predicate_lu_cps, 0L);
#endif
}