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/arrays.c

2557 lines
72 KiB
C
Raw Normal View History

2016-09-27 18:31:12 +01: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: arrays.c *
* Last rev: *
* mods: *
* comments: Array Manipulation Routines *
* *
*************************************************************************/
2014-12-24 15:32:29 +00:00
/** @defgroup YAPArrays Named Arrays
2015-01-04 23:58:23 +00:00
@ingroup extensions
2014-09-11 20:06:57 +01:00
@{
The YAP system includes experimental support for arrays. The
support is enabled with the option `YAP_ARRAYS`.
There are two very distinct forms of arrays in YAP. The
<em>dynamic arrays</em> are a different way to access compound terms
created during the execution. Like any other terms, any bindings to
these terms and eventually the terms themselves will be destroyed during
backtracking. Our goal in supporting dynamic arrays is twofold. First,
they provide an alternative to the standard arg/3
built-in. Second, because dynamic arrays may have name that are globally
visible, a dynamic array can be visible from any point in the
program. In more detail, the clause
~~~~~
g(X) :- array_element(a,2,X).
~~~~~
will succeed as long as the programmer has used the built-in <tt>array/2</tt>
to create an array term with at least 3 elements in the current
environment, and the array was associated with the name `a`. The
element `X` is a Prolog term, so one can bind it and any such
bindings will be undone when backtracking. Note that dynamic arrays do
not have a type: each element may be any Prolog term.
The <em>static arrays</em> are an extension of the database. They provide
a compact way for manipulating data-structures formed by characters,
integers, or floats imperatively. They can also be used to provide
two-way communication between YAP and external programs through
shared memory.
In order to efficiently manage space elements in a static array must
have a type. Currently, elements of static arrays in YAP should
have one of the following predefined types:
+ `byte`: an 8-bit signed character.
+ `unsigned_byte`: an 8-bit unsigned character.
+ `int`: Prolog integers. Size would be the natural size for
the machine's architecture.
+ `float`: Prolog floating point number. Size would be equivalent
to a double in `C`.
+ `atom`: a Prolog atom.
+ `dbref`: an internal database reference.
+ `term`: a generic Prolog term. Note that this will term will
not be stored in the array itself, but instead will be stored in the
Prolog internal database.
Arrays may be <em>named</em> or <em>anonymous</em>. Most arrays will be
<em>named</em>, that is associated with an atom that will be used to find
the array. Anonymous arrays do not have a name, and they are only of
interest if the `TERM_EXTENSIONS` compilation flag is enabled. In
this case, the unification and parser are extended to replace
occurrences of Prolog terms of the form `X[I]` by run-time calls to
array_element/3, so that one can use array references instead of
extra calls to arg/3. As an example:
~~~~~
g(X,Y,Z,I,J) :- X[I] is Y[J]+Z[I].
~~~~~
should give the same results as:
~~~~~
G(X,Y,Z,I,J) :-
array_element(X,I,E1),
2016-04-26 15:33:16 +01:00
array_element(Y,J,E2),
array_element(Z,I,E3),
2014-09-11 20:06:57 +01:00
E1 is E2+E3.
~~~~~
Note that the only limitation on array size are the stack size for
dynamic arrays; and, the heap size for static (not memory mapped)
arrays. Memory mapped arrays are limited by available space in the file
system and in the virtual memory space.
The following predicates manipulate arrays:
2016-07-31 05:06:28 +01:00
2016-04-26 15:33:16 +01:00
*/
2014-09-11 20:06:57 +01:00
#include "Yap.h"
2015-06-19 00:15:39 +01:00
#include "Yatom.h"
#include "clause.h"
2017-02-20 14:21:46 +00:00
#include "YapEval.h"
#include "heapgc.h"
2016-07-31 05:06:28 +01:00
#if HAVE_ERRNO_H
#include <errno.h>
#else
extern int errno;
#endif
#if HAVE_STRING_H
#include <string.h>
#endif
#if __simplescalar__
#ifdef HAVE_MMAP
#undef HAVE_MMAP
#endif
#endif
2016-04-26 15:33:16 +01:00
static Int compile_array_refs(USES_REGS1);
static Int array_refs_compiled(USES_REGS1);
static Int sync_mmapped_arrays(USES_REGS1);
2014-09-15 09:13:50 +01:00
/**
* === Implementation Notes
2016-04-26 15:33:16 +01:00
*
* This file works together with pl/arrays.yap and arrays.h.
2016-04-26 15:33:16 +01:00
*
2015-06-19 00:15:39 +01:00
* YAP supports a very simple notion of arrays. Arrays may be
* allocated dynamically or statically:
2016-04-26 15:33:16 +01:00
*
* o anonymous arrays are created during execution and allocated
* in the heap. They have the lifetime of any other other heap
* object. Any term can be an argument to a dynamic array.
2016-04-26 15:33:16 +01:00
*
* Dynamic arrays are named as a free variable and are
2014-09-15 09:13:50 +01:00
* initialized with free variables.
2016-04-26 15:33:16 +01:00
*
* o named arrays are created during execution but allocated
* in the code space. They have the lifetime of an heap
* object. Any term can be an argument to a dynamic array.
2016-04-26 15:33:16 +01:00
*
* Named arrays are named with atoms and are initialized with
* free variables.
2016-04-26 15:33:16 +01:00
*
2014-09-15 09:13:50 +01:00
* + static arrays are allocated in the heap. Their space is
* never recovered unless explicitly said so by the
* program. Arguments to these arrays must have fixed size,
* and can only be atomic (at least for now).
2016-04-26 15:33:16 +01:00
*
* Static arrays can be named through an atom. They are
2014-09-15 09:13:50 +01:00
* initialized with [].
2016-04-26 15:33:16 +01:00
*
* Users create arrays by a declaration X array Arity. If X is an atom
* A, then this it is a static array and A's the array name, otherwise
* X refers to a dynamic array.
2016-04-26 15:33:16 +01:00
*
* As in C, arrays start counting from 0.
2016-04-26 15:33:16 +01:00
*
* Users access arrays by a token X[I] or a[I], this token can appear
* anywhere within the computation, so a[2] = X[3*4] means that the
* second element of global array a should unify with the 12th element
* of array X. The mechanism used to implement this is the same
* mechanism used to implement suspension variables.
2016-04-26 15:33:16 +01:00
*
2014-09-15 09:13:50 +01:00
* ==== Representation:
2016-04-26 15:33:16 +01:00
*
* Dynamic Arrays are represented as a compound term of arity N, where
* N is the size of the array. Even so, I will not include array bound
* checking for now.
2016-04-26 15:33:16 +01:00
*
2014-09-15 09:13:50 +01:00
* ~~~~
* |--------------------------------------------------------------|
* | $ARRAY/N|....
* |______________________________________________________________
2014-09-15 09:13:50 +01:00
* ~~~~
2016-04-26 15:33:16 +01:00
*
* Unbound Var is used as a place to point to.
2016-04-26 15:33:16 +01:00
*
* Static Arrays are represented as a special property for an atom,
2016-04-26 15:33:16 +01:00
* with field size and
*
* A term of the form X[I] is represented as a Reference pointing to
* the compound term:
2016-04-26 15:33:16 +01:00
*
2014-09-15 09:13:50 +01:00
* []([I],X)
2016-04-26 15:33:16 +01:00
*
*/
2016-04-26 15:33:16 +01:00
static Int create_array(USES_REGS1);
static Int create_mmapped_array(USES_REGS1);
static Int array_references(USES_REGS1);
static Int create_static_array(USES_REGS1);
static Int resize_static_array(USES_REGS1);
static Int close_static_array(USES_REGS1);
static Int access_array(USES_REGS1);
static Int assign_static(USES_REGS1);
static Int assign_dynamic(USES_REGS1);
#if HAVE_MMAP
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#if HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
/* keep a list of mmaped blocks to synch on exit */
typedef struct MMAP_ARRAY_BLOCK {
Atom name;
void *start;
2016-04-26 15:33:16 +01:00
size_t size;
Int items;
2016-04-26 15:33:16 +01:00
int fd;
struct MMAP_ARRAY_BLOCK *next;
} mmap_array_block;
2016-04-26 15:33:16 +01:00
static Int CloseMmappedArray(StaticArrayEntry *pp, void *area USES_REGS) {
mmap_array_block *ptr = GLOBAL_mmap_arrays, *optr = GLOBAL_mmap_arrays;
while (ptr != NULL && ptr->start != area) {
ptr = ptr->next;
optr = ptr;
}
if (ptr == NULL) {
#if !defined(USE_SYSTEM_MALLOC)
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_INTERNAL, ARG1,
"close_mmapped_array (array chain incoherent)",
strerror(errno));
#endif
return FALSE;
}
if (munmap(ptr->start, ptr->size) == -1) {
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_INTERNAL, ARG1,
"close_mmapped_array (munmap: %s)", strerror(errno));
2016-04-26 15:33:16 +01:00
return (FALSE);
}
optr->next = ptr->next;
pp->ValueOfVE.ints = NULL;
pp->ArrayEArity = 0;
if (close(ptr->fd) < 0) {
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"close_mmapped_array (close: %s)", strerror(errno));
2016-04-26 15:33:16 +01:00
return (FALSE);
}
Yap_FreeAtomSpace((char *)ptr);
2016-04-26 15:33:16 +01:00
return (TRUE);
}
2016-04-26 15:33:16 +01:00
static void ResizeMmappedArray(StaticArrayEntry *pp, Int dim,
void *area USES_REGS) {
mmap_array_block *ptr = GLOBAL_mmap_arrays;
2016-04-26 15:33:16 +01:00
size_t total_size;
while (ptr != NULL && ptr->start != area) {
ptr = ptr->next;
}
if (ptr == NULL)
return;
/* This is a very stupid algorithm to change size for an array.
First, we unmap it, then we actually change the size for the file,
and last we initialize again
*/
if (munmap(ptr->start, ptr->size) == -1) {
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"resize_mmapped_array (munmap: %s)", strerror(errno));
2016-04-26 15:33:16 +01:00
return;
}
2016-04-26 15:33:16 +01:00
total_size = (ptr->size / ptr->items) * dim;
if (ftruncate(ptr->fd, total_size) < 0) {
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"resize_mmapped_array (ftruncate: %s)", strerror(errno));
return;
}
2016-04-26 15:33:16 +01:00
if (lseek(ptr->fd, total_size - 1, SEEK_SET) < 0) {
2016-09-21 20:38:21 +01:00
Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"resize_mmapped_array (lseek: %s)", strerror(errno));
return;
}
if (write(ptr->fd, "", 1) < 0) {
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"resize_mmapped_array (write: %s)", strerror(errno));
return;
}
2016-04-26 15:33:16 +01:00
if ((ptr->start = (void *)mmap(0, (size_t)total_size, PROT_READ | PROT_WRITE,
MAP_SHARED, ptr->fd, 0)) == (void *)-1) {
2016-09-21 20:38:21 +01:00
Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"resize_mmapped_array (mmap: %s)", ___LINE__, __FUNCTION__,
-__FILE__, strerror(errno));
return;
}
ptr->size = total_size;
ptr->items = dim;
pp->ValueOfVE.chars = ptr->start;
}
#endif
2016-04-26 15:33:16 +01:00
static Term GetTermFromArray(DBTerm *ref USES_REGS) {
if (ref != NULL) {
Term TRef;
while ((TRef = Yap_FetchTermFromDB(ref)) == 0L) {
2016-09-21 20:38:21 +01:00
if (!Yap_gcl(LOCAL_Error_Size, 3, ENV, Yap_gcP())) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return 0;
}
}
return TRef;
} else {
2016-09-21 20:38:21 +01:00
Yap_Error(DOMAIN_ERROR_NOT_ZERO, ARG1, "Null reference.");
return 0;
}
}
2016-04-26 15:33:16 +01:00
static Term GetNBTerm(live_term *ar, Int indx USES_REGS) {
/* The object is now in use */
Term livet = ar[indx].tlive;
if (!IsVarTerm(livet)) {
if (!IsApplTerm(livet)) {
return livet;
} else if (FunctorOfTerm(livet) == FunctorAtFoundOne) {
return Yap_ReadTimedVar(livet);
} else {
return livet;
}
} else {
Term termt = ar[indx].tstore;
if (!IsUnboundVar(&(ar[indx].tlive))) {
return livet;
}
if (IsVarTerm(termt)) {
livet = MkVarTerm();
} else if (IsAtomicTerm(termt)) {
livet = termt;
} else {
DBTerm *ref = (DBTerm *)RepAppl(termt);
2016-09-21 20:38:21 +01:00
if ((livet = GetTermFromArray(ref PASS_REGS)) == 0) {
return 0;
}
}
YapBind(&(ar[indx].tlive), livet);
return livet;
}
}
2016-04-26 15:33:16 +01:00
static ArrayEntry *GetArrayEntry(Atom at, int owner) {
CACHE_REGS
2015-06-19 00:15:39 +01:00
ArrayEntry *pp;
AtomEntry *ae = RepAtom(at);
2016-04-26 15:33:16 +01:00
READ_LOCK(ae->ARWLock);
pp = RepArrayProp(ae->PropsOfAE);
2016-04-26 15:33:16 +01:00
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty
#if THREADS
2016-04-26 15:33:16 +01:00
&& pp->owner_id != worker_id
#endif
2016-04-26 15:33:16 +01:00
)
pp = RepArrayProp(pp->NextOfPE);
READ_UNLOCK(ae->ARWLock);
2015-06-19 00:15:39 +01:00
return pp;
}
2016-04-26 15:33:16 +01:00
static Term AccessNamedArray(Atom a, Int indx USES_REGS) {
ArrayEntry *pp;
AtomEntry *ae = RepAtom(a);
2015-06-19 00:15:39 +01:00
2016-04-26 15:33:16 +01:00
pp = GetArrayEntry(ae, worker_id);
if (!EndOfPAEntr(pp)) {
if (ArrayIsDynamic(pp)) {
Term out;
READ_LOCK(pp->ArRWLock);
2016-09-21 20:38:21 +01:00
if (IsVarTerm(pp->ValueOfVE)) {
2016-04-26 15:33:16 +01:00
READ_UNLOCK(pp->ArRWLock);
2016-09-21 20:38:21 +01:00
Yap_Error(INSTANTIATION_ERROR, ARG1, "unbound static array", indx);
}
if (pp->ArrayEArity <= indx || indx < 0) {
READ_UNLOCK(pp->ArRWLock);
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, ARG1, "bad index %ld", indx);
2016-04-26 15:33:16 +01:00
}
out = RepAppl(pp->ValueOfVE)[indx + 1];
READ_UNLOCK(pp->ArRWLock);
2016-04-26 15:33:16 +01:00
return (out);
} else {
StaticArrayEntry *ptr = (StaticArrayEntry *)pp;
READ_LOCK(ptr->ArRWLock);
if (pp->ArrayEArity <= indx || indx < 0) {
2016-09-21 20:38:21 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, ARG1, "bad index %ld", indx);
}
switch (ptr->ArrayType) {
2016-04-26 15:33:16 +01:00
case array_of_ints: {
Term out;
out = MkIntegerTerm(ptr->ValueOfVE.ints[indx]);
READ_UNLOCK(ptr->ArRWLock);
return out;
}
case array_of_doubles: {
Term out;
out = MkEvalFl(ptr->ValueOfVE.floats[indx]);
READ_UNLOCK(ptr->ArRWLock);
return out;
}
case array_of_ptrs: {
Term out;
out = MkIntegerTerm((Int)(ptr->ValueOfVE.ptrs[indx]));
READ_UNLOCK(ptr->ArRWLock);
return out;
}
case array_of_atoms: {
Term out;
out = ptr->ValueOfVE.atoms[indx];
READ_UNLOCK(ptr->ArRWLock);
if (out == 0L)
return TermNil;
else
return out;
}
/* just return the atom */
case array_of_chars: {
Term out;
out = MkIntegerTerm((Int)(ptr->ValueOfVE.chars[indx]));
READ_UNLOCK(ptr->ArRWLock);
return out;
}
case array_of_uchars: {
Term out;
out = MkIntegerTerm((Int)(ptr->ValueOfVE.uchars[indx]));
READ_UNLOCK(ptr->ArRWLock);
return out;
}
case array_of_dbrefs: {
/* The object is now in use */
Term TRef = ptr->ValueOfVE.dbrefs[indx];
2016-04-26 15:33:16 +01:00
READ_UNLOCK(ptr->ArRWLock);
if (TRef != 0L) {
DBRef ref = DBRefOfTerm(TRef);
#if MULTIPLE_STACKS
2016-04-26 15:33:16 +01:00
LOCK(ref->lock);
INC_DBREF_COUNT(ref);
TRAIL_REF(ref); /* So that fail will erase it */
UNLOCK(ref->lock);
#else
2016-04-26 15:33:16 +01:00
if (ref->Flags & LogUpdMask) {
LogUpdClause *cl = (LogUpdClause *)ref;
if (!(cl->ClFlags & InUseMask)) {
cl->ClFlags |= InUseMask;
TRAIL_CLREF(cl);
}
} else {
if (!(ref->Flags & InUseMask)) {
ref->Flags |= InUseMask;
TRAIL_REF(ref); /* So that fail will erase it */
}
}
#endif
2016-04-26 15:33:16 +01:00
} else {
P = (yamop *)FAILCODE;
TRef = TermNil;
}
return TRef;
}
case array_of_nb_terms: {
/* The object is now in use */
Term out = GetNBTerm(ptr->ValueOfVE.lterms, indx PASS_REGS);
READ_UNLOCK(ptr->ArRWLock);
2016-09-21 20:38:21 +01:00
if (out == 0)
return TermNil;
2016-04-26 15:33:16 +01:00
}
case array_of_terms: {
/* The object is now in use */
DBTerm *ref = ptr->ValueOfVE.terms[indx];
2016-04-26 15:33:16 +01:00
READ_UNLOCK(ptr->ArRWLock);
return GetTermFromArray(ref PASS_REGS);
}
default:
2016-04-26 15:33:16 +01:00
READ_UNLOCK(ptr->ArRWLock);
return TermNil;
}
2016-04-26 15:33:16 +01:00
}
} else {
Yap_Error(EXISTENCE_ERROR_ARRAY, MkAtomTerm(a), "named array");
return (TermNil);
}
}
2014-09-15 09:13:50 +01:00
/** @pred array_element(+ _Name_, + _Index_, ? _Element_)
Unify _Element_ with _Name_[ _Index_]. It works for both
static and dynamic arrays, but it is read-only for static arrays, while
it can be used to unify with an element of a dynamic array.
*/
/// @memberof array_element/3
2016-04-26 15:33:16 +01:00
static Int access_array(USES_REGS1) {
Term t = Deref(ARG1);
Term ti = Deref(ARG2);
Term tf;
Int indx;
if (IsNonVarTerm(ti)) {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(ti)))
indx = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, ti, "access_array");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
} else {
Yap_Error(INSTANTIATION_ERROR, ti, "access_array");
return (TermNil);
}
if (IsNonVarTerm(t)) {
if (IsApplTerm(t)) {
if (indx >= ArityOfFunctor(FunctorOfTerm(t)) || indx < 0) {
2016-04-26 15:33:16 +01:00
/* Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, MkIntegerTerm(indx),
* "access_array");*/
P = (yamop *)FAILCODE;
return (FALSE);
}
tf = (RepAppl(t))[indx + 1];
} else if (IsAtomTerm(t)) {
tf = AccessNamedArray(AtomOfTerm(t), indx PASS_REGS);
if (tf == MkAtomTerm(AtomFoundVar)) {
2016-04-26 15:33:16 +01:00
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ARRAY, t, "access_array");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t, "access_array");
return (FALSE);
}
return Yap_unify(tf, ARG3);
}
2016-04-26 15:33:16 +01:00
static Int array_arg(USES_REGS1) {
register Term ti = Deref(ARG3), t;
register Int indx;
if (IsNonVarTerm(ti)) {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(ti)))
indx = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, ti, "access_array");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
} else {
Yap_Error(INSTANTIATION_ERROR, ti, "array_arg");
return (FALSE);
}
t = Deref(ARG2);
if (IsNonVarTerm(t)) {
if (IsApplTerm(t)) {
return (Yap_unify(((RepAppl(t))[indx + 1]), ARG1));
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
Term tf = AccessNamedArray(AtomOfTerm(t), indx PASS_REGS);
if (tf == MkAtomTerm(AtomFoundVar)) {
2016-04-26 15:33:16 +01:00
return (FALSE);
}
return (Yap_unify(tf, ARG1));
2016-04-26 15:33:16 +01:00
} else
Yap_Error(TYPE_ERROR_ARRAY, t, "array_arg");
} else
Yap_Error(INSTANTIATION_ERROR, t, "array_arg");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
static void InitNamedArray(ArrayEntry *p, Int dim USES_REGS) {
Term *tp;
WRITE_LOCK(p->ArRWLock);
/* Leave a pointer so that we can reclaim array space when
* we backtrack or when we abort */
/* place terms in reverse order */
2016-04-26 15:33:16 +01:00
Bind_Global(&(p->ValueOfVE), AbsAppl(HR));
2014-01-19 21:15:05 +00:00
tp = HR;
2016-04-26 15:33:16 +01:00
tp[0] = (CELL)Yap_MkFunctor(AtomArray, dim);
tp++;
p->ArrayEArity = dim;
/* Initialize the array as a set of variables */
2016-04-26 15:33:16 +01:00
HR = tp + dim;
2014-01-19 21:15:05 +00:00
for (; tp < HR; tp++) {
RESET_VARIABLE(tp);
}
WRITE_UNLOCK(p->ArRWLock);
}
/* we assume the atom ae is already locked */
2016-04-26 15:33:16 +01:00
static void CreateNamedArray(PropEntry *pp, Int dim, AtomEntry *ae USES_REGS) {
ArrayEntry *p;
2016-04-26 15:33:16 +01:00
p = (ArrayEntry *)Yap_AllocAtomSpace(sizeof(*p));
p->KindOfPE = ArrayProperty;
p->TypeOfAE = DYNAMIC_ARRAY;
AddPropToAtom(ae, (PropEntry *)p);
INIT_RWLOCK(p->ArRWLock);
#if THREADS
p->owner_id = worker_id;
#endif
2011-05-04 10:11:41 +01:00
p->NextAE = LOCAL_DynamicArrays;
LOCAL_DynamicArrays = p;
InitNamedArray(p, dim PASS_REGS);
}
2016-04-26 15:33:16 +01:00
static void AllocateStaticArraySpace(StaticArrayEntry *p,
static_array_types atype, void *old,
size_t array_size USES_REGS) {
size_t asize = 0;
switch (atype) {
case array_of_doubles:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(Float);
break;
case array_of_ints:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(Int);
break;
case array_of_chars:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(char);
break;
case array_of_uchars:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(unsigned char);
break;
case array_of_ptrs:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(AtomEntry *);
break;
case array_of_atoms:
case array_of_terms:
case array_of_nb_terms:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(live_term);
break;
case array_of_dbrefs:
2016-04-26 15:33:16 +01:00
asize = array_size * sizeof(DBRef);
break;
}
if (old == NULL) {
2016-04-26 15:33:16 +01:00
while ((p->ValueOfVE.floats = (Float *)Yap_AllocCodeSpace(asize)) == NULL) {
YAPLeaveCriticalSection();
if (!Yap_growheap(FALSE, asize, NULL)) {
2016-04-26 15:33:16 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
return;
}
YAPEnterCriticalSection();
}
} else {
2016-04-26 15:33:16 +01:00
while ((p->ValueOfVE.floats = (Float *)Yap_ReallocCodeSpace(old, asize)) ==
NULL) {
YAPLeaveCriticalSection();
if (!Yap_growheap(FALSE, asize, NULL)) {
2016-04-26 15:33:16 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
return;
}
YAPEnterCriticalSection();
}
}
}
/* ae and p are assumed to be locked, if they exist */
2016-04-26 15:33:16 +01:00
static StaticArrayEntry *CreateStaticArray(AtomEntry *ae, size_t dim,
static_array_types type,
CODEADDR start_addr,
StaticArrayEntry *p USES_REGS) {
if (EndOfPAEntr(p)) {
2016-04-26 15:33:16 +01:00
while ((p = (StaticArrayEntry *)Yap_AllocCodeSpace(sizeof(*p))) == NULL) {
if (!Yap_growheap(FALSE, sizeof(*p), NULL)) {
2016-04-26 15:33:16 +01:00
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
return NULL;
}
}
p->KindOfPE = ArrayProperty;
INIT_RWLOCK(p->ArRWLock);
AddPropToAtom(ae, (PropEntry *)p);
2011-05-04 10:11:41 +01:00
p->NextAE = LOCAL_StaticArrays;
LOCAL_StaticArrays = p;
}
WRITE_LOCK(p->ArRWLock);
p->ArrayEArity = dim;
p->ArrayType = type;
p->TypeOfAE = STATIC_ARRAY;
if (start_addr == NULL) {
2016-04-26 15:33:16 +01:00
size_t i;
AllocateStaticArraySpace(p, type, NULL, dim PASS_REGS);
if (p->ValueOfVE.ints == NULL) {
WRITE_UNLOCK(p->ArRWLock);
return p;
}
2016-04-26 15:33:16 +01:00
switch (type) {
case array_of_ints:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.ints[i] = 0;
break;
case array_of_chars:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.chars[i] = '\0';
break;
case array_of_uchars:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.uchars[i] = '\0';
break;
case array_of_doubles:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.floats[i] = 0.0;
break;
case array_of_ptrs:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.ptrs[i] = NULL;
break;
case array_of_atoms:
case array_of_dbrefs:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.atoms[i] = 0L;
break;
case array_of_terms:
for (i = 0; i < dim; i++)
2016-04-26 15:33:16 +01:00
p->ValueOfVE.terms[i] = NULL;
break;
case array_of_nb_terms:
for (i = 0; i < dim; i++) {
2016-04-26 15:33:16 +01:00
RESET_VARIABLE(&(p->ValueOfVE.lterms[i].tlive));
p->ValueOfVE.lterms[i].tstore = TermNil;
}
break;
}
} else {
/* external array */
p->TypeOfAE |= MMAP_ARRAY;
p->ValueOfVE.chars = (char *)start_addr;
}
WRITE_UNLOCK(p->ArRWLock);
return p;
}
2015-06-19 00:15:39 +01:00
/* ae and p are assumed to be locked, if they exist */
2016-04-26 15:33:16 +01:00
StaticArrayEntry *Yap_StaticArray(Atom na, size_t dim, static_array_types type,
CODEADDR start_addr, StaticArrayEntry *p) {
CACHE_REGS
2015-06-19 00:15:39 +01:00
StaticArrayEntry *e;
2016-04-26 15:33:16 +01:00
ArrayEntry *e0 = GetArrayEntry(RepAtom(na), worker_id);
if (e0 && ArrayIsDynamic(e0)) {
2015-06-19 00:15:39 +01:00
e = NULL;
} else {
// initial version for e
2016-04-26 15:33:16 +01:00
e = RepStaticArrayProp(AbsArrayProp(e0));
2015-06-19 00:15:39 +01:00
}
2016-04-26 15:33:16 +01:00
e = CreateStaticArray(RepAtom(na), dim, type, NULL, e PASS_REGS);
2015-06-19 00:15:39 +01:00
return e;
}
2016-04-26 15:33:16 +01:00
static void ResizeStaticArray(StaticArrayEntry *pp, size_t dim USES_REGS) {
statarray_elements old_v = pp->ValueOfVE;
static_array_types type = pp->ArrayType;
2014-01-02 21:59:02 +00:00
size_t old_dim = pp->ArrayEArity;
size_t mindim = (dim < old_dim ? dim : old_dim), i;
/* change official size */
2016-04-26 15:33:16 +01:00
if (pp->ArrayEArity == 0) {
return;
}
WRITE_LOCK(pp->ArRWLock);
pp->ArrayEArity = dim;
#if HAVE_MMAP
if (pp->TypeOfAE & MMAP_ARRAY) {
2016-04-26 15:33:16 +01:00
ResizeMmappedArray(pp, dim, (void *)(pp->ValueOfVE.chars)PASS_REGS);
WRITE_UNLOCK(pp->ArRWLock);
return;
}
#endif
AllocateStaticArraySpace(pp, type, old_v.chars, dim PASS_REGS);
2016-04-26 15:33:16 +01:00
switch (type) {
case array_of_ints:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.ints[i] = 0;
break;
case array_of_chars:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.chars[i] = '\0';
break;
case array_of_uchars:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.uchars[i] = '\0';
break;
case array_of_doubles:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.floats[i] = 0.0;
break;
case array_of_ptrs:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.ptrs[i] = NULL;
break;
case array_of_atoms:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.atoms[i] = TermNil;
break;
case array_of_dbrefs:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.dbrefs[i] = 0L;
break;
case array_of_terms:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++)
pp->ValueOfVE.terms[i] = NULL;
break;
case array_of_nb_terms:
2016-04-26 15:33:16 +01:00
for (i = mindim; i < dim; i++) {
RESET_VARIABLE(&(pp->ValueOfVE.lterms[i].tlive));
pp->ValueOfVE.lterms[i].tstore = TermNil;
}
break;
}
WRITE_UNLOCK(pp->ArRWLock);
}
2016-04-26 15:33:16 +01:00
static void ClearStaticArray(StaticArrayEntry *pp) {
statarray_elements old_v = pp->ValueOfVE;
static_array_types type = pp->ArrayType;
2014-01-02 21:59:02 +00:00
Int dim = pp->ArrayEArity, i;
/* change official size */
2016-04-26 15:33:16 +01:00
if (pp->ArrayEArity == 0) {
return;
}
WRITE_LOCK(pp->ArRWLock);
2016-04-26 15:33:16 +01:00
switch (type) {
case array_of_ints:
2016-04-26 15:33:16 +01:00
memset((void *)pp->ValueOfVE.ints, 0, sizeof(Int) * dim);
break;
case array_of_chars:
2016-04-26 15:33:16 +01:00
memset((void *)pp->ValueOfVE.chars, 0, sizeof(char) * dim);
break;
case array_of_uchars:
2016-04-26 15:33:16 +01:00
memset((void *)pp->ValueOfVE.uchars, 0, sizeof(unsigned char) * dim);
break;
case array_of_doubles:
2016-04-26 15:33:16 +01:00
memset((void *)pp->ValueOfVE.floats, 0, sizeof(double) * dim);
break;
case array_of_ptrs:
2016-04-26 15:33:16 +01:00
memset((void *)pp->ValueOfVE.ptrs, 0, sizeof(void *) * dim);
break;
case array_of_atoms:
2016-04-26 15:33:16 +01:00
for (i = 0; i < dim; i++)
pp->ValueOfVE.atoms[i] = TermNil;
break;
case array_of_dbrefs:
for (i = 0; i < dim; i++) {
Term t0 = pp->ValueOfVE.dbrefs[i];
if (t0 != 0L) {
2016-04-26 15:33:16 +01:00
DBRef ptr = DBRefOfTerm(t0);
if (ptr->Flags & LogUpdMask) {
LogUpdClause *lup = (LogUpdClause *)ptr;
// LOCK(lup->ClLock);
lup->ClRefCount--;
if (lup->ClRefCount == 0 && (lup->ClFlags & ErasedMask) &&
!(lup->ClFlags & InUseMask)) {
// UNLOCK(lup->ClLock);
Yap_ErLogUpdCl(lup);
} else {
// UNLOCK(lup->ClLock);
}
} else {
ptr->NOfRefsTo--;
if (ptr->NOfRefsTo == 0 && (ptr->Flags & ErasedMask) &&
!(ptr->Flags & InUseMask)) {
Yap_ErDBE(ptr);
}
}
}
pp->ValueOfVE.dbrefs[i] = 0L;
}
break;
case array_of_terms:
for (i = 0; i < dim; i++) {
DBTerm *ref = pp->ValueOfVE.terms[i];
if (ref != NULL) {
2016-04-26 15:33:16 +01:00
Yap_ReleaseTermFromDB(ref);
}
pp->ValueOfVE.terms[i] = NULL;
}
break;
case array_of_nb_terms:
for (i = 0; i < dim; i++) {
Term told = pp->ValueOfVE.lterms[i].tstore;
CELL *livep = &(pp->ValueOfVE.lterms[i].tlive);
RESET_VARIABLE(livep);
/* recover space */
if (IsApplTerm(told)) {
2016-04-26 15:33:16 +01:00
Yap_ReleaseTermFromDB((DBTerm *)RepAppl(told));
}
pp->ValueOfVE.lterms[i].tstore = old_v.lterms[i].tstore;
}
break;
}
WRITE_UNLOCK(pp->ArRWLock);
}
/* create an array (?Name, + Size) */
2016-04-26 15:33:16 +01:00
static Int create_array(USES_REGS1) {
Term ti;
Term t;
Int size;
2016-04-26 15:33:16 +01:00
restart:
ti = Deref(ARG2);
t = Deref(ARG1);
{
Term nti;
if (IsVarTerm(ti)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, ti, "create_array");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(ti)))
size = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, ti, "create_array");
return (FALSE);
}
}
if (IsVarTerm(t)) {
/* Create an anonymous array */
Functor farray;
farray = Yap_MkFunctor(AtomArray, size);
2016-04-26 15:33:16 +01:00
if (HR + 1 + size > ASP - 1024) {
if (!Yap_gcl((1 + size) * sizeof(CELL), 2, ENV, Yap_gcP())) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return (FALSE);
} else {
2016-04-26 15:33:16 +01:00
if (HR + 1 + size > ASP - 1024) {
if (!Yap_growstack(sizeof(CELL) * (size + 1 - (HR - ASP - 1024)))) {
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
}
}
goto restart;
}
2014-01-19 21:15:05 +00:00
t = AbsAppl(HR);
2016-04-26 15:33:16 +01:00
*HR++ = (CELL)farray;
for (; size >= 0; size--) {
2014-01-19 21:15:05 +00:00
RESET_VARIABLE(HR);
HR++;
}
return (Yap_unify(t, ARG1));
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
PropEntry *pp;
WRITE_LOCK(ae->ARWLock);
pp = RepProp(ae->PropsOfAE);
2016-04-26 15:33:16 +01:00
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty
#if THREADS
2016-04-26 15:33:16 +01:00
&& ((ArrayEntry *)pp)->owner_id != worker_id
#endif
)
pp = RepProp(pp->NextOfPE);
if (EndOfPAEntr(pp)) {
2016-04-26 15:33:16 +01:00
if (HR + 1 + size > ASP - 1024) {
WRITE_UNLOCK(ae->ARWLock);
if (!Yap_gcl((1 + size) * sizeof(CELL), 2, ENV, gc_P(P, CP))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return (FALSE);
} else
goto restart;
}
CreateNamedArray(pp, size, ae PASS_REGS);
WRITE_UNLOCK(ae->ARWLock);
return (TRUE);
} else {
2016-04-26 15:33:16 +01:00
ArrayEntry *app = (ArrayEntry *)pp;
WRITE_UNLOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
if (!IsVarTerm(app->ValueOfVE) || !IsUnboundVar(&app->ValueOfVE)) {
if (size == app->ArrayEArity)
return TRUE;
Yap_Error(PERMISSION_ERROR_CREATE_ARRAY, t, "create_array",
ae->StrOfAE);
} else {
2016-04-26 15:33:16 +01:00
if (HR + 1 + size > ASP - 1024) {
if (!Yap_gcl((1 + size) * sizeof(CELL), 2, ENV, gc_P(P, CP))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return (FALSE);
} else
goto restart;
}
InitNamedArray(app, size PASS_REGS);
return (TRUE);
}
}
}
return (FALSE);
}
/* create an array (+Name, + Size, +Props) */
2016-04-26 15:33:16 +01:00
static Int
/** @pred static_array(+ _Name_, + _Size_, + _Type_)
2014-09-15 09:13:50 +01:00
2016-04-26 15:33:16 +01:00
Create a new static array with name _Name_. Note that the _Name_
must be an atom (named array). The _Size_ must evaluate to an
integer. The _Type_ must be bound to one of types mentioned
previously.
*/
create_static_array(USES_REGS1) {
Term ti = Deref(ARG2);
Term t = Deref(ARG1);
Term tprops = Deref(ARG3);
Int size;
static_array_types props;
if (IsVarTerm(ti)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, ti, "create static array");
return (FALSE);
} else {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(ti)))
size = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, ti, "create static array");
return (FALSE);
}
}
if (IsVarTerm(tprops)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, tprops, "create static array");
return (FALSE);
} else if (IsAtomTerm(tprops)) {
2015-09-21 23:05:36 +01:00
char *atname = (char *)RepAtom(AtomOfTerm(tprops))->StrOfAE;
if (!strcmp(atname, "int"))
props = array_of_ints;
else if (!strcmp(atname, "dbref"))
props = array_of_dbrefs;
else if (!strcmp(atname, "float"))
props = array_of_doubles;
else if (!strcmp(atname, "ptr"))
props = array_of_ptrs;
else if (!strcmp(atname, "atom"))
props = array_of_atoms;
else if (!strcmp(atname, "char"))
props = array_of_chars;
else if (!strcmp(atname, "unsigned_char"))
props = array_of_uchars;
else if (!strcmp(atname, "term"))
props = array_of_terms;
else if (!strcmp(atname, "nb_term"))
props = array_of_nb_terms;
else {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_TYPE, tprops, "create static array");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, tprops, "create static array");
return (FALSE);
}
if (IsVarTerm(t)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t, "create static array");
return (FALSE);
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
StaticArrayEntry *pp;
ArrayEntry *app;
WRITE_LOCK(ae->ARWLock);
pp = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
2016-04-26 15:33:16 +01:00
app = (ArrayEntry *)pp;
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
pp = CreateStaticArray(ae, size, props, NULL, pp PASS_REGS);
if (pp == NULL || pp->ValueOfVE.ints == NULL) {
2016-04-26 15:33:16 +01:00
WRITE_UNLOCK(ae->ARWLock);
return FALSE;
}
WRITE_UNLOCK(ae->ARWLock);
return TRUE;
} else if (ArrayIsDynamic(app)) {
if (IsVarTerm(app->ValueOfVE) && IsUnboundVar(&app->ValueOfVE)) {
2016-04-26 15:33:16 +01:00
pp = CreateStaticArray(ae, size, props, NULL, pp PASS_REGS);
WRITE_UNLOCK(ae->ARWLock);
if (pp == NULL) {
return false;
}
return true;
} else {
2016-04-26 15:33:16 +01:00
WRITE_UNLOCK(ae->ARWLock);
Yap_Error(PERMISSION_ERROR_CREATE_ARRAY, t,
"cannot create static array over dynamic array");
return false;
}
} else {
2016-04-26 15:33:16 +01:00
if (pp->ArrayEArity == size && pp->ArrayType == props) {
WRITE_UNLOCK(ae->ARWLock);
return true;
}
Yap_FreeCodeSpace(pp->ValueOfVE.floats);
WRITE_UNLOCK(ae->ARWLock);
return true;
}
}
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t, "create static array");
return false;
}
2016-04-26 15:33:16 +01:00
/// create a new vectir in a given name Name. If one exists, destroy prrexisting
/// onr
StaticArrayEntry *Yap_StaticVector(Atom Name, size_t size,
static_array_types props) {
CACHE_REGS
AtomEntry *ae = RepAtom(Name);
2015-06-19 00:15:39 +01:00
WRITE_LOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
StaticArrayEntry *pp =
RepStaticArrayProp(AbsArrayProp(GetArrayEntry(ae, worker_id)));
2015-06-19 00:15:39 +01:00
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
pp = CreateStaticArray(ae, size, props, NULL, pp PASS_REGS);
if (pp == NULL || pp->ValueOfVE.ints == NULL) {
WRITE_UNLOCK(ae->ARWLock);
return FALSE;
}
WRITE_UNLOCK(ae->ARWLock);
return pp;
}
return NULL;
}
2016-04-26 15:33:16 +01:00
/* has a static array associated (+Name) */
2016-04-26 15:33:16 +01:00
static Int static_array_properties(USES_REGS1) {
Term t = Deref(ARG1);
if (IsVarTerm(t)) {
return (FALSE);
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
StaticArrayEntry *pp;
READ_LOCK(ae->ARWLock);
pp = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
READ_UNLOCK(ae->ARWLock);
return (FALSE);
} else {
static_array_types tp = pp->ArrayType;
Int dim = pp->ArrayEArity;
READ_UNLOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
if (dim <= 0 || !Yap_unify(ARG2, MkIntegerTerm(dim)))
return (FALSE);
switch (tp) {
case array_of_ints:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, MkAtomTerm(AtomInt)));
case array_of_dbrefs:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, MkAtomTerm(AtomDBref)));
case array_of_doubles:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, MkAtomTerm(AtomFloat)));
case array_of_ptrs:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, TermPointer));
case array_of_chars:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, MkAtomTerm(AtomChar)));
case array_of_uchars:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, MkAtomTerm(AtomUnsignedChar)));
case array_of_terms:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, TermTerm));
case array_of_nb_terms:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, TermTerm));
case array_of_atoms:
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG3, MkAtomTerm(AtomAtom)));
}
}
}
return (FALSE);
}
/* resize a static array (+Name, + Size, +Props) */
/* does not work for mmap arrays yet */
2016-04-26 15:33:16 +01:00
static Int resize_static_array(USES_REGS1) {
Term ti = Deref(ARG3);
Term t = Deref(ARG1);
Int size;
if (IsVarTerm(ti)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, ti, "resize a static array");
return (FALSE);
} else {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(ti)))
size = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, ti, "resize a static array");
return (FALSE);
}
}
if (IsVarTerm(t)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t, "resize a static array");
return (FALSE);
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* resize a named array */
Atom a = AtomOfTerm(t);
StaticArrayEntry *pp = RepStaticArrayProp(RepAtom(a)->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
2016-04-26 15:33:16 +01:00
Yap_Error(PERMISSION_ERROR_RESIZE_ARRAY, t, "resize a static array");
return (FALSE);
} else {
2016-04-26 15:33:16 +01:00
size_t osize = pp->ArrayEArity;
ResizeStaticArray(pp, size PASS_REGS);
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG2, MkIntegerTerm(osize)));
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t, "resize a static array");
return (FALSE);
}
}
/* resize a static array (+Name, + Size, +Props) */
/* does not work for mmap arrays yet */
2014-09-15 09:13:50 +01:00
/** @pred reset_static_array(+ _Name_)
Reset static array with name _Name_ to its initial value.
*/
2016-04-26 15:33:16 +01:00
static Int clear_static_array(USES_REGS1) {
Term t = Deref(ARG1);
if (IsVarTerm(t)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t, "clear a static array");
return FALSE;
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* resize a named array */
Atom a = AtomOfTerm(t);
StaticArrayEntry *pp = RepStaticArrayProp(RepAtom(a)->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
2016-04-26 15:33:16 +01:00
Yap_Error(PERMISSION_ERROR_RESIZE_ARRAY, t, "clear a static array");
return FALSE;
} else {
ClearStaticArray(pp);
return TRUE;
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t, "clear a static array");
return FALSE;
}
}
/* Close a named array (+Name) */
2014-09-15 09:13:50 +01:00
/** @pred close_static_array(+ _Name_)
Close an existing static array of name _Name_. The _Name_ must
be an atom (named array). Space for the array will be recovered and
further accesses to the array will return an error.
*/
2016-04-26 15:33:16 +01:00
static Int close_static_array(USES_REGS1) {
/* does not work for mmap arrays yet */
Term t = Deref(ARG1);
if (IsVarTerm(t)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t, "close static array");
return (FALSE);
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
PropEntry *pp;
READ_LOCK(ae->ARWLock);
pp = RepProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepProp(pp->NextOfPE);
READ_UNLOCK(ae->ARWLock);
if (EndOfPAEntr(pp)) {
return (FALSE);
} else {
StaticArrayEntry *ptr = (StaticArrayEntry *)pp;
if (ptr->ValueOfVE.ints != NULL) {
#if HAVE_MMAP
2016-04-26 15:33:16 +01:00
Int val =
CloseMmappedArray(ptr, (void *)ptr->ValueOfVE.chars PASS_REGS);
#if USE_SYSTEM_MALLOC
2016-04-26 15:33:16 +01:00
if (val) {
#endif
2016-04-26 15:33:16 +01:00
return (val);
2014-02-05 16:21:21 +00:00
#if USE_SYSTEM_MALLOC
2016-04-26 15:33:16 +01:00
}
2014-02-05 16:21:21 +00:00
#endif
#endif
2016-04-26 15:33:16 +01:00
Yap_FreeAtomSpace((char *)(ptr->ValueOfVE.ints));
ptr->ValueOfVE.ints = NULL;
ptr->ArrayEArity = 0;
return (TRUE);
} else {
2016-04-26 15:33:16 +01:00
return (FALSE);
}
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t, "close static array");
return (FALSE);
}
}
2014-09-15 09:13:50 +01:00
/** @pred mmapped_array(+ _Name_, + _Size_, + _Type_, + _File_)
Similar to static_array/3, but the array is memory mapped to file
_File_. This means that the array is initialized from the file, and
that any changes to the array will also be stored in the file.
This built-in is only available in operating systems that support the
system call `mmap`. Moreover, mmapped arrays do not store generic
terms (type `term`).
*/
2016-04-26 15:33:16 +01:00
static Int create_mmapped_array(USES_REGS1) {
#ifdef HAVE_MMAP
Term ti = Deref(ARG2);
Term t = Deref(ARG1);
Term tprops = Deref(ARG3);
Term tfile = Deref(ARG4);
Int size;
static_array_types props;
size_t total_size;
CODEADDR array_addr;
int fd;
if (IsVarTerm(ti)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, ti, "create_mmapped_array");
return (FALSE);
} else {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(ti)))
size = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, ti, "create_mmapped_array");
return (FALSE);
}
}
if (IsVarTerm(tprops)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, tprops, "create_mmapped_array");
return (FALSE);
} else if (IsAtomTerm(tprops)) {
char *atname = RepAtom(AtomOfTerm(tprops))->StrOfAE;
if (!strcmp(atname, "int")) {
props = array_of_ints;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(Int);
} else if (!strcmp(atname, "dbref")) {
props = array_of_dbrefs;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(Int);
} else if (!strcmp(atname, "float")) {
props = array_of_doubles;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(Float);
} else if (!strcmp(atname, "ptr")) {
props = array_of_ptrs;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(AtomEntry *);
} else if (!strcmp(atname, "atom")) {
props = array_of_atoms;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(Term);
} else if (!strcmp(atname, "char")) {
props = array_of_chars;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(char);
} else if (!strcmp(atname, "unsigned_char")) {
props = array_of_uchars;
2016-04-26 15:33:16 +01:00
total_size = size * sizeof(unsigned char);
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_TYPE, tprops, "create_mmapped_array");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, tprops, "create_mmapped_array");
return (FALSE);
}
if (IsVarTerm(tfile)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, tfile, "create_mmapped_array");
return (FALSE);
} else if (IsAtomTerm(tfile)) {
char *filename = RepAtom(AtomOfTerm(tfile))->StrOfAE;
2016-04-26 15:33:16 +01:00
fd = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
if (fd == -1) {
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "create_mmapped_array (open: %s)",
strerror(errno));
return (FALSE);
}
2016-04-26 15:33:16 +01:00
if (lseek(fd, total_size - 1, SEEK_SET) < 0)
Yap_Error(SYSTEM_ERROR_INTERNAL, tfile,
"create_mmapped_array (lseek: %s)", strerror(errno));
if (write(fd, "", 1) < 0)
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, tfile,
"create_mmapped_array (write: %s)", strerror(errno));
/*
if (ftruncate(fd, total_size) < 0)
2015-09-25 10:57:26 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL,tfile,"create_mmapped_array");
*/
2016-04-26 15:33:16 +01:00
if ((array_addr =
(CODEADDR)mmap(0, (size_t)total_size, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0)) == (CODEADDR)-1)
Yap_Error(SYSTEM_ERROR_INTERNAL, tfile, "create_mmapped_array (mmap: %s)",
strerror(errno));
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, tfile, "create_mmapped_array");
return (FALSE);
}
if (IsVarTerm(t)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t, "create_mmapped_array");
return (FALSE);
2016-04-26 15:33:16 +01:00
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
StaticArrayEntry *pp;
WRITE_LOCK(ae->ARWLock);
pp = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
mmap_array_block *ptr;
if (EndOfPAEntr(pp)) {
2016-04-26 15:33:16 +01:00
WRITE_UNLOCK(ae->ARWLock);
return FALSE;
} else {
2016-04-26 15:33:16 +01:00
WRITE_LOCK(pp->ArRWLock);
}
CreateStaticArray(ae, size, props, array_addr, pp PASS_REGS);
ptr = (mmap_array_block *)Yap_AllocAtomSpace(sizeof(mmap_array_block));
ptr->name = AbsAtom(ae);
ptr->size = total_size;
ptr->items = size;
ptr->start = (void *)array_addr;
ptr->fd = fd;
ptr->next = GLOBAL_mmap_arrays;
GLOBAL_mmap_arrays = ptr;
WRITE_UNLOCK(pp->ArRWLock);
WRITE_UNLOCK(ae->ARWLock);
return TRUE;
} else {
WRITE_UNLOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_TYPE, t, "create_mmapped_array",
ae->StrOfAE);
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t, "create_mmapped_array");
return FALSE;
}
#else
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "create_mmapped_array (mmap)");
return (FALSE);
#endif
}
/* This routine removes array references from complex terms? */
2016-04-26 15:33:16 +01:00
static void replace_array_references_complex(register CELL *pt0,
register CELL *pt0_end,
register CELL *ptn,
Term Var USES_REGS) {
register CELL **to_visit = (CELL **)Yap_PreAllocCodeSpace();
CELL **to_visit_base = to_visit;
loop:
while (pt0 < pt0_end) {
register CELL d0;
++pt0;
d0 = Derefa(pt0);
if (IsVarTerm(d0)) {
*ptn++ = d0;
2016-04-26 15:33:16 +01:00
} else if (IsPairTerm(d0)) {
/* store the terms to visit */
2014-01-19 21:15:05 +00:00
*ptn++ = AbsPair(HR);
#ifdef RATIONAL_TREES
to_visit[0] = pt0;
to_visit[1] = pt0_end;
to_visit[2] = ptn;
to_visit[3] = (CELL *)*pt0;
to_visit += 4;
*pt0 = TermNil;
#else
if (pt0 < pt0_end) {
2016-04-26 15:33:16 +01:00
to_visit[0] = pt0;
to_visit[1] = pt0_end;
to_visit[2] = ptn;
to_visit += 3;
}
#endif
pt0 = RepPair(d0) - 1;
pt0_end = RepPair(d0) + 1;
/* write the head and tail of the list */
2014-01-19 21:15:05 +00:00
ptn = HR;
HR += 2;
2016-04-26 15:33:16 +01:00
} else if (IsApplTerm(d0)) {
register Functor f;
f = FunctorOfTerm(d0);
/* store the terms to visit */
if (IsExtensionFunctor(f)) {
2016-04-26 15:33:16 +01:00
{
*ptn++ = d0;
continue;
}
}
2014-01-19 21:15:05 +00:00
*ptn++ = AbsAppl(HR);
2016-04-26 15:33:16 +01:00
/* store the terms to visit */
#ifdef RATIONAL_TREES
to_visit[0] = pt0;
to_visit[1] = pt0_end;
to_visit[2] = ptn;
to_visit[3] = (CELL *)*pt0;
to_visit += 4;
*pt0 = TermNil;
#else
if (pt0 < pt0_end) {
2016-04-26 15:33:16 +01:00
to_visit[0] = pt0;
to_visit[1] = pt0_end;
to_visit[2] = ptn;
to_visit += 3;
}
#endif
pt0 = RepAppl(d0);
d0 = ArityOfFunctor(f);
pt0_end = pt0 + d0;
/* start writing the compound term */
2014-01-19 21:15:05 +00:00
ptn = HR;
2016-04-26 15:33:16 +01:00
*ptn++ = (CELL)f;
2014-01-19 21:15:05 +00:00
HR += d0 + 1;
2016-04-26 15:33:16 +01:00
} else { /* AtomOrInt */
*ptn++ = d0;
}
/* just continue the loop */
}
/* Do we still have compound terms to visit */
2016-04-26 15:33:16 +01:00
if (to_visit > (CELL **)to_visit_base) {
#ifdef RATIONAL_TREES
to_visit -= 4;
pt0 = to_visit[0];
pt0_end = to_visit[1];
ptn = to_visit[2];
*pt0 = (CELL)to_visit[3];
#else
to_visit -= 3;
pt0 = to_visit[0];
pt0_end = to_visit[1];
ptn = to_visit[2];
#endif
goto loop;
}
Bind_Global(PtrOfTerm(Var), TermNil);
Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
}
/*
2016-04-26 15:33:16 +01:00
*
* Given a term t0, build a new term tf of the form ta+tb, where ta is
* obtained by replacing the array references in t0 by empty
* variables, and tb is a list of array references and corresponding
* variables.
*/
2016-04-26 15:33:16 +01:00
static Term replace_array_references(Term t0 USES_REGS) {
Term t;
t = Deref(t0);
if (IsVarTerm(t)) {
/* we found a variable */
return (MkPairTerm(t, TermNil));
} else if (IsAtomOrIntTerm(t)) {
return (MkPairTerm(t, TermNil));
} else if (IsPairTerm(t)) {
Term VList = MkVarTerm();
2014-01-19 21:15:05 +00:00
CELL *h0 = HR;
2014-01-19 21:15:05 +00:00
HR += 2;
replace_array_references_complex(RepPair(t) - 1, RepPair(t) + 1, h0,
2016-04-26 15:33:16 +01:00
VList PASS_REGS);
return MkPairTerm(AbsPair(h0), VList);
} else {
Term VList = MkVarTerm();
2014-01-19 21:15:05 +00:00
CELL *h0 = HR;
Functor f = FunctorOfTerm(t);
2016-04-26 15:33:16 +01:00
*HR++ = (CELL)(f);
2014-01-19 21:15:05 +00:00
HR += ArityOfFunctor(f);
2016-04-26 15:33:16 +01:00
replace_array_references_complex(
RepAppl(t), RepAppl(t) + ArityOfFunctor(FunctorOfTerm(t)), h0 + 1,
VList PASS_REGS);
return (MkPairTerm(AbsAppl(h0), VList));
}
}
2016-04-26 15:33:16 +01:00
static Int array_references(USES_REGS1) {
Term t = replace_array_references(ARG1 PASS_REGS);
Term t1 = HeadOfTerm(t);
Term t2 = TailOfTerm(t);
return (Yap_unify(t1, ARG2) && Yap_unify(t2, ARG3));
}
2014-09-15 09:13:50 +01:00
/** @pred update_array(+ _Name_, + _Index_, ? _Value_)
Attribute value _Value_ to _Name_[ _Index_]. Type
restrictions must be respected for static arrays. This operation is
available for dynamic arrays if `MULTI_ASSIGNMENT_VARIABLES` is
enabled (true by default). Backtracking undoes _update_array/3_ for
dynamic arrays, but not for static arrays.
Note that update_array/3 actually uses `setarg/3` to update
elements of dynamic arrays, and `setarg/3` spends an extra cell for
every update. For intensive operations we suggest it may be less
expensive to unify each element of the array with a mutable terms and
to use the operations on mutable terms.
*/
2016-04-26 15:33:16 +01:00
static Int assign_static(USES_REGS1) {
Term t1, t2, t3;
StaticArrayEntry *ptr;
Int indx;
t2 = Deref(ARG2);
if (IsNonVarTerm(t2)) {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(t2)))
indx = IntegerOfTerm(nti);
else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, t2, "update_array");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t2, "update_array");
return (FALSE);
}
t3 = Deref(ARG3);
t1 = Deref(ARG1);
if (IsVarTerm(t1)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t1, "update_array");
return (FALSE);
}
if (!IsAtomTerm(t1)) {
if (IsApplTerm(t1)) {
CELL *ptr;
Functor f = FunctorOfTerm(t1);
/* store the terms to visit */
if (IsExtensionFunctor(f)) {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ARRAY, t1, "update_array");
return (FALSE);
}
if (indx > 0 && indx > ArityOfFunctor(f)) {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "update_array");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
ptr = RepAppl(t1) + indx + 1;
#ifdef MULTI_ASSIGNMENT_VARIABLES
MaBind(ptr, t3);
2016-04-26 15:33:16 +01:00
return (TRUE);
#else
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, t2, "update_array");
return (FALSE);
#endif
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t1, "update_array");
return (FALSE);
}
}
{
AtomEntry *ae = RepAtom(AtomOfTerm(t1));
READ_LOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
ptr = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(ptr) && ptr->KindOfPE != ArrayProperty)
ptr = RepStaticArrayProp(ptr->NextOfPE);
if (EndOfPAEntr(ptr)) {
READ_UNLOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(EXISTENCE_ERROR_ARRAY, t1, "assign_static %s",
RepAtom(AtomOfTerm(t1))->StrOfAE);
return FALSE;
}
if (ArrayIsDynamic((ArrayEntry *)ptr)) {
ArrayEntry *pp = (ArrayEntry *)ptr;
CELL *pt;
2016-04-26 15:33:16 +01:00
WRITE_LOCK(pp->ArRWLock);
READ_UNLOCK(ae->ARWLock);
if (indx < 0 || indx >= pp->ArrayEArity) {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "assign_static");
WRITE_UNLOCK(pp->ArRWLock);
return FALSE;
}
pt = RepAppl(pp->ValueOfVE) + indx + 1;
WRITE_UNLOCK(pp->ArRWLock);
#ifdef MULTI_ASSIGNMENT_VARIABLES
/* the evil deed is to be done now */
MaBind(pt, t3);
return TRUE;
#else
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, t2, "update_array");
return FALSE;
#endif
}
WRITE_LOCK(ptr->ArRWLock);
READ_UNLOCK(ae->ARWLock);
/* a static array */
if (indx < 0 || indx >= ptr->ArrayEArity) {
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "assign_static");
return FALSE;
}
switch (ptr->ArrayType) {
2016-04-26 15:33:16 +01:00
case array_of_ints: {
Int i;
Term nti;
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(t3)))
i = IntegerOfTerm(nti);
else {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_INTEGER, t3, "assign_static");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
ptr->ValueOfVE.ints[indx] = i;
} break;
2016-04-26 15:33:16 +01:00
case array_of_chars: {
Int i;
Term nti;
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(t3)))
i = IntegerOfTerm(nti);
else {
Yap_Error(TYPE_ERROR_INTEGER, t3, "assign_static");
return (FALSE);
}
if (i > 127 || i < -128) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_CHAR, t3, "assign_static");
return FALSE;
}
ptr->ValueOfVE.chars[indx] = i;
} break;
2016-04-26 15:33:16 +01:00
case array_of_uchars: {
Int i;
Term nti;
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(t3)))
i = IntegerOfTerm(nti);
else {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_INTEGER, t3, "assign_static");
return FALSE;
}
if (i > 255 || i < 0) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_UCHAR, t3, "assign_static");
return FALSE;
}
ptr->ValueOfVE.chars[indx] = i;
} break;
2016-04-26 15:33:16 +01:00
case array_of_doubles: {
Float f;
Term nti;
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
2016-04-26 15:33:16 +01:00
if (IsFloatTerm(nti = Yap_Eval(t3)))
f = FloatOfTerm(nti);
else if (IsIntegerTerm(nti))
f = IntegerOfTerm(nti);
else {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_FLOAT, t3, "assign_static");
return FALSE;
}
ptr->ValueOfVE.floats[indx] = f;
} break;
2016-04-26 15:33:16 +01:00
case array_of_ptrs: {
Int r;
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(t3))
r = IntegerOfTerm(t3);
else {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_PTR, t3, "assign_static");
return FALSE;
}
ptr->ValueOfVE.ptrs[indx] = (AtomEntry *)r;
} break;
case array_of_atoms: {
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
if (!IsAtomTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_ATOM, t3, "assign_static");
return FALSE;
}
ptr->ValueOfVE.atoms[indx] = t3;
} break;
2016-04-26 15:33:16 +01:00
case array_of_dbrefs: {
Term t0 = ptr->ValueOfVE.dbrefs[indx];
DBRef p = DBRefOfTerm(t3);
if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(INSTANTIATION_ERROR, t3, "assign_static");
return FALSE;
}
2016-04-26 15:33:16 +01:00
if (!IsDBRefTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(TYPE_ERROR_DBREF, t3, "assign_static");
return FALSE;
}
ptr->ValueOfVE.dbrefs[indx] = t3;
if (t0 != 0L) {
DBRef ptr = DBRefOfTerm(t0);
if (ptr->Flags & LogUpdMask) {
LogUpdClause *lup = (LogUpdClause *)ptr;
// LOCK(lup->ClLock);
lup->ClRefCount--;
if (lup->ClRefCount == 0 && (lup->ClFlags & ErasedMask) &&
!(lup->ClFlags & InUseMask)) {
// UNLOCK(lup->ClLock);
Yap_ErLogUpdCl(lup);
} else {
// UNLOCK(lup->ClLock);
}
} else {
ptr->NOfRefsTo--;
if (ptr->NOfRefsTo == 0 && (ptr->Flags & ErasedMask) &&
!(ptr->Flags & InUseMask)) {
Yap_ErDBE(ptr);
}
}
}
if (p->Flags & LogUpdMask) {
LogUpdClause *lup = (LogUpdClause *)p;
// LOCK(lup->ClLock);
lup->ClRefCount++;
// UNLOCK(lup->ClLock);
} else {
p->NOfRefsTo++;
}
} break;
case array_of_nb_terms:
2016-04-26 15:33:16 +01:00
{
Term told = ptr->ValueOfVE.lterms[indx].tstore;
CELL *livep = &(ptr->ValueOfVE.lterms[indx].tlive);
RESET_VARIABLE(livep);
/* recover space */
if (IsApplTerm(told)) {
Yap_ReleaseTermFromDB((DBTerm *)RepAppl(told));
}
2016-04-26 15:33:16 +01:00
if (IsVarTerm(t3)) {
RESET_VARIABLE(&(ptr->ValueOfVE.lterms[indx].tstore));
} else if (IsAtomicTerm(t3)) {
ptr->ValueOfVE.lterms[indx].tstore = t3;
} else {
DBTerm *new = Yap_StoreTermInDB(t3, 3);
if (!new) {
WRITE_UNLOCK(ptr->ArRWLock);
return FALSE;
}
ptr->ValueOfVE.lterms[indx].tstore = AbsAppl((CELL *)new);
}
} break;
2016-04-26 15:33:16 +01:00
case array_of_terms: {
DBTerm *ref = ptr->ValueOfVE.terms[indx];
if (ref != NULL) {
Yap_ReleaseTermFromDB(ref);
}
2016-04-26 15:33:16 +01:00
ptr->ValueOfVE.terms[indx] = Yap_StoreTermInDB(t3, 3);
if (ptr->ValueOfVE.terms[indx] == NULL) {
WRITE_UNLOCK(ptr->ArRWLock);
return FALSE;
}
} break;
}
WRITE_UNLOCK(ptr->ArRWLock);
return TRUE;
}
}
2016-04-26 15:33:16 +01:00
static Int assign_dynamic(USES_REGS1) {
Term t1, t2, t3;
StaticArrayEntry *ptr;
Int indx;
t2 = Deref(ARG2);
if (IsNonVarTerm(t2)) {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(t2))) {
indx = IntegerOfTerm(nti);
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, t2, "update_array");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t2, "update_array");
return (FALSE);
}
t3 = Deref(ARG3);
t1 = Deref(ARG1);
if (IsVarTerm(t1)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t1, "update_array");
return (FALSE);
}
if (!IsAtomTerm(t1)) {
if (IsApplTerm(t1)) {
CELL *ptr;
Functor f = FunctorOfTerm(t1);
/* store the terms to visit */
if (IsExtensionFunctor(f)) {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ARRAY, t1, "update_array");
return (FALSE);
}
if (indx > 0 && indx > ArityOfFunctor(f)) {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "update_array");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
ptr = RepAppl(t1) + indx + 1;
#ifdef MULTI_ASSIGNMENT_VARIABLES
MaBind(ptr, t3);
2016-04-26 15:33:16 +01:00
return (TRUE);
#else
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, t2, "update_array");
return (FALSE);
#endif
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t1, "update_array");
return (FALSE);
}
}
{
AtomEntry *ae = RepAtom(AtomOfTerm(t1));
READ_LOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
ptr = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(ptr) && ptr->KindOfPE != ArrayProperty)
ptr = RepStaticArrayProp(ptr->NextOfPE);
READ_UNLOCK(ae->ARWLock);
}
if (EndOfPAEntr(ptr)) {
2016-04-26 15:33:16 +01:00
Yap_Error(EXISTENCE_ERROR_ARRAY, t1, "assign_static %s",
RepAtom(AtomOfTerm(t1))->StrOfAE);
return (FALSE);
}
if (ArrayIsDynamic((ArrayEntry *)ptr)) {
ArrayEntry *pp = (ArrayEntry *)ptr;
CELL *pt;
WRITE_LOCK(pp->ArRWLock);
if (indx < 0 || indx >= pp->ArrayEArity) {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "assign_static");
WRITE_UNLOCK(pp->ArRWLock);
2016-04-26 15:33:16 +01:00
return (FALSE);
}
pt = RepAppl(pp->ValueOfVE) + indx + 1;
WRITE_UNLOCK(pp->ArRWLock);
#ifdef MULTI_ASSIGNMENT_VARIABLES
/* the evil deed is to be done now */
MaBind(pt, t3);
return TRUE;
#else
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, t2, "update_array");
return FALSE;
#endif
}
WRITE_LOCK(ptr->ArRWLock);
/* a static array */
if (indx < 0 || indx >= ptr->ArrayEArity) {
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "assign_static");
return FALSE;
}
switch (ptr->ArrayType) {
case array_of_ints:
case array_of_chars:
case array_of_uchars:
case array_of_doubles:
case array_of_ptrs:
case array_of_atoms:
case array_of_dbrefs:
case array_of_terms:
WRITE_UNLOCK(ptr->ArRWLock);
Yap_Error(DOMAIN_ERROR_ARRAY_TYPE, t3, "assign_static");
return FALSE;
case array_of_nb_terms:
#ifdef MULTI_ASSIGNMENT_VARIABLES
2016-04-26 15:33:16 +01:00
{
Term t = ptr->ValueOfVE.lterms[indx].tlive;
Functor f;
/* we have a mutable term there */
if (IsVarTerm(t) || !IsApplTerm(t) ||
(f = FunctorOfTerm(t)) != FunctorAtFoundOne) {
Term tn = Yap_NewTimedVar(t3);
CELL *sp = RepAppl(tn);
*sp = (CELL)FunctorAtFoundOne;
YapBind(&(ptr->ValueOfVE.lterms[indx].tlive), tn);
} else {
Yap_UpdateTimedVar(t, t3);
}
2016-04-26 15:33:16 +01:00
}
WRITE_UNLOCK(ptr->ArRWLock);
return TRUE;
#else
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, t2, "update_array");
return FALSE;
#endif
}
WRITE_UNLOCK(ptr->ArRWLock);
return TRUE;
}
2014-09-15 09:13:50 +01:00
/** @pred add_to_array_element(+ _Name_, + _Index_, + _Number_, ? _NewValue_)
Add _Number_ _Name_[ _Index_] and unify _NewValue_ with
the incremented value. Observe that _Name_[ _Index_] must be an
number. If _Name_ is a static array the type of the array must be
`int` or `float`. If the type of the array is `int` you
only may add integers, if it is `float` you may add integers or
floats. If _Name_ corresponds to a dynamic array the array element
must have been previously bound to a number and `Number` can be
any kind of number.
The `add_to_array_element/3` built-in actually uses
`setarg/3` to update elements of dynamic arrays. For intensive
operations we suggest it may be less expensive to unify each element
of the array with a mutable terms and to use the operations on mutable
terms.
*/
2016-04-26 15:33:16 +01:00
static Int add_to_array_element(USES_REGS1) {
Term t1, t2, t3;
StaticArrayEntry *ptr;
Int indx;
t2 = Deref(ARG2);
if (IsNonVarTerm(t2)) {
Term nti;
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(nti = Yap_Eval(t2))) {
indx = IntegerOfTerm(nti);
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, t2, "add_to_array_element");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t2, "add_to_array_element");
return (FALSE);
}
t1 = Deref(ARG1);
if (IsVarTerm(t1)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t1, "add_to_array_element");
return (FALSE);
}
t3 = Deref(ARG3);
if (IsVarTerm(t3)) {
2016-04-26 15:33:16 +01:00
Yap_Error(INSTANTIATION_ERROR, t3, "add_to_array_element");
return (FALSE);
}
if (!IsAtomTerm(t1)) {
if (IsApplTerm(t1)) {
CELL *ptr;
Functor f = FunctorOfTerm(t1);
Term ta;
/* store the terms to visit */
if (IsExtensionFunctor(f)) {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ARRAY, t1, "add_to_array_element");
return (FALSE);
}
if (indx > 0 && indx > ArityOfFunctor(f)) {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "add_to_array_element");
return (FALSE);
}
2016-04-26 15:33:16 +01:00
ptr = RepAppl(t1) + indx + 1;
ta = RepAppl(t1)[indx + 1];
if (IsIntegerTerm(ta)) {
2016-04-26 15:33:16 +01:00
if (IsIntegerTerm(t3)) {
ta = MkIntegerTerm(IntegerOfTerm(ta) + IntegerOfTerm(t3));
} else if (IsFloatTerm(t3)) {
ta = MkFloatTerm(IntegerOfTerm(ta) + FloatOfTerm(t3));
} else {
Yap_Error(TYPE_ERROR_NUMBER, t3, "add_to_array_element");
return (FALSE);
}
} else if (IsFloatTerm(ta)) {
2016-04-26 15:33:16 +01:00
if (IsFloatTerm(t3)) {
ta = MkFloatTerm(FloatOfTerm(ta) + IntegerOfTerm(t3));
} else if (IsFloatTerm(t3)) {
ta = MkFloatTerm(FloatOfTerm(ta) + FloatOfTerm(t3));
} else {
Yap_Error(TYPE_ERROR_NUMBER, t3, "add_to_array_element");
return (FALSE);
}
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_NUMBER, ta, "add_to_array_element");
return (FALSE);
}
#ifdef MULTI_ASSIGNMENT_VARIABLES
MaBind(ptr, ta);
2016-04-26 15:33:16 +01:00
return (Yap_unify(ARG4, ta));
#else
2016-04-26 15:33:16 +01:00
Yap_Error(SYSTEM_ERROR_INTERNAL, t2, "add_to_array_element");
return (FALSE);
#endif
} else {
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t1, "add_to_array_element");
return (FALSE);
}
}
{
AtomEntry *ae = RepAtom(AtomOfTerm(t1));
READ_LOCK(ae->ARWLock);
2016-04-26 15:33:16 +01:00
ptr = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(ptr) && ptr->KindOfPE != ArrayProperty)
ptr = RepStaticArrayProp(ptr->NextOfPE);
READ_UNLOCK(ae->ARWLock);
}
if (EndOfPAEntr(ptr)) {
2016-04-26 15:33:16 +01:00
Yap_Error(EXISTENCE_ERROR_ARRAY, t1, "add_to_array_element %s",
RepAtom(AtomOfTerm(t1))->StrOfAE);
return (FALSE);
}
if (ArrayIsDynamic((ArrayEntry *)ptr)) {
ArrayEntry *pp = (ArrayEntry *)ptr;
CELL *pt;
Term ta;
WRITE_LOCK(pp->ArRWLock);
if (indx < 0 || indx >= pp->ArrayEArity) {
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "add_to_array_element");
READ_UNLOCK(pp->ArRWLock);
return FALSE;
}
pt = RepAppl(pp->ValueOfVE) + indx + 1;
2016-04-26 15:33:16 +01:00
ta = RepAppl(pp->ValueOfVE)[indx + 1];
if (IsIntegerTerm(ta)) {
if (IsIntegerTerm(t3)) {
2016-04-26 15:33:16 +01:00
ta = MkIntegerTerm(IntegerOfTerm(ta) + IntegerOfTerm(t3));
} else if (IsFloatTerm(t3)) {
2016-04-26 15:33:16 +01:00
ta = MkFloatTerm(IntegerOfTerm(ta) + FloatOfTerm(t3));
} else {
2016-04-26 15:33:16 +01:00
WRITE_UNLOCK(pp->ArRWLock);
Yap_Error(TYPE_ERROR_NUMBER, t3, "add_to_array_element");
return FALSE;
}
} else if (IsFloatTerm(ta)) {
if (IsFloatTerm(t3)) {
2016-04-26 15:33:16 +01:00
ta = MkFloatTerm(FloatOfTerm(ta) + IntegerOfTerm(t3));
} else if (IsFloatTerm(t3)) {
2016-04-26 15:33:16 +01:00
ta = MkFloatTerm(FloatOfTerm(ta) + FloatOfTerm(t3));
} else {
2016-04-26 15:33:16 +01:00
WRITE_UNLOCK(pp->ArRWLock);
Yap_Error(TYPE_ERROR_NUMBER, t3, "add_to_array_element");
return FALSE;
}
} else {
WRITE_UNLOCK(pp->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_NUMBER, ta, "add_to_array_element");
return FALSE;
}
/* the evil deed is to be done now */
MaBind(pt, ta);
WRITE_UNLOCK(pp->ArRWLock);
2016-04-26 15:33:16 +01:00
return Yap_unify(ARG4, t3);
}
WRITE_LOCK(ptr->ArRWLock);
/* a static array */
if (indx < 0 || indx >= ptr->ArrayEArity) {
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, t2, "add_to_array_element");
return FALSE;
}
switch (ptr->ArrayType) {
2016-04-26 15:33:16 +01:00
case array_of_ints: {
Int i = ptr->ValueOfVE.ints[indx];
if (!IsIntegerTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_INTEGER, t3, "add_to_array_element");
return FALSE;
}
2016-04-26 15:33:16 +01:00
i += IntegerOfTerm(t3);
ptr->ValueOfVE.ints[indx] = i;
WRITE_UNLOCK(ptr->ArRWLock);
return Yap_unify(ARG4, MkIntegerTerm(i));
} break;
case array_of_doubles: {
Float fl = ptr->ValueOfVE.floats[indx];
if (IsFloatTerm(t3)) {
fl += FloatOfTerm(t3);
} else if (IsIntegerTerm(t3)) {
fl += IntegerOfTerm(t3);
} else {
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_NUMBER, t3, "add_to_array_element");
return FALSE;
}
2016-04-26 15:33:16 +01:00
ptr->ValueOfVE.floats[indx] = fl;
WRITE_UNLOCK(ptr->ArRWLock);
return Yap_unify(ARG4, MkFloatTerm(fl));
} break;
default:
WRITE_UNLOCK(ptr->ArRWLock);
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_NUMBER, t2, "add_to_array_element");
return FALSE;
}
}
2016-04-26 15:33:16 +01:00
static Int compile_array_refs(USES_REGS1) {
compile_arrays = TRUE;
return (TRUE);
}
2016-04-26 15:33:16 +01:00
static Int array_refs_compiled(USES_REGS1) { return compile_arrays; }
2016-04-26 15:33:16 +01:00
static Int sync_mmapped_arrays(USES_REGS1) {
#ifdef HAVE_MMAP
mmap_array_block *ptr = GLOBAL_mmap_arrays;
while (ptr != NULL) {
msync(ptr->start, ptr->size, MS_SYNC);
ptr = ptr->next;
}
#endif
2016-04-26 15:33:16 +01:00
return (TRUE);
}
2014-09-15 09:13:50 +01:00
/** @pred static_array_to_term(? _Name_, ? _Term_)
Convert a static array with name
_Name_ to a compound term of name _Name_.
This built-in will silently fail if the there is no static array with
that name.
*/
2016-04-26 15:33:16 +01:00
static Int static_array_to_term(USES_REGS1) {
Term t = Deref(ARG1);
if (IsVarTerm(t)) {
return FALSE;
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
StaticArrayEntry *pp;
READ_LOCK(ae->ARWLock);
pp = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
READ_UNLOCK(ae->ARWLock);
return (FALSE);
} else {
static_array_types tp = pp->ArrayType;
2014-01-02 21:59:02 +00:00
Int dim = pp->ArrayEArity, indx;
CELL *base;
2016-04-26 15:33:16 +01:00
while (HR + 1 + dim > ASP - 1024) {
if (!Yap_gcl((1 + dim) * sizeof(CELL), 2, ENV, gc_P(P, CP))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return (FALSE);
} else {
if (HR + 1 + dim > ASP - 1024) {
if (!Yap_growstack(sizeof(CELL) * (dim + 1 - (HR - ASP - 1024)))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
}
}
}
READ_LOCK(pp->ArRWLock);
READ_UNLOCK(ae->ARWLock);
2014-01-19 21:15:05 +00:00
base = HR;
2016-04-26 15:33:16 +01:00
*HR++ = (CELL)Yap_MkFunctor(AbsAtom(ae), dim);
switch (tp) {
case array_of_ints: {
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
*sptr++ = MkIntegerTerm(pp->ValueOfVE.ints[indx]);
}
} break;
case array_of_dbrefs:
2016-04-26 15:33:16 +01:00
for (indx = 0; indx < dim; indx++) {
/* The object is now in use */
Term TRef = pp->ValueOfVE.dbrefs[indx];
2016-04-26 15:33:16 +01:00
if (TRef != 0L) {
DBRef ref = DBRefOfTerm(TRef);
LOCK(ref->lock);
#if MULTIPLE_STACKS
2016-04-26 15:33:16 +01:00
INC_DBREF_COUNT(ref);
TRAIL_REF(ref); /* So that fail will erase it */
#else
2016-04-26 15:33:16 +01:00
if (!(ref->Flags & InUseMask)) {
ref->Flags |= InUseMask;
TRAIL_REF(ref); /* So that fail will erase it */
}
#endif
2016-04-26 15:33:16 +01:00
UNLOCK(ref->lock);
} else {
TRef = TermNil;
}
*HR++ = TRef;
}
break;
case array_of_doubles: {
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
*sptr++ = MkEvalFl(pp->ValueOfVE.floats[indx]);
}
} break;
case array_of_ptrs: {
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
*sptr++ = MkAddressTerm(pp->ValueOfVE.ptrs[indx]);
}
} break;
case array_of_chars: {
CACHE_REGS
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
*sptr++ = MkIntTerm(pp->ValueOfVE.chars[indx]);
}
} break;
case array_of_uchars: {
CACHE_REGS
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
*sptr++ = MkIntTerm(pp->ValueOfVE.uchars[indx]);
}
} break;
case array_of_terms: {
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
/* The object is now in use */
DBTerm *ref = pp->ValueOfVE.terms[indx];
Term TRef = GetTermFromArray(ref PASS_REGS);
if (P == FAILCODE) {
return FALSE;
}
*sptr++ = TRef;
}
} break;
case array_of_nb_terms: {
CELL *sptr = HR;
HR += dim;
for (indx = 0; indx < dim; indx++) {
/* The object is now in use */
Term To = GetNBTerm(pp->ValueOfVE.lterms, indx PASS_REGS);
if (P == FAILCODE) {
return FALSE;
}
*sptr++ = To;
}
} break;
case array_of_atoms:
2016-04-26 15:33:16 +01:00
for (indx = 0; indx < dim; indx++) {
Term out;
out = pp->ValueOfVE.atoms[indx];
if (out == 0L)
out = TermNil;
*HR++ = out;
}
break;
}
READ_UNLOCK(pp->ArRWLock);
2016-04-26 15:33:16 +01:00
return Yap_unify(AbsAppl(base), ARG2);
}
}
2016-04-26 15:33:16 +01:00
Yap_Error(TYPE_ERROR_ATOM, t, "add_to_array_element");
return FALSE;
}
2014-09-15 09:13:50 +01:00
/** @pred static_array_location(+ _Name_, - _Ptr_)
Give the location or memory address for a static array with name
_Name_. The result is observed as an integer.
*/
2016-04-26 15:33:16 +01:00
static Int static_array_location(USES_REGS1) {
Term t = Deref(ARG1);
Int *ptr;
if (IsVarTerm(t)) {
return FALSE;
} else if (IsAtomTerm(t)) {
/* Create a named array */
AtomEntry *ae = RepAtom(AtomOfTerm(t));
StaticArrayEntry *pp;
READ_LOCK(ae->ARWLock);
pp = RepStaticArrayProp(ae->PropsOfAE);
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
READ_UNLOCK(ae->ARWLock);
return FALSE;
} else {
2016-04-26 15:33:16 +01:00
ptr = pp->ValueOfVE.ints;
READ_UNLOCK(ae->ARWLock);
}
2016-04-26 15:33:16 +01:00
return Yap_unify(ARG2, MkAddressTerm(ptr));
}
return FALSE;
}
2016-04-26 15:33:16 +01:00
void Yap_InitArrayPreds(void) {
Yap_InitCPred("$create_array", 2, create_array, SyncPredFlag);
Yap_InitCPred("$array_references", 3, array_references, SafePredFlag);
Yap_InitCPred("$array_arg", 3, array_arg, SafePredFlag);
2016-04-26 15:33:16 +01:00
Yap_InitCPred("static_array", 3, create_static_array,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("resize_static_array", 3, resize_static_array,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("mmapped_array", 4, create_mmapped_array,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("update_array", 3, assign_static, SafePredFlag);
Yap_InitCPred("dynamic_update_array", 3, assign_dynamic, SafePredFlag);
Yap_InitCPred("add_to_array_element", 4, add_to_array_element, SafePredFlag);
Yap_InitCPred("array_element", 3, access_array, 0);
Yap_InitCPred("reset_static_array", 1, clear_static_array, SafePredFlag);
Yap_InitCPred("close_static_array", 1, close_static_array, SafePredFlag);
Yap_InitCPred("$sync_mmapped_arrays", 0, sync_mmapped_arrays, SafePredFlag);
Yap_InitCPred("$compile_array_refs", 0, compile_array_refs, SafePredFlag);
Yap_InitCPred("$array_refs_compiled", 0, array_refs_compiled, SafePredFlag);
2016-04-26 15:33:16 +01:00
Yap_InitCPred("$static_array_properties", 3, static_array_properties,
SafePredFlag);
Yap_InitCPred("static_array_to_term", 2, static_array_to_term, 0L);
Yap_InitCPred("static_array_location", 2, static_array_location, 0L);
}
2014-09-11 20:06:57 +01:00
/**
@}
*/