![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.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 screen.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 "io.h"
12: #include "ctype.h"
13: #include "temp.h"
14: #include "termcap.h"
15:
16: extern int BufSize;
17:
18: int OkayAbort,
19: tabstop = 8;
20:
21: int (*TTins_line)(),
22: (*TTdel_line)();
23:
24: struct scrimage
25: *DesiredScreen = 0,
26: *PhysScreen = 0;
27:
28: struct screenline *Screen = 0, /* the screen (a bunch of screenline) */
29: *Savelines = 0, /* another bunch (LI of them) */
30: *Curline = 0; /* current line */
31: char *cursor, /* offset into current Line */
32: *cursend;
33:
34: int CapCol,
35: CapLine,
36:
37: i_line,
38: i_col;
39:
40: make_scr()
41: {
42: register int i;
43: register struct screenline *ns;
44: register char *nsp;
45:
46: #ifdef RESHAPING
47: /* In case we are RESHAPING the window! */
48: if (DesiredScreen)
49: free((char *) DesiredScreen);
50: if (PhysScreen)
51: free((char *) PhysScreen);
52: if (Savelines)
53: free((char *) Savelines);
54: if (Screen) {
55: ns = Screen;
56: for (i = 0; i < LI; i++)
57: free((ns++)->s_line);
58: free((char *) Screen);
59: }
60: #endif RESHAPING
61:
62: DesiredScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage));
63: PhysScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage));
64:
65: Savelines = (struct screenline *)
66: malloc((unsigned) LI * sizeof(struct screenline));
67: ns = Screen = (struct screenline *)
68: malloc((unsigned) LI * sizeof(struct screenline));
69:
70: nsp = (char *) malloc((unsigned)CO * LI);
71: if (nsp == 0) {
72: printf("\n\rCannot malloc screen!\n");
73: finish(1);
74: }
75:
76: for (i = 0; i < LI; i++) {
77: ns->s_line = nsp;
78: nsp += CO;
79: ns->s_length = nsp - 1; /* End of Line */
80: ns++;
81: }
82: cl_scr(0);
83: }
84:
85: clrline(cp1, cp2)
86: register char *cp1,
87: *cp2;
88: {
89: while (cp1 <= cp2)
90: *cp1++ = ' ';
91: }
92:
93: #define sputc(c) ((*cursor != (char) (c)) ? dosputc(c) : (cursor++, i_col++))
94: #define soutputc(c) if (--n <= 0) break; else sputc(c)
95:
96: cl_eol()
97: {
98: if (cursor > cursend)
99: return;
100:
101: if (cursor < Curline->s_length) {
102: if (CE) {
103: Placur(i_line, i_col);
104: putpad(CE, 1);
105: clrline(cursor, Curline->s_length);
106: } else {
107: /* Ugh. The slow way for dumb terminals. */
108: register char *savecp = cursor;
109:
110: while (cursor <= Curline->s_length)
111: sputc(' ');
112: cursor = savecp;
113: }
114: Curline->s_length = cursor;
115: }
116: }
117:
118: cl_scr(doit)
119: {
120: register int i;
121: register struct screenline *sp = Screen;
122:
123: for (i = 0; i < LI; i++, sp++) {
124: clrline(sp->s_line, sp->s_length);
125: sp->s_length = sp->s_line;
126: PhysScreen[i].s_id = 0;
127: }
128: if (doit) {
129: putpad(CL, LI);
130: CapCol = CapLine = 0;
131: UpdMesg++;
132: }
133: }
134:
135: #ifdef ID_CHAR
136: extern int IN_INSmode;
137: #endif
138:
139: /* Output one character (if necessary) at the current position */
140:
141: dosputc(c)
142: register char c;
143: {
144: if (*cursor != c) {
145: #ifdef ID_CHAR
146: if (IN_INSmode)
147: INSmode(0);
148: #endif
149: if (i_line != CapLine || i_col != CapCol)
150: Placur(i_line, i_col);
151: if (UL && (c & 0177) == '_' && (*cursor & 0177) != ' ')
152: putstr(" \b"); /* Erase so '_' looks right. */
153: *cursor++ = c;
154: putchar(c & 0177);
155: CapCol++;
156: i_col++;
157: } else {
158: cursor++;
159: i_col++;
160: }
161: }
162:
163: /* Write `line' at the current position of `cursor'. Stop when we
164: reach the end of the screen. Aborts if there is a character
165: waiting. */
166:
167: swrite(line, inversep, abortable)
168: register char *line;
169: register int abortable;
170: {
171: register int c;
172: int col = i_col,
173: aborted = 0;
174: register int n = cursend - cursor;
175: int or_byte = inversep ? 0200 : 0,
176: thebyte;
177:
178: if (n <= 0)
179: return 1;
180:
181: OkayAbort = 0;
182: while (c = *line++) {
183: if (abortable && OkayAbort) {
184: OkayAbort = NO;
185: if (InputPending = charp()) {
186: aborted = 1;
187: break;
188: }
189: }
190: if (c == '\t') {
191: int nchars;
192:
193: nchars = (tabstop - (col % tabstop));
194: col += nchars;
195:
196: thebyte = (' ' | or_byte);
197: while (nchars--)
198: soutputc(thebyte);
199: if (n <= 0)
200: break;
201: } else if (isctrl(c)) {
202: thebyte = ('^' | or_byte);
203: soutputc(thebyte);
204: thebyte = (((c == '\177') ? '?' : c + '@') | or_byte);
205: soutputc(thebyte);
206: col += 2;
207: } else {
208: thebyte = (c | or_byte);
209: soutputc(thebyte);
210: col++;
211: }
212: }
213: if (n <= 0) {
214: thebyte = ('!' | or_byte);
215: sputc(thebyte);
216: }
217: if (cursor > Curline->s_length)
218: Curline->s_length = cursor;
219: return !aborted;
220: }
221:
222: /* This is for writing a buffer line to the screen. This is to
223: minimize the amount of copying from one buffer to another buffer.
224: This gets the info directly from the disk buffers. */
225:
226: BufSwrite(linenum)
227: {
228: char *bp;
229: register int n = cursend - cursor,
230: col = 0,
231: c;
232: int StartCol = DesiredScreen[linenum].s_offset,
233: visspace = DesiredScreen[linenum].s_window->w_visspace,
234: aborted = 0;
235:
236: bp = lcontents(DesiredScreen[linenum].s_lp);
237: if (*bp) for (;;) {
238: if (col >= StartCol) {
239: DesiredScreen[linenum].s_offset = col;
240: break;
241: }
242:
243: c = *bp++ & 0177;
244: if (c == '\t')
245: col += (tabstop - (col % tabstop));
246: else if (isctrl(c))
247: col += 2;
248: else
249: col++;
250: }
251:
252: OkayAbort = 0;
253: while (c = (*bp++ & 0177)) {
254: if (OkayAbort) {
255: OkayAbort = NO;
256: if (InputPending = charp()) {
257: aborted = 1;
258: break;
259: }
260: }
261: if (c == '\t') {
262: int nchars = (tabstop - (col % tabstop));
263:
264: col += nchars;
265: if (visspace) {
266: soutputc('>');
267: nchars--;
268: }
269: while (--nchars >= 0)
270: soutputc(' ');
271: if (n <= 0)
272: break;
273: } else if (isctrl(c)) {
274: soutputc('^');
275: soutputc((c == '\177') ? '?' : c + '@');
276: col += 2;
277: } else {
278: if (visspace && c == ' ')
279: c = '_';
280: soutputc(c);
281: col++;
282: }
283: }
284: if (n <= 0)
285: sputc('!');
286: if (cursor > Curline->s_length)
287: Curline->s_length = cursor;
288: return !aborted; /* Didn't abort */
289: }
290:
291: i_set(nline, ncol)
292: register int nline,
293: ncol;
294: {
295: Curline = &Screen[nline];
296: cursor = Curline->s_line + ncol;
297: cursend = &Curline->s_line[CO - 1];
298: i_line = nline;
299: i_col = ncol;
300: }
301:
302: /* Insert `num' lines a top, but leave all the lines BELOW `bottom'
303: alone (at least they won't look any different when we are done).
304: This changes the screen array AND does the physical changes. */
305:
306: v_ins_line(num, top, bottom)
307: {
308: register int i;
309:
310: /* Save the screen pointers. */
311:
312: for(i = 0; i < num && top + i <= bottom; i++)
313: Savelines[i] = Screen[bottom - i];
314:
315: /* Num number of bottom lines will be lost.
316: Copy everything down num number of times. */
317:
318: for (i = bottom; i > top && i-num >= 0; i--)
319: Screen[i] = Screen[i - num];
320:
321: /* Restore the saved ones, making them blank. */
322:
323: for (i = 0; i < num; i++) {
324: Screen[top + i] = Savelines[i];
325: clrline(Screen[top + i].s_line, Screen[top + i].s_length);
326: Screen[top + i].s_length = Screen[top + i].s_line;
327: }
328:
329: (*TTins_line)(top, bottom, num);
330: }
331:
332: /* Delete `num' lines starting at `top' leaving the lines below `bottom'
333: alone. This updates the internal image as well as the physical image. */
334:
335: v_del_line(num, top, bottom)
336: {
337: register int i,
338: bot;
339:
340: bot = bottom;
341:
342: /* Save the lost lines. */
343:
344: for (i = 0; i < num && top + i <= bottom; i++)
345: Savelines[i] = Screen[top + i];
346:
347: /* Copy everything up num number of lines. */
348:
349: for (i = top; num + i <= bottom; i++)
350: Screen[i] = Screen[i + num];
351:
352: /* Restore the lost ones, clearing them. */
353:
354: for (i = 0; i < num; i++) {
355: Screen[bottom - i] = Savelines[i];
356: clrline(Screen[bot].s_line, Screen[bot].s_length);
357: Screen[bot].s_length = Screen[bot].s_line;
358: bot--;
359: }
360:
361: (*TTdel_line)(top, bottom, num);
362: }
363:
364:
365: /* The cursor optimization happens here. You may decide that this
366: is going too far with cursor optimization, or perhaps it should
367: limit the amount of checking to when the output speed is slow.
368: What ever turns you on ... */
369:
370: private struct cursaddr {
371: int c_numchars,
372: (*c_proc)();
373: };
374:
375: private char *Cmstr;
376: private struct cursaddr *HorMin,
377: *VertMin,
378: *DirectMin;
379:
380: private ForMotion(),
381: ForTab(),
382: BackMotion(),
383: RetTab(),
384: DownMotion(),
385: UpMotion(),
386: GoDirect(),
387: HomeGo(),
388: BottomUp();
389:
390:
391: private struct cursaddr WarpHor[] = {
392: 0, ForMotion,
393: 0, ForTab,
394: 0, BackMotion,
395: 0, RetTab
396: };
397:
398: private struct cursaddr WarpVert[] = {
399: 0, DownMotion,
400: 0, UpMotion
401: };
402:
403: private struct cursaddr WarpDirect[] = {
404: 0, GoDirect,
405: 0, HomeGo,
406: 0, BottomUp
407: };
408:
409: #undef FORWARD
410: #define FORWARD 0 /* Move forward */
411: #define FORTAB 1 /* Forward using tabs */
412: #undef BACKWARD
413: #define BACKWARD 2 /* Move backward */
414: #define RETFORWARD 3 /* Beginning of line and then tabs */
415: #define NUMHOR 4
416:
417: #define DOWN 0 /* Move down */
418: #define UPMOVE 1 /* Move up */
419: #define NUMVERT 2
420:
421: #define DIRECT 0 /* Using CM */
422: #define HOME 1 /* HOME */
423: #define LOWER 2 /* Lower Line */
424: #define NUMDIRECT 3
425:
426: #define home() Placur(0, 0)
427: #define LowLine() putpad(LL, 1), CapLine = ILI, CapCol = 0
428: #define PrintHo() putpad(HO, 1), CapLine = CapCol = 0
429:
430: int phystab = 8;
431:
432: private
433: GoDirect(line, col)
434: register int line,
435: col;
436: {
437: putpad(Cmstr, 1);
438: CapLine = line;
439: CapCol = col;
440: }
441:
442: private
443: RetTab(col)
444: register int col;
445: {
446: putchar('\r');
447: CapCol = 0;
448: ForTab(col);
449: }
450:
451: private
452: HomeGo(line, col)
453: {
454: PrintHo();
455: DownMotion(line);
456: ForTab(col);
457: }
458:
459: private
460: BottomUp(line, col)
461: register int line,
462: col;
463: {
464: LowLine();
465: UpMotion(line);
466: ForTab(col);
467: }
468:
469: /* Tries to move forward using tabs (if possible). It tabs to the
470: closest tabstop which means it may go past 'destcol' and backspace
471: to it. */
472:
473: private
474: ForTab(destcol)
475: int destcol;
476: {
477: register int tabgoal,
478: ntabs,
479: tabstp = phystab;
480:
481: if (TABS && (tabstp > 0)) {
482: tabgoal = destcol + (tabstp / 2);
483: tabgoal -= (tabgoal % tabstp);
484:
485: /* Don't tab to last place or else it is likely to screw up. */
486: if (tabgoal >= CO)
487: tabgoal -= tabstp;
488:
489: ntabs = (tabgoal / tabstp) - (CapCol / tabstp);
490: while (--ntabs >= 0)
491: putchar('\t');
492: CapCol = tabgoal;
493: }
494: if (CapCol > destcol)
495: BackMotion(destcol);
496: else if (CapCol < destcol)
497: ForMotion(destcol);
498: }
499:
500: private
501: ForMotion(destcol)
502: register int destcol;
503: {
504: register int nchars = destcol - CapCol;
505: register char *cp = &Screen[CapLine].s_line[CapCol];
506:
507: while (--nchars >= 0)
508: putchar(*cp++ & 0177);
509: CapCol = destcol;
510: }
511:
512: private
513: BackMotion(destcol)
514: register int destcol;
515: {
516: register int nchars = CapCol - destcol;
517:
518: if (BC)
519: while (--nchars >= 0)
520: putpad(BC, 1);
521: else
522: while (--nchars >= 0)
523: putchar('\b');
524: CapCol = destcol;
525: }
526:
527: private
528: DownMotion(destline)
529: register int destline;
530: {
531: register int nlines = destline - CapLine;
532:
533: while (--nlines >= 0)
534: putchar('\n');
535: CapLine = destline;
536: }
537:
538: private
539: UpMotion(destline)
540: register int destline;
541: {
542: register int nchars = CapLine - destline;
543:
544: while (--nchars >= 0)
545: putpad(UP, 1);
546: CapLine = destline;
547: }
548:
549: #ifdef ID_CHAR
550: static int EIlen;
551: #endif
552: extern int IMlen;
553:
554: InitCM()
555: {
556: HOlen = HO ? strlen(HO) : 1000;
557: LLlen = LL ? strlen(LL) : 1000;
558: UPlen = UP ? strlen(UP) : 1000;
559: #ifdef ID_CHAR
560: if (EI)
561: EIlen = strlen(EI);
562: #endif
563: }
564:
565: Placur(line, col)
566: {
567: int dline, /* Number of lines to move */
568: dcol; /* Number of columns to move */
569: register int best,
570: i;
571: register struct cursaddr *cp;
572: int xtracost = 0; /* Misc addition to cost. */
573:
574: #define CursMin(which,addrs,max) \
575: for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \
576: if (cp->c_numchars < addrs[best].c_numchars) \
577: best = i; \
578: which = &addrs[best];
579:
580: if (line == CapLine && col == CapCol)
581: return; /* We are already there. */
582:
583: dline = line - CapLine;
584: dcol = col - CapCol;
585: #ifdef ID_CHAR
586: if (IN_INSmode && MI)
587: xtracost = EIlen + IMlen;
588: /* If we're already in insert mode, it is likely that we will
589: want to be in insert mode again, after the insert. */
590: #endif
591:
592: /* Number of characters to move horizontally for each case.
593: 1: Just move forward by typing the right character on the screen.
594: 2: Print the correct number of back spaces.
595: 3: Try tabbing to the correct place.
596: 4: Try going to the beginning of the line, and then tab. */
597:
598: if (dcol == 1 || dcol == 0) { /* Most common case. */
599: HorMin = &WarpHor[FORWARD];
600: HorMin->c_numchars = dcol + xtracost;
601: } else {
602: WarpHor[FORWARD].c_numchars = dcol >= 0 ? dcol + xtracost : 1000;
603: WarpHor[BACKWARD].c_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
604: WarpHor[FORTAB].c_numchars = dcol >= 0 && TABS ?
605: ForNum(CapCol, col) + xtracost : 1000;
606: WarpHor[RETFORWARD].c_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
607:
608: /* Which is the shortest of the bunch */
609:
610: CursMin(HorMin, WarpHor, NUMHOR);
611: }
612:
613: /* Moving vertically is more simple. */
614:
615: WarpVert[DOWN].c_numchars = dline >= 0 ? dline : 1000;
616: WarpVert[UPMOVE].c_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
617:
618: /* Which of these is simpler */
619: CursMin(VertMin, WarpVert, NUMVERT);
620:
621: /* Homing first and lowering first are considered
622: direct motions.
623: Homing first's total is the sum of the cost of homing
624: and the sum of tabbing (if possible) to the right. */
625:
626: if (VertMin->c_numchars + HorMin->c_numchars <= 3) {
627: DirectMin = &WarpDirect[DIRECT]; /* A dummy ... */
628: DirectMin->c_numchars = 100;
629: } else {
630: WarpDirect[DIRECT].c_numchars = CM ?
631: strlen(Cmstr = tgoto(CM, col, line)) : 1000;
632: WarpDirect[HOME].c_numchars = HOlen + line +
633: WarpHor[RETFORWARD].c_numchars;
634: WarpDirect[LOWER].c_numchars = LLlen + ((ILI - line) * UPlen) +
635: WarpHor[RETFORWARD].c_numchars;
636: CursMin(DirectMin, WarpDirect, NUMDIRECT);
637: }
638:
639: if (HorMin->c_numchars + VertMin->c_numchars < DirectMin->c_numchars) {
640: if (line != CapLine)
641: (*VertMin->c_proc)(line);
642: if (col != CapCol) {
643: #ifdef ID_CHAR
644: if (IN_INSmode) /* We may use real characters ... */
645: INSmode(0);
646: #endif
647: (*HorMin->c_proc)(col);
648: }
649: } else {
650: #ifdef ID_CHAR
651: if (IN_INSmode && !MI)
652: INSmode(0);
653: #endif
654: (*DirectMin->c_proc)(line, col);
655: }
656: }
657:
658: #define abs(x) ((x) >= 0 ? (x) : -(x))
659:
660: ForNum(from, to)
661: register int from;
662: {
663: register int tabgoal,
664: tabstp = phystab;
665: int numchars = 0;
666:
667: if (from >= to)
668: return from - to;
669: if (TABS && (tabstp > 0)) {
670: tabgoal = to + (tabstp / 2);
671: tabgoal -= (tabgoal % tabstp);
672: if (tabgoal >= CO)
673: tabgoal -= tabstp;
674: numchars = (tabgoal / tabstop) - (from / tabstp);
675: from = tabgoal;
676: }
677: return numchars + abs(from - to);
678: }
679:
680: #ifdef WIRED_TERMS
681:
682: BGi_lines(top, bottom, num)
683: {
684: printf("\033[%d;%dr\033[%dL\033[r", top + 1, bottom + 1, num);
685: CapCol = CapLine = 0;
686: }
687:
688: SUNi_lines(top, bottom, num)
689: {
690: Placur(bottom - num + 1, 0);
691: printf("\033[%dM", num);
692: Placur(top, 0);
693: printf("\033[%dL", num);
694: }
695:
696: C100i_lines(top, bottom, num)
697: {
698: if (num <= 1) {
699: GENi_lines(top, bottom, num);
700: return;
701: }
702: printf("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO);
703: CapLine = CapCol = 0;
704: Placur(top, 0);
705: while (num--)
706: putpad(AL, ILI - CapLine);
707: printf("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO);
708: CapLine = CapCol = 0;
709: }
710:
711: #endif WIRED_TERMS
712:
713: GENi_lines(top, bottom, num)
714: {
715: register int i;
716:
717: if (CS) {
718: printf(tgoto(CS, bottom, top));
719: CapCol = CapLine = 0;
720: Placur(top, 0);
721: for (i = 0; i < num; i++)
722: putpad(SR, bottom - top);
723: printf(tgoto(CS, ILI, 0));
724: CapCol = CapLine = 0;
725: } else {
726: Placur(bottom - num + 1, 0);
727: if (M_DL && (num > 1)) {
728: char minibuf[16];
729:
730: sprintf(minibuf, M_DL, num);
731: putpad(minibuf, ILI - CapLine);
732: } else {
733: for (i = 0; i < num; i++)
734: putpad(DL, ILI - CapLine);
735: }
736: Placur(top, 0);
737: if (M_AL && (num > 1)) {
738: char minibuf[16];
739:
740: sprintf(minibuf, M_AL, num);
741: putpad(minibuf, ILI - CapLine);
742: } else {
743: for (i = 0; i < num; i++)
744: putpad(AL, ILI - CapLine);
745: }
746: }
747: }
748:
749: #ifdef WIRED_TERMS
750:
751: BGd_lines(top, bottom, num)
752: {
753: printf("\033[%d;%dr\033[%dM\033[r", top + 1, bottom + 1, num);
754: CapCol = CapLine = 0;
755: }
756:
757: SUNd_lines(top, bottom, num)
758: {
759: Placur(top, 0);
760: printf("\033[%dM", num);
761: Placur(bottom + 1 - num, 0);
762: printf("\033[%dL", num);
763: }
764:
765: C100d_lines(top, bottom, num)
766: {
767: if (num <= 1) {
768: GENd_lines(top, bottom, num);
769: return;
770: }
771: printf("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO);
772: CapLine = CapCol = 0;
773: Placur(top, 0);
774: while (num--)
775: putpad(DL, ILI - CapLine);
776: printf("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO);
777: CapLine = CapCol = 0;
778: }
779:
780: #endif WIRED_TERMS
781:
782: GENd_lines(top, bottom, num)
783: {
784: register int i;
785:
786: if (CS) {
787: printf(tgoto(CS, bottom, top));
788: CapCol = CapLine = 0;
789: Placur(bottom, 0);
790: for (i = 0; i < num; i++)
791: putpad(SF, bottom - top);
792: printf(tgoto(CS, ILI, 0));
793: CapCol = CapLine = 0;
794: } else {
795: Placur(top, 0);
796: if (M_DL && (num > 1)) {
797: char minibuf[16];
798:
799: sprintf(minibuf, M_DL, num);
800: putpad(minibuf, ILI - top);
801: } else {
802: for (i = 0; i < num; i++)
803: putpad(DL, ILI - top);
804: }
805: Placur(bottom + 1 - num, 0);
806: if (M_AL && (num > 1)) {
807: char minibuf[16];
808:
809: sprintf(minibuf, M_AL, num);
810: putpad(minibuf, ILI - CapLine);
811: } else {
812: for (i = 0; i < num; i++)
813: putpad(AL, ILI - CapLine);
814: }
815: }
816: }
817:
818: struct ID_lookup {
819: char *ID_name;
820: int (*I_proc)(); /* proc to insert lines */
821: int (*D_proc)(); /* proc to delete lines */
822: } ID_trms[] = {
823: "generic", GENi_lines, GENd_lines, /* This should stay here */
824: #ifdef WIRED_TERMS
825: "sun", SUNi_lines, SUNd_lines,
826: "bg", BGi_lines, BGd_lines,
827: "c1", C100i_lines, C100d_lines,
828: #endif WIRED_TERMS
829: 0, 0, 0
830: };
831:
832: IDline_setup(tname)
833: char *tname;
834: {
835: register struct ID_lookup *idp;
836:
837: for (idp = &ID_trms[1]; idp->ID_name; idp++)
838: if (strncmp(idp->ID_name, tname, strlen(idp->ID_name)) == 0)
839: break;
840: if (idp->ID_name == 0)
841: idp = &ID_trms[0];
842: TTins_line = idp->I_proc;
843: TTdel_line = idp->D_proc;
844: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.