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