/* $NetBSD: read.c,v 1.94 2026/01/11 18:11:38 rillig Exp $ */

/*
 * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
 * 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.
 */

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/cdefs.h>
#if defined(__RCSID)
__RCSID("$NetBSD: read.c,v 1.94 2026/01/11 18:11:38 rillig Exp $");
#endif

#include <ctype.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.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 indices to file names.
 * Indices of type short are used instead of pointers to save memory.
 */
const char **fnames;
static size_t *flines;
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, an 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;
        unsigned short th_idx;
        struct thtab *th_next;
} thtab_t;
static thtab_t *thtab[1009];            /* hash table */
type_t **tlst;                          /* array for indexed access */
static size_t tlstlen;          /* length of tlst */

static hte_t **renametab;

/* index of current C source file (as specified at the command line) */
static int csrcfile;

static const char *readfile_line;

static void inperr(const char *, ...)
    __printflike(1, 2) __attribute__((noreturn));
static void setsrc(const char *);
static void setfnid(int, const char *);
static void funccall(pos_t, const char *);
static void decldef(pos_t, const char *);
static void usedsym(pos_t, const char *);
static unsigned short inptype(const char *, const char **);
static size_t gettlen(const char *, const char **);
static unsigned short findtype(const char *, size_t, int);
static unsigned short storetyp(type_t *, const char *, size_t, int);
static unsigned int thash(const char *, size_t);
static char *inpqstrg(const char *, const char **);
static const char *inpname(const char *, const char **);
static int getfnidx(const char *);

/* Allocate zero-initialized memory that doesn't need to be freed. */
static void *
xalloc(size_t sz)
{

        void *ptr = xmalloc(sz);
        (void)memset(ptr, 0, sz);
        return ptr;
}

static bool
try_parse_int(const char **p, int *num)
{
        char *end;

        *num = (int)strtol(*p, &end, 10);
        if (end == *p)
                return false;
        *p = end;
        return true;
}

static int
parse_int(const char **p)
{
        char *end;
        int n;

        n = (int)strtol(*p, &end, 10);
        if (end == *p)
                inperr("not a number: %s", *p);
        *p = end;
        return n;
}

static short
parse_short(const char **p)
{
        return (short)parse_int(p);
}

static void
read_ln_line(const char *line)
{
        const char *cp;
        int cline, isrc, iline;
        char rt;
        pos_t pos;

        cp = line;

        /* line number in csrcfile */
        if (!try_parse_int(&cp, &cline))
                cline = -1;

        /* record type */
        if (*cp == '\0')
                inperr("missing record type");
        rt = *cp++;

        if (rt == 'S') {
                setsrc(cp);
                return;
        }
        if (rt == 's') {
                setfnid(cline, cp);
                return;
        }

        /*
         * Index of (included) source file. If this index is different from
         * csrcfile, it refers to an included file.
         */
        isrc = parse_int(&cp);
        isrc = inpfns[isrc];

        /* line number in isrc */
        if (*cp++ != '.')
                inperr("bad line number");
        iline = parse_int(&cp);

        pos.p_src = (unsigned short)csrcfile;
        pos.p_line = (unsigned short)cline;
        pos.p_isrc = (unsigned short)isrc;
        pos.p_iline = (unsigned 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("bad record type %c", rt);
        }
}

void
readfile(const char *name)
{
        FILE *inp;
        size_t len;
        char *line;

        if (inpfns == NULL)
                inpfns = xcalloc(ninpfns = 128, sizeof(*inpfns));
        if (fnames == NULL)
                fnames = xcalloc(nfnames = 256, sizeof(*fnames));
        if (flines == NULL)
                flines = xcalloc(nfnames, sizeof(*flines));
        if (tlstlen == 0)
                tlst = xcalloc(tlstlen = 256, sizeof(*tlst));

        renametab = htab_new();

        srcfile = getfnidx(name);

        if ((inp = fopen(name, "r")) == NULL)
                err(1, "cannot open %s", name);

        while ((line = fgetln(inp, &len)) != NULL) {
                flines[srcfile]++;

                readfile_line = line;
                if (len == 0 || line[len - 1] != '\n')
                        inperr("missing newline after '%s'", &line[len - 1]);
                line[len - 1] = '\0';

                read_ln_line(line);
                readfile_line = NULL;
        }

        hash_free(renametab);

        if (ferror(inp) != 0)
                err(1, "read error on %s", name);

        (void)fclose(inp);
}


static void
inperr(const char *fmt, ...)
{
        va_list ap;
        char buf[1024];

        va_start(ap, fmt);
        (void)vsnprintf(buf, sizeof(buf), fmt, ap);
        va_end(ap);

        errx(1, "error: %s:%zu: %s (for '%s')",
            fnames[srcfile], flines[srcfile], buf, readfile_line);
}

/*
 * Set the name of the C source file of the .ln file which is
 * currently read.
 */
static void
setsrc(const char *cp)
{

        csrcfile = getfnidx(cp);
}

/*
 * setfnid() gets as input an index as used in an input file and the
 * associated file name. If necessary, 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(int fid, const char *cp)
{

        if (fid < 0)
                inperr("bad fid");

        if ((size_t)fid >= ninpfns) {
                inpfns = xrealloc(inpfns, (ninpfns * 2) * sizeof(*inpfns));
                (void)memset(inpfns + ninpfns, 0, ninpfns * sizeof(*inpfns));
                ninpfns *= 2;
        }
        /*
         * Should always be true because indices written in the output file by
         * lint1 are always the previous index + 1.
         */
        if ((size_t)fid >= ninpfns)
                errx(1, "internal error: setfnid");
        inpfns[fid] = (unsigned short)getfnidx(cp);
}

/*
 * Process a function call record (c-record).
 */
static void
funccall(pos_t pos, const char *cp)
{
        arginf_t *ai, **lai;
        char c;
        bool rused, rdisc;
        hte_t *hte;
        fcall_t *fcall;
        const char *name;

        fcall = xalloc(sizeof(*fcall));
        fcall->f_pos = pos;

        /* read flags */
        rused = rdisc = false;
        lai = &fcall->f_args;

again:
        c = *cp++;
        switch (c) {
        case 'u':
                if (rused || rdisc)
                        inperr("used or discovered: %c", c);
                rused = true;
                goto again;
        case 'i':
                if (rused || rdisc)
                        inperr("used or discovered: %c", c);
                goto again;
        case 'd':
                if (rused || rdisc)
                        inperr("used or discovered: %c", c);
                rdisc = true;
                goto again;
        case 'z':
        case 'p':
        case 'n':
        case 's':
                ai = xalloc(sizeof(*ai));
                ai->a_num = parse_int(&cp);
                if (c == 'z')
                        ai->a_pcon = ai->a_zero = true;
                else if (c == 'p')
                        ai->a_pcon = true;
                else if (c == 'n')
                        ai->a_ncon = true;
                else {
                        ai->a_fmt = true;
                        ai->a_fstrg = inpqstrg(cp, &cp);
                }
                *lai = ai;
                lai = &ai->a_next;
                goto again;
        default:
                cp--;
        }

        fcall->f_rused = rused;
        fcall->f_rdisc = rdisc;

        /* read name of function */
        name = inpname(cp, &cp);

        /* first look it up in the renaming table, then in the normal table */
        hte = hash_search(renametab, name, false);
        if (hte != NULL)
                hte = hte->h_hte;
        else
                hte = htab_search(name, true);
        hte->h_used = true;

        fcall->f_type = inptype(cp, &cp);

        *hte->h_lcall = fcall;
        hte->h_lcall = &fcall->f_next;

        if (*cp != '\0')
                inperr("trailing line data: %s", cp);
}

static bool
parse_function_attribute(const char **pp, sym_t *sym, bool *used)
{

        switch (*(*pp)++) {
        case 'd':
                if (sym->s_def != NODECL)
                        inperr("def");
                sym->s_def = DEF;
                break;
        case 'e':
                if (sym->s_def != NODECL)
                        inperr("decl");
                sym->s_def = DECL;
                break;
        case 'i':
                if (sym->s_inline)
                        inperr("inline");
                sym->s_inline = true;
                break;
        case 'o':
                if (sym->s_old_style_function)
                        inperr("osdef");
                sym->s_old_style_function = true;
                break;
        case 'r':
                if (sym->s_function_has_return_value)
                        inperr("r");
                sym->s_function_has_return_value = true;
                break;
        case 's':
                if (sym->s_static)
                        inperr("static");
                sym->s_static = true;
                break;
        case 't':
                if (sym->s_def != NODECL)
                        inperr("tdef");
                sym->s_def = TDEF;
                break;
        case 'u':
                if (*used)
                        inperr("used");
                *used = true;
                break;
        case 'v':
                if (sym->s_check_only_first_args)
                        inperr("v");
                sym->s_check_only_first_args = true;
                sym->s_check_num_args = parse_short(pp);
                break;
        case 'P':
                if (sym->s_printflike)
                        inperr("P");
                sym->s_printflike = true;
                sym->s_printflike_arg = parse_short(pp);
                break;
        case 'S':
                if (sym->s_scanflike)
                        inperr("S");
                sym->s_scanflike = true;
                sym->s_scanflike_arg = parse_short(pp);
                break;
        default:
                (*pp)--;
                return false;
        }
        return true;
}

/*
 * Process a declaration or definition (d-record).
 */
static void
decldef(pos_t pos, const char *cp)
{
        sym_t *symp, sym;
        char *tname;
        bool used, renamed;
        hte_t *hte, *renamehte = NULL;
        const char *name, *newname;

        (void)memset(&sym, 0, sizeof(sym));
        sym.s_pos = pos;
        sym.s_def = NODECL;

        used = false;

        while (parse_function_attribute(&cp, &sym, &used))
                continue;

        /* read symbol name, doing renaming if necessary */
        name = inpname(cp, &cp);
        renamed = false;
        if (*cp == 'r') {
                cp++;
                tname = xstrdup(name);
                newname = inpname(cp, &cp);

                /* enter it and see if it's already been renamed */
                renamehte = hash_search(renametab, tname, true);
                if (renamehte->h_hte == NULL) {
                        hte = htab_search(newname, true);
                        renamehte->h_hte = hte;
                        renamed = true;
                } else if (hte = renamehte->h_hte,
                    strcmp(hte->h_name, newname) != 0) {
                        /* %s is renamed multiple times in %s and %s */
                        msg(18, tname, mkpos(&renamehte->h_syms->s_pos),
                            mkpos(&sym.s_pos));
                }
                free(tname);
        } else {
                /* it might be a previously-done rename */
                hte = hash_search(renametab, name, false);
                if (hte != NULL)
                        hte = hte->h_hte;
                else
                        hte = htab_search(name, true);
        }
        hte->h_used |= used;
        if (sym.s_def == DEF || sym.s_def == TDEF)
                hte->h_def = true;

        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_next) {
                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) {
                if (sym.s_check_only_first_args ||
                    sym.s_printflike || sym.s_scanflike) {
                        symp = xalloc(sizeof(*symp));
                        *symp = sym;
                } else {
                        /* no need to allocate memory for unused members */
                        symp = xalloc(sizeof(symp->s_s));
                        symp->s_s = sym.s_s;
                }
                *hte->h_lsym = symp;
                hte->h_lsym = &symp->s_next;

                /* XXX hack so we can remember where a symbol was renamed */
                if (renamed)
                        renamehte->h_syms = symp;
        }

        if (*cp != '\0')
                inperr("trailing line: %s", cp);
}

/*
 * Read an u-record (emitted by lint1 if a symbol was used).
 */
static void
usedsym(pos_t pos, const char *cp)
{
        usym_t *usym;
        hte_t *hte;
        const char *name;

        usym = xalloc(sizeof(*usym));
        usym->u_pos = pos;

        /* needed as delimiter between two numbers */
        if (*cp++ != 'x')
                inperr("bad delim %c", cp[-1]);

        name = inpname(cp, &cp);
        hte = hash_search(renametab, name, false);
        if (hte != NULL)
                hte = hte->h_hte;
        else
                hte = htab_search(name, true);
        hte->h_used = true;

        *hte->h_lusym = usym;
        hte->h_lusym = &usym->u_next;
}

static tspec_t
parse_tspec(const char **pp, char c, bool *osdef)
{
        char s;

        switch (c) {
        case 's':               /* 'signed' or 'struct' or 'float' */
        case 'u':               /* 'unsigned' or 'union' */
        case 'l':               /* 'long double' */
        case 'e':               /* 'enum' */
                s = c;
                c = *(*pp)++;
                break;
        default:
                s = '\0';
                break;
        }

        switch (c) {
        case 'B':
                return BOOL;
        case 'C':
                return s == 's' ? SCHAR : (s == 'u' ? UCHAR : CHAR);
        case 'S':
                return s == 'u' ? USHORT : SHORT;
        case 'I':
                return s == 'u' ? UINT : INT;
        case 'L':
                return s == 'u' ? ULONG : LONG;
        case 'Q':
                return s == 'u' ? ULLONG : LLONG;
        case 'J':
                return s == 'u' ? UINT128 : INT128;
        case 'D':
                return s == 's' ? FLOAT : (s == 'l' ? LDOUBLE : DOUBLE);
        case 'V':
                return VOID;
        case 'P':
                return PTR;
        case 'A':
                return ARRAY;
        case 'F':
        case 'f':
                *osdef = c == 'f';
                return FUNC;
        case 'T':
                return s == 'e' ? ENUM : (s == 's' ? STRUCT : UNION);
        case 'X':
                return s == 's' ? FCOMPLEX
                    : (s == 'l' ? LCOMPLEX : DCOMPLEX);
        default:
                inperr("tspec '%c'", c);
                /* NOTREACHED */
        }
}

/*
 * Read a type and return the index of this type.
 */
static unsigned short
inptype(const char *cp, const char **epp)
{
        char c;
        const char *ep;
        type_t *tp;
        int narg, i;
        bool osdef = false;
        size_t tlen;
        unsigned short tidx;
        int h;

        /* If we have this type already, return its 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(*tp));

        tidx = storetyp(tp, cp, tlen, h);

        c = *cp++;

        if (c == 'c') {
                tp->t_const = true;
                c = *cp++;
        }
        if (c == 'v') {
                tp->t_volatile = true;
                c = *cp++;
        }

        tp->t_tspec = parse_tspec(&cp, c, &osdef);

        switch (tp->t_tspec) {
        case ARRAY:
                tp->t_dim = parse_int(&cp);
                tp->t_subt = TP(inptype(cp, &cp));
                break;
        case PTR:
                tp->t_subt = TP(inptype(cp, &cp));
                break;
        case FUNC:
                c = *cp;
                if (ch_isdigit(c)) {
                        if (!osdef)
                                tp->t_proto = true;
                        narg = parse_int(&cp);
                        tp->t_args = xcalloc((size_t)narg + 1,
                            sizeof(*tp->t_args));
                        for (i = 0; i < narg; i++) {
                                if (i == narg - 1 && *cp == 'E') {
                                        tp->t_vararg = true;
                                        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_is_enum = true;
                /* FALLTHROUGH */
        case STRUCT:
        case UNION:
                switch (*cp++) {
                case '1':
                        tp->t_istag = true;
                        tp->t_tag = htab_search(inpname(cp, &cp), true);
                        break;
                case '2':
                        tp->t_istynam = true;
                        tp->t_tynam = htab_search(inpname(cp, &cp), true);
                        break;
                case '3':
                        tp->t_isuniqpos = true;
                        tp->t_uniqpos.p_line = parse_int(&cp);
                        cp++;
                        /* xlate to 'global' file name. */
                        tp->t_uniqpos.p_file = (short)
                            addoutfile(inpfns[parse_int(&cp)]);
                        cp++;
                        tp->t_uniqpos.p_uniq = parse_int(&cp);
                        break;
                }
                break;
        default:
                break;
        }

        *epp = cp;
        return tidx;
}

/*
 * Get the length of a type string.
 */
static size_t
gettlen(const char *cp, const char **epp)
{
        const char *cp1;
        char c, s;
        tspec_t t;
        int narg, i;

        cp1 = cp;

        c = *cp++;

        if (c == 'c')
                c = *cp++;
        if (c == 'v')
                c = *cp++;

        switch (c) {
        case 's':
        case 'u':
        case 'l':
        case 'e':
                s = c;
                c = *cp++;
                break;
        default:
                s = '\0';
                break;
        }

        t = NO_TSPEC;

        switch (c) {
        case 'B':
                if (s == '\0')
                        t = BOOL;
                break;
        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 = ULLONG;
                else if (s == '\0')
                        t = LLONG;
                break;
        case 'J':
                if (s == 'u')
                        t = UINT128;
                else if (s == '\0')
                        t = INT128;
                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;
        case 'X':
                if (s == 's')
                        t = FCOMPLEX;
                else if (s == 'l')
                        t = LCOMPLEX;
                else if (s == '\0')
                        t = DCOMPLEX;
                break;
        default:
                break;
        }

        if (t == NO_TSPEC)
                inperr("bad type: %c %c", c, s);

        switch (t) {
        case ARRAY:
                (void)parse_int(&cp);
                (void)gettlen(cp, &cp);
                break;
        case PTR:
                (void)gettlen(cp, &cp);
                break;
        case FUNC:
                c = *cp;
                if (ch_isdigit(c)) {
                        narg = parse_int(&cp);
                        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 '1':
                case '2':
                        (void)inpname(cp, &cp);
                        break;
                case '3':
                        /* unique position: line.file.uniquifier */
                        (void)parse_int(&cp);
                        if (*cp++ != '.')
                                inperr("not dot: %c", cp[-1]);
                        (void)parse_int(&cp);
                        if (*cp++ != '.')
                                inperr("not dot: %c", cp[-1]);
                        (void)parse_int(&cp);
                        break;
                default:
                        inperr("bad value: %c", cp[-1]);
                }
                break;
        default:
                break;
        }

        *epp = cp;
        return (size_t)(cp - cp1);
}

/*
 * Search a type by its type string.
 */
static unsigned short
findtype(const char *cp, size_t len, int h)
{
        thtab_t *thte;

        for (thte = thtab[h]; thte != NULL; thte = thte->th_next) {
                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 its type string, so we can later share this type
 * if we read the same type string from the input file.
 */
static unsigned short
storetyp(type_t *tp, const char *cp, size_t len, int h)
{
        static unsigned int tidx = 1;   /* 0 is reserved */
        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(*tlst));
                (void)memset(tlst + tlstlen, 0, tlstlen * sizeof(*tlst));
                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(*thte));
        thte->th_name = name;
        thte->th_idx = (unsigned short)tidx;
        thte->th_next = thtab[h];
        thtab[h] = thte;

        return (unsigned short)tidx++;
}

/*
 * Hash function for types
 */
static unsigned int
thash(const char *s, size_t len)
{
        unsigned int v;

        v = 0;
        while (len-- != 0) {
                v = (v << sizeof(v)) + (unsigned char)*s++;
                v ^= v >> (sizeof(v) * CHAR_BIT - sizeof(v));
        }
        return v % (sizeof(thtab) / sizeof(thtab[0]));
}

/*
 * Read a string enclosed by "". This string may contain quoted chars.
 */
static char *
inpqstrg(const char *src, const char **epp)
{
        char *strg, *dst;
        size_t slen;
        char c;
        int v;

        dst = strg = xmalloc(slen = 32);

        if ((c = *src++) != '"')
                inperr("not quote: %c", c);
        if ((c = *src++) == '\0')
                inperr("trailing data: %c", c);

        while (c != '"') {
                if (c == '\\') {
                        if ((c = *src++) == '\0')
                                inperr("missing after \\");
                        switch (c) {
                        case 'n':
                                c = '\n';
                                break;
                        case 't':
                                c = '\t';
                                break;
                        case 'v':
                                c = '\v';
                                break;
                        case 'b':
                                c = '\b';
                                break;
                        case 'r':
                                c = '\r';
                                break;
                        case 'f':
                                c = '\f';
                                break;
                        case 'a':
                                c = '\a';
                                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("not octal: %c", c);
                                v |= (c - '0') << 3;
                                if ((c = *src++) < '0' || c > '7')
                                        inperr("not octal: %c", c);
                                v |= c - '0';
                                c = (char)v;
                                break;
                        default:
                                inperr("bad \\ escape: %c", c);
                        }
                }
                /* keep space for trailing '\0' */
                if ((size_t)(dst - strg) == slen - 1) {
                        strg = xrealloc(strg, slen * 2);
                        dst = strg + (slen - 1);
                        slen *= 2;
                }
                *dst++ = c;
                if ((c = *src++) == '\0')
                        inperr("missing closing quote");
        }
        *dst = '\0';

        *epp = src;
        return strg;
}

/*
 * Read the name of a symbol in static memory.
 */
static const char *
inpname(const char *cp, const char **epp)
{
        static char *buf;
        static size_t blen = 0;
        size_t len, i;
        char c;

        len = parse_int(&cp);
        if (len + 1 > blen)
                buf = xrealloc(buf, blen = len + 1);
        for (i = 0; i < len; i++) {
                c = *cp++;
                if (!ch_isalnum(c) && c != '_')
                        inperr("not alnum or _: %c", c);
                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(const char *fn)
{
        size_t i;

        /* 0 is reserved */
        for (i = 1; fnames[i] != NULL; i++) {
                if (strcmp(fnames[i], fn) == 0)
                        return (int)i;
        }

        if (i == nfnames - 1) {
                size_t nlen = nfnames * 2;
                fnames = xrealloc(fnames, nlen * sizeof(*fnames));
                (void)memset(fnames + nfnames, 0, nfnames * sizeof(*fnames));
                flines = xrealloc(flines, nlen * sizeof(*flines));
                (void)memset(flines + nfnames, 0, nfnames * sizeof(*flines));
                nfnames = nlen;
        }

        fnames[i] = xstrdup(fn);
        flines[i] = 0;
        return (int)i;
}

/*
 * Separate symbols with static and external linkage.
 */
void
mkstatic(hte_t *hte)
{
        sym_t *sym1, **symp, *sym;
        fcall_t **callp, *call;
        usym_t **usymp, *usym;
        hte_t *nhte;
        bool ofnd;

        /* Look for first static definition */
        for (sym1 = hte->h_syms; sym1 != NULL; sym1 = sym1->s_next) {
                if (sym1->s_static)
                        break;
        }
        if (sym1 == NULL)
                return;

        /* Do nothing if this name is used only in one translation unit. */
        ofnd = false;
        for (sym = hte->h_syms; sym != NULL && !ofnd; sym = sym->s_next) {
                if (sym->s_pos.p_src != sym1->s_pos.p_src)
                        ofnd = true;
        }
        for (call = hte->h_calls; call != NULL && !ofnd; call = call->f_next) {
                if (call->f_pos.p_src != sym1->s_pos.p_src)
                        ofnd = true;
        }
        for (usym = hte->h_usyms; usym != NULL && !ofnd; usym = usym->u_next) {
                if (usym->u_pos.p_src != sym1->s_pos.p_src)
                        ofnd = true;
        }
        if (!ofnd) {
                hte->h_used = true;
                /* errors about undef. static symbols are printed in lint1 */
                hte->h_def = true;
                hte->h_static = true;
                return;
        }

        /*
         * Create a new hash table entry
         *
         * XXX this entry should be put at the beginning of the list to avoid
         * processing the same symbol twice.
         */
        for (nhte = hte; nhte->h_link != NULL; nhte = nhte->h_link)
                continue;
        nhte->h_link = xmalloc(sizeof(*nhte->h_link));
        nhte = nhte->h_link;
        nhte->h_name = hte->h_name;
        nhte->h_used = true;
        nhte->h_def = true;     /* error in lint1 */
        nhte->h_static = true;
        nhte->h_syms = NULL;
        nhte->h_lsym = &nhte->h_syms;
        nhte->h_calls = NULL;
        nhte->h_lcall = &nhte->h_calls;
        nhte->h_usyms = NULL;
        nhte->h_lusym = &nhte->h_usyms;
        nhte->h_link = NULL;
        nhte->h_hte = NULL;

        /*
         * 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 = true;
                        *symp = sym->s_next;
                        if (hte->h_lsym == &sym->s_next)
                                hte->h_lsym = symp;
                        sym->s_next = NULL;
                        *nhte->h_lsym = sym;
                        nhte->h_lsym = &sym->s_next;
                } else {
                        symp = &sym->s_next;
                }
        }
        for (callp = &hte->h_calls; (call = *callp) != NULL; ) {
                if (call->f_pos.p_src == sym1->s_pos.p_src) {
                        *callp = call->f_next;
                        if (hte->h_lcall == &call->f_next)
                                hte->h_lcall = callp;
                        call->f_next = NULL;
                        *nhte->h_lcall = call;
                        nhte->h_lcall = &call->f_next;
                } else {
                        callp = &call->f_next;
                }
        }
        for (usymp = &hte->h_usyms; (usym = *usymp) != NULL; ) {
                if (usym->u_pos.p_src == sym1->s_pos.p_src) {
                        *usymp = usym->u_next;
                        if (hte->h_lusym == &usym->u_next)
                                hte->h_lusym = usymp;
                        usym->u_next = NULL;
                        *nhte->h_lusym = usym;
                        nhte->h_lusym = &usym->u_next;
                } else {
                        usymp = &usym->u_next;
                }
        }

        /* h_def must be recalculated for old hte */
        hte->h_def = nhte->h_def = false;
        for (sym = hte->h_syms; sym != NULL; sym = sym->s_next) {
                if (sym->s_def == DEF || sym->s_def == TDEF) {
                        hte->h_def = true;
                        break;
                }
        }

        mkstatic(hte);
}