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 _read
  52 #define write _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 #ifndef HAVE_TEXT_START
2159 char *
2160 start_of_text ()
2161 {
2162 #ifdef TEXT_START
2163   return ((char *) TEXT_START);
2164 #else
2165 #ifdef GOULD
2166   extern csrt ();
2167   return ((char *) csrt);
2168 #else /* not GOULD */
2169   extern int _start ();
2170   return ((char *) _start);
2171 #endif /* GOULD */
2172 #endif /* TEXT_START */
2173 }
2174 #endif /* not HAVE_TEXT_START */
2175
2176 /*
2177  *      Return the address of the start of the data segment prior to
2178  *      doing an unexec.  After unexec the return value is undefined.
2179  *      See crt0.c for further information and definition of data_start.
2180  *
2181  *      Apparently, on BSD systems this is etext at startup.  On
2182  *      USG systems (swapping) this is highly mmu dependent and
2183  *      is also dependent on whether or not the program is running
2184  *      with shared text.  Generally there is a (possibly large)
2185  *      gap between end of text and start of data with shared text.
2186  *
2187  *      On Uniplus+ systems with shared text, data starts at a
2188  *      fixed address.  Each port (from a given oem) is generally
2189  *      different, and the specific value of the start of data can
2190  *      be obtained via the UniPlus+ specific "uvar" system call,
2191  *      however the method outlined in crt0.c seems to be more portable.
2192  *
2193  *      Probably what will have to happen when a USG unexec is available,
2194  *      at least on UniPlus, is temacs will have to be made unshared so
2195  *      that text and data are contiguous.  Then once loadup is complete,
2196  *      unexec will produce a shared executable where the data can be
2197  *      at the normal shared text boundary and the startofdata variable
2198  *      will be patched by unexec to the correct value.
2199  *
2200  */
2201
2202 char *
2203 start_of_data ()
2204 {
2205 #ifdef DATA_START
2206   return ((char *) DATA_START);
2207 #else
2208 #ifdef ORDINARY_LINK
2209   /*
2210    * This is a hack.  Since we're not linking crt0.c or pre_crt0.c,
2211    * data_start isn't defined.  We take the address of environ, which
2212    * is known to live at or near the start of the system crt0.c, and
2213    * we don't sweat the handful of bytes that might lose.
2214    */
2215   extern char **environ;
2216
2217   return ((char *) &environ);
2218 #else
2219   extern int data_start;
2220   return ((char *) &data_start);
2221 #endif /* ORDINARY_LINK */
2222 #endif /* DATA_START */
2223 }
2224 #endif /* NEED_STARTS (not CANNOT_DUMP or not SYSTEM_MALLOC) */
2225
2226 #ifndef CANNOT_DUMP
2227 /* Some systems that cannot dump also cannot implement these.  */
2228
2229 /*
2230  *      Return the address of the end of the text segment prior to
2231  *      doing an unexec.  After unexec the return value is undefined.
2232  */
2233
2234 char *
2235 end_of_text ()
2236 {
2237 #ifdef TEXT_END
2238   return ((char *) TEXT_END);
2239 #else
2240   extern int etext;
2241   return ((char *) &etext);
2242 #endif
2243 }
2244
2245 /*
2246  *      Return the address of the end of the data segment prior to
2247  *      doing an unexec.  After unexec the return value is undefined.
2248  */
2249
2250 char *
2251 end_of_data ()
2252 {
2253 #ifdef DATA_END
2254   return ((char *) DATA_END);
2255 #else
2256   extern int edata;
2257   return ((char *) &edata);
2258 #endif
2259 }
2260
2261 #endif /* not CANNOT_DUMP */
2262 \f
2263 /* init_system_name sets up the string for the Lisp function
2264    system-name to return. */
2265
2266 #ifdef BSD4_1
2267 #include <whoami.h>
2268 #endif
2269
2270 extern Lisp_Object Vsystem_name;
2271
2272 #ifndef BSD4_1
2273 #ifndef VMS
2274 #ifdef HAVE_SOCKETS
2275 #include <sys/socket.h>
2276 #include <netdb.h>
2277 #endif /* HAVE_SOCKETS */
2278 #endif /* not VMS */
2279 #endif /* not BSD4_1 */
2280
2281 void
2282 init_system_name ()
2283 {
2284 #ifdef BSD4_1
2285   Vsystem_name = build_string (sysname);
2286 #else
2287 #ifdef VMS
2288   char *sp, *end;
2289   if ((sp = egetenv ("SYS$NODE")) == 0)
2290     Vsystem_name = build_string ("vax-vms");
2291   else if ((end = index (sp, ':')) == 0)
2292     Vsystem_name = build_string (sp);
2293   else
2294     Vsystem_name = make_string (sp, end - sp);
2295 #else
2296 #ifndef HAVE_GETHOSTNAME
2297   struct utsname uts;
2298   uname (&uts);
2299   Vsystem_name = build_string (uts.nodename);
2300 #else /* HAVE_GETHOSTNAME */
2301   unsigned int hostname_size = 256;
2302   char *hostname = (char *) alloca (hostname_size);
2303
2304   /* Try to get the host name; if the buffer is too short, try
2305      again.  Apparently, the only indication gethostname gives of
2306      whether the buffer was large enough is the presence or absence
2307      of a '\0' in the string.  Eech.  */
2308   for (;;)
2309     {
2310       gethostname (hostname, hostname_size - 1);
2311       hostname[hostname_size - 1] = '\0';
2312
2313       /* Was the buffer large enough for the '\0'?  */
2314       if (strlen (hostname) < hostname_size - 1)
2315         break;
2316
2317       hostname_size <<= 1;
2318       hostname = (char *) alloca (hostname_size);
2319     }
2320 #ifdef HAVE_SOCKETS
2321   /* Turn the hostname into the official, fully-qualified hostname.
2322      Don't do this if we're going to dump; this can confuse system
2323      libraries on some machines and make the dumped emacs core dump. */
2324 #ifndef CANNOT_DUMP
2325   if (initialized)
2326 #endif /* not CANNOT_DUMP */
2327     if (! index (hostname, '.'))
2328       {
2329         struct hostent *hp;
2330         int count;
2331         for (count = 0;; count++)
2332           {
2333 #ifdef TRY_AGAIN
2334             h_errno = 0;
2335 #endif
2336             hp = gethostbyname (hostname);
2337 #ifdef TRY_AGAIN
2338             if (! (hp == 0 && h_errno == TRY_AGAIN))
2339 #endif
2340               break;
2341             if (count >= 5)
2342               break;
2343             Fsleep_for (make_number (1), Qnil);
2344           }
2345         if (hp)
2346           {
2347             char *fqdn = (char *) hp->h_name;
2348             char *p;
2349
2350             if (!index (fqdn, '.'))
2351               {
2352                 /* We still don't have a fully qualified domain name.
2353                    Try to find one in the list of alternate names */
2354                 char **alias = hp->h_aliases;
2355                 while (*alias && !index (*alias, '.'))
2356                   alias++;
2357                 if (*alias)
2358                   fqdn = *alias;
2359               }
2360             hostname = fqdn;
2361 #if 0
2362             /* Convert the host name to lower case.  */
2363             /* Using ctype.h here would introduce a possible locale
2364                dependence that is probably wrong for hostnames.  */
2365             p = hostname;
2366             while (*p)
2367               {
2368                 if (*p >= 'A' && *p <= 'Z')
2369                   *p += 'a' - 'A';
2370                 p++;
2371               }
2372 #endif
2373           }
2374       }
2375 #endif /* HAVE_SOCKETS */
2376   /* We used to try using getdomainname here,
2377      but NIIBE Yutaka <gniibe@etl.go.jp> says that
2378      getdomainname gets the NIS/YP domain which often is not the same
2379      as in Internet domain name.  */
2380 #if 0 /* Turned off because sysinfo is not really likely to return the
2381          correct Internet domain.  */
2382 #if (HAVE_SYSINFO && defined (SI_SRPC_DOMAIN))
2383   if (! index (hostname, '.'))
2384     {
2385       /* The hostname is not fully qualified.  Append the domain name.  */
2386
2387       int hostlen = strlen (hostname);
2388       int domain_size = 256;
2389
2390       for (;;)
2391         {
2392           char *domain = (char *) alloca (domain_size + 1);
2393           char *fqdn = (char *) alloca (hostlen + 1 + domain_size + 1);
2394           int sys_domain_size = sysinfo (SI_SRPC_DOMAIN, domain, domain_size);
2395           if (sys_domain_size <= 0)
2396             break;
2397           if (domain_size < sys_domain_size)
2398             {
2399               domain_size = sys_domain_size;
2400               continue;
2401             }
2402           strcpy (fqdn, hostname);
2403           if (domain[0] == '.')
2404             strcpy (fqdn + hostlen, domain);
2405           else if (domain[0] != 0)
2406             {
2407               fqdn[hostlen] = '.';
2408               strcpy (fqdn + hostlen + 1, domain);
2409             }
2410           hostname = fqdn;
2411           break;
2412         }
2413     }
2414 #endif /* HAVE_SYSINFO && defined (SI_SRPC_DOMAIN) */
2415 #endif /* 0 */
2416   Vsystem_name = build_string (hostname);
2417 #endif /* HAVE_GETHOSTNAME */
2418 #endif /* VMS */
2419 #endif /* BSD4_1 */
2420   {
2421     unsigned char *p;
2422     for (p = XSTRING (Vsystem_name)->data; *p; p++)
2423       if (*p == ' ' || *p == '\t')
2424         *p = '-';
2425   }
2426 }
2427 \f
2428 #ifndef MSDOS
2429 #ifndef VMS
2430 #if !defined (HAVE_SELECT) || defined (BROKEN_SELECT_NON_X)
2431
2432 #include "sysselect.h"
2433 #undef select
2434
2435 #if defined (HAVE_X_WINDOWS) && !defined (HAVE_SELECT)
2436 /* Cause explanatory error message at compile time,
2437    since the select emulation is not good enough for X.  */
2438 int *x = &x_windows_lose_if_no_select_system_call;
2439 #endif
2440
2441 /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs
2442  * Only checks read descriptors.
2443  */
2444 /* How long to wait between checking fds in select */
2445 #define SELECT_PAUSE 1
2446 int select_alarmed;
2447
2448 /* For longjmp'ing back to read_input_waiting.  */
2449
2450 jmp_buf read_alarm_throw;
2451
2452 /* Nonzero if the alarm signal should throw back to read_input_waiting.
2453    The read_socket_hook function sets this to 1 while it is waiting.  */
2454
2455 int read_alarm_should_throw;
2456
2457 SIGTYPE
2458 select_alarm ()
2459 {
2460   select_alarmed = 1;
2461 #ifdef BSD4_1
2462   sigrelse (SIGALRM);
2463 #else /* not BSD4_1 */
2464   signal (SIGALRM, SIG_IGN);
2465 #endif /* not BSD4_1 */
2466   if (read_alarm_should_throw)
2467     longjmp (read_alarm_throw, 1);
2468 }
2469
2470 #ifndef WINDOWSNT
2471 /* Only rfds are checked.  */
2472 int
2473 sys_select (nfds, rfds, wfds, efds, timeout)
2474      int nfds;
2475      SELECT_TYPE *rfds, *wfds, *efds;
2476      EMACS_TIME *timeout;
2477 {
2478   int ravail = 0;
2479   SELECT_TYPE orfds;
2480   int timeoutval;
2481   int *local_timeout;
2482   extern int proc_buffered_char[];
2483 #ifndef subprocesses
2484   int process_tick = 0, update_tick = 0;
2485 #else
2486   extern int process_tick, update_tick;
2487 #endif
2488   unsigned char buf;
2489
2490 #if defined (HAVE_SELECT) && defined (HAVE_X_WINDOWS)
2491   /* If we're using X, then the native select will work; we only need the
2492      emulation for non-X usage.  */
2493   if (!NILP (Vwindow_system))
2494     return select (nfds, rfds, wfds, efds, timeout);
2495 #endif
2496   timeoutval = timeout ? EMACS_SECS (*timeout) : 100000;
2497   local_timeout = &timeoutval;
2498   FD_ZERO (&orfds);
2499   if (rfds)
2500     {
2501       orfds = *rfds;
2502       FD_ZERO (rfds);
2503     }
2504   if (wfds)
2505     FD_ZERO (wfds);
2506   if (efds)
2507     FD_ZERO (efds);
2508
2509   /* If we are looking only for the terminal, with no timeout,
2510      just read it and wait -- that's more efficient.  */
2511   if (*local_timeout == 100000 && process_tick == update_tick
2512       && FD_ISSET (0, &orfds))
2513     {
2514       int fd;
2515       for (fd = 1; fd < nfds; ++fd)
2516         if (FD_ISSET (fd, &orfds))
2517           goto hardway;
2518       if (! detect_input_pending ())
2519         read_input_waiting ();
2520       FD_SET (0, rfds);
2521       return 1;
2522     }
2523
2524  hardway:
2525   /* Once a second, till the timer expires, check all the flagged read
2526    * descriptors to see if any input is available.  If there is some then
2527    * set the corresponding bit in the return copy of rfds.
2528    */
2529   while (1)
2530     {
2531       register int to_check, fd;
2532
2533       if (rfds)
2534         {
2535           for (to_check = nfds, fd = 0; --to_check >= 0; fd++)
2536             {
2537               if (FD_ISSET (fd, &orfds))
2538                 {
2539                   int avail = 0, status = 0;
2540
2541                   if (fd == 0)
2542                     avail = detect_input_pending (); /* Special keyboard handler */
2543                   else
2544                     {
2545 #ifdef FIONREAD
2546                       status = ioctl (fd, FIONREAD, &avail);
2547 #else /* no FIONREAD */
2548                       /* Hoping it will return -1 if nothing available
2549                          or 0 if all 0 chars requested are read.  */
2550                       if (proc_buffered_char[fd] >= 0)
2551                         avail = 1;
2552                       else
2553                         {
2554                           avail = read (fd, &buf, 1);
2555                           if (avail > 0)
2556                             proc_buffered_char[fd] = buf;
2557                         }
2558 #endif /* no FIONREAD */
2559                     }
2560                   if (status >= 0 && avail > 0)
2561                     {
2562                       FD_SET (fd, rfds);
2563                       ravail++;
2564                     }
2565                 }
2566             }
2567         }
2568       if (*local_timeout == 0 || ravail != 0 || process_tick != update_tick)
2569         break;
2570
2571       turn_on_atimers (0);
2572       signal (SIGALRM, select_alarm);
2573       select_alarmed = 0;
2574       alarm (SELECT_PAUSE);
2575
2576       /* Wait for a SIGALRM (or maybe a SIGTINT) */
2577       while (select_alarmed == 0 && *local_timeout != 0
2578              && process_tick == update_tick)
2579         {
2580           /* If we are interested in terminal input,
2581              wait by reading the terminal.
2582              That makes instant wakeup for terminal input at least.  */
2583           if (FD_ISSET (0, &orfds))
2584             {
2585               read_input_waiting ();
2586               if (detect_input_pending ())
2587                 select_alarmed = 1;
2588             }
2589           else
2590             pause ();
2591         }
2592       (*local_timeout) -= SELECT_PAUSE;
2593
2594       /* Reset the old alarm if there was one.  */
2595       turn_on_atimers (1);
2596
2597       if (*local_timeout == 0)  /* Stop on timer being cleared */
2598         break;
2599     }
2600   return ravail;
2601 }
2602 #endif /* not WINDOWSNT */
2603
2604 /* Read keyboard input into the standard buffer,
2605    waiting for at least one character.  */
2606
2607 /* Make all keyboard buffers much bigger when using a window system.  */
2608 #ifdef HAVE_WINDOW_SYSTEM
2609 #define BUFFER_SIZE_FACTOR 16
2610 #else
2611 #define BUFFER_SIZE_FACTOR 1
2612 #endif
2613
2614 void
2615 read_input_waiting ()
2616 {
2617   struct input_event e;
2618   int nread, i;
2619   extern int quit_char;
2620
2621   if (read_socket_hook)
2622     {
2623       struct input_event buf[256];
2624
2625       read_alarm_should_throw = 0;
2626       if (! setjmp (read_alarm_throw))
2627         nread = (*read_socket_hook) (0, buf, 256, 1);
2628       else
2629         nread = -1;
2630
2631       /* Scan the chars for C-g and store them in kbd_buffer.  */
2632       for (i = 0; i < nread; i++)
2633         {
2634           kbd_buffer_store_event (&buf[i]);
2635           /* Don't look at input that follows a C-g too closely.
2636              This reduces lossage due to autorepeat on C-g.  */
2637           if (buf[i].kind == ascii_keystroke
2638               && buf[i].code == quit_char)
2639             break;
2640         }
2641     }
2642   else
2643     {
2644       char buf[3];
2645       nread = read (fileno (stdin), buf, 1);
2646
2647       /* Scan the chars for C-g and store them in kbd_buffer.  */
2648       e.kind = ascii_keystroke;
2649       e.frame_or_window = selected_frame;
2650       e.modifiers = 0;
2651       for (i = 0; i < nread; i++)
2652         {
2653           /* Convert chars > 0177 to meta events if desired.
2654              We do this under the same conditions that read_avail_input does.  */
2655           if (read_socket_hook == 0)
2656             {
2657               /* If the user says she has a meta key, then believe her. */
2658               if (meta_key == 1 && (buf[i] & 0x80))
2659                 e.modifiers = meta_modifier;
2660               if (meta_key != 2)
2661                 buf[i] &= ~0x80;
2662             }
2663
2664           XSETINT (e.code, buf[i]);
2665           kbd_buffer_store_event (&e);
2666           /* Don't look at input that follows a C-g too closely.
2667              This reduces lossage due to autorepeat on C-g.  */
2668           if (buf[i] == quit_char)
2669             break;
2670         }
2671     }
2672 }
2673
2674 #endif /* not HAVE_SELECT */
2675 #endif /* not VMS */
2676 #endif /* not MSDOS */
2677 \f
2678 #ifdef BSD4_1
2679 void
2680 init_sigio (fd)
2681      int fd;
2682 {
2683   if (noninteractive)
2684     return;
2685   lmode = LINTRUP | lmode;
2686   ioctl (fd, TIOCLSET, &lmode);
2687 }
2688
2689 void
2690 reset_sigio ()
2691 {
2692   if (noninteractive)
2693     return;
2694   lmode = ~LINTRUP & lmode;
2695   ioctl (0, TIOCLSET, &lmode);
2696 }
2697
2698 void
2699 request_sigio ()
2700 {
2701   sigrelse (SIGTINT);
2702
2703   interrupts_deferred = 0;
2704 }
2705
2706 void
2707 unrequest_sigio ()
2708 {
2709   sighold (SIGTINT);
2710
2711   interrupts_deferred = 1;
2712 }
2713
2714 /* still inside #ifdef BSD4_1 */
2715 #ifdef subprocesses
2716
2717 int sigheld; /* Mask of held signals */
2718
2719 void
2720 sigholdx (signum)
2721      int signum;
2722 {
2723   sigheld |= sigbit (signum);
2724   sighold (signum);
2725 }
2726
2727 void
2728 sigisheld (signum)
2729      int signum;
2730 {
2731   sigheld |= sigbit (signum);
2732 }
2733
2734 void
2735 sigunhold (signum)
2736      int signum;
2737 {
2738   sigheld &= ~sigbit (signum);
2739   sigrelse (signum);
2740 }
2741
2742 void
2743 sigfree ()    /* Free all held signals */
2744 {
2745   int i;
2746   for (i = 0; i < NSIG; i++)
2747     if (sigheld & sigbit (i))
2748       sigrelse (i);
2749   sigheld = 0;
2750 }
2751
2752 int
2753 sigbit (i)
2754 {
2755   return 1 << (i - 1);
2756 }
2757 #endif /* subprocesses */
2758 #endif /* BSD4_1 */
2759 \f
2760 /* POSIX signals support - DJB */
2761 /* Anyone with POSIX signals should have ANSI C declarations */
2762
2763 #ifdef POSIX_SIGNALS
2764
2765 sigset_t empty_mask, full_mask;
2766
2767 signal_handler_t
2768 sys_signal (int signal_number, signal_handler_t action)
2769 {
2770   struct sigaction new_action, old_action;
2771   sigemptyset (&new_action.sa_mask);
2772   new_action.sa_handler = action;
2773 #ifdef SA_RESTART
2774   /* Emacs mostly works better with restartable system services. If this
2775    * flag exists, we probably want to turn it on here.
2776    */
2777   new_action.sa_flags = SA_RESTART;
2778 #else
2779   new_action.sa_flags = 0;
2780 #endif
2781   sigaction (signal_number, &new_action, &old_action);
2782   return (old_action.sa_handler);
2783 }
2784
2785 #ifndef __GNUC__
2786 /* If we're compiling with GCC, we don't need this function, since it
2787    can be written as a macro.  */
2788 sigset_t
2789 sys_sigmask (int sig)
2790 {
2791   sigset_t mask;
2792   sigemptyset (&mask);
2793   sigaddset (&mask, sig);
2794   return mask;
2795 }
2796 #endif
2797
2798 /* I'd like to have these guys return pointers to the mask storage in here,
2799    but there'd be trouble if the code was saving multiple masks.  I'll be
2800    safe and pass the structure.  It normally won't be more than 2 bytes
2801    anyhow. - DJB */
2802
2803 sigset_t
2804 sys_sigblock (sigset_t new_mask)
2805 {
2806   sigset_t old_mask;
2807   sigprocmask (SIG_BLOCK, &new_mask, &old_mask);
2808   return (old_mask);
2809 }
2810
2811 sigset_t
2812 sys_sigunblock (sigset_t new_mask)
2813 {
2814   sigset_t old_mask;
2815   sigprocmask (SIG_UNBLOCK, &new_mask, &old_mask);
2816   return (old_mask);
2817 }
2818
2819 sigset_t
2820 sys_sigsetmask (sigset_t new_mask)
2821 {
2822   sigset_t old_mask;
2823   sigprocmask (SIG_SETMASK, &new_mask, &old_mask);
2824   return (old_mask);
2825 }
2826
2827 #endif /* POSIX_SIGNALS */
2828 \f
2829 #if !defined HAVE_STRSIGNAL && !defined SYS_SIGLIST_DECLARED
2830 static char *my_sys_siglist[NSIG];
2831 # ifdef sys_siglist
2832 #  undef sys_siglist
2833 # endif
2834 # define sys_siglist my_sys_siglist
2835 #endif
2836
2837 void
2838 init_signals ()
2839 {
2840 #ifdef POSIX_SIGNALS
2841   sigemptyset (&empty_mask);
2842   sigfillset (&full_mask);
2843 #endif
2844
2845 #if !defined HAVE_STRSIGNAL && !defined SYS_SIGLIST_DECLARED
2846   if (! initialized)
2847     {
2848 # ifdef SIGABRT
2849       sys_siglist[SIGABRT] = "Aborted";
2850 # endif
2851 # ifdef SIGAIO
2852       sys_siglist[SIGAIO] = "LAN I/O interrupt";
2853 # endif
2854 # ifdef SIGALRM
2855       sys_siglist[SIGALRM] = "Alarm clock";
2856 # endif
2857 # ifdef SIGBUS
2858       sys_siglist[SIGBUS] = "Bus error";
2859 # endif
2860 # ifdef SIGCLD
2861       sys_siglist[SIGCLD] = "Child status changed";
2862 # endif
2863 # ifdef SIGCHLD
2864       sys_siglist[SIGCHLD] = "Child status changed";
2865 # endif
2866 # ifdef SIGCONT
2867       sys_siglist[SIGCONT] = "Continued";
2868 # endif
2869 # ifdef SIGDANGER
2870       sys_siglist[SIGDANGER] = "Swap space dangerously low";
2871 # endif
2872 # ifdef SIGDGNOTIFY
2873       sys_siglist[SIGDGNOTIFY] = "Notification message in queue";
2874 # endif
2875 # ifdef SIGEMT
2876       sys_siglist[SIGEMT] = "Emulation trap";
2877 # endif
2878 # ifdef SIGFPE
2879       sys_siglist[SIGFPE] = "Arithmetic exception";
2880 # endif
2881 # ifdef SIGFREEZE
2882       sys_siglist[SIGFREEZE] = "SIGFREEZE";
2883 # endif
2884 # ifdef SIGGRANT
2885       sys_siglist[SIGGRANT] = "Monitor mode granted";
2886 # endif
2887 # ifdef SIGHUP
2888       sys_siglist[SIGHUP] = "Hangup";
2889 # endif
2890 # ifdef SIGILL
2891       sys_siglist[SIGILL] = "Illegal instruction";
2892 # endif
2893 # ifdef SIGINT
2894       sys_siglist[SIGINT] = "Interrupt";
2895 # endif
2896 # ifdef SIGIO
2897       sys_siglist[SIGIO] = "I/O possible";
2898 # endif
2899 # ifdef SIGIOINT
2900       sys_siglist[SIGIOINT] = "I/O intervention required";
2901 # endif
2902 # ifdef SIGIOT
2903       sys_siglist[SIGIOT] = "IOT trap";
2904 # endif
2905 # ifdef SIGKILL
2906       sys_siglist[SIGKILL] = "Killed";
2907 # endif
2908 # ifdef SIGLOST
2909       sys_siglist[SIGLOST] = "Resource lost";
2910 # endif
2911 # ifdef SIGLWP
2912       sys_siglist[SIGLWP] = "SIGLWP";
2913 # endif
2914 # ifdef SIGMSG
2915       sys_siglist[SIGMSG] = "Monitor mode data available";
2916 # endif
2917 # ifdef SIGPHONE
2918       sys_siglist[SIGWIND] = "SIGPHONE";
2919 # endif
2920 # ifdef SIGPIPE
2921       sys_siglist[SIGPIPE] = "Broken pipe";
2922 # endif
2923 # ifdef SIGPOLL
2924       sys_siglist[SIGPOLL] = "Pollable event occurred";
2925 # endif
2926 # ifdef SIGPROF
2927       sys_siglist[SIGPROF] = "Profiling timer expired";
2928 # endif
2929 # ifdef SIGPTY
2930       sys_siglist[SIGPTY] = "PTY I/O interrupt";
2931 # endif
2932 # ifdef SIGPWR
2933       sys_siglist[SIGPWR] = "Power-fail restart";
2934 # endif
2935 # ifdef SIGQUIT
2936       sys_siglist[SIGQUIT] = "Quit";
2937 # endif
2938 # ifdef SIGRETRACT
2939       sys_siglist[SIGRETRACT] = "Need to relinguish monitor mode";
2940 # endif
2941 # ifdef SIGSAK
2942       sys_siglist[SIGSAK] = "Secure attention";
2943 # endif
2944 # ifdef SIGSEGV
2945       sys_siglist[SIGSEGV] = "Segmentation violation";
2946 # endif
2947 # ifdef SIGSOUND
2948       sys_siglist[SIGSOUND] = "Sound completed";
2949 # endif
2950 # ifdef SIGSTOP
2951       sys_siglist[SIGSTOP] = "Stopped (signal)";
2952 # endif
2953 # ifdef SIGSTP
2954       sys_siglist[SIGSTP] = "Stopped (user)";
2955 # endif
2956 # ifdef SIGSYS
2957       sys_siglist[SIGSYS] = "Bad argument to system call";
2958 # endif
2959 # ifdef SIGTERM
2960       sys_siglist[SIGTERM] = "Terminated";
2961 # endif
2962 # ifdef SIGTHAW
2963       sys_siglist[SIGTHAW] = "SIGTHAW";
2964 # endif
2965 # ifdef SIGTRAP
2966       sys_siglist[SIGTRAP] = "Trace/breakpoint trap";
2967 # endif
2968 # ifdef SIGTSTP
2969       sys_siglist[SIGTSTP] = "Stopped (user)";
2970 # endif
2971 # ifdef SIGTTIN
2972       sys_siglist[SIGTTIN] = "Stopped (tty input)";
2973 # endif
2974 # ifdef SIGTTOU
2975       sys_siglist[SIGTTOU] = "Stopped (tty output)";
2976 # endif
2977 # ifdef SIGURG
2978       sys_siglist[SIGURG] = "Urgent I/O condition";
2979 # endif
2980 # ifdef SIGUSR1
2981       sys_siglist[SIGUSR1] = "User defined signal 1";
2982 # endif
2983 # ifdef SIGUSR2
2984       sys_siglist[SIGUSR2] = "User defined signal 2";
2985 # endif
2986 # ifdef SIGVTALRM
2987       sys_siglist[SIGVTALRM] = "Virtual timer expired";
2988 # endif
2989 # ifdef SIGWAITING
2990       sys_siglist[SIGWAITING] = "Process's LWPs are blocked";
2991 # endif
2992 # ifdef SIGWINCH
2993       sys_siglist[SIGWINCH] = "Window size changed";
2994 # endif
2995 # ifdef SIGWIND
2996       sys_siglist[SIGWIND] = "SIGWIND";
2997 # endif
2998 # ifdef SIGXCPU
2999       sys_siglist[SIGXCPU] = "CPU time limit exceeded";
3000 # endif
3001 # ifdef SIGXFSZ
3002       sys_siglist[SIGXFSZ] = "File size limit exceeded";
3003 # endif
3004     }
3005 #endif /* !defined HAVE_STRSIGNAL && !defined SYS_SIGLIST_DECLARED */
3006 }
3007 \f
3008 #ifndef HAVE_RANDOM
3009 #ifdef random
3010 #define HAVE_RANDOM
3011 #endif
3012 #endif
3013
3014 /* Figure out how many bits the system's random number generator uses.
3015    `random' and `lrand48' are assumed to return 31 usable bits.
3016    BSD `rand' returns a 31 bit value but the low order bits are unusable;
3017    so we'll shift it and treat it like the 15-bit USG `rand'.  */
3018
3019 #ifndef RAND_BITS
3020 # ifdef HAVE_RANDOM
3021 #  define RAND_BITS 31
3022 # else /* !HAVE_RANDOM */
3023 #  ifdef HAVE_LRAND48
3024 #   define RAND_BITS 31
3025 #   define random lrand48
3026 #  else /* !HAVE_LRAND48 */
3027 #   define RAND_BITS 15
3028 #   if RAND_MAX == 32767
3029 #    define random rand
3030 #   else /* RAND_MAX != 32767 */
3031 #    if RAND_MAX == 2147483647
3032 #     define random() (rand () >> 16)
3033 #    else /* RAND_MAX != 2147483647 */
3034 #     ifdef USG
3035 #      define random rand
3036 #     else
3037 #      define random() (rand () >> 16)
3038 #     endif /* !USG */
3039 #    endif /* RAND_MAX != 2147483647 */
3040 #   endif /* RAND_MAX != 32767 */
3041 #  endif /* !HAVE_LRAND48 */
3042 # endif /* !HAVE_RANDOM */
3043 #endif /* !RAND_BITS */
3044
3045 void
3046 seed_random (arg)
3047      long arg;
3048 {
3049 #ifdef HAVE_RANDOM
3050   srandom ((unsigned int)arg);
3051 #else
3052 # ifdef HAVE_LRAND48
3053   srand48 (arg);
3054 # else
3055   srand ((unsigned int)arg);
3056 # endif
3057 #endif
3058 }
3059
3060 /*
3061  * Build a full Emacs-sized word out of whatever we've got.
3062  * This suffices even for a 64-bit architecture with a 15-bit rand.
3063  */
3064 long
3065 get_random ()
3066 {
3067   long val = random ();
3068 #if VALBITS > RAND_BITS
3069   val = (val << RAND_BITS) ^ random ();
3070 #if VALBITS > 2*RAND_BITS
3071   val = (val << RAND_BITS) ^ random ();
3072 #if VALBITS > 3*RAND_BITS
3073   val = (val << RAND_BITS) ^ random ();
3074 #if VALBITS > 4*RAND_BITS
3075   val = (val << RAND_BITS) ^ random ();
3076 #endif /* need at least 5 */
3077 #endif /* need at least 4 */
3078 #endif /* need at least 3 */
3079 #endif /* need at least 2 */
3080   return val & ((1L << VALBITS) - 1);
3081 }
3082 \f
3083 #ifdef WRONG_NAME_INSQUE
3084
3085 insque (q,p)
3086      caddr_t q,p;
3087 {
3088   _insque (q,p);
3089 }
3090
3091 #endif
3092 \f
3093 #ifdef VMS
3094
3095 #ifdef getenv
3096 /* If any place else asks for the TERM variable,
3097    allow it to be overridden with the EMACS_TERM variable
3098    before attempting to translate the logical name TERM.  As a last
3099    resort, ask for VAX C's special idea of the TERM variable.  */
3100 #undef getenv
3101 char *
3102 sys_getenv (name)
3103      char *name;
3104 {
3105   register char *val;
3106   static char buf[256];
3107   static struct dsc$descriptor_s equiv
3108     = {sizeof (buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, buf};
3109   static struct dsc$descriptor_s d_name
3110     = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0};
3111   short eqlen;
3112
3113   if (!strcmp (name, "TERM"))
3114     {
3115       val = (char *) getenv ("EMACS_TERM");
3116       if (val)
3117         return val;
3118     }
3119
3120   d_name.dsc$w_length = strlen (name);
3121   d_name.dsc$a_pointer = name;
3122   if (LIB$SYS_TRNLOG (&d_name, &eqlen, &equiv) == 1)
3123     {
3124       char *str = (char *) xmalloc (eqlen + 1);
3125       bcopy (buf, str, eqlen);
3126       str[eqlen] = '\0';
3127       /* This is a storage leak, but a pain to fix.  With luck,
3128          no one will ever notice.  */
3129       return str;
3130     }
3131   return (char *) getenv (name);
3132 }
3133 #endif /* getenv */
3134
3135 #ifdef abort
3136 /* Since VMS doesn't believe in core dumps, the only way to debug this beast is
3137    to force a call on the debugger from within the image. */
3138 #undef abort
3139 sys_abort ()
3140 {
3141   reset_sys_modes ();
3142   LIB$SIGNAL (SS$_DEBUG);
3143 }
3144 #endif /* abort */
3145 #endif /* VMS */
3146 \f
3147 #ifdef VMS
3148 #ifdef LINK_CRTL_SHARE
3149 #ifdef SHARABLE_LIB_BUG
3150 /* Variables declared noshare and initialized in sharable libraries
3151    cannot be shared.  The VMS linker incorrectly forces you to use a private
3152    version which is uninitialized... If not for this "feature", we
3153    could use the C library definition of sys_nerr and sys_errlist. */
3154 int sys_nerr = 35;
3155 char *sys_errlist[] =
3156   {
3157     "error 0",
3158     "not owner",
3159     "no such file or directory",
3160     "no such process",
3161     "interrupted system call",
3162     "i/o error",
3163     "no such device or address",
3164     "argument list too long",
3165     "exec format error",
3166     "bad file number",
3167     "no child process",
3168     "no more processes",
3169     "not enough memory",
3170     "permission denied",
3171     "bad address",
3172     "block device required",
3173     "mount devices busy",
3174     "file exists",
3175     "cross-device link",
3176     "no such device",
3177     "not a directory",
3178     "is a directory",
3179     "invalid argument",
3180     "file table overflow",
3181     "too many open files",
3182     "not a typewriter",
3183     "text file busy",
3184     "file too big",
3185     "no space left on device",
3186     "illegal seek",
3187     "read-only file system",
3188     "too many links",
3189     "broken pipe",
3190     "math argument",
3191     "result too large",
3192     "I/O stream empty",
3193     "vax/vms specific error code nontranslatable error"
3194   };
3195 #endif /* SHARABLE_LIB_BUG */
3196 #endif /* LINK_CRTL_SHARE */
3197 #endif /* VMS */
3198
3199 #ifndef HAVE_STRERROR
3200 #ifndef WINDOWSNT
3201 char *
3202 strerror (errnum)
3203      int errnum;
3204 {
3205   extern char *sys_errlist[];
3206   extern int sys_nerr;
3207
3208   if (errnum >= 0 && errnum < sys_nerr)
3209     return sys_errlist[errnum];
3210   return (char *) "Unknown error";
3211 }
3212 #endif /* not WINDOWSNT */
3213 #endif /* ! HAVE_STRERROR */
3214 \f
3215 int
3216 emacs_open (path, oflag, mode)
3217      char *path;
3218      int oflag, mode;
3219 {
3220   register int rtnval;
3221
3222 #ifdef BSD4_1
3223   if (oflag & O_CREAT)
3224     return creat (path, mode);
3225 #endif
3226
3227   while ((rtnval = open (path, oflag, mode)) == -1
3228          && (errno == EINTR));
3229   return (rtnval);
3230 }
3231
3232 int
3233 emacs_close (fd)
3234      int fd;
3235 {
3236   int did_retry = 0;
3237   register int rtnval;
3238
3239   while ((rtnval = close (fd)) == -1
3240          && (errno == EINTR))
3241     did_retry = 1;
3242
3243   /* If close is interrupted SunOS 4.1 may or may not have closed the
3244      file descriptor.  If it did the second close will fail with
3245      errno = EBADF.  That means we have succeeded.  */
3246   if (rtnval == -1 && did_retry && errno == EBADF)
3247     return 0;
3248
3249   return rtnval;
3250 }
3251
3252 int
3253 emacs_read (fildes, buf, nbyte)
3254      int fildes;
3255      char *buf;
3256      unsigned int nbyte;
3257 {
3258   register int rtnval;
3259
3260   while ((rtnval = read (fildes, buf, nbyte)) == -1
3261          && (errno == EINTR));
3262   return (rtnval);
3263 }
3264
3265 int
3266 emacs_write (fildes, buf, nbyte)
3267      int fildes;
3268      char *buf;
3269      unsigned int nbyte;
3270 {
3271   register int rtnval, bytes_written;
3272
3273   bytes_written = 0;
3274
3275   while (nbyte > 0)
3276     {
3277       rtnval = write (fildes, buf, nbyte);
3278
3279       if (rtnval == -1)
3280         {
3281           if (errno == EINTR)
3282             continue;
3283           else
3284             return (bytes_written ? bytes_written : -1);
3285         }
3286
3287       buf += rtnval;
3288       nbyte -= rtnval;
3289       bytes_written += rtnval;
3290     }
3291   return (bytes_written);
3292 }
3293 \f
3294 #ifndef HAVE_VFORK
3295 #ifndef WINDOWSNT
3296 /*
3297  *      Substitute fork for vfork on USG flavors.
3298  */
3299
3300 VFORK_RETURN_TYPE
3301 vfork ()
3302 {
3303   return (fork ());
3304 }
3305 #endif /* not WINDOWSNT */
3306 #endif /* not HAVE_VFORK */
3307 \f
3308 #ifdef USG
3309 /*
3310  *      All of the following are for USG.
3311  *
3312  *      On USG systems the system calls are INTERRUPTIBLE by signals
3313  *      that the user program has elected to catch.  Thus the system call
3314  *      must be retried in these cases.  To handle this without massive
3315  *      changes in the source code, we remap the standard system call names
3316  *      to names for our own functions in sysdep.c that do the system call
3317  *      with retries.  Actually, for portability reasons, it is good
3318  *      programming practice, as this example shows, to limit all actual
3319  *      system calls to a single occurrence in the source.  Sure, this
3320  *      adds an extra level of function call overhead but it is almost
3321  *      always negligible.   Fred Fish, Unisoft Systems Inc.
3322  */
3323
3324 /*
3325  *      Warning, this function may not duplicate 4.2 action properly
3326  *      under error conditions.
3327  */
3328
3329 #ifndef MAXPATHLEN
3330 /* In 4.1, param.h fails to define this.  */
3331 #define MAXPATHLEN 1024
3332 #endif
3333
3334 #ifndef HAVE_GETWD
3335
3336 char *
3337 getwd (pathname)
3338      char *pathname;
3339 {
3340   char *npath, *spath;
3341   extern char *getcwd ();
3342
3343   BLOCK_INPUT;                  /* getcwd uses malloc */
3344   spath = npath = getcwd ((char *) 0, MAXPATHLEN);
3345   if (spath == 0)
3346     return spath;
3347   /* On Altos 3068, getcwd can return @hostname/dir, so discard
3348      up to first slash.  Should be harmless on other systems.  */
3349   while (*npath && *npath != '/')
3350     npath++;
3351   strcpy (pathname, npath);
3352   free (spath);                 /* getcwd uses malloc */
3353   UNBLOCK_INPUT;
3354   return pathname;
3355 }
3356
3357 #endif /* HAVE_GETWD */
3358
3359 /*
3360  *      Emulate rename using unlink/link.  Note that this is
3361  *      only partially correct.  Also, doesn't enforce restriction
3362  *      that files be of same type (regular->regular, dir->dir, etc).
3363  */
3364
3365 #ifndef HAVE_RENAME
3366
3367 rename (from, to)
3368      const char *from;
3369      const char *to;
3370 {
3371   if (access (from, 0) == 0)
3372     {
3373       unlink (to);
3374       if (link (from, to) == 0)
3375         if (unlink (from) == 0)
3376           return (0);
3377     }
3378   return (-1);
3379 }
3380
3381 #endif
3382
3383
3384 #ifdef HPUX
3385 #ifndef HAVE_PERROR
3386
3387 /* HPUX curses library references perror, but as far as we know
3388    it won't be called.  Anyway this definition will do for now.  */
3389
3390 perror ()
3391 {
3392 }
3393
3394 #endif /* not HAVE_PERROR */
3395 #endif /* HPUX */
3396
3397 #ifndef HAVE_DUP2
3398
3399 /*
3400  *      Emulate BSD dup2.  First close newd if it already exists.
3401  *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
3402  *      until we are, then close the unsuccessful ones.
3403  */
3404
3405 dup2 (oldd, newd)
3406      int oldd;
3407      int newd;
3408 {
3409   register int fd, ret;
3410
3411   emacs_close (newd);
3412
3413 #ifdef F_DUPFD
3414   return fcntl (oldd, F_DUPFD, newd);
3415 #else
3416   fd = dup (old);
3417   if (fd == -1)
3418     return -1;
3419   if (fd == new)
3420     return new;
3421   ret = dup2 (old,new);
3422   emacs_close (fd);
3423   return ret;
3424 #endif
3425 }
3426
3427 #endif /* not HAVE_DUP2 */
3428
3429 /*
3430  *      Gettimeofday.  Simulate as much as possible.  Only accurate
3431  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
3432  *      Only needed when subprocesses are defined.
3433  */
3434
3435 #ifdef subprocesses
3436 #ifndef VMS
3437 #ifndef HAVE_GETTIMEOFDAY
3438 #ifdef HAVE_TIMEVAL
3439
3440 /* ARGSUSED */
3441 int
3442 gettimeofday (tp, tzp)
3443      struct timeval *tp;
3444      struct timezone *tzp;
3445 {
3446   extern long time ();
3447
3448   tp->tv_sec = time ((long *)0);
3449   tp->tv_usec = 0;
3450   if (tzp != 0)
3451     tzp->tz_minuteswest = -1;
3452   return 0;
3453 }
3454
3455 #endif
3456 #endif
3457 #endif
3458 #endif /* subprocess && !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL && !VMS */
3459
3460 /*
3461  *      This function will go away as soon as all the stubs fixed. (fnf)
3462  */
3463
3464 void
3465 croak (badfunc)
3466      char *badfunc;
3467 {
3468   printf ("%s not yet implemented\r\n", badfunc);
3469   reset_sys_modes ();
3470   exit (1);
3471 }
3472
3473 #endif /* USG */
3474 \f
3475 /* Directory routines for systems that don't have them. */
3476
3477 #ifdef SYSV_SYSTEM_DIR
3478
3479 #include <dirent.h>
3480
3481 #if defined (BROKEN_CLOSEDIR) || !defined (HAVE_CLOSEDIR)
3482
3483 int
3484 closedir (dirp)
3485      register DIR *dirp;              /* stream from opendir */
3486 {
3487   int rtnval;
3488
3489   rtnval = emacs_close (dirp->dd_fd);
3490
3491   /* Some systems (like Solaris) allocate the buffer and the DIR all
3492      in one block.  Why in the world are we freeing this ourselves
3493      anyway?  */
3494 #if ! (defined (sun) && defined (USG5_4))
3495   xfree ((char *) dirp->dd_buf); /* directory block defined in <dirent.h> */
3496 #endif
3497   xfree ((char *) dirp);
3498
3499   return rtnval;
3500 }
3501 #endif /* BROKEN_CLOSEDIR or not HAVE_CLOSEDIR */
3502 #endif /* SYSV_SYSTEM_DIR */
3503
3504 #ifdef NONSYSTEM_DIR_LIBRARY
3505
3506 DIR *
3507 opendir (filename)
3508      char *filename;    /* name of directory */
3509 {
3510   register DIR *dirp;           /* -> malloc'ed storage */
3511   register int fd;              /* file descriptor for read */
3512   struct stat sbuf;             /* result of fstat */
3513
3514   fd = emacs_open (filename, O_RDONLY, 0);
3515   if (fd < 0)
3516     return 0;
3517
3518   BLOCK_INPUT;
3519   if (fstat (fd, &sbuf) < 0
3520       || (sbuf.st_mode & S_IFMT) != S_IFDIR
3521       || (dirp = (DIR *) malloc (sizeof (DIR))) == 0)
3522     {
3523       emacs_close (fd);
3524       UNBLOCK_INPUT;
3525       return 0;         /* bad luck today */
3526     }
3527   UNBLOCK_INPUT;
3528
3529   dirp->dd_fd = fd;
3530   dirp->dd_loc = dirp->dd_size = 0;     /* refill needed */
3531
3532   return dirp;
3533 }
3534
3535 void
3536 closedir (dirp)
3537      register DIR *dirp;                /* stream from opendir */
3538 {
3539   emacs_close (dirp->dd_fd);
3540   xfree ((char *) dirp);
3541 }
3542
3543
3544 #ifndef VMS
3545 #define DIRSIZ  14
3546 struct olddir
3547   {
3548     ino_t od_ino;               /* inode */
3549     char od_name[DIRSIZ];       /* filename */
3550   };
3551 #endif /* not VMS */
3552
3553 struct direct dir_static;       /* simulated directory contents */
3554
3555 /* ARGUSED */
3556 struct direct *
3557 readdir (dirp)
3558      register DIR *dirp;        /* stream from opendir */
3559 {
3560 #ifndef VMS
3561   register struct olddir *dp;   /* -> directory data */
3562 #else /* VMS */
3563   register struct dir$_name *dp; /* -> directory data */
3564   register struct dir$_version *dv; /* -> version data */
3565 #endif /* VMS */
3566
3567   for (; ;)
3568     {
3569       if (dirp->dd_loc >= dirp->dd_size)
3570         dirp->dd_loc = dirp->dd_size = 0;
3571
3572       if (dirp->dd_size == 0    /* refill buffer */
3573           && (dirp->dd_size = emacs_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3574         return 0;
3575
3576 #ifndef VMS
3577       dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc];
3578       dirp->dd_loc += sizeof (struct olddir);
3579
3580       if (dp->od_ino != 0)      /* not deleted entry */
3581         {
3582           dir_static.d_ino = dp->od_ino;
3583           strncpy (dir_static.d_name, dp->od_name, DIRSIZ);
3584           dir_static.d_name[DIRSIZ] = '\0';
3585           dir_static.d_namlen = strlen (dir_static.d_name);
3586           dir_static.d_reclen = sizeof (struct direct)
3587             - MAXNAMLEN + 3
3588               + dir_static.d_namlen - dir_static.d_namlen % 4;
3589           return &dir_static;   /* -> simulated structure */
3590         }
3591 #else /* VMS */
3592       dp = (struct dir$_name *) dirp->dd_buf;
3593       if (dirp->dd_loc == 0)
3594         dirp->dd_loc = (dp->dir$b_namecount&1) ? dp->dir$b_namecount + 1
3595           : dp->dir$b_namecount;
3596       dv = (struct dir$_version *)&dp->dir$t_name[dirp->dd_loc];
3597       dir_static.d_ino = dv->dir$w_fid_num;
3598       dir_static.d_namlen = dp->dir$b_namecount;
3599       dir_static.d_reclen = sizeof (struct direct)
3600         - MAXNAMLEN + 3
3601           + dir_static.d_namlen - dir_static.d_namlen % 4;
3602       strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3603       dir_static.d_name[dir_static.d_namlen] = '\0';
3604       dirp->dd_loc = dirp->dd_size; /* only one record at a time */
3605       return &dir_static;
3606 #endif /* VMS */
3607     }
3608 }
3609
3610 #ifdef VMS
3611 /* readdirver is just like readdir except it returns all versions of a file
3612    as separate entries.  */
3613
3614 /* ARGUSED */
3615 struct direct *
3616 readdirver (dirp)
3617      register DIR *dirp;        /* stream from opendir */
3618 {
3619   register struct dir$_name *dp; /* -> directory data */
3620   register struct dir$_version *dv; /* -> version data */
3621
3622   if (dirp->dd_loc >= dirp->dd_size - sizeof (struct dir$_name))
3623     dirp->dd_loc = dirp->dd_size = 0;
3624
3625   if (dirp->dd_size == 0        /* refill buffer */
3626       && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0)
3627     return 0;
3628
3629   dp = (struct dir$_name *) dirp->dd_buf;
3630   if (dirp->dd_loc == 0)
3631     dirp->dd_loc = (dp->dir$b_namecount & 1) ? dp->dir$b_namecount + 1
3632                    : dp->dir$b_namecount;
3633   dv = (struct dir$_version *) &dp->dir$t_name[dirp->dd_loc];
3634   strncpy (dir_static.d_name, dp->dir$t_name, dp->dir$b_namecount);
3635   sprintf (&dir_static.d_name[dp->dir$b_namecount], ";%d", dv->dir$w_version);
3636   dir_static.d_namlen = strlen (dir_static.d_name);
3637   dir_static.d_ino = dv->dir$w_fid_num;
3638   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3
3639                         + dir_static.d_namlen - dir_static.d_namlen % 4;
3640   dirp->dd_loc = ((char *) (++dv) - dp->dir$t_name);
3641   return &dir_static;
3642 }
3643
3644 #endif /* VMS */
3645
3646 #endif /* NONSYSTEM_DIR_LIBRARY */
3647
3648 \f
3649 int
3650 set_file_times (filename, atime, mtime)
3651      char *filename;
3652      EMACS_TIME atime, mtime;
3653 {
3654 #ifdef HAVE_UTIMES
3655   struct timeval tv[2];
3656   tv[0] = atime;
3657   tv[1] = mtime;
3658   return utimes (filename, tv);
3659 #else /* not HAVE_UTIMES */
3660   struct utimbuf utb;
3661   utb.actime = EMACS_SECS (atime);
3662   utb.modtime = EMACS_SECS (mtime);
3663   return utime (filename, &utb);
3664 #endif /* not HAVE_UTIMES */
3665 }
3666 \f
3667 /* mkdir and rmdir functions, for systems which don't have them.  */
3668
3669 #ifndef HAVE_MKDIR
3670 /*
3671  * Written by Robert Rother, Mariah Corporation, August 1985.
3672  *
3673  * If you want it, it's yours.  All I ask in return is that if you
3674  * figure out how to do this in a Bourne Shell script you send me
3675  * a copy.
3676  *                                      sdcsvax!rmr or rmr@uscd
3677  *
3678  * Severely hacked over by John Gilmore to make a 4.2BSD compatible
3679  * subroutine.  11Mar86; hoptoad!gnu
3680  *
3681  * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
3682  * subroutine didn't return EEXIST.  It does now.
3683  */
3684
3685 /*
3686  * Make a directory.
3687  */
3688 #ifdef MKDIR_PROTOTYPE
3689 MKDIR_PROTOTYPE
3690 #else
3691 int
3692 mkdir (dpath, dmode)
3693      char *dpath;
3694      int dmode;
3695 #endif
3696 {
3697   int cpid, status, fd;
3698   struct stat statbuf;
3699
3700   if (stat (dpath, &statbuf) == 0)
3701     {
3702       errno = EEXIST;           /* Stat worked, so it already exists */
3703       return -1;
3704     }
3705
3706   /* If stat fails for a reason other than non-existence, return error */
3707   if (errno != ENOENT)
3708     return -1;
3709
3710   synch_process_alive = 1;
3711   switch (cpid = fork ())
3712     {
3713
3714     case -1:                    /* Error in fork */
3715       return (-1);              /* Errno is set already */
3716
3717     case 0:                     /* Child process */
3718       /*
3719                  * Cheap hack to set mode of new directory.  Since this
3720                  * child process is going away anyway, we zap its umask.
3721                  * FIXME, this won't suffice to set SUID, SGID, etc. on this
3722                  * directory.  Does anybody care?
3723                  */
3724       status = umask (0);       /* Get current umask */
3725       status = umask (status | (0777 & ~dmode));        /* Set for mkdir */
3726       fd = emacs_open ("/dev/null", O_RDWR, 0);
3727       if (fd >= 0)
3728         {
3729           dup2 (fd, 0);
3730           dup2 (fd, 1);
3731           dup2 (fd, 2);
3732         }
3733       execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
3734       _exit (-1);               /* Can't exec /bin/mkdir */
3735
3736     default:                    /* Parent process */
3737       wait_for_termination (cpid);
3738     }
3739
3740   if (synch_process_death != 0 || synch_process_retcode != 0)
3741     {
3742       errno = EIO;              /* We don't know why, but */
3743       return -1;                /* /bin/mkdir failed */
3744     }
3745
3746   return 0;
3747 }
3748 #endif /* not HAVE_MKDIR */
3749
3750 #ifndef HAVE_RMDIR
3751 int
3752 rmdir (dpath)
3753      char *dpath;
3754 {
3755   int cpid, status, fd;
3756   struct stat statbuf;
3757
3758   if (stat (dpath, &statbuf) != 0)
3759     {
3760       /* Stat just set errno.  We don't have to */
3761       return -1;
3762     }
3763
3764   synch_process_alive = 1;
3765   switch (cpid = fork ())
3766     {
3767
3768     case -1:                    /* Error in fork */
3769       return (-1);              /* Errno is set already */
3770
3771     case 0:                     /* Child process */
3772       fd = emacs_open ("/dev/null", O_RDWR, 0);
3773       if (fd >= 0)
3774         {
3775           dup2 (fd, 0);
3776           dup2 (fd, 1);
3777           dup2 (fd, 2);
3778         }
3779       execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
3780       _exit (-1);               /* Can't exec /bin/rmdir */
3781
3782     default:                    /* Parent process */
3783       wait_for_termination (cpid);
3784     }
3785
3786   if (synch_process_death != 0 || synch_process_retcode != 0)
3787     {
3788       errno = EIO;              /* We don't know why, but */
3789       return -1;                /* /bin/rmdir failed */
3790     }
3791
3792   return 0;
3793 }
3794 #endif /* !HAVE_RMDIR */
3795
3796
3797 \f
3798 /* Functions for VMS */
3799 #ifdef VMS
3800 #include "vms-pwd.h"
3801 #include <acldef.h>
3802 #include <chpdef.h>
3803 #include <jpidef.h>
3804
3805 /* Return as a string the VMS error string pertaining to STATUS.
3806    Reuses the same static buffer each time it is called.  */
3807
3808 char *
3809 vmserrstr (status)
3810      int status;                /* VMS status code */
3811 {
3812   int bufadr[2];
3813   short len;
3814   static char buf[257];
3815
3816   bufadr[0] = sizeof buf - 1;
3817   bufadr[1] = (int) buf;
3818   if (! (SYS$GETMSG (status, &len, bufadr, 0x1, 0) & 1))
3819     return "untranslatable VMS error status";
3820   buf[len] = '\0';
3821   return buf;
3822 }
3823
3824 #ifdef access
3825 #undef access
3826
3827 /* The following is necessary because 'access' emulation by VMS C (2.0) does
3828  * not work correctly.  (It also doesn't work well in version 2.3.)
3829  */
3830
3831 #ifdef VMS4_4
3832
3833 #define DESCRIPTOR(name,string) struct dsc$descriptor_s name = \
3834         { strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string }
3835
3836 typedef union {
3837     struct {
3838         unsigned short s_buflen;
3839         unsigned short s_code;
3840         char *s_bufadr;
3841         unsigned short *s_retlenadr;
3842     } s;
3843     int end;
3844 } item;
3845 #define buflen s.s_buflen
3846 #define code s.s_code
3847 #define bufadr s.s_bufadr
3848 #define retlenadr s.s_retlenadr
3849
3850 #define R_OK 4  /* test for read permission */
3851 #define W_OK 2  /* test for write permission */
3852 #define X_OK 1  /* test for execute (search) permission */
3853 #define F_OK 0  /* test for presence of file */
3854
3855 int
3856 sys_access (path, mode)
3857      char *path;
3858      int mode;
3859 {
3860   static char *user = NULL;
3861   char dir_fn[512];
3862
3863   /* translate possible directory spec into .DIR file name, so brain-dead
3864    * access can treat the directory like a file.  */
3865   if (directory_file_name (path, dir_fn))
3866     path = dir_fn;
3867
3868   if (mode == F_OK)
3869     return access (path, mode);
3870   if (user == NULL && (user = (char *) getenv ("USER")) == NULL)
3871     return -1;
3872   {
3873     int stat;
3874     int flags;
3875     int acces;
3876     unsigned short int dummy;
3877     item itemlst[3];
3878     static int constant = ACL$C_FILE;
3879     DESCRIPTOR (path_desc, path);
3880     DESCRIPTOR (user_desc, user);
3881
3882     flags = 0;
3883     acces = 0;
3884     if ((mode & X_OK) && ((stat = access (path, mode)) < 0 || mode == X_OK))
3885       return stat;
3886     if (mode & R_OK)
3887       acces |= CHP$M_READ;
3888     if (mode & W_OK)
3889       acces |= CHP$M_WRITE;
3890     itemlst[0].buflen = sizeof (int);
3891     itemlst[0].code = CHP$_FLAGS;
3892     itemlst[0].bufadr = (char *) &flags;
3893     itemlst[0].retlenadr = &dummy;
3894     itemlst[1].buflen = sizeof (int);
3895     itemlst[1].code = CHP$_ACCESS;
3896     itemlst[1].bufadr = (char *) &acces;
3897     itemlst[1].retlenadr = &dummy;
3898     itemlst[2].end = CHP$_END;
3899     stat = SYS$CHECK_ACCESS (&constant, &path_desc, &user_desc, itemlst);
3900     return stat == SS$_NORMAL ? 0 : -1;
3901   }
3902 }
3903
3904 #else /* not VMS4_4 */
3905
3906 #include <prvdef.h>
3907 #define ACE$M_WRITE     2
3908 #define ACE$C_KEYID     1
3909
3910 static unsigned short memid, grpid;
3911 static unsigned int uic;
3912
3913 /* Called from init_sys_modes, so it happens not very often
3914    but at least each time Emacs is loaded.  */
3915 void
3916 sys_access_reinit ()
3917 {
3918   uic = 0;
3919 }
3920
3921 int
3922 sys_access (filename, type)
3923      char * filename;
3924      int type;
3925 {
3926   struct FAB fab;
3927   struct XABPRO xab;
3928   int status, size, i, typecode, acl_controlled;
3929   unsigned int *aclptr, *aclend, aclbuf[60];
3930   union prvdef prvmask;
3931
3932   /* Get UIC and GRP values for protection checking.  */
3933   if (uic == 0)
3934     {
3935       status = LIB$GETJPI (&JPI$_UIC, 0, 0, &uic, 0, 0);
3936       if (! (status & 1))
3937         return -1;
3938       memid = uic & 0xFFFF;
3939       grpid = uic >> 16;
3940     }
3941
3942   if (type != 2)                /* not checking write access */
3943     return access (filename, type);
3944
3945   /* Check write protection. */
3946
3947 #define CHECKPRIV(bit)    (prvmask.bit)
3948 #define WRITABLE(field)  (! ((xab.xab$w_pro >> field) & XAB$M_NOWRITE))
3949
3950   /* Find privilege bits */
3951   status = SYS$SETPRV (0, 0, 0, prvmask);
3952   if (! (status & 1))
3953     error ("Unable to find privileges: %s", vmserrstr (status));
3954   if (CHECKPRIV (PRV$V_BYPASS))
3955     return 0;                   /* BYPASS enabled */
3956   fab = cc$rms_fab;
3957   fab.fab$b_fac = FAB$M_GET;
3958   fab.fab$l_fna = filename;
3959   fab.fab$b_fns = strlen (filename);
3960   fab.fab$l_xab = &xab;
3961   xab = cc$rms_xabpro;
3962   xab.xab$l_aclbuf = aclbuf;
3963   xab.xab$w_aclsiz = sizeof (aclbuf);
3964   status = SYS$OPEN (&fab, 0, 0);
3965   if (! (status & 1))
3966     return -1;
3967   SYS$CLOSE (&fab, 0, 0);
3968   /* Check system access */
3969   if (CHECKPRIV (PRV$V_SYSPRV) && WRITABLE (XAB$V_SYS))
3970     return 0;
3971   /* Check ACL entries, if any */
3972   acl_controlled = 0;
3973   if (xab.xab$w_acllen > 0)
3974     {
3975       aclptr = aclbuf;
3976       aclend = &aclbuf[xab.xab$w_acllen / 4];
3977       while (*aclptr && aclptr < aclend)
3978         {
3979           size = (*aclptr & 0xff) / 4;
3980           typecode = (*aclptr >> 8) & 0xff;
3981           if (typecode == ACE$C_KEYID)
3982             for (i = size - 1; i > 1; i--)
3983               if (aclptr[i] == uic)
3984                 {
3985                   acl_controlled = 1;
3986                   if (aclptr[1] & ACE$M_WRITE)
3987                     return 0;   /* Write access through ACL */
3988                 }
3989           aclptr = &aclptr[size];
3990         }
3991       if (acl_controlled)       /* ACL specified, prohibits write access */
3992         return -1;
3993     }
3994   /* No ACL entries specified, check normal protection */
3995   if (WRITABLE (XAB$V_WLD))     /* World writable */
3996     return 0;
3997   if (WRITABLE (XAB$V_GRP) &&
3998       (unsigned short) (xab.xab$l_uic >> 16) == grpid)
3999     return 0;                   /* Group writable */
4000   if (WRITABLE (XAB$V_OWN) &&
4001       (xab.xab$l_uic & 0xFFFF) == memid)
4002     return 0;                   /* Owner writable */
4003
4004   return -1;    /* Not writable */
4005 }
4006 #endif /* not VMS4_4 */
4007 #endif /* access */
4008
4009 static char vtbuf[NAM$C_MAXRSS+1];
4010
4011 /* translate a vms file spec to a unix path */
4012 char *
4013 sys_translate_vms (vfile)
4014      char * vfile;
4015 {
4016   char * p;
4017   char * targ;
4018
4019   if (!vfile)
4020     return 0;
4021
4022   targ = vtbuf;
4023
4024   /* leading device or logical name is a root directory */
4025   if (p = strchr (vfile, ':'))
4026     {
4027       *targ++ = '/';
4028       while (vfile < p)
4029         *targ++ = *vfile++;
4030       vfile++;
4031       *targ++ = '/';
4032     }
4033   p = vfile;
4034   if (*p == '[' || *p == '<')
4035     {
4036       while (*++vfile != *p + 2)
4037         switch (*vfile)
4038           {
4039           case '.':
4040             if (vfile[-1] == *p)
4041               *targ++ = '.';
4042             *targ++ = '/';
4043             break;
4044
4045           case '-':
4046             *targ++ = '.';
4047             *targ++ = '.';
4048             break;
4049
4050           default:
4051             *targ++ = *vfile;
4052             break;
4053           }
4054       vfile++;
4055       *targ++ = '/';
4056     }
4057   while (*vfile)
4058     *targ++ = *vfile++;
4059
4060   return vtbuf;
4061 }
4062
4063 static char utbuf[NAM$C_MAXRSS+1];
4064
4065 /* translate a unix path to a VMS file spec */
4066 char *
4067 sys_translate_unix (ufile)
4068      char * ufile;
4069 {
4070   int slash_seen = 0;
4071   char *p;
4072   char * targ;
4073
4074   if (!ufile)
4075     return 0;
4076
4077   targ = utbuf;
4078
4079   if (*ufile == '/')
4080     {
4081       ufile++;
4082     }
4083
4084   while (*ufile)
4085     {
4086       switch (*ufile)
4087         {
4088         case '/':
4089           if (slash_seen)
4090             if (index (&ufile[1], '/'))
4091               *targ++ = '.';
4092             else
4093               *targ++ = ']';
4094           else
4095             {
4096               *targ++ = ':';
4097               if (index (&ufile[1], '/'))
4098                 *targ++ = '[';
4099               slash_seen = 1;
4100             }
4101           break;
4102
4103         case '.':
4104           if (strncmp (ufile, "./", 2) == 0)
4105             {
4106               if (!slash_seen)
4107                 {
4108                   *targ++ = '[';
4109                   slash_seen = 1;
4110                 }
4111               ufile++;          /* skip the dot */
4112               if (index (&ufile[1], '/'))
4113                 *targ++ = '.';
4114               else
4115                 *targ++ = ']';
4116             }
4117           else if (strncmp (ufile, "../", 3) == 0)
4118             {
4119               if (!slash_seen)
4120                 {
4121                   *targ++ = '[';
4122                   slash_seen = 1;
4123                 }
4124               *targ++ = '-';
4125               ufile += 2;       /* skip the dots */
4126               if (index (&ufile[1], '/'))
4127                 *targ++ = '.';
4128               else
4129                 *targ++ = ']';
4130             }
4131           else
4132             *targ++ = *ufile;
4133           break;
4134
4135         default:
4136           *targ++ = *ufile;
4137           break;
4138         }
4139       ufile++;
4140     }
4141   *targ = '\0';
4142
4143   return utbuf;
4144 }
4145
4146 char *
4147 getwd (pathname)
4148      char *pathname;
4149 {
4150   char *ptr, *val;
4151   extern char *getcwd ();
4152
4153 #define MAXPATHLEN 1024
4154
4155   ptr = xmalloc (MAXPATHLEN);
4156   val = getcwd (ptr, MAXPATHLEN);
4157   if (val == 0)
4158     {
4159       xfree (ptr);
4160       return val;
4161     }
4162   strcpy (pathname, ptr);
4163   xfree (ptr);
4164
4165  return pathname;
4166 }
4167
4168 int
4169 getppid ()
4170 {
4171   long item_code = JPI$_OWNER;
4172   unsigned long parent_id;
4173   int status;
4174
4175   if (((status = LIB$GETJPI (&item_code, 0, 0, &parent_id)) & 1) == 0)
4176     {
4177       errno = EVMSERR;
4178       vaxc$errno = status;
4179       return -1;
4180     }
4181   return parent_id;
4182 }
4183
4184 #undef getuid
4185 unsigned
4186 sys_getuid ()
4187 {
4188   return (getgid () << 16) | getuid ();
4189 }
4190
4191 #undef read
4192 int
4193 sys_read (fildes, buf, nbyte)
4194      int fildes;
4195      char *buf;
4196      unsigned int nbyte;
4197 {
4198   return read (fildes, buf, (nbyte < MAXIOSIZE ? nbyte : MAXIOSIZE));
4199 }
4200
4201 #if 0
4202 int
4203 sys_write (fildes, buf, nbyte)
4204      int fildes;
4205      char *buf;
4206      unsigned int nbyte;
4207 {
4208   register int nwrote, rtnval = 0;
4209
4210   while (nbyte > MAXIOSIZE && (nwrote = write (fildes, buf, MAXIOSIZE)) > 0) {
4211     nbyte -= nwrote;
4212     buf += nwrote;
4213     rtnval += nwrote;
4214   }
4215   if (nwrote < 0)
4216     return rtnval ? rtnval : -1;
4217   if ((nwrote = write (fildes, buf, nbyte)) < 0)
4218     return rtnval ? rtnval : -1;
4219   return (rtnval + nwrote);
4220 }
4221 #endif /* 0 */
4222
4223 /*
4224  *      VAX/VMS VAX C RTL really loses. It insists that records
4225  *      end with a newline (carriage return) character, and if they
4226  *      don't it adds one (nice of it isn't it!)
4227  *
4228  *      Thus we do this stupidity below.
4229  */
4230
4231 #undef write
4232 int
4233 sys_write (fildes, buf, nbytes)
4234      int fildes;
4235      char *buf;
4236      unsigned int nbytes;
4237 {
4238   register char *p;
4239   register char *e;
4240   int sum = 0;
4241   struct stat st;
4242
4243   fstat (fildes, &st);
4244   p = buf;
4245   while (nbytes > 0)
4246     {
4247       int len, retval;
4248
4249       /* Handle fixed-length files with carriage control.  */
4250       if (st.st_fab_rfm == FAB$C_FIX
4251           && ((st.st_fab_rat & (FAB$M_FTN | FAB$M_CR)) != 0))
4252         {
4253           len = st.st_fab_mrs;
4254           retval = write (fildes, p, min (len, nbytes));
4255           if (retval != len)
4256             return -1;
4257           retval++;     /* This skips the implied carriage control */
4258         }
4259       else
4260         {
4261           e =  p + min (MAXIOSIZE, nbytes) - 1;
4262           while (*e != '\n' && e > p) e--;
4263           if (p == e)           /* Ok.. so here we add a newline... sigh. */
4264             e = p + min (MAXIOSIZE, nbytes) - 1;
4265           len = e + 1 - p;
4266           retval = write (fildes, p, len);
4267           if (retval != len)
4268             return -1;
4269         }
4270       p += retval;
4271       sum += retval;
4272       nbytes -= retval;
4273     }
4274   return sum;
4275 }
4276
4277 /* Create file NEW copying its attributes from file OLD.  If
4278    OLD is 0 or does not exist, create based on the value of
4279    vms_stmlf_recfm. */
4280
4281 /* Protection value the file should ultimately have.
4282    Set by create_copy_attrs, and use by rename_sansversions.  */
4283 static unsigned short int fab_final_pro;
4284
4285 int
4286 creat_copy_attrs (old, new)
4287      char *old, *new;
4288 {
4289   struct FAB fab = cc$rms_fab;
4290   struct XABPRO xabpro;
4291   char aclbuf[256];     /* Choice of size is arbitrary.  See below. */
4292   extern int vms_stmlf_recfm;
4293
4294   if (old)
4295     {
4296       fab.fab$b_fac = FAB$M_GET;
4297       fab.fab$l_fna = old;
4298       fab.fab$b_fns = strlen (old);
4299       fab.fab$l_xab = (char *) &xabpro;
4300       xabpro = cc$rms_xabpro;
4301       xabpro.xab$l_aclbuf = aclbuf;
4302       xabpro.xab$w_aclsiz = sizeof aclbuf;
4303       /* Call $OPEN to fill in the fab & xabpro fields. */
4304       if (SYS$OPEN (&fab, 0, 0) & 1)
4305         {
4306           SYS$CLOSE (&fab, 0, 0);
4307           fab.fab$l_alq = 0;    /* zero the allocation quantity */
4308           if (xabpro.xab$w_acllen > 0)
4309             {
4310               if (xabpro.xab$w_acllen > sizeof aclbuf)
4311                 /* If the acl buffer was too short, redo open with longer one.
4312                    Wouldn't need to do this if there were some system imposed
4313                    limit on the size of an ACL, but I can't find any such. */
4314                 {
4315                   xabpro.xab$l_aclbuf = (char *) alloca (xabpro.xab$w_acllen);
4316                   xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
4317                   if (SYS$OPEN (&fab, 0, 0) & 1)
4318                     SYS$CLOSE (&fab, 0, 0);
4319                   else
4320                     old = 0;
4321                 }
4322             }
4323           else
4324             xabpro.xab$l_aclbuf = 0;
4325         }
4326       else
4327         old = 0;
4328     }
4329   fab.fab$l_fna = new;
4330   fab.fab$b_fns = strlen (new);
4331   if (!old)
4332     {
4333       fab.fab$l_xab = 0;
4334       fab.fab$b_rfm = vms_stmlf_recfm ? FAB$C_STMLF : FAB$C_VAR;
4335       fab.fab$b_rat = FAB$M_CR;
4336     }
4337
4338   /* Set the file protections such that we will be able to manipulate
4339      this file.  Once we are done writing and renaming it, we will set
4340      the protections back.  */
4341   if (old)
4342     fab_final_pro = xabpro.xab$w_pro;
4343   else
4344     SYS$SETDFPROT (0, &fab_final_pro);
4345   xabpro.xab$w_pro &= 0xff0f; /* set O:rewd for now. This is set back later. */
4346
4347   /* Create the new file with either default attrs or attrs copied
4348      from old file. */
4349   if (!(SYS$CREATE (&fab, 0, 0) & 1))
4350     return -1;
4351   SYS$CLOSE (&fab, 0, 0);
4352   /* As this is a "replacement" for creat, return a file descriptor
4353      opened for writing. */
4354   return open (new, O_WRONLY);
4355 }
4356
4357 #ifdef creat
4358 #undef creat
4359 #include <varargs.h>
4360 #ifdef __GNUC__
4361 #ifndef va_count
4362 #define va_count(X) ((X) = *(((int *) &(va_alist)) - 1))
4363 #endif
4364 #endif
4365
4366 int
4367 sys_creat (va_alist)
4368      va_dcl
4369 {
4370   va_list list_incrementer;
4371   char *name;
4372   int mode;
4373   int rfd;                      /* related file descriptor */
4374   int fd;                       /* Our new file descriptor */
4375   int count;
4376   struct stat st_buf;
4377   char rfm[12];
4378   char rat[15];
4379   char mrs[13];
4380   char fsz[13];
4381   extern int vms_stmlf_recfm;
4382
4383   va_count (count);
4384   va_start (list_incrementer);
4385   name = va_arg (list_incrementer, char *);
4386   mode = va_arg (list_incrementer, int);
4387   if (count > 2)
4388     rfd = va_arg (list_incrementer, int);
4389   va_end (list_incrementer);
4390   if (count > 2)
4391     {
4392       /* Use information from the related file descriptor to set record
4393          format of the newly created file. */
4394       fstat (rfd, &st_buf);
4395       switch (st_buf.st_fab_rfm)
4396         {
4397         case FAB$C_FIX:
4398           strcpy (rfm, "rfm = fix");
4399           sprintf (mrs, "mrs = %d", st_buf.st_fab_mrs);
4400           strcpy (rat, "rat = ");
4401           if (st_buf.st_fab_rat & FAB$M_CR)
4402             strcat (rat, "cr");
4403           else if (st_buf.st_fab_rat & FAB$M_FTN)
4404             strcat (rat, "ftn");
4405           else if (st_buf.st_fab_rat & FAB$M_PRN)
4406             strcat (rat, "prn");
4407           if (st_buf.st_fab_rat & FAB$M_BLK)
4408             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4409               strcat (rat, ", blk");
4410             else
4411               strcat (rat, "blk");
4412           return creat (name, 0, rfm, rat, mrs);
4413
4414         case FAB$C_VFC:
4415           strcpy (rfm, "rfm = vfc");
4416           sprintf (fsz, "fsz = %d", st_buf.st_fab_fsz);
4417           strcpy (rat, "rat = ");
4418           if (st_buf.st_fab_rat & FAB$M_CR)
4419             strcat (rat, "cr");
4420           else if (st_buf.st_fab_rat & FAB$M_FTN)
4421             strcat (rat, "ftn");
4422           else if (st_buf.st_fab_rat & FAB$M_PRN)
4423             strcat (rat, "prn");
4424           if (st_buf.st_fab_rat & FAB$M_BLK)
4425             if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4426               strcat (rat, ", blk");
4427             else
4428               strcat (rat, "blk");
4429           return creat (name, 0, rfm, rat, fsz);
4430
4431         case FAB$C_STM:
4432           strcpy (rfm, "rfm = stm");
4433           break;
4434
4435         case FAB$C_STMCR:
4436           strcpy (rfm, "rfm = stmcr");
4437           break;
4438
4439         case FAB$C_STMLF:
4440           strcpy (rfm, "rfm = stmlf");
4441           break;
4442
4443         case FAB$C_UDF:
4444           strcpy (rfm, "rfm = udf");
4445           break;
4446
4447         case FAB$C_VAR:
4448           strcpy (rfm, "rfm = var");
4449           break;
4450         }
4451       strcpy (rat, "rat = ");
4452       if (st_buf.st_fab_rat & FAB$M_CR)
4453         strcat (rat, "cr");
4454       else if (st_buf.st_fab_rat & FAB$M_FTN)
4455         strcat (rat, "ftn");
4456       else if (st_buf.st_fab_rat & FAB$M_PRN)
4457         strcat (rat, "prn");
4458       if (st_buf.st_fab_rat & FAB$M_BLK)
4459         if (st_buf.st_fab_rat & (FAB$M_CR|FAB$M_FTN|FAB$M_PRN))
4460           strcat (rat, ", blk");
4461         else
4462           strcat (rat, "blk");
4463     }
4464   else
4465     {
4466       strcpy (rfm, vms_stmlf_recfm ? "rfm = stmlf" : "rfm=var");
4467       strcpy (rat, "rat=cr");
4468     }
4469   /* Until the VAX C RTL fixes the many bugs with modes, always use
4470      mode 0 to get the user's default protection. */
4471   fd = creat (name, 0, rfm, rat);
4472   if (fd < 0 && errno == EEXIST)
4473     {
4474       if (unlink (name) < 0)
4475         report_file_error ("delete", build_string (name));
4476       fd = creat (name, 0, rfm, rat);
4477     }
4478   return fd;
4479 }
4480 #endif /* creat */
4481
4482 /* fwrite to stdout is S L O W.  Speed it up by using fputc...*/
4483 int
4484 sys_fwrite (ptr, size, num, fp)
4485      register char * ptr;
4486      FILE * fp;
4487 {
4488   register int tot = num * size;
4489
4490   while (tot--)
4491     fputc (*ptr++, fp);
4492   return num;
4493 }
4494
4495 /*
4496  * The VMS C library routine creat actually creates a new version of an
4497  * existing file rather than truncating the old version.  There are times
4498  * when this is not the desired behavior, for instance, when writing an
4499  * auto save file (you only want one version), or when you don't have
4500  * write permission in the directory containing the file (but the file
4501  * itself is writable).  Hence this routine, which is equivalent to
4502  * "close (creat (fn, 0));" on Unix if fn already exists.
4503  */
4504 int
4505 vms_truncate (fn)
4506      char *fn;
4507 {
4508   struct FAB xfab = cc$rms_fab;
4509   struct RAB xrab = cc$rms_rab;
4510   int status;
4511
4512   xfab.fab$l_fop = FAB$M_TEF;   /* free allocated but unused blocks on close */
4513   xfab.fab$b_fac = FAB$M_TRN | FAB$M_GET; /* allow truncate and get access */
4514   xfab.fab$b_shr = FAB$M_NIL;   /* allow no sharing - file must be locked */
4515   xfab.fab$l_fna = fn;
4516   xfab.fab$b_fns = strlen (fn);
4517   xfab.fab$l_dna = ";0";        /* default to latest version of the file */
4518   xfab.fab$b_dns = 2;
4519   xrab.rab$l_fab = &xfab;
4520
4521   /* This gibberish opens the file, positions to the first record, and
4522      deletes all records from there until the end of file. */
4523   if ((SYS$OPEN (&xfab) & 01) == 01)
4524     {
4525       if ((SYS$CONNECT (&xrab) & 01) == 01 &&
4526           (SYS$FIND (&xrab) & 01) == 01 &&
4527           (SYS$TRUNCATE (&xrab) & 01) == 01)
4528         status = 0;
4529       else
4530         status = -1;
4531     }
4532   else
4533     status = -1;
4534   SYS$CLOSE (&xfab);
4535   return status;
4536 }
4537
4538 /* Define this symbol to actually read SYSUAF.DAT.  This requires either
4539    SYSPRV or a readable SYSUAF.DAT. */
4540
4541 #ifdef READ_SYSUAF
4542 /*
4543  * getuaf.c
4544  *
4545  * Routine to read the VMS User Authorization File and return
4546  * a specific user's record.
4547  */
4548
4549 static struct UAF retuaf;
4550
4551 struct UAF *
4552 get_uaf_name (uname)
4553      char * uname;
4554 {
4555   register status;
4556   struct FAB uaf_fab;
4557   struct RAB uaf_rab;
4558
4559   uaf_fab = cc$rms_fab;
4560   uaf_rab = cc$rms_rab;
4561   /* initialize fab fields */
4562   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4563   uaf_fab.fab$b_fns = 21;
4564   uaf_fab.fab$b_fac = FAB$M_GET;
4565   uaf_fab.fab$b_org = FAB$C_IDX;
4566   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4567   /* initialize rab fields */
4568   uaf_rab.rab$l_fab = &uaf_fab;
4569   /* open the User Authorization File */
4570   status = SYS$OPEN (&uaf_fab);
4571   if (!(status&1))
4572     {
4573       errno = EVMSERR;
4574       vaxc$errno = status;
4575       return 0;
4576     }
4577   status = SYS$CONNECT (&uaf_rab);
4578   if (!(status&1))
4579     {
4580       errno = EVMSERR;
4581       vaxc$errno = status;
4582       return 0;
4583     }
4584   /* read the requested record - index is in uname */
4585   uaf_rab.rab$l_kbf = uname;
4586   uaf_rab.rab$b_ksz = strlen (uname);
4587   uaf_rab.rab$b_rac = RAB$C_KEY;
4588   uaf_rab.rab$l_ubf = (char *)&retuaf;
4589   uaf_rab.rab$w_usz = sizeof retuaf;
4590   status = SYS$GET (&uaf_rab);
4591   if (!(status&1))
4592     {
4593       errno = EVMSERR;
4594       vaxc$errno = status;
4595       return 0;
4596     }
4597   /* close the User Authorization File */
4598   status = SYS$DISCONNECT (&uaf_rab);
4599   if (!(status&1))
4600     {
4601       errno = EVMSERR;
4602       vaxc$errno = status;
4603       return 0;
4604     }
4605   status = SYS$CLOSE (&uaf_fab);
4606   if (!(status&1))
4607     {
4608       errno = EVMSERR;
4609       vaxc$errno = status;
4610       return 0;
4611     }
4612   return &retuaf;
4613 }
4614
4615 struct UAF *
4616 get_uaf_uic (uic)
4617      unsigned long uic;
4618 {
4619   register status;
4620   struct FAB uaf_fab;
4621   struct RAB uaf_rab;
4622
4623   uaf_fab = cc$rms_fab;
4624   uaf_rab = cc$rms_rab;
4625   /* initialize fab fields */
4626   uaf_fab.fab$l_fna = "SYS$SYSTEM:SYSUAF.DAT";
4627   uaf_fab.fab$b_fns = 21;
4628   uaf_fab.fab$b_fac = FAB$M_GET;
4629   uaf_fab.fab$b_org = FAB$C_IDX;
4630   uaf_fab.fab$b_shr = FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL;
4631   /* initialize rab fields */
4632   uaf_rab.rab$l_fab = &uaf_fab;
4633   /* open the User Authorization File */
4634   status = SYS$OPEN (&uaf_fab);
4635   if (!(status&1))
4636     {
4637       errno = EVMSERR;
4638       vaxc$errno = status;
4639       return 0;
4640     }
4641   status = SYS$CONNECT (&uaf_rab);
4642   if (!(status&1))
4643     {
4644       errno = EVMSERR;
4645       vaxc$errno = status;
4646       return 0;
4647     }
4648   /* read the requested record - index is in uic */
4649   uaf_rab.rab$b_krf = 1;        /* 1st alternate key */
4650   uaf_rab.rab$l_kbf = (char *) &uic;
4651   uaf_rab.rab$b_ksz = sizeof uic;
4652   uaf_rab.rab$b_rac = RAB$C_KEY;
4653   uaf_rab.rab$l_ubf = (char *)&retuaf;
4654   uaf_rab.rab$w_usz = sizeof retuaf;
4655   status = SYS$GET (&uaf_rab);
4656   if (!(status&1))
4657     {
4658       errno = EVMSERR;
4659       vaxc$errno = status;
4660       return 0;
4661     }
4662   /* close the User Authorization File */
4663   status = SYS$DISCONNECT (&uaf_rab);
4664   if (!(status&1))
4665     {
4666       errno = EVMSERR;
4667       vaxc$errno = status;
4668       return 0;
4669     }
4670   status = SYS$CLOSE (&uaf_fab);
4671   if (!(status&1))
4672     {
4673       errno = EVMSERR;
4674       vaxc$errno = status;
4675       return 0;
4676     }
4677   return &retuaf;
4678 }
4679
4680 static struct passwd retpw;
4681
4682 struct passwd *
4683 cnv_uaf_pw (up)
4684      struct UAF * up;
4685 {
4686   char * ptr;
4687
4688   /* copy these out first because if the username is 32 chars, the next
4689      section will overwrite the first byte of the UIC */
4690   retpw.pw_uid = up->uaf$w_mem;
4691   retpw.pw_gid = up->uaf$w_grp;
4692
4693   /* I suppose this is not the best style, to possibly overwrite one
4694      byte beyond the end of the field, but what the heck... */
4695   ptr = &up->uaf$t_username[UAF$S_USERNAME];
4696   while (ptr[-1] == ' ')
4697     ptr--;
4698   *ptr = '\0';
4699   strcpy (retpw.pw_name, up->uaf$t_username);
4700
4701   /* the rest of these are counted ascii strings */
4702   strncpy (retpw.pw_gecos, &up->uaf$t_owner[1], up->uaf$t_owner[0]);
4703   retpw.pw_gecos[up->uaf$t_owner[0]] = '\0';
4704   strncpy (retpw.pw_dir, &up->uaf$t_defdev[1], up->uaf$t_defdev[0]);
4705   retpw.pw_dir[up->uaf$t_defdev[0]] = '\0';
4706   strncat (retpw.pw_dir, &up->uaf$t_defdir[1], up->uaf$t_defdir[0]);
4707   retpw.pw_dir[up->uaf$t_defdev[0] + up->uaf$t_defdir[0]] = '\0';
4708   strncpy (retpw.pw_shell, &up->uaf$t_defcli[1], up->uaf$t_defcli[0]);
4709   retpw.pw_shell[up->uaf$t_defcli[0]] = '\0';
4710
4711   return &retpw;
4712 }
4713 #else /* not READ_SYSUAF */
4714 static struct passwd retpw;
4715 #endif /* not READ_SYSUAF */
4716
4717 struct passwd *
4718 getpwnam (name)
4719      char * name;
4720 {
4721 #ifdef READ_SYSUAF
4722   struct UAF *up;
4723 #else
4724   char * user;
4725   char * dir;
4726   unsigned char * full;
4727 #endif /* READ_SYSUAF */
4728   char *ptr = name;
4729
4730   while (*ptr)
4731     {
4732       if ('a' <= *ptr && *ptr <= 'z')
4733         *ptr -= 040;
4734       ptr++;
4735     }
4736 #ifdef READ_SYSUAF
4737   if (!(up = get_uaf_name (name)))
4738     return 0;
4739   return cnv_uaf_pw (up);
4740 #else
4741   if (strcmp (name, getenv ("USER")) == 0)
4742     {
4743       retpw.pw_uid = getuid ();
4744       retpw.pw_gid = getgid ();
4745       strcpy (retpw.pw_name, name);
4746       if (full = egetenv ("FULLNAME"))
4747         strcpy (retpw.pw_gecos, full);
4748       else
4749         *retpw.pw_gecos = '\0';
4750       strcpy (retpw.pw_dir, egetenv ("HOME"));
4751       *retpw.pw_shell = '\0';
4752       return &retpw;
4753     }
4754   else
4755     return 0;
4756 #endif /* not READ_SYSUAF */
4757 }
4758
4759 struct passwd *
4760 getpwuid (uid)
4761      unsigned long uid;
4762 {
4763 #ifdef READ_SYSUAF
4764   struct UAF * up;
4765
4766   if (!(up = get_uaf_uic (uid)))
4767     return 0;
4768   return cnv_uaf_pw (up);
4769 #else
4770   if (uid == sys_getuid ())
4771     return getpwnam (egetenv ("USER"));
4772   else
4773     return 0;
4774 #endif /* not READ_SYSUAF */
4775 }
4776
4777 /* return total address space available to the current process.  This is
4778    the sum of the current p0 size, p1 size and free page table entries
4779    available. */
4780 int
4781 vlimit ()
4782 {
4783   int item_code;
4784   unsigned long free_pages;
4785   unsigned long frep0va;
4786   unsigned long frep1va;
4787   register status;
4788
4789   item_code = JPI$_FREPTECNT;
4790   if (((status = LIB$GETJPI (&item_code, 0, 0, &free_pages)) & 1) == 0)
4791     {
4792       errno = EVMSERR;
4793       vaxc$errno = status;
4794       return -1;
4795     }
4796   free_pages *= 512;
4797
4798   item_code = JPI$_FREP0VA;
4799   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep0va)) & 1) == 0)
4800     {
4801       errno = EVMSERR;
4802       vaxc$errno = status;
4803       return -1;
4804     }
4805   item_code = JPI$_FREP1VA;
4806   if (((status = LIB$GETJPI (&item_code, 0, 0, &frep1va)) & 1) == 0)
4807     {
4808       errno = EVMSERR;
4809       vaxc$errno = status;
4810       return -1;
4811     }
4812
4813   return free_pages + frep0va + (0x7fffffff - frep1va);
4814 }
4815
4816 int
4817 define_logical_name (varname, string)
4818      char *varname;
4819      char *string;
4820 {
4821   struct dsc$descriptor_s strdsc =
4822     {strlen (string), DSC$K_DTYPE_T, DSC$K_CLASS_S, string};
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$SET_LOGICAL (&envdsc, &strdsc, &lnmdsc, 0, 0);
4829 }
4830
4831 int
4832 delete_logical_name (varname)
4833      char *varname;
4834 {
4835   struct dsc$descriptor_s envdsc =
4836     {strlen (varname), DSC$K_DTYPE_T, DSC$K_CLASS_S, varname};
4837   struct dsc$descriptor_s lnmdsc =
4838     {7, DSC$K_DTYPE_T, DSC$K_CLASS_S, "LNM$JOB"};
4839
4840   return LIB$DELETE_LOGICAL (&envdsc, &lnmdsc);
4841 }
4842
4843 int
4844 ulimit ()
4845 {
4846   return 0;
4847 }
4848
4849 int
4850 setpgrp ()
4851 {
4852   return 0;
4853 }
4854
4855 int
4856 execvp ()
4857 {
4858   error ("execvp system call not implemented");
4859   return -1;
4860 }
4861
4862 int
4863 rename (from, to)
4864      char *from, *to;
4865 {
4866   int status;
4867   struct FAB from_fab = cc$rms_fab, to_fab = cc$rms_fab;
4868   struct NAM from_nam = cc$rms_nam, to_nam = cc$rms_nam;
4869   char from_esn[NAM$C_MAXRSS];
4870   char to_esn[NAM$C_MAXRSS];
4871
4872   from_fab.fab$l_fna = from;
4873   from_fab.fab$b_fns = strlen (from);
4874   from_fab.fab$l_nam = &from_nam;
4875   from_fab.fab$l_fop = FAB$M_NAM;
4876
4877   from_nam.nam$l_esa = from_esn;
4878   from_nam.nam$b_ess = sizeof from_esn;
4879
4880   to_fab.fab$l_fna = to;
4881   to_fab.fab$b_fns = strlen (to);
4882   to_fab.fab$l_nam = &to_nam;
4883   to_fab.fab$l_fop = FAB$M_NAM;
4884
4885   to_nam.nam$l_esa = to_esn;
4886   to_nam.nam$b_ess = sizeof to_esn;
4887
4888   status = SYS$RENAME (&from_fab, 0, 0, &to_fab);
4889
4890   if (status & 1)
4891     return 0;
4892   else
4893     {
4894       if (status == RMS$_DEV)
4895         errno = EXDEV;
4896       else
4897         errno = EVMSERR;
4898       vaxc$errno = status;
4899       return -1;
4900     }
4901 }
4902
4903 /* This function renames a file like `rename', but it strips
4904    the version number from the "to" filename, such that the "to" file is
4905    will always be a new version.  It also sets the file protection once it is
4906    finished.  The protection that we will use is stored in fab_final_pro,
4907    and was set when we did a creat_copy_attrs to create the file that we
4908    are renaming.
4909
4910    We could use the chmod function, but Eunichs uses 3 bits per user category
4911    to describe the protection, and VMS uses 4 (write and delete are separate
4912    bits).  To maintain portability, the VMS implementation of `chmod' wires
4913    the W and D bits together.  */
4914
4915
4916 static struct fibdef fib;       /* We need this initialized to zero */
4917 char vms_file_written[NAM$C_MAXRSS];
4918
4919 int
4920 rename_sans_version (from,to)
4921      char *from, *to;
4922 {
4923   short int chan;
4924   int stat;
4925   short int iosb[4];
4926   int status;
4927   struct FAB to_fab = cc$rms_fab;
4928   struct NAM to_nam = cc$rms_nam;
4929   struct dsc$descriptor fib_d ={sizeof (fib),0,0,(char*) &fib};
4930   struct dsc$descriptor fib_attr[2]
4931     = {{sizeof (fab_final_pro),ATR$C_FPRO,0,(char*) &fab_final_pro},{0,0,0,0}};
4932   char to_esn[NAM$C_MAXRSS];
4933
4934   $DESCRIPTOR (disk,to_esn);
4935
4936   to_fab.fab$l_fna = to;
4937   to_fab.fab$b_fns = strlen (to);
4938   to_fab.fab$l_nam = &to_nam;
4939   to_fab.fab$l_fop = FAB$M_NAM;
4940
4941   to_nam.nam$l_esa = to_esn;
4942   to_nam.nam$b_ess = sizeof to_esn;
4943
4944   status = SYS$PARSE (&to_fab, 0, 0); /* figure out the full file name */
4945
4946   if (to_nam.nam$l_fnb && NAM$M_EXP_VER)
4947     *(to_nam.nam$l_ver) = '\0';
4948
4949   stat = rename (from, to_esn);
4950   if (stat < 0)
4951     return stat;
4952
4953   strcpy (vms_file_written, to_esn);
4954
4955   to_fab.fab$l_fna = vms_file_written; /* this points to the versionless name */
4956   to_fab.fab$b_fns = strlen (vms_file_written);
4957
4958   /* Now set the file protection to the correct value */
4959   SYS$OPEN (&to_fab, 0, 0);     /* This fills in the nam$w_fid fields */
4960
4961   /* Copy these fields into the fib */
4962   fib.fib$r_fid_overlay.fib$w_fid[0] = to_nam.nam$w_fid[0];
4963   fib.fib$r_fid_overlay.fib$w_fid[1] = to_nam.nam$w_fid[1];
4964   fib.fib$r_fid_overlay.fib$w_fid[2] = to_nam.nam$w_fid[2];
4965
4966   SYS$CLOSE (&to_fab, 0, 0);
4967
4968   stat = SYS$ASSIGN (&disk, &chan, 0, 0); /* open a channel to the disk */
4969   if (!stat)
4970     LIB$SIGNAL (stat);
4971   stat = SYS$QIOW (0, chan, IO$_MODIFY, iosb, 0, 0, &fib_d,
4972                    0, 0, 0, &fib_attr, 0);
4973   if (!stat)
4974     LIB$SIGNAL (stat);
4975   stat = SYS$DASSGN (chan);
4976   if (!stat)
4977     LIB$SIGNAL (stat);
4978   strcpy (vms_file_written, to_esn); /* We will write this to the terminal*/
4979   return 0;
4980 }
4981
4982 int
4983 link (file, new)
4984      char * file, * new;
4985 {
4986   register status;
4987   struct FAB fab;
4988   struct NAM nam;
4989   unsigned short fid[3];
4990   char esa[NAM$C_MAXRSS];
4991
4992   fab = cc$rms_fab;
4993   fab.fab$l_fop = FAB$M_OFP;
4994   fab.fab$l_fna = file;
4995   fab.fab$b_fns = strlen (file);
4996   fab.fab$l_nam = &nam;
4997
4998   nam = cc$rms_nam;
4999   nam.nam$l_esa = esa;
5000   nam.nam$b_ess = NAM$C_MAXRSS;
5001
5002   status = SYS$PARSE (&fab);
5003   if ((status & 1) == 0)
5004     {
5005       errno = EVMSERR;
5006       vaxc$errno = status;
5007       return -1;
5008     }
5009   status = SYS$SEARCH (&fab);
5010   if ((status & 1) == 0)
5011     {
5012       errno = EVMSERR;
5013       vaxc$errno = status;
5014       return -1;
5015     }
5016
5017   fid[0] = nam.nam$w_fid[0];
5018   fid[1] = nam.nam$w_fid[1];
5019   fid[2] = nam.nam$w_fid[2];
5020
5021   fab.fab$l_fna = new;
5022   fab.fab$b_fns = strlen (new);
5023
5024   status = SYS$PARSE (&fab);
5025   if ((status & 1) == 0)
5026     {
5027       errno = EVMSERR;
5028       vaxc$errno = status;
5029       return -1;
5030     }
5031
5032   nam.nam$w_fid[0] = fid[0];
5033   nam.nam$w_fid[1] = fid[1];
5034   nam.nam$w_fid[2] = fid[2];
5035
5036   nam.nam$l_esa = nam.nam$l_name;
5037   nam.nam$b_esl = nam.nam$b_name + nam.nam$b_type + nam.nam$b_ver;
5038
5039   status = SYS$ENTER (&fab);
5040   if ((status & 1) == 0)
5041     {
5042       errno = EVMSERR;
5043       vaxc$errno = status;
5044       return -1;
5045     }
5046
5047   return 0;
5048 }
5049
5050 void
5051 croak (badfunc)
5052      char *badfunc;
5053 {
5054   printf ("%s not yet implemented\r\n", badfunc);
5055   reset_sys_modes ();
5056   exit (1);
5057 }
5058
5059 long
5060 random ()
5061 {
5062   /* Arrange to return a range centered on zero.  */
5063   return rand () - (1 << 30);
5064 }
5065
5066 void
5067 srandom (seed)
5068 {
5069   srand (seed);
5070 }
5071 #endif /* VMS */
5072 \f
5073 #ifdef AIXHFT
5074
5075 /* Called from init_sys_modes.  */
5076 void
5077 hft_init ()
5078 {
5079   int junk;
5080
5081   /* If we're not on an HFT we shouldn't do any of this.  We determine
5082      if we are on an HFT by trying to get an HFT error code.  If this
5083      call fails, we're not on an HFT. */
5084 #ifdef IBMR2AIX
5085   if (ioctl (0, HFQERROR, &junk) < 0)
5086     return;
5087 #else /* not IBMR2AIX */
5088   if (ioctl (0, HFQEIO, 0) < 0)
5089     return;
5090 #endif /* not IBMR2AIX */
5091
5092   /* On AIX the default hft keyboard mapping uses backspace rather than delete
5093      as the rubout key's ASCII code.  Here this is changed.  The bug is that
5094      there's no way to determine the old mapping, so in reset_sys_modes
5095      we need to assume that the normal map had been present.  Of course, this
5096      code also doesn't help if on a terminal emulator which doesn't understand
5097      HFT VTD's.  */
5098   {
5099     struct hfbuf buf;
5100     struct hfkeymap keymap;
5101
5102     buf.hf_bufp = (char *)&keymap;
5103     buf.hf_buflen = sizeof (keymap);
5104     keymap.hf_nkeys = 2;
5105     keymap.hfkey[0].hf_kpos = 15;
5106     keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
5107 #ifdef IBMR2AIX
5108     keymap.hfkey[0].hf_keyidh = '<';
5109 #else /* not IBMR2AIX */
5110     keymap.hfkey[0].hf_page = '<';
5111 #endif /* not IBMR2AIX */
5112     keymap.hfkey[0].hf_char = 127;
5113     keymap.hfkey[1].hf_kpos = 15;
5114     keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
5115 #ifdef IBMR2AIX
5116     keymap.hfkey[1].hf_keyidh = '<';
5117 #else /* not IBMR2AIX */
5118     keymap.hfkey[1].hf_page = '<';
5119 #endif /* not IBMR2AIX */
5120     keymap.hfkey[1].hf_char = 127;
5121     hftctl (0, HFSKBD, &buf);
5122   }
5123   /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
5124      at times.  */
5125   line_ins_del_ok = char_ins_del_ok = 0;
5126 }
5127
5128 /* Reset the rubout key to backspace.  */
5129
5130 void
5131 hft_reset ()
5132 {
5133   struct hfbuf buf;
5134   struct hfkeymap keymap;
5135   int junk;
5136
5137 #ifdef IBMR2AIX
5138   if (ioctl (0, HFQERROR, &junk) < 0)
5139     return;
5140 #else /* not IBMR2AIX */
5141   if (ioctl (0, HFQEIO, 0) < 0)
5142     return;
5143 #endif /* not IBMR2AIX */
5144
5145   buf.hf_bufp = (char *)&keymap;
5146   buf.hf_buflen = sizeof (keymap);
5147   keymap.hf_nkeys = 2;
5148   keymap.hfkey[0].hf_kpos = 15;
5149   keymap.hfkey[0].hf_kstate = HFMAPCHAR | HFSHFNONE;
5150 #ifdef IBMR2AIX
5151   keymap.hfkey[0].hf_keyidh = '<';
5152 #else /* not IBMR2AIX */
5153   keymap.hfkey[0].hf_page = '<';
5154 #endif /* not IBMR2AIX */
5155   keymap.hfkey[0].hf_char = 8;
5156   keymap.hfkey[1].hf_kpos = 15;
5157   keymap.hfkey[1].hf_kstate = HFMAPCHAR | HFSHFSHFT;
5158 #ifdef IBMR2AIX
5159   keymap.hfkey[1].hf_keyidh = '<';
5160 #else /* not IBMR2AIX */
5161   keymap.hfkey[1].hf_page = '<';
5162 #endif /* not IBMR2AIX */
5163   keymap.hfkey[1].hf_char = 8;
5164   hftctl (0, HFSKBD, &buf);
5165 }
5166
5167 #endif /* AIXHFT */
5168
5169 #ifdef USE_DL_STUBS
5170
5171 /* These are included on Sunos 4.1 when we do not use shared libraries.
5172    X11 libraries may refer to these functions but (we hope) do not
5173    actually call them.  */
5174
5175 void *
5176 dlopen ()
5177 {
5178   return 0;
5179 }
5180
5181 void *
5182 dlsym ()
5183 {
5184   return 0;
5185 }
5186
5187 int
5188 dlclose ()
5189 {
5190   return -1;
5191 }
5192
5193 #endif /* USE_DL_STUBS */
5194 \f
5195 #ifndef BSTRING
5196
5197 #ifndef bzero
5198
5199 void
5200 bzero (b, length)
5201      register char *b;
5202      register int length;
5203 {
5204 #ifdef VMS
5205   short zero = 0;
5206   long max_str = 65535;
5207
5208   while (length > max_str) {
5209     (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
5210     length -= max_str;
5211     b += max_str;
5212   }
5213   max_str = length;
5214   (void) LIB$MOVC5 (&zero, &zero, &zero, &max_str, b);
5215 #else
5216   while (length-- > 0)
5217     *b++ = 0;
5218 #endif /* not VMS */
5219 }
5220
5221 #endif /* no bzero */
5222 #endif /* BSTRING */
5223
5224 #if (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY)
5225 #undef bcopy
5226
5227 /* Saying `void' requires a declaration, above, where bcopy is used
5228    and that declaration causes pain for systems where bcopy is a macro.  */
5229 bcopy (b1, b2, length)
5230      register char *b1;
5231      register char *b2;
5232      register int length;
5233 {
5234 #ifdef VMS
5235   long max_str = 65535;
5236
5237   while (length > max_str) {
5238     (void) LIB$MOVC3 (&max_str, b1, b2);
5239     length -= max_str;
5240     b1 += max_str;
5241     b2 += max_str;
5242   }
5243   max_str = length;
5244   (void) LIB$MOVC3 (&length, b1, b2);
5245 #else
5246   while (length-- > 0)
5247     *b2++ = *b1++;
5248 #endif /* not VMS */
5249 }
5250 #endif /* (!defined (BSTRING) && !defined (bcopy)) || defined (NEED_BCOPY) */
5251
5252 #ifndef BSTRING
5253 #ifndef bcmp
5254 int
5255 bcmp (b1, b2, length)   /* This could be a macro! */
5256      register char *b1;
5257      register char *b2;
5258      register int length;
5259 {
5260 #ifdef VMS
5261   struct dsc$descriptor_s src1 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b1};
5262   struct dsc$descriptor_s src2 = {length, DSC$K_DTYPE_T, DSC$K_CLASS_S, b2};
5263
5264   return STR$COMPARE (&src1, &src2);
5265 #else
5266   while (length-- > 0)
5267     if (*b1++ != *b2++)
5268       return 1;
5269
5270   return 0;
5271 #endif /* not VMS */
5272 }
5273 #endif /* no bcmp */
5274 #endif /* not BSTRING */
5275 \f
5276 #ifndef HAVE_STRSIGNAL
5277 char *
5278 strsignal (code)
5279      int code;
5280 {
5281   char *signame = 0;
5282
5283   if (0 <= code && code < NSIG)
5284     {
5285 #ifdef VMS
5286       signame = sys_errlist[code];
5287 #else
5288       /* Cast to suppress warning if the table has const char *.  */
5289       signame = (char *) sys_siglist[code];
5290 #endif
5291     }
5292
5293   return signame;
5294 }
5295 #endif /* HAVE_STRSIGNAL */
5296 \f
5297 /* All the Macintosh stuffs go here */
5298
5299 #ifdef macintosh
5300
5301 #include <Files.h>
5302 #include <MacTypes.h>
5303 #include <TextUtils.h>
5304 #include <Folders.h>
5305
5306 #include <dirent.h>
5307 #include <sys/stat.h>
5308 #include <string.h>
5309 #include <pwd.h>
5310 #include <sys/param.h>
5311
5312 /* Convert a Mac pathname to Unix form.  A Mac full pathname is one
5313    that does not begin with a ':' and contains at least one ':'. A Mac
5314    full pathname causes an '/' to be prepended to the Unix pathname.
5315    The algorithm for the rest of the pathname is as follows:
5316      For each segment between two ':',
5317        if it is non-null, copy as is and then add a '/' at the end,
5318        otherwise, insert a "../" into the Unix pathname.
5319    Returns 1 if successful; 0 if fails.  */
5320
5321 int
5322 Mac2UnixPathname (const char *mfn, char *ufn, int ufnbuflen)
5323 {
5324   const char *p, *q, *pe;
5325
5326   strcpy (ufn, "");
5327
5328   if (*mfn == '\0')
5329     return 1;
5330
5331   p = strchr (mfn, ':');
5332   if (p != 0 && p != mfn)  /* full pathname */
5333     strcat (ufn, "/");
5334
5335   p = mfn;
5336   if (*p == ':')
5337     p++;
5338
5339   pe = mfn + strlen (mfn);
5340   while (p < pe)
5341     {
5342       q = strchr (p, ':');
5343       if (q)
5344         {
5345           if (q == p)
5346             {  /* two consecutive ':' */
5347               if (strlen (ufn) + 3 >= ufnbuflen)
5348                 return 0;
5349               strcat (ufn, "../");
5350             }
5351           else
5352             {
5353               if (strlen (ufn) + (q - p) + 1 >= ufnbuflen)
5354                 return 0;
5355               strncat (ufn, p, q - p);
5356               strcat (ufn, "/");
5357             }
5358           p = q + 1;
5359         }
5360       else
5361         {
5362           if (strlen (ufn) + (pe - p) >= ufnbuflen)
5363             return 0;
5364           strncat (ufn, p, pe - p);  /* no separator for last one */
5365           p = pe;
5366         }
5367     }
5368
5369   return 1;
5370 }
5371
5372 extern char *GetTempDirName ();
5373
5374 /* Convert a Unix pathname to Mac form.  Approximately reverse of the
5375    above in algorithm.  */
5376 int
5377 Unix2MacPathname (const char *ufn, char *mfn, int mfnbuflen)
5378 {
5379   const char *p, *q, *pe;
5380   char expandedPathname[MAXPATHLEN+1];
5381
5382   strcpy (mfn, "");
5383
5384   if (*ufn == '\0')
5385     return 1;
5386
5387   p = ufn;
5388
5389   /* Check for and handle volume names.  Last comparison: strangely
5390      somewhere `/.emacs' is passed.  A temporary fix for now.  */
5391   if (*p == '/' && strchr (p+1, '/') == NULL && strcmp (p, "/.emacs") != 0)
5392     {
5393       if (strlen (p) + 1 > mfnbuflen)
5394         return 0;
5395       strcpy (mfn, p+1);
5396       strcat (mfn, ":");
5397       return 1;
5398     }
5399
5400   if (strncmp (p, "~emacs/", 7) == 0)
5401     {  /* expand to emacs dir found by InitEmacsPasswdDir */
5402       struct passwd *pw = getpwnam ("emacs");
5403       p += 7;
5404       if (strlen (pw->pw_dir) + strlen (p) > MAXPATHLEN)
5405         return 0;
5406       strcpy (expandedPathname, pw->pw_dir);
5407       strcat (expandedPathname, p);
5408       p = expandedPathname;
5409       /* Now p points to the pathname with emacs dir prefix.  */
5410     }
5411   else if (strncmp (p, "/tmp/", 5) == 0)
5412     {
5413       char *t = GetTempDirName ();
5414       p += 5;
5415       if (strlen (t) + strlen (p) > MAXPATHLEN)
5416         return 0;
5417       strcpy (expandedPathname, t);
5418       strcat (expandedPathname, p);
5419       p = expandedPathname;
5420       /* Now p points to the pathname with emacs dir prefix.  */
5421     }
5422   else if (*p != '/')  /* relative pathname */
5423     strcat (mfn, ":");
5424
5425   if (*p == '/')
5426     p++;
5427
5428   pe = p + strlen (p);
5429   while (p < pe)
5430     {
5431       q = strchr (p, '/');
5432       if (q)
5433         {
5434           if (q - p == 2 && *p == '.' && *(p+1) == '.')
5435             {
5436               if (strlen (mfn) + 1 >= mfnbuflen)
5437                 return 0;
5438               strcat (mfn, ":");
5439             }
5440           else
5441             {
5442               if (strlen (mfn) + (q - p) + 1 >= mfnbuflen)
5443                 return 0;
5444               strncat (mfn, p, q - p);
5445               strcat (mfn, ":");
5446             }
5447           p = q + 1;
5448         }
5449       else
5450         {
5451           if (strlen (mfn) + (pe - p) >= mfnbuflen)
5452             return 0;
5453           strncat (mfn, p, pe - p);
5454           p = pe;
5455         }
5456     }
5457
5458   return 1;
5459 }
5460
5461 /* The following functions with "sys_" prefix are stubs to Unix
5462    functions that have already been implemented by CW or MPW.  The
5463    calls to them in Emacs source course are #define'd to call the sys_
5464    versions by the header files s-mac.h.  In these stubs pathnames are
5465    converted between their Unix and Mac forms.  */
5466 /* Unix Epoch is Jan 1, 1970 while Mac Epoch is Jan 1, 1904: 66 years
5467    + 17 leap days */
5468 #define MAC_UNIX_EPOCH_DIFF  ((365L * 66 + 17) * 24 * 60 * 60)
5469
5470 /* CW Epoch is Jan 1, 1900 (aaarghhhhh!); remember, 1900 is not a leap
5471    year! */
5472 #define CW_UNIX_EPOCH_DIFF ((365L * 70 + 17) * 24 * 60 * 60)
5473
5474 /* Define our own stat function for both MrC and CW.  The reason for
5475    doing this: "stat" is both the name of a struct and function name:
5476    we can't #define stat to something else to
5477    redirect Emacs's calls to our own version that converts Unix style
5478    filenames to Mac style filename because all sorts of compilation
5479    errors will be generated if stat is #define'd to be something else.  */
5480
5481 int
5482 stat (const char *path, struct stat *buf)
5483 {
5484   char MacPathname[MAXPATHLEN+1];
5485   CInfoPBRec cipb;
5486
5487   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5488     return -1;
5489
5490   c2pstr (MacPathname);
5491   cipb.hFileInfo.ioNamePtr = MacPathname;
5492   cipb.hFileInfo.ioVRefNum = 0;
5493   cipb.hFileInfo.ioDirID = 0;
5494   cipb.hFileInfo.ioFDirIndex = 0;  /* set to 0 to get information about specific dir or file */
5495
5496   errno = PBGetCatInfo (&cipb, false);
5497   if (errno == -43) /* -43: fnfErr defined in Errors.h */
5498     errno = ENOENT;
5499   if (errno != noErr)
5500     return -1;
5501
5502   if (cipb.hFileInfo.ioFlAttrib & 0x10)
5503     {  /* bit 4 = 1 for directories */
5504       buf->st_mode = S_IFDIR | S_IREAD | S_IEXEC;
5505       if (!(cipb.hFileInfo.ioFlAttrib & 0x1))  /* bit 1 = 1 for locked files/directories */
5506         buf->st_mode |= S_IWRITE;
5507       buf->st_ino = cipb.dirInfo.ioDrDirID;
5508       buf->st_dev = cipb.dirInfo.ioVRefNum;
5509       buf->st_size = cipb.dirInfo.ioDrNmFls;  /* size of dir = number of files and dirs */
5510       buf->st_atime = buf->st_mtime = cipb.dirInfo.ioDrMdDat - MAC_UNIX_EPOCH_DIFF;
5511       buf->st_ctime = cipb.dirInfo.ioDrCrDat - MAC_UNIX_EPOCH_DIFF;
5512     }
5513   else
5514     {
5515       buf->st_mode = S_IFREG | S_IREAD;
5516       if (!(cipb.hFileInfo.ioFlAttrib & 0x1))  /* bit 1 = 1 for locked files/directories */
5517         buf->st_mode |= S_IWRITE;
5518       if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
5519         buf->st_mode |= S_IEXEC;
5520       buf->st_ino = cipb.hFileInfo.ioDirID;
5521       buf->st_dev = cipb.hFileInfo.ioVRefNum;
5522       buf->st_size = cipb.hFileInfo.ioFlLgLen;
5523       buf->st_atime = buf->st_mtime = cipb.hFileInfo.ioFlMdDat - MAC_UNIX_EPOCH_DIFF;
5524       buf->st_ctime = cipb.hFileInfo.ioFlCrDat - MAC_UNIX_EPOCH_DIFF;
5525     }
5526   buf->st_nlink = 1;
5527   buf->st_uid = getuid ();
5528   buf->st_gid = getgid ();
5529   buf->st_rdev = 0;
5530
5531   return 0;
5532 }
5533
5534 #if __MRC__
5535
5536 /* CW defines fstat in stat.mac.c while MPW does not provide this
5537    function.  Without the information of how to get from a file
5538    descriptor in MPW StdCLib to a Mac OS file spec, it should be hard
5539    to implement this function.  Fortunately, there is only one place
5540    where this function is called in our configuration: in fileio.c,
5541    where only the st_dev and st_ino fields are used to determine
5542    whether two fildes point to different i-nodes to prevent copying
5543    a file onto itself equal.  What we have here probably needs
5544    improvement.  */
5545 int
5546 fstat (int fildes, struct stat *buf)
5547 {
5548   buf->st_dev = 0;
5549   buf->st_ino = fildes;
5550   return 0;  /* success */
5551 }
5552
5553 #endif  /* __MRC__ */
5554
5555 /* From Think Reference code example */
5556 int
5557 mkdir (const char *dirname, int mode)
5558 {
5559 #pragma unused (mode)
5560
5561   HFileParam hfpb;
5562   char MacPathname[MAXPATHLEN+1];
5563
5564   if (Unix2MacPathname (dirname, MacPathname, MAXPATHLEN+1) == 0)
5565     return -1;
5566
5567   c2pstr (MacPathname);
5568   hfpb.ioNamePtr = MacPathname;
5569   hfpb.ioVRefNum = 0; /*ignored unless name is invalid */
5570   hfpb.ioDirID = 0;  /*parent is the root */
5571
5572   /* Just return the Mac OSErr code for now.  */
5573   errno = PBDirCreate ((HParmBlkPtr) &hfpb, false);
5574   return errno == noErr ? 0 : -1;
5575 }
5576
5577 int
5578 rmdir (const char *dirname)
5579 {
5580   HFileParam hfpb;
5581   char MacPathname[MAXPATHLEN+1];
5582
5583   if (Unix2MacPathname (dirname, MacPathname, MAXPATHLEN+1) == 0)
5584     return -1;
5585
5586   c2pstr (MacPathname);
5587   hfpb.ioNamePtr = MacPathname;
5588   hfpb.ioVRefNum = 0; /*ignored unless name is invalid */
5589   hfpb.ioDirID = 0;  /*parent is the root */
5590
5591   errno = PBHDelete ((HParmBlkPtr) &hfpb, false);
5592   return errno == noErr ? 0 : -1;
5593 }
5594
5595 #ifdef __MRC__
5596
5597 /* No implementation yet. */
5598 int
5599 execvp (const char *path, ...)
5600 {
5601   return -1;
5602 }
5603
5604 #endif /* __MRC__ */
5605
5606 int
5607 utime (const char *path, const struct utimbuf *times)
5608 {
5609   char MacPathname[MAXPATHLEN+1];
5610   CInfoPBRec cipb;
5611
5612   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5613     return -1;
5614
5615   c2pstr (MacPathname);
5616   cipb.hFileInfo.ioNamePtr = MacPathname;
5617   cipb.hFileInfo.ioVRefNum = 0;
5618   cipb.hFileInfo.ioDirID = 0;
5619   /* Set to 0 to get information about specific dir or file.  */
5620   cipb.hFileInfo.ioFDirIndex = 0;
5621
5622   errno = PBGetCatInfo (&cipb, false);
5623   if (errno != noErr)
5624     return -1;
5625
5626   if (cipb.hFileInfo.ioFlAttrib & 0x10)
5627     {  /* bit 4 = 1 for directories */
5628       if (times)
5629         cipb.dirInfo.ioDrMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
5630       else
5631         GetDateTime (&cipb.dirInfo.ioDrMdDat);
5632     }
5633   else
5634     {
5635       if (times)
5636         cipb.hFileInfo.ioFlMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
5637       else
5638         GetDateTime (&cipb.hFileInfo.ioFlMdDat);
5639     }
5640
5641   errno = PBSetCatInfo (&cipb, false);
5642   return errno == noErr ? 0 : -1;
5643 }
5644
5645 #define F_OK 0
5646 #define X_OK 1
5647 #define W_OK 2
5648
5649 /* Like stat, but test for access mode in hfpb.ioFlAttrib.  */
5650 int
5651 access (const char *path, int mode)
5652 {
5653   char MacPathname[MAXPATHLEN+1];
5654   CInfoPBRec cipb;
5655
5656   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5657     return -1;
5658
5659   c2pstr (MacPathname);
5660   cipb.hFileInfo.ioNamePtr = MacPathname;
5661   cipb.hFileInfo.ioVRefNum = 0;
5662   cipb.hFileInfo.ioDirID = 0;
5663   cipb.hFileInfo.ioFDirIndex = 0;  /* set to 0 to get information about specific dir or file */
5664
5665   errno = PBGetCatInfo (&cipb, false);
5666   if (errno != noErr)
5667     return -1;
5668
5669   if (mode == F_OK)  /* got this far, file exists */
5670     return 0;
5671
5672   if (mode & X_OK)
5673     if (cipb.hFileInfo.ioFlAttrib & 0x10)  /* path refers to a directory */
5674       return 0;
5675     else
5676       {
5677         if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
5678           return 0;
5679         else
5680           return -1;
5681       }
5682
5683   if (mode & W_OK)
5684     return (cipb.hFileInfo.ioFlAttrib & 0x1) ? -1 : 0;  /* don't allow if lock bit on */
5685
5686   return -1;
5687 }
5688
5689 #define DEV_NULL_FD 0x10000
5690
5691 #undef open
5692 int
5693 sys_open (const char *path, int oflag)
5694 {
5695   char MacPathname[MAXPATHLEN+1];
5696
5697   if (strcmp (path, "/dev/null") == 0)
5698     return DEV_NULL_FD;  /* some bogus fd to be ignored in write */
5699
5700   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5701     return -1;
5702   else
5703     return open (MacPathname, oflag);
5704 }
5705
5706 #undef creat
5707 int
5708 sys_creat (const char *path, mode_t mode)
5709 {
5710   char MacPathname[MAXPATHLEN+1];
5711
5712   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5713     return -1;
5714   else
5715     return creat (MacPathname, mode);
5716 }
5717
5718 #undef unlink
5719 int
5720 sys_unlink (const char *path)
5721 {
5722   char MacPathname[MAXPATHLEN+1];
5723
5724   if (Unix2MacPathname (path, MacPathname, MAXPATHLEN+1) == 0)
5725     return -1;
5726   else
5727     return unlink (MacPathname);
5728 }
5729
5730 #undef read
5731 int
5732 sys_read (int fildes, char *buf, int count)
5733 {
5734   if (fildes == 0)
5735     {  /* if stdin, call (non-echoing) "getch" in console.h */
5736       if (MacKeyPending ())
5737         {  /* don't wait for a key if none has been pressed */
5738           *buf = MacGetChar ();
5739           return 1;
5740         }
5741       else
5742         return 0;
5743     }
5744   else
5745     return read (fildes, buf, count);
5746 }
5747
5748 #undef write
5749 int
5750 sys_write (int fildes, char *buf, int count)
5751 {
5752   if (fildes == DEV_NULL_FD)
5753     return count;
5754   else
5755     return write (fildes, buf, count);
5756 }
5757
5758 #undef rename
5759 int
5760 sys_rename (const char * old_name, const char * new_name)
5761 {
5762   char MacOldName[MAXPATHLEN+1], MacNewName[MAXPATHLEN+1];
5763
5764   if (strcmp (old_name, new_name) == 0)
5765     return 0;
5766
5767   if (Unix2MacPathname (old_name, MacOldName, MAXPATHLEN+1) == 0)
5768     return 1;
5769
5770   if (Unix2MacPathname (new_name, MacNewName, MAXPATHLEN+1) == 0)
5771     return 1;
5772
5773   return rename (MacOldName, MacNewName);
5774 }
5775
5776 #undef fopen
5777 extern FILE *fopen (const char *name, const char *mode);
5778 FILE
5779 sys_fopen (const char *name, const char *mode)
5780 {
5781   char MacPathname[MAXPATHLEN+1];
5782
5783   if (Unix2MacPathname (name, MacPathname, MAXPATHLEN+1) == 0)
5784     return 0;
5785   else
5786     return fopen (MacPathname, mode);
5787 }
5788
5789 #include <Events.h>
5790
5791 long targetTicks = 0;
5792
5793 #ifdef __MRC__
5794 __sigfun alarm_signal_func = (__sigfun) 0;
5795 #elif __MWERKS__
5796 __signal_func_ptr alarm_signal_func = (__signal_func_ptr) 0;
5797 #else
5798 You lose!!!
5799 #endif
5800
5801 /* These functions simulate SIG_ALRM.  The stub for function signal
5802    stores the signal handler function in alarm_signal_func if a
5803    SIG_ALRM is encountered.  CheckAlarm is called in mac_read_socket,
5804    which emacs calls periodically.  A pending alarm is represented by
5805    a non-zero targetTicks value.  CheckAlarm calls the handler
5806    function pointed to by alarm_signal_func if one has been set up and
5807    an alarm is pending.  */
5808 void
5809 CheckAlarm ()
5810 {
5811   if (targetTicks && TickCount () > targetTicks)
5812     {
5813       targetTicks = 0;
5814       if (alarm_signal_func)
5815         (*alarm_signal_func)(SIGALRM);
5816     }
5817 }
5818
5819 /* Called in sys_select to wait for an alarm signal to arrive.  */
5820 int
5821 pause ()
5822 {
5823   unsigned long finalTick;
5824
5825   if (!targetTicks)  /* no alarm pending */
5826     return -1;
5827
5828   while (TickCount () <= targetTicks)
5829     Delay (1UL, &finalTick);  /* wait for 1/60 second before trying again */
5830
5831   targetTicks = 0;
5832   if (alarm_signal_func)
5833     (*alarm_signal_func)(SIGALRM);
5834
5835   return 0;
5836 }
5837
5838 int
5839 alarm (int seconds)
5840 {
5841   long remaining = targetTicks ? (TickCount () - targetTicks) / 60 : 0;
5842
5843   targetTicks = seconds ? TickCount () + 60 * seconds : 0;
5844
5845   return (remaining < 0) ? 0 : (unsigned int) remaining;
5846 }
5847
5848 #undef signal
5849 #ifdef __MRC__
5850 extern __sigfun signal (int signal, __sigfun signal_func);
5851 __sigfun
5852 sys_signal (int signal_num, __sigfun signal_func)
5853 #elif __MWERKS__
5854 extern __signal_func_ptr signal (int signal, __signal_func_ptr signal_func);
5855 __signal_func_ptr
5856 sys_signal (int signal_num, __signal_func_ptr signal_func)
5857 #else
5858      You lose!!!
5859 #endif
5860 {
5861   if (signal_num != SIGALRM)
5862     return signal (signal_num, signal_func);
5863   else
5864     {
5865 #ifdef __MRC__
5866       __sigfun old_signal_func;
5867 #elif __MWERKS__
5868       __signal_func_ptr old_signal_func;
5869 #else
5870       You lose!!!
5871 #endif
5872         old_signal_func = alarm_signal_func;
5873       alarm_signal_func = signal_func;
5874       return old_signal_func;
5875     }
5876 }
5877
5878 /* The time functions adjust time values according to the difference
5879    between the Unix and CW epoches. */
5880
5881 #undef gmtime
5882 extern struct tm *gmtime (const time_t *);
5883 struct tm
5884 sys_gmtime (const time_t *timer)
5885 {
5886   time_t unixTime = *timer + CW_UNIX_EPOCH_DIFF;
5887
5888   return gmtime (&unixTime);
5889 }
5890
5891 #undef localtime
5892 extern struct tm *localtime (const time_t *);
5893 struct tm *
5894 sys_localtime (const time_t *timer)
5895 {
5896   time_t unixTime = *timer + CW_UNIX_EPOCH_DIFF;
5897
5898   return localtime (&unixTime);
5899 }
5900
5901 #undef ctime
5902 extern char *ctime (const time_t *);
5903 char *
5904 sys_ctime (const time_t *timer)
5905 {
5906   time_t unixTime = *timer + CW_UNIX_EPOCH_DIFF;
5907
5908   return ctime (&unixTime);
5909 }
5910
5911 #undef time
5912 extern time_t time (time_t *);
5913 time_t
5914 sys_time (time_t *timer)
5915 {
5916   time_t macTime = time (NULL) - CW_UNIX_EPOCH_DIFF;
5917
5918   if (timer)
5919     *timer = macTime;
5920
5921   return macTime;
5922 }
5923
5924 /* no subprocesses, empty wait */
5925 int
5926 wait (int pid)
5927 {
5928   return 0;
5929 }
5930
5931 void
5932 croak (char *badfunc)
5933 {
5934   printf ("%s not yet implemented\r\n", badfunc);
5935   exit (1);
5936 }
5937
5938 char *
5939 index (const char * str, int chr)
5940 {
5941   return strchr (str, chr);
5942 }
5943
5944 char *e[] = { 0 };
5945 char **environ = &e[0];
5946
5947 char *
5948 mktemp (char *template)
5949 {
5950   int len, k;
5951   static seqnum = 0;
5952
5953   len = strlen (template);
5954   k = len - 1;
5955   while (k >= 0 && template[k] == 'X')
5956     k--;
5957
5958   k++;  /* make k index of first 'X' */
5959
5960   if (k < len)
5961     {
5962       /* Zero filled, number of digits equal to the number of X's.  */
5963       sprintf (&template[k], "%0*d", len-k, seqnum++);
5964
5965       return template;
5966     }
5967   else
5968     return 0;
5969 }
5970
5971 /* Emulate getpwuid, getpwnam and others.  */
5972
5973 #define PASSWD_FIELD_SIZE 256
5974
5975 static char myPasswdName[PASSWD_FIELD_SIZE];
5976 static char myPasswdDir[MAXPATHLEN+1];
5977
5978 static struct passwd myPasswd =
5979 {
5980   myPasswdName,
5981   myPasswdDir,
5982 };
5983
5984 /* Initialized by main () in macterm.c to pathname of emacs directory.  */
5985 char emacsPasswdDir[MAXPATHLEN+1];
5986
5987 void
5988 InitEmacsPasswdDir ()
5989 {
5990   int found = false;
5991
5992   if (getwd (emacsPasswdDir) && getwd (myPasswdDir))
5993     {
5994       /* Need pathname of first ancestor that begins with `emacs' since
5995          Mac emacs application is somewhere in the emacs-20.3 tree.  */
5996       int len = strlen (emacsPasswdDir);
5997       /* J points to the "/" following the directory name being compared.  */
5998       int j = len - 1;
5999       int i = j - 1;
6000       while (i >= 0 && !found)
6001         {
6002           while (i >= 0 && emacsPasswdDir[i] != '/')
6003             i--;
6004           if (emacsPasswdDir[i] == '/' && i+5 < len)
6005             found = (strncmp (&(emacsPasswdDir[i+1]), "emacs", 5) == 0);
6006           if (found)
6007             emacsPasswdDir[j+1] = '\0';
6008           else
6009             {
6010               j = i;
6011               i = j - 1;
6012             }
6013         }
6014     }
6015
6016   if (!found)
6017     {  /* setting to "/" probably won't work,
6018           but set it to something anyway.  */
6019       strcpy (emacsPasswdDir, "/");
6020       strcpy (myPasswdDir, "/");
6021     }
6022 }
6023
6024 static struct passwd emacsPasswd =
6025 {
6026   "emacs",
6027   emacsPasswdDir,
6028 };
6029
6030 static int myPasswdInited = 0;
6031
6032 static void
6033 InitMyPasswd ()
6034 {
6035   char **ownerName;
6036
6037   /* Note: myPasswdDir initialized in InitEmacsPasswdDir to directory
6038      where Emacs was started. */
6039
6040   ownerName = (char **) GetResource ('STR ',-16096);
6041   if (ownerName)
6042     {
6043       HLock (ownerName);
6044       BlockMove ((unsigned char *) *ownerName,
6045                  (unsigned char *) myPasswdName, *ownerName[0] + 1);
6046       HUnlock (ownerName);
6047       p2cstr ((unsigned char *) myPasswdName);
6048     }
6049   else
6050     myPasswdName[0] = 0;
6051 }
6052
6053 struct passwd *
6054 getpwuid (uid_t uid)
6055 {
6056   if (!myPasswdInited)
6057     {
6058       InitMyPasswd ();
6059       myPasswdInited = 1;
6060     }
6061
6062   return &myPasswd;
6063 }
6064
6065 struct passwd *
6066 getpwnam (const char *name)
6067 {
6068   if (strcmp (name, "emacs") == 0)
6069         return &emacsPasswd;
6070
6071   if (!myPasswdInited)
6072     {
6073       InitMyPasswd ();
6074       myPasswdInited = 1;
6075     }
6076
6077   return &myPasswd;
6078 }
6079
6080 /* The functions fork, kill, sigsetmask, sigblock, request_sigio,
6081    setpgrp, setpriority, and unrequest_sigio are defined to be empty
6082    as in msdos.c.  */
6083
6084 int
6085 fork ()
6086 {
6087   return -1;
6088 }
6089
6090 int
6091 kill (int x, int y)
6092 {
6093   return -1;
6094 }
6095
6096 int
6097 sigsetmask (int x)
6098 {
6099   return 0;
6100 }
6101
6102 int
6103 sigblock (int mask)
6104 {
6105   return 0;
6106 }
6107
6108 void
6109 request_sigio (void)
6110 {
6111 }
6112
6113 int
6114 setpgrp ()
6115 {
6116   return 0;
6117 }
6118
6119 void
6120 unrequest_sigio (void)
6121 {
6122 }
6123
6124 /* djgpp does not implement pipe either.  */
6125 int
6126 pipe (int _fildes[2])
6127 {
6128   errno = EACCES;
6129   return -1;
6130 }
6131
6132 /* Hard and symbolic links.  */
6133 int
6134 symlink (const char *name1, const char *name2)
6135 {
6136   errno = ENOENT;
6137   return -1;
6138 }
6139
6140 int
6141 link (const char *name1, const char *name2)
6142 {
6143   errno = ENOENT;
6144   return -1;
6145 }
6146
6147 int
6148 lstat (const char *path, struct stat *sb)
6149 {
6150   return stat (path, sb);
6151 }
6152
6153 int
6154 readlink (const char *path, char *buf, int bufsiz)
6155 {
6156   errno = ENOENT;
6157   return -1;
6158 }
6159
6160 mode_t
6161 umask (mode_t numask)
6162 {
6163   static mode_t mask = 022;
6164   mode_t oldmask = mask;
6165   mask = numask;
6166   return oldmask;
6167 }
6168
6169 int
6170 chmod (const char *path, mode_t mode)
6171 {
6172   /* say it always succeed for now */
6173   return 0;
6174 }
6175
6176 int
6177 dup (int oldd)
6178 {
6179 #ifdef __MRC__
6180   return fcntl (oldd, F_DUPFD, 0);
6181 #elif __MWERKS__
6182   /* current implementation of fcntl in fcntl.mac.c simply returns old
6183      descriptor */
6184   return fcntl (oldd, F_DUPFD);
6185 #else
6186 You lose!!!
6187 #endif
6188 }
6189
6190 /* This is from the original sysdep.c.  Emulate BSD dup2.  First close
6191    newd if it already exists.  Then, attempt to dup oldd.  If not
6192    successful, call dup2 recursively until we are, then close the
6193    unsuccessful ones.  */
6194 int
6195 dup2 (int oldd, int newd)
6196 {
6197   int fd, ret;
6198
6199   close (newd);
6200
6201   fd = dup (oldd);
6202   if (fd == -1)
6203     return -1;
6204   if (fd == newd)
6205     return newd;
6206   ret = dup2 (oldd, newd);
6207   close (fd);
6208   return ret;
6209 }
6210
6211 /* let it fail for now */
6212 char *
6213 sbrk (int incr)
6214 {
6215   return (char *) -1;
6216 }
6217
6218 int
6219 fsync (int fd)
6220 {
6221   return 0;
6222 }
6223
6224 int
6225 ioctl (int d, int request, void *argp)
6226 {
6227   return -1;
6228 }
6229
6230 #ifdef __MRC__
6231 int
6232 isatty (int fildes)
6233 {
6234   if (fildes >=0 && fildes <= 2)
6235     return 1;
6236   else
6237     return 0;
6238 }
6239
6240 int
6241 getgid ()
6242 {
6243   return 100;
6244 }
6245
6246 int
6247 getegid ()
6248 {
6249   return 100;
6250 }
6251
6252 int
6253 getuid ()
6254 {
6255   return 200;
6256 }
6257
6258 int
6259 geteuid ()
6260 {
6261   return 200;
6262 }
6263
6264 unsigned int
6265 sleep (unsigned int seconds)
6266 {
6267   unsigned long finalTick;
6268
6269   Delay (seconds * 60UL, &finalTick);
6270   return (0);
6271 }
6272 #endif /* __MRC__ */
6273
6274 #ifdef __MWERKS__
6275 #undef getpid
6276 int
6277 getpid ()
6278 {
6279   return 9999;
6280 }
6281 #endif /* __MWERKS__ */
6282
6283 /* Return the path to the directory in which Emacs can create
6284    temporary files.  The MacOS "temporary items" directory cannot be
6285    used because it removes the file written by a process when it
6286    exits.  In that sense it's more like "/dev/null" than "/tmp" (but
6287    again not exactly).  And of course Emacs needs to read back the
6288    files written by its subprocesses.  So here we write the files to a
6289    directory "Emacs" in the Preferences Folder.  This directory is
6290    created if it does not exist.  */
6291 static char *
6292 GetTempDirName ()
6293 {
6294   static char *TempDirName = NULL;
6295   short vRefNum;
6296   long dirID;
6297   OSErr err;
6298   Str255 dirName, fullPath;
6299   CInfoPBRec cpb;
6300   char unixDirName[MAXPATHLEN+1];
6301   DIR *dir;
6302
6303   /* Cache directory name with pointer TempDirName.
6304      Look for it only the first time.  */
6305   if (!TempDirName)
6306     {
6307       err = FindFolder (kOnSystemDisk, kPreferencesFolderType,
6308                         kCreateFolder, &vRefNum, &dirID);
6309       if (err != noErr)
6310         return NULL;
6311
6312       *fullPath = '\0';
6313       cpb.dirInfo.ioNamePtr = dirName;
6314       cpb.dirInfo.ioDrParID = dirID;
6315
6316       /* Standard ref num to full path name loop */
6317       do {
6318         cpb.dirInfo.ioVRefNum = vRefNum;
6319         cpb.dirInfo.ioFDirIndex = -1;
6320         cpb.dirInfo.ioDrDirID = cpb.dirInfo.ioDrParID;
6321
6322         err = PBGetCatInfo (&cpb, false);
6323
6324         p2cstr (dirName);
6325         strcat (dirName, ":");
6326         if (strlen (fullPath) + strlen (dirName) <= MAXPATHLEN)
6327           {
6328             strcat (dirName, fullPath);
6329             strcpy (fullPath, dirName);
6330           }
6331         else
6332           return NULL;
6333       }
6334       while (cpb.dirInfo.ioDrDirID != fsRtDirID && err == noErr);
6335
6336       if (strlen (fullPath) + 6 <= MAXPATHLEN)
6337         strcat (fullPath, "Emacs:");
6338       else
6339         return NULL;
6340
6341       if (Mac2UnixPathname (fullPath, unixDirName, MAXPATHLEN+1) == 0)
6342         return NULL;
6343
6344       dir = opendir (unixDirName);  /* check whether temp directory exists */
6345       if (dir)
6346         closedir (dir);
6347       else if (mkdir (unixDirName, 0700) != 0)  /* create it if not */
6348         return NULL;
6349
6350       TempDirName = (char *) malloc (strlen (unixDirName) + 1);
6351       strcpy (TempDirName, unixDirName);
6352     }
6353
6354   return TempDirName;
6355 }
6356
6357 char *
6358 getenv (const char * name)
6359 {
6360   if (strcmp (name, "TERM") == 0)
6361     return "vt100";
6362   else if (strcmp (name, "TERMCAP") == 0)
6363     /* for debugging purpose when code was still outputting to dumb terminal */
6364     return "d0|vt100|vt100-am|vt100am|dec vt100:do=[do]:co#100:li#32:cl=[cl]:sf=[sf]:km:\
6365 :le=[le]:bs:am:cm=[cm-%d,%d]:nd=[nd]:up=[up]:ce=[ce]:cd=[cd]:so=[so]:se=[se]:\
6366 :us=[us]:ue=[ue]:md=[md]:mr=[mr]:mb=[mb]:me=[me]:is=[is]:\
6367 :rf=/usr/share/lib/tabset/vt100:rs=[rs]:ks=[ks]:ke=[ke]:\
6368 :ku=\\036:kd=\\037:kr=\\035:kl=\\034:kb=[kb]:ho=[ho]:k1=[k1]:k2=[k2]:k3=[k3]:k4=[k4]:\
6369 :pt:sr=[sr]:vt#3:xn:sc=[sc]:rc=[rc]:cs=[cs-%d,%d]";
6370   else if (strcmp (name, "TMPDIR") == 0)
6371     return GetTempDirName ();
6372   else
6373     return (NULL);
6374 }
6375
6376 #ifdef __MRC__
6377 #include <utsname.h>
6378
6379 int
6380 uname (struct utsname *name)
6381 {
6382   char **systemName;
6383   systemName = GetString (-16413);  /* IM - Resource Manager Reference */
6384   if (systemName)
6385     {
6386       BlockMove (*systemName, name->nodename, (*systemName)[0]+1);
6387       p2cstr (name->nodename);
6388     }
6389   else
6390     return -1;
6391 }
6392 #endif
6393
6394 #include <Processes.h>
6395 #include <EPPC.h>
6396
6397 /* Event class of HLE sent to subprocess.  */
6398 const OSType kEmacsSubprocessSend = 'ESND';
6399 /* Event class of HLE sent back from subprocess.  */
6400 const OSType kEmacsSubprocessReply = 'ERPY';
6401
6402 char *
6403 mystrchr (char *s, char c)
6404 {
6405   while (*s && *s != c)
6406     {
6407       if (*s == '\\')
6408         s++;
6409       s++;
6410     }
6411
6412   if (*s)
6413     {
6414       *s = '\0';
6415       return s;
6416     }
6417   else
6418     return NULL;
6419 }
6420
6421 char *
6422 mystrtok (char *s)
6423 {
6424   while (*s)
6425     s++;
6426
6427   return s + 1;
6428 }
6429
6430 void
6431 mystrcpy (char *to, char *from)
6432 {
6433   while (*from)
6434     {
6435       if (*from == '\\')
6436         from++;
6437       *to++ = *from++;
6438     }
6439   *to = '\0';
6440 }
6441
6442 /* Start a Mac subprocess.  Arguments for it is passed in argv (null
6443    terminated).  The process should run with the default directory
6444    "workdir", read input from "infn", and write output and error to
6445    "outfn" and "errfn", resp.  The Process Manager call
6446    LaunchApplication is used to start the subprocess.  We use high
6447    level events as the mechanism to pass arguments to the subprocess
6448    and to make Emacs wait for the subprocess to terminate and pass
6449    back a result code.  The bulk of the code here packs the arguments
6450    into one message to be passed together with the high level event.
6451    Emacs also sometimes starts a subprocess using a shell to perform
6452    wildcard filename expansion.  Since we don't really have a shell on
6453    the Mac, this case is detected and the starting of the shell is
6454    by-passed.  We really need to add code here to do filename
6455    expansion to support such functionality. */
6456 int
6457 run_mac_command (argv, workdir, infn, outfn, errfn)
6458      unsigned char **argv;
6459      const char *workdir;
6460      const char *infn, *outfn, errfn;
6461 {
6462   char macappname[MAXPATHLEN+1], macworkdir[MAXPATHLEN+1];
6463   char macinfn[MAXPATHLEN+1], macoutfn[MAXPATHLEN+1], macerrfn[MAXPATHLEN+1];
6464   int paramlen, argc, newargc, j, retries;
6465   char **newargv, *param, *p;
6466   OSErr iErr;
6467   FSSpec spec;
6468   LaunchParamBlockRec lpbr;
6469   EventRecord sendEvent, replyEvent;
6470   RgnHandle cursorRegionHdl;
6471   TargetID targ;
6472   unsigned long refCon, len;
6473
6474   if (Unix2MacPathname (workdir, macworkdir, MAXPATHLEN+1) == 0)
6475     return -1;
6476   if (Unix2MacPathname (infn, macinfn, MAXPATHLEN+1) == 0)
6477     return -1;
6478   if (Unix2MacPathname (outfn, macoutfn, MAXPATHLEN+1) == 0)
6479     return -1;
6480   if (Unix2MacPathname (errfn, macerrfn, MAXPATHLEN+1) == 0)
6481     return -1;
6482
6483   paramlen = strlen (macworkdir) + strlen (macinfn) + strlen (macoutfn) + strlen (macerrfn) + 4;
6484   /* count nulls at end of strings */
6485
6486   argc = 0;
6487   while (argv[argc])
6488     argc++;
6489
6490   if (argc == 0)
6491     return -1;
6492
6493   /* If a subprocess is invoked with a shell, we receive 3 arguments of the form:
6494      "<path to emacs bins>/sh" "-c" "<path to emacs bins>/<command> <command args>" */
6495   j = strlen (argv[0]);
6496   if (j >= 3 && strcmp (argv[0]+j-3, "/sh") == 0 && argc == 3 && strcmp (argv[1], "-c") == 0)
6497     {
6498       char *command, *t, tempmacpathname[MAXPATHLEN+1];
6499
6500       /* The arguments for the command in argv[2] are separated by spaces.  Count them and put
6501          the count in newargc.  */
6502       command = (char *) alloca (strlen (argv[2])+2);
6503       strcpy (command, argv[2]);
6504       if (command[strlen (command) - 1] != ' ')
6505         strcat (command, " ");
6506
6507       t = command;
6508       newargc = 0;
6509       t = mystrchr (t, ' ');
6510       while (t)
6511         {
6512           newargc++;
6513           t = mystrchr (t+1, ' ');
6514         }
6515
6516       newargv = (char **) alloca (sizeof (char *) * newargc);
6517
6518       t = command;
6519       for (j = 0; j < newargc; j++)
6520         {
6521           newargv[j] = (char *) alloca (strlen (t) + 1);
6522           mystrcpy (newargv[j], t);
6523
6524           t = mystrtok (t);
6525           paramlen += strlen (newargv[j]) + 1;
6526         }
6527
6528       if (strncmp (newargv[0], "~emacs/", 7) == 0)
6529         {
6530           if (Unix2MacPathname (newargv[0], tempmacpathname, MAXPATHLEN+1) == 0)
6531             return -1;
6532         }
6533       else
6534         {  /* sometimes Emacs call "sh" without a path for the command */
6535 #if 0
6536           char *t = (char *) alloca (strlen (newargv[0]) + 7 + 1);
6537           strcpy (t, "~emacs/");
6538           strcat (t, newargv[0]);
6539 #endif
6540           Lisp_Object path;
6541           openp (Vexec_path, build_string (newargv[0]), EXEC_SUFFIXES, &path, 1);
6542
6543           if (NILP (path))
6544             return -1;
6545           if (Unix2MacPathname (XSTRING (path)->data, tempmacpathname, MAXPATHLEN+1) == 0)
6546             return -1;
6547         }
6548       strcpy (macappname, tempmacpathname);
6549     }
6550   else
6551     {
6552       if (Unix2MacPathname (argv[0], macappname, MAXPATHLEN+1) == 0)
6553         return -1;
6554
6555       newargv = (char **) alloca (sizeof (char *) * argc);
6556       newargc = argc;
6557       for (j = 1; j < argc; j++)
6558         {
6559           if (strncmp (argv[j], "~emacs/", 7) == 0)
6560             {
6561               char *t = strchr (argv[j], ' ');
6562               if (t)
6563                 {
6564                   char tempcmdname[MAXPATHLEN+1], tempmaccmdname[MAXPATHLEN+1];
6565                   strncpy (tempcmdname, argv[j], t-argv[j]);
6566                   tempcmdname[t-argv[j]] = '\0';
6567                   if (Unix2MacPathname (tempcmdname, tempmaccmdname, MAXPATHLEN+1) == 0)
6568                     return -1;
6569                   newargv[j] = (char *) alloca (strlen (tempmaccmdname) + strlen (t) + 1);
6570                   strcpy (newargv[j], tempmaccmdname);
6571                   strcat (newargv[j], t);
6572                 }
6573               else
6574                 {
6575                   char tempmaccmdname[MAXPATHLEN+1];
6576                   if (Unix2MacPathname (argv[j], tempmaccmdname, MAXPATHLEN+1) == 0)
6577                     return -1;
6578                   newargv[j] = (char *) alloca (strlen (tempmaccmdname)+1);
6579                   strcpy (newargv[j], tempmaccmdname);
6580                 }
6581             }
6582           else
6583             newargv[j] = argv[j];
6584           paramlen += strlen (newargv[j]) + 1;
6585         }
6586     }
6587
6588   /* After expanding all the arguments, we now know the length of the parameter block to be
6589      sent to the subprocess as a message attached to the HLE. */
6590   param = (char *) malloc (paramlen + 1);
6591   if (!param)
6592     return -1;
6593
6594   p = param;
6595   *p++ = newargc;  /* first byte of message contains number of arguments for command */
6596   strcpy (p, macworkdir);
6597   p += strlen (macworkdir);
6598   *p++ = '\0';  /* null terminate strings sent so it's possible to use strcpy over there */
6599   strcpy (p, macinfn);
6600   p += strlen (macinfn);
6601   *p++ = '\0';
6602   strcpy (p, macoutfn);
6603   p += strlen (macoutfn);
6604   *p++ = '\0';
6605   strcpy (p, macerrfn);
6606   p += strlen (macerrfn);
6607   *p++ = '\0';
6608   for (j = 1; j < newargc; j++) {
6609     strcpy (p, newargv[j]);
6610     p += strlen (newargv[j]);
6611     *p++ = '\0';
6612   }
6613
6614   c2pstr (macappname);
6615
6616   iErr = FSMakeFSSpec (0, 0, macappname, &spec);
6617
6618   if (iErr != noErr) {
6619     free (param);
6620     return -1;
6621   }
6622
6623   lpbr.launchBlockID = extendedBlock;
6624   lpbr.launchEPBLength = extendedBlockLen;
6625   lpbr.launchControlFlags = launchContinue + launchNoFileFlags;
6626   lpbr.launchAppSpec = &spec;
6627   lpbr.launchAppParameters = NULL;
6628
6629   iErr = LaunchApplication (&lpbr);  /* call the subprocess */
6630   if (iErr != noErr) {
6631     free (param);
6632     return -1;
6633   }
6634
6635   sendEvent.what = kHighLevelEvent;
6636   sendEvent.message = kEmacsSubprocessSend;  /* Event ID stored in "where" unused */
6637
6638   retries = 3;
6639   do {  /* OS may think current subprocess has terminated if previous one terminated recently */
6640     iErr = PostHighLevelEvent (&sendEvent, &lpbr.launchProcessSN, 0, param, paramlen + 1, receiverIDisPSN);
6641   }
6642   while (iErr == sessClosedErr && retries-- > 0);
6643
6644   if (iErr != noErr) {
6645     free (param);
6646     return -1;
6647   }
6648
6649   cursorRegionHdl = NewRgn ();
6650
6651   /* Wait for the subprocess to finish, when it will send us a ERPY high level event */
6652   while (1)
6653     if (WaitNextEvent (highLevelEventMask, &replyEvent, 180, cursorRegionHdl) && replyEvent.message == kEmacsSubprocessReply)
6654       break;
6655
6656   /* The return code is sent through the refCon */
6657   iErr = AcceptHighLevelEvent (&targ, &refCon, NULL, &len);
6658   if (iErr != noErr) {
6659     DisposeHandle ((Handle) cursorRegionHdl);
6660     free (param);
6661     return -1;
6662   }
6663
6664   DisposeHandle ((Handle) cursorRegionHdl);
6665   free (param);
6666
6667   return refCon;
6668 }
6669
6670 DIR *
6671 opendir (const char *dirname)
6672 {
6673   char MacPathname[MAXPATHLEN+1];
6674   DIR *dirp;
6675   CInfoPBRec cipb;
6676   int len;
6677
6678   dirp = (DIR *) malloc (sizeof (DIR));
6679   if (!dirp)
6680     return 0;
6681
6682   /* Handle special case when dirname is "/": sets up for readir to
6683      get all mount volumes. */
6684   if (strcmp (dirname, "/") == 0) {
6685     dirp->getting_volumes = 1;  /* special all mounted volumes DIR struct */
6686     dirp->current_index = 1;  /* index for first volume */
6687     return dirp;
6688   }
6689
6690   /* Handle typical cases: not accessing all mounted volumes. */
6691   if (Unix2MacPathname (dirname, MacPathname, MAXPATHLEN+1) == 0)
6692     return 0;
6693
6694   /* Emacs calls opendir without the trailing '/', Mac needs trailing ':' */
6695   len = strlen (MacPathname);
6696   if (MacPathname[len - 1] != ':' && len < MAXPATHLEN)
6697     strcat (MacPathname, ":");
6698
6699   c2pstr (MacPathname);
6700   cipb.hFileInfo.ioNamePtr = MacPathname;  /* using full pathname so vRefNum and dirID ignored */
6701   cipb.hFileInfo.ioVRefNum = 0;
6702   cipb.hFileInfo.ioDirID = 0;
6703   cipb.hFileInfo.ioFDirIndex = 0;  /* set to 0 to get information about specific dir or file */
6704
6705   errno = PBGetCatInfo (&cipb, false);
6706   if (errno != noErr) {
6707     errno = ENOENT;
6708     return 0;
6709   }
6710
6711   if (!(cipb.hFileInfo.ioFlAttrib & 0x10))  /* bit 4 = 1 for directories */
6712     return 0;  /* not a directory */
6713
6714   dirp->dir_id = cipb.dirInfo.ioDrDirID;  /* used later in readdir */
6715   dirp->getting_volumes = 0;
6716   dirp->current_index = 1;  /* index for first file/directory */
6717
6718   return dirp;
6719 }
6720
6721 int
6722 closedir (DIR *dp)
6723 {
6724   free (dp);
6725
6726   return 0;
6727 }
6728
6729 struct dirent *
6730 readdir (DIR *dp)
6731 {
6732   HParamBlockRec HPBlock;
6733   CInfoPBRec cipb;
6734   static struct dirent s_dirent;
6735   static Str255 s_name;
6736   int done;
6737
6738   /* Handle the root directory containing the mounted volumes.  Call
6739      PBHGetVInfo specifying an index to obtain the info for a volume.
6740      PBHGetVInfo returns an error when it receives an index beyond the
6741      last volume, at which time we should return a nil dirent struct
6742      pointer. */
6743   if (dp->getting_volumes) {
6744     HPBlock.volumeParam.ioNamePtr = s_name;
6745     HPBlock.volumeParam.ioVRefNum = 0;
6746     HPBlock.volumeParam.ioVolIndex = dp->current_index;
6747
6748     errno = PBHGetVInfo (&HPBlock, false);
6749     if (errno != noErr) {
6750       errno = ENOENT;
6751       return 0;
6752     }
6753
6754     p2cstr (s_name);
6755     strcat (s_name, "/");  /* need "/" for stat to work correctly */
6756
6757     dp->current_index++;
6758
6759     s_dirent.d_ino = cipb.dirInfo.ioDrDirID;
6760     s_dirent.d_name = s_name;
6761
6762     return &s_dirent;
6763   }
6764   else {
6765     cipb.hFileInfo.ioVRefNum = 0;
6766     cipb.hFileInfo.ioNamePtr = s_name;  /* location to receive filename returned */
6767
6768     /* return only visible files */
6769     done = false;
6770     while (!done) {
6771       cipb.hFileInfo.ioDirID = dp->dir_id;  /* directory ID found by opendir */
6772       cipb.hFileInfo.ioFDirIndex = dp->current_index;
6773
6774       errno = PBGetCatInfo (&cipb, false);
6775       if (errno != noErr) {
6776         errno = ENOENT;
6777         return 0;
6778       }
6779
6780       /* insist on an visibile entry */
6781       if (cipb.hFileInfo.ioFlAttrib & 0x10)  /* directory? */
6782         done = !(cipb.dirInfo.ioDrUsrWds.frFlags & fInvisible);
6783       else
6784         done = !(cipb.hFileInfo.ioFlFndrInfo.fdFlags & fInvisible);
6785
6786       dp->current_index++;
6787     }
6788
6789     p2cstr (s_name);
6790
6791     s_dirent.d_ino = cipb.dirInfo.ioDrDirID;  /* value unimportant: non-zero for valid file */
6792     s_dirent.d_name = s_name;
6793
6794     return &s_dirent;
6795   }
6796 }
6797
6798 char *
6799 getwd (char *path)
6800 {
6801   char MacPathname[MAXPATHLEN+1];
6802   Str255 directoryName;
6803   OSErr errno;
6804   CInfoPBRec cipb;
6805
6806   MacPathname[0] = '\0';
6807   directoryName[0] = '\0';
6808   cipb.dirInfo.ioDrParID = 0;
6809   cipb.dirInfo.ioNamePtr = directoryName;  /* empty string = default directory */
6810
6811   do {
6812     cipb.dirInfo.ioVRefNum = 0;
6813     cipb.dirInfo.ioFDirIndex = -1;
6814     cipb.dirInfo.ioDrDirID = cipb.dirInfo.ioDrParID;  /* go up to parent each time */
6815
6816     errno = PBGetCatInfo (&cipb, false);
6817     if (errno != noErr) {
6818       errno = ENOENT;
6819       return 0;
6820     }
6821
6822     p2cstr (directoryName);
6823     strcat (directoryName, ":");
6824     strcat (directoryName, MacPathname);  /* attach to front since going up directory tree */
6825     strcpy (MacPathname, directoryName);
6826   } while (cipb.dirInfo.ioDrDirID != fsRtDirID);  /* until volume's root directory */
6827
6828   if (Mac2UnixPathname (MacPathname, path, MAXPATHLEN+1) == 0)
6829     return 0;
6830   else
6831     return path;
6832 }
6833
6834 #endif /* macintosh */