/* calculate approximate length of a printed term. For space alloc. */
DWORD clenpterm(prolog_term term)
{
int i, clen;
if (is_var(term)) return 11;
else if (is_int(term)) return 12;
else if (is_float(term)) return 12;
else if (is_nil(term)) return 2;
else if (is_string(term)) return strlen(p2c_string(term))+5;
else if (is_list(term)) {
clen = 1;
clen += clenpterm(p2p_car(term)) + 1;
while (is_list(term)) {
clen += clenpterm(p2p_car(term)) + 1;
term = p2p_cdr(term);
}
if (!is_nil(term)) {
clen += clenpterm(term) + 1;
}
return clen+1;
} else if (is_functor(term)) {
clen = strlen(p2c_functor(term))+5;
if (p2c_arity(term) > 0) {
clen += clenpterm(p2p_arg(term,1)) + 1;
for (i = 2; i <= p2c_arity(term); i++) {
clen += clenpterm(p2p_arg(term,i)) + 1;
}
return clen + 1;
} else return clen;
} else {
fprintf(stderr,"error, unrecognized type");
return 0;
}
}
//todo: need to refactor this code.
int callpy(CTXTdecl)
{
setenv("PYTHONPATH", ".", 1);
PyObject *pName = NULL, *pModule = NULL, *pFunc = NULL;
PyObject *pArgs = NULL, *pValue = NULL;
//PyObject *pArgs, *pValue;
prolog_term V, temp;
Py_Initialize();
char *module = ptoc_string(CTXTdeclc 1);
//char *function = ptoc_string(CTXTdeclc 2);
pName = PyString_FromString(module);
pModule = PyImport_Import(pName);
if(pModule == NULL)
{
return FALSE;
}
Py_DECREF(pName);
V = extern_reg_term(2);
char *function = p2c_functor(V);
if(is_functor(V))
{
int args_count = p2c_arity(V);
pFunc = PyObject_GetAttrString(pModule, function);
Py_DECREF(pModule);
if(pFunc && PyCallable_Check(pFunc))
{
pArgs = PyTuple_New(args_count);
int i;
for(i = 1; i <= args_count; i++)
{
temp = p2p_arg(V, i);
if(!(set_python_argument(temp, pArgs, i)))
{
return FALSE;
}
}
}
else
{
return FALSE;
}
pValue = PyObject_CallObject(pFunc, pArgs);
//printf("return call : %p\n",pValue);
if(return_to_prolog(pValue))
return TRUE;
else
return FALSE;
}
else
{
return FALSE;
}
return TRUE;
}
/* print a prolog_term into a buffer.
(Atoms are quoted if !toplevel and it's necessary for Prolog reading) */
void printpterm(prolog_term term, int toplevel, char *straddr, long int *ind)
{
int i;
if (is_var(term)) {
sprintf(tempstring,"_%p",term);
strcpy(straddr+*ind,tempstring);
*ind += strlen(tempstring);
} else if (is_int(term)) {
sprintf(tempstring,"%d",p2c_int(term));
strcpy(straddr+*ind,tempstring);
*ind += strlen(tempstring);
} else if (is_float(term)) {
sprintf(tempstring,"%f",p2c_float(term));
strcpy(straddr+*ind,tempstring);
*ind += strlen(tempstring);
} else if (is_nil(term)) {
strcpy(straddr+*ind,"[]");
*ind += 2;
} else if (is_string(term)) {
printpstring(p2c_string(term),toplevel,straddr,ind);
} else if (is_list(term)) {
strcpy(straddr+*ind,"[");
*ind += 1;
printpterm(p2p_car(term),FALSE,straddr,ind);
term = p2p_cdr(term);
while (is_list(term)) {
strcpy(straddr+*ind,",");
*ind += 1;
printpterm(p2p_car(term),FALSE,straddr,ind);
term = p2p_cdr(term);
}
if (!is_nil(term)) {
strcpy(straddr+*ind,"|");
*ind += 1;
printpterm(term,FALSE,straddr,ind);
}
strcpy(straddr+*ind,"]");
*ind += 1;
} else if (is_functor(term)) {
printpstring(p2c_functor(term),FALSE,straddr,ind);
if (p2c_arity(term) > 0) {
strcpy(straddr+*ind,"(");
*ind += 1;
printpterm(p2p_arg(term,1),FALSE,straddr,ind);
for (i = 2; i <= p2c_arity(term); i++) {
strcpy(straddr+*ind,",");
*ind += 1;
printpterm(p2p_arg(term,i),FALSE,straddr,ind);
}
strcpy(straddr+*ind,")");
*ind += 1;
}
} else fprintf(stderr,"error, unrecognized type");
}
/*
* call as: is_datime(+T)
* Returns true if T is a datime (with or without counter)
*/
int is_datime(CTXTdecl)
{
prolog_term t = reg_term(CTXTc 1);
if(is_functor(t))
{
char *func = p2c_functor(t);
if(strcmp(func,"datime")==0)
return TRUE;
}
return FALSE;
}
/* call as: current_datime(-D)
Returns the predicate datime(D) where D is the current time in ms*/
int current_datime(CTXTdecl)
{
time_t now;
time(&now);
prolog_term t = reg_term(CTXTc 1);
if (is_functor(t))
{
char *func = p2c_functor(t);
if(strcmp(func,"datime")==0)
{
c2p_int(CTXTc now, p2p_arg(reg_term(CTXTc 1),1));
return TRUE;
}
return FALSE;
}
c2p_functor(CTXTc "datime",1,reg_term(CTXTc 1));
c2p_int(CTXTc now, p2p_arg(reg_term(CTXTc 1),1));
return TRUE;
}
DllExport int call_conv pl_load_page()
{
prolog_term head, tail, result = 0;
char *functor, *url = NULL, *data = NULL;
char *username = NULL, *password = NULL;
curl_opt options = init_options();
curl_ret ret_vals;
check_thread_context
tail = reg_term(CTXTc 1);
if(!is_list(tail))
return curl2pl_error(ERR_DOMAIN, "source", tail);
while(is_list(tail)){
head = p2p_car(tail);
tail = p2p_cdr(tail);
if(is_functor(head)){
functor = p2c_functor(head);
if(!strcmp(functor,"source")){
prolog_term term_url_func, term_url = 0;
term_url_func = p2p_arg(head, 1);
if(is_functor(term_url_func)){
if(!strcmp(p2c_functor(term_url_func), "url")){
term_url = p2p_arg(term_url_func, 1);
url = p2c_string(term_url);
data = load_page(url, options, &ret_vals);
}
else{
return curl2pl_error(ERR_MISC, "source", term_url);
}
}
else{
return curl2pl_error(ERR_MISC, "source", "Improper input format");
}
}
else if(!strcmp(functor,"options")){
prolog_term term_options = p2p_arg(head, 1);
prolog_term term_option;
while(is_list(term_options)){
term_option = p2p_car(term_options);
if(!strcmp(p2c_functor(term_option), "redirect")) {
if(!strcmp(p2c_string(p2p_arg(term_option, 1)), "true"))
options.redir_flag = 1;
else
options.redir_flag = 0;
}
else if(!strcmp(p2c_functor(term_option), "secure")){
if(!strcmp(p2c_string(p2p_arg(term_option, 1)), "false"))
options.secure.flag = 0;
else
options.secure.crt_name = p2c_string(p2p_arg(term_option, 1));
}
else if(!strcmp(p2c_functor(term_option), "auth")){
username = p2c_string(p2p_arg(term_option, 1));
password = p2c_string(p2p_arg(term_option, 2));
options.auth.usr_pwd = (char *) malloc ((strlen(username) + strlen(password) + 2) * sizeof(char));
strcpy(options.auth.usr_pwd, username);
strcat(options.auth.usr_pwd, ":");
strcat(options.auth.usr_pwd, password);
}
else if(!strcmp(p2c_functor(term_option), "timeout")){
options.timeout = (int)p2c_int(p2p_arg(term_option, 1));
}
else if(!strcmp(p2c_functor(term_option), "url_prop")){
options.url_prop = options.redir_flag;
}
else if(!strcmp(p2c_functor(term_option), "user_agent")){
options.user_agent = p2c_string(p2p_arg(term_option, 1));
}
else if(!strcmp(p2c_functor(term_option), "post")){
options.post_data = p2c_string(p2p_arg(term_option, 1));
}
term_options = p2p_cdr(term_options);
}
}
else if(!strcmp(functor,"document")){
result = p2p_arg(head, 1);
}
else if(!strcmp(functor,"properties")){
c2p_int(CTXTc (int) ret_vals.size, p2p_arg(head, 1));
/* the following code can be used to convert to local/UTC time, if
necessary. Note: XSB uses local time, and ret_vals.modify_time
is local, too.
struct tm * timeinfo;
timeinfo = gmtime(&(ret_vals.modify_time)); // UTC time
timeinfo = localtime(&(ret_vals.modify_time)); // local time
c2p_int(CTXTc (int) mktime(timeinfo), p2p_arg(head,2));
*/
/* return modification time as an integer */
c2p_int(CTXTc (int) ret_vals.modify_time, p2p_arg(head,2));
/*
The following converts time to string - not useful
if (ctime(&ret_vals.modify_time) == NULL)
c2p_string("", p2p_arg(head, 2));
else
c2p_string(CTXTc (char *) ctime(&ret_vals.modify_time),
p2p_arg(head, 2));
*/
}
}
else{
return curl2pl_error(ERR_DOMAIN, "source", head);
}
}
c2p_string(CTXTc data, result);
return TRUE;
}
/* TLS: making a conservative guess at which system calls need to be
mutexed. I'm doing it whenever I see the process table altered or
affected, so this is the data structure that its protecting.
At some point, the SET_FILEPTRs should be protected against other
threads closing that stream. Perhaps for such things a
thread-specific stream table should be used.
*/
xsbBool sys_system(CTXTdeclc int callno)
{
// int pid;
Integer pid;
switch (callno) {
case PLAIN_SYSTEM_CALL: /* dumb system call: no communication with XSB */
/* this call is superseded by shell and isn't used */
ctop_int(CTXTc 3, system(ptoc_string(CTXTc 2)));
return TRUE;
case SLEEP_FOR_SECS:
#ifdef WIN_NT
Sleep((int)iso_ptoc_int_arg(CTXTc 2,"sleep/1",1) * 1000);
#else
sleep(iso_ptoc_int_arg(CTXTc 2,"sleep/1",1));
#endif
return TRUE;
case GET_TMP_FILENAME:
ctop_string(CTXTc 2,tempnam(NULL,NULL));
return TRUE;
case IS_PLAIN_FILE:
case IS_DIRECTORY:
case STAT_FILE_TIME:
case STAT_FILE_SIZE:
return file_stat(CTXTc callno, ptoc_longstring(CTXTc 2));
case EXEC: {
#ifdef HAVE_EXECVP
/* execs a new process in place of XSB */
char *params[MAX_SUBPROC_PARAMS+2];
prolog_term cmdspec_term;
int index = 0;
cmdspec_term = reg_term(CTXTc 2);
if (islist(cmdspec_term)) {
prolog_term temp, head;
char *string_head=NULL;
if (isnil(cmdspec_term))
xsb_abort("[exec] Arg 1 must not be an empty list.");
temp = cmdspec_term;
do {
head = p2p_car(temp);
temp = p2p_cdr(temp);
if (isstring(head))
string_head = string_val(head);
else
xsb_abort("[exec] non-string argument passed in list.");
params[index++] = string_head;
if (index > MAX_SUBPROC_PARAMS)
xsb_abort("[exec] Too many arguments.");
} while (!isnil(temp));
params[index] = NULL;
} else if (isstring(cmdspec_term)) {
char *string = string_val(cmdspec_term);
split_command_arguments(string, params, "exec");
} else
xsb_abort("[exec] 1st argument should be term or list of strings.");
if (execvp(params[0], params))
xsb_abort("[exec] Exec call failed.");
#else
xsb_abort("[exec] builtin not supported in this architecture.");
#endif
}
case SHELL: /* smart system call: like SPAWN_PROCESS, but returns error code
instead of PID. Uses system() rather than execvp.
Advantage: can pass arbitrary shell command. */
case SPAWN_PROCESS: { /* spawn new process, reroute stdin/out/err to XSB */
/* +CallNo=2, +ProcAndArgsList,
-StreamToProc, -StreamFromProc, -StreamFromProcStderr,
-Pid */
static int pipe_to_proc[2], pipe_from_proc[2], pipe_from_stderr[2];
int toproc_stream=-1, fromproc_stream=-1, fromproc_stderr_stream=-1;
int pid_or_status;
FILE *toprocess_fptr=NULL,
*fromprocess_fptr=NULL, *fromproc_stderr_fptr=NULL;
char *params[MAX_SUBPROC_PARAMS+2]; /* one for progname--0th member,
one for NULL termination*/
prolog_term cmdspec_term, cmdlist_temp_term;
prolog_term cmd_or_arg_term;
xsbBool toproc_needed=FALSE, fromproc_needed=FALSE, fromstderr_needed=FALSE;
char *cmd_or_arg=NULL, *shell_cmd=NULL;
int idx = 0, tbl_pos;
char *callname=NULL;
xsbBool params_are_in_a_list=FALSE;
SYS_MUTEX_LOCK( MUTEX_SYS_SYSTEM );
init_process_table();
if (callno == SPAWN_PROCESS)
callname = "spawn_process/5";
else
callname = "shell/[1,2,5]";
cmdspec_term = reg_term(CTXTc 2);
if (islist(cmdspec_term))
params_are_in_a_list = TRUE;
else if (isstring(cmdspec_term))
shell_cmd = string_val(cmdspec_term);
else if (isref(cmdspec_term))
xsb_instantiation_error(CTXTc callname,1);
else
xsb_type_error(CTXTc "atom or list e.g. [command, arg, ...]",cmdspec_term,callname,1);
// xsb_abort("[%s] Arg 1 must be an atom or a list [command, arg, ...]",
// callname);
/* the user can indicate that he doesn't want either of the streams created
by putting an atom in the corresponding argument position */
if (isref(reg_term(CTXTc 3)))
toproc_needed = TRUE;
if (isref(reg_term(CTXTc 4)))
fromproc_needed = TRUE;
if (isref(reg_term(CTXTc 5)))
fromstderr_needed = TRUE;
/* if any of the arg streams is already used by XSB, then don't create
pipes --- use these streams instead. */
if (isointeger(reg_term(CTXTc 3))) {
SET_FILEPTR(toprocess_fptr, oint_val(reg_term(CTXTc 3)));
}
if (isointeger(reg_term(CTXTc 4))) {
SET_FILEPTR(fromprocess_fptr, oint_val(reg_term(CTXTc 4)));
}
if (isointeger(reg_term(CTXTc 5))) {
SET_FILEPTR(fromproc_stderr_fptr, oint_val(reg_term(CTXTc 5)));
}
if (!isref(reg_term(CTXTc 6)))
xsb_type_error(CTXTc "variable (to return process id)",reg_term(CTXTc 6),callname,5);
// xsb_abort("[%s] Arg 5 (process id) must be a variable", callname);
if (params_are_in_a_list) {
/* fill in the params[] array */
if (isnil(cmdspec_term))
xsb_abort("[%s] Arg 1 must not be an empty list", callname);
cmdlist_temp_term = cmdspec_term;
do {
cmd_or_arg_term = p2p_car(cmdlist_temp_term);
cmdlist_temp_term = p2p_cdr(cmdlist_temp_term);
if (isstring(cmd_or_arg_term)) {
cmd_or_arg = string_val(cmd_or_arg_term);
}
else
xsb_abort("[%s] Non string list member in the Arg",
callname);
params[idx++] = cmd_or_arg;
if (idx > MAX_SUBPROC_PARAMS)
xsb_abort("[%s] Too many arguments passed to subprocess",
callname);
} while (!isnil(cmdlist_temp_term));
params[idx] = NULL; /* null termination */
} else { /* params are in a string */
if (callno == SPAWN_PROCESS)
split_command_arguments(shell_cmd, params, callname);
else {
/* if callno==SHELL => call system() => don't split shell_cmd */
params[0] = shell_cmd;
params[1] = NULL;
}
}
/* -1 means: no space left */
if ((tbl_pos = get_free_process_cell()) < 0) {
xsb_warn(CTXTc "Can't create subprocess because XSB process table is full");
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return FALSE;
}
/* params[0] is the progname */
pid_or_status = xsb_spawn(CTXTc params[0], params, callno,
(toproc_needed ? pipe_to_proc : NULL),
(fromproc_needed ? pipe_from_proc : NULL),
(fromstderr_needed ? pipe_from_stderr : NULL),
toprocess_fptr, fromprocess_fptr,
fromproc_stderr_fptr);
if (pid_or_status < 0) {
xsb_warn(CTXTc "[%s] Subprocess creation failed, Error: %d, errno: %d, Cmd: %s", callname,pid_or_status,errno,params[0]);
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return FALSE;
}
if (toproc_needed) {
toprocess_fptr = fdopen(pipe_to_proc[1], "w");
toproc_stream = xsb_intern_fileptr(CTXTc toprocess_fptr,callname,"pipe","w",CURRENT_CHARSET);
ctop_int(CTXTc 3, toproc_stream);
}
if (fromproc_needed) {
fromprocess_fptr = fdopen(pipe_from_proc[0], "r");
fromproc_stream = xsb_intern_fileptr(CTXTc fromprocess_fptr,callname,"pipe","r",CURRENT_CHARSET);
ctop_int(CTXTc 4, fromproc_stream);
}
if (fromstderr_needed) {
fromproc_stderr_fptr = fdopen(pipe_from_stderr[0], "r");
fromproc_stderr_stream
= xsb_intern_fileptr(CTXTc fromproc_stderr_fptr,callname,"pipe","r",CURRENT_CHARSET);
ctop_int(CTXTc 5, fromproc_stderr_stream);
}
ctop_int(CTXTc 6, pid_or_status);
xsb_process_table.process[tbl_pos].pid = pid_or_status;
xsb_process_table.process[tbl_pos].to_stream = toproc_stream;
xsb_process_table.process[tbl_pos].from_stream = fromproc_stream;
xsb_process_table.process[tbl_pos].stderr_stream = fromproc_stderr_stream;
concat_array(CTXTc params, " ",
xsb_process_table.process[tbl_pos].cmdline,MAX_CMD_LEN);
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return TRUE;
}
case GET_PROCESS_TABLE: { /* sys_system(3, X). X is bound to the list
of the form [process(Pid,To,From,Stderr,Cmdline), ...] */
int i;
prolog_term table_term_tail, listHead;
prolog_term table_term=reg_term(CTXTc 2);
SYS_MUTEX_LOCK( MUTEX_SYS_SYSTEM );
init_process_table();
if (!isref(table_term))
xsb_abort("[GET_PROCESS_TABLE] Arg 1 must be a variable");
table_term_tail = table_term;
for (i=0; i<MAX_SUBPROC_NUMBER; i++) {
if (!FREE_PROC_TABLE_CELL(xsb_process_table.process[i].pid)) {
c2p_list(CTXTc table_term_tail); /* make it into a list */
listHead = p2p_car(table_term_tail);
c2p_functor(CTXTc "process", 5, listHead);
c2p_int(CTXTc xsb_process_table.process[i].pid, p2p_arg(listHead,1));
c2p_int(CTXTc xsb_process_table.process[i].to_stream, p2p_arg(listHead,2));
c2p_int(CTXTc xsb_process_table.process[i].from_stream, p2p_arg(listHead,3));
c2p_int(CTXTc xsb_process_table.process[i].stderr_stream,
p2p_arg(listHead,4));
c2p_string(CTXTc xsb_process_table.process[i].cmdline, p2p_arg(listHead,5));
table_term_tail = p2p_cdr(table_term_tail);
}
}
c2p_nil(CTXTc table_term_tail); /* bind tail to nil */
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return p2p_unify(CTXTc table_term, reg_term(CTXTc 2));
}
case PROCESS_STATUS: {
prolog_term pid_term=reg_term(CTXTc 2), status_term=reg_term(CTXTc 3);
SYS_MUTEX_LOCK( MUTEX_SYS_SYSTEM );
init_process_table();
if (!(isointeger(pid_term)))
xsb_abort("[PROCESS_STATUS] Arg 1 (process id) must be an integer");
pid = (int)oint_val(pid_term);
if (!isref(status_term))
xsb_abort("[PROCESS_STATUS] Arg 2 (process status) must be a variable");
switch (process_status(pid)) {
case RUNNING:
c2p_string(CTXTc "running", status_term);
break;
case STOPPED:
c2p_string(CTXTc "stopped", status_term);
break;
case EXITED_NORMALLY:
c2p_string(CTXTc "exited_normally", status_term);
break;
case EXITED_ABNORMALLY:
c2p_string(CTXTc "exited_abnormally", status_term);
break;
case ABORTED:
c2p_string(CTXTc "aborted", status_term);
break;
case INVALID:
c2p_string(CTXTc "invalid", status_term);
break;
default:
c2p_string(CTXTc "unknown", status_term);
}
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return TRUE;
}
case PROCESS_CONTROL: {
/* sys_system(PROCESS_CONTROL, +Pid, +Signal). Signal: wait, kill */
int status;
prolog_term pid_term=reg_term(CTXTc 2), signal_term=reg_term(CTXTc 3);
SYS_MUTEX_LOCK( MUTEX_SYS_SYSTEM );
init_process_table();
if (!(isointeger(pid_term)))
xsb_abort("[PROCESS_CONTROL] Arg 1 (process id) must be an integer");
pid = (int)oint_val(pid_term);
if (isstring(signal_term) && strcmp(string_val(signal_term), "kill")==0) {
if (KILL_FAILED(pid)) {
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return FALSE;
}
#ifdef WIN_NT
CloseHandle((HANDLE) pid);
#endif
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return TRUE;
}
if (isconstr(signal_term)
&& strcmp(p2c_functor(signal_term),"wait") == 0
&& p2c_arity(signal_term)==1) {
int exit_status;
if (WAIT(pid, status) < 0) {
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return FALSE;
}
#ifdef WIN_NT
exit_status = status;
#else
if (WIFEXITED(status))
exit_status = WEXITSTATUS(status);
else
exit_status = -1;
#endif
p2p_unify(CTXTc p2p_arg(signal_term,1), makeint(exit_status));
SYS_MUTEX_UNLOCK( MUTEX_SYS_SYSTEM );
return TRUE;
}
xsb_warn(CTXTc "[PROCESS_CONTROL] Arg 2: Invalid signal specification. Must be `kill' or `wait(Var)'");
return FALSE;
}
case LIST_DIRECTORY: {
/* assume all type- and mode-checking is done in Prolog */
prolog_term handle = reg_term(CTXTc 2); /* ref for handle */
char *dir_name = ptoc_longstring(CTXTc 3); /* +directory name */
prolog_term filename = reg_term(CTXTc 4); /* reference for name of file */
if (is_var(handle))
return xsb_find_first_file(CTXTc handle,dir_name,filename);
else
return xsb_find_next_file(CTXTc handle,dir_name,filename);
}
default:
xsb_abort("[SYS_SYSTEM] Wrong call number (an XSB bug)");
} /* end case */
return TRUE;
}
int set_python_argument(prolog_term temp, PyObject *pArgs,int i)
{
PyObject *pValue;
if(find_prolog_term_type(temp) == INT)
{
prolog_term argument = temp;
int argument_int = p2c_int(argument);
pValue = PyInt_FromLong(argument_int);
PyTuple_SetItem(pArgs, i-1, pValue);
}else if(find_prolog_term_type(temp) == STRING)
{
prolog_term argument = temp;
char *argument_char = p2c_string(argument);
//printf("%s", argument_char);
pValue = PyString_FromString(argument_char);
PyTuple_SetItem(pArgs, i-1, pValue);
}else if(find_prolog_term_type(temp) == FLOAT)
{
prolog_term argument = temp;
float argument_float = p2c_float(argument);
pValue = PyFloat_FromDouble(argument_float);
PyTuple_SetItem(pArgs, i-1, pValue);
}
else if(find_prolog_term_type(temp) == LIST)
{
prolog_term argument = temp;
int count = find_length_prolog_list(argument);
PyObject *pList = PyList_New(count);
if (! prlist2pyList(argument, pList, count))
return FALSE;
PyTuple_SetItem(pArgs, i-1, pList);
}
else if (find_prolog_term_type(temp) == FUNCTOR)
{
//region begin : handle pyobject term
if(strcmp(p2c_functor(temp),"pyObject") == 0)
{
prolog_term ref = p2p_arg(temp, 1);
char *node_pointer = p2c_string(ref);
pyobj_ref_node *pyobj_ref = (pyobj_ref_node *)strtol(node_pointer,NULL, 0);
//pyobj_ref_node *node = (pyobj_ref_node *)(node_pointer);
pValue = pyobj_ref->python_obj;
//printf("set_argN: %p %zu" , pValue, pyobj_ref->ref_id);
PyTuple_SetItem(pArgs, i - 1 , pValue);
}
//end region
}
// else if(find_prolog_term_type(temp) == REF)
// { //when a reference is passed.
// prolog_term argument = temp;
// char *argument_ref = p2c_string(argument);
// if(strncmp("ref_", argument_ref, 4)== 0 )
// { //gets the reference id from the string and finds it in the list
// argument_ref = argument_ref + 4;
// size_t ref = strtoul(argument_ref, NULL, 0);
// PyObject *obj = get_pyobj_ref_list(ref);
// if(obj == NULL)
// return FALSE;
// PyTuple_SetItem(pArgs, i-1, obj);
// }
// }
return TRUE;
}
int convert_prObj_pyObj(prolog_term prTerm, PyObject **pyObj)
{
if(find_prolog_term_type(prTerm) == INT)
{
prolog_term argument = prTerm;
int argument_int = p2c_int(argument);
*pyObj = PyInt_FromLong(argument_int);
return TRUE;
}else if(find_prolog_term_type(prTerm) == STRING)
{
prolog_term argument = prTerm;
char *argument_char = p2c_string(argument);
*pyObj = PyString_FromString(argument_char);
return TRUE;
}else if(find_prolog_term_type(prTerm) == FLOAT)
{
prolog_term argument = prTerm;
float argument_float = p2c_float(argument);
*pyObj = PyFloat_FromDouble(argument_float);
return TRUE;
}
else if(find_prolog_term_type(prTerm) == LIST)
{
prolog_term argument = prTerm;
if(find_prolog_term_type(argument) == LIST)
{
int count = find_length_prolog_list(argument);
PyObject *pList = PyList_New(count);
if(!prlist2pyList(argument, pList, count))
return FALSE;
*pyObj = pList;
return TRUE;
}
}
// else if(find_prolog_term_type(prTerm) == REF)
// { //when a reference is passed.
// prolog_term argument = prTerm;
// char *argument_ref = p2c_string(argument);
// if(strncmp("ref_", argument_ref, 4)== 0 )
// { //gets the reference id from the string and finds it in the list
// argument_ref = argument_ref + 4;
// size_t ref = strtoul(argument_ref, NULL, 0);
// PyObject *obj = get_pyobj_ref_list(ref);
// if(obj == NULL)
// return FALSE;
// *pyObj = obj;
// return TRUE;
// }
// }
else if (find_prolog_term_type(prTerm) == FUNCTOR)
{
//region begin : handle pyobject term
if(strcmp(p2c_functor(prTerm),"pyObject") == 0)
{
prolog_term ref = p2p_arg(prTerm, 1);
char *node_pointer = p2c_string(ref);
pyobj_ref_node *pyobj_ref = (pyobj_ref_node *)strtol(node_pointer,NULL, 0);
//pyobj_ref_node *node = (pyobj_ref_node *)(node_pointer);
*pyObj = pyobj_ref->python_obj;
}
//end region
}
return FALSE;
}
