usr.bin/xlint/lint2/read.c

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