1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985-1988, 1992-1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Tinker Systems.
5 This file is part of XEmacs.
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Synched up with: FSF 19.30 except for some Windows-NT crap. */
24 /* Substantially cleaned up by Ben Wing, Dec. 1994 / Jan. 1995. */
26 /* In this file, open, read and write refer to the system calls,
27 not our sugared interfaces sys_open, sys_read and sys_write.
30 #define DONT_ENCAPSULATE
37 #include <mingw32/process.h>
39 /* <process.h> should not conflict with "process.h", as per ANSI definition.
40 This is not true with visual c though. The trick below works with
41 VC4.2b, 5.0 and 6.0. It assumes that VC is installed in a kind of
42 standard way, so include path ends with /include.
44 Unfortunately, this must go before lisp.h, since process.h defines abort()
45 which will conflict with the macro defined in lisp.h
47 #include <../include/process.h>
48 #endif /* __MINGW32__ */
49 #endif /* WINDOWSNT */
55 /* ------------------------------- */
57 /* ------------------------------- */
60 #include "console-tty.h"
62 #include "syssignal.h"
66 #include "console-stream.h"
71 #include "redisplay.h"
77 #ifdef HAVE_LIBGEN_H /* Must come before sysfile.h */
84 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
85 #include "syssignal.h"
88 #include <sys/times.h>
92 #include <sys/utime.h>
96 /* ------------------------------- */
98 /* ------------------------------- */
101 #include <sys/utsname.h>
102 #if defined (TIOCGWINSZ) || defined (ISC4_0)
104 #include <sys/sioctl.h>
107 #include <sys/stream.h>
108 #include <sys/ptem.h>
110 #endif /* TIOCGWINSZ or ISC4_0 */
113 #ifdef HAVE_SYS_STROPTS_H
114 #include <sys/stropts.h>
115 #endif /* HAVE_SYS_STROPTS_H */
117 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */
128 static int baud_convert[] =
133 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
134 1800, 2400, 4800, 9600, 19200, 38400
141 static void hft_init (struct console *c);
142 static void hft_reset (struct console *c);
143 #include <sys/termio.h>
146 /* ------------------------------- */
148 /* ------------------------------- */
151 #ifndef HAVE_STRUCT_UTIMBUF
152 /* We want to use utime rather than utimes, but we couldn't find the
153 structure declaration. We'll use the traditional one. */
163 /************************************************************************/
164 /* subprocess control */
165 /************************************************************************/
171 /* Arrange for character C to be read as the next input from
174 stuff_char (struct console *con, int c)
178 assert (CONSOLE_TTY_P (con));
179 input_fd = CONSOLE_TTY_DATA (con)->infd;
180 /* Should perhaps error if in batch mode */
182 ioctl (input_fd, TIOCSTI, &c);
183 #else /* no TIOCSTI */
184 error ("Cannot stuff terminal input characters in this version of Unix.");
185 #endif /* no TIOCSTI */
190 #endif /* HAVE_TTY */
193 set_exclusive_use (int fd)
196 ioctl (fd, FIOCLEX, 0);
198 /* Ok to do nothing if this feature does not exist */
202 set_descriptor_non_blocking (int fd)
204 /* Stride people say it's a mystery why this is needed
205 as well as the O_NDELAY, but that it fails without this. */
206 /* For AIX: Apparently need this for non-blocking reads on sockets.
207 It seems that O_NONBLOCK applies only to FIFOs? From
208 lowry@watson.ibm.com (Andy Lowry). */
209 /* #### Should this be conditionalized on FIONBIO? */
210 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS)) || defined (AIX)
213 ioctl (fd, FIONBIO, &one);
218 fcntl (fd, F_SETFL, O_NONBLOCK);
222 #if defined (NO_SUBPROCESSES)
226 wait_without_blocking (void)
228 wait3 (0, WNOHANG | WUNTRACED, 0);
229 synch_process_alive = 0;
233 #endif /* NO_SUBPROCESSES */
237 void wait_for_termination (HANDLE pHandle)
239 void wait_for_termination (int pid)
242 /* #### With the new improved SIGCHLD handling stuff, there is much
243 less danger of race conditions and some of the comments below
244 don't apply. This should be updated. */
246 #if defined (NO_SUBPROCESSES)
249 /* No need to be tricky like below; we can just call wait(). */
250 /* #### should figure out how to write a wait_allowing_quit().
251 Since hardly any systems don't have subprocess support,
252 however, there doesn't seem to be much point. */
256 #elif defined (HAVE_WAITPID)
257 /* Note that, whenever any subprocess terminates (asynch. or synch.),
258 the SIGCHLD handler will be called and it will call wait(). Thus
259 we cannot just call wait() ourselves, and we can't block SIGCHLD
260 and then call wait(), because then if an asynch. process dies
261 while we're waiting for our synch. process, Emacs will never
262 notice that the asynch. process died.
264 So, the general approach we take is to repeatedly block until a
265 signal arrives, and then check if our process died using kill
266 (pid, 0). (We could also check the value of `synch_process_alive',
267 since the SIGCHLD handler will reset that and we know that we're
268 only being called on synchronous processes, but this approach is
269 safer. I don't trust the proper delivery of SIGCHLD.
271 Note also that we cannot use any form of waitpid(). A loop with
272 WNOHANG will chew up CPU time; better to use sleep(). A loop
273 without WNOWAIT will screw up the SIGCHLD handler (actually this
274 is not true, if you duplicate the exit-status-reaping code; see
275 below). A loop with WNOWAIT will result in a race condition if
276 the process terminates between the process-status check and the
277 call to waitpid(). */
279 /* Formerly, immediate_quit was set around this function call, but
280 that could lead to problems if the QUIT happened when SIGCHLD was
281 blocked -- it would remain blocked. Yet another reason why
282 immediate_quit is a bad idea. In any case, there is no reason to
283 resort to this because either the SIGIO or the SIGALRM will stop
284 the block in EMACS_WAIT_FOR_SIGNAL(). */
286 /* Apparently there are bugs on some systems with the second method
287 used below (the EMACS_BLOCK_SIGNAL method), whereby zombie
288 processes get left around. It appears in those cases that the
289 SIGCHLD handler is never getting invoked. It's not clear whether
290 this is an Emacs bug or a kernel bug or both: on HPUX this
291 problem is observed only with XEmacs, but under Solaris 2.4 all
292 sorts of different programs have problems with zombies. The
293 method we use here does not require a working SIGCHLD (but will
294 not break if it is working), and should be safe. */
296 We use waitpid(), contrary to the remarks above. There is no
297 race condition, because the three situations when sigchld_handler
298 is invoked should be handled OK:
300 - handler invoked before waitpid(): In this case, subprocess
301 status will be set by sigchld_handler. waitpid() here will
302 return -1 with errno set to ECHILD, which is a valid exit
305 - handler invoked during waitpid(): as above, except that errno
306 here will be set to EINTR. This will cause waitpid() to be
307 called again, and this time it will exit with ECHILD.
309 - handler invoked after waitpid(): The following code will reap
310 the subprocess. In the handler, wait() will return -1 because
311 there is no child to reap, and the handler will exit without
312 modifying child subprocess status. */
315 /* Because the SIGCHLD handler can potentially reap the synchronous
316 subprocess, we should take care of that. */
318 /* Will stay in the do loop as long as:
320 2. Ctrl-G is not pressed */
324 ret = waitpid (pid, &status, 0);
325 /* waitpid returns 0 if the process is still alive. */
327 while (ret == 0 || (ret == -1 && errno == EINTR));
329 if (ret == pid) /* Success */
330 /* Set synch process globals. This is can also happen
331 in sigchld_handler, and that code is duplicated. */
333 synch_process_alive = 0;
334 if (WIFEXITED (status))
335 synch_process_retcode = WEXITSTATUS (status);
336 else if (WIFSIGNALED (status))
337 synch_process_death = signal_name (WTERMSIG (status));
339 /* On exiting the loop, ret will be -1, with errno set to ECHILD if
340 the child has already been reaped, e.g. in the signal handler. */
342 /* Otherwise, we've had some error condition here.
343 Per POSIX, the only other possibilities are:
344 - EFAULT (bus error accessing arg 2) or
345 - EINVAL (incorrect arguments),
346 which are both program bugs.
348 Since implementations may add their own error indicators on top,
349 we ignore it by default. */
350 #elif defined (WINDOWSNT)
351 int ret = 0, status = 0;
354 warn_when_safe (Qprocess, Qwarning, "Cannot wait for unknown process to terminate");
360 ret = WaitForSingleObject(pHandle, 100);
362 while (ret == WAIT_TIMEOUT);
363 if (ret == WAIT_FAILED)
365 warn_when_safe (Qprocess, Qwarning, "waiting for process failed");
367 if (ret == WAIT_ABANDONED)
369 warn_when_safe (Qprocess, Qwarning,
370 "process to wait for has been abandoned");
372 if (ret == WAIT_OBJECT_0)
374 ret = GetExitCodeProcess(pHandle, &status);
377 synch_process_alive = 0;
378 synch_process_retcode = status;
382 /* GetExitCodeProcess() didn't return a valid exit status,
383 nothing to do. APA */
384 warn_when_safe (Qprocess, Qwarning,
385 "failure to obtain process exit value");
388 if (pHandle != NULL && !CloseHandle(pHandle))
390 warn_when_safe (Qprocess, Qwarning,
391 "failure to close unknown process");
393 #elif defined (EMACS_BLOCK_SIGNAL) && !defined (BROKEN_WAIT_FOR_SIGNAL) && defined (SIGCHLD)
396 static int wait_debugging = 0; /* Set nonzero to make following
397 function work under dbx (at least for bsd). */
402 EMACS_BLOCK_SIGNAL (SIGCHLD);
403 /* Block SIGCHLD from happening during this check,
404 to avoid race conditions. */
405 if (kill (pid, 0) < 0)
407 EMACS_UNBLOCK_SIGNAL (SIGCHLD);
411 /* WARNING: Whatever this macro does *must* not allow SIGCHLD
412 to happen between the time that it's reenabled and when we
413 begin to block. Otherwise we may end up blocking for a
414 signal that has already arrived and isn't coming again.
415 Can you say "race condition"?
417 I assume that the system calls sigpause() or sigsuspend()
418 to provide this atomicness. If you're getting hangs in
419 sigpause()/sigsuspend(), then your OS doesn't implement
420 this properly (this applies under hpux9, for example).
421 Try defining BROKEN_WAIT_FOR_SIGNAL. */
422 EMACS_WAIT_FOR_SIGNAL (SIGCHLD);
424 #else /* not HAVE_WAITPID and not WINDOWSNT and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
425 /* This approach is kind of cheesy but is guaranteed(?!) to work
430 if (kill (pid, 0) < 0)
434 #endif /* OS features */
438 #if !defined (NO_SUBPROCESSES)
441 * flush any pending output
442 * (may flush input as well; it does not matter the way we use it)
446 flush_pending_output (int channel)
449 /* If we try this, we get hit with SIGTTIN, because
450 the child's tty belongs to the child's pgrp. */
451 #elif defined (TCFLSH)
452 ioctl (channel, TCFLSH, 1);
453 #elif defined (TIOCFLUSH)
455 /* 3rd arg should be ignored
456 but some 4.2 kernels actually want the address of an int
457 and nonzero means something different. */
458 ioctl (channel, TIOCFLUSH, &zero);
463 /* Set up the terminal at the other end of a pseudo-terminal that
464 we will be controlling an inferior through.
465 It should not echo or do line-editing, since that is done
466 in Emacs. No padding needed for insertion into an Emacs buffer. */
469 child_setup_tty (int out)
472 emacs_get_tty (out, &s);
474 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
475 assert (isatty(out));
476 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
477 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
479 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
480 /* No output delays */
482 s.main.c_lflag &= ~ECHO; /* Disable echo */
483 s.main.c_lflag |= ISIG; /* Enable signals */
485 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
488 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
490 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
491 #if defined (CSIZE) && defined (CS8)
492 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
495 s.main.c_iflag &= ~ISTRIP; /* Don't strip 8th bit on input */
498 /* Unnecessary as long as ICANON is set */
499 s.main.c_cc[VMIN] = 1; /* minimum number of characters to accept */
500 s.main.c_cc[VTIME] = 0; /* wait forever for at least 1 character */
503 s.main.c_lflag |= ICANON; /* Enable erase/kill and eof processing */
504 s.main.c_cc[VEOF] = 04; /* ensure that EOF is Control-D */
505 s.main.c_cc[VERASE] = _POSIX_VDISABLE; /* disable erase processing */
506 s.main.c_cc[VKILL] = _POSIX_VDISABLE; /* disable kill processing */
509 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
514 /* AIX enhanced edit loses NULs, so disable it. */
516 s.main.c_iflag &= ~ASCEDIT;
517 #endif /* IBMR2AIX */
518 /* Also, PTY overloads NUL and BREAK.
519 don't ignore break, but don't signal either, so it looks like NUL.
520 This really serves a purpose only if running in an XTERM window
521 or via TELNET or the like, but does no harm elsewhere. */
522 s.main.c_iflag &= ~IGNBRK;
523 s.main.c_iflag &= ~BRKINT;
525 #ifdef SIGNALS_VIA_CHARACTERS
526 /* TTY `special characters' are used in process_send_signal
527 so set them here to something useful. */
528 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
529 s.main.c_cc[VINTR] = 'C' &037; /* Control-C */
530 s.main.c_cc[VSUSP] = 'Z' &037; /* Control-Z */
531 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
532 /* TTY `special characters' work better as signals, so disable
534 s.main.c_cc[VQUIT] = _POSIX_VDISABLE;
535 s.main.c_cc[VINTR] = _POSIX_VDISABLE;
536 s.main.c_cc[VSUSP] = _POSIX_VDISABLE;
537 s.main.c_lflag &= ~ISIG;
538 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
539 s.main.c_cc[VEOL] = _POSIX_VDISABLE;
541 /* <mdiers> #### This is not portable. ###
542 POSIX does not specify CBAUD, and 4.4BSD does not have it.
543 Instead, POSIX suggests to use cfset{i,o}speed().
544 [cf. D. Lewine, POSIX Programmer's Guide, Chapter 8: Terminal
545 I/O, O'Reilly 1991] */
546 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
548 /* <mdiers> What to do upon failure? Just ignoring rc is probably
549 not acceptable, is it? */
550 if (cfsetispeed (&s.main, B9600) == -1) /* ignore */;
551 if (cfsetospeed (&s.main, B9600) == -1) /* ignore */;
552 #endif /* defined (CBAUD) */
554 #else /* not HAVE_TERMIO */
556 s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
558 s.main.sg_flags |= LPASS8;
559 s.main.sg_erase = 0377;
560 s.main.sg_kill = 0377;
561 s.lmode = LLITOUT | s.lmode; /* Don't strip 8th bit */
563 #endif /* not HAVE_TERMIO */
564 emacs_set_tty (out, &s, 0);
569 ioctl (out, FIOASYNC, &zero);
573 #endif /* WINDOWSNT */
575 #endif /* not NO_SUBPROCESSES */
578 #if !defined (SIGTSTP) && !defined (USG_JOBCTRL)
580 #if defined(__STDC__) || defined(_MSC_VER)
581 #define SIG_PARAM_TYPE int
583 #define SIG_PARAM_TYPE
586 /* Record a signal code and the handler for it. */
590 SIGTYPE (*handler) (SIG_PARAM_TYPE);
594 save_signal_handlers (struct save_signal *saved_handlers)
596 while (saved_handlers->code)
598 saved_handlers->handler
599 = (SIGTYPE (*) (SIG_PARAM_TYPE)) signal (saved_handlers->code, SIG_IGN);
605 restore_signal_handlers (struct save_signal *saved_handlers)
607 while (saved_handlers->code)
609 signal (saved_handlers->code, saved_handlers->handler);
619 return abs (getpid ());
622 #endif /* WINDOWSNT */
624 /* Fork a subshell. */
631 struct save_signal saved_handlers[5];
633 unsigned char *str = 0;
637 saved_handlers[0].code = SIGINT;
638 saved_handlers[1].code = SIGQUIT;
639 saved_handlers[2].code = SIGTERM;
641 saved_handlers[3].code = SIGIO;
642 saved_handlers[4].code = 0;
644 saved_handlers[3].code = 0;
647 /* Mentioning current_buffer->buffer would mean including buffer.h,
648 which somehow wedges the hp compiler. So instead... */
650 if (NILP (Fboundp (Qdefault_directory)))
652 dir = Fsymbol_value (Qdefault_directory);
657 dir = Funhandled_file_name_directory (dir);
658 dir = expand_and_dir_to_file (dir, Qnil);
660 str = (unsigned char *) alloca (XSTRING_LENGTH (dir) + 2);
661 len = XSTRING_LENGTH (dir);
662 memcpy (str, XSTRING_DATA (dir), len);
663 if (!IS_ANY_SEP (str[len - 1]))
664 str[len++] = DIRECTORY_SEP;
672 error ("Can't spawn subshell");
674 #endif /* not WINDOWSNT */
679 sh = (char *) egetenv ("SHELL");
683 /* Use our buffer's default directory for the subshell. */
689 /* Waits for process completion */
690 if (_spawnlp (_P_WAIT, sh, sh, NULL) != 0)
691 error ("Can't spawn subshell");
693 return; /* we're done, no need to wait for termination */
698 #if !defined (NO_SUBPROCESSES)
699 close_process_descs (); /* Close Emacs's pipes/ptys */
702 #ifdef SET_EMACS_PRIORITY
703 if (emacs_priority != 0)
704 nice (-emacs_priority); /* Give the new shell the default priority */
708 write (1, "Can't execute subshell", 22);
712 save_signal_handlers (saved_handlers);
713 synch_process_alive = 1;
714 wait_for_termination (pid);
715 restore_signal_handlers (saved_handlers);
717 #endif /* not WINDOWSNT */
721 #endif /* !defined (SIGTSTP) && !defined (USG_JOBCTRL) */
725 /* Suspend the Emacs process; give terminal to its superior. */
729 #if defined (SIGTSTP)
731 int pgrp = EMACS_GET_PROCESS_GROUP ();
732 EMACS_KILLPG (pgrp, SIGTSTP);
735 #elif defined (USG_JOBCTRL)
736 /* If you don't know what this is don't mess with it */
737 ptrace (0, 0, 0, 0); /* set for ptrace - caught by csh */
738 kill (getpid (), SIGQUIT);
740 #else /* No SIGTSTP or USG_JOBCTRL */
742 /* On a system where suspending is not implemented,
743 instead fork a subshell and let it talk directly to the terminal
750 /* Suspend a process if possible; give terminal to its superior. */
752 sys_suspend_process (int process)
754 /* I don't doubt that it is possible to suspend processes on
755 * VMS machines or thost that use USG_JOBCTRL,
756 * but I don't know how to do it, so...
758 #if defined (SIGTSTP)
759 kill(process, SIGTSTP);
764 /* Given FD, obtain pty buffer size. When no luck, a good guess is made,
765 so that the function works even when fd is not a pty. */
768 get_pty_max_bytes (int fd)
770 /* DEC OSF 4.0 fpathconf returns 255, but xemacs hangs on long shell
771 input lines if we return 253. 252 is OK!. So let's leave a bit
772 of slack for the newline that xemacs will insert, and for those
773 inevitable vendor off-by-one-or-two-or-three bugs. */
774 #define MAX_CANON_SLACK 10
775 #define SAFE_MAX_CANON (127 - MAX_CANON_SLACK)
776 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
778 int max_canon = fpathconf (fd, _PC_MAX_CANON);
779 return (max_canon < 0 ? SAFE_MAX_CANON :
780 max_canon > SAFE_MAX_CANON ? max_canon - MAX_CANON_SLACK :
783 #elif defined (_POSIX_MAX_CANON)
784 return (_POSIX_MAX_CANON > SAFE_MAX_CANON ?
785 _POSIX_MAX_CANON - MAX_CANON_SLACK :
788 return SAFE_MAX_CANON;
792 /* Figure out the eof character for the FD. */
795 get_eof_char (int fd)
797 const Bufbyte ctrl_d = (Bufbyte) '\004';
806 /* What is the following line designed to do??? -mrb */
807 if (strlen ((const char *) t.c_cc) < (unsigned int) (VEOF + 1))
810 return (Bufbyte) t.c_cc[VEOF];
812 return t.c_cc[VEOF] == _POSIX_VDISABLE ? ctrl_d : (Bufbyte) t.c_cc[VEOF];
814 #else /* ! HAVE_TERMIOS */
815 /* On Berkeley descendants, the following IOCTL's retrieve the
816 current control characters. */
817 #if defined (TIOCGETC)
820 ioctl (fd, TIOCGETC, &c);
821 return (Bufbyte) c.t_eofc;
823 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
824 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
829 ioctl (fd, TCGETA, &t);
830 if (strlen ((const char *) t.c_cc) < (unsigned int) (VINTR + 1))
833 return (Bufbyte) t.c_cc[VINTR];
835 #else /* ! defined (TCGETA) */
836 /* Rather than complain, we'll just guess ^D, which is what
837 * earlier emacsen always used. */
839 #endif /* ! defined (TCGETA) */
840 #endif /* ! defined (TIOCGETC) */
841 #endif /* ! defined (HAVE_TERMIOS) */
844 /* Set the logical window size associated with descriptor FD
845 to HEIGHT and WIDTH. This is used mainly with ptys. */
848 set_window_size (int fd, int height, int width)
854 size.ws_row = height;
857 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
858 return 0; /* error */
862 #elif defined (TIOCSSIZE)
866 size.ts_lines = height;
867 size.ts_cols = width;
869 if (ioctl (fd, TIOCGSIZE, &size) == -1)
880 /* Set up the proper status flags for use of a pty. */
885 /* I'm told that TOICREMOTE does not mean control chars
886 "can't be sent" but rather that they don't have
887 input-editing or signaling effects.
888 That should be good, because we have other ways
889 to do those things in Emacs.
890 However, telnet mode seems not to work on 4.2.
891 So TIOCREMOTE is turned off now. */
893 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
894 will hang. In particular, the "timeout" feature (which
895 causes a read to return if there is no data available)
896 does this. Also it is known that telnet mode will hang
897 in such a way that Emacs must be stopped (perhaps this
898 is the same problem).
900 If TIOCREMOTE is turned off, then there is a bug in
901 hp-ux which sometimes loses data. Apparently the
902 code which blocks the master process when the internal
903 buffer fills up does not work. Other than this,
904 though, everything else seems to work fine.
906 Since the latter lossage is more benign, we may as well
907 lose that way. -- cph */
908 #if defined (FIONBIO) && defined (SYSV_PTYS)
911 ioctl (fd, FIONBIO, &on);
915 /* On AIX, the parent gets SIGHUP when a pty attached child dies. So, we */
916 /* ignore SIGHUP once we've started a child on a pty. Note that this may */
917 /* cause EMACS not to die when it should, i.e., when its own controlling */
918 /* tty goes away. I've complained to the AIX developers, and they may */
919 /* change this behavior, but I'm not going to hold my breath. */
920 signal (SIGHUP, SIG_IGN);
923 /* In some systems (Linux through 2.0.0, at least), packet mode doesn't
924 get cleared when a pty is closed, so we need to clear it here.
925 Linux pre2.0.13 contained an attempted fix for this (from Ted Ts'o,
926 tytso@mit.edu), but apparently it messed up rlogind and telnetd, so he
927 removed the fix in pre2.0.14. - dkindred@cs.cmu.edu
931 ioctl (fd, TIOCPKT, (char *)&off);
935 #endif /* HAVE_PTYS */
938 /************************************************************************/
940 /************************************************************************/
942 /* ------------------------------------------------------ */
944 /* ------------------------------------------------------ */
946 /* It really makes more sense for the baud-rate to be console-specific
947 and not device-specific, but it's (at least potentially) used for output
951 init_baud_rate (struct device *d)
953 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
954 if (DEVICE_WIN_P (d) || DEVICE_STREAM_P (d))
956 DEVICE_BAUD_RATE (d) = 38400;
961 assert (DEVICE_TTY_P (d));
963 int input_fd = CONSOLE_TTY_DATA (con)->infd;
964 #if defined (WINDOWSNT)
965 DEVICE_TTY_DATA (d)->ospeed = 15;
966 #elif defined (HAVE_TERMIOS)
970 tcgetattr (input_fd, &sg);
971 DEVICE_TTY_DATA (d)->ospeed = cfgetospeed (&sg);
972 # if defined (USE_GETOBAUD) && defined (getobaud)
973 /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
974 if (DEVICE_TTY_DATA (d)->ospeed == 0)
975 DEVICE_TTY_DATA (d)->ospeed = getobaud (sg.c_cflag);
977 #elif defined (HAVE_TERMIO)
982 tcgetattr (input_fd, &sg);
984 ioctl (input_fd, TCGETA, &sg);
986 DEVICE_TTY_DATA (d)->ospeed = sg.c_cflag & CBAUD;
987 #else /* neither TERMIOS nor TERMIO */
990 sg.sg_ospeed = B9600;
991 if (ioctl (input_fd, TIOCGETP, &sg) < 0)
993 DEVICE_TTY_DATA (d)->ospeed = sg.sg_ospeed;
997 DEVICE_BAUD_RATE (d) =
998 (DEVICE_TTY_DATA (d)->ospeed < countof (baud_convert)
999 ? baud_convert[DEVICE_TTY_DATA (d)->ospeed]
1002 if (DEVICE_BAUD_RATE (d) == 0)
1003 DEVICE_BAUD_RATE (d) = 1200;
1004 #endif /* HAVE_TTY */
1008 /* ------------------------------------------------------ */
1010 /* ------------------------------------------------------ */
1012 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1015 init_sigio_on_device (struct device *d)
1017 int filedesc = DEVICE_INFD (d);
1019 #if defined (FIOSSAIOOWN)
1021 int owner = getpid ();
1023 if (DEVICE_TTY_P (d))
1025 ioctl_status = ioctl (filedesc, FIOGSAIOOWN,
1026 &DEVICE_OLD_FCNTL_OWNER (d));
1027 ioctl_status = ioctl (filedesc, FIOSSAIOOWN, &owner);
1029 #ifdef HAVE_WINDOW_SYSTEM
1030 else if (!DEVICE_STREAM_P (d))
1032 ioctl_status = ioctl (filedesc, SIOCGPGRP,
1033 &DEVICE_OLD_FCNTL_OWNER (d));
1034 ioctl_status = ioctl (filedesc, SIOCSPGRP, &owner);
1038 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1039 DEVICE_OLD_FCNTL_OWNER (d) = fcntl (filedesc, F_GETOWN, 0);
1040 # ifdef F_SETOWN_SOCK_NEG
1041 /* stdin is a socket here */
1042 fcntl (filedesc, F_SETOWN, -getpid ());
1044 fcntl (filedesc, F_SETOWN, getpid ());
1050 reset_sigio_on_device (struct device *d)
1052 int filedesc = DEVICE_INFD (d);
1054 #if defined (FIOSSAIOOWN)
1057 if (DEVICE_TTY_P (d))
1059 ioctl_status = ioctl (filedesc, FIOSSAIOOWN,
1060 &DEVICE_OLD_FCNTL_OWNER (d));
1062 #ifdef HAVE_WINDOW_SYSTEM
1063 else if (!DEVICE_STREAM_P (d))
1065 ioctl_status = ioctl (filedesc, SIOCSPGRP,
1066 &DEVICE_OLD_FCNTL_OWNER (d));
1070 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1071 fcntl (filedesc, F_SETOWN, DEVICE_OLD_FCNTL_OWNER (d));
1076 request_sigio_on_device (struct device *d)
1078 int filedesc = DEVICE_INFD (d);
1080 #if defined (I_SETSIG) && !defined(HPUX10) && !defined(LINUX)
1083 ioctl (filedesc, I_GETSIG, &events);
1084 ioctl (filedesc, I_SETSIG, events | S_INPUT);
1086 #elif defined (FASYNC)
1087 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) | FASYNC);
1088 #elif defined (FIOSSAIOSTAT)
1090 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1091 sockets and other devices for some bizarre reason. We guess
1092 that an X device is a socket, and tty devices aren't. We then
1093 use the following crud to do the appropriate thing. */
1095 int ioctl_status; /* ####DG: check if IOCTL succeeds here. */
1097 if (DEVICE_TTY_P (d))
1099 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &on);
1101 #ifdef HAVE_WINDOW_SYSTEM
1102 else if (!DEVICE_STREAM_P (d))
1104 ioctl_status = ioctl (filedesc, FIOASYNC, &on);
1108 #elif defined (FIOASYNC)
1111 ioctl (filedesc, FIOASYNC, &on);
1115 #if defined (_CX_UX) /* #### Is this crap necessary? */
1116 EMACS_UNBLOCK_SIGNAL (SIGIO);
1121 unrequest_sigio_on_device (struct device *d)
1123 int filedesc = DEVICE_INFD (d);
1125 #if defined (I_SETSIG) && !defined(HPUX10)
1128 ioctl (filedesc, I_GETSIG, &events);
1129 ioctl (filedesc, I_SETSIG, events & ~S_INPUT);
1131 #elif defined (FASYNC)
1132 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) & ~FASYNC);
1133 #elif defined (FIOSSAIOSTAT)
1135 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1136 sockets and other devices for some bizarre reason. We guess
1137 that an X device is a socket, and tty devices aren't. We then
1138 use the following crud to do the appropriate thing. */
1143 /* See comment for request_sigio_on_device */
1145 if (DEVICE_TTY_P (d))
1147 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &off);
1151 ioctl_status = ioctl (filedesc, FIOASYNC, &off);
1154 #elif defined (FIOASYNC)
1157 ioctl (filedesc, FIOASYNC, &off);
1163 request_sigio (void)
1165 Lisp_Object devcons, concons;
1167 DEVICE_LOOP_NO_BREAK (devcons, concons)
1171 d = XDEVICE (XCAR (devcons));
1173 if (!DEVICE_STREAM_P (d))
1174 request_sigio_on_device (d);
1179 unrequest_sigio (void)
1181 Lisp_Object devcons, concons;
1183 DEVICE_LOOP_NO_BREAK (devcons, concons)
1187 d = XDEVICE (XCAR (devcons));
1189 if (!DEVICE_STREAM_P (d))
1190 unrequest_sigio_on_device (d);
1196 /* ------------------------------------------------------ */
1197 /* Changing Emacs's process group */
1198 /* ------------------------------------------------------ */
1200 /* Saving and restoring the process group of Emacs's terminal. */
1202 /* On some systems, apparently (?!) Emacs must be in its own process
1203 group in order to receive SIGIO correctly. On other systems
1204 (e.g. Solaris), it's not required and doing it makes things
1205 get fucked up. So, we only do it when
1206 SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP is defined. Basically,
1207 this is only required for BSD 4.2 systems. (Actually, I bet
1208 we don't have to do this at all -- those systems also
1209 required interrupt input, which we don't support.)
1211 If Emacs was in its own process group (i.e. inherited_pgroup ==
1212 getpid ()), then we know we're running under a shell with job
1213 control (Emacs would never be run as part of a pipeline).
1216 If Emacs was not in its own process group, then we know we're
1217 running under a shell (or a caller) that doesn't know how to
1218 separate itself from Emacs (like sh). Emacs must be in its own
1219 process group in order to receive SIGIO correctly. In this
1220 situation, we put ourselves in our own pgroup, forcibly set the
1221 tty's pgroup to our pgroup, and make sure to restore and reinstate
1222 the tty's pgroup just like any other terminal setting. If
1223 inherited_group was not the tty's pgroup, then we'll get a
1224 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1225 it goes foreground in the future, which is what should happen. */
1227 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1229 static int inherited_pgroup;
1230 static int inherited_tty_pgroup;
1235 munge_tty_process_group (void)
1237 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1241 /* Only do this munging if we have a device on the controlling
1242 terminal. See the large comment below. */
1244 if (CONSOLEP (Vcontrolling_terminal) &&
1245 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1247 int fd = open ("/dev/tty", O_RDWR, 0);
1249 EMACS_BLOCK_SIGNAL (SIGTTOU);
1250 EMACS_SET_TTY_PROCESS_GROUP (fd, &me);
1251 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1257 /* Split off the foreground process group to Emacs alone.
1258 When we are in the foreground, but not started in our own process
1259 group, redirect the TTY to point to our own process group. We need
1260 to be in our own process group to receive SIGIO properly. */
1262 munge_process_groups (void)
1264 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1268 EMACS_SEPARATE_PROCESS_GROUP ();
1270 munge_tty_process_group ();
1275 unmunge_tty_process_group (void)
1277 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1279 int fd = open ("/dev/tty", O_RDWR, 0);
1280 EMACS_BLOCK_SIGNAL (SIGTTOU);
1281 EMACS_SET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1282 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1288 /* Set the tty to our original foreground group.
1289 Also restore the original process group (put us back into sh's
1290 process group), so that ^Z will suspend both us and sh. */
1292 unmunge_process_groups (void)
1294 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1298 unmunge_tty_process_group ();
1300 EMACS_SET_PROCESS_GROUP (inherited_pgroup);
1304 /* According to some old wisdom, we need to be in a separate process
1305 group for SIGIO to work correctly (at least on some systems ...).
1306 So go ahead and put ourselves into our own process group. This
1307 will fail if we're already in our own process group, but who cares.
1308 Also record whether we were in our own process group. (In general,
1309 we will already be in our own process group if we were started from
1310 a job-control shell like csh, but not if we were started from sh).
1312 If we succeeded in changing our process group, then we will no
1313 longer be in the foreground process group of our controlling
1314 terminal. Therefore, if we have a console open onto this terminal,
1315 we have to change the controlling terminal's foreground process
1316 group (otherwise we will get stopped with a SIGTTIN signal when
1317 attempting to read from the terminal). It's important,
1318 however, that we do this *only* when we have a console open onto
1319 the terminal. It's a decidedly bad idea to do so otherwise,
1320 especially if XEmacs was started from the background. */
1323 init_process_group (void)
1325 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1326 if (! noninteractive)
1328 int fd = open ("/dev/tty", O_RDWR, 0);
1329 inherited_pgroup = EMACS_GET_PROCESS_GROUP ();
1330 EMACS_GET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1332 EMACS_SEPARATE_PROCESS_GROUP ();
1338 disconnect_controlling_terminal (void)
1341 /* Controlling terminals are attached to a session.
1342 Create a new session for us; it will have no controlling
1343 terminal. This also, of course, puts us in our own
1347 /* Put us in our own process group. */
1348 EMACS_SEPARATE_PROCESS_GROUP ();
1349 # if defined (TIOCNOTTY)
1350 /* This is the older way of disconnecting the controlling
1351 terminal, on 4.3 BSD. We must open /dev/tty; using
1352 filedesc 0 is not sufficient because it could be
1353 something else (e.g. our stdin was redirected to
1357 int j = open ("/dev/tty", O_RDWR, 0);
1358 ioctl (j, TIOCNOTTY, 0);
1361 # endif /* TIOCNOTTY */
1363 On systems without TIOCNOTTY and without
1364 setsid(), we don't need to do anything more to
1365 disconnect our controlling terminal. Here is
1366 what the man page for termio(7) from a SYSV 3.2
1369 "The first terminal file opened by the process group leader
1370 of a terminal file not already associated with a process
1371 group becomes the control terminal for that process group.
1372 The control terminal plays a special role in handling quit
1373 and interrupt signals, as discussed below. The control
1374 terminal is inherited by a child process during a fork(2).
1375 A process can break this association by changing its process
1376 group using setpgrp(2)."
1379 # endif /* not HAVE_SETSID */
1383 /* ------------------------------------------------------ */
1384 /* Getting and setting emacs_tty structures */
1385 /* ------------------------------------------------------ */
1387 /* It's wrong to encase these into #ifdef HAVE_TTY because we need
1388 them for child TTY processes. */
1389 /* However, this does break NT support while we don't do child TTY processes */
1392 /* Set *TC to the parameters associated with the terminal FD.
1393 Return zero if all's well, or -1 if we ran into an error we
1394 couldn't deal with. */
1396 emacs_get_tty (int fd, struct emacs_tty *settings)
1398 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
1400 /* We have those nifty POSIX tcmumbleattr functions. */
1401 if (tcgetattr (fd, &settings->main) < 0)
1404 #elif defined HAVE_TERMIO
1405 /* The SYSV-style interface? */
1406 if (ioctl (fd, TCGETA, &settings->main) < 0)
1409 #elif !defined (WINDOWSNT)
1410 /* I give up - I hope you have the BSD ioctls. */
1411 if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1413 #endif /* HAVE_TCATTR */
1415 /* Suivant - Do we have to get struct ltchars data? */
1417 if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1421 /* How about a struct tchars and a wordful of lmode bits? */
1423 if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1424 || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1428 /* We have survived the tempest. */
1432 /* Set the parameters of the tty on FD according to the contents of
1433 *SETTINGS. If FLUSHP is non-zero, we discard input.
1434 Return 0 if all went well, and -1 if anything failed.
1435 #### All current callers use FLUSHP == 0. */
1438 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
1440 /* Set the primary parameters - baud rate, character size, etcetera. */
1443 /* We have those nifty POSIX tcmumbleattr functions.
1444 William J. Smith <wjs@wiis.wang.com> writes:
1445 "POSIX 1003.1 defines tcsetattr() to return success if it was
1446 able to perform any of the requested actions, even if some
1447 of the requested actions could not be performed.
1448 We must read settings back to ensure tty setup properly.
1449 AIX requires this to keep tty from hanging occasionally." */
1450 /* This makes sure that we don't loop indefinitely in here. */
1451 for (i = 0 ; i < 10 ; i++)
1452 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1463 /* Get the current settings, and see if they're what we asked for. */
1464 tcgetattr (fd, &new);
1465 /* We cannot use memcmp on the whole structure here because under
1466 * aix386 the termios structure has some reserved field that may
1469 if ( new.c_iflag == settings->main.c_iflag
1470 && new.c_oflag == settings->main.c_oflag
1471 && new.c_cflag == settings->main.c_cflag
1472 && new.c_lflag == settings->main.c_lflag
1473 && memcmp(new.c_cc, settings->main.c_cc, NCCS) == 0)
1478 #elif defined HAVE_TERMIO
1479 /* The SYSV-style interface? */
1480 if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1483 #elif !defined (WINDOWSNT)
1484 /* I give up - I hope you have the BSD ioctls. */
1485 if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1487 #endif /* HAVE_TCATTR */
1489 /* Suivant - Do we have to get struct ltchars data? */
1491 if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1495 /* How about a struct tchars and a wordful of lmode bits? */
1497 if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1498 || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1502 /* We have survived the tempest. */
1506 #endif /* WINDOWSNT */
1508 /* ------------------------------------------------------ */
1509 /* Initializing a device */
1510 /* ------------------------------------------------------ */
1514 /* This may also be defined in stdio,
1515 but if so, this does no harm,
1516 and using the same name avoids wasting the other one's space. */
1518 #if ((defined(USG) || defined(DGUX)) && !defined(__STDC__))
1519 char _sobuf[BUFSIZ+8];
1520 #elif (defined(USG) && !defined(LINUX) && !defined(_SCO_DS)) || defined(IRIX5)
1521 extern unsigned char _sobuf[BUFSIZ+8];
1523 char _sobuf[BUFSIZ];
1526 #if defined (TIOCGLTC) && defined (HAVE_LTCHARS) /* HAVE_LTCHARS */
1527 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1529 #ifdef TIOCGETC /* HAVE_TCHARS */
1531 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1536 tty_init_sys_modes_on_device (struct device *d)
1538 struct emacs_tty tty;
1539 int input_fd, output_fd;
1540 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1542 input_fd = CONSOLE_TTY_DATA (con)->infd;
1543 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1545 emacs_get_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
1546 tty = CONSOLE_TTY_DATA (con)->old_tty;
1548 con->tty_erase_char = Qnil;
1550 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1551 /* after all those years... */
1552 con->tty_erase_char = make_char (tty.main.c_cc[VERASE]);
1554 /* This allows meta to be sent on 8th bit. */
1555 tty.main.c_iflag &= ~INPCK; /* don't check input for parity */
1557 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
1558 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
1560 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
1562 tty.main.c_lflag &= ~ECHO; /* Disable echo */
1563 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
1565 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
1567 tty.main.c_lflag |= ISIG; /* Enable signals */
1568 if (TTY_FLAGS (con).flow_control)
1570 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
1572 tty.main.c_iflag &= ~IXANY;
1576 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
1577 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
1579 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
1581 if (TTY_FLAGS (con).meta_key)
1583 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
1584 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1587 if (CONSOLE_TTY_DATA (con)->controlling_terminal)
1589 tty.main.c_cc[VINTR] =
1590 CONSOLE_QUIT_CHAR (con); /* C-g (usually) gives SIGINT */
1591 /* Set up C-g for both SIGQUIT and SIGINT.
1592 We don't know which we will get, but we handle both alike
1593 so which one it really gives us does not matter. */
1594 tty.main.c_cc[VQUIT] = CONSOLE_QUIT_CHAR (con);
1598 tty.main.c_cc[VINTR] = _POSIX_VDISABLE;
1599 tty.main.c_cc[VQUIT] = _POSIX_VDISABLE;
1601 tty.main.c_cc[VMIN] = 1; /* Input should wait for at
1603 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
1605 tty.main.c_cc[VSWTCH] = _POSIX_VDISABLE; /* Turn off shell layering use
1608 /* There was some conditionalizing here on (mips or TCATTR), but
1609 I think that's wrong. There was one report of C-y (DSUSP) not being
1610 disabled on HP9000s700 systems, and this might fix it. */
1612 tty.main.c_cc[VSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-z. */
1615 tty.main.c_cc[V_DSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-y. */
1616 #endif /* V_DSUSP */
1617 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1618 tty.main.c_cc[VDSUSP] = _POSIX_VDISABLE;
1621 tty.main.c_cc[VLNEXT] = _POSIX_VDISABLE;
1624 tty.main.c_cc[VREPRINT] = _POSIX_VDISABLE;
1625 #endif /* VREPRINT */
1627 tty.main.c_cc[VWERASE] = _POSIX_VDISABLE;
1628 #endif /* VWERASE */
1630 tty.main.c_cc[VDISCARD] = _POSIX_VDISABLE;
1631 #endif /* VDISCARD */
1633 tty.main.c_cc[VSTART] = _POSIX_VDISABLE;
1636 tty.main.c_cc[VSTRT] = _POSIX_VDISABLE; /* called VSTRT on some systems */
1639 tty.main.c_cc[VSTOP] = _POSIX_VDISABLE;
1641 #ifdef SET_LINE_DISCIPLINE
1642 /* Need to explicitly request TERMIODISC line discipline or
1643 Ultrix's termios does not work correctly. */
1644 tty.main.c_line = SET_LINE_DISCIPLINE;
1649 /* AIX enhanced edit loses NULs, so disable it. */
1650 tty.main.c_line = 0;
1651 tty.main.c_iflag &= ~ASCEDIT;
1653 tty.main.c_cc[VSTRT] = 255;
1654 tty.main.c_cc[VSTOP] = 255;
1655 tty.main.c_cc[VSUSP] = 255;
1656 tty.main.c_cc[VDSUSP] = 255;
1657 #endif /* IBMR2AIX */
1658 /* Also, PTY overloads NUL and BREAK.
1659 don't ignore break, but don't signal either, so it looks like NUL.
1660 This really serves a purpose only if running in an XTERM window
1661 or via TELNET or the like, but does no harm elsewhere. */
1662 tty.main.c_iflag &= ~IGNBRK;
1663 tty.main.c_iflag &= ~BRKINT;
1665 #else /* if not HAVE_TERMIO */
1666 #if !defined (WINDOWSNT)
1667 con->tty_erase_char = make_char (tty.main.sg_erase);
1668 tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1669 if (TTY_FLAGS (con).meta_key)
1670 tty.main.sg_flags |= ANYP;
1671 /* #### should we be using RAW mode here? */
1672 tty.main.sg_flags |= /* interrupt_input ? RAW : */ CBREAK;
1673 #endif /* not WINDOWSNT */
1674 #endif /* not HAVE_TERMIO */
1676 /* If going to use CBREAK mode, we must request C-g to interrupt
1677 and turn off start and stop chars, etc. If not going to use
1678 CBREAK mode, do this anyway so as to turn off local flow
1679 control for user coming over network on 4.2; in this case,
1680 only t_stopc and t_startc really matter. */
1683 /* Note: if not using CBREAK mode, it makes no difference how we
1685 tty.tchars = new_tchars;
1686 tty.tchars.t_intrc = CONSOLE_QUIT_CHAR (con);
1687 if (TTY_FLAGS (con).flow_control)
1689 tty.tchars.t_startc = '\021';
1690 tty.tchars.t_stopc = '\023';
1693 tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH |
1694 CONSOLE_TTY_DATA (con)->old_tty.lmode;
1696 #if defined (ultrix) || defined (__bsdi__)
1697 /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1698 anything, and leaving it in breaks the meta key. Go figure. */
1699 /* Turning off ONLCR is enough under BSD/386. Leave the general
1700 output post-processing flag alone since for some reason it
1701 doesn't get reset after XEmacs goes away. */
1702 tty.lmode &= ~LLITOUT;
1705 #endif /* HAVE_TCHARS */
1706 #endif /* not HAVE_TERMIO */
1709 tty.ltchars = new_ltchars;
1710 #endif /* HAVE_LTCHARS */
1712 emacs_set_tty (input_fd, &tty, 0);
1714 /* This code added to insure that, if flow-control is not to be used,
1715 we have an unlocked terminal at the start. */
1718 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TCXONC, 1);
1721 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TIOCSTART, 0);
1724 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1726 if (!TTY_FLAGS (con).flow_control) tcflow (input_fd, TCOON);
1733 /* IBM's HFT device usually thinks a ^J should be LF/CR.
1734 We need it to be only LF. This is the way that is
1738 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1739 write (output_fd, "\033[20l", 5);
1744 #if 0 /* We do our own buffering with lstreams. */
1746 /* This symbol is defined on recent USG systems.
1747 Someone says without this call USG won't really buffer the file
1748 even with a call to setbuf. */
1749 setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1751 setbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf);
1754 set_tty_modes (con);
1757 #endif /* HAVE_TTY */
1760 init_one_device (struct device *d)
1763 if (DEVICE_TTY_P (d))
1764 tty_init_sys_modes_on_device (d);
1766 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1767 if (!DEVICE_STREAM_P (d))
1769 init_sigio_on_device (d);
1770 request_sigio_on_device (d);
1776 init_one_console (struct console *con)
1778 Lisp_Object devcons;
1780 CONSOLE_DEVICE_LOOP (devcons, con)
1782 struct device *d = XDEVICE (XCAR (devcons));
1784 init_one_device (d);
1789 reinit_initial_console (void)
1791 munge_process_groups ();
1792 if (CONSOLEP (Vcontrolling_terminal) &&
1793 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1794 init_one_console (XCONSOLE (Vcontrolling_terminal));
1798 /* ------------------------------------------------------ */
1799 /* Other TTY functions */
1800 /* ------------------------------------------------------ */
1804 #if 0 /* not currently used */
1806 /* Return nonzero if safe to use tabs in output.
1807 At the time this is called, init_sys_modes has not been done yet. */
1810 tabs_safe_p (struct device *d)
1813 if (DEVICE_TTY_P (d))
1815 struct emacs_tty tty;
1817 emacs_get_tty (DEVICE_INFD (d), &tty);
1818 return EMACS_TTY_TABS_OK (&tty);
1826 /* Get terminal size from system.
1827 Store number of lines into *heightp and width into *widthp.
1828 If zero or a negative number is stored, the value is not valid. */
1831 get_tty_device_size (struct device *d, int *widthp, int *heightp)
1833 int input_fd = DEVICE_INFD (d);
1835 assert (DEVICE_TTY_P (d));
1840 struct winsize size;
1842 if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1843 *widthp = *heightp = 0;
1846 *widthp = size.ws_col;
1847 *heightp = size.ws_row;
1850 #elif defined TIOCGSIZE
1852 /* SunOS - style. */
1853 struct ttysize size;
1855 if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1856 *widthp = *heightp = 0;
1859 *widthp = size.ts_cols;
1860 *heightp = size.ts_lines;
1863 #else /* system doesn't know size */
1868 #endif /* not !TIOCGWINSZ */
1871 #endif /* HAVE_TTY */
1874 /* ------------------------------------------------------ */
1875 /* Is device 8 bit ? */
1876 /* ------------------------------------------------------ */
1881 eight_bit_tty (struct device *d)
1887 assert (DEVICE_TTY_P (d));
1888 input_fd = DEVICE_INFD (d);
1890 emacs_get_tty (input_fd, &s);
1892 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1893 eight_bit = (s.main.c_cflag & CSIZE) == CS8;
1895 eight_bit = 0; /* I don't know how to do it */
1900 #endif /* HAVE_TTY */
1903 /* ------------------------------------------------------ */
1904 /* Resetting a device */
1905 /* ------------------------------------------------------ */
1909 /* Prepare the terminal for exiting Emacs; move the cursor to the
1910 bottom of the frame, turn off interrupt-driven I/O, etc. */
1912 tty_reset_sys_modes_on_device (struct device *d)
1914 int input_fd, output_fd;
1915 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1917 input_fd = CONSOLE_TTY_DATA (con)->infd;
1918 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1920 #if defined (IBMR2AIX) && defined (AIXHFT)
1922 /* HFT consoles normally use ^J as a LF/CR. We forced it to
1923 do the LF only. Now, we need to reset it. */
1926 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1927 write (output_fd, "\033[20h", 5);
1931 tty_redisplay_shutdown (con);
1932 /* reset_tty_modes() flushes the connection at its end. */
1933 reset_tty_modes (con);
1936 /* Avoid possible loss of output when changing terminal modes. */
1940 while (emacs_set_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
1941 < 0 && errno == EINTR)
1944 #ifdef SET_LINE_DISCIPLINE
1945 /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
1946 A different old line discipline is therefore not restored, yet.
1947 Restore the old line discipline by hand. */
1948 ioctl (input_fd, TIOCSETD, &old_tty.main.c_line);
1957 #endif /* HAVE_TTY */
1960 reset_one_device (struct device *d)
1963 if (DEVICE_TTY_P (d))
1964 tty_reset_sys_modes_on_device (d);
1967 if (DEVICE_STREAM_P (d))
1968 fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->out);
1969 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1970 if (!DEVICE_STREAM_P (d))
1972 unrequest_sigio_on_device (d);
1973 reset_sigio_on_device (d);
1979 reset_one_console (struct console *con)
1981 /* Note: this can be called during GC. */
1982 Lisp_Object devcons;
1984 CONSOLE_DEVICE_LOOP (devcons, con)
1986 struct device *d = XDEVICE (XCAR (devcons));
1988 reset_one_device (d);
1993 reset_all_consoles (void)
1995 /* Note: this can be called during GC. */
1996 Lisp_Object concons;
1998 CONSOLE_LOOP (concons)
2000 struct console *con = XCONSOLE (XCAR (concons));
2002 reset_one_console (con);
2005 unmunge_process_groups ();
2009 reset_initial_console (void)
2011 if (CONSOLEP (Vcontrolling_terminal) &&
2012 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
2013 reset_one_console (XCONSOLE (Vcontrolling_terminal));
2014 unmunge_process_groups ();
2018 /* ------------------------------------------------------ */
2019 /* extra TTY stuff under AIX */
2020 /* ------------------------------------------------------ */
2024 /* Called from init_sys_modes. */
2026 hft_init (struct console *con)
2031 assert (CONSOLE_TTY_P (con));
2032 input_fd = CONSOLE_TTY_DATA (con)->infd;
2034 /* If we're not on an HFT we shouldn't do any of this. We determine
2035 if we are on an HFT by trying to get an HFT error code. If this
2036 call fails, we're not on an HFT. */
2038 if (ioctl (input_fd, HFQERROR, &junk) < 0)
2040 #else /* not IBMR2AIX */
2041 if (ioctl (input_fd, HFQEIO, 0) < 0)
2043 #endif /* not IBMR2AIX */
2045 /* On AIX the default hft keyboard mapping uses backspace rather than delete
2046 as the rubout key's ASCII code. Here this is changed. The bug is that
2047 there's no way to determine the old mapping, so in reset_one_console
2048 we need to assume that the normal map had been present. Of course, this
2049 code also doesn't help if on a terminal emulator which doesn't understand
2053 struct hfkeymap keymap;
2055 buf.hf_bufp = (char *)&keymap;
2056 buf.hf_buflen = sizeof (keymap);
2057 keymap.hf_nkeys = 2;
2058 keymap.hfkey[0].hf_kpos = 15;
2059 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2061 keymap.hfkey[0].hf_keyidh = '<';
2062 #else /* not IBMR2AIX */
2063 keymap.hfkey[0].hf_page = '<';
2064 #endif /* not IBMR2AIX */
2065 keymap.hfkey[0].hf_char = 127;
2066 keymap.hfkey[1].hf_kpos = 15;
2067 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2069 keymap.hfkey[1].hf_keyidh = '<';
2070 #else /* not IBMR2AIX */
2071 keymap.hfkey[1].hf_page = '<';
2072 #endif /* not IBMR2AIX */
2073 keymap.hfkey[1].hf_char = 127;
2074 hftctl (input_fd, HFSKBD, &buf);
2076 /* #### Should probably set a console TTY flag here. */
2078 /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
2080 line_ins_del_ok = char_ins_del_ok = 0;
2084 /* Reset the rubout key to backspace. */
2087 hft_reset (struct console *con)
2090 struct hfkeymap keymap;
2094 assert (CONSOLE_TTY_P (con));
2095 input_fd = CONSOLE_TTY_DATA (con)->infd;
2098 if (ioctl (input_fd, HFQERROR, &junk) < 0)
2100 #else /* not IBMR2AIX */
2101 if (ioctl (input_fd, HFQEIO, 0) < 0)
2103 #endif /* not IBMR2AIX */
2105 buf.hf_bufp = (char *)&keymap;
2106 buf.hf_buflen = sizeof (keymap);
2107 keymap.hf_nkeys = 2;
2108 keymap.hfkey[0].hf_kpos = 15;
2109 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2111 keymap.hfkey[0].hf_keyidh = '<';
2112 #else /* not IBMR2AIX */
2113 keymap.hfkey[0].hf_page = '<';
2114 #endif /* not IBMR2AIX */
2115 keymap.hfkey[0].hf_char = 8;
2116 keymap.hfkey[1].hf_kpos = 15;
2117 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2119 keymap.hfkey[1].hf_keyidh = '<';
2120 #else /* not IBMR2AIX */
2121 keymap.hfkey[1].hf_page = '<';
2122 #endif /* not IBMR2AIX */
2123 keymap.hfkey[1].hf_char = 8;
2124 hftctl (input_fd, HFSKBD, &buf);
2130 /************************************************************************/
2131 /* limits of text/data segments */
2132 /************************************************************************/
2134 #if !defined(CANNOT_DUMP) && !defined(PDUMP)
2138 #ifndef SYSTEM_MALLOC
2145 /* Some systems that cannot dump also cannot implement these. */
2148 * Return the address of the start of the text segment prior to
2149 * doing an unexec. After unexec the return value is undefined.
2150 * See crt0.c for further explanation and _start.
2154 #if !defined(HAVE_TEXT_START) && !defined(PDUMP)
2157 extern "C" int _start (void);
2159 extern int _start (void);
2163 start_of_text (void)
2166 return ((char *) TEXT_START);
2170 return ((char *) csrt);
2171 #else /* not GOULD */
2172 return ((char *) _start);
2174 #endif /* TEXT_START */
2176 #endif /* !defined(HAVE_TEXT_START) && !defined(PDUMP) */
2179 * Return the address of the start of the data segment prior to
2180 * doing an unexec. After unexec the return value is undefined.
2181 * See crt0.c for further information and definition of data_start.
2183 * Apparently, on BSD systems this is etext at startup. On
2184 * USG systems (swapping) this is highly mmu dependent and
2185 * is also dependent on whether or not the program is running
2186 * with shared text. Generally there is a (possibly large)
2187 * gap between end of text and start of data with shared text.
2189 * On Uniplus+ systems with shared text, data starts at a
2190 * fixed address. Each port (from a given oem) is generally
2191 * different, and the specific value of the start of data can
2192 * be obtained via the UniPlus+ specific "uvar" system call,
2193 * however the method outlined in crt0.c seems to be more portable.
2195 * Probably what will have to happen when a USG unexec is available,
2196 * at least on UniPlus, is temacs will have to be made unshared so
2197 * that text and data are contiguous. Then once loadup is complete,
2198 * unexec will produce a shared executable where the data can be
2199 * at the normal shared text boundary and the startofdata variable
2200 * will be patched by unexec to the correct value.
2204 #if defined(ORDINARY_LINK) && !defined(__MINGW32__)
2205 extern char **environ;
2209 start_of_data (void)
2212 return ((char *) DATA_START);
2214 #ifdef ORDINARY_LINK
2216 * This is a hack. Since we're not linking crt0.c or pre_crt0.c,
2217 * data_start isn't defined. We take the address of environ, which
2218 * is known to live at or near the start of the system crt0.c, and
2219 * we don't sweat the handful of bytes that might lose.
2221 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2222 extern char* static_heap_base;
2224 return static_heap_base;
2226 return((char *) &environ);
2228 extern int data_start;
2229 return ((char *) &data_start);
2230 #endif /* ORDINARY_LINK */
2231 #endif /* DATA_START */
2233 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2235 #if !defined(CANNOT_DUMP) && !defined(PDUMP)
2236 /* Some systems that cannot dump also cannot implement these. */
2239 * Return the address of the end of the text segment prior to
2240 * doing an unexec. After unexec the return value is undefined.
2247 return ((char *) TEXT_END);
2250 return ((char *) &etext);
2255 * Return the address of the end of the data segment prior to
2256 * doing an unexec. After unexec the return value is undefined.
2263 return ((char *) DATA_END);
2266 return ((char *) &edata);
2270 #endif /* !defined(CANNOT_DUMP) && !defined(PDUMP) */
2273 /************************************************************************/
2274 /* get the system name */
2275 /************************************************************************/
2277 /* init_system_name sets up the string for the Lisp function
2278 system-name to return. */
2280 extern Lisp_Object Vsystem_name;
2283 # include <sys/socket.h>
2285 #endif /* HAVE_SOCKETS */
2288 init_system_name (void)
2290 #if defined (WINDOWSNT)
2291 char hostname [MAX_COMPUTERNAME_LENGTH + 1];
2292 size_t size = sizeof (hostname);
2293 GetComputerName (hostname, &size);
2294 Vsystem_name = build_string (hostname);
2295 #elif !defined (HAVE_GETHOSTNAME)
2298 Vsystem_name = build_string (uts.nodename);
2299 #else /* HAVE_GETHOSTNAME */
2300 unsigned int hostname_size = 256;
2301 char *hostname = (char *) alloca (hostname_size);
2303 /* Try to get the host name; if the buffer is too short, try
2304 again. Apparently, the only indication gethostname gives of
2305 whether the buffer was large enough is the presence or absence
2306 of a '\0' in the string. Eech. */
2309 gethostname (hostname, hostname_size - 1);
2310 hostname[hostname_size - 1] = '\0';
2312 /* Was the buffer large enough for the '\0'? */
2313 if (strlen (hostname) < (size_t) (hostname_size - 1))
2316 hostname_size <<= 1;
2317 hostname = (char *) alloca (hostname_size);
2319 # if defined( HAVE_SOCKETS) && !defined(BROKEN_CYGWIN)
2320 /* Turn the hostname into the official, fully-qualified hostname.
2321 Don't do this if we're going to dump; this can confuse system
2322 libraries on some machines and make the dumped emacs core dump. */
2323 # ifndef CANNOT_DUMP
2325 # endif /* not CANNOT_DUMP */
2326 if (!strchr (hostname, '.'))
2328 # if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETNAMEINFO))
2329 struct hostent *hp = NULL;
2332 for (count = 0; count < 10; count++)
2336 /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
2338 hp = gethostbyname (hostname);
2339 start_interrupts ();
2341 if (! (hp == 0 && h_errno == TRY_AGAIN))
2343 Fsleep_for (make_int (1));
2348 const char *fqdn = (const char *) hp->h_name;
2350 if (!strchr (fqdn, '.'))
2352 /* We still don't have a fully qualified domain name.
2353 Try to find one in the list of alternate names */
2354 char **alias = hp->h_aliases;
2355 while (*alias && !strchr (*alias, '.'))
2360 hostname = (char *) alloca (strlen (fqdn) + 1);
2361 strcpy (hostname, fqdn);
2363 # else /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
2364 struct addrinfo hints, *res;
2367 hints.ai_flags = AI_CANONNAME;
2368 hints.ai_family = AF_UNSPEC;
2369 hints.ai_socktype = SOCK_STREAM;
2370 hints.ai_protocol = 0;
2371 if (!getaddrinfo (hostname, NULL, &hints, &res))
2373 hostname = (char *) alloca (strlen (res->ai_canonname) + 1);
2374 strcpy (hostname, res->ai_canonname);
2378 # endif /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
2380 # endif /* HAVE_SOCKETS */
2381 Vsystem_name = build_string (hostname);
2382 #endif /* HAVE_GETHOSTNAME */
2387 for (i = 0, p = XSTRING_DATA (Vsystem_name);
2388 i < XSTRING_LENGTH (Vsystem_name);
2391 if (*p == ' ' || *p == '\t')
2398 /************************************************************************/
2399 /* Emulation of select() */
2400 /************************************************************************/
2404 ERROR: XEmacs requires a working select().
2406 #endif /* not HAVE_SELECT */
2409 /************************************************************************/
2410 /* Emulation of signal stuff */
2411 /************************************************************************/
2413 /* BSD 4.1 crap deleted. 4.2 was released in 1983, for God's sake! I
2414 can't imagine that anyone is actually running that OS any more.
2415 You can't use X under it (I think) because there's no select().
2416 Anyway, the signal stuff has all been changed. If someone wants to
2417 get this stuff working again, look in the FSF Emacs sources. */
2419 /* POSIX signals support - DJB */
2421 #ifdef HAVE_SIGPROCMASK
2423 /* #### Is there any reason this is static global rather than local? */
2424 static struct sigaction new_action, old_action;
2427 sys_do_signal (int signal_number, signal_handler_t action)
2431 /* XEmacs works better if system calls are *not* restarted.
2432 This allows C-g to interrupt reads and writes, on most systems.
2434 #### Another possibility is to just longjmp() out of the signal
2435 handler. According to W.R. Stevens, this should be OK on all
2436 systems. However, I don't want to deal with the potential
2437 evil ramifications of this at this point. */
2440 /* This gets us restartable system calls for efficiency.
2441 The "else" code will work as well. */
2442 return (berk_signal (signal_number, action));
2444 sigemptyset (&new_action.sa_mask);
2445 new_action.sa_handler = action;
2446 #if defined (SA_RESTART)
2447 /* Emacs mostly works better with restartable system services. If this
2448 * flag exists, we probably want to turn it on here.
2450 new_action.sa_flags = SA_RESTART;
2452 new_action.sa_flags = 0;
2454 sigaction (signal_number, &new_action, &old_action);
2455 return (old_action.sa_handler);
2460 sigemptyset (&new_action.sa_mask);
2461 new_action.sa_handler = action;
2462 #if defined (SA_INTERRUPT) /* don't restart system calls, under SunOS */
2463 new_action.sa_flags = SA_INTERRUPT;
2465 new_action.sa_flags = 0;
2467 sigaction (signal_number, &new_action, &old_action);
2468 return (signal_handler_t) (old_action.sa_handler);
2473 #elif defined (HAVE_SIGBLOCK)
2475 /* We use sigvec() rather than signal() if we have it, because
2476 it lets us specify interruptible system calls. */
2478 sys_do_signal (int signal_number, signal_handler_t action)
2480 struct sigvec vec, ovec;
2482 vec.sv_handler = action;
2484 #ifdef SV_INTERRUPT /* don't restart system calls */
2485 vec.sv_flags = SV_INTERRUPT;
2490 sigvec (signal_number, &vec, &ovec);
2492 return (ovec.sv_handler);
2495 #endif /* HAVE_SIGBLOCK (HAVE_SIGPROCMASK) */
2498 /************************************************************************/
2499 /* Emulation of strerror() and errno support */
2500 /************************************************************************/
2502 #ifndef HAVE_STRERROR
2504 #if !defined(NeXT) && !defined(__alpha) && !defined(MACH) && !defined(LINUX) && !defined(IRIX) && !defined(__NetBSD__)
2505 /* Linux added here by Raymond L. Toy <toy@alydar.crd.ge.com> for XEmacs. */
2506 /* Irix added here by gparker@sni-usa.com for XEmacs. */
2507 /* NetBSD added here by James R Grinter <jrg@doc.ic.ac.uk> for XEmacs */
2508 extern const char *sys_errlist[];
2509 extern int sys_nerr;
2513 extern char *sys_errlist[];
2514 extern int sys_nerr;
2519 strerror (int errnum)
2521 if (errnum >= 0 && errnum < sys_nerr)
2522 return sys_errlist[errnum];
2523 return ((const char *) GETTEXT ("Unknown error"));
2526 #endif /* ! HAVE_STRERROR */
2531 unsigned long oscode; /* Win32 error */
2532 int errnocode; /* unix errno */
2535 static struct errentry errtable[] = {
2536 { ERROR_INVALID_FUNCTION, EINVAL }, /* 1 */
2537 { ERROR_FILE_NOT_FOUND, ENOENT }, /* 2 */
2538 { ERROR_PATH_NOT_FOUND, ENOENT }, /* 3 */
2539 { ERROR_TOO_MANY_OPEN_FILES, EMFILE }, /* 4 */
2540 { ERROR_ACCESS_DENIED, EACCES }, /* 5 */
2541 { ERROR_INVALID_HANDLE, EBADF }, /* 6 */
2542 { ERROR_ARENA_TRASHED, ENOMEM }, /* 7 */
2543 { ERROR_NOT_ENOUGH_MEMORY, ENOMEM }, /* 8 */
2544 { ERROR_INVALID_BLOCK, ENOMEM }, /* 9 */
2545 { ERROR_BAD_ENVIRONMENT, E2BIG }, /* 10 */
2546 { ERROR_BAD_FORMAT, ENOEXEC }, /* 11 */
2547 { ERROR_INVALID_ACCESS, EINVAL }, /* 12 */
2548 { ERROR_INVALID_DATA, EINVAL }, /* 13 */
2549 { ERROR_INVALID_DRIVE, ENOENT }, /* 15 */
2550 { ERROR_CURRENT_DIRECTORY, EACCES }, /* 16 */
2551 { ERROR_NOT_SAME_DEVICE, EXDEV }, /* 17 */
2552 { ERROR_NO_MORE_FILES, ENOENT }, /* 18 */
2553 { ERROR_LOCK_VIOLATION, EACCES }, /* 33 */
2554 { ERROR_BAD_NETPATH, ENOENT }, /* 53 */
2555 { ERROR_NETWORK_ACCESS_DENIED, EACCES }, /* 65 */
2556 { ERROR_BAD_NET_NAME, ENOENT }, /* 67 */
2557 { ERROR_FILE_EXISTS, EEXIST }, /* 80 */
2558 { ERROR_CANNOT_MAKE, EACCES }, /* 82 */
2559 { ERROR_FAIL_I24, EACCES }, /* 83 */
2560 { ERROR_INVALID_PARAMETER, EINVAL }, /* 87 */
2561 { ERROR_NO_PROC_SLOTS, EAGAIN }, /* 89 */
2562 { ERROR_DRIVE_LOCKED, EACCES }, /* 108 */
2563 { ERROR_BROKEN_PIPE, EPIPE }, /* 109 */
2564 { ERROR_DISK_FULL, ENOSPC }, /* 112 */
2565 { ERROR_INVALID_TARGET_HANDLE, EBADF }, /* 114 */
2566 { ERROR_INVALID_HANDLE, EINVAL }, /* 124 */
2567 { ERROR_WAIT_NO_CHILDREN, ECHILD }, /* 128 */
2568 { ERROR_CHILD_NOT_COMPLETE, ECHILD }, /* 129 */
2569 { ERROR_DIRECT_ACCESS_HANDLE, EBADF }, /* 130 */
2570 { ERROR_NEGATIVE_SEEK, EINVAL }, /* 131 */
2571 { ERROR_SEEK_ON_DEVICE, EACCES }, /* 132 */
2572 { ERROR_DIR_NOT_EMPTY, ENOTEMPTY }, /* 145 */
2573 { ERROR_NOT_LOCKED, EACCES }, /* 158 */
2574 { ERROR_BAD_PATHNAME, ENOENT }, /* 161 */
2575 { ERROR_MAX_THRDS_REACHED, EAGAIN }, /* 164 */
2576 { ERROR_LOCK_FAILED, EACCES }, /* 167 */
2577 { ERROR_ALREADY_EXISTS, EEXIST }, /* 183 */
2578 { ERROR_FILENAME_EXCED_RANGE, ENOENT }, /* 206 */
2579 { ERROR_NESTING_NOT_ALLOWED, EAGAIN }, /* 215 */
2580 { ERROR_NOT_ENOUGH_QUOTA, ENOMEM } /* 1816 */
2583 /* The following two constants must be the minimum and maximum
2584 values in the (contiguous) range of Exec Failure errors. */
2585 #define MIN_EXEC_ERROR ERROR_INVALID_STARTING_CODESEG
2586 #define MAX_EXEC_ERROR ERROR_INFLOOP_IN_RELOC_CHAIN
2588 /* These are the low and high value in the range of errors that are
2589 access violations */
2590 #define MIN_EACCES_RANGE ERROR_WRITE_PROTECT
2591 #define MAX_EACCES_RANGE ERROR_SHARING_BUFFER_EXCEEDED
2594 mswindows_set_errno (unsigned long win32_error)
2598 /* check the table for the OS error code */
2599 for (i = 0; i < countof (errtable); ++i)
2601 if (win32_error == errtable[i].oscode)
2603 errno = errtable[i].errnocode;
2608 /* The error code wasn't in the table. We check for a range of
2609 * EACCES errors or exec failure errors (ENOEXEC). Otherwise EINVAL is
2611 if (win32_error >= MIN_EACCES_RANGE && win32_error <= MAX_EACCES_RANGE)
2613 else if (win32_error >= MIN_EXEC_ERROR && win32_error <= MAX_EXEC_ERROR)
2620 mswindows_set_last_errno (void)
2622 mswindows_set_errno (GetLastError ());
2625 #endif /* WINDOWSNT */
2628 /************************************************************************/
2629 /* Encapsulations of system calls */
2630 /************************************************************************/
2632 #define PATHNAME_CONVERT_OUT(path) \
2633 TO_EXTERNAL_FORMAT (C_STRING, (path), C_STRING_ALLOCA, (path), Qfile_name);
2635 /***************** low-level calls ****************/
2638 * On USG systems the system calls are INTERRUPTIBLE by signals
2639 * that the user program has elected to catch. Thus the system call
2640 * must be retried in these cases. To handle this without massive
2641 * changes in the source code, we remap the standard system call names
2642 * to names for our own functions in sysdep.c that do the system call
2643 * with retries. Actually, for portability reasons, it is good
2644 * programming practice, as this example shows, to limit all actual
2645 * system calls to a single occurrence in the source. Sure, this
2646 * adds an extra level of function call overhead but it is almost
2647 * always negligible. Fred Fish, Unisoft Systems Inc.
2650 /* Ben sez: read Dick Gabriel's essay about the Worse Is Better
2651 approach to programming and its connection to the silly
2652 interruptible-system-call business. To find it, look on
2653 Jamie's home page (http://www.jwz.org/worse-is-better.html). */
2655 #ifdef ENCAPSULATE_OPEN
2657 sys_open (const char *path, int oflag, ...)
2662 va_start (ap, oflag);
2663 mode = va_arg (ap, int);
2666 PATHNAME_CONVERT_OUT (path);
2669 /* Make all handles non-inheritable */
2670 oflag |= _O_NOINHERIT;
2673 #ifdef INTERRUPTIBLE_OPEN
2676 while ((rtnval = open (path, oflag, mode)) == -1
2677 && (errno == EINTR))
2682 return open (path, oflag, mode);
2685 #endif /* ENCAPSULATE_OPEN */
2687 /* Like sys_open, only when open() is interrupted by EINTR, check for
2688 QUIT. This allows the callers of this function to be interrupted
2689 with C-g when, say, reading from named pipes. However, this should
2690 be used with caution, as it can GC.
2692 This function will not function as expected on systems where open()
2693 is not interrupted by C-g. However, the worst that can happen is
2694 the fallback to simple open(). */
2696 interruptible_open (const char *path, int oflag, int mode)
2698 /* This function can GC */
2699 size_t len = strlen (path);
2700 char *nonreloc = (char *) alloca (len + 1);
2702 /* Must copy PATH, because it might be the data of a Lisp_String,
2703 which could be relocated by GC when checking for QUIT. */
2704 memcpy (nonreloc, path, len + 1);
2706 PATHNAME_CONVERT_OUT (nonreloc);
2709 /* Make all handles non-inheritable */
2710 oflag |= _O_NOINHERIT;
2715 int rtnval = open (nonreloc, oflag, mode);
2716 if (!(rtnval == -1 && errno == EINTR))
2718 /* open() was interrupted. Was QUIT responsible? */
2723 #ifdef ENCAPSULATE_CLOSE
2725 sys_close (int filedes)
2727 #ifdef INTERRUPTIBLE_CLOSE
2729 REGISTER int rtnval;
2731 while ((rtnval = close (filedes)) == -1
2732 && (errno == EINTR))
2735 /* If close is interrupted SunOS 4.1 may or may not have closed the
2736 file descriptor. If it did the second close will fail with
2737 errno = EBADF. That means we have succeeded. */
2738 if (rtnval == -1 && did_retry && errno == EBADF)
2743 return close (filedes);
2746 #endif /* ENCAPSULATE_CLOSE */
2749 sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit)
2753 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2754 while ((rtnval = read (fildes, buf, nbyte)) == -1
2755 && (errno == EINTR))
2763 #ifdef ENCAPSULATE_READ
2765 sys_read (int fildes, void *buf, size_t nbyte)
2767 return sys_read_1 (fildes, buf, nbyte, 0);
2769 #endif /* ENCAPSULATE_READ */
2772 sys_write_1 (int fildes, const void *buf, size_t nbyte, int allow_quit)
2774 ssize_t bytes_written = 0;
2775 const char *b = (const char *) buf;
2777 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2780 ssize_t rtnval = write (fildes, b, nbyte);
2790 return bytes_written ? bytes_written : -1;
2794 bytes_written += rtnval;
2796 return bytes_written;
2799 #ifdef ENCAPSULATE_WRITE
2801 sys_write (int fildes, const void *buf, size_t nbyte)
2803 return sys_write_1 (fildes, buf, nbyte, 0);
2805 #endif /* ENCAPSULATE_WRITE */
2808 /**************** stdio calls ****************/
2810 /* There is at least some evidence that the stdio calls are interruptible
2811 just like the normal system calls, at least on some systems. In any
2812 case, it doesn't hurt to encapsulate them. */
2814 /* #### Should also encapsulate fflush().
2815 #### Should conceivably encapsulate getchar() etc. What a pain! */
2817 #ifdef ENCAPSULATE_FOPEN
2819 sys_fopen (const char *path, const char *type)
2821 PATHNAME_CONVERT_OUT (path);
2822 #if defined (WINDOWSNT)
2826 const char * type_save = type;
2828 /* Force all file handles to be non-inheritable. This is necessary to
2829 ensure child processes don't unwittingly inherit handles that might
2830 prevent future file access. */
2834 else if (type[0] == 'w' || type[0] == 'a')
2835 oflag = O_WRONLY | O_CREAT | O_TRUNC;
2839 /* Only do simplistic option parsing. */
2843 oflag &= ~(O_RDONLY | O_WRONLY);
2846 else if (type[0] == 'b')
2851 else if (type[0] == 't')
2858 fd = open (path, oflag | _O_NOINHERIT, 0644);
2862 return _fdopen (fd, type_save);
2864 #elif defined (INTERRUPTIBLE_OPEN)
2867 while (!(rtnval = fopen (path, type)) && (errno == EINTR))
2872 return fopen (path, type);
2875 #endif /* ENCAPSULATE_FOPEN */
2878 #ifdef ENCAPSULATE_FCLOSE
2880 sys_fclose (FILE *stream)
2882 #ifdef INTERRUPTIBLE_CLOSE
2885 while ((rtnval = fclose (stream)) == EOF
2886 && (errno == EINTR))
2890 return fclose (stream);
2893 #endif /* ENCAPSULATE_FCLOSE */
2896 #ifdef ENCAPSULATE_FREAD
2898 sys_fread (void *ptr, size_t size, size_t nitem, FILE *stream)
2900 #ifdef INTERRUPTIBLE_IO
2902 size_t items_read = 0;
2903 char *b = (char *) ptr;
2907 rtnval = fread (b, size, nitem, stream);
2910 if (ferror (stream) && errno == EINTR)
2917 items_read += rtnval;
2919 return (items_read);
2921 return fread (ptr, size, nitem, stream);
2924 #endif /* ENCAPSULATE_FREAD */
2927 #ifdef ENCAPSULATE_FWRITE
2929 sys_fwrite (const void *ptr, size_t size, size_t nitem, FILE *stream)
2931 #ifdef INTERRUPTIBLE_IO
2933 size_t items_written = 0;
2934 const char *b = (const char *) ptr;
2938 rtnval = fwrite (b, size, nitem, stream);
2941 if (ferror (stream) && errno == EINTR)
2944 return items_written;
2948 items_written += rtnval;
2950 return (items_written);
2952 return fwrite (ptr, size, nitem, stream);
2955 #endif /* ENCAPSULATE_FWRITE */
2958 /********************* directory calls *******************/
2960 #ifdef ENCAPSULATE_CHDIR
2962 sys_chdir (const char *path)
2964 PATHNAME_CONVERT_OUT (path);
2965 return chdir (path);
2967 #endif /* ENCAPSULATE_CHDIR */
2970 #ifdef ENCAPSULATE_MKDIR
2972 sys_mkdir (const char *path, mode_t mode)
2974 PATHNAME_CONVERT_OUT (path);
2976 return mkdir (path);
2978 return mkdir (path, mode);
2981 #endif /* ENCAPSULATE_MKDIR */
2984 #ifdef ENCAPSULATE_OPENDIR
2986 sys_opendir (const char *filename)
2989 PATHNAME_CONVERT_OUT (filename);
2991 while (!(rtnval = opendir (filename))
2992 && (errno == EINTR))
2996 #endif /* ENCAPSULATE_OPENDIR */
2999 #ifdef ENCAPSULATE_READDIR
3001 sys_readdir (DIR *dirp)
3005 /* Apparently setting errno is necessary on some systems?
3006 Maybe readdir() doesn't always set errno ?! */
3007 while (!(errno = 0, rtnval = readdir (dirp))
3008 && (errno == EINTR))
3013 if (rtnval == NULL) /* End of directory */
3016 Extcount external_len;
3017 int ascii_filename_p = 1;
3018 const Extbyte * const external_name = (const Extbyte *) rtnval->d_name;
3020 /* Optimize for the common all-ASCII case, computing len en passant */
3021 for (external_len = 0; external_name[external_len] ; external_len++)
3023 if (!BYTE_ASCII_P (external_name[external_len]))
3024 ascii_filename_p = 0;
3026 if (ascii_filename_p)
3029 { /* Non-ASCII filename */
3030 static Bufbyte_dynarr *internal_DIRENTRY;
3031 const Bufbyte *internal_name;
3032 Bytecount internal_len;
3033 if (!internal_DIRENTRY)
3034 internal_DIRENTRY = Dynarr_new (Bufbyte);
3036 Dynarr_reset (internal_DIRENTRY);
3038 Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
3039 offsetof (DIRENTRY, d_name));
3041 TO_INTERNAL_FORMAT (DATA, (external_name, external_len),
3042 ALLOCA, (internal_name, internal_len),
3045 Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
3046 Dynarr_add (internal_DIRENTRY, 0); /* zero-terminate */
3047 return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0);
3052 #endif /* ENCAPSULATE_READDIR */
3055 #ifdef ENCAPSULATE_CLOSEDIR
3057 sys_closedir (DIR *dirp)
3061 while ((rtnval = closedir (dirp)) == -1
3062 && (errno == EINTR))
3066 #endif /* ENCAPSULATE_CLOSEDIR */
3069 #ifdef ENCAPSULATE_RMDIR
3071 sys_rmdir (const char *path)
3073 PATHNAME_CONVERT_OUT (path);
3074 return rmdir (path);
3076 #endif /* ENCAPSULATE_RMDIR */
3079 /***************** file-information calls ******************/
3081 #ifdef ENCAPSULATE_ACCESS
3083 sys_access (const char *path, int mode)
3085 PATHNAME_CONVERT_OUT (path);
3086 return access (path, mode);
3088 #endif /* ENCAPSULATE_ACCESS */
3092 #ifdef ENCAPSULATE_EACCESS
3094 sys_eaccess (const char *path, int mode)
3096 PATHNAME_CONVERT_OUT (path);
3097 return eaccess (path, mode);
3099 #endif /* ENCAPSULATE_EACCESS */
3100 #endif /* HAVE_EACCESS */
3103 #ifdef ENCAPSULATE_LSTAT
3105 sys_lstat (const char *path, struct stat *buf)
3107 PATHNAME_CONVERT_OUT (path);
3108 return lstat (path, buf);
3110 #endif /* ENCAPSULATE_LSTAT */
3113 #ifdef ENCAPSULATE_READLINK
3115 sys_readlink (const char *path, char *buf, size_t bufsiz)
3117 PATHNAME_CONVERT_OUT (path);
3118 /* #### currently we don't do conversions on the incoming data */
3119 return readlink (path, buf, bufsiz);
3121 #endif /* ENCAPSULATE_READLINK */
3124 #ifdef ENCAPSULATE_FSTAT
3126 sys_fstat (int fd, struct stat *buf)
3128 return fstat (fd, buf);
3130 #endif /* ENCAPSULATE_FSTAT */
3133 #ifdef ENCAPSULATE_STAT
3135 sys_stat (const char *path, struct stat *buf)
3137 PATHNAME_CONVERT_OUT (path);
3138 return stat (path, buf);
3140 #endif /* ENCAPSULATE_STAT */
3143 /****************** file-manipulation calls *****************/
3145 #ifdef ENCAPSULATE_CHMOD
3147 sys_chmod (const char *path, mode_t mode)
3149 PATHNAME_CONVERT_OUT (path);
3150 return chmod (path, mode);
3152 #endif /* ENCAPSULATE_CHMOD */
3155 #ifdef ENCAPSULATE_CREAT
3157 sys_creat (const char *path, mode_t mode)
3159 PATHNAME_CONVERT_OUT (path);
3160 return creat (path, mode);
3162 #endif /* ENCAPSULATE_CREAT */
3165 #ifdef ENCAPSULATE_LINK
3167 sys_link (const char *existing, const char *new)
3169 PATHNAME_CONVERT_OUT (existing);
3170 PATHNAME_CONVERT_OUT (new);
3171 return link (existing, new);
3173 #endif /* ENCAPSULATE_LINK */
3176 #ifdef ENCAPSULATE_RENAME
3178 sys_rename (const char *old, const char *new)
3180 PATHNAME_CONVERT_OUT (old);
3181 PATHNAME_CONVERT_OUT (new);
3183 /* Windows rename fails if NEW exists */
3184 if (rename (old, new) == 0)
3186 if (errno != EEXIST)
3189 #endif /* WINDOWSNT */
3190 return rename (old, new);
3192 #endif /* ENCAPSULATE_RENAME */
3195 #ifdef ENCAPSULATE_SYMLINK
3197 sys_symlink (const char *name1, const char *name2)
3199 PATHNAME_CONVERT_OUT (name1);
3200 PATHNAME_CONVERT_OUT (name2);
3201 return symlink (name1, name2);
3203 #endif /* ENCAPSULATE_SYMLINK */
3206 #ifdef ENCAPSULATE_UNLINK
3208 sys_unlink (const char *path)
3210 PATHNAME_CONVERT_OUT (path);
3211 return unlink (path);
3213 #endif /* ENCAPSULATE_UNLINK */
3216 #ifdef ENCAPSULATE_EXECVP
3218 sys_execvp (const char *path, char * const * argv)
3223 PATHNAME_CONVERT_OUT (path);
3224 for (argc = 0; argv[argc]; argc++)
3226 new_argv = alloca_array (char *, argc + 1);
3227 for (i = 0; i < argc; i++)
3229 new_argv[i] = argv[i];
3230 PATHNAME_CONVERT_OUT (new_argv[i]);
3232 new_argv[argc] = NULL;
3233 return execvp (path, new_argv);
3235 #endif /* ENCAPSULATE_EXECVP */
3238 /************************************************************************/
3239 /* Emulations of missing system calls */
3240 /************************************************************************/
3242 /***** (these are primarily required for USG, it seems) *****/
3246 getcwd (char *pathname, size_t size)
3248 return getwd (pathname);
3250 #endif /* emulate getcwd */
3255 * Warning, this function may not duplicate BSD 4.2 action properly
3256 * under error conditions.
3261 getwd (char *pathname)
3263 char *npath, *spath;
3264 #if !__STDC__ && !defined(STDC_HEADERS)
3265 extern char *getcwd ();
3268 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3271 /* On Altos 3068, getcwd can return @hostname/dir, so discard
3272 up to first slash. Should be harmless on other systems. */
3273 while (*npath && *npath != '/')
3275 strcpy (pathname, npath);
3276 xfree (spath); /* getcwd uses malloc */
3279 #endif /* HAVE_GETWD */
3280 #endif /* 0 - mrb */
3283 * Emulate rename using unlink/link. Note that this is
3284 * only partially correct. Also, doesn't enforce restriction
3285 * that files be of same type (regular->regular, dir->dir, etc).
3290 rename (const char *from, const char *to)
3292 if (access (from, 0) == 0)
3295 if (link (from, to) == 0)
3296 if (unlink (from) == 0)
3301 #endif /* HAVE_RENAME */
3306 /* HPUX curses library references perror, but as far as we know
3307 it won't be called. Anyway this definition will do for now. */
3313 #endif /* not HAVE_PERROR */
3319 * Emulate BSD dup2. First close newd if it already exists.
3320 * Then, attempt to dup oldd. If not successful, call dup2 recursively
3321 * until we are, then close the unsuccessful ones.
3325 dup2 (int oldd, int newd)
3332 fd = fcntl (oldd, F_DUPFD, newd);
3334 error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3341 ret = dup2 (old, new);
3344 #endif /* F_DUPFD */
3347 #endif /* not HAVE_DUP2 */
3350 * Gettimeofday. Simulate as much as possible. Only accurate
3351 * to nearest second. Emacs doesn't use tzp so ignore it for now.
3354 #if !defined (HAVE_GETTIMEOFDAY)
3357 gettimeofday (struct timeval *tp, struct timezone *tzp)
3359 extern long time ();
3361 tp->tv_sec = time ((long *)0);
3364 tzp->tz_minuteswest = -1;
3368 #endif /* !HAVE_GETTIMEOFDAY */
3370 /* No need to encapsulate utime and utimes explicitly because all
3371 access to those functions goes through the following. */
3374 set_file_times (char *filename, EMACS_TIME atime, EMACS_TIME mtime)
3377 struct timeval tv[2];
3380 return utimes (filename, tv);
3381 #else /* not HAVE_UTIMES */
3383 utb.actime = EMACS_SECS (atime);
3384 utb.modtime = EMACS_SECS (mtime);
3385 return utime (filename, &utb);
3386 #endif /* not HAVE_UTIMES */
3391 static long ticks_per_second;
3392 static long orig_user_ticks, orig_system_ticks;
3393 EMACS_TIME orig_real_time;
3395 static int process_times_available;
3397 /* Return the relative user and system tick count. We try to
3398 maintain calculations in terms of integers as long as possible
3399 for increased accuracy. */
3402 get_process_times_1 (long *user_ticks, long *system_ticks)
3404 #if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WINDOWSNT)
3405 /* We have the POSIX times() function available. */
3408 *user_ticks = (long) tttt.tms_utime;
3409 *system_ticks = (long) tttt.tms_stime;
3411 #elif defined (CLOCKS_PER_SEC)
3412 *user_ticks = (long) clock ();
3421 init_process_times_very_early (void)
3423 #if defined (_SC_CLK_TCK)
3424 ticks_per_second = sysconf (_SC_CLK_TCK);
3425 #elif defined (CLK_TCK)
3426 ticks_per_second = CLK_TCK;
3427 #elif defined (CLOCKS_PER_SEC)
3428 ticks_per_second = CLOCKS_PER_SEC;
3431 process_times_available = get_process_times_1 (&orig_user_ticks,
3432 &orig_system_ticks);
3433 EMACS_GET_TIME (orig_real_time);
3436 /* Return the user and system times used up by this process so far. */
3438 get_process_times (double *user_time, double *system_time, double *real_time)
3440 EMACS_TIME curr_real_time;
3441 EMACS_TIME elapsed_time;
3442 long curr_user_ticks, curr_system_ticks;
3444 EMACS_GET_TIME (curr_real_time);
3445 EMACS_SUB_TIME (elapsed_time, curr_real_time, orig_real_time);
3446 *real_time = (EMACS_SECS (elapsed_time)
3447 + ((double) EMACS_USECS (elapsed_time)) / 1000000);
3448 if (get_process_times_1 (&curr_user_ticks, &curr_system_ticks))
3450 *user_time = (((double) (curr_user_ticks - orig_user_ticks))
3451 / ticks_per_second);
3452 *system_time = (((double) (curr_system_ticks - orig_system_ticks))
3453 / ticks_per_second);
3458 *user_time = *real_time;
3469 /* Figure out how many bits the system's random number generator uses.
3470 `random' and `lrand48' are assumed to return 31 usable bits.
3471 BSD `rand' returns a 31 bit value but the low order bits are unusable;
3472 so we'll shift it and treat it like the 15-bit USG `rand'. */
3476 # define RAND_BITS 31
3477 # else /* !HAVE_RANDOM */
3478 # ifdef HAVE_LRAND48
3479 # define RAND_BITS 31
3480 # define random lrand48
3481 # else /* !HAVE_LRAND48 */
3482 # define RAND_BITS 15
3483 # if RAND_MAX == 32767
3484 # define random rand
3485 # else /* RAND_MAX != 32767 */
3486 # if RAND_MAX == 2147483647
3487 # define random() (rand () >> 16)
3488 # else /* RAND_MAX != 2147483647 */
3490 # define random rand
3492 # define random() (rand () >> 16)
3494 # endif /* RAND_MAX != 2147483647 */
3495 # endif /* RAND_MAX != 32767 */
3496 # endif /* !HAVE_LRAND48 */
3497 # endif /* !HAVE_RANDOM */
3498 #endif /* !RAND_BITS */
3500 void seed_random (long arg);
3502 seed_random (long arg)
3505 srandom ((unsigned int)arg);
3507 # ifdef HAVE_LRAND48
3510 srand ((unsigned int)arg);
3516 * Build a full Emacs-sized word out of whatever we've got.
3517 * This suffices even for a 64-bit architecture with a 15-bit rand.
3519 long get_random (void);
3523 long val = random ();
3524 #if VALBITS > RAND_BITS
3525 val = (val << RAND_BITS) ^ random ();
3526 #if VALBITS > 2*RAND_BITS
3527 val = (val << RAND_BITS) ^ random ();
3528 #if VALBITS > 3*RAND_BITS
3529 val = (val << RAND_BITS) ^ random ();
3530 #if VALBITS > 4*RAND_BITS
3531 val = (val << RAND_BITS) ^ random ();
3532 #endif /* need at least 5 */
3533 #endif /* need at least 4 */
3534 #endif /* need at least 3 */
3535 #endif /* need at least 2 */
3536 return val & ((1L << VALBITS) - 1);
3540 /************************************************************************/
3541 /* Strings corresponding to defined signals */
3542 /************************************************************************/
3544 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
3546 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
3547 const char *sys_siglist[] =
3553 "illegal instruction",
3557 "floating point exception",
3560 "segmentation violation",
3561 "bad argument to system call",
3562 "write on a pipe with no one to read it",
3564 "software termination signal from kill",
3566 "sendable stop signal not from tty",
3567 "stop signal from tty",
3568 "continue a stopped process",
3569 "child status has changed",
3570 "background read attempted from control tty",
3571 "background write attempted from control tty",
3572 "input record available at control tty",
3573 "exceeded CPU time limit",
3574 "exceeded file size limit"
3580 const char *sys_siglist[NSIG + 1] =
3582 /* AIX has changed the signals a bit */
3583 DEFER_GETTEXT ("bogus signal"), /* 0 */
3584 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3585 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3586 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3587 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3588 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3589 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3590 DEFER_GETTEXT ("crash likely"), /* 7 SIGDANGER */
3591 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3592 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3593 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3594 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3595 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3596 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3597 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3598 DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */
3599 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3600 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3601 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3602 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3603 DEFER_GETTEXT ("bogus signal"), /* 20 */
3604 DEFER_GETTEXT ("bogus signal"), /* 21 */
3605 DEFER_GETTEXT ("bogus signal"), /* 22 */
3606 DEFER_GETTEXT ("bogus signal"), /* 23 */
3607 DEFER_GETTEXT ("bogus signal"), /* 24 */
3608 DEFER_GETTEXT ("LAN I/O interrupt"), /* 25 SIGAIO */
3609 DEFER_GETTEXT ("PTY I/O interrupt"), /* 26 SIGPTY */
3610 DEFER_GETTEXT ("I/O intervention required"), /* 27 SIGIOINT */
3612 DEFER_GETTEXT ("HFT grant"), /* 28 SIGGRANT */
3613 DEFER_GETTEXT ("HFT retract"), /* 29 SIGRETRACT */
3614 DEFER_GETTEXT ("HFT sound done"), /* 30 SIGSOUND */
3615 DEFER_GETTEXT ("HFT input ready"), /* 31 SIGMSG */
3619 #else /* USG, not AIX */
3620 const char *sys_siglist[NSIG + 1] =
3622 DEFER_GETTEXT ("bogus signal"), /* 0 */
3623 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3624 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3625 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3626 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3627 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3628 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3629 DEFER_GETTEXT ("EMT instruction"), /* 7 SIGEMT */
3630 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3631 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3632 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3633 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3634 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3635 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3636 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3637 DEFER_GETTEXT ("software termination signum"), /* 15 SIGTERM */
3638 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3639 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3640 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3641 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3643 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3644 DEFER_GETTEXT ("urgent socket condition"), /* 21 SIGURG */
3645 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3646 DEFER_GETTEXT ("stop (cannot be caught or ignored)"), /* 23 SIGSTOP */
3647 DEFER_GETTEXT ("user stop requested from tty"), /* 24 SIGTSTP */
3648 DEFER_GETTEXT ("stopped process has been continued"), /* 25 SIGCONT */
3649 DEFER_GETTEXT ("background tty read attempted"), /* 26 SIGTTIN */
3650 DEFER_GETTEXT ("background tty write attempted"), /* 27 SIGTTOU */
3651 DEFER_GETTEXT ("virtual timer expired"), /* 28 SIGVTALRM */
3652 DEFER_GETTEXT ("profiling timer expired"), /* 29 SIGPROF */
3653 DEFER_GETTEXT ("exceeded cpu limit"), /* 30 SIGXCPU */
3654 DEFER_GETTEXT ("exceeded file size limit"), /* 31 SIGXFSZ */
3655 DEFER_GETTEXT ("process's lwps are blocked"), /* 32 SIGWAITING */
3656 DEFER_GETTEXT ("special signal used by thread library"), /* 33 SIGLWP */
3658 DEFER_GETTEXT ("special signal used by CPR"), /* 34 SIGFREEZE */
3661 DEFER_GETTEXT ("special signal used by CPR"), /* 35 SIGTHAW */
3666 #endif /* not AIX */
3669 const char *sys_siglist[NSIG + 1] =
3671 DEFER_GETTEXT ("null signal"), /* 0 SIGNULL */
3672 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3673 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3674 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3675 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3676 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3677 DEFER_GETTEXT ("abort termination"), /* 6 SIGABRT */
3678 DEFER_GETTEXT ("SIGEMT"), /* 7 SIGEMT */
3679 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3680 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3681 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3682 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3683 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3684 DEFER_GETTEXT ("write on a pipe with no reader"), /* 13 SIGPIPE */
3685 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3686 DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */
3687 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3688 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3689 DEFER_GETTEXT ("child stopped or terminated"), /* 18 SIGCLD */
3690 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3691 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3692 DEFER_GETTEXT ("undefined"), /* 21 */
3693 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3694 DEFER_GETTEXT ("sendable stop signal not from tty"), /* 23 SIGSTOP */
3695 DEFER_GETTEXT ("stop signal from tty"), /* 24 SIGSTP */
3696 DEFER_GETTEXT ("continue a stopped process"), /* 25 SIGCONT */
3697 DEFER_GETTEXT ("attempted background tty read"), /* 26 SIGTTIN */
3698 DEFER_GETTEXT ("attempted background tty write"), /* 27 SIGTTOU */
3699 DEFER_GETTEXT ("undefined"), /* 28 */
3700 DEFER_GETTEXT ("undefined"), /* 29 */
3701 DEFER_GETTEXT ("undefined"), /* 30 */
3702 DEFER_GETTEXT ("undefined"), /* 31 */
3703 DEFER_GETTEXT ("undefined"), /* 32 */
3704 DEFER_GETTEXT ("socket (TCP/IP) urgent data arrival"), /* 33 SIGURG */
3705 DEFER_GETTEXT ("I/O is possible"), /* 34 SIGIO */
3706 DEFER_GETTEXT ("exceeded cpu time limit"), /* 35 SIGXCPU */
3707 DEFER_GETTEXT ("exceeded file size limit"), /* 36 SIGXFSZ */
3708 DEFER_GETTEXT ("virtual time alarm"), /* 37 SIGVTALRM */
3709 DEFER_GETTEXT ("profiling time alarm"), /* 38 SIGPROF */
3710 DEFER_GETTEXT ("undefined"), /* 39 */
3711 DEFER_GETTEXT ("file record locks revoked"), /* 40 SIGLOST */
3712 DEFER_GETTEXT ("undefined"), /* 41 */
3713 DEFER_GETTEXT ("undefined"), /* 42 */
3714 DEFER_GETTEXT ("undefined"), /* 43 */
3715 DEFER_GETTEXT ("undefined"), /* 44 */
3716 DEFER_GETTEXT ("undefined"), /* 45 */
3717 DEFER_GETTEXT ("undefined"), /* 46 */
3718 DEFER_GETTEXT ("undefined"), /* 47 */
3719 DEFER_GETTEXT ("undefined"), /* 48 */
3720 DEFER_GETTEXT ("undefined"), /* 49 */
3721 DEFER_GETTEXT ("undefined"), /* 50 */
3722 DEFER_GETTEXT ("undefined"), /* 51 */
3723 DEFER_GETTEXT ("undefined"), /* 52 */
3724 DEFER_GETTEXT ("undefined"), /* 53 */
3725 DEFER_GETTEXT ("undefined"), /* 54 */
3726 DEFER_GETTEXT ("undefined"), /* 55 */
3727 DEFER_GETTEXT ("undefined"), /* 56 */
3728 DEFER_GETTEXT ("undefined"), /* 57 */
3729 DEFER_GETTEXT ("undefined"), /* 58 */
3730 DEFER_GETTEXT ("undefined"), /* 59 */
3731 DEFER_GETTEXT ("undefined"), /* 60 */
3732 DEFER_GETTEXT ("undefined"), /* 61 */
3733 DEFER_GETTEXT ("undefined"), /* 62 */
3734 DEFER_GETTEXT ("undefined"), /* 63 */
3735 DEFER_GETTEXT ("notification message in mess. queue"), /* 64 SIGDGNOTIFY */
3740 #endif /* ! SYS_SIGLIST_DECLARED && ! HAVE_SYS_SIGLIST */
3743 /************************************************************************/
3744 /* Directory routines for systems that don't have them */
3745 /************************************************************************/
3747 #ifdef SYSV_SYSTEM_DIR
3751 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3753 closedir (DIR *dirp) /* stream from opendir */
3757 rtnval = sys_close (dirp->dd_fd);
3759 /* Some systems (like Solaris) allocate the buffer and the DIR all
3760 in one block. Why in the world are we freeing this ourselves
3762 #if ! (defined (sun) && defined (USG5_4))
3763 xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3765 xfree ((char *) dirp);
3768 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3769 #endif /* SYSV_SYSTEM_DIR */
3771 #ifdef NONSYSTEM_DIR_LIBRARY
3774 opendir (const char *filename) /* name of directory */
3776 DIR *dirp; /* -> malloc'ed storage */
3777 int fd; /* file descriptor for read */
3778 struct stat sbuf; /* result of fstat */
3780 fd = sys_open (filename, O_RDONLY);
3784 if (fstat (fd, &sbuf) < 0
3785 || (sbuf.st_mode & S_IFMT) != S_IFDIR
3786 || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3789 return 0; /* bad luck today */
3793 dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
3799 closedir (DIR *dirp) /* stream from opendir */
3801 sys_close (dirp->dd_fd);
3809 ino_t od_ino; /* inode */
3810 char od_name[DIRSIZ]; /* filename */
3813 static struct direct dir_static; /* simulated directory contents */
3817 readdir (DIR *dirp) /* stream from opendir */
3819 struct olddir *dp; /* -> directory data */
3823 if (dirp->dd_loc >= dirp->dd_size)
3824 dirp->dd_loc = dirp->dd_size = 0;
3826 if (dirp->dd_size == 0 /* refill buffer */
3827 && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3830 dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3831 dirp->dd_loc += sizeof (struct olddir);
3833 if (dp->od_ino != 0) /* not deleted entry */
3835 dir_static.d_ino = dp->od_ino;
3836 strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3837 dir_static.d_name[DIRSIZ] = '\0';
3838 dir_static.d_namlen = strlen (dir_static.d_name);
3839 dir_static.d_reclen = sizeof (struct direct)
3841 + dir_static.d_namlen - dir_static.d_namlen % 4;
3842 return &dir_static; /* -> simulated structure */
3848 #endif /* NONSYSTEM_DIR_LIBRARY */
3851 /* mkdir and rmdir functions, for systems which don't have them. */
3855 * Written by Robert Rother, Mariah Corporation, August 1985.
3857 * If you want it, it's yours. All I ask in return is that if you
3858 * figure out how to do this in a Bourne Shell script you send me
3860 * sdcsvax!rmr or rmr@uscd
3862 * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3863 * subroutine. 11Mar86; hoptoad!gnu
3865 * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3866 * subroutine didn't return EEXIST. It does now.
3872 #ifdef MKDIR_PROTOTYPE
3876 mkdir (const char *dpath, int dmode)
3879 int cpid, status, fd;
3880 struct stat statbuf;
3882 if (stat (dpath, &statbuf) == 0)
3884 errno = EEXIST; /* Stat worked, so it already exists */
3888 /* If stat fails for a reason other than non-existence, return error */
3889 if (errno != ENOENT)
3892 synch_process_alive = 1;
3893 switch (cpid = fork ())
3896 case -1: /* Error in fork() */
3897 return -1; /* Errno is set already */
3899 case 0: /* Child process */
3902 * Cheap hack to set mode of new directory. Since this
3903 * child process is going away anyway, we zap its umask.
3904 * ####, this won't suffice to set SUID, SGID, etc. on this
3905 * directory. Does anybody care?
3907 status = umask (0); /* Get current umask */
3908 status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
3909 fd = sys_open ("/dev/null", O_RDWR);
3912 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3913 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3914 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3916 execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3917 _exit (-1); /* Can't exec /bin/mkdir */
3920 default: /* Parent process */
3921 wait_for_termination (cpid);
3924 if (synch_process_death != 0 || synch_process_retcode != 0)
3926 errno = EIO; /* We don't know why, but */
3927 return -1; /* /bin/mkdir failed */
3932 #endif /* not HAVE_MKDIR */
3936 rmdir (const char *dpath)
3938 int cpid, status, fd;
3939 struct stat statbuf;
3941 if (stat (dpath, &statbuf) != 0)
3943 /* Stat just set errno. We don't have to */
3947 synch_process_alive = 1;
3948 switch (cpid = fork ())
3951 case -1: /* Error in fork() */
3952 return (-1); /* Errno is set already */
3954 case 0: /* Child process */
3955 fd = sys_open("/dev/null", O_RDWR);
3958 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3959 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3960 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3962 execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3963 _exit (-1); /* Can't exec /bin/mkdir */
3965 default: /* Parent process */
3966 wait_for_termination (cpid);
3969 if (synch_process_death != 0 ||
3970 synch_process_retcode != 0)
3972 errno = EIO; /* We don't know why, but */
3973 return -1; /* /bin/rmdir failed */
3978 #endif /* !HAVE_RMDIR */
3981 /************************************************************************/
3982 /* Misc. SunOS crap */
3983 /************************************************************************/
3987 /* These are included on Sunos 4.1 when we do not use shared libraries.
3988 X11 libraries may refer to these functions but (we hope) do not
3989 actually call them. */
4009 #endif /* USE_DL_STUBS */
4013 #ifndef HAVE_STRCASECMP
4017 static unsigned char charmap[] = {
4018 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
4019 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
4020 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
4021 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
4022 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
4023 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
4024 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
4025 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
4026 '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
4027 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
4028 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
4029 '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
4030 '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
4031 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
4032 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
4033 '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
4034 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
4035 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
4036 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
4037 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
4038 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
4039 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
4040 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
4041 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
4042 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
4043 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
4044 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
4045 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
4046 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
4047 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
4048 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
4049 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
4053 strcasecmp (char *s1, char *s2)
4055 unsigned char *cm = charmap;
4056 unsigned char *us1 = (unsigned char *) s1;
4057 unsigned char *us2 = (unsigned char *)s2;
4059 while (cm[*us1] == cm[*us2++])
4063 return (cm[*us1] - cm[*--us2]);
4065 #endif /* !HAVE_STRCASECMP */