src/sysdep.c

   1 /* Interfaces to system-dependent kernel and library entries.
   2    Copyright (C) 1985, 86,87,88,93,94,95,1999,2000,01,2003
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <signal.h>
  27 #include <setjmp.h>
  28 #ifdef HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31 #include "lisp.h"
  32 /* Including stdlib.h isn't necessarily enough to get srandom
  33    declared, e.g. without __USE_XOPEN_EXTENDED with glibc 2.  */
  34 #ifdef HAVE_RANDOM
  35 #if 0 /* It turns out that defining _OSF_SOURCE in osf5-0.h gets
  36          random prototyped as returning `int'.  It looks to me as
  37          though the best way to DTRT is to prefer the rand48 functions
  38          (per libc.info).  -- fx */
  39 extern long int random P_ ((void));
  40 #endif
  41 #if 0 /* Don't prototype srandom; it takes an unsigned argument on
  42          some systems, and an unsigned long on others, like FreeBSD
  43          4.1.  */
  44 extern void srandom P_ ((unsigned int));
  45 #endif
  46 #endif
  47
  48 #include "blockinput.h"
  49 #undef NULL
  50
  51 #ifdef MAC_OS8
  52 /* It is essential to include stdlib.h so that this file picks up
  53    the correct definitions of rand, srand, and RAND_MAX.
  54    Otherwise random numbers will not work correctly.  */
  55 #include <stdlib.h>
  56
  57 #ifndef subprocesses
  58 /* Nonzero means delete a process right away if it exits (process.c).  */
  59 static int delete_exited_processes;
  60 #endif
  61 #endif  /* MAC_OS8 */
  62
  63 #ifdef WINDOWSNT
  64 #define read sys_read
  65 #define write sys_write
  66 #include <windows.h>
  67 #ifndef NULL
  68 #define NULL 0
  69 #endif
  70 #endif /* not WINDOWSNT */
  71
  72 #ifdef HAVE_CARBON
  73 #define read sys_read
  74 #endif
  75
  76 /* Does anyone other than VMS need this? */
  77 #ifndef fwrite
  78 #define sys_fwrite fwrite
  79 #else
  80 #undef fwrite
  81 #endif
  82
  83 #include <stdio.h>
  84 #include <sys/types.h>
  85 #include <sys/stat.h>
  86 #include <errno.h>
  87
  88 #ifdef HAVE_SETPGID
  89 #if !defined (USG) || defined (BSD_PGRPS)
  90 #undef setpgrp
  91 #define setpgrp setpgid
  92 #endif
  93 #endif
  94
  95 /* Get SI_SRPC_DOMAIN, if it is available.  */
  96 #ifdef HAVE_SYS_SYSTEMINFO_H
  97 #include <sys/systeminfo.h>
  98 #endif
  99
 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>
 105
 106 #if __DJGPP__ > 1
 107 extern int etext;
 108 extern unsigned start __asm__ ("start");
 109 #endif
 110 #endif
 111
 112 #ifndef USE_CRT_DLL
 113 #ifndef errno
 114 extern int errno;
 115 #endif
 116 #endif
 117
 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
 138 #define MAXIOSIZE (32 * PAGESIZE) /* Don't I/O more than 32 blocks at a time */
 139 #endif /* VMS */
 140
 141 #ifndef VMS
 142 #include <sys/file.h>
 143 #endif /* not VMS */
 144
 145 #ifdef HAVE_FCNTL_H
 146 #include <fcntl.h>
 147 #endif
 148
 149 #ifndef MSDOS
 150 #include <sys/ioctl.h>
 151 #endif
 152
 153 #include "systty.h"
 154 #include "syswait.h"
 155
 156 #ifdef BROKEN_TIOCGWINSZ
 157 #undef TIOCGWINSZ
 158 #undef TIOCSWINSZ
 159 #endif
 160
 161 #if defined (USG) || defined (DGUX)
 162 #include <sys/utsname.h>
 163 #ifndef MEMORY_IN_STRING_H
 164 #include <memory.h>
 165 #endif
 166 #if defined (TIOCGWINSZ) || defined (ISC4_0)
 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
 174 #endif /* TIOCGWINSZ or ISC4_0 */
 175 #endif /* USG or DGUX */
 176
 177 extern int quit_char;
 178
 179 #include "keyboard.h"
 180 #include "frame.h"
 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
 188 #ifdef WINDOWSNT
 189 #include <direct.h>
 190 /* In process.h which conflicts with the local copy.  */
 191 #define _P_WAIT 0
 192 int _CRTAPI1 _spawnlp (int, const char *, const char *, ...);
 193 int _CRTAPI1 _getpid (void);
 194 #endif
 195
 196 #ifdef NONSYSTEM_DIR_LIBRARY
 197 #include "ndir.h"
 198 #endif /* NONSYSTEM_DIR_LIBRARY */
 199
 200 #include "syssignal.h"
 201 #include "systime.h"
 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.  */
 210 struct utimbuf {
 211   long actime;
 212   long modtime;
 213 };
 214 #endif
 215 #endif
 216
 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
 226 static 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
 236 #ifdef HAVE_SPEED_T
 237 #include <termios.h>
 238 #else
 239 #if defined (HAVE_LIBNCURSES) && ! defined (NCURSES_OSPEED_T)
 240 #else
 241 #if defined (HAVE_TERMIOS_H) && defined (GNU_LINUX)
 242 #include <termios.h>
 243 #endif
 244 #endif
 245 #endif
 246
 247 int emacs_ospeed;
 248
 249 /* The file descriptor for Emacs's input terminal.
 250    Under Unix, this is normally zero except when using X;
 251    under VMS, we place the input channel number here.  */
 252 int input_fd;
 253
 254 void croak P_ ((char *));
 255
 256 #ifdef AIXHFT
 257 void hft_init ();
 258 void hft_reset ();
 259 #endif
 260
 261 /* Temporary used by `sigblock' when defined in terms of signprocmask.  */
 262
 263 SIGMASKTYPE sigprocmask_set;
 264
 265 \f
 266 /* Specify a different file descriptor for further input operations.  */
 267
 268 void
 269 change_input_fd (fd)
 270      int fd;
 271 {
 272   input_fd = fd;
 273 }
 274
 275 /* Discard pending input on descriptor input_fd.  */
 276
 277 void
 278 discard_tty_input ()
 279 {
 280 #ifndef WINDOWSNT
 281   struct emacs_tty buf;
 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 ();
 293   SYS$QIOW (0, input_fd, IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
 294             &buf.main, 0, 0, terminator_mask, 0, 0);
 295   queue_kbd_input ();
 296 #else /* not VMS */
 297 #ifdef APOLLO
 298   {
 299     int zero = 0;
 300     ioctl (input_fd, TIOCFLUSH, &zero);
 301   }
 302 #else /* not Apollo */
 303 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
 304   while (dos_keyread () != -1)
 305     ;
 306 #else /* not MSDOS */
 307   EMACS_GET_TTY (input_fd, &buf);
 308   EMACS_SET_TTY (input_fd, &buf, 0);
 309 #endif /* not MSDOS */
 310 #endif /* not Apollo */
 311 #endif /* not VMS */
 312 #endif /* not WINDOWSNT */
 313 }
 314
 315 #ifdef SIGTSTP
 316
 317 /* Arrange for character C to be read as the next input from
 318    the terminal.  */
 319
 320 void
 321 #ifdef PROTOTYPES
 322 stuff_char (char c)
 323 #else
 324 stuff_char (c)
 325      char c;
 326 #endif
 327 {
 328   if (read_socket_hook)
 329     return;
 330
 331 /* Should perhaps error if in batch mode */
 332 #ifdef TIOCSTI
 333   ioctl (input_fd, TIOCSTI, &c);
 334 #else /* no TIOCSTI */
 335   error ("Cannot stuff terminal input characters in this version of Unix");
 336 #endif /* no TIOCSTI */
 337 }
 338
 339 #endif /* SIGTSTP */
 340 \f
 341 void
 342 init_baud_rate ()
 343 {
 344   if (noninteractive)
 345     emacs_ospeed = 0;
 346   else
 347     {
 348 #ifdef INIT_BAUD_RATE
 349       INIT_BAUD_RATE ();
 350 #else
 351 #ifdef DOS_NT
 352     emacs_ospeed = 15;
 353 #else  /* not DOS_NT */
 354 #ifdef VMS
 355       struct sensemode sg;
 356
 357       SYS$QIOW (0, input_fd, IO$_SENSEMODE, &sg, 0, 0,
 358                 &sg.class, 12, 0, 0, 0, 0 );
 359       emacs_ospeed = sg.xmit_baud;
 360 #else /* not VMS */
 361 #ifdef HAVE_TERMIOS
 362       struct termios sg;
 363
 364       sg.c_cflag = B9600;
 365       tcgetattr (input_fd, &sg);
 366       emacs_ospeed = cfgetospeed (&sg);
 367 #if defined (USE_GETOBAUD) && defined (getobaud)
 368       /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
 369       if (emacs_ospeed == 0)
 370         emacs_ospeed = getobaud (sg.c_cflag);
 371 #endif
 372 #else /* neither VMS nor TERMIOS */
 373 #ifdef HAVE_TERMIO
 374       struct termio sg;
 375
 376       sg.c_cflag = B9600;
 377 #ifdef HAVE_TCATTR
 378       tcgetattr (input_fd, &sg);
 379 #else
 380       ioctl (input_fd, TCGETA, &sg);
 381 #endif
 382       emacs_ospeed = sg.c_cflag & CBAUD;
 383 #else /* neither VMS nor TERMIOS nor TERMIO */
 384       struct sgttyb sg;
 385
 386       sg.sg_ospeed = B9600;
 387       if (ioctl (input_fd, TIOCGETP, &sg) < 0)
 388         abort ();
 389       emacs_ospeed = sg.sg_ospeed;
 390 #endif /* not HAVE_TERMIO */
 391 #endif /* not HAVE_TERMIOS */
 392 #endif /* not VMS */
 393 #endif /* not DOS_NT */
 394 #endif /* not INIT_BAUD_RATE */
 395     }
 396
 397   baud_rate = (emacs_ospeed < sizeof baud_convert / sizeof baud_convert[0]
 398                ? baud_convert[emacs_ospeed] : 9600);
 399   if (baud_rate == 0)
 400     baud_rate = 1200;
 401 }
 402
 403 /*ARGSUSED*/
 404 void
 405 set_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 }
 413 \f
 414 #ifndef subprocesses
 415
 416 wait_without_blocking ()
 417 {
 418 #ifdef BSD_SYSTEM
 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
 428 int wait_debugging;   /* Set nonzero to make following function work under dbx
 429                          (at least for bsd).  */
 430
 431 SIGTYPE
 432 wait_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
 438 void
 439 wait_for_termination (pid)
 440      int pid;
 441 {
 442   while (1)
 443     {
 444 #ifdef subprocesses
 445 #ifdef VMS
 446       int status;
 447
 448       status = SYS$FORCEX (&pid, 0, 0);
 449       break;
 450 #else /* not VMS */
 451 #if defined (BSD_SYSTEM) || (defined (HPUX) && !defined (HPUX_5))
 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))
 461         {
 462           sigsetmask (SIGEMPTYMASK);
 463           kill (getpid (), SIGCHLD);
 464           break;
 465         }
 466       if (wait_debugging)
 467         sleep (1);
 468       else
 469         sigpause (SIGEMPTYMASK);
 470 #else /* not BSD_SYSTEM, and not HPUX version >= 6 */
 471 #if defined (UNIPLUS)
 472       if (0 > kill (pid, 0))
 473         break;
 474       wait (0);
 475 #else /* neither BSD_SYSTEM nor UNIPLUS: random sysV */
 476 #ifdef POSIX_SIGNALS    /* would this work for GNU/Linux as well? */
 477       sigblock (sigmask (SIGCHLD));
 478       errno = 0;
 479       if (kill (pid, 0) == -1 && errno == ESRCH)
 480         {
 481           sigunblock (sigmask (SIGCHLD));
 482           break;
 483         }
 484
 485       sigsuspend (&empty_mask);
 486 #else /* not POSIX_SIGNALS */
 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 */
 496 #ifdef WINDOWSNT
 497       wait (0);
 498       break;
 499 #else /* not WINDOWSNT */
 500       if (0 > kill (pid, 0))
 501         break;
 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);
 506 #endif /* not WINDOWSNT */
 507 #endif /* not HAVE_SYSV_SIGPAUSE */
 508 #endif /* not POSIX_SIGNALS */
 509 #endif /* not UNIPLUS */
 510 #endif /* not BSD_SYSTEM, and not HPUX version >= 6 */
 511 #endif /* not VMS */
 512 #else /* not subprocesses */
 513 #if __DJGPP__ > 1
 514       break;
 515 #else /* not __DJGPP__ > 1 */
 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 */
 526 #endif /* not __DJGPP__ > 1*/
 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  */
 537
 538 void
 539 flush_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 }
 559 \f
 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
 566 void
 567 child_setup_tty (out)
 568      int out;
 569 {
 570 #ifndef DOS_NT
 571   struct emacs_tty s;
 572
 573   EMACS_GET_TTY (out, &s);
 574
 575 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
 576   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
 577   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 578 #ifdef NLDLY
 579   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
 580                                 /* No output delays */
 581 #endif
 582   s.main.c_lflag &= ~ECHO;      /* Disable echo */
 583   s.main.c_lflag |= ISIG;       /* Enable signals */
 584 #if 0  /* This causes bugs in (for instance) telnet to certain sites.  */
 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
 590 #endif
 591 #ifdef IUCLC
 592   s.main.c_iflag &= ~IUCLC;     /* Disable downcasing on input.  */
 593 #endif
 594 #ifdef ISTRIP
 595   s.main.c_iflag &= ~ISTRIP;    /* don't strip 8th bit on input */
 596 #endif
 597 #ifdef OLCUC
 598   s.main.c_oflag &= ~OLCUC;     /* Disable upcasing on output.  */
 599 #endif
 600   s.main.c_oflag &= ~TAB3;      /* Disable tab expansion */
 601   s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
 602 #if 0
 603   /* Said to be unnecessary:  */
 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 */
 610   s.main.c_cc[VERASE] = CDISABLE;       /* disable erase processing */
 611   s.main.c_cc[VKILL] = CDISABLE;        /* disable kill processing */
 612
 613 #ifdef HPUX
 614   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 615 #endif /* HPUX */
 616
 617 #ifdef AIX
 618 /* AIX enhanced edit loses NULs, so disable it */
 619 #ifndef IBMR2AIX
 620   s.main.c_line = 0;
 621   s.main.c_iflag &= ~ASCEDIT;
 622 #endif
 623   /* Also, PTY overloads NUL and BREAK.
 624      don't ignore break, but don't signal either, so it looks like NUL.  */
 625   s.main.c_iflag &= ~IGNBRK;
 626   s.main.c_iflag &= ~BRKINT;
 627   /* QUIT and INTR work better as signals, so disable character forms */
 628   s.main.c_cc[VINTR] = 0377;
 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;
 640   s.main.c_lflag &= ~ISIG;
 641 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 642   s.main.c_cc[VEOL] = 0377;
 643   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 644 #endif /* AIX */
 645
 646 #else /* not HAVE_TERMIO */
 647
 648   s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
 649                        | CBREAK | TANDEM);
 650   s.main.sg_flags |= LPASS8;
 651   s.main.sg_erase = 0377;
 652   s.main.sg_kill = 0377;
 653   s.lmode = LLITOUT | s.lmode;        /* Don't strip 8th bit */
 654
 655 #endif /* not HAVE_TERMIO */
 656
 657   EMACS_SET_TTY (out, &s, 0);
 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 */
 669 #endif /* not DOS_NT */
 670 }
 671 #endif /* not VMS */
 672
 673 #endif /* subprocesses */
 674 \f
 675 /* Record a signal code and the handler for it.  */
 676 struct save_signal
 677 {
 678   int code;
 679   SIGTYPE (*handler) P_ ((int));
 680 };
 681
 682 static void save_signal_handlers P_ ((struct save_signal *));
 683 static void restore_signal_handlers P_ ((struct save_signal *));
 684
 685 /* Suspend the Emacs process; give terminal to its superior.  */
 686
 687 void
 688 sys_suspend ()
 689 {
 690 #ifdef VMS
 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
 709   xfree (fpid_string);          /* On VMS, this was malloc'd */
 710
 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 */
 726       LIB$SPAWN (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, &d_prompt, 0);
 727       return 1;
 728     }
 729   return -1;
 730 #else
 731 #if defined (SIGTSTP) && !defined (MSDOS)
 732
 733   {
 734     int pgrp = EMACS_GETPGRP (0);
 735     EMACS_KILLPG (pgrp, SIGTSTP);
 736   }
 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.  */
 748   sys_subshell ();
 749
 750 #endif /* no USG_JOBCTRL */
 751 #endif /* no SIGTSTP */
 752 #endif /* not VMS */
 753 }
 754
 755 /* Fork a subshell.  */
 756
 757 #ifndef MAC_OS8
 758 void
 759 sys_subshell ()
 760 {
 761 #ifndef VMS
 762 #ifdef DOS_NT   /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 763   int st;
 764   char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS.  */
 765 #endif
 766   int pid;
 767   struct save_signal saved_handlers[5];
 768   Lisp_Object dir;
 769   unsigned char *str = 0;
 770   int len;
 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
 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");
 786   if (NILP (Fboundp (dir)))
 787     goto xyzzy;
 788   dir = Fsymbol_value (dir);
 789   if (!STRINGP (dir))
 790     goto xyzzy;
 791
 792   dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
 793   str = (unsigned char *) alloca (SCHARS (dir) + 2);
 794   len = SCHARS (dir);
 795   bcopy (SDATA (dir), str, len);
 796   if (str[len - 1] != '/') str[len++] = '/';
 797   str[len] = 0;
 798  xyzzy:
 799
 800 #ifdef DOS_NT
 801   pid = 0;
 802 #if __DJGPP__ > 1
 803   save_signal_handlers (saved_handlers);
 804   synch_process_alive = 1;
 805 #endif /* __DJGPP__ > 1 */
 806 #else
 807   pid = vfork ();
 808   if (pid == -1)
 809     error ("Can't spawn subshell");
 810 #endif
 811
 812   if (pid == 0)
 813     {
 814       char *sh = 0;
 815
 816 #ifdef DOS_NT    /* MW, Aug 1993 */
 817       getwd (oldwd);
 818       if (sh == 0)
 819         sh = (char *) egetenv ("SUSPEND");      /* KFS, 1994-12-14 */
 820 #endif
 821       if (sh == 0)
 822         sh = (char *) egetenv ("SHELL");
 823       if (sh == 0)
 824         sh = "sh";
 825
 826       /* Use our buffer's default directory for the subshell.  */
 827       if (str)
 828         chdir ((char *) str);
 829
 830 #ifdef subprocesses
 831       close_process_descs ();   /* Close Emacs's pipes/ptys */
 832 #endif
 833
 834 #ifdef SET_EMACS_PRIORITY
 835       {
 836         extern EMACS_INT emacs_priority;
 837
 838         if (emacs_priority < 0)
 839           nice (-emacs_priority);
 840       }
 841 #endif
 842
 843 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 844       {
 845         char *epwd = getenv ("PWD");
 846         char old_pwd[MAXPATHLEN+1+4];
 847
 848         /* If PWD is set, pass it with corrected value.  */
 849         if (epwd)
 850           {
 851             strcpy (old_pwd, epwd);
 852             if (str[len - 1] == '/')
 853               str[len - 1] = '\0';
 854             setenv ("PWD", str, 1);
 855           }
 856         st = system (sh);
 857         chdir (oldwd);
 858         if (epwd)
 859           putenv (old_pwd);     /* restore previous value */
 860       }
 861 #if 0   /* This is also reported if last command executed in subshell failed, KFS */
 862       if (st)
 863         report_file_error ("Can't execute subshell", Fcons (build_string (sh), Qnil));
 864 #endif
 865 #else /* not MSDOS */
 866 #ifdef  WINDOWSNT
 867       /* Waits for process completion */
 868       pid = _spawnlp (_P_WAIT, sh, sh, NULL);
 869       chdir (oldwd);
 870       if (pid == -1)
 871         write (1, "Can't execute subshell", 22);
 872 #else   /* not WINDOWSNT */
 873       execlp (sh, sh, 0);
 874       write (1, "Can't execute subshell", 22);
 875       _exit (1);
 876 #endif  /* not WINDOWSNT */
 877 #endif /* not MSDOS */
 878     }
 879
 880   /* Do this now if we did not do it before.  */
 881 #if !defined (MSDOS) || __DJGPP__ == 1
 882   save_signal_handlers (saved_handlers);
 883   synch_process_alive = 1;
 884 #endif
 885
 886 #ifndef DOS_NT
 887   wait_for_termination (pid);
 888 #endif
 889   restore_signal_handlers (saved_handlers);
 890   synch_process_alive = 0;
 891 #endif /* !VMS */
 892 }
 893 #endif /* !MAC_OS8 */
 894
 895 static void
 896 save_signal_handlers (saved_handlers)
 897      struct save_signal *saved_handlers;
 898 {
 899   while (saved_handlers->code)
 900     {
 901       saved_handlers->handler
 902         = (SIGTYPE (*) P_ ((int))) signal (saved_handlers->code, SIG_IGN);
 903       saved_handlers++;
 904     }
 905 }
 906
 907 static void
 908 restore_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
 920 int old_fcntl_flags;
 921
 922 void
 923 init_sigio (fd)
 924      int fd;
 925 {
 926 #ifdef FASYNC
 927   old_fcntl_flags = fcntl (fd, F_GETFL, 0) & ~FASYNC;
 928   fcntl (fd, F_SETFL, old_fcntl_flags | FASYNC);
 929 #endif
 930   interrupts_deferred = 0;
 931 }
 932
 933 void
 934 reset_sigio ()
 935 {
 936   unrequest_sigio ();
 937 }
 938
 939 #ifdef FASYNC           /* F_SETFL does not imply existence of FASYNC */
 940
 941 void
 942 request_sigio ()
 943 {
 944   if (read_socket_hook)
 945     return;
 946
 947 #ifdef SIGWINCH
 948   sigunblock (sigmask (SIGWINCH));
 949 #endif
 950   fcntl (input_fd, F_SETFL, old_fcntl_flags | FASYNC);
 951
 952   interrupts_deferred = 0;
 953 }
 954
 955 void
 956 unrequest_sigio ()
 957 {
 958   if (read_socket_hook)
 959     return;
 960
 961 #ifdef SIGWINCH
 962   sigblock (sigmask (SIGWINCH));
 963 #endif
 964   fcntl (input_fd, F_SETFL, old_fcntl_flags);
 965   interrupts_deferred = 1;
 966 }
 967
 968 #else /* no FASYNC */
 969 #ifdef STRIDE           /* Stride doesn't have FASYNC - use FIOASYNC */
 970
 971 void
 972 request_sigio ()
 973 {
 974   int on = 1;
 975
 976   if (read_socket_hook)
 977     return;
 978
 979   ioctl (input_fd, FIOASYNC, &on);
 980   interrupts_deferred = 0;
 981 }
 982
 983 void
 984 unrequest_sigio ()
 985 {
 986   int off = 0;
 987
 988   if (read_socket_hook)
 989     return;
 990
 991   ioctl (input_fd, FIOASYNC, &off);
 992   interrupts_deferred = 1;
 993 }
 994
 995 #else /* not FASYNC, not STRIDE */
 996
 997 #ifdef _CX_UX
 998
 999 #include <termios.h>
1000
1001 void
1002 request_sigio ()
1003 {
1004   int on = 1;
1005   sigset_t st;
1006
1007   if (read_socket_hook)
1008     return;
1009
1010   sigemptyset (&st);
1011   sigaddset (&st, SIGIO);
1012   ioctl (input_fd, FIOASYNC, &on);
1013   interrupts_deferred = 0;
1014   sigprocmask (SIG_UNBLOCK, &st, (sigset_t *)0);
1015 }
1016
1017 void
1018 unrequest_sigio ()
1019 {
1020   int off = 0;
1021
1022   if (read_socket_hook)
1023     return;
1024
1025   ioctl (input_fd, FIOASYNC, &off);
1026   interrupts_deferred = 1;
1027 }
1028
1029 #else /* ! _CX_UX */
1030 #ifndef MSDOS
1031
1032 void
1033 request_sigio ()
1034 {
1035   if (read_socket_hook)
1036     return;
1037
1038   croak ("request_sigio");
1039 }
1040
1041 void
1042 unrequest_sigio ()
1043 {
1044   if (read_socket_hook)
1045     return;
1046
1047   croak ("unrequest_sigio");
1048 }
1049
1050 #endif /* MSDOS */
1051 #endif /* _CX_UX */
1052 #endif /* STRIDE */
1053 #endif /* FASYNC */
1054 #endif /* F_SETFL */
1055 \f
1056 /* Saving and restoring the process group of Emacs's terminal.  */
1057
1058 #ifdef BSD_PGRPS
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.  */
1078 int 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.  */
1084 void
1085 narrow_foreground_group ()
1086 {
1087   int me = getpid ();
1088
1089   setpgrp (0, inherited_pgroup);
1090   if (inherited_pgroup != me)
1091     EMACS_SET_TTY_PGRP (input_fd, &me);
1092   setpgrp (0, me);
1093 }
1094
1095 /* Set the tty to our original foreground group.  */
1096 void
1097 widen_foreground_group ()
1098 {
1099   if (inherited_pgroup != getpid ())
1100     EMACS_SET_TTY_PGRP (input_fd, &inherited_pgroup);
1101   setpgrp (0, inherited_pgroup);
1102 }
1103
1104 #endif /* BSD_PGRPS */
1105 \f
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.  */
1111 int
1112 emacs_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.  */
1119   bzero (&settings->main, sizeof (settings->main));
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
1138 #ifndef DOS_NT
1139   /* I give up - I hope you have the BSD ioctls.  */
1140   if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1141     return -1;
1142 #endif /* not DOS_NT */
1143 #endif
1144 #endif
1145 #endif
1146
1147   /* Suivant - Do we have to get struct ltchars data?  */
1148 #ifdef HAVE_LTCHARS
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?  */
1154 #ifdef HAVE_TCHARS
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
1166    *SETTINGS.  If FLUSHP is non-zero, we discard input.
1167    Return 0 if all went well, and -1 if anything failed.  */
1168
1169 int
1170 emacs_set_tty (fd, settings, flushp)
1171      int fd;
1172      struct emacs_tty *settings;
1173      int flushp;
1174 {
1175   /* Set the primary parameters - baud rate, character size, etcetera.  */
1176 #ifdef HAVE_TCATTR
1177   int i;
1178   /* We have those nifty POSIX tcmumbleattr functions.
1179      William J. Smith <wjs@wiis.wang.com> writes:
1180      "POSIX 1003.1 defines tcsetattr to return success if it was
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."  */
1185   /* This make sure that we don't loop indefinitely in here.  */
1186   for (i = 0 ; i < 10 ; i++)
1187     if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1188       {
1189         if (errno == EINTR)
1190           continue;
1191         else
1192           return -1;
1193       }
1194     else
1195       {
1196         struct termios new;
1197
1198         bzero (&new, sizeof (new));
1199         /* Get the current settings, and see if they're what we asked for.  */
1200         tcgetattr (fd, &new);
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
1209             && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
1210           break;
1211         else
1212           continue;
1213       }
1214
1215 #else
1216 #ifdef HAVE_TERMIO
1217   /* The SYSV-style interface?  */
1218   if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
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
1230 #ifndef DOS_NT
1231   /* I give up - I hope you have the BSD ioctls.  */
1232   if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1233     return -1;
1234 #endif /* not DOS_NT */
1235
1236 #endif
1237 #endif
1238 #endif
1239
1240   /* Suivant - Do we have to get struct ltchars data?  */
1241 #ifdef HAVE_LTCHARS
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?  */
1247 #ifdef HAVE_TCHARS
1248   if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1249       || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1250     return -1;
1251 #endif
1252
1253   /* We have survived the tempest.  */
1254   return 0;
1255 }
1256
1257 \f
1258 /* The initial tty mode bits */
1259 struct emacs_tty old_tty;
1260
1261 /* 1 if we have been through init_sys_modes.  */
1262 int term_initted;
1263
1264 /* 1 if outer tty status has been recorded.  */
1265 int old_tty_valid;
1266
1267 #ifdef BSD4_1
1268 /* BSD 4.1 needs to keep track of the lmode bits in order to start
1269    sigio.  */
1270 int lmode;
1271 #endif
1272
1273 #ifndef F_SETOWN_BUG
1274 #ifdef F_SETOWN
1275 int old_fcntl_owner;
1276 #endif /* F_SETOWN */
1277 #endif /* F_SETOWN_BUG */
1278
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
1283 #ifdef nec_ews_svr4
1284 extern char *_sobuf ;
1285 #else
1286 #if defined (USG) || defined (DGUX)
1287 unsigned char _sobuf[BUFSIZ+8];
1288 #else
1289 char _sobuf[BUFSIZ];
1290 #endif
1291 #endif
1292
1293 #ifdef HAVE_LTCHARS
1294 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1295 #endif
1296 #ifdef HAVE_TCHARS
1297 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1298 #endif
1299
1300 void
1301 init_sys_modes ()
1302 {
1303   struct emacs_tty tty;
1304
1305 #ifdef MAC_OS8
1306 /* cus-start.el complains if delete-exited-processes is not defined */
1307 #ifndef subprocesses
1308   DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
1309                doc: /* *Non-nil means delete processes immediately when they exit.
1310 nil means don't delete them until `list-processes' is run.  */);
1311   delete_exited_processes = 0;
1312 #endif
1313 #endif /* MAC_OS8 */
1314
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
1322   Vtty_erase_char = Qnil;
1323
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);
1337 #if 0
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.");
1345 #endif
1346   if (input_ef / 32 != timer_ef / 32)
1347     croak ("Input and timer event flags in different clusters.");
1348 #if 0
1349   input_eflist = ((unsigned) 1 << (input_ef % 32)) |
1350     ((unsigned) 1 << (process_ef % 32));
1351 #endif
1352   timer_eflist = ((unsigned) 1 << (input_ef % 32)) |
1353     ((unsigned) 1 << (timer_ef % 32));
1354 #ifndef VMS4_4
1355   sys_access_reinit ();
1356 #endif
1357 #endif /* not VMS */
1358
1359 #ifdef BSD_PGRPS
1360   if (! read_socket_hook && EQ (Vwindow_system, Qnil))
1361     narrow_foreground_group ();
1362 #endif
1363
1364 #ifdef HAVE_WINDOW_SYSTEM
1365   /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
1366      needs the initialization code below.  */
1367   if (!read_socket_hook && EQ (Vwindow_system, Qnil))
1368 #endif
1369     {
1370       EMACS_GET_TTY (input_fd, &old_tty);
1371
1372       old_tty_valid = 1;
1373
1374       tty = old_tty;
1375
1376 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1377       XSETINT (Vtty_erase_char, old_tty.main.c_cc[VERASE]);
1378
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
1383       tty.main.c_iflag |= (IGNBRK);     /* Ignore break condition */
1384       tty.main.c_iflag &= ~ICRNL;       /* Disable map of CR to NL on input */
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
1389 #ifdef ISTRIP
1390       tty.main.c_iflag &= ~ISTRIP;      /* don't strip 8th bit on input */
1391 #endif
1392       tty.main.c_lflag &= ~ECHO;        /* Disable echo */
1393       tty.main.c_lflag &= ~ICANON;      /* Disable erase/kill processing */
1394 #ifdef IEXTEN
1395       tty.main.c_lflag &= ~IEXTEN;      /* Disable other editing characters.  */
1396 #endif
1397       tty.main.c_lflag |= ISIG; /* Enable signals */
1398       if (flow_control)
1399         {
1400           tty.main.c_iflag |= IXON;     /* Enable start/stop output control */
1401 #ifdef IXANY
1402           tty.main.c_iflag &= ~IXANY;
1403 #endif /* IXANY */
1404         }
1405       else
1406         tty.main.c_iflag &= ~IXON;      /* Disable start/stop output control */
1407       tty.main.c_oflag &= ~ONLCR;       /* Disable map of NL to CR-NL
1408                                            on output */
1409       tty.main.c_oflag &= ~TAB3;        /* Disable tab expansion */
1410 #ifdef CS8
1411       if (meta_key)
1412         {
1413           tty.main.c_cflag |= CS8;      /* allow 8th bit on input */
1414           tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1415         }
1416 #endif
1417       tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
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.  */
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.  */
1424 #ifdef VSWTCH
1425       tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
1426                                            of C-z */
1427 #endif /* VSWTCH */
1428
1429 #if defined (mips) || defined (HAVE_TCATTR)
1430 #ifdef VSUSP
1431       tty.main.c_cc[VSUSP] = CDISABLE;  /* Turn off mips handling of C-z.  */
1432 #endif /* VSUSP */
1433 #ifdef V_DSUSP
1434       tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y.  */
1435 #endif /* V_DSUSP */
1436 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
1437       tty.main.c_cc[VDSUSP] = CDISABLE;
1438 #endif /* VDSUSP */
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 */
1451
1452       if (flow_control)
1453         {
1454 #ifdef VSTART
1455           tty.main.c_cc[VSTART] = '\021';
1456 #endif /* VSTART */
1457 #ifdef VSTOP
1458           tty.main.c_cc[VSTOP] = '\023';
1459 #endif /* VSTOP */
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         }
1470 #endif /* mips or HAVE_TCATTR */
1471
1472 #ifdef SET_LINE_DISCIPLINE
1473       /* Need to explicitly request TERMIODISC line discipline or
1474          Ultrix's termios does not work correctly.  */
1475       tty.main.c_line = SET_LINE_DISCIPLINE;
1476 #endif
1477 #ifdef AIX
1478 #ifndef IBMR2AIX
1479       /* AIX enhanced edit loses NULs, so disable it.  */
1480       tty.main.c_line = 0;
1481       tty.main.c_iflag &= ~ASCEDIT;
1482 #else
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;
1487 #endif /* IBMR2AIX */
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         }
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.  */
1501       tty.main.c_iflag &= ~IGNBRK;
1502       tty.main.c_iflag &= ~BRKINT;
1503 #endif
1504 #else /* if not HAVE_TERMIO */
1505 #ifdef VMS
1506       tty.main.tt_char |= TT$M_NOECHO;
1507       if (meta_key)
1508         tty.main.tt_char |= TT$M_EIGHTBIT;
1509       if (flow_control)
1510         tty.main.tt_char |= TT$M_TTSYNC;
1511       else
1512         tty.main.tt_char &= ~TT$M_TTSYNC;
1513       tty.main.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
1514 #else /* not VMS (BSD, that is) */
1515 #ifndef DOS_NT
1516       XSETINT (Vtty_erase_char, tty.main.sg_erase);
1517       tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1518       if (meta_key)
1519         tty.main.sg_flags |= ANYP;
1520       tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
1521 #endif /* not DOS_NT */
1522 #endif /* not VMS (BSD, that is) */
1523 #endif /* not HAVE_TERMIO */
1524
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
1531 #ifdef HAVE_TCHARS
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
1542       tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | old_tty.lmode;
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
1548
1549 #ifdef BSD4_1
1550       lmode = tty.lmode;
1551 #endif
1552
1553 #endif /* HAVE_TCHARS */
1554 #endif /* not HAVE_TERMIO */
1555
1556 #ifdef HAVE_LTCHARS
1557       tty.ltchars = new_ltchars;
1558 #endif /* HAVE_LTCHARS */
1559 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1560       if (!term_initted)
1561         internal_terminal_init ();
1562       dos_ttraw ();
1563 #endif
1564
1565       EMACS_SET_TTY (input_fd, &tty, 0);
1566
1567       /* This code added to insure that, if flow-control is not to be used,
1568          we have an unlocked terminal at the start. */
1569
1570 #ifdef TCXONC
1571       if (!flow_control) ioctl (input_fd, TCXONC, 1);
1572 #endif
1573 #ifndef APOLLO
1574 #ifdef TIOCSTART
1575       if (!flow_control) ioctl (input_fd, TIOCSTART, 0);
1576 #endif
1577 #endif
1578
1579 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1580 #ifdef TCOON
1581       if (!flow_control) tcflow (input_fd, TCOON);
1582 #endif
1583 #endif
1584
1585 #ifdef AIXHFT
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
1597 #endif /* AIXHFT */
1598
1599 #ifdef VMS
1600 /*  Appears to do nothing when in PASTHRU mode.
1601       SYS$QIOW (0, input_fd, IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
1602                 interrupt_signal, oob_chars, 0, 0, 0, 0);
1603 */
1604       queue_kbd_input (0);
1605 #endif /* VMS */
1606     }
1607
1608 #ifdef F_SETFL
1609 #ifndef F_SETOWN_BUG
1610 #ifdef F_GETOWN         /* F_SETFL does not imply existence of F_GETOWN */
1611   if (interrupt_input
1612       && ! read_socket_hook && EQ (Vwindow_system, Qnil))
1613     {
1614       old_fcntl_owner = fcntl (input_fd, F_GETOWN, 0);
1615       fcntl (input_fd, F_SETOWN, getpid ());
1616       init_sigio (input_fd);
1617     }
1618 #endif /* F_GETOWN */
1619 #endif /* F_SETOWN_BUG */
1620 #endif /* F_SETFL */
1621
1622 #ifdef BSD4_1
1623   if (interrupt_input)
1624     init_sigio (input_fd);
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. */
1634   setvbuf (stdout, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1635 #else
1636   setbuf (stdout, (char *) _sobuf);
1637 #endif
1638 #ifdef HAVE_WINDOW_SYSTEM
1639   /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
1640      needs the initialization code below.  */
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       )
1648 #endif
1649     set_terminal_modes ();
1650
1651   if (!term_initted
1652       && FRAMEP (Vterminal_frame)
1653       && FRAME_TERMCAP_P (XFRAME (Vterminal_frame)))
1654     init_frame_faces (XFRAME (Vterminal_frame));
1655
1656   if (term_initted && no_redraw_on_reenter)
1657     {
1658       if (display_completed)
1659         direct_output_forward_char (0);
1660     }
1661   else
1662     {
1663       frame_garbaged = 1;
1664       if (FRAMEP (Vterminal_frame))
1665         FRAME_GARBAGED_P (XFRAME (Vterminal_frame)) = 1;
1666     }
1667
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.  */
1673
1674 int
1675 tabs_safe_p ()
1676 {
1677   struct emacs_tty tty;
1678
1679   EMACS_GET_TTY (input_fd, &tty);
1680   return EMACS_TTY_TABS_OK (&tty);
1681 }
1682 \f
1683 /* Get terminal size from system.
1684    Store number of lines into *HEIGHTP and width into *WIDTHP.
1685    We store 0 if there's no valid information.  */
1686
1687 void
1688 get_frame_size (widthp, heightp)
1689      int *widthp, *heightp;
1690 {
1691
1692 #ifdef TIOCGWINSZ
1693
1694   /* BSD-style.  */
1695   struct winsize size;
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.  */
1709   struct ttysize size;
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
1720 #ifdef VMS
1721
1722   struct sensemode tty;
1723
1724   SYS$QIOW (0, input_fd, IO$_SENSEMODE, &tty, 0, 0,
1725             &tty.class, 12, 0, 0, 0, 0);
1726   *widthp = tty.scr_wid;
1727   *heightp = tty.scr_len;
1728
1729 #else
1730 #ifdef MSDOS
1731   *widthp = ScreenCols ();
1732   *heightp = ScreenRows ();
1733 #else /* system doesn't know size */
1734   *widthp = 0;
1735   *heightp = 0;
1736 #endif
1737
1738 #endif /* not VMS */
1739 #endif /* not SunOS-style */
1740 #endif /* not BSD-style */
1741 }
1742
1743 /* Set the logical window size associated with descriptor FD
1744    to HEIGHT and WIDTH.  This is used mainly with ptys.  */
1745
1746 int
1747 set_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.  */
1766   struct ttysize size;
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
1780 \f
1781 /* Prepare the terminal for exiting Emacs; move the cursor to the
1782    bottom of the frame, turn off interrupt-driven I/O, etc.  */
1783 void
1784 reset_sys_modes ()
1785 {
1786   struct frame *sf;
1787
1788   if (noninteractive)
1789     {
1790       fflush (stdout);
1791       return;
1792     }
1793   if (!term_initted)
1794     return;
1795 #ifdef HAVE_WINDOW_SYSTEM
1796   /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
1797      needs the clean-up code below.  */
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       )
1805     return;
1806 #endif
1807   sf = SELECTED_FRAME ();
1808   cursor_to (FRAME_LINES (sf) - 1, 0);
1809   clear_end_of_line (FRAME_COLS (sf));
1810   /* clear_end_of_line may move the cursor */
1811   cursor_to (FRAME_LINES (sf) - 1, 0);
1812 #if defined (IBMR2AIX) && defined (AIXHFT)
1813   {
1814     /* HFT devices normally use ^J as a LF/CR.  We forced it to
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);
1825 #ifdef BSD_SYSTEM
1826 #ifndef BSD4_1
1827   /* Avoid possible loss of output when changing terminal modes.  */
1828   fsync (fileno (stdout));
1829 #endif
1830 #endif
1831
1832 #ifdef F_SETFL
1833 #ifndef F_SETOWN_BUG
1834 #ifdef F_SETOWN         /* F_SETFL does not imply existence of F_SETOWN */
1835   if (interrupt_input)
1836     {
1837       reset_sigio ();
1838       fcntl (input_fd, F_SETOWN, old_fcntl_owner);
1839     }
1840 #endif /* F_SETOWN */
1841 #endif /* F_SETOWN_BUG */
1842 #ifdef O_NDELAY
1843   fcntl (input_fd, F_SETFL, fcntl (input_fd, F_GETFL, 0) & ~O_NDELAY);
1844 #endif
1845 #endif /* F_SETFL */
1846 #ifdef BSD4_1
1847   if (interrupt_input)
1848     reset_sigio ();
1849 #endif /* BSD4_1 */
1850
1851   if (old_tty_valid)
1852     while (EMACS_SET_TTY (input_fd, &old_tty, 0) < 0 && errno == EINTR)
1853       ;
1854
1855 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1856   dos_ttcooked ();
1857 #endif
1858
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
1866 #ifdef AIXHFT
1867   hft_reset ();
1868 #endif
1869
1870 #ifdef BSD_PGRPS
1871   widen_foreground_group ();
1872 #endif
1873 }
1874 \f
1875 #ifdef HAVE_PTYS
1876
1877 /* Set up the proper status flags for use of a pty.  */
1878
1879 void
1880 setup_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).
1897
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.
1903
1904      Since the latter lossage is more benign, we may as well
1905      lose that way.  -- cph */
1906 #ifdef FIONBIO
1907 #if defined(SYSV_PTYS) || defined(UNIX98_PTYS)
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
1931 void
1932 init_vms_input ()
1933 {
1934   int status;
1935
1936   if (input_fd == 0)
1937     {
1938       status = SYS$ASSIGN (&input_dsc, &input_fd, 0, 0);
1939       if (! (status & 1))
1940         LIB$STOP (status);
1941     }
1942 }
1943
1944 /* Deassigning the input channel is done before exiting.  */
1945
1946 void
1947 stop_vms_input ()
1948 {
1949   return SYS$DASSGN (input_fd);
1950 }
1951
1952 short input_buffer;
1953
1954 /* Request reading one character into the keyboard buffer.
1955    This is done as soon as the buffer becomes empty.  */
1956
1957 void
1958 queue_kbd_input ()
1959 {
1960   int status;
1961   extern kbd_input_ast ();
1962
1963   waiting_for_ast = 0;
1964   stop_input = 0;
1965   status = SYS$QIO (0, input_fd, IO$_READVBLK,
1966                     &input_iosb, kbd_input_ast, 1,
1967                     &input_buffer, 1, 0, terminator_mask, 0, 0);
1968 }
1969
1970 int input_count;
1971
1972 /* Ast routine that is called when keyboard input comes in
1973    in accord with the SYS$QIO above.  */
1974
1975 void
1976 kbd_input_ast ()
1977 {
1978   register int c = -1;
1979   int old_errno = errno;
1980   extern EMACS_TIME *input_available_clear_time;
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;
2011       EVENT_INIT (e);
2012
2013       e.kind = ASCII_KEYSTROKE_EVENT;
2014       XSETINT (e.code, c);
2015       e.frame_or_window = selected_frame;
2016       kbd_buffer_store_event (&e);
2017     }
2018   if (input_available_clear_time)
2019     EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
2020   errno = old_errno;
2021 }
2022
2023 /* Wait until there is something in kbd_buffer.  */
2024
2025 void
2026 wait_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);
2044       clear_waiting_for_input ();
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++;
2058               prepare_menu_bars ();
2059               redisplay_preserve_echo_area (18);
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
2072 void
2073 end_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     {
2082       SYS$CANCEL (input_fd);
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;
2091   SYS$CANCEL (input_fd);
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
2099 void
2100 input_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
2132 sys_sleep (timeval)
2133      int timeval;
2134 {
2135   int time [2];
2136   static int zero = 0;
2137   static int large = -10000000;
2138
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
2146 void
2147 init_sigio (fd)
2148      int fd;
2149 {
2150   request_sigio ();
2151 }
2152
2153 reset_sigio ()
2154 {
2155   unrequest_sigio ();
2156 }
2157
2158 void
2159 request_sigio ()
2160 {
2161   croak ("request sigio");
2162 }
2163
2164 void
2165 unrequest_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
2193 #if !(defined (__NetBSD__) && defined (__ELF__))
2194 #ifndef HAVE_TEXT_START
2195 char *
2196 start_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 }
2210 #endif /* not HAVE_TEXT_START */
2211 #endif
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
2234  *      at the normal shared text boundary and the startofdata variable
2235  *      will be patched by unexec to the correct value.
2236  *
2237  */
2238
2239 #ifndef start_of_data
2240 char *
2241 start_of_data ()
2242 {
2243 #ifdef DATA_START
2244   return ((char *) DATA_START);
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
2255   return ((char *) &environ);
2256 #else
2257   extern int data_start;
2258   return ((char *) &data_start);
2259 #endif /* ORDINARY_LINK */
2260 #endif /* DATA_START */
2261 }
2262 #endif /* start_of_data */
2263 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2264 \f
2265 /* init_system_name sets up the string for the Lisp function
2266    system-name to return. */
2267
2268 #ifdef BSD4_1
2269 #include <whoami.h>
2270 #endif
2271
2272 extern Lisp_Object Vsystem_name;
2273
2274 #ifndef BSD4_1
2275 #ifndef VMS
2276 #ifdef HAVE_SOCKETS
2277 #include <sys/socket.h>
2278 #include <netdb.h>
2279 #endif /* HAVE_SOCKETS */
2280 #endif /* not VMS */
2281 #endif /* not BSD4_1 */
2282
2283 #ifdef TRY_AGAIN
2284 #ifndef HAVE_H_ERRNO
2285 extern int h_errno;
2286 #endif
2287 #endif /* TRY_AGAIN */
2288
2289 void
2290 init_system_name ()
2291 {
2292 #ifdef BSD4_1
2293   Vsystem_name = build_string (sysname);
2294 #else
2295 #ifdef VMS
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);
2303 #else
2304 #ifndef HAVE_GETHOSTNAME
2305   struct utsname uts;
2306   uname (&uts);
2307   Vsystem_name = build_string (uts.nodename);
2308 #else /* HAVE_GETHOSTNAME */
2309   unsigned int hostname_size = 256;
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     }
2328 #ifdef HAVE_SOCKETS
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. */
2332 #ifndef CANNOT_DUMP
2333   if (initialized)
2334 #endif /* not CANNOT_DUMP */
2335     if (! index (hostname, '.'))
2336       {
2337         struct hostent *hp;
2338         int count;
2339         for (count = 0;; count++)
2340           {
2341 #ifdef TRY_AGAIN
2342             h_errno = 0;
2343 #endif
2344             hp = gethostbyname (hostname);
2345 #ifdef TRY_AGAIN
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;
2356 #if 0
2357             char *p;
2358 #endif
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;
2371 #if 0
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       }
2385 #endif /* HAVE_SOCKETS */
2386   /* We used to try using getdomainname here,
2387      but NIIBE Yutaka <gniibe@etl.go.jp> says that
2388      getdomainname gets the NIS/YP domain which often is not the same
2389      as in Internet domain name.  */
2390 #if 0 /* Turned off because sysinfo is not really likely to return the
2391          correct Internet domain.  */
2392 #if (HAVE_SYSINFO && defined (SI_SRPC_DOMAIN))
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         {
2402           char *domain = (char *) alloca (domain_size + 1);
2403           char *fqdn = (char *) alloca (hostlen + 1 + domain_size + 1);
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             }
2412           strcpy (fqdn, hostname);
2413           if (domain[0] == '.')
2414             strcpy (fqdn + hostlen, domain);
2415           else if (domain[0] != 0)
2416             {
2417               fqdn[hostlen] = '.';
2418               strcpy (fqdn + hostlen + 1, domain);
2419             }
2420           hostname = fqdn;
2421           break;
2422         }
2423     }
2424 #endif /* HAVE_SYSINFO && defined (SI_SRPC_DOMAIN) */
2425 #endif /* 0 */
2426   Vsystem_name = build_string (hostname);
2427 #endif /* HAVE_GETHOSTNAME */
2428 #endif /* VMS */
2429 #endif /* BSD4_1 */
2430   {
2431     unsigned char *p;
2432     for (p = SDATA (Vsystem_name); *p; p++)
2433       if (*p == ' ' || *p == '\t')
2434         *p = '-';
2435   }
2436 }
2437 \f
2438 #ifndef MSDOS
2439 #ifndef VMS
2440 #if !defined (HAVE_SELECT) || defined (BROKEN_SELECT_NON_X)
2441
2442 #include "sysselect.h"
2443 #undef select
2444
2445 #if defined (HAVE_X_WINDOWS) && !defined (HAVE_SELECT)
2446 /* Cause explanatory error message at compile time,
2447    since the select emulation is not good enough for X.  */
2448 int *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
2456 int select_alarmed;
2457
2458 /* For longjmp'ing back to read_input_waiting.  */
2459
2460 jmp_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
2465 int read_alarm_should_throw;
2466
2467 SIGTYPE
2468 select_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
2480 #ifndef WINDOWSNT
2481 /* Only rfds are checked.  */
2482 int
2483 sys_select (nfds, rfds, wfds, efds, timeout)
2484      int nfds;
2485      SELECT_TYPE *rfds, *wfds, *efds;
2486      EMACS_TIME *timeout;
2487 {
2488   int ravail = 0;
2489   SELECT_TYPE orfds;
2490   int timeoutval;
2491   int *local_timeout;
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
2498   unsigned char buf;
2499
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);
2509   if (rfds)
2510     {
2511       orfds = *rfds;
2512       FD_ZERO (rfds);
2513     }
2514   if (wfds)
2515     FD_ZERO (wfds);
2516   if (efds)
2517     FD_ZERO (efds);
2518
2519   /* If we are looking only for the terminal, with no timeout,
2520      just read it and wait -- that's more efficient.  */
2521   if (*local_timeout == 100000 && process_tick == update_tick
2522       && FD_ISSET (0, &orfds))
2523     {
2524       int fd;
2525       for (fd = 1; fd < nfds; ++fd)
2526         if (FD_ISSET (fd, &orfds))
2527           goto hardway;
2528       if (! detect_input_pending ())
2529         read_input_waiting ();
2530       FD_SET (0, rfds);
2531       return 1;
2532     }
2533
2534  hardway:
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.
2538    */
2539   while (1)
2540     {
2541       register int to_check, fd;
2542
2543       if (rfds)
2544         {
2545           for (to_check = nfds, fd = 0; --to_check >= 0; fd++)
2546             {
2547               if (FD_ISSET (fd, &orfds))
2548                 {
2549                   int avail = 0, status = 0;
2550
2551                   if (fd == 0)
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                     {
2572                       FD_SET (fd, rfds);
2573                       ravail++;
2574                     }
2575                 }
2576             }
2577         }
2578       if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
2579         break;
2580
2581       turn_on_atimers (0);
2582       signal (SIGALRM, select_alarm);
2583       select_alarmed = 0;
2584       alarm (SELECT_PAUSE);
2585
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.  */
2593           if (FD_ISSET (0, &orfds))
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;
2603
2604       /* Reset the old alarm if there was one.  */
2605       turn_on_atimers (1);
2606
2607       if (*local_timeout == 0)  /* Stop on timer being cleared */
2608         break;
2609     }
2610   return ravail;
2611 }
2612 #endif /* not WINDOWSNT */
2613
2614 /* Read keyboard input into the standard buffer,
2615    waiting for at least one character.  */
2616
2617 /* Make all keyboard buffers much bigger when using a window system.  */
2618 #ifdef HAVE_WINDOW_SYSTEM
2619 #define BUFFER_SIZE_FACTOR 16
2620 #else
2621 #define BUFFER_SIZE_FACTOR 1
2622 #endif
2623
2624 void
2625 read_input_waiting ()
2626 {
2627   int nread, i;
2628   extern int quit_char;
2629
2630   if (read_socket_hook)
2631     {
2632       struct input_event buf[256];
2633       for (i = 0; i < 256; i++)
2634         EVENT_INIT (buf[i]);
2635
2636       read_alarm_should_throw = 0;
2637       if (! setjmp (read_alarm_throw))
2638         nread = (*read_socket_hook) (0, buf, 256, 1);
2639       else
2640         nread = -1;
2641
2642       /* Scan the chars for C-g and store them in kbd_buffer.  */
2643       for (i = 0; i < nread; i++)
2644         {
2645           kbd_buffer_store_event (&buf[i]);
2646           /* Don't look at input that follows a C-g too closely.
2647              This reduces lossage due to autorepeat on C-g.  */
2648           if (buf[i].kind == ASCII_KEYSTROKE_EVENT
2649               && buf[i].code == quit_char)
2650             break;
2651         }
2652     }
2653   else
2654     {
2655       struct input_event e;
2656       char buf[3];
2657       nread = read (fileno (stdin), buf, 1);
2658       EVENT_INIT (e);
2659
2660       /* Scan the chars for C-g and store them in kbd_buffer.  */
2661       e.kind = ASCII_KEYSTROKE_EVENT;
2662       e.frame_or_window = selected_frame;
2663       e.modifiers = 0;
2664       for (i = 0; i < nread; i++)
2665         {
2666           /* Convert chars > 0177 to meta events if desired.
2667              We do this under the same conditions that read_avail_input does.  */
2668           if (read_socket_hook == 0)
2669             {
2670               /* If the user says she has a meta key, then believe her. */
2671               if (meta_key == 1 && (buf[i] & 0x80))
2672                 e.modifiers = meta_modifier;
2673               if (meta_key != 2)
2674                 buf[i] &= ~0x80;
2675             }
2676
2677           XSETINT (e.code, buf[i]);
2678           kbd_buffer_store_event (&e);
2679           /* Don't look at input that follows a C-g too closely.
2680              This reduces lossage due to autorepeat on C-g.  */
2681           if (buf[i] == quit_char)
2682             break;
2683         }
2684     }
2685 }
2686
2687 #endif /* not HAVE_SELECT */
2688 #endif /* not VMS */
2689 #endif /* not MSDOS */
2690 \f
2691 #ifdef BSD4_1
2692 void
2693 init_sigio (fd)
2694      int fd;
2695 {
2696   if (noninteractive)
2697     return;
2698   lmode = LINTRUP | lmode;
2699   ioctl (fd, TIOCLSET, &lmode);
2700 }
2701
2702 void
2703 reset_sigio ()
2704 {
2705   if (noninteractive)
2706     return;
2707   lmode = ~LINTRUP & lmode;
2708   ioctl (0, TIOCLSET, &lmode);
2709 }
2710
2711 void
2712 request_sigio ()
2713 {
2714   sigrelse (SIGTINT);
2715
2716   interrupts_deferred = 0;
2717 }
2718
2719 void
2720 unrequest_sigio ()
2721 {
2722   sighold (SIGTINT);
2723
2724   interrupts_deferred = 1;
2725 }
2726
2727 /* still inside #ifdef BSD4_1 */
2728 #ifdef subprocesses
2729
2730 int sigheld; /* Mask of held signals */
2731
2732 void
2733 sigholdx (signum)
2734      int signum;
2735 {
2736   sigheld |= sigbit (signum);
2737   sighold (signum);
2738 }
2739
2740 void
2741 sigisheld (signum)
2742      int signum;
2743 {
2744   sigheld |= sigbit (signum);
2745 }
2746
2747 void
2748 sigunhold (signum)
2749      int signum;
2750 {
2751   sigheld &= ~sigbit (signum);
2752   sigrelse (signum);
2753 }
2754
2755 void
2756 sigfree ()    /* Free all held signals */
2757 {
2758   int i;
2759   for (i = 0; i < NSIG; i++)
2760     if (sigheld & sigbit (i))
2761       sigrelse (i);
2762   sigheld = 0;
2763 }
2764
2765 int
2766 sigbit (i)
2767 {
2768   return 1 << (i - 1);
2769 }
2770 #endif /* subprocesses */
2771 #endif /* BSD4_1 */
2772 \f
2773 /* POSIX signals support - DJB */
2774 /* Anyone with POSIX signals should have ANSI C declarations */
2775
2776 #ifdef POSIX_SIGNALS
2777
2778 sigset_t empty_mask, full_mask;
2779
2780 signal_handler_t
2781 sys_signal (int signal_number, signal_handler_t action)
2782 {
2783   struct sigaction new_action, old_action;
2784   sigemptyset (&new_action.sa_mask);
2785   new_action.sa_handler = action;
2786 #if defined (SA_RESTART) && ! defined (BROKEN_SA_RESTART)
2787   /* Emacs mostly works better with restartable system services. If this
2788      flag exists, we probably want to turn it on here.
2789      However, on some systems this resets the timeout of `select'
2790      which means that `select' never finishes if it keeps getting signals.
2791      BROKEN_SA_RESTART is defined on those systems.  */
2792   new_action.sa_flags = SA_RESTART;
2793 #else
2794   new_action.sa_flags = 0;
2795 #endif
2796   sigaction (signal_number, &new_action, &old_action);
2797   return (old_action.sa_handler);
2798 }
2799
2800 #ifndef __GNUC__
2801 /* If we're compiling with GCC, we don't need this function, since it
2802    can be written as a macro.  */
2803 sigset_t
2804 sys_sigmask (int sig)
2805 {
2806   sigset_t mask;
2807   sigemptyset (&mask);
2808   sigaddset (&mask, sig);
2809   return mask;
2810 }
2811 #endif
2812
2813 /* I'd like to have these guys return pointers to the mask storage in here,
2814    but there'd be trouble if the code was saving multiple masks.  I'll be
2815    safe and pass the structure.  It normally won't be more than 2 bytes
2816    anyhow. - DJB */
2817
2818 sigset_t
2819 sys_sigblock (sigset_t new_mask)
2820 {
2821   sigset_t old_mask;
2822   sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2823   return (old_mask);
2824 }
2825
2826 sigset_t
2827 sys_sigunblock (sigset_t new_mask)
2828 {
2829   sigset_t old_mask;
2830   sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2831   return (old_mask);
2832 }
2833
2834 sigset_t
2835 sys_sigsetmask (sigset_t new_mask)
2836 {
2837   sigset_t old_mask;
2838   sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2839   return (old_mask);
2840 }
2841
2842 #endif /* POSIX_SIGNALS */
2843 \f
2844 #if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
2845 static char *my_sys_siglist[NSIG];
2846 # ifdef sys_siglist
2847 #  undef sys_siglist
2848 # endif
2849 # define sys_siglist my_sys_siglist
2850 #endif
2851
2852 void
2853 init_signals ()
2854 {
2855 #ifdef POSIX_SIGNALS
2856   sigemptyset (&empty_mask);
2857   sigfillset (&full_mask);
2858 #endif
2859
2860 #if !defined HAVE_STRSIGNAL && !HAVE_DECL_SYS_SIGLIST
2861   if (! initialized)
2862     {
2863 # ifdef SIGABRT
2864       sys_siglist[SIGABRT] = "Aborted";
2865 # endif
2866 # ifdef SIGAIO
2867       sys_siglist[SIGAIO] = "LAN I/O interrupt";
2868 # endif
2869 # ifdef SIGALRM
2870       sys_siglist[SIGALRM] = "Alarm clock";
2871 # endif
2872 # ifdef SIGBUS
2873       sys_siglist[SIGBUS] = "Bus error";
2874 # endif
2875 # ifdef SIGCLD
2876       sys_siglist[SIGCLD] = "Child status changed";
2877 # endif
2878 # ifdef SIGCHLD
2879       sys_siglist[SIGCHLD] = "Child status changed";
2880 # endif
2881 # ifdef SIGCONT
2882       sys_siglist[SIGCONT] = "Continued";
2883 # endif
2884 # ifdef SIGDANGER
2885       sys_siglist[SIGDANGER] = "Swap space dangerously low";
2886 # endif
2887 # ifdef SIGDGNOTIFY
2888       sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
2889 # endif
2890 # ifdef SIGEMT
2891       sys_siglist[SIGEMT] = "Emulation trap";
2892 # endif
2893 # ifdef SIGFPE
2894       sys_siglist[SIGFPE] = "Arithmetic exception";
2895 # endif
2896 # ifdef SIGFREEZE
2897       sys_siglist[SIGFREEZE] = "SIGFREEZE";
2898 # endif
2899 # ifdef SIGGRANT
2900       sys_siglist[SIGGRANT] = "Monitor mode granted";
2901 # endif
2902 # ifdef SIGHUP
2903       sys_siglist[SIGHUP] = "Hangup";
2904 # endif
2905 # ifdef SIGILL
2906       sys_siglist[SIGILL] = "Illegal instruction";
2907 # endif
2908 # ifdef SIGINT
2909       sys_siglist[SIGINT] = "Interrupt";
2910 # endif
2911 # ifdef SIGIO
2912       sys_siglist[SIGIO] = "I/O possible";
2913 # endif
2914 # ifdef SIGIOINT
2915       sys_siglist[SIGIOINT] = "I/O intervention required";
2916 # endif
2917 # ifdef SIGIOT
2918       sys_siglist[SIGIOT] = "IOT trap";
2919 # endif
2920 # ifdef SIGKILL
2921       sys_siglist[SIGKILL] = "Killed";
2922 # endif
2923 # ifdef SIGLOST
2924       sys_siglist[SIGLOST] = "Resource lost";
2925 # endif
2926 # ifdef SIGLWP
2927       sys_siglist[SIGLWP] = "SIGLWP";
2928 # endif
2929 # ifdef SIGMSG
2930       sys_siglist[SIGMSG] = "Monitor mode data available";
2931 # endif
2932 # ifdef SIGPHONE
2933       sys_siglist[SIGWIND] = "SIGPHONE";
2934 # endif
2935 # ifdef SIGPIPE
2936       sys_siglist[SIGPIPE] = "Broken pipe";
2937 # endif
2938 # ifdef SIGPOLL
2939       sys_siglist[SIGPOLL] = "Pollable event occurred";
2940 # endif
2941 # ifdef SIGPROF
2942       sys_siglist[SIGPROF] = "Profiling timer expired";
2943 # endif
2944 # ifdef SIGPTY
2945       sys_siglist[SIGPTY] = "PTY I/O interrupt";
2946 # endif
2947 # ifdef SIGPWR
2948       sys_siglist[SIGPWR] = "Power-fail restart";
2949 # endif
2950 # ifdef SIGQUIT
2951       sys_siglist[SIGQUIT] = "Quit";
2952 # endif
2953 # ifdef SIGRETRACT
2954       sys_siglist[SIGRETRACT] = "Need to relinguish monitor mode";
2955 # endif
2956 # ifdef SIGSAK
2957       sys_siglist[SIGSAK] = "Secure attention";
2958 # endif
2959 # ifdef SIGSEGV
2960       sys_siglist[SIGSEGV] = "Segmentation violation";
2961 # endif
2962 # ifdef SIGSOUND
2963       sys_siglist[SIGSOUND] = "Sound completed";
2964 # endif
2965 # ifdef SIGSTOP
2966       sys_siglist[SIGSTOP] = "Stopped (signal)";
2967 # endif
2968 # ifdef SIGSTP
2969       sys_siglist[SIGSTP] = "Stopped (user)";
2970 # endif
2971 # ifdef SIGSYS
2972       sys_siglist[SIGSYS] = "Bad argument to system call";
2973 # endif
2974 # ifdef SIGTERM
2975       sys_siglist[SIGTERM] = "Terminated";
2976 # endif
2977 # ifdef SIGTHAW
2978       sys_siglist[SIGTHAW] = "SIGTHAW";
2979 # endif
2980 # ifdef SIGTRAP
2981       sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
2982 # endif
2983 # ifdef SIGTSTP
2984       sys_siglist[SIGTSTP] = "Stopped (user)";
2985 # endif
2986 # ifdef SIGTTIN
2987       sys_siglist[SIGTTIN] = "Stopped (tty input)";
2988 # endif
2989 # ifdef SIGTTOU
2990       sys_siglist[SIGTTOU] = "Stopped (tty output)";
2991 # endif
2992 # ifdef SIGURG
2993       sys_siglist[SIGURG] = "Urgent I/O condition";
2994 # endif
2995 # ifdef SIGUSR1
2996       sys_siglist[SIGUSR1] = "User defined signal 1";
2997 # endif
2998 # ifdef SIGUSR2
2999       sys_siglist[SIGUSR2] = "User defined signal 2";
3000 # endif
3001 # ifdef SIGVTALRM
3002       sys_siglist[SIGVTALRM] = "Virtual timer expired";
3003 # endif
3004 # ifdef SIGWAITING
3005       sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
3006 # endif
3007 # ifdef SIGWINCH
3008       sys_siglist[SIGWINCH] = "Window size changed";
3009 # endif
3010 # ifdef SIGWIND
3011       sys_siglist[SIGWIND] = "SIGWIND";
3012 # endif
3013 # ifdef SIGXCPU
3014       sys_siglist[SIGXCPU] = "CPU time limit exceeded";
3015 # endif
3016 # ifdef SIGXFSZ
3017       sys_siglist[SIGXFSZ] = "File size limit exceeded";
3018 # endif
3019     }
3020 #endif /* !defined HAVE_STRSIGNAL && !defined HAVE_DECL_SYS_SIGLIST */
3021 }
3022 \f
3023 #ifndef HAVE_RANDOM
3024 #ifdef random
3025 #define HAVE_RANDOM
3026 #endif
3027 #endif
3028
3029 /* Figure out how many bits the system's random number generator uses.
3030    `random' and `lrand48' are assumed to return 31 usable bits.
3031    BSD `rand' returns a 31 bit value but the low order bits are unusable;
3032    so we'll shift it and treat it like the 15-bit USG `rand'.  */
3033
3034 #ifndef RAND_BITS
3035 # ifdef HAVE_RANDOM
3036 #  define RAND_BITS 31
3037 # else /* !HAVE_RANDOM */
3038 #  ifdef HAVE_LRAND48
3039 #   define RAND_BITS 31
3040 #   define random lrand48
3041 #  else /* !HAVE_LRAND48 */
3042 #   define RAND_BITS 15
3043 #   if RAND_MAX == 32767
3044 #    define random rand
3045 #   else /* RAND_MAX != 32767 */
3046 #    if RAND_MAX == 2147483647
3047 #     define random() (rand () >> 16)
3048 #    else /* RAND_MAX != 2147483647 */
3049 #     ifdef USG
3050 #      define random rand
3051 #     else
3052 #      define random() (rand () >> 16)
3053 #     endif /* !USG */
3054 #    endif /* RAND_MAX != 2147483647 */
3055 #   endif /* RAND_MAX != 32767 */
3056 #  endif /* !HAVE_LRAND48 */
3057 # endif /* !HAVE_RANDOM */
3058 #endif /* !RAND_BITS */
3059
3060 void
3061 seed_random (arg)
3062      long arg;
3063 {
3064 #ifdef HAVE_RANDOM
3065   srandom ((unsigned int)arg);
3066 #else
3067 # ifdef HAVE_LRAND48
3068   srand48 (arg);
3069 # else
3070   srand ((unsigned int)arg);
3071 # endif
3072 #endif
3073 }
3074
3075 /*
3076  * Build a full Emacs-sized word out of whatever we've got.
3077  * This suffices even for a 64-bit architecture with a 15-bit rand.
3078  */
3079 long
3080 get_random ()
3081 {
3082   long val = random ();
3083 #if VALBITS > RAND_BITS
3084   val = (val << RAND_BITS) ^ random ();
3085 #if VALBITS > 2*RAND_BITS
3086   val = (val << RAND_BITS) ^ random ();
3087 #if VALBITS > 3*RAND_BITS
3088   val = (val << RAND_BITS) ^ random ();
3089 #if VALBITS > 4*RAND_BITS
3090   val = (val << RAND_BITS) ^ random ();
3091 #endif /* need at least 5 */
3092 #endif /* need at least 4 */
3093 #endif /* need at least 3 */
3094 #endif /* need at least 2 */
3095   return val & ((1L << VALBITS) - 1);
3096 }
3097 \f
3098 #ifdef WRONG_NAME_INSQUE
3099
3100 insque (q,p)
3101      caddr_t q,p;
3102 {
3103   _insque (q,p);
3104 }
3105
3106 #endif
3107 \f
3108 #ifdef VMS
3109
3110 #ifdef getenv
3111 /* If any place else asks for the TERM variable,
3112    allow it to be overridden with the EMACS_TERM variable
3113    before attempting to translate the logical name TERM.  As a last
3114    resort, ask for VAX C's special idea of the TERM variable.  */
3115 #undef getenv
3116 char *
3117 sys_getenv (name)
3118      char *name;
3119 {
3120   register char *val;
3121   static char buf[256];
3122   static struct dsc$descriptor_s equiv
3123     = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
3124   static struct dsc$descriptor_s d_name
3125     = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
3126   short eqlen;
3127
3128   if (!strcmp (name, "TERM"))
3129     {
3130       val = (char *) getenv ("EMACS_TERM");
3131       if (val)
3132         return val;
3133     }
3134
3135   d_name.dsc$w_length = strlen (name);
3136   d_name.dsc$a_pointer = name;
3137   if (LIB$SYS_TRNLOG (&d_name, &eqlen, &equiv) == 1)
3138     {
3139       char *str = (char *) xmalloc (eqlen + 1);
3140       bcopy (buf, str, eqlen);
3141       str[eqlen] = '\0';
3142       /* This is a storage leak, but a pain to fix.  With luck,
3143          no one will ever notice.  */
3144       return str;
3145     }
3146   return (char *) getenv (name);
3147 }
3148 #endif /* getenv */
3149
3150 #ifdef abort
3151 /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
3152    to force a call on the debugger from within the image. */
3153 #undef abort
3154 sys_abort ()
3155 {
3156   reset_sys_modes ();
3157   LIB$SIGNAL (SS$_DEBUG);
3158 }
3159 #endif /* abort */
3160 #endif /* VMS */
3161 \f
3162 #ifdef VMS
3163 #ifdef LINK_CRTL_SHARE
3164 #ifdef SHARABLE_LIB_BUG
3165 /* Variables declared noshare and initialized in sharable libraries
3166    cannot be shared.  The VMS linker incorrectly forces you to use a private
3167    version which is uninitialized... If not for this "feature", we
3168    could use the C library definition of sys_nerr and sys_errlist. */
3169 int sys_nerr = 35;
3170 char *sys_errlist[] =
3171   {
3172     "error 0",
3173     "not owner",
3174     "no such file or directory",
3175     "no such process",
3176     "interrupted system call",
3177     "i/o error",
3178     "no such device or address",
3179     "argument list too long",
3180     "exec format error",
3181     "bad file number",
3182     "no child process",
3183     "no more processes",
3184     "not enough memory",
3185     "permission denied",
3186     "bad address",
3187     "block device required",
3188     "mount devices busy",
3189     "file exists",
3190     "cross-device link",
3191     "no such device",
3192     "not a directory",
3193     "is a directory",
3194     "invalid argument",
3195     "file table overflow",
3196     "too many open files",
3197     "not a typewriter",
3198     "text file busy",
3199     "file too big",
3200     "no space left on device",
3201     "illegal seek",
3202     "read-only file system",
3203     "too many links",
3204     "broken pipe",
3205     "math argument",
3206     "result too large",
3207     "I/O stream empty",
3208     "vax/vms specific error code nontranslatable error"
3209   };
3210 #endif /* SHARABLE_LIB_BUG */
3211 #endif /* LINK_CRTL_SHARE */
3212 #endif /* VMS */
3213
3214 #ifndef HAVE_STRERROR
3215 #ifndef WINDOWSNT
3216 char *
3217 strerror (errnum)
3218      int errnum;
3219 {
3220   extern char *sys_errlist[];
3221   extern int sys_nerr;
3222
3223   if (errnum >= 0 && errnum < sys_nerr)
3224     return sys_errlist[errnum];
3225   return (char *) "Unknown error";
3226 }
3227 #endif /* not WINDOWSNT */
3228 #endif /* ! HAVE_STRERROR */
3229 \f
3230 int
3231 emacs_open (path, oflag, mode)
3232      const char *path;
3233      int oflag, mode;
3234 {
3235   register int rtnval;
3236
3237 #ifdef BSD4_1
3238   if (oflag & O_CREAT)
3239     return creat (path, mode);
3240 #endif
3241
3242   while ((rtnval = open (path, oflag, mode)) == -1
3243          && (errno == EINTR));
3244   return (rtnval);
3245 }
3246
3247 int
3248 emacs_close (fd)
3249      int fd;
3250 {
3251   int did_retry = 0;
3252   register int rtnval;
3253
3254   while ((rtnval = close (fd)) == -1
3255          && (errno == EINTR))
3256     did_retry = 1;
3257
3258   /* If close is interrupted SunOS 4.1 may or may not have closed the
3259      file descriptor.  If it did the second close will fail with
3260      errno = EBADF.  That means we have succeeded.  */
3261   if (rtnval == -1 && did_retry && errno == EBADF)
3262     return 0;
3263
3264   return rtnval;
3265 }
3266
3267 int
3268 emacs_read (fildes, buf, nbyte)
3269      int fildes;
3270      char *buf;
3271      unsigned int nbyte;
3272 {
3273   register int rtnval;
3274
3275   while ((rtnval = read (fildes, buf, nbyte)) == -1
3276          && (errno == EINTR));
3277   return (rtnval);
3278 }
3279
3280 int
3281 emacs_write (fildes, buf, nbyte)
3282      int fildes;
3283      const char *buf;
3284      unsigned int nbyte;
3285 {
3286   register int rtnval, bytes_written;
3287
3288   bytes_written = 0;
3289
3290   while (nbyte > 0)
3291     {
3292       rtnval = write (fildes, buf, nbyte);
3293
3294       if (rtnval == -1)
3295         {
3296           if (errno == EINTR)
3297             continue;
3298           else
3299             return (bytes_written ? bytes_written : -1);
3300         }
3301
3302       buf += rtnval;
3303       nbyte -= rtnval;
3304       bytes_written += rtnval;
3305     }
3306   return (bytes_written);
3307 }
3308 \f
3309 #ifdef USG
3310 /*
3311  *      All of the following are for USG.
3312  *
3313  *      On USG systems the system calls are INTERRUPTIBLE by signals
3314  *      that the user program has elected to catch.  Thus the system call
3315  *      must be retried in these cases.  To handle this without massive
3316  *      changes in the source code, we remap the standard system call names
3317  *      to names for our own functions in sysdep.c that do the system call
3318  *      with retries.  Actually, for portability reasons, it is good
3319  *      programming practice, as this example shows, to limit all actual
3320  *      system calls to a single occurrence in the source.  Sure, this
3321  *      adds an extra level of function call overhead but it is almost
3322  *      always negligible.   Fred Fish, Unisoft Systems Inc.
3323  */
3324
3325 /*
3326  *      Warning, this function may not duplicate 4.2 action properly
3327  *      under error conditions.
3328  */
3329
3330 #ifndef MAXPATHLEN
3331 /* In 4.1, param.h fails to define this.  */
3332 #define MAXPATHLEN 1024
3333 #endif
3334
3335 #ifndef HAVE_GETWD
3336
3337 char *
3338 getwd (pathname)
3339      char *pathname;
3340 {
3341   char *npath, *spath;
3342   extern char *getcwd ();
3343
3344   BLOCK_INPUT;                  /* getcwd uses malloc */
3345   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3346   if (spath == 0)
3347     {
3348       UNBLOCK_INPUT;
3349       return spath;
3350     }
3351   /* On Altos 3068, getcwd can return @hostname/dir, so discard
3352      up to first slash.  Should be harmless on other systems.  */
3353   while (*npath && *npath != '/')
3354     npath++;
3355   strcpy (pathname, npath);
3356   free (spath);                 /* getcwd uses malloc */
3357   UNBLOCK_INPUT;
3358   return pathname;
3359 }
3360
3361 #endif /* HAVE_GETWD */
3362
3363 /*
3364  *      Emulate rename using unlink/link.  Note that this is
3365  *      only partially correct.  Also, doesn't enforce restriction
3366  *      that files be of same type (regular->regular, dir->dir, etc).
3367  */
3368
3369 #ifndef HAVE_RENAME
3370
3371 rename (from, to)
3372      const char *from;
3373      const char *to;
3374 {
3375   if (access (from, 0) == 0)
3376     {
3377       unlink (to);
3378       if (link (from, to) == 0)
3379         if (unlink (from) == 0)
3380           return (0);
3381     }
3382   return (-1);
3383 }
3384
3385 #endif
3386
3387
3388 #ifdef HPUX
3389 #ifndef HAVE_PERROR
3390
3391 /* HPUX curses library references perror, but as far as we know
3392    it won't be called.  Anyway this definition will do for now.  */
3393
3394 perror ()
3395 {
3396 }
3397
3398 #endif /* not HAVE_PERROR */
3399 #endif /* HPUX */
3400
3401 #ifndef HAVE_DUP2
3402
3403 /*
3404  *      Emulate BSD dup2.  First close newd if it already exists.
3405  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
3406  *      until we are, then close the unsuccessful ones.
3407  */
3408
3409 dup2 (oldd, newd)
3410      int oldd;
3411      int newd;
3412 {
3413   register int fd, ret;
3414
3415   emacs_close (newd);
3416
3417 #ifdef F_DUPFD
3418   return fcntl (oldd, F_DUPFD, newd);
3419 #else
3420   fd = dup (old);
3421   if (fd == -1)
3422     return -1;
3423   if (fd == new)
3424     return new;
3425   ret = dup2 (old,new);
3426   emacs_close (fd);
3427   return ret;
3428 #endif
3429 }
3430
3431 #endif /* not HAVE_DUP2 */
3432
3433 /*
3434  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3435  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3436  *      Only needed when subprocesses are defined.
3437  */
3438
3439 #ifdef subprocesses
3440 #ifndef VMS
3441 #ifndef HAVE_GETTIMEOFDAY
3442 #ifdef HAVE_TIMEVAL
3443
3444 /* ARGSUSED */
3445 int
3446 gettimeofday (tp, tzp)
3447      struct timeval *tp;
3448      struct timezone *tzp;
3449 {
3450   extern long time ();
3451
3452   tp->tv_sec = time ((long *)0);
3453   tp->tv_usec = 0;
3454   if (tzp != 0)
3455     tzp->tz_minuteswest = -1;
3456   return 0;
3457 }
3458
3459 #endif
3460 #endif
3461 #endif
3462 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3463
3464 /*
3465  *      This function will go away as soon as all the stubs fixed. (fnf)
3466  */
3467
3468 void
3469 croak (badfunc)
3470      char *badfunc;
3471 {
3472   printf ("%s not yet implemented\r\n", badfunc);
3473   reset_sys_modes ();
3474   exit (1);
3475 }
3476
3477 #endif /* USG */
3478 \f
3479 /* Directory routines for systems that don't have them. */
3480
3481 #ifdef SYSV_SYSTEM_DIR
3482
3483 #include <dirent.h>
3484
3485 #if defined (BROKEN_CLOSEDIR) || !defined (HAVE_CLOSEDIR)
3486
3487 int
3488 closedir (dirp)
3489      register DIR *dirp;              /* stream from opendir */
3490 {
3491   int rtnval;
3492
3493   rtnval = emacs_close (dirp->dd_fd);
3494
3495   /* Some systems (like Solaris) allocate the buffer and the DIR all
3496      in one block.  Why in the world are we freeing this ourselves
3497      anyway?  */
3498 #if ! (defined (sun) && defined (USG5_4))
3499   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3500 #endif
3501   xfree ((char *) dirp);
3502
3503   return rtnval;
3504 }
3505 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3506 #endif /* SYSV_SYSTEM_DIR */
3507
3508 #ifdef NONSYSTEM_DIR_LIBRARY
3509
3510 DIR *
3511 opendir (filename)
3512      char *filename;    /* name of directory */
3513 {
3514   register DIR *dirp;           /* -> malloc'ed storage */
3515   register int fd;              /* file descriptor for read */
3516   struct stat sbuf;             /* result of fstat */
3517
3518   fd = emacs_open (filename, O_RDONLY, 0);
3519   if (fd < 0)
3520     return 0;
3521
3522   BLOCK_INPUT;
3523   if (fstat (fd, &sbuf) < 0
3524       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3525       || (dirp = (DIR *) xmalloc (sizeof (DIR))) == 0)
3526     {
3527       emacs_close (fd);
3528       UNBLOCK_INPUT;
3529       return 0;         /* bad luck today */
3530     }
3531   UNBLOCK_INPUT;
3532
3533   dirp->dd_fd = fd;
3534   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3535
3536   return dirp;
3537 }
3538
3539 void
3540 closedir (dirp)
3541      register DIR *dirp;                /* stream from opendir */
3542 {
3543   emacs_close (dirp->dd_fd);
3544   xfree ((char *) dirp);
3545 }
3546
3547
3548 #ifndef VMS
3549 #define DIRSIZ  14
3550 struct olddir
3551   {
3552     ino_t od_ino;               /* inode */
3553     char od_name[DIRSIZ];       /* filename */
3554   };
3555 #endif /* not VMS */
3556
3557 struct direct dir_static;       /* simulated directory contents */
3558
3559 /* ARGUSED */
3560 struct direct *
3561 readdir (dirp)
3562      register DIR *dirp;        /* stream from opendir */
3563 {
3564 #ifndef VMS
3565   register struct olddir *dp;   /* -> directory data */
3566 #else /* VMS */
3567   register struct dir$_name *dp; /* -> directory data */
3568   register struct dir$_version *dv; /* -> version data */
3569 #endif /* VMS */
3570
3571   for (; ;)
3572     {
3573       if (dirp->dd_loc >= dirp->dd_size)
3574         dirp->dd_loc = dirp->dd_size = 0;
3575
3576       if (dirp->dd_size == 0    /* refill buffer */
3577           && (dirp->dd_size = emacs_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3578         return 0;
3579
3580 #ifndef VMS
3581       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3582       dirp->dd_loc += sizeof (struct olddir);
3583
3584       if (dp->od_ino != 0)      /* not deleted entry */
3585         {
3586           dir_static.d_ino = dp->od_ino;
3587           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3588           dir_static.d_name[DIRSIZ] = '\0';
3589           dir_static.d_namlen = strlen (dir_static.d_name);
3590           dir_static.d_reclen = sizeof (struct direct)
3591             - MAXNAMLEN + 3
3592               + dir_static.d_namlen - dir_static.d_namlen % 4;
3593           return &dir_static;   /* -> simulated structure */
3594         }
3595 #else /* VMS */
3596       dp = (struct dir$_name *) dirp->dd_buf;
3597       if (dirp->dd_loc == 0)
3598         dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3599           : dp->dir$b_namecount;
3600       dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3601       dir_static.d_ino = dv->dir$w_fid_num;
3602       dir_static.d_namlen = dp->dir$b_namecount;
3603       dir_static.d_reclen = sizeof (struct direct)
3604         - MAXNAMLEN + 3
3605           + dir_static.d_namlen - dir_static.d_namlen % 4;
3606       strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3607       dir_static.d_name[dir_static.d_namlen] = '\0';
3608       dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3609       return &dir_static;
3610 #endif /* VMS */
3611     }
3612 }
3613
3614 #ifdef VMS
3615 /* readdirver is just like readdir except it returns all versions of a file
3616    as separate entries.  */
3617
3618 /* ARGUSED */
3619 struct direct *
3620 readdirver (dirp)
3621      register DIR *dirp;        /* stream from opendir */
3622 {
3623   register struct dir$_name *dp; /* -> directory data */
3624   register struct dir$_version *dv; /* -> version data */
3625
3626   if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3627     dirp->dd_loc = dirp->dd_size = 0;
3628
3629   if (dirp->dd_size == 0        /* refill buffer */
3630       && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3631     return 0;
3632
3633   dp = (struct dir$_name *) dirp->dd_buf;
3634   if (dirp->dd_loc == 0)
3635     dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
3636                    : dp->dir$b_namecount;
3637   dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
3638   strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3639   sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3640   dir_static.d_namlen = strlen (dir_static.d_name);
3641   dir_static.d_ino = dv->dir$w_fid_num;
3642   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3643                         + dir_static.d_namlen - dir_static.d_namlen % 4;
3644   dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3645   return &dir_static;
3646 }
3647
3648 #endif /* VMS */
3649
3650 #endif /* NONSYSTEM_DIR_LIBRARY */
3651
3652 \f
3653 int
3654 set_file_times (filename, atime, mtime)
3655      const char *filename;
3656      EMACS_TIME atime, mtime;
3657 {
3658 #ifdef HAVE_UTIMES
3659   struct timeval tv[2];
3660   tv[0] = atime;
3661   tv[1] = mtime;
3662   return utimes (filename, tv);
3663 #else /* not HAVE_UTIMES */
3664   struct utimbuf utb;
3665   utb.actime = EMACS_SECS (atime);
3666   utb.modtime = EMACS_SECS (mtime);
3667   return utime (filename, &utb);
3668 #endif /* not HAVE_UTIMES */
3669 }
3670 \f
3671 /* mkdir and rmdir functions, for systems which don't have them.  */
3672
3673 #ifndef HAVE_MKDIR
3674 /*
3675  * Written by Robert Rother, Mariah Corporation, August 1985.
3676  *
3677  * If you want it, it's yours.  All I ask in return is that if you
3678  * figure out how to do this in a Bourne Shell script you send me
3679  * a copy.
3680  *                                      sdcsvax!rmr or rmr@uscd
3681  *
3682  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3683  * subroutine.  11Mar86; hoptoad!gnu
3684  *
3685  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3686  * subroutine didn't return EEXIST.  It does now.
3687  */
3688
3689 /*
3690  * Make a directory.
3691  */
3692 #ifdef MKDIR_PROTOTYPE
3693 MKDIR_PROTOTYPE
3694 #else
3695 int
3696 mkdir (dpath, dmode)
3697      char *dpath;
3698      int dmode;
3699 #endif
3700 {
3701   int cpid, status, fd;
3702   struct stat statbuf;
3703
3704   if (stat (dpath, &statbuf) == 0)
3705     {
3706       errno = EEXIST;           /* Stat worked, so it already exists */
3707       return -1;
3708     }
3709
3710   /* If stat fails for a reason other than non-existence, return error */
3711   if (errno != ENOENT)
3712     return -1;
3713
3714   synch_process_alive = 1;
3715   switch (cpid = fork ())
3716     {
3717
3718     case -1:                    /* Error in fork */
3719       return (-1);              /* Errno is set already */
3720
3721     case 0:                     /* Child process */
3722       /*
3723                  * Cheap hack to set mode of new directory.  Since this
3724                  * child process is going away anyway, we zap its umask.
3725                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
3726                  * directory.  Does anybody care?
3727                  */
3728       status = umask (0);       /* Get current umask */
3729       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3730       fd = emacs_open ("/dev/null", O_RDWR, 0);
3731       if (fd >= 0)
3732         {
3733           dup2 (fd, 0);
3734           dup2 (fd, 1);
3735           dup2 (fd, 2);
3736         }
3737       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3738       _exit (-1);               /* Can't exec /bin/mkdir */
3739
3740     default:                    /* Parent process */
3741       wait_for_termination (cpid);
3742     }
3743
3744   if (synch_process_death != 0 || synch_process_retcode != 0)
3745     {
3746       errno = EIO;              /* We don't know why, but */
3747       return -1;                /* /bin/mkdir failed */
3748     }
3749
3750   return 0;
3751 }
3752 #endif /* not HAVE_MKDIR */
3753
3754 #ifndef HAVE_RMDIR
3755 int
3756 rmdir (dpath)
3757      char *dpath;
3758 {
3759   int cpid, status, fd;
3760   struct stat statbuf;
3761
3762   if (stat (dpath, &statbuf) != 0)
3763     {
3764       /* Stat just set errno.  We don't have to */
3765       return -1;
3766     }
3767
3768   synch_process_alive = 1;
3769   switch (cpid = fork ())
3770     {
3771
3772     case -1:                    /* Error in fork */
3773       return (-1);              /* Errno is set already */
3774
3775     case 0:                     /* Child process */
3776       fd = emacs_open ("/dev/null", O_RDWR, 0);
3777       if (fd >= 0)
3778         {
3779           dup2 (fd, 0);
3780           dup2 (fd, 1);
3781           dup2 (fd, 2);
3782         }
3783       execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3784       _exit (-1);               /* Can't exec /bin/rmdir */
3785
3786     default:                    /* Parent process */
3787       wait_for_termination (cpid);
3788     }
3789
3790   if (synch_process_death != 0 || synch_process_retcode != 0)
3791     {
3792       errno = EIO;              /* We don't know why, but */
3793       return -1;                /* /bin/rmdir failed */
3794     }
3795
3796   return 0;
3797 }
3798 #endif /* !HAVE_RMDIR */
3799
3800
3801 \f
3802 /* Functions for VMS */
3803 #ifdef VMS
3804 #include "vms-pwd.h"
3805 #include <acldef.h>
3806 #include <chpdef.h>
3807 #include <jpidef.h>
3808
3809 /* Return as a string the VMS error string pertaining to STATUS.
3810    Reuses the same static buffer each time it is called.  */
3811
3812 char *
3813 vmserrstr (status)
3814      int status;                /* VMS status code */
3815 {
3816   int bufadr[2];
3817   short len;
3818   static char buf[257];
3819
3820   bufadr[0] = sizeof buf - 1;
3821   bufadr[1] = (int) buf;
3822   if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3823     return "untranslatable VMS error status";
3824   buf[len] = '\0';
3825   return buf;
3826 }
3827
3828 #ifdef access
3829 #undef access
3830
3831 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3832  * not work correctly.  (It also doesn't work well in version 2.3.)
3833  */
3834
3835 #ifdef VMS4_4
3836
3837 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3838         { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3839
3840 typedef union {
3841     struct {
3842         unsigned short s_buflen;
3843         unsigned short s_code;
3844         char *s_bufadr;
3845         unsigned short *s_retlenadr;
3846     } s;
3847     int end;
3848 } item;
3849 #define buflen s.s_buflen
3850 #define code s.s_code
3851 #define bufadr s.s_bufadr
3852 #define retlenadr s.s_retlenadr
3853
3854 #define R_OK 4  /* test for read permission */
3855 #define W_OK 2  /* test for write permission */
3856 #define X_OK 1  /* test for execute (search) permission */
3857 #define F_OK 0  /* test for presence of file */
3858
3859 int
3860 sys_access (path, mode)
3861      char *path;
3862      int mode;
3863 {
3864   static char *user = NULL;
3865   char dir_fn[512];
3866
3867   /* translate possible directory spec into .DIR file name, so brain-dead
3868    * access can treat the directory like a file.  */
3869   if (directory_file_name (path, dir_fn))
3870     path = dir_fn;
3871
3872   if (mode == F_OK)
3873     return access (path, mode);
3874   if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3875     return -1;
3876   {
3877     int stat;
3878     int flags;
3879     int acces;
3880     unsigned short int dummy;
3881     item itemlst[3];
3882     static int constant = ACL$C_FILE;
3883     DESCRIPTOR (path_desc, path);
3884     DESCRIPTOR (user_desc, user);
3885
3886     flags = 0;
3887     acces = 0;
3888     if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3889       return stat;
3890     if (mode & R_OK)
3891       acces |= CHP$M_READ;
3892     if (mode & W_OK)
3893       acces |= CHP$M_WRITE;
3894     itemlst[0].buflen = sizeof (int);
3895     itemlst[0].code = CHP$_FLAGS;
3896     itemlst[0].bufadr = (char *) &flags;
3897     itemlst[0].retlenadr = &dummy;
3898     itemlst[1].buflen = sizeof (int);
3899     itemlst[1].code = CHP$_ACCESS;
3900     itemlst[1].bufadr = (char *) &acces;
3901     itemlst[1].retlenadr = &dummy;
3902     itemlst[2].end = CHP$_END;
3903     stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3904     return stat == SS$_NORMAL ? 0 : -1;
3905   }
3906 }
3907
3908 #else /* not VMS4_4 */
3909
3910 #include <prvdef.h>
3911 #define ACE$M_WRITE     2
3912 #define ACE$C_KEYID     1
3913
3914 static unsigned short memid, grpid;
3915 static unsigned int uic;
3916
3917 /* Called from init_sys_modes, so it happens not very often
3918    but at least each time Emacs is loaded.  */
3919 void
3920 sys_access_reinit ()
3921 {
3922   uic = 0;
3923 }
3924
3925 int
3926 sys_access (filename, type)
3927      char * filename;
3928      int type;
3929 {
3930   struct FAB fab;
3931   struct XABPRO xab;
3932   int status, size, i, typecode, acl_controlled;
3933   unsigned int *aclptr, *aclend, aclbuf[60];
3934   union prvdef prvmask;
3935
3936   /* Get UIC and GRP values for protection checking.  */
3937   if (uic == 0)
3938     {
3939       status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3940       if (! (status & 1))
3941         return -1;
3942       memid = uic & 0xFFFF;
3943       grpid = uic >> 16;
3944     }
3945
3946   if (type != 2)                /* not checking write access */
3947     return access (filename, type);
3948
3949   /* Check write protection. */
3950
3951 #define CHECKPRIV(bit)    (prvmask.bit)
3952 #define WRITABLE(field)  (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3953
3954   /* Find privilege bits */
3955   status = SYS$SETPRV (0, 0, 0, prvmask);
3956   if (! (status & 1))
3957     error ("Unable to find privileges: %s", vmserrstr (status));
3958   if (CHECKPRIV (PRV$V_BYPASS))
3959     return 0;                   /* BYPASS enabled */
3960   fab = cc$rms_fab;
3961   fab.fab$b_fac = FAB$M_GET;
3962   fab.fab$l_fna = filename;
3963   fab.fab$b_fns = strlen (filename);
3964   fab.fab$l_xab = &xab;
3965   xab = cc$rms_xabpro;
3966   xab.xab$l_aclbuf = aclbuf;
3967   xab.xab$w_aclsiz = sizeof (aclbuf);
3968   status = SYS$OPEN (&fab, 0, 0);
3969   if (! (status & 1))
3970     return -1;
3971   SYS$CLOSE (&fab, 0, 0);
3972   /* Check system access */
3973   if (CHECKPRIV (PRV$V_SYSPRV) && WRITABLE (XAB$V_SYS))
3974     return 0;
3975   /* Check ACL entries, if any */
3976   acl_controlled = 0;
3977   if (xab.xab$w_acllen > 0)
3978     {
3979       aclptr = aclbuf;
3980       aclend = &aclbuf[xab.xab$w_acllen / 4];
3981       while (*aclptr && aclptr < aclend)
3982         {
3983           size = (*aclptr & 0xff) / 4;
3984           typecode = (*aclptr >> 8) & 0xff;
3985           if (typecode == ACE$C_KEYID)
3986             for (i = size - 1; i > 1; i--)
3987               if (aclptr[i] == uic)
3988                 {
3989                   acl_controlled = 1;
3990                   if (aclptr[1] & ACE$M_WRITE)
3991                     return 0;   /* Write access through ACL */
3992                 }
3993           aclptr = &aclptr[size];
3994         }
3995       if (acl_controlled)       /* ACL specified, prohibits write access */
3996         return -1;
3997     }
3998   /* No ACL entries specified, check normal protection */
3999   if (WRITABLE (XAB$V_WLD))     /* World writable */
4000     return 0;
4001   if (WRITABLE (XAB$V_GRP) &&
4002       (unsigned short) (xab.xab$l_uic >> 16) == grpid)
4003     return 0;                   /* Group writable */
4004   if (WRITABLE (XAB$V_OWN) &&
4005       (xab.xab$l_uic & 0xFFFF) == memid)
4006     return 0;                   /* Owner writable */
4007
4008   return -1;    /* Not writable */
4009 }
4010 #endif /* not VMS4_4 */
4011 #endif /* access */
4012
4013 static char vtbuf[NAM$C_MAXRSS+1];
4014
4015 /* translate a vms file spec to a unix path */
4016 char *
4017 sys_translate_vms (vfile)
4018      char * vfile;
4019 {
4020   char * p;
4021   char * targ;
4022
4023   if (!vfile)
4024     return 0;
4025
4026   targ = vtbuf;
4027
4028   /* leading device or logical name is a root directory */
4029   if (p = strchr (vfile, ':'))
4030     {
4031       *targ++ = '/';
4032       while (vfile < p)
4033         *targ++ = *vfile++;
4034       vfile++;
4035       *targ++ = '/';
4036     }
4037   p = vfile;
4038   if (*p == '[' || *p == '<')
4039     {
4040       while (*++vfile != *p + 2)
4041         switch (*vfile)
4042           {
4043           case '.':
4044             if (vfile[-1] == *p)
4045               *targ++ = '.';
4046             *targ++ = '/';
4047             break;
4048
4049           case '-':
4050             *targ++ = '.';
4051             *targ++ = '.';
4052             break;
4053
4054           default:
4055             *targ++ = *vfile;
4056             break;
4057           }
4058       vfile++;
4059       *targ++ = '/';
4060     }
4061   while (*vfile)
4062     *targ++ = *vfile++;
4063
4064   return vtbuf;
4065 }
4066
4067 static char utbuf[NAM$C_MAXRSS+1];
4068
4069 /* translate a unix path to a VMS file spec */
4070 char *
4071 sys_translate_unix (ufile)
4072      char * ufile;
4073 {
4074   int slash_seen = 0;
4075   char *p;
4076   char * targ;
4077
4078   if (!ufile)
4079     return 0;
4080
4081   targ = utbuf;
4082
4083   if (*ufile == '/')
4084     {
4085       ufile++;
4086     }
4087
4088   while (*ufile)
4089     {
4090       switch (*ufile)
4091         {
4092         case '/':
4093           if (slash_seen)
4094             if (index (&ufile[1], '/'))
4095               *targ++ = '.';
4096             else
4097               *targ++ = ']';
4098           else
4099             {
4100               *targ++ = ':';
4101               if (index (&ufile[1], '/'))
4102                 *targ++ = '[';
4103               slash_seen = 1;
4104             }
4105           break;
4106
4107         case '.':
4108           if (strncmp (ufile, "./", 2) == 0)
4109             {
4110               if (!slash_seen)
4111                 {
4112                   *targ++ = '[';
4113                   slash_seen = 1;
4114                 }
4115               ufile++;          /* skip the dot */
4116               if (index (&ufile[1], '/'))
4117                 *targ++ = '.';
4118               else
4119                 *targ++ = ']';
4120             }
4121           else if (strncmp (ufile, "../", 3) == 0)
4122             {
4123               if (!slash_seen)
4124                 {
4125                   *targ++ = '[';
4126                   slash_seen = 1;
4127                 }
4128               *targ++ = '-';
4129               ufile += 2;       /* skip the dots */
4130               if (index (&ufile[1], '/'))
4131                 *targ++ = '.';
4132               else
4133                 *targ++ = ']';
4134             }
4135           else
4136             *targ++ = *ufile;
4137           break;
4138
4139         default:
4140           *targ++ = *ufile;
4141           break;
4142         }
4143       ufile++;
4144     }
4145   *targ = '\0';
4146
4147   return utbuf;
4148 }
4149
4150 char *
4151 getwd (pathname)
4152      char *pathname;
4153 {
4154   char *ptr, *val;
4155   extern char *getcwd ();
4156
4157 #define MAXPATHLEN 1024
4158
4159   ptr = xmalloc (MAXPATHLEN);
4160   val = getcwd (ptr, MAXPATHLEN);
4161   if (val == 0)
4162     {
4163       xfree (ptr);
4164       return val;
4165     }
4166   strcpy (pathname, ptr);
4167   xfree (ptr);
4168
4169  return pathname;
4170 }
4171
4172 int
4173 getppid ()
4174 {
4175   long item_code = JPI$_OWNER;
4176   unsigned long parent_id;
4177   int status;
4178
4179   if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
4180     {
4181       errno = EVMSERR;
4182       vaxc$errno = status;
4183       return -1;
4184     }
4185   return parent_id;
4186 }
4187
4188 #undef getuid
4189 unsigned
4190 sys_getuid ()
4191 {
4192   return (getgid () << 16) | getuid ();
4193 }
4194
4195 #undef read
4196 int
4197 sys_read (fildes, buf, nbyte)
4198      int fildes;
4199      char *buf;
4200      unsigned int nbyte;
4201 {
4202   return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
4203 }
4204
4205 #if 0
4206 int
4207 sys_write (fildes, buf, nbyte)
4208      int fildes;
4209      char *buf;
4210      unsigned int nbyte;
4211 {
4212   register int nwrote, rtnval = 0;
4213
4214   while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
4215     nbyte -= nwrote;
4216     buf += nwrote;
4217     rtnval += nwrote;
4218   }
4219   if (nwrote < 0)
4220     return rtnval ? rtnval : -1;
4221   if ((nwrote = write (fildes, buf, nbyte)) < 0)
4222     return rtnval ? rtnval : -1;
4223   return (rtnval + nwrote);
4224 }
4225 #endif /* 0 */
4226
4227 /*
4228  *      VAX/VMS VAX C RTL really loses. It insists that records
4229  *      end with a newline (carriage return) character, and if they
4230  *      don't it adds one (nice of it isn't it!)
4231  *
4232  *      Thus we do this stupidity below.
4233  */
4234
4235 #undef write
4236 int
4237 sys_write (fildes, buf, nbytes)
4238      int fildes;
4239      char *buf;
4240      unsigned int nbytes;
4241 {
4242   register char *p;
4243   register char *e;
4244   int sum = 0;
4245   struct stat st;
4246
4247   fstat (fildes, &st);
4248   p = buf;
4249   while (nbytes > 0)
4250     {
4251       int len, retval;
4252
4253       /* Handle fixed-length files with carriage control.  */
4254       if (st.st_fab_rfm == FAB$C_FIX
4255           && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4256         {
4257           len = st.st_fab_mrs;
4258           retval = write (fildes, p, min (len, nbytes));
4259           if (retval != len)
4260             return -1;
4261           retval++;     /* This skips the implied carriage control */
4262         }
4263       else
4264         {
4265           e =  p + min (MAXIOSIZE, nbytes) - 1;
4266           while (*e != '\n' && e > p) e--;
4267           if (p == e)           /* Ok.. so here we add a newline... sigh. */
4268             e = p + min (MAXIOSIZE, nbytes) - 1;
4269           len = e + 1 - p;
4270           retval = write (fildes, p, len);
4271           if (retval != len)
4272             return -1;
4273         }
4274       p += retval;
4275       sum += retval;
4276       nbytes -= retval;
4277     }
4278   return sum;
4279 }
4280
4281 /* Create file NEW copying its attributes from file OLD.  If
4282    OLD is 0 or does not exist, create based on the value of
4283    vms_stmlf_recfm. */
4284
4285 /* Protection value the file should ultimately have.
4286    Set by create_copy_attrs, and use by rename_sansversions.  */
4287 static unsigned short int fab_final_pro;
4288
4289 int
4290 creat_copy_attrs (old, new)
4291      char *old, *new;
4292 {
4293   struct FAB fab = cc$rms_fab;
4294   struct XABPRO xabpro;
4295   char aclbuf[256];     /* Choice of size is arbitrary.  See below. */
4296   extern int vms_stmlf_recfm;
4297
4298   if (old)
4299     {
4300       fab.fab$b_fac = FAB$M_GET;
4301       fab.fab$l_fna = old;
4302       fab.fab$b_fns = strlen (old);
4303       fab.fab$l_xab = (char *) &xabpro;
4304       xabpro = cc$rms_xabpro;
4305       xabpro.xab$l_aclbuf = aclbuf;
4306       xabpro.xab$w_aclsiz = sizeof aclbuf;
4307       /* Call $OPEN to fill in the fab & xabpro fields. */
4308       if (SYS$OPEN (&fab, 0, 0) & 1)
4309         {
4310           SYS$CLOSE (&fab, 0, 0);
4311           fab.fab$l_alq = 0;    /* zero the allocation quantity */
4312           if (xabpro.xab$w_acllen > 0)
4313             {
4314               if (xabpro.xab$w_acllen > sizeof aclbuf)
4315                 /* If the acl buffer was too short, redo open with longer one.
4316                    Wouldn't need to do this if there were some system imposed
4317                    limit on the size of an ACL, but I can't find any such. */
4318                 {
4319                   xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
4320                   xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
4321                   if (SYS$OPEN (&fab, 0, 0) & 1)
4322                     SYS$CLOSE (&fab, 0, 0);
4323                   else
4324                     old = 0;
4325                 }
4326             }
4327           else
4328             xabpro.xab$l_aclbuf = 0;
4329         }
4330       else
4331         old = 0;
4332     }
4333   fab.fab$l_fna = new;
4334   fab.fab$b_fns = strlen (new);
4335   if (!old)
4336     {
4337       fab.fab$l_xab = 0;
4338       fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
4339       fab.fab$b_rat = FAB$M_CR;
4340     }
4341
4342   /* Set the file protections such that we will be able to manipulate
4343      this file.  Once we are done writing and renaming it, we will set
4344      the protections back.  */
4345   if (old)
4346     fab_final_pro = xabpro.xab$w_pro;
4347   else
4348     SYS$SETDFPROT (0, &fab_final_pro);
4349   xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
4350
4351   /* Create the new file with either default attrs or attrs copied
4352      from old file. */
4353   if (!(SYS$CREATE (&fab, 0, 0) & 1))
4354     return -1;
4355   SYS$CLOSE (&fab, 0, 0);
4356   /* As this is a "replacement" for creat, return a file descriptor
4357      opened for writing. */
4358   return open (new, O_WRONLY);
4359 }
4360
4361 #ifdef creat
4362 #undef creat
4363 #include <varargs.h>
4364 #ifdef __GNUC__
4365 #ifndef va_count
4366 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4367 #endif
4368 #endif
4369
4370 int
4371 sys_creat (va_alist)
4372      va_dcl
4373 {
4374   va_list list_incrementer;
4375   char *name;
4376   int mode;
4377   int rfd;                      /* related file descriptor */
4378   int fd;                       /* Our new file descriptor */
4379   int count;
4380   struct stat st_buf;
4381   char rfm[12];
4382   char rat[15];
4383   char mrs[13];
4384   char fsz[13];
4385   extern int vms_stmlf_recfm;
4386
4387   va_count (count);
4388   va_start (list_incrementer);
4389   name = va_arg (list_incrementer, char *);
4390   mode = va_arg (list_incrementer, int);
4391   if (count > 2)
4392     rfd = va_arg (list_incrementer, int);
4393   va_end (list_incrementer);
4394   if (count > 2)
4395     {
4396       /* Use information from the related file descriptor to set record
4397          format of the newly created file. */
4398       fstat (rfd, &st_buf);
4399       switch (st_buf.st_fab_rfm)
4400         {
4401         case FAB$C_FIX:
4402           strcpy (rfm, "rfm = fix");
4403           sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4404           strcpy (rat, "rat = ");
4405           if (st_buf.st_fab_rat & FAB$M_CR)
4406             strcat (rat, "cr");
4407           else if (st_buf.st_fab_rat & FAB$M_FTN)
4408             strcat (rat, "ftn");
4409           else if (st_buf.st_fab_rat & FAB$M_PRN)
4410             strcat (rat, "prn");
4411           if (st_buf.st_fab_rat & FAB$M_BLK)
4412             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4413               strcat (rat, ", blk");
4414             else
4415               strcat (rat, "blk");
4416           return creat (name, 0, rfm, rat, mrs);
4417
4418         case FAB$C_VFC:
4419           strcpy (rfm, "rfm = vfc");
4420           sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4421           strcpy (rat, "rat = ");
4422           if (st_buf.st_fab_rat & FAB$M_CR)
4423             strcat (rat, "cr");
4424           else if (st_buf.st_fab_rat & FAB$M_FTN)
4425             strcat (rat, "ftn");
4426           else if (st_buf.st_fab_rat & FAB$M_PRN)
4427             strcat (rat, "prn");
4428           if (st_buf.st_fab_rat & FAB$M_BLK)
4429             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4430               strcat (rat, ", blk");
4431             else
4432               strcat (rat, "blk");
4433           return creat (name, 0, rfm, rat, fsz);
4434
4435         case FAB$C_STM:
4436           strcpy (rfm, "rfm = stm");
4437           break;
4438
4439         case FAB$C_STMCR:
4440           strcpy (rfm, "rfm = stmcr");
4441           break;
4442
4443         case FAB$C_STMLF:
4444           strcpy (rfm, "rfm = stmlf");
4445           break;
4446
4447         case FAB$C_UDF:
4448           strcpy (rfm, "rfm = udf");
4449           break;
4450
4451         case FAB$C_VAR:
4452           strcpy (rfm, "rfm = var");
4453           break;
4454         }
4455       strcpy (rat, "rat = ");
4456       if (st_buf.st_fab_rat & FAB$M_CR)
4457         strcat (rat, "cr");
4458       else if (st_buf.st_fab_rat & FAB$M_FTN)
4459         strcat (rat, "ftn");
4460       else if (st_buf.st_fab_rat & FAB$M_PRN)
4461         strcat (rat, "prn");
4462       if (st_buf.st_fab_rat & FAB$M_BLK)
4463         if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4464           strcat (rat, ", blk");
4465         else
4466           strcat (rat, "blk");
4467     }
4468   else
4469     {
4470       strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4471       strcpy (rat, "rat=cr");
4472     }
4473   /* Until the VAX C RTL fixes the many bugs with modes, always use
4474      mode 0 to get the user's default protection. */
4475   fd = creat (name, 0, rfm, rat);
4476   if (fd < 0 && errno == EEXIST)
4477     {
4478       if (unlink (name) < 0)
4479         report_file_error ("delete", build_string (name));
4480       fd = creat (name, 0, rfm, rat);
4481     }
4482   return fd;
4483 }
4484 #endif /* creat */
4485
4486 /* fwrite to stdout is S L O W.  Speed it up by using fputc...*/
4487 int
4488 sys_fwrite (ptr, size, num, fp)
4489      register char * ptr;
4490      FILE * fp;
4491 {
4492   register int tot = num * size;
4493
4494   while (tot--)
4495     fputc (*ptr++, fp);
4496   return num;
4497 }
4498
4499 /*
4500  * The VMS C library routine creat actually creates a new version of an
4501  * existing file rather than truncating the old version.  There are times
4502  * when this is not the desired behavior, for instance, when writing an
4503  * auto save file (you only want one version), or when you don't have
4504  * write permission in the directory containing the file (but the file
4505  * itself is writable).  Hence this routine, which is equivalent to
4506  * "close (creat (fn, 0));" on Unix if fn already exists.
4507  */
4508 int
4509 vms_truncate (fn)
4510      char *fn;
4511 {
4512   struct FAB xfab = cc$rms_fab;
4513   struct RAB xrab = cc$rms_rab;
4514   int status;
4515
4516   xfab.fab$l_fop = FAB$M_TEF;   /* free allocated but unused blocks on close */
4517   xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4518   xfab.fab$b_shr = FAB$M_NIL;   /* allow no sharing - file must be locked */
4519   xfab.fab$l_fna = fn;
4520   xfab.fab$b_fns = strlen (fn);
4521   xfab.fab$l_dna = ";0";        /* default to latest version of the file */
4522   xfab.fab$b_dns = 2;
4523   xrab.rab$l_fab = &xfab;
4524
4525   /* This gibberish opens the file, positions to the first record, and
4526      deletes all records from there until the end of file. */
4527   if ((SYS$OPEN (&xfab) & 01) == 01)
4528     {
4529       if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4530           (SYS$FIND (&xrab) & 01) == 01 &&
4531           (SYS$TRUNCATE (&xrab) & 01) == 01)
4532         status = 0;
4533       else
4534         status = -1;
4535     }
4536   else
4537     status = -1;
4538   SYS$CLOSE (&xfab);
4539   return status;
4540 }
4541
4542 /* Define this symbol to actually read SYSUAF.DAT.  This requires either
4543    SYSPRV or a readable SYSUAF.DAT. */
4544
4545 #ifdef READ_SYSUAF
4546 /*
4547  * getuaf.c
4548  *
4549  * Routine to read the VMS User Authorization File and return
4550  * a specific user's record.
4551  */
4552
4553 static struct UAF retuaf;
4554
4555 struct UAF *
4556 get_uaf_name (uname)
4557      char * uname;
4558 {
4559   register status;
4560   struct FAB uaf_fab;
4561   struct RAB uaf_rab;
4562
4563   uaf_fab = cc$rms_fab;
4564   uaf_rab = cc$rms_rab;
4565   /* initialize fab fields */
4566   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4567   uaf_fab.fab$b_fns = 21;
4568   uaf_fab.fab$b_fac = FAB$M_GET;
4569   uaf_fab.fab$b_org = FAB$C_IDX;
4570   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4571   /* initialize rab fields */
4572   uaf_rab.rab$l_fab = &uaf_fab;
4573   /* open the User Authorization File */
4574   status = SYS$OPEN (&uaf_fab);
4575   if (!(status&1))
4576     {
4577       errno = EVMSERR;
4578       vaxc$errno = status;
4579       return 0;
4580     }
4581   status = SYS$CONNECT (&uaf_rab);
4582   if (!(status&1))
4583     {
4584       errno = EVMSERR;
4585       vaxc$errno = status;
4586       return 0;
4587     }
4588   /* read the requested record - index is in uname */
4589   uaf_rab.rab$l_kbf = uname;
4590   uaf_rab.rab$b_ksz = strlen (uname);
4591   uaf_rab.rab$b_rac = RAB$C_KEY;
4592   uaf_rab.rab$l_ubf = (char *)&retuaf;
4593   uaf_rab.rab$w_usz = sizeof retuaf;
4594   status = SYS$GET (&uaf_rab);
4595   if (!(status&1))
4596     {
4597       errno = EVMSERR;
4598       vaxc$errno = status;
4599       return 0;
4600     }
4601   /* close the User Authorization File */
4602   status = SYS$DISCONNECT (&uaf_rab);
4603   if (!(status&1))
4604     {
4605       errno = EVMSERR;
4606       vaxc$errno = status;
4607       return 0;
4608     }
4609   status = SYS$CLOSE (&uaf_fab);
4610   if (!(status&1))
4611     {
4612       errno = EVMSERR;
4613       vaxc$errno = status;
4614       return 0;
4615     }
4616   return &retuaf;
4617 }
4618
4619 struct UAF *
4620 get_uaf_uic (uic)
4621      unsigned long uic;
4622 {
4623   register status;
4624   struct FAB uaf_fab;
4625   struct RAB uaf_rab;
4626
4627   uaf_fab = cc$rms_fab;
4628   uaf_rab = cc$rms_rab;
4629   /* initialize fab fields */
4630   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4631   uaf_fab.fab$b_fns = 21;
4632   uaf_fab.fab$b_fac = FAB$M_GET;
4633   uaf_fab.fab$b_org = FAB$C_IDX;
4634   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4635   /* initialize rab fields */
4636   uaf_rab.rab$l_fab = &uaf_fab;
4637   /* open the User Authorization File */
4638   status = SYS$OPEN (&uaf_fab);
4639   if (!(status&1))
4640     {
4641       errno = EVMSERR;
4642       vaxc$errno = status;
4643       return 0;
4644     }
4645   status = SYS$CONNECT (&uaf_rab);
4646   if (!(status&1))
4647     {
4648       errno = EVMSERR;
4649       vaxc$errno = status;
4650       return 0;
4651     }
4652   /* read the requested record - index is in uic */
4653   uaf_rab.rab$b_krf = 1;        /* 1st alternate key */
4654   uaf_rab.rab$l_kbf = (char *) &uic;
4655   uaf_rab.rab$b_ksz = sizeof uic;
4656   uaf_rab.rab$b_rac = RAB$C_KEY;
4657   uaf_rab.rab$l_ubf = (char *)&retuaf;
4658   uaf_rab.rab$w_usz = sizeof retuaf;
4659   status = SYS$GET (&uaf_rab);
4660   if (!(status&1))
4661     {
4662       errno = EVMSERR;
4663       vaxc$errno = status;
4664       return 0;
4665     }
4666   /* close the User Authorization File */
4667   status = SYS$DISCONNECT (&uaf_rab);
4668   if (!(status&1))
4669     {
4670       errno = EVMSERR;
4671       vaxc$errno = status;
4672       return 0;
4673     }
4674   status = SYS$CLOSE (&uaf_fab);
4675   if (!(status&1))
4676     {
4677       errno = EVMSERR;
4678       vaxc$errno = status;
4679       return 0;
4680     }
4681   return &retuaf;
4682 }
4683
4684 static struct passwd retpw;
4685
4686 struct passwd *
4687 cnv_uaf_pw (up)
4688      struct UAF * up;
4689 {
4690   char * ptr;
4691
4692   /* copy these out first because if the username is 32 chars, the next
4693      section will overwrite the first byte of the UIC */
4694   retpw.pw_uid = up->uaf$w_mem;
4695   retpw.pw_gid = up->uaf$w_grp;
4696
4697   /* I suppose this is not the best style, to possibly overwrite one
4698      byte beyond the end of the field, but what the heck... */
4699   ptr = &up->uaf$t_username[UAF$S_USERNAME];
4700   while (ptr[-1] == ' ')
4701     ptr--;
4702   *ptr = '\0';
4703   strcpy (retpw.pw_name, up->uaf$t_username);
4704
4705   /* the rest of these are counted ascii strings */
4706   strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4707   retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4708   strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4709   retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4710   strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4711   retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4712   strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4713   retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4714
4715   return &retpw;
4716 }
4717 #else /* not READ_SYSUAF */
4718 static struct passwd retpw;
4719 #endif /* not READ_SYSUAF */
4720
4721 struct passwd *
4722 getpwnam (name)
4723      char * name;
4724 {
4725 #ifdef READ_SYSUAF
4726   struct UAF *up;
4727 #else
4728   char * user;
4729   char * dir;
4730   unsigned char * full;
4731 #endif /* READ_SYSUAF */
4732   char *ptr = name;
4733
4734   while (*ptr)
4735     {
4736       if ('a' <= *ptr && *ptr <= 'z')
4737         *ptr -= 040;
4738       ptr++;
4739     }
4740 #ifdef READ_SYSUAF
4741   if (!(up = get_uaf_name (name)))
4742     return 0;
4743   return cnv_uaf_pw (up);
4744 #else
4745   if (strcmp (name, getenv ("USER")) == 0)
4746     {
4747       retpw.pw_uid = getuid ();
4748       retpw.pw_gid = getgid ();
4749       strcpy (retpw.pw_name, name);
4750       if (full = egetenv ("FULLNAME"))
4751         strcpy (retpw.pw_gecos, full);
4752       else
4753         *retpw.pw_gecos = '\0';
4754       strcpy (retpw.pw_dir, egetenv ("HOME"));
4755       *retpw.pw_shell = '\0';
4756       return &retpw;
4757     }
4758   else
4759     return 0;
4760 #endif /* not READ_SYSUAF */
4761 }
4762
4763 struct passwd *
4764 getpwuid (uid)
4765      unsigned long uid;
4766 {
4767 #ifdef READ_SYSUAF
4768   struct UAF * up;
4769
4770   if (!(up = get_uaf_uic (uid)))
4771     return 0;
4772   return cnv_uaf_pw (up);
4773 #else
4774   if (uid == sys_getuid ())
4775     return getpwnam (egetenv ("USER"));
4776   else
4777     return 0;
4778 #endif /* not READ_SYSUAF */
4779 }
4780
4781 /* return total address space available to the current process.  This is
4782    the sum of the current p0 size, p1 size and free page table entries
4783    available. */
4784 int
4785 vlimit ()
4786 {
4787   int item_code;
4788   unsigned long free_pages;
4789   unsigned long frep0va;
4790   unsigned long frep1va;
4791   register status;
4792
4793   item_code = JPI$_FREPTECNT;
4794   if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4795     {
4796       errno = EVMSERR;
4797       vaxc$errno = status;
4798       return -1;
4799     }
4800   free_pages *= 512;
4801
4802   item_code = JPI$_FREP0VA;
4803   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4804     {
4805       errno = EVMSERR;
4806       vaxc$errno = status;
4807       return -1;
4808     }
4809   item_code = JPI$_FREP1VA;
4810   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4811     {
4812       errno = EVMSERR;
4813       vaxc$errno = status;
4814       return -1;
4815     }
4816
4817   return free_pages + frep0va + (0x7fffffff - frep1va);
4818 }
4819
4820 int
4821 define_logical_name (varname, string)
4822      char *varname;
4823      char *string;
4824 {
4825   struct dsc$descriptor_s strdsc =
4826     {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
4827   struct dsc$descriptor_s envdsc =
4828     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4829   struct dsc$descriptor_s lnmdsc =
4830     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4831
4832   return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4833 }
4834
4835 int
4836 delete_logical_name (varname)
4837      char *varname;
4838 {
4839   struct dsc$descriptor_s envdsc =
4840     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4841   struct dsc$descriptor_s lnmdsc =
4842     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4843
4844   return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4845 }
4846
4847 int
4848 ulimit ()
4849 {
4850   return 0;
4851 }
4852
4853 int
4854 setpgrp ()
4855 {
4856   return 0;
4857 }
4858
4859 int
4860 execvp ()
4861 {
4862   error ("execvp system call not implemented");
4863   return -1;
4864 }
4865
4866 int
4867 rename (from, to)
4868      char *from, *to;
4869 {
4870   int status;
4871   struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4872   struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4873   char from_esn[NAM$C_MAXRSS];
4874   char to_esn[NAM$C_MAXRSS];
4875
4876   from_fab.fab$l_fna = from;
4877   from_fab.fab$b_fns = strlen (from);
4878   from_fab.fab$l_nam = &from_nam;
4879   from_fab.fab$l_fop = FAB$M_NAM;
4880
4881   from_nam.nam$l_esa = from_esn;
4882   from_nam.nam$b_ess = sizeof from_esn;
4883
4884   to_fab.fab$l_fna = to;
4885   to_fab.fab$b_fns = strlen (to);
4886   to_fab.fab$l_nam = &to_nam;
4887   to_fab.fab$l_fop = FAB$M_NAM;
4888
4889   to_nam.nam$l_esa = to_esn;
4890   to_nam.nam$b_ess = sizeof to_esn;
4891
4892   status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4893
4894   if (status & 1)
4895     return 0;
4896   else
4897     {
4898       if (status == RMS$_DEV)
4899         errno = EXDEV;
4900       else
4901         errno = EVMSERR;
4902       vaxc$errno = status;
4903       return -1;
4904     }
4905 }
4906
4907 /* This function renames a file like `rename', but it strips
4908    the version number from the "to" filename, such that the "to" file is
4909    will always be a new version.  It also sets the file protection once it is
4910    finished.  The protection that we will use is stored in fab_final_pro,
4911    and was set when we did a creat_copy_attrs to create the file that we
4912    are renaming.
4913
4914    We could use the chmod function, but Eunichs uses 3 bits per user category
4915    to describe the protection, and VMS uses 4 (write and delete are separate
4916    bits).  To maintain portability, the VMS implementation of `chmod' wires
4917    the W and D bits together.  */
4918
4919
4920 static struct fibdef fib;       /* We need this initialized to zero */
4921 char vms_file_written[NAM$C_MAXRSS];
4922
4923 int
4924 rename_sans_version (from,to)
4925      char *from, *to;
4926 {
4927   short int chan;
4928   int stat;
4929   short int iosb[4];
4930   int status;
4931   struct FAB to_fab = cc$rms_fab;
4932   struct NAM to_nam = cc$rms_nam;
4933   struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4934   struct dsc$descriptor fib_attr[2]
4935     = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4936   char to_esn[NAM$C_MAXRSS];
4937
4938   $DESCRIPTOR (disk,to_esn);
4939
4940   to_fab.fab$l_fna = to;
4941   to_fab.fab$b_fns = strlen (to);
4942   to_fab.fab$l_nam = &to_nam;
4943   to_fab.fab$l_fop = FAB$M_NAM;
4944
4945   to_nam.nam$l_esa = to_esn;
4946   to_nam.nam$b_ess = sizeof to_esn;
4947
4948   status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4949
4950   if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4951     *(to_nam.nam$l_ver) = '\0';
4952
4953   stat = rename (from, to_esn);
4954   if (stat < 0)
4955     return stat;
4956
4957   strcpy (vms_file_written, to_esn);
4958
4959   to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4960   to_fab.fab$b_fns = strlen (vms_file_written);
4961
4962   /* Now set the file protection to the correct value */
4963   SYS$OPEN (&to_fab, 0, 0);     /* This fills in the nam$w_fid fields */
4964
4965   /* Copy these fields into the fib */
4966   fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4967   fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4968   fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4969
4970   SYS$CLOSE (&to_fab, 0, 0);
4971
4972   stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
4973   if (!stat)
4974     LIB$SIGNAL (stat);
4975   stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4976                    0, 0, 0, &fib_attr, 0);
4977   if (!stat)
4978     LIB$SIGNAL (stat);
4979   stat = SYS$DASSGN (chan);
4980   if (!stat)
4981     LIB$SIGNAL (stat);
4982   strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
4983   return 0;
4984 }
4985
4986 int
4987 link (file, new)
4988      char * file, * new;
4989 {
4990   register status;
4991   struct FAB fab;
4992   struct NAM nam;
4993   unsigned short fid[3];
4994   char esa[NAM$C_MAXRSS];
4995
4996   fab = cc$rms_fab;
4997   fab.fab$l_fop = FAB$M_OFP;
4998   fab.fab$l_fna = file;
4999   fab.fab$b_fns = strlen (file);
5000   fab.fab$l_nam = &nam;
5001
5002   nam = cc$rms_nam;
5003   nam.nam$l_esa = esa;
5004   nam.nam$b_ess = NAM$C_MAXRSS;
5005
5006   status = SYS$PARSE (&fab);
5007   if ((status & 1) == 0)
5008     {
5009       errno = EVMSERR;
5010       vaxc$errno = status;
5011       return -1;
5012     }
5013   status = SYS$SEARCH (&fab);
5014   if ((status & 1) == 0)
5015     {
5016       errno = EVMSERR;
5017       vaxc$errno = status;
5018       return -1;
5019     }
5020
5021   fid[0] = nam.nam$w_fid[0];
5022   fid[1] = nam.nam$w_fid[1];
5023   fid[2] = nam.nam$w_fid[2];
5024
5025   fab.fab$l_fna = new;
5026   fab.fab$b_fns = strlen (new);
5027
5028   status = SYS$PARSE (&fab);
5029   if ((status & 1) == 0)
5030     {
5031       errno = EVMSERR;
5032       vaxc$errno = status;
5033       return -1;
5034     }
5035
5036   nam.nam$w_fid[0] = fid[0];
5037   nam.nam$w_fid[1] = fid[1];
5038   nam.nam$w_fid[2] = fid[2];
5039
5040   nam.nam$l_esa = nam.nam$l_name;
5041   nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
5042
5043   status = SYS$ENTER (&fab);
5044   if ((status & 1) == 0)
5045     {
5046       errno = EVMSERR;
5047       vaxc$errno = status;
5048       return -1;
5049     }
5050
5051   return 0;
5052 }
5053
5054 void
5055 croak (badfunc)
5056      char *badfunc;
5057 {
5058   printf ("%s not yet implemented\r\n", badfunc);
5059   reset_sys_modes ();
5060   exit (1);
5061 }
5062
5063 long
5064 random ()
5065 {
5066   /* Arrange to return a range centered on zero.  */
5067   return rand () - (1 << 30);
5068 }
5069
5070 void
5071 srandom (seed)
5072 {
5073   srand (seed);
5074 }
5075 #endif /* VMS */
5076 \f
5077 #ifdef AIXHFT
5078
5079 /* Called from init_sys_modes.  */
5080 void
5081 hft_init ()
5082 {
5083   int junk;
5084
5085   /* If we're not on an HFT we shouldn't do any of this.  We determine
5086      if we are on an HFT by trying to get an HFT error code.  If this
5087      call fails, we're not on an HFT. */
5088 #ifdef IBMR2AIX
5089   if (ioctl (0, HFQERROR, &junk) < 0)
5090     return;
5091 #else /* not IBMR2AIX */
5092   if (ioctl (0, HFQEIO, 0) < 0)
5093     return;
5094 #endif /* not IBMR2AIX */
5095
5096   /* On AIX the default hft keyboard mapping uses backspace rather than delete
5097      as the rubout key's ASCII code.  Here this is changed.  The bug is that
5098      there's no way to determine the old mapping, so in reset_sys_modes
5099      we need to assume that the normal map had been present.  Of course, this
5100      code also doesn't help if on a terminal emulator which doesn't understand
5101      HFT VTD's.  */
5102   {
5103     struct hfbuf buf;
5104     struct hfkeymap keymap;
5105
5106     buf.hf_bufp = (char *)&keymap;
5107     buf.hf_buflen = sizeof (keymap);
5108     keymap.hf_nkeys = 2;
5109     keymap.hfkey[0].hf_kpos = 15;
5110     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
5111 #ifdef IBMR2AIX
5112     keymap.hfkey[0].hf_keyidh = '<';
5113 #else /* not IBMR2AIX */
5114     keymap.hfkey[0].hf_page = '<';
5115 #endif /* not IBMR2AIX */
5116     keymap.hfkey[0].hf_char = 127;
5117     keymap.hfkey[1].hf_kpos = 15;
5118     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
5119 #ifdef IBMR2AIX
5120     keymap.hfkey[1].hf_keyidh = '<';
5121 #else /* not IBMR2AIX */
5122     keymap.hfkey[1].hf_page = '<';
5123 #endif /* not IBMR2AIX */
5124     keymap.hfkey[1].hf_char = 127;
5125     hftctl (0, HFSKBD, &buf);
5126   }
5127   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
5128      at times.  */
5129   line_ins_del_ok = char_ins_del_ok = 0;
5130 }
5131
5132 /* Reset the rubout key to backspace.  */
5133
5134 void
5135 hft_reset ()
5136 {
5137   struct hfbuf buf;
5138   struct hfkeymap keymap;
5139   int junk;
5140
5141 #ifdef IBMR2AIX
5142   if (ioctl (0, HFQERROR, &junk) < 0)
5143     return;
5144 #else /* not IBMR2AIX */
5145   if (ioctl (0, HFQEIO, 0) < 0)
5146     return;
5147 #endif /* not IBMR2AIX */
5148
5149   buf.hf_bufp = (char *)&keymap;
5150   buf.hf_buflen = sizeof (keymap);
5151   keymap.hf_nkeys = 2;
5152   keymap.hfkey[0].hf_kpos = 15;
5153   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
5154 #ifdef IBMR2AIX
5155   keymap.hfkey[0].hf_keyidh = '<';
5156 #else /* not IBMR2AIX */
5157   keymap.hfkey[0].hf_page = '<';
5158 #endif /* not IBMR2AIX */
5159   keymap.hfkey[0].hf_char = 8;
5160   keymap.hfkey[1].hf_kpos = 15;
5161   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
5162 #ifdef IBMR2AIX
5163   keymap.hfkey[1].hf_keyidh = '<';
5164 #else /* not IBMR2AIX */
5165   keymap.hfkey[1].hf_page = '<';
5166 #endif /* not IBMR2AIX */
5167   keymap.hfkey[1].hf_char = 8;
5168   hftctl (0, HFSKBD, &buf);
5169 }
5170
5171 #endif /* AIXHFT */
5172
5173 #ifdef USE_DL_STUBS
5174
5175 /* These are included on Sunos 4.1 when we do not use shared libraries.
5176    X11 libraries may refer to these functions but (we hope) do not
5177    actually call them.  */
5178
5179 void *
5180 dlopen ()
5181 {
5182   return 0;
5183 }
5184
5185 void *
5186 dlsym ()
5187 {
5188   return 0;
5189 }
5190
5191 int
5192 dlclose ()
5193 {
5194   return -1;
5195 }
5196
5197 #endif /* USE_DL_STUBS */
5198 \f
5199 #ifndef BSTRING
5200
5201 #ifndef bzero
5202
5203 void
5204 bzero (b, length)
5205      register char *b;
5206      register int length;
5207 {
5208 #ifdef VMS
5209   short zero = 0;
5210   long max_str = 65535;
5211
5212   while (length > max_str) {
5213     (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
5214     length -= max_str;
5215     b += max_str;
5216   }
5217   max_str = length;
5218   (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
5219 #else
5220   while (length-- > 0)
5221     *b++ = 0;
5222 #endif /* not VMS */
5223 }
5224
5225 #endif /* no bzero */
5226 #endif /* BSTRING */
5227
5228 #if (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY)
5229 #undef bcopy
5230
5231 /* Saying `void' requires a declaration, above, where bcopy is used
5232    and that declaration causes pain for systems where bcopy is a macro.  */
5233 bcopy (b1, b2, length)
5234      register char *b1;
5235      register char *b2;
5236      register int length;
5237 {
5238 #ifdef VMS
5239   long max_str = 65535;
5240
5241   while (length > max_str) {
5242     (void) LIB$MOVC3 (&max_str, b1, b2);
5243     length -= max_str;
5244     b1 += max_str;
5245     b2 += max_str;
5246   }
5247   max_str = length;
5248   (void) LIB$MOVC3 (&length, b1, b2);
5249 #else
5250   while (length-- > 0)
5251     *b2++ = *b1++;
5252 #endif /* not VMS */
5253 }
5254 #endif /* (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY) */
5255
5256 #ifndef BSTRING
5257 #ifndef bcmp
5258 int
5259 bcmp (b1, b2, length)   /* This could be a macro! */
5260      register char *b1;
5261      register char *b2;
5262      register int length;
5263 {
5264 #ifdef VMS
5265   struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
5266   struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
5267
5268   return STR$COMPARE (&src1, &src2);
5269 #else
5270   while (length-- > 0)
5271     if (*b1++ != *b2++)
5272       return 1;
5273
5274   return 0;
5275 #endif /* not VMS */
5276 }
5277 #endif /* no bcmp */
5278 #endif /* not BSTRING */
5279 \f
5280 #ifndef HAVE_STRSIGNAL
5281 char *
5282 strsignal (code)
5283      int code;
5284 {
5285   char *signame = 0;
5286
5287   if (0 <= code && code < NSIG)
5288     {
5289 #ifdef VMS
5290       signame = sys_errlist[code];
5291 #else
5292       /* Cast to suppress warning if the table has const char *.  */
5293       signame = (char *) sys_siglist[code];
5294 #endif
5295     }
5296
5297   return signame;
5298 }
5299 #endif /* HAVE_STRSIGNAL */
5300
5301 /* arch-tag: edb43589-4e09-4544-b325-978b5b121dcf
5302    (do not change this comment) */