![[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] / 43BSDTahoe / new / jove|
Return to jove.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: /* Contains the main loop initializations, and some system dependent
9: type things, e.g. putting terminal in CBREAK mode, etc. */
10:
11: #include "jove.h"
12: #include "io.h"
13: #include "termcap.h"
14:
15: #ifdef MAC
16: # include "mac.h"
17: #else
18: # include <varargs.h>
19: # include <sys/stat.h>
20: #endif
21:
22: #include <signal.h>
23: #include <errno.h>
24:
25: #ifdef UNIX
26: # ifndef SYSV
27: # include <sgtty.h>
28: # else
29: # include <termio.h>
30: # endif /* SYSV */
31: #endif /* UNIX */
32:
33: #ifdef MSDOS
34: # include <process.h>
35: #endif /* MSDOS */
36:
37: #ifndef MAC
38: # include <fcntl.h>
39: #endif
40:
41: #ifdef MAC
42: # undef private
43: # define private
44: #endif
45:
46: #ifdef LINT_ARGS
47: extern long time(long *);
48: private void break_off(void);
49: private void break_rst(void);
50: #else
51: extern long time();
52: private void break_off();
53: private void break_rst();
54: #endif
55:
56: #ifdef MAC
57: # undef private
58: # define private static
59: #endif
60:
61: #ifdef UNIX
62: # ifdef TIOCSLTC
63: struct ltchars ls1, ls2;
64: # endif /* TIOCSLTC */
65:
66: # ifdef TIOCGETC
67: struct tchars tc1, tc2;
68: # endif
69:
70: # ifdef PASS8 /* use pass8 instead of raw for meta-key */
71: int lmword1, lmword2; /* local mode word */
72: # endif
73:
74: # ifdef BRLUNIX
75: struct sg_brl sg1, sg2;
76: # else
77: # ifdef SYSV
78: struct termio sg1, sg2;
79: # else /* SYSV */
80: struct sgttyb sg1, sg2;
81: # endif /* SYSV */
82: # endif /* BRLUNIX */
83:
84: # ifdef BIFF
85: private struct stat tt_stat; /* for biff */
86: # ifndef BSD4_2
87: private char *tt_name = 0; /* name of the control tty */
88: extern char *ttyname(); /* for systems w/o fchmod ... */
89: # endif
90: private int dw_biff = NO; /* whether or not to fotz at all */
91: # endif /* BIFF */
92: #endif /* UNIX */
93:
94: int errormsg;
95: extern char *tfname;
96: char NullStr[] = "";
97:
98: #ifdef MSDOS
99: # define SIGHUP 99
100: #endif /* MSDOS */
101:
102: void
103: finish(code)
104: {
105: int CoreDump = (code != 0 && code != SIGHUP),
106: DelTmps = 1; /* Usually we delete them. */
107:
108: if (code == SIGINT) {
109: char c;
110:
111: #ifndef MENLO_JCL
112: (void) signal(code, finish);
113: #endif
114: f_mess("Abort (Type 'n' if you're not sure)? ");
115: #ifndef MSDOS
116: (void) read(0, &c, 1);
117: #else /* MSDOS */
118: c = getrawinchar();
119: #endif /* MSDOS */
120: message(NullStr);
121: if ((c & 0377) != 'y') {
122: redisplay();
123: return;
124: }
125: }
126: ttyset(OFF);
127: UnsetTerm(NullStr);
128: #ifndef MSDOS
129: if (code != 0) {
130: if (!Crashing) {
131: Crashing = YES;
132: lsave();
133: SyncRec();
134: printf("JOVE CRASH!! (code %d)\n", code);
135: if (ModBufs(1)) {
136: printf("Your buffers have been saved.\n");
137: printf("Use \"jove -r\" to have a look at them.\n");
138: DelTmps = 0; /* Don't delete anymore. */
139: } else
140: printf("You didn't lose any work.\n");
141: } else
142: printf("\r\nYou may have lost your work!\n");
143: }
144: #endif /* MSDOS */
145: flusho();
146: if (DelTmps) {
147: tmpclose();
148: #ifndef MSDOS
149: recclose();
150: #endif /* MSDOS */
151: }
152: #ifdef UNIX
153: if (CoreDump)
154: abort();
155: #ifdef PROFILING
156: exit(0);
157: #else
158: _exit(0);
159: #endif
160: #else /* MSDOS or MAC*/
161: #ifdef MSDOS
162: break_rst(); /* restore previous ctrl-c handling */
163: #endif
164: exit(0);
165: #endif /* UNIX */
166: }
167:
168: private char smbuf[20],
169: *bp = smbuf;
170: private int nchars = 0;
171:
172: private char peekbuf[10],
173: *peekp = peekbuf;
174:
175: #if defined(SYSV) || defined(M_XENIX)
176: void
177: setblock(fd, on) /* turn blocking on or off */
178: register int fd, on;
179: {
180: static int blockf, nonblockf;
181: static int first = 1;
182: int flags;
183:
184: if (first) {
185: first = 0;
186: if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
187: finish(SIGHUP);
188: blockf = flags & ~O_NDELAY; /* make sure O_NDELAY is off */
189: nonblockf = flags | O_NDELAY; /* make sure O_NDELAY is on */
190: }
191: if (fcntl(fd, F_SETFL, on ? blockf : nonblockf) == -1)
192: finish(SIGHUP);
193: }
194: #endif /* SYSV */
195:
196: int
197: Peekc()
198: {
199: int c;
200:
201: if (peekp == peekbuf)
202: c = -1;
203: else
204: c = *--peekp & 0377;
205: return c;
206: }
207:
208: void
209: Ungetc(c)
210: {
211: if (peekp == &peekbuf[(sizeof peekbuf) - 1])
212: return; /* Sorry, can't oblige you ... */
213: *peekp++ = c;
214: }
215:
216: int InputPending = 0;
217:
218: char *Inputp = 0;
219:
220: #if (defined(IPROCS) && !defined(PIPEPROCS)) /* that is, if ptys */
221: getchar()
222: {
223: extern long global_fd;
224: long reads;
225: extern int NumProcs,
226: errno;
227: register int tmp,
228: nfds;
229: int c;
230:
231: if (nchars <= 0) {
232: /* Get a character from the keyboard, first checking for
233: any input from a process. Handle that first, and then
234: deal with the terminal input. */
235: do {
236: do {
237: reads = global_fd;
238: nfds = select(32, &reads, (long *) 0, (long *) 0, (struct timeval *) 0);
239: } while (nfds < 0 && errno == EINTR);
240:
241: if (nfds == -1)
242: complain("\rerror %d in select %ld", errno, global_fd);
243: else {
244: if (reads & 01) {
245: nchars = read(0, smbuf, sizeof(smbuf));
246: reads &= ~01;
247: nfds -= 1;
248: }
249: while (nfds--) {
250: tmp = ffs(reads) - 1;
251: read_proc(tmp);
252: reads &= ~(1L << tmp);
253: }
254: }
255: } while (nchars <= 0);
256:
257: if (nchars <= 0)
258: finish(SIGHUP);
259:
260: bp = smbuf;
261: InputPending = (nchars > 1);
262: }
263:
264: if (((c = *bp) & 0200) && MetaKey != 0) {
265: *bp = (c & CHARMASK);
266: return '\033';
267: }
268: nchars -= 1;
269: return *bp++ & 0377;
270: }
271:
272: #else
273:
274: getchar()
275: {
276: extern int errno;
277: register int c;
278:
279: if (nchars <= 0) {
280: bp = smbuf;
281: #ifdef MSDOS
282: *bp = getrawinchar();
283: nchars = 1;
284: #else
285: do
286: nchars = read(0, smbuf, sizeof smbuf);
287: # ifdef SYSV
288: while (nchars == 0 || (nchars < 0 && errno == EINTR));
289: if (nchars < 0)
290: # else
291: while (nchars < 0 && errno == EINTR);
292: if (nchars <= 0)
293: # endif /* SYSV */
294: finish(SIGHUP);
295: #endif MSDOS
296: InputPending = nchars > 1;
297: }
298: if (((c = *bp) & 0200) && MetaKey != 0) {
299: *bp = (c & CHARMASK);
300: return '\033';
301: }
302: nchars -= 1;
303: return (*bp++ & CHARMASK);
304: }
305:
306: #endif /* IPROCS */
307:
308: /* Returns non-zero if a character waiting */
309:
310: int
311: charp()
312: {
313: #ifndef MSDOS
314: int some = 0;
315: #endif /* MSDOS */
316:
317: if (InJoverc != 0 || nchars > 0 || Inputp != 0)
318: return 1;
319: #ifdef BRLUNIX
320: {
321: static struct sg_brl gttyBuf;
322:
323: gtty(0, (char *) >tyBuf);
324: if (gttyBuf.sg_xflags & INWAIT)
325: some += 1;
326: }
327: #endif
328: #ifdef FIONREAD
329: {
330: long c;
331:
332: if (ioctl(0, FIONREAD, (struct sgttyb *) &c) == -1)
333: c = 0;
334: some = (c > 0);
335: }
336: #endif /* FIONREAD */
337: #if defined(SYSV) || defined(M_XENIX)
338: setblock(0, 0); /* turn blocking off */
339: nchars = read(0, smbuf, sizeof smbuf); /* Is anything there? */
340: setblock(0, 1); /* turn blocking on */
341: if (nchars > 0) /* something was there */
342: bp = smbuf; /* make sure bp points to it */
343: some = (nchars > 0); /* just say we found something */
344: #endif /* SYSV */
345: #ifdef c70
346: some = !empty(0);
347: #endif
348: #ifdef MSDOS
349: return rawkey_ready();
350: #else
351: #ifdef MAC
352: some = rawchkc();
353: #endif
354: return some;
355: #endif /* MSDOS */
356: }
357:
358: #ifdef TERMCAP
359: void
360: ResetTerm()
361: {
362: putpad(TI, 1);
363: putpad(VS, 1);
364: putpad(KS, 1);
365: #ifndef MSDOS
366: (void) chkmail(YES); /* force it to check to we can be accurate */
367: #endif
368: #ifdef BIFF
369: if (BiffChk != dw_biff)
370: biff_init();
371: /* just in case we changed our minds about whether to deal with
372: biff */
373: #endif
374: do_sgtty(); /* this is so if you change baudrate or stuff
375: like that, JOVE will notice. */
376: ttyset(ON);
377: }
378:
379: void
380: UnsetTerm(mesg)
381: char *mesg;
382: {
383: ttyset(OFF);
384: putpad(KE, 1);
385: putpad(VE, 1);
386: putpad(TE, 1);
387: #ifdef ID_CHAR
388: INSmode(0);
389: #endif
390: Placur(ILI, 0);
391: printf("%s", mesg);
392: putpad(CE, 1);
393: flusho();
394: }
395: #endif /* TERMCAP */
396:
397: #ifdef JOB_CONTROL
398: PauseJove()
399: {
400: UnsetTerm(ModBufs(0) ? "[There are modified buffers]" : NullStr);
401: (void) kill(0, SIGTSTP);
402: ResetTerm();
403: ClAndRedraw();
404: }
405: #endif
406:
407:
408: #ifndef MAC
409: void
410: Push()
411: {
412: int
413: #ifndef MSDOS
414: pid,
415: (*old_quit)() = signal(SIGQUIT, SIG_IGN),
416: #endif /* MSDOS */
417: (*old_int)() = signal(SIGINT, SIG_IGN);
418:
419: #ifndef MSDOS
420: #ifdef IPROCS
421: sighold(SIGCHLD);
422: #endif
423: switch (pid = fork()) {
424: case -1:
425: complain("[Fork failed]");
426:
427: case 0:
428: UnsetTerm(NullStr);
429: #ifdef IPROCS
430: sigrelse(SIGCHLD);
431: #endif
432: (void) signal(SIGTERM, SIG_DFL);
433: #else /* MSDOS */
434: UnsetTerm(NullStr);
435: #endif /* MSDOS */
436: (void) signal(SIGINT, SIG_DFL);
437: #ifdef UNIX
438: (void) signal(SIGQUIT, SIG_DFL);
439: execl(Shell, basename(Shell), (char *)0);
440: message("[Execl failed]");
441: _exit(1);
442: }
443: dowait(pid, (int *) 0);
444: #ifdef IPROCS
445: sigrelse(SIGCHLD);
446: #endif
447: #endif /* UNIX */
448: #ifdef MSDOS
449: break_rst();
450: if (spawnl(0, Shell, basename(Shell), (char *)0) == -1)
451: message("[Spawn failed]");
452: #endif /* MSDOS */
453: ResetTerm();
454: ClAndRedraw();
455: #ifndef MSDOS
456: (void) signal(SIGQUIT, old_quit);
457: #else /* MSDOS */
458: break_off();
459: #ifdef CHDIR
460: getCWD();
461: #endif
462: #endif /* MSDOS */
463: (void) signal(SIGINT, old_int);
464: }
465: #endif /* MAC */
466:
467: int OKXonXoff = 0, /* ^S and ^Q initially DON'T work */
468: IntChar = CTL(']');
469:
470: void
471: ttsize()
472: {
473: #ifdef UNIX
474: # ifdef TIOCGWINSZ
475: struct winsize win;
476:
477: if (ioctl (0, TIOCGWINSZ, &win) == 0) {
478: if (win.ws_col)
479: CO = win.ws_col;
480: if (win.ws_row)
481: LI = win.ws_row;
482: }
483: # else /* TIOCGWINSZ */
484: # ifdef BTL_BLIT
485: #include <sys/jioctl.h>
486: struct jwinsize jwin;
487:
488: if (ioctl(0, JWINSIZE, &jwin) == 0) {
489: if (jwin.bytesx)
490: CO = jwin.bytesx;
491: if (jwin.bytesy)
492: LI = jwin.bytesy;
493: }
494: # endif /* BTL_BLIT */
495: # endif /* TIOCGWINSZ */
496: #endif /* UNIX */
497: ILI = LI - 1;
498: }
499:
500: #ifdef BIFF
501: biff_init()
502: {
503: dw_biff = ((BiffChk) &&
504: # ifndef BSD4_2
505: ((tt_name != 0) || (tt_name = ttyname(0))) &&
506: (stat(tt_name, &tt_stat) != -1) &&
507: # else
508: (fstat(0, &tt_stat) != -1) &&
509: # endif
510: (tt_stat.st_mode & S_IEXEC)); /* he's using biff */
511:
512: }
513:
514: biff(on)
515: {
516: if (dw_biff == NO)
517: return;
518: # ifndef BSD4_2
519: (void) chmod(tt_name, on ? tt_stat.st_mode :
520: (tt_stat.st_mode & ~S_IEXEC));
521: # else
522: (void) fchmod(0, on ? tt_stat.st_mode :
523: (tt_stat.st_mode & ~S_IEXEC));
524: # endif
525: }
526:
527: #endif /* BIFF */
528:
529: void
530: ttinit()
531: {
532: #ifdef BIFF
533: biff_init();
534: #endif
535: #ifdef TIOCSLTC
536: (void) ioctl(0, TIOCGLTC, (struct sgttyb *) &ls1);
537: ls2 = ls1;
538: ls2.t_suspc = (char) -1;
539: ls2.t_dsuspc = (char) -1;
540: ls2.t_flushc = (char) -1;
541: ls2.t_lnextc = (char) -1;
542: #endif
543:
544: #ifdef TIOCGETC
545: /* Change interupt and quit. */
546: (void) ioctl(0, TIOCGETC, (struct sgttyb *) &tc1);
547: tc2 = tc1;
548: tc2.t_intrc = IntChar;
549: tc2.t_quitc = (char) -1;
550: if (OKXonXoff) {
551: tc2.t_stopc = (char) -1;
552: tc2.t_startc = (char) -1;
553: }
554: #endif /* TIOCGETC */
555: do_sgtty();
556: }
557:
558: private int done_ttinit = 0;
559:
560: void
561: do_sgtty()
562: {
563: #ifdef UNIX
564: # ifdef SYSV
565: (void) ioctl(0, TCGETA, (char *) &sg1);
566: # else
567: (void) gtty(0, &sg1);
568: # endif /* SYSV */
569: sg2 = sg1;
570:
571: # ifdef LPASS8
572: (void) ioctl(0, TIOCLGET, &lmword1);
573: lmword2 = lmword1;
574: if (MetaKey == YES)
575: lmword2 |= LPASS8;
576: # endif
577:
578: # ifdef SYSV
579: TABS = !((sg1.c_oflag & TAB3) == TAB3);
580: ospeed = sg1.c_cflag & CBAUD;
581:
582: if (OKXonXoff)
583: sg2.c_iflag &= ~(IXON | IXOFF);
584: sg2.c_iflag &= ~(INLCR|ICRNL|IGNCR);
585: sg2.c_lflag &= ~(ISIG|ICANON|ECHO);
586: sg2.c_oflag &= ~(OCRNL|ONLCR);
587: sg2.c_cc[VMIN] = sizeof smbuf;
588: sg2.c_cc[VTIME] = 1;
589: # else
590: TABS = !(sg1.sg_flags & XTABS);
591: ospeed = sg1.sg_ospeed;
592: # ifdef BRLUNIX
593: sg2.sg_flags &= ~(ECHO | CRMOD);
594: sg2.sg_flags |= CBREAK;
595:
596: /* VT100 Kludge: leave STALL on for flow control if DC3DC1 (Yuck.) */
597: sg2.sg_xflags &= ~((sg2.sg_xflags&DC3DC1 ? 0 : STALL) | PAGE);
598: # else
599: sg2.sg_flags &= ~(ECHO | CRMOD);
600: # endif /* BRLUNIX */
601:
602: # ifdef PURDUE_EE
603: # ifdef pdp11
604: sg2.sg_flags |= RAW;
605: # else
606: sg2.sg_flags |= (MetaKey ? RAW : CBREAK);
607: # endif
608: # else
609: # ifdef LPASS8
610: sg2.sg_flags |= CBREAK;
611: # else
612: sg2.sg_flags |= (MetaKey ? RAW : CBREAK);
613: # endif
614: # endif /* PURDUE_EE */
615: # endif /* SYSV */
616: #endif /* UNIX */
617:
618: #ifdef MSDOS
619: # ifndef IBMPC
620: setmode(1, 0x8000);
621: # endif /* IBMPC */
622: TABS = 0;
623: #endif /* MSDOS */
624: }
625:
626: void
627: tty_reset()
628: {
629: if (!done_ttinit)
630: return;
631: ttyset(OFF); /* go back to original modes */
632: ttinit();
633: ttyset(ON);
634: }
635:
636: /* If n is OFF reset to original modes */
637:
638: void
639: ttyset(n)
640: {
641: if (!done_ttinit && n == 0) /* Try to reset before we've set! */
642: return;
643: #ifdef UNIX
644: # ifdef SYSV
645: (void) ioctl(0, TCSETAW, n == 0 ? (struct sgttyb *) &sg1 : (struct sgttyb *) &sg2);
646: # else
647: # ifdef BRLUNIX
648: (void) stty(0, n == 0 ? (struct sgttyb *) &sg1 : (struct sgttyb *) &sg2);
649: # else
650: (void) ioctl(0, TIOCSETN, n == 0 ? (struct sgttyb *) &sg1 : (struct sgttyb *) &sg2);
651: # endif /* BRLUNIX */
652: # endif /* SYSV */
653:
654: # ifdef TIOCSETC
655: (void) ioctl(0, TIOCSETC, n == 0 ? (struct sgttyb *) &tc1 : (struct sgttyb *) &tc2);
656: # endif /* TIOCSETC */
657: # ifdef TIOCSLTC
658: (void) ioctl(0, TIOCSLTC, n == 0 ? (struct sgttyb *) &ls1 : (struct sgttyb *) &ls2);
659: # endif /* TIOCSLTC */
660: # ifdef LPASS8
661: (void) ioctl(0, TIOCLSET, n == 0 ? &lmword1 : &lmword2);
662: # endif
663: #endif /* UNIX */
664:
665: #ifdef MSDOS
666: # ifndef IBMPC
667: setmode(1, n == 0 ? 0x4000 : 0x8000);
668: # endif
669: #endif /* MSDOS */
670: done_ttinit = 1;
671: #ifdef BIFF
672: biff(!n);
673: #endif
674: }
675:
676: int this_cmd,
677: last_cmd;
678:
679: void
680: dispatch(c)
681: register int c;
682: {
683: data_obj *cp;
684:
685: this_cmd = 0;
686: cp = mainmap[c & CHARMASK];
687:
688: if (cp == 0) {
689: rbell();
690: clr_arg_value();
691: errormsg = NO;
692: message(NullStr);
693: } else
694: ExecCmd(cp);
695: }
696:
697: int LastKeyStruck,
698: MetaKey = 0;
699:
700: int
701: getch()
702: {
703: register int c,
704: peekc;
705: #ifdef IPROCS
706: extern int NumProcs;
707: #endif
708: extern int ModCount,
709: Interactive;
710:
711: if (Inputp) {
712: if ((c = *Inputp++) != 0)
713: return LastKeyStruck = c;
714: Inputp = 0;
715: }
716:
717: if (InJoverc)
718: return EOF; /* somethings wrong if Inputp runs out while
719: we're reading a .joverc file. */
720:
721: #ifndef MSDOS
722: if (ModCount >= SyncFreq) {
723: ModCount = 0;
724: SyncRec();
725: }
726: #endif /* MSDOS */
727:
728: /* If we're not interactive and we're not executing a macro,
729: AND there are no ungetc'd characters, we read from the
730: terminal (i.e., getch()). And characters only get put
731: in macros from inside this if. */
732: if (((peekc = c = Peekc()) == -1) && (Interactive || ((c = mac_getc()) == -1))) {
733: /* So messages that aren't error messages don't
734: hang around forever. */
735: if (!UpdMesg && !Asking) { /* Don't erase if we are asking */
736: if (mesgbuf[0] && !errormsg)
737: message(NullStr);
738: }
739: redisplay();
740: #if defined(IPROCS) && defined(PIPEPROCS)
741: if (NumProcs > 0) {
742: sigrelse(INPUT_SIG);
743: sigrelse(SIGCHLD);
744: }
745: #endif
746: #ifdef UNIX
747: inIOread = 1;
748: #endif
749: if ((c = getchar()) == EOF)
750: finish(SIGHUP);
751: #ifdef UNIX
752: inIOread = 0;
753: #endif
754:
755: #if defined(IPROCS) && defined(PIPEPROCS)
756: if (NumProcs > 0) {
757: sighold(INPUT_SIG);
758: sighold(SIGCHLD);
759: }
760: #endif
761: if (!Interactive && InMacDefine)
762: mac_putc(c);
763: }
764: if (peekc == -1) /* don't add_stroke peekc's */
765: add_stroke(c);
766: return LastKeyStruck = c;
767: }
768:
769: #ifdef UNIX
770: dorecover()
771: {
772: execl(Recover, "recover", "-d", TmpFilePath, (char *) 0);
773: printf("%s: execl failed!\n", Recover);
774: flusho();
775: _exit(-1);
776: }
777: #endif /* UNIX */
778:
779: void
780: ShowVersion()
781: {
782: extern char *version;
783:
784: s_mess("Jonathan's Own Version of Emacs (%s)", version);
785: }
786:
787: void
788: UNIX_cmdline(argc, argv)
789: char *argv[];
790: {
791: int lineno = 0,
792: nwinds = 1;
793: Buffer *b;
794:
795: ShowVersion();
796: while (argc > 1) {
797: if (argv[1][0] != '-' && argv[1][0] != '+') {
798: int force = (nwinds > 0 || lineno != 0);
799:
800: #ifdef MSDOS
801: strlwr(argv[1]);
802: #endif
803: minib_add(argv[1], force ? YES : NO);
804: b = do_find(nwinds > 0 ? curwind : (Window *) 0,
805: argv[1], force);
806: if (force) {
807: SetABuf(curbuf);
808: SetBuf(b);
809: if (lineno >= 0)
810: SetLine(next_line(curbuf->b_first, lineno));
811: else
812: SetLine(curbuf->b_last);
813: if (nwinds > 1)
814: NextWindow();
815: if (nwinds)
816: nwinds -= 1;
817: }
818: lineno = 0;
819: } else switch (argv[1][1]) {
820: case 'd':
821: argv += 1;
822: argc -= 1;
823: break;
824:
825: case 'j': /* Ignore .joverc in HOME */
826: break;
827: #ifndef MAC
828: case 'p':
829: argv += 1;
830: argc -= 1;
831: if (argv[1] != 0) {
832: SetBuf(do_find(curwind, argv[1], 0));
833: ErrParse();
834: nwinds = 0;
835: }
836: break;
837: #endif
838: case 't':
839: /* check if syntax is -tTag or -t Tag */
840: if (argv[1][2] != 0) {
841: find_tag(&(argv[1][2]), YES);
842: } else {
843: argv += 1;
844: argc -= 1;
845: if (argv[1] != 0)
846: find_tag(argv[1], YES);
847: }
848: break;
849:
850: case 'w':
851: if (argv[1][2] == '\0')
852: nwinds += 1;
853: else {
854: int n;
855:
856: (void) chr_to_int(&argv[1][2], 10, NO, &n);
857: nwinds += -1 + n;
858: }
859: (void) div_wind(curwind, nwinds - 1);
860: break;
861:
862: case '0':
863: case '1':
864: case '2':
865: case '3':
866: case '4':
867: case '5':
868: case '6':
869: case '7':
870: case '8':
871: case '9':
872: (void) chr_to_int(&argv[1][1], 10, NO, &lineno);
873: lineno -= 1;
874: break;
875: case 0:
876: lineno = -1; /* goto end of file ... */
877: break; /* just like some people's */
878: } /* favourite editor */
879: argv += 1;
880: argc -= 1;
881: }
882: }
883:
884: /* VARARGS1 */
885:
886: void
887: error(fmt, va_alist)
888: char *fmt;
889: va_dcl
890: {
891: va_list ap;
892:
893: if (fmt) {
894: va_start(ap);
895: format(mesgbuf, sizeof mesgbuf, fmt, ap);
896: va_end(ap);
897: UpdMesg = YES;
898: }
899: rbell();
900: longjmp(mainjmp, ERROR);
901: }
902:
903: /* VARARGS1 */
904:
905: void
906: complain(fmt, va_alist)
907: char *fmt;
908: va_dcl
909: {
910: va_list ap;
911:
912: if (fmt) {
913: va_start(ap);
914: format(mesgbuf, sizeof mesgbuf, fmt, ap);
915: va_end(ap);
916: UpdMesg = YES;
917: }
918: rbell();
919: longjmp(mainjmp, COMPLAIN);
920: }
921:
922: /* VARARGS1 */
923:
924: void
925: confirm(fmt, va_alist)
926: char *fmt;
927: va_dcl
928: {
929: char *yorn;
930: va_list ap;
931:
932: va_start(ap);
933: format(mesgbuf, sizeof mesgbuf, fmt, ap);
934: va_end(ap);
935: yorn = ask((char *) 0, mesgbuf);
936: if (*yorn != 'Y' && *yorn != 'y')
937: longjmp(mainjmp, COMPLAIN);
938: }
939:
940: int RecDepth = 0;
941:
942: void
943: Recur()
944: {
945: char bname[128];
946: Mark *m;
947:
948: sprintf(bname, "%s", curbuf->b_name);
949: m = MakeMark(curline, curchar, M_FLOATER);
950:
951: RecDepth += 1;
952: UpdModLine = YES;
953: DoKeys(1); /* 1 means not first time */
954: UpdModLine = YES;
955: RecDepth -= 1;
956: SetBuf(do_select(curwind, bname));
957: if (!is_an_arg())
958: ToMark(m);
959: DelMark(m);
960: }
961:
962: jmp_buf mainjmp;
963:
964: #ifdef MAC
965: jmp_buf auxjmp;
966: #endif
967:
968: int iniargc; /* main sets these for DoKeys() */
969: char **iniargv;
970:
971: void
972: DoKeys(nocmdline)
973: {
974: int c;
975: jmp_buf savejmp;
976:
977: push_env(savejmp);
978:
979: switch (setjmp(mainjmp)) {
980: case 0:
981: if (!nocmdline)
982: UNIX_cmdline(iniargc, iniargv);
983: break;
984:
985: case QUIT:
986: if (RecDepth == 0) {
987: if (ModMacs()) {
988: rbell();
989: if (CharUpcase(*ask("No",
990: "Some MACROS haven't been saved; leave anyway? ")) != 'Y')
991: break;
992: }
993: if (ModBufs(0)) {
994: rbell();
995: if (CharUpcase(*ask("No",
996: "Some buffers haven't been saved; leave anyway? ")) != 'Y')
997: break;
998: }
999: #ifdef IPROCS
1000: KillProcs();
1001: #endif
1002: }
1003: pop_env(savejmp);
1004: return;
1005:
1006: case ERROR:
1007: getDOT(); /* God knows what state linebuf was in */
1008:
1009: case COMPLAIN:
1010: {
1011: extern int DisabledRedisplay;
1012:
1013: gc_openfiles(); /* close any files we left open */
1014: errormsg = YES;
1015: unwind_macro_stack();
1016: Asking = 0;
1017: curwind->w_bufp = curbuf;
1018: DisabledRedisplay = NO;
1019: redisplay();
1020: break;
1021: }
1022: }
1023:
1024: this_cmd = last_cmd = 0;
1025:
1026: for (;;) {
1027: #ifdef MAC
1028: setjmp(auxjmp);
1029: #endif
1030: if (this_cmd != ARG_CMD) {
1031: clr_arg_value();
1032: last_cmd = this_cmd;
1033: init_strokes();
1034: }
1035: #ifdef MAC
1036: HiliteMenu(0);
1037: EventCmd = 0;
1038: menus_on();
1039: #endif
1040: c = getch();
1041: if (c == -1)
1042: continue;
1043: dispatch(c);
1044: }
1045: }
1046:
1047: int Crashing = 0;
1048:
1049: char **
1050: scanvec(args, str)
1051: register char **args,
1052: *str;
1053: {
1054: while (*args) {
1055: if (strcmp(*args, str) == 0)
1056: return args;
1057: args += 1;
1058: }
1059: return 0;
1060: }
1061:
1062: #ifdef UNIX
1063: int UpdFreq = 30,
1064: inIOread = 0;
1065:
1066: updmode()
1067: {
1068: UpdModLine = YES;
1069: if (inIOread)
1070: redisplay();
1071: #ifndef JOB_CONTROL
1072: (void) signal(SIGALRM, updmode);
1073: #endif
1074: (void) alarm((unsigned) UpdFreq);
1075: }
1076: #endif /* UNIX */
1077:
1078: #ifndef MSDOS
1079: # if defined(TIOCGWINSZ) && defined(SIGWINCH)
1080: extern win_reshape();
1081: # endif
1082: #else /* MSDOS */
1083: # ifndef IBMPC
1084: char ttbuf[BUFSIZ];
1085: # endif /* IBMPC */
1086: #endif /* MSDOS */
1087:
1088: #if defined(TIOCGWINSZ) && defined(SIGWINCH)
1089: win_reshape()
1090: {
1091: register int oldsize;
1092: register int newsize, total;
1093: register Window *wp;
1094:
1095: (void) signal(SIGWINCH, SIG_IGN);
1096:
1097: /*
1098: * Save old number of lines.
1099: */
1100: oldsize = LI;
1101:
1102: /*
1103: * Get new line/col info.
1104: */
1105: ttsize();
1106:
1107: /*
1108: * LI has changed, and now holds the
1109: * new value.
1110: */
1111: /*
1112: * Go through the window list, changing each window size in
1113: * proportion to the resize. If a window becomes too small,
1114: * delete it. We keep track of all the excess lines (caused by
1115: * roundoff!), and give them to the current window, as a sop -
1116: * can't be more than one or two lines anyway. This seems fairer
1117: * than just resizing the current window.
1118: */
1119: wp = fwind;
1120: total = 0;
1121: do {
1122: newsize = LI * wp->w_height / oldsize;
1123:
1124: if (newsize < 2) {
1125: total += wp->w_height;
1126: wp = wp->w_next;
1127: del_wind(wp->w_prev);
1128: } else {
1129: wp->w_height = newsize;
1130: total += newsize;
1131: wp = wp->w_next;
1132: }
1133: } while (wp != fwind);
1134:
1135: curwind->w_height += LI - total - 1;
1136:
1137: /* Make a new screen structure */
1138: make_scr();
1139: /* Do a 'hard' update on the screen - clear and redraw */
1140: cl_scr(1);
1141: flusho();
1142: redisplay();
1143:
1144: (void) signal(SIGWINCH, win_reshape);
1145: }
1146: #endif
1147:
1148: void
1149:
1150: #ifdef MAC /* will get args from user, if option key held during launch */
1151: main()
1152: {
1153: int argc;
1154: char **argv;
1155: #else
1156: main(argc, argv)
1157: char *argv[];
1158: {
1159: #endif /* MAC */
1160: char *cp;
1161: #ifndef MSDOS
1162: char ttbuf[MAXTTYBUF],
1163: # ifndef VMUNIX
1164: s_iobuff[LBSIZE],
1165: s_genbuf[LBSIZE],
1166: s_linebuf[LBSIZE];
1167: /* The way I look at it, there ain't no way I is gonna run
1168: out of stack space UNLESS I have some kind of infinite
1169: recursive bug. So why use up some valuable memory, when
1170: there is plenty of space on the stack? (This only matters
1171: on wimpy pdp11's, of course.) */
1172:
1173: iobuff = s_iobuff;
1174: genbuf = s_genbuf;
1175: linebuf = s_linebuf;
1176: # endif
1177:
1178: #else /* MSDOS */
1179: char *getenv();
1180: #endif /* MSDOS */
1181:
1182: errormsg = 0;
1183:
1184: #ifdef MAC
1185: MacInit(); /* initializes all */
1186: if(make_cache() == 0) exit(-1);
1187: argc = getArgs(&argv);
1188: #endif /* MAC */
1189:
1190: iniargc = argc;
1191: iniargv = argv;
1192:
1193: if (setjmp(mainjmp)) {
1194: printf("\rAck! I can't deal with error \"%s\" now.\n\r", mesgbuf);
1195: finish(0);
1196: }
1197:
1198: #ifdef MSDOS
1199: /* import the temporary file path from the environment and
1200: fix the string, so that we can append a slash safely */
1201:
1202: if (((cp = getenv("TMP")) || (cp = getenv("TMPDIR"))) &&
1203: (*cp != '\0')) {
1204: strcpy(TmpFilePath, cp);
1205: cp = &TmpFilePath[strlen(TmpFilePath)-1];
1206: if ((*cp == '/') || (*cp == '\\'))
1207: *cp = 0;
1208: }
1209: ShFlags[0] = switchar();
1210: #endif /* MSDOS */
1211:
1212: getTERM(); /* Get terminal. */
1213: if (getenv("METAKEY"))
1214: MetaKey = 1;
1215: ttsize();
1216: InitCM();
1217: #ifdef MAC
1218: InitEvents();
1219: #endif
1220:
1221: d_cache_init(); /* initialize the disk buffer cache */
1222: #ifndef MAC
1223: if ((cp = getenv("COMSPEC")) && (*cp != '\0')) {
1224: strcpy(Shell, cp);
1225: }
1226: #endif
1227: #ifdef MSDOS
1228: if ((cp = getenv("DESCRIBE")) && (*cp != '\0'))
1229: strcpy(CmdDb, cp);
1230: #endif /* MSDOS */
1231:
1232: make_scr();
1233: mac_init(); /* Initialize Macros */
1234: winit(); /* Initialize Window */
1235: #ifdef IPROCS
1236: pinit(); /* Pipes/process initialization */
1237: #endif
1238: SetBuf(do_select(curwind, Mainbuf));
1239:
1240: #ifdef CHDIR
1241: {
1242: char **argp;
1243:
1244: if ((argp = scanvec(argv, "-d")) && (argp[1][0] == '/'))
1245: setCWD(argp[1]);
1246: else
1247: getCWD(); /* After we setup curbuf in case we have to getwd() */
1248: }
1249: #endif
1250: HomeDir = getenv("HOME");
1251: if (HomeDir == 0)
1252: HomeDir = "/";
1253: HomeLen = strlen(HomeDir);
1254:
1255: #ifdef UNIX
1256: # ifdef SYSV
1257: sprintf(Mailbox, "/usr/mail/%s", getenv("LOGNAME"));
1258: # else
1259: sprintf(Mailbox, "/usr/spool/mail/%s", getenv("USER"));
1260: # endif
1261: #endif
1262:
1263: #ifdef MSDOS
1264: if ((cp = getenv("JOVERC")) && (*cp != '\0'))
1265: (void) joverc(cp);
1266: #endif /* MSDOS */
1267: (void) joverc(Joverc);
1268: if (!scanvec(argv, "-j")) {
1269: char tmpbuf[100];
1270: sprintf(tmpbuf, "%s/.joverc", HomeDir);
1271: (void) joverc(tmpbuf);
1272: }
1273: #ifndef MSDOS
1274: if (scanvec(argv, "-r"))
1275: dorecover();
1276: if (scanvec(argv, "-rc"))
1277: FullRecover();
1278: #endif /* MSDOS */
1279: ttinit(); /* initialize terminal (after ~/.joverc) */
1280: #ifndef IBMPC
1281: settout(ttbuf); /* not until we know baudrate */
1282: #endif
1283:
1284: #ifdef MSDOS
1285: (void) signal(SIGINT, SIG_IGN);
1286: break_off(); /* disable ctrl-c checking */
1287: #endif /* MSDOS */
1288: #ifdef UNIX
1289: (void) signal(SIGHUP, finish);
1290: (void) signal(SIGINT, finish);
1291: (void) signal(SIGBUS, finish);
1292: (void) signal(SIGSEGV, finish);
1293: (void) signal(SIGPIPE, finish);
1294: (void) signal(SIGTERM, SIG_IGN);
1295: # if defined(TIOCGWINSZ) && defined(SIGWINCH)
1296: (void) signal(SIGWINCH, win_reshape);
1297: # endif
1298: /* set things up to update the modeline every UpdFreq seconds */
1299: (void) signal(SIGALRM, updmode);
1300: (void) alarm((unsigned) (60 - (time((time_t *) 0) % 60)));
1301: #endif /* UNIX */
1302:
1303: ResetTerm();
1304: cl_scr(1);
1305: flusho();
1306: RedrawDisplay(); /* start the redisplay process. */
1307: DoKeys(0);
1308: finish(0);
1309: }
1310:
1311: #ifdef MSDOS
1312:
1313: #include <dos.h>
1314:
1315: static char break_state;
1316:
1317: /* set the break state to off */
1318: private void
1319: break_off()
1320: {
1321: union REGS regs;
1322:
1323: regs.h.ah = 0x33; /* break status */
1324: regs.h.al = 0x00; /* request current state */
1325: intdos(®s, ®s);
1326: break_state = regs.h.dl;
1327: bdos(0x33, 0, 1); /* turn off break */
1328: }
1329:
1330: /* reset the break state */
1331: private void
1332: break_rst()
1333: {
1334: bdos(0x33, break_state, 1);
1335: }
1336: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.