src/sysdep.c

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