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