/* execute a command as a detached process */
static YAP_Bool do_shell(void) {
#if defined(__MINGW32__) || _MSC_VER
YAP_Error(0, 0L, "system not available in this configuration");
return (FALSE);
#elif HAVE_SYSTEM
char *buf = YAP_AllocSpaceFromYap(BUF_SIZE);
int sys;
if (buf == NULL) {
YAP_Error(0, 0L, "No Temporary Space for Shell");
return (FALSE);
}
#if HAVE_STRNCPY
strncpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1)), BUF_SIZE);
strncpy(buf, " ", BUF_SIZE);
strncpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), BUF_SIZE);
strncpy(buf, " ", BUF_SIZE);
strncpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), BUF_SIZE);
#else
strcpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1)));
strcpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)));
strcpy(buf, " ");
strcpy(buf, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)));
#endif
sys = system(buf);
YAP_FreeSpaceFromYap(buf);
if (sys < 0) {
return YAP_Unify(YAP_ARG5, YAP_MkIntTerm(errno));
}
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(sys));
#else
char *cptr[4];
int t;
int sys;
cptr[0] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
cptr[1] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2));
cptr[2] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3));
cptr[3] = NULL;
t = fork();
if (t < 0) {
return YAP_Unify(YAP_ARG5, YAP_MkIntTerm(errno));
} else if (t == 0) {
t = execvp(cptr[0], cptr);
return t;
} else {
t = wait(&sys);
if (t < 0) {
return YAP_Unify(YAP_ARG5, YAP_MkIntTerm(errno));
}
}
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(sys));
#endif
}
static YAP_Bool point_list_to_sequence (YAP_Term term,
unsigned int size,
sequence_t *sequence)
{
YAP_Float x, y;
unsigned int n;
YAP_Term head;
*sequence = GEOSCoordSeq_create (size, 2);
if (*sequence == NULL)
return (FALSE);
for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++)
{
assert (n < size);
head = YAP_HeadOfTerm (term);
if ((Yap_IsNumberTerm (YAP_ArgOfTerm (1, head), &x) == FALSE)
|| (Yap_IsNumberTerm (YAP_ArgOfTerm (2, head), &y) == FALSE)
|| (GEOSCoordSeq_setX (*sequence, n, x) == 0)
|| (GEOSCoordSeq_setY (*sequence, n, y) == 0))
{
GEOSCoordSeq_destroy (*sequence);
return (FALSE);
}
term = YAP_TailOfTerm (term);
}
assert (n == size);
assert (YAP_IsAtomTerm (term) != FALSE);
assert (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") == 0);
return (TRUE);
}
static int
p_startmatlab(void)
{
char opts[BUFSIZE];
const char *ptr;
YAP_Term topts = YAP_ARG1;
if (Meng)
return TRUE;
if (YAP_IsAtomTerm(topts))
ptr = YAP_AtomName(YAP_AtomOfTerm(topts));
else
{
if (!YAP_StringToBuffer(topts,opts, BUFSIZE))
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1));
ptr = opts;
}
if (!strlen(ptr)) {
if (!(Meng = engOpen("\0"))) {
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-2));
}
} else {
if (!(Meng = engOpen(ptr))) {
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-2));
}
}
engOutputBuffer(Meng, NULL, 0);
return TRUE;
}
static int
p_create_cell_matrix_and_copy1(void)
{
int rows, cols;
mxArray *mat;
YAP_Term tl = YAP_ARG3;
rows = YAP_IntOfTerm(YAP_ARG1);
cols = YAP_IntOfTerm(YAP_ARG2);
if (!(mat = mxCreateCellMatrix(rows, cols)))
return FALSE;
while (YAP_IsPairTerm(tl)) {
YAP_Term th = YAP_HeadOfTerm(tl);
int off = MAT_ACCESS(YAP_IntOfTerm(YAP_ArgOfTerm(1,th))-1,
YAP_IntOfTerm(YAP_ArgOfTerm(2,th))-1,
rows,cols);
mxArray *mat2 = get_array(YAP_ArgOfTerm(3,th));
mxSetCell(mat,off, mat2);
tl = YAP_TailOfTerm(tl);
}
if (YAP_IsAtomTerm(YAP_ARG4)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat);
}
return YAP_Unify(YAP_ARG4,address2term(mat));
}
static YAP_Bool p_mktemp(void) {
#if HAVE_MKSTEMP || HAVE_MKTEMP || defined(__MINGW32__) || _MSC_VER
char *s, tmp[BUF_SIZE];
s = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if HAVE_STRNCPY
strncpy(tmp, s, BUF_SIZE);
#else
strcpy(tmp, s);
#endif
#if defined(__MINGW32__) || _MSC_VER
if ((s = _mktemp(tmp)) == NULL) {
/* return an error number */
return (YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno)));
}
return (YAP_Unify(YAP_ARG2, YAP_MkAtomTerm(YAP_LookupAtom(s))));
#elif HAVE_MKSTEMP
strcpy(tmp, "/tmp/YAP_tmpXXXXXXXX");
if (mkstemp(tmp) == -1) {
/* return an error number */
return (YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno)));
}
return YAP_Unify(YAP_ARG2, YAP_MkAtomTerm(YAP_LookupAtom(tmp)));
#else
if ((s = mktemp(tmp)) == NULL) {
/* return an error number */
return (YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno)));
}
return YAP_Unify(YAP_ARG2, YAP_MkAtomTerm(YAP_LookupAtom(s)));
#endif
#else
return FALSE;
#endif
return (TRUE);
}
static int
cuda_load_fact( void ) {
int i = currentFact;
#if defined(DATALOG) || defined(TUFFY)
YAP_Term th = YAP_ARG1;
int ncols = currentPred->num_columns;
int j;
int *mat = currentPred->address_host_table;
for (j = 0; j < ncols; j++) {
YAP_Term ta = YAP_ArgOfTerm(j+1, th);
if (YAP_IsAtomTerm(ta)) {
mat[i*ncols+j] = YAP_AtomToInt(YAP_AtomOfTerm(ta));
} else {
mat[i*ncols+j] = YAP_IntOfTerm(ta);
}
}
#endif
i++;
if (i == currentPred->num_rows) {
Cuda_NewFacts(currentPred);
currentPred = NULL;
currentFact = 0;
} else {
currentFact = i;
}
return TRUE;
}
static mxArray*
get_array(YAP_Term ti)
{
if (YAP_IsIntTerm(ti)) {
return mxCreateDoubleScalar(YAP_IntOfTerm(ti));
} else if (YAP_IsFloatTerm(ti)) {
return mxCreateDoubleScalar(YAP_FloatOfTerm(ti));
} else if (YAP_IsAtomTerm(ti)) {
return matlab_getvar(ti);
} else if (YAP_IsPairTerm(ti)) {
YAP_Term tv = YAP_HeadOfTerm(ti);
YAP_Term tf = YAP_TailOfTerm(ti);
const mxArray *mout;
if (!YAP_IsAtomTerm(tv)) {
char s[BUFSIZE];
if (!YAP_StringToBuffer(ti, s, BUFSIZE))
return FALSE;
return mxCreateString(s);
}
mout = matlab_getvar(tv);
if (!mout)
return FALSE;
if (YAP_IsIntTerm(tf)) {
return mxGetFieldByNumber(mout, 0, YAP_IntOfTerm(tf));
} else if (YAP_IsAtomTerm(tf)) {
const char *s=YAP_AtomName(YAP_AtomOfTerm(tf));
return mxGetField(mout, 0, s);
} else {
return NULL;
}
} else {
return (mxArray *)YAP_IntOfTerm(YAP_ArgOfTerm(1,ti));
}
}
static int p_trie_mode(void) {
YAP_Term mode_term;
const char *mode_str;
YAP_Int mode;
/* get mode */
if (YAP_IsVarTerm(arg_mode)) {
mode = trie_get_mode();
if (mode == TRIE_MODE_STANDARD)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("std"));
else if (mode == TRIE_MODE_REVERSE)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("rev"));
else
return FALSE;
return YAP_Unify(arg_mode, mode_term);
}
/* set mode */
mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
if (!strcmp(mode_str, "std"))
mode = TRIE_MODE_STANDARD;
else if (!strcmp(mode_str, "rev"))
mode = TRIE_MODE_REVERSE;
else
return FALSE;
trie_set_mode(mode);
return TRUE;
}
static int cuda_init_query(void)
{
int32_t pname = YAP_AtomToInt(YAP_AtomOfTerm(YAP_ARG1));
query[qcont] = pname;
qcont++;
query[qcont] = 0;
return TRUE;
}
static int
cp_back(YAP_Term vart, mxArray *mat)
{
if (!YAP_IsAtomTerm(vart)) {
return TRUE;
}
/* save back to matlab */
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(vart)), mat);
}
static int
p_call_matlab(void)
{
YAP_Term tlength = YAP_ARG2,
tl = YAP_ARG3,
tname = YAP_ARG1,
tolength = YAP_ARG4,
tout = YAP_ARG5;
int i = 0;
mxArray *inps[50], *outs[50];
const char *name;
int olength = YAP_IntOfTerm(tolength);
if (!YAP_IsAtomTerm(tname))
return FALSE;
name = YAP_AtomName(YAP_AtomOfTerm(tname));
if (!YAP_IsIntTerm(tlength))
return FALSE;
while (YAP_IsPairTerm(tl)) {
inps[i] = get_array(YAP_HeadOfTerm(tl));
i++;
tl = YAP_TailOfTerm(tl);
}
if (mexCallMATLAB(olength, outs, i, inps, name))
return FALSE;
/* output arguments */
if (YAP_IsPairTerm(tout)) {
for (i=0; i<olength; i++) {
YAP_Term ti = YAP_HeadOfTerm(tout);
if (YAP_IsAtomTerm(ti)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(ti)), outs[i]);
} else {
return YAP_Unify(ti,address2term(outs[i]));
}
}
} else {
YAP_Term to = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
for (i=olength; i>0; i--) {
to = YAP_MkPairTerm(address2term(outs[i-1]),to);
}
}
return TRUE;
}
/* Check if a prolog `term' is a well formed list and optionally
return it's size if the variable `size' is not NULL. */
static YAP_Bool is_list_get_size (YAP_Term term, unsigned int *size)
{
unsigned int n;
for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++)
term = YAP_TailOfTerm (term);
if ((YAP_IsAtomTerm (term) == FALSE)
|| (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") != 0))
return (FALSE);
if (size != NULL)
*size = n;
return (TRUE);
}
static YAP_Bool p_unlink(void) {
char *fd = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if defined(__MINGW32__) || _MSC_VER
if (_unlink(fd) == -1)
#else
if (unlink(fd) == -1)
#endif
{
/* return an error number */
return (YAP_Unify(YAP_ARG2, YAP_MkIntTerm(errno)));
}
return (TRUE);
}
static int
cuda_coverage( void )
{
int32_t *mat;
#if defined(DATALOG) || defined(TUFFY)
int32_t *query = NULL;
setQuery(YAP_ARG1, &query);
#endif
int32_t n = Cuda_Eval(facts, cf, rules, cr, query, & mat, 0, 0);
int32_t post = YAP_AtomToInt(YAP_AtomOfTerm(YAP_ARG2));
int32_t i = n/2, min = 0, max = n-1;
int32_t t0, t1;
if (n < 0)
return FALSE;
if (n == 0) {
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(0)) &&
YAP_Unify(YAP_ARG3, YAP_MkIntTerm(0));
}
t0 = mat[0], t1 = mat[(n-1)*2];
if (t0 == t1) { /* all sametype */
free( mat );
/* all pos */
if (t0 == post)
return YAP_Unify(YAP_ARG3, YAP_MkIntTerm(n)) &&
YAP_Unify(YAP_ARG4, YAP_MkIntTerm(0));
/* all neg */
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(n)) &&
YAP_Unify(YAP_ARG3, YAP_MkIntTerm(0));
}
do {
i = (min+max)/2;
if (i == min) i++;
if (mat[i*2] == t0) {
min = i;
} else {
max = i;
}
if (min+1 == max) {
free( mat );
if (t0 == post)
return YAP_Unify(YAP_ARG3, YAP_MkIntTerm(max)) &&
YAP_Unify(YAP_ARG4, YAP_MkIntTerm(n-max));
/* all neg */
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm(max)) &&
YAP_Unify(YAP_ARG3, YAP_MkIntTerm(n-max));
}
} while ( TRUE );
}
/** @pred system(+ _S_)
Passes command _S_ to the Bourne shell (on UNIX environments) or the
current command interpreter in WIN32 environments.
Note that it executes them command as a detached process. It requires
`system` to be implemented by the system library.
*/
static YAP_Bool do_system(void) {
char *command = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if HAVE_SYSTEM
int sys = system(command);
if (sys < 0) {
return YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno));
}
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(sys));
#else
YAP_Error(0, 0L, "system not available in this configuration, trying %s",
command);
return FALSE;
#endif
}
static int
p_create_double_vector(void)
{
mwSize dims[1];
mxArray *mat;
dims[0] = YAP_IntOfTerm(YAP_ARG1);
if (!(mat = mxCreateNumericArray(1, dims, mxDOUBLE_CLASS, mxREAL)))
return FALSE;
if (YAP_IsAtomTerm(YAP_ARG2)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), mat);
}
return YAP_Unify(YAP_ARG2,address2term(mat));
}
static int
p_create_cell_vector(void)
{
mwSize dims[1];
mxArray *mat;
dims[0] = YAP_IntOfTerm(YAP_ARG1);
if (!(mat = mxCreateCellArray(1, dims)))
return FALSE;
if (YAP_IsAtomTerm(YAP_ARG2)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), mat);
}
return YAP_Unify(YAP_ARG2,address2term(mat));
}
static YAP_Bool list_to_geometry (YAP_Term term,
unsigned int minimum,
procedure_to_geometry_t procedure,
geometry_type_t geometry_type,
geometry_t *geometry)
{
geometry_t *p;
unsigned int size;
unsigned int v, n;
YAP_Term head;
assert (geometry != NULL);
term = YAP_ArgOfTerm (1, term);
if ((is_list_get_size (term, &size) == FALSE) || (size < minimum))
return (FALSE);
p = (geometry_t *) malloc (sizeof (geometry_t) * size);
if (p == NULL)
{
warning ("%s: list_to_geometry: not enough memory", __FILE__);
return (FALSE);
}
memset (p, 0, sizeof (geometry_t) * size);
for (n = 0; YAP_IsPairTerm (term) != FALSE; n ++)
{
assert (n < size);
head = YAP_HeadOfTerm (term);
if (procedure (head, &p[n]) == FALSE)
{
for (v = 0; v < n; v ++)
GEOSGeom_destroy (p[v]);
free (p);
return (FALSE);
}
term = YAP_TailOfTerm (term);
}
assert (n == size);
assert (YAP_IsAtomTerm (term) != FALSE);
assert (strcmp (YAP_AtomName (YAP_AtomOfTerm (term)), "[]") == 0);
if (geometry_type == GEOS_POLYGON)
*geometry = GEOSGeom_createPolygon (p[0], p + 1, size - 1);
else
*geometry = GEOSGeom_createCollection (geometry_type, p, size);
memset (p, 0, sizeof (geometry_t) * size);
free (p);
if (*geometry == NULL)
return (FALSE);
return (TRUE);
}
static int
cuda_init_facts( void ) {
int32_t nrows = YAP_IntOfTerm(YAP_ARG1);
int32_t ncols = YAP_IntOfTerm(YAP_ARG2);
int32_t *mat = (int32_t *)malloc(sizeof(int32_t)*nrows*ncols);
int32_t pname = YAP_AtomToInt(YAP_AtomOfTerm(YAP_ARG3));
predicate *pred;
strcat(names, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)));
strcat(names, " ");
if (!mat)
return FALSE;
if (YAP_IsVarTerm( YAP_ARG4)) {
// new
pred = (predicate *)malloc(sizeof(predicate));
} else {
pred = (predicate *)YAP_IntOfTerm(YAP_ARG4);
if (pred->address_host_table)
free( pred->address_host_table );
}
pred->name = pname;
pred->num_rows = nrows;
pred->num_columns = ncols;
pred->is_fact = TRUE;
pred->address_host_table = mat;
currentPred = pred;
currentFact = 0;
if (YAP_IsVarTerm( YAP_ARG4)) {
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm((YAP_Int)pred));
} else {
return TRUE;
}
}
static YAP_Bool p_rmdir(void) {
char *fd = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if defined(__MINGW32__) || _MSC_VER
if (_rmdir(fd) == -1) {
#else
if (rmdir(fd) == -1) {
#endif
/* return an error number */
return (YAP_Unify(YAP_ARG2, YAP_MkIntTerm(errno)));
}
return (TRUE);
}
static YAP_Bool rename_file(void) {
char *s1 = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
char *s2 = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2));
#if HAVE_RENAME
if (rename(s1, s2) == -1) {
/* return an error number */
return (YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno)));
}
#endif
return (TRUE);
}
static int
p_create_double_array(void)
{
int rows, cols;
mxArray *mat;
rows = YAP_IntOfTerm(YAP_ARG1);
cols = YAP_IntOfTerm(YAP_ARG2);
if (!(mat = mxCreateDoubleMatrix(rows, cols, mxREAL)))
return FALSE;
if (YAP_IsAtomTerm(YAP_ARG3)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), mat);
}
return YAP_Unify(YAP_ARG3,address2term(mat));
}
static int
p_evalstring2(void)
{
char com[BUFSIZE];
YAP_Term tcom = YAP_ARG1;
const char *comd;
if (YAP_IsAtomTerm(tcom))
comd = YAP_AtomName(YAP_AtomOfTerm(tcom));
else {
if (!YAP_StringToBuffer(tcom, com, BUFSIZE))
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1));
comd = com;
}
return !engEvalString(Meng, comd);
}
static int
load_facts( void ) {
int32_t nrows = YAP_IntOfTerm(YAP_ARG1);
int32_t ncols = YAP_IntOfTerm(YAP_ARG2), i = 0;
YAP_Term t3 = YAP_ARG3;
int32_t *mat = (int32_t *)malloc(sizeof(int32_t)*nrows*ncols);
int32_t pname = YAP_AtomToInt(YAP_NameOfFunctor(YAP_FunctorOfTerm(YAP_HeadOfTerm(t3))));
predicate *pred;
while(YAP_IsPairTerm(t3)) {
int32_t j = 0;
YAP_Term th = YAP_HeadOfTerm(t3);
for (j = 0; j < ncols; j++) {
YAP_Term ta = YAP_ArgOfTerm(j+1, th);
if (YAP_IsAtomTerm(ta)) {
mat[i*ncols+j] = YAP_AtomToInt(YAP_AtomOfTerm(ta));
} else {
mat[i*ncols+j] = YAP_IntOfTerm(ta);
}
}
t3 = YAP_TailOfTerm( t3 );
i++;
}
if (YAP_IsVarTerm( YAP_ARG4)) {
// new
pred = (predicate *)malloc(sizeof(predicate));
} else {
pred = (predicate *)YAP_IntOfTerm(YAP_ARG4);
if (pred->address_host_table)
free( pred->address_host_table );
}
pred->name = pname;
pred->num_rows = nrows;
pred->num_columns = ncols;
pred->is_fact = TRUE;
pred->address_host_table = mat;
Cuda_NewFacts(pred);
if (YAP_IsVarTerm( YAP_ARG4)) {
return YAP_Unify(YAP_ARG4, YAP_MkIntTerm((YAP_Int)pred));
} else {
return TRUE;
}
}
static int optimizer_get_parameter( void ) {
YAP_Term t1 = YAP_ARG1;
YAP_Term t2 = YAP_ARG2;
if (! YAP_IsAtomTerm(t1)) {
return FALSE;
}
const char* name=YAP_AtomName(YAP_AtomOfTerm(t1));
if ((strcmp(name, "m") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.m));
} else if ((strcmp(name, "epsilon") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.epsilon));
} else if ((strcmp(name, "past") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.past));
} else if ((strcmp(name, "delta") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.delta));
} else if ((strcmp(name, "max_iterations") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.max_iterations));
} else if ((strcmp(name, "linesearch") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.linesearch));
} else if ((strcmp(name, "max_linesearch") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.max_linesearch));
} else if ((strcmp(name, "min_step") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.min_step));
} else if ((strcmp(name, "max_step") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.max_step));
} else if ((strcmp(name, "ftol") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.ftol));
} else if ((strcmp(name, "gtol") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.gtol));
} else if ((strcmp(name, "xtol") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.xtol));
} else if ((strcmp(name, "orthantwise_c") == 0)) {
return YAP_Unify(t2,YAP_MkFloatTerm(param.orthantwise_c));
} else if ((strcmp(name, "orthantwise_start") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.orthantwise_start));
} else if ((strcmp(name, "orthantwise_end") == 0)) {
return YAP_Unify(t2,YAP_MkIntTerm(param.orthantwise_end));
}
printf("ERROR: The parameter %s is unknown.\n",name);
return FALSE;
}
static YAP_Bool read_link(void) {
char *s1 = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
#if HAVE_READLINK
char buf[MAXPATHLEN + 1];
if (readlink(s1, buf, MAXPATHLEN) < 0)
return false;
/* return an error number */
if (!YAP_Unify(YAP_ARG2, YAP_MkAtomTerm(YAP_LookupAtom(buf)))) {
return false;
}
#endif
#if _WIN32
return false;
#endif
return true;
}
static int p_itrie_mode(void) {
YAP_Term mode_term;
const char *mode_str;
YAP_Int mode;
/* check arg */
if (!YAP_IsIntTerm(arg_itrie))
return FALSE;
/* get mode */
if (YAP_IsVarTerm(arg_mode)) {
mode = itrie_get_mode((TrEntry) YAP_IntOfTerm(arg_itrie));
if (mode == ITRIES_MODE_INC_POS)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("inc_pos"));
else if (mode == ITRIES_MODE_DEC_POS)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("dec_pos"));
else if (mode == ITRIES_MODE_INC_NEG)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("inc_neg"));
else if (mode == ITRIES_MODE_DEC_NEG)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("dec_neg"));
else if (mode == ITRIES_MODE_NONE)
mode_term = YAP_MkAtomTerm(YAP_LookupAtom("none"));
else
return FALSE;
return YAP_Unify(arg_mode, mode_term);
}
/* set mode */
mode_str = YAP_AtomName(YAP_AtomOfTerm(arg_mode));
if (!strcmp(mode_str, "inc_pos"))
mode = ITRIES_MODE_INC_POS;
else if (!strcmp(mode_str, "dec_pos"))
mode = ITRIES_MODE_DEC_POS;
else if (!strcmp(mode_str, "inc_neg"))
mode = ITRIES_MODE_INC_NEG;
else if (!strcmp(mode_str, "dec_neg"))
mode = ITRIES_MODE_DEC_NEG;
else if (!strcmp(mode_str, "none"))
mode = ITRIES_MODE_NONE;
else
return FALSE;
itrie_set_mode((TrEntry) YAP_IntOfTerm(arg_itrie), mode);
return TRUE;
}
static int p_itrie_save_as_trie(void) {
const char *file_str;
FILE *file;
/* check args */
if (!YAP_IsIntTerm(arg_itrie))
return FALSE;
if (!YAP_IsAtomTerm(arg_file))
return FALSE;
/* open file */
file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
if (!(file = fopen(file_str, "w")))
return FALSE;
/* save itrie as trie and close file */
itrie_save_as_trie((TrEntry) YAP_IntOfTerm(arg_itrie), file);
if (fclose(file))
return FALSE;
return TRUE;
}
static int
p_evalstring3(void)
{
int out;
YAP_Term tcom = YAP_ARG1;
const char *comd;
char com[BUFSIZE];
char buf[OBUFSIZE];
buf[0] = '\0';
if (YAP_IsAtomTerm(tcom))
comd = YAP_AtomName(YAP_AtomOfTerm(tcom));
else {
if (!YAP_StringToBuffer(tcom, com, BUFSIZE))
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1));
comd = com;
}
engOutputBuffer(Meng, buf, OBUFSIZE);
out = !engEvalString(Meng, comd);
engOutputBuffer(Meng, NULL, 0);
return YAP_Unify(YAP_ARG2, YAP_BufferToString(buf));
}
static int
p_set_float_array(void)
{
int rows, cols, i = 0, j = 0;
double *input;
mxArray *mat;
YAP_Term tl = YAP_ARG3;
rows = YAP_IntOfTerm(YAP_ARG1);
cols = YAP_IntOfTerm(YAP_ARG2);
if (!(mat = mxCreateDoubleMatrix(rows, cols, mxREAL)))
return FALSE;
input = mxGetPr(mat);
/* copy ints to matrix. */
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
YAP_Term th;
if (!YAP_IsPairTerm(tl)) {
return FALSE;
}
th = YAP_HeadOfTerm(tl);
if (YAP_IsIntTerm(th)) {
input[MAT_ACCESS(i,j,rows,cols)] = YAP_IntOfTerm(th);
} else if (YAP_IsFloatTerm(th)) {
input[MAT_ACCESS(i,j,rows,cols)] = YAP_FloatOfTerm(th);
} else {
/* ERROR */
return FALSE;
}
tl = YAP_TailOfTerm(tl);
}
}
if (YAP_IsAtomTerm(YAP_ARG4)) {
return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat);
}
return YAP_Unify(YAP_ARG4,address2term(mat));
}
static int p_itrie_load(void) {
TrEntry itrie;
const char *file_str;
FILE *file;
/* check args */
if (!YAP_IsVarTerm(arg_itrie))
return FALSE;
if (!YAP_IsAtomTerm(arg_file))
return FALSE;
/* open file */
file_str = YAP_AtomName(YAP_AtomOfTerm(arg_file));
if (!(file = fopen(file_str, "r")))
return FALSE;
/* load itrie and close file */
if (!(itrie = itrie_load(file)))
return FALSE;
if (fclose(file))
return FALSE;
return YAP_Unify(arg_itrie, YAP_MkIntTerm((YAP_Int) itrie));
}
