helper: add get_last_statement_from_expression_stmt() [build fix]
[smatch.git] / lib.c
blob7e4ccd493735ccb551c0daefae1d3784283dd1c3
1 /*
2 * 'sparse' library helper routines.
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
25 #include <ctype.h>
26 #include <fcntl.h>
27 #include <stdarg.h>
28 #include <stddef.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <assert.h>
35 #include <sys/types.h>
37 #include "lib.h"
38 #include "allocate.h"
39 #include "token.h"
40 #include "parse.h"
41 #include "symbol.h"
42 #include "expression.h"
43 #include "scope.h"
44 #include "linearize.h"
45 #include "target.h"
46 #include "version.h"
48 int verbose, optimize, optimize_size, preprocessing;
49 int die_if_error = 0;
50 int parse_error;
51 int has_error = 0;
53 #ifndef __GNUC__
54 # define __GNUC__ 2
55 # define __GNUC_MINOR__ 95
56 # define __GNUC_PATCHLEVEL__ 0
57 #endif
59 int gcc_major = __GNUC__;
60 int gcc_minor = __GNUC_MINOR__;
61 int gcc_patchlevel = __GNUC_PATCHLEVEL__;
63 static const char *gcc_base_dir = GCC_BASE;
64 static const char *multiarch_dir = MULTIARCH_TRIPLET;
66 struct token *skip_to(struct token *token, int op)
68 while (!match_op(token, op) && !eof_token(token))
69 token = token->next;
70 return token;
73 struct token *expect(struct token *token, int op, const char *where)
75 if (!match_op(token, op)) {
76 static struct token bad_token;
77 if (token != &bad_token) {
78 bad_token.next = token;
79 sparse_error(token->pos, "Expected %s %s", show_special(op), where);
80 sparse_error(token->pos, "got %s", show_token(token));
82 if (op == ';')
83 return skip_to(token, op);
84 return &bad_token;
86 return token->next;
89 unsigned int hexval(unsigned int c)
91 int retval = 256;
92 switch (c) {
93 case '0'...'9':
94 retval = c - '0';
95 break;
96 case 'a'...'f':
97 retval = c - 'a' + 10;
98 break;
99 case 'A'...'F':
100 retval = c - 'A' + 10;
101 break;
103 return retval;
106 static void do_warn(const char *type, struct position pos, const char * fmt, va_list args)
108 static char buffer[512];
109 const char *name;
111 vsprintf(buffer, fmt, args);
112 name = stream_name(pos.stream);
114 fprintf(stderr, "%s:%d:%d: %s%s\n",
115 name, pos.line, pos.pos, type, buffer);
118 static int max_warnings = 100;
119 static int show_info = 1;
121 void info(struct position pos, const char * fmt, ...)
123 va_list args;
125 if (!show_info)
126 return;
127 va_start(args, fmt);
128 do_warn("", pos, fmt, args);
129 va_end(args);
132 static void do_error(struct position pos, const char * fmt, va_list args)
134 static int errors = 0;
136 parse_error = 1;
137 die_if_error = 1;
138 show_info = 1;
139 /* Shut up warnings after an error */
140 has_error |= ERROR_CURR_PHASE;
141 if (errors > 100) {
142 static int once = 0;
143 show_info = 0;
144 if (once)
145 return;
146 fmt = "too many errors";
147 once = 1;
150 do_warn("error: ", pos, fmt, args);
151 errors++;
154 void warning(struct position pos, const char * fmt, ...)
156 va_list args;
158 if (Wsparse_error) {
159 va_start(args, fmt);
160 do_error(pos, fmt, args);
161 va_end(args);
162 return;
165 if (!max_warnings || has_error) {
166 show_info = 0;
167 return;
170 if (!--max_warnings) {
171 show_info = 0;
172 fmt = "too many warnings";
175 va_start(args, fmt);
176 do_warn("warning: ", pos, fmt, args);
177 va_end(args);
180 void sparse_error(struct position pos, const char * fmt, ...)
182 va_list args;
183 va_start(args, fmt);
184 do_error(pos, fmt, args);
185 va_end(args);
188 void expression_error(struct expression *expr, const char *fmt, ...)
190 va_list args;
191 va_start(args, fmt);
192 do_error(expr->pos, fmt, args);
193 va_end(args);
194 expr->ctype = &bad_ctype;
197 NORETURN_ATTR
198 void error_die(struct position pos, const char * fmt, ...)
200 va_list args;
201 va_start(args, fmt);
202 do_warn("error: ", pos, fmt, args);
203 va_end(args);
204 exit(1);
207 NORETURN_ATTR
208 void die(const char *fmt, ...)
210 va_list args;
211 static char buffer[512];
213 va_start(args, fmt);
214 vsnprintf(buffer, sizeof(buffer), fmt, args);
215 va_end(args);
217 fprintf(stderr, "%s\n", buffer);
218 exit(1);
221 static struct token *pre_buffer_begin = NULL;
222 static struct token *pre_buffer_end = NULL;
224 int Waddress = 0;
225 int Waddress_space = 1;
226 int Wbitwise = 1;
227 int Wcast_to_as = 0;
228 int Wcast_truncate = 1;
229 int Wconstexpr_not_const = 0;
230 int Wcontext = 1;
231 int Wdecl = 1;
232 int Wdeclarationafterstatement = -1;
233 int Wdefault_bitfield_sign = 0;
234 int Wdesignated_init = 1;
235 int Wdo_while = 0;
236 int Winit_cstring = 0;
237 int Wenum_mismatch = 1;
238 int Wsparse_error = 0;
239 int Wmemcpy_max_count = 1;
240 int Wnon_pointer_null = 1;
241 int Wold_initializer = 1;
242 int Wone_bit_signed_bitfield = 1;
243 int Woverride_init = 1;
244 int Woverride_init_all = 0;
245 int Woverride_init_whole_range = 0;
246 int Wparen_string = 0;
247 int Wptr_subtraction_blows = 0;
248 int Wreturn_void = 0;
249 int Wshadow = 0;
250 int Wsizeof_bool = 0;
251 int Wtautological_compare = 0;
252 int Wtransparent_union = 0;
253 int Wtypesign = 0;
254 int Wundef = 0;
255 int Wuninitialized = 1;
256 int Wunknown_attribute = 0;
257 int Wvla = 1;
259 int dump_macro_defs = 0;
261 int dbg_entry = 0;
262 int dbg_dead = 0;
264 int fmem_report = 0;
265 int fdump_linearize;
266 unsigned long long fmemcpy_max_count = 100000;
268 int preprocess_only;
270 static enum { STANDARD_C89,
271 STANDARD_C94,
272 STANDARD_C99,
273 STANDARD_C11,
274 STANDARD_GNU11,
275 STANDARD_GNU89,
276 STANDARD_GNU99, } standard = STANDARD_GNU89;
278 #define ARCH_LP32 0
279 #define ARCH_LP64 1
280 #define ARCH_LLP64 2
282 #ifdef __x86_64__
283 #define ARCH_M64_DEFAULT ARCH_LP64
284 #else
285 #define ARCH_M64_DEFAULT ARCH_LP32
286 #endif
288 int arch_m64 = ARCH_M64_DEFAULT;
289 int arch_msize_long = 0;
291 #ifdef __BIG_ENDIAN__
292 #define ARCH_BIG_ENDIAN 1
293 #else
294 #define ARCH_BIG_ENDIAN 0
295 #endif
296 int arch_big_endian = ARCH_BIG_ENDIAN;
299 #define CMDLINE_INCLUDE 20
300 static int cmdline_include_nr = 0;
301 static char *cmdline_include[CMDLINE_INCLUDE];
304 void add_pre_buffer(const char *fmt, ...)
306 va_list args;
307 unsigned int size;
308 struct token *begin, *end;
309 char buffer[4096];
311 va_start(args, fmt);
312 size = vsnprintf(buffer, sizeof(buffer), fmt, args);
313 va_end(args);
314 begin = tokenize_buffer(buffer, size, &end);
315 if (!pre_buffer_begin)
316 pre_buffer_begin = begin;
317 if (pre_buffer_end)
318 pre_buffer_end->next = begin;
319 pre_buffer_end = end;
322 static char **handle_switch_D(char *arg, char **next)
324 const char *name = arg + 1;
325 const char *value = "1";
327 if (!*name || isspace((unsigned char)*name))
328 die("argument to `-D' is missing");
330 for (;;) {
331 char c;
332 c = *++arg;
333 if (!c)
334 break;
335 if (isspace((unsigned char)c) || c == '=') {
336 *arg = '\0';
337 value = arg + 1;
338 break;
341 add_pre_buffer("#define %s %s\n", name, value);
342 return next;
345 static char **handle_switch_E(char *arg, char **next)
347 if (arg[1] == '\0')
348 preprocess_only = 1;
349 return next;
352 static char **handle_switch_I(char *arg, char **next)
354 char *path = arg+1;
356 switch (arg[1]) {
357 case '-':
358 add_pre_buffer("#split_include\n");
359 break;
361 case '\0': /* Plain "-I" */
362 path = *++next;
363 if (!path)
364 die("missing argument for -I option");
365 /* Fall through */
366 default:
367 add_pre_buffer("#add_include \"%s/\"\n", path);
369 return next;
372 static void add_cmdline_include(char *filename)
374 if (cmdline_include_nr >= CMDLINE_INCLUDE)
375 die("too many include files for %s\n", filename);
376 cmdline_include[cmdline_include_nr++] = filename;
379 static char **handle_switch_i(char *arg, char **next)
381 if (*next && !strcmp(arg, "include"))
382 add_cmdline_include(*++next);
383 else if (*next && !strcmp(arg, "imacros"))
384 add_cmdline_include(*++next);
385 else if (*next && !strcmp(arg, "isystem")) {
386 char *path = *++next;
387 if (!path)
388 die("missing argument for -isystem option");
389 add_pre_buffer("#add_isystem \"%s/\"\n", path);
390 } else if (*next && !strcmp(arg, "idirafter")) {
391 char *path = *++next;
392 if (!path)
393 die("missing argument for -idirafter option");
394 add_pre_buffer("#add_dirafter \"%s/\"\n", path);
396 return next;
399 static char **handle_switch_M(char *arg, char **next)
401 if (!strcmp(arg, "MF") || !strcmp(arg,"MQ") || !strcmp(arg,"MT")) {
402 if (!*next)
403 die("missing argument for -%s option", arg);
404 return next + 1;
406 return next;
409 static char **handle_multiarch_dir(char *arg, char **next)
411 multiarch_dir = *++next;
412 if (!multiarch_dir)
413 die("missing argument for -multiarch-dir option");
414 return next;
417 static char **handle_switch_m(char *arg, char **next)
419 if (!strcmp(arg, "m64")) {
420 arch_m64 = ARCH_LP64;
421 } else if (!strcmp(arg, "m32")) {
422 arch_m64 = ARCH_LP32;
423 } else if (!strcmp(arg, "msize-llp64")) {
424 arch_m64 = ARCH_LLP64;
425 } else if (!strcmp(arg, "msize-long")) {
426 arch_msize_long = 1;
427 } else if (!strcmp(arg, "multiarch-dir")) {
428 return handle_multiarch_dir(arg, next);
429 } else if (!strcmp(arg, "mbig-endian")) {
430 arch_big_endian = 1;
431 } else if (!strcmp(arg, "mlittle-endian")) {
432 arch_big_endian = 0;
434 return next;
437 static void handle_arch_m64_finalize(void)
439 switch (arch_m64) {
440 case ARCH_LP32:
441 /* default values */
442 return;
443 case ARCH_LP64:
444 bits_in_long = 64;
445 max_int_alignment = 8;
446 size_t_ctype = &ulong_ctype;
447 ssize_t_ctype = &long_ctype;
448 add_pre_buffer("#weak_define __LP64__ 1\n");
449 add_pre_buffer("#weak_define _LP64 1\n");
450 goto case_64bit_common;
451 case ARCH_LLP64:
452 bits_in_long = 32;
453 max_int_alignment = 4;
454 size_t_ctype = &ullong_ctype;
455 ssize_t_ctype = &llong_ctype;
456 add_pre_buffer("#weak_define __LLP64__ 1\n");
457 goto case_64bit_common;
458 case_64bit_common:
459 bits_in_pointer = 64;
460 pointer_alignment = 8;
461 #ifdef __x86_64__
462 add_pre_buffer("#weak_define __x86_64__ 1\n");
463 #endif
464 break;
468 static void handle_arch_msize_long_finalize(void)
470 if (arch_msize_long) {
471 size_t_ctype = &ulong_ctype;
472 ssize_t_ctype = &long_ctype;
476 static void handle_arch_finalize(void)
478 handle_arch_m64_finalize();
479 handle_arch_msize_long_finalize();
483 static int handle_simple_switch(const char *arg, const char *name, int *flag)
485 int val = 1;
487 // Prefixe "no-" mean to turn flag off.
488 if (strncmp(arg, "no-", 3) == 0) {
489 arg += 3;
490 val = 0;
493 if (strcmp(arg, name) == 0) {
494 *flag = val;
495 return 1;
498 // not handled
499 return 0;
502 static char **handle_switch_o(char *arg, char **next)
504 if (!strcmp (arg, "o")) { // "-o foo"
505 if (!*++next)
506 die("argument to '-o' is missing");
508 // else "-ofoo"
510 return next;
513 static const struct warning {
514 const char *name;
515 int *flag;
516 } warnings[] = {
517 { "address", &Waddress },
518 { "address-space", &Waddress_space },
519 { "bitwise", &Wbitwise },
520 { "cast-to-as", &Wcast_to_as },
521 { "cast-truncate", &Wcast_truncate },
522 { "constexpr-not-const", &Wconstexpr_not_const},
523 { "context", &Wcontext },
524 { "decl", &Wdecl },
525 { "declaration-after-statement", &Wdeclarationafterstatement },
526 { "default-bitfield-sign", &Wdefault_bitfield_sign },
527 { "designated-init", &Wdesignated_init },
528 { "do-while", &Wdo_while },
529 { "enum-mismatch", &Wenum_mismatch },
530 { "init-cstring", &Winit_cstring },
531 { "memcpy-max-count", &Wmemcpy_max_count },
532 { "non-pointer-null", &Wnon_pointer_null },
533 { "old-initializer", &Wold_initializer },
534 { "one-bit-signed-bitfield", &Wone_bit_signed_bitfield },
535 { "override-init", &Woverride_init },
536 { "override-init-all", &Woverride_init_all },
537 { "paren-string", &Wparen_string },
538 { "ptr-subtraction-blows", &Wptr_subtraction_blows },
539 { "return-void", &Wreturn_void },
540 { "shadow", &Wshadow },
541 { "sizeof-bool", &Wsizeof_bool },
542 { "sparse-error", &Wsparse_error },
543 { "tautological-compare", &Wtautological_compare },
544 { "transparent-union", &Wtransparent_union },
545 { "typesign", &Wtypesign },
546 { "undef", &Wundef },
547 { "uninitialized", &Wuninitialized },
548 { "unknown-attribute", &Wunknown_attribute },
549 { "vla", &Wvla },
552 enum {
553 WARNING_OFF,
554 WARNING_ON,
555 WARNING_FORCE_OFF
559 static char **handle_onoff_switch(char *arg, char **next, const struct warning warnings[], int n)
561 int flag = WARNING_ON;
562 char *p = arg + 1;
563 unsigned i;
565 if (!strcmp(p, "sparse-all")) {
566 for (i = 0; i < n; i++) {
567 if (*warnings[i].flag != WARNING_FORCE_OFF && warnings[i].flag != &Wsparse_error)
568 *warnings[i].flag = WARNING_ON;
572 // Prefixes "no" and "no-" mean to turn warning off.
573 if (p[0] == 'n' && p[1] == 'o') {
574 p += 2;
575 if (p[0] == '-')
576 p++;
577 flag = WARNING_FORCE_OFF;
580 for (i = 0; i < n; i++) {
581 if (!strcmp(p,warnings[i].name)) {
582 *warnings[i].flag = flag;
583 return next;
587 // Unknown.
588 return NULL;
591 static char **handle_switch_W(char *arg, char **next)
593 char ** ret = handle_onoff_switch(arg, next, warnings, ARRAY_SIZE(warnings));
594 if (ret)
595 return ret;
597 // Unknown.
598 return next;
601 static struct warning debugs[] = {
602 { "entry", &dbg_entry},
603 { "dead", &dbg_dead},
607 static char **handle_switch_v(char *arg, char **next)
609 char ** ret = handle_onoff_switch(arg, next, debugs, ARRAY_SIZE(debugs));
610 if (ret)
611 return ret;
613 // Unknown.
614 do {
615 verbose++;
616 } while (*++arg == 'v');
617 return next;
620 static struct warning dumps[] = {
621 { "D", &dump_macro_defs},
624 static char **handle_switch_d(char *arg, char **next)
626 char ** ret = handle_onoff_switch(arg, next, dumps, ARRAY_SIZE(dumps));
627 if (ret)
628 return ret;
630 return next;
634 static void handle_onoff_switch_finalize(const struct warning warnings[], int n)
636 unsigned i;
638 for (i = 0; i < n; i++) {
639 if (*warnings[i].flag == WARNING_FORCE_OFF)
640 *warnings[i].flag = WARNING_OFF;
644 static void handle_switch_W_finalize(void)
646 handle_onoff_switch_finalize(warnings, ARRAY_SIZE(warnings));
648 /* default Wdeclarationafterstatement based on the C dialect */
649 if (-1 == Wdeclarationafterstatement)
651 switch (standard)
653 case STANDARD_C89:
654 case STANDARD_C94:
655 Wdeclarationafterstatement = 1;
656 break;
658 case STANDARD_C99:
659 case STANDARD_GNU89:
660 case STANDARD_GNU99:
661 case STANDARD_C11:
662 case STANDARD_GNU11:
663 Wdeclarationafterstatement = 0;
664 break;
666 default:
667 assert (0);
673 static void handle_switch_v_finalize(void)
675 handle_onoff_switch_finalize(debugs, ARRAY_SIZE(debugs));
678 static char **handle_switch_U(char *arg, char **next)
680 const char *name = arg + 1;
681 add_pre_buffer ("#undef %s\n", name);
682 return next;
685 static char **handle_switch_O(char *arg, char **next)
687 int level = 1;
688 if (arg[1] >= '0' && arg[1] <= '9')
689 level = arg[1] - '0';
690 optimize = level;
691 optimize_size = arg[1] == 's';
692 return next;
695 static char **handle_switch_fmemcpy_max_count(char *arg, char **next)
697 unsigned long long val;
698 char *end;
700 val = strtoull(arg, &end, 0);
701 if (*end != '\0' || end == arg)
702 die("error: missing argument to \"-fmemcpy-max-count=\"");
704 if (val == 0)
705 val = ~0ULL;
706 fmemcpy_max_count = val;
707 return next;
710 static char **handle_switch_ftabstop(char *arg, char **next)
712 char *end;
713 unsigned long val;
715 if (*arg == '\0')
716 die("error: missing argument to \"-ftabstop=\"");
718 /* we silently ignore silly values */
719 val = strtoul(arg, &end, 10);
720 if (*end == '\0' && 1 <= val && val <= 100)
721 tabstop = val;
723 return next;
726 static int funsigned_char;
727 static void handle_funsigned_char(void)
729 if (funsigned_char) {
730 char_ctype.ctype.modifiers &= ~MOD_SIGNED;
731 char_ctype.ctype.modifiers |= MOD_UNSIGNED;
735 static char **handle_switch_fdump(char *arg, char **next)
737 if (!strncmp(arg, "linearize", 9)) {
738 arg += 9;
739 if (*arg == '\0')
740 fdump_linearize = 1;
741 else if (!strcmp(arg, "=only"))
742 fdump_linearize = 2;
743 else
744 goto err;
747 /* ignore others flags */
748 return next;
750 err:
751 die("error: unknown flag \"-fdump-%s\"", arg);
754 static char **handle_switch_f(char *arg, char **next)
756 arg++;
758 if (!strncmp(arg, "tabstop=", 8))
759 return handle_switch_ftabstop(arg+8, next);
760 if (!strncmp(arg, "dump-", 5))
761 return handle_switch_fdump(arg+5, next);
762 if (!strncmp(arg, "memcpy-max-count=", 17))
763 return handle_switch_fmemcpy_max_count(arg+17, next);
765 if (!strcmp(arg, "unsigned-char")) {
766 funsigned_char = 1;
767 return next;
770 /* handle switches w/ arguments above, boolean and only boolean below */
771 if (handle_simple_switch(arg, "mem-report", &fmem_report))
772 return next;
774 return next;
777 static char **handle_switch_G(char *arg, char **next)
779 if (!strcmp (arg, "G") && *next)
780 return next + 1; // "-G 0"
781 else
782 return next; // "-G0" or (bogus) terminal "-G"
785 static char **handle_switch_a(char *arg, char **next)
787 if (!strcmp (arg, "ansi"))
788 standard = STANDARD_C89;
790 return next;
793 static char **handle_switch_s(char *arg, char **next)
795 if (!strncmp (arg, "std=", 4))
797 arg += 4;
799 if (!strcmp (arg, "c89") ||
800 !strcmp (arg, "iso9899:1990"))
801 standard = STANDARD_C89;
803 else if (!strcmp (arg, "iso9899:199409"))
804 standard = STANDARD_C94;
806 else if (!strcmp (arg, "c99") ||
807 !strcmp (arg, "c9x") ||
808 !strcmp (arg, "iso9899:1999") ||
809 !strcmp (arg, "iso9899:199x"))
810 standard = STANDARD_C99;
812 else if (!strcmp (arg, "gnu89"))
813 standard = STANDARD_GNU89;
815 else if (!strcmp (arg, "gnu99") || !strcmp (arg, "gnu9x"))
816 standard = STANDARD_GNU99;
818 else if (!strcmp(arg, "c11") ||
819 !strcmp(arg, "c1x") ||
820 !strcmp(arg, "iso9899:2011"))
821 standard = STANDARD_C11;
823 else if (!strcmp(arg, "gnu11"))
824 standard = STANDARD_GNU11;
826 else
827 die ("Unsupported C dialect");
830 return next;
833 static char **handle_nostdinc(char *arg, char **next)
835 add_pre_buffer("#nostdinc\n");
836 return next;
839 static char **handle_switch_n(char *arg, char **next)
841 if (!strcmp (arg, "nostdinc"))
842 return handle_nostdinc(arg, next);
844 return next;
847 static char **handle_base_dir(char *arg, char **next)
849 gcc_base_dir = *++next;
850 if (!gcc_base_dir)
851 die("missing argument for -gcc-base-dir option");
852 return next;
855 static char **handle_no_lineno(char *arg, char **next)
857 no_lineno = 1;
858 return next;
861 static char **handle_switch_g(char *arg, char **next)
863 if (!strcmp (arg, "gcc-base-dir"))
864 return handle_base_dir(arg, next);
866 return next;
869 static char **handle_version(char *arg, char **next)
871 printf("%s\n", SPARSE_VERSION);
872 exit(0);
875 static char **handle_param(char *arg, char **next)
877 char *value = NULL;
879 /* For now just skip any '--param=*' or '--param *' */
880 if (*arg == '\0') {
881 value = *++next;
882 } else if (isspace((unsigned char)*arg) || *arg == '=') {
883 value = ++arg;
886 if (!value)
887 die("missing argument for --param option");
889 return next;
892 struct switches {
893 const char *name;
894 char **(*fn)(char *, char **);
895 unsigned int prefix:1;
898 static char **handle_long_options(char *arg, char **next)
900 static struct switches cmd[] = {
901 { "param", handle_param, 1 },
902 { "version", handle_version },
903 { "nostdinc", handle_nostdinc },
904 { "gcc-base-dir", handle_base_dir},
905 { "no-lineno", handle_no_lineno},
906 { NULL, NULL }
908 struct switches *s = cmd;
910 while (s->name) {
911 int optlen = strlen(s->name);
912 if (!strncmp(s->name, arg, optlen + !s->prefix))
913 return s->fn(arg + optlen, next);
914 s++;
916 return next;
919 static char **handle_switch(char *arg, char **next)
921 switch (*arg) {
922 case 'a': return handle_switch_a(arg, next);
923 case 'D': return handle_switch_D(arg, next);
924 case 'd': return handle_switch_d(arg, next);
925 case 'E': return handle_switch_E(arg, next);
926 case 'f': return handle_switch_f(arg, next);
927 case 'g': return handle_switch_g(arg, next);
928 case 'G': return handle_switch_G(arg, next);
929 case 'I': return handle_switch_I(arg, next);
930 case 'i': return handle_switch_i(arg, next);
931 case 'M': return handle_switch_M(arg, next);
932 case 'm': return handle_switch_m(arg, next);
933 case 'n': return handle_switch_n(arg, next);
934 case 'o': return handle_switch_o(arg, next);
935 case 'O': return handle_switch_O(arg, next);
936 case 's': return handle_switch_s(arg, next);
937 case 'U': return handle_switch_U(arg, next);
938 case 'v': return handle_switch_v(arg, next);
939 case 'W': return handle_switch_W(arg, next);
940 case '-': return handle_long_options(arg + 1, next);
941 default:
942 break;
946 * Ignore unknown command line options:
947 * they're probably gcc switches
949 return next;
952 static void predefined_sizeof(const char *name, unsigned bits)
954 add_pre_buffer("#weak_define __SIZEOF_%s__ %d\n", name, bits/8);
957 static void predefined_max(const char *name, const char *suffix, unsigned bits)
959 unsigned long long max = (1ULL << (bits - 1 )) - 1;
961 add_pre_buffer("#weak_define __%s_MAX__ %#llx%s\n", name, max, suffix);
964 static void predefined_type_size(const char *name, const char *suffix, unsigned bits)
966 predefined_max(name, suffix, bits);
967 predefined_sizeof(name, bits);
970 static void predefined_macros(void)
972 add_pre_buffer("#define __CHECKER__ 1\n");
974 predefined_sizeof("SHORT", bits_in_short);
975 predefined_max("SHRT", "", bits_in_short);
976 predefined_max("SCHAR", "", bits_in_char);
977 predefined_max("WCHAR", "", bits_in_wchar);
978 add_pre_buffer("#weak_define __CHAR_BIT__ %d\n", bits_in_char);
980 predefined_type_size("INT", "", bits_in_int);
981 predefined_type_size("LONG", "L", bits_in_long);
982 predefined_type_size("LONG_LONG", "LL", bits_in_longlong);
984 predefined_sizeof("INT128", 128);
986 predefined_sizeof("SIZE_T", bits_in_pointer);
987 predefined_sizeof("PTRDIFF_T", bits_in_pointer);
988 predefined_sizeof("POINTER", bits_in_pointer);
990 predefined_sizeof("FLOAT", bits_in_float);
991 predefined_sizeof("DOUBLE", bits_in_double);
992 predefined_sizeof("LONG_DOUBLE", bits_in_longdouble);
994 add_pre_buffer("#weak_define __%s_ENDIAN__ 1\n",
995 arch_big_endian ? "BIG" : "LITTLE");
997 add_pre_buffer("#weak_define __ORDER_LITTLE_ENDIAN__ 1234\n");
998 add_pre_buffer("#weak_define __ORDER_BIG_ENDIAN__ 4321\n");
999 add_pre_buffer("#weak_define __ORDER_PDP_ENDIAN__ 3412\n");
1000 add_pre_buffer("#weak_define __BYTE_ORDER__ __ORDER_%s_ENDIAN__\n",
1001 arch_big_endian ? "BIG" : "LITTLE");
1004 void declare_builtin_functions(void)
1006 /* Gaah. gcc knows tons of builtin <string.h> functions */
1007 add_pre_buffer("extern void *__builtin_memchr(const void *, int, __SIZE_TYPE__);\n");
1008 add_pre_buffer("extern void *__builtin_memcpy(void *, const void *, __SIZE_TYPE__);\n");
1009 add_pre_buffer("extern void *__builtin_mempcpy(void *, const void *, __SIZE_TYPE__);\n");
1010 add_pre_buffer("extern void *__builtin_memmove(void *, const void *, __SIZE_TYPE__);\n");
1011 add_pre_buffer("extern void *__builtin_memset(void *, int, __SIZE_TYPE__);\n");
1012 add_pre_buffer("extern int __builtin_memcmp(const void *, const void *, __SIZE_TYPE__);\n");
1013 add_pre_buffer("extern char *__builtin_strcat(char *, const char *);\n");
1014 add_pre_buffer("extern char *__builtin_strncat(char *, const char *, __SIZE_TYPE__);\n");
1015 add_pre_buffer("extern int __builtin_strcmp(const char *, const char *);\n");
1016 add_pre_buffer("extern int __builtin_strncmp(const char *, const char *, __SIZE_TYPE__);\n");
1017 add_pre_buffer("extern int __builtin_strcasecmp(const char *, const char *);\n");
1018 add_pre_buffer("extern int __builtin_strncasecmp(const char *, const char *, __SIZE_TYPE__);\n");
1019 add_pre_buffer("extern char *__builtin_strchr(const char *, int);\n");
1020 add_pre_buffer("extern char *__builtin_strrchr(const char *, int);\n");
1021 add_pre_buffer("extern char *__builtin_strcpy(char *, const char *);\n");
1022 add_pre_buffer("extern char *__builtin_strncpy(char *, const char *, __SIZE_TYPE__);\n");
1023 add_pre_buffer("extern char *__builtin_strdup(const char *);\n");
1024 add_pre_buffer("extern char *__builtin_strndup(const char *, __SIZE_TYPE__);\n");
1025 add_pre_buffer("extern __SIZE_TYPE__ __builtin_strspn(const char *, const char *);\n");
1026 add_pre_buffer("extern __SIZE_TYPE__ __builtin_strcspn(const char *, const char *);\n");
1027 add_pre_buffer("extern char * __builtin_strpbrk(const char *, const char *);\n");
1028 add_pre_buffer("extern char* __builtin_stpcpy(const char *, const char*);\n");
1029 add_pre_buffer("extern char* __builtin_stpncpy(const char *, const char*, __SIZE_TYPE__);\n");
1030 add_pre_buffer("extern __SIZE_TYPE__ __builtin_strlen(const char *);\n");
1031 add_pre_buffer("extern char *__builtin_strstr(const char *, const char *);\n");
1032 add_pre_buffer("extern char *__builtin_strcasestr(const char *, const char *);\n");
1033 add_pre_buffer("extern char *__builtin_strnstr(const char *, const char *, __SIZE_TYPE__);\n");
1035 /* And even some from <strings.h> */
1036 add_pre_buffer("extern int __builtin_bcmp(const void *, const void *, __SIZE_TYPE__);\n");
1037 add_pre_buffer("extern void __builtin_bcopy(const void *, void *, __SIZE_TYPE__);\n");
1038 add_pre_buffer("extern void __builtin_bzero(void *, __SIZE_TYPE__);\n");
1039 add_pre_buffer("extern char*__builtin_index(const char *, int);\n");
1040 add_pre_buffer("extern char*__builtin_rindex(const char *, int);\n");
1042 /* And bitwise operations.. */
1043 add_pre_buffer("extern int __builtin_clrsb(int);\n");
1044 add_pre_buffer("extern int __builtin_clrsbl(long);\n");
1045 add_pre_buffer("extern int __builtin_clrsbll(long long);\n");
1046 add_pre_buffer("extern int __builtin_clz(int);\n");
1047 add_pre_buffer("extern int __builtin_clzl(long);\n");
1048 add_pre_buffer("extern int __builtin_clzll(long long);\n");
1049 add_pre_buffer("extern int __builtin_ctz(int);\n");
1050 add_pre_buffer("extern int __builtin_ctzl(long);\n");
1051 add_pre_buffer("extern int __builtin_ctzll(long long);\n");
1052 add_pre_buffer("extern int __builtin_ffs(int);\n");
1053 add_pre_buffer("extern int __builtin_ffsl(long);\n");
1054 add_pre_buffer("extern int __builtin_ffsll(long long);\n");
1055 add_pre_buffer("extern int __builtin_parity(unsigned int);\n");
1056 add_pre_buffer("extern int __builtin_parityl(unsigned long);\n");
1057 add_pre_buffer("extern int __builtin_parityll(unsigned long long);\n");
1058 add_pre_buffer("extern int __builtin_popcount(unsigned int);\n");
1059 add_pre_buffer("extern int __builtin_popcountl(unsigned long);\n");
1060 add_pre_buffer("extern int __builtin_popcountll(unsigned long long);\n");
1062 /* And byte swaps.. */
1063 add_pre_buffer("extern unsigned short __builtin_bswap16(unsigned short);\n");
1064 add_pre_buffer("extern unsigned int __builtin_bswap32(unsigned int);\n");
1065 add_pre_buffer("extern unsigned long long __builtin_bswap64(unsigned long long);\n");
1067 /* And atomic memory access functions.. */
1068 add_pre_buffer("extern int __sync_fetch_and_add(void *, ...);\n");
1069 add_pre_buffer("extern int __sync_fetch_and_sub(void *, ...);\n");
1070 add_pre_buffer("extern int __sync_fetch_and_or(void *, ...);\n");
1071 add_pre_buffer("extern int __sync_fetch_and_and(void *, ...);\n");
1072 add_pre_buffer("extern int __sync_fetch_and_xor(void *, ...);\n");
1073 add_pre_buffer("extern int __sync_fetch_and_nand(void *, ...);\n");
1074 add_pre_buffer("extern int __sync_add_and_fetch(void *, ...);\n");
1075 add_pre_buffer("extern int __sync_sub_and_fetch(void *, ...);\n");
1076 add_pre_buffer("extern int __sync_or_and_fetch(void *, ...);\n");
1077 add_pre_buffer("extern int __sync_and_and_fetch(void *, ...);\n");
1078 add_pre_buffer("extern int __sync_xor_and_fetch(void *, ...);\n");
1079 add_pre_buffer("extern int __sync_nand_and_fetch(void *, ...);\n");
1080 add_pre_buffer("extern int __sync_bool_compare_and_swap(void *, ...);\n");
1081 add_pre_buffer("extern int __sync_val_compare_and_swap(void *, ...);\n");
1082 add_pre_buffer("extern void __sync_synchronize();\n");
1083 add_pre_buffer("extern int __sync_lock_test_and_set(void *, ...);\n");
1084 add_pre_buffer("extern void __sync_lock_release(void *, ...);\n");
1086 /* And some random ones.. */
1087 add_pre_buffer("extern void *__builtin_return_address(unsigned int);\n");
1088 add_pre_buffer("extern void *__builtin_extract_return_addr(void *);\n");
1089 add_pre_buffer("extern void *__builtin_frame_address(unsigned int);\n");
1090 add_pre_buffer("extern void __builtin_trap(void);\n");
1091 add_pre_buffer("extern void *__builtin_alloca(__SIZE_TYPE__);\n");
1092 add_pre_buffer("extern void __builtin_prefetch (const void *, ...);\n");
1093 add_pre_buffer("extern long __builtin_alpha_extbl(long, long);\n");
1094 add_pre_buffer("extern long __builtin_alpha_extwl(long, long);\n");
1095 add_pre_buffer("extern long __builtin_alpha_insbl(long, long);\n");
1096 add_pre_buffer("extern long __builtin_alpha_inswl(long, long);\n");
1097 add_pre_buffer("extern long __builtin_alpha_insql(long, long);\n");
1098 add_pre_buffer("extern long __builtin_alpha_inslh(long, long);\n");
1099 add_pre_buffer("extern long __builtin_alpha_cmpbge(long, long);\n");
1100 add_pre_buffer("extern int __builtin_abs(int);\n");
1101 add_pre_buffer("extern long __builtin_labs(long);\n");
1102 add_pre_buffer("extern long long __builtin_llabs(long long);\n");
1103 add_pre_buffer("extern double __builtin_fabs(double);\n");
1104 add_pre_buffer("extern __SIZE_TYPE__ __builtin_va_arg_pack_len(void);\n");
1106 /* Add Blackfin-specific stuff */
1107 add_pre_buffer(
1108 "#ifdef __bfin__\n"
1109 "extern void __builtin_bfin_csync(void);\n"
1110 "extern void __builtin_bfin_ssync(void);\n"
1111 "extern int __builtin_bfin_norm_fr1x32(int);\n"
1112 "#endif\n"
1115 /* And some floating point stuff.. */
1116 add_pre_buffer("extern int __builtin_isgreater(float, float);\n");
1117 add_pre_buffer("extern int __builtin_isgreaterequal(float, float);\n");
1118 add_pre_buffer("extern int __builtin_isless(float, float);\n");
1119 add_pre_buffer("extern int __builtin_islessequal(float, float);\n");
1120 add_pre_buffer("extern int __builtin_islessgreater(float, float);\n");
1121 add_pre_buffer("extern int __builtin_isunordered(float, float);\n");
1123 /* And some INFINITY / NAN stuff.. */
1124 add_pre_buffer("extern double __builtin_huge_val(void);\n");
1125 add_pre_buffer("extern float __builtin_huge_valf(void);\n");
1126 add_pre_buffer("extern long double __builtin_huge_vall(void);\n");
1127 add_pre_buffer("extern double __builtin_inf(void);\n");
1128 add_pre_buffer("extern float __builtin_inff(void);\n");
1129 add_pre_buffer("extern long double __builtin_infl(void);\n");
1130 add_pre_buffer("extern double __builtin_nan(const char *);\n");
1131 add_pre_buffer("extern float __builtin_nanf(const char *);\n");
1132 add_pre_buffer("extern long double __builtin_nanl(const char *);\n");
1133 add_pre_buffer("extern int __builtin_isinf_sign(float);\n");
1134 add_pre_buffer("extern int __builtin_isfinite(float);\n");
1135 add_pre_buffer("extern int __builtin_isnan(float);\n");
1137 /* And some __FORTIFY_SOURCE ones.. */
1138 add_pre_buffer ("extern __SIZE_TYPE__ __builtin_object_size(const void *, int);\n");
1139 add_pre_buffer ("extern void * __builtin___memcpy_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
1140 add_pre_buffer ("extern void * __builtin___memmove_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
1141 add_pre_buffer ("extern void * __builtin___mempcpy_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
1142 add_pre_buffer ("extern void * __builtin___memset_chk(void *, int, __SIZE_TYPE__, __SIZE_TYPE__);\n");
1143 add_pre_buffer ("extern int __builtin___sprintf_chk(char *, int, __SIZE_TYPE__, const char *, ...);\n");
1144 add_pre_buffer ("extern int __builtin___snprintf_chk(char *, __SIZE_TYPE__, int , __SIZE_TYPE__, const char *, ...);\n");
1145 add_pre_buffer ("extern char * __builtin___stpcpy_chk(char *, const char *, __SIZE_TYPE__);\n");
1146 add_pre_buffer ("extern char * __builtin___strcat_chk(char *, const char *, __SIZE_TYPE__);\n");
1147 add_pre_buffer ("extern char * __builtin___strcpy_chk(char *, const char *, __SIZE_TYPE__);\n");
1148 add_pre_buffer ("extern char * __builtin___strncat_chk(char *, const char *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
1149 add_pre_buffer ("extern char * __builtin___strncpy_chk(char *, const char *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
1150 add_pre_buffer ("extern int __builtin___vsprintf_chk(char *, int, __SIZE_TYPE__, const char *, __builtin_va_list);\n");
1151 add_pre_buffer ("extern int __builtin___vsnprintf_chk(char *, __SIZE_TYPE__, int, __SIZE_TYPE__, const char *, __builtin_va_list ap);\n");
1152 add_pre_buffer ("extern void __builtin_unreachable(void);\n");
1154 /* And some from <stdlib.h> */
1155 add_pre_buffer("extern void __builtin_abort(void);\n");
1156 add_pre_buffer("extern void *__builtin_calloc(__SIZE_TYPE__, __SIZE_TYPE__);\n");
1157 add_pre_buffer("extern void __builtin_exit(int);\n");
1158 add_pre_buffer("extern void *__builtin_malloc(__SIZE_TYPE__);\n");
1159 add_pre_buffer("extern void *__builtin_realloc(void *, __SIZE_TYPE__);\n");
1160 add_pre_buffer("extern void __builtin_free(void *);\n");
1162 /* And some from <stdio.h> */
1163 add_pre_buffer("extern int __builtin_printf(const char *, ...);\n");
1164 add_pre_buffer("extern int __builtin_sprintf(char *, const char *, ...);\n");
1165 add_pre_buffer("extern int __builtin_snprintf(char *, __SIZE_TYPE__, const char *, ...);\n");
1166 add_pre_buffer("extern int __builtin_puts(const char *);\n");
1167 add_pre_buffer("extern int __builtin_vprintf(const char *, __builtin_va_list);\n");
1168 add_pre_buffer("extern int __builtin_vsprintf(char *, const char *, __builtin_va_list);\n");
1169 add_pre_buffer("extern int __builtin_vsnprintf(char *, __SIZE_TYPE__, const char *, __builtin_va_list ap);\n");
1172 void create_builtin_stream(void)
1174 add_pre_buffer("#weak_define __GNUC__ %d\n", gcc_major);
1175 add_pre_buffer("#weak_define __GNUC_MINOR__ %d\n", gcc_minor);
1176 add_pre_buffer("#weak_define __GNUC_PATCHLEVEL__ %d\n", gcc_patchlevel);
1178 /* add the multiarch include directories, if any */
1179 if (multiarch_dir && *multiarch_dir) {
1180 add_pre_buffer("#add_system \"/usr/include/%s\"\n", multiarch_dir);
1181 add_pre_buffer("#add_system \"/usr/local/include/%s\"\n", multiarch_dir);
1184 /* We add compiler headers path here because we have to parse
1185 * the arguments to get it, falling back to default. */
1186 add_pre_buffer("#add_system \"%s/include\"\n", gcc_base_dir);
1187 add_pre_buffer("#add_system \"%s/include-fixed\"\n", gcc_base_dir);
1189 add_pre_buffer("#define __extension__\n");
1190 add_pre_buffer("#define __pragma__\n");
1191 add_pre_buffer("#define _Pragma(x)\n");
1193 // gcc defines __SIZE_TYPE__ to be size_t. For linux/i86 and
1194 // solaris/sparc that is really "unsigned int" and for linux/x86_64
1195 // it is "long unsigned int". In either case we can probably
1196 // get away with this. We need the #weak_define as cgcc will define
1197 // the right __SIZE_TYPE__.
1198 if (size_t_ctype == &ulong_ctype)
1199 add_pre_buffer("#weak_define __SIZE_TYPE__ long unsigned int\n");
1200 else
1201 add_pre_buffer("#weak_define __SIZE_TYPE__ unsigned int\n");
1202 add_pre_buffer("#weak_define __STDC__ 1\n");
1204 switch (standard)
1206 case STANDARD_C89:
1207 add_pre_buffer("#weak_define __STRICT_ANSI__\n");
1208 break;
1210 case STANDARD_C94:
1211 add_pre_buffer("#weak_define __STDC_VERSION__ 199409L\n");
1212 add_pre_buffer("#weak_define __STRICT_ANSI__\n");
1213 break;
1215 case STANDARD_C99:
1216 add_pre_buffer("#weak_define __STDC_VERSION__ 199901L\n");
1217 add_pre_buffer("#weak_define __STRICT_ANSI__\n");
1218 break;
1220 case STANDARD_GNU89:
1221 break;
1223 case STANDARD_GNU99:
1224 add_pre_buffer("#weak_define __STDC_VERSION__ 199901L\n");
1225 break;
1227 case STANDARD_C11:
1228 add_pre_buffer("#weak_define __STRICT_ANSI__ 1\n");
1229 case STANDARD_GNU11:
1230 add_pre_buffer("#weak_define __STDC_NO_ATOMICS__ 1\n");
1231 add_pre_buffer("#weak_define __STDC_NO_COMPLEX__ 1\n");
1232 add_pre_buffer("#weak_define __STDC_NO_THREADS__ 1\n");
1233 add_pre_buffer("#weak_define __STDC_VERSION__ 201112L\n");
1234 break;
1236 default:
1237 assert (0);
1240 add_pre_buffer("#define __builtin_stdarg_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
1241 add_pre_buffer("#define __builtin_va_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
1242 add_pre_buffer("#define __builtin_ms_va_start(a,b) ((a) = (__builtin_ms_va_list)(&(b)))\n");
1243 add_pre_buffer("#define __builtin_va_arg(arg,type) ({ type __va_arg_ret = *(type *)(arg); arg += sizeof(type); __va_arg_ret; })\n");
1244 add_pre_buffer("#define __builtin_va_alist (*(void *)0)\n");
1245 add_pre_buffer("#define __builtin_va_arg_incr(x) ((x) + 1)\n");
1246 add_pre_buffer("#define __builtin_va_copy(dest, src) ({ dest = src; (void)0; })\n");
1247 add_pre_buffer("#define __builtin_ms_va_copy(dest, src) ({ dest = src; (void)0; })\n");
1248 add_pre_buffer("#define __builtin_va_end(arg)\n");
1249 add_pre_buffer("#define __builtin_ms_va_end(arg)\n");
1250 add_pre_buffer("#define __builtin_va_arg_pack()\n");
1252 /* FIXME! We need to do these as special magic macros at expansion time! */
1253 add_pre_buffer("#define __BASE_FILE__ \"base_file.c\"\n");
1255 if (optimize)
1256 add_pre_buffer("#define __OPTIMIZE__ 1\n");
1257 if (optimize_size)
1258 add_pre_buffer("#define __OPTIMIZE_SIZE__ 1\n");
1261 static struct symbol_list *sparse_tokenstream(struct token *token)
1263 int builtin = token && !token->pos.stream;
1265 // Preprocess the stream
1266 token = preprocess(token);
1268 if (dump_macro_defs && !builtin)
1269 dump_macro_definitions();
1271 if (preprocess_only) {
1272 while (!eof_token(token)) {
1273 int prec = 1;
1274 struct token *next = token->next;
1275 const char *separator = "";
1276 if (next->pos.whitespace)
1277 separator = " ";
1278 if (next->pos.newline) {
1279 separator = "\n\t\t\t\t\t";
1280 prec = next->pos.pos;
1281 if (prec > 4)
1282 prec = 4;
1284 printf("%s%.*s", show_token(token), prec, separator);
1285 token = next;
1287 putchar('\n');
1289 return NULL;
1292 // Parse the resulting C code
1293 while (!eof_token(token))
1294 token = external_declaration(token, &translation_unit_used_list, NULL);
1295 return translation_unit_used_list;
1298 static struct symbol_list *sparse_file(const char *filename)
1300 int fd;
1301 struct token *token;
1303 if (strcmp (filename, "-") == 0) {
1304 fd = 0;
1305 } else {
1306 fd = open(filename, O_RDONLY);
1307 if (fd < 0)
1308 die("No such file: %s", filename);
1311 // Tokenize the input stream
1312 token = tokenize(filename, fd, NULL, includepath);
1313 store_all_tokens(token);
1314 close(fd);
1316 return sparse_tokenstream(token);
1320 * This handles the "-include" directive etc: we're in global
1321 * scope, and all types/macros etc will affect all the following
1322 * files.
1324 * NOTE NOTE NOTE! "#undef" of anything in this stage will
1325 * affect all subsequent files too, i.e. we can have non-local
1326 * behaviour between files!
1328 static struct symbol_list *sparse_initial(void)
1330 int i;
1332 // Prepend any "include" file to the stream.
1333 // We're in global scope, it will affect all files!
1334 for (i = 0; i < cmdline_include_nr; i++)
1335 add_pre_buffer("#argv_include \"%s\"\n", cmdline_include[i]);
1337 return sparse_tokenstream(pre_buffer_begin);
1340 struct symbol_list *sparse_initialize(int argc, char **argv, struct string_list **filelist)
1342 char **args;
1343 struct symbol_list *list;
1345 // Initialize symbol stream first, so that we can add defines etc
1346 init_symbols();
1347 init_include_path();
1349 args = argv;
1350 for (;;) {
1351 char *arg = *++args;
1352 if (!arg)
1353 break;
1355 if (arg[0] == '-' && arg[1]) {
1356 args = handle_switch(arg+1, args);
1357 continue;
1359 add_ptr_list_notag(filelist, arg);
1361 handle_switch_W_finalize();
1362 handle_switch_v_finalize();
1364 handle_arch_finalize();
1366 list = NULL;
1367 if (!ptr_list_empty(filelist)) {
1368 // Initialize type system
1369 init_ctype();
1370 handle_funsigned_char();
1372 create_builtin_stream();
1373 predefined_macros();
1374 if (!preprocess_only)
1375 declare_builtin_functions();
1377 list = sparse_initial();
1380 * Protect the initial token allocations, since
1381 * they need to survive all the others
1383 protect_token_alloc();
1386 * Evaluate the complete symbol list
1387 * Note: This is not needed for normal cases.
1388 * These symbols should only be predefined defines and
1389 * declaratons which will be evaluated later, when needed.
1390 * This is also the case when a file is directly included via
1391 * '-include <file>' on the command line *AND* the file only
1392 * contains defines, declarations and inline definitions.
1393 * However, in the rare cases where the given file should
1394 * contain some definitions, these will never be evaluated
1395 * and thus won't be able to be linearized correctly.
1396 * Hence the evaluate_symbol_list() here under.
1398 evaluate_symbol_list(list);
1399 return list;
1402 struct symbol_list * sparse_keep_tokens(char *filename)
1404 struct symbol_list *res;
1406 /* Clear previous symbol list */
1407 translation_unit_used_list = NULL;
1409 new_file_scope();
1410 res = sparse_file(filename);
1412 /* And return it */
1413 return res;
1417 struct symbol_list * __sparse(char *filename)
1419 struct symbol_list *res;
1421 res = sparse_keep_tokens(filename);
1423 /* Drop the tokens for this file after parsing */
1424 clear_token_alloc();
1426 /* And return it */
1427 return res;
1430 struct symbol_list * sparse(char *filename)
1432 struct symbol_list *res = __sparse(filename);
1434 if (has_error & ERROR_CURR_PHASE)
1435 has_error = ERROR_PREV_PHASE;
1436 /* Evaluate the complete symbol list */
1437 evaluate_symbol_list(res);
1439 return res;