static int p_itrie_get_data(void) {
YAP_Term list;
YAP_Term item;
YAP_Functor f;
YAP_Int pos, neg, time;
/* check arg */
if (!YAP_IsIntTerm(arg_ref))
return FALSE;
/* get data */
itrie_get_data((TrData) YAP_IntOfTerm(arg_ref), &pos, &neg, &time);
list = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
f = YAP_MkFunctor(YAP_LookupAtom("timestamp"), 1);
item = YAP_MkIntTerm(time);
item = YAP_MkApplTerm(f, 1, &item);
list = YAP_MkPairTerm(item, list);
f = YAP_MkFunctor(YAP_LookupAtom("neg"), 1);
item = YAP_MkIntTerm(neg);
item = YAP_MkApplTerm(f, 1, &item);
list = YAP_MkPairTerm(item, list);
f = YAP_MkFunctor(YAP_LookupAtom("pos"), 1);
item = YAP_MkIntTerm(pos);
item = YAP_MkApplTerm(f, 1, &item);
list = YAP_MkPairTerm(item, list);
return YAP_Unify(arg_data, list);
}
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 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 YAP_Bool make_multi_to_term (geometry_t geometry,
procedure_to_term_t procedure,
const char * functor_name,
YAP_Term *term)
{
int n;
geometry_t geometry_n;
YAP_Functor functor;
unsigned int size;
YAP_Term list, head;
assert (term != NULL);
list = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
size = GEOSGetNumGeometries (geometry);
for (n = size - 1; n >= 0; n --)
{
geometry_n = (geometry_t) GEOSGetGeometryN (geometry, n);
if (procedure (geometry_n, NULL, &head) == FALSE)
return (FALSE);
list = YAP_MkPairTerm (head, list);
}
functor = YAP_MkFunctor (YAP_LookupAtom (functor_name), 1);
*term = YAP_MkApplTerm (functor, 1, &list);
return (TRUE);
}
int main(int argc, char **argv)
#endif
{
int BootMode;
int i;
YAP_init_args init_args;
BootMode = init_standard_system(argc, argv, &init_args);
if (BootMode == YAP_BOOT_ERROR) {
fprintf(stderr, "[ FATAL ERROR: could not find saved state ]\n");
exit(1);
}
/* Begin preprocessor code */
if (BootMode != YAP_BOOT_FROM_SAVED_STACKS) {
// process the definitions
for (i = 0; i < init_args.def_c; ++i) {
YAP_Term t_args[2], t_goal;
t_args[0] = YAP_MkAtomTerm(YAP_LookupAtom(init_args.def_var[i]));
t_args[1] = YAP_MkAtomTerm(YAP_LookupAtom(init_args.def_value[i]));
t_goal = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom("ypp_define"), 2), 2,
t_args);
YAP_RunGoalOnce(t_goal);
}
}
YAP_Reset(YAP_FULL_RESET);
/* End preprocessor code */
exec_top_level(BootMode, &init_args);
return (0);
}
void
init_matlab(void)
{
MatlabAddress = YAP_MkFunctor(YAP_LookupAtom("MATLAB"),1);
YAP_UserCPredicate("start_matlab", p_startmatlab, 1);
YAP_UserCPredicate("close_matlab", p_closematlab, 0);
YAP_UserCPredicate("matlab_on", p_matlabon, 0);
YAP_UserCPredicate("matlab_eval_string", p_evalstring2, 1);
YAP_UserCPredicate("matlab_eval_string", p_evalstring3, 2);
YAP_UserCPredicate("matlab_cells", p_create_cell_vector, 2);
YAP_UserCPredicate("matlab_cells", p_create_cell_array, 3);
YAP_UserCPredicate("matlab_initialized_cells", p_create_cell_matrix_and_copy1, 4);
YAP_UserCPredicate("matlab_zeros", p_create_double_vector, 2);
YAP_UserCPredicate("matlab_zeros", p_create_double_array, 3);
YAP_UserCPredicate("matlab_zeros", p_create_double_array3, 4);
YAP_UserCPredicate("matlab_int_array", p_set_int_array, 4);
YAP_UserCPredicate("matlab_vector", p_set_float_vector, 3);
YAP_UserCPredicate("matlab_matrix", p_set_float_array, 4);
YAP_UserCPredicate("matlab_set_int", p_set_int, 4);
YAP_UserCPredicate("matlab_set", p_set_float, 4);
YAP_UserCPredicate("matlab_get_variable", p_get_variable, 2);
YAP_UserCPredicate("matlab_item", p_item, 3);
YAP_UserCPredicate("matlab_item", p_item2, 4);
YAP_UserCPredicate("matlab_item1", p_item_1, 3);
YAP_UserCPredicate("matlab_item1", p_item2_1, 4);
YAP_UserCPredicate("matlab_call_matlab", p_call_matlab, 5);
}
static YAP_Bool
mpi_get_processor_name(term_t YAP_ARG1,...) {
char name[MPI_MAX_PROCESSOR_NAME];
int length;
MPI_CALL(MPI_Get_processor_name(name,&length));
return (YAP_Unify(YAP_ARG1,YAP_MkAtomTerm(YAP_LookupAtom(name))));
}
static YAP_Bool error_message(void) {
#if HAVE_STRERROR
return YAP_Unify(YAP_ARG2, YAP_MkAtomTerm(YAP_LookupAtom(
strerror(YAP_IntOfTerm(YAP_ARG1)))));
#else
return YAP_Unify(YAP_ARG2, YAP_ARG1);
#endif
}
static YAP_Term WinError(void) {
char msg[256];
/* Error, we could not read time */
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
msg, 256, NULL);
return (YAP_MkAtomTerm(YAP_LookupAtom(msg)));
}
static YAP_Bool make_point (YAP_Float x,
YAP_Float y,
const char * functor_name,
YAP_Term *term)
{
YAP_Term p[2];
YAP_Functor functor;
if (functor_name == NULL)
functor = YAP_MkFunctor (YAP_LookupAtom (","), 2);
else
functor = YAP_MkFunctor (YAP_LookupAtom (functor_name), 2);
p[0] = YAP_MkFloatTerm (x);
p[1] = YAP_MkFloatTerm (y);
*term = YAP_MkApplTerm (functor, 2, p);
return (TRUE);
}
static YAP_Bool make_polygon_to_geometry (YAP_Term term,
geometry_t *geometry)
{
YAP_Functor functor;
functor = YAP_MkFunctor (YAP_LookupAtom (","), 1);
term = YAP_MkApplTerm (functor, 1, &term);
return (polygon_to_geometry (term, geometry));
}
void
init_cuda(void)
{
if (first_time) Cuda_Initialize();
first_time = FALSE;
AtomEq = YAP_LookupAtom("=");
AtomGt = YAP_LookupAtom(">");
AtomLt = YAP_LookupAtom("<");
AtomGe = YAP_LookupAtom(">=");
AtomLe = YAP_LookupAtom("=<");
AtomDf = YAP_LookupAtom("\\=");
AtomNt = YAP_LookupAtom("not");
YAP_UserCPredicate("load_facts", load_facts, 4);
YAP_UserCPredicate("cuda_init_facts", cuda_init_facts, 4);
YAP_UserCPredicate("cuda_load_fact", cuda_load_fact, 1);
YAP_UserCPredicate("load_rule", load_rule, 4);
YAP_UserCPredicate("cuda_erase", cuda_erase, 1);
YAP_UserCPredicate("cuda_eval", cuda_eval, 3);
YAP_UserCPredicate("cuda_coverage", cuda_coverage, 4);
YAP_UserCPredicate("cuda_count", cuda_count, 2);
YAP_UserCPredicate("cuda_statistics", cuda_statistics, 0);
#ifdef ROCKIT
YAP_UserCPredicate("cuda_init_query", cuda_init_query, 1);
#endif
}
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;
}
/* execute a command as a detached process */
static YAP_Bool plwait(void) {
long int pid = YAP_IntOfTerm(YAP_ARG1);
#if defined(__MINGW32__) || _MSC_VER
HANDLE proc = OpenProcess(STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE, FALSE, pid);
DWORD ExitCode;
if (proc == NULL) {
return (YAP_Unify(YAP_ARG3, WinError()));
}
if (WaitForSingleObject(proc, INFINITE) == WAIT_FAILED) {
return (YAP_Unify(YAP_ARG3, WinError()));
}
if (GetExitCodeProcess(proc, &ExitCode) == 0) {
return (YAP_Unify(YAP_ARG4, WinError()));
}
CloseHandle(proc);
return (YAP_Unify(YAP_ARG2, YAP_MkIntTerm(ExitCode)));
#else
do {
int status;
/* check for interruptions */
if (waitpid(pid, &status, 0) == -1) {
if (errno) {
if (errno == EINTR) {
continue;
}
return YAP_Unify(YAP_ARG3, YAP_MkIntTerm(errno));
}
}
if (WIFEXITED(status)) {
return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(WEXITSTATUS(status)));
} else if (WIFSIGNALED(status)) {
return YAP_Unify(YAP_ARG3, YAP_MkAtomTerm(YAP_LookupAtom("signalled"))) &&
YAP_Unify(YAP_ARG4, YAP_MkIntTerm(WTERMSIG(status)));
} else /* WIFSTOPPED(status) */ {
return YAP_Unify(YAP_ARG3, YAP_MkAtomTerm(YAP_LookupAtom("stopped"))) &&
YAP_Unify(YAP_ARG4, YAP_MkIntTerm(WSTOPSIG(status)));
}
} while (TRUE);
#endif
}
static YAP_Bool p_tmpnam(void) {
#if HAVE_MKSTEMP
char s[21];
strcpy(s, "/tmp/YAP_tmpXXXXXXXX");
if (mkstemp(s) == -1)
return FALSE;
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(s)));
#elif HAVE_MKTEMP
char *s;
if (!(s = mktemp("/tmp/YAP_tmpXXXXXXXX")))
return FALSE;
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(s)));
#elif HAVE_TMPNAM
char buf[L_tmpnam], *s;
if (!(s = tmpnam(buf)))
return FALSE;
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(s)));
#else
return FALSE;
#endif
}
void init_lbfgs_predicates( void )
{
fcall3 = YAP_MkFunctor(YAP_LookupAtom("$lbfgs_callback_evaluate"), 3);
fprogress8 = YAP_MkFunctor(YAP_LookupAtom("$lbfgs_callback_progress"), 8);
//Initialize the parameters for the L-BFGS optimization.
lbfgs_parameter_init(¶m);
YAP_UserCPredicate("optimizer_reserve_memory",optimizer_initialize,1);
YAP_UserCPredicate("optimizer_run",optimizer_run,2);
YAP_UserCPredicate("optimizer_free_memory",optimizer_finalize,0);
YAP_UserCPredicate("optimizer_set_x",set_x_value,2);
YAP_UserCPredicate("optimizer_get_x",get_x_value,2);
YAP_UserCPredicate("optimizer_set_g",set_g_value,2);
YAP_UserCPredicate("optimizer_get_g",get_g_value,2);
YAP_UserCPredicate("optimizer_set_parameter",optimizer_set_parameter,2);
YAP_UserCPredicate("optimizer_get_parameter",optimizer_get_parameter,2);
}
static YAP_Bool make_polygon_to_term (geometry_t geometry,
const char * functor_name,
YAP_Term *term)
{
int n;
geometry_t ring;
sequence_t sequence;
YAP_Functor functor;
unsigned int size;
YAP_Term head;
assert (term != NULL);
*term = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
size = GEOSGetNumInteriorRings (geometry);
for (n = size - 1; n >= 0; n --)
{
ring = (geometry_t) GEOSGetInteriorRingN (geometry, n);
sequence = (sequence_t) GEOSGeom_getCoordSeq (ring);
if ((sequence == NULL)
|| (point_list_to_term (sequence, &head) == FALSE))
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
}
/* Exterior ring always exists. */
ring = (geometry_t) GEOSGetExteriorRing (geometry);
if (ring == NULL)
return (FALSE);
sequence = (sequence_t) GEOSGeom_getCoordSeq (ring);
if ((sequence == NULL)
|| (point_list_to_term (sequence, &head) == FALSE))
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
if (functor_name != NULL)
{
functor = YAP_MkFunctor (YAP_LookupAtom (NAME_POLYGON), 1);
*term = YAP_MkApplTerm (functor, 1, term);
}
return (TRUE);
}
static YAP_Term build_list(list l, int current_pos)
{
if (l.size > 0)
{
if (l.nDims > 1)
{
YAP_Term curr_term = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
int cDims = l.dims[0], i, j, k, inc = cDims;
for (i = cDims - 1; i >= 0; i--)
{
list newL;
newL.nDims = l.nDims - 1;
newL.size = l.size / cDims;
k = 0;
for (j = 1; j < l.nDims; j++)
newL.dims[j - 1] = l.dims[j];
for (j = i; j < l.size; j += inc)
newL.values[k++] = l.values[j];
curr_term = YAP_MkPairTerm(build_list(newL, 0), curr_term);
}
return curr_term;
}
else
{
YAP_Term curr_term = get_term(l.values[current_pos]);
if (current_pos == l.size - 1)
return YAP_MkPairTerm(curr_term,
YAP_MkAtomTerm(YAP_LookupAtom("[]")));
else
return YAP_MkPairTerm(curr_term,
build_list(l, current_pos + 1));
}
}
return YAP_MkAtomTerm(YAP_LookupAtom("[]"));
}
static YAP_Bool p_tmpdir(void) {
#if defined(__MINGW32__) || _MSC_VER
char buf[512];
DWORD out = GetTempPath(512, buf);
if (!out) {
return (YAP_Unify(YAP_ARG2, WinError()));
}
if (out > 511) {
char *nbuf = malloc(out + 1);
if (!nbuf)
return YAP_Unify(YAP_ARG2,
YAP_MkAtomTerm(YAP_LookupAtom("no malloc memory")));
out = GetTempPath(512, nbuf);
if (!out) {
return YAP_Unify(YAP_ARG2, WinError());
}
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(nbuf)));
}
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(buf)));
#else
char *s;
if ((s = getenv("TMPDIR")))
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(s)));
#ifdef P_tmpdir
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(P_tmpdir)));
#endif
return YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom("/tmp")));
#endif
}
YAP_Bool geometrycollection_to_term (geometry_t geometry, YAP_Term *term)
{
int n;
geometry_t geometry_n;
YAP_Functor functor;
unsigned int size;
YAP_Term head;
assert (term != NULL);
*term = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
size = GEOSGetNumGeometries (geometry);
for (n = size - 1; n >= 0; n --)
{
geometry_n = (geometry_t) GEOSGetGeometryN (geometry, n);
if (geometry_to_term (geometry_n, &head) == FALSE)
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
}
functor = YAP_MkFunctor (YAP_LookupAtom (NAME_GEOMETRYCOLLECTION), 1);
*term = YAP_MkApplTerm (functor, 1, term);
return (TRUE);
}
int
main (int argc, char **argv)
#endif
{
int BootMode;
YAP_init_args init_args;
int i;
#if DEBUG_LOCKS
char buf[1024];
sprintf(buf, "/tmp/yap%d", getpid());
debugf= fopen(buf, "w");
if (!debugf) fprintf(stderr,"ERROR %s\n", strerror(errno));
setvbuf( debugf,NULL, _IOLBF, 1024);
#endif
BootMode = init_standard_system(argc, argv, &init_args);
if (BootMode == YAP_BOOT_ERROR) {
fprintf(stderr,"[ FATAL ERROR: could not find saved state ]\n");
exit(1);
}
/* Begin preprocessor code */
if (BootMode != YAP_BOOT_FROM_SAVED_STACKS) {
// process the definitions
for(i=0;i<init_args.def_c;++i) {
YAP_Term t_args[2],t_goal;
t_args[0] = YAP_MkAtomTerm(YAP_LookupAtom(init_args.def_var[i]));
t_args[1] = YAP_MkAtomTerm(YAP_LookupAtom(init_args.def_value[i]));
t_goal = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom("ypp_define"),2), 2, t_args);
YAP_RunGoalOnce(t_goal);
}
}
YAP_Reset( YAP_FULL_RESET );
/* End preprocessor code */
exec_top_level(BootMode, &init_args);
return(0);
}
/*
* Sets up the mpi enviromment. This function should be called before any other MPI
* function.
* the argument is the name of the predicate that will be invoked when a message is received
*/
static YAP_Bool
rcv_msg_thread(char *handle_pred) {
YAP_Term pred=YAP_MkAtomTerm(YAP_LookupAtom(handle_pred));
MPI_Status status;
while(1) {
write_msg(__FUNCTION__,__FILE__,__LINE__,"Waiting for MPI msg\n");
if( MPI_CALL(MPI_Probe( MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status )) == MPI_SUCCESS ) {
// call handle
write_msg(__FUNCTION__,__FILE__,__LINE__,"MPI Msg received\n");
YAP_CallProlog(pred);
} else
write_msg(__FUNCTION__,__FILE__,__LINE__,"Error in MPI_Probe\n");
}
return 1;
}
static YAP_Bool host_name(void) {
#if defined(__MINGW32__) || _MSC_VER
char name[MAX_COMPUTERNAME_LENGTH + 1];
DWORD nSize = MAX_COMPUTERNAME_LENGTH + 1;
if (GetComputerName(name, &nSize) == 0) {
return (YAP_Unify(YAP_ARG2, WinError()));
}
#else
#if HAVE_GETHOSTNAME
char name[256];
if (gethostname(name, 256) == -1) {
/* return an error number */
return (YAP_Unify(YAP_ARG2, YAP_MkIntTerm(errno)));
}
#endif
#endif /* defined(__MINGW32__) || _MSC_VER */
return (YAP_Unify(YAP_ARG1, YAP_MkAtomTerm(YAP_LookupAtom(name))));
}
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 YAP_Bool make_linestring_to_term (geometry_t geometry,
const char * functor_name,
YAP_Term *term)
{
sequence_t sequence;
YAP_Functor functor;
assert (term != NULL);
sequence = (sequence_t) GEOSGeom_getCoordSeq (geometry);
if ((sequence == NULL)
|| (point_list_to_term (sequence, term) == FALSE))
return (FALSE);
if (functor_name != NULL)
{
functor = YAP_MkFunctor (YAP_LookupAtom (functor_name), 1);
*term = YAP_MkApplTerm (functor, 1, term);
}
return (TRUE);
}
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;
}
static YAP_Bool make_point_to_geometry (YAP_Term term,
geometry_t *geometry)
{
YAP_Functor functor;
const char * functor_name;
unsigned int arity;
YAP_Term p[2];
if (YAP_IsApplTerm (term) == FALSE)
return (FALSE);
functor = YAP_FunctorOfTerm (term);
functor_name = YAP_AtomName (YAP_NameOfFunctor (functor));
arity = YAP_ArityOfFunctor (functor);
if ((strcmp (functor_name, ",") != 0) || (arity != 2))
return (FALSE);
p[0] = YAP_ArgOfTerm (1, term);
p[1] = YAP_ArgOfTerm (2, term);
functor = YAP_MkFunctor (YAP_LookupAtom (NAME_POINT), 2);
term = YAP_MkApplTerm (functor, 2, p);
return (point_to_geometry (term, geometry));
}
static YAP_Bool point_list_to_term (sequence_t sequence, YAP_Term *term)
{
int n;
unsigned int size;
YAP_Float x, y;
YAP_Term head;
assert (term != NULL);
*term = YAP_MkAtomTerm (YAP_LookupAtom ("[]"));
if (GEOSCoordSeq_getSize (sequence, &size) == 0)
return (FALSE);
for (n = size - 1; n >= 0; n --)
{
if ((GEOSCoordSeq_getX (sequence, n, &x) == 0)
|| (GEOSCoordSeq_getY (sequence, n, &y) == 0))
return (FALSE);
if (make_point (x, y, NULL, &head) == FALSE)
return (FALSE);
*term = YAP_MkPairTerm (head, *term);
}
return (TRUE);
}
/* Return time in a structure */
static YAP_Bool datime(void) {
YAP_Term tf, out[6];
#if defined(__MINGW32__) || _MSC_VER
SYSTEMTIME stime;
GetLocalTime(&stime);
out[0] = YAP_MkIntTerm(stime.wYear);
out[1] = YAP_MkIntTerm(stime.wMonth);
out[2] = YAP_MkIntTerm(stime.wDay);
out[3] = YAP_MkIntTerm(stime.wHour);
out[4] = YAP_MkIntTerm(stime.wMinute);
out[5] = YAP_MkIntTerm(stime.wSecond);
#elif HAVE_TIME
time_t tp;
if ((tp = time(NULL)) == -1) {
return (YAP_Unify(YAP_ARG2, YAP_MkIntTerm(errno)));
}
#ifdef HAVE_LOCALTIME
{
struct tm *loc = localtime(&tp);
if (loc == NULL) {
return (YAP_Unify(YAP_ARG2, YAP_MkIntTerm(errno)));
}
out[0] = YAP_MkIntTerm(1900 + loc->tm_year);
out[1] = YAP_MkIntTerm(1 + loc->tm_mon);
out[2] = YAP_MkIntTerm(loc->tm_mday);
out[3] = YAP_MkIntTerm(loc->tm_hour);
out[4] = YAP_MkIntTerm(loc->tm_min);
out[5] = YAP_MkIntTerm(loc->tm_sec);
}
#else
oops
#endif /* HAVE_LOCALTIME */
#else
oops
#endif /* HAVE_TIME */
tf = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom("datime"), 6), 6, out);
return YAP_Unify(YAP_ARG1, tf);
}
/* execute a command as a detached process */
static YAP_Bool execute_command(void) {
YAP_Term ti = YAP_ARG2, to = YAP_ARG3, te = YAP_ARG4;
int res;
YAP_Term AtomNull = YAP_MkAtomTerm(YAP_LookupAtom("null"));
#if defined(__MINGW32__) || _MSC_VER
HANDLE inpf, outf, errf;
DWORD CreationFlags = 0;
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInformation;
inpf = get_handle(ti, STD_INPUT_HANDLE);
if (inpf == INVALID_HANDLE_VALUE) {
return (YAP_Unify(YAP_ARG6, WinError()));
}
outf = get_handle(to, STD_OUTPUT_HANDLE);
if (outf == INVALID_HANDLE_VALUE) {
close_handle(ti, inpf);
return (YAP_Unify(YAP_ARG6, WinError()));
}
errf = get_handle(te, STD_OUTPUT_HANDLE);
if (errf == INVALID_HANDLE_VALUE) {
close_handle(ti, inpf);
close_handle(to, outf);
return (YAP_Unify(YAP_ARG6, WinError()));
}
if (!YAP_IsIntTerm(ti) && !YAP_IsIntTerm(to) && !YAP_IsIntTerm(te)) {
/* we do not keep a current stream */
CreationFlags = DETACHED_PROCESS;
}
StartupInfo.cb = sizeof(STARTUPINFO);
StartupInfo.lpReserved = NULL;
StartupInfo.lpDesktop = NULL; /* inherit */
StartupInfo.lpTitle = NULL; /* we do not create a new console window */
StartupInfo.dwFlags = STARTF_USESTDHANDLES;
StartupInfo.cbReserved2 = 0;
StartupInfo.lpReserved2 = NULL;
StartupInfo.hStdInput = inpf;
StartupInfo.hStdOutput = outf;
StartupInfo.hStdError = errf;
/* got stdin, stdout and error as I like it */
if (CreateProcess(NULL, (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1)), NULL,
NULL, TRUE, CreationFlags, NULL, NULL, &StartupInfo,
&ProcessInformation) == FALSE) {
close_handle(ti, inpf);
close_handle(to, outf);
close_handle(te, errf);
return (YAP_Unify(YAP_ARG6, WinError()));
}
close_handle(ti, inpf);
close_handle(to, outf);
close_handle(te, errf);
res = ProcessInformation.dwProcessId;
return (YAP_Unify(YAP_ARG5, YAP_MkIntTerm(res)));
#else /* UNIX CODE */
int inpf, outf, errf;
/* process input first */
if (ti == AtomNull) {
inpf = open("/dev/null", O_RDONLY);
} else {
int sd;
if (YAP_IsIntTerm(ti))
sd = YAP_IntOfTerm(ti);
else
sd = YAP_StreamToFileNo(ti);
if (sd == 0)
inpf = 0;
else
inpf = dup(sd);
}
if (inpf < 0) {
/* return an error number */
return (YAP_Unify(YAP_ARG6, YAP_MkIntTerm(errno)));
}
/* then output stream */
if (to == AtomNull) {
outf = open("/dev/zero", O_WRONLY);
} else {
int sd;
if (YAP_IsIntTerm(to))
sd = YAP_IntOfTerm(to);
else
sd = YAP_StreamToFileNo(to);
if (sd == 1)
outf = 1;
else
outf = dup(sd);
}
if (outf < 0) {
/* return an error number */
if (inpf != 0)
close(inpf);
return (YAP_Unify(YAP_ARG6, YAP_MkIntTerm(errno)));
}
/* then error stream */
if (te == AtomNull) {
errf = open("/dev/zero", O_WRONLY);
} else {
int sd;
if (YAP_IsIntTerm(te))
sd = YAP_IntOfTerm(te);
else
sd = YAP_StreamToFileNo(te);
if (sd == 2)
errf = 2;
else
errf = dup(sd);
}
if (errf < 0) {
/* return an error number */
if (inpf != 0)
close(inpf);
if (outf != 1)
close(outf);
return (YAP_Unify(YAP_ARG6, YAP_MkIntTerm(errno)));
}
YAP_FlushAllStreams();
/* we are now ready to fork */
if ((res = fork()) < 0) {
/* close streams we don't need */
if (inpf != 0)
close(inpf);
if (outf != 1)
close(outf);
if (errf != 2)
close(errf);
/* return an error number */
return (YAP_Unify(YAP_ARG6, YAP_MkIntTerm(errno)));
} else if (res == 0) {
char *argv[4];
/* child */
/* close current streams, but not std streams */
YAP_CloseAllOpenStreams();
if (inpf != 0) {
close(0);
if (dup(inpf) != 0)
exit(1);
close(inpf);
}
if (outf != 1) {
close(1);
if (dup(outf) != 1)
exit(1);
close(outf);
}
if (errf != 2) {
close(2);
if (dup(errf) != 2)
exit(2);
close(errf);
}
argv[0] = "sh";
argv[1] = "-c";
argv[2] = (char *)YAP_AtomName(YAP_AtomOfTerm(YAP_ARG1));
argv[3] = NULL;
execv("/bin/sh", argv);
exit(127);
/* we have the streams where we want them, just want to execute now */
} else {
if (inpf != 0)
close(inpf);
if (outf != 1)
close(outf);
if (errf != 2)
close(errf);
return (YAP_Unify(YAP_ARG5, YAP_MkIntTerm(res)));
}
#endif /* UNIX code */
}
