xemacs-beta: src/sysdep.c comparison

comparison src/sysdep.c @ 398:74fd4e045ea6 r21-2-29

Import from CVS: tag r21-2-29

author	cvs
date	Mon, 13 Aug 2007 11:13:30 +0200
parents	6719134a07c2
children	a86b2b5e0111

comparison

equal deleted inserted replaced

-:f4aeb21a5bad
+:74fd4e045ea6
 #include <config.h>
 #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
+This is not true 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
+VC4.2b, 5.0 and 6.0. It assumes that VC is installed in a kind of
-standard way, so include files get to what/ever/path/include.
+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>
 /* ------------------------------- */
 /*          basic includes         */
 /* ------------------------------- */
 #include <sys/times.h>
 #endif
 #ifdef WINDOWSNT
 #include <sys/utime.h>
-#include <windows.h>
 #include "ntheap.h"
 #endif
 /* ------------------------------- */
 /*         TTY definitions         */
 #endif /* BSD */
 #endif /* NO_SUBPROCESSES */
-void
+#ifdef WINDOWSNT
-wait_for_termination (int pid)
+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
 don't apply.  This should be updated. */
 - EINVAL (incorrect arguments),
 which are both program bugs.
 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)
 {
 static int wait_debugging = 0; /* Set nonzero to make following
 function work under dbx (at least for bsd).  */
 	   sigpause()/sigsuspend(), then your OS doesn't implement
 	   this properly (this applies under hpux9, for example).
 	   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)
 {
 QUIT;
 void
 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));
 s.main.c_oflag |= OPOST;	/* Enable output postprocessing */
 s.main.c_oflag &= ~ONLCR;	/* Disable map of NL to CR-NL on output */
 s.main.c_cc[VSUSP] = _POSIX_VDISABLE;
 s.main.c_lflag &= ~ISIG;
 #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
 I/O, O'Reilly 1991] */
 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 s.main.sg_erase = 0377;
 s.main.sg_kill  = 0377;
 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
 {
 int zero = 0;
 ioctl (out, FIOASYNC, &zero);
 saved_handlers++;
 }
 }
 #ifdef WINDOWSNT
-int
+pid_t
 sys_getpid (void)
 {
 return abs (getpid ());
 }
 #endif /* WINDOWSNT */
 /* Fork a subshell.  */
 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;
 int len;
 struct gcpro gcpro1;
 if (str[len - 1] != '/') str[len++] = '/';
 str[len] = 0;
 xyzzy:
 #ifdef WINDOWSNT
-pid = -1;
+pid = NULL;
 #else /* not WINDOWSNT */
 pid = fork ();
 if (pid == -1)
 #endif
 #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 */
 execlp (sh, sh, 0);
 write (1, "Can't execute subshell", 22);
 /* Figure out the eof character for the FD. */
 Bufbyte
 get_eof_char (int fd)
 {
-CONST Bufbyte ctrl_d = (Bufbyte) '\004';
+const Bufbyte ctrl_d = (Bufbyte) '\004';
 if (!isatty (fd))
 return ctrl_d;
 #ifdef HAVE_TERMIOS
 {
 struct termios t;
 tcgetattr (fd, &t);
 #if 0
 /* What is the following line designed to do??? -mrb */
-if (strlen ((CONST char *) t.c_cc) < (unsigned int) (VEOF + 1))
+if (strlen ((const char *) t.c_cc) < (unsigned int) (VEOF + 1))
 return ctrl_d;
 else
 return (Bufbyte) t.c_cc[VEOF];
 #endif
 return t.c_cc[VEOF] == _POSIX_VDISABLE ? ctrl_d : (Bufbyte) t.c_cc[VEOF];
 characters.  */
 #ifdef TCGETA
 {
 struct termio t;
 ioctl (fd, TCGETA, &t);
-if (strlen ((CONST char *) t.c_cc) < (unsigned int) (VINTR + 1))
+if (strlen ((const char *) t.c_cc) < (unsigned int) (VINTR + 1))
 return ctrl_d;
 else
 return (Bufbyte) t.c_cc[VINTR];
 }
 #else /* ! defined (TCGETA) */
 static void
 request_sigio_on_device (struct device *d)
 {
 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);
 ioctl (filedesc, I_SETSIG, events | S_INPUT);
 }
 return 0;
 }
 /* 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)
 {
 /* Set the primary parameters - baud rate, character size, etcetera.  */
 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
 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;
 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
 #ifdef HAVE_LTCHARS
 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
 if (!TTY_FLAGS (con).flow_control) tcflow (input_fd, TCOON);
 #ifdef HAVE_TTY
 if (DEVICE_TTY_P (d))
 {
 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
 return 1;
 }
 int eight_bit = 0;
 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;
 #else
 eight_bit = 0;	/* I don't know how to do it */
 #if defined (BSD)
 /* Avoid possible loss of output when changing terminal modes.  */
 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)
 ;
 #ifdef SET_LINE_DISCIPLINE
 /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
 /************************************************************************/
 /*                    limits of text/data segments                      */
 /************************************************************************/
-#ifndef CANNOT_DUMP
+#if !defined(CANNOT_DUMP) && !defined(PDUMP)
 #define NEED_STARTS
 #endif
 #ifndef SYSTEM_MALLOC
 #ifndef NEED_STARTS
 *	doing an unexec.  After unexec the return value is undefined.
 *	See crt0.c for further explanation and _start.
 *
 */
+#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)
 {
 #ifdef TEXT_START
 return ((char *) TEXT_START);
 #else /* not GOULD */
 return ((char *) _start);
 #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
 *	doing an unexec.  After unexec the return value is undefined.
 *	See crt0.c for further information and definition of data_start.
 #endif /* ORDINARY_LINK */
 #endif /* DATA_START */
 }
 #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.  */
 /*
 *	Return the address of the end of the text segment prior to
 *	doing an unexec.  After unexec the return value is undefined.
 extern int edata;
 return ((char *) &edata);
 #endif
 }
-#endif /* not CANNOT_DUMP */
+#endif /* !defined(CANNOT_DUMP) && !defined(PDUMP) */
 /************************************************************************/
 /*                          get the system name                         */
 /************************************************************************/
 void
 init_system_name (void)
 {
 #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)
 struct utsname uts;
 uname (&uts);
 Don't do this if we're going to dump; this can confuse system
 libraries on some machines and make the dumped emacs core dump. */
 #  ifndef CANNOT_DUMP
 if (initialized)
 #  endif /* not CANNOT_DUMP */
-{
+if (!strchr (hostname, '.'))
-struct hostent *hp = NULL;
+{
-int count;
+#  if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETNAMEINFO))
-#  ifdef TRY_AGAIN
+	struct hostent *hp = NULL;
-for (count = 0; count < 10; count++)
+	int count;
-	{
+#   ifdef TRY_AGAIN
-	  h_errno = 0;
+	for (count = 0; count < 10; count++)
-#  endif
+	  {
-	  /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
+	    h_errno = 0;
-	  stop_interrupts ();
+#   endif
-	  hp = gethostbyname (hostname);
+	    /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
-	  start_interrupts ();
+	    stop_interrupts ();
-#  ifdef TRY_AGAIN
+	    hp = gethostbyname (hostname);
-	  if (! (hp == 0 && h_errno == TRY_AGAIN))
+	    start_interrupts ();
-	    break;
+#   ifdef TRY_AGAIN
-	  Fsleep_for (make_int (1));
+	    if (! (hp == 0 && h_errno == TRY_AGAIN))
-	}
+	      break;
-#  endif
+	    Fsleep_for (make_int (1));
-if (hp)
+	  }
-	{
+#   endif
-	  CONST char *fqdn = (CONST char *) hp->h_name;
+	if (hp)
+	  {
-	  if (!strchr (fqdn, '.'))
+	    const char *fqdn = (const char *) hp->h_name;
-	    {
-	      /* We still don't have a fully qualified domain name.
+	    if (!strchr (fqdn, '.'))
-		 Try to find one in the list of alternate names */
+	      {
-	      char **alias = hp->h_aliases;
+		/* We still don't have a fully qualified domain name.
-	      while (*alias && !strchr (*alias, '.'))
+		   Try to find one in the list of alternate names */
-		alias++;
+		char **alias = hp->h_aliases;
-	      if (*alias)
+		while (*alias && !strchr (*alias, '.'))
-		fqdn = *alias;
+		  alias++;
-	    }
+		if (*alias)
-	  hostname = (char *) alloca (strlen (fqdn) + 1);
+		  fqdn = *alias;
-	  strcpy (hostname, fqdn);
+	      }
-	}
+	    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  */
 {
 Bufbyte *p;
 #if !defined(NeXT) && !defined(__alpha) && !defined(MACH) && !defined(LINUX) && !defined(IRIX) && !defined(__NetBSD__)
 /* Linux added here by Raymond L. Toy <toy@alydar.crd.ge.com> for XEmacs. */
 /* Irix added here by gparker@sni-usa.com for XEmacs. */
 /* NetBSD added here by James R Grinter <jrg@doc.ic.ac.uk> for XEmacs */
-extern CONST char *sys_errlist[];
+extern const char *sys_errlist[];
 extern int sys_nerr;
 #endif
 #ifdef __NetBSD__
 extern char *sys_errlist[];
 extern int sys_nerr;
 #endif
-CONST char *
+const char *
 strerror (int errnum)
 {
 if (errnum >= 0 && errnum < sys_nerr)
 return sys_errlist[errnum];
-return ((CONST char *) GETTEXT ("Unknown error"));
+return ((const char *) GETTEXT ("Unknown error"));
 }
 #endif /* ! HAVE_STRERROR */
 #ifdef WINDOWSNT
 mswindows_set_errno (unsigned long win32_error)
 {
 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)
 	{
 	  errno = errtable[i].errnocode;
 	  return;
 /************************************************************************/
 /*                    Encapsulations of system calls                    */
 /************************************************************************/
 #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 ****************/
 /*
 *	On USG systems the system calls are INTERRUPTIBLE by signals
 *	always negligible.   Fred Fish, Unisoft Systems Inc.
 */
 /* 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
+interruptible-system-call business.  To find it, look on
-Jamie's home page (http://www.netscape.com/people/jwz). */
+Jamie's home page (http://www.jwz.org/worse-is-better.html). */
 #ifdef ENCAPSULATE_OPEN
 int
-sys_open (CONST char *path, int oflag, ...)
+sys_open (const char *path, int oflag, ...)
 {
 int mode;
 va_list ap;
 va_start (ap, oflag);
 mode = va_arg (ap, int);
 va_end (ap);
-PATHNAME_CONVERT_OUT (path);
+#ifdef WINDOWSNT
-#if defined (WINDOWSNT)
 /* Make all handles non-inheritable */
-return open (path, oflag | _O_NOINHERIT, mode);
+oflag |= _O_NOINHERIT;
-#elif defined (INTERRUPTIBLE_OPEN)
+#endif
+#ifdef INTERRUPTIBLE_OPEN
 {
 int rtnval;
 while ((rtnval = open (path, oflag, mode)) == -1
 	   && (errno == EINTR))
 DO_NOTHING;
 This function will not function as expected on systems where open()
 is not interrupted by C-g.  However, the worst that can happen is
 the fallback to simple open().  */
 int
-interruptible_open (CONST char *path, int oflag, int mode)
+interruptible_open (const char *path, int oflag, int mode)
 {
 /* This function can GC */
 size_t len = strlen (path);
 char *nonreloc = (char *) alloca (len + 1);
 /* Must copy PATH, because it might be the data of a Lisp_String,
 which could be relocated by GC when checking for QUIT.  */
 memcpy (nonreloc, path, len + 1);
 PATHNAME_CONVERT_OUT (nonreloc);
+#ifdef WINDOWSNT
+/* Make all handles non-inheritable */
+oflag |= _O_NOINHERIT;
+#endif
 for (;;)
 {
 int rtnval = open (nonreloc, oflag, mode);
 if (!(rtnval == -1 && errno == EINTR))
 }
 }
 #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;
 /* If close is interrupted SunOS 4.1 may or may not have closed the
 file descriptor.  If it did the second close will fail with
 if (rtnval == -1 && did_retry && errno == EBADF)
 return 0;
 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
 	 && (errno == EINTR))
 {
 }
 return rtnval;
 }
 #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)
+sys_write_1 (int fildes, const void *buf, size_t nbyte, int allow_quit)
 {
-int rtnval;
+ssize_t bytes_written = 0;
-int bytes_written = 0;
+const char *b = (const char *) buf;
-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 (rtnval == -1)
 	{
 	  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)
+sys_write (int fildes, const void *buf, size_t nbyte)
 {
 return sys_write_1 (fildes, buf, nbyte, 0);
 }
 #endif /* ENCAPSULATE_WRITE */
 /* #### Should also encapsulate fflush().
 #### Should conceivably encapsulate getchar() etc.  What a pain! */
 #ifdef ENCAPSULATE_FOPEN
 FILE *
-sys_fopen (CONST char *path, CONST char *type)
+sys_fopen (const char *path, const char *type)
 {
 PATHNAME_CONVERT_OUT (path);
 #if defined (WINDOWSNT)
 {
 int fd;
 #endif /* ENCAPSULATE_FREAD */
 #ifdef ENCAPSULATE_FWRITE
 size_t
-sys_fwrite (CONST void *ptr, size_t size, size_t nitem, FILE *stream)
+sys_fwrite (const void *ptr, size_t size, size_t nitem, FILE *stream)
 {
 #ifdef INTERRUPTIBLE_IO
 size_t rtnval;
 size_t items_written = 0;
-CONST char *b = (CONST char *) ptr;
+const char *b = (const char *) ptr;
 while (nitem > 0)
 {
 rtnval = fwrite (b, size, nitem, stream);
 if (rtnval == 0)
 /********************* directory calls *******************/
 #ifdef ENCAPSULATE_CHDIR
 int
-sys_chdir (CONST char *path)
+sys_chdir (const char *path)
 {
 PATHNAME_CONVERT_OUT (path);
 return chdir (path);
 }
 #endif /* ENCAPSULATE_CHDIR */
 #ifdef ENCAPSULATE_MKDIR
 int
-sys_mkdir (CONST char *path, mode_t mode)
+sys_mkdir (const char *path, mode_t mode)
 {
 PATHNAME_CONVERT_OUT (path);
 #ifdef WINDOWSNT
 return mkdir (path);
 #else
 #endif /* ENCAPSULATE_MKDIR */
 #ifdef ENCAPSULATE_OPENDIR
 DIR *
-sys_opendir (CONST char *filename)
+sys_opendir (const char *filename)
 {
 DIR *rtnval;
 PATHNAME_CONVERT_OUT (filename);
 while (!(rtnval = opendir (filename))
 if (rtnval == NULL)           /* End of directory */
 return NULL;
 {
 Extcount external_len;
 int ascii_filename_p = 1;
-CONST Extbyte * CONST external_name = (CONST Extbyte *) rtnval->d_name;
+const Extbyte * const external_name = (const Extbyte *) rtnval->d_name;
 /* Optimize for the common all-ASCII case, computing len en passant */
 for (external_len = 0; external_name[external_len] ; external_len++)
 {
 if (!BYTE_ASCII_P (external_name[external_len]))
 if (ascii_filename_p)
 return rtnval;
 { /* Non-ASCII filename */
 static Bufbyte_dynarr *internal_DIRENTRY;
-CONST Bufbyte *internal_name;
+const Bufbyte *internal_name;
 Bytecount internal_len;
 if (!internal_DIRENTRY)
 internal_DIRENTRY = Dynarr_new (Bufbyte);
 else
 Dynarr_reset (internal_DIRENTRY);
 Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
 offsetof (DIRENTRY, d_name));
-internal_name =
+TO_INTERNAL_FORMAT (DATA, (external_name, external_len),
-convert_from_external_format (external_name, external_len,
+			  ALLOCA, (internal_name, internal_len),
-&internal_len, FORMAT_FILENAME);
+			  Qfile_name);
 Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
 Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */
 return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0);
 }
 #endif /* ENCAPSULATE_CLOSEDIR */
 #ifdef ENCAPSULATE_RMDIR
 int
-sys_rmdir (CONST char *path)
+sys_rmdir (const char *path)
 {
 PATHNAME_CONVERT_OUT (path);
 return rmdir (path);
 }
 #endif /* ENCAPSULATE_RMDIR */
 /***************** file-information calls ******************/
 #ifdef ENCAPSULATE_ACCESS
 int
-sys_access (CONST char *path, int mode)
+sys_access (const char *path, int mode)
 {
 PATHNAME_CONVERT_OUT (path);
 return access (path, mode);
 }
 #endif /* ENCAPSULATE_ACCESS */
 #ifdef HAVE_EACCESS
 #ifdef ENCAPSULATE_EACCESS
 int
-sys_eaccess (CONST char *path, int mode)
+sys_eaccess (const char *path, int mode)
 {
 PATHNAME_CONVERT_OUT (path);
 return eaccess (path, mode);
 }
 #endif /* ENCAPSULATE_EACCESS */
 #endif /* HAVE_EACCESS */
 #ifdef ENCAPSULATE_LSTAT
 int
-sys_lstat (CONST char *path, struct stat *buf)
+sys_lstat (const char *path, struct stat *buf)
 {
 PATHNAME_CONVERT_OUT (path);
 return lstat (path, buf);
 }
 #endif /* ENCAPSULATE_LSTAT */
 #ifdef ENCAPSULATE_READLINK
 int
-sys_readlink (CONST char *path, char *buf, size_t bufsiz)
+sys_readlink (const char *path, char *buf, size_t bufsiz)
 {
 PATHNAME_CONVERT_OUT (path);
 /* #### currently we don't do conversions on the incoming data */
 return readlink (path, buf, bufsiz);
 }
 #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)
+sys_stat (const char *path, struct stat *buf)
 {
 PATHNAME_CONVERT_OUT (path);
 return stat (path, buf);
 }
 #endif /* ENCAPSULATE_STAT */
 /****************** file-manipulation calls *****************/
 #ifdef ENCAPSULATE_CHMOD
 int
-sys_chmod (CONST char *path, mode_t mode)
+sys_chmod (const char *path, mode_t mode)
 {
 PATHNAME_CONVERT_OUT (path);
 return chmod (path, mode);
 }
 #endif /* ENCAPSULATE_CHMOD */
 #ifdef ENCAPSULATE_CREAT
 int
-sys_creat (CONST char *path, mode_t mode)
+sys_creat (const char *path, mode_t mode)
 {
 PATHNAME_CONVERT_OUT (path);
 return creat (path, mode);
 }
 #endif /* ENCAPSULATE_CREAT */
 #ifdef ENCAPSULATE_LINK
 int
-sys_link (CONST char *existing, CONST char *new)
+sys_link (const char *existing, const char *new)
 {
 PATHNAME_CONVERT_OUT (existing);
 PATHNAME_CONVERT_OUT (new);
 return link (existing, new);
 }
 #endif /* ENCAPSULATE_LINK */
 #ifdef ENCAPSULATE_RENAME
 int
-sys_rename (CONST char *old, CONST char *new)
+sys_rename (const char *old, const char *new)
 {
 PATHNAME_CONVERT_OUT (old);
 PATHNAME_CONVERT_OUT (new);
 #ifdef WINDOWSNT
 /* Windows rename fails if NEW exists */
 #endif /* ENCAPSULATE_RENAME */
 #ifdef ENCAPSULATE_SYMLINK
 int
-sys_symlink (CONST char *name1, CONST char *name2)
+sys_symlink (const char *name1, const char *name2)
 {
 PATHNAME_CONVERT_OUT (name1);
 PATHNAME_CONVERT_OUT (name2);
 return symlink (name1, name2);
 }
 #endif /* ENCAPSULATE_SYMLINK */
 #ifdef ENCAPSULATE_UNLINK
 int
-sys_unlink (CONST char *path)
+sys_unlink (const char *path)
 {
 PATHNAME_CONVERT_OUT (path);
 return unlink (path);
 }
 #endif /* ENCAPSULATE_UNLINK */
 #ifdef ENCAPSULATE_EXECVP
 int
-sys_execvp (CONST char *path, char * CONST * argv)
+sys_execvp (const char *path, char * const * argv)
 {
 int i, argc;
 char ** new_argv;
 PATHNAME_CONVERT_OUT (path);
 /***** (these are primarily required for USG, it seems) *****/
 #ifndef HAVE_GETCWD
 char *
-getcwd (char *pathname, int size)
+getcwd (char *pathname, size_t size)
 {
 return getwd (pathname);
 }
 #endif /* emulate getcwd */
 *	that files be of same type (regular->regular, dir->dir, etc).
 */
 #ifndef HAVE_RENAME
 int
-rename (CONST char *from, CONST char *to)
+rename (const char *from, const char *to)
 {
 if (access (from, 0) == 0)
 {
 unlink (to);
 if (link (from, to) == 0)
 /************************************************************************/
 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
-CONST char *sys_siglist[] =
+const char *sys_siglist[] =
 {
 "bum signal!!",
 "hangup",
 "interrupt",
 "quit",
 };
 #endif
 #ifdef USG
 #ifdef AIX
-CONST char *sys_siglist[NSIG + 1] =
+const char *sys_siglist[NSIG + 1] =
 {
 /* AIX has changed the signals a bit */
 DEFER_GETTEXT ("bogus signal"),			/* 0 */
 DEFER_GETTEXT ("hangup"),				/* 1  SIGHUP */
 DEFER_GETTEXT ("interrupt"),			/* 2  SIGINT */
 DEFER_GETTEXT ("HFT input ready"),			/* 31 SIGMSG */
 #endif
 0
 };
 #else /* USG, not AIX */
-CONST char *sys_siglist[NSIG + 1] =
+const char *sys_siglist[NSIG + 1] =
 {
 DEFER_GETTEXT ("bogus signal"),			/* 0 */
 DEFER_GETTEXT ("hangup"),				/* 1  SIGHUP */
 DEFER_GETTEXT ("interrupt"),			/* 2  SIGINT */
 DEFER_GETTEXT ("quit"),				/* 3  SIGQUIT */
 0
 };
 #endif /* not AIX */
 #endif /* USG */
 #ifdef DGUX
-CONST char *sys_siglist[NSIG + 1] =
+const char *sys_siglist[NSIG + 1] =
 {
 DEFER_GETTEXT ("null signal"),			 /*  0 SIGNULL   */
 DEFER_GETTEXT ("hangup"),				 /*  1 SIGHUP    */
 DEFER_GETTEXT ("interrupt"),	       		 /*  2 SIGINT    */
 DEFER_GETTEXT ("quit"),				 /*  3 SIGQUIT   */
 #endif /* SYSV_SYSTEM_DIR */
 #ifdef NONSYSTEM_DIR_LIBRARY
 DIR *
-opendir (CONST char *filename)	/* name of directory */
+opendir (const char *filename)	/* name of directory */
 {
 DIR *dirp;		/* -> malloc'ed storage */
 int fd;		/* file descriptor for read */
 struct stat sbuf;		/* result of fstat */
 */
 #ifdef MKDIR_PROTOTYPE
 MKDIR_PROTOTYPE
 #else
 int
-mkdir (CONST char *dpath, int dmode)
+mkdir (const char *dpath, int dmode)
 #endif
 {
 int cpid, status, fd;
 struct stat statbuf;
 }
 #endif /* not HAVE_MKDIR */
 #ifndef HAVE_RMDIR
 int
-rmdir (CONST char *dpath)
+rmdir (const char *dpath)
 {
 int cpid, status, fd;
 struct stat statbuf;
 if (stat (dpath, &statbuf) != 0)

Mercurial > hg > xemacs-beta

comparison src/sysdep.c @ 398:74fd4e045ea6 r21-2-29