X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=blobdiff_plain;f=src%2Fsysdep.c;h=54059496cc1d19d4b0ee8adbeb2c0d0f0702fc90;hp=9755327ddf15e606035fe53eb7f3839b50dd78c5;hb=14ac73276fa152e8f0b74602792afc0b9c3236c9;hpb=77dcef404dc78635f6ffa8f71a803d2bc7cc8921 diff --git a/src/sysdep.c b/src/sysdep.c index 9755327..5405949 100644 --- a/src/sysdep.c +++ b/src/sysdep.c @@ -30,25 +30,8 @@ Boston, MA 02111-1307, USA. */ #define DONT_ENCAPSULATE #include - -#ifdef WINDOWSNT -#include -/* 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. - - 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 /* WINDOWSNT */ - #include "lisp.h" -#include -#include - /* ------------------------------- */ /* basic includes */ /* ------------------------------- */ @@ -78,19 +61,35 @@ Boston, MA 02111-1307, USA. */ #include "syswait.h" #include "sysdir.h" #include "systime.h" -#if defined(WINDOWSNT) || defined(__CYGWIN32__) +#if defined(WIN32_NATIVE) || defined(CYGWIN) #include "syssignal.h" #endif -#ifndef WINDOWSNT + +#include "sysproc.h" + +#ifndef WIN32_NATIVE #include #endif -#ifdef WINDOWSNT +#ifdef WIN32_NATIVE #include -#include #include "ntheap.h" +#include "nt.h" #endif +#ifdef WIN32_NATIVE +#ifdef MINGW +#include <../mingw/process.h> +#else +/* should not conflict with "process.h", as per ANSI definition. + 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. +*/ +#include <../include/process.h> +#endif /* MINGW */ +#endif /* WIN32_NATIVE */ + /* ------------------------------- */ /* TTY definitions */ /* ------------------------------- */ @@ -108,10 +107,6 @@ Boston, MA 02111-1307, USA. */ #endif /* TIOCGWINSZ or ISC4_0 */ #endif /* USG */ -#ifdef HAVE_SYS_STROPTS_H -#include -#endif /* HAVE_SYS_STROPTS_H */ - /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */ #ifndef LPASS8 #define LPASS8 0 @@ -141,22 +136,6 @@ static void hft_reset (struct console *c); #include #endif -/* ------------------------------- */ -/* miscellaneous */ -/* ------------------------------- */ - -#ifndef HAVE_UTIMES -#ifndef HAVE_STRUCT_UTIMBUF -/* We want to use utime rather than utimes, but we couldn't find the - structure declaration. We'll use the traditional one. */ -struct utimbuf -{ - long actime; - long modtime; -}; -#endif -#endif - /************************************************************************/ /* subprocess control */ @@ -212,7 +191,9 @@ set_descriptor_non_blocking (int fd) } #endif +#ifdef F_SETFL fcntl (fd, F_SETFL, O_NONBLOCK); +#endif } #if defined (NO_SUBPROCESSES) @@ -229,8 +210,11 @@ wait_without_blocking (void) #endif /* NO_SUBPROCESSES */ -void -wait_for_termination (int pid) +#ifdef WIN32_NATIVE +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 @@ -340,6 +324,49 @@ wait_for_termination (int pid) Since implementations may add their own error indicators on top, we ignore it by default. */ +#elif defined (WIN32_NATIVE) + 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) { @@ -371,7 +398,7 @@ wait_for_termination (int pid) 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 WIN32_NATIVE 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) @@ -409,7 +436,7 @@ flush_pending_output (int channel) #endif } -#ifndef WINDOWSNT +#ifndef WIN32_NATIVE /* Set up the terminal at the other end of a pseudo-terminal that we will be controlling an inferior through. It should not echo or do line-editing, since that is done @@ -419,7 +446,7 @@ 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)); @@ -488,7 +515,7 @@ child_setup_tty (int out) #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */ s.main.c_cc[VEOL] = _POSIX_VDISABLE; #if defined (CBAUD) - /* ### This is not portable. ### + /* #### 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 @@ -511,7 +538,7 @@ child_setup_tty (int out) 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 { @@ -520,7 +547,7 @@ child_setup_tty (int out) } #endif /* RTU */ } -#endif /* WINDOWSNT */ +#endif /* WIN32_NATIVE */ #endif /* not NO_SUBPROCESSES */ @@ -561,19 +588,23 @@ restore_signal_handlers (struct save_signal *saved_handlers) } } -#ifdef WINDOWSNT -int +#ifdef WIN32_NATIVE + +pid_t sys_getpid (void) { return abs (getpid ()); } -#endif /* WINDOWSNT */ + +#endif /* WIN32_NATIVE */ /* Fork a subshell. */ static void sys_subshell (void) { +#ifndef WIN32_NATIVE int pid; +#endif struct save_signal saved_handlers[5]; Lisp_Object dir; unsigned char *str = 0; @@ -606,22 +637,18 @@ sys_subshell (void) str = (unsigned char *) alloca (XSTRING_LENGTH (dir) + 2); len = XSTRING_LENGTH (dir); memcpy (str, XSTRING_DATA (dir), len); - /* #### Unix specific */ - if (str[len - 1] != '/') str[len++] = '/'; + if (!IS_ANY_SEP (str[len - 1])) + str[len++] = DIRECTORY_SEP; str[len] = 0; xyzzy: -#ifdef WINDOWSNT - pid = -1; -#else /* not WINDOWSNT */ - +#ifndef WIN32_NATIVE pid = fork (); if (pid == -1) error ("Can't spawn subshell"); if (pid == 0) - -#endif /* not WINDOWSNT */ +#endif /* not WIN32_NATIVE */ { char *sh = 0; @@ -634,7 +661,18 @@ sys_subshell (void) if (str) sys_chdir (str); -#if !defined (NO_SUBPROCESSES) && !defined (WINDOWSNT) +#ifdef WIN32_NATIVE + + /* Waits for process completion */ + if (_spawnlp (_P_WAIT, sh, sh, NULL) != 0) + error ("Can't spawn subshell"); + else + return; /* we're done, no need to wait for termination */ + } + +#else + +#if !defined (NO_SUBPROCESSES) close_process_descs (); /* Close Emacs's pipes/ptys */ #endif @@ -643,23 +681,18 @@ sys_subshell (void) nice (-emacs_priority); /* Give the new shell the default priority */ #endif -#ifdef WINDOWSNT - /* Waits for process completion */ - pid = _spawnlp (_P_WAIT, sh, sh, NULL); - if (pid == -1) - write (1, "Can't execute subshell", 22); - -#else /* not WINDOWSNT */ execlp (sh, sh, 0); write (1, "Can't execute subshell", 22); _exit (1); -#endif /* not WINDOWSNT */ } save_signal_handlers (saved_handlers); synch_process_alive = 1; wait_for_termination (pid); restore_signal_handlers (saved_handlers); + +#endif /* not WIN32_NATIVE */ + } #endif /* !defined (SIGTSTP) && !defined (USG_JOBCTRL) */ @@ -706,23 +739,36 @@ sys_suspend_process (int process) /* Given FD, obtain pty buffer size. When no luck, a good guess is made, - so that the function works even fd is not a pty. */ + so that the function works even when fd is not a pty. */ int get_pty_max_bytes (int fd) { - int pty_max_bytes; - + /* DEC OSF 4.0 fpathconf returns 255, but xemacs hangs on long shell + input lines if we return 253. 252 is OK!. So let's leave a bit + of slack for the newline that xemacs will insert, and for those + inevitable vendor off-by-one-or-two-or-three bugs. */ +#define MAX_CANON_SLACK 10 +#define SAFE_MAX_CANON (127 - MAX_CANON_SLACK) #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON) - pty_max_bytes = fpathconf (fd, _PC_MAX_CANON); - if (pty_max_bytes < 0) + { + int max_canon = fpathconf (fd, _PC_MAX_CANON); +#ifdef __hpux__ + /* HP-UX 10.20 fpathconf returns 768, but this results in + truncated input lines, while 255 works. */ + if (max_canon > 255) max_canon = 255; +#endif + return (max_canon < 0 ? SAFE_MAX_CANON : + max_canon > SAFE_MAX_CANON ? max_canon - MAX_CANON_SLACK : + max_canon); + } +#elif defined (_POSIX_MAX_CANON) + return (_POSIX_MAX_CANON > SAFE_MAX_CANON ? + _POSIX_MAX_CANON - MAX_CANON_SLACK : + _POSIX_MAX_CANON); +#else + return SAFE_MAX_CANON; #endif - pty_max_bytes = 250; - - /* Deduct one, to leave space for the eof. */ - pty_max_bytes--; - - return pty_max_bytes; } /* Figure out the eof character for the FD. */ @@ -730,7 +776,7 @@ get_pty_max_bytes (int 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; @@ -740,7 +786,7 @@ get_eof_char (int fd) 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]; @@ -763,7 +809,7 @@ get_eof_char (int fd) { 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]; @@ -818,7 +864,7 @@ set_window_size (int fd, int height, int width) void setup_pty (int fd) { - /* I'm told that TOICREMOTE does not mean control chars + /* I'm told that TIOCREMOTE does not mean control chars "can't be sent" but rather that they don't have input-editing or signaling effects. That should be good, because we have other ways @@ -897,7 +943,7 @@ init_baud_rate (struct device *d) assert (DEVICE_TTY_P (d)); { int input_fd = CONSOLE_TTY_DATA (con)->infd; -#if defined (WINDOWSNT) +#if defined (WIN32_NATIVE) DEVICE_TTY_DATA (d)->ospeed = 15; #elif defined (HAVE_TERMIOS) struct termios sg; @@ -925,7 +971,7 @@ init_baud_rate (struct device *d) sg.sg_ospeed = B9600; if (ioctl (input_fd, TIOCGETP, &sg) < 0) - abort (); + ABORT (); DEVICE_TTY_DATA (d)->ospeed = sg.sg_ospeed; #endif } @@ -1013,7 +1059,7 @@ 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); @@ -1162,8 +1208,8 @@ unrequest_sigio (void) #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP -static int inherited_pgroup; -static int inherited_tty_pgroup; +static pid_t inherited_pgroup; +static pid_t inherited_tty_pgroup; #endif @@ -1181,7 +1227,7 @@ munge_tty_process_group (void) CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal))) { int fd = open ("/dev/tty", O_RDWR, 0); - int me = getpid (); + pid_t me = getpid (); EMACS_BLOCK_SIGNAL (SIGTTOU); EMACS_SET_TTY_PROCESS_GROUP (fd, &me); EMACS_UNBLOCK_SIGNAL (SIGTTOU); @@ -1323,7 +1369,7 @@ disconnect_controlling_terminal (void) /* It's wrong to encase these into #ifdef HAVE_TTY because we need them for child TTY processes. */ /* However, this does break NT support while we don't do child TTY processes */ -#ifndef WINDOWSNT +#ifndef WIN32_NATIVE /* Set *TC to the parameters associated with the terminal FD. Return zero if all's well, or -1 if we ran into an error we @@ -1342,7 +1388,7 @@ emacs_get_tty (int fd, struct emacs_tty *settings) if (ioctl (fd, TCGETA, &settings->main) < 0) return -1; -#elif !defined (WINDOWSNT) +#elif !defined (WIN32_NATIVE) /* I give up - I hope you have the BSD ioctls. */ if (ioctl (fd, TIOCGETP, &settings->main) < 0) return -1; @@ -1367,7 +1413,8 @@ emacs_get_tty (int fd, struct emacs_tty *settings) /* 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) @@ -1415,7 +1462,7 @@ emacs_set_tty (int fd, struct emacs_tty *settings, int flushp) if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0) return -1; -#elif !defined (WINDOWSNT) +#elif !defined (WIN32_NATIVE) /* I give up - I hope you have the BSD ioctls. */ if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0) return -1; @@ -1438,7 +1485,7 @@ emacs_set_tty (int fd, struct emacs_tty *settings, int flushp) return 0; } -#endif /* WINDOWSNT */ +#endif /* WIN32_NATIVE */ /* ------------------------------------------------------ */ /* Initializing a device */ @@ -1477,7 +1524,7 @@ tty_init_sys_modes_on_device (struct device *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; @@ -1598,14 +1645,14 @@ tty_init_sys_modes_on_device (struct device *d) tty.main.c_iflag &= ~BRKINT; #endif /* AIX */ #else /* if not HAVE_TERMIO */ -#if !defined (WINDOWSNT) +#if !defined (WIN32_NATIVE) con->tty_erase_char = make_char (tty.main.sg_erase); tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS); if (TTY_FLAGS (con).meta_key) tty.main.sg_flags |= ANYP; /* #### should we be using RAW mode here? */ tty.main.sg_flags |= /* interrupt_input ? RAW : */ CBREAK; -#endif /* not WINDOWSNT */ +#endif /* not WIN32_NATIVE */ #endif /* not HAVE_TERMIO */ /* If going to use CBREAK mode, we must request C-g to interrupt @@ -1644,7 +1691,7 @@ tty_init_sys_modes_on_device (struct device *d) 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. */ @@ -1652,11 +1699,9 @@ tty_init_sys_modes_on_device (struct device *d) #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 @@ -1751,7 +1796,7 @@ tabs_safe_p (struct device *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 @@ -1824,7 +1869,7 @@ eight_bit_tty (struct device *d) 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; @@ -1874,7 +1919,7 @@ tty_reset_sys_modes_on_device (struct device *d) 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) ; @@ -1902,7 +1947,7 @@ reset_one_device (struct device *d) 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)) { @@ -2068,7 +2113,7 @@ hft_reset (struct console *con) /* limits of text/data segments */ /************************************************************************/ -#ifndef CANNOT_DUMP +#if !defined(CANNOT_DUMP) && !defined(PDUMP) #define NEED_STARTS #endif @@ -2088,33 +2133,25 @@ hft_reset (struct console *con) * */ -#ifdef __cplusplus - extern "C" int _start (); -#else - extern int _start (); -#endif +#if !defined(HAVE_TEXT_START) && !defined(PDUMP) + +EXTERN_C int _start (void); -#ifndef HAVE_TEXT_START char * start_of_text (void) { #ifdef TEXT_START - return ((char *) TEXT_START); + return (char *) TEXT_START; #else -#ifdef GOULD - extern csrt (); - return ((char *) csrt); -#else /* not GOULD */ - return ((char *) _start); -#endif /* GOULD */ + return (char *) _start; #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. + * See ecrt0.c for further information and definition of data_start. * * Apparently, on BSD systems this is etext at startup. On * USG systems (swapping) this is highly mmu dependent and @@ -2137,7 +2174,7 @@ start_of_text (void) * */ -#ifdef ORDINARY_LINK +#if defined(ORDINARY_LINK) && !defined(MINGW) extern char **environ; #endif @@ -2147,14 +2184,14 @@ start_of_data (void) #ifdef DATA_START return ((char *) DATA_START); #else -#ifdef ORDINARY_LINK +#if defined (ORDINARY_LINK) || defined(PDUMP) /* * This is a hack. Since we're not linking crt0.c or pre_crt0.c, * data_start isn't defined. We take the address of environ, which * is known to live at or near the start of the system crt0.c, and * we don't sweat the handful of bytes that might lose. */ -#ifdef HEAP_IN_DATA +#if defined (HEAP_IN_DATA) && !defined(PDUMP) extern char* static_heap_base; if (!initialized) return static_heap_base; @@ -2168,7 +2205,7 @@ start_of_data (void) } #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. */ /* @@ -2203,7 +2240,7 @@ end_of_data (void) #endif } -#endif /* not CANNOT_DUMP */ +#endif /* !defined(CANNOT_DUMP) && !defined(PDUMP) */ /************************************************************************/ @@ -2215,17 +2252,12 @@ end_of_data (void) extern Lisp_Object Vsystem_name; -#ifdef HAVE_SOCKETS -# include -# include -#endif /* HAVE_SOCKETS */ - void init_system_name (void) { -#if defined (WINDOWSNT) +#if defined (WIN32_NATIVE) 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) @@ -2259,42 +2291,64 @@ init_system_name (void) # 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; +#ifdef IPV6_CANONICALIZE + hints.ai_family = AF_UNSPEC; +#else + hints.ai_family = PF_INET; +#endif + 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 */ @@ -2423,7 +2477,7 @@ sys_do_signal (int signal_number, signal_handler_t action) /* Linux added here by Raymond L. Toy for XEmacs. */ /* Irix added here by gparker@sni-usa.com for XEmacs. */ /* NetBSD added here by James R Grinter for XEmacs */ -extern CONST char *sys_errlist[]; +extern const char *sys_errlist[]; extern int sys_nerr; #endif @@ -2433,17 +2487,17 @@ 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 +#ifdef WIN32_NATIVE struct errentry { unsigned long oscode; /* Win32 error */ @@ -2514,7 +2568,7 @@ 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) { @@ -2540,7 +2594,7 @@ mswindows_set_last_errno (void) mswindows_set_errno (GetLastError ()); } -#endif /* WINDOWSNT */ +#endif /* WIN32_NATIVE */ /************************************************************************/ @@ -2548,7 +2602,7 @@ mswindows_set_last_errno (void) /************************************************************************/ #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 ****************/ @@ -2567,12 +2621,12 @@ mswindows_set_last_errno (void) /* 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 -sys_open (CONST char *path, int oflag, ...) +sys_open (const char *path, int oflag, ...) { int mode; va_list ap; @@ -2582,10 +2636,13 @@ sys_open (CONST char *path, int oflag, ...) va_end (ap); PATHNAME_CONVERT_OUT (path); -#if defined (WINDOWSNT) + +#ifdef WIN32_NATIVE /* 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 @@ -2608,7 +2665,7 @@ sys_open (CONST char *path, int oflag, ...) 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); @@ -2620,6 +2677,11 @@ interruptible_open (CONST char *path, int oflag, int mode) PATHNAME_CONVERT_OUT (nonreloc); +#ifdef WIN32_NATIVE + /* Make all handles non-inheritable */ + oflag |= _O_NOINHERIT; +#endif + for (;;) { int rtnval = open (nonreloc, oflag, mode); @@ -2632,13 +2694,13 @@ interruptible_open (CONST char *path, int oflag, int 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; @@ -2650,15 +2712,15 @@ sys_close (int fd) 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 @@ -2671,24 +2733,23 @@ sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit) } #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 -sys_write_1 (int fildes, CONST void *buf, size_t nbyte, int allow_quit) +ssize_t +sys_write_1 (int fildes, const void *buf, size_t nbyte, int allow_quit) { - int rtnval; - int bytes_written = 0; - CONST char *b = (CONST char *) buf; + 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; @@ -2698,18 +2759,18 @@ sys_write_1 (int fildes, CONST void *buf, size_t nbyte, int allow_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 -sys_write (int fildes, CONST void *buf, size_t nbyte) +ssize_t +sys_write (int fildes, const void *buf, size_t nbyte) { return sys_write_1 (fildes, buf, nbyte, 0); } @@ -2727,10 +2788,10 @@ sys_write (int fildes, CONST void *buf, size_t nbyte) #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) +#if defined (WIN32_NATIVE) { int fd; int oflag; @@ -2837,12 +2898,12 @@ sys_fread (void *ptr, size_t size, size_t nitem, FILE *stream) #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) { @@ -2870,7 +2931,7 @@ sys_fwrite (CONST void *ptr, size_t size, size_t nitem, FILE *stream) #ifdef ENCAPSULATE_CHDIR int -sys_chdir (CONST char *path) +sys_chdir (const char *path) { PATHNAME_CONVERT_OUT (path); return chdir (path); @@ -2880,10 +2941,10 @@ sys_chdir (CONST char *path) #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 +#ifdef WIN32_NATIVE return mkdir (path); #else return mkdir (path, mode); @@ -2894,7 +2955,7 @@ sys_mkdir (CONST char *path, mode_t mode) #ifdef ENCAPSULATE_OPENDIR DIR * -sys_opendir (CONST char *filename) +sys_opendir (const char *filename) { DIR *rtnval; PATHNAME_CONVERT_OUT (filename); @@ -2924,23 +2985,22 @@ sys_readdir (DIR *dirp) 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; - - /* 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])) - ascii_filename_p = 0; - } - if (ascii_filename_p) + const Extbyte * const external_name = (const Extbyte *) rtnval->d_name; + Extcount external_len = strlen (rtnval->d_name); + const Bufbyte *internal_name; + Bytecount internal_len; + + TO_INTERNAL_FORMAT (DATA, (external_name, external_len), + ALLOCA, (internal_name, internal_len), + Qfile_name); + + /* check for common case of ASCII filename */ + if (internal_len == external_len && + !memcmp (external_name, internal_name, internal_len)) return rtnval; { /* Non-ASCII filename */ static Bufbyte_dynarr *internal_DIRENTRY; - CONST Bufbyte *internal_name; - Bytecount internal_len; if (!internal_DIRENTRY) internal_DIRENTRY = Dynarr_new (Bufbyte); else @@ -2949,12 +3009,9 @@ sys_readdir (DIR *dirp) 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); Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len); - Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */ + Dynarr_add (internal_DIRENTRY, '\0'); /* NUL-terminate */ return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0); } } @@ -2979,7 +3036,7 @@ sys_closedir (DIR *dirp) #ifdef ENCAPSULATE_RMDIR int -sys_rmdir (CONST char *path) +sys_rmdir (const char *path) { PATHNAME_CONVERT_OUT (path); return rmdir (path); @@ -2991,7 +3048,7 @@ sys_rmdir (CONST char *path) #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); @@ -3002,7 +3059,7 @@ sys_access (CONST char *path, int mode) #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); @@ -3013,7 +3070,7 @@ sys_eaccess (CONST char *path, int mode) #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); @@ -3023,7 +3080,7 @@ sys_lstat (CONST char *path, struct stat *buf) #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 */ @@ -3031,22 +3088,34 @@ sys_readlink (CONST char *path, char *buf, size_t bufsiz) } #endif /* ENCAPSULATE_READLINK */ +#ifdef ENCAPSULATE_FSTAT +int +sys_fstat (int fd, struct stat *buf) +{ +#ifdef WIN32_NATIVE + return mswindows_fstat (fd, buf); +#else + return fstat (fd, buf); +#endif +} +#endif /* ENCAPSULATE_FSTAT */ -#ifdef ENCAPSULATE_STAT int -sys_stat (CONST char *path, struct stat *buf) +xemacs_stat (const char *path, struct stat *buf) { PATHNAME_CONVERT_OUT (path); +#ifdef WIN32_NATIVE + return mswindows_stat (path, buf); +#else return stat (path, buf); +#endif } -#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); @@ -3056,7 +3125,7 @@ sys_chmod (CONST char *path, mode_t mode) #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); @@ -3066,7 +3135,7 @@ sys_creat (CONST char *path, mode_t mode) #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); @@ -3077,18 +3146,20 @@ sys_link (CONST char *existing, CONST char *new) #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 +#ifdef WIN32_NATIVE /* Windows rename fails if NEW exists */ if (rename (old, new) == 0) return 0; - if (errno != EEXIST) + /* In some cases errno is EACCES if NEW exists */ + if (errno != EEXIST && errno != EACCES) + return -1; + if (unlink (new) != 0) return -1; - unlink (new); -#endif /* WINDOWSNT */ +#endif /* WIN32_NATIVE */ return rename (old, new); } #endif /* ENCAPSULATE_RENAME */ @@ -3096,7 +3167,7 @@ sys_rename (CONST char *old, CONST char *new) #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); @@ -3107,7 +3178,7 @@ sys_symlink (CONST char *name1, CONST char *name2) #ifdef ENCAPSULATE_UNLINK int -sys_unlink (CONST char *path) +sys_unlink (const char *path) { PATHNAME_CONVERT_OUT (path); return unlink (path); @@ -3117,7 +3188,7 @@ sys_unlink (CONST char *path) #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; @@ -3145,7 +3216,7 @@ sys_execvp (CONST char *path, char * CONST * argv) #ifndef HAVE_GETCWD char * -getcwd (char *pathname, int size) +getcwd (char *pathname, size_t size) { return getwd (pathname); } @@ -3189,7 +3260,7 @@ getwd (char *pathname) #ifndef HAVE_RENAME int -rename (CONST char *from, CONST char *to) +rename (const char *from, const char *to) { if (access (from, 0) == 0) { @@ -3273,19 +3344,31 @@ gettimeofday (struct timeval *tp, struct timezone *tzp) access to those functions goes through the following. */ int -set_file_times (char *filename, EMACS_TIME atime, EMACS_TIME mtime) +set_file_times (Lisp_Object path, EMACS_TIME atime, EMACS_TIME mtime) { -#ifdef HAVE_UTIMES - struct timeval tv[2]; - tv[0] = atime; - tv[1] = mtime; - return utimes (filename, tv); -#else /* not HAVE_UTIMES */ +#if defined (WIN32_NATIVE) + struct utimbuf utb; + utb.actime = EMACS_SECS (atime); + utb.modtime = EMACS_SECS (mtime); + return mswindows_utime (path, &utb); +#elif defined (HAVE_UTIME) struct utimbuf utb; + Extbyte *filename; utb.actime = EMACS_SECS (atime); utb.modtime = EMACS_SECS (mtime); + LISP_STRING_TO_EXTERNAL (path, filename, Qfile_name); return utime (filename, &utb); -#endif /* not HAVE_UTIMES */ +#elif defined (HAVE_UTIMES) + struct timeval tv[2]; + Extbyte *filename; + tv[0] = atime; + tv[1] = mtime; + LISP_STRING_TO_EXTERNAL (path, filename, Qfile_name); + return utimes (filename, tv); +#else + /* No file times setting function available. */ + return -1; +#endif } /* */ @@ -3303,7 +3386,7 @@ static int process_times_available; static int get_process_times_1 (long *user_ticks, long *system_ticks) { -#if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WINDOWSNT) +#if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WIN32_NATIVE) /* We have the POSIX times() function available. */ struct tms tttt; times (&tttt); @@ -3423,19 +3506,19 @@ long get_random (void) { long val = random (); -#if VALBITS > RAND_BITS +#if INT_VALBITS > RAND_BITS val = (val << RAND_BITS) ^ random (); -#if VALBITS > 2*RAND_BITS +#if INT_VALBITS > 2*RAND_BITS val = (val << RAND_BITS) ^ random (); -#if VALBITS > 3*RAND_BITS +#if INT_VALBITS > 3*RAND_BITS val = (val << RAND_BITS) ^ random (); -#if VALBITS > 4*RAND_BITS +#if INT_VALBITS > 4*RAND_BITS val = (val << RAND_BITS) ^ random (); #endif /* need at least 5 */ #endif /* need at least 4 */ #endif /* need at least 3 */ #endif /* need at least 2 */ - return val & ((1L << VALBITS) - 1); + return val & (EMACS_INT) ((1UL << INT_VALBITS) - 1); } @@ -3445,8 +3528,8 @@ get_random (void) #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST) -#if defined(WINDOWSNT) || defined(__CYGWIN32__) -CONST char *sys_siglist[] = +#if defined(WIN32_NATIVE) || defined(CYGWIN) +const char *sys_siglist[] = { "bum signal!!", "hangup", @@ -3479,7 +3562,7 @@ CONST char *sys_siglist[] = #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 */ @@ -3497,7 +3580,7 @@ CONST char *sys_siglist[NSIG + 1] = DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */ DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */ DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */ - DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */ + DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */ DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */ DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */ DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */ @@ -3519,7 +3602,7 @@ CONST char *sys_siglist[NSIG + 1] = 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 */ @@ -3536,7 +3619,7 @@ CONST char *sys_siglist[NSIG + 1] = DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */ DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */ DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */ - DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */ + DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */ DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */ DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */ DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */ @@ -3568,7 +3651,7 @@ CONST char *sys_siglist[NSIG + 1] = #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 */ @@ -3673,7 +3756,7 @@ closedir (DIR *dirp) /* stream from opendir */ #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 */ @@ -3775,13 +3858,13 @@ readdir (DIR *dirp) /* stream from opendir */ MKDIR_PROTOTYPE #else int -mkdir (CONST char *dpath, int dmode) +mkdir (const char *dpath, int dmode) #endif { int cpid, status, fd; struct stat statbuf; - if (stat (dpath, &statbuf) == 0) + if (stat (dpath, &statbuf) == 0) /* we do want stat() here */ { errno = EEXIST; /* Stat worked, so it already exists */ return -1; @@ -3835,12 +3918,12 @@ mkdir (CONST char *dpath, int dmode) #ifndef HAVE_RMDIR int -rmdir (CONST char *dpath) +rmdir (const char *dpath) { int cpid, status, fd; struct stat statbuf; - if (stat (dpath, &statbuf) != 0) + if (stat (dpath, &statbuf) != 0) /* we do want stat() here */ { /* Stat just set errno. We don't have to */ return -1; @@ -3909,59 +3992,3 @@ dlclose (void) } #endif /* USE_DL_STUBS */ - - - -#ifndef HAVE_STRCASECMP -/* - * From BSD - */ -static unsigned char charmap[] = { - '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', - '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', - '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', - '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', - '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', - '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', - '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', - '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', - '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', - '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', - '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', - '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', - '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', - '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', - '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', - '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', - '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', - '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', - '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', - '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', - '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', - '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', - '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', - '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', - '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307', - '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317', - '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327', - '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337', - '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', - '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', - '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', - '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', -}; - -int -strcasecmp (char *s1, char *s2) -{ - unsigned char *cm = charmap; - unsigned char *us1 = (unsigned char *) s1; - unsigned char *us2 = (unsigned char *)s2; - - while (cm[*us1] == cm[*us2++]) - if (*us1++ == '\0') - return (0); - - return (cm[*us1] - cm[*--us2]); -} -#endif /* !HAVE_STRCASECMP */