/* 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; } }
/* * call as: between_datime(+T1,+T2,+T3) * Checks if T1 is between T2 and T3 */ int between_datime(CTXTdecl) { prolog_term t1 = reg_term(CTXTc 1); prolog_term t2 = reg_term(CTXTc 2); prolog_term t3 = reg_term(CTXTc 3); if (!is_functor(t1) && !is_functor(t2) && !is_functor(t3)) return FALSE; int t1_arity = p2c_arity(t1); int t2_arity = p2c_arity(t2); int t3_arity = p2c_arity(t3); int t1_ts = p2c_int(p2p_arg(t1,1)); int t2_ts = p2c_int(p2p_arg(t2,1)); int t3_ts = p2c_int(p2p_arg(t3,1)); int t1_coun = 0; int t2_coun = 0; int t3_coun = 0; if ( t1_arity > 1 && t2_arity > 1 && t3_arity > 1 ) { t1_coun = p2c_int(p2p_arg(t1,2)); t2_coun = p2c_int(p2p_arg(t2,2)); t3_coun = p2c_int(p2p_arg(t3,2)); } return aux_less_datime(t2_ts,t1_ts,t2_coun,t1_coun) && aux_less_datime(t1_ts,t3_ts,t1_coun,t3_coun); }
/* 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"); }
//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; }
/* * call as: less_datime(T1,T2) * Return true if T1 is an older date than T2 */ int less_datime(CTXTdecl) { prolog_term t1 = reg_term(CTXTc 1); prolog_term t2 = reg_term(CTXTc 2); if (!is_functor(t1) || !is_functor(t2)) { return FALSE; } int t1_arity = p2c_arity(t1); int t2_arity = p2c_arity(t2); int t1_ts = p2c_int(p2p_arg(t1,1)); int t2_ts = p2c_int(p2p_arg(t2,1)); int t1_coun = 0; int t2_coun = 0; if ( t1_arity > 1 && t2_arity > 1 ) { t1_coun = p2c_int(p2p_arg(t1,2)); t2_coun = p2c_int(p2p_arg(t2,2)); } return aux_less_datime(t1_ts,t2_ts,t1_coun,t2_coun); }
/* * call as: datime_plus_sec(T1,Sec,T2) * Returns T2 as the result of date T1 plus Sec seconds */ int datime_plus_sec(CTXTdecl) { prolog_term t1 = reg_term(CTXTc 1); if(!is_functor(t1)) return FALSE; int t1_ts = p2c_int(p2p_arg(t1,1)); int sec = p2c_int(reg_term(CTXTc 2)); if (p2c_arity(t1) > 1) { int counter = p2p_arg(t1,2); c2p_functor(CTXTc "datime",2,reg_term(CTXTc 3)); c2p_int(CTXTc t1_ts+sec,p2p_arg(reg_term(CTXTc 3),1)); c2p_int(CTXTc counter,p2p_arg(reg_term(CTXTc 3),2)); } else { c2p_functor(CTXTc "datime",1,reg_term(CTXTc 3)); c2p_int(CTXTc t1_ts+sec,p2p_arg(reg_term(CTXTc 3),1)); } return TRUE; }
HDDEDATA FAR PASCAL _export DdeCallback(UINT type, UINT fmt, HCONV hConv, HSZ hsz1, HSZ hsz2, HDDEDATA data, DWORD data1, DWORD data2) { long int ind, i, spaceneeded, sizeQuery; DWORD Qlen, QSegLen; static HCONV handConv; static HDDEDATA hdDataHandle; /*DdeQueryString(idInst,hsz1,szBuff1,sizeof(szBuff1),0); DdeQueryString(idInst,hsz2,szBuff2,sizeof(szBuff2),0); fprintf(stderr,"DDE Callback, type=%d, fmt=%d, hConv=%d, hsz1=%s, hsz2=%s,\n d1=%x, d2=%x\n", type,fmt,hConv,szBuff1,szBuff2,data1,data2);*/ switch (type) { case XTYP_ERROR: fprintf(stderr,"error: xtyp_error\n"); return NULL; case XTYP_ADVDATA: fprintf(stderr,"DDE msg received ADVDATA\n"); return DDE_FNOTPROCESSED; case XTYP_ADVREQ: fprintf(stderr,"DDE msg received ADVREQ\n"); return NULL; case XTYP_ADVSTART: fprintf(stderr,"DDE msg received ADVSTART\n"); return NULL; case XTYP_ADVSTOP: fprintf(stderr,"DDE msg received ADVSTOP\n"); return NULL; case XTYP_CONNECT: DdeQueryString(idInst,hsz2,szBuffer,sizeof(szBuffer),0); if (strcmp(szBuffer,szAppName)) return FALSE; Qlen = DdeQueryString(idInst,hsz1,NULL,0,0); szQuery = (char *)malloc(Qlen+1); (void)DdeQueryString(idInst,hsz1,szQuery,Qlen+1,0); if (!strcmp(szQuery,"XSB")) { free(szQuery); szQuery = NULL; } return TRUE; case XTYP_CONNECT_CONFIRM: handConv = hConv; return TRUE; case XTYP_DISCONNECT: return NULL; case XTYP_EXECUTE: fprintf(stderr,"DDE msg received EXECUTE\n"); return DDE_FNOTPROCESSED; case XTYP_POKE: QSegLen = DdeGetData(data,NULL,100000,0L); if (!szQuery) { szQuery = (char *)malloc(QSegLen); QSegLen = DdeGetData(data,szQuery,100000,0L); sizeQuery = QSegLen; } else { szQuery = (char *)realloc(szQuery,sizeQuery+QSegLen+1); QSegLen = DdeGetData(data,szQuery+sizeQuery,100000,0L); sizeQuery =+ QSegLen; } return DDE_FACK; case XTYP_REGISTER: fprintf(stderr,"DDE msg received REGISTER\n"); return NULL; case XTYP_REQUEST: /*fprintf(stderr,"DDE msg received REQUEST:\n");*/ if (!szQuery) return NULL; if (sizeBuff3 < 10) { szBuff3 = (char *)malloc(initsizeBuff3); sizeBuff3 = initsizeBuff3; } ind = 0; rcode = xsb_query_string(szQuery); /* call the query */ if (rcode) { strcpy(szBuff3+ind,"no\r"); ind += 3; } else if (is_string(reg_term(2)) || p2c_arity(reg_term(2))==0) { strcpy(szBuff3+ind,"yes\r"); ind += 4; while (!rcode) rcode = xsb_next(); } else while (!rcode) { spaceneeded = ind + clenpterm(reg_term(2)) + 20; /* fudge factor */ if (spaceneeded > sizeBuff3) { while (spaceneeded > sizeBuff3) {sizeBuff3 = 2*sizeBuff3;} szBuff3 = realloc(szBuff3,sizeBuff3); } for (i=1; i<p2c_arity(reg_term(2)); i++) { printpterm(p2p_arg(reg_term(2),i),TRUE,szBuff3,&ind); strcpy(szBuff3+ind,"\t"); ind += 1; } printpterm(p2p_arg(reg_term(2),p2c_arity(reg_term(2))),TRUE,szBuff3,&ind); strcpy(szBuff3+ind,"\r"); ind += 1; rcode = xsb_next(); } hdDataHandle = DdeCreateDataHandle(idInst,szBuff3,ind+1,0,hsz2,CF_TEXT,0); free(szQuery); szQuery = NULL; return hdDataHandle; case XTYP_WILDCONNECT: fprintf(stderr,"DDE msg received WILDCONNECT\n"); return NULL; default: fprintf(stderr,"DDE msg received: %d\n",type); } return NULL; }
/* 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; }