usr.bin/xlint/lint1/lint1.h

   1 /* $NetBSD: lint1.h,v 1.12 2002/01/31 19:33:27 tv Exp $ */
   2
   3 /*
   4  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
   5  * Copyright (c) 1994, 1995 Jochen Pohl
   6  * All Rights Reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by Jochen Pohl for
  19  *      The NetBSD Project.
  20  * 4. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include "lint.h"
  38 #include "op.h"
  39
  40 /* XXX - works for most systems, but the whole ALIGN thing needs to go away */
  41 #ifndef LINT_ALIGN
  42 #define LINT_ALIGN(x) (((x) + 15) & ~15)
  43 #endif
  44
  45 /*
  46  * Describes the position of a declaration or anything else.
  47  */
  48 typedef struct {
  49         int     p_line;
  50         const   char *p_file;
  51         int     p_uniq;                 /* uniquifier */
  52 } pos_t;
  53
  54 /* Copies curr_pos, keeping things unique. */
  55 #define UNIQUE_CURR_POS(pos)                                            \
  56     do {                                                                \
  57         STRUCT_ASSIGN((pos), curr_pos);                                 \
  58         curr_pos.p_uniq++;                                              \
  59         if (curr_pos.p_file == csrc_pos.p_file)                         \
  60             csrc_pos.p_uniq++;                                          \
  61     } while (0)
  62
  63 /*
  64  * Strings cannot be referenced to simply by a pointer to its first
  65  * char. This is because strings can contain NUL characters other than the
  66  * trailing NUL.
  67  *
  68  * Strings are stored with a trailing NUL.
  69  */
  70 typedef struct strg {
  71         tspec_t st_tspec;               /* CHAR or WCHAR */
  72         size_t  st_len;                 /* length without trailing NUL */
  73         union {
  74                 u_char  *_st_cp;
  75                 wchar_t *_st_wcp;
  76         } st_u;
  77 } strg_t;
  78
  79 #define st_cp   st_u._st_cp
  80 #define st_wcp  st_u._st_wcp
  81
  82 /*
  83  * qualifiers (only for lex/yacc interface)
  84  */
  85 typedef enum {
  86         CONST, VOLATILE
  87 } tqual_t;
  88
  89 /*
  90  * Integer and floating point values are stored in this structure
  91  */
  92 typedef struct {
  93         tspec_t v_tspec;
  94         int     v_ansiu;                /* set if an integer constant is
  95                                            unsigned in ANSI C */
  96         union {
  97                 int64_t _v_quad;        /* integers */
  98                 ldbl_t  _v_ldbl;        /* floats */
  99         } v_u;
 100 } val_t;
 101
 102 #define v_quad  v_u._v_quad
 103 #define v_ldbl  v_u._v_ldbl
 104
 105 /*
 106  * Structures of type str_t uniqely identify structures. This can't
 107  * be done in structures of type type_t, because these are copied
 108  * if they must be modified. So it would not be possible to check
 109  * if to structures are identical by comparing the pointers to
 110  * the type structures.
 111  *
 112  * The typename is used if the structure is unnamed to identify
 113  * the structure type in pass 2.
 114  */
 115 typedef struct {
 116         u_int   size;           /* size in bit */
 117         u_int   align : 15;     /* alignment in bit */
 118         u_int   sincompl : 1;   /* set if incomplete type */
 119         struct  sym *memb;      /* list of members */
 120         struct  sym *stag;      /* symbol table entry of tag */
 121         struct  sym *stdef;     /* symbol table entry of first typename */
 122 } str_t;
 123
 124 /*
 125  * same as above for enums
 126  */
 127 typedef struct {
 128         u_int   eincompl : 1;   /* incomplete enum type */
 129         struct  sym *elem;      /* list of enumerators */
 130         struct  sym *etag;      /* symbol table entry of tag */
 131         struct  sym *etdef;     /* symbol table entry of first typename */
 132 } enum_t;
 133
 134 /*
 135  * Types are represented by concatenation of structures of type type_t
 136  * via t_subt.
 137  */
 138 typedef struct type {
 139         tspec_t t_tspec;        /* type specifier */
 140         u_int   t_aincompl : 1; /* incomplete array type */
 141         u_int   t_const : 1;    /* const modifier */
 142         u_int   t_volatile : 1; /* volatile modifier */
 143         u_int   t_proto : 1;    /* function prototype (t_args valid) */
 144         u_int   t_vararg : 1;   /* protoype with ... */
 145         u_int   t_typedef : 1;  /* type defined with typedef */
 146         u_int   t_isfield : 1;  /* type is bitfield */
 147         u_int   t_isenum : 1;   /* type is (or was) enum (t_enum valid) */
 148         union {
 149                 int     _t_dim;         /* dimension */
 150                 str_t   *_t_str;        /* struct/union tag */
 151                 enum_t  *_t_enum;       /* enum tag */
 152                 struct  sym *_t_args;   /* arguments (if t_proto) */
 153         } t_u;
 154         struct {
 155                 u_int   _t_flen : 8;    /* length of bit-field */
 156                 u_int   _t_foffs : 24;  /* offset of bit-field */
 157         } t_b;
 158         struct  type *t_subt;   /* element type (arrays), return value
 159                                    (functions), or type pointer points to */
 160 } type_t;
 161
 162 #define t_dim   t_u._t_dim
 163 #define t_str   t_u._t_str
 164 #define t_field t_u._t_field
 165 #define t_enum  t_u._t_enum
 166 #define t_args  t_u._t_args
 167 #define t_flen  t_b._t_flen
 168 #define t_foffs t_b._t_foffs
 169
 170 /*
 171  * types of symbols
 172  */
 173 typedef enum {
 174         FVFT,           /* variables, functions, type names, enums */
 175         FMOS,           /* members of structs or unions */
 176         FTAG,           /* tags */
 177         FLAB            /* labels */
 178 } symt_t;
 179
 180 /*
 181  * storage classes
 182  */
 183 typedef enum {
 184         NOSCL,
 185         EXTERN,         /* external symbols (indep. of decl_t) */
 186         STATIC,         /* static symbols (local and global) */
 187         AUTO,           /* automatic symbols (except register) */
 188         REG,            /* register */
 189         TYPEDEF,        /* typedef */
 190         STRTAG,
 191         UNIONTAG,
 192         ENUMTAG,
 193         MOS,            /* member of struct */
 194         MOU,            /* member of union */
 195         ENUMCON,        /* enumerator */
 196         ABSTRACT,       /* abstract symbol (sizeof, casts, unnamed argument) */
 197         ARG,            /* argument */
 198         PARG,           /* used in declaration stack during prototype
 199                            declaration */
 200         INLINE          /* only used by the parser */
 201 } scl_t;
 202
 203 /*
 204  * symbol table entry
 205  */
 206 typedef struct sym {
 207         const   char *s_name;   /* name */
 208         const   char *s_rename; /* renamed symbol's given name */
 209         pos_t   s_dpos;         /* position of last (prototype)definition,
 210                                    prototypedeclaration, no-prototype-def.,
 211                                    tentative definition or declaration,
 212                                    in this order */
 213         pos_t   s_spos;         /* position of first initialisation */
 214         pos_t   s_upos;         /* position of first use */
 215         symt_t  s_kind;         /* type of symbol */
 216         u_int   s_keyw : 1;     /* keyword */
 217         u_int   s_field : 1;    /* bit-field */
 218         u_int   s_set : 1;      /* variable set, label defined */
 219         u_int   s_used : 1;     /* variable/label used */
 220         u_int   s_arg : 1;      /* symbol is function argument */
 221         u_int   s_reg : 1;      /* symbol is register variable */
 222         u_int   s_defarg : 1;   /* undefined symbol in old style function
 223                                    definition */
 224         u_int   s_rimpl : 1;    /* return value of function implizit decl. */
 225         u_int   s_osdef : 1;    /* symbol stems from old style function def. */
 226         u_int   s_inline : 1;   /* true if this is an inline function */
 227         struct  sym *s_xsym;    /* for local declared external symbols pointer
 228                                    to external symbol with same name */
 229         def_t   s_def;          /* declared, tentative defined, defined */
 230         scl_t   s_scl;          /* storage class */
 231         int     s_blklev;       /* level of declaration, -1 if not in symbol
 232                                    table */
 233         type_t  *s_type;        /* type */
 234         val_t   s_value;        /* value (if enumcon) */
 235         union {
 236                 str_t   *_s_st; /* tag, if it is a struct/union member */
 237                 enum_t  *_s_et; /* tag, if it is an enumerator */
 238                 tspec_t _s_tsp; /* type (only for keywords) */
 239                 tqual_t _s_tqu; /* qualifier (only for keywords) */
 240                 struct  sym *_s_args; /* arguments in old style function
 241                                          definitions */
 242         } u;
 243         struct  sym *s_link;    /* next symbol with same hash value */
 244         struct  sym **s_rlink;  /* pointer to s_link of prev. symbol */
 245         struct  sym *s_nxt;     /* next struct/union member, enumerator,
 246                                    argument */
 247         struct  sym *s_dlnxt;   /* next symbol declared on same level */
 248 } sym_t;
 249
 250 #define s_styp  u._s_st
 251 #define s_etyp  u._s_et
 252 #define s_tspec u._s_tsp
 253 #define s_tqual u._s_tqu
 254 #define s_args  u._s_args
 255
 256 /*
 257  * Used to keep some informations about symbols before they are entered
 258  * into the symbol table.
 259  */
 260 typedef struct sbuf {
 261         const   char *sb_name;          /* name of symbol */
 262         size_t  sb_len;                 /* length (without '\0') */
 263         int     sb_hash;                /* hash value */
 264         sym_t   *sb_sym;                /* symbol table entry */
 265         struct  sbuf *sb_nxt;           /* for freelist */
 266 } sbuf_t;
 267
 268
 269 /*
 270  * tree node
 271  */
 272 typedef struct tnode {
 273         op_t    tn_op;          /* operator */
 274         type_t  *tn_type;       /* type */
 275         u_int   tn_lvalue : 1;  /* node is lvalue */
 276         u_int   tn_cast : 1;    /* if tn_op == CVT its an explizit cast */
 277         u_int   tn_parn : 1;    /* node parenthesized */
 278         union {
 279                 struct {
 280                         struct  tnode *_tn_left;        /* (left) operand */
 281                         struct  tnode *_tn_right;       /* right operand */
 282                 } tn_s;
 283                 sym_t   *_tn_sym;       /* symbol if op == NAME */
 284                 val_t   *_tn_val;       /* value if op == CON */
 285                 strg_t  *_tn_strg;      /* string if op == STRING */
 286         } tn_u;
 287 } tnode_t;
 288
 289 #define tn_left tn_u.tn_s._tn_left
 290 #define tn_right tn_u.tn_s._tn_right
 291 #define tn_sym  tn_u._tn_sym
 292 #define tn_val  tn_u._tn_val
 293 #define tn_strg tn_u._tn_strg
 294
 295 /*
 296  * For nested declarations a stack exists, which holds all information
 297  * needed for the current level. dcs points to the top element of this
 298  * stack.
 299  *
 300  * ctx describes the context of the current declaration. Its value is
 301  * one of
 302  *      EXTERN  global declarations
 303  *      MOS oder MOU declarations of struct or union members
 304  *      ENUMCON declarations of enums
 305  *      ARG     declaration of arguments in old style function definitions
 306  *      PARG    declaration of arguments in function prototypes
 307  *      AUTO    declaration of local symbols
 308  *      ABSTRACT abstract declarations (sizeof, casts)
 309  *
 310  */
 311 typedef struct dinfo {
 312         tspec_t d_atyp;         /* VOID, CHAR, INT, FLOAT or DOUBLE */
 313         tspec_t d_smod;         /* SIGNED or UNSIGN */
 314         tspec_t d_lmod;         /* SHORT, LONG or QUAD */
 315         scl_t   d_scl;          /* storage class */
 316         type_t  *d_type;        /* after deftyp() pointer to the type used
 317                                    for all declarators */
 318         sym_t   *d_rdcsym;      /* redeclared symbol */
 319         int     d_offset;       /* offset of next structure member */
 320         int     d_stralign;     /* alignment required for current structure */
 321         scl_t   d_ctx;          /* context of declaration */
 322         u_int   d_const : 1;    /* const in declaration specifiers */
 323         u_int   d_volatile : 1; /* volatile in declaration specifiers */
 324         u_int   d_inline : 1;   /* inline in declaration specifiers */
 325         u_int   d_mscl : 1;     /* multiple storage classes */
 326         u_int   d_terr : 1;     /* invalid type combination */
 327         u_int   d_nedecl : 1;   /* 1 if at least a tag is declared */
 328         u_int   d_vararg : 1;   /* ... in current function decl. */
 329         u_int   d_proto : 1;    /* current funct. decl. is prototype */
 330         u_int   d_notyp : 1;    /* set if no type specifier was present */
 331         u_int   d_asm : 1;      /* set if d_ctx == AUTO and asm() present */
 332         type_t  *d_tagtyp;      /* tag during member declaration */
 333         sym_t   *d_fargs;       /* list of arguments during function def. */
 334         pos_t   d_fdpos;        /* position of function definition */
 335         sym_t   *d_dlsyms;      /* first symbol declared at this level */
 336         sym_t   **d_ldlsym;     /* points to s_dlnxt in last symbol decl.
 337                                    at this level */
 338         sym_t   *d_fpsyms;      /* symbols defined in prototype */
 339         struct  dinfo *d_nxt;   /* next level */
 340 } dinfo_t;
 341
 342 /*
 343  * Type of stack which is used for initialisation of aggregate types.
 344  */
 345 typedef struct  istk {
 346         type_t  *i_type;                /* type of initialisation */
 347         type_t  *i_subt;                /* type of next level */
 348         u_int   i_brace : 1;            /* need } for pop */
 349         u_int   i_nolimit : 1;          /* incomplete array type */
 350         sym_t   *i_mem;                 /* next structure member */
 351         int     i_cnt;                  /* # of remaining elements */
 352         struct  istk *i_nxt;            /* previous level */
 353 } istk_t;
 354
 355 /*
 356  * Used to collect information about pointers and qualifiers in
 357  * declarators.
 358  */
 359 typedef struct pqinf {
 360         int     p_pcnt;                 /* number of asterisks */
 361         u_int   p_const : 1;
 362         u_int   p_volatile : 1;
 363         struct  pqinf *p_nxt;
 364 } pqinf_t;
 365
 366 /*
 367  * Case values are stored in a list of type clst_t.
 368  */
 369 typedef struct clst {
 370         val_t   cl_val;
 371         struct  clst *cl_nxt;
 372 } clst_t;
 373
 374 /*
 375  * Used to keep informations about nested control statements.
 376  */
 377 typedef struct cstk {
 378         int     c_env;                  /* type of statement (T_IF, ...) */
 379         u_int   c_loop : 1;             /* continue && break are valid */
 380         u_int   c_switch : 1;           /* case && break are valid */
 381         u_int   c_break : 1;            /* loop/switch has break */
 382         u_int   c_cont : 1;             /* loop has continue */
 383         u_int   c_default : 1;          /* switch has default */
 384         u_int   c_infinite : 1;         /* break condition always false
 385                                            (for (;;), while (1)) */
 386         u_int   c_rchif : 1;            /* end of if-branch reached */
 387         u_int   c_noretval : 1;         /* had "return;" */
 388         u_int   c_retval : 1;           /* had "return (e);" */
 389         type_t  *c_swtype;              /* type of switch expression */
 390         clst_t  *c_clst;                /* list of case values */
 391         struct  mbl *c_fexprm;          /* saved memory for end of loop
 392                                            expression in for() */
 393         tnode_t *c_f3expr;              /* end of loop expr in for() */
 394         pos_t   c_fpos;                 /* position of end of loop expr */
 395         pos_t   c_cfpos;                /* same for csrc_pos */
 396         struct  cstk *c_nxt;            /* outer control statement */
 397 } cstk_t;
 398
 399 #include "externs1.h"
 400
 401 #define ERR_SETSIZE     1024
 402 #define __NERRBITS (sizeof(unsigned int))
 403
 404 typedef struct err_set {
 405         unsigned int    errs_bits[(ERR_SETSIZE + __NERRBITS-1) / __NERRBITS];
 406 } err_set;
 407
 408 #define ERR_SET(n, p)   \
 409     ((p)->errs_bits[(n)/__NERRBITS] |= (1 << ((n) % __NERRBITS)))
 410 #define ERR_CLR(n, p)   \
 411     ((p)->errs_bits[(n)/__NERRBITS] &= ~(1 << ((n) % __NERRBITS)))
 412 #define ERR_ISSET(n, p) \
 413     ((p)->errs_bits[(n)/__NERRBITS] & (1 << ((n) % __NERRBITS)))
 414 #define ERR_ZERO(p)     (void)memset((p), 0, sizeof(*(p)))
 415
 416 extern err_set  msgset;