1/* $NetBSD: read.c,v 1.12 2002/01/21 19:49:52 tv Exp $ */
2
3/*
4 * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
5 * Copyright (c) 1994, 1995 Jochen Pohl
6 * All Rights Reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 *    must display the following acknowledgement:
18 *      This product includes software developed by Jochen Pohl for
19 *	The NetBSD Project.
20 * 4. The name of the author may not be used to endorse or promote products
21 *    derived from this software without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35#include <sys/cdefs.h>
36#if defined(__RCSID) && !defined(lint)
37__RCSID("$NetBSD: read.c,v 1.12 2002/01/21 19:49:52 tv Exp $");
38#endif
39__FBSDID("$FreeBSD$");
40
41#include <ctype.h>
42#include <err.h>
43#include <limits.h>
44#include <stdio.h>
45#include <stdlib.h>
46#include <string.h>
47
48#include "lint2.h"
49
50
51/* index of current (included) source file */
52static	int	srcfile;
53
54/*
55 * The array pointed to by inpfns maps the file name indices of input files
56 * to the file name indices used in lint2
57 */
58static	short	*inpfns;
59static	size_t	ninpfns;
60
61/*
62 * The array pointed to by *fnames maps file name indizes to file names.
63 * Indices of type short are used instead of pointers to save memory.
64 */
65const	char **fnames;
66static	size_t	nfnames;
67
68/*
69 * Types are shared (to save memory for the types itself) and accessed
70 * via indices (to save memory for references to types (indices are short)).
71 * To share types, an equal type must be located fast. This is done by a
72 * hash table. Access by indices is done via an array of pointers to the
73 * types.
74 */
75typedef struct thtab {
76	const	char *th_name;
77	u_short	th_idx;
78	struct	thtab *th_nxt;
79} thtab_t;
80static	thtab_t	**thtab;		/* hash table */
81type_t	**tlst;				/* array for indexed access */
82static	size_t	tlstlen;		/* length of tlst */
83
84static	hte_t **renametab;
85
86/* index of current C source file (as spezified at the command line) */
87static	int	csrcfile;
88
89
90static	void	inperr(void);
91static	void	setsrc(const char *);
92static	void	setfnid(int, const char *);
93static	void	funccall(pos_t *, const char *);
94static	void	decldef(pos_t *, const char *);
95static	void	usedsym(pos_t *, const char *);
96static	u_short	inptype(const char *, const char **);
97static	int	gettlen(const char *, const char **);
98static	u_short	findtype(const char *, size_t, int);
99static	u_short	storetyp(type_t *, const char *, size_t, int);
100static	int	thash(const char *, size_t);
101static	char	*inpqstrg(const char *, const char **);
102static	const	char *inpname(const char *, const char **);
103static	int	getfnidx(const char *);
104
105void
106readfile(const char *name)
107{
108	FILE	*inp;
109	size_t	len;
110	const	char *cp;
111	char	*line, *eptr, rt = '\0';
112	int	cline, isrc, iline;
113	pos_t	pos;
114
115	if (inpfns == NULL)
116		if ((inpfns = calloc(ninpfns = 128, sizeof (short))) == NULL)
117			nomem();
118	if (fnames == NULL)
119		if ((fnames = calloc(nfnames = 256, sizeof (char *))) == NULL)
120			nomem();
121	if (tlstlen == 0)
122		if ((tlst = calloc(tlstlen = 256, sizeof (type_t *))) == NULL)
123			nomem();
124	if (thtab == NULL)
125		if ((thtab = calloc(THSHSIZ2, sizeof (thtab_t))) == NULL)
126			nomem();
127
128	_inithash(&renametab);
129
130	srcfile = getfnidx(name);
131
132	if ((inp = fopen(name, "r")) == NULL)
133		err(1, "cannot open %s", name);
134
135	while ((line = fgetln(inp, &len)) != NULL) {
136
137		if (len == 0 || line[len - 1] != '\n')
138			inperr();
139		line[len - 1] = '\0';
140		cp = line;
141
142		/* line number in csrcfile */
143		cline = (int)strtol(cp, &eptr, 10);
144		if (cp == eptr) {
145		        cline = -1;
146		} else {
147			cp = eptr;
148		}
149
150		/* record type */
151		if (*cp != '\0') {
152			rt = *cp++;
153		} else {
154			inperr();
155		}
156
157		if (rt == 'S') {
158			setsrc(cp);
159			continue;
160		} else if (rt == 's') {
161			setfnid(cline, cp);
162			continue;
163		}
164
165		/*
166		 * Index of (included) source file. If this index is
167		 * different from csrcfile, it refers to an included
168		 * file.
169		 */
170		isrc = (int)strtol(cp, &eptr, 10);
171		if (cp == eptr)
172			inperr();
173		cp = eptr;
174		isrc = inpfns[isrc];
175
176		/* line number in isrc */
177		if (*cp++ != '.')
178			inperr();
179		iline = (int)strtol(cp, &eptr, 10);
180		if (cp == eptr)
181			inperr();
182		cp = eptr;
183
184		pos.p_src = (u_short)csrcfile;
185		pos.p_line = (u_short)cline;
186		pos.p_isrc = (u_short)isrc;
187		pos.p_iline = (u_short)iline;
188
189		/* process rest of this record */
190		switch (rt) {
191		case 'c':
192			funccall(&pos, cp);
193			break;
194		case 'd':
195			decldef(&pos, cp);
196			break;
197		case 'u':
198			usedsym(&pos, cp);
199			break;
200		default:
201			inperr();
202		}
203
204	}
205
206	_destroyhash(renametab);
207
208	if (ferror(inp))
209		err(1, "read error on %s", name);
210
211	(void)fclose(inp);
212}
213
214
215static void
216inperr(void)
217{
218
219	errx(1, "input file error: %s", fnames[srcfile]);
220}
221
222/*
223 * Set the name of the C source file of the .ln file which is
224 * currently read.
225 */
226static void
227setsrc(const char *cp)
228{
229
230	csrcfile = getfnidx(cp);
231}
232
233/*
234 * setfnid() gets as input an index as used in an input file and the
235 * associated file name. If necessary, it creates a new lint2 file
236 * name index for this file name and creates the mapping of the index
237 * as used in the input file to the index used in lint2.
238 */
239static void
240setfnid(int fid, const char *cp)
241{
242
243	if (fid == -1)
244		inperr();
245
246	if (fid >= ninpfns) {
247		if ((inpfns = realloc(inpfns, (ninpfns * 2) * sizeof (short)))
248		    == NULL)
249			nomem();
250		(void)memset(inpfns + ninpfns, 0, ninpfns * sizeof (short));
251		ninpfns *= 2;
252	}
253	/*
254	 * Should always be true because indices written in the output
255	 * file by lint1 are always the previous index + 1.
256	 */
257	if (fid >= ninpfns)
258		errx(1, "internal error: setfnid()");
259	inpfns[fid] = (u_short)getfnidx(cp);
260}
261
262/*
263 * Process a function call record (c-record).
264 */
265static void
266funccall(pos_t *posp, const char *cp)
267{
268	arginf_t *ai, **lai;
269	char	c, *eptr;
270	int	rused, rdisc;
271	hte_t	*hte;
272	fcall_t	*fcall;
273	const char *name;
274
275	fcall = xalloc(sizeof (fcall_t));
276	STRUCT_ASSIGN(fcall->f_pos, *posp);
277
278	/* read flags */
279	rused = rdisc = 0;
280	lai = &fcall->f_args;
281	while ((c = *cp) == 'u' || c == 'i' || c == 'd' ||
282	       c == 'z' || c == 'p' || c == 'n' || c == 's') {
283		cp++;
284		switch (c) {
285		case 'u':
286			if (rused || rdisc)
287				inperr();
288			rused = 1;
289			break;
290		case 'i':
291			if (rused || rdisc)
292				inperr();
293			break;
294		case 'd':
295			if (rused || rdisc)
296				inperr();
297			rdisc = 1;
298			break;
299		case 'z':
300		case 'p':
301		case 'n':
302		case 's':
303			ai = xalloc(sizeof (arginf_t));
304			ai->a_num = (int)strtol(cp, &eptr, 10);
305			if (cp == eptr)
306				inperr();
307			cp = eptr;
308			if (c == 'z') {
309				ai->a_pcon = ai->a_zero = 1;
310			} else if (c == 'p') {
311				ai->a_pcon = 1;
312			} else if (c == 'n') {
313				ai->a_ncon = 1;
314			} else {
315				ai->a_fmt = 1;
316				ai->a_fstrg = inpqstrg(cp, &cp);
317			}
318			*lai = ai;
319			lai = &ai->a_nxt;
320			break;
321		}
322	}
323	fcall->f_rused = rused;
324	fcall->f_rdisc = rdisc;
325
326	/* read name of function */
327	name = inpname(cp, &cp);
328
329	/* first look it up in the renaming table, then in the normal table */
330	hte = _hsearch(renametab, name, 0);
331	if (hte != NULL)
332		hte = hte->h_hte;
333	else
334		hte = hsearch(name, 1);
335	hte->h_used = 1;
336
337	fcall->f_type = inptype(cp, &cp);
338
339	*hte->h_lcall = fcall;
340	hte->h_lcall = &fcall->f_nxt;
341
342	if (*cp != '\0')
343		inperr();
344}
345
346/*
347 * Process a declaration or definition (d-record).
348 */
349static void
350decldef(pos_t *posp, const char *cp)
351{
352	sym_t	*symp, sym;
353	char	c, *ep, *pos1;
354	int	used, renamed;
355	hte_t	*hte, *renamehte = NULL;
356	const char *name, *rename;
357
358	(void)memset(&sym, 0, sizeof (sym));
359	STRUCT_ASSIGN(sym.s_pos, *posp);
360	sym.s_def = NODECL;
361
362	used = 0;
363
364	while ((c = *cp) == 't' || c == 'd' || c == 'e' || c == 'u' ||
365	       c == 'r' || c == 'o' || c == 's' || c == 'v' ||
366	       c == 'P' || c == 'S') {
367		cp++;
368		switch (c) {
369		case 't':
370			if (sym.s_def != NODECL)
371				inperr();
372			sym.s_def = TDEF;
373			break;
374		case 'd':
375			if (sym.s_def != NODECL)
376				inperr();
377			sym.s_def = DEF;
378			break;
379		case 'e':
380			if (sym.s_def != NODECL)
381				inperr();
382			sym.s_def = DECL;
383			break;
384		case 'u':
385			if (used)
386				inperr();
387			used = 1;
388			break;
389		case 'r':
390			if (sym.s_rval)
391				inperr();
392			sym.s_rval = 1;
393			break;
394		case 'o':
395			if (sym.s_osdef)
396				inperr();
397			sym.s_osdef = 1;
398			break;
399		case 's':
400			if (sym.s_static)
401				inperr();
402			sym.s_static = 1;
403			break;
404		case 'v':
405			if (sym.s_va)
406				inperr();
407			sym.s_va = 1;
408			sym.s_nva = (short)strtol(cp, &ep, 10);
409			if (cp == ep)
410				inperr();
411			cp = ep;
412			break;
413		case 'P':
414			if (sym.s_prfl)
415				inperr();
416			sym.s_prfl = 1;
417			sym.s_nprfl = (short)strtol(cp, &ep, 10);
418			if (cp == ep)
419				inperr();
420			cp = ep;
421			break;
422		case 'S':
423			if (sym.s_scfl)
424				inperr();
425			sym.s_scfl = 1;
426			sym.s_nscfl = (short)strtol(cp, &ep, 10);
427			if (cp == ep)
428				inperr();
429			cp = ep;
430			break;
431		}
432	}
433
434	/* read symbol name, doing renaming if necessary */
435	name = inpname(cp, &cp);
436	renamed = 0;
437	if (*cp == 'r') {
438		cp++;
439		name = xstrdup(name);
440		rename = inpname(cp, &cp);
441
442		/* enter it and see if it's already been renamed */
443		renamehte = _hsearch(renametab, name, 1);
444		if (renamehte->h_hte == NULL) {
445			hte = hsearch(rename, 1);
446			renamehte->h_hte = hte;
447			renamed = 1;
448		} else if (strcmp((hte = renamehte->h_hte)->h_name, rename)) {
449			pos1 = xstrdup(mkpos(&renamehte->h_syms->s_pos));
450			/* %s renamed multiple times\t%s  ::  %s */
451			msg(18, name, pos1, mkpos(&sym.s_pos));
452			free(pos1);
453		}
454		free((char *)name);
455	} else {
456		/* it might be a previously-done rename */
457		hte = _hsearch(renametab, name, 0);
458		if (hte != NULL)
459			hte = hte->h_hte;
460		else
461			hte = hsearch(name, 1);
462	}
463	hte->h_used |= used;
464	if (sym.s_def == DEF || sym.s_def == TDEF)
465		hte->h_def = 1;
466
467	sym.s_type = inptype(cp, &cp);
468
469	/*
470	 * Allocate memory for this symbol only if it was not already
471	 * declared or tentatively defined at the same location with
472	 * the same type. Works only for symbols with external linkage,
473	 * because static symbols, tentatively defined at the same location
474	 * but in different translation units are really different symbols.
475	 */
476	for (symp = hte->h_syms; symp != NULL; symp = symp->s_nxt) {
477		if (symp->s_pos.p_isrc == sym.s_pos.p_isrc &&
478		    symp->s_pos.p_iline == sym.s_pos.p_iline &&
479		    symp->s_type == sym.s_type &&
480		    ((symp->s_def == DECL && sym.s_def == DECL) ||
481		     (!sflag && symp->s_def == TDEF && sym.s_def == TDEF)) &&
482		    !symp->s_static && !sym.s_static) {
483			break;
484		}
485	}
486
487	if (symp == NULL) {
488		/* allocsym reserviert keinen Platz fuer s_nva */
489		if (sym.s_va || sym.s_prfl || sym.s_scfl) {
490			symp = xalloc(sizeof (sym_t));
491			STRUCT_ASSIGN(*symp, sym);
492		} else {
493			symp = xalloc(sizeof (symp->s_s));
494			STRUCT_ASSIGN(symp->s_s, sym.s_s);
495		}
496		*hte->h_lsym = symp;
497		hte->h_lsym = &symp->s_nxt;
498
499		/* XXX hack so we can remember where a symbol was renamed */
500		if (renamed)
501			renamehte->h_syms = symp;
502	}
503
504	if (*cp != '\0')
505		inperr();
506}
507
508/*
509 * Read an u-record (emitted by lint1 if a symbol was used).
510 */
511static void
512usedsym(pos_t *posp, const char *cp)
513{
514	usym_t	*usym;
515	hte_t	*hte;
516	const char *name;
517
518	usym = xalloc(sizeof (usym_t));
519	STRUCT_ASSIGN(usym->u_pos, *posp);
520
521	/* needed as delimiter between two numbers */
522	if (*cp++ != 'x')
523		inperr();
524
525	name = inpname(cp, &cp);
526	hte = _hsearch(renametab, name, 0);
527	if (hte != NULL)
528		hte = hte->h_hte;
529	else
530		hte = hsearch(name, 1);
531	hte->h_used = 1;
532
533	*hte->h_lusym = usym;
534	hte->h_lusym = &usym->u_nxt;
535}
536
537/*
538 * Read a type and return the index of this type.
539 */
540static u_short
541inptype(const char *cp, const char **epp)
542{
543	char	c, s, *eptr;
544	const	char *ep;
545	type_t	*tp;
546	int	narg, i, osdef = 0;
547	size_t	tlen;
548	u_short	tidx;
549	int	h;
550
551	/* If we have this type already, return it's index. */
552	tlen = gettlen(cp, &ep);
553	h = thash(cp, tlen);
554	if ((tidx = findtype(cp, tlen, h)) != 0) {
555		*epp = ep;
556		return (tidx);
557	}
558
559	/* No, we must create a new type. */
560	tp = xalloc(sizeof (type_t));
561
562	tidx = storetyp(tp, cp, tlen, h);
563
564	c = *cp++;
565
566	while (c == 'c' || c == 'v') {
567		if (c == 'c') {
568			tp->t_const = 1;
569		} else {
570			tp->t_volatile = 1;
571		}
572		c = *cp++;
573	}
574
575	if (c == 's' || c == 'u' || c == 'l' || c == 'e') {
576		s = c;
577		c = *cp++;
578	} else {
579		s = '\0';
580	}
581
582	switch (c) {
583	case 'C':
584		tp->t_tspec = s == 's' ? SCHAR : (s == 'u' ? UCHAR : CHAR);
585		break;
586	case 'S':
587		tp->t_tspec = s == 'u' ? USHORT : SHORT;
588		break;
589	case 'I':
590		tp->t_tspec = s == 'u' ? UINT : INT;
591		break;
592	case 'L':
593		tp->t_tspec = s == 'u' ? ULONG : LONG;
594		break;
595	case 'Q':
596		tp->t_tspec = s == 'u' ? UQUAD : QUAD;
597		break;
598	case 'D':
599		tp->t_tspec = s == 's' ? FLOAT : (s == 'l' ? LDOUBLE : DOUBLE);
600		break;
601	case 'V':
602		tp->t_tspec = VOID;
603		break;
604	case 'P':
605		tp->t_tspec = PTR;
606		break;
607	case 'A':
608		tp->t_tspec = ARRAY;
609		break;
610	case 'F':
611	case 'f':
612		osdef = c == 'f';
613		tp->t_tspec = FUNC;
614		break;
615	case 'T':
616		tp->t_tspec = s == 'e' ? ENUM : (s == 's' ? STRUCT : UNION);
617		break;
618	}
619
620	switch (tp->t_tspec) {
621	case ARRAY:
622		tp->t_dim = (int)strtol(cp, &eptr, 10);
623		cp = eptr;
624		tp->t_subt = TP(inptype(cp, &cp));
625		break;
626	case PTR:
627		tp->t_subt = TP(inptype(cp, &cp));
628		break;
629	case FUNC:
630		c = *cp;
631		if (isdigit((u_char)c)) {
632			if (!osdef)
633				tp->t_proto = 1;
634			narg = (int)strtol(cp, &eptr, 10);
635			cp = eptr;
636			if ((tp->t_args = calloc((size_t)(narg + 1),
637			    sizeof (type_t *))) == NULL)
638				nomem();
639			for (i = 0; i < narg; i++) {
640				if (i == narg - 1 && *cp == 'E') {
641					tp->t_vararg = 1;
642					cp++;
643				} else {
644					tp->t_args[i] = TP(inptype(cp, &cp));
645				}
646			}
647		}
648		tp->t_subt = TP(inptype(cp, &cp));
649		break;
650	case ENUM:
651		tp->t_tspec = INT;
652		tp->t_isenum = 1;
653		/* FALLTHROUGH */
654	case STRUCT:
655	case UNION:
656		switch (*cp++) {
657		case '1':
658			tp->t_istag = 1;
659			tp->t_tag = hsearch(inpname(cp, &cp), 1);
660			break;
661		case '2':
662			tp->t_istynam = 1;
663			tp->t_tynam = hsearch(inpname(cp, &cp), 1);
664			break;
665		case '3':
666			tp->t_isuniqpos = 1;
667			tp->t_uniqpos.p_line = strtol(cp, &eptr, 10);
668			cp = eptr;
669			cp++;
670			/* xlate to 'global' file name. */
671			tp->t_uniqpos.p_file =
672			    addoutfile(inpfns[strtol(cp, &eptr, 10)]);
673			cp = eptr;
674			cp++;
675			tp->t_uniqpos.p_uniq = strtol(cp, &eptr, 10);
676			cp = eptr;
677			break;
678		}
679		break;
680	case LONG:
681	case VOID:
682	case LDOUBLE:
683	case DOUBLE:
684	case FLOAT:
685	case UQUAD:
686	case QUAD:
687	case ULONG:
688	case UINT:
689	case INT:
690	case USHORT:
691	case SHORT:
692	case UCHAR:
693	case SCHAR:
694	case CHAR:
695	case UNSIGN:
696	case SIGNED:
697	case NOTSPEC:
698		break;
699	}
700
701	*epp = cp;
702	return (tidx);
703}
704
705/*
706 * Get the length of a type string.
707 */
708static int
709gettlen(const char *cp, const char **epp)
710{
711	const	char *cp1;
712	char	c, s, *eptr;
713	tspec_t	t;
714	int	narg, i, cm, vm;
715
716	cp1 = cp;
717
718	c = *cp++;
719
720	cm = vm = 0;
721
722	while (c == 'c' || c == 'v') {
723		if (c == 'c') {
724			if (cm)
725				inperr();
726			cm = 1;
727		} else {
728			if (vm)
729				inperr();
730			vm = 1;
731		}
732		c = *cp++;
733	}
734
735	if (c == 's' || c == 'u' || c == 'l' || c == 'e') {
736		s = c;
737		c = *cp++;
738	} else {
739		s = '\0';
740	}
741
742	t = NOTSPEC;
743
744	switch (c) {
745	case 'C':
746		if (s == 's') {
747			t = SCHAR;
748		} else if (s == 'u') {
749			t = UCHAR;
750		} else if (s == '\0') {
751			t = CHAR;
752		}
753		break;
754	case 'S':
755		if (s == 'u') {
756			t = USHORT;
757		} else if (s == '\0') {
758			t = SHORT;
759		}
760		break;
761	case 'I':
762		if (s == 'u') {
763			t = UINT;
764		} else if (s == '\0') {
765			t = INT;
766		}
767		break;
768	case 'L':
769		if (s == 'u') {
770			t = ULONG;
771		} else if (s == '\0') {
772			t = LONG;
773		}
774		break;
775	case 'Q':
776		if (s == 'u') {
777			t = UQUAD;
778		} else if (s == '\0') {
779			t = QUAD;
780		}
781		break;
782	case 'D':
783		if (s == 's') {
784			t = FLOAT;
785		} else if (s == 'l') {
786			t = LDOUBLE;
787		} else if (s == '\0') {
788			t = DOUBLE;
789		}
790		break;
791	case 'V':
792		if (s == '\0')
793			t = VOID;
794		break;
795	case 'P':
796		if (s == '\0')
797			t = PTR;
798		break;
799	case 'A':
800		if (s == '\0')
801			t = ARRAY;
802		break;
803	case 'F':
804	case 'f':
805		if (s == '\0')
806			t = FUNC;
807		break;
808	case 'T':
809		if (s == 'e') {
810			t = ENUM;
811		} else if (s == 's') {
812			t = STRUCT;
813		} else if (s == 'u') {
814			t = UNION;
815		}
816		break;
817	default:
818		inperr();
819	}
820
821	if (t == NOTSPEC)
822		inperr();
823
824	switch (t) {
825	case ARRAY:
826		(void)strtol(cp, &eptr, 10);
827		if (cp == eptr)
828			inperr();
829		cp = eptr;
830		(void)gettlen(cp, &cp);
831		break;
832	case PTR:
833		(void)gettlen(cp, &cp);
834		break;
835	case FUNC:
836		c = *cp;
837		if (isdigit((u_char)c)) {
838			narg = (int)strtol(cp, &eptr, 10);
839			cp = eptr;
840			for (i = 0; i < narg; i++) {
841				if (i == narg - 1 && *cp == 'E') {
842					cp++;
843				} else {
844					(void)gettlen(cp, &cp);
845				}
846			}
847		}
848		(void)gettlen(cp, &cp);
849		break;
850	case ENUM:
851	case STRUCT:
852	case UNION:
853		switch (*cp++) {
854		case '1':
855			(void)inpname(cp, &cp);
856			break;
857		case '2':
858			(void)inpname(cp, &cp);
859			break;
860		case '3':
861			/* unique position: line.file.uniquifier */
862			(void)strtol(cp, &eptr, 10);
863			if (cp == eptr)
864				inperr();
865			cp = eptr;
866			if (*cp++ != '.')
867				inperr();
868			(void)strtol(cp, &eptr, 10);
869			if (cp == eptr)
870				inperr();
871			cp = eptr;
872			if (*cp++ != '.')
873				inperr();
874			(void)strtol(cp, &eptr, 10);
875			if (cp == eptr)
876				inperr();
877			cp = eptr;
878			break;
879		default:
880			inperr();
881		}
882		break;
883	case FLOAT:
884	case USHORT:
885	case SHORT:
886	case UCHAR:
887	case SCHAR:
888	case CHAR:
889	case UNSIGN:
890	case SIGNED:
891	case NOTSPEC:
892	case INT:
893	case UINT:
894	case DOUBLE:
895	case LDOUBLE:
896	case VOID:
897	case ULONG:
898	case QUAD:
899	case UQUAD:
900	case LONG:
901		break;
902	}
903
904	*epp = cp;
905	return (cp - cp1);
906}
907
908/*
909 * Search a type by it's type string.
910 */
911static u_short
912findtype(const char *cp, size_t len, int h)
913{
914	thtab_t	*thte;
915
916	for (thte = thtab[h]; thte != NULL; thte = thte->th_nxt) {
917		if (strncmp(thte->th_name, cp, len) != 0)
918			continue;
919		if (thte->th_name[len] == '\0')
920			return (thte->th_idx);
921	}
922
923	return (0);
924}
925
926/*
927 * Store a type and it's type string so we can later share this type
928 * if we read the same type string from the input file.
929 */
930static u_short
931storetyp(type_t *tp, const char *cp, size_t len, int h)
932{
933	static	u_int	tidx = 1;	/* 0 is reserved */
934	thtab_t	*thte;
935	char	*name;
936
937	if (tidx >= USHRT_MAX)
938		errx(1, "sorry, too many types");
939
940	if (tidx == tlstlen - 1) {
941		if ((tlst = realloc(tlst, (tlstlen * 2) * sizeof (type_t *)))
942		    == NULL)
943			nomem();
944		(void)memset(tlst + tlstlen, 0, tlstlen * sizeof (type_t *));
945		tlstlen *= 2;
946	}
947
948	tlst[tidx] = tp;
949
950	/* create a hash table entry */
951	name = xalloc(len + 1);
952	(void)memcpy(name, cp, len);
953	name[len] = '\0';
954
955	thte = xalloc(sizeof (thtab_t));
956	thte->th_name = name;
957	thte->th_idx = tidx;
958	thte->th_nxt = thtab[h];
959	thtab[h] = thte;
960
961	return ((u_short)tidx++);
962}
963
964/*
965 * Hash function for types
966 */
967static int
968thash(const char *s, size_t len)
969{
970	u_int	v;
971
972	v = 0;
973	while (len-- != 0) {
974		v = (v << sizeof (v)) + (u_char)*s++;
975		v ^= v >> (sizeof (v) * CHAR_BIT - sizeof (v));
976	}
977	return (v % THSHSIZ2);
978}
979
980/*
981 * Read a string enclosed by "". This string may contain quoted chars.
982 */
983static char *
984inpqstrg(const char *src, const char **epp)
985{
986	char	*strg, *dst;
987	size_t	slen;
988	int	c;
989	int	v;
990
991	if ((dst = strg = malloc(slen = 32)) == NULL)
992		nomem();
993
994	if ((c = *src++) != '"')
995		inperr();
996	if ((c = *src++) == '\0')
997		inperr();
998
999	while (c != '"') {
1000		if (c == '\\') {
1001			if ((c = *src++) == '\0')
1002				inperr();
1003			switch (c) {
1004			case 'n':
1005				c = '\n';
1006				break;
1007			case 't':
1008				c = '\t';
1009				break;
1010			case 'v':
1011				c = '\v';
1012				break;
1013			case 'b':
1014				c = '\b';
1015				break;
1016			case 'r':
1017				c = '\r';
1018				break;
1019			case 'f':
1020				c = '\f';
1021				break;
1022			case 'a':
1023				c = '\a';
1024				break;
1025			case '\\':
1026				c = '\\';
1027				break;
1028			case '"':
1029				c = '"';
1030				break;
1031			case '\'':
1032				c = '\'';
1033				break;
1034			case '0': case '1': case '2': case '3':
1035				v = (c - '0') << 6;
1036				if ((c = *src++) < '0' || c > '7')
1037					inperr();
1038				v |= (c - '0') << 3;
1039				if ((c = *src++) < '0' || c > '7')
1040					inperr();
1041				v |= c - '0';
1042				c = (u_char)v;
1043				break;
1044			default:
1045				inperr();
1046			}
1047		}
1048		/* keep space for trailing '\0' */
1049		if (dst - strg == slen - 1) {
1050			if ((strg = realloc(strg, slen * 2)) == NULL)
1051				nomem();
1052			dst = strg + (slen - 1);
1053			slen *= 2;
1054		}
1055		*dst++ = (char)c;
1056		if ((c = *src++) == '\0')
1057			inperr();
1058	}
1059	*dst = '\0';
1060
1061	*epp = src;
1062	return (strg);
1063}
1064
1065/*
1066 * Read the name of a symbol in static memory.
1067 */
1068static const char *
1069inpname(const char *cp, const char **epp)
1070{
1071	static	char	*buf;
1072	static	size_t	blen = 0;
1073	size_t	len, i;
1074	char	*eptr, c;
1075
1076	len = (int)strtol(cp, &eptr, 10);
1077	if (cp == eptr)
1078		inperr();
1079	cp = eptr;
1080	if (len + 1 > blen)
1081		if ((buf = realloc(buf, blen = len + 1)) == NULL)
1082			nomem();
1083	for (i = 0; i < len; i++) {
1084		c = *cp++;
1085		if (!isalnum((unsigned char)c) && c != '_')
1086			inperr();
1087		buf[i] = c;
1088	}
1089	buf[i] = '\0';
1090
1091	*epp = cp;
1092	return (buf);
1093}
1094
1095/*
1096 * Return the index of a file name. If the name cannot be found, create
1097 * a new entry and return the index of the newly created entry.
1098 */
1099static int
1100getfnidx(const char *fn)
1101{
1102	int	i;
1103
1104	/* 0 ist reserved */
1105	for (i = 1; fnames[i] != NULL; i++) {
1106		if (strcmp(fnames[i], fn) == 0)
1107			break;
1108	}
1109	if (fnames[i] != NULL)
1110		return (i);
1111
1112	if (i == nfnames - 1) {
1113		if ((fnames = realloc(fnames, (nfnames * 2) * sizeof (char *)))
1114		    == NULL)
1115			nomem();
1116		(void)memset(fnames + nfnames, 0, nfnames * sizeof (char *));
1117		nfnames *= 2;
1118	}
1119
1120	if ((fnames[i] = strdup(fn)) == NULL)
1121		nomem();
1122	return (i);
1123}
1124
1125/*
1126 * Separate symbols with static and external linkage.
1127 */
1128void
1129mkstatic(hte_t *hte)
1130{
1131	sym_t	*sym1, **symp, *sym;
1132	fcall_t	**callp, *call;
1133	usym_t	**usymp, *usym;
1134	hte_t	*nhte;
1135	int	ofnd;
1136
1137	/* Look for first static definition */
1138	for (sym1 = hte->h_syms; sym1 != NULL; sym1 = sym1->s_nxt) {
1139		if (sym1->s_static)
1140			break;
1141	}
1142	if (sym1 == NULL)
1143		return;
1144
1145	/* Do nothing if this name is used only in one translation unit. */
1146	ofnd = 0;
1147	for (sym = hte->h_syms; sym != NULL && !ofnd; sym = sym->s_nxt) {
1148		if (sym->s_pos.p_src != sym1->s_pos.p_src)
1149			ofnd = 1;
1150	}
1151	for (call = hte->h_calls; call != NULL && !ofnd; call = call->f_nxt) {
1152		if (call->f_pos.p_src != sym1->s_pos.p_src)
1153			ofnd = 1;
1154	}
1155	for (usym = hte->h_usyms; usym != NULL && !ofnd; usym = usym->u_nxt) {
1156		if (usym->u_pos.p_src != sym1->s_pos.p_src)
1157			ofnd = 1;
1158	}
1159	if (!ofnd) {
1160		hte->h_used = 1;
1161		/* errors about undef. static symbols are printed in lint1 */
1162		hte->h_def = 1;
1163		hte->h_static = 1;
1164		return;
1165	}
1166
1167	/*
1168	 * Create a new hash table entry
1169	 *
1170	 * XXX this entry should be put at the beginning of the list to
1171	 * avoid to process the same symbol twice.
1172	 */
1173	for (nhte = hte; nhte->h_link != NULL; nhte = nhte->h_link)
1174		continue;
1175	nhte->h_link = xmalloc(sizeof (hte_t));
1176	nhte = nhte->h_link;
1177	nhte->h_name = hte->h_name;
1178	nhte->h_used = 1;
1179	nhte->h_def = 1;	/* error in lint1 */
1180	nhte->h_static = 1;
1181	nhte->h_syms = NULL;
1182	nhte->h_lsym = &nhte->h_syms;
1183	nhte->h_calls = NULL;
1184	nhte->h_lcall = &nhte->h_calls;
1185	nhte->h_usyms = NULL;
1186	nhte->h_lusym = &nhte->h_usyms;
1187	nhte->h_link = NULL;
1188	nhte->h_hte = NULL;
1189
1190	/*
1191	 * move all symbols used in this translation unit into the new
1192	 * hash table entry.
1193	 */
1194	for (symp = &hte->h_syms; (sym = *symp) != NULL; ) {
1195		if (sym->s_pos.p_src == sym1->s_pos.p_src) {
1196			sym->s_static = 1;
1197			(*symp) = sym->s_nxt;
1198			if (hte->h_lsym == &sym->s_nxt)
1199				hte->h_lsym = symp;
1200			sym->s_nxt = NULL;
1201			*nhte->h_lsym = sym;
1202			nhte->h_lsym = &sym->s_nxt;
1203		} else {
1204			symp = &sym->s_nxt;
1205		}
1206	}
1207	for (callp = &hte->h_calls; (call = *callp) != NULL; ) {
1208		if (call->f_pos.p_src == sym1->s_pos.p_src) {
1209			(*callp) = call->f_nxt;
1210			if (hte->h_lcall == &call->f_nxt)
1211				hte->h_lcall = callp;
1212			call->f_nxt = NULL;
1213			*nhte->h_lcall = call;
1214			nhte->h_lcall = &call->f_nxt;
1215		} else {
1216			callp = &call->f_nxt;
1217		}
1218	}
1219	for (usymp = &hte->h_usyms; (usym = *usymp) != NULL; ) {
1220		if (usym->u_pos.p_src == sym1->s_pos.p_src) {
1221			(*usymp) = usym->u_nxt;
1222			if (hte->h_lusym == &usym->u_nxt)
1223				hte->h_lusym = usymp;
1224			usym->u_nxt = NULL;
1225			*nhte->h_lusym = usym;
1226			nhte->h_lusym = &usym->u_nxt;
1227		} else {
1228			usymp = &usym->u_nxt;
1229		}
1230	}
1231
1232	/* h_def must be recalculated for old hte */
1233	hte->h_def = nhte->h_def = 0;
1234	for (sym = hte->h_syms; sym != NULL; sym = sym->s_nxt) {
1235		if (sym->s_def == DEF || sym->s_def == TDEF) {
1236			hte->h_def = 1;
1237			break;
1238		}
1239	}
1240
1241	mkstatic(hte);
1242}
1243