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