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