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;
}
/** md5( +Text, -Key, -Remaining keyq
* encode text using OpenSSL
*
* arg Text is a List of ASCII codes
* arg2 and 3: difference list with the character codes for the
* digest.
*
* @return whether ARG1's md5 unifies with the difference liat.
*/
static YAP_Bool md5(void) {
unsigned char buf[64];
md5_state_t pms;
const char *s;
size_t len = -1;
if (!(s = YAP_StringToBuffer(YAP_ARG1, NULL, len)) || s[0] == 0)
return false;
md5_init(&pms);
md5_append(&pms, (const unsigned char *)s, strlen(s));
md5_finish(&pms, buf);
// free((void *)s);
YAP_Term t = YAP_ARG3;
int i = 16;
while (i > 0) {
int top, bop;
i--;
top = buf[i] >> 4;
if (top > 9)
top = (top - 10) + 'a';
else
top = top + '0';
bop = buf[i] & 15;
if (bop > 9)
bop = (bop - 10) + 'a';
else
bop = bop + '0';
t = YAP_MkPairTerm(YAP_MkIntTerm(top),
YAP_MkPairTerm(YAP_MkIntTerm(bop), t));
}
return YAP_Unify(YAP_ARG2, t);
}
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 YAP_Bool check_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;
int yap_flags = YAP_IntOfTerm(YAP_ARG5);
int regcomp_flags = REG_NOSUB|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)
return(FALSE);
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);
}
out = yap_regexec(®,sbuf,0,NULL,0);
yap_regfree(®);
YAP_FreeSpaceFromYap(buf);
YAP_FreeSpaceFromYap(sbuf);
if (out != 0 && out != REG_NOMATCH) {
return(FALSE);
}
return(out == 0);
}
static int send_r_command(void)
{
YAP_Term in = YAP_ARG1;
char buffer[256];
YAP_StringToBuffer(in, buffer, BUFSIZE);
send_command(buffer);
return 1;
}
static int list_val(void)
{
YAP_Term in = YAP_ARG1;
YAP_Term out = YAP_ARG2;
char buffer[256];
YAP_StringToBuffer(in, buffer, BUFSIZE);
YAP_Term res = build_list(get_list(buffer), 0);
return YAP_Unify(out, res);
}
static int float_val(void)
{
YAP_Term in = YAP_ARG1;
YAP_Term out = YAP_ARG2;
char buffer[256];
YAP_StringToBuffer(in, buffer, BUFSIZE);
YAP_Term res = YAP_MkFloatTerm(get_double(buffer));
return YAP_Unify(out, res);
}
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 YAP_Bool create_dot(void) {
const char *onames[] = {"Out"};
char **inames;
DdNode *array[1];
YAP_Term arg1, arg2;
int i, b, index;
variable v;
char numberVar[10], numberBit[10], filename[1000];
FILE *file;
arg1 = YAP_ARG1;
arg2 = YAP_ARG2;
YAP_StringToBuffer(arg2, filename, 1000);
inames = (char **)malloc(sizeof(char *) * (boolVars_ex[ex]));
index = 0;
for (i = 0; i < nVars_ex[ex]; i++) {
v = vars_ex[ex][i];
for (b = 0; b < v.nVal - 1; b++) {
inames[b + index] = (char *)malloc(sizeof(char) * 20);
strcpy(inames[b + index], "X");
sprintf(numberVar, "%d", i);
strcat(inames[b + index], numberVar);
strcat(inames[b + index], "_");
sprintf(numberBit, "%d", b);
strcat(inames[b + index], numberBit);
}
index = index + v.nVal - 1;
}
array[0] = (DdNode *)YAP_IntOfTerm(arg1);
file = open_file(filename, "w");
Cudd_DumpDot(mgr_ex[ex], 1, array, (const char **)inames, onames, file);
fclose(file);
index = 0;
for (i = 0; i < nVars_ex[ex]; i++) {
v = vars_ex[ex][i];
for (b = 0; b < v.nVal - 1; b++) {
free(inames[b + index]);
}
index = index + v.nVal - 1;
}
free(inames);
return 1;
}
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 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);
}
