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