![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sysdep.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src|
Return to sysdep.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src |
1.1 ! root 1: /* Interfaces to system-dependent kernel and library entries. ! 2: Copyright (C) 1985 Richard M. Stallman. ! 3: ! 4: This file is part of GNU Emacs. ! 5: ! 6: GNU Emacs is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU Emacs General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU Emacs, but only under the conditions described in the ! 15: GNU Emacs General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU Emacs so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: #include <signal.h> ! 23: ! 24: #include "config.h" ! 25: #include "lisp.h" ! 26: #undef NULL ! 27: ! 28: /* In this file, open, read and write refer to the system calls, ! 29: not our sugared interfaces sys_open, sys_read and sys_write. ! 30: Contrariwise, for systems where we use the system calls directly, ! 31: define sys_read, etc. here as aliases for them. */ ! 32: #ifndef read ! 33: #define sys_read read ! 34: #define sys_write write ! 35: #endif /* `read' is not a macro */ ! 36: ! 37: #undef read ! 38: #undef write ! 39: ! 40: #ifndef open ! 41: #define sys_open open ! 42: #endif /* `open' is not a macro. */ ! 43: ! 44: #undef open ! 45: ! 46: #include <stdio.h> ! 47: #include <sys/types.h> ! 48: #include <sys/stat.h> ! 49: ! 50: #if defined (USG) || (defined (BSD) && !defined (BSD4_1)) ! 51: #include <fcntl.h> ! 52: #endif ! 53: ! 54: #ifdef BSD ! 55: #include <sys/ioctl.h> ! 56: #ifdef BSD4_1 ! 57: #include <wait.h> ! 58: #else /* not 4.1 */ ! 59: #include <sys/wait.h> ! 60: #endif /* not 4.1 */ ! 61: #include <sgtty.h> ! 62: #define TERMINAL struct sgttyb ! 63: #define OSPEED(str) str.sg_ospeed ! 64: #define TABS_OK(str) ((str.sg_flags & XTABS) != XTABS) ! 65: #endif ! 66: ! 67: /* Get rid of LLITOUT in 4.1, since it is said to stimulate kernel bugs. */ ! 68: #ifdef BSD4_1 ! 69: #undef LLITOUT ! 70: #define LLITOUT 0 ! 71: #endif /* 4.1 */ ! 72: ! 73: #ifdef USG ! 74: #include <termio.h> ! 75: #include <sys/utsname.h> ! 76: #include <memory.h> ! 77: #include <string.h> ! 78: #ifdef HAVE_TIMEVAL ! 79: #ifdef HPUX ! 80: #include <time.h> ! 81: #else ! 82: #include <sys/time.h> ! 83: #endif ! 84: #endif /* HAVE_TIMEVAL */ ! 85: #include <errno.h> ! 86: #define TIOCGETP TCGETA ! 87: #define TIOCSETN TCSETA ! 88: #define TIOCSETP TCSETAF ! 89: #define TERMINAL struct termio ! 90: #define OSPEED(str) (str.c_cflag & CBAUD) ! 91: #define TABS_OK(str) ((str.c_oflag & TABDLY) != TAB3) ! 92: #endif /* USG */ ! 93: ! 94: #include "termhooks.h" ! 95: #include "termchar.h" ! 96: #include "termopts.h" ! 97: #include "dispextern.h" ! 98: ! 99: #ifdef NONSYSTEM_DIR_LIBRARY ! 100: #include "ndir.h" ! 101: #endif /* NONSYSTEM_DIR_LIBRARY */ ! 102: ! 103: /* Define SIGCHLD as an alias for SIGCLD. There are many conditionals ! 104: testing SIGCHLD. */ ! 105: ! 106: #if !defined (SIGCHLD) && defined (SIGCLD) ! 107: #define SIGCHLD SIGCLD ! 108: #endif /* SIGCLD and not SIGCHLD */ ! 109: ! 110: static int baud_convert[] = ! 111: { ! 112: 0, 50, 75, 110, 135, 150, 200, 300, 600, 1200, ! 113: 1800, 2400, 4800, 9600, 19200, 38400 ! 114: }; ! 115: ! 116: extern short ospeed; ! 117: ! 118: discard_tty_input () ! 119: { ! 120: TERMINAL buf; ! 121: ! 122: if (noninteractive) ! 123: return; ! 124: ! 125: ioctl (0, TIOCGETP, &buf); ! 126: ioctl (0, TIOCSETP, &buf); ! 127: } ! 128: ! 129: #ifdef SIGTSTP ! 130: ! 131: stuff_char (c) ! 132: char c; ! 133: { ! 134: /* Should perhaps error if in batch mode */ ! 135: #ifdef TIOCSTI ! 136: ioctl (0, TIOCSTI, &c); ! 137: #else /* no TIOCSTI */ ! 138: error ("Cannot stuff terminal input characters in this version of Unix."); ! 139: #endif /* no TIOCSTI */ ! 140: } ! 141: ! 142: #endif /* SIGTSTP */ ! 143: ! 144: init_baud_rate () ! 145: { ! 146: TERMINAL sg; ! 147: ! 148: if (noninteractive) ! 149: ospeed = 0; ! 150: else ! 151: { ! 152: ioctl (0, TIOCGETP, &sg); ! 153: ospeed = OSPEED (sg); ! 154: } ! 155: baud_rate = ospeed == 0 ? 1200 ! 156: : ospeed < sizeof baud_convert / sizeof baud_convert[0] ! 157: ? baud_convert[ospeed] : 9600; ! 158: } ! 159: ! 160: set_exclusive_use (fd) ! 161: int fd; ! 162: { ! 163: #ifdef FIOCLEX ! 164: ioctl (fd, FIOCLEX, 0); ! 165: #endif ! 166: /* Ok to do nothing if this feature does not exist */ ! 167: } ! 168: ! 169: #ifndef subprocesses ! 170: ! 171: wait_without_blocking () ! 172: { ! 173: #ifndef USG ! 174: wait3 (0, WNOHANG | WUNTRACED, 0); ! 175: #else ! 176: croak ("wait_without_blocking"); ! 177: #endif ! 178: } ! 179: ! 180: #endif /* not subprocesses */ ! 181: ! 182: int wait_debugging; /* Set nonzero to make following function work under dbx ! 183: (at least for bsd). */ ! 184: ! 185: /* Wait for subprocess with process id `pid' to terminate and ! 186: make sure it will get eliminated (not remain forever as a zombie) */ ! 187: ! 188: wait_for_termination (pid) ! 189: int pid; ! 190: { ! 191: int status; ! 192: while (1) ! 193: { ! 194: #ifdef subprocesses ! 195: #ifdef BSD ! 196: /* Note that kill returns -1 even if the process is just a zombie now. ! 197: But inevitably a SIGCHLD interrupt should be generated ! 198: and child_sig will do wait3 and make the process go away. */ ! 199: /* There is some indication that there is a bug involved with ! 200: termination of subprocesses, perhaps involving a kernel bug too, ! 201: but no idea what it is. Just as a hunch we signal SIGCHLD to see ! 202: if that causes the problem to go away or get worse. */ ! 203: #ifdef BSD4_1 ! 204: extern int synch_process_pid; ! 205: sighold (SIGCHLD); ! 206: if (synch_process_pid == 0) ! 207: { ! 208: sigrelse (SIGCHLD); ! 209: break; ! 210: } ! 211: if (wait_debugging) ! 212: sleep (1); ! 213: else ! 214: sigpause (SIGCHLD); ! 215: #else /* not BSD4_1 */ ! 216: sigsetmask (1 << (SIGCHLD - 1)); ! 217: if (0 > kill (pid, 0)) ! 218: { ! 219: sigsetmask (0); ! 220: kill (getpid (), SIGCHLD); ! 221: break; ! 222: } ! 223: if (wait_debugging) ! 224: sleep (1); ! 225: else ! 226: sigpause (0); ! 227: #endif /* not BSD4_1 */ ! 228: #else /* not BSD */ ! 229: #ifdef UNIPLUS ! 230: if (0 > kill (pid, 0)) ! 231: break; ! 232: wait (0); ! 233: #else /* neither BSD nor UNIPLUS: random sysV */ ! 234: if (0 > kill (pid, 0)) ! 235: break; ! 236: pause (); ! 237: #endif /* not UNIPLUS */ ! 238: #endif /* not BSD */ ! 239: #else /* not subprocesses */ ! 240: #ifndef BSD4_1 ! 241: if (0 > kill (pid, 0)) ! 242: break; ! 243: wait (0); ! 244: #else /* BSD4_1 */ ! 245: int status; ! 246: status = wait (0); ! 247: if (status == pid || status == -1) ! 248: break; ! 249: #endif /* BSD4_1 */ ! 250: #endif /* not subprocesses */ ! 251: } ! 252: } ! 253: ! 254: /* ! 255: * Insert description of what this command is really supposed to ! 256: * to (I.E. what state is the child process line to be placed into, ! 257: * and why). I have tried to interpret this as much as possible from ! 258: * the BSD setup and map to an appropriate USG control, but don't ! 259: * guarantee the results. fnf@unisoft ! 260: */ ! 261: ! 262: child_setup_tty (out) ! 263: int out; ! 264: { ! 265: TERMINAL s; ! 266: ! 267: ioctl (out, TIOCGETP, &s); ! 268: #ifdef USG ! 269: s.c_oflag |= OPOST; /* Enable output postprocessing */ ! 270: s.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */ ! 271: s.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY); /* No output delays */ ! 272: s.c_lflag &= ~ECHO; /* Disable echo */ ! 273: s.c_lflag &= ~ICANON; /* Disable erase/kill processing */ ! 274: s.c_lflag |= ISIG; /* Enable signals */ ! 275: s.c_iflag &= ~IUCLC; /* Disable map of upper case to lower on input */ ! 276: s.c_oflag &= ~OLCUC; /* Disable map of lower case to upper on output */ ! 277: s.c_cc[VMIN] = 1; /* minimum number of characters to accept */ ! 278: s.c_cc[VTIME] = 0; /* wait forever for at least 1 character */ ! 279: #else /* not USG */ ! 280: s.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE | CBREAK | TANDEM); ! 281: #endif /* not USG */ ! 282: ioctl (out, TIOCSETN, &s); ! 283: ! 284: #ifdef BSD4_1 ! 285: if (interrupt_input) ! 286: reset_sigio (); ! 287: #endif /* BSD4_1 */ ! 288: } ! 289: ! 290: setpgrp_of_tty (pid) ! 291: int pid; ! 292: { ! 293: #ifdef TIOCSPGRP ! 294: ioctl (0, TIOCSPGRP, &pid); ! 295: #else ! 296: /* Just ignore this for now and hope for the best */ ! 297: #endif ! 298: } ! 299: ! 300: #ifdef F_SETFL ! 301: ! 302: init_sigio () ! 303: { ! 304: request_sigio (); ! 305: } ! 306: ! 307: reset_sigio () ! 308: { ! 309: unrequest_sigio (); ! 310: } ! 311: ! 312: #ifdef FASYNC /* F_SETFL does not imply existance of FASYNC */ ! 313: int old_fcntl_flags; ! 314: ! 315: request_sigio () ! 316: { ! 317: old_fcntl_flags = fcntl (0, F_GETFL, 0); ! 318: fcntl (0, F_SETFL, old_fcntl_flags | FASYNC); ! 319: } ! 320: ! 321: unrequest_sigio () ! 322: { ! 323: fcntl (0, F_SETFL, old_fcntl_flags); ! 324: } ! 325: ! 326: #else /* no FASYNC */ ! 327: ! 328: request_sigio () ! 329: { ! 330: croak ("request_sigio"); ! 331: } ! 332: ! 333: unrequest_sigio () ! 334: { ! 335: croak ("unrequest_sigio"); ! 336: } ! 337: ! 338: #endif /* FASYNC */ ! 339: #endif /* F_SETFL */ ! 340: ! 341: TERMINAL old_gtty; /* The initial tty mode bits */ ! 342: ! 343: int term_initted; /* 1 if outer tty status has been recorded */ ! 344: ! 345: #ifdef F_SETOWN ! 346: int old_fcntl_owner; ! 347: #endif /* F_SETOWN */ ! 348: ! 349: #ifdef TIOCGLTC ! 350: struct tchars old_tchars; ! 351: struct ltchars old_ltchars; ! 352: int old_lmode; ! 353: ! 354: int lmode; /* Current lmode value. */ ! 355: /* Needed as global for 4.1 */ ! 356: #endif /* TIOCGLTC */ ! 357: ! 358: /* This may also be defined in stdio, ! 359: but if so, this does no harm, ! 360: and using the same name avoids wasting the other one's space. */ ! 361: ! 362: #ifdef USG ! 363: unsigned char _sobuf[BUFSIZ+8]; ! 364: #else ! 365: char _sobuf[BUFSIZ]; ! 366: #endif ! 367: ! 368: init_sys_modes () ! 369: { ! 370: TERMINAL sg; ! 371: #ifdef TIOCGLTC ! 372: struct tchars tchars; ! 373: static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1}; ! 374: static struct ltchars new_ltchars = {-1,-1,-1,-1,-1,-1}; ! 375: #endif ! 376: ! 377: if (noninteractive) ! 378: return; ! 379: ! 380: ioctl (0, TIOCGETP, &old_gtty); ! 381: if (!read_socket_hook) ! 382: { ! 383: sg = old_gtty; ! 384: ! 385: #ifdef USG ! 386: sg.c_iflag |= (IGNBRK); /* Ignore break condition */ ! 387: sg.c_iflag &= ~ICRNL; /* Disable map of CR to NL on input */ ! 388: #ifdef ISTRIP ! 389: sg.c_iflag &= ~ISTRIP; /* don't strip 8th bit on input */ ! 390: #endif ! 391: sg.c_lflag &= ~ECHO; /* Disable echo */ ! 392: sg.c_lflag &= ~ICANON; /* Disable erase/kill processing */ ! 393: sg.c_lflag |= ISIG; /* Enable signals */ ! 394: if (flow_control) ! 395: { ! 396: sg.c_iflag |= IXON; /* Enable start/stop output control */ ! 397: #ifdef IXANY ! 398: sg.c_iflag &= ~IXANY; ! 399: #endif /* IXANY */ ! 400: } ! 401: else ! 402: sg.c_iflag &= ~IXON; /* Disable start/stop output control */ ! 403: sg.c_oflag &= ~ONLCR; /* Disable map of NL to CR-NL on output */ ! 404: sg.c_oflag &= ~TAB3; /* Disable tab expansion */ ! 405: #ifdef CS8 ! 406: sg.c_cflag |= CS8; /* allow 8th bit on input */ ! 407: sg.c_cflag &= ~PARENB; /* Don't check parity */ ! 408: #endif ! 409: sg.c_cc[VINTR] = '\007'; /* ^G gives SIGINT */ ! 410: #ifdef HPUX ! 411: /* Can't use CDEL as that makes Meta-DEL do SIGQUIT. ! 412: Instead set up C-g for both; we handle both alike ! 413: so which one it really gives us does not matter. */ ! 414: sg.c_cc[VQUIT] = '\007'; ! 415: #else /* not HPUX */ ! 416: sg.c_cc[VQUIT] = CDEL; /* Turn off SIGQUIT */ ! 417: #endif /* not HPUX */ ! 418: sg.c_cc[VMIN] = 1; /* Input should wait for at least 1 char */ ! 419: sg.c_cc[VTIME] = 0; /* no matter how long that takes. */ ! 420: #ifdef VSWTCH ! 421: sg.c_cc[VSWTCH] = CDEL; /* Turn off shell layering use of C-z */ ! 422: #endif /* VSWTCH */ ! 423: #else /* if not USG */ ! 424: sg.sg_flags &= ~(ECHO | CRMOD | XTABS); ! 425: sg.sg_flags |= ANYP; ! 426: sg.sg_flags |= interrupt_input ? RAW : CBREAK; ! 427: #endif /* not USG (BSD, that is) */ ! 428: ! 429: ioctl (0, TIOCSETN, &sg); ! 430: ! 431: #ifdef F_SETFL ! 432: #ifdef F_GETOWN /* F_SETFL does not imply existance of F_GETOWN */ ! 433: if (interrupt_input) ! 434: { ! 435: old_fcntl_owner = fcntl (0, F_GETOWN, 0); ! 436: fcntl (0, F_SETOWN, getpid ()); ! 437: init_sigio (); ! 438: } ! 439: #endif /* F_GETOWN */ ! 440: #endif /* F_SETFL */ ! 441: ! 442: /* If going to use CBREAK mode, we must request C-g to interrupt ! 443: and turn off start and stop chars, etc. ! 444: If not going to use CBREAK mode, do this anyway ! 445: so as to turn off local flow control for user coming over ! 446: network on 4.2; in this case, only t_stopc and t_startc really matter. */ ! 447: #ifdef TIOCGLTC ! 448: ioctl (0, TIOCGETC, &old_tchars); ! 449: ioctl (0, TIOCGLTC, &old_ltchars); ! 450: ioctl (0, TIOCLGET, &old_lmode); ! 451: ! 452: /* Note: if not using CBREAK mode, it makes no difference how we set this */ ! 453: tchars = new_tchars; ! 454: tchars.t_intrc = 07; ! 455: if (flow_control) ! 456: { ! 457: tchars.t_startc = '\021'; ! 458: tchars.t_stopc = '\023'; ! 459: } ! 460: /* LPASS8 is new in 4.3, and makes cbreak mode provide all 8 bits. */ ! 461: #ifndef LPASS8 ! 462: #define LPASS8 0 ! 463: #endif ! 464: ! 465: #ifdef BSD4_1 ! 466: #define LNOFLSH 0100000 ! 467: #endif ! 468: ! 469: lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | old_lmode; ! 470: ! 471: ioctl (0, TIOCSETC, &tchars); ! 472: ioctl (0, TIOCSLTC, &new_ltchars); ! 473: ioctl (0, TIOCLSET, &lmode); ! 474: #endif TIOCGLTC ! 475: #ifdef BSD4_1 ! 476: if (interrupt_input) ! 477: init_sigio (); ! 478: #endif ! 479: } ! 480: screen_garbaged = 1; ! 481: setbuf (stdout, _sobuf); ! 482: term_initted = 1; ! 483: set_terminal_modes (); ! 484: } ! 485: ! 486: /* Return nonzero if safe to use tabs in output. ! 487: At the time this is called, init_sys_modes has not been done yet. */ ! 488: ! 489: tabs_safe_p () ! 490: { ! 491: TERMINAL sg; ! 492: if (noninteractive) ! 493: return 1; ! 494: ioctl (0, TIOCGETP, &sg); ! 495: return (TABS_OK(sg)); ! 496: } ! 497: ! 498: /* Get terminal size from system. ! 499: Store number of lines into *heightp and width into *widthp. ! 500: If zero or a negative number is stored, the value is not valid. */ ! 501: ! 502: get_screen_size (widthp, heightp) ! 503: int *widthp, *heightp; ! 504: { ! 505: /* Define the 4.3 names in terms of the Sun names ! 506: if the latter exist and the former do not. */ ! 507: #if !defined (TIOCGWINSZ) && defined (TIOCGSIZE) ! 508: #define TIOCGWINSZ TIOCGSIZE ! 509: #define winsize ttysize ! 510: #define ws_row ts_lines ! 511: #define ws_col ts_cols ! 512: #endif /* Sun */ ! 513: ! 514: #ifdef TIOCGWINSZ ! 515: struct winsize size; ! 516: *widthp = 0; ! 517: *heightp = 0; ! 518: if (ioctl (0, TIOCGWINSZ, &size) < 0) ! 519: return; ! 520: *widthp = size.ws_col; ! 521: *heightp = size.ws_row; ! 522: #else /* system doesn't know size */ ! 523: *widthp = 0; ! 524: *heightp = 0; ! 525: #endif /* system does not know size */ ! 526: } ! 527: ! 528: reset_sys_modes () ! 529: { ! 530: if (noninteractive) ! 531: { ! 532: fflush (stdout); ! 533: return; ! 534: } ! 535: if (!term_initted) ! 536: return; ! 537: topos (screen_height - 1, 0); ! 538: clear_end_of_line (screen_width); ! 539: /* clear_end_of_line may move the cursor */ ! 540: topos (screen_height - 1, 0); ! 541: reset_terminal_modes (); ! 542: fflush (stdout); ! 543: if (read_socket_hook) ! 544: return; ! 545: #ifdef TIOCGLTC ! 546: ioctl (0, TIOCSETC, &old_tchars); ! 547: ioctl (0, TIOCSLTC, &old_ltchars); ! 548: ioctl (0, TIOCLSET, &old_lmode); ! 549: #endif /* TIOCGLTC */ ! 550: #ifdef F_SETFL ! 551: #ifdef F_SETOWN /* F_SETFL does not imply existance of F_SETOWN */ ! 552: if (interrupt_input) ! 553: { ! 554: #ifdef FASYNC ! 555: old_fcntl_flags &= ~FASYNC; ! 556: #endif /* FASYNC */ ! 557: reset_sigio (); ! 558: reset_sigio (); ! 559: fcntl (0, F_SETOWN, old_fcntl_owner); ! 560: } ! 561: #endif /* F_SETOWN */ ! 562: #endif /* F_SETFL */ ! 563: #ifdef BSD4_1 ! 564: if (interrupt_input) ! 565: reset_sigio (); ! 566: #endif /* BSD4_1 */ ! 567: ioctl (0, TIOCSETN, &old_gtty); ! 568: } ! 569: ! 570: /* ! 571: * flush any pending output ! 572: */ ! 573: ! 574: flush_pending_output (channel) ! 575: int channel; ! 576: { ! 577: #ifdef USG ! 578: ioctl (channel, TCFLSH, 1); ! 579: #else ! 580: ioctl (channel, TIOCFLUSH, 0); ! 581: #endif ! 582: } ! 583: ! 584: /* ! 585: * Return the address of the start of the text segment prior to ! 586: * doing an unexec(). After unexec() the return value is undefined. ! 587: * See crt0.c for further explanation and _start(). ! 588: * ! 589: */ ! 590: ! 591: char * ! 592: start_of_text () ! 593: { ! 594: #ifdef TEXT_START ! 595: return ((char *) TEXT_START); ! 596: #else ! 597: extern int _start (); ! 598: return ((char *) _start); ! 599: #endif ! 600: } ! 601: ! 602: /* ! 603: * Return the address of the start of the data segment prior to ! 604: * doing an unexec(). After unexec() the return value is undefined. ! 605: * See crt0.c for further information and definition of data_start. ! 606: * ! 607: * Apparently, on BSD systems this is etext at startup. On ! 608: * USG systems (swapping) this is highly mmu dependent and ! 609: * is also dependent on whether or not the program is running ! 610: * with shared text. Generally there is a (possibly large) ! 611: * gap between end of text and start of data with shared text. ! 612: * ! 613: * On Uniplus+ systems with shared text, data starts at a ! 614: * fixed address. Each port (from a given oem) is generally ! 615: * different, and the specific value of the start of data can ! 616: * be obtained via the UniPlus+ specific "uvar(2)" system call, ! 617: * however the method outlined in crt0.c seems to be more portable. ! 618: * ! 619: * Probably what will have to happen when a USG unexec is available, ! 620: * at least on UniPlus, is temacs will have to be made unshared so ! 621: * that text and data are contiguous. Then once loadup is complete, ! 622: * unexec will produce a shared executable where the data can be ! 623: * at the normal shared text boundry and the startofdata variable ! 624: * will be patched by unexec to the correct value. ! 625: * ! 626: */ ! 627: ! 628: char * ! 629: start_of_data () ! 630: { ! 631: #ifdef DATA_START ! 632: return ((char *) DATA_START); ! 633: #else ! 634: extern int data_start; ! 635: return ((char *) &data_start); ! 636: #endif ! 637: } ! 638: ! 639: #ifdef NOTDEF ! 640: ! 641: /* ! 642: * Return the address of the end of the text segment prior to ! 643: * doing an unexec(). After unexec() the return value is undefined. ! 644: */ ! 645: ! 646: char * ! 647: end_of_text () ! 648: { ! 649: #ifdef TEXT_END ! 650: return ((char *) TEXT_END); ! 651: #else ! 652: extern int etext; ! 653: return ((char *) &etext); ! 654: #endif ! 655: } ! 656: ! 657: /* ! 658: * Return the address of the end of the data segment prior to ! 659: * doing an unexec(). After unexec() the return value is undefined. ! 660: */ ! 661: ! 662: char * ! 663: end_of_data () ! 664: { ! 665: #ifdef DATA_END ! 666: return ((char *) DATA_END); ! 667: #else ! 668: extern int edata; ! 669: return ((char *) &edata); ! 670: #endif ! 671: } ! 672: ! 673: #endif NOTDEF ! 674: ! 675: ! 676: /* Get_system_name returns as its value ! 677: a string for the Lisp function system-name to return. */ ! 678: ! 679: #ifdef USG ! 680: struct utsname get_system_name_name; ! 681: #endif ! 682: #ifdef BSD4_1 ! 683: #include <whoami.h> ! 684: #endif ! 685: ! 686: char * ! 687: get_system_name () ! 688: { ! 689: #ifdef USG ! 690: uname (&get_system_name_name); ! 691: return (get_system_name_name.nodename); ! 692: #else /* Not USG */ ! 693: #ifdef BSD4_1 ! 694: return sysname; ! 695: #else /* BSD, not 4.1 */ ! 696: static char system_name_saved[32]; ! 697: (void) gethostname (system_name_saved, sizeof (system_name_saved)); ! 698: return (system_name_saved); ! 699: #endif /* BSD, not 4.1 */ ! 700: #endif /* not USG */ ! 701: } ! 702: ! 703: #ifndef HAVE_SELECT ! 704: ! 705: /* Emulate as much as select as is possible under 4.1 and needed by Gnu Emacs ! 706: * Only checks read descriptors. ! 707: */ ! 708: /* How long to wait between checking fds in select */ ! 709: #define SELECT_PAUSE 1 ! 710: int select_alarmed; ! 711: ! 712: select_alarm () ! 713: { ! 714: select_alarmed = 1; ! 715: #ifdef BSD4_1 ! 716: sigrelse (SIGALRM); ! 717: #else /* not BSD4_1 */ ! 718: signal (SIGALRM, SIG_IGN); ! 719: #endif /* not BSD4_1 */ ! 720: } ! 721: ! 722: /* Only rfds are checked and timeout must point somewhere */ ! 723: int ! 724: select (nfds, rfds, wfds, efds, timeout) ! 725: int nfds; ! 726: int *rfds, *wfds, *efds, *timeout; ! 727: { ! 728: int ravail = 0, orfds = 0, old_alarm, val; ! 729: extern int kbd_count; ! 730: extern int proc_buffered_char[]; ! 731: extern int child_changed; ! 732: int (*old_trap) (); ! 733: char buf; ! 734: ! 735: if (rfds) ! 736: { ! 737: orfds = *rfds; ! 738: *rfds = 0; ! 739: } ! 740: if (wfds) ! 741: *wfds = 0; ! 742: if (efds) ! 743: *efds = 0; ! 744: ! 745: /* If we are looking only for the terminal, with no timeout, ! 746: just read it and wait -- that's more efficient. */ ! 747: if (orfds == 1 && *timeout == 100000 && !child_changed) ! 748: { ! 749: if (!kbd_count) ! 750: read_input_waiting (); ! 751: *rfds = 1; ! 752: return 1; ! 753: } ! 754: ! 755: /* Once a second, till the timer expires, check all the flagged read ! 756: * descriptors to see if any input is available. If there is some then ! 757: * set the corresponding bit in the return copy of rfds. ! 758: */ ! 759: while (1) ! 760: { ! 761: register int to_check, bit, fd; ! 762: ! 763: if (rfds) ! 764: { ! 765: for (to_check = nfds, bit = 1, fd = 0; --to_check >= 0; bit <<= 1, fd++) ! 766: { ! 767: if (orfds & bit) ! 768: { ! 769: int avail = 0, status = 0; ! 770: ! 771: if (bit == 1) ! 772: avail = detect_input_pending(); /* Special keyboard handler */ ! 773: else ! 774: { ! 775: #ifdef FIONREAD ! 776: status = ioctl (fd, FIONREAD, &avail); ! 777: #else /* no FIONREAD */ ! 778: /* Hoping it will return -1 if nothing available ! 779: or 0 if all 0 chars requested are read. */ ! 780: if (proc_buffered_char[fd] >= 0) ! 781: avail = 1; ! 782: else ! 783: { ! 784: avail = read (fd, &buf, 1); ! 785: if (avail > 0) ! 786: proc_buffered_char[fd] = buf; ! 787: } ! 788: #endif /* no FIONREAD */ ! 789: } ! 790: if (status >= 0 && avail > 0) ! 791: { ! 792: (*rfds) |= bit; ! 793: ravail++; ! 794: } ! 795: } ! 796: } ! 797: } ! 798: if (*timeout == 0 || ravail != 0 || child_changed) ! 799: break; ! 800: old_alarm = alarm (0); ! 801: old_trap = signal (SIGALRM, select_alarm); ! 802: select_alarmed = 0; ! 803: alarm (SELECT_PAUSE); ! 804: /* Wait for a SIGALRM (or maybe a SIGTINT) */ ! 805: while (select_alarmed == 0 && *timeout != 0 && child_changed == 0) ! 806: { ! 807: /* If we are interested in terminal input, ! 808: wait by reading the terminal. ! 809: That makes instant wakeup for terminal input at least. */ ! 810: if (orfds & 1) ! 811: { ! 812: read_input_waiting (); ! 813: if (kbd_count) ! 814: select_alarmed = 1; ! 815: } ! 816: else ! 817: pause(); ! 818: } ! 819: (*timeout) -= SELECT_PAUSE; ! 820: /* Reset the old alarm if there was one */ ! 821: alarm (0); ! 822: signal (SIGALRM, old_trap); ! 823: if (old_alarm != 0) ! 824: { ! 825: /* Reset or forge an interrupt for the original handler. */ ! 826: old_alarm -= SELECT_PAUSE; ! 827: if (old_alarm <= 0) ! 828: kill (getpid (), SIGALRM); /* Fake an alarm with the orig' handler */ ! 829: else ! 830: alarm (old_alarm); ! 831: } ! 832: if (*timeout == 0) /* Stop on timer being cleared */ ! 833: break; ! 834: } ! 835: return ravail; ! 836: } ! 837: ! 838: /* Read keyboard input into the standard buffer, ! 839: waiting for at least one character. */ ! 840: ! 841: read_input_waiting () ! 842: { ! 843: extern int kbd_count; ! 844: extern unsigned char kbd_buffer[]; ! 845: extern unsigned char *kbd_ptr; ! 846: int val = read (fileno(stdin), kbd_buffer, 1); ! 847: if (val > 0) ! 848: { ! 849: kbd_ptr = kbd_buffer; ! 850: kbd_count = val; ! 851: } ! 852: } ! 853: ! 854: #endif /* not HAVE_SELECT */ ! 855: ! 856: #ifdef BSD4_1 ! 857: /* VARARGS */ ! 858: setpriority () ! 859: { ! 860: return 0; ! 861: } ! 862: ! 863: /* ! 864: * Partially emulate 4.2 open call. ! 865: * open is defined as this in 4.1. ! 866: * ! 867: * - added by Michael Bloom @ Citicorp/TTI ! 868: * ! 869: */ ! 870: ! 871: int ! 872: sys_open (path, oflag, mode) ! 873: char *path; ! 874: int oflag, mode; ! 875: { ! 876: if (oflag & O_CREAT) ! 877: return creat (path, mode); ! 878: else ! 879: return open (path, oflag); ! 880: } ! 881: ! 882: init_sigio () ! 883: { ! 884: if (noninteractive) ! 885: return; ! 886: lmode = LINTRUP | lmode; ! 887: ioctl (0, TIOCLSET, &lmode); ! 888: } ! 889: ! 890: reset_sigio () ! 891: { ! 892: if (noninteractive) ! 893: return; ! 894: lmode = ~LINTRUP & lmode; ! 895: ioctl (0, TIOCLSET, &lmode); ! 896: } ! 897: ! 898: request_sigio () ! 899: { ! 900: sigrelse (SIGTINT); ! 901: } ! 902: ! 903: unrequest_sigio () ! 904: { ! 905: sighold (SIGTINT); ! 906: } ! 907: ! 908: /* still inside #ifdef BSD4_1 */ ! 909: #ifdef subprocesses ! 910: ! 911: int sigheld; /* Mask of held signals */ ! 912: ! 913: sigholdx (signum) ! 914: int signum; ! 915: { ! 916: sigheld |= sigbit (signum); ! 917: sighold (signum); ! 918: } ! 919: ! 920: sigisheld (signum) ! 921: int signum; ! 922: { ! 923: sigheld |= sigbit (signum); ! 924: } ! 925: ! 926: sigunhold (signum) ! 927: int signum; ! 928: { ! 929: sigheld &= ~sigbit (signum); ! 930: sigrelse (signum); ! 931: } ! 932: ! 933: sigfree () /* Free all held signals */ ! 934: { ! 935: int i; ! 936: for (i = 0; i < NSIG; i++) ! 937: if (sigheld & sigbit (i)) ! 938: sigrelse (i); ! 939: sigheld = 0; ! 940: } ! 941: ! 942: sigbit (i) ! 943: { ! 944: return 1 << (i - 1); ! 945: } ! 946: #endif /* subprocesses */ ! 947: #endif /* BSD4_1 */ ! 948: ! 949: #ifndef BSTRING ! 950: ! 951: void ! 952: bzero (b, length) ! 953: register char *b; ! 954: register int length; ! 955: { ! 956: while (length-- > 0) ! 957: *b++ = 0; ! 958: } ! 959: ! 960: void ! 961: bcopy (b1, b2, length) ! 962: register char *b1; ! 963: register char *b2; ! 964: register int length; ! 965: { ! 966: while (length-- > 0) ! 967: *b2++ = *b1++; ! 968: } ! 969: ! 970: int ! 971: bcmp (b1, b2, length) /* This could be a macro! */ ! 972: register char *b1; ! 973: register char *b2; ! 974: register int length; ! 975: { ! 976: while (length-- > 0) ! 977: if (*b1++ != *b2++) ! 978: return 1; ! 979: ! 980: return 0; ! 981: } ! 982: #endif /* not BSTRING */ ! 983: ! 984: #if defined (BSD4_1) || defined (USG) ! 985: ! 986: /* ! 987: * The BSD random(3) returns numbers in the range of ! 988: * 0 to 2e31 - 1. The USG rand(3C) returns numbers in the ! 989: * range of 0 to 2e15 - 1. This is probably not significant ! 990: * in this usage. ! 991: */ ! 992: ! 993: long ! 994: random () ! 995: { ! 996: return (rand ()); ! 997: } ! 998: ! 999: srandom (arg) ! 1000: int arg; ! 1001: { ! 1002: srand (arg); ! 1003: } ! 1004: ! 1005: #endif /* bsd4.1 or any USG */ ! 1006: ! 1007: #ifdef USG ! 1008: /* ! 1009: * All of the following are for USG. ! 1010: * ! 1011: * On USG systems the system calls are interruptable by signals ! 1012: * that the user program has elected to catch. Thus the system call ! 1013: * must be retried in these cases. To handle this without massive ! 1014: * changes in the source code, we remap the standard system call names ! 1015: * to names for our own functions in sysdep.c that do the system call ! 1016: * with retries. Actually, for portability reasons, it is good ! 1017: * programming practice, as this example shows, to limit all actual ! 1018: * system calls to a single occurance in the source. Sure, this ! 1019: * adds an extra level of function call overhead but it is almost ! 1020: * always negligible. Fred Fish, Unisoft Systems Inc. ! 1021: */ ! 1022: ! 1023: char *sys_siglist[NSIG + 1] = ! 1024: { ! 1025: "bogus signal", /* 0 */ ! 1026: "hangup", /* 1 SIGHUP */ ! 1027: "interrupt", /* 2 SIGINT */ ! 1028: "quit", /* 3 SIGQUIT */ ! 1029: "illegal instruction", /* 4 SIGILL */ ! 1030: "trace trap", /* 5 SIGTRAP */ ! 1031: "IOT instruction", /* 6 SIGIOT */ ! 1032: "EMT instruction", /* 7 SIGEMT */ ! 1033: "floating point exception", /* 8 SIGFPE */ ! 1034: "kill", /* 9 SIGKILL */ ! 1035: "bus error", /* 10 SIGBUS */ ! 1036: "segmentation violation", /* 11 SIGSEGV */ ! 1037: "bad argument to system call", /* 12 SIGSYS */ ! 1038: "write on a pipe with no one to read it", /* 13 SIGPIPE */ ! 1039: "alarm clock", /* 14 SIGALRM */ ! 1040: "software termination signum", /* 15 SIGTERM */ ! 1041: "user defined signal 1", /* 16 SIGUSR1 */ ! 1042: "user defined signal 2", /* 17 SIGUSR2 */ ! 1043: "death of a child", /* 18 SIGCLD */ ! 1044: "power-fail restart", /* 19 SIGPWR */ ! 1045: 0 ! 1046: }; ! 1047: ! 1048: int ! 1049: sys_read (fildes, buf, nbyte) ! 1050: int fildes; ! 1051: char *buf; ! 1052: unsigned int nbyte; ! 1053: { ! 1054: register int rtnval; ! 1055: ! 1056: while ((rtnval = read (fildes, buf, nbyte)) == -1 && errno == EINTR); ! 1057: return (rtnval); ! 1058: } ! 1059: ! 1060: int ! 1061: /* VARARGS 2 */ ! 1062: sys_open (path, oflag, mode) ! 1063: char *path; ! 1064: int oflag, mode; ! 1065: { ! 1066: register int rtnval; ! 1067: ! 1068: while ((rtnval = open (path, oflag, mode)) == -1 && errno == EINTR); ! 1069: return (rtnval); ! 1070: } ! 1071: ! 1072: int ! 1073: sys_write (fildes, buf, nbyte) ! 1074: int fildes; ! 1075: char *buf; ! 1076: unsigned int nbyte; ! 1077: { ! 1078: register int rtnval; ! 1079: ! 1080: while ((rtnval = write (fildes, buf, nbyte)) == -1 && errno == EINTR); ! 1081: return (rtnval); ! 1082: } ! 1083: ! 1084: /* ! 1085: * Warning, this function may not duplicate 4.2 action properly ! 1086: * under error conditions. ! 1087: */ ! 1088: ! 1089: #ifndef MAXPATHLEN ! 1090: /* In 4.1, param.h fails to define this. */ ! 1091: #define MAXPATHLEN 1024 ! 1092: #endif ! 1093: ! 1094: char * ! 1095: getwd (pathname) ! 1096: char *pathname; ! 1097: { ! 1098: extern char *getcwd (); ! 1099: ! 1100: return (getcwd (pathname, MAXPATHLEN)); ! 1101: } ! 1102: ! 1103: /* ! 1104: * Emulate rename using unlink/link. Note that this is ! 1105: * only partially correct. Also, doesn't enforce restriction ! 1106: * that files be of same type (regular->regular, dir->dir, etc). ! 1107: */ ! 1108: ! 1109: rename (from, to) ! 1110: char *from; ! 1111: char *to; ! 1112: { ! 1113: if (access (from, 0) == 0) ! 1114: { ! 1115: unlink (to); ! 1116: if (link (from, to) == 0) ! 1117: if (unlink (from) == 0) ! 1118: return (0); ! 1119: } ! 1120: return (-1); ! 1121: } ! 1122: ! 1123: /* VARARGS */ ! 1124: setpriority () ! 1125: { ! 1126: return (0); ! 1127: } ! 1128: ! 1129: #ifndef HPUX ! 1130: ! 1131: /* ! 1132: * Substitute fork(2) for vfork(2) on USG flavors. ! 1133: */ ! 1134: ! 1135: vfork () ! 1136: { ! 1137: return (fork ()); ! 1138: } ! 1139: ! 1140: /* ! 1141: * Emulate BSD dup2(2). First close newd if it already exists. ! 1142: * Then, attempt to dup oldd. If not successful, call dup2 recursively ! 1143: * until we are, then close the unsuccessful ones. ! 1144: */ ! 1145: ! 1146: dup2 (oldd, newd) ! 1147: int oldd; ! 1148: int newd; ! 1149: { ! 1150: register int fd; ! 1151: ! 1152: close (newd); ! 1153: while ((fd = dup (oldd)) != newd) { ! 1154: dup2 (oldd, newd); ! 1155: close (fd); ! 1156: } ! 1157: } ! 1158: ! 1159: /* ! 1160: * Gettimeofday. Simulate as much as possible. Only accurate ! 1161: * to nearest second. Emacs doesn't use tzp so ignore it for now. ! 1162: * Only needed when subprocesses are defined. ! 1163: */ ! 1164: ! 1165: #if defined(subprocesses) && !defined(STRIDE) && defined(HAVE_TIMEVAL) ! 1166: ! 1167: /* ARGSUSED */ ! 1168: gettimeofday (tp, tzp) ! 1169: struct timeval *tp; ! 1170: struct timezone *tzp; ! 1171: { ! 1172: extern long time (); ! 1173: ! 1174: tp->tv_sec = time ((long *)0); ! 1175: tp->tv_usec = 0; ! 1176: } ! 1177: ! 1178: #endif /* subprocess && ~STRIDE && HAVE_TIMEVAL */ ! 1179: #endif /* not HPUX */ ! 1180: ! 1181: /* ! 1182: * This function will go away as soon as all the stubs fixed. (fnf) ! 1183: */ ! 1184: ! 1185: croak (badfunc) ! 1186: char *badfunc; ! 1187: { ! 1188: printf ("%s not yet implemented\r\n", badfunc); ! 1189: reset_sys_modes (); ! 1190: exit (1); ! 1191: } ! 1192: ! 1193: #endif /* USG */ ! 1194: ! 1195: /* Directory routines for systems that don't have them. */ ! 1196: ! 1197: #ifdef NONSYSTEM_DIR_LIBRARY ! 1198: ! 1199: DIR * ! 1200: opendir (filename) ! 1201: char *filename; /* name of directory */ ! 1202: { ! 1203: register DIR *dirp; /* -> malloc'ed storage */ ! 1204: register int fd; /* file descriptor for read */ ! 1205: struct stat sbuf; /* result of fstat() */ ! 1206: ! 1207: fd = sys_open (filename, 0); ! 1208: if (fd < 0) ! 1209: return 0; ! 1210: ! 1211: if (fstat (fd, &sbuf) < 0 ! 1212: || (sbuf.st_mode & S_IFMT) != S_IFDIR ! 1213: || (dirp = (DIR *) malloc (sizeof (DIR))) == 0) ! 1214: { ! 1215: close (fd); ! 1216: return 0; /* bad luck today */ ! 1217: } ! 1218: ! 1219: dirp->dd_fd = fd; ! 1220: dirp->dd_loc = dirp->dd_size = 0; /* refill needed */ ! 1221: ! 1222: return dirp; ! 1223: } ! 1224: ! 1225: void ! 1226: closedir (dirp) ! 1227: register DIR *dirp; /* stream from opendir() */ ! 1228: { ! 1229: close (dirp->dd_fd); ! 1230: free ((char *) dirp); ! 1231: } ! 1232: ! 1233: ! 1234: #define DIRSIZ 14 ! 1235: struct olddir ! 1236: { ! 1237: ino_t od_ino; /* inode */ ! 1238: char od_name[DIRSIZ]; /* filename */ ! 1239: }; ! 1240: ! 1241: struct direct dir_static; /* simulated directory contents */ ! 1242: ! 1243: struct direct * ! 1244: readdir (dirp) ! 1245: register DIR *dirp; /* stream from opendir() */ ! 1246: { ! 1247: register struct olddir *dp; /* -> directory data */ ! 1248: ! 1249: for ( ; ; ) ! 1250: { ! 1251: if (dirp->dd_loc >= dirp->dd_size) ! 1252: dirp->dd_loc = dirp->dd_size = 0; ! 1253: ! 1254: if (dirp->dd_size == 0 /* refill buffer */ ! 1255: && (dirp->dd_size = sys_read (dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ)) <= 0) ! 1256: return 0; ! 1257: ! 1258: dp = (struct olddir *) &dirp->dd_buf[dirp->dd_loc]; ! 1259: dirp->dd_loc += sizeof (struct olddir); ! 1260: ! 1261: if (dp->od_ino != 0) /* not deleted entry */ ! 1262: { ! 1263: dir_static.d_ino = dp->od_ino; ! 1264: strncpy (dir_static.d_name, dp->od_name, DIRSIZ); ! 1265: dir_static.d_name[DIRSIZ] = '\0'; ! 1266: dir_static.d_namlen = strlen (dir_static.d_name); ! 1267: dir_static.d_reclen = sizeof (struct direct) ! 1268: - MAXNAMLEN + 3 ! 1269: + dir_static.d_namlen - dir_static.d_namlen % 4; ! 1270: return &dir_static; /* -> simulated structure */ ! 1271: } ! 1272: } ! 1273: } ! 1274: ! 1275: #endif /* NONSYSTEM_DIR_LIBRARY */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.