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