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