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
36 #include <../mingw/process.h>
38 /* <process.h> should not conflict with "process.h", as per ANSI definition.
39 This is not true with visual c though. The trick below works with
40 VC4.2b, 5.0 and 6.0. It assumes that VC is installed in a kind of
41 standard way, so include path ends with /include.
43 Unfortunately, this must go before lisp.h, since process.h defines abort()
44 which will conflict with the macro defined in lisp.h
46 #include <../include/process.h>
48 #endif /* WIN32_NATIVE */
52 /* ------------------------------- */
54 /* ------------------------------- */
57 #include "console-tty.h"
59 #include "syssignal.h"
63 #include "console-stream.h"
68 #include "redisplay.h"
74 #ifdef HAVE_LIBGEN_H /* Must come before sysfile.h */
81 #if defined(WIN32_NATIVE) || defined(CYGWIN)
82 #include "syssignal.h"
88 #include <sys/times.h>
92 #include <sys/utime.h>
97 /* ------------------------------- */
99 /* ------------------------------- */
102 #include <sys/utsname.h>
103 #if defined (TIOCGWINSZ) || defined (ISC4_0)
105 #include <sys/sioctl.h>
108 #include <sys/stream.h>
109 #include <sys/ptem.h>
111 #endif /* TIOCGWINSZ or ISC4_0 */
114 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */
125 static int baud_convert[] =
130 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
131 1800, 2400, 4800, 9600, 19200, 38400
138 static void hft_init (struct console *c);
139 static void hft_reset (struct console *c);
140 #include <sys/termio.h>
144 /************************************************************************/
145 /* subprocess control */
146 /************************************************************************/
152 /* Arrange for character C to be read as the next input from
155 stuff_char (struct console *con, int c)
159 assert (CONSOLE_TTY_P (con));
160 input_fd = CONSOLE_TTY_DATA (con)->infd;
161 /* Should perhaps error if in batch mode */
163 ioctl (input_fd, TIOCSTI, &c);
164 #else /* no TIOCSTI */
165 error ("Cannot stuff terminal input characters in this version of Unix.");
166 #endif /* no TIOCSTI */
171 #endif /* HAVE_TTY */
174 set_exclusive_use (int fd)
177 ioctl (fd, FIOCLEX, 0);
179 /* Ok to do nothing if this feature does not exist */
183 set_descriptor_non_blocking (int fd)
185 /* Stride people say it's a mystery why this is needed
186 as well as the O_NDELAY, but that it fails without this. */
187 /* For AIX: Apparently need this for non-blocking reads on sockets.
188 It seems that O_NONBLOCK applies only to FIFOs? From
189 lowry@watson.ibm.com (Andy Lowry). */
190 /* #### Should this be conditionalized on FIONBIO? */
191 #if defined (STRIDE) || (defined (pfa) && defined (HAVE_PTYS)) || defined (AIX)
194 ioctl (fd, FIONBIO, &one);
199 fcntl (fd, F_SETFL, O_NONBLOCK);
203 #if defined (NO_SUBPROCESSES)
207 wait_without_blocking (void)
209 wait3 (0, WNOHANG | WUNTRACED, 0);
210 synch_process_alive = 0;
214 #endif /* NO_SUBPROCESSES */
218 void wait_for_termination (HANDLE pHandle)
220 void wait_for_termination (int pid)
223 /* #### With the new improved SIGCHLD handling stuff, there is much
224 less danger of race conditions and some of the comments below
225 don't apply. This should be updated. */
227 #if defined (NO_SUBPROCESSES)
230 /* No need to be tricky like below; we can just call wait(). */
231 /* #### should figure out how to write a wait_allowing_quit().
232 Since hardly any systems don't have subprocess support,
233 however, there doesn't seem to be much point. */
237 #elif defined (HAVE_WAITPID)
238 /* Note that, whenever any subprocess terminates (asynch. or synch.),
239 the SIGCHLD handler will be called and it will call wait(). Thus
240 we cannot just call wait() ourselves, and we can't block SIGCHLD
241 and then call wait(), because then if an asynch. process dies
242 while we're waiting for our synch. process, Emacs will never
243 notice that the asynch. process died.
245 So, the general approach we take is to repeatedly block until a
246 signal arrives, and then check if our process died using kill
247 (pid, 0). (We could also check the value of `synch_process_alive',
248 since the SIGCHLD handler will reset that and we know that we're
249 only being called on synchronous processes, but this approach is
250 safer. I don't trust the proper delivery of SIGCHLD.
252 Note also that we cannot use any form of waitpid(). A loop with
253 WNOHANG will chew up CPU time; better to use sleep(). A loop
254 without WNOWAIT will screw up the SIGCHLD handler (actually this
255 is not true, if you duplicate the exit-status-reaping code; see
256 below). A loop with WNOWAIT will result in a race condition if
257 the process terminates between the process-status check and the
258 call to waitpid(). */
260 /* Formerly, immediate_quit was set around this function call, but
261 that could lead to problems if the QUIT happened when SIGCHLD was
262 blocked -- it would remain blocked. Yet another reason why
263 immediate_quit is a bad idea. In any case, there is no reason to
264 resort to this because either the SIGIO or the SIGALRM will stop
265 the block in EMACS_WAIT_FOR_SIGNAL(). */
267 /* Apparently there are bugs on some systems with the second method
268 used below (the EMACS_BLOCK_SIGNAL method), whereby zombie
269 processes get left around. It appears in those cases that the
270 SIGCHLD handler is never getting invoked. It's not clear whether
271 this is an Emacs bug or a kernel bug or both: on HPUX this
272 problem is observed only with XEmacs, but under Solaris 2.4 all
273 sorts of different programs have problems with zombies. The
274 method we use here does not require a working SIGCHLD (but will
275 not break if it is working), and should be safe. */
277 We use waitpid(), contrary to the remarks above. There is no
278 race condition, because the three situations when sigchld_handler
279 is invoked should be handled OK:
281 - handler invoked before waitpid(): In this case, subprocess
282 status will be set by sigchld_handler. waitpid() here will
283 return -1 with errno set to ECHILD, which is a valid exit
286 - handler invoked during waitpid(): as above, except that errno
287 here will be set to EINTR. This will cause waitpid() to be
288 called again, and this time it will exit with ECHILD.
290 - handler invoked after waitpid(): The following code will reap
291 the subprocess. In the handler, wait() will return -1 because
292 there is no child to reap, and the handler will exit without
293 modifying child subprocess status. */
296 /* Because the SIGCHLD handler can potentially reap the synchronous
297 subprocess, we should take care of that. */
299 /* Will stay in the do loop as long as:
301 2. Ctrl-G is not pressed */
305 ret = waitpid (pid, &status, 0);
306 /* waitpid returns 0 if the process is still alive. */
308 while (ret == 0 || (ret == -1 && errno == EINTR));
310 if (ret == pid) /* Success */
311 /* Set synch process globals. This is can also happen
312 in sigchld_handler, and that code is duplicated. */
314 synch_process_alive = 0;
315 if (WIFEXITED (status))
316 synch_process_retcode = WEXITSTATUS (status);
317 else if (WIFSIGNALED (status))
318 synch_process_death = signal_name (WTERMSIG (status));
320 /* On exiting the loop, ret will be -1, with errno set to ECHILD if
321 the child has already been reaped, e.g. in the signal handler. */
323 /* Otherwise, we've had some error condition here.
324 Per POSIX, the only other possibilities are:
325 - EFAULT (bus error accessing arg 2) or
326 - EINVAL (incorrect arguments),
327 which are both program bugs.
329 Since implementations may add their own error indicators on top,
330 we ignore it by default. */
331 #elif defined (WIN32_NATIVE)
332 int ret = 0, status = 0;
335 warn_when_safe (Qprocess, Qwarning, "Cannot wait for unknown process to terminate");
341 ret = WaitForSingleObject(pHandle, 100);
343 while (ret == WAIT_TIMEOUT);
344 if (ret == WAIT_FAILED)
346 warn_when_safe (Qprocess, Qwarning, "waiting for process failed");
348 if (ret == WAIT_ABANDONED)
350 warn_when_safe (Qprocess, Qwarning,
351 "process to wait for has been abandoned");
353 if (ret == WAIT_OBJECT_0)
355 ret = GetExitCodeProcess(pHandle, &status);
358 synch_process_alive = 0;
359 synch_process_retcode = status;
363 /* GetExitCodeProcess() didn't return a valid exit status,
364 nothing to do. APA */
365 warn_when_safe (Qprocess, Qwarning,
366 "failure to obtain process exit value");
369 if (pHandle != NULL && !CloseHandle(pHandle))
371 warn_when_safe (Qprocess, Qwarning,
372 "failure to close unknown process");
374 #elif defined (EMACS_BLOCK_SIGNAL) && !defined (BROKEN_WAIT_FOR_SIGNAL) && defined (SIGCHLD)
377 static int wait_debugging = 0; /* Set nonzero to make following
378 function work under dbx (at least for bsd). */
383 EMACS_BLOCK_SIGNAL (SIGCHLD);
384 /* Block SIGCHLD from happening during this check,
385 to avoid race conditions. */
386 if (kill (pid, 0) < 0)
388 EMACS_UNBLOCK_SIGNAL (SIGCHLD);
392 /* WARNING: Whatever this macro does *must* not allow SIGCHLD
393 to happen between the time that it's reenabled and when we
394 begin to block. Otherwise we may end up blocking for a
395 signal that has already arrived and isn't coming again.
396 Can you say "race condition"?
398 I assume that the system calls sigpause() or sigsuspend()
399 to provide this atomicness. If you're getting hangs in
400 sigpause()/sigsuspend(), then your OS doesn't implement
401 this properly (this applies under hpux9, for example).
402 Try defining BROKEN_WAIT_FOR_SIGNAL. */
403 EMACS_WAIT_FOR_SIGNAL (SIGCHLD);
405 #else /* not HAVE_WAITPID and not WIN32_NATIVE and (not EMACS_BLOCK_SIGNAL or BROKEN_WAIT_FOR_SIGNAL) */
406 /* This approach is kind of cheesy but is guaranteed(?!) to work
411 if (kill (pid, 0) < 0)
415 #endif /* OS features */
419 #if !defined (NO_SUBPROCESSES)
422 * flush any pending output
423 * (may flush input as well; it does not matter the way we use it)
427 flush_pending_output (int channel)
430 /* If we try this, we get hit with SIGTTIN, because
431 the child's tty belongs to the child's pgrp. */
432 #elif defined (TCFLSH)
433 ioctl (channel, TCFLSH, 1);
434 #elif defined (TIOCFLUSH)
436 /* 3rd arg should be ignored
437 but some 4.2 kernels actually want the address of an int
438 and nonzero means something different. */
439 ioctl (channel, TIOCFLUSH, &zero);
444 /* Set up the terminal at the other end of a pseudo-terminal that
445 we will be controlling an inferior through.
446 It should not echo or do line-editing, since that is done
447 in Emacs. No padding needed for insertion into an Emacs buffer. */
450 child_setup_tty (int out)
453 emacs_get_tty (out, &s);
455 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
456 assert (isatty(out));
457 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
458 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
460 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
461 /* No output delays */
463 s.main.c_lflag &= ~ECHO; /* Disable echo */
464 s.main.c_lflag |= ISIG; /* Enable signals */
466 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
469 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
471 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
472 #if defined (CSIZE) && defined (CS8)
473 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
476 s.main.c_iflag &= ~ISTRIP; /* Don't strip 8th bit on input */
479 /* Unnecessary as long as ICANON is set */
480 s.main.c_cc[VMIN] = 1; /* minimum number of characters to accept */
481 s.main.c_cc[VTIME] = 0; /* wait forever for at least 1 character */
484 s.main.c_lflag |= ICANON; /* Enable erase/kill and eof processing */
485 s.main.c_cc[VEOF] = 04; /* ensure that EOF is Control-D */
486 s.main.c_cc[VERASE] = _POSIX_VDISABLE; /* disable erase processing */
487 s.main.c_cc[VKILL] = _POSIX_VDISABLE; /* disable kill processing */
490 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
495 /* AIX enhanced edit loses NULs, so disable it. */
497 s.main.c_iflag &= ~ASCEDIT;
498 #endif /* IBMR2AIX */
499 /* Also, PTY overloads NUL and BREAK.
500 don't ignore break, but don't signal either, so it looks like NUL.
501 This really serves a purpose only if running in an XTERM window
502 or via TELNET or the like, but does no harm elsewhere. */
503 s.main.c_iflag &= ~IGNBRK;
504 s.main.c_iflag &= ~BRKINT;
506 #ifdef SIGNALS_VIA_CHARACTERS
507 /* TTY `special characters' are used in process_send_signal
508 so set them here to something useful. */
509 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
510 s.main.c_cc[VINTR] = 'C' &037; /* Control-C */
511 s.main.c_cc[VSUSP] = 'Z' &037; /* Control-Z */
512 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
513 /* TTY `special characters' work better as signals, so disable
515 s.main.c_cc[VQUIT] = _POSIX_VDISABLE;
516 s.main.c_cc[VINTR] = _POSIX_VDISABLE;
517 s.main.c_cc[VSUSP] = _POSIX_VDISABLE;
518 s.main.c_lflag &= ~ISIG;
519 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
520 s.main.c_cc[VEOL] = _POSIX_VDISABLE;
522 /* <mdiers> #### This is not portable. ###
523 POSIX does not specify CBAUD, and 4.4BSD does not have it.
524 Instead, POSIX suggests to use cfset{i,o}speed().
525 [cf. D. Lewine, POSIX Programmer's Guide, Chapter 8: Terminal
526 I/O, O'Reilly 1991] */
527 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
529 /* <mdiers> What to do upon failure? Just ignoring rc is probably
530 not acceptable, is it? */
531 if (cfsetispeed (&s.main, B9600) == -1) /* ignore */;
532 if (cfsetospeed (&s.main, B9600) == -1) /* ignore */;
533 #endif /* defined (CBAUD) */
535 #else /* not HAVE_TERMIO */
537 s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
539 s.main.sg_flags |= LPASS8;
540 s.main.sg_erase = 0377;
541 s.main.sg_kill = 0377;
542 s.lmode = LLITOUT | s.lmode; /* Don't strip 8th bit */
544 #endif /* not HAVE_TERMIO */
545 emacs_set_tty (out, &s, 0);
550 ioctl (out, FIOASYNC, &zero);
554 #endif /* WIN32_NATIVE */
556 #endif /* not NO_SUBPROCESSES */
559 #if !defined (SIGTSTP) && !defined (USG_JOBCTRL)
561 #if defined(__STDC__) || defined(_MSC_VER)
562 #define SIG_PARAM_TYPE int
564 #define SIG_PARAM_TYPE
567 /* Record a signal code and the handler for it. */
571 SIGTYPE (*handler) (SIG_PARAM_TYPE);
575 save_signal_handlers (struct save_signal *saved_handlers)
577 while (saved_handlers->code)
579 saved_handlers->handler
580 = (SIGTYPE (*) (SIG_PARAM_TYPE)) signal (saved_handlers->code, SIG_IGN);
586 restore_signal_handlers (struct save_signal *saved_handlers)
588 while (saved_handlers->code)
590 signal (saved_handlers->code, saved_handlers->handler);
600 return abs (getpid ());
603 #endif /* WIN32_NATIVE */
605 /* Fork a subshell. */
612 struct save_signal saved_handlers[5];
614 unsigned char *str = 0;
618 saved_handlers[0].code = SIGINT;
619 saved_handlers[1].code = SIGQUIT;
620 saved_handlers[2].code = SIGTERM;
622 saved_handlers[3].code = SIGIO;
623 saved_handlers[4].code = 0;
625 saved_handlers[3].code = 0;
628 /* Mentioning current_buffer->buffer would mean including buffer.h,
629 which somehow wedges the hp compiler. So instead... */
631 if (NILP (Fboundp (Qdefault_directory)))
633 dir = Fsymbol_value (Qdefault_directory);
638 dir = Funhandled_file_name_directory (dir);
639 dir = expand_and_dir_to_file (dir, Qnil);
641 str = (unsigned char *) alloca (XSTRING_LENGTH (dir) + 2);
642 len = XSTRING_LENGTH (dir);
643 memcpy (str, XSTRING_DATA (dir), len);
644 if (!IS_ANY_SEP (str[len - 1]))
645 str[len++] = DIRECTORY_SEP;
653 error ("Can't spawn subshell");
655 #endif /* not WIN32_NATIVE */
660 sh = (char *) egetenv ("SHELL");
664 /* Use our buffer's default directory for the subshell. */
670 /* Waits for process completion */
671 if (_spawnlp (_P_WAIT, sh, sh, NULL) != 0)
672 error ("Can't spawn subshell");
674 return; /* we're done, no need to wait for termination */
679 #if !defined (NO_SUBPROCESSES)
680 close_process_descs (); /* Close Emacs's pipes/ptys */
683 #ifdef SET_EMACS_PRIORITY
684 if (emacs_priority != 0)
685 nice (-emacs_priority); /* Give the new shell the default priority */
689 write (1, "Can't execute subshell", 22);
693 save_signal_handlers (saved_handlers);
694 synch_process_alive = 1;
695 wait_for_termination (pid);
696 restore_signal_handlers (saved_handlers);
698 #endif /* not WIN32_NATIVE */
702 #endif /* !defined (SIGTSTP) && !defined (USG_JOBCTRL) */
706 /* Suspend the Emacs process; give terminal to its superior. */
710 #if defined (SIGTSTP)
712 int pgrp = EMACS_GET_PROCESS_GROUP ();
713 EMACS_KILLPG (pgrp, SIGTSTP);
716 #elif defined (USG_JOBCTRL)
717 /* If you don't know what this is don't mess with it */
718 ptrace (0, 0, 0, 0); /* set for ptrace - caught by csh */
719 kill (getpid (), SIGQUIT);
721 #else /* No SIGTSTP or USG_JOBCTRL */
723 /* On a system where suspending is not implemented,
724 instead fork a subshell and let it talk directly to the terminal
731 /* Suspend a process if possible; give terminal to its superior. */
733 sys_suspend_process (int process)
735 /* I don't doubt that it is possible to suspend processes on
736 * VMS machines or thost that use USG_JOBCTRL,
737 * but I don't know how to do it, so...
739 #if defined (SIGTSTP)
740 kill(process, SIGTSTP);
745 /* Given FD, obtain pty buffer size. When no luck, a good guess is made,
746 so that the function works even when fd is not a pty. */
749 get_pty_max_bytes (int fd)
751 /* DEC OSF 4.0 fpathconf returns 255, but xemacs hangs on long shell
752 input lines if we return 253. 252 is OK!. So let's leave a bit
753 of slack for the newline that xemacs will insert, and for those
754 inevitable vendor off-by-one-or-two-or-three bugs. */
755 #define MAX_CANON_SLACK 10
756 #define SAFE_MAX_CANON (127 - MAX_CANON_SLACK)
757 #if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
759 int max_canon = fpathconf (fd, _PC_MAX_CANON);
761 /* HP-UX 10.20 fpathconf returns 768, but this results in
762 truncated input lines, while 255 works. */
763 if (max_canon > 255) max_canon = 255;
765 return (max_canon < 0 ? SAFE_MAX_CANON :
766 max_canon > SAFE_MAX_CANON ? max_canon - MAX_CANON_SLACK :
769 #elif defined (_POSIX_MAX_CANON)
770 return (_POSIX_MAX_CANON > SAFE_MAX_CANON ?
771 _POSIX_MAX_CANON - MAX_CANON_SLACK :
774 return SAFE_MAX_CANON;
778 /* Figure out the eof character for the FD. */
781 get_eof_char (int fd)
783 const Bufbyte ctrl_d = (Bufbyte) '\004';
792 /* What is the following line designed to do??? -mrb */
793 if (strlen ((const char *) t.c_cc) < (unsigned int) (VEOF + 1))
796 return (Bufbyte) t.c_cc[VEOF];
798 return t.c_cc[VEOF] == _POSIX_VDISABLE ? ctrl_d : (Bufbyte) t.c_cc[VEOF];
800 #else /* ! HAVE_TERMIOS */
801 /* On Berkeley descendants, the following IOCTL's retrieve the
802 current control characters. */
803 #if defined (TIOCGETC)
806 ioctl (fd, TIOCGETC, &c);
807 return (Bufbyte) c.t_eofc;
809 #else /* ! defined (TIOCGLTC) && defined (TIOCGETC) */
810 /* On SYSV descendants, the TCGETA ioctl retrieves the current control
815 ioctl (fd, TCGETA, &t);
816 if (strlen ((const char *) t.c_cc) < (unsigned int) (VINTR + 1))
819 return (Bufbyte) t.c_cc[VINTR];
821 #else /* ! defined (TCGETA) */
822 /* Rather than complain, we'll just guess ^D, which is what
823 * earlier emacsen always used. */
825 #endif /* ! defined (TCGETA) */
826 #endif /* ! defined (TIOCGETC) */
827 #endif /* ! defined (HAVE_TERMIOS) */
830 /* Set the logical window size associated with descriptor FD
831 to HEIGHT and WIDTH. This is used mainly with ptys. */
834 set_window_size (int fd, int height, int width)
840 size.ws_row = height;
843 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
844 return 0; /* error */
848 #elif defined (TIOCSSIZE)
852 size.ts_lines = height;
853 size.ts_cols = width;
855 if (ioctl (fd, TIOCGSIZE, &size) == -1)
866 /* Set up the proper status flags for use of a pty. */
871 /* I'm told that TIOCREMOTE does not mean control chars
872 "can't be sent" but rather that they don't have
873 input-editing or signaling effects.
874 That should be good, because we have other ways
875 to do those things in Emacs.
876 However, telnet mode seems not to work on 4.2.
877 So TIOCREMOTE is turned off now. */
879 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
880 will hang. In particular, the "timeout" feature (which
881 causes a read to return if there is no data available)
882 does this. Also it is known that telnet mode will hang
883 in such a way that Emacs must be stopped (perhaps this
884 is the same problem).
886 If TIOCREMOTE is turned off, then there is a bug in
887 hp-ux which sometimes loses data. Apparently the
888 code which blocks the master process when the internal
889 buffer fills up does not work. Other than this,
890 though, everything else seems to work fine.
892 Since the latter lossage is more benign, we may as well
893 lose that way. -- cph */
894 #if defined (FIONBIO) && defined (SYSV_PTYS)
897 ioctl (fd, FIONBIO, &on);
901 /* On AIX, the parent gets SIGHUP when a pty attached child dies. So, we */
902 /* ignore SIGHUP once we've started a child on a pty. Note that this may */
903 /* cause EMACS not to die when it should, i.e., when its own controlling */
904 /* tty goes away. I've complained to the AIX developers, and they may */
905 /* change this behavior, but I'm not going to hold my breath. */
906 signal (SIGHUP, SIG_IGN);
909 /* In some systems (Linux through 2.0.0, at least), packet mode doesn't
910 get cleared when a pty is closed, so we need to clear it here.
911 Linux pre2.0.13 contained an attempted fix for this (from Ted Ts'o,
912 tytso@mit.edu), but apparently it messed up rlogind and telnetd, so he
913 removed the fix in pre2.0.14. - dkindred@cs.cmu.edu
917 ioctl (fd, TIOCPKT, (char *)&off);
921 #endif /* HAVE_PTYS */
924 /************************************************************************/
926 /************************************************************************/
928 /* ------------------------------------------------------ */
930 /* ------------------------------------------------------ */
932 /* It really makes more sense for the baud-rate to be console-specific
933 and not device-specific, but it's (at least potentially) used for output
937 init_baud_rate (struct device *d)
939 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
940 if (DEVICE_WIN_P (d) || DEVICE_STREAM_P (d))
942 DEVICE_BAUD_RATE (d) = 38400;
947 assert (DEVICE_TTY_P (d));
949 int input_fd = CONSOLE_TTY_DATA (con)->infd;
950 #if defined (WIN32_NATIVE)
951 DEVICE_TTY_DATA (d)->ospeed = 15;
952 #elif defined (HAVE_TERMIOS)
956 tcgetattr (input_fd, &sg);
957 DEVICE_TTY_DATA (d)->ospeed = cfgetospeed (&sg);
958 # if defined (USE_GETOBAUD) && defined (getobaud)
959 /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
960 if (DEVICE_TTY_DATA (d)->ospeed == 0)
961 DEVICE_TTY_DATA (d)->ospeed = getobaud (sg.c_cflag);
963 #elif defined (HAVE_TERMIO)
968 tcgetattr (input_fd, &sg);
970 ioctl (input_fd, TCGETA, &sg);
972 DEVICE_TTY_DATA (d)->ospeed = sg.c_cflag & CBAUD;
973 #else /* neither TERMIOS nor TERMIO */
976 sg.sg_ospeed = B9600;
977 if (ioctl (input_fd, TIOCGETP, &sg) < 0)
979 DEVICE_TTY_DATA (d)->ospeed = sg.sg_ospeed;
983 DEVICE_BAUD_RATE (d) =
984 (DEVICE_TTY_DATA (d)->ospeed < countof (baud_convert)
985 ? baud_convert[DEVICE_TTY_DATA (d)->ospeed]
988 if (DEVICE_BAUD_RATE (d) == 0)
989 DEVICE_BAUD_RATE (d) = 1200;
990 #endif /* HAVE_TTY */
994 /* ------------------------------------------------------ */
996 /* ------------------------------------------------------ */
998 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1001 init_sigio_on_device (struct device *d)
1003 int filedesc = DEVICE_INFD (d);
1005 #if defined (FIOSSAIOOWN)
1007 int owner = getpid ();
1009 if (DEVICE_TTY_P (d))
1011 ioctl_status = ioctl (filedesc, FIOGSAIOOWN,
1012 &DEVICE_OLD_FCNTL_OWNER (d));
1013 ioctl_status = ioctl (filedesc, FIOSSAIOOWN, &owner);
1015 #ifdef HAVE_WINDOW_SYSTEM
1016 else if (!DEVICE_STREAM_P (d))
1018 ioctl_status = ioctl (filedesc, SIOCGPGRP,
1019 &DEVICE_OLD_FCNTL_OWNER (d));
1020 ioctl_status = ioctl (filedesc, SIOCSPGRP, &owner);
1024 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1025 DEVICE_OLD_FCNTL_OWNER (d) = fcntl (filedesc, F_GETOWN, 0);
1026 # ifdef F_SETOWN_SOCK_NEG
1027 /* stdin is a socket here */
1028 fcntl (filedesc, F_SETOWN, -getpid ());
1030 fcntl (filedesc, F_SETOWN, getpid ());
1036 reset_sigio_on_device (struct device *d)
1038 int filedesc = DEVICE_INFD (d);
1040 #if defined (FIOSSAIOOWN)
1043 if (DEVICE_TTY_P (d))
1045 ioctl_status = ioctl (filedesc, FIOSSAIOOWN,
1046 &DEVICE_OLD_FCNTL_OWNER (d));
1048 #ifdef HAVE_WINDOW_SYSTEM
1049 else if (!DEVICE_STREAM_P (d))
1051 ioctl_status = ioctl (filedesc, SIOCSPGRP,
1052 &DEVICE_OLD_FCNTL_OWNER (d));
1056 #elif defined (F_SETOWN) && !defined (F_SETOWN_BUG)
1057 fcntl (filedesc, F_SETOWN, DEVICE_OLD_FCNTL_OWNER (d));
1062 request_sigio_on_device (struct device *d)
1064 int filedesc = DEVICE_INFD (d);
1066 #if defined (I_SETSIG) && !defined(HPUX10) && !defined(LINUX)
1069 ioctl (filedesc, I_GETSIG, &events);
1070 ioctl (filedesc, I_SETSIG, events | S_INPUT);
1072 #elif defined (FASYNC)
1073 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) | FASYNC);
1074 #elif defined (FIOSSAIOSTAT)
1076 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1077 sockets and other devices for some bizarre reason. We guess
1078 that an X device is a socket, and tty devices aren't. We then
1079 use the following crud to do the appropriate thing. */
1081 int ioctl_status; /* ####DG: check if IOCTL succeeds here. */
1083 if (DEVICE_TTY_P (d))
1085 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &on);
1087 #ifdef HAVE_WINDOW_SYSTEM
1088 else if (!DEVICE_STREAM_P (d))
1090 ioctl_status = ioctl (filedesc, FIOASYNC, &on);
1094 #elif defined (FIOASYNC)
1097 ioctl (filedesc, FIOASYNC, &on);
1101 #if defined (_CX_UX) /* #### Is this crap necessary? */
1102 EMACS_UNBLOCK_SIGNAL (SIGIO);
1107 unrequest_sigio_on_device (struct device *d)
1109 int filedesc = DEVICE_INFD (d);
1111 #if defined (I_SETSIG) && !defined(HPUX10)
1114 ioctl (filedesc, I_GETSIG, &events);
1115 ioctl (filedesc, I_SETSIG, events & ~S_INPUT);
1117 #elif defined (FASYNC)
1118 fcntl (filedesc, F_SETFL, fcntl (filedesc, F_GETFL, 0) & ~FASYNC);
1119 #elif defined (FIOSSAIOSTAT)
1121 /* DG: Changed for HP-UX. HP-UX uses different IOCTLs for
1122 sockets and other devices for some bizarre reason. We guess
1123 that an X device is a socket, and tty devices aren't. We then
1124 use the following crud to do the appropriate thing. */
1129 /* See comment for request_sigio_on_device */
1131 if (DEVICE_TTY_P (d))
1133 ioctl_status = ioctl (filedesc, FIOSSAIOSTAT, &off);
1137 ioctl_status = ioctl (filedesc, FIOASYNC, &off);
1140 #elif defined (FIOASYNC)
1143 ioctl (filedesc, FIOASYNC, &off);
1149 request_sigio (void)
1151 Lisp_Object devcons, concons;
1153 DEVICE_LOOP_NO_BREAK (devcons, concons)
1157 d = XDEVICE (XCAR (devcons));
1159 if (!DEVICE_STREAM_P (d))
1160 request_sigio_on_device (d);
1165 unrequest_sigio (void)
1167 Lisp_Object devcons, concons;
1169 DEVICE_LOOP_NO_BREAK (devcons, concons)
1173 d = XDEVICE (XCAR (devcons));
1175 if (!DEVICE_STREAM_P (d))
1176 unrequest_sigio_on_device (d);
1182 /* ------------------------------------------------------ */
1183 /* Changing Emacs's process group */
1184 /* ------------------------------------------------------ */
1186 /* Saving and restoring the process group of Emacs's terminal. */
1188 /* On some systems, apparently (?!) Emacs must be in its own process
1189 group in order to receive SIGIO correctly. On other systems
1190 (e.g. Solaris), it's not required and doing it makes things
1191 get fucked up. So, we only do it when
1192 SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP is defined. Basically,
1193 this is only required for BSD 4.2 systems. (Actually, I bet
1194 we don't have to do this at all -- those systems also
1195 required interrupt input, which we don't support.)
1197 If Emacs was in its own process group (i.e. inherited_pgroup ==
1198 getpid ()), then we know we're running under a shell with job
1199 control (Emacs would never be run as part of a pipeline).
1202 If Emacs was not in its own process group, then we know we're
1203 running under a shell (or a caller) that doesn't know how to
1204 separate itself from Emacs (like sh). Emacs must be in its own
1205 process group in order to receive SIGIO correctly. In this
1206 situation, we put ourselves in our own pgroup, forcibly set the
1207 tty's pgroup to our pgroup, and make sure to restore and reinstate
1208 the tty's pgroup just like any other terminal setting. If
1209 inherited_group was not the tty's pgroup, then we'll get a
1210 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1211 it goes foreground in the future, which is what should happen. */
1213 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1215 static pid_t inherited_pgroup;
1216 static pid_t inherited_tty_pgroup;
1221 munge_tty_process_group (void)
1223 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1227 /* Only do this munging if we have a device on the controlling
1228 terminal. See the large comment below. */
1230 if (CONSOLEP (Vcontrolling_terminal) &&
1231 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1233 int fd = open ("/dev/tty", O_RDWR, 0);
1234 pid_t me = getpid ();
1235 EMACS_BLOCK_SIGNAL (SIGTTOU);
1236 EMACS_SET_TTY_PROCESS_GROUP (fd, &me);
1237 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1243 /* Split off the foreground process group to Emacs alone.
1244 When we are in the foreground, but not started in our own process
1245 group, redirect the TTY to point to our own process group. We need
1246 to be in our own process group to receive SIGIO properly. */
1248 munge_process_groups (void)
1250 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1254 EMACS_SEPARATE_PROCESS_GROUP ();
1256 munge_tty_process_group ();
1261 unmunge_tty_process_group (void)
1263 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1265 int fd = open ("/dev/tty", O_RDWR, 0);
1266 EMACS_BLOCK_SIGNAL (SIGTTOU);
1267 EMACS_SET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1268 EMACS_UNBLOCK_SIGNAL (SIGTTOU);
1274 /* Set the tty to our original foreground group.
1275 Also restore the original process group (put us back into sh's
1276 process group), so that ^Z will suspend both us and sh. */
1278 unmunge_process_groups (void)
1280 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1284 unmunge_tty_process_group ();
1286 EMACS_SET_PROCESS_GROUP (inherited_pgroup);
1290 /* According to some old wisdom, we need to be in a separate process
1291 group for SIGIO to work correctly (at least on some systems ...).
1292 So go ahead and put ourselves into our own process group. This
1293 will fail if we're already in our own process group, but who cares.
1294 Also record whether we were in our own process group. (In general,
1295 we will already be in our own process group if we were started from
1296 a job-control shell like csh, but not if we were started from sh).
1298 If we succeeded in changing our process group, then we will no
1299 longer be in the foreground process group of our controlling
1300 terminal. Therefore, if we have a console open onto this terminal,
1301 we have to change the controlling terminal's foreground process
1302 group (otherwise we will get stopped with a SIGTTIN signal when
1303 attempting to read from the terminal). It's important,
1304 however, that we do this *only* when we have a console open onto
1305 the terminal. It's a decidedly bad idea to do so otherwise,
1306 especially if XEmacs was started from the background. */
1309 init_process_group (void)
1311 #ifdef SIGIO_REQUIRES_SEPARATE_PROCESS_GROUP
1312 if (! noninteractive)
1314 int fd = open ("/dev/tty", O_RDWR, 0);
1315 inherited_pgroup = EMACS_GET_PROCESS_GROUP ();
1316 EMACS_GET_TTY_PROCESS_GROUP (fd, &inherited_tty_pgroup);
1318 EMACS_SEPARATE_PROCESS_GROUP ();
1324 disconnect_controlling_terminal (void)
1327 /* Controlling terminals are attached to a session.
1328 Create a new session for us; it will have no controlling
1329 terminal. This also, of course, puts us in our own
1333 /* Put us in our own process group. */
1334 EMACS_SEPARATE_PROCESS_GROUP ();
1335 # if defined (TIOCNOTTY)
1336 /* This is the older way of disconnecting the controlling
1337 terminal, on 4.3 BSD. We must open /dev/tty; using
1338 filedesc 0 is not sufficient because it could be
1339 something else (e.g. our stdin was redirected to
1343 int j = open ("/dev/tty", O_RDWR, 0);
1344 ioctl (j, TIOCNOTTY, 0);
1347 # endif /* TIOCNOTTY */
1349 On systems without TIOCNOTTY and without
1350 setsid(), we don't need to do anything more to
1351 disconnect our controlling terminal. Here is
1352 what the man page for termio(7) from a SYSV 3.2
1355 "The first terminal file opened by the process group leader
1356 of a terminal file not already associated with a process
1357 group becomes the control terminal for that process group.
1358 The control terminal plays a special role in handling quit
1359 and interrupt signals, as discussed below. The control
1360 terminal is inherited by a child process during a fork(2).
1361 A process can break this association by changing its process
1362 group using setpgrp(2)."
1365 # endif /* not HAVE_SETSID */
1369 /* ------------------------------------------------------ */
1370 /* Getting and setting emacs_tty structures */
1371 /* ------------------------------------------------------ */
1373 /* It's wrong to encase these into #ifdef HAVE_TTY because we need
1374 them for child TTY processes. */
1375 /* However, this does break NT support while we don't do child TTY processes */
1376 #ifndef WIN32_NATIVE
1378 /* Set *TC to the parameters associated with the terminal FD.
1379 Return zero if all's well, or -1 if we ran into an error we
1380 couldn't deal with. */
1382 emacs_get_tty (int fd, struct emacs_tty *settings)
1384 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
1386 /* We have those nifty POSIX tcmumbleattr functions. */
1387 if (tcgetattr (fd, &settings->main) < 0)
1390 #elif defined HAVE_TERMIO
1391 /* The SYSV-style interface? */
1392 if (ioctl (fd, TCGETA, &settings->main) < 0)
1395 #elif !defined (WIN32_NATIVE)
1396 /* I give up - I hope you have the BSD ioctls. */
1397 if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1399 #endif /* HAVE_TCATTR */
1401 /* Suivant - Do we have to get struct ltchars data? */
1403 if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1407 /* How about a struct tchars and a wordful of lmode bits? */
1409 if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1410 || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1414 /* We have survived the tempest. */
1418 /* Set the parameters of the tty on FD according to the contents of
1419 *SETTINGS. If FLUSHP is non-zero, we discard input.
1420 Return 0 if all went well, and -1 if anything failed.
1421 #### All current callers use FLUSHP == 0. */
1424 emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
1426 /* Set the primary parameters - baud rate, character size, etcetera. */
1429 /* We have those nifty POSIX tcmumbleattr functions.
1430 William J. Smith <wjs@wiis.wang.com> writes:
1431 "POSIX 1003.1 defines tcsetattr() to return success if it was
1432 able to perform any of the requested actions, even if some
1433 of the requested actions could not be performed.
1434 We must read settings back to ensure tty setup properly.
1435 AIX requires this to keep tty from hanging occasionally." */
1436 /* This makes sure that we don't loop indefinitely in here. */
1437 for (i = 0 ; i < 10 ; i++)
1438 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1449 /* Get the current settings, and see if they're what we asked for. */
1450 tcgetattr (fd, &new);
1451 /* We cannot use memcmp on the whole structure here because under
1452 * aix386 the termios structure has some reserved field that may
1455 if ( new.c_iflag == settings->main.c_iflag
1456 && new.c_oflag == settings->main.c_oflag
1457 && new.c_cflag == settings->main.c_cflag
1458 && new.c_lflag == settings->main.c_lflag
1459 && memcmp(new.c_cc, settings->main.c_cc, NCCS) == 0)
1464 #elif defined HAVE_TERMIO
1465 /* The SYSV-style interface? */
1466 if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1469 #elif !defined (WIN32_NATIVE)
1470 /* I give up - I hope you have the BSD ioctls. */
1471 if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1473 #endif /* HAVE_TCATTR */
1475 /* Suivant - Do we have to get struct ltchars data? */
1477 if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1481 /* How about a struct tchars and a wordful of lmode bits? */
1483 if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1484 || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1488 /* We have survived the tempest. */
1492 #endif /* WIN32_NATIVE */
1494 /* ------------------------------------------------------ */
1495 /* Initializing a device */
1496 /* ------------------------------------------------------ */
1500 /* This may also be defined in stdio,
1501 but if so, this does no harm,
1502 and using the same name avoids wasting the other one's space. */
1504 #if ((defined(USG) || defined(DGUX)) && !defined(__STDC__))
1505 char _sobuf[BUFSIZ+8];
1506 #elif (defined(USG) && !defined(LINUX) && !defined(_SCO_DS)) || defined(IRIX5)
1507 extern unsigned char _sobuf[BUFSIZ+8];
1509 char _sobuf[BUFSIZ];
1512 #if defined (TIOCGLTC) && defined (HAVE_LTCHARS) /* HAVE_LTCHARS */
1513 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1515 #ifdef TIOCGETC /* HAVE_TCHARS */
1517 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1522 tty_init_sys_modes_on_device (struct device *d)
1524 struct emacs_tty tty;
1525 int input_fd, output_fd;
1526 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1528 input_fd = CONSOLE_TTY_DATA (con)->infd;
1529 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1531 emacs_get_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty);
1532 tty = CONSOLE_TTY_DATA (con)->old_tty;
1534 con->tty_erase_char = Qnil;
1536 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1537 /* after all those years... */
1538 con->tty_erase_char = make_char (tty.main.c_cc[VERASE]);
1540 /* This allows meta to be sent on 8th bit. */
1541 tty.main.c_iflag &= ~INPCK; /* don't check input for parity */
1543 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
1544 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
1546 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
1548 tty.main.c_lflag &= ~ECHO; /* Disable echo */
1549 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
1551 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
1553 tty.main.c_lflag |= ISIG; /* Enable signals */
1554 if (TTY_FLAGS (con).flow_control)
1556 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
1558 tty.main.c_iflag &= ~IXANY;
1562 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
1563 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
1565 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
1567 if (TTY_FLAGS (con).meta_key)
1569 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
1570 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1573 if (CONSOLE_TTY_DATA (con)->controlling_terminal)
1575 tty.main.c_cc[VINTR] =
1576 CONSOLE_QUIT_CHAR (con); /* C-g (usually) gives SIGINT */
1577 /* Set up C-g for both SIGQUIT and SIGINT.
1578 We don't know which we will get, but we handle both alike
1579 so which one it really gives us does not matter. */
1580 tty.main.c_cc[VQUIT] = CONSOLE_QUIT_CHAR (con);
1584 tty.main.c_cc[VINTR] = _POSIX_VDISABLE;
1585 tty.main.c_cc[VQUIT] = _POSIX_VDISABLE;
1587 tty.main.c_cc[VMIN] = 1; /* Input should wait for at
1589 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
1591 tty.main.c_cc[VSWTCH] = _POSIX_VDISABLE; /* Turn off shell layering use
1594 /* There was some conditionalizing here on (mips or TCATTR), but
1595 I think that's wrong. There was one report of C-y (DSUSP) not being
1596 disabled on HP9000s700 systems, and this might fix it. */
1598 tty.main.c_cc[VSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-z. */
1601 tty.main.c_cc[V_DSUSP] = _POSIX_VDISABLE; /* Turn off mips handling of C-y. */
1602 #endif /* V_DSUSP */
1603 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1604 tty.main.c_cc[VDSUSP] = _POSIX_VDISABLE;
1607 tty.main.c_cc[VLNEXT] = _POSIX_VDISABLE;
1610 tty.main.c_cc[VREPRINT] = _POSIX_VDISABLE;
1611 #endif /* VREPRINT */
1613 tty.main.c_cc[VWERASE] = _POSIX_VDISABLE;
1614 #endif /* VWERASE */
1616 tty.main.c_cc[VDISCARD] = _POSIX_VDISABLE;
1617 #endif /* VDISCARD */
1619 tty.main.c_cc[VSTART] = _POSIX_VDISABLE;
1622 tty.main.c_cc[VSTRT] = _POSIX_VDISABLE; /* called VSTRT on some systems */
1625 tty.main.c_cc[VSTOP] = _POSIX_VDISABLE;
1627 #ifdef SET_LINE_DISCIPLINE
1628 /* Need to explicitly request TERMIODISC line discipline or
1629 Ultrix's termios does not work correctly. */
1630 tty.main.c_line = SET_LINE_DISCIPLINE;
1635 /* AIX enhanced edit loses NULs, so disable it. */
1636 tty.main.c_line = 0;
1637 tty.main.c_iflag &= ~ASCEDIT;
1639 tty.main.c_cc[VSTRT] = 255;
1640 tty.main.c_cc[VSTOP] = 255;
1641 tty.main.c_cc[VSUSP] = 255;
1642 tty.main.c_cc[VDSUSP] = 255;
1643 #endif /* IBMR2AIX */
1644 /* Also, PTY overloads NUL and BREAK.
1645 don't ignore break, but don't signal either, so it looks like NUL.
1646 This really serves a purpose only if running in an XTERM window
1647 or via TELNET or the like, but does no harm elsewhere. */
1648 tty.main.c_iflag &= ~IGNBRK;
1649 tty.main.c_iflag &= ~BRKINT;
1651 #else /* if not HAVE_TERMIO */
1652 #if !defined (WIN32_NATIVE)
1653 con->tty_erase_char = make_char (tty.main.sg_erase);
1654 tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1655 if (TTY_FLAGS (con).meta_key)
1656 tty.main.sg_flags |= ANYP;
1657 /* #### should we be using RAW mode here? */
1658 tty.main.sg_flags |= /* interrupt_input ? RAW : */ CBREAK;
1659 #endif /* not WIN32_NATIVE */
1660 #endif /* not HAVE_TERMIO */
1662 /* If going to use CBREAK mode, we must request C-g to interrupt
1663 and turn off start and stop chars, etc. If not going to use
1664 CBREAK mode, do this anyway so as to turn off local flow
1665 control for user coming over network on 4.2; in this case,
1666 only t_stopc and t_startc really matter. */
1669 /* Note: if not using CBREAK mode, it makes no difference how we
1671 tty.tchars = new_tchars;
1672 tty.tchars.t_intrc = CONSOLE_QUIT_CHAR (con);
1673 if (TTY_FLAGS (con).flow_control)
1675 tty.tchars.t_startc = '\021';
1676 tty.tchars.t_stopc = '\023';
1679 tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH |
1680 CONSOLE_TTY_DATA (con)->old_tty.lmode;
1682 #if defined (ultrix) || defined (__bsdi__)
1683 /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1684 anything, and leaving it in breaks the meta key. Go figure. */
1685 /* Turning off ONLCR is enough under BSD/386. Leave the general
1686 output post-processing flag alone since for some reason it
1687 doesn't get reset after XEmacs goes away. */
1688 tty.lmode &= ~LLITOUT;
1691 #endif /* HAVE_TCHARS */
1692 #endif /* not HAVE_TERMIO */
1695 tty.ltchars = new_ltchars;
1696 #endif /* HAVE_LTCHARS */
1698 emacs_set_tty (input_fd, &tty, 0);
1700 /* This code added to insure that, if flow-control is not to be used,
1701 we have an unlocked terminal at the start. */
1704 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TCXONC, 1);
1707 if (!TTY_FLAGS (con).flow_control) ioctl (input_fd, TIOCSTART, 0);
1710 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1712 if (!TTY_FLAGS (con).flow_control) tcflow (input_fd, TCOON);
1719 /* IBM's HFT device usually thinks a ^J should be LF/CR.
1720 We need it to be only LF. This is the way that is
1724 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1725 write (output_fd, "\033[20l", 5);
1730 #if 0 /* We do our own buffering with lstreams. */
1732 /* This symbol is defined on recent USG systems.
1733 Someone says without this call USG won't really buffer the file
1734 even with a call to setbuf. */
1735 setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1737 setbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf);
1740 set_tty_modes (con);
1743 #endif /* HAVE_TTY */
1746 init_one_device (struct device *d)
1749 if (DEVICE_TTY_P (d))
1750 tty_init_sys_modes_on_device (d);
1752 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1753 if (!DEVICE_STREAM_P (d))
1755 init_sigio_on_device (d);
1756 request_sigio_on_device (d);
1762 init_one_console (struct console *con)
1764 Lisp_Object devcons;
1766 CONSOLE_DEVICE_LOOP (devcons, con)
1768 struct device *d = XDEVICE (XCAR (devcons));
1770 init_one_device (d);
1775 reinit_initial_console (void)
1777 munge_process_groups ();
1778 if (CONSOLEP (Vcontrolling_terminal) &&
1779 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1780 init_one_console (XCONSOLE (Vcontrolling_terminal));
1784 /* ------------------------------------------------------ */
1785 /* Other TTY functions */
1786 /* ------------------------------------------------------ */
1790 #if 0 /* not currently used */
1792 /* Return nonzero if safe to use tabs in output.
1793 At the time this is called, init_sys_modes has not been done yet. */
1796 tabs_safe_p (struct device *d)
1799 if (DEVICE_TTY_P (d))
1801 struct emacs_tty tty;
1803 emacs_get_tty (DEVICE_INFD (d), &tty);
1804 return EMACS_TTY_TABS_OK (&tty);
1812 /* Get terminal size from system.
1813 Store number of lines into *heightp and width into *widthp.
1814 If zero or a negative number is stored, the value is not valid. */
1817 get_tty_device_size (struct device *d, int *widthp, int *heightp)
1819 int input_fd = DEVICE_INFD (d);
1821 assert (DEVICE_TTY_P (d));
1826 struct winsize size;
1828 if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1829 *widthp = *heightp = 0;
1832 *widthp = size.ws_col;
1833 *heightp = size.ws_row;
1836 #elif defined TIOCGSIZE
1838 /* SunOS - style. */
1839 struct ttysize size;
1841 if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1842 *widthp = *heightp = 0;
1845 *widthp = size.ts_cols;
1846 *heightp = size.ts_lines;
1849 #else /* system doesn't know size */
1854 #endif /* not !TIOCGWINSZ */
1857 #endif /* HAVE_TTY */
1860 /* ------------------------------------------------------ */
1861 /* Is device 8 bit ? */
1862 /* ------------------------------------------------------ */
1867 eight_bit_tty (struct device *d)
1873 assert (DEVICE_TTY_P (d));
1874 input_fd = DEVICE_INFD (d);
1876 emacs_get_tty (input_fd, &s);
1878 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1879 eight_bit = (s.main.c_cflag & CSIZE) == CS8;
1881 eight_bit = 0; /* I don't know how to do it */
1886 #endif /* HAVE_TTY */
1889 /* ------------------------------------------------------ */
1890 /* Resetting a device */
1891 /* ------------------------------------------------------ */
1895 /* Prepare the terminal for exiting Emacs; move the cursor to the
1896 bottom of the frame, turn off interrupt-driven I/O, etc. */
1898 tty_reset_sys_modes_on_device (struct device *d)
1900 int input_fd, output_fd;
1901 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
1903 input_fd = CONSOLE_TTY_DATA (con)->infd;
1904 output_fd = CONSOLE_TTY_DATA (con)->outfd;
1906 #if defined (IBMR2AIX) && defined (AIXHFT)
1908 /* HFT consoles normally use ^J as a LF/CR. We forced it to
1909 do the LF only. Now, we need to reset it. */
1912 if (ioctl (output_fd, HFTGETID, &tty) != -1)
1913 write (output_fd, "\033[20h", 5);
1917 tty_redisplay_shutdown (con);
1918 /* reset_tty_modes() flushes the connection at its end. */
1919 reset_tty_modes (con);
1922 /* Avoid possible loss of output when changing terminal modes. */
1926 while (emacs_set_tty (input_fd, &CONSOLE_TTY_DATA (con)->old_tty, 0)
1927 < 0 && errno == EINTR)
1930 #ifdef SET_LINE_DISCIPLINE
1931 /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
1932 A different old line discipline is therefore not restored, yet.
1933 Restore the old line discipline by hand. */
1934 ioctl (input_fd, TIOCSETD, &old_tty.main.c_line);
1943 #endif /* HAVE_TTY */
1946 reset_one_device (struct device *d)
1949 if (DEVICE_TTY_P (d))
1950 tty_reset_sys_modes_on_device (d);
1953 if (DEVICE_STREAM_P (d))
1954 fflush (CONSOLE_STREAM_DATA (XCONSOLE (DEVICE_CONSOLE (d)))->out);
1955 #if defined(SIGIO) && !defined(BROKEN_SIGIO)
1956 if (!DEVICE_STREAM_P (d))
1958 unrequest_sigio_on_device (d);
1959 reset_sigio_on_device (d);
1965 reset_one_console (struct console *con)
1967 /* Note: this can be called during GC. */
1968 Lisp_Object devcons;
1970 CONSOLE_DEVICE_LOOP (devcons, con)
1972 struct device *d = XDEVICE (XCAR (devcons));
1974 reset_one_device (d);
1979 reset_all_consoles (void)
1981 /* Note: this can be called during GC. */
1982 Lisp_Object concons;
1984 CONSOLE_LOOP (concons)
1986 struct console *con = XCONSOLE (XCAR (concons));
1988 reset_one_console (con);
1991 unmunge_process_groups ();
1995 reset_initial_console (void)
1997 if (CONSOLEP (Vcontrolling_terminal) &&
1998 CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
1999 reset_one_console (XCONSOLE (Vcontrolling_terminal));
2000 unmunge_process_groups ();
2004 /* ------------------------------------------------------ */
2005 /* extra TTY stuff under AIX */
2006 /* ------------------------------------------------------ */
2010 /* Called from init_sys_modes. */
2012 hft_init (struct console *con)
2017 assert (CONSOLE_TTY_P (con));
2018 input_fd = CONSOLE_TTY_DATA (con)->infd;
2020 /* If we're not on an HFT we shouldn't do any of this. We determine
2021 if we are on an HFT by trying to get an HFT error code. If this
2022 call fails, we're not on an HFT. */
2024 if (ioctl (input_fd, HFQERROR, &junk) < 0)
2026 #else /* not IBMR2AIX */
2027 if (ioctl (input_fd, HFQEIO, 0) < 0)
2029 #endif /* not IBMR2AIX */
2031 /* On AIX the default hft keyboard mapping uses backspace rather than delete
2032 as the rubout key's ASCII code. Here this is changed. The bug is that
2033 there's no way to determine the old mapping, so in reset_one_console
2034 we need to assume that the normal map had been present. Of course, this
2035 code also doesn't help if on a terminal emulator which doesn't understand
2039 struct hfkeymap keymap;
2041 buf.hf_bufp = (char *)&keymap;
2042 buf.hf_buflen = sizeof (keymap);
2043 keymap.hf_nkeys = 2;
2044 keymap.hfkey[0].hf_kpos = 15;
2045 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2047 keymap.hfkey[0].hf_keyidh = '<';
2048 #else /* not IBMR2AIX */
2049 keymap.hfkey[0].hf_page = '<';
2050 #endif /* not IBMR2AIX */
2051 keymap.hfkey[0].hf_char = 127;
2052 keymap.hfkey[1].hf_kpos = 15;
2053 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2055 keymap.hfkey[1].hf_keyidh = '<';
2056 #else /* not IBMR2AIX */
2057 keymap.hfkey[1].hf_page = '<';
2058 #endif /* not IBMR2AIX */
2059 keymap.hfkey[1].hf_char = 127;
2060 hftctl (input_fd, HFSKBD, &buf);
2062 /* #### Should probably set a console TTY flag here. */
2064 /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
2066 line_ins_del_ok = char_ins_del_ok = 0;
2070 /* Reset the rubout key to backspace. */
2073 hft_reset (struct console *con)
2076 struct hfkeymap keymap;
2080 assert (CONSOLE_TTY_P (con));
2081 input_fd = CONSOLE_TTY_DATA (con)->infd;
2084 if (ioctl (input_fd, HFQERROR, &junk) < 0)
2086 #else /* not IBMR2AIX */
2087 if (ioctl (input_fd, HFQEIO, 0) < 0)
2089 #endif /* not IBMR2AIX */
2091 buf.hf_bufp = (char *)&keymap;
2092 buf.hf_buflen = sizeof (keymap);
2093 keymap.hf_nkeys = 2;
2094 keymap.hfkey[0].hf_kpos = 15;
2095 keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
2097 keymap.hfkey[0].hf_keyidh = '<';
2098 #else /* not IBMR2AIX */
2099 keymap.hfkey[0].hf_page = '<';
2100 #endif /* not IBMR2AIX */
2101 keymap.hfkey[0].hf_char = 8;
2102 keymap.hfkey[1].hf_kpos = 15;
2103 keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
2105 keymap.hfkey[1].hf_keyidh = '<';
2106 #else /* not IBMR2AIX */
2107 keymap.hfkey[1].hf_page = '<';
2108 #endif /* not IBMR2AIX */
2109 keymap.hfkey[1].hf_char = 8;
2110 hftctl (input_fd, HFSKBD, &buf);
2116 /************************************************************************/
2117 /* limits of text/data segments */
2118 /************************************************************************/
2120 #if !defined(CANNOT_DUMP) && !defined(PDUMP)
2124 #ifndef SYSTEM_MALLOC
2131 /* Some systems that cannot dump also cannot implement these. */
2134 * Return the address of the start of the text segment prior to
2135 * doing an unexec. After unexec the return value is undefined.
2136 * See crt0.c for further explanation and _start.
2140 #if !defined(HAVE_TEXT_START) && !defined(PDUMP)
2142 EXTERN_C int _start (void);
2145 start_of_text (void)
2148 return (char *) TEXT_START;
2150 return (char *) _start;
2151 #endif /* TEXT_START */
2153 #endif /* !defined(HAVE_TEXT_START) && !defined(PDUMP) */
2156 * Return the address of the start of the data segment prior to
2157 * doing an unexec. After unexec the return value is undefined.
2158 * See ecrt0.c for further information and definition of data_start.
2160 * Apparently, on BSD systems this is etext at startup. On
2161 * USG systems (swapping) this is highly mmu dependent and
2162 * is also dependent on whether or not the program is running
2163 * with shared text. Generally there is a (possibly large)
2164 * gap between end of text and start of data with shared text.
2166 * On Uniplus+ systems with shared text, data starts at a
2167 * fixed address. Each port (from a given oem) is generally
2168 * different, and the specific value of the start of data can
2169 * be obtained via the UniPlus+ specific "uvar" system call,
2170 * however the method outlined in crt0.c seems to be more portable.
2172 * Probably what will have to happen when a USG unexec is available,
2173 * at least on UniPlus, is temacs will have to be made unshared so
2174 * that text and data are contiguous. Then once loadup is complete,
2175 * unexec will produce a shared executable where the data can be
2176 * at the normal shared text boundary and the startofdata variable
2177 * will be patched by unexec to the correct value.
2181 #if defined(ORDINARY_LINK) && !defined(MINGW)
2182 extern char **environ;
2186 start_of_data (void)
2189 return ((char *) DATA_START);
2191 #if defined (ORDINARY_LINK) || defined(PDUMP)
2193 * This is a hack. Since we're not linking crt0.c or pre_crt0.c,
2194 * data_start isn't defined. We take the address of environ, which
2195 * is known to live at or near the start of the system crt0.c, and
2196 * we don't sweat the handful of bytes that might lose.
2198 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2199 extern char* static_heap_base;
2201 return static_heap_base;
2203 return((char *) &environ);
2205 extern int data_start;
2206 return ((char *) &data_start);
2207 #endif /* ORDINARY_LINK */
2208 #endif /* DATA_START */
2210 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2212 #if !defined(CANNOT_DUMP) && !defined(PDUMP)
2213 /* Some systems that cannot dump also cannot implement these. */
2216 * Return the address of the end of the text segment prior to
2217 * doing an unexec. After unexec the return value is undefined.
2224 return ((char *) TEXT_END);
2227 return ((char *) &etext);
2232 * Return the address of the end of the data segment prior to
2233 * doing an unexec. After unexec the return value is undefined.
2240 return ((char *) DATA_END);
2243 return ((char *) &edata);
2247 #endif /* !defined(CANNOT_DUMP) && !defined(PDUMP) */
2250 /************************************************************************/
2251 /* get the system name */
2252 /************************************************************************/
2254 /* init_system_name sets up the string for the Lisp function
2255 system-name to return. */
2257 extern Lisp_Object Vsystem_name;
2260 init_system_name (void)
2262 #if defined (WIN32_NATIVE)
2263 char hostname [MAX_COMPUTERNAME_LENGTH + 1];
2264 size_t size = sizeof (hostname);
2265 GetComputerName (hostname, &size);
2266 Vsystem_name = build_string (hostname);
2267 #elif !defined (HAVE_GETHOSTNAME)
2270 Vsystem_name = build_string (uts.nodename);
2271 #else /* HAVE_GETHOSTNAME */
2272 unsigned int hostname_size = 256;
2273 char *hostname = (char *) alloca (hostname_size);
2275 /* Try to get the host name; if the buffer is too short, try
2276 again. Apparently, the only indication gethostname gives of
2277 whether the buffer was large enough is the presence or absence
2278 of a '\0' in the string. Eech. */
2281 gethostname (hostname, hostname_size - 1);
2282 hostname[hostname_size - 1] = '\0';
2284 /* Was the buffer large enough for the '\0'? */
2285 if (strlen (hostname) < (size_t) (hostname_size - 1))
2288 hostname_size <<= 1;
2289 hostname = (char *) alloca (hostname_size);
2291 # if defined( HAVE_SOCKETS) && !defined(BROKEN_CYGWIN)
2292 /* Turn the hostname into the official, fully-qualified hostname.
2293 Don't do this if we're going to dump; this can confuse system
2294 libraries on some machines and make the dumped emacs core dump. */
2295 # ifndef CANNOT_DUMP
2297 # endif /* not CANNOT_DUMP */
2298 if (!strchr (hostname, '.'))
2300 # if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETNAMEINFO))
2301 struct hostent *hp = NULL;
2304 for (count = 0; count < 10; count++)
2308 /* Some systems can't handle SIGALARM/SIGIO in gethostbyname(). */
2310 hp = gethostbyname (hostname);
2311 start_interrupts ();
2313 if (! (hp == 0 && h_errno == TRY_AGAIN))
2315 Fsleep_for (make_int (1));
2320 const char *fqdn = (const char *) hp->h_name;
2322 if (!strchr (fqdn, '.'))
2324 /* We still don't have a fully qualified domain name.
2325 Try to find one in the list of alternate names */
2326 char **alias = hp->h_aliases;
2327 while (*alias && !strchr (*alias, '.'))
2332 hostname = (char *) alloca (strlen (fqdn) + 1);
2333 strcpy (hostname, fqdn);
2335 # else /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
2336 struct addrinfo hints, *res;
2339 hints.ai_flags = AI_CANONNAME;
2340 #ifdef IPV6_CANONICALIZE
2341 hints.ai_family = AF_UNSPEC;
2343 hints.ai_family = PF_INET;
2345 hints.ai_socktype = SOCK_STREAM;
2346 hints.ai_protocol = 0;
2347 if (!getaddrinfo (hostname, NULL, &hints, &res))
2349 hostname = (char *) alloca (strlen (res->ai_canonname) + 1);
2350 strcpy (hostname, res->ai_canonname);
2354 # endif /* !(HAVE_GETADDRINFO && HAVE_GETNAMEINFO) */
2356 # endif /* HAVE_SOCKETS */
2357 Vsystem_name = build_string (hostname);
2358 #endif /* HAVE_GETHOSTNAME */
2363 for (i = 0, p = XSTRING_DATA (Vsystem_name);
2364 i < XSTRING_LENGTH (Vsystem_name);
2367 if (*p == ' ' || *p == '\t')
2374 /************************************************************************/
2375 /* Emulation of select() */
2376 /************************************************************************/
2380 ERROR: XEmacs requires a working select().
2382 #endif /* not HAVE_SELECT */
2385 /************************************************************************/
2386 /* Emulation of signal stuff */
2387 /************************************************************************/
2389 /* BSD 4.1 crap deleted. 4.2 was released in 1983, for God's sake! I
2390 can't imagine that anyone is actually running that OS any more.
2391 You can't use X under it (I think) because there's no select().
2392 Anyway, the signal stuff has all been changed. If someone wants to
2393 get this stuff working again, look in the FSF Emacs sources. */
2395 /* POSIX signals support - DJB */
2397 #ifdef HAVE_SIGPROCMASK
2399 /* #### Is there any reason this is static global rather than local? */
2400 static struct sigaction new_action, old_action;
2403 sys_do_signal (int signal_number, signal_handler_t action)
2407 /* XEmacs works better if system calls are *not* restarted.
2408 This allows C-g to interrupt reads and writes, on most systems.
2410 #### Another possibility is to just longjmp() out of the signal
2411 handler. According to W.R. Stevens, this should be OK on all
2412 systems. However, I don't want to deal with the potential
2413 evil ramifications of this at this point. */
2416 /* This gets us restartable system calls for efficiency.
2417 The "else" code will work as well. */
2418 return (berk_signal (signal_number, action));
2420 sigemptyset (&new_action.sa_mask);
2421 new_action.sa_handler = action;
2422 #if defined (SA_RESTART)
2423 /* Emacs mostly works better with restartable system services. If this
2424 * flag exists, we probably want to turn it on here.
2426 new_action.sa_flags = SA_RESTART;
2428 new_action.sa_flags = 0;
2430 sigaction (signal_number, &new_action, &old_action);
2431 return (old_action.sa_handler);
2436 sigemptyset (&new_action.sa_mask);
2437 new_action.sa_handler = action;
2438 #if defined (SA_INTERRUPT) /* don't restart system calls, under SunOS */
2439 new_action.sa_flags = SA_INTERRUPT;
2441 new_action.sa_flags = 0;
2443 sigaction (signal_number, &new_action, &old_action);
2444 return (signal_handler_t) (old_action.sa_handler);
2449 #elif defined (HAVE_SIGBLOCK)
2451 /* We use sigvec() rather than signal() if we have it, because
2452 it lets us specify interruptible system calls. */
2454 sys_do_signal (int signal_number, signal_handler_t action)
2456 struct sigvec vec, ovec;
2458 vec.sv_handler = action;
2460 #ifdef SV_INTERRUPT /* don't restart system calls */
2461 vec.sv_flags = SV_INTERRUPT;
2466 sigvec (signal_number, &vec, &ovec);
2468 return (ovec.sv_handler);
2471 #endif /* HAVE_SIGBLOCK (HAVE_SIGPROCMASK) */
2474 /************************************************************************/
2475 /* Emulation of strerror() and errno support */
2476 /************************************************************************/
2478 #ifndef HAVE_STRERROR
2480 #if !defined(NeXT) && !defined(__alpha) && !defined(MACH) && !defined(LINUX) && !defined(IRIX) && !defined(__NetBSD__)
2481 /* Linux added here by Raymond L. Toy <toy@alydar.crd.ge.com> for XEmacs. */
2482 /* Irix added here by gparker@sni-usa.com for XEmacs. */
2483 /* NetBSD added here by James R Grinter <jrg@doc.ic.ac.uk> for XEmacs */
2484 extern const char *sys_errlist[];
2485 extern int sys_nerr;
2489 extern char *sys_errlist[];
2490 extern int sys_nerr;
2495 strerror (int errnum)
2497 if (errnum >= 0 && errnum < sys_nerr)
2498 return sys_errlist[errnum];
2499 return ((const char *) GETTEXT ("Unknown error"));
2502 #endif /* ! HAVE_STRERROR */
2507 unsigned long oscode; /* Win32 error */
2508 int errnocode; /* unix errno */
2511 static struct errentry errtable[] = {
2512 { ERROR_INVALID_FUNCTION, EINVAL }, /* 1 */
2513 { ERROR_FILE_NOT_FOUND, ENOENT }, /* 2 */
2514 { ERROR_PATH_NOT_FOUND, ENOENT }, /* 3 */
2515 { ERROR_TOO_MANY_OPEN_FILES, EMFILE }, /* 4 */
2516 { ERROR_ACCESS_DENIED, EACCES }, /* 5 */
2517 { ERROR_INVALID_HANDLE, EBADF }, /* 6 */
2518 { ERROR_ARENA_TRASHED, ENOMEM }, /* 7 */
2519 { ERROR_NOT_ENOUGH_MEMORY, ENOMEM }, /* 8 */
2520 { ERROR_INVALID_BLOCK, ENOMEM }, /* 9 */
2521 { ERROR_BAD_ENVIRONMENT, E2BIG }, /* 10 */
2522 { ERROR_BAD_FORMAT, ENOEXEC }, /* 11 */
2523 { ERROR_INVALID_ACCESS, EINVAL }, /* 12 */
2524 { ERROR_INVALID_DATA, EINVAL }, /* 13 */
2525 { ERROR_INVALID_DRIVE, ENOENT }, /* 15 */
2526 { ERROR_CURRENT_DIRECTORY, EACCES }, /* 16 */
2527 { ERROR_NOT_SAME_DEVICE, EXDEV }, /* 17 */
2528 { ERROR_NO_MORE_FILES, ENOENT }, /* 18 */
2529 { ERROR_LOCK_VIOLATION, EACCES }, /* 33 */
2530 { ERROR_BAD_NETPATH, ENOENT }, /* 53 */
2531 { ERROR_NETWORK_ACCESS_DENIED, EACCES }, /* 65 */
2532 { ERROR_BAD_NET_NAME, ENOENT }, /* 67 */
2533 { ERROR_FILE_EXISTS, EEXIST }, /* 80 */
2534 { ERROR_CANNOT_MAKE, EACCES }, /* 82 */
2535 { ERROR_FAIL_I24, EACCES }, /* 83 */
2536 { ERROR_INVALID_PARAMETER, EINVAL }, /* 87 */
2537 { ERROR_NO_PROC_SLOTS, EAGAIN }, /* 89 */
2538 { ERROR_DRIVE_LOCKED, EACCES }, /* 108 */
2539 { ERROR_BROKEN_PIPE, EPIPE }, /* 109 */
2540 { ERROR_DISK_FULL, ENOSPC }, /* 112 */
2541 { ERROR_INVALID_TARGET_HANDLE, EBADF }, /* 114 */
2542 { ERROR_INVALID_HANDLE, EINVAL }, /* 124 */
2543 { ERROR_WAIT_NO_CHILDREN, ECHILD }, /* 128 */
2544 { ERROR_CHILD_NOT_COMPLETE, ECHILD }, /* 129 */
2545 { ERROR_DIRECT_ACCESS_HANDLE, EBADF }, /* 130 */
2546 { ERROR_NEGATIVE_SEEK, EINVAL }, /* 131 */
2547 { ERROR_SEEK_ON_DEVICE, EACCES }, /* 132 */
2548 { ERROR_DIR_NOT_EMPTY, ENOTEMPTY }, /* 145 */
2549 { ERROR_NOT_LOCKED, EACCES }, /* 158 */
2550 { ERROR_BAD_PATHNAME, ENOENT }, /* 161 */
2551 { ERROR_MAX_THRDS_REACHED, EAGAIN }, /* 164 */
2552 { ERROR_LOCK_FAILED, EACCES }, /* 167 */
2553 { ERROR_ALREADY_EXISTS, EEXIST }, /* 183 */
2554 { ERROR_FILENAME_EXCED_RANGE, ENOENT }, /* 206 */
2555 { ERROR_NESTING_NOT_ALLOWED, EAGAIN }, /* 215 */
2556 { ERROR_NOT_ENOUGH_QUOTA, ENOMEM } /* 1816 */
2559 /* The following two constants must be the minimum and maximum
2560 values in the (contiguous) range of Exec Failure errors. */
2561 #define MIN_EXEC_ERROR ERROR_INVALID_STARTING_CODESEG
2562 #define MAX_EXEC_ERROR ERROR_INFLOOP_IN_RELOC_CHAIN
2564 /* These are the low and high value in the range of errors that are
2565 access violations */
2566 #define MIN_EACCES_RANGE ERROR_WRITE_PROTECT
2567 #define MAX_EACCES_RANGE ERROR_SHARING_BUFFER_EXCEEDED
2570 mswindows_set_errno (unsigned long win32_error)
2574 /* check the table for the OS error code */
2575 for (i = 0; i < countof (errtable); ++i)
2577 if (win32_error == errtable[i].oscode)
2579 errno = errtable[i].errnocode;
2584 /* The error code wasn't in the table. We check for a range of
2585 * EACCES errors or exec failure errors (ENOEXEC). Otherwise EINVAL is
2587 if (win32_error >= MIN_EACCES_RANGE && win32_error <= MAX_EACCES_RANGE)
2589 else if (win32_error >= MIN_EXEC_ERROR && win32_error <= MAX_EXEC_ERROR)
2596 mswindows_set_last_errno (void)
2598 mswindows_set_errno (GetLastError ());
2601 #endif /* WIN32_NATIVE */
2604 /************************************************************************/
2605 /* Encapsulations of system calls */
2606 /************************************************************************/
2608 #define PATHNAME_CONVERT_OUT(path) \
2609 TO_EXTERNAL_FORMAT (C_STRING, (path), C_STRING_ALLOCA, (path), Qfile_name);
2611 /***************** low-level calls ****************/
2614 * On USG systems the system calls are INTERRUPTIBLE by signals
2615 * that the user program has elected to catch. Thus the system call
2616 * must be retried in these cases. To handle this without massive
2617 * changes in the source code, we remap the standard system call names
2618 * to names for our own functions in sysdep.c that do the system call
2619 * with retries. Actually, for portability reasons, it is good
2620 * programming practice, as this example shows, to limit all actual
2621 * system calls to a single occurrence in the source. Sure, this
2622 * adds an extra level of function call overhead but it is almost
2623 * always negligible. Fred Fish, Unisoft Systems Inc.
2626 /* Ben sez: read Dick Gabriel's essay about the Worse Is Better
2627 approach to programming and its connection to the silly
2628 interruptible-system-call business. To find it, look on
2629 Jamie's home page (http://www.jwz.org/worse-is-better.html). */
2631 #ifdef ENCAPSULATE_OPEN
2633 sys_open (const char *path, int oflag, ...)
2638 va_start (ap, oflag);
2639 mode = va_arg (ap, int);
2642 PATHNAME_CONVERT_OUT (path);
2645 /* Make all handles non-inheritable */
2646 oflag |= _O_NOINHERIT;
2649 #ifdef INTERRUPTIBLE_OPEN
2652 while ((rtnval = open (path, oflag, mode)) == -1
2653 && (errno == EINTR))
2658 return open (path, oflag, mode);
2661 #endif /* ENCAPSULATE_OPEN */
2663 /* Like sys_open, only when open() is interrupted by EINTR, check for
2664 QUIT. This allows the callers of this function to be interrupted
2665 with C-g when, say, reading from named pipes. However, this should
2666 be used with caution, as it can GC.
2668 This function will not function as expected on systems where open()
2669 is not interrupted by C-g. However, the worst that can happen is
2670 the fallback to simple open(). */
2672 interruptible_open (const char *path, int oflag, int mode)
2674 /* This function can GC */
2675 size_t len = strlen (path);
2676 char *nonreloc = (char *) alloca (len + 1);
2678 /* Must copy PATH, because it might be the data of a Lisp_String,
2679 which could be relocated by GC when checking for QUIT. */
2680 memcpy (nonreloc, path, len + 1);
2682 PATHNAME_CONVERT_OUT (nonreloc);
2685 /* Make all handles non-inheritable */
2686 oflag |= _O_NOINHERIT;
2691 int rtnval = open (nonreloc, oflag, mode);
2692 if (!(rtnval == -1 && errno == EINTR))
2694 /* open() was interrupted. Was QUIT responsible? */
2699 #ifdef ENCAPSULATE_CLOSE
2701 sys_close (int filedes)
2703 #ifdef INTERRUPTIBLE_CLOSE
2705 REGISTER int rtnval;
2707 while ((rtnval = close (filedes)) == -1
2708 && (errno == EINTR))
2711 /* If close is interrupted SunOS 4.1 may or may not have closed the
2712 file descriptor. If it did the second close will fail with
2713 errno = EBADF. That means we have succeeded. */
2714 if (rtnval == -1 && did_retry && errno == EBADF)
2719 return close (filedes);
2722 #endif /* ENCAPSULATE_CLOSE */
2725 sys_read_1 (int fildes, void *buf, size_t nbyte, int allow_quit)
2729 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2730 while ((rtnval = read (fildes, buf, nbyte)) == -1
2731 && (errno == EINTR))
2739 #ifdef ENCAPSULATE_READ
2741 sys_read (int fildes, void *buf, size_t nbyte)
2743 return sys_read_1 (fildes, buf, nbyte, 0);
2745 #endif /* ENCAPSULATE_READ */
2748 sys_write_1 (int fildes, const void *buf, size_t nbyte, int allow_quit)
2750 ssize_t bytes_written = 0;
2751 const char *b = (const char *) buf;
2753 /* No harm in looping regardless of the INTERRUPTIBLE_IO setting. */
2756 ssize_t rtnval = write (fildes, b, nbyte);
2766 return bytes_written ? bytes_written : -1;
2770 bytes_written += rtnval;
2772 return bytes_written;
2775 #ifdef ENCAPSULATE_WRITE
2777 sys_write (int fildes, const void *buf, size_t nbyte)
2779 return sys_write_1 (fildes, buf, nbyte, 0);
2781 #endif /* ENCAPSULATE_WRITE */
2784 /**************** stdio calls ****************/
2786 /* There is at least some evidence that the stdio calls are interruptible
2787 just like the normal system calls, at least on some systems. In any
2788 case, it doesn't hurt to encapsulate them. */
2790 /* #### Should also encapsulate fflush().
2791 #### Should conceivably encapsulate getchar() etc. What a pain! */
2793 #ifdef ENCAPSULATE_FOPEN
2795 sys_fopen (const char *path, const char *type)
2797 PATHNAME_CONVERT_OUT (path);
2798 #if defined (WIN32_NATIVE)
2802 const char * type_save = type;
2804 /* Force all file handles to be non-inheritable. This is necessary to
2805 ensure child processes don't unwittingly inherit handles that might
2806 prevent future file access. */
2810 else if (type[0] == 'w' || type[0] == 'a')
2811 oflag = O_WRONLY | O_CREAT | O_TRUNC;
2815 /* Only do simplistic option parsing. */
2819 oflag &= ~(O_RDONLY | O_WRONLY);
2822 else if (type[0] == 'b')
2827 else if (type[0] == 't')
2834 fd = open (path, oflag | _O_NOINHERIT, 0644);
2838 return _fdopen (fd, type_save);
2840 #elif defined (INTERRUPTIBLE_OPEN)
2843 while (!(rtnval = fopen (path, type)) && (errno == EINTR))
2848 return fopen (path, type);
2851 #endif /* ENCAPSULATE_FOPEN */
2854 #ifdef ENCAPSULATE_FCLOSE
2856 sys_fclose (FILE *stream)
2858 #ifdef INTERRUPTIBLE_CLOSE
2861 while ((rtnval = fclose (stream)) == EOF
2862 && (errno == EINTR))
2866 return fclose (stream);
2869 #endif /* ENCAPSULATE_FCLOSE */
2872 #ifdef ENCAPSULATE_FREAD
2874 sys_fread (void *ptr, size_t size, size_t nitem, FILE *stream)
2876 #ifdef INTERRUPTIBLE_IO
2878 size_t items_read = 0;
2879 char *b = (char *) ptr;
2883 rtnval = fread (b, size, nitem, stream);
2886 if (ferror (stream) && errno == EINTR)
2893 items_read += rtnval;
2895 return (items_read);
2897 return fread (ptr, size, nitem, stream);
2900 #endif /* ENCAPSULATE_FREAD */
2903 #ifdef ENCAPSULATE_FWRITE
2905 sys_fwrite (const void *ptr, size_t size, size_t nitem, FILE *stream)
2907 #ifdef INTERRUPTIBLE_IO
2909 size_t items_written = 0;
2910 const char *b = (const char *) ptr;
2914 rtnval = fwrite (b, size, nitem, stream);
2917 if (ferror (stream) && errno == EINTR)
2920 return items_written;
2924 items_written += rtnval;
2926 return (items_written);
2928 return fwrite (ptr, size, nitem, stream);
2931 #endif /* ENCAPSULATE_FWRITE */
2934 /********************* directory calls *******************/
2936 #ifdef ENCAPSULATE_CHDIR
2938 sys_chdir (const char *path)
2940 PATHNAME_CONVERT_OUT (path);
2941 return chdir (path);
2943 #endif /* ENCAPSULATE_CHDIR */
2946 #ifdef ENCAPSULATE_MKDIR
2948 sys_mkdir (const char *path, mode_t mode)
2950 PATHNAME_CONVERT_OUT (path);
2952 return mkdir (path);
2954 return mkdir (path, mode);
2957 #endif /* ENCAPSULATE_MKDIR */
2960 #ifdef ENCAPSULATE_OPENDIR
2962 sys_opendir (const char *filename)
2965 PATHNAME_CONVERT_OUT (filename);
2967 while (!(rtnval = opendir (filename))
2968 && (errno == EINTR))
2972 #endif /* ENCAPSULATE_OPENDIR */
2975 #ifdef ENCAPSULATE_READDIR
2977 sys_readdir (DIR *dirp)
2981 /* Apparently setting errno is necessary on some systems?
2982 Maybe readdir() doesn't always set errno ?! */
2983 while (!(errno = 0, rtnval = readdir (dirp))
2984 && (errno == EINTR))
2989 if (rtnval == NULL) /* End of directory */
2992 const Extbyte * const external_name = (const Extbyte *) rtnval->d_name;
2993 Extcount external_len = strlen (rtnval->d_name);
2994 const Bufbyte *internal_name;
2995 Bytecount internal_len;
2997 TO_INTERNAL_FORMAT (DATA, (external_name, external_len),
2998 ALLOCA, (internal_name, internal_len),
3001 /* check for common case of ASCII filename */
3002 if (internal_len == external_len &&
3003 !memcmp (external_name, internal_name, internal_len))
3006 { /* Non-ASCII filename */
3007 static Bufbyte_dynarr *internal_DIRENTRY;
3008 if (!internal_DIRENTRY)
3009 internal_DIRENTRY = Dynarr_new (Bufbyte);
3011 Dynarr_reset (internal_DIRENTRY);
3013 Dynarr_add_many (internal_DIRENTRY, (Bufbyte *) rtnval,
3014 offsetof (DIRENTRY, d_name));
3017 Dynarr_add_many (internal_DIRENTRY, internal_name, internal_len);
3018 Dynarr_add (internal_DIRENTRY, '\0'); /* NUL-terminate */
3019 return (DIRENTRY *) Dynarr_atp (internal_DIRENTRY, 0);
3024 #endif /* ENCAPSULATE_READDIR */
3027 #ifdef ENCAPSULATE_CLOSEDIR
3029 sys_closedir (DIR *dirp)
3033 while ((rtnval = closedir (dirp)) == -1
3034 && (errno == EINTR))
3038 #endif /* ENCAPSULATE_CLOSEDIR */
3041 #ifdef ENCAPSULATE_RMDIR
3043 sys_rmdir (const char *path)
3045 PATHNAME_CONVERT_OUT (path);
3046 return rmdir (path);
3048 #endif /* ENCAPSULATE_RMDIR */
3051 /***************** file-information calls ******************/
3053 #ifdef ENCAPSULATE_ACCESS
3055 sys_access (const char *path, int mode)
3057 PATHNAME_CONVERT_OUT (path);
3058 return access (path, mode);
3060 #endif /* ENCAPSULATE_ACCESS */
3064 #ifdef ENCAPSULATE_EACCESS
3066 sys_eaccess (const char *path, int mode)
3068 PATHNAME_CONVERT_OUT (path);
3069 return eaccess (path, mode);
3071 #endif /* ENCAPSULATE_EACCESS */
3072 #endif /* HAVE_EACCESS */
3075 #ifdef ENCAPSULATE_LSTAT
3077 sys_lstat (const char *path, struct stat *buf)
3079 PATHNAME_CONVERT_OUT (path);
3080 return lstat (path, buf);
3082 #endif /* ENCAPSULATE_LSTAT */
3085 #ifdef ENCAPSULATE_READLINK
3087 sys_readlink (const char *path, char *buf, size_t bufsiz)
3089 PATHNAME_CONVERT_OUT (path);
3090 /* #### currently we don't do conversions on the incoming data */
3091 return readlink (path, buf, bufsiz);
3093 #endif /* ENCAPSULATE_READLINK */
3095 #ifdef ENCAPSULATE_FSTAT
3097 sys_fstat (int fd, struct stat *buf)
3100 return mswindows_fstat (fd, buf);
3102 return fstat (fd, buf);
3105 #endif /* ENCAPSULATE_FSTAT */
3108 xemacs_stat (const char *path, struct stat *buf)
3110 PATHNAME_CONVERT_OUT (path);
3112 return mswindows_stat (path, buf);
3114 return stat (path, buf);
3118 /****************** file-manipulation calls *****************/
3120 #ifdef ENCAPSULATE_CHMOD
3122 sys_chmod (const char *path, mode_t mode)
3124 PATHNAME_CONVERT_OUT (path);
3125 return chmod (path, mode);
3127 #endif /* ENCAPSULATE_CHMOD */
3130 #ifdef ENCAPSULATE_CREAT
3132 sys_creat (const char *path, mode_t mode)
3134 PATHNAME_CONVERT_OUT (path);
3135 return creat (path, mode);
3137 #endif /* ENCAPSULATE_CREAT */
3140 #ifdef ENCAPSULATE_LINK
3142 sys_link (const char *existing, const char *new)
3144 PATHNAME_CONVERT_OUT (existing);
3145 PATHNAME_CONVERT_OUT (new);
3146 return link (existing, new);
3148 #endif /* ENCAPSULATE_LINK */
3151 #ifdef ENCAPSULATE_RENAME
3153 sys_rename (const char *old, const char *new)
3155 PATHNAME_CONVERT_OUT (old);
3156 PATHNAME_CONVERT_OUT (new);
3158 /* Windows rename fails if NEW exists */
3159 if (rename (old, new) == 0)
3161 /* In some cases errno is EACCES if NEW exists */
3162 if (errno != EEXIST && errno != EACCES)
3164 if (unlink (new) != 0)
3166 #endif /* WIN32_NATIVE */
3167 return rename (old, new);
3169 #endif /* ENCAPSULATE_RENAME */
3172 #ifdef ENCAPSULATE_SYMLINK
3174 sys_symlink (const char *name1, const char *name2)
3176 PATHNAME_CONVERT_OUT (name1);
3177 PATHNAME_CONVERT_OUT (name2);
3178 return symlink (name1, name2);
3180 #endif /* ENCAPSULATE_SYMLINK */
3183 #ifdef ENCAPSULATE_UNLINK
3185 sys_unlink (const char *path)
3187 PATHNAME_CONVERT_OUT (path);
3188 return unlink (path);
3190 #endif /* ENCAPSULATE_UNLINK */
3193 #ifdef ENCAPSULATE_EXECVP
3195 sys_execvp (const char *path, char * const * argv)
3200 PATHNAME_CONVERT_OUT (path);
3201 for (argc = 0; argv[argc]; argc++)
3203 new_argv = alloca_array (char *, argc + 1);
3204 for (i = 0; i < argc; i++)
3206 new_argv[i] = argv[i];
3207 PATHNAME_CONVERT_OUT (new_argv[i]);
3209 new_argv[argc] = NULL;
3210 return execvp (path, new_argv);
3212 #endif /* ENCAPSULATE_EXECVP */
3215 /************************************************************************/
3216 /* Emulations of missing system calls */
3217 /************************************************************************/
3219 /***** (these are primarily required for USG, it seems) *****/
3223 getcwd (char *pathname, size_t size)
3225 return getwd (pathname);
3227 #endif /* emulate getcwd */
3232 * Warning, this function may not duplicate BSD 4.2 action properly
3233 * under error conditions.
3238 getwd (char *pathname)
3240 char *npath, *spath;
3241 #if !__STDC__ && !defined(STDC_HEADERS)
3242 extern char *getcwd ();
3245 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3248 /* On Altos 3068, getcwd can return @hostname/dir, so discard
3249 up to first slash. Should be harmless on other systems. */
3250 while (*npath && *npath != '/')
3252 strcpy (pathname, npath);
3253 xfree (spath); /* getcwd uses malloc */
3256 #endif /* HAVE_GETWD */
3257 #endif /* 0 - mrb */
3260 * Emulate rename using unlink/link. Note that this is
3261 * only partially correct. Also, doesn't enforce restriction
3262 * that files be of same type (regular->regular, dir->dir, etc).
3267 rename (const char *from, const char *to)
3269 if (access (from, 0) == 0)
3272 if (link (from, to) == 0)
3273 if (unlink (from) == 0)
3278 #endif /* HAVE_RENAME */
3283 /* HPUX curses library references perror, but as far as we know
3284 it won't be called. Anyway this definition will do for now. */
3290 #endif /* not HAVE_PERROR */
3296 * Emulate BSD dup2. First close newd if it already exists.
3297 * Then, attempt to dup oldd. If not successful, call dup2 recursively
3298 * until we are, then close the unsuccessful ones.
3302 dup2 (int oldd, int newd)
3309 fd = fcntl (oldd, F_DUPFD, newd);
3311 error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3318 ret = dup2 (old, new);
3321 #endif /* F_DUPFD */
3324 #endif /* not HAVE_DUP2 */
3327 * Gettimeofday. Simulate as much as possible. Only accurate
3328 * to nearest second. Emacs doesn't use tzp so ignore it for now.
3331 #if !defined (HAVE_GETTIMEOFDAY)
3334 gettimeofday (struct timeval *tp, struct timezone *tzp)
3336 extern long time ();
3338 tp->tv_sec = time ((long *)0);
3341 tzp->tz_minuteswest = -1;
3345 #endif /* !HAVE_GETTIMEOFDAY */
3347 /* No need to encapsulate utime and utimes explicitly because all
3348 access to those functions goes through the following. */
3351 set_file_times (Lisp_Object path, EMACS_TIME atime, EMACS_TIME mtime)
3353 #if defined (WIN32_NATIVE)
3355 utb.actime = EMACS_SECS (atime);
3356 utb.modtime = EMACS_SECS (mtime);
3357 return mswindows_utime (path, &utb);
3358 #elif defined (HAVE_UTIME)
3361 utb.actime = EMACS_SECS (atime);
3362 utb.modtime = EMACS_SECS (mtime);
3363 LISP_STRING_TO_EXTERNAL (path, filename, Qfile_name);
3364 return utime (filename, &utb);
3365 #elif defined (HAVE_UTIMES)
3366 struct timeval tv[2];
3370 LISP_STRING_TO_EXTERNAL (path, filename, Qfile_name);
3371 return utimes (filename, tv);
3373 /* No file times setting function available. */
3380 static long ticks_per_second;
3381 static long orig_user_ticks, orig_system_ticks;
3382 EMACS_TIME orig_real_time;
3384 static int process_times_available;
3386 /* Return the relative user and system tick count. We try to
3387 maintain calculations in terms of integers as long as possible
3388 for increased accuracy. */
3391 get_process_times_1 (long *user_ticks, long *system_ticks)
3393 #if defined (_SC_CLK_TCK) || defined (CLK_TCK) && !defined(WIN32_NATIVE)
3394 /* We have the POSIX times() function available. */
3397 *user_ticks = (long) tttt.tms_utime;
3398 *system_ticks = (long) tttt.tms_stime;
3400 #elif defined (CLOCKS_PER_SEC)
3401 *user_ticks = (long) clock ();
3410 init_process_times_very_early (void)
3412 #if defined (_SC_CLK_TCK)
3413 ticks_per_second = sysconf (_SC_CLK_TCK);
3414 #elif defined (CLK_TCK)
3415 ticks_per_second = CLK_TCK;
3416 #elif defined (CLOCKS_PER_SEC)
3417 ticks_per_second = CLOCKS_PER_SEC;
3420 process_times_available = get_process_times_1 (&orig_user_ticks,
3421 &orig_system_ticks);
3422 EMACS_GET_TIME (orig_real_time);
3425 /* Return the user and system times used up by this process so far. */
3427 get_process_times (double *user_time, double *system_time, double *real_time)
3429 EMACS_TIME curr_real_time;
3430 EMACS_TIME elapsed_time;
3431 long curr_user_ticks, curr_system_ticks;
3433 EMACS_GET_TIME (curr_real_time);
3434 EMACS_SUB_TIME (elapsed_time, curr_real_time, orig_real_time);
3435 *real_time = (EMACS_SECS (elapsed_time)
3436 + ((double) EMACS_USECS (elapsed_time)) / 1000000);
3437 if (get_process_times_1 (&curr_user_ticks, &curr_system_ticks))
3439 *user_time = (((double) (curr_user_ticks - orig_user_ticks))
3440 / ticks_per_second);
3441 *system_time = (((double) (curr_system_ticks - orig_system_ticks))
3442 / ticks_per_second);
3447 *user_time = *real_time;
3458 /* Figure out how many bits the system's random number generator uses.
3459 `random' and `lrand48' are assumed to return 31 usable bits.
3460 BSD `rand' returns a 31 bit value but the low order bits are unusable;
3461 so we'll shift it and treat it like the 15-bit USG `rand'. */
3465 # define RAND_BITS 31
3466 # else /* !HAVE_RANDOM */
3467 # ifdef HAVE_LRAND48
3468 # define RAND_BITS 31
3469 # define random lrand48
3470 # else /* !HAVE_LRAND48 */
3471 # define RAND_BITS 15
3472 # if RAND_MAX == 32767
3473 # define random rand
3474 # else /* RAND_MAX != 32767 */
3475 # if RAND_MAX == 2147483647
3476 # define random() (rand () >> 16)
3477 # else /* RAND_MAX != 2147483647 */
3479 # define random rand
3481 # define random() (rand () >> 16)
3483 # endif /* RAND_MAX != 2147483647 */
3484 # endif /* RAND_MAX != 32767 */
3485 # endif /* !HAVE_LRAND48 */
3486 # endif /* !HAVE_RANDOM */
3487 #endif /* !RAND_BITS */
3489 void seed_random (long arg);
3491 seed_random (long arg)
3494 srandom ((unsigned int)arg);
3496 # ifdef HAVE_LRAND48
3499 srand ((unsigned int)arg);
3505 * Build a full Emacs-sized word out of whatever we've got.
3506 * This suffices even for a 64-bit architecture with a 15-bit rand.
3508 long get_random (void);
3512 long val = random ();
3513 #if VALBITS > RAND_BITS
3514 val = (val << RAND_BITS) ^ random ();
3515 #if VALBITS > 2*RAND_BITS
3516 val = (val << RAND_BITS) ^ random ();
3517 #if VALBITS > 3*RAND_BITS
3518 val = (val << RAND_BITS) ^ random ();
3519 #if VALBITS > 4*RAND_BITS
3520 val = (val << RAND_BITS) ^ random ();
3521 #endif /* need at least 5 */
3522 #endif /* need at least 4 */
3523 #endif /* need at least 3 */
3524 #endif /* need at least 2 */
3525 return val & ((1L << VALBITS) - 1);
3529 /************************************************************************/
3530 /* Strings corresponding to defined signals */
3531 /************************************************************************/
3533 #if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_SYS_SIGLIST)
3535 #if defined(WIN32_NATIVE) || defined(CYGWIN)
3536 const char *sys_siglist[] =
3542 "illegal instruction",
3546 "floating point exception",
3549 "segmentation violation",
3550 "bad argument to system call",
3551 "write on a pipe with no one to read it",
3553 "software termination signal from kill",
3555 "sendable stop signal not from tty",
3556 "stop signal from tty",
3557 "continue a stopped process",
3558 "child status has changed",
3559 "background read attempted from control tty",
3560 "background write attempted from control tty",
3561 "input record available at control tty",
3562 "exceeded CPU time limit",
3563 "exceeded file size limit"
3569 const char *sys_siglist[NSIG + 1] =
3571 /* AIX has changed the signals a bit */
3572 DEFER_GETTEXT ("bogus signal"), /* 0 */
3573 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3574 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3575 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3576 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3577 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3578 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3579 DEFER_GETTEXT ("crash likely"), /* 7 SIGDANGER */
3580 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3581 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3582 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3583 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3584 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3585 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3586 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3587 DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */
3588 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3589 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3590 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3591 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3592 DEFER_GETTEXT ("bogus signal"), /* 20 */
3593 DEFER_GETTEXT ("bogus signal"), /* 21 */
3594 DEFER_GETTEXT ("bogus signal"), /* 22 */
3595 DEFER_GETTEXT ("bogus signal"), /* 23 */
3596 DEFER_GETTEXT ("bogus signal"), /* 24 */
3597 DEFER_GETTEXT ("LAN I/O interrupt"), /* 25 SIGAIO */
3598 DEFER_GETTEXT ("PTY I/O interrupt"), /* 26 SIGPTY */
3599 DEFER_GETTEXT ("I/O intervention required"), /* 27 SIGIOINT */
3601 DEFER_GETTEXT ("HFT grant"), /* 28 SIGGRANT */
3602 DEFER_GETTEXT ("HFT retract"), /* 29 SIGRETRACT */
3603 DEFER_GETTEXT ("HFT sound done"), /* 30 SIGSOUND */
3604 DEFER_GETTEXT ("HFT input ready"), /* 31 SIGMSG */
3608 #else /* USG, not AIX */
3609 const char *sys_siglist[NSIG + 1] =
3611 DEFER_GETTEXT ("bogus signal"), /* 0 */
3612 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3613 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3614 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3615 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3616 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3617 DEFER_GETTEXT ("IOT instruction"), /* 6 SIGIOT */
3618 DEFER_GETTEXT ("EMT instruction"), /* 7 SIGEMT */
3619 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3620 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3621 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3622 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3623 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3624 DEFER_GETTEXT ("write on a pipe with no one to read it"), /* 13 SIGPIPE */
3625 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3626 DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */
3627 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3628 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3629 DEFER_GETTEXT ("death of a child"), /* 18 SIGCLD */
3630 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3632 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3633 DEFER_GETTEXT ("urgent socket condition"), /* 21 SIGURG */
3634 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3635 DEFER_GETTEXT ("stop (cannot be caught or ignored)"), /* 23 SIGSTOP */
3636 DEFER_GETTEXT ("user stop requested from tty"), /* 24 SIGTSTP */
3637 DEFER_GETTEXT ("stopped process has been continued"), /* 25 SIGCONT */
3638 DEFER_GETTEXT ("background tty read attempted"), /* 26 SIGTTIN */
3639 DEFER_GETTEXT ("background tty write attempted"), /* 27 SIGTTOU */
3640 DEFER_GETTEXT ("virtual timer expired"), /* 28 SIGVTALRM */
3641 DEFER_GETTEXT ("profiling timer expired"), /* 29 SIGPROF */
3642 DEFER_GETTEXT ("exceeded cpu limit"), /* 30 SIGXCPU */
3643 DEFER_GETTEXT ("exceeded file size limit"), /* 31 SIGXFSZ */
3644 DEFER_GETTEXT ("process's lwps are blocked"), /* 32 SIGWAITING */
3645 DEFER_GETTEXT ("special signal used by thread library"), /* 33 SIGLWP */
3647 DEFER_GETTEXT ("special signal used by CPR"), /* 34 SIGFREEZE */
3650 DEFER_GETTEXT ("special signal used by CPR"), /* 35 SIGTHAW */
3655 #endif /* not AIX */
3658 const char *sys_siglist[NSIG + 1] =
3660 DEFER_GETTEXT ("null signal"), /* 0 SIGNULL */
3661 DEFER_GETTEXT ("hangup"), /* 1 SIGHUP */
3662 DEFER_GETTEXT ("interrupt"), /* 2 SIGINT */
3663 DEFER_GETTEXT ("quit"), /* 3 SIGQUIT */
3664 DEFER_GETTEXT ("illegal instruction"), /* 4 SIGILL */
3665 DEFER_GETTEXT ("trace trap"), /* 5 SIGTRAP */
3666 DEFER_GETTEXT ("abort termination"), /* 6 SIGABRT */
3667 DEFER_GETTEXT ("SIGEMT"), /* 7 SIGEMT */
3668 DEFER_GETTEXT ("floating point exception"), /* 8 SIGFPE */
3669 DEFER_GETTEXT ("kill"), /* 9 SIGKILL */
3670 DEFER_GETTEXT ("bus error"), /* 10 SIGBUS */
3671 DEFER_GETTEXT ("segmentation violation"), /* 11 SIGSEGV */
3672 DEFER_GETTEXT ("bad argument to system call"), /* 12 SIGSYS */
3673 DEFER_GETTEXT ("write on a pipe with no reader"), /* 13 SIGPIPE */
3674 DEFER_GETTEXT ("alarm clock"), /* 14 SIGALRM */
3675 DEFER_GETTEXT ("software termination signal"), /* 15 SIGTERM */
3676 DEFER_GETTEXT ("user defined signal 1"), /* 16 SIGUSR1 */
3677 DEFER_GETTEXT ("user defined signal 2"), /* 17 SIGUSR2 */
3678 DEFER_GETTEXT ("child stopped or terminated"), /* 18 SIGCLD */
3679 DEFER_GETTEXT ("power-fail restart"), /* 19 SIGPWR */
3680 DEFER_GETTEXT ("window size changed"), /* 20 SIGWINCH */
3681 DEFER_GETTEXT ("undefined"), /* 21 */
3682 DEFER_GETTEXT ("pollable event occurred"), /* 22 SIGPOLL */
3683 DEFER_GETTEXT ("sendable stop signal not from tty"), /* 23 SIGSTOP */
3684 DEFER_GETTEXT ("stop signal from tty"), /* 24 SIGSTP */
3685 DEFER_GETTEXT ("continue a stopped process"), /* 25 SIGCONT */
3686 DEFER_GETTEXT ("attempted background tty read"), /* 26 SIGTTIN */
3687 DEFER_GETTEXT ("attempted background tty write"), /* 27 SIGTTOU */
3688 DEFER_GETTEXT ("undefined"), /* 28 */
3689 DEFER_GETTEXT ("undefined"), /* 29 */
3690 DEFER_GETTEXT ("undefined"), /* 30 */
3691 DEFER_GETTEXT ("undefined"), /* 31 */
3692 DEFER_GETTEXT ("undefined"), /* 32 */
3693 DEFER_GETTEXT ("socket (TCP/IP) urgent data arrival"), /* 33 SIGURG */
3694 DEFER_GETTEXT ("I/O is possible"), /* 34 SIGIO */
3695 DEFER_GETTEXT ("exceeded cpu time limit"), /* 35 SIGXCPU */
3696 DEFER_GETTEXT ("exceeded file size limit"), /* 36 SIGXFSZ */
3697 DEFER_GETTEXT ("virtual time alarm"), /* 37 SIGVTALRM */
3698 DEFER_GETTEXT ("profiling time alarm"), /* 38 SIGPROF */
3699 DEFER_GETTEXT ("undefined"), /* 39 */
3700 DEFER_GETTEXT ("file record locks revoked"), /* 40 SIGLOST */
3701 DEFER_GETTEXT ("undefined"), /* 41 */
3702 DEFER_GETTEXT ("undefined"), /* 42 */
3703 DEFER_GETTEXT ("undefined"), /* 43 */
3704 DEFER_GETTEXT ("undefined"), /* 44 */
3705 DEFER_GETTEXT ("undefined"), /* 45 */
3706 DEFER_GETTEXT ("undefined"), /* 46 */
3707 DEFER_GETTEXT ("undefined"), /* 47 */
3708 DEFER_GETTEXT ("undefined"), /* 48 */
3709 DEFER_GETTEXT ("undefined"), /* 49 */
3710 DEFER_GETTEXT ("undefined"), /* 50 */
3711 DEFER_GETTEXT ("undefined"), /* 51 */
3712 DEFER_GETTEXT ("undefined"), /* 52 */
3713 DEFER_GETTEXT ("undefined"), /* 53 */
3714 DEFER_GETTEXT ("undefined"), /* 54 */
3715 DEFER_GETTEXT ("undefined"), /* 55 */
3716 DEFER_GETTEXT ("undefined"), /* 56 */
3717 DEFER_GETTEXT ("undefined"), /* 57 */
3718 DEFER_GETTEXT ("undefined"), /* 58 */
3719 DEFER_GETTEXT ("undefined"), /* 59 */
3720 DEFER_GETTEXT ("undefined"), /* 60 */
3721 DEFER_GETTEXT ("undefined"), /* 61 */
3722 DEFER_GETTEXT ("undefined"), /* 62 */
3723 DEFER_GETTEXT ("undefined"), /* 63 */
3724 DEFER_GETTEXT ("notification message in mess. queue"), /* 64 SIGDGNOTIFY */
3729 #endif /* ! SYS_SIGLIST_DECLARED && ! HAVE_SYS_SIGLIST */
3732 /************************************************************************/
3733 /* Directory routines for systems that don't have them */
3734 /************************************************************************/
3736 #ifdef SYSV_SYSTEM_DIR
3740 #if defined(BROKEN_CLOSEDIR) || !defined(HAVE_CLOSEDIR)
3742 closedir (DIR *dirp) /* stream from opendir */
3746 rtnval = sys_close (dirp->dd_fd);
3748 /* Some systems (like Solaris) allocate the buffer and the DIR all
3749 in one block. Why in the world are we freeing this ourselves
3751 #if ! (defined (sun) && defined (USG5_4))
3752 xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3754 xfree ((char *) dirp);
3757 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3758 #endif /* SYSV_SYSTEM_DIR */
3760 #ifdef NONSYSTEM_DIR_LIBRARY
3763 opendir (const char *filename) /* name of directory */
3765 DIR *dirp; /* -> malloc'ed storage */
3766 int fd; /* file descriptor for read */
3767 struct stat sbuf; /* result of fstat */
3769 fd = sys_open (filename, O_RDONLY);
3773 if (fstat (fd, &sbuf) < 0
3774 || (sbuf.st_mode & S_IFMT) != S_IFDIR
3775 || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3778 return 0; /* bad luck today */
3782 dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
3788 closedir (DIR *dirp) /* stream from opendir */
3790 sys_close (dirp->dd_fd);
3798 ino_t od_ino; /* inode */
3799 char od_name[DIRSIZ]; /* filename */
3802 static struct direct dir_static; /* simulated directory contents */
3806 readdir (DIR *dirp) /* stream from opendir */
3808 struct olddir *dp; /* -> directory data */
3812 if (dirp->dd_loc >= dirp->dd_size)
3813 dirp->dd_loc = dirp->dd_size = 0;
3815 if (dirp->dd_size == 0 /* refill buffer */
3816 && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3819 dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3820 dirp->dd_loc += sizeof (struct olddir);
3822 if (dp->od_ino != 0) /* not deleted entry */
3824 dir_static.d_ino = dp->od_ino;
3825 strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3826 dir_static.d_name[DIRSIZ] = '\0';
3827 dir_static.d_namlen = strlen (dir_static.d_name);
3828 dir_static.d_reclen = sizeof (struct direct)
3830 + dir_static.d_namlen - dir_static.d_namlen % 4;
3831 return &dir_static; /* -> simulated structure */
3837 #endif /* NONSYSTEM_DIR_LIBRARY */
3840 /* mkdir and rmdir functions, for systems which don't have them. */
3844 * Written by Robert Rother, Mariah Corporation, August 1985.
3846 * If you want it, it's yours. All I ask in return is that if you
3847 * figure out how to do this in a Bourne Shell script you send me
3849 * sdcsvax!rmr or rmr@uscd
3851 * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3852 * subroutine. 11Mar86; hoptoad!gnu
3854 * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3855 * subroutine didn't return EEXIST. It does now.
3861 #ifdef MKDIR_PROTOTYPE
3865 mkdir (const char *dpath, int dmode)
3868 int cpid, status, fd;
3869 struct stat statbuf;
3871 if (stat (dpath, &statbuf) == 0) /* we do want stat() here */
3873 errno = EEXIST; /* Stat worked, so it already exists */
3877 /* If stat fails for a reason other than non-existence, return error */
3878 if (errno != ENOENT)
3881 synch_process_alive = 1;
3882 switch (cpid = fork ())
3885 case -1: /* Error in fork() */
3886 return -1; /* Errno is set already */
3888 case 0: /* Child process */
3891 * Cheap hack to set mode of new directory. Since this
3892 * child process is going away anyway, we zap its umask.
3893 * ####, this won't suffice to set SUID, SGID, etc. on this
3894 * directory. Does anybody care?
3896 status = umask (0); /* Get current umask */
3897 status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
3898 fd = sys_open ("/dev/null", O_RDWR);
3901 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3902 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3903 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3905 execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3906 _exit (-1); /* Can't exec /bin/mkdir */
3909 default: /* Parent process */
3910 wait_for_termination (cpid);
3913 if (synch_process_death != 0 || synch_process_retcode != 0)
3915 errno = EIO; /* We don't know why, but */
3916 return -1; /* /bin/mkdir failed */
3921 #endif /* not HAVE_MKDIR */
3925 rmdir (const char *dpath)
3927 int cpid, status, fd;
3928 struct stat statbuf;
3930 if (stat (dpath, &statbuf) != 0) /* we do want stat() here */
3932 /* Stat just set errno. We don't have to */
3936 synch_process_alive = 1;
3937 switch (cpid = fork ())
3940 case -1: /* Error in fork() */
3941 return (-1); /* Errno is set already */
3943 case 0: /* Child process */
3944 fd = sys_open("/dev/null", O_RDWR);
3947 if (fd != STDIN_FILENO) dup2 (fd, STDIN_FILENO);
3948 if (fd != STDOUT_FILENO) dup2 (fd, STDOUT_FILENO);
3949 if (fd != STDERR_FILENO) dup2 (fd, STDERR_FILENO);
3951 execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3952 _exit (-1); /* Can't exec /bin/mkdir */
3954 default: /* Parent process */
3955 wait_for_termination (cpid);
3958 if (synch_process_death != 0 ||
3959 synch_process_retcode != 0)
3961 errno = EIO; /* We don't know why, but */
3962 return -1; /* /bin/rmdir failed */
3967 #endif /* !HAVE_RMDIR */
3970 /************************************************************************/
3971 /* Misc. SunOS crap */
3972 /************************************************************************/
3976 /* These are included on Sunos 4.1 when we do not use shared libraries.
3977 X11 libraries may refer to these functions but (we hope) do not
3978 actually call them. */
3998 #endif /* USE_DL_STUBS */