Home | History | Annotate | Line # | Download | only in lint1
lex.c revision 1.7
      1  1.7    rillig /* $NetBSD: lex.c,v 1.7 2021/01/24 09:44:35 rillig Exp $ */
      2  1.1    rillig 
      3  1.1    rillig /*
      4  1.1    rillig  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
      5  1.1    rillig  * Copyright (c) 1994, 1995 Jochen Pohl
      6  1.1    rillig  * All Rights Reserved.
      7  1.1    rillig  *
      8  1.1    rillig  * Redistribution and use in source and binary forms, with or without
      9  1.1    rillig  * modification, are permitted provided that the following conditions
     10  1.1    rillig  * are met:
     11  1.1    rillig  * 1. Redistributions of source code must retain the above copyright
     12  1.1    rillig  *    notice, this list of conditions and the following disclaimer.
     13  1.1    rillig  * 2. Redistributions in binary form must reproduce the above copyright
     14  1.1    rillig  *    notice, this list of conditions and the following disclaimer in the
     15  1.1    rillig  *    documentation and/or other materials provided with the distribution.
     16  1.1    rillig  * 3. All advertising materials mentioning features or use of this software
     17  1.1    rillig  *    must display the following acknowledgement:
     18  1.1    rillig  *      This product includes software developed by Jochen Pohl for
     19  1.1    rillig  *      The NetBSD Project.
     20  1.1    rillig  * 4. The name of the author may not be used to endorse or promote products
     21  1.1    rillig  *    derived from this software without specific prior written permission.
     22  1.1    rillig  *
     23  1.1    rillig  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     24  1.1    rillig  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     25  1.1    rillig  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     26  1.1    rillig  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     27  1.1    rillig  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     28  1.1    rillig  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     29  1.1    rillig  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     30  1.1    rillig  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     31  1.1    rillig  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     32  1.1    rillig  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     33  1.1    rillig  */
     34  1.1    rillig 
     35  1.4  christos #if HAVE_NBTOOL_CONFIG_H
     36  1.4  christos #include "nbtool_config.h"
     37  1.4  christos #endif
     38  1.4  christos 
     39  1.1    rillig #include <sys/cdefs.h>
     40  1.1    rillig #if defined(__RCSID) && !defined(lint)
     41  1.7    rillig __RCSID("$NetBSD: lex.c,v 1.7 2021/01/24 09:44:35 rillig Exp $");
     42  1.1    rillig #endif
     43  1.1    rillig 
     44  1.1    rillig #include <ctype.h>
     45  1.1    rillig #include <errno.h>
     46  1.1    rillig #include <float.h>
     47  1.1    rillig #include <limits.h>
     48  1.1    rillig #include <math.h>
     49  1.1    rillig #include <stdlib.h>
     50  1.1    rillig #include <string.h>
     51  1.1    rillig 
     52  1.1    rillig #include "lint1.h"
     53  1.1    rillig #include "cgram.h"
     54  1.1    rillig 
     55  1.1    rillig #define CHAR_MASK	((int)(~(~0U << CHAR_SIZE)))
     56  1.1    rillig 
     57  1.1    rillig 
     58  1.1    rillig /* Current position (it's also updated when an included file is parsed) */
     59  1.1    rillig pos_t	curr_pos = { 1, "", 0 };
     60  1.1    rillig 
     61  1.1    rillig /*
     62  1.1    rillig  * Current position in C source (not updated when an included file is
     63  1.1    rillig  * parsed).
     64  1.1    rillig  */
     65  1.1    rillig pos_t	csrc_pos = { 1, "", 0 };
     66  1.1    rillig 
     67  1.1    rillig /* Are we parsing a gcc attribute? */
     68  1.1    rillig bool attron;
     69  1.1    rillig 
     70  1.1    rillig bool in_system_header = false;
     71  1.1    rillig 
     72  1.1    rillig static	sbuf_t *allocsb(void);
     73  1.1    rillig static	void	freesb(sbuf_t *);
     74  1.1    rillig static	int	inpc(void);
     75  1.1    rillig static	int	hash(const char *);
     76  1.1    rillig static	sym_t *	search(sbuf_t *);
     77  1.1    rillig static	int	keyw(sym_t *);
     78  1.6    rillig static	int	get_escaped_char(int);
     79  1.1    rillig 
     80  1.1    rillig void
     81  1.6    rillig lex_next_line(void)
     82  1.1    rillig {
     83  1.1    rillig 	curr_pos.p_line++;
     84  1.1    rillig 	curr_pos.p_uniq = 0;
     85  1.1    rillig #ifdef DEBUG
     86  1.1    rillig 	printf("parsing %s:%d\n", curr_pos.p_file, curr_pos.p_line);
     87  1.1    rillig #endif
     88  1.1    rillig 	if (curr_pos.p_file == csrc_pos.p_file) {
     89  1.1    rillig 		csrc_pos.p_line++;
     90  1.1    rillig 		csrc_pos.p_uniq = 0;
     91  1.1    rillig 	}
     92  1.1    rillig }
     93  1.1    rillig 
     94  1.1    rillig void
     95  1.6    rillig lex_unknown_character(int c)
     96  1.1    rillig {
     97  1.1    rillig 
     98  1.1    rillig 	/* unknown character \%o */
     99  1.1    rillig 	error(250, c);
    100  1.1    rillig }
    101  1.1    rillig 
    102  1.1    rillig /*
    103  1.1    rillig  * Keywords.
    104  1.1    rillig  * During initialisation they are written to the symbol table.
    105  1.1    rillig  */
    106  1.1    rillig static	struct	kwtab {
    107  1.1    rillig 	const	char *kw_name;	/* keyword */
    108  1.1    rillig 	int	kw_token;	/* token returned by yylex() */
    109  1.1    rillig 	scl_t	kw_scl;		/* storage class if kw_token T_SCLASS */
    110  1.1    rillig 	tspec_t	kw_tspec;	/* type spec. if kw_token
    111  1.1    rillig 				 * T_TYPE or T_STRUCT_OR_UNION */
    112  1.1    rillig 	tqual_t	kw_tqual;	/* type qual. fi kw_token T_QUAL */
    113  1.1    rillig 	bool	kw_c89 : 1;	/* C89 keyword */
    114  1.1    rillig 	bool	kw_c99 : 1;	/* C99 keyword */
    115  1.1    rillig 	bool	kw_gcc : 1;	/* GCC keyword */
    116  1.1    rillig 	bool	kw_attr : 1;	/* GCC attribute, keyword */
    117  1.1    rillig 	u_int	kw_deco : 3;	/* 1 = name, 2 = __name, 4 = __name__ */
    118  1.1    rillig } kwtab[] = {
    119  1.1    rillig #ifdef INT128_SIZE
    120  1.1    rillig 	{ "__int128_t",	T_TYPE,		0,	INT128,	0,	  0,1,0,0,1 },
    121  1.1    rillig 	{ "__uint128_t",T_TYPE,		0,	UINT128,0,	  0,1,0,0,1 },
    122  1.1    rillig #endif
    123  1.1    rillig 	{ "__thread",	T_QUAL,		0,	0,	THREAD,	  0,0,1,0,1 },
    124  1.1    rillig 	{ "_Alignof",	T_ALIGNOF,	0,	0,	0,	  0,0,0,0,1 },
    125  1.1    rillig 	{ "_Bool",	T_TYPE,		0,	BOOL,	0,	  0,1,0,0,1 },
    126  1.1    rillig 	{ "_Complex",	T_TYPE,		0,	COMPLEX,0,	  0,1,0,0,1 },
    127  1.1    rillig 	{ "_Generic",	T_GENERIC,	0,	0,	0,	  0,1,0,0,1 },
    128  1.1    rillig 	{ "_Noreturn",	T_NORETURN,	0,	0,	0,	  0,1,0,0,1 },
    129  1.1    rillig 	{ "_Thread_local",T_QUAL,	0,	0,	THREAD,	  0,1,0,0,1 },
    130  1.1    rillig 	{ "alias",	T_AT_ALIAS,	0,	0,	0,	  0,0,1,1,5 },
    131  1.1    rillig 	{ "aligned",	T_AT_ALIGNED,	0,	0,	0,	  0,0,1,1,5 },
    132  1.1    rillig 	{ "alignof",	T_ALIGNOF,	0,	0,	0,	  0,0,0,0,4 },
    133  1.1    rillig 	{ "alloc_size",	T_AT_ALLOC_SIZE,0,	0,	0,	  0,0,1,1,5 },
    134  1.1    rillig 	{ "always_inline", T_AT_ALWAYS_INLINE, 0,0,	0,	  0,0,1,1,5 },
    135  1.1    rillig 	{ "asm",	T_ASM,		0,	0,	0,	  0,0,1,0,7 },
    136  1.1    rillig 	{ "attribute",	T_ATTRIBUTE,	0,	0,	0,	  0,0,1,0,6 },
    137  1.1    rillig 	{ "auto",	T_SCLASS,	AUTO,	0,	0,	  0,0,0,0,1 },
    138  1.1    rillig 	{ "bounded",	T_AT_BOUNDED,	0,	0,	0,	  0,0,1,1,5 },
    139  1.1    rillig 	{ "break",	T_BREAK,	0,	0,	0,	  0,0,0,0,1 },
    140  1.1    rillig 	{ "buffer",	T_AT_BUFFER,	0,	0,	0,	  0,0,1,1,5 },
    141  1.1    rillig 	{ "builtin_offsetof", T_BUILTIN_OFFSETOF, 0, 0, 0,	  0,0,1,0,2 },
    142  1.1    rillig 	{ "case",	T_CASE,		0,	0,	0,	  0,0,0,0,1 },
    143  1.1    rillig 	{ "char",	T_TYPE,		0,	CHAR,	0,	  0,0,0,0,1 },
    144  1.1    rillig 	{ "cold",	T_AT_COLD,	0,	0,	0,	  0,0,1,1,5 },
    145  1.1    rillig 	{ "const",	T_QUAL,		0,	0,	CONST,	  1,0,0,0,7 },
    146  1.1    rillig 	{ "constructor",T_AT_CONSTRUCTOR,0,	0,	0,	  0,0,1,1,5 },
    147  1.1    rillig 	{ "continue",	T_CONTINUE,	0,	0,	0,	  0,0,0,0,1 },
    148  1.1    rillig 	{ "default",	T_DEFAULT,	0,	0,	0,	  0,0,0,0,1 },
    149  1.1    rillig 	{ "deprecated",	T_AT_DEPRECATED,0,	0,	0,	  0,0,1,1,5 },
    150  1.1    rillig 	{ "destructor",	T_AT_DESTRUCTOR,0,	0,	0,	  0,0,1,1,5 },
    151  1.1    rillig 	{ "do",		T_DO,		0,	0,	0,	  0,0,0,0,1 },
    152  1.1    rillig 	{ "double",	T_TYPE,		0,	DOUBLE,	0,	  0,0,0,0,1 },
    153  1.1    rillig 	{ "else",	T_ELSE,		0,	0,	0,	  0,0,0,0,1 },
    154  1.1    rillig 	{ "enum",	T_ENUM,		0,	0,	0,	  0,0,0,0,1 },
    155  1.1    rillig 	{ "extension",  T_EXTENSION,	0,	0,	0,	  0,0,1,0,4 },
    156  1.1    rillig 	{ "extern",	T_SCLASS,	EXTERN,	0,	0,	  0,0,0,0,1 },
    157  1.1    rillig 	{ "float",	T_TYPE,		0,	FLOAT,	0,	  0,0,0,0,1 },
    158  1.1    rillig 	{ "for",	T_FOR,		0,	0,	0,	  0,0,0,0,1 },
    159  1.1    rillig 	{ "format",	T_AT_FORMAT,	0,	0,	0,	  0,0,1,1,5 },
    160  1.1    rillig 	{ "format_arg", T_AT_FORMAT_ARG,0,	0,	0,	  0,0,1,1,5 },
    161  1.1    rillig 	{ "gnu_inline",	T_AT_GNU_INLINE,0,	0,	0,	  0,0,1,1,5 },
    162  1.1    rillig 	{ "gnu_printf",	T_AT_FORMAT_GNU_PRINTF,0,0,	0,	  0,0,1,1,5 },
    163  1.1    rillig 	{ "goto",	T_GOTO,		0,	0,	0,	  0,0,0,0,1 },
    164  1.1    rillig 	{ "if",		T_IF,		0,	0,	0,	  0,0,0,0,1 },
    165  1.1    rillig 	{ "imag",	T_IMAG,		0,	0,	0,	  0,1,0,0,4 },
    166  1.1    rillig 	{ "inline",	T_SCLASS,	INLINE,	0,	0,	  0,1,0,0,7 },
    167  1.1    rillig 	{ "int",	T_TYPE,		0,	INT,	0,	  0,0,0,0,1 },
    168  1.1    rillig 	{ "long",	T_TYPE,		0,	LONG,	0,	  0,0,0,0,1 },
    169  1.1    rillig 	{ "malloc",	T_AT_MALLOC,	0,	0,	0,	  0,0,1,1,5 },
    170  1.1    rillig 	{ "may_alias",	T_AT_MAY_ALIAS,	0,	0,	0,	  0,0,1,1,5 },
    171  1.1    rillig 	{ "minbytes",	T_AT_MINBYTES,	0,	0,	0,	  0,0,1,1,5 },
    172  1.1    rillig 	{ "mode",	T_AT_MODE,	0,	0,	0,	  0,0,1,1,5 },
    173  1.1    rillig 	{ "no_instrument_function", T_AT_NO_INSTRUMENT_FUNCTION,
    174  1.1    rillig 					0,	0,	0,	  0,0,1,1,5 },
    175  1.1    rillig 	{ "nonnull",	T_AT_NONNULL,	0,	0,	0,	  0,0,1,1,5 },
    176  1.1    rillig 	{ "noinline",	T_AT_NOINLINE,	0,	0,	0,	  0,0,1,1,5 },
    177  1.1    rillig 	{ "noreturn",	T_AT_NORETURN,	0,	0,	0,	  0,0,1,1,5 },
    178  1.1    rillig 	{ "nothrow",	T_AT_NOTHROW,	0,	0,	0,	  0,0,1,1,5 },
    179  1.1    rillig 	{ "optimize",	T_AT_OPTIMIZE,	0,	0,	0,	  0,0,1,1,5 },
    180  1.1    rillig 	{ "packed",	T_AT_PACKED,	0,	0,	0,	  0,0,1,1,5 },
    181  1.1    rillig 	{ "packed",	T_PACKED,	0,	0,	0,	  0,0,0,0,2 },
    182  1.1    rillig 	{ "pcs",	T_AT_PCS,	0,	0,	0,	  0,0,0,0,5 },
    183  1.1    rillig 	{ "printf",	T_AT_FORMAT_PRINTF,0,	0,	0,	  0,0,1,1,5 },
    184  1.1    rillig 	{ "pure",	T_AT_PURE,	0,	0,	0,	  0,0,1,1,5 },
    185  1.1    rillig 	{ "real",	T_REAL,		0,	0,	0,	  0,1,0,0,4 },
    186  1.1    rillig 	{ "register",	T_SCLASS,	REG,	0,	0,	  0,0,0,0,1 },
    187  1.1    rillig 	{ "restrict",	T_QUAL,		0,	0,	RESTRICT, 0,1,0,0,5 },
    188  1.1    rillig 	{ "return",	T_RETURN,	0,	0,	0,	  0,0,0,0,1 },
    189  1.1    rillig 	{ "returns_twice", T_AT_RETURNS_TWICE,0,0,	0,	  0,0,1,1,5 },
    190  1.1    rillig 	{ "scanf",	T_AT_FORMAT_SCANF,0,	0,	0,	  0,0,1,1,5 },
    191  1.1    rillig 	{ "section",	T_AT_SECTION,	0,	0,	0,	  0,0,1,1,7 },
    192  1.1    rillig 	{ "sentinel",	T_AT_SENTINEL,	0,	0,	0,	  0,0,1,1,5 },
    193  1.1    rillig 	{ "short",	T_TYPE,		0,	SHORT,	0,	  0,0,0,0,1 },
    194  1.1    rillig 	{ "signed",	T_TYPE,		0,	SIGNED,	0,	  1,0,0,0,3 },
    195  1.1    rillig 	{ "sizeof",	T_SIZEOF,	0,	0,	0,	  0,0,0,0,1 },
    196  1.1    rillig 	{ "static",	T_SCLASS,	STATIC,	0,	0,	  0,0,0,0,1 },
    197  1.1    rillig 	{ "strfmon",	T_AT_FORMAT_STRFMON,0,	0,	0,	  0,0,1,1,5 },
    198  1.1    rillig 	{ "strftime",	T_AT_FORMAT_STRFTIME,0,	0,	0,	  0,0,1,1,5 },
    199  1.1    rillig 	{ "string",	T_AT_STRING,	0,	0,	0,	  0,0,1,1,5 },
    200  1.1    rillig 	{ "struct",	T_STRUCT_OR_UNION, 0,	STRUCT,	0,	  0,0,0,0,1 },
    201  1.1    rillig 	{ "switch",	T_SWITCH,	0,	0,	0,	  0,0,0,0,1 },
    202  1.1    rillig 	{ "symbolrename", T_SYMBOLRENAME,0,	0,	0,	  0,0,0,0,2 },
    203  1.1    rillig 	{ "syslog",	T_AT_FORMAT_SYSLOG,0,	0,	0,	  0,0,1,1,5 },
    204  1.1    rillig 	{ "transparent_union",T_AT_TUNION,0,	0,	0,	  0,0,1,1,5 },
    205  1.1    rillig 	{ "tls_model",	T_AT_TLS_MODEL,	0,	0,	0,	  0,0,1,1,5 },
    206  1.1    rillig 	{ "typedef",	T_SCLASS,	TYPEDEF, 0,	0,	  0,0,0,0,1 },
    207  1.1    rillig 	{ "typeof",	T_TYPEOF,	0,	0,	0,	  0,0,1,0,7 },
    208  1.1    rillig 	{ "union",	T_STRUCT_OR_UNION, 0,	UNION,	0,	  0,0,0,0,1 },
    209  1.1    rillig 	{ "unsigned",	T_TYPE,		0,	UNSIGN,	0,	  0,0,0,0,1 },
    210  1.1    rillig 	{ "unused",	T_AT_UNUSED,	0,	0,	0,	  0,0,1,1,5 },
    211  1.1    rillig 	{ "used",	T_AT_USED,	0,	0,	0,	  0,0,1,1,5 },
    212  1.1    rillig 	{ "visibility", T_AT_VISIBILITY,0,	0,	0,	  0,0,1,1,5 },
    213  1.1    rillig 	{ "void",	T_TYPE,		0,	VOID,	0,	  0,0,0,0,1 },
    214  1.1    rillig 	{ "volatile",	T_QUAL,		0,	0,	VOLATILE, 1,0,0,0,7 },
    215  1.1    rillig 	{ "warn_unused_result", T_AT_WARN_UNUSED_RESULT, 0, 0, 0, 0,0,1,1,5 },
    216  1.1    rillig 	{ "weak",	T_AT_WEAK,	0,	0,	0,	  0,0,1,1,5 },
    217  1.1    rillig 	{ "while",	T_WHILE,	0,	0,	0,	  0,0,0,0,1 },
    218  1.1    rillig 	{ NULL,		0,		0,	0,	0,	  0,0,0,0,0 }
    219  1.1    rillig };
    220  1.1    rillig 
    221  1.1    rillig /* Symbol table */
    222  1.1    rillig static	sym_t	*symtab[HSHSIZ1];
    223  1.1    rillig 
    224  1.1    rillig /* bit i of the entry with index i is set */
    225  1.1    rillig uint64_t qbmasks[64];
    226  1.1    rillig 
    227  1.1    rillig /* least significant i bits are set in the entry with index i */
    228  1.1    rillig uint64_t qlmasks[64 + 1];
    229  1.1    rillig 
    230  1.1    rillig /* least significant i bits are not set in the entry with index i */
    231  1.1    rillig uint64_t qumasks[64 + 1];
    232  1.1    rillig 
    233  1.1    rillig /* free list for sbuf structures */
    234  1.1    rillig static	sbuf_t	 *sbfrlst;
    235  1.1    rillig 
    236  1.1    rillig /* type of next expected symbol */
    237  1.1    rillig symt_t	symtyp;
    238  1.1    rillig 
    239  1.1    rillig 
    240  1.1    rillig static void
    241  1.1    rillig add_keyword(struct kwtab *kw, int deco)
    242  1.1    rillig {
    243  1.1    rillig 	sym_t *sym;
    244  1.1    rillig 	size_t h;
    245  1.1    rillig 	char buf[256];
    246  1.1    rillig 	const char *name;
    247  1.1    rillig 
    248  1.1    rillig 	if (!(kw->kw_deco & deco))
    249  1.1    rillig 		return;
    250  1.1    rillig 
    251  1.1    rillig 	switch (deco) {
    252  1.1    rillig 	case 1:
    253  1.1    rillig 		name = kw->kw_name;
    254  1.1    rillig 		break;
    255  1.1    rillig 	case 2:
    256  1.1    rillig 		snprintf(buf, sizeof(buf), "__%s", kw->kw_name);
    257  1.1    rillig 		name = strdup(buf);
    258  1.1    rillig 		break;
    259  1.1    rillig 	default:
    260  1.1    rillig 		lint_assert(deco == 4);
    261  1.1    rillig 		snprintf(buf, sizeof(buf), "__%s__", kw->kw_name);
    262  1.1    rillig 		name = strdup(buf);
    263  1.1    rillig 		break;
    264  1.1    rillig 	}
    265  1.1    rillig 
    266  1.1    rillig 	if (name == NULL)
    267  1.1    rillig 		err(1, "Can't init symbol table");
    268  1.1    rillig 
    269  1.1    rillig 	sym = getblk(sizeof (sym_t));
    270  1.1    rillig 	sym->s_name = name;
    271  1.1    rillig 	sym->s_keyword = kw;
    272  1.1    rillig 	sym->s_value.v_quad = kw->kw_token;
    273  1.1    rillig 	if (kw->kw_token == T_TYPE || kw->kw_token == T_STRUCT_OR_UNION) {
    274  1.1    rillig 		sym->s_tspec = kw->kw_tspec;
    275  1.1    rillig 	} else if (kw->kw_token == T_SCLASS) {
    276  1.1    rillig 		sym->s_scl = kw->kw_scl;
    277  1.1    rillig 	} else if (kw->kw_token == T_QUAL) {
    278  1.1    rillig 		sym->s_tqual = kw->kw_tqual;
    279  1.1    rillig 	}
    280  1.1    rillig 	h = hash(sym->s_name);
    281  1.1    rillig 	if ((sym->s_link = symtab[h]) != NULL)
    282  1.1    rillig 		symtab[h]->s_rlink = &sym->s_link;
    283  1.1    rillig 	sym->s_rlink = &symtab[h];
    284  1.1    rillig 	symtab[h] = sym;
    285  1.1    rillig }
    286  1.1    rillig 
    287  1.1    rillig /*
    288  1.1    rillig  * All keywords are written to the symbol table. This saves us looking
    289  1.1    rillig  * in a extra table for each name we found.
    290  1.1    rillig  */
    291  1.1    rillig void
    292  1.1    rillig initscan(void)
    293  1.1    rillig {
    294  1.1    rillig 	struct	kwtab *kw;
    295  1.1    rillig 	size_t	i;
    296  1.1    rillig 	uint64_t uq;
    297  1.1    rillig 
    298  1.1    rillig 	for (kw = kwtab; kw->kw_name != NULL; kw++) {
    299  1.1    rillig 		if ((kw->kw_c89 || kw->kw_c99) && tflag)
    300  1.1    rillig 			continue;
    301  1.1    rillig 		if (kw->kw_c99 && !(Sflag || gflag))
    302  1.1    rillig 			continue;
    303  1.1    rillig 		if (kw->kw_gcc && !gflag)
    304  1.1    rillig 			continue;
    305  1.1    rillig 		add_keyword(kw, 1);
    306  1.1    rillig 		add_keyword(kw, 2);
    307  1.1    rillig 		add_keyword(kw, 4);
    308  1.1    rillig 	}
    309  1.1    rillig 
    310  1.1    rillig 	/* initialize bit-masks for quads */
    311  1.1    rillig 	for (i = 0; i < 64; i++) {
    312  1.1    rillig 		qbmasks[i] = (uint64_t)1 << i;
    313  1.1    rillig 		uq = ~(uint64_t)0 << i;
    314  1.1    rillig 		qumasks[i] = uq;
    315  1.1    rillig 		qlmasks[i] = ~uq;
    316  1.1    rillig 	}
    317  1.1    rillig 	qumasks[i] = 0;
    318  1.1    rillig 	qlmasks[i] = ~(uint64_t)0;
    319  1.1    rillig }
    320  1.1    rillig 
    321  1.1    rillig /*
    322  1.1    rillig  * Get a free sbuf structure, if possible from the free list
    323  1.1    rillig  */
    324  1.1    rillig static sbuf_t *
    325  1.1    rillig allocsb(void)
    326  1.1    rillig {
    327  1.1    rillig 	sbuf_t	*sb;
    328  1.1    rillig 
    329  1.1    rillig 	if ((sb = sbfrlst) != NULL) {
    330  1.1    rillig 		sbfrlst = sb->sb_next;
    331  1.1    rillig #ifdef BLKDEBUG
    332  1.1    rillig 		(void)memset(sb, 0, sizeof (*sb));
    333  1.1    rillig #else
    334  1.1    rillig 		sb->sb_next = NULL;
    335  1.1    rillig #endif
    336  1.1    rillig 	} else {
    337  1.1    rillig 		sb = xmalloc(sizeof (sbuf_t));
    338  1.1    rillig 		(void)memset(sb, 0, sizeof (*sb));
    339  1.1    rillig 	}
    340  1.1    rillig 	return sb;
    341  1.1    rillig }
    342  1.1    rillig 
    343  1.1    rillig /*
    344  1.1    rillig  * Put a sbuf structure to the free list
    345  1.1    rillig  */
    346  1.1    rillig static void
    347  1.1    rillig freesb(sbuf_t *sb)
    348  1.1    rillig {
    349  1.1    rillig 
    350  1.1    rillig 	(void)memset(sb, ZERO, sizeof (*sb));
    351  1.1    rillig 	sb->sb_next = sbfrlst;
    352  1.1    rillig 	sbfrlst = sb;
    353  1.1    rillig }
    354  1.1    rillig 
    355  1.1    rillig /*
    356  1.1    rillig  * Read a character and ensure that it is positive (except EOF).
    357  1.1    rillig  * Increment line count(s) if necessary.
    358  1.1    rillig  */
    359  1.1    rillig static int
    360  1.1    rillig inpc(void)
    361  1.1    rillig {
    362  1.1    rillig 	int	c;
    363  1.1    rillig 
    364  1.1    rillig 	if ((c = lex_input()) != EOF && (c &= CHAR_MASK) == '\n')
    365  1.6    rillig 		lex_next_line();
    366  1.1    rillig 	return c;
    367  1.1    rillig }
    368  1.1    rillig 
    369  1.1    rillig static int
    370  1.1    rillig hash(const char *s)
    371  1.1    rillig {
    372  1.1    rillig 	u_int	v;
    373  1.1    rillig 	const	u_char *us;
    374  1.1    rillig 
    375  1.1    rillig 	v = 0;
    376  1.1    rillig 	for (us = (const u_char *)s; *us != '\0'; us++) {
    377  1.1    rillig 		v = (v << sizeof (v)) + *us;
    378  1.1    rillig 		v ^= v >> (sizeof (v) * CHAR_BIT - sizeof (v));
    379  1.1    rillig 	}
    380  1.1    rillig 	return v % HSHSIZ1;
    381  1.1    rillig }
    382  1.1    rillig 
    383  1.1    rillig /*
    384  1.1    rillig  * Lex has found a letter followed by zero or more letters or digits.
    385  1.1    rillig  * It looks for a symbol in the symbol table with the same name. This
    386  1.1    rillig  * symbol must either be a keyword or a symbol of the type required by
    387  1.1    rillig  * symtyp (label, member, tag, ...).
    388  1.1    rillig  *
    389  1.1    rillig  * If it is a keyword, the token is returned. In some cases it is described
    390  1.1    rillig  * more deeply by data written to yylval.
    391  1.1    rillig  *
    392  1.1    rillig  * If it is a symbol, T_NAME is returned and the pointer to a sbuf struct
    393  1.1    rillig  * is stored in yylval. This struct contains the name of the symbol, its
    394  1.1    rillig  * length and hash value. If there is already a symbol of the same name
    395  1.1    rillig  * and type in the symbol table, the sbuf struct also contains a pointer
    396  1.1    rillig  * to the symbol table entry.
    397  1.1    rillig  */
    398  1.1    rillig extern int
    399  1.1    rillig lex_name(const char *yytext, size_t yyleng)
    400  1.1    rillig {
    401  1.1    rillig 	char	*s;
    402  1.1    rillig 	sbuf_t	*sb;
    403  1.1    rillig 	sym_t	*sym;
    404  1.1    rillig 	int	tok;
    405  1.1    rillig 
    406  1.1    rillig 	sb = allocsb();
    407  1.1    rillig 	sb->sb_name = yytext;
    408  1.1    rillig 	sb->sb_len = yyleng;
    409  1.1    rillig 	sb->sb_hash = hash(yytext);
    410  1.3    rillig 	if ((sym = search(sb)) != NULL && sym->s_keyword != NULL) {
    411  1.1    rillig 		freesb(sb);
    412  1.1    rillig 		return keyw(sym);
    413  1.1    rillig 	}
    414  1.1    rillig 
    415  1.1    rillig 	sb->sb_sym = sym;
    416  1.1    rillig 
    417  1.1    rillig 	if (sym != NULL) {
    418  1.1    rillig 		lint_assert(blklev >= sym->s_blklev);
    419  1.1    rillig 		sb->sb_name = sym->s_name;
    420  1.1    rillig 		sb->sb_len = strlen(sym->s_name);
    421  1.1    rillig 		tok = sym->s_scl == TYPEDEF ? T_TYPENAME : T_NAME;
    422  1.1    rillig 	} else {
    423  1.1    rillig 		s = getblk(yyleng + 1);
    424  1.1    rillig 		(void)memcpy(s, yytext, yyleng + 1);
    425  1.1    rillig 		sb->sb_name = s;
    426  1.1    rillig 		sb->sb_len = yyleng;
    427  1.1    rillig 		tok = T_NAME;
    428  1.1    rillig 	}
    429  1.1    rillig 
    430  1.1    rillig 	yylval.y_sb = sb;
    431  1.1    rillig 	return tok;
    432  1.1    rillig }
    433  1.1    rillig 
    434  1.1    rillig static sym_t *
    435  1.1    rillig search(sbuf_t *sb)
    436  1.1    rillig {
    437  1.1    rillig 	sym_t	*sym;
    438  1.1    rillig 
    439  1.1    rillig 	for (sym = symtab[sb->sb_hash]; sym != NULL; sym = sym->s_link) {
    440  1.1    rillig 		if (strcmp(sym->s_name, sb->sb_name) == 0) {
    441  1.3    rillig 			if (sym->s_keyword != NULL) {
    442  1.1    rillig 				struct kwtab *kw = sym->s_keyword;
    443  1.1    rillig 				if (!kw->kw_attr || attron)
    444  1.1    rillig 					return sym;
    445  1.1    rillig 			} else if (!attron && sym->s_kind == symtyp)
    446  1.1    rillig 				return sym;
    447  1.1    rillig 		}
    448  1.1    rillig 	}
    449  1.1    rillig 
    450  1.1    rillig 	return NULL;
    451  1.1    rillig }
    452  1.1    rillig 
    453  1.1    rillig static int
    454  1.1    rillig keyw(sym_t *sym)
    455  1.1    rillig {
    456  1.1    rillig 	int	t;
    457  1.1    rillig 
    458  1.1    rillig 	if ((t = (int)sym->s_value.v_quad) == T_SCLASS) {
    459  1.1    rillig 		yylval.y_scl = sym->s_scl;
    460  1.1    rillig 	} else if (t == T_TYPE || t == T_STRUCT_OR_UNION) {
    461  1.1    rillig 		yylval.y_tspec = sym->s_tspec;
    462  1.1    rillig 	} else if (t == T_QUAL) {
    463  1.1    rillig 		yylval.y_tqual = sym->s_tqual;
    464  1.1    rillig 	}
    465  1.1    rillig 	return t;
    466  1.1    rillig }
    467  1.1    rillig 
    468  1.1    rillig /*
    469  1.1    rillig  * Convert a string representing an integer into internal representation.
    470  1.1    rillig  * The value is returned in yylval. icon() (and yylex()) returns T_CON.
    471  1.1    rillig  */
    472  1.1    rillig int
    473  1.6    rillig lex_integer_constant(const char *yytext, size_t yyleng, int base)
    474  1.1    rillig {
    475  1.1    rillig 	int	l_suffix, u_suffix;
    476  1.1    rillig 	int	len;
    477  1.1    rillig 	const	char *cp;
    478  1.1    rillig 	char	c, *eptr;
    479  1.1    rillig 	tspec_t	typ;
    480  1.1    rillig 	bool	ansiu;
    481  1.1    rillig #ifdef TARG_INT128_MAX
    482  1.1    rillig 	__uint128_t uq = 0;
    483  1.1    rillig 	static	tspec_t contypes[2][4] = {
    484  1.1    rillig 		{ INT,  LONG,  QUAD, INT128, },
    485  1.1    rillig 		{ UINT, ULONG, UQUAD, UINT128, }
    486  1.1    rillig 	};
    487  1.1    rillig #else
    488  1.1    rillig 	uint64_t uq = 0;
    489  1.1    rillig 	static	tspec_t contypes[2][3] = {
    490  1.1    rillig 		{ INT,  LONG,  QUAD, },
    491  1.1    rillig 		{ UINT, ULONG, UQUAD, }
    492  1.1    rillig 	};
    493  1.1    rillig #endif
    494  1.1    rillig 
    495  1.1    rillig 	cp = yytext;
    496  1.1    rillig 	len = yyleng;
    497  1.1    rillig 
    498  1.1    rillig 	/* skip 0[xX] or 0[bB] */
    499  1.1    rillig 	if (base == 16 || base == 2) {
    500  1.1    rillig 		cp += 2;
    501  1.1    rillig 		len -= 2;
    502  1.1    rillig 	}
    503  1.1    rillig 
    504  1.1    rillig 	/* read suffixes */
    505  1.1    rillig 	l_suffix = u_suffix = 0;
    506  1.1    rillig 	for (;;) {
    507  1.1    rillig 		if ((c = cp[len - 1]) == 'l' || c == 'L') {
    508  1.1    rillig 			l_suffix++;
    509  1.1    rillig 		} else if (c == 'u' || c == 'U') {
    510  1.1    rillig 			u_suffix++;
    511  1.1    rillig 		} else {
    512  1.1    rillig 			break;
    513  1.1    rillig 		}
    514  1.1    rillig 		len--;
    515  1.1    rillig 	}
    516  1.1    rillig 	if (l_suffix > 2 || u_suffix > 1) {
    517  1.1    rillig 		/* malformed integer constant */
    518  1.1    rillig 		warning(251);
    519  1.1    rillig 		if (l_suffix > 2)
    520  1.1    rillig 			l_suffix = 2;
    521  1.1    rillig 		if (u_suffix > 1)
    522  1.1    rillig 			u_suffix = 1;
    523  1.1    rillig 	}
    524  1.1    rillig 	if (tflag && u_suffix != 0) {
    525  1.1    rillig 		/* suffix U is illegal in traditional C */
    526  1.1    rillig 		warning(97);
    527  1.1    rillig 	}
    528  1.1    rillig 	typ = contypes[u_suffix][l_suffix];
    529  1.1    rillig 
    530  1.1    rillig 	errno = 0;
    531  1.1    rillig 
    532  1.1    rillig 	uq = strtouq(cp, &eptr, base);
    533  1.1    rillig 	lint_assert(eptr == cp + len);
    534  1.1    rillig 	if (errno != 0)
    535  1.1    rillig 		/* integer constant out of range */
    536  1.1    rillig 		warning(252);
    537  1.1    rillig 
    538  1.1    rillig 	/*
    539  1.1    rillig 	 * If the value is too big for the current type, we must choose
    540  1.1    rillig 	 * another type.
    541  1.1    rillig 	 */
    542  1.1    rillig 	ansiu = false;
    543  1.1    rillig 	switch (typ) {
    544  1.1    rillig 	case INT:
    545  1.1    rillig 		if (uq <= TARG_INT_MAX) {
    546  1.1    rillig 			/* ok */
    547  1.1    rillig 		} else if (uq <= TARG_UINT_MAX && base != 10) {
    548  1.1    rillig 			typ = UINT;
    549  1.1    rillig 		} else if (uq <= TARG_LONG_MAX) {
    550  1.1    rillig 			typ = LONG;
    551  1.1    rillig 		} else {
    552  1.1    rillig 			typ = ULONG;
    553  1.1    rillig 			if (uq > TARG_ULONG_MAX) {
    554  1.1    rillig 				/* integer constant out of range */
    555  1.1    rillig 				warning(252);
    556  1.1    rillig 			}
    557  1.1    rillig 		}
    558  1.1    rillig 		if (typ == UINT || typ == ULONG) {
    559  1.1    rillig 			if (tflag) {
    560  1.1    rillig 				typ = LONG;
    561  1.1    rillig 			} else if (!sflag) {
    562  1.1    rillig 				/*
    563  1.1    rillig 				 * Remember that the constant is unsigned
    564  1.1    rillig 				 * only in ANSI C
    565  1.1    rillig 				 */
    566  1.1    rillig 				ansiu = true;
    567  1.1    rillig 			}
    568  1.1    rillig 		}
    569  1.1    rillig 		break;
    570  1.1    rillig 	case UINT:
    571  1.1    rillig 		if (uq > TARG_UINT_MAX) {
    572  1.1    rillig 			typ = ULONG;
    573  1.1    rillig 			if (uq > TARG_ULONG_MAX) {
    574  1.1    rillig 				/* integer constant out of range */
    575  1.1    rillig 				warning(252);
    576  1.1    rillig 			}
    577  1.1    rillig 		}
    578  1.1    rillig 		break;
    579  1.1    rillig 	case LONG:
    580  1.1    rillig 		if (uq > TARG_LONG_MAX && !tflag) {
    581  1.1    rillig 			typ = ULONG;
    582  1.1    rillig 			if (!sflag)
    583  1.1    rillig 				ansiu = true;
    584  1.1    rillig 			if (uq > TARG_ULONG_MAX) {
    585  1.1    rillig 				/* integer constant out of range */
    586  1.1    rillig 				warning(252);
    587  1.1    rillig 			}
    588  1.1    rillig 		}
    589  1.1    rillig 		break;
    590  1.1    rillig 	case ULONG:
    591  1.1    rillig 		if (uq > TARG_ULONG_MAX) {
    592  1.1    rillig 			/* integer constant out of range */
    593  1.1    rillig 			warning(252);
    594  1.1    rillig 		}
    595  1.1    rillig 		break;
    596  1.1    rillig 	case QUAD:
    597  1.1    rillig 		if (uq > TARG_QUAD_MAX && !tflag) {
    598  1.1    rillig 			typ = UQUAD;
    599  1.1    rillig 			if (!sflag)
    600  1.1    rillig 				ansiu = true;
    601  1.1    rillig 		}
    602  1.1    rillig 		break;
    603  1.1    rillig 	case UQUAD:
    604  1.1    rillig 		if (uq > TARG_UQUAD_MAX) {
    605  1.1    rillig 			/* integer constant out of range */
    606  1.1    rillig 			warning(252);
    607  1.1    rillig 		}
    608  1.1    rillig 		break;
    609  1.1    rillig #ifdef INT128_SIZE
    610  1.1    rillig 	case INT128:
    611  1.1    rillig #ifdef TARG_INT128_MAX
    612  1.1    rillig 		if (uq > TARG_INT128_MAX && !tflag) {
    613  1.1    rillig 			typ = UINT128;
    614  1.1    rillig 			if (!sflag)
    615  1.1    rillig 				ansiu = true;
    616  1.1    rillig 		}
    617  1.1    rillig #endif
    618  1.1    rillig 		break;
    619  1.1    rillig 	case UINT128:
    620  1.1    rillig #ifdef TARG_INT128_MAX
    621  1.1    rillig 		if (uq > TARG_UINT128_MAX) {
    622  1.1    rillig 			/* integer constant out of range */
    623  1.1    rillig 			warning(252);
    624  1.1    rillig 		}
    625  1.1    rillig #endif
    626  1.1    rillig 		break;
    627  1.1    rillig #endif
    628  1.1    rillig 		/* LINTED206: (enumeration values not handled in switch) */
    629  1.1    rillig 	case STRUCT:
    630  1.1    rillig 	case VOID:
    631  1.1    rillig 	case LDOUBLE:
    632  1.1    rillig 	case FUNC:
    633  1.1    rillig 	case ARRAY:
    634  1.1    rillig 	case PTR:
    635  1.1    rillig 	case ENUM:
    636  1.1    rillig 	case UNION:
    637  1.1    rillig 	case SIGNED:
    638  1.1    rillig 	case NOTSPEC:
    639  1.1    rillig 	case DOUBLE:
    640  1.1    rillig 	case FLOAT:
    641  1.1    rillig 	case USHORT:
    642  1.1    rillig 	case SHORT:
    643  1.1    rillig 	case UCHAR:
    644  1.1    rillig 	case SCHAR:
    645  1.1    rillig 	case CHAR:
    646  1.1    rillig 	case BOOL:
    647  1.1    rillig 	case UNSIGN:
    648  1.1    rillig 	case FCOMPLEX:
    649  1.1    rillig 	case DCOMPLEX:
    650  1.1    rillig 	case LCOMPLEX:
    651  1.1    rillig 	case COMPLEX:
    652  1.1    rillig 		break;
    653  1.1    rillig 	}
    654  1.1    rillig 
    655  1.1    rillig 	uq = (uint64_t)xsign((int64_t)uq, typ, -1);
    656  1.1    rillig 
    657  1.1    rillig 	(yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ;
    658  1.1    rillig 	yylval.y_val->v_ansiu = ansiu;
    659  1.1    rillig 	yylval.y_val->v_quad = (int64_t)uq;
    660  1.1    rillig 
    661  1.1    rillig 	return T_CON;
    662  1.1    rillig }
    663  1.1    rillig 
    664  1.1    rillig /*
    665  1.3    rillig  * Returns whether t is a signed type and the value is negative.
    666  1.1    rillig  *
    667  1.1    rillig  * len is the number of significant bits. If len is -1, len is set
    668  1.1    rillig  * to the width of type t.
    669  1.1    rillig  */
    670  1.3    rillig static bool
    671  1.1    rillig sign(int64_t q, tspec_t t, int len)
    672  1.1    rillig {
    673  1.1    rillig 
    674  1.1    rillig 	if (t == PTR || is_uinteger(t))
    675  1.3    rillig 		return false;
    676  1.3    rillig 	return msb(q, t, len) != 0;
    677  1.1    rillig }
    678  1.1    rillig 
    679  1.1    rillig int
    680  1.1    rillig msb(int64_t q, tspec_t t, int len)
    681  1.1    rillig {
    682  1.1    rillig 
    683  1.1    rillig 	if (len <= 0)
    684  1.1    rillig 		len = size(t);
    685  1.3    rillig 	return (q & qbmasks[len - 1]) != 0 ? 1 : 0;
    686  1.1    rillig }
    687  1.1    rillig 
    688  1.1    rillig /*
    689  1.1    rillig  * Extends the sign of q.
    690  1.1    rillig  */
    691  1.1    rillig int64_t
    692  1.1    rillig xsign(int64_t q, tspec_t t, int len)
    693  1.1    rillig {
    694  1.1    rillig 
    695  1.1    rillig 	if (len <= 0)
    696  1.1    rillig 		len = size(t);
    697  1.1    rillig 
    698  1.1    rillig 	if (t == PTR || is_uinteger(t) || !sign(q, t, len)) {
    699  1.1    rillig 		q &= qlmasks[len];
    700  1.1    rillig 	} else {
    701  1.1    rillig 		q |= qumasks[len];
    702  1.1    rillig 	}
    703  1.1    rillig 	return q;
    704  1.1    rillig }
    705  1.1    rillig 
    706  1.1    rillig /*
    707  1.1    rillig  * Convert a string representing a floating point value into its integral
    708  1.1    rillig  * representation. Type and value are returned in yylval. fcon()
    709  1.1    rillig  * (and yylex()) returns T_CON.
    710  1.1    rillig  * XXX Currently it is not possible to convert constants of type
    711  1.1    rillig  * long double which are greater than DBL_MAX.
    712  1.1    rillig  */
    713  1.1    rillig int
    714  1.6    rillig lex_floating_constant(const char *yytext, size_t yyleng)
    715  1.1    rillig {
    716  1.1    rillig 	const	char *cp;
    717  1.1    rillig 	int	len;
    718  1.1    rillig 	tspec_t typ;
    719  1.1    rillig 	char	c, *eptr;
    720  1.1    rillig 	double	d;
    721  1.1    rillig 	float	f = 0;
    722  1.1    rillig 
    723  1.1    rillig 	cp = yytext;
    724  1.1    rillig 	len = yyleng;
    725  1.1    rillig 
    726  1.1    rillig 	if (cp[len - 1] == 'i') {
    727  1.1    rillig 		/* imaginary, do nothing for now */
    728  1.1    rillig 		len--;
    729  1.1    rillig 	}
    730  1.1    rillig 	if ((c = cp[len - 1]) == 'f' || c == 'F') {
    731  1.1    rillig 		typ = FLOAT;
    732  1.1    rillig 		len--;
    733  1.1    rillig 	} else if (c == 'l' || c == 'L') {
    734  1.1    rillig 		typ = LDOUBLE;
    735  1.1    rillig 		len--;
    736  1.1    rillig 	} else {
    737  1.1    rillig 		if (c == 'd' || c == 'D')
    738  1.1    rillig 			len--;
    739  1.1    rillig 		typ = DOUBLE;
    740  1.1    rillig 	}
    741  1.1    rillig 
    742  1.1    rillig 	if (tflag && typ != DOUBLE) {
    743  1.1    rillig 		/* suffixes F and L are illegal in traditional C */
    744  1.1    rillig 		warning(98);
    745  1.1    rillig 	}
    746  1.1    rillig 
    747  1.1    rillig 	errno = 0;
    748  1.1    rillig 	d = strtod(cp, &eptr);
    749  1.1    rillig 	if (eptr != cp + len) {
    750  1.1    rillig 		switch (*eptr) {
    751  1.1    rillig 			/*
    752  1.1    rillig 			 * XXX: non-native non-current strtod() may not handle hex
    753  1.1    rillig 			 * floats, ignore the rest if we find traces of hex float
    754  1.1    rillig 			 * syntax...
    755  1.1    rillig 			 */
    756  1.1    rillig 		case 'p':
    757  1.1    rillig 		case 'P':
    758  1.1    rillig 		case 'x':
    759  1.1    rillig 		case 'X':
    760  1.1    rillig 			d = 0;
    761  1.1    rillig 			errno = 0;
    762  1.1    rillig 			break;
    763  1.1    rillig 		default:
    764  1.1    rillig 			LERROR("fcon(%s->%s)", cp, eptr);
    765  1.1    rillig 		}
    766  1.1    rillig 	}
    767  1.1    rillig 	if (errno != 0)
    768  1.1    rillig 		/* floating-point constant out of range */
    769  1.1    rillig 		warning(248);
    770  1.1    rillig 
    771  1.1    rillig 	if (typ == FLOAT) {
    772  1.1    rillig 		f = (float)d;
    773  1.5    rillig 		if (finite(f) == 0) {
    774  1.1    rillig 			/* floating-point constant out of range */
    775  1.1    rillig 			warning(248);
    776  1.1    rillig 			f = f > 0 ? FLT_MAX : -FLT_MAX;
    777  1.1    rillig 		}
    778  1.1    rillig 	}
    779  1.1    rillig 
    780  1.1    rillig 	(yylval.y_val = xcalloc(1, sizeof (val_t)))->v_tspec = typ;
    781  1.1    rillig 	if (typ == FLOAT) {
    782  1.1    rillig 		yylval.y_val->v_ldbl = f;
    783  1.1    rillig 	} else {
    784  1.1    rillig 		yylval.y_val->v_ldbl = d;
    785  1.1    rillig 	}
    786  1.1    rillig 
    787  1.1    rillig 	return T_CON;
    788  1.1    rillig }
    789  1.1    rillig 
    790  1.1    rillig int
    791  1.1    rillig lex_operator(int t, op_t o)
    792  1.1    rillig {
    793  1.1    rillig 
    794  1.1    rillig 	yylval.y_op = o;
    795  1.1    rillig 	return t;
    796  1.1    rillig }
    797  1.1    rillig 
    798  1.1    rillig /*
    799  1.1    rillig  * Called if lex found a leading \'.
    800  1.1    rillig  */
    801  1.1    rillig int
    802  1.6    rillig lex_character_constant(void)
    803  1.1    rillig {
    804  1.1    rillig 	size_t	n;
    805  1.1    rillig 	int val, c;
    806  1.1    rillig 	char	cv;
    807  1.1    rillig 
    808  1.1    rillig 	n = 0;
    809  1.1    rillig 	val = 0;
    810  1.6    rillig 	while ((c = get_escaped_char('\'')) >= 0) {
    811  1.1    rillig 		val = (val << CHAR_SIZE) + c;
    812  1.1    rillig 		n++;
    813  1.1    rillig 	}
    814  1.1    rillig 	if (c == -2) {
    815  1.1    rillig 		/* unterminated character constant */
    816  1.1    rillig 		error(253);
    817  1.1    rillig 	} else {
    818  1.1    rillig 		if (n > sizeof (int) || (n > 1 && (pflag || hflag))) {
    819  1.1    rillig 			/* too many characters in character constant */
    820  1.1    rillig 			error(71);
    821  1.1    rillig 		} else if (n > 1) {
    822  1.1    rillig 			/* multi-character character constant */
    823  1.1    rillig 			warning(294);
    824  1.1    rillig 		} else if (n == 0) {
    825  1.1    rillig 			/* empty character constant */
    826  1.1    rillig 			error(73);
    827  1.1    rillig 		}
    828  1.1    rillig 	}
    829  1.1    rillig 	if (n == 1) {
    830  1.1    rillig 		cv = (char)val;
    831  1.1    rillig 		val = cv;
    832  1.1    rillig 	}
    833  1.1    rillig 
    834  1.1    rillig 	yylval.y_val = xcalloc(1, sizeof (val_t));
    835  1.1    rillig 	yylval.y_val->v_tspec = INT;
    836  1.1    rillig 	yylval.y_val->v_quad = val;
    837  1.1    rillig 
    838  1.1    rillig 	return T_CON;
    839  1.1    rillig }
    840  1.1    rillig 
    841  1.1    rillig /*
    842  1.1    rillig  * Called if lex found a leading L\'
    843  1.1    rillig  */
    844  1.1    rillig int
    845  1.6    rillig lex_wide_character_constant(void)
    846  1.1    rillig {
    847  1.1    rillig 	static	char buf[MB_LEN_MAX + 1];
    848  1.7    rillig 	size_t	i, imax;
    849  1.1    rillig 	int c;
    850  1.1    rillig 	wchar_t	wc;
    851  1.1    rillig 
    852  1.7    rillig 	imax = MB_CUR_MAX;
    853  1.7    rillig 
    854  1.1    rillig 	i = 0;
    855  1.6    rillig 	while ((c = get_escaped_char('\'')) >= 0) {
    856  1.7    rillig 		if (i < imax)
    857  1.1    rillig 			buf[i] = (char)c;
    858  1.1    rillig 		i++;
    859  1.1    rillig 	}
    860  1.1    rillig 
    861  1.1    rillig 	wc = 0;
    862  1.1    rillig 
    863  1.1    rillig 	if (c == -2) {
    864  1.1    rillig 		/* unterminated character constant */
    865  1.1    rillig 		error(253);
    866  1.1    rillig 	} else if (c == 0) {
    867  1.1    rillig 		/* empty character constant */
    868  1.1    rillig 		error(73);
    869  1.1    rillig 	} else {
    870  1.7    rillig 		if (i > imax) {
    871  1.7    rillig 			i = imax;
    872  1.1    rillig 			/* too many characters in character constant */
    873  1.1    rillig 			error(71);
    874  1.1    rillig 		} else {
    875  1.1    rillig 			buf[i] = '\0';
    876  1.1    rillig 			(void)mbtowc(NULL, NULL, 0);
    877  1.7    rillig 			if (mbtowc(&wc, buf, imax) < 0)
    878  1.1    rillig 				/* invalid multibyte character */
    879  1.1    rillig 				error(291);
    880  1.1    rillig 		}
    881  1.1    rillig 	}
    882  1.1    rillig 
    883  1.1    rillig 	yylval.y_val = xcalloc(1, sizeof (val_t));
    884  1.1    rillig 	yylval.y_val->v_tspec = WCHAR;
    885  1.1    rillig 	yylval.y_val->v_quad = wc;
    886  1.1    rillig 
    887  1.1    rillig 	return T_CON;
    888  1.1    rillig }
    889  1.1    rillig 
    890  1.1    rillig /*
    891  1.1    rillig  * Read a character which is part of a character constant or of a string
    892  1.1    rillig  * and handle escapes.
    893  1.1    rillig  *
    894  1.2    rillig  * The argument is the character which delimits the character constant or
    895  1.1    rillig  * string.
    896  1.1    rillig  *
    897  1.1    rillig  * Returns -1 if the end of the character constant or string is reached,
    898  1.1    rillig  * -2 if the EOF is reached, and the character otherwise.
    899  1.1    rillig  */
    900  1.1    rillig static int
    901  1.6    rillig get_escaped_char(int delim)
    902  1.1    rillig {
    903  1.1    rillig 	static	int pbc = -1;
    904  1.1    rillig 	int	n, c, v;
    905  1.1    rillig 
    906  1.1    rillig 	if (pbc == -1) {
    907  1.1    rillig 		c = inpc();
    908  1.1    rillig 	} else {
    909  1.1    rillig 		c = pbc;
    910  1.1    rillig 		pbc = -1;
    911  1.1    rillig 	}
    912  1.2    rillig 	if (c == delim)
    913  1.1    rillig 		return -1;
    914  1.1    rillig 	switch (c) {
    915  1.1    rillig 	case '\n':
    916  1.1    rillig 		if (tflag) {
    917  1.1    rillig 			/* newline in string or char constant */
    918  1.1    rillig 			error(254);
    919  1.1    rillig 			return -2;
    920  1.1    rillig 		}
    921  1.1    rillig 		return c;
    922  1.1    rillig 	case EOF:
    923  1.1    rillig 		return -2;
    924  1.1    rillig 	case '\\':
    925  1.1    rillig 		switch (c = inpc()) {
    926  1.1    rillig 		case '"':
    927  1.2    rillig 			if (tflag && delim == '\'')
    928  1.1    rillig 				/* \" inside character constants undef... */
    929  1.1    rillig 				warning(262);
    930  1.1    rillig 			return '"';
    931  1.1    rillig 		case '\'':
    932  1.1    rillig 			return '\'';
    933  1.1    rillig 		case '?':
    934  1.1    rillig 			if (tflag)
    935  1.1    rillig 				/* \? undefined in traditional C */
    936  1.1    rillig 				warning(263);
    937  1.1    rillig 			return '?';
    938  1.1    rillig 		case '\\':
    939  1.1    rillig 			return '\\';
    940  1.1    rillig 		case 'a':
    941  1.1    rillig 			if (tflag)
    942  1.1    rillig 				/* \a undefined in traditional C */
    943  1.1    rillig 				warning(81);
    944  1.1    rillig 			return '\a';
    945  1.1    rillig 		case 'b':
    946  1.1    rillig 			return '\b';
    947  1.1    rillig 		case 'f':
    948  1.1    rillig 			return '\f';
    949  1.1    rillig 		case 'n':
    950  1.1    rillig 			return '\n';
    951  1.1    rillig 		case 'r':
    952  1.1    rillig 			return '\r';
    953  1.1    rillig 		case 't':
    954  1.1    rillig 			return '\t';
    955  1.1    rillig 		case 'v':
    956  1.1    rillig 			if (tflag)
    957  1.1    rillig 				/* \v undefined in traditional C */
    958  1.1    rillig 				warning(264);
    959  1.1    rillig 			return '\v';
    960  1.1    rillig 		case '8': case '9':
    961  1.1    rillig 			/* bad octal digit %c */
    962  1.1    rillig 			warning(77, c);
    963  1.1    rillig 			/* FALLTHROUGH */
    964  1.1    rillig 		case '0': case '1': case '2': case '3':
    965  1.1    rillig 		case '4': case '5': case '6': case '7':
    966  1.1    rillig 			n = 3;
    967  1.1    rillig 			v = 0;
    968  1.1    rillig 			do {
    969  1.1    rillig 				v = (v << 3) + (c - '0');
    970  1.1    rillig 				c = inpc();
    971  1.3    rillig 			} while (--n > 0 && isdigit(c) && (tflag || c <= '7'));
    972  1.1    rillig 			if (tflag && n > 0 && isdigit(c))
    973  1.1    rillig 				/* bad octal digit %c */
    974  1.1    rillig 				warning(77, c);
    975  1.1    rillig 			pbc = c;
    976  1.1    rillig 			if (v > TARG_UCHAR_MAX) {
    977  1.1    rillig 				/* character escape does not fit in character */
    978  1.1    rillig 				warning(76);
    979  1.1    rillig 				v &= CHAR_MASK;
    980  1.1    rillig 			}
    981  1.1    rillig 			return v;
    982  1.1    rillig 		case 'x':
    983  1.1    rillig 			if (tflag)
    984  1.1    rillig 				/* \x undefined in traditional C */
    985  1.1    rillig 				warning(82);
    986  1.1    rillig 			v = 0;
    987  1.1    rillig 			n = 0;
    988  1.1    rillig 			while ((c = inpc()) >= 0 && isxdigit(c)) {
    989  1.1    rillig 				c = isdigit(c) ?
    990  1.1    rillig 				    c - '0' : toupper(c) - 'A' + 10;
    991  1.1    rillig 				v = (v << 4) + c;
    992  1.1    rillig 				if (n >= 0) {
    993  1.1    rillig 					if ((v & ~CHAR_MASK) != 0) {
    994  1.1    rillig 						/* overflow in hex escape */
    995  1.1    rillig 						warning(75);
    996  1.1    rillig 						n = -1;
    997  1.1    rillig 					} else {
    998  1.1    rillig 						n++;
    999  1.1    rillig 					}
   1000  1.1    rillig 				}
   1001  1.1    rillig 			}
   1002  1.1    rillig 			pbc = c;
   1003  1.1    rillig 			if (n == 0) {
   1004  1.1    rillig 				/* no hex digits follow \x */
   1005  1.1    rillig 				error(74);
   1006  1.1    rillig 			} if (n == -1) {
   1007  1.1    rillig 				v &= CHAR_MASK;
   1008  1.1    rillig 			}
   1009  1.1    rillig 			return v;
   1010  1.1    rillig 		case '\n':
   1011  1.6    rillig 			return get_escaped_char(delim);
   1012  1.1    rillig 		case EOF:
   1013  1.1    rillig 			return -2;
   1014  1.1    rillig 		default:
   1015  1.1    rillig 			if (isprint(c)) {
   1016  1.1    rillig 				/* dubious escape \%c */
   1017  1.1    rillig 				warning(79, c);
   1018  1.1    rillig 			} else {
   1019  1.1    rillig 				/* dubious escape \%o */
   1020  1.1    rillig 				warning(80, c);
   1021  1.1    rillig 			}
   1022  1.1    rillig 		}
   1023  1.1    rillig 	}
   1024  1.1    rillig 	return c;
   1025  1.1    rillig }
   1026  1.1    rillig 
   1027  1.1    rillig /* See https://gcc.gnu.org/onlinedocs/cpp/Preprocessor-Output.html */
   1028  1.1    rillig static void
   1029  1.1    rillig parse_line_directive_flags(const char *p)
   1030  1.1    rillig {
   1031  1.1    rillig 
   1032  1.1    rillig 	in_system_header = false;
   1033  1.1    rillig 
   1034  1.1    rillig 	while (ch_isspace(*p))
   1035  1.1    rillig 		p++;
   1036  1.1    rillig 	while (ch_isdigit(*p)) {
   1037  1.1    rillig 		if (*p == '3' && !ch_isdigit(p[1]))
   1038  1.1    rillig 			in_system_header = true;
   1039  1.1    rillig 		p++;
   1040  1.1    rillig 		while (ch_isspace(*p))
   1041  1.1    rillig 			p++;
   1042  1.1    rillig 	}
   1043  1.1    rillig 
   1044  1.1    rillig #if 0
   1045  1.1    rillig 	if (c != '\0')
   1046  1.1    rillig 		warning("extra character(s) after directive");
   1047  1.1    rillig #endif
   1048  1.1    rillig }
   1049  1.1    rillig 
   1050  1.1    rillig /*
   1051  1.1    rillig  * Called for preprocessor directives. Currently implemented are:
   1052  1.1    rillig  *	# lineno
   1053  1.1    rillig  *	# lineno "filename"
   1054  1.2    rillig  *	# lineno "filename" GCC-flag...
   1055  1.1    rillig  */
   1056  1.1    rillig void
   1057  1.1    rillig lex_directive(const char *yytext)
   1058  1.1    rillig {
   1059  1.1    rillig 	const	char *cp, *fn;
   1060  1.1    rillig 	char	c, *eptr;
   1061  1.1    rillig 	size_t	fnl;
   1062  1.1    rillig 	long	ln;
   1063  1.1    rillig 	static	bool first = true;
   1064  1.1    rillig 
   1065  1.1    rillig 	/* Go to first non-whitespace after # */
   1066  1.1    rillig 	for (cp = yytext + 1; (c = *cp) == ' ' || c == '\t'; cp++)
   1067  1.1    rillig 		continue;
   1068  1.1    rillig 
   1069  1.1    rillig 	if (!ch_isdigit(c)) {
   1070  1.1    rillig 		if (strncmp(cp, "pragma", 6) == 0 && ch_isspace(cp[6]))
   1071  1.1    rillig 			return;
   1072  1.1    rillig 	error:
   1073  1.1    rillig 		/* undefined or invalid # directive */
   1074  1.1    rillig 		warning(255);
   1075  1.1    rillig 		return;
   1076  1.1    rillig 	}
   1077  1.1    rillig 	ln = strtol(--cp, &eptr, 10);
   1078  1.1    rillig 	if (cp == eptr)
   1079  1.1    rillig 		goto error;
   1080  1.1    rillig 	if ((c = *(cp = eptr)) != ' ' && c != '\t' && c != '\0')
   1081  1.1    rillig 		goto error;
   1082  1.1    rillig 	while ((c = *cp++) == ' ' || c == '\t')
   1083  1.1    rillig 		continue;
   1084  1.1    rillig 	if (c != '\0') {
   1085  1.1    rillig 		if (c != '"')
   1086  1.1    rillig 			goto error;
   1087  1.1    rillig 		fn = cp;
   1088  1.1    rillig 		while ((c = *cp) != '"' && c != '\0')
   1089  1.1    rillig 			cp++;
   1090  1.1    rillig 		if (c != '"')
   1091  1.1    rillig 			goto error;
   1092  1.1    rillig 		if ((fnl = cp++ - fn) > PATH_MAX)
   1093  1.1    rillig 			goto error;
   1094  1.1    rillig 		parse_line_directive_flags(cp);
   1095  1.1    rillig 
   1096  1.1    rillig 		/* empty string means stdin */
   1097  1.1    rillig 		if (fnl == 0) {
   1098  1.1    rillig 			fn = "{standard input}";
   1099  1.1    rillig 			fnl = 16;			/* strlen (fn) */
   1100  1.1    rillig 		}
   1101  1.1    rillig 		curr_pos.p_file = fnnalloc(fn, fnl);
   1102  1.1    rillig 		/*
   1103  1.1    rillig 		 * If this is the first directive, the name is the name
   1104  1.1    rillig 		 * of the C source file as specified at the command line.
   1105  1.1    rillig 		 * It is written to the output file.
   1106  1.1    rillig 		 */
   1107  1.1    rillig 		if (first) {
   1108  1.1    rillig 			csrc_pos.p_file = curr_pos.p_file;
   1109  1.1    rillig 			outsrc(fnxform(curr_pos.p_file,
   1110  1.1    rillig 			    strlen(curr_pos.p_file)));
   1111  1.1    rillig 			first = false;
   1112  1.1    rillig 		}
   1113  1.1    rillig 	}
   1114  1.1    rillig 	curr_pos.p_line = (int)ln - 1;
   1115  1.1    rillig 	curr_pos.p_uniq = 0;
   1116  1.1    rillig 	if (curr_pos.p_file == csrc_pos.p_file) {
   1117  1.1    rillig 		csrc_pos.p_line = (int)ln - 1;
   1118  1.1    rillig 		csrc_pos.p_uniq = 0;
   1119  1.1    rillig 	}
   1120  1.1    rillig }
   1121  1.1    rillig 
   1122  1.1    rillig /*
   1123  1.2    rillig  * Handle lint comments such as ARGSUSED.
   1124  1.2    rillig  *
   1125  1.1    rillig  * If one of these comments is recognized, the argument, if any, is
   1126  1.1    rillig  * parsed and a function which handles this comment is called.
   1127  1.1    rillig  */
   1128  1.1    rillig void
   1129  1.1    rillig lex_comment(void)
   1130  1.1    rillig {
   1131  1.1    rillig 	int	c, lc;
   1132  1.1    rillig 	static const struct {
   1133  1.1    rillig 		const	char *keywd;
   1134  1.3    rillig 		bool	arg;
   1135  1.1    rillig 		void	(*func)(int);
   1136  1.1    rillig 	} keywtab[] = {
   1137  1.3    rillig 		{ "ARGSUSED",		true,	argsused	},
   1138  1.3    rillig 		{ "BITFIELDTYPE",	false,	bitfieldtype	},
   1139  1.3    rillig 		{ "CONSTCOND",		false,	constcond	},
   1140  1.3    rillig 		{ "CONSTANTCOND",	false,	constcond	},
   1141  1.3    rillig 		{ "CONSTANTCONDITION",	false,	constcond	},
   1142  1.3    rillig 		{ "FALLTHRU",		false,	fallthru	},
   1143  1.3    rillig 		{ "FALLTHROUGH",	false,	fallthru	},
   1144  1.3    rillig 		{ "LINTLIBRARY",	false,	lintlib		},
   1145  1.3    rillig 		{ "LINTED",		true,	linted		},
   1146  1.3    rillig 		{ "LONGLONG",		false,	longlong	},
   1147  1.3    rillig 		{ "NOSTRICT",		true,	linted		},
   1148  1.3    rillig 		{ "NOTREACHED",		false,	notreach	},
   1149  1.3    rillig 		{ "PRINTFLIKE",		true,	printflike	},
   1150  1.3    rillig 		{ "PROTOLIB",		true,	protolib	},
   1151  1.3    rillig 		{ "SCANFLIKE",		true,	scanflike	},
   1152  1.3    rillig 		{ "VARARGS",		true,	varargs		},
   1153  1.1    rillig 	};
   1154  1.1    rillig 	char	keywd[32];
   1155  1.1    rillig 	char	arg[32];
   1156  1.1    rillig 	size_t	l, i;
   1157  1.1    rillig 	int	a;
   1158  1.1    rillig 	bool	eoc;
   1159  1.1    rillig 
   1160  1.1    rillig 	eoc = false;
   1161  1.1    rillig 
   1162  1.1    rillig 	/* Skip whitespace after the start of the comment */
   1163  1.1    rillig 	while ((c = inpc()) != EOF && isspace(c))
   1164  1.1    rillig 		continue;
   1165  1.1    rillig 
   1166  1.1    rillig 	/* Read the potential keyword to keywd */
   1167  1.1    rillig 	l = 0;
   1168  1.1    rillig 	while (c != EOF && isupper(c) && l < sizeof (keywd) - 1) {
   1169  1.1    rillig 		keywd[l++] = (char)c;
   1170  1.1    rillig 		c = inpc();
   1171  1.1    rillig 	}
   1172  1.1    rillig 	keywd[l] = '\0';
   1173  1.1    rillig 
   1174  1.1    rillig 	/* look for the keyword */
   1175  1.1    rillig 	for (i = 0; i < sizeof (keywtab) / sizeof (keywtab[0]); i++) {
   1176  1.1    rillig 		if (strcmp(keywtab[i].keywd, keywd) == 0)
   1177  1.1    rillig 			break;
   1178  1.1    rillig 	}
   1179  1.1    rillig 	if (i == sizeof (keywtab) / sizeof (keywtab[0]))
   1180  1.1    rillig 		goto skip_rest;
   1181  1.1    rillig 
   1182  1.1    rillig 	/* skip whitespace after the keyword */
   1183  1.1    rillig 	while (c != EOF && isspace(c))
   1184  1.1    rillig 		c = inpc();
   1185  1.1    rillig 
   1186  1.1    rillig 	/* read the argument, if the keyword accepts one and there is one */
   1187  1.1    rillig 	l = 0;
   1188  1.1    rillig 	if (keywtab[i].arg) {
   1189  1.1    rillig 		while (c != EOF && isdigit(c) && l < sizeof (arg) - 1) {
   1190  1.1    rillig 			arg[l++] = (char)c;
   1191  1.1    rillig 			c = inpc();
   1192  1.1    rillig 		}
   1193  1.1    rillig 	}
   1194  1.1    rillig 	arg[l] = '\0';
   1195  1.1    rillig 	a = l != 0 ? atoi(arg) : -1;
   1196  1.1    rillig 
   1197  1.1    rillig 	/* skip whitespace after the argument */
   1198  1.1    rillig 	while (c != EOF && isspace(c))
   1199  1.1    rillig 		c = inpc();
   1200  1.1    rillig 
   1201  1.1    rillig 	if (c != '*' || (c = inpc()) != '/') {
   1202  1.1    rillig 		if (keywtab[i].func != linted)
   1203  1.1    rillig 			/* extra characters in lint comment */
   1204  1.1    rillig 			warning(257);
   1205  1.1    rillig 	} else {
   1206  1.1    rillig 		/*
   1207  1.1    rillig 		 * remember that we have already found the end of the
   1208  1.1    rillig 		 * comment
   1209  1.1    rillig 		 */
   1210  1.1    rillig 		eoc = true;
   1211  1.1    rillig 	}
   1212  1.1    rillig 
   1213  1.1    rillig 	if (keywtab[i].func != NULL)
   1214  1.1    rillig 		(*keywtab[i].func)(a);
   1215  1.1    rillig 
   1216  1.1    rillig skip_rest:
   1217  1.1    rillig 	while (!eoc) {
   1218  1.1    rillig 		lc = c;
   1219  1.1    rillig 		if ((c = inpc()) == EOF) {
   1220  1.1    rillig 			/* unterminated comment */
   1221  1.1    rillig 			error(256);
   1222  1.1    rillig 			break;
   1223  1.1    rillig 		}
   1224  1.1    rillig 		if (lc == '*' && c == '/')
   1225  1.1    rillig 			eoc = true;
   1226  1.1    rillig 	}
   1227  1.1    rillig }
   1228  1.1    rillig 
   1229  1.1    rillig /*
   1230  1.1    rillig  * Handle // style comments
   1231  1.1    rillig  */
   1232  1.1    rillig void
   1233  1.6    rillig lex_slash_slash_comment(void)
   1234  1.1    rillig {
   1235  1.1    rillig 	int c;
   1236  1.1    rillig 
   1237  1.1    rillig 	if (!Sflag && !gflag)
   1238  1.1    rillig 		/* %s C does not support // comments */
   1239  1.1    rillig 		gnuism(312, tflag ? "traditional" : "ANSI");
   1240  1.1    rillig 
   1241  1.1    rillig 	while ((c = inpc()) != EOF && c != '\n')
   1242  1.1    rillig 		continue;
   1243  1.1    rillig }
   1244  1.1    rillig 
   1245  1.1    rillig /*
   1246  1.1    rillig  * Clear flags for lint comments LINTED, LONGLONG and CONSTCOND.
   1247  1.1    rillig  * clear_warn_flags() is called after function definitions and global and
   1248  1.1    rillig  * local declarations and definitions. It is also called between
   1249  1.1    rillig  * the controlling expression and the body of control statements
   1250  1.1    rillig  * (if, switch, for, while).
   1251  1.1    rillig  */
   1252  1.1    rillig void
   1253  1.1    rillig clear_warn_flags(void)
   1254  1.1    rillig {
   1255  1.1    rillig 
   1256  1.1    rillig 	lwarn = LWARN_ALL;
   1257  1.1    rillig 	quadflg = false;
   1258  1.1    rillig 	constcond_flag = false;
   1259  1.1    rillig }
   1260  1.1    rillig 
   1261  1.1    rillig /*
   1262  1.1    rillig  * Strings are stored in a dynamically allocated buffer and passed
   1263  1.1    rillig  * in yylval.y_xstrg to the parser. The parser or the routines called
   1264  1.1    rillig  * by the parser are responsible for freeing this buffer.
   1265  1.1    rillig  */
   1266  1.1    rillig int
   1267  1.1    rillig lex_string(void)
   1268  1.1    rillig {
   1269  1.1    rillig 	u_char	*s;
   1270  1.1    rillig 	int	c;
   1271  1.1    rillig 	size_t	len, max;
   1272  1.1    rillig 	strg_t	*strg;
   1273  1.1    rillig 
   1274  1.1    rillig 	s = xmalloc(max = 64);
   1275  1.1    rillig 
   1276  1.1    rillig 	len = 0;
   1277  1.6    rillig 	while ((c = get_escaped_char('"')) >= 0) {
   1278  1.1    rillig 		/* +1 to reserve space for a trailing NUL character */
   1279  1.1    rillig 		if (len + 1 == max)
   1280  1.1    rillig 			s = xrealloc(s, max *= 2);
   1281  1.1    rillig 		s[len++] = (char)c;
   1282  1.1    rillig 	}
   1283  1.1    rillig 	s[len] = '\0';
   1284  1.1    rillig 	if (c == -2)
   1285  1.1    rillig 		/* unterminated string constant */
   1286  1.1    rillig 		error(258);
   1287  1.1    rillig 
   1288  1.1    rillig 	strg = xcalloc(1, sizeof (strg_t));
   1289  1.1    rillig 	strg->st_tspec = CHAR;
   1290  1.1    rillig 	strg->st_len = len;
   1291  1.1    rillig 	strg->st_cp = s;
   1292  1.1    rillig 
   1293  1.1    rillig 	yylval.y_string = strg;
   1294  1.1    rillig 	return T_STRING;
   1295  1.1    rillig }
   1296  1.1    rillig 
   1297  1.1    rillig int
   1298  1.6    rillig lex_wide_string(void)
   1299  1.1    rillig {
   1300  1.1    rillig 	char	*s;
   1301  1.1    rillig 	int	c, n;
   1302  1.1    rillig 	size_t	i, wi;
   1303  1.1    rillig 	size_t	len, max, wlen;
   1304  1.1    rillig 	wchar_t	*ws;
   1305  1.1    rillig 	strg_t	*strg;
   1306  1.1    rillig 
   1307  1.1    rillig 	s = xmalloc(max = 64);
   1308  1.1    rillig 	len = 0;
   1309  1.6    rillig 	while ((c = get_escaped_char('"')) >= 0) {
   1310  1.1    rillig 		/* +1 to save space for a trailing NUL character */
   1311  1.1    rillig 		if (len + 1 >= max)
   1312  1.1    rillig 			s = xrealloc(s, max *= 2);
   1313  1.1    rillig 		s[len++] = (char)c;
   1314  1.1    rillig 	}
   1315  1.1    rillig 	s[len] = '\0';
   1316  1.1    rillig 	if (c == -2)
   1317  1.1    rillig 		/* unterminated string constant */
   1318  1.1    rillig 		error(258);
   1319  1.1    rillig 
   1320  1.1    rillig 	/* get length of wide-character string */
   1321  1.1    rillig 	(void)mblen(NULL, 0);
   1322  1.1    rillig 	for (i = 0, wlen = 0; i < len; i += n, wlen++) {
   1323  1.1    rillig 		if ((n = mblen(&s[i], MB_CUR_MAX)) == -1) {
   1324  1.1    rillig 			/* invalid multibyte character */
   1325  1.1    rillig 			error(291);
   1326  1.1    rillig 			break;
   1327  1.1    rillig 		}
   1328  1.1    rillig 		if (n == 0)
   1329  1.1    rillig 			n = 1;
   1330  1.1    rillig 	}
   1331  1.1    rillig 
   1332  1.1    rillig 	ws = xmalloc((wlen + 1) * sizeof (wchar_t));
   1333  1.1    rillig 
   1334  1.1    rillig 	/* convert from multibyte to wide char */
   1335  1.1    rillig 	(void)mbtowc(NULL, NULL, 0);
   1336  1.1    rillig 	for (i = 0, wi = 0; i < len; i += n, wi++) {
   1337  1.1    rillig 		if ((n = mbtowc(&ws[wi], &s[i], MB_CUR_MAX)) == -1)
   1338  1.1    rillig 			break;
   1339  1.1    rillig 		if (n == 0)
   1340  1.1    rillig 			n = 1;
   1341  1.1    rillig 	}
   1342  1.1    rillig 	ws[wi] = 0;
   1343  1.1    rillig 	free(s);
   1344  1.1    rillig 
   1345  1.1    rillig 	strg = xcalloc(1, sizeof (strg_t));
   1346  1.1    rillig 	strg->st_tspec = WCHAR;
   1347  1.1    rillig 	strg->st_len = wlen;
   1348  1.1    rillig 	strg->st_wcp = ws;
   1349  1.1    rillig 
   1350  1.1    rillig 	yylval.y_string = strg;
   1351  1.1    rillig 	return T_STRING;
   1352  1.1    rillig }
   1353  1.1    rillig 
   1354  1.1    rillig /*
   1355  1.1    rillig  * As noted above the scanner does not create new symbol table entries
   1356  1.1    rillig  * for symbols it cannot find in the symbol table. This is to avoid
   1357  1.1    rillig  * putting undeclared symbols into the symbol table if a syntax error
   1358  1.1    rillig  * occurs.
   1359  1.1    rillig  *
   1360  1.1    rillig  * getsym() is called as soon as it is probably ok to put the symbol to
   1361  1.1    rillig  * the symbol table. This does not mean that it is not possible that
   1362  1.1    rillig  * symbols are put to the symbol table which are not completely
   1363  1.1    rillig  * declared due to syntax errors. To avoid too many problems in this
   1364  1.1    rillig  * case, symbols get type int in getsym().
   1365  1.1    rillig  *
   1366  1.2    rillig  * XXX calls to getsym() should be delayed until decl1*() is called.
   1367  1.1    rillig  */
   1368  1.1    rillig sym_t *
   1369  1.1    rillig getsym(sbuf_t *sb)
   1370  1.1    rillig {
   1371  1.1    rillig 	dinfo_t	*di;
   1372  1.1    rillig 	char	*s;
   1373  1.1    rillig 	sym_t	*sym;
   1374  1.1    rillig 
   1375  1.1    rillig 	sym = sb->sb_sym;
   1376  1.1    rillig 
   1377  1.1    rillig 	/*
   1378  1.1    rillig 	 * During member declaration it is possible that name() looked
   1379  1.1    rillig 	 * for symbols of type FVFT, although it should have looked for
   1380  1.1    rillig 	 * symbols of type FTAG. Same can happen for labels. Both cases
   1381  1.1    rillig 	 * are compensated here.
   1382  1.1    rillig 	 */
   1383  1.1    rillig 	if (symtyp == FMEMBER || symtyp == FLABEL) {
   1384  1.1    rillig 		if (sym == NULL || sym->s_kind == FVFT)
   1385  1.1    rillig 			sym = search(sb);
   1386  1.1    rillig 	}
   1387  1.1    rillig 
   1388  1.1    rillig 	if (sym != NULL) {
   1389  1.1    rillig 		if (sym->s_kind != symtyp)
   1390  1.1    rillig 			LERROR("getsym(%d, %d)", sym->s_kind, symtyp);
   1391  1.1    rillig 		symtyp = FVFT;
   1392  1.1    rillig 		freesb(sb);
   1393  1.1    rillig 		return sym;
   1394  1.1    rillig 	}
   1395  1.1    rillig 
   1396  1.1    rillig 	/* create a new symbol table entry */
   1397  1.1    rillig 
   1398  1.1    rillig 	/* labels must always be allocated at level 1 (outermost block) */
   1399  1.1    rillig 	if (symtyp == FLABEL) {
   1400  1.1    rillig 		sym = getlblk(1, sizeof (sym_t));
   1401  1.1    rillig 		s = getlblk(1, sb->sb_len + 1);
   1402  1.1    rillig 		(void)memcpy(s, sb->sb_name, sb->sb_len + 1);
   1403  1.1    rillig 		sym->s_name = s;
   1404  1.1    rillig 		sym->s_blklev = 1;
   1405  1.1    rillig 		di = dcs;
   1406  1.1    rillig 		while (di->d_next != NULL && di->d_next->d_next != NULL)
   1407  1.1    rillig 			di = di->d_next;
   1408  1.1    rillig 		lint_assert(di->d_ctx == AUTO);
   1409  1.1    rillig 	} else {
   1410  1.1    rillig 		sym = getblk(sizeof (sym_t));
   1411  1.1    rillig 		sym->s_name = sb->sb_name;
   1412  1.1    rillig 		sym->s_blklev = blklev;
   1413  1.1    rillig 		di = dcs;
   1414  1.1    rillig 	}
   1415  1.1    rillig 
   1416  1.1    rillig 	UNIQUE_CURR_POS(sym->s_def_pos);
   1417  1.1    rillig 	if ((sym->s_kind = symtyp) != FLABEL)
   1418  1.1    rillig 		sym->s_type = gettyp(INT);
   1419  1.1    rillig 
   1420  1.1    rillig 	symtyp = FVFT;
   1421  1.1    rillig 
   1422  1.1    rillig 	if ((sym->s_link = symtab[sb->sb_hash]) != NULL)
   1423  1.1    rillig 		symtab[sb->sb_hash]->s_rlink = &sym->s_link;
   1424  1.1    rillig 	sym->s_rlink = &symtab[sb->sb_hash];
   1425  1.1    rillig 	symtab[sb->sb_hash] = sym;
   1426  1.1    rillig 
   1427  1.1    rillig 	*di->d_ldlsym = sym;
   1428  1.1    rillig 	di->d_ldlsym = &sym->s_dlnxt;
   1429  1.1    rillig 
   1430  1.1    rillig 	freesb(sb);
   1431  1.1    rillig 	return sym;
   1432  1.1    rillig }
   1433  1.1    rillig 
   1434  1.1    rillig /*
   1435  1.1    rillig  * Construct a temporary symbol. The symbol starts with a digit, so that
   1436  1.1    rillig  * it is illegal.
   1437  1.1    rillig  */
   1438  1.1    rillig sym_t *
   1439  1.1    rillig mktempsym(type_t *t)
   1440  1.1    rillig {
   1441  1.1    rillig 	static int n = 0;
   1442  1.1    rillig 	int h;
   1443  1.1    rillig 	char *s = getlblk(blklev, 64);
   1444  1.1    rillig 	sym_t *sym = getblk(sizeof (sym_t));
   1445  1.1    rillig 
   1446  1.1    rillig 	(void)snprintf(s, 64, "%.8d_tmp", n++);
   1447  1.1    rillig 	h = hash(s);
   1448  1.1    rillig 
   1449  1.1    rillig 	sym->s_name = s;
   1450  1.1    rillig 	sym->s_type = t;
   1451  1.1    rillig 	sym->s_blklev = blklev;
   1452  1.1    rillig 	sym->s_scl = AUTO;
   1453  1.1    rillig 	sym->s_kind = FVFT;
   1454  1.1    rillig 	sym->s_used = true;
   1455  1.1    rillig 	sym->s_set = true;
   1456  1.1    rillig 
   1457  1.1    rillig 	if ((sym->s_link = symtab[h]) != NULL)
   1458  1.1    rillig 		symtab[h]->s_rlink = &sym->s_link;
   1459  1.1    rillig 	sym->s_rlink = &symtab[h];
   1460  1.1    rillig 	symtab[h] = sym;
   1461  1.1    rillig 
   1462  1.1    rillig 	*dcs->d_ldlsym = sym;
   1463  1.1    rillig 	dcs->d_ldlsym = &sym->s_dlnxt;
   1464  1.1    rillig 
   1465  1.1    rillig 	return sym;
   1466  1.1    rillig }
   1467  1.1    rillig 
   1468  1.1    rillig /*
   1469  1.1    rillig  * Remove a symbol forever from the symbol table. s_blklev
   1470  1.1    rillig  * is set to -1 to avoid that the symbol will later be put
   1471  1.1    rillig  * back to the symbol table.
   1472  1.1    rillig  */
   1473  1.1    rillig void
   1474  1.1    rillig rmsym(sym_t *sym)
   1475  1.1    rillig {
   1476  1.1    rillig 
   1477  1.1    rillig 	if ((*sym->s_rlink = sym->s_link) != NULL)
   1478  1.1    rillig 		sym->s_link->s_rlink = sym->s_rlink;
   1479  1.1    rillig 	sym->s_blklev = -1;
   1480  1.1    rillig 	sym->s_link = NULL;
   1481  1.1    rillig }
   1482  1.1    rillig 
   1483  1.1    rillig /*
   1484  1.1    rillig  * Remove a list of symbols declared at one level from the symbol
   1485  1.1    rillig  * table.
   1486  1.1    rillig  */
   1487  1.1    rillig void
   1488  1.1    rillig rmsyms(sym_t *syms)
   1489  1.1    rillig {
   1490  1.1    rillig 	sym_t	*sym;
   1491  1.1    rillig 
   1492  1.1    rillig 	for (sym = syms; sym != NULL; sym = sym->s_dlnxt) {
   1493  1.1    rillig 		if (sym->s_blklev != -1) {
   1494  1.1    rillig 			if ((*sym->s_rlink = sym->s_link) != NULL)
   1495  1.1    rillig 				sym->s_link->s_rlink = sym->s_rlink;
   1496  1.1    rillig 			sym->s_link = NULL;
   1497  1.1    rillig 			sym->s_rlink = NULL;
   1498  1.1    rillig 		}
   1499  1.1    rillig 	}
   1500  1.1    rillig }
   1501  1.1    rillig 
   1502  1.1    rillig /*
   1503  1.2    rillig  * Put a symbol into the symbol table.
   1504  1.1    rillig  */
   1505  1.1    rillig void
   1506  1.1    rillig inssym(int bl, sym_t *sym)
   1507  1.1    rillig {
   1508  1.1    rillig 	int	h;
   1509  1.1    rillig 
   1510  1.1    rillig 	h = hash(sym->s_name);
   1511  1.1    rillig 	if ((sym->s_link = symtab[h]) != NULL)
   1512  1.1    rillig 		symtab[h]->s_rlink = &sym->s_link;
   1513  1.1    rillig 	sym->s_rlink = &symtab[h];
   1514  1.1    rillig 	symtab[h] = sym;
   1515  1.1    rillig 	sym->s_blklev = bl;
   1516  1.1    rillig 	lint_assert(sym->s_link == NULL ||
   1517  1.1    rillig 		    sym->s_blklev >= sym->s_link->s_blklev);
   1518  1.1    rillig }
   1519  1.1    rillig 
   1520  1.1    rillig /*
   1521  1.2    rillig  * Called at level 0 after syntax errors.
   1522  1.2    rillig  *
   1523  1.1    rillig  * Removes all symbols which are not declared at level 0 from the
   1524  1.1    rillig  * symbol table. Also frees all memory which is not associated with
   1525  1.1    rillig  * level 0.
   1526  1.1    rillig  */
   1527  1.1    rillig void
   1528  1.1    rillig cleanup(void)
   1529  1.1    rillig {
   1530  1.1    rillig 	sym_t	*sym, *nsym;
   1531  1.1    rillig 	int	i;
   1532  1.1    rillig 
   1533  1.1    rillig 	for (i = 0; i < HSHSIZ1; i++) {
   1534  1.1    rillig 		for (sym = symtab[i]; sym != NULL; sym = nsym) {
   1535  1.1    rillig 			nsym = sym->s_link;
   1536  1.1    rillig 			if (sym->s_blklev >= 1) {
   1537  1.1    rillig 				if ((*sym->s_rlink = nsym) != NULL)
   1538  1.1    rillig 					nsym->s_rlink = sym->s_rlink;
   1539  1.1    rillig 			}
   1540  1.1    rillig 		}
   1541  1.1    rillig 	}
   1542  1.1    rillig 
   1543  1.1    rillig 	for (i = mblklev; i > 0; i--)
   1544  1.1    rillig 		freelblk(i);
   1545  1.1    rillig }
   1546  1.1    rillig 
   1547  1.1    rillig /*
   1548  1.1    rillig  * Create a new symbol with the name of an existing symbol.
   1549  1.1    rillig  */
   1550  1.1    rillig sym_t *
   1551  1.1    rillig pushdown(sym_t *sym)
   1552  1.1    rillig {
   1553  1.1    rillig 	int	h;
   1554  1.1    rillig 	sym_t	*nsym;
   1555  1.1    rillig 
   1556  1.1    rillig 	h = hash(sym->s_name);
   1557  1.1    rillig 	nsym = getblk(sizeof (sym_t));
   1558  1.1    rillig 	lint_assert(sym->s_blklev <= blklev);
   1559  1.1    rillig 	nsym->s_name = sym->s_name;
   1560  1.1    rillig 	UNIQUE_CURR_POS(nsym->s_def_pos);
   1561  1.1    rillig 	nsym->s_kind = sym->s_kind;
   1562  1.1    rillig 	nsym->s_blklev = blklev;
   1563  1.1    rillig 
   1564  1.1    rillig 	if ((nsym->s_link = symtab[h]) != NULL)
   1565  1.1    rillig 		symtab[h]->s_rlink = &nsym->s_link;
   1566  1.1    rillig 	nsym->s_rlink = &symtab[h];
   1567  1.1    rillig 	symtab[h] = nsym;
   1568  1.1    rillig 
   1569  1.1    rillig 	*dcs->d_ldlsym = nsym;
   1570  1.1    rillig 	dcs->d_ldlsym = &nsym->s_dlnxt;
   1571  1.1    rillig 
   1572  1.1    rillig 	return nsym;
   1573  1.1    rillig }
   1574  1.1    rillig 
   1575  1.1    rillig /*
   1576  1.1    rillig  * Free any dynamically allocated memory referenced by
   1577  1.1    rillig  * the value stack or yylval.
   1578  1.1    rillig  * The type of information in yylval is described by tok.
   1579  1.1    rillig  */
   1580  1.1    rillig void
   1581  1.1    rillig freeyyv(void *sp, int tok)
   1582  1.1    rillig {
   1583  1.1    rillig 	if (tok == T_NAME || tok == T_TYPENAME) {
   1584  1.1    rillig 		sbuf_t *sb = *(sbuf_t **)sp;
   1585  1.1    rillig 		freesb(sb);
   1586  1.1    rillig 	} else if (tok == T_CON) {
   1587  1.1    rillig 		val_t *val = *(val_t **)sp;
   1588  1.1    rillig 		free(val);
   1589  1.1    rillig 	} else if (tok == T_STRING) {
   1590  1.1    rillig 		strg_t *strg = *(strg_t **)sp;
   1591  1.1    rillig 		if (strg->st_tspec == CHAR) {
   1592  1.1    rillig 			free(strg->st_cp);
   1593  1.1    rillig 		} else {
   1594  1.1    rillig 			lint_assert(strg->st_tspec == WCHAR);
   1595  1.1    rillig 			free(strg->st_wcp);
   1596  1.1    rillig 		}
   1597  1.1    rillig 		free(strg);
   1598  1.1    rillig 	}
   1599  1.1    rillig }
   1600