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