#ifdef WINDOWSNT
#include <direct.h>
+#ifdef __MINGW32__
+#include <mingw32/process.h>
+#else
/* <process.h> should not conflict with "process.h", as per ANSI definition.
- This is not true though with visual c though. The trick below works with
- VC4.2b and with VC5.0. It assumes that VC is installed in a kind of
- standard way, so include files get to what/ever/path/include.
+ This is not true with visual c though. The trick below works with
+ VC4.2b, 5.0 and 6.0. It assumes that VC is installed in a kind of
+ standard way, so include path ends with /include.
Unfortunately, this must go before lisp.h, since process.h defines abort()
which will conflict with the macro defined in lisp.h
*/
#include <../include/process.h>
+#endif /* __MINGW32__ */
#endif /* WINDOWSNT */
#include "lisp.h"
-#include <stddef.h>
#include <stdlib.h>
/* ------------------------------- */
#ifdef WINDOWSNT
#include <sys/utime.h>
-#include <windows.h>
#include "ntheap.h"
#endif
#endif /* NO_SUBPROCESSES */
-void
-wait_for_termination (int pid)
+#ifdef WINDOWSNT
+void wait_for_termination (HANDLE pHandle)
+#else
+void wait_for_termination (int pid)
+#endif
{
/* #### With the new improved SIGCHLD handling stuff, there is much
less danger of race conditions and some of the comments below
Since implementations may add their own error indicators on top,
we ignore it by default. */
+#elif defined (WINDOWSNT)
+ int ret = 0, status = 0;
+ if (pHandle == NULL)
+ {
+ warn_when_safe (Qprocess, Qwarning, "Cannot wait for unknown process to terminate");
+ return;
+ }
+ do
+ {
+ QUIT;
+ ret = WaitForSingleObject(pHandle, 100);
+ }
+ while (ret == WAIT_TIMEOUT);
+ if (ret == WAIT_FAILED)
+ {
+ warn_when_safe (Qprocess, Qwarning, "waiting for process failed");
+ }
+ if (ret == WAIT_ABANDONED)
+ {
+ warn_when_safe (Qprocess, Qwarning,
+ "process to wait for has been abandoned");
+ }
+ if (ret == WAIT_OBJECT_0)
+ {
+ ret = GetExitCodeProcess(pHandle, &status);
+ if (ret)
+ {
+ synch_process_alive = 0;
+ synch_process_retcode = status;
+ }
+ else
+ {
+ /* GetExitCodeProcess() didn't return a valid exit status,
+ nothing to do. APA */
+ warn_when_safe (Qprocess, Qwarning,
+ "failure to obtain process exit value");
+ }
+ }
+ if (pHandle != NULL && !CloseHandle(pHandle))
+ {
+ warn_when_safe (Qprocess, Qwarning,
+ "failure to close unknown process");
+ }
#elif defined (EMACS_BLOCK_SIGNAL) && !defined (BROKEN_WAIT_FOR_SIGNAL) && defined (SIGCHLD)
while (1)
{
Try defining BROKEN_WAIT_FOR_SIGNAL. */
EMACS_WAIT_FOR_SIGNAL (SIGCHLD);
}
-#else /* not HAVE_WAITPID and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
+#else /* not HAVE_WAITPID and not WINDOWSNT and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
/* This approach is kind of cheesy but is guaranteed(?!) to work
for all systems. */
while (1)
child_setup_tty (int out)
{
struct emacs_tty s;
- EMACS_GET_TTY (out, &s);
+ emacs_get_tty (out, &s);
#if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
assert (isatty(out));
#endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
s.main.c_cc[VEOL] = _POSIX_VDISABLE;
#if defined (CBAUD)
- /* <mdiers> ### This is not portable. ###
+ /* <mdiers> #### This is not portable. ###
POSIX does not specify CBAUD, and 4.4BSD does not have it.
Instead, POSIX suggests to use cfset{i,o}speed().
[cf. D. Lewine, POSIX Programmer's Guide, Chapter 8: Terminal
s.lmode = LLITOUT | s.lmode; /* Don't strip 8th bit */
#endif /* not HAVE_TERMIO */
- EMACS_SET_TTY (out, &s, 0);
+ emacs_set_tty (out, &s, 0);
#ifdef RTU
{
}
#ifdef WINDOWSNT
-int
+pid_t
sys_getpid (void)
{
return abs (getpid ());
static void
sys_subshell (void)
{
+#ifdef WINDOWSNT
+ HANDLE pid;
+#else
int pid;
+#endif
struct save_signal saved_handlers[5];
Lisp_Object dir;
unsigned char *str = 0;
xyzzy:
#ifdef WINDOWSNT
- pid = -1;
+ pid = NULL;
#else /* not WINDOWSNT */
pid = fork ();
#ifdef WINDOWSNT
/* Waits for process completion */
pid = _spawnlp (_P_WAIT, sh, sh, NULL);
- if (pid == -1)
+ if (pid == NULL)
write (1, "Can't execute subshell", 22);
#else /* not WINDOWSNT */
{
int filedesc = DEVICE_INFD (d);
-#if defined (I_SETSIG) && !defined(HPUX10)
+#if defined (I_SETSIG) && !defined(HPUX10) && !defined(LINUX)
{
int events=0;
ioctl (filedesc, I_GETSIG, &events);
/* Set the parameters of the tty on FD according to the contents of
*SETTINGS. If FLUSHP is non-zero, we discard input.
- Return 0 if all went well, and -1 if anything failed. */
+ Return 0 if all went well, and -1 if anything failed.
+ #### All current callers use FLUSHP == 0. */
int
emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
input_fd = CONSOLE_TTY_DATA (con)->infd;
output_fd = CONSOLE_TTY_DATA (con)->outfd;
- EMACS_GET_TTY (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
+ emacs_get_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
tty = CONSOLE_TTY_DATA (con)->old_tty;
con->tty_erase_char = Qnil;
tty.ltchars = new_ltchars;
#endif /* HAVE_LTCHARS */
- EMACS_SET_TTY (input_fd, &tty, 0);
+ emacs_set_tty (input_fd, &tty, 0);
/* This code added to insure that, if flow-control is not to be used,
we have an unlocked terminal at the start. */
#ifdef TCXONC
if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TCXONC, 1);
#endif
-#ifndef APOLLO
#ifdef TIOCSTART
if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TIOCSTART, 0);
#endif
-#endif
#if defined (HAVE_TERMIOS) || defined (HPUX9)
#ifdef TCOON
{
struct emacs_tty tty;
- EMACS_GET_TTY (DEVICE_INFD (d), &tty);
+ emacs_get_tty (DEVICE_INFD (d), &tty);
return EMACS_TTY_TABS_OK (&tty);
}
#endif
assert (DEVICE_TTY_P (d));
input_fd = DEVICE_INFD (d);
- EMACS_GET_TTY (input_fd, &s);
+ emacs_get_tty (input_fd, &s);
#if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
eight_bit = (s.main.c_cflag & CSIZE) == CS8;
fsync (output_fd);
#endif
- while (EMACS_SET_TTY (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
+ while (emacs_set_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
< 0 && errno == EINTR)
;
else
#endif
if (DEVICE_STREAM_P (d))
- fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->outfd);
+ fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->out);
#if defined(SIGIO) && !defined(BROKEN_SIGIO)
if (!DEVICE_STREAM_P (d))
{
/* limits of text/data segments */
/************************************************************************/
-#ifndef CANNOT_DUMP
+#if !defined(CANNOT_DUMP) && !defined(PDUMP)
#define NEED_STARTS
#endif
*
*/
+#if !defined(HAVE_TEXT_START) && !defined(PDUMP)
+
#ifdef __cplusplus
- extern "C" int _start ();
+ extern "C" int _start (void);
#else
- extern int _start ();
+ extern int _start (void);
#endif
-#ifndef HAVE_TEXT_START
char *
start_of_text (void)
{
#endif /* GOULD */
#endif /* TEXT_START */
}
-#endif /* not HAVE_TEXT_START */
+#endif /* !defined(HAVE_TEXT_START) && !defined(PDUMP) */
/*
* Return the address of the start of the data segment prior to
}
#endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
-#ifndef CANNOT_DUMP
+#if !defined(CANNOT_DUMP) && !defined(PDUMP)
/* Some systems that cannot dump also cannot implement these. */
/*
#endif
}
-#endif /* not CANNOT_DUMP */
+#endif /* !defined(CANNOT_DUMP) && !defined(PDUMP) */
\f
/************************************************************************/
{
#if defined (WINDOWSNT)
char hostname [MAX_COMPUTERNAME_LENGTH + 1];
- size_t size = sizeof(hostname);
+ size_t size = sizeof (hostname);
GetComputerName (hostname, &size);
Vsystem_name = build_string (hostname);
#elif !defined (HAVE_GETHOSTNAME)
# ifndef CANNOT_DUMP
if (initialized)
# endif /* not CANNOT_DUMP */
- {
- struct hostent *hp = NULL;
- int count;
-# ifdef TRY_AGAIN
- for (count = 0; count < 10; count++)
- {
- h_errno = 0;
-# endif
- /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
- stop_interrupts ();
- hp = gethostbyname (hostname);
- start_interrupts ();
-# ifdef TRY_AGAIN
- if (! (hp == 0 && h_errno == TRY_AGAIN))
- break;
- Fsleep_for (make_int (1));
- }
-# endif
- if (hp)
- {
- CONST char *fqdn = (CONST char *) hp->h_name;
-
- if (!strchr (fqdn, '.'))
- {
- /* We still don't have a fully qualified domain name.
- Try to find one in the list of alternate names */
- char **alias = hp->h_aliases;
- while (*alias && !strchr (*alias, '.'))
- alias++;
- if (*alias)
- fqdn = *alias;
- }
- hostname = (char *) alloca (strlen (fqdn) + 1);
- strcpy (hostname, fqdn);
- }
- }
+ if (!strchr (hostname, '.'))
+ {
+# if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETNAMEINFO))
+ struct hostent *hp = NULL;
+ int count;
+# ifdef TRY_AGAIN
+ for (count = 0; count < 10; count++)
+ {
+ h_errno = 0;
+# endif
+ /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
+ stop_interrupts ();
+ hp = gethostbyname (hostname);
+ start_interrupts ();
+# ifdef TRY_AGAIN
+ if (! (hp == 0 && h_errno == TRY_AGAIN))
+ break;
+ Fsleep_for (make_int (1));
+ }
+# endif
+ if (hp)
+ {
+ CONST char *fqdn = (CONST char *) hp->h_name;
+
+ if (!strchr (fqdn, '.'))
+ {
+ /* We still don't have a fully qualified domain name.
+ Try to find one in the list of alternate names */
+ char **alias = hp->h_aliases;
+ while (*alias && !strchr (*alias, '.'))
+ alias++;
+ if (*alias)
+ fqdn = *alias;
+ }
+ hostname = (char *) alloca (strlen (fqdn) + 1);
+ strcpy (hostname, fqdn);
+ }
+# else /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
+ struct addrinfo hints, *res;
+
+ xzero (hints);
+ hints.ai_flags = AI_CANONNAME;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = 0;
+ if (!getaddrinfo (hostname, NULL, &hints, &res))
+ {
+ hostname = (char *) alloca (strlen (res->ai_canonname) + 1);
+ strcpy (hostname, res->ai_canonname);
+
+ freeaddrinfo (res);
+ }
+# endif /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
+ }
# endif /* HAVE_SOCKETS */
Vsystem_name = build_string (hostname);
#endif /* HAVE_GETHOSTNAME */
int i;
/* check the table for the OS error code */
- for (i = 0; i < sizeof(errtable)/sizeof(errtable[0]); ++i)
+ for (i = 0; i < countof (errtable); ++i)
{
if (win32_error == errtable[i].oscode)
{
/************************************************************************/
#define PATHNAME_CONVERT_OUT(path) \
- GET_C_CHARPTR_EXT_FILENAME_DATA_ALLOCA ((CONST Bufbyte *) path, path)
+ TO_EXTERNAL_FORMAT (C_STRING, (path), C_STRING_ALLOCA, (path), Qfile_name);
/***************** low-level calls ****************/
/* Ben sez: read Dick Gabriel's essay about the Worse Is Better
approach to programming and its connection to the silly
- interruptible-system-call business. To find it, look at
- Jamie's home page (http://www.netscape.com/people/jwz). */
+ interruptible-system-call business. To find it, look on
+ Jamie's home page (http://www.jwz.org/worse-is-better.html). */
#ifdef ENCAPSULATE_OPEN
int
mode = va_arg (ap, int);
va_end (ap);
- PATHNAME_CONVERT_OUT (path);
-#if defined (WINDOWSNT)
+#ifdef WINDOWSNT
/* Make all handles non-inheritable */
- return open (path, oflag | _O_NOINHERIT, mode);
-#elif defined (INTERRUPTIBLE_OPEN)
+ oflag |= _O_NOINHERIT;
+#endif
+
+#ifdef INTERRUPTIBLE_OPEN
{
int rtnval;
while ((rtnval = open (path, oflag, mode)) == -1
PATHNAME_CONVERT_OUT (nonreloc);
+#ifdef WINDOWSNT
+ /* Make all handles non-inheritable */
+ oflag |= _O_NOINHERIT;
+#endif
+
for (;;)
{
int rtnval = open (nonreloc, oflag, mode);
#ifdef ENCAPSULATE_CLOSE
int
-sys_close (int fd)
+sys_close (int filedes)
{
#ifdef INTERRUPTIBLE_CLOSE
int did_retry = 0;
REGISTER int rtnval;
- while ((rtnval = close (fd)) == -1
+ while ((rtnval = close (filedes)) == -1
&& (errno == EINTR))
did_retry = 1;
return rtnval;
#else
- return close (fd);
+ return close (filedes);
#endif
}
#endif /* ENCAPSULATE_CLOSE */
-int
+ssize_t
sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit)
{
- int rtnval;
+ ssize_t rtnval;
/* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
while ((rtnval = read (fildes, buf, nbyte)) == -1
}
#ifdef ENCAPSULATE_READ
-int
+ssize_t
sys_read (int fildes, void *buf, size_t nbyte)
{
return sys_read_1 (fildes, buf, nbyte, 0);
}
#endif /* ENCAPSULATE_READ */
-int
+ssize_t
sys_write_1 (int fildes, CONST void *buf, size_t nbyte, int allow_quit)
{
- int rtnval;
- int bytes_written = 0;
+ ssize_t bytes_written = 0;
CONST char *b = (CONST char *) buf;
/* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
while (nbyte > 0)
{
- rtnval = write (fildes, b, nbyte);
+ ssize_t rtnval = write (fildes, b, nbyte);
if (allow_quit)
REALLY_QUIT;
if (errno == EINTR)
continue;
else
- return (bytes_written ? bytes_written : -1);
+ return bytes_written ? bytes_written : -1;
}
b += rtnval;
nbyte -= rtnval;
bytes_written += rtnval;
}
- return (bytes_written);
+ return bytes_written;
}
#ifdef ENCAPSULATE_WRITE
-int
+ssize_t
sys_write (int fildes, CONST void *buf, size_t nbyte)
{
return sys_write_1 (fildes, buf, nbyte, 0);
Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
offsetof (DIRENTRY, d_name));
- internal_name =
- convert_from_external_format (external_name, external_len,
- &internal_len, FORMAT_FILENAME);
+ TO_INTERNAL_FORMAT (DATA, (external_name, external_len),
+ ALLOCA, (internal_name, internal_len),
+ Qfile_name);
Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */
#endif /* ENCAPSULATE_READLINK */
+#ifdef ENCAPSULATE_FSTAT
+int
+sys_fstat (int fd, struct stat *buf)
+{
+ return fstat (fd, buf);
+}
+#endif /* ENCAPSULATE_FSTAT */
+
+
#ifdef ENCAPSULATE_STAT
int
sys_stat (CONST char *path, struct stat *buf)
projects / chise / xemacs-chise.git- / blobdiff