![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jove.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / jove|
Return to jove.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / jove |
1.1 ! root 1: /************************************************************************* ! 2: * This program is copyright (C) 1985, 1986 by Jonathan Payne. It is * ! 3: * provided to you without charge for use only on a licensed Unix * ! 4: * system. You may copy JOVE provided that this notice is included with * ! 5: * the copy. You may not sell copies of this program or versions * ! 6: * modified for use on microcomputer systems, unless the copies are * ! 7: * included with a Unix system distribution and the source is provided. * ! 8: *************************************************************************/ ! 9: ! 10: /* Contains the main loop initializations, and some system dependent ! 11: type things, e.g. putting terminal in CBREAK mode, etc. */ ! 12: ! 13: #include "jove.h" ! 14: #include "io.h" ! 15: #include "termcap.h" ! 16: ! 17: #include <varargs.h> ! 18: #include <sys/stat.h> ! 19: #include <signal.h> ! 20: #include <errno.h> ! 21: #ifndef SYSV ! 22: #include <sgtty.h> ! 23: #include <fcntl.h> ! 24: #else ! 25: #include <termio.h> ! 26: #endif SYSV ! 27: ! 28: #ifdef TIOCSLTC ! 29: struct ltchars ls1, ! 30: ls2; ! 31: #endif TIOCSLTC ! 32: ! 33: #ifdef TIOCGETC ! 34: struct tchars tc1, ! 35: tc2; ! 36: #endif ! 37: ! 38: #ifdef BRLUNIX ! 39: struct sg_brl sg1, sg2; ! 40: #else ! 41: #ifdef SYSV ! 42: struct termio sg1, sg2; ! 43: #else SYSV ! 44: struct sgttyb sg1, sg2; ! 45: #endif SYSV ! 46: #endif BRLUNIX ! 47: ! 48: #ifdef BIFF ! 49: private struct stat tt_stat; /* for biff */ ! 50: #ifndef BSD4_2 ! 51: private char *tt_name = 0; /* name of the control tty */ ! 52: extern char *ttyname(); /* for systems w/o fchmod ... */ ! 53: #endif ! 54: private int dw_biff = NO; /* whether or not to fotz at all */ ! 55: #endif ! 56: ! 57: time_t time0; /* when jove started up */ ! 58: int errormsg; ! 59: extern char *tfname; ! 60: char NullStr[] = ""; ! 61: ! 62: finish(code) ! 63: { ! 64: int CoreDump = (code != 0 && code != SIGHUP), ! 65: DelTmps = 1; /* Usually we delete them. */ ! 66: ! 67: #ifdef LSRHS ! 68: if (CoreDump) ! 69: setdump(1); ! 70: #endif ! 71: if (code == SIGINT) { ! 72: char c; ! 73: ! 74: #ifndef MENLO_JCL ! 75: (void) signal(code, finish); ! 76: #endif ! 77: f_mess("Abort (Type 'n' if you're not sure)? "); ! 78: (void) read(0, &c, 1); ! 79: message(NullStr); ! 80: if ((c & 0377) != 'y') { ! 81: redisplay(); ! 82: return; ! 83: } ! 84: } ! 85: ttyset(OFF); ! 86: UnsetTerm(NullStr); ! 87: if (code != 0) { ! 88: if (!Crashing) { ! 89: Crashing++; ! 90: lsave(); ! 91: SyncRec(); ! 92: printf("JOVE CRASH!! (code %d)\n", code); ! 93: if (ModBufs(1)) { ! 94: printf("Your buffers have been saved.\n"); ! 95: printf("Use \"jove_recover\" or \"jove -r\"\n"); ! 96: printf("to have a look at them.\n"); ! 97: DelTmps = 0; /* Don't delete anymore. */ ! 98: } else ! 99: printf("You didn't lose any work.\n"); ! 100: } else ! 101: printf("\r\nYou may have lost your work!\n"); ! 102: } ! 103: flusho(); ! 104: if (DelTmps) { ! 105: tmpclose(); ! 106: recclose(); ! 107: } ! 108: if (CoreDump) ! 109: abort(); ! 110: #ifdef PROFILING ! 111: exit(exp_p); ! 112: #else ! 113: _exit(exp_p); ! 114: #endif ! 115: } ! 116: ! 117: private char smbuf[20], ! 118: *bp = smbuf; ! 119: private int nchars = 0; ! 120: ! 121: private char peekbuf[10], ! 122: *peekp = peekbuf; ! 123: ! 124: #ifdef SYSV ! 125: void ! 126: setblock(fd, on) /* turn blocking on or off */ ! 127: register int fd, on; ! 128: { ! 129: static int blockf, nonblockf; ! 130: static int first = 1; ! 131: int flags; ! 132: ! 133: if (first) { ! 134: first = 0; ! 135: if ((flags = fcntl(fd, F_GETFL, 0)) == -1) ! 136: finish(SIGHUP); ! 137: blockf = flags & ~O_NDELAY; /* make sure O_NDELAY is off */ ! 138: nonblockf = flags | O_NDELAY; /* make sure O_NDELAY is on */ ! 139: } ! 140: if (fcntl(fd, F_SETFL, on ? blockf : nonblockf) == -1) ! 141: finish(SIGHUP); ! 142: return; ! 143: } ! 144: #endif SYSV ! 145: ! 146: Peekc() ! 147: { ! 148: int c; ! 149: ! 150: if (peekp == peekbuf) ! 151: c = -1; ! 152: else ! 153: c = *--peekp & 0377; ! 154: return c; ! 155: } ! 156: ! 157: Ungetc(c) ! 158: { ! 159: if (peekp == &peekbuf[(sizeof peekbuf) - 1]) ! 160: return; /* Sorry, can't oblige you ... */ ! 161: *peekp++ = c; ! 162: } ! 163: ! 164: char *Inputp = 0; ! 165: ! 166: #ifdef IPROCS ! 167: #ifdef PIPEPROCS ! 168: getchar() ! 169: { ! 170: extern int errno; ! 171: register int c; ! 172: ! 173: if (nchars <= 0) { ! 174: do ! 175: nchars = read(0, smbuf, sizeof smbuf); ! 176: #ifdef SYSV ! 177: while (nchars == 0 || (nchars < 0 && errno == EINTR)); ! 178: if (nchars < 0) ! 179: #else ! 180: while (nchars < 0 && errno == EINTR); ! 181: if (nchars <= 0) ! 182: #endif SYSV ! 183: finish(SIGHUP); ! 184: bp = smbuf; ! 185: InputPending = nchars > 1; ! 186: } ! 187: if (((c = *bp) & 0200) && MetaKey != 0) { ! 188: *bp = (c & 0177); ! 189: return '\033'; ! 190: } ! 191: nchars--; ! 192: return (*bp++ & 0177); ! 193: } ! 194: #else PIPEPROCS ! 195: getchar() ! 196: { ! 197: extern int global_fd, ! 198: NumProcs, ! 199: errno; ! 200: register int tmp, ! 201: nfds; ! 202: int reads, ! 203: c; ! 204: ! 205: if (nchars <= 0) { ! 206: /* Get a character from the keyboard, first checking for ! 207: any input from a process. Handle that first, and then ! 208: deal with the terminal input. */ ! 209: if (NumProcs > 0) { ! 210: do { ! 211: do { ! 212: reads = global_fd; ! 213: nfds = select(32, &reads, (int *) 0, (int *) 0, (struct timeval *) 0); ! 214: } while (nfds < 0 && errno == EINTR); ! 215: ! 216: switch (nfds) { ! 217: case -1: ! 218: printf("\rerror %d in select %d", errno, global_fd); ! 219: global_fd = 1; ! 220: break; ! 221: default: ! 222: if (reads & 01) { ! 223: nchars = read(0, smbuf, sizeof(smbuf)); ! 224: reads &= ~01; ! 225: --nfds; ! 226: } ! 227: ! 228: while (nfds--) { ! 229: tmp = ffs(reads) - 1; ! 230: read_proc(tmp); ! 231: reads &= ~tmp; ! 232: } ! 233: ! 234: break; ! 235: } ! 236: } while (nchars <= 0); ! 237: } else { ! 238: do ! 239: nchars = read(0, smbuf, sizeof(smbuf)); ! 240: while (nchars < 0 && errno == EINTR); ! 241: } ! 242: ! 243: if (nchars <= 0) ! 244: finish(SIGHUP); ! 245: ! 246: bp = smbuf; ! 247: InputPending = (nchars > 1); ! 248: } ! 249: ! 250: if (((c = *bp) & 0200) && MetaKey != 0) { ! 251: *bp = (c & 0177); ! 252: return '\033'; ! 253: } ! 254: nchars--; ! 255: return *bp++ & 0377; ! 256: } ! 257: #endif PIPEPROCS ! 258: #else IPROCS ! 259: getchar() ! 260: { ! 261: extern int errno; ! 262: register int c; ! 263: ! 264: if (nchars <= 0) { ! 265: do ! 266: nchars = read(0, smbuf, sizeof smbuf); ! 267: while (nchars < 0 && errno == EINTR); ! 268: ! 269: if (nchars <= 0) ! 270: finish(SIGHUP); ! 271: bp = smbuf; ! 272: InputPending = nchars > 1; ! 273: } ! 274: if (((c = *bp) & 0200) && MetaKey != 0) { ! 275: *bp = (c & 0177); ! 276: return '\033'; ! 277: } ! 278: nchars--; ! 279: return *bp++ & 0377; ! 280: } ! 281: #endif IPROCS ! 282: ! 283: int InputPending = 0; ! 284: ! 285: /* Returns non-zero if a character waiting */ ! 286: ! 287: charp() ! 288: { ! 289: int some = 0; ! 290: ! 291: if (InJoverc != 0 || nchars > 0 || Inputp != 0) ! 292: return 1; ! 293: #ifdef BRLUNIX ! 294: { ! 295: static struct sg_brl gttyBuf; ! 296: ! 297: gtty(0, (char *) >tyBuf); ! 298: if (gttyBuf.sg_xflags & INWAIT) ! 299: some++; ! 300: } ! 301: #endif ! 302: #ifdef FIONREAD ! 303: { ! 304: long c; ! 305: ! 306: if (ioctl(0, FIONREAD, (struct sgttyb *) &c) == -1) ! 307: c = 0; ! 308: some = (c > 0); ! 309: } ! 310: #endif FIONREAD ! 311: #ifdef SYSV ! 312: setblock(0, 0); /* turn blocking off */ ! 313: nchars = read(0, smbuf, sizeof smbuf); /* Is anything there? */ ! 314: setblock(0, 1); /* turn blocking on */ ! 315: if (nchars > 0) /* something was there */ ! 316: bp = smbuf; /* make sure bp points to it */ ! 317: some = (nchars > 0); /* just say we found something */ ! 318: #endif SYSV ! 319: #ifdef c70 ! 320: some = !empty(0); ! 321: #endif ! 322: return some; ! 323: } ! 324: ! 325: ResetTerm() ! 326: { ! 327: putpad(TI, 1); ! 328: putpad(VS, 1); ! 329: putpad(KS, 1); ! 330: #ifdef BIFF ! 331: if (BiffChk != dw_biff) ! 332: biff_init(); ! 333: /* just in case we changed our minds about whether to deal with ! 334: biff */ ! 335: #endif ! 336: chkmail(YES); /* force it to check to we can be accurate */ ! 337: do_sgtty(); /* this is so if you change baudrate or stuff ! 338: like that, JOVE will notice. */ ! 339: ttyset(ON); ! 340: } ! 341: ! 342: UnsetTerm(mesg) ! 343: char *mesg; ! 344: { ! 345: ttyset(OFF); ! 346: putpad(KE, 1); ! 347: putpad(VE, 1); ! 348: putpad(TE, 1); ! 349: #ifdef ID_CHAR ! 350: INSmode(0); ! 351: #endif ! 352: Placur(ILI, 0); ! 353: printf("%s", mesg); ! 354: putpad(CE, 1); ! 355: flusho(); ! 356: } ! 357: ! 358: #ifdef JOB_CONTROL ! 359: PauseJove() ! 360: { ! 361: UnsetTerm(ModBufs(0) ? "[There are modified buffers]" : NullStr); ! 362: (void) kill(0, SIGTSTP); ! 363: ResetTerm(); ! 364: ClAndRedraw(); ! 365: } ! 366: #endif ! 367: ! 368: Push() ! 369: { ! 370: int pid; ! 371: ! 372: switch (pid = fork()) { ! 373: case -1: ! 374: complain("[Fork failed]"); ! 375: ! 376: case 0: ! 377: UnsetTerm(NullStr); ! 378: (void) signal(SIGTERM, SIG_DFL); ! 379: (void) signal(SIGINT, SIG_DFL); ! 380: execl(Shell, basename(Shell), 0); ! 381: message("[Execl failed]"); ! 382: _exit(1); ! 383: ! 384: default: ! 385: { ! 386: int (*old_int)() = signal(SIGINT, SIG_IGN); ! 387: int (*old_quit)() = signal(SIGQUIT, SIG_IGN); ! 388: ! 389: #ifdef IPROCS ! 390: sighold(SIGCHLD); ! 391: #endif ! 392: dowait(pid, (int *) 0); ! 393: #ifdef IPROCS ! 394: sigrelse(SIGCHLD); ! 395: #endif ! 396: ResetTerm(); ! 397: ClAndRedraw(); ! 398: (void) signal(SIGINT, old_int); ! 399: (void) signal(SIGQUIT, old_quit); ! 400: } ! 401: } ! 402: } ! 403: ! 404: int OKXonXoff = 0; /* ^S and ^Q initially DON'T work */ ! 405: ! 406: ttsize() ! 407: { ! 408: #ifdef TIOCGWINSZ ! 409: struct winsize win; ! 410: ! 411: if (ioctl (0, TIOCGWINSZ, &win) == 0) { ! 412: if (win.ws_col) ! 413: CO = win.ws_col; ! 414: if (win.ws_row) ! 415: LI = win.ws_row; ! 416: } ! 417: #else TIOCGWINSZ ! 418: #ifdef BTL_BLIT ! 419: #include <sys/jioctl.h> ! 420: struct jwinsize jwin; ! 421: ! 422: if (ioctl(0, JWINSIZE, &jwin) == 0) { ! 423: if (jwin.bytesx) ! 424: CO = jwin.bytesx; ! 425: if (jwin.bytesy) ! 426: LI = jwin.bytesy; ! 427: } ! 428: #endif BTL_BLIT ! 429: #endif TIOCGWINSZ ! 430: ILI = LI - 1; ! 431: } ! 432: ! 433: #ifdef BIFF ! 434: biff_init() ! 435: { ! 436: dw_biff = ((BiffChk) && ! 437: #ifndef BSD4_2 ! 438: ((tt_name != 0) || (tt_name = ttyname(0))) && ! 439: (stat(tt_name, &tt_stat) != -1) && ! 440: #else ! 441: (fstat(0, &tt_stat) != -1) && ! 442: #endif ! 443: (tt_stat.st_mode & S_IEXEC)); /* he's using biff */ ! 444: ! 445: } ! 446: ! 447: biff(on) ! 448: { ! 449: if (dw_biff == NO) ! 450: return; ! 451: #ifndef BSD4_2 ! 452: (void) chmod(tt_name, on ? tt_stat.st_mode : ! 453: (tt_stat.st_mode & ~S_IEXEC)); ! 454: #else ! 455: (void) fchmod(0, on ? tt_stat.st_mode : ! 456: (tt_stat.st_mode & ~S_IEXEC)); ! 457: #endif ! 458: } ! 459: ! 460: #endif ! 461: ! 462: ttinit() ! 463: { ! 464: #ifdef BIFF ! 465: biff_init(); ! 466: #endif ! 467: #ifdef TIOCSLTC ! 468: (void) ioctl(0, TIOCGLTC, (struct sgttyb *) &ls1); ! 469: ls2 = ls1; ! 470: ls2.t_suspc = (char) -1; ! 471: ls2.t_dsuspc = (char) -1; ! 472: ls2.t_flushc = (char) -1; ! 473: ls2.t_lnextc = (char) -1; ! 474: #endif ! 475: ! 476: #ifdef TIOCGETC ! 477: /* Change interupt and quit. */ ! 478: (void) ioctl(0, TIOCGETC, (struct sgttyb *) &tc1); ! 479: tc2 = tc1; ! 480: tc2.t_intrc = CTL(]); ! 481: tc2.t_quitc = (char) -1; ! 482: if (OKXonXoff) { ! 483: tc2.t_stopc = (char) -1; ! 484: tc2.t_startc = (char) -1; ! 485: } ! 486: #endif TIOCGETC ! 487: do_sgtty(); ! 488: } ! 489: ! 490: private int done_ttinit = 0; ! 491: ! 492: do_sgtty() ! 493: { ! 494: #ifdef SYSV ! 495: (void) ioctl(0, TCGETA, (char *) &sg1); ! 496: #else ! 497: (void) gtty(0, &sg1); ! 498: #endif SYSV ! 499: sg2 = sg1; ! 500: ! 501: #ifdef SYSV ! 502: TABS = !((sg1.c_oflag & TAB3) == TAB3); ! 503: ospeed = sg1.c_cflag & CBAUD; ! 504: ! 505: sg2.c_iflag &= ~(INLCR|ICRNL|IGNCR); ! 506: sg2.c_lflag &= ~(ISIG|ICANON|ECHO); ! 507: sg2.c_oflag &= ~(OCRNL|ONLCR); ! 508: sg2.c_cc[VMIN] = sizeof smbuf; ! 509: sg2.c_cc[VTIME] = 1; ! 510: #else ! 511: TABS = !(sg1.sg_flags & XTABS); ! 512: ospeed = sg1.sg_ospeed; ! 513: #ifdef BRLUNIX ! 514: sg2.sg_flags &= ~(ECHO | CRMOD); ! 515: sg2.sg_flags |= CBREAK; ! 516: ! 517: /* VT100 Kludge: leave STALL on for flow control if DC3DC1 (Yuck.) */ ! 518: sg2.sg_xflags &= ~((sg2.sg_xflags&DC3DC1 ? 0 : STALL) | PAGE); ! 519: #else ! 520: sg2.sg_flags &= ~(ECHO | CRMOD); ! 521: #endif BRLUNIX ! 522: ! 523: #ifdef EUNICE ! 524: sg2.sg_flags |= RAW; /* Eunice needs RAW mode last I heard. */ ! 525: #else ! 526: #ifdef PURDUE_EE ! 527: # ifdef pdp11 ! 528: sg2.sg_flags |= RAW; ! 529: # else ! 530: sg2.sg_flags |= (MetaKey ? RAW : CBREAK); ! 531: # endif ! 532: #else ! 533: sg2.sg_flags |= (MetaKey ? RAW : CBREAK); ! 534: #endif PURDUE_EE ! 535: #endif EUNICE ! 536: #endif SYSV ! 537: } ! 538: ! 539: tty_reset() ! 540: { ! 541: if (!done_ttinit) ! 542: return; ! 543: ttyset(OFF); /* go back to original modes */ ! 544: ttinit(); ! 545: ttyset(ON); ! 546: } ! 547: ! 548: /* If n is OFF reset to original modes */ ! 549: ! 550: ttyset(n) ! 551: { ! 552: if (!done_ttinit && n == 0) /* Try to reset before we've set! */ ! 553: return; ! 554: #ifdef SYSV ! 555: (void) ioctl(0, TCSETAW, n == 0 ? (struct sgttyb *) &sg1 : (struct sgttyb *) &sg2); ! 556: #else ! 557: #ifdef BRLUNIX ! 558: (void) stty(0, n == 0 ? (struct sgttyb *) &sg1 : (struct sgttyb *) &sg2); ! 559: #else ! 560: (void) ioctl(0, TIOCSETN, n == 0 ? (struct sgttyb *) &sg1 : (struct sgttyb *) &sg2); ! 561: #endif BRLUNIX ! 562: #endif SYSV ! 563: ! 564: #ifdef TIOCSETC ! 565: (void) ioctl(0, TIOCSETC, n == 0 ? (struct sgttyb *) &tc1 : (struct sgttyb *) &tc2); ! 566: #endif TIOCSETC ! 567: #ifdef TIOCSLTC ! 568: (void) ioctl(0, TIOCSLTC, n == 0 ? (struct sgttyb *) &ls1 : (struct sgttyb *) &ls2); ! 569: #endif TIOCSLTC ! 570: done_ttinit = 1; ! 571: #ifdef BIFF ! 572: biff(!n); ! 573: #endif ! 574: } ! 575: ! 576: int this_cmd, ! 577: last_cmd; ! 578: ! 579: dispatch(c) ! 580: register int c; ! 581: { ! 582: data_obj *cp; ! 583: ! 584: this_cmd = 0; ! 585: cp = mainmap[c & 0177]; ! 586: ! 587: if (cp == 0) { ! 588: rbell(); ! 589: exp = 1; ! 590: exp_p = errormsg = 0; ! 591: message(NullStr); ! 592: return; ! 593: } ! 594: ExecCmd(cp); ! 595: } ! 596: ! 597: int LastKeyStruck, ! 598: MetaKey = 0; ! 599: ! 600: getch() ! 601: { ! 602: register int c, ! 603: peekc; ! 604: #ifdef IPROCS ! 605: extern int NumProcs; ! 606: #endif ! 607: extern int ModCount, ! 608: Interactive; ! 609: ! 610: if (Inputp) { ! 611: if ((c = *Inputp++) != 0) ! 612: return LastKeyStruck = c; ! 613: Inputp = 0; ! 614: } ! 615: ! 616: if (InJoverc) ! 617: return EOF; /* somethings wrong if Inputp runs out while ! 618: we're reading a .joverc file. */ ! 619: ! 620: if (ModCount >= SyncFreq) { ! 621: ModCount = 0; ! 622: SyncRec(); ! 623: } ! 624: ! 625: /* If we're not interactive and we're not executing a macro, ! 626: AND there are no ungetc'd characters, we read from the ! 627: terminal (i.e., getch()). And characters only get put ! 628: in macros from inside this if. */ ! 629: if (((peekc = c = Peekc()) == -1) && (Interactive || ((c = mac_getc()) == -1))) { ! 630: /* So messages that aren't error messages don't ! 631: hang around forever. */ ! 632: if (!UpdMesg && !Asking) { /* Don't erase if we are asking */ ! 633: if (mesgbuf[0] && !errormsg) ! 634: message(NullStr); ! 635: } ! 636: redisplay(); ! 637: #ifdef IPROCS ! 638: # ifdef PIPEPROCS ! 639: if (NumProcs > 0) { ! 640: sigrelse(INPUT_SIG); ! 641: sigrelse(SIGCHLD); ! 642: } ! 643: # endif ! 644: #endif ! 645: inIOread = 1; ! 646: if ((c = getchar()) == EOF) ! 647: finish(SIGHUP); ! 648: inIOread = 0; ! 649: ! 650: #ifdef IPROCS ! 651: # ifdef PIPEPROCS ! 652: if (NumProcs > 0) { ! 653: sighold(INPUT_SIG); ! 654: sighold(SIGCHLD); ! 655: } ! 656: # endif ! 657: #endif ! 658: if (!Interactive && (KeyMacro.m_flags & DEFINE)) ! 659: mac_putc(c); ! 660: } ! 661: if (peekc == -1) /* Don't add_stroke peekc's */ ! 662: add_stroke(c); ! 663: return LastKeyStruck = c; ! 664: } ! 665: ! 666: dorecover() ! 667: { ! 668: execl(RECOVER, "jove_recover", 0); ! 669: printf("%s: execl failed!\n", RECOVER); ! 670: flusho(); ! 671: _exit(-1); ! 672: } ! 673: ! 674: ! 675: ShowVersion() ! 676: { ! 677: extern char *version; ! 678: ! 679: s_mess("Jonathan's Own Version of Emacs (%s)", version); ! 680: } ! 681: ! 682: UNIX_cmdline(argc, argv) ! 683: char *argv[]; ! 684: { ! 685: int lineno = 0, ! 686: nwinds = 1; ! 687: Buffer *b; ! 688: ! 689: ShowVersion(); ! 690: while (argc > 1) { ! 691: if (argv[1][0] != '-' && argv[1][0] != '+') { ! 692: int force = (nwinds > 0 || lineno != 0); ! 693: ! 694: minib_add(argv[1], force ? YES : NO); ! 695: b = do_find(nwinds > 0 ? curwind : (Window *) 0, ! 696: argv[1], force); ! 697: if (force) { ! 698: SetABuf(curbuf); ! 699: SetBuf(b); ! 700: SetLine(next_line(curbuf->b_first, lineno)); ! 701: if (nwinds > 1) ! 702: NextWindow(); ! 703: if (nwinds) ! 704: nwinds--; ! 705: } ! 706: lineno = 0; ! 707: } else switch (argv[1][1]) { ! 708: case 'd': ! 709: ++argv; ! 710: --argc; ! 711: break; ! 712: ! 713: case 'j': /* Ignore .joverc in HOME */ ! 714: break; ! 715: ! 716: case 'p': ! 717: ++argv; ! 718: --argc; ! 719: SetBuf(do_find(curwind, argv[1], 0)); ! 720: ParseAll(); ! 721: nwinds = 0; ! 722: break; ! 723: ! 724: case 't': ! 725: ++argv; ! 726: --argc; ! 727: exp_p = 1; ! 728: find_tag(argv[1], YES); ! 729: break; ! 730: ! 731: case 'w': ! 732: if (argv[1][2] == '\0') ! 733: nwinds++; ! 734: else ! 735: nwinds += -1 + chr_to_int(&argv[1][2], 10, NIL); ! 736: (void) div_wind(curwind, nwinds - 1); ! 737: break; ! 738: ! 739: case '0': ! 740: case '1': ! 741: case '2': ! 742: case '3': ! 743: case '4': ! 744: case '5': ! 745: case '6': ! 746: case '7': ! 747: case '8': ! 748: case '9': ! 749: lineno = chr_to_int(&argv[1][1], 10, 0) - 1; ! 750: break; ! 751: } ! 752: ++argv; ! 753: --argc; ! 754: } ! 755: } ! 756: ! 757: #ifdef lint ! 758: Ignore(a) ! 759: char *a; ! 760: { ! 761: ! 762: a = a; ! 763: } ! 764: ! 765: Ignorf(a) ! 766: int (*a)(); ! 767: { ! 768: ! 769: a = a; ! 770: } ! 771: ! 772: Ignorl(a) ! 773: long a; ! 774: { ! 775: a = a; ! 776: } ! 777: #endif ! 778: ! 779: /* VARARGS1 */ ! 780: ! 781: error(fmt, va_alist) ! 782: char *fmt; ! 783: va_dcl ! 784: { ! 785: va_list ap; ! 786: ! 787: if (fmt) { ! 788: va_start(ap); ! 789: format(mesgbuf, sizeof mesgbuf, fmt, ap); ! 790: va_end(ap); ! 791: UpdMesg++; ! 792: } ! 793: rbell(); ! 794: (void) longjmp(mainjmp, ERROR); ! 795: } ! 796: ! 797: /* VARARGS1 */ ! 798: ! 799: complain(fmt, va_alist) ! 800: char *fmt; ! 801: va_dcl ! 802: { ! 803: va_list ap; ! 804: ! 805: if (fmt) { ! 806: va_start(ap); ! 807: format(mesgbuf, sizeof mesgbuf, fmt, ap); ! 808: va_end(ap); ! 809: UpdMesg++; ! 810: } ! 811: rbell(); ! 812: (void) longjmp(mainjmp, COMPLAIN); ! 813: } ! 814: ! 815: /* VARARGS1 */ ! 816: ! 817: confirm(fmt, va_alist) ! 818: char *fmt; ! 819: va_dcl ! 820: { ! 821: char *yorn; ! 822: va_list ap; ! 823: ! 824: va_start(ap); ! 825: format(mesgbuf, sizeof mesgbuf, fmt, ap); ! 826: va_end(ap); ! 827: yorn = ask((char *) 0, mesgbuf); ! 828: if (*yorn != 'Y' && *yorn != 'y') ! 829: (void) longjmp(mainjmp, COMPLAIN); ! 830: } ! 831: ! 832: int RecDepth = 0; ! 833: ! 834: Recur() ! 835: { ! 836: char bname[128]; ! 837: Mark *m; ! 838: ! 839: sprintf(bname, "%s", curbuf->b_name); ! 840: m = MakeMark(curline, curchar, FLOATER); ! 841: ! 842: RecDepth++; ! 843: UpdModLine++; ! 844: DoKeys(1); /* 1 means not first time */ ! 845: UpdModLine++; ! 846: RecDepth--; ! 847: SetBuf(do_select(curwind, bname)); ! 848: if (!exp_p) ! 849: ToMark(m); ! 850: DelMark(m); ! 851: } ! 852: ! 853: jmp_buf mainjmp; ! 854: int iniargc; /* main sets these for DoKeys() */ ! 855: char **iniargv; ! 856: ! 857: DoKeys(nocmdline) ! 858: { ! 859: int c; ! 860: jmp_buf savejmp; ! 861: ! 862: push_env(savejmp); ! 863: ! 864: switch (setjmp(mainjmp)) { ! 865: case 0: ! 866: if (!nocmdline) ! 867: UNIX_cmdline(iniargc, iniargv); ! 868: break; ! 869: ! 870: case QUIT: ! 871: if (RecDepth == 0) { ! 872: if (ModMacs()) { ! 873: rbell(); ! 874: if (Upper(*ask("No", ! 875: "Some MACROS haven't been saved; leave anyway? ")) != 'Y') ! 876: break; ! 877: } ! 878: if (ModBufs(0)) { ! 879: rbell(); ! 880: if (Upper(*ask("No", ! 881: "Some buffers haven't been saved; leave anyway? ")) != 'Y') ! 882: break; ! 883: } ! 884: #ifdef IPROCS ! 885: KillProcs(); ! 886: #endif ! 887: } ! 888: pop_env(savejmp); ! 889: return; ! 890: ! 891: case ERROR: ! 892: getDOT(); /* God knows what state linebuf was in */ ! 893: ! 894: case COMPLAIN: ! 895: gc_openfiles(); /* close any files we left open */ ! 896: errormsg++; ! 897: fix_macros(); ! 898: Asking = 0; ! 899: curwind->w_bufp = curbuf; ! 900: redisplay(); ! 901: break; ! 902: } ! 903: ! 904: this_cmd = last_cmd = 0; ! 905: ! 906: for (;;) { ! 907: if (this_cmd != ARG_CMD) { ! 908: exp = 1; ! 909: exp_p = 0; ! 910: last_cmd = this_cmd; ! 911: init_strokes(); ! 912: } ! 913: c = getch(); ! 914: if (c == -1) ! 915: continue; ! 916: dispatch(c); ! 917: } ! 918: } ! 919: ! 920: int Crashing = 0; ! 921: ! 922: char ** ! 923: scanvec(args, str) ! 924: register char **args, ! 925: *str; ! 926: { ! 927: while (*args) { ! 928: if (strcmp(*args, str) == 0) ! 929: return args; ! 930: args++; ! 931: } ! 932: return 0; ! 933: } ! 934: ! 935: int UpdFreq = 30, ! 936: inIOread = 0; ! 937: ! 938: updmode() ! 939: { ! 940: UpdModLine++; ! 941: if (inIOread) ! 942: redisplay(); ! 943: #ifndef JOB_CONTROL ! 944: (void) signal(SIGALRM, updmode); ! 945: #endif ! 946: (void) alarm((unsigned) UpdFreq); ! 947: } ! 948: ! 949: #ifdef TIOCGWINSZ ! 950: #ifdef SIGWINCH ! 951: extern win_reshape(); ! 952: #endif ! 953: #endif ! 954: ! 955: #ifdef TIOCGWINSZ ! 956: #ifdef SIGWINCH ! 957: win_reshape() ! 958: { ! 959: register int diff; ! 960: ! 961: (void) signal(SIGWINCH, SIG_IGN); ! 962: ! 963: /* ! 964: * Save old number of lines. ! 965: */ ! 966: diff = LI; ! 967: ! 968: /* ! 969: * Get new line/col info. ! 970: */ ! 971: ttsize(); ! 972: ! 973: /* ! 974: * LI has changed, and now holds the ! 975: * new value. See how much the size ! 976: * changed. ! 977: */ ! 978: diff = LI - diff; ! 979: ! 980: /* ! 981: * Change the size of the current window ! 982: * only. If they shrank by more than ! 983: * the window size, tough. ! 984: */ ! 985: if ((curwind->w_height + diff) < 2) ! 986: curwind->w_height = 2; ! 987: else ! 988: curwind->w_height += diff; ! 989: ! 990: make_scr(); ! 991: redisplay(); ! 992: ! 993: (void) signal(SIGWINCH, win_reshape); ! 994: } ! 995: #endif ! 996: #endif ! 997: ! 998: main(argc, argv) ! 999: char *argv[]; ! 1000: { ! 1001: char ttbuf[512], ! 1002: #ifndef VMUNIX ! 1003: s_iobuff[LBSIZE], ! 1004: s_genbuf[LBSIZE], ! 1005: s_linebuf[LBSIZE], ! 1006: #endif ! 1007: *cp; ! 1008: ! 1009: ! 1010: #ifndef VMUNIX ! 1011: /* The way I look at it, there ain't no way I is gonna run ! 1012: out of stack space UNLESS I have some kind of infinite ! 1013: recursive bug. So why use up some valuable memory, when ! 1014: there is plenty of space on the stack? (This only matters ! 1015: on wimpy pdp11's, of course.) */ ! 1016: ! 1017: iobuff = s_iobuff; ! 1018: genbuf = s_genbuf; ! 1019: linebuf = s_linebuf; ! 1020: #endif ! 1021: ! 1022: errormsg = 0; ! 1023: ! 1024: iniargc = argc; ! 1025: iniargv = argv; ! 1026: ! 1027: if (setjmp(mainjmp)) { ! 1028: printf("\rAck! I can't deal with error \"%s\" now.\n\r", mesgbuf); ! 1029: finish(0); ! 1030: } ! 1031: ! 1032: if (scanvec(argv, "-r")) ! 1033: dorecover(); ! 1034: ! 1035: getTERM(); /* Get terminal. */ ! 1036: if (getenv("METAKEY")) ! 1037: MetaKey = 1; ! 1038: ttsize(); ! 1039: InitCM(); ! 1040: ! 1041: tmpinit(); /* Init temp file. */ ! 1042: ! 1043: if (cp = getenv("SHELL")) ! 1044: strcpy(Shell, cp); ! 1045: ! 1046: make_scr(); ! 1047: mac_init(); /* Initialize Macros */ ! 1048: winit(); /* Initialize Window */ ! 1049: #ifdef IPROCS ! 1050: pinit(); /* Pipes/process initialization */ ! 1051: #endif ! 1052: SetBuf(do_select(curwind, Mainbuf)); ! 1053: ! 1054: #ifdef CHDIR ! 1055: { ! 1056: char **argp; ! 1057: ! 1058: if ((argp = scanvec(argv, "-d")) && (argp[1][0] == '/')) ! 1059: setCWD(argp[1]); ! 1060: else ! 1061: getCWD(); /* After we setup curbuf in case we have to getwd() */ ! 1062: } ! 1063: #endif ! 1064: HomeDir = getenv("HOME"); ! 1065: if (HomeDir == 0) ! 1066: HomeDir = "/"; ! 1067: HomeLen = strlen(HomeDir); ! 1068: (void) joverc(JOVERC); ! 1069: if (!scanvec(argv, "-j")) { ! 1070: char tmpbuf[100]; ! 1071: ! 1072: sprintf(tmpbuf, "%s/.joverc", HomeDir); ! 1073: (void) joverc(tmpbuf); ! 1074: } ! 1075: #ifdef SYSV ! 1076: sprintf(MailBox, "/usr/mail/%s", getenv("LOGNAME")); ! 1077: #else ! 1078: sprintf(Mailbox, "/usr/spool/mail/%s", getenv("USER")); ! 1079: #endif SYSV ! 1080: (void) time(&time0); ! 1081: ttinit(); /* initialize terminal (after ~/.joverc) */ ! 1082: settout(ttbuf); /* not until we know baudrate */ ! 1083: ResetTerm(); ! 1084: ! 1085: (void) signal(SIGHUP, finish); ! 1086: (void) signal(SIGINT, finish); ! 1087: (void) signal(SIGQUIT, SIG_IGN); ! 1088: (void) signal(SIGBUS, finish); ! 1089: (void) signal(SIGSEGV, finish); ! 1090: (void) signal(SIGPIPE, finish); ! 1091: (void) signal(SIGTERM, SIG_IGN); ! 1092: #ifdef TIOCGWINSZ ! 1093: #ifdef SIGWINCH ! 1094: (void) signal(SIGWINCH, win_reshape); ! 1095: #endif ! 1096: #endif ! 1097: ! 1098: /* set things up to update the modeline every UpdFreq seconds */ ! 1099: (void) signal(SIGALRM, updmode); ! 1100: (void) alarm((unsigned) UpdFreq); ! 1101: ! 1102: cl_scr(1); ! 1103: flusho(); ! 1104: RedrawDisplay(); /* start the redisplay process. */ ! 1105: DoKeys(0); ! 1106: finish(0); ! 1107: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.