From a9c0aaa0e8a6efa66f2c4364b24f1bf7520d9a53 Mon Sep 17 00:00:00 2001 From: markm Date: Sun, 3 Mar 2002 13:17:00 +0000 Subject: Import of NetBSD's (x)lint, snapshotted at 2002-3-3. --- usr.bin/xlint/Makefile | 2 +- usr.bin/xlint/Makefile.inc | 21 ++ usr.bin/xlint/arch/alpha/targparam.h | 53 +++ usr.bin/xlint/arch/amd64/targparam.h | 53 +++ usr.bin/xlint/arch/arm/targparam.h | 63 ++++ usr.bin/xlint/arch/i386/targparam.h | 53 +++ usr.bin/xlint/arch/m68000/targparam.h | 53 +++ usr.bin/xlint/arch/m68k/targparam.h | 53 +++ usr.bin/xlint/arch/mips/targparam.h | 53 +++ usr.bin/xlint/arch/ns32k/targparam.h | 53 +++ usr.bin/xlint/arch/powerpc/targparam.h | 53 +++ usr.bin/xlint/arch/sh3/targparam.h | 53 +++ usr.bin/xlint/arch/sparc/targparam.h | 53 +++ usr.bin/xlint/arch/sparc64/targparam.h | 53 +++ usr.bin/xlint/arch/vax/targparam.h | 53 +++ usr.bin/xlint/arch/x86_64/targparam.h | 53 +++ usr.bin/xlint/common/emit.c | 234 +++++++++++++ usr.bin/xlint/common/externs.h | 66 ++++ usr.bin/xlint/common/ilp32.h | 59 ++++ usr.bin/xlint/common/inittyp.c | 133 +++++++ usr.bin/xlint/common/lint.h | 126 +++++++ usr.bin/xlint/common/lp64.h | 59 ++++ usr.bin/xlint/common/mem.c | 88 +++++ usr.bin/xlint/common/param.h | 88 +++++ usr.bin/xlint/lint1/Makefile | 58 +++- usr.bin/xlint/lint1/cgram.y | 210 ++++++++--- usr.bin/xlint/lint1/decl.c | 521 ++++++++++++---------------- usr.bin/xlint/lint1/emit1.c | 73 ++-- usr.bin/xlint/lint1/err.c | 128 +++---- usr.bin/xlint/lint1/externs1.h | 308 +++++++++-------- usr.bin/xlint/lint1/func.c | 180 +++++----- usr.bin/xlint/lint1/init.c | 53 +-- usr.bin/xlint/lint1/lint1.h | 50 ++- usr.bin/xlint/lint1/main1.c | 70 +++- usr.bin/xlint/lint1/makeman | 94 +++++ usr.bin/xlint/lint1/mem1.c | 80 ++--- usr.bin/xlint/lint1/op.h | 2 +- usr.bin/xlint/lint1/scan.l | 297 +++++++++------- usr.bin/xlint/lint1/tree.c | 611 ++++++++++++++++----------------- usr.bin/xlint/lint2/Makefile | 21 +- usr.bin/xlint/lint2/chk.c | 302 +++++----------- usr.bin/xlint/lint2/emit2.c | 103 ++++-- usr.bin/xlint/lint2/externs2.h | 36 +- usr.bin/xlint/lint2/hash.c | 79 ++++- usr.bin/xlint/lint2/lint2.h | 25 +- usr.bin/xlint/lint2/main2.c | 26 +- usr.bin/xlint/lint2/mem2.c | 18 +- usr.bin/xlint/lint2/msg.c | 40 +-- usr.bin/xlint/lint2/read.c | 278 ++++++++++----- usr.bin/xlint/llib/Makefile | 20 +- usr.bin/xlint/llib/llib-lposix | 2 +- usr.bin/xlint/llib/llib-lstdc | 2 +- usr.bin/xlint/xlint/Makefile | 21 +- usr.bin/xlint/xlint/lint.1 | 161 +++++++-- usr.bin/xlint/xlint/pathnames.h | 7 +- usr.bin/xlint/xlint/xlint.c | 427 ++++++++++++++--------- 56 files changed, 4045 insertions(+), 1886 deletions(-) create mode 100644 usr.bin/xlint/Makefile.inc create mode 100644 usr.bin/xlint/arch/alpha/targparam.h create mode 100644 usr.bin/xlint/arch/amd64/targparam.h create mode 100644 usr.bin/xlint/arch/arm/targparam.h create mode 100644 usr.bin/xlint/arch/i386/targparam.h create mode 100644 usr.bin/xlint/arch/m68000/targparam.h create mode 100644 usr.bin/xlint/arch/m68k/targparam.h create mode 100644 usr.bin/xlint/arch/mips/targparam.h create mode 100644 usr.bin/xlint/arch/ns32k/targparam.h create mode 100644 usr.bin/xlint/arch/powerpc/targparam.h create mode 100644 usr.bin/xlint/arch/sh3/targparam.h create mode 100644 usr.bin/xlint/arch/sparc/targparam.h create mode 100644 usr.bin/xlint/arch/sparc64/targparam.h create mode 100644 usr.bin/xlint/arch/vax/targparam.h create mode 100644 usr.bin/xlint/arch/x86_64/targparam.h create mode 100644 usr.bin/xlint/common/emit.c create mode 100644 usr.bin/xlint/common/externs.h create mode 100644 usr.bin/xlint/common/ilp32.h create mode 100644 usr.bin/xlint/common/inittyp.c create mode 100644 usr.bin/xlint/common/lint.h create mode 100644 usr.bin/xlint/common/lp64.h create mode 100644 usr.bin/xlint/common/mem.c create mode 100644 usr.bin/xlint/common/param.h create mode 100644 usr.bin/xlint/lint1/makeman diff --git a/usr.bin/xlint/Makefile b/usr.bin/xlint/Makefile index 01557ad..4ffb2dd 100644 --- a/usr.bin/xlint/Makefile +++ b/usr.bin/xlint/Makefile @@ -1,4 +1,4 @@ -# $NetBSD: Makefile,v 1.2 1995/07/03 21:23:45 cgd Exp $ +# $NetBSD$ SUBDIR= lint1 lint2 xlint llib diff --git a/usr.bin/xlint/Makefile.inc b/usr.bin/xlint/Makefile.inc new file mode 100644 index 0000000..0a31de2 --- /dev/null +++ b/usr.bin/xlint/Makefile.inc @@ -0,0 +1,21 @@ +# $NetBSD: Makefile.inc,v 1.8 2002/02/04 00:18:32 thorpej Exp $ + +.include + +.PATH: ${.CURDIR}/../common + +# On the m68000, MACHINE_CPU is "m68k", but we have different +# target parameters (namely, long double is a different size +# on the m68000), so we special case the directory name here. +.if ${MACHINE_ARCH} == "m68000" +ARCHSUBDIR= m68000 +.else +ARCHSUBDIR= ${MACHINE_CPU} +.endif + +CPPFLAGS+= -I${.CURDIR}/../arch/${ARCHSUBDIR} +CPPFLAGS+= -I${.CURDIR}/../common + +.if exists(${.CURDIR}/../../Makefile.inc) +.include "${.CURDIR}/../../Makefile.inc" +.endif diff --git a/usr.bin/xlint/arch/alpha/targparam.h b/usr.bin/xlint/arch/alpha/targparam.h new file mode 100644 index 0000000..e31168e --- /dev/null +++ b/usr.bin/xlint/arch/alpha/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:18 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "lp64.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 1 +#define SIZEOF_IS_ULONG 1 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/amd64/targparam.h b/usr.bin/xlint/arch/amd64/targparam.h new file mode 100644 index 0000000..8d57fbd --- /dev/null +++ b/usr.bin/xlint/arch/amd64/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.2 2002/01/30 06:55:00 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "lp64.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 1 +#define SIZEOF_IS_ULONG 1 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (16 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/arm/targparam.h b/usr.bin/xlint/arch/arm/targparam.h new file mode 100644 index 0000000..d1d6f94 --- /dev/null +++ b/usr.bin/xlint/arch/arm/targparam.h @@ -0,0 +1,63 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:19 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#if defined(TARGET_OBJFMT_ELF) +#define PTRDIFF_IS_LONG 1 +#define SIZEOF_IS_ULONG 1 +#else +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 +#endif + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#if defined(TARGET_OBJFMT_ELF) +/* XXX ARM ELF ABI says packed enums -- variable size! */ +#define ENUM_SIZE (4 * CHAR_BIT) +#else +#define ENUM_SIZE (4 * CHAR_BIT) +#endif diff --git a/usr.bin/xlint/arch/i386/targparam.h b/usr.bin/xlint/arch/i386/targparam.h new file mode 100644 index 0000000..86dfb19 --- /dev/null +++ b/usr.bin/xlint/arch/i386/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:19 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (12 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/m68000/targparam.h b/usr.bin/xlint/arch/m68000/targparam.h new file mode 100644 index 0000000..f79777d --- /dev/null +++ b/usr.bin/xlint/arch/m68000/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD$ */ + +/* + * 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/m68k/targparam.h b/usr.bin/xlint/arch/m68k/targparam.h new file mode 100644 index 0000000..86dfb19 --- /dev/null +++ b/usr.bin/xlint/arch/m68k/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:19 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (12 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/mips/targparam.h b/usr.bin/xlint/arch/mips/targparam.h new file mode 100644 index 0000000..7b6e056 --- /dev/null +++ b/usr.bin/xlint/arch/mips/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:19 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/ns32k/targparam.h b/usr.bin/xlint/arch/ns32k/targparam.h new file mode 100644 index 0000000..f6b3308 --- /dev/null +++ b/usr.bin/xlint/arch/ns32k/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:20 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (12 * CHAR_BIT) /* XXX double-check */ + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/powerpc/targparam.h b/usr.bin/xlint/arch/powerpc/targparam.h new file mode 100644 index 0000000..d49eb76 --- /dev/null +++ b/usr.bin/xlint/arch/powerpc/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:20 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/sh3/targparam.h b/usr.bin/xlint/arch/sh3/targparam.h new file mode 100644 index 0000000..d49eb76 --- /dev/null +++ b/usr.bin/xlint/arch/sh3/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:20 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/sparc/targparam.h b/usr.bin/xlint/arch/sparc/targparam.h new file mode 100644 index 0000000..c0eabbd --- /dev/null +++ b/usr.bin/xlint/arch/sparc/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:21 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 1 +#define SIZEOF_IS_ULONG 1 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/sparc64/targparam.h b/usr.bin/xlint/arch/sparc64/targparam.h new file mode 100644 index 0000000..8d57fbd --- /dev/null +++ b/usr.bin/xlint/arch/sparc64/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.2 2002/01/30 06:55:00 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "lp64.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 1 +#define SIZEOF_IS_ULONG 1 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (16 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/vax/targparam.h b/usr.bin/xlint/arch/vax/targparam.h new file mode 100644 index 0000000..261369d --- /dev/null +++ b/usr.bin/xlint/arch/vax/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:22 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "ilp32.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 0 +#define SIZEOF_IS_ULONG 0 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (8 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/arch/x86_64/targparam.h b/usr.bin/xlint/arch/x86_64/targparam.h new file mode 100644 index 0000000..6cfedcb --- /dev/null +++ b/usr.bin/xlint/arch/x86_64/targparam.h @@ -0,0 +1,53 @@ +/* $NetBSD: targparam.h,v 1.1 2002/01/18 20:39:22 thorpej 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. + */ + +/* + * Machine-dependent target parameters for lint1. + */ + +#include "lp64.h" + +/* + * Should be set to 1 if the difference of two pointers is of type long + * or the value of sizeof is of type unsigned long. Note this MUST be + * kept in sync with the compiler! + */ + +#define PTRDIFF_IS_LONG 1 +#define SIZEOF_IS_ULONG 1 + +#define FLOAT_SIZE (4 * CHAR_BIT) +#define DOUBLE_SIZE (8 * CHAR_BIT) +#define LDOUBLE_SIZE (16 * CHAR_BIT) + +#define ENUM_SIZE (4 * CHAR_BIT) diff --git a/usr.bin/xlint/common/emit.c b/usr.bin/xlint/common/emit.c new file mode 100644 index 0000000..9413433 --- /dev/null +++ b/usr.bin/xlint/common/emit.c @@ -0,0 +1,234 @@ +/* $NetBSD: emit.c,v 1.2 2002/01/21 19:49:51 tv 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. + */ + +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: emit.c,v 1.2 2002/01/21 19:49:51 tv Exp $"); +#endif + +#include +#include +#include + +#include "lint.h" + +/* name and handle of output file */ +static const char *loname; +static FILE *lout; + +/* output buffer data */ +ob_t ob; + +static void outxbuf(void); + + +/* + * initialize output + */ +void +outopen(const char *name) +{ + + loname = name; + + /* Open output file */ + if ((lout = fopen(name, "w")) == NULL) + err(1, "cannot open '%s'", name); + + /* Create output buffer */ + ob.o_len = 1024; + ob.o_end = (ob.o_buf = ob.o_nxt = xmalloc(ob.o_len)) + ob.o_len; +} + +/* + * flush output buffer and close file + */ +void +outclose(void) +{ + + outclr(); + if (fclose(lout) == EOF) + err(1, "cannot close '%s'", loname); +} + +/* + * resize output buffer + */ +static void +outxbuf(void) +{ + ptrdiff_t coffs; + + coffs = ob.o_nxt - ob.o_buf; + ob.o_len *= 2; + ob.o_end = (ob.o_buf = xrealloc(ob.o_buf, ob.o_len)) + ob.o_len; + ob.o_nxt = ob.o_buf + coffs; +} + +/* + * reset output buffer + * if it is not empty, it is flushed + */ +void +outclr(void) +{ + size_t sz; + + if (ob.o_buf != ob.o_nxt) { + outchar('\n'); + sz = ob.o_nxt - ob.o_buf; + if (sz > ob.o_len) + errx(1, "internal error: outclr() 1"); + if (fwrite(ob.o_buf, sz, 1, lout) != 1) + err(1, "cannot write to %s", loname); + ob.o_nxt = ob.o_buf; + } +} + +/* + * write a character to the output buffer + */ +void +outchar(int c) +{ + + if (ob.o_nxt == ob.o_end) + outxbuf(); + *ob.o_nxt++ = (char)c; +} + +/* + * write a character to the output buffer, qouted if necessary + */ +void +outqchar(int c) +{ + + if (isprint(c) && c != '\\' && c != '"' && c != '\'') { + outchar(c); + } else { + outchar('\\'); + switch (c) { + case '\\': + outchar('\\'); + break; + case '"': + outchar('"'); + break; + case '\'': + outchar('\''); + break; + case '\b': + outchar('b'); + break; + case '\t': + outchar('t'); + break; + case '\n': + outchar('n'); + break; + case '\f': + outchar('f'); + break; + case '\r': + outchar('r'); + break; + case '\v': + outchar('v'); + break; + case '\a': + outchar('a'); + break; + default: + outchar((((u_int)c >> 6) & 07) + '0'); + outchar((((u_int)c >> 3) & 07) + '0'); + outchar((c & 07) + '0'); + break; + } + } +} + +/* + * write a strint to the output buffer + * the string must not contain any characters which + * should be quoted + */ +void +outstrg(const char *s) +{ + + while (*s != '\0') { + if (ob.o_nxt == ob.o_end) + outxbuf(); + *ob.o_nxt++ = *s++; + } +} + +/* + * write an integer value to toe output buffer + */ +void +outint(int i) +{ + + if ((ob.o_end - ob.o_nxt) < 3 * sizeof (int)) + outxbuf(); + ob.o_nxt += sprintf(ob.o_nxt, "%d", i); +} + +/* + * write the name of a symbol to the output buffer + * the name is preceded by its length + */ +void +outname(const char *name) +{ + + if (name == NULL) + errx(1, "internal error: outname() 1"); + outint((int)strlen(name)); + outstrg(name); +} + +/* + * write the name of the .c source + */ +void +outsrc(const char *name) +{ + + outclr(); + outchar('S'); + outstrg(name); +} diff --git a/usr.bin/xlint/common/externs.h b/usr.bin/xlint/common/externs.h new file mode 100644 index 0000000..8c454b4 --- /dev/null +++ b/usr.bin/xlint/common/externs.h @@ -0,0 +1,66 @@ +/* $NetBSD: externs.h,v 1.1 2002/01/18 20:39:23 thorpej 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. + */ + +/* + * main[12].c + */ +extern int pflag; + +/* + * inittyp.c + */ +extern void inittyp(void); + +/* + * mem.c + */ +extern void *xmalloc(size_t); +extern void *xcalloc(size_t, size_t); +extern void *xrealloc(void *, size_t); +extern char *xstrdup(const char *); +extern void nomem(void); + +/* + * emit.c + */ +extern ob_t ob; + +extern void outopen(const char *); +extern void outclose(void); +extern void outclr(void); +extern void outchar(int); +extern void outqchar(int); +extern void outstrg(const char *); +extern void outint(int); +extern void outname(const char *); +extern void outsrc(const char *); diff --git a/usr.bin/xlint/common/ilp32.h b/usr.bin/xlint/common/ilp32.h new file mode 100644 index 0000000..5eb5f03 --- /dev/null +++ b/usr.bin/xlint/common/ilp32.h @@ -0,0 +1,59 @@ +/* $NetBSD: ilp32.h,v 1.1 2002/01/18 20:39:23 thorpej Exp $ */ + +/* + * Copyright (c) 2001 Wasabi Systems, Inc. + * All rights reserved. + * + * Written by Jason R. Thorpe for Wasabi Systems, Inc. + * + * 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 for the NetBSD Project by + * Wasabi Systems, Inc. + * 4. The name of Wasabi Systems, Inc. may not be used to endorse + * or promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC + * 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. + */ + +/* + * Type sizes for IPL32 platforms (int, long, pointer: 32-bit) + */ + +#define CHAR_SIZE (CHAR_BIT) +#define SHORT_SIZE (2 * CHAR_BIT) +#define INT_SIZE (4 * CHAR_BIT) +#define LONG_SIZE (4 * CHAR_BIT) +#define QUAD_SIZE (8 * CHAR_BIT) +#define PTR_SIZE (4 * CHAR_BIT) + +#define TARG_INT_MAX ((int32_t) (((uint32_t) -1) >> 1)) +#define TARG_INT_MIN ((-TARG_INT_MAX) - 1) +#define TARG_UINT_MAX ((uint32_t) -1) + +#define TARG_LONG_MAX TARG_INT_MAX +#define TARG_LONG_MIN TARG_INT_MIN +#define TARG_ULONG_MAX TARG_UINT_MAX + +#define TARG_QUAD_MAX ((int64_t) (((uint64_t) -1) >> 1)) +#define TARG_QUAD_MIN ((-TARG_QUAD_MAX) - 1) +#define TARG_UQUAD_MAX ((uint64_t) -1) diff --git a/usr.bin/xlint/common/inittyp.c b/usr.bin/xlint/common/inittyp.c new file mode 100644 index 0000000..b0958bf --- /dev/null +++ b/usr.bin/xlint/common/inittyp.c @@ -0,0 +1,133 @@ +/* $NetBSD: inittyp.c,v 1.3 2002/01/30 06:55:02 thorpej 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. + */ + +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: inittyp.c,v 1.3 2002/01/30 06:55:02 thorpej Exp $"); +#endif + +#include +#include +#include + +#include "lint.h" + +/* various type information */ +ttab_t ttab[NTSPEC]; + +void +inittyp(void) +{ + int i; + static const struct { + tspec_t it_tspec; + ttab_t it_ttab; + } ittab[NTSPEC] = { + { SIGNED, { 0, 0, + SIGNED, UNSIGN, + 0, 0, 0, 0, 0, "signed" } }, + { UNSIGN, { 0, 0, + SIGNED, UNSIGN, + 0, 0, 0, 0, 0, "unsigned" } }, + { CHAR, { CHAR_SIZE, CHAR_BIT, + SCHAR, UCHAR, + 1, 0, 0, 1, 1, "char" } }, + { SCHAR, { CHAR_SIZE, CHAR_BIT, + SCHAR, UCHAR, + 1, 0, 0, 1, 1, "signed char" } }, + { UCHAR, { CHAR_SIZE, CHAR_BIT, + SCHAR, UCHAR, + 1, 1, 0, 1, 1, "unsigned char" } }, + { SHORT, { SHORT_SIZE, 2 * CHAR_BIT, + SHORT, USHORT, + 1, 0, 0, 1, 1, "short" } }, + { USHORT, { SHORT_SIZE, 2 * CHAR_BIT, + SHORT, USHORT, + 1, 1, 0, 1, 1, "unsigned short" } }, + { INT, { INT_SIZE, 3 * CHAR_BIT, + INT, UINT, + 1, 0, 0, 1, 1, "int" } }, + { UINT, { INT_SIZE, 3 * CHAR_BIT, + INT, UINT, + 1, 1, 0, 1, 1, "unsigned int" } }, + { LONG, { LONG_SIZE, 4 * CHAR_BIT, + LONG, ULONG, + 1, 0, 0, 1, 1, "long" } }, + { ULONG, { LONG_SIZE, 4 * CHAR_BIT, + LONG, ULONG, + 1, 1, 0, 1, 1, "unsigned long" } }, + { QUAD, { QUAD_SIZE, 8 * CHAR_BIT, + QUAD, UQUAD, + 1, 0, 0, 1, 1, "long long" } }, + { UQUAD, { QUAD_SIZE, 8 * CHAR_BIT, + QUAD, UQUAD, + 1, 1, 0, 1, 1, "unsigned long long" } }, + { FLOAT, { FLOAT_SIZE, 4 * CHAR_BIT, + FLOAT, FLOAT, + 0, 0, 1, 1, 1, "float" } }, + { DOUBLE, { DOUBLE_SIZE, 8 * CHAR_BIT, + DOUBLE, DOUBLE, + 0, 0, 1, 1, 1, "double" } }, + { LDOUBLE, { LDOUBLE_SIZE, 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, { ENUM_SIZE, 3 * CHAR_BIT, + ENUM, ENUM, + 1, 0, 0, 1, 1, "enum" } }, + { PTR, { PTR_SIZE, 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" } }, + }; + + 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; + } +} diff --git a/usr.bin/xlint/common/lint.h b/usr.bin/xlint/common/lint.h new file mode 100644 index 0000000..c73f73c --- /dev/null +++ b/usr.bin/xlint/common/lint.h @@ -0,0 +1,126 @@ +/* $NetBSD: lint.h,v 1.3 2002/01/31 22:44:00 tv 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. + */ + +#if HAVE_CONFIG_H +#include "config.h" +#else +#define HAVE_DECL_SYS_SIGNAME 1 +#endif + +#include +#include +#include +#include +#include + +#include "param.h" + +/* + * Type specifiers, used in type structures (type_t) and otherwere. + */ +typedef enum { + NOTSPEC = 0, + SIGNED, /* keyword "signed", only used in the parser */ + UNSIGN, /* keyword "unsigned", only used in the parser */ + CHAR, /* char */ + SCHAR, /* signed char */ + UCHAR, /* unsigned char */ + SHORT, /* (signed) short */ + USHORT, /* unsigned short */ + INT, /* (signed) int */ + UINT, /* unsigned int */ + LONG, /* (signed) long */ + ULONG, /* unsigned long */ + QUAD, /* (signed) long long */ + UQUAD, /* unsigned long long */ + FLOAT, /* float */ + DOUBLE, /* double or, with tflag, long float */ + LDOUBLE, /* long double */ + VOID, /* void */ + STRUCT, /* structure tag */ + UNION, /* union tag */ + ENUM, /* enum tag */ + PTR, /* pointer */ + ARRAY, /* array */ + FUNC, /* function */ + NTSPEC +} tspec_t; + +/* + * size of types, name and classification + */ +typedef struct { + int tt_sz; /* size in bits */ + int tt_psz; /* size, different from tt_sz + if pflag is set */ + tspec_t tt_styp; /* signed counterpart */ + tspec_t tt_utyp; /* unsigned counterpart */ + u_int tt_isityp : 1; /* 1 if integer type */ + u_int tt_isutyp : 1; /* 1 if unsigned integer type */ + u_int tt_isftyp : 1; /* 1 if floating point type */ + u_int tt_isatyp : 1; /* 1 if arithmetic type */ + u_int tt_issclt : 1; /* 1 if scalar type */ + char *tt_name; /* Bezeichnung des Typs */ +} ttab_t; + +#define size(t) (ttab[t].tt_sz) +#define psize(t) (ttab[t].tt_psz) +#define styp(t) (ttab[t].tt_styp) +#define utyp(t) (ttab[t].tt_utyp) +#define isityp(t) (ttab[t].tt_isityp) +#define isutyp(t) (ttab[t].tt_isutyp) +#define isftyp(t) (ttab[t].tt_isftyp) +#define isatyp(t) (ttab[t].tt_isatyp) +#define issclt(t) (ttab[t].tt_issclt) + +extern ttab_t ttab[]; + + +typedef enum { + NODECL, /* until now not declared */ + DECL, /* declared */ + TDEF, /* tentative defined */ + DEF /* defined */ +} def_t; + +/* + * Following structure contains some data used for the output buffer. + */ +typedef struct ob { + char *o_buf; /* buffer */ + char *o_end; /* first byte after buffer */ + size_t o_len; /* length of buffer */ + char *o_nxt; /* next free byte in buffer */ +} ob_t; + +#include "externs.h" diff --git a/usr.bin/xlint/common/lp64.h b/usr.bin/xlint/common/lp64.h new file mode 100644 index 0000000..cd88700 --- /dev/null +++ b/usr.bin/xlint/common/lp64.h @@ -0,0 +1,59 @@ +/* $NetBSD: lp64.h,v 1.1 2002/01/18 20:39:23 thorpej Exp $ */ + +/* + * Copyright (c) 2001 Wasabi Systems, Inc. + * All rights reserved. + * + * Written by Jason R. Thorpe for Wasabi Systems, Inc. + * + * 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 for the NetBSD Project by + * Wasabi Systems, Inc. + * 4. The name of Wasabi Systems, Inc. may not be used to endorse + * or promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC + * 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. + */ + +/* + * Type sizes for LP64 platforms (long, pointer: 64-bit) + */ + +#define CHAR_SIZE (CHAR_BIT) +#define SHORT_SIZE (2 * CHAR_BIT) +#define INT_SIZE (4 * CHAR_BIT) +#define LONG_SIZE (8 * CHAR_BIT) +#define QUAD_SIZE (8 * CHAR_BIT) +#define PTR_SIZE (8 * CHAR_BIT) + +#define TARG_INT_MAX ((int32_t) (((uint32_t) -1) >> 1)) +#define TARG_INT_MIN ((-TARG_INT_MAX) - 1) +#define TARG_UINT_MAX ((uint32_t) -1) + +#define TARG_QUAD_MAX ((int64_t) (((uint64_t) -1) >> 1)) +#define TARG_QUAD_MIN ((-TARG_QUAD_MAX) - 1) +#define TARG_UQUAD_MAX ((uint64_t) -1) + +#define TARG_LONG_MAX TARG_QUAD_MAX +#define TARG_LONG_MIN TARG_QUAD_MIN +#define TARG_ULONG_MAX TARG_UQUAD_MAX diff --git a/usr.bin/xlint/common/mem.c b/usr.bin/xlint/common/mem.c new file mode 100644 index 0000000..2621081 --- /dev/null +++ b/usr.bin/xlint/common/mem.c @@ -0,0 +1,88 @@ +/* $NetBSD: mem.c,v 1.2 2002/01/21 19:49:51 tv 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. + */ + +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: mem.c,v 1.2 2002/01/21 19:49:51 tv Exp $"); +#endif + +#include +#include + +#include "lint.h" + +void * +xmalloc(size_t s) +{ + void *p; + + if ((p = malloc(s)) == NULL) + nomem(); + return (p); +} + +void * +xcalloc(size_t n, size_t s) +{ + void *p; + + if ((p = calloc(n, s)) == NULL) + nomem(); + return (p); +} + +void * +xrealloc(void *p, size_t s) +{ + + if ((p = realloc(p, s)) == NULL) + nomem(); + return (p); +} + +char * +xstrdup(const char *s) +{ + char *s2; + + if ((s2 = strdup(s)) == NULL) + nomem(); + return (s2); +} + +void +nomem(void) +{ + + errx(1, "virtual memory exhausted"); +} diff --git a/usr.bin/xlint/common/param.h b/usr.bin/xlint/common/param.h new file mode 100644 index 0000000..46f7326 --- /dev/null +++ b/usr.bin/xlint/common/param.h @@ -0,0 +1,88 @@ +/* $NetBSD: param.h,v 1.1 2002/01/18 20:39:24 thorpej 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. + */ + +/* + * Minimun size of string buffer. If this is not enough, the buffer + * is enlarged in steps of STRBLEN bytes. + */ +#define STRBLEN 256 + +/* + * This defines the size of memory blocks which are used to allocate + * memory in larger chunks. + */ +#define MBLKSIZ ((size_t)0x4000) + +/* + * Sizes of hash tables + * Should be a prime. Possible primes are + * 307, 401, 503, 601, 701, 809, 907, 1009, 1103, 1201, 1301, 1409, 1511. + * + * HSHSIZ1 symbol table 1st pass + * HSHSIZ2 symbol table 2nd pass + * THSHSIZ2 type table 2nd pass + */ +#define HSHSIZ1 503 +#define HSHSIZ2 1009 +#define THSHSIZ2 1009 + +/* + * Pull in target-specific parameters. + */ +#include "targparam.h" + +/* + * Make sure this matches wchar_t. + */ +#define WCHAR INT + +/* + * long double only in ANSI C. + * + * And the sparc64 long double code generation is broken. + */ +#if !defined(__sparc64__) && defined(__STDC__) +typedef long double ldbl_t; +#else +typedef double ldbl_t; +#endif + +/* + * Some traditional compilers are not able to assign structures. + */ +#ifdef __STDC__ +#define STRUCT_ASSIGN(dest, src) (dest) = (src) +#else +#define STRUCT_ASSIGN(dest, src) (void)memcpy(&(dest), &(src), \ + sizeof (dest)); +#endif diff --git a/usr.bin/xlint/lint1/Makefile b/usr.bin/xlint/lint1/Makefile index d5e519a..6c8a68f 100644 --- a/usr.bin/xlint/lint1/Makefile +++ b/usr.bin/xlint/lint1/Makefile @@ -1,19 +1,49 @@ -# $NetBSD: Makefile,v 1.3 1995/07/04 01:53:05 cgd Exp $ +# $NetBSD: Makefile,v 1.25 2002/02/01 01:32:20 ross Exp $ -PROG= lint1 -SRCS= cgram.c scan.c mem1.c mem.c err.c main1.c decl.c tree.c func.c \ - init.c emit.c emit1.c -NOMAN= -LDADD+= -ll -DPADD+= ${LIBL} -YFLAGS= -d -CFLAGS+=-I. -LINTFLAGS=-aehpz -CLEANFILES+=y.tab.h cgram.c scan.c +.include -BINDIR= /usr/libexec +PROG= lint1 +SRCS= cgram.y scan.l mem1.c mem.c err.c main1.c decl.c tree.c func.c \ + init.c emit.c emit1.c inittyp.c +MAN= lint.7 +YHEADER= -# XXX: -O causes the gcc to die on the i386, when compiling tree.o -CFLAGS+= -DXXX_BROKEN_GCC +CPPFLAGS+= -I${.CURDIR} -I. + +.if ${OBJECT_FMT} == "a.out" +CPPFLAGS+= -DTARGET_OBJFMT_AOUT +.elif ${OBJECT_FMT} == "COFF" +CPPFLAGS+= -DTARGET_OBJFMT_COFF +.elif ${OBJECT_FMT} == "ELF" +CPPFLAGS+= -DTARGET_OBJFMT_ELF +.else +.BEGIN: + @echo "Unrecognized OBJECT_FMT ${OBJECT_FMT}" + @false +.endif + +LINTFLAGS= -aehpz +WFORMAT=1 #hopeless +BINDIR= /usr/libexec + +scan.c: cgram.h + +CLEANFILES+= ${MAN} + +.if ${USETOOLS} == "yes" +LINT1= ${TOOLDIR}/libexec/${MACHINE_GNU_PLATFORM}-lint1 +.endif +LINT1?= ./${PROG} + +${MAN}: makeman ${LINT1:C/^\.\///} Makefile + sh ${.ALLSRC:M*makeman} ${LINT1} -m >${.TARGET} + +LDADD+= -lm +DPADD+= ${LIBM} + +.ifndef HOSTPROG +LDADD+= -ll +DPADD+= ${LIBL} .include +.endif diff --git a/usr.bin/xlint/lint1/cgram.y b/usr.bin/xlint/lint1/cgram.y index e65584a..9fdc58c 100644 --- a/usr.bin/xlint/lint1/cgram.y +++ b/usr.bin/xlint/lint1/cgram.y @@ -1,7 +1,8 @@ %{ -/* $NetBSD: cgram.y,v 1.8 1995/10/02 17:31:35 jpo Exp $ */ +/* $NetBSD: cgram.y,v 1.23 2002/01/31 19:36:53 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -32,11 +33,13 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: cgram.y,v 1.8 1995/10/02 17:31:35 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: cgram.y,v 1.23 2002/01/31 19:36:53 tv Exp $"); #endif #include +#include #include #include "lint1.h" @@ -55,10 +58,52 @@ int blklev; */ int mblklev; -static int toicon __P((tnode_t *)); -static void idecl __P((sym_t *, int)); -static void ignuptorp __P((void)); +/* + * Save the no-warns state and restore it to avoid the problem where + * if (expr) { stmt } / * NOLINT * / stmt; + */ +static int onowarn = -1; + +static int toicon(tnode_t *); +static void idecl(sym_t *, int, sbuf_t *); +static void ignuptorp(void); + +#ifdef DEBUG +static __inline void CLRWFLGS(void); +static __inline void CLRWFLGS(void) +{ + printf("%s, %d: clear flags %s %d\n", curr_pos.p_file, + curr_pos.p_line, __FILE__, __LINE__); + clrwflgs(); + onowarn = -1; +} +static __inline void SAVE(void); +static __inline void SAVE(void) +{ + if (onowarn != -1) + abort(); + printf("%s, %d: save flags %s %d = %d\n", curr_pos.p_file, + curr_pos.p_line, __FILE__, __LINE__, nowarn); + onowarn = nowarn; +} + +static __inline void RESTORE(void); +static __inline void RESTORE(void) +{ + if (onowarn != -1) { + nowarn = onowarn; + printf("%s, %d: restore flags %s %d = %d\n", curr_pos.p_file, + curr_pos.p_line, __FILE__, __LINE__, nowarn); + onowarn = -1; + } else + CLRWFLGS(); +} +#else +#define CLRWFLGS() clrwflgs(), onowarn = -1 +#define SAVE() onowarn = nowarn +#define RESTORE() (void)(onowarn == -1 ? (clrwflgs(), 0) : (nowarn = onowarn)) +#endif %} %union { @@ -129,6 +174,7 @@ static void ignuptorp __P((void)); %token T_BREAK %token T_RETURN %token T_ASM +%token T_SYMBOLRENAME %left T_COMMA %right T_ASSIGN T_OPASS @@ -205,6 +251,7 @@ static void ignuptorp __P((void)); %type opt_expr %type string %type string2 +%type opt_asm_or_symbolrename %% @@ -228,13 +275,14 @@ translation_unit: ; ext_decl: - func_def { + asm_stmnt + | func_def { glclup(0); - clrwflgs(); + CLRWFLGS(); } | data_def { glclup(0); - clrwflgs(); + CLRWFLGS(); } ; @@ -278,7 +326,7 @@ data_def: } | declspecs deftyp type_init_decls T_SEMI | error T_SEMI { - globclup(); + globclup(); } | error T_RBRACE { globclup(); @@ -712,7 +760,7 @@ enums_with_opt_comma: error(54); } else { /* trailing "," prohibited in enum declaration */ - warning(54); + (void)gnuism(54); } $$ = $1; } @@ -757,24 +805,24 @@ type_init_decls: ; notype_init_decl: - notype_decl opt_asm_spec { - idecl($1, 0); + notype_decl opt_asm_or_symbolrename { + idecl($1, 0, $2); chksz($1); } - | notype_decl opt_asm_spec { - idecl($1, 1); + | notype_decl opt_asm_or_symbolrename { + idecl($1, 1, $2); } T_ASSIGN initializer { chksz($1); } ; type_init_decl: - type_decl opt_asm_spec { - idecl($1, 0); + type_decl opt_asm_or_symbolrename { + idecl($1, 0, $2); chksz($1); } - | type_decl opt_asm_spec { - idecl($1, 1); + | type_decl opt_asm_or_symbolrename { + idecl($1, 1, $2); } T_ASSIGN initializer { chksz($1); } @@ -1015,10 +1063,10 @@ vararg_parameter_type_list: ; parameter_type_list: - parameter_declaration opt_asm_spec { + parameter_declaration { $$ = $1; } - | parameter_type_list T_COMMA parameter_declaration opt_asm_spec { + | parameter_type_list T_COMMA parameter_declaration { $$ = lnklst($1, $3); } ; @@ -1051,10 +1099,16 @@ parameter_declaration: } ; -opt_asm_spec: - /* empty */ +opt_asm_or_symbolrename: /* expect only one */ + /* empty */ { + $$ = NULL; + } | T_ASM T_LPARN T_STRING T_RPARN { freeyyv(&$3, T_STRING); + $$ = NULL; + } + | T_SYMBOLRENAME T_LPARN T_NAME T_RPARN { + $$ = $3; } ; @@ -1212,15 +1266,11 @@ opt_stmnt_list: ; stmnt_list: - stmnt { - clrwflgs(); - } + stmnt | stmnt_list stmnt { - clrwflgs(); - } - | stmnt_list error T_SEMI { - clrwflgs(); + RESTORE(); } + | stmnt_list error T_SEMI ; expr_stmnt: @@ -1235,21 +1285,27 @@ expr_stmnt: selection_stmnt: if_without_else { + SAVE(); if2(); if3(0); } | if_without_else T_ELSE { + SAVE(); if2(); } stmnt { + CLRWFLGS(); if3(1); } | if_without_else T_ELSE error { + CLRWFLGS(); if3(0); } | switch_expr stmnt { + CLRWFLGS(); switch2(); } | switch_expr error { + CLRWFLGS(); switch2(); } ; @@ -1262,35 +1318,46 @@ if_without_else: if_expr: T_IF T_LPARN expr T_RPARN { if1($3); - clrwflgs(); + CLRWFLGS(); } ; switch_expr: T_SWITCH T_LPARN expr T_RPARN { switch1($3); - clrwflgs(); + CLRWFLGS(); + } + ; + +do_stmnt: + do stmnt { + CLRWFLGS(); } ; iteration_stmnt: while_expr stmnt { + CLRWFLGS(); while2(); } | while_expr error { + CLRWFLGS(); while2(); } - | do stmnt do_while_expr { - do2($3); + | do_stmnt do_while_expr { + do2($2); ftflg = 0; } | do error { + CLRWFLGS(); do2(NULL); } | for_exprs stmnt { + CLRWFLGS(); for2(); } | for_exprs error { + CLRWFLGS(); for2(); } ; @@ -1298,7 +1365,7 @@ iteration_stmnt: while_expr: T_WHILE T_LPARN expr T_RPARN { while1($3); - clrwflgs(); + CLRWFLGS(); } ; @@ -1317,7 +1384,7 @@ do_while_expr: for_exprs: T_FOR T_LPARN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPARN { for1($3, $5, $7); - clrwflgs(); + CLRWFLGS(); } ; @@ -1375,10 +1442,10 @@ read_until_rparn: declaration_list: declaration { - clrwflgs(); + CLRWFLGS(); } | declaration_list declaration { - clrwflgs(); + CLRWFLGS(); } ; @@ -1441,7 +1508,7 @@ expr: term: T_NAME { - /* XXX realy neccessary? */ + /* XXX really necessary? */ if (yychar < 0) yychar = yylex(); $$ = getnnode(getsym($1), yychar); @@ -1565,15 +1632,34 @@ identifier: /* ARGSUSED */ int -yyerror(msg) - char *msg; +yyerror(char *msg) { + error(249); if (++sytxerr >= 5) norecover(); return (0); } +static inline int uq_gt(uint64_t, uint64_t); +static inline int q_gt(int64_t, int64_t); + +static inline int +uq_gt(uint64_t a, uint64_t b) +{ + + return (a > b); +} + +static inline int +q_gt(int64_t a, int64_t b) +{ + + return (a > b); +} + +#define q_lt(a, b) q_gt(b, a) + /* * Gets a node for a constant and returns the value of this constant * as integer. @@ -1584,8 +1670,7 @@ yyerror(msg) * expressions, it frees the memory used for the expression. */ static int -toicon(tn) - tnode_t *tn; +toicon(tnode_t *tn) { int i; tspec_t t; @@ -1607,12 +1692,14 @@ toicon(tn) } else { i = (int)v->v_quad; if (isutyp(t)) { - if ((u_quad_t)v->v_quad > INT_MAX) { + if (uq_gt((uint64_t)v->v_quad, + (uint64_t)INT_MAX)) { /* integral constant too large */ warning(56); } } else { - if (v->v_quad > INT_MAX || v->v_quad < INT_MIN) { + if (q_gt(v->v_quad, (int64_t)INT_MAX) || + q_lt(v->v_quad, (int64_t)INT_MIN)) { /* integral constant too large */ warning(56); } @@ -1623,25 +1710,46 @@ toicon(tn) } static void -idecl(decl, initflg) - sym_t *decl; - int initflg; +idecl(sym_t *decl, int initflg, sbuf_t *rename) { + char *s; + initerr = 0; initsym = decl; switch (dcs->d_ctx) { case EXTERN: + if (rename != NULL) { + if (decl->s_rename != NULL) + lerror("idecl() 1"); + + s = getlblk(1, rename->sb_len + 1); + (void)memcpy(s, rename->sb_name, rename->sb_len + 1); + decl->s_rename = s; + freeyyv(&rename, T_NAME); + } decl1ext(decl, initflg); break; case ARG: + if (rename != NULL) { + /* symbol renaming can't be used on function arguments */ + error(310); + freeyyv(&rename, T_NAME); + break; + } (void)decl1arg(decl, initflg); break; case AUTO: + if (rename != NULL) { + /* symbol renaming can't be used on automatic variables */ + error(311); + freeyyv(&rename, T_NAME); + break; + } decl1loc(decl, initflg); break; default: - lerror("idecl()"); + lerror("idecl() 2"); } if (initflg && !initerr) @@ -1652,8 +1760,8 @@ idecl(decl, initflg) * Discard all input tokens up to and including the next * unmatched right paren */ -void -ignuptorp() +static void +ignuptorp(void) { int level; diff --git a/usr.bin/xlint/lint1/decl.c b/usr.bin/xlint/lint1/decl.c index fa023b7..a77a561 100644 --- a/usr.bin/xlint/lint1/decl.c +++ b/usr.bin/xlint/lint1/decl.c @@ -1,6 +1,7 @@ -/* $NetBSD: decl.c,v 1.11 1995/10/02 17:34:16 jpo Exp $ */ +/* $NetBSD: decl.c,v 1.29 2002/01/18 21:01:39 thorpej Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -31,8 +32,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: decl.c,v 1.11 1995/10/02 17:34:16 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: decl.c,v 1.29 2002/01/18 21:01:39 thorpej Exp $"); #endif #include @@ -44,9 +46,6 @@ static char rcsid[] = "$NetBSD: decl.c,v 1.11 1995/10/02 17:34:16 jpo Exp $"; const char *unnamed = ""; -/* contains various information and classification on types */ -ttab_t ttab[NTSPEC]; - /* shared type structures for arithmtic types and void */ static type_t *typetab; @@ -59,107 +58,33 @@ 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 *)); +static type_t *tdeferr(type_t *, tspec_t); +static void settdsym(type_t *, sym_t *); +static tspec_t mrgtspec(tspec_t, tspec_t); +static void align(int, int); +static sym_t *newtag(sym_t *, scl_t, int, int); +static int eqargs(type_t *, type_t *, int *); +static int mnoarg(type_t *, int *); +static int chkosdef(sym_t *, sym_t *); +static int chkptdecl(sym_t *, sym_t *); +static sym_t *nsfunc(sym_t *, sym_t *); +static void osfunc(sym_t *, sym_t *); +static void ledecl(sym_t *); +static int chkinit(sym_t *); +static void chkausg(int, sym_t *); +static void chkvusg(int, sym_t *); +static void chklusg(sym_t *); +static void chktusg(sym_t *); +static void chkglvar(sym_t *); +static void glchksz(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" } }, - }; +initdecl(void) +{ + int i; /* declaration stack */ dcs = xcalloc(1, sizeof (dinfo_t)); @@ -167,13 +92,8 @@ initdecl() 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; - } - + inittyp(); + /* shared type structures */ typetab = xcalloc(NTSPEC, sizeof (type_t)); for (i = 0; i < NTSPEC; i++) @@ -208,15 +128,14 @@ initdecl() * if it is to be modified (adding qualifiers or anything else). */ type_t * -gettyp(t) - tspec_t t; +gettyp(tspec_t t) { + return (&typetab[t]); } type_t * -duptyp(tp) - const type_t *tp; +duptyp(const type_t *tp) { type_t *ntp; @@ -230,8 +149,7 @@ duptyp(tp) * allocated memory should be freed after the expr). */ type_t * -tduptyp(tp) - const type_t *tp; +tduptyp(const type_t *tp) { type_t *ntp; @@ -245,8 +163,7 @@ tduptyp(tp) * struct, union or enum type. */ int -incompl(tp) - type_t *tp; +incompl(type_t *tp) { tspec_t t; @@ -267,9 +184,7 @@ incompl(tp) * types. */ void -setcompl(tp, ic) - type_t *tp; - int ic; +setcompl(type_t *tp, int ic) { tspec_t t; @@ -290,9 +205,9 @@ setcompl(tp, ic) * storage classes. */ void -addscl(sc) - scl_t sc; +addscl(scl_t sc) { + if (sc == INLINE) { if (dcs->d_inline) /* duplicate '%s' */ @@ -327,8 +242,7 @@ addscl(sc) * struct/union/enum tag. */ void -addtype(tp) - type_t *tp; +addtype(type_t *tp) { tspec_t t; @@ -394,7 +308,7 @@ addtype(tp) /* remeber specifiers "signed" and "unsigned" in dcs->d_smod */ if (dcs->d_smod != NOTSPEC) /* - * more then one "signed" and/or "unsigned"; print + * more than one "signed" and/or "unsigned"; print * an error in deftyp() */ dcs->d_terr = 1; @@ -411,7 +325,7 @@ addtype(tp) } else { /* * remember specifiers "void", "char", "int", "float" or - * "double" int dcs->d_atyp + * "double" int dcs->d_atyp */ if (dcs->d_atyp != NOTSPEC) /* more than one, print error in deftyp() */ @@ -425,9 +339,7 @@ addtype(tp) * and other specifiers (except struct, union, enum, typedef name) */ static type_t * -tdeferr(td, t) - type_t *td; - tspec_t t; +tdeferr(type_t *td, tspec_t t) { tspec_t t2; @@ -479,6 +391,30 @@ tdeferr(td, t) } break; /* LINTED (enumeration values not handled in switch) */ + 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; + + case NTSPEC: /* this value unused */ + break; } /* Anything other is not accepted. */ @@ -492,14 +428,12 @@ tdeferr(td, t) * 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 + * of this tag in lint2. Although its possible that more than 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; +settdsym(type_t *tp, sym_t *sym) { tspec_t t; @@ -517,13 +451,13 @@ settdsym(tp, sym) * (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 + * The remembered qualifier is used by deftyp() to construct the type * for all declarators. */ void -addqual(q) - tqual_t q; +addqual(tqual_t q) { + if (q == CONST) { if (dcs->d_const) { /* duplicate "%s" */ @@ -546,8 +480,7 @@ addqual(q) * argument declaration lists ...) */ void -pushdecl(sc) - scl_t sc; +pushdecl(scl_t sc) { dinfo_t *di; @@ -566,7 +499,7 @@ pushdecl(sc) * Go back to previous declaration level */ void -popdecl() +popdecl(void) { dinfo_t *di; @@ -651,7 +584,7 @@ popdecl() * global declarations/definitions. */ void -setasm() +setasm(void) { dinfo_t *di; @@ -664,8 +597,9 @@ setasm() * will be used by the next declaration */ void -clrtyp() +clrtyp(void) { + dcs->d_atyp = dcs->d_smod = dcs->d_lmod = NOTSPEC; dcs->d_scl = NOSCL; dcs->d_type = NULL; @@ -683,7 +617,7 @@ clrtyp() * context. */ void -deftyp() +deftyp(void) { tspec_t t, s, l; type_t *tp; @@ -799,9 +733,9 @@ deftyp() * Merge type specifiers (char, ..., long long, signed, unsigned). */ static tspec_t -mrgtspec(t, s) - tspec_t t, s; +mrgtspec(tspec_t t, tspec_t s) { + if (s == SIGNED || s == UNSIGN) { if (t == CHAR) { t = s == SIGNED ? SCHAR : UCHAR; @@ -827,17 +761,18 @@ mrgtspec(t, s) * if name is not NULL. */ int -length(tp, name) - type_t *tp; - const char *name; +length(type_t *tp, const char *name) { int elem, elsz; elem = 1; - while (tp->t_tspec == ARRAY) { + while (tp && tp->t_tspec == ARRAY) { elem *= tp->t_dim; tp = tp->t_subt; } + if (tp == NULL) + return -1; + switch (tp->t_tspec) { case FUNC: /* compiler takes size of function */ @@ -870,15 +805,17 @@ length(tp, name) * Get the alignment of the given Type in bits. */ int -getbound(tp) - type_t *tp; +getbound(type_t *tp) { int a; tspec_t t; - while (tp->t_tspec == ARRAY) + while (tp && tp->t_tspec == ARRAY) tp = tp->t_subt; + if (tp == NULL) + return -1; + if ((t = tp->t_tspec) == STRUCT || t == UNION) { a = tp->t_str->align; } else if (t == FUNC) { @@ -902,8 +839,7 @@ getbound(tp) * struct/union/enum elements and parameters. */ sym_t * -lnklst(l1, l2) - sym_t *l1, *l2; +lnklst(sym_t *l1, sym_t *l2) { sym_t *l; @@ -925,8 +861,7 @@ lnklst(l1, l2) * - void types other than type of function or pointer */ void -chktyp(sym) - sym_t *sym; +chktyp(sym_t *sym) { tspec_t to, t; type_t **tpp, *tp; @@ -1018,12 +953,12 @@ chktyp(sym) * Process the declarator of a struct/union element. */ sym_t * -decl1str(dsym) - sym_t *dsym; +decl1str(sym_t *dsym) { type_t *tp; tspec_t t; - int sz, o, len; + int sz, len; + int o = 0; /* Appease gcc */ scl_t sc; if ((sc = dsym->s_scl) != MOS && sc != MOU) @@ -1053,25 +988,38 @@ decl1str(dsym) */ 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); + if (bitfieldtype_ok == 0) { + 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) { + if (pflag && bitfieldtype_ok == 0) { /* 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); + /* + * Non-integer types are always illegal for + * bitfields, regardless of BITFIELDTYPE. + * Integer types not dealt with above are + * okay only if BITFIELDTYPE is in effect. + */ + if (bitfieldtype_ok == 0 || isityp(t) == 0) { + /* 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 */ @@ -1127,6 +1075,12 @@ decl1str(dsym) chkfdef(dsym, 0); + /* + * Clear the BITFIELDTYPE indicator after processing each + * structure element. + */ + bitfieldtype_ok = 0; + return (dsym); } @@ -1136,8 +1090,7 @@ decl1str(dsym) * al contains the required alignment, len the length of a bit-field. */ static void -align(al, len) - int al, len; +align(int al, int len) { int no; @@ -1148,7 +1101,7 @@ align(al, len) */ 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; @@ -1158,16 +1111,15 @@ align(al, len) * Remember the width of the field in its type structure. */ sym_t * -bitfield(dsym, len) - sym_t *dsym; - int len; +bitfield(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_type = gettyp(UINT); dsym->s_blklev = -1; } dsym->s_type = duptyp(dsym->s_type); @@ -1184,14 +1136,14 @@ bitfield(dsym, len) * will be at the top of the list. */ pqinf_t * -mergepq(p1, p2) - pqinf_t *p1, *p2; +mergepq(pqinf_t *p1, pqinf_t *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) ; + for (p = p2; p->p_nxt != NULL; p = p->p_nxt) + continue; p->p_nxt = p1; return (p2); } else { @@ -1223,16 +1175,16 @@ mergepq(p1, p2) * declarator. The new type extension is inserted between both. */ sym_t * -addptr(decl, pi) - sym_t *decl; - pqinf_t *pi; +addptr(sym_t *decl, pqinf_t *pi) { type_t **tpp, *tp; pqinf_t *npi; tpp = &decl->s_type; - while (*tpp != dcs->d_type) + while (*tpp && *tpp != dcs->d_type) tpp = &(*tpp)->t_subt; + if (*tpp == NULL) + return decl; while (pi != NULL) { *tpp = tp = getblk(sizeof (type_t)); @@ -1252,15 +1204,15 @@ addptr(decl, pi) * n is the specified dimension */ sym_t * -addarray(decl, dim, n) - sym_t *decl; - int dim, n; +addarray(sym_t *decl, int dim, int n) { type_t **tpp, *tp; tpp = &decl->s_type; - while (*tpp != dcs->d_type) + while (*tpp && *tpp != dcs->d_type) tpp = &(*tpp)->t_subt; + if (*tpp == NULL) + return decl; *tpp = tp = getblk(sizeof (type_t)); tp->t_tspec = ARRAY; @@ -1283,8 +1235,7 @@ addarray(decl, dim, n) } sym_t * -addfunc(decl, args) - sym_t *decl, *args; +addfunc(sym_t *decl, sym_t *args) { type_t **tpp, *tp; @@ -1314,8 +1265,10 @@ addfunc(decl, args) } tpp = &decl->s_type; - while (*tpp != dcs->d_nxt->d_type) + while (*tpp && *tpp != dcs->d_nxt->d_type) tpp = &(*tpp)->t_subt; + if (*tpp == NULL) + return decl; *tpp = tp = getblk(sizeof (type_t)); tp->t_tspec = FUNC; @@ -1332,8 +1285,7 @@ addfunc(decl, args) */ /* ARGSUSED */ static sym_t * -nsfunc(decl, args) - sym_t *decl, *args; +nsfunc(sym_t *decl, sym_t *args) { sym_t *arg, *sym; scl_t sc; @@ -1371,9 +1323,9 @@ nsfunc(decl, args) * Called for old style function declarations. */ static void -osfunc(decl, args) - sym_t *decl, *args; +osfunc(sym_t *decl, sym_t *args) { + /* * Remember list of params only if this is really seams to be * a function definition. @@ -1382,7 +1334,7 @@ osfunc(decl, args) decl->s_type == dcs->d_nxt->d_type) { /* * We assume that this becomes a function definition. If - * we are wrong, its corrected in chkfdef(). + * we are wrong, its corrected in chkfdef(). */ if (args != NULL) { decl->s_osdef = 1; @@ -1401,10 +1353,9 @@ osfunc(decl, args) * error message. */ void -chkfdef(sym, msg) - sym_t *sym; - int msg; +chkfdef(sym_t *sym, int msg) { + if (sym->s_osdef) { if (msg) { /* incomplete or misplaced function definition */ @@ -1423,10 +1374,9 @@ chkfdef(sym, msg) * s_def and s_reg are valid after dname(). */ sym_t * -dname(sym) - sym_t *sym; +dname(sym_t *sym) { - scl_t sc; + scl_t sc = NOSCL; if (sym->s_scl == NOSCL) { dcs->d_rdcsym = NULL; @@ -1489,7 +1439,7 @@ dname(sym) * 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. + * we have the necessary type information. */ sc = AUTO; sym->s_def = DEF; @@ -1522,9 +1472,9 @@ dname(sym) * definition. */ sym_t * -iname(sym) - sym_t *sym; +iname(sym_t *sym) { + if (sym->s_scl != NOSCL) { if (blklev == sym->s_blklev) { /* redeclaration of formal parameter %s */ @@ -1551,12 +1501,9 @@ iname(sym) * 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; +mktag(sym_t *tag, tspec_t kind, int decl, int semi) { - scl_t scl; + scl_t scl = NOSCL; type_t *tp; if (kind == STRUCT) { @@ -1590,7 +1537,7 @@ mktag(tag, kind, decl, semi) } else { tag = getblk(sizeof (sym_t)); tag->s_name = unnamed; - STRUCT_ASSIGN(tag->s_dpos, curr_pos); + UNIQUE_CURR_POS(tag->s_dpos); tag->s_kind = FTAG; tag->s_scl = scl; tag->s_blklev = -1; @@ -1622,11 +1569,9 @@ mktag(tag, kind, decl, semi) * semi is 1 if T_SEMI follows */ static sym_t * -newtag(tag, scl, decl, semi) - sym_t *tag; - scl_t scl; - int decl, semi; +newtag(sym_t *tag, scl_t scl, int decl, int semi) { + if (tag->s_blklev < blklev) { if (semi) { /* "struct a;" */ @@ -1641,7 +1586,7 @@ newtag(tag, scl, decl, semi) } dcs->d_nxt->d_nedecl = 1; } else if (decl) { - /* "struct a { ..." */ + /* "struct a { ... } " */ if (hflag) /* redefinition hides earlier one: %s */ warning(43, tag->s_name); @@ -1677,8 +1622,7 @@ newtag(tag, scl, decl, semi) } const char * -scltoa(sc) - scl_t sc; +scltoa(scl_t sc) { const char *s; @@ -1701,9 +1645,7 @@ scltoa(sc) * 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; +compltag(type_t *tp, sym_t *fmem) { tspec_t t; str_t *sp; @@ -1745,13 +1687,12 @@ compltag(tp, fmem) * * 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. + * impl is 1 if the value of the enumerator was not explicit specified. */ sym_t * -ename(sym, val, impl) - sym_t *sym; - int val, impl; +ename(sym_t *sym, int val, int impl) { + if (sym->s_scl) { if (sym->s_blklev == blklev) { /* no hflag, because this is illegal!!! */ @@ -1792,9 +1733,7 @@ ename(sym, val, impl) * Process a single external declarator. */ void -decl1ext(dsym, initflg) - sym_t *dsym; - int initflg; +decl1ext(sym_t *dsym, int initflg) { int warn, rval, redec; sym_t *rdsym; @@ -1850,7 +1789,7 @@ decl1ext(dsym, initflg) } if (!redec && !isredec(dsym, (warn = 0, &warn))) { - + if (warn) { /* redeclaration of %s */ (*(sflag ? error : warning))(27, dsym->s_name); @@ -1896,7 +1835,7 @@ decl1ext(dsym, initflg) compltyp(dsym, rdsym); } - + rmsym(rdsym); } @@ -1913,9 +1852,9 @@ decl1ext(dsym, initflg) * the same symbol. */ void -cpuinfo(sym, rdsym) - sym_t *sym, *rdsym; +cpuinfo(sym_t *sym, sym_t *rdsym) { + sym->s_spos = rdsym->s_spos; sym->s_upos = rdsym->s_upos; sym->s_set = rdsym->s_set; @@ -1928,9 +1867,7 @@ cpuinfo(sym, rdsym) * a warning. */ int -isredec(dsym, warn) - sym_t *dsym; - int *warn; +isredec(sym_t *dsym, int *warn) { sym_t *rsym; @@ -2003,15 +1940,13 @@ isredec(dsym, warn) * 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 comparision of params of + * 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; +eqtype(type_t *tp1, type_t *tp2, int ignqual, int promot, int *warn) { tspec_t t; @@ -2077,9 +2012,7 @@ eqtype(tp1, tp2, ignqual, promot, warn) * Compares the parameter types of two prototypes. */ static int -eqargs(tp1, tp2, warn) - type_t *tp1, *tp2; - int *warn; +eqargs(type_t *tp1, type_t *tp2, int *warn) { sym_t *a1, *a2; @@ -2113,9 +2046,7 @@ eqargs(tp1, tp2, warn) * is applied on it */ static int -mnoarg(tp, warn) - type_t *tp; - int *warn; +mnoarg(type_t *tp, int *warn) { sym_t *arg; tspec_t t; @@ -2140,8 +2071,7 @@ mnoarg(tp, warn) * a previous old style function definition. */ static int -chkosdef(rdsym, dsym) - sym_t *rdsym, *dsym; +chkosdef(sym_t *rdsym, sym_t *dsym) { sym_t *args, *pargs, *arg, *parg; int narg, nparg, n; @@ -2202,8 +2132,7 @@ chkosdef(rdsym, dsym) * be duplicated. */ void -compltyp(dsym, ssym) - sym_t *dsym, *ssym; +compltyp(sym_t *dsym, sym_t *ssym) { type_t **dstp, *src; type_t *dst; @@ -2237,9 +2166,7 @@ compltyp(dsym, ssym) * Completes the declaration of a single argument. */ sym_t * -decl1arg(sym, initflg) - sym_t *sym; - int initflg; +decl1arg(sym_t *sym, int initflg) { tspec_t t; @@ -2303,7 +2230,7 @@ decl1arg(sym, initflg) * prototype. */ void -cluparg() +cluparg(void) { sym_t *args, *arg, *pargs, *parg; int narg, nparg, n, msg; @@ -2417,7 +2344,7 @@ cluparg() /* from now the prototype is valid */ funcsym->s_osdef = 0; funcsym->s_args = NULL; - + } } @@ -2428,8 +2355,7 @@ cluparg() * Returns 1 if the position of the previous declaration should be reported. */ static int -chkptdecl(arg, parg) - sym_t *arg, *parg; +chkptdecl(sym_t *arg, sym_t *parg) { type_t *tp, *ptp; int warn, msg; @@ -2462,10 +2388,9 @@ chkptdecl(arg, parg) * Completes a single local declaration/definition. */ void -decl1loc(dsym, initflg) - sym_t *dsym; - int initflg; +decl1loc(sym_t *dsym, int initflg) { + /* Correct a mistake done in dname(). */ if (dsym->s_type->t_tspec == FUNC) { dsym->s_def = DECL; @@ -2570,7 +2495,7 @@ decl1loc(dsym, initflg) if (hflag) /* declaration hides earlier one: %s */ warning(95, dsym->s_name); - + } if (dcs->d_rdcsym->s_blklev == blklev) { @@ -2604,8 +2529,7 @@ decl1loc(dsym, initflg) * Processes (re)declarations of external Symbols inside blocks. */ static void -ledecl(dsym) - sym_t *dsym; +ledecl(sym_t *dsym) { int eqt, warn; sym_t *esym; @@ -2660,8 +2584,7 @@ ledecl(dsym) * detected. */ static int -chkinit(sym) - sym_t *sym; +chkinit(sym_t *sym) { int err; @@ -2692,7 +2615,7 @@ chkinit(sym) * Create a symbole for an abstract declaration. */ sym_t * -aname() +aname(void) { sym_t *sym; @@ -2720,8 +2643,9 @@ aname() * Removes anything which has nothing to do on global level. */ void -globclup() +globclup(void) { + while (dcs->d_nxt != NULL) popdecl(); @@ -2740,9 +2664,9 @@ globclup() * Process an abstract type declaration */ sym_t * -decl1abs(sym) - sym_t *sym; +decl1abs(sym_t *sym) { + chkfdef(sym, 1); chktyp(sym); return (sym); @@ -2752,9 +2676,9 @@ decl1abs(sym) * Checks size after declarations of variables and their initialisation. */ void -chksz(dsym) - sym_t *dsym; +chksz(sym_t *dsym) { + /* * check size only for symbols which are defined and no function and * not typedef name @@ -2781,12 +2705,12 @@ chksz(dsym) * Mark an object as set if it is not already */ void -setsflg(sym) - sym_t *sym; +setsflg(sym_t *sym) { + if (!sym->s_set) { sym->s_set = 1; - STRUCT_ASSIGN(sym->s_spos, curr_pos); + UNIQUE_CURR_POS(sym->s_spos); } } @@ -2794,13 +2718,12 @@ setsflg(sym) * Mark an object as used if it is not already */ void -setuflg(sym, fcall, szof) - sym_t *sym; - int fcall, szof; +setuflg(sym_t *sym, int fcall, int szof) { + if (!sym->s_used) { sym->s_used = 1; - STRUCT_ASSIGN(sym->s_upos, curr_pos); + UNIQUE_CURR_POS(sym->s_upos); } /* * for function calls another record is written @@ -2818,8 +2741,7 @@ setuflg(sym, fcall, szof) * with s_dlnxt) if these are not used or only set. */ void -chkusage(di) - dinfo_t *di; +chkusage(dinfo_t *di) { sym_t *sym; int mknowarn; @@ -2839,9 +2761,7 @@ chkusage(di) * only set. */ void -chkusg1(novar, sym) - int novar; - sym_t *sym; +chkusg1(int novar, sym_t *sym) { pos_t cpos; @@ -2866,10 +2786,9 @@ chkusg1(novar, sym) } static void -chkausg(novar, arg) - int novar; - sym_t *arg; +chkausg(int novar, sym_t *arg) { + if (!arg->s_set) lerror("chkausg() 1"); @@ -2884,9 +2803,7 @@ chkausg(novar, arg) } static void -chkvusg(novar, sym) - int novar; - sym_t *sym; +chkvusg(int novar, sym_t *sym) { scl_t sc; sym_t *xsym; @@ -2953,9 +2870,9 @@ chkvusg(novar, sym) } static void -chklusg(lab) - sym_t *lab; +chklusg(sym_t *lab) { + if (blklev != 1 || lab->s_blklev != 1) lerror("chklusg() 1"); @@ -2971,9 +2888,9 @@ chklusg(lab) } static void -chktusg(sym) - sym_t *sym; +chktusg(sym_t *sym) { + if (!incompl(sym->s_type)) return; @@ -3009,7 +2926,7 @@ chktusg(sym) * - static symbols which are never used */ void -chkglsyms() +chkglsyms(void) { sym_t *sym; pos_t cpos; @@ -3036,12 +2953,12 @@ chkglsyms() } static void -chkglvar(sym) - sym_t *sym; +chkglvar(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"); @@ -3083,13 +3000,13 @@ chkglvar(sym) } static void -glchksz(sym) - sym_t *sym; +glchksz(sym_t *sym) { + if (sym->s_def == TDEF) { if (sym->s_type->t_tspec == FUNC) /* - * this can happen if an syntax error occured + * this can happen if an syntax error occurred * after a function declaration */ return; @@ -3110,9 +3027,7 @@ glchksz(sym) * Prints information about location of previous definition/declaration. */ void -prevdecl(msg, psym) - int msg; - sym_t *psym; +prevdecl(int msg, sym_t *psym) { pos_t cpos; diff --git a/usr.bin/xlint/lint1/emit1.c b/usr.bin/xlint/lint1/emit1.c index ee2434e..fc47a84 100644 --- a/usr.bin/xlint/lint1/emit1.c +++ b/usr.bin/xlint/lint1/emit1.c @@ -1,6 +1,7 @@ -/* $NetBSD: emit1.c,v 1.4 1995/10/02 17:21:28 jpo Exp $ */ +/* $NetBSD: emit1.c,v 1.11 2002/01/31 19:36:54 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -31,16 +32,17 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: emit1.c,v 1.4 1995/10/02 17:21:28 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: emit1.c,v 1.11 2002/01/31 19:36:54 tv Exp $"); #endif #include #include "lint1.h" -static void outtt __P((sym_t *, sym_t *)); -static void outfstrg __P((strg_t *)); +static void outtt(sym_t *, sym_t *); +static void outfstrg(strg_t *); /* * Write type into the output buffer. @@ -82,8 +84,7 @@ static void outfstrg __P((strg_t *)); * and 'v' (for volatile) */ void -outtype(tp) - type_t *tp; +outtype(type_t *tp) { int t, s, na; sym_t *arg; @@ -153,8 +154,7 @@ outtype(tp) * it uses its own output buffer for conversion */ const char * -ttos(tp) - type_t *tp; +ttos(type_t *tp) { static ob_t tob; ob_t tmp; @@ -184,9 +184,12 @@ ttos(tp) * refers to this tag, this typename is written */ static void -outtt(tag, tdef) - sym_t *tag, *tdef; +outtt(sym_t *tag, sym_t *tdef) { + + /* + * 0 is no longer used. + */ if (tag->s_name != unnamed) { outint(1); outname(tag->s_name); @@ -194,7 +197,12 @@ outtt(tag, tdef) outint(2); outname(tdef->s_name); } else { - outint(0); + outint(3); + outint(tag->s_dpos.p_line); + outchar('.'); + outint(getfnid(tag->s_dpos.p_file)); + outchar('.'); + outint(tag->s_dpos.p_uniq); } } @@ -206,11 +214,9 @@ outtt(tag, tdef) * not here */ void -outsym(sym, sc, def) - sym_t *sym; - scl_t sc; - def_t def; +outsym(sym_t *sym, scl_t sc, def_t def) { + /* * Static function declarations must also be written to the output * file. Compatibility of function declarations (for both static @@ -266,6 +272,12 @@ outsym(sym, sc, def) /* name of the symbol */ outname(sym->s_name); + /* renamed name of symbol, if necessary */ + if (sym->s_rename) { + outchar('r'); + outname(sym->s_rename); + } + /* type of the symbol */ outtype(sym->s_type); } @@ -277,10 +289,7 @@ outsym(sym, sc, def) * they are called with proper argument types */ void -outfdef(fsym, posp, rval, osdef, args) - sym_t *fsym, *args; - pos_t *posp; - int rval, osdef; +outfdef(sym_t *fsym, pos_t *posp, int rval, int osdef, sym_t *args) { int narg; sym_t *arg; @@ -352,6 +361,12 @@ outfdef(fsym, posp, rval, osdef, args) /* name of function */ outname(fsym->s_name); + /* renamed name of function, if necessary */ + if (fsym->s_rename) { + outchar('r'); + outname(fsym->s_rename); + } + /* argument types and return value */ if (osdef) { narg = 0; @@ -376,13 +391,11 @@ outfdef(fsym, posp, rval, osdef, args) * (casted to void) */ void -outcall(tn, rvused, rvdisc) - tnode_t *tn; - int rvused, rvdisc; +outcall(tnode_t *tn, int rvused, int rvdisc) { tnode_t *args, *arg; int narg, n, i; - quad_t q; + int64_t q; tspec_t t; /* reset buffer */ @@ -410,7 +423,8 @@ outcall(tn, rvused, rvdisc) /* informations about arguments */ for (n = 1; n <= narg; n++) { /* the last argument is the top one in the tree */ - for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) ; + for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) + continue; arg = arg->tn_left; if (arg->tn_op == CON) { if (isityp(t = arg->tn_type->t_tspec)) { @@ -451,7 +465,8 @@ outcall(tn, rvused, rvdisc) outint(narg); for (n = 1; n <= narg; n++) { /* the last argument is the top one in the tree */ - for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) ; + for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) + continue; outtype(arg->tn_left->tn_type); } /* expected type of return value */ @@ -463,8 +478,7 @@ outcall(tn, rvused, rvdisc) * writes them, enclosed in "" and qouted if necessary, to the output buffer */ static void -outfstrg(strg) - strg_t *strg; +outfstrg(strg_t *strg) { int c, oc, first; u_char *cp; @@ -563,8 +577,7 @@ outfstrg(strg) * writes a record if sym was used */ void -outusg(sym) - sym_t *sym; +outusg(sym_t *sym) { /* reset buffer */ outclr(); diff --git a/usr.bin/xlint/lint1/err.c b/usr.bin/xlint/lint1/err.c index 32c80c4..ffbc1bc 100644 --- a/usr.bin/xlint/lint1/err.c +++ b/usr.bin/xlint/lint1/err.c @@ -1,4 +1,4 @@ -/* $NetBSD: err.c,v 1.8 1995/10/02 17:37:00 jpo Exp $ */ +/* $NetBSD: err.c,v 1.16 2001/12/13 23:56:00 augustss Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,28 +31,27 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: err.c,v 1.8 1995/10/02 17:37:00 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: err.c,v 1.16 2001/12/13 23:56:00 augustss Exp $"); #endif +#include +#include +#include + +#include "lint1.h" + /* number of errors found */ int nerr; /* number of syntax errors */ int sytxerr; -#include -#ifdef __STDC__ -#include -#else -#include -#endif - -#include "lint1.h" -static const char *basename __P((const char *)); -static void verror __P((int, va_list)); -static void vwarning __P((int, va_list)); +static const char *basename(const char *); +static void verror(int, va_list); +static void vwarning(int, va_list); const char *msgs[] = { @@ -218,7 +217,7 @@ const char *msgs[] = { "assignment in conditional context", /* 159 */ "operator '==' found where '=' was expected", /* 160 */ "constant in conditional context", /* 161 */ - "comparision of %s with %s, op %s", /* 162 */ + "comparison of %s with %s, op %s", /* 162 */ "a cast does not yield an lvalue", /* 163 */ "assignment of negative constant to unsigned type", /* 164 */ "constant truncated by assignment", /* 165 */ @@ -286,7 +285,7 @@ const char *msgs[] = { "const object %s should have initializer", /* 227 */ "function cannot return const or volatile object", /* 228 */ "questionable conversion of function pointer", /* 229 */ - "nonportable character comparision, op %s", /* 230 */ + "nonportable character comparison, op %s", /* 230 */ "argument %s unused in function %s", /* 231 */ "label %s unused in function %s", /* 232 */ "struct %s never defined", /* 233 */ @@ -299,7 +298,7 @@ const char *msgs[] = { "assignment of different structures", /* 240 */ "dubious operation on enum, op %s", /* 241 */ "combination of '%s' and '%s', op %s", /* 242 */ - "dubious comparision of enums, op %s", /* 243 */ + "dubious comparison of enums, op %s", /* 243 */ "illegal structure pointer combination", /* 244 */ "illegal structure pointer combination, op %s", /* 245 */ "dubious conversion of enum to '%s'", /* 246 */ @@ -330,7 +329,7 @@ const char *msgs[] = { "switch expression must be of type `int' in traditional C", /* 271 */ "empty translation unit", /* 272 */ "bit-field type '%s' invalid in ANSI C", /* 273 */ - "ANSI C forbids comparision of %s with %s", /* 274 */ + "ANSI C forbids comparison of %s with %s", /* 274 */ "cast discards 'const' from pointer target type", /* 275 */ "", /* 276 */ "initialisation of '%s' with '%s'", /* 277 */ @@ -366,15 +365,29 @@ const char *msgs[] = { "static variable %s set but not used", /* 307 */ "", /* 308 */ "extra bits set to 0 in conversion of '%s' to '%s', op %s", /* 309 */ + "symbol renaming can't be used on function arguments", /* 310 */ + "symbol renaming can't be used on automatic variables", /* 311 */ + "%s C does not support // comments", /* 312 */ }; /* + * print a list of the messages with their ids + */ +void +msglist(void) +{ + int i; + + for (i = 0; i < sizeof(msgs) / sizeof(msgs[0]); i++) + printf("%d\t%s\n", i, msgs[i]); +} + +/* * If Fflag is not set basename() returns a pointer to the last * component of the path, otherwise it returns the argument. */ static const char * -basename(path) - const char *path; +basename(const char *path) { const char *cp, *cp1, *cp2; @@ -392,26 +405,28 @@ basename(path) } static void -verror(n, ap) - int n; - va_list ap; +verror( int n, va_list ap) { const char *fn; + if (ERR_ISSET(n, &msgset)) + return; + fn = basename(curr_pos.p_file); (void)printf("%s(%d): ", fn, curr_pos.p_line); (void)vprintf(msgs[n], ap); - (void)printf("\n"); + (void)printf(" [%d]\n", n); nerr++; } static void -vwarning(n, ap) - int n; - va_list ap; +vwarning( int n, va_list ap) { const char *fn; + if (ERR_ISSET(n, &msgset)) + return; + if (nowarn) /* this warning is suppressed by a LINTED comment */ return; @@ -419,46 +434,28 @@ vwarning(n, ap) fn = basename(curr_pos.p_file); (void)printf("%s(%d): warning: ", fn, curr_pos.p_line); (void)vprintf(msgs[n], ap); - (void)printf("\n"); + (void)printf(" [%d]\n", n); + if (wflag) + nerr++; } void -#ifdef __STDC__ error(int n, ...) -#else -error(n, va_alist) - int n; - va_dcl -#endif { va_list ap; -#ifdef __STDC__ va_start(ap, n); -#else - va_start(ap); -#endif verror(n, ap); va_end(ap); } void -#ifdef __STDC__ lerror(const char *msg, ...) -#else -lerror(msg, va_alist) - const char *msg; - va_dcl -#endif { va_list ap; const char *fn; -#ifdef __STDC__ va_start(ap, msg); -#else - va_start(ap); -#endif fn = basename(curr_pos.p_file); (void)fprintf(stderr, "%s(%d): lint error: ", fn, curr_pos.p_line); (void)vfprintf(stderr, msg, ap); @@ -468,66 +465,39 @@ lerror(msg, va_alist) } void -#ifdef __STDC__ warning(int n, ...) -#else -warning(n, va_alist) - int n; - va_dcl -#endif { va_list ap; -#ifdef __STDC__ va_start(ap, n); -#else - va_start(ap); -#endif vwarning(n, ap); va_end(ap); } void -#ifdef __STDC__ message(int n, ...) -#else -message(n, va_alist) - int n; - va_dcl -#endif { va_list ap; const char *fn; -#ifdef __STDC__ + if (ERR_ISSET(n, &msgset)) + return; + va_start(ap, n); -#else - va_start(ap); -#endif fn = basename(curr_pos.p_file); (void)printf("%s(%d): ", fn, curr_pos.p_line); (void)vprintf(msgs[n], ap); - (void)printf("\n"); + (void)printf(" [%d]\n", n); va_end(ap); } int -#ifdef __STDC__ gnuism(int n, ...) -#else -gnuism(n, va_alist) - int n; - va_dcl -#endif { va_list ap; int msg; -#ifdef __STDC__ va_start(ap, n); -#else - va_start(ap); -#endif if (sflag && !gflag) { verror(n, ap); msg = 1; diff --git a/usr.bin/xlint/lint1/externs1.h b/usr.bin/xlint/lint1/externs1.h index e9923c7..765c1ef 100644 --- a/usr.bin/xlint/lint1/externs1.h +++ b/usr.bin/xlint/lint1/externs1.h @@ -1,4 +1,4 @@ -/* $NetBSD: externs1.h,v 1.7 1995/10/02 17:31:39 jpo Exp $ */ +/* $NetBSD: externs1.h,v 1.13 2002/01/18 21:01:39 thorpej Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -42,16 +42,16 @@ extern int eflag; extern int Fflag; extern int gflag; extern int hflag; -extern int pflag; extern int rflag; extern int sflag; extern int tflag; extern int uflag; extern int vflag; extern int yflag; +extern int wflag; extern int zflag; -extern void norecover __P((void)); +extern void norecover(void); /* * cgram.y @@ -60,8 +60,8 @@ extern int blklev; extern int mblklev; extern int yydebug; -extern int yyerror __P((char *)); -extern int yyparse __P((void)); +extern int yyerror(char *); +extern int yyparse(void); /* * scan.l @@ -70,41 +70,41 @@ extern pos_t curr_pos; extern pos_t csrc_pos; extern symt_t symtyp; extern FILE *yyin; -extern u_quad_t qbmasks[], qlmasks[], qumasks[]; +extern uint64_t qbmasks[], qlmasks[], qumasks[]; -extern void initscan __P((void)); -extern int sign __P((quad_t, tspec_t, int)); -extern int msb __P((quad_t, tspec_t, int)); -extern quad_t xsign __P((quad_t, tspec_t, int)); -extern void clrwflgs __P((void)); -extern sym_t *getsym __P((sbuf_t *)); -extern void cleanup __P((void)); -extern sym_t *pushdown __P((sym_t *)); -extern void rmsym __P((sym_t *)); -extern void rmsyms __P((sym_t *)); -extern void inssym __P((int, sym_t *)); -extern void freeyyv __P((void *, int)); -extern int yylex __P((void)); +extern void initscan(void); +extern int sign(int64_t, tspec_t, int); +extern int msb(int64_t, tspec_t, int); +extern int64_t xsign(int64_t, tspec_t, int); +extern void clrwflgs(void); +extern sym_t *getsym(sbuf_t *); +extern void cleanup(void); +extern sym_t *pushdown(sym_t *); +extern void rmsym(sym_t *); +extern void rmsyms(sym_t *); +extern void inssym(int, sym_t *); +extern void freeyyv(void *, int); +extern int yylex(void); /* * mem1.c */ -extern const char *fnalloc __P((const char *)); -extern const char *fnnalloc __P((const char *, size_t)); -extern int getfnid __P((const char *)); +extern const char *fnalloc(const char *); +extern const char *fnnalloc(const char *, size_t); +extern int getfnid(const char *); -extern void initmem __P((void)); +extern void initmem(void); -extern void *getblk __P((size_t)); -extern void *getlblk __P((int, size_t)); -extern void freeblk __P((void)); -extern void freelblk __P((int)); +extern void *getblk(size_t); +extern void *getlblk(int, size_t); +extern void freeblk(void); +extern void freelblk(int); -extern void *tgetblk __P((size_t)); -extern tnode_t *getnode __P((void)); -extern void tfreeblk __P((void)); -extern struct mbl *tsave __P((void)); -extern void trestor __P((struct mbl *)); +extern void *tgetblk(size_t); +extern tnode_t *getnode(void); +extern void tfreeblk(void); +extern struct mbl *tsave(void); +extern void trestor(struct mbl *); /* * err.c @@ -113,11 +113,13 @@ extern int nerr; extern int sytxerr; extern const char *msgs[]; -extern void error __P((int, ...)); -extern void warning __P((int, ...)); -extern void message __P((int, ...)); -extern int gnuism __P((int, ...)); -extern void lerror __P((const char *, ...)); +extern void msglist(void); +extern void error(int, ...); +extern void warning(int, ...); +extern void message(int, ...); +extern int gnuism(int, ...); +extern void lerror(const char *, ...) + __attribute__((__noreturn__,__format__(__printf__, 1, 2))); /* * decl.c @@ -126,82 +128,82 @@ extern dinfo_t *dcs; extern const char *unnamed; extern int enumval; -extern void initdecl __P((void)); -extern type_t *gettyp __P((tspec_t)); -extern type_t *duptyp __P((const type_t *)); -extern type_t *tduptyp __P((const type_t *)); -extern int incompl __P((type_t *)); -extern void setcompl __P((type_t *, int)); -extern void addscl __P((scl_t)); -extern void addtype __P((type_t *)); -extern void addqual __P((tqual_t)); -extern void pushdecl __P((scl_t)); -extern void popdecl __P((void)); -extern void setasm __P((void)); -extern void clrtyp __P((void)); -extern void deftyp __P((void)); -extern int length __P((type_t *, const char *)); -extern int getbound __P((type_t *)); -extern sym_t *lnklst __P((sym_t *, sym_t *)); -extern void chktyp __P((sym_t *)); -extern sym_t *decl1str __P((sym_t *)); -extern sym_t *bitfield __P((sym_t *, int)); -extern pqinf_t *mergepq __P((pqinf_t *, pqinf_t *)); -extern sym_t *addptr __P((sym_t *, pqinf_t *)); -extern sym_t *addarray __P((sym_t *, int, int)); -extern sym_t *addfunc __P((sym_t *, sym_t *)); -extern void chkfdef __P((sym_t *, int)); -extern sym_t *dname __P((sym_t *)); -extern sym_t *iname __P((sym_t *)); -extern type_t *mktag __P((sym_t *, tspec_t, int, int)); -extern const char *scltoa __P((scl_t)); -extern type_t *compltag __P((type_t *, sym_t *)); -extern sym_t *ename __P((sym_t *, int, int)); -extern void decl1ext __P((sym_t *, int)); -extern void cpuinfo __P((sym_t *, sym_t *)); -extern int isredec __P((sym_t *, int *)); -extern int eqtype __P((type_t *, type_t *, int, int, int *)); -extern void compltyp __P((sym_t *, sym_t *)); -extern sym_t *decl1arg __P((sym_t *, int)); -extern void cluparg __P((void)); -extern void decl1loc __P((sym_t *, int)); -extern sym_t *aname __P((void)); -extern void globclup __P((void)); -extern sym_t *decl1abs __P((sym_t *)); -extern void chksz __P((sym_t *)); -extern void setsflg __P((sym_t *)); -extern void setuflg __P((sym_t *, int, int)); -extern void chkusage __P((dinfo_t *)); -extern void chkusg1 __P((int, sym_t *)); -extern void chkglsyms __P((void)); -extern void prevdecl __P((int, sym_t *)); +extern void initdecl(void); +extern type_t *gettyp(tspec_t); +extern type_t *duptyp(const type_t *); +extern type_t *tduptyp(const type_t *); +extern int incompl(type_t *); +extern void setcompl(type_t *, int); +extern void addscl(scl_t); +extern void addtype(type_t *); +extern void addqual(tqual_t); +extern void pushdecl(scl_t); +extern void popdecl(void); +extern void setasm(void); +extern void clrtyp(void); +extern void deftyp(void); +extern int length(type_t *, const char *); +extern int getbound(type_t *); +extern sym_t *lnklst(sym_t *, sym_t *); +extern void chktyp(sym_t *); +extern sym_t *decl1str(sym_t *); +extern sym_t *bitfield(sym_t *, int); +extern pqinf_t *mergepq(pqinf_t *, pqinf_t *); +extern sym_t *addptr(sym_t *, pqinf_t *); +extern sym_t *addarray(sym_t *, int, int); +extern sym_t *addfunc(sym_t *, sym_t *); +extern void chkfdef(sym_t *, int); +extern sym_t *dname(sym_t *); +extern sym_t *iname(sym_t *); +extern type_t *mktag(sym_t *, tspec_t, int, int); +extern const char *scltoa(scl_t); +extern type_t *compltag(type_t *, sym_t *); +extern sym_t *ename(sym_t *, int, int); +extern void decl1ext(sym_t *, int); +extern void cpuinfo(sym_t *, sym_t *); +extern int isredec(sym_t *, int *); +extern int eqtype(type_t *, type_t *, int, int, int *); +extern void compltyp(sym_t *, sym_t *); +extern sym_t *decl1arg(sym_t *, int); +extern void cluparg(void); +extern void decl1loc(sym_t *, int); +extern sym_t *aname(void); +extern void globclup(void); +extern sym_t *decl1abs(sym_t *); +extern void chksz(sym_t *); +extern void setsflg(sym_t *); +extern void setuflg(sym_t *, int, int); +extern void chkusage(dinfo_t *); +extern void chkusg1(int, sym_t *); +extern void chkglsyms(void); +extern void prevdecl(int, sym_t *); /* * tree.c */ -extern void initmtab __P((void)); -extern type_t *incref __P((type_t *, tspec_t)); -extern type_t *tincref __P((type_t *, tspec_t)); -extern tnode_t *getcnode __P((type_t *, val_t *)); -extern tnode_t *getnnode __P((sym_t *, int)); -extern tnode_t *getsnode __P((strg_t *)); -extern sym_t *strmemb __P((tnode_t *, op_t, sym_t *)); -extern tnode_t *build __P((op_t, tnode_t *, tnode_t *)); -extern tnode_t *cconv __P((tnode_t *)); -extern int typeok __P((op_t, int, tnode_t *, tnode_t *)); -extern tnode_t *promote __P((op_t, int, tnode_t *)); -extern tnode_t *convert __P((op_t, int, type_t *, tnode_t *)); -extern void cvtcon __P((op_t, int, type_t *, val_t *, val_t *)); -extern const char *tyname __P((type_t *)); -extern tnode_t *bldszof __P((type_t *)); -extern tnode_t *cast __P((tnode_t *, type_t *)); -extern tnode_t *funcarg __P((tnode_t *, tnode_t *)); -extern tnode_t *funccall __P((tnode_t *, tnode_t *)); -extern val_t *constant __P((tnode_t *)); -extern void expr __P((tnode_t *, int, int)); -extern void chkmisc __P((tnode_t *, int, int, int, int, int, int)); -extern int conaddr __P((tnode_t *, sym_t **, ptrdiff_t *)); -extern strg_t *catstrg __P((strg_t *, strg_t *)); +extern void initmtab(void); +extern type_t *incref(type_t *, tspec_t); +extern type_t *tincref(type_t *, tspec_t); +extern tnode_t *getcnode(type_t *, val_t *); +extern tnode_t *getnnode(sym_t *, int); +extern tnode_t *getsnode(strg_t *); +extern sym_t *strmemb(tnode_t *, op_t, sym_t *); +extern tnode_t *build(op_t, tnode_t *, tnode_t *); +extern tnode_t *cconv(tnode_t *); +extern int typeok(op_t, int, tnode_t *, tnode_t *); +extern tnode_t *promote(op_t, int, tnode_t *); +extern tnode_t *convert(op_t, int, type_t *, tnode_t *); +extern void cvtcon(op_t, int, type_t *, val_t *, val_t *); +extern const char *tyname(type_t *); +extern tnode_t *bldszof(type_t *); +extern tnode_t *cast(tnode_t *, type_t *); +extern tnode_t *funcarg(tnode_t *, tnode_t *); +extern tnode_t *funccall(tnode_t *, tnode_t *); +extern val_t *constant(tnode_t *); +extern void expr(tnode_t *, int, int); +extern void chkmisc(tnode_t *, int, int, int, int, int, int); +extern int conaddr(tnode_t *, sym_t **, ptrdiff_t *); +extern strg_t *catstrg(strg_t *, strg_t *); /* * func.c @@ -221,42 +223,44 @@ extern pos_t scflpos; extern int ccflg; extern int llibflg; extern int nowarn; +extern int bitfieldtype_ok; extern int plibflg; extern int quadflg; -extern void pushctrl __P((int)); -extern void popctrl __P((int)); -extern void chkreach __P((void)); -extern void funcdef __P((sym_t *)); -extern void funcend __P((void)); -extern void label __P((int, sym_t *, tnode_t *)); -extern void if1 __P((tnode_t *)); -extern void if2 __P((void)); -extern void if3 __P((int)); -extern void switch1 __P((tnode_t *)); -extern void switch2 __P((void)); -extern void while1 __P((tnode_t *)); -extern void while2 __P((void)); -extern void do1 __P((void)); -extern void do2 __P((tnode_t *)); -extern void for1 __P((tnode_t *, tnode_t *, tnode_t *)); -extern void for2 __P((void)); -extern void dogoto __P((sym_t *)); -extern void docont __P((void)); -extern void dobreak __P((void)); -extern void doreturn __P((tnode_t *)); -extern void glclup __P((int)); -extern void argsused __P((int)); -extern void constcond __P((int)); -extern void fallthru __P((int)); -extern void notreach __P((int)); -extern void lintlib __P((int)); -extern void linted __P((int)); -extern void varargs __P((int)); -extern void printflike __P((int)); -extern void scanflike __P((int)); -extern void protolib __P((int)); -extern void longlong __P((int)); +extern void pushctrl(int); +extern void popctrl(int); +extern void chkreach(void); +extern void funcdef(sym_t *); +extern void funcend(void); +extern void label(int, sym_t *, tnode_t *); +extern void if1(tnode_t *); +extern void if2(void); +extern void if3(int); +extern void switch1(tnode_t *); +extern void switch2(void); +extern void while1(tnode_t *); +extern void while2(void); +extern void do1(void); +extern void do2(tnode_t *); +extern void for1(tnode_t *, tnode_t *, tnode_t *); +extern void for2(void); +extern void dogoto(sym_t *); +extern void docont(void); +extern void dobreak(void); +extern void doreturn(tnode_t *); +extern void glclup(int); +extern void argsused(int); +extern void constcond(int); +extern void fallthru(int); +extern void notreach(int); +extern void lintlib(int); +extern void linted(int); +extern void varargs(int); +extern void printflike(int); +extern void scanflike(int); +extern void protolib(int); +extern void longlong(int); +extern void bitfieldtype(int); /* * init.c @@ -265,17 +269,17 @@ extern int initerr; extern sym_t *initsym; extern int startinit; -extern void prepinit __P((void)); -extern void initrbr __P((void)); -extern void initlbr __P((void)); -extern void mkinit __P((tnode_t *)); +extern void prepinit(void); +extern void initrbr(void); +extern void initlbr(void); +extern void mkinit(tnode_t *); /* * emit.c */ -extern void outtype __P((type_t *)); -extern const char *ttos __P((type_t *)); -extern void outsym __P((sym_t *, scl_t, def_t)); -extern void outfdef __P((sym_t *, pos_t *, int, int, sym_t *)); -extern void outcall __P((tnode_t *, int, int)); -extern void outusg __P((sym_t *)); +extern void outtype(type_t *); +extern const char *ttos(type_t *); +extern void outsym(sym_t *, scl_t, def_t); +extern void outfdef(sym_t *, pos_t *, int, int, sym_t *); +extern void outcall(tnode_t *, int, int); +extern void outusg(sym_t *); diff --git a/usr.bin/xlint/lint1/func.c b/usr.bin/xlint/lint1/func.c index 5d3a172..73ade1f 100644 --- a/usr.bin/xlint/lint1/func.c +++ b/usr.bin/xlint/lint1/func.c @@ -1,4 +1,4 @@ -/* $NetBSD: func.c,v 1.7 1995/10/02 17:31:40 jpo Exp $ */ +/* $NetBSD: func.c,v 1.16 2002/01/03 04:25:15 thorpej Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,15 +31,16 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: func.c,v 1.7 1995/10/02 17:31:40 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: func.c,v 1.16 2002/01/03 04:25:15 thorpej Exp $"); #endif #include #include #include "lint1.h" -#include "y.tab.h" +#include "cgram.h" /* * Contains a pointer to the symbol table entry of the current function @@ -129,6 +130,12 @@ int llibflg; int nowarn; /* + * Nonzero if bitfield type errors are suppressed by a BITFIELDTYPE + * directive. + */ +int bitfieldtype_ok; + +/* * Nonzero if complaints about use of "long long" are suppressed in * the next statement or declaration. */ @@ -138,8 +145,7 @@ int quadflg; * Puts a new element at the top of the stack used for control statements. */ void -pushctrl(env) - int env; +pushctrl(int env) { cstk_t *ci; @@ -153,8 +159,7 @@ pushctrl(env) * Removes the top element of the stack used for control statements. */ void -popctrl(env) - int env; +popctrl(int env) { cstk_t *ci; clst_t *cl; @@ -179,7 +184,7 @@ popctrl(env) * Prints a warning if a statement cannot be reached. */ void -chkreach() +chkreach(void) { if (!reached && !rchflg) { /* statement not reached */ @@ -199,8 +204,7 @@ chkreach() * redeclaration etc.. */ void -funcdef(fsym) - sym_t *fsym; +funcdef(sym_t *fsym) { int n, warn; sym_t *arg, *sym, *rdsym; @@ -322,7 +326,7 @@ funcdef(fsym) } if (dcs->d_notyp) - /* return value is implizitly declared to be int */ + /* return value is implicitly declared to be int */ fsym->s_rimpl = 1; reached = 1; @@ -332,7 +336,7 @@ funcdef(fsym) * Called at the end of a function definition. */ void -funcend() +funcend(void) { sym_t *arg; int n; @@ -368,7 +372,7 @@ funcend() /* * write the information about the function definition to the * output file - * inline functions explicitely declared extern are written as + * inline functions explicitly declared extern are written as * declarations only. */ if (dcs->d_scl == EXTERN && funcsym->s_inline) { @@ -398,14 +402,12 @@ funcend() * tn expression if typ == T_CASE */ void -label(typ, sym, tn) - int typ; - sym_t *sym; - tnode_t *tn; +label(int typ, sym_t *sym, tnode_t *tn) { cstk_t *ci; clst_t *cl; - val_t *v, *nv; + val_t *v; + val_t nv; tspec_t t; switch (typ) { @@ -422,7 +424,8 @@ label(typ, sym, tn) case T_CASE: /* find the stack entry for the innermost switch statement */ - for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_nxt) ; + for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_nxt) + continue; if (ci == NULL) { /* case not in switch */ @@ -462,28 +465,28 @@ label(typ, sym, tn) * to the type of the switch expression */ v = constant(tn); - nv = xcalloc(1, sizeof (val_t)); - cvtcon(CASE, 0, ci->c_swtype, nv, v); + (void) memset(&nv, 0, sizeof nv); + cvtcon(CASE, 0, ci->c_swtype, &nv, v); free(v); /* look if we had this value already */ for (cl = ci->c_clst; cl != NULL; cl = cl->cl_nxt) { - if (cl->cl_val.v_quad == nv->v_quad) + if (cl->cl_val.v_quad == nv.v_quad) break; } - if (cl != NULL && isutyp(nv->v_tspec)) { + if (cl != NULL && isutyp(nv.v_tspec)) { /* duplicate case in switch, %lu */ - error(200, (u_long)nv->v_quad); + error(200, (u_long)nv.v_quad); } else if (cl != NULL) { /* duplicate case in switch, %ld */ - error(199, (long)nv->v_quad); + error(199, (long)nv.v_quad); } else { /* * append the value to the list of * case values */ cl = xcalloc(1, sizeof (clst_t)); - STRUCT_ASSIGN(cl->cl_val, *nv); + STRUCT_ASSIGN(cl->cl_val, nv); cl->cl_nxt = ci->c_clst; ci->c_clst = cl; } @@ -494,7 +497,8 @@ label(typ, sym, tn) case T_DEFAULT: /* find the stack entry for the innermost switch statement */ - for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_nxt) ; + for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_nxt) + continue; if (ci == NULL) { /* default outside switch */ @@ -519,9 +523,9 @@ label(typ, sym, tn) * T_IF T_LPARN expr T_RPARN */ void -if1(tn) - tnode_t *tn; +if1(tnode_t *tn) { + if (tn != NULL) tn = cconv(tn); if (tn != NULL) @@ -535,8 +539,9 @@ if1(tn) * if_without_else T_ELSE */ void -if2() +if2(void) { + cstk->c_rchif = reached ? 1 : 0; reached = 1; } @@ -546,9 +551,9 @@ if2() * if_without_else T_ELSE stmnt */ void -if3(els) - int els; +if3(int els) { + if (els) { reached |= cstk->c_rchif; } else { @@ -561,8 +566,7 @@ if3(els) * T_SWITCH T_LPARN expr T_RPARN */ void -switch1(tn) - tnode_t *tn; +switch1(tnode_t *tn) { tspec_t t; type_t *tp; @@ -613,9 +617,9 @@ switch1(tn) * switch_expr stmnt */ void -switch2() +switch2(void) { - int nenum, nclab; + int nenum = 0, nclab = 0; sym_t *esym; clst_t *cl; @@ -668,9 +672,9 @@ switch2() * T_WHILE T_LPARN expr T_RPARN */ void -while1(tn) - tnode_t *tn; +while1(tnode_t *tn) { + if (!reached) { /* loop not entered at top */ warning(207); @@ -705,8 +709,9 @@ while1(tn) * while_expr error */ void -while2() +while2(void) { + /* * The end of the loop can be reached if it is no endless loop * or there was a break statement which was reached. @@ -721,8 +726,9 @@ while2() * T_DO */ void -do1() +do1(void) { + if (!reached) { /* loop not entered at top */ warning(207); @@ -738,9 +744,9 @@ do1() * do error */ void -do2(tn) - tnode_t *tn; +do2(tnode_t *tn) { + /* * If there was a continue statement the expression controlling the * loop is reached. @@ -782,9 +788,9 @@ do2(tn) * T_FOR T_LPARN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPARN */ void -for1(tn1, tn2, tn3) - tnode_t *tn1, *tn2, *tn3; +for1(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3) { + /* * If there is no initialisation expression it is possible that * it is intended not to enter the loop at top. @@ -843,7 +849,7 @@ for1(tn1, tn2, tn3) * for_exprs error */ void -for2() +for2(void) { pos_t cpos, cspos; tnode_t *tn3; @@ -888,9 +894,9 @@ for2() * T_GOTO error T_SEMI */ void -dogoto(lab) - sym_t *lab; +dogoto(sym_t *lab) { + setuflg(lab, 0, 0); chkreach(); @@ -902,7 +908,7 @@ dogoto(lab) * T_BREAK T_SEMI */ void -dobreak() +dobreak(void) { cstk_t *ci; @@ -928,11 +934,12 @@ dobreak() * T_CONTINUE T_SEMI */ void -docont() +docont(void) { cstk_t *ci; - for (ci = cstk; ci != NULL && !ci->c_loop; ci = ci->c_nxt) ; + for (ci = cstk; ci != NULL && !ci->c_loop; ci = ci->c_nxt) + continue; if (ci == NULL) { /* continue outside loop */ @@ -951,14 +958,14 @@ docont() * T_RETURN expr T_SEMI */ void -doreturn(tn) - tnode_t *tn; +doreturn(tnode_t *tn) { tnode_t *ln, *rn; cstk_t *ci; op_t op; - for (ci = cstk; ci->c_nxt != NULL; ci = ci->c_nxt) ; + for (ci = cstk; ci->c_nxt != NULL; ci = ci->c_nxt) + continue; if (tn != NULL) { ci->c_retval = 1; @@ -1020,8 +1027,7 @@ doreturn(tn) * Especially remove informations about unused lint comments. */ void -glclup(silent) - int silent; +glclup(int silent) { pos_t cpos; @@ -1072,9 +1078,9 @@ glclup(silent) * for usage. A missing argument is taken to be 0. */ void -argsused(n) - int n; +argsused(int n) { + if (n == -1) n = 0; @@ -1098,9 +1104,9 @@ argsused(n) * to the function definition. A missing argument is taken to be 0. */ void -varargs(n) - int n; +varargs(int n) { + if (n == -1) n = 0; @@ -1124,9 +1130,9 @@ varargs(n) * used the check the types of remaining arguments. */ void -printflike(n) - int n; +printflike(int n) { + if (n == -1) n = 0; @@ -1150,9 +1156,9 @@ printflike(n) * used the check the types of remaining arguments. */ void -scanflike(n) - int n; +scanflike(int n) { + if (n == -1) n = 0; @@ -1175,9 +1181,9 @@ scanflike(n) */ /* ARGSUSED */ void -constcond(n) - int n; +constcond(int n) { + ccflg = 1; } @@ -1187,9 +1193,9 @@ constcond(n) */ /* ARGSUSED */ void -fallthru(n) - int n; +fallthru(int n) { + ftflg = 1; } @@ -1199,18 +1205,18 @@ fallthru(n) */ /* ARGSUSED */ void -notreach(n) - int n; +notreach(int n) { + reached = 0; rchflg = 1; } /* ARGSUSED */ void -lintlib(n) - int n; +lintlib(int n) { + if (dcs->d_ctx != EXTERN) { /* must be outside function: ** %s ** */ warning(280, "LINTLIBRARY"); @@ -1225,21 +1231,39 @@ lintlib(n) */ /* ARGSUSED */ void -linted(n) - int n; +linted(int n) { + +#ifdef DEBUG + printf("%s, %d: nowarn = 1\n", curr_pos.p_file, curr_pos.p_line); +#endif nowarn = 1; } /* + * Suppress bitfield type errors on the current line. + */ +/* ARGSUSED */ +void +bitfieldtype(int n) +{ + +#ifdef DEBUG + printf("%s, %d: bitfieldtype_ok = 1\n", curr_pos.p_file, + curr_pos.p_line); +#endif + bitfieldtype_ok = 1; +} + +/* * PROTOTLIB in conjunction with LINTLIBRARY can be used to handle * prototypes like function definitions. This is done if the argument * to PROTOLIB is nonzero. Otherwise prototypes are handled normaly. */ void -protolib(n) - int n; +protolib(int n) { + if (dcs->d_ctx != EXTERN) { /* must be outside function: ** %s ** */ warning(280, "PROTOLIB"); @@ -1254,8 +1278,8 @@ protolib(n) */ /* ARGSUSED */ void -longlong(n) - int n; +longlong(int n) { + quadflg = 1; } diff --git a/usr.bin/xlint/lint1/init.c b/usr.bin/xlint/lint1/init.c index dbd216b..0fd0383 100644 --- a/usr.bin/xlint/lint1/init.c +++ b/usr.bin/xlint/lint1/init.c @@ -1,4 +1,4 @@ -/* $NetBSD: init.c,v 1.4 1995/10/02 17:21:37 jpo Exp $ */ +/* $NetBSD: init.c,v 1.9 2001/09/18 18:15:54 wiz Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,8 +31,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: init.c,v 1.4 1995/10/02 17:21:37 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: init.c,v 1.9 2001/09/18 18:15:54 wiz Exp $"); #endif #include @@ -40,7 +41,7 @@ static char rcsid[] = "$NetBSD: init.c,v 1.4 1995/10/02 17:21:37 jpo Exp $"; #include "lint1.h" /* - * initerr is set as soon as a fatal error occured in an initialisation. + * initerr is set as soon as a fatal error occurred in an initialisation. * The effect is that the rest of the initialisation is ignored (parsed * by yacc, expression trees built, but no initialisation takes place). */ @@ -53,12 +54,12 @@ sym_t *initsym; istk_t *initstk; -static void popi2 __P((void)); -static void popinit __P((int)); -static void pushinit __P((void)); -static void testinit __P((void)); -static void nextinit __P((int)); -static int strginit __P((tnode_t *)); +static void popi2(void); +static void popinit(int); +static void pushinit(void); +static void testinit(void); +static void nextinit(int); +static int strginit(tnode_t *); /* @@ -66,7 +67,7 @@ static int strginit __P((tnode_t *)); * which is to be initialized on it. */ void -prepinit() +prepinit(void) { istk_t *istk; @@ -93,7 +94,7 @@ prepinit() } static void -popi2() +popi2(void) { istk_t *istk; sym_t *m; @@ -124,9 +125,9 @@ popi2() } static void -popinit(brace) - int brace; +popinit(int brace) { + if (brace) { /* * Take all entries, including the first which requires @@ -150,7 +151,7 @@ popinit(brace) } static void -pushinit() +pushinit(void) { istk_t *istk; int cnt; @@ -235,7 +236,7 @@ pushinit() } static void -testinit() +testinit(void) { istk_t *istk; @@ -266,9 +267,9 @@ testinit() } static void -nextinit(brace) - int brace; +nextinit(int brace) { + if (!brace) { if (initstk->i_type == NULL && !issclt(initstk->i_subt->t_tspec)) { @@ -303,8 +304,9 @@ nextinit(brace) } void -initlbr() +initlbr(void) { + if (initerr) return; @@ -325,8 +327,9 @@ initlbr() } void -initrbr() +initrbr(void) { + if (initerr) return; @@ -334,8 +337,7 @@ initrbr() } void -mkinit(tn) - tnode_t *tn; +mkinit(tnode_t *tn) { ptrdiff_t offs; sym_t *sym; @@ -351,7 +353,7 @@ mkinit(tn) /* * Do not test for automatic aggregat initialisation. If the - * initalizer starts with a brace we have the warning already. + * initializer starts with a brace we have the warning already. * If not, an error will be printed that the initializer must * be enclosed by braces. */ @@ -412,7 +414,7 @@ mkinit(tn) tmem = tsave(); expr(tn, 1, 0); trestor(tmem); - + if (isityp(lt) && ln->tn_type->t_isfield && !isityp(rt)) { /* * Bit-fields can be initialized in trad. C only by integer @@ -446,8 +448,7 @@ mkinit(tn) static int -strginit(tn) - tnode_t *tn; +strginit(tnode_t *tn) { tspec_t t; istk_t *istk; diff --git a/usr.bin/xlint/lint1/lint1.h b/usr.bin/xlint/lint1/lint1.h index 019c98d..278019e 100644 --- a/usr.bin/xlint/lint1/lint1.h +++ b/usr.bin/xlint/lint1/lint1.h @@ -1,6 +1,7 @@ -/* $NetBSD: lint1.h,v 1.6 1995/10/02 17:31:41 jpo Exp $ */ +/* $NetBSD: lint1.h,v 1.12 2002/01/31 19:33:27 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -34,14 +35,29 @@ #include "lint.h" #include "op.h" +/* XXX - works for most systems, but the whole ALIGN thing needs to go away */ +#ifndef ALIGN +#define ALIGN(x) (((x) + 7) & ~7) +#endif + /* * Describes the position of a declaration or anything else. */ typedef struct { int p_line; const char *p_file; + int p_uniq; /* uniquifier */ } pos_t; +/* Copies curr_pos, keeping things unique. */ +#define UNIQUE_CURR_POS(pos) \ + do { \ + STRUCT_ASSIGN((pos), curr_pos); \ + curr_pos.p_uniq++; \ + if (curr_pos.p_file == csrc_pos.p_file) \ + csrc_pos.p_uniq++; \ + } while (0) + /* * Strings cannot be referenced to simply by a pointer to its first * char. This is because strings can contain NUL characters other than the @@ -76,7 +92,7 @@ typedef struct { int v_ansiu; /* set if an integer constant is unsigned in ANSI C */ union { - quad_t _v_quad; /* integers */ + int64_t _v_quad; /* integers */ ldbl_t _v_ldbl; /* floats */ } v_u; } val_t; @@ -132,11 +148,11 @@ typedef struct type { str_t *_t_str; /* struct/union tag */ enum_t *_t_enum; /* enum tag */ struct sym *_t_args; /* arguments (if t_proto) */ - struct { - u_int _t_flen : 8; /* length of bit-field */ - u_int _t_foffs : 24; /* offset of bit-field */ - } _t_u; } t_u; + struct { + u_int _t_flen : 8; /* length of bit-field */ + u_int _t_foffs : 24; /* offset of bit-field */ + } t_b; struct type *t_subt; /* element type (arrays), return value (functions), or type pointer points to */ } type_t; @@ -146,8 +162,8 @@ typedef struct type { #define t_field t_u._t_field #define t_enum t_u._t_enum #define t_args t_u._t_args -#define t_flen t_u._t_u._t_flen -#define t_foffs t_u._t_u._t_foffs +#define t_flen t_b._t_flen +#define t_foffs t_b._t_foffs /* * types of symbols @@ -187,6 +203,7 @@ typedef enum { */ typedef struct sym { const char *s_name; /* name */ + const char *s_rename; /* renamed symbol's given name */ pos_t s_dpos; /* position of last (prototype)definition, prototypedeclaration, no-prototype-def., tentative definition or declaration, @@ -378,3 +395,20 @@ typedef struct cstk { } cstk_t; #include "externs1.h" + +#define ERR_SETSIZE 1024 +#define __NERRBITS (sizeof(unsigned int)) + +typedef struct err_set { + unsigned int errs_bits[(ERR_SETSIZE + __NERRBITS-1) / __NERRBITS]; +} err_set; + +#define ERR_SET(n, p) \ + ((p)->errs_bits[(n)/__NERRBITS] |= (1 << ((n) % __NERRBITS))) +#define ERR_CLR(n, p) \ + ((p)->errs_bits[(n)/__NERRBITS] &= ~(1 << ((n) % __NERRBITS))) +#define ERR_ISSET(n, p) \ + ((p)->errs_bits[(n)/__NERRBITS] & (1 << ((n) % __NERRBITS))) +#define ERR_ZERO(p) (void)memset((p), 0, sizeof(*(p))) + +extern err_set msgset; diff --git a/usr.bin/xlint/lint1/main1.c b/usr.bin/xlint/lint1/main1.c index 0add206..f04d817 100644 --- a/usr.bin/xlint/lint1/main1.c +++ b/usr.bin/xlint/lint1/main1.c @@ -1,4 +1,4 @@ -/* $NetBSD: main1.c,v 1.3 1995/10/02 17:29:56 jpo Exp $ */ +/* $NetBSD: main1.c,v 1.11 2002/01/29 02:43:38 tv Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,14 +31,18 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: main1.c,v 1.3 1995/10/02 17:29:56 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: main1.c,v 1.11 2002/01/29 02:43:38 tv Exp $"); #endif +#include #include +#include #include #include -#include +#include +#include #include "lint1.h" @@ -49,7 +53,7 @@ int yflag; * Print warnings if an assignment of an integertype to another integertype * causes an implizit narrowing conversion. If aflag is 1, these warnings * are printed only if the source type is at least as wide as long. If aflag - * is greather then 1, they are always printed. + * is greater than 1, they are always printed. */ int aflag; @@ -71,6 +75,9 @@ int Fflag; /* Enable some extensions of gcc */ int gflag; +/* Treat warnings as errors */ +int wflag; + /* * Apply a number of heuristic tests to attempt to intuit bugs, improve * style, and reduce waste. @@ -104,16 +111,22 @@ int vflag = 1; /* Complain about structures which are never defined. */ int zflag = 1; -static void usage __P((void)); +err_set msgset; + +static void usage(void); + +int main(int, char *[]); int -main(argc, argv) - int argc; - char *argv[]; +main(int argc, char *argv[]) { int c; + char *ptr; - while ((c = getopt(argc, argv, "abcdeghprstuvyzF")) != -1) { + setprogname(argv[0]); + + ERR_ZERO(&msgset); + while ((c = getopt(argc, argv, "abcdeghmprstuvwyzFX:")) != -1) { switch (c) { case 'a': aflag++; break; case 'b': bflag = 1; break; @@ -128,10 +141,35 @@ main(argc, argv) case 's': sflag = 1; break; case 't': tflag = 1; break; case 'u': uflag = 0; break; + case 'w': wflag = 1; break; case 'v': vflag = 0; break; case 'y': yflag = 1; break; case 'z': zflag = 0; break; - case '?': usage(); + + case 'm': + msglist(); + return(0); + + case 'X': + for (ptr = strtok(optarg, ","); ptr; + ptr = strtok(NULL, ",")) { + char *eptr; + long msg = strtol(ptr, &eptr, 0); + if ((msg == LONG_MIN || msg == LONG_MAX) && + errno == ERANGE) + err(1, "invalid error message id '%s'", + ptr); + if (*eptr || ptr == eptr || msg < 0 || + msg >= ERR_SETSIZE) + errx(1, "invalid error message id '%s'", + ptr); + ERR_SET(msg, &msgset); + } + break; + case '?': + default: + usage(); + break; } } argc -= optind; @@ -168,14 +206,16 @@ main(argc, argv) } static void -usage() +usage(void) { - (void)fprintf(stderr, "usage: lint1 [-abcdeghprstuvyzF] src dest\n"); + (void)fprintf(stderr, + "Usage: %s [-abcdeghmprstuvwyzF] [-X [,]... src dest\n", + getprogname()); exit(1); } - + void -norecover() +norecover(void) { /* cannot recover from previous errors */ error(224); diff --git a/usr.bin/xlint/lint1/makeman b/usr.bin/xlint/lint1/makeman new file mode 100644 index 0000000..721e825 --- /dev/null +++ b/usr.bin/xlint/lint1/makeman @@ -0,0 +1,94 @@ +#!/bin/sh +# $NetBSD$ +# +# Copyright (c) 2000 The NetBSD Foundation, Inc. +# All rights reserved. +# +# This code is derived from software contributed to The NetBSD Foundation +# by Christos Zoulas. +# +# 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 the NetBSD +# Foundation, Inc. and its contributors. +# 4. Neither the name of The NetBSD Foundation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS +# ``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 FOUNDATION OR CONTRIBUTORS +# 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. + + +cat << \__EOF +.\" $NetBSD$ +.\" +.\" Copyright (c) 2000 The NetBSD Foundation, Inc. +.\" All rights reserved. +.\" +.\" This code is derived from software contributed to The NetBSD Foundation +.\" by Christos Zoulas. +.\" +.\" 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 the NetBSD +.\" Foundation, Inc. and its contributors. +.\" 4. Neither the name of The NetBSD Foundation nor the names of its +.\" contributors may be used to endorse or promote products derived +.\" from this software without specific prior written permission. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS +.\" ``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 FOUNDATION OR CONTRIBUTORS +.\" 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. +.Dd July 5, 2000 +.Dt LINT 7 +.Os +.Sh NAME +.Nm lint +.Nd Lint error message list +.Sh DESCRIPTION +The following is a list of message id's and messages produced by +.Xr lint 1 . +It is intended to be used with +.Fl X +flag of +.Xr lint 1 . +.Pp +.Bd -ragged -offset indent -compact +.Bl -column "Id# Message" +__EOF +"$@" | sed -e 's/^/.It /' -e 's/\\/\\e/g' -e "s/'/\\'/" +echo ".El" +echo ".Ed" diff --git a/usr.bin/xlint/lint1/mem1.c b/usr.bin/xlint/lint1/mem1.c index df880b1..4e21f07 100644 --- a/usr.bin/xlint/lint1/mem1.c +++ b/usr.bin/xlint/lint1/mem1.c @@ -1,4 +1,4 @@ -/* $NetBSD: mem1.c,v 1.2 1995/07/03 21:24:25 cgd Exp $ */ +/* $NetBSD: mem1.c,v 1.6 2002/01/29 02:43:39 tv Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,8 +31,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: mem1.c,v 1.2 1995/07/03 21:24:25 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: mem1.c,v 1.6 2002/01/29 02:43:39 tv Exp $"); #endif #include @@ -41,7 +42,6 @@ static char rcsid[] = "$NetBSD: mem1.c,v 1.2 1995/07/03 21:24:25 cgd Exp $"; #include #include #include -#include #include "lint1.h" @@ -57,15 +57,13 @@ typedef struct fn { static fn_t *fnames; -static fn_t *srchfn __P((const char *, size_t)); +static fn_t *srchfn(const char *, size_t); /* * Look for a Filename of length l. */ static fn_t * -srchfn(s, len) - const char *s; - size_t len; +srchfn(const char *s, size_t len) { fn_t *fn; @@ -80,16 +78,14 @@ srchfn(s, len) * Return a shared string for filename s. */ const char * -fnalloc(s) - const char *s; +fnalloc(const char *s) { + return (s != NULL ? fnnalloc(s, strlen(s)) : NULL); } const char * -fnnalloc(s, len) - const char *s; - size_t len; +fnnalloc(const char *s, size_t len) { fn_t *fn; @@ -121,8 +117,7 @@ fnnalloc(s, len) * Get id of a filename. */ int -getfnid(s) - const char *s; +getfnid(const char *s) { fn_t *fn; @@ -163,12 +158,12 @@ static mbl_t *frmblks; /* length of new allocated memory blocks */ static size_t mblklen; -static void *xgetblk __P((mbl_t **, size_t)); -static void xfreeblk __P((mbl_t **)); -static mbl_t *xnewblk __P((void)); +static void *xgetblk(mbl_t **, size_t); +static void xfreeblk(mbl_t **); +static mbl_t *xnewblk(void); static mbl_t * -xnewblk() +xnewblk(void) { mbl_t *mb; int prot, flags; @@ -182,8 +177,6 @@ xnewblk() mb->blk = mmap(NULL, mblklen, prot, flags, -1, (off_t)0); if (mb->blk == (void *)-1) err(1, "can't map memory"); - if (ALIGN((u_long)mb->blk) != (u_long)mb->blk) - errx(1, "mapped address is not aligned"); mb->size = mblklen; @@ -199,9 +192,7 @@ xnewblk() * zero'd in xfreeblk(). */ static void * -xgetblk(mbp, s) - mbl_t **mbp; - size_t s; +xgetblk(mbl_t **mbp, size_t s) { mbl_t *mb; void *p; @@ -230,8 +221,7 @@ xgetblk(mbp, s) * used memory to zero. */ static void -xfreeblk(fmbp) - mbl_t **fmbp; +xfreeblk(mbl_t **fmbp) { mbl_t *mb; @@ -244,7 +234,7 @@ xfreeblk(fmbp) } void -initmem() +initmem(void) { int pgsz; @@ -254,15 +244,14 @@ initmem() mblks = xcalloc(nmblks = ML_INC, sizeof (mbl_t *)); } - + /* * Allocate memory associated with level l. */ void * -getlblk(l, s) - int l; - size_t s; +getlblk(int l, size_t s) { + while (l >= nmblks) { mblks = xrealloc(mblks, (nmblks + ML_INC) * sizeof (mbl_t *)); (void)memset(&mblks[nmblks], 0, ML_INC * sizeof (mbl_t *)); @@ -272,9 +261,9 @@ getlblk(l, s) } void * -getblk(s) - size_t s; +getblk(size_t s) { + return (getlblk(mblklev, s)); } @@ -282,15 +271,16 @@ getblk(s) * Free all memory associated with level l. */ void -freelblk(l) - int l; +freelblk(int l) { + xfreeblk(&mblks[l]); } void -freeblk() +freeblk(void) { + freelblk(mblklev); } @@ -301,9 +291,9 @@ freeblk() static mbl_t *tmblk; void * -tgetblk(s) - size_t s; +tgetblk(size_t s) { + return (xgetblk(&tmblk, s)); } @@ -311,17 +301,19 @@ tgetblk(s) * Get memory for a new tree node. */ tnode_t * -getnode() +getnode(void) { + return (tgetblk(sizeof (tnode_t))); } /* - * Free all memory which is allocated by the the current expression. + * Free all memory which is allocated by the current expression. */ void -tfreeblk() +tfreeblk(void) { + xfreeblk(&tmblk); } @@ -331,7 +323,7 @@ tfreeblk() * used to restore the memory. */ mbl_t * -tsave() +tsave(void) { mbl_t *tmem; @@ -346,9 +338,9 @@ tsave() * tfreeblk() frees the restored memory. */ void -trestor(tmem) - mbl_t *tmem; +trestor(mbl_t *tmem) { + tfreeblk(); if (tmblk != NULL) { free(tmblk->blk); diff --git a/usr.bin/xlint/lint1/op.h b/usr.bin/xlint/lint1/op.h index 11f05a5..042195a 100644 --- a/usr.bin/xlint/lint1/op.h +++ b/usr.bin/xlint/lint1/op.h @@ -48,7 +48,7 @@ typedef struct { u_int m_tlansiu : 1; /* warning if left op. is unsign. in ANSI C */ u_int m_transiu : 1; /* warning if right op. is unsign. in ANSI C */ u_int m_tpconf : 1; /* test possible precedence confusion */ - u_int m_comp : 1; /* op. performs comparision */ + u_int m_comp : 1; /* op. performs comparison */ u_int m_enumop : 1; /* valid operation on enums */ u_int m_badeop : 1; /* dubious operation on enums */ u_int m_eqwarn : 1; /* warning if on operand stems from == */ diff --git a/usr.bin/xlint/lint1/scan.l b/usr.bin/xlint/lint1/scan.l index 5e23c6b..bd18f73 100644 --- a/usr.bin/xlint/lint1/scan.l +++ b/usr.bin/xlint/lint1/scan.l @@ -1,7 +1,8 @@ %{ -/* $NetBSD: scan.l,v 1.8 1995/10/23 13:38:51 jpo Exp $ */ +/* $NetBSD: scan.l,v 1.26 2002/01/31 22:30:21 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -32,8 +33,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: scan.l,v 1.8 1995/10/23 13:38:51 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: scan.l,v 1.26 2002/01/31 22:30:21 tv Exp $"); #endif #include @@ -43,44 +45,42 @@ static char rcsid[] = "$NetBSD: scan.l,v 1.8 1995/10/23 13:38:51 jpo Exp $"; #include #include #include -#include #include "lint1.h" -#include "y.tab.h" +#include "cgram.h" #define CHAR_MASK (~(~0 << CHAR_BIT)) - -/* XXX declaration of strtouq() is missing in stdlib.h ? */ -extern u_quad_t strtouq __P((const char *, char **, int)); +#define YY_NO_UNPUT /* Current position (its also updated when an included file is parsed) */ -pos_t curr_pos = { 1, "" }; +pos_t curr_pos = { 1, "", 0 }; /* * Current position in C source (not updated when an included file is * parsed). */ -pos_t csrc_pos = { 1, "" }; - -static void incline __P((void)); -static void badchar __P((int)); -static sbuf_t *allocsb __P((void)); -static void freesb __P((sbuf_t *)); -static int inpc __P((void)); -static int hash __P((const char *)); -static sym_t *search __P((sbuf_t *)); -static int name __P((void)); -static int keyw __P((sym_t *)); -static int icon __P((int)); -static int fcon __P((void)); -static int operator __P((int, op_t)); -static int ccon __P((void)); -static int wccon __P((void)); -static int getescc __P((int)); -static void directive __P((void)); -static void comment __P((void)); -static int string __P((void)); -static int wcstrg __P((void)); +pos_t csrc_pos = { 1, "", 0 }; + +static void incline(void); +static void badchar(int); +static sbuf_t *allocsb(void); +static void freesb(sbuf_t *); +static int inpc(void); +static int hash(const char *); +static sym_t *search(sbuf_t *); +static int name(void); +static int keyw(sym_t *); +static int icon(int); +static int fcon(void); +static int operator(int, op_t); +static int ccon(void); +static int wccon(void); +static int getescc(int); +static void directive(void); +static void comment(void); +static void slashslashcomment(void); +static int string(void); +static int wcstrg(void); %} @@ -154,22 +154,26 @@ EX ([eE][+-]?[0-9]+) \n incline(); \t|" "|\f|\v ; "/*" comment(); +"//" slashslashcomment(); . badchar(yytext[0]); %% static void -incline() +incline(void) { curr_pos.p_line++; - if (curr_pos.p_file == csrc_pos.p_file) + curr_pos.p_uniq = 0; + if (curr_pos.p_file == csrc_pos.p_file) { csrc_pos.p_line++; + csrc_pos.p_uniq = 0; + } } static void -badchar(c) - int c; +badchar(int c) { + /* unknown character \%o */ error(250, c); } @@ -212,6 +216,7 @@ static struct kwtab { { "__inline__", T_SCLASS, INLINE, 0, 0, 0, 0 }, { "__inline", T_SCLASS, INLINE, 0, 0, 0, 0 }, { "int", T_TYPE, 0, INT, 0, 0, 0 }, + { "__symbolrename", T_SYMBOLRENAME, 0, 0, 0, 0, 0 }, { "long", T_TYPE, 0, LONG, 0, 0, 0 }, { "register", T_SCLASS, REG, 0, 0, 0, 0 }, { "return", T_RETURN, 0, 0, 0, 0, 0 }, @@ -238,13 +243,13 @@ static struct kwtab { static sym_t *symtab[HSHSIZ1]; /* bit i of the entry with index i is set */ -u_quad_t qbmasks[sizeof(u_quad_t) * CHAR_BIT]; +uint64_t qbmasks[sizeof(uint64_t) * CHAR_BIT]; /* least significant i bits are set in the entry with index i */ -u_quad_t qlmasks[sizeof(u_quad_t) * CHAR_BIT + 1]; +uint64_t qlmasks[sizeof(uint64_t) * CHAR_BIT + 1]; /* least significant i bits are not set in the entry with index i */ -u_quad_t qumasks[sizeof(u_quad_t) * CHAR_BIT + 1]; +uint64_t qumasks[sizeof(uint64_t) * CHAR_BIT + 1]; /* free list for sbuf structures */ static sbuf_t *sbfrlst; @@ -258,12 +263,12 @@ symt_t symtyp; * in a extra table for each name we found. */ void -initscan() +initscan(void) { struct kwtab *kw; sym_t *sym; int h, i; - u_quad_t uq; + uint64_t uq; for (kw = kwtab; kw->kw_name != NULL; kw++) { if (kw->kw_stdc && tflag) @@ -288,21 +293,21 @@ initscan() } /* initialize bit-masks for quads */ - for (i = 0; i < sizeof (u_quad_t) * CHAR_BIT; i++) { - qbmasks[i] = (u_quad_t)1 << i; - uq = ~(u_quad_t)0 << i; + for (i = 0; i < sizeof (uint64_t) * CHAR_BIT; i++) { + qbmasks[i] = (uint64_t)1 << i; + uq = ~(uint64_t)0 << i; qumasks[i] = uq; qlmasks[i] = ~uq; } qumasks[i] = 0; - qlmasks[i] = ~(u_quad_t)0; + qlmasks[i] = ~(uint64_t)0; } /* * Get a free sbuf structure, if possible from the free list */ static sbuf_t * -allocsb() +allocsb(void) { sbuf_t *sb; @@ -319,9 +324,9 @@ allocsb() * Put a sbuf structure to the free list */ static void -freesb(sb) - sbuf_t *sb; +freesb(sbuf_t *sb) { + sb->sb_nxt = sbfrlst; sbfrlst = sb; } @@ -331,7 +336,7 @@ freesb(sb) * Increment line count(s) if necessary. */ static int -inpc() +inpc(void) { int c; @@ -341,8 +346,7 @@ inpc() } static int -hash(s) - const char *s; +hash(const char *s) { u_int v; const u_char *us; @@ -371,7 +375,7 @@ hash(s) * to the symbol table entry. */ static int -name() +name(void) { char *s; sbuf_t *sb; @@ -409,8 +413,7 @@ name() } static sym_t * -search(sb) - sbuf_t *sb; +search(sbuf_t *sb) { sym_t *sym; @@ -423,10 +426,9 @@ search(sb) return (NULL); } - + static int -keyw(sym) - sym_t *sym; +keyw(sym_t *sym) { int t; @@ -445,16 +447,15 @@ keyw(sym) * The value is returned in yylval. icon() (and yylex()) returns T_CON. */ static int -icon(base) - int base; +icon(int base) { int l_suffix, u_suffix; int len; const char *cp; char c, *eptr; tspec_t typ; - u_long ul; - u_quad_t uq; + u_long ul = 0; + uint64_t uq = 0; int ansiu; static tspec_t contypes[2][3] = { { INT, LONG, QUAD }, @@ -509,7 +510,7 @@ icon(base) warning(252); /* - * If the value is to big for the current type, we must choose + * If the value is to big for the current type, we must choose * another type. */ ansiu = 0; @@ -555,21 +556,45 @@ icon(base) } break; /* LINTED (enumeration values not handled in switch) */ + case STRUCT: + case VOID: + case LDOUBLE: + case FUNC: + case ARRAY: + case PTR: + case ENUM: + case UNION: + case SIGNED: + case NOTSPEC: + case DOUBLE: + case FLOAT: + case UQUAD: + case ULONG: + case USHORT: + case SHORT: + case UCHAR: + case SCHAR: + case CHAR: + case UNSIGN: + break; + + case NTSPEC: /* this value unused */ + break; } if (typ != QUAD && typ != UQUAD) { if (isutyp(typ)) { uq = ul; } else { - uq = (quad_t)(long)ul; + uq = (int64_t)(long)ul; } } - uq = (u_quad_t)xsign((quad_t)uq, typ, -1); + uq = (uint64_t)xsign((int64_t)uq, typ, -1); (yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ; yylval.y_val->v_ansiu = ansiu; - yylval.y_val->v_quad = (quad_t)uq; + yylval.y_val->v_quad = (int64_t)uq; return (T_CON); } @@ -581,22 +606,18 @@ icon(base) * to the width of type t. */ int -sign(q, t, len) - quad_t q; - tspec_t t; - int len; +sign(int64_t q, tspec_t t, int len) { + if (t == PTR || isutyp(t)) return (0); return (msb(q, t, len)); } int -msb(q, t, len) - quad_t q; - tspec_t t; - int len; +msb(int64_t q, tspec_t t, int len) { + if (len <= 0) len = size(t); return ((q & qbmasks[len - 1]) != 0); @@ -605,12 +626,10 @@ msb(q, t, len) /* * Extends the sign of q. */ -quad_t -xsign(q, t, len) - quad_t q; - tspec_t t; - int len; +int64_t +xsign(int64_t q, tspec_t t, int len) { + if (len <= 0) len = size(t); @@ -627,17 +646,17 @@ xsign(q, t, len) * representation. Type and value are returned in yylval. fcon() * (and yylex()) returns T_CON. * XXX Currently it is not possible to convert constants of type - * long double which are greater then DBL_MAX. + * long double which are greater than DBL_MAX. */ static int -fcon() +fcon(void) { const char *cp; int len; tspec_t typ; char c, *eptr; double d; - float f; + float f = 0; cp = yytext; len = yyleng; @@ -667,7 +686,7 @@ fcon() if (typ == FLOAT) { f = (float)d; - if (isinf(f)) { + if (!finite(f)) { /* floating-point constant out of range */ warning(248); f = f > 0 ? FLT_MAX : -FLT_MAX; @@ -685,10 +704,9 @@ fcon() } static int -operator(t, o) - int t; - op_t o; +operator(int t, op_t o) { + yylval.y_op = o; return (t); } @@ -697,7 +715,7 @@ operator(t, o) * Called if lex found a leading \'. */ static int -ccon() +ccon(void) { int n, val, c; char cv; @@ -727,7 +745,7 @@ ccon() cv = (char)val; val = cv; } - + yylval.y_val = xcalloc(1, sizeof (val_t)); yylval.y_val->v_tspec = INT; yylval.y_val->v_quad = val; @@ -739,7 +757,7 @@ ccon() * Called if lex found a leading L\' */ static int -wccon() +wccon(void) { static char buf[MB_LEN_MAX + 1]; int i, c; @@ -789,11 +807,10 @@ wccon() * string. * * Returns -1 if the end of the character constant or string is reached, - * -2 if the EOF is reached, and the charachter otherwise. + * -2 if the EOF is reached, and the character otherwise. */ static int -getescc(d) - int d; +getescc(int d) { static int pbc = -1; int n, c, v; @@ -808,9 +825,12 @@ getescc(d) return (-1); switch (c) { case '\n': - /* newline in string or char constant */ - error(254); - return (-2); + if (tflag) { + /* newline in string or char constant */ + error(254); + return (-2); + } + return (c); case EOF: return (-2); case '\\': @@ -833,11 +853,7 @@ getescc(d) if (tflag) /* \a undefined in traditional C */ warning(81); -#ifdef __STDC__ return ('\a'); -#else - return ('\007'); -#endif case 'b': return ('\b'); case 'f': @@ -852,11 +868,7 @@ getescc(d) if (tflag) /* \v undefined in traditional C */ warning(264); -#ifdef __STDC__ return ('\v'); -#else - return ('\013'); -#endif case '8': case '9': /* bad octal digit %c */ warning(77, c); @@ -930,7 +942,7 @@ getescc(d) * # lineno "filename" */ static void -directive() +directive(void) { const char *cp, *fn; char c, *eptr; @@ -939,9 +951,10 @@ directive() static int first = 1; /* Go to first non-whitespace after # */ - for (cp = yytext + 1; (c = *cp) == ' ' || c == '\t'; cp++) ; + for (cp = yytext + 1; (c = *cp) == ' ' || c == '\t'; cp++) + continue; - if (!isdigit(c)) { + if (!isdigit((unsigned char)c)) { error: /* undefined or invalid # directive */ warning(255); @@ -952,7 +965,8 @@ directive() goto error; if ((c = *(cp = eptr)) != ' ' && c != '\t' && c != '\0') goto error; - while ((c = *cp++) == ' ' || c == '\t') ; + while ((c = *cp++) == ' ' || c == '\t') + continue; if (c != '\0') { if (c != '"') goto error; @@ -963,11 +977,18 @@ directive() goto error; if ((fnl = cp++ - fn) > PATH_MAX) goto error; - while ((c = *cp++) == ' ' || c == '\t') ; + while ((c = *cp++) == ' ' || c == '\t') + continue; #if 0 if (c != '\0') warning("extra character(s) after directive"); #endif + + /* empty string means stdin */ + if (fnl == 0) { + fn = "{standard input}"; + fnl = 16; /* strlen (fn) */ + } curr_pos.p_file = fnnalloc(fn, fnl); /* * If this is the first directive, the name is the name @@ -981,13 +1002,17 @@ directive() } } curr_pos.p_line = (int)ln - 1; - if (curr_pos.p_file == csrc_pos.p_file) + curr_pos.p_uniq = 0; + if (curr_pos.p_file == csrc_pos.p_file) { csrc_pos.p_line = (int)ln - 1; + csrc_pos.p_uniq = 0; + } } /* * Handle lint comments. Following comments are currently understood: * ARGSUSEDn + * BITFIELDTYPE * CONSTCOND CONSTANTCOND CONSTANTCONDITION * FALLTHRU FALLTHROUGH * LINTLIBRARY @@ -1002,15 +1027,16 @@ directive() * parsed and a function which handles this comment is called. */ static void -comment() +comment(void) { int c, lc; static struct { const char *keywd; int arg; - void (*func) __P((int)); + void (*func)(int); } keywtab[] = { { "ARGSUSED", 1, argsused }, + { "BITFIELDTYPE", 0, bitfieldtype }, { "CONSTCOND", 0, constcond }, { "CONSTANTCOND", 0, constcond }, { "CONSTANTCONDITION", 0, constcond }, @@ -1034,7 +1060,8 @@ comment() eoc = 0; /* Skip white spaces after the start of the comment */ - while ((c = inpc()) != EOF && isspace(c)) ; + while ((c = inpc()) != EOF && isspace(c)) + continue; /* Read the potential keyword to keywd */ l = 0; @@ -1100,6 +1127,22 @@ comment() } /* + * Handle // style comments + */ +static void +slashslashcomment(void) +{ + int c; + + if (sflag < 2 && !gflag) + /* // comments only supported in C99 */ + (void)gnuism(312, tflag ? "traditional" : "ANSI"); + + while ((c = inpc()) != EOF && c != '\n') + continue; +} + +/* * Clear flags for lint comments LINTED, LONGLONG and CONSTCOND. * clrwflgs() is called after function definitions and global and * local declarations and definitions. It is also called between @@ -1107,8 +1150,9 @@ comment() * (if, switch, for, while). */ void -clrwflgs() +clrwflgs(void) { + nowarn = 0; quadflg = 0; ccflg = 0; @@ -1120,7 +1164,7 @@ clrwflgs() * by the parser are responsible for freeing this buffer. */ static int -string() +string(void) { u_char *s; int c; @@ -1151,7 +1195,7 @@ string() } static int -wcstrg() +wcstrg(void) { char *s; int c, i, n, wi; @@ -1221,8 +1265,7 @@ wcstrg() * XXX calls to getsym() should be delayed until decl1*() is called */ sym_t * -getsym(sb) - sbuf_t *sb; +getsym(sbuf_t *sb) { dinfo_t *di; char *s; @@ -1270,7 +1313,7 @@ getsym(sb) di = dcs; } - STRUCT_ASSIGN(sym->s_dpos, curr_pos); + UNIQUE_CURR_POS(sym->s_dpos); if ((sym->s_kind = symtyp) != FLAB) sym->s_type = gettyp(INT); @@ -1293,9 +1336,9 @@ getsym(sb) * back to the symbol table. */ void -rmsym(sym) - sym_t *sym; +rmsym(sym_t *sym) { + if ((*sym->s_rlink = sym->s_link) != NULL) sym->s_link->s_rlink = sym->s_rlink; sym->s_blklev = -1; @@ -1307,8 +1350,7 @@ rmsym(sym) * table. */ void -rmsyms(syms) - sym_t *syms; +rmsyms(sym_t *syms) { sym_t *sym; @@ -1326,9 +1368,7 @@ rmsyms(syms) * Put a symbol into the symbol table */ void -inssym(bl, sym) - int bl; - sym_t *sym; +inssym(int bl, sym_t *sym) { int h; @@ -1348,7 +1388,7 @@ inssym(bl, sym) * level 0. */ void -cleanup() +cleanup(void) { sym_t *sym, *nsym; int i; @@ -1371,8 +1411,7 @@ cleanup() * Create a new symbol with the name of an existing symbol. */ sym_t * -pushdown(sym) - sym_t *sym; +pushdown(sym_t *sym) { int h; sym_t *nsym; @@ -1382,7 +1421,7 @@ pushdown(sym) if (sym->s_blklev > blklev) lerror("pushdown()"); nsym->s_name = sym->s_name; - STRUCT_ASSIGN(nsym->s_dpos, curr_pos); + UNIQUE_CURR_POS(nsym->s_dpos); nsym->s_kind = sym->s_kind; nsym->s_blklev = blklev; @@ -1402,9 +1441,7 @@ pushdown(sym) * The type of information in yylval is described by tok. */ void -freeyyv(sp, tok) - void *sp; - int tok; +freeyyv(void *sp, int tok) { if (tok == T_NAME || tok == T_TYPENAME) { sbuf_t *sb = *(sbuf_t **)sp; @@ -1422,5 +1459,5 @@ freeyyv(sp, tok) lerror("fryylv() 1"); } free(strg); - } + } } diff --git a/usr.bin/xlint/lint1/tree.c b/usr.bin/xlint/lint1/tree.c index 525e407..d725de8 100644 --- a/usr.bin/xlint/lint1/tree.c +++ b/usr.bin/xlint/lint1/tree.c @@ -1,4 +1,4 @@ -/* $NetBSD: tree.c,v 1.12 1995/10/02 17:37:57 jpo Exp $ */ +/* $NetBSD: tree.c,v 1.24 2002/01/31 22:30:20 tv Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,8 +31,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: tree.c,v 1.12 1995/10/02 17:37:57 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: tree.c,v 1.24 2002/01/31 22:30:20 tv Exp $"); #endif #include @@ -42,51 +43,51 @@ static char rcsid[] = "$NetBSD: tree.c,v 1.12 1995/10/02 17:37:57 jpo Exp $"; #include #include "lint1.h" -#include "y.tab.h" +#include "cgram.h" /* Various flags for each operator. */ static mod_t modtab[NOPS]; -static tnode_t *getinode __P((tspec_t, quad_t)); -static void ptrcmpok __P((op_t, tnode_t *, tnode_t *)); -static int asgntypok __P((op_t, int, tnode_t *, tnode_t *)); -static void chkbeop __P((op_t, tnode_t *, tnode_t *)); -static void chkeop2 __P((op_t, int, tnode_t *, tnode_t *)); -static void chkeop1 __P((op_t, int, tnode_t *, tnode_t *)); -static tnode_t *mktnode __P((op_t, type_t *, tnode_t *, tnode_t *)); -static void balance __P((op_t, tnode_t **, tnode_t **)); -static void incompat __P((op_t, tspec_t, tspec_t)); -static void illptrc __P((mod_t *, type_t *, type_t *)); -static void mrgqual __P((type_t **, type_t *, type_t *)); -static int conmemb __P((type_t *)); -static void ptconv __P((int, tspec_t, tspec_t, type_t *, tnode_t *)); -static void iiconv __P((op_t, int, tspec_t, tspec_t, type_t *, tnode_t *)); -static void piconv __P((op_t, tspec_t, type_t *, tnode_t *)); -static void ppconv __P((op_t, tnode_t *, type_t *)); -static tnode_t *bldstr __P((op_t, tnode_t *, tnode_t *)); -static tnode_t *bldincdec __P((op_t, tnode_t *)); -static tnode_t *bldamper __P((tnode_t *, int)); -static tnode_t *bldplmi __P((op_t, tnode_t *, tnode_t *)); -static tnode_t *bldshft __P((op_t, tnode_t *, tnode_t *)); -static tnode_t *bldcol __P((tnode_t *, tnode_t *)); -static tnode_t *bldasgn __P((op_t, tnode_t *, tnode_t *)); -static tnode_t *plength __P((type_t *)); -static tnode_t *fold __P((tnode_t *)); -static tnode_t *foldtst __P((tnode_t *)); -static tnode_t *foldflt __P((tnode_t *)); -static tnode_t *chkfarg __P((type_t *, tnode_t *)); -static tnode_t *parg __P((int, type_t *, tnode_t *)); -static void nulleff __P((tnode_t *)); -static void displexpr __P((tnode_t *, int)); -static void chkaidx __P((tnode_t *, int)); -static void chkcomp __P((op_t, tnode_t *, tnode_t *)); -static void precconf __P((tnode_t *)); +static tnode_t *getinode(tspec_t, int64_t); +static void ptrcmpok(op_t, tnode_t *, tnode_t *); +static int asgntypok(op_t, int, tnode_t *, tnode_t *); +static void chkbeop(op_t, tnode_t *, tnode_t *); +static void chkeop2(op_t, int, tnode_t *, tnode_t *); +static void chkeop1(op_t, int, tnode_t *, tnode_t *); +static tnode_t *mktnode(op_t, type_t *, tnode_t *, tnode_t *); +static void balance(op_t, tnode_t **, tnode_t **); +static void incompat(op_t, tspec_t, tspec_t); +static void illptrc(mod_t *, type_t *, type_t *); +static void mrgqual(type_t **, type_t *, type_t *); +static int conmemb(type_t *); +static void ptconv(int, tspec_t, tspec_t, type_t *, tnode_t *); +static void iiconv(op_t, int, tspec_t, tspec_t, type_t *, tnode_t *); +static void piconv(op_t, tspec_t, type_t *, tnode_t *); +static void ppconv(op_t, tnode_t *, type_t *); +static tnode_t *bldstr(op_t, tnode_t *, tnode_t *); +static tnode_t *bldincdec(op_t, tnode_t *); +static tnode_t *bldamper(tnode_t *, int); +static tnode_t *bldplmi(op_t, tnode_t *, tnode_t *); +static tnode_t *bldshft(op_t, tnode_t *, tnode_t *); +static tnode_t *bldcol(tnode_t *, tnode_t *); +static tnode_t *bldasgn(op_t, tnode_t *, tnode_t *); +static tnode_t *plength(type_t *); +static tnode_t *fold(tnode_t *); +static tnode_t *foldtst(tnode_t *); +static tnode_t *foldflt(tnode_t *); +static tnode_t *chkfarg(type_t *, tnode_t *); +static tnode_t *parg(int, type_t *, tnode_t *); +static void nulleff(tnode_t *); +static void displexpr(tnode_t *, int); +static void chkaidx(tnode_t *, int); +static void chkcomp(op_t, tnode_t *, tnode_t *); +static void precconf(tnode_t *); /* * Initialize mods of operators. */ void -initmtab() +initmtab(void) { static struct { op_t op; @@ -217,9 +218,7 @@ initmtab() * This is most often used to change type "T" in type "pointer to T". */ type_t * -incref(tp, t) - type_t *tp; - tspec_t t; +incref(type_t *tp, tspec_t t) { type_t *tp2; @@ -233,9 +232,7 @@ incref(tp, t) * same for use in expressions */ type_t * -tincref(tp, t) - type_t *tp; - tspec_t t; +tincref(type_t *tp, tspec_t t) { type_t *tp2; @@ -249,9 +246,7 @@ tincref(tp, t) * Create a node for a constant. */ tnode_t * -getcnode(tp, v) - type_t *tp; - val_t *v; +getcnode(type_t *tp, val_t *v) { tnode_t *n; @@ -270,9 +265,7 @@ getcnode(tp, v) * Create a node for a integer constant. */ static tnode_t * -getinode(t, q) - tspec_t t; - quad_t q; +getinode(tspec_t t, int64_t q) { tnode_t *n; @@ -290,9 +283,7 @@ getinode(t, q) * ntok is the token which follows the name. */ tnode_t * -getnnode(sym, ntok) - sym_t *sym; - int ntok; +getnnode(sym_t *sym, int ntok) { tnode_t *n; @@ -338,8 +329,7 @@ getnnode(sym, ntok) * Create a node for a string. */ tnode_t * -getsnode(strg) - strg_t *strg; +getsnode(strg_t *strg) { size_t len; tnode_t *n; @@ -377,10 +367,7 @@ getsnode(strg) * member of the struct or union specified by the tn argument. */ sym_t * -strmemb(tn, op, msym) - tnode_t *tn; - op_t op; - sym_t *msym; +strmemb(tnode_t *tn, op_t op, sym_t *msym) { str_t *str; type_t *tp; @@ -537,9 +524,7 @@ strmemb(tn, op, msym) * rn if not NULL, right operand */ tnode_t * -build(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +build(op_t op, tnode_t *ln, tnode_t *rn) { mod_t *mp; tnode_t *ntn; @@ -565,7 +550,7 @@ build(op, ln, rn) rn = cconv(rn); /* - * Print some warnings for comparisions of unsigned values with + * Print some warnings for comparisons of unsigned values with * constants lower than or equal to null. This must be done * before promote() because otherwise unsigned char and unsigned * short would be promoted to int. Also types are tested to be @@ -670,7 +655,7 @@ build(op, ln, rn) break; } - /* Return if an error occured. */ + /* Return if an error occurred. */ if (ntn == NULL) return (NULL); @@ -717,8 +702,7 @@ build(op, ln, rn) * Lvalues are converted to rvalues. */ tnode_t * -cconv(tn) - tnode_t *tn; +cconv(tnode_t *tn) { type_t *tp; @@ -762,14 +746,12 @@ cconv(tn) * If the types are ok, typeok() returns 1, otherwise 0. */ int -typeok(op, arg, ln, rn) - op_t op; - int arg; - tnode_t *ln, *rn; +typeok(op_t op, int arg, tnode_t *ln, tnode_t *rn) { mod_t *mp; - tspec_t lt, rt, lst, rst, olt, ort; - type_t *ltp, *rtp, *lstp, *rstp; + tspec_t lt, rt = NOTSPEC, lst = NOTSPEC, rst = NOTSPEC, olt = NOTSPEC, + ort = NOTSPEC; + type_t *ltp, *rtp = NULL, *lstp = NULL, *rstp = NULL; tnode_t *tn; mp = &modtab[op]; @@ -806,12 +788,14 @@ typeok(op, arg, ln, rn) * For these operations we need the types before promotion * and balancing. */ - for (tn=ln; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left) ; + for (tn=ln; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left) + continue; olt = tn->tn_type->t_tspec; - for (tn=rn; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left) ; + for (tn=rn; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left) + continue; ort = tn->tn_type->t_tspec; } - + switch (op) { case POINT: /* @@ -978,10 +962,10 @@ typeok(op, arg, ln, rn) if (!isutyp(rt) && rn->tn_val->v_quad < 0) { /* negative shift */ warning(121); - } else if ((u_quad_t)rn->tn_val->v_quad == size(lt)) { + } else if ((uint64_t)rn->tn_val->v_quad == size(lt)) { /* shift equal to size fo object */ warning(267); - } else if ((u_quad_t)rn->tn_val->v_quad > size(lt)) { + } else if ((uint64_t)rn->tn_val->v_quad > size(lt)) { /* shift greater than size of object */ warning(122); } @@ -991,7 +975,7 @@ typeok(op, arg, ln, rn) case NE: /* * Accept some things which are allowed with EQ and NE, - * but not with ordered comparisions. + * but not with ordered comparisons. */ if (lt == PTR && ((rt == PTR && rst == VOID) || isityp(rt))) { if (rn->tn_op == CON && rn->tn_val->v_quad == 0) @@ -1133,6 +1117,32 @@ typeok(op, arg, ln, rn) nulleff(ln); break; /* LINTED (enumeration values not handled in switch) */ + case CON: + case CASE: + case PUSH: + case LOAD: + case ICALL: + case CVT: + case CALL: + case FSEL: + case STRING: + case NAME: + case LOGOR: + case LOGAND: + case OR: + case XOR: + case AND: + case MOD: + case DIV: + case MULT: + case UMINUS: + case UPLUS: + case DEC: + case INC: + case COMPL: + case NOT: + case NOOP: + break; } if (mp->m_badeop && @@ -1148,9 +1158,7 @@ typeok(op, arg, ln, rn) } static void -ptrcmpok(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +ptrcmpok(op_t op, tnode_t *ln, tnode_t *rn) { type_t *ltp, *rtp; tspec_t lt, rt; @@ -1164,7 +1172,7 @@ ptrcmpok(op, ln, rn) /* (void *)0 already handled in typeok() */ *(lt == FUNC ? <s : &rts) = "function pointer"; *(lt == VOID ? <s : &rts) = "'void *'"; - /* ANSI C forbids comparision of %s with %s */ + /* ANSI C forbids comparison of %s with %s */ warning(274, lts, rts); } return; @@ -1188,13 +1196,10 @@ ptrcmpok(op, ln, rn) * If the types are (almost) compatible, 1 is returned, otherwise 0. */ static int -asgntypok(op, arg, ln, rn) - op_t op; - int arg; - tnode_t *ln, *rn; +asgntypok(op_t op, int arg, tnode_t *ln, tnode_t *rn) { - tspec_t lt, rt, lst, rst; - type_t *ltp, *rtp, *lstp, *rstp; + tspec_t lt, rt, lst = NOTSPEC, rst = NOTSPEC; + type_t *ltp, *rtp, *lstp = NULL, *rstp = NULL; mod_t *mp; const char *lts, *rts; @@ -1329,9 +1334,7 @@ asgntypok(op, arg, ln, rn) * enum type, is applied to an enum type. */ static void -chkbeop(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +chkbeop(op_t op, tnode_t *ln, tnode_t *rn) { mod_t *mp; @@ -1364,10 +1367,7 @@ chkbeop(op, ln, rn) * Prints a warning if an operator is applied to two different enum types. */ static void -chkeop2(op, arg, ln, rn) - op_t op; - int arg; - tnode_t *ln, *rn; +chkeop2(op_t op, int arg, tnode_t *ln, tnode_t *rn) { mod_t *mp; @@ -1395,7 +1395,7 @@ chkeop2(op, arg, ln, rn) #if 0 } else if (mp->m_comp && op != EQ && op != NE) { if (eflag) - /* dubious comparisions of enums */ + /* dubious comparisons of enums */ warning(243, mp->m_name); #endif } @@ -1406,11 +1406,9 @@ chkeop2(op, arg, ln, rn) * types. */ static void -chkeop1(op, arg, ln, rn) - op_t op; - int arg; - tnode_t *ln, *rn; +chkeop1(op_t op, int arg, tnode_t *ln, tnode_t *rn) { + if (!eflag) return; @@ -1448,10 +1446,7 @@ chkeop1(op, arg, ln, rn) * Build and initialize a new node. */ static tnode_t * -mktnode(op, type, ln, rn) - op_t op; - type_t *type; - tnode_t *ln, *rn; +mktnode(op_t op, type_t *type, tnode_t *ln, tnode_t *rn) { tnode_t *ntn; tspec_t t; @@ -1484,10 +1479,7 @@ mktnode(op, type, ln, rn) * float to double. */ tnode_t * -promote(op, farg, tn) - op_t op; - int farg; - tnode_t *tn; +promote(op_t op, int farg, tnode_t *tn) { tspec_t t; type_t *ntp; @@ -1562,9 +1554,7 @@ promote(op, farg, tn) * type. This is done in different ways for traditional C and ANIS C. */ static void -balance(op, lnp, rnp) - op_t op; - tnode_t **lnp, **rnp; +balance(op_t op, tnode_t **lnp, tnode_t **rnp) { tspec_t lt, rt, t; int i, u; @@ -1639,14 +1629,10 @@ balance(op, lnp, rnp) * If op is FARG, arg is the number of the argument (used for warnings). */ tnode_t * -convert(op, arg, tp, tn) - op_t op; - int arg; - type_t *tp; - tnode_t *tn; +convert(op_t op, int arg, type_t *tp, tnode_t *tn) { tnode_t *ntn; - tspec_t nt, ot, ost; + tspec_t nt, ot, ost = NOTSPEC; if (tn->tn_lvalue) lerror("convert() 1"); @@ -1692,11 +1678,7 @@ convert(op, arg, tp, tn) * in asgntypok(). */ static void -ptconv(arg, nt, ot, tp, tn) - int arg; - tspec_t nt, ot; - type_t *tp; - tnode_t *tn; +ptconv(int arg, tspec_t nt, tspec_t ot, type_t *tp, tnode_t *tn) { tnode_t *ptn; @@ -1748,12 +1730,7 @@ ptconv(arg, nt, ot, tp, tn) */ /* ARGSUSED */ static void -iiconv(op, arg, nt, ot, tp, tn) - op_t op; - int arg; - tspec_t nt, ot; - type_t *tp; - tnode_t *tn; +iiconv(op_t op, int arg, tspec_t nt, tspec_t ot, type_t *tp, tnode_t *tn) { if (tn->tn_op == CON) return; @@ -1784,7 +1761,7 @@ iiconv(op, arg, nt, ot, tp, tn) } else { warning(132, tyname(tn->tn_type)); } - } + } } } @@ -1792,12 +1769,9 @@ iiconv(op, arg, nt, ot, tp, tn) * Print warnings for dubious conversions of pointer to integer. */ static void -piconv(op, nt, tp, tn) - op_t op; - tspec_t nt; - type_t *tp; - tnode_t *tn; +piconv(op_t op, tspec_t nt, type_t *tp, tnode_t *tn) { + if (tn->tn_op == CON) return; @@ -1821,10 +1795,7 @@ piconv(op, nt, tp, tn) * Print warnings for questionable pointer conversions. */ static void -ppconv(op, tn, tp) - op_t op; - tnode_t *tn; - type_t *tp; +ppconv(op_t op, tnode_t *tn, type_t *tp) { tspec_t nt, ot; const char *nts, *ots; @@ -1855,7 +1826,7 @@ ppconv(op, tn, tp) warning(229); return; } - + if (getbound(tp->t_subt) > getbound(tn->tn_type->t_subt)) { if (hflag) /* possible pointer alignment problem */ @@ -1881,16 +1852,12 @@ ppconv(op, tn, tp) * v old constant */ void -cvtcon(op, arg, tp, nv, v) - op_t op; - int arg; - type_t *tp; - val_t *nv, *v; +cvtcon(op_t op, int arg, type_t *tp, val_t *nv, val_t *v) { tspec_t ot, nt; - ldbl_t max, min; + ldbl_t max = 0.0, min = 0.0; int sz, rchk; - quad_t xmask, xmsk1; + int64_t xmask, xmsk1; int osz, nsz; ot = v->v_tspec; @@ -1921,7 +1888,7 @@ cvtcon(op, arg, tp, nv, v) case QUAD: max = QUAD_MAX; min = QUAD_MIN; break; case UQUAD: - max = (u_quad_t)UQUAD_MAX; min = 0; break; + max = (uint64_t)UQUAD_MAX; min = 0; break; case FLOAT: max = FLT_MAX; min = -FLT_MAX; break; case DOUBLE: @@ -1954,18 +1921,18 @@ cvtcon(op, arg, tp, nv, v) nv->v_ldbl = v->v_ldbl; } else { nv->v_quad = (nt == PTR || isutyp(nt)) ? - (u_quad_t)v->v_ldbl : (quad_t)v->v_ldbl; + (uint64_t)v->v_ldbl : (int64_t)v->v_ldbl; } } else { if (nt == FLOAT) { nv->v_ldbl = (ot == PTR || isutyp(ot)) ? - (float)(u_quad_t)v->v_quad : (float)v->v_quad; + (float)(uint64_t)v->v_quad : (float)v->v_quad; } else if (nt == DOUBLE) { nv->v_ldbl = (ot == PTR || isutyp(ot)) ? - (double)(u_quad_t)v->v_quad : (double)v->v_quad; + (double)(uint64_t)v->v_quad : (double)v->v_quad; } else if (nt == LDOUBLE) { nv->v_ldbl = (ot == PTR || isutyp(ot)) ? - (ldbl_t)(u_quad_t)v->v_quad : (ldbl_t)v->v_quad; + (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad; } else { rchk = 1; /* Check for lost precision. */ nv->v_quad = v->v_quad; @@ -1987,7 +1954,7 @@ cvtcon(op, arg, tp, nv, v) sz = tp->t_isfield ? tp->t_flen : size(nt); nv->v_quad = xsign(nv->v_quad, nt, sz); } - + if (rchk && op != CVT) { osz = size(ot); nsz = tp->t_isfield ? tp->t_flen : size(nt); @@ -2114,9 +2081,7 @@ cvtcon(op, arg, tp, nv, v) * Prints a appropriate warning. */ static void -incompat(op, lt, rt) - op_t op; - tspec_t lt, rt; +incompat(op_t op, tspec_t lt, tspec_t rt) { mod_t *mp; @@ -2148,9 +2113,7 @@ incompat(op, lt, rt) * Print an appropriate warning. */ static void -illptrc(mp, ltp, rtp) - mod_t *mp; - type_t *ltp, *rtp; +illptrc(mod_t *mp, type_t *ltp, type_t *rtp) { tspec_t lt, rt; @@ -2184,9 +2147,9 @@ illptrc(mp, ltp, rtp) * of tp1->t_subt and tp2->t_subt. */ static void -mrgqual(tpp, tp1, tp2) - type_t **tpp, *tp1, *tp2; +mrgqual(type_t **tpp, type_t *tp1, type_t *tp2) { + if ((*tpp)->t_tspec != PTR || tp1->t_tspec != PTR || tp2->t_tspec != PTR) { lerror("mrgqual()"); @@ -2212,8 +2175,7 @@ mrgqual(tpp, tp1, tp2) * (maybe recursively). */ static int -conmemb(tp) - type_t *tp; +conmemb(type_t *tp) { sym_t *m; tspec_t t; @@ -2233,8 +2195,7 @@ conmemb(tp) } const char * -tyname(tp) - type_t *tp; +tyname(type_t *tp) { tspec_t t; const char *s; @@ -2273,9 +2234,7 @@ tyname(tp) * Create a new node for one of the operators POINT and ARROW. */ static tnode_t * -bldstr(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +bldstr(op_t op, tnode_t *ln, tnode_t *rn) { tnode_t *ntn, *ctn; int nolval; @@ -2327,9 +2286,7 @@ bldstr(op, ln, rn) * Create a node for INCAFT, INCBEF, DECAFT and DECBEF. */ static tnode_t * -bldincdec(op, ln) - op_t op; - tnode_t *ln; +bldincdec(op_t op, tnode_t *ln) { tnode_t *cn, *ntn; @@ -2339,7 +2296,7 @@ bldincdec(op, ln) if (ln->tn_type->t_tspec == PTR) { cn = plength(ln->tn_type); } else { - cn = getinode(INT, (quad_t)1); + cn = getinode(INT, (int64_t)1); } ntn = mktnode(op, ln->tn_type, ln, cn); @@ -2350,13 +2307,11 @@ bldincdec(op, ln) * Create a tree node for the & operator */ static tnode_t * -bldamper(tn, noign) - tnode_t *tn; - int noign; +bldamper(tnode_t *tn, int noign) { tnode_t *ntn; tspec_t t; - + if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) { /* & before array or function: ignored */ if (tflag) @@ -2370,7 +2325,7 @@ bldamper(tn, noign) tn->tn_left->tn_type->t_subt == tn->tn_type) { return (tn->tn_left); } - + ntn = mktnode(AMPER, tincref(tn->tn_type, PTR), tn, NULL); return (ntn); @@ -2380,9 +2335,7 @@ bldamper(tn, noign) * Create a node for operators PLUS and MINUS. */ static tnode_t * -bldplmi(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +bldplmi(op_t op, tnode_t *ln, tnode_t *rn) { tnode_t *ntn, *ctn; type_t *tp; @@ -2435,9 +2388,7 @@ bldplmi(op, ln, rn) * Create a node for operators SHL and SHR. */ static tnode_t * -bldshft(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +bldshft(op_t op, tnode_t *ln, tnode_t *rn) { tspec_t t; tnode_t *ntn; @@ -2452,8 +2403,7 @@ bldshft(op, ln, rn) * Create a node for COLON. */ static tnode_t * -bldcol(ln, rn) - tnode_t *ln, *rn; +bldcol(tnode_t *ln, tnode_t *rn) { tspec_t lt, rt, pdt; type_t *rtp; @@ -2531,9 +2481,7 @@ bldcol(ln, rn) * Create a node for an assignment operator (both = and op= ). */ static tnode_t * -bldasgn(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +bldasgn(op_t op, tnode_t *ln, tnode_t *rn) { tspec_t lt, rt; tnode_t *ntn, *ctn; @@ -2594,8 +2542,7 @@ bldasgn(op, ln, rn) * Get length of type tp->t_subt. */ static tnode_t * -plength(tp) - type_t *tp; +plength(type_t *tp) { int elem, elsz; tspec_t st; @@ -2657,39 +2604,28 @@ plength(tp) st = INT; #endif - return (getinode(st, (quad_t)(elem * elsz / CHAR_BIT))); + return (getinode(st, (int64_t)(elem * elsz / CHAR_BIT))); } -#ifdef XXX_BROKEN_GCC -static int -quad_t_eq(x, y) - quad_t x, y; -{ - return (x == y); -} - -static int -u_quad_t_eq(x, y) - u_quad_t x, y; -{ - return (x == y); -} -#endif - +/* + * XXX + * Note: There appear to be a number of bugs in detecting overflow in + * this function. An audit and a set of proper regression tests are needed. + * --Perry Metzger, Nov. 16, 2001 + */ /* * Do only as much as necessary to compute constant expressions. * Called only if the operator allows folding and (both) operands * are constants. */ static tnode_t * -fold(tn) - tnode_t *tn; +fold(tnode_t *tn) { val_t *v; tspec_t t; int utyp, ovfl; - quad_t sl, sr, q, mask; - u_quad_t ul, ur; + int64_t sl, sr = 0, q = 0, mask; + uint64_t ul, ur = 0; tnode_t *cn; v = xcalloc(1, sizeof (val_t)); @@ -2700,6 +2636,7 @@ fold(tn) if (modtab[tn->tn_op].m_binary) ur = sr = tn->tn_right->tn_val->v_quad; + mask = qlmasks[size(t)]; ovfl = 0; switch (tn->tn_op) { @@ -2715,9 +2652,17 @@ fold(tn) q = ~sl; break; case MULT: - q = utyp ? ul * ur : sl * sr; - if (msb(q, t, -1) != (msb(sl, t, -1) ^ msb(sr, t, -1))) - ovfl = 1; + if (utyp) { + q = ul * ur; + if (q != (q & mask)) + ovfl = 1; + else if ((ul != 0) && ((q / ul) != ur)) + ovfl = 1; + } else { + q = sl * sr; + if (msb(q, t, -1) != (msb(sl, t, -1) ^ msb(sr, t, -1))) + ovfl = 1; + } break; case DIV: if (sr == 0) { @@ -2762,7 +2707,7 @@ fold(tn) break; case SHR: /* - * The sign must be explizitly extended because + * The sign must be explicitly extended because * shifts of signed values are implementation dependent. */ q = ul >> sr; @@ -2781,11 +2726,7 @@ fold(tn) q = utyp ? ul > ur : sl > sr; break; case EQ: -#ifdef XXX_BROKEN_GCC - q = utyp ? u_quad_t_eq(ul, ur) : quad_t_eq(sl, sr); -#else q = utyp ? ul == ur : sl == sr; -#endif break; case NE: q = utyp ? ul != ur : sl != sr; @@ -2803,10 +2744,8 @@ fold(tn) lerror("fold() 5"); } - mask = qlmasks[size(t)]; - /* XXX does not work for quads. */ - if (ovfl || ((q | mask) != ~(u_quad_t)0 && (q & ~mask) != 0)) { + if (ovfl || ((q | mask) != ~(uint64_t)0 && (q & ~mask) != 0)) { if (hflag) /* integer overflow detected, op %s */ warning(141, modtab[tn->tn_op].m_name); @@ -2819,23 +2758,13 @@ fold(tn) return (cn); } -#ifdef XXX_BROKEN_GCC -int -ldbl_t_neq(x, y) - ldbl_t x, y; -{ - return (x != y); -} -#endif - /* * Same for operators whose operands are compared with 0 (test context). */ static tnode_t * -foldtst(tn) - tnode_t *tn; +foldtst(tnode_t *tn) { - int l, r; + int l, r = 0; val_t *v; v = xcalloc(1, sizeof (val_t)); @@ -2844,22 +2773,14 @@ foldtst(tn) lerror("foldtst() 1"); if (isftyp(tn->tn_left->tn_type->t_tspec)) { -#ifdef XXX_BROKEN_GCC - l = ldbl_t_neq(tn->tn_left->tn_val->v_ldbl, 0.0); -#else l = tn->tn_left->tn_val->v_ldbl != 0.0; -#endif } else { l = tn->tn_left->tn_val->v_quad != 0; } if (modtab[tn->tn_op].m_binary) { if (isftyp(tn->tn_right->tn_type->t_tspec)) { -#ifdef XXX_BROKEN_GCC - r = ldbl_t_neq(tn->tn_right->tn_val->v_ldbl, 0.0); -#else r = tn->tn_right->tn_val->v_ldbl != 0.0; -#endif } else { r = tn->tn_right->tn_val->v_quad != 0; } @@ -2889,12 +2810,11 @@ foldtst(tn) * Same for operands with floating point type. */ static tnode_t * -foldflt(tn) - tnode_t *tn; +foldflt(tnode_t *tn) { val_t *v; tspec_t t; - ldbl_t l, r; + ldbl_t l, r = 0; v = xcalloc(1, sizeof (val_t)); v->v_tspec = t = tn->tn_type->t_tspec; @@ -2966,7 +2886,7 @@ foldflt(tn) if (isnan((double)v->v_ldbl)) lerror("foldflt() 5"); - if (isinf((double)v->v_ldbl) || + if (!finite((double)v->v_ldbl) || (t == FLOAT && (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) || (t == DOUBLE && @@ -2989,8 +2909,7 @@ foldflt(tn) * Create a constant node for sizeof. */ tnode_t * -bldszof(tp) - type_t *tp; +bldszof(type_t *tp) { int elem, elsz; tspec_t st; @@ -3050,16 +2969,14 @@ bldszof(tp) st = UINT; #endif - return (getinode(st, (quad_t)(elem * elsz / CHAR_BIT))); + return (getinode(st, (int64_t)(elem * elsz / CHAR_BIT))); } /* * Type casts. */ tnode_t * -cast(tn, tp) - tnode_t *tn; - type_t *tp; +cast(tnode_t *tn, type_t *tp) { tspec_t nt, ot; @@ -3118,8 +3035,7 @@ cast(tn, tp) * in funcarg() we have no information about expected argument types. */ tnode_t * -funcarg(args, arg) - tnode_t *args, *arg; +funcarg(tnode_t *args, tnode_t *arg) { tnode_t *ntn; @@ -3129,7 +3045,7 @@ funcarg(args, arg) * will not change. */ if (arg == NULL) - arg = getinode(INT, (quad_t)0); + arg = getinode(INT, (int64_t)0); ntn = mktnode(PUSH, arg->tn_type, arg, args); @@ -3141,8 +3057,7 @@ funcarg(args, arg) * function arguments and insert conversions, if necessary. */ tnode_t * -funccall(func, args) - tnode_t *func, *args; +funccall(tnode_t *func, tnode_t *args) { tnode_t *ntn; op_t fcop; @@ -3181,9 +3096,7 @@ funccall(func, args) * if necessary. */ static tnode_t * -chkfarg(ftp, args) - type_t *ftp; /* type of called function */ - tnode_t *args; /* arguments */ +chkfarg(type_t *ftp, tnode_t *args) { tnode_t *arg; sym_t *asym; @@ -3206,14 +3119,15 @@ chkfarg(ftp, args) error(150, narg, narg > 1 ? "s" : "", npar); asym = NULL; } - + for (n = 1; n <= narg; n++) { /* * The rightmost argument is at the top of the argument * subtree. */ - for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) ; + for (i = narg, arg = args; i > n; i--, arg = arg->tn_right) + continue; /* some things which are always not allowd */ if ((at = arg->tn_left->tn_type->t_tspec) == VOID) { @@ -3255,10 +3169,9 @@ chkfarg(ftp, args) * the type of the parameter. */ static tnode_t * -parg(n, tp, tn) - int n; /* pos of arg */ - type_t *tp; /* expected type (from prototype) */ - tnode_t *tn; /* argument */ +parg( int n, /* pos of arg */ + type_t *tp, /* expected type (from prototype) */ + tnode_t *tn) /* argument */ { tnode_t *ln; int warn; @@ -3281,8 +3194,7 @@ parg(n, tp, tn) * type, an error message is printed. */ val_t * -constant(tn) - tnode_t *tn; +constant(tnode_t *tn) { val_t *v; @@ -3334,10 +3246,9 @@ constant(tn) * for the expression. */ void -expr(tn, vctx, tctx) - tnode_t *tn; - int vctx, tctx; +expr(tnode_t *tn, int vctx, int tctx) { + if (tn == NULL && nerr == 0) lerror("expr() 1"); @@ -3376,9 +3287,9 @@ expr(tn, vctx, tctx) } static void -nulleff(tn) - tnode_t *tn; +nulleff(tnode_t *tn) { + if (!hflag) return; @@ -3397,7 +3308,7 @@ nulleff(tn) * operands has a side effect */ tn = tn->tn_right; - } else if (tn->tn_op == COLON) { + } else if (tn->tn_op == COLON || tn->tn_op == COMMA) { /* * : has a side effect if at least one of its operands * has a side effect @@ -3423,11 +3334,9 @@ nulleff(tn) * only used for debugging */ static void -displexpr(tn, offs) - tnode_t *tn; - int offs; +displexpr(tnode_t *tn, int offs) { - u_quad_t uq; + uint64_t uq; if (tn == NULL) { (void)printf("%*s%s\n", offs, "", "NULL"); @@ -3481,9 +3390,8 @@ displexpr(tn, offs) */ /* ARGSUSED */ void -chkmisc(tn, vctx, tctx, eqwarn, fcall, rvdisc, szof) - tnode_t *tn; - int vctx, tctx, eqwarn, fcall, rvdisc, szof; +chkmisc(tnode_t *tn, int vctx, int tctx, int eqwarn, int fcall, int rvdisc, + int szof) { tnode_t *ln, *rn; mod_t *mp; @@ -3576,6 +3484,44 @@ chkmisc(tn, vctx, tctx, eqwarn, fcall, rvdisc, szof) case STRING: return; /* LINTED (enumeration values not handled in switch) */ + case OR: + case XOR: + case NE: + case GE: + case GT: + case LE: + case LT: + case SHR: + case SHL: + case MINUS: + case PLUS: + case MOD: + case DIV: + case MULT: + case STAR: + case UMINUS: + case UPLUS: + case DEC: + case INC: + case COMPL: + case NOT: + case POINT: + case ARROW: + case NOOP: + case AND: + case FARG: + case CASE: + case INIT: + case RETURN: + case ICALL: + case CVT: + case COMMA: + case FSEL: + case COLON: + case QUEST: + case LOGOR: + case LOGAND: + break; } cvctx = mp->m_vctx; @@ -3603,6 +3549,9 @@ chkmisc(tn, vctx, tctx, eqwarn, fcall, rvdisc, szof) case COLON: chkmisc(rn, cvctx, ctctx, mp->m_eqwarn, 0, 0, szof); break; + case COMMA: + chkmisc(rn, vctx, tctx, mp->m_eqwarn, 0, 0, szof); + break; default: if (mp->m_binary) chkmisc(rn, 1, 0, mp->m_eqwarn, 0, 0, szof); @@ -3618,14 +3567,12 @@ chkmisc(tn, vctx, tctx, eqwarn, fcall, rvdisc, szof) * after the array. */ static void -chkaidx(tn, amper) - tnode_t *tn; - int amper; +chkaidx(tnode_t *tn, int amper) { int dim; tnode_t *ln, *rn; int elsz; - quad_t con; + int64_t con; ln = tn->tn_left; rn = tn->tn_right; @@ -3641,7 +3588,7 @@ chkaidx(tn, amper) return; if (ln->tn_left->tn_type->t_tspec != ARRAY) return; - + /* * For incomplete array types, we can print a warning only if * the index is negative. @@ -3656,7 +3603,7 @@ chkaidx(tn, amper) /* Change the unit of the index from bytes to element size. */ if (isutyp(rn->tn_type->t_tspec)) { - con = (u_quad_t)rn->tn_val->v_quad / elsz; + con = (uint64_t)rn->tn_val->v_quad / elsz; } else { con = rn->tn_val->v_quad / elsz; } @@ -3666,19 +3613,17 @@ chkaidx(tn, amper) if (!isutyp(rn->tn_type->t_tspec) && con < 0) { /* array subscript cannot be negative: %ld */ warning(167, (long)con); - } else if (dim > 0 && (u_quad_t)con >= dim) { + } else if (dim > 0 && (uint64_t)con >= dim) { /* array subscript cannot be > %d: %ld */ warning(168, dim - 1, (long)con); } } /* - * Check for ordered comparisions of unsigned values with 0. + * Check for ordered comparisons of unsigned values with 0. */ static void -chkcomp(op, ln, rn) - op_t op; - tnode_t *ln, *rn; +chkcomp(op_t op, tnode_t *ln, tnode_t *rn) { tspec_t lt, rt; mod_t *mp; @@ -3696,25 +3641,25 @@ chkcomp(op, ln, rn) if ((hflag || pflag) && lt == CHAR && rn->tn_op == CON && (rn->tn_val->v_quad < 0 || rn->tn_val->v_quad > ~(~0 << (CHAR_BIT - 1)))) { - /* nonportable character comparision, op %s */ + /* nonportable character comparison, op %s */ warning(230, mp->m_name); return; } if ((hflag || pflag) && rt == CHAR && ln->tn_op == CON && (ln->tn_val->v_quad < 0 || ln->tn_val->v_quad > ~(~0 << (CHAR_BIT - 1)))) { - /* nonportable character comparision, op %s */ + /* nonportable character comparison, op %s */ warning(230, mp->m_name); return; } if (isutyp(lt) && !isutyp(rt) && rn->tn_op == CON && rn->tn_val->v_quad <= 0) { if (rn->tn_val->v_quad < 0) { - /* comparision of %s with %s, op %s */ + /* comparison of %s with %s, op %s */ warning(162, tyname(ln->tn_type), "negative constant", mp->m_name); } else if (op == LT || op == GE || (hflag && op == LE)) { - /* comparision of %s with %s, op %s */ + /* comparison of %s with %s, op %s */ warning(162, tyname(ln->tn_type), "0", mp->m_name); } return; @@ -3722,11 +3667,11 @@ chkcomp(op, ln, rn) if (isutyp(rt) && !isutyp(lt) && ln->tn_op == CON && ln->tn_val->v_quad <= 0) { if (ln->tn_val->v_quad < 0) { - /* comparision of %s with %s, op %s */ + /* comparison of %s with %s, op %s */ warning(162, "negative constant", tyname(rn->tn_type), mp->m_name); } else if (op == GT || op == LE || (hflag && op == GE)) { - /* comparision of %s with %s, op %s */ + /* comparison of %s with %s, op %s */ warning(162, "0", tyname(rn->tn_type), mp->m_name); } return; @@ -3747,10 +3692,7 @@ chkcomp(op, ln, rn) * representation (including width). */ int -conaddr(tn, symp, offsp) - tnode_t *tn; - sym_t **symp; - ptrdiff_t *offsp; +conaddr(tnode_t *tn, sym_t **symp, ptrdiff_t *offsp) { sym_t *sym; ptrdiff_t offs1, offs2; @@ -3812,8 +3754,7 @@ conaddr(tn, symp, offsp) * Concatenate two string constants. */ strg_t * -catstrg(strg1, strg2) - strg_t *strg1, *strg2; +catstrg(strg_t *strg1, strg_t *strg2) { size_t len1, len2, len; @@ -3849,12 +3790,11 @@ catstrg(strg1, strg2) * expressions are already folded. */ static void -precconf(tn) - tnode_t *tn; +precconf(tnode_t *tn) { tnode_t *ln, *rn; - op_t lop, rop; - int lparn, rparn; + op_t lop, rop = NOOP; + int lparn, rparn = 0; mod_t *mp; int warn; @@ -3914,6 +3854,61 @@ precconf(tn) } break; /* LINTED (enumeration values not handled in switch) */ + case DECAFT: + case XORASS: + case SHLASS: + case NOOP: + case ARROW: + case ORASS: + case POINT: + case NAME: + case NOT: + case COMPL: + case CON: + case INC: + case STRING: + case DEC: + case INCBEF: + case DECBEF: + case INCAFT: + case FSEL: + case CALL: + case COMMA: + case CVT: + case ICALL: + case LOAD: + case PUSH: + case RETURN: + case INIT: + case CASE: + case FARG: + case SUBASS: + case ADDASS: + case MODASS: + case DIVASS: + case MULASS: + case ASSIGN: + case COLON: + case QUEST: + case LOGAND: + case NE: + case EQ: + case GE: + case GT: + case LE: + case LT: + case MINUS: + case PLUS: + case MOD: + case DIV: + case MULT: + case AMPER: + case STAR: + case UMINUS: + case SHRASS: + case UPLUS: + case ANDASS: + break; } if (warn) { diff --git a/usr.bin/xlint/lint2/Makefile b/usr.bin/xlint/lint2/Makefile index 0e7d405..60f7886 100644 --- a/usr.bin/xlint/lint2/Makefile +++ b/usr.bin/xlint/lint2/Makefile @@ -1,13 +1,14 @@ -# $NetBSD: Makefile,v 1.2 1995/07/03 21:24:39 cgd Exp $ +# $NetBSD: Makefile,v 1.12 2002/01/18 20:39:32 thorpej Exp $ -.PATH: ${.CURDIR}/../lint1 - -PROG= lint2 -SRCS= main2.c hash.c read.c mem.c mem2.c chk.c msg.c emit.c emit2.c -NOMAN= -CFLAGS+=-I${.CURDIR}/../lint1 -LINTFLAGS=-abehrz - -BINDIR= /usr/libexec +PROG= lint2 +SRCS= main2.c hash.c read.c mem.c mem2.c chk.c msg.c emit.c emit2.c \ + inittyp.c +NOMAN= # defined +LINTFLAGS= -abehrz +WFORMAT=1 # hopeless +BINDIR= /usr/libexec +.ifndef HOSTPROG .include +.endif + diff --git a/usr.bin/xlint/lint2/chk.c b/usr.bin/xlint/lint2/chk.c index 0aac852..46923f9 100644 --- a/usr.bin/xlint/lint2/chk.c +++ b/usr.bin/xlint/lint2/chk.c @@ -1,6 +1,7 @@ -/* $NetBSD: chk.c,v 1.2 1995/07/03 21:24:42 cgd Exp $ */ +/* $NetBSD: chk.c,v 1.15 2002/01/21 19:49:52 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -31,138 +32,44 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: chk.c,v 1.2 1995/07/03 21:24:42 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: chk.c,v 1.15 2002/01/21 19:49:52 tv Exp $"); #endif -#include #include #include -#include +#include #include "lint2.h" -/* various type information */ -ttab_t ttab[NTSPEC]; - - -static void chkund __P((hte_t *)); -static void chkdnu __P((hte_t *)); -static void chkdnud __P((hte_t *)); -static void chkmd __P((hte_t *)); -static void chkvtui __P((hte_t *, sym_t *, sym_t *)); -static void chkvtdi __P((hte_t *, sym_t *, sym_t *)); -static void chkfaui __P((hte_t *, sym_t *, sym_t *)); -static void chkau __P((hte_t *, int, sym_t *, sym_t *, pos_t *, - fcall_t *, fcall_t *, type_t *, type_t *)); -static void chkrvu __P((hte_t *, sym_t *)); -static void chkadecl __P((hte_t *, sym_t *, sym_t *)); -static void printflike __P((hte_t *,fcall_t *, int, - const char *, type_t **)); -static void scanflike __P((hte_t *, fcall_t *, int, - const char *, type_t **)); -static void badfmt __P((hte_t *, fcall_t *)); -static void inconarg __P((hte_t *, fcall_t *, int)); -static void tofewarg __P((hte_t *, fcall_t *)); -static void tomanyarg __P((hte_t *, fcall_t *)); -static int eqtype __P((type_t *, type_t *, int, int, int, int *)); -static int eqargs __P((type_t *, type_t *, int *)); -static int mnoarg __P((type_t *, int *)); - - -void -inittyp() -{ - 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" } }, - }; - - 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; - } -} +static void chkund(hte_t *); +static void chkdnu(hte_t *); +static void chkdnud(hte_t *); +static void chkmd(hte_t *); +static void chkvtui(hte_t *, sym_t *, sym_t *); +static void chkvtdi(hte_t *, sym_t *, sym_t *); +static void chkfaui(hte_t *, sym_t *, sym_t *); +static void chkau(hte_t *, int, sym_t *, sym_t *, pos_t *, + fcall_t *, fcall_t *, type_t *, type_t *); +static void chkrvu(hte_t *, sym_t *); +static void chkadecl(hte_t *, sym_t *, sym_t *); +static void printflike(hte_t *,fcall_t *, int, const char *, type_t **); +static void scanflike(hte_t *, fcall_t *, int, const char *, type_t **); +static void badfmt(hte_t *, fcall_t *); +static void inconarg(hte_t *, fcall_t *, int); +static void tofewarg(hte_t *, fcall_t *); +static void tomanyarg(hte_t *, fcall_t *); +static int eqtype(type_t *, type_t *, int, int, int, int *); +static int eqargs(type_t *, type_t *, int *); +static int mnoarg(type_t *, int *); /* * If there is a symbol named "main", mark it as used. */ void -mainused() +mainused(void) { hte_t *hte; @@ -174,8 +81,7 @@ mainused() * Performs all tests for a single name */ void -chkname(hte) - hte_t *hte; +chkname(hte_t *hte) { sym_t *sym, *def, *pdecl, *decl; @@ -220,8 +126,7 @@ chkname(hte) * Print a warning if the name has been used, but not defined. */ static void -chkund(hte) - hte_t *hte; +chkund(hte_t *hte) { fcall_t *fcall; usym_t *usym; @@ -242,8 +147,7 @@ chkund(hte) * Print a warning if the name has been defined, but never used. */ static void -chkdnu(hte) - hte_t *hte; +chkdnu(hte_t *hte) { sym_t *sym; @@ -260,33 +164,33 @@ chkdnu(hte) } /* - * Print a warning if the name has been declared, but is not used + * Print a warning if the variable has been declared, but is not used * or defined. */ static void -chkdnud(hte) - hte_t *hte; +chkdnud(hte_t *hte) { sym_t *sym; if (hte->h_syms == NULL || hte->h_used || hte->h_def) return; - - if ((sym = hte->h_syms) != NULL) { - if (sym->s_def != DECL) - errx(1, "internal error: chkdnud() 1"); - /* %s declared( %s ), but never used or defined */ - msg(2, hte->h_name, mkpos(&sym->s_pos)); - } + + sym = hte->h_syms; + if (TP(sym->s_type)->t_tspec == FUNC) + return; + + if (sym->s_def != DECL) + errx(1, "internal error: chkdnud() 1"); + /* %s declared( %s ), but never used or defined */ + msg(2, hte->h_name, mkpos(&sym->s_pos)); } /* - * Print a warning if there is more then one definition for + * Print a warning if there is more than one definition for * this name. */ static void -chkmd(hte) - hte_t *hte; +chkmd(hte_t *hte) { sym_t *sym, *def1; char *pos1; @@ -323,9 +227,7 @@ chkmd(hte) * call as it's done for function arguments. */ static void -chkvtui(hte, def, decl) - hte_t *hte; - sym_t *def, *decl; +chkvtui(hte_t *hte, sym_t *def, sym_t *decl) { fcall_t *call; char *pos1; @@ -386,9 +288,7 @@ chkvtui(hte, def, decl) * types of return values are tested. */ static void -chkvtdi(hte, def, decl) - hte_t *hte; - sym_t *def, *decl; +chkvtdi(hte_t *hte, sym_t *def, sym_t *decl) { sym_t *sym; type_t *tp1, *tp2; @@ -427,12 +327,10 @@ chkvtdi(hte, def, decl) * of the same function. */ static void -chkfaui(hte, def, decl) - hte_t *hte; - sym_t *def, *decl; +chkfaui(hte_t *hte, sym_t *def, sym_t *decl) { type_t *tp1, *tp2, **ap1, **ap2; - pos_t *pos1p; + pos_t *pos1p = NULL; fcall_t *calls, *call, *call1; int n, as; char *pos1; @@ -442,7 +340,7 @@ chkfaui(hte, def, decl) return; /* - * If we find a function definition, we use this for comparision, + * If we find a function definition, we use this for comparison, * otherwise the first prototype we can find. If there is no * definition or prototype declaration, the first function call * is used. @@ -537,13 +435,8 @@ chkfaui(hte, def, decl) * */ static void -chkau(hte, n, def, decl, pos1p, call1, call, arg1, arg2) - hte_t *hte; - int n; - sym_t *def, *decl; - pos_t *pos1p; - fcall_t *call1, *call; - type_t *arg1, *arg2; +chkau(hte_t *hte, int n, sym_t *def, sym_t *decl, pos_t *pos1p, + fcall_t *call1, fcall_t *call, type_t *arg1, type_t *arg2) { /* LINTED (automatic hides external declaration: warn) */ int promote, asgn, warn; @@ -577,7 +470,7 @@ chkau(hte, n, def, decl, pos1p, call1, call, arg1, arg2) /* * Other lint implementations print warnings as soon as the type * of an argument does not match exactly the expected type. The - * result are lots of warnings which are really not neccessary. + * result are lots of warnings which are really not necessary. * We print a warning only if * (0) at least one type is not an interger type and types differ * (1) hflag is set and types differ @@ -670,11 +563,16 @@ chkau(hte, n, def, decl, pos1p, call1, call, arg1, arg2) } } - } else if (t1 == PTR && isityp(t2) && psize(t1) == psize(t2)) { + } else if (t1 == PTR && isityp(t2)) { for (ai = call->f_args; ai != NULL; ai = ai->a_nxt) { if (ai->a_num == n) break; } + /* + * Vendor implementations of lint (e.g. HP-UX, Digital UNIX) + * don't care about the size of the integer argument, + * only whether or not it is zero. We do the same. + */ if (ai != NULL && ai->a_zero) return; } @@ -690,17 +588,12 @@ chkau(hte, n, def, decl, pos1p, call1, call, arg1, arg2) * string fmt. */ static void -printflike(hte, call, n, fmt, ap) - hte_t *hte; - fcall_t *call; - int n; - const char *fmt; - type_t **ap; +printflike(hte_t *hte, fcall_t *call, int n, const char *fmt, type_t **ap) { const char *fp; int fc; int fwidth, prec, left, sign, space, alt, zero; - tspec_t sz, t1, t2; + tspec_t sz, t1, t2 = NOTSPEC; type_t *tp; fp = fmt; @@ -920,18 +813,13 @@ printflike(hte, call, n, fmt, ap) * string fmt. */ static void -scanflike(hte, call, n, fmt, ap) - hte_t *hte; - fcall_t *call; - int n; - const char *fmt; - type_t **ap; +scanflike(hte_t *hte, fcall_t *call, int n, const char *fmt, type_t **ap) { const char *fp; int fc; int noasgn, fwidth; - tspec_t sz, t1, t2; - type_t *tp; + tspec_t sz, t1 = NOTSPEC, t2 = NOTSPEC; + type_t *tp = NULL; fp = fmt; fc = *fp++; @@ -955,7 +843,7 @@ scanflike(hte, call, n, fmt, ap) noasgn = 1; fc = *fp++; } - + if (isdigit(fc)) { fwidth = 1; do { fc = *fp++; } while (isdigit(fc)); @@ -1116,38 +1004,33 @@ scanflike(hte, call, n, fmt, ap) } static void -badfmt(hte, call) - hte_t *hte; - fcall_t *call; +badfmt(hte_t *hte, fcall_t *call) { + /* %s: malformed format string\t%s */ msg(13, hte->h_name, mkpos(&call->f_pos)); } static void -inconarg(hte, call, n) - hte_t *hte; - fcall_t *call; - int n; +inconarg(hte_t *hte, fcall_t *call, int n) { + /* %s, arg %d inconsistent with format\t%s(%d) */ msg(14, hte->h_name, n, mkpos(&call->f_pos)); } static void -tofewarg(hte, call) - hte_t *hte; - fcall_t *call; +tofewarg(hte_t *hte, fcall_t *call) { + /* %s: too few args for format \t%s */ msg(15, hte->h_name, mkpos(&call->f_pos)); } static void -tomanyarg(hte, call) - hte_t *hte; - fcall_t *call; +tomanyarg(hte_t *hte, fcall_t *call) { + /* %s: too many args for format \t%s */ msg(16, hte->h_name, mkpos(&call->f_pos)); } @@ -1158,9 +1041,7 @@ tomanyarg(hte, call) * or return values which are always or sometimes ignored. */ static void -chkrvu(hte, def) - hte_t *hte; - sym_t *def; +chkrvu(hte_t *hte, sym_t *def) { fcall_t *call; int used, ignored; @@ -1176,7 +1057,7 @@ chkrvu(hte, def) /* function has return value */ used = ignored = 0; for (call = hte->h_calls; call != NULL; call = call->f_nxt) { - used |= call->f_rused; + used |= call->f_rused || call->f_rdisc; ignored |= !call->f_rused && !call->f_rdisc; } /* @@ -1208,9 +1089,7 @@ chkrvu(hte, def) * Print warnings for inconsistent argument declarations. */ static void -chkadecl(hte, def, decl) - hte_t *hte; - sym_t *def, *decl; +chkadecl(hte_t *hte, sym_t *def, sym_t *decl) { /* LINTED (automatic hides external declaration: warn) */ int osdef, eq, warn, n; @@ -1280,8 +1159,8 @@ chkadecl(hte, def, decl) * * ignqual if set, ignore qualifiers of outhermost type; used for * function arguments - * promote if set, promote left type before comparision; used for - * comparisions of arguments with parameters of old style + * promote if set, promote left type before comparison; used for + * comparisons of arguments with parameters of old style * definitions * asgn left indirected type must have at least the same qualifiers * like right indirected type (for assignments and function @@ -1290,9 +1169,7 @@ chkadecl(hte, def, decl) * an incompatible prototype declaration */ static int -eqtype(tp1, tp2, ignqual, promot, asgn, warn) - type_t *tp1, *tp2; - int ignqual, promot, asgn, *warn; +eqtype(type_t *tp1, type_t *tp2, int ignqual, int promot, int asgn, int *warn) { tspec_t t, to; int indir; @@ -1322,7 +1199,7 @@ eqtype(tp1, tp2, ignqual, promot, asgn, warn) if (indir == 1 && (t == VOID || tp2->t_tspec == VOID)) return (1); } - + if (t != tp2->t_tspec) { /* * Give pointer to types which differ only in @@ -1339,6 +1216,13 @@ eqtype(tp1, tp2, ignqual, promot, asgn, warn) return (tp1->t_tag == tp2->t_tag); } else if (tp1->t_istynam && tp2->t_istynam) { return (tp1->t_tynam == tp2->t_tynam); + } else if (tp1->t_isuniqpos && tp2->t_isuniqpos) { + return (tp1->t_uniqpos.p_line == + tp2->t_uniqpos.p_line && + tp1->t_uniqpos.p_file == + tp2->t_uniqpos.p_file && + tp1->t_uniqpos.p_uniq == + tp2->t_uniqpos.p_uniq); } else { return (0); } @@ -1366,6 +1250,13 @@ eqtype(tp1, tp2, ignqual, promot, asgn, warn) return (tp1->t_tag == tp2->t_tag); } else if (tp1->t_istynam && tp2->t_istynam) { return (tp1->t_tynam == tp2->t_tynam); + } else if (tp1->t_isuniqpos && tp2->t_isuniqpos) { + return (tp1->t_uniqpos.p_line == + tp2->t_uniqpos.p_line && + tp1->t_uniqpos.p_file == + tp2->t_uniqpos.p_file && + tp1->t_uniqpos.p_uniq == + tp2->t_uniqpos.p_uniq); } else { return (0); } @@ -1404,9 +1295,7 @@ eqtype(tp1, tp2, ignqual, promot, asgn, warn) * Compares arguments of two prototypes */ static int -eqargs(tp1, tp2, warn) - type_t *tp1, *tp2; - int *warn; +eqargs(type_t *tp1, type_t *tp2, int *warn) { type_t **a1, **a2; @@ -1440,9 +1329,7 @@ eqargs(tp1, tp2, warn) * is applied on it */ static int -mnoarg(tp, warn) - type_t *tp; - int *warn; +mnoarg(type_t *tp, int *warn) { type_t **arg; tspec_t t; @@ -1459,4 +1346,3 @@ mnoarg(tp, warn) } return (1); } - diff --git a/usr.bin/xlint/lint2/emit2.c b/usr.bin/xlint/lint2/emit2.c index 82527b5..1b4510f 100644 --- a/usr.bin/xlint/lint2/emit2.c +++ b/usr.bin/xlint/lint2/emit2.c @@ -1,6 +1,7 @@ -/* $NetBSD: emit2.c,v 1.2 1995/07/03 21:24:44 cgd Exp $ */ +/* $NetBSD: emit2.c,v 1.8 2002/01/21 19:49:52 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -31,24 +32,23 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: emit2.c,v 1.2 1995/07/03 21:24:44 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: emit2.c,v 1.8 2002/01/21 19:49:52 tv Exp $"); #endif -#include - #include "lint2.h" -static void outtype __P((type_t *)); -static void outdef __P((hte_t *, sym_t *)); -static void dumpname __P((hte_t *)); +static void outtype(type_t *); +static void outdef(hte_t *, sym_t *); +static void dumpname(hte_t *); +static void outfiles(void); /* * Write type into the output buffer. */ static void -outtype(tp) - type_t *tp; +outtype(type_t *tp) { int t, s, na; tspec_t ts; @@ -105,9 +105,15 @@ outtype(tp) } else if (tp->t_istynam) { outint(2); outname(tp->t_tynam->h_name); - } else { - outint(0); - } + } else if (tp->t_isuniqpos) { + outint(3); + outint(tp->t_uniqpos.p_line); + outchar('.'); + outint(tp->t_uniqpos.p_file); + outchar('.'); + outint(tp->t_uniqpos.p_uniq); + } else + errx(1, "internal error: outtype() 2"); } else if (ts == FUNC && tp->t_args != NULL) { na = 0; for (ap = tp->t_args; *ap != NULL; ap++) @@ -128,10 +134,9 @@ outtype(tp) * Write a definition. */ static void -outdef(hte, sym) - hte_t *hte; - sym_t *sym; +outdef(hte_t *hte, sym_t *sym) { + /* reset output buffer */ outclr(); @@ -180,8 +185,7 @@ outdef(hte, sym) * Write the first definition of a name into the lint library. */ static void -dumpname(hte) - hte_t *hte; +dumpname(hte_t *hte) { sym_t *sym, *def; @@ -191,7 +195,7 @@ dumpname(hte) /* * If there is a definition, write it. Otherwise write a tentative - * definition. This is neccessary because more than one tentative + * definition. This is necessary because more than one tentative * definition is allowed (except with sflag). */ def = NULL; @@ -213,8 +217,7 @@ dumpname(hte) * Write a new lint library. */ void -outlib(name) - const char *name; +outlib(const char *name) { /* Open of output file and initialisation of the output buffer */ outopen(name); @@ -228,9 +231,67 @@ outlib(name) outchar('s'); outstrg(name); + /* + * print the names of all files references by unnamed + * struct/union/enum declarations. + */ + outfiles(); + /* write all definitions with external linkage */ forall(dumpname); /* close the output */ outclose(); } + +/* + * Write out the name of a file referenced by a type. + */ +struct outflist { + short ofl_num; + struct outflist *ofl_next; +}; +static struct outflist *outflist; + +int +addoutfile(short num) +{ + struct outflist *ofl, **pofl; + int i; + + ofl = outflist; + pofl = &outflist; + i = 1; /* library is 0 */ + + while (ofl != NULL) { + if (ofl->ofl_num == num) + break; + + pofl = &ofl->ofl_next; + ofl = ofl->ofl_next; + i++; + } + + if (ofl == NULL) { + ofl = *pofl = xmalloc(sizeof (struct outflist)); + ofl->ofl_num = num; + ofl->ofl_next = NULL; + } + return (i); +} + +static void +outfiles(void) +{ + struct outflist *ofl; + int i; + + for (ofl = outflist, i = 1; ofl != NULL; ofl = ofl->ofl_next, i++) { + /* reset output buffer */ + outclr(); + + outint(i); + outchar('s'); + outstrg(fnames[ofl->ofl_num]); + } +} diff --git a/usr.bin/xlint/lint2/externs2.h b/usr.bin/xlint/lint2/externs2.h index 2e65e53..3b6f03a 100644 --- a/usr.bin/xlint/lint2/externs2.h +++ b/usr.bin/xlint/lint2/externs2.h @@ -1,6 +1,7 @@ -/* $NetBSD: externs2.h,v 1.2 1995/07/03 21:24:46 cgd Exp $ */ +/* $NetBSD: externs2.h,v 1.7 2001/05/28 12:40:38 lukem Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -38,7 +39,6 @@ extern int xflag; extern int uflag; extern int Cflag; extern const char *libname; -extern int pflag; extern int sflag; extern int tflag; extern int Hflag; @@ -49,9 +49,14 @@ extern int Fflag; /* * hash.c */ -extern void inithash __P((void)); -extern hte_t *hsearch __P((const char *, int)); -extern void forall __P((void (*)(hte_t *))); +extern void _inithash(hte_t ***); +extern hte_t *_hsearch(hte_t **, const char *, int); +extern void _forall(hte_t **, void (*)(hte_t *)); +extern void _destroyhash(hte_t **); + +#define inithash() _inithash(NULL); +#define hsearch(a, b) _hsearch(NULL, (a), (b)) +#define forall(a) _forall(NULL, (a)) /* * read.c @@ -59,29 +64,30 @@ extern void forall __P((void (*)(hte_t *))); extern const char **fnames; extern type_t **tlst; -extern void readfile __P((const char *)); -extern void mkstatic __P((hte_t *)); +extern void readfile(const char *); +extern void mkstatic(hte_t *); /* * mem2.c */ -extern void initmem __P((void)); -extern void *xalloc __P((size_t)); +extern void initmem(void); +extern void *xalloc(size_t); /* * chk.c */ -extern void inittyp __P((void)); -extern void mainused __P((void)); -extern void chkname __P((hte_t *)); +extern void inittyp(void); +extern void mainused(void); +extern void chkname(hte_t *); /* * msg.c */ -extern void msg __P((int, ...)); -extern const char *mkpos __P((pos_t *)); +extern void msg(int, ...); +extern const char *mkpos(pos_t *); /* * emit2.c */ -extern void outlib __P((const char *)); +extern void outlib(const char *); +extern int addoutfile(short); diff --git a/usr.bin/xlint/lint2/hash.c b/usr.bin/xlint/lint2/hash.c index 7901802..fac7358 100644 --- a/usr.bin/xlint/lint2/hash.c +++ b/usr.bin/xlint/lint2/hash.c @@ -1,4 +1,4 @@ -/* $NetBSD: hash.c,v 1.2 1995/07/03 21:24:47 cgd Exp $ */ +/* $NetBSD: hash.c,v 1.7 2002/01/21 19:49:52 tv Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,36 +31,45 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: hash.c,v 1.2 1995/07/03 21:24:47 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: hash.c,v 1.7 2002/01/21 19:49:52 tv Exp $"); #endif +/* + * XXX Really need a generalized hash table package + */ + +#include #include +#include #include -#include #include "lint2.h" /* pointer to hash table, initialized in inithash() */ static hte_t **htab; -static int hash __P((const char *)); +static int hash(const char *); /* * Initialize hash table. */ void -inithash() +_inithash(hte_t ***tablep) { - htab = xcalloc(HSHSIZ2, sizeof (hte_t *)); + + if (tablep == NULL) + tablep = &htab; + + *tablep = xcalloc(HSHSIZ2, sizeof (hte_t *)); } /* * Compute hash value from a string. */ static int -hash(s) - const char *s; +hash(const char *s) { u_int v; const u_char *us; @@ -78,15 +87,16 @@ hash(s) * given name exists and mknew is set, create a new one. */ hte_t * -hsearch(s, mknew) - const char *s; - int mknew; +_hsearch(hte_t **table, const char *s, int mknew) { int h; hte_t *hte; + if (table == NULL) + table = htab; + h = hash(s); - for (hte = htab[h]; hte != NULL; hte = hte->h_link) { + for (hte = table[h]; hte != NULL; hte = hte->h_link) { if (strcmp(hte->h_name, s) == 0) break; } @@ -95,13 +105,20 @@ hsearch(s, mknew) return (hte); /* create a new hte */ - hte = xalloc(sizeof (hte_t)); + hte = xmalloc(sizeof (hte_t)); hte->h_name = xstrdup(s); + hte->h_used = 0; + hte->h_def = 0; + hte->h_static = 0; + hte->h_syms = NULL; hte->h_lsym = &hte->h_syms; + hte->h_calls = NULL; hte->h_lcall = &hte->h_calls; + hte->h_usyms = NULL; hte->h_lusym = &hte->h_usyms; - hte->h_link = htab[h]; - htab[h] = hte; + hte->h_link = table[h]; + hte->h_hte = NULL; + table[h] = hte; return (hte); } @@ -110,14 +127,38 @@ hsearch(s, mknew) * Call function f for each name in the hash table. */ void -forall(f) - void (*f) __P((hte_t *)); +_forall(hte_t **table, void (*f)(hte_t *)) { int i; hte_t *hte; + if (table == NULL) + table = htab; + for (i = 0; i < HSHSIZ2; i++) { - for (hte = htab[i]; hte != NULL; hte = hte->h_link) + for (hte = table[i]; hte != NULL; hte = hte->h_link) (*f)(hte); } } + +/* + * Free all contents of the hash table that this module allocated. + */ +void +_destroyhash(hte_t **table) +{ + int i; + hte_t *hte, *nexthte; + + if (table == NULL) + err(1, "_destroyhash called on main hash table"); + + for (i = 0; i < HSHSIZ2; i++) { + for (hte = table[i]; hte != NULL; hte = nexthte) { + free((void *)hte->h_name); + nexthte = hte->h_link; + free(hte); + } + } + free(table); +} diff --git a/usr.bin/xlint/lint2/lint2.h b/usr.bin/xlint/lint2/lint2.h index 0ade110..75f9dc9 100644 --- a/usr.bin/xlint/lint2/lint2.h +++ b/usr.bin/xlint/lint2/lint2.h @@ -1,6 +1,7 @@ -/* $NetBSD: lint2.h,v 1.2 1995/07/03 21:24:49 cgd Exp $ */ +/* $NetBSD: lint2.h,v 1.5 2000/06/14 06:49:23 cgd Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -45,6 +46,7 @@ typedef struct type { u_int t_proto : 1; /* this is a prototype */ u_int t_istag : 1; /* tag with _t_tag valid */ u_int t_istynam : 1; /* tag with _t_tynam valid */ + u_int t_isuniqpos : 1; /* tag with _t_uniqpos valid */ union { int _t_dim; /* if the type is an ARRAY than this is the dimension of the array. */ @@ -52,6 +54,13 @@ typedef struct type { t_isenum, STRUCT or UNION */ struct hte *_t_tynam; /* hash table entry of typename if t_isenum, STRUCT or UNION */ + struct { + int p_line; + short p_file; + int p_uniq; + } _t_uniqpos; /* unique position, for untagged + untyped STRUCTs, UNIONS, and ENUMs, + if t_isuniqpos */ struct type **_t_args; /* list of argument types if this is a prototype */ } t_u; @@ -59,10 +68,11 @@ typedef struct type { type, type of return value) */ } type_t; -#define t_dim t_u._t_dim -#define t_tag t_u._t_tag -#define t_tynam t_u._t_tynam -#define t_args t_u._t_args +#define t_dim t_u._t_dim +#define t_tag t_u._t_tag +#define t_tynam t_u._t_tynam +#define t_uniqpos t_u._t_uniqpos +#define t_args t_u._t_args /* * argument information @@ -90,7 +100,7 @@ typedef struct { u_short p_line; /* line number in p_src */ u_short p_isrc; /* index of (included) file */ u_short p_iline; /* line number in p_iline */ -} pos_t; +} pos_t; /* * Used for definitions and declarations @@ -107,7 +117,7 @@ typedef struct sym { u_int s_def : 3; /* DECL, TDEF or DEF */ #else def_t s_def; -#endif +#endif u_int s_rval : 1; /* function has return value */ u_int s_osdef : 1; /* old style function definition */ u_int s_static : 1; /* symbol is static */ @@ -169,6 +179,7 @@ typedef struct hte { usym_t *h_usyms; /* usage info */ usym_t **h_lusym; /* points to u_nxt of last usage info */ struct hte *h_link; /* next hte with same hash function */ + struct hte *h_hte; /* pointer to other htes (for renames */ } hte_t; /* maps type indices into pointers to type structs */ diff --git a/usr.bin/xlint/lint2/main2.c b/usr.bin/xlint/lint2/main2.c index 171344a..71e8c10 100644 --- a/usr.bin/xlint/lint2/main2.c +++ b/usr.bin/xlint/lint2/main2.c @@ -1,4 +1,4 @@ -/* $NetBSD: main2.c,v 1.2 1995/07/03 21:24:53 cgd Exp $ */ +/* $NetBSD: main2.c,v 1.5 2001/11/21 19:14:26 wiz Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,8 +31,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: main2.c,v 1.2 1995/07/03 21:24:53 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: main2.c,v 1.5 2001/11/21 19:14:26 wiz Exp $"); #endif #include @@ -58,7 +59,7 @@ const char *libname; int pflag; /* - * warnings for (tentative) definitions of the same name in more then + * warnings for (tentative) definitions of the same name in more than * one translation unit */ int sflag; @@ -83,13 +84,12 @@ int Fflag; */ const char **libs; -static void usage __P((void)); +static void usage(void); +int main(int, char *[]); int -main(argc, argv) - int argc; - char *argv[]; +main(int argc, char *argv[]) { int c, i; size_t len; @@ -133,8 +133,9 @@ main(argc, argv) Fflag = 1; break; case 'l': - for (i = 0; libs[i] != NULL; i++) ; - libs = xrealloc(libs, (i + 2) * sizeof (char *)); + for (i = 0; libs[i] != NULL; i++) + continue; + libs = xrealloc(libs, (i + 2) * sizeof (char *)); libs[i] = xstrdup(optarg); libs[i + 1] = NULL; break; @@ -142,7 +143,7 @@ main(argc, argv) usage(); } } - + argc -= optind; argv += optind; @@ -181,10 +182,9 @@ main(argc, argv) } static void -usage() +usage(void) { (void)fprintf(stderr, "usage: lint2 -hpstxuHF -Clib -l lib ... src1 ...\n"); exit(1); } - diff --git a/usr.bin/xlint/lint2/mem2.c b/usr.bin/xlint/lint2/mem2.c index 06d7491..87d5a1b 100644 --- a/usr.bin/xlint/lint2/mem2.c +++ b/usr.bin/xlint/lint2/mem2.c @@ -1,4 +1,4 @@ -/* $NetBSD: mem2.c,v 1.3 1995/10/02 17:27:11 jpo Exp $ */ +/* $NetBSD: mem2.c,v 1.6 2002/01/21 19:49:52 tv Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,8 +31,9 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: mem2.c,v 1.3 1995/10/02 17:27:11 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: mem2.c,v 1.6 2002/01/21 19:49:52 tv Exp $"); #endif #include @@ -40,7 +41,6 @@ static char rcsid[] = "$NetBSD: mem2.c,v 1.3 1995/10/02 17:27:11 jpo Exp $"; #include #include #include -#include #include "lint2.h" @@ -54,7 +54,7 @@ static size_t nxtfree; static void *mbuf; void -initmem() +initmem(void) { int pgsz; @@ -70,13 +70,13 @@ initmem() * need never to be freed. */ void * -xalloc(sz) - size_t sz; +xalloc(size_t sz) { void *ptr; int prot, flags; - sz = ALIGN(sz); + /* Align to at least 8 bytes. */ + sz = (sz + 7) & ~7L; if (nxtfree + sz > mblklen) { /* use mmap() instead of malloc() to avoid malloc overhead. */ prot = PROT_READ | PROT_WRITE; @@ -84,8 +84,6 @@ xalloc(sz) mbuf = mmap(NULL, mblklen, prot, flags, -1, (off_t)0); if (mbuf == (void *)-1) err(1, "can't map memory"); - if (ALIGN((u_long)mbuf) != (u_long)mbuf) - errx(1, "mapped address is not aligned"); (void)memset(mbuf, 0, mblklen); nxtfree = 0; } diff --git a/usr.bin/xlint/lint2/msg.c b/usr.bin/xlint/lint2/msg.c index c55ba96..b4a6a31 100644 --- a/usr.bin/xlint/lint2/msg.c +++ b/usr.bin/xlint/lint2/msg.c @@ -1,4 +1,4 @@ -/* $NetBSD: msg.c,v 1.2 1995/07/03 21:24:56 cgd Exp $ */ +/* $NetBSD: msg.c,v 1.6 2002/01/21 19:49:52 tv Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -31,22 +31,17 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: msg.c,v 1.2 1995/07/03 21:24:56 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: msg.c,v 1.6 2002/01/21 19:49:52 tv Exp $"); #endif -#include - #include -#ifdef __STDC__ #include -#else -#include -#endif +#include #include "lint2.h" - static const char *msgs[] = { "%s used( %s ), but not defined", /* 0 */ "%s defined( %s ), but never used", /* 1 */ @@ -66,29 +61,17 @@ static const char *msgs[] = { "%s: too few args for format \t%s", /* 15 */ "%s: too many args for format \t%s", /* 16 */ "%s function value must be declared before use \t%s :: %s",/* 17 */ + "%s renamed multiple times \t%s :: %s", /* 18 */ }; -static const char *basename __P((const char *)); +static const char *lbasename(const char *); -#ifdef __STDC__ void msg(int n, ...) { -#else -void -msg(va_alist) - va_dcl - int n; -{ -#endif va_list ap; -#ifdef __STDC__ va_start(ap, n); -#else - va_start(ap); - n = va_arg(ap, int); -#endif (void)vprintf(msgs[n], ap); (void)printf("\n"); @@ -100,8 +83,7 @@ msg(va_alist) * Return a pointer to the last component of a path. */ static const char * -basename(path) - const char *path; +lbasename(const char *path) { const char *cp, *cp1, *cp2; @@ -122,8 +104,7 @@ basename(path) * Create a string which describes a position in a source file. */ const char * -mkpos(posp) - pos_t *posp; +mkpos(pos_t *posp) { size_t len; const char *fn; @@ -140,7 +121,7 @@ mkpos(posp) } qm = !Hflag && posp->p_src != posp->p_isrc; - len = strlen(fn = basename(fnames[src])); + len = strlen(fn = lbasename(fnames[src])); len += 3 * sizeof (u_short) + 4; if (len > blen) @@ -154,4 +135,3 @@ mkpos(posp) return (buf); } - diff --git a/usr.bin/xlint/lint2/read.c b/usr.bin/xlint/lint2/read.c index daffe1e..d3e8f9e 100644 --- a/usr.bin/xlint/lint2/read.c +++ b/usr.bin/xlint/lint2/read.c @@ -1,6 +1,7 @@ -/* $NetBSD: read.c,v 1.2 1995/07/03 21:24:59 cgd Exp $ */ +/* $NetBSD: read.c,v 1.12 2002/01/21 19:49:52 tv Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -31,16 +32,16 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: read.c,v 1.2 1995/07/03 21:24:59 cgd Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: read.c,v 1.12 2002/01/21 19:49:52 tv Exp $"); #endif +#include +#include #include #include #include -#include -#include -#include #include "lint2.h" @@ -78,33 +79,34 @@ static thtab_t **thtab; /* hash table */ type_t **tlst; /* array for indexed access */ static size_t tlstlen; /* length of tlst */ +static hte_t **renametab; + /* index of current C source file (as spezified at the command line) */ static int csrcfile; -static void inperr __P((void)); -static void setsrc __P((const char *)); -static void setfnid __P((int, const char *)); -static void funccall __P((pos_t *, const char *)); -static void decldef __P((pos_t *, const char *)); -static void usedsym __P((pos_t *, const char *)); -static u_short inptype __P((const char *, const char **)); -static int gettlen __P((const char *, const char **)); -static u_short findtype __P((const char *, size_t, int)); -static u_short storetyp __P((type_t *, const char *, size_t, int)); -static int thash __P((const char *, size_t)); -static char *inpqstrg __P((const char *, const char **)); -static const char *inpname __P((const char *, const char **)); -static int getfnidx __P((const char *)); +static void inperr(void); +static void setsrc(const char *); +static void setfnid(int, const char *); +static void funccall(pos_t *, const char *); +static void decldef(pos_t *, const char *); +static void usedsym(pos_t *, const char *); +static u_short inptype(const char *, const char **); +static int gettlen(const char *, const char **); +static u_short findtype(const char *, size_t, int); +static u_short storetyp(type_t *, const char *, size_t, int); +static int thash(const char *, size_t); +static char *inpqstrg(const char *, const char **); +static const char *inpname(const char *, const char **); +static int getfnidx(const char *); void -readfile(name) - const char *name; +readfile(const char *name) { FILE *inp; size_t len; const char *cp; - char *line, *eptr, rt; + char *line, *eptr, rt = '\0'; int cline, isrc, iline; pos_t pos; @@ -117,6 +119,8 @@ readfile(name) if (thtab == NULL) thtab = xcalloc(THSHSIZ2, sizeof (thtab_t)); + _inithash(&renametab); + srcfile = getfnidx(name); if ((inp = fopen(name, "r")) == NULL) @@ -193,6 +197,8 @@ readfile(name) } + _destroyhash(renametab); + if (ferror(inp)) err(1, "read error on %s", name); @@ -201,8 +207,9 @@ readfile(name) static void -inperr() +inperr(void) { + errx(1, "input file error: %s", fnames[srcfile]); } @@ -211,23 +218,22 @@ inperr() * currently read. */ static void -setsrc(cp) - const char *cp; +setsrc(const char *cp) { + csrcfile = getfnidx(cp); } /* * setfnid() gets as input an index as used in an input file and the - * associated file name. If neccessary, it creates a new lint2 file + * associated file name. If necessary, it creates a new lint2 file * name index for this file name and creates the mapping of the index * as used in the input file to the index used in lint2. */ static void -setfnid(fid, cp) - int fid; - const char *cp; +setfnid(int fid, const char *cp) { + if (fid == -1) inperr(); @@ -249,15 +255,14 @@ setfnid(fid, cp) * Process a function call record (c-record). */ static void -funccall(posp, cp) - pos_t *posp; - const char *cp; +funccall(pos_t *posp, const char *cp) { arginf_t *ai, **lai; char c, *eptr; int rused, rdisc; hte_t *hte; fcall_t *fcall; + const char *name; fcall = xalloc(sizeof (fcall_t)); STRUCT_ASSIGN(fcall->f_pos, *posp); @@ -311,7 +316,14 @@ funccall(posp, cp) fcall->f_rdisc = rdisc; /* read name of function */ - hte = hsearch(inpname(cp, &cp), 1); + name = inpname(cp, &cp); + + /* first look it up in the renaming table, then in the normal table */ + hte = _hsearch(renametab, name, 0); + if (hte != NULL) + hte = hte->h_hte; + else + hte = hsearch(name, 1); hte->h_used = 1; fcall->f_type = inptype(cp, &cp); @@ -327,14 +339,13 @@ funccall(posp, cp) * Process a declaration or definition (d-record). */ static void -decldef(posp, cp) - pos_t *posp; - const char *cp; +decldef(pos_t *posp, const char *cp) { sym_t *symp, sym; - char c, *ep; - int used; - hte_t *hte; + char c, *ep, *pos1; + int used, renamed; + hte_t *hte, *renamehte = NULL; + const char *name, *rename; (void)memset(&sym, 0, sizeof (sym)); STRUCT_ASSIGN(sym.s_pos, *posp); @@ -412,8 +423,35 @@ decldef(posp, cp) } } - /* read symbol name */ - hte = hsearch(inpname(cp, &cp), 1); + /* read symbol name, doing renaming if necessary */ + name = inpname(cp, &cp); + renamed = 0; + if (*cp == 'r') { + cp++; + name = xstrdup(name); + rename = inpname(cp, &cp); + + /* enter it and see if it's already been renamed */ + renamehte = _hsearch(renametab, name, 1); + if (renamehte->h_hte == NULL) { + hte = hsearch(rename, 1); + renamehte->h_hte = hte; + renamed = 1; + } else if (strcmp((hte = renamehte->h_hte)->h_name, rename)) { + pos1 = xstrdup(mkpos(&renamehte->h_syms->s_pos)); + /* %s renamed multiple times\t%s :: %s */ + msg(18, name, pos1, mkpos(&sym.s_pos)); + free(pos1); + } + free((char *)name); + } else { + /* it might be a previously-done rename */ + hte = _hsearch(renametab, name, 0); + if (hte != NULL) + hte = hte->h_hte; + else + hte = hsearch(name, 1); + } hte->h_used |= used; if (sym.s_def == DEF || sym.s_def == TDEF) hte->h_def = 1; @@ -449,6 +487,10 @@ decldef(posp, cp) } *hte->h_lsym = symp; hte->h_lsym = &symp->s_nxt; + + /* XXX hack so we can remember where a symbol was renamed */ + if (renamed) + renamehte->h_syms = symp; } if (*cp != '\0') @@ -459,12 +501,11 @@ decldef(posp, cp) * Read an u-record (emited by lint1 if a symbol was used). */ static void -usedsym(posp, cp) - pos_t *posp; - const char *cp; +usedsym(pos_t *posp, const char *cp) { usym_t *usym; hte_t *hte; + const char *name; usym = xalloc(sizeof (usym_t)); STRUCT_ASSIGN(usym->u_pos, *posp); @@ -473,7 +514,12 @@ usedsym(posp, cp) if (*cp++ != 'x') inperr(); - hte = hsearch(inpname(cp, &cp), 1); + name = inpname(cp, &cp); + hte = _hsearch(renametab, name, 0); + if (hte != NULL) + hte = hte->h_hte; + else + hte = hsearch(name, 1); hte->h_used = 1; *hte->h_lusym = usym; @@ -484,13 +530,12 @@ usedsym(posp, cp) * Read a type and return the index of this type. */ static u_short -inptype(cp, epp) - const char *cp, **epp; +inptype(const char *cp, const char **epp) { char c, s, *eptr; const char *ep; type_t *tp; - int narg, i, osdef; + int narg, i, osdef = 0; size_t tlen; u_short tidx; int h; @@ -600,8 +645,6 @@ inptype(cp, epp) case STRUCT: case UNION: switch (*cp++) { - case '0': - break; case '1': tp->t_istag = 1; tp->t_tag = hsearch(inpname(cp, &cp), 1); @@ -610,9 +653,42 @@ inptype(cp, epp) tp->t_istynam = 1; tp->t_tynam = hsearch(inpname(cp, &cp), 1); break; + case '3': + tp->t_isuniqpos = 1; + tp->t_uniqpos.p_line = strtol(cp, &eptr, 10); + cp = eptr; + cp++; + /* xlate to 'global' file name. */ + tp->t_uniqpos.p_file = + addoutfile(inpfns[strtol(cp, &eptr, 10)]); + cp = eptr; + cp++; + tp->t_uniqpos.p_uniq = strtol(cp, &eptr, 10); + cp = eptr; + break; } break; - /* LINTED (enumeration value(s) not handled in switch) */ + case LONG: + case VOID: + case LDOUBLE: + case DOUBLE: + case FLOAT: + case UQUAD: + case QUAD: + case ULONG: + case UINT: + case INT: + case USHORT: + case SHORT: + case UCHAR: + case SCHAR: + case CHAR: + case UNSIGN: + case SIGNED: + case NOTSPEC: + break; + case NTSPEC: + abort(); } *epp = cp; @@ -623,8 +699,7 @@ inptype(cp, epp) * Get the length of a type string. */ static int -gettlen(cp, epp) - const char *cp, **epp; +gettlen(const char *cp, const char **epp) { const char *cp1; char c, s, *eptr; @@ -769,19 +844,56 @@ gettlen(cp, epp) case STRUCT: case UNION: switch (*cp++) { - case '0': - break; case '1': (void)inpname(cp, &cp); break; case '2': (void)inpname(cp, &cp); break; + case '3': + /* unique position: line.file.uniquifier */ + (void)strtol(cp, &eptr, 10); + if (cp == eptr) + inperr(); + cp = eptr; + if (*cp++ != '.') + inperr(); + (void)strtol(cp, &eptr, 10); + if (cp == eptr) + inperr(); + cp = eptr; + if (*cp++ != '.') + inperr(); + (void)strtol(cp, &eptr, 10); + if (cp == eptr) + inperr(); + cp = eptr; + break; default: inperr(); } break; - /* LINTED (enumeration value(s) not handled in switch) */ + case FLOAT: + case USHORT: + case SHORT: + case UCHAR: + case SCHAR: + case CHAR: + case UNSIGN: + case SIGNED: + case NOTSPEC: + case INT: + case UINT: + case DOUBLE: + case LDOUBLE: + case VOID: + case ULONG: + case QUAD: + case UQUAD: + case LONG: + break; + case NTSPEC: + abort(); } *epp = cp; @@ -792,10 +904,7 @@ gettlen(cp, epp) * Search a type by it's type string. */ static u_short -findtype(cp, len, h) - const char *cp; - size_t len; - int h; +findtype(const char *cp, size_t len, int h) { thtab_t *thte; @@ -814,14 +923,9 @@ findtype(cp, len, h) * if we read the same type string from the input file. */ static u_short -storetyp(tp, cp, len, h) - type_t *tp; - const char *cp; - size_t len; - int h; +storetyp(type_t *tp, const char *cp, size_t len, int h) { - /* 0 ist reserved */ - static u_int tidx = 1; + static u_int tidx = 1; /* 0 is reserved */ thtab_t *thte; char *name; @@ -854,9 +958,7 @@ storetyp(tp, cp, len, h) * Hash function for types */ static int -thash(s, len) - const char *s; - size_t len; +thash(const char *s, size_t len) { u_int v; @@ -872,8 +974,7 @@ thash(s, len) * Read a string enclosed by "". This string may contain quoted chars. */ static char * -inpqstrg(src, epp) - const char *src, **epp; +inpqstrg(const char *src, const char **epp) { char *strg, *dst; size_t slen; @@ -899,11 +1000,7 @@ inpqstrg(src, epp) c = '\t'; break; case 'v': -#ifdef __STDC__ c = '\v'; -#else - c = '\013'; -#endif break; case 'b': c = '\b'; @@ -915,11 +1012,7 @@ inpqstrg(src, epp) c = '\f'; break; case 'a': -#ifdef __STDC__ c = '\a'; -#else - c = '\007'; -#endif break; case '\\': c = '\\'; @@ -964,8 +1057,7 @@ inpqstrg(src, epp) * Read the name of a symbol in static memory. */ static const char * -inpname(cp, epp) - const char *cp, **epp; +inpname(const char *cp, const char **epp) { static char *buf; static size_t blen = 0; @@ -980,7 +1072,7 @@ inpname(cp, epp) buf = xrealloc(buf, blen = len + 1); for (i = 0; i < len; i++) { c = *cp++; - if (!isalnum(c) && c != '_') + if (!isalnum((unsigned char)c) && c != '_') inperr(); buf[i] = c; } @@ -995,8 +1087,7 @@ inpname(cp, epp) * a new entry and return the index of the newly created entry. */ static int -getfnidx(fn) - const char *fn; +getfnidx(const char *fn) { int i; @@ -1022,8 +1113,7 @@ getfnidx(fn) * Separate symbols with static and external linkage. */ void -mkstatic(hte) - hte_t *hte; +mkstatic(hte_t *hte) { sym_t *sym1, **symp, *sym; fcall_t **callp, *call; @@ -1067,16 +1157,22 @@ mkstatic(hte) * XXX this entry should be put at the beginning of the list to * avoid to process the same symbol twice. */ - for (nhte = hte; nhte->h_link != NULL; nhte = nhte->h_link) ; - nhte->h_link = xalloc(sizeof (hte_t)); + for (nhte = hte; nhte->h_link != NULL; nhte = nhte->h_link) + continue; + nhte->h_link = xmalloc(sizeof (hte_t)); nhte = nhte->h_link; nhte->h_name = hte->h_name; - nhte->h_static = 1; nhte->h_used = 1; nhte->h_def = 1; /* error in lint1 */ + nhte->h_static = 1; + nhte->h_syms = NULL; nhte->h_lsym = &nhte->h_syms; + nhte->h_calls = NULL; nhte->h_lcall = &nhte->h_calls; + nhte->h_usyms = NULL; nhte->h_lusym = &nhte->h_usyms; + nhte->h_link = NULL; + nhte->h_hte = NULL; /* * move all symbols used in this translation unit into the new diff --git a/usr.bin/xlint/llib/Makefile b/usr.bin/xlint/llib/Makefile index 2e24c31..fe917d8 100644 --- a/usr.bin/xlint/llib/Makefile +++ b/usr.bin/xlint/llib/Makefile @@ -1,20 +1,22 @@ -# $NetBSD: Makefile,v 1.2 1995/07/03 21:25:05 cgd Exp $ +# $NetBSD: Makefile,v 1.7 2000/06/14 20:22:19 matt Exp $ + +.include LIBS= llib-lposix.ln llib-lstdc.ln -all: ${LIBS} +.if ${MKLINT} != "no" +FILES= ${LIBS} +FILESDIR= ${LINTLIBDIR} -install: - install ${COPY} -o ${BINOWN} -g ${BINGRP} -m ${NONBINMODE} \ - ${LIBS} ${DESTDIR}${LINTLIBDIR} +realall: ${LIBS} +.endif -clean cleanall: - rm -f ${LIBS} +CLEANFILES+= ${LIBS} llib-lposix.ln: llib-lposix - lint -Cposix ${.ALLSRC} + ${LINT} ${LINTFLAGS} -Cposix ${.ALLSRC} llib-lstdc.ln: llib-lstdc - lint -Cstdc ${.ALLSRC} + ${LINT} ${LINTFLAGS} -Cstdc ${.ALLSRC} .include diff --git a/usr.bin/xlint/llib/llib-lposix b/usr.bin/xlint/llib/llib-lposix index db1b3cf..f3a5351 100644 --- a/usr.bin/xlint/llib/llib-lposix +++ b/usr.bin/xlint/llib/llib-lposix @@ -1,4 +1,4 @@ -/* $NetBSD: llib-lposix,v 1.2 1995/07/03 21:25:09 cgd Exp $ */ +/* $NetBSD$ */ /* * Copyright (c) 1994, 1995 Jochen Pohl diff --git a/usr.bin/xlint/llib/llib-lstdc b/usr.bin/xlint/llib/llib-lstdc index f2b33da..90f456b 100644 --- a/usr.bin/xlint/llib/llib-lstdc +++ b/usr.bin/xlint/llib/llib-lstdc @@ -1,4 +1,4 @@ -/* $NetBSD: llib-lstdc,v 1.3 1995/07/03 21:39:28 cgd Exp $ */ +/* $NetBSD: llib-lstdc,v 1.2 1995/07/03 21:25:11 cgd Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl diff --git a/usr.bin/xlint/xlint/Makefile b/usr.bin/xlint/xlint/Makefile index 41c833c..c49e6c2 100644 --- a/usr.bin/xlint/xlint/Makefile +++ b/usr.bin/xlint/xlint/Makefile @@ -1,17 +1,14 @@ -# $NetBSD: Makefile,v 1.2 1995/07/03 21:25:14 cgd Exp $ +# $NetBSD: Makefile,v 1.11 2001/10/25 02:22:56 thorpej Exp $ -.PATH: ${.CURDIR}/../lint1 +.PATH: ${.CURDIR}/../lint1 -PROG= xlint -SRCS= xlint.c mem.c -MAN= lint.1 +PROG= xlint +SRCS= xlint.c mem.c +PROGNAME= lint +MAN= lint.1 -CFLAGS+=-I${.CURDIR}/../lint1 +CPPFLAGS+= -I${.CURDIR}/../lint1 -realinstall: - install ${COPY} ${STRIP} -o ${BINOWN} -g ${BINGRP} -m ${BINMODE} \ - ${PROG} ${DESTDIR}${BINDIR}/lint - - -.include "${.CURDIR}/../../Makefile.inc" +.ifndef HOSTPROG .include +.endif diff --git a/usr.bin/xlint/xlint/lint.1 b/usr.bin/xlint/xlint/lint.1 index 99d459c..6c127e2 100644 --- a/usr.bin/xlint/xlint/lint.1 +++ b/usr.bin/xlint/xlint/lint.1 @@ -1,5 +1,6 @@ -.\" $NetBSD: lint.1,v 1.3 1995/10/23 13:45:31 jpo Exp $ +.\" $NetBSD: lint.1,v 1.20 2001/12/08 19:27:56 wiz Exp $ .\" +.\" Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. .\" Copyright (c) 1994, 1995 Jochen Pohl .\" All Rights Reserved. .\" @@ -29,37 +30,81 @@ .\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF .\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. .\" -.Dd August 28, 1994 +.Dd May 24, 2001 .Dt LINT 1 -.Os NetBSD +.Os .Sh NAME .Nm lint -.Nd a C program verifier. +.Nd a C program verifier .Sh SYNOPSIS -.Nm lint -.Op Fl abceghprvxzHFV -.Op Fl s Ns | Ns Fl t -.Op Fl i Ns | Ns Fl nu -.Op Fl D Ns Ar name Ns Op =def -.Op Fl U Ns Ar name -.Op Fl I Ns Ar directory -.Op Fl L Ns Ar directory -.Op Fl l Ns Ar library -.Op Fl o Ns Ar outputfile +.Nm +.Op Fl abceghprvwxzHFV +.Bk -words +.Op Fl s | Fl t +.Ek +.Bk -words +.Op Fl i | Fl nu +.Ek +.Bk -words +.Op Fl D Ar name Ns Op =def +.Ek +.Bk -words +.Op Fl U Ar name +.Ek +.Bk -words +.Op Fl I Ar directory +.Ek +.Bk -words +.Op Fl d Ar directory +.Ek +.Bk -words +.Op Fl L Ar directory +.Ek +.Bk -words +.Op Fl l Ar library +.Ek +.Bk -words +.Op Fl o Ar outputfile +.Ek +.Bk -words +.Op Fl B Ar directory +.Ek +.Bk -words +.Op Fl X Ar id Ns Op ,id ... +.Ek .Ar .Nm lint -.Op Fl abceghprvzHFV -.Op Fl s Ns | Ns Fl t -.Fl C Ns Ar library -.Op Fl D Ns Ar name Ns Op =def -.Op Fl I Ns Ar directory -.Op Fl U Ns Ar name +.Op Fl abceghprvwzHFV +.Bk -words +.Op Fl s | Fl t +.Ek +.Bk -words +.Fl C Ar library +.Ek +.Bk -words +.Op Fl D Ar name Ns Op =def +.Ek +.Bk -words +.Op Fl U Ar name +.Ek +.Bk -words +.Op Fl I Ar directory +.Ek +.Bk -words +.Op Fl d Ar directory +.Ek +.Bk -words +.Op Fl B Ar directory +.Ek +.Bk -words +.Op Fl X Ar id Ns Op ,id ... +.Ek .Ar .Sh DESCRIPTION .Nm attempts to detect features of the named C program files that are likely to be bugs, to be non-portable, or to be -wasteful. It also performs stricter type checking then does +wasteful. It also performs stricter type checking than does the C compiler. .Nm runs the C preprocessor as its first phase, with the @@ -67,10 +112,10 @@ preprocessor symbol .Sy lint defined to allow certain questionable code to be altered or skipped by -.Nm lint . +.Nm "" . Therefore, this symbol should be thought of as a reserved word for all code that is to be checked by -.Nm lint . +.Nm "" . .Pp Among the possible problems that are currently noted are unreachable statements, loops not entered at the top, @@ -90,7 +135,7 @@ are taken to be C source files. Filename arguments with names ending with .Pa \&.ln are taken to be the result of an earlier invocation of -.Nm lint , +.Nm "" , with either the .Fl i , .Fl o @@ -143,6 +188,22 @@ if a complaint stems not from a given source file, but from one of its included files, the source filename will be printed followed by a question mark. .Pp +The special input file name +.Dq Pa - +causes +.Nm +to take input from standard input (until end of file) and process +it as if it were a +.Pa \&.c +file. +If the +.Fl i +flag is given and +.Dq Pa - +is named as one of the input files, the +.Fl o +flag must also be specified to provide an output file name. +.Pp .Sy Options .Bl -tag -width Fl .It Fl a @@ -174,21 +235,25 @@ Complain about unusual operations on and combinations of .Sy enum Ns - and -.Sy integer Ns -Types. +.Sy integer Ns -Types . .It Fl g Don't print warnings for some extensions of .Xr gcc 1 to the C language. Currently these are nonconstant initializers in automatic aggregate initializations, arithmetic on pointer to void, +trailing commas in enum declarations, C++ -style +.Dq // +comments, zero sized structures, subscripting of non-lvalue arrays, prototypes overriding old style function declarations and long long -integer types. The +integer types. +The .Fl g flag also turns on the keywords .Sy asm and .Sy inline -(alternate keywords with leading underscores for both +(alternative keywords with leading underscores for both .Sy asm and .Sy inline @@ -204,7 +269,7 @@ file for every file on the command line. These .Pa \&.ln files are the product of -.Nm lint Ns 's +.Nm "" Ns 's first pass only, and are not checked for compatibility between functions. .It Fl n @@ -237,7 +302,7 @@ are defined without leading and trailing underscores. The keywords .Sy volatile and .Sy signed -are not available in traditional C mode (although the alternate +are not available in traditional C mode (although the alternative keywords with leading underscores still are). .It Fl u Do not complain about functions and external variables used @@ -248,13 +313,16 @@ on a subset of files comprising part of a larger program). .It Fl v Suppress complaints about unused arguments in functions. .It Fl x -Report variables refferd to by +Report variables referred to by .Sy extern declarations, but never used. .It Fl z Do not complain about structures that are never defined (for example, using a structure pointer without knowing its contents). +.It Fl B Ns Ar path +Path to use when looking for the lint1 and lint2 binaries. Defualts to +.Pa /usr/libexec . .It Fl C Ns Ar library Create a .Nm @@ -284,6 +352,10 @@ is defined as 1. Add .Ar directory to the list of directories in which to search for include files. +.It Fl d Ns Ar directory +Use +.Ar directory +instead of /usr/include as the default place to find include files. .It Fl l Ns Ar library Include the lint library .Pa llib-l Ns Ar library Ns Pa \&.ln . @@ -306,7 +378,7 @@ followed by a question mark. Name the output file .Ar outputfile . The output file produced is the input that is given to -.Nm lint Ns 's +.Nm "" Ns 's second pass. The .Fl o option simply saves this file in the named output file. If the @@ -327,13 +399,19 @@ for the preprocessor. .It Fl V Print the command lines constructed by the controller program to run the C preprocessor and -.Nm lint Ns 's +.Nm "" Ns 's first and second pass. +.It Fl w +Treat warnings as errors. +.It Fl X Ar id Ns Op ,id ... +Suppress error messages identified by the list of ids. A list of messages +and ids can be found in +.Xr lint 7 . .El .Pp .Sy Input Grammar .Pp -.Nm lint Ns 's +.Nm "" Ns 's first pass reads standard C source files. .Nm recognizes the following C comments as commands. @@ -348,6 +426,9 @@ arguments for usage; a missing is taken to be 0 (this option acts like the .Fl v option for the next function). +.It Li /* BITFIELDTYPE */ +Suppress error messages about illegal bitfield types if the type +is an integer type, and suppress non-portable bitfield type warnings. .It Li /* CONSTCOND */ No or Xo .Li /* CONSTANTCOND */ No or .Li /* CONSTANTCONDITION */ @@ -376,14 +457,14 @@ Also shut off complaints about unused function arguments. .Xc Suppresses any intra-file warning except those dealing with unused variables or functions. This directive should be placed -on the line immediately preceding where the lint warning occured. +on the line immediately preceding where the lint warning occurred. .It Li /* LONGLONG */ Suppress complaints about use of long long integer types. .It Li /* NOTREACHED */ At appropriate points, inhibit complaints about unreachable code. (This comment is typically placed just after calls to functions like -.Xr exit 2 ). +.Xr exit 3 ) . .It Li /* PRINTFLIKE Ns Ar n Li */ makes .Nm @@ -442,7 +523,7 @@ file that corresponds to the file, and prints all messages that are about just that source file. After all the source files have been separetely run through -.Nm lint , +.Nm "" , it is invoked once more (without the .Fl i option), listing all the @@ -458,7 +539,7 @@ to be used to .Nm only the source files that have been modified since the last time the set of source files were -.Nm lint Ns No ed . +.Nm "" Ns No ed . .Sh ENVIRONMENT .Bl -tag -width Fl .It Ev LIBDIR @@ -471,6 +552,9 @@ will be used to search for the libraries. .It Ev TMPDIR usually the path for temporary files can be redefined by setting this environment variable. +.It Ev CC +Location of the C compiler program. Defaults to +.Pa /usr/bin/cc . .El .Sh FILES .Bl -tag -width /usr/libdata/lint/llib-lc.ln -compact @@ -480,6 +564,7 @@ programs various prebuilt lint libraries .It Pa /tmp/lint* temporaries +.El .Sh SEE ALSO .Xr cc 1 , .Xr cpp 1 , @@ -488,7 +573,7 @@ temporaries Jochen Pohl .Sh BUGS The routines -.Xr exit 2 , +.Xr exit 3 , .Xr longjmp 3 and other functions that do not return are not understood; this causes various incorrect diagnostics. diff --git a/usr.bin/xlint/xlint/pathnames.h b/usr.bin/xlint/xlint/pathnames.h index d03845d..7e7a77b 100644 --- a/usr.bin/xlint/xlint/pathnames.h +++ b/usr.bin/xlint/xlint/pathnames.h @@ -1,4 +1,4 @@ -/* $NetBSD: pathnames.h,v 1.2 1995/07/03 21:25:20 cgd Exp $ */ +/* $NetBSD: pathnames.h,v 1.3 1999/04/22 04:40:58 mrg Exp $ */ /* * Copyright (c) 1994, 1995 Jochen Pohl @@ -32,7 +32,12 @@ */ /* directory where lint1 and lint2 reside */ +#ifndef PATH_LIBEXEC #define PATH_LIBEXEC "/usr/libexec" +#endif + +/* directory where cc(1) resides */ +#define PATH_USRBIN "/usr/bin" /* default library search path */ #define PATH_LINTLIB "/usr/libdata/lint" diff --git a/usr.bin/xlint/xlint/xlint.c b/usr.bin/xlint/xlint/xlint.c index 3e57797..bacf9c8 100644 --- a/usr.bin/xlint/xlint/xlint.c +++ b/usr.bin/xlint/xlint/xlint.c @@ -1,6 +1,7 @@ -/* $NetBSD: xlint.c,v 1.3 1995/10/23 14:29:30 jpo Exp $ */ +/* $NetBSD: xlint.c,v 1.26 2002/01/22 01:14:03 thorpej Exp $ */ /* + * Copyright (c) 1996 Christopher G. Demetriou. All Rights Reserved. * Copyright (c) 1994, 1995 Jochen Pohl * All Rights Reserved. * @@ -31,33 +32,38 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef lint -static char rcsid[] = "$NetBSD: xlint.c,v 1.3 1995/10/23 14:29:30 jpo Exp $"; +#include +#if defined(__RCSID) && !defined(lint) +__RCSID("$NetBSD: xlint.c,v 1.26 2002/01/22 01:14:03 thorpej Exp $"); #endif #include #include #include #include +#include +#include +#include +#include #include #include -#include #include #include -#include -#include -#include -#include #include "lint.h" #include "pathnames.h" +int main(int, char *[]); + /* directory for temporary files */ static const char *tmpdir; /* path name for cpp output */ static char *cppout; +/* file descriptor for cpp output */ +static int cppoutfd = -1; + /* files created by 1st pass */ static char **p1out; @@ -67,11 +73,11 @@ static char **p2in; /* library which will be created by 2nd pass */ static char *p2out; -/* flags always passed to cpp */ -static char **cppflags; +/* flags always passed to cc(1) */ +static char **cflags; -/* flags for cpp, controled by sflag/tflag */ -static char **lcppflgs; +/* flags for cc(1), controled by sflag/tflag */ +static char **lcflags; /* flags for lint1 */ static char **l1flags; @@ -91,8 +97,10 @@ static char **libs; /* search path for libraries */ static char **libsrchpath; +static char *libexec_path; + /* flags */ -static int iflag, oflag, Cflag, sflag, tflag, Fflag; +static int iflag, oflag, Cflag, sflag, tflag, Fflag, dflag, Bflag; /* print the commands executed to run the stages of compilation */ static int Vflag; @@ -109,80 +117,80 @@ static int first = 1; */ static const char *currfn; - -static void appstrg __P((char ***, char *)); -static void appcstrg __P((char ***, const char *)); -static void applst __P((char ***, char *const *)); -static void freelst __P((char ***)); -static char *concat2 __P((const char *, const char *)); -static char *concat3 __P((const char *, const char *, const char *)); -static void terminate __P((int)); -static const char *basename __P((const char *, int)); -static void appdef __P((char ***, const char *)); -static void usage __P((void)); -static void fname __P((const char *, int)); -static void runchild __P((const char *, char *const *, const char *)); -static void findlibs __P((char *const *)); -static int rdok __P((const char *)); -static void lint2 __P((void)); -static void cat __P((char *const *, const char *)); +#if !defined(TARGET_PREFIX) +#define TARGET_PREFIX "" +#endif +static const char target_prefix[] = TARGET_PREFIX; + +static void appstrg(char ***, char *); +static void appcstrg(char ***, const char *); +static void applst(char ***, char *const *); +static void freelst(char ***); +static char *concat2(const char *, const char *); +static char *concat3(const char *, const char *, const char *); +static void terminate(int) __attribute__((__noreturn__)); +static const char *lbasename(const char *, int); +static void appdef(char ***, const char *); +static void usage(void); +static void fname(const char *); +static void runchild(const char *, char *const *, const char *, int); +static void findlibs(char *const *); +static int rdok(const char *); +static void lint2(void); +static void cat(char *const *, const char *); /* * Some functions to deal with lists of strings. * Take care that we get no surprises in case of asyncron signals. */ static void -appstrg(lstp, s) - char ***lstp, *s; +appstrg(char ***lstp, char *s) { char **lst, **olst; int i; olst = *lstp; - for (i = 0; olst[i] != NULL; i++) ; - lst = xmalloc((i + 2) * sizeof (char *)); - (void)memcpy(lst, olst, i * sizeof (char *)); + for (i = 0; olst[i] != NULL; i++) + continue; + lst = xrealloc(olst, (i + 2) * sizeof (char *)); lst[i] = s; lst[i + 1] = NULL; *lstp = lst; -} +} static void -appcstrg(lstp, s) - char ***lstp; - const char *s; +appcstrg(char ***lstp, const char *s) { + appstrg(lstp, xstrdup(s)); } static void -applst(destp, src) - char ***destp; - char *const *src; +applst(char ***destp, char *const *src) { int i, k; char **dest, **odest; odest = *destp; - for (i = 0; odest[i] != NULL; i++) ; - for (k = 0; src[k] != NULL; k++) ; - dest = xmalloc((i + k + 1) * sizeof (char *)); - (void)memcpy(dest, odest, i * sizeof (char *)); + for (i = 0; odest[i] != NULL; i++) + continue; + for (k = 0; src[k] != NULL; k++) + continue; + dest = xrealloc(odest, (i + k + 1) * sizeof (char *)); for (k = 0; src[k] != NULL; k++) dest[i + k] = xstrdup(src[k]); dest[i + k] = NULL; *destp = dest; - free(odest); } static void -freelst(lstp) - char ***lstp; +freelst(char ***lstp) { char *s; int i; - for (i = 0; (*lstp)[i] != NULL; i++) ; + for (i = 0; (*lstp)[i] != NULL; i++) + continue; while (i-- > 0) { s = (*lstp)[i]; (*lstp)[i] = NULL; @@ -191,8 +199,7 @@ freelst(lstp) } static char * -concat2(s1, s2) - const char *s1, *s2; +concat2(const char *s1, const char *s2) { char *s; @@ -204,8 +211,7 @@ concat2(s1, s2) } static char * -concat3(s1, s2, s3) - const char *s1, *s2, *s3; +concat3(const char *s1, const char *s2, const char *s3) { char *s; @@ -221,11 +227,12 @@ concat3(s1, s2, s3) * Clean up after a signal. */ static void -terminate(signo) - int signo; +terminate(int signo) { int i; + if (cppoutfd != -1) + (void)close(cppoutfd); if (cppout != NULL) (void)remove(cppout); @@ -248,9 +255,7 @@ terminate(signo) * Returns strg if the string does not contain delim. */ static const char * -basename(strg, delim) - const char *strg; - int delim; +lbasename(const char *strg, int delim) { const char *cp, *cp1, *cp2; @@ -265,34 +270,40 @@ basename(strg, delim) } static void -appdef(lstp, def) - char ***lstp; - const char *def; +appdef(char ***lstp, const char *def) { + appstrg(lstp, concat2("-D__", def)); appstrg(lstp, concat3("-D__", def, "__")); } static void -usage() +usage(void) { - (void)printf("lint [-abceghprvxzHF] [-s|-t] [-i|-nu] [-Dname[=def]] [-Uname]\n"); - (void)printf(" [-Idirectory] [-Ldirectory] [-llibrary] [-ooutputfile] file ...\n"); - (void)printf("\n"); - (void)printf("lint [-abceghprvzHF] [-s|-t] -Clibrary [-Dname[=def]]\n"); - (void)printf(" [-Idirectory] [-Uname] file ...\n"); + + (void)fprintf(stderr, + "Usage: %s [-abceghprvwxzHF] [-s|-t] [-i|-nu] [-Dname[=def]]" + " [-Uname] [-X [,]...\n", getprogname()); + (void)fprintf(stderr, + "\t[-Idirectory] [-Ldirectory] [-llibrary] [-ooutputfile]" + " file...\n"); + (void)fprintf(stderr, + " %s [-abceghprvwzHF] [-s|-t] -Clibrary [-Dname[=def]]\n" + " [-X [,]...\n", getprogname()); + (void)fprintf(stderr, "\t[-Idirectory] [-Uname] [-Bpath] file" + " ...\n"); terminate(-1); } + int -main(argc, argv) - int argc; - char *argv[]; +main(int argc, char *argv[]) { int c; char flgbuf[3], *tmp, *s; size_t len; - struct utsname un; + + setprogname(argv[0]); if ((tmp = getenv("TMPDIR")) == NULL || (len = strlen(tmp)) == 0) { tmpdir = xstrdup(_PATH_TMP); @@ -304,15 +315,16 @@ main(argc, argv) cppout = xmalloc(strlen(tmpdir) + sizeof ("lint0.XXXXXX")); (void)sprintf(cppout, "%slint0.XXXXXX", tmpdir); - if (mktemp(cppout) == NULL) { + cppoutfd = mkstemp(cppout); + if (cppoutfd == -1) { warn("can't make temp"); terminate(-1); } p1out = xcalloc(1, sizeof (char *)); p2in = xcalloc(1, sizeof (char *)); - cppflags = xcalloc(1, sizeof (char *)); - lcppflgs = xcalloc(1, sizeof (char *)); + cflags = xcalloc(1, sizeof (char *)); + lcflags = xcalloc(1, sizeof (char *)); l1flags = xcalloc(1, sizeof (char *)); l2flags = xcalloc(1, sizeof (char *)); l2libs = xcalloc(1, sizeof (char *)); @@ -320,30 +332,25 @@ main(argc, argv) libs = xcalloc(1, sizeof (char *)); libsrchpath = xcalloc(1, sizeof (char *)); - appcstrg(&cppflags, "-lang-c"); - appcstrg(&cppflags, "-undef"); - appcstrg(&cppflags, "-$"); - appcstrg(&cppflags, "-C"); - appcstrg(&cppflags, "-Wcomment"); - appcstrg(&cppflags, "-D__NetBSD__"); - appcstrg(&cppflags, "-Dlint"); /* XXX don't def. with -s */ - appdef(&cppflags, "lint"); - appdef(&cppflags, "unix"); - - appcstrg(&lcppflgs, "-Wtraditional"); - - if (uname(&un) == -1) - err(1, "uname"); - appdef(&cppflags, un.machine); - appstrg(&lcppflgs, concat2("-D", un.machine)); - -#ifdef MACHINE_ARCH - if (strcmp(un.machine, MACHINE_ARCH) != 0) { - appdef(&cppflags, MACHINE_ARCH); - appstrg(&lcppflgs, concat2("-D", MACHINE_ARCH)); - } + appcstrg(&cflags, "-E"); + appcstrg(&cflags, "-x"); + appcstrg(&cflags, "c"); +#if 0 + appcstrg(&cflags, "-D__attribute__(x)="); + appcstrg(&cflags, "-D__extension__(x)=/*NOSTRICT*/0"); +#else + appcstrg(&cflags, "-U__GNUC__"); #endif - + appcstrg(&cflags, "-Wp,-$"); + appcstrg(&cflags, "-Wp,-CC"); + appcstrg(&cflags, "-Wcomment"); + appcstrg(&cflags, "-D__LINT__"); + appcstrg(&cflags, "-Dlint"); /* XXX don't def. with -s */ + + appdef(&cflags, "lint"); + + appcstrg(&lcflags, "-Wtraditional"); + appcstrg(&deflibs, "c"); if (signal(SIGHUP, terminate) == SIG_IGN) @@ -352,14 +359,7 @@ main(argc, argv) (void)signal(SIGQUIT, terminate); (void)signal(SIGTERM, terminate); - while (argc > optind) { - - argc -= optind; - argv += optind; - optind = 0; - - c = getopt(argc, argv, "abceghil:no:prstuvxzC:D:FHI:L:U:V"); - + while ((c = getopt(argc, argv, "abcd:eghil:no:prstuvwxzB:C:D:FHI:L:U:VX:")) != -1) { switch (c) { case 'a': @@ -369,6 +369,7 @@ main(argc, argv) case 'g': case 'r': case 'v': + case 'w': case 'z': (void)sprintf(flgbuf, "-%c", c); appcstrg(&l1flags, flgbuf); @@ -384,6 +385,12 @@ main(argc, argv) appcstrg(&l2flags, flgbuf); break; + case 'X': + (void)sprintf(flgbuf, "-%c", c); + appcstrg(&l1flags, flgbuf); + appcstrg(&l1flags, optarg); + break; + case 'i': if (Cflag) usage(); @@ -406,27 +413,29 @@ main(argc, argv) case 's': if (tflag) usage(); - freelst(&lcppflgs); - appcstrg(&lcppflgs, "-trigraphs"); - appcstrg(&lcppflgs, "-Wtrigraphs"); - appcstrg(&lcppflgs, "-pedantic"); - appcstrg(&lcppflgs, "-D__STRICT_ANSI__"); + freelst(&lcflags); + appcstrg(&lcflags, "-trigraphs"); + appcstrg(&lcflags, "-Wtrigraphs"); + appcstrg(&lcflags, "-pedantic"); + appcstrg(&lcflags, "-D__STRICT_ANSI__"); appcstrg(&l1flags, "-s"); appcstrg(&l2flags, "-s"); sflag = 1; break; +#if !HAVE_CONFIG_H case 't': if (sflag) usage(); - freelst(&lcppflgs); - appcstrg(&lcppflgs, "-traditional"); - appstrg(&lcppflgs, concat2("-D", MACHINE)); - appstrg(&lcppflgs, concat2("-D", MACHINE_ARCH)); + freelst(&lcflags); + appcstrg(&lcflags, "-traditional"); + appstrg(&lcflags, concat2("-D", MACHINE)); + appstrg(&lcflags, concat2("-D", MACHINE_ARCH)); appcstrg(&l1flags, "-t"); appcstrg(&l2flags, "-t"); tflag = 1; break; +#endif case 'x': appcstrg(&l2flags, "-x"); @@ -442,11 +451,20 @@ main(argc, argv) freelst(&deflibs); break; + case 'd': + if (dflag) + usage(); + dflag = 1; + appcstrg(&cflags, "-nostdinc"); + appcstrg(&cflags, "-idirafter"); + appcstrg(&cflags, optarg); + break; + case 'D': case 'I': case 'U': (void)sprintf(flgbuf, "-%c", c); - appstrg(&cppflags, concat2(flgbuf, optarg)); + appstrg(&cflags, concat2(flgbuf, optarg)); break; case 'l': @@ -468,21 +486,64 @@ main(argc, argv) appcstrg(&l2flags, "-H"); break; + case 'B': + Bflag = 1; + libexec_path = xstrdup(optarg); + break; + case 'V': Vflag = 1; break; - case '?': + default: usage(); /* NOTREACHED */ + } + } + argc -= optind; + argv += optind; + + /* + * To avoid modifying getopt(3)'s state engine midstream, we + * explicitly accept just a few options after the first source file. + * + * In particular, only -l and -L (and these with a space + * after -l or -L) are allowed. + */ + while (argc > 0) { + const char *arg = argv[0]; + + if (arg[0] == '-') { + char ***list; + + /* option */ + switch (arg[1]) { + case 'l': + list = &libs; + break; + + case 'L': + list = &libsrchpath; + break; - case -1: + default: + usage(); + /* NOTREACHED */ + } + if (arg[2]) + appcstrg(list, arg + 2); + else if (argc > 1) { + argc--; + appcstrg(list, *++argv); + } else + usage(); + } else { /* filename */ - fname(argv[0], argc == 1); + fname(arg); first = 0; - optind = 1; } - + argc--; + argv++; } if (first) @@ -517,16 +578,17 @@ main(argc, argv) * and pass it through lint1 if it is a C source. */ static void -fname(name, last) - const char *name; - int last; +fname(const char *name) { const char *bn, *suff; char **args, *ofn, *path; size_t len; + int is_stdin; + int fd; - bn = basename(name, '/'); - suff = basename(bn, '.'); + is_stdin = (strcmp(name, "-") == 0); + bn = lbasename(name, '/'); + suff = lbasename(bn, '.'); if (strcmp(suff, "ln") == 0) { /* only for lint2 */ @@ -535,14 +597,15 @@ fname(name, last) return; } - if (strcmp(suff, "c") != 0 && + if (!is_stdin && strcmp(suff, "c") != 0 && (strncmp(bn, "llib-l", 6) != 0 || bn != suff)) { warnx("unknown file type: %s\n", name); return; } - if (!iflag || !first || !last) - (void)printf("%s:\n", Fflag ? name : bn); + if (!iflag || !first) + (void)printf("%s:\n", + is_stdin ? "{standard input}" : Fflag ? name : bn); /* build the name of the output file of lint1 */ if (oflag) { @@ -550,6 +613,10 @@ fname(name, last) outputfn = NULL; oflag = 0; } else if (iflag) { + if (is_stdin) { + warnx("-i not supported without -o for standard input"); + return; + } ofn = xmalloc(strlen(bn) + (bn == suff ? 4 : 2)); len = bn == suff ? strlen(bn) : (suff - 1) - bn; (void)sprintf(ofn, "%.*s", (int)len, bn); @@ -557,42 +624,68 @@ fname(name, last) } else { ofn = xmalloc(strlen(tmpdir) + sizeof ("lint1.XXXXXX")); (void)sprintf(ofn, "%slint1.XXXXXX", tmpdir); - if (mktemp(ofn) == NULL) { + fd = mkstemp(ofn); + if (fd == -1) { warn("can't make temp"); terminate(-1); } + close(fd); } if (!iflag) appcstrg(&p1out, ofn); args = xcalloc(1, sizeof (char *)); - /* run cpp */ + /* run cc */ - path = xmalloc(strlen(PATH_LIBEXEC) + sizeof ("/cpp")); - (void)sprintf(path, "%s/cpp", PATH_LIBEXEC); + if (getenv("CC") == NULL) { + path = xmalloc(strlen(PATH_USRBIN) + sizeof ("/cc")); + (void)sprintf(path, "%s/cc", PATH_USRBIN); + } else { + path = strdup(getenv("CC")); + } appcstrg(&args, path); - applst(&args, cppflags); - applst(&args, lcppflgs); + applst(&args, cflags); + applst(&args, lcflags); appcstrg(&args, name); - appcstrg(&args, cppout); - runchild(path, args, cppout); + /* we reuse the same tmp file for cpp output, so rewind and truncate */ + if (lseek(cppoutfd, SEEK_SET, (off_t)0) != 0) { + warn("lseek"); + terminate(-1); + } + if (ftruncate(cppoutfd, (off_t)0) != 0) { + warn("ftruncate"); + terminate(-1); + } + + runchild(path, args, cppout, cppoutfd); free(path); freelst(&args); /* run lint1 */ - path = xmalloc(strlen(PATH_LIBEXEC) + sizeof ("/lint1")); - (void)sprintf(path, "%s/lint1", PATH_LIBEXEC); + if (!Bflag) { + path = xmalloc(strlen(PATH_LIBEXEC) + sizeof ("/lint1") + + strlen(target_prefix)); + (void)sprintf(path, "%s/%slint1", PATH_LIBEXEC, + target_prefix); + } else { + /* + * XXX Unclear whether we should be using target_prefix + * XXX here. --thorpej@wasabisystems.com + */ + path = xmalloc(strlen(libexec_path) + sizeof ("/lint1")); + (void)sprintf(path, "%s/lint1", libexec_path); + } appcstrg(&args, path); applst(&args, l1flags); appcstrg(&args, cppout); appcstrg(&args, ofn); - runchild(path, args, ofn); + runchild(path, args, ofn, -1); free(path); freelst(&args); @@ -603,9 +696,7 @@ fname(name, last) } static void -runchild(path, args, crfn) - const char *path, *crfn; - char *const *args; +runchild(const char *path, char *const *args, const char *crfn, int fdout) { int status, rv, signo, i; @@ -619,7 +710,7 @@ runchild(path, args, crfn) (void)fflush(stdout); - switch (fork()) { + switch (vfork()) { case -1: warn("cannot fork"); terminate(-1); @@ -629,9 +720,15 @@ runchild(path, args, crfn) break; case 0: /* child */ - (void)execv(path, args); + + /* setup the standard output if necessary */ + if (fdout != -1) { + dup2(fdout, STDOUT_FILENO); + close(fdout); + } + (void)execvp(path, args); warn("cannot exec %s", path); - exit(1); + _exit(1); /* NOTREACHED */ } @@ -642,7 +739,11 @@ runchild(path, args, crfn) } if (WIFSIGNALED(status)) { signo = WTERMSIG(status); +#if HAVE_DECL_SYS_SIGNAME warnx("%s got SIG%s", path, sys_signame[signo]); +#else + warnx("%s got signal %d", path, signo); +#endif terminate(-1); } if (WEXITSTATUS(status) != 0) @@ -651,8 +752,7 @@ runchild(path, args, crfn) } static void -findlibs(liblst) - char *const *liblst; +findlibs(char *const *liblst) { int i, k; const char *lib, *path; @@ -684,14 +784,13 @@ findlibs(liblst) } static int -rdok(path) - const char *path; +rdok(const char *path) { struct stat sbuf; if (stat(path, &sbuf) == -1) return (0); - if ((sbuf.st_mode & S_IFMT) != S_IFREG) + if (!S_ISREG(sbuf.st_mode)) return (0); if (access(path, R_OK) == -1) return (0); @@ -699,30 +798,39 @@ rdok(path) } static void -lint2() +lint2(void) { char *path, **args; args = xcalloc(1, sizeof (char *)); - path = xmalloc(strlen(PATH_LIBEXEC) + sizeof ("/lint2")); - (void)sprintf(path, "%s/lint2", PATH_LIBEXEC); - + if (!Bflag) { + path = xmalloc(strlen(PATH_LIBEXEC) + sizeof ("/lint2") + + strlen(target_prefix)); + (void)sprintf(path, "%s/%slint2", PATH_LIBEXEC, + target_prefix); + } else { + /* + * XXX Unclear whether we should be using target_prefix + * XXX here. --thorpej@wasabisystems.com + */ + path = xmalloc(strlen(libexec_path) + sizeof ("/lint2")); + (void)sprintf(path, "%s/lint2", libexec_path); + } + appcstrg(&args, path); applst(&args, l2flags); applst(&args, l2libs); applst(&args, p2in); - runchild(path, args, p2out); + runchild(path, args, p2out, -1); free(path); freelst(&args); free(args); } static void -cat(srcs, dest) - char *const *srcs; - const char *dest; +cat(char *const *srcs, const char *dest) { int ifd, ofd, i; char *src, *buf; @@ -758,4 +866,3 @@ cat(srcs, dest) (void)close(ofd); free(buf); } - -- cgit v1.1