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);
}
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);
}
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);
}
static YAP_Term
address2term(mxArray *mat)
{
YAP_Term t[1];
t[0] = YAP_MkIntTerm((YAP_Int)mat);
return YAP_MkApplTerm(MatlabAddress,1,t);
}
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));
}
static int progress(
void *instance,
const lbfgsfloatval_t *local_x,
const lbfgsfloatval_t *local_g,
const lbfgsfloatval_t fx,
const lbfgsfloatval_t xnorm,
const lbfgsfloatval_t gnorm,
const lbfgsfloatval_t step,
int n,
int k,
int ls
)
{
YAP_Term call;
YAP_Bool result;
YAP_Int s1;
YAP_Term t[8];
t[0] = YAP_MkFloatTerm(fx);
t[1] = YAP_MkFloatTerm(xnorm);
t[2] = YAP_MkFloatTerm(gnorm);
t[3] = YAP_MkFloatTerm(step);
t[4] = YAP_MkIntTerm(n);
t[5] = YAP_MkIntTerm(k);
t[6] = YAP_MkIntTerm(ls);
t[7] = YAP_MkVarTerm();
call = YAP_MkApplTerm( fprogress8, 8, t);
s1 = YAP_InitSlot(call);
optimizer_status=OPTIMIZER_STATUS_CB_PROGRESS;
result=YAP_CallProlog(call);
optimizer_status=OPTIMIZER_STATUS_RUNNING;
call = YAP_GetFromSlot( s1 );
if (result==FALSE) {
printf("ERROR: Calling the progress call back function in YAP.\n");
// Goal did not succeed
return FALSE;
}
if (YAP_IsIntTerm(YAP_ArgOfTerm(8,call))) {
return YAP_IntOfTerm(YAP_ArgOfTerm(8,call));
}
YAP_ShutdownGoal( TRUE );
fprintf(stderr, "ERROR: The progress call back function did not return an integer as last argument\n");
return 1;
}
static lbfgsfloatval_t evaluate(
void *instance,
const lbfgsfloatval_t *x,
lbfgsfloatval_t *g_tmp,
const int n,
const lbfgsfloatval_t step
)
{
YAP_Term call;
YAP_Term a1;
YAP_Bool result;
YAP_Int s1;
YAP_Term t[3];
t[0] = YAP_MkVarTerm();
t[1] = YAP_MkIntTerm(n);
t[2] = YAP_MkFloatTerm(step);
call = YAP_MkApplTerm(fcall3, 3, t);
g=g_tmp;
s1 = YAP_InitSlot(call);
optimizer_status=OPTIMIZER_STATUS_CB_EVAL;
result=YAP_CallProlog(call);
optimizer_status=OPTIMIZER_STATUS_RUNNING;
if (result==FALSE) {
printf("ERROR: Calling the evaluate call back function in YAP.\n");
// Goal did not succeed
return FALSE;
}
call = YAP_GetFromSlot( s1 );
a1 = YAP_ArgOfTerm(1,call);
if (YAP_IsFloatTerm(a1)) {
YAP_ShutdownGoal( TRUE );
return (lbfgsfloatval_t) YAP_FloatOfTerm(a1);
} else if (YAP_IsIntTerm(a1)) {
YAP_ShutdownGoal( TRUE );
return (lbfgsfloatval_t) YAP_IntOfTerm(a1);
}
YAP_ShutdownGoal( TRUE );
fprintf(stderr, "ERROR: The evaluate call back function did not return a number as first argument.\n");
return 0;
}
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_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 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 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);
}
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);
}
/* 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);
}
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);
}
static int
cuda_eval( void )
{
int32_t *mat;
#if defined(DATALOG) || defined(TUFFY)
int32_t *query = NULL;
setQuery(YAP_ARG1, &query);
#endif
int32_t finalDR = YAP_IntOfTerm(YAP_ARG3);
int32_t n = Cuda_Eval(facts, cf, rules, cr, query, & mat, names, finalDR);
#ifdef TUFFY
cf = 0;
#endif
#ifdef ROCKIT
if(cf > 0)
cf *= -1;
#endif
#if defined(TUFFY) || defined(ROCKIT)
cr = 0;
names[0] = '\0';
return FALSE;
#else
int32_t i;
predicate *ptr = (predicate *)YAP_IntOfTerm(YAP_ARG1);
int32_t ncols = ptr->num_columns;
YAP_Term out = YAP_TermNil();
YAP_Functor f = YAP_MkFunctor(YAP_IntToAtom(ptr->name), ncols);
YAP_Term vec[256];
YAP_Atom at;
if (n < 0)
return FALSE;
for (i=0; i<n; i++) {
int32_t ni = ((n-1)-i)*ncols, j;
printf("%s(", YAP_AtomName(YAP_IntToAtom(ptr->name)));
for (j=0; j<ncols; j++) {
vec[j] = YAP_MkIntTerm(mat[ni+j]);
at = YAP_IntToAtom(mat[ni+j]);
if(at != NULL)
printf("%s", YAP_AtomName(at));
else
printf("%d", mat[ni+j]);
if(j < (ncols - 1))
printf(",");
}
out = YAP_MkPairTerm(YAP_MkApplTerm( f, ncols, vec ), out);
printf(")\n");
}
if (n > 0)
free( mat );
return YAP_Unify(YAP_ARG2, out);
#endif
}
static YAP_Bool regexp(void)
{
unsigned int buflen = (unsigned int)YAP_IntOfTerm(YAP_ARG2)+1;
unsigned int sbuflen = (unsigned int)YAP_IntOfTerm(YAP_ARG4)+1;
char *buf, *sbuf;
regex_t reg;
int out;
size_t nmatch;
regmatch_t *pmatch;
long int tout;
int yap_flags = YAP_IntOfTerm(YAP_ARG5);
int regcomp_flags = REG_EXTENDED;
if ((buf = (char *)YAP_AllocSpaceFromYap(buflen)) == NULL) {
/* early exit */
return(FALSE);
}
if (YAP_StringToBuffer(YAP_ARG1,buf,buflen) == FALSE) {
/* something went wrong, possibly a type checking error */
YAP_FreeSpaceFromYap(buf);
return(FALSE);
}
if (yap_flags & 1)
regcomp_flags |= REG_ICASE;
/* cool, now I have my string in the buffer, let's have some fun */
if (yap_regcomp(®,buf, regcomp_flags) != 0) {
YAP_FreeSpaceFromYap(buf);
return(FALSE);
}
if (YAP_IsVarTerm(YAP_ARG7)) {
nmatch = reg.re_nsub;
} else {
nmatch = YAP_IntOfTerm(YAP_ARG7);
}
if ((sbuf = (char *)YAP_AllocSpaceFromYap(sbuflen)) == NULL) {
/* early exit */
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
return(FALSE);
}
if (YAP_StringToBuffer(YAP_ARG3,sbuf,sbuflen) == FALSE) {
/* something went wrong, possibly a type checking error */
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
YAP_FreeSpaceFromYap(sbuf);
return(FALSE);
}
pmatch = YAP_AllocSpaceFromYap(sizeof(regmatch_t)*(nmatch));
out = yap_regexec(®,sbuf,nmatch,pmatch,0);
if (out == 0) {
/* match succeed, let's fill the match in */
long int i;
YAP_Term TNil = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
YAP_Functor FDiff = YAP_MkFunctor(YAP_LookupAtom("-"),2);
tout = TNil;
for (i = nmatch-1; i >= 0; --i) {
int j;
YAP_Term t = TNil;
if (pmatch[i].rm_so != -1) {
if (yap_flags & 2) {
YAP_Term to[2];
to[0] = YAP_MkIntTerm(pmatch[i].rm_so);
to[1] = YAP_MkIntTerm(pmatch[i].rm_eo);
t = YAP_MkApplTerm(FDiff,2,to);
} else {
for (j = pmatch[i].rm_eo-1; j >= pmatch[i].rm_so; j--) {
t = YAP_MkPairTerm(YAP_MkIntTerm(sbuf[j]),t);
}
}
tout = YAP_MkPairTerm(t,tout);
}
}
out = !YAP_Unify(tout, YAP_ARG6);
}
else if (out != REG_NOMATCH) {
out = 0;
}
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
YAP_FreeSpaceFromYap(sbuf);
YAP_FreeSpaceFromYap(pmatch);
return(out == 0);
}
