]> code.delx.au - gnu-emacs/blob - src/sysdep.c
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Remove support for Mac Carbon.
[gnu-emacs] / src / sysdep.c
1 /* Interfaces to system-dependent kernel and library entries.
2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5
6 This file is part of GNU Emacs.
7
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <signal.h>
26 #include <stdio.h>
27 #include <setjmp.h>
28 #ifdef HAVE_UNISTD_H
29 #include <unistd.h>
30 #endif
31 #include "lisp.h"
32 /* Including stdlib.h isn't necessarily enough to get srandom
33 declared, e.g. without __USE_XOPEN_EXTENDED with glibc 2. */
34
35 /* The w32 build defines select stuff in w32.h, which is included by
36 sys/select.h (included below). */
37 #ifndef WINDOWSNT
38 #include "sysselect.h"
39 #endif
40
41 #include "blockinput.h"
42
43 #ifdef WINDOWSNT
44 #define read sys_read
45 #define write sys_write
46 #include <windows.h>
47 #ifndef NULL
48 #define NULL 0
49 #endif
50 #endif /* not WINDOWSNT */
51
52 /* Does anyone other than VMS need this? */
53 #ifndef fwrite
54 #define sys_fwrite fwrite
55 #else
56 #undef fwrite
57 #endif
58
59 #include <sys/types.h>
60 #include <sys/stat.h>
61 #include <errno.h>
62
63 #ifdef HAVE_SETPGID
64 #if !defined (USG) || defined (BSD_PGRPS)
65 #undef setpgrp
66 #define setpgrp setpgid
67 #endif
68 #endif
69
70 /* Get SI_SRPC_DOMAIN, if it is available. */
71 #ifdef HAVE_SYS_SYSTEMINFO_H
72 #include <sys/systeminfo.h>
73 #endif
74
75 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
76 #include <dos.h>
77 #include "dosfns.h"
78 #include "msdos.h"
79 #include <sys/param.h>
80
81 #if __DJGPP__ > 1
82 extern int etext;
83 extern unsigned start __asm__ ("start");
84 #endif
85 #endif
86
87 #ifndef USE_CRT_DLL
88 #ifndef errno
89 extern int errno;
90 #endif
91 #endif
92
93 #ifdef VMS
94 #include <rms.h>
95 #include <ttdef.h>
96 #include <tt2def.h>
97 #include <iodef.h>
98 #include <ssdef.h>
99 #include <descrip.h>
100 #include <fibdef.h>
101 #include <atrdef.h>
102 #include <ctype.h>
103 #include <string.h>
104 #ifdef __GNUC__
105 #include <sys/file.h>
106 #else
107 #include <file.h>
108 #endif
109 #undef F_SETFL
110 #ifndef RAB$C_BID
111 #include <rab.h>
112 #endif
113 #define MAXIOSIZE (32 * PAGESIZE) /* Don't I/O more than 32 blocks at a time */
114 #endif /* VMS */
115
116 #ifndef VMS
117 #include <sys/file.h>
118 #endif /* not VMS */
119
120 #ifdef HAVE_FCNTL_H
121 #include <fcntl.h>
122 #endif
123
124 #ifndef MSDOS
125 #include <sys/ioctl.h>
126 #endif
127
128 #include "systty.h"
129 #include "syswait.h"
130
131 #if defined (USG)
132 #include <sys/utsname.h>
133 #include <memory.h>
134 #endif /* USG */
135
136 extern int quit_char;
137
138 #include "keyboard.h"
139 #include "frame.h"
140 #include "window.h"
141 #include "termhooks.h"
142 #include "termchar.h"
143 #include "termopts.h"
144 #include "dispextern.h"
145 #include "process.h"
146 #include "cm.h" /* for reset_sys_modes */
147
148 /* For serial_configure and serial_open. */
149 extern Lisp_Object QCport, QCspeed, QCprocess;
150 extern Lisp_Object QCbytesize, QCstopbits, QCparity, Qodd, Qeven;
151 extern Lisp_Object QCflowcontrol, Qhw, Qsw, QCsummary;
152
153 #ifdef WINDOWSNT
154 #include <direct.h>
155 /* In process.h which conflicts with the local copy. */
156 #define _P_WAIT 0
157 int _cdecl _spawnlp (int, const char *, const char *, ...);
158 int _cdecl _getpid (void);
159 extern char *getwd (char *);
160 #endif
161
162 #ifdef NONSYSTEM_DIR_LIBRARY
163 #include "ndir.h"
164 #endif /* NONSYSTEM_DIR_LIBRARY */
165
166 #include "syssignal.h"
167 #include "systime.h"
168 #ifdef HAVE_UTIME_H
169 #include <utime.h>
170 #endif
171
172 #ifndef HAVE_UTIMES
173 #ifndef HAVE_STRUCT_UTIMBUF
174 /* We want to use utime rather than utimes, but we couldn't find the
175 structure declaration. We'll use the traditional one. */
176 struct utimbuf {
177 long actime;
178 long modtime;
179 };
180 #endif
181 #endif
182
183 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */
184 #ifndef LPASS8
185 #define LPASS8 0
186 #endif
187
188 static int baud_convert[] =
189 {
190 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
191 1800, 2400, 4800, 9600, 19200, 38400
192 };
193
194 #ifdef HAVE_SPEED_T
195 #include <termios.h>
196 #else
197 #if defined (HAVE_LIBNCURSES) && ! defined (NCURSES_OSPEED_T)
198 #else
199 #if defined (HAVE_TERMIOS_H) && defined (GNU_LINUX)
200 #include <termios.h>
201 #endif
202 #endif
203 #endif
204
205 int emacs_ospeed;
206
207 void croak P_ ((char *)) NO_RETURN;
208
209 /* Temporary used by `sigblock' when defined in terms of signprocmask. */
210
211 SIGMASKTYPE sigprocmask_set;
212
213
214 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
215
216 /* Return the current working directory. Returns NULL on errors.
217 Any other returned value must be freed with free. This is used
218 only when get_current_dir_name is not defined on the system. */
219 char*
220 get_current_dir_name ()
221 {
222 char *buf;
223 char *pwd;
224 struct stat dotstat, pwdstat;
225 /* If PWD is accurate, use it instead of calling getwd. PWD is
226 sometimes a nicer name, and using it may avoid a fatal error if a
227 parent directory is searchable but not readable. */
228 if ((pwd = getenv ("PWD")) != 0
229 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
230 && stat (pwd, &pwdstat) == 0
231 && stat (".", &dotstat) == 0
232 && dotstat.st_ino == pwdstat.st_ino
233 && dotstat.st_dev == pwdstat.st_dev
234 #ifdef MAXPATHLEN
235 && strlen (pwd) < MAXPATHLEN
236 #endif
237 )
238 {
239 buf = (char *) malloc (strlen (pwd) + 1);
240 if (!buf)
241 return NULL;
242 strcpy (buf, pwd);
243 }
244 #ifdef HAVE_GETCWD
245 else
246 {
247 size_t buf_size = 1024;
248 buf = (char *) malloc (buf_size);
249 if (!buf)
250 return NULL;
251 for (;;)
252 {
253 if (getcwd (buf, buf_size) == buf)
254 break;
255 if (errno != ERANGE)
256 {
257 int tmp_errno = errno;
258 free (buf);
259 errno = tmp_errno;
260 return NULL;
261 }
262 buf_size *= 2;
263 buf = (char *) realloc (buf, buf_size);
264 if (!buf)
265 return NULL;
266 }
267 }
268 #else
269 else
270 {
271 /* We need MAXPATHLEN here. */
272 buf = (char *) malloc (MAXPATHLEN + 1);
273 if (!buf)
274 return NULL;
275 if (getwd (buf) == NULL)
276 {
277 int tmp_errno = errno;
278 free (buf);
279 errno = tmp_errno;
280 return NULL;
281 }
282 }
283 #endif
284 return buf;
285 }
286 #endif
287
288 \f
289 /* Discard pending input on all input descriptors. */
290
291 void
292 discard_tty_input ()
293 {
294 #ifndef WINDOWSNT
295 struct emacs_tty buf;
296
297 if (noninteractive)
298 return;
299
300 #ifdef VMS
301 end_kbd_input ();
302 SYS$QIOW (0, fileno (CURTTY()->input), IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
303 &buf.main, 0, 0, terminator_mask, 0, 0);
304 queue_kbd_input ();
305 #else /* not VMS */
306 #ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
307 while (dos_keyread () != -1)
308 ;
309 #else /* not MSDOS */
310 {
311 struct tty_display_info *tty;
312 for (tty = tty_list; tty; tty = tty->next)
313 {
314 if (tty->input) /* Is the device suspended? */
315 {
316 EMACS_GET_TTY (fileno (tty->input), &buf);
317 EMACS_SET_TTY (fileno (tty->input), &buf, 0);
318 }
319 }
320 }
321 #endif /* not MSDOS */
322 #endif /* not VMS */
323 #endif /* not WINDOWSNT */
324 }
325
326 \f
327 #ifdef SIGTSTP
328
329 /* Arrange for character C to be read as the next input from
330 the terminal.
331 XXX What if we have multiple ttys?
332 */
333
334 void
335 stuff_char (char c)
336 {
337 if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
338 return;
339
340 /* Should perhaps error if in batch mode */
341 #ifdef TIOCSTI
342 ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
343 #else /* no TIOCSTI */
344 error ("Cannot stuff terminal input characters in this version of Unix");
345 #endif /* no TIOCSTI */
346 }
347
348 #endif /* SIGTSTP */
349 \f
350 void
351 init_baud_rate (int fd)
352 {
353 if (noninteractive)
354 emacs_ospeed = 0;
355 else
356 {
357 #ifdef DOS_NT
358 emacs_ospeed = 15;
359 #else /* not DOS_NT */
360 #ifdef VMS
361 struct sensemode sg;
362
363 SYS$QIOW (0, fd, IO$_SENSEMODE, &sg, 0, 0,
364 &sg.class, 12, 0, 0, 0, 0 );
365 emacs_ospeed = sg.xmit_baud;
366 #else /* not VMS */
367 #ifdef HAVE_TERMIOS
368 struct termios sg;
369
370 sg.c_cflag = B9600;
371 tcgetattr (fd, &sg);
372 emacs_ospeed = cfgetospeed (&sg);
373 #else /* neither VMS nor TERMIOS */
374 #ifdef HAVE_TERMIO
375 struct termio sg;
376
377 sg.c_cflag = B9600;
378 #ifdef HAVE_TCATTR
379 tcgetattr (fd, &sg);
380 #else
381 ioctl (fd, TCGETA, &sg);
382 #endif
383 emacs_ospeed = sg.c_cflag & CBAUD;
384 #else /* neither VMS nor TERMIOS nor TERMIO */
385 struct sgttyb sg;
386
387 sg.sg_ospeed = B9600;
388 if (ioctl (fd, TIOCGETP, &sg) < 0)
389 abort ();
390 emacs_ospeed = sg.sg_ospeed;
391 #endif /* not HAVE_TERMIO */
392 #endif /* not HAVE_TERMIOS */
393 #endif /* not VMS */
394 #endif /* not DOS_NT */
395 }
396
397 baud_rate = (emacs_ospeed < sizeof baud_convert / sizeof baud_convert[0]
398 ? baud_convert[emacs_ospeed] : 9600);
399 if (baud_rate == 0)
400 baud_rate = 1200;
401 }
402
403 \f
404 /*ARGSUSED*/
405 void
406 set_exclusive_use (fd)
407 int fd;
408 {
409 #ifdef FIOCLEX
410 ioctl (fd, FIOCLEX, 0);
411 #endif
412 /* Ok to do nothing if this feature does not exist */
413 }
414 \f
415 #ifndef subprocesses
416
417 wait_without_blocking ()
418 {
419 #ifdef BSD_SYSTEM
420 wait3 (0, WNOHANG | WUNTRACED, 0);
421 #else
422 croak ("wait_without_blocking");
423 #endif
424 synch_process_alive = 0;
425 }
426
427 #endif /* not subprocesses */
428
429 int wait_debugging; /* Set nonzero to make following function work under dbx
430 (at least for bsd). */
431
432 SIGTYPE
433 wait_for_termination_signal ()
434 {}
435
436 /* Wait for subprocess with process id `pid' to terminate and
437 make sure it will get eliminated (not remain forever as a zombie) */
438
439 void
440 wait_for_termination (pid)
441 int pid;
442 {
443 while (1)
444 {
445 #ifdef subprocesses
446 #ifdef VMS
447 int status;
448
449 status = SYS$FORCEX (&pid, 0, 0);
450 break;
451 #else /* not VMS */
452 #if defined (BSD_SYSTEM) || defined (HPUX)
453 /* Note that kill returns -1 even if the process is just a zombie now.
454 But inevitably a SIGCHLD interrupt should be generated
455 and child_sig will do wait3 and make the process go away. */
456 /* There is some indication that there is a bug involved with
457 termination of subprocesses, perhaps involving a kernel bug too,
458 but no idea what it is. Just as a hunch we signal SIGCHLD to see
459 if that causes the problem to go away or get worse. */
460 sigsetmask (sigmask (SIGCHLD));
461 if (0 > kill (pid, 0))
462 {
463 sigsetmask (SIGEMPTYMASK);
464 kill (getpid (), SIGCHLD);
465 break;
466 }
467 if (wait_debugging)
468 sleep (1);
469 else
470 sigpause (SIGEMPTYMASK);
471 #else /* not BSD_SYSTEM, and not HPUX version >= 6 */
472 #ifdef POSIX_SIGNALS /* would this work for GNU/Linux as well? */
473 sigblock (sigmask (SIGCHLD));
474 errno = 0;
475 if (kill (pid, 0) == -1 && errno == ESRCH)
476 {
477 sigunblock (sigmask (SIGCHLD));
478 break;
479 }
480
481 sigsuspend (&empty_mask);
482 #else /* not POSIX_SIGNALS */
483 #ifdef HAVE_SYSV_SIGPAUSE
484 sighold (SIGCHLD);
485 if (0 > kill (pid, 0))
486 {
487 sigrelse (SIGCHLD);
488 break;
489 }
490 sigpause (SIGCHLD);
491 #else /* not HAVE_SYSV_SIGPAUSE */
492 #ifdef WINDOWSNT
493 wait (0);
494 break;
495 #else /* not WINDOWSNT */
496 if (0 > kill (pid, 0))
497 break;
498 /* Using sleep instead of pause avoids timing error.
499 If the inferior dies just before the sleep,
500 we lose just one second. */
501 sleep (1);
502 #endif /* not WINDOWSNT */
503 #endif /* not HAVE_SYSV_SIGPAUSE */
504 #endif /* not POSIX_SIGNALS */
505 #endif /* not BSD_SYSTEM, and not HPUX version >= 6 */
506 #endif /* not VMS */
507 #else /* not subprocesses */
508 #if __DJGPP__ > 1
509 break;
510 #else /* not __DJGPP__ > 1 */
511 if (kill (pid, 0) < 0)
512 break;
513 wait (0);
514 #endif /* not __DJGPP__ > 1*/
515 #endif /* not subprocesses */
516 }
517 }
518
519 #ifdef subprocesses
520
521 /*
522 * flush any pending output
523 * (may flush input as well; it does not matter the way we use it)
524 */
525
526 void
527 flush_pending_output (channel)
528 int channel;
529 {
530 #ifdef HAVE_TERMIOS
531 /* If we try this, we get hit with SIGTTIN, because
532 the child's tty belongs to the child's pgrp. */
533 #else
534 #ifdef TCFLSH
535 ioctl (channel, TCFLSH, 1);
536 #else
537 #ifdef TIOCFLUSH
538 int zero = 0;
539 /* 3rd arg should be ignored
540 but some 4.2 kernels actually want the address of an int
541 and nonzero means something different. */
542 ioctl (channel, TIOCFLUSH, &zero);
543 #endif
544 #endif
545 #endif
546 }
547 \f
548 #ifndef VMS
549 /* Set up the terminal at the other end of a pseudo-terminal that
550 we will be controlling an inferior through.
551 It should not echo or do line-editing, since that is done
552 in Emacs. No padding needed for insertion into an Emacs buffer. */
553
554 void
555 child_setup_tty (out)
556 int out;
557 {
558 #ifndef DOS_NT
559 struct emacs_tty s;
560
561 EMACS_GET_TTY (out, &s);
562
563 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
564 s.main.c_oflag |= OPOST; /* Enable output postprocessing */
565 s.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */
566 #ifdef NLDLY
567 /* http://lists.gnu.org/archive/html/emacs-devel/2008-05/msg00406.html
568 Some versions of GNU Hurd do not have FFDLY? */
569 #ifdef FFDLY
570 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
571 /* No output delays */
572 #else
573 s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY);
574 /* No output delays */
575 #endif
576 #endif
577 s.main.c_lflag &= ~ECHO; /* Disable echo */
578 s.main.c_lflag |= ISIG; /* Enable signals */
579 #ifdef IUCLC
580 s.main.c_iflag &= ~IUCLC; /* Disable downcasing on input. */
581 #endif
582 #ifdef ISTRIP
583 s.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
584 #endif
585 #ifdef OLCUC
586 s.main.c_oflag &= ~OLCUC; /* Disable upcasing on output. */
587 #endif
588 s.main.c_oflag &= ~TAB3; /* Disable tab expansion */
589 s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
590 s.main.c_lflag |= ICANON; /* Enable erase/kill and eof processing */
591 s.main.c_cc[VEOF] = 04; /* insure that EOF is Control-D */
592 s.main.c_cc[VERASE] = CDISABLE; /* disable erase processing */
593 s.main.c_cc[VKILL] = CDISABLE; /* disable kill processing */
594
595 #ifdef HPUX
596 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
597 #endif /* HPUX */
598
599 #ifdef SIGNALS_VIA_CHARACTERS
600 /* the QUIT and INTR character are used in process_send_signal
601 so set them here to something useful. */
602 if (s.main.c_cc[VQUIT] == CDISABLE)
603 s.main.c_cc[VQUIT] = '\\'&037; /* Control-\ */
604 if (s.main.c_cc[VINTR] == CDISABLE)
605 s.main.c_cc[VINTR] = 'C'&037; /* Control-C */
606 #endif /* not SIGNALS_VIA_CHARACTERS */
607
608 #ifdef AIX
609 /* AIX enhanced edit loses NULs, so disable it */
610 #ifndef IBMR2AIX
611 s.main.c_line = 0;
612 s.main.c_iflag &= ~ASCEDIT;
613 #endif
614 /* Also, PTY overloads NUL and BREAK.
615 don't ignore break, but don't signal either, so it looks like NUL. */
616 s.main.c_iflag &= ~IGNBRK;
617 s.main.c_iflag &= ~BRKINT;
618 /* rms: Formerly it set s.main.c_cc[VINTR] to 0377 here
619 unconditionally. Then a SIGNALS_VIA_CHARACTERS conditional
620 would force it to 0377. That looks like duplicated code. */
621 #ifndef SIGNALS_VIA_CHARACTERS
622 /* QUIT and INTR work better as signals, so disable character forms */
623 s.main.c_cc[VQUIT] = CDISABLE;
624 s.main.c_cc[VINTR] = CDISABLE;
625 s.main.c_lflag &= ~ISIG;
626 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
627 s.main.c_cc[VEOL] = CDISABLE;
628 s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
629 #endif /* AIX */
630
631 #else /* not HAVE_TERMIO */
632
633 s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
634 | CBREAK | TANDEM);
635 s.main.sg_flags |= LPASS8;
636 s.main.sg_erase = 0377;
637 s.main.sg_kill = 0377;
638 s.lmode = LLITOUT | s.lmode; /* Don't strip 8th bit */
639
640 #endif /* not HAVE_TERMIO */
641
642 EMACS_SET_TTY (out, &s, 0);
643
644 #endif /* not DOS_NT */
645 }
646 #endif /* not VMS */
647
648 #endif /* subprocesses */
649 \f
650 /* Record a signal code and the handler for it. */
651 struct save_signal
652 {
653 int code;
654 SIGTYPE (*handler) P_ ((int));
655 };
656
657 static void save_signal_handlers P_ ((struct save_signal *));
658 static void restore_signal_handlers P_ ((struct save_signal *));
659
660 /* Suspend the Emacs process; give terminal to its superior. */
661
662 void
663 sys_suspend ()
664 {
665 #ifdef VMS
666 /* "Foster" parentage allows emacs to return to a subprocess that attached
667 to the current emacs as a cheaper than starting a whole new process. This
668 is set up by KEPTEDITOR.COM. */
669 unsigned long parent_id, foster_parent_id;
670 char *fpid_string;
671
672 fpid_string = getenv ("EMACS_PARENT_PID");
673 if (fpid_string != NULL)
674 {
675 sscanf (fpid_string, "%x", &foster_parent_id);
676 if (foster_parent_id != 0)
677 parent_id = foster_parent_id;
678 else
679 parent_id = getppid ();
680 }
681 else
682 parent_id = getppid ();
683
684 xfree (fpid_string); /* On VMS, this was malloc'd */
685
686 if (parent_id && parent_id != 0xffffffff)
687 {
688 SIGTYPE (*oldsig)() = (int) signal (SIGINT, SIG_IGN);
689 int status = LIB$ATTACH (&parent_id) & 1;
690 signal (SIGINT, oldsig);
691 return status;
692 }
693 else
694 {
695 struct {
696 int l;
697 char *a;
698 } d_prompt;
699 d_prompt.l = sizeof ("Emacs: "); /* Our special prompt */
700 d_prompt.a = "Emacs: "; /* Just a reminder */
701 LIB$SPAWN (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, &d_prompt, 0);
702 return 1;
703 }
704 return -1;
705 #else
706 #if defined (SIGTSTP) && !defined (MSDOS)
707
708 {
709 int pgrp = EMACS_GETPGRP (0);
710 EMACS_KILLPG (pgrp, SIGTSTP);
711 }
712
713 #else /* No SIGTSTP */
714 #ifdef USG_JOBCTRL /* If you don't know what this is don't mess with it */
715 ptrace (0, 0, 0, 0); /* set for ptrace - caught by csh */
716 kill (getpid (), SIGQUIT);
717
718 #else /* No SIGTSTP or USG_JOBCTRL */
719
720 /* On a system where suspending is not implemented,
721 instead fork a subshell and let it talk directly to the terminal
722 while we wait. */
723 sys_subshell ();
724
725 #endif /* no USG_JOBCTRL */
726 #endif /* no SIGTSTP */
727 #endif /* not VMS */
728 }
729
730 /* Fork a subshell. */
731
732 void
733 sys_subshell ()
734 {
735 #ifndef VMS
736 #ifdef DOS_NT /* Demacs 1.1.2 91/10/20 Manabu Higashida */
737 int st;
738 char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS. */
739 #endif
740 int pid;
741 struct save_signal saved_handlers[5];
742 Lisp_Object dir;
743 unsigned char *str = 0;
744 int len;
745
746 saved_handlers[0].code = SIGINT;
747 saved_handlers[1].code = SIGQUIT;
748 saved_handlers[2].code = SIGTERM;
749 #ifdef SIGIO
750 saved_handlers[3].code = SIGIO;
751 saved_handlers[4].code = 0;
752 #else
753 saved_handlers[3].code = 0;
754 #endif
755
756 /* Mentioning current_buffer->buffer would mean including buffer.h,
757 which somehow wedges the hp compiler. So instead... */
758
759 dir = intern ("default-directory");
760 if (NILP (Fboundp (dir)))
761 goto xyzzy;
762 dir = Fsymbol_value (dir);
763 if (!STRINGP (dir))
764 goto xyzzy;
765
766 dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
767 str = (unsigned char *) alloca (SCHARS (dir) + 2);
768 len = SCHARS (dir);
769 bcopy (SDATA (dir), str, len);
770 if (str[len - 1] != '/') str[len++] = '/';
771 str[len] = 0;
772 xyzzy:
773
774 #ifdef DOS_NT
775 pid = 0;
776 #if __DJGPP__ > 1
777 save_signal_handlers (saved_handlers);
778 synch_process_alive = 1;
779 #endif /* __DJGPP__ > 1 */
780 #else
781 pid = vfork ();
782 if (pid == -1)
783 error ("Can't spawn subshell");
784 #endif
785
786 if (pid == 0)
787 {
788 char *sh = 0;
789
790 #ifdef DOS_NT /* MW, Aug 1993 */
791 getwd (oldwd);
792 if (sh == 0)
793 sh = (char *) egetenv ("SUSPEND"); /* KFS, 1994-12-14 */
794 #endif
795 if (sh == 0)
796 sh = (char *) egetenv ("SHELL");
797 if (sh == 0)
798 sh = "sh";
799
800 /* Use our buffer's default directory for the subshell. */
801 if (str)
802 chdir ((char *) str);
803
804 #ifdef subprocesses
805 close_process_descs (); /* Close Emacs's pipes/ptys */
806 #endif
807
808 #ifdef SET_EMACS_PRIORITY
809 {
810 extern EMACS_INT emacs_priority;
811
812 if (emacs_priority < 0)
813 nice (-emacs_priority);
814 }
815 #endif
816
817 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
818 {
819 char *epwd = getenv ("PWD");
820 char old_pwd[MAXPATHLEN+1+4];
821
822 /* If PWD is set, pass it with corrected value. */
823 if (epwd)
824 {
825 strcpy (old_pwd, epwd);
826 if (str[len - 1] == '/')
827 str[len - 1] = '\0';
828 setenv ("PWD", str, 1);
829 }
830 st = system (sh);
831 chdir (oldwd);
832 if (epwd)
833 putenv (old_pwd); /* restore previous value */
834 }
835 #else /* not MSDOS */
836 #ifdef WINDOWSNT
837 /* Waits for process completion */
838 pid = _spawnlp (_P_WAIT, sh, sh, NULL);
839 chdir (oldwd);
840 if (pid == -1)
841 write (1, "Can't execute subshell", 22);
842 #else /* not WINDOWSNT */
843 execlp (sh, sh, (char *) 0);
844 write (1, "Can't execute subshell", 22);
845 _exit (1);
846 #endif /* not WINDOWSNT */
847 #endif /* not MSDOS */
848 }
849
850 /* Do this now if we did not do it before. */
851 #if !defined (MSDOS) || __DJGPP__ == 1
852 save_signal_handlers (saved_handlers);
853 synch_process_alive = 1;
854 #endif
855
856 #ifndef DOS_NT
857 wait_for_termination (pid);
858 #endif
859 restore_signal_handlers (saved_handlers);
860 synch_process_alive = 0;
861 #endif /* !VMS */
862 }
863
864 static void
865 save_signal_handlers (saved_handlers)
866 struct save_signal *saved_handlers;
867 {
868 while (saved_handlers->code)
869 {
870 saved_handlers->handler
871 = (SIGTYPE (*) P_ ((int))) signal (saved_handlers->code, SIG_IGN);
872 saved_handlers++;
873 }
874 }
875
876 static void
877 restore_signal_handlers (saved_handlers)
878 struct save_signal *saved_handlers;
879 {
880 while (saved_handlers->code)
881 {
882 signal (saved_handlers->code, saved_handlers->handler);
883 saved_handlers++;
884 }
885 }
886 \f
887 #ifndef SIGIO
888 /* If SIGIO is broken, don't do anything. */
889 void
890 init_sigio (int fd)
891 {
892 }
893
894 void
895 reset_sigio (int fd)
896 {
897 }
898
899 void
900 request_sigio (void)
901 {
902 }
903
904 void
905 unrequest_sigio (void)
906 {
907 }
908
909 #else
910 #ifdef F_SETFL
911
912 int old_fcntl_flags[MAXDESC];
913
914 void
915 init_sigio (fd)
916 int fd;
917 {
918 #ifdef FASYNC
919 old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
920 fcntl (fd, F_SETFL, old_fcntl_flags[fd] | FASYNC);
921 #endif
922 interrupts_deferred = 0;
923 }
924
925 void
926 reset_sigio (fd)
927 int fd;
928 {
929 #ifdef FASYNC
930 fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
931 #endif
932 }
933
934 #ifdef FASYNC /* F_SETFL does not imply existence of FASYNC */
935 /* XXX Uhm, FASYNC is not used anymore here. */
936 /* XXX Yeah, but you need it for SIGIO, don't you? */
937
938 void
939 request_sigio ()
940 {
941 if (noninteractive)
942 return;
943
944 #ifdef SIGWINCH
945 sigunblock (sigmask (SIGWINCH));
946 #endif
947 sigunblock (sigmask (SIGIO));
948
949 interrupts_deferred = 0;
950 }
951
952 void
953 unrequest_sigio (void)
954 {
955 if (noninteractive)
956 return;
957
958 #if 0 /* XXX What's wrong with blocking SIGIO under X? */
959 if (x_display_list)
960 return;
961 #endif
962
963 #ifdef SIGWINCH
964 sigblock (sigmask (SIGWINCH));
965 #endif
966 sigblock (sigmask (SIGIO));
967 interrupts_deferred = 1;
968 }
969
970 #else /* no FASYNC */
971 #ifndef MSDOS
972
973 void
974 request_sigio ()
975 {
976 if (noninteractive || read_socket_hook)
977 return;
978
979 croak ("request_sigio");
980 }
981
982 void
983 unrequest_sigio ()
984 {
985 if (noninteractive || read_socket_hook)
986 return;
987
988 croak ("unrequest_sigio");
989 }
990
991 #endif /* MSDOS */
992 #endif /* FASYNC */
993 #endif /* F_SETFL */
994 #endif /* SIGIO */
995 \f
996 /* Saving and restoring the process group of Emacs's terminal. */
997
998 #ifdef BSD_PGRPS
999
1000 /* The process group of which Emacs was a member when it initially
1001 started.
1002
1003 If Emacs was in its own process group (i.e. inherited_pgroup ==
1004 getpid ()), then we know we're running under a shell with job
1005 control (Emacs would never be run as part of a pipeline).
1006 Everything is fine.
1007
1008 If Emacs was not in its own process group, then we know we're
1009 running under a shell (or a caller) that doesn't know how to
1010 separate itself from Emacs (like sh). Emacs must be in its own
1011 process group in order to receive SIGIO correctly. In this
1012 situation, we put ourselves in our own pgroup, forcibly set the
1013 tty's pgroup to our pgroup, and make sure to restore and reinstate
1014 the tty's pgroup just like any other terminal setting. If
1015 inherited_group was not the tty's pgroup, then we'll get a
1016 SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1017 it goes foreground in the future, which is what should happen.
1018
1019 This variable is initialized in emacs.c. */
1020 int inherited_pgroup;
1021
1022 /* Split off the foreground process group to Emacs alone. When we are
1023 in the foreground, but not started in our own process group,
1024 redirect the tty device handle FD to point to our own process
1025 group. We need to be in our own process group to receive SIGIO
1026 properly. */
1027 static void
1028 narrow_foreground_group (int fd)
1029 {
1030 int me = getpid ();
1031
1032 setpgrp (0, inherited_pgroup);
1033 #if 0
1034 /* XXX inherited_pgroup should not be zero here, but GTK seems to
1035 mess this up. */
1036 if (! inherited_pgroup)
1037 abort (); /* Should not happen. */
1038 #endif
1039 if (inherited_pgroup != me)
1040 EMACS_SET_TTY_PGRP (fd, &me); /* XXX This only works on the controlling tty. */
1041 setpgrp (0, me);
1042 }
1043
1044 /* Set the tty to our original foreground group. */
1045 static void
1046 widen_foreground_group (int fd)
1047 {
1048 if (inherited_pgroup != getpid ())
1049 EMACS_SET_TTY_PGRP (fd, &inherited_pgroup);
1050 setpgrp (0, inherited_pgroup);
1051 }
1052
1053 #endif /* BSD_PGRPS */
1054 \f
1055 /* Getting and setting emacs_tty structures. */
1056
1057 /* Set *TC to the parameters associated with the terminal FD.
1058 Return zero if all's well, or -1 if we ran into an error we
1059 couldn't deal with. */
1060 int
1061 emacs_get_tty (fd, settings)
1062 int fd;
1063 struct emacs_tty *settings;
1064 {
1065 /* Retrieve the primary parameters - baud rate, character size, etcetera. */
1066 #ifdef HAVE_TCATTR
1067 /* We have those nifty POSIX tcmumbleattr functions. */
1068 bzero (&settings->main, sizeof (settings->main));
1069 if (tcgetattr (fd, &settings->main) < 0)
1070 return -1;
1071
1072 #else
1073 #ifdef HAVE_TERMIO
1074 /* The SYSV-style interface? */
1075 if (ioctl (fd, TCGETA, &settings->main) < 0)
1076 return -1;
1077
1078 #else
1079 #ifdef VMS
1080 /* Vehemently Monstrous System? :-) */
1081 if (! (SYS$QIOW (0, fd, IO$_SENSEMODE, settings, 0, 0,
1082 &settings->main.class, 12, 0, 0, 0, 0)
1083 & 1))
1084 return -1;
1085
1086 #else
1087 #ifndef DOS_NT
1088 /* I give up - I hope you have the BSD ioctls. */
1089 if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1090 return -1;
1091 #endif /* not DOS_NT */
1092 #endif
1093 #endif
1094 #endif
1095
1096 /* Suivant - Do we have to get struct ltchars data? */
1097 #ifdef HAVE_LTCHARS
1098 if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1099 return -1;
1100 #endif
1101
1102 /* How about a struct tchars and a wordful of lmode bits? */
1103 #ifdef HAVE_TCHARS
1104 if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1105 || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1106 return -1;
1107 #endif
1108
1109 /* We have survived the tempest. */
1110 return 0;
1111 }
1112
1113
1114 /* Set the parameters of the tty on FD according to the contents of
1115 *SETTINGS. If FLUSHP is non-zero, we discard input.
1116 Return 0 if all went well, and -1 if anything failed. */
1117
1118 int
1119 emacs_set_tty (fd, settings, flushp)
1120 int fd;
1121 struct emacs_tty *settings;
1122 int flushp;
1123 {
1124 /* Set the primary parameters - baud rate, character size, etcetera. */
1125 #ifdef HAVE_TCATTR
1126 int i;
1127 /* We have those nifty POSIX tcmumbleattr functions.
1128 William J. Smith <wjs@wiis.wang.com> writes:
1129 "POSIX 1003.1 defines tcsetattr to return success if it was
1130 able to perform any of the requested actions, even if some
1131 of the requested actions could not be performed.
1132 We must read settings back to ensure tty setup properly.
1133 AIX requires this to keep tty from hanging occasionally." */
1134 /* This make sure that we don't loop indefinitely in here. */
1135 for (i = 0 ; i < 10 ; i++)
1136 if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1137 {
1138 if (errno == EINTR)
1139 continue;
1140 else
1141 return -1;
1142 }
1143 else
1144 {
1145 struct termios new;
1146
1147 bzero (&new, sizeof (new));
1148 /* Get the current settings, and see if they're what we asked for. */
1149 tcgetattr (fd, &new);
1150 /* We cannot use memcmp on the whole structure here because under
1151 * aix386 the termios structure has some reserved field that may
1152 * not be filled in.
1153 */
1154 if ( new.c_iflag == settings->main.c_iflag
1155 && new.c_oflag == settings->main.c_oflag
1156 && new.c_cflag == settings->main.c_cflag
1157 && new.c_lflag == settings->main.c_lflag
1158 && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
1159 break;
1160 else
1161 continue;
1162 }
1163
1164 #else
1165 #ifdef HAVE_TERMIO
1166 /* The SYSV-style interface? */
1167 if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1168 return -1;
1169
1170 #else
1171 #ifdef VMS
1172 /* Vehemently Monstrous System? :-) */
1173 if (! (SYS$QIOW (0, fd, IO$_SETMODE, &input_iosb, 0, 0,
1174 &settings->main.class, 12, 0, 0, 0, 0)
1175 & 1))
1176 return -1;
1177
1178 #else
1179 #ifndef DOS_NT
1180 /* I give up - I hope you have the BSD ioctls. */
1181 if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1182 return -1;
1183 #endif /* not DOS_NT */
1184
1185 #endif
1186 #endif
1187 #endif
1188
1189 /* Suivant - Do we have to get struct ltchars data? */
1190 #ifdef HAVE_LTCHARS
1191 if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1192 return -1;
1193 #endif
1194
1195 /* How about a struct tchars and a wordful of lmode bits? */
1196 #ifdef HAVE_TCHARS
1197 if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1198 || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1199 return -1;
1200 #endif
1201
1202 /* We have survived the tempest. */
1203 return 0;
1204 }
1205
1206 \f
1207
1208 #ifdef F_SETOWN
1209 int old_fcntl_owner[MAXDESC];
1210 #endif /* F_SETOWN */
1211
1212 /* This may also be defined in stdio,
1213 but if so, this does no harm,
1214 and using the same name avoids wasting the other one's space. */
1215
1216 #if defined (USG) || defined (DGUX)
1217 unsigned char _sobuf[BUFSIZ+8];
1218 #else
1219 char _sobuf[BUFSIZ];
1220 #endif
1221
1222 #ifdef HAVE_LTCHARS
1223 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1224 #endif
1225 #ifdef HAVE_TCHARS
1226 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1227 #endif
1228
1229 /* Initialize the terminal mode on all tty devices that are currently
1230 open. */
1231
1232 void
1233 init_all_sys_modes (void)
1234 {
1235 struct tty_display_info *tty;
1236 for (tty = tty_list; tty; tty = tty->next)
1237 init_sys_modes (tty);
1238 }
1239
1240 /* Initialize the terminal mode on the given tty device. */
1241
1242 void
1243 init_sys_modes (tty_out)
1244 struct tty_display_info *tty_out;
1245 {
1246 struct emacs_tty tty;
1247
1248 Vtty_erase_char = Qnil;
1249
1250 if (noninteractive)
1251 return;
1252
1253 if (!tty_out->output)
1254 return; /* The tty is suspended. */
1255
1256 #ifdef VMS
1257 if (!input_ef)
1258 input_ef = get_kbd_event_flag ();
1259 /* LIB$GET_EF (&input_ef); */
1260 SYS$CLREF (input_ef);
1261 waiting_for_ast = 0;
1262 if (!timer_ef)
1263 timer_ef = get_timer_event_flag ();
1264 /* LIB$GET_EF (&timer_ef); */
1265 SYS$CLREF (timer_ef);
1266 if (input_ef / 32 != timer_ef / 32)
1267 croak ("Input and timer event flags in different clusters.");
1268 timer_eflist = ((unsigned) 1 << (input_ef % 32)) |
1269 ((unsigned) 1 << (timer_ef % 32));
1270 #ifndef VMS4_4
1271 sys_access_reinit ();
1272 #endif
1273 #endif /* VMS */
1274
1275 #ifdef BSD_PGRPS
1276 #if 0
1277 /* read_socket_hook is not global anymore. I think doing this
1278 unconditionally will not cause any problems. */
1279 if (! read_socket_hook && EQ (Vinitial_window_system, Qnil))
1280 #endif
1281 narrow_foreground_group (fileno (tty_out->input));
1282 #endif
1283
1284 if (! tty_out->old_tty)
1285 tty_out->old_tty = (struct emacs_tty *) xmalloc (sizeof (struct emacs_tty));
1286
1287 EMACS_GET_TTY (fileno (tty_out->input), tty_out->old_tty);
1288
1289 tty = *tty_out->old_tty;
1290
1291 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1292 XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);
1293
1294 tty.main.c_iflag |= (IGNBRK); /* Ignore break condition */
1295 tty.main.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */
1296 #ifdef INLCR /* I'm just being cautious,
1297 since I can't check how widespread INLCR is--rms. */
1298 tty.main.c_iflag &= ~INLCR; /* Disable map of NL to CR on input */
1299 #endif
1300 #ifdef ISTRIP
1301 tty.main.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */
1302 #endif
1303 tty.main.c_lflag &= ~ECHO; /* Disable echo */
1304 tty.main.c_lflag &= ~ICANON; /* Disable erase/kill processing */
1305 #ifdef IEXTEN
1306 tty.main.c_lflag &= ~IEXTEN; /* Disable other editing characters. */
1307 #endif
1308 tty.main.c_lflag |= ISIG; /* Enable signals */
1309 if (tty_out->flow_control)
1310 {
1311 tty.main.c_iflag |= IXON; /* Enable start/stop output control */
1312 #ifdef IXANY
1313 tty.main.c_iflag &= ~IXANY;
1314 #endif /* IXANY */
1315 }
1316 else
1317 tty.main.c_iflag &= ~IXON; /* Disable start/stop output control */
1318 tty.main.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL
1319 on output */
1320 tty.main.c_oflag &= ~TAB3; /* Disable tab expansion */
1321 #ifdef CS8
1322 if (tty_out->meta_key)
1323 {
1324 tty.main.c_cflag |= CS8; /* allow 8th bit on input */
1325 tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1326 }
1327 #endif
1328 if (tty_out->input == stdin)
1329 {
1330 tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
1331 /* Set up C-g for both SIGQUIT and SIGINT.
1332 We don't know which we will get, but we handle both alike
1333 so which one it really gives us does not matter. */
1334 tty.main.c_cc[VQUIT] = quit_char;
1335 }
1336 else
1337 {
1338 /* We normally don't get interrupt or quit signals from tty
1339 devices other than our controlling terminal; therefore,
1340 we must handle C-g as normal input. Unfortunately, this
1341 means that the interrupt and quit feature must be
1342 disabled on secondary ttys, or we would not even see the
1343 keypress.
1344
1345 Note that even though emacsclient could have special code
1346 to pass SIGINT to Emacs, we should _not_ enable
1347 interrupt/quit keys for emacsclient frames. This means
1348 that we can't break out of loops in C code from a
1349 secondary tty frame, but we can always decide what
1350 display the C-g came from, which is more important from a
1351 usability point of view. (Consider the case when two
1352 people work together using the same Emacs instance.) */
1353 tty.main.c_cc[VINTR] = CDISABLE;
1354 tty.main.c_cc[VQUIT] = CDISABLE;
1355 }
1356 tty.main.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */
1357 tty.main.c_cc[VTIME] = 0; /* no matter how long that takes. */
1358 #ifdef VSWTCH
1359 tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
1360 of C-z */
1361 #endif /* VSWTCH */
1362
1363 #if defined (__mips__) || defined (HAVE_TCATTR)
1364 #ifdef VSUSP
1365 tty.main.c_cc[VSUSP] = CDISABLE; /* Turn off mips handling of C-z. */
1366 #endif /* VSUSP */
1367 #ifdef V_DSUSP
1368 tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y. */
1369 #endif /* V_DSUSP */
1370 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP. */
1371 tty.main.c_cc[VDSUSP] = CDISABLE;
1372 #endif /* VDSUSP */
1373 #ifdef VLNEXT
1374 tty.main.c_cc[VLNEXT] = CDISABLE;
1375 #endif /* VLNEXT */
1376 #ifdef VREPRINT
1377 tty.main.c_cc[VREPRINT] = CDISABLE;
1378 #endif /* VREPRINT */
1379 #ifdef VWERASE
1380 tty.main.c_cc[VWERASE] = CDISABLE;
1381 #endif /* VWERASE */
1382 #ifdef VDISCARD
1383 tty.main.c_cc[VDISCARD] = CDISABLE;
1384 #endif /* VDISCARD */
1385
1386 if (tty_out->flow_control)
1387 {
1388 #ifdef VSTART
1389 tty.main.c_cc[VSTART] = '\021';
1390 #endif /* VSTART */
1391 #ifdef VSTOP
1392 tty.main.c_cc[VSTOP] = '\023';
1393 #endif /* VSTOP */
1394 }
1395 else
1396 {
1397 #ifdef VSTART
1398 tty.main.c_cc[VSTART] = CDISABLE;
1399 #endif /* VSTART */
1400 #ifdef VSTOP
1401 tty.main.c_cc[VSTOP] = CDISABLE;
1402 #endif /* VSTOP */
1403 }
1404 #endif /* mips or HAVE_TCATTR */
1405
1406 #ifdef AIX
1407 #ifndef IBMR2AIX
1408 /* AIX enhanced edit loses NULs, so disable it. */
1409 tty.main.c_line = 0;
1410 tty.main.c_iflag &= ~ASCEDIT;
1411 #else
1412 tty.main.c_cc[VSTRT] = CDISABLE;
1413 tty.main.c_cc[VSTOP] = CDISABLE;
1414 tty.main.c_cc[VSUSP] = CDISABLE;
1415 tty.main.c_cc[VDSUSP] = CDISABLE;
1416 #endif /* IBMR2AIX */
1417 if (tty_out->flow_control)
1418 {
1419 #ifdef VSTART
1420 tty.main.c_cc[VSTART] = '\021';
1421 #endif /* VSTART */
1422 #ifdef VSTOP
1423 tty.main.c_cc[VSTOP] = '\023';
1424 #endif /* VSTOP */
1425 }
1426 /* Also, PTY overloads NUL and BREAK.
1427 don't ignore break, but don't signal either, so it looks like NUL.
1428 This really serves a purpose only if running in an XTERM window
1429 or via TELNET or the like, but does no harm elsewhere. */
1430 tty.main.c_iflag &= ~IGNBRK;
1431 tty.main.c_iflag &= ~BRKINT;
1432 #endif
1433 #else /* if not HAVE_TERMIO */
1434 #ifdef VMS
1435 tty.main.tt_char |= TT$M_NOECHO;
1436 if (meta_key)
1437 tty.main.tt_char |= TT$M_EIGHTBIT;
1438 if (tty_out->flow_control)
1439 tty.main.tt_char |= TT$M_TTSYNC;
1440 else
1441 tty.main.tt_char &= ~TT$M_TTSYNC;
1442 tty.main.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
1443 #else /* not VMS (BSD, that is) */
1444 #ifndef DOS_NT
1445 XSETINT (Vtty_erase_char, tty.main.sg_erase);
1446 tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1447 if (meta_key)
1448 tty.main.sg_flags |= ANYP;
1449 tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
1450 #endif /* not DOS_NT */
1451 #endif /* not VMS (BSD, that is) */
1452 #endif /* not HAVE_TERMIO */
1453
1454 /* If going to use CBREAK mode, we must request C-g to interrupt
1455 and turn off start and stop chars, etc. If not going to use
1456 CBREAK mode, do this anyway so as to turn off local flow
1457 control for user coming over network on 4.2; in this case,
1458 only t_stopc and t_startc really matter. */
1459 #ifndef HAVE_TERMIO
1460 #ifdef HAVE_TCHARS
1461 /* Note: if not using CBREAK mode, it makes no difference how we
1462 set this */
1463 tty.tchars = new_tchars;
1464 tty.tchars.t_intrc = quit_char;
1465 if (tty_out->flow_control)
1466 {
1467 tty.tchars.t_startc = '\021';
1468 tty.tchars.t_stopc = '\023';
1469 }
1470
1471 tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | tty_out->old_tty.lmode;
1472
1473 #endif /* HAVE_TCHARS */
1474 #endif /* not HAVE_TERMIO */
1475
1476 #ifdef HAVE_LTCHARS
1477 tty.ltchars = new_ltchars;
1478 #endif /* HAVE_LTCHARS */
1479 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1480 if (!tty_out->term_initted)
1481 internal_terminal_init ();
1482 dos_ttraw ();
1483 #endif
1484
1485 EMACS_SET_TTY (fileno (tty_out->input), &tty, 0);
1486
1487 /* This code added to insure that, if flow-control is not to be used,
1488 we have an unlocked terminal at the start. */
1489
1490 #ifdef TCXONC
1491 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
1492 #endif
1493 #ifdef TIOCSTART
1494 if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
1495 #endif
1496
1497 #if defined (HAVE_TERMIOS) || defined (HPUX)
1498 #ifdef TCOON
1499 if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
1500 #endif
1501 #endif
1502
1503 #ifdef VMS
1504 /* Appears to do nothing when in PASTHRU mode.
1505 SYS$QIOW (0, fileno (tty_out->input), IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
1506 interrupt_signal, oob_chars, 0, 0, 0, 0);
1507 */
1508 queue_kbd_input (0);
1509 #endif /* VMS */
1510
1511 #ifdef F_SETFL
1512 #ifdef F_GETOWN /* F_SETFL does not imply existence of F_GETOWN */
1513 if (interrupt_input)
1514 {
1515 old_fcntl_owner[fileno (tty_out->input)] =
1516 fcntl (fileno (tty_out->input), F_GETOWN, 0);
1517 fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
1518 init_sigio (fileno (tty_out->input));
1519 #ifdef HAVE_GPM
1520 if (gpm_tty == tty_out)
1521 {
1522 /* Arrange for mouse events to give us SIGIO signals. */
1523 fcntl (gpm_fd, F_SETOWN, getpid ());
1524 fcntl (gpm_fd, F_SETFL, fcntl (gpm_fd, F_GETFL, 0) | O_NONBLOCK);
1525 init_sigio (gpm_fd);
1526 }
1527 #endif /* HAVE_GPM */
1528 }
1529 #endif /* F_GETOWN */
1530 #endif /* F_SETFL */
1531
1532 #ifdef VMS /* VMS sometimes has this symbol but lacks setvbuf. */
1533 #undef _IOFBF
1534 #endif
1535 #ifdef _IOFBF
1536 /* This symbol is defined on recent USG systems.
1537 Someone says without this call USG won't really buffer the file
1538 even with a call to setbuf. */
1539 setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1540 #else
1541 setbuf (tty_out->output, (char *) _sobuf);
1542 #endif
1543
1544 if (tty_out->terminal->set_terminal_modes_hook)
1545 tty_out->terminal->set_terminal_modes_hook (tty_out->terminal);
1546
1547 if (!tty_out->term_initted)
1548 {
1549 Lisp_Object tail, frame;
1550 FOR_EACH_FRAME (tail, frame)
1551 {
1552 /* XXX This needs to be revised. */
1553 if (FRAME_TERMCAP_P (XFRAME (frame))
1554 && FRAME_TTY (XFRAME (frame)) == tty_out)
1555 init_frame_faces (XFRAME (frame));
1556 }
1557 }
1558
1559 if (tty_out->term_initted && no_redraw_on_reenter)
1560 {
1561 /* XXX This seems wrong on multi-tty. */
1562 if (display_completed)
1563 direct_output_forward_char (0);
1564 }
1565 else
1566 {
1567 Lisp_Object tail, frame;
1568 frame_garbaged = 1;
1569 FOR_EACH_FRAME (tail, frame)
1570 {
1571 if (FRAME_TERMCAP_P (XFRAME (frame))
1572 && FRAME_TTY (XFRAME (frame)) == tty_out)
1573 FRAME_GARBAGED_P (XFRAME (frame)) = 1;
1574 }
1575 }
1576
1577 tty_out->term_initted = 1;
1578 }
1579
1580 /* Return nonzero if safe to use tabs in output.
1581 At the time this is called, init_sys_modes has not been done yet. */
1582
1583 int
1584 tabs_safe_p (int fd)
1585 {
1586 struct emacs_tty etty;
1587
1588 EMACS_GET_TTY (fd, &etty);
1589 return EMACS_TTY_TABS_OK (&etty);
1590 }
1591 \f
1592 /* Get terminal size from system.
1593 Store number of lines into *HEIGHTP and width into *WIDTHP.
1594 We store 0 if there's no valid information. */
1595
1596 void
1597 get_tty_size (int fd, int *widthp, int *heightp)
1598 {
1599
1600 #ifdef TIOCGWINSZ
1601
1602 /* BSD-style. */
1603 struct winsize size;
1604
1605 if (ioctl (fd, TIOCGWINSZ, &size) == -1)
1606 *widthp = *heightp = 0;
1607 else
1608 {
1609 *widthp = size.ws_col;
1610 *heightp = size.ws_row;
1611 }
1612
1613 #else
1614 #ifdef TIOCGSIZE
1615
1616 /* SunOS - style. */
1617 struct ttysize size;
1618
1619 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1620 *widthp = *heightp = 0;
1621 else
1622 {
1623 *widthp = size.ts_cols;
1624 *heightp = size.ts_lines;
1625 }
1626
1627 #else
1628 #ifdef VMS
1629
1630 /* Use a fresh channel since the current one may have stale info
1631 (for example, from prior to a suspend); and to avoid a dependency
1632 in the init sequence. */
1633 int chan;
1634 struct sensemode tty;
1635
1636 SYS$ASSIGN (&input_dsc, &chan, 0, 0);
1637 SYS$QIOW (0, chan, IO$_SENSEMODE, &tty, 0, 0,
1638 &tty.class, 12, 0, 0, 0, 0);
1639 SYS$DASSGN (chan);
1640 *widthp = tty.scr_wid;
1641 *heightp = tty.scr_len;
1642
1643 #else
1644 #ifdef MSDOS
1645 *widthp = ScreenCols ();
1646 *heightp = ScreenRows ();
1647 #else /* system doesn't know size */
1648 *widthp = 0;
1649 *heightp = 0;
1650 #endif
1651 #endif /* not VMS */
1652 #endif /* not SunOS-style */
1653 #endif /* not BSD-style */
1654 }
1655
1656 /* Set the logical window size associated with descriptor FD
1657 to HEIGHT and WIDTH. This is used mainly with ptys. */
1658
1659 int
1660 set_window_size (fd, height, width)
1661 int fd, height, width;
1662 {
1663 #ifdef TIOCSWINSZ
1664
1665 /* BSD-style. */
1666 struct winsize size;
1667 size.ws_row = height;
1668 size.ws_col = width;
1669
1670 if (ioctl (fd, TIOCSWINSZ, &size) == -1)
1671 return 0; /* error */
1672 else
1673 return 1;
1674
1675 #else
1676 #ifdef TIOCSSIZE
1677
1678 /* SunOS - style. */
1679 struct ttysize size;
1680 size.ts_lines = height;
1681 size.ts_cols = width;
1682
1683 if (ioctl (fd, TIOCGSIZE, &size) == -1)
1684 return 0;
1685 else
1686 return 1;
1687 #else
1688 return -1;
1689 #endif /* not SunOS-style */
1690 #endif /* not BSD-style */
1691 }
1692
1693 \f
1694
1695 /* Prepare all terminal devices for exiting Emacs. */
1696
1697 void
1698 reset_all_sys_modes (void)
1699 {
1700 struct tty_display_info *tty;
1701 for (tty = tty_list; tty; tty = tty->next)
1702 reset_sys_modes (tty);
1703 }
1704
1705 /* Prepare the terminal for closing it; move the cursor to the
1706 bottom of the frame, turn off interrupt-driven I/O, etc. */
1707
1708 void
1709 reset_sys_modes (tty_out)
1710 struct tty_display_info *tty_out;
1711 {
1712 if (noninteractive)
1713 {
1714 fflush (stdout);
1715 return;
1716 }
1717 if (!tty_out->term_initted)
1718 return;
1719
1720 if (!tty_out->output)
1721 return; /* The tty is suspended. */
1722
1723 /* Go to and clear the last line of the terminal. */
1724
1725 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
1726
1727 /* Code adapted from tty_clear_end_of_line. */
1728 if (tty_out->TS_clr_line)
1729 {
1730 emacs_tputs (tty_out, tty_out->TS_clr_line, 1, cmputc);
1731 }
1732 else
1733 { /* have to do it the hard way */
1734 int i;
1735 tty_turn_off_insert (tty_out);
1736
1737 for (i = curX (tty_out); i < FrameCols (tty_out) - 1; i++)
1738 {
1739 fputc (' ', tty_out->output);
1740 }
1741 }
1742
1743 cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
1744 fflush (tty_out->output);
1745
1746 if (tty_out->terminal->reset_terminal_modes_hook)
1747 tty_out->terminal->reset_terminal_modes_hook (tty_out->terminal);
1748
1749 #ifdef BSD_SYSTEM
1750 /* Avoid possible loss of output when changing terminal modes. */
1751 fsync (fileno (tty_out->output));
1752 #endif
1753
1754 #ifdef F_SETFL
1755 #ifdef F_SETOWN /* F_SETFL does not imply existence of F_SETOWN */
1756 if (interrupt_input)
1757 {
1758 reset_sigio (fileno (tty_out->input));
1759 fcntl (fileno (tty_out->input), F_SETOWN,
1760 old_fcntl_owner[fileno (tty_out->input)]);
1761 }
1762 #endif /* F_SETOWN */
1763 #ifdef O_NDELAY
1764 fcntl (fileno (tty_out->input), F_SETFL,
1765 fcntl (fileno (tty_out->input), F_GETFL, 0) & ~O_NDELAY);
1766 #endif
1767 #endif /* F_SETFL */
1768
1769 if (tty_out->old_tty)
1770 while (EMACS_SET_TTY (fileno (tty_out->input),
1771 tty_out->old_tty, 0) < 0 && errno == EINTR)
1772 ;
1773
1774 #ifdef MSDOS /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1775 dos_ttcooked ();
1776 #endif
1777
1778 #ifdef BSD_PGRPS
1779 widen_foreground_group (fileno (tty_out->input));
1780 #endif
1781 }
1782 \f
1783 #ifdef HAVE_PTYS
1784
1785 /* Set up the proper status flags for use of a pty. */
1786
1787 void
1788 setup_pty (fd)
1789 int fd;
1790 {
1791 /* I'm told that TOICREMOTE does not mean control chars
1792 "can't be sent" but rather that they don't have
1793 input-editing or signaling effects.
1794 That should be good, because we have other ways
1795 to do those things in Emacs.
1796 However, telnet mode seems not to work on 4.2.
1797 So TIOCREMOTE is turned off now. */
1798
1799 /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1800 will hang. In particular, the "timeout" feature (which
1801 causes a read to return if there is no data available)
1802 does this. Also it is known that telnet mode will hang
1803 in such a way that Emacs must be stopped (perhaps this
1804 is the same problem).
1805
1806 If TIOCREMOTE is turned off, then there is a bug in
1807 hp-ux which sometimes loses data. Apparently the
1808 code which blocks the master process when the internal
1809 buffer fills up does not work. Other than this,
1810 though, everything else seems to work fine.
1811
1812 Since the latter lossage is more benign, we may as well
1813 lose that way. -- cph */
1814 #ifdef FIONBIO
1815 #if defined(UNIX98_PTYS)
1816 {
1817 int on = 1;
1818 ioctl (fd, FIONBIO, &on);
1819 }
1820 #endif
1821 #endif
1822 }
1823 #endif /* HAVE_PTYS */
1824 \f
1825 #ifdef VMS
1826
1827 /* Assigning an input channel is done at the start of Emacs execution.
1828 This is called each time Emacs is resumed, also, but does nothing
1829 because input_chain is no longer zero. */
1830
1831 void
1832 init_vms_input ()
1833 {
1834 int status;
1835
1836 if (fileno (CURTTY ()->input)) == 0)
1837 {
1838 status = SYS$ASSIGN (&input_dsc, &fileno (CURTTY ()->input)), 0, 0);
1839 if (! (status & 1))
1840 LIB$STOP (status);
1841 }
1842 }
1843
1844 /* Deassigning the input channel is done before exiting. */
1845
1846 void
1847 stop_vms_input ()
1848 {
1849 return SYS$DASSGN (fileno (CURTTY ()->input)));
1850 }
1851
1852 short input_buffer;
1853
1854 /* Request reading one character into the keyboard buffer.
1855 This is done as soon as the buffer becomes empty. */
1856
1857 void
1858 queue_kbd_input ()
1859 {
1860 int status;
1861 extern kbd_input_ast ();
1862
1863 waiting_for_ast = 0;
1864 stop_input = 0;
1865 status = SYS$QIO (0, fileno (CURTTY()->input), IO$_READVBLK,
1866 &input_iosb, kbd_input_ast, 1,
1867 &input_buffer, 1, 0, terminator_mask, 0, 0);
1868 }
1869
1870 int input_count;
1871
1872 /* Ast routine that is called when keyboard input comes in
1873 in accord with the SYS$QIO above. */
1874
1875 void
1876 kbd_input_ast ()
1877 {
1878 register int c = -1;
1879 int old_errno = errno;
1880 extern EMACS_TIME *input_available_clear_time;
1881
1882 if (waiting_for_ast)
1883 SYS$SETEF (input_ef);
1884 waiting_for_ast = 0;
1885 input_count++;
1886 #ifdef ASTDEBUG
1887 if (input_count == 25)
1888 exit (1);
1889 printf ("Ast # %d,", input_count);
1890 printf (" iosb = %x, %x, %x, %x",
1891 input_iosb.offset, input_iosb.status, input_iosb.termlen,
1892 input_iosb.term);
1893 #endif
1894 if (input_iosb.offset)
1895 {
1896 c = input_buffer;
1897 #ifdef ASTDEBUG
1898 printf (", char = 0%o", c);
1899 #endif
1900 }
1901 #ifdef ASTDEBUG
1902 printf ("\n");
1903 fflush (stdout);
1904 sleep (1);
1905 #endif
1906 if (! stop_input)
1907 queue_kbd_input ();
1908 if (c >= 0)
1909 {
1910 struct input_event e;
1911 EVENT_INIT (e);
1912
1913 e.kind = ASCII_KEYSTROKE_EVENT;
1914 XSETINT (e.code, c);
1915 e.frame_or_window = selected_frame;
1916 kbd_buffer_store_event (&e);
1917 }
1918 if (input_available_clear_time)
1919 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
1920 errno = old_errno;
1921 }
1922
1923 /* Wait until there is something in kbd_buffer. */
1924
1925 void
1926 wait_for_kbd_input ()
1927 {
1928 extern int have_process_input, process_exited;
1929
1930 /* If already something, avoid doing system calls. */
1931 if (detect_input_pending ())
1932 {
1933 return;
1934 }
1935 /* Clear a flag, and tell ast routine above to set it. */
1936 SYS$CLREF (input_ef);
1937 waiting_for_ast = 1;
1938 /* Check for timing error: ast happened while we were doing that. */
1939 if (!detect_input_pending ())
1940 {
1941 /* No timing error: wait for flag to be set. */
1942 set_waiting_for_input (0);
1943 SYS$WFLOR (input_ef, input_eflist);
1944 clear_waiting_for_input ();
1945 if (!detect_input_pending ())
1946 /* Check for subprocess input availability */
1947 {
1948 int dsp = have_process_input || process_exited;
1949
1950 SYS$CLREF (process_ef);
1951 if (have_process_input)
1952 process_command_input ();
1953 if (process_exited)
1954 process_exit ();
1955 if (dsp)
1956 {
1957 update_mode_lines++;
1958 prepare_menu_bars ();
1959 redisplay_preserve_echo_area (18);
1960 }
1961 }
1962 }
1963 waiting_for_ast = 0;
1964 }
1965
1966 /* Get rid of any pending QIO, when we are about to suspend
1967 or when we want to throw away pending input.
1968 We wait for a positive sign that the AST routine has run
1969 and therefore there is no I/O request queued when we return.
1970 SYS$SETAST is used to avoid a timing error. */
1971
1972 void
1973 end_kbd_input ()
1974 {
1975 #ifdef ASTDEBUG
1976 printf ("At end_kbd_input.\n");
1977 fflush (stdout);
1978 sleep (1);
1979 #endif
1980 if (LIB$AST_IN_PROG ()) /* Don't wait if suspending from kbd_buffer_store_event! */
1981 {
1982 SYS$CANCEL (fileno (CURTTY()->input));
1983 return;
1984 }
1985
1986 SYS$SETAST (0);
1987 /* Clear a flag, and tell ast routine above to set it. */
1988 SYS$CLREF (input_ef);
1989 waiting_for_ast = 1;
1990 stop_input = 1;
1991 SYS$CANCEL (fileno (CURTTY()->input));
1992 SYS$SETAST (1);
1993 SYS$WAITFR (input_ef);
1994 waiting_for_ast = 0;
1995 }
1996
1997 /* Wait for either input available or time interval expiry. */
1998
1999 void
2000 input_wait_timeout (timeval)
2001 int timeval; /* Time to wait, in seconds */
2002 {
2003 int time [2];
2004 static int zero = 0;
2005 static int large = -10000000;
2006
2007 LIB$EMUL (&timeval, &large, &zero, time); /* Convert to VMS format */
2008
2009 /* If already something, avoid doing system calls. */
2010 if (detect_input_pending ())
2011 {
2012 return;
2013 }
2014 /* Clear a flag, and tell ast routine above to set it. */
2015 SYS$CLREF (input_ef);
2016 waiting_for_ast = 1;
2017 /* Check for timing error: ast happened while we were doing that. */
2018 if (!detect_input_pending ())
2019 {
2020 /* No timing error: wait for flag to be set. */
2021 SYS$CANTIM (1, 0);
2022 if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
2023 SYS$WFLOR (timer_ef, timer_eflist); /* Wait for timer expiry or input */
2024 }
2025 waiting_for_ast = 0;
2026 }
2027
2028 /* The standard `sleep' routine works some other way
2029 and it stops working if you have ever quit out of it.
2030 This one continues to work. */
2031
2032 sys_sleep (timeval)
2033 int timeval;
2034 {
2035 int time [2];
2036 static int zero = 0;
2037 static int large = -10000000;
2038
2039 LIB$EMUL (&timeval, &large, &zero, time); /* Convert to VMS format */
2040
2041 SYS$CANTIM (1, 0);
2042 if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
2043 SYS$WAITFR (timer_ef); /* Wait for timer expiry only */
2044 }
2045
2046 void
2047 init_sigio (fd)
2048 int fd;
2049 {
2050 request_sigio ();
2051 }
2052
2053 reset_sigio (fd)
2054 int fd;
2055 {
2056 unrequest_sigio ();
2057 }
2058
2059 void
2060 request_sigio ()
2061 {
2062 if (noninteractive)
2063 return;
2064 croak ("request sigio");
2065 }
2066
2067 void
2068 unrequest_sigio ()
2069 {
2070 if (noninteractive)
2071 return;
2072 croak ("unrequest sigio");
2073 }
2074
2075 #endif /* VMS */
2076 \f
2077 /* Note that VMS compiler won't accept defined (CANNOT_DUMP). */
2078 #ifndef CANNOT_DUMP
2079 #define NEED_STARTS
2080 #endif
2081
2082 #ifndef SYSTEM_MALLOC
2083 #ifndef NEED_STARTS
2084 #define NEED_STARTS
2085 #endif
2086 #endif
2087
2088 #ifdef NEED_STARTS
2089 /* Some systems that cannot dump also cannot implement these. */
2090
2091 /*
2092 * Return the address of the start of the text segment prior to
2093 * doing an unexec. After unexec the return value is undefined.
2094 * See crt0.c for further explanation and _start.
2095 *
2096 */
2097
2098 #if !(defined (__NetBSD__) && defined (__ELF__))
2099 #ifndef HAVE_TEXT_START
2100 char *
2101 start_of_text ()
2102 {
2103 #ifdef TEXT_START
2104 return ((char *) TEXT_START);
2105 #else
2106 extern int _start ();
2107 return ((char *) _start);
2108 #endif /* TEXT_START */
2109 }
2110 #endif /* not HAVE_TEXT_START */
2111 #endif
2112
2113 /*
2114 * Return the address of the start of the data segment prior to
2115 * doing an unexec. After unexec the return value is undefined.
2116 * See crt0.c for further information and definition of data_start.
2117 *
2118 * Apparently, on BSD systems this is etext at startup. On
2119 * USG systems (swapping) this is highly mmu dependent and
2120 * is also dependent on whether or not the program is running
2121 * with shared text. Generally there is a (possibly large)
2122 * gap between end of text and start of data with shared text.
2123 *
2124 * On Uniplus+ systems with shared text, data starts at a
2125 * fixed address. Each port (from a given oem) is generally
2126 * different, and the specific value of the start of data can
2127 * be obtained via the UniPlus+ specific "uvar" system call,
2128 * however the method outlined in crt0.c seems to be more portable.
2129 *
2130 * Probably what will have to happen when a USG unexec is available,
2131 * at least on UniPlus, is temacs will have to be made unshared so
2132 * that text and data are contiguous. Then once loadup is complete,
2133 * unexec will produce a shared executable where the data can be
2134 * at the normal shared text boundary and the startofdata variable
2135 * will be patched by unexec to the correct value.
2136 *
2137 */
2138
2139 #ifndef start_of_data
2140 char *
2141 start_of_data ()
2142 {
2143 #ifdef DATA_START
2144 return ((char *) DATA_START);
2145 #else
2146 #ifdef ORDINARY_LINK
2147 /*
2148 * This is a hack. Since we're not linking crt0.c or pre_crt0.c,
2149 * data_start isn't defined. We take the address of environ, which
2150 * is known to live at or near the start of the system crt0.c, and
2151 * we don't sweat the handful of bytes that might lose.
2152 */
2153 extern char **environ;
2154
2155 return ((char *) &environ);
2156 #else
2157 extern int data_start;
2158 return ((char *) &data_start);
2159 #endif /* ORDINARY_LINK */
2160 #endif /* DATA_START */
2161 }
2162 #endif /* start_of_data */
2163 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2164 \f
2165 /* init_system_name sets up the string for the Lisp function
2166 system-name to return. */
2167
2168 extern Lisp_Object Vsystem_name;
2169
2170 #ifndef VMS
2171 #ifdef HAVE_SOCKETS
2172 #include <sys/socket.h>
2173 #include <netdb.h>
2174 #endif /* HAVE_SOCKETS */
2175 #endif /* not VMS */
2176
2177 #ifdef TRY_AGAIN
2178 #ifndef HAVE_H_ERRNO
2179 extern int h_errno;
2180 #endif
2181 #endif /* TRY_AGAIN */
2182
2183 void
2184 init_system_name ()
2185 {
2186 #ifdef VMS
2187 char *sp, *end;
2188 if ((sp = egetenv ("SYS$NODE")) == 0)
2189 Vsystem_name = build_string ("vax-vms");
2190 else if ((end = index (sp, ':')) == 0)
2191 Vsystem_name = build_string (sp);
2192 else
2193 Vsystem_name = make_string (sp, end - sp);
2194 #else
2195 #ifndef HAVE_GETHOSTNAME
2196 struct utsname uts;
2197 uname (&uts);
2198 Vsystem_name = build_string (uts.nodename);
2199 #else /* HAVE_GETHOSTNAME */
2200 unsigned int hostname_size = 256;
2201 char *hostname = (char *) alloca (hostname_size);
2202
2203 /* Try to get the host name; if the buffer is too short, try
2204 again. Apparently, the only indication gethostname gives of
2205 whether the buffer was large enough is the presence or absence
2206 of a '\0' in the string. Eech. */
2207 for (;;)
2208 {
2209 gethostname (hostname, hostname_size - 1);
2210 hostname[hostname_size - 1] = '\0';
2211
2212 /* Was the buffer large enough for the '\0'? */
2213 if (strlen (hostname) < hostname_size - 1)
2214 break;
2215
2216 hostname_size <<= 1;
2217 hostname = (char *) alloca (hostname_size);
2218 }
2219 #ifdef HAVE_SOCKETS
2220 /* Turn the hostname into the official, fully-qualified hostname.
2221 Don't do this if we're going to dump; this can confuse system
2222 libraries on some machines and make the dumped emacs core dump. */
2223 #ifndef CANNOT_DUMP
2224 if (initialized)
2225 #endif /* not CANNOT_DUMP */
2226 if (! index (hostname, '.'))
2227 {
2228 int count;
2229 #ifdef HAVE_GETADDRINFO
2230 struct addrinfo *res;
2231 struct addrinfo hints;
2232 int ret;
2233
2234 memset (&hints, 0, sizeof(hints));
2235 hints.ai_socktype = SOCK_STREAM;
2236 hints.ai_flags = AI_CANONNAME;
2237
2238 for (count = 0;; count++)
2239 {
2240 if ((ret = getaddrinfo (hostname, NULL, &hints, &res)) == 0
2241 || ret != EAI_AGAIN)
2242 break;
2243
2244 if (count >= 5)
2245 break;
2246 Fsleep_for (make_number (1), Qnil);
2247 }
2248
2249 if (ret == 0)
2250 {
2251 struct addrinfo *it = res;
2252 while (it)
2253 {
2254 char *fqdn = it->ai_canonname;
2255 if (fqdn && index (fqdn, '.')
2256 && strcmp (fqdn, "localhost.localdomain") != 0)
2257 break;
2258 it = it->ai_next;
2259 }
2260 if (it)
2261 {
2262 hostname = alloca (strlen (it->ai_canonname) + 1);
2263 strcpy (hostname, it->ai_canonname);
2264 }
2265 freeaddrinfo (res);
2266 }
2267 #else /* !HAVE_GETADDRINFO */
2268 struct hostent *hp;
2269 for (count = 0;; count++)
2270 {
2271
2272 #ifdef TRY_AGAIN
2273 h_errno = 0;
2274 #endif
2275 hp = gethostbyname (hostname);
2276 #ifdef TRY_AGAIN
2277 if (! (hp == 0 && h_errno == TRY_AGAIN))
2278 #endif
2279
2280 break;
2281
2282 if (count >= 5)
2283 break;
2284 Fsleep_for (make_number (1), Qnil);
2285 }
2286
2287 if (hp)
2288 {
2289 char *fqdn = (char *) hp->h_name;
2290
2291 if (!index (fqdn, '.'))
2292 {
2293 /* We still don't have a fully qualified domain name.
2294 Try to find one in the list of alternate names */
2295 char **alias = hp->h_aliases;
2296 while (*alias
2297 && (!index (*alias, '.')
2298 || !strcmp (*alias, "localhost.localdomain")))
2299 alias++;
2300 if (*alias)
2301 fqdn = *alias;
2302 }
2303 hostname = fqdn;
2304 }
2305 #endif /* !HAVE_GETADDRINFO */
2306 }
2307 #endif /* HAVE_SOCKETS */
2308 Vsystem_name = build_string (hostname);
2309 #endif /* HAVE_GETHOSTNAME */
2310 #endif /* VMS */
2311 {
2312 unsigned char *p;
2313 for (p = SDATA (Vsystem_name); *p; p++)
2314 if (*p == ' ' || *p == '\t')
2315 *p = '-';
2316 }
2317 }
2318 \f
2319 #ifndef MSDOS
2320 #ifndef VMS
2321 #if !defined (HAVE_SELECT)
2322
2323 #include "sysselect.h"
2324 #undef select
2325
2326 #if defined (HAVE_X_WINDOWS) && !defined (HAVE_SELECT)
2327 /* Cause explanatory error message at compile time,
2328 since the select emulation is not good enough for X. */
2329 int *x = &x_windows_lose_if_no_select_system_call;
2330 #endif
2331
2332 /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs
2333 * Only checks read descriptors.
2334 */
2335 /* How long to wait between checking fds in select */
2336 #define SELECT_PAUSE 1
2337 int select_alarmed;
2338
2339 /* For longjmp'ing back to read_input_waiting. */
2340
2341 jmp_buf read_alarm_throw;
2342
2343 /* Nonzero if the alarm signal should throw back to read_input_waiting.
2344 The read_socket_hook function sets this to 1 while it is waiting. */
2345
2346 int read_alarm_should_throw;
2347
2348 SIGTYPE
2349 select_alarm ()
2350 {
2351 select_alarmed = 1;
2352 signal (SIGALRM, SIG_IGN);
2353 SIGNAL_THREAD_CHECK (SIGALRM);
2354 if (read_alarm_should_throw)
2355 longjmp (read_alarm_throw, 1);
2356 }
2357
2358 #ifndef WINDOWSNT
2359 /* Only rfds are checked. */
2360 int
2361 sys_select (nfds, rfds, wfds, efds, timeout)
2362 int nfds;
2363 SELECT_TYPE *rfds, *wfds, *efds;
2364 EMACS_TIME *timeout;
2365 {
2366 /* XXX This needs to be updated for multi-tty support. Is there
2367 anybody who needs to emulate select these days? */
2368 int ravail = 0;
2369 SELECT_TYPE orfds;
2370 int timeoutval;
2371 int *local_timeout;
2372 extern int proc_buffered_char[];
2373 #ifndef subprocesses
2374 int process_tick = 0, update_tick = 0;
2375 #else
2376 extern int process_tick, update_tick;
2377 #endif
2378 unsigned char buf;
2379
2380 #if defined (HAVE_SELECT) && defined (HAVE_X_WINDOWS)
2381 /* If we're using X, then the native select will work; we only need the
2382 emulation for non-X usage. */
2383 if (!NILP (Vinitial_window_system))
2384 return select (nfds, rfds, wfds, efds, timeout);
2385 #endif
2386 timeoutval = timeout ? EMACS_SECS (*timeout) : 100000;
2387 local_timeout = &timeoutval;
2388 FD_ZERO (&orfds);
2389 if (rfds)
2390 {
2391 orfds = *rfds;
2392 FD_ZERO (rfds);
2393 }
2394 if (wfds)
2395 FD_ZERO (wfds);
2396 if (efds)
2397 FD_ZERO (efds);
2398
2399 /* If we are looking only for the terminal, with no timeout,
2400 just read it and wait -- that's more efficient. */
2401 if (*local_timeout == 100000 && process_tick == update_tick
2402 && FD_ISSET (0, &orfds))
2403 {
2404 int fd;
2405 for (fd = 1; fd < nfds; ++fd)
2406 if (FD_ISSET (fd, &orfds))
2407 goto hardway;
2408 if (! detect_input_pending ())
2409 read_input_waiting ();
2410 FD_SET (0, rfds);
2411 return 1;
2412 }
2413
2414 hardway:
2415 /* Once a second, till the timer expires, check all the flagged read
2416 * descriptors to see if any input is available. If there is some then
2417 * set the corresponding bit in the return copy of rfds.
2418 */
2419 while (1)
2420 {
2421 register int to_check, fd;
2422
2423 if (rfds)
2424 {
2425 for (to_check = nfds, fd = 0; --to_check >= 0; fd++)
2426 {
2427 if (FD_ISSET (fd, &orfds))
2428 {
2429 int avail = 0, status = 0;
2430
2431 if (fd == 0)
2432 avail = detect_input_pending (); /* Special keyboard handler */
2433 else
2434 {
2435 #ifdef FIONREAD
2436 status = ioctl (fd, FIONREAD, &avail);
2437 #else /* no FIONREAD */
2438 /* Hoping it will return -1 if nothing available
2439 or 0 if all 0 chars requested are read. */
2440 if (proc_buffered_char[fd] >= 0)
2441 avail = 1;
2442 else
2443 {
2444 avail = read (fd, &buf, 1);
2445 if (avail > 0)
2446 proc_buffered_char[fd] = buf;
2447 }
2448 #endif /* no FIONREAD */
2449 }
2450 if (status >= 0 && avail > 0)
2451 {
2452 FD_SET (fd, rfds);
2453 ravail++;
2454 }
2455 }
2456 }
2457 }
2458 if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
2459 break;
2460
2461 turn_on_atimers (0);
2462 signal (SIGALRM, select_alarm);
2463 select_alarmed = 0;
2464 alarm (SELECT_PAUSE);
2465
2466 /* Wait for a SIGALRM (or maybe a SIGTINT) */
2467 while (select_alarmed == 0 && *local_timeout != 0
2468 && process_tick == update_tick)
2469 {
2470 /* If we are interested in terminal input,
2471 wait by reading the terminal.
2472 That makes instant wakeup for terminal input at least. */
2473 if (FD_ISSET (0, &orfds))
2474 {
2475 read_input_waiting ();
2476 if (detect_input_pending ())
2477 select_alarmed = 1;
2478 }
2479 else
2480 pause ();
2481 }
2482 (*local_timeout) -= SELECT_PAUSE;
2483
2484 /* Reset the old alarm if there was one. */
2485 turn_on_atimers (1);
2486
2487 if (*local_timeout == 0) /* Stop on timer being cleared */
2488 break;
2489 }
2490 return ravail;
2491 }
2492 #endif /* not WINDOWSNT */
2493
2494 /* Read keyboard input into the standard buffer,
2495 waiting for at least one character. */
2496
2497 void
2498 read_input_waiting ()
2499 {
2500 /* XXX This needs to be updated for multi-tty support. Is there
2501 anybody who needs to emulate select these days? */
2502 int nread, i;
2503 extern int quit_char;
2504
2505 if (read_socket_hook)
2506 {
2507 struct input_event hold_quit;
2508
2509 EVENT_INIT (hold_quit);
2510 hold_quit.kind = NO_EVENT;
2511
2512 read_alarm_should_throw = 0;
2513 if (! setjmp (read_alarm_throw))
2514 nread = (*read_socket_hook) (0, 1, &hold_quit);
2515 else
2516 nread = -1;
2517
2518 if (hold_quit.kind != NO_EVENT)
2519 kbd_buffer_store_event (&hold_quit);
2520 }
2521 else
2522 {
2523 struct input_event e;
2524 char buf[3];
2525 nread = read (fileno (stdin), buf, 1);
2526 EVENT_INIT (e);
2527
2528 /* Scan the chars for C-g and store them in kbd_buffer. */
2529 e.kind = ASCII_KEYSTROKE_EVENT;
2530 e.frame_or_window = selected_frame;
2531 e.modifiers = 0;
2532 for (i = 0; i < nread; i++)
2533 {
2534 /* Convert chars > 0177 to meta events if desired.
2535 We do this under the same conditions that read_avail_input does. */
2536 if (read_socket_hook == 0)
2537 {
2538 /* If the user says she has a meta key, then believe her. */
2539 if (meta_key == 1 && (buf[i] & 0x80))
2540 e.modifiers = meta_modifier;
2541 if (meta_key != 2)
2542 buf[i] &= ~0x80;
2543 }
2544
2545 XSETINT (e.code, buf[i]);
2546 kbd_buffer_store_event (&e);
2547 /* Don't look at input that follows a C-g too closely.
2548 This reduces lossage due to autorepeat on C-g. */
2549 if (buf[i] == quit_char)
2550 break;
2551 }
2552 }
2553 }
2554
2555 #if !defined (HAVE_SELECT)
2556 #define select sys_select
2557 #endif
2558
2559 #endif /* not HAVE_SELECT */
2560 #endif /* not VMS */
2561 #endif /* not MSDOS */
2562 \f
2563 /* POSIX signals support - DJB */
2564 /* Anyone with POSIX signals should have ANSI C declarations */
2565
2566 #ifdef POSIX_SIGNALS
2567
2568 sigset_t empty_mask, full_mask;
2569
2570 signal_handler_t
2571 sys_signal (int signal_number, signal_handler_t action)
2572 {
2573 struct sigaction new_action, old_action;
2574 sigemptyset (&new_action.sa_mask);
2575 new_action.sa_handler = action;
2576 #if defined (SA_RESTART) && ! defined (BROKEN_SA_RESTART) && !defined(SYNC_INPUT)
2577 /* Emacs mostly works better with restartable system services. If this
2578 flag exists, we probably want to turn it on here.
2579 However, on some systems this resets the timeout of `select'
2580 which means that `select' never finishes if it keeps getting signals.
2581 BROKEN_SA_RESTART is defined on those systems. */
2582 /* It's not clear why the comment above says "mostly works better". --Stef
2583 When SYNC_INPUT is set, we don't want SA_RESTART because we need to poll
2584 for pending input so we need long-running syscalls to be interrupted
2585 after a signal that sets the interrupt_input_pending flag. */
2586 new_action.sa_flags = SA_RESTART;
2587 #else
2588 new_action.sa_flags = 0;
2589 #endif
2590 sigaction (signal_number, &new_action, &old_action);
2591 return (old_action.sa_handler);
2592 }
2593
2594 #ifndef __GNUC__
2595 /* If we're compiling with GCC, we don't need this function, since it
2596 can be written as a macro. */
2597 sigset_t
2598 sys_sigmask (int sig)
2599 {
2600 sigset_t mask;
2601 sigemptyset (&mask);
2602 sigaddset (&mask, sig);
2603 return mask;
2604 }
2605 #endif
2606
2607 /* I'd like to have these guys return pointers to the mask storage in here,
2608 but there'd be trouble if the code was saving multiple masks. I'll be
2609 safe and pass the structure. It normally won't be more than 2 bytes
2610 anyhow. - DJB */
2611
2612 sigset_t
2613 sys_sigblock (sigset_t new_mask)
2614 {
2615 sigset_t old_mask;
2616 sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2617 return (old_mask);
2618 }
2619
2620 sigset_t
2621 sys_sigunblock (sigset_t new_mask)
2622 {
2623 sigset_t old_mask;
2624 sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2625 return (old_mask);
2626 }
2627
2628 sigset_t
2629 sys_sigsetmask (sigset_t new_mask)
2630 {
2631 sigset_t old_mask;
2632 sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2633 return (old_mask);
2634 }
2635
2636 #endif /* POSIX_SIGNALS */
2637 \f
2638 #if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
2639 static char *my_sys_siglist[NSIG];
2640 # ifdef sys_siglist
2641 # undef sys_siglist
2642 # endif
2643 # define sys_siglist my_sys_siglist
2644 #endif
2645
2646 void
2647 init_signals ()
2648 {
2649 #ifdef POSIX_SIGNALS
2650 sigemptyset (&empty_mask);
2651 sigfillset (&full_mask);
2652 #endif
2653
2654 #if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
2655 if (! initialized)
2656 {
2657 # ifdef SIGABRT
2658 sys_siglist[SIGABRT] = "Aborted";
2659 # endif
2660 # ifdef SIGAIO
2661 sys_siglist[SIGAIO] = "LAN I/O interrupt";
2662 # endif
2663 # ifdef SIGALRM
2664 sys_siglist[SIGALRM] = "Alarm clock";
2665 # endif
2666 # ifdef SIGBUS
2667 sys_siglist[SIGBUS] = "Bus error";
2668 # endif
2669 # ifdef SIGCLD
2670 sys_siglist[SIGCLD] = "Child status changed";
2671 # endif
2672 # ifdef SIGCHLD
2673 sys_siglist[SIGCHLD] = "Child status changed";
2674 # endif
2675 # ifdef SIGCONT
2676 sys_siglist[SIGCONT] = "Continued";
2677 # endif
2678 # ifdef SIGDANGER
2679 sys_siglist[SIGDANGER] = "Swap space dangerously low";
2680 # endif
2681 # ifdef SIGDGNOTIFY
2682 sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
2683 # endif
2684 # ifdef SIGEMT
2685 sys_siglist[SIGEMT] = "Emulation trap";
2686 # endif
2687 # ifdef SIGFPE
2688 sys_siglist[SIGFPE] = "Arithmetic exception";
2689 # endif
2690 # ifdef SIGFREEZE
2691 sys_siglist[SIGFREEZE] = "SIGFREEZE";
2692 # endif
2693 # ifdef SIGGRANT
2694 sys_siglist[SIGGRANT] = "Monitor mode granted";
2695 # endif
2696 # ifdef SIGHUP
2697 sys_siglist[SIGHUP] = "Hangup";
2698 # endif
2699 # ifdef SIGILL
2700 sys_siglist[SIGILL] = "Illegal instruction";
2701 # endif
2702 # ifdef SIGINT
2703 sys_siglist[SIGINT] = "Interrupt";
2704 # endif
2705 # ifdef SIGIO
2706 sys_siglist[SIGIO] = "I/O possible";
2707 # endif
2708 # ifdef SIGIOINT
2709 sys_siglist[SIGIOINT] = "I/O intervention required";
2710 # endif
2711 # ifdef SIGIOT
2712 sys_siglist[SIGIOT] = "IOT trap";
2713 # endif
2714 # ifdef SIGKILL
2715 sys_siglist[SIGKILL] = "Killed";
2716 # endif
2717 # ifdef SIGLOST
2718 sys_siglist[SIGLOST] = "Resource lost";
2719 # endif
2720 # ifdef SIGLWP
2721 sys_siglist[SIGLWP] = "SIGLWP";
2722 # endif
2723 # ifdef SIGMSG
2724 sys_siglist[SIGMSG] = "Monitor mode data available";
2725 # endif
2726 # ifdef SIGPHONE
2727 sys_siglist[SIGWIND] = "SIGPHONE";
2728 # endif
2729 # ifdef SIGPIPE
2730 sys_siglist[SIGPIPE] = "Broken pipe";
2731 # endif
2732 # ifdef SIGPOLL
2733 sys_siglist[SIGPOLL] = "Pollable event occurred";
2734 # endif
2735 # ifdef SIGPROF
2736 sys_siglist[SIGPROF] = "Profiling timer expired";
2737 # endif
2738 # ifdef SIGPTY
2739 sys_siglist[SIGPTY] = "PTY I/O interrupt";
2740 # endif
2741 # ifdef SIGPWR
2742 sys_siglist[SIGPWR] = "Power-fail restart";
2743 # endif
2744 # ifdef SIGQUIT
2745 sys_siglist[SIGQUIT] = "Quit";
2746 # endif
2747 # ifdef SIGRETRACT
2748 sys_siglist[SIGRETRACT] = "Need to relinguish monitor mode";
2749 # endif
2750 # ifdef SIGSAK
2751 sys_siglist[SIGSAK] = "Secure attention";
2752 # endif
2753 # ifdef SIGSEGV
2754 sys_siglist[SIGSEGV] = "Segmentation violation";
2755 # endif
2756 # ifdef SIGSOUND
2757 sys_siglist[SIGSOUND] = "Sound completed";
2758 # endif
2759 # ifdef SIGSTOP
2760 sys_siglist[SIGSTOP] = "Stopped (signal)";
2761 # endif
2762 # ifdef SIGSTP
2763 sys_siglist[SIGSTP] = "Stopped (user)";
2764 # endif
2765 # ifdef SIGSYS
2766 sys_siglist[SIGSYS] = "Bad argument to system call";
2767 # endif
2768 # ifdef SIGTERM
2769 sys_siglist[SIGTERM] = "Terminated";
2770 # endif
2771 # ifdef SIGTHAW
2772 sys_siglist[SIGTHAW] = "SIGTHAW";
2773 # endif
2774 # ifdef SIGTRAP
2775 sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
2776 # endif
2777 # ifdef SIGTSTP
2778 sys_siglist[SIGTSTP] = "Stopped (user)";
2779 # endif
2780 # ifdef SIGTTIN
2781 sys_siglist[SIGTTIN] = "Stopped (tty input)";
2782 # endif
2783 # ifdef SIGTTOU
2784 sys_siglist[SIGTTOU] = "Stopped (tty output)";
2785 # endif
2786 # ifdef SIGURG
2787 sys_siglist[SIGURG] = "Urgent I/O condition";
2788 # endif
2789 # ifdef SIGUSR1
2790 sys_siglist[SIGUSR1] = "User defined signal 1";
2791 # endif
2792 # ifdef SIGUSR2
2793 sys_siglist[SIGUSR2] = "User defined signal 2";
2794 # endif
2795 # ifdef SIGVTALRM
2796 sys_siglist[SIGVTALRM] = "Virtual timer expired";
2797 # endif
2798 # ifdef SIGWAITING
2799 sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
2800 # endif
2801 # ifdef SIGWINCH
2802 sys_siglist[SIGWINCH] = "Window size changed";
2803 # endif
2804 # ifdef SIGWIND
2805 sys_siglist[SIGWIND] = "SIGWIND";
2806 # endif
2807 # ifdef SIGXCPU
2808 sys_siglist[SIGXCPU] = "CPU time limit exceeded";
2809 # endif
2810 # ifdef SIGXFSZ
2811 sys_siglist[SIGXFSZ] = "File size limit exceeded";
2812 # endif
2813 }
2814 #endif /* !defined HAVE_STRSIGNAL && !defined HAVE_DECL_SYS_SIGLIST */
2815 }
2816 \f
2817 #ifndef HAVE_RANDOM
2818 #ifdef random
2819 #define HAVE_RANDOM
2820 #endif
2821 #endif
2822
2823 /* Figure out how many bits the system's random number generator uses.
2824 `random' and `lrand48' are assumed to return 31 usable bits.
2825 BSD `rand' returns a 31 bit value but the low order bits are unusable;
2826 so we'll shift it and treat it like the 15-bit USG `rand'. */
2827
2828 #ifndef RAND_BITS
2829 # ifdef HAVE_RANDOM
2830 # define RAND_BITS 31
2831 # else /* !HAVE_RANDOM */
2832 # ifdef HAVE_LRAND48
2833 # define RAND_BITS 31
2834 # define random lrand48
2835 # else /* !HAVE_LRAND48 */
2836 # define RAND_BITS 15
2837 # if RAND_MAX == 32767
2838 # define random rand
2839 # else /* RAND_MAX != 32767 */
2840 # if RAND_MAX == 2147483647
2841 # define random() (rand () >> 16)
2842 # else /* RAND_MAX != 2147483647 */
2843 # ifdef USG
2844 # define random rand
2845 # else
2846 # define random() (rand () >> 16)
2847 # endif /* !USG */
2848 # endif /* RAND_MAX != 2147483647 */
2849 # endif /* RAND_MAX != 32767 */
2850 # endif /* !HAVE_LRAND48 */
2851 # endif /* !HAVE_RANDOM */
2852 #endif /* !RAND_BITS */
2853
2854 void
2855 seed_random (arg)
2856 long arg;
2857 {
2858 #ifdef HAVE_RANDOM
2859 srandom ((unsigned int)arg);
2860 #else
2861 # ifdef HAVE_LRAND48
2862 srand48 (arg);
2863 # else
2864 srand ((unsigned int)arg);
2865 # endif
2866 #endif
2867 }
2868
2869 /*
2870 * Build a full Emacs-sized word out of whatever we've got.
2871 * This suffices even for a 64-bit architecture with a 15-bit rand.
2872 */
2873 long
2874 get_random ()
2875 {
2876 long val = random ();
2877 #if VALBITS > RAND_BITS
2878 val = (val << RAND_BITS) ^ random ();
2879 #if VALBITS > 2*RAND_BITS
2880 val = (val << RAND_BITS) ^ random ();
2881 #if VALBITS > 3*RAND_BITS
2882 val = (val << RAND_BITS) ^ random ();
2883 #if VALBITS > 4*RAND_BITS
2884 val = (val << RAND_BITS) ^ random ();
2885 #endif /* need at least 5 */
2886 #endif /* need at least 4 */
2887 #endif /* need at least 3 */
2888 #endif /* need at least 2 */
2889 return val & ((1L << VALBITS) - 1);
2890 }
2891 \f
2892 #ifdef VMS
2893
2894 #ifdef getenv
2895 /* If any place else asks for the TERM variable,
2896 allow it to be overridden with the EMACS_TERM variable
2897 before attempting to translate the logical name TERM. As a last
2898 resort, ask for VAX C's special idea of the TERM variable. */
2899 #undef getenv
2900 char *
2901 sys_getenv (name)
2902 char *name;
2903 {
2904 register char *val;
2905 static char buf[256];
2906 static struct dsc$descriptor_s equiv
2907 = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
2908 static struct dsc$descriptor_s d_name
2909 = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
2910 short eqlen;
2911
2912 if (!strcmp (name, "TERM"))
2913 {
2914 val = (char *) getenv ("EMACS_TERM");
2915 if (val)
2916 return val;
2917 }
2918
2919 d_name.dsc$w_length = strlen (name);
2920 d_name.dsc$a_pointer = name;
2921 if (LIB$SYS_TRNLOG (&d_name, &eqlen, &equiv) == 1)
2922 {
2923 char *str = (char *) xmalloc (eqlen + 1);
2924 bcopy (buf, str, eqlen);
2925 str[eqlen] = '\0';
2926 /* This is a storage leak, but a pain to fix. With luck,
2927 no one will ever notice. */
2928 return str;
2929 }
2930 return (char *) getenv (name);
2931 }
2932 #endif /* getenv */
2933
2934 #ifdef abort
2935 /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
2936 to force a call on the debugger from within the image. */
2937 #undef abort
2938 sys_abort ()
2939 {
2940 reset_all_sys_modes ();
2941 LIB$SIGNAL (SS$_DEBUG);
2942 }
2943 #endif /* abort */
2944 #endif /* VMS */
2945 \f
2946 #ifdef VMS
2947 #ifdef LINK_CRTL_SHARE
2948 #ifdef SHARABLE_LIB_BUG
2949 /* Variables declared noshare and initialized in sharable libraries
2950 cannot be shared. The VMS linker incorrectly forces you to use a private
2951 version which is uninitialized... If not for this "feature", we
2952 could use the C library definition of sys_nerr and sys_errlist. */
2953 int sys_nerr = 35;
2954 char *sys_errlist[] =
2955 {
2956 "error 0",
2957 "not owner",
2958 "no such file or directory",
2959 "no such process",
2960 "interrupted system call",
2961 "i/o error",
2962 "no such device or address",
2963 "argument list too long",
2964 "exec format error",
2965 "bad file number",
2966 "no child process",
2967 "no more processes",
2968 "not enough memory",
2969 "permission denied",
2970 "bad address",
2971 "block device required",
2972 "mount devices busy",
2973 "file exists",
2974 "cross-device link",
2975 "no such device",
2976 "not a directory",
2977 "is a directory",
2978 "invalid argument",
2979 "file table overflow",
2980 "too many open files",
2981 "not a typewriter",
2982 "text file busy",
2983 "file too big",
2984 "no space left on device",
2985 "illegal seek",
2986 "read-only file system",
2987 "too many links",
2988 "broken pipe",
2989 "math argument",
2990 "result too large",
2991 "I/O stream empty",
2992 "vax/vms specific error code nontranslatable error"
2993 };
2994 #endif /* SHARABLE_LIB_BUG */
2995 #endif /* LINK_CRTL_SHARE */
2996 #endif /* VMS */
2997
2998 #ifndef HAVE_STRERROR
2999 #ifndef WINDOWSNT
3000 char *
3001 strerror (errnum)
3002 int errnum;
3003 {
3004 extern char *sys_errlist[];
3005 extern int sys_nerr;
3006
3007 if (errnum >= 0 && errnum < sys_nerr)
3008 return sys_errlist[errnum];
3009 return (char *) "Unknown error";
3010 }
3011 #endif /* not WINDOWSNT */
3012 #endif /* ! HAVE_STRERROR */
3013 \f
3014 int
3015 emacs_open (path, oflag, mode)
3016 const char *path;
3017 int oflag, mode;
3018 {
3019 register int rtnval;
3020
3021 while ((rtnval = open (path, oflag, mode)) == -1
3022 && (errno == EINTR))
3023 QUIT;
3024 return (rtnval);
3025 }
3026
3027 int
3028 emacs_close (fd)
3029 int fd;
3030 {
3031 int did_retry = 0;
3032 register int rtnval;
3033
3034 while ((rtnval = close (fd)) == -1
3035 && (errno == EINTR))
3036 did_retry = 1;
3037
3038 /* If close is interrupted SunOS 4.1 may or may not have closed the
3039 file descriptor. If it did the second close will fail with
3040 errno = EBADF. That means we have succeeded. */
3041 if (rtnval == -1 && did_retry && errno == EBADF)
3042 return 0;
3043
3044 return rtnval;
3045 }
3046
3047 int
3048 emacs_read (fildes, buf, nbyte)
3049 int fildes;
3050 char *buf;
3051 unsigned int nbyte;
3052 {
3053 register int rtnval;
3054
3055 while ((rtnval = read (fildes, buf, nbyte)) == -1
3056 && (errno == EINTR))
3057 QUIT;
3058 return (rtnval);
3059 }
3060
3061 int
3062 emacs_write (fildes, buf, nbyte)
3063 int fildes;
3064 const char *buf;
3065 unsigned int nbyte;
3066 {
3067 register int rtnval, bytes_written;
3068
3069 bytes_written = 0;
3070
3071 while (nbyte > 0)
3072 {
3073 rtnval = write (fildes, buf, nbyte);
3074
3075 if (rtnval == -1)
3076 {
3077 if (errno == EINTR)
3078 {
3079 #ifdef SYNC_INPUT
3080 /* I originally used `QUIT' but that might causes files to
3081 be truncated if you hit C-g in the middle of it. --Stef */
3082 if (interrupt_input_pending)
3083 handle_async_input ();
3084 if (pending_atimers)
3085 do_pending_atimers ();
3086 #endif
3087 continue;
3088 }
3089 else
3090 return (bytes_written ? bytes_written : -1);
3091 }
3092
3093 buf += rtnval;
3094 nbyte -= rtnval;
3095 bytes_written += rtnval;
3096 }
3097 return (bytes_written);
3098 }
3099 \f
3100 #ifdef USG
3101 /*
3102 * All of the following are for USG.
3103 *
3104 * On USG systems the system calls are INTERRUPTIBLE by signals
3105 * that the user program has elected to catch. Thus the system call
3106 * must be retried in these cases. To handle this without massive
3107 * changes in the source code, we remap the standard system call names
3108 * to names for our own functions in sysdep.c that do the system call
3109 * with retries. Actually, for portability reasons, it is good
3110 * programming practice, as this example shows, to limit all actual
3111 * system calls to a single occurrence in the source. Sure, this
3112 * adds an extra level of function call overhead but it is almost
3113 * always negligible. Fred Fish, Unisoft Systems Inc.
3114 */
3115
3116 /*
3117 * Warning, this function may not duplicate 4.2 action properly
3118 * under error conditions.
3119 */
3120
3121 #ifndef MAXPATHLEN
3122 /* In 4.1, param.h fails to define this. */
3123 #define MAXPATHLEN 1024
3124 #endif
3125
3126 #ifndef HAVE_GETWD
3127
3128 char *
3129 getwd (pathname)
3130 char *pathname;
3131 {
3132 char *npath, *spath;
3133 extern char *getcwd ();
3134
3135 BLOCK_INPUT; /* getcwd uses malloc */
3136 spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3137 if (spath == 0)
3138 {
3139 UNBLOCK_INPUT;
3140 return spath;
3141 }
3142 /* On Altos 3068, getcwd can return @hostname/dir, so discard
3143 up to first slash. Should be harmless on other systems. */
3144 while (*npath && *npath != '/')
3145 npath++;
3146 strcpy (pathname, npath);
3147 free (spath); /* getcwd uses malloc */
3148 UNBLOCK_INPUT;
3149 return pathname;
3150 }
3151
3152 #endif /* HAVE_GETWD */
3153
3154 /*
3155 * Emulate rename using unlink/link. Note that this is
3156 * only partially correct. Also, doesn't enforce restriction
3157 * that files be of same type (regular->regular, dir->dir, etc).
3158 */
3159
3160 #ifndef HAVE_RENAME
3161
3162 rename (from, to)
3163 const char *from;
3164 const char *to;
3165 {
3166 if (access (from, 0) == 0)
3167 {
3168 unlink (to);
3169 if (link (from, to) == 0)
3170 if (unlink (from) == 0)
3171 return (0);
3172 }
3173 return (-1);
3174 }
3175
3176 #endif
3177
3178
3179 #ifdef HPUX
3180 #ifndef HAVE_PERROR
3181
3182 /* HPUX curses library references perror, but as far as we know
3183 it won't be called. Anyway this definition will do for now. */
3184
3185 perror ()
3186 {
3187 }
3188
3189 #endif /* not HAVE_PERROR */
3190 #endif /* HPUX */
3191
3192 #ifndef HAVE_DUP2
3193
3194 /*
3195 * Emulate BSD dup2. First close newd if it already exists.
3196 * Then, attempt to dup oldd. If not successful, call dup2 recursively
3197 * until we are, then close the unsuccessful ones.
3198 */
3199
3200 dup2 (oldd, newd)
3201 int oldd;
3202 int newd;
3203 {
3204 register int fd, ret;
3205
3206 emacs_close (newd);
3207
3208 #ifdef F_DUPFD
3209 return fcntl (oldd, F_DUPFD, newd);
3210 #else
3211 fd = dup (old);
3212 if (fd == -1)
3213 return -1;
3214 if (fd == new)
3215 return new;
3216 ret = dup2 (old,new);
3217 emacs_close (fd);
3218 return ret;
3219 #endif
3220 }
3221
3222 #endif /* not HAVE_DUP2 */
3223
3224 /*
3225 * Gettimeofday. Simulate as much as possible. Only accurate
3226 * to nearest second. Emacs doesn't use tzp so ignore it for now.
3227 * Only needed when subprocesses are defined.
3228 */
3229
3230 #ifdef subprocesses
3231 #ifndef VMS
3232 #ifndef HAVE_GETTIMEOFDAY
3233 #ifdef HAVE_TIMEVAL
3234
3235 /* ARGSUSED */
3236 int
3237 gettimeofday (tp, tzp)
3238 struct timeval *tp;
3239 struct timezone *tzp;
3240 {
3241 extern long time ();
3242
3243 tp->tv_sec = time ((long *)0);
3244 tp->tv_usec = 0;
3245 if (tzp != 0)
3246 tzp->tz_minuteswest = -1;
3247 return 0;
3248 }
3249
3250 #endif
3251 #endif
3252 #endif
3253 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3254
3255 /*
3256 * This function will go away as soon as all the stubs fixed. (fnf)
3257 */
3258
3259 void
3260 croak (badfunc)
3261 char *badfunc;
3262 {
3263 printf ("%s not yet implemented\r\n", badfunc);
3264 reset_all_sys_modes ();
3265 exit (1);
3266 }
3267
3268 #endif /* USG */
3269 \f
3270 /* Directory routines for systems that don't have them. */
3271
3272 #ifdef SYSV_SYSTEM_DIR
3273
3274 #include <dirent.h>
3275
3276 #if defined (BROKEN_CLOSEDIR) || !defined (HAVE_CLOSEDIR)
3277
3278 int
3279 closedir (dirp)
3280 register DIR *dirp; /* stream from opendir */
3281 {
3282 int rtnval;
3283
3284 rtnval = emacs_close (dirp->dd_fd);
3285
3286 /* Some systems (like Solaris) allocate the buffer and the DIR all
3287 in one block. Why in the world are we freeing this ourselves
3288 anyway? */
3289 #if ! defined (SOLARIS2)
3290 xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3291 #endif
3292 xfree ((char *) dirp);
3293
3294 return rtnval;
3295 }
3296 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3297 #endif /* SYSV_SYSTEM_DIR */
3298
3299 #ifdef NONSYSTEM_DIR_LIBRARY
3300
3301 DIR *
3302 opendir (filename)
3303 char *filename; /* name of directory */
3304 {
3305 register DIR *dirp; /* -> malloc'ed storage */
3306 register int fd; /* file descriptor for read */
3307 struct stat sbuf; /* result of fstat */
3308
3309 fd = emacs_open (filename, O_RDONLY, 0);
3310 if (fd < 0)
3311 return 0;
3312
3313 BLOCK_INPUT;
3314 if (fstat (fd, &sbuf) < 0
3315 || (sbuf.st_mode & S_IFMT) != S_IFDIR
3316 || (dirp = (DIR *) xmalloc (sizeof (DIR))) == 0)
3317 {
3318 emacs_close (fd);
3319 UNBLOCK_INPUT;
3320 return 0; /* bad luck today */
3321 }
3322 UNBLOCK_INPUT;
3323
3324 dirp->dd_fd = fd;
3325 dirp->dd_loc = dirp->dd_size = 0; /* refill needed */
3326
3327 return dirp;
3328 }
3329
3330 void
3331 closedir (dirp)
3332 register DIR *dirp; /* stream from opendir */
3333 {
3334 emacs_close (dirp->dd_fd);
3335 xfree ((char *) dirp);
3336 }
3337
3338
3339 #ifndef VMS
3340 #define DIRSIZ 14
3341 struct olddir
3342 {
3343 ino_t od_ino; /* inode */
3344 char od_name[DIRSIZ]; /* filename */
3345 };
3346 #endif /* not VMS */
3347
3348 struct direct dir_static; /* simulated directory contents */
3349
3350 /* ARGUSED */
3351 struct direct *
3352 readdir (dirp)
3353 register DIR *dirp; /* stream from opendir */
3354 {
3355 #ifndef VMS
3356 register struct olddir *dp; /* -> directory data */
3357 #else /* VMS */
3358 register struct dir$_name *dp; /* -> directory data */
3359 register struct dir$_version *dv; /* -> version data */
3360 #endif /* VMS */
3361
3362 for (; ;)
3363 {
3364 if (dirp->dd_loc >= dirp->dd_size)
3365 dirp->dd_loc = dirp->dd_size = 0;
3366
3367 if (dirp->dd_size == 0 /* refill buffer */
3368 && (dirp->dd_size = emacs_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3369 return 0;
3370
3371 #ifndef VMS
3372 dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3373 dirp->dd_loc += sizeof (struct olddir);
3374
3375 if (dp->od_ino != 0) /* not deleted entry */
3376 {
3377 dir_static.d_ino = dp->od_ino;
3378 strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3379 dir_static.d_name[DIRSIZ] = '\0';
3380 dir_static.d_namlen = strlen (dir_static.d_name);
3381 dir_static.d_reclen = sizeof (struct direct)
3382 - MAXNAMLEN + 3
3383 + dir_static.d_namlen - dir_static.d_namlen % 4;
3384 return &dir_static; /* -> simulated structure */
3385 }
3386 #else /* VMS */
3387 dp = (struct dir$_name *) dirp->dd_buf;
3388 if (dirp->dd_loc == 0)
3389 dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3390 : dp->dir$b_namecount;
3391 dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3392 dir_static.d_ino = dv->dir$w_fid_num;
3393 dir_static.d_namlen = dp->dir$b_namecount;
3394 dir_static.d_reclen = sizeof (struct direct)
3395 - MAXNAMLEN + 3
3396 + dir_static.d_namlen - dir_static.d_namlen % 4;
3397 strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3398 dir_static.d_name[dir_static.d_namlen] = '\0';
3399 dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3400 return &dir_static;
3401 #endif /* VMS */
3402 }
3403 }
3404
3405 #ifdef VMS
3406 /* readdirver is just like readdir except it returns all versions of a file
3407 as separate entries. */
3408
3409 /* ARGUSED */
3410 struct direct *
3411 readdirver (dirp)
3412 register DIR *dirp; /* stream from opendir */
3413 {
3414 register struct dir$_name *dp; /* -> directory data */
3415 register struct dir$_version *dv; /* -> version data */
3416
3417 if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3418 dirp->dd_loc = dirp->dd_size = 0;
3419
3420 if (dirp->dd_size == 0 /* refill buffer */
3421 && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3422 return 0;
3423
3424 dp = (struct dir$_name *) dirp->dd_buf;
3425 if (dirp->dd_loc == 0)
3426 dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
3427 : dp->dir$b_namecount;
3428 dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
3429 strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3430 sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3431 dir_static.d_namlen = strlen (dir_static.d_name);
3432 dir_static.d_ino = dv->dir$w_fid_num;
3433 dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3434 + dir_static.d_namlen - dir_static.d_namlen % 4;
3435 dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3436 return &dir_static;
3437 }
3438
3439 #endif /* VMS */
3440
3441 #endif /* NONSYSTEM_DIR_LIBRARY */
3442
3443 \f
3444 int
3445 set_file_times (filename, atime, mtime)
3446 const char *filename;
3447 EMACS_TIME atime, mtime;
3448 {
3449 #ifdef HAVE_UTIMES
3450 struct timeval tv[2];
3451 tv[0] = atime;
3452 tv[1] = mtime;
3453 return utimes (filename, tv);
3454 #else /* not HAVE_UTIMES */
3455 struct utimbuf utb;
3456 utb.actime = EMACS_SECS (atime);
3457 utb.modtime = EMACS_SECS (mtime);
3458 return utime (filename, &utb);
3459 #endif /* not HAVE_UTIMES */
3460 }
3461 \f
3462 /* mkdir and rmdir functions, for systems which don't have them. */
3463
3464 #ifndef HAVE_MKDIR
3465 /*
3466 * Written by Robert Rother, Mariah Corporation, August 1985.
3467 *
3468 * If you want it, it's yours. All I ask in return is that if you
3469 * figure out how to do this in a Bourne Shell script you send me
3470 * a copy.
3471 * sdcsvax!rmr or rmr@uscd
3472 *
3473 * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3474 * subroutine. 11Mar86; hoptoad!gnu
3475 *
3476 * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3477 * subroutine didn't return EEXIST. It does now.
3478 */
3479
3480 /*
3481 * Make a directory.
3482 */
3483 #ifdef MKDIR_PROTOTYPE
3484 MKDIR_PROTOTYPE
3485 #else
3486 int
3487 mkdir (dpath, dmode)
3488 char *dpath;
3489 int dmode;
3490 #endif
3491 {
3492 int cpid, status, fd;
3493 struct stat statbuf;
3494
3495 if (stat (dpath, &statbuf) == 0)
3496 {
3497 errno = EEXIST; /* Stat worked, so it already exists */
3498 return -1;
3499 }
3500
3501 /* If stat fails for a reason other than non-existence, return error */
3502 if (errno != ENOENT)
3503 return -1;
3504
3505 synch_process_alive = 1;
3506 switch (cpid = fork ())
3507 {
3508
3509 case -1: /* Error in fork */
3510 return (-1); /* Errno is set already */
3511
3512 case 0: /* Child process */
3513 /*
3514 * Cheap hack to set mode of new directory. Since this
3515 * child process is going away anyway, we zap its umask.
3516 * FIXME, this won't suffice to set SUID, SGID, etc. on this
3517 * directory. Does anybody care?
3518 */
3519 status = umask (0); /* Get current umask */
3520 status = umask (status | (0777 & ~dmode)); /* Set for mkdir */
3521 fd = emacs_open ("/dev/null", O_RDWR, 0);
3522 if (fd >= 0)
3523 {
3524 dup2 (fd, 0);
3525 dup2 (fd, 1);
3526 dup2 (fd, 2);
3527 }
3528 execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3529 _exit (-1); /* Can't exec /bin/mkdir */
3530
3531 default: /* Parent process */
3532 wait_for_termination (cpid);
3533 }
3534
3535 if (synch_process_death != 0 || synch_process_retcode != 0
3536 || synch_process_termsig != 0)
3537 {
3538 errno = EIO; /* We don't know why, but */
3539 return -1; /* /bin/mkdir failed */
3540 }
3541
3542 return 0;
3543 }
3544 #endif /* not HAVE_MKDIR */
3545
3546 #ifndef HAVE_RMDIR
3547 int
3548 rmdir (dpath)
3549 char *dpath;
3550 {
3551 int cpid, status, fd;
3552 struct stat statbuf;
3553
3554 if (stat (dpath, &statbuf) != 0)
3555 {
3556 /* Stat just set errno. We don't have to */
3557 return -1;
3558 }
3559
3560 synch_process_alive = 1;
3561 switch (cpid = fork ())
3562 {
3563
3564 case -1: /* Error in fork */
3565 return (-1); /* Errno is set already */
3566
3567 case 0: /* Child process */
3568 fd = emacs_open ("/dev/null", O_RDWR, 0);
3569 if (fd >= 0)
3570 {
3571 dup2 (fd, 0);
3572 dup2 (fd, 1);
3573 dup2 (fd, 2);
3574 }
3575 execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3576 _exit (-1); /* Can't exec /bin/rmdir */
3577
3578 default: /* Parent process */
3579 wait_for_termination (cpid);
3580 }
3581
3582 if (synch_process_death != 0 || synch_process_retcode != 0
3583 || synch_process_termsig != 0)
3584 {
3585 errno = EIO; /* We don't know why, but */
3586 return -1; /* /bin/rmdir failed */
3587 }
3588
3589 return 0;
3590 }
3591 #endif /* !HAVE_RMDIR */
3592
3593
3594 \f
3595 /* Functions for VMS */
3596 #ifdef VMS
3597 #include <acldef.h>
3598 #include <chpdef.h>
3599 #include <jpidef.h>
3600
3601 /* Return as a string the VMS error string pertaining to STATUS.
3602 Reuses the same static buffer each time it is called. */
3603
3604 char *
3605 vmserrstr (status)
3606 int status; /* VMS status code */
3607 {
3608 int bufadr[2];
3609 short len;
3610 static char buf[257];
3611
3612 bufadr[0] = sizeof buf - 1;
3613 bufadr[1] = (int) buf;
3614 if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3615 return "untranslatable VMS error status";
3616 buf[len] = '\0';
3617 return buf;
3618 }
3619
3620 #ifdef access
3621 #undef access
3622
3623 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3624 * not work correctly. (It also doesn't work well in version 2.3.)
3625 */
3626
3627 #ifdef VMS4_4
3628
3629 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3630 { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3631
3632 typedef union {
3633 struct {
3634 unsigned short s_buflen;
3635 unsigned short s_code;
3636 char *s_bufadr;
3637 unsigned short *s_retlenadr;
3638 } s;
3639 int end;
3640 } item;
3641 #define buflen s.s_buflen
3642 #define code s.s_code
3643 #define bufadr s.s_bufadr
3644 #define retlenadr s.s_retlenadr
3645
3646 #define R_OK 4 /* test for read permission */
3647 #define W_OK 2 /* test for write permission */
3648 #define X_OK 1 /* test for execute (search) permission */
3649 #define F_OK 0 /* test for presence of file */
3650
3651 int
3652 sys_access (path, mode)
3653 char *path;
3654 int mode;
3655 {
3656 static char *user = NULL;
3657 char dir_fn[512];
3658
3659 /* translate possible directory spec into .DIR file name, so brain-dead
3660 * access can treat the directory like a file. */
3661 if (directory_file_name (path, dir_fn))
3662 path = dir_fn;
3663
3664 if (mode == F_OK)
3665 return access (path, mode);
3666 if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3667 return -1;
3668 {
3669 int stat;
3670 int flags;
3671 int acces;
3672 unsigned short int dummy;
3673 item itemlst[3];
3674 static int constant = ACL$C_FILE;
3675 DESCRIPTOR (path_desc, path);
3676 DESCRIPTOR (user_desc, user);
3677
3678 flags = 0;
3679 acces = 0;
3680 if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3681 return stat;
3682 if (mode & R_OK)
3683 acces |= CHP$M_READ;
3684 if (mode & W_OK)
3685 acces |= CHP$M_WRITE;
3686 itemlst[0].buflen = sizeof (int);
3687 itemlst[0].code = CHP$_FLAGS;
3688 itemlst[0].bufadr = (char *) &flags;
3689 itemlst[0].retlenadr = &dummy;
3690 itemlst[1].buflen = sizeof (int);
3691 itemlst[1].code = CHP$_ACCESS;
3692 itemlst[1].bufadr = (char *) &acces;
3693 itemlst[1].retlenadr = &dummy;
3694 itemlst[2].end = CHP$_END;
3695 stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3696 return stat == SS$_NORMAL ? 0 : -1;
3697 }
3698 }
3699
3700 #else /* not VMS4_4 */
3701
3702 #include <prvdef.h>
3703 #define ACE$M_WRITE 2
3704 #define ACE$C_KEYID 1
3705
3706 static unsigned short memid, grpid;
3707 static unsigned int uic;
3708
3709 /* Called from init_sys_modes, so it happens not very often
3710 but at least each time Emacs is loaded. */
3711 void
3712 sys_access_reinit ()
3713 {
3714 uic = 0;
3715 }
3716
3717 int
3718 sys_access (filename, type)
3719 char * filename;
3720 int type;
3721 {
3722 struct FAB fab;
3723 struct XABPRO xab;
3724 int status, size, i, typecode, acl_controlled;
3725 unsigned int *aclptr, *aclend, aclbuf[60];
3726 union prvdef prvmask;
3727
3728 /* Get UIC and GRP values for protection checking. */
3729 if (uic == 0)
3730 {
3731 status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3732 if (! (status & 1))
3733 return -1;
3734 memid = uic & 0xFFFF;
3735 grpid = uic >> 16;
3736 }
3737
3738 if (type != 2) /* not checking write access */
3739 return access (filename, type);
3740
3741 /* Check write protection. */
3742
3743 #define CHECKPRIV(bit) (prvmask.bit)
3744 #define WRITABLE(field) (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3745
3746 /* Find privilege bits */
3747 status = SYS$SETPRV (0, 0, 0, prvmask);
3748 if (! (status & 1))
3749 error ("Unable to find privileges: %s", vmserrstr (status));
3750 if (CHECKPRIV (PRV$V_BYPASS))
3751 return 0; /* BYPASS enabled */
3752 fab = cc$rms_fab;
3753 fab.fab$b_fac = FAB$M_GET;
3754 fab.fab$l_fna = filename;
3755 fab.fab$b_fns = strlen (filename);
3756 fab.fab$l_xab = &xab;
3757 xab = cc$rms_xabpro;
3758 xab.xab$l_aclbuf = aclbuf;
3759 xab.xab$w_aclsiz = sizeof (aclbuf);
3760 status = SYS$OPEN (&fab, 0, 0);
3761 if (! (status & 1))
3762 return -1;
3763 SYS$CLOSE (&fab, 0, 0);
3764 /* Check system access */
3765 if (CHECKPRIV (PRV$V_SYSPRV) && WRITABLE (XAB$V_SYS))
3766 return 0;
3767 /* Check ACL entries, if any */
3768 acl_controlled = 0;
3769 if (xab.xab$w_acllen > 0)
3770 {
3771 aclptr = aclbuf;
3772 aclend = &aclbuf[xab.xab$w_acllen / 4];
3773 while (*aclptr && aclptr < aclend)
3774 {
3775 size = (*aclptr & 0xff) / 4;
3776 typecode = (*aclptr >> 8) & 0xff;
3777 if (typecode == ACE$C_KEYID)
3778 for (i = size - 1; i > 1; i--)
3779 if (aclptr[i] == uic)
3780 {
3781 acl_controlled = 1;
3782 if (aclptr[1] & ACE$M_WRITE)
3783 return 0; /* Write access through ACL */
3784 }
3785 aclptr = &aclptr[size];
3786 }
3787 if (acl_controlled) /* ACL specified, prohibits write access */
3788 return -1;
3789 }
3790 /* No ACL entries specified, check normal protection */
3791 if (WRITABLE (XAB$V_WLD)) /* World writable */
3792 return 0;
3793 if (WRITABLE (XAB$V_GRP) &&
3794 (unsigned short) (xab.xab$l_uic >> 16) == grpid)
3795 return 0; /* Group writable */
3796 if (WRITABLE (XAB$V_OWN) &&
3797 (xab.xab$l_uic & 0xFFFF) == memid)
3798 return 0; /* Owner writable */
3799
3800 return -1; /* Not writable */
3801 }
3802 #endif /* not VMS4_4 */
3803 #endif /* access */
3804
3805 static char vtbuf[NAM$C_MAXRSS+1];
3806
3807 /* translate a vms file spec to a unix path */
3808 char *
3809 sys_translate_vms (vfile)
3810 char * vfile;
3811 {
3812 char * p;
3813 char * targ;
3814
3815 if (!vfile)
3816 return 0;
3817
3818 targ = vtbuf;
3819
3820 /* leading device or logical name is a root directory */
3821 if (p = strchr (vfile, ':'))
3822 {
3823 *targ++ = '/';
3824 while (vfile < p)
3825 *targ++ = *vfile++;
3826 vfile++;
3827 *targ++ = '/';
3828 }
3829 p = vfile;
3830 if (*p == '[' || *p == '<')
3831 {
3832 while (*++vfile != *p + 2)
3833 switch (*vfile)
3834 {
3835 case '.':
3836 if (vfile[-1] == *p)
3837 *targ++ = '.';
3838 *targ++ = '/';
3839 break;
3840
3841 case '-':
3842 *targ++ = '.';
3843 *targ++ = '.';
3844 break;
3845
3846 default:
3847 *targ++ = *vfile;
3848 break;
3849 }
3850 vfile++;
3851 *targ++ = '/';
3852 }
3853 while (*vfile)
3854 *targ++ = *vfile++;
3855
3856 return vtbuf;
3857 }
3858
3859 static char utbuf[NAM$C_MAXRSS+1];
3860
3861 /* translate a unix path to a VMS file spec */
3862 char *
3863 sys_translate_unix (ufile)
3864 char * ufile;
3865 {
3866 int slash_seen = 0;
3867 char *p;
3868 char * targ;
3869
3870 if (!ufile)
3871 return 0;
3872
3873 targ = utbuf;
3874
3875 if (*ufile == '/')
3876 {
3877 ufile++;
3878 }
3879
3880 while (*ufile)
3881 {
3882 switch (*ufile)
3883 {
3884 case '/':
3885 if (slash_seen)
3886 if (index (&ufile[1], '/'))
3887 *targ++ = '.';
3888 else
3889 *targ++ = ']';
3890 else
3891 {
3892 *targ++ = ':';
3893 if (index (&ufile[1], '/'))
3894 *targ++ = '[';
3895 slash_seen = 1;
3896 }
3897 break;
3898
3899 case '.':
3900 if (strncmp (ufile, "./", 2) == 0)
3901 {
3902 if (!slash_seen)
3903 {
3904 *targ++ = '[';
3905 slash_seen = 1;
3906 }
3907 ufile++; /* skip the dot */
3908 if (index (&ufile[1], '/'))
3909 *targ++ = '.';
3910 else
3911 *targ++ = ']';
3912 }
3913 else if (strncmp (ufile, "../", 3) == 0)
3914 {
3915 if (!slash_seen)
3916 {
3917 *targ++ = '[';
3918 slash_seen = 1;
3919 }
3920 *targ++ = '-';
3921 ufile += 2; /* skip the dots */
3922 if (index (&ufile[1], '/'))
3923 *targ++ = '.';
3924 else
3925 *targ++ = ']';
3926 }
3927 else
3928 *targ++ = *ufile;
3929 break;
3930
3931 default:
3932 *targ++ = *ufile;
3933 break;
3934 }
3935 ufile++;
3936 }
3937 *targ = '\0';
3938
3939 return utbuf;
3940 }
3941
3942 char *
3943 getwd (pathname)
3944 char *pathname;
3945 {
3946 char *ptr, *val;
3947 extern char *getcwd ();
3948
3949 #define MAXPATHLEN 1024
3950
3951 ptr = xmalloc (MAXPATHLEN);
3952 val = getcwd (ptr, MAXPATHLEN);
3953 if (val == 0)
3954 {
3955 xfree (ptr);
3956 return val;
3957 }
3958 strcpy (pathname, ptr);
3959 xfree (ptr);
3960
3961 return pathname;
3962 }
3963
3964 int
3965 getppid ()
3966 {
3967 long item_code = JPI$_OWNER;
3968 unsigned long parent_id;
3969 int status;
3970
3971 if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
3972 {
3973 errno = EVMSERR;
3974 vaxc$errno = status;
3975 return -1;
3976 }
3977 return parent_id;
3978 }
3979
3980 #undef getuid
3981 unsigned
3982 sys_getuid ()
3983 {
3984 return (getgid () << 16) | getuid ();
3985 }
3986
3987 #undef read
3988 int
3989 sys_read (fildes, buf, nbyte)
3990 int fildes;
3991 char *buf;
3992 unsigned int nbyte;
3993 {
3994 return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
3995 }
3996
3997 /*
3998 * VAX/VMS VAX C RTL really loses. It insists that records
3999 * end with a newline (carriage return) character, and if they
4000 * don't it adds one (nice of it isn't it!)
4001 *
4002 * Thus we do this stupidity below.
4003 */
4004
4005 #undef write
4006 int
4007 sys_write (fildes, buf, nbytes)
4008 int fildes;
4009 char *buf;
4010 unsigned int nbytes;
4011 {
4012 register char *p;
4013 register char *e;
4014 int sum = 0;
4015 struct stat st;
4016
4017 fstat (fildes, &st);
4018 p = buf;
4019 while (nbytes > 0)
4020 {
4021 int len, retval;
4022
4023 /* Handle fixed-length files with carriage control. */
4024 if (st.st_fab_rfm == FAB$C_FIX
4025 && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4026 {
4027 len = st.st_fab_mrs;
4028 retval = write (fildes, p, min (len, nbytes));
4029 if (retval != len)
4030 return -1;
4031 retval++; /* This skips the implied carriage control */
4032 }
4033 else
4034 {
4035 e = p + min (MAXIOSIZE, nbytes) - 1;
4036 while (*e != '\n' && e > p) e--;
4037 if (p == e) /* Ok.. so here we add a newline... sigh. */
4038 e = p + min (MAXIOSIZE, nbytes) - 1;
4039 len = e + 1 - p;
4040 retval = write (fildes, p, len);
4041 if (retval != len)
4042 return -1;
4043 }
4044 p += retval;
4045 sum += retval;
4046 nbytes -= retval;
4047 }
4048 return sum;
4049 }
4050
4051 /* Create file NEW copying its attributes from file OLD. If
4052 OLD is 0 or does not exist, create based on the value of
4053 vms_stmlf_recfm. */
4054
4055 /* Protection value the file should ultimately have.
4056 Set by create_copy_attrs, and use by rename_sansversions. */
4057 static unsigned short int fab_final_pro;
4058
4059 int
4060 creat_copy_attrs (old, new)
4061 char *old, *new;
4062 {
4063 struct FAB fab = cc$rms_fab;
4064 struct XABPRO xabpro;
4065 char aclbuf[256]; /* Choice of size is arbitrary. See below. */
4066 extern int vms_stmlf_recfm;
4067
4068 if (old)
4069 {
4070 fab.fab$b_fac = FAB$M_GET;
4071 fab.fab$l_fna = old;
4072 fab.fab$b_fns = strlen (old);
4073 fab.fab$l_xab = (char *) &xabpro;
4074 xabpro = cc$rms_xabpro;
4075 xabpro.xab$l_aclbuf = aclbuf;
4076 xabpro.xab$w_aclsiz = sizeof aclbuf;
4077 /* Call $OPEN to fill in the fab & xabpro fields. */
4078 if (SYS$OPEN (&fab, 0, 0) & 1)
4079 {
4080 SYS$CLOSE (&fab, 0, 0);
4081 fab.fab$l_alq = 0; /* zero the allocation quantity */
4082 if (xabpro.xab$w_acllen > 0)
4083 {
4084 if (xabpro.xab$w_acllen > sizeof aclbuf)
4085 /* If the acl buffer was too short, redo open with longer one.
4086 Wouldn't need to do this if there were some system imposed
4087 limit on the size of an ACL, but I can't find any such. */
4088 {
4089 xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
4090 xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
4091 if (SYS$OPEN (&fab, 0, 0) & 1)
4092 SYS$CLOSE (&fab, 0, 0);
4093 else
4094 old = 0;
4095 }
4096 }
4097 else
4098 xabpro.xab$l_aclbuf = 0;
4099 }
4100 else
4101 old = 0;
4102 }
4103 fab.fab$l_fna = new;
4104 fab.fab$b_fns = strlen (new);
4105 if (!old)
4106 {
4107 fab.fab$l_xab = 0;
4108 fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
4109 fab.fab$b_rat = FAB$M_CR;
4110 }
4111
4112 /* Set the file protections such that we will be able to manipulate
4113 this file. Once we are done writing and renaming it, we will set
4114 the protections back. */
4115 if (old)
4116 fab_final_pro = xabpro.xab$w_pro;
4117 else
4118 SYS$SETDFPROT (0, &fab_final_pro);
4119 xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
4120
4121 /* Create the new file with either default attrs or attrs copied
4122 from old file. */
4123 if (!(SYS$CREATE (&fab, 0, 0) & 1))
4124 return -1;
4125 SYS$CLOSE (&fab, 0, 0);
4126 /* As this is a "replacement" for creat, return a file descriptor
4127 opened for writing. */
4128 return open (new, O_WRONLY);
4129 }
4130
4131 #ifdef creat
4132 #undef creat
4133 #include <varargs.h>
4134 #ifdef __GNUC__
4135 #ifndef va_count
4136 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4137 #endif
4138 #endif
4139
4140 int
4141 sys_creat (va_alist)
4142 va_dcl
4143 {
4144 va_list list_incrementer;
4145 char *name;
4146 int mode;
4147 int rfd; /* related file descriptor */
4148 int fd; /* Our new file descriptor */
4149 int count;
4150 struct stat st_buf;
4151 char rfm[12];
4152 char rat[15];
4153 char mrs[13];
4154 char fsz[13];
4155 extern int vms_stmlf_recfm;
4156
4157 va_count (count);
4158 va_start (list_incrementer);
4159 name = va_arg (list_incrementer, char *);
4160 mode = va_arg (list_incrementer, int);
4161 if (count > 2)
4162 rfd = va_arg (list_incrementer, int);
4163 va_end (list_incrementer);
4164 if (count > 2)
4165 {
4166 /* Use information from the related file descriptor to set record
4167 format of the newly created file. */
4168 fstat (rfd, &st_buf);
4169 switch (st_buf.st_fab_rfm)
4170 {
4171 case FAB$C_FIX:
4172 strcpy (rfm, "rfm = fix");
4173 sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4174 strcpy (rat, "rat = ");
4175 if (st_buf.st_fab_rat & FAB$M_CR)
4176 strcat (rat, "cr");
4177 else if (st_buf.st_fab_rat & FAB$M_FTN)
4178 strcat (rat, "ftn");
4179 else if (st_buf.st_fab_rat & FAB$M_PRN)
4180 strcat (rat, "prn");
4181 if (st_buf.st_fab_rat & FAB$M_BLK)
4182 if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4183 strcat (rat, ", blk");
4184 else
4185 strcat (rat, "blk");
4186 return creat (name, 0, rfm, rat, mrs);
4187
4188 case FAB$C_VFC:
4189 strcpy (rfm, "rfm = vfc");
4190 sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4191 strcpy (rat, "rat = ");
4192 if (st_buf.st_fab_rat & FAB$M_CR)
4193 strcat (rat, "cr");
4194 else if (st_buf.st_fab_rat & FAB$M_FTN)
4195 strcat (rat, "ftn");
4196 else if (st_buf.st_fab_rat & FAB$M_PRN)
4197 strcat (rat, "prn");
4198 if (st_buf.st_fab_rat & FAB$M_BLK)
4199 if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4200 strcat (rat, ", blk");
4201 else
4202 strcat (rat, "blk");
4203 return creat (name, 0, rfm, rat, fsz);
4204
4205 case FAB$C_STM:
4206 strcpy (rfm, "rfm = stm");
4207 break;
4208
4209 case FAB$C_STMCR:
4210 strcpy (rfm, "rfm = stmcr");
4211 break;
4212
4213 case FAB$C_STMLF:
4214 strcpy (rfm, "rfm = stmlf");
4215 break;
4216
4217 case FAB$C_UDF:
4218 strcpy (rfm, "rfm = udf");
4219 break;
4220
4221 case FAB$C_VAR:
4222 strcpy (rfm, "rfm = var");
4223 break;
4224 }
4225 strcpy (rat, "rat = ");
4226 if (st_buf.st_fab_rat & FAB$M_CR)
4227 strcat (rat, "cr");
4228 else if (st_buf.st_fab_rat & FAB$M_FTN)
4229 strcat (rat, "ftn");
4230 else if (st_buf.st_fab_rat & FAB$M_PRN)
4231 strcat (rat, "prn");
4232 if (st_buf.st_fab_rat & FAB$M_BLK)
4233 if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4234 strcat (rat, ", blk");
4235 else
4236 strcat (rat, "blk");
4237 }
4238 else
4239 {
4240 strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4241 strcpy (rat, "rat=cr");
4242 }
4243 /* Until the VAX C RTL fixes the many bugs with modes, always use
4244 mode 0 to get the user's default protection. */
4245 fd = creat (name, 0, rfm, rat);
4246 if (fd < 0 && errno == EEXIST)
4247 {
4248 if (unlink (name) < 0)
4249 report_file_error ("delete", build_string (name));
4250 fd = creat (name, 0, rfm, rat);
4251 }
4252 return fd;
4253 }
4254 #endif /* creat */
4255
4256 /* fwrite to stdout is S L O W. Speed it up by using fputc...*/
4257 int
4258 sys_fwrite (ptr, size, num, fp)
4259 register char * ptr;
4260 FILE * fp;
4261 {
4262 register int tot = num * size;
4263
4264 while (tot--)
4265 fputc (*ptr++, fp);
4266 return num;
4267 }
4268
4269 /*
4270 * The VMS C library routine creat actually creates a new version of an
4271 * existing file rather than truncating the old version. There are times
4272 * when this is not the desired behavior, for instance, when writing an
4273 * auto save file (you only want one version), or when you don't have
4274 * write permission in the directory containing the file (but the file
4275 * itself is writable). Hence this routine, which is equivalent to
4276 * "close (creat (fn, 0));" on Unix if fn already exists.
4277 */
4278 int
4279 vms_truncate (fn)
4280 char *fn;
4281 {
4282 struct FAB xfab = cc$rms_fab;
4283 struct RAB xrab = cc$rms_rab;
4284 int status;
4285
4286 xfab.fab$l_fop = FAB$M_TEF; /* free allocated but unused blocks on close */
4287 xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4288 xfab.fab$b_shr = FAB$M_NIL; /* allow no sharing - file must be locked */
4289 xfab.fab$l_fna = fn;
4290 xfab.fab$b_fns = strlen (fn);
4291 xfab.fab$l_dna = ";0"; /* default to latest version of the file */
4292 xfab.fab$b_dns = 2;
4293 xrab.rab$l_fab = &xfab;
4294
4295 /* This gibberish opens the file, positions to the first record, and
4296 deletes all records from there until the end of file. */
4297 if ((SYS$OPEN (&xfab) & 01) == 01)
4298 {
4299 if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4300 (SYS$FIND (&xrab) & 01) == 01 &&
4301 (SYS$TRUNCATE (&xrab) & 01) == 01)
4302 status = 0;
4303 else
4304 status = -1;
4305 }
4306 else
4307 status = -1;
4308 SYS$CLOSE (&xfab);
4309 return status;
4310 }
4311
4312 /* Define this symbol to actually read SYSUAF.DAT. This requires either
4313 SYSPRV or a readable SYSUAF.DAT. */
4314
4315 #ifdef READ_SYSUAF
4316 /*
4317 * getuaf.c
4318 *
4319 * Routine to read the VMS User Authorization File and return
4320 * a specific user's record.
4321 */
4322
4323 static struct UAF retuaf;
4324
4325 struct UAF *
4326 get_uaf_name (uname)
4327 char * uname;
4328 {
4329 register status;
4330 struct FAB uaf_fab;
4331 struct RAB uaf_rab;
4332
4333 uaf_fab = cc$rms_fab;
4334 uaf_rab = cc$rms_rab;
4335 /* initialize fab fields */
4336 uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4337 uaf_fab.fab$b_fns = 21;
4338 uaf_fab.fab$b_fac = FAB$M_GET;
4339 uaf_fab.fab$b_org = FAB$C_IDX;
4340 uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4341 /* initialize rab fields */
4342 uaf_rab.rab$l_fab = &uaf_fab;
4343 /* open the User Authorization File */
4344 status = SYS$OPEN (&uaf_fab);
4345 if (!(status&1))
4346 {
4347 errno = EVMSERR;
4348 vaxc$errno = status;
4349 return 0;
4350 }
4351 status = SYS$CONNECT (&uaf_rab);
4352 if (!(status&1))
4353 {
4354 errno = EVMSERR;
4355 vaxc$errno = status;
4356 return 0;
4357 }
4358 /* read the requested record - index is in uname */
4359 uaf_rab.rab$l_kbf = uname;
4360 uaf_rab.rab$b_ksz = strlen (uname);
4361 uaf_rab.rab$b_rac = RAB$C_KEY;
4362 uaf_rab.rab$l_ubf = (char *)&retuaf;
4363 uaf_rab.rab$w_usz = sizeof retuaf;
4364 status = SYS$GET (&uaf_rab);
4365 if (!(status&1))
4366 {
4367 errno = EVMSERR;
4368 vaxc$errno = status;
4369 return 0;
4370 }
4371 /* close the User Authorization File */
4372 status = SYS$DISCONNECT (&uaf_rab);
4373 if (!(status&1))
4374 {
4375 errno = EVMSERR;
4376 vaxc$errno = status;
4377 return 0;
4378 }
4379 status = SYS$CLOSE (&uaf_fab);
4380 if (!(status&1))
4381 {
4382 errno = EVMSERR;
4383 vaxc$errno = status;
4384 return 0;
4385 }
4386 return &retuaf;
4387 }
4388
4389 struct UAF *
4390 get_uaf_uic (uic)
4391 unsigned long uic;
4392 {
4393 register status;
4394 struct FAB uaf_fab;
4395 struct RAB uaf_rab;
4396
4397 uaf_fab = cc$rms_fab;
4398 uaf_rab = cc$rms_rab;
4399 /* initialize fab fields */
4400 uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4401 uaf_fab.fab$b_fns = 21;
4402 uaf_fab.fab$b_fac = FAB$M_GET;
4403 uaf_fab.fab$b_org = FAB$C_IDX;
4404 uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4405 /* initialize rab fields */
4406 uaf_rab.rab$l_fab = &uaf_fab;
4407 /* open the User Authorization File */
4408 status = SYS$OPEN (&uaf_fab);
4409 if (!(status&1))
4410 {
4411 errno = EVMSERR;
4412 vaxc$errno = status;
4413 return 0;
4414 }
4415 status = SYS$CONNECT (&uaf_rab);
4416 if (!(status&1))
4417 {
4418 errno = EVMSERR;
4419 vaxc$errno = status;
4420 return 0;
4421 }
4422 /* read the requested record - index is in uic */
4423 uaf_rab.rab$b_krf = 1; /* 1st alternate key */
4424 uaf_rab.rab$l_kbf = (char *) &uic;
4425 uaf_rab.rab$b_ksz = sizeof uic;
4426 uaf_rab.rab$b_rac = RAB$C_KEY;
4427 uaf_rab.rab$l_ubf = (char *)&retuaf;
4428 uaf_rab.rab$w_usz = sizeof retuaf;
4429 status = SYS$GET (&uaf_rab);
4430 if (!(status&1))
4431 {
4432 errno = EVMSERR;
4433 vaxc$errno = status;
4434 return 0;
4435 }
4436 /* close the User Authorization File */
4437 status = SYS$DISCONNECT (&uaf_rab);
4438 if (!(status&1))
4439 {
4440 errno = EVMSERR;
4441 vaxc$errno = status;
4442 return 0;
4443 }
4444 status = SYS$CLOSE (&uaf_fab);
4445 if (!(status&1))
4446 {
4447 errno = EVMSERR;
4448 vaxc$errno = status;
4449 return 0;
4450 }
4451 return &retuaf;
4452 }
4453
4454 static struct passwd retpw;
4455
4456 struct passwd *
4457 cnv_uaf_pw (up)
4458 struct UAF * up;
4459 {
4460 char * ptr;
4461
4462 /* copy these out first because if the username is 32 chars, the next
4463 section will overwrite the first byte of the UIC */
4464 retpw.pw_uid = up->uaf$w_mem;
4465 retpw.pw_gid = up->uaf$w_grp;
4466
4467 /* I suppose this is not the best style, to possibly overwrite one
4468 byte beyond the end of the field, but what the heck... */
4469 ptr = &up->uaf$t_username[UAF$S_USERNAME];
4470 while (ptr[-1] == ' ')
4471 ptr--;
4472 *ptr = '\0';
4473 strcpy (retpw.pw_name, up->uaf$t_username);
4474
4475 /* the rest of these are counted ascii strings */
4476 strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4477 retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4478 strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4479 retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4480 strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4481 retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4482 strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4483 retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4484
4485 return &retpw;
4486 }
4487 #else /* not READ_SYSUAF */
4488 static struct passwd retpw;
4489 #endif /* not READ_SYSUAF */
4490
4491 struct passwd *
4492 getpwnam (name)
4493 char * name;
4494 {
4495 #ifdef READ_SYSUAF
4496 struct UAF *up;
4497 #else
4498 char * user;
4499 char * dir;
4500 unsigned char * full;
4501 #endif /* READ_SYSUAF */
4502 char *ptr = name;
4503
4504 while (*ptr)
4505 {
4506 if ('a' <= *ptr && *ptr <= 'z')
4507 *ptr -= 040;
4508 ptr++;
4509 }
4510 #ifdef READ_SYSUAF
4511 if (!(up = get_uaf_name (name)))
4512 return 0;
4513 return cnv_uaf_pw (up);
4514 #else
4515 if (strcmp (name, getenv ("USER")) == 0)
4516 {
4517 retpw.pw_uid = getuid ();
4518 retpw.pw_gid = getgid ();
4519 strcpy (retpw.pw_name, name);
4520 if (full = egetenv ("FULLNAME"))
4521 strcpy (retpw.pw_gecos, full);
4522 else
4523 *retpw.pw_gecos = '\0';
4524 strcpy (retpw.pw_dir, egetenv ("HOME"));
4525 *retpw.pw_shell = '\0';
4526 return &retpw;
4527 }
4528 else
4529 return 0;
4530 #endif /* not READ_SYSUAF */
4531 }
4532
4533 struct passwd *
4534 getpwuid (uid)
4535 unsigned long uid;
4536 {
4537 #ifdef READ_SYSUAF
4538 struct UAF * up;
4539
4540 if (!(up = get_uaf_uic (uid)))
4541 return 0;
4542 return cnv_uaf_pw (up);
4543 #else
4544 if (uid == sys_getuid ())
4545 return getpwnam (egetenv ("USER"));
4546 else
4547 return 0;
4548 #endif /* not READ_SYSUAF */
4549 }
4550
4551 /* return total address space available to the current process. This is
4552 the sum of the current p0 size, p1 size and free page table entries
4553 available. */
4554 int
4555 vlimit ()
4556 {
4557 int item_code;
4558 unsigned long free_pages;
4559 unsigned long frep0va;
4560 unsigned long frep1va;
4561 register status;
4562
4563 item_code = JPI$_FREPTECNT;
4564 if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4565 {
4566 errno = EVMSERR;
4567 vaxc$errno = status;
4568 return -1;
4569 }
4570 free_pages *= 512;
4571
4572 item_code = JPI$_FREP0VA;
4573 if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4574 {
4575 errno = EVMSERR;
4576 vaxc$errno = status;
4577 return -1;
4578 }
4579 item_code = JPI$_FREP1VA;
4580 if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4581 {
4582 errno = EVMSERR;
4583 vaxc$errno = status;
4584 return -1;
4585 }
4586
4587 return free_pages + frep0va + (0x7fffffff - frep1va);
4588 }
4589
4590 int
4591 define_logical_name (varname, string)
4592 char *varname;
4593 char *string;
4594 {
4595 struct dsc$descriptor_s strdsc =
4596 {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
4597 struct dsc$descriptor_s envdsc =
4598 {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4599 struct dsc$descriptor_s lnmdsc =
4600 {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4601
4602 return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4603 }
4604
4605 int
4606 delete_logical_name (varname)
4607 char *varname;
4608 {
4609 struct dsc$descriptor_s envdsc =
4610 {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4611 struct dsc$descriptor_s lnmdsc =
4612 {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4613
4614 return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4615 }
4616
4617 int
4618 ulimit ()
4619 {
4620 return 0;
4621 }
4622
4623 int
4624 setpgrp ()
4625 {
4626 return 0;
4627 }
4628
4629 int
4630 execvp ()
4631 {
4632 error ("execvp system call not implemented");
4633 return -1;
4634 }
4635
4636 int
4637 rename (from, to)
4638 char *from, *to;
4639 {
4640 int status;
4641 struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4642 struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4643 char from_esn[NAM$C_MAXRSS];
4644 char to_esn[NAM$C_MAXRSS];
4645
4646 from_fab.fab$l_fna = from;
4647 from_fab.fab$b_fns = strlen (from);
4648 from_fab.fab$l_nam = &from_nam;
4649 from_fab.fab$l_fop = FAB$M_NAM;
4650
4651 from_nam.nam$l_esa = from_esn;
4652 from_nam.nam$b_ess = sizeof from_esn;
4653
4654 to_fab.fab$l_fna = to;
4655 to_fab.fab$b_fns = strlen (to);
4656 to_fab.fab$l_nam = &to_nam;
4657 to_fab.fab$l_fop = FAB$M_NAM;
4658
4659 to_nam.nam$l_esa = to_esn;
4660 to_nam.nam$b_ess = sizeof to_esn;
4661
4662 status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4663
4664 if (status & 1)
4665 return 0;
4666 else
4667 {
4668 if (status == RMS$_DEV)
4669 errno = EXDEV;
4670 else
4671 errno = EVMSERR;
4672 vaxc$errno = status;
4673 return -1;
4674 }
4675 }
4676
4677 /* This function renames a file like `rename', but it strips
4678 the version number from the "to" filename, such that the "to" file is
4679 will always be a new version. It also sets the file protection once it is
4680 finished. The protection that we will use is stored in fab_final_pro,
4681 and was set when we did a creat_copy_attrs to create the file that we
4682 are renaming.
4683
4684 We could use the chmod function, but Eunichs uses 3 bits per user category
4685 to describe the protection, and VMS uses 4 (write and delete are separate
4686 bits). To maintain portability, the VMS implementation of `chmod' wires
4687 the W and D bits together. */
4688
4689
4690 static struct fibdef fib; /* We need this initialized to zero */
4691 char vms_file_written[NAM$C_MAXRSS];
4692
4693 int
4694 rename_sans_version (from,to)
4695 char *from, *to;
4696 {
4697 short int chan;
4698 int stat;
4699 short int iosb[4];
4700 int status;
4701 struct FAB to_fab = cc$rms_fab;
4702 struct NAM to_nam = cc$rms_nam;
4703 struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4704 struct dsc$descriptor fib_attr[2]
4705 = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4706 char to_esn[NAM$C_MAXRSS];
4707
4708 $DESCRIPTOR (disk,to_esn);
4709
4710 to_fab.fab$l_fna = to;
4711 to_fab.fab$b_fns = strlen (to);
4712 to_fab.fab$l_nam = &to_nam;
4713 to_fab.fab$l_fop = FAB$M_NAM;
4714
4715 to_nam.nam$l_esa = to_esn;
4716 to_nam.nam$b_ess = sizeof to_esn;
4717
4718 status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4719
4720 if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4721 *(to_nam.nam$l_ver) = '\0';
4722
4723 stat = rename (from, to_esn);
4724 if (stat < 0)
4725 return stat;
4726
4727 strcpy (vms_file_written, to_esn);
4728
4729 to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4730 to_fab.fab$b_fns = strlen (vms_file_written);
4731
4732 /* Now set the file protection to the correct value */
4733 SYS$OPEN (&to_fab, 0, 0); /* This fills in the nam$w_fid fields */
4734
4735 /* Copy these fields into the fib */
4736 fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4737 fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4738 fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4739
4740 SYS$CLOSE (&to_fab, 0, 0);
4741
4742 stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
4743 if (!stat)
4744 LIB$SIGNAL (stat);
4745 stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4746 0, 0, 0, &fib_attr, 0);
4747 if (!stat)
4748 LIB$SIGNAL (stat);
4749 stat = SYS$DASSGN (chan);
4750 if (!stat)
4751 LIB$SIGNAL (stat);
4752 strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
4753 return 0;
4754 }
4755
4756 int
4757 link (file, new)
4758 char * file, * new;
4759 {
4760 register status;
4761 struct FAB fab;
4762 struct NAM nam;
4763 unsigned short fid[3];
4764 char esa[NAM$C_MAXRSS];
4765
4766 fab = cc$rms_fab;
4767 fab.fab$l_fop = FAB$M_OFP;
4768 fab.fab$l_fna = file;
4769 fab.fab$b_fns = strlen (file);
4770 fab.fab$l_nam = &nam;
4771
4772 nam = cc$rms_nam;
4773 nam.nam$l_esa = esa;
4774 nam.nam$b_ess = NAM$C_MAXRSS;
4775
4776 status = SYS$PARSE (&fab);
4777 if ((status & 1) == 0)
4778 {
4779 errno = EVMSERR;
4780 vaxc$errno = status;
4781 return -1;
4782 }
4783 status = SYS$SEARCH (&fab);
4784 if ((status & 1) == 0)
4785 {
4786 errno = EVMSERR;
4787 vaxc$errno = status;
4788 return -1;
4789 }
4790
4791 fid[0] = nam.nam$w_fid[0];
4792 fid[1] = nam.nam$w_fid[1];
4793 fid[2] = nam.nam$w_fid[2];
4794
4795 fab.fab$l_fna = new;
4796 fab.fab$b_fns = strlen (new);
4797
4798 status = SYS$PARSE (&fab);
4799 if ((status & 1) == 0)
4800 {
4801 errno = EVMSERR;
4802 vaxc$errno = status;
4803 return -1;
4804 }
4805
4806 nam.nam$w_fid[0] = fid[0];
4807 nam.nam$w_fid[1] = fid[1];
4808 nam.nam$w_fid[2] = fid[2];
4809
4810 nam.nam$l_esa = nam.nam$l_name;
4811 nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
4812
4813 status = SYS$ENTER (&fab);
4814 if ((status & 1) == 0)
4815 {
4816 errno = EVMSERR;
4817 vaxc$errno = status;
4818 return -1;
4819 }
4820
4821 return 0;
4822 }
4823
4824 void
4825 croak (badfunc)
4826 char *badfunc;
4827 {
4828 printf ("%s not yet implemented\r\n", badfunc);
4829 reset_all_sys_modes ();
4830 exit (1);
4831 }
4832
4833 long
4834 random ()
4835 {
4836 /* Arrange to return a range centered on zero. */
4837 return rand () - (1 << 30);
4838 }
4839
4840 void
4841 srandom (seed)
4842 {
4843 srand (seed);
4844 }
4845 #endif /* VMS */
4846 \f
4847 #ifndef BSTRING
4848
4849 #ifndef bzero
4850
4851 void
4852 bzero (b, length)
4853 register char *b;
4854 register int length;
4855 {
4856 #ifdef VMS
4857 short zero = 0;
4858 long max_str = 65535;
4859
4860 while (length > max_str) {
4861 (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
4862 length -= max_str;
4863 b += max_str;
4864 }
4865 max_str = length;
4866 (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
4867 #else
4868 while (length-- > 0)
4869 *b++ = 0;
4870 #endif /* not VMS */
4871 }
4872
4873 #endif /* no bzero */
4874 #endif /* BSTRING */
4875
4876 #if (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY)
4877 #undef bcopy
4878
4879 /* Saying `void' requires a declaration, above, where bcopy is used
4880 and that declaration causes pain for systems where bcopy is a macro. */
4881 bcopy (b1, b2, length)
4882 register char *b1;
4883 register char *b2;
4884 register int length;
4885 {
4886 #ifdef VMS
4887 long max_str = 65535;
4888
4889 while (length > max_str) {
4890 (void) LIB$MOVC3 (&max_str, b1, b2);
4891 length -= max_str;
4892 b1 += max_str;
4893 b2 += max_str;
4894 }
4895 max_str = length;
4896 (void) LIB$MOVC3 (&length, b1, b2);
4897 #else
4898 while (length-- > 0)
4899 *b2++ = *b1++;
4900 #endif /* not VMS */
4901 }
4902 #endif /* (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY) */
4903
4904 #ifndef BSTRING
4905 #ifndef bcmp
4906 int
4907 bcmp (b1, b2, length) /* This could be a macro! */
4908 register char *b1;
4909 register char *b2;
4910 register int length;
4911 {
4912 #ifdef VMS
4913 struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
4914 struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
4915
4916 return STR$COMPARE (&src1, &src2);
4917 #else
4918 while (length-- > 0)
4919 if (*b1++ != *b2++)
4920 return 1;
4921
4922 return 0;
4923 #endif /* not VMS */
4924 }
4925 #endif /* no bcmp */
4926 #endif /* not BSTRING */
4927 \f
4928 #ifndef HAVE_STRSIGNAL
4929 char *
4930 strsignal (code)
4931 int code;
4932 {
4933 char *signame = 0;
4934
4935 if (0 <= code && code < NSIG)
4936 {
4937 #ifdef VMS
4938 signame = sys_errlist[code];
4939 #else
4940 /* Cast to suppress warning if the table has const char *. */
4941 signame = (char *) sys_siglist[code];
4942 #endif
4943 }
4944
4945 return signame;
4946 }
4947 #endif /* HAVE_STRSIGNAL */
4948 \f
4949 #ifdef HAVE_TERMIOS
4950 /* For make-serial-process */
4951 int serial_open (char *port)
4952 {
4953 int fd = -1;
4954
4955 fd = emacs_open ((char*) port,
4956 O_RDWR
4957 #ifdef O_NONBLOCK
4958 | O_NONBLOCK
4959 #else
4960 | O_NDELAY
4961 #endif
4962 #ifdef O_NOCTTY
4963 | O_NOCTTY
4964 #endif
4965 , 0);
4966 if (fd < 0)
4967 {
4968 error ("Could not open %s: %s",
4969 port, emacs_strerror (errno));
4970 }
4971 #ifdef TIOCEXCL
4972 ioctl (fd, TIOCEXCL, (char *) 0);
4973 #endif
4974
4975 return fd;
4976 }
4977 #endif /* TERMIOS */
4978
4979 #ifdef HAVE_TERMIOS
4980
4981 #if !defined (HAVE_CFMAKERAW)
4982 /* Workaround for targets which are missing cfmakeraw. */
4983 /* Pasted from man page. */
4984 static void cfmakeraw (struct termios *termios_p)
4985 {
4986 termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
4987 termios_p->c_oflag &= ~OPOST;
4988 termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
4989 termios_p->c_cflag &= ~(CSIZE|PARENB);
4990 termios_p->c_cflag |= CS8;
4991 }
4992 #endif /* !defined (HAVE_CFMAKERAW */
4993
4994 #if !defined (HAVE_CFSETSPEED)
4995 /* Workaround for targets which are missing cfsetspeed. */
4996 static int cfsetspeed (struct termios *termios_p, speed_t vitesse)
4997 {
4998 return (cfsetispeed (termios_p, vitesse)
4999 + cfsetospeed (termios_p, vitesse));
5000 }
5001 #endif
5002
5003 /* For serial-process-configure */
5004 void
5005 serial_configure (struct Lisp_Process *p,
5006 Lisp_Object contact)
5007 {
5008 Lisp_Object childp2 = Qnil;
5009 Lisp_Object tem = Qnil;
5010 struct termios attr;
5011 int err = -1;
5012 char summary[4] = "???"; /* This usually becomes "8N1". */
5013
5014 childp2 = Fcopy_sequence (p->childp);
5015
5016 /* Read port attributes and prepare default configuration. */
5017 err = tcgetattr (p->outfd, &attr);
5018 if (err != 0)
5019 error ("tcgetattr() failed: %s", emacs_strerror (errno));
5020 cfmakeraw (&attr);
5021 #if defined (CLOCAL)
5022 attr.c_cflag |= CLOCAL;
5023 #endif
5024 #if defined (CREAD)
5025 attr.c_cflag | CREAD;
5026 #endif
5027
5028 /* Configure speed. */
5029 if (!NILP (Fplist_member (contact, QCspeed)))
5030 tem = Fplist_get (contact, QCspeed);
5031 else
5032 tem = Fplist_get (p->childp, QCspeed);
5033 CHECK_NUMBER (tem);
5034 err = cfsetspeed (&attr, XINT (tem));
5035 if (err != 0)
5036 error ("cfsetspeed(%d) failed: %s", XINT (tem), emacs_strerror (errno));
5037 childp2 = Fplist_put (childp2, QCspeed, tem);
5038
5039 /* Configure bytesize. */
5040 if (!NILP (Fplist_member (contact, QCbytesize)))
5041 tem = Fplist_get (contact, QCbytesize);
5042 else
5043 tem = Fplist_get (p->childp, QCbytesize);
5044 if (NILP (tem))
5045 tem = make_number (8);
5046 CHECK_NUMBER (tem);
5047 if (XINT (tem) != 7 && XINT (tem) != 8)
5048 error (":bytesize must be nil (8), 7, or 8");
5049 summary[0] = XINT(tem) + '0';
5050 #if defined (CSIZE) && defined (CS7) && defined (CS8)
5051 attr.c_cflag &= ~CSIZE;
5052 attr.c_cflag |= ((XINT (tem) == 7) ? CS7 : CS8);
5053 #else
5054 /* Don't error on bytesize 8, which should be set by cfmakeraw. */
5055 if (XINT (tem) != 8)
5056 error ("Bytesize cannot be changed");
5057 #endif
5058 childp2 = Fplist_put (childp2, QCbytesize, tem);
5059
5060 /* Configure parity. */
5061 if (!NILP (Fplist_member (contact, QCparity)))
5062 tem = Fplist_get (contact, QCparity);
5063 else
5064 tem = Fplist_get (p->childp, QCparity);
5065 if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
5066 error (":parity must be nil (no parity), `even', or `odd'");
5067 #if defined (PARENB) && defined (PARODD) && defined (IGNPAR) && defined (INPCK)
5068 attr.c_cflag &= ~(PARENB | PARODD);
5069 attr.c_iflag &= ~(IGNPAR | INPCK);
5070 if (NILP (tem))
5071 {
5072 summary[1] = 'N';
5073 }
5074 else if (EQ (tem, Qeven))
5075 {
5076 summary[1] = 'E';
5077 attr.c_cflag |= PARENB;
5078 attr.c_iflag |= (IGNPAR | INPCK);
5079 }
5080 else if (EQ (tem, Qodd))
5081 {
5082 summary[1] = 'O';
5083 attr.c_cflag |= (PARENB | PARODD);
5084 attr.c_iflag |= (IGNPAR | INPCK);
5085 }
5086 #else
5087 /* Don't error on no parity, which should be set by cfmakeraw. */
5088 if (!NILP (tem))
5089 error ("Parity cannot be configured");
5090 #endif
5091 childp2 = Fplist_put (childp2, QCparity, tem);
5092
5093 /* Configure stopbits. */
5094 if (!NILP (Fplist_member (contact, QCstopbits)))
5095 tem = Fplist_get (contact, QCstopbits);
5096 else
5097 tem = Fplist_get (p->childp, QCstopbits);
5098 if (NILP (tem))
5099 tem = make_number (1);
5100 CHECK_NUMBER (tem);
5101 if (XINT (tem) != 1 && XINT (tem) != 2)
5102 error (":stopbits must be nil (1 stopbit), 1, or 2");
5103 summary[2] = XINT (tem) + '0';
5104 #if defined (CSTOPB)
5105 attr.c_cflag &= ~CSTOPB;
5106 if (XINT (tem) == 2)
5107 attr.c_cflag |= CSTOPB;
5108 #else
5109 /* Don't error on 1 stopbit, which should be set by cfmakeraw. */
5110 if (XINT (tem) != 1)
5111 error ("Stopbits cannot be configured");
5112 #endif
5113 childp2 = Fplist_put (childp2, QCstopbits, tem);
5114
5115 /* Configure flowcontrol. */
5116 if (!NILP (Fplist_member (contact, QCflowcontrol)))
5117 tem = Fplist_get (contact, QCflowcontrol);
5118 else
5119 tem = Fplist_get (p->childp, QCflowcontrol);
5120 if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
5121 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
5122 #if defined (CRTSCTS)
5123 attr.c_cflag &= ~CRTSCTS;
5124 #endif
5125 #if defined (CNEW_RTSCTS)
5126 attr.c_cflag &= ~CNEW_RTSCTS;
5127 #endif
5128 #if defined (IXON) && defined (IXOFF)
5129 attr.c_iflag &= ~(IXON | IXOFF);
5130 #endif
5131 if (NILP (tem))
5132 {
5133 /* Already configured. */
5134 }
5135 else if (EQ (tem, Qhw))
5136 {
5137 #if defined (CRTSCTS)
5138 attr.c_cflag |= CRTSCTS;
5139 #elif defined (CNEW_RTSCTS)
5140 attr.c_cflag |= CNEW_RTSCTS;
5141 #else
5142 error ("Hardware flowcontrol (RTS/CTS) not supported");
5143 #endif
5144 }
5145 else if (EQ (tem, Qsw))
5146 {
5147 #if defined (IXON) && defined (IXOFF)
5148 attr.c_iflag |= (IXON | IXOFF);
5149 #else
5150 error ("Software flowcontrol (XON/XOFF) not supported");
5151 #endif
5152 }
5153 childp2 = Fplist_put (childp2, QCflowcontrol, tem);
5154
5155 /* Activate configuration. */
5156 err = tcsetattr (p->outfd, TCSANOW, &attr);
5157 if (err != 0)
5158 error ("tcsetattr() failed: %s", emacs_strerror (errno));
5159
5160 childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
5161 p->childp = childp2;
5162
5163 }
5164 #endif /* TERMIOS */
5165
5166 /* arch-tag: edb43589-4e09-4544-b325-978b5b121dcf
5167 (do not change this comment) */