![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wwinit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / window|
Return to wwinit.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / window |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: */
17:
18: #ifndef lint
19: static char sccsid[] = "@(#)wwinit.c 3.31 (Berkeley) 6/29/88";
20: #endif /* not lint */
21:
22: #include "ww.h"
23: #include "tt.h"
24: #include <sys/signal.h>
25: #include <fcntl.h>
26: #include "char.h"
27:
28: wwinit()
29: {
30: register i, j;
31: char *kp;
32: int s;
33:
34: wwdtablesize = getdtablesize();
35: wwhead.ww_forw = &wwhead;
36: wwhead.ww_back = &wwhead;
37:
38: s = sigblock(sigmask(SIGIO));
39: if (signal(SIGIO, wwrint) == BADSIG)
40: return -1;
41:
42: if (wwgettty(0, &wwoldtty) < 0)
43: return -1;
44: wwwintty = wwoldtty;
45: wwwintty.ww_sgttyb.sg_flags &= ~XTABS;
46: wwnewtty.ww_sgttyb = wwoldtty.ww_sgttyb;
47: wwnewtty.ww_sgttyb.sg_erase = -1;
48: wwnewtty.ww_sgttyb.sg_kill = -1;
49: wwnewtty.ww_sgttyb.sg_flags |= CBREAK;
50: wwnewtty.ww_sgttyb.sg_flags &= ~(ECHO|CRMOD);
51: wwnewtty.ww_tchars.t_intrc = -1;
52: wwnewtty.ww_tchars.t_quitc = -1;
53: wwnewtty.ww_tchars.t_startc = -1;
54: wwnewtty.ww_tchars.t_stopc = -1;
55: wwnewtty.ww_tchars.t_eofc = -1;
56: wwnewtty.ww_tchars.t_brkc = -1;
57: wwnewtty.ww_ltchars.t_suspc = -1;
58: wwnewtty.ww_ltchars.t_dsuspc = -1;
59: wwnewtty.ww_ltchars.t_rprntc = -1;
60: wwnewtty.ww_ltchars.t_flushc = -1;
61: wwnewtty.ww_ltchars.t_werasc = -1;
62: wwnewtty.ww_ltchars.t_lnextc = -1;
63: wwnewtty.ww_lmode = wwoldtty.ww_lmode | LLITOUT;
64: wwnewtty.ww_ldisc = wwoldtty.ww_ldisc;
65: wwnewtty.ww_fflags = wwoldtty.ww_fflags | FASYNC;
66: if (wwsettty(0, &wwnewtty, &wwoldtty) < 0)
67: goto bad;
68:
69: if ((wwterm = getenv("TERM")) == 0) {
70: wwerrno = WWE_BADTERM;
71: goto bad;
72: }
73: if (tgetent(wwtermcap, wwterm) != 1) {
74: wwerrno = WWE_BADTERM;
75: goto bad;
76: }
77: wwbaud = wwbaudmap[wwoldtty.ww_sgttyb.sg_ospeed];
78:
79: if (ttinit() < 0)
80: goto bad;
81: wwnrow = tt.tt_nrow;
82: wwncol = tt.tt_ncol;
83: wwavailmodes = tt.tt_availmodes;
84: wwwrap = tt.tt_wrap;
85: (*tt.tt_init)();
86:
87: if (wwavailmodes & WWM_REV)
88: wwcursormodes = WWM_REV | wwavailmodes & WWM_BLK;
89: else if (wwavailmodes & WWM_UL)
90: wwcursormodes = WWM_UL;
91:
92: if ((wwib = malloc((unsigned) 512)) == 0)
93: goto bad;
94: wwibe = wwib + 512;
95: wwibq = wwibp = wwib;
96:
97: if ((wwsmap = wwalloc(0, 0, wwnrow, wwncol, sizeof (char))) == 0)
98: goto bad;
99: for (i = 0; i < wwnrow; i++)
100: for (j = 0; j < wwncol; j++)
101: wwsmap[i][j] = WWX_NOBODY;
102:
103: wwos = (union ww_char **)
104: wwalloc(0, 0, wwnrow, wwncol, sizeof (union ww_char));
105: if (wwos == 0)
106: goto bad;
107: for (i = 0; i < wwnrow; i++)
108: for (j = 0; j < wwncol; j++)
109: wwos[i][j].c_w = ' ';
110: wwns = (union ww_char **)
111: wwalloc(0, 0, wwnrow, wwncol, sizeof (union ww_char));
112: if (wwns == 0)
113: goto bad;
114: for (i = 0; i < wwnrow; i++)
115: for (j = 0; j < wwncol; j++)
116: wwns[i][j].c_w = ' ';
117:
118: wwtouched = malloc((unsigned) wwnrow);
119: if (wwtouched == 0) {
120: wwerrno = WWE_NOMEM;
121: goto bad;
122: }
123: for (i = 0; i < wwnrow; i++)
124: wwtouched[i] = 0;
125:
126: wwindex[WWX_NOBODY] = &wwnobody;
127: wwnobody.ww_order = NWW;
128:
129: kp = wwwintermcap;
130: if (wwavailmodes & WWM_REV)
131: wwaddcap1(WWT_REV, &kp);
132: if (wwavailmodes & WWM_BLK)
133: wwaddcap1(WWT_BLK, &kp);
134: if (wwavailmodes & WWM_UL)
135: wwaddcap1(WWT_UL, &kp);
136: if (wwavailmodes & WWM_GRP)
137: wwaddcap1(WWT_GRP, &kp);
138: if (wwavailmodes & WWM_DIM)
139: wwaddcap1(WWT_DIM, &kp);
140: if (wwavailmodes & WWM_USR)
141: wwaddcap1(WWT_USR, &kp);
142: if (tt.tt_insline && tt.tt_delline || tt.tt_setscroll)
143: wwaddcap1(WWT_ALDL, &kp);
144: if (tt.tt_hasinsert)
145: wwaddcap1(WWT_IMEI, &kp);
146: if (tt.tt_delchar)
147: wwaddcap1(WWT_DC, &kp);
148: wwaddcap("kb", &kp);
149: wwaddcap("ku", &kp);
150: wwaddcap("kd", &kp);
151: wwaddcap("kl", &kp);
152: wwaddcap("kr", &kp);
153: wwaddcap("kh", &kp);
154: if ((j = tgetnum("kn")) >= 0) {
155: char cap[32];
156:
157: (void) sprintf(kp, "kn#%d:", j);
158: for (; *kp; kp++)
159: ;
160: for (i = 1; i <= j; i++) {
161: (void) sprintf(cap, "k%d", i);
162: wwaddcap(cap, &kp);
163: cap[0] = 'l';
164: wwaddcap(cap, &kp);
165: }
166: }
167: /*
168: * It's ok to do this here even if setenv() is destructive
169: * since tt_init() has already made its own copy of it and
170: * wwterm now points to the copy.
171: */
172: (void) setenv("TERM", WWT_TERM, 1);
173:
174: (void) signal(SIGPIPE, SIG_IGN);
175: (void) sigsetmask(s);
176: return 0;
177: bad:
178: /*
179: * Don't bother to free storage. We're supposed
180: * to exit when wwinit fails anyway.
181: */
182: (void) wwsettty(0, &wwoldtty, &wwnewtty);
183: (void) signal(SIGIO, SIG_DFL);
184: (void) sigsetmask(s);
185: return -1;
186: }
187:
188: wwaddcap(cap, kp)
189: register char *cap;
190: register char **kp;
191: {
192: char tbuf[512];
193: char *tp = tbuf;
194: register char *str, *p;
195:
196: if ((str = tgetstr(cap, &tp)) != 0) {
197: while (*(*kp)++ = *cap++)
198: ;
199: (*kp)[-1] = '=';
200: while (*str) {
201: for (p = unctrl(*str++); *(*kp)++ = *p++;)
202: ;
203: (*kp)--;
204: }
205: *(*kp)++ = ':';
206: **kp = 0;
207: }
208: }
209:
210: wwaddcap1(cap, kp)
211: register char *cap;
212: register char **kp;
213: {
214: while (*(*kp)++ = *cap++)
215: ;
216: (*kp)--;
217: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.