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