xref: /illumos-gate/usr/src/cmd/vgrind/vgrindefs.c (revision e5af7cce)
1 /*
2  * Copyright (c) 1980 Regents of the University of California.
3  * All rights reserved.  The Berkeley software License Agreement
4  * specifies the terms and conditions for redistribution.
5  */
6 
7 #pragma ident	"%Z%%M%	%I%	%E% SMI"
8 
9 #define	BUFSIZ	1024
10 #define MAXHOP	32	/* max number of tc= indirections */
11 
12 #include <ctype.h>
13 #include <locale.h>
14 #include <string.h>
15 /*
16  * grindcap - routines for dealing with the language definitions data base
17  *	(code stolen almost totally from termcap)
18  *
19  * BUG:		Should use a "last" pointer in tbuf, so that searching
20  *		for capabilities alphabetically would not be a n**2/2
21  *		process when large numbers of capabilities are given.
22  * Note:	If we add a last pointer now we will screw up the
23  *		tc capability. We really should compile termcap.
24  *
25  * Essentially all the work here is scanning and decoding escapes
26  * in string capabilities.  We don't use stdio because the editor
27  * doesn't, and because living w/o it is not hard.
28  */
29 
30 static	char *tbuf;
31 static	char *filename;
32 static	int hopcount;	/* detect infinite loops in termcap, init 0 */
33 char	*tgetstr();
34 char	*getenv();
35 
36 static char *tdecode(char *str, char **area);
37 static char *tskip(char *bp);
38 static int tnchktc(void);
39 static int tnamatch(char *np);
40 
41 static char	*vgrind_msg;
42 
43 /*
44  * Get an entry for terminal name in buffer bp,
45  * from the termcap file.  Parse is very rudimentary;
46  * we just notice escaped newlines.
47  */
48 int
tgetent(char * bp,char * name,char * file)49 tgetent(char *bp, char *name, char *file)
50 {
51 	char *cp;
52 	int c;
53 	int i = 0, cnt = 0;
54 	char ibuf[BUFSIZ];
55 	char *cp2;
56 	int tf;
57 
58 	tbuf = bp;
59 	tf = 0;
60 	filename = file;
61 	tf = open(filename, 0);
62 	if (tf < 0)
63 		return (-1);
64 	for (;;) {
65 		cp = bp;
66 		for (;;) {
67 			if (i == cnt) {
68 				cnt = read(tf, ibuf, BUFSIZ);
69 				if (cnt <= 0) {
70 					close(tf);
71 					return (0);
72 				}
73 				i = 0;
74 			}
75 			c = ibuf[i++];
76 			if (c == '\n') {
77 				if (cp > bp && cp[-1] == '\\'){
78 					cp--;
79 					continue;
80 				}
81 				break;
82 			}
83 			if (cp >= bp+BUFSIZ) {
84 				vgrind_msg = gettext("Vgrind entry too long\n");
85 				write(2, vgrind_msg, strlen(vgrind_msg));
86 				break;
87 			} else
88 				*cp++ = c;
89 		}
90 		*cp = 0;
91 
92 		/*
93 		 * The real work for the match.
94 		 */
95 		if (tnamatch(name)) {
96 			close(tf);
97 			return(tnchktc());
98 		}
99 	}
100 }
101 
102 /*
103  * tnchktc: check the last entry, see if it's tc=xxx. If so,
104  * recursively find xxx and append that entry (minus the names)
105  * to take the place of the tc=xxx entry. This allows termcap
106  * entries to say "like an HP2621 but doesn't turn on the labels".
107  * Note that this works because of the left to right scan.
108  */
109 static int
tnchktc(void)110 tnchktc(void)
111 {
112 	char *p, *q;
113 	char tcname[16];	/* name of similar terminal */
114 	char tcbuf[BUFSIZ];
115 	char *holdtbuf = tbuf;
116 	int l;
117 
118 	p = tbuf + strlen(tbuf) - 2;	/* before the last colon */
119 	while (*--p != ':')
120 		if (p<tbuf) {
121 			vgrind_msg = gettext("Bad vgrind entry\n");
122 			write(2, vgrind_msg, strlen(vgrind_msg));
123 			return (0);
124 		}
125 	p++;
126 	/* p now points to beginning of last field */
127 	if (p[0] != 't' || p[1] != 'c')
128 		return(1);
129 	strcpy(tcname,p+3);
130 	q = tcname;
131 	while (q && *q != ':')
132 		q++;
133 	*q = 0;
134 	if (++hopcount > MAXHOP) {
135 		vgrind_msg = gettext("Infinite tc= loop\n");
136 		write(2, vgrind_msg, strlen(vgrind_msg));
137 		return (0);
138 	}
139 	if (tgetent(tcbuf, tcname, filename) != 1)
140 		return(0);
141 	for (q=tcbuf; *q != ':'; q++)
142 		;
143 	l = p - holdtbuf + strlen(q);
144 	if (l > BUFSIZ) {
145 		vgrind_msg = gettext("Vgrind entry too long\n");
146 		write(2, vgrind_msg, strlen(vgrind_msg));
147 		q[BUFSIZ - (p-tbuf)] = 0;
148 	}
149 	strcpy(p, q+1);
150 	tbuf = holdtbuf;
151 	return(1);
152 }
153 
154 /*
155  * Tnamatch deals with name matching.  The first field of the termcap
156  * entry is a sequence of names separated by |'s, so we compare
157  * against each such name.  The normal : terminator after the last
158  * name (before the first field) stops us.
159  */
160 static int
tnamatch(char * np)161 tnamatch(char *np)
162 {
163 	char *Np, *Bp;
164 
165 	Bp = tbuf;
166 	if (*Bp == '#')
167 		return(0);
168 	for (;;) {
169 		for (Np = np; *Np && *Bp == *Np; Bp++, Np++)
170 			continue;
171 		if (*Np == 0 && (*Bp == '|' || *Bp == ':' || *Bp == 0))
172 			return (1);
173 		while (*Bp && *Bp != ':' && *Bp != '|')
174 			Bp++;
175 		if (*Bp == 0 || *Bp == ':')
176 			return (0);
177 		Bp++;
178 	}
179 }
180 
181 /*
182  * Skip to the next field.  Notice that this is very dumb, not
183  * knowing about \: escapes or any such.  If necessary, :'s can be put
184  * into the termcap file in octal.
185  */
186 static char *
tskip(char * bp)187 tskip(char *bp)
188 {
189 
190 	while (*bp && *bp != ':')
191 		bp++;
192 	if (*bp == ':')
193 		bp++;
194 	return (bp);
195 }
196 
197 /*
198  * Return the (numeric) option id.
199  * Numeric options look like
200  *	li#80
201  * i.e. the option string is separated from the numeric value by
202  * a # character.  If the option is not found we return -1.
203  * Note that we handle octal numbers beginning with 0.
204  */
205 static int
tgetnum(char * id)206 tgetnum(char *id)
207 {
208 	int i, base;
209 	char *bp = tbuf;
210 
211 	for (;;) {
212 		bp = tskip(bp);
213 		if (*bp == 0)
214 			return (-1);
215 		if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
216 			continue;
217 		if (*bp == '@')
218 			return(-1);
219 		if (*bp != '#')
220 			continue;
221 		bp++;
222 		base = 10;
223 		if (*bp == '0')
224 			base = 8;
225 		i = 0;
226 		while (isdigit(*bp))
227 			i *= base, i += *bp++ - '0';
228 		return (i);
229 	}
230 }
231 
232 /*
233  * Handle a flag option.
234  * Flag options are given "naked", i.e. followed by a : or the end
235  * of the buffer.  Return 1 if we find the option, or 0 if it is
236  * not given.
237  */
238 int
tgetflag(char * id)239 tgetflag(char *id)
240 {
241 	char *bp = tbuf;
242 
243 	for (;;) {
244 		bp = tskip(bp);
245 		if (!*bp)
246 			return (0);
247 		if (*bp++ == id[0] && *bp != 0 && *bp++ == id[1]) {
248 			if (!*bp || *bp == ':')
249 				return (1);
250 			else if (*bp == '@')
251 				return(0);
252 		}
253 	}
254 }
255 
256 /*
257  * Get a string valued option.
258  * These are given as
259  *	cl=^Z
260  * Much decoding is done on the strings, and the strings are
261  * placed in area, which is a ref parameter which is updated.
262  * No checking on area overflow.
263  */
264 char *
tgetstr(char * id,char ** area)265 tgetstr(char *id, char **area)
266 {
267 	char *bp = tbuf;
268 
269 	for (;;) {
270 		bp = tskip(bp);
271 		if (!*bp)
272 			return (0);
273 		if (*bp++ != id[0] || *bp == 0 || *bp++ != id[1])
274 			continue;
275 		if (*bp == '@')
276 			return(0);
277 		if (*bp != '=')
278 			continue;
279 		bp++;
280 		return (tdecode(bp, area));
281 	}
282 }
283 
284 /*
285  * Tdecode does the grung work to decode the
286  * string capability escapes.
287  */
288 static char *
tdecode(char * str,char ** area)289 tdecode(char *str, char **area)
290 {
291 	char *cp;
292 	int c;
293 	int i;
294 
295 	cp = *area;
296 	while (c = *str++) {
297 	    if (c == ':' && *(cp-1) != '\\')
298 		break;
299 	    *cp++ = c;
300 	}
301 	*cp++ = 0;
302 	str = *area;
303 	*area = cp;
304 	return (str);
305 }
306