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 */ }