c0ef937614
git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@40 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
582 lines
12 KiB
C
582 lines
12 KiB
C
/*************************************************************************
|
|
* *
|
|
* YAP Prolog *
|
|
* *
|
|
* Yap Prolog was developed at NCCUP - Universidade do Porto *
|
|
* *
|
|
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
|
|
* *
|
|
**************************************************************************
|
|
* *
|
|
* File: regexp.c *
|
|
* Last rev: *
|
|
* mods: *
|
|
* comments: regular expression interpreter *
|
|
* *
|
|
*************************************************************************/
|
|
|
|
#include "config.h"
|
|
#include "c_interface.h"
|
|
#if STDC_HEADERS
|
|
#include <stdlib.h>
|
|
#endif
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#if HAVE_TIME_H
|
|
#include <time.h>
|
|
#endif
|
|
#if HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
#if HAVE_SYS_STAT_H
|
|
#include <sys/stat.h>
|
|
#endif
|
|
#if HAVE_FCNTL_H
|
|
#include <fcntl.h>
|
|
#endif
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#if HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
#if HAVE_STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
#if HAVE_SIGNAL_H
|
|
#include <signal.h>
|
|
#endif
|
|
#if HAVE_SYS_WAIT_H
|
|
#include <sys/wait.h>
|
|
#endif
|
|
#if HAVE_DIRENT_H
|
|
#include <dirent.h>
|
|
#endif
|
|
|
|
#ifdef __MINGW32__
|
|
#ifdef HAVE_ENVIRON
|
|
#undef HAVE_ENVIRON
|
|
#endif
|
|
#endif
|
|
|
|
void PROTO(init_sys, (void));
|
|
|
|
/* Return time in a structure */
|
|
static int
|
|
datime(void)
|
|
{
|
|
Term tf, out[6];
|
|
#ifdef HAVE_TIME
|
|
time_t tp;
|
|
|
|
if ((tp = time(NULL)) == -1) {
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
#ifdef HAVE_LOCALTIME
|
|
{
|
|
struct tm *loc = localtime(&tp);
|
|
if (loc == NULL) {
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
out[0] = MkIntTerm(1900+loc->tm_year);
|
|
out[1] = MkIntTerm(1+loc->tm_mon);
|
|
out[2] = MkIntTerm(loc->tm_mday);
|
|
out[3] = MkIntTerm(loc->tm_hour);
|
|
out[4] = MkIntTerm(loc->tm_min);
|
|
out[5] = MkIntTerm(loc->tm_sec);
|
|
}
|
|
#else
|
|
oops
|
|
#endif /* HAVE_LOCALTIME */
|
|
#else
|
|
oops
|
|
#endif /* HAVE_TIME */
|
|
tf = MkApplTerm(MkFunctor(LookupAtom("datime"),6), 6, out);
|
|
return(unify(ARG1, tf));
|
|
}
|
|
|
|
#define BUF_SIZE 1024
|
|
|
|
/* Return a list of files for a directory */
|
|
static int
|
|
list_directory(void)
|
|
{
|
|
Term tf = MkAtomTerm(LookupAtom("[]"));
|
|
|
|
char *buf = AtomName(AtomOfTerm(ARG1));
|
|
#if HAVE_OPENDIR
|
|
{
|
|
DIR *de;
|
|
struct dirent *dp;
|
|
|
|
if ((de = opendir(buf)) == NULL) {
|
|
return(unify(ARG3, MkIntTerm(errno)));
|
|
}
|
|
while ((dp = readdir(de))) {
|
|
Term ti = MkAtomTerm(LookupAtom(dp->d_name));
|
|
tf = MkPairTerm(ti, tf);
|
|
}
|
|
closedir(de);
|
|
}
|
|
#endif /* HAVE_OPENDIR */
|
|
return(unify(ARG2, tf));
|
|
}
|
|
|
|
static int
|
|
p_unlink(void)
|
|
{
|
|
char *fd = AtomName(AtomOfTerm(ARG1));
|
|
if (unlink(fd) == -1) {
|
|
/* return an error number */
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
static int
|
|
p_mkdir(void)
|
|
{
|
|
char *fd = AtomName(AtomOfTerm(ARG1));
|
|
if (mkdir(fd, 0777) == -1) {
|
|
/* return an error number */
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
static int
|
|
p_rmdir(void)
|
|
{
|
|
char *fd = AtomName(AtomOfTerm(ARG1));
|
|
if (rmdir(fd) == -1) {
|
|
/* return an error number */
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
static int
|
|
rename_file(void)
|
|
{
|
|
char *s1 = AtomName(AtomOfTerm(ARG1));
|
|
char *s2 = AtomName(AtomOfTerm(ARG2));
|
|
#if HAVE_RENAME
|
|
if (rename(s1, s2) == -1) {
|
|
/* return an error number */
|
|
return(unify(ARG3, MkIntTerm(errno)));
|
|
}
|
|
#endif
|
|
return(TRUE);
|
|
}
|
|
|
|
static int
|
|
dir_separator(void)
|
|
{
|
|
return(unify(ARG1,MkAtomTerm(LookupAtom("/"))));
|
|
}
|
|
|
|
static int
|
|
file_property(void)
|
|
{
|
|
char *fd;
|
|
#if HAVE_LSTAT
|
|
struct stat buf;
|
|
|
|
fd = AtomName(AtomOfTerm(ARG1));
|
|
if (lstat(fd, &buf) == -1) {
|
|
/* return an error number */
|
|
return(unify(ARG6, MkIntTerm(errno)));
|
|
}
|
|
if (S_ISREG(buf.st_mode))
|
|
unify(ARG2, MkAtomTerm(LookupAtom("regular")));
|
|
else if (S_ISDIR(buf.st_mode))
|
|
unify(ARG2, MkAtomTerm(LookupAtom("directory")));
|
|
else if (S_ISFIFO(buf.st_mode))
|
|
unify(ARG2, MkAtomTerm(LookupAtom("fifo")));
|
|
else if (S_ISLNK(buf.st_mode))
|
|
unify(ARG2, MkAtomTerm(LookupAtom("symlink")));
|
|
else if (S_ISSOCK(buf.st_mode))
|
|
unify(ARG2, MkAtomTerm(LookupAtom("socket")));
|
|
else
|
|
unify(ARG2, MkAtomTerm(LookupAtom("unknown")));
|
|
unify(ARG3, MkIntTerm(buf.st_size));
|
|
unify(ARG4, MkIntTerm(buf.st_mtime));
|
|
unify(ARG5, MkIntTerm(buf.st_mode));
|
|
#endif
|
|
return(TRUE);
|
|
}
|
|
|
|
/* temporary files */
|
|
|
|
static int
|
|
p_mktemp(void)
|
|
{
|
|
#if HAVE_MKTEMP
|
|
char *s, tmp[1024];
|
|
s = AtomName(AtomOfTerm(ARG1));
|
|
#if HAVE_STRNCPY
|
|
strncpy(tmp, s, 1024);
|
|
#else
|
|
strcpy(tmp, s);
|
|
#endif
|
|
if ((s = mktemp(tmp)) == NULL) {
|
|
/* return an error number */
|
|
return(unify(ARG3, MkIntTerm(errno)));
|
|
}
|
|
return(unify(ARG2,MkAtomTerm(LookupAtom(s))));
|
|
#else
|
|
oops
|
|
#endif
|
|
return(TRUE);
|
|
}
|
|
|
|
static int
|
|
p_tpmnam(void)
|
|
{
|
|
#if HAVE_TMPNAM
|
|
return(unify(ARG1,MkAtomTerm(LookupAtom(tmpnam(NULL)))));
|
|
#else
|
|
oops
|
|
#endif
|
|
}
|
|
|
|
/* return YAP's environment */
|
|
static int
|
|
p_environ(void)
|
|
{
|
|
#if HAVE_ENVIRON
|
|
extern char **environ;
|
|
Term t1 = ARG1;
|
|
Int i;
|
|
|
|
i = IntOfTerm(t1);
|
|
if (environ[i] == NULL)
|
|
return(FALSE);
|
|
else {
|
|
Term t = BufferToString(environ[i]);
|
|
return(unify(t, ARG2));
|
|
}
|
|
#else
|
|
YapError("environ not available in this configuration");
|
|
return(FALSE);
|
|
#endif
|
|
}
|
|
|
|
/* execute a command as a detached process */
|
|
static int
|
|
execute_command(void)
|
|
{
|
|
Term ti = ARG2, to = ARG3, te = ARG4;
|
|
Term tzero = MkIntTerm(0);
|
|
int res;
|
|
int inpf, outf, errf;
|
|
/* process input first */
|
|
if (ti == tzero) {
|
|
inpf = open("/dev/null", O_RDONLY);
|
|
} else {
|
|
int sd = YapStreamToFileNo(ti);
|
|
inpf = dup(sd);
|
|
}
|
|
if (inpf < 0) {
|
|
/* return an error number */
|
|
return(unify(ARG6, MkIntTerm(errno)));
|
|
}
|
|
/* then output stream */
|
|
if (to == tzero) {
|
|
outf = open("/dev/zero", O_WRONLY);
|
|
} else {
|
|
int sd = YapStreamToFileNo(to);
|
|
outf = dup(sd);
|
|
}
|
|
if (outf < 0) {
|
|
/* return an error number */
|
|
return(unify(ARG6, MkIntTerm(errno)));
|
|
}
|
|
/* then error stream */
|
|
if (te == tzero) {
|
|
errf = open("/dev/zero", O_WRONLY);
|
|
} else {
|
|
int sd = YapStreamToFileNo(te);
|
|
errf = dup(sd);
|
|
}
|
|
if (errf < 0) {
|
|
/* return an error number */
|
|
return(unify(ARG6, MkIntTerm(errno)));
|
|
}
|
|
/* we are now ready to fork */
|
|
if ((res = fork()) < 0) {
|
|
/* close streams we don't need */
|
|
close(inpf);
|
|
close(outf);
|
|
close(errf);
|
|
/* return an error number */
|
|
return(unify(ARG6, MkIntTerm(errno)));
|
|
} else if (res == 0) {
|
|
char *argv[4];
|
|
|
|
/* child */
|
|
/* close current streams, but not std streams */
|
|
YapCloseAllOpenStreams();
|
|
close(0);
|
|
dup(inpf);
|
|
close(1);
|
|
dup(outf);
|
|
close(2);
|
|
dup(outf);
|
|
close(inpf);
|
|
close(outf);
|
|
close(errf);
|
|
argv[0] = "sh";
|
|
argv[1] = "-c";
|
|
argv[2] = AtomName(AtomOfTerm(ARG1));
|
|
argv[3] = NULL;
|
|
execv("/bin/sh", argv);
|
|
exit(127);
|
|
/* we have the streams where we want them, just want to execute now */
|
|
} else {
|
|
close(inpf);
|
|
close(outf);
|
|
close(errf);
|
|
return(unify(ARG5,MkIntTerm(res)));
|
|
}
|
|
}
|
|
|
|
/* execute a command as a detached process */
|
|
static int
|
|
shell(void)
|
|
{
|
|
char *command = AtomName(AtomOfTerm(ARG1));
|
|
int pid;
|
|
/* we are now ready to fork */
|
|
if ((pid = fork()) < 0) {
|
|
/* return an error number */
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
} else if (pid == 0) {
|
|
char *argv[4];
|
|
char *shell;
|
|
|
|
/* child */
|
|
/* close current streams, but not std streams */
|
|
YapCloseAllOpenStreams();
|
|
#if HAVE_GETENV
|
|
shell = getenv ("SHELL");
|
|
if (shell == NULL)
|
|
shell = "/bin/sh";
|
|
#endif
|
|
argv[0] = shell;
|
|
argv[1] = "-c";
|
|
argv[2] = command;
|
|
argv[3] = NULL;
|
|
execv("/bin/sh", argv);
|
|
exit(127);
|
|
/* we have the streams where we want them, just want to execute now */
|
|
} else {
|
|
do {
|
|
int status;
|
|
|
|
/* check for interruptions */
|
|
if (waitpid(pid, &status, 0) == -1) {
|
|
if (errno != EINTR)
|
|
return -1;
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
} else
|
|
return(TRUE);
|
|
} while(TRUE);
|
|
}
|
|
}
|
|
|
|
/* execute a command as a detached process */
|
|
static int
|
|
do_system(void)
|
|
{
|
|
char *command = AtomName(AtomOfTerm(ARG1));
|
|
int sys = system(command);
|
|
#if HAVE_SYSTEM
|
|
return(unify(ARG2, MkIntTerm(sys)));
|
|
#endif
|
|
}
|
|
|
|
/* execute a command as a detached process */
|
|
static int
|
|
p_wait(void)
|
|
{
|
|
Int pid = IntOfTerm(ARG1);
|
|
do {
|
|
int status;
|
|
|
|
/* check for interruptions */
|
|
if (waitpid(pid, &status, 0) == -1) {
|
|
if (errno != EINTR)
|
|
return -1;
|
|
return(unify(ARG3, MkIntTerm(errno)));
|
|
} else {
|
|
return(unify(ARG2, MkIntTerm(status)));
|
|
}
|
|
} while(TRUE);
|
|
}
|
|
|
|
/* execute a command as a detached process */
|
|
static int
|
|
p_popen(void)
|
|
{
|
|
char *command = AtomName(AtomOfTerm(ARG1));
|
|
Int mode = IntOfTerm(ARG2);
|
|
FILE *pfd;
|
|
Term tsno;
|
|
int flags;
|
|
|
|
#if HAVE_POPEN
|
|
if (mode == 0)
|
|
pfd = popen(command, "r");
|
|
else
|
|
pfd = popen(command, "w");
|
|
if (pfd == NULL) {
|
|
return(unify(ARG4, MkIntTerm(errno)));
|
|
}
|
|
if (mode == 0)
|
|
flags = YAP_INPUT_STREAM | YAP_POPEN_STREAM;
|
|
else
|
|
flags = YAP_OUTPUT_STREAM | YAP_POPEN_STREAM;
|
|
tsno = YapOpenStream((void *)pfd,
|
|
"pipe",
|
|
MkAtomTerm(LookupAtom("pipe")),
|
|
flags);
|
|
#endif
|
|
return(unify(ARG3, tsno));
|
|
}
|
|
|
|
static int
|
|
p_sleep(void)
|
|
{
|
|
Term ts = ARG1;
|
|
Int secs = 0, usecs = 0, out;
|
|
if (IsIntTerm(ts)) {
|
|
secs = IntOfTerm(ts);
|
|
} else if (IsFloatTerm(ts)) {
|
|
flt tfl = FloatOfTerm(ts);
|
|
if (tfl > 1.0)
|
|
secs = tfl;
|
|
else
|
|
usecs = tfl*1000;
|
|
}
|
|
#if HAVE_USLEEP
|
|
if (usecs > 0) {
|
|
usleep(usecs);
|
|
out = 0;
|
|
} else
|
|
#endif
|
|
#if HAVE_SLEEP
|
|
{
|
|
out = sleep(secs);
|
|
}
|
|
#endif
|
|
return(unify(ARG2, MkIntTerm(out)));
|
|
}
|
|
|
|
/* host info */
|
|
|
|
static int
|
|
host_name(void)
|
|
{
|
|
char name[256];
|
|
#if HAVE_GETHOSTNAME
|
|
if (gethostname(name, 256) == -1) {
|
|
/* return an error number */
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
#endif
|
|
return(unify(ARG1, MkAtomTerm(LookupAtom(name))));
|
|
}
|
|
|
|
static int
|
|
host_id(void)
|
|
{
|
|
#if HAVE_GETHOSTID
|
|
return(unify(ARG1, MkIntTerm(gethostid())));
|
|
#endif
|
|
}
|
|
|
|
static int
|
|
pid(void)
|
|
{
|
|
return(unify(ARG1, MkIntTerm(getpid())));
|
|
}
|
|
|
|
static int
|
|
p_kill(void)
|
|
{
|
|
#if HAVE_KILL
|
|
if (kill(IntOfTerm(ARG1), IntOfTerm(ARG2)) < 0) {
|
|
/* return an error number */
|
|
return(unify(ARG2, MkIntTerm(errno)));
|
|
}
|
|
#else
|
|
oops
|
|
#endif
|
|
return(TRUE);
|
|
}
|
|
|
|
static int
|
|
error_message(void)
|
|
{
|
|
#if HAVE_STRERROR
|
|
return(unify(ARG2,MkAtomTerm(LookupAtom(strerror(IntOfTerm(ARG1))))));
|
|
#else
|
|
#if HAVE_STRERROR
|
|
return(unify(ARG2,ARG1));
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void
|
|
init_sys(void)
|
|
{
|
|
UserCPredicate("datime", datime, 2);
|
|
UserCPredicate("list_directory", list_directory, 3);
|
|
UserCPredicate("file_property", file_property, 6);
|
|
UserCPredicate("unlink", p_unlink, 2);
|
|
UserCPredicate("mkdir", p_mkdir, 2);
|
|
UserCPredicate("rmdir", p_rmdir, 2);
|
|
UserCPredicate("dir_separator", dir_separator, 1);
|
|
UserCPredicate("p_environ", p_environ, 2);
|
|
UserCPredicate("exec_command", execute_command, 6);
|
|
UserCPredicate("do_shell", shell, 2);
|
|
UserCPredicate("do_system", do_system, 2);
|
|
UserCPredicate("popen", p_popen, 4);
|
|
UserCPredicate("wait", p_wait, 3);
|
|
UserCPredicate("host_name", host_name, 2);
|
|
UserCPredicate("host_id", host_id, 2);
|
|
UserCPredicate("pid", pid, 2);
|
|
UserCPredicate("kill", p_kill, 3);
|
|
UserCPredicate("mktemp", p_mktemp, 3);
|
|
UserCPredicate("tmpnam", p_tpmnam, 2);
|
|
UserCPredicate("rename_file", rename_file, 3);
|
|
UserCPredicate("sleep", p_sleep, 2);
|
|
UserCPredicate("error_message", error_message, 2);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
int WINAPI PROTO(win_system, (HANDLE, DWORD, LPVOID));
|
|
|
|
int WINAPI win_system(HANDLE hinst, DWORD reason, LPVOID reserved)
|
|
{
|
|
switch (reason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
break;
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
case DLL_THREAD_ATTACH:
|
|
break;
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
}
|
|
p return 1;
|
|
}
|
|
#endif
|