![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disp.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 disp.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: #include "jove.h"
9: #include "ctype.h"
10: #include "termcap.h"
11:
12:
13: #ifdef MAC
14: # include "mac.h"
15: #else
16: # include <varargs.h>
17: # include <sys/stat.h>
18: #endif
19:
20: #include <signal.h>
21:
22: #ifdef MAC
23: # undef private
24: # define private
25: #endif
26:
27: #ifdef LINT_ARGS
28: private void
29: #ifdef ID_CHAR
30: DeTab(int, char *, char *, int, int),
31: DelChar(int, int, int),
32: InsChar(int, int, int, char *),
33: #endif
34: DoIDline(int),
35: do_cl_eol(int),
36: ModeLine(Window *),
37: mode_app(char *),
38: GotoDot(void),
39: UpdLine(int),
40: UpdWindow(Window *, int);
41:
42: private int
43: AddLines(int, int),
44: DelLines(int, int),
45: UntilEqual(int);
46: #else
47: private void
48: #ifdef ID_CHAR
49: DeTab(),
50: DelChar(),
51: InsChar(),
52: #endif
53: DoIDline(),
54: do_cl_eol(),
55: GotoDot(),
56: ModeLine(),
57: mode_app(),
58: UpdLine(),
59: UpdWindow();
60: private int
61: AddLines(),
62: DelLines(),
63: UntilEqual();
64: #endif /* LINT_ARGS */
65:
66: #ifdef MAC
67: # undef private
68: # define private static
69: #endif
70:
71: int DisabledRedisplay = NO;
72:
73: /* Kludge windows gets called by the routines that delete lines from the
74: buffer. If the w->w_line or w->w_top are deleted and this procedure
75: is not called, the redisplay routine will barf. */
76:
77: void
78: ChkWindows(line1, line2)
79: Line *line1;
80: register Line *line2;
81: {
82: register Window *w = fwind;
83: register Line *lp;
84:
85: do {
86: for (lp = line1->l_next; lp != line2->l_next; lp = lp->l_next) {
87: if (lp == w->w_top)
88: w->w_flags |= W_TOPGONE;
89: if (lp == w->w_line)
90: w->w_flags |= W_CURGONE;
91: }
92: w = w->w_next;
93: } while (w != fwind);
94: }
95:
96: extern int RingBell;
97:
98: void
99: redisplay()
100: {
101: extern int AbortCnt;
102: register Window *w = fwind;
103: int lineno,
104: done_ID = NO,
105: i;
106: register struct scrimage *des_p,
107: *phys_p;
108:
109: if (DisabledRedisplay == YES)
110: return;
111: curwind->w_line = curwind->w_bufp->b_dot;
112: curwind->w_char = curwind->w_bufp->b_char;
113: #ifdef MAC
114: InputPending = 0;
115: #else
116: if (InputPending = charp()) /* calls CheckEvent, which could */
117: return; /* result in a call to rediplay(). We don't want that. */
118: #endif
119: #ifdef JOB_CONTROL
120: if (UpdFreq)
121: sighold(SIGALRM);
122: #endif
123: if (RingBell) {
124: dobell(1);
125: RingBell = 0;
126: }
127: AbortCnt = BufSize; /* initialize this now */
128: if (UpdMesg)
129: DrawMesg(YES);
130:
131: for (lineno = 0, w = fwind; lineno < ILI; w = w->w_next) {
132: UpdWindow(w, lineno);
133: lineno += w->w_height;
134: }
135:
136: UpdModLine = 0; /* Now that we've called update window, we can
137: assume that the modeline will be updated. But
138: if while redrawing the modeline the user types
139: a character, ModeLine() is free to set this on
140: again so that the modeline will be fully drawn
141: at the next redisplay. */
142:
143: des_p = DesiredScreen;
144: phys_p = PhysScreen;
145: for (i = 0; i < ILI; i++, des_p++, phys_p++) {
146: if (!done_ID && (des_p->s_id != phys_p->s_id)) {
147: DoIDline(i);
148: done_ID = YES;
149: }
150: if ((des_p->s_flags & (DIRTY | L_MOD)) ||
151: (des_p->s_id != phys_p->s_id) ||
152: (des_p->s_vln != phys_p->s_vln) ||
153: (des_p->s_offset != phys_p->s_offset))
154: UpdLine(i);
155: if (InputPending)
156: goto ret;
157: }
158:
159:
160: if (Asking) {
161: Placur(LI - 1, min(CO - 2, calc_pos(mesgbuf, Asking)));
162: /* Nice kludge */
163: flusho();
164: } else
165: GotoDot();
166: ret:
167: #ifdef JOB_CONTROL
168: if (UpdFreq)
169: sigrelse(SIGALRM);
170: #else
171: ; /* yuck */
172: #endif
173: #ifdef MAC
174: if(Windchange) docontrols();
175: #endif /* MAC */
176: }
177:
178: #ifndef IBMPC
179: private void
180: dobell(n)
181: {
182: while (--n >= 0) {
183: #ifndef MAC
184: if (VisBell && VB)
185: putstr(VB);
186: else
187: putpad(BL, 1);
188: #else
189: SysBeep(5);
190: #endif
191: }
192: flusho();
193: }
194: #endif /* IBMPC */
195:
196: /* find_pos() returns the position on the line, that C_CHAR represents
197: in LINE */
198:
199: int
200: find_pos(line, c_char)
201: Line *line;
202: {
203: return calc_pos(lcontents(line), c_char);
204: }
205:
206: int
207: calc_pos(lp, c_char)
208: register char *lp;
209: register int c_char;
210: {
211: register int pos = 0;
212: register int c;
213:
214:
215: while ((--c_char >= 0) && ((c = *lp++) & CHARMASK) != 0) {
216: if (c == '\t')
217: pos += (tabstop - (pos % tabstop));
218: else if (isctrl(c))
219: pos += 2;
220: else
221: pos += 1;
222: }
223: return pos;
224: }
225:
226: int UpdModLine = 0,
227: UpdMesg = 0,
228: CanScroll = 0;
229:
230: private void
231: DoIDline(start)
232: {
233: register struct scrimage *des_p = &DesiredScreen[start];
234: struct scrimage *phys_p = &PhysScreen[start];
235: register int i,
236: j;
237:
238: /* Some changes have been made. Try for insert or delete lines.
239: If either case has happened, Addlines and/or DelLines will do
240: necessary scrolling, also CONVERTING PhysScreen to account for the
241: physical changes. The comparison continues from where the
242: insertion/deletion takes place; this doesn't happen very often,
243: usually it happens with more than one window with the same
244: buffer. */
245:
246: if (!CanScroll)
247: return; /* We should never have been called! */
248:
249: for (i = start; i < ILI; i++, des_p++, phys_p++)
250: if (des_p->s_id != phys_p->s_id)
251: break;
252:
253: for (; i < ILI; i++) {
254: for (j = i + 1; j < ILI; j++) {
255: des_p = &DesiredScreen[j];
256: phys_p = &PhysScreen[j];
257: if (des_p->s_id != 0 && des_p->s_id == phys_p->s_id)
258: break;
259: if (des_p->s_id == PhysScreen[i].s_id) {
260: if (des_p->s_id == 0)
261: continue;
262: if (AddLines(i, j - i)) {
263: DoIDline(j);
264: return;
265: }
266: break;
267: }
268: if ((des_p = &DesiredScreen[i])->s_id == phys_p->s_id) {
269: if (des_p->s_id == 0)
270: continue;
271: if (DelLines(i, j - i)) {
272: DoIDline(i);
273: return;
274: }
275: break;
276: }
277: }
278: }
279: }
280:
281: /* Make DesiredScreen reflect what the screen should look like when we are done
282: with the redisplay. This deals with horizontal scrolling. Also makes
283: sure the current line of the Window is in the window. */
284:
285: int ScrollAll = NO;
286:
287: private void
288: UpdWindow(w, start)
289: register Window *w;
290: {
291: Line *lp;
292: int i,
293: upper, /* top of window */
294: lower, /* bottom of window */
295: strt_col, /* starting print column of current line */
296: ntries = 0; /* # of tries at updating window */
297: register struct scrimage *des_p,
298: *phys_p;
299: Buffer *bp = w->w_bufp;
300:
301: retry:
302: if (w->w_flags & W_CURGONE) {
303: w->w_line = bp->b_dot;
304: w->w_char = bp->b_char;
305: }
306: if (w->w_flags & W_TOPGONE)
307: CentWind(w); /* reset topline of screen */
308: w->w_flags &= ~(W_CURGONE | W_TOPGONE);
309:
310: /* make sure that the current line is in the window */
311: upper = start;
312: lower = upper + w->w_height - 1; /* don't include modeline */
313: for (i = upper, lp = w->w_top; i < lower && lp != 0; lp = lp->l_next, i++)
314: if (lp == w->w_line)
315: break;
316: if (i == lower || lp == 0) {
317: ntries += 1;
318: if (ntries == 1) {
319: CalcWind(w);
320: goto retry;
321: } else if (ntries == 2) {
322: w->w_top = w->w_line = w->w_bufp->b_first;
323: printf("\rERROR in redisplay: I got hopelessly lost!");
324: dobell(2);
325: goto retry;
326: } else if (ntries == 3) {
327: printf("\n\rOops, still lost, quitting ...\r\n");
328: finish(1);
329: }
330: }
331:
332: /* first do some calculations for the current line */
333: {
334: int diff = (w->w_flags & W_NUMLINES) ? 8 : 0,
335: end_col;
336:
337: strt_col = (ScrollAll == YES) ? w->w_LRscroll :
338: PhysScreen[i].s_offset;
339: end_col = strt_col + (CO - 2) - diff;
340: /* Right now we are displaying from strt_col to
341: end_col of the buffer line. These are PRINT
342: columns, not actual characters. */
343: w->w_dotcol = find_pos(w->w_line, w->w_char);
344: /* if the new dotcol is out of range, reselect
345: a horizontal window */
346: if ((PhysScreen[i].s_offset == -1) ||
347: (w->w_dotcol < strt_col) ||
348: (w->w_dotcol >= end_col)) {
349: if (w->w_dotcol < ((CO - 2) - diff))
350: strt_col = 0;
351: else
352: strt_col = w->w_dotcol - (CO / 2);
353: if (ScrollAll == YES) {
354: if (w->w_LRscroll != strt_col)
355: UpdModLine = YES;
356: w->w_LRscroll = strt_col;
357: }
358: }
359: w->w_dotline = i;
360: w->w_dotcol += diff;
361: }
362:
363: des_p = &DesiredScreen[upper];
364: phys_p = &PhysScreen[upper];
365: for (i = upper, lp = w->w_top; lp != 0 && i < lower; i++, des_p++, phys_p++, lp = lp->l_next) {
366: des_p->s_window = w;
367: des_p->s_lp = lp;
368: des_p->s_id = lp->l_dline & ~DIRTY;
369: des_p->s_flags = isdirty(lp) ? L_MOD : 0;
370: if (w->w_flags & W_NUMLINES)
371: des_p->s_vln = w->w_topnum + (i - upper);
372: else
373: des_p->s_vln = 0;
374:
375: if (lp == w->w_line)
376: des_p->s_offset = strt_col;
377: else
378: des_p->s_offset = w->w_LRscroll;
379: }
380:
381: /* Is structure assignment faster than copy each field separately? */
382: if (i < lower) {
383: static struct scrimage dirty_plate = { 0, DIRTY, 0, 0, 0, 0 },
384: clean_plate = { 0, 0, 0, 0, 0, 0 };
385:
386: for (; i < lower; i++, des_p++, phys_p++)
387: if (phys_p->s_id != 0)
388: *des_p = dirty_plate;
389: else
390: *des_p = clean_plate;
391: }
392:
393: des_p->s_window = w;
394: des_p->s_flags = 0;
395: if (((des_p->s_id = (int) w->w_bufp) != phys_p->s_id) || UpdModLine)
396: des_p->s_flags = MODELINE | DIRTY;
397: #ifdef MAC
398: if(UpdModLine) Modechange = 1;
399: if(w == curwind && w->w_control) SetScrollBar(w->w_control);
400: #endif
401: }
402:
403: /* Write whatever is in mesgbuf (maybe we are Asking, or just printed
404: a message). Turns off the UpdateMesg line flag. */
405:
406: void
407: DrawMesg(abortable)
408: {
409: #ifndef MAC /* same reason as in redisplay() */
410: if (charp())
411: return;
412: #endif
413: i_set(ILI, 0);
414: if (swrite(mesgbuf, NO, abortable)) {
415: cl_eol();
416: UpdMesg = 0;
417: }
418: flusho();
419: }
420:
421: /* Goto the current position in the current window. Presumably redisplay()
422: has already been called, and curwind->{w_dotline,w_dotcol} have been set
423: correctly. */
424:
425: private void
426: GotoDot()
427: {
428: if (InputPending)
429: return;
430: Placur(curwind->w_dotline, curwind->w_dotcol -
431: PhysScreen[curwind->w_dotline].s_offset);
432: flusho();
433: }
434:
435: private int
436: UntilEqual(start)
437: register int start;
438: {
439: register struct scrimage *des_p = &DesiredScreen[start],
440: *phys_p = &PhysScreen[start];
441:
442: while ((start < ILI) && (des_p->s_id != phys_p->s_id)) {
443: des_p += 1;
444: phys_p += 1;
445: start += 1;
446: }
447:
448: return start;
449: }
450:
451: /* Calls the routine to do the physical changes, and changes PhysScreen to
452: reflect those changes. */
453:
454: private int
455: AddLines(at, num)
456: register int at,
457: num;
458: {
459: register int i;
460: int bottom = UntilEqual(at + num);
461:
462: if (num == 0 || num >= ((bottom - 1) - at))
463: return NO; /* we did nothing */
464: v_ins_line(num, at, bottom - 1);
465:
466: /* Now change PhysScreen to account for the physical change. */
467:
468: for (i = bottom - 1; i - num >= at; i--)
469: PhysScreen[i] = PhysScreen[i - num];
470: for (i = 0; i < num; i++)
471: PhysScreen[at + i].s_id = 0;
472: return YES; /* we did something */
473: }
474:
475: private int
476: DelLines(at, num)
477: register int at,
478: num;
479: {
480: register int i;
481: int bottom = UntilEqual(at + num);
482:
483: if (num == 0 || num >= ((bottom - 1) - at))
484: return NO;
485: v_del_line(num, at, bottom - 1);
486:
487: for (i = at; num + i < bottom; i++)
488: PhysScreen[i] = PhysScreen[num + i];
489: for (i = bottom - num; i < bottom; i++)
490: PhysScreen[i].s_id = 0;
491: return YES;
492: }
493:
494: /* Update line linenum in window w. Only set PhysScreen to DesiredScreen
495: if the swrite or cl_eol works, that is nothing is interupted by
496: characters typed. */
497:
498: private void
499: UpdLine(linenum)
500: register int linenum;
501: {
502: register struct scrimage *des_p = &DesiredScreen[linenum];
503: register Window *w = des_p->s_window;
504:
505: i_set(linenum, 0);
506: if (des_p->s_flags & MODELINE)
507: ModeLine(w);
508: else if (des_p->s_id) {
509: des_p->s_lp->l_dline &= ~DIRTY;
510: des_p->s_flags &= ~(DIRTY | L_MOD);
511: #ifdef ID_CHAR
512: if (!UseIC && (w->w_flags & W_NUMLINES))
513: #else
514: if (w->w_flags & W_NUMLINES)
515: #endif
516: (void) swrite(sprint("%6d ", des_p->s_vln), NO, YES);
517:
518: #ifdef ID_CHAR
519: if (UseIC) {
520: char outbuf[MAXCOLS],
521: *lptr;
522: int fromcol = (w->w_flags & W_NUMLINES) ? 8 : 0;
523:
524: if (w->w_flags & W_NUMLINES)
525: sprintf(outbuf, "%6d ", des_p->s_vln);
526: lptr = lcontents(des_p->s_lp);
527: DeTab(des_p->s_offset, lptr, outbuf + fromcol,
528: (sizeof outbuf) - 1 - fromcol,
529: des_p->s_window->w_flags & W_VISSPACE);
530: if (IDchar(outbuf, linenum, 0))
531: PhysScreen[linenum] = *des_p;
532: else if (i_set(linenum, 0), swrite(outbuf, NO, YES))
533: do_cl_eol(linenum);
534: else
535: PhysScreen[linenum].s_id = -1;
536: } else
537: #endif /* ID_CHAR */
538: if (BufSwrite(linenum))
539: do_cl_eol(linenum);
540: else
541: PhysScreen[linenum].s_id = -1;
542: } else if (PhysScreen[linenum].s_id) /* not the same ... make sure */
543: do_cl_eol(linenum);
544: }
545:
546: private void
547: do_cl_eol(linenum)
548: register int linenum;
549: {
550: cl_eol();
551: PhysScreen[linenum] = DesiredScreen[linenum];
552: }
553:
554: #ifdef ID_CHAR
555:
556: /* From here to the end of the file is code that tries to utilize the
557: insert/delete character feature on some terminals. It is very confusing
558: and not so well written code, AND there is a lot of it. You may want
559: to use the space for something else. */
560:
561: extern struct screenline *Screen;
562: int IN_INSmode = 0;
563:
564: int UseIC;
565:
566: int DClen,
567: MDClen,
568: IClen,
569: MIClen,
570: IMlen,
571: CElen;
572:
573: void
574: disp_opt_init()
575: {
576: DClen = DC ? strlen(DC) : 0;
577: MDClen = M_DC ? strlen(M_DC) : 9999;
578: IClen = IC ? strlen(IC) : 0;
579: MIClen = M_IC ? strlen(M_IC) : 9999;
580: IMlen = IM ? strlen(IM) : 0;
581: CElen = CE ? strlen(CE) : 0;
582:
583: UseIC = (IC || IM || M_IC);
584: }
585:
586: void
587: INSmode(on)
588: {
589: if (on && !IN_INSmode) {
590: putpad(IM, 1);
591: IN_INSmode = YES;
592: } else if (!on && IN_INSmode) {
593: putpad(EI, 1);
594: IN_INSmode = NO;
595: }
596: }
597:
598: private void
599: DeTab(s_offset, buf, outbuf, limit, visspace)
600: register char *buf;
601: char *outbuf;
602: {
603: register char *phys_p = outbuf,
604: c;
605: register int pos = 0;
606: char *limitp = &outbuf[limit];
607:
608: #define OkayOut(ch) if ((pos++ >= s_offset) && (phys_p < limitp))\
609: *phys_p++ = ch;\
610: else
611:
612: while (c = *buf++) {
613: if (c == '\t') {
614: int nchars = (tabstop - (pos % tabstop));
615:
616: if (visspace) {
617: OkayOut('>');
618: nchars -= 1;
619: }
620: while (--nchars >= 0)
621: OkayOut(' ');
622:
623: } else if (isctrl(c)) {
624: OkayOut('^');
625: OkayOut(c == 0177 ? '?' : c + '@');
626: } else {
627: if (visspace && c == ' ')
628: c = '_';
629: OkayOut(c);
630: }
631: if (pos - s_offset >= CO) {
632: phys_p = &outbuf[CO - 1];
633: *phys_p++ = '!';
634: break;
635: }
636: }
637: *phys_p = 0;
638: }
639:
640: /* ID character routines full of special cases and other fun stuff like that.
641: It actually works though ...
642:
643: Returns Non-Zero if you are finished (no differences left). */
644:
645: private int
646: IDchar(new, lineno, col)
647: register char *new;
648: {
649: register int i;
650: int j,
651: oldlen,
652: NumSaved;
653: register struct screenline *sline = &Screen[lineno];
654:
655: oldlen = sline->s_length - sline->s_line;
656:
657: for (i = col; i < oldlen && new[i] != 0; i++)
658: if (sline->s_line[i] != new[i])
659: break;
660: if (new[i] == 0 || i == oldlen)
661: return (new[i] == 0 && i == oldlen);
662:
663: for (j = i + 1; j < oldlen && new[j]; j++) {
664: if (new[j] == sline->s_line[i]) {
665: NumSaved = IDcomp(new + j, sline->s_line + i,
666: strlen(new)) + NumSimilar(new + i,
667: sline->s_line + i, j - i);
668: if (OkayInsert(NumSaved, j - i)) {
669: InsChar(lineno, i, j - i, new);
670: return(IDchar(new, lineno, j));
671: }
672: }
673: }
674:
675: for (j = i + 1; j < oldlen && new[i]; j++) {
676: if (new[i] == sline->s_line[j]) {
677: NumSaved = IDcomp(new + i, sline->s_line + j,
678: oldlen - j);
679: if (OkayDelete(NumSaved, j - i, new[oldlen] == 0)) {
680: DelChar(lineno, i, j - i);
681: return(IDchar(new, lineno, j));
682: }
683: }
684: }
685: return 0;
686: }
687:
688: private int
689: NumSimilar(s, t, n)
690: register char *s,
691: *t;
692: {
693: register int num = 0;
694:
695: while (n--)
696: if (*s++ == *t++)
697: num += 1;
698: return num;
699: }
700:
701: private int
702: IDcomp(s, t, len)
703: register char *s,
704: *t;
705: {
706: register int i;
707: int num = 0,
708: nonspace = 0;
709: char c;
710:
711: for (i = 0; i < len; i++) {
712: if ((c = *s++) != *t++)
713: break;
714: if (c != ' ')
715: nonspace++;
716: if (nonspace)
717: num += 1;
718: }
719:
720: return num;
721: }
722:
723: private int
724: OkayDelete(Saved, num, samelength)
725: {
726: /* If the old and the new are the same length, then we don't
727: * have to clear to end of line. We take that into consideration.
728: */
729: return ((Saved + (!samelength ? CElen : 0))
730: > min(MDClen, DClen * num));
731: }
732:
733: private int
734: OkayInsert(Saved, num)
735: {
736: register int n = 0;
737:
738: if (IC) /* Per character prefixes */
739: n = min(num * IClen, MIClen);
740:
741: if (IM && !IN_INSmode) {
742: /* Good terminal. Fewer characters in this case */
743: n += IMlen;
744: }
745:
746: n += num; /* The characters themselves */
747:
748: return Saved > n;
749: }
750:
751: extern int CapCol;
752: extern char *cursend;
753: extern struct screenline *Curline;
754:
755: private void
756: DelChar(lineno, col, num)
757: {
758: register char *from,
759: *to;
760: register int i;
761: struct screenline *sp = (&Screen[lineno]);
762:
763: Placur(lineno, col);
764: if (M_DC && num > 1) {
765: char minibuf[16];
766:
767: sprintf(minibuf, M_DC, num);
768: putpad(minibuf, num);
769: } else {
770: for (i = num; --i >= 0; )
771: putpad(DC, 1);
772: }
773:
774: to = sp->s_line + col;
775: from = to + num;
776:
777: byte_copy(from, to, sp->s_length - from + 1);
778: clrline(sp->s_length - num, sp->s_length);
779: sp->s_length -= num;
780: }
781:
782: private void
783: InsChar(lineno, col, num, new)
784: char *new;
785: {
786: register char *sp1,
787: *sp2, /* To push over the array. */
788: *sp3; /* Last character to push over. */
789: int i;
790:
791: i_set(lineno, 0);
792: sp2 = Curline->s_length + num;
793:
794: if (sp2 >= cursend) {
795: i_set(lineno, CO - num - 1);
796: cl_eol();
797: sp2 = cursend - 1;
798: }
799: Curline->s_length = sp2;
800: sp1 = sp2 - num;
801: sp3 = Curline->s_line + col;
802:
803: while (sp1 >= sp3)
804: *sp2-- = *sp1--;
805:
806: new += col;
807: byte_copy(new, sp3, num);
808: /* The internal screen is correct, and now we have to do
809: the physical stuff. */
810:
811: Placur(lineno, col);
812: if (IM) {
813: if (!IN_INSmode)
814: INSmode(1);
815: } else if (M_IC && num > 1) {
816: char minibuf[16];
817:
818: sprintf(minibuf, M_IC, num);
819: putpad(minibuf, num);
820: } else if (IC) {
821: for (i = 0; i < num; i++)
822: putpad(IC, 1);
823: }
824: for (i = 0; i < num; i++) {
825: putchar(new[i]);
826: if (IN_INSmode)
827: putpad(IP, 1);
828: }
829: CapCol += num;
830: }
831:
832: #endif /* ID_CHAR */
833:
834: #ifdef UNIX /* obviously ... no mail today if not Unix*/
835:
836: /* chkmail() returns nonzero if there is new mail since the
837: last time we checked. */
838:
839: char Mailbox[FILESIZE]; /* initialized in main */
840: int MailInt = 60; /* check no more often than 60 seconds */
841: #ifdef BIFF
842: int BiffChk = NO; /* whether or not to turn off biff while in JOVE */
843: #endif
844:
845: int
846: chkmail(force)
847: {
848: time_t now;
849: static time_t last_chk = 0;
850: static int value = FALSE;
851: static off_t last_size = 0;
852: struct stat stbuf;
853: int last_val;
854: static time_t last_time = 0;
855:
856: time(&now);
857: if (!force && (now < last_chk + MailInt))
858: return value;
859: last_chk = now;
860: if (force)
861: last_time = now;
862: if (stat(Mailbox, &stbuf) < 0) {
863: value = FALSE;
864: return FALSE;
865: }
866: last_val = value;
867: value = ((stbuf.st_mtime > last_time) &&
868: (stbuf.st_size > 0) &&
869: (stbuf.st_size >= last_size) &&
870: (stbuf.st_mtime + 5 > stbuf.st_atime));
871: if (value == TRUE &&
872: ((value != last_val) || (stbuf.st_size != last_size)))
873: dobell(3);
874: if (stbuf.st_size < last_size)
875: last_time = now;
876: last_size = stbuf.st_size;
877: return value;
878: }
879:
880: #endif /* UNIX */
881:
882: /* Print the mode line. */
883:
884: private char *mode_p,
885: *mend_p;
886: int BriteMode = 1; /* modeline should standout */
887:
888: private void
889: mode_app(str)
890: register char *str;
891: {
892: if (mode_p >= mend_p)
893: return;
894: while ((mode_p < mend_p) && (*mode_p++ = *str++))
895: ;
896: mode_p -= 1; /* back over the null */
897: }
898:
899: char ModeFmt[120] = "%3c %w %[%sJOVE (%M) Buffer: %b \"%f\" %]%s%m*- %((%t)%s%)%e";
900:
901: private void
902: ModeLine(w)
903: register Window *w;
904: {
905: extern int i_line;
906: extern char *pwd();
907: int n,
908: ign_some = NO;
909: char line[MAXCOLS],
910: *fmt = ModeFmt,
911: fillc,
912: c;
913: register Buffer *thisbuf = w->w_bufp;
914: register Buffer *bp;
915:
916: mode_p = line;
917: mend_p = &line[(sizeof line) - 1];
918:
919: #if defined(UNIX) || (defined (MSDOS) && !defined(IBMPC))
920: if (BriteMode != 0 && SO == 0)
921: BriteMode = 0;
922: fillc = BriteMode ? ' ' : '-';
923: #endif /* UNIX */
924: #ifdef IBMPC /* very subtle - don't mess up attributes too much */
925: fillc = '-'; /*BriteMode ? ' ' : '-';*/
926: #endif /* IBMPC */
927: #ifdef MAC
928: fillc = '_'; /* looks better on a Mac */
929: #endif /* MAC */
930:
931: while (c = *fmt++) {
932: if (c != '%') {
933: if (c == '\\')
934: if ((c = *fmt++) == '\0')
935: break;
936: if (!ign_some)
937: *mode_p++ = c;
938: continue;
939: }
940: if ((c = *fmt++) == '\0') /* char after the '%' */
941: break;
942: if (ign_some && c != ')')
943: continue;
944: n = 1;
945: if (c >= '0' && c <= '9') {
946: n = 0;
947: while (c >= '0' && c <= '9') {
948: n = n * 10 + (c - '0');
949: c = *fmt++;
950: }
951: }
952: switch (c) {
953: case '(':
954: if (w->w_next != fwind) /* Not bottom window. */
955: ign_some = YES;
956: break;
957:
958: case ')':
959: ign_some = NO;
960: break;
961:
962: case '[':
963: case ']':
964: {
965: char *strs = (c == '[') ? "[[[[[[[[[[" : "]]]]]]]]]]";
966:
967: mode_app(strs + 10 - RecDepth);
968: break;
969: }
970:
971: #ifdef UNIX
972: case 'C': /* check mail here */
973: if (chkmail(NO))
974: mode_app("[New mail]");
975: break;
976:
977: #endif /* UNIX */
978:
979: case 'M':
980: {
981: static char *mmodes[] = {
982: "Fundamental ",
983: "Text ",
984: "C ",
985: #ifdef LISP
986: "Lisp ",
987: #endif
988: 0
989: };
990:
991: mode_app(mmodes[thisbuf->b_major]);
992:
993: if (BufMinorMode(thisbuf, Fill))
994: mode_app("Fill ");
995: if (BufMinorMode(thisbuf, Abbrev))
996: mode_app("Abbrev ");
997: if (BufMinorMode(thisbuf, OverWrite))
998: mode_app("OvrWt ");
999: if (BufMinorMode(thisbuf, Indent))
1000: mode_app("AI ");
1001: if (InMacDefine)
1002: mode_app("Def ");
1003: mode_p -= 1; /* Back over the extra space. */
1004: break;
1005: }
1006:
1007: case 'c':
1008: while (--n >= 0)
1009: *mode_p++ = fillc;
1010: break;
1011:
1012: #ifdef CHDIR
1013: case 'd': /* print working directory */
1014: mode_app(pr_name(pwd(), YES));
1015: break;
1016: #endif
1017:
1018: case 'e':
1019: {
1020: /* 2 space pad pluss padding for magic cookies */
1021: char *last_p = &line[CO - 2 - (2 * SG)];
1022:
1023: while (mode_p < last_p)
1024: *mode_p++ = fillc;
1025:
1026: goto outahere; /* %e means we're done! */
1027: }
1028:
1029: case 'b':
1030: mode_app(thisbuf->b_name);
1031: break;
1032:
1033: case 'f':
1034: case 'F':
1035: if (thisbuf->b_fname == 0)
1036: mode_app("[No file]");
1037: else {
1038: if (c == 'f')
1039: mode_app(pr_name(thisbuf->b_fname, YES));
1040: else
1041: mode_app(basename(thisbuf->b_fname));
1042: }
1043: break;
1044:
1045: #ifdef LOAD_AV
1046: case 'l':
1047: {
1048: double theavg;
1049: char minibuf[10];
1050:
1051: get_la(&theavg);
1052: theavg += .005; /* round to nearest .01 */
1053: sprintf(minibuf, "%d.%02d",
1054: (int) theavg,
1055: (int)((theavg - (int) theavg) * 100));
1056: mode_app(minibuf);
1057: break;
1058: }
1059: #endif
1060:
1061: case 'm':
1062: if (IsModified(w->w_bufp))
1063: *mode_p++ = fmt[0];
1064: else
1065: *mode_p++ = fmt[1];
1066: fmt += 2; /* skip two characters */
1067: break;
1068:
1069: case 'n':
1070: {
1071: char tmp[16];
1072: for (bp = world, n = 1; bp != 0; bp = bp->b_next, n++)
1073: if (bp == thisbuf)
1074: break;
1075:
1076: sprintf(tmp, "%d", n);
1077: mode_app(tmp);
1078: break;
1079: }
1080:
1081: #ifdef IPROCS
1082: case 'p':
1083: if (thisbuf->b_type == B_PROCESS) {
1084: char tmp[40];
1085:
1086: sprintf(tmp, "(%s)", (thisbuf->b_process == 0) ?
1087: "No process" :
1088: pstate(thisbuf->b_process));
1089: mode_app(tmp);
1090: break;
1091: }
1092: #endif
1093:
1094: case 's':
1095: if (mode_p[-1] == ' ')
1096: continue;
1097: *mode_p++ = ' ';
1098: break;
1099:
1100: case 't':
1101: {
1102: char timestr[12];
1103:
1104: mode_app(get_time((time_t *) 0, timestr, 11, 16));
1105: break;
1106: }
1107:
1108: case 'w':
1109: if (w->w_LRscroll > 0)
1110: mode_app(">");
1111: }
1112: }
1113:
1114: outahere:
1115: *mode_p = 0;
1116:
1117: /* Highlight mode line. */
1118: if (BriteMode) {
1119: #ifdef ID_CHAR
1120: if (IN_INSmode)
1121: INSmode(0);
1122: #endif
1123: #ifdef TERMCAP
1124: putpad(SO, 1);
1125: #else
1126: SO_on();
1127: #endif /* TERMCAP */
1128: }
1129: if (swrite(line, BriteMode, YES))
1130: do_cl_eol(i_line);
1131: else
1132: UpdModLine = 1;
1133: if (BriteMode)
1134: #ifdef TERMCAP
1135: putpad(SE, 1);
1136: #else
1137: SO_off();
1138: #endif /* TERMCAP */
1139: }
1140:
1141: /* This tries to place the current line of the current window in the
1142: center of the window, OR to place it at the arg'th line of the window.
1143: This also causes the horizontal position of the line to be centered,
1144: if the line needs scrolling, or moved all the way back to the left,
1145: if that's possible. */
1146: void
1147: RedrawDisplay()
1148: {
1149: int line;
1150: Line *newtop = prev_line((curwind->w_line = curline), is_an_arg() ?
1151: arg_value() : HALF(curwind));
1152:
1153: if ((line = in_window(curwind, curwind->w_line)) != -1)
1154: PhysScreen[line].s_offset = -1;
1155: if (newtop == curwind->w_top)
1156: v_clear(FLine(curwind), FLine(curwind) + SIZE(curwind));
1157: else
1158: SetTop(curwind, newtop);
1159: }
1160:
1161: void
1162: v_clear(line1, line2)
1163: register int line1;
1164: {
1165: register struct scrimage *phys_p, *des_p;
1166:
1167: phys_p = &PhysScreen[line1];
1168: des_p = &DesiredScreen[line1];
1169:
1170: while (line1 <= line2) {
1171: i_set(line1, 0);
1172: cl_eol();
1173: phys_p->s_id = des_p->s_id = 0;
1174: phys_p += 1;
1175: des_p += 1;
1176: line1 += 1;
1177: }
1178: }
1179:
1180: void
1181: ClAndRedraw()
1182: {
1183: cl_scr(YES);
1184: }
1185:
1186: void
1187: NextPage()
1188: {
1189: Line *newline;
1190:
1191: if (Asking)
1192: return;
1193: if (arg_value() < 0) {
1194: negate_arg_value();
1195: PrevPage();
1196: return;
1197: }
1198: if (arg_type() == YES)
1199: UpScroll();
1200: else {
1201: if (in_window(curwind, curwind->w_bufp->b_last) != -1) {
1202: rbell();
1203: return;
1204: }
1205: newline = next_line(curwind->w_top, max(1, SIZE(curwind) - 1));
1206: SetTop(curwind, curwind->w_line = newline);
1207: if (curwind->w_bufp == curbuf)
1208: SetLine(newline);
1209: }
1210: }
1211:
1212: #ifdef MSDOS /* kg */
1213:
1214: void
1215: PageScrollUp()
1216: {
1217: int i, n;
1218:
1219: n = max(1, SIZE(curwind) - 1);
1220: for (i=0; i<n; i++) {
1221: UpScroll();
1222: redisplay();
1223: }
1224: }
1225:
1226: void
1227: PageScrollDown()
1228: {
1229: int i, n;
1230:
1231: n = max(1, SIZE(curwind) - 1);
1232: for (i=0; i<n; i++) {
1233: DownScroll();
1234: redisplay();
1235: }
1236: }
1237: #endif /* MSDOS */
1238:
1239: void
1240: PrevPage()
1241: {
1242: Line *newline;
1243:
1244: if (Asking)
1245: return;
1246: if (arg_value() < 0) {
1247: negate_arg_value();
1248: NextPage();
1249: return;
1250: }
1251: if (arg_type() == YES)
1252: DownScroll();
1253: else {
1254: newline = prev_line(curwind->w_top, max(1, SIZE(curwind) - 1));
1255: SetTop(curwind, curwind->w_line = newline);
1256: if (curwind->w_bufp == curbuf)
1257: SetLine(newline);
1258: }
1259: }
1260:
1261: void
1262: UpScroll()
1263: {
1264: SetTop(curwind, next_line(curwind->w_top, arg_value()));
1265: if ((curwind->w_bufp == curbuf) &&
1266: (in_window(curwind, curline) == -1))
1267: SetLine(curwind->w_top);
1268: }
1269:
1270: void
1271: DownScroll()
1272: {
1273: SetTop(curwind, prev_line(curwind->w_top, arg_value()));
1274: if ((curwind->w_bufp == curbuf) &&
1275: (in_window(curwind, curline) == -1))
1276: SetLine(curwind->w_top);
1277: }
1278:
1279: int VisBell = NO,
1280: RingBell = NO; /* So if we have a lot of errors ...
1281: ring the bell only ONCE */
1282: void
1283: rbell()
1284: {
1285: RingBell = YES;
1286: }
1287:
1288: /* Message prints the null terminated string onto the bottom line of the
1289: terminal. */
1290:
1291: void
1292: message(str)
1293: char *str;
1294: {
1295: if (InJoverc)
1296: return;
1297: UpdMesg = YES;
1298: errormsg = NO;
1299: if (str != mesgbuf)
1300: null_ncpy(mesgbuf, str, (sizeof mesgbuf) - 1);
1301: }
1302:
1303: /* End of Window */
1304:
1305: void
1306: Eow()
1307: {
1308: if (Asking)
1309: return;
1310: SetLine(next_line(curwind->w_top, SIZE(curwind) - 1 -
1311: min(SIZE(curwind) - 1, arg_value() - 1)));
1312: if (!is_an_arg())
1313: Eol();
1314: }
1315:
1316: /* Beginning of Window */
1317:
1318: void
1319: Bow()
1320: {
1321: if (Asking)
1322: return;
1323: SetLine(next_line(curwind->w_top, min(SIZE(curwind) - 1, arg_value() - 1)));
1324: }
1325:
1326: private int LineNo,
1327: last_col,
1328: DoAutoNL;
1329: private Window *old_wind; /* save the window we were in BEFORE
1330: before we were called, if UseBuffers
1331: is nonzero */
1332:
1333: int UseBuffers = FALSE;
1334: int TOabort = 0;
1335:
1336: /* This initializes the typeout. If send-typeout-to-buffers is set
1337: the buffer NAME is created (emptied if it already exists) and output
1338: goes to the buffer. Otherwise output is drawn on the screen and
1339: erased by TOstop() */
1340:
1341: void
1342: TOstart(name, auto_newline)
1343: char *name;
1344: {
1345: if (UseBuffers) {
1346: old_wind = curwind;
1347: pop_wind(name, YES, B_SCRATCH);
1348: } else
1349: DisabledRedisplay = YES;
1350: TOabort = LineNo = last_col = 0;
1351: DoAutoNL = auto_newline;
1352: }
1353:
1354: /* VARARGS1 */
1355:
1356: void
1357: Typeout(fmt, va_alist)
1358: char *fmt;
1359: va_dcl
1360: {
1361: if (TOabort)
1362: return;
1363:
1364: if (!UseBuffers && (LineNo == ILI - 1)) {
1365: register int c;
1366:
1367: LineNo = 0;
1368: last_col = 0;
1369: f_mess("--more--");
1370: if ((c = getchar()) != ' ') {
1371: TOabort = YES;
1372: if (c != AbortChar && c != RUBOUT)
1373: Ungetc(c);
1374: f_mess(NullStr);
1375: return;
1376: }
1377: f_mess(NullStr);
1378: }
1379:
1380: if (fmt) {
1381: extern int i_col;
1382: char string[132];
1383: va_list ap;
1384:
1385: va_start(ap);
1386: format(string, sizeof string, fmt, ap);
1387: va_end(ap);
1388: if (UseBuffers)
1389: ins_str(string, NO);
1390: else {
1391: i_set(LineNo, last_col);
1392: (void) swrite(string, NO, YES);
1393: last_col = i_col;
1394: }
1395: }
1396: if (!UseBuffers) {
1397: PhysScreen[LineNo].s_id = -1;
1398: if (fmt == 0 || DoAutoNL == YES) {
1399: cl_eol();
1400: flusho();
1401: LineNo += 1;
1402: last_col = 0;
1403: }
1404: } else if (fmt == 0 || DoAutoNL != 0)
1405: ins_str("\n", NO);
1406: }
1407:
1408: void
1409: TOstop()
1410: {
1411: int c;
1412:
1413: if (UseBuffers) {
1414: ToFirst();
1415: SetWind(old_wind);
1416: } else {
1417: if (TOabort) {
1418: DisabledRedisplay = NO;
1419: return;
1420: }
1421: if (last_col != 0)
1422: Typeout((char *) 0);
1423: Typeout("----------");
1424: cl_eol();
1425: flusho();
1426: c = getchar();
1427: if (c != ' ')
1428: Ungetc(c);
1429: DisabledRedisplay = NO;
1430: }
1431: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.