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