#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD");
#endif
#include <sys/param.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include "lint1.h"
const char *unnamed = "<unnamed>";
ttab_t ttab[NTSPEC];
static type_t *typetab;
int enumval;
dinfo_t *dcs;
static type_t *tdeferr __P((type_t *, tspec_t));
static void settdsym __P((type_t *, sym_t *));
static tspec_t mrgtspec __P((tspec_t, tspec_t));
static void align __P((int, int));
static sym_t *newtag __P((sym_t *, scl_t, int, int));
static int eqargs __P((type_t *, type_t *, int *));
static int mnoarg __P((type_t *, int *));
static int chkosdef __P((sym_t *, sym_t *));
static int chkptdecl __P((sym_t *, sym_t *));
static sym_t *nsfunc __P((sym_t *, sym_t *));
static void osfunc __P((sym_t *, sym_t *));
static void ledecl __P((sym_t *));
static int chkinit __P((sym_t *));
static void chkausg __P((int, sym_t *));
static void chkvusg __P((int, sym_t *));
static void chklusg __P((sym_t *));
static void chktusg __P((sym_t *));
static void chkglvar __P((sym_t *));
static void glchksz __P((sym_t *));
void
initdecl()
{
int i;
static struct {
tspec_t it_tspec;
ttab_t it_ttab;
} ittab[] = {
{ SIGNED, { 0, 0,
SIGNED, UNSIGN,
0, 0, 0, 0, 0, "signed" } },
{ UNSIGN, { 0, 0,
SIGNED, UNSIGN,
0, 0, 0, 0, 0, "unsigned" } },
{ CHAR, { CHAR_BIT, CHAR_BIT,
SCHAR, UCHAR,
1, 0, 0, 1, 1, "char" } },
{ SCHAR, { CHAR_BIT, CHAR_BIT,
SCHAR, UCHAR,
1, 0, 0, 1, 1, "signed char" } },
{ UCHAR, { CHAR_BIT, CHAR_BIT,
SCHAR, UCHAR,
1, 1, 0, 1, 1, "unsigned char" } },
{ SHORT, { sizeof (short) * CHAR_BIT, 2 * CHAR_BIT,
SHORT, USHORT,
1, 0, 0, 1, 1, "short" } },
{ USHORT, { sizeof (u_short) * CHAR_BIT, 2 * CHAR_BIT,
SHORT, USHORT,
1, 1, 0, 1, 1, "unsigned short" } },
{ INT, { sizeof (int) * CHAR_BIT, 3 * CHAR_BIT,
INT, UINT,
1, 0, 0, 1, 1, "int" } },
{ UINT, { sizeof (u_int) * CHAR_BIT, 3 * CHAR_BIT,
INT, UINT,
1, 1, 0, 1, 1, "unsigned int" } },
{ LONG, { sizeof (long) * CHAR_BIT, 4 * CHAR_BIT,
LONG, ULONG,
1, 0, 0, 1, 1, "long" } },
{ ULONG, { sizeof (u_long) * CHAR_BIT, 4 * CHAR_BIT,
LONG, ULONG,
1, 1, 0, 1, 1, "unsigned long" } },
{ QUAD, { sizeof (quad_t) * CHAR_BIT, 8 * CHAR_BIT,
QUAD, UQUAD,
1, 0, 0, 1, 1, "long long" } },
{ UQUAD, { sizeof (u_quad_t) * CHAR_BIT, 8 * CHAR_BIT,
QUAD, UQUAD,
1, 1, 0, 1, 1, "unsigned long long" } },
{ FLOAT, { sizeof (float) * CHAR_BIT, 4 * CHAR_BIT,
FLOAT, FLOAT,
0, 0, 1, 1, 1, "float" } },
{ DOUBLE, { sizeof (double) * CHAR_BIT, 8 * CHAR_BIT,
DOUBLE, DOUBLE,
0, 0, 1, 1, 1, "double" } },
{ LDOUBLE, { sizeof (ldbl_t) * CHAR_BIT, 10 * CHAR_BIT,
LDOUBLE, LDOUBLE,
0, 0, 1, 1, 1, "long double" } },
{ VOID, { -1, -1,
VOID, VOID,
0, 0, 0, 0, 0, "void" } },
{ STRUCT, { -1, -1,
STRUCT, STRUCT,
0, 0, 0, 0, 0, "struct" } },
{ UNION, { -1, -1,
UNION, UNION,
0, 0, 0, 0, 0, "union" } },
{ ENUM, { sizeof (int) * CHAR_BIT, 3 * CHAR_BIT,
ENUM, ENUM,
1, 0, 0, 1, 1, "enum" } },
{ PTR, { sizeof (void *) * CHAR_BIT, 4 * CHAR_BIT,
PTR, PTR,
0, 1, 0, 0, 1, "pointer" } },
{ ARRAY, { -1, -1,
ARRAY, ARRAY,
0, 0, 0, 0, 0, "array" } },
{ FUNC, { -1, -1,
FUNC, FUNC,
0, 0, 0, 0, 0, "function" } },
};
dcs = xcalloc(1, sizeof (dinfo_t));
dcs->d_ctx = EXTERN;
dcs->d_ldlsym = &dcs->d_dlsyms;
for (i = 0; i < sizeof (ittab) / sizeof (ittab[0]); i++)
STRUCT_ASSIGN(ttab[ittab[i].it_tspec], ittab[i].it_ttab);
if (!pflag) {
for (i = 0; i < NTSPEC; i++)
ttab[i].tt_psz = ttab[i].tt_sz;
}
typetab = xcalloc(NTSPEC, sizeof (type_t));
for (i = 0; i < NTSPEC; i++)
typetab[i].t_tspec = NOTSPEC;
typetab[CHAR].t_tspec = CHAR;
typetab[SCHAR].t_tspec = SCHAR;
typetab[UCHAR].t_tspec = UCHAR;
typetab[SHORT].t_tspec = SHORT;
typetab[USHORT].t_tspec = USHORT;
typetab[INT].t_tspec = INT;
typetab[UINT].t_tspec = UINT;
typetab[LONG].t_tspec = LONG;
typetab[ULONG].t_tspec = ULONG;
typetab[QUAD].t_tspec = QUAD;
typetab[UQUAD].t_tspec = UQUAD;
typetab[FLOAT].t_tspec = FLOAT;
typetab[DOUBLE].t_tspec = DOUBLE;
typetab[LDOUBLE].t_tspec = LDOUBLE;
typetab[VOID].t_tspec = VOID;
typetab[SIGNED].t_tspec = SIGNED;
typetab[UNSIGN].t_tspec = UNSIGN;
}
type_t *
gettyp(t)
tspec_t t;
{
return (&typetab[t]);
}
type_t *
duptyp(tp)
const type_t *tp;
{
type_t *ntp;
ntp = getblk(sizeof (type_t));
STRUCT_ASSIGN(*ntp, *tp);
return (ntp);
}
type_t *
tduptyp(tp)
const type_t *tp;
{
type_t *ntp;
ntp = tgetblk(sizeof (type_t));
STRUCT_ASSIGN(*ntp, *tp);
return (ntp);
}
int
incompl(tp)
type_t *tp;
{
tspec_t t;
if ((t = tp->t_tspec) == VOID) {
return (1);
} else if (t == ARRAY) {
return (tp->t_aincompl);
} else if (t == STRUCT || t == UNION) {
return (tp->t_str->sincompl);
} else if (t == ENUM) {
return (tp->t_enum->eincompl);
}
return (0);
}
void
setcompl(tp, ic)
type_t *tp;
int ic;
{
tspec_t t;
if ((t = tp->t_tspec) == ARRAY) {
tp->t_aincompl = ic;
} else if (t == STRUCT || t == UNION) {
tp->t_str->sincompl = ic;
} else {
if (t != ENUM)
lerror("setcompl() 1");
tp->t_enum->eincompl = ic;
}
}
void
addscl(sc)
scl_t sc;
{
if (sc == INLINE) {
if (dcs->d_inline)
warning(10, "inline");
dcs->d_inline = 1;
return;
}
if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
dcs->d_smod != NOTSPEC || dcs->d_lmod != NOTSPEC) {
warning(83);
}
if (dcs->d_scl == NOSCL) {
dcs->d_scl = sc;
} else {
dcs->d_mscl = 1;
}
}
void
addtype(tp)
type_t *tp;
{
tspec_t t;
if (tp->t_typedef) {
if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
lerror("addtype()");
}
dcs->d_type = tp;
return;
}
t = tp->t_tspec;
if (t == STRUCT || t == UNION || t == ENUM) {
if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
dcs->d_terr = 1;
dcs->d_atyp = dcs->d_lmod = dcs->d_smod = NOTSPEC;
}
dcs->d_type = tp;
return;
}
if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
dcs->d_terr = 1;
return;
}
if (t == LONG && dcs->d_lmod == LONG) {
t = QUAD;
dcs->d_lmod = NOTSPEC;
if (!quadflg)
(void)gnuism(265, tflag ? "traditional" : "ANSI");
}
if (dcs->d_type != NULL && dcs->d_type->t_typedef) {
dcs->d_type = tdeferr(dcs->d_type, t);
return;
}
if (t == SIGNED || t == UNSIGN) {
if (dcs->d_smod != NOTSPEC)
dcs->d_terr = 1;
dcs->d_smod = t;
} else if (t == SHORT || t == LONG || t == QUAD) {
if (dcs->d_lmod != NOTSPEC)
dcs->d_terr = 1;
dcs->d_lmod = t;
} else {
if (dcs->d_atyp != NOTSPEC)
dcs->d_terr = 1;
dcs->d_atyp = t;
}
}
static type_t *
tdeferr(td, t)
type_t *td;
tspec_t t;
{
tspec_t t2;
t2 = td->t_tspec;
switch (t) {
case SIGNED:
case UNSIGN:
if (t2 == CHAR || t2 == SHORT || t2 == INT || t2 == LONG ||
t2 == QUAD) {
if (!tflag)
warning(5, ttab[t].tt_name);
td = duptyp(gettyp(mrgtspec(t2, t)));
td->t_typedef = 1;
return (td);
}
break;
case SHORT:
if (t2 == INT || t2 == UINT) {
warning(5, "short");
td = duptyp(gettyp(t2 == INT ? SHORT : USHORT));
td->t_typedef = 1;
return (td);
}
break;
case LONG:
if (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
t2 == FLOAT || t2 == DOUBLE) {
warning(5, "long");
if (t2 == INT) {
td = gettyp(LONG);
} else if (t2 == UINT) {
td = gettyp(ULONG);
} else if (t2 == LONG) {
td = gettyp(QUAD);
} else if (t2 == ULONG) {
td = gettyp(UQUAD);
} else if (t2 == FLOAT) {
td = gettyp(DOUBLE);
} else if (t2 == DOUBLE) {
td = gettyp(LDOUBLE);
}
td = duptyp(td);
td->t_typedef = 1;
return (td);
}
break;
case NOTSPEC:
case USHORT:
case UCHAR:
case SCHAR:
case CHAR:
case FUNC:
case ARRAY:
case PTR:
case ENUM:
case UNION:
case STRUCT:
case VOID:
case LDOUBLE:
case DOUBLE:
case FLOAT:
case UQUAD:
case QUAD:
case ULONG:
case UINT:
case INT:
break;
}
dcs->d_terr = 1;
return (td);
}
static void
settdsym(tp, sym)
type_t *tp;
sym_t *sym;
{
tspec_t t;
if ((t = tp->t_tspec) == STRUCT || t == UNION) {
if (tp->t_str->stdef == NULL)
tp->t_str->stdef = sym;
} else if (t == ENUM) {
if (tp->t_enum->etdef == NULL)
tp->t_enum->etdef = sym;
}
}
void
addqual(q)
tqual_t q;
{
if (q == CONST) {
if (dcs->d_const) {
warning(10, "const");
}
dcs->d_const = 1;
} else {
if (q != VOLATILE)
lerror("addqual() 1");
if (dcs->d_volatile) {
warning(10, "volatile");
}
dcs->d_volatile = 1;
}
}
void
pushdecl(sc)
scl_t sc;
{
dinfo_t *di;
if (dflag)
(void)printf("pushdecl(%d)\n", (int)sc);
di = xcalloc(1, sizeof (dinfo_t));
di->d_nxt = dcs;
dcs = di;
di->d_ctx = sc;
di->d_ldlsym = &di->d_dlsyms;
}
void
popdecl()
{
dinfo_t *di;
if (dflag)
(void)printf("popdecl(%d)\n", (int)dcs->d_ctx);
if (dcs->d_nxt == NULL)
lerror("popdecl() 1");
di = dcs;
dcs = di->d_nxt;
switch (di->d_ctx) {
case EXTERN:
lerror("popdecl() 2");
case MOS:
case MOU:
case ENUMCON:
if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
dcs->d_ldlsym = di->d_ldlsym;
break;
case ARG:
if (di->d_dlsyms != NULL) {
*di->d_ldlsym = dcs->d_fpsyms;
dcs->d_fpsyms = di->d_dlsyms;
}
break;
case ABSTRACT:
if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
dcs->d_ldlsym = di->d_ldlsym;
break;
case AUTO:
chkusage(di);
case PARG:
rmsyms(di->d_dlsyms);
break;
default:
lerror("popdecl() 3");
}
free(di);
}
void
setasm()
{
dinfo_t *di;
for (di = dcs; di != NULL; di = di->d_nxt)
di->d_asm = 1;
}
void
clrtyp()
{
dcs->d_atyp = dcs->d_smod = dcs->d_lmod = NOTSPEC;
dcs->d_scl = NOSCL;
dcs->d_type = NULL;
dcs->d_const = dcs->d_volatile = 0;
dcs->d_inline = 0;
dcs->d_mscl = dcs->d_terr = 0;
dcs->d_nedecl = 0;
dcs->d_notyp = 0;
}
void
deftyp()
{
tspec_t t, s, l;
type_t *tp;
scl_t scl;
t = dcs->d_atyp;
s = dcs->d_smod;
l = dcs->d_lmod;
tp = dcs->d_type;
scl = dcs->d_scl;
if (t == NOTSPEC && s == NOTSPEC && l == NOTSPEC && tp == NULL)
dcs->d_notyp = 1;
if (tp != NULL && (t != NOTSPEC || s != NOTSPEC || l != NOTSPEC)) {
lerror("deftyp() 1");
}
if (tp == NULL) {
switch (t) {
case NOTSPEC:
t = INT;
case INT:
if (s == NOTSPEC)
s = SIGNED;
break;
case CHAR:
if (l != NOTSPEC) {
dcs->d_terr = 1;
l = NOTSPEC;
}
break;
case FLOAT:
if (l == LONG) {
l = NOTSPEC;
t = DOUBLE;
if (!tflag)
warning(6);
}
break;
case DOUBLE:
if (l == LONG) {
l = NOTSPEC;
t = LDOUBLE;
if (tflag)
warning(266);
}
break;
case VOID:
break;
default:
lerror("deftyp() 2");
}
if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
dcs->d_terr = 1;
l = s = NOTSPEC;
}
if (l != NOTSPEC)
t = l;
dcs->d_type = gettyp(mrgtspec(t, s));
}
if (dcs->d_mscl) {
error(7);
}
if (dcs->d_terr) {
error(4);
}
if (dcs->d_ctx == EXTERN) {
if (scl == REG || scl == AUTO) {
error(8);
scl = NOSCL;
}
} else if (dcs->d_ctx == ARG || dcs->d_ctx == PARG) {
if (scl != NOSCL && scl != REG) {
error(9);
scl = NOSCL;
}
}
dcs->d_scl = scl;
if (dcs->d_const && dcs->d_type->t_const) {
if (!dcs->d_type->t_typedef)
lerror("deftyp() 3");
warning(68, "const");
}
if (dcs->d_volatile && dcs->d_type->t_volatile) {
if (!dcs->d_type->t_typedef)
lerror("deftyp() 4");
warning(68, "volatile");
}
if (dcs->d_const || dcs->d_volatile) {
dcs->d_type = duptyp(dcs->d_type);
dcs->d_type->t_const |= dcs->d_const;
dcs->d_type->t_volatile |= dcs->d_volatile;
}
}
static tspec_t
mrgtspec(t, s)
tspec_t t, s;
{
if (s == SIGNED || s == UNSIGN) {
if (t == CHAR) {
t = s == SIGNED ? SCHAR : UCHAR;
} else if (t == SHORT) {
t = s == SIGNED ? SHORT : USHORT;
} else if (t == INT) {
t = s == SIGNED ? INT : UINT;
} else if (t == LONG) {
t = s == SIGNED ? LONG : ULONG;
} else if (t == QUAD) {
t = s == SIGNED ? QUAD : UQUAD;
}
}
return (t);
}
int
length(tp, name)
type_t *tp;
const char *name;
{
int elem, elsz;
elem = 1;
while (tp->t_tspec == ARRAY) {
elem *= tp->t_dim;
tp = tp->t_subt;
}
switch (tp->t_tspec) {
case FUNC:
lerror(msgs[12]);
case STRUCT:
case UNION:
if (incompl(tp) && name != NULL) {
error(31, tp->t_str->stag->s_name, name);
}
elsz = tp->t_str->size;
break;
case ENUM:
if (incompl(tp) && name != NULL) {
warning(13, name);
}
default:
elsz = size(tp->t_tspec);
if (elsz <= 0)
lerror("length()");
break;
}
return (elem * elsz);
}
int
getbound(tp)
type_t *tp;
{
int a;
tspec_t t;
while (tp->t_tspec == ARRAY)
tp = tp->t_subt;
if ((t = tp->t_tspec) == STRUCT || t == UNION) {
a = tp->t_str->align;
} else if (t == FUNC) {
error(14);
a = ALIGN(1) * CHAR_BIT;
} else {
if ((a = size(t)) == 0) {
a = CHAR_BIT;
} else if (a > ALIGN(1) * CHAR_BIT) {
a = ALIGN(1) * CHAR_BIT;
}
}
if (a < CHAR_BIT || a > ALIGN(1) * CHAR_BIT)
lerror("getbound() 1");
return (a);
}
sym_t *
lnklst(l1, l2)
sym_t *l1, *l2;
{
sym_t *l;
if ((l = l1) == NULL)
return (l2);
while (l1->s_nxt != NULL)
l1 = l1->s_nxt;
l1->s_nxt = l2;
return (l);
}
void
chktyp(sym)
sym_t *sym;
{
tspec_t to, t;
type_t **tpp, *tp;
tpp = &sym->s_type;
to = NOTSPEC;
while ((tp = *tpp) != NULL) {
t = tp->t_tspec;
if (t == FUNC && !tp->t_proto &&
!(to == NOTSPEC && sym->s_osdef)) {
if (sflag && hflag)
warning(287);
}
if (to == FUNC) {
if (t == FUNC || t == ARRAY) {
error(15);
if (t == FUNC) {
*tpp = incref(*tpp, PTR);
} else {
*tpp = incref((*tpp)->t_subt, PTR);
}
return;
} else if (tp->t_const || tp->t_volatile) {
if (sflag) {
warning(228);
}
}
} if (to == ARRAY) {
if (t == FUNC) {
error(16);
*tpp = gettyp(INT);
return;
} else if (t == ARRAY && tp->t_dim == 0) {
error(17);
return;
} else if (t == VOID) {
error(18);
*tpp = gettyp(INT);
#if 0
} else if (incompl(tp)) {
if (sflag) {
error(301);
} else {
warning(301);
}
#endif
}
} else if (to == NOTSPEC && t == VOID) {
if (dcs->d_ctx == PARG) {
if (sym->s_scl != ABSTRACT) {
if (sym->s_name == unnamed)
lerror("chktyp()");
error(61, sym->s_name);
*tpp = gettyp(INT);
}
} else if (dcs->d_ctx == ABSTRACT) {
} else if (sym->s_scl != TYPEDEF) {
error(19, sym->s_name);
*tpp = gettyp(INT);
}
}
if (t == VOID && to != PTR) {
if (tp->t_const || tp->t_volatile) {
warning(69);
tp->t_const = tp->t_volatile = 0;
}
}
tpp = &tp->t_subt;
to = t;
}
}
sym_t *
decl1str(dsym)
sym_t *dsym;
{
type_t *tp;
tspec_t t;
int sz, len;
int o = 0;
scl_t sc;
if ((sc = dsym->s_scl) != MOS && sc != MOU)
lerror("decl1str() 1");
if (dcs->d_rdcsym != NULL) {
if ((sc = dcs->d_rdcsym->s_scl) != MOS && sc != MOU)
lerror("decl1str() 2");
if (dsym->s_styp == dcs->d_rdcsym->s_styp) {
error(33, dsym->s_name);
rmsym(dcs->d_rdcsym);
}
}
chktyp(dsym);
t = (tp = dsym->s_type)->t_tspec;
if (dsym->s_field) {
if (t == CHAR || t == UCHAR || t == SCHAR ||
t == SHORT || t == USHORT || t == ENUM) {
if (sflag) {
warning(273, tyname(tp));
} else if (pflag) {
warning(34);
}
} else if (t == INT && dcs->d_smod == NOTSPEC) {
if (pflag) {
warning(34);
}
} else if (t != INT && t != UINT) {
error(35);
sz = tp->t_flen;
dsym->s_type = tp = duptyp(gettyp(t = INT));
if ((tp->t_flen = sz) > size(t))
tp->t_flen = size(t);
}
if ((len = tp->t_flen) < 0 || len > size(t)) {
error(36);
tp->t_flen = size(t);
} else if (len == 0 && dsym->s_name != unnamed) {
error(37);
tp->t_flen = size(t);
}
if (dsym->s_scl == MOU) {
error(41);
dsym->s_type->t_isfield = 0;
dsym->s_field = 0;
}
} else if (t == FUNC) {
error(38);
dsym->s_type = tp = incref(tp, t = PTR);
}
if ((sz = length(dsym->s_type, dsym->s_name)) == 0) {
if (t == ARRAY && dsym->s_type->t_dim == 0) {
warning(39, dsym->s_name);
}
}
if (dcs->d_ctx == MOU) {
o = dcs->d_offset;
dcs->d_offset = 0;
}
if (dsym->s_field) {
align(getbound(tp), tp->t_flen);
dsym->s_value.v_quad = (dcs->d_offset / size(t)) * size(t);
tp->t_foffs = dcs->d_offset - (int)dsym->s_value.v_quad;
dcs->d_offset += tp->t_flen;
} else {
align(getbound(tp), 0);
dsym->s_value.v_quad = dcs->d_offset;
dcs->d_offset += sz;
}
if (dcs->d_ctx == MOU) {
if (o > dcs->d_offset)
dcs->d_offset = o;
}
chkfdef(dsym, 0);
return (dsym);
}
static void
align(al, len)
int al, len;
{
int no;
if (al > dcs->d_stralign)
dcs->d_stralign = al;
no = (dcs->d_offset + (al - 1)) & ~(al - 1);
if (len == 0 || dcs->d_offset + len > no)
dcs->d_offset = no;
}
sym_t *
bitfield(dsym, len)
sym_t *dsym;
int len;
{
if (dsym == NULL) {
dsym = getblk(sizeof (sym_t));
dsym->s_name = unnamed;
dsym->s_kind = FMOS;
dsym->s_scl = MOS;
dsym->s_type = gettyp(INT);
dsym->s_blklev = -1;
}
dsym->s_type = duptyp(dsym->s_type);
dsym->s_type->t_isfield = 1;
dsym->s_type->t_flen = len;
dsym->s_field = 1;
return (dsym);
}
pqinf_t *
mergepq(p1, p2)
pqinf_t *p1, *p2;
{
pqinf_t *p;
if (p2->p_pcnt != 0) {
for (p = p2; p->p_nxt != NULL; p = p->p_nxt) ;
p->p_nxt = p1;
return (p2);
} else {
if (p2->p_const) {
if (p1->p_const) {
warning(10, "const");
}
p1->p_const = 1;
}
if (p2->p_volatile) {
if (p1->p_volatile) {
warning(10, "volatile");
}
p1->p_volatile = 1;
}
free(p2);
return (p1);
}
}
sym_t *
addptr(decl, pi)
sym_t *decl;
pqinf_t *pi;
{
type_t **tpp, *tp;
pqinf_t *npi;
tpp = &decl->s_type;
while (*tpp != dcs->d_type)
tpp = &(*tpp)->t_subt;
while (pi != NULL) {
*tpp = tp = getblk(sizeof (type_t));
tp->t_tspec = PTR;
tp->t_const = pi->p_const;
tp->t_volatile = pi->p_volatile;
*(tpp = &tp->t_subt) = dcs->d_type;
npi = pi->p_nxt;
free(pi);
pi = npi;
}
return (decl);
}
sym_t *
addarray(decl, dim, n)
sym_t *decl;
int dim, n;
{
type_t **tpp, *tp;
tpp = &decl->s_type;
while (*tpp != dcs->d_type)
tpp = &(*tpp)->t_subt;
*tpp = tp = getblk(sizeof (type_t));
tp->t_tspec = ARRAY;
tp->t_subt = dcs->d_type;
tp->t_dim = n;
if (n < 0) {
error(20);
n = 0;
} else if (n == 0 && dim) {
warning(20);
} else if (n == 0 && !dim) {
setcompl(tp, 1);
}
return (decl);
}
sym_t *
addfunc(decl, args)
sym_t *decl, *args;
{
type_t **tpp, *tp;
if (dcs->d_proto) {
if (tflag)
warning(270);
args = nsfunc(decl, args);
} else {
osfunc(decl, args);
}
if (dcs->d_nxt->d_ctx == EXTERN &&
decl->s_type == dcs->d_nxt->d_type) {
dcs->d_nxt->d_fpsyms = dcs->d_dlsyms;
dcs->d_nxt->d_fargs = args;
}
tpp = &decl->s_type;
while (*tpp != dcs->d_nxt->d_type)
tpp = &(*tpp)->t_subt;
*tpp = tp = getblk(sizeof (type_t));
tp->t_tspec = FUNC;
tp->t_subt = dcs->d_nxt->d_type;
if ((tp->t_proto = dcs->d_proto) != 0)
tp->t_args = args;
tp->t_vararg = dcs->d_vararg;
return (decl);
}
static sym_t *
nsfunc(decl, args)
sym_t *decl, *args;
{
sym_t *arg, *sym;
scl_t sc;
int n;
for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
sc = sym->s_scl;
if (sc == STRTAG || sc == UNIONTAG || sc == ENUMTAG) {
warning(85, scltoa(sc), sym->s_name);
}
}
n = 1;
for (arg = args; arg != NULL; arg = arg->s_nxt) {
if (arg->s_type->t_tspec == VOID) {
if (n > 1 || arg->s_nxt != NULL) {
error(60);
arg->s_type = gettyp(INT);
}
}
n++;
}
return (args != NULL && args->s_type->t_tspec != VOID ? args : NULL);
}
static void
osfunc(decl, args)
sym_t *decl, *args;
{
if (dcs->d_nxt->d_ctx == EXTERN &&
decl->s_type == dcs->d_nxt->d_type) {
if (args != NULL) {
decl->s_osdef = 1;
decl->s_args = args;
}
} else {
if (args != NULL)
warning(62);
}
}
void
chkfdef(sym, msg)
sym_t *sym;
int msg;
{
if (sym->s_osdef) {
if (msg) {
error(22);
}
sym->s_osdef = 0;
sym->s_args = NULL;
}
}
sym_t *
dname(sym)
sym_t *sym;
{
scl_t sc = NOSCL;
if (sym->s_scl == NOSCL) {
dcs->d_rdcsym = NULL;
} else if (sym->s_defarg) {
sym->s_defarg = 0;
dcs->d_rdcsym = NULL;
} else {
dcs->d_rdcsym = sym;
sym = pushdown(sym);
}
switch (dcs->d_ctx) {
case MOS:
case MOU:
sym->s_styp = dcs->d_tagtyp->t_str;
sym->s_def = DEF;
sym->s_value.v_tspec = INT;
sc = dcs->d_ctx;
break;
case EXTERN:
if ((sc = dcs->d_scl) == NOSCL) {
sc = EXTERN;
sym->s_def = TDEF;
} else if (sc == STATIC) {
sym->s_def = TDEF;
} else if (sc == TYPEDEF) {
sym->s_def = DEF;
} else if (sc == EXTERN) {
sym->s_def = DECL;
} else {
lerror("dname() 1");
}
break;
case PARG:
sym->s_arg = 1;
case ARG:
if ((sc = dcs->d_scl) == NOSCL) {
sc = AUTO;
} else if (sc == REG) {
sym->s_reg = 1;
sc = AUTO;
} else {
lerror("dname() 2");
}
sym->s_def = DEF;
break;
case AUTO:
if ((sc = dcs->d_scl) == NOSCL) {
sc = AUTO;
sym->s_def = DEF;
} else if (sc == AUTO || sc == STATIC || sc == TYPEDEF) {
sym->s_def = DEF;
} else if (sc == REG) {
sym->s_reg = 1;
sc = AUTO;
sym->s_def = DEF;
} else if (sc == EXTERN) {
sym->s_def = DECL;
} else {
lerror("dname() 3");
}
break;
default:
lerror("dname() 4");
}
sym->s_scl = sc;
sym->s_type = dcs->d_type;
dcs->d_fpsyms = NULL;
return (sym);
}
sym_t *
iname(sym)
sym_t *sym;
{
if (sym->s_scl != NOSCL) {
if (blklev == sym->s_blklev) {
error(21, sym->s_name);
if (!sym->s_defarg)
lerror("iname()");
}
sym = pushdown(sym);
}
sym->s_type = gettyp(INT);
sym->s_scl = AUTO;
sym->s_def = DEF;
sym->s_defarg = sym->s_arg = 1;
return (sym);
}
type_t *
mktag(tag, kind, decl, semi)
sym_t *tag;
tspec_t kind;
int decl, semi;
{
scl_t scl = NOSCL;
type_t *tp;
if (kind == STRUCT) {
scl = STRTAG;
} else if (kind == UNION) {
scl = UNIONTAG;
} else if (kind == ENUM) {
scl = ENUMTAG;
} else {
lerror("mktag()");
}
if (tag != NULL) {
if (tag->s_scl != NOSCL) {
tag = newtag(tag, scl, decl, semi);
} else {
dcs->d_nxt->d_nedecl = 1;
if (scl == ENUMTAG && !decl) {
if (!tflag && (sflag || pflag))
warning(42);
}
}
if (tag->s_scl == NOSCL) {
tag->s_scl = scl;
tag->s_type = tp = getblk(sizeof (type_t));
} else {
tp = tag->s_type;
}
} else {
tag = getblk(sizeof (sym_t));
tag->s_name = unnamed;
UNIQUE_CURR_POS(tag->s_dpos);
tag->s_kind = FTAG;
tag->s_scl = scl;
tag->s_blklev = -1;
tag->s_type = tp = getblk(sizeof (type_t));
dcs->d_nxt->d_nedecl = 1;
}
if (tp->t_tspec == NOTSPEC) {
tp->t_tspec = kind;
if (kind != ENUM) {
tp->t_str = getblk(sizeof (str_t));
tp->t_str->align = CHAR_BIT;
tp->t_str->stag = tag;
} else {
tp->t_isenum = 1;
tp->t_enum = getblk(sizeof (enum_t));
tp->t_enum->etag = tag;
}
setcompl(tp, 1);
}
return (tp);
}
static sym_t *
newtag(tag, scl, decl, semi)
sym_t *tag;
scl_t scl;
int decl, semi;
{
if (tag->s_blklev < blklev) {
if (semi) {
if (!tflag) {
if (!sflag)
warning(44, scltoa(scl), tag->s_name);
tag = pushdown(tag);
} else if (tag->s_scl != scl) {
warning(45, scltoa(tag->s_scl), tag->s_name);
}
dcs->d_nxt->d_nedecl = 1;
} else if (decl) {
if (hflag)
warning(43, tag->s_name);
tag = pushdown(tag);
dcs->d_nxt->d_nedecl = 1;
} else if (tag->s_scl != scl) {
warning(45, scltoa(tag->s_scl), tag->s_name);
if (!sflag)
warning(44, scltoa(scl), tag->s_name);
tag = pushdown(tag);
dcs->d_nxt->d_nedecl = 1;
}
} else {
if (tag->s_scl != scl) {
error(46, scltoa(tag->s_scl));
prevdecl(-1, tag);
tag = pushdown(tag);
dcs->d_nxt->d_nedecl = 1;
} else if (decl && !incompl(tag->s_type)) {
error(46, scltoa(tag->s_scl));
prevdecl(-1, tag);
tag = pushdown(tag);
dcs->d_nxt->d_nedecl = 1;
} else if (semi || decl) {
dcs->d_nxt->d_nedecl = 1;
}
}
return (tag);
}
const char *
scltoa(sc)
scl_t sc;
{
const char *s;
switch (sc) {
case EXTERN: s = "extern"; break;
case STATIC: s = "static"; break;
case AUTO: s = "auto"; break;
case REG: s = "register"; break;
case TYPEDEF: s = "typedef"; break;
case STRTAG: s = "struct"; break;
case UNIONTAG: s = "union"; break;
case ENUMTAG: s = "enum"; break;
default: lerror("tagttoa()");
}
return (s);
}
type_t *
compltag(tp, fmem)
type_t *tp;
sym_t *fmem;
{
tspec_t t;
str_t *sp;
int n;
sym_t *mem;
setcompl(tp, 0);
if ((t = tp->t_tspec) != ENUM) {
align(dcs->d_stralign, 0);
sp = tp->t_str;
sp->align = dcs->d_stralign;
sp->size = dcs->d_offset;
sp->memb = fmem;
if (sp->size == 0) {
(void)gnuism(47, ttab[t].tt_name);
} else {
n = 0;
for (mem = fmem; mem != NULL; mem = mem->s_nxt) {
if (mem->s_name != unnamed)
n++;
}
if (n == 0) {
warning(65,
t == STRUCT ? "structure" : "union");
}
}
} else {
tp->t_enum->elem = fmem;
}
return (tp);
}
sym_t *
ename(sym, val, impl)
sym_t *sym;
int val, impl;
{
if (sym->s_scl) {
if (sym->s_blklev == blklev) {
if (sym->s_arg) {
warning(57, sym->s_name);
} else {
error(27, sym->s_name);
if (blklev == 0)
prevdecl(-1, sym);
}
} else {
if (hflag)
warning(43, sym->s_name);
}
sym = pushdown(sym);
}
sym->s_scl = ENUMCON;
sym->s_type = dcs->d_tagtyp;
sym->s_value.v_tspec = INT;
sym->s_value.v_quad = val;
if (impl && val - 1 == INT_MAX) {
warning(48, sym->s_name);
}
enumval = val + 1;
return (sym);
}
void
decl1ext(dsym, initflg)
sym_t *dsym;
int initflg;
{
int warn, rval, redec;
sym_t *rdsym;
chkfdef(dsym, 1);
chktyp(dsym);
if (initflg && !(initerr = chkinit(dsym)))
dsym->s_def = DEF;
if (dsym->s_type->t_tspec == FUNC && dsym->s_def == TDEF)
dsym->s_def = DECL;
if (dcs->d_inline) {
if (dsym->s_type->t_tspec == FUNC) {
dsym->s_inline = 1;
} else {
warning(268, dsym->s_name);
}
}
if (plibflg && llibflg &&
dsym->s_type->t_tspec == FUNC && dsym->s_type->t_proto) {
rval = dsym->s_type->t_subt->t_tspec != VOID;
outfdef(dsym, &dsym->s_dpos, rval, 0, NULL);
} else {
outsym(dsym, dsym->s_scl, dsym->s_def);
}
if ((rdsym = dcs->d_rdcsym) != NULL) {
if (rdsym->s_osdef && dsym->s_type->t_proto) {
redec = chkosdef(rdsym, dsym);
} else {
redec = 0;
}
if (!redec && !isredec(dsym, (warn = 0, &warn))) {
if (warn) {
(*(sflag ? error : warning))(27, dsym->s_name);
prevdecl(-1, rdsym);
}
if (rdsym->s_osdef && !dsym->s_type->t_proto) {
dsym->s_osdef = rdsym->s_osdef;
dsym->s_args = rdsym->s_args;
STRUCT_ASSIGN(dsym->s_dpos, rdsym->s_dpos);
}
if (rdsym->s_type->t_proto && !dsym->s_type->t_proto) {
STRUCT_ASSIGN(dsym->s_dpos, rdsym->s_dpos);
} else if (rdsym->s_def == DEF && dsym->s_def != DEF) {
STRUCT_ASSIGN(dsym->s_dpos, rdsym->s_dpos);
}
cpuinfo(dsym, rdsym);
if (rdsym->s_def == DEF)
dsym->s_def = DEF;
if (rdsym->s_inline)
dsym->s_inline = 1;
compltyp(dsym, rdsym);
}
rmsym(rdsym);
}
if (dsym->s_scl == TYPEDEF) {
dsym->s_type = duptyp(dsym->s_type);
dsym->s_type->t_typedef = 1;
settdsym(dsym->s_type, dsym);
}
}
void
cpuinfo(sym, rdsym)
sym_t *sym, *rdsym;
{
sym->s_spos = rdsym->s_spos;
sym->s_upos = rdsym->s_upos;
sym->s_set = rdsym->s_set;
sym->s_used = rdsym->s_used;
}
int
isredec(dsym, warn)
sym_t *dsym;
int *warn;
{
sym_t *rsym;
if ((rsym = dcs->d_rdcsym)->s_scl == ENUMCON) {
error(27, dsym->s_name);
prevdecl(-1, rsym);
return (1);
}
if (rsym->s_scl == TYPEDEF) {
error(89, dsym->s_name);
prevdecl(-1, rsym);
return (1);
}
if (dsym->s_scl == TYPEDEF) {
error(27, dsym->s_name);
prevdecl(-1, rsym);
return (1);
}
if (rsym->s_def == DEF && dsym->s_def == DEF) {
error(28, dsym->s_name);
prevdecl(-1, rsym);
return(1);
}
if (!eqtype(rsym->s_type, dsym->s_type, 0, 0, warn)) {
error(27, dsym->s_name);
prevdecl(-1, rsym);
return(1);
}
if (rsym->s_scl == EXTERN && dsym->s_scl == EXTERN)
return(0);
if (rsym->s_scl == STATIC && dsym->s_scl == STATIC)
return(0);
if (rsym->s_scl == STATIC && dsym->s_def == DECL)
return(0);
if (rsym->s_scl == EXTERN && rsym->s_def == DEF) {
error(27, dsym->s_name);
prevdecl(-1, rsym);
return(1);
}
if (rsym->s_scl == EXTERN) {
warning(29, dsym->s_name);
prevdecl(-1, rsym);
return(0);
}
if (sflag) {
warning(30, dsym->s_name);
prevdecl(-1, rsym);
}
dsym->s_scl = STATIC;
return (0);
}
int
eqtype(tp1, tp2, ignqual, promot, warn)
type_t *tp1, *tp2;
int ignqual, promot, *warn;
{
tspec_t t;
while (tp1 != NULL && tp2 != NULL) {
t = tp1->t_tspec;
if (promot) {
if (t == FLOAT) {
t = DOUBLE;
} else if (t == CHAR || t == SCHAR) {
t = INT;
} else if (t == UCHAR) {
t = tflag ? UINT : INT;
} else if (t == SHORT) {
t = INT;
} else if (t == USHORT) {
t = INT_MAX < USHRT_MAX || tflag ? UINT : INT;
}
}
if (t != tp2->t_tspec)
return (0);
if (tp1->t_const != tp2->t_const && !ignqual && !tflag)
return (0);
if (tp1->t_volatile != tp2->t_volatile && !ignqual && !tflag)
return (0);
if (t == STRUCT || t == UNION)
return (tp1->t_str == tp2->t_str);
if (t == ARRAY && tp1->t_dim != tp2->t_dim) {
if (tp1->t_dim != 0 && tp2->t_dim != 0)
return (0);
}
if (t == FUNC && !tflag) {
if (tp1->t_proto && tp2->t_proto) {
if (!eqargs(tp1, tp2, warn))
return (0);
} else if (tp1->t_proto) {
if (!mnoarg(tp1, warn))
return (0);
} else if (tp2->t_proto) {
if (!mnoarg(tp2, warn))
return (0);
}
}
tp1 = tp1->t_subt;
tp2 = tp2->t_subt;
ignqual = promot = 0;
}
return (tp1 == tp2);
}
static int
eqargs(tp1, tp2, warn)
type_t *tp1, *tp2;
int *warn;
{
sym_t *a1, *a2;
if (tp1->t_vararg != tp2->t_vararg)
return (0);
a1 = tp1->t_args;
a2 = tp2->t_args;
while (a1 != NULL && a2 != NULL) {
if (eqtype(a1->s_type, a2->s_type, 1, 0, warn) == 0)
return (0);
a1 = a1->s_nxt;
a2 = a2->s_nxt;
}
return (a1 == a2);
}
static int
mnoarg(tp, warn)
type_t *tp;
int *warn;
{
sym_t *arg;
tspec_t t;
if (tp->t_vararg) {
if (warn != NULL)
*warn = 1;
}
for (arg = tp->t_args; arg != NULL; arg = arg->s_nxt) {
if ((t = arg->s_type->t_tspec) == FLOAT ||
t == CHAR || t == SCHAR || t == UCHAR ||
t == SHORT || t == USHORT) {
if (warn != NULL)
*warn = 1;
}
}
return (1);
}
static int
chkosdef(rdsym, dsym)
sym_t *rdsym, *dsym;
{
sym_t *args, *pargs, *arg, *parg;
int narg, nparg, n;
int warn, msg;
args = rdsym->s_args;
pargs = dsym->s_type->t_args;
msg = 0;
narg = nparg = 0;
for (arg = args; arg != NULL; arg = arg->s_nxt)
narg++;
for (parg = pargs; parg != NULL; parg = parg->s_nxt)
nparg++;
if (narg != nparg) {
error(63);
msg = 1;
goto end;
}
arg = args;
parg = pargs;
n = 1;
while (narg--) {
warn = 0;
if (!eqtype(arg->s_type, parg->s_type, 1, 1, &warn) || warn) {
error(299, n);
msg = 1;
}
arg = arg->s_nxt;
parg = parg->s_nxt;
n++;
}
end:
if (msg)
prevdecl(300, rdsym);
return (msg);
}
void
compltyp(dsym, ssym)
sym_t *dsym, *ssym;
{
type_t **dstp, *src;
type_t *dst;
dstp = &dsym->s_type;
src = ssym->s_type;
while ((dst = *dstp) != NULL) {
if (src == NULL || dst->t_tspec != src->t_tspec)
lerror("compltyp() 1");
if (dst->t_tspec == ARRAY) {
if (dst->t_dim == 0 && src->t_dim != 0) {
*dstp = dst = duptyp(dst);
dst->t_dim = src->t_dim;
setcompl(dst, 0);
}
} else if (dst->t_tspec == FUNC) {
if (!dst->t_proto && src->t_proto) {
*dstp = dst = duptyp(dst);
dst->t_proto = 1;
dst->t_args = src->t_args;
}
}
dstp = &dst->t_subt;
src = src->t_subt;
}
}
sym_t *
decl1arg(sym, initflg)
sym_t *sym;
int initflg;
{
tspec_t t;
chkfdef(sym, 1);
chktyp(sym);
if (dcs->d_rdcsym != NULL && dcs->d_rdcsym->s_blklev == blklev) {
error(237, sym->s_name);
rmsym(dcs->d_rdcsym);
sym->s_arg = 1;
}
if (!sym->s_arg) {
error(53, sym->s_name);
sym->s_arg = 1;
}
if (initflg) {
error(52, sym->s_name);
initerr = 1;
}
if ((t = sym->s_type->t_tspec) == ARRAY) {
sym->s_type = incref(sym->s_type->t_subt, PTR);
} else if (t == FUNC) {
if (tflag)
warning(50, sym->s_name);
sym->s_type = incref(sym->s_type, PTR);
} else if (t == FLOAT) {
if (tflag)
sym->s_type = gettyp(DOUBLE);
}
if (dcs->d_inline)
warning(269, sym->s_name);
if (sym->s_type->t_tspec != VOID)
(void)length(sym->s_type, sym->s_name);
setsflg(sym);
return (sym);
}
void
cluparg()
{
sym_t *args, *arg, *pargs, *parg;
int narg, nparg, n, msg;
tspec_t t;
args = funcsym->s_args;
pargs = funcsym->s_type->t_args;
if (prflstrg != -1 && scflstrg != -1) {
warning(289);
prflstrg = scflstrg = -1;
}
if (nvararg != -1 && (prflstrg != -1 || scflstrg != -1)) {
warning(288, prflstrg != -1 ? "PRINTFLIKE" : "SCANFLIKE");
nvararg = -1;
}
narg = 0;
for (arg = dcs->d_fargs; arg != NULL; arg = arg->s_nxt)
narg++;
if (nargusg > narg) {
warning(283, "ARGSUSED");
nargusg = 0;
}
if (nvararg > narg) {
warning(283, "VARARGS");
nvararg = 0;
}
if (prflstrg > narg) {
warning(283, "PRINTFLIKE");
prflstrg = -1;
} else if (prflstrg == 0) {
prflstrg = -1;
}
if (scflstrg > narg) {
warning(283, "SCANFLIKE");
scflstrg = -1;
} else if (scflstrg == 0) {
scflstrg = -1;
}
if (prflstrg != -1 || scflstrg != -1) {
narg = prflstrg != -1 ? prflstrg : scflstrg;
arg = dcs->d_fargs;
for (n = 1; n < narg; n++)
arg = arg->s_nxt;
if (arg->s_type->t_tspec != PTR ||
((t = arg->s_type->t_subt->t_tspec) != CHAR &&
t != UCHAR && t != SCHAR)) {
warning(293, narg);
prflstrg = scflstrg = -1;
}
}
for (arg = args; arg != NULL; arg = arg->s_nxt) {
if (arg->s_defarg) {
warning(32, arg->s_name);
arg->s_defarg = 0;
setsflg(arg);
}
}
if (funcsym->s_osdef && funcsym->s_type->t_proto) {
narg = nparg = 0;
msg = 0;
for (parg = pargs; parg != NULL; parg = parg->s_nxt)
nparg++;
for (arg = args; arg != NULL; arg = arg->s_nxt)
narg++;
if (narg != nparg) {
error(51, nparg, narg);
msg = 1;
} else {
parg = pargs;
arg = args;
while (narg--) {
msg |= chkptdecl(arg, parg);
parg = parg->s_nxt;
arg = arg->s_nxt;
}
}
if (msg)
prevdecl(285, dcs->d_rdcsym);
funcsym->s_osdef = 0;
funcsym->s_args = NULL;
}
}
static int
chkptdecl(arg, parg)
sym_t *arg, *parg;
{
type_t *tp, *ptp;
int warn, msg;
tp = arg->s_type;
ptp = parg->s_type;
msg = 0;
warn = 0;
if (!eqtype(tp, ptp, 1, 1, &warn)) {
if (eqtype(tp, ptp, 1, 0, &warn)) {
msg = gnuism(58, arg->s_name);
} else {
error(58, arg->s_name);
msg = 1;
}
} else if (warn) {
(*(sflag ? error : warning))(58, arg->s_name);
msg = 1;
}
return (msg);
}
void
decl1loc(dsym, initflg)
sym_t *dsym;
int initflg;
{
if (dsym->s_type->t_tspec == FUNC) {
dsym->s_def = DECL;
if (dcs->d_scl == NOSCL)
dsym->s_scl = EXTERN;
}
if (dsym->s_type->t_tspec == FUNC) {
if (dsym->s_scl == STATIC) {
warning(93, dsym->s_name);
dsym->s_scl = EXTERN;
} else if (dsym->s_scl != EXTERN && dsym->s_scl != TYPEDEF) {
error(94, dsym->s_name);
dsym->s_scl = EXTERN;
}
}
if (dcs->d_inline) {
if (dsym->s_type->t_tspec == FUNC) {
dsym->s_inline = 1;
} else {
warning(268, dsym->s_name);
}
}
chkfdef(dsym, 1);
chktyp(dsym);
if (dcs->d_rdcsym != NULL && dsym->s_scl == EXTERN)
ledecl(dsym);
if (dsym->s_scl == EXTERN) {
if (dsym->s_xsym == NULL) {
outsym(dsym, EXTERN, dsym->s_def);
} else {
outsym(dsym, dsym->s_xsym->s_scl, dsym->s_def);
}
}
if (dcs->d_rdcsym != NULL) {
if (dcs->d_rdcsym->s_blklev == 0) {
switch (dsym->s_scl) {
case AUTO:
if (hflag)
warning(86, dsym->s_name);
break;
case STATIC:
if (hflag)
warning(87, dsym->s_name);
break;
case TYPEDEF:
if (hflag)
warning(88, dsym->s_name);
break;
case EXTERN:
break;
default:
lerror("decl1loc() 1");
}
} else if (dcs->d_rdcsym->s_blklev == blklev) {
if (dcs->d_rdcsym->s_arg) {
if (tflag) {
if (hflag)
warning(91, dsym->s_name);
rmsym(dcs->d_rdcsym);
}
}
} else if (dcs->d_rdcsym->s_blklev < blklev) {
if (hflag)
warning(95, dsym->s_name);
}
if (dcs->d_rdcsym->s_blklev == blklev) {
error(27, dsym->s_name);
rmsym(dcs->d_rdcsym);
}
}
if (initflg && !(initerr = chkinit(dsym))) {
dsym->s_def = DEF;
setsflg(dsym);
}
if (dsym->s_scl == TYPEDEF) {
dsym->s_type = duptyp(dsym->s_type);
dsym->s_type->t_typedef = 1;
settdsym(dsym->s_type, dsym);
}
}
static void
ledecl(dsym)
sym_t *dsym;
{
int eqt, warn;
sym_t *esym;
esym = dcs->d_rdcsym;
while (esym != NULL && esym->s_blklev != 0) {
while ((esym = esym->s_link) != NULL) {
if (esym->s_kind != FVFT)
continue;
if (strcmp(dsym->s_name, esym->s_name) == 0)
break;
}
}
if (esym == NULL)
return;
if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
warning(27, dsym->s_name);
prevdecl(-1, esym);
return;
}
warn = 0;
eqt = eqtype(esym->s_type, dsym->s_type, 0, 0, &warn);
if (!eqt || warn) {
if (esym->s_scl == EXTERN) {
warning(90, dsym->s_name);
prevdecl(-1, esym);
} else {
warning(92, dsym->s_name);
prevdecl(-1, esym);
}
}
if (eqt) {
dsym->s_xsym = esym;
}
}
static int
chkinit(sym)
sym_t *sym;
{
int err;
err = 0;
if (sym->s_type->t_tspec == FUNC) {
error(24, sym->s_name);
err = 1;
} else if (sym->s_scl == TYPEDEF) {
error(25, sym->s_name);
err = 1;
} else if (sym->s_scl == EXTERN && sym->s_def == DECL) {
if (dcs->d_ctx == EXTERN) {
warning(26, sym->s_name);
} else {
error(26, sym->s_name);
err = 1;
}
}
return (err);
}
sym_t *
aname()
{
sym_t *sym;
if (dcs->d_ctx != ABSTRACT && dcs->d_ctx != PARG)
lerror("aname()");
sym = getblk(sizeof (sym_t));
sym->s_name = unnamed;
sym->s_def = DEF;
sym->s_scl = ABSTRACT;
sym->s_blklev = -1;
if (dcs->d_ctx == PARG)
sym->s_arg = 1;
sym->s_type = dcs->d_type;
dcs->d_rdcsym = NULL;
dcs->d_vararg = 0;
return (sym);
}
void
globclup()
{
while (dcs->d_nxt != NULL)
popdecl();
cleanup();
blklev = 0;
mblklev = 0;
glclup(1);
}
sym_t *
decl1abs(sym)
sym_t *sym;
{
chkfdef(sym, 1);
chktyp(sym);
return (sym);
}
void
chksz(dsym)
sym_t *dsym;
{
if (dsym->s_def != DEF)
return;
if (dsym->s_scl == TYPEDEF)
return;
if (dsym->s_type->t_tspec == FUNC)
return;
if (length(dsym->s_type, dsym->s_name) == 0 &&
dsym->s_type->t_tspec == ARRAY && dsym->s_type->t_dim == 0) {
if (tflag) {
warning(190, dsym->s_name);
} else {
error(190, dsym->s_name);
}
}
}
void
setsflg(sym)
sym_t *sym;
{
if (!sym->s_set) {
sym->s_set = 1;
UNIQUE_CURR_POS(sym->s_spos);
}
}
void
setuflg(sym, fcall, szof)
sym_t *sym;
int fcall, szof;
{
if (!sym->s_used) {
sym->s_used = 1;
UNIQUE_CURR_POS(sym->s_upos);
}
if (!fcall && !szof && sym->s_kind == FVFT && sym->s_scl == EXTERN)
outusg(sym);
}
void
chkusage(di)
dinfo_t *di;
{
sym_t *sym;
int mknowarn;
mknowarn = nowarn;
nowarn = 0;
for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_dlnxt)
chkusg1(di->d_asm, sym);
nowarn = mknowarn;
}
void
chkusg1(novar, sym)
int novar;
sym_t *sym;
{
pos_t cpos;
if (sym->s_blklev == -1)
return;
STRUCT_ASSIGN(cpos, curr_pos);
if (sym->s_kind == FVFT) {
if (sym->s_arg) {
chkausg(novar, sym);
} else {
chkvusg(novar, sym);
}
} else if (sym->s_kind == FLAB) {
chklusg(sym);
} else if (sym->s_kind == FTAG) {
chktusg(sym);
}
STRUCT_ASSIGN(curr_pos, cpos);
}
static void
chkausg(novar, arg)
int novar;
sym_t *arg;
{
if (!arg->s_set)
lerror("chkausg() 1");
if (novar)
return;
if (!arg->s_used && vflag) {
STRUCT_ASSIGN(curr_pos, arg->s_dpos);
warning(231, arg->s_name, funcsym->s_name);
}
}
static void
chkvusg(novar, sym)
int novar;
sym_t *sym;
{
scl_t sc;
sym_t *xsym;
if (blklev == 0 || sym->s_blklev == 0)
lerror("chkvusg() 1");
if (nerr != 0)
return;
if ((sc = sym->s_scl) != EXTERN && sc != STATIC &&
sc != AUTO && sc != REG) {
return;
}
if (novar)
return;
if (sc == EXTERN) {
if (!sym->s_used && !sym->s_set) {
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
warning(192, sym->s_name, funcsym->s_name);
}
} else {
if (sym->s_set && !sym->s_used) {
STRUCT_ASSIGN(curr_pos, sym->s_spos);
warning(191, sym->s_name, funcsym->s_name);
} else if (!sym->s_used) {
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
warning(192, sym->s_name, funcsym->s_name);
}
}
if (sc == EXTERN) {
if ((xsym = sym->s_xsym) != NULL) {
if (sym->s_used && !xsym->s_used) {
xsym->s_used = 1;
STRUCT_ASSIGN(xsym->s_upos, sym->s_upos);
}
if (sym->s_set && !xsym->s_set) {
xsym->s_set = 1;
STRUCT_ASSIGN(xsym->s_spos, sym->s_spos);
}
}
}
}
static void
chklusg(lab)
sym_t *lab;
{
if (blklev != 1 || lab->s_blklev != 1)
lerror("chklusg() 1");
if (lab->s_set && !lab->s_used) {
STRUCT_ASSIGN(curr_pos, lab->s_spos);
warning(192, lab->s_name, funcsym->s_name);
} else if (!lab->s_set) {
STRUCT_ASSIGN(curr_pos, lab->s_upos);
warning(23, lab->s_name);
}
}
static void
chktusg(sym)
sym_t *sym;
{
if (!incompl(sym->s_type))
return;
if (!zflag || dcs->d_ctx != EXTERN)
return;
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
switch (sym->s_type->t_tspec) {
case STRUCT:
warning(233, sym->s_name);
break;
case UNION:
warning(234, sym->s_name);
break;
case ENUM:
warning(235, sym->s_name);
break;
default:
lerror("chktusg() 1");
}
}
void
chkglsyms()
{
sym_t *sym;
pos_t cpos;
if (blklev != 0 || dcs->d_nxt != NULL)
norecover();
STRUCT_ASSIGN(cpos, curr_pos);
for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
if (sym->s_blklev == -1)
continue;
if (sym->s_kind == FVFT) {
chkglvar(sym);
} else if (sym->s_kind == FTAG) {
chktusg(sym);
} else {
if (sym->s_kind != FMOS)
lerror("chkglsyms() 1");
}
}
STRUCT_ASSIGN(curr_pos, cpos);
}
static void
chkglvar(sym)
sym_t *sym;
{
if (sym->s_scl == TYPEDEF || sym->s_scl == ENUMCON)
return;
if (sym->s_scl != EXTERN && sym->s_scl != STATIC)
lerror("chkglvar() 1");
glchksz(sym);
if (sym->s_scl == STATIC) {
if (sym->s_type->t_tspec == FUNC) {
if (sym->s_used && sym->s_def != DEF) {
STRUCT_ASSIGN(curr_pos, sym->s_upos);
error(225, sym->s_name);
}
}
if (!sym->s_used) {
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
if (sym->s_type->t_tspec == FUNC) {
if (sym->s_def == DEF) {
if (!sym->s_inline)
warning(236, sym->s_name);
} else {
warning(290, sym->s_name);
}
} else if (!sym->s_set) {
warning(226, sym->s_name);
} else {
warning(307, sym->s_name);
}
}
if (!tflag && sym->s_def == TDEF && sym->s_type->t_const) {
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
warning(227, sym->s_name);
}
}
}
static void
glchksz(sym)
sym_t *sym;
{
if (sym->s_def == TDEF) {
if (sym->s_type->t_tspec == FUNC)
return;
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
if (length(sym->s_type, sym->s_name) == 0 &&
sym->s_type->t_tspec == ARRAY && sym->s_type->t_dim == 0) {
if (tflag || (sym->s_scl == EXTERN && !sflag)) {
warning(190, sym->s_name);
} else {
error(190, sym->s_name);
}
}
}
}
void
prevdecl(msg, psym)
int msg;
sym_t *psym;
{
pos_t cpos;
if (!rflag)
return;
STRUCT_ASSIGN(cpos, curr_pos);
STRUCT_ASSIGN(curr_pos, psym->s_dpos);
if (msg != -1) {
message(msg, psym->s_name);
} else if (psym->s_def == DEF || psym->s_def == TDEF) {
message(261, psym->s_name);
} else {
message(260, psym->s_name);
}
STRUCT_ASSIGN(curr_pos, cpos);
}