initial import of NetBSD tree

1 files changed, 1133 insertions, 0 deletions

diff --git a/usr.bin/xlint/lint2/read.c b/usr.bin/xlint/lint2/read.c
new file mode 100644
index 00000000000..daffe1e4d4e
--- /dev/null
+++ b/usr.bin/xlint/lint2/read.c
@@ -0,0 +1,1133 @@
+/*	$NetBSD: read.c,v 1.2 1995/07/03 21:24:59 cgd Exp $	*/
+
+/*
+ * Copyright (c) 1994, 1995 Jochen Pohl
+ * All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Jochen Pohl for
+ *	The NetBSD Project.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef lint
+static char rcsid[] = "$NetBSD: read.c,v 1.2 1995/07/03 21:24:59 cgd Exp $";
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <err.h>
+
+#include "lint2.h"
+
+
+/* index of current (included) source file */
+static	int	srcfile;
+
+/*
+ * The array pointed to by inpfns maps the file name indices of input files
+ * to the file name indices used in lint2
+ */
+static	short	*inpfns;
+static	size_t	ninpfns;
+
+/*
+ * The array pointed to by *fnames maps file name indizes to file names.
+ * Indices of type short are used instead of pointers to save memory.
+ */
+const	char **fnames;
+static	size_t	nfnames;
+
+/*
+ * Types are shared (to save memory for the types itself) and accessed
+ * via indices (to save memory for references to types (indices are short)).
+ * To share types, a equal type must be located fast. This is done by a
+ * hash table. Access by indices is done via an array of pointers to the
+ * types.
+ */
+typedef struct thtab {
+	const	char *th_name;
+	u_short	th_idx;
+	struct	thtab *th_nxt;
+} thtab_t;
+static	thtab_t	**thtab;		/* hash table */
+type_t	**tlst;				/* array for indexed access */
+static	size_t	tlstlen;		/* length of tlst */
+
+/* index of current C source file (as spezified at the command line) */
+static	int	csrcfile;
+
+
+static	void	inperr __P((void));
+static	void	setsrc __P((const char *));
+static	void	setfnid __P((int, const char *));
+static	void	funccall __P((pos_t *, const char *));
+static	void	decldef __P((pos_t *, const char *));
+static	void	usedsym __P((pos_t *, const char *));
+static	u_short	inptype __P((const char *, const char **));
+static	int	gettlen __P((const char *, const char **));
+static	u_short	findtype __P((const char *, size_t, int));
+static	u_short	storetyp __P((type_t *, const char *, size_t, int));
+static	int	thash __P((const char *, size_t));
+static	char	*inpqstrg __P((const char *, const char **));
+static	const	char *inpname __P((const char *, const char **));
+static	int	getfnidx __P((const char *));
+
+void
+readfile(name)
+	const	char *name;
+{
+	FILE	*inp;
+	size_t	len;
+	const	char *cp;
+	char	*line, *eptr, rt;
+	int	cline, isrc, iline;
+	pos_t	pos;
+
+	if (inpfns == NULL)
+		inpfns = xcalloc(ninpfns = 128, sizeof (short));
+	if (fnames == NULL)
+		fnames = xcalloc(nfnames = 256, sizeof (char *));
+	if (tlstlen == 0)
+		tlst = xcalloc(tlstlen = 256, sizeof (type_t *));
+	if (thtab == NULL)
+		thtab = xcalloc(THSHSIZ2, sizeof (thtab_t));
+
+	srcfile = getfnidx(name);
+
+	if ((inp = fopen(name, "r")) == NULL)
+		err(1, "cannot open %s", name);
+
+	while ((line = fgetln(inp, &len)) != NULL) {
+
+		if (len == 0 || line[len - 1] != '\n')
+			inperr();
+		line[len - 1] = '\0';
+		cp = line;
+
+		/* line number in csrcfile */
+		cline = (int)strtol(cp, &eptr, 10);
+		if (cp == eptr) {
+		        cline = -1;
+		} else {
+			cp = eptr;
+		}
+
+		/* record type */
+		if (*cp != '\0') {
+			rt = *cp++;
+		} else {
+			inperr();
+		}
+
+		if (rt == 'S') {
+			setsrc(cp);
+			continue;
+		} else if (rt == 's') {
+			setfnid(cline, cp);
+			continue;
+		}
+
+		/*
+		 * Index of (included) source file. If this index is
+		 * different from csrcfile, it refers to an included
+		 * file.
+		 */
+		isrc = (int)strtol(cp, &eptr, 10);
+		if (cp == eptr)
+			inperr();
+		cp = eptr;
+		isrc = inpfns[isrc];
+
+		/* line number in isrc */
+		if (*cp++ != '.')
+			inperr();
+		iline = (int)strtol(cp, &eptr, 10);
+		if (cp == eptr)
+			inperr();
+		cp = eptr;
+
+		pos.p_src = (u_short)csrcfile;
+		pos.p_line = (u_short)cline;
+		pos.p_isrc = (u_short)isrc;
+		pos.p_iline = (u_short)iline;
+
+		/* process rest of this record */
+		switch (rt) {
+		case 'c':
+			funccall(&pos, cp);
+			break;
+		case 'd':
+			decldef(&pos, cp);
+			break;
+		case 'u':
+			usedsym(&pos, cp);
+			break;
+		default:
+			inperr();
+		}
+
+	}
+
+	if (ferror(inp))
+		err(1, "read error on %s", name);
+
+	(void)fclose(inp);
+}
+
+
+static void
+inperr()
+{
+	errx(1, "input file error: %s", fnames[srcfile]);
+}
+
+/*
+ * Set the name of the C source file of the .ln file which is
+ * currently read.
+ */
+static void
+setsrc(cp)
+	const	char *cp;
+{
+	csrcfile = getfnidx(cp);
+}
+
+/*
+ * setfnid() gets as input an index as used in an input file and the
+ * associated file name. If neccessary, it creates a new lint2 file
+ * name index for this file name and creates the mapping of the index
+ * as used in the input file to the index used in lint2.
+ */
+static void
+setfnid(fid, cp)
+	int	fid;
+	const	char *cp;
+{
+	if (fid == -1)
+		inperr();
+
+	if (fid >= ninpfns) {
+		inpfns = xrealloc(inpfns, (ninpfns * 2) * sizeof (short));
+		(void)memset(inpfns + ninpfns, 0, ninpfns * sizeof (short));
+		ninpfns *= 2;
+	}
+	/*
+	 * Should always be true because indices written in the output
+	 * file by lint1 are always the previous index + 1.
+	 */
+	if (fid >= ninpfns)
+		errx(1, "internal error: setfnid()");
+	inpfns[fid] = (u_short)getfnidx(cp);
+}
+
+/*
+ * Process a function call record (c-record).
+ */
+static void
+funccall(posp, cp)
+	pos_t	*posp;
+	const	char *cp;
+{
+	arginf_t *ai, **lai;
+	char	c, *eptr;
+	int	rused, rdisc;
+	hte_t	*hte;
+	fcall_t	*fcall;
+
+	fcall = xalloc(sizeof (fcall_t));
+	STRUCT_ASSIGN(fcall->f_pos, *posp);
+
+	/* read flags */
+	rused = rdisc = 0;
+	lai = &fcall->f_args;
+	while ((c = *cp) == 'u' || c == 'i' || c == 'd' ||
+	       c == 'z' || c == 'p' || c == 'n' || c == 's') {
+		cp++;
+		switch (c) {
+		case 'u':
+			if (rused || rdisc)
+				inperr();
+			rused = 1;
+			break;
+		case 'i':
+			if (rused || rdisc)
+				inperr();
+			break;
+		case 'd':
+			if (rused || rdisc)
+				inperr();
+			rdisc = 1;
+			break;
+		case 'z':
+		case 'p':
+		case 'n':
+		case 's':
+			ai = xalloc(sizeof (arginf_t));
+			ai->a_num = (int)strtol(cp, &eptr, 10);
+			if (cp == eptr)
+				inperr();
+			cp = eptr;
+			if (c == 'z') {
+				ai->a_pcon = ai->a_zero = 1;
+			} else if (c == 'p') {
+				ai->a_pcon = 1;
+			} else if (c == 'n') {
+				ai->a_ncon = 1;
+			} else {
+				ai->a_fmt = 1;
+				ai->a_fstrg = inpqstrg(cp, &cp);
+			}
+			*lai = ai;
+			lai = &ai->a_nxt;
+			break;
+		}
+	}
+	fcall->f_rused = rused;
+	fcall->f_rdisc = rdisc;
+
+	/* read name of function */
+	hte = hsearch(inpname(cp, &cp), 1);
+	hte->h_used = 1;
+
+	fcall->f_type = inptype(cp, &cp);
+
+	*hte->h_lcall = fcall;
+	hte->h_lcall = &fcall->f_nxt;
+
+	if (*cp != '\0')
+		inperr();
+}
+
+/*
+ * Process a declaration or definition (d-record).
+ */
+static void
+decldef(posp, cp)
+	pos_t	*posp;
+	const	char *cp;
+{
+	sym_t	*symp, sym;
+	char	c, *ep;
+	int	used;
+	hte_t	*hte;
+
+	(void)memset(&sym, 0, sizeof (sym));
+	STRUCT_ASSIGN(sym.s_pos, *posp);
+	sym.s_def = NODECL;
+
+	used = 0;
+
+	while ((c = *cp) == 't' || c == 'd' || c == 'e' || c == 'u' ||
+	       c == 'r' || c == 'o' || c == 's' || c == 'v' ||
+	       c == 'P' || c == 'S') {
+		cp++;
+		switch (c) {
+		case 't':
+			if (sym.s_def != NODECL)
+				inperr();
+			sym.s_def = TDEF;
+			break;
+		case 'd':
+			if (sym.s_def != NODECL)
+				inperr();
+			sym.s_def = DEF;
+			break;
+		case 'e':
+			if (sym.s_def != NODECL)
+				inperr();
+			sym.s_def = DECL;
+			break;
+		case 'u':
+			if (used)
+				inperr();
+			used = 1;
+			break;
+		case 'r':
+			if (sym.s_rval)
+				inperr();
+			sym.s_rval = 1;
+			break;
+		case 'o':
+			if (sym.s_osdef)
+				inperr();
+			sym.s_osdef = 1;
+			break;
+		case 's':
+			if (sym.s_static)
+				inperr();
+			sym.s_static = 1;
+			break;
+		case 'v':
+			if (sym.s_va)
+				inperr();
+			sym.s_va = 1;
+			sym.s_nva = (short)strtol(cp, &ep, 10);
+			if (cp == ep)
+				inperr();
+			cp = ep;
+			break;
+		case 'P':
+			if (sym.s_prfl)
+				inperr();
+			sym.s_prfl = 1;
+			sym.s_nprfl = (short)strtol(cp, &ep, 10);
+			if (cp == ep)
+				inperr();
+			cp = ep;
+			break;
+		case 'S':
+			if (sym.s_scfl)
+				inperr();
+			sym.s_scfl = 1;
+			sym.s_nscfl = (short)strtol(cp, &ep, 10);
+			if (cp == ep)
+				inperr();
+			cp = ep;
+			break;
+		}
+	}
+
+	/* read symbol name */
+	hte = hsearch(inpname(cp, &cp), 1);
+	hte->h_used |= used;
+	if (sym.s_def == DEF || sym.s_def == TDEF)
+		hte->h_def = 1;
+
+	sym.s_type = inptype(cp, &cp);
+
+	/*
+	 * Allocate memory for this symbol only if it was not already
+	 * declared or tentatively defined at the same location with
+	 * the same type. Works only for symbols with external linkage,
+	 * because static symbols, tentatively defined at the same location
+	 * but in different translation units are really different symbols.
+	 */
+	for (symp = hte->h_syms; symp != NULL; symp = symp->s_nxt) {
+		if (symp->s_pos.p_isrc == sym.s_pos.p_isrc &&
+		    symp->s_pos.p_iline == sym.s_pos.p_iline &&
+		    symp->s_type == sym.s_type &&
+		    ((symp->s_def == DECL && sym.s_def == DECL) ||
+		     (!sflag && symp->s_def == TDEF && sym.s_def == TDEF)) &&
+		    !symp->s_static && !sym.s_static) {
+			break;
+		}
+	}
+
+	if (symp == NULL) {
+		/* allocsym reserviert keinen Platz fuer s_nva */
+		if (sym.s_va || sym.s_prfl || sym.s_scfl) {
+			symp = xalloc(sizeof (sym_t));
+			STRUCT_ASSIGN(*symp, sym);
+		} else {
+			symp = xalloc(sizeof (symp->s_s));
+			STRUCT_ASSIGN(symp->s_s, sym.s_s);
+		}
+		*hte->h_lsym = symp;
+		hte->h_lsym = &symp->s_nxt;
+	}
+
+	if (*cp != '\0')
+		inperr();
+}
+
+/*
+ * Read an u-record (emited by lint1 if a symbol was used).
+ */
+static void
+usedsym(posp, cp)
+	pos_t	*posp;
+	const	char *cp;
+{
+	usym_t	*usym;
+	hte_t	*hte;
+
+	usym = xalloc(sizeof (usym_t));
+	STRUCT_ASSIGN(usym->u_pos, *posp);
+
+	/* needed as delimiter between two numbers */
+	if (*cp++ != 'x')
+		inperr();
+
+	hte = hsearch(inpname(cp, &cp), 1);
+	hte->h_used = 1;
+
+	*hte->h_lusym = usym;
+	hte->h_lusym = &usym->u_nxt;
+}
+
+/*
+ * Read a type and return the index of this type.
+ */
+static u_short
+inptype(cp, epp)
+	const	char *cp, **epp;
+{
+	char	c, s, *eptr;
+	const	char *ep;
+	type_t	*tp;
+	int	narg, i, osdef;
+	size_t	tlen;
+	u_short	tidx;
+	int	h;
+
+	/* If we have this type already, return it's index. */
+	tlen = gettlen(cp, &ep);
+	h = thash(cp, tlen);
+	if ((tidx = findtype(cp, tlen, h)) != 0) {
+		*epp = ep;
+		return (tidx);
+	}
+
+	/* No, we must create a new type. */
+	tp = xalloc(sizeof (type_t));
+
+	tidx = storetyp(tp, cp, tlen, h);
+
+	c = *cp++;
+
+	while (c == 'c' || c == 'v') {
+		if (c == 'c') {
+			tp->t_const = 1;
+		} else {
+			tp->t_volatile = 1;
+		}
+		c = *cp++;
+	}
+
+	if (c == 's' || c == 'u' || c == 'l' || c == 'e') {
+		s = c;
+		c = *cp++;
+	} else {
+		s = '\0';
+	}
+
+	switch (c) {
+	case 'C':
+		tp->t_tspec = s == 's' ? SCHAR : (s == 'u' ? UCHAR : CHAR);
+		break;
+	case 'S':
+		tp->t_tspec = s == 'u' ? USHORT : SHORT;
+		break;
+	case 'I':
+		tp->t_tspec = s == 'u' ? UINT : INT;
+		break;
+	case 'L':
+		tp->t_tspec = s == 'u' ? ULONG : LONG;
+		break;
+	case 'Q':
+		tp->t_tspec = s == 'u' ? UQUAD : QUAD;
+		break;
+	case 'D':
+		tp->t_tspec = s == 's' ? FLOAT : (s == 'l' ? LDOUBLE : DOUBLE);
+		break;
+	case 'V':
+		tp->t_tspec = VOID;
+		break;
+	case 'P':
+		tp->t_tspec = PTR;
+		break;
+	case 'A':
+		tp->t_tspec = ARRAY;
+		break;
+	case 'F':
+	case 'f':
+		osdef = c == 'f';
+		tp->t_tspec = FUNC;
+		break;
+	case 'T':
+		tp->t_tspec = s == 'e' ? ENUM : (s == 's' ? STRUCT : UNION);
+		break;
+	}
+
+	switch (tp->t_tspec) {
+	case ARRAY:
+		tp->t_dim = (int)strtol(cp, &eptr, 10);
+		cp = eptr;
+		tp->t_subt = TP(inptype(cp, &cp));
+		break;
+	case PTR:
+		tp->t_subt = TP(inptype(cp, &cp));
+		break;
+	case FUNC:
+		c = *cp;
+		if (isdigit((u_char)c)) {
+			if (!osdef)
+				tp->t_proto = 1;
+			narg = (int)strtol(cp, &eptr, 10);
+			cp = eptr;
+			tp->t_args = xcalloc((size_t)(narg + 1),
+					     sizeof (type_t *));
+			for (i = 0; i < narg; i++) {
+				if (i == narg - 1 && *cp == 'E') {
+					tp->t_vararg = 1;
+					cp++;
+				} else {
+					tp->t_args[i] = TP(inptype(cp, &cp));
+				}
+			}
+		}
+		tp->t_subt = TP(inptype(cp, &cp));
+		break;
+	case ENUM:
+		tp->t_tspec = INT;
+		tp->t_isenum = 1;
+		/* FALLTHROUGH */
+	case STRUCT:
+	case UNION:
+		switch (*cp++) {
+		case '0':
+			break;
+		case '1':
+			tp->t_istag = 1;
+			tp->t_tag = hsearch(inpname(cp, &cp), 1);
+			break;
+		case '2':
+			tp->t_istynam = 1;
+			tp->t_tynam = hsearch(inpname(cp, &cp), 1);
+			break;
+		}
+		break;
+		/* LINTED (enumeration value(s) not handled in switch) */
+	}
+
+	*epp = cp;
+	return (tidx);
+}
+
+/*
+ * Get the length of a type string.
+ */
+static int
+gettlen(cp, epp)
+	const	char *cp, **epp;
+{
+	const	char *cp1;
+	char	c, s, *eptr;
+	tspec_t	t;
+	int	narg, i, cm, vm;
+
+	cp1 = cp;
+
+	c = *cp++;
+
+	cm = vm = 0;
+
+	while (c == 'c' || c == 'v') {
+		if (c == 'c') {
+			if (cm)
+				inperr();
+			cm = 1;
+		} else {
+			if (vm)
+				inperr();
+			vm = 1;
+		}
+		c = *cp++;
+	}
+
+	if (c == 's' || c == 'u' || c == 'l' || c == 'e') {
+		s = c;
+		c = *cp++;
+	} else {
+		s = '\0';
+	}
+
+	t = NOTSPEC;
+
+	switch (c) {
+	case 'C':
+		if (s == 's') {
+			t = SCHAR;
+		} else if (s == 'u') {
+			t = UCHAR;
+		} else if (s == '\0') {
+			t = CHAR;
+		}
+		break;
+	case 'S':
+		if (s == 'u') {
+			t = USHORT;
+		} else if (s == '\0') {
+			t = SHORT;
+		}
+		break;
+	case 'I':
+		if (s == 'u') {
+			t = UINT;
+		} else if (s == '\0') {
+			t = INT;
+		}
+		break;
+	case 'L':
+		if (s == 'u') {
+			t = ULONG;
+		} else if (s == '\0') {
+			t = LONG;
+		}
+		break;
+	case 'Q':
+		if (s == 'u') {
+			t = UQUAD;
+		} else if (s == '\0') {
+			t = QUAD;
+		}
+		break;
+	case 'D':
+		if (s == 's') {
+			t = FLOAT;
+		} else if (s == 'l') {
+			t = LDOUBLE;
+		} else if (s == '\0') {
+			t = DOUBLE;
+		}
+		break;
+	case 'V':
+		if (s == '\0')
+			t = VOID;
+		break;
+	case 'P':
+		if (s == '\0')
+			t = PTR;
+		break;
+	case 'A':
+		if (s == '\0')
+			t = ARRAY;
+		break;
+	case 'F':
+	case 'f':
+		if (s == '\0')
+			t = FUNC;
+		break;
+	case 'T':
+		if (s == 'e') {
+			t = ENUM;
+		} else if (s == 's') {
+			t = STRUCT;
+		} else if (s == 'u') {
+			t = UNION;
+		}
+		break;
+	default:
+		inperr();
+	}
+
+	if (t == NOTSPEC)
+		inperr();
+
+	switch (t) {
+	case ARRAY:
+		(void)strtol(cp, &eptr, 10);
+		if (cp == eptr)
+			inperr();
+		cp = eptr;
+		(void)gettlen(cp, &cp);
+		break;
+	case PTR:
+		(void)gettlen(cp, &cp);
+		break;
+	case FUNC:
+		c = *cp;
+		if (isdigit((u_char)c)) {
+			narg = (int)strtol(cp, &eptr, 10);
+			cp = eptr;
+			for (i = 0; i < narg; i++) {
+				if (i == narg - 1 && *cp == 'E') {
+					cp++;
+				} else {
+					(void)gettlen(cp, &cp);
+				}
+			}
+		}
+		(void)gettlen(cp, &cp);
+		break;
+	case ENUM:
+	case STRUCT:
+	case UNION:
+		switch (*cp++) {
+		case '0':
+			break;
+		case '1':
+			(void)inpname(cp, &cp);
+			break;
+		case '2':
+			(void)inpname(cp, &cp);
+			break;
+		default:
+			inperr();
+		}
+		break;
+		/* LINTED (enumeration value(s) not handled in switch) */
+	}
+
+	*epp = cp;
+	return (cp - cp1);
+}
+
+/*
+ * Search a type by it's type string.
+ */
+static u_short
+findtype(cp, len, h)
+	const	char *cp;
+	size_t	len;
+	int	h;
+{
+	thtab_t	*thte;
+
+	for (thte = thtab[h]; thte != NULL; thte = thte->th_nxt) {
+		if (strncmp(thte->th_name, cp, len) != 0)
+			continue;
+		if (thte->th_name[len] == '\0')
+			return (thte->th_idx);
+	}
+
+	return (0);
+}
+
+/*
+ * Store a type and it's type string so we can later share this type
+ * if we read the same type string from the input file.
+ */
+static u_short
+storetyp(tp, cp, len, h)
+	type_t	*tp;
+	const	char *cp;
+	size_t	len;
+	int	h;
+{
+	/* 0 ist reserved */
+	static	u_int	tidx = 1;
+	thtab_t	*thte;
+	char	*name;
+
+	if (tidx >= USHRT_MAX)
+		errx(1, "sorry, too many types");
+
+	if (tidx == tlstlen - 1) {
+		tlst = xrealloc(tlst, (tlstlen * 2) * sizeof (type_t *));
+		(void)memset(tlst + tlstlen, 0, tlstlen * sizeof (type_t *));
+		tlstlen *= 2;
+	}
+
+	tlst[tidx] = tp;
+
+	/* create a hash table entry */
+	name = xalloc(len + 1);
+	(void)memcpy(name, cp, len);
+	name[len] = '\0';
+
+	thte = xalloc(sizeof (thtab_t));
+	thte->th_name = name;
+	thte->th_idx = tidx;
+	thte->th_nxt = thtab[h];
+	thtab[h] = thte;
+
+	return ((u_short)tidx++);
+}
+
+/*
+ * Hash function for types
+ */
+static int
+thash(s, len)
+	const	char *s;
+	size_t	len;
+{
+	u_int	v;
+
+	v = 0;
+	while (len-- != 0) {
+		v = (v << sizeof (v)) + (u_char)*s++;
+		v ^= v >> (sizeof (v) * CHAR_BIT - sizeof (v));
+	}
+	return (v % THSHSIZ2);
+}
+
+/*
+ * Read a string enclosed by "". This string may contain quoted chars.
+ */
+static char *
+inpqstrg(src, epp)
+	const	char *src, **epp;
+{
+	char	*strg, *dst;
+	size_t	slen;
+	int	c;
+	int	v;
+
+	dst = strg = xmalloc(slen = 32);
+
+	if ((c = *src++) != '"')
+		inperr();
+	if ((c = *src++) == '\0')
+		inperr();
+
+	while (c != '"') {
+		if (c == '\\') {
+			if ((c = *src++) == '\0')
+				inperr();
+			switch (c) {
+			case 'n':
+				c = '\n';
+				break;
+			case 't':
+				c = '\t';
+				break;
+			case 'v':
+#ifdef __STDC__
+				c = '\v';
+#else
+				c = '\013';
+#endif
+				break;
+			case 'b':
+				c = '\b';
+				break;
+			case 'r':
+				c = '\r';
+				break;
+			case 'f':
+				c = '\f';
+				break;
+			case 'a':
+#ifdef __STDC__
+				c = '\a';
+#else
+				c = '\007';
+#endif
+				break;
+			case '\\':
+				c = '\\';
+				break;
+			case '"':
+				c = '"';
+				break;
+			case '\'':
+				c = '\'';
+				break;
+			case '0': case '1': case '2': case '3':
+				v = (c - '0') << 6;
+				if ((c = *src++) < '0' || c > '7')
+					inperr();
+				v |= (c - '0') << 3;
+				if ((c = *src++) < '0' || c > '7')
+					inperr();
+				v |= c - '0';
+				c = (u_char)v;
+				break;
+			default:
+				inperr();
+			}
+		}
+		/* keep space for trailing '\0' */
+		if (dst - strg == slen - 1) {
+			strg = xrealloc(strg, slen * 2);
+			dst = strg + (slen - 1);
+			slen *= 2;
+		}
+		*dst++ = (char)c;
+		if ((c = *src++) == '\0')
+			inperr();
+	}
+	*dst = '\0';
+
+	*epp = src;
+	return (strg);
+}
+
+/*
+ * Read the name of a symbol in static memory.
+ */
+static const char *
+inpname(cp, epp)
+	const	char *cp, **epp;
+{
+	static	char	*buf;
+	static	size_t	blen = 0;
+	size_t	len, i;
+	char	*eptr, c;
+
+	len = (int)strtol(cp, &eptr, 10);
+	if (cp == eptr)
+		inperr();
+	cp = eptr;
+	if (len + 1 > blen)
+		buf = xrealloc(buf, blen = len + 1);
+	for (i = 0; i < len; i++) {
+		c = *cp++;
+		if (!isalnum(c) && c != '_')
+			inperr();
+		buf[i] = c;
+	}
+	buf[i] = '\0';
+
+	*epp = cp;
+	return (buf);
+}
+
+/*
+ * Return the index of a file name. If the name cannot be found, create
+ * a new entry and return the index of the newly created entry.
+ */
+static int
+getfnidx(fn)
+	const	char *fn;
+{
+	int	i;
+
+	/* 0 ist reserved */
+	for (i = 1; fnames[i] != NULL; i++) {
+		if (strcmp(fnames[i], fn) == 0)
+			break;
+	}
+	if (fnames[i] != NULL)
+		return (i);
+
+	if (i == nfnames - 1) {
+		fnames = xrealloc(fnames, (nfnames * 2) * sizeof (char *));
+		(void)memset(fnames + nfnames, 0, nfnames * sizeof (char *));
+		nfnames *= 2;
+	}
+
+	fnames[i] = xstrdup(fn);
+	return (i);
+}
+
+/*
+ * Separate symbols with static and external linkage.
+ */
+void
+mkstatic(hte)
+	hte_t	*hte;
+{
+	sym_t	*sym1, **symp, *sym;
+	fcall_t	**callp, *call;
+	usym_t	**usymp, *usym;
+	hte_t	*nhte;
+	int	ofnd;
+
+	/* Look for first static definition */
+	for (sym1 = hte->h_syms; sym1 != NULL; sym1 = sym1->s_nxt) {
+		if (sym1->s_static)
+			break;
+	}
+	if (sym1 == NULL)
+		return;
+
+	/* Do nothing if this name is used only in one translation unit. */
+	ofnd = 0;
+	for (sym = hte->h_syms; sym != NULL && !ofnd; sym = sym->s_nxt) {
+		if (sym->s_pos.p_src != sym1->s_pos.p_src)
+			ofnd = 1;
+	}
+	for (call = hte->h_calls; call != NULL && !ofnd; call = call->f_nxt) {
+		if (call->f_pos.p_src != sym1->s_pos.p_src)
+			ofnd = 1;
+	}
+	for (usym = hte->h_usyms; usym != NULL && !ofnd; usym = usym->u_nxt) {
+		if (usym->u_pos.p_src != sym1->s_pos.p_src)
+			ofnd = 1;
+	}
+	if (!ofnd) {
+		hte->h_used = 1;
+		/* errors about undef. static symbols are printed in lint1 */
+		hte->h_def = 1;
+		hte->h_static = 1;
+		return;
+	}
+
+	/*
+	 * Create a new hash table entry
+	 *
+	 * XXX this entry should be put at the beginning of the list to
+	 * avoid to process the same symbol twice.
+	 */
+	for (nhte = hte; nhte->h_link != NULL; nhte = nhte->h_link) ;
+	nhte->h_link = xalloc(sizeof (hte_t));
+	nhte = nhte->h_link;
+	nhte->h_name = hte->h_name;
+	nhte->h_static = 1;
+	nhte->h_used = 1;
+	nhte->h_def = 1;	/* error in lint1 */
+	nhte->h_lsym = &nhte->h_syms;
+	nhte->h_lcall = &nhte->h_calls;
+	nhte->h_lusym = &nhte->h_usyms;
+
+	/*
+	 * move all symbols used in this translation unit into the new
+	 * hash table entry.
+	 */
+	for (symp = &hte->h_syms; (sym = *symp) != NULL; ) {
+		if (sym->s_pos.p_src == sym1->s_pos.p_src) {
+			sym->s_static = 1;
+			(*symp) = sym->s_nxt;
+			if (hte->h_lsym == &sym->s_nxt)
+				hte->h_lsym = symp;
+			sym->s_nxt = NULL;
+			*nhte->h_lsym = sym;
+			nhte->h_lsym = &sym->s_nxt;
+		} else {
+			symp = &sym->s_nxt;
+		}
+	}
+	for (callp = &hte->h_calls; (call = *callp) != NULL; ) {
+		if (call->f_pos.p_src == sym1->s_pos.p_src) {
+			(*callp) = call->f_nxt;
+			if (hte->h_lcall == &call->f_nxt)
+				hte->h_lcall = callp;
+			call->f_nxt = NULL;
+			*nhte->h_lcall = call;
+			nhte->h_lcall = &call->f_nxt;
+		} else {
+			callp = &call->f_nxt;
+		}
+	}
+	for (usymp = &hte->h_usyms; (usym = *usymp) != NULL; ) {
+		if (usym->u_pos.p_src == sym1->s_pos.p_src) {
+			(*usymp) = usym->u_nxt;
+			if (hte->h_lusym == &usym->u_nxt)
+				hte->h_lusym = usymp;
+			usym->u_nxt = NULL;
+			*nhte->h_lusym = usym;
+			nhte->h_lusym = &usym->u_nxt;
+		} else {
+			usymp = &usym->u_nxt;
+		}
+	}
+
+	/* h_def must be recalculated for old hte */
+	hte->h_def = nhte->h_def = 0;
+	for (sym = hte->h_syms; sym != NULL; sym = sym->s_nxt) {
+		if (sym->s_def == DEF || sym->s_def == TDEF) {
+			hte->h_def = 1;
+			break;
+		}
+	}
+
+	mkstatic(hte);
+}