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