3c5bf66cec
(even found some unchecked naked uses)
3140 lines
68 KiB
C
3140 lines
68 KiB
C
/* $NetBSD: decl.c,v 1.11 1995/10/02 17:34:16 jpo Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1994, 1995 Jochen Pohl
|
|
* All Rights Reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Jochen Pohl for
|
|
* The NetBSD Project.
|
|
* 4. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static const char rcsid[] =
|
|
"$FreeBSD$";
|
|
#endif
|
|
|
|
#include <sys/param.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "lint1.h"
|
|
|
|
const char *unnamed = "<unnamed>";
|
|
|
|
/* contains various information and classification on types */
|
|
ttab_t ttab[NTSPEC];
|
|
|
|
/* shared type structures for arithmtic types and void */
|
|
static type_t *typetab;
|
|
|
|
/* value of next enumerator during declaration of enum types */
|
|
int enumval;
|
|
|
|
/*
|
|
* pointer to top element of a stack which contains informations local
|
|
* to nested declarations
|
|
*/
|
|
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 *));
|
|
|
|
/*
|
|
* initializes all global vars used in declarations
|
|
*/
|
|
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" } },
|
|
};
|
|
|
|
/* declaration stack */
|
|
if ((dcs = calloc(1, sizeof (dinfo_t))) == NULL)
|
|
nomem();
|
|
dcs->d_ctx = EXTERN;
|
|
dcs->d_ldlsym = &dcs->d_dlsyms;
|
|
|
|
/* type information and classification */
|
|
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;
|
|
}
|
|
|
|
/* shared type structures */
|
|
if ((typetab = calloc(NTSPEC, sizeof (type_t))) == NULL)
|
|
nomem();
|
|
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;
|
|
/*
|
|
* Next two are not real types. They are only used by the parser
|
|
* to return keywords "signed" and "unsigned"
|
|
*/
|
|
typetab[SIGNED].t_tspec = SIGNED;
|
|
typetab[UNSIGN].t_tspec = UNSIGN;
|
|
}
|
|
|
|
/*
|
|
* Returns a shared type structure vor arithmetic types and void.
|
|
*
|
|
* It's important do duplicate this structure (using duptyp() or tdupdyp())
|
|
* if it is to be modified (adding qualifiers or anything else).
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Use tduptyp() instead of duptyp() inside expressions (if the
|
|
* allocated memory should be freed after the expr).
|
|
*/
|
|
type_t *
|
|
tduptyp(tp)
|
|
const type_t *tp;
|
|
{
|
|
type_t *ntp;
|
|
|
|
ntp = tgetblk(sizeof (type_t));
|
|
STRUCT_ASSIGN(*ntp, *tp);
|
|
return (ntp);
|
|
}
|
|
|
|
/*
|
|
* Returns 1 if the argument is void or an incomplete array,
|
|
* struct, union or enum type.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Set the flag for (in)complete array, struct, union or enum
|
|
* types.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Remember the storage class of the current declaration in dcs->d_scl
|
|
* (the top element of the declaration stack) and detect multiple
|
|
* storage classes.
|
|
*/
|
|
void
|
|
addscl(sc)
|
|
scl_t sc;
|
|
{
|
|
if (sc == INLINE) {
|
|
if (dcs->d_inline)
|
|
/* duplicate '%s' */
|
|
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) {
|
|
/* storage class after type is obsolescent */
|
|
warning(83);
|
|
}
|
|
if (dcs->d_scl == NOSCL) {
|
|
dcs->d_scl = sc;
|
|
} else {
|
|
/*
|
|
* multiple storage classes. An error will be reported in
|
|
* deftyp().
|
|
*/
|
|
dcs->d_mscl = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Remember the type, modifier or typedef name returned by the parser
|
|
* in *dcs (top element of decl stack). This information is used in
|
|
* deftyp() to build the type used for all declarators in this
|
|
* declaration.
|
|
*
|
|
* Is tp->t_typedef 1, the type comes from a previously defined typename.
|
|
* Otherwise it comes from a type specifier (int, long, ...) or a
|
|
* struct/union/enum tag.
|
|
*/
|
|
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) {
|
|
/*
|
|
* something like "typedef int a; int a b;"
|
|
* This should not happen with current grammar.
|
|
*/
|
|
lerror("addtype()");
|
|
}
|
|
dcs->d_type = tp;
|
|
return;
|
|
}
|
|
|
|
t = tp->t_tspec;
|
|
|
|
if (t == STRUCT || t == UNION || t == ENUM) {
|
|
/*
|
|
* something like "int struct a ..."
|
|
* struct/union/enum with anything else is not allowed
|
|
*/
|
|
if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
|
|
dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
|
|
/*
|
|
* remember that an error must be reported in
|
|
* deftyp().
|
|
*/
|
|
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) {
|
|
/*
|
|
* something like "struct a int"
|
|
* struct/union/enum with anything else is not allowed
|
|
*/
|
|
dcs->d_terr = 1;
|
|
return;
|
|
}
|
|
|
|
if (t == LONG && dcs->d_lmod == LONG) {
|
|
/* "long long" or "long ... long" */
|
|
t = QUAD;
|
|
dcs->d_lmod = NOTSPEC;
|
|
if (!quadflg)
|
|
/* %s C does not support 'long long' */
|
|
(void)gnuism(265, tflag ? "traditional" : "ANSI");
|
|
}
|
|
|
|
if (dcs->d_type != NULL && dcs->d_type->t_typedef) {
|
|
/* something like "typedef int a; a long ..." */
|
|
dcs->d_type = tdeferr(dcs->d_type, t);
|
|
return;
|
|
}
|
|
|
|
/* now it can be only a combination of arithmetic types and void */
|
|
if (t == SIGNED || t == UNSIGN) {
|
|
/* remeber specifiers "signed" and "unsigned" in dcs->d_smod */
|
|
if (dcs->d_smod != NOTSPEC)
|
|
/*
|
|
* more then one "signed" and/or "unsigned"; print
|
|
* an error in deftyp()
|
|
*/
|
|
dcs->d_terr = 1;
|
|
dcs->d_smod = t;
|
|
} else if (t == SHORT || t == LONG || t == QUAD) {
|
|
/*
|
|
* remember specifiers "short", "long" and "long long" in
|
|
* dcs->d_lmod
|
|
*/
|
|
if (dcs->d_lmod != NOTSPEC)
|
|
/* more than one, print error in deftyp() */
|
|
dcs->d_terr = 1;
|
|
dcs->d_lmod = t;
|
|
} else {
|
|
/*
|
|
* remember specifiers "void", "char", "int", "float" or
|
|
* "double" int dcs->d_atyp
|
|
*/
|
|
if (dcs->d_atyp != NOTSPEC)
|
|
/* more than one, print error in deftyp() */
|
|
dcs->d_terr = 1;
|
|
dcs->d_atyp = t;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* called if a list of declaration specifiers contains a typedef name
|
|
* and other specifiers (except struct, union, enum, typedef name)
|
|
*/
|
|
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)
|
|
/* modifying typedef with ... */
|
|
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) {
|
|
/* modifying typedef with ... */
|
|
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) {
|
|
/* modifying typedef with ... */
|
|
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;
|
|
/* LINTED (enumeration values not handled in switch) */
|
|
default:
|
|
}
|
|
|
|
/* Anything other is not accepted. */
|
|
|
|
dcs->d_terr = 1;
|
|
return (td);
|
|
}
|
|
|
|
/*
|
|
* Remember the symbol of a typedef name (2nd arg) in a struct, union
|
|
* or enum tag if the typedef name is the first defined for this tag.
|
|
*
|
|
* If the tag is unnamed, the typdef name is used for identification
|
|
* of this tag in lint2. Although its possible that more then one typedef
|
|
* name is defined for one tag, the first name defined should be unique
|
|
* if the tag is unnamed.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Remember a qualifier which is part of the declaration specifiers
|
|
* (and not the declarator) in the top element of the declaration stack.
|
|
* Also detect multiple qualifiers of the same kind.
|
|
|
|
* The rememberd qualifier is used by deftyp() to construct the type
|
|
* for all declarators.
|
|
*/
|
|
void
|
|
addqual(q)
|
|
tqual_t q;
|
|
{
|
|
if (q == CONST) {
|
|
if (dcs->d_const) {
|
|
/* duplicate "%s" */
|
|
warning(10, "const");
|
|
}
|
|
dcs->d_const = 1;
|
|
} else {
|
|
if (q != VOLATILE)
|
|
lerror("addqual() 1");
|
|
if (dcs->d_volatile) {
|
|
/* duplicate "%s" */
|
|
warning(10, "volatile");
|
|
}
|
|
dcs->d_volatile = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Go to the next declaration level (structs, nested structs, blocks,
|
|
* argument declaration lists ...)
|
|
*/
|
|
void
|
|
pushdecl(sc)
|
|
scl_t sc;
|
|
{
|
|
dinfo_t *di;
|
|
|
|
if (dflag)
|
|
(void)printf("pushdecl(%d)\n", (int)sc);
|
|
|
|
/* put a new element on the declaration stack */
|
|
if ((di = calloc(1, sizeof (dinfo_t))) == NULL)
|
|
nomem();
|
|
di->d_nxt = dcs;
|
|
dcs = di;
|
|
di->d_ctx = sc;
|
|
di->d_ldlsym = &di->d_dlsyms;
|
|
}
|
|
|
|
/*
|
|
* Go back to previous declaration level
|
|
*/
|
|
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:
|
|
/* there is nothing after external declarations */
|
|
lerror("popdecl() 2");
|
|
/* NOTREACHED */
|
|
case MOS:
|
|
case MOU:
|
|
case ENUMCON:
|
|
/*
|
|
* Symbols declared in (nested) structs or enums are
|
|
* part of the next level (they are removed from the
|
|
* symbol table if the symbols of the outher level are
|
|
* removed)
|
|
*/
|
|
if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
|
|
dcs->d_ldlsym = di->d_ldlsym;
|
|
break;
|
|
case ARG:
|
|
/*
|
|
* All symbols in dcs->d_dlsyms are introduced in old style
|
|
* argument declarations (it's not clean, but possible).
|
|
* They are appended to the list of symbols declared in
|
|
* an old style argument identifier list or a new style
|
|
* parameter type list.
|
|
*/
|
|
if (di->d_dlsyms != NULL) {
|
|
*di->d_ldlsym = dcs->d_fpsyms;
|
|
dcs->d_fpsyms = di->d_dlsyms;
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
/*
|
|
* casts and sizeof
|
|
* Append all symbols declared in the abstract declaration
|
|
* to the list of symbols declared in the surounding decl.
|
|
* or block.
|
|
* XXX I'm not sure whether they should be removed from the
|
|
* symbol table now or later.
|
|
*/
|
|
if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
|
|
dcs->d_ldlsym = di->d_ldlsym;
|
|
break;
|
|
case AUTO:
|
|
/* check usage of local vars */
|
|
chkusage(di);
|
|
/* FALLTHROUGH */
|
|
case PARG:
|
|
/* usage of arguments will be checked by funcend() */
|
|
rmsyms(di->d_dlsyms);
|
|
break;
|
|
default:
|
|
lerror("popdecl() 3");
|
|
}
|
|
free(di);
|
|
}
|
|
|
|
/*
|
|
* Set flag d_asm in all declaration stack elements up to the
|
|
* outermost one.
|
|
*
|
|
* This is used to mark compound statements which have, possibly in
|
|
* nested compound statements, asm statements. For these compound
|
|
* statements no warnings about unused or unitialized variables are
|
|
* printed.
|
|
*
|
|
* There is no need to clear d_asm in dinfo structs with context AUTO,
|
|
* because these structs are freed at the end of the compound statement.
|
|
* But it must be cleard in the outermost dinfo struct, which has
|
|
* context EXTERN. This could be done in clrtyp() and would work for
|
|
* C, but not for C++ (due to mixed statements and declarations). Thus
|
|
* we clear it in glclup(), which is used to do some cleanup after
|
|
* global declarations/definitions.
|
|
*/
|
|
void
|
|
setasm()
|
|
{
|
|
dinfo_t *di;
|
|
|
|
for (di = dcs; di != NULL; di = di->d_nxt)
|
|
di->d_asm = 1;
|
|
}
|
|
|
|
/*
|
|
* Clean all elements of the top element of declaration stack which
|
|
* will be used by the next declaration
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Create a type structure from the informations gathered in
|
|
* the declaration stack.
|
|
* Complain about storage classes which are not possible in current
|
|
* context.
|
|
*/
|
|
void
|
|
deftyp()
|
|
{
|
|
tspec_t t, s, l;
|
|
type_t *tp;
|
|
scl_t scl;
|
|
|
|
t = dcs->d_atyp; /* CHAR, INT, FLOAT, DOUBLE, VOID */
|
|
s = dcs->d_smod; /* SIGNED, UNSIGNED */
|
|
l = dcs->d_lmod; /* SHORT, LONG, QUAD */
|
|
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)) {
|
|
/* should never happen */
|
|
lerror("deftyp() 1");
|
|
}
|
|
|
|
if (tp == NULL) {
|
|
switch (t) {
|
|
case NOTSPEC:
|
|
t = INT;
|
|
/* FALLTHROUGH */
|
|
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)
|
|
/* use 'double' instead of ... */
|
|
warning(6);
|
|
}
|
|
break;
|
|
case DOUBLE:
|
|
if (l == LONG) {
|
|
l = NOTSPEC;
|
|
t = LDOUBLE;
|
|
if (tflag)
|
|
/* 'long double' is illegal in ... */
|
|
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) {
|
|
/* only one storage class allowed */
|
|
error(7);
|
|
}
|
|
if (dcs->d_terr) {
|
|
/* illegal type combination */
|
|
error(4);
|
|
}
|
|
|
|
if (dcs->d_ctx == EXTERN) {
|
|
if (scl == REG || scl == AUTO) {
|
|
/* illegal storage class */
|
|
error(8);
|
|
scl = NOSCL;
|
|
}
|
|
} else if (dcs->d_ctx == ARG || dcs->d_ctx == PARG) {
|
|
if (scl != NOSCL && scl != REG) {
|
|
/* only "register" valid ... */
|
|
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");
|
|
/* typedef already qualified with "%s" */
|
|
warning(68, "const");
|
|
}
|
|
if (dcs->d_volatile && dcs->d_type->t_volatile) {
|
|
if (!dcs->d_type->t_typedef)
|
|
lerror("deftyp() 4");
|
|
/* typedef already qualified with "%s" */
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Merge type specifiers (char, ..., long long, signed, unsigned).
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Return the length of a type in bit.
|
|
*
|
|
* Printing a message if the outhermost dimension of an array is 0 must
|
|
* be done by the caller. All other problems are reported by length()
|
|
* if name is not NULL.
|
|
*/
|
|
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:
|
|
/* compiler takes size of function */
|
|
lerror("%s", msgs[12]);
|
|
/* NOTREACHED */
|
|
case STRUCT:
|
|
case UNION:
|
|
if (incompl(tp) && name != NULL) {
|
|
/* incomplete structure or union %s: %s */
|
|
error(31, tp->t_str->stag->s_name, name);
|
|
}
|
|
elsz = tp->t_str->size;
|
|
break;
|
|
case ENUM:
|
|
if (incompl(tp) && name != NULL) {
|
|
/* incomplete enum type: %s */
|
|
warning(13, name);
|
|
}
|
|
/* FALLTHROUGH */
|
|
default:
|
|
elsz = size(tp->t_tspec);
|
|
if (elsz <= 0)
|
|
lerror("length()");
|
|
break;
|
|
}
|
|
return (elem * elsz);
|
|
}
|
|
|
|
/*
|
|
* Get the alignment of the given Type in bits.
|
|
*/
|
|
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) {
|
|
/* compiler takes alignment of function */
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Concatenate two lists of symbols by s_nxt. Used by declarations of
|
|
* struct/union/enum elements and parameters.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Check if the type of the given symbol is valid and print an error
|
|
* message if it is not.
|
|
*
|
|
* Invalid types are:
|
|
* - arrays of incomlete types or functions
|
|
* - functions returning arrays or functions
|
|
* - void types other than type of function or pointer
|
|
*/
|
|
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 this is the type of an old style function definition,
|
|
* a better warning is printed in funcdef().
|
|
*/
|
|
if (t == FUNC && !tp->t_proto &&
|
|
!(to == NOTSPEC && sym->s_osdef)) {
|
|
if (sflag && hflag)
|
|
/* function declaration is not a prototype */
|
|
warning(287);
|
|
}
|
|
if (to == FUNC) {
|
|
if (t == FUNC || t == ARRAY) {
|
|
/* function returns illegal type */
|
|
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) { /* XXX oder better !tflag ? */
|
|
/* function cannot return const... */
|
|
warning(228);
|
|
}
|
|
}
|
|
} if (to == ARRAY) {
|
|
if (t == FUNC) {
|
|
/* array of function is illegal */
|
|
error(16);
|
|
*tpp = gettyp(INT);
|
|
return;
|
|
} else if (t == ARRAY && tp->t_dim == 0) {
|
|
/* null dimension */
|
|
error(17);
|
|
return;
|
|
} else if (t == VOID) {
|
|
/* illegal use of void */
|
|
error(18);
|
|
*tpp = gettyp(INT);
|
|
#if 0 /* errors are produced by length() */
|
|
} else if (incompl(tp)) {
|
|
/* array of incomplete type */
|
|
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()");
|
|
/* void param cannot have name: %s */
|
|
error(61, sym->s_name);
|
|
*tpp = gettyp(INT);
|
|
}
|
|
} else if (dcs->d_ctx == ABSTRACT) {
|
|
/* ok */
|
|
} else if (sym->s_scl != TYPEDEF) {
|
|
/* void type for %s */
|
|
error(19, sym->s_name);
|
|
*tpp = gettyp(INT);
|
|
}
|
|
}
|
|
if (t == VOID && to != PTR) {
|
|
if (tp->t_const || tp->t_volatile) {
|
|
/* inappropriate qualifiers with "void" */
|
|
warning(69);
|
|
tp->t_const = tp->t_volatile = 0;
|
|
}
|
|
}
|
|
tpp = &tp->t_subt;
|
|
to = t;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Process the declarator of a struct/union element.
|
|
*/
|
|
sym_t *
|
|
decl1str(dsym)
|
|
sym_t *dsym;
|
|
{
|
|
type_t *tp;
|
|
tspec_t t;
|
|
int sz, o, len;
|
|
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)
|
|
/* should be ensured by storesym() */
|
|
lerror("decl1str() 2");
|
|
if (dsym->s_styp == dcs->d_rdcsym->s_styp) {
|
|
/* duplicate member name: %s */
|
|
error(33, dsym->s_name);
|
|
rmsym(dcs->d_rdcsym);
|
|
}
|
|
}
|
|
|
|
chktyp(dsym);
|
|
|
|
t = (tp = dsym->s_type)->t_tspec;
|
|
|
|
if (dsym->s_field) {
|
|
/*
|
|
* bit field
|
|
*
|
|
* only unsigned und signed int are protable bit-field types
|
|
*(at least in ANSI C, in traditional C only unsigned int)
|
|
*/
|
|
if (t == CHAR || t == UCHAR || t == SCHAR ||
|
|
t == SHORT || t == USHORT || t == ENUM) {
|
|
if (sflag) {
|
|
/* bit-field type '%s' invalid in ANSI C */
|
|
warning(273, tyname(tp));
|
|
} else if (pflag) {
|
|
/* nonportable bit-field type */
|
|
warning(34);
|
|
}
|
|
} else if (t == INT && dcs->d_smod == NOTSPEC) {
|
|
if (pflag) {
|
|
/* nonportable bit-field type */
|
|
warning(34);
|
|
}
|
|
} else if (t != INT && t != UINT) {
|
|
/* illegal bit-field type */
|
|
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)) {
|
|
/* illegal bit-field size */
|
|
error(36);
|
|
tp->t_flen = size(t);
|
|
} else if (len == 0 && dsym->s_name != unnamed) {
|
|
/* zero size bit-field */
|
|
error(37);
|
|
tp->t_flen = size(t);
|
|
}
|
|
if (dsym->s_scl == MOU) {
|
|
/* illegal use of bit-field */
|
|
error(41);
|
|
dsym->s_type->t_isfield = 0;
|
|
dsym->s_field = 0;
|
|
}
|
|
} else if (t == FUNC) {
|
|
/* function illegal in structure or union */
|
|
error(38);
|
|
dsym->s_type = tp = incref(tp, t = PTR);
|
|
}
|
|
|
|
/*
|
|
* bit-fields of length 0 are not warned about because length()
|
|
* does not return the length of the bit-field but the length
|
|
* of the type the bit-field is packed in (its ok)
|
|
*/
|
|
if ((sz = length(dsym->s_type, dsym->s_name)) == 0) {
|
|
if (t == ARRAY && dsym->s_type->t_dim == 0) {
|
|
/* illegal zero sized structure member: %s */
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Aligns next structure element as required.
|
|
*
|
|
* al contains the required alignment, len the length of a bit-field.
|
|
*/
|
|
static void
|
|
align(al, len)
|
|
int al, len;
|
|
{
|
|
int no;
|
|
|
|
/*
|
|
* The alignment of the current element becomes the alignment of
|
|
* the struct/union if it is larger than the current alignment
|
|
* of the struct/union.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Remember the width of the field in its type structure.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Collect informations about a sequence of asterisks and qualifiers
|
|
* in a list of type pqinf_t.
|
|
* Qualifiers refer always to the left asterisk. The rightmost asterisk
|
|
* will be at the top of the list.
|
|
*/
|
|
pqinf_t *
|
|
mergepq(p1, p2)
|
|
pqinf_t *p1, *p2;
|
|
{
|
|
pqinf_t *p;
|
|
|
|
if (p2->p_pcnt != 0) {
|
|
/* left '*' at the end of the list */
|
|
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) {
|
|
/* duplicate %s */
|
|
warning(10, "const");
|
|
}
|
|
p1->p_const = 1;
|
|
}
|
|
if (p2->p_volatile) {
|
|
if (p1->p_volatile) {
|
|
/* duplicate %s */
|
|
warning(10, "volatile");
|
|
}
|
|
p1->p_volatile = 1;
|
|
}
|
|
free(p2);
|
|
return (p1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Followint 3 functions extend the type of a declarator with
|
|
* pointer, function and array types.
|
|
*
|
|
* The current type is the Type built by deftyp() (dcs->d_type) and
|
|
* pointer, function and array types already added for this
|
|
* declarator. The new type extension is inserted between both.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* If a dimension was specified, dim is 1, otherwise 0
|
|
* n is the specified dimension
|
|
*/
|
|
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) {
|
|
/* zero or negative array dimension */
|
|
error(20);
|
|
n = 0;
|
|
} else if (n == 0 && dim) {
|
|
/* zero or negative array dimension */
|
|
warning(20);
|
|
} else if (n == 0 && !dim) {
|
|
/* is incomplete type */
|
|
setcompl(tp, 1);
|
|
}
|
|
|
|
return (decl);
|
|
}
|
|
|
|
sym_t *
|
|
addfunc(decl, args)
|
|
sym_t *decl, *args;
|
|
{
|
|
type_t **tpp, *tp;
|
|
|
|
if (dcs->d_proto) {
|
|
if (tflag)
|
|
/* function prototypes are illegal in traditional C */
|
|
warning(270);
|
|
args = nsfunc(decl, args);
|
|
} else {
|
|
osfunc(decl, args);
|
|
}
|
|
|
|
/*
|
|
* The symbols are removed from the symbol table by popdecl() after
|
|
* addfunc(). To be able to restore them if this is a function
|
|
* definition, a pointer to the list of all symbols is stored in
|
|
* dcs->d_nxt->d_fpsyms. Also a list of the arguments (concatenated
|
|
* by s_nxt) is stored in dcs->d_nxt->d_fargs.
|
|
* (dcs->d_nxt must be used because *dcs is the declaration stack
|
|
* element created for the list of params and is removed after
|
|
* addfunc())
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Called for new style function declarations.
|
|
*/
|
|
/* ARGSUSED */
|
|
static sym_t *
|
|
nsfunc(decl, args)
|
|
sym_t *decl, *args;
|
|
{
|
|
sym_t *arg, *sym;
|
|
scl_t sc;
|
|
int n;
|
|
|
|
/*
|
|
* Declarations of structs/unions/enums in param lists are legal,
|
|
* but senseless.
|
|
*/
|
|
for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
|
|
sc = sym->s_scl;
|
|
if (sc == STRTAG || sc == UNIONTAG || sc == ENUMTAG) {
|
|
/* dubious tag declaration: %s %s */
|
|
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) {
|
|
/* "void" must be sole parameter */
|
|
error(60);
|
|
arg->s_type = gettyp(INT);
|
|
}
|
|
}
|
|
n++;
|
|
}
|
|
|
|
/* return NULL if first param is VOID */
|
|
return (args != NULL && args->s_type->t_tspec != VOID ? args : NULL);
|
|
}
|
|
|
|
/*
|
|
* Called for old style function declarations.
|
|
*/
|
|
static void
|
|
osfunc(decl, args)
|
|
sym_t *decl, *args;
|
|
{
|
|
/*
|
|
* Remember list of params only if this is really seams to be
|
|
* a function definition.
|
|
*/
|
|
if (dcs->d_nxt->d_ctx == EXTERN &&
|
|
decl->s_type == dcs->d_nxt->d_type) {
|
|
/*
|
|
* We assume that this becomes a function definition. If
|
|
* we are wrong, its corrected in chkfdef().
|
|
*/
|
|
if (args != NULL) {
|
|
decl->s_osdef = 1;
|
|
decl->s_args = args;
|
|
}
|
|
} else {
|
|
if (args != NULL)
|
|
/* function prototype parameters must have types */
|
|
warning(62);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Lists of Identifiers in functions declarations are allowed only if
|
|
* its also a function definition. If this is not the case, print a
|
|
* error message.
|
|
*/
|
|
void
|
|
chkfdef(sym, msg)
|
|
sym_t *sym;
|
|
int msg;
|
|
{
|
|
if (sym->s_osdef) {
|
|
if (msg) {
|
|
/* incomplete or misplaced function definition */
|
|
error(22);
|
|
}
|
|
sym->s_osdef = 0;
|
|
sym->s_args = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Process the name in a declarator.
|
|
* If the symbol does already exists, a new one is created.
|
|
* The symbol becomes one of the storage classes EXTERN, STATIC, AUTO or
|
|
* TYPEDEF.
|
|
* s_def and s_reg are valid after dname().
|
|
*/
|
|
sym_t *
|
|
dname(sym)
|
|
sym_t *sym;
|
|
{
|
|
scl_t sc;
|
|
|
|
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:
|
|
/* Parent setzen */
|
|
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:
|
|
/*
|
|
* static and external symbols without "extern" are
|
|
* considered to be tentative defined, external
|
|
* symbols with "extern" are declared, and typedef names
|
|
* are defined. Tentative defined and declared symbols
|
|
* may become defined if an initializer is present or
|
|
* this is a function definition.
|
|
*/
|
|
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;
|
|
/* FALLTHROUGH */
|
|
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) {
|
|
/*
|
|
* XXX somewhat ugly because we dont know whether
|
|
* this is AUTO or EXTERN (functions). If we are
|
|
* wrong it must be corrected in decl1loc(), where
|
|
* we have the neccessary type information.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Process a name in the list of formal params in an old style function
|
|
* definition.
|
|
*/
|
|
sym_t *
|
|
iname(sym)
|
|
sym_t *sym;
|
|
{
|
|
if (sym->s_scl != NOSCL) {
|
|
if (blklev == sym->s_blklev) {
|
|
/* redeclaration of formal parameter %s */
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Create the type of a tag.
|
|
*
|
|
* tag points to the symbol table entry of the tag
|
|
* kind is the kind of the tag (STRUCT/UNION/ENUM)
|
|
* decl is 1 if the type of the tag will be completed in this declaration
|
|
* (the following token is T_LBRACE)
|
|
* semi is 1 if the following token is T_SEMI
|
|
*/
|
|
type_t *
|
|
mktag(tag, kind, decl, semi)
|
|
sym_t *tag;
|
|
tspec_t kind;
|
|
int decl, semi;
|
|
{
|
|
scl_t scl;
|
|
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 {
|
|
/* a new tag, no empty declaration */
|
|
dcs->d_nxt->d_nedecl = 1;
|
|
if (scl == ENUMTAG && !decl) {
|
|
if (!tflag && (sflag || pflag))
|
|
/* forward reference to enum type */
|
|
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;
|
|
STRUCT_ASSIGN(tag->s_dpos, curr_pos);
|
|
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;
|
|
}
|
|
/* ist unvollstaendiger Typ */
|
|
setcompl(tp, 1);
|
|
}
|
|
|
|
return (tp);
|
|
}
|
|
|
|
/*
|
|
* Checks all possible cases of tag redeclarations.
|
|
* decl is 1 if T_LBRACE follows
|
|
* semi is 1 if T_SEMI follows
|
|
*/
|
|
static sym_t *
|
|
newtag(tag, scl, decl, semi)
|
|
sym_t *tag;
|
|
scl_t scl;
|
|
int decl, semi;
|
|
{
|
|
if (tag->s_blklev < blklev) {
|
|
if (semi) {
|
|
/* "struct a;" */
|
|
if (!tflag) {
|
|
if (!sflag)
|
|
/* decl. introduces new type ... */
|
|
warning(44, scltoa(scl), tag->s_name);
|
|
tag = pushdown(tag);
|
|
} else if (tag->s_scl != scl) {
|
|
/* base type is really "%s %s" */
|
|
warning(45, scltoa(tag->s_scl), tag->s_name);
|
|
}
|
|
dcs->d_nxt->d_nedecl = 1;
|
|
} else if (decl) {
|
|
/* "struct a { ..." */
|
|
if (hflag)
|
|
/* redefinition hides earlier one: %s */
|
|
warning(43, tag->s_name);
|
|
tag = pushdown(tag);
|
|
dcs->d_nxt->d_nedecl = 1;
|
|
} else if (tag->s_scl != scl) {
|
|
/* base type is really "%s %s" */
|
|
warning(45, scltoa(tag->s_scl), tag->s_name);
|
|
/* declaration introduces new type in ANSI C: %s %s */
|
|
if (!sflag)
|
|
warning(44, scltoa(scl), tag->s_name);
|
|
tag = pushdown(tag);
|
|
dcs->d_nxt->d_nedecl = 1;
|
|
}
|
|
} else {
|
|
if (tag->s_scl != scl) {
|
|
/* (%s) tag redeclared */
|
|
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)) {
|
|
/* (%s) tag redeclared */
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Completes the type of a tag in a struct/union/enum declaration.
|
|
* tp points to the type of the, tag, fmem to the list of members/enums.
|
|
*/
|
|
type_t *
|
|
compltag(tp, fmem)
|
|
type_t *tp;
|
|
sym_t *fmem;
|
|
{
|
|
tspec_t t;
|
|
str_t *sp;
|
|
int n;
|
|
sym_t *mem;
|
|
|
|
/* from now a complete type */
|
|
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) {
|
|
/* zero sized %s */
|
|
(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) {
|
|
/* %s has no named members */
|
|
warning(65,
|
|
t == STRUCT ? "structure" : "union");
|
|
}
|
|
}
|
|
} else {
|
|
tp->t_enum->elem = fmem;
|
|
}
|
|
return (tp);
|
|
}
|
|
|
|
/*
|
|
* Processes the name of an enumerator in en enum declaration.
|
|
*
|
|
* sym points to the enumerator
|
|
* val is the value of the enumerator
|
|
* impl is 1 if the the value of the enumerator was not explicit specified.
|
|
*/
|
|
sym_t *
|
|
ename(sym, val, impl)
|
|
sym_t *sym;
|
|
int val, impl;
|
|
{
|
|
if (sym->s_scl) {
|
|
if (sym->s_blklev == blklev) {
|
|
/* no hflag, because this is illegal!!! */
|
|
if (sym->s_arg) {
|
|
/* enumeration constant hides parameter: %s */
|
|
warning(57, sym->s_name);
|
|
} else {
|
|
/* redeclaration of %s */
|
|
error(27, sym->s_name);
|
|
/*
|
|
* inside blocks it should not too complicated
|
|
* to find the position of the previous
|
|
* declaration
|
|
*/
|
|
if (blklev == 0)
|
|
prevdecl(-1, sym);
|
|
}
|
|
} else {
|
|
if (hflag)
|
|
/* redefinition hides earlier one: %s */
|
|
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) {
|
|
/* overflow in enumeration values: %s */
|
|
warning(48, sym->s_name);
|
|
}
|
|
enumval = val + 1;
|
|
return (sym);
|
|
}
|
|
|
|
/*
|
|
* Process a single external declarator.
|
|
*/
|
|
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;
|
|
|
|
/*
|
|
* Declarations of functions are marked as "tentative" in dname().
|
|
* This is wrong because there are no tentative function
|
|
* definitions.
|
|
*/
|
|
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 {
|
|
/* variable declared inline: %s */
|
|
warning(268, dsym->s_name);
|
|
}
|
|
}
|
|
|
|
/* Write the declaration into the output file */
|
|
if (plibflg && llibflg &&
|
|
dsym->s_type->t_tspec == FUNC && dsym->s_type->t_proto) {
|
|
/*
|
|
* With both LINTLIBRARY and PROTOLIB the prototyp is
|
|
* written as a function definition to the output file.
|
|
*/
|
|
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 the old symbol stems from a old style function definition
|
|
* we have remembered the params in rdsmy->s_args and compare
|
|
* them with the params of the prototype.
|
|
*/
|
|
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) {
|
|
/* redeclaration of %s */
|
|
(*(sflag ? error : warning))(27, dsym->s_name);
|
|
prevdecl(-1, rdsym);
|
|
}
|
|
|
|
/*
|
|
* Overtake the rememberd params if the new symbol
|
|
* is not a prototype.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Remember the position of the declaration if the
|
|
* old symbol was a prototype and the new is not.
|
|
* Also remember the position if the old symbol
|
|
* was defined and the new is not.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Copy informations about usage of the name into
|
|
* the new symbol.
|
|
*/
|
|
cpuinfo(dsym, rdsym);
|
|
|
|
/* Once a name is defined, it remains defined. */
|
|
if (rdsym->s_def == DEF)
|
|
dsym->s_def = DEF;
|
|
|
|
/* once a function is inline, it remains inline */
|
|
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);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Copies informations about usage into a new symbol table entry of
|
|
* the same symbol.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Prints an error and returns 1 if a symbol is redeclared/redefined.
|
|
* Otherwise returns 0 and, in some cases of minor problems, prints
|
|
* a warning.
|
|
*/
|
|
int
|
|
isredec(dsym, warn)
|
|
sym_t *dsym;
|
|
int *warn;
|
|
{
|
|
sym_t *rsym;
|
|
|
|
if ((rsym = dcs->d_rdcsym)->s_scl == ENUMCON) {
|
|
/* redeclaration of %s */
|
|
error(27, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
return (1);
|
|
}
|
|
if (rsym->s_scl == TYPEDEF) {
|
|
/* typedef redeclared: %s */
|
|
error(89, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
return (1);
|
|
}
|
|
if (dsym->s_scl == TYPEDEF) {
|
|
/* redeclaration of %s */
|
|
error(27, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
return (1);
|
|
}
|
|
if (rsym->s_def == DEF && dsym->s_def == DEF) {
|
|
/* redefinition of %s */
|
|
error(28, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
return(1);
|
|
}
|
|
if (!eqtype(rsym->s_type, dsym->s_type, 0, 0, warn)) {
|
|
/* redeclaration of %s */
|
|
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) {
|
|
/*
|
|
* All cases except "int a = 1; static int a;" are catched
|
|
* above with or without a warning
|
|
*/
|
|
/* redeclaration of %s */
|
|
error(27, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
return(1);
|
|
}
|
|
if (rsym->s_scl == EXTERN) {
|
|
/* previously declared extern, becomes static: %s */
|
|
warning(29, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
return(0);
|
|
}
|
|
/*
|
|
* Now its on of:
|
|
* "static a; int a;", "static a; int a = 1;", "static a = 1; int a;"
|
|
*/
|
|
/* redeclaration of %s; ANSI C requires "static" */
|
|
if (sflag) {
|
|
warning(30, dsym->s_name);
|
|
prevdecl(-1, rsym);
|
|
}
|
|
dsym->s_scl = STATIC;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Checks if two types are compatible. Returns 0 if not, otherwise 1.
|
|
*
|
|
* ignqual ignore qualifiers of type; used for function params
|
|
* promot promote left type; used for comparison of params of
|
|
* old style function definitions with params of prototypes.
|
|
* *warn set to 1 if an old style function declaration is not
|
|
* compatible with a prototype
|
|
*/
|
|
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) {
|
|
/* CONSTCOND */
|
|
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);
|
|
}
|
|
|
|
/* dont check prototypes for traditional */
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Compares the parameter types of two prototypes.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* mnoarg() (matches functions with no argument type information)
|
|
* returns 1 if all parameters of a prototype are compatible with
|
|
* and old style function declaration.
|
|
* This is the case if following conditions are met:
|
|
* 1. the prototype must have a fixed number of parameters
|
|
* 2. no parameter is of type float
|
|
* 3. no parameter is converted to another type if integer promotion
|
|
* is applied on it
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Compares a prototype declaration with the remembered arguments of
|
|
* a previous old style function definition.
|
|
*/
|
|
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) {
|
|
/* prototype does not match old-style definition */
|
|
error(63);
|
|
msg = 1;
|
|
goto end;
|
|
}
|
|
|
|
arg = args;
|
|
parg = pargs;
|
|
n = 1;
|
|
while (narg--) {
|
|
warn = 0;
|
|
/*
|
|
* If it does not match due to promotion and sflag is
|
|
* not set we print only a warning.
|
|
*/
|
|
if (!eqtype(arg->s_type, parg->s_type, 1, 1, &warn) || warn) {
|
|
/* prototype does not match old-style def., arg #%d */
|
|
error(299, n);
|
|
msg = 1;
|
|
}
|
|
arg = arg->s_nxt;
|
|
parg = parg->s_nxt;
|
|
n++;
|
|
}
|
|
|
|
end:
|
|
if (msg)
|
|
/* old style definition */
|
|
prevdecl(300, rdsym);
|
|
|
|
return (msg);
|
|
}
|
|
|
|
/*
|
|
* Complets a type by copying the dimension and prototype information
|
|
* from a second compatible type.
|
|
*
|
|
* Following lines are legal:
|
|
* "typedef a[]; a b; a b[10]; a c; a c[20];"
|
|
* "typedef ft(); ft f; f(int); ft g; g(long);"
|
|
* This means that, if a type is completed, the type structure must
|
|
* be duplicated.
|
|
*/
|
|
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;
|
|
/* now a complete Typ */
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Completes the declaration of a single argument.
|
|
*/
|
|
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) {
|
|
/* redeclaration of formal parameter %s */
|
|
error(237, sym->s_name);
|
|
rmsym(dcs->d_rdcsym);
|
|
sym->s_arg = 1;
|
|
}
|
|
|
|
if (!sym->s_arg) {
|
|
/* declared argument %s is missing */
|
|
error(53, sym->s_name);
|
|
sym->s_arg = 1;
|
|
}
|
|
|
|
if (initflg) {
|
|
/* cannot initialize parameter: %s */
|
|
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)
|
|
/* a function is declared as an argument: %s */
|
|
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)
|
|
/* argument declared inline: %s */
|
|
warning(269, sym->s_name);
|
|
|
|
/*
|
|
* Arguments must have complete types. lengths() prints the needed
|
|
* error messages (null dimension is impossible because arrays are
|
|
* converted to pointers).
|
|
*/
|
|
if (sym->s_type->t_tspec != VOID)
|
|
(void)length(sym->s_type, sym->s_name);
|
|
|
|
setsflg(sym);
|
|
|
|
return (sym);
|
|
}
|
|
|
|
/*
|
|
* Does some checks for lint directives which apply to functions.
|
|
* Processes arguments in old style function definitions which default
|
|
* to int.
|
|
* Checks compatiblility of old style function definition with previous
|
|
* prototype.
|
|
*/
|
|
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;
|
|
|
|
/* check for illegal combinations of lint directives */
|
|
if (prflstrg != -1 && scflstrg != -1) {
|
|
/* can't be used together: ** PRINTFLIKE ** ** SCANFLIKE ** */
|
|
warning(289);
|
|
prflstrg = scflstrg = -1;
|
|
}
|
|
if (nvararg != -1 && (prflstrg != -1 || scflstrg != -1)) {
|
|
/* dubious use of ** VARARGS ** with ** %s ** */
|
|
warning(288, prflstrg != -1 ? "PRINTFLIKE" : "SCANFLIKE");
|
|
nvararg = -1;
|
|
}
|
|
|
|
/*
|
|
* check if the argument of a lint directive is compatible with the
|
|
* number of arguments.
|
|
*/
|
|
narg = 0;
|
|
for (arg = dcs->d_fargs; arg != NULL; arg = arg->s_nxt)
|
|
narg++;
|
|
if (nargusg > narg) {
|
|
/* argument number mismatch with directive: ** %s ** */
|
|
warning(283, "ARGSUSED");
|
|
nargusg = 0;
|
|
}
|
|
if (nvararg > narg) {
|
|
/* argument number mismatch with directive: ** %s ** */
|
|
warning(283, "VARARGS");
|
|
nvararg = 0;
|
|
}
|
|
if (prflstrg > narg) {
|
|
/* argument number mismatch with directive: ** %s ** */
|
|
warning(283, "PRINTFLIKE");
|
|
prflstrg = -1;
|
|
} else if (prflstrg == 0) {
|
|
prflstrg = -1;
|
|
}
|
|
if (scflstrg > narg) {
|
|
/* argument number mismatch with directive: ** %s ** */
|
|
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)) {
|
|
/* arg. %d must be 'char *' for PRINTFLIKE/SCANFLIKE */
|
|
warning(293, narg);
|
|
prflstrg = scflstrg = -1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* print a warning for each argument off an old style function
|
|
* definition which defaults to int
|
|
*/
|
|
for (arg = args; arg != NULL; arg = arg->s_nxt) {
|
|
if (arg->s_defarg) {
|
|
/* argument type defaults to int: %s */
|
|
warning(32, arg->s_name);
|
|
arg->s_defarg = 0;
|
|
setsflg(arg);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If this is an old style function definition and a prototyp
|
|
* exists, compare the types of arguments.
|
|
*/
|
|
if (funcsym->s_osdef && funcsym->s_type->t_proto) {
|
|
/*
|
|
* If the number of arguments does not macht, we need not
|
|
* continue.
|
|
*/
|
|
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) {
|
|
/* parameter mismatch: %d declared, %d defined */
|
|
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)
|
|
/* prototype declaration */
|
|
prevdecl(285, dcs->d_rdcsym);
|
|
|
|
/* from now the prototype is valid */
|
|
funcsym->s_osdef = 0;
|
|
funcsym->s_args = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Checks compatibility of an old style function definition with a previous
|
|
* prototype declaration.
|
|
* Returns 1 if the position of the previous declaration should be reported.
|
|
*/
|
|
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)) {
|
|
/* type does not match prototype: %s */
|
|
msg = gnuism(58, arg->s_name);
|
|
} else {
|
|
/* type does not match prototype: %s */
|
|
error(58, arg->s_name);
|
|
msg = 1;
|
|
}
|
|
} else if (warn) {
|
|
/* type does not match prototype: %s */
|
|
(*(sflag ? error : warning))(58, arg->s_name);
|
|
msg = 1;
|
|
}
|
|
|
|
return (msg);
|
|
}
|
|
|
|
/*
|
|
* Completes a single local declaration/definition.
|
|
*/
|
|
void
|
|
decl1loc(dsym, initflg)
|
|
sym_t *dsym;
|
|
int initflg;
|
|
{
|
|
/* Correct a mistake done in dname(). */
|
|
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) {
|
|
/* dubious static function at block level: %s */
|
|
warning(93, dsym->s_name);
|
|
dsym->s_scl = EXTERN;
|
|
} else if (dsym->s_scl != EXTERN && dsym->s_scl != TYPEDEF) {
|
|
/* function has illegal storage class: %s */
|
|
error(94, dsym->s_name);
|
|
dsym->s_scl = EXTERN;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* functions may be declared inline at local scope, although
|
|
* this has no effect for a later definition of the same
|
|
* function.
|
|
* XXX it should have an effect if tflag is set. this would
|
|
* also be the way gcc behaves.
|
|
*/
|
|
if (dcs->d_inline) {
|
|
if (dsym->s_type->t_tspec == FUNC) {
|
|
dsym->s_inline = 1;
|
|
} else {
|
|
/* variable declared inline: %s */
|
|
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) {
|
|
/*
|
|
* XXX wenn die statische Variable auf Ebene 0 erst
|
|
* spaeter definiert wird, haben wir die Brille auf.
|
|
*/
|
|
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:
|
|
/* automatic hides external declaration: %s */
|
|
if (hflag)
|
|
warning(86, dsym->s_name);
|
|
break;
|
|
case STATIC:
|
|
/* static hides external declaration: %s */
|
|
if (hflag)
|
|
warning(87, dsym->s_name);
|
|
break;
|
|
case TYPEDEF:
|
|
/* typedef hides external declaration: %s */
|
|
if (hflag)
|
|
warning(88, dsym->s_name);
|
|
break;
|
|
case EXTERN:
|
|
/*
|
|
* Warnings and errors are printed in ledecl()
|
|
*/
|
|
break;
|
|
default:
|
|
lerror("decl1loc() 1");
|
|
}
|
|
|
|
} else if (dcs->d_rdcsym->s_blklev == blklev) {
|
|
|
|
/* no hflag, because its illegal! */
|
|
if (dcs->d_rdcsym->s_arg) {
|
|
/*
|
|
* if !tflag, a "redeclaration of %s" error
|
|
* is produced below
|
|
*/
|
|
if (tflag) {
|
|
if (hflag)
|
|
/* decl. hides parameter: %s */
|
|
warning(91, dsym->s_name);
|
|
rmsym(dcs->d_rdcsym);
|
|
}
|
|
}
|
|
|
|
} else if (dcs->d_rdcsym->s_blklev < blklev) {
|
|
|
|
if (hflag)
|
|
/* declaration hides earlier one: %s */
|
|
warning(95, dsym->s_name);
|
|
|
|
}
|
|
|
|
if (dcs->d_rdcsym->s_blklev == blklev) {
|
|
|
|
/* redeclaration of %s */
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Before we can check the size we must wait for a initialisation
|
|
* which may follow.
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* Processes (re)declarations of external Symbols inside blocks.
|
|
*/
|
|
static void
|
|
ledecl(dsym)
|
|
sym_t *dsym;
|
|
{
|
|
int eqt, warn;
|
|
sym_t *esym;
|
|
|
|
/* look for a symbol with the same name */
|
|
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) {
|
|
/* gcc accepts this without a warning, pcc prints an error. */
|
|
/* redeclaration of %s */
|
|
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) {
|
|
/* inconsistent redeclaration of extern: %s */
|
|
warning(90, dsym->s_name);
|
|
prevdecl(-1, esym);
|
|
} else {
|
|
/* inconsistent redeclaration of static: %s */
|
|
warning(92, dsym->s_name);
|
|
prevdecl(-1, esym);
|
|
}
|
|
}
|
|
|
|
if (eqt) {
|
|
/*
|
|
* Remember the external symbol so we can update usage
|
|
* information at the end of the block.
|
|
*/
|
|
dsym->s_xsym = esym;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Print an error or a warning if the symbol cant be initialized due
|
|
* to type/storage class. Returnvalue is 1 if an error has been
|
|
* detected.
|
|
*/
|
|
static int
|
|
chkinit(sym)
|
|
sym_t *sym;
|
|
{
|
|
int err;
|
|
|
|
err = 0;
|
|
|
|
if (sym->s_type->t_tspec == FUNC) {
|
|
/* cannot initialize function: %s */
|
|
error(24, sym->s_name);
|
|
err = 1;
|
|
} else if (sym->s_scl == TYPEDEF) {
|
|
/* cannot initialize typedef: %s */
|
|
error(25, sym->s_name);
|
|
err = 1;
|
|
} else if (sym->s_scl == EXTERN && sym->s_def == DECL) {
|
|
/* cannot initialize "extern" declaration: %s */
|
|
if (dcs->d_ctx == EXTERN) {
|
|
warning(26, sym->s_name);
|
|
} else {
|
|
error(26, sym->s_name);
|
|
err = 1;
|
|
}
|
|
}
|
|
|
|
return (err);
|
|
}
|
|
|
|
/*
|
|
* Create a symbole for an abstract declaration.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Removes anything which has nothing to do on global level.
|
|
*/
|
|
void
|
|
globclup()
|
|
{
|
|
while (dcs->d_nxt != NULL)
|
|
popdecl();
|
|
|
|
cleanup();
|
|
blklev = 0;
|
|
mblklev = 0;
|
|
|
|
/*
|
|
* remove all informations about pending lint directives without
|
|
* warnings.
|
|
*/
|
|
glclup(1);
|
|
}
|
|
|
|
/*
|
|
* Process an abstract type declaration
|
|
*/
|
|
sym_t *
|
|
decl1abs(sym)
|
|
sym_t *sym;
|
|
{
|
|
chkfdef(sym, 1);
|
|
chktyp(sym);
|
|
return (sym);
|
|
}
|
|
|
|
/*
|
|
* Checks size after declarations of variables and their initialisation.
|
|
*/
|
|
void
|
|
chksz(dsym)
|
|
sym_t *dsym;
|
|
{
|
|
/*
|
|
* check size only for symbols which are defined and no function and
|
|
* not typedef name
|
|
*/
|
|
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) {
|
|
/* empty array declaration: %s */
|
|
if (tflag) {
|
|
warning(190, dsym->s_name);
|
|
} else {
|
|
error(190, dsym->s_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Mark an object as set if it is not already
|
|
*/
|
|
void
|
|
setsflg(sym)
|
|
sym_t *sym;
|
|
{
|
|
if (!sym->s_set) {
|
|
sym->s_set = 1;
|
|
STRUCT_ASSIGN(sym->s_spos, curr_pos);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Mark an object as used if it is not already
|
|
*/
|
|
void
|
|
setuflg(sym, fcall, szof)
|
|
sym_t *sym;
|
|
int fcall, szof;
|
|
{
|
|
if (!sym->s_used) {
|
|
sym->s_used = 1;
|
|
STRUCT_ASSIGN(sym->s_upos, curr_pos);
|
|
}
|
|
/*
|
|
* for function calls another record is written
|
|
*
|
|
* XXX Should symbols used in sizeof() treated as used or not?
|
|
* Probably not, because there is no sense to declare an
|
|
* external variable only to get their size.
|
|
*/
|
|
if (!fcall && !szof && sym->s_kind == FVFT && sym->s_scl == EXTERN)
|
|
outusg(sym);
|
|
}
|
|
|
|
/*
|
|
* Prints warnings for a list of variables and labels (concatenated
|
|
* with s_dlnxt) if these are not used or only set.
|
|
*/
|
|
void
|
|
chkusage(di)
|
|
dinfo_t *di;
|
|
{
|
|
sym_t *sym;
|
|
int mknowarn;
|
|
|
|
/* for this warnings LINTED has no effect */
|
|
mknowarn = nowarn;
|
|
nowarn = 0;
|
|
|
|
for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_dlnxt)
|
|
chkusg1(di->d_asm, sym);
|
|
|
|
nowarn = mknowarn;
|
|
}
|
|
|
|
/*
|
|
* Prints a warning for a single variable or label if it is not used or
|
|
* only set.
|
|
*/
|
|
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);
|
|
/* argument %s unused in function %s */
|
|
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");
|
|
|
|
/* errors in expressions easily cause lots of these warnings */
|
|
if (nerr != 0)
|
|
return;
|
|
|
|
/*
|
|
* XXX Only variables are checkd, although types should
|
|
* probably also be checked
|
|
*/
|
|
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);
|
|
/* %s unused in function %s */
|
|
warning(192, sym->s_name, funcsym->s_name);
|
|
}
|
|
} else {
|
|
if (sym->s_set && !sym->s_used) {
|
|
STRUCT_ASSIGN(curr_pos, sym->s_spos);
|
|
/* %s set but not used in function %s */
|
|
warning(191, sym->s_name, funcsym->s_name);
|
|
} else if (!sym->s_used) {
|
|
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
|
|
/* %s unused in function %s */
|
|
warning(192, sym->s_name, funcsym->s_name);
|
|
}
|
|
}
|
|
|
|
if (sc == EXTERN) {
|
|
/*
|
|
* information about usage is taken over into the symbol
|
|
* tabel entry at level 0 if the symbol was locally declared
|
|
* as an external symbol.
|
|
*
|
|
* XXX This is wrong for symbols declared static at level 0
|
|
* if the usage information stems from sizeof(). This is
|
|
* because symbols at level 0 only used in sizeof() are
|
|
* considered to not be used.
|
|
*/
|
|
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);
|
|
/* label %s unused in function %s */
|
|
warning(192, lab->s_name, funcsym->s_name);
|
|
} else if (!lab->s_set) {
|
|
STRUCT_ASSIGN(curr_pos, lab->s_upos);
|
|
/* undefined label %s */
|
|
warning(23, lab->s_name);
|
|
}
|
|
}
|
|
|
|
static void
|
|
chktusg(sym)
|
|
sym_t *sym;
|
|
{
|
|
if (!incompl(sym->s_type))
|
|
return;
|
|
|
|
/* complain alwasy about incomplet tags declared inside blocks */
|
|
if (!zflag || dcs->d_ctx != EXTERN)
|
|
return;
|
|
|
|
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
|
|
switch (sym->s_type->t_tspec) {
|
|
case STRUCT:
|
|
/* struct %s never defined */
|
|
warning(233, sym->s_name);
|
|
break;
|
|
case UNION:
|
|
/* union %s never defined */
|
|
warning(234, sym->s_name);
|
|
break;
|
|
case ENUM:
|
|
/* enum %s never defined */
|
|
warning(235, sym->s_name);
|
|
break;
|
|
default:
|
|
lerror("chktusg() 1");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called after the entire translation unit has been parsed.
|
|
* Changes tentative definitions in definitions.
|
|
* Performs some tests on global Symbols. Detected Problems are:
|
|
* - defined variables of incomplete type
|
|
* - constant variables which are not initialized
|
|
* - static symbols which are never used
|
|
*/
|
|
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);
|
|
/* static func. called but not def.. */
|
|
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)
|
|
/* static function %s unused */
|
|
warning(236, sym->s_name);
|
|
} else {
|
|
/* static function %s decl. but ... */
|
|
warning(290, sym->s_name);
|
|
}
|
|
} else if (!sym->s_set) {
|
|
/* static variable %s unused */
|
|
warning(226, sym->s_name);
|
|
} else {
|
|
/* static variable %s set but not used */
|
|
warning(307, sym->s_name);
|
|
}
|
|
}
|
|
if (!tflag && sym->s_def == TDEF && sym->s_type->t_const) {
|
|
STRUCT_ASSIGN(curr_pos, sym->s_dpos);
|
|
/* const object %s should have initializer */
|
|
warning(227, sym->s_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
glchksz(sym)
|
|
sym_t *sym;
|
|
{
|
|
if (sym->s_def == TDEF) {
|
|
if (sym->s_type->t_tspec == FUNC)
|
|
/*
|
|
* this can happen if an syntax error occured
|
|
* after a function declaration
|
|
*/
|
|
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) {
|
|
/* empty array declaration: %s */
|
|
if (tflag || (sym->s_scl == EXTERN && !sflag)) {
|
|
warning(190, sym->s_name);
|
|
} else {
|
|
error(190, sym->s_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Prints information about location of previous definition/declaration.
|
|
*/
|
|
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) {
|
|
/* previous definition of %s */
|
|
message(261, psym->s_name);
|
|
} else {
|
|
/* previous declaration of %s */
|
|
message(260, psym->s_name);
|
|
}
|
|
STRUCT_ASSIGN(curr_pos, cpos);
|
|
}
|