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