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