?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Attribute "sentinel"
[smatch.git] / parse.c
blob43396578da920a2754d17b89183e0e8dbaf0455f
1 /*
2 * Stupid C parser, version 1e-6.
3 *
4 * Let's see how hard this is to do.
5 *
6 * Copyright (C) 2003 Transmeta Corp.
7 * 2003-2004 Linus Torvalds
8 *
9 * Licensed under the Open Software License version 1.1
10 */
11
12 #include <stdarg.h>
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <string.h>
16 #include <ctype.h>
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <limits.h>
20
21 #include "lib.h"
22 #include "allocate.h"
23 #include "token.h"
24 #include "parse.h"
25 #include "symbol.h"
26 #include "scope.h"
27 #include "expression.h"
28 #include "target.h"
29
30 #define warn_on_mixed (1)
31
32 static struct symbol_list **function_symbol_list;
33 struct symbol_list *function_computed_target_list;
34 struct statement_list *function_computed_goto_list;
35
36 static struct token *statement(struct token *token, struct statement **tree);
37
38 // Add a symbol to the list of function-local symbols
39 static void fn_local_symbol(struct symbol *sym)
40 {
41 if (function_symbol_list)
42 add_symbol(function_symbol_list, sym);
43 }
44
45 static int match_idents(struct token *token, ...)
46 {
47 va_list args;
48
49 if (token_type(token) != TOKEN_IDENT)
50 return 0;
51
52 va_start(args, token);
53 for (;;) {
54 struct ident * next = va_arg(args, struct ident *);
55 if (!next)
56 return 0;
57 if (token->ident == next)
58 return 1;
59 }
60 }
61
62
63 struct statement *alloc_statement(struct position pos, int type)
64 {
65 struct statement *stmt = __alloc_statement(0);
66 stmt->type = type;
67 stmt->pos = pos;
68 return stmt;
69 }
70
71 static struct token *struct_declaration_list(struct token *token, struct symbol_list **list);
72
73 static struct symbol * indirect(struct position pos, struct ctype *ctype, int type)
74 {
75 struct symbol *sym = alloc_symbol(pos, type);
76
77 sym->ctype.base_type = ctype->base_type;
78 sym->ctype.modifiers = ctype->modifiers & ~MOD_STORAGE;
79
80 ctype->base_type = sym;
81 ctype->modifiers &= MOD_STORAGE;
82 return sym;
83 }
84
85 static struct symbol *lookup_or_create_symbol(enum namespace ns, enum type type, struct token *token)
86 {
87 struct symbol *sym = lookup_symbol(token->ident, ns);
88 if (!sym) {
89 sym = alloc_symbol(token->pos, type);
90 bind_symbol(sym, token->ident, ns);
91 if (type == SYM_LABEL)
92 fn_local_symbol(sym);
93 }
94 return sym;
95 }
96
97 /*
98 * NOTE! NS_LABEL is not just a different namespace,
99 * it also ends up using function scope instead of the
100 * regular symbol scope.
101 */
102 struct symbol *label_symbol(struct token *token)
103 {
104 return lookup_or_create_symbol(NS_LABEL, SYM_LABEL, token);
105 }
106
107 static struct token *struct_union_enum_specifier(enum type type,
108 struct token *token, struct ctype *ctype,
109 struct token *(*parse)(struct token *, struct symbol *))
110 {
111 struct symbol *sym;
112 struct position *repos;
113
114 ctype->modifiers = 0;
115 if (token_type(token) == TOKEN_IDENT) {
116 sym = lookup_symbol(token->ident, NS_STRUCT);
117 if (!sym ||
118 (sym->scope != block_scope &&
119 (match_op(token->next,';') || match_op(token->next,'{')))) {
120 // Either a new symbol, or else an out-of-scope
121 // symbol being redefined.
122 sym = alloc_symbol(token->pos, type);
123 bind_symbol(sym, token->ident, NS_STRUCT);
124 }
125 if (sym->type != type)
126 error_die(token->pos, "invalid tag applied to %s", show_typename (sym));
127 ctype->base_type = sym;
128 repos = &token->pos;
129 token = token->next;
130 if (match_op(token, '{')) {
131 // The following test is actually wrong for empty
132 // structs, but (1) they are not C99, (2) gcc does
133 // the same thing, and (3) it's easier.
134 if (sym->symbol_list)
135 error_die(token->pos, "redefinition of %s", show_typename (sym));
136 sym->pos = *repos;
137 token = parse(token->next, sym);
138 token = expect(token, '}', "at end of struct-union-enum-specifier");
139
140 // Mark the structure as needing re-examination
141 sym->examined = 0;
142 }
143 return token;
144 }
145
146 // private struct/union/enum type
147 if (!match_op(token, '{')) {
148 sparse_error(token->pos, "expected declaration");
149 ctype->base_type = &bad_ctype;
150 return token;
151 }
152
153 sym = alloc_symbol(token->pos, type);
154 token = parse(token->next, sym);
155 ctype->base_type = sym;
156 return expect(token, '}', "at end of specifier");
157 }
158
159 static struct token *parse_struct_declaration(struct token *token, struct symbol *sym)
160 {
161 return struct_declaration_list(token, &sym->symbol_list);
162 }
163
164 static struct token *struct_or_union_specifier(enum type type, struct token *token, struct ctype *ctype)
165 {
166 return struct_union_enum_specifier(type, token, ctype, parse_struct_declaration);
167 }
168
169 typedef struct {
170 int x;
171 unsigned long long y;
172 } Num;
173
174 static void upper_boundary(Num *n, Num *v)
175 {
176 if (n->x > v->x)
177 return;
178 if (n->x < v->x) {
179 *n = *v;
180 return;
181 }
182 if (n->y < v->y)
183 n->y = v->y;
184 }
185
186 static void lower_boundary(Num *n, Num *v)
187 {
188 if (n->x < v->x)
189 return;
190 if (n->x > v->x) {
191 *n = *v;
192 return;
193 }
194 if (n->y > v->y)
195 n->y = v->y;
196 }
197
198 static int type_is_ok(struct symbol *type, Num *upper, Num *lower)
199 {
200 int shift = type->bit_size;
201 int is_unsigned = type->ctype.modifiers & MOD_UNSIGNED;
202
203 if (!is_unsigned)
204 shift--;
205 if (upper->x == 0 && upper->y >> shift)
206 return 0;
207 if (lower->x == 0 || (!is_unsigned && (~lower->y >> shift) == 0))
208 return 1;
209 return 0;
210 }
211
212 static struct symbol *bigger_enum_type(struct symbol *s1, struct symbol *s2)
213 {
214 if (s1->bit_size < s2->bit_size) {
215 s1 = s2;
216 } else if (s1->bit_size == s2->bit_size) {
217 if (s2->ctype.modifiers & MOD_UNSIGNED)
218 s1 = s2;
219 }
220 if (s1->bit_size < bits_in_int)
221 return &int_ctype;
222 return s1;
223 }
224
225 static void cast_enum_list(struct symbol_list *list, struct symbol *base_type)
226 {
227 struct symbol *sym;
228
229 FOR_EACH_PTR(list, sym) {
230 struct expression *expr = sym->initializer;
231 struct symbol *ctype;
232 if (expr->type != EXPR_VALUE)
233 continue;
234 ctype = expr->ctype;
235 if (ctype->bit_size == base_type->bit_size)
236 continue;
237 cast_value(expr, base_type, expr, ctype);
238 } END_FOR_EACH_PTR(sym);
239 }
240
241 static struct token *parse_enum_declaration(struct token *token, struct symbol *parent)
242 {
243 unsigned long long lastval = 0;
244 struct symbol *ctype = NULL, *base_type = NULL;
245 Num upper = {-1, 0}, lower = {1, 0};
246 struct symbol_list *entries = NULL;
247
248 parent->examined = 1;
249 parent->ctype.base_type = &int_ctype;
250 while (token_type(token) == TOKEN_IDENT) {
251 struct expression *expr = NULL;
252 struct token *next = token->next;
253 struct symbol *sym;
254
255 sym = alloc_symbol(token->pos, SYM_NODE);
256 bind_symbol(sym, token->ident, NS_SYMBOL);
257 sym->ctype.modifiers &= ~MOD_ADDRESSABLE;
258
259 if (match_op(next, '=')) {
260 next = constant_expression(next->next, &expr);
261 lastval = get_expression_value(expr);
262 ctype = &void_ctype;
263 if (expr && expr->ctype)
264 ctype = expr->ctype;
265 } else if (!ctype) {
266 ctype = &int_ctype;
267 } else if (is_int_type(ctype)) {
268 lastval++;
269 } else {
270 error_die(token->pos, "can't increment the last enum member");
271 }
272
273 if (!expr) {
274 expr = alloc_expression(token->pos, EXPR_VALUE);
275 expr->value = lastval;
276 expr->ctype = ctype;
277 }
278
279 sym->initializer = expr;
280 sym->ctype.base_type = parent;
281 add_ptr_list(&entries, sym);
282
283 if (base_type != &bad_ctype) {
284 if (ctype->type == SYM_NODE)
285 ctype = ctype->ctype.base_type;
286 if (ctype->type == SYM_ENUM) {
287 if (ctype == parent)
288 ctype = base_type;
289 else
290 ctype = ctype->ctype.base_type;
291 }
292 /*
293 * base_type rules:
294 * - if all enum's are of the same type, then
295 * the base_type is that type (two first
296 * cases)
297 * - if enums are of different types, they
298 * all have to be integer types, and the
299 * base type is at least "int_ctype".
300 * - otherwise the base_type is "bad_ctype".
301 */
302 if (!base_type) {
303 base_type = ctype;
304 } else if (ctype == base_type) {
305 /* nothing */
306 } else if (is_int_type(base_type) && is_int_type(ctype)) {
307 base_type = bigger_enum_type(base_type, ctype);
308 } else
309 base_type = &bad_ctype;
310 parent->ctype.base_type = base_type;
311 }
312 if (is_int_type(base_type)) {
313 Num v = {.y = lastval};
314 if (ctype->ctype.modifiers & MOD_UNSIGNED)
315 v.x = 0;
316 else if ((long long)lastval >= 0)
317 v.x = 0;
318 else
319 v.x = -1;
320 upper_boundary(&upper, &v);
321 lower_boundary(&lower, &v);
322 }
323 token = next;
324 if (!match_op(token, ','))
325 break;
326 token = token->next;
327 }
328 if (!base_type) {
329 sparse_error(token->pos, "bad enum definition");
330 base_type = &bad_ctype;
331 }
332 else if (!is_int_type(base_type))
333 base_type = base_type;
334 else if (type_is_ok(base_type, &upper, &lower))
335 base_type = base_type;
336 else if (type_is_ok(&int_ctype, &upper, &lower))
337 base_type = &int_ctype;
338 else if (type_is_ok(&uint_ctype, &upper, &lower))
339 base_type = &uint_ctype;
340 else if (type_is_ok(&long_ctype, &upper, &lower))
341 base_type = &long_ctype;
342 else if (type_is_ok(&ulong_ctype, &upper, &lower))
343 base_type = &ulong_ctype;
344 else if (type_is_ok(&llong_ctype, &upper, &lower))
345 base_type = &llong_ctype;
346 else if (type_is_ok(&ullong_ctype, &upper, &lower))
347 base_type = &ullong_ctype;
348 else
349 base_type = &bad_ctype;
350 parent->ctype.base_type = base_type;
351 parent->ctype.modifiers |= (base_type->ctype.modifiers & MOD_UNSIGNED);
352 parent->examined = 0;
353
354 cast_enum_list(entries, base_type);
355 free_ptr_list(&entries);
356
357 return token;
358 }
359
360 static struct token *enum_specifier(struct token *token, struct ctype *ctype)
361 {
362 struct token *ret = struct_union_enum_specifier(SYM_ENUM, token, ctype, parse_enum_declaration);
363
364 ctype = &ctype->base_type->ctype;
365 if (!ctype->base_type)
366 ctype->base_type = &incomplete_ctype;
367
368 return ret;
369 }
370
371 static struct token *typeof_specifier(struct token *token, struct ctype *ctype)
372 {
373 struct symbol *sym;
374
375 if (!match_op(token, '(')) {
376 sparse_error(token->pos, "expected '(' after typeof");
377 return token;
378 }
379 if (lookup_type(token->next)) {
380 token = typename(token->next, &sym);
381 *ctype = sym->ctype;
382 } else {
383 struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
384 token = parse_expression(token->next, &typeof_sym->initializer);
385
386 ctype->modifiers = 0;
387 ctype->base_type = typeof_sym;
388 }
389 return expect(token, ')', "after typeof");
390 }
391
392 static const char * handle_attribute(struct ctype *ctype, struct ident *attribute, struct expression *expr)
393 {
394 if (attribute == &packed_ident ||
395 attribute == &__packed___ident) {
396 ctype->alignment = 1;
397 return NULL;
398 }
399 if (attribute == &aligned_ident ||
400 attribute == &__aligned___ident) {
401 int alignment = max_alignment;
402 if (expr)
403 alignment = get_expression_value(expr);
404 ctype->alignment = alignment;
405 return NULL;
406 }
407 if (attribute == &nocast_ident) {
408 ctype->modifiers |= MOD_NOCAST;
409 return NULL;
410 }
411 if (attribute == &noderef_ident) {
412 ctype->modifiers |= MOD_NODEREF;
413 return NULL;
414 }
415 if (attribute == &safe_ident) {
416 ctype->modifiers |= MOD_SAFE;
417 return NULL;
418 }
419 if (attribute == &force_ident) {
420 ctype->modifiers |= MOD_FORCE;
421 return NULL;
422 }
423 if (attribute == &bitwise_ident ||
424 attribute == &__bitwise___ident) {
425 if (Wbitwise)
426 ctype->modifiers |= MOD_BITWISE;
427 return NULL;
428 }
429 if (attribute == &address_space_ident) {
430 if (!expr)
431 return "expected address space number";
432 ctype->as = get_expression_value(expr);
433 return NULL;
434 }
435 if (attribute == &context_ident) {
436 if (expr && expr->type == EXPR_COMMA) {
437 int input = get_expression_value(expr->left);
438 int output = get_expression_value(expr->right);
439 ctype->in_context = input;
440 ctype->out_context = output;
441 return NULL;
442 }
443 return "expected context input/output values";
444 }
445 if (attribute == &mode_ident ||
446 attribute == &__mode___ident) {
447 if (expr && expr->type == EXPR_SYMBOL) {
448 struct ident *ident = expr->symbol_name;
449
450 /*
451 * Match against __QI__/__HI__/__SI__/__DI__
452 *
453 * FIXME! This is broken - we don't actually get
454 * the type information updated properly at this
455 * stage for some reason.
456 */
457 if (ident == &__QI___ident ||
458 ident == &QI_ident) {
459 ctype->modifiers |= MOD_CHAR;
460 return NULL;
461 }
462 if (ident == &__HI___ident ||
463 ident == &HI_ident) {
464 ctype->modifiers |= MOD_SHORT;
465 return NULL;
466 }
467 if (ident == &__SI___ident ||
468 ident == &SI_ident) {
469 /* Nothing? */
470 return NULL;
471 }
472 if (ident == &__DI___ident ||
473 ident == &DI_ident) {
474 ctype->modifiers |= MOD_LONGLONG;
475 return NULL;
476 }
477 if (ident == &__word___ident ||
478 ident == &word_ident) {
479 ctype->modifiers |= MOD_LONG;
480 return NULL;
481 }
482 return "unknown mode attribute";
483 }
484 return "expected attribute mode symbol";
485 }
486
487 /* Throw away for now.. */
488 if (attribute == &__transparent_union___ident) {
489 if (Wtransparent_union)
490 return "ignoring attribute __transparent_union__";
491 return NULL;
492 }
493 if (attribute == &nothrow_ident ||
494 attribute == &__nothrow_ident ||
495 attribute == &__nothrow___ident)
496 return NULL;
497 if (attribute == &__malloc___ident)
498 return NULL;
499 if (attribute == &nonnull_ident ||
500 attribute == &__nonnull_ident ||
501 attribute == &__nonnull___ident)
502 return NULL;
503 if (attribute == &format_ident ||
504 attribute == &__format___ident ||
505 attribute == &__format_arg___ident)
506 return NULL;
507 if (attribute == &section_ident ||
508 attribute == &__section___ident)
509 return NULL;
510 if (attribute == &unused_ident ||
511 attribute == &__unused___ident)
512 return NULL;
513 if (attribute == &const_ident ||
514 attribute == &__const_ident ||
515 attribute == &__const___ident)
516 return NULL;
517 if (attribute == &noreturn_ident ||
518 attribute == &__noreturn___ident)
519 return NULL;
520 if (attribute == &sentinel_ident ||
521 attribute == &__sentinel___ident)
522 return NULL;
523 if (attribute == &regparm_ident)
524 return NULL;
525 if (attribute == &weak_ident ||
526 attribute == &__weak___ident)
527 return NULL;
528 if (attribute == &alias_ident)
529 return NULL;
530 if (attribute == &pure_ident ||
531 attribute == &__pure___ident)
532 return NULL;
533 if (attribute == &always_inline_ident)
534 return NULL;
535 if (attribute == &syscall_linkage_ident)
536 return NULL;
537 if (attribute == &visibility_ident)
538 return NULL;
539 if (attribute == &deprecated_ident ||
540 attribute == &__deprecated___ident)
541 return NULL;
542 if (attribute == &noinline_ident)
543 return NULL;
544 if (attribute == &__used___ident)
545 return NULL;
546 if (attribute == &warn_unused_result_ident ||
547 attribute == &__warn_unused_result___ident)
548 return NULL;
549 if (attribute == &model_ident ||
550 attribute == &__model___ident)
551 return NULL;
552
553 return "unknown attribute";
554 }
555
556 static struct token *attribute_specifier(struct token *token, struct ctype *ctype)
557 {
558 ctype->modifiers = 0;
559 token = expect(token, '(', "after attribute");
560 token = expect(token, '(', "after attribute");
561
562 for (;;) {
563 const char *error_str;
564 struct ident *attribute_name;
565 struct expression *attribute_expr;
566
567 if (eof_token(token))
568 break;
569 if (match_op(token, ';'))
570 break;
571 if (token_type(token) != TOKEN_IDENT)
572 break;
573 attribute_name = token->ident;
574 token = token->next;
575 attribute_expr = NULL;
576 if (match_op(token, '('))
577 token = parens_expression(token, &attribute_expr, "in attribute");
578 error_str = handle_attribute(ctype, attribute_name, attribute_expr);
579 if (error_str)
580 sparse_error(token->pos, "attribute '%s': %s", show_ident(attribute_name), error_str);
581 if (!match_op(token, ','))
582 break;
583 token = token->next;
584 }
585
586 token = expect(token, ')', "after attribute");
587 token = expect(token, ')', "after attribute");
588 return token;
589 }
590
591 struct symbol * ctype_integer(unsigned long spec)
592 {
593 static struct symbol *const integer_ctypes[][3] = {
594 { &llong_ctype, &sllong_ctype, &ullong_ctype },
595 { &long_ctype, &slong_ctype, &ulong_ctype },
596 { &short_ctype, &sshort_ctype, &ushort_ctype },
597 { &char_ctype, &schar_ctype, &uchar_ctype },
598 { &int_ctype, &sint_ctype, &uint_ctype },
599 };
600 struct symbol *const (*ctype)[3];
601 int sub;
602
603 ctype = integer_ctypes;
604 if (!(spec & MOD_LONGLONG)) {
605 ctype++;
606 if (!(spec & MOD_LONG)) {
607 ctype++;
608 if (!(spec & MOD_SHORT)) {
609 ctype++;
610 if (!(spec & MOD_CHAR))
611 ctype++;
612 }
613 }
614 }
615
616 sub = ((spec & MOD_UNSIGNED)
617 ? 2
618 : ((spec & MOD_EXPLICITLY_SIGNED)
619 ? 1
620 : 0));
621
622 return ctype[0][sub];
623 }
624
625 struct symbol * ctype_fp(unsigned long spec)
626 {
627 if (spec & MOD_LONGLONG)
628 return &ldouble_ctype;
629 if (spec & MOD_LONG)
630 return &double_ctype;
631 return &float_ctype;
632 }
633
634 static void apply_ctype(struct position pos, struct ctype *thistype, struct ctype *ctype)
635 {
636 unsigned long mod = thistype->modifiers;
637
638 if (mod) {
639 unsigned long old = ctype->modifiers;
640 unsigned long extra = 0, dup, conflict;
641
642 if (mod & old & MOD_LONG) {
643 extra = MOD_LONGLONG | MOD_LONG;
644 mod &= ~MOD_LONG;
645 old &= ~MOD_LONG;
646 }
647 dup = (mod & old) | (extra & old) | (extra & mod);
648 if (dup)
649 sparse_error(pos, "Just how %sdo you want this type to be?",
650 modifier_string(dup));
651
652 conflict = !(~mod & ~old & (MOD_LONG | MOD_SHORT));
653 if (conflict)
654 sparse_error(pos, "You cannot have both long and short modifiers.");
655
656 conflict = !(~mod & ~old & (MOD_SIGNED | MOD_UNSIGNED));
657 if (conflict)
658 sparse_error(pos, "You cannot have both signed and unsigned modifiers.");
659
660 // Only one storage modifier allowed, except that "inline" doesn't count.
661 conflict = (mod | old) & (MOD_STORAGE & ~MOD_INLINE);
662 conflict &= (conflict - 1);
663 if (conflict)
664 sparse_error(pos, "multiple storage classes");
665
666 ctype->modifiers = old | mod | extra;
667 }
668
669 /* Context mask and value */
670 ctype->in_context += thistype->in_context;
671 ctype->out_context += thistype->out_context;
672
673 /* Alignment */
674 if (thistype->alignment & (thistype->alignment-1)) {
675 warning(pos, "I don't like non-power-of-2 alignments");
676 thistype->alignment = 0;
677 }
678 if (thistype->alignment > ctype->alignment)
679 ctype->alignment = thistype->alignment;
680
681 /* Address space */
682 if (thistype->as)
683 ctype->as = thistype->as;
684 }
685
686 static void check_modifiers(struct position *pos, struct symbol *s, unsigned long mod)
687 {
688 unsigned long banned, wrong;
689 unsigned long this_mod = s->ctype.modifiers;
690 const unsigned long BANNED_SIZE = MOD_LONG | MOD_LONGLONG | MOD_SHORT;
691 const unsigned long BANNED_SIGN = MOD_SIGNED | MOD_UNSIGNED;
692
693 if (this_mod & (MOD_STRUCTOF | MOD_UNIONOF | MOD_ENUMOF))
694 banned = BANNED_SIZE | BANNED_SIGN;
695 else if (this_mod & MOD_SPECIALBITS)
696 banned = 0;
697 else if (s->ctype.base_type == &fp_type)
698 banned = BANNED_SIGN;
699 else if (s->ctype.base_type == &int_type || !s->ctype.base_type || is_int_type (s))
700 banned = 0;
701 else {
702 // label_type
703 // void_type
704 // bad_type
705 // vector_type <-- whatever that is
706 banned = BANNED_SIZE | BANNED_SIGN;
707 }
708
709 wrong = mod & banned;
710 if (wrong)
711 sparse_error(*pos, "modifier %sis invalid in this context",
712 modifier_string (wrong));
713 }
714
715
716 static struct token *declaration_specifiers(struct token *next, struct ctype *ctype, int qual)
717 {
718 struct token *token;
719
720 while ( (token = next) != NULL ) {
721 struct ctype thistype;
722 struct ident *ident;
723 struct symbol *s, *type;
724 unsigned long mod;
725
726 next = token->next;
727 if (token_type(token) != TOKEN_IDENT)
728 break;
729 ident = token->ident;
730
731 s = lookup_symbol(ident, NS_TYPEDEF);
732 if (!s)
733 break;
734 thistype = s->ctype;
735 mod = thistype.modifiers;
736 if (qual && (mod & ~(MOD_ATTRIBUTE | MOD_CONST | MOD_VOLATILE)))
737 break;
738 if (mod & MOD_SPECIALBITS) {
739 if (mod & MOD_STRUCTOF)
740 next = struct_or_union_specifier(SYM_STRUCT, next, &thistype);
741 else if (mod & MOD_UNIONOF)
742 next = struct_or_union_specifier(SYM_UNION, next, &thistype);
743 else if (mod & MOD_ENUMOF)
744 next = enum_specifier(next, &thistype);
745 else if (mod & MOD_ATTRIBUTE)
746 next = attribute_specifier(next, &thistype);
747 else if (mod & MOD_TYPEOF)
748 next = typeof_specifier(next, &thistype);
749 mod = thistype.modifiers;
750 }
751 type = thistype.base_type;
752 if (type) {
753 if (qual)
754 break;
755 if (ctype->base_type)
756 break;
757 /* User types only mix with qualifiers */
758 if (mod & MOD_USERTYPE) {
759 if (ctype->modifiers & MOD_SPECIFIER)
760 break;
761 }
762 ctype->base_type = type;
763 }
764
765 check_modifiers(&token->pos, s, ctype->modifiers);
766 apply_ctype(token->pos, &thistype, ctype);
767 }
768
769 /* Turn the "virtual types" into real types with real sizes etc */
770 if (!ctype->base_type) {
771 struct symbol *base = &incomplete_ctype;
772
773 /*
774 * If we have modifiers, we'll default to an integer
775 * type, and "ctype_integer()" will turn this into
776 * a specific one.
777 */
778 if (ctype->modifiers & MOD_SPECIFIER)
779 base = &int_type;
780 ctype->base_type = base;
781 }
782 if (ctype->base_type == &int_type) {
783 ctype->base_type = ctype_integer(ctype->modifiers);
784 ctype->modifiers &= ~MOD_SPECIFIER;
785 } else if (ctype->base_type == &fp_type) {
786 ctype->base_type = ctype_fp(ctype->modifiers);
787 ctype->modifiers &= ~MOD_SPECIFIER;
788 }
789 if (ctype->modifiers & MOD_BITWISE) {
790 struct symbol *type;
791 ctype->modifiers &= ~(MOD_BITWISE | MOD_SPECIFIER);
792 if (!is_int_type(ctype->base_type)) {
793 sparse_error(token->pos, "invalid modifier");
794 return token;
795 }
796 type = alloc_symbol(token->pos, SYM_BASETYPE);
797 *type = *ctype->base_type;
798 type->ctype.base_type = ctype->base_type;
799 type->type = SYM_RESTRICT;
800 type->ctype.modifiers &= ~MOD_SPECIFIER;
801 ctype->base_type = type;
802 }
803 return token;
804 }
805
806 static struct token *abstract_array_declarator(struct token *token, struct symbol *sym)
807 {
808 struct expression *expr = NULL;
809
810 token = parse_expression(token, &expr);
811 sym->array_size = expr;
812 return token;
813 }
814
815 static struct token *parameter_type_list(struct token *, struct symbol *, struct ident **p);
816 static struct token *declarator(struct token *token, struct symbol *sym, struct ident **p);
817
818 static struct token *handle_attributes(struct token *token, struct ctype *ctype)
819 {
820 for (;;) {
821 if (token_type(token) != TOKEN_IDENT)
822 break;
823 if (match_idents(token, &__attribute___ident, &__attribute_ident, NULL)) {
824 struct ctype thistype = { 0, };
825 token = attribute_specifier(token->next, &thistype);
826 apply_ctype(token->pos, &thistype, ctype);
827 continue;
828 }
829 if (match_idents(token, &asm_ident, &__asm_ident, &__asm___ident)) {
830 struct expression *expr;
831 token = expect(token->next, '(', "after asm");
832 token = parse_expression(token->next, &expr);
833 token = expect(token, ')', "after asm");
834 continue;
835 }
836 break;
837 }
838 return token;
839 }
840
841 static struct token *direct_declarator(struct token *token, struct symbol *decl, struct ident **p)
842 {
843 struct ctype *ctype = &decl->ctype;
844
845 if (p && token_type(token) == TOKEN_IDENT) {
846 *p = token->ident;
847 token = token->next;
848 }
849
850 for (;;) {
851 token = handle_attributes(token, ctype);
852
853 if (token_type(token) != TOKEN_SPECIAL)
854 return token;
855
856 /*
857 * This can be either a parameter list or a grouping.
858 * For the direct (non-abstract) case, we know if must be
859 * a parameter list if we already saw the identifier.
860 * For the abstract case, we know if must be a parameter
861 * list if it is empty or starts with a type.
862 */
863 if (token->special == '(') {
864 struct symbol *sym;
865 struct token *next = token->next;
866 int fn = (p && *p) || match_op(next, ')') || lookup_type(next);
867
868 if (!fn) {
869 struct symbol *base_type = ctype->base_type;
870 token = declarator(next, decl, p);
871 token = expect(token, ')', "in nested declarator");
872 while (ctype->base_type != base_type)
873 ctype = &ctype->base_type->ctype;
874 p = NULL;
875 continue;
876 }
877
878 sym = indirect(token->pos, ctype, SYM_FN);
879 token = parameter_type_list(next, sym, p);
880 token = expect(token, ')', "in function declarator");
881 continue;
882 }
883 if (token->special == '[') {
884 struct symbol *array = indirect(token->pos, ctype, SYM_ARRAY);
885 token = abstract_array_declarator(token->next, array);
886 token = expect(token, ']', "in abstract_array_declarator");
887 ctype = &array->ctype;
888 continue;
889 }
890 break;
891 }
892 return token;
893 }
894
895 static struct token *pointer(struct token *token, struct ctype *ctype)
896 {
897 unsigned long modifiers;
898 struct symbol *base_type;
899
900 modifiers = ctype->modifiers & ~(MOD_TYPEDEF | MOD_ATTRIBUTE);
901 base_type = ctype->base_type;
902 ctype->modifiers = modifiers;
903
904 while (match_op(token,'*')) {
905 struct symbol *ptr = alloc_symbol(token->pos, SYM_PTR);
906 ptr->ctype.modifiers = modifiers & ~MOD_STORAGE;
907 ptr->ctype.as = ctype->as;
908 ptr->ctype.in_context += ctype->in_context;
909 ptr->ctype.out_context += ctype->out_context;
910 ptr->ctype.base_type = base_type;
911
912 base_type = ptr;
913 ctype->modifiers = modifiers & MOD_STORAGE;
914 ctype->base_type = base_type;
915 ctype->as = 0;
916 ctype->in_context = 0;
917 ctype->out_context = 0;
918
919 token = declaration_specifiers(token->next, ctype, 1);
920 modifiers = ctype->modifiers;
921 }
922 return token;
923 }
924
925 static struct token *declarator(struct token *token, struct symbol *sym, struct ident **p)
926 {
927 token = pointer(token, &sym->ctype);
928 return direct_declarator(token, sym, p);
929 }
930
931 static struct token *handle_bitfield(struct token *token, struct symbol *decl)
932 {
933 struct ctype *ctype = &decl->ctype;
934 struct expression *expr;
935 struct symbol *bitfield;
936 long long width;
937
938 if (!is_int_type(ctype->base_type)) {
939 sparse_error(token->pos, "invalid bitfield specifier for type %s.",
940 show_typename(ctype->base_type));
941 // Parse this to recover gracefully.
942 return conditional_expression(token->next, &expr);
943 }
944
945 bitfield = indirect(token->pos, ctype, SYM_BITFIELD);
946 token = conditional_expression(token->next, &expr);
947 width = get_expression_value(expr);
948 bitfield->bit_size = width;
949
950 if (width < 0 || width > INT_MAX) {
951 sparse_error(token->pos, "invalid bitfield width, %lld.", width);
952 width = -1;
953 } else if (decl->ident && width == 0) {
954 sparse_error(token->pos, "invalid named zero-width bitfield `%s'",
955 show_ident(decl->ident));
956 width = -1;
957 } else if (decl->ident) {
958 struct symbol *base_type = bitfield->ctype.base_type;
959 int is_signed = !(base_type->ctype.modifiers & MOD_UNSIGNED);
960 if (Wone_bit_signed_bitfield && width == 1 && is_signed) {
961 // Valid values are either {-1;0} or {0}, depending on integer
962 // representation. The latter makes for very efficient code...
963 sparse_error(token->pos, "dubious one-bit signed bitfield");
964 }
965 if (Wdefault_bitfield_sign &&
966 base_type->type != SYM_ENUM &&
967 !(base_type->ctype.modifiers & MOD_EXPLICITLY_SIGNED) &&
968 is_signed) {
969 // The sign of bitfields is unspecified by default.
970 sparse_error(token->pos, "dubious bitfield without explicit `signed' or `unsigned'");
971 }
972 }
973 bitfield->bit_size = width;
974 return token;
975 }
976
977 static struct token *declaration_list(struct token *token, struct symbol_list **list)
978 {
979 struct ctype ctype = {0, };
980
981 token = declaration_specifiers(token, &ctype, 0);
982 for (;;) {
983 struct ident *ident = NULL;
984 struct symbol *decl = alloc_symbol(token->pos, SYM_NODE);
985 decl->ctype = ctype;
986 token = declarator(token, decl, &ident);
987 decl->ident = ident;
988 if (match_op(token, ':')) {
989 token = handle_bitfield(token, decl);
990 token = handle_attributes(token, &decl->ctype);
991 }
992 add_symbol(list, decl);
993 if (!match_op(token, ','))
994 break;
995 token = token->next;
996 }
997 return token;
998 }
999
1000 static struct token *struct_declaration_list(struct token *token, struct symbol_list **list)
1001 {
1002 while (!match_op(token, '}')) {
1003 token = declaration_list(token, list);
1004 if (!match_op(token, ';')) {
1005 sparse_error(token->pos, "expected ; at end of declaration");
1006 break;
1007 }
1008 token = token->next;
1009 }
1010 return token;
1011 }
1012
1013 static struct token *parameter_declaration(struct token *token, struct symbol **tree)
1014 {
1015 struct ident *ident = NULL;
1016 struct symbol *sym;
1017 struct ctype ctype = { 0, };
1018
1019 token = declaration_specifiers(token, &ctype, 0);
1020 sym = alloc_symbol(token->pos, SYM_NODE);
1021 sym->ctype = ctype;
1022 *tree = sym;
1023 token = declarator(token, sym, &ident);
1024 sym->ident = ident;
1025 return token;
1026 }
1027
1028 struct token *typename(struct token *token, struct symbol **p)
1029 {
1030 struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
1031 *p = sym;
1032 token = declaration_specifiers(token, &sym->ctype, 0);
1033 return declarator(token, sym, NULL);
1034 }
1035
1036 static struct token *expression_statement(struct token *token, struct expression **tree)
1037 {
1038 token = parse_expression(token, tree);
1039 return expect(token, ';', "at end of statement");
1040 }
1041
1042 static struct token *parse_asm_operands(struct token *token, struct statement *stmt,
1043 struct expression_list **inout)
1044 {
1045 struct expression *expr;
1046
1047 /* Allow empty operands */
1048 if (match_op(token->next, ':') || match_op(token->next, ')'))
1049 return token->next;
1050 do {
1051 struct ident *ident = NULL;
1052 if (match_op(token->next, '[') &&
1053 token_type(token->next->next) == TOKEN_IDENT &&
1054 match_op(token->next->next->next, ']')) {
1055 ident = token->next->next->ident;
1056 token = token->next->next->next;
1057 }
1058 add_expression(inout, (struct expression *)ident); /* UGGLEE!!! */
1059 token = primary_expression(token->next, &expr);
1060 add_expression(inout, expr);
1061 token = parens_expression(token, &expr, "in asm parameter");
1062 add_expression(inout, expr);
1063 } while (match_op(token, ','));
1064 return token;
1065 }
1066
1067 static struct token *parse_asm_clobbers(struct token *token, struct statement *stmt,
1068 struct expression_list **clobbers)
1069 {
1070 struct expression *expr;
1071
1072 do {
1073 token = primary_expression(token->next, &expr);
1074 add_expression(clobbers, expr);
1075 } while (match_op(token, ','));
1076 return token;
1077 }
1078
1079 static struct token *parse_asm(struct token *token, struct statement *stmt)
1080 {
1081 stmt->type = STMT_ASM;
1082 if (match_idents(token, &__volatile___ident, &__volatile_ident, &volatile_ident, NULL)) {
1083 token = token->next;
1084 }
1085 token = expect(token, '(', "after asm");
1086 token = parse_expression(token, &stmt->asm_string);
1087 if (match_op(token, ':'))
1088 token = parse_asm_operands(token, stmt, &stmt->asm_outputs);
1089 if (match_op(token, ':'))
1090 token = parse_asm_operands(token, stmt, &stmt->asm_inputs);
1091 if (match_op(token, ':'))
1092 token = parse_asm_clobbers(token, stmt, &stmt->asm_clobbers);
1093 token = expect(token, ')', "after asm");
1094 return expect(token, ';', "at end of asm-statement");
1095 }
1096
1097 /* Make a statement out of an expression */
1098 static struct statement *make_statement(struct expression *expr)
1099 {
1100 struct statement *stmt;
1101
1102 if (!expr)
1103 return NULL;
1104 stmt = alloc_statement(expr->pos, STMT_EXPRESSION);
1105 stmt->expression = expr;
1106 return stmt;
1107 }
1108
1109 /*
1110 * All iterators have two symbols associated with them:
1111 * the "continue" and "break" symbols, which are targets
1112 * for continue and break statements respectively.
1113 *
1114 * They are in a special name-space, but they follow
1115 * all the normal visibility rules, so nested iterators
1116 * automatically work right.
1117 */
1118 static void start_iterator(struct statement *stmt)
1119 {
1120 struct symbol *cont, *brk;
1121
1122 start_symbol_scope();
1123 cont = alloc_symbol(stmt->pos, SYM_NODE);
1124 bind_symbol(cont, &continue_ident, NS_ITERATOR);
1125 brk = alloc_symbol(stmt->pos, SYM_NODE);
1126 bind_symbol(brk, &break_ident, NS_ITERATOR);
1127
1128 stmt->type = STMT_ITERATOR;
1129 stmt->iterator_break = brk;
1130 stmt->iterator_continue = cont;
1131 fn_local_symbol(brk);
1132 fn_local_symbol(cont);
1133 }
1134
1135 static void end_iterator(struct statement *stmt)
1136 {
1137 end_symbol_scope();
1138 }
1139
1140 static struct statement *start_function(struct symbol *sym)
1141 {
1142 struct symbol *ret;
1143 struct statement *stmt = alloc_statement(sym->pos, STMT_COMPOUND);
1144
1145 start_function_scope();
1146 ret = alloc_symbol(sym->pos, SYM_NODE);
1147 ret->ctype = sym->ctype.base_type->ctype;
1148 ret->ctype.modifiers &= ~(MOD_STORAGE | MOD_CONST | MOD_VOLATILE | MOD_INLINE | MOD_ADDRESSABLE | MOD_NOCAST | MOD_NODEREF | MOD_ACCESSED | MOD_TOPLEVEL);
1149 ret->ctype.modifiers |= (MOD_AUTO | MOD_REGISTER);
1150 bind_symbol(ret, &return_ident, NS_ITERATOR);
1151 stmt->ret = ret;
1152 fn_local_symbol(ret);
1153
1154 // Currently parsed symbol for __func__/__FUNCTION__/__PRETTY_FUNCTION__
1155 current_fn = sym;
1156
1157 return stmt;
1158 }
1159
1160 static void end_function(struct symbol *sym)
1161 {
1162 current_fn = NULL;
1163 end_function_scope();
1164 }
1165
1166 /*
1167 * A "switch()" statement, like an iterator, has a
1168 * the "break" symbol associated with it. It works
1169 * exactly like the iterator break - it's the target
1170 * for any break-statements in scope, and means that
1171 * "break" handling doesn't even need to know whether
1172 * it's breaking out of an iterator or a switch.
1173 *
1174 * In addition, the "case" symbol is a marker for the
1175 * case/default statements to find the switch statement
1176 * that they are associated with.
1177 */
1178 static void start_switch(struct statement *stmt)
1179 {
1180 struct symbol *brk, *switch_case;
1181
1182 start_symbol_scope();
1183 brk = alloc_symbol(stmt->pos, SYM_NODE);
1184 bind_symbol(brk, &break_ident, NS_ITERATOR);
1185
1186 switch_case = alloc_symbol(stmt->pos, SYM_NODE);
1187 bind_symbol(switch_case, &case_ident, NS_ITERATOR);
1188 switch_case->stmt = stmt;
1189
1190 stmt->type = STMT_SWITCH;
1191 stmt->switch_break = brk;
1192 stmt->switch_case = switch_case;
1193
1194 fn_local_symbol(brk);
1195 fn_local_symbol(switch_case);
1196 }
1197
1198 static void end_switch(struct statement *stmt)
1199 {
1200 if (!stmt->switch_case->symbol_list)
1201 warning(stmt->pos, "switch with no cases");
1202 end_symbol_scope();
1203 }
1204
1205 static void add_case_statement(struct statement *stmt)
1206 {
1207 struct symbol *target = lookup_symbol(&case_ident, NS_ITERATOR);
1208 struct symbol *sym;
1209
1210 if (!target) {
1211 sparse_error(stmt->pos, "not in switch scope");
1212 stmt->type = STMT_NONE;
1213 return;
1214 }
1215 sym = alloc_symbol(stmt->pos, SYM_NODE);
1216 add_symbol(&target->symbol_list, sym);
1217 sym->stmt = stmt;
1218 stmt->case_label = sym;
1219 fn_local_symbol(sym);
1220 }
1221
1222 static struct token *parse_return_statement(struct token *token, struct statement *stmt)
1223 {
1224 struct symbol *target = lookup_symbol(&return_ident, NS_ITERATOR);
1225
1226 if (!target)
1227 error_die(token->pos, "internal error: return without a function target");
1228 stmt->type = STMT_RETURN;
1229 stmt->ret_target = target;
1230 return expression_statement(token->next, &stmt->ret_value);
1231 }
1232
1233 static struct token *parse_for_statement(struct token *token, struct statement *stmt)
1234 {
1235 struct symbol_list *syms;
1236 struct expression *e1, *e2, *e3;
1237 struct statement *iterator;
1238
1239 start_iterator(stmt);
1240 token = expect(token->next, '(', "after 'for'");
1241
1242 syms = NULL;
1243 e1 = NULL;
1244 /* C99 variable declaration? */
1245 if (lookup_type(token)) {
1246 token = external_declaration(token, &syms);
1247 } else {
1248 token = parse_expression(token, &e1);
1249 token = expect(token, ';', "in 'for'");
1250 }
1251 token = parse_expression(token, &e2);
1252 token = expect(token, ';', "in 'for'");
1253 token = parse_expression(token, &e3);
1254 token = expect(token, ')', "in 'for'");
1255 token = statement(token, &iterator);
1256
1257 stmt->iterator_syms = syms;
1258 stmt->iterator_pre_statement = make_statement(e1);
1259 stmt->iterator_pre_condition = e2;
1260 stmt->iterator_post_statement = make_statement(e3);
1261 stmt->iterator_post_condition = NULL;
1262 stmt->iterator_statement = iterator;
1263 end_iterator(stmt);
1264
1265 return token;
1266 }
1267
1268 static struct token *parse_while_statement(struct token *token, struct statement *stmt)
1269 {
1270 struct expression *expr;
1271 struct statement *iterator;
1272
1273 start_iterator(stmt);
1274 token = parens_expression(token->next, &expr, "after 'while'");
1275 token = statement(token, &iterator);
1276
1277 stmt->iterator_pre_condition = expr;
1278 stmt->iterator_post_condition = NULL;
1279 stmt->iterator_statement = iterator;
1280 end_iterator(stmt);
1281
1282 return token;
1283 }
1284
1285 static struct token *parse_do_statement(struct token *token, struct statement *stmt)
1286 {
1287 struct expression *expr;
1288 struct statement *iterator;
1289
1290 start_iterator(stmt);
1291 token = statement(token->next, &iterator);
1292 if (token_type(token) == TOKEN_IDENT && token->ident == &while_ident)
1293 token = token->next;
1294 else
1295 sparse_error(token->pos, "expected 'while' after 'do'");
1296 token = parens_expression(token, &expr, "after 'do-while'");
1297
1298 stmt->iterator_post_condition = expr;
1299 stmt->iterator_statement = iterator;
1300 end_iterator(stmt);
1301
1302 return expect(token, ';', "after statement");
1303 }
1304
1305 static struct token *statement(struct token *token, struct statement **tree)
1306 {
1307 struct statement *stmt = alloc_statement(token->pos, STMT_NONE);
1308
1309 *tree = stmt;
1310 if (token_type(token) == TOKEN_IDENT) {
1311 if (token->ident == &if_ident) {
1312 stmt->type = STMT_IF;
1313 token = parens_expression(token->next, &stmt->if_conditional, "after if");
1314 token = statement(token, &stmt->if_true);
1315 if (token_type(token) != TOKEN_IDENT)
1316 return token;
1317 if (token->ident != &else_ident)
1318 return token;
1319 return statement(token->next, &stmt->if_false);
1320 }
1321
1322 if (token->ident == &return_ident)
1323 return parse_return_statement(token, stmt);
1324
1325 if (token->ident == &break_ident || token->ident == &continue_ident) {
1326 struct symbol *target = lookup_symbol(token->ident, NS_ITERATOR);
1327 stmt->type = STMT_GOTO;
1328 stmt->goto_label = target;
1329 if (!target)
1330 sparse_error(stmt->pos, "break/continue not in iterator scope");
1331 return expect(token->next, ';', "at end of statement");
1332 }
1333 if (token->ident == &default_ident) {
1334 token = token->next;
1335 goto default_statement;
1336 }
1337 if (token->ident == &case_ident) {
1338 token = parse_expression(token->next, &stmt->case_expression);
1339 if (match_op(token, SPECIAL_ELLIPSIS))
1340 token = parse_expression(token->next, &stmt->case_to);
1341 default_statement:
1342 stmt->type = STMT_CASE;
1343 token = expect(token, ':', "after default/case");
1344 add_case_statement(stmt);
1345 return statement(token, &stmt->case_statement);
1346 }
1347 if (token->ident == &switch_ident) {
1348 stmt->type = STMT_SWITCH;
1349 start_switch(stmt);
1350 token = parens_expression(token->next, &stmt->switch_expression, "after 'switch'");
1351 token = statement(token, &stmt->switch_statement);
1352 end_switch(stmt);
1353 return token;
1354 }
1355 if (token->ident == &for_ident)
1356 return parse_for_statement(token, stmt);
1357
1358 if (token->ident == &while_ident)
1359 return parse_while_statement(token, stmt);
1360
1361 if (token->ident == &do_ident)
1362 return parse_do_statement(token, stmt);
1363
1364 if (token->ident == &goto_ident) {
1365 stmt->type = STMT_GOTO;
1366 token = token->next;
1367 if (match_op(token, '*')) {
1368 token = parse_expression(token->next, &stmt->goto_expression);
1369 add_statement(&function_computed_goto_list, stmt);
1370 } else if (token_type(token) == TOKEN_IDENT) {
1371 stmt->goto_label = label_symbol(token);
1372 token = token->next;
1373 } else {
1374 sparse_error(token->pos, "Expected identifier or goto expression");
1375 }
1376 return expect(token, ';', "at end of statement");
1377 }
1378 if (match_idents(token, &asm_ident, &__asm___ident, &__asm_ident, NULL)) {
1379 return parse_asm(token->next, stmt);
1380 }
1381 if (token->ident == &__context___ident) {
1382 stmt->type = STMT_CONTEXT;
1383 token = parse_expression(token->next, &stmt->expression);
1384 return expect(token, ';', "at end of statement");
1385 }
1386 if (token->ident == &__range___ident) {
1387 stmt->type = STMT_RANGE;
1388 token = assignment_expression(token->next, &stmt->range_expression);
1389 token = expect(token, ',', "after range expression");
1390 token = assignment_expression(token, &stmt->range_low);
1391 token = expect(token, ',', "after low range");
1392 token = assignment_expression(token, &stmt->range_high);
1393 return expect(token, ';', "after range statement");
1394 }
1395 if (match_op(token->next, ':')) {
1396 stmt->type = STMT_LABEL;
1397 stmt->label_identifier = label_symbol(token);
1398 return statement(token->next->next, &stmt->label_statement);
1399 }
1400 }
1401
1402 if (match_op(token, '{')) {
1403 stmt->type = STMT_COMPOUND;
1404 start_symbol_scope();
1405 token = compound_statement(token->next, stmt);
1406 end_symbol_scope();
1407
1408 return expect(token, '}', "at end of compound statement");
1409 }
1410
1411 stmt->type = STMT_EXPRESSION;
1412 return expression_statement(token, &stmt->expression);
1413 }
1414
1415 static struct token * statement_list(struct token *token, struct statement_list **list)
1416 {
1417 int seen_statement = 0;
1418 for (;;) {
1419 struct statement * stmt;
1420 if (eof_token(token))
1421 break;
1422 if (match_op(token, '}'))
1423 break;
1424 if (lookup_type(token)) {
1425 if (seen_statement) {
1426 warning(token->pos, "mixing declarations and code");
1427 seen_statement = 0;
1428 }
1429 stmt = alloc_statement(token->pos, STMT_DECLARATION);
1430 token = external_declaration(token, &stmt->declaration);
1431 } else {
1432 seen_statement = warn_on_mixed;
1433 token = statement(token, &stmt);
1434 }
1435 add_statement(list, stmt);
1436 }
1437 return token;
1438 }
1439
1440 static struct token *parameter_type_list(struct token *token, struct symbol *fn, struct ident **p)
1441 {
1442 struct symbol_list **list = &fn->arguments;
1443
1444 if (match_op(token, ')')) {
1445 // No warning for "void oink ();"
1446 // Bug or feature: warns for "void oink () __attribute__ ((noreturn));"
1447 if (p && !match_op(token->next, ';'))
1448 warning(token->pos, "non-ANSI function declaration of function '%s'", show_ident(*p));
1449 return token;
1450 }
1451
1452 for (;;) {
1453 struct symbol *sym;
1454
1455 if (match_op(token, SPECIAL_ELLIPSIS)) {
1456 if (!*list)
1457 warning(token->pos, "variadic functions must have one named argument");
1458 fn->variadic = 1;
1459 token = token->next;
1460 break;
1461 }
1462
1463 sym = alloc_symbol(token->pos, SYM_NODE);
1464 token = parameter_declaration(token, &sym);
1465 if (sym->ctype.base_type == &void_ctype) {
1466 /* Special case: (void) */
1467 if (!*list && !sym->ident)
1468 break;
1469 warning(token->pos, "void parameter");
1470 }
1471 add_symbol(list, sym);
1472 if (!match_op(token, ','))
1473 break;
1474 token = token->next;
1475
1476 }
1477 return token;
1478 }
1479
1480 struct token *compound_statement(struct token *token, struct statement *stmt)
1481 {
1482 token = statement_list(token, &stmt->stmts);
1483 return token;
1484 }
1485
1486 static struct expression *identifier_expression(struct token *token)
1487 {
1488 struct expression *expr = alloc_expression(token->pos, EXPR_IDENTIFIER);
1489 expr->expr_ident = token->ident;
1490 return expr;
1491 }
1492
1493 static struct expression *index_expression(struct expression *from, struct expression *to)
1494 {
1495 int idx_from, idx_to;
1496 struct expression *expr = alloc_expression(from->pos, EXPR_INDEX);
1497
1498 idx_from = get_expression_value(from);
1499 idx_to = idx_from;
1500 if (to) {
1501 idx_to = get_expression_value(to);
1502 if (idx_to < idx_from || idx_from < 0)
1503 warning(from->pos, "nonsense array initializer index range");
1504 }
1505 expr->idx_from = idx_from;
1506 expr->idx_to = idx_to;
1507 return expr;
1508 }
1509
1510 static struct token *single_initializer(struct expression **ep, struct token *token)
1511 {
1512 int expect_equal = 0;
1513 struct token *next = token->next;
1514 struct expression **tail = ep;
1515 int nested;
1516
1517 *ep = NULL;
1518
1519 if ((token_type(token) == TOKEN_IDENT) && match_op(next, ':')) {
1520 struct expression *expr = identifier_expression(token);
1521 warning(token->pos, "obsolete struct initializer, use C99 syntax");
1522 token = initializer(&expr->ident_expression, next->next);
1523 if (expr->ident_expression)
1524 *ep = expr;
1525 return token;
1526 }
1527
1528 for (tail = ep, nested = 0; ; nested++, next = token->next) {
1529 if (match_op(token, '.') && (token_type(next) == TOKEN_IDENT)) {
1530 struct expression *expr = identifier_expression(next);
1531 *tail = expr;
1532 tail = &expr->ident_expression;
1533 expect_equal = 1;
1534 token = next->next;
1535 } else if (match_op(token, '[')) {
1536 struct expression *from = NULL, *to = NULL, *expr;
1537 token = constant_expression(token->next, &from);
1538 if (!from) {
1539 sparse_error(token->pos, "Expected constant expression");
1540 break;
1541 }
1542 if (match_op(token, SPECIAL_ELLIPSIS))
1543 token = constant_expression(token->next, &to);
1544 expr = index_expression(from, to);
1545 *tail = expr;
1546 tail = &expr->idx_expression;
1547 token = expect(token, ']', "at end of initializer index");
1548 if (nested)
1549 expect_equal = 1;
1550 } else {
1551 break;
1552 }
1553 }
1554 if (nested && !expect_equal) {
1555 if (!match_op(token, '='))
1556 warning(token->pos, "obsolete array initializer, use C99 syntax");
1557 else
1558 expect_equal = 1;
1559 }
1560 if (expect_equal)
1561 token = expect(token, '=', "at end of initializer index");
1562
1563 token = initializer(tail, token);
1564 if (!*tail)
1565 *ep = NULL;
1566 return token;
1567 }
1568
1569 static struct token *initializer_list(struct expression_list **list, struct token *token)
1570 {
1571 struct expression *expr;
1572
1573 for (;;) {
1574 token = single_initializer(&expr, token);
1575 if (!expr)
1576 break;
1577 add_expression(list, expr);
1578 if (!match_op(token, ','))
1579 break;
1580 token = token->next;
1581 }
1582 return token;
1583 }
1584
1585 struct token *initializer(struct expression **tree, struct token *token)
1586 {
1587 if (match_op(token, '{')) {
1588 struct expression *expr = alloc_expression(token->pos, EXPR_INITIALIZER);
1589 *tree = expr;
1590 token = initializer_list(&expr->expr_list, token->next);
1591 return expect(token, '}', "at end of initializer");
1592 }
1593 return assignment_expression(token, tree);
1594 }
1595
1596 static void declare_argument(struct symbol *sym, struct symbol *fn)
1597 {
1598 if (!sym->ident) {
1599 sparse_error(sym->pos, "no identifier for function argument");
1600 return;
1601 }
1602 bind_symbol(sym, sym->ident, NS_SYMBOL);
1603 }
1604
1605 static struct token *parse_function_body(struct token *token, struct symbol *decl,
1606 struct symbol_list **list)
1607 {
1608 struct symbol_list **old_symbol_list;
1609 struct symbol *base_type = decl->ctype.base_type;
1610 struct statement *stmt, **p;
1611 struct symbol *arg;
1612
1613 old_symbol_list = function_symbol_list;
1614 if (decl->ctype.modifiers & MOD_INLINE) {
1615 function_symbol_list = &decl->inline_symbol_list;
1616 p = &base_type->inline_stmt;
1617 } else {
1618 function_symbol_list = &decl->symbol_list;
1619 p = &base_type->stmt;
1620 }
1621 function_computed_target_list = NULL;
1622 function_computed_goto_list = NULL;
1623
1624 if (decl->ctype.modifiers & MOD_EXTERN) {
1625 if (!(decl->ctype.modifiers & MOD_INLINE))
1626 warning(decl->pos, "function '%s' with external linkage has definition", show_ident(decl->ident));
1627 }
1628 if (!(decl->ctype.modifiers & MOD_STATIC))
1629 decl->ctype.modifiers |= MOD_EXTERN;
1630
1631 stmt = start_function(decl);
1632
1633 *p = stmt;
1634 FOR_EACH_PTR (base_type->arguments, arg) {
1635 declare_argument(arg, base_type);
1636 } END_FOR_EACH_PTR(arg);
1637
1638 token = compound_statement(token->next, stmt);
1639
1640 end_function(decl);
1641 if (!(decl->ctype.modifiers & MOD_INLINE))
1642 add_symbol(list, decl);
1643 check_declaration(decl);
1644 function_symbol_list = old_symbol_list;
1645 if (function_computed_goto_list) {
1646 if (!function_computed_target_list)
1647 warning(decl->pos, "function '%s' has computed goto but no targets?", show_ident(decl->ident));
1648 else {
1649 struct statement *stmt;
1650 FOR_EACH_PTR(function_computed_goto_list, stmt) {
1651 stmt->target_list = function_computed_target_list;
1652 } END_FOR_EACH_PTR(stmt);
1653 }
1654 }
1655 return expect(token, '}', "at end of function");
1656 }
1657
1658 static void promote_k_r_types(struct symbol *arg)
1659 {
1660 struct symbol *base = arg->ctype.base_type;
1661 if (base && base->ctype.base_type == &int_type && (base->ctype.modifiers & (MOD_CHAR | MOD_SHORT))) {
1662 arg->ctype.base_type = &int_ctype;
1663 }
1664 }
1665
1666 static void apply_k_r_types(struct symbol_list *argtypes, struct symbol *fn)
1667 {
1668 struct symbol_list *real_args = fn->ctype.base_type->arguments;
1669 struct symbol *arg;
1670
1671 FOR_EACH_PTR(real_args, arg) {
1672 struct symbol *type;
1673
1674 /* This is quadratic in the number of arguments. We _really_ don't care */
1675 FOR_EACH_PTR(argtypes, type) {
1676 if (type->ident == arg->ident)
1677 goto match;
1678 } END_FOR_EACH_PTR(type);
1679 sparse_error(arg->pos, "missing type declaration for parameter '%s'", show_ident(arg->ident));
1680 continue;
1681 match:
1682 type->used = 1;
1683 /* "char" and "short" promote to "int" */
1684 promote_k_r_types(type);
1685
1686 arg->ctype = type->ctype;
1687 } END_FOR_EACH_PTR(arg);
1688
1689 FOR_EACH_PTR(argtypes, arg) {
1690 if (!arg->used)
1691 warning(arg->pos, "nonsensical parameter declaration '%s'", show_ident(arg->ident));
1692 } END_FOR_EACH_PTR(arg);
1693
1694 }
1695
1696 static struct token *parse_k_r_arguments(struct token *token, struct symbol *decl,
1697 struct symbol_list **list)
1698 {
1699 struct symbol_list *args = NULL;
1700
1701 warning(token->pos, "non-ANSI definition of function '%s'", show_ident(decl->ident));
1702 do {
1703 token = declaration_list(token, &args);
1704 if (!match_op(token, ';')) {
1705 sparse_error(token->pos, "expected ';' at end of parameter declaration");
1706 break;
1707 }
1708 token = token->next;
1709 } while (lookup_type(token));
1710
1711 apply_k_r_types(args, decl);
1712
1713 if (!match_op(token, '{')) {
1714 sparse_error(token->pos, "expected function body");
1715 return token;
1716 }
1717 return parse_function_body(token, decl, list);
1718 }
1719
1720
1721 struct token *external_declaration(struct token *token, struct symbol_list **list)
1722 {
1723 struct ident *ident = NULL;
1724 struct symbol *decl;
1725 struct ctype ctype = { 0, };
1726 struct symbol *base_type;
1727 int is_typedef;
1728
1729 /* Top-level inline asm? */
1730 if (match_idents(token, &asm_ident, &__asm___ident, &__asm_ident, NULL)) {
1731 struct symbol *anon = alloc_symbol(token->pos, SYM_NODE);
1732 struct symbol *fn = alloc_symbol(token->pos, SYM_FN);
1733 struct statement *stmt;
1734
1735 anon->ctype.base_type = fn;
1736 stmt = alloc_statement(token->pos, STMT_NONE);
1737 fn->stmt = stmt;
1738
1739 token = parse_asm(token->next, stmt);
1740
1741 add_symbol(list, anon);
1742 return token;
1743 }
1744
1745 /* Parse declaration-specifiers, if any */
1746 token = declaration_specifiers(token, &ctype, 0);
1747 decl = alloc_symbol(token->pos, SYM_NODE);
1748 decl->ctype = ctype;
1749 token = declarator(token, decl, &ident);
1750
1751 /* Just a type declaration? */
1752 if (!ident)
1753 return expect(token, ';', "end of type declaration");
1754
1755 /* type define declaration? */
1756 is_typedef = (ctype.modifiers & MOD_TYPEDEF) != 0;
1757
1758 /* Typedef's don't have meaningful storage */
1759 if (is_typedef) {
1760 ctype.modifiers &= ~MOD_STORAGE;
1761 decl->ctype.modifiers &= ~MOD_STORAGE;
1762 decl->ctype.modifiers |= MOD_USERTYPE;
1763 }
1764
1765 bind_symbol(decl, ident, is_typedef ? NS_TYPEDEF: NS_SYMBOL);
1766
1767 base_type = decl->ctype.base_type;
1768
1769 if (is_typedef) {
1770 if (base_type && !base_type->ident)
1771 base_type->ident = ident;
1772 } else if (base_type && base_type->type == SYM_FN) {
1773 /* K&R argument declaration? */
1774 if (lookup_type(token))
1775 return parse_k_r_arguments(token, decl, list);
1776 if (match_op(token, '{'))
1777 return parse_function_body(token, decl, list);
1778
1779 if (!(decl->ctype.modifiers & MOD_STATIC))
1780 decl->ctype.modifiers |= MOD_EXTERN;
1781 } else if (base_type == &void_ctype && !(decl->ctype.modifiers & MOD_EXTERN)) {
1782 sparse_error(token->pos, "void declaration");
1783 }
1784
1785 for (;;) {
1786 if (!is_typedef && match_op(token, '=')) {
1787 if (decl->ctype.modifiers & MOD_EXTERN) {
1788 warning(decl->pos, "symbol with external linkage has initializer");
1789 decl->ctype.modifiers &= ~MOD_EXTERN;
1790 }
1791 token = initializer(&decl->initializer, token->next);
1792 }
1793 if (!is_typedef) {
1794 if (!(decl->ctype.modifiers & (MOD_EXTERN | MOD_INLINE))) {
1795 add_symbol(list, decl);
1796 fn_local_symbol(decl);
1797 }
1798 }
1799 check_declaration(decl);
1800
1801 if (!match_op(token, ','))
1802 break;
1803
1804 token = token->next;
1805 ident = NULL;
1806 decl = alloc_symbol(token->pos, SYM_NODE);
1807 decl->ctype = ctype;
1808 token = declaration_specifiers(token, &decl->ctype, 1);
1809 token = declarator(token, decl, &ident);
1810 if (!ident) {
1811 sparse_error(token->pos, "expected identifier name in type definition");
1812 return token;
1813 }
1814
1815 bind_symbol(decl, ident, is_typedef ? NS_TYPEDEF: NS_SYMBOL);
1816
1817 /* Function declarations are automatically extern unless specifically static */
1818 base_type = decl->ctype.base_type;
1819 if (!is_typedef && base_type && base_type->type == SYM_FN) {
1820 if (!(decl->ctype.modifiers & MOD_STATIC))
1821 decl->ctype.modifiers |= MOD_EXTERN;
1822 }
1823 }
1824 return expect(token, ';', "at end of declaration");
1825 }
Static analysis for C