src/sysdep.c

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