/* 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); }
YAP_Bool term_to_geometry (YAP_Term term, geometry_t *geometry) { YAP_Functor functor; const char * functor_name; unsigned int n, arity, size; assert (geometry != NULL); *geometry = NULL; if (YAP_IsApplTerm (term) == FALSE) return (FALSE); functor = YAP_FunctorOfTerm (term); functor_name = YAP_AtomName (YAP_NameOfFunctor (functor)); arity = YAP_ArityOfFunctor (functor); size = sizeof (translate) / sizeof (struct type_name_arity); for (n = 0; n < size; n ++) if (strcmp (translate[n].name, functor_name) == 0) { if (translate[n].arity == arity) return (translate[n].procedure_import (term, geometry)); break; } return (FALSE); }
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 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 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 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 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 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 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)); }
/** @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 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 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 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 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_put_trie_entry(void) { TrData data; const char *mode_str; YAP_Int mode, current_mode; /* check args */ 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; if (!YAP_IsIntTerm(arg_trie)) return FALSE; /* put trie entry */ current_mode = trie_get_mode(); trie_set_mode(mode); data = trie_put_entry((TrEntry) YAP_IntOfTerm(arg_trie), arg_entry); trie_set_mode(current_mode); return YAP_Unify(arg_ref, YAP_MkIntTerm((YAP_Int) data)); }
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)); }
static int p_get_trie_entry(void) { YAP_Term entry; const char *mode_str; YAP_Int mode, current_mode; /* check args */ 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; if (!YAP_IsIntTerm(arg_ref)) return FALSE; /* get trie entry */ current_mode = trie_get_mode(); trie_set_mode(mode); entry = trie_get_entry((TrData) YAP_IntOfTerm(arg_ref)); trie_set_mode(current_mode); return YAP_Unify(arg_entry, entry); }
YAP_Bool point_to_geometry (YAP_Term term, geometry_t *geometry) { sequence_t sequence; YAP_Float x, y; YAP_Functor functor; const char * functor_name; unsigned int arity; assert (geometry != NULL); 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, NAME_POINT) != 0) || (arity != 2)) return (FALSE); if ((Yap_IsNumberTerm (YAP_ArgOfTerm (1, term), &x) == FALSE) || (Yap_IsNumberTerm (YAP_ArgOfTerm (2, term), &y) == FALSE)) return (FALSE); sequence = GEOSCoordSeq_create (1, 2); if (sequence == NULL) return (FALSE); if ((GEOSCoordSeq_setX (sequence, 0, x) == 0) || (GEOSCoordSeq_setY (sequence, 0, y) == 0)) { GEOSCoordSeq_destroy (sequence); return (FALSE); } *geometry = GEOSGeom_createPoint (sequence); if (*geometry == NULL) return (FALSE); return (TRUE); }