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, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include <signal.h>
  23 #include <setjmp.h>
  24
  25 #include <config.h>
  26 #ifdef STDC_HEADERS
  27 #include <stdlib.h>
  28 #endif
  29 #include "lisp.h"
  30 #include "blockinput.h"
  31 #undef NULL
  32
  33 #ifdef macintosh
  34 #ifdef __MRC__
  35 __sigfun sys_signal (int signal, __sigfun signal_func);
  36 #elif __MWERKS__
  37 __signal_func_ptr sys_signal (int signal, __signal_func_ptr signal_func);
  38 #else
  39 You lose!!!
  40 #endif
  41 #ifndef subprocesses
  42 /* Nonzero means delete a process right away if it exits (process.c).  */
  43 static int delete_exited_processes;
  44 #endif
  45 #ifndef HAVE_X_WINDOWS
  46 /* Search path for bitmap files (xfns.c).  */
  47 Lisp_Object Vx_bitmap_file_path;
  48 #endif
  49 #endif  /* macintosh */
  50
  51 #define min(x,y) ((x) > (y) ? (y) : (x))
  52
  53 /* In this file, open, read and write refer to the system calls,
  54    not our sugared interfaces  sys_open, sys_read and sys_write.
  55    Contrariwise, for systems where we use the system calls directly,
  56    define sys_read, etc. here as aliases for them.  */
  57 #ifndef read
  58 #define sys_read read
  59 #define sys_write write
  60 #endif /* `read' is not a macro */
  61
  62 #undef read
  63 #undef write
  64
  65 #ifdef WINDOWSNT
  66 #define read _read
  67 #define write _write
  68 #include <windows.h>
  69 extern int errno;
  70 #endif /* not WINDOWSNT */
  71
  72 #ifndef close
  73 #define sys_close close
  74 #else
  75 #undef close
  76 #endif
  77
  78 #ifndef open
  79 #define sys_open open
  80 #else /* `open' is a macro */
  81 #undef open
  82 #endif /* `open' is a macro */
  83
  84 /* Does anyone other than VMS need this? */
  85 #ifndef fwrite
  86 #define sys_fwrite fwrite
  87 #else
  88 #undef fwrite
  89 #endif
  90
  91 #ifndef HAVE_H_ERRNO
  92 extern int h_errno;
  93 #endif
  94
  95 #include <stdio.h>
  96 #include <sys/types.h>
  97 #include <sys/stat.h>
  98 #include <errno.h>
  99
 100 /* Get _POSIX_VDISABLE, if it is available.  */
 101 #ifdef HAVE_UNISTD_H
 102 #include <unistd.h>
 103 #endif
 104
 105 /* Get SI_SRPC_DOMAIN, if it is available.  */
 106 #ifdef HAVE_SYS_SYSTEMINFO_H
 107 #include <sys/systeminfo.h>
 108 #endif
 109
 110 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
 111 #include <dos.h>
 112 #include "dosfns.h"
 113 #include "msdos.h"
 114 #include <sys/param.h>
 115
 116 #if __DJGPP__ > 1
 117 extern int etext;
 118 extern unsigned start __asm__ ("start");
 119 #endif
 120 #endif
 121
 122 #ifndef errno
 123 extern int errno;
 124 #endif
 125
 126 #ifdef VMS
 127 #include <rms.h>
 128 #include <ttdef.h>
 129 #include <tt2def.h>
 130 #include <iodef.h>
 131 #include <ssdef.h>
 132 #include <descrip.h>
 133 #include <fibdef.h>
 134 #include <atrdef.h>
 135 #include <ctype.h>
 136 #include <string.h>
 137 #ifdef __GNUC__
 138 #include <sys/file.h>
 139 #else
 140 #include <file.h>
 141 #endif
 142 #undef F_SETFL
 143 #ifndef RAB$C_BID
 144 #include <rab.h>
 145 #endif
 146 #define MAXIOSIZE (32 * PAGESIZE) /* Don't I/O more than 32 blocks at a time */
 147 #endif /* VMS */
 148
 149 #ifndef BSD4_1
 150 #ifdef BSD_SYSTEM /* avoid writing defined (BSD_SYSTEM) || defined (USG)
 151               because the vms compiler doesn't grok `defined' */
 152 #include <fcntl.h>
 153 #endif
 154 #ifdef USG
 155 #ifndef USG5
 156 #include <fcntl.h>
 157 #endif
 158 #endif
 159 #endif /* not 4.1 bsd */
 160
 161 #ifndef MSDOS
 162 #include <sys/ioctl.h>
 163 #endif
 164
 165 #include "systty.h"
 166 #include "syswait.h"
 167
 168 #ifdef BROKEN_TIOCGWINSZ
 169 #undef TIOCGWINSZ
 170 #undef TIOCSWINSZ
 171 #endif
 172
 173 #if defined (USG) || defined (DGUX)
 174 #include <sys/utsname.h>
 175 #include <string.h>
 176 #ifndef MEMORY_IN_STRING_H
 177 #include <memory.h>
 178 #endif
 179 #if defined (TIOCGWINSZ) || defined (ISC4_0)
 180 #ifdef NEED_SIOCTL
 181 #include <sys/sioctl.h>
 182 #endif
 183 #ifdef NEED_PTEM_H
 184 #include <sys/stream.h>
 185 #include <sys/ptem.h>
 186 #endif
 187 #endif /* TIOCGWINSZ or ISC4_0 */
 188 #endif /* USG or DGUX */
 189
 190 extern int quit_char;
 191
 192 #include "frame.h"
 193 #include "window.h"
 194 #include "termhooks.h"
 195 #include "termchar.h"
 196 #include "termopts.h"
 197 #include "dispextern.h"
 198 #include "process.h"
 199
 200 #ifdef WINDOWSNT
 201 #include <direct.h>
 202 /* In process.h which conflicts with the local copy.  */
 203 #define _P_WAIT 0
 204 int _CRTAPI1 _spawnlp (int, const char *, const char *, ...);
 205 int _CRTAPI1 _getpid (void);
 206 #endif
 207
 208 #ifdef NONSYSTEM_DIR_LIBRARY
 209 #include "ndir.h"
 210 #endif /* NONSYSTEM_DIR_LIBRARY */
 211
 212 #include "syssignal.h"
 213 #include "systime.h"
 214 #ifdef HAVE_UTIME_H
 215 #include <utime.h>
 216 #endif
 217
 218 #ifndef HAVE_UTIMES
 219 #ifndef HAVE_STRUCT_UTIMBUF
 220 /* We want to use utime rather than utimes, but we couldn't find the
 221    structure declaration.  We'll use the traditional one.  */
 222 struct utimbuf {
 223   long actime;
 224   long modtime;
 225 };
 226 #endif
 227 #endif
 228
 229 #ifndef VFORK_RETURN_TYPE
 230 #define VFORK_RETURN_TYPE int
 231 #endif
 232
 233 /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits.  */
 234 #ifndef LPASS8
 235 #define LPASS8 0
 236 #endif
 237
 238 #ifdef BSD4_1
 239 #define LNOFLSH 0100000
 240 #endif
 241
 242 static int baud_convert[] =
 243 #ifdef BAUD_CONVERT
 244   BAUD_CONVERT;
 245 #else
 246   {
 247     0, 50, 75, 110, 135, 150, 200, 300, 600, 1200,
 248     1800, 2400, 4800, 9600, 19200, 38400
 249   };
 250 #endif
 251
 252 #if defined (HAVE_LIBNCURSES) && ! defined (NCURSES_OSPEED_T)
 253 extern short ospeed;
 254 #else
 255 #if defined (HAVE_TERMIOS_H) && defined (LINUX)
 256 #include <termios.h>
 257 /* HJL's version of libc is said to need this on the Alpha.
 258    On the other hand, DEC OSF1 on the Alpha needs ospeed to be a short.  */
 259 extern speed_t ospeed;
 260 #else
 261 extern short ospeed;
 262 #endif
 263 #endif
 264
 265 /* The file descriptor for Emacs's input terminal.
 266    Under Unix, this is normally zero except when using X;
 267    under VMS, we place the input channel number here.  */
 268 int input_fd;
 269
 270 void croak P_ ((char *));
 271
 272 #ifdef AIXHFT
 273 void hft_init ();
 274 void hft_reset ();
 275 #endif
 276
 277 \f
 278 /* Specify a different file descriptor for further input operations.  */
 279
 280 void
 281 change_input_fd (fd)
 282      int fd;
 283 {
 284   input_fd = fd;
 285 }
 286
 287 /* Discard pending input on descriptor input_fd.  */
 288
 289 void
 290 discard_tty_input ()
 291 {
 292 #ifndef WINDOWSNT
 293   struct emacs_tty buf;
 294
 295   if (noninteractive)
 296     return;
 297
 298   /* Discarding input is not safe when the input could contain
 299      replies from the X server.  So don't do it.  */
 300   if (read_socket_hook)
 301     return;
 302
 303 #ifdef VMS
 304   end_kbd_input ();
 305   SYS$QIOW (0, input_fd, IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
 306             &buf.main, 0, 0, terminator_mask, 0, 0);
 307   queue_kbd_input ();
 308 #else /* not VMS */
 309 #ifdef APOLLO
 310   {
 311     int zero = 0;
 312     ioctl (input_fd, TIOCFLUSH, &zero);
 313   }
 314 #else /* not Apollo */
 315 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
 316   while (dos_keyread () != -1)
 317     ;
 318 #else /* not MSDOS */
 319   EMACS_GET_TTY (input_fd, &buf);
 320   EMACS_SET_TTY (input_fd, &buf, 0);
 321 #endif /* not MSDOS */
 322 #endif /* not Apollo */
 323 #endif /* not VMS */
 324 #endif /* not WINDOWSNT */
 325 }
 326
 327 #ifdef SIGTSTP
 328
 329 /* Arrange for character C to be read as the next input from
 330    the terminal.  */
 331
 332 void
 333 stuff_char (c)
 334      char c;
 335 {
 336   if (read_socket_hook)
 337     return;
 338
 339 /* Should perhaps error if in batch mode */
 340 #ifdef TIOCSTI
 341   ioctl (input_fd, TIOCSTI, &c);
 342 #else /* no TIOCSTI */
 343   error ("Cannot stuff terminal input characters in this version of Unix");
 344 #endif /* no TIOCSTI */
 345 }
 346
 347 #endif /* SIGTSTP */
 348 \f
 349 void
 350 init_baud_rate ()
 351 {
 352   if (noninteractive)
 353     ospeed = 0;
 354   else
 355     {
 356 #ifdef INIT_BAUD_RATE
 357       INIT_BAUD_RATE ();
 358 #else
 359 #ifdef DOS_NT
 360     ospeed = 15;
 361 #else  /* not DOS_NT */
 362 #ifdef VMS
 363       struct sensemode sg;
 364
 365       SYS$QIOW (0, input_fd, IO$_SENSEMODE, &sg, 0, 0,
 366                 &sg.class, 12, 0, 0, 0, 0 );
 367       ospeed = sg.xmit_baud;
 368 #else /* not VMS */
 369 #ifdef HAVE_TERMIOS
 370       struct termios sg;
 371
 372       sg.c_cflag = B9600;
 373       tcgetattr (input_fd, &sg);
 374       ospeed = cfgetospeed (&sg);
 375 #if defined (USE_GETOBAUD) && defined (getobaud)
 376       /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
 377       if (ospeed == 0)
 378         ospeed = getobaud (sg.c_cflag);
 379 #endif
 380 #else /* neither VMS nor TERMIOS */
 381 #ifdef HAVE_TERMIO
 382       struct termio sg;
 383
 384       sg.c_cflag = B9600;
 385 #ifdef HAVE_TCATTR
 386       tcgetattr (input_fd, &sg);
 387 #else
 388       ioctl (input_fd, TCGETA, &sg);
 389 #endif
 390       ospeed = sg.c_cflag & CBAUD;
 391 #else /* neither VMS nor TERMIOS nor TERMIO */
 392       struct sgttyb sg;
 393
 394       sg.sg_ospeed = B9600;
 395       if (ioctl (input_fd, TIOCGETP, &sg) < 0)
 396         abort ();
 397       ospeed = sg.sg_ospeed;
 398 #endif /* not HAVE_TERMIO */
 399 #endif /* not HAVE_TERMIOS */
 400 #endif /* not VMS */
 401 #endif /* not DOS_NT */
 402 #endif /* not INIT_BAUD_RATE */
 403     }
 404
 405   baud_rate = (ospeed < sizeof baud_convert / sizeof baud_convert[0]
 406                ? baud_convert[ospeed] : 9600);
 407   if (baud_rate == 0)
 408     baud_rate = 1200;
 409 }
 410
 411 /*ARGSUSED*/
 412 void
 413 set_exclusive_use (fd)
 414      int fd;
 415 {
 416 #ifdef FIOCLEX
 417   ioctl (fd, FIOCLEX, 0);
 418 #endif
 419   /* Ok to do nothing if this feature does not exist */
 420 }
 421 \f
 422 #ifndef subprocesses
 423
 424 wait_without_blocking ()
 425 {
 426 #ifdef BSD_SYSTEM
 427   wait3 (0, WNOHANG | WUNTRACED, 0);
 428 #else
 429   croak ("wait_without_blocking");
 430 #endif
 431   synch_process_alive = 0;
 432 }
 433
 434 #endif /* not subprocesses */
 435
 436 int wait_debugging;   /* Set nonzero to make following function work under dbx
 437                          (at least for bsd).  */
 438
 439 SIGTYPE
 440 wait_for_termination_signal ()
 441 {}
 442
 443 /* Wait for subprocess with process id `pid' to terminate and
 444    make sure it will get eliminated (not remain forever as a zombie) */
 445
 446 void
 447 wait_for_termination (pid)
 448      int pid;
 449 {
 450   while (1)
 451     {
 452 #ifdef subprocesses
 453 #ifdef VMS
 454       int status;
 455
 456       status = SYS$FORCEX (&pid, 0, 0);
 457       break;
 458 #else /* not VMS */
 459 #if defined (BSD_SYSTEM) || (defined (HPUX) && !defined (HPUX_5))
 460       /* Note that kill returns -1 even if the process is just a zombie now.
 461          But inevitably a SIGCHLD interrupt should be generated
 462          and child_sig will do wait3 and make the process go away. */
 463       /* There is some indication that there is a bug involved with
 464          termination of subprocesses, perhaps involving a kernel bug too,
 465          but no idea what it is.  Just as a hunch we signal SIGCHLD to see
 466          if that causes the problem to go away or get worse.  */
 467       sigsetmask (sigmask (SIGCHLD));
 468       if (0 > kill (pid, 0))
 469         {
 470           sigsetmask (SIGEMPTYMASK);
 471           kill (getpid (), SIGCHLD);
 472           break;
 473         }
 474       if (wait_debugging)
 475         sleep (1);
 476       else
 477         sigpause (SIGEMPTYMASK);
 478 #else /* not BSD_SYSTEM, and not HPUX version >= 6 */
 479 #if defined (UNIPLUS)
 480       if (0 > kill (pid, 0))
 481         break;
 482       wait (0);
 483 #else /* neither BSD_SYSTEM nor UNIPLUS: random sysV */
 484 #ifdef POSIX_SIGNALS    /* would this work for LINUX as well? */
 485       sigblock (sigmask (SIGCHLD));
 486       if (0 > kill (pid, 0))
 487         {
 488           sigunblock (sigmask (SIGCHLD));
 489           break;
 490         }
 491       sigpause (SIGEMPTYMASK);
 492 #else /* not POSIX_SIGNALS */
 493 #ifdef HAVE_SYSV_SIGPAUSE
 494       sighold (SIGCHLD);
 495       if (0 > kill (pid, 0))
 496         {
 497           sigrelse (SIGCHLD);
 498           break;
 499         }
 500       sigpause (SIGCHLD);
 501 #else /* not HAVE_SYSV_SIGPAUSE */
 502 #ifdef WINDOWSNT
 503       wait (0);
 504       break;
 505 #else /* not WINDOWSNT */
 506       if (0 > kill (pid, 0))
 507         break;
 508       /* Using sleep instead of pause avoids timing error.
 509          If the inferior dies just before the sleep,
 510          we lose just one second.  */
 511       sleep (1);
 512 #endif /* not WINDOWSNT */
 513 #endif /* not HAVE_SYSV_SIGPAUSE */
 514 #endif /* not POSIX_SIGNALS */
 515 #endif /* not UNIPLUS */
 516 #endif /* not BSD_SYSTEM, and not HPUX version >= 6 */
 517 #endif /* not VMS */
 518 #else /* not subprocesses */
 519 #if __DJGPP__ > 1
 520       break;
 521 #else /* not __DJGPP__ > 1 */
 522 #ifndef BSD4_1
 523       if (kill (pid, 0) < 0)
 524         break;
 525       wait (0);
 526 #else /* BSD4_1 */
 527       int status;
 528       status = wait (0);
 529       if (status == pid || status == -1)
 530         break;
 531 #endif /* BSD4_1 */
 532 #endif /* not __DJGPP__ > 1*/
 533 #endif /* not subprocesses */
 534     }
 535 }
 536
 537 #ifdef subprocesses
 538
 539 /*
 540  *      flush any pending output
 541  *      (may flush input as well; it does not matter the way we use it)
 542  */
 543
 544 void
 545 flush_pending_output (channel)
 546      int channel;
 547 {
 548 #ifdef HAVE_TERMIOS
 549   /* If we try this, we get hit with SIGTTIN, because
 550      the child's tty belongs to the child's pgrp. */
 551 #else
 552 #ifdef TCFLSH
 553   ioctl (channel, TCFLSH, 1);
 554 #else
 555 #ifdef TIOCFLUSH
 556   int zero = 0;
 557   /* 3rd arg should be ignored
 558      but some 4.2 kernels actually want the address of an int
 559      and nonzero means something different.  */
 560   ioctl (channel, TIOCFLUSH, &zero);
 561 #endif
 562 #endif
 563 #endif
 564 }
 565 \f
 566 #ifndef VMS
 567 /*  Set up the terminal at the other end of a pseudo-terminal that
 568     we will be controlling an inferior through.
 569     It should not echo or do line-editing, since that is done
 570     in Emacs.  No padding needed for insertion into an Emacs buffer.  */
 571
 572 void
 573 child_setup_tty (out)
 574      int out;
 575 {
 576 #ifndef DOS_NT
 577   struct emacs_tty s;
 578
 579   EMACS_GET_TTY (out, &s);
 580
 581 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
 582   s.main.c_oflag |= OPOST;      /* Enable output postprocessing */
 583   s.main.c_oflag &= ~ONLCR;     /* Disable map of NL to CR-NL on output */
 584 #ifdef NLDLY
 585   s.main.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
 586                                 /* No output delays */
 587 #endif
 588   s.main.c_lflag &= ~ECHO;      /* Disable echo */
 589   s.main.c_lflag |= ISIG;       /* Enable signals */
 590 #ifdef IUCLC
 591   s.main.c_iflag &= ~IUCLC;     /* Disable downcasing on input.  */
 592 #endif
 593 #ifdef ISTRIP
 594   s.main.c_iflag &= ~ISTRIP;    /* don't strip 8th bit on input */
 595 #endif
 596 #ifdef OLCUC
 597   s.main.c_oflag &= ~OLCUC;     /* Disable upcasing on output.  */
 598 #endif
 599   s.main.c_oflag &= ~TAB3;      /* Disable tab expansion */
 600   s.main.c_cflag = (s.main.c_cflag & ~CSIZE) | CS8; /* Don't strip 8th bit */
 601 #if 0
 602   /* Said to be unnecessary:  */
 603   s.main.c_cc[VMIN] = 1;        /* minimum number of characters to accept  */
 604   s.main.c_cc[VTIME] = 0;       /* wait forever for at least 1 character  */
 605 #endif
 606
 607   s.main.c_lflag |= ICANON;     /* Enable erase/kill and eof processing */
 608   s.main.c_cc[VEOF] = 04;       /* insure that EOF is Control-D */
 609   s.main.c_cc[VERASE] = CDISABLE;       /* disable erase processing */
 610   s.main.c_cc[VKILL] = CDISABLE;        /* disable kill processing */
 611
 612 #ifdef HPUX
 613   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 614 #endif /* HPUX */
 615
 616 #ifdef AIX
 617 /* AIX enhanced edit loses NULs, so disable it */
 618 #ifndef IBMR2AIX
 619   s.main.c_line = 0;
 620   s.main.c_iflag &= ~ASCEDIT;
 621 #endif
 622   /* Also, PTY overloads NUL and BREAK.
 623      don't ignore break, but don't signal either, so it looks like NUL.  */
 624   s.main.c_iflag &= ~IGNBRK;
 625   s.main.c_iflag &= ~BRKINT;
 626   /* QUIT and INTR work better as signals, so disable character forms */
 627   s.main.c_cc[VINTR] = 0377;
 628 #ifdef SIGNALS_VIA_CHARACTERS
 629   /* the QUIT and INTR character are used in process_send_signal
 630      so set them here to something useful.  */
 631   if (s.main.c_cc[VQUIT] == 0377)
 632     s.main.c_cc[VQUIT] = '\\'&037;      /* Control-\ */
 633   if (s.main.c_cc[VINTR] == 0377)
 634     s.main.c_cc[VINTR] = 'C'&037;       /* Control-C */
 635 #else /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 636   /* QUIT and INTR work better as signals, so disable character forms */
 637   s.main.c_cc[VQUIT] = 0377;
 638   s.main.c_cc[VINTR] = 0377;
 639   s.main.c_lflag &= ~ISIG;
 640 #endif /* no TIOCGPGRP or no TIOCGLTC or no TIOCGETC */
 641   s.main.c_cc[VEOL] = 0377;
 642   s.main.c_cflag = (s.main.c_cflag & ~CBAUD) | B9600; /* baud rate sanity */
 643 #endif /* AIX */
 644
 645 #else /* not HAVE_TERMIO */
 646
 647   s.main.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE
 648                        | CBREAK | TANDEM);
 649   s.main.sg_flags |= LPASS8;
 650   s.main.sg_erase = 0377;
 651   s.main.sg_kill = 0377;
 652   s.lmode = LLITOUT | s.lmode;        /* Don't strip 8th bit */
 653
 654 #endif /* not HAVE_TERMIO */
 655
 656   EMACS_SET_TTY (out, &s, 0);
 657
 658 #ifdef BSD4_1
 659   if (interrupt_input)
 660     reset_sigio ();
 661 #endif /* BSD4_1 */
 662 #ifdef RTU
 663   {
 664     int zero = 0;
 665     ioctl (out, FIOASYNC, &zero);
 666   }
 667 #endif /* RTU */
 668 #endif /* not DOS_NT */
 669 }
 670 #endif /* not VMS */
 671
 672 #endif /* subprocesses */
 673 \f
 674 /* Record a signal code and the handler for it.  */
 675 struct save_signal
 676 {
 677   int code;
 678   SIGTYPE (*handler) P_ ((int));
 679 };
 680
 681 static void save_signal_handlers P_ ((struct save_signal *));
 682 static void restore_signal_handlers P_ ((struct save_signal *));
 683
 684 /* Suspend the Emacs process; give terminal to its superior.  */
 685
 686 void
 687 sys_suspend ()
 688 {
 689 #ifdef VMS
 690   /* "Foster" parentage allows emacs to return to a subprocess that attached
 691      to the current emacs as a cheaper than starting a whole new process.  This
 692      is set up by KEPTEDITOR.COM.  */
 693   unsigned long parent_id, foster_parent_id;
 694   char *fpid_string;
 695
 696   fpid_string = getenv ("EMACS_PARENT_PID");
 697   if (fpid_string != NULL)
 698     {
 699       sscanf (fpid_string, "%x", &foster_parent_id);
 700       if (foster_parent_id != 0)
 701         parent_id = foster_parent_id;
 702       else
 703         parent_id = getppid ();
 704     }
 705   else
 706     parent_id = getppid ();
 707
 708   xfree (fpid_string);          /* On VMS, this was malloc'd */
 709
 710   if (parent_id && parent_id != 0xffffffff)
 711     {
 712       SIGTYPE (*oldsig)() = (int) signal (SIGINT, SIG_IGN);
 713       int status = LIB$ATTACH (&parent_id) & 1;
 714       signal (SIGINT, oldsig);
 715       return status;
 716     }
 717   else
 718     {
 719       struct {
 720         int     l;
 721         char    *a;
 722       } d_prompt;
 723       d_prompt.l = sizeof ("Emacs: ");          /* Our special prompt */
 724       d_prompt.a = "Emacs: ";                   /* Just a reminder */
 725       LIB$SPAWN (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, &d_prompt, 0);
 726       return 1;
 727     }
 728   return -1;
 729 #else
 730 #if defined (SIGTSTP) && !defined (MSDOS)
 731
 732   {
 733     int pgrp = EMACS_GETPGRP (0);
 734     EMACS_KILLPG (pgrp, SIGTSTP);
 735   }
 736
 737 #else /* No SIGTSTP */
 738 #ifdef USG_JOBCTRL /* If you don't know what this is don't mess with it */
 739   ptrace (0, 0, 0, 0);          /* set for ptrace - caught by csh */
 740   kill (getpid (), SIGQUIT);
 741
 742 #else /* No SIGTSTP or USG_JOBCTRL */
 743
 744 /* On a system where suspending is not implemented,
 745    instead fork a subshell and let it talk directly to the terminal
 746    while we wait.  */
 747   sys_subshell ();
 748
 749 #endif /* no USG_JOBCTRL */
 750 #endif /* no SIGTSTP */
 751 #endif /* not VMS */
 752 }
 753
 754 /* Fork a subshell.  */
 755
 756 void
 757 sys_subshell ()
 758 {
 759 #ifdef macintosh
 760     error ("Can't spawn subshell");
 761 #else
 762 #ifndef VMS
 763 #ifdef DOS_NT   /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 764   int st;
 765   char oldwd[MAXPATHLEN+1]; /* Fixed length is safe on MSDOS.  */
 766 #endif
 767   int pid;
 768   struct save_signal saved_handlers[5];
 769   Lisp_Object dir;
 770   unsigned char *str = 0;
 771   int len;
 772
 773   saved_handlers[0].code = SIGINT;
 774   saved_handlers[1].code = SIGQUIT;
 775   saved_handlers[2].code = SIGTERM;
 776 #ifdef SIGIO
 777   saved_handlers[3].code = SIGIO;
 778   saved_handlers[4].code = 0;
 779 #else
 780   saved_handlers[3].code = 0;
 781 #endif
 782
 783   /* Mentioning current_buffer->buffer would mean including buffer.h,
 784      which somehow wedges the hp compiler.  So instead...  */
 785
 786   dir = intern ("default-directory");
 787   if (NILP (Fboundp (dir)))
 788     goto xyzzy;
 789   dir = Fsymbol_value (dir);
 790   if (!STRINGP (dir))
 791     goto xyzzy;
 792
 793   dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
 794   str = (unsigned char *) alloca (XSTRING (dir)->size + 2);
 795   len = XSTRING (dir)->size;
 796   bcopy (XSTRING (dir)->data, str, len);
 797   if (str[len - 1] != '/') str[len++] = '/';
 798   str[len] = 0;
 799  xyzzy:
 800
 801 #ifdef DOS_NT
 802   pid = 0;
 803 #if __DJGPP__ > 1
 804   save_signal_handlers (saved_handlers);
 805   synch_process_alive = 1;
 806 #endif /* __DJGPP__ > 1 */
 807 #else
 808   pid = vfork ();
 809   if (pid == -1)
 810     error ("Can't spawn subshell");
 811 #endif
 812
 813   if (pid == 0)
 814     {
 815       char *sh = 0;
 816
 817 #ifdef DOS_NT    /* MW, Aug 1993 */
 818       getwd (oldwd);
 819       if (sh == 0)
 820         sh = (char *) egetenv ("SUSPEND");      /* KFS, 1994-12-14 */
 821 #endif
 822       if (sh == 0)
 823         sh = (char *) egetenv ("SHELL");
 824       if (sh == 0)
 825         sh = "sh";
 826
 827       /* Use our buffer's default directory for the subshell.  */
 828       if (str)
 829         chdir ((char *) str);
 830
 831 #ifdef subprocesses
 832       close_process_descs ();   /* Close Emacs's pipes/ptys */
 833 #endif
 834
 835 #ifdef SET_EMACS_PRIORITY
 836       {
 837         extern int emacs_priority;
 838
 839         if (emacs_priority < 0)
 840           nice (-emacs_priority);
 841       }
 842 #endif
 843
 844 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
 845       st = system (sh);
 846       chdir (oldwd);
 847 #if 0   /* This is also reported if last command executed in subshell failed, KFS */
 848       if (st)
 849         report_file_error ("Can't execute subshell", Fcons (build_string (sh), Qnil));
 850 #endif
 851 #else /* not MSDOS */
 852 #ifdef  WINDOWSNT
 853       /* Waits for process completion */
 854       pid = _spawnlp (_P_WAIT, sh, sh, NULL);
 855       chdir (oldwd);
 856       if (pid == -1)
 857         write (1, "Can't execute subshell", 22);
 858 #else   /* not WINDOWSNT */
 859       execlp (sh, sh, 0);
 860       write (1, "Can't execute subshell", 22);
 861       _exit (1);
 862 #endif  /* not WINDOWSNT */
 863 #endif /* not MSDOS */
 864     }
 865
 866   /* Do this now if we did not do it before.  */
 867 #if !defined (MSDOS) || __DJGPP__ == 1
 868   save_signal_handlers (saved_handlers);
 869   synch_process_alive = 1;
 870 #endif
 871
 872 #ifndef DOS_NT
 873   wait_for_termination (pid);
 874 #endif
 875   restore_signal_handlers (saved_handlers);
 876   synch_process_alive = 0;
 877 #endif /* !VMS */
 878 #endif /* !macintosh */
 879 }
 880
 881 static void
 882 save_signal_handlers (saved_handlers)
 883      struct save_signal *saved_handlers;
 884 {
 885   while (saved_handlers->code)
 886     {
 887       saved_handlers->handler
 888         = (SIGTYPE (*) P_ ((int))) signal (saved_handlers->code, SIG_IGN);
 889       saved_handlers++;
 890     }
 891 }
 892
 893 static void
 894 restore_signal_handlers (saved_handlers)
 895      struct save_signal *saved_handlers;
 896 {
 897   while (saved_handlers->code)
 898     {
 899       signal (saved_handlers->code, saved_handlers->handler);
 900       saved_handlers++;
 901     }
 902 }
 903 \f
 904 #ifdef F_SETFL
 905
 906 int old_fcntl_flags;
 907
 908 void
 909 init_sigio (fd)
 910      int fd;
 911 {
 912 #ifdef FASYNC
 913   old_fcntl_flags = fcntl (fd, F_GETFL, 0) & ~FASYNC;
 914   fcntl (fd, F_SETFL, old_fcntl_flags | FASYNC);
 915 #endif
 916   interrupts_deferred = 0;
 917 }
 918
 919 void
 920 reset_sigio ()
 921 {
 922   unrequest_sigio ();
 923 }
 924
 925 #ifdef FASYNC           /* F_SETFL does not imply existence of FASYNC */
 926
 927 void
 928 request_sigio ()
 929 {
 930   if (read_socket_hook)
 931     return;
 932
 933 #ifdef SIGWINCH
 934   sigunblock (sigmask (SIGWINCH));
 935 #endif
 936   fcntl (input_fd, F_SETFL, old_fcntl_flags | FASYNC);
 937
 938   interrupts_deferred = 0;
 939 }
 940
 941 void
 942 unrequest_sigio ()
 943 {
 944   if (read_socket_hook)
 945     return;
 946
 947 #ifdef SIGWINCH
 948   sigblock (sigmask (SIGWINCH));
 949 #endif
 950   fcntl (input_fd, F_SETFL, old_fcntl_flags);
 951   interrupts_deferred = 1;
 952 }
 953
 954 #else /* no FASYNC */
 955 #ifdef STRIDE           /* Stride doesn't have FASYNC - use FIOASYNC */
 956
 957 void
 958 request_sigio ()
 959 {
 960   int on = 1;
 961
 962   if (read_socket_hook)
 963     return;
 964
 965   ioctl (input_fd, FIOASYNC, &on);
 966   interrupts_deferred = 0;
 967 }
 968
 969 void
 970 unrequest_sigio ()
 971 {
 972   int off = 0;
 973
 974   if (read_socket_hook)
 975     return;
 976
 977   ioctl (input_fd, FIOASYNC, &off);
 978   interrupts_deferred = 1;
 979 }
 980
 981 #else /* not FASYNC, not STRIDE */
 982
 983 #ifdef _CX_UX
 984
 985 #include <termios.h>
 986
 987 void
 988 request_sigio ()
 989 {
 990   int on = 1;
 991   sigset_t st;
 992
 993   if (read_socket_hook)
 994     return;
 995
 996   sigemptyset (&st);
 997   sigaddset (&st, SIGIO);
 998   ioctl (input_fd, FIOASYNC, &on);
 999   interrupts_deferred = 0;
1000   sigprocmask (SIG_UNBLOCK, &st, (sigset_t *)0);
1001 }
1002
1003 void
1004 unrequest_sigio ()
1005 {
1006   int off = 0;
1007
1008   if (read_socket_hook)
1009     return;
1010
1011   ioctl (input_fd, FIOASYNC, &off);
1012   interrupts_deferred = 1;
1013 }
1014
1015 #else /* ! _CX_UX */
1016
1017 void
1018 request_sigio ()
1019 {
1020   if (read_socket_hook)
1021     return;
1022
1023   croak ("request_sigio");
1024 }
1025
1026 void
1027 unrequest_sigio ()
1028 {
1029   if (read_socket_hook)
1030     return;
1031
1032   croak ("unrequest_sigio");
1033 }
1034
1035 #endif /* _CX_UX */
1036 #endif /* STRIDE */
1037 #endif /* FASYNC */
1038 #endif /* F_SETFL */
1039 \f
1040 /* Saving and restoring the process group of Emacs's terminal.  */
1041
1042 #ifdef BSD_PGRPS
1043
1044 /* The process group of which Emacs was a member when it initially
1045    started.
1046
1047    If Emacs was in its own process group (i.e. inherited_pgroup ==
1048    getpid ()), then we know we're running under a shell with job
1049    control (Emacs would never be run as part of a pipeline).
1050    Everything is fine.
1051
1052    If Emacs was not in its own process group, then we know we're
1053    running under a shell (or a caller) that doesn't know how to
1054    separate itself from Emacs (like sh).  Emacs must be in its own
1055    process group in order to receive SIGIO correctly.  In this
1056    situation, we put ourselves in our own pgroup, forcibly set the
1057    tty's pgroup to our pgroup, and make sure to restore and reinstate
1058    the tty's pgroup just like any other terminal setting.  If
1059    inherited_group was not the tty's pgroup, then we'll get a
1060    SIGTTmumble when we try to change the tty's pgroup, and a CONT if
1061    it goes foreground in the future, which is what should happen.  */
1062 int inherited_pgroup;
1063
1064 /* Split off the foreground process group to Emacs alone.
1065    When we are in the foreground, but not started in our own process
1066    group, redirect the TTY to point to our own process group.  We need
1067    to be in our own process group to receive SIGIO properly.  */
1068 void
1069 narrow_foreground_group ()
1070 {
1071   int me = getpid ();
1072
1073   setpgrp (0, inherited_pgroup);
1074   if (inherited_pgroup != me)
1075     EMACS_SET_TTY_PGRP (input_fd, &me);
1076   setpgrp (0, me);
1077 }
1078
1079 /* Set the tty to our original foreground group.  */
1080 void
1081 widen_foreground_group ()
1082 {
1083   if (inherited_pgroup != getpid ())
1084     EMACS_SET_TTY_PGRP (input_fd, &inherited_pgroup);
1085   setpgrp (0, inherited_pgroup);
1086 }
1087
1088 #endif /* BSD_PGRPS */
1089 \f
1090 /* Getting and setting emacs_tty structures.  */
1091
1092 /* Set *TC to the parameters associated with the terminal FD.
1093    Return zero if all's well, or -1 if we ran into an error we
1094    couldn't deal with.  */
1095 int
1096 emacs_get_tty (fd, settings)
1097      int fd;
1098      struct emacs_tty *settings;
1099 {
1100   /* Retrieve the primary parameters - baud rate, character size, etcetera.  */
1101 #ifdef HAVE_TCATTR
1102   /* We have those nifty POSIX tcmumbleattr functions.  */
1103   bzero (&settings->main, sizeof (settings->main));
1104   if (tcgetattr (fd, &settings->main) < 0)
1105     return -1;
1106
1107 #else
1108 #ifdef HAVE_TERMIO
1109   /* The SYSV-style interface?  */
1110   if (ioctl (fd, TCGETA, &settings->main) < 0)
1111     return -1;
1112
1113 #else
1114 #ifdef VMS
1115   /* Vehemently Monstrous System?  :-)  */
1116   if (! (SYS$QIOW (0, fd, IO$_SENSEMODE, settings, 0, 0,
1117                    &settings->main.class, 12, 0, 0, 0, 0)
1118          & 1))
1119     return -1;
1120
1121 #else
1122 #ifndef DOS_NT
1123   /* I give up - I hope you have the BSD ioctls.  */
1124   if (ioctl (fd, TIOCGETP, &settings->main) < 0)
1125     return -1;
1126 #endif /* not DOS_NT */
1127 #endif
1128 #endif
1129 #endif
1130
1131   /* Suivant - Do we have to get struct ltchars data?  */
1132 #ifdef HAVE_LTCHARS
1133   if (ioctl (fd, TIOCGLTC, &settings->ltchars) < 0)
1134     return -1;
1135 #endif
1136
1137   /* How about a struct tchars and a wordful of lmode bits?  */
1138 #ifdef HAVE_TCHARS
1139   if (ioctl (fd, TIOCGETC, &settings->tchars) < 0
1140       || ioctl (fd, TIOCLGET, &settings->lmode) < 0)
1141     return -1;
1142 #endif
1143
1144   /* We have survived the tempest.  */
1145   return 0;
1146 }
1147
1148
1149 /* Set the parameters of the tty on FD according to the contents of
1150    *SETTINGS.  If FLUSHP is non-zero, we discard input.
1151    Return 0 if all went well, and -1 if anything failed.  */
1152
1153 int
1154 emacs_set_tty (fd, settings, flushp)
1155      int fd;
1156      struct emacs_tty *settings;
1157      int flushp;
1158 {
1159   /* Set the primary parameters - baud rate, character size, etcetera.  */
1160 #ifdef HAVE_TCATTR
1161   int i;
1162   /* We have those nifty POSIX tcmumbleattr functions.
1163      William J. Smith <wjs@wiis.wang.com> writes:
1164      "POSIX 1003.1 defines tcsetattr to return success if it was
1165      able to perform any of the requested actions, even if some
1166      of the requested actions could not be performed.
1167      We must read settings back to ensure tty setup properly.
1168      AIX requires this to keep tty from hanging occasionally."  */
1169   /* This make sure that we don't loop indefinitely in here.  */
1170   for (i = 0 ; i < 10 ; i++)
1171     if (tcsetattr (fd, flushp ? TCSAFLUSH : TCSADRAIN, &settings->main) < 0)
1172       {
1173         if (errno == EINTR)
1174           continue;
1175         else
1176           return -1;
1177       }
1178     else
1179       {
1180         struct termios new;
1181
1182         bzero (&new, sizeof (new));
1183         /* Get the current settings, and see if they're what we asked for.  */
1184         tcgetattr (fd, &new);
1185         /* We cannot use memcmp on the whole structure here because under
1186          * aix386 the termios structure has some reserved field that may
1187          * not be filled in.
1188          */
1189         if (   new.c_iflag == settings->main.c_iflag
1190             && new.c_oflag == settings->main.c_oflag
1191             && new.c_cflag == settings->main.c_cflag
1192             && new.c_lflag == settings->main.c_lflag
1193             && memcmp (new.c_cc, settings->main.c_cc, NCCS) == 0)
1194           break;
1195         else
1196           continue;
1197       }
1198
1199 #else
1200 #ifdef HAVE_TERMIO
1201   /* The SYSV-style interface?  */
1202   if (ioctl (fd, flushp ? TCSETAF : TCSETAW, &settings->main) < 0)
1203     return -1;
1204
1205 #else
1206 #ifdef VMS
1207   /* Vehemently Monstrous System?  :-)  */
1208   if (! (SYS$QIOW (0, fd, IO$_SETMODE, &input_iosb, 0, 0,
1209                    &settings->main.class, 12, 0, 0, 0, 0)
1210          & 1))
1211     return -1;
1212
1213 #else
1214 #ifndef DOS_NT
1215   /* I give up - I hope you have the BSD ioctls.  */
1216   if (ioctl (fd, (flushp) ? TIOCSETP : TIOCSETN, &settings->main) < 0)
1217     return -1;
1218 #endif /* not DOS_NT */
1219
1220 #endif
1221 #endif
1222 #endif
1223
1224   /* Suivant - Do we have to get struct ltchars data?  */
1225 #ifdef HAVE_LTCHARS
1226   if (ioctl (fd, TIOCSLTC, &settings->ltchars) < 0)
1227     return -1;
1228 #endif
1229
1230   /* How about a struct tchars and a wordful of lmode bits?  */
1231 #ifdef HAVE_TCHARS
1232   if (ioctl (fd, TIOCSETC, &settings->tchars) < 0
1233       || ioctl (fd, TIOCLSET, &settings->lmode) < 0)
1234     return -1;
1235 #endif
1236
1237   /* We have survived the tempest.  */
1238   return 0;
1239 }
1240
1241 \f
1242 /* The initial tty mode bits */
1243 struct emacs_tty old_tty;
1244
1245 /* 1 if we have been through init_sys_modes.  */
1246 int term_initted;
1247
1248 /* 1 if outer tty status has been recorded.  */
1249 int old_tty_valid;
1250
1251 #ifdef BSD4_1
1252 /* BSD 4.1 needs to keep track of the lmode bits in order to start
1253    sigio.  */
1254 int lmode;
1255 #endif
1256
1257 #ifndef F_SETOWN_BUG
1258 #ifdef F_SETOWN
1259 int old_fcntl_owner;
1260 #endif /* F_SETOWN */
1261 #endif /* F_SETOWN_BUG */
1262
1263 /* This may also be defined in stdio,
1264    but if so, this does no harm,
1265    and using the same name avoids wasting the other one's space.  */
1266
1267 #ifdef nec_ews_svr4
1268 extern char *_sobuf ;
1269 #else
1270 #if defined (USG) || defined (DGUX)
1271 unsigned char _sobuf[BUFSIZ+8];
1272 #else
1273 char _sobuf[BUFSIZ];
1274 #endif
1275 #endif
1276
1277 #ifdef HAVE_LTCHARS
1278 static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1};
1279 #endif
1280 #ifdef HAVE_TCHARS
1281 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
1282 #endif
1283
1284 void
1285 init_sys_modes ()
1286 {
1287   struct emacs_tty tty;
1288
1289 #ifdef macintosh
1290   Vwindow_system = intern ("mac");
1291   Vwindow_system_version = make_number (1);
1292
1293 /* cus-start.el complains if delete-exited-processes and x-bitmap-file-path not defined */
1294 #ifndef subprocesses
1295   DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
1296     "*Non-nil means delete processes immediately when they exit.\n\
1297 nil means don't delete them until `list-processes' is run.");
1298   delete_exited_processes = 0;
1299 #endif
1300
1301 #ifndef HAVE_X_WINDOWS
1302   DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path,
1303     "List of directories to search for bitmap files for X.");
1304   Vx_bitmap_file_path = decode_env_path ((char *) 0, ".");
1305 #endif
1306
1307 #endif /* not macintosh */
1308
1309 #ifdef VMS
1310 #if 0
1311   static int oob_chars[2] = {0, 1 << 7}; /* catch C-g's */
1312   extern int (*interrupt_signal) ();
1313 #endif
1314 #endif
1315
1316   Vtty_erase_char = Qnil;
1317
1318   if (noninteractive)
1319     return;
1320
1321 #ifdef VMS
1322   if (!input_ef)
1323     input_ef = get_kbd_event_flag ();
1324     /* LIB$GET_EF (&input_ef); */
1325   SYS$CLREF (input_ef);
1326   waiting_for_ast = 0;
1327   if (!timer_ef)
1328     timer_ef = get_timer_event_flag ();
1329     /* LIB$GET_EF (&timer_ef); */
1330   SYS$CLREF (timer_ef);
1331 #if 0
1332   if (!process_ef)
1333     {
1334       LIB$GET_EF (&process_ef);
1335       SYS$CLREF (process_ef);
1336     }
1337   if (input_ef / 32 != process_ef / 32)
1338     croak ("Input and process event flags in different clusters.");
1339 #endif
1340   if (input_ef / 32 != timer_ef / 32)
1341     croak ("Input and timer event flags in different clusters.");
1342 #if 0
1343   input_eflist = ((unsigned) 1 << (input_ef % 32)) |
1344     ((unsigned) 1 << (process_ef % 32));
1345 #endif
1346   timer_eflist = ((unsigned) 1 << (input_ef % 32)) |
1347     ((unsigned) 1 << (timer_ef % 32));
1348 #ifndef VMS4_4
1349   sys_access_reinit ();
1350 #endif
1351 #endif /* not VMS */
1352
1353 #ifdef BSD_PGRPS
1354   if (! read_socket_hook && EQ (Vwindow_system, Qnil))
1355     narrow_foreground_group ();
1356 #endif
1357
1358 #ifdef HAVE_WINDOW_SYSTEM
1359   /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
1360      needs the initialization code below.  */
1361   if (!read_socket_hook && EQ (Vwindow_system, Qnil))
1362 #endif
1363     {
1364       EMACS_GET_TTY (input_fd, &old_tty);
1365
1366       old_tty_valid = 1;
1367
1368       tty = old_tty;
1369
1370 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
1371       XSETINT (Vtty_erase_char, old_tty.main.c_cc[VERASE]);
1372
1373 #ifdef DGUX
1374       /* This allows meta to be sent on 8th bit.  */
1375       tty.main.c_iflag &= ~INPCK;       /* don't check input for parity */
1376 #endif
1377       tty.main.c_iflag |= (IGNBRK);     /* Ignore break condition */
1378       tty.main.c_iflag &= ~ICRNL;       /* Disable map of CR to NL on input */
1379 #ifdef INLCR  /* I'm just being cautious,
1380                  since I can't check how widespread INLCR is--rms.  */
1381       tty.main.c_iflag &= ~INLCR;       /* Disable map of NL to CR on input */
1382 #endif
1383 #ifdef ISTRIP
1384       tty.main.c_iflag &= ~ISTRIP;      /* don't strip 8th bit on input */
1385 #endif
1386       tty.main.c_lflag &= ~ECHO;        /* Disable echo */
1387       tty.main.c_lflag &= ~ICANON;      /* Disable erase/kill processing */
1388 #ifdef IEXTEN
1389       tty.main.c_lflag &= ~IEXTEN;      /* Disable other editing characters.  */
1390 #endif
1391       tty.main.c_lflag |= ISIG; /* Enable signals */
1392       if (flow_control)
1393         {
1394           tty.main.c_iflag |= IXON;     /* Enable start/stop output control */
1395 #ifdef IXANY
1396           tty.main.c_iflag &= ~IXANY;
1397 #endif /* IXANY */
1398         }
1399       else
1400         tty.main.c_iflag &= ~IXON;      /* Disable start/stop output control */
1401       tty.main.c_oflag &= ~ONLCR;       /* Disable map of NL to CR-NL
1402                                            on output */
1403       tty.main.c_oflag &= ~TAB3;        /* Disable tab expansion */
1404 #ifdef CS8
1405       if (meta_key)
1406         {
1407           tty.main.c_cflag |= CS8;      /* allow 8th bit on input */
1408           tty.main.c_cflag &= ~PARENB;/* Don't check parity */
1409         }
1410 #endif
1411       tty.main.c_cc[VINTR] = quit_char; /* C-g (usually) gives SIGINT */
1412       /* Set up C-g for both SIGQUIT and SIGINT.
1413          We don't know which we will get, but we handle both alike
1414          so which one it really gives us does not matter.  */
1415       tty.main.c_cc[VQUIT] = quit_char;
1416       tty.main.c_cc[VMIN] = 1;  /* Input should wait for at least 1 char */
1417       tty.main.c_cc[VTIME] = 0; /* no matter how long that takes.  */
1418 #ifdef VSWTCH
1419       tty.main.c_cc[VSWTCH] = CDISABLE; /* Turn off shell layering use
1420                                            of C-z */
1421 #endif /* VSWTCH */
1422
1423 #if defined (mips) || defined (HAVE_TCATTR)
1424 #ifdef VSUSP
1425       tty.main.c_cc[VSUSP] = CDISABLE;  /* Turn off mips handling of C-z.  */
1426 #endif /* VSUSP */
1427 #ifdef V_DSUSP
1428       tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y.  */
1429 #endif /* V_DSUSP */
1430 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
1431       tty.main.c_cc[VDSUSP] = CDISABLE;
1432 #endif /* VDSUSP */
1433 #ifdef VLNEXT
1434       tty.main.c_cc[VLNEXT] = CDISABLE;
1435 #endif /* VLNEXT */
1436 #ifdef VREPRINT
1437       tty.main.c_cc[VREPRINT] = CDISABLE;
1438 #endif /* VREPRINT */
1439 #ifdef VWERASE
1440       tty.main.c_cc[VWERASE] = CDISABLE;
1441 #endif /* VWERASE */
1442 #ifdef VDISCARD
1443       tty.main.c_cc[VDISCARD] = CDISABLE;
1444 #endif /* VDISCARD */
1445
1446       if (flow_control)
1447         {
1448 #ifdef VSTART
1449           tty.main.c_cc[VSTART] = '\021';
1450 #endif /* VSTART */
1451 #ifdef VSTOP
1452           tty.main.c_cc[VSTOP] = '\023';
1453 #endif /* VSTOP */
1454         }
1455       else
1456         {
1457 #ifdef VSTART
1458           tty.main.c_cc[VSTART] = CDISABLE;
1459 #endif /* VSTART */
1460 #ifdef VSTOP
1461           tty.main.c_cc[VSTOP] = CDISABLE;
1462 #endif /* VSTOP */
1463         }
1464 #endif /* mips or HAVE_TCATTR */
1465
1466 #ifdef SET_LINE_DISCIPLINE
1467       /* Need to explicitly request TERMIODISC line discipline or
1468          Ultrix's termios does not work correctly.  */
1469       tty.main.c_line = SET_LINE_DISCIPLINE;
1470 #endif
1471 #ifdef AIX
1472 #ifndef IBMR2AIX
1473       /* AIX enhanced edit loses NULs, so disable it.  */
1474       tty.main.c_line = 0;
1475       tty.main.c_iflag &= ~ASCEDIT;
1476 #else
1477       tty.main.c_cc[VSTRT] = 255;
1478       tty.main.c_cc[VSTOP] = 255;
1479       tty.main.c_cc[VSUSP] = 255;
1480       tty.main.c_cc[VDSUSP] = 255;
1481 #endif /* IBMR2AIX */
1482       if (flow_control)
1483         {
1484 #ifdef VSTART
1485           tty.main.c_cc[VSTART] = '\021';
1486 #endif /* VSTART */
1487 #ifdef VSTOP
1488           tty.main.c_cc[VSTOP] = '\023';
1489 #endif /* VSTOP */
1490         }
1491       /* Also, PTY overloads NUL and BREAK.
1492          don't ignore break, but don't signal either, so it looks like NUL.
1493          This really serves a purpose only if running in an XTERM window
1494          or via TELNET or the like, but does no harm elsewhere.  */
1495       tty.main.c_iflag &= ~IGNBRK;
1496       tty.main.c_iflag &= ~BRKINT;
1497 #endif
1498 #else /* if not HAVE_TERMIO */
1499 #ifdef VMS
1500       tty.main.tt_char |= TT$M_NOECHO;
1501       if (meta_key)
1502         tty.main.tt_char |= TT$M_EIGHTBIT;
1503       if (flow_control)
1504         tty.main.tt_char |= TT$M_TTSYNC;
1505       else
1506         tty.main.tt_char &= ~TT$M_TTSYNC;
1507       tty.main.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
1508 #else /* not VMS (BSD, that is) */
1509 #ifndef DOS_NT
1510       XSETINT (Vtty_erase_char, tty.main.sg_erase);
1511       tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
1512       if (meta_key)
1513         tty.main.sg_flags |= ANYP;
1514       tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
1515 #endif /* not DOS_NT */
1516 #endif /* not VMS (BSD, that is) */
1517 #endif /* not HAVE_TERMIO */
1518
1519       /* If going to use CBREAK mode, we must request C-g to interrupt
1520          and turn off start and stop chars, etc.  If not going to use
1521          CBREAK mode, do this anyway so as to turn off local flow
1522          control for user coming over network on 4.2; in this case,
1523          only t_stopc and t_startc really matter.  */
1524 #ifndef HAVE_TERMIO
1525 #ifdef HAVE_TCHARS
1526       /* Note: if not using CBREAK mode, it makes no difference how we
1527          set this */
1528       tty.tchars = new_tchars;
1529       tty.tchars.t_intrc = quit_char;
1530       if (flow_control)
1531         {
1532           tty.tchars.t_startc = '\021';
1533           tty.tchars.t_stopc = '\023';
1534         }
1535
1536       tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | old_tty.lmode;
1537 #ifdef ultrix
1538       /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
1539          anything, and leaving it in breaks the meta key.  Go figure.  */
1540       tty.lmode &= ~LLITOUT;
1541 #endif
1542
1543 #ifdef BSD4_1
1544       lmode = tty.lmode;
1545 #endif
1546
1547 #endif /* HAVE_TCHARS */
1548 #endif /* not HAVE_TERMIO */
1549
1550 #ifdef HAVE_LTCHARS
1551       tty.ltchars = new_ltchars;
1552 #endif /* HAVE_LTCHARS */
1553 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
1554       if (!term_initted)
1555         internal_terminal_init ();
1556       dos_ttraw ();
1557 #endif
1558
1559       EMACS_SET_TTY (input_fd, &tty, 0);
1560
1561       /* This code added to insure that, if flow-control is not to be used,
1562          we have an unlocked terminal at the start. */
1563
1564 #ifdef TCXONC
1565       if (!flow_control) ioctl (input_fd, TCXONC, 1);
1566 #endif
1567 #ifndef APOLLO
1568 #ifdef TIOCSTART
1569       if (!flow_control) ioctl (input_fd, TIOCSTART, 0);
1570 #endif
1571 #endif
1572
1573 #if defined (HAVE_TERMIOS) || defined (HPUX9)
1574 #ifdef TCOON
1575       if (!flow_control) tcflow (input_fd, TCOON);
1576 #endif
1577 #endif
1578
1579 #ifdef AIXHFT
1580       hft_init ();
1581 #ifdef IBMR2AIX
1582       {
1583         /* IBM's HFT device usually thinks a ^J should be LF/CR.  We need it
1584            to be only LF.  This is the way that is done. */
1585         struct termio tty;
1586
1587         if (ioctl (1, HFTGETID, &tty) != -1)
1588           write (1, "\033[20l", 5);
1589       }
1590 #endif
1591 #endif /* AIXHFT */
1592
1593 #ifdef VMS
1594 /*  Appears to do nothing when in PASTHRU mode.
1595       SYS$QIOW (0, input_fd, IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
1596                 interrupt_signal, oob_chars, 0, 0, 0, 0);
1597 */
1598       queue_kbd_input (0);
1599 #endif /* VMS */
1600     }
1601
1602 #ifdef F_SETFL
1603 #ifndef F_SETOWN_BUG
1604 #ifdef F_GETOWN         /* F_SETFL does not imply existence of F_GETOWN */
1605   if (interrupt_input
1606       && ! read_socket_hook && EQ (Vwindow_system, Qnil))
1607     {
1608       old_fcntl_owner = fcntl (input_fd, F_GETOWN, 0);
1609       fcntl (input_fd, F_SETOWN, getpid ());
1610       init_sigio (input_fd);
1611     }
1612 #endif /* F_GETOWN */
1613 #endif /* F_SETOWN_BUG */
1614 #endif /* F_SETFL */
1615
1616 #ifdef BSD4_1
1617   if (interrupt_input)
1618     init_sigio (input_fd);
1619 #endif
1620
1621 #ifdef VMS  /* VMS sometimes has this symbol but lacks setvbuf.  */
1622 #undef _IOFBF
1623 #endif
1624 #ifdef _IOFBF
1625   /* This symbol is defined on recent USG systems.
1626      Someone says without this call USG won't really buffer the file
1627      even with a call to setbuf. */
1628   setvbuf (stdout, (char *) _sobuf, _IOFBF, sizeof _sobuf);
1629 #else
1630   setbuf (stdout, (char *) _sobuf);
1631 #endif
1632 #ifdef HAVE_WINDOW_SYSTEM
1633   /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
1634      needs the initialization code below.  */
1635   if (EQ (Vwindow_system, Qnil)
1636 #ifndef WINDOWSNT
1637       /* When running in tty mode on NT/Win95, we have a read_socket
1638          hook, but still need the rest of the initialization code below.  */
1639       && (! read_socket_hook)
1640 #endif
1641       )
1642 #endif
1643     set_terminal_modes ();
1644
1645   if (!term_initted
1646       && FRAMEP (Vterminal_frame)
1647       && FRAME_TERMCAP_P (XFRAME (Vterminal_frame)))
1648     init_frame_faces (XFRAME (Vterminal_frame));
1649
1650   if (term_initted && no_redraw_on_reenter)
1651     {
1652       if (display_completed)
1653         direct_output_forward_char (0);
1654     }
1655   else
1656     {
1657       frame_garbaged = 1;
1658       if (FRAMEP (Vterminal_frame))
1659         FRAME_GARBAGED_P (XFRAME (Vterminal_frame)) = 1;
1660     }
1661
1662   term_initted = 1;
1663 }
1664
1665 /* Return nonzero if safe to use tabs in output.
1666    At the time this is called, init_sys_modes has not been done yet.  */
1667
1668 int
1669 tabs_safe_p ()
1670 {
1671   struct emacs_tty tty;
1672
1673   EMACS_GET_TTY (input_fd, &tty);
1674   return EMACS_TTY_TABS_OK (&tty);
1675 }
1676 \f
1677 /* Get terminal size from system.
1678    Store number of lines into *HEIGHTP and width into *WIDTHP.
1679    We store 0 if there's no valid information.  */
1680
1681 void
1682 get_frame_size (widthp, heightp)
1683      int *widthp, *heightp;
1684 {
1685
1686 #ifdef TIOCGWINSZ
1687
1688   /* BSD-style.  */
1689   struct winsize size;
1690
1691   if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
1692     *widthp = *heightp = 0;
1693   else
1694     {
1695       *widthp = size.ws_col;
1696       *heightp = size.ws_row;
1697     }
1698
1699 #else
1700 #ifdef TIOCGSIZE
1701
1702   /* SunOS - style.  */
1703   struct ttysize size;
1704
1705   if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
1706     *widthp = *heightp = 0;
1707   else
1708     {
1709       *widthp = size.ts_cols;
1710       *heightp = size.ts_lines;
1711     }
1712
1713 #else
1714 #ifdef VMS
1715
1716   struct sensemode tty;
1717
1718   SYS$QIOW (0, input_fd, IO$_SENSEMODE, &tty, 0, 0,
1719             &tty.class, 12, 0, 0, 0, 0);
1720   *widthp = tty.scr_wid;
1721   *heightp = tty.scr_len;
1722
1723 #else
1724 #ifdef MSDOS
1725   *widthp = ScreenCols ();
1726   *heightp = ScreenRows ();
1727 #else /* system doesn't know size */
1728   *widthp = 0;
1729   *heightp = 0;
1730 #endif
1731
1732 #endif /* not VMS */
1733 #endif /* not SunOS-style */
1734 #endif /* not BSD-style */
1735 }
1736
1737 /* Set the logical window size associated with descriptor FD
1738    to HEIGHT and WIDTH.  This is used mainly with ptys.  */
1739
1740 int
1741 set_window_size (fd, height, width)
1742      int fd, height, width;
1743 {
1744 #ifdef TIOCSWINSZ
1745
1746   /* BSD-style.  */
1747   struct winsize size;
1748   size.ws_row = height;
1749   size.ws_col = width;
1750
1751   if (ioctl (fd, TIOCSWINSZ, &size) == -1)
1752     return 0; /* error */
1753   else
1754     return 1;
1755
1756 #else
1757 #ifdef TIOCSSIZE
1758
1759   /* SunOS - style.  */
1760   struct ttysize size;
1761   size.ts_lines = height;
1762   size.ts_cols = width;
1763
1764   if (ioctl (fd, TIOCGSIZE, &size) == -1)
1765     return 0;
1766   else
1767     return 1;
1768 #else
1769   return -1;
1770 #endif /* not SunOS-style */
1771 #endif /* not BSD-style */
1772 }
1773
1774 \f
1775 /* Prepare the terminal for exiting Emacs; move the cursor to the
1776    bottom of the frame, turn off interrupt-driven I/O, etc.  */
1777 void
1778 reset_sys_modes ()
1779 {
1780   struct frame *sf;
1781
1782   if (noninteractive)
1783     {
1784       fflush (stdout);
1785       return;
1786     }
1787   if (!term_initted)
1788     return;
1789 #ifdef HAVE_WINDOW_SYSTEM
1790   /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
1791      needs the clean-up code below.  */
1792   if (!EQ (Vwindow_system, Qnil)
1793 #ifndef WINDOWSNT
1794       /* When running in tty mode on NT/Win95, we have a read_socket
1795          hook, but still need the rest of the clean-up code below.  */
1796       || read_socket_hook
1797 #endif
1798       )
1799     return;
1800 #endif
1801   sf = SELECTED_FRAME ();
1802   cursor_to (FRAME_HEIGHT (sf) - 1, 0);
1803   clear_end_of_line (FRAME_WIDTH (sf));
1804   /* clear_end_of_line may move the cursor */
1805   cursor_to (FRAME_HEIGHT (sf) - 1, 0);
1806 #if defined (IBMR2AIX) && defined (AIXHFT)
1807   {
1808     /* HFT devices normally use ^J as a LF/CR.  We forced it to
1809        do the LF only.  Now, we need to reset it. */
1810     struct termio tty;
1811
1812     if (ioctl (1, HFTGETID, &tty) != -1)
1813       write (1, "\033[20h", 5);
1814   }
1815 #endif
1816
1817   reset_terminal_modes ();
1818   fflush (stdout);
1819 #ifdef BSD_SYSTEM
1820 #ifndef BSD4_1
1821   /* Avoid possible loss of output when changing terminal modes.  */
1822   fsync (fileno (stdout));
1823 #endif
1824 #endif
1825
1826 #ifdef F_SETFL
1827 #ifndef F_SETOWN_BUG
1828 #ifdef F_SETOWN         /* F_SETFL does not imply existence of F_SETOWN */
1829   if (interrupt_input)
1830     {
1831       reset_sigio ();
1832       fcntl (input_fd, F_SETOWN, old_fcntl_owner);
1833     }
1834 #endif /* F_SETOWN */
1835 #endif /* F_SETOWN_BUG */
1836 #ifdef O_NDELAY
1837   fcntl (input_fd, F_SETFL, fcntl (input_fd, F_GETFL, 0) & ~O_NDELAY);
1838 #endif
1839 #endif /* F_SETFL */
1840 #ifdef BSD4_1
1841   if (interrupt_input)
1842     reset_sigio ();
1843 #endif /* BSD4_1 */
1844
1845   if (old_tty_valid)
1846     while (EMACS_SET_TTY (input_fd, &old_tty, 0) < 0 && errno == EINTR)
1847       ;
1848
1849 #ifdef MSDOS    /* Demacs 1.1.2 91/10/20 Manabu Higashida */
1850   dos_ttcooked ();
1851 #endif
1852
1853 #ifdef SET_LINE_DISCIPLINE
1854   /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
1855      A different old line discipline is therefore not restored, yet.
1856      Restore the old line discipline by hand.  */
1857   ioctl (0, TIOCSETD, &old_tty.main.c_line);
1858 #endif
1859
1860 #ifdef AIXHFT
1861   hft_reset ();
1862 #endif
1863
1864 #ifdef BSD_PGRPS
1865   widen_foreground_group ();
1866 #endif
1867 }
1868 \f
1869 #ifdef HAVE_PTYS
1870
1871 /* Set up the proper status flags for use of a pty.  */
1872
1873 void
1874 setup_pty (fd)
1875      int fd;
1876 {
1877   /* I'm told that TOICREMOTE does not mean control chars
1878      "can't be sent" but rather that they don't have
1879      input-editing or signaling effects.
1880      That should be good, because we have other ways
1881      to do those things in Emacs.
1882      However, telnet mode seems not to work on 4.2.
1883      So TIOCREMOTE is turned off now. */
1884
1885   /* Under hp-ux, if TIOCREMOTE is turned on, some calls
1886      will hang.  In particular, the "timeout" feature (which
1887      causes a read to return if there is no data available)
1888      does this.  Also it is known that telnet mode will hang
1889      in such a way that Emacs must be stopped (perhaps this
1890      is the same problem).
1891
1892      If TIOCREMOTE is turned off, then there is a bug in
1893      hp-ux which sometimes loses data.  Apparently the
1894      code which blocks the master process when the internal
1895      buffer fills up does not work.  Other than this,
1896      though, everything else seems to work fine.
1897
1898      Since the latter lossage is more benign, we may as well
1899      lose that way.  -- cph */
1900 #ifdef FIONBIO
1901 #ifdef SYSV_PTYS
1902   {
1903     int on = 1;
1904     ioctl (fd, FIONBIO, &on);
1905   }
1906 #endif
1907 #endif
1908 #ifdef IBMRTAIX
1909   /* On AIX, the parent gets SIGHUP when a pty attached child dies.  So, we */
1910   /* ignore SIGHUP once we've started a child on a pty.  Note that this may */
1911   /* cause EMACS not to die when it should, i.e., when its own controlling  */
1912   /* tty goes away.  I've complained to the AIX developers, and they may    */
1913   /* change this behavior, but I'm not going to hold my breath.             */
1914   signal (SIGHUP, SIG_IGN);
1915 #endif
1916 }
1917 #endif /* HAVE_PTYS */
1918 \f
1919 #ifdef VMS
1920
1921 /* Assigning an input channel is done at the start of Emacs execution.
1922    This is called each time Emacs is resumed, also, but does nothing
1923    because input_chain is no longer zero.  */
1924
1925 void
1926 init_vms_input ()
1927 {
1928   int status;
1929
1930   if (input_fd == 0)
1931     {
1932       status = SYS$ASSIGN (&input_dsc, &input_fd, 0, 0);
1933       if (! (status & 1))
1934         LIB$STOP (status);
1935     }
1936 }
1937
1938 /* Deassigning the input channel is done before exiting.  */
1939
1940 void
1941 stop_vms_input ()
1942 {
1943   return SYS$DASSGN (input_fd);
1944 }
1945
1946 short input_buffer;
1947
1948 /* Request reading one character into the keyboard buffer.
1949    This is done as soon as the buffer becomes empty.  */
1950
1951 void
1952 queue_kbd_input ()
1953 {
1954   int status;
1955   extern kbd_input_ast ();
1956
1957   waiting_for_ast = 0;
1958   stop_input = 0;
1959   status = SYS$QIO (0, input_fd, IO$_READVBLK,
1960                     &input_iosb, kbd_input_ast, 1,
1961                     &input_buffer, 1, 0, terminator_mask, 0, 0);
1962 }
1963
1964 int input_count;
1965
1966 /* Ast routine that is called when keyboard input comes in
1967    in accord with the SYS$QIO above.  */
1968
1969 void
1970 kbd_input_ast ()
1971 {
1972   register int c = -1;
1973   int old_errno = errno;
1974   extern EMACS_TIME *input_available_clear_time;
1975
1976   if (waiting_for_ast)
1977     SYS$SETEF (input_ef);
1978   waiting_for_ast = 0;
1979   input_count++;
1980 #ifdef ASTDEBUG
1981   if (input_count == 25)
1982     exit (1);
1983   printf ("Ast # %d,", input_count);
1984   printf (" iosb = %x, %x, %x, %x",
1985           input_iosb.offset, input_iosb.status, input_iosb.termlen,
1986           input_iosb.term);
1987 #endif
1988   if (input_iosb.offset)
1989     {
1990       c = input_buffer;
1991 #ifdef ASTDEBUG
1992       printf (", char = 0%o", c);
1993 #endif
1994     }
1995 #ifdef ASTDEBUG
1996   printf ("\n");
1997   fflush (stdout);
1998   sleep (1);
1999 #endif
2000   if (! stop_input)
2001     queue_kbd_input ();
2002   if (c >= 0)
2003     {
2004       struct input_event e;
2005       e.kind = ascii_keystroke;
2006       XSETINT (e.code, c);
2007       e.frame_or_window = selected_frame;
2008       kbd_buffer_store_event (&e);
2009     }
2010   if (input_available_clear_time)
2011     EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
2012   errno = old_errno;
2013 }
2014
2015 /* Wait until there is something in kbd_buffer.  */
2016
2017 void
2018 wait_for_kbd_input ()
2019 {
2020   extern int have_process_input, process_exited;
2021
2022   /* If already something, avoid doing system calls.  */
2023   if (detect_input_pending ())
2024     {
2025       return;
2026     }
2027   /* Clear a flag, and tell ast routine above to set it.  */
2028   SYS$CLREF (input_ef);
2029   waiting_for_ast = 1;
2030   /* Check for timing error: ast happened while we were doing that.  */
2031   if (!detect_input_pending ())
2032     {
2033       /* No timing error: wait for flag to be set.  */
2034       set_waiting_for_input (0);
2035       SYS$WFLOR (input_ef, input_eflist);
2036       clear_waiting_for_input (0);
2037       if (!detect_input_pending ())
2038         /* Check for subprocess input availability */
2039         {
2040           int dsp = have_process_input || process_exited;
2041
2042           SYS$CLREF (process_ef);
2043           if (have_process_input)
2044             process_command_input ();
2045           if (process_exited)
2046             process_exit ();
2047           if (dsp)
2048             {
2049               update_mode_lines++;
2050               prepare_menu_bars ();
2051               redisplay_preserve_echo_area ();
2052             }
2053         }
2054     }
2055   waiting_for_ast = 0;
2056 }
2057
2058 /* Get rid of any pending QIO, when we are about to suspend
2059    or when we want to throw away pending input.
2060    We wait for a positive sign that the AST routine has run
2061    and therefore there is no I/O request queued when we return.
2062    SYS$SETAST is used to avoid a timing error.  */
2063
2064 void
2065 end_kbd_input ()
2066 {
2067 #ifdef ASTDEBUG
2068   printf ("At end_kbd_input.\n");
2069   fflush (stdout);
2070   sleep (1);
2071 #endif
2072   if (LIB$AST_IN_PROG ())  /* Don't wait if suspending from kbd_buffer_store_event! */
2073     {
2074       SYS$CANCEL (input_fd);
2075       return;
2076     }
2077
2078   SYS$SETAST (0);
2079   /* Clear a flag, and tell ast routine above to set it.  */
2080   SYS$CLREF (input_ef);
2081   waiting_for_ast = 1;
2082   stop_input = 1;
2083   SYS$CANCEL (input_fd);
2084   SYS$SETAST (1);
2085   SYS$WAITFR (input_ef);
2086   waiting_for_ast = 0;
2087 }
2088
2089 /* Wait for either input available or time interval expiry.  */
2090
2091 void
2092 input_wait_timeout (timeval)
2093      int timeval;               /* Time to wait, in seconds */
2094 {
2095   int time [2];
2096   static int zero = 0;
2097   static int large = -10000000;
2098
2099   LIB$EMUL (&timeval, &large, &zero, time);       /* Convert to VMS format */
2100
2101   /* If already something, avoid doing system calls.  */
2102   if (detect_input_pending ())
2103     {
2104       return;
2105     }
2106   /* Clear a flag, and tell ast routine above to set it.  */
2107   SYS$CLREF (input_ef);
2108   waiting_for_ast = 1;
2109   /* Check for timing error: ast happened while we were doing that.  */
2110   if (!detect_input_pending ())
2111     {
2112       /* No timing error: wait for flag to be set.  */
2113       SYS$CANTIM (1, 0);
2114       if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
2115         SYS$WFLOR (timer_ef, timer_eflist);       /* Wait for timer expiry or input */
2116     }
2117   waiting_for_ast = 0;
2118 }
2119
2120 /* The standard `sleep' routine works some other way
2121    and it stops working if you have ever quit out of it.
2122    This one continues to work.  */
2123
2124 sys_sleep (timeval)
2125      int timeval;
2126 {
2127   int time [2];
2128   static int zero = 0;
2129   static int large = -10000000;
2130
2131   LIB$EMUL (&timeval, &large, &zero, time);       /* Convert to VMS format */
2132
2133   SYS$CANTIM (1, 0);
2134   if (SYS$SETIMR (timer_ef, time, 0, 1) & 1) /* Set timer */
2135     SYS$WAITFR (timer_ef);        /* Wait for timer expiry only */
2136 }
2137
2138 void
2139 init_sigio (fd)
2140      int fd;
2141 {
2142   request_sigio ();
2143 }
2144
2145 reset_sigio ()
2146 {
2147   unrequest_sigio ();
2148 }
2149
2150 void
2151 request_sigio ()
2152 {
2153   croak ("request sigio");
2154 }
2155
2156 void
2157 unrequest_sigio ()
2158 {
2159   croak ("unrequest sigio");
2160 }
2161
2162 #endif /* VMS */
2163 \f
2164 /* Note that VMS compiler won't accept defined (CANNOT_DUMP).  */
2165 #ifndef CANNOT_DUMP
2166 #define NEED_STARTS
2167 #endif
2168
2169 #ifndef SYSTEM_MALLOC
2170 #ifndef NEED_STARTS
2171 #define NEED_STARTS
2172 #endif
2173 #endif
2174
2175 #ifdef NEED_STARTS
2176 /* Some systems that cannot dump also cannot implement these.  */
2177
2178 /*
2179  *      Return the address of the start of the text segment prior to
2180  *      doing an unexec.  After unexec the return value is undefined.
2181  *      See crt0.c for further explanation and _start.
2182  *
2183  */
2184
2185 #ifndef HAVE_TEXT_START
2186 char *
2187 start_of_text ()
2188 {
2189 #ifdef TEXT_START
2190   return ((char *) TEXT_START);
2191 #else
2192 #ifdef GOULD
2193   extern csrt ();
2194   return ((char *) csrt);
2195 #else /* not GOULD */
2196   extern int _start ();
2197   return ((char *) _start);
2198 #endif /* GOULD */
2199 #endif /* TEXT_START */
2200 }
2201 #endif /* not HAVE_TEXT_START */
2202
2203 /*
2204  *      Return the address of the start of the data segment prior to
2205  *      doing an unexec.  After unexec the return value is undefined.
2206  *      See crt0.c for further information and definition of data_start.
2207  *
2208  *      Apparently, on BSD systems this is etext at startup.  On
2209  *      USG systems (swapping) this is highly mmu dependent and
2210  *      is also dependent on whether or not the program is running
2211  *      with shared text.  Generally there is a (possibly large)
2212  *      gap between end of text and start of data with shared text.
2213  *
2214  *      On Uniplus+ systems with shared text, data starts at a
2215  *      fixed address.  Each port (from a given oem) is generally
2216  *      different, and the specific value of the start of data can
2217  *      be obtained via the UniPlus+ specific "uvar" system call,
2218  *      however the method outlined in crt0.c seems to be more portable.
2219  *
2220  *      Probably what will have to happen when a USG unexec is available,
2221  *      at least on UniPlus, is temacs will have to be made unshared so
2222  *      that text and data are contiguous.  Then once loadup is complete,
2223  *      unexec will produce a shared executable where the data can be
2224  *      at the normal shared text boundary and the startofdata variable
2225  *      will be patched by unexec to the correct value.
2226  *
2227  */
2228
2229 char *
2230 start_of_data ()
2231 {
2232 #ifdef DATA_START
2233   return ((char *) DATA_START);
2234 #else
2235 #ifdef ORDINARY_LINK
2236   /*
2237    * This is a hack.  Since we're not linking crt0.c or pre_crt0.c,
2238    * data_start isn't defined.  We take the address of environ, which
2239    * is known to live at or near the start of the system crt0.c, and
2240    * we don't sweat the handful of bytes that might lose.
2241    */
2242   extern char **environ;
2243
2244   return ((char *) &environ);
2245 #else
2246   extern int data_start;
2247   return ((char *) &data_start);
2248 #endif /* ORDINARY_LINK */
2249 #endif /* DATA_START */
2250 }
2251 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2252
2253 #ifndef CANNOT_DUMP
2254 /* Some systems that cannot dump also cannot implement these.  */
2255
2256 /*
2257  *      Return the address of the end of the text segment prior to
2258  *      doing an unexec.  After unexec the return value is undefined.
2259  */
2260
2261 char *
2262 end_of_text ()
2263 {
2264 #ifdef TEXT_END
2265   return ((char *) TEXT_END);
2266 #else
2267   extern int etext;
2268   return ((char *) &etext);
2269 #endif
2270 }
2271
2272 /*
2273  *      Return the address of the end of the data segment prior to
2274  *      doing an unexec.  After unexec the return value is undefined.
2275  */
2276
2277 char *
2278 end_of_data ()
2279 {
2280 #ifdef DATA_END
2281   return ((char *) DATA_END);
2282 #else
2283   extern int edata;
2284   return ((char *) &edata);
2285 #endif
2286 }
2287
2288 #endif /* not CANNOT_DUMP */
2289 \f
2290 /* init_system_name sets up the string for the Lisp function
2291    system-name to return. */
2292
2293 #ifdef BSD4_1
2294 #include <whoami.h>
2295 #endif
2296
2297 extern Lisp_Object Vsystem_name;
2298
2299 #ifndef BSD4_1
2300 #ifndef VMS
2301 #ifdef HAVE_SOCKETS
2302 #include <sys/socket.h>
2303 #include <netdb.h>
2304 #endif /* HAVE_SOCKETS */
2305 #endif /* not VMS */
2306 #endif /* not BSD4_1 */
2307
2308 void
2309 init_system_name ()
2310 {
2311 #ifdef BSD4_1
2312   Vsystem_name = build_string (sysname);
2313 #else
2314 #ifdef VMS
2315   char *sp, *end;
2316   if ((sp = egetenv ("SYS$NODE")) == 0)
2317     Vsystem_name = build_string ("vax-vms");
2318   else if ((end = index (sp, ':')) == 0)
2319     Vsystem_name = build_string (sp);
2320   else
2321     Vsystem_name = make_string (sp, end - sp);
2322 #else
2323 #ifndef HAVE_GETHOSTNAME
2324   struct utsname uts;
2325   uname (&uts);
2326   Vsystem_name = build_string (uts.nodename);
2327 #else /* HAVE_GETHOSTNAME */
2328   unsigned int hostname_size = 256;
2329   char *hostname = (char *) alloca (hostname_size);
2330
2331   /* Try to get the host name; if the buffer is too short, try
2332      again.  Apparently, the only indication gethostname gives of
2333      whether the buffer was large enough is the presence or absence
2334      of a '\0' in the string.  Eech.  */
2335   for (;;)
2336     {
2337       gethostname (hostname, hostname_size - 1);
2338       hostname[hostname_size - 1] = '\0';
2339
2340       /* Was the buffer large enough for the '\0'?  */
2341       if (strlen (hostname) < hostname_size - 1)
2342         break;
2343
2344       hostname_size <<= 1;
2345       hostname = (char *) alloca (hostname_size);
2346     }
2347 #ifdef HAVE_SOCKETS
2348   /* Turn the hostname into the official, fully-qualified hostname.
2349      Don't do this if we're going to dump; this can confuse system
2350      libraries on some machines and make the dumped emacs core dump. */
2351 #ifndef CANNOT_DUMP
2352   if (initialized)
2353 #endif /* not CANNOT_DUMP */
2354     if (! index (hostname, '.'))
2355       {
2356         struct hostent *hp;
2357         int count;
2358         for (count = 0;; count++)
2359           {
2360 #ifdef TRY_AGAIN
2361             h_errno = 0;
2362 #endif
2363             hp = gethostbyname (hostname);
2364 #ifdef TRY_AGAIN
2365             if (! (hp == 0 && h_errno == TRY_AGAIN))
2366 #endif
2367               break;
2368             if (count >= 5)
2369               break;
2370             Fsleep_for (make_number (1), Qnil);
2371           }
2372         if (hp)
2373           {
2374             char *fqdn = (char *) hp->h_name;
2375             char *p;
2376
2377             if (!index (fqdn, '.'))
2378               {
2379                 /* We still don't have a fully qualified domain name.
2380                    Try to find one in the list of alternate names */
2381                 char **alias = hp->h_aliases;
2382                 while (*alias && !index (*alias, '.'))
2383                   alias++;
2384                 if (*alias)
2385                   fqdn = *alias;
2386               }
2387             hostname = fqdn;
2388 #if 0
2389             /* Convert the host name to lower case.  */
2390             /* Using ctype.h here would introduce a possible locale
2391                dependence that is probably wrong for hostnames.  */
2392             p = hostname;
2393             while (*p)
2394               {
2395                 if (*p >= 'A' && *p <= 'Z')
2396                   *p += 'a' - 'A';
2397                 p++;
2398               }
2399 #endif
2400           }
2401       }
2402 #endif /* HAVE_SOCKETS */
2403   /* We used to try using getdomainname here,
2404      but NIIBE Yutaka <gniibe@etl.go.jp> says that
2405      getdomainname gets the NIS/YP domain which often is not the same
2406      as in Internet domain name.  */
2407 #if 0 /* Turned off because sysinfo is not really likely to return the
2408          correct Internet domain.  */
2409 #if (HAVE_SYSINFO && defined (SI_SRPC_DOMAIN))
2410   if (! index (hostname, '.'))
2411     {
2412       /* The hostname is not fully qualified.  Append the domain name.  */
2413
2414       int hostlen = strlen (hostname);
2415       int domain_size = 256;
2416
2417       for (;;)
2418         {
2419           char *domain = (char *) alloca (domain_size + 1);
2420           char *fqdn = (char *) alloca (hostlen + 1 + domain_size + 1);
2421           int sys_domain_size = sysinfo (SI_SRPC_DOMAIN, domain, domain_size);
2422           if (sys_domain_size <= 0)
2423             break;
2424           if (domain_size < sys_domain_size)
2425             {
2426               domain_size = sys_domain_size;
2427               continue;
2428             }
2429           strcpy (fqdn, hostname);
2430           if (domain[0] == '.')
2431             strcpy (fqdn + hostlen, domain);
2432           else if (domain[0] != 0)
2433             {
2434               fqdn[hostlen] = '.';
2435               strcpy (fqdn + hostlen + 1, domain);
2436             }
2437           hostname = fqdn;
2438           break;
2439         }
2440     }
2441 #endif /* HAVE_SYSINFO && defined (SI_SRPC_DOMAIN) */
2442 #endif /* 0 */
2443   Vsystem_name = build_string (hostname);
2444 #endif /* HAVE_GETHOSTNAME */
2445 #endif /* VMS */
2446 #endif /* BSD4_1 */
2447   {
2448     unsigned char *p;
2449     for (p = XSTRING (Vsystem_name)->data; *p; p++)
2450       if (*p == ' ' || *p == '\t')
2451         *p = '-';
2452   }
2453 }
2454 \f
2455 #ifndef MSDOS
2456 #ifndef VMS
2457 #if !defined (HAVE_SELECT) || defined (BROKEN_SELECT_NON_X)
2458
2459 #include "sysselect.h"
2460 #undef select
2461
2462 #if defined (HAVE_X_WINDOWS) && !defined (HAVE_SELECT)
2463 /* Cause explanatory error message at compile time,
2464    since the select emulation is not good enough for X.  */
2465 int *x = &x_windows_lose_if_no_select_system_call;
2466 #endif
2467
2468 /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs
2469  * Only checks read descriptors.
2470  */
2471 /* How long to wait between checking fds in select */
2472 #define SELECT_PAUSE 1
2473 int select_alarmed;
2474
2475 /* For longjmp'ing back to read_input_waiting.  */
2476
2477 jmp_buf read_alarm_throw;
2478
2479 /* Nonzero if the alarm signal should throw back to read_input_waiting.
2480    The read_socket_hook function sets this to 1 while it is waiting.  */
2481
2482 int read_alarm_should_throw;
2483
2484 SIGTYPE
2485 select_alarm ()
2486 {
2487   select_alarmed = 1;
2488 #ifdef BSD4_1
2489   sigrelse (SIGALRM);
2490 #else /* not BSD4_1 */
2491   signal (SIGALRM, SIG_IGN);
2492 #endif /* not BSD4_1 */
2493   if (read_alarm_should_throw)
2494     longjmp (read_alarm_throw, 1);
2495 }
2496
2497 #ifndef WINDOWSNT
2498 /* Only rfds are checked.  */
2499 int
2500 sys_select (nfds, rfds, wfds, efds, timeout)
2501      int nfds;
2502      SELECT_TYPE *rfds, *wfds, *efds;
2503      EMACS_TIME *timeout;
2504 {
2505   int ravail = 0, old_alarm;
2506   SELECT_TYPE orfds;
2507   int timeoutval;
2508   int *local_timeout;
2509   extern int proc_buffered_char[];
2510 #ifndef subprocesses
2511   int process_tick = 0, update_tick = 0;
2512 #else
2513   extern int process_tick, update_tick;
2514 #endif
2515   SIGTYPE (*old_trap) ();
2516   unsigned char buf;
2517
2518 #if defined (HAVE_SELECT) && defined (HAVE_X_WINDOWS)
2519   /* If we're using X, then the native select will work; we only need the
2520      emulation for non-X usage.  */
2521   if (!NILP (Vwindow_system))
2522     return select (nfds, rfds, wfds, efds, timeout);
2523 #endif
2524   timeoutval = timeout ? EMACS_SECS (*timeout) : 100000;
2525   local_timeout = &timeoutval;
2526   FD_ZERO (&orfds);
2527   if (rfds)
2528     {
2529       orfds = *rfds;
2530       FD_ZERO (rfds);
2531     }
2532   if (wfds)
2533     FD_ZERO (wfds);
2534   if (efds)
2535     FD_ZERO (efds);
2536
2537   /* If we are looking only for the terminal, with no timeout,
2538      just read it and wait -- that's more efficient.  */
2539   if (*local_timeout == 100000 && process_tick == update_tick
2540       && FD_ISSET (0, &orfds))
2541     {
2542       int fd;
2543       for (fd = 1; fd < nfds; ++fd)
2544         if (FD_ISSET (fd, &orfds))
2545           goto hardway;
2546       if (! detect_input_pending ())
2547         read_input_waiting ();
2548       FD_SET (0, rfds);
2549       return 1;
2550     }
2551
2552  hardway:
2553   /* Once a second, till the timer expires, check all the flagged read
2554    * descriptors to see if any input is available.  If there is some then
2555    * set the corresponding bit in the return copy of rfds.
2556    */
2557   while (1)
2558     {
2559       register int to_check, fd;
2560
2561       if (rfds)
2562         {
2563           for (to_check = nfds, fd = 0; --to_check >= 0; fd++)
2564             {
2565               if (FD_ISSET (fd, &orfds))
2566                 {
2567                   int avail = 0, status = 0;
2568
2569                   if (fd == 0)
2570                     avail = detect_input_pending (); /* Special keyboard handler */
2571                   else
2572                     {
2573 #ifdef FIONREAD
2574                       status = ioctl (fd, FIONREAD, &avail);
2575 #else /* no FIONREAD */
2576                       /* Hoping it will return -1 if nothing available
2577                          or 0 if all 0 chars requested are read.  */
2578                       if (proc_buffered_char[fd] >= 0)
2579                         avail = 1;
2580                       else
2581                         {
2582                           avail = read (fd, &buf, 1);
2583                           if (avail > 0)
2584                             proc_buffered_char[fd] = buf;
2585                         }
2586 #endif /* no FIONREAD */
2587                     }
2588                   if (status >= 0 && avail > 0)
2589                     {
2590                       FD_SET (fd, rfds);
2591                       ravail++;
2592                     }
2593                 }
2594             }
2595         }
2596       if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
2597         break;
2598       old_alarm = alarm (0);
2599       old_trap = signal (SIGALRM, select_alarm);
2600       select_alarmed = 0;
2601       alarm (SELECT_PAUSE);
2602       /* Wait for a SIGALRM (or maybe a SIGTINT) */
2603       while (select_alarmed == 0 && *local_timeout != 0
2604              && process_tick == update_tick)
2605         {
2606           /* If we are interested in terminal input,
2607              wait by reading the terminal.
2608              That makes instant wakeup for terminal input at least.  */
2609           if (FD_ISSET (0, &orfds))
2610             {
2611               read_input_waiting ();
2612               if (detect_input_pending ())
2613                 select_alarmed = 1;
2614             }
2615           else
2616             pause ();
2617         }
2618       (*local_timeout) -= SELECT_PAUSE;
2619       /* Reset the old alarm if there was one */
2620       alarm (0);
2621       signal (SIGALRM, old_trap);
2622       if (old_alarm != 0)
2623         {
2624           /* Reset or forge an interrupt for the original handler. */
2625           old_alarm -= SELECT_PAUSE;
2626           if (old_alarm <= 0)
2627             kill (getpid (), SIGALRM); /* Fake an alarm with the orig' handler */
2628           else
2629             alarm (old_alarm);
2630         }
2631       if (*local_timeout == 0)  /* Stop on timer being cleared */
2632         break;
2633     }
2634   return ravail;
2635 }
2636 #endif /* not WINDOWSNT */
2637
2638 /* Read keyboard input into the standard buffer,
2639    waiting for at least one character.  */
2640
2641 /* Make all keyboard buffers much bigger when using a window system.  */
2642 #ifdef HAVE_WINDOW_SYSTEM
2643 #define BUFFER_SIZE_FACTOR 16
2644 #else
2645 #define BUFFER_SIZE_FACTOR 1
2646 #endif
2647
2648 void
2649 read_input_waiting ()
2650 {
2651   struct input_event e;
2652   int nread, i;
2653   extern int quit_char;
2654
2655   if (read_socket_hook)
2656     {
2657       struct input_event buf[256];
2658
2659       read_alarm_should_throw = 0;
2660       if (! setjmp (read_alarm_throw))
2661         nread = (*read_socket_hook) (0, buf, 256, 1);
2662       else
2663         nread = -1;
2664
2665       /* Scan the chars for C-g and store them in kbd_buffer.  */
2666       for (i = 0; i < nread; i++)
2667         {
2668           kbd_buffer_store_event (&buf[i]);
2669           /* Don't look at input that follows a C-g too closely.
2670              This reduces lossage due to autorepeat on C-g.  */
2671           if (buf[i].kind == ascii_keystroke
2672               && buf[i].code == quit_char)
2673             break;
2674         }
2675     }
2676   else
2677     {
2678       char buf[3];
2679       nread = read (fileno (stdin), buf, 1);
2680
2681       /* Scan the chars for C-g and store them in kbd_buffer.  */
2682       e.kind = ascii_keystroke;
2683       e.frame_or_window = selected_frame;
2684       e.modifiers = 0;
2685       for (i = 0; i < nread; i++)
2686         {
2687           /* Convert chars > 0177 to meta events if desired.
2688              We do this under the same conditions that read_avail_input does.  */
2689           if (read_socket_hook == 0)
2690             {
2691               /* If the user says she has a meta key, then believe her. */
2692               if (meta_key == 1 && (buf[i] & 0x80))
2693                 e.modifiers = meta_modifier;
2694               if (meta_key != 2)
2695                 buf[i] &= ~0x80;
2696             }
2697
2698           XSETINT (e.code, buf[i]);
2699           kbd_buffer_store_event (&e);
2700           /* Don't look at input that follows a C-g too closely.
2701              This reduces lossage due to autorepeat on C-g.  */
2702           if (buf[i] == quit_char)
2703             break;
2704         }
2705     }
2706 }
2707
2708 #endif /* not HAVE_SELECT */
2709 #endif /* not VMS */
2710 #endif /* not MSDOS */
2711 \f
2712 #ifdef BSD4_1
2713 /*
2714  * Partially emulate 4.2 open call.
2715  * open is defined as this in 4.1.
2716  *
2717  * - added by Michael Bloom @ Citicorp/TTI
2718  *
2719  */
2720
2721 int
2722 sys_open (path, oflag, mode)
2723      char *path;
2724      int oflag, mode;
2725 {
2726   if (oflag & O_CREAT)
2727     return creat (path, mode);
2728   else
2729     return open (path, oflag);
2730 }
2731
2732 void
2733 init_sigio (fd)
2734      int fd;
2735 {
2736   if (noninteractive)
2737     return;
2738   lmode = LINTRUP | lmode;
2739   ioctl (fd, TIOCLSET, &lmode);
2740 }
2741
2742 void
2743 reset_sigio ()
2744 {
2745   if (noninteractive)
2746     return;
2747   lmode = ~LINTRUP & lmode;
2748   ioctl (0, TIOCLSET, &lmode);
2749 }
2750
2751 void
2752 request_sigio ()
2753 {
2754   sigrelse (SIGTINT);
2755
2756   interrupts_deferred = 0;
2757 }
2758
2759 void
2760 unrequest_sigio ()
2761 {
2762   sighold (SIGTINT);
2763
2764   interrupts_deferred = 1;
2765 }
2766
2767 /* still inside #ifdef BSD4_1 */
2768 #ifdef subprocesses
2769
2770 int sigheld; /* Mask of held signals */
2771
2772 void
2773 sigholdx (signum)
2774      int signum;
2775 {
2776   sigheld |= sigbit (signum);
2777   sighold (signum);
2778 }
2779
2780 void
2781 sigisheld (signum)
2782      int signum;
2783 {
2784   sigheld |= sigbit (signum);
2785 }
2786
2787 void
2788 sigunhold (signum)
2789      int signum;
2790 {
2791   sigheld &= ~sigbit (signum);
2792   sigrelse (signum);
2793 }
2794
2795 void
2796 sigfree ()    /* Free all held signals */
2797 {
2798   int i;
2799   for (i = 0; i < NSIG; i++)
2800     if (sigheld & sigbit (i))
2801       sigrelse (i);
2802   sigheld = 0;
2803 }
2804
2805 int
2806 sigbit (i)
2807 {
2808   return 1 << (i - 1);
2809 }
2810 #endif /* subprocesses */
2811 #endif /* BSD4_1 */
2812 \f
2813 /* POSIX signals support - DJB */
2814 /* Anyone with POSIX signals should have ANSI C declarations */
2815
2816 #ifdef POSIX_SIGNALS
2817
2818 sigset_t empty_mask, full_mask;
2819
2820 void
2821 init_signals ()
2822 {
2823   sigemptyset (&empty_mask);
2824   sigfillset (&full_mask);
2825 }
2826
2827 signal_handler_t
2828 sys_signal (int signal_number, signal_handler_t action)
2829 {
2830   struct sigaction new_action, old_action;
2831   sigemptyset (&new_action.sa_mask);
2832   new_action.sa_handler = action;
2833 #ifdef SA_RESTART
2834   /* Emacs mostly works better with restartable system services. If this
2835    * flag exists, we probably want to turn it on here.
2836    */
2837   new_action.sa_flags = SA_RESTART;
2838 #else
2839   new_action.sa_flags = 0;
2840 #endif
2841   sigaction (signal_number, &new_action, &old_action);
2842   return (old_action.sa_handler);
2843 }
2844
2845 #ifndef __GNUC__
2846 /* If we're compiling with GCC, we don't need this function, since it
2847    can be written as a macro.  */
2848 sigset_t
2849 sys_sigmask (int sig)
2850 {
2851   sigset_t mask;
2852   sigemptyset (&mask);
2853   sigaddset (&mask, sig);
2854   return mask;
2855 }
2856 #endif
2857
2858 /* I'd like to have these guys return pointers to the mask storage in here,
2859    but there'd be trouble if the code was saving multiple masks.  I'll be
2860    safe and pass the structure.  It normally won't be more than 2 bytes
2861    anyhow. - DJB */
2862
2863 sigset_t
2864 sys_sigblock (sigset_t new_mask)
2865 {
2866   sigset_t old_mask;
2867   sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2868   return (old_mask);
2869 }
2870
2871 sigset_t
2872 sys_sigunblock (sigset_t new_mask)
2873 {
2874   sigset_t old_mask;
2875   sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2876   return (old_mask);
2877 }
2878
2879 sigset_t
2880 sys_sigsetmask (sigset_t new_mask)
2881 {
2882   sigset_t old_mask;
2883   sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2884   return (old_mask);
2885 }
2886
2887 #endif /* POSIX_SIGNALS */
2888 \f
2889 #ifndef HAVE_RANDOM
2890 #ifdef random
2891 #define HAVE_RANDOM
2892 #endif
2893 #endif
2894
2895 /* Figure out how many bits the system's random number generator uses.
2896    `random' and `lrand48' are assumed to return 31 usable bits.
2897    BSD `rand' returns a 31 bit value but the low order bits are unusable;
2898    so we'll shift it and treat it like the 15-bit USG `rand'.  */
2899
2900 #ifndef RAND_BITS
2901 # ifdef HAVE_RANDOM
2902 #  define RAND_BITS 31
2903 # else /* !HAVE_RANDOM */
2904 #  ifdef HAVE_LRAND48
2905 #   define RAND_BITS 31
2906 #   define random lrand48
2907 #  else /* !HAVE_LRAND48 */
2908 #   define RAND_BITS 15
2909 #   if RAND_MAX == 32767
2910 #    define random rand
2911 #   else /* RAND_MAX != 32767 */
2912 #    if RAND_MAX == 2147483647
2913 #     define random() (rand () >> 16)
2914 #    else /* RAND_MAX != 2147483647 */
2915 #     ifdef USG
2916 #      define random rand
2917 #     else
2918 #      define random() (rand () >> 16)
2919 #     endif /* !USG */
2920 #    endif /* RAND_MAX != 2147483647 */
2921 #   endif /* RAND_MAX != 32767 */
2922 #  endif /* !HAVE_LRAND48 */
2923 # endif /* !HAVE_RANDOM */
2924 #endif /* !RAND_BITS */
2925
2926 void
2927 seed_random (arg)
2928      long arg;
2929 {
2930 #ifdef HAVE_RANDOM
2931   srandom ((unsigned int)arg);
2932 #else
2933 # ifdef HAVE_LRAND48
2934   srand48 (arg);
2935 # else
2936   srand ((unsigned int)arg);
2937 # endif
2938 #endif
2939 }
2940
2941 /*
2942  * Build a full Emacs-sized word out of whatever we've got.
2943  * This suffices even for a 64-bit architecture with a 15-bit rand.
2944  */
2945 long
2946 get_random ()
2947 {
2948   long val = random ();
2949 #if VALBITS > RAND_BITS
2950   val = (val << RAND_BITS) ^ random ();
2951 #if VALBITS > 2*RAND_BITS
2952   val = (val << RAND_BITS) ^ random ();
2953 #if VALBITS > 3*RAND_BITS
2954   val = (val << RAND_BITS) ^ random ();
2955 #if VALBITS > 4*RAND_BITS
2956   val = (val << RAND_BITS) ^ random ();
2957 #endif /* need at least 5 */
2958 #endif /* need at least 4 */
2959 #endif /* need at least 3 */
2960 #endif /* need at least 2 */
2961   return val & ((1L << VALBITS) - 1);
2962 }
2963 \f
2964 #ifdef WRONG_NAME_INSQUE
2965
2966 insque (q,p)
2967      caddr_t q,p;
2968 {
2969   _insque (q,p);
2970 }
2971
2972 #endif
2973 \f
2974 #ifdef VMS
2975
2976 #ifdef getenv
2977 /* If any place else asks for the TERM variable,
2978    allow it to be overridden with the EMACS_TERM variable
2979    before attempting to translate the logical name TERM.  As a last
2980    resort, ask for VAX C's special idea of the TERM variable.  */
2981 #undef getenv
2982 char *
2983 sys_getenv (name)
2984      char *name;
2985 {
2986   register char *val;
2987   static char buf[256];
2988   static struct dsc$descriptor_s equiv
2989     = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
2990   static struct dsc$descriptor_s d_name
2991     = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
2992   short eqlen;
2993
2994   if (!strcmp (name, "TERM"))
2995     {
2996       val = (char *) getenv ("EMACS_TERM");
2997       if (val)
2998         return val;
2999     }
3000
3001   d_name.dsc$w_length = strlen (name);
3002   d_name.dsc$a_pointer = name;
3003   if (LIB$SYS_TRNLOG (&d_name, &eqlen, &equiv) == 1)
3004     {
3005       char *str = (char *) xmalloc (eqlen + 1);
3006       bcopy (buf, str, eqlen);
3007       str[eqlen] = '\0';
3008       /* This is a storage leak, but a pain to fix.  With luck,
3009          no one will ever notice.  */
3010       return str;
3011     }
3012   return (char *) getenv (name);
3013 }
3014 #endif /* getenv */
3015
3016 #ifdef abort
3017 /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
3018    to force a call on the debugger from within the image. */
3019 #undef abort
3020 sys_abort ()
3021 {
3022   reset_sys_modes ();
3023   LIB$SIGNAL (SS$_DEBUG);
3024 }
3025 #endif /* abort */
3026 #endif /* VMS */
3027 \f
3028 #ifdef VMS
3029 #ifdef LINK_CRTL_SHARE
3030 #ifdef SHARABLE_LIB_BUG
3031 /* Variables declared noshare and initialized in sharable libraries
3032    cannot be shared.  The VMS linker incorrectly forces you to use a private
3033    version which is uninitialized... If not for this "feature", we
3034    could use the C library definition of sys_nerr and sys_errlist. */
3035 int sys_nerr = 35;
3036 char *sys_errlist[] =
3037   {
3038     "error 0",
3039     "not owner",
3040     "no such file or directory",
3041     "no such process",
3042     "interrupted system call",
3043     "i/o error",
3044     "no such device or address",
3045     "argument list too long",
3046     "exec format error",
3047     "bad file number",
3048     "no child process",
3049     "no more processes",
3050     "not enough memory",
3051     "permission denied",
3052     "bad address",
3053     "block device required",
3054     "mount devices busy",
3055     "file exists",
3056     "cross-device link",
3057     "no such device",
3058     "not a directory",
3059     "is a directory",
3060     "invalid argument",
3061     "file table overflow",
3062     "too many open files",
3063     "not a typewriter",
3064     "text file busy",
3065     "file too big",
3066     "no space left on device",
3067     "illegal seek",
3068     "read-only file system",
3069     "too many links",
3070     "broken pipe",
3071     "math argument",
3072     "result too large",
3073     "I/O stream empty",
3074     "vax/vms specific error code nontranslatable error"
3075   };
3076 #endif /* SHARABLE_LIB_BUG */
3077 #endif /* LINK_CRTL_SHARE */
3078 #endif /* VMS */
3079
3080 #ifndef HAVE_STRERROR
3081 #ifndef WINDOWSNT
3082 char *
3083 strerror (errnum)
3084      int errnum;
3085 {
3086   extern char *sys_errlist[];
3087   extern int sys_nerr;
3088
3089   if (errnum >= 0 && errnum < sys_nerr)
3090     return sys_errlist[errnum];
3091   return (char *) "Unknown error";
3092 }
3093 #endif /* not WINDOWSNT */
3094 #endif /* ! HAVE_STRERROR */
3095 \f
3096 #ifdef INTERRUPTIBLE_OPEN
3097
3098 int
3099 /* VARARGS 2 */
3100 sys_open (path, oflag, mode)
3101      char *path;
3102      int oflag, mode;
3103 {
3104   register int rtnval;
3105
3106   while ((rtnval = open (path, oflag, mode)) == -1
3107          && (errno == EINTR));
3108   return (rtnval);
3109 }
3110
3111 #endif /* INTERRUPTIBLE_OPEN */
3112
3113 #ifdef INTERRUPTIBLE_CLOSE
3114
3115 int
3116 sys_close (fd)
3117      int fd;
3118 {
3119   int did_retry = 0;
3120   register int rtnval;
3121
3122   while ((rtnval = close (fd)) == -1
3123          && (errno == EINTR))
3124     did_retry = 1;
3125
3126   /* If close is interrupted SunOS 4.1 may or may not have closed the
3127      file descriptor.  If it did the second close will fail with
3128      errno = EBADF.  That means we have succeeded.  */
3129   if (rtnval == -1 && did_retry && errno == EBADF)
3130     return 0;
3131
3132   return rtnval;
3133 }
3134
3135 #endif /* INTERRUPTIBLE_CLOSE */
3136
3137 #ifdef INTERRUPTIBLE_IO
3138
3139 int
3140 sys_read (fildes, buf, nbyte)
3141      int fildes;
3142      char *buf;
3143      unsigned int nbyte;
3144 {
3145   register int rtnval;
3146
3147   while ((rtnval = read (fildes, buf, nbyte)) == -1
3148          && (errno == EINTR));
3149   return (rtnval);
3150 }
3151
3152 int
3153 sys_write (fildes, buf, nbyte)
3154      int fildes;
3155      char *buf;
3156      unsigned int nbyte;
3157 {
3158   register int rtnval, bytes_written;
3159
3160   bytes_written = 0;
3161
3162   while (nbyte > 0)
3163     {
3164       rtnval = write (fildes, buf, nbyte);
3165
3166       if (rtnval == -1)
3167         {
3168           if (errno == EINTR)
3169             continue;
3170           else
3171             return (bytes_written ? bytes_written : -1);
3172         }
3173
3174       buf += rtnval;
3175       nbyte -= rtnval;
3176       bytes_written += rtnval;
3177     }
3178   return (bytes_written);
3179 }
3180
3181 #endif /* INTERRUPTIBLE_IO */
3182 \f
3183 #ifndef HAVE_VFORK
3184 #ifndef WINDOWSNT
3185 /*
3186  *      Substitute fork for vfork on USG flavors.
3187  */
3188
3189 VFORK_RETURN_TYPE
3190 vfork ()
3191 {
3192   return (fork ());
3193 }
3194 #endif /* not WINDOWSNT */
3195 #endif /* not HAVE_VFORK */
3196 \f
3197 #ifdef USG
3198 /*
3199  *      All of the following are for USG.
3200  *
3201  *      On USG systems the system calls are INTERRUPTIBLE by signals
3202  *      that the user program has elected to catch.  Thus the system call
3203  *      must be retried in these cases.  To handle this without massive
3204  *      changes in the source code, we remap the standard system call names
3205  *      to names for our own functions in sysdep.c that do the system call
3206  *      with retries.  Actually, for portability reasons, it is good
3207  *      programming practice, as this example shows, to limit all actual
3208  *      system calls to a single occurrence in the source.  Sure, this
3209  *      adds an extra level of function call overhead but it is almost
3210  *      always negligible.   Fred Fish, Unisoft Systems Inc.
3211  */
3212
3213 #ifndef HAVE_SYS_SIGLIST
3214 char *sys_siglist[NSIG + 1] =
3215 {
3216 #ifdef AIX
3217 /* AIX has changed the signals a bit */
3218   "bogus signal",                       /* 0 */
3219   "hangup",                             /* 1  SIGHUP */
3220   "interrupt",                          /* 2  SIGINT */
3221   "quit",                               /* 3  SIGQUIT */
3222   "illegal instruction",                /* 4  SIGILL */
3223   "trace trap",                         /* 5  SIGTRAP */
3224   "IOT instruction",                    /* 6  SIGIOT */
3225   "crash likely",                       /* 7  SIGDANGER */
3226   "floating point exception",           /* 8  SIGFPE */
3227   "kill",                               /* 9  SIGKILL */
3228   "bus error",                          /* 10 SIGBUS */
3229   "segmentation violation",             /* 11 SIGSEGV */
3230   "bad argument to system call",        /* 12 SIGSYS */
3231   "write on a pipe with no one to read it", /* 13 SIGPIPE */
3232   "alarm clock",                        /* 14 SIGALRM */
3233   "software termination signum",        /* 15 SIGTERM */
3234   "user defined signal 1",              /* 16 SIGUSR1 */
3235   "user defined signal 2",              /* 17 SIGUSR2 */
3236   "death of a child",                   /* 18 SIGCLD */
3237   "power-fail restart",                 /* 19 SIGPWR */
3238   "bogus signal",                       /* 20 */
3239   "bogus signal",                       /* 21 */
3240   "bogus signal",                       /* 22 */
3241   "bogus signal",                       /* 23 */
3242   "bogus signal",                       /* 24 */
3243   "LAN I/O interrupt",                  /* 25 SIGAIO */
3244   "PTY I/O interrupt",                  /* 26 SIGPTY */
3245   "I/O intervention required",          /* 27 SIGIOINT */
3246 #ifdef AIXHFT
3247   "HFT grant",                          /* 28 SIGGRANT */
3248   "HFT retract",                        /* 29 SIGRETRACT */
3249   "HFT sound done",                     /* 30 SIGSOUND */
3250   "HFT input ready",                    /* 31 SIGMSG */
3251 #endif
3252 #else /* not AIX */
3253   "bogus signal",                       /* 0 */
3254   "hangup",                             /* 1  SIGHUP */
3255   "interrupt",                          /* 2  SIGINT */
3256   "quit",                               /* 3  SIGQUIT */
3257   "illegal instruction",                /* 4  SIGILL */
3258   "trace trap",                         /* 5  SIGTRAP */
3259   "IOT instruction",                    /* 6  SIGIOT */
3260   "EMT instruction",                    /* 7  SIGEMT */
3261   "floating point exception",           /* 8  SIGFPE */
3262   "kill",                               /* 9  SIGKILL */
3263   "bus error",                          /* 10 SIGBUS */
3264   "segmentation violation",             /* 11 SIGSEGV */
3265   "bad argument to system call",        /* 12 SIGSYS */
3266   "write on a pipe with no one to read it", /* 13 SIGPIPE */
3267   "alarm clock",                        /* 14 SIGALRM */
3268   "software termination signum",        /* 15 SIGTERM */
3269   "user defined signal 1",              /* 16 SIGUSR1 */
3270   "user defined signal 2",              /* 17 SIGUSR2 */
3271   "death of a child",                   /* 18 SIGCLD */
3272   "power-fail restart",                 /* 19 SIGPWR */
3273 #ifdef sun
3274   "window size change",                     /* 20 SIGWINCH */
3275   "urgent socket condition",                /* 21 SIGURG */
3276   "pollable event occurred",                /* 22 SIGPOLL */
3277   "stop (cannot be caught or ignored)", /*  23 SIGSTOP */
3278   "user stop requested from tty",           /* 24 SIGTSTP */
3279   "stopped process has been continued", /* 25 SIGCONT */
3280   "background tty read attempted",          /* 26 SIGTTIN */
3281   "background tty write attempted",    /* 27 SIGTTOU */
3282   "virtual timer expired",                  /* 28 SIGVTALRM */
3283   "profiling timer expired",                /* 29 SIGPROF */
3284   "exceeded cpu limit",                     /* 30 SIGXCPU */
3285   "exceeded file size limit",               /* 31 SIGXFSZ */
3286   "process's lwps are blocked",     /*  32 SIGWAITING */
3287   "special signal used by thread library", /* 33 SIGLWP */
3288 #ifdef SIGFREEZE
3289   "Special Signal Used By CPR",     /* 34 SIGFREEZE */
3290 #endif
3291 #ifdef SIGTHAW
3292   "Special Signal Used By CPR",     /* 35 SIGTHAW */
3293 #endif
3294 #endif /* sun */
3295 #endif /* not AIX */
3296   0
3297   };
3298 #endif /* HAVE_SYS_SIGLIST */
3299
3300 /*
3301  *      Warning, this function may not duplicate 4.2 action properly
3302  *      under error conditions.
3303  */
3304
3305 #ifndef MAXPATHLEN
3306 /* In 4.1, param.h fails to define this.  */
3307 #define MAXPATHLEN 1024
3308 #endif
3309
3310 #ifndef HAVE_GETWD
3311
3312 char *
3313 getwd (pathname)
3314      char *pathname;
3315 {
3316   char *npath, *spath;
3317   extern char *getcwd ();
3318
3319   BLOCK_INPUT;                  /* getcwd uses malloc */
3320   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3321   if (spath == 0)
3322     return spath;
3323   /* On Altos 3068, getcwd can return @hostname/dir, so discard
3324      up to first slash.  Should be harmless on other systems.  */
3325   while (*npath && *npath != '/')
3326     npath++;
3327   strcpy (pathname, npath);
3328   free (spath);                 /* getcwd uses malloc */
3329   UNBLOCK_INPUT;
3330   return pathname;
3331 }
3332
3333 #endif /* HAVE_GETWD */
3334
3335 /*
3336  *      Emulate rename using unlink/link.  Note that this is
3337  *      only partially correct.  Also, doesn't enforce restriction
3338  *      that files be of same type (regular->regular, dir->dir, etc).
3339  */
3340
3341 #ifndef HAVE_RENAME
3342
3343 rename (from, to)
3344      const char *from;
3345      const char *to;
3346 {
3347   if (access (from, 0) == 0)
3348     {
3349       unlink (to);
3350       if (link (from, to) == 0)
3351         if (unlink (from) == 0)
3352           return (0);
3353     }
3354   return (-1);
3355 }
3356
3357 #endif
3358
3359
3360 #ifdef HPUX
3361 #ifndef HAVE_PERROR
3362
3363 /* HPUX curses library references perror, but as far as we know
3364    it won't be called.  Anyway this definition will do for now.  */
3365
3366 perror ()
3367 {
3368 }
3369
3370 #endif /* not HAVE_PERROR */
3371 #endif /* HPUX */
3372
3373 #ifndef HAVE_DUP2
3374
3375 /*
3376  *      Emulate BSD dup2.  First close newd if it already exists.
3377  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
3378  *      until we are, then close the unsuccessful ones.
3379  */
3380
3381 dup2 (oldd, newd)
3382      int oldd;
3383      int newd;
3384 {
3385   register int fd, ret;
3386
3387   sys_close (newd);
3388
3389 #ifdef F_DUPFD
3390   fd = fcntl (oldd, F_DUPFD, newd);
3391   if (fd != newd)
3392     error ("can't dup2 (%i,%i) : %s", oldd, newd, strerror (errno));
3393 #else
3394   fd = dup (old);
3395   if (fd == -1)
3396     return -1;
3397   if (fd == new)
3398     return new;
3399   ret = dup2 (old,new);
3400   sys_close (fd);
3401   return ret;
3402 #endif
3403 }
3404
3405 #endif /* not HAVE_DUP2 */
3406
3407 /*
3408  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3409  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3410  *      Only needed when subprocesses are defined.
3411  */
3412
3413 #ifdef subprocesses
3414 #ifndef VMS
3415 #ifndef HAVE_GETTIMEOFDAY
3416 #ifdef HAVE_TIMEVAL
3417
3418 /* ARGSUSED */
3419 int
3420 gettimeofday (tp, tzp)
3421      struct timeval *tp;
3422      struct timezone *tzp;
3423 {
3424   extern long time ();
3425
3426   tp->tv_sec = time ((long *)0);
3427   tp->tv_usec = 0;
3428   if (tzp != 0)
3429     tzp->tz_minuteswest = -1;
3430   return 0;
3431 }
3432
3433 #endif
3434 #endif
3435 #endif
3436 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3437
3438 /*
3439  *      This function will go away as soon as all the stubs fixed. (fnf)
3440  */
3441
3442 void
3443 croak (badfunc)
3444      char *badfunc;
3445 {
3446   printf ("%s not yet implemented\r\n", badfunc);
3447   reset_sys_modes ();
3448   exit (1);
3449 }
3450
3451 #endif /* USG */
3452 \f
3453 #ifdef DGUX
3454
3455 char *sys_siglist[NSIG + 1] =
3456 {
3457   "null signal",                         /*  0 SIGNULL   */
3458   "hangup",                              /*  1 SIGHUP    */
3459   "interrupt",                           /*  2 SIGINT    */
3460   "quit",                                /*  3 SIGQUIT   */
3461   "illegal instruction",                 /*  4 SIGILL    */
3462   "trace trap",                          /*  5 SIGTRAP   */
3463   "abort termination",                   /*  6 SIGABRT   */
3464   "SIGEMT",                              /*  7 SIGEMT    */
3465   "floating point exception",            /*  8 SIGFPE    */
3466   "kill",                                /*  9 SIGKILL   */
3467   "bus error",                           /* 10 SIGBUS    */
3468   "segmentation violation",              /* 11 SIGSEGV   */
3469   "bad argument to system call",         /* 12 SIGSYS    */
3470   "write on a pipe with no reader",      /* 13 SIGPIPE   */
3471   "alarm clock",                         /* 14 SIGALRM   */
3472   "software termination signal",         /* 15 SIGTERM   */
3473   "user defined signal 1",               /* 16 SIGUSR1   */
3474   "user defined signal 2",               /* 17 SIGUSR2   */
3475   "child stopped or terminated",         /* 18 SIGCLD    */
3476   "power-fail restart",                  /* 19 SIGPWR    */
3477   "window size changed",                 /* 20 SIGWINCH  */
3478   "undefined",                           /* 21           */
3479   "pollable event occurred",             /* 22 SIGPOLL   */
3480   "sendable stop signal not from tty",   /* 23 SIGSTOP   */
3481   "stop signal from tty",                /* 24 SIGSTP    */
3482   "continue a stopped process",          /* 25 SIGCONT   */
3483   "attempted background tty read",       /* 26 SIGTTIN   */
3484   "attempted background tty write",      /* 27 SIGTTOU   */
3485   "undefined",                           /* 28           */
3486   "undefined",                           /* 29           */
3487   "undefined",                           /* 30           */
3488   "undefined",                           /* 31           */
3489   "undefined",                           /* 32           */
3490   "socket (TCP/IP) urgent data arrival", /* 33 SIGURG    */
3491   "I/O is possible",                     /* 34 SIGIO     */
3492   "exceeded cpu time limit",             /* 35 SIGXCPU   */
3493   "exceeded file size limit",            /* 36 SIGXFSZ   */
3494   "virtual time alarm",                  /* 37 SIGVTALRM */
3495   "profiling time alarm",                /* 38 SIGPROF   */
3496   "undefined",                           /* 39           */
3497   "file record locks revoked",           /* 40 SIGLOST   */
3498   "undefined",                           /* 41           */
3499   "undefined",                           /* 42           */
3500   "undefined",                           /* 43           */
3501   "undefined",                           /* 44           */
3502   "undefined",                           /* 45           */
3503   "undefined",                           /* 46           */
3504   "undefined",                           /* 47           */
3505   "undefined",                           /* 48           */
3506   "undefined",                           /* 49           */
3507   "undefined",                           /* 50           */
3508   "undefined",                           /* 51           */
3509   "undefined",                           /* 52           */
3510   "undefined",                           /* 53           */
3511   "undefined",                           /* 54           */
3512   "undefined",                           /* 55           */
3513   "undefined",                           /* 56           */
3514   "undefined",                           /* 57           */
3515   "undefined",                           /* 58           */
3516   "undefined",                           /* 59           */
3517   "undefined",                           /* 60           */
3518   "undefined",                           /* 61           */
3519   "undefined",                           /* 62           */
3520   "undefined",                           /* 63           */
3521   "notification message in mess. queue", /* 64 SIGDGNOTIFY */
3522   0
3523 };
3524
3525 #endif /* DGUX */
3526 \f
3527 /* Directory routines for systems that don't have them. */
3528
3529 #ifdef SYSV_SYSTEM_DIR
3530
3531 #include <dirent.h>
3532
3533 #if defined (BROKEN_CLOSEDIR) || !defined (HAVE_CLOSEDIR)
3534
3535 int
3536 closedir (dirp)
3537      register DIR *dirp;              /* stream from opendir */
3538 {
3539   int rtnval;
3540
3541   rtnval = sys_close (dirp->dd_fd);
3542
3543   /* Some systems (like Solaris) allocate the buffer and the DIR all
3544      in one block.  Why in the world are we freeing this ourselves
3545      anyway?  */
3546 #if ! (defined (sun) && defined (USG5_4))
3547   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3548 #endif
3549   xfree ((char *) dirp);
3550
3551   return rtnval;
3552 }
3553 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3554 #endif /* SYSV_SYSTEM_DIR */
3555
3556 #ifdef NONSYSTEM_DIR_LIBRARY
3557
3558 DIR *
3559 opendir (filename)
3560      char *filename;    /* name of directory */
3561 {
3562   register DIR *dirp;           /* -> malloc'ed storage */
3563   register int fd;              /* file descriptor for read */
3564   struct stat sbuf;             /* result of fstat */
3565
3566   fd = sys_open (filename, 0);
3567   if (fd < 0)
3568     return 0;
3569
3570   BLOCK_INPUT;
3571   if (fstat (fd, &sbuf) < 0
3572       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3573       || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3574     {
3575       sys_close (fd);
3576       UNBLOCK_INPUT;
3577       return 0;         /* bad luck today */
3578     }
3579   UNBLOCK_INPUT;
3580
3581   dirp->dd_fd = fd;
3582   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3583
3584   return dirp;
3585 }
3586
3587 void
3588 closedir (dirp)
3589      register DIR *dirp;                /* stream from opendir */
3590 {
3591   sys_close (dirp->dd_fd);
3592   xfree ((char *) dirp);
3593 }
3594
3595
3596 #ifndef VMS
3597 #define DIRSIZ  14
3598 struct olddir
3599   {
3600     ino_t od_ino;               /* inode */
3601     char od_name[DIRSIZ];       /* filename */
3602   };
3603 #endif /* not VMS */
3604
3605 struct direct dir_static;       /* simulated directory contents */
3606
3607 /* ARGUSED */
3608 struct direct *
3609 readdir (dirp)
3610      register DIR *dirp;        /* stream from opendir */
3611 {
3612 #ifndef VMS
3613   register struct olddir *dp;   /* -> directory data */
3614 #else /* VMS */
3615   register struct dir$_name *dp; /* -> directory data */
3616   register struct dir$_version *dv; /* -> version data */
3617 #endif /* VMS */
3618
3619   for (; ;)
3620     {
3621       if (dirp->dd_loc >= dirp->dd_size)
3622         dirp->dd_loc = dirp->dd_size = 0;
3623
3624       if (dirp->dd_size == 0    /* refill buffer */
3625           && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3626         return 0;
3627
3628 #ifndef VMS
3629       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3630       dirp->dd_loc += sizeof (struct olddir);
3631
3632       if (dp->od_ino != 0)      /* not deleted entry */
3633         {
3634           dir_static.d_ino = dp->od_ino;
3635           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3636           dir_static.d_name[DIRSIZ] = '\0';
3637           dir_static.d_namlen = strlen (dir_static.d_name);
3638           dir_static.d_reclen = sizeof (struct direct)
3639             - MAXNAMLEN + 3
3640               + dir_static.d_namlen - dir_static.d_namlen % 4;
3641           return &dir_static;   /* -> simulated structure */
3642         }
3643 #else /* VMS */
3644       dp = (struct dir$_name *) dirp->dd_buf;
3645       if (dirp->dd_loc == 0)
3646         dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3647           : dp->dir$b_namecount;
3648       dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3649       dir_static.d_ino = dv->dir$w_fid_num;
3650       dir_static.d_namlen = dp->dir$b_namecount;
3651       dir_static.d_reclen = sizeof (struct direct)
3652         - MAXNAMLEN + 3
3653           + dir_static.d_namlen - dir_static.d_namlen % 4;
3654       strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3655       dir_static.d_name[dir_static.d_namlen] = '\0';
3656       dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3657       return &dir_static;
3658 #endif /* VMS */
3659     }
3660 }
3661
3662 #ifdef VMS
3663 /* readdirver is just like readdir except it returns all versions of a file
3664    as separate entries.  */
3665
3666 /* ARGUSED */
3667 struct direct *
3668 readdirver (dirp)
3669      register DIR *dirp;        /* stream from opendir */
3670 {
3671   register struct dir$_name *dp; /* -> directory data */
3672   register struct dir$_version *dv; /* -> version data */
3673
3674   if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3675     dirp->dd_loc = dirp->dd_size = 0;
3676
3677   if (dirp->dd_size == 0        /* refill buffer */
3678       && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3679     return 0;
3680
3681   dp = (struct dir$_name *) dirp->dd_buf;
3682   if (dirp->dd_loc == 0)
3683     dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
3684                    : dp->dir$b_namecount;
3685   dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
3686   strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3687   sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3688   dir_static.d_namlen = strlen (dir_static.d_name);
3689   dir_static.d_ino = dv->dir$w_fid_num;
3690   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3691                         + dir_static.d_namlen - dir_static.d_namlen % 4;
3692   dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3693   return &dir_static;
3694 }
3695
3696 #endif /* VMS */
3697
3698 #endif /* NONSYSTEM_DIR_LIBRARY */
3699
3700 \f
3701 int
3702 set_file_times (filename, atime, mtime)
3703      char *filename;
3704      EMACS_TIME atime, mtime;
3705 {
3706 #ifdef HAVE_UTIMES
3707   struct timeval tv[2];
3708   tv[0] = atime;
3709   tv[1] = mtime;
3710   return utimes (filename, tv);
3711 #else /* not HAVE_UTIMES */
3712   struct utimbuf utb;
3713   utb.actime = EMACS_SECS (atime);
3714   utb.modtime = EMACS_SECS (mtime);
3715   return utime (filename, &utb);
3716 #endif /* not HAVE_UTIMES */
3717 }
3718 \f
3719 /* mkdir and rmdir functions, for systems which don't have them.  */
3720
3721 #ifndef HAVE_MKDIR
3722 /*
3723  * Written by Robert Rother, Mariah Corporation, August 1985.
3724  *
3725  * If you want it, it's yours.  All I ask in return is that if you
3726  * figure out how to do this in a Bourne Shell script you send me
3727  * a copy.
3728  *                                      sdcsvax!rmr or rmr@uscd
3729  *
3730  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3731  * subroutine.  11Mar86; hoptoad!gnu
3732  *
3733  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3734  * subroutine didn't return EEXIST.  It does now.
3735  */
3736
3737 /*
3738  * Make a directory.
3739  */
3740 #ifdef MKDIR_PROTOTYPE
3741 MKDIR_PROTOTYPE
3742 #else
3743 int
3744 mkdir (dpath, dmode)
3745      char *dpath;
3746      int dmode;
3747 #endif
3748 {
3749   int cpid, status, fd;
3750   struct stat statbuf;
3751
3752   if (stat (dpath, &statbuf) == 0)
3753     {
3754       errno = EEXIST;           /* Stat worked, so it already exists */
3755       return -1;
3756     }
3757
3758   /* If stat fails for a reason other than non-existence, return error */
3759   if (errno != ENOENT)
3760     return -1;
3761
3762   synch_process_alive = 1;
3763   switch (cpid = fork ())
3764     {
3765
3766     case -1:                    /* Error in fork */
3767       return (-1);              /* Errno is set already */
3768
3769     case 0:                     /* Child process */
3770       /*
3771                  * Cheap hack to set mode of new directory.  Since this
3772                  * child process is going away anyway, we zap its umask.
3773                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
3774                  * directory.  Does anybody care?
3775                  */
3776       status = umask (0);       /* Get current umask */
3777       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3778       fd = sys_open ("/dev/null", 2);
3779       if (fd >= 0)
3780         {
3781           dup2 (fd, 0);
3782           dup2 (fd, 1);
3783           dup2 (fd, 2);
3784         }
3785       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3786       _exit (-1);               /* Can't exec /bin/mkdir */
3787
3788     default:                    /* Parent process */
3789       wait_for_termination (cpid);
3790     }
3791
3792   if (synch_process_death != 0 || synch_process_retcode != 0)
3793     {
3794       errno = EIO;              /* We don't know why, but */
3795       return -1;                /* /bin/mkdir failed */
3796     }
3797
3798   return 0;
3799 }
3800 #endif /* not HAVE_MKDIR */
3801
3802 #ifndef HAVE_RMDIR
3803 int
3804 rmdir (dpath)
3805      char *dpath;
3806 {
3807   int cpid, status, fd;
3808   struct stat statbuf;
3809
3810   if (stat (dpath, &statbuf) != 0)
3811     {
3812       /* Stat just set errno.  We don't have to */
3813       return -1;
3814     }
3815
3816   synch_process_alive = 1;
3817   switch (cpid = fork ())
3818     {
3819
3820     case -1:                    /* Error in fork */
3821       return (-1);              /* Errno is set already */
3822
3823     case 0:                     /* Child process */
3824       fd = sys_open ("/dev/null", 2);
3825       if (fd >= 0)
3826         {
3827           dup2 (fd, 0);
3828           dup2 (fd, 1);
3829           dup2 (fd, 2);
3830         }
3831       execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3832       _exit (-1);               /* Can't exec /bin/rmdir */
3833
3834     default:                    /* Parent process */
3835       wait_for_termination (cpid);
3836     }
3837
3838   if (synch_process_death != 0 || synch_process_retcode != 0)
3839     {
3840       errno = EIO;              /* We don't know why, but */
3841       return -1;                /* /bin/rmdir failed */
3842     }
3843
3844   return 0;
3845 }
3846 #endif /* !HAVE_RMDIR */
3847
3848
3849 \f
3850 /* Functions for VMS */
3851 #ifdef VMS
3852 #include "vms-pwd.h"
3853 #include <acldef.h>
3854 #include <chpdef.h>
3855 #include <jpidef.h>
3856
3857 /* Return as a string the VMS error string pertaining to STATUS.
3858    Reuses the same static buffer each time it is called.  */
3859
3860 char *
3861 vmserrstr (status)
3862      int status;                /* VMS status code */
3863 {
3864   int bufadr[2];
3865   short len;
3866   static char buf[257];
3867
3868   bufadr[0] = sizeof buf - 1;
3869   bufadr[1] = (int) buf;
3870   if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3871     return "untranslatable VMS error status";
3872   buf[len] = '\0';
3873   return buf;
3874 }
3875
3876 #ifdef access
3877 #undef access
3878
3879 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3880  * not work correctly.  (It also doesn't work well in version 2.3.)
3881  */
3882
3883 #ifdef VMS4_4
3884
3885 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3886         { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3887
3888 typedef union {
3889     struct {
3890         unsigned short s_buflen;
3891         unsigned short s_code;
3892         char *s_bufadr;
3893         unsigned short *s_retlenadr;
3894     } s;
3895     int end;
3896 } item;
3897 #define buflen s.s_buflen
3898 #define code s.s_code
3899 #define bufadr s.s_bufadr
3900 #define retlenadr s.s_retlenadr
3901
3902 #define R_OK 4  /* test for read permission */
3903 #define W_OK 2  /* test for write permission */
3904 #define X_OK 1  /* test for execute (search) permission */
3905 #define F_OK 0  /* test for presence of file */
3906
3907 int
3908 sys_access (path, mode)
3909      char *path;
3910      int mode;
3911 {
3912   static char *user = NULL;
3913   char dir_fn[512];
3914
3915   /* translate possible directory spec into .DIR file name, so brain-dead
3916    * access can treat the directory like a file.  */
3917   if (directory_file_name (path, dir_fn))
3918     path = dir_fn;
3919
3920   if (mode == F_OK)
3921     return access (path, mode);
3922   if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3923     return -1;
3924   {
3925     int stat;
3926     int flags;
3927     int acces;
3928     unsigned short int dummy;
3929     item itemlst[3];
3930     static int constant = ACL$C_FILE;
3931     DESCRIPTOR (path_desc, path);
3932     DESCRIPTOR (user_desc, user);
3933
3934     flags = 0;
3935     acces = 0;
3936     if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3937       return stat;
3938     if (mode & R_OK)
3939       acces |= CHP$M_READ;
3940     if (mode & W_OK)
3941       acces |= CHP$M_WRITE;
3942     itemlst[0].buflen = sizeof (int);
3943     itemlst[0].code = CHP$_FLAGS;
3944     itemlst[0].bufadr = (char *) &flags;
3945     itemlst[0].retlenadr = &dummy;
3946     itemlst[1].buflen = sizeof (int);
3947     itemlst[1].code = CHP$_ACCESS;
3948     itemlst[1].bufadr = (char *) &acces;
3949     itemlst[1].retlenadr = &dummy;
3950     itemlst[2].end = CHP$_END;
3951     stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3952     return stat == SS$_NORMAL ? 0 : -1;
3953   }
3954 }
3955
3956 #else /* not VMS4_4 */
3957
3958 #include <prvdef.h>
3959 #define ACE$M_WRITE     2
3960 #define ACE$C_KEYID     1
3961
3962 static unsigned short memid, grpid;
3963 static unsigned int uic;
3964
3965 /* Called from init_sys_modes, so it happens not very often
3966    but at least each time Emacs is loaded.  */
3967 void
3968 sys_access_reinit ()
3969 {
3970   uic = 0;
3971 }
3972
3973 int
3974 sys_access (filename, type)
3975      char * filename;
3976      int type;
3977 {
3978   struct FAB fab;
3979   struct XABPRO xab;
3980   int status, size, i, typecode, acl_controlled;
3981   unsigned int *aclptr, *aclend, aclbuf[60];
3982   union prvdef prvmask;
3983
3984   /* Get UIC and GRP values for protection checking.  */
3985   if (uic == 0)
3986     {
3987       status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3988       if (! (status & 1))
3989         return -1;
3990       memid = uic & 0xFFFF;
3991       grpid = uic >> 16;
3992     }
3993
3994   if (type != 2)                /* not checking write access */
3995     return access (filename, type);
3996
3997   /* Check write protection. */
3998
3999 #define CHECKPRIV(bit)    (prvmask.bit)
4000 #define WRITABLE(field)  (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
4001
4002   /* Find privilege bits */
4003   status = SYS$SETPRV (0, 0, 0, prvmask);
4004   if (! (status & 1))
4005     error ("Unable to find privileges: %s", vmserrstr (status));
4006   if (CHECKPRIV (PRV$V_BYPASS))
4007     return 0;                   /* BYPASS enabled */
4008   fab = cc$rms_fab;
4009   fab.fab$b_fac = FAB$M_GET;
4010   fab.fab$l_fna = filename;
4011   fab.fab$b_fns = strlen (filename);
4012   fab.fab$l_xab = &xab;
4013   xab = cc$rms_xabpro;
4014   xab.xab$l_aclbuf = aclbuf;
4015   xab.xab$w_aclsiz = sizeof (aclbuf);
4016   status = SYS$OPEN (&fab, 0, 0);
4017   if (! (status & 1))
4018     return -1;
4019   SYS$CLOSE (&fab, 0, 0);
4020   /* Check system access */
4021   if (CHECKPRIV (PRV$V_SYSPRV) && WRITABLE (XAB$V_SYS))
4022     return 0;
4023   /* Check ACL entries, if any */
4024   acl_controlled = 0;
4025   if (xab.xab$w_acllen > 0)
4026     {
4027       aclptr = aclbuf;
4028       aclend = &aclbuf[xab.xab$w_acllen / 4];
4029       while (*aclptr && aclptr < aclend)
4030         {
4031           size = (*aclptr & 0xff) / 4;
4032           typecode = (*aclptr >> 8) & 0xff;
4033           if (typecode == ACE$C_KEYID)
4034             for (i = size - 1; i > 1; i--)
4035               if (aclptr[i] == uic)
4036                 {
4037                   acl_controlled = 1;
4038                   if (aclptr[1] & ACE$M_WRITE)
4039                     return 0;   /* Write access through ACL */
4040                 }
4041           aclptr = &aclptr[size];
4042         }
4043       if (acl_controlled)       /* ACL specified, prohibits write access */
4044         return -1;
4045     }
4046   /* No ACL entries specified, check normal protection */
4047   if (WRITABLE (XAB$V_WLD))     /* World writable */
4048     return 0;
4049   if (WRITABLE (XAB$V_GRP) &&
4050       (unsigned short) (xab.xab$l_uic >> 16) == grpid)
4051     return 0;                   /* Group writable */
4052   if (WRITABLE (XAB$V_OWN) &&
4053       (xab.xab$l_uic & 0xFFFF) == memid)
4054     return 0;                   /* Owner writable */
4055
4056   return -1;    /* Not writable */
4057 }
4058 #endif /* not VMS4_4 */
4059 #endif /* access */
4060
4061 static char vtbuf[NAM$C_MAXRSS+1];
4062
4063 /* translate a vms file spec to a unix path */
4064 char *
4065 sys_translate_vms (vfile)
4066      char * vfile;
4067 {
4068   char * p;
4069   char * targ;
4070
4071   if (!vfile)
4072     return 0;
4073
4074   targ = vtbuf;
4075
4076   /* leading device or logical name is a root directory */
4077   if (p = strchr (vfile, ':'))
4078     {
4079       *targ++ = '/';
4080       while (vfile < p)
4081         *targ++ = *vfile++;
4082       vfile++;
4083       *targ++ = '/';
4084     }
4085   p = vfile;
4086   if (*p == '[' || *p == '<')
4087     {
4088       while (*++vfile != *p + 2)
4089         switch (*vfile)
4090           {
4091           case '.':
4092             if (vfile[-1] == *p)
4093               *targ++ = '.';
4094             *targ++ = '/';
4095             break;
4096
4097           case '-':
4098             *targ++ = '.';
4099             *targ++ = '.';
4100             break;
4101
4102           default:
4103             *targ++ = *vfile;
4104             break;
4105           }
4106       vfile++;
4107       *targ++ = '/';
4108     }
4109   while (*vfile)
4110     *targ++ = *vfile++;
4111
4112   return vtbuf;
4113 }
4114
4115 static char utbuf[NAM$C_MAXRSS+1];
4116
4117 /* translate a unix path to a VMS file spec */
4118 char *
4119 sys_translate_unix (ufile)
4120      char * ufile;
4121 {
4122   int slash_seen = 0;
4123   char *p;
4124   char * targ;
4125
4126   if (!ufile)
4127     return 0;
4128
4129   targ = utbuf;
4130
4131   if (*ufile == '/')
4132     {
4133       ufile++;
4134     }
4135
4136   while (*ufile)
4137     {
4138       switch (*ufile)
4139         {
4140         case '/':
4141           if (slash_seen)
4142             if (index (&ufile[1], '/'))
4143               *targ++ = '.';
4144             else
4145               *targ++ = ']';
4146           else
4147             {
4148               *targ++ = ':';
4149               if (index (&ufile[1], '/'))
4150                 *targ++ = '[';
4151               slash_seen = 1;
4152             }
4153           break;
4154
4155         case '.':
4156           if (strncmp (ufile, "./", 2) == 0)
4157             {
4158               if (!slash_seen)
4159                 {
4160                   *targ++ = '[';
4161                   slash_seen = 1;
4162                 }
4163               ufile++;          /* skip the dot */
4164               if (index (&ufile[1], '/'))
4165                 *targ++ = '.';
4166               else
4167                 *targ++ = ']';
4168             }
4169           else if (strncmp (ufile, "../", 3) == 0)
4170             {
4171               if (!slash_seen)
4172                 {
4173                   *targ++ = '[';
4174                   slash_seen = 1;
4175                 }
4176               *targ++ = '-';
4177               ufile += 2;       /* skip the dots */
4178               if (index (&ufile[1], '/'))
4179                 *targ++ = '.';
4180               else
4181                 *targ++ = ']';
4182             }
4183           else
4184             *targ++ = *ufile;
4185           break;
4186
4187         default:
4188           *targ++ = *ufile;
4189           break;
4190         }
4191       ufile++;
4192     }
4193   *targ = '\0';
4194
4195   return utbuf;
4196 }
4197
4198 char *
4199 getwd (pathname)
4200      char *pathname;
4201 {
4202   char *ptr, *val;
4203   extern char *getcwd ();
4204
4205 #define MAXPATHLEN 1024
4206
4207   ptr = xmalloc (MAXPATHLEN);
4208   val = getcwd (ptr, MAXPATHLEN);
4209   if (val == 0)
4210     {
4211       xfree (ptr);
4212       return val;
4213     }
4214   strcpy (pathname, ptr);
4215   xfree (ptr);
4216
4217  return pathname;
4218 }
4219
4220 int
4221 getppid ()
4222 {
4223   long item_code = JPI$_OWNER;
4224   unsigned long parent_id;
4225   int status;
4226
4227   if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
4228     {
4229       errno = EVMSERR;
4230       vaxc$errno = status;
4231       return -1;
4232     }
4233   return parent_id;
4234 }
4235
4236 #undef getuid
4237 unsigned
4238 sys_getuid ()
4239 {
4240   return (getgid () << 16) | getuid ();
4241 }
4242
4243 int
4244 sys_read (fildes, buf, nbyte)
4245      int fildes;
4246      char *buf;
4247      unsigned int nbyte;
4248 {
4249   return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
4250 }
4251
4252 #if 0
4253 int
4254 sys_write (fildes, buf, nbyte)
4255      int fildes;
4256      char *buf;
4257      unsigned int nbyte;
4258 {
4259   register int nwrote, rtnval = 0;
4260
4261   while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
4262     nbyte -= nwrote;
4263     buf += nwrote;
4264     rtnval += nwrote;
4265   }
4266   if (nwrote < 0)
4267     return rtnval ? rtnval : -1;
4268   if ((nwrote = write (fildes, buf, nbyte)) < 0)
4269     return rtnval ? rtnval : -1;
4270   return (rtnval + nwrote);
4271 }
4272 #endif /* 0 */
4273
4274 /*
4275  *      VAX/VMS VAX C RTL really loses. It insists that records
4276  *      end with a newline (carriage return) character, and if they
4277  *      don't it adds one (nice of it isn't it!)
4278  *
4279  *      Thus we do this stupidity below.
4280  */
4281
4282 int
4283 sys_write (fildes, buf, nbytes)
4284      int fildes;
4285      char *buf;
4286      unsigned int nbytes;
4287 {
4288   register char *p;
4289   register char *e;
4290   int sum = 0;
4291   struct stat st;
4292
4293   fstat (fildes, &st);
4294   p = buf;
4295   while (nbytes > 0)
4296     {
4297       int len, retval;
4298
4299       /* Handle fixed-length files with carriage control.  */
4300       if (st.st_fab_rfm == FAB$C_FIX
4301           && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4302         {
4303           len = st.st_fab_mrs;
4304           retval = write (fildes, p, min (len, nbytes));
4305           if (retval != len)
4306             return -1;
4307           retval++;     /* This skips the implied carriage control */
4308         }
4309       else
4310         {
4311           e =  p + min (MAXIOSIZE, nbytes) - 1;
4312           while (*e != '\n' && e > p) e--;
4313           if (p == e)           /* Ok.. so here we add a newline... sigh. */
4314             e = p + min (MAXIOSIZE, nbytes) - 1;
4315           len = e + 1 - p;
4316           retval = write (fildes, p, len);
4317           if (retval != len)
4318             return -1;
4319         }
4320       p += retval;
4321       sum += retval;
4322       nbytes -= retval;
4323     }
4324   return sum;
4325 }
4326
4327 /* Create file NEW copying its attributes from file OLD.  If
4328    OLD is 0 or does not exist, create based on the value of
4329    vms_stmlf_recfm. */
4330
4331 /* Protection value the file should ultimately have.
4332    Set by create_copy_attrs, and use by rename_sansversions.  */
4333 static unsigned short int fab_final_pro;
4334
4335 int
4336 creat_copy_attrs (old, new)
4337      char *old, *new;
4338 {
4339   struct FAB fab = cc$rms_fab;
4340   struct XABPRO xabpro;
4341   char aclbuf[256];     /* Choice of size is arbitrary.  See below. */
4342   extern int vms_stmlf_recfm;
4343
4344   if (old)
4345     {
4346       fab.fab$b_fac = FAB$M_GET;
4347       fab.fab$l_fna = old;
4348       fab.fab$b_fns = strlen (old);
4349       fab.fab$l_xab = (char *) &xabpro;
4350       xabpro = cc$rms_xabpro;
4351       xabpro.xab$l_aclbuf = aclbuf;
4352       xabpro.xab$w_aclsiz = sizeof aclbuf;
4353       /* Call $OPEN to fill in the fab & xabpro fields. */
4354       if (SYS$OPEN (&fab, 0, 0) & 1)
4355         {
4356           SYS$CLOSE (&fab, 0, 0);
4357           fab.fab$l_alq = 0;    /* zero the allocation quantity */
4358           if (xabpro.xab$w_acllen > 0)
4359             {
4360               if (xabpro.xab$w_acllen > sizeof aclbuf)
4361                 /* If the acl buffer was too short, redo open with longer one.
4362                    Wouldn't need to do this if there were some system imposed
4363                    limit on the size of an ACL, but I can't find any such. */
4364                 {
4365                   xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
4366                   xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
4367                   if (SYS$OPEN (&fab, 0, 0) & 1)
4368                     SYS$CLOSE (&fab, 0, 0);
4369                   else
4370                     old = 0;
4371                 }
4372             }
4373           else
4374             xabpro.xab$l_aclbuf = 0;
4375         }
4376       else
4377         old = 0;
4378     }
4379   fab.fab$l_fna = new;
4380   fab.fab$b_fns = strlen (new);
4381   if (!old)
4382     {
4383       fab.fab$l_xab = 0;
4384       fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
4385       fab.fab$b_rat = FAB$M_CR;
4386     }
4387
4388   /* Set the file protections such that we will be able to manipulate
4389      this file.  Once we are done writing and renaming it, we will set
4390      the protections back.  */
4391   if (old)
4392     fab_final_pro = xabpro.xab$w_pro;
4393   else
4394     SYS$SETDFPROT (0, &fab_final_pro);
4395   xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
4396
4397   /* Create the new file with either default attrs or attrs copied
4398      from old file. */
4399   if (!(SYS$CREATE (&fab, 0, 0) & 1))
4400     return -1;
4401   SYS$CLOSE (&fab, 0, 0);
4402   /* As this is a "replacement" for creat, return a file descriptor
4403      opened for writing. */
4404   return open (new, O_WRONLY);
4405 }
4406
4407 #ifdef creat
4408 #undef creat
4409 #include <varargs.h>
4410 #ifdef __GNUC__
4411 #ifndef va_count
4412 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4413 #endif
4414 #endif
4415
4416 int
4417 sys_creat (va_alist)
4418      va_dcl
4419 {
4420   va_list list_incrementer;
4421   char *name;
4422   int mode;
4423   int rfd;                      /* related file descriptor */
4424   int fd;                       /* Our new file descriptor */
4425   int count;
4426   struct stat st_buf;
4427   char rfm[12];
4428   char rat[15];
4429   char mrs[13];
4430   char fsz[13];
4431   extern int vms_stmlf_recfm;
4432
4433   va_count (count);
4434   va_start (list_incrementer);
4435   name = va_arg (list_incrementer, char *);
4436   mode = va_arg (list_incrementer, int);
4437   if (count > 2)
4438     rfd = va_arg (list_incrementer, int);
4439   va_end (list_incrementer);
4440   if (count > 2)
4441     {
4442       /* Use information from the related file descriptor to set record
4443          format of the newly created file. */
4444       fstat (rfd, &st_buf);
4445       switch (st_buf.st_fab_rfm)
4446         {
4447         case FAB$C_FIX:
4448           strcpy (rfm, "rfm = fix");
4449           sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4450           strcpy (rat, "rat = ");
4451           if (st_buf.st_fab_rat & FAB$M_CR)
4452             strcat (rat, "cr");
4453           else if (st_buf.st_fab_rat & FAB$M_FTN)
4454             strcat (rat, "ftn");
4455           else if (st_buf.st_fab_rat & FAB$M_PRN)
4456             strcat (rat, "prn");
4457           if (st_buf.st_fab_rat & FAB$M_BLK)
4458             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4459               strcat (rat, ", blk");
4460             else
4461               strcat (rat, "blk");
4462           return creat (name, 0, rfm, rat, mrs);
4463
4464         case FAB$C_VFC:
4465           strcpy (rfm, "rfm = vfc");
4466           sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4467           strcpy (rat, "rat = ");
4468           if (st_buf.st_fab_rat & FAB$M_CR)
4469             strcat (rat, "cr");
4470           else if (st_buf.st_fab_rat & FAB$M_FTN)
4471             strcat (rat, "ftn");
4472           else if (st_buf.st_fab_rat & FAB$M_PRN)
4473             strcat (rat, "prn");
4474           if (st_buf.st_fab_rat & FAB$M_BLK)
4475             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4476               strcat (rat, ", blk");
4477             else
4478               strcat (rat, "blk");
4479           return creat (name, 0, rfm, rat, fsz);
4480
4481         case FAB$C_STM:
4482           strcpy (rfm, "rfm = stm");
4483           break;
4484
4485         case FAB$C_STMCR:
4486           strcpy (rfm, "rfm = stmcr");
4487           break;
4488
4489         case FAB$C_STMLF:
4490           strcpy (rfm, "rfm = stmlf");
4491           break;
4492
4493         case FAB$C_UDF:
4494           strcpy (rfm, "rfm = udf");
4495           break;
4496
4497         case FAB$C_VAR:
4498           strcpy (rfm, "rfm = var");
4499           break;
4500         }
4501       strcpy (rat, "rat = ");
4502       if (st_buf.st_fab_rat & FAB$M_CR)
4503         strcat (rat, "cr");
4504       else if (st_buf.st_fab_rat & FAB$M_FTN)
4505         strcat (rat, "ftn");
4506       else if (st_buf.st_fab_rat & FAB$M_PRN)
4507         strcat (rat, "prn");
4508       if (st_buf.st_fab_rat & FAB$M_BLK)
4509         if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4510           strcat (rat, ", blk");
4511         else
4512           strcat (rat, "blk");
4513     }
4514   else
4515     {
4516       strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4517       strcpy (rat, "rat=cr");
4518     }
4519   /* Until the VAX C RTL fixes the many bugs with modes, always use
4520      mode 0 to get the user's default protection. */
4521   fd = creat (name, 0, rfm, rat);
4522   if (fd < 0 && errno == EEXIST)
4523     {
4524       if (unlink (name) < 0)
4525         report_file_error ("delete", build_string (name));
4526       fd = creat (name, 0, rfm, rat);
4527     }
4528   return fd;
4529 }
4530 #endif /* creat */
4531
4532 /* fwrite to stdout is S L O W.  Speed it up by using fputc...*/
4533 int
4534 sys_fwrite (ptr, size, num, fp)
4535      register char * ptr;
4536      FILE * fp;
4537 {
4538   register int tot = num * size;
4539
4540   while (tot--)
4541     fputc (*ptr++, fp);
4542   return num;
4543 }
4544
4545 /*
4546  * The VMS C library routine creat actually creates a new version of an
4547  * existing file rather than truncating the old version.  There are times
4548  * when this is not the desired behavior, for instance, when writing an
4549  * auto save file (you only want one version), or when you don't have
4550  * write permission in the directory containing the file (but the file
4551  * itself is writable).  Hence this routine, which is equivalent to
4552  * "close (creat (fn, 0));" on Unix if fn already exists.
4553  */
4554 int
4555 vms_truncate (fn)
4556      char *fn;
4557 {
4558   struct FAB xfab = cc$rms_fab;
4559   struct RAB xrab = cc$rms_rab;
4560   int status;
4561
4562   xfab.fab$l_fop = FAB$M_TEF;   /* free allocated but unused blocks on close */
4563   xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4564   xfab.fab$b_shr = FAB$M_NIL;   /* allow no sharing - file must be locked */
4565   xfab.fab$l_fna = fn;
4566   xfab.fab$b_fns = strlen (fn);
4567   xfab.fab$l_dna = ";0";        /* default to latest version of the file */
4568   xfab.fab$b_dns = 2;
4569   xrab.rab$l_fab = &xfab;
4570
4571   /* This gibberish opens the file, positions to the first record, and
4572      deletes all records from there until the end of file. */
4573   if ((SYS$OPEN (&xfab) & 01) == 01)
4574     {
4575       if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4576           (SYS$FIND (&xrab) & 01) == 01 &&
4577           (SYS$TRUNCATE (&xrab) & 01) == 01)
4578         status = 0;
4579       else
4580         status = -1;
4581     }
4582   else
4583     status = -1;
4584   SYS$CLOSE (&xfab);
4585   return status;
4586 }
4587
4588 /* Define this symbol to actually read SYSUAF.DAT.  This requires either
4589    SYSPRV or a readable SYSUAF.DAT. */
4590
4591 #ifdef READ_SYSUAF
4592 /*
4593  * getuaf.c
4594  *
4595  * Routine to read the VMS User Authorization File and return
4596  * a specific user's record.
4597  */
4598
4599 static struct UAF retuaf;
4600
4601 struct UAF *
4602 get_uaf_name (uname)
4603      char * uname;
4604 {
4605   register status;
4606   struct FAB uaf_fab;
4607   struct RAB uaf_rab;
4608
4609   uaf_fab = cc$rms_fab;
4610   uaf_rab = cc$rms_rab;
4611   /* initialize fab fields */
4612   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4613   uaf_fab.fab$b_fns = 21;
4614   uaf_fab.fab$b_fac = FAB$M_GET;
4615   uaf_fab.fab$b_org = FAB$C_IDX;
4616   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4617   /* initialize rab fields */
4618   uaf_rab.rab$l_fab = &uaf_fab;
4619   /* open the User Authorization File */
4620   status = SYS$OPEN (&uaf_fab);
4621   if (!(status&1))
4622     {
4623       errno = EVMSERR;
4624       vaxc$errno = status;
4625       return 0;
4626     }
4627   status = SYS$CONNECT (&uaf_rab);
4628   if (!(status&1))
4629     {
4630       errno = EVMSERR;
4631       vaxc$errno = status;
4632       return 0;
4633     }
4634   /* read the requested record - index is in uname */
4635   uaf_rab.rab$l_kbf = uname;
4636   uaf_rab.rab$b_ksz = strlen (uname);
4637   uaf_rab.rab$b_rac = RAB$C_KEY;
4638   uaf_rab.rab$l_ubf = (char *)&retuaf;
4639   uaf_rab.rab$w_usz = sizeof retuaf;
4640   status = SYS$GET (&uaf_rab);
4641   if (!(status&1))
4642     {
4643       errno = EVMSERR;
4644       vaxc$errno = status;
4645       return 0;
4646     }
4647   /* close the User Authorization File */
4648   status = SYS$DISCONNECT (&uaf_rab);
4649   if (!(status&1))
4650     {
4651       errno = EVMSERR;
4652       vaxc$errno = status;
4653       return 0;
4654     }
4655   status = SYS$CLOSE (&uaf_fab);
4656   if (!(status&1))
4657     {
4658       errno = EVMSERR;
4659       vaxc$errno = status;
4660       return 0;
4661     }
4662   return &retuaf;
4663 }
4664
4665 struct UAF *
4666 get_uaf_uic (uic)
4667      unsigned long uic;
4668 {
4669   register status;
4670   struct FAB uaf_fab;
4671   struct RAB uaf_rab;
4672
4673   uaf_fab = cc$rms_fab;
4674   uaf_rab = cc$rms_rab;
4675   /* initialize fab fields */
4676   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4677   uaf_fab.fab$b_fns = 21;
4678   uaf_fab.fab$b_fac = FAB$M_GET;
4679   uaf_fab.fab$b_org = FAB$C_IDX;
4680   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4681   /* initialize rab fields */
4682   uaf_rab.rab$l_fab = &uaf_fab;
4683   /* open the User Authorization File */
4684   status = SYS$OPEN (&uaf_fab);
4685   if (!(status&1))
4686     {
4687       errno = EVMSERR;
4688       vaxc$errno = status;
4689       return 0;
4690     }
4691   status = SYS$CONNECT (&uaf_rab);
4692   if (!(status&1))
4693     {
4694       errno = EVMSERR;
4695       vaxc$errno = status;
4696       return 0;
4697     }
4698   /* read the requested record - index is in uic */
4699   uaf_rab.rab$b_krf = 1;        /* 1st alternate key */
4700   uaf_rab.rab$l_kbf = (char *) &uic;
4701   uaf_rab.rab$b_ksz = sizeof uic;
4702   uaf_rab.rab$b_rac = RAB$C_KEY;
4703   uaf_rab.rab$l_ubf = (char *)&retuaf;
4704   uaf_rab.rab$w_usz = sizeof retuaf;
4705   status = SYS$GET (&uaf_rab);
4706   if (!(status&1))
4707     {
4708       errno = EVMSERR;
4709       vaxc$errno = status;
4710       return 0;
4711     }
4712   /* close the User Authorization File */
4713   status = SYS$DISCONNECT (&uaf_rab);
4714   if (!(status&1))
4715     {
4716       errno = EVMSERR;
4717       vaxc$errno = status;
4718       return 0;
4719     }
4720   status = SYS$CLOSE (&uaf_fab);
4721   if (!(status&1))
4722     {
4723       errno = EVMSERR;
4724       vaxc$errno = status;
4725       return 0;
4726     }
4727   return &retuaf;
4728 }
4729
4730 static struct passwd retpw;
4731
4732 struct passwd *
4733 cnv_uaf_pw (up)
4734      struct UAF * up;
4735 {
4736   char * ptr;
4737
4738   /* copy these out first because if the username is 32 chars, the next
4739      section will overwrite the first byte of the UIC */
4740   retpw.pw_uid = up->uaf$w_mem;
4741   retpw.pw_gid = up->uaf$w_grp;
4742
4743   /* I suppose this is not the best style, to possibly overwrite one
4744      byte beyond the end of the field, but what the heck... */
4745   ptr = &up->uaf$t_username[UAF$S_USERNAME];
4746   while (ptr[-1] == ' ')
4747     ptr--;
4748   *ptr = '\0';
4749   strcpy (retpw.pw_name, up->uaf$t_username);
4750
4751   /* the rest of these are counted ascii strings */
4752   strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4753   retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4754   strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4755   retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4756   strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4757   retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4758   strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4759   retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4760
4761   return &retpw;
4762 }
4763 #else /* not READ_SYSUAF */
4764 static struct passwd retpw;
4765 #endif /* not READ_SYSUAF */
4766
4767 struct passwd *
4768 getpwnam (name)
4769      char * name;
4770 {
4771 #ifdef READ_SYSUAF
4772   struct UAF *up;
4773 #else
4774   char * user;
4775   char * dir;
4776   unsigned char * full;
4777 #endif /* READ_SYSUAF */
4778   char *ptr = name;
4779
4780   while (*ptr)
4781     {
4782       if ('a' <= *ptr && *ptr <= 'z')
4783         *ptr -= 040;
4784       ptr++;
4785     }
4786 #ifdef READ_SYSUAF
4787   if (!(up = get_uaf_name (name)))
4788     return 0;
4789   return cnv_uaf_pw (up);
4790 #else
4791   if (strcmp (name, getenv ("USER")) == 0)
4792     {
4793       retpw.pw_uid = getuid ();
4794       retpw.pw_gid = getgid ();
4795       strcpy (retpw.pw_name, name);
4796       if (full = egetenv ("FULLNAME"))
4797         strcpy (retpw.pw_gecos, full);
4798       else
4799         *retpw.pw_gecos = '\0';
4800       strcpy (retpw.pw_dir, egetenv ("HOME"));
4801       *retpw.pw_shell = '\0';
4802       return &retpw;
4803     }
4804   else
4805     return 0;
4806 #endif /* not READ_SYSUAF */
4807 }
4808
4809 struct passwd *
4810 getpwuid (uid)
4811      unsigned long uid;
4812 {
4813 #ifdef READ_SYSUAF
4814   struct UAF * up;
4815
4816   if (!(up = get_uaf_uic (uid)))
4817     return 0;
4818   return cnv_uaf_pw (up);
4819 #else
4820   if (uid == sys_getuid ())
4821     return getpwnam (egetenv ("USER"));
4822   else
4823     return 0;
4824 #endif /* not READ_SYSUAF */
4825 }
4826
4827 /* return total address space available to the current process.  This is
4828    the sum of the current p0 size, p1 size and free page table entries
4829    available. */
4830 int
4831 vlimit ()
4832 {
4833   int item_code;
4834   unsigned long free_pages;
4835   unsigned long frep0va;
4836   unsigned long frep1va;
4837   register status;
4838
4839   item_code = JPI$_FREPTECNT;
4840   if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4841     {
4842       errno = EVMSERR;
4843       vaxc$errno = status;
4844       return -1;
4845     }
4846   free_pages *= 512;
4847
4848   item_code = JPI$_FREP0VA;
4849   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4850     {
4851       errno = EVMSERR;
4852       vaxc$errno = status;
4853       return -1;
4854     }
4855   item_code = JPI$_FREP1VA;
4856   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4857     {
4858       errno = EVMSERR;
4859       vaxc$errno = status;
4860       return -1;
4861     }
4862
4863   return free_pages + frep0va + (0x7fffffff - frep1va);
4864 }
4865
4866 int
4867 define_logical_name (varname, string)
4868      char *varname;
4869      char *string;
4870 {
4871   struct dsc$descriptor_s strdsc =
4872     {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
4873   struct dsc$descriptor_s envdsc =
4874     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4875   struct dsc$descriptor_s lnmdsc =
4876     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4877
4878   return LIB$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4879 }
4880
4881 int
4882 delete_logical_name (varname)
4883      char *varname;
4884 {
4885   struct dsc$descriptor_s envdsc =
4886     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4887   struct dsc$descriptor_s lnmdsc =
4888     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4889
4890   return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4891 }
4892
4893 int
4894 ulimit ()
4895 {
4896   return 0;
4897 }
4898
4899 int
4900 setpgrp ()
4901 {
4902   return 0;
4903 }
4904
4905 int
4906 execvp ()
4907 {
4908   error ("execvp system call not implemented");
4909   return -1;
4910 }
4911
4912 int
4913 rename (from, to)
4914      char *from, *to;
4915 {
4916   int status;
4917   struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4918   struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4919   char from_esn[NAM$C_MAXRSS];
4920   char to_esn[NAM$C_MAXRSS];
4921
4922   from_fab.fab$l_fna = from;
4923   from_fab.fab$b_fns = strlen (from);
4924   from_fab.fab$l_nam = &from_nam;
4925   from_fab.fab$l_fop = FAB$M_NAM;
4926
4927   from_nam.nam$l_esa = from_esn;
4928   from_nam.nam$b_ess = sizeof from_esn;
4929
4930   to_fab.fab$l_fna = to;
4931   to_fab.fab$b_fns = strlen (to);
4932   to_fab.fab$l_nam = &to_nam;
4933   to_fab.fab$l_fop = FAB$M_NAM;
4934
4935   to_nam.nam$l_esa = to_esn;
4936   to_nam.nam$b_ess = sizeof to_esn;
4937
4938   status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4939
4940   if (status & 1)
4941     return 0;
4942   else
4943     {
4944       if (status == RMS$_DEV)
4945         errno = EXDEV;
4946       else
4947         errno = EVMSERR;
4948       vaxc$errno = status;
4949       return -1;
4950     }
4951 }
4952
4953 /* This function renames a file like `rename', but it strips
4954    the version number from the "to" filename, such that the "to" file is
4955    will always be a new version.  It also sets the file protection once it is
4956    finished.  The protection that we will use is stored in fab_final_pro,
4957    and was set when we did a creat_copy_attrs to create the file that we
4958    are renaming.
4959
4960    We could use the chmod function, but Eunichs uses 3 bits per user category
4961    to describe the protection, and VMS uses 4 (write and delete are separate
4962    bits).  To maintain portability, the VMS implementation of `chmod' wires
4963    the W and D bits together.  */
4964
4965
4966 static struct fibdef fib;       /* We need this initialized to zero */
4967 char vms_file_written[NAM$C_MAXRSS];
4968
4969 int
4970 rename_sans_version (from,to)
4971      char *from, *to;
4972 {
4973   short int chan;
4974   int stat;
4975   short int iosb[4];
4976   int status;
4977   struct FAB to_fab = cc$rms_fab;
4978   struct NAM to_nam = cc$rms_nam;
4979   struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4980   struct dsc$descriptor fib_attr[2]
4981     = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4982   char to_esn[NAM$C_MAXRSS];
4983
4984   $DESCRIPTOR (disk,to_esn);
4985
4986   to_fab.fab$l_fna = to;
4987   to_fab.fab$b_fns = strlen (to);
4988   to_fab.fab$l_nam = &to_nam;
4989   to_fab.fab$l_fop = FAB$M_NAM;
4990
4991   to_nam.nam$l_esa = to_esn;
4992   to_nam.nam$b_ess = sizeof to_esn;
4993
4994   status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4995
4996   if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4997     *(to_nam.nam$l_ver) = '\0';
4998
4999   stat = rename (from, to_esn);
5000   if (stat < 0)
5001     return stat;
5002
5003   strcpy (vms_file_written, to_esn);
5004
5005   to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
5006   to_fab.fab$b_fns = strlen (vms_file_written);
5007
5008   /* Now set the file protection to the correct value */
5009   SYS$OPEN (&to_fab, 0, 0);     /* This fills in the nam$w_fid fields */
5010
5011   /* Copy these fields into the fib */
5012   fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
5013   fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
5014   fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
5015
5016   SYS$CLOSE (&to_fab, 0, 0);
5017
5018   stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
5019   if (!stat)
5020     LIB$SIGNAL (stat);
5021   stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
5022                    0, 0, 0, &fib_attr, 0);
5023   if (!stat)
5024     LIB$SIGNAL (stat);
5025   stat = SYS$DASSGN (chan);
5026   if (!stat)
5027     LIB$SIGNAL (stat);
5028   strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
5029   return 0;
5030 }
5031
5032 int
5033 link (file, new)
5034      char * file, * new;
5035 {
5036   register status;
5037   struct FAB fab;
5038   struct NAM nam;
5039   unsigned short fid[3];
5040   char esa[NAM$C_MAXRSS];
5041
5042   fab = cc$rms_fab;
5043   fab.fab$l_fop = FAB$M_OFP;
5044   fab.fab$l_fna = file;
5045   fab.fab$b_fns = strlen (file);
5046   fab.fab$l_nam = &nam;
5047
5048   nam = cc$rms_nam;
5049   nam.nam$l_esa = esa;
5050   nam.nam$b_ess = NAM$C_MAXRSS;
5051
5052   status = SYS$PARSE (&fab);
5053   if ((status & 1) == 0)
5054     {
5055       errno = EVMSERR;
5056       vaxc$errno = status;
5057       return -1;
5058     }
5059   status = SYS$SEARCH (&fab);
5060   if ((status & 1) == 0)
5061     {
5062       errno = EVMSERR;
5063       vaxc$errno = status;
5064       return -1;
5065     }
5066
5067   fid[0] = nam.nam$w_fid[0];
5068   fid[1] = nam.nam$w_fid[1];
5069   fid[2] = nam.nam$w_fid[2];
5070
5071   fab.fab$l_fna = new;
5072   fab.fab$b_fns = strlen (new);
5073
5074   status = SYS$PARSE (&fab);
5075   if ((status & 1) == 0)
5076     {
5077       errno = EVMSERR;
5078       vaxc$errno = status;
5079       return -1;
5080     }
5081
5082   nam.nam$w_fid[0] = fid[0];
5083   nam.nam$w_fid[1] = fid[1];
5084   nam.nam$w_fid[2] = fid[2];
5085
5086   nam.nam$l_esa = nam.nam$l_name;
5087   nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
5088
5089   status = SYS$ENTER (&fab);
5090   if ((status & 1) == 0)
5091     {
5092       errno = EVMSERR;
5093       vaxc$errno = status;
5094       return -1;
5095     }
5096
5097   return 0;
5098 }
5099
5100 void
5101 croak (badfunc)
5102      char *badfunc;
5103 {
5104   printf ("%s not yet implemented\r\n", badfunc);
5105   reset_sys_modes ();
5106   exit (1);
5107 }
5108
5109 long
5110 random ()
5111 {
5112   /* Arrange to return a range centered on zero.  */
5113   return rand () - (1 << 30);
5114 }
5115
5116 void
5117 srandom (seed)
5118 {
5119   srand (seed);
5120 }
5121 #endif /* VMS */
5122 \f
5123 #ifdef AIXHFT
5124
5125 /* Called from init_sys_modes.  */
5126 void
5127 hft_init ()
5128 {
5129   int junk;
5130
5131   /* If we're not on an HFT we shouldn't do any of this.  We determine
5132      if we are on an HFT by trying to get an HFT error code.  If this
5133      call fails, we're not on an HFT. */
5134 #ifdef IBMR2AIX
5135   if (ioctl (0, HFQERROR, &junk) < 0)
5136     return;
5137 #else /* not IBMR2AIX */
5138   if (ioctl (0, HFQEIO, 0) < 0)
5139     return;
5140 #endif /* not IBMR2AIX */
5141
5142   /* On AIX the default hft keyboard mapping uses backspace rather than delete
5143      as the rubout key's ASCII code.  Here this is changed.  The bug is that
5144      there's no way to determine the old mapping, so in reset_sys_modes
5145      we need to assume that the normal map had been present.  Of course, this
5146      code also doesn't help if on a terminal emulator which doesn't understand
5147      HFT VTD's.  */
5148   {
5149     struct hfbuf buf;
5150     struct hfkeymap keymap;
5151
5152     buf.hf_bufp = (char *)&keymap;
5153     buf.hf_buflen = sizeof (keymap);
5154     keymap.hf_nkeys = 2;
5155     keymap.hfkey[0].hf_kpos = 15;
5156     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
5157 #ifdef IBMR2AIX
5158     keymap.hfkey[0].hf_keyidh = '<';
5159 #else /* not IBMR2AIX */
5160     keymap.hfkey[0].hf_page = '<';
5161 #endif /* not IBMR2AIX */
5162     keymap.hfkey[0].hf_char = 127;
5163     keymap.hfkey[1].hf_kpos = 15;
5164     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
5165 #ifdef IBMR2AIX
5166     keymap.hfkey[1].hf_keyidh = '<';
5167 #else /* not IBMR2AIX */
5168     keymap.hfkey[1].hf_page = '<';
5169 #endif /* not IBMR2AIX */
5170     keymap.hfkey[1].hf_char = 127;
5171     hftctl (0, HFSKBD, &buf);
5172   }
5173   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
5174      at times.  */
5175   line_ins_del_ok = char_ins_del_ok = 0;
5176 }
5177
5178 /* Reset the rubout key to backspace.  */
5179
5180 void
5181 hft_reset ()
5182 {
5183   struct hfbuf buf;
5184   struct hfkeymap keymap;
5185   int junk;
5186
5187 #ifdef IBMR2AIX
5188   if (ioctl (0, HFQERROR, &junk) < 0)
5189     return;
5190 #else /* not IBMR2AIX */
5191   if (ioctl (0, HFQEIO, 0) < 0)
5192     return;
5193 #endif /* not IBMR2AIX */
5194
5195   buf.hf_bufp = (char *)&keymap;
5196   buf.hf_buflen = sizeof (keymap);
5197   keymap.hf_nkeys = 2;
5198   keymap.hfkey[0].hf_kpos = 15;
5199   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
5200 #ifdef IBMR2AIX
5201   keymap.hfkey[0].hf_keyidh = '<';
5202 #else /* not IBMR2AIX */
5203   keymap.hfkey[0].hf_page = '<';
5204 #endif /* not IBMR2AIX */
5205   keymap.hfkey[0].hf_char = 8;
5206   keymap.hfkey[1].hf_kpos = 15;
5207   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
5208 #ifdef IBMR2AIX
5209   keymap.hfkey[1].hf_keyidh = '<';
5210 #else /* not IBMR2AIX */
5211   keymap.hfkey[1].hf_page = '<';
5212 #endif /* not IBMR2AIX */
5213   keymap.hfkey[1].hf_char = 8;
5214   hftctl (0, HFSKBD, &buf);
5215 }
5216
5217 #endif /* AIXHFT */
5218
5219 #ifdef USE_DL_STUBS
5220
5221 /* These are included on Sunos 4.1 when we do not use shared libraries.
5222    X11 libraries may refer to these functions but (we hope) do not
5223    actually call them.  */
5224
5225 void *
5226 dlopen ()
5227 {
5228   return 0;
5229 }
5230
5231 void *
5232 dlsym ()
5233 {
5234   return 0;
5235 }
5236
5237 int
5238 dlclose ()
5239 {
5240   return -1;
5241 }
5242
5243 #endif /* USE_DL_STUBS */
5244 \f
5245 #ifndef BSTRING
5246
5247 #ifndef bzero
5248
5249 void
5250 bzero (b, length)
5251      register char *b;
5252      register int length;
5253 {
5254 #ifdef VMS
5255   short zero = 0;
5256   long max_str = 65535;
5257
5258   while (length > max_str) {
5259     (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
5260     length -= max_str;
5261     b += max_str;
5262   }
5263   max_str = length;
5264   (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
5265 #else
5266   while (length-- > 0)
5267     *b++ = 0;
5268 #endif /* not VMS */
5269 }
5270
5271 #endif /* no bzero */
5272 #endif /* BSTRING */
5273
5274 #if (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY)
5275 #undef bcopy
5276
5277 /* Saying `void' requires a declaration, above, where bcopy is used
5278    and that declaration causes pain for systems where bcopy is a macro.  */
5279 bcopy (b1, b2, length)
5280      register char *b1;
5281      register char *b2;
5282      register int length;
5283 {
5284 #ifdef VMS
5285   long max_str = 65535;
5286
5287   while (length > max_str) {
5288     (void) LIB$MOVC3 (&max_str, b1, b2);
5289     length -= max_str;
5290     b1 += max_str;
5291     b2 += max_str;
5292   }
5293   max_str = length;
5294   (void) LIB$MOVC3 (&length, b1, b2);
5295 #else
5296   while (length-- > 0)
5297     *b2++ = *b1++;
5298 #endif /* not VMS */
5299 }
5300 #endif /* (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY) */
5301
5302 #ifndef BSTRING
5303 #ifndef bcmp
5304 int
5305 bcmp (b1, b2, length)   /* This could be a macro! */
5306      register char *b1;
5307      register char *b2;
5308      register int length;
5309 {
5310 #ifdef VMS
5311   struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
5312   struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
5313
5314   return STR$COMPARE (&src1, &src2);
5315 #else
5316   while (length-- > 0)
5317     if (*b1++ != *b2++)
5318       return 1;
5319
5320   return 0;
5321 #endif /* not VMS */
5322 }
5323 #endif /* no bcmp */
5324 #endif /* not BSTRING */
5325
5326 /* All the Macintosh stuffs go here */
5327
5328 #ifdef macintosh
5329
5330 #include <Files.h>
5331 #include <MacTypes.h>
5332 #include <TextUtils.h>
5333 #include <Folders.h>
5334
5335 #include <dirent.h>
5336 #include <sys/stat.h>
5337 #include <string.h>
5338 #include <pwd.h>
5339 #include <sys/param.h>
5340
5341 /* Convert a Mac pathname to Unix form.  A Mac full pathname is one
5342    that does not begin with a ':' and contains at least one ':'. A Mac
5343    full pathname causes an '/' to be prepended to the Unix pathname.
5344    The algorithm for the rest of the pathname is as follows:
5345      For each segment between two ':',
5346        if it is non-null, copy as is and then add a '/' at the end,
5347        otherwise, insert a "../" into the Unix pathname.
5348    Returns 1 if successful; 0 if fails.  */
5349
5350 int
5351 Mac2UnixPathname (const char *mfn, char *ufn, int ufnbuflen)
5352 {
5353   const char *p, *q, *pe;
5354
5355   strcpy (ufn, "");
5356
5357   if (*mfn == '\0')
5358     return 1;
5359
5360   p = strchr (mfn, ':');
5361   if (p != 0 && p != mfn)  /* full pathname */
5362     strcat (ufn, "/");
5363
5364   p = mfn;
5365   if (*p == ':')
5366     p++;
5367
5368   pe = mfn + strlen (mfn);
5369   while (p < pe)
5370     {
5371       q = strchr (p, ':');
5372       if (q)
5373         {
5374           if (q == p)
5375             {  /* two consecutive ':' */
5376               if (strlen (ufn) + 3 >= ufnbuflen)
5377                 return 0;
5378               strcat (ufn, "../");
5379             }
5380           else
5381             {
5382               if (strlen (ufn) + (q - p) + 1 >= ufnbuflen)
5383                 return 0;
5384               strncat (ufn, p, q - p);
5385               strcat (ufn, "/");
5386             }
5387           p = q + 1;
5388         }
5389       else
5390         {
5391           if (strlen (ufn) + (pe - p) >= ufnbuflen)
5392             return 0;
5393           strncat (ufn, p, pe - p);  /* no separator for last one */
5394           p = pe;
5395         }
5396     }
5397
5398   return 1;
5399 }
5400
5401 extern char *GetTempDirName ();
5402
5403 /* Convert a Unix pathname to Mac form.  Approximately reverse of the
5404    above in algorithm.  */
5405 int
5406 Unix2MacPathname (const char *ufn, char *mfn, int mfnbuflen)
5407 {
5408   const char *p, *q, *pe;
5409   char expandedPathname[MAXPATHLEN+1];
5410
5411   strcpy (mfn, "");
5412
5413   if (*ufn == '\0')
5414     return 1;
5415
5416   p = ufn;
5417
5418   /* Check for and handle volume names.  Last comparison: strangely
5419      somewhere `/.emacs' is passed.  A temporary fix for now.  */
5420   if (*p == '/' && strchr (p+1, '/') == NULL && strcmp (p, "/.emacs") != 0)
5421     {
5422       if (strlen (p) + 1 > mfnbuflen)
5423         return 0;
5424       strcpy (mfn, p+1);
5425       strcat (mfn, ":");
5426       return 1;
5427     }
5428
5429   if (strncmp (p, "~emacs/", 7) == 0)
5430     {  /* expand to emacs dir found by InitEmacsPasswdDir */
5431       struct passwd *pw = getpwnam ("emacs");
5432       p += 7;
5433       if (strlen (pw->pw_dir) + strlen (p) > MAXPATHLEN)
5434         return 0;
5435       strcpy (expandedPathname, pw->pw_dir);
5436       strcat (expandedPathname, p);
5437       p = expandedPathname;
5438       /* Now p points to the pathname with emacs dir prefix.  */
5439     }
5440   else if (strncmp (p, "/tmp/", 5) == 0)
5441     {
5442       char *t = GetTempDirName ();
5443       p += 5;
5444       if (strlen (t) + strlen (p) > MAXPATHLEN)
5445         return 0;
5446       strcpy (expandedPathname, t);
5447       strcat (expandedPathname, p);
5448       p = expandedPathname;
5449       /* Now p points to the pathname with emacs dir prefix.  */
5450     }
5451   else if (*p != '/')  /* relative pathname */
5452     strcat (mfn, ":");
5453
5454   if (*p == '/')
5455     p++;
5456
5457   pe = p + strlen (p);
5458   while (p < pe)
5459     {
5460       q = strchr (p, '/');
5461       if (q)
5462         {
5463           if (q - p == 2 && *p == '.' && *(p+1) == '.')
5464             {
5465               if (strlen (mfn) + 1 >= mfnbuflen)
5466                 return 0;
5467               strcat (mfn, ":");
5468             }
5469           else
5470             {
5471               if (strlen (mfn) + (q - p) + 1 >= mfnbuflen)
5472                 return 0;
5473               strncat (mfn, p, q - p);
5474               strcat (mfn, ":");
5475             }
5476           p = q + 1;
5477         }
5478       else
5479         {
5480           if (strlen (mfn) + (pe - p) >= mfnbuflen)
5481             return 0;
5482           strncat (mfn, p, pe - p);
5483           p = pe;
5484         }
5485     }
5486
5487   return 1;
5488 }
5489
5490 /* The following functions with "sys_" prefix are stubs to Unix
5491    functions that have already been implemented by CW or MPW.  The
5492    calls to them in Emacs source course are #define'd to call the sys_
5493    versions by the header files s-mac.h.  In these stubs pathnames are
5494    converted between their Unix and Mac forms.  */
5495 /* Unix Epoch is Jan 1, 1970 while Mac Epoch is Jan 1, 1904: 66 years
5496    + 17 leap days */
5497 #define MAC_UNIX_EPOCH_DIFF  ((365L * 66 + 17) * 24 * 60 * 60)
5498
5499 /* CW Epoch is Jan 1, 1900 (aaarghhhhh!); remember, 1900 is not a leap
5500    year! */
5501 #define CW_UNIX_EPOCH_DIFF ((365L * 70 + 17) * 24 * 60 * 60)
5502
5503 /* Define our own stat function for both MrC and CW.  The reason for
5504    doing this: "stat" is both the name of a struct and function name:
5505    can't use the same trick like that for sys_open, sys_close, etc. to
5506    redirect Emacs's calls to our own version that converts Unix style
5507    filenames to Mac style filename because all sorts of compilation
5508    errors will be generated if stat is #define'd to be sys_stat.  */
5509
5510 int
5511 stat (const char *path, struct stat *buf)
5512 {
5513   char MacPathname[MAXPATHLEN+1];
5514   CInfoPBRec cipb;
5515
5516   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5517     return -1;
5518
5519   c2pstr (MacPathname);
5520   cipb.hFileInfo.ioNamePtr = MacPathname;
5521   cipb.hFileInfo.ioVRefNum = 0;
5522   cipb.hFileInfo.ioDirID = 0;
5523   cipb.hFileInfo.ioFDirIndex = 0;  /* set to 0 to get information about specific dir or file */
5524
5525   errno = PBGetCatInfo (&cipb, false);
5526   if (errno == -43) /* -43: fnfErr defined in Errors.h */
5527     errno = ENOENT;
5528   if (errno != noErr)
5529     return -1;
5530
5531   if (cipb.hFileInfo.ioFlAttrib & 0x10)
5532     {  /* bit 4 = 1 for directories */
5533       buf->st_mode = S_IFDIR | S_IREAD | S_IEXEC;
5534       if (!(cipb.hFileInfo.ioFlAttrib & 0x1))  /* bit 1 = 1 for locked files/directories */
5535         buf->st_mode |= S_IWRITE;
5536       buf->st_ino = cipb.dirInfo.ioDrDirID;
5537       buf->st_dev = cipb.dirInfo.ioVRefNum;
5538       buf->st_size = cipb.dirInfo.ioDrNmFls;  /* size of dir = number of files and dirs */
5539       buf->st_atime = buf->st_mtime = cipb.dirInfo.ioDrMdDat - MAC_UNIX_EPOCH_DIFF;
5540       buf->st_ctime = cipb.dirInfo.ioDrCrDat - MAC_UNIX_EPOCH_DIFF;
5541     }
5542   else
5543     {
5544       buf->st_mode = S_IFREG | S_IREAD;
5545       if (!(cipb.hFileInfo.ioFlAttrib & 0x1))  /* bit 1 = 1 for locked files/directories */
5546         buf->st_mode |= S_IWRITE;
5547       if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
5548         buf->st_mode |= S_IEXEC;
5549       buf->st_ino = cipb.hFileInfo.ioDirID;
5550       buf->st_dev = cipb.hFileInfo.ioVRefNum;
5551       buf->st_size = cipb.hFileInfo.ioFlLgLen;
5552       buf->st_atime = buf->st_mtime = cipb.hFileInfo.ioFlMdDat - MAC_UNIX_EPOCH_DIFF;
5553       buf->st_ctime = cipb.hFileInfo.ioFlCrDat - MAC_UNIX_EPOCH_DIFF;
5554     }
5555   buf->st_nlink = 1;
5556   buf->st_uid = getuid ();
5557   buf->st_gid = getgid ();
5558   buf->st_rdev = 0;
5559
5560   return 0;
5561 }
5562
5563 #if __MRC__
5564
5565 /* CW defines fstat in stat.mac.c while MPW does not provide this
5566    function.  Without the information of how to get from a file
5567    descriptor in MPW StdCLib to a Mac OS file spec, it should be hard
5568    to implement this function.  Fortunately, there is only one place
5569    where this function is called in our configuration: in fileio.c,
5570    where only the st_dev and st_ino fields are used to determine
5571    whether two fildes point to different i-nodes to prevent copying
5572    a file onto itself equal.  What we have here probably needs
5573    improvement.  */
5574 int
5575 fstat (int fildes, struct stat *buf)
5576 {
5577   buf->st_dev = 0;
5578   buf->st_ino = fildes;
5579   return 0;  /* success */
5580 }
5581
5582 #endif  /* __MRC__ */
5583
5584 /* From Think Reference code example */
5585 int
5586 mkdir (const char *dirname, int mode)
5587 {
5588 #pragma unused (mode)
5589
5590   HFileParam hfpb;
5591   char MacPathname[MAXPATHLEN+1];
5592
5593   if (Unix2MacPathname (dirname, MacPathname, MAXPATHLEN+1) == 0)
5594     return -1;
5595
5596   c2pstr (MacPathname);
5597   hfpb.ioNamePtr = MacPathname;
5598   hfpb.ioVRefNum = 0; /*ignored unless name is invalid */
5599   hfpb.ioDirID = 0;  /*parent is the root */
5600
5601   /* Just return the Mac OSErr code for now.  */
5602   errno = PBDirCreate ((HParmBlkPtr) &hfpb, false);
5603   return errno == noErr ? 0 : -1;
5604 }
5605
5606 int
5607 rmdir (const char *dirname)
5608 {
5609   HFileParam hfpb;
5610   char MacPathname[MAXPATHLEN+1];
5611
5612   if (Unix2MacPathname (dirname, MacPathname, MAXPATHLEN+1) == 0)
5613     return -1;
5614
5615   c2pstr (MacPathname);
5616   hfpb.ioNamePtr = MacPathname;
5617   hfpb.ioVRefNum = 0; /*ignored unless name is invalid */
5618   hfpb.ioDirID = 0;  /*parent is the root */
5619
5620   errno = PBHDelete ((HParmBlkPtr) &hfpb, false);
5621   return errno == noErr ? 0 : -1;
5622 }
5623
5624 #ifdef __MRC__
5625
5626 /* No implementation yet. */
5627 int
5628 execvp (const char *path, ...)
5629 {
5630   return -1;
5631 }
5632
5633 #endif /* __MRC__ */
5634
5635 int
5636 utime (const char *path, const struct utimbuf *times)
5637 {
5638   char MacPathname[MAXPATHLEN+1];
5639   CInfoPBRec cipb;
5640
5641   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5642     return -1;
5643
5644   c2pstr (MacPathname);
5645   cipb.hFileInfo.ioNamePtr = MacPathname;
5646   cipb.hFileInfo.ioVRefNum = 0;
5647   cipb.hFileInfo.ioDirID = 0;
5648   /* Set to 0 to get information about specific dir or file.  */
5649   cipb.hFileInfo.ioFDirIndex = 0;
5650
5651   errno = PBGetCatInfo (&cipb, false);
5652   if (errno != noErr)
5653     return -1;
5654
5655   if (cipb.hFileInfo.ioFlAttrib & 0x10)
5656     {  /* bit 4 = 1 for directories */
5657       if (times)
5658         cipb.dirInfo.ioDrMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
5659       else
5660         GetDateTime (&cipb.dirInfo.ioDrMdDat);
5661     }
5662   else
5663     {
5664       if (times)
5665         cipb.hFileInfo.ioFlMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
5666       else
5667         GetDateTime (&cipb.hFileInfo.ioFlMdDat);
5668     }
5669
5670   errno = PBSetCatInfo (&cipb, false);
5671   return errno == noErr ? 0 : -1;
5672 }
5673
5674 #define F_OK 0
5675 #define X_OK 1
5676 #define W_OK 2
5677
5678 /* Like stat, but test for access mode in hfpb.ioFlAttrib.  */
5679 int
5680 access (const char *path, int mode)
5681 {
5682   char MacPathname[MAXPATHLEN+1];
5683   CInfoPBRec cipb;
5684
5685   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5686     return -1;
5687
5688   c2pstr (MacPathname);
5689   cipb.hFileInfo.ioNamePtr = MacPathname;
5690   cipb.hFileInfo.ioVRefNum = 0;
5691   cipb.hFileInfo.ioDirID = 0;
5692   cipb.hFileInfo.ioFDirIndex = 0;  /* set to 0 to get information about specific dir or file */
5693
5694   errno = PBGetCatInfo (&cipb, false);
5695   if (errno != noErr)
5696     return -1;
5697
5698   if (mode == F_OK)  /* got this far, file exists */
5699     return 0;
5700
5701   if (mode & X_OK)
5702     if (cipb.hFileInfo.ioFlAttrib & 0x10)  /* path refers to a directory */
5703       return 0;
5704     else
5705       {
5706         if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
5707           return 0;
5708         else
5709           return -1;
5710       }
5711
5712   if (mode & W_OK)
5713     return (cipb.hFileInfo.ioFlAttrib & 0x1) ? -1 : 0;  /* don't allow if lock bit on */
5714
5715   return -1;
5716 }
5717
5718 #define DEV_NULL_FD 0x10000
5719
5720 #undef open
5721 int
5722 sys_open (const char *path, int oflag)
5723 {
5724   char MacPathname[MAXPATHLEN+1];
5725
5726   if (strcmp (path, "/dev/null") == 0)
5727     return DEV_NULL_FD;  /* some bogus fd to be ignored in write */
5728
5729   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5730     return -1;
5731   else
5732     return open (MacPathname, oflag);
5733 }
5734
5735 #undef creat
5736 int
5737 sys_creat (const char *path, mode_t mode)
5738 {
5739   char MacPathname[MAXPATHLEN+1];
5740
5741   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5742     return -1;
5743   else
5744     return creat (MacPathname, mode);
5745 }
5746
5747 #undef unlink
5748 int
5749 sys_unlink (const char *path)
5750 {
5751   char MacPathname[MAXPATHLEN+1];
5752
5753   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5754     return -1;
5755   else
5756     return unlink (MacPathname);
5757 }
5758
5759 #undef read
5760 int
5761 sys_read (int fildes, char *buf, int count)
5762 {
5763   if (fildes == 0)
5764     {  /* if stdin, call (non-echoing) "getch" in console.h */
5765       if (MacKeyPending ())
5766         {  /* don't wait for a key if none has been pressed */
5767           *buf = MacGetChar ();
5768           return 1;
5769         }
5770       else
5771         return 0;
5772     }
5773   else
5774     return read (fildes, buf, count);
5775 }
5776
5777 #undef write
5778 int
5779 sys_write (int fildes, char *buf, int count)
5780 {
5781   if (fildes == DEV_NULL_FD)
5782     return count;
5783   else
5784     return write (fildes, buf, count);
5785 }
5786
5787 #undef rename
5788 int
5789 sys_rename (const char * old_name, const char * new_name)
5790 {
5791   char MacOldName[MAXPATHLEN+1], MacNewName[MAXPATHLEN+1];
5792
5793   if (strcmp (old_name, new_name) == 0)
5794     return 0;
5795
5796   if (Unix2MacPathname (old_name, MacOldName, MAXPATHLEN+1) == 0)
5797     return 1;
5798
5799   if (Unix2MacPathname (new_name, MacNewName, MAXPATHLEN+1) == 0)
5800     return 1;
5801
5802   return rename (MacOldName, MacNewName);
5803 }
5804
5805 #undef fopen
5806 extern FILE *fopen (const char *name, const char *mode);
5807 FILE
5808 sys_fopen (const char *name, const char *mode)
5809 {
5810   char MacPathname[MAXPATHLEN+1];
5811
5812   if (Unix2MacPathname (name, MacPathname, MAXPATHLEN+1) == 0)
5813     return 0;
5814   else
5815     return fopen (MacPathname, mode);
5816 }
5817
5818 #include <Events.h>
5819
5820 long targetTicks = 0;
5821
5822 #ifdef __MRC__
5823 __sigfun alarm_signal_func = (__sigfun) 0;
5824 #elif __MWERKS__
5825 __signal_func_ptr alarm_signal_func = (__signal_func_ptr) 0;
5826 #else
5827 You lose!!!
5828 #endif
5829
5830 /* These functions simulate SIG_ALRM.  The stub for function signal
5831    stores the signal handler function in alarm_signal_func if a
5832    SIG_ALRM is encountered.  CheckAlarm is called in mac_read_socket,
5833    which emacs calls periodically.  A pending alarm is represented by
5834    a non-zero targetTicks value.  CheckAlarm calls the handler
5835    function pointed to by alarm_signal_func if one has been set up and
5836    an alarm is pending.  */
5837 void
5838 CheckAlarm ()
5839 {
5840   if (targetTicks && TickCount () > targetTicks)
5841     {
5842       targetTicks = 0;
5843       if (alarm_signal_func)
5844         (*alarm_signal_func)(SIGALRM);
5845     }
5846 }
5847
5848 /* Called in sys_select to wait for an alarm signal to arrive.  */
5849 int
5850 pause ()
5851 {
5852   unsigned long finalTick;
5853
5854   if (!targetTicks)  /* no alarm pending */
5855     return -1;
5856
5857   while (TickCount () <= targetTicks)
5858     Delay (1UL, &finalTick);  /* wait for 1/60 second before trying again */
5859
5860   targetTicks = 0;
5861   if (alarm_signal_func)
5862     (*alarm_signal_func)(SIGALRM);
5863
5864   return 0;
5865 }
5866
5867 int
5868 alarm (int seconds)
5869 {
5870   long remaining = targetTicks ? (TickCount () - targetTicks) / 60 : 0;
5871
5872   targetTicks = seconds ? TickCount () + 60 * seconds : 0;
5873
5874   return (remaining < 0) ? 0 : (unsigned int) remaining;
5875 }
5876
5877 #undef signal
5878 #ifdef __MRC__
5879 extern __sigfun signal (int signal, __sigfun signal_func);
5880 __sigfun
5881 sys_signal (int signal_num, __sigfun signal_func)
5882 #elif __MWERKS__
5883 extern __signal_func_ptr signal (int signal, __signal_func_ptr signal_func);
5884 __signal_func_ptr
5885 sys_signal (int signal_num, __signal_func_ptr signal_func)
5886 #else
5887      You lose!!!
5888 #endif
5889 {
5890   if (signal_num != SIGALRM)
5891     return signal (signal_num, signal_func);
5892   else
5893     {
5894 #ifdef __MRC__
5895       __sigfun old_signal_func;
5896 #elif __MWERKS__
5897       __signal_func_ptr old_signal_func;
5898 #else
5899       You lose!!!
5900 #endif
5901         old_signal_func = alarm_signal_func;
5902       alarm_signal_func = signal_func;
5903       return old_signal_func;
5904     }
5905 }
5906
5907 /* The time functions adjust time values according to the difference
5908    between the Unix and CW epoches. */
5909
5910 #undef gmtime
5911 extern struct tm *gmtime (const time_t *);
5912 struct tm
5913 sys_gmtime (const time_t *timer)
5914 {
5915   time_t unixTime = *timer + CW_UNIX_EPOCH_DIFF;
5916
5917   return gmtime (&unixTime);
5918 }
5919
5920 #undef localtime
5921 extern struct tm *localtime (const time_t *);
5922 struct tm *
5923 sys_localtime (const time_t *timer)
5924 {
5925   time_t unixTime = *timer + CW_UNIX_EPOCH_DIFF;
5926
5927   return localtime (&unixTime);
5928 }
5929
5930 #undef ctime
5931 extern char *ctime (const time_t *);
5932 char *
5933 sys_ctime (const time_t *timer)
5934 {
5935   time_t unixTime = *timer + CW_UNIX_EPOCH_DIFF;
5936
5937   return ctime (&unixTime);
5938 }
5939
5940 #undef time
5941 extern time_t time (time_t *);
5942 time_t
5943 sys_time (time_t *timer)
5944 {
5945   time_t macTime = time (NULL) - CW_UNIX_EPOCH_DIFF;
5946
5947   if (timer)
5948     *timer = macTime;
5949
5950   return macTime;
5951 }
5952
5953 /* no subprocesses, empty wait */
5954 int
5955 wait (int pid)
5956 {
5957   return 0;
5958 }
5959
5960 void
5961 croak (char *badfunc)
5962 {
5963   printf ("%s not yet implemented\r\n", badfunc);
5964   exit (1);
5965 }
5966
5967 char *
5968 index (const char * str, int chr)
5969 {
5970   return strchr (str, chr);
5971 }
5972
5973 char *e[] = { 0 };
5974 char **environ = &e[0];
5975
5976 char *
5977 mktemp (char *template)
5978 {
5979   int len, k;
5980   static seqnum = 0;
5981
5982   len = strlen (template);
5983   k = len - 1;
5984   while (k >= 0 && template[k] == 'X')
5985     k--;
5986
5987   k++;  /* make k index of first 'X' */
5988
5989   if (k < len)
5990     {
5991       /* Zero filled, number of digits equal to the number of X's.  */
5992       sprintf (&template[k], "%0*d", len-k, seqnum++);
5993
5994       return template;
5995     }
5996   else
5997     return 0;
5998 }
5999
6000 /* Emulate getpwuid, getpwnam and others.  */
6001
6002 #define PASSWD_FIELD_SIZE 256
6003
6004 static char myPasswdName[PASSWD_FIELD_SIZE];
6005 static char myPasswdDir[MAXPATHLEN+1];
6006
6007 static struct passwd myPasswd =
6008 {
6009   myPasswdName,
6010   myPasswdDir,
6011 };
6012
6013 /* Initialized by main () in macterm.c to pathname of emacs directory.  */
6014 char emacsPasswdDir[MAXPATHLEN+1];
6015
6016 void
6017 InitEmacsPasswdDir ()
6018 {
6019   int found = false;
6020
6021   if (getwd (emacsPasswdDir) && getwd (myPasswdDir))
6022     {
6023       /* Need pathname of first ancestor that begins with `emacs' since
6024          Mac emacs application is somewhere in the emacs-20.3 tree.  */
6025       int len = strlen (emacsPasswdDir);
6026       /* J points to the "/" following the directory name being compared.  */
6027       int j = len - 1;
6028       int i = j - 1;
6029       while (i >= 0 && !found)
6030         {
6031           while (i >= 0 && emacsPasswdDir[i] != '/')
6032             i--;
6033           if (emacsPasswdDir[i] == '/' && i+5 < len)
6034             found = (strncmp (&(emacsPasswdDir[i+1]), "emacs", 5) == 0);
6035           if (found)
6036             emacsPasswdDir[j+1] = '\0';
6037           else
6038             {
6039               j = i;
6040               i = j - 1;
6041             }
6042         }
6043     }
6044
6045   if (!found)
6046     {  /* setting to "/" probably won't work,
6047           but set it to something anyway.  */
6048       strcpy (emacsPasswdDir, "/");
6049       strcpy (myPasswdDir, "/");
6050     }
6051 }
6052
6053 static struct passwd emacsPasswd =
6054 {
6055   "emacs",
6056   emacsPasswdDir,
6057 };
6058
6059 static int myPasswdInited = 0;
6060
6061 static void
6062 InitMyPasswd ()
6063 {
6064   char **ownerName;
6065
6066   /* Note: myPasswdDir initialized in InitEmacsPasswdDir to directory
6067      where Emacs was started. */
6068
6069   ownerName = (char **) GetResource ('STR ',-16096);
6070   if (ownerName)
6071     {
6072       HLock (ownerName);
6073       BlockMove ((unsigned char *) *ownerName,
6074                  (unsigned char *) myPasswdName, *ownerName[0] + 1);
6075       HUnlock (ownerName);
6076       p2cstr ((unsigned char *) myPasswdName);
6077     }
6078   else
6079     myPasswdName[0] = 0;
6080 }
6081
6082 struct passwd *
6083 getpwuid (uid_t uid)
6084 {
6085   if (!myPasswdInited)
6086     {
6087       InitMyPasswd ();
6088       myPasswdInited = 1;
6089     }
6090
6091   return &myPasswd;
6092 }
6093
6094 struct passwd *
6095 getpwnam (const char *name)
6096 {
6097   if (strcmp (name, "emacs") == 0)
6098         return &emacsPasswd;
6099
6100   if (!myPasswdInited)
6101     {
6102       InitMyPasswd ();
6103       myPasswdInited = 1;
6104     }
6105
6106   return &myPasswd;
6107 }
6108
6109 /* The functions fork, kill, sigsetmask, sigblock, request_sigio,
6110    setpgrp, setpriority, and unrequest_sigio are defined to be empty
6111    as in msdos.c.  */
6112
6113 int
6114 fork ()
6115 {
6116   return -1;
6117 }
6118
6119 int
6120 kill (int x, int y)
6121 {
6122   return -1;
6123 }
6124
6125 int
6126 sigsetmask (int x)
6127 {
6128   return 0;
6129 }
6130
6131 int
6132 sigblock (int mask)
6133 {
6134   return 0;
6135 }
6136
6137 void
6138 request_sigio (void)
6139 {
6140 }
6141
6142 int
6143 setpgrp ()
6144 {
6145   return 0;
6146 }
6147
6148 void
6149 unrequest_sigio (void)
6150 {
6151 }
6152
6153 /* djgpp does not implement pipe either.  */
6154 int
6155 pipe (int _fildes[2])
6156 {
6157   errno = EACCES;
6158   return -1;
6159 }
6160
6161 /* Hard and symbolic links.  */
6162 int
6163 symlink (const char *name1, const char *name2)
6164 {
6165   errno = ENOENT;
6166   return -1;
6167 }
6168
6169 int
6170 link (const char *name1, const char *name2)
6171 {
6172   errno = ENOENT;
6173   return -1;
6174 }
6175
6176 int
6177 lstat (const char *path, struct stat *sb)
6178 {
6179   return stat (path, sb);
6180 }
6181
6182 int
6183 readlink (const char *path, char *buf, int bufsiz)
6184 {
6185   errno = ENOENT;
6186   return -1;
6187 }
6188
6189 mode_t
6190 umask (mode_t numask)
6191 {
6192   static mode_t mask = 022;
6193   mode_t oldmask = mask;
6194   mask = numask;
6195   return oldmask;
6196 }
6197
6198 int
6199 chmod (const char *path, mode_t mode)
6200 {
6201   /* say it always succeed for now */
6202   return 0;
6203 }
6204
6205 int
6206 dup (int oldd)
6207 {
6208 #ifdef __MRC__
6209   return fcntl (oldd, F_DUPFD, 0);
6210 #elif __MWERKS__
6211   /* current implementation of fcntl in fcntl.mac.c simply returns old
6212      descriptor */
6213   return fcntl (oldd, F_DUPFD);
6214 #else
6215 You lose!!!
6216 #endif
6217 }
6218
6219 /* This is from the original sysdep.c.  Emulate BSD dup2.  First close
6220    newd if it already exists.  Then, attempt to dup oldd.  If not
6221    successful, call dup2 recursively until we are, then close the
6222    unsuccessful ones.  */
6223 int
6224 dup2 (int oldd, int newd)
6225 {
6226   int fd, ret;
6227
6228   close (newd);
6229
6230   fd = dup (oldd);
6231   if (fd == -1)
6232     return -1;
6233   if (fd == newd)
6234     return newd;
6235   ret = dup2 (oldd, newd);
6236   close (fd);
6237   return ret;
6238 }
6239
6240 /* let it fail for now */
6241 char *
6242 sbrk (int incr)
6243 {
6244   return (char *) -1;
6245 }
6246
6247 int
6248 fsync (int fd)
6249 {
6250   return 0;
6251 }
6252
6253 int
6254 ioctl (int d, int request, void *argp)
6255 {
6256   return -1;
6257 }
6258
6259 #ifdef __MRC__
6260 int
6261 isatty (int fildes)
6262 {
6263   if (fildes >=0 && fildes <= 2)
6264     return 1;
6265   else
6266     return 0;
6267 }
6268
6269 int
6270 getgid ()
6271 {
6272   return 100;
6273 }
6274
6275 int
6276 getegid ()
6277 {
6278   return 100;
6279 }
6280
6281 int
6282 getuid ()
6283 {
6284   return 200;
6285 }
6286
6287 int
6288 geteuid ()
6289 {
6290   return 200;
6291 }
6292
6293 unsigned int
6294 sleep (unsigned int seconds)
6295 {
6296   unsigned long finalTick;
6297
6298   Delay (seconds * 60UL, &finalTick);
6299   return (0);
6300 }
6301 #endif /* __MRC__ */
6302
6303 #ifdef __MWERKS__
6304 #undef getpid
6305 int
6306 getpid ()
6307 {
6308   return 9999;
6309 }
6310 #endif /* __MWERKS__ */
6311
6312 /* Return the path to the directory in which Emacs can create
6313    temporary files.  The MacOS "temporary items" directory cannot be
6314    used because it removes the file written by a process when it
6315    exits.  In that sense it's more like "/dev/null" than "/tmp" (but
6316    again not exactly).  And of course Emacs needs to read back the
6317    files written by its subprocesses.  So here we write the files to a
6318    directory "Emacs" in the Preferences Folder.  This directory is
6319    created if it does not exist.  */
6320 static char *
6321 GetTempDirName ()
6322 {
6323   static char *TempDirName = NULL;
6324   short vRefNum;
6325   long dirID;
6326   OSErr err;
6327   Str255 dirName, fullPath;
6328   CInfoPBRec cpb;
6329   char unixDirName[MAXPATHLEN+1];
6330   DIR *dir;
6331
6332   /* Cache directory name with pointer TempDirName.
6333      Look for it only the first time.  */
6334   if (!TempDirName)
6335     {
6336       err = FindFolder (kOnSystemDisk, kPreferencesFolderType,
6337                         kCreateFolder, &vRefNum, &dirID);
6338       if (err != noErr)
6339         return NULL;
6340
6341       *fullPath = '\0';
6342       cpb.dirInfo.ioNamePtr = dirName;
6343       cpb.dirInfo.ioDrParID = dirID;
6344
6345       /* Standard ref num to full path name loop */
6346       do {
6347         cpb.dirInfo.ioVRefNum = vRefNum;
6348         cpb.dirInfo.ioFDirIndex = -1;
6349         cpb.dirInfo.ioDrDirID = cpb.dirInfo.ioDrParID;
6350
6351         err = PBGetCatInfo (&cpb, false);
6352
6353         p2cstr (dirName);
6354         strcat (dirName, ":");
6355         if (strlen (fullPath) + strlen (dirName) <= MAXPATHLEN)
6356           {
6357             strcat (dirName, fullPath);
6358             strcpy (fullPath, dirName);
6359           }
6360         else
6361           return NULL;
6362       }
6363       while (cpb.dirInfo.ioDrDirID != fsRtDirID && err == noErr);
6364
6365       if (strlen (fullPath) + 6 <= MAXPATHLEN)
6366         strcat (fullPath, "Emacs:");
6367       else
6368         return NULL;
6369
6370       if (Mac2UnixPathname (fullPath, unixDirName, MAXPATHLEN+1) == 0)
6371         return NULL;
6372
6373       dir = opendir (unixDirName);  /* check whether temp directory exists */
6374       if (dir)
6375         closedir (dir);
6376       else if (mkdir (unixDirName, 0700) != 0)  /* create it if not */
6377         return NULL;
6378
6379       TempDirName = (char *) malloc (strlen (unixDirName) + 1);
6380       strcpy (TempDirName, unixDirName);
6381     }
6382
6383   return TempDirName;
6384 }
6385
6386 char *
6387 getenv (const char * name)
6388 {
6389   if (strcmp (name, "TERM") == 0)
6390     return "vt100";
6391   else if (strcmp (name, "TERMCAP") == 0)
6392     /* for debugging purpose when code was still outputting to dumb terminal */
6393     return "d0|vt100|vt100-am|vt100am|dec vt100:do=[do]:co#100:li#32:cl=[cl]:sf=[sf]:km:\
6394 :le=[le]:bs:am:cm=[cm-%d,%d]:nd=[nd]:up=[up]:ce=[ce]:cd=[cd]:so=[so]:se=[se]:\
6395 :us=[us]:ue=[ue]:md=[md]:mr=[mr]:mb=[mb]:me=[me]:is=[is]:\
6396 :rf=/usr/share/lib/tabset/vt100:rs=[rs]:ks=[ks]:ke=[ke]:\
6397 :ku=\\036:kd=\\037:kr=\\035:kl=\\034:kb=[kb]:ho=[ho]:k1=[k1]:k2=[k2]:k3=[k3]:k4=[k4]:\
6398 :pt:sr=[sr]:vt#3:xn:sc=[sc]:rc=[rc]:cs=[cs-%d,%d]";
6399   else if (strcmp (name, "TMPDIR") == 0)
6400     return GetTempDirName ();
6401   else
6402     return (NULL);
6403 }
6404
6405 #ifdef __MRC__
6406 /* see Interfaces&Libraries:Interfaces:CIncludes:signal.h */
6407 char *sys_siglist[] =
6408 {
6409   "Zero is not a signal!!!",
6410   "Abort",  /* 1 */
6411   "Interactive user interrupt",  /* 2 */  "BAD",
6412   "Floating point exception",  /* 4 */  "BAD", "BAD", "BAD",
6413   "Illegal instruction",  /* 8 */  "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD",
6414   "Segment violation",  /* 16 */  "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD", "BAD",
6415   "Terminal"  /* 32 */
6416 };
6417 #elif __MWERKS__
6418 char *sys_siglist[] =
6419 {
6420   "Zero is not a signal!!!",
6421   "Abort",
6422   "Floating point exception",
6423   "Illegal instruction",
6424   "Interactive user interrupt",
6425   "Segment violation",
6426   "Terminal"
6427 };
6428 #else
6429 You lose!!!
6430 #endif
6431
6432 #ifdef __MRC__
6433 #include <utsname.h>
6434
6435 int
6436 uname (struct utsname *name)
6437 {
6438   char **systemName;
6439   systemName = GetString (-16413);  /* IM - Resource Manager Reference */
6440   if (systemName)
6441     {
6442       BlockMove (*systemName, name->nodename, (*systemName)[0]+1);
6443       p2cstr (name->nodename);
6444     }
6445   else
6446     return -1;
6447 }
6448 #endif
6449
6450 #include <Processes.h>
6451 #include <EPPC.h>
6452
6453 /* Event class of HLE sent to subprocess.  */
6454 const OSType kEmacsSubprocessSend = 'ESND';
6455 /* Event class of HLE sent back from subprocess.  */
6456 const OSType kEmacsSubprocessReply = 'ERPY';
6457
6458 char *
6459 mystrchr (char *s, char c)
6460 {
6461   while (*s && *s != c)
6462     {
6463       if (*s == '\\')
6464         s++;
6465       s++;
6466     }
6467
6468   if (*s)
6469     {
6470       *s = '\0';
6471       return s;
6472     }
6473   else
6474     return NULL;
6475 }
6476
6477 char *
6478 mystrtok (char *s)
6479 {
6480   while (*s)
6481     s++;
6482
6483   return s + 1;
6484 }
6485
6486 void
6487 mystrcpy (char *to, char *from)
6488 {
6489   while (*from)
6490     {
6491       if (*from == '\\')
6492         from++;
6493       *to++ = *from++;
6494     }
6495   *to = '\0';
6496 }
6497
6498 /* Start a Mac subprocess.  Arguments for it is passed in argv (null
6499    terminated).  The process should run with the default directory
6500    "workdir", read input from "infn", and write output and error to
6501    "outfn" and "errfn", resp.  The Process Manager call
6502    LaunchApplication is used to start the subprocess.  We use high
6503    level events as the mechanism to pass arguments to the subprocess
6504    and to make Emacs wait for the subprocess to terminate and pass
6505    back a result code.  The bulk of the code here packs the arguments
6506    into one message to be passed together with the high level event.
6507    Emacs also sometimes starts a subprocess using a shell to perform
6508    wildcard filename expansion.  Since we don't really have a shell on
6509    the Mac, this case is detected and the starting of the shell is
6510    by-passed.  We really need to add code here to do filename
6511    expansion to support such functionality. */
6512 int
6513 run_mac_command (argv, workdir, infn, outfn, errfn)
6514      unsigned char **argv;
6515      const char *workdir;
6516      const char *infn, *outfn, errfn;
6517 {
6518   char macappname[MAXPATHLEN+1], macworkdir[MAXPATHLEN+1];
6519   char macinfn[MAXPATHLEN+1], macoutfn[MAXPATHLEN+1], macerrfn[MAXPATHLEN+1];
6520   int paramlen, argc, newargc, j, retries;
6521   char **newargv, *param, *p;
6522   OSErr iErr;
6523   FSSpec spec;
6524   LaunchParamBlockRec lpbr;
6525   EventRecord sendEvent, replyEvent;
6526   RgnHandle cursorRegionHdl;
6527   TargetID targ;
6528   unsigned long refCon, len;
6529
6530   if (Unix2MacPathname (workdir, macworkdir, MAXPATHLEN+1) == 0)
6531     return -1;
6532   if (Unix2MacPathname (infn, macinfn, MAXPATHLEN+1) == 0)
6533     return -1;
6534   if (Unix2MacPathname (outfn, macoutfn, MAXPATHLEN+1) == 0)
6535     return -1;
6536   if (Unix2MacPathname (errfn, macerrfn, MAXPATHLEN+1) == 0)
6537     return -1;
6538
6539   paramlen = strlen (macworkdir) + strlen (macinfn) + strlen (macoutfn) + strlen (macerrfn) + 4;
6540   /* count nulls at end of strings */
6541
6542   argc = 0;
6543   while (argv[argc])
6544     argc++;
6545
6546   if (argc == 0)
6547     return -1;
6548
6549   /* If a subprocess is invoked with a shell, we receive 3 arguments of the form:
6550      "<path to emacs bins>/sh" "-c" "<path to emacs bins>/<command> <command args>" */
6551   j = strlen (argv[0]);
6552   if (j >= 3 && strcmp (argv[0]+j-3, "/sh") == 0 && argc == 3 && strcmp (argv[1], "-c") == 0)
6553     {
6554       char *command, *t, tempmacpathname[MAXPATHLEN+1];
6555
6556       /* The arguments for the command in argv[2] are separated by spaces.  Count them and put
6557          the count in newargc.  */
6558       command = (char *) alloca (strlen (argv[2])+2);
6559       strcpy (command, argv[2]);
6560       if (command[strlen (command) - 1] != ' ')
6561         strcat (command, " ");
6562
6563       t = command;
6564       newargc = 0;
6565       t = mystrchr (t, ' ');
6566       while (t)
6567         {
6568           newargc++;
6569           t = mystrchr (t+1, ' ');
6570         }
6571
6572       newargv = (char **) alloca (sizeof (char *) * newargc);
6573
6574       t = command;
6575       for (j = 0; j < newargc; j++)
6576         {
6577           newargv[j] = (char *) alloca (strlen (t) + 1);
6578           mystrcpy (newargv[j], t);
6579
6580           t = mystrtok (t);
6581           paramlen += strlen (newargv[j]) + 1;
6582         }
6583
6584       if (strncmp (newargv[0], "~emacs/", 7) == 0)
6585         {
6586           if (Unix2MacPathname (newargv[0], tempmacpathname, MAXPATHLEN+1) == 0)
6587             return -1;
6588         }
6589       else
6590         {  /* sometimes Emacs call "sh" without a path for the command */
6591 #if 0
6592           char *t = (char *) alloca (strlen (newargv[0]) + 7 + 1);
6593           strcpy (t, "~emacs/");
6594           strcat (t, newargv[0]);
6595 #endif
6596           Lisp_Object path;
6597           openp (Vexec_path, build_string (newargv[0]), EXEC_SUFFIXES, &path, 1);
6598
6599           if (NILP (path))
6600             return -1;
6601           if (Unix2MacPathname (XSTRING (path)->data, tempmacpathname, MAXPATHLEN+1) == 0)
6602             return -1;
6603         }
6604       strcpy (macappname, tempmacpathname);
6605     }
6606   else
6607     {
6608       if (Unix2MacPathname (argv[0], macappname, MAXPATHLEN+1) == 0)
6609         return -1;
6610
6611       newargv = (char **) alloca (sizeof (char *) * argc);
6612       newargc = argc;
6613       for (j = 1; j < argc; j++)
6614         {
6615           if (strncmp (argv[j], "~emacs/", 7) == 0)
6616             {
6617               char *t = strchr (argv[j], ' ');
6618               if (t)
6619                 {
6620                   char tempcmdname[MAXPATHLEN+1], tempmaccmdname[MAXPATHLEN+1];
6621                   strncpy (tempcmdname, argv[j], t-argv[j]);
6622                   tempcmdname[t-argv[j]] = '\0';
6623                   if (Unix2MacPathname (tempcmdname, tempmaccmdname, MAXPATHLEN+1) == 0)
6624                     return -1;
6625                   newargv[j] = (char *) alloca (strlen (tempmaccmdname) + strlen (t) + 1);
6626                   strcpy (newargv[j], tempmaccmdname);
6627                   strcat (newargv[j], t);
6628                 }
6629               else
6630                 {
6631                   char tempmaccmdname[MAXPATHLEN+1];
6632                   if (Unix2MacPathname (argv[j], tempmaccmdname, MAXPATHLEN+1) == 0)
6633                     return -1;
6634                   newargv[j] = (char *) alloca (strlen (tempmaccmdname)+1);
6635                   strcpy (newargv[j], tempmaccmdname);
6636                 }
6637             }
6638           else
6639             newargv[j] = argv[j];
6640           paramlen += strlen (newargv[j]) + 1;
6641         }
6642     }
6643
6644   /* After expanding all the arguments, we now know the length of the parameter block to be
6645      sent to the subprocess as a message attached to the HLE. */
6646   param = (char *) malloc (paramlen + 1);
6647   if (!param)
6648     return -1;
6649
6650   p = param;
6651   *p++ = newargc;  /* first byte of message contains number of arguments for command */
6652   strcpy (p, macworkdir);
6653   p += strlen (macworkdir);
6654   *p++ = '\0';  /* null terminate strings sent so it's possible to use strcpy over there */
6655   strcpy (p, macinfn);
6656   p += strlen (macinfn);
6657   *p++ = '\0';
6658   strcpy (p, macoutfn);
6659   p += strlen (macoutfn);
6660   *p++ = '\0';
6661   strcpy (p, macerrfn);
6662   p += strlen (macerrfn);
6663   *p++ = '\0';
6664   for (j = 1; j < newargc; j++) {
6665     strcpy (p, newargv[j]);
6666     p += strlen (newargv[j]);
6667     *p++ = '\0';
6668   }
6669
6670   c2pstr (macappname);
6671
6672   iErr = FSMakeFSSpec (0, 0, macappname, &spec);
6673
6674   if (iErr != noErr) {
6675     free (param);
6676     return -1;
6677   }
6678
6679   lpbr.launchBlockID = extendedBlock;
6680   lpbr.launchEPBLength = extendedBlockLen;
6681   lpbr.launchControlFlags = launchContinue + launchNoFileFlags;
6682   lpbr.launchAppSpec = &spec;
6683   lpbr.launchAppParameters = NULL;
6684
6685   iErr = LaunchApplication (&lpbr);  /* call the subprocess */
6686   if (iErr != noErr) {
6687     free (param);
6688     return -1;
6689   }
6690
6691   sendEvent.what = kHighLevelEvent;
6692   sendEvent.message = kEmacsSubprocessSend;  /* Event ID stored in "where" unused */
6693
6694   retries = 3;
6695   do {  /* OS may think current subprocess has terminated if previous one terminated recently */
6696     iErr = PostHighLevelEvent (&sendEvent, &lpbr.launchProcessSN, 0, param, paramlen + 1, receiverIDisPSN);
6697   }
6698   while (iErr == sessClosedErr && retries-- > 0);
6699
6700   if (iErr != noErr) {
6701     free (param);
6702     return -1;
6703   }
6704
6705   cursorRegionHdl = NewRgn ();
6706
6707   /* Wait for the subprocess to finish, when it will send us a ERPY high level event */
6708   while (1)
6709     if (WaitNextEvent (highLevelEventMask, &replyEvent, 180, cursorRegionHdl) && replyEvent.message == kEmacsSubprocessReply)
6710       break;
6711
6712   /* The return code is sent through the refCon */
6713   iErr = AcceptHighLevelEvent (&targ, &refCon, NULL, &len);
6714   if (iErr != noErr) {
6715     DisposeHandle ((Handle) cursorRegionHdl);
6716     free (param);
6717     return -1;
6718   }
6719
6720   DisposeHandle ((Handle) cursorRegionHdl);
6721   free (param);
6722
6723   return refCon;
6724 }
6725
6726 DIR *
6727 opendir (const char *dirname)
6728 {
6729   char MacPathname[MAXPATHLEN+1];
6730   DIR *dirp;
6731   CInfoPBRec cipb;
6732   int len;
6733
6734   dirp = (DIR *) malloc (sizeof (DIR));
6735   if (!dirp)
6736     return 0;
6737
6738   /* Handle special case when dirname is "/": sets up for readir to
6739      get all mount volumes. */
6740   if (strcmp (dirname, "/") == 0) {
6741     dirp->getting_volumes = 1;  /* special all mounted volumes DIR struct */
6742     dirp->current_index = 1;  /* index for first volume */
6743     return dirp;
6744   }
6745
6746   /* Handle typical cases: not accessing all mounted volumes. */
6747   if (Unix2MacPathname (dirname, MacPathname, MAXPATHLEN+1) == 0)
6748     return 0;
6749
6750   /* Emacs calls opendir without the trailing '/', Mac needs trailing ':' */
6751   len = strlen (MacPathname);
6752   if (MacPathname[len - 1] != ':' && len < MAXPATHLEN)
6753     strcat (MacPathname, ":");
6754
6755   c2pstr (MacPathname);
6756   cipb.hFileInfo.ioNamePtr = MacPathname;  /* using full pathname so vRefNum and dirID ignored */
6757   cipb.hFileInfo.ioVRefNum = 0;
6758   cipb.hFileInfo.ioDirID = 0;
6759   cipb.hFileInfo.ioFDirIndex = 0;  /* set to 0 to get information about specific dir or file */
6760
6761   errno = PBGetCatInfo (&cipb, false);
6762   if (errno != noErr) {
6763     errno = ENOENT;
6764     return 0;
6765   }
6766
6767   if (!(cipb.hFileInfo.ioFlAttrib & 0x10))  /* bit 4 = 1 for directories */
6768     return 0;  /* not a directory */
6769
6770   dirp->dir_id = cipb.dirInfo.ioDrDirID;  /* used later in readdir */
6771   dirp->getting_volumes = 0;
6772   dirp->current_index = 1;  /* index for first file/directory */
6773
6774   return dirp;
6775 }
6776
6777 int
6778 closedir (DIR *dp)
6779 {
6780   free (dp);
6781
6782   return 0;
6783 }
6784
6785 struct dirent *
6786 readdir (DIR *dp)
6787 {
6788   HParamBlockRec HPBlock;
6789   CInfoPBRec cipb;
6790   static struct dirent s_dirent;
6791   static Str255 s_name;
6792   int done;
6793
6794   /* Handle the root directory containing the mounted volumes.  Call
6795      PBHGetVInfo specifying an index to obtain the info for a volume.
6796      PBHGetVInfo returns an error when it receives an index beyond the
6797      last volume, at which time we should return a nil dirent struct
6798      pointer. */
6799   if (dp->getting_volumes) {
6800     HPBlock.volumeParam.ioNamePtr = s_name;
6801     HPBlock.volumeParam.ioVRefNum = 0;
6802     HPBlock.volumeParam.ioVolIndex = dp->current_index;
6803
6804     errno = PBHGetVInfo (&HPBlock, false);
6805     if (errno != noErr) {
6806       errno = ENOENT;
6807       return 0;
6808     }
6809
6810     p2cstr (s_name);
6811     strcat (s_name, "/");  /* need "/" for stat to work correctly */
6812
6813     dp->current_index++;
6814
6815     s_dirent.d_ino = cipb.dirInfo.ioDrDirID;
6816     s_dirent.d_name = s_name;
6817
6818     return &s_dirent;
6819   }
6820   else {
6821     cipb.hFileInfo.ioVRefNum = 0;
6822     cipb.hFileInfo.ioNamePtr = s_name;  /* location to receive filename returned */
6823
6824     /* return only visible files */
6825     done = false;
6826     while (!done) {
6827       cipb.hFileInfo.ioDirID = dp->dir_id;  /* directory ID found by opendir */
6828       cipb.hFileInfo.ioFDirIndex = dp->current_index;
6829
6830       errno = PBGetCatInfo (&cipb, false);
6831       if (errno != noErr) {
6832         errno = ENOENT;
6833         return 0;
6834       }
6835
6836       /* insist on an visibile entry */
6837       if (cipb.hFileInfo.ioFlAttrib & 0x10)  /* directory? */
6838         done = !(cipb.dirInfo.ioDrUsrWds.frFlags & fInvisible);
6839       else
6840         done = !(cipb.hFileInfo.ioFlFndrInfo.fdFlags & fInvisible);
6841
6842       dp->current_index++;
6843     }
6844
6845     p2cstr (s_name);
6846
6847     s_dirent.d_ino = cipb.dirInfo.ioDrDirID;  /* value unimportant: non-zero for valid file */
6848     s_dirent.d_name = s_name;
6849
6850     return &s_dirent;
6851   }
6852 }
6853
6854 char *
6855 getwd (char *path)
6856 {
6857   char MacPathname[MAXPATHLEN+1];
6858   Str255 directoryName;
6859   OSErr errno;
6860   CInfoPBRec cipb;
6861
6862   MacPathname[0] = '\0';
6863   directoryName[0] = '\0';
6864   cipb.dirInfo.ioDrParID = 0;
6865   cipb.dirInfo.ioNamePtr = directoryName;  /* empty string = default directory */
6866
6867   do {
6868     cipb.dirInfo.ioVRefNum = 0;
6869     cipb.dirInfo.ioFDirIndex = -1;
6870     cipb.dirInfo.ioDrDirID = cipb.dirInfo.ioDrParID;  /* go up to parent each time */
6871
6872     errno = PBGetCatInfo (&cipb, false);
6873     if (errno != noErr) {
6874       errno = ENOENT;
6875       return 0;
6876     }
6877
6878     p2cstr (directoryName);
6879     strcat (directoryName, ":");
6880     strcat (directoryName, MacPathname);  /* attach to front since going up directory tree */
6881     strcpy (MacPathname, directoryName);
6882   } while (cipb.dirInfo.ioDrDirID != fsRtDirID);  /* until volume's root directory */
6883
6884   if (Mac2UnixPathname (MacPathname, path, MAXPATHLEN+1) == 0)
6885     return 0;
6886   else
6887     return path;
6888 }
6889
6890 #endif /* macintosh */