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