src/sysdep.c

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